sisyphi 1.2.2 → 1.2.12

package/dist/daemon.js

@@ -18,6 +18,9 @@ __export(paths_exports, {
   askMetaPath: () => askMetaPath,
   askOutputPath: () => askOutputPath,
   askProgressPath: () => askProgressPath,
+  askReviewDraftPath: () => askReviewDraftPath,
+  askReviewPath: () => askReviewPath,
+  askReviewSubmitFlagPath: () => askReviewSubmitFlagPath,
   askVisualAnsiPath: () => askVisualAnsiPath,
   askVisualMarkdownPath: () => askVisualMarkdownPath,
   askVisualsDir: () => askVisualsDir,
@@ -195,14 +198,23 @@ function askMetaPath(cwd, sessionId, askId) {
   return join(askEntryDir(cwd, sessionId, askId), "meta.json");
 }
 function askDecisionsPath(cwd, sessionId, askId) {
-  return join(askEntryDir(cwd, sessionId, askId), "decisions.json");
+  return join(askEntryDir(cwd, sessionId, askId), "deck.json");
 }
 function askOutputPath(cwd, sessionId, askId) {
-  return join(askEntryDir(cwd, sessionId, askId), "output.json");
+  return join(askEntryDir(cwd, sessionId, askId), "response.json");
 }
 function askProgressPath(cwd, sessionId, askId) {
   return join(askEntryDir(cwd, sessionId, askId), "progress.json");
 }
+function askReviewPath(cwd, sessionId, askId) {
+  return join(askEntryDir(cwd, sessionId, askId), "review.json");
+}
+function askReviewDraftPath(cwd, sessionId, askId) {
+  return join(askEntryDir(cwd, sessionId, askId), "draft.json");
+}
+function askReviewSubmitFlagPath(cwd, sessionId, askId) {
+  return join(askEntryDir(cwd, sessionId, askId), "submitted");
+}
 function askVisualsDir(cwd, sessionId, askId) {
   return join(askEntryDir(cwd, sessionId, askId), "visuals");
 }
@@ -328,6 +340,7 @@ var init_config = __esm({
     DEFAULT_CONFIG = {
       model: "claude-opus-4-7[1m]",
       pollIntervalMs: 5e3,
+      statusBarRenderTicks: 4,
       orchestratorEffort: "xhigh",
       agentEffort: "medium",
       notifications: {
@@ -337,11 +350,32 @@ var init_config = __esm({
       companionPopup: true,
       requiredPlugins: [
         { name: "devcore", marketplace: "crouton-kit", owner: "crouton-labs" }
+      ],
+      requiredCrtrPlugins: [
+        {
+          marketplace: "sisyphus",
+          plugin: "sisyphus",
+          gitUrl: "https://github.com/crouton-labs/sisyphus"
+        }
       ]
     };
   }
 });
 
+// src/shared/protocol.ts
+var errUsage, errNotFound, errAmbiguous, errConflict, errTransient, errPermanent;
+var init_protocol = __esm({
+  "src/shared/protocol.ts"() {
+    "use strict";
+    errUsage = (code, f) => ({ kind: "usage", code, ...f });
+    errNotFound = (code, f) => ({ kind: "not_found", code, ...f });
+    errAmbiguous = (code, f) => ({ kind: "ambiguous", code, ...f });
+    errConflict = (code, f) => ({ kind: "conflict", code, ...f });
+    errTransient = (code, f) => ({ kind: "transient", code, ...f });
+    errPermanent = (code, f) => ({ kind: "permanent", code, ...f });
+  }
+});
+
 // src/shared/shell.ts
 function shellQuote(s) {
   return `'${s.replace(/'/g, "'\\''")}'`;
@@ -439,7 +473,7 @@ var init_types = __esm({
 });
 
 // src/daemon/state.ts
-import { copyFileSync, cpSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, readdirSync, rmSync, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { copyFileSync, cpSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, readdirSync, rmSync, statSync, watch as fsWatch, writeFileSync as writeFileSync3 } from "fs";
 import { join as join4 } from "path";
 function withSessionLock(sessionId, fn) {
   return withLock(sessionId, fn);
@@ -481,9 +515,7 @@ function createSession(id, task, cwd, context, name, effort) {
   atomicWrite(statePath(cwd, id), JSON.stringify(session, null, 2));
   return session;
 }
-function getSession(cwd, sessionId) {
-  const content = readFileSync3(statePath(cwd, sessionId), "utf-8");
-  const session = JSON.parse(content);
+function normalizeSession(session) {
   if (session.activeMs == null) session.activeMs = 0;
   if (session.userBlockedMs == null) session.userBlockedMs = 0;
   for (const agent of session.agents) {
@@ -496,10 +528,106 @@ function getSession(cwd, sessionId) {
     if (cycle.activeMs == null) cycle.activeMs = 0;
     if (cycle.userBlockedMs == null) cycle.userBlockedMs = 0;
   }
+}
+function loadFromDisk(p) {
+  const session = JSON.parse(readFileSync3(p, "utf-8"));
+  normalizeSession(session);
   return session;
 }
+function reloadIntoCache(p) {
+  if (!sessionCache.has(p)) return;
+  try {
+    sessionCache.set(p, loadFromDisk(p));
+  } catch (err) {
+    console.warn(`[sisyphus] state cache reload failed for ${p}:`, err instanceof Error ? err.message : err);
+  }
+}
+function scheduleReload(p) {
+  const existing = debounceTimers.get(p);
+  if (existing) clearTimeout(existing);
+  const t2 = setTimeout(() => {
+    debounceTimers.delete(p);
+    reloadIntoCache(p);
+  }, DEBOUNCE_MS);
+  t2.unref?.();
+  debounceTimers.set(p, t2);
+}
+function installWatcher(p) {
+  if (watchers.has(p)) return;
+  let w;
+  try {
+    w = fsWatch(p, { persistent: false });
+  } catch (err) {
+    console.warn(`[sisyphus] fs.watch install failed for ${p}:`, err instanceof Error ? err.message : err);
+    return;
+  }
+  w.on("change", (eventType) => {
+    if (eventType === "rename") {
+      try {
+        w.close();
+      } catch {
+      }
+      watchers.delete(p);
+      scheduleReload(p);
+      const reinstall = setTimeout(() => {
+        if (sessionCache.has(p)) installWatcher(p);
+      }, DEBOUNCE_MS + 10);
+      reinstall.unref?.();
+    } else {
+      scheduleReload(p);
+    }
+  });
+  w.on("error", (err) => {
+    console.warn(`[sisyphus] fs.watch error for ${p}:`, err instanceof Error ? err.message : err);
+    try {
+      w.close();
+    } catch {
+    }
+    watchers.delete(p);
+  });
+  watchers.set(p, w);
+}
+function installStateWatcher(cwd, sessionId) {
+  const p = statePath(cwd, sessionId);
+  try {
+    sessionCache.set(p, loadFromDisk(p));
+  } catch (err) {
+    console.warn(`[sisyphus] state cache prime failed for ${p}:`, err instanceof Error ? err.message : err);
+    return;
+  }
+  setImmediate(() => {
+    if (sessionCache.has(p)) installWatcher(p);
+  });
+}
+function uninstallStateWatcher(cwd, sessionId) {
+  const p = statePath(cwd, sessionId);
+  const w = watchers.get(p);
+  if (w) {
+    try {
+      w.close();
+    } catch {
+    }
+    watchers.delete(p);
+  }
+  const t2 = debounceTimers.get(p);
+  if (t2) {
+    clearTimeout(t2);
+    debounceTimers.delete(p);
+  }
+  sessionCache.delete(p);
+}
+function getSession(cwd, sessionId) {
+  const p = statePath(cwd, sessionId);
+  const hit = sessionCache.get(p);
+  if (hit) return structuredClone(hit);
+  return loadFromDisk(p);
+}
 function saveSession(session) {
-  atomicWrite(statePath(session.cwd, session.id), JSON.stringify(session, null, 2));
+  const p = statePath(session.cwd, session.id);
+  atomicWrite(p, JSON.stringify(session, null, 2));
+  if (sessionCache.has(p)) {
+    sessionCache.set(p, structuredClone(session));
+  }
 }
 function isSessionDangerous(cwd, sessionId) {
   try {
@@ -874,7 +1002,7 @@ async function createCloneState(sourceCwd, sourceId, cloneId, goal, context, con
     return clone;
   });
 }
-var ROADMAP_SEED, CONTEXT_CLAUDE_MD;
+var ROADMAP_SEED, CONTEXT_CLAUDE_MD, sessionCache, watchers, debounceTimers, DEBOUNCE_MS;
 var init_state = __esm({
   "src/daemon/state.ts"() {
     "use strict";
@@ -891,6 +1019,10 @@ description: >
 
 Agents save exploration findings, architectural notes, and reference material here for use across cycles.
 `;
+    sessionCache = /* @__PURE__ */ new Map();
+    watchers = /* @__PURE__ */ new Map();
+    debounceTimers = /* @__PURE__ */ new Map();
+    DEBOUNCE_MS = 25;
   }
 });
 
@@ -926,6 +1058,38 @@ var init_spawn_helpers = __esm({
   }
 });
 
+// src/daemon/help-inject.ts
+import { execSync } from "child_process";
+function injectHelp(text) {
+  if (!text.includes("{{HELP:")) return text;
+  const cliBin = resolveCliBin();
+  const renderHelp = (cmd) => {
+    try {
+      return execSync(`${process.execPath} ${cliBin} ${cmd} -h`, {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 1e4
+      }).trim();
+    } catch (e) {
+      const out = e.stdout;
+      if (typeof out === "string" && out.length > 0) return out.trim();
+      return `(help unavailable: sis ${cmd} -h)`;
+    }
+  };
+  return text.replace(/\{\{HELP:([^}]+)\}\}/g, (_m, cmd) => {
+    const c = cmd.trim();
+    return `<cli-guide bash="sis ${c} -h">
+${renderHelp(c)}
+</cli-guide>`;
+  });
+}
+var init_help_inject = __esm({
+  "src/daemon/help-inject.ts"() {
+    "use strict";
+    init_spawn_helpers();
+  }
+});
+
 // src/shared/env.ts
 import { resolve as resolve2 } from "path";
 function augmentedPath() {
@@ -963,10 +1127,12 @@ function augmentedPath() {
   return prepend.length > 0 ? `${prepend.join(":")}:${basePath}` : basePath;
 }
 function execEnv() {
-  return {
+  const env = {
     ...process.env,
     PATH: augmentedPath()
   };
+  if (!env["LC_ALL"] && !env["LANG"]) env["LANG"] = "en_US.UTF-8";
+  return env;
 }
 var init_env = __esm({
   "src/shared/env.ts"() {
@@ -975,13 +1141,13 @@ var init_env = __esm({
 });
 
 // src/shared/exec.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function exec(cmd, cwd, timeoutMs = 3e4) {
-  return execSync(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, timeout: timeoutMs }).trim();
+  return execSync2(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, timeout: timeoutMs }).trim();
 }
 function execSafe(cmd, cwd, timeoutMs) {
   try {
-    return execSync(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, stdio: ["pipe", "pipe", "pipe"], timeout: timeoutMs }).trim();
+    return execSync2(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, stdio: ["pipe", "pipe", "pipe"], timeout: timeoutMs }).trim();
   } catch {
     return null;
   }
@@ -995,6 +1161,31 @@ var init_exec = __esm({
   }
 });
 
+// src/shared/digest-verbs.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+function digestSpinnerVerbs(cwd, sessionId) {
+  try {
+    const dp = digestPath(cwd, sessionId);
+    if (!existsSync4(dp)) return null;
+    const raw = JSON.parse(readFileSync4(dp, "utf-8"));
+    if (!raw || typeof raw.recentWork !== "string" || typeof raw.currentActivity !== "string" || typeof raw.whatsNext !== "string" || !Array.isArray(raw.unusualEvents)) {
+      return null;
+    }
+    const base = [raw.recentWork, raw.currentActivity, raw.whatsNext].map((v) => v.trim()).filter((v) => v.length > 0);
+    const unusual = raw.unusualEvents.filter((e) => typeof e === "string").map((e) => e.trim()).filter((e) => e.length > 0).map((e) => `unusual: ${e}`);
+    const verbs = [...base, ...unusual];
+    return verbs.length > 0 ? verbs : null;
+  } catch {
+    return null;
+  }
+}
+var init_digest_verbs = __esm({
+  "src/shared/digest-verbs.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
 // src/daemon/colors.ts
 function normalizeTmuxColor(color) {
   return TMUX_COLOR_MAP[color] ?? color;
@@ -1023,7 +1214,7 @@ var init_colors = __esm({
 });
 
 // src/daemon/frontmatter.ts
-import { readFileSync as readFileSync4, existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join5, basename as basename2 } from "path";
 function detectProvider(model) {
@@ -1070,7 +1261,7 @@ function extractAgentBody(content) {
 function findPluginInstallPath(namespace) {
   try {
     const registryPath2 = join5(homedir2(), ".claude", "plugins", "installed_plugins.json");
-    const registry = JSON.parse(readFileSync4(registryPath2, "utf-8"));
+    const registry = JSON.parse(readFileSync5(registryPath2, "utf-8"));
     for (const key of Object.keys(registry)) {
       if (key.startsWith(`${namespace}@`)) {
         return registry[key].installPath ?? null;
@@ -1104,7 +1295,7 @@ function resolveAgentTypePath(agentType, pluginDir, cwd) {
     searchPaths.push(join5(pluginDir, "agents", `${name}.md`));
   }
   for (const path of searchPaths) {
-    if (existsSync4(path)) return path;
+    if (existsSync5(path)) return path;
   }
   return null;
 }
@@ -1125,7 +1316,7 @@ function discoverAgentTypes(pluginDir, cwd) {
       if (seen.has(qualifiedName)) continue;
       seen.add(qualifiedName);
       try {
-        const content = readFileSync4(join5(dir, file), "utf-8");
+        const content = readFileSync5(join5(dir, file), "utf-8");
         const fm = parseAgentFrontmatter(content);
         results.push({ qualifiedName, source, description: fm.description, model: fm.model });
       } catch {
@@ -1140,7 +1331,7 @@ function discoverAgentTypes(pluginDir, cwd) {
   scanDir(join5(pluginDir, "agents"), "sisyphus", "bundled");
   try {
     const registryPath2 = join5(homedir2(), ".claude", "plugins", "installed_plugins.json");
-    const registry = JSON.parse(readFileSync4(registryPath2, "utf-8"));
+    const registry = JSON.parse(readFileSync5(registryPath2, "utf-8"));
     const pluginEntries = registry.plugins ?? registry;
     for (const key of Object.keys(pluginEntries)) {
       const atIdx = key.indexOf("@");
@@ -1160,7 +1351,7 @@ function resolveAgentConfig(agentType, pluginDir, cwd) {
   const filePath = resolveAgentTypePath(agentType, pluginDir, cwd);
   if (!filePath) return null;
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     return {
       frontmatter: parseAgentFrontmatter(content),
       body: extractAgentBody(content),
@@ -1178,22 +1369,22 @@ var init_frontmatter = __esm({
 });
 
 // src/daemon/orchestrator-modes.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync6, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve3, join as join6 } from "path";
 import { homedir as homedir3 } from "os";
 function resolveTemplatesDir() {
   const distLayout = resolve3(import.meta.dirname, "../templates");
-  if (existsSync5(distLayout)) return distLayout;
+  if (existsSync6(distLayout)) return distLayout;
   const srcLayout = resolve3(import.meta.dirname, "../../templates");
-  if (existsSync5(srcLayout)) return srcLayout;
+  if (existsSync6(srcLayout)) return srcLayout;
   return void 0;
 }
 function modeLayers(cwd) {
   const layers = [];
   const project = projectDir(cwd);
-  if (existsSync5(project)) layers.push({ source: "project", dir: project });
+  if (existsSync6(project)) layers.push({ source: "project", dir: project });
   const user = join6(homedir3(), ".sisyphus");
-  if (existsSync5(user)) layers.push({ source: "user", dir: user });
+  if (existsSync6(user)) layers.push({ source: "user", dir: user });
   const bundled = resolveTemplatesDir();
   if (bundled) layers.push({ source: "bundled", dir: bundled });
   return layers;
@@ -1215,7 +1406,7 @@ function discoverOrchestratorModes(cwd) {
       const filePath = join6(layer.dir, file);
       let content = "";
       try {
-        content = readFileSync5(filePath, "utf-8");
+        content = readFileSync6(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -1270,7 +1461,7 @@ var init_effort_render = __esm({
 });
 
 // src/daemon/lib/render-plugin.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, rmSync as rmSync2, existsSync as existsSync6 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync2, copyFileSync as copyFileSync2, rmSync as rmSync2, existsSync as existsSync7 } from "fs";
 import { join as join7 } from "path";
 function isFiltered(name) {
   for (const ext of FILTERED_EXTS) {
@@ -1279,7 +1470,7 @@ function isFiltered(name) {
   return false;
 }
 function renderPluginDir(srcDir, destDir, tier) {
-  if (!existsSync6(srcDir)) {
+  if (!existsSync7(srcDir)) {
     throw new Error(`renderPluginDir: source dir does not exist: ${srcDir}`);
   }
   rmSync2(destDir, { recursive: true, force: true });
@@ -1295,7 +1486,7 @@ function walk(src, dest, tier) {
       walk(srcPath, destPath, tier);
     } else if (entry.isFile()) {
       if (isFiltered(entry.name)) {
-        const rendered = renderEffortMarkers(readFileSync6(srcPath, "utf-8"), tier);
+        const rendered = renderEffortMarkers(readFileSync7(srcPath, "utf-8"), tier);
         writeFileSync5(destPath, rendered, "utf-8");
       } else {
         copyFileSync2(srcPath, destPath);
@@ -1313,21 +1504,21 @@ var init_render_plugin = __esm({
 });
 
 // src/daemon/extensions.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, readdirSync as readdirSync5, copyFileSync as copyFileSync3, mkdirSync as mkdirSync3, statSync as statSync2, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, readdirSync as readdirSync5, copyFileSync as copyFileSync3, mkdirSync as mkdirSync3, statSync as statSync2, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve4, join as join8, basename as basename3, relative } from "path";
 function resolveBundledTemplateDir(kind) {
   const built = resolve4(import.meta.dirname, "../templates", kind);
-  if (existsSync7(built)) return built;
+  if (existsSync8(built)) return built;
   const src = resolve4(import.meta.dirname, "../../templates", kind);
-  if (existsSync7(src)) return src;
+  if (existsSync8(src)) return src;
   return void 0;
 }
 function agentPluginLayers(cwd) {
   const layers = [];
   const project = projectAgentPluginDir(cwd);
-  if (existsSync7(project)) layers.push({ source: "project", root: project });
+  if (existsSync8(project)) layers.push({ source: "project", root: project });
   const user = userAgentPluginDir();
-  if (existsSync7(user)) layers.push({ source: "user", root: user });
+  if (existsSync8(user)) layers.push({ source: "user", root: user });
   const bundled = resolveBundledTemplateDir("agent-plugin");
   if (bundled) layers.push({ source: "bundled", root: bundled });
   return layers;
@@ -1335,18 +1526,18 @@ function agentPluginLayers(cwd) {
 function orchestratorPluginLayers(cwd) {
   const layers = [];
   const project = projectOrchestratorPluginDir(cwd);
-  if (existsSync7(project)) layers.push({ source: "project", root: project });
+  if (existsSync8(project)) layers.push({ source: "project", root: project });
   const user = userOrchestratorPluginDir();
-  if (existsSync7(user)) layers.push({ source: "user", root: user });
+  if (existsSync8(user)) layers.push({ source: "user", root: user });
   const bundled = resolveBundledTemplateDir("orchestrator-plugin");
   if (bundled) layers.push({ source: "bundled", root: bundled });
   return layers;
 }
 function readManifest(layerRoot) {
   const path = join8(layerRoot, "hooks", "hooks.json");
-  if (!existsSync7(path)) return null;
+  if (!existsSync8(path)) return null;
   try {
-    const raw = readFileSync7(path, "utf-8");
+    const raw = readFileSync8(path, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch (err) {
@@ -1354,8 +1545,8 @@ function readManifest(layerRoot) {
     return null;
   }
 }
-function commandScriptName(command2) {
-  const match = command2.match(/([\w.-]+\.[\w]+)\s*$/);
+function commandScriptName(command) {
+  const match = command.match(/([\w.-]+\.[\w]+)\s*$/);
   return match ? match[1] : null;
 }
 function groupApplies(group, ctx) {
@@ -1402,7 +1593,7 @@ function copyLayered(layers, opts) {
   const written = /* @__PURE__ */ new Set();
   for (const layer of layers) {
     const layerSubdir = join8(layer.root, opts.subdir);
-    if (!existsSync7(layerSubdir)) continue;
+    if (!existsSync8(layerSubdir)) continue;
     let entries;
     try {
       entries = readdirSync5(layerSubdir);
@@ -1470,7 +1661,7 @@ function indexAvailableSkills(layers) {
   const index = /* @__PURE__ */ new Map();
   for (const layer of layers) {
     const skillsRoot = join8(layer.root, "skills");
-    if (!existsSync7(skillsRoot)) continue;
+    if (!existsSync8(skillsRoot)) continue;
     let entries;
     try {
       entries = readdirSync5(skillsRoot);
@@ -1504,7 +1695,7 @@ function isRenderable(name) {
 function collectOverlay(layers) {
   const overlay = /* @__PURE__ */ new Map();
   for (const layer of layers) {
-    if (!existsSync7(layer.root)) continue;
+    if (!existsSync8(layer.root)) continue;
     walkRelative(layer.root, "", (relPath, absPath) => {
       if (overlay.has(relPath)) return;
       overlay.set(relPath, { src: absPath, source: layer.source });
@@ -1544,7 +1735,7 @@ function renderLayeredPluginDir(layers, destDir, tier) {
     const destPath = join8(destDir, relPath);
     mkdirSync3(join8(destPath, ".."), { recursive: true });
     if (isRenderable(basename3(relPath))) {
-      const rendered = renderEffortMarkers(readFileSync7(entry.src, "utf-8"), tier);
+      const rendered = renderEffortMarkers(readFileSync8(entry.src, "utf-8"), tier);
       writeFileSync6(destPath, rendered, "utf-8");
     } else {
       copyFileSync3(entry.src, destPath);
@@ -1563,7 +1754,7 @@ var init_extensions = __esm({
 });
 
 // src/daemon/tmux.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function planSendKeys(state) {
   if (!state.exists || state.dead) return { action: "abort" };
   if (state.inMode) return { action: "cancel-then-send" };
@@ -1585,14 +1776,14 @@ function createPane(windowTarget, cwd, position = "right") {
   execSafe(`tmux select-layout -t ${t(windowTarget)} even-horizontal`);
   return paneId;
 }
-function sendKeys(paneTarget, command2) {
+function sendKeys(paneTarget, command) {
   const state = getPaneState(paneTarget);
   const { action } = planSendKeys(state);
   if (action === "abort") throw new PaneUnavailableError(paneTarget, state);
   if (action === "cancel-then-send") {
     execSafe(`tmux send-keys -t ${t(paneTarget)} -X cancel`, void 0, TMUX_TIMEOUT_MS);
   }
-  exec(`tmux send-keys -t ${t(paneTarget)} ${shellQuote(command2)} Enter`, void 0, TMUX_TIMEOUT_MS);
+  exec(`tmux send-keys -t ${t(paneTarget)} ${shellQuote(command)} Enter`, void 0, TMUX_TIMEOUT_MS);
 }
 function pasteToPane(paneTarget, text, submit) {
   const state = getPaneState(paneTarget);
@@ -1602,7 +1793,7 @@ function pasteToPane(paneTarget, text, submit) {
     execSafe(`tmux send-keys -t ${t(paneTarget)} -X cancel`, void 0, TMUX_TIMEOUT_MS);
   }
   const bufName = `sisyphus-tell-${Math.random().toString(36).slice(2, 10)}`;
-  execSync2(`tmux load-buffer -b ${shellQuote(bufName)} -`, {
+  execSync3(`tmux load-buffer -b ${shellQuote(bufName)} -`, {
     input: text,
     env: EXEC_ENV,
     timeout: TMUX_TIMEOUT_MS,
@@ -1703,13 +1894,27 @@ function getFirstWindowId(sessionTarget) {
   return execSafe(`tmux list-windows -t ${t(sessionTarget)} -F "#{window_id}" -f "#{==:#{window_index},0}"`)?.trim() || null;
 }
 function listPanes(windowTarget) {
-  const output = execSafe(`tmux list-panes -t ${t(windowTarget)} -F "#{pane_id} #{pane_pid}"`);
+  const output = execSafe(`tmux list-panes -t ${t(windowTarget)} -F "#{pane_id} #{pane_pid}"`, void 0, TMUX_TIMEOUT_MS);
   if (!output) return [];
   return output.split("\n").filter(Boolean).map((line) => {
     const [paneId, panePid] = line.split(" ");
     return { paneId, panePid };
   });
 }
+function listAllPanesByWindow() {
+  const output = execSafe('tmux list-panes -a -F "#{window_id} #{pane_id} #{pane_pid}"', void 0, TMUX_TIMEOUT_MS);
+  const map = /* @__PURE__ */ new Map();
+  if (!output) return map;
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const [windowId, paneId, panePid] = line.split(" ");
+    if (!windowId || !paneId || !panePid) continue;
+    const bucket = map.get(windowId);
+    if (bucket) bucket.push({ paneId, panePid });
+    else map.set(windowId, [{ paneId, panePid }]);
+  }
+  return map;
+}
 function setPaneTitle(paneTarget, title) {
   execSafe(`tmux select-pane -t ${t(paneTarget)} -T ${shellQuote(title)}`);
 }
@@ -1754,11 +1959,6 @@ function listAllSessions() {
   if (!output) return [];
   return output.split("\n").filter(Boolean).map(parseSessionLine);
 }
-function listWindowPanes(windowTarget) {
-  const output = execSafe(`tmux list-panes -t ${t(windowTarget)} -F '#{pane_id}'`);
-  if (!output) return [];
-  return output.split("\n").filter(Boolean).map((paneId) => ({ paneId }));
-}
 function listAllPanes() {
   const output = execSafe('tmux list-panes -a -F "#{session_name} #{pane_id}"');
   if (!output) return [];
@@ -1767,6 +1967,23 @@ function listAllPanes() {
     return { sessionName: line.slice(0, spaceIdx), paneId: line.slice(spaceIdx + 1) };
   });
 }
+function listAllWindowsBySession() {
+  const output = execSafe('tmux list-windows -a -F "#{session_name}	#{window_index}	#{window_id}	#{window_name}"', void 0, TMUX_TIMEOUT_MS);
+  const map = /* @__PURE__ */ new Map();
+  if (!output) return map;
+  for (const line of output.split("\n")) {
+    if (!line) continue;
+    const [sessionName, indexStr, id, ...nameParts] = line.split("	");
+    if (!sessionName || indexStr == null || !id) continue;
+    const index = parseInt(indexStr, 10);
+    if (!Number.isFinite(index)) continue;
+    const name = nameParts.join("	");
+    const bucket = map.get(sessionName);
+    if (bucket) bucket.push({ index, id, name });
+    else map.set(sessionName, [{ index, id, name }]);
+  }
+  return map;
+}
 function configureSessionDefaults(sessionTarget, windowId) {
   execSafe(`tmux set -w -t ${t(windowId)} pane-border-status top`);
   execSafe(`tmux set -w -t ${t(windowId)} allow-rename off`);
@@ -2005,7 +2222,7 @@ var init_summarize = __esm({
 });
 
 // src/daemon/plugins.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { execFileSync } from "child_process";
 import { homedir as homedir4 } from "os";
 import { join as join9 } from "path";
@@ -2015,7 +2232,7 @@ function installedPluginsPath() {
 function resolveInstalledPlugin(name) {
   let data;
   try {
-    data = JSON.parse(readFileSync8(installedPluginsPath(), "utf-8"));
+    data = JSON.parse(readFileSync9(installedPluginsPath(), "utf-8"));
   } catch {
     return null;
   }
@@ -2078,7 +2295,7 @@ var init_plugins = __esm({
 });
 
 // src/daemon/history.ts
-import { appendFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, renameSync as renameSync2, readdirSync as readdirSync6, readFileSync as readFileSync9, rmSync as rmSync4, statSync as statSync3 } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync7, renameSync as renameSync2, readdirSync as readdirSync6, readFileSync as readFileSync10, rmSync as rmSync4, statSync as statSync3 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import { dirname as dirname2, join as join10 } from "path";
 function ensureDir(sessionId) {
@@ -2181,7 +2398,7 @@ function getRecentSentiments(count = 5, scanLimit = 30, overrideBaseDir) {
     const limit = Math.min(withMtime.length, scanLimit);
     for (let i = 0; i < limit && results.length < count; i++) {
       try {
-        const raw = readFileSync9(join10(base, withMtime[i].name, "session.json"), "utf-8");
+        const raw = readFileSync10(join10(base, withMtime[i].name, "session.json"), "utf-8");
         const summary = JSON.parse(raw);
         if (summary.sentiment && summary.completedAt) {
           results.push({
@@ -2213,13 +2430,13 @@ function pruneHistory() {
       const dir = join10(base, name);
       try {
         const summaryPath = join10(dir, "session.json");
-        const raw = readFileSync9(summaryPath, "utf-8");
+        const raw = readFileSync10(summaryPath, "utf-8");
         const summary = JSON.parse(raw);
         sessions.push({ dir, startedAt: new Date(summary.startedAt ?? 0).getTime() });
       } catch {
         try {
           const eventsPath = join10(dir, "events.jsonl");
-          const firstLine = readFileSync9(eventsPath, "utf-8").split("\n")[0];
+          const firstLine = readFileSync10(eventsPath, "utf-8").split("\n")[0];
           const firstEvent = JSON.parse(firstLine);
           sessions.push({ dir, startedAt: new Date(firstEvent.ts ?? 0).getTime() });
         } catch {
@@ -2255,8 +2472,8 @@ var init_history = __esm({
 });
 
 // src/shared/platform.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync10 } from "fs";
+import { execSync as execSync4 } from "child_process";
+import { existsSync as existsSync9, readFileSync as readFileSync11 } from "fs";
 function detectPlatform() {
   if (cachedPlatform) return cachedPlatform;
   if (process.platform === "darwin") {
@@ -2273,8 +2490,8 @@ function detectPlatform() {
 function isWsl() {
   if (process.env["WSL_DISTRO_NAME"] || process.env["WSL_INTEROP"]) return true;
   try {
-    if (existsSync8("/proc/version")) {
-      const v = readFileSync10("/proc/version", "utf-8").toLowerCase();
+    if (existsSync9("/proc/version")) {
+      const v = readFileSync11("/proc/version", "utf-8").toLowerCase();
       if (v.includes("microsoft") || v.includes("wsl")) return true;
     }
   } catch {
@@ -2285,7 +2502,7 @@ function hasCommand(cmd) {
   const cached = cmdCache.get(cmd);
   if (cached !== void 0) return cached;
   try {
-    execSync3(`command -v ${cmd}`, { stdio: "pipe", shell: "/bin/sh" });
+    execSync4(`command -v ${cmd}`, { stdio: "pipe", shell: "/bin/sh" });
     cmdCache.set(cmd, true);
     return true;
   } catch {
@@ -2303,7 +2520,7 @@ var init_platform = __esm({
 
 // src/daemon/notify.ts
 import { spawn, execFile } from "child_process";
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync9 } from "fs";
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync10 } from "fs";
 import { join as join11 } from "path";
 import { homedir as homedir5 } from "os";
 function ensureSwitchScript() {
@@ -2323,7 +2540,7 @@ function ensureNotifyProcess() {
     return notifyProcess;
   }
   const binary = getNotifyBinary();
-  if (!existsSync9(binary)) {
+  if (!existsSync10(binary)) {
     return null;
   }
   notifyProcess = spawn(binary, [], {
@@ -2445,7 +2662,7 @@ var init_notify = __esm({
 });
 
 // src/daemon/ask-store.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync11, readdirSync as readdirSync7 } from "fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync12, readdirSync as readdirSync7 } from "fs";
 function maybeNotifyOnAskCreated(cwd, sessionId, meta) {
   if (process.env.NODE_ENV === "test" || process.env.SISYPHUS_DISABLE_NOTIFY === "1") return;
   const isActionable = meta.kind !== void 0 && ACTIONABLE_KINDS.has(meta.kind);
@@ -2496,7 +2713,7 @@ function writeDecisions(cwd, sessionId, askId, deck) {
 function readDecisions(cwd, sessionId, askId) {
   const p = askDecisionsPath(cwd, sessionId, askId);
   try {
-    return JSON.parse(readFileSync11(p, { encoding: "utf-8" }));
+    return JSON.parse(readFileSync12(p, { encoding: "utf-8" }));
   } catch (_e) {
     return null;
   }
@@ -2509,25 +2726,50 @@ function writeOutput(cwd, sessionId, askId, responses, completedAt) {
 }
 function readMeta(cwd, sessionId, askId) {
   const p = askMetaPath(cwd, sessionId, askId);
-  if (!existsSync10(p)) {
+  if (!existsSync11(p)) {
     return null;
   }
-  return JSON.parse(readFileSync11(p, "utf-8"));
+  return JSON.parse(readFileSync12(p, "utf-8"));
 }
 async function updateMeta(cwd, sessionId, askId, patch) {
-  return withLock(askId, () => {
+  const next = await withLock(askId, () => {
     const cur = readMeta(cwd, sessionId, askId);
     if (!cur) {
       throw new Error(`updateMeta: askId ${askId} not found`);
     }
-    const next = { ...cur, ...patch };
-    atomicWrite(askMetaPath(cwd, sessionId, askId), JSON.stringify(next, null, 2));
-    return next;
+    const updated = { ...cur, ...patch };
+    atomicWrite(askMetaPath(cwd, sessionId, askId), JSON.stringify(updated, null, 2));
+    return updated;
+  });
+  if (patch.status === "answered" && next.heartbeatAskId) {
+    const hbAskId = next.heartbeatAskId;
+    cascadeResolveHeartbeatAsk(cwd, sessionId, hbAskId).catch((err) => {
+      console.warn(
+        `[sisyphus] heartbeat cascade-resolve failed for ${hbAskId}:`,
+        err instanceof Error ? err.message : err
+      );
+    });
+  }
+  return next;
+}
+async function cascadeResolveHeartbeatAsk(cwd, sessionId, heartbeatAskId) {
+  const hbMeta = readMeta(cwd, sessionId, heartbeatAskId);
+  if (!hbMeta) return;
+  if (hbMeta.status === "answered") return;
+  if (existsSync11(askOutputPath(cwd, sessionId, heartbeatAskId))) return;
+  writeOutput(cwd, sessionId, heartbeatAskId, [{
+    id: "heartbeat",
+    selectedOptionId: "ack",
+    freetext: "auto-resolved: original ask was answered"
+  }]);
+  await updateMeta(cwd, sessionId, heartbeatAskId, {
+    status: "answered",
+    completedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
 function listAsks(cwd, sessionId) {
   const dir = askDir(cwd, sessionId);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     return [];
   }
   return readdirSync7(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -2543,7 +2785,7 @@ function buildAutoResponses(deck) {
 }
 async function autoResolveAsk(cwd, sessionId, askId, deck) {
   try {
-    if (existsSync10(askOutputPath(cwd, sessionId, askId))) return false;
+    if (existsSync11(askOutputPath(cwd, sessionId, askId))) return false;
     const d = deck ?? readDecisions(cwd, sessionId, askId);
     if (!d) return false;
     const responses = buildAutoResponses(d);
@@ -2563,6 +2805,8 @@ async function maybeAutoResolveAsk(cwd, sessionId, askId, deck) {
   try {
     if (!isSessionDangerous(cwd, sessionId)) return;
     if (deck.source?.askedBy === ORPHAN_ASKED_BY) return;
+    const meta = readMeta(cwd, sessionId, askId);
+    if (meta?.kind === "review") return;
     await autoResolveAsk(cwd, sessionId, askId, deck);
   } catch {
   }
@@ -2576,7 +2820,7 @@ function listOpenAsksFor(cwd, sessionId, askedBy) {
     if (meta.orphaned) continue;
     if (!meta.blocking) continue;
     if (meta.status !== "pending" && meta.status !== "in-progress") continue;
-    if (existsSync10(askOutputPath(cwd, sessionId, askId))) continue;
+    if (existsSync11(askOutputPath(cwd, sessionId, askId))) continue;
     out.push({ askId, status: meta.status, ...meta.title !== void 0 ? { title: meta.title } : {} });
   }
   return out;
@@ -2596,7 +2840,8 @@ var init_ask_store = __esm({
       "validation",
       "decision",
       "context",
-      "error"
+      "error",
+      "review"
     ]);
     HEARTBEAT_ASKED_BY = "system:heartbeat";
     ORPHAN_ASKED_BY = "system:orphan-handler";
@@ -2792,9 +3037,38 @@ async function orphanRunningAgentAsks(cwd, sessionId, session) {
   if (runningAgentIds.length === 0) return;
   await Promise.all(runningAgentIds.map((agentId) => markAgentAsksOrphan(cwd, sessionId, agentId)));
 }
-async function resolveOrchestratorOrphanAsks(cwd, sessionId, selectedOptionId) {
+async function resolveAgentOrphanAsks(cwd, sessionId, agentId, resolution) {
+  const asks = listAsks(cwd, sessionId);
+  const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const selectedOptionId = "dismiss";
+  const freetext = resolution === "respawn" ? "auto-resolved: agent was restarted" : resolution === "superseded" ? "auto-resolved: agent superseded by replacement" : "auto-resolved by system";
+  await mapWithLimit(asks, ASK_FANOUT_LIMIT, async (askId) => {
+    try {
+      const meta = readMeta(cwd, sessionId, askId);
+      if (!meta) return;
+      if (meta.askedBy !== ORPHAN_ASKED_BY2) return;
+      if (meta.status === "answered") return;
+      if (meta.orphanTarget?.kind !== "agent") return;
+      if (meta.orphanTarget.agentId !== agentId) return;
+      writeOutput(cwd, sessionId, askId, [{
+        id: "orphan",
+        selectedOptionId,
+        freetext
+      }], completedAt);
+      await updateMeta(cwd, sessionId, askId, { status: "answered", completedAt });
+    } catch (err) {
+      console.warn(
+        `[sisyphus] resolveAgentOrphanAsks: ${sessionId}/${askId} failed:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  });
+}
+async function resolveOrchestratorOrphanAsks(cwd, sessionId, resolution) {
   const asks = listAsks(cwd, sessionId);
   const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const selectedOptionId = resolution === "respawn" ? "dismiss" : resolution;
+  const freetext = resolution === "resume" ? "auto-resolved by sis session lifecycle resume" : resolution === "respawn" ? "auto-resolved by orchestrator auto-respawn" : "auto-resolved by system";
   await mapWithLimit(asks, ASK_FANOUT_LIMIT, async (askId) => {
     try {
       const meta = readMeta(cwd, sessionId, askId);
@@ -2805,7 +3079,7 @@ async function resolveOrchestratorOrphanAsks(cwd, sessionId, selectedOptionId) {
       writeOutput(cwd, sessionId, askId, [{
         id: "orphan",
         selectedOptionId,
-        freetext: `auto-resolved by ${selectedOptionId === "resume" ? "sis session resume" : "system"}`
+        freetext
       }], completedAt);
       await updateMeta(cwd, sessionId, askId, { status: "answered", completedAt });
     } catch (err) {
@@ -2845,17 +3119,18 @@ var init_process = __esm({
 });
 
 // src/daemon/orphan-sweep.ts
-import { existsSync as existsSync11 } from "fs";
-import { execSync as execSync4 } from "child_process";
-function probePidLstart(pid, expectedLstart, psRunner = defaultPsRunner) {
+import { existsSync as existsSync12 } from "fs";
+import { execFile as execFile2 } from "child_process";
+import { promisify } from "util";
+async function probePidLstart(pid, expectedLstart, psRunner = defaultPsRunner) {
   try {
-    const lstart = psRunner(pid, execEnv());
+    const lstart = await psRunner(pid, execEnv());
     if (!lstart) return "gone";
     if (lstart === expectedLstart) return "live";
     return "recycled";
   } catch (err) {
     const e = err;
-    if (e.status === 1) return "gone";
+    if (e.code === 1) return "gone";
     return "unknown";
   }
 }
@@ -2865,7 +3140,7 @@ async function capturePanePidLstart(paneId) {
     try {
       const pid = getPanePid(paneId);
       if (pid === null) throw new Error("tmux returned non-integer pane_pid");
-      const lstart = defaultPsRunner(pid, env);
+      const lstart = await defaultPsRunner(pid, env);
       if (!lstart) throw new Error("ps returned empty lstart");
       return { pid, lstart };
     } catch (captureErr) {
@@ -2879,18 +3154,22 @@ async function capturePanePidLstart(paneId) {
 }
 async function sweepOrphans(registry) {
   const reg = registry ?? loadSessionRegistry();
-  for (const [sessionId, cwd] of Object.entries(reg)) {
-    if (!existsSync11(statePath(cwd, sessionId))) continue;
-    try {
-      await sweepSessionAgents(cwd, sessionId);
-      await sweepSessionAsks(cwd, sessionId);
-    } catch (err) {
-      console.warn(
-        `[sisyphus] orphan-sweep failed for ${sessionId}:`,
-        err instanceof Error ? err.message : err
-      );
-    }
-  }
+  await Promise.all(
+    Object.entries(reg).map(async ([sessionId, cwd]) => {
+      if (!existsSync12(statePath(cwd, sessionId))) return;
+      try {
+        await Promise.all([
+          sweepSessionAgents(cwd, sessionId),
+          sweepSessionAsks(cwd, sessionId)
+        ]);
+      } catch (err) {
+        console.warn(
+          `[sisyphus] orphan-sweep failed for ${sessionId}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    })
+  );
 }
 async function sweepSessionAgents(cwd, sessionId) {
   let session;
@@ -2899,11 +3178,13 @@ async function sweepSessionAgents(cwd, sessionId) {
   } catch {
     return;
   }
-  for (const agent of session.agents) {
-    if (agent.status !== "running") continue;
-    if (agent.orphaned) continue;
-    if (agent.pid === void 0 || !agent.pidLstart) continue;
-    const probe = probePidLstart(agent.pid, agent.pidLstart);
+  const candidates = session.agents.filter(
+    (a) => a.status === "running" && !a.orphaned && a.pid !== void 0 && a.pidLstart
+  );
+  const probes = await Promise.all(
+    candidates.map(async (a) => ({ agent: a, probe: await probePidLstart(a.pid, a.pidLstart) }))
+  );
+  for (const { agent, probe } of probes) {
     if (probe === "live" || probe === "unknown") continue;
     await markAgentOrphan(cwd, sessionId, agent.id, {
       reason: probe === "recycled" ? "pid recycled (daemon-startup sweep)" : "process gone (daemon-startup sweep)",
@@ -2931,7 +3212,7 @@ async function sweepSessionAsks(cwd, sessionId) {
     await updateMeta(cwd, sessionId, askId, { orphaned: true });
   }
 }
-var defaultPsRunner;
+var execFileAsync, defaultPsRunner;
 var init_orphan_sweep = __esm({
   "src/daemon/orphan-sweep.ts"() {
     "use strict";
@@ -2943,12 +3224,16 @@ var init_orphan_sweep = __esm({
     init_paths();
     init_orphan_asks();
     init_process();
-    defaultPsRunner = (pid, env) => execSync4(`ps -o lstart= -p ${pid}`, { encoding: "utf-8", env, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    execFileAsync = promisify(execFile2);
+    defaultPsRunner = async (pid, env) => {
+      const { stdout } = await execFileAsync("ps", ["-o", "lstart=", "-p", String(pid)], { env });
+      return stdout.trim();
+    };
   }
 });
 
 // src/daemon/agent.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, readdirSync as readdirSync8, existsSync as existsSync12, unlinkSync } from "fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, readdirSync as readdirSync8, existsSync as existsSync13, unlinkSync } from "fs";
 import { execSync as execSync5 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import { resolve as resolve5, relative as relative2, dirname as dirname3, join as join12 } from "path";
@@ -2970,13 +3255,15 @@ function renderAgentSuffix(sessionId, instruction, contextDirRel) {
   const templatePath = resolve5(import.meta.dirname, "../templates/agent-suffix.md");
   let template;
   try {
-    template = readFileSync12(templatePath, "utf-8");
+    template = readFileSync13(templatePath, "utf-8");
   } catch {
     template = `# Sisyphus Agent
 Session: {{SESSION_ID}}
 Task: {{INSTRUCTION}}`;
   }
-  return template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{CONTEXT_DIR\}\}/g, contextDirRel);
+  return injectHelp(
+    template.replace(/\{\{SESSION_ID\}\}/g, sessionId).replace(/\{\{INSTRUCTION\}\}/g, instruction).replace(/\{\{CONTEXT_DIR\}\}/g, contextDirRel)
+  );
 }
 function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
   const base = `${promptsDir(cwd, sessionId)}/${agentId}-plugin`;
@@ -2994,10 +3281,10 @@ function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
   if (agentConfig?.filePath && agentType && agentType !== "worker") {
     const shortName = agentType.replace(/^sisyphus:/, "");
     const subAgentDir = join12(dirname3(agentConfig.filePath), shortName);
-    if (existsSync12(subAgentDir)) {
+    if (existsSync13(subAgentDir)) {
       for (const f of readdirSync8(subAgentDir)) {
         if (f.endsWith(".md") && f !== "CLAUDE.md") {
-          writeFileSync9(`${base}/agents/${f}`, substituteEnvVars(readFileSync12(join12(subAgentDir, f), "utf-8")), "utf-8");
+          writeFileSync9(`${base}/agents/${f}`, substituteEnvVars(readFileSync13(join12(subAgentDir, f), "utf-8")), "utf-8");
         }
       }
     }
@@ -3094,7 +3381,24 @@ ${instruction}`);
     const sessionIdFlag = claudeSessionId ? ` --session-id "${claudeSessionId}"` : "";
     const promptFlag = agentConfig?.frontmatter.systemPrompt === "replace" ? "--system-prompt" : "--append-system-prompt";
     const siblingSettingsPath = agentConfig?.filePath ? agentConfig.filePath.replace(/\.md$/, ".settings.json") : null;
-    const settingsFlag = siblingSettingsPath && existsSync12(siblingSettingsPath) ? ` --settings "${siblingSettingsPath}"` : "";
+    const hasSibling = !!siblingSettingsPath && existsSync13(siblingSettingsPath);
+    const agentDigestVerbs = digestSpinnerVerbs(cwd, sessionId);
+    let resolvedSettingsPath = hasSibling ? siblingSettingsPath : null;
+    if (agentDigestVerbs) {
+      let base = {};
+      if (hasSibling) {
+        try {
+          base = JSON.parse(readFileSync13(siblingSettingsPath, "utf-8"));
+        } catch {
+          base = {};
+        }
+      }
+      base.spinnerVerbs = { mode: "replace", verbs: agentDigestVerbs };
+      const mergedSettingsOut = join12(promptsDir(cwd, sessionId), `${agentId}-settings.merged.json`);
+      writeFileSync9(mergedSettingsOut, JSON.stringify(base, null, 2), "utf-8");
+      resolvedSettingsPath = mergedSettingsOut;
+    }
+    const settingsFlag = resolvedSettingsPath ? ` --settings "${resolvedSettingsPath}"` : "";
     mainCmd = `claude${permFlag} --effort ${effort}${modelFlag} --plugin-dir "${pluginPath}"${sessionIdFlag}${extraPluginFlags ? ` ${extraPluginFlags}` : ""}${settingsFlag} --name ${shellQuote(agentTitle)} ${promptFlag} "$(cat '${suffixFilePath}')" ${shellQuote(instruction)}`;
     resumeArgs = `${permFlag.trimStart()} --effort ${effort}${modelFlag} --plugin-dir "${pluginPath}"${extraPluginFlags ? ` ${extraPluginFlags}` : ""}${settingsFlag}`;
   }
@@ -3128,12 +3432,12 @@ async function spawnAgent(opts) {
       try {
         execSync5(`which ${fallbackCli}`, { stdio: "pipe", env: execEnv() });
       } catch {
-        throw new Error(`Neither ${cliToCheck} (model: ${agentConfig?.frontmatter.model}) nor ${fallbackCli} (fallback: ${fallback}) CLI found on PATH. Run \`sis admin doctor\` to diagnose.`);
+        throw new Error(`Neither ${cliToCheck} (model: ${agentConfig?.frontmatter.model}) nor ${fallbackCli} (fallback: ${fallback}) CLI found on PATH. Run \`sis admin check doctor\` to diagnose.`);
       }
       if (agentConfig) agentConfig.frontmatter.model = fallback;
       provider = fallbackProvider;
     } else {
-      throw new Error(`${cliToCheck} CLI not found on PATH. Run \`sis admin doctor\` to diagnose.`);
+      throw new Error(`${cliToCheck} CLI not found on PATH. Run \`sis admin check doctor\` to diagnose.`);
     }
   }
   const repo = opts.repo !== void 0 ? opts.repo : ".";
@@ -3250,6 +3554,12 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     await setAgentPid(cwd, sessionId, agentId, capturedRestart.pid, capturedRestart.lstart);
   }
   emitHistoryEvent(sessionId, "agent-restarted", { agentId, restartCount, originalSpawnedAt, previousStatus, claudeSessionId });
+  resolveAgentOrphanAsks(cwd, sessionId, agentId, "respawn").catch((err) => {
+    console.warn(
+      `[sisyphus] resolveAgentOrphanAsks on restart failed for ${agentId}:`,
+      err instanceof Error ? err.message : err
+    );
+  });
 }
 function nextReportNumber(cwd, sessionId, agentId) {
   const dir = reportsDir(cwd, sessionId);
@@ -3283,9 +3593,9 @@ async function handleAgentReport(cwd, sessionId, agentId, content) {
 }
 function gcBgTasks(cwd, sessionId, agentId) {
   const file = `${sessionDir(cwd, sessionId)}/runtime/bg-tasks/${agentId}.txt`;
-  if (!existsSync12(file)) return;
+  if (!existsSync13(file)) return;
   try {
-    const leftover = readFileSync12(file, "utf-8").split("\n").map((s) => s.trim()).filter(Boolean);
+    const leftover = readFileSync13(file, "utf-8").split("\n").map((s) => s.trim()).filter(Boolean);
     if (leftover.length > 0) {
       console.warn(`[bg-tasks] ${agentId} exited with ${leftover.length} untracked background task(s): ${leftover.join(", ")}`);
       emitHistoryEvent(sessionId, "bg-tasks-leftover", { agentId, leftover });
@@ -3392,6 +3702,7 @@ var init_agent = __esm({
     init_tmux();
     init_colors();
     init_paths();
+    init_help_inject();
     init_pane_registry();
     init_pane_monitor();
     init_summarize();
@@ -3401,6 +3712,7 @@ var init_agent = __esm({
     init_shell();
     init_spawn_helpers();
     init_plugins();
+    init_digest_verbs();
     init_history();
     init_orphan_asks();
     init_orphan_sweep();
@@ -3558,7 +3870,7 @@ var init_companion_types = __esm({
 });
 
 // src/daemon/companion-memory.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync13, renameSync as renameSync3, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync8, readFileSync as readFileSync14, renameSync as renameSync3, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname4, join as join13 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { z } from "zod";
@@ -3591,10 +3903,10 @@ function fillDefaults(state) {
 }
 function loadMemoryStrict() {
   const path = resolvedMemoryPath();
-  if (!existsSync13(path)) return defaultMemoryState();
+  if (!existsSync14(path)) return defaultMemoryState();
   let raw;
   try {
-    raw = readFileSync13(path, "utf-8");
+    raw = readFileSync14(path, "utf-8");
   } catch (err) {
     throw new MemoryStoreParseError(err);
   }
@@ -4035,7 +4347,7 @@ var init_companion_memory = __esm({
 });
 
 // src/daemon/companion.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync4, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, readFileSync as readFileSync15, renameSync as renameSync4, writeFileSync as writeFileSync11 } from "fs";
 import { randomUUID as randomUUID5 } from "crypto";
 import { dirname as dirname5, join as join14 } from "path";
 function welfordUpdate(stats, value) {
@@ -4059,12 +4371,12 @@ function zScore(value, stats, metric) {
 }
 function loadCompanion() {
   const path = companionPath();
-  if (!existsSync14(path)) {
+  if (!existsSync15(path)) {
     const state2 = createDefaultCompanion();
     saveCompanion(state2);
     return state2;
   }
-  const raw = readFileSync14(path, "utf-8");
+  const raw = readFileSync15(path, "utf-8");
   const state = JSON.parse(raw);
   return normalizeCompanion(state);
 }
@@ -4245,7 +4557,7 @@ function computeMood(companion, session, signals) {
   const now = Date.now();
   const weekAgo = now - 7 * 24 * 36e5;
   const weeklyCompletions = companion.recentCompletions.filter(
-    (ts2) => new Date(ts2).getTime() > weekAgo
+    (ts) => new Date(ts).getTime() > weekAgo
   ).length;
   const weeklyAvgDaily = weeklyCompletions / 7;
   const weeklyZ = zScore(weeklyAvgDaily, baselines.sessionsPerDay, "sessionsPerDay");
@@ -4638,8 +4950,8 @@ var init_companion = __esm({
       },
       "overdrive": (c) => {
         const dateCounts = {};
-        for (const ts2 of c.recentCompletions) {
-          const date = ts2.slice(0, 10);
+        for (const ts of c.recentCompletions) {
+          const date = ts.slice(0, 10);
           dateCounts[date] = (dateCounts[date] ?? 0) + 1;
         }
         return Object.values(dateCounts).some((count) => count >= 6);
@@ -5803,7 +6115,7 @@ var init_companion_render = __esm({
 });
 
 // src/daemon/companion-popup.ts
-import { writeFileSync as writeFileSync12, readFileSync as readFileSync15, unlinkSync as unlinkSync2, existsSync as existsSync15 } from "fs";
+import { writeFileSync as writeFileSync12, readFileSync as readFileSync16, unlinkSync as unlinkSync2, existsSync as existsSync16 } from "fs";
 import { tmpdir } from "os";
 import { join as join15, resolve as resolve6 } from "path";
 function wrapText(text, width) {
@@ -5847,7 +6159,7 @@ function showCommentaryPopupQueue(pages) {
       if (contentHeight > maxContentHeight) maxContentHeight = contentHeight;
       writeFileSync12(`${POPUP_TMP_PREFIX}-${i}.txt`, content);
     }
-    const whipAvailable = existsSync15(WHIP_ANIMATION_PATH);
+    const whipAvailable = existsSync16(WHIP_ANIMATION_PATH);
     if (whipAvailable && maxContentHeight < WHIP_ANIMATION_ROWS + 2) {
       maxContentHeight = WHIP_ANIMATION_ROWS + 2;
     }
@@ -5921,7 +6233,7 @@ fi
     }
     let raw;
     try {
-      raw = readFileSync15(POPUP_RESULT_PREFIX, "utf8").trim();
+      raw = readFileSync16(POPUP_RESULT_PREFIX, "utf8").trim();
     } catch {
       return null;
     } finally {
@@ -6074,6 +6386,7 @@ function stopMonitor() {
 function trackSession(sessionId, cwd, tmuxSessionId, tmuxSessionName2) {
   const existing = trackedSessions.get(sessionId);
   trackedSessions.set(sessionId, { id: sessionId, cwd, tmuxSessionId, tmuxSessionName: tmuxSessionName2, windowId: existing ? existing.windowId : null });
+  installStateWatcher(cwd, sessionId);
   if (!activeTimers.has(sessionId)) {
     try {
       const session = getSession(cwd, sessionId);
@@ -6088,7 +6401,9 @@ function updateTrackedWindow(sessionId, windowId) {
   entry.windowId = windowId;
 }
 function untrackSession(sessionId) {
+  const entry = trackedSessions.get(sessionId);
   trackedSessions.delete(sessionId);
+  if (entry) uninstallStateWatcher(entry.cwd, sessionId);
 }
 function hasRecentSessionActivity(s, recentCutoffMs) {
   for (const agent of s.agents) {
@@ -6112,13 +6427,16 @@ async function pollAllSessions() {
   const increment = elapsed > threshold ? storedPollIntervalMs : elapsed;
   lastPollTime = now;
   const pollSessionCache = /* @__PURE__ */ new Map();
-  for (const { id: sessionId, cwd, windowId } of trackedSessions.values()) {
-    if (windowId) {
-      await pollSession(sessionId, cwd, windowId, increment, pollSessionCache);
-    }
-  }
+  const panesByWindow = listAllPanesByWindow();
+  await Promise.all(
+    [...trackedSessions.values()].filter(({ windowId }) => !!windowId).map(
+      ({ id: sessionId, cwd, windowId }) => pollSession(sessionId, cwd, windowId, increment, panesByWindow, pollSessionCache).catch((err) => {
+        console.error(`[sisyphus] pollSession error for ${sessionId}:`, err);
+      })
+    )
+  );
   try {
-    onDotsUpdate?.();
+    onDotsUpdate?.(panesByWindow);
   } catch {
   }
   try {
@@ -6269,11 +6587,12 @@ async function pollAllSessions() {
   } catch {
   }
 }
-async function pollSession(sessionId, cwd, windowId, increment, sessionCache) {
+async function pollSession(sessionId, cwd, windowId, increment, panesByWindow, sessionCache2) {
+  const panesForWindow = () => panesByWindow.get(windowId) ?? [];
   let session;
   try {
     session = getSession(cwd, sessionId);
-    sessionCache?.set(sessionId, session);
+    sessionCache2?.set(sessionId, session);
   } catch (err) {
     console.error(`[sisyphus] Failed to read state for session ${sessionId}:`, err);
     return;
@@ -6281,8 +6600,7 @@ async function pollSession(sessionId, cwd, windowId, increment, sessionCache) {
   if (session.status === "completed") {
     const orchPaneId2 = getOrchestratorPaneId(sessionId);
     if (orchPaneId2) {
-      const livePanes2 = listPanes(windowId);
-      const livePaneIds2 = new Set(livePanes2.map((p) => p.paneId));
+      const livePaneIds2 = new Set(panesForWindow().map((p) => p.paneId));
       if (!livePaneIds2.has(orchPaneId2)) {
         cleanupSessionMaps(sessionId);
         untrackSession(sessionId);
@@ -6295,7 +6613,7 @@ async function pollSession(sessionId, cwd, windowId, increment, sessionCache) {
     return;
   }
   if (session.status !== "active") return;
-  const livePanes = listPanes(windowId);
+  const livePanes = panesForWindow();
   if (livePanes.length === 0) {
     if (respawningSessions.has(sessionId)) return;
     const tracked = trackedSessions.get(sessionId);
@@ -6346,9 +6664,9 @@ async function pollSession(sessionId, cwd, windowId, increment, sessionCache) {
   if (orchPaneId && !livePaneIds.has(orchPaneId) && !respawningSessions.has(sessionId)) {
     const cycleActiveMs = flushCycleTimer(sessionId, session.orchestratorCycles.length);
     await completeOrchestratorCycle(cwd, sessionId, void 0, void 0, cycleActiveMs);
-    await orphanOrchestrator(cwd, sessionId, "orchestrator pane vanished without yield", "orchestrator-gone");
     const runningAgents = session.agents.filter((a) => a.status === "running");
     if (runningAgents.length === 0) {
+      await orphanOrchestrator(cwd, sessionId, "orchestrator pane vanished without yield", "orchestrator-gone");
       await flushTimers(sessionId);
       await updateSessionStatus(cwd, sessionId, "paused");
       console.log(`[sisyphus] Session ${sessionId} paused: orchestrator pane disappeared`);
@@ -6392,7 +6710,7 @@ var init_pane_monitor = __esm({
 });
 
 // src/daemon/mode-notify.ts
-import { existsSync as existsSync16 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { ulid as ulid2 } from "ulid";
 function capitalize(s) {
   return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
@@ -6414,7 +6732,7 @@ function findOpenModeTransitionAsk(cwd, sessionId) {
     if (meta.modeTransition !== true) continue;
     if (meta.status === "answered") continue;
     if (meta.orphaned === true) continue;
-    if (existsSync16(askOutputPath(cwd, sessionId, askId))) continue;
+    if (existsSync17(askOutputPath(cwd, sessionId, askId))) continue;
     return askId;
   }
   return null;
@@ -6478,13 +6796,14 @@ async function emitModeTransitionNotify(cwd, sessionId, prevMode, nextMode, prev
     kind: "notify",
     options: [{ id: "ack", label: "Acknowledged" }]
   };
+  const deckSource = {
+    ...sessionName !== void 0 ? { sessionName } : {},
+    askedBy: ORCHESTRATOR_ASKED_BY,
+    modeChain: chain
+  };
   const deck = {
     title: deckTitle,
-    source: {
-      ...sessionName !== void 0 ? { sessionName } : {},
-      askedBy: ORCHESTRATOR_ASKED_BY,
-      modeChain: chain
-    },
+    source: deckSource,
     interactions: [interaction]
   };
   try {
@@ -6528,14 +6847,14 @@ var init_mode_notify = __esm({
 });
 
 // src/daemon/orchestrator.ts
-import { existsSync as existsSync17, readdirSync as readdirSync10, readFileSync as readFileSync16, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync10, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "fs";
 import { execSync as execSync6 } from "child_process";
 import { randomUUID as randomUUID6 } from "crypto";
 import { resolve as resolve7, join as join16, relative as relative3 } from "path";
 function detectRepos(cwd) {
   const config = loadConfig(cwd);
   const repos = [];
-  if (existsSync17(join16(cwd, ".git"))) {
+  if (existsSync18(join16(cwd, ".git"))) {
     try {
       repos.push(getRepoInfo(cwd, "."));
     } catch {
@@ -6547,7 +6866,7 @@ function detectRepos(cwd) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
       const childPath = join16(cwd, entry.name);
-      if (existsSync17(join16(childPath, ".git"))) {
+      if (existsSync18(join16(childPath, ".git"))) {
         try {
           repos.push(getRepoInfo(childPath, entry.name));
         } catch {
@@ -6585,40 +6904,44 @@ function resolveOrchestratorSettings(cwd, sessionId) {
   const bundled = resolve7(import.meta.dirname, "../templates/orchestrator-settings.json");
   const projectSettings = projectOrchestratorSettingsPath(cwd);
   const userSettings = userOrchestratorSettingsPath();
-  const hasProject = existsSync17(projectSettings);
-  const hasUser = existsSync17(userSettings);
-  if (!hasProject && !hasUser) return bundled;
+  const hasProject = existsSync18(projectSettings);
+  const hasUser = existsSync18(userSettings);
+  const digestVerbs = digestSpinnerVerbs(cwd, sessionId);
+  if (!hasProject && !hasUser && !digestVerbs) return bundled;
   let merged = {};
   for (const path of [bundled, hasUser ? userSettings : null, hasProject ? projectSettings : null]) {
-    if (!path || !existsSync17(path)) continue;
+    if (!path || !existsSync18(path)) continue;
     try {
-      const parsed = JSON.parse(readFileSync16(path, "utf-8"));
+      const parsed = JSON.parse(readFileSync17(path, "utf-8"));
       merged = { ...merged, ...parsed };
     } catch (err) {
       console.warn(`[sisyphus] Failed to parse settings layer ${path}: ${err instanceof Error ? err.message : err}`);
     }
   }
+  if (digestVerbs) {
+    merged.spinnerVerbs = { mode: "replace", verbs: digestVerbs };
+  }
   const out = join16(promptsDir(cwd, sessionId), "orchestrator-settings.merged.json");
   writeFileSync13(out, JSON.stringify(merged, null, 2), "utf-8");
   return out;
 }
 function loadOrchestratorPrompt(cwd, sessionId, mode) {
   const projectPath = projectOrchestratorPromptPath(cwd);
-  if (existsSync17(projectPath)) {
-    return readFileSync16(projectPath, "utf-8");
+  if (existsSync18(projectPath)) {
+    return readFileSync17(projectPath, "utf-8");
   }
   const userPath = userOrchestratorPromptPath();
-  if (existsSync17(userPath)) {
-    return readFileSync16(userPath, "utf-8");
+  if (existsSync18(userPath)) {
+    return readFileSync17(userPath, "utf-8");
   }
   const basePath = resolve7(import.meta.dirname, "../templates/orchestrator-base.md");
-  const base = readFileSync16(basePath, "utf-8");
+  const base = readFileSync17(basePath, "utf-8");
   const modes = discoverOrchestratorModes(cwd);
   const selected = modes.find((m) => m.name === mode) ?? modes.find((m) => m.name === "discovery");
   if (!selected) {
     throw new Error(`Unknown orchestrator mode '${mode}' and no fallback found. Available: ${modes.map((m) => m.name).join(", ")}`);
   }
-  const modeContent = readFileSync16(selected.filePath, "utf-8");
+  const modeContent = readFileSync17(selected.filePath, "utf-8");
   const modeBody = extractAgentBody(modeContent);
   return base + "\n\n" + modeBody;
 }
@@ -6636,7 +6959,7 @@ function buildCompletionContent(session) {
     lines.push("");
   }
   const logsDirPath = logsDir(session.cwd, session.id);
-  if (existsSync17(logsDirPath)) {
+  if (existsSync18(logsDirPath)) {
     const logFiles = readdirSync10(logsDirPath).filter((f) => f.startsWith("cycle-") && f.endsWith(".md")).sort();
     if (logFiles.length > 0) {
       lines.push("### Cycle Logs\n");
@@ -6661,7 +6984,7 @@ function buildCompletionContent(session) {
           while (j < entries.length && entries[j].idle && entries[j].mode === e.mode) j++;
           const runEntries = entries.slice(i, j);
           if (runEntries.length === 1) {
-            const content = readFileSync16(join16(logsDirPath, e.file), "utf-8").trim();
+            const content = readFileSync17(join16(logsDirPath, e.file), "utf-8").trim();
             if (content) {
               lines.push(content);
               lines.push("");
@@ -6677,7 +7000,7 @@ function buildCompletionContent(session) {
           }
           i = j;
         } else {
-          const content = readFileSync16(join16(logsDirPath, e.file), "utf-8").trim();
+          const content = readFileSync17(join16(logsDirPath, e.file), "utf-8").trim();
           if (content) {
             lines.push(content);
             lines.push("");
@@ -6688,7 +7011,7 @@ function buildCompletionContent(session) {
     }
   }
   const reportsDirPath = reportsDir(session.cwd, session.id);
-  if (existsSync17(reportsDirPath)) {
+  if (existsSync18(reportsDirPath)) {
     const reportFiles = readdirSync10(reportsDirPath).filter((f) => f.endsWith(".md"));
     if (reportFiles.length > 0) {
       lines.push("### Detailed Reports\n");
@@ -6714,7 +7037,7 @@ ${session.context}
     }
   } else {
     let ctxFiles = [];
-    if (existsSync17(ctxDir)) {
+    if (existsSync18(ctxDir)) {
       ctxFiles = readdirSync10(ctxDir).filter((f) => f !== "CLAUDE.md");
     }
     if (ctxFiles.length > 0) {
@@ -6756,10 +7079,10 @@ ${agentLines}
     }
   }
   const strategyFile = strategyPath(session.cwd, session.id);
-  const strategyRef = existsSync17(strategyFile) ? `@${relative3(session.cwd, strategyFile)}` : "(empty)";
-  const roadmapRef = existsSync17(roadmapFile) ? `@${relative3(session.cwd, roadmapFile)}` : "(empty)";
+  const strategyRef = existsSync18(strategyFile) ? `@${relative3(session.cwd, strategyFile)}` : "(empty)";
+  const roadmapRef = existsSync18(roadmapFile) ? `@${relative3(session.cwd, roadmapFile)}` : "(empty)";
   const digestFile = digestPath(session.cwd, session.id);
-  const digestRef = existsSync17(digestFile) ? `@${relative3(session.cwd, digestFile)}` : "(not yet created)";
+  const digestRef = existsSync18(digestFile) ? `@${relative3(session.cwd, digestFile)}` : "(not yet created)";
   const repos = detectRepos(session.cwd);
   let repositoriesSection = "\n\n## Repositories\n";
   if (repos.length === 0) {
@@ -6786,7 +7109,7 @@ ${agentLines}
     }
   }
   const goalFile = goalPath(session.cwd, session.id);
-  const goalContent = existsSync17(goalFile) ? readFileSync16(goalFile, "utf-8").trim() : session.task;
+  const goalContent = existsSync18(goalFile) ? readFileSync17(goalFile, "utf-8").trim() : session.task;
   const modeContent = modeContentBuilders[mode]?.(session) ?? "";
   return `## Goal
 
@@ -6813,7 +7136,7 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message, forceMode) {
   try {
     execSync6("which claude", { stdio: "pipe", env: EXEC_ENV });
   } catch {
-    throw new Error("Claude CLI not found on PATH. Run `sis admin doctor` to diagnose.");
+    throw new Error("Claude CLI not found on PATH. Run `sis admin check doctor` to diagnose.");
   }
   const session = getSession(cwd, sessionId);
   const lastCycle = [...session.orchestratorCycles].reverse().find((c) => c.completedAt);
@@ -6823,9 +7146,9 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message, forceMode) {
   const agentPluginPath = resolve7(import.meta.dirname, "../templates/agent-plugin");
   const agentTypes = discoverAgentTypes(agentPluginPath, session.cwd).filter((t2) => t2.source === "bundled");
   const agentTypeLines = agentTypes.length > 0 ? agentTypes.map((t2) => {
-    const modelTag = t2.model ? ` (${t2.model})` : "";
+    const tag = t2.model ? `(agent, ${t2.model})` : "(agent)";
     const desc = t2.description ? ` \u2014 ${t2.description}` : "";
-    return `- \`${t2.qualifiedName}\`${modelTag}${desc}`;
+    return `- \`${t2.qualifiedName}\` ${tag}${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);
@@ -6835,7 +7158,9 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message, forceMode) {
     return `- \`${m.name}\`${desc}`;
   }).join("\n");
   const substitutedPrompt = substituteEnvVars(
-    basePrompt.replace("{{AGENT_TYPES}}", agentTypeLines).replace("{{ORCHESTRATOR_MODES}}", modeLines)
+    injectHelp(
+      basePrompt.replace("{{AGENT_TYPES}}", agentTypeLines).replace("{{ORCHESTRATOR_MODES}}", modeLines)
+    )
   );
   const sessionEffort = session.effort != null ? session.effort : "high";
   const systemPrompt = renderEffortMarkers(substitutedPrompt, sessionEffort);
@@ -7003,8 +7328,10 @@ var init_orchestrator = __esm({
   "src/daemon/orchestrator.ts"() {
     "use strict";
     init_spawn_helpers();
+    init_help_inject();
     init_paths();
     init_exec();
+    init_digest_verbs();
     init_types();
     init_config();
     init_shell();
@@ -7029,7 +7356,7 @@ var init_orchestrator = __esm({
 });
 
 // src/daemon/status-dots.ts
-import { readFileSync as readFileSync17 } from "fs";
+import { readFileSync as readFileSync18 } from "fs";
 function renderDots(dots) {
   const sorted = [...dots].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
   return sorted.map((d) => {
@@ -7040,7 +7367,7 @@ function renderDots(dots) {
 function readClaudeState(paneId) {
   const numericId = paneId.replace("%", "");
   try {
-    const content = readFileSync17(`${CLAUDE_STATE_DIR}/${numericId}`, "utf-8").trim();
+    const content = readFileSync18(`${CLAUDE_STATE_DIR}/${numericId}`, "utf-8").trim();
     if (content === "idle" || content === "processing" || content === "stopped") {
       return content;
     }
@@ -7099,7 +7426,7 @@ function getDashboardWindowId(cwd) {
   dashboardWindowCache.set(cwd, { windowId, checkedAt: now });
   return windowId;
 }
-function recomputeDots() {
+function recomputeDots(panesByWindow) {
   if (!getTrackedEntries) return;
   pruneCompleted();
   sisyphusPhases.clear();
@@ -7129,7 +7456,7 @@ function recomputeDots() {
       seenIds.add(sessionId);
       try {
         const session = getSession(cwd, sessionId);
-        const livePanes = listPanes(windowId);
+        const livePanes = panesByWindow?.get(windowId) ?? listPanes(windowId);
         const livePaneIds = new Set(livePanes.map((p) => p.paneId));
         const phase = detectPhase(session, livePaneIds);
         dots.push({ phase, createdAt: session.createdAt });
@@ -7147,11 +7474,14 @@ function recomputeDots() {
     const dashboardWindowId = getDashboardWindowId(cwd);
     if (dashboardWindowId) {
       const rendered = dots.length > 0 ? " " + renderDots(dots) : "";
-      setWindowOption(dashboardWindowId, "@sisyphus_dots", rendered);
+      if (lastDotsByWindow.get(dashboardWindowId) !== rendered) {
+        setWindowOption(dashboardWindowId, "@sisyphus_dots", rendered);
+        lastDotsByWindow.set(dashboardWindowId, rendered);
+      }
     }
   }
 }
-var CLAUDE_STATE_DIR, DOT_MAP, sisyphusPhases, getTrackedEntries, COMPLETED_TTL_MS, completedSessions, dashboardWindowCache, CACHE_TTL_MS;
+var CLAUDE_STATE_DIR, DOT_MAP, sisyphusPhases, getTrackedEntries, COMPLETED_TTL_MS, completedSessions, dashboardWindowCache, CACHE_TTL_MS, lastDotsByWindow;
 var init_status_dots = __esm({
   "src/daemon/status-dots.ts"() {
     "use strict";
@@ -7179,6 +7509,7 @@ var init_status_dots = __esm({
     completedSessions = /* @__PURE__ */ new Map();
     dashboardWindowCache = /* @__PURE__ */ new Map();
     CACHE_TTL_MS = 3e4;
+    lastDotsByWindow = /* @__PURE__ */ new Map();
   }
 });
 
@@ -7220,9 +7551,9 @@ var init_manifest = __esm({
 });
 
 // src/shared/session-export.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify } from "util";
-import { existsSync as existsSync18, readFileSync as readFileSync18, mkdirSync as mkdirSync10, symlinkSync, rmSync as rmSync5, writeFileSync as writeFileSync14 } from "fs";
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { existsSync as existsSync19, readFileSync as readFileSync19, mkdirSync as mkdirSync10, symlinkSync, rmSync as rmSync5, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join17 } from "path";
 function sanitizeName(name) {
@@ -7234,7 +7565,7 @@ function buildOutputPath(label, dir) {
   const base = `sisyphus-${label}-${date}`;
   let candidate = join17(dir, `${base}.zip`);
   let counter = 1;
-  while (existsSync18(candidate)) {
+  while (existsSync19(candidate)) {
     counter++;
     candidate = join17(dir, `${base}-${counter}.zip`);
   }
@@ -7297,16 +7628,16 @@ async function exportSessionToZip(sessionId, cwd, options) {
   const reveal = options?.reveal ?? true;
   const sessDir = sessionDir(cwd, sessionId);
   const histDir = historySessionDir(sessionId);
-  const sessExists = existsSync18(sessDir);
-  const histExists = existsSync18(histDir);
+  const sessExists = existsSync19(sessDir);
+  const histExists = existsSync19(histDir);
   if (!sessExists && !histExists) {
     throw new Error(`No data found for session ${sessionId}`);
   }
   let label = sessionId.slice(0, 8);
   const stPath = statePath(cwd, sessionId);
-  if (existsSync18(stPath)) {
+  if (existsSync19(stPath)) {
     try {
-      const state = JSON.parse(readFileSync18(stPath, "utf-8"));
+      const state = JSON.parse(readFileSync19(stPath, "utf-8"));
       if (state.name) {
         label = sanitizeName(state.name);
       }
@@ -7326,24 +7657,24 @@ async function exportSessionToZip(sessionId, cwd, options) {
       symlinkSync(histDir, join17(tmpDir, "history"));
     }
     const parts = ["CLAUDE.md", sessExists ? "session/" : "", histExists ? "history/" : ""].filter(Boolean);
-    await execFileAsync("zip", ["-rq", outputPath, ...parts], { cwd: tmpDir });
+    await execFileAsync2("zip", ["-rq", outputPath, ...parts], { cwd: tmpDir });
   } finally {
     rmSync5(tmpDir, { recursive: true, force: true });
   }
   if (reveal) {
     try {
-      await execFileAsync("open", ["-R", outputPath]);
+      await execFileAsync2("open", ["-R", outputPath]);
     } catch {
     }
   }
   return outputPath;
 }
-var execFileAsync;
+var execFileAsync2;
 var init_session_export = __esm({
   "src/shared/session-export.ts"() {
     "use strict";
     init_paths();
-    execFileAsync = promisify(execFile2);
+    execFileAsync2 = promisify2(execFile3);
   }
 });
 
@@ -7427,12 +7758,12 @@ var init_uploader = __esm({
 });
 
 // src/shared/version.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { resolve as resolve8 } from "path";
 function readSisyphusVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync19(resolve8(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync20(resolve8(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -7470,14 +7801,19 @@ function formatDuration2(startOrMs, endIso) {
   if (minutes > 0) return `${minutes}m${seconds}s`;
   return `${seconds}s`;
 }
+function colorEnabled() {
+  if (process.env["FORCE_COLOR"] === "1") return true;
+  if (process.env["NO_COLOR"] !== void 0) return false;
+  if (process.env["TERM"] === "dumb") return false;
+  return process.stdout.isTTY === true;
+}
 function wrap(open, close = "\x1B[0m") {
-  return (s) => COLOR_ENABLED ? `${open}${s}${close}` : s;
+  return (s) => colorEnabled() ? `${open}${s}${close}` : s;
 }
-var COLOR_ENABLED, bold, dim, red, green, yellow, cyan, gray, magenta, white;
+var bold, dim, red, green, yellow, cyan, gray, magenta, white;
 var init_format = __esm({
   "src/shared/format.ts"() {
     "use strict";
-    COLOR_ENABLED = process.env["FORCE_COLOR"] === "1" || process.stdout.isTTY === true && process.env["NO_COLOR"] === void 0 && process.env["TERM"] !== "dumb";
     bold = wrap("\x1B[1m");
     dim = wrap("\x1B[2m");
     red = wrap("\x1B[31m");
@@ -7491,7 +7827,7 @@ var init_format = __esm({
 });
 
 // src/cli/deploy/creds.ts
-import { chmodSync, existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync20 } from "fs";
+import { chmodSync, existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync21 } from "fs";
 import { createInterface } from "readline";
 function isValidProvider(value) {
   return PROVIDERS.includes(value);
@@ -7532,12 +7868,12 @@ var init_pricing = __esm({
 });
 
 // src/cli/deploy/runtime.ts
-import { existsSync as existsSync20, readFileSync as readFileSync21, unlinkSync as unlinkSync3 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync22, unlinkSync as unlinkSync3 } from "fs";
 function readRuntimeState(provider) {
   const path = deployRuntimePath(provider);
-  if (!existsSync20(path)) return null;
+  if (!existsSync21(path)) return null;
   try {
-    return JSON.parse(readFileSync21(path, "utf-8"));
+    return JSON.parse(readFileSync22(path, "utf-8"));
   } catch {
     return null;
   }
@@ -7559,15 +7895,15 @@ var init_tailnet = __esm({
 });
 
 // src/cli/deploy/templates.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync22 } from "fs";
 import { dirname as dirname6, resolve as resolve9 } from "path";
 import { fileURLToPath } from "url";
 function deployRoot() {
   const here = dirname6(fileURLToPath(import.meta.url));
   const bundled = resolve9(here, "..", "deploy");
-  if (existsSync21(bundled)) return bundled;
+  if (existsSync22(bundled)) return bundled;
   const sourceRoot = resolve9(here, "..", "..", "..", "deploy");
-  if (existsSync21(sourceRoot)) return sourceRoot;
+  if (existsSync22(sourceRoot)) return sourceRoot;
   throw new Error(
     `Could not locate deploy/ templates. Looked at:
   ${bundled}
@@ -7596,7 +7932,7 @@ var init_tailscale = __esm({
 
 // src/cli/deploy/runner.ts
 import { spawn as spawn2, spawnSync } from "child_process";
-import { copyFileSync as copyFileSync5, existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync22 } from "fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync23 } from "fs";
 function readOutputs(provider) {
   const result = spawnSync("terraform", ["output", "-json", `-state=${deployStatePath(provider)}`], {
     cwd: providerModuleDir(provider),
@@ -7622,7 +7958,7 @@ function readOutputs(provider) {
   }
 }
 function isProvisioned(provider) {
-  if (!existsSync22(deployStatePath(provider))) return false;
+  if (!existsSync23(deployStatePath(provider))) return false;
   return readOutputs(provider) !== null;
 }
 function effectiveSshTarget(provider) {
@@ -7741,7 +8077,7 @@ var init_grove = __esm({
 
 // src/cli/cloud/repo.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { basename as basename5, join as join18 } from "path";
 function captureGit(args, cwd) {
   const result = spawnSync3("git", args, {
@@ -7782,10 +8118,10 @@ function buildRsyncArgs(localDir, remoteTarget) {
   ];
 }
 function detectPackageManager(toplevel) {
-  if (existsSync23(join18(toplevel, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync23(join18(toplevel, "bun.lockb"))) return "bun";
-  if (existsSync23(join18(toplevel, "yarn.lock"))) return "yarn";
-  if (existsSync23(join18(toplevel, "package-lock.json"))) return "npm";
+  if (existsSync24(join18(toplevel, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync24(join18(toplevel, "bun.lockb"))) return "bun";
+  if (existsSync24(join18(toplevel, "yarn.lock"))) return "yarn";
+  if (existsSync24(join18(toplevel, "package-lock.json"))) return "npm";
   return null;
 }
 function packageManagerInstallCmd(pm) {
@@ -7952,7 +8288,7 @@ async function cloudInstall(provider, repo, cwd) {
 }
 async function cloudSession(provider, repo) {
   const remoteDir = boxRepoPath(repo);
-  const cmd = `sis admin home-init ${shellQuote(repo)} ${shellQuoteHomePath(remoteDir)}`;
+  const cmd = `sis diagnostic home-init ${shellQuote(repo)} ${shellQuoteHomePath(remoteDir)}`;
   console.log(`\u2192 initializing tmux home session "${repo}" on box...`);
   const result = runOnBox(provider, cmd);
   if (result.exitCode !== 0) {
@@ -7986,7 +8322,7 @@ __export(cloud_handoff_exports, {
   triggerForceHandoff: () => triggerForceHandoff
 });
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 import { join as join19 } from "path";
 function runRsync2(args) {
   return new Promise((resolve13) => {
@@ -8026,7 +8362,7 @@ async function syncSessionState(cwd, sessionId, repo, target, provider) {
   const candidates = ["config.json", "orchestrator.md", "orchestrator-settings.json"];
   for (const name of candidates) {
     const localPath = join19(localProject, name);
-    if (!existsSync24(localPath)) continue;
+    if (!existsSync25(localPath)) continue;
     const remotePath = `${boxRepoPath(repo)}/.sisyphus/${name}`;
     const args = [
       "-avz",
@@ -8087,7 +8423,7 @@ async function pushToCloud(sessionId, cwd) {
   }
   const message = handoff.message;
   const remoteRepoDir = boxRepoPath(repo);
-  const baseCmd = message ? `sis session resume ${shellQuote(sessionId)} ${shellQuote(message)}` : `sis session resume ${shellQuote(sessionId)}`;
+  const baseCmd = message ? `sis session lifecycle resume ${shellQuote(sessionId)} ${shellQuote(message)}` : `sis session lifecycle resume ${shellQuote(sessionId)}`;
   const resumeCmd = `cd ${shellQuoteHomePath(remoteRepoDir)} && ${baseCmd}`;
   console.log(`[sisyphus] handoff: ssh sis resume`);
   const resumeResult = runOnBox(provider, resumeCmd);
@@ -8193,14 +8529,14 @@ var init_cloud_handoff = __esm({
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync25, readFileSync as readFileSync23, readdirSync as readdirSync11, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync24, readdirSync as readdirSync11, rmSync as rmSync6 } from "fs";
 function truncate(s, max) {
   return s.length <= max ? s : s.slice(0, max) + "...";
 }
 function readGoal(cwd, sessionId, fallback) {
   try {
     const p = goalPath(cwd, sessionId);
-    if (existsSync25(p)) return readFileSync23(p, "utf-8").trim();
+    if (existsSync26(p)) return readFileSync24(p, "utf-8").trim();
   } catch {
   }
   return fallback;
@@ -8369,7 +8705,7 @@ async function startSession(task, cwd, context, name, effort) {
 async function cloneSession(sourceId, cwd, goal, context, name, strategy) {
   const sourceSession = getSession(cwd, sourceId);
   if (sourceSession.status === "completed") {
-    throw new Error("Cannot clone completed session. Use `sis session continue` to resume it first.");
+    throw new Error("Cannot clone completed session. Use `sis session lifecycle continue` to resume it first.");
   }
   const cloneId = uuidv4();
   if (name && !NAME_PATTERN.test(name)) {
@@ -8439,7 +8775,7 @@ It is the other session's responsibility. You do not need to monitor it.
 function pruneOldSessions(cwd) {
   try {
     const dir = sessionsDir(cwd);
-    if (!existsSync25(dir)) return;
+    if (!existsSync26(dir)) return;
     const entries = readdirSync11(dir, { withFileTypes: true });
     const candidates = [];
     for (const entry of entries) {
@@ -8484,7 +8820,7 @@ async function reconnectSession(sessionId, cwd) {
   const session = getSession(cwd, sessionId);
   const tmuxName = session.tmuxSessionName ?? tmuxSessionName(cwd, session.name ?? sessionId.slice(0, 8));
   if (!sessionNameTaken(tmuxName)) {
-    throw new Error(`No tmux session named "${tmuxName}" exists. Use \`sis session resume\` to create a new one.`);
+    throw new Error(`No tmux session named "${tmuxName}" exists. Use \`sis session lifecycle resume\` to create a new one.`);
   }
   const tmuxSessId = resolveSessionId(tmuxName);
   if (!tmuxSessId) {
@@ -8575,9 +8911,18 @@ async function resumeSession(sessionId, cwd, message) {
 function getSessionStatus(cwd, sessionId) {
   return getSession(cwd, sessionId);
 }
+function countSessions(cwd) {
+  const dir = sessionsDir(cwd);
+  if (!existsSync26(dir)) return 0;
+  let n = 0;
+  for (const entry of readdirSync11(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) n++;
+  }
+  return n;
+}
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync25(dir)) return [];
+  if (!existsSync26(dir)) return [];
   const entries = readdirSync11(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
@@ -8650,8 +8995,8 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
 Agents: ${truncate(spawnedThisCycle, 200)}`;
     try {
       const logPath2 = cycleLogPath(cwd, sessionId, cycleNumber);
-      if (existsSync25(logPath2)) {
-        const log = readFileSync23(logPath2, "utf-8").trim();
+      if (existsSync26(logPath2)) {
+        const log = readFileSync24(logPath2, "utf-8").trim();
         if (log) cycleCtx += `
 Cycle log: ${truncate(log, 200)}`;
       }
@@ -8676,6 +9021,20 @@ Cycle log: ${truncate(log, 200)}`;
         await performHandoff2(sessionId, cwd);
         return;
       }
+      const sessionForOrphanResolve = getSession(cwd, sessionId);
+      const supersededAgentIds = sessionForOrphanResolve.agents.filter((a) => a.status !== "running").map((a) => a.id);
+      await Promise.all([
+        clearSessionOrphan(cwd, sessionId),
+        resolveOrchestratorOrphanAsks(cwd, sessionId, "respawn"),
+        ...supersededAgentIds.map(
+          (agentId) => resolveAgentOrphanAsks(cwd, sessionId, agentId, "superseded").catch((err) => {
+            console.warn(
+              `[sisyphus] resolveAgentOrphanAsks (superseded) failed for ${agentId}:`,
+              err instanceof Error ? err.message : err
+            );
+          })
+        )
+      ]);
       let activeWindowId = windowId;
       const tmuxName = freshSession.tmuxSessionName;
       const existingTmuxSessId = freshSession.tmuxSessionId;
@@ -8797,7 +9156,7 @@ async function handleSubmit(cwd, sessionId, agentId, report, windowId) {
 function formatPendingAskError(verb, askedBy, open) {
   const lines = open.map((a) => `  - ${a.askId} (${a.status})${a.title ? ": " + a.title : ""}`);
   const who = askedBy === ORCHESTRATOR_ASKED_BY ? "orchestrator" : `agent ${askedBy}`;
-  const recovery = verb === "yield" ? `Resolve before yielding: \`sis ask poll <askId>\` blocks until the user answers, then process the response and yield with a continuation prompt that names the answered branch.` : `Resolve before submitting: \`sis ask poll <askId>\` blocks until the user answers, parse the response, then call \`sis agent submit\` with your final report.`;
+  const recovery = verb === "yield" ? `Resolve before yielding: \`sis ask state poll <askId>\` blocks until the user answers, then process the response and yield with a continuation prompt that names the answered branch.` : `Resolve before submitting: \`sis ask state poll <askId>\` blocks until the user answers, parse the response, then call \`sis agent submit\` with your final report.`;
   return `Cannot ${verb}: ${who} owns ${open.length} open deck${open.length === 1 ? "" : "s"}:
 ${lines.join("\n")}
 
@@ -9231,8 +9590,8 @@ function digestTranscript(opts) {
     const role = entry.message?.role !== void 0 ? entry.message.role : entry.type;
     const text = formatContent(entry.message?.content);
     if (!text) continue;
-    const ts2 = entry.timestamp !== void 0 ? entry.timestamp : "";
-    kept.push({ ts: ts2, role, text });
+    const ts = entry.timestamp !== void 0 ? entry.timestamp : "";
+    kept.push({ ts, role, text });
   }
   let totalBytes = 0;
   const selected = [];
@@ -9279,11 +9638,10 @@ var init_transcript_digest = __esm({
 });
 
 // src/daemon/ask-visual.ts
-import { spawn as spawn6 } from "child_process";
 import {
   closeSync as closeSync2,
   constants,
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   fstatSync as fstatSync2,
   lstatSync,
   openSync as openSync2,
@@ -9295,16 +9653,17 @@ import { resolve as resolve10, dirname as dirname7, isAbsolute, sep } from "path
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { z as z3 } from "zod";
 import { tool } from "@r-cli/sdk";
+import { renderMarkdown, checkMarkdown } from "@crouton-kit/humanloop";
 async function generateVisualForQuestion(opts) {
   const meta = readMeta(opts.cwd, opts.sessionId, opts.askId);
   if (!meta) return { ok: false, error: `ask not found: ${opts.askId}` };
   const decisions = readDecisions(opts.cwd, opts.sessionId, opts.askId);
-  if (!decisions) return { ok: false, error: "decisions.json missing" };
+  if (!decisions) return { ok: false, error: "deck.json missing" };
   const question = decisions.interactions.find((q) => q.id === opts.qid);
   if (!question) return { ok: false, error: `qid ${opts.qid} not found in decisions` };
   const mdPath = askVisualMarkdownPath(opts.cwd, opts.sessionId, opts.askId, opts.qid);
   const ansiPath = askVisualAnsiPath(opts.cwd, opts.sessionId, opts.askId, opts.qid);
-  if (!opts.force && existsSync26(mdPath) && existsSync26(ansiPath)) {
+  if (!opts.force && existsSync27(mdPath) && existsSync27(ansiPath)) {
     return { ok: true, markdownPath: mdPath, ansiPath, turns: 0 };
   }
   if (opts.force) {
@@ -9333,7 +9692,7 @@ async function generateVisualForQuestion(opts) {
   );
   const attachVisualTool = tool(
     "attach_visual",
-    "Submit final termrender markdown for this question. Validated via `termrender --check` and rendered to ANSI.",
+    "Submit final directive-flavored markdown for this question. Validated and rendered to ANSI via the humanloop SDK (no subprocess).",
     { content: z3.string().min(1) },
     async (args) => {
       const r = await attachVisualHandler({ content: args.content, mdPath, ansiPath, cols: opts.cols });
@@ -9378,7 +9737,7 @@ function buildUserPrompt(q, askedBy, ctx) {
 }
 function readSystemPrompt() {
   if (cachedSystemPrompt !== void 0) return cachedSystemPrompt;
-  const found = SYSTEM_PROMPT_CANDIDATES.find((p) => existsSync26(p));
+  const found = SYSTEM_PROMPT_CANDIDATES.find((p) => existsSync27(p));
   if (found === void 0) {
     throw new Error(
       `termrender-haiku-system.md not found in any candidate location: ${SYSTEM_PROMPT_CANDIDATES.join(", ")}`
@@ -9447,48 +9806,20 @@ function readFileHandler(realSessionCwd, requestedPath) {
 function errorResult(msg) {
   return { content: [{ type: "text", text: msg }], isError: true };
 }
-function spawnAsync(cmd, args, input, timeoutMs) {
-  return new Promise((resolve13) => {
-    const chunks = [];
-    const errChunks = [];
-    const proc = spawn6(cmd, args, { stdio: ["pipe", "pipe", "pipe"], env: execEnv() });
-    const timer = setTimeout(() => {
-      proc.kill();
-      resolve13({ stdout: "", stderr: "", status: null, error: new Error(`timed out after ${timeoutMs}ms`) });
-    }, timeoutMs);
-    proc.stdout.on("data", (d) => chunks.push(d));
-    proc.stderr.on("data", (d) => errChunks.push(d));
-    proc.on("error", (err) => {
-      clearTimeout(timer);
-      resolve13({ stdout: "", stderr: "", status: null, error: err });
-    });
-    proc.on("close", (code) => {
-      clearTimeout(timer);
-      resolve13({ stdout: Buffer.concat(chunks).toString("utf-8"), stderr: Buffer.concat(errChunks).toString("utf-8"), status: code });
-    });
-    proc.stdin.end(input, "utf-8");
-  });
-}
 async function attachVisualHandler(args) {
-  const check = await spawnAsync("termrender", ["--check"], args.content, 5e3);
-  if (check.error) {
-    const msg = `termrender invocation failed: ${check.error.message}`;
+  const check = checkMarkdown(args.content);
+  if (!check.ok) {
+    const msg = `directive check rejected the content: ${check.error}`;
     return { ok: false, error: msg, toolResult: errorResult(msg) };
   }
-  if (check.status !== 0) {
-    const msg = `termrender --check rejected the content: ${check.stderr.trim()}`;
-    return { ok: false, error: msg, toolResult: errorResult(msg) };
-  }
-  const render = await spawnAsync("termrender", ["-w", String(args.cols)], args.content, 8e3);
-  if (render.error) {
-    const msg = `termrender render failed: ${render.error.message}`;
-    return { ok: false, error: msg, toolResult: errorResult(msg) };
-  }
-  if (render.status !== 0) {
-    const msg = `termrender render failed: ${render.stderr.trim()}`;
+  let ansi;
+  try {
+    const r = { lines: renderMarkdown(args.content, args.cols) };
+    ansi = r.lines.join("\n");
+  } catch (e) {
+    const msg = `render failed: ${e.message}`;
     return { ok: false, error: msg, toolResult: errorResult(msg) };
   }
-  const ansi = render.stdout;
   const ansiBytes = Buffer.byteLength(ansi, "utf-8");
   if (ansiBytes > ANSI_CAP) {
     const msg = `rendered ANSI exceeds ${ANSI_CAP} byte cap (got ${ansiBytes})`;
@@ -9534,7 +9865,6 @@ var READ_FILE_CAP, ANSI_CAP, SYSTEM_PROMPT_CANDIDATES, cachedSystemPrompt;
 var init_ask_visual = __esm({
   "src/daemon/ask-visual.ts"() {
     "use strict";
-    init_env();
     init_haiku();
     init_transcript_digest();
     init_ask_store();
@@ -9554,8 +9884,9 @@ var init_ask_visual = __esm({
 
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync as unlinkSync4, existsSync as existsSync27, writeFileSync as writeFileSync15, readFileSync as readFileSync25, mkdirSync as mkdirSync13, readdirSync as readdirSync12, rmSync as rmSync8, chmodSync as chmodSync2 } from "fs";
-import { join as join21 } from "path";
+import { unlinkSync as unlinkSync4, existsSync as existsSync28, writeFileSync as writeFileSync15, readFileSync as readFileSync26, mkdirSync as mkdirSync13, readdirSync as readdirSync12, rmSync as rmSync8, chmodSync as chmodSync2 } from "fs";
+import { join as join21, basename as basename6, dirname as dirname8 } from "path";
+import { scanInbox } from "@crouton-kit/humanloop";
 function setCompositor(c) {
   compositor = c;
 }
@@ -9573,9 +9904,9 @@ function persistSessionRegistry() {
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync27(p)) return {};
+  if (!existsSync28(p)) return {};
   try {
-    return JSON.parse(readFileSync25(p, "utf-8"));
+    return JSON.parse(readFileSync26(p, "utf-8"));
   } catch (err) {
     console.warn("[sisyphus] Failed to parse session registry:", err instanceof Error ? err.message : err);
     return {};
@@ -9605,7 +9936,14 @@ function registerSessionTmux(sessionId, tmuxSession, windowId, tmuxSessionId) {
   }
 }
 function unknownSessionError(sessionId) {
-  return { ok: false, error: `Unknown session: ${sessionId}. Run \`sis list --all\` to see available sessions.` };
+  return {
+    ok: false,
+    error: errNotFound("unknown_session", {
+      message: `Unknown session: ${sessionId}. Run \`sis session inspect list --all\` to see available sessions.`,
+      received: sessionId,
+      next: "sis session inspect list --all"
+    })
+  };
 }
 function collectAllSessionIds() {
   const idToCwd = /* @__PURE__ */ new Map();
@@ -9622,7 +9960,7 @@ function collectAllSessionIds() {
     scannedCwds.add(cwd);
     try {
       const dir = sessionsDir(cwd);
-      if (!existsSync27(dir)) continue;
+      if (!existsSync28(dir)) continue;
       for (const entry of readdirSync12(dir, { withFileTypes: true })) {
         if (entry.isDirectory() && !idToCwd.has(entry.name)) {
           idToCwd.set(entry.name, cwd);
@@ -9647,9 +9985,16 @@ function resolvePartialSessionId(partial) {
     return { id };
   }
   if (matches.length > 1) {
-    const list = matches.map((id) => `  ${id}`).join("\n");
-    return { error: { ok: false, error: `Ambiguous session prefix "${partial}" matches ${matches.length} sessions:
-${list}` } };
+    return {
+      error: {
+        ok: false,
+        error: errAmbiguous("ambiguous_session", {
+          message: `Ambiguous session prefix "${partial}" matches ${matches.length} sessions`,
+          received: partial,
+          candidates: matches
+        })
+      }
+    };
   }
   return { id: partial };
 }
@@ -9664,7 +10009,13 @@ async function handleRequest(req) {
   try {
     if ("sessionId" in req && req.sessionId) {
       if (!validateSessionId(req.sessionId)) {
-        return { ok: false, error: `Invalid session ID: must contain only alphanumeric characters, hyphens, and underscores` };
+        return {
+          ok: false,
+          error: errUsage("invalid_session_id", {
+            message: "Invalid session ID: must contain only alphanumeric characters, hyphens, and underscores",
+            received: req.sessionId
+          })
+        };
       }
       const resolved = resolvePartialSessionId(req.sessionId);
       if ("error" in resolved) return resolved.error;
@@ -9709,7 +10060,13 @@ async function handleRequest(req) {
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
         if (req.repo && req.repo !== "." && !validateRepoName(req.repo)) {
-          return { ok: false, error: 'Invalid repo name: must be a simple directory name without path separators or ".."' };
+          return {
+            ok: false,
+            error: errUsage("invalid_repo_name", {
+              message: 'Invalid repo name: must be a simple directory name without path separators or ".."',
+              received: req.repo
+            })
+          };
         }
         const result = await handleSpawn(req.sessionId, tracking.cwd, req.agentType, req.name, req.instruction, req.repo);
         return { ok: true, data: { agentId: result.agentId } };
@@ -9717,7 +10074,13 @@ async function handleRequest(req) {
       case "submit": {
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
-        if (!tracking.windowId) return { ok: false, error: `No tmux window found for session: ${req.sessionId}` };
+        if (!tracking.windowId) return {
+          ok: false,
+          error: errNotFound("no_tmux_window", {
+            message: `No tmux window found for session: ${req.sessionId}`,
+            received: req.sessionId
+          })
+        };
         await handleSubmit(tracking.cwd, req.sessionId, req.agentId, req.report, tracking.windowId);
         return { ok: true };
       }
@@ -9737,7 +10100,13 @@ async function handleRequest(req) {
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
         const result = await handleAwait(tracking.cwd, req.sessionId, req.agentId);
-        if (!result) return { ok: false, error: `Unknown agent: ${req.agentId} in session ${req.sessionId}` };
+        if (!result) return {
+          ok: false,
+          error: errNotFound("unknown_agent", {
+            message: `Unknown agent: ${req.agentId} in session ${req.sessionId}`,
+            received: req.agentId
+          })
+        };
         return {
           ok: true,
           data: {
@@ -9811,7 +10180,7 @@ async function handleRequest(req) {
           for (const tracking of sessionTrackingMap.values()) {
             if (seenCwds.has(tracking.cwd)) continue;
             seenCwds.add(tracking.cwd);
-            totalCount += listSessions(tracking.cwd).length;
+            totalCount += countSessions(tracking.cwd);
           }
           if (totalCount > allSessions.length) {
             return { ok: true, data: { sessions: allSessions, totalCount, filtered: true } };
@@ -9823,12 +10192,19 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync27(stateFile)) {
+          if (existsSync28(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
           } else {
-            return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json found at ${stateFile}. Run \`sis list --all\` to see available sessions.` };
+            return {
+              ok: false,
+              error: errNotFound("unknown_session", {
+                message: `Unknown session: ${req.sessionId}. No state.json found at ${stateFile}. Run \`sis session inspect list --all\` to see available sessions.`,
+                received: req.sessionId,
+                next: "sis session inspect list --all"
+              })
+            };
           }
         }
         const session = await resumeSession(req.sessionId, tracking.cwd, req.message);
@@ -9838,8 +10214,15 @@ async function handleRequest(req) {
       }
       case "clear-orphan": {
         const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-        if (!existsSync27(stateFile)) {
-          return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json at ${stateFile}.` };
+        if (!existsSync28(stateFile)) {
+          return {
+            ok: false,
+            error: errNotFound("unknown_session", {
+              message: `Unknown session: ${req.sessionId}. No state.json at ${stateFile}.`,
+              received: req.sessionId,
+              next: "sis session inspect list --all"
+            })
+          };
         }
         await Promise.all([
           clearSessionOrphan(req.cwd, req.sessionId),
@@ -9889,7 +10272,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync27(stateFile)) {
+          if (existsSync28(stateFile)) {
             registerSessionCwd(req.sessionId, req.cwd);
             tracking = sessionTrackingMap.get(req.sessionId);
           } else {
@@ -9903,7 +10286,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync27(stateFile)) {
+          if (existsSync28(stateFile)) {
             registerSessionCwd(req.sessionId, req.cwd);
             tracking = sessionTrackingMap.get(req.sessionId);
           } else {
@@ -9920,7 +10303,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync27(stateFile)) {
+          if (existsSync28(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -9990,7 +10373,7 @@ async function handleRequest(req) {
       }
       case "set-upload-status": {
         const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-        if (!existsSync27(stateFile)) {
+        if (!existsSync28(stateFile)) {
           return unknownSessionError(req.sessionId);
         }
         try {
@@ -10002,7 +10385,12 @@ async function handleRequest(req) {
           });
           return { ok: true };
         } catch (err) {
-          return { ok: false, error: `Failed to persist upload status: ${err instanceof Error ? err.message : String(err)}` };
+          return {
+            ok: false,
+            error: errPermanent("rpc_failed", {
+              message: `Failed to persist upload status: ${err instanceof Error ? err.message : String(err)}`
+            })
+          };
         }
       }
       case "message": {
@@ -10048,13 +10436,32 @@ async function handleRequest(req) {
           const liveCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt);
           paneId = liveCycle?.paneId ?? session.orchestratorCycles.at(-1)?.paneId;
           targetLabel = "orchestrator";
-          if (!paneId) return { ok: false, error: "No orchestrator pane found for this session" };
+          if (!paneId) return {
+            ok: false,
+            error: errNotFound("no_orchestrator_pane", {
+              message: "No orchestrator pane found for this session",
+              received: req.sessionId
+            })
+          };
         } else {
           const agentId = req.target.agentId;
           const ag = session.agents.find((a) => a.id === agentId);
-          if (!ag) return { ok: false, error: `Unknown agent: ${agentId} in session ${req.sessionId}` };
+          if (!ag) return {
+            ok: false,
+            error: errNotFound("unknown_agent", {
+              message: `Unknown agent: ${agentId} in session ${req.sessionId}`,
+              received: agentId
+            })
+          };
           if (ag.status !== "running") {
-            return { ok: false, error: `Agent ${agentId} is ${ag.status}, not running \u2014 cannot tell` };
+            return {
+              ok: false,
+              error: errConflict("agent_not_running", {
+                message: `Agent ${agentId} is ${ag.status}, not running \u2014 cannot tell`,
+                received: ag.status,
+                expected: "running"
+              })
+            };
           }
           paneId = ag.paneId;
           targetLabel = agentId;
@@ -10062,7 +10469,12 @@ async function handleRequest(req) {
         try {
           pasteToPane(paneId, req.text, req.submit);
         } catch (err) {
-          return { ok: false, error: err instanceof Error ? err.message : String(err) };
+          return {
+            ok: false,
+            error: errPermanent("rpc_failed", {
+              message: err instanceof Error ? err.message : String(err)
+            })
+          };
         }
         tracking.messageCounter += 1;
         const id = `tell-${String(tracking.messageCounter).padStart(3, "0")}`;
@@ -10093,7 +10505,7 @@ async function handleRequest(req) {
         return { ok: true, data: companion };
       }
       case "register-segment": {
-        if (!compositor) return { ok: false, error: "Compositor not initialized" };
+        if (!compositor) return { ok: false, error: errTransient("compositor_uninit", { message: "Compositor not initialized" }) };
         compositor.registerExternal({
           id: req.id,
           side: req.side,
@@ -10104,26 +10516,41 @@ async function handleRequest(req) {
         return { ok: true };
       }
       case "update-segment": {
-        if (!compositor) return { ok: false, error: "Compositor not initialized" };
+        if (!compositor) return { ok: false, error: errTransient("compositor_uninit", { message: "Compositor not initialized" }) };
         try {
           compositor.updateExternal(req.id, req.content);
           return { ok: true };
         } catch (e) {
-          return { ok: false, error: e.message };
+          return {
+            ok: false,
+            error: errPermanent("rpc_failed", { message: e.message })
+          };
         }
       }
       case "unregister-segment": {
-        if (!compositor) return { ok: false, error: "Compositor not initialized" };
+        if (!compositor) return { ok: false, error: errTransient("compositor_uninit", { message: "Compositor not initialized" }) };
         compositor.unregisterExternal(req.id);
         return { ok: true };
       }
       case "ask-generate-visual": {
         const ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
-        if (!ID_RE.test(req.askId)) return { ok: false, error: `Invalid askId: ${req.askId}` };
-        if (!ID_RE.test(req.qid)) return { ok: false, error: `Invalid qid: ${req.qid}` };
+        if (!ID_RE.test(req.askId)) return {
+          ok: false,
+          error: errUsage("invalid_ask_id", { message: `Invalid askId: ${req.askId}`, received: req.askId })
+        };
+        if (!ID_RE.test(req.qid)) return {
+          ok: false,
+          error: errUsage("invalid_qid", { message: `Invalid qid: ${req.qid}`, received: req.qid })
+        };
         const tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) return unknownSessionError(req.sessionId);
-        if (!tracking.cwd) return { ok: false, error: `No cwd registered for session: ${req.sessionId}` };
+        if (!tracking.cwd) return {
+          ok: false,
+          error: errUsage("no_cwd_registered", {
+            message: `No cwd registered for session: ${req.sessionId}`,
+            received: req.sessionId
+          })
+        };
         const result = await generateVisualForQuestion({
           cwd: tracking.cwd,
           sessionId: req.sessionId,
@@ -10135,62 +10562,31 @@ async function handleRequest(req) {
         if (result.ok) {
           return { ok: true, data: { markdownPath: result.markdownPath, ansiPath: result.ansiPath, turns: result.turns } };
         }
-        return { ok: false, error: result.error };
+        return {
+          ok: false,
+          error: errPermanent("rpc_failed", { message: result.error })
+        };
       }
       case "inbox-list": {
-        const items = [];
+        const askDirs = [];
         for (const [sessionId, tracking] of sessionTrackingMap) {
           if (!tracking.cwd) continue;
-          let askIds = [];
-          try {
-            askIds = listAsks(tracking.cwd, sessionId);
-          } catch (err) {
-            console.warn(`[sisyphus] inbox-list: listAsks failed for ${sessionId}:`, err);
-            continue;
-          }
-          const sessionName = tracking.name;
-          for (const askId of askIds) {
-            try {
-              const meta = readMeta(tracking.cwd, sessionId, askId);
-              if (!meta) continue;
-              if (meta.status === "answered") continue;
-              let title = meta.title;
-              let subtitle = meta.subtitle;
-              let kind = meta.kind;
-              if (title === void 0 || kind === void 0) {
-                try {
-                  const decisions = readDecisions(tracking.cwd, sessionId, askId);
-                  if (decisions) {
-                    const q0 = decisions.interactions[0];
-                    if (title === void 0) title = decisions.title !== void 0 ? decisions.title : q0?.title;
-                    if (subtitle === void 0) subtitle = q0?.subtitle;
-                    if (kind === void 0) kind = q0?.kind;
-                  }
-                } catch (_err) {
-                }
-              }
-              items.push({
-                sessionId,
-                sessionName,
-                cwd: tracking.cwd,
-                askId,
-                askedBy: meta.askedBy,
-                askedAt: meta.askedAt,
-                status: meta.status,
-                blocking: meta.blocking,
-                orphaned: meta.orphaned,
-                title,
-                subtitle,
-                blockedSince: meta.status === "in-progress" ? meta.startedAt ?? meta.askedAt : meta.askedAt,
-                kind
-              });
-            } catch (err) {
-              console.warn(`[sisyphus] inbox-list: readMeta failed for ${sessionId}/${askId}:`, err);
-            }
-          }
+          askDirs.push(askDir(tracking.cwd, sessionId));
+        }
+        let items;
+        try {
+          items = scanInbox(askDirs);
+        } catch (err) {
+          console.warn("[sisyphus] inbox-list: scanInbox failed:", err);
+          items = [];
         }
-        items.sort((a, b) => a.blockedSince.localeCompare(b.blockedSince));
-        return { ok: true, data: { items } };
+        const itemsWithName = items.map((item) => {
+          const sessionId = basename6(dirname8(dirname8(dirname8(item.dir))));
+          const tracking = sessionTrackingMap.get(sessionId);
+          const sessionName = tracking?.name ?? item.source?.sessionName;
+          return { ...item, sessionName };
+        });
+        return { ok: true, data: { items: itemsWithName } };
       }
       case "cloud-handoff": {
         const tracking = sessionTrackingMap.get(req.sessionId);
@@ -10198,23 +10594,45 @@ async function handleRequest(req) {
         const session = getSession(tracking.cwd, req.sessionId);
         if (session.handoff?.sentAt) {
           const where = session.handoff.target ? `${session.handoff.target.provider}:${session.handoff.target.repo}` : "cloud";
-          return { ok: false, error: `Session ${req.sessionId} is already on ${where}. Use \`sis cloud reclaim\` first.` };
+          return {
+            ok: false,
+            error: errConflict("already_on_cloud", {
+              message: `Session ${req.sessionId} is already on ${where}. Use \`sis cloud handoff pull\` first.`,
+              received: req.sessionId,
+              next: "sis cloud handoff pull"
+            })
+          };
         }
         if (session.handoff && !req.force) {
-          return { ok: false, error: `Session ${req.sessionId} already has a queued handoff. Pass --force to override or --cancel to clear.` };
+          return {
+            ok: false,
+            error: errConflict("handoff_already_queued", {
+              message: `Session ${req.sessionId} already has a queued handoff. Pass --force to override or run \`sis cloud handoff cancel ${req.sessionId}\` to clear.`,
+              received: req.sessionId
+            })
+          };
         }
         const { resolveProvider: resolveProvider2, defaultRepoName: defaultRepoName2, checkRepoName: checkRepoName2, triggerForceHandoff: triggerForceHandoff2 } = await Promise.resolve().then(() => (init_cloud_handoff(), cloud_handoff_exports));
         let provider;
         try {
           provider = resolveProvider2(req.provider);
         } catch (err) {
-          return { ok: false, error: err instanceof Error ? err.message : String(err) };
+          return {
+            ok: false,
+            error: errPermanent("rpc_failed", { message: err instanceof Error ? err.message : String(err) })
+          };
         }
         const repo = req.repo ?? defaultRepoName2(tracking.cwd);
         try {
           checkRepoName2(repo);
         } catch (err) {
-          return { ok: false, error: err instanceof Error ? err.message : String(err) };
+          return {
+            ok: false,
+            error: errUsage("invalid_repo_name", {
+              message: err instanceof Error ? err.message : String(err),
+              received: repo
+            })
+          };
         }
         await updateSession(tracking.cwd, req.sessionId, {
           handoff: {
@@ -10234,10 +10652,23 @@ async function handleRequest(req) {
         if (!tracking) return unknownSessionError(req.sessionId);
         const session = getSession(tracking.cwd, req.sessionId);
         if (!session.handoff) {
-          return { ok: false, error: `Session ${req.sessionId} has no queued handoff.` };
+          return {
+            ok: false,
+            error: errNotFound("no_queued_handoff", {
+              message: `Session ${req.sessionId} has no queued handoff.`,
+              received: req.sessionId
+            })
+          };
         }
         if (session.handoff.sentAt) {
-          return { ok: false, error: `Session ${req.sessionId} has already shipped to cloud \u2014 use \`sis cloud reclaim\` to bring it back.` };
+          return {
+            ok: false,
+            error: errConflict("already_shipped", {
+              message: `Session ${req.sessionId} has already shipped to cloud \u2014 use \`sis cloud handoff pull\` to bring it back.`,
+              received: req.sessionId,
+              next: "sis cloud handoff pull"
+            })
+          };
         }
         await updateSession(tracking.cwd, req.sessionId, { handoff: void 0 });
         return { ok: true, data: { cancelled: true } };
@@ -10247,7 +10678,13 @@ async function handleRequest(req) {
         if (!tracking) return unknownSessionError(req.sessionId);
         const session = getSession(tracking.cwd, req.sessionId);
         if (!session.handoff?.sentAt) {
-          return { ok: false, error: `Session ${req.sessionId} was never sent to cloud; nothing to reclaim.` };
+          return {
+            ok: false,
+            error: errConflict("not_on_cloud", {
+              message: `Session ${req.sessionId} was never sent to cloud; nothing to reclaim.`,
+              received: req.sessionId
+            })
+          };
         }
         await updateSession(tracking.cwd, req.sessionId, {
           handoff: { ...session.handoff, reclaimedAt: (/* @__PURE__ */ new Date()).toISOString() }
@@ -10259,7 +10696,14 @@ async function handleRequest(req) {
         if (!tracking) return unknownSessionError(req.sessionId);
         const session = getSession(tracking.cwd, req.sessionId);
         if (session.handoff?.sentAt) {
-          return { ok: false, error: `Session ${req.sessionId} already lives on cloud; nothing to quiesce locally.` };
+          return {
+            ok: false,
+            error: errConflict("already_on_cloud", {
+              message: `Session ${req.sessionId} already lives on cloud; nothing to quiesce locally.`,
+              received: req.sessionId,
+              next: "sis cloud handoff pull"
+            })
+          };
         }
         await updateSession(tracking.cwd, req.sessionId, {
           handoff: {
@@ -10275,17 +10719,23 @@ async function handleRequest(req) {
         return { ok: true, data: { queued: true, force: false } };
       }
       default:
-        return { ok: false, error: `Unknown request type: ${req.type}` };
+        return {
+          ok: false,
+          error: errUsage("unknown_request_type", {
+            message: `Unknown request type: ${req.type}`,
+            received: req.type
+          })
+        };
     }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    return { ok: false, error: message };
+    return { ok: false, error: errPermanent("internal_error", { message }) };
   }
 }
 function startServer() {
   return new Promise((resolve13, reject) => {
     const sock = socketPath();
-    if (existsSync27(sock)) {
+    if (existsSync28(sock)) {
       unlinkSync4(sock);
     }
     server = createServer((conn) => {
@@ -10300,7 +10750,7 @@ function startServer() {
           try {
             req = JSON.parse(line);
           } catch {
-            conn.write(JSON.stringify({ ok: false, error: "Invalid JSON" }) + "\n");
+            conn.write(JSON.stringify({ ok: false, error: errUsage("invalid_json", { message: "Invalid JSON" }) }) + "\n");
             continue;
           }
           handleRequest(req).then((res) => {
@@ -10310,7 +10760,7 @@ function startServer() {
           }).catch((err) => {
             console.warn("[sisyphus] Unhandled request error:", err instanceof Error ? err.message : err);
             if (!conn.destroyed) {
-              conn.write(JSON.stringify({ ok: false, error: "Internal server error" }) + "\n");
+              conn.write(JSON.stringify({ ok: false, error: errPermanent("internal_error", { message: "Internal server error" }) }) + "\n");
             }
           });
         }
@@ -10340,7 +10790,7 @@ function stopServer() {
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync27(sock)) {
+      if (existsSync28(sock)) {
         unlinkSync4(sock);
       }
       server = null;
@@ -10353,6 +10803,7 @@ var init_server = __esm({
   "src/daemon/server.ts"() {
     "use strict";
     init_paths();
+    init_protocol();
     init_shell();
     init_session_manager();
     init_companion();
@@ -10367,6 +10818,7 @@ var init_server = __esm({
     init_orchestrator();
     init_agent();
     init_tmux();
+    init_paths();
     server = null;
     compositor = null;
     sessionTrackingMap = /* @__PURE__ */ new Map();
@@ -10378,9 +10830,10 @@ init_paths();
 init_config();
 init_server();
 init_orphan_sweep();
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync28, writeFileSync as writeFileSync17, unlinkSync as unlinkSync6, existsSync as existsSync31 } from "fs";
+import { mkdirSync as mkdirSync15, readFileSync as readFileSync29, writeFileSync as writeFileSync17, unlinkSync as unlinkSync6, existsSync as existsSync32 } from "fs";
 import { execSync as execSync8 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
+import { Command } from "commander";
 
 // src/daemon/heartbeat-asks.ts
 init_ask_store();
@@ -10388,7 +10841,7 @@ init_state();
 init_server();
 init_paths();
 import { ulid as ulid3 } from "ulid";
-import { existsSync as existsSync28 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 var HEARTBEAT_ASKED_BY2 = "system:heartbeat";
 var HEARTBEAT_THRESHOLD_MS = 60 * 60 * 1e3;
 var HEARTBEAT_SCAN_INTERVAL_MS = 15 * 60 * 1e3;
@@ -10443,17 +10896,47 @@ async function emitHeartbeatAsk(cwd, sessionId, original) {
   });
   writeDecisions(cwd, sessionId, askId, deck);
   await updateMeta(cwd, sessionId, original.askId, {
-    heartbeatNotifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+    heartbeatNotifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    heartbeatAskId: askId
   });
 }
+function isModeGateStale(deck, currentMode) {
+  const source = deck.source;
+  const chain = source?.modeChain;
+  if (!chain || chain.length === 0) return false;
+  if (!currentMode) return false;
+  return !chain.some((e) => e.mode === currentMode);
+}
 async function scanSessionForStaleAsks(cwd, sessionId) {
   const now = Date.now();
+  let currentMode;
+  try {
+    const session = getSession(cwd, sessionId);
+    currentMode = session.orchestratorCycles[session.orchestratorCycles.length - 1]?.mode;
+  } catch {
+  }
   for (const askId of listAsks(cwd, sessionId)) {
     try {
       const meta = readMeta(cwd, sessionId, askId);
       if (!meta) continue;
       if (meta.status === "answered") continue;
       if (meta.orphaned) continue;
+      if (meta.modeTransition === true) {
+        const deck = readDecisions(cwd, sessionId, askId);
+        if (deck && isModeGateStale(deck, currentMode)) {
+          writeOutput(cwd, sessionId, askId, [{
+            id: "mode-transition",
+            selectedOptionId: "ack",
+            freetext: "auto-resolved: session advanced past mode-transition"
+          }]);
+          await updateMeta(cwd, sessionId, askId, {
+            status: "answered",
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          console.log(`[sisyphus] mode-gate auto-resolved ask ${askId} for session ${sessionId} (currentMode: ${currentMode})`);
+        }
+        continue;
+      }
       if (meta.heartbeatNotifiedAt) continue;
       if (meta.askedBy === HEARTBEAT_ASKED_BY2) continue;
       const askedAtMs = new Date(meta.askedAt).getTime();
@@ -10471,7 +10954,7 @@ async function scanSessionForStaleAsks(cwd, sessionId) {
 async function scanAllSessionsForStaleAsks() {
   const reg = loadSessionRegistry();
   for (const [sessionId, cwd] of Object.entries(reg)) {
-    if (!existsSync28(statePath(cwd, sessionId))) continue;
+    if (!existsSync29(statePath(cwd, sessionId))) continue;
     try {
       await scanSessionForStaleAsks(cwd, sessionId);
     } catch (err) {
@@ -10534,17 +11017,15 @@ var DEFAULT_STATUS_BAR_CONFIG = {
 init_tmux();
 init_status_dots();
 init_companion();
-init_exec();
-init_shell();
-import { readFileSync as readFileSync26, existsSync as existsSync29 } from "fs";
+import { readFileSync as readFileSync27, existsSync as existsSync30 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join22 } from "path";
 var STATUS_BAR_BG = "#1d1e21";
 var SESSION_ORDER_PATH = join22(homedir8(), ".config", "tmux", "session-order");
 function getSessionOrder() {
   try {
-    if (!existsSync29(SESSION_ORDER_PATH)) return [];
-    return readFileSync26(SESSION_ORDER_PATH, "utf-8").split("\n").filter(Boolean);
+    if (!existsSync30(SESSION_ORDER_PATH)) return [];
+    return readFileSync27(SESSION_ORDER_PATH, "utf-8").split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -10554,17 +11035,6 @@ var STATE_PRIORITY = {
   stopped: 2,
   idle: 1
 };
-function listWindowsForSession(sessionName) {
-  const output = execSafe(`tmux list-windows -t ${shellQuote(sessionName)} -F "#{window_index} #{window_id} #{window_name}"`);
-  if (!output) return [];
-  return output.split("\n").filter(Boolean).map((line) => {
-    const parts = line.split(" ");
-    const index = parseInt(parts[0], 10);
-    const id = parts[1];
-    const name = parts.slice(2).join(" ");
-    return { index, id, name };
-  });
-}
 function leftArrow(fromBg, toBg) {
   return `#[fg=${fromBg}]#[bg=${toBg}]\uE0B0`;
 }
@@ -10585,6 +11055,11 @@ var Compositor = class {
   segments = /* @__PURE__ */ new Map();
   external = /* @__PURE__ */ new Map();
   config;
+  // Per-session diff cache: skip setSessionOption when the rendered string is
+  // unchanged. With 12 sessions at 5s polling this is the difference between
+  // 24 tmux subprocess spawns per render and 0 on a stable status bar.
+  lastLeftBySession = /* @__PURE__ */ new Map();
+  lastRightBySession = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = config;
   }
@@ -10602,18 +11077,35 @@ var Compositor = class {
   unregisterExternal(id) {
     this.external.delete(id);
   }
-  render() {
-    const ctx = this.buildContext();
+  render(panesByWindow) {
+    const ctx = this.buildContext(panesByWindow);
+    const liveNames = /* @__PURE__ */ new Set();
     for (const session of ctx.allSessions) {
+      liveNames.add(session.name);
       const sessionCtx = this.buildSessionContext(ctx, session.name);
-      setSessionOption(session.name, "@sisyphus_left", this.composeLeft(sessionCtx));
-      setSessionOption(session.name, "@sisyphus_right", this.composeRight(sessionCtx));
+      const left = this.composeLeft(sessionCtx);
+      if (this.lastLeftBySession.get(session.name) !== left) {
+        setSessionOption(session.name, "@sisyphus_left", left);
+        this.lastLeftBySession.set(session.name, left);
+      }
+      const right = this.composeRight(sessionCtx);
+      if (this.lastRightBySession.get(session.name) !== right) {
+        setSessionOption(session.name, "@sisyphus_right", right);
+        this.lastRightBySession.set(session.name, right);
+      }
+    }
+    for (const name of this.lastLeftBySession.keys()) {
+      if (!liveNames.has(name)) this.lastLeftBySession.delete(name);
+    }
+    for (const name of this.lastRightBySession.keys()) {
+      if (!liveNames.has(name)) this.lastRightBySession.delete(name);
     }
   }
-  buildContext() {
+  buildContext(panesByWindow) {
     const allPanes = listAllPanes();
     const allSessionEntries = listAllSessions();
     const allSessions = allSessionEntries.map((e) => ({ name: e.name }));
+    const panes = panesByWindow ?? listAllPanesByWindow();
     const sessionStates = /* @__PURE__ */ new Map();
     for (const { sessionName, paneId } of allPanes) {
       const state = readClaudeState(paneId);
@@ -10626,10 +11118,7 @@ var Compositor = class {
     const sisyphusPhases2 = getSisyphusPhases();
     const sessionOrder = getSessionOrder();
     const companion = loadCompanion();
-    const windowsBySession = /* @__PURE__ */ new Map();
-    for (const session of allSessions) {
-      windowsBySession.set(session.name, listWindowsForSession(session.name));
-    }
+    const windowsBySession = listAllWindowsBySession();
     return {
       allSessions,
       allPanes,
@@ -10639,6 +11128,7 @@ var Compositor = class {
       companion,
       config: this.config,
       windowsBySession,
+      panesByWindow: panes,
       prevBg: STATUS_BAR_BG,
       currentSession: ""
       // overwritten per-session in buildSessionContext
@@ -10928,7 +11418,6 @@ function createCompanionSegment() {
 }
 
 // src/daemon/segments/windows.ts
-init_tmux();
 init_status_dots();
 function createWindowsSegment() {
   return {
@@ -10947,7 +11436,7 @@ function createWindowsSegment() {
       if (!windows || windows.length === 0) return { content: "" };
       const windowDots = /* @__PURE__ */ new Map();
       for (const win of windows) {
-        const panes = listWindowPanes(win.id);
+        const panes = ctx.panesByWindow.get(win.id) ?? [];
         let dots = "";
         for (const { paneId } of panes) {
           const state = readClaudeState(paneId);
@@ -11061,8 +11550,8 @@ function buildEntries() {
   return entries;
 }
 function toTsv(entries) {
-  const ts2 = Math.floor(Date.now() / 1e3);
-  const lines = [`#ts:${ts2}`];
+  const ts = Math.floor(Date.now() / 1e3);
+  const lines = [`#ts:${ts}`];
   for (const e of entries) {
     lines.push(`${e.type}	${e.tmuxName}	${e.cwd}	${e.phase ?? "-"}	${e.tmuxSessionId}`);
   }
@@ -11080,8 +11569,8 @@ function writeManifest() {
   atomicWrite(sessionsManifestPath(), toJson(entries));
 }
 function writeEmptyManifest() {
-  const ts2 = Math.floor(Date.now() / 1e3);
-  atomicWrite(sessionsManifestTsvPath(), `#ts:${ts2}
+  const ts = Math.floor(Date.now() / 1e3);
+  atomicWrite(sessionsManifestTsvPath(), `#ts:${ts}
 `);
   atomicWrite(sessionsManifestPath(), JSON.stringify({ updatedAt: Date.now(), sessions: [] }, null, 2));
 }
@@ -11209,7 +11698,7 @@ async function checkAndApply() {
     console.error("[sisyphus] Auto-update check failed:", err);
   }
 }
-var UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+var UPDATE_INTERVAL_MS = 15 * 60 * 1e3;
 var updateTimer = null;
 function startPeriodicUpdateCheck() {
   if (isLinkedInstall()) return;
@@ -11226,7 +11715,7 @@ function stopPeriodicUpdateCheck() {
 }
 
 // src/daemon/plugin-install.ts
-import { copyFileSync as copyFileSync6, mkdirSync as mkdirSync14, readdirSync as readdirSync13, statSync as statSync4, existsSync as existsSync30, readFileSync as readFileSync27, chmodSync as chmodSync3 } from "fs";
+import { copyFileSync as copyFileSync6, mkdirSync as mkdirSync14, readdirSync as readdirSync13, statSync as statSync4, existsSync as existsSync31, readFileSync as readFileSync28, chmodSync as chmodSync3 } from "fs";
 import { join as join23, resolve as resolve12 } from "path";
 import { homedir as homedir9 } from "os";
 var PLUGIN_NAME = "sisyphus-tmux";
@@ -11240,7 +11729,7 @@ function copyDir(src, dest) {
       copyDir(srcPath, destPath);
     } else {
       const srcMtime = statSync4(srcPath).mtimeMs;
-      const destMtime = existsSync30(destPath) ? statSync4(destPath).mtimeMs : 0;
+      const destMtime = existsSync31(destPath) ? statSync4(destPath).mtimeMs : 0;
       if (srcMtime > destMtime) {
         copyFileSync6(srcPath, destPath);
       }
@@ -11250,16 +11739,16 @@ function copyDir(src, dest) {
 function pluginNeedsUpdate(sourceDir) {
   const srcHooks = join23(sourceDir, "hooks", "hooks.json");
   const destHooks = join23(INSTALL_DIR, "hooks", "hooks.json");
-  if (!existsSync30(destHooks)) return true;
+  if (!existsSync31(destHooks)) return true;
   try {
-    return readFileSync27(srcHooks, "utf-8") !== readFileSync27(destHooks, "utf-8");
+    return readFileSync28(srcHooks, "utf-8") !== readFileSync28(destHooks, "utf-8");
   } catch {
     return true;
   }
 }
 function installPlugin() {
   const sourceDir = resolve12(import.meta.dirname, "../templates/sisyphus-tmux-plugin");
-  if (!existsSync30(sourceDir)) {
+  if (!existsSync31(sourceDir)) {
     console.error(`[plugin-install] Source dir not found: ${sourceDir}`);
     return;
   }
@@ -11267,7 +11756,7 @@ function installPlugin() {
   try {
     copyDir(sourceDir, INSTALL_DIR);
     const hookScript = join23(INSTALL_DIR, "hooks", "tmux-state.sh");
-    if (existsSync30(hookScript)) {
+    if (existsSync31(hookScript)) {
       try {
         chmodSync3(hookScript, 493);
       } catch {
@@ -11322,18 +11811,13 @@ if (nodeVersion < 22) {
   console.error(`[sisyphus] Node.js v22+ required (current: v${process.versions.node})`);
   process.exit(1);
 }
-var ts = () => (/* @__PURE__ */ new Date()).toISOString();
-var origLog = console.log.bind(console);
-var origError = console.error.bind(console);
-console.log = (...args) => origLog(`[${ts()}]`, ...args);
-console.error = (...args) => origError(`[${ts()}]`, ...args);
 function ensureDirs() {
   mkdirSync15(globalDir(), { recursive: true });
 }
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync28(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync29(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -11394,6 +11878,94 @@ function stopDaemon() {
   releasePidLock();
   return true;
 }
+async function recoverOneSession(sessionId, cwd, tmuxIdSet, tmuxNameToId, panesByWindow) {
+  const stateFile = statePath(cwd, sessionId);
+  if (!existsSync32(stateFile)) return false;
+  let session;
+  try {
+    session = JSON.parse(readFileSync29(stateFile, "utf-8"));
+  } catch {
+    console.error(`[sisyphus] Failed to read session state for ${sessionId}, skipping`);
+    return false;
+  }
+  if (session.status !== "active" && session.status !== "paused") return false;
+  registerSessionCwd(sessionId, cwd);
+  resetAgentCounterFromState(sessionId, session.agents ?? []);
+  if (!session.tmuxSessionName) return true;
+  let sessionAlive = false;
+  let currentTmuxId = session.tmuxSessionId;
+  if (currentTmuxId && tmuxIdSet.has(currentTmuxId)) {
+    sessionAlive = true;
+  } else {
+    currentTmuxId = void 0;
+  }
+  if (!sessionAlive) {
+    const resolved = tmuxNameToId.get(session.tmuxSessionName);
+    if (resolved) {
+      currentTmuxId = resolved;
+      sessionAlive = true;
+      await updateSessionTmux(cwd, sessionId, session.tmuxSessionName, session.tmuxWindowId ?? "", currentTmuxId);
+    }
+  }
+  if (!sessionAlive) {
+    if (session.status === "active") {
+      await updateSessionStatus(cwd, sessionId, "paused");
+      await updateSession(cwd, sessionId, { tmuxSessionId: void 0 });
+      console.log(`[sisyphus] Session ${sessionId} paused: tmux session no longer exists`);
+    }
+    return true;
+  }
+  let windowId = session.tmuxWindowId;
+  if (!windowId) {
+    windowId = getFirstWindowId(currentTmuxId) ?? getFirstWindowId(session.tmuxSessionName) ?? void 0;
+    if (windowId) {
+      await updateSessionTmux(cwd, sessionId, session.tmuxSessionName, windowId, currentTmuxId);
+      console.log(`[sisyphus] Discovered missing windowId ${windowId} for session ${sessionId}`);
+    }
+  }
+  const livePanes = windowId ? panesByWindow.get(windowId) ?? listPanes(windowId) : [];
+  if (livePanes.length === 0) {
+    if (session.status === "active") {
+      await updateSessionStatus(cwd, sessionId, "paused");
+      console.log(`[sisyphus] Session ${sessionId} paused: tmux window no longer exists`);
+    }
+    return true;
+  }
+  initSessionMeta(currentTmuxId, cwd, sessionId);
+  registerSessionTmux(sessionId, session.tmuxSessionName, windowId, currentTmuxId);
+  setWindowId(sessionId, windowId);
+  trackSession(sessionId, cwd, currentTmuxId, session.tmuxSessionName);
+  updateTrackedWindow(sessionId, windowId);
+  initTimers(sessionId, session);
+  const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+  const lastIncompleteCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt && c.paneId);
+  if (lastIncompleteCycle?.paneId) {
+    setOrchestratorPaneId(sessionId, lastIncompleteCycle.paneId);
+    if (livePaneIds.has(lastIncompleteCycle.paneId)) {
+      registerPane(lastIncompleteCycle.paneId, sessionId, "orchestrator");
+    }
+  }
+  for (const agent of session.agents) {
+    if (agent.status === "running" && agent.paneId && livePaneIds.has(agent.paneId)) {
+      registerPane(agent.paneId, sessionId, "agent", agent.id);
+    }
+  }
+  console.log(`[sisyphus] Reconnected session ${sessionId} to tmux window ${session.tmuxWindowId}`);
+  if (session.status === "active" && session.agents.length > 0) {
+    const hasRunningAgents = session.agents.some((a) => a.status === "running");
+    if (!hasRunningAgents) {
+      const orchestratorPaneId = getOrchestratorPaneId(sessionId);
+      const orchestratorAlive = orchestratorPaneId && livePaneIds.has(orchestratorPaneId);
+      if (!orchestratorAlive) {
+        await orphanOrchestrator(cwd, sessionId, "orchestrator lost while daemon was down", "daemon-startup-stuck");
+        await completeOrchestratorCycle(cwd, sessionId);
+        console.log(`[sisyphus] Detected stuck session ${sessionId} on recovery: triggering orchestrator respawn`);
+        await onAllAgentsDone2(sessionId, cwd, session.tmuxWindowId);
+      }
+    }
+  }
+  return true;
+}
 async function recoverSessions() {
   const registry = loadSessionRegistry();
   const entries = Object.entries(registry);
@@ -11401,104 +11973,14 @@ async function recoverSessions() {
     console.log("[sisyphus] No sessions to recover");
     return;
   }
-  let recovered = 0;
-  for (const [sessionId, cwd] of entries) {
-    const stateFile = statePath(cwd, sessionId);
-    if (!existsSync31(stateFile)) {
-      continue;
-    }
-    try {
-      const session = JSON.parse(readFileSync28(stateFile, "utf-8"));
-      if (session.status === "active" || session.status === "paused") {
-        registerSessionCwd(sessionId, cwd);
-        resetAgentCounterFromState(sessionId, session.agents ?? []);
-        if (session.tmuxSessionName) {
-          let sessionAlive = false;
-          let currentTmuxId = session.tmuxSessionId;
-          if (currentTmuxId) {
-            sessionAlive = sessionExistsById(currentTmuxId);
-            if (!sessionAlive) {
-              currentTmuxId = void 0;
-            }
-          }
-          if (!sessionAlive && session.tmuxSessionName) {
-            if (sessionNameTaken(session.tmuxSessionName)) {
-              currentTmuxId = resolveSessionId(session.tmuxSessionName) ?? void 0;
-              sessionAlive = !!currentTmuxId;
-              if (currentTmuxId) {
-                await updateSessionTmux(cwd, sessionId, session.tmuxSessionName, session.tmuxWindowId ?? "", currentTmuxId);
-              }
-            }
-          }
-          if (!sessionAlive) {
-            if (session.status === "active") {
-              await updateSessionStatus(cwd, sessionId, "paused");
-              await updateSession(cwd, sessionId, { tmuxSessionId: void 0 });
-              console.log(`[sisyphus] Session ${sessionId} paused: tmux session no longer exists`);
-            }
-            recovered++;
-            continue;
-          }
-          let windowId = session.tmuxWindowId;
-          if (!windowId) {
-            windowId = getFirstWindowId(currentTmuxId) ?? getFirstWindowId(session.tmuxSessionName) ?? void 0;
-            if (windowId) {
-              await updateSessionTmux(cwd, sessionId, session.tmuxSessionName, windowId, currentTmuxId);
-              console.log(`[sisyphus] Discovered missing windowId ${windowId} for session ${sessionId}`);
-            }
-          }
-          const livePanes = windowId ? listPanes(windowId) : [];
-          if (livePanes.length > 0) {
-            initSessionMeta(currentTmuxId, cwd, sessionId);
-            registerSessionTmux(sessionId, session.tmuxSessionName, windowId, currentTmuxId);
-            setWindowId(sessionId, windowId);
-            trackSession(sessionId, cwd, currentTmuxId, session.tmuxSessionName);
-            updateTrackedWindow(sessionId, windowId);
-            initTimers(sessionId, session);
-            const lastIncompleteCycle = [...session.orchestratorCycles].reverse().find((c) => !c.completedAt && c.paneId);
-            if (lastIncompleteCycle?.paneId) {
-              setOrchestratorPaneId(sessionId, lastIncompleteCycle.paneId);
-              const livePaneIds = new Set(livePanes.map((p) => p.paneId));
-              if (livePaneIds.has(lastIncompleteCycle.paneId)) {
-                registerPane(lastIncompleteCycle.paneId, sessionId, "orchestrator");
-              }
-            }
-            for (const agent of session.agents) {
-              if (agent.status === "running" && agent.paneId) {
-                const livePaneIds = new Set(livePanes.map((p) => p.paneId));
-                if (livePaneIds.has(agent.paneId)) {
-                  registerPane(agent.paneId, sessionId, "agent", agent.id);
-                }
-              }
-            }
-            console.log(`[sisyphus] Reconnected session ${sessionId} to tmux window ${session.tmuxWindowId}`);
-            if (session.status === "active" && session.agents.length > 0) {
-              const hasRunningAgents = session.agents.some((a) => a.status === "running");
-              if (!hasRunningAgents) {
-                const livePaneIds = new Set(livePanes.map((p) => p.paneId));
-                const orchestratorPaneId = getOrchestratorPaneId(sessionId);
-                const orchestratorAlive = orchestratorPaneId && livePaneIds.has(orchestratorPaneId);
-                if (!orchestratorAlive) {
-                  await orphanOrchestrator(cwd, sessionId, "orchestrator lost while daemon was down", "daemon-startup-stuck");
-                  await completeOrchestratorCycle(cwd, sessionId);
-                  console.log(`[sisyphus] Detected stuck session ${sessionId} on recovery: triggering orchestrator respawn`);
-                  await onAllAgentsDone2(sessionId, cwd, session.tmuxWindowId);
-                }
-              }
-            }
-          } else {
-            if (session.status === "active") {
-              await updateSessionStatus(cwd, sessionId, "paused");
-              console.log(`[sisyphus] Session ${sessionId} paused: tmux window no longer exists`);
-            }
-          }
-        }
-        recovered++;
-      }
-    } catch {
-      console.error(`[sisyphus] Failed to read session state for ${sessionId}, skipping`);
-    }
-  }
+  const allTmuxSessions = listAllSessions();
+  const tmuxIdSet = new Set(allTmuxSessions.map((s) => s.sessionId));
+  const tmuxNameToId = new Map(allTmuxSessions.map((s) => [s.name, s.sessionId]));
+  const panesByWindow = listAllPanesByWindow();
+  const results = await Promise.all(
+    entries.map(([sessionId, cwd]) => recoverOneSession(sessionId, cwd, tmuxIdSet, tmuxNameToId, panesByWindow))
+  );
+  const recovered = results.filter(Boolean).length;
   console.log(`[sisyphus] Recovered ${recovered} session(s) from registry`);
 }
 async function startDaemon() {
@@ -11507,9 +11989,6 @@ async function startDaemon() {
   startLogRotator();
   installPlugin();
   const config = loadConfig(process.cwd());
-  if (config.autoUpdate !== false) {
-    await checkAndApply();
-  }
   acquirePidLock();
   const statusBarConfig = { ...DEFAULT_STATUS_BAR_CONFIG };
   statusBarConfig.colors = { ...DEFAULT_STATUS_BAR_CONFIG.colors, ...config.statusBar?.colors };
@@ -11527,36 +12006,45 @@ async function startDaemon() {
     compositor2.register(createWindowsSegment());
     compositor2.register(createSessionNameSegment());
     setCompositor(compositor2);
-    setDotsCallback(() => {
-      recomputeDots();
+    let tickCounter = 0;
+    const renderEvery = Math.max(1, config.statusBarRenderTicks ?? 4);
+    setDotsCallback((panesByWindow) => {
       try {
         writeManifest();
       } catch {
       }
+      tickCounter += 1;
+      if (tickCounter % renderEvery !== 0) return;
+      recomputeDots(panesByWindow);
       try {
-        compositor2.render();
+        compositor2.render(panesByWindow);
       } catch {
       }
     });
   } else {
-    setDotsCallback(() => {
-      recomputeDots();
+    let tickCounter = 0;
+    const renderEvery = Math.max(1, config.statusBarRenderTicks ?? 4);
+    setDotsCallback((panesByWindow) => {
       try {
         writeManifest();
       } catch {
       }
+      tickCounter += 1;
+      if (tickCounter % renderEvery !== 0) return;
+      recomputeDots(panesByWindow);
     });
   }
   setRespawnCallback(onAllAgentsDone2);
   setTrackedEntriesProvider(getTrackedSessionEntries);
   await startServer();
   startMonitor(config.pollIntervalMs);
-  await recoverSessions();
-  await sweepOrphans();
-  startHeartbeatScanner();
   if (config.autoUpdate !== false) {
+    void checkAndApply();
     startPeriodicUpdateCheck();
   }
+  await recoverSessions();
+  await sweepOrphans();
+  startHeartbeatScanner();
   const shutdown = async () => {
     console.log("[sisyphus] Shutting down...");
     stopLogRotator();
@@ -11581,50 +12069,110 @@ async function startDaemon() {
   process.on("SIGINT", shutdown);
 }
 process.title = "sisyphusd";
-var command = process.argv[2];
-(async () => {
-  switch (command) {
-    case "stop":
-      stopDaemon();
-      break;
-    case "restart": {
-      stopDaemon();
-      if (isLaunchdManaged()) {
-        for (let i = 0; i < 6; i++) {
-          await sleep(500);
-          const respawnedPid = readPid();
-          if (respawnedPid) {
-            console.log(`[sisyphus] Daemon restarted (pid ${respawnedPid}) by process manager`);
-            process.exit(0);
-          }
-        }
-        console.log("[sisyphus] Daemon will be restarted by process manager");
+var isHelpInvocation = process.argv.includes("--help") || process.argv[2] === "help";
+if (!isHelpInvocation) {
+  const ts = () => (/* @__PURE__ */ new Date()).toISOString();
+  const origLog = console.log.bind(console);
+  const origError = console.error.bind(console);
+  console.log = (...args) => origLog(`[${ts()}]`, ...args);
+  console.error = (...args) => origError(`[${ts()}]`, ...args);
+}
+var rootHelpText = `sisyphusd: long-lived orchestration daemon for sis sessions.
+
+Subtrees
+  start    boot the daemon and recover sessions     | use when no daemon is running for this user
+  stop     terminate the running daemon             | use to free the IPC socket or before an upgrade
+  restart  stop, then start                          | use after a binary upgrade or config change
+
+Globals
+  --help   print this message
+
+I/O contract: subprocess control (no JSON; this is a process-lifecycle tool, not an agent surface).
+Exit 0 on success, non-zero on failure. Diagnostic output streams to stderr; structured payloads are absent \u2014 for session/agent state, use \`sis session inspect status\` and friends.
+`;
+var program = new Command().name("sisyphusd").description("Long-lived orchestration daemon for sis sessions.").helpOption("--help", "print this message").allowExcessArguments(false).showSuggestionAfterError(false).exitOverride((err) => {
+  if (err.code === "commander.unknownCommand" || err.code === "commander.unknownOption" || err.code === "commander.excessArguments") {
+    const offender = process.argv[2];
+    if (offender) {
+      process.stderr.write(`error: unknown command '${offender}'
+`);
+    }
+    process.exit(2);
+  }
+  if (err.code === "commander.helpDisplayed" || err.code === "commander.help") {
+    process.exit(0);
+  }
+  process.exit(err.exitCode ?? 1);
+}).action(async () => {
+  await startDaemon();
+});
+program.helpInformation = () => rootHelpText;
+program.command("help").description("Print sisyphusd help").helpOption("--help", "print this message").action(() => {
+  process.stdout.write(rootHelpText);
+  process.exit(0);
+});
+program.command("start").description("Boot the daemon and recover sessions").helpOption("--help", "display help for command").addHelpText("after", `
+start: launch the sisyphus daemon process.
+
+Input
+  None.
+
+Output (subprocess control; diagnostic text to stderr; no JSON \u2014 daemon-control carve-out)
+  Progress messages stream to stderr. Blocks until the daemon event loop is running and sessions are recovered.
+
+Effects
+  Acquires the IPC socket. Writes pid file. Recovers active sessions from registry. Starts pane monitor and heartbeat scanner.
+
+Exit codes: 0 ok | non-zero on failure (diagnostic on stderr).
+`).action(async () => {
+  await startDaemon();
+});
+program.command("stop").description("Terminate the running daemon").helpOption("--help", "display help for command").addHelpText("after", `
+stop: terminate the running daemon process.
+
+Input
+  None.
+
+Output (subprocess control; diagnostic text to stderr; no JSON \u2014 daemon-control carve-out)
+  Reports daemon pid and stop status to stderr. Waits up to 5s for graceful SIGTERM; falls back to SIGKILL.
+
+Effects
+  Sends SIGTERM (then SIGKILL if needed). Removes pid file. Releases IPC socket.
+
+Exit codes: 0 ok | non-zero on failure (diagnostic on stderr).
+`).action(() => {
+  stopDaemon();
+});
+program.command("restart").description("Stop, then start the daemon").helpOption("--help", "display help for command").addHelpText("after", `
+restart: stop the running daemon, then start a fresh one.
+
+Input
+  None.
+
+Output (subprocess control; diagnostic text to stderr; no JSON \u2014 daemon-control carve-out)
+  Reports stop and start progress to stderr. When launchd manages the daemon, exits after confirming respawn.
+
+Effects
+  Stops the running daemon (SIGTERM/SIGKILL). If launchd-managed, exits and lets launchd respawn via KeepAlive. Otherwise starts the daemon in-process.
+
+Exit codes: 0 ok | non-zero on failure (diagnostic on stderr).
+`).action(async () => {
+  stopDaemon();
+  if (isLaunchdManaged()) {
+    for (let i = 0; i < 6; i++) {
+      await sleep(500);
+      const respawnedPid = readPid();
+      if (respawnedPid) {
+        console.log(`[sisyphus] Daemon restarted (pid ${respawnedPid}) by process manager`);
         process.exit(0);
       }
-      await startDaemon();
-      break;
-    }
-    case "start":
-    case void 0:
-      await startDaemon();
-      break;
-    case "help":
-    case "--help":
-    case "-h":
-      console.log("Usage: sisyphusd [command]");
-      console.log("");
-      console.log("Commands:");
-      console.log("  start     Start the daemon (default if no command given)");
-      console.log("  stop      Stop the running daemon");
-      console.log("  restart   Stop and restart the daemon");
-      console.log("  help      Show this help message");
-      break;
-    default:
-      console.error(`[sisyphus] Unknown command: ${command}`);
-      console.error("Usage: sisyphusd [start|stop|restart|help]");
-      process.exit(1);
+    }
+    console.log("[sisyphus] Daemon will be restarted by process manager");
+    process.exit(0);
   }
-})().catch((err) => {
+  await startDaemon();
+});
+program.parseAsync(process.argv).catch((err) => {
   console.error("[sisyphus] Fatal error:", err);
   process.exit(1);
 });