sisyphi 0.1.1 → 0.1.3

package/dist/daemon.js

@@ -4,18 +4,23 @@ import {
   daemonPidPath,
   globalConfigPath,
   globalDir,
+  logsPath,
+  planPath,
   projectConfigPath,
   projectOrchestratorPromptPath,
+  promptsDir,
   reportFilePath,
   reportsDir,
   sessionDir,
   sessionsDir,
   socketPath,
-  statePath
-} from "./chunk-T6Z5F4SP.js";
+  statePath,
+  worktreeBaseDir,
+  worktreeConfigPath
+} from "./chunk-N2BPQOO2.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync4 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync6 } from "fs";
 
 // src/shared/config.ts
 import { readFileSync } from "fs";
@@ -38,17 +43,33 @@ function loadConfig(cwd) {
 
 // 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";
+import { unlinkSync, existsSync as existsSync5, writeFileSync as writeFileSync4, readFileSync as readFileSync7, 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 existsSync2, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync4 } 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 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.
+---
+`;
+var LOGS_SEED = `---
+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.
+---
+`;
 var sessionLocks = /* @__PURE__ */ new Map();
 async function withSessionLock(sessionId, fn) {
   const prev = sessionLocks.get(sessionId) ?? Promise.resolve();
@@ -74,13 +95,15 @@ function createSession(id, task, cwd) {
   const dir = sessionDir(cwd, id);
   mkdirSync(dir, { recursive: true });
   mkdirSync(contextDir(cwd, id), { recursive: true });
+  mkdirSync(promptsDir(cwd, id), { recursive: true });
+  writeFileSync(planPath(cwd, id), PLAN_SEED, "utf-8");
+  writeFileSync(logsPath(cwd, id), LOGS_SEED, "utf-8");
   const session = {
     id,
     task,
     cwd,
     status: "active",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    tasks: [],
     agents: [],
     orchestratorCycles: []
   };
@@ -94,30 +117,6 @@ function getSession(cwd, sessionId) {
 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);
@@ -128,7 +127,7 @@ async function addAgent(cwd, sessionId, agent) {
 async function updateAgent(cwd, sessionId, agentId, updates) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
-    const agent = session.agents.find((a) => a.id === agentId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
     if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
     Object.assign(agent, updates);
     saveSession(session);
@@ -172,12 +171,20 @@ async function completeSession(cwd, sessionId, report) {
 async function appendAgentReport(cwd, sessionId, agentId, entry) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
-    const agent = session.agents.find((a) => a.id === agentId);
+    const agent = session.agents.slice().reverse().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 updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.tmuxSessionName = tmuxSessionName;
+    session.tmuxWindowId = tmuxWindowId;
+    saveSession(session);
+  });
+}
 async function completeOrchestratorCycle(cwd, sessionId, nextPrompt) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -191,9 +198,83 @@ async function completeOrchestratorCycle(cwd, sessionId, nextPrompt) {
 }
 
 // src/daemon/orchestrator.ts
-import { readFileSync as readFileSync3, existsSync, writeFileSync as writeFileSync2, readdirSync } from "fs";
+import { existsSync, readdirSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 
+// src/daemon/colors.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var ORCHESTRATOR_COLOR = "yellow";
+var AGENT_PALETTE = ["blue", "green", "magenta", "cyan", "red", "white"];
+var TMUX_COLOR_MAP = {
+  orange: "colour208",
+  teal: "colour6"
+};
+function normalizeTmuxColor(color) {
+  return TMUX_COLOR_MAP[color] ?? color;
+}
+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);
+}
+function extractFrontmatterColor(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const colorMatch = match[1].match(/^color:\s*(.+)$/m);
+  return colorMatch ? colorMatch[1].trim() : null;
+}
+function findPluginInstallPath(namespace) {
+  try {
+    const registryPath2 = join2(homedir(), ".claude", "plugins", "installed_plugins.json");
+    const registry = JSON.parse(readFileSync3(registryPath2, "utf-8"));
+    for (const key of Object.keys(registry)) {
+      if (key.startsWith(`${namespace}@`)) {
+        return registry[key].installPath ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveAgentTypeColor(agentType, pluginDir, cwd) {
+  if (!agentType) return null;
+  let namespace;
+  let name;
+  if (agentType.includes(":")) {
+    [namespace, name] = agentType.split(":", 2);
+  } else {
+    name = agentType;
+  }
+  const searchPaths = [];
+  if (namespace) {
+    searchPaths.push(join2(pluginDir, "agents", `${name}.md`));
+    const installPath = findPluginInstallPath(namespace);
+    if (installPath) {
+      searchPaths.push(join2(installPath, "agents", `${name}.md`));
+    }
+  } else {
+    searchPaths.push(join2(cwd, ".claude", "agents", `${name}.md`));
+    searchPaths.push(join2(homedir(), ".claude", "agents", `${name}.md`));
+    searchPaths.push(join2(pluginDir, "agents", `${name}.md`));
+  }
+  for (const path of searchPaths) {
+    try {
+      const content = readFileSync3(path, "utf-8");
+      const color = extractFrontmatterColor(content);
+      if (color) return normalizeTmuxColor(color);
+    } catch {
+    }
+  }
+  return null;
+}
+
 // src/daemon/tmux.ts
 import { execSync } from "child_process";
 var EXEC_ENV = {
@@ -216,8 +297,8 @@ function createPane(windowTarget, cwd) {
   execSafe(`tmux select-layout -t "${windowTarget}" even-horizontal`);
   return paneId;
 }
-function sendKeys(paneTarget, command) {
-  exec(`tmux send-keys -t "${paneTarget}" ${shellQuote(command)} Enter`);
+function sendKeys(paneTarget, command2) {
+  exec(`tmux send-keys -t "${paneTarget}" ${shellQuote(command2)} Enter`);
 }
 function killPane(paneTarget) {
   execSafe(`tmux kill-pane -t "${paneTarget}"`);
@@ -239,48 +320,43 @@ function setPaneTitle(paneTarget, title) {
 function setPaneStyle(paneTarget, color) {
   const fmt = `#[fg=${color},bold] #{pane_title} #[fg=${color}]#{pane_current_path} #[default]`;
   execSafe(`tmux set -p -t "${paneTarget}" pane-border-format ${shellQuote(fmt)}`);
-  execSafe(`tmux set -p -t "${paneTarget}" pane-border-style "fg=${color}"`);
-  execSafe(`tmux set -p -t "${paneTarget}" pane-active-border-style "fg=${color}"`);
+  execSafe(`tmux set -p -t "${paneTarget}" @pane_color "${color}"`);
+  execSafe(`tmux set -w -t "${paneTarget}" pane-border-style "fg=#{?#{@pane_color},#{@pane_color},default}"`);
+  execSafe(`tmux set -w -t "${paneTarget}" pane-active-border-style "fg=#{?#{@pane_color},#{@pane_color},default}"`);
+}
+function selectLayout(windowTarget, layout = "even-horizontal") {
+  execSafe(`tmux select-layout -t "${windowTarget}" ${layout}`);
 }
 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 setWindowId(sessionId, windowId) {
+  sessionWindowMap.set(sessionId, windowId);
+}
 function getOrchestratorPaneId(sessionId) {
   return sessionOrchestratorPane.get(sessionId);
 }
+function setOrchestratorPaneId(sessionId, paneId) {
+  sessionOrchestratorPane.set(sessionId, paneId);
+}
 function loadOrchestratorPrompt(cwd) {
   const projectPath = projectOrchestratorPromptPath(cwd);
   if (existsSync(projectPath)) {
-    return readFileSync3(projectPath, "utf-8");
+    return readFileSync4(projectPath, "utf-8");
   }
   const bundledPath = resolve(import.meta.dirname, "../templates/orchestrator.md");
-  return readFileSync3(bundledPath, "utf-8");
+  return readFileSync4(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 ctxDir = contextDir(session.cwd, session.id);
   let contextLines;
   if (existsSync(ctxDir)) {
@@ -289,6 +365,10 @@ function formatStateForOrchestrator(session) {
   } else {
     contextLines = "  (none)";
   }
+  const planFile = planPath(session.cwd, session.id);
+  const planRef = existsSync(planFile) ? `@${planFile}` : "(empty)";
+  const logsFile = logsPath(session.cwd, session.id);
+  const logsRef = existsSync(logsFile) ? `@${logsFile}` : "(empty)";
   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;
@@ -303,32 +383,54 @@ function formatStateForOrchestrator(session) {
     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,
-    "",
-    "## Context Files",
-    contextLines,
-    "",
-    "## Agents",
-    agentLines,
-    "",
-    "## Previous Cycles",
-    cycleLines,
-    "</state>"
-  ].join("\n");
+  const worktreeAgents = session.agents.filter((a) => a.worktreePath);
+  let worktreeSection = "";
+  if (worktreeAgents.length > 0) {
+    const wtLines = worktreeAgents.map((a) => {
+      if (a.mergeStatus === "conflict") {
+        return `- ${a.id}: conflict \u2014 ${a.mergeDetails ?? "unknown"}
+  Branch: ${a.branchName}
+  Worktree: ${a.worktreePath}`;
+      }
+      const status = a.mergeStatus ?? "pending";
+      return `- ${a.id}: ${status} (branch ${a.branchName})`;
+    }).join("\n");
+    worktreeSection = `
+
+## Worktrees
+${wtLines}`;
+  }
+  const worktreeHint = existsSync(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.";
+  return `<state>
+session: ${shortId} (cycle ${cycleNum})
+task: ${session.task}
+status: ${session.status}
+
+## Plan
+${planRef}
+
+## Logs
+${logsRef}
+
+## Agents
+${agentLines}${worktreeSection}
+
+## Previous Cycles
+${cycleLines}
+
+## Context Files
+${contextLines}
+
+## Git Worktrees
+${worktreeHint}
+</state>`;
 }
 async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   const session = getSession(cwd, sessionId);
   const basePrompt = loadOrchestratorPrompt(cwd);
   const formattedState = formatStateForOrchestrator(session);
   const cycleNum = session.orchestratorCycles.length + 1;
-  const promptFilePath = `${sessionDir(cwd, sessionId)}/orchestrator-prompt-${cycleNum}.md`;
+  const promptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-system-${cycleNum}.md`;
   writeFileSync2(promptFilePath, basePrompt, "utf-8");
   sessionWindowMap.set(sessionId, windowId);
   const envExports = [
@@ -350,17 +452,21 @@ ${storedPrompt}`;
     } else {
       userPrompt = `${formattedState}
 
-Review the current session state and execute the next cycle of work.`;
+Review the current session and delegate the next cycle of work.`;
     }
   }
-  const userPromptFilePath = `${sessionDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
+  const userPromptFilePath = `${promptsDir(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 pluginPath = resolve(import.meta.dirname, "../templates/orchestrator-plugin");
+  const settingsPath = resolve(import.meta.dirname, "../templates/orchestrator-settings.json");
+  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);
   setPaneTitle(paneId, `orchestrator (${sessionId.slice(0, 8)})`);
   setPaneStyle(paneId, ORCHESTRATOR_COLOR);
-  sendKeys(paneId, `${envExports} && ${claudeCmd}`);
+  const bannerPath = resolve(import.meta.dirname, "../templates/banner.txt");
+  const bannerCmd = existsSync(bannerPath) ? `cat '${bannerPath}' &&` : "";
+  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}`);
   await addOrchestratorCycle(cwd, sessionId, {
     cycle: cycleNum,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -381,6 +487,8 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
     killPane(paneId);
     sessionOrchestratorPane.delete(sessionId);
   }
+  const windowId = sessionWindowMap.get(sessionId);
+  if (windowId) selectLayout(windowId);
   await completeOrchestratorCycle(cwd, sessionId, nextPrompt);
   const session = getSession(cwd, sessionId);
   const runningAgents = session.agents.filter((a) => a.status === "running");
@@ -389,58 +497,238 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
   }
 }
 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}`);
 }
+function cleanupSessionMaps(sessionId) {
+  sessionOrchestratorPane.delete(sessionId);
+  sessionWindowMap.delete(sessionId);
+}
 
 // src/daemon/agent.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3, existsSync as existsSync3 } from "fs";
 import { resolve as resolve2 } from "path";
+
+// src/daemon/worktree.ts
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync5, readdirSync as readdirSync2, rmSync } from "fs";
+import { dirname as dirname2, join as join3 } 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, "'\\''")}'`;
+}
+function loadWorktreeConfig(cwd) {
+  try {
+    const content = readFileSync5(worktreeConfigPath(cwd), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function createWorktree(cwd, sessionId, agentId) {
+  const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
+  const worktreePath = join3(worktreeBaseDir(cwd), agentId);
+  mkdirSync2(dirname2(worktreePath), { recursive: true });
+  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) {
+  if (config.copy) {
+    for (const entry of config.copy) {
+      const dest = join3(worktreePath, entry);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      execSafe2(`cp -r ${shellQuote2(join3(cwd, entry))} ${shellQuote2(dest)}`);
+    }
+  }
+  if (config.clone) {
+    for (const entry of config.clone) {
+      const dest = join3(worktreePath, entry);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      const src = shellQuote2(join3(cwd, entry));
+      const dstQ = shellQuote2(dest);
+      if (execSafe2(`cp -Rc ${src} ${dstQ}`) === null) {
+        execSafe2(`cp -r ${src} ${dstQ}`);
+      }
+    }
+  }
+  if (config.symlink) {
+    for (const entry of config.symlink) {
+      const dest = join3(worktreePath, entry);
+      mkdirSync2(dirname2(dest), { recursive: true });
+      execSafe2(`ln -s ${shellQuote2(join3(cwd, entry))} ${shellQuote2(dest)}`);
+    }
+  }
+  if (config.init) {
+    try {
+      exec2(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`);
+  if (!output) return null;
+  const lines = output.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i] === `worktree ${worktreePath}`) {
+      for (let j = i + 1; j < lines.length; j++) {
+        const line = lines[j];
+        if (line === "") break;
+        if (line.startsWith("branch refs/heads/")) {
+          return line.slice("branch refs/heads/".length);
+        }
+      }
+      break;
+    }
+  }
+  return null;
+}
+function mergeWorktrees(cwd, agents) {
+  const pending = agents.filter(
+    (a) => a.worktreePath && a.mergeStatus === "pending"
+  );
+  const results = [];
+  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`);
+      continue;
+    }
+    const aheadLog = execSafe2(`git -C ${shellQuote2(cwd)} log HEAD..${shellQuote2(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)}`;
+    try {
+      exec2(mergeCmd);
+      execSafe2(`git -C ${shellQuote2(cwd)} worktree remove ${shellQuote2(agent.worktreePath)}`);
+      execSafe2(`git -C ${shellQuote2(cwd)} branch -d ${shellQuote2(branch)}`);
+      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);
+      results.push({ agentId: agent.id, name: agent.name, status: "conflict", conflictDetails });
+    }
+  }
+  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 = dirname2(worktreePath);
+  try {
+    const entries = readdirSync2(baseDir);
+    if (entries.length === 0) {
+      rmSync(baseDir, { recursive: true });
+    }
+  } catch {
+  }
+}
+function countWorktreeAgents(agents) {
+  return agents.filter((a) => a.worktreePath && a.status === "running").length;
+}
+
+// src/daemon/agent.ts
 var agentCounters = /* @__PURE__ */ new Map();
-function resetAgentCounter(sessionId, value = 0) {
-  agentCounters.set(sessionId, value);
+function resetAgentCounterFromState(sessionId, agents) {
+  let max = 0;
+  for (const a of agents) {
+    const match = a.id.match(/^agent-(\d+)$/);
+    if (match) max = Math.max(max, parseInt(match[1], 10));
+  }
+  agentCounters.set(sessionId, max);
 }
 function clearAgentCounter(sessionId) {
   agentCounters.delete(sessionId);
 }
-function renderAgentSuffix(sessionId, instruction) {
+function renderAgentSuffix(sessionId, instruction, worktreeContext) {
   const templatePath = resolve2(import.meta.dirname, "../templates/agent-suffix.md");
   let template;
   try {
-    template = readFileSync4(templatePath, "utf-8");
+    template = readFileSync6(templatePath, "utf-8");
   } catch {
     template = `# Sisyphus Agent
 Session: {{SESSION_ID}}
 Task: {{INSTRUCTION}}`;
   }
-  return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction);
+  let worktreeBlock = "";
+  if (worktreeContext) {
+    worktreeBlock = [
+      "## Worktree Context",
+      `You are working in worktree ${worktreeContext.offset} of ${worktreeContext.total} concurrent worktrees on branch \`${worktreeContext.branchName}\`.`,
+      `If you start any services that require ports, add ${worktreeContext.offset} to the default port.`
+    ].join("\n");
+  }
+  return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{WORKTREE_CONTEXT\}\}/g, worktreeBlock);
 }
 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);
+  const pluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
+  const color = resolveAgentTypeColor(agentType, pluginPath, cwd) ?? getNextColor(sessionId);
+  let paneCwd = cwd;
+  let worktreePath;
+  let branchName;
+  let worktreeContext;
+  if (opts.worktree) {
+    const wt = createWorktree(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 = createPane(windowId, paneCwd);
   setPaneTitle(paneId, `${name} (${agentId})`);
   setPaneStyle(paneId, color);
-  const suffix = renderAgentSuffix(sessionId, instruction);
-  const suffixFilePath = `${sessionDir(cwd, sessionId)}/${agentId}-system.md`;
+  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 = existsSync3(bannerPath) ? `cat '${bannerPath}' &&` : "";
   const envExports = [
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
-    `export SISYPHUS_AGENT_ID='${agentId}'`
+    `export SISYPHUS_AGENT_ID='${agentId}'`,
+    ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : []
   ].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 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 agent = {
     id: agentId,
     name,
@@ -451,7 +739,8 @@ async function spawnAgent(opts) {
     spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
     completedAt: null,
     reports: [],
-    paneId
+    paneId,
+    ...worktreePath ? { worktreePath, branchName, mergeStatus: "pending" } : {}
   };
   await addAgent(cwd, sessionId, agent);
   return agent;
@@ -459,7 +748,7 @@ async function spawnAgent(opts) {
 function nextReportNumber(cwd, sessionId, agentId) {
   const dir = reportsDir(cwd, sessionId);
   try {
-    const files = readdirSync2(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
+    const files = readdirSync3(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
     return String(files.length + 1).padStart(3, "0");
   } catch {
     return "001";
@@ -467,7 +756,7 @@ function nextReportNumber(cwd, sessionId, agentId) {
 }
 async function handleAgentReport(cwd, sessionId, agentId, content) {
   const dir = reportsDir(cwd, sessionId);
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   const num = nextReportNumber(cwd, sessionId, agentId);
   const filePath = reportFilePath(cwd, sessionId, agentId, num);
   writeFileSync3(filePath, content, "utf-8");
@@ -481,7 +770,7 @@ async function handleAgentReport(cwd, sessionId, agentId, content) {
 }
 async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const dir = reportsDir(cwd, sessionId);
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   const filePath = reportFilePath(cwd, sessionId, agentId, "final");
   writeFileSync3(filePath, report, "utf-8");
   const entry = {
@@ -496,10 +785,13 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
     completedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const session = getSession(cwd, sessionId);
-  const agent = session.agents.find((a) => a.id === agentId);
+  const agentArr = session.agents;
+  const agent = agentArr.slice().reverse().find((a) => a.id === agentId);
   if (agent) {
     killPane(agent.paneId);
   }
+  const windowId = getWindowId(sessionId);
+  if (windowId) selectLayout(windowId);
   return allAgentsDone(session);
 }
 async function handleAgentKilled(cwd, sessionId, agentId, reason) {
@@ -515,7 +807,7 @@ function allAgentsDone(session) {
   const running = session.agents.filter((a) => a.status === "running");
   return running.length === 0 && session.agents.length > 0;
 }
-function shellQuote2(s) {
+function shellQuote3(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
 }
 
@@ -567,19 +859,38 @@ async function pollSession(sessionId, cwd, windowId) {
     console.error(`[sisyphus] Failed to read state for session ${sessionId}:`, err);
     return;
   }
+  if (session.status === "completed") {
+    const orchPaneId2 = getOrchestratorPaneId(sessionId);
+    if (orchPaneId2) {
+      const livePanes2 = listPanes(windowId);
+      const livePaneIds2 = new Set(livePanes2.map((p) => p.paneId));
+      if (!livePaneIds2.has(orchPaneId2)) {
+        cleanupSessionMaps(sessionId);
+        untrackSession(sessionId);
+        console.log(`[sisyphus] Session ${sessionId} cleaned up: orchestrator pane closed by user`);
+      }
+    } else {
+      cleanupSessionMaps(sessionId);
+      untrackSession(sessionId);
+    }
+    return;
+  }
   if (session.status !== "active") return;
   const livePanes = listPanes(windowId);
   if (livePanes.length === 0) return;
   const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+  let paneRemoved = false;
   for (const agent of session.agents) {
     if (agent.status !== "running") continue;
     if (!livePaneIds.has(agent.paneId)) {
+      paneRemoved = true;
       const allDone = await handleAgentKilled(cwd, sessionId, agent.id, "pane closed by user");
       if (allDone && onAllAgentsDone) {
         onAllAgentsDone(sessionId, cwd, windowId);
       }
     }
   }
+  if (paneRemoved) selectLayout(windowId);
   const orchPaneId = getOrchestratorPaneId(sessionId);
   if (orchPaneId && !livePaneIds.has(orchPaneId)) {
     const runningAgents = session.agents.filter((a) => a.status === "running");
@@ -588,12 +899,18 @@ async function pollSession(sessionId, cwd, windowId) {
       console.log(`[sisyphus] Session ${sessionId} paused: orchestrator pane disappeared`);
     }
   }
+  session = getSession(cwd, sessionId);
+  if (session.status === "active" && session.agents.length > 0 && session.agents.every((a) => a.status !== "running") && (!orchPaneId || !livePaneIds.has(orchPaneId)) && onAllAgentsDone) {
+    console.log(`[sisyphus] Detected stuck session ${sessionId}: all agents done, no orchestrator \u2014 triggering respawn`);
+    onAllAgentsDone(sessionId, cwd, windowId);
+  }
 }
 
 // src/daemon/session-manager.ts
 async function startSession(task, cwd, tmuxSession, windowId) {
   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);
@@ -601,17 +918,30 @@ async function startSession(task, cwd, tmuxSession, windowId) {
 }
 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"
-      });
+  if (session.status !== "active") {
+    const livePaneIds = /* @__PURE__ */ new Set();
+    if (session.tmuxWindowId) {
+      const panes = listPanes(session.tmuxWindowId);
+      for (const pane of panes) {
+        livePaneIds.add(pane.paneId);
+      }
+    }
+    for (const agent of session.agents) {
+      if (agent.status === "running") {
+        const isAlive = agent.paneId != null && livePaneIds.has(agent.paneId);
+        if (!isAlive) {
+          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);
+  await updateSessionTmux(cwd, sessionId, tmuxSession, windowId);
+  resetAgentCounterFromState(sessionId, session.agents);
   resetColors(sessionId);
   trackSession(sessionId, cwd, tmuxSession);
   await spawnOrchestrator(sessionId, cwd, windowId, message);
@@ -623,8 +953,8 @@ function getSessionStatus(cwd, sessionId) {
 }
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync2(dir)) return [];
-  const entries = readdirSync3(dir, { withFileTypes: true });
+  if (!existsSync4(dir)) return [];
+  const entries = readdirSync4(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -646,11 +976,22 @@ function listSessions(cwd) {
 function onAllAgentsDone2(sessionId, cwd, windowId) {
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") return;
+  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";
+      updateAgent(cwd, sessionId, result.agentId, {
+        mergeStatus,
+        mergeDetails: result.conflictDetails
+      }).catch((err) => console.error(`[sisyphus] Failed to update merge status for ${result.agentId}:`, err));
+    }
+  }
   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) {
+async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktree) {
   const windowId = getWindowId(sessionId);
   if (!windowId) throw new Error(`No tmux window found for session ${sessionId}`);
   const agent = await spawnAgent({
@@ -659,7 +1000,8 @@ async function handleSpawn(sessionId, cwd, agentType, name, instruction) {
     agentType,
     name,
     instruction,
-    windowId
+    windowId,
+    worktree
   });
   await appendAgentToLastCycle(cwd, sessionId, agent.id);
   return { agentId: agent.id };
@@ -677,29 +1019,8 @@ async function handleYield(sessionId, cwd, nextPrompt) {
   await handleOrchestratorYield(sessionId, cwd, nextPrompt);
 }
 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 });
 }
@@ -717,6 +1038,11 @@ async function handleKill(sessionId, cwd) {
       killedAgents++;
     }
   }
+  for (const agent of session.agents) {
+    if (agent.worktreePath && agent.branchName) {
+      cleanupWorktree(cwd, agent.worktreePath, agent.branchName);
+    }
+  }
   const orchPaneId = getOrchestratorPaneId(sessionId);
   if (orchPaneId) {
     killPane(orchPaneId);
@@ -736,11 +1062,11 @@ var sessionCwdMap = /* @__PURE__ */ new Map();
 var sessionTmuxMap = /* @__PURE__ */ new Map();
 var sessionWindowMap2 = /* @__PURE__ */ new Map();
 function registryPath() {
-  return join2(globalDir(), "session-registry.json");
+  return join4(globalDir(), "session-registry.json");
 }
 function persistSessionRegistry() {
   const dir = globalDir();
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   const registry = {};
   for (const [id, cwd] of sessionCwdMap) {
     registry[id] = cwd;
@@ -749,9 +1075,9 @@ function persistSessionRegistry() {
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync3(p)) return {};
+  if (!existsSync5(p)) return {};
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync7(p, "utf-8"));
   } catch {
     return {};
   }
@@ -760,6 +1086,10 @@ function registerSessionCwd(sessionId, cwd) {
   sessionCwdMap.set(sessionId, cwd);
   persistSessionRegistry();
 }
+function registerSessionTmux(sessionId, tmuxSession, windowId) {
+  sessionTmuxMap.set(sessionId, tmuxSession);
+  sessionWindowMap2.set(sessionId, windowId);
+}
 async function handleRequest(req) {
   try {
     switch (req.type) {
@@ -773,7 +1103,7 @@ async function handleRequest(req) {
       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);
+        const result = await handleSpawn(req.sessionId, cwd, req.agentType, req.name, req.instruction, req.worktree);
         return { ok: true, data: { agentId: result.agentId } };
       }
       case "submit": {
@@ -811,32 +1141,29 @@ async function handleRequest(req) {
         }
         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));
+        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 })));
+          }
+        } 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;
+          }
+          if (totalCount > allSessions.length) {
+            return { ok: true, data: { sessions: allSessions, totalCount, filtered: true } };
+          }
         }
         return { ok: true, data: { sessions: allSessions } };
       }
@@ -844,7 +1171,7 @@ async function handleRequest(req) {
         let cwd = sessionCwdMap.get(req.sessionId);
         if (!cwd) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync3(stateFile)) {
+          if (existsSync5(stateFile)) {
             cwd = req.cwd;
             registerSessionCwd(req.sessionId, cwd);
           } else {
@@ -883,7 +1210,7 @@ async function handleRequest(req) {
 function startServer() {
   return new Promise((resolve3, reject) => {
     const sock = socketPath();
-    if (existsSync3(sock)) {
+    if (existsSync5(sock)) {
       unlinkSync(sock);
     }
     server = createServer((conn) => {
@@ -925,7 +1252,7 @@ function stopServer() {
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync3(sock)) {
+      if (existsSync5(sock)) {
         unlinkSync(sock);
       }
       server = null;
@@ -936,7 +1263,7 @@ function stopServer() {
 
 // src/daemon/index.ts
 function ensureDirs() {
-  mkdirSync4(globalDir(), { recursive: true });
+  mkdirSync5(globalDir(), { recursive: true });
 }
 function isProcessAlive(pid) {
   try {
@@ -946,17 +1273,22 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function acquirePidLock() {
+function readPid() {
   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);
-    }
+    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
+    return pid && isProcessAlive(pid) ? pid : null;
   } catch {
+    return null;
   }
-  writeFileSync5(pidFile, String(process.pid), "utf-8");
+}
+function acquirePidLock() {
+  const pid = readPid();
+  if (pid) {
+    console.error(`[sisyphus] Daemon already running (pid ${pid}). Use 'sisyphusd restart' or 'sisyphusd stop' first.`);
+    process.exit(0);
+  }
+  writeFileSync5(daemonPidPath(), String(process.pid), "utf-8");
 }
 function releasePidLock() {
   try {
@@ -964,7 +1296,40 @@ function releasePidLock() {
   } catch {
   }
 }
-function recoverSessions() {
+function stopDaemon() {
+  const pid = readPid();
+  if (!pid) {
+    console.log("[sisyphus] Daemon is not running");
+    releasePidLock();
+    return false;
+  }
+  console.log(`[sisyphus] Stopping daemon (pid ${pid})...`);
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    console.error(`[sisyphus] Failed to send SIGTERM to pid ${pid}`);
+    return false;
+  }
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) {
+      console.log("[sisyphus] Daemon stopped");
+      releasePidLock();
+      return true;
+    }
+    const wait = Date.now() + 100;
+    while (Date.now() < wait) {
+    }
+  }
+  console.error(`[sisyphus] Daemon (pid ${pid}) did not exit within 5s, sending SIGKILL`);
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+  releasePidLock();
+  return true;
+}
+async function recoverSessions() {
   const registry = loadSessionRegistry();
   const entries = Object.entries(registry);
   if (entries.length === 0) {
@@ -974,13 +1339,45 @@ function recoverSessions() {
   let recovered = 0;
   for (const [sessionId, cwd] of entries) {
     const stateFile = statePath(cwd, sessionId);
-    if (!existsSync4(stateFile)) {
+    if (!existsSync6(stateFile)) {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync6(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync8(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
+        resetAgentCounterFromState(sessionId, session.agents ?? []);
+        if (session.tmuxSessionName && session.tmuxWindowId) {
+          const livePanes = listPanes(session.tmuxWindowId);
+          if (livePanes.length > 0) {
+            registerSessionTmux(sessionId, session.tmuxSessionName, session.tmuxWindowId);
+            setWindowId(sessionId, session.tmuxWindowId);
+            trackSession(sessionId, cwd, session.tmuxSessionName);
+            updateTrackedWindow(sessionId, session.tmuxWindowId);
+            const lastIncompleteCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt && c.paneId);
+            if (lastIncompleteCycle?.paneId) {
+              setOrchestratorPaneId(sessionId, lastIncompleteCycle.paneId);
+            }
+            console.log(`[sisyphus] Reconnected session ${sessionId} to tmux window ${session.tmuxWindowId}`);
+            if (session.status === "active" && session.agents.length > 0) {
+              const hasRunningAgents = session.agents.some((a) => a.status === "running");
+              if (!hasRunningAgents) {
+                const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+                const orchestratorPaneId = getOrchestratorPaneId(sessionId);
+                const orchestratorAlive = orchestratorPaneId && livePaneIds.has(orchestratorPaneId);
+                if (!orchestratorAlive) {
+                  console.log(`[sisyphus] Detected stuck session ${sessionId} on recovery: triggering orchestrator respawn`);
+                  await onAllAgentsDone2(sessionId, cwd, session.tmuxWindowId);
+                }
+              }
+            }
+          } else {
+            if (session.status === "active") {
+              await updateSessionStatus(cwd, sessionId, "paused");
+              console.log(`[sisyphus] Session ${sessionId} paused: tmux window no longer exists`);
+            }
+          }
+        }
         recovered++;
       }
     } catch {
@@ -989,7 +1386,7 @@ function recoverSessions() {
   }
   console.log(`[sisyphus] Recovered ${recovered} session(s) from registry`);
 }
-async function main() {
+async function startDaemon() {
   console.log("[sisyphus] Starting daemon...");
   ensureDirs();
   acquirePidLock();
@@ -997,7 +1394,7 @@ async function main() {
   setRespawnCallback(onAllAgentsDone2);
   await startServer();
   startMonitor(config.pollIntervalMs);
-  recoverSessions();
+  await recoverSessions();
   const shutdown = async () => {
     console.log("[sisyphus] Shutting down...");
     stopMonitor();
@@ -1008,8 +1405,32 @@ async function main() {
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
 }
-main().catch((err) => {
-  console.error("[sisyphus] Fatal error:", err);
-  process.exit(1);
-});
+var command = process.argv[2];
+switch (command) {
+  case "stop":
+    stopDaemon();
+    break;
+  case "restart": {
+    stopDaemon();
+    const wait = Date.now() + 500;
+    while (Date.now() < wait) {
+    }
+    startDaemon().catch((err) => {
+      console.error("[sisyphus] Fatal error:", err);
+      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);
+}
 //# sourceMappingURL=daemon.js.map