sisyphi 0.1.21 → 0.1.23

package/dist/cli.js

@@ -1,31 +1,172 @@
 #!/usr/bin/env node
+import {
+  computeActiveTimeMs
+} from "./chunk-ZE2SKB4B.js";
 import {
   daemonLogPath,
+  daemonPidPath,
   daemonUpdatingPath,
   globalDir,
+  roadmapPath,
   socketPath
-} from "./chunk-LTAW6OWS.js";
+} from "./chunk-YGBGKMTF.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
 
+// src/cli/commands/start.ts
+import { execSync as execSync5 } from "child_process";
+
 // src/cli/client.ts
 import { connect as connect2 } from "net";
 
 // src/cli/install.ts
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { connect } from "net";
-import { homedir } from "os";
-import { dirname, join, resolve } from "path";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
+
+// src/cli/tmux-setup.ts
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_KEY = "M-s";
+var SISYPHUS_CONF_MARKER = "# sisyphus-managed \u2014 do not edit";
+function cycleScriptPath() {
+  return join(globalDir(), "bin", "sisyphus-cycle");
+}
+function sisyphusTmuxConfPath() {
+  return join(globalDir(), "tmux.conf");
+}
+function userTmuxConfPath() {
+  const dotfile = join(homedir(), ".tmux.conf");
+  const xdg = join(homedir(), ".config", "tmux", "tmux.conf");
+  if (existsSync(xdg)) return xdg;
+  if (existsSync(dotfile)) return dotfile;
+  return null;
+}
+var CYCLE_SCRIPT = `#!/bin/bash
+cwd=$(tmux show-option -v @sisyphus_cwd 2>/dev/null)
+[ -z "$cwd" ] && exit 0
+current=$(tmux display-message -p '#{session_name}')
+sessions=()
+while IFS= read -r name; do
+  scwd=$(tmux show-option -t "$name" -v @sisyphus_cwd 2>/dev/null)
+  [ "$scwd" = "$cwd" ] && sessions+=("$name")
+done < <(tmux list-sessions -F '#{session_name}')
+(( \${#sessions[@]} <= 1 )) && exit 0
+for (( i=0; i<\${#sessions[@]}; i++ )); do
+  if [ "\${sessions[$i]}" = "$current" ]; then
+    next=$(( (i + 1) % \${#sessions[@]} ))
+    tmux switch-client -t "\${sessions[$next]}"
+    exit 0
+  fi
+done
+tmux switch-client -t "\${sessions[0]}"
+`;
+function installCycleScript() {
+  const scriptPath = cycleScriptPath();
+  mkdirSync(join(globalDir(), "bin"), { recursive: true });
+  writeFileSync(scriptPath, CYCLE_SCRIPT, "utf8");
+  chmodSync(scriptPath, 493);
+}
+function getExistingBinding(key) {
+  try {
+    const output = execSync("tmux list-keys", { stdio: ["pipe", "pipe", "pipe"] }).toString();
+    for (const line of output.split("\n")) {
+      if (line.includes(key)) {
+        const parts = line.trim().split(/\s+/);
+        const keyIdx = parts.indexOf(key);
+        if (keyIdx !== -1) {
+          return line.trim();
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isSisyphusBinding(binding) {
+  return binding.includes("sisyphus");
+}
+function setupTmuxKeybind(key = DEFAULT_KEY) {
+  installCycleScript();
+  const existing = getExistingBinding(key);
+  if (existing !== null && !isSisyphusBinding(existing)) {
+    return {
+      status: "conflict",
+      message: `Tmux key ${key} is already bound to something else. Run "sisyphus setup-keybind <key>" to use a different key.`,
+      existingBinding: existing
+    };
+  }
+  const confPath = sisyphusTmuxConfPath();
+  const bindingLine = `bind-key -T root ${key} run-shell ${cycleScriptPath()}`;
+  writeFileSync(confPath, `${SISYPHUS_CONF_MARKER}
+${bindingLine}
+`, "utf8");
+  const userConf = userTmuxConfPath();
+  const sourceLine = `source-file ${confPath}`;
+  const markedSourceLine = `${sourceLine} ${SISYPHUS_CONF_MARKER}`;
+  let persistedToConf = false;
+  if (userConf !== null) {
+    const contents = readFileSync(userConf, "utf8");
+    if (!contents.includes(confPath)) {
+      const separator = contents.endsWith("\n") ? "" : "\n";
+      writeFileSync(userConf, `${contents}${separator}${markedSourceLine}
+`, "utf8");
+    }
+    persistedToConf = true;
+  }
+  try {
+    execSync(`tmux bind-key -T root ${key} run-shell ${cycleScriptPath()}`, { stdio: "pipe" });
+  } catch {
+  }
+  if (existing !== null && isSisyphusBinding(existing)) {
+    return {
+      status: "already-installed",
+      message: `Tmux keybinding ${key} already configured for sisyphus.`
+    };
+  }
+  const persistNote = persistedToConf ? "" : `
+Note: No tmux.conf found. Add this to your tmux config for persistence:
+  source-file ${confPath}`;
+  return {
+    status: "installed",
+    message: `Tmux keybinding set: ${key} cycles sisyphus sessions${persistNote}`
+  };
+}
+function removeTmuxKeybind() {
+  const confPath = sisyphusTmuxConfPath();
+  for (const candidate of [join(homedir(), ".tmux.conf"), join(homedir(), ".config", "tmux", "tmux.conf")]) {
+    if (existsSync(candidate)) {
+      const contents = readFileSync(candidate, "utf8");
+      const filtered = contents.split("\n").filter((line) => !line.includes(confPath)).join("\n");
+      if (filtered !== contents) {
+        writeFileSync(candidate, filtered, "utf8");
+      }
+    }
+  }
+  if (existsSync(confPath)) {
+    unlinkSync(confPath);
+  }
+  const scriptPath = cycleScriptPath();
+  if (existsSync(scriptPath)) {
+    unlinkSync(scriptPath);
+  }
+}
+
+// src/cli/install.ts
 var PLIST_LABEL = "com.sisyphus.daemon";
 var PLIST_FILENAME = `${PLIST_LABEL}.plist`;
 function launchAgentDir() {
-  return join(homedir(), "Library", "LaunchAgents");
+  return join2(homedir2(), "Library", "LaunchAgents");
 }
 function plistPath() {
-  return join(launchAgentDir(), PLIST_FILENAME);
+  return join2(launchAgentDir(), PLIST_FILENAME);
 }
 function daemonBinPath() {
   const installDir = dirname(fileURLToPath(import.meta.url));
@@ -56,7 +197,7 @@ function generatePlist(nodePath, daemonPath, logPath) {
 `;
 }
 function isInstalled() {
-  return existsSync(plistPath());
+  return existsSync2(plistPath());
 }
 async function ensureDaemonInstalled() {
   if (process.platform !== "darwin") return;
@@ -64,11 +205,13 @@ async function ensureDaemonInstalled() {
     const nodePath = process.execPath;
     const daemonPath = daemonBinPath();
     const logPath = daemonLogPath();
-    mkdirSync(globalDir(), { recursive: true });
-    mkdirSync(launchAgentDir(), { recursive: true });
+    mkdirSync2(globalDir(), { recursive: true });
+    mkdirSync2(launchAgentDir(), { recursive: true });
     const plist = generatePlist(nodePath, daemonPath, logPath);
-    writeFileSync(plistPath(), plist, "utf8");
-    execSync(`launchctl load -w ${plistPath()}`);
+    writeFileSync2(plistPath(), plist, "utf8");
+    execSync2(`launchctl load -w ${plistPath()}`);
+    const keybindResult = setupTmuxKeybind();
+    printGettingStarted(keybindResult);
   }
   await waitForDaemon();
 }
@@ -78,24 +221,60 @@ async function uninstallDaemon(purge) {
     return;
   }
   const plist = plistPath();
-  if (existsSync(plist)) {
+  if (existsSync2(plist)) {
     try {
-      execSync(`launchctl unload -w ${plist}`, { stdio: "pipe" });
+      execSync2(`launchctl unload -w ${plist}`, { stdio: "pipe" });
     } catch {
     }
-    unlinkSync(plist);
+    unlinkSync2(plist);
     console.log("Daemon unloaded and plist removed.");
   } else {
     console.log("Daemon is not installed (plist not found).");
   }
+  removeTmuxKeybind();
   if (purge) {
     const dir = globalDir();
-    if (existsSync(dir)) {
+    if (existsSync2(dir)) {
       rmSync(dir, { recursive: true, force: true });
       console.log(`Removed ${dir}`);
     }
   }
 }
+function printGettingStarted(keybindResult) {
+  const lines = [
+    "",
+    "Sisyphus installed \u2014 daemon running via launchd.",
+    "",
+    "Sisyphus is a tmux-integrated orchestration daemon for Claude Code multi-agent workflows.",
+    "A background daemon manages sessions where an orchestrator Claude breaks tasks into",
+    "subtasks, spawns agent Claude instances in tmux panes, and coordinates their lifecycle.",
+    "",
+    "Quick start:",
+    '  sisyphus start "task description"   Start a session (must be inside tmux)',
+    "  sisyphus list                        List sessions",
+    "  sisyphus status                      Show current session status",
+    "  sisyphus kill <id>                   Kill a session",
+    "",
+    "Monitoring:",
+    "  sisyphus dashboard                   Open TUI dashboard",
+    "  tail -f ~/.sisyphus/daemon.log       Watch daemon logs",
+    ""
+  ];
+  if (keybindResult.status === "installed") {
+    lines.push(`Tmux keybind: ${keybindResult.message}`);
+  } else if (keybindResult.status === "conflict") {
+    lines.push(`Keybind: ${keybindResult.message}`);
+  }
+  lines.push(
+    "",
+    "Troubleshooting:",
+    "  sisyphus doctor                      Check installation health",
+    "  sisyphus setup-keybind [key]         Configure tmux session-cycling keybind",
+    "  sisyphus uninstall [--purge]         Remove daemon and optionally all data",
+    ""
+  );
+  console.log(lines.join("\n"));
+}
 function testConnection() {
   return new Promise((resolve2, reject) => {
     const sock = connect(socketPath());
@@ -117,10 +296,10 @@ async function waitForDaemon(maxWaitMs = 6e3) {
   let updatingLogged = false;
   while (Date.now() - start < maxWaitMs) {
     const updatingPath = daemonUpdatingPath();
-    if (existsSync(updatingPath)) {
+    if (existsSync2(updatingPath)) {
       if (!updatingLogged) {
         try {
-          const version = readFileSync(updatingPath, "utf-8").trim();
+          const version = readFileSync2(updatingPath, "utf-8").trim();
           console.log(`Updating sisyphus to ${version}...`);
         } catch {
           console.log("Updating sisyphus...");
@@ -129,7 +308,7 @@ async function waitForDaemon(maxWaitMs = 6e3) {
       }
       maxWaitMs = Math.max(maxWaitMs, 3e4);
     }
-    if (existsSync(socketPath())) {
+    if (existsSync2(socketPath())) {
       try {
         await testConnection();
         return;
@@ -212,7 +391,7 @@ async function sendRequest(request) {
 }
 
 // src/cli/tmux.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function assertTmux() {
   if (!process.env.TMUX) {
     throw new Error("Not running inside a tmux pane. Sisyphus requires tmux.");
@@ -220,24 +399,79 @@ function assertTmux() {
 }
 function getTmuxSession() {
   assertTmux();
-  return execSync2('tmux display-message -p "#{session_name}"', { encoding: "utf8" }).trim();
+  return execSync3('tmux display-message -p "#{session_name}"', { encoding: "utf8" }).trim();
 }
-function getTmuxWindow() {
-  assertTmux();
-  return execSync2('tmux display-message -p "#{window_id}"', { encoding: "utf8" }).trim();
+
+// src/cli/commands/dashboard.ts
+import { join as join3 } from "path";
+import { execSync as execSync4 } from "child_process";
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function isDashboardOpen(tmuxSession) {
+  try {
+    const windows = execSync4(
+      `tmux list-windows -t ${shellQuote(tmuxSession)} -F "#{window_name}"`,
+      { encoding: "utf-8" }
+    );
+    return windows.split("\n").some((name) => name.trim() === "sisyphus-dashboard");
+  } catch {
+    return false;
+  }
+}
+function launchDashboard(tmuxSession, cwd) {
+  const tuiPath = join3(import.meta.dirname, "tui.js");
+  const windowId = execSync4(
+    `tmux new-window -n "sisyphus-dashboard" -c ${shellQuote(cwd)} -P -F "#{window_id}"`,
+    { encoding: "utf-8" }
+  ).trim();
+  const cmd = `node ${shellQuote(tuiPath)} --cwd ${shellQuote(cwd)}`;
+  execSync4(
+    `tmux send-keys -t ${shellQuote(windowId)} ${shellQuote(cmd)} Enter`
+  );
+}
+function registerDashboard(program2) {
+  program2.command("dashboard").description("Launch the TUI dashboard for monitoring and managing sessions").action(async () => {
+    assertTmux();
+    const tmuxSession = getTmuxSession();
+    const cwd = process.cwd();
+    launchDashboard(tmuxSession, cwd);
+  });
 }
 
 // src/cli/commands/start.ts
+function shellQuote2(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
 function registerStart(program2) {
-  program2.command("start").description("Start a new sisyphus session").argument("<task>", "Task description for the orchestrator").option("-c, --context <context>", "Background context for the orchestrator").action(async (task, opts) => {
-    const tmuxSession = getTmuxSession();
-    const tmuxWindow = getTmuxWindow();
-    const request = { type: "start", task, context: opts.context, cwd: process.cwd(), tmuxSession, tmuxWindow };
+  program2.command("start").description("Start a new sisyphus session").argument("<task>", "Task description for the orchestrator").option("-c, --context <context>", "Background context for the orchestrator").option("-n, --name <name>", "Human-readable name for the session").action(async (task, opts) => {
+    const cwd = process.env["SISYPHUS_CWD"] ?? process.cwd();
+    const request = { type: "start", task, context: opts.context, cwd, name: opts.name };
     const response = await sendRequest(request);
     if (response.ok) {
       const sessionId = response.data?.sessionId;
+      const tmuxSessionName = response.data?.tmuxSessionName;
+      if (process.env["TMUX"]) {
+        try {
+          execSync5(`tmux set-option @sisyphus_cwd ${shellQuote2(cwd)}`, { stdio: "ignore" });
+        } catch {
+        }
+        try {
+          const tmuxSession = getTmuxSession();
+          if (!isDashboardOpen(tmuxSession)) {
+            launchDashboard(tmuxSession, cwd);
+            console.log(`Dashboard opened in tmux window "sisyphus-dashboard"`);
+          }
+        } catch {
+        }
+      }
       console.log(`Task handed off to sisyphus orchestrator (session ${sessionId})`);
       console.log(`The orchestrator and its agents will handle this task autonomously \u2014 no further action needed from you.`);
+      if (tmuxSessionName) {
+        console.log(`
+Tmux session: ${tmuxSessionName}`);
+        console.log(`  tmux attach -t ${tmuxSessionName}`);
+      }
       console.log(`
 Monitor:`);
       console.log(`  sisyphus status ${sessionId}    # agents, cycles, reports`);
@@ -303,11 +537,11 @@ function registerSpawn(program2) {
 }
 
 // src/cli/commands/submit.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function isInWorktree() {
   try {
-    const gitDir = execSync3("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
-    const commonDir = execSync3("git rev-parse --git-common-dir", { encoding: "utf-8" }).trim();
+    const gitDir = execSync6("git rev-parse --git-dir", { encoding: "utf-8" }).trim();
+    const commonDir = execSync6("git rev-parse --git-common-dir", { encoding: "utf-8" }).trim();
     return gitDir !== commonDir;
   } catch {
     return false;
@@ -315,7 +549,7 @@ function isInWorktree() {
 }
 function getUncommittedChanges() {
   try {
-    const status = execSync3("git status --porcelain", { encoding: "utf-8" }).trim();
+    const status = execSync6("git status --porcelain", { encoding: "utf-8" }).trim();
     return status || null;
   } catch {
     return null;
@@ -360,7 +594,7 @@ function registerSubmit(program2) {
 
 // src/cli/commands/yield.ts
 function registerYield(program2) {
-  program2.command("yield").description("Yield control back to daemon (orchestrator only)").option("--prompt <text>", "Instructions for the next orchestrator cycle (or pipe via stdin)").action(async (opts) => {
+  program2.command("yield").description("Yield control back to daemon (orchestrator only)").option("--prompt <text>", "Instructions for the next orchestrator cycle (or pipe via stdin)").option("--mode <mode>", "System prompt mode for next cycle (planning, implementation)").action(async (opts) => {
     assertTmux();
     const sessionId = process.env.SISYPHUS_SESSION_ID;
     if (!sessionId) {
@@ -368,7 +602,7 @@ function registerYield(program2) {
       process.exit(1);
     }
     const nextPrompt = opts.prompt ?? await readStdin() ?? void 0;
-    const request = { type: "yield", sessionId, agentId: "orchestrator", nextPrompt };
+    const request = { type: "yield", sessionId, agentId: "orchestrator", nextPrompt, mode: opts.mode };
     const response = await sendRequest(request);
     if (response.ok) {
       console.log("Yielded. Waiting for agents to complete.");
@@ -394,7 +628,28 @@ function registerComplete(program2) {
       console.log("Session completed.");
       console.log(`
 Follow up:`);
-      console.log(`  sisyphus resume ${sessionId} "new instructions"  # respawn orchestrator with follow-up`);
+      console.log(`  sisyphus continue                                # reactivate and keep working`);
+      console.log(`  sisyphus resume ${sessionId} "new instructions"   # respawn orchestrator externally`);
+    } else {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/continue.ts
+function registerContinue(program2) {
+  program2.command("continue").description("Reactivate a completed session (orchestrator only)").action(async () => {
+    assertTmux();
+    const sessionId = process.env.SISYPHUS_SESSION_ID;
+    if (!sessionId) {
+      console.error("Error: SISYPHUS_SESSION_ID environment variable not set");
+      process.exit(1);
+    }
+    const request = { type: "continue", sessionId };
+    const response = await sendRequest(request);
+    if (response.ok) {
+      console.log("Session reactivated. Plan cleared.");
     } else {
       console.error(`Error: ${response.error}`);
       process.exit(1);
@@ -403,6 +658,7 @@ Follow up:`);
 }
 
 // src/cli/commands/status.ts
+import { readFileSync as readFileSync3 } from "fs";
 var STATUS_COLORS = {
   active: "\x1B[32m",
   // green
@@ -423,13 +679,12 @@ var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 function colorize(text, status) {
-  const color = STATUS_COLORS[status] ?? "";
+  const color = STATUS_COLORS[status];
+  if (!color) return `${text}${RESET}`;
   return `${color}${text}${RESET}`;
 }
-function formatDuration(startIso, endIso) {
-  const start = new Date(startIso).getTime();
-  const end = endIso ? new Date(endIso).getTime() : Date.now();
-  const totalSeconds = Math.floor((end - start) / 1e3);
+function formatMs(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
   if (totalSeconds < 0) return "0s";
   const hours = Math.floor(totalSeconds / 3600);
   const minutes = Math.floor(totalSeconds % 3600 / 60);
@@ -440,6 +695,30 @@ function formatDuration(startIso, endIso) {
   parts.push(`${seconds}s`);
   return parts.join(" ");
 }
+function formatDuration(startOrMs, endIso) {
+  if (typeof startOrMs === "number") return formatMs(startOrMs);
+  const start = new Date(startOrMs).getTime();
+  const end = endIso ? new Date(endIso).getTime() : Date.now();
+  return formatMs(end - start);
+}
+function inferOrchestratorPhase(session) {
+  const cycles = session.orchestratorCycles;
+  if (cycles.length === 0) return "planning";
+  const lastCycle = cycles[cycles.length - 1];
+  if (!lastCycle.completedAt) {
+    const elapsed = Date.now() - new Date(lastCycle.timestamp).getTime();
+    if (elapsed < 5e3 || lastCycle.agentsSpawned.length === 0) return "planning";
+    return "spawning";
+  } else {
+    const runningAgents = session.agents.filter(
+      (a) => lastCycle.agentsSpawned.includes(a.id) && a.status === "running"
+    );
+    if (runningAgents.length > 0) {
+      return `waiting on ${runningAgents.map((a) => a.id).join(", ")}`;
+    }
+    return "starting";
+  }
+}
 function formatAgent(agent) {
   const status = colorize(agent.status, agent.status);
   const name = `${BOLD}${agent.name}${RESET}`;
@@ -459,10 +738,41 @@ function formatAgent(agent) {
   }
   return line;
 }
-function formatCycle(cycle) {
-  const duration = cycle.completedAt ? ` ${DIM}(${formatDuration(cycle.timestamp, cycle.completedAt)})${RESET}` : ` ${DIM}(running)${RESET}`;
+function formatCycle(cycle, phase) {
+  let duration;
+  if (cycle.completedAt) {
+    duration = ` ${DIM}(${formatDuration(cycle.timestamp, cycle.completedAt)})${RESET}`;
+  } else {
+    const elapsed = formatDuration(cycle.timestamp, null);
+    duration = ` ${DIM}(running, ${elapsed})${RESET}`;
+  }
   const agents = cycle.agentsSpawned.length > 0 ? ` \u2014 agents: ${cycle.agentsSpawned.join(", ")}` : "";
-  return `    Cycle ${cycle.cycle}${duration}${agents}`;
+  const phaseStr = phase ? ` \u2014 orchestrator: ${phase}` : "";
+  return `    Cycle ${cycle.cycle}${duration}${agents}${phaseStr}`;
+}
+function computeLastActivity(session) {
+  const timestamps = [];
+  for (const cycle of session.orchestratorCycles) {
+    timestamps.push(new Date(cycle.timestamp).getTime());
+    if (cycle.completedAt) timestamps.push(new Date(cycle.completedAt).getTime());
+  }
+  for (const agent of session.agents) {
+    timestamps.push(new Date(agent.spawnedAt).getTime());
+    if (agent.completedAt) timestamps.push(new Date(agent.completedAt).getTime());
+    for (const r of agent.reports) {
+      timestamps.push(new Date(r.timestamp).getTime());
+    }
+  }
+  if (timestamps.length === 0) return null;
+  return new Date(Math.max(...timestamps));
+}
+function readRoadmapTodos(cwd, sessionId) {
+  try {
+    const content = readFileSync3(roadmapPath(cwd, sessionId), "utf8");
+    return content.split("\n").filter((line) => /^\s*- \[ \]/.test(line)).map((line) => line.replace(/^\s*- \[ \]\s*/, "")).slice(0, 5);
+  } catch {
+    return [];
+  }
 }
 function printSession(session) {
   const status = colorize(session.status, session.status);
@@ -477,13 +787,40 @@ ${BOLD}Session: ${session.id}${RESET}`);
   }
   console.log(`  CWD: ${session.cwd}`);
   console.log(`  Created: ${session.createdAt}`);
-  console.log(`  Duration: ${sessionDuration}${session.completedAt ? "" : " (ongoing)"}`);
+  const activeTime = formatDuration(computeActiveTimeMs(session));
+  console.log(`  Duration: ${sessionDuration}${session.completedAt ? "" : " (ongoing)"} (${activeTime} active)`);
+  const lastActivity = computeLastActivity(session);
+  if (lastActivity) {
+    console.log(`  Last activity: ${formatMs(Date.now() - lastActivity.getTime())} ago`);
+  }
   console.log(`  Orchestrator cycles: ${session.orchestratorCycles.length}`);
+  const runningAgents = session.agents.filter((a) => a.status === "running");
+  if (runningAgents.length > 0) {
+    console.log(`
+${BOLD}Active agents (${runningAgents.length}):${RESET}`);
+    for (const agent of runningAgents) {
+      const name = `${BOLD}${agent.name}${RESET}`;
+      const type = `${DIM}(${agent.agentType})${RESET}`;
+      const duration = formatDuration(agent.spawnedAt, null);
+      console.log(`  ${agent.id}  ${name}  ${type}  running ${duration}`);
+    }
+  }
+  const todos = readRoadmapTodos(session.cwd, session.id);
+  if (todos.length > 0) {
+    console.log(`
+${BOLD}Remaining (${todos.length} unchecked):${RESET}`);
+    for (const todo of todos) {
+      console.log(`  - ${todo}`);
+    }
+  }
   if (session.orchestratorCycles.length > 0) {
     console.log(`
   ${BOLD}Cycles:${RESET}`);
-    for (const cycle of session.orchestratorCycles) {
-      console.log(formatCycle(cycle));
+    const cycles = session.orchestratorCycles;
+    for (let i = 0; i < cycles.length; i++) {
+      const isLast = i === cycles.length - 1;
+      const phase = isLast && session.status === "active" ? inferOrchestratorPhase(session) : void 0;
+      console.log(formatCycle(cycles[i], phase));
     }
   }
   if (session.agents.length > 0) {
@@ -594,15 +931,15 @@ function registerReport(program2) {
 // src/cli/commands/resume.ts
 function registerResume(program2) {
   program2.command("resume").description("Resume a paused session").argument("<session-id>", "Session ID to resume").argument("[message]", "Additional instructions for the orchestrator").action(async (sessionId, message) => {
-    const tmuxSession = getTmuxSession();
-    const tmuxWindow = getTmuxWindow();
     const cwd = process.cwd();
-    const request = { type: "resume", sessionId, cwd, tmuxSession, tmuxWindow, message };
+    const request = { type: "resume", sessionId, cwd, message };
     const response = await sendRequest(request);
     if (response.ok) {
+      const tmuxSessionName = response.data?.tmuxSessionName;
       console.log(`Session ${sessionId} resumed`);
-      if (response.data?.tmuxWindow) {
-        console.log(`Orchestrator respawned in tmux window: ${response.data.tmuxWindow}`);
+      if (tmuxSessionName) {
+        console.log(`Tmux session: ${tmuxSessionName}`);
+        console.log(`  tmux attach -t ${tmuxSessionName}`);
       }
     } else {
       console.error(`Error: ${response.error}`);
@@ -666,6 +1003,248 @@ function registerNotify(program2) {
   });
 }
 
+// src/cli/commands/message.ts
+function registerMessage(program2) {
+  program2.command("message <content>").description("Queue a message for the orchestrator to see on next cycle").option("--session <sessionId>", "Session ID (defaults to SISYPHUS_SESSION_ID env var)").action(async (content, opts) => {
+    const sessionId = opts.session ?? process.env.SISYPHUS_SESSION_ID;
+    if (!sessionId) {
+      console.error("Error: provide --session or set SISYPHUS_SESSION_ID environment variable");
+      process.exit(1);
+    }
+    const source = process.env.SISYPHUS_AGENT_ID ? { type: "agent", agentId: process.env.SISYPHUS_AGENT_ID } : void 0;
+    const request = { type: "message", sessionId, content, source };
+    const response = await sendRequest(request);
+    if (response.ok) {
+      console.log("Message queued");
+    } else {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/update-task.ts
+function registerUpdateTask(program2) {
+  program2.command("update-task <task>").description("Update the session task/goal").option("--session <sessionId>", "Session ID (defaults to SISYPHUS_SESSION_ID env var)").action(async (task, opts) => {
+    const sessionId = opts.session ?? process.env.SISYPHUS_SESSION_ID;
+    if (!sessionId) {
+      console.error("Error: provide --session or set SISYPHUS_SESSION_ID environment variable");
+      process.exit(1);
+    }
+    const request = { type: "update-task", sessionId, task };
+    const response = await sendRequest(request);
+    if (response.ok) {
+      console.log("Task updated");
+    } else {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/rollback.ts
+function registerRollback(program2) {
+  program2.command("rollback <sessionId> <cycle>").description("Roll back a session to a previous cycle boundary").action(async (sessionId, cycleStr) => {
+    const toCycle = parseInt(cycleStr, 10);
+    if (isNaN(toCycle) || toCycle < 1) {
+      console.error("Error: cycle must be a positive integer");
+      process.exit(1);
+    }
+    const request = { type: "rollback", sessionId, cwd: process.cwd(), toCycle };
+    const response = await sendRequest(request);
+    if (response.ok) {
+      const data = response.data;
+      console.log(`Session ${sessionId} rolled back to cycle ${data.restoredToCycle}.`);
+      console.log(`Session is now paused. Use 'sisyphus resume ${sessionId}' to respawn the orchestrator.`);
+    } else {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/restart-agent.ts
+function registerRestartAgent(program2) {
+  program2.command("restart-agent <agentId>").description("Restart a failed/killed/lost agent in a new tmux pane").option("-s, --session <sessionId>", "Session ID (defaults to SISYPHUS_SESSION_ID)").action(async (agentId, opts) => {
+    const sessionId = opts.session ?? process.env.SISYPHUS_SESSION_ID;
+    if (!sessionId) {
+      console.error("Error: No session ID. Use --session or set SISYPHUS_SESSION_ID.");
+      process.exit(1);
+    }
+    const request = { type: "restart-agent", sessionId, agentId };
+    const response = await sendRequest(request);
+    if (response.ok) {
+      console.log(`Agent ${agentId} restarted.`);
+    } else {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/setup-keybind.ts
+function registerSetupKeybind(program2) {
+  program2.command("setup-keybind [key]").description("Install the sisyphus-cycle tmux keybinding (default: M-s)").action(async (key) => {
+    const resolvedKey = key ?? DEFAULT_KEY;
+    const result = setupTmuxKeybind(resolvedKey);
+    switch (result.status) {
+      case "installed":
+        console.log(result.message);
+        break;
+      case "already-installed":
+        console.log(result.message);
+        break;
+      case "conflict":
+        console.log(`Key ${resolvedKey} is already bound:`);
+        console.log(`  ${result.existingBinding}`);
+        console.log("");
+        console.log("Use a different key, e.g.:");
+        console.log("  sisyphus setup-keybind M-S");
+        console.log("  sisyphus setup-keybind M-w");
+        console.log("  sisyphus setup-keybind M-j");
+        break;
+    }
+  });
+}
+
+// src/cli/commands/doctor.ts
+import { execSync as execSync7 } from "child_process";
+import { existsSync as existsSync3, statSync } from "fs";
+function checkDaemonInstalled() {
+  if (isInstalled()) {
+    return { name: "Daemon plist", status: "ok", detail: "Installed in LaunchAgents" };
+  }
+  return {
+    name: "Daemon plist",
+    status: "fail",
+    detail: "Not installed",
+    fix: 'Run any sisyphus command to auto-install, or: sisyphus start "test"'
+  };
+}
+function checkDaemonRunning() {
+  const pid = daemonPidPath();
+  if (!existsSync3(pid)) {
+    return {
+      name: "Daemon process",
+      status: "fail",
+      detail: "No PID file found",
+      fix: "launchctl load -w ~/Library/LaunchAgents/com.sisyphus.daemon.plist"
+    };
+  }
+  try {
+    const sock = socketPath();
+    execSync7(`test -S "${sock}"`, { stdio: "pipe" });
+    return { name: "Daemon process", status: "ok", detail: `Socket at ${sock}` };
+  } catch {
+    return {
+      name: "Daemon process",
+      status: "warn",
+      detail: "PID file exists but socket not found",
+      fix: `Check logs: tail -20 ${daemonLogPath()}`
+    };
+  }
+}
+function checkTmux() {
+  try {
+    execSync7("which tmux", { stdio: "pipe" });
+  } catch {
+    return { name: "tmux", status: "fail", detail: "Not found on PATH", fix: "brew install tmux" };
+  }
+  try {
+    execSync7("tmux list-sessions", { stdio: "pipe" });
+    return { name: "tmux", status: "ok", detail: "Running" };
+  } catch {
+    return { name: "tmux", status: "warn", detail: "Installed but no server running" };
+  }
+}
+function checkCycleScript() {
+  const path = cycleScriptPath();
+  if (!existsSync3(path)) {
+    return {
+      name: "Cycle script",
+      status: "fail",
+      detail: `Not found at ${path}`,
+      fix: "sisyphus setup-keybind"
+    };
+  }
+  try {
+    const mode = statSync(path).mode;
+    if ((mode & 73) === 0) {
+      return {
+        name: "Cycle script",
+        status: "fail",
+        detail: "Not executable",
+        fix: `chmod +x ${path}`
+      };
+    }
+  } catch {
+  }
+  return { name: "Cycle script", status: "ok", detail: path };
+}
+function checkTmuxKeybind() {
+  const existing = getExistingBinding(DEFAULT_KEY);
+  if (existing === null) {
+    if (existsSync3(sisyphusTmuxConfPath())) {
+      return {
+        name: `Tmux keybind (${DEFAULT_KEY})`,
+        status: "warn",
+        detail: "Configured in sisyphus tmux.conf but not active (tmux may not be running)"
+      };
+    }
+    return {
+      name: `Tmux keybind (${DEFAULT_KEY})`,
+      status: "fail",
+      detail: "Not bound",
+      fix: "sisyphus setup-keybind"
+    };
+  }
+  if (isSisyphusBinding(existing)) {
+    return { name: `Tmux keybind (${DEFAULT_KEY})`, status: "ok", detail: "Bound to sisyphus-cycle" };
+  }
+  return {
+    name: `Tmux keybind (${DEFAULT_KEY})`,
+    status: "warn",
+    detail: `Bound to something else: ${existing}`,
+    fix: "sisyphus setup-keybind M-S  (or another free key)"
+  };
+}
+function checkGlobalDir() {
+  const dir = globalDir();
+  if (existsSync3(dir)) {
+    return { name: "Data directory", status: "ok", detail: dir };
+  }
+  return { name: "Data directory", status: "warn", detail: `${dir} does not exist (created on first use)` };
+}
+var SYMBOLS = { ok: "\u2713", warn: "!", fail: "\u2717" };
+function registerDoctor(program2) {
+  program2.command("doctor").description("Check sisyphus installation health").action(async () => {
+    const checks = [
+      checkGlobalDir(),
+      checkDaemonInstalled(),
+      checkDaemonRunning(),
+      checkTmux(),
+      checkCycleScript(),
+      checkTmuxKeybind()
+    ];
+    let hasIssues = false;
+    for (const c of checks) {
+      const sym = SYMBOLS[c.status];
+      console.log(`  ${sym} ${c.name}: ${c.detail}`);
+      if (c.status !== "ok") hasIssues = true;
+    }
+    const fixable = checks.filter((c) => c.fix);
+    if (fixable.length > 0) {
+      console.log("\nFixes:");
+      for (const c of fixable) {
+        console.log(`  ${c.name}: ${c.fix}`);
+      }
+    }
+    if (!hasIssues) {
+      console.log("\nAll checks passed.");
+    }
+  });
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("sisyphus").description("tmux-integrated orchestration daemon for Claude Code").version("0.1.0");
@@ -675,12 +1254,20 @@ registerSubmit(program);
 registerReport(program);
 registerYield(program);
 registerComplete(program);
+registerContinue(program);
 registerStatus(program);
 registerList(program);
 registerResume(program);
 registerKill(program);
 registerUninstall(program);
 registerNotify(program);
+registerMessage(program);
+registerUpdateTask(program);
+registerDashboard(program);
+registerRollback(program);
+registerRestartAgent(program);
+registerSetupKeybind(program);
+registerDoctor(program);
 program.parseAsync(process.argv).catch((err) => {
   console.error(err.message);
   process.exit(1);