sisyphi 1.0.13 → 1.1.0

package/dist/daemon.js

@@ -5,7 +5,7 @@ import {
   execEnv,
   execSafe,
   loadConfig
-} from "./chunk-LWWRGQWM.js";
+} from "./chunk-Z32YVDMY.js";
 import {
   shellQuote
 } from "./chunk-6G226ZK7.js";
@@ -30,23 +30,22 @@ import {
   snapshotsDir,
   socketPath,
   statePath,
-  worktreeBaseDir,
-  worktreeConfigPath
-} from "./chunk-JXKUI4P6.js";
+  strategyPath
+} from "./chunk-REUQ4B45.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, existsSync as existsSync9 } from "fs";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync8, writeFileSync as writeFileSync5, readFileSync as readFileSync6, mkdirSync as mkdirSync4, rmSync as rmSync4 } from "fs";
-import { join as join6 } from "path";
+import { unlinkSync, existsSync as existsSync7, writeFileSync as writeFileSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync3, rmSync as rmSync3 } from "fs";
+import { join as join5 } from "path";
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync7, readdirSync as readdirSync6, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync5, rmSync as rmSync2 } from "fs";
 
 // src/daemon/state.ts
 import { randomUUID } from "crypto";
@@ -91,6 +90,9 @@ function createSession(id, task, cwd, context, name) {
   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");
+  if (context) {
+    writeFileSync(join(contextDir(cwd, id), "initial-context.md"), context, "utf-8");
+  }
   const session = {
     id,
     ...name ? { name } : {},
@@ -99,6 +101,7 @@ function createSession(id, task, cwd, context, name) {
     cwd,
     status: "active",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    activeMs: 0,
     agents: [],
     orchestratorCycles: [],
     messages: []
@@ -108,7 +111,16 @@ function createSession(id, task, cwd, context, name) {
 }
 function getSession(cwd, sessionId) {
   const content = readFileSync(statePath(cwd, sessionId), "utf-8");
-  return JSON.parse(content);
+  const session = JSON.parse(content);
+  if (session.activeMs == null) session.activeMs = 0;
+  for (const agent of session.agents) {
+    if (!agent.repo) agent.repo = ".";
+    if (agent.activeMs == null) agent.activeMs = 0;
+  }
+  for (const cycle of session.orchestratorCycles) {
+    if (cycle.activeMs == null) cycle.activeMs = 0;
+  }
+  return session;
 }
 function saveSession(session) {
   atomicWrite(statePath(session.cwd, session.id), JSON.stringify(session, null, 2));
@@ -202,6 +214,13 @@ async function updateReportSummary(cwd, sessionId, agentId, filePath, summary) {
     }
   });
 }
+async function updateSessionName(cwd, sessionId, name) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.name = name;
+    saveSession(session);
+  });
+}
 async function updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -234,15 +253,32 @@ async function updateTask(cwd, sessionId, task) {
     writeFileSync(goalPath(cwd, sessionId), task, "utf-8");
   });
 }
-async function completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode) {
+async function completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode, activeMs) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
     const cycles = session.orchestratorCycles;
     if (cycles.length === 0) return;
     const cycle = cycles[cycles.length - 1];
+    if (cycle.completedAt) return;
     cycle.completedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (nextPrompt) cycle.nextPrompt = nextPrompt;
     if (mode) cycle.mode = mode;
+    if (activeMs != null) cycle.activeMs += activeMs;
+    saveSession(session);
+  });
+}
+async function incrementActiveTime(cwd, sessionId, sessionDelta, agentDeltas, cycleDeltas) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.activeMs += sessionDelta;
+    for (const [agentId, delta] of agentDeltas) {
+      const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+      if (agent) agent.activeMs += delta;
+    }
+    for (const [cycleNum, delta] of cycleDeltas) {
+      const cycle = session.orchestratorCycles.find((c) => c.cycle === cycleNum);
+      if (cycle) cycle.activeMs += delta;
+    }
     saveSession(session);
   });
 }
@@ -300,9 +336,10 @@ function deleteSnapshotsAfter(cwd, sessionId, afterCycle) {
 }
 
 // src/daemon/orchestrator.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { execSync } from "child_process";
-import { resolve as resolve2, join as join3 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { randomUUID as randomUUID3 } from "crypto";
+import { resolve as resolve3, join as join4 } from "path";
 
 // src/daemon/spawn-helpers.ts
 import { writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
@@ -375,6 +412,8 @@ function parseAgentFrontmatter(content) {
   fm.description = str("description");
   fm.permissionMode = str("permissionMode");
   fm.effort = str("effort");
+  const interactive = str("interactive");
+  if (interactive === "true") fm.interactive = true;
   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);
@@ -521,6 +560,9 @@ function sessionExists(sessionName) {
 function killSession(sessionName) {
   execSafe(`tmux kill-session -t "${sessionName}"`);
 }
+function renameSession(oldName, newName) {
+  exec(`tmux rename-session -t "${oldName}" "${newName}"`);
+}
 function setSessionOption(sessionName, option, value) {
   execSafe(`tmux set-option -t "${sessionName}" ${option} ${shellQuote(value)}`);
 }
@@ -554,15 +596,30 @@ function listPanes(windowTarget) {
 function setPaneTitle(paneTarget, title) {
   execSafe(`tmux select-pane -t "${paneTarget}" -T ${shellQuote(title)}`);
 }
-function setPaneStyle(paneTarget, color) {
+function setPaneStyle(paneTarget, color, meta) {
   const gitBranch = `#(cd #{pane_current_path} && git branch --show-current 2>/dev/null)`;
   const branchSuffix = `#(cd #{pane_current_path} && git branch --show-current 2>/dev/null | grep -q . && echo ' |') ${gitBranch}`;
-  const fmt = `#[fg=${color},bold] #{pane_title} #[fg=${color}]#{pane_current_path}${branchSuffix} #[default]`;
+  const homePath = `#(echo '#{pane_current_path}' | sed "s|^$HOME|~|")`;
+  execSafe(`tmux set -p -t "${paneTarget}" @pane_role ${shellQuote(meta.role)}`);
+  execSafe(`tmux set -p -t "${paneTarget}" @pane_session ${shellQuote(meta.session)}`);
+  execSafe(`tmux set -p -t "${paneTarget}" @pane_cycle ${shellQuote(meta.cycle)}`);
+  const fmt = [
+    `#[bg=${color},fg=black,bold] #{@pane_role} #[default]`,
+    ` #[fg=${color},bold]#{@pane_session}`,
+    ` #[default,dim]#{@pane_cycle}`,
+    `  ${homePath}${branchSuffix}`,
+    `#[default]`
+  ].join("");
   execSafe(`tmux set -p -t "${paneTarget}" pane-border-format ${shellQuote(fmt)}`);
   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 updatePaneMeta(paneTarget, updates) {
+  if (updates.role !== void 0) execSafe(`tmux set -p -t "${paneTarget}" @pane_role ${shellQuote(updates.role)}`);
+  if (updates.session !== void 0) execSafe(`tmux set -p -t "${paneTarget}" @pane_session ${shellQuote(updates.session)}`);
+  if (updates.cycle !== void 0) execSafe(`tmux set -p -t "${paneTarget}" @pane_cycle ${shellQuote(updates.cycle)}`);
+}
 function selectLayout(windowTarget, layout = "even-horizontal") {
   execSafe(`tmux select-layout -t "${windowTarget}" ${layout}`);
 }
@@ -600,401 +657,61 @@ function unregisterSessionPanes(sessionId) {
 function lookupPane(paneId) {
   return paneMap.get(paneId);
 }
-
-// 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, mode) {
-  const projectPath = projectOrchestratorPromptPath(cwd);
-  if (existsSync4(projectPath)) {
-    return readFileSync3(projectPath, "utf-8");
-  }
-  const basePath = resolve2(import.meta.dirname, "../templates/orchestrator-base.md");
-  const base = readFileSync3(basePath, "utf-8");
-  if (mode === "implementation") {
-    const implPath = resolve2(import.meta.dirname, "../templates/orchestrator-impl.md");
-    return base + "\n\n" + readFileSync3(implPath, "utf-8");
-  }
-  const planningPath = resolve2(import.meta.dirname, "../templates/orchestrator-planning.md");
-  return base + "\n\n" + readFileSync3(planningPath, "utf-8");
-}
-function formatStateForOrchestrator(session) {
-  const cycleNum = session.orchestratorCycles.length;
-  const ctxDir = contextDir(session.cwd, session.id);
-  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 {
-    let ctxFiles = [];
-    if (existsSync4(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)"}`;
-    });
-    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 agentLines = lastCycle.agentsSpawned.map((id) => {
-      const agent = agentMap.get(id);
-      if (!agent) return `- **${id}**: unknown (no agent data)`;
-      const finalReport = agent.reports.find((r) => r.type === "final");
-      const reportToUse = finalReport ?? agent.reports[agent.reports.length - 1];
-      const reportRef = reportToUse ? `@${reportToUse.filePath}` : "(no reports)";
-      return `- **${id}** (${agent.name}) [${agent.status}]: ${reportRef}`;
-    }).join("\n");
-    mostRecentCycleSection = `
-### Most Recent Cycle
-
-${agentLines}
-`;
-  }
-  const roadmapRef = existsSync4(roadmapFile) ? `@${roadmapFile}` : "(empty)";
-  const worktreeAgents = session.agents.filter((a) => a.worktreePath);
-  let worktreeSection = "";
-  if (worktreeAgents.length > 0 || existsSync4(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");
+function getSessionPanes(sessionId) {
+  const result = [];
+  for (const [paneId, entry] of paneMap) {
+    if (entry.sessionId === sessionId) {
+      result.push({ paneId, ...entry });
     }
-    const worktreeHint = existsSync4(worktreeConfigPath(session.cwd)) ? "Worktree config active (`.sisyphus/worktree.json`). Use `--worktree` flag with `sisyphus spawn` to isolate agents in their own worktrees. Recommended for feature work, especially with potential file overlap." : "No worktree configuration found. If this session involves parallel work where agents may edit overlapping files, use the `git-management` skill to set up `.sisyphus/worktree.json` and enable worktree isolation.";
-    worktreeSection = `
-
-## Git Worktrees
-
-${worktreeHint}${wtLines}`;
   }
-  const goalFile = goalPath(session.cwd, session.id);
-  const goalContent = existsSync4(goalFile) ? readFileSync3(goalFile, "utf-8").trim() : session.task;
-  return `## Goal
-
-${goalContent}
-${contextSection}${messagesSection}
-### Cycle Log
-
-Write your cycle summary to: ${logFile}
-${previousCyclesSection}${mostRecentCycleSection}
-## Roadmap
-
-${roadmapRef}
-${worktreeSection}`;
-}
-async function spawnOrchestrator(sessionId, cwd, windowId, message) {
-  try {
-    execSync("which claude", { stdio: "pipe", env: EXEC_ENV });
-  } catch {
-    throw new Error("Claude CLI not found on PATH. Run `sisyphus doctor` to diagnose.");
-  }
-  const session = getSession(cwd, sessionId);
-  const lastCycle = [...session.orchestratorCycles].reverse().find((c) => c.completedAt);
-  const mode = lastCycle?.mode ?? "planning";
-  const basePrompt = loadOrchestratorPrompt(cwd, mode);
-  const formattedState = formatStateForOrchestrator(session);
-  const agentPluginPath = resolve2(import.meta.dirname, "../templates/agent-plugin");
-  const agentTypes = discoverAgentTypes(agentPluginPath, session.cwd);
-  agentTypes.push(
-    { qualifiedName: "Explore", source: "bundled", model: "haiku", description: "Fast codebase exploration \u2014 find files, search code, answer questions about architecture. Use for research and context gathering." }
-  );
-  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`;
-  writeFileSync3(promptFilePath, systemPrompt, "utf-8");
-  sessionWindowMap.set(sessionId, windowId);
-  const npmBinDir = resolveNpmBinDir();
-  const envExports = buildEnvExports([
-    `export SISYPHUS_SESSION_ID='${sessionId}'`,
-    `export SISYPHUS_AGENT_ID='orchestrator'`,
-    `export SISYPHUS_CWD='${cwd}'`,
-    `export PATH="${npmBinDir}:$PATH"`
-  ]);
-  let userPrompt = formattedState;
-  if (message) {
-    userPrompt += `
-
-## Continuation Instructions
-
-The user resumed this session with new instructions: ${message}`;
-  } else {
-    const storedPrompt = lastCycle?.nextPrompt;
-    const continuationText = storedPrompt ? storedPrompt : "Review the current session and delegate the next cycle of work.";
-    userPrompt += `
-
-## Continuation Instructions
-
-${continuationText}`;
-  }
-  const userPromptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
-  writeFileSync3(userPromptFilePath, userPrompt, "utf-8");
-  if (session.messages && session.messages.length > 0) {
-    await drainMessages(cwd, sessionId, session.messages.length);
-  }
-  const pluginPath = resolve2(import.meta.dirname, "../templates/orchestrator-plugin");
-  const settingsPath = resolve2(import.meta.dirname, "../templates/orchestrator-settings.json");
-  const config = loadConfig(cwd);
-  const effort = config.orchestratorEffort ?? "high";
-  const claudeCmd = `claude --dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --settings "${settingsPath}" --plugin-dir "${pluginPath}" --name "sisyphus:orch-${sessionId.slice(0, 8)}-cycle-${cycleNum}" --system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
-  const paneId = createPane(windowId, cwd, "left");
-  sessionOrchestratorPane.set(sessionId, paneId);
-  registerPane(paneId, sessionId, "orchestrator");
-  setPaneTitle(paneId, `Sisyphus`);
-  setPaneStyle(paneId, ORCHESTRATOR_COLOR);
-  const bannerCmd = resolveBannerCmd();
-  const notifyCmd = buildNotifyCmd(paneId);
-  const scriptPath = writeRunScript(promptsDir(cwd, sessionId), `orchestrator-run-${cycleNum}`, [
-    "#!/usr/bin/env bash",
-    ...bannerCmd ? [bannerCmd] : [],
-    envExports,
-    claudeCmd,
-    notifyCmd
-  ]);
-  sendKeys(paneId, `bash '${scriptPath}'`);
-  await addOrchestratorCycle(cwd, sessionId, {
-    cycle: cycleNum,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    agentsSpawned: [],
-    paneId
-  });
-}
-function resolveOrchestratorPane(sessionId, cwd) {
-  const memPane = sessionOrchestratorPane.get(sessionId);
-  if (memPane) return memPane;
-  const session = getSession(cwd, sessionId);
-  const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
-  return lastCycle?.paneId ?? void 0;
-}
-async function handleOrchestratorYield(sessionId, cwd, nextPrompt, mode) {
-  const paneId = resolveOrchestratorPane(sessionId, cwd);
-  if (paneId) {
-    killPane(paneId);
-    unregisterPane(paneId);
-    sessionOrchestratorPane.delete(sessionId);
-  }
-  const windowId = sessionWindowMap.get(sessionId);
-  if (windowId) selectLayout(windowId);
-  await completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode);
-  const session = getSession(cwd, sessionId);
-  const runningAgents = session.agents.filter((a) => a.status === "running");
-  if (runningAgents.length === 0) {
-    console.log(`[sisyphus] Orchestrator yielded with no running agents for session ${sessionId}`);
-  }
-}
-async function handleOrchestratorComplete(sessionId, cwd, report) {
-  await completeOrchestratorCycle(cwd, sessionId);
-  await completeSession(cwd, sessionId, report);
-  console.log(`[sisyphus] Session ${sessionId} completed: ${report}`);
-}
-function cleanupSessionMaps(sessionId) {
-  sessionOrchestratorPane.delete(sessionId);
-  sessionWindowMap.delete(sessionId);
-  unregisterSessionPanes(sessionId);
+  return result;
 }
 
 // src/daemon/agent.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, copyFileSync as copyFileSync2, mkdirSync as mkdirSync3, readdirSync as readdirSync5, existsSync as existsSync6 } from "fs";
-import { execSync as execSync2 } from "child_process";
-import { resolve as resolve3, dirname as dirname3, join as join5 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, copyFileSync as copyFileSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync3, existsSync as existsSync4 } from "fs";
+import { execSync } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { resolve as resolve2, dirname as dirname2, join as join3 } from "path";
 
-// src/daemon/worktree.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
-import { dirname as dirname2, join as join4 } from "path";
-function loadWorktreeConfig(cwd) {
+// src/daemon/summarize.ts
+import { query } from "@r-cli/sdk";
+var COOLDOWN_MS = 5 * 60 * 1e3;
+var disabledUntil = 0;
+async function generateSessionName(task) {
+  if (Date.now() < disabledUntil) return null;
   try {
-    const content = readFileSync4(worktreeConfigPath(cwd), "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-function createWorktreeShell(cwd, sessionId, agentId) {
-  const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
-  const worktreePath = join4(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
-  mkdirSync2(dirname2(worktreePath), { recursive: true });
-  execSafe(`git -C ${shellQuote(cwd)} worktree prune`);
-  if (existsSync5(worktreePath)) {
-    execSafe(`git -C ${shellQuote(cwd)} worktree remove --force ${shellQuote(worktreePath)}`);
-  }
-  execSafe(`git -C ${shellQuote(cwd)} branch -D ${shellQuote(branchName)}`);
-  exec(`git -C ${shellQuote(cwd)} branch ${shellQuote(branchName)} HEAD`);
-  exec(`git -C ${shellQuote(cwd)} worktree add ${shellQuote(worktreePath)} ${shellQuote(branchName)}`);
-  return { worktreePath, branchName };
-}
-function bootstrapWorktree(cwd, worktreePath, config) {
-  if (config.copy) {
-    for (const entry of config.copy) {
-      const dest = join4(worktreePath, entry);
-      mkdirSync2(dirname2(dest), { recursive: true });
-      execSafe(`cp -r ${shellQuote(join4(cwd, entry))} ${shellQuote(dest)}`);
-    }
-  }
-  if (config.clone) {
-    for (const entry of config.clone) {
-      const dest = join4(worktreePath, entry);
-      mkdirSync2(dirname2(dest), { recursive: true });
-      const src = shellQuote(join4(cwd, entry));
-      const dstQ = shellQuote(dest);
-      if (execSafe(`cp -Rc ${src} ${dstQ}`) === null) {
-        execSafe(`cp -r ${src} ${dstQ}`);
+    const session = await query({
+      prompt: `Generate a 2-4 word kebab-case name for this task. Output ONLY the name.
+
+${task.slice(0, 500)}`,
+      options: {
+        model: "haiku",
+        maxTurns: 1,
+        env: execEnv()
       }
-    }
-  }
-  if (config.symlink) {
-    for (const entry of config.symlink) {
-      const dest = join4(worktreePath, entry);
-      mkdirSync2(dirname2(dest), { recursive: true });
-      execSafe(`ln -s ${shellQuote(join4(cwd, entry))} ${shellQuote(dest)}`);
-    }
-  }
-  if (config.init) {
-    try {
-      exec(config.init, worktreePath);
-    } catch (err) {
-      console.error(`[sisyphus] worktree init command failed: ${err instanceof Error ? err.message : err}`);
-    }
-  }
-}
-function resolveWorktreeBranch(cwd, worktreePath) {
-  const output = execSafe(`git -C ${shellQuote(cwd)} worktree list --porcelain`);
-  if (!output) return null;
-  const lines = output.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    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);
+    });
+    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;
         }
       }
-      break;
-    }
-  }
-  return null;
-}
-function mergeWorktrees(cwd, agents) {
-  const pending = agents.filter(
-    (a) => a.worktreePath && a.mergeStatus === "pending"
-  );
-  const results = [];
-  execSafe(`git -C ${shellQuote(cwd)} add .sisyphus`);
-  execSafe(`git -C ${shellQuote(cwd)} commit -m 'sisyphus: snapshot session state before merge'`);
-  for (const agent of pending) {
-    const branch = resolveWorktreeBranch(cwd, agent.worktreePath);
-    if (!branch) {
-      results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
-      execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(agent.worktreePath)} --force`);
-      continue;
     }
-    const aheadLog = execSafe(`git -C ${shellQuote(cwd)} log HEAD..${shellQuote(branch)} --oneline`);
-    if (!aheadLog) {
-      results.push({ agentId: agent.id, name: agent.name, status: "no-changes" });
-      cleanupWorktree(cwd, agent.worktreePath, branch);
-      continue;
-    }
-    const mergeMsg = `sisyphus: merge ${agent.id} (${agent.name})`;
-    const mergeCmd = `git -C ${shellQuote(cwd)} merge --no-ff ${shellQuote(branch)} -m ${shellQuote(mergeMsg)}`;
-    try {
-      exec(mergeCmd);
-      execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(agent.worktreePath)}`);
-      execSafe(`git -C ${shellQuote(cwd)} branch -d ${shellQuote(branch)}`);
-      results.push({ agentId: agent.id, name: agent.name, status: "merged" });
-    } catch (err) {
-      execSafe(`git -C ${shellQuote(cwd)} merge --abort`);
-      const errObj = err;
-      const stdout = errObj.stdout ? (typeof errObj.stdout === "string" ? errObj.stdout : errObj.stdout.toString("utf-8")).trim() : "";
-      const stderr = errObj.stderr ? (typeof errObj.stderr === "string" ? errObj.stderr : errObj.stderr.toString("utf-8")).trim() : "";
-      const conflictDetails = stdout || stderr || (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) {
-  execSafe(`git -C ${shellQuote(cwd)} worktree remove ${shellQuote(worktreePath)} --force`);
-  execSafe(`git -C ${shellQuote(cwd)} branch -D ${shellQuote(branchName)}`);
-  const baseDir = dirname2(worktreePath);
-  try {
-    const entries = readdirSync4(baseDir);
-    if (entries.length === 0) {
-      rmSync2(baseDir, { recursive: true });
+    const name = text.trim().toLowerCase();
+    if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) return null;
+    return name.slice(0, 30);
+  } catch (err) {
+    console.error(`[sisyphus] Haiku name generation failed: ${err instanceof Error ? err.message : err}`);
+    const status = err.status;
+    if (status === 401 || status === 403) {
+      disabledUntil = Date.now() + COOLDOWN_MS;
     }
-  } catch {
+    return null;
   }
 }
-function countWorktreeAgents(agents) {
-  return agents.filter((a) => a.worktreePath && a.status === "running").length;
-}
-
-// src/daemon/summarize.ts
-import { query } from "@r-cli/sdk";
-var disabled = false;
 async function summarizeReport(reportText) {
-  if (disabled) return null;
+  if (Date.now() < disabledUntil) return null;
   try {
     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.
@@ -1002,7 +719,8 @@ async function summarizeReport(reportText) {
 ${reportText.slice(0, 3e3)}`,
       options: {
         model: "haiku",
-        maxTurns: 1
+        maxTurns: 1,
+        env: execEnv()
       }
     });
     let text = "";
@@ -1019,7 +737,7 @@ ${reportText.slice(0, 3e3)}`,
     console.error(`[sisyphus] Haiku summarization failed: ${err instanceof Error ? err.message : err}`);
     const status = err.status;
     if (status === 401 || status === 403) {
-      disabled = true;
+      disabledUntil = Date.now() + COOLDOWN_MS;
     }
     return null;
   }
@@ -1038,69 +756,65 @@ function resetAgentCounterFromState(sessionId, agents) {
 function clearAgentCounter(sessionId) {
   agentCounters.delete(sessionId);
 }
-function renderAgentSuffix(sessionId, instruction, worktreeContext) {
-  const templatePath = resolve3(import.meta.dirname, "../templates/agent-suffix.md");
+function renderAgentSuffix(sessionId, instruction) {
+  const templatePath = resolve2(import.meta.dirname, "../templates/agent-suffix.md");
   let template;
   try {
-    template = readFileSync5(templatePath, "utf-8");
+    template = readFileSync3(templatePath, "utf-8");
   } catch {
     template = `# Sisyphus Agent
 Session: {{SESSION_ID}}
 Task: {{INSTRUCTION}}`;
   }
-  let worktreeBlock = "";
-  if (worktreeContext) {
-    worktreeBlock = [
-      "## Worktree Context",
-      `You are working in an isolated git worktree on branch \`${worktreeContext.branchName}\`.`,
-      `If you start any services that require ports, add ${worktreeContext.offset} to the default port.`
-    ].join("\n");
-  }
-  return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{WORKTREE_CONTEXT\}\}/g, worktreeBlock);
+  return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{WORKTREE_CONTEXT\}\}/g, "");
 }
 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 });
-  writeFileSync4(
+  mkdirSync2(`${base}/.claude-plugin`, { recursive: true });
+  mkdirSync2(`${base}/agents`, { recursive: true });
+  mkdirSync2(`${base}/hooks`, { recursive: true });
+  writeFileSync3(
     `${base}/.claude-plugin/plugin.json`,
     JSON.stringify({ name: `sisyphus-agent-${agentId}`, version: "1.0.0" }),
     "utf-8"
   );
+  const sesDir = sessionDir(cwd, sessionId);
+  const substituteEnvVars = (text) => text.replace(/\$SISYPHUS_SESSION_DIR/g, sesDir).replace(/\$SISYPHUS_SESSION_ID/g, sessionId);
   if (agentConfig?.filePath && agentType && agentType !== "worker") {
     const shortName = agentType.replace(/^sisyphus:/, "");
-    copyFileSync2(agentConfig.filePath, `${base}/agents/${shortName}.md`);
-    const subAgentDir = join5(dirname3(agentConfig.filePath), shortName);
-    if (existsSync6(subAgentDir)) {
-      for (const f of readdirSync5(subAgentDir)) {
+    writeFileSync3(`${base}/agents/${shortName}.md`, substituteEnvVars(readFileSync3(agentConfig.filePath, "utf-8")), "utf-8");
+    const subAgentDir = join3(dirname2(agentConfig.filePath), shortName);
+    if (existsSync4(subAgentDir)) {
+      for (const f of readdirSync3(subAgentDir)) {
         if (f.endsWith(".md") && f !== "CLAUDE.md") {
-          copyFileSync2(join5(subAgentDir, f), `${base}/agents/${f}`);
+          writeFileSync3(`${base}/agents/${f}`, substituteEnvVars(readFileSync3(join3(subAgentDir, f), "utf-8")), "utf-8");
         }
       }
     }
   }
-  const srcHooks = resolve3(import.meta.dirname, "../templates/agent-plugin/hooks");
+  const srcHooks = resolve2(import.meta.dirname, "../templates/agent-plugin/hooks");
   for (const f of ["require-submit.sh", "intercept-send-message.sh"]) {
     copyFileSync2(`${srcHooks}/${f}`, `${base}/hooks/${f}`);
   }
   const hooksConfig = {
     PreToolUse: [
       { matcher: "SendMessage", hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/intercept-send-message.sh" }] }
-    ],
-    Stop: [
-      { hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/require-submit.sh" }] }
     ]
   };
+  if (!agentConfig?.frontmatter.interactive) {
+    hooksConfig.Stop = [
+      { hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/require-submit.sh" }] }
+    ];
+  }
   const normalizedType = agentType?.replace(/^sisyphus:/, "") ?? "";
   const userPromptHooks = {
     "plan": "plan-user-prompt.sh",
-    "spec-draft": "spec-user-prompt.sh",
     "review": "review-user-prompt.sh",
     "review-plan": "review-plan-user-prompt.sh",
     "debug": "debug-user-prompt.sh",
     "operator": "operator-user-prompt.sh",
-    "test-spec": "test-spec-user-prompt.sh"
+    "test-spec": "test-spec-user-prompt.sh",
+    "explore": "explore-user-prompt.sh"
   };
   const hookScript = userPromptHooks[normalizedType];
   if (hookScript) {
@@ -1109,27 +823,30 @@ function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
     ];
     copyFileSync2(`${srcHooks}/${hookScript}`, `${base}/hooks/${hookScript}`);
   }
-  writeFileSync4(`${base}/hooks/hooks.json`, JSON.stringify({ hooks: hooksConfig }, null, 2), "utf-8");
+  writeFileSync3(`${base}/hooks/hooks.json`, JSON.stringify({ hooks: hooksConfig }, null, 2), "utf-8");
   return base;
 }
 function setupAgentPane(opts) {
-  const { sessionId, cwd, agentId, agentType, name, instruction, windowId, color, provider, agentConfig, worktreeContext, paneCwd } = opts;
+  const { sessionId, cycleNum, cwd, agentId, agentType, name, instruction, windowId, color, provider, agentConfig, paneCwd, claudeSessionId } = opts;
   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 sessionLabel = opts.sessionName ?? sessionId.slice(0, 8);
+  const agentTitle = `ssph:${sessionLabel} ${paneLabel} c${cycleNum}`;
+  setPaneTitle(paneId, agentTitle);
+  setPaneStyle(paneId, color, { role: paneLabel, session: sessionLabel, cycle: `c${cycleNum}` });
+  const suffix = renderAgentSuffix(sessionId, instruction);
   const suffixFilePath = `${promptsDir(cwd, sessionId)}/${agentId}-system.md`;
-  writeFileSync4(suffixFilePath, suffix, "utf-8");
+  writeFileSync3(suffixFilePath, suffix, "utf-8");
   const bannerCmd = resolveBannerCmd();
   const npmBinDir = resolveNpmBinDir();
+  const sesDir = sessionDir(cwd, sessionId);
   const envExports = buildEnvExports([
     `export SISYPHUS_SESSION_ID='${sessionId}'`,
     `export SISYPHUS_AGENT_ID='${agentId}'`,
     `export SISYPHUS_CWD='${cwd}'`,
-    ...worktreeContext ? [`export SISYPHUS_PORT_OFFSET='${worktreeContext.offset}'`] : [],
+    `export SISYPHUS_SESSION_DIR='${sesDir}'`,
     `export PATH="${npmBinDir}:$PATH"`
   ]);
   const notifyCmd = buildNotifyCmd(paneId);
@@ -1142,7 +859,7 @@ function setupAgentPane(opts) {
     parts.push(`## Task
 
 ${instruction}`);
-    writeFileSync4(codexPromptPath, parts.join("\n\n"), "utf-8");
+    writeFileSync3(codexPromptPath, parts.join("\n\n"), "utf-8");
     const model = agentConfig?.frontmatter.model ?? "codex-mini";
     mainCmd = `codex -m ${shellQuote(model)} --dangerously-bypass-approvals-and-sandbox "$(cat '${codexPromptPath}')"`;
   } else {
@@ -1150,7 +867,8 @@ ${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 ${shellQuote(`sisyphus:${name}`)} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote(instruction)}`;
+    const sessionIdFlag = claudeSessionId ? ` --session-id "${claudeSessionId}"` : "";
+    mainCmd = `claude --dangerously-skip-permissions --effort ${effort} --plugin-dir "${pluginPath}"${agentFlag}${sessionIdFlag} --name ${shellQuote(agentTitle)} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote(instruction)}`;
   }
   const scriptPath = writeRunScript(promptsDir(cwd, sessionId), `${agentId}-run`, [
     "#!/usr/bin/env bash",
@@ -1167,31 +885,24 @@ async function spawnAgent(opts) {
   const count = (agentCounters.get(sessionId) ?? 0) + 1;
   agentCounters.set(sessionId, count);
   const agentId = `agent-${String(count).padStart(3, "0")}`;
-  const bundledPluginPath = resolve3(import.meta.dirname, "../templates/agent-plugin");
+  const 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);
   const cliToCheck = provider === "openai" ? "codex" : "claude";
   try {
-    execSync2(`which ${cliToCheck}`, { stdio: "pipe", env: execEnv() });
+    execSync(`which ${cliToCheck}`, { stdio: "pipe", env: execEnv() });
   } catch {
     throw new Error(`${cliToCheck} CLI not found on PATH. Run \`sisyphus doctor\` to diagnose.`);
   }
-  let paneCwd = cwd;
-  let worktreePath;
-  let branchName;
-  let worktreeContext;
-  if (opts.worktree) {
-    const wt = createWorktreeShell(cwd, sessionId, agentId);
-    worktreePath = wt.worktreePath;
-    branchName = wt.branchName;
-    paneCwd = worktreePath;
-    const session = getSession(cwd, sessionId);
-    const portOffset = countWorktreeAgents(session.agents) + 1;
-    worktreeContext = { offset: portOffset, total: portOffset, branchName };
-  }
+  const repo = opts.repo !== void 0 ? opts.repo : ".";
+  const repoRoot = repo === "." ? cwd : join3(cwd, repo);
+  const paneCwd = repoRoot;
+  const claudeSessionId = provider !== "openai" ? randomUUID2() : void 0;
   const { paneId, fullCmd } = setupAgentPane({
     sessionId,
+    sessionName: opts.sessionName,
+    cycleNum: opts.cycleNum,
     cwd,
     agentId,
     agentType,
@@ -1201,42 +912,27 @@ async function spawnAgent(opts) {
     color,
     provider,
     agentConfig,
-    worktreeContext,
-    paneCwd
+    paneCwd,
+    claudeSessionId
   });
   const agent = {
     id: agentId,
     name,
     agentType,
     provider,
+    claudeSessionId,
     color,
     instruction,
     status: "running",
     spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
     completedAt: null,
+    activeMs: 0,
     reports: [],
     paneId,
-    ...worktreePath ? { worktreePath, branchName, mergeStatus: "pending" } : {}
+    repo
   };
   await addAgent(cwd, sessionId, agent);
-  if (opts.worktree && worktreePath) {
-    const config = loadWorktreeConfig(cwd);
-    if (config) {
-      const wtPath = worktreePath;
-      setImmediate(() => {
-        try {
-          bootstrapWorktree(cwd, wtPath, config);
-        } catch (err) {
-          console.error(`[sisyphus] worktree bootstrap failed for ${agentId}: ${err instanceof Error ? err.message : err}`);
-        }
-        sendKeys(paneId, fullCmd);
-      });
-    } else {
-      sendKeys(paneId, fullCmd);
-    }
-  } else {
-    sendKeys(paneId, fullCmd);
-  }
+  sendKeys(paneId, fullCmd);
   return agent;
 }
 async function restartAgent(sessionId, cwd, agentId, windowId) {
@@ -1255,19 +951,12 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     });
   }
   const { instruction, agentType, name, color } = agent;
-  const bundledPluginPath = resolve3(import.meta.dirname, "../templates/agent-plugin");
+  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.repo !== ".") {
+    paneCwd = join3(cwd, agent.repo);
   }
   if (agent.paneId) {
     try {
@@ -1276,8 +965,11 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     }
     unregisterAgentPane(sessionId, agentId);
   }
+  const claudeSessionId = provider !== "openai" ? randomUUID2() : void 0;
   const { paneId, fullCmd } = setupAgentPane({
     sessionId,
+    sessionName: session.name,
+    cycleNum: session.orchestratorCycles.length,
     cwd,
     agentId,
     agentType,
@@ -1287,13 +979,14 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     color,
     provider,
     agentConfig,
-    worktreeContext,
-    paneCwd
+    paneCwd,
+    claudeSessionId
   });
   await updateAgent(cwd, sessionId, agentId, {
     status: "running",
     paneId,
     provider,
+    claudeSessionId,
     spawnedAt: (/* @__PURE__ */ new Date()).toISOString(),
     completedAt: null,
     killedReason: void 0
@@ -1303,7 +996,7 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
 function nextReportNumber(cwd, sessionId, agentId) {
   const dir = reportsDir(cwd, sessionId);
   try {
-    const files = readdirSync5(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";
@@ -1311,10 +1004,10 @@ function nextReportNumber(cwd, sessionId, agentId) {
 }
 async function handleAgentReport(cwd, sessionId, agentId, content) {
   const dir = reportsDir(cwd, sessionId);
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync2(dir, { recursive: true });
   const num = nextReportNumber(cwd, sessionId, agentId);
   const filePath = reportFilePath(cwd, sessionId, agentId, num);
-  writeFileSync4(filePath, content, "utf-8");
+  writeFileSync3(filePath, content, "utf-8");
   const entry = {
     type: "update",
     filePath,
@@ -1331,9 +1024,9 @@ async function handleAgentReport(cwd, sessionId, agentId, content) {
 }
 async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const dir = reportsDir(cwd, sessionId);
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync2(dir, { recursive: true });
   const filePath = reportFilePath(cwd, sessionId, agentId, "final");
-  writeFileSync4(filePath, report, "utf-8");
+  writeFileSync3(filePath, report, "utf-8");
   const entry = {
     type: "final",
     filePath,
@@ -1347,9 +1040,11 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
     }
   }).catch(() => {
   });
+  const flushedActiveMs = flushAgentTimer(sessionId, agentId);
   await updateAgent(cwd, sessionId, agentId, {
     status: "completed",
-    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    activeMs: flushedActiveMs
   });
   const session = getSession(cwd, sessionId);
   const agent = session.agents.find((a) => a.id === agentId);
@@ -1367,10 +1062,12 @@ async function handleAgentSubmit(cwd, sessionId, agentId, report) {
 }
 async function handleAgentKilled(cwd, sessionId, agentId, reason) {
   unregisterAgentPane(sessionId, agentId);
+  const flushedActiveMs = flushAgentTimer(sessionId, agentId);
   await updateAgent(cwd, sessionId, agentId, {
     status: "killed",
     killedReason: reason,
-    completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    activeMs: flushedActiveMs
   });
   const session = getSession(cwd, sessionId);
   return allAgentsDone(session);
@@ -1383,105 +1080,515 @@ function allAgentsDone(session) {
 // src/daemon/pane-monitor.ts
 var monitorInterval = null;
 var onAllAgentsDone = null;
+var lastPollTime = 0;
+var storedPollIntervalMs = 5e3;
+var activeTimers = /* @__PURE__ */ new Map();
+function initTimers(sessionId, session) {
+  const entry = {
+    sessionMs: session.activeMs,
+    agentMs: /* @__PURE__ */ new Map(),
+    cycleMs: /* @__PURE__ */ new Map()
+  };
+  for (const agent of session.agents) {
+    entry.agentMs.set(agent.id, agent.activeMs);
+  }
+  for (const cycle of session.orchestratorCycles) {
+    entry.cycleMs.set(cycle.cycle, cycle.activeMs);
+  }
+  activeTimers.set(sessionId, entry);
+}
+function getActiveTimers(sessionId) {
+  return activeTimers.get(sessionId);
+}
+async function flushTimers(sessionId) {
+  const entry = activeTimers.get(sessionId);
+  if (!entry) return;
+  const tracked = trackedSessions.get(sessionId);
+  if (!tracked) return;
+  let session;
+  try {
+    session = getSession(tracked.cwd, sessionId);
+  } catch {
+    return;
+  }
+  const sessionDelta = entry.sessionMs - session.activeMs;
+  const agentDeltas = /* @__PURE__ */ new Map();
+  for (const [agentId, ms] of entry.agentMs) {
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    const persisted = agent?.activeMs ?? 0;
+    const delta = ms - persisted;
+    if (delta > 0) agentDeltas.set(agentId, delta);
+  }
+  const cycleDeltas = /* @__PURE__ */ new Map();
+  for (const [cycleNum, ms] of entry.cycleMs) {
+    const cycle = session.orchestratorCycles.find((c) => c.cycle === cycleNum);
+    const persisted = cycle?.activeMs ?? 0;
+    const delta = ms - persisted;
+    if (delta > 0) cycleDeltas.set(cycleNum, delta);
+  }
+  if (sessionDelta > 0 || agentDeltas.size > 0 || cycleDeltas.size > 0) {
+    await incrementActiveTime(tracked.cwd, sessionId, Math.max(0, sessionDelta), agentDeltas, cycleDeltas);
+  }
+}
+function flushAgentTimer(sessionId, agentId) {
+  const entry = activeTimers.get(sessionId);
+  if (!entry) return 0;
+  return entry.agentMs.get(agentId) ?? 0;
+}
+function flushCycleTimer(sessionId, cycleNumber) {
+  const entry = activeTimers.get(sessionId);
+  if (!entry) return 0;
+  return entry.cycleMs.get(cycleNumber) ?? 0;
+}
+function getTrackedSessionIds() {
+  return [...trackedSessions.keys()];
+}
 function setRespawnCallback(cb) {
   onAllAgentsDone = cb;
 }
 function startMonitor(pollIntervalMs = 5e3) {
   if (monitorInterval) return;
+  storedPollIntervalMs = pollIntervalMs;
+  lastPollTime = Date.now();
   monitorInterval = setInterval(() => {
     pollAllSessions().catch((err) => {
       console.error("[sisyphus] Pane monitor error:", err);
     });
-  }, pollIntervalMs);
-}
-function stopMonitor() {
-  if (monitorInterval) {
-    clearInterval(monitorInterval);
-    monitorInterval = null;
+  }, pollIntervalMs);
+}
+function stopMonitor() {
+  if (monitorInterval) {
+    clearInterval(monitorInterval);
+    monitorInterval = null;
+  }
+}
+var trackedSessions = /* @__PURE__ */ new Map();
+function trackSession(sessionId, cwd, tmuxSession) {
+  const existing = trackedSessions.get(sessionId);
+  trackedSessions.set(sessionId, { id: sessionId, cwd, tmuxSession, windowId: existing ? existing.windowId : null });
+}
+function updateTrackedWindow(sessionId, windowId) {
+  const entry = trackedSessions.get(sessionId);
+  if (!entry) throw new Error(`Cannot update window for untracked session: ${sessionId}`);
+  entry.windowId = windowId;
+}
+function untrackSession(sessionId) {
+  trackedSessions.delete(sessionId);
+}
+async function pollAllSessions() {
+  const now = Date.now();
+  const elapsed = now - lastPollTime;
+  const threshold = storedPollIntervalMs * 3;
+  const increment = elapsed > threshold ? storedPollIntervalMs : elapsed;
+  lastPollTime = now;
+  for (const { id: sessionId, cwd, windowId } of trackedSessions.values()) {
+    if (windowId) {
+      await pollSession(sessionId, cwd, windowId, increment);
+    }
+  }
+}
+async function pollSession(sessionId, cwd, windowId, increment) {
+  let session;
+  try {
+    session = getSession(cwd, sessionId);
+  } catch (err) {
+    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) {
+    const tracked = trackedSessions.get(sessionId);
+    if (tracked && !sessionExists(tracked.tmuxSession)) {
+      await flushTimers(sessionId);
+      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 timerEntry = activeTimers.get(sessionId);
+  if (!timerEntry) {
+    initTimers(sessionId, session);
+    timerEntry = activeTimers.get(sessionId);
+  }
+  let anyAlive = false;
+  for (const agent of session.agents) {
+    if (agent.status === "running" && livePaneIds.has(agent.paneId)) {
+      timerEntry.agentMs.set(agent.id, (timerEntry.agentMs.get(agent.id) ?? 0) + increment);
+      anyAlive = true;
+    }
+  }
+  const orchPaneId = getOrchestratorPaneId(sessionId);
+  if (orchPaneId && livePaneIds.has(orchPaneId)) {
+    const currentCycle = session.orchestratorCycles.length;
+    if (currentCycle > 0) {
+      timerEntry.cycleMs.set(currentCycle, (timerEntry.cycleMs.get(currentCycle) ?? 0) + increment);
+    }
+    anyAlive = true;
+  }
+  if (anyAlive) {
+    timerEntry.sessionMs += increment;
+  }
+  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);
+  if (orchPaneId && !livePaneIds.has(orchPaneId)) {
+    const cycleActiveMs = flushCycleTimer(sessionId, session.orchestratorCycles.length);
+    await completeOrchestratorCycle(cwd, sessionId, void 0, void 0, cycleActiveMs);
+    const runningAgents = session.agents.filter((a) => a.status === "running");
+    if (runningAgents.length === 0) {
+      await flushTimers(sessionId);
+      await updateSessionStatus(cwd, sessionId, "paused");
+      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/orchestrator.ts
+function detectRepos(cwd) {
+  const config = loadConfig(cwd);
+  const repos = [];
+  if (existsSync5(join4(cwd, ".git"))) {
+    try {
+      repos.push(getRepoInfo(cwd, "."));
+    } catch {
+    }
+  }
+  try {
+    const entries = readdirSync4(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".")) continue;
+      const childPath = join4(cwd, entry.name);
+      if (existsSync5(join4(childPath, ".git"))) {
+        try {
+          repos.push(getRepoInfo(childPath, entry.name));
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (config.repos && config.repos.length > 0) {
+    const allowed = new Set(config.repos);
+    return repos.filter((r) => r.name === "." || allowed.has(r.name));
+  }
+  return repos;
+}
+function getRepoInfo(repoPath, name) {
+  const branchRaw = execSafe(`git -C ${shellQuote(repoPath)} rev-parse --abbrev-ref HEAD`)?.trim();
+  if (!branchRaw) throw new Error(`Failed to detect git branch for repo: ${repoPath}`);
+  const status = execSafe(`git -C ${shellQuote(repoPath)} status --porcelain`);
+  const isDirty = !!(status && status.trim().length > 0);
+  return { name, path: repoPath, branch: branchRaw, isDirty };
+}
+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, sessionId, mode) {
+  const projectPath = projectOrchestratorPromptPath(cwd);
+  if (existsSync5(projectPath)) {
+    return readFileSync4(projectPath, "utf-8");
+  }
+  const basePath = resolve3(import.meta.dirname, "../templates/orchestrator-base.md");
+  const base = readFileSync4(basePath, "utf-8");
+  let modePrompt;
+  if (mode === "strategy") {
+    const strategyTemplatePath = resolve3(import.meta.dirname, "../templates/orchestrator-strategy.md");
+    modePrompt = readFileSync4(strategyTemplatePath, "utf-8");
+  } else if (mode === "implementation") {
+    const implPath = resolve3(import.meta.dirname, "../templates/orchestrator-impl.md");
+    modePrompt = readFileSync4(implPath, "utf-8");
+  } else if (mode === "validation") {
+    const validationPath = resolve3(import.meta.dirname, "../templates/orchestrator-validation.md");
+    modePrompt = readFileSync4(validationPath, "utf-8");
+  } else {
+    const planningPath = resolve3(import.meta.dirname, "../templates/orchestrator-planning.md");
+    modePrompt = readFileSync4(planningPath, "utf-8");
+  }
+  return base + "\n\n" + modePrompt;
+}
+function formatStateForOrchestrator(session) {
+  const cycleNum = session.orchestratorCycles.length;
+  const ctxDir = contextDir(session.cwd, session.id);
+  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 {
+    let ctxFiles = [];
+    if (existsSync5(ctxDir)) {
+      ctxFiles = readdirSync4(ctxDir).filter((f) => f !== "CLAUDE.md");
+    }
+    if (ctxFiles.length > 0) {
+      const ctxLines = ctxFiles.map((f) => `- ${join4(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)"}`;
+    });
+    previousCyclesSection = `
+### Previous Cycles
+
+${lines.join("\n")}
+`;
   }
-}
-var trackedSessions = /* @__PURE__ */ new Map();
-function trackSession(sessionId, cwd, tmuxSession) {
-  const existing = trackedSessions.get(sessionId);
-  trackedSessions.set(sessionId, { id: sessionId, cwd, tmuxSession, windowId: existing ? existing.windowId : null });
-}
-function updateTrackedWindow(sessionId, windowId) {
-  const entry = trackedSessions.get(sessionId);
-  if (!entry) throw new Error(`Cannot update window for untracked session: ${sessionId}`);
-  entry.windowId = windowId;
-}
-function untrackSession(sessionId) {
-  trackedSessions.delete(sessionId);
-}
-async function pollAllSessions() {
-  for (const { id: sessionId, cwd, windowId } of trackedSessions.values()) {
-    if (windowId) {
-      await pollSession(sessionId, cwd, windowId);
+  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 agentLines = lastCycle.agentsSpawned.map((id) => {
+      const agent = agentMap.get(id);
+      if (!agent) return `- **${id}**: unknown (no agent data)`;
+      const finalReport = agent.reports.find((r) => r.type === "final");
+      const reportToUse = finalReport ?? agent.reports[agent.reports.length - 1];
+      const reportRef = reportToUse ? `@${reportToUse.filePath}` : "(no reports)";
+      return `- **${id}** (${agent.name}) [${agent.status}]: ${reportRef}`;
+    }).join("\n");
+    mostRecentCycleSection = `
+### Most Recent Cycle
+
+${agentLines}
+`;
+  }
+  const strategyFile = strategyPath(session.cwd, session.id);
+  const strategyRef = existsSync5(strategyFile) ? `@${strategyFile}` : "(empty)";
+  const roadmapRef = existsSync5(roadmapFile) ? `@${roadmapFile}` : "(empty)";
+  const repos = detectRepos(session.cwd);
+  let repositoriesSection = "\n\n## Repositories\n";
+  if (repos.length === 0) {
+    repositoriesSection += "\nNo git repositories detected.\n";
+  } else {
+    for (const repo of repos) {
+      const dirtyTag = repo.isDirty ? " (dirty)" : "";
+      repositoriesSection += `
+### ${repo.name === "." ? "Session Root (.)" : repo.name}
+`;
+      repositoriesSection += `Branch: \`${repo.branch}\`${dirtyTag}
+`;
+      const repoAgents = session.agents.filter((a) => a.repo === repo.name);
+      if (repoAgents.length > 0) {
+        repositoriesSection += "\nAgents:\n";
+        for (const a of repoAgents) {
+          repositoriesSection += `- ${a.id} (${a.name}) [${a.status}]
+`;
+        }
+      }
+    }
+    if (repos.length > 1) {
+      repositoriesSection += '\nTarget agents at specific repos:\n```bash\nsisyphus spawn --name "impl" --repo <repo-name> "task"\n```\n';
     }
   }
+  const goalFile = goalPath(session.cwd, session.id);
+  const goalContent = existsSync5(goalFile) ? readFileSync4(goalFile, "utf-8").trim() : session.task;
+  return `## Goal
+
+${goalContent}
+${contextSection}${messagesSection}
+### Cycle Log
+
+Write your cycle summary to: ${logFile}
+${previousCyclesSection}${mostRecentCycleSection}
+## Strategy
+
+${strategyRef}
+
+## Roadmap
+
+${roadmapRef}
+`;
 }
-async function pollSession(sessionId, cwd, windowId) {
-  let session;
+async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   try {
-    session = getSession(cwd, sessionId);
-  } catch (err) {
-    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;
+    execSync2("which claude", { stdio: "pipe", env: EXEC_ENV });
+  } catch {
+    throw new Error("Claude CLI not found on PATH. Run `sisyphus doctor` to diagnose.");
   }
-  if (session.status !== "active") return;
-  const livePanes = listPanes(windowId);
-  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 session = getSession(cwd, sessionId);
+  const lastCycle = [...session.orchestratorCycles].reverse().find((c) => c.completedAt);
+  const mode = lastCycle?.mode ?? "strategy";
+  const basePrompt = loadOrchestratorPrompt(cwd, sessionId, mode);
+  const formattedState = formatStateForOrchestrator(session);
+  const agentPluginPath = resolve3(import.meta.dirname, "../templates/agent-plugin");
+  const agentTypes = discoverAgentTypes(agentPluginPath, session.cwd);
+  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 sesDir = sessionDir(cwd, sessionId);
+  const substituteEnvVars = (text) => text.replace(/\$SISYPHUS_SESSION_DIR/g, sesDir).replace(/\$SISYPHUS_SESSION_ID/g, sessionId);
+  const systemPrompt = substituteEnvVars(basePrompt.replace("{{AGENT_TYPES}}", agentTypeLines));
+  const cycleNum = session.orchestratorCycles.length + 1;
+  const promptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-system-${cycleNum}.md`;
+  writeFileSync4(promptFilePath, systemPrompt, "utf-8");
+  sessionWindowMap.set(sessionId, windowId);
+  const npmBinDir = resolveNpmBinDir();
+  const envExports = buildEnvExports([
+    `export SISYPHUS_SESSION_ID='${sessionId}'`,
+    `export SISYPHUS_AGENT_ID='orchestrator'`,
+    `export SISYPHUS_CWD='${cwd}'`,
+    `export SISYPHUS_SESSION_DIR='${sesDir}'`,
+    `export PATH="${npmBinDir}:$PATH"`
+  ]);
+  let userPrompt = formattedState;
+  if (message) {
+    userPrompt += `
+
+## Continuation Instructions
+
+The user resumed this session with new instructions: ${message}`;
+  } else {
+    const storedPrompt = lastCycle?.nextPrompt;
+    const continuationText = storedPrompt ? storedPrompt : "Review the current session and delegate the next cycle of work.";
+    userPrompt += `
+
+## Continuation Instructions
+
+${continuationText}`;
   }
-  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);
-      }
-    }
+  const userPromptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
+  writeFileSync4(userPromptFilePath, substituteEnvVars(userPrompt), "utf-8");
+  if (session.messages && session.messages.length > 0) {
+    await drainMessages(cwd, sessionId, session.messages.length);
   }
-  if (paneRemoved) selectLayout(windowId);
-  const orchPaneId = getOrchestratorPaneId(sessionId);
-  if (orchPaneId && !livePaneIds.has(orchPaneId)) {
-    const runningAgents = session.agents.filter((a) => a.status === "running");
-    if (runningAgents.length === 0) {
-      await updateSessionStatus(cwd, sessionId, "paused");
-      console.log(`[sisyphus] Session ${sessionId} paused: orchestrator pane disappeared`);
-    }
+  const pluginPath = resolve3(import.meta.dirname, "../templates/orchestrator-plugin");
+  const settingsPath = resolve3(import.meta.dirname, "../templates/orchestrator-settings.json");
+  const config = loadConfig(cwd);
+  const effort = config.orchestratorEffort ?? "high";
+  const claudeSessionId = randomUUID3();
+  const claudeCmd = `claude --dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --session-id "${claudeSessionId}" --settings "${settingsPath}" --plugin-dir "${pluginPath}" --name "ssph:orch ${session.name ?? sessionId.slice(0, 8)} c${cycleNum}" --system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
+  const paneId = createPane(windowId, cwd, "left");
+  sessionOrchestratorPane.set(sessionId, paneId);
+  registerPane(paneId, sessionId, "orchestrator");
+  const sessionLabel = session.name ?? sessionId.slice(0, 8);
+  setPaneTitle(paneId, `ssph:orch ${sessionLabel} c${cycleNum}`);
+  setPaneStyle(paneId, ORCHESTRATOR_COLOR, { role: "orch", session: sessionLabel, cycle: `c${cycleNum}` });
+  const bannerCmd = resolveBannerCmd();
+  const notifyCmd = buildNotifyCmd(paneId);
+  const scriptPath = writeRunScript(promptsDir(cwd, sessionId), `orchestrator-run-${cycleNum}`, [
+    "#!/usr/bin/env bash",
+    ...bannerCmd ? [bannerCmd] : [],
+    envExports,
+    claudeCmd,
+    notifyCmd
+  ]);
+  sendKeys(paneId, `bash '${scriptPath}'`);
+  await addOrchestratorCycle(cwd, sessionId, {
+    cycle: cycleNum,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    activeMs: 0,
+    agentsSpawned: [],
+    paneId,
+    claudeSessionId
+  });
+}
+function resolveOrchestratorPane(sessionId, cwd) {
+  const memPane = sessionOrchestratorPane.get(sessionId);
+  if (memPane) return memPane;
+  const session = getSession(cwd, sessionId);
+  const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
+  return lastCycle?.paneId ?? void 0;
+}
+async function handleOrchestratorYield(sessionId, cwd, nextPrompt, mode) {
+  const paneId = resolveOrchestratorPane(sessionId, cwd);
+  if (paneId) {
+    killPane(paneId);
+    unregisterPane(paneId);
+    sessionOrchestratorPane.delete(sessionId);
   }
-  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);
+  const windowId = sessionWindowMap.get(sessionId);
+  if (windowId) selectLayout(windowId);
+  const session = getSession(cwd, sessionId);
+  const cycleActiveMs = flushCycleTimer(sessionId, session.orchestratorCycles.length);
+  await completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode, cycleActiveMs);
+  const freshSession = getSession(cwd, sessionId);
+  const runningAgents = freshSession.agents.filter((a) => a.status === "running");
+  if (runningAgents.length === 0) {
+    console.log(`[sisyphus] Orchestrator yielded with no running agents for session ${sessionId}`);
   }
 }
+async function handleOrchestratorComplete(sessionId, cwd, report) {
+  const session = getSession(cwd, sessionId);
+  const cycleActiveMs = flushCycleTimer(sessionId, session.orchestratorCycles.length);
+  await completeOrchestratorCycle(cwd, sessionId, void 0, void 0, cycleActiveMs);
+  await completeSession(cwd, sessionId, report);
+  console.log(`[sisyphus] Session ${sessionId} completed: ${report}`);
+}
+function cleanupSessionMaps(sessionId) {
+  sessionOrchestratorPane.delete(sessionId);
+  sessionWindowMap.delete(sessionId);
+  unregisterSessionPanes(sessionId);
+}
 
 // src/daemon/notify.ts
 import { execFile } from "child_process";
@@ -1521,6 +1628,49 @@ async function startSession(task, cwd, context, name) {
   updateTrackedWindow(sessionId, windowId);
   killPane(initialPaneId);
   pruneOldSessions(cwd);
+  if (!name) {
+    generateSessionName(task).then(async (generatedName) => {
+      if (!generatedName) {
+        console.log(`[sisyphus] Name generation returned null for session ${sessionId}`);
+        return;
+      }
+      let finalName = generatedName;
+      let candidate = `sisyphus-${finalName}`;
+      let attempt = 0;
+      while (sessionExists(candidate) && attempt < 5) {
+        attempt++;
+        finalName = `${generatedName}-${attempt}`;
+        candidate = `sisyphus-${finalName}`;
+      }
+      if (sessionExists(candidate)) return;
+      try {
+        renameSession(tmuxName, candidate);
+      } catch {
+        return;
+      }
+      await updateSessionName(cwd, sessionId, finalName);
+      await updateSessionTmux(cwd, sessionId, candidate, getSession(cwd, sessionId).tmuxWindowId);
+      trackSession(sessionId, cwd, candidate);
+      registerSessionTmux(sessionId, candidate, getSession(cwd, sessionId).tmuxWindowId);
+      const session2 = getSession(cwd, sessionId);
+      for (const pane of getSessionPanes(sessionId)) {
+        updatePaneMeta(pane.paneId, { session: finalName });
+        if (pane.role === "orchestrator") {
+          setPaneTitle(pane.paneId, `ssph:orch ${finalName} c${session2.orchestratorCycles.length}`);
+        } else if (pane.role === "agent" && pane.agentId) {
+          const agent = session2.agents.find((a) => a.id === pane.agentId);
+          if (agent) {
+            const shortType = agent.agentType && agent.agentType !== "worker" ? agent.agentType.replace(/^sisyphus:/, "") : "";
+            const paneLabel = shortType ? `${agent.name}-${shortType}` : agent.name;
+            setPaneTitle(pane.paneId, `ssph:${finalName} ${paneLabel} c${session2.orchestratorCycles.length}`);
+          }
+        }
+      }
+      console.log(`[sisyphus] Session ${sessionId} named: ${finalName}`);
+    }).catch((err) => {
+      console.error(`[sisyphus] Name generation failed for session ${sessionId}:`, err);
+    });
+  }
   return { ...getSession(cwd, sessionId), tmuxSessionName: tmuxName };
 }
 var PRUNE_KEEP_COUNT = 10;
@@ -1528,8 +1678,8 @@ var PRUNE_KEEP_DAYS = 7;
 function pruneOldSessions(cwd) {
   try {
     const dir = sessionsDir(cwd);
-    if (!existsSync7(dir)) return;
-    const entries = readdirSync6(dir, { withFileTypes: true });
+    if (!existsSync6(dir)) return;
+    const entries = readdirSync5(dir, { withFileTypes: true });
     const candidates = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
@@ -1552,7 +1702,7 @@ function pruneOldSessions(cwd) {
     }
     for (const c of candidates) {
       if (keep.has(c.id)) continue;
-      rmSync3(sessionDir(cwd, c.id), { recursive: true, force: true });
+      rmSync2(sessionDir(cwd, c.id), { recursive: true, force: true });
     }
   } catch (err) {
     console.error("[sisyphus] Session pruning failed:", err);
@@ -1621,8 +1771,8 @@ function getSessionStatus(cwd, sessionId) {
 }
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync7(dir)) return [];
-  const entries = readdirSync6(dir, { withFileTypes: true });
+  if (!existsSync6(dir)) return [];
+  const entries = readdirSync5(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -1662,17 +1812,6 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
   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);
-    for (const result of results) {
-      const mergeStatus = result.status;
-      updateAgent(cwd, sessionId, result.agentId, {
-        mergeStatus,
-        mergeDetails: result.conflictDetails
-      }).catch((err) => console.error(`[sisyphus] Failed to update merge status for ${result.agentId}:`, err));
-    }
-  }
   const cycleNumber = session.orchestratorCycles.length;
   if (cycleNumber > 0) {
     createSnapshot(cwd, sessionId, cycleNumber);
@@ -1711,7 +1850,7 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
     }
   });
 }
-async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktree) {
+async function handleSpawn(sessionId, cwd, agentType, name, instruction, repo) {
   const windowId = getWindowId(sessionId);
   if (!windowId) throw new Error(`No tmux window found for session ${sessionId}`);
   const session = getSession(cwd, sessionId);
@@ -1721,12 +1860,14 @@ async function handleSpawn(sessionId, cwd, agentType, name, instruction, worktre
   }
   const agent = await spawnAgent({
     sessionId,
+    sessionName: session.name,
+    cycleNum: session.orchestratorCycles.length,
     cwd,
     agentType,
     name,
     instruction,
     windowId,
-    worktree
+    repo
   });
   await appendAgentToLastCycle(cwd, sessionId, agent.id);
   return { agentId: agent.id };
@@ -1758,16 +1899,15 @@ async function handleYield(sessionId, cwd, nextPrompt, mode) {
 }
 async function handleComplete(sessionId, cwd, report) {
   const session = getSession(cwd, sessionId);
+  await flushTimers(sessionId);
   await handleOrchestratorComplete(sessionId, cwd, report);
   switchToHomeSession(session);
 }
 async function handleContinue(sessionId, cwd) {
   await continueSession(cwd, sessionId);
 }
-async function handleRegisterClaudeSession(cwd, sessionId, agentId, claudeSessionId) {
-  await updateAgent(cwd, sessionId, agentId, { claudeSessionId });
-}
 async function handleKill(sessionId, cwd) {
+  await flushTimers(sessionId);
   const session = getSession(cwd, sessionId);
   const windowId = getWindowId(sessionId);
   let killedAgents = 0;
@@ -1781,11 +1921,6 @@ 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);
@@ -1820,9 +1955,6 @@ async function handleKillAgent(sessionId, cwd, 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",
@@ -1852,11 +1984,6 @@ async function handleRollback(sessionId, cwd, toCycle) {
       });
     }
   }
-  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);
@@ -1887,6 +2014,8 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
   } else if (role === "orchestrator") {
     const sessionName = session.name ?? sessionId.slice(0, 8);
     sendTerminalNotification("Sisyphus", `Orchestrator exited without yielding (${sessionName})`);
+    const cycleActiveMs = flushCycleTimer(sessionId, session.orchestratorCycles.length);
+    await completeOrchestratorCycle(cwd, sessionId, void 0, void 0, cycleActiveMs);
     orchestratorDone.add(sessionId);
     const hasRunningAgents = session.agents.some((a) => a.status === "running");
     if (!hasRunningAgents && session.agents.length > 0) {
@@ -1906,11 +2035,11 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
 var server = null;
 var sessionTrackingMap = /* @__PURE__ */ new Map();
 function registryPath() {
-  return join6(globalDir(), "session-registry.json");
+  return join5(globalDir(), "session-registry.json");
 }
 function persistSessionRegistry() {
   const dir = globalDir();
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   const registry = {};
   for (const [id, tracking] of sessionTrackingMap) {
     registry[id] = tracking.cwd;
@@ -1919,9 +2048,9 @@ function persistSessionRegistry() {
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync8(p)) return {};
+  if (!existsSync7(p)) return {};
   try {
-    return JSON.parse(readFileSync6(p, "utf-8"));
+    return JSON.parse(readFileSync5(p, "utf-8"));
   } catch {
     return {};
   }
@@ -1964,7 +2093,7 @@ async function handleRequest(req) {
       case "spawn": {
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
-        const result = await handleSpawn(req.sessionId, tracking.cwd, req.agentType, req.name, req.instruction, req.worktree);
+        const result = await handleSpawn(req.sessionId, tracking.cwd, req.agentType, req.name, req.instruction, req.repo);
         return { ok: true, data: { agentId: result.agentId } };
       }
       case "submit": {
@@ -2003,6 +2132,18 @@ async function handleRequest(req) {
           const cwd = sessionTrackingMap.get(req.sessionId)?.cwd ?? req.cwd;
           if (!cwd) return unknownSessionError(req.sessionId);
           const session = getSessionStatus(cwd, req.sessionId);
+          const timers = getActiveTimers(req.sessionId);
+          if (timers) {
+            session.activeMs = timers.sessionMs;
+            for (const agent of session.agents) {
+              const agentMs = timers.agentMs.get(agent.id);
+              if (agentMs != null) agent.activeMs = agentMs;
+            }
+            for (const cycle of session.orchestratorCycles) {
+              const cycleMs = timers.cycleMs.get(cycle.cycle);
+              if (cycleMs != null) cycle.activeMs = cycleMs;
+            }
+          }
           return { ok: true, data: { session } };
         }
         return { ok: true, data: { message: "daemon running" } };
@@ -2037,7 +2178,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync8(stateFile)) {
+          if (existsSync7(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -2050,12 +2191,6 @@ async function handleRequest(req) {
         if (session.tmuxWindowId) tracking.windowId = session.tmuxWindowId;
         return { ok: true, data: { sessionId: session.id, status: session.status, tmuxSessionName: session.tmuxSessionName } };
       }
-      case "register_claude_session": {
-        const tracking = sessionTrackingMap.get(req.sessionId);
-        if (!tracking) return unknownSessionError(req.sessionId);
-        await handleRegisterClaudeSession(tracking.cwd, req.sessionId, req.agentId, req.claudeSessionId);
-        return { ok: true };
-      }
       case "kill": {
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
@@ -2080,7 +2215,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync8(stateFile)) {
+          if (existsSync7(stateFile)) {
             registerSessionCwd(req.sessionId, req.cwd);
             tracking = sessionTrackingMap.get(req.sessionId);
           } else {
@@ -2094,7 +2229,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync8(stateFile)) {
+          if (existsSync7(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -2117,8 +2252,8 @@ async function handleRequest(req) {
           sessionTrackingMap.delete(req.sessionId);
           persistSessionRegistry();
         }
-        const { sessionDir: sessionDir2 } = await import("./paths-NUUALUVP.js");
-        rmSync4(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
+        const { sessionDir: sessionDir2 } = await import("./paths-IJXOAN4E.js");
+        rmSync3(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
         return { ok: true };
       }
       case "pane-exited": {
@@ -2149,8 +2284,8 @@ async function handleRequest(req) {
         let filePath;
         if (req.content.length > 200) {
           const dir = messagesDir(tracking.cwd, req.sessionId);
-          mkdirSync4(dir, { recursive: true });
-          filePath = join6(dir, `${id}.md`);
+          mkdirSync3(dir, { recursive: true });
+          filePath = join5(dir, `${id}.md`);
           writeFileSync5(filePath, req.content, "utf-8");
         }
         await appendMessage(tracking.cwd, req.sessionId, {
@@ -2174,7 +2309,7 @@ async function handleRequest(req) {
 function startServer() {
   return new Promise((resolve5, reject) => {
     const sock = socketPath();
-    if (existsSync8(sock)) {
+    if (existsSync7(sock)) {
       unlinkSync(sock);
     }
     server = createServer((conn) => {
@@ -2193,12 +2328,16 @@ function startServer() {
             continue;
           }
           handleRequest(req).then((res) => {
-            conn.write(JSON.stringify(res) + "\n");
+            if (!conn.destroyed) {
+              conn.write(JSON.stringify(res) + "\n");
+            }
           });
         }
       });
       conn.on("error", (err) => {
-        console.error("[sisyphus] Connection error:", err.message);
+        if (err.code !== "EPIPE") {
+          console.error("[sisyphus] Connection error:", err.message);
+        }
       });
     });
     server.on("error", reject);
@@ -2216,7 +2355,7 @@ function stopServer() {
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync8(sock)) {
+      if (existsSync7(sock)) {
         unlinkSync(sock);
       }
       server = null;
@@ -2227,7 +2366,7 @@ function stopServer() {
 
 // src/daemon/updater.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, lstatSync } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, lstatSync } from "fs";
 import { resolve as resolve4 } from "path";
 import { get } from "https";
 function isNewer(latest, current) {
@@ -2244,7 +2383,7 @@ function isNewer(latest, current) {
 function readPackageVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync7(resolve4(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync6(resolve4(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -2359,7 +2498,7 @@ var origError = console.error.bind(console);
 console.log = (...args) => origLog(`[${ts()}]`, ...args);
 console.error = (...args) => origError(`[${ts()}]`, ...args);
 function ensureDirs() {
-  mkdirSync5(globalDir(), { recursive: true });
+  mkdirSync4(globalDir(), { recursive: true });
 }
 function isProcessAlive(pid) {
   try {
@@ -2372,7 +2511,7 @@ function isProcessAlive(pid) {
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync7(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -2443,11 +2582,11 @@ async function recoverSessions() {
   let recovered = 0;
   for (const [sessionId, cwd] of entries) {
     const stateFile = statePath(cwd, sessionId);
-    if (!existsSync9(stateFile)) {
+    if (!existsSync8(stateFile)) {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync8(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync7(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
         resetAgentCounterFromState(sessionId, session.agents ?? []);
@@ -2466,6 +2605,7 @@ async function recoverSessions() {
             setWindowId(sessionId, session.tmuxWindowId);
             trackSession(sessionId, cwd, session.tmuxSessionName);
             updateTrackedWindow(sessionId, session.tmuxWindowId);
+            initTimers(sessionId, session);
             const lastIncompleteCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt && c.paneId);
             if (lastIncompleteCycle?.paneId) {
               setOrchestratorPaneId(sessionId, lastIncompleteCycle.paneId);
@@ -2490,6 +2630,7 @@ async function recoverSessions() {
                 const orchestratorPaneId = getOrchestratorPaneId(sessionId);
                 const orchestratorAlive = orchestratorPaneId && livePaneIds.has(orchestratorPaneId);
                 if (!orchestratorAlive) {
+                  await completeOrchestratorCycle(cwd, sessionId);
                   console.log(`[sisyphus] Detected stuck session ${sessionId} on recovery: triggering orchestrator respawn`);
                   await onAllAgentsDone2(sessionId, cwd, session.tmuxWindowId);
                 }
@@ -2525,6 +2666,12 @@ async function startDaemon() {
   const shutdown = async () => {
     console.log("[sisyphus] Shutting down...");
     stopMonitor();
+    for (const sessionId of getTrackedSessionIds()) {
+      try {
+        await flushTimers(sessionId);
+      } catch {
+      }
+    }
     await stopServer();
     releasePidLock();
     process.exit(0);