sisyphi 0.1.21 → 0.1.23

package/dist/daemon.js

@@ -1,73 +1,53 @@
 #!/usr/bin/env node
+import {
+  loadConfig
+} from "./chunk-KQBSC5KY.js";
 import {
   contextDir,
+  cycleLogPath,
   daemonPidPath,
   daemonUpdatingPath,
-  globalConfigPath,
   globalDir,
-  logsPath,
-  planPath,
-  projectConfigPath,
+  goalPath,
+  legacyLogsPath,
+  logsDir,
+  messagesDir,
   projectOrchestratorPromptPath,
   promptsDir,
   reportFilePath,
   reportsDir,
+  roadmapPath,
   sessionDir,
   sessionsDir,
+  snapshotDir,
+  snapshotsDir,
   socketPath,
   statePath,
   worktreeBaseDir,
   worktreeConfigPath
-} from "./chunk-LTAW6OWS.js";
+} from "./chunk-YGBGKMTF.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3, existsSync as existsSync7 } from "fs";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 
-// src/shared/config.ts
-import { readFileSync } from "fs";
-var DEFAULT_CONFIG = {
-  pollIntervalMs: 5e3
-};
-function readJsonFile(filePath) {
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-function loadConfig(cwd) {
-  const global = readJsonFile(globalConfigPath());
-  const project = readJsonFile(projectConfigPath(cwd));
-  return { ...DEFAULT_CONFIG, ...global, ...project };
-}
-
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync6, writeFileSync as writeFileSync4, readFileSync as readFileSync7, mkdirSync as mkdirSync4 } from "fs";
-import { join as join4 } from "path";
+import { unlinkSync, existsSync as existsSync7, writeFileSync as writeFileSync4, 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 existsSync5, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
 
 // src/daemon/state.ts
 import { randomUUID } from "crypto";
-import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
-var PLAN_SEED = `---
+var ROADMAP_SEED = `---
 description: >
-  Living document of what still needs to happen. Write out ne
----
-`;
-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.
+  Living document tracking development phases and outstanding work.
 ---
 `;
 var CONTEXT_CLAUDE_MD = `# context/
@@ -95,29 +75,32 @@ function atomicWrite(filePath, data) {
   writeFileSync(tmpPath, data, "utf-8");
   renameSync(tmpPath, filePath);
 }
-function createSession(id, task, cwd, context) {
+function createSession(id, task, cwd, context, name) {
   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");
+  writeFileSync(roadmapPath(cwd, id), ROADMAP_SEED, "utf-8");
+  mkdirSync(logsDir(cwd, id), { recursive: true });
+  writeFileSync(goalPath(cwd, id), task, "utf-8");
   writeFileSync(join(contextDir(cwd, id), "CLAUDE.md"), CONTEXT_CLAUDE_MD, "utf-8");
   const session = {
     id,
+    ...name ? { name } : {},
     task,
     ...context ? { context } : {},
     cwd,
     status: "active",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     agents: [],
-    orchestratorCycles: []
+    orchestratorCycles: [],
+    messages: []
   };
   atomicWrite(statePath(cwd, id), JSON.stringify(session, null, 2));
   return session;
 }
 function getSession(cwd, sessionId) {
-  const content = readFileSync2(statePath(cwd, sessionId), "utf-8");
+  const content = readFileSync(statePath(cwd, sessionId), "utf-8");
   return JSON.parse(content);
 }
 function saveSession(session) {
@@ -174,6 +157,23 @@ async function completeSession(cwd, sessionId, report) {
     saveSession(session);
   });
 }
+async function continueSession(cwd, sessionId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    if (session.status !== "completed") {
+      throw new Error(`Session ${sessionId} is not completed (status: ${session.status})`);
+    }
+    session.status = "active";
+    session.completedAt = void 0;
+    session.completionReport = void 0;
+    const cycles = session.orchestratorCycles;
+    if (cycles.length > 0) {
+      cycles[cycles.length - 1].completedAt = void 0;
+    }
+    saveSession(session);
+    writeFileSync(roadmapPath(cwd, sessionId), "", "utf-8");
+  });
+}
 async function appendAgentReport(cwd, sessionId, agentId, entry) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -183,6 +183,18 @@ async function appendAgentReport(cwd, sessionId, agentId, entry) {
     saveSession(session);
   });
 }
+async function updateReportSummary(cwd, sessionId, agentId, filePath, summary) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) return;
+    const report = agent.reports.find((r) => r.filePath === filePath);
+    if (report) {
+      report.summary = summary;
+      saveSession(session);
+    }
+  });
+}
 async function updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -191,7 +203,31 @@ async function updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId)
     saveSession(session);
   });
 }
-async function completeOrchestratorCycle(cwd, sessionId, nextPrompt) {
+async function drainMessages(cwd, sessionId, count) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    if (!session.messages || count <= 0) return;
+    session.messages = session.messages.slice(count);
+    saveSession(session);
+  });
+}
+async function appendMessage(cwd, sessionId, message) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    if (!session.messages) session.messages = [];
+    session.messages.push(message);
+    saveSession(session);
+  });
+}
+async function updateTask(cwd, sessionId, task) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.task = task;
+    saveSession(session);
+    writeFileSync(goalPath(cwd, sessionId), task, "utf-8");
+  });
+}
+async function completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
     const cycles = session.orchestratorCycles;
@@ -199,13 +235,66 @@ async function completeOrchestratorCycle(cwd, sessionId, nextPrompt) {
     const cycle = cycles[cycles.length - 1];
     cycle.completedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (nextPrompt) cycle.nextPrompt = nextPrompt;
+    if (mode) cycle.mode = mode;
     saveSession(session);
   });
 }
+function createSnapshot(cwd, sessionId, cycleNumber) {
+  const dir = snapshotDir(cwd, sessionId, cycleNumber);
+  mkdirSync(dir, { recursive: true });
+  copyFileSync(statePath(cwd, sessionId), join(dir, "state.json"));
+  const roadmap = roadmapPath(cwd, sessionId);
+  if (existsSync(roadmap)) copyFileSync(roadmap, join(dir, "roadmap.md"));
+  const ld = logsDir(cwd, sessionId);
+  if (existsSync(ld)) cpSync(ld, join(dir, "logs"), { recursive: true });
+  const legacyLogs = legacyLogsPath(cwd, sessionId);
+  if (existsSync(legacyLogs)) copyFileSync(legacyLogs, join(dir, "logs.md"));
+}
+async function restoreSnapshot(cwd, sessionId, toCycle) {
+  return withSessionLock(sessionId, () => {
+    const dir = snapshotDir(cwd, sessionId, toCycle);
+    if (!existsSync(dir)) throw new Error(`No snapshot found for cycle ${toCycle}`);
+    const snapshotState = readFileSync(join(dir, "state.json"), "utf-8");
+    const session = JSON.parse(snapshotState);
+    session.status = "paused";
+    session.completedAt = void 0;
+    session.completionReport = void 0;
+    session.tmuxSessionName = void 0;
+    session.tmuxWindowId = void 0;
+    atomicWrite(statePath(cwd, sessionId), JSON.stringify(session, null, 2));
+    const snapshotRoadmap = join(dir, "roadmap.md");
+    if (existsSync(snapshotRoadmap)) copyFileSync(snapshotRoadmap, roadmapPath(cwd, sessionId));
+    const snapshotLogsDir = join(dir, "logs");
+    if (existsSync(snapshotLogsDir)) {
+      const currentLogsDir = logsDir(cwd, sessionId);
+      if (existsSync(currentLogsDir)) rmSync(currentLogsDir, { recursive: true, force: true });
+      cpSync(snapshotLogsDir, currentLogsDir, { recursive: true });
+    } else {
+      const snapshotLogs = join(dir, "logs.md");
+      if (existsSync(snapshotLogs)) copyFileSync(snapshotLogs, legacyLogsPath(cwd, sessionId));
+    }
+  });
+}
+function listSnapshots(cwd, sessionId) {
+  const dir = snapshotsDir(cwd, sessionId);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("cycle-")).map((e) => parseInt(e.name.replace("cycle-", ""), 10)).filter((n) => !isNaN(n)).sort((a, b) => a - b);
+}
+function deleteSnapshotsAfter(cwd, sessionId, afterCycle) {
+  const dir = snapshotsDir(cwd, sessionId);
+  if (!existsSync(dir)) return;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("cycle-")) continue;
+    const num = parseInt(entry.name.replace("cycle-", ""), 10);
+    if (!isNaN(num) && num > afterCycle) {
+      rmSync(join(dir, entry.name), { recursive: true, force: true });
+    }
+  }
+}
 
 // src/daemon/orchestrator.ts
-import { existsSync, readdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { resolve } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { resolve, join as join3 } from "path";
 
 // src/daemon/colors.ts
 var ORCHESTRATOR_COLOR = "yellow";
@@ -228,6 +317,140 @@ function resetColors(sessionId) {
   sessionColorIndex.delete(sessionId);
 }
 
+// src/daemon/frontmatter.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2, basename } from "path";
+function detectProvider(model) {
+  if (!model) return "anthropic";
+  if (/^(gpt-|codex-)/.test(model)) return "openai";
+  return "anthropic";
+}
+function parseAgentFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const block = match[1];
+  const fm = {};
+  const str = (key) => {
+    const m = block.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+    return m ? m[1].trim() : void 0;
+  };
+  fm.name = str("name");
+  fm.model = str("model");
+  fm.color = str("color");
+  fm.description = str("description");
+  fm.permissionMode = str("permissionMode");
+  fm.effort = str("effort");
+  const skillsMatch = block.match(/^skills:\s*\n((?:\s+-\s+.+\n?)*)/m);
+  if (skillsMatch) {
+    fm.skills = skillsMatch[1].split("\n").map((line) => line.replace(/^\s+-\s+/, "").trim()).filter(Boolean);
+  }
+  return fm;
+}
+function extractAgentBody(content) {
+  const match = content.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
+  return match ? match[1].trim() : content.trim();
+}
+function findPluginInstallPath(namespace) {
+  try {
+    const registryPath2 = join2(homedir(), ".claude", "plugins", "installed_plugins.json");
+    const registry = JSON.parse(readFileSync2(registryPath2, "utf-8"));
+    for (const key of Object.keys(registry)) {
+      if (key.startsWith(`${namespace}@`)) {
+        return registry[key].installPath ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function resolveAgentTypePath(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) {
+    if (existsSync2(path)) return path;
+  }
+  return null;
+}
+function discoverAgentTypes(pluginDir, cwd) {
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  function scanDir(dir, prefix, source) {
+    let files;
+    try {
+      files = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".md") || file === "CLAUDE.md") continue;
+      const name = basename(file, ".md");
+      const qualifiedName = prefix ? `${prefix}:${name}` : name;
+      if (seen.has(qualifiedName)) continue;
+      seen.add(qualifiedName);
+      try {
+        const content = readFileSync2(join2(dir, file), "utf-8");
+        const fm = parseAgentFrontmatter(content);
+        results.push({ qualifiedName, source, description: fm.description, model: fm.model });
+      } catch {
+        results.push({ qualifiedName, source });
+      }
+    }
+  }
+  scanDir(join2(cwd, ".claude", "agents"), null, "project");
+  scanDir(join2(homedir(), ".claude", "agents"), null, "user");
+  scanDir(join2(pluginDir, "agents"), "sisyphus", "bundled");
+  try {
+    const registryPath2 = join2(homedir(), ".claude", "plugins", "installed_plugins.json");
+    const registry = JSON.parse(readFileSync2(registryPath2, "utf-8"));
+    const pluginEntries = registry.plugins ?? registry;
+    for (const key of Object.keys(pluginEntries)) {
+      const atIdx = key.indexOf("@");
+      if (atIdx < 1) continue;
+      const namespace = key.slice(0, atIdx);
+      const entry = pluginEntries[key];
+      const installPath = Array.isArray(entry) ? entry[0]?.installPath : entry?.installPath;
+      if (installPath) {
+        scanDir(join2(installPath, "agents"), namespace, "plugin");
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function resolveAgentConfig(agentType, pluginDir, cwd) {
+  const filePath = resolveAgentTypePath(agentType, pluginDir, cwd);
+  if (!filePath) return null;
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return {
+      frontmatter: parseAgentFrontmatter(content),
+      body: extractAgentBody(content),
+      filePath
+    };
+  } catch {
+    return null;
+  }
+}
+
 // src/daemon/tmux.ts
 import { execSync } from "child_process";
 var EXEC_ENV = {
@@ -239,7 +462,7 @@ function exec(cmd) {
 }
 function execSafe(cmd) {
   try {
-    return exec(cmd);
+    return execSync(cmd, { encoding: "utf-8", env: EXEC_ENV, stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return null;
   }
@@ -263,6 +486,24 @@ function killPane(paneTarget) {
 function killWindow(windowTarget) {
   execSafe(`tmux kill-window -t "${windowTarget}"`);
 }
+function createSession2(sessionName, windowName, cwd) {
+  exec(`tmux new-session -d -s "${sessionName}" -n "${windowName}" -c ${shellQuote(cwd)}`);
+  const windowId = exec(`tmux display-message -t "${sessionName}:${windowName}" -p "#{window_id}"`);
+  const initialPaneId = exec(`tmux display-message -t "${sessionName}:${windowName}" -p "#{pane_id}"`);
+  return { windowId, initialPaneId };
+}
+function paneExists(paneTarget) {
+  return execSafe(`tmux display-message -t "${paneTarget}" -p "#{pane_id}"`) !== null;
+}
+function sessionExists(sessionName) {
+  return execSafe(`tmux has-session -t "${sessionName}"`) !== null;
+}
+function killSession(sessionName) {
+  execSafe(`tmux kill-session -t "${sessionName}"`);
+}
+function setSessionOption(sessionName, option, value) {
+  execSafe(`tmux set-option -t "${sessionName}" ${option} ${shellQuote(value)}`);
+}
 function listPanes(windowTarget) {
   const output = execSafe(`tmux list-panes -t "${windowTarget}" -F "#{pane_id} #{pane_pid}"`);
   if (!output) return [];
@@ -330,135 +571,206 @@ function getOrchestratorPaneId(sessionId) {
 function setOrchestratorPaneId(sessionId, paneId) {
   sessionOrchestratorPane.set(sessionId, paneId);
 }
-function loadOrchestratorPrompt(cwd) {
+function loadOrchestratorPrompt(cwd, mode) {
   const projectPath = projectOrchestratorPromptPath(cwd);
-  if (existsSync(projectPath)) {
+  if (existsSync3(projectPath)) {
     return readFileSync3(projectPath, "utf-8");
   }
-  const bundledPath = resolve(import.meta.dirname, "../templates/orchestrator.md");
-  return readFileSync3(bundledPath, "utf-8");
+  const basePath = resolve(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");
+    return base + "\n\n" + readFileSync3(implPath, "utf-8");
+  }
+  const planningPath = resolve(import.meta.dirname, "../templates/orchestrator-planning.md");
+  return base + "\n\n" + readFileSync3(planningPath, "utf-8");
 }
 function formatStateForOrchestrator(session) {
-  const shortId = session.id.slice(0, 8);
   const cycleNum = session.orchestratorCycles.length;
   const ctxDir = contextDir(session.cwd, session.id);
-  let contextLines;
-  if (existsSync(ctxDir)) {
-    const files = readdirSync(ctxDir);
-    contextLines = files.length > 0 ? files.map((f) => `- ${f}`).join("\n") : "  (none)";
+  const roadmapFile = roadmapPath(session.cwd, session.id);
+  const logFile = cycleLogPath(session.cwd, session.id, cycleNum + 1);
+  let contextSection = "";
+  if (cycleNum === 0) {
+    if (session.context) {
+      contextSection = `
+## Context
+
+${session.context}
+`;
+    }
   } 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;
-    let updateNum = 0;
-    const reportLines = a.reports.map((r) => {
-      const label = r.type === "final" ? "[final]" : `[update ${String(++updateNum).padStart(3, "0")}]`;
-      return `  ${label} "${r.summary}" \u2192 ${r.filePath}`;
+    let ctxFiles = [];
+    if (existsSync3(ctxDir)) {
+      ctxFiles = readdirSync3(ctxDir).filter((f) => f !== "CLAUDE.md");
+    }
+    if (ctxFiles.length > 0) {
+      const ctxLines = ctxFiles.map((f) => `- ${join3(ctxDir, f)}`).join("\n");
+      contextSection = `
+## Context
+
+${ctxLines}
+`;
+    }
+  }
+  const messages = session.messages ?? [];
+  const messagesSection = messages.length > 0 ? "\n### Messages\n\n" + messages.map((m) => {
+    const sourceLabel = m.source.type === "agent" ? `agent:${m.source.agentId}` : m.source.type === "system" && m.source.detail ? `system:${m.source.detail}` : m.source.type;
+    const fileRef = m.filePath ? ` \u2192 ${m.filePath}` : "";
+    return `- [${sourceLabel} @ ${m.timestamp}] "${m.summary}"${fileRef}`;
+  }).join("\n") + "\n" : "";
+  let previousCyclesSection = "";
+  if (session.orchestratorCycles.length > 1) {
+    const previousCycles = session.orchestratorCycles.slice(0, -1);
+    const agentMap = new Map(session.agents.map((a) => [a.id, a]));
+    const lines = previousCycles.map((c) => {
+      const agentDescs = c.agentsSpawned.map((id) => {
+        const agent = agentMap.get(id);
+        return agent ? `${id} (${agent.name})` : id;
+      }).join(", ");
+      return `Cycle ${c.cycle}: ${agentDescs || "(none)"}`;
     });
-    return [header, ...reportLines].join("\n");
-  }).join("\n") : "  (none)";
-  const cycleLines = session.orchestratorCycles.length > 0 ? session.orchestratorCycles.map((c) => {
-    const spawnedList = c.agentsSpawned.length > 0 ? c.agentsSpawned.join(", ") : "(none)";
-    return `Cycle ${c.cycle}: Spawned ${spawnedList}`;
-  }).join("\n") : "  (none)";
+    previousCyclesSection = `
+### Previous Cycles
+
+${lines.join("\n")}
+`;
+  }
+  let mostRecentCycleSection = "";
+  const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
+  if (lastCycle && lastCycle.agentsSpawned.length > 0) {
+    const agentMap = new Map(session.agents.map((a) => [a.id, a]));
+    const agentBlocks = lastCycle.agentsSpawned.map((id) => {
+      const agent = agentMap.get(id);
+      if (!agent) return `<agent-${id} status="unknown">
+(no agent data)
+</agent-${id}>`;
+      const finalReport = agent.reports.find((r) => r.type === "final");
+      const reportToUse = finalReport ?? agent.reports[agent.reports.length - 1];
+      let reportContent = "(no reports)";
+      if (reportToUse) {
+        try {
+          reportContent = readFileSync3(reportToUse.filePath, "utf-8");
+        } catch {
+          reportContent = `(could not read report: ${reportToUse.filePath})`;
+        }
+      }
+      return `<agent-${id} name="${agent.name}" status="${agent.status}">
+${reportContent}
+</agent-${id}>`;
+    }).join("\n");
+    mostRecentCycleSection = `
+### Most Recent Cycle
+
+<last-cycle>
+${agentBlocks}
+</last-cycle>
+`;
+  }
+  const roadmapRef = existsSync3(roadmapFile) ? `@${roadmapFile}` : "(empty)";
   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"}
+  if (worktreeAgents.length > 0 || existsSync3(worktreeConfigPath(session.cwd))) {
+    let wtLines = "";
+    if (worktreeAgents.length > 0) {
+      wtLines = "\n" + worktreeAgents.map((a) => {
+        if (a.mergeStatus === "conflict") {
+          return `- ${a.id}: CONFLICT \u2014 ${a.mergeDetails ?? "unknown"}
   Branch: ${a.branchName}
   Worktree: ${a.worktreePath}`;
-      }
-      if (a.mergeStatus === "no-changes") {
-        return `- ${a.id}: NO CHANGES \u2014 agent did not commit any work to branch ${a.branchName}`;
-      }
-      const status = a.mergeStatus ?? "pending";
-      return `- ${a.id}: ${status} (branch ${a.branchName})`;
-    }).join("\n");
+        }
+        if (a.mergeStatus === "no-changes") {
+          return `- ${a.id}: NO CHANGES \u2014 agent did not commit any work to branch ${a.branchName}`;
+        }
+        const status = a.mergeStatus ?? "pending";
+        return `- ${a.id}: ${status} (branch ${a.branchName})`;
+      }).join("\n");
+    }
+    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.";
     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.";
-  const contextSection = session.context ? `
-## Background Context
-${session.context}
-` : "";
-  return `<state>
-session: ${shortId} (cycle ${cycleNum})
-task: ${session.task}
-status: ${session.status}
-${contextSection}
-## Plan
-${planRef}
-
-## Logs
-${logsRef}
+## Git Worktrees
 
-## Agents
-${agentLines}${worktreeSection}
+${worktreeHint}${wtLines}`;
+  }
+  const goalFile = goalPath(session.cwd, session.id);
+  const goalContent = existsSync3(goalFile) ? readFileSync3(goalFile, "utf-8").trim() : session.task;
+  return `## Goal
 
-## Previous Cycles
-${cycleLines}
+${goalContent}
+${contextSection}${messagesSection}
+### Cycle Log
 
-## Context Files
-${contextLines}
+Write your cycle summary to: ${logFile}
+${previousCyclesSection}${mostRecentCycleSection}
+## Roadmap
 
-## Git Worktrees
-${worktreeHint}
-</state>`;
+${roadmapRef}
+${worktreeSection}`;
 }
 async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   const session = getSession(cwd, sessionId);
-  const basePrompt = loadOrchestratorPrompt(cwd);
+  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 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." }
+  );
+  const agentTypeLines = agentTypes.length > 0 ? agentTypes.map((t) => {
+    const modelTag = t.model ? ` (${t.model})` : "";
+    const desc = t.description ? ` \u2014 ${t.description}` : "";
+    return `- \`${t.qualifiedName}\`${modelTag}${desc}`;
+  }).join("\n") : "  (none)";
+  const systemPrompt = basePrompt.replace("{{AGENT_TYPES}}", agentTypeLines);
   const cycleNum = session.orchestratorCycles.length + 1;
   const promptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-system-${cycleNum}.md`;
-  writeFileSync2(promptFilePath, basePrompt, "utf-8");
+  writeFileSync2(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 = [
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
-    `export SISYPHUS_AGENT_ID='orchestrator'`
+    `export SISYPHUS_AGENT_ID='orchestrator'`,
+    `export SISYPHUS_CWD='${cwd}'`,
+    `export PATH="${npmBinDir}:$PATH"`
   ].join(" && ");
-  let userPrompt;
+  let userPrompt = formattedState;
   if (message) {
-    userPrompt = `${formattedState}
+    userPrompt += `
+
+## Continuation Instructions
 
 The user resumed this session with new instructions: ${message}`;
   } else {
-    const lastCycle = [...session.orchestratorCycles].reverse().find((c) => c.completedAt);
     const storedPrompt = lastCycle?.nextPrompt;
-    if (storedPrompt) {
-      userPrompt = `${formattedState}
+    const continuationText = storedPrompt ? storedPrompt : "Review the current session and delegate the next cycle of work.";
+    userPrompt += `
 
-${storedPrompt}`;
-    } else {
-      userPrompt = `${formattedState}
+## Continuation Instructions
 
-Review the current session and delegate the next cycle of work.`;
-    }
+${continuationText}`;
   }
   const userPromptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
   writeFileSync2(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 claudeCmd = `claude --dangerously-skip-permissions --settings "${settingsPath}" --plugin-dir "${pluginPath}" --append-system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
+  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}')"`;
   const paneId = createPane(windowId, cwd, "left");
   sessionOrchestratorPane.set(sessionId, paneId);
   registerPane(paneId, sessionId, "orchestrator");
   setPaneTitle(paneId, `Sisyphus`);
   setPaneStyle(paneId, ORCHESTRATOR_COLOR);
   const bannerPath = resolve(import.meta.dirname, "../templates/banner.txt");
-  const bannerCmd = existsSync(bannerPath) ? `cat '${bannerPath}' &&` : "";
-  const notifyCmd = `sisyphus notify pane-exited --pane-id ${paneId}`;
+  const bannerCmd = existsSync3(bannerPath) ? `cat '${bannerPath}' &&` : "";
+  const notifyCmd = `node "${cliBin}" notify pane-exited --pane-id ${paneId}`;
   sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}; ${notifyCmd}`);
   await addOrchestratorCycle(cwd, sessionId, {
     cycle: cycleNum,
@@ -474,7 +786,7 @@ function resolveOrchestratorPane(sessionId, cwd) {
   const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
   return lastCycle?.paneId ?? void 0;
 }
-async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
+async function handleOrchestratorYield(sessionId, cwd, nextPrompt, mode) {
   const paneId = resolveOrchestratorPane(sessionId, cwd);
   if (paneId) {
     killPane(paneId);
@@ -483,7 +795,7 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
   }
   const windowId = sessionWindowMap.get(sessionId);
   if (windowId) selectLayout(windowId);
-  await completeOrchestratorCycle(cwd, sessionId, nextPrompt);
+  await completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode);
   const session = getSession(cwd, sessionId);
   const runningAgents = session.agents.filter((a) => a.status === "running");
   if (runningAgents.length === 0) {
@@ -502,13 +814,13 @@ function cleanupSessionMaps(sessionId) {
 }
 
 // src/daemon/agent.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync3, existsSync as existsSync4 } from "fs";
+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";
 
 // src/daemon/worktree.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync as readdirSync2, rmSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+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"}`
@@ -536,10 +848,10 @@ function loadWorktreeConfig(cwd) {
 }
 function createWorktreeShell(cwd, sessionId, agentId) {
   const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
-  const worktreePath = join2(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
-  mkdirSync2(dirname2(worktreePath), { recursive: true });
+  const worktreePath = join4(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
+  mkdirSync2(dirname3(worktreePath), { recursive: true });
   execSafe2(`git -C ${shellQuote2(cwd)} worktree prune`);
-  if (existsSync2(worktreePath)) {
+  if (existsSync4(worktreePath)) {
     execSafe2(`git -C ${shellQuote2(cwd)} worktree remove --force ${shellQuote2(worktreePath)}`);
   }
   execSafe2(`git -C ${shellQuote2(cwd)} branch -D ${shellQuote2(branchName)}`);
@@ -550,16 +862,16 @@ function createWorktreeShell(cwd, sessionId, agentId) {
 function bootstrapWorktree(cwd, worktreePath, config) {
   if (config.copy) {
     for (const entry of config.copy) {
-      const dest = join2(worktreePath, entry);
-      mkdirSync2(dirname2(dest), { recursive: true });
-      execSafe2(`cp -r ${shellQuote2(join2(cwd, entry))} ${shellQuote2(dest)}`);
+      const dest = join4(worktreePath, entry);
+      mkdirSync2(dirname3(dest), { recursive: true });
+      execSafe2(`cp -r ${shellQuote2(join4(cwd, entry))} ${shellQuote2(dest)}`);
     }
   }
   if (config.clone) {
     for (const entry of config.clone) {
-      const dest = join2(worktreePath, entry);
-      mkdirSync2(dirname2(dest), { recursive: true });
-      const src = shellQuote2(join2(cwd, entry));
+      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}`);
@@ -568,9 +880,9 @@ function bootstrapWorktree(cwd, worktreePath, config) {
   }
   if (config.symlink) {
     for (const entry of config.symlink) {
-      const dest = join2(worktreePath, entry);
-      mkdirSync2(dirname2(dest), { recursive: true });
-      execSafe2(`ln -s ${shellQuote2(join2(cwd, entry))} ${shellQuote2(dest)}`);
+      const dest = join4(worktreePath, entry);
+      mkdirSync2(dirname3(dest), { recursive: true });
+      execSafe2(`ln -s ${shellQuote2(join4(cwd, entry))} ${shellQuote2(dest)}`);
     }
   }
   if (config.init) {
@@ -640,11 +952,11 @@ function mergeWorktrees(cwd, agents) {
 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);
+  const baseDir = dirname3(worktreePath);
   try {
-    const entries = readdirSync2(baseDir);
+    const entries = readdirSync4(baseDir);
     if (entries.length === 0) {
-      rmSync(baseDir, { recursive: true });
+      rmSync2(baseDir, { recursive: true });
     }
   } catch {
   }
@@ -653,89 +965,37 @@ function countWorktreeAgents(agents) {
   return agents.filter((a) => a.worktreePath && a.status === "running").length;
 }
 
-// src/daemon/frontmatter.ts
-import { readFileSync as readFileSync5, existsSync as existsSync3 } from "fs";
-import { homedir } from "os";
-import { join as join3 } from "path";
-function detectProvider(model) {
-  if (!model) return "anthropic";
-  if (/^(gpt-|codex-)/.test(model)) return "openai";
-  return "anthropic";
-}
-function parseAgentFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  const block = match[1];
-  const fm = {};
-  const str = (key) => {
-    const m = block.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
-    return m ? m[1].trim() : void 0;
-  };
-  fm.name = str("name");
-  fm.model = str("model");
-  fm.color = str("color");
-  fm.description = str("description");
-  fm.permissionMode = str("permissionMode");
-  const skillsMatch = block.match(/^skills:\s*\n((?:\s+-\s+.+\n?)*)/m);
-  if (skillsMatch) {
-    fm.skills = skillsMatch[1].split("\n").map((line) => line.replace(/^\s+-\s+/, "").trim()).filter(Boolean);
-  }
-  return fm;
-}
-function extractAgentBody(content) {
-  const match = content.match(/^---\n[\s\S]*?\n---\n?([\s\S]*)$/);
-  return match ? match[1].trim() : content.trim();
-}
-function findPluginInstallPath(namespace) {
+// src/daemon/summarize.ts
+import { query } from "@r-cli/sdk";
+var disabled = false;
+async function summarizeReport(reportText) {
+  if (disabled) return null;
   try {
-    const registryPath2 = join3(homedir(), ".claude", "plugins", "installed_plugins.json");
-    const registry = JSON.parse(readFileSync5(registryPath2, "utf-8"));
-    for (const key of Object.keys(registry)) {
-      if (key.startsWith(`${namespace}@`)) {
-        return registry[key].installPath ?? null;
+    const session = await query({
+      prompt: `Summarize this agent work report in one concise sentence (max 120 chars). Focus on what was accomplished and the outcome. Output ONLY the summary sentence, nothing else.
+
+${reportText.slice(0, 3e3)}`,
+      options: {
+        model: "haiku",
+        maxTurns: 1
+      }
+    });
+    let text = "";
+    for await (const msg of session) {
+      if (msg.type === "assistant" && msg.message?.content) {
+        for (const block of msg.message.content) {
+          if (block.type === "text") text += block.text;
+        }
       }
     }
-  } catch {
-  }
-  return null;
-}
-function resolveAgentTypePath(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(join3(pluginDir, "agents", `${name}.md`));
-    const installPath = findPluginInstallPath(namespace);
-    if (installPath) {
-      searchPaths.push(join3(installPath, "agents", `${name}.md`));
+    const summary = text.trim();
+    return summary.length > 0 ? summary : null;
+  } catch (err) {
+    console.error(`[sisyphus] Haiku summarization failed: ${err instanceof Error ? err.message : err}`);
+    const status = err.status;
+    if (status === 401 || status === 403) {
+      disabled = true;
     }
-  } else {
-    searchPaths.push(join3(cwd, ".claude", "agents", `${name}.md`));
-    searchPaths.push(join3(homedir(), ".claude", "agents", `${name}.md`));
-    searchPaths.push(join3(pluginDir, "agents", `${name}.md`));
-  }
-  for (const path of searchPaths) {
-    if (existsSync3(path)) return path;
-  }
-  return null;
-}
-function resolveAgentConfig(agentType, pluginDir, cwd) {
-  const filePath = resolveAgentTypePath(agentType, pluginDir, cwd);
-  if (!filePath) return null;
-  try {
-    const content = readFileSync5(filePath, "utf-8");
-    return {
-      frontmatter: parseAgentFrontmatter(content),
-      body: extractAgentBody(content),
-      filePath
-    };
-  } catch {
     return null;
   }
 }
@@ -757,7 +1017,7 @@ function renderAgentSuffix(sessionId, instruction, worktreeContext) {
   const templatePath = resolve2(import.meta.dirname, "../templates/agent-suffix.md");
   let template;
   try {
-    template = readFileSync6(templatePath, "utf-8");
+    template = readFileSync5(templatePath, "utf-8");
   } catch {
     template = `# Sisyphus Agent
 Session: {{SESSION_ID}}
@@ -773,13 +1033,33 @@ Task: {{INSTRUCTION}}`;
   }
   return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{WORKTREE_CONTEXT\}\}/g, worktreeBlock);
 }
+function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
+  const base = `${promptsDir(cwd, sessionId)}/${agentId}-plugin`;
+  mkdirSync3(`${base}/.claude-plugin`, { recursive: true });
+  mkdirSync3(`${base}/agents`, { recursive: true });
+  mkdirSync3(`${base}/hooks`, { recursive: true });
+  writeFileSync3(
+    `${base}/.claude-plugin/plugin.json`,
+    JSON.stringify({ name: `sisyphus-agent-${agentId}`, version: "1.0.0" }),
+    "utf-8"
+  );
+  if (agentConfig?.filePath && agentType && agentType !== "worker") {
+    const shortName = agentType.replace(/^sisyphus:/, "");
+    copyFileSync2(agentConfig.filePath, `${base}/agents/${shortName}.md`);
+  }
+  const srcHooks = resolve2(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 pluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
-  const agentConfig = resolveAgentConfig(agentType, pluginPath, cwd);
+  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;
@@ -805,13 +1085,17 @@ async function spawnAgent(opts) {
   const suffixFilePath = `${promptsDir(cwd, sessionId)}/${agentId}-system.md`;
   writeFileSync3(suffixFilePath, suffix, "utf-8");
   const bannerPath = resolve2(import.meta.dirname, "../templates/banner.txt");
-  const bannerCmd = existsSync4(bannerPath) ? `cat '${bannerPath}' &&` : "";
+  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}'`,
-    ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : []
+    `export SISYPHUS_CWD='${cwd}'`,
+    ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : [],
+    `export PATH="${npmBinDir}:$PATH"`
   ].join(" && ");
-  const notifyCmd = `sisyphus notify pane-exited --pane-id ${paneId}`;
+  const notifyCmd = `node "${cliBin}" notify pane-exited --pane-id ${paneId}`;
   let mainCmd;
   if (provider === "openai") {
     const codexPromptPath = `${promptsDir(cwd, sessionId)}/${agentId}-codex-prompt.md`;
@@ -828,7 +1112,10 @@ ${instruction}`);
     mainCmd = `codex -m ${shellQuote3(model)} --dangerously-bypass-approvals-and-sandbox "$(cat '${codexPromptPath}')"`;
   } else {
     const agentFlag = agentType && agentType !== "worker" ? ` --agent ${shellQuote3(agentType)}` : "";
-    mainCmd = `claude --dangerously-skip-permissions --plugin-dir "${pluginPath}"${agentFlag} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote3(instruction)}`;
+    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 fullCmd = `${bannerCmd} ${envExports} && ${mainCmd}; ${notifyCmd}`;
   const agent = {
@@ -866,10 +1153,98 @@ ${instruction}`);
   }
   return agent;
 }
+async function restartAgent(sessionId, cwd, agentId, windowId) {
+  const session = getSession(cwd, sessionId);
+  const agent = session.agents.find((a) => a.id === agentId);
+  if (!agent) throw new Error(`Unknown agent: ${agentId}`);
+  if (agent.status === "running") {
+    const paneAlive = agent.paneId && paneExists(agent.paneId);
+    if (paneAlive) {
+      throw new Error(`Agent ${agentId} is already running`);
+    }
+    await updateAgent(cwd, sessionId, agentId, {
+      status: "lost",
+      killedReason: "pane disappeared (detected on restart)",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const { instruction, agentType, name, color } = agent;
+  const bundledPluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
+  const agentConfig = resolveAgentConfig(agentType, bundledPluginPath, cwd);
+  const provider = detectProvider(agentConfig?.frontmatter.model);
+  let paneCwd = cwd;
+  let worktreeContext;
+  if (agent.worktreePath) {
+    paneCwd = agent.worktreePath;
+    const portOffset = countWorktreeAgents(session.agents);
+    worktreeContext = {
+      offset: portOffset,
+      total: portOffset,
+      branchName: agent.branchName
+    };
+  }
+  if (agent.paneId) {
+    try {
+      killPane(agent.paneId);
+    } catch {
+    }
+    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 fullCmd = `${bannerCmd} ${envExports} && ${mainCmd}; ${notifyCmd}`;
+  await updateAgent(cwd, sessionId, agentId, {
+    status: "running",
+    paneId,
+    provider,
+    spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: null,
+    killedReason: void 0
+  });
+  sendKeys(paneId, fullCmd);
+}
 function nextReportNumber(cwd, sessionId, agentId) {
   const dir = reportsDir(cwd, sessionId);
   try {
-    const files = readdirSync3(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
+    const files = readdirSync5(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
     return String(files.length + 1).padStart(3, "0");
   } catch {
     return "001";
@@ -888,6 +1263,12 @@ async function handleAgentReport(cwd, sessionId, agentId, content) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   await appendAgentReport(cwd, sessionId, agentId, entry);
+  summarizeReport(content).then(async (aiSummary) => {
+    if (aiSummary) {
+      await updateReportSummary(cwd, sessionId, agentId, filePath, aiSummary);
+    }
+  }).catch(() => {
+  });
 }
 async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const dir = reportsDir(cwd, sessionId);
@@ -901,20 +1282,26 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   await appendAgentReport(cwd, sessionId, agentId, entry);
+  summarizeReport(report).then(async (aiSummary) => {
+    if (aiSummary) {
+      await updateReportSummary(cwd, sessionId, agentId, filePath, aiSummary);
+    }
+  }).catch(() => {
+  });
   await updateAgent(cwd, sessionId, agentId, {
     status: "completed",
     completedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   const session = getSession(cwd, sessionId);
-  const agentArr = session.agents;
-  const agent = agentArr.slice().reverse().find((a) => a.id === agentId);
-  if (agent) {
-    unregisterPane(agent.paneId);
-    killPane(agent.paneId);
+  const agent = session.agents.find((a) => a.id === agentId);
+  if (agent?.paneId) {
+    unregisterAgentPane(sessionId, agentId);
+    try {
+      killPane(agent.paneId);
+    } catch {
+    }
   }
-  const windowId = getWindowId(sessionId);
-  if (windowId) selectLayout(windowId);
-  return allAgentsDone(session);
+  return allAgentsDone(getSession(cwd, sessionId));
 }
 async function handleAgentKilled(cwd, sessionId, agentId, reason) {
   unregisterAgentPane(sessionId, agentId);
@@ -1000,7 +1387,15 @@ async function pollSession(sessionId, cwd, windowId) {
   }
   if (session.status !== "active") return;
   const livePanes = listPanes(windowId);
-  if (livePanes.length === 0) return;
+  if (livePanes.length === 0) {
+    const tracked = trackedSessions.get(sessionId);
+    if (tracked && !sessionExists(tracked.tmuxSession)) {
+      await updateSessionStatus(cwd, sessionId, "paused");
+      untrackSession(sessionId);
+      console.log(`[sisyphus] Session ${sessionId} paused: tmux session destroyed`);
+    }
+    return;
+  }
   const livePaneIds = new Set(livePanes.map((p) => p.paneId));
   let paneRemoved = false;
   for (const agent of session.agents) {
@@ -1030,23 +1425,34 @@ async function pollSession(sessionId, cwd, windowId) {
 }
 
 // src/daemon/session-manager.ts
-async function startSession(task, cwd, tmuxSession, windowId, context) {
+var NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+async function startSession(task, cwd, context, name) {
   const sessionId = uuidv4();
-  const session = createSession(sessionId, task, cwd, context);
-  await updateSessionTmux(cwd, sessionId, tmuxSession, windowId);
-  trackSession(sessionId, cwd, tmuxSession);
+  if (name && !NAME_PATTERN.test(name)) {
+    throw new Error(`Invalid session name "${name}": only alphanumeric, hyphens, and underscores allowed`);
+  }
+  const tmuxName = `sisyphus-${name ?? sessionId.slice(0, 8)}`;
+  if (sessionExists(tmuxName)) {
+    throw new Error(`Tmux session "${tmuxName}" already exists. Choose a different name.`);
+  }
+  const session = createSession(sessionId, task, cwd, context, name);
+  const { windowId, initialPaneId } = createSession2(tmuxName, "main", cwd);
+  setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
+  await updateSessionTmux(cwd, sessionId, tmuxName, windowId);
+  trackSession(sessionId, cwd, tmuxName);
   await spawnOrchestrator(sessionId, cwd, windowId);
   updateTrackedWindow(sessionId, windowId);
+  killPane(initialPaneId);
   pruneOldSessions(cwd);
-  return session;
+  return { ...getSession(cwd, sessionId), tmuxSessionName: tmuxName };
 }
 var PRUNE_KEEP_COUNT = 10;
 var PRUNE_KEEP_DAYS = 7;
 function pruneOldSessions(cwd) {
   try {
     const dir = sessionsDir(cwd);
-    if (!existsSync5(dir)) return;
-    const entries = readdirSync4(dir, { withFileTypes: true });
+    if (!existsSync6(dir)) return;
+    const entries = readdirSync6(dir, { withFileTypes: true });
     const candidates = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
@@ -1069,14 +1475,25 @@ function pruneOldSessions(cwd) {
     }
     for (const c of candidates) {
       if (keep.has(c.id)) continue;
-      rmSync2(sessionDir(cwd, c.id), { recursive: true, force: true });
+      rmSync3(sessionDir(cwd, c.id), { recursive: true, force: true });
     }
   } catch (err) {
     console.error("[sisyphus] Session pruning failed:", err);
   }
 }
-async function resumeSession(sessionId, cwd, tmuxSession, windowId, message) {
+async function resumeSession(sessionId, cwd, message) {
   const session = getSession(cwd, sessionId);
+  const tmuxName = session.tmuxSessionName ?? `sisyphus-${sessionId.slice(0, 8)}`;
+  let windowId;
+  if (sessionExists(tmuxName) && session.tmuxWindowId) {
+    windowId = session.tmuxWindowId;
+  } else {
+    const created = createSession2(tmuxName, "main", cwd);
+    setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
+    windowId = created.windowId;
+    await updateSessionTmux(cwd, sessionId, tmuxName, windowId);
+    var initialPaneId = created.initialPaneId;
+  }
   if (session.status !== "active") {
     const livePaneIds = /* @__PURE__ */ new Set();
     if (session.tmuxWindowId) {
@@ -1099,12 +1516,16 @@ async function resumeSession(sessionId, cwd, tmuxSession, windowId, message) {
     }
   }
   await updateSessionStatus(cwd, sessionId, "active");
-  await updateSessionTmux(cwd, sessionId, tmuxSession, windowId);
+  await updateSessionTmux(cwd, sessionId, tmuxName, windowId);
   resetAgentCounterFromState(sessionId, session.agents);
   resetColors(sessionId);
-  trackSession(sessionId, cwd, tmuxSession);
+  orchestratorDone.delete(sessionId);
+  trackSession(sessionId, cwd, tmuxName);
   await spawnOrchestrator(sessionId, cwd, windowId, message);
   updateTrackedWindow(sessionId, windowId);
+  if (initialPaneId) {
+    killPane(initialPaneId);
+  }
   return getSession(cwd, sessionId);
 }
 function getSessionStatus(cwd, sessionId) {
@@ -1112,8 +1533,8 @@ function getSessionStatus(cwd, sessionId) {
 }
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync5(dir)) return [];
-  const entries = readdirSync4(dir, { withFileTypes: true });
+  if (!existsSync6(dir)) return [];
+  const entries = readdirSync6(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -1121,10 +1542,13 @@ function listSessions(cwd) {
       const session = getSession(cwd, entry.name);
       sessions.push({
         id: session.id,
+        name: session.name,
         task: session.task,
         status: session.status,
         createdAt: session.createdAt,
-        agentCount: session.agents.length
+        agentCount: session.agents.length,
+        tmuxSessionName: session.tmuxSessionName,
+        tmuxWindowId: session.tmuxWindowId
       });
     } catch (err) {
       console.error(`[sisyphus] Failed to read session ${entry.name}:`, err);
@@ -1133,11 +1557,17 @@ function listSessions(cwd) {
   return sessions;
 }
 var pendingRespawns = /* @__PURE__ */ new Set();
+var orchestratorDone = /* @__PURE__ */ new Set();
 function onAllAgentsDone2(sessionId, cwd, windowId) {
   if (pendingRespawns.has(sessionId)) return;
+  if (!orchestratorDone.has(sessionId)) {
+    console.log(`[sisyphus] All agents done for session ${sessionId}, waiting for orchestrator to yield`);
+    return;
+  }
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") return;
   pendingRespawns.add(sessionId);
+  orchestratorDone.delete(sessionId);
   const worktreeAgents = session.agents.filter((a) => a.worktreePath && a.mergeStatus === "pending");
   if (worktreeAgents.length > 0) {
     const results = mergeWorktrees(cwd, worktreeAgents);
@@ -1149,9 +1579,42 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
       }).catch((err) => console.error(`[sisyphus] Failed to update merge status for ${result.agentId}:`, err));
     }
   }
-  setImmediate(() => {
+  const cycleNumber = session.orchestratorCycles.length;
+  if (cycleNumber > 0) {
+    createSnapshot(cwd, sessionId, cycleNumber);
+  }
+  setImmediate(async () => {
     pendingRespawns.delete(sessionId);
-    spawnOrchestrator(sessionId, cwd, windowId).then(() => updateTrackedWindow(sessionId, windowId)).catch((err) => console.error(`[sisyphus] Failed to respawn orchestrator for session ${sessionId}:`, err));
+    try {
+      const freshSession = getSession(cwd, sessionId);
+      if (freshSession.status !== "active") return;
+      let activeWindowId = windowId;
+      const tmuxName = freshSession.tmuxSessionName;
+      const needsRecreation = tmuxName && (!sessionExists(tmuxName) || listPanes(activeWindowId).length === 0);
+      let initialPaneId;
+      if (needsRecreation) {
+        if (sessionExists(tmuxName)) {
+          killSession(tmuxName);
+        }
+        const created = createSession2(tmuxName, "main", cwd);
+        setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
+        activeWindowId = created.windowId;
+        initialPaneId = created.initialPaneId;
+        await updateSessionTmux(cwd, sessionId, tmuxName, activeWindowId);
+        trackSession(sessionId, cwd, tmuxName);
+      }
+      await spawnOrchestrator(sessionId, cwd, activeWindowId);
+      updateTrackedWindow(sessionId, activeWindowId);
+      if (initialPaneId) killPane(initialPaneId);
+      for (const agent of freshSession.agents) {
+        if (agent.status !== "running" && agent.paneId) {
+          killPane(agent.paneId);
+        }
+      }
+      selectLayout(activeWindowId);
+    } catch (err) {
+      console.error(`[sisyphus] Failed to respawn orchestrator for session ${sessionId}:`, err);
+    }
   });
 }
 async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktree) {
@@ -1183,16 +1646,17 @@ async function handleSubmit(cwd, sessionId, agentId, report, windowId) {
 async function handleReport(cwd, sessionId, agentId, content) {
   await handleAgentReport(cwd, sessionId, agentId, content);
 }
-async function handleYield(sessionId, cwd, nextPrompt) {
+async function handleYield(sessionId, cwd, nextPrompt, mode) {
   const pre = getSession(cwd, sessionId);
   if (pre.status === "paused") {
     await updateSessionStatus(cwd, sessionId, "active");
   }
-  await handleOrchestratorYield(sessionId, cwd, nextPrompt);
+  await handleOrchestratorYield(sessionId, cwd, nextPrompt, mode);
+  orchestratorDone.add(sessionId);
   const session = getSession(cwd, sessionId);
   const hasRunningAgents = session.agents.some((a) => a.status === "running");
   if (!hasRunningAgents) {
-    const windowId = getWindowId(sessionId);
+    const windowId = getWindowId(sessionId) ?? session.tmuxWindowId;
     if (windowId) {
       onAllAgentsDone2(sessionId, cwd, windowId);
     }
@@ -1201,6 +1665,9 @@ async function handleYield(sessionId, cwd, nextPrompt) {
 async function handleComplete(sessionId, cwd, report) {
   await handleOrchestratorComplete(sessionId, cwd, report);
 }
+async function handleContinue(sessionId, cwd) {
+  await continueSession(cwd, sessionId);
+}
 async function handleRegisterClaudeSession(cwd, sessionId, agentId, claudeSessionId) {
   await updateAgent(cwd, sessionId, agentId, { claudeSessionId });
 }
@@ -1230,12 +1697,81 @@ async function handleKill(sessionId, cwd) {
   await updateSessionStatus(cwd, sessionId, "completed");
   untrackSession(sessionId);
   unregisterSessionPanes(sessionId);
-  if (windowId) {
+  if (session.tmuxSessionName) {
+    killSession(session.tmuxSessionName);
+  } else if (windowId) {
     killWindow(windowId);
   }
   clearAgentCounter(sessionId);
+  orchestratorDone.delete(sessionId);
   return killedAgents;
 }
+async function handleRestartAgent(sessionId, cwd, agentId) {
+  const session = getSession(cwd, sessionId);
+  const agent = session.agents.find((a) => a.id === agentId);
+  if (!agent) throw new Error(`Unknown agent: ${agentId}`);
+  const windowId = getWindowId(sessionId) ?? session.tmuxWindowId;
+  if (!windowId) throw new Error(`No tmux window found for session ${sessionId}`);
+  await restartAgent(sessionId, cwd, agentId, windowId);
+}
+async function handleKillAgent(sessionId, cwd, agentId) {
+  const session = getSession(cwd, sessionId);
+  const agent = session.agents.find((a) => a.id === agentId);
+  if (!agent) throw new Error(`Unknown agent: ${agentId}`);
+  if (agent.status !== "running") throw new Error(`Agent ${agentId} is not running (status: ${agent.status})`);
+  unregisterAgentPane(sessionId, agentId);
+  if (agent.paneId) {
+    killPane(agent.paneId);
+  }
+  if (agent.worktreePath && agent.branchName) {
+    cleanupWorktree(cwd, agent.worktreePath, agent.branchName);
+  }
+  await updateAgent(cwd, sessionId, agentId, {
+    status: "killed",
+    killedReason: "killed by user",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function handleRollback(sessionId, cwd, toCycle) {
+  const session = getSession(cwd, sessionId);
+  if (toCycle < 1 || toCycle > session.orchestratorCycles.length) {
+    const available2 = listSnapshots(cwd, sessionId);
+    throw new Error(
+      `Invalid cycle ${toCycle}. Available snapshots: ${available2.length > 0 ? available2.join(", ") : "none"}`
+    );
+  }
+  const available = listSnapshots(cwd, sessionId);
+  if (!available.includes(toCycle)) {
+    throw new Error(
+      `No snapshot for cycle ${toCycle}. Available snapshots: ${available.length > 0 ? available.join(", ") : "none"}`
+    );
+  }
+  for (const agent of session.agents) {
+    if (agent.status === "running") {
+      await updateAgent(cwd, sessionId, agent.id, {
+        status: "killed",
+        killedReason: "session rolled back",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  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);
+  }
+  untrackSession(sessionId);
+  unregisterSessionPanes(sessionId);
+  clearAgentCounter(sessionId);
+  orchestratorDone.delete(sessionId);
+  await restoreSnapshot(cwd, sessionId, toCycle);
+  deleteSnapshotsAfter(cwd, sessionId, toCycle);
+  return { sessionId, restoredToCycle: toCycle };
+}
 async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") return;
@@ -1244,15 +1780,16 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
     if (!agent || agent.status !== "running") return;
     const allDone = await handleAgentKilled(cwd, sessionId, agentId, "pane exited");
     if (allDone) {
-      const windowId = getWindowId(sessionId);
+      const windowId = getWindowId(sessionId) ?? session.tmuxWindowId;
       if (windowId) {
         onAllAgentsDone2(sessionId, cwd, windowId);
       }
     }
   } else if (role === "orchestrator") {
+    orchestratorDone.add(sessionId);
     const hasRunningAgents = session.agents.some((a) => a.status === "running");
     if (!hasRunningAgents && session.agents.length > 0) {
-      const windowId = getWindowId(sessionId);
+      const windowId = getWindowId(sessionId) ?? session.tmuxWindowId;
       if (windowId) {
         console.log(`[sisyphus] Orchestrator pane exited for session ${sessionId}, all agents done \u2014 triggering respawn`);
         onAllAgentsDone2(sessionId, cwd, windowId);
@@ -1267,10 +1804,11 @@ 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();
 function registryPath() {
-  return join4(globalDir(), "session-registry.json");
+  return join5(globalDir(), "session-registry.json");
 }
 function persistSessionRegistry() {
   const dir = globalDir();
@@ -1283,9 +1821,9 @@ function persistSessionRegistry() {
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync6(p)) return {};
+  if (!existsSync7(p)) return {};
   try {
-    return JSON.parse(readFileSync7(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return {};
   }
@@ -1302,11 +1840,11 @@ async function handleRequest(req) {
   try {
     switch (req.type) {
       case "start": {
-        const session = await startSession(req.task, req.cwd, req.tmuxSession, req.tmuxWindow, req.context);
+        const session = await startSession(req.task, req.cwd, req.context, req.name);
         registerSessionCwd(session.id, req.cwd);
-        sessionTmuxMap.set(session.id, req.tmuxSession);
-        sessionWindowMap2.set(session.id, req.tmuxWindow);
-        return { ok: true, data: { sessionId: session.id } };
+        if (session.tmuxSessionName) sessionTmuxMap.set(session.id, session.tmuxSessionName);
+        if (session.tmuxWindowId) sessionWindowMap2.set(session.id, session.tmuxWindowId);
+        return { ok: true, data: { sessionId: session.id, tmuxSessionName: session.tmuxSessionName } };
       }
       case "spawn": {
         const cwd = sessionCwdMap.get(req.sessionId);
@@ -1331,7 +1869,7 @@ async function handleRequest(req) {
       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);
+        await handleYield(req.sessionId, cwd, req.nextPrompt, req.mode);
         return { ok: true };
       }
       case "complete": {
@@ -1340,9 +1878,15 @@ async function handleRequest(req) {
         await handleComplete(req.sessionId, 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);
+        return { ok: true };
+      }
       case "status": {
         if (req.sessionId) {
-          const cwd = sessionCwdMap.get(req.sessionId);
+          const cwd = sessionCwdMap.get(req.sessionId) ?? req.cwd;
           if (!cwd) return { ok: false, error: `Unknown session: ${req.sessionId}` };
           const session = getSessionStatus(cwd, req.sessionId);
           return { ok: true, data: { session } };
@@ -1379,17 +1923,17 @@ async function handleRequest(req) {
         let cwd = sessionCwdMap.get(req.sessionId);
         if (!cwd) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync6(stateFile)) {
+          if (existsSync7(stateFile)) {
             cwd = req.cwd;
             registerSessionCwd(req.sessionId, cwd);
           } else {
             return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json found at ${stateFile}` };
           }
         }
-        sessionTmuxMap.set(req.sessionId, req.tmuxSession);
-        sessionWindowMap2.set(req.sessionId, req.tmuxWindow);
-        const session = await resumeSession(req.sessionId, cwd, req.tmuxSession, req.tmuxWindow, req.message);
-        return { ok: true, data: { sessionId: session.id, status: session.status } };
+        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);
+        return { ok: true, data: { sessionId: session.id, status: session.status, tmuxSessionName: session.tmuxSessionName } };
       }
       case "register_claude_session": {
         const cwd = sessionCwdMap.get(req.sessionId);
@@ -1407,6 +1951,49 @@ async function handleRequest(req) {
         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);
+        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);
+        return { ok: true, data: { agentId: req.agentId } };
+      }
+      case "rollback": {
+        let cwd = sessionCwdMap.get(req.sessionId);
+        if (!cwd) {
+          const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
+          if (existsSync7(stateFile)) {
+            cwd = req.cwd;
+            registerSessionCwd(req.sessionId, cwd);
+          } else {
+            return { ok: false, error: `Unknown session: ${req.sessionId}` };
+          }
+        }
+        const result = await handleRollback(req.sessionId, cwd, req.toCycle);
+        return { ok: true, data: result };
+      }
+      case "delete": {
+        const activeCwd = sessionCwdMap.get(req.sessionId);
+        if (activeCwd) {
+          try {
+            await handleKill(req.sessionId, activeCwd);
+          } catch {
+          }
+          sessionCwdMap.delete(req.sessionId);
+          sessionTmuxMap.delete(req.sessionId);
+          sessionWindowMap2.delete(req.sessionId);
+          sessionMessageCounters.delete(req.sessionId);
+          persistSessionRegistry();
+        }
+        const { sessionDir: sessionDir2 } = await import("./paths-FYYSBD27.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 };
@@ -1419,6 +2006,37 @@ async function handleRequest(req) {
         await handlePaneExited(req.paneId, 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);
+        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 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);
+          mkdirSync4(dir, { recursive: true });
+          filePath = join5(dir, `${id}.md`);
+          writeFileSync4(filePath, req.content, "utf-8");
+        }
+        await appendMessage(cwd, req.sessionId, {
+          id,
+          source,
+          content: req.content,
+          summary,
+          ...filePath ? { filePath } : {},
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return { ok: true };
+      }
       default:
         return { ok: false, error: `Unknown request type: ${req.type}` };
     }
@@ -1430,7 +2048,7 @@ async function handleRequest(req) {
 function startServer() {
   return new Promise((resolve4, reject) => {
     const sock = socketPath();
-    if (existsSync6(sock)) {
+    if (existsSync7(sock)) {
       unlinkSync(sock);
     }
     server = createServer((conn) => {
@@ -1472,7 +2090,7 @@ function stopServer() {
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync6(sock)) {
+      if (existsSync7(sock)) {
         unlinkSync(sock);
       }
       server = null;
@@ -1483,7 +2101,7 @@ function stopServer() {
 
 // src/daemon/updater.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2 } from "fs";
 import { resolve as resolve3 } from "path";
 import { get } from "https";
 function isNewer(latest, current) {
@@ -1500,7 +2118,7 @@ function isNewer(latest, current) {
 function readPackageVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync8(resolve3(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync7(resolve3(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -1607,7 +2225,7 @@ function isProcessAlive(pid) {
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync9(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -1678,15 +2296,23 @@ async function recoverSessions() {
   let recovered = 0;
   for (const [sessionId, cwd] of entries) {
     const stateFile = statePath(cwd, sessionId);
-    if (!existsSync7(stateFile)) {
+    if (!existsSync8(stateFile)) {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync9(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) {
+          if (!sessionExists(session.tmuxSessionName)) {
+            if (session.status === "active") {
+              await updateSessionStatus(cwd, sessionId, "paused");
+              console.log(`[sisyphus] Session ${sessionId} paused: tmux session no longer exists`);
+            }
+            recovered++;
+            continue;
+          }
           const livePanes = listPanes(session.tmuxWindowId);
           if (livePanes.length > 0) {
             registerSessionTmux(sessionId, session.tmuxSessionName, session.tmuxWindowId);