sisyphi 1.0.5 → 1.0.6

package/dist/daemon.js

@@ -1,7 +1,14 @@
 #!/usr/bin/env node
 import {
+  EXEC_ENV,
+  exec,
+  execEnv,
+  execSafe,
   loadConfig
-} from "./chunk-KQBSC5KY.js";
+} from "./chunk-LWWRGQWM.js";
+import {
+  shellQuote
+} from "./chunk-6G226ZK7.js";
 import {
   contextDir,
   cycleLogPath,
@@ -25,21 +32,21 @@ import {
   statePath,
   worktreeBaseDir,
   worktreeConfigPath
-} from "./chunk-YGBGKMTF.js";
+} from "./chunk-JXKUI4P6.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync7, writeFileSync as writeFileSync4, readFileSync as readFileSync6, mkdirSync as mkdirSync4, rmSync as rmSync4 } from "fs";
+import { unlinkSync, existsSync as existsSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync6, mkdirSync as mkdirSync4, rmSync as rmSync4 } from "fs";
 import { join as join5 } from "path";
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync6, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
 
 // src/daemon/state.ts
 import { randomUUID } from "crypto";
@@ -57,16 +64,16 @@ Agents save exploration findings, architectural notes, and reference material he
 var sessionLocks = /* @__PURE__ */ new Map();
 async function withSessionLock(sessionId, fn) {
   const prev = sessionLocks.get(sessionId) ?? Promise.resolve();
-  let resolve4;
+  let resolve5;
   const next = new Promise((r) => {
-    resolve4 = r;
+    resolve5 = r;
   });
   sessionLocks.set(sessionId, next);
   await prev;
   try {
     return fn();
   } finally {
-    resolve4();
+    resolve5();
   }
 }
 function atomicWrite(filePath, data) {
@@ -293,8 +300,35 @@ function deleteSnapshotsAfter(cwd, sessionId, afterCycle) {
 }
 
 // src/daemon/orchestrator.ts
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { resolve, join as join3 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { execSync } from "child_process";
+import { resolve as resolve2, join as join3 } from "path";
+
+// src/daemon/spawn-helpers.ts
+import { writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+function resolveCliBin() {
+  return resolve(import.meta.dirname, "cli.js");
+}
+function resolveNpmBinDir() {
+  return resolve(import.meta.dirname, "../../.bin");
+}
+function resolveBannerCmd() {
+  const bannerPath = resolve(import.meta.dirname, "../templates/banner.txt");
+  return existsSync2(bannerPath) ? `cat '${bannerPath}'` : null;
+}
+function buildEnvExports(statements) {
+  return statements.join(" && ");
+}
+function buildNotifyCmd(paneId) {
+  const cliBin = resolveCliBin();
+  return `node "${cliBin}" notify pane-exited --pane-id ${paneId}`;
+}
+function writeRunScript(dir, name, lines) {
+  const scriptPath = `${dir}/${name}.sh`;
+  writeFileSync2(scriptPath, lines.join("\n"), { mode: 493 });
+  return scriptPath;
+}
 
 // src/daemon/colors.ts
 var ORCHESTRATOR_COLOR = "yellow";
@@ -318,7 +352,7 @@ function resetColors(sessionId) {
 }
 
 // src/daemon/frontmatter.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync as readdirSync2 } from "fs";
 import { homedir } from "os";
 import { join as join2, basename } from "path";
 function detectProvider(model) {
@@ -386,7 +420,7 @@ function resolveAgentTypePath(agentType, pluginDir, cwd) {
     searchPaths.push(join2(pluginDir, "agents", `${name}.md`));
   }
   for (const path of searchPaths) {
-    if (existsSync2(path)) return path;
+    if (existsSync3(path)) return path;
   }
   return null;
 }
@@ -452,21 +486,6 @@ function resolveAgentConfig(agentType, pluginDir, cwd) {
 }
 
 // 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 execSync(cmd, { encoding: "utf-8", env: EXEC_ENV, stdio: ["pipe", "pipe", "pipe"] }).trim();
-  } catch {
-    return null;
-  }
-}
 function createPane(windowTarget, cwd, position = "right") {
   const cwdFlag = cwd ? ` -c ${shellQuote(cwd)}` : "";
   const panes = listPanes(windowTarget);
@@ -525,9 +544,6 @@ function setPaneStyle(paneTarget, color) {
 function selectLayout(windowTarget, layout = "even-horizontal") {
   execSafe(`tmux select-layout -t "${windowTarget}" ${layout}`);
 }
-function shellQuote(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
 
 // src/daemon/pane-registry.ts
 var paneMap = /* @__PURE__ */ new Map();
@@ -573,16 +589,16 @@ function setOrchestratorPaneId(sessionId, paneId) {
 }
 function loadOrchestratorPrompt(cwd, mode) {
   const projectPath = projectOrchestratorPromptPath(cwd);
-  if (existsSync3(projectPath)) {
+  if (existsSync4(projectPath)) {
     return readFileSync3(projectPath, "utf-8");
   }
-  const basePath = resolve(import.meta.dirname, "../templates/orchestrator-base.md");
+  const basePath = resolve2(import.meta.dirname, "../templates/orchestrator-base.md");
   const base = readFileSync3(basePath, "utf-8");
   if (mode === "implementation") {
-    const implPath = resolve(import.meta.dirname, "../templates/orchestrator-impl.md");
+    const implPath = resolve2(import.meta.dirname, "../templates/orchestrator-impl.md");
     return base + "\n\n" + readFileSync3(implPath, "utf-8");
   }
-  const planningPath = resolve(import.meta.dirname, "../templates/orchestrator-planning.md");
+  const planningPath = resolve2(import.meta.dirname, "../templates/orchestrator-planning.md");
   return base + "\n\n" + readFileSync3(planningPath, "utf-8");
 }
 function formatStateForOrchestrator(session) {
@@ -601,7 +617,7 @@ ${session.context}
     }
   } else {
     let ctxFiles = [];
-    if (existsSync3(ctxDir)) {
+    if (existsSync4(ctxDir)) {
       ctxFiles = readdirSync3(ctxDir).filter((f) => f !== "CLAUDE.md");
     }
     if (ctxFiles.length > 0) {
@@ -667,10 +683,10 @@ ${agentBlocks}
 </last-cycle>
 `;
   }
-  const roadmapRef = existsSync3(roadmapFile) ? `@${roadmapFile}` : "(empty)";
+  const roadmapRef = existsSync4(roadmapFile) ? `@${roadmapFile}` : "(empty)";
   const worktreeAgents = session.agents.filter((a) => a.worktreePath);
   let worktreeSection = "";
-  if (worktreeAgents.length > 0 || existsSync3(worktreeConfigPath(session.cwd))) {
+  if (worktreeAgents.length > 0 || existsSync4(worktreeConfigPath(session.cwd))) {
     let wtLines = "";
     if (worktreeAgents.length > 0) {
       wtLines = "\n" + worktreeAgents.map((a) => {
@@ -686,7 +702,7 @@ ${agentBlocks}
         return `- ${a.id}: ${status} (branch ${a.branchName})`;
       }).join("\n");
     }
-    const worktreeHint = existsSync3(worktreeConfigPath(session.cwd)) ? "Worktree config active (`.sisyphus/worktree.json`). Use `--worktree` flag with `sisyphus spawn` to isolate agents in their own worktrees. Recommended for feature work, especially with potential file overlap." : "No worktree configuration found. If this session involves parallel work where agents may edit overlapping files, use the `git-management` skill to set up `.sisyphus/worktree.json` and enable worktree isolation.";
+    const worktreeHint = existsSync4(worktreeConfigPath(session.cwd)) ? "Worktree config active (`.sisyphus/worktree.json`). Use `--worktree` flag with `sisyphus spawn` to isolate agents in their own worktrees. Recommended for feature work, especially with potential file overlap." : "No worktree configuration found. If this session involves parallel work where agents may edit overlapping files, use the `git-management` skill to set up `.sisyphus/worktree.json` and enable worktree isolation.";
     worktreeSection = `
 
 ## Git Worktrees
@@ -694,7 +710,7 @@ ${agentBlocks}
 ${worktreeHint}${wtLines}`;
   }
   const goalFile = goalPath(session.cwd, session.id);
-  const goalContent = existsSync3(goalFile) ? readFileSync3(goalFile, "utf-8").trim() : session.task;
+  const goalContent = existsSync4(goalFile) ? readFileSync3(goalFile, "utf-8").trim() : session.task;
   return `## Goal
 
 ${goalContent}
@@ -709,12 +725,17 @@ ${roadmapRef}
 ${worktreeSection}`;
 }
 async function spawnOrchestrator(sessionId, cwd, windowId, message) {
+  try {
+    execSync("which claude", { stdio: "pipe", env: EXEC_ENV });
+  } catch {
+    throw new Error("Claude CLI not found on PATH. Run `sisyphus doctor` to diagnose.");
+  }
   const session = getSession(cwd, sessionId);
   const lastCycle = [...session.orchestratorCycles].reverse().find((c) => c.completedAt);
   const mode = lastCycle?.mode ?? "planning";
   const basePrompt = loadOrchestratorPrompt(cwd, mode);
   const formattedState = formatStateForOrchestrator(session);
-  const agentPluginPath = resolve(import.meta.dirname, "../templates/agent-plugin");
+  const agentPluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
   const agentTypes = discoverAgentTypes(agentPluginPath, session.cwd);
   agentTypes.push(
     { qualifiedName: "Explore", source: "bundled", model: "haiku", description: "Fast codebase exploration \u2014 find files, search code, answer questions about architecture. Use for research and context gathering." }
@@ -727,16 +748,15 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   const systemPrompt = basePrompt.replace("{{AGENT_TYPES}}", agentTypeLines);
   const cycleNum = session.orchestratorCycles.length + 1;
   const promptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-system-${cycleNum}.md`;
-  writeFileSync2(promptFilePath, systemPrompt, "utf-8");
+  writeFileSync3(promptFilePath, systemPrompt, "utf-8");
   sessionWindowMap.set(sessionId, windowId);
-  const cliBin = resolve(import.meta.dirname, "cli.js");
-  const npmBinDir = resolve(import.meta.dirname, "../../.bin");
-  const envExports = [
+  const npmBinDir = resolveNpmBinDir();
+  const envExports = buildEnvExports([
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
     `export SISYPHUS_AGENT_ID='orchestrator'`,
     `export SISYPHUS_CWD='${cwd}'`,
     `export PATH="${npmBinDir}:$PATH"`
-  ].join(" && ");
+  ]);
   let userPrompt = formattedState;
   if (message) {
     userPrompt += `
@@ -754,12 +774,12 @@ The user resumed this session with new instructions: ${message}`;
 ${continuationText}`;
   }
   const userPromptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
-  writeFileSync2(userPromptFilePath, userPrompt, "utf-8");
+  writeFileSync3(userPromptFilePath, userPrompt, "utf-8");
   if (session.messages && session.messages.length > 0) {
     await drainMessages(cwd, sessionId, session.messages.length);
   }
-  const pluginPath = resolve(import.meta.dirname, "../templates/orchestrator-plugin");
-  const settingsPath = resolve(import.meta.dirname, "../templates/orchestrator-settings.json");
+  const pluginPath = resolve2(import.meta.dirname, "../templates/orchestrator-plugin");
+  const settingsPath = resolve2(import.meta.dirname, "../templates/orchestrator-settings.json");
   const config = loadConfig(cwd);
   const effort = config.orchestratorEffort ?? "high";
   const claudeCmd = `claude --dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --settings "${settingsPath}" --plugin-dir "${pluginPath}" --name "sisyphus:orch-${sessionId.slice(0, 8)}-cycle-${cycleNum}" --system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
@@ -768,18 +788,15 @@ ${continuationText}`;
   registerPane(paneId, sessionId, "orchestrator");
   setPaneTitle(paneId, `Sisyphus`);
   setPaneStyle(paneId, ORCHESTRATOR_COLOR);
-  const bannerPath = resolve(import.meta.dirname, "../templates/banner.txt");
-  const bannerCmd = existsSync3(bannerPath) ? `cat '${bannerPath}'` : "";
-  const notifyCmd = `node "${cliBin}" notify pane-exited --pane-id ${paneId}`;
-  const scriptLines = [
+  const bannerCmd = resolveBannerCmd();
+  const notifyCmd = buildNotifyCmd(paneId);
+  const scriptPath = writeRunScript(promptsDir(cwd, sessionId), `orchestrator-run-${cycleNum}`, [
     "#!/usr/bin/env bash",
     ...bannerCmd ? [bannerCmd] : [],
     envExports,
-    `${claudeCmd}`,
+    claudeCmd,
     notifyCmd
-  ];
-  const scriptPath = `${promptsDir(cwd, sessionId)}/orchestrator-run-${cycleNum}.sh`;
-  writeFileSync2(scriptPath, scriptLines.join("\n"), { mode: 493 });
+  ]);
   sendKeys(paneId, `bash '${scriptPath}'`);
   await addOrchestratorCycle(cwd, sessionId, {
     cycle: cycleNum,
@@ -823,30 +840,13 @@ function cleanupSessionMaps(sessionId) {
 }
 
 // src/daemon/agent.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, copyFileSync as copyFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync5, existsSync as existsSync5 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, copyFileSync as copyFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync5 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { resolve as resolve3 } from "path";
 
 // src/daemon/worktree.ts
-import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
-import { dirname as dirname3, join as join4 } from "path";
-var EXEC_ENV2 = {
-  ...process.env,
-  PATH: `/opt/homebrew/bin:/usr/local/bin:${process.env["PATH"] ?? "/usr/bin:/bin"}`
-};
-function exec2(cmd, cwd) {
-  return execSync2(cmd, { encoding: "utf-8", env: EXEC_ENV2, cwd }).trim();
-}
-function execSafe2(cmd, cwd) {
-  try {
-    return exec2(cmd, cwd);
-  } catch {
-    return null;
-  }
-}
-function shellQuote2(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 function loadWorktreeConfig(cwd) {
   try {
     const content = readFileSync4(worktreeConfigPath(cwd), "utf-8");
@@ -858,52 +858,52 @@ function loadWorktreeConfig(cwd) {
 function createWorktreeShell(cwd, sessionId, agentId) {
   const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
   const worktreePath = join4(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
-  mkdirSync2(dirname3(worktreePath), { recursive: true });
-  execSafe2(`git -C ${shellQuote2(cwd)} worktree prune`);
-  if (existsSync4(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)}`);
+  mkdirSync2(dirname2(worktreePath), { recursive: true });
+  execSafe(`git -C ${shellQuote(cwd)} worktree prune`);
+  if (existsSync5(worktreePath)) {
+    execSafe(`git -C ${shellQuote(cwd)} worktree remove --force ${shellQuote(worktreePath)}`);
+  }
+  execSafe(`git -C ${shellQuote(cwd)} branch -D ${shellQuote(branchName)}`);
+  exec(`git -C ${shellQuote(cwd)} branch ${shellQuote(branchName)} HEAD`);
+  exec(`git -C ${shellQuote(cwd)} worktree add ${shellQuote(worktreePath)} ${shellQuote(branchName)}`);
   return { worktreePath, branchName };
 }
 function bootstrapWorktree(cwd, worktreePath, config) {
   if (config.copy) {
     for (const entry of config.copy) {
       const dest = join4(worktreePath, entry);
-      mkdirSync2(dirname3(dest), { recursive: true });
-      execSafe2(`cp -r ${shellQuote2(join4(cwd, entry))} ${shellQuote2(dest)}`);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      execSafe(`cp -r ${shellQuote(join4(cwd, entry))} ${shellQuote(dest)}`);
     }
   }
   if (config.clone) {
     for (const entry of config.clone) {
       const dest = join4(worktreePath, entry);
-      mkdirSync2(dirname3(dest), { recursive: true });
-      const src = shellQuote2(join4(cwd, entry));
-      const dstQ = shellQuote2(dest);
-      if (execSafe2(`cp -Rc ${src} ${dstQ}`) === null) {
-        execSafe2(`cp -r ${src} ${dstQ}`);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      const src = shellQuote(join4(cwd, entry));
+      const dstQ = shellQuote(dest);
+      if (execSafe(`cp -Rc ${src} ${dstQ}`) === null) {
+        execSafe(`cp -r ${src} ${dstQ}`);
       }
     }
   }
   if (config.symlink) {
     for (const entry of config.symlink) {
       const dest = join4(worktreePath, entry);
-      mkdirSync2(dirname3(dest), { recursive: true });
-      execSafe2(`ln -s ${shellQuote2(join4(cwd, entry))} ${shellQuote2(dest)}`);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      execSafe(`ln -s ${shellQuote(join4(cwd, entry))} ${shellQuote(dest)}`);
     }
   }
   if (config.init) {
     try {
-      exec2(config.init, worktreePath);
+      exec(config.init, worktreePath);
     } catch (err) {
       console.error(`[sisyphus] worktree init command failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
 function resolveWorktreeBranch(cwd, worktreePath) {
-  const output = execSafe2(`git -C ${shellQuote2(cwd)} worktree list --porcelain`);
+  const output = execSafe(`git -C ${shellQuote(cwd)} worktree list --porcelain`);
   if (!output) return null;
   const lines = output.split("\n");
   for (let i = 0; i < lines.length; i++) {
@@ -925,30 +925,30 @@ 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'`);
+  execSafe(`git -C ${shellQuote(cwd)} add .sisyphus`);
+  execSafe(`git -C ${shellQuote(cwd)} commit -m 'sisyphus: snapshot session state before merge'`);
   for (const agent of pending) {
     const branch = resolveWorktreeBranch(cwd, agent.worktreePath);
     if (!branch) {
       results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
-      execSafe2(`git -C ${shellQuote2(cwd)} worktree remove ${shellQuote2(agent.worktreePath)} --force`);
+      execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(agent.worktreePath)} --force`);
       continue;
     }
-    const aheadLog = execSafe2(`git -C ${shellQuote2(cwd)} log HEAD..${shellQuote2(branch)} --oneline`);
+    const aheadLog = execSafe(`git -C ${shellQuote(cwd)} log HEAD..${shellQuote(branch)} --oneline`);
     if (!aheadLog) {
       results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
       cleanupWorktree(cwd, agent.worktreePath, branch);
       continue;
     }
     const mergeMsg = `sisyphus: merge ${agent.id} (${agent.name})`;
-    const mergeCmd = `git -C ${shellQuote2(cwd)} merge --no-ff ${shellQuote2(branch)} -m ${shellQuote2(mergeMsg)}`;
+    const mergeCmd = `git -C ${shellQuote(cwd)} merge --no-ff ${shellQuote(branch)} -m ${shellQuote(mergeMsg)}`;
     try {
-      exec2(mergeCmd);
-      execSafe2(`git -C ${shellQuote2(cwd)} worktree remove ${shellQuote2(agent.worktreePath)}`);
-      execSafe2(`git -C ${shellQuote2(cwd)} branch -d ${shellQuote2(branch)}`);
+      exec(mergeCmd);
+      execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(agent.worktreePath)}`);
+      execSafe(`git -C ${shellQuote(cwd)} branch -d ${shellQuote(branch)}`);
       results.push({ agentId: agent.id, name: agent.name, status: "merged" });
     } catch (err) {
-      execSafe2(`git -C ${shellQuote2(cwd)} merge --abort`);
+      execSafe(`git -C ${shellQuote(cwd)} merge --abort`);
       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() : "";
@@ -959,9 +959,9 @@ function mergeWorktrees(cwd, agents) {
   return results;
 }
 function cleanupWorktree(cwd, worktreePath, branchName) {
-  execSafe2(`git -C ${shellQuote2(cwd)} worktree remove ${shellQuote2(worktreePath)} --force`);
-  execSafe2(`git -C ${shellQuote2(cwd)} branch -D ${shellQuote2(branchName)}`);
-  const baseDir = dirname3(worktreePath);
+  execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(worktreePath)} --force`);
+  execSafe(`git -C ${shellQuote(cwd)} branch -D ${shellQuote(branchName)}`);
+  const baseDir = dirname2(worktreePath);
   try {
     const entries = readdirSync4(baseDir);
     if (entries.length === 0) {
@@ -1023,7 +1023,7 @@ function clearAgentCounter(sessionId) {
   agentCounters.delete(sessionId);
 }
 function renderAgentSuffix(sessionId, instruction, worktreeContext) {
-  const templatePath = resolve2(import.meta.dirname, "../templates/agent-suffix.md");
+  const templatePath = resolve3(import.meta.dirname, "../templates/agent-suffix.md");
   let template;
   try {
     template = readFileSync5(templatePath, "utf-8");
@@ -1047,7 +1047,7 @@ function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
   mkdirSync3(`${base}/.claude-plugin`, { recursive: true });
   mkdirSync3(`${base}/agents`, { recursive: true });
   mkdirSync3(`${base}/hooks`, { recursive: true });
-  writeFileSync3(
+  writeFileSync4(
     `${base}/.claude-plugin/plugin.json`,
     JSON.stringify({ name: `sisyphus-agent-${agentId}`, version: "1.0.0" }),
     "utf-8"
@@ -1056,34 +1056,14 @@ function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
     const shortName = agentType.replace(/^sisyphus:/, "");
     copyFileSync2(agentConfig.filePath, `${base}/agents/${shortName}.md`);
   }
-  const srcHooks = resolve2(import.meta.dirname, "../templates/agent-plugin/hooks");
+  const srcHooks = resolve3(import.meta.dirname, "../templates/agent-plugin/hooks");
   for (const f of ["hooks.json", "require-submit.sh", "intercept-send-message.sh"]) {
     copyFileSync2(`${srcHooks}/${f}`, `${base}/hooks/${f}`);
   }
   return base;
 }
-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 bundledPluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
-  const agentConfig = resolveAgentConfig(agentType, bundledPluginPath, cwd);
-  const provider = detectProvider(agentConfig?.frontmatter.model);
-  const color = (agentConfig?.frontmatter.color ? normalizeTmuxColor(agentConfig.frontmatter.color) : null) ?? getNextColor(sessionId);
-  let paneCwd = cwd;
-  let worktreePath;
-  let branchName;
-  let worktreeContext;
-  if (opts.worktree) {
-    const wt = createWorktreeShell(cwd, sessionId, agentId);
-    worktreePath = wt.worktreePath;
-    branchName = wt.branchName;
-    paneCwd = worktreePath;
-    const session = getSession(cwd, sessionId);
-    const portOffset = countWorktreeAgents(session.agents) + 1;
-    worktreeContext = { offset: portOffset, total: portOffset, branchName };
-  }
+function setupAgentPane(opts) {
+  const { sessionId, cwd, agentId, agentType, name, instruction, windowId, color, provider, agentConfig, worktreeContext, paneCwd } = opts;
   const paneId = createPane(windowId, paneCwd);
   registerPane(paneId, sessionId, "agent", agentId);
   const shortType = agentType && agentType !== "worker" ? agentType.replace(/^sisyphus:/, "") : "";
@@ -1092,50 +1072,88 @@ async function spawnAgent(opts) {
   setPaneStyle(paneId, color);
   const suffix = renderAgentSuffix(sessionId, instruction, worktreeContext);
   const suffixFilePath = `${promptsDir(cwd, sessionId)}/${agentId}-system.md`;
-  writeFileSync3(suffixFilePath, suffix, "utf-8");
-  const bannerPath = resolve2(import.meta.dirname, "../templates/banner.txt");
-  const bannerCmd = existsSync5(bannerPath) ? `cat '${bannerPath}' &&` : "";
-  const cliBin = resolve2(import.meta.dirname, "cli.js");
-  const npmBinDir = resolve2(import.meta.dirname, "../../.bin");
-  const envExports = [
+  writeFileSync4(suffixFilePath, suffix, "utf-8");
+  const bannerCmd = resolveBannerCmd();
+  const npmBinDir = resolveNpmBinDir();
+  const envExports = buildEnvExports([
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
     `export SISYPHUS_AGENT_ID='${agentId}'`,
     `export SISYPHUS_CWD='${cwd}'`,
     ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : [],
     `export PATH="${npmBinDir}:$PATH"`
-  ].join(" && ");
-  const notifyCmd = `node "${cliBin}" notify pane-exited --pane-id ${paneId}`;
+  ]);
+  const notifyCmd = buildNotifyCmd(paneId);
   let mainCmd;
   if (provider === "openai") {
     const codexPromptPath = `${promptsDir(cwd, sessionId)}/${agentId}-codex-prompt.md`;
     const parts = [];
-    if (agentConfig?.body) {
-      parts.push(agentConfig.body);
-    }
+    if (agentConfig?.body) parts.push(agentConfig.body);
     parts.push(suffix);
     parts.push(`## Task
 
 ${instruction}`);
-    writeFileSync3(codexPromptPath, parts.join("\n\n"), "utf-8");
+    writeFileSync4(codexPromptPath, parts.join("\n\n"), "utf-8");
     const model = agentConfig?.frontmatter.model ?? "codex-mini";
-    mainCmd = `codex -m ${shellQuote3(model)} --dangerously-bypass-approvals-and-sandbox "$(cat '${codexPromptPath}')"`;
+    mainCmd = `codex -m ${shellQuote(model)} --dangerously-bypass-approvals-and-sandbox "$(cat '${codexPromptPath}')"`;
   } else {
-    const agentFlag = agentType && agentType !== "worker" ? ` --agent ${shellQuote3(agentType)}` : "";
+    const agentFlag = agentType && agentType !== "worker" ? ` --agent ${shellQuote(agentType)}` : "";
     const config = loadConfig(cwd);
     const effort = agentConfig?.frontmatter.effort ?? config.agentEffort ?? "medium";
     const pluginPath = createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig);
-    mainCmd = `claude --dangerously-skip-permissions --effort ${effort} --plugin-dir "${pluginPath}"${agentFlag} --name ${shellQuote3(`sisyphus:${name}`)} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote3(instruction)}`;
+    mainCmd = `claude --dangerously-skip-permissions --effort ${effort} --plugin-dir "${pluginPath}"${agentFlag} --name ${shellQuote(`sisyphus:${name}`)} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote(instruction)}`;
   }
-  const scriptLines = [
+  const scriptPath = writeRunScript(promptsDir(cwd, sessionId), `${agentId}-run`, [
     "#!/usr/bin/env bash",
-    ...bannerCmd ? [bannerCmd.replace(/ &&$/, "")] : [],
+    ...bannerCmd ? [bannerCmd] : [],
     envExports,
     mainCmd,
     notifyCmd
-  ];
-  const scriptPath = `${promptsDir(cwd, sessionId)}/${agentId}-run.sh`;
-  writeFileSync3(scriptPath, scriptLines.join("\n"), { mode: 493 });
+  ]);
   const fullCmd = `bash '${scriptPath}'`;
+  return { paneId, fullCmd };
+}
+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 bundledPluginPath = resolve3(import.meta.dirname, "../templates/agent-plugin");
+  const agentConfig = resolveAgentConfig(agentType, bundledPluginPath, cwd);
+  const provider = detectProvider(agentConfig?.frontmatter.model);
+  const color = (agentConfig?.frontmatter.color ? normalizeTmuxColor(agentConfig.frontmatter.color) : null) ?? getNextColor(sessionId);
+  const cliToCheck = provider === "openai" ? "codex" : "claude";
+  try {
+    execSync2(`which ${cliToCheck}`, { stdio: "pipe", env: execEnv() });
+  } catch {
+    throw new Error(`${cliToCheck} CLI not found on PATH. Run \`sisyphus doctor\` to diagnose.`);
+  }
+  let paneCwd = cwd;
+  let worktreePath;
+  let branchName;
+  let worktreeContext;
+  if (opts.worktree) {
+    const wt = createWorktreeShell(cwd, sessionId, agentId);
+    worktreePath = wt.worktreePath;
+    branchName = wt.branchName;
+    paneCwd = worktreePath;
+    const session = getSession(cwd, sessionId);
+    const portOffset = countWorktreeAgents(session.agents) + 1;
+    worktreeContext = { offset: portOffset, total: portOffset, branchName };
+  }
+  const { paneId, fullCmd } = setupAgentPane({
+    sessionId,
+    cwd,
+    agentId,
+    agentType,
+    name,
+    instruction,
+    windowId,
+    color,
+    provider,
+    agentConfig,
+    worktreeContext,
+    paneCwd
+  });
   const agent = {
     id: agentId,
     name,
@@ -1187,7 +1205,7 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     });
   }
   const { instruction, agentType, name, color } = agent;
-  const bundledPluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
+  const bundledPluginPath = resolve3(import.meta.dirname, "../templates/agent-plugin");
   const agentConfig = resolveAgentConfig(agentType, bundledPluginPath, cwd);
   const provider = detectProvider(agentConfig?.frontmatter.model);
   let paneCwd = cwd;
@@ -1208,56 +1226,20 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     }
     unregisterAgentPane(sessionId, agentId);
   }
-  const paneId = createPane(windowId, paneCwd);
-  registerPane(paneId, sessionId, "agent", agentId);
-  const shortType = agentType && agentType !== "worker" ? agentType.replace(/^sisyphus:/, "") : "";
-  const paneLabel = shortType ? `${name}-${shortType}` : name;
-  setPaneTitle(paneId, `${paneLabel} (${agentId})`);
-  setPaneStyle(paneId, color);
-  const suffix = renderAgentSuffix(sessionId, instruction, worktreeContext);
-  const suffixFilePath = `${promptsDir(cwd, sessionId)}/${agentId}-system.md`;
-  writeFileSync3(suffixFilePath, suffix, "utf-8");
-  const bannerPath = resolve2(import.meta.dirname, "../templates/banner.txt");
-  const bannerCmd = existsSync5(bannerPath) ? `cat '${bannerPath}' &&` : "";
-  const cliBin = resolve2(import.meta.dirname, "cli.js");
-  const npmBinDir = resolve2(import.meta.dirname, "../../.bin");
-  const envExports = [
-    `export SISYPHUS_SESSION_ID='${sessionId}'`,
-    `export SISYPHUS_AGENT_ID='${agentId}'`,
-    `export SISYPHUS_CWD='${cwd}'`,
-    ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : [],
-    `export PATH="${npmBinDir}:$PATH"`
-  ].join(" && ");
-  const notifyCmd = `node "${cliBin}" notify pane-exited --pane-id ${paneId}`;
-  let mainCmd;
-  if (provider === "openai") {
-    const codexPromptPath = `${promptsDir(cwd, sessionId)}/${agentId}-codex-prompt.md`;
-    const parts = [];
-    if (agentConfig?.body) parts.push(agentConfig.body);
-    parts.push(suffix);
-    parts.push(`## Task
-
-${instruction}`);
-    writeFileSync3(codexPromptPath, parts.join("\n\n"), "utf-8");
-    const model = agentConfig?.frontmatter.model ?? "codex-mini";
-    mainCmd = `codex -m ${shellQuote3(model)} --dangerously-bypass-approvals-and-sandbox "$(cat '${codexPromptPath}')"`;
-  } else {
-    const agentFlag = agentType && agentType !== "worker" ? ` --agent ${shellQuote3(agentType)}` : "";
-    const config = loadConfig(cwd);
-    const effort = agentConfig?.frontmatter.effort ?? config.agentEffort ?? "medium";
-    const pluginPath = createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig);
-    mainCmd = `claude --dangerously-skip-permissions --effort ${effort} --plugin-dir "${pluginPath}"${agentFlag} --name ${shellQuote3(`sisyphus:${name}`)} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote3(instruction)}`;
-  }
-  const scriptLines = [
-    "#!/usr/bin/env bash",
-    ...bannerCmd ? [bannerCmd.replace(/ &&$/, "")] : [],
-    envExports,
-    mainCmd,
-    notifyCmd
-  ];
-  const scriptPath = `${promptsDir(cwd, sessionId)}/${agentId}-run.sh`;
-  writeFileSync3(scriptPath, scriptLines.join("\n"), { mode: 493 });
-  const fullCmd = `bash '${scriptPath}'`;
+  const { paneId, fullCmd } = setupAgentPane({
+    sessionId,
+    cwd,
+    agentId,
+    agentType,
+    name,
+    instruction,
+    windowId,
+    color,
+    provider,
+    agentConfig,
+    worktreeContext,
+    paneCwd
+  });
   await updateAgent(cwd, sessionId, agentId, {
     status: "running",
     paneId,
@@ -1282,7 +1264,7 @@ async function handleAgentReport(cwd, sessionId, agentId, content) {
   mkdirSync3(dir, { recursive: true });
   const num = nextReportNumber(cwd, sessionId, agentId);
   const filePath = reportFilePath(cwd, sessionId, agentId, num);
-  writeFileSync3(filePath, content, "utf-8");
+  writeFileSync4(filePath, content, "utf-8");
   const entry = {
     type: "update",
     filePath,
@@ -1301,7 +1283,7 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const dir = reportsDir(cwd, sessionId);
   mkdirSync3(dir, { recursive: true });
   const filePath = reportFilePath(cwd, sessionId, agentId, "final");
-  writeFileSync3(filePath, report, "utf-8");
+  writeFileSync4(filePath, report, "utf-8");
   const entry = {
     type: "final",
     filePath,
@@ -1344,9 +1326,6 @@ function allAgentsDone(session) {
   const running = session.agents.filter((a) => a.status === "running");
   return running.length === 0 && session.agents.length > 0;
 }
-function shellQuote3(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
 
 // src/daemon/pane-monitor.ts
 var monitorInterval = null;
@@ -1491,7 +1470,7 @@ var PRUNE_KEEP_DAYS = 7;
 function pruneOldSessions(cwd) {
   try {
     const dir = sessionsDir(cwd);
-    if (!existsSync6(dir)) return;
+    if (!existsSync7(dir)) return;
     const entries = readdirSync6(dir, { withFileTypes: true });
     const candidates = [];
     for (const entry of entries) {
@@ -1573,7 +1552,7 @@ function getSessionStatus(cwd, sessionId) {
 }
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync6(dir)) return [];
+  if (!existsSync7(dir)) return [];
   const entries = readdirSync6(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
@@ -1853,10 +1832,7 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
 
 // src/daemon/server.ts
 var server = null;
-var sessionCwdMap = /* @__PURE__ */ new Map();
-var sessionMessageCounters = /* @__PURE__ */ new Map();
-var sessionTmuxMap = /* @__PURE__ */ new Map();
-var sessionWindowMap2 = /* @__PURE__ */ new Map();
+var sessionTrackingMap = /* @__PURE__ */ new Map();
 function registryPath() {
   return join5(globalDir(), "session-registry.json");
 }
@@ -1864,14 +1840,14 @@ function persistSessionRegistry() {
   const dir = globalDir();
   mkdirSync4(dir, { recursive: true });
   const registry = {};
-  for (const [id, cwd] of sessionCwdMap) {
-    registry[id] = cwd;
+  for (const [id, tracking] of sessionTrackingMap) {
+    registry[id] = tracking.cwd;
   }
-  writeFileSync4(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
+  writeFileSync5(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync7(p)) return {};
+  if (!existsSync8(p)) return {};
   try {
     return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
@@ -1879,65 +1855,81 @@ function loadSessionRegistry() {
   }
 }
 function registerSessionCwd(sessionId, cwd) {
-  sessionCwdMap.set(sessionId, cwd);
+  const existing = sessionTrackingMap.get(sessionId);
+  if (existing) {
+    existing.cwd = cwd;
+  } else {
+    sessionTrackingMap.set(sessionId, { cwd, messageCounter: 0 });
+  }
   persistSessionRegistry();
 }
 function registerSessionTmux(sessionId, tmuxSession, windowId) {
-  sessionTmuxMap.set(sessionId, tmuxSession);
-  sessionWindowMap2.set(sessionId, windowId);
+  const existing = sessionTrackingMap.get(sessionId);
+  if (existing) {
+    existing.tmuxSession = tmuxSession;
+    existing.windowId = windowId;
+  } else {
+    sessionTrackingMap.set(sessionId, { cwd: "", tmuxSession, windowId, messageCounter: 0 });
+  }
+}
+function unknownSessionError(sessionId) {
+  return { ok: false, error: `Unknown session: ${sessionId}. Run \`sisyphus list --all\` to see available sessions.` };
 }
 async function handleRequest(req) {
   try {
     switch (req.type) {
       case "start": {
         const session = await startSession(req.task, req.cwd, req.context, req.name);
-        registerSessionCwd(session.id, req.cwd);
-        if (session.tmuxSessionName) sessionTmuxMap.set(session.id, session.tmuxSessionName);
-        if (session.tmuxWindowId) sessionWindowMap2.set(session.id, session.tmuxWindowId);
+        sessionTrackingMap.set(session.id, {
+          cwd: req.cwd,
+          tmuxSession: session.tmuxSessionName,
+          windowId: session.tmuxWindowId,
+          messageCounter: 0
+        });
+        persistSessionRegistry();
         return { ok: true, data: { sessionId: session.id, tmuxSessionName: session.tmuxSessionName } };
       }
       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, req.worktree);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        const result = await handleSpawn(req.sessionId, tracking.cwd, req.agentType, req.name, req.instruction, req.worktree);
         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);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        if (!tracking.windowId) return { ok: false, error: `No tmux window found for session: ${req.sessionId}` };
+        await handleSubmit(tracking.cwd, req.sessionId, req.agentId, req.report, tracking.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);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleReport(tracking.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, req.nextPrompt, req.mode);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleYield(req.sessionId, tracking.cwd, req.nextPrompt, req.mode);
         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);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleComplete(req.sessionId, tracking.cwd, req.report);
         return { ok: true };
       }
       case "continue": {
-        const cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
-        await handleContinue(req.sessionId, cwd);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleContinue(req.sessionId, tracking.cwd);
         return { ok: true };
       }
       case "status": {
         if (req.sessionId) {
-          const cwd = sessionCwdMap.get(req.sessionId) ?? req.cwd;
-          if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
+          const cwd = sessionTrackingMap.get(req.sessionId)?.cwd ?? req.cwd;
+          if (!cwd) return unknownSessionError(req.sessionId);
           const session = getSessionStatus(cwd, req.sessionId);
           return { ok: true, data: { session } };
         }
@@ -1947,21 +1939,21 @@ async function handleRequest(req) {
         const allSessions = [];
         if (req.all) {
           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, cwd })));
+          for (const tracking of sessionTrackingMap.values()) {
+            if (seenCwds.has(tracking.cwd)) continue;
+            seenCwds.add(tracking.cwd);
+            const sessions = listSessions(tracking.cwd);
+            allSessions.push(...sessions.map((s) => ({ ...s, cwd: tracking.cwd })));
           }
         } else {
           const sessions = listSessions(req.cwd);
           allSessions.push(...sessions.map((s) => ({ ...s, cwd: req.cwd })));
           let totalCount = allSessions.length;
           const seenCwds = /* @__PURE__ */ new Set([req.cwd]);
-          for (const cwd of sessionCwdMap.values()) {
-            if (seenCwds.has(cwd)) continue;
-            seenCwds.add(cwd);
-            totalCount += listSessions(cwd).length;
+          for (const tracking of sessionTrackingMap.values()) {
+            if (seenCwds.has(tracking.cwd)) continue;
+            seenCwds.add(tracking.cwd);
+            totalCount += listSessions(tracking.cwd).length;
           }
           if (totalCount > allSessions.length) {
             return { ok: true, data: { sessions: allSessions, totalCount, filtered: true } };
@@ -1970,114 +1962,109 @@ async function handleRequest(req) {
         return { ok: true, data: { sessions: allSessions } };
       }
       case "resume": {
-        let cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) {
+        let tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync7(stateFile)) {
-            cwd = req.cwd;
-            registerSessionCwd(req.sessionId, cwd);
+          if (existsSync8(stateFile)) {
+            tracking = { cwd: req.cwd, messageCounter: 0 };
+            sessionTrackingMap.set(req.sessionId, tracking);
+            persistSessionRegistry();
           } else {
-            return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json found at ${stateFile}` };
+            return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json found at ${stateFile}. Run \`sisyphus list --all\` to see available sessions.` };
           }
         }
-        const session = await resumeSession(req.sessionId, cwd, req.message);
-        if (session.tmuxSessionName) sessionTmuxMap.set(req.sessionId, session.tmuxSessionName);
-        if (session.tmuxWindowId) sessionWindowMap2.set(req.sessionId, session.tmuxWindowId);
+        const session = await resumeSession(req.sessionId, tracking.cwd, req.message);
+        if (session.tmuxSessionName) tracking.tmuxSession = session.tmuxSessionName;
+        if (session.tmuxWindowId) tracking.windowId = session.tmuxWindowId;
         return { ok: true, data: { sessionId: session.id, status: session.status, tmuxSessionName: session.tmuxSessionName } };
       }
       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);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleRegisterClaudeSession(tracking.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);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        const killedAgents = await handleKill(req.sessionId, tracking.cwd);
+        sessionTrackingMap.delete(req.sessionId);
         persistSessionRegistry();
         return { ok: true, data: { killedAgents, sessionId: req.sessionId } };
       }
       case "kill-agent": {
-        const cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
-        await handleKillAgent(req.sessionId, cwd, req.agentId);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleKillAgent(req.sessionId, tracking.cwd, req.agentId);
         return { ok: true, data: { agentId: req.agentId } };
       }
       case "restart-agent": {
-        const cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
-        await handleRestartAgent(req.sessionId, cwd, req.agentId);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await handleRestartAgent(req.sessionId, tracking.cwd, req.agentId);
         return { ok: true, data: { agentId: req.agentId } };
       }
       case "rollback": {
-        let cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) {
+        let tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync7(stateFile)) {
-            cwd = req.cwd;
-            registerSessionCwd(req.sessionId, cwd);
+          if (existsSync8(stateFile)) {
+            registerSessionCwd(req.sessionId, req.cwd);
+            tracking = sessionTrackingMap.get(req.sessionId);
           } else {
-            return { ok: false, error: `Unknown session: ${req.sessionId}` };
+            return unknownSessionError(req.sessionId);
           }
         }
-        const result = await handleRollback(req.sessionId, cwd, req.toCycle);
+        const result = await handleRollback(req.sessionId, tracking.cwd, req.toCycle);
         return { ok: true, data: result };
       }
       case "delete": {
-        const activeCwd = sessionCwdMap.get(req.sessionId);
-        if (activeCwd) {
+        const activeTracking = sessionTrackingMap.get(req.sessionId);
+        if (activeTracking) {
           try {
-            await handleKill(req.sessionId, activeCwd);
+            await handleKill(req.sessionId, activeTracking.cwd);
           } catch {
           }
-          sessionCwdMap.delete(req.sessionId);
-          sessionTmuxMap.delete(req.sessionId);
-          sessionWindowMap2.delete(req.sessionId);
-          sessionMessageCounters.delete(req.sessionId);
+          sessionTrackingMap.delete(req.sessionId);
           persistSessionRegistry();
         }
-        const { sessionDir: sessionDir2 } = await import("./paths-FYYSBD27.js");
+        const { sessionDir: sessionDir2 } = await import("./paths-NUUALUVP.js");
         rmSync4(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
         return { ok: true };
       }
       case "pane-exited": {
         const entry = lookupPane(req.paneId);
         if (!entry) return { ok: true };
-        const cwd = sessionCwdMap.get(entry.sessionId);
-        if (!cwd) {
+        const tracking = sessionTrackingMap.get(entry.sessionId);
+        if (!tracking) {
           unregisterPane(req.paneId);
           return { ok: true };
         }
         unregisterPane(req.paneId);
-        await handlePaneExited(req.paneId, cwd, entry.sessionId, entry.role, entry.agentId);
+        await handlePaneExited(req.paneId, tracking.cwd, entry.sessionId, entry.role, entry.agentId);
         return { ok: true };
       }
       case "update-task": {
-        const cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
-        await updateTask(cwd, req.sessionId, req.task);
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await updateTask(tracking.cwd, req.sessionId, req.task);
         return { ok: true };
       }
       case "message": {
-        const cwd = sessionCwdMap.get(req.sessionId);
-        if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
-        const counter = (sessionMessageCounters.get(req.sessionId) ?? 0) + 1;
-        sessionMessageCounters.set(req.sessionId, counter);
-        const id = `msg-${String(counter).padStart(3, "0")}`;
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        tracking.messageCounter += 1;
+        const id = `msg-${String(tracking.messageCounter).padStart(3, "0")}`;
         const source = req.source ?? { type: "user" };
         const summary = req.content.length > 200 ? req.content.slice(0, 200) + "..." : req.content;
         let filePath;
         if (req.content.length > 200) {
-          const dir = messagesDir(cwd, req.sessionId);
+          const dir = messagesDir(tracking.cwd, req.sessionId);
           mkdirSync4(dir, { recursive: true });
           filePath = join5(dir, `${id}.md`);
-          writeFileSync4(filePath, req.content, "utf-8");
+          writeFileSync5(filePath, req.content, "utf-8");
         }
-        await appendMessage(cwd, req.sessionId, {
+        await appendMessage(tracking.cwd, req.sessionId, {
           id,
           source,
           content: req.content,
@@ -2096,9 +2083,9 @@ async function handleRequest(req) {
   }
 }
 function startServer() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const sock = socketPath();
-    if (existsSync7(sock)) {
+    if (existsSync8(sock)) {
       unlinkSync(sock);
     }
     server = createServer((conn) => {
@@ -2128,31 +2115,31 @@ function startServer() {
     server.on("error", reject);
     server.listen(sock, () => {
       console.log(`[sisyphus] Daemon listening on ${sock}`);
-      resolve4(server);
+      resolve5(server);
     });
   });
 }
 function stopServer() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     if (!server) {
-      resolve4();
+      resolve5();
       return;
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync7(sock)) {
+      if (existsSync8(sock)) {
         unlinkSync(sock);
       }
       server = null;
-      resolve4();
+      resolve5();
     });
   });
 }
 
 // src/daemon/updater.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2 } from "fs";
+import { resolve as resolve4 } from "path";
 import { get } from "https";
 function isNewer(latest, current) {
   const a = latest.split(".").map(Number);
@@ -2168,7 +2155,7 @@ function isNewer(latest, current) {
 function readPackageVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync7(resolve3(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync7(resolve4(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -2178,9 +2165,9 @@ function readPackageVersion() {
 }
 var currentVersion = readPackageVersion();
 function checkForUpdate() {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const timeout = setTimeout(() => {
-      resolve4(null);
+      resolve5(null);
     }, 5e3);
     const req = get("https://registry.npmjs.org/sisyphi/latest", (res) => {
       let data = "";
@@ -2192,24 +2179,24 @@ function checkForUpdate() {
         try {
           const { version: latest } = JSON.parse(data);
           if (latest && isNewer(latest, currentVersion)) {
-            resolve4({ current: currentVersion, latest });
+            resolve5({ current: currentVersion, latest });
           } else {
-            resolve4(null);
+            resolve5(null);
           }
         } catch {
-          resolve4(null);
+          resolve5(null);
         }
       });
     });
     req.on("error", () => {
       clearTimeout(timeout);
-      resolve4(null);
+      resolve5(null);
     });
   });
 }
 function applyUpdate(expectedVersion) {
   try {
-    const nodeDir = resolve3(process.execPath, "..");
+    const nodeDir = resolve4(process.execPath, "..");
     const env = { ...process.env, PATH: `${nodeDir}:${process.env.PATH ?? ""}` };
     execSync3("npm install -g sisyphi", { timeout: 15e3, stdio: "pipe", env });
     const result = execSync3("npm ls -g sisyphi --json --depth=0", {
@@ -2231,7 +2218,7 @@ function applyUpdate(expectedVersion) {
 }
 function markUpdating(version) {
   try {
-    writeFileSync5(daemonUpdatingPath(), version, "utf-8");
+    writeFileSync6(daemonUpdatingPath(), version, "utf-8");
   } catch {
   }
 }
@@ -2261,6 +2248,11 @@ async function checkAndApply() {
 }
 
 // src/daemon/index.ts
+var nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeVersion < 22) {
+  console.error(`[sisyphus] Node.js v22+ required (current: v${process.versions.node})`);
+  process.exit(1);
+}
 var ts = () => (/* @__PURE__ */ new Date()).toISOString();
 var origLog = console.log.bind(console);
 var origError = console.error.bind(console);
@@ -2292,7 +2284,7 @@ function acquirePidLock() {
     console.error(`[sisyphus] Daemon already running (pid ${pid}). Use 'sisyphusd restart' or 'sisyphusd stop' first.`);
     process.exit(0);
   }
-  writeFileSync6(daemonPidPath(), String(process.pid), "utf-8");
+  writeFileSync7(daemonPidPath(), String(process.pid), "utf-8");
 }
 function isLaunchdManaged() {
   try {
@@ -2351,7 +2343,7 @@ async function recoverSessions() {
   let recovered = 0;
   for (const [sessionId, cwd] of entries) {
     const stateFile = statePath(cwd, sessionId);
-    if (!existsSync8(stateFile)) {
+    if (!existsSync9(stateFile)) {
       continue;
     }
     try {