sisyphi 1.1.32 → 1.1.33

package/dist/daemon.js

@@ -51,9 +51,12 @@ __export(paths_exports, {
   legacyLogsPath: () => legacyLogsPath,
   logsDir: () => logsDir,
   messagesDir: () => messagesDir,
+  projectAgentPluginDir: () => projectAgentPluginDir,
   projectConfigPath: () => projectConfigPath,
   projectDir: () => projectDir,
+  projectOrchestratorPluginDir: () => projectOrchestratorPluginDir,
   projectOrchestratorPromptPath: () => projectOrchestratorPromptPath,
+  projectOrchestratorSettingsPath: () => projectOrchestratorSettingsPath,
   promptsDir: () => promptsDir,
   reportFilePath: () => reportFilePath,
   reportsDir: () => reportsDir,
@@ -69,7 +72,11 @@ __export(paths_exports, {
   strategyPath: () => strategyPath,
   tmuxSessionDisplayName: () => tmuxSessionDisplayName,
   tmuxSessionName: () => tmuxSessionName,
-  tuiScratchDir: () => tuiScratchDir
+  tuiScratchDir: () => tuiScratchDir,
+  userAgentPluginDir: () => userAgentPluginDir,
+  userOrchestratorPluginDir: () => userOrchestratorPluginDir,
+  userOrchestratorPromptPath: () => userOrchestratorPromptPath,
+  userOrchestratorSettingsPath: () => userOrchestratorSettingsPath
 });
 import { homedir } from "os";
 import { basename, join } from "path";
@@ -100,6 +107,27 @@ function projectConfigPath(cwd) {
 function projectOrchestratorPromptPath(cwd) {
   return join(projectDir(cwd), "orchestrator.md");
 }
+function userOrchestratorPromptPath() {
+  return join(globalDir(), "orchestrator.md");
+}
+function projectOrchestratorSettingsPath(cwd) {
+  return join(projectDir(cwd), "orchestrator-settings.json");
+}
+function userOrchestratorSettingsPath() {
+  return join(globalDir(), "orchestrator-settings.json");
+}
+function projectAgentPluginDir(cwd) {
+  return join(projectDir(cwd), "agent-plugin");
+}
+function userAgentPluginDir() {
+  return join(globalDir(), "agent-plugin");
+}
+function projectOrchestratorPluginDir(cwd) {
+  return join(projectDir(cwd), "orchestrator-plugin");
+}
+function userOrchestratorPluginDir() {
+  return join(globalDir(), "orchestrator-plugin");
+}
 function sessionsDir(cwd) {
   return join(projectDir(cwd), "sessions");
 }
@@ -255,7 +283,7 @@ var init_paths = __esm({
 
 // src/daemon/index.ts
 init_paths();
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync23, writeFileSync as writeFileSync16, unlinkSync as unlinkSync5, existsSync as existsSync23 } from "fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync24, writeFileSync as writeFileSync17, unlinkSync as unlinkSync5, existsSync as existsSync24 } from "fs";
 import { execSync as execSync7 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 
@@ -317,8 +345,8 @@ function loadConfig(cwd) {
 // src/daemon/server.ts
 init_paths();
 import { createServer } from "net";
-import { unlinkSync as unlinkSync3, existsSync as existsSync19, writeFileSync as writeFileSync14, readFileSync as readFileSync20, mkdirSync as mkdirSync10, readdirSync as readdirSync11, rmSync as rmSync7, chmodSync } from "fs";
-import { join as join18 } from "path";
+import { unlinkSync as unlinkSync3, existsSync as existsSync20, writeFileSync as writeFileSync15, readFileSync as readFileSync21, mkdirSync as mkdirSync11, readdirSync as readdirSync12, rmSync as rmSync8, chmodSync } from "fs";
+import { join as join19 } from "path";
 
 // src/shared/shell.ts
 function shellQuote(s) {
@@ -337,7 +365,7 @@ function escapeAppleScript(s) {
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync17, readFileSync as readFileSync18, readdirSync as readdirSync10, rmSync as rmSync5 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync19, readdirSync as readdirSync11, rmSync as rmSync6 } from "fs";
 
 // src/daemon/state.ts
 import { copyFileSync, cpSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, readdirSync, rmSync, statSync, writeFileSync as writeFileSync3 } from "fs";
@@ -356,16 +384,16 @@ function atomicWrite(filePath, data) {
 var locks = /* @__PURE__ */ new Map();
 async function withLock(key, fn) {
   const prev = locks.get(key) ?? Promise.resolve();
-  let resolve11;
+  let resolve12;
   const next = new Promise((r) => {
-    resolve11 = r;
+    resolve12 = r;
   });
   locks.set(key, next);
   await prev;
   try {
     return fn();
   } finally {
-    resolve11();
+    resolve12();
     if (locks.get(key) === next) {
       locks.delete(key);
     }
@@ -468,6 +496,13 @@ function getSession(cwd, sessionId) {
 function saveSession(session) {
   atomicWrite(statePath(session.cwd, session.id), JSON.stringify(session, null, 2));
 }
+function isSessionDangerous(cwd, sessionId) {
+  try {
+    return getSession(cwd, sessionId).dangerousMode === true;
+  } catch {
+    return false;
+  }
+}
 async function addAgent(cwd, sessionId, agent) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -836,10 +871,10 @@ async function createCloneState(sourceCwd, sourceId, cloneId, goal, context, con
 }
 
 // src/daemon/orchestrator.ts
-import { existsSync as existsSync15, readdirSync as readdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync13 } from "fs";
 import { execSync as execSync5 } from "child_process";
 import { randomUUID as randomUUID6 } from "crypto";
-import { resolve as resolve6, join as join15, relative as relative2 } from "path";
+import { resolve as resolve7, join as join16, relative as relative3 } from "path";
 
 // src/daemon/spawn-helpers.ts
 import { writeFileSync as writeFileSync4, existsSync as existsSync3 } from "fs";
@@ -951,6 +986,7 @@ function resetColors(sessionId) {
 }
 
 // src/daemon/frontmatter.ts
+init_paths();
 import { readFileSync as readFileSync4, existsSync as existsSync4, readdirSync as readdirSync2 } from "fs";
 import { homedir as homedir2 } from "os";
 import { join as join5, basename as basename2 } from "path";
@@ -1025,6 +1061,8 @@ function resolveAgentTypePath(agentType, pluginDir, cwd) {
       searchPaths.push(join5(installPath, "agents", `${name}.md`));
     }
   } else {
+    searchPaths.push(join5(projectAgentPluginDir(cwd), "agents", `${name}.md`));
+    searchPaths.push(join5(userAgentPluginDir(), "agents", `${name}.md`));
     searchPaths.push(join5(cwd, ".claude", "agents", `${name}.md`));
     searchPaths.push(join5(homedir2(), ".claude", "agents", `${name}.md`));
     searchPaths.push(join5(pluginDir, "agents", `${name}.md`));
@@ -1059,6 +1097,8 @@ function discoverAgentTypes(pluginDir, cwd) {
       }
     }
   }
+  scanDir(join5(projectAgentPluginDir(cwd), "agents"), null, "project-sis");
+  scanDir(join5(userAgentPluginDir(), "agents"), null, "user-sis");
   scanDir(join5(cwd, ".claude", "agents"), null, "project");
   scanDir(join5(homedir2(), ".claude", "agents"), null, "user");
   scanDir(join5(pluginDir, "agents"), "sisyphus", "bundled");
@@ -1098,6 +1138,8 @@ function resolveAgentConfig(agentType, pluginDir, cwd) {
 // src/daemon/orchestrator-modes.ts
 import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync5 } from "fs";
 import { resolve as resolve3, join as join6 } from "path";
+init_paths();
+import { homedir as homedir3 } from "os";
 function resolveTemplatesDir() {
   const distLayout = resolve3(import.meta.dirname, "../templates");
   if (existsSync5(distLayout)) return distLayout;
@@ -1105,18 +1147,46 @@ function resolveTemplatesDir() {
   if (existsSync5(srcLayout)) return srcLayout;
   return void 0;
 }
-function discoverOrchestratorModes() {
-  const templatesDir = resolveTemplatesDir();
-  if (!templatesDir) return [];
-  const files = readdirSync3(templatesDir).filter(
-    (f) => f.startsWith("orchestrator-") && f.endsWith(".md") && f !== "orchestrator-base.md"
-  );
-  return files.map((file) => {
-    const content = readFileSync5(join6(templatesDir, file), "utf-8");
-    const fm = parseAgentFrontmatter(content);
-    const name = fm.name ?? file.replace(/^orchestrator-/, "").replace(/\.md$/, "");
-    return { name, description: fm.description, filePath: join6(templatesDir, file) };
-  });
+function modeLayers(cwd) {
+  const layers = [];
+  const project = projectDir(cwd);
+  if (existsSync5(project)) layers.push({ source: "project", dir: project });
+  const user = join6(homedir3(), ".sisyphus");
+  if (existsSync5(user)) layers.push({ source: "user", dir: user });
+  const bundled = resolveTemplatesDir();
+  if (bundled) layers.push({ source: "bundled", dir: bundled });
+  return layers;
+}
+function discoverOrchestratorModes(cwd) {
+  const layers = cwd ? modeLayers(cwd) : modeLayers(process.cwd());
+  const seen = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    let files;
+    try {
+      files = readdirSync3(layer.dir);
+    } catch {
+      continue;
+    }
+    const modeFiles = files.filter(
+      (f) => f.startsWith("orchestrator-") && f.endsWith(".md") && f !== "orchestrator-base.md"
+    );
+    for (const file of modeFiles) {
+      const filePath = join6(layer.dir, file);
+      let content = "";
+      try {
+        content = readFileSync5(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const fm = parseAgentFrontmatter(content);
+      const name = fm.name ?? file.replace(/^orchestrator-/, "").replace(/\.md$/, "");
+      if (seen.has(name)) continue;
+      const entry = { name, filePath, source: layer.source };
+      if (fm.description !== void 0) entry.description = fm.description;
+      seen.set(name, entry);
+    }
+  }
+  return Array.from(seen.values());
 }
 
 // src/daemon/lib/effort-render.ts
@@ -1181,6 +1251,249 @@ function walk(src, dest, tier) {
   }
 }
 
+// src/daemon/extensions.ts
+init_paths();
+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 { 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;
+  const src = resolve4(import.meta.dirname, "../../templates", kind);
+  if (existsSync7(src)) return src;
+  return void 0;
+}
+function agentPluginLayers(cwd) {
+  const layers = [];
+  const project = projectAgentPluginDir(cwd);
+  if (existsSync7(project)) layers.push({ source: "project", root: project });
+  const user = userAgentPluginDir();
+  if (existsSync7(user)) layers.push({ source: "user", root: user });
+  const bundled = resolveBundledTemplateDir("agent-plugin");
+  if (bundled) layers.push({ source: "bundled", root: bundled });
+  return layers;
+}
+function orchestratorPluginLayers(cwd) {
+  const layers = [];
+  const project = projectOrchestratorPluginDir(cwd);
+  if (existsSync7(project)) layers.push({ source: "project", root: project });
+  const user = userOrchestratorPluginDir();
+  if (existsSync7(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;
+  try {
+    const raw = readFileSync7(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch (err) {
+    console.warn(`[sisyphus] Failed to parse hooks manifest at ${path}: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}
+function commandScriptName(command2) {
+  const match = command2.match(/([\w.-]+\.[\w]+)\s*$/);
+  return match ? match[1] : null;
+}
+function groupApplies(group, ctx) {
+  const types = group.agentTypes ?? ["all"];
+  const matchesType = types.includes("all") || types.includes(ctx.agentType);
+  if (!matchesType) return false;
+  if (group.condition === "non-interactive" && ctx.interactive) return false;
+  return true;
+}
+function mergeHookManifests(layers, ctx) {
+  const disabled = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const manifest = readManifest(layer.root);
+    if (!manifest?.disable) continue;
+    for (const name of manifest.disable) disabled.add(name);
+  }
+  const merged = {};
+  for (const layer of layers) {
+    const manifest = readManifest(layer.root);
+    if (!manifest?.hooks) continue;
+    for (const [event, groups] of Object.entries(manifest.hooks)) {
+      if (!Array.isArray(groups)) continue;
+      for (const group of groups) {
+        if (!groupApplies(group, ctx)) continue;
+        const filteredHooks = group.hooks.filter((h) => {
+          const script = commandScriptName(h.command);
+          return !script || !disabled.has(script);
+        });
+        if (filteredHooks.length === 0) continue;
+        const cleaned = {
+          ...group.matcher !== void 0 && { matcher: group.matcher },
+          hooks: filteredHooks
+        };
+        if (!merged[event]) merged[event] = [];
+        merged[event].push(cleaned);
+      }
+    }
+  }
+  return merged;
+}
+var defaultFilter = (name) => name !== "CLAUDE.md" && name !== "hooks.json";
+function copyLayered(layers, opts) {
+  mkdirSync3(opts.destDir, { recursive: true });
+  const filter = opts.filter ?? defaultFilter;
+  const written = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const layerSubdir = join8(layer.root, opts.subdir);
+    if (!existsSync7(layerSubdir)) continue;
+    let entries;
+    try {
+      entries = readdirSync5(layerSubdir);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (!filter(name)) continue;
+      if (opts.skipFiles?.has(name)) continue;
+      if (written.has(name)) continue;
+      const src = join8(layerSubdir, name);
+      const dest = join8(opts.destDir, name);
+      const stat = statSync2(src);
+      if (stat.isDirectory()) {
+        if (!opts.recurse) continue;
+        copyDirRecursive(src, dest);
+      } else if (stat.isFile()) {
+        copyFileSync3(src, dest);
+      }
+      written.add(name);
+    }
+  }
+}
+function copyDirRecursive(src, dest) {
+  mkdirSync3(dest, { recursive: true });
+  for (const name of readdirSync5(src)) {
+    const s = join8(src, name);
+    const d = join8(dest, name);
+    const stat = statSync2(s);
+    if (stat.isDirectory()) {
+      copyDirRecursive(s, d);
+    } else if (stat.isFile()) {
+      copyFileSync3(s, d);
+    }
+  }
+}
+function collectReferencedHookScripts(layers, ctx) {
+  const scripts = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const manifest = readManifest(layer.root);
+    if (!manifest?.hooks) continue;
+    for (const groups of Object.values(manifest.hooks)) {
+      if (!Array.isArray(groups)) continue;
+      for (const group of groups) {
+        if (!groupApplies(group, ctx)) continue;
+        for (const h of group.hooks) {
+          const name = commandScriptName(h.command);
+          if (name) scripts.add(name);
+        }
+      }
+    }
+  }
+  return scripts;
+}
+function collectDisabledHookScripts(layers) {
+  const disabled = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    const manifest = readManifest(layer.root);
+    if (!manifest?.disable) continue;
+    for (const name of manifest.disable) disabled.add(name);
+  }
+  return disabled;
+}
+function indexAvailableSkills(layers) {
+  const index = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    const skillsRoot = join8(layer.root, "skills");
+    if (!existsSync7(skillsRoot)) continue;
+    let entries;
+    try {
+      entries = readdirSync5(skillsRoot);
+    } catch {
+      continue;
+    }
+    for (const name of entries) {
+      if (index.has(name)) continue;
+      const path = join8(skillsRoot, name);
+      try {
+        if (statSync2(path).isDirectory()) index.set(name, path);
+      } catch {
+      }
+    }
+  }
+  return index;
+}
+function copySkill(layers, skillName, destSkillsDir) {
+  const index = indexAvailableSkills(layers);
+  const src = index.get(skillName);
+  if (!src) return false;
+  copyDirRecursive(src, join8(destSkillsDir, skillName));
+  return true;
+}
+var FILTERED_RENDER_EXTS = /* @__PURE__ */ new Set([".md"]);
+function isRenderable(name) {
+  for (const ext of FILTERED_RENDER_EXTS) {
+    if (name.endsWith(ext)) return true;
+  }
+  return false;
+}
+function collectOverlay(layers) {
+  const overlay = /* @__PURE__ */ new Map();
+  for (const layer of layers) {
+    if (!existsSync7(layer.root)) continue;
+    walkRelative(layer.root, "", (relPath, absPath) => {
+      if (overlay.has(relPath)) return;
+      overlay.set(relPath, { src: absPath, source: layer.source });
+    });
+  }
+  return overlay;
+}
+function walkRelative(root, prefix, visit) {
+  const dir = prefix ? join8(root, prefix) : root;
+  let entries;
+  try {
+    entries = readdirSync5(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const childPrefix = prefix ? join8(prefix, name) : name;
+    const abs = join8(dir, name);
+    let stat;
+    try {
+      stat = statSync2(abs);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      walkRelative(root, childPrefix, visit);
+    } else if (stat.isFile()) {
+      visit(childPrefix, abs);
+    }
+  }
+}
+function renderLayeredPluginDir(layers, destDir, tier) {
+  rmSync3(destDir, { recursive: true, force: true });
+  mkdirSync3(destDir, { recursive: true });
+  const overlay = collectOverlay(layers);
+  for (const [relPath, entry] of overlay) {
+    const destPath = join8(destDir, relPath);
+    mkdirSync3(join8(destPath, ".."), { recursive: true });
+    if (isRenderable(basename3(relPath))) {
+      const rendered = renderEffortMarkers(readFileSync7(entry.src, "utf-8"), tier);
+      writeFileSync6(destPath, rendered, "utf-8");
+    } else {
+      copyFileSync3(entry.src, destPath);
+    }
+  }
+}
+
 // src/daemon/tmux.ts
 import { execSync as execSync2 } from "child_process";
 var t = (target) => shellQuote(target);
@@ -1443,10 +1756,10 @@ function getSessionPanes(sessionId) {
 }
 
 // src/daemon/agent.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, copyFileSync as copyFileSync3, mkdirSync as mkdirSync6, readdirSync as readdirSync7, existsSync as existsSync10, unlinkSync } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, readdirSync as readdirSync8, existsSync as existsSync11, unlinkSync } from "fs";
 import { execSync as execSync4 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
-import { resolve as resolve4, relative, dirname as dirname3, join as join11 } from "path";
+import { resolve as resolve5, relative as relative2, dirname as dirname3, join as join12 } from "path";
 init_paths();
 
 // src/daemon/haiku.ts
@@ -1602,17 +1915,17 @@ ${reportText.slice(0, 3e3)}`
 }
 
 // src/daemon/plugins.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { execFileSync } from "child_process";
-import { homedir as homedir3 } from "os";
-import { join as join8 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join9 } from "path";
 function installedPluginsPath() {
-  return join8(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  return join9(homedir4(), ".claude", "plugins", "installed_plugins.json");
 }
 function resolveInstalledPlugin(name) {
   let data;
   try {
-    data = JSON.parse(readFileSync7(installedPluginsPath(), "utf-8"));
+    data = JSON.parse(readFileSync8(installedPluginsPath(), "utf-8"));
   } catch {
     return null;
   }
@@ -1670,13 +1983,13 @@ function resolveAgentPluginDirs(plugins) {
 
 // src/daemon/history.ts
 init_paths();
-import { appendFileSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync6, renameSync as renameSync2, readdirSync as readdirSync5, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync2 } from "fs";
+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 { randomUUID as randomUUID2 } from "crypto";
-import { dirname as dirname2, join as join9 } from "path";
+import { dirname as dirname2, join as join10 } from "path";
 var knownDirs = /* @__PURE__ */ new Set();
 function ensureDir(sessionId) {
   if (knownDirs.has(sessionId)) return;
-  mkdirSync3(historySessionDir(sessionId), { recursive: true });
+  mkdirSync4(historySessionDir(sessionId), { recursive: true });
   knownDirs.add(sessionId);
 }
 function emitHistoryEvent(sessionId, event, data) {
@@ -1744,8 +2057,8 @@ function writeSessionSummary(session, extra) {
       sentiment: extra?.sentiment ?? null
     };
     const filePath = historySessionSummaryPath(session.id);
-    const tmp = join9(dirname2(filePath), `.session-${randomUUID2()}.tmp`);
-    writeFileSync6(tmp, JSON.stringify(summary, null, 2), "utf-8");
+    const tmp = join10(dirname2(filePath), `.session-${randomUUID2()}.tmp`);
+    writeFileSync7(tmp, JSON.stringify(summary, null, 2), "utf-8");
     renameSync2(tmp, filePath);
   } catch (err) {
     console.error(`[history] Failed to write session summary for ${session.id}:`, err);
@@ -1756,14 +2069,14 @@ function getRecentSentiments(count = 5, scanLimit = 30, overrideBaseDir) {
     const base = overrideBaseDir ?? historyBaseDir();
     let entries;
     try {
-      entries = readdirSync5(base);
+      entries = readdirSync6(base);
     } catch {
       return [];
     }
     const withMtime = [];
     for (const name of entries) {
       try {
-        const st = statSync2(join9(base, name));
+        const st = statSync3(join10(base, name));
         if (st.isDirectory()) withMtime.push({ name, mtime: st.mtimeMs });
       } catch {
         continue;
@@ -1774,7 +2087,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 = readFileSync8(join9(base, withMtime[i].name, "session.json"), "utf-8");
+        const raw = readFileSync9(join10(base, withMtime[i].name, "session.json"), "utf-8");
         const summary = JSON.parse(raw);
         if (summary.sentiment && summary.completedAt) {
           results.push({
@@ -1799,27 +2112,27 @@ function pruneHistory() {
     const base = historyBaseDir();
     let entries;
     try {
-      entries = readdirSync5(base);
+      entries = readdirSync6(base);
     } catch {
       return;
     }
     const sessions = [];
     for (const name of entries) {
-      const dir = join9(base, name);
+      const dir = join10(base, name);
       try {
-        const summaryPath = join9(dir, "session.json");
-        const raw = readFileSync8(summaryPath, "utf-8");
+        const summaryPath = join10(dir, "session.json");
+        const raw = readFileSync9(summaryPath, "utf-8");
         const summary = JSON.parse(raw);
         sessions.push({ dir, startedAt: new Date(summary.startedAt ?? 0).getTime() });
       } catch {
         try {
-          const eventsPath = join9(dir, "events.jsonl");
-          const firstLine = readFileSync8(eventsPath, "utf-8").split("\n")[0];
+          const eventsPath = join10(dir, "events.jsonl");
+          const firstLine = readFileSync9(eventsPath, "utf-8").split("\n")[0];
           const firstEvent = JSON.parse(firstLine);
           sessions.push({ dir, startedAt: new Date(firstEvent.ts ?? 0).getTime() });
         } catch {
           try {
-            const st = statSync2(dir);
+            const st = statSync3(dir);
             sessions.push({ dir, startedAt: st.mtimeMs });
           } catch {
             continue;
@@ -1832,7 +2145,7 @@ function pruneHistory() {
     const cutoff = Date.now() - PRUNE_KEEP_DAYS * 24 * 60 * 60 * 1e3;
     for (let i = PRUNE_KEEP_COUNT; i < sessions.length; i++) {
       if (sessions[i].startedAt < cutoff) {
-        rmSync3(sessions[i].dir, { recursive: true, force: true });
+        rmSync4(sessions[i].dir, { recursive: true, force: true });
       }
     }
   } catch {
@@ -1844,13 +2157,13 @@ import { ulid } from "ulid";
 
 // src/daemon/ask-store.ts
 init_paths();
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync9, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync10, readdirSync as readdirSync7 } from "fs";
 
 // src/daemon/notify.ts
 import { spawn, execFile } from "child_process";
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync4, existsSync as existsSync7 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir4 } from "os";
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync8 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir5 } from "os";
 var TMUX_SOCKET = `/tmp/tmux-${process.getuid?.() ?? 0}/default`;
 var SWITCH_SCRIPT = [
   "#!/bin/bash",
@@ -1892,24 +2205,24 @@ var SWITCH_SCRIPT = [
   ""
 ].join("\n");
 function ensureSwitchScript() {
-  const dir = join10(homedir4(), ".sisyphus");
-  const scriptPath = join10(dir, "notify-switch.sh");
+  const dir = join11(homedir5(), ".sisyphus");
+  const scriptPath = join11(dir, "notify-switch.sh");
   try {
-    mkdirSync4(dir, { recursive: true });
-    writeFileSync7(scriptPath, SWITCH_SCRIPT, { mode: 493 });
+    mkdirSync5(dir, { recursive: true });
+    writeFileSync8(scriptPath, SWITCH_SCRIPT, { mode: 493 });
   } catch {
   }
 }
 var notifyProcess = null;
 function getNotifyBinary() {
-  return join10(homedir4(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
+  return join11(homedir5(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
 }
 function ensureNotifyProcess() {
   if (notifyProcess && !notifyProcess.killed && notifyProcess.stdin?.writable) {
     return notifyProcess;
   }
   const binary = getNotifyBinary();
-  if (!existsSync7(binary)) {
+  if (!existsSync8(binary)) {
     return null;
   }
   notifyProcess = spawn(binary, [], {
@@ -1989,7 +2302,7 @@ function maybeNotifyOnAskCreated(cwd, sessionId, meta) {
   }
 }
 function createAsk(cwd, sessionId, params) {
-  mkdirSync5(askVisualsDir(cwd, sessionId, params.askId), { recursive: true });
+  mkdirSync6(askVisualsDir(cwd, sessionId, params.askId), { recursive: true });
   const askedAt = (/* @__PURE__ */ new Date()).toISOString();
   const meta = {
     askId: params.askId,
@@ -2018,11 +2331,12 @@ function createAsk(cwd, sessionId, params) {
 }
 function writeDecisions(cwd, sessionId, askId, deck) {
   atomicWrite(askDecisionsPath(cwd, sessionId, askId), JSON.stringify(deck, null, 2));
+  void maybeAutoResolveAsk(cwd, sessionId, askId, deck);
 }
 function readDecisions(cwd, sessionId, askId) {
   const p = askDecisionsPath(cwd, sessionId, askId);
   try {
-    return JSON.parse(readFileSync9(p, { encoding: "utf-8" }));
+    return JSON.parse(readFileSync10(p, { encoding: "utf-8" }));
   } catch (_e) {
     return null;
   }
@@ -2035,10 +2349,10 @@ function writeOutput(cwd, sessionId, askId, responses, completedAt) {
 }
 function readMeta(cwd, sessionId, askId) {
   const p = askMetaPath(cwd, sessionId, askId);
-  if (!existsSync8(p)) {
+  if (!existsSync9(p)) {
     return null;
   }
-  return JSON.parse(readFileSync9(p, "utf-8"));
+  return JSON.parse(readFileSync10(p, "utf-8"));
 }
 async function updateMeta(cwd, sessionId, askId, patch) {
   return withLock(askId, () => {
@@ -2053,10 +2367,44 @@ async function updateMeta(cwd, sessionId, askId, patch) {
 }
 function listAsks(cwd, sessionId) {
   const dir = askDir(cwd, sessionId);
-  if (!existsSync8(dir)) {
+  if (!existsSync9(dir)) {
     return [];
   }
-  return readdirSync6(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+  return readdirSync7(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+function buildAutoResponses(deck) {
+  const out = [];
+  for (const interaction of deck.interactions) {
+    const first = interaction.options[0];
+    if (!first) continue;
+    out.push({ id: interaction.id, selectedOptionId: first.id });
+  }
+  return out;
+}
+async function autoResolveAsk(cwd, sessionId, askId, deck) {
+  try {
+    if (existsSync9(askOutputPath(cwd, sessionId, askId))) return false;
+    const d = deck ?? readDecisions(cwd, sessionId, askId);
+    if (!d) return false;
+    const responses = buildAutoResponses(d);
+    if (responses.length === 0) return false;
+    writeOutput(cwd, sessionId, askId, responses);
+    await updateMeta(cwd, sessionId, askId, {
+      status: "answered",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return true;
+  } catch (err) {
+    console.warn(`[sisyphus] dangerous-mode auto-resolve failed for ask ${askId}:`, err instanceof Error ? err.message : err);
+    return false;
+  }
+}
+async function maybeAutoResolveAsk(cwd, sessionId, askId, deck) {
+  try {
+    if (!isSessionDangerous(cwd, sessionId)) return;
+    await autoResolveAsk(cwd, sessionId, askId, deck);
+  } catch {
+  }
 }
 function listOpenAsksFor(cwd, sessionId, askedBy) {
   const out = [];
@@ -2067,7 +2415,7 @@ function listOpenAsksFor(cwd, sessionId, askedBy) {
     if (meta.orphaned) continue;
     if (!meta.blocking) continue;
     if (meta.status !== "pending" && meta.status !== "in-progress") continue;
-    if (existsSync8(askOutputPath(cwd, sessionId, askId))) continue;
+    if (existsSync9(askOutputPath(cwd, sessionId, askId))) continue;
     out.push({ askId, status: meta.status, ...meta.title !== void 0 ? { title: meta.title } : {} });
   }
   return out;
@@ -2266,7 +2614,7 @@ async function resolveOrchestratorOrphanAsks(cwd, sessionId, selectedOptionId) {
 }
 
 // src/daemon/orphan-sweep.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { execSync as execSync3 } from "child_process";
 init_paths();
 
@@ -2315,7 +2663,7 @@ async function capturePanePidLstart(paneId) {
 async function sweepOrphans(registry) {
   const reg = registry ?? loadSessionRegistry();
   for (const [sessionId, cwd] of Object.entries(reg)) {
-    if (!existsSync9(statePath(cwd, sessionId))) continue;
+    if (!existsSync10(statePath(cwd, sessionId))) continue;
     try {
       await sweepSessionAgents(cwd, sessionId);
       await sweepSessionAsks(cwd, sessionId);
@@ -2384,10 +2732,10 @@ function substituteSisyphusVars(text, sessionId, agentId, sesDir) {
   return text.replace(/\$SISYPHUS_SESSION_DIR/g, sesDir).replace(/\$SISYPHUS_SESSION_ID/g, sessionId).replace(/\$SISYPHUS_AGENT_ID/g, agentId);
 }
 function renderAgentSuffix(sessionId, instruction, contextDirRel) {
-  const templatePath = resolve4(import.meta.dirname, "../templates/agent-suffix.md");
+  const templatePath = resolve5(import.meta.dirname, "../templates/agent-suffix.md");
   let template;
   try {
-    template = readFileSync10(templatePath, "utf-8");
+    template = readFileSync11(templatePath, "utf-8");
   } catch {
     template = `# Sisyphus Agent
 Session: {{SESSION_ID}}
@@ -2397,10 +2745,11 @@ Task: {{INSTRUCTION}}`;
 }
 function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
   const base = `${promptsDir(cwd, sessionId)}/${agentId}-plugin`;
-  mkdirSync6(`${base}/.claude-plugin`, { recursive: true });
-  mkdirSync6(`${base}/agents`, { recursive: true });
-  mkdirSync6(`${base}/hooks`, { recursive: true });
-  writeFileSync8(
+  mkdirSync7(`${base}/.claude-plugin`, { recursive: true });
+  mkdirSync7(`${base}/agents`, { recursive: true });
+  mkdirSync7(`${base}/hooks`, { recursive: true });
+  mkdirSync7(`${base}/skills`, { recursive: true });
+  writeFileSync9(
     `${base}/.claude-plugin/plugin.json`,
     JSON.stringify({ name: `sisyphus-agent-${agentId}`, version: "1.0.0" }),
     "utf-8"
@@ -2409,65 +2758,39 @@ function createAgentPlugin(cwd, sessionId, agentId, agentType, agentConfig) {
   const substituteEnvVars = (text) => substituteSisyphusVars(text, sessionId, agentId, sesDir);
   if (agentConfig?.filePath && agentType && agentType !== "worker") {
     const shortName = agentType.replace(/^sisyphus:/, "");
-    const subAgentDir = join11(dirname3(agentConfig.filePath), shortName);
-    if (existsSync10(subAgentDir)) {
-      for (const f of readdirSync7(subAgentDir)) {
+    const subAgentDir = join12(dirname3(agentConfig.filePath), shortName);
+    if (existsSync11(subAgentDir)) {
+      for (const f of readdirSync8(subAgentDir)) {
         if (f.endsWith(".md") && f !== "CLAUDE.md") {
-          writeFileSync8(`${base}/agents/${f}`, substituteEnvVars(readFileSync10(join11(subAgentDir, f), "utf-8")), "utf-8");
+          writeFileSync9(`${base}/agents/${f}`, substituteEnvVars(readFileSync11(join12(subAgentDir, f), "utf-8")), "utf-8");
         }
       }
     }
   }
-  const srcHooks = resolve4(import.meta.dirname, "../templates/agent-plugin/hooks");
-  for (const f of ["require-submit.sh", "intercept-send-message.sh", "register-bg-task.sh", "ask-background-guard.sh"]) {
-    copyFileSync3(`${srcHooks}/${f}`, `${base}/hooks/${f}`);
-  }
-  const hooksConfig = {
-    PreToolUse: [
-      { matcher: "SendMessage", hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/intercept-send-message.sh" }] },
-      { matcher: "Bash", hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/ask-background-guard.sh" }] }
-    ],
-    PostToolUse: [
-      { matcher: "Task", hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/register-bg-task.sh" }] }
-    ]
-  };
-  if (!agentConfig?.frontmatter.interactive) {
-    hooksConfig.Stop = [
-      { hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/require-submit.sh" }] }
-    ];
-  }
+  const layers = agentPluginLayers(cwd);
   const normalizedType = agentType?.replace(/^sisyphus:/, "") ?? "";
-  const userPromptHooks = {
-    "problem": "problem-user-prompt.sh",
-    "plan": "plan-user-prompt.sh",
-    "spec": "spec-user-prompt.sh",
-    "review": "review-user-prompt.sh",
-    "review-plan": "review-plan-user-prompt.sh",
-    "debug": "debug-user-prompt.sh",
-    "operator": "operator-user-prompt.sh",
-    "test-spec": "test-spec-user-prompt.sh",
-    "explore": "explore-user-prompt.sh"
+  const filterCtx = {
+    agentType: normalizedType,
+    interactive: agentConfig?.frontmatter.interactive === true
   };
-  const hookScript = userPromptHooks[normalizedType];
-  if (hookScript) {
-    hooksConfig.UserPromptSubmit = [
-      { hooks: [{ type: "command", command: `bash \${CLAUDE_PLUGIN_ROOT}/hooks/${hookScript}` }] }
-    ];
-    copyFileSync3(`${srcHooks}/${hookScript}`, `${base}/hooks/${hookScript}`);
-  }
-  if (normalizedType === "plan") {
-    hooksConfig.PreToolUse.push({
-      matcher: "Bash",
-      hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/plan-validate.sh" }]
-    });
-    copyFileSync3(`${srcHooks}/plan-validate.sh`, `${base}/hooks/plan-validate.sh`);
-    hooksConfig.PreToolUse.push({
-      matcher: "Write|Edit|MultiEdit",
-      hooks: [{ type: "command", command: "bash ${CLAUDE_PLUGIN_ROOT}/hooks/plan-write-path.sh" }]
-    });
-    copyFileSync3(`${srcHooks}/plan-write-path.sh`, `${base}/hooks/plan-write-path.sh`);
+  const referenced = collectReferencedHookScripts(layers, filterCtx);
+  const disabled = collectDisabledHookScripts(layers);
+  const skipFiles = new Set(disabled);
+  copyLayered(layers, {
+    subdir: "hooks",
+    destDir: `${base}/hooks`,
+    filter: (name) => name !== "CLAUDE.md" && name !== "hooks.json" && (referenced.has(name) || !name.endsWith(".sh")),
+    skipFiles
+  });
+  const mergedHooks = mergeHookManifests(layers, filterCtx);
+  writeFileSync9(`${base}/hooks/hooks.json`, JSON.stringify({ hooks: mergedHooks }, null, 2), "utf-8");
+  const requestedSkills = agentConfig?.frontmatter.skills ?? [];
+  for (const skillName of requestedSkills) {
+    const ok = copySkill(layers, skillName, `${base}/skills`);
+    if (!ok) {
+      console.warn(`[sisyphus] Agent ${agentId} (${normalizedType}) requested skill '${skillName}' but no layer provides it.`);
+    }
   }
-  writeFileSync8(`${base}/hooks/hooks.json`, JSON.stringify({ hooks: hooksConfig }, null, 2), "utf-8");
   return base;
 }
 function setupAgentPane(opts) {
@@ -2480,9 +2803,9 @@ function setupAgentPane(opts) {
   const agentTitle = `ssph:${sessionLabel} ${paneLabel} c${cycleNum}`;
   setPaneTitle(paneId, agentTitle);
   setPaneStyle(paneId, color, { role: paneLabel, session: sessionLabel, cycle: `c${cycleNum}` });
-  const ctxDirRel = relative(paneCwd, contextDir(cwd, sessionId));
+  const ctxDirRel = relative2(paneCwd, contextDir(cwd, sessionId));
   if (agentType === "plan") {
-    mkdirSync6(join11(contextDir(cwd, sessionId), agentId), { recursive: true });
+    mkdirSync7(join12(contextDir(cwd, sessionId), agentId), { recursive: true });
   }
   const sesDir = sessionDir(cwd, sessionId);
   const substitute = (text) => substituteSisyphusVars(text, sessionId, agentId, sesDir);
@@ -2496,7 +2819,7 @@ function setupAgentPane(opts) {
   }
   systemParts.push(suffix);
   const suffixFilePath = `${promptsDir(cwd, sessionId)}/${agentId}-system.md`;
-  writeFileSync8(suffixFilePath, systemParts.join("\n\n"), "utf-8");
+  writeFileSync9(suffixFilePath, systemParts.join("\n\n"), "utf-8");
   const bannerCmd = resolveBannerCmd();
   const npmBinDir = resolveNpmBinDir();
   const envExports = buildEnvExports([
@@ -2517,7 +2840,7 @@ function setupAgentPane(opts) {
     parts.push(`## Task
 
 ${instruction}`);
-    writeFileSync8(codexPromptPath, parts.join("\n\n"), "utf-8");
+    writeFileSync9(codexPromptPath, parts.join("\n\n"), "utf-8");
     const model = agentConfig?.frontmatter.model ?? "codex-mini";
     mainCmd = `codex -m ${shellQuote(model)} --dangerously-bypass-approvals-and-sandbox "$(cat '${codexPromptPath}')"`;
   } else {
@@ -2536,7 +2859,7 @@ ${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 && existsSync10(siblingSettingsPath) ? ` --settings "${siblingSettingsPath}"` : "";
+    const settingsFlag = siblingSettingsPath && existsSync11(siblingSettingsPath) ? ` --settings "${siblingSettingsPath}"` : "";
     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}`;
   }
@@ -2555,7 +2878,7 @@ async function spawnAgent(opts) {
   const count = (agentCounters.get(sessionId) ?? 0) + 1;
   agentCounters.set(sessionId, count);
   const agentId = `agent-${String(count).padStart(3, "0")}`;
-  const bundledPluginPath = resolve4(import.meta.dirname, "../templates/agent-plugin");
+  const bundledPluginPath = resolve5(import.meta.dirname, "../templates/agent-plugin");
   const agentConfig = resolveAgentConfig(agentType, bundledPluginPath, cwd);
   let provider = detectProvider(agentConfig?.frontmatter.model);
   const color = (agentConfig?.frontmatter.color ? normalizeTmuxColor(agentConfig.frontmatter.color) : null) ?? getNextColor(sessionId);
@@ -2579,7 +2902,7 @@ async function spawnAgent(opts) {
     }
   }
   const repo = opts.repo !== void 0 ? opts.repo : ".";
-  const repoRoot = repo === "." ? cwd : join11(cwd, repo);
+  const repoRoot = repo === "." ? cwd : join12(cwd, repo);
   const paneCwd = repoRoot;
   const claudeSessionId = provider !== "openai" ? randomUUID3() : void 0;
   const { paneId, fullCmd, resumeEnv, resumeArgs } = setupAgentPane({
@@ -2640,12 +2963,12 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
     });
   }
   const { instruction, agentType, name, color } = agent;
-  const bundledPluginPath = resolve4(import.meta.dirname, "../templates/agent-plugin");
+  const bundledPluginPath = resolve5(import.meta.dirname, "../templates/agent-plugin");
   const agentConfig = resolveAgentConfig(agentType, bundledPluginPath, cwd);
   const provider = detectProvider(agentConfig?.frontmatter.model);
   let paneCwd = cwd;
   if (agent.repo !== ".") {
-    paneCwd = join11(cwd, agent.repo);
+    paneCwd = join12(cwd, agent.repo);
   }
   if (agent.paneId) {
     try {
@@ -2696,7 +3019,7 @@ async function restartAgent(sessionId, cwd, agentId, windowId) {
 function nextReportNumber(cwd, sessionId, agentId) {
   const dir = reportsDir(cwd, sessionId);
   try {
-    const files = readdirSync7(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
+    const files = readdirSync8(dir).filter((f) => f.startsWith(`${agentId}-`) && !f.endsWith("-final.md"));
     return String(files.length + 1).padStart(3, "0");
   } catch {
     return "001";
@@ -2704,10 +3027,10 @@ function nextReportNumber(cwd, sessionId, agentId) {
 }
 async function handleAgentReport(cwd, sessionId, agentId, content) {
   const dir = reportsDir(cwd, sessionId);
-  mkdirSync6(dir, { recursive: true });
+  mkdirSync7(dir, { recursive: true });
   const num = nextReportNumber(cwd, sessionId, agentId);
   const filePath = reportFilePath(cwd, sessionId, agentId, num);
-  writeFileSync8(filePath, content, "utf-8");
+  writeFileSync9(filePath, content, "utf-8");
   const entry = {
     type: "update",
     filePath,
@@ -2725,9 +3048,9 @@ async function handleAgentReport(cwd, sessionId, agentId, content) {
 }
 function gcBgTasks(cwd, sessionId, agentId) {
   const file = `${sessionDir(cwd, sessionId)}/runtime/bg-tasks/${agentId}.txt`;
-  if (!existsSync10(file)) return;
+  if (!existsSync11(file)) return;
   try {
-    const leftover = readFileSync10(file, "utf-8").split("\n").map((s) => s.trim()).filter(Boolean);
+    const leftover = readFileSync11(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 });
@@ -2739,9 +3062,9 @@ function gcBgTasks(cwd, sessionId, agentId) {
 }
 async function handleAgentSubmit(cwd, sessionId, agentId, report) {
   const dir = reportsDir(cwd, sessionId);
-  mkdirSync6(dir, { recursive: true });
+  mkdirSync7(dir, { recursive: true });
   const filePath = reportFilePath(cwd, sessionId, agentId, "final");
-  writeFileSync8(filePath, report, "utf-8");
+  writeFileSync9(filePath, report, "utf-8");
   const entry = {
     type: "final",
     filePath,
@@ -2811,7 +3134,7 @@ async function handleAwait(cwd, sessionId, agentId) {
   const POLL_MS = 250;
   let agent = initialAgent;
   while (agent.status === "running") {
-    await new Promise((resolve11) => setTimeout(resolve11, POLL_MS));
+    await new Promise((resolve12) => setTimeout(resolve12, POLL_MS));
     const session = getSession(cwd, sessionId);
     const found = session.agents.find((a) => a.id === agentId);
     if (!found) return null;
@@ -2832,9 +3155,9 @@ var respawningSessions = /* @__PURE__ */ new Set();
 
 // src/daemon/companion.ts
 init_paths();
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync12, renameSync as renameSync4, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync13, renameSync as renameSync4, writeFileSync as writeFileSync11 } from "fs";
 import { randomUUID as randomUUID5 } from "crypto";
-import { dirname as dirname5, join as join13 } from "path";
+import { dirname as dirname5, join as join14 } from "path";
 
 // src/shared/companion-normalize.ts
 function emptyStats() {
@@ -2965,8 +3288,8 @@ var ACHIEVEMENTS = [
 
 // src/daemon/companion-memory.ts
 init_paths();
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync11, renameSync as renameSync3, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname4, join as join12 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync12, 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";
 var MAX_OBSERVATIONS = 200;
@@ -3003,10 +3326,10 @@ function fillDefaults(state) {
 }
 function loadMemoryStrict() {
   const path = resolvedMemoryPath();
-  if (!existsSync11(path)) return defaultMemoryState();
+  if (!existsSync12(path)) return defaultMemoryState();
   let raw;
   try {
-    raw = readFileSync11(path, "utf-8");
+    raw = readFileSync12(path, "utf-8");
   } catch (err) {
     throw new MemoryStoreParseError(err);
   }
@@ -3039,9 +3362,9 @@ function loadMemory() {
 function saveMemory(store) {
   const path = resolvedMemoryPath();
   const dir = dirname4(path);
-  mkdirSync7(dir, { recursive: true });
-  const tmp = join12(dir, `.companion-memory.${randomUUID4()}.tmp`);
-  writeFileSync9(tmp, JSON.stringify(store, null, 2), "utf-8");
+  mkdirSync8(dir, { recursive: true });
+  const tmp = join13(dir, `.companion-memory.${randomUUID4()}.tmp`);
+  writeFileSync10(tmp, JSON.stringify(store, null, 2), "utf-8");
   renameSync3(tmp, path);
 }
 function appendObservations(records, detectorUpdates) {
@@ -3468,21 +3791,21 @@ function zScore(value, stats, metric) {
 }
 function loadCompanion() {
   const path = companionPath();
-  if (!existsSync12(path)) {
+  if (!existsSync13(path)) {
     const state2 = createDefaultCompanion();
     saveCompanion(state2);
     return state2;
   }
-  const raw = readFileSync12(path, "utf-8");
+  const raw = readFileSync13(path, "utf-8");
   const state = JSON.parse(raw);
   return normalizeCompanion(state);
 }
 function saveCompanion(state) {
   const path = companionPath();
   const dir = dirname5(path);
-  mkdirSync8(dir, { recursive: true });
-  const tmp = join13(dir, `.companion.${randomUUID5()}.tmp`);
-  writeFileSync10(tmp, JSON.stringify(state, null, 2), "utf-8");
+  mkdirSync9(dir, { recursive: true });
+  const tmp = join14(dir, `.companion.${randomUUID5()}.tmp`);
+  writeFileSync11(tmp, JSON.stringify(state, null, 2), "utf-8");
   renameSync4(tmp, path);
 }
 var MAX_COMMENTARY_HISTORY = 1e3;
@@ -4069,7 +4392,7 @@ async function runPostSessionObservations(companion, session, prev) {
 }
 
 // src/daemon/companion-commentary.ts
-import { basename as basename3 } from "path";
+import { basename as basename4 } from "path";
 import { z as z2 } from "zod";
 var COMMENTARY_JSON_SCHEMA = {
   type: "object",
@@ -4880,9 +5203,9 @@ Generate a single agent nickname. One word only. No quotes, no explanation.`;
 }
 
 // src/daemon/companion-popup.ts
-import { writeFileSync as writeFileSync11, readFileSync as readFileSync13, unlinkSync as unlinkSync2, existsSync as existsSync13 } from "fs";
+import { writeFileSync as writeFileSync12, readFileSync as readFileSync14, unlinkSync as unlinkSync2, existsSync as existsSync14 } from "fs";
 import { tmpdir } from "os";
-import { join as join14, resolve as resolve5 } from "path";
+import { join as join15, resolve as resolve6 } from "path";
 
 // src/shared/companion-render.ts
 import stringWidth from "string-width";
@@ -5178,10 +5501,10 @@ function applyColor(result, fields, facePart, mood, opts) {
 var POPUP_WIDTH = 38;
 var INNER_WIDTH = POPUP_WIDTH - 6;
 var POPUP_DURATION = 15;
-var POPUP_TMP_PREFIX = join14(tmpdir(), "sisyphus-popup");
-var POPUP_SCRIPT = join14(tmpdir(), "sisyphus-popup.sh");
-var POPUP_RESULT_PREFIX = join14(tmpdir(), "sisyphus-popup-result");
-var WHIP_ANIMATION_PATH = resolve5(import.meta.dirname, "../templates/whip-animation.sh");
+var POPUP_TMP_PREFIX = join15(tmpdir(), "sisyphus-popup");
+var POPUP_SCRIPT = join15(tmpdir(), "sisyphus-popup.sh");
+var POPUP_RESULT_PREFIX = join15(tmpdir(), "sisyphus-popup-result");
+var WHIP_ANIMATION_PATH = resolve6(import.meta.dirname, "../templates/whip-animation.sh");
 var WHIP_ANIMATION_ROWS = 12;
 function wrapText(text, width) {
   const words = text.split(" ");
@@ -5222,9 +5545,9 @@ function showCommentaryPopupQueue(pages) {
       const contentLineCount = content.split("\n").length - 1;
       const contentHeight = Math.max(contentLineCount + 2, 5);
       if (contentHeight > maxContentHeight) maxContentHeight = contentHeight;
-      writeFileSync11(`${POPUP_TMP_PREFIX}-${i}.txt`, content);
+      writeFileSync12(`${POPUP_TMP_PREFIX}-${i}.txt`, content);
     }
-    const whipAvailable = existsSync13(WHIP_ANIMATION_PATH);
+    const whipAvailable = existsSync14(WHIP_ANIMATION_PATH);
     if (whipAvailable && maxContentHeight < WHIP_ANIMATION_ROWS + 2) {
       maxContentHeight = WHIP_ANIMATION_ROWS + 2;
     }
@@ -5271,7 +5594,7 @@ if [ ! -f "$RESULT_FILE" ]; then
   printf 'neutral' > "$RESULT_FILE"
 fi
 `;
-    writeFileSync11(POPUP_SCRIPT, script, { mode: 493 });
+    writeFileSync12(POPUP_SCRIPT, script, { mode: 493 });
     try {
       unlinkSync2(POPUP_RESULT_PREFIX);
     } catch {
@@ -5298,7 +5621,7 @@ fi
     }
     let raw;
     try {
-      raw = readFileSync13(POPUP_RESULT_PREFIX, "utf8").trim();
+      raw = readFileSync14(POPUP_RESULT_PREFIX, "utf8").trim();
     } catch {
       return null;
     } finally {
@@ -5734,7 +6057,7 @@ async function pollSession(sessionId, cwd, windowId, increment, sessionCache) {
 }
 
 // src/daemon/mode-notify.ts
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { ulid as ulid2 } from "ulid";
 init_paths();
 function capitalize(s) {
@@ -5757,7 +6080,7 @@ function findOpenModeTransitionAsk(cwd, sessionId) {
     if (meta.modeTransition !== true) continue;
     if (meta.status === "answered") continue;
     if (meta.orphaned === true) continue;
-    if (existsSync14(askOutputPath(cwd, sessionId, askId))) continue;
+    if (existsSync15(askOutputPath(cwd, sessionId, askId))) continue;
     return askId;
   }
   return null;
@@ -5776,9 +6099,9 @@ function buildNextChain(prevChain, prevMode, nextMode, prevModeStats) {
   }
   return [{ mode: "unknown" }, { mode: nextMode }];
 }
-function renderBody(chain) {
+function renderBody(chain, cwd) {
   const current = chain[chain.length - 1];
-  const description = discoverOrchestratorModes().find((m) => m.name === current.mode)?.description?.trim();
+  const description = discoverOrchestratorModes(cwd).find((m) => m.name === current.mode)?.description?.trim();
   const lines = [];
   if (description) {
     lines.push(`**${capitalize(current.mode)}** \u2014 ${description}`);
@@ -5812,7 +6135,7 @@ async function emitModeTransitionNotify(cwd, sessionId, prevMode, nextMode, prev
   const subtitle = chain.map((e) => e.mode).join(" \u2192 ");
   const title = "Mode change";
   const deckTitle = `Mode: ${subtitle}`;
-  const body = renderBody(chain);
+  const body = renderBody(chain, cwd);
   const interaction = {
     id: "mode-transition",
     title,
@@ -5864,19 +6187,19 @@ async function emitModeTransitionNotify(cwd, sessionId, prevMode, nextMode, prev
 function detectRepos(cwd) {
   const config = loadConfig(cwd);
   const repos = [];
-  if (existsSync15(join15(cwd, ".git"))) {
+  if (existsSync16(join16(cwd, ".git"))) {
     try {
       repos.push(getRepoInfo(cwd, "."));
     } catch {
     }
   }
   try {
-    const entries = readdirSync9(cwd, { withFileTypes: true });
+    const entries = readdirSync10(cwd, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const childPath = join15(cwd, entry.name);
-      if (existsSync15(join15(childPath, ".git"))) {
+      const childPath = join16(cwd, entry.name);
+      if (existsSync16(join16(childPath, ".git"))) {
         try {
           repos.push(getRepoInfo(childPath, entry.name));
         } catch {
@@ -5912,19 +6235,44 @@ function getOrchestratorPaneId(sessionId) {
 function setOrchestratorPaneId(sessionId, paneId) {
   sessionOrchestratorPane.set(sessionId, paneId);
 }
+function resolveOrchestratorSettings(cwd, sessionId) {
+  const bundled = resolve7(import.meta.dirname, "../templates/orchestrator-settings.json");
+  const projectSettings = projectOrchestratorSettingsPath(cwd);
+  const userSettings = userOrchestratorSettingsPath();
+  const hasProject = existsSync16(projectSettings);
+  const hasUser = existsSync16(userSettings);
+  if (!hasProject && !hasUser) return bundled;
+  let merged = {};
+  for (const path of [bundled, hasUser ? userSettings : null, hasProject ? projectSettings : null]) {
+    if (!path || !existsSync16(path)) continue;
+    try {
+      const parsed = JSON.parse(readFileSync15(path, "utf-8"));
+      merged = { ...merged, ...parsed };
+    } catch (err) {
+      console.warn(`[sisyphus] Failed to parse settings layer ${path}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+  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 (existsSync15(projectPath)) {
-    return readFileSync14(projectPath, "utf-8");
+  if (existsSync16(projectPath)) {
+    return readFileSync15(projectPath, "utf-8");
   }
-  const basePath = resolve6(import.meta.dirname, "../templates/orchestrator-base.md");
-  const base = readFileSync14(basePath, "utf-8");
-  const modes = discoverOrchestratorModes();
+  const userPath = userOrchestratorPromptPath();
+  if (existsSync16(userPath)) {
+    return readFileSync15(userPath, "utf-8");
+  }
+  const basePath = resolve7(import.meta.dirname, "../templates/orchestrator-base.md");
+  const base = readFileSync15(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 = readFileSync14(selected.filePath, "utf-8");
+  const modeContent = readFileSync15(selected.filePath, "utf-8");
   const modeBody = extractAgentBody(modeContent);
   return base + "\n\n" + modeBody;
 }
@@ -5945,8 +6293,8 @@ function buildCompletionContent(session) {
     lines.push("");
   }
   const logsDirPath = logsDir(session.cwd, session.id);
-  if (existsSync15(logsDirPath)) {
-    const logFiles = readdirSync9(logsDirPath).filter((f) => f.startsWith("cycle-") && f.endsWith(".md")).sort();
+  if (existsSync16(logsDirPath)) {
+    const logFiles = readdirSync10(logsDirPath).filter((f) => f.startsWith("cycle-") && f.endsWith(".md")).sort();
     if (logFiles.length > 0) {
       lines.push("### Cycle Logs\n");
       const cycleByNum = new Map(session.orchestratorCycles.map((c) => [c.cycle, c]));
@@ -5970,7 +6318,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 = readFileSync14(join15(logsDirPath, e.file), "utf-8").trim();
+            const content = readFileSync15(join16(logsDirPath, e.file), "utf-8").trim();
             if (content) {
               lines.push(content);
               lines.push("");
@@ -5986,7 +6334,7 @@ function buildCompletionContent(session) {
           }
           i = j;
         } else {
-          const content = readFileSync14(join15(logsDirPath, e.file), "utf-8").trim();
+          const content = readFileSync15(join16(logsDirPath, e.file), "utf-8").trim();
           if (content) {
             lines.push(content);
             lines.push("");
@@ -5997,11 +6345,11 @@ function buildCompletionContent(session) {
     }
   }
   const reportsDirPath = reportsDir(session.cwd, session.id);
-  if (existsSync15(reportsDirPath)) {
-    const reportFiles = readdirSync9(reportsDirPath).filter((f) => f.endsWith(".md"));
+  if (existsSync16(reportsDirPath)) {
+    const reportFiles = readdirSync10(reportsDirPath).filter((f) => f.endsWith(".md"));
     if (reportFiles.length > 0) {
       lines.push("### Detailed Reports\n");
-      lines.push(`Full agent reports: @${relative2(session.cwd, reportsDirPath)}
+      lines.push(`Full agent reports: @${relative3(session.cwd, reportsDirPath)}
 `);
     }
   }
@@ -6023,21 +6371,21 @@ ${session.context}
     }
   } else {
     let ctxFiles = [];
-    if (existsSync15(ctxDir)) {
-      ctxFiles = readdirSync9(ctxDir).filter((f) => f !== "CLAUDE.md");
+    if (existsSync16(ctxDir)) {
+      ctxFiles = readdirSync10(ctxDir).filter((f) => f !== "CLAUDE.md");
     }
     if (ctxFiles.length > 0) {
       contextSection = `
 ## Context
 
-@${relative2(session.cwd, ctxDir)}
+@${relative3(session.cwd, ctxDir)}
 `;
     }
   }
   const messages = session.messages ?? [];
   const messagesSection = messages.length > 0 ? "\n### Messages\n\n" + messages.map((m) => {
     const sourceLabel = m.source.type === "agent" ? `agent:${m.source.agentId}` : m.source.type === "system" && m.source.detail ? `system:${m.source.detail}` : m.source.type;
-    const fileRef = m.filePath ? ` \u2192 ${relative2(session.cwd, m.filePath)}` : "";
+    const fileRef = m.filePath ? ` \u2192 ${relative3(session.cwd, m.filePath)}` : "";
     return `- [${sourceLabel} @ ${m.timestamp}] "${m.summary}"${fileRef}`;
   }).join("\n") + "\n" : "";
   let mostRecentCycleSection = "";
@@ -6054,7 +6402,7 @@ ${session.context}
         if (!agent) return `- **${id}**: unknown (no agent data)`;
         const finalReport = agent.reports.find((r) => r.type === "final");
         const reportToUse = finalReport ?? agent.reports[agent.reports.length - 1];
-        const reportRef = reportToUse ? `@${relative2(session.cwd, reportToUse.filePath)}` : "(no reports)";
+        const reportRef = reportToUse ? `@${relative3(session.cwd, reportToUse.filePath)}` : "(no reports)";
         return `- **${id}** (${agent.name}) [${agent.status}]: ${reportRef}`;
       }).join("\n");
       mostRecentCycleSection = `
@@ -6065,10 +6413,10 @@ ${agentLines}
     }
   }
   const strategyFile = strategyPath(session.cwd, session.id);
-  const strategyRef = existsSync15(strategyFile) ? `@${relative2(session.cwd, strategyFile)}` : "(empty)";
-  const roadmapRef = existsSync15(roadmapFile) ? `@${relative2(session.cwd, roadmapFile)}` : "(empty)";
+  const strategyRef = existsSync16(strategyFile) ? `@${relative3(session.cwd, strategyFile)}` : "(empty)";
+  const roadmapRef = existsSync16(roadmapFile) ? `@${relative3(session.cwd, roadmapFile)}` : "(empty)";
   const digestFile = digestPath(session.cwd, session.id);
-  const digestRef = existsSync15(digestFile) ? `@${relative2(session.cwd, digestFile)}` : "(not yet created)";
+  const digestRef = existsSync16(digestFile) ? `@${relative3(session.cwd, digestFile)}` : "(not yet created)";
   const repos = detectRepos(session.cwd);
   let repositoriesSection = "\n\n## Repositories\n";
   if (repos.length === 0) {
@@ -6095,7 +6443,7 @@ ${agentLines}
     }
   }
   const goalFile = goalPath(session.cwd, session.id);
-  const goalContent = existsSync15(goalFile) ? readFileSync14(goalFile, "utf-8").trim() : session.task;
+  const goalContent = existsSync16(goalFile) ? readFileSync15(goalFile, "utf-8").trim() : session.task;
   const modeContent = modeContentBuilders[mode]?.(session) ?? "";
   return `## Goal
 
@@ -6103,7 +6451,7 @@ ${goalContent}
 ${contextSection}${messagesSection}
 ### Cycle Log
 
-Write your cycle summary to: ${relative2(session.cwd, logFile)}
+Write your cycle summary to: ${relative3(session.cwd, logFile)}
 ${mostRecentCycleSection}${modeContent}
 ## Strategy
 
@@ -6129,7 +6477,7 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message, forceMode) {
   const mode = forceMode ?? (lastCycle?.mode ?? "discovery");
   const basePrompt = loadOrchestratorPrompt(cwd, sessionId, mode);
   const formattedState = formatStateForOrchestrator(session, mode);
-  const agentPluginPath = resolve6(import.meta.dirname, "../templates/agent-plugin");
+  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})` : "";
@@ -6138,7 +6486,7 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message, forceMode) {
   }).join("\n") : "  (none)";
   const sesDir = sessionDir(cwd, sessionId);
   const substituteEnvVars = (text) => text.replace(/\$SISYPHUS_SESSION_DIR/g, sesDir).replace(/\$SISYPHUS_SESSION_ID/g, sessionId);
-  const modes = discoverOrchestratorModes();
+  const modes = discoverOrchestratorModes(cwd);
   const modeLines = modes.map((m) => {
     const desc = m.description ? ` \u2014 ${m.description}` : "";
     return `- \`${m.name}\`${desc}`;
@@ -6150,7 +6498,7 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message, forceMode) {
   const systemPrompt = renderEffortMarkers(substitutedPrompt, sessionEffort);
   const cycleNum = session.orchestratorCycles.length + 1;
   const promptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-system-${cycleNum}.md`;
-  writeFileSync12(promptFilePath, systemPrompt, "utf-8");
+  writeFileSync13(promptFilePath, systemPrompt, "utf-8");
   sessionWindowMap.set(sessionId, windowId);
   const npmBinDir = resolveNpmBinDir();
   const envExports = buildEnvExports([
@@ -6187,14 +6535,19 @@ ${continuationText}`;
 The previous cycle waited ~${hours}h for a \`sis ask\` answer. Repository state and any in-flight context may have drifted during that window. Briefly verify before acting on the answer.`;
   }
   const userPromptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
-  writeFileSync12(userPromptFilePath, substituteEnvVars(userPrompt), "utf-8");
+  writeFileSync13(userPromptFilePath, substituteEnvVars(userPrompt), "utf-8");
   if (session.messages && session.messages.length > 0) {
     await drainMessages(cwd, sessionId, session.messages.length);
   }
-  const pluginSrcPath = resolve6(import.meta.dirname, "../templates/orchestrator-plugin");
-  const pluginPath = join15(sesDir, ".orchestrator-plugin");
-  renderPluginDir(pluginSrcPath, pluginPath, sessionEffort);
-  const settingsPath = resolve6(import.meta.dirname, "../templates/orchestrator-settings.json");
+  const pluginPath = join16(sesDir, ".orchestrator-plugin");
+  const orchLayers = orchestratorPluginLayers(cwd);
+  if (orchLayers.length === 0) {
+    const pluginSrcPath = resolve7(import.meta.dirname, "../templates/orchestrator-plugin");
+    renderPluginDir(pluginSrcPath, pluginPath, sessionEffort);
+  } else {
+    renderLayeredPluginDir(orchLayers, pluginPath, sessionEffort);
+  }
+  const settingsPath = resolveOrchestratorSettings(cwd, sessionId);
   const config = loadConfig(cwd);
   const effort = config.orchestratorEffort ?? "xhigh";
   const model = config.model;
@@ -6307,7 +6660,7 @@ function cleanupSessionMaps(sessionId) {
 init_paths();
 
 // src/daemon/status-dots.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 var CLAUDE_STATE_DIR = "/tmp/claude-tmux-state";
 var DOT_MAP = {
   "orchestrator:processing": { icon: "\u25CF", color: "#d4ad6a" },
@@ -6333,7 +6686,7 @@ function renderDots(dots) {
 function readClaudeState(paneId) {
   const numericId = paneId.replace("%", "");
   try {
-    const content = readFileSync15(`${CLAUDE_STATE_DIR}/${numericId}`, "utf-8").trim();
+    const content = readFileSync16(`${CLAUDE_STATE_DIR}/${numericId}`, "utf-8").trim();
     if (content === "idle" || content === "processing" || content === "stopped") {
       return content;
     }
@@ -6491,21 +6844,21 @@ function buildManifest(args) {
 init_paths();
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync16, readFileSync as readFileSync16, mkdirSync as mkdirSync9, symlinkSync, rmSync as rmSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync17, 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) {
   return name.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
 function buildOutputPath(label, dir) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  mkdirSync9(dir, { recursive: true });
+  mkdirSync10(dir, { recursive: true });
   const base = `sisyphus-${label}-${date}`;
-  let candidate = join16(dir, `${base}.zip`);
+  let candidate = join17(dir, `${base}.zip`);
   let counter = 1;
-  while (existsSync16(candidate)) {
+  while (existsSync17(candidate)) {
     counter++;
-    candidate = join16(dir, `${base}-${counter}.zip`);
+    candidate = join17(dir, `${base}-${counter}.zip`);
   }
   return candidate;
 }
@@ -6567,38 +6920,38 @@ async function exportSessionToZip(sessionId, cwd, options) {
   const reveal = options?.reveal ?? true;
   const sessDir = sessionDir(cwd, sessionId);
   const histDir = historySessionDir(sessionId);
-  const sessExists = existsSync16(sessDir);
-  const histExists = existsSync16(histDir);
+  const sessExists = existsSync17(sessDir);
+  const histExists = existsSync17(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 (existsSync16(stPath)) {
+  if (existsSync17(stPath)) {
     try {
-      const state = JSON.parse(readFileSync16(stPath, "utf-8"));
+      const state = JSON.parse(readFileSync17(stPath, "utf-8"));
       if (state.name) {
         label = sanitizeName(state.name);
       }
     } catch {
     }
   }
-  const dir = options?.outputDir ?? join16(homedir5(), "Downloads");
+  const dir = options?.outputDir ?? join17(homedir6(), "Downloads");
   const outputPath = buildOutputPath(label, dir);
   const tmpDir = `/tmp/sisyphus-export-${sessionId.slice(0, 8)}-${Date.now()}`;
   try {
-    mkdirSync9(tmpDir, { recursive: true });
-    writeFileSync13(join16(tmpDir, "CLAUDE.md"), generateGuide(), "utf-8");
+    mkdirSync10(tmpDir, { recursive: true });
+    writeFileSync14(join17(tmpDir, "CLAUDE.md"), generateGuide(), "utf-8");
     if (sessExists) {
-      symlinkSync(sessDir, join16(tmpDir, "session"));
+      symlinkSync(sessDir, join17(tmpDir, "session"));
     }
     if (histExists) {
-      symlinkSync(histDir, join16(tmpDir, "history"));
+      symlinkSync(histDir, join17(tmpDir, "history"));
     }
     const parts = ["CLAUDE.md", sessExists ? "session/" : "", histExists ? "history/" : ""].filter(Boolean);
     await execFileAsync("zip", ["-rq", outputPath, ...parts], { cwd: tmpDir });
   } finally {
-    rmSync4(tmpDir, { recursive: true, force: true });
+    rmSync5(tmpDir, { recursive: true, force: true });
   }
   if (reveal) {
     try {
@@ -6672,12 +7025,12 @@ async function runSessionUploadAndPersist(args) {
 }
 
 // src/shared/version.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync18 } from "fs";
+import { resolve as resolve8 } from "path";
 function readSisyphusVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync17(resolve7(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync18(resolve8(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -6718,7 +7071,7 @@ function truncate(s, max) {
 function readGoal(cwd, sessionId, fallback) {
   try {
     const p = goalPath(cwd, sessionId);
-    if (existsSync17(p)) return readFileSync18(p, "utf-8").trim();
+    if (existsSync18(p)) return readFileSync19(p, "utf-8").trim();
   } catch {
   }
   return fallback;
@@ -6959,8 +7312,8 @@ var PRUNE_KEEP_DAYS2 = 7;
 function pruneOldSessions(cwd) {
   try {
     const dir = sessionsDir(cwd);
-    if (!existsSync17(dir)) return;
-    const entries = readdirSync10(dir, { withFileTypes: true });
+    if (!existsSync18(dir)) return;
+    const entries = readdirSync11(dir, { withFileTypes: true });
     const candidates = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
@@ -6983,7 +7336,7 @@ function pruneOldSessions(cwd) {
     }
     for (const c of candidates) {
       if (keep.has(c.id)) continue;
-      rmSync5(sessionDir(cwd, c.id), { recursive: true, force: true });
+      rmSync6(sessionDir(cwd, c.id), { recursive: true, force: true });
     }
   } catch (err) {
     console.error("[sisyphus] Session pruning failed:", err);
@@ -7097,8 +7450,8 @@ function getSessionStatus(cwd, sessionId) {
 }
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync17(dir)) return [];
-  const entries = readdirSync10(dir, { withFileTypes: true });
+  if (!existsSync18(dir)) return [];
+  const entries = readdirSync11(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
@@ -7165,8 +7518,8 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
 Agents: ${truncate(spawnedThisCycle, 200)}`;
     try {
       const logPath = cycleLogPath(cwd, sessionId, cycleNumber);
-      if (existsSync17(logPath)) {
-        const log = readFileSync18(logPath, "utf-8").trim();
+      if (existsSync18(logPath)) {
+        const log = readFileSync19(logPath, "utf-8").trim();
         if (log) cycleCtx += `
 Cycle log: ${truncate(log, 200)}`;
       }
@@ -7633,7 +7986,7 @@ import { spawn as spawn2 } from "child_process";
 import {
   closeSync as closeSync2,
   constants,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   fstatSync as fstatSync2,
   lstatSync,
   openSync as openSync2,
@@ -7641,15 +7994,15 @@ import {
   writeSync
 } from "fs";
 import * as fs from "fs";
-import { resolve as resolve8, dirname as dirname6, isAbsolute, sep } from "path";
+import { resolve as resolve9, dirname as dirname6, isAbsolute, sep } from "path";
 import { fileURLToPath } from "url";
 import { z as z3 } from "zod";
 import { tool } from "@r-cli/sdk";
 
 // src/daemon/transcript-digest.ts
 import { openSync, fstatSync, readSync, closeSync } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join17 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join18 } from "path";
 var BYTE_CAP = 8 * 1024;
 var TAIL_BYTES = 64 * 1024;
 var TOOL_USE_INPUT_CAP = 200;
@@ -7662,8 +8015,8 @@ function digestTranscript(opts) {
     warnOnce("transcript-digest: no claudeSessionId; falling back to empty context");
     return "";
   }
-  const home = opts.homeDir ?? homedir6();
-  const path = join17(home, ".claude", "projects", encodeCwd(opts.cwd), `${opts.claudeSessionId}.jsonl`);
+  const home = opts.homeDir ?? homedir7();
+  const path = join18(home, ".claude", "projects", encodeCwd(opts.cwd), `${opts.claudeSessionId}.jsonl`);
   let raw;
   let fd;
   try {
@@ -7746,11 +8099,11 @@ init_paths();
 var READ_FILE_CAP = 50 * 1024;
 var ANSI_CAP = 256 * 1024;
 var SYSTEM_PROMPT_CANDIDATES = [
-  resolve8(dirname6(fileURLToPath(import.meta.url)), "templates/termrender-haiku-system.md"),
+  resolve9(dirname6(fileURLToPath(import.meta.url)), "templates/termrender-haiku-system.md"),
   // dist/templates/
-  resolve8(dirname6(fileURLToPath(import.meta.url)), "../templates/termrender-haiku-system.md"),
+  resolve9(dirname6(fileURLToPath(import.meta.url)), "../templates/termrender-haiku-system.md"),
   // <sisyphus>/templates/ from dist/
-  resolve8(dirname6(fileURLToPath(import.meta.url)), "../../templates/termrender-haiku-system.md")
+  resolve9(dirname6(fileURLToPath(import.meta.url)), "../../templates/termrender-haiku-system.md")
   // src/daemon/ → <sisyphus>/templates/
 ];
 var cachedSystemPrompt;
@@ -7763,7 +8116,7 @@ async function generateVisualForQuestion(opts) {
   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 && existsSync18(mdPath) && existsSync18(ansiPath)) {
+  if (!opts.force && existsSync19(mdPath) && existsSync19(ansiPath)) {
     return { ok: true, markdownPath: mdPath, ansiPath, turns: 0 };
   }
   if (opts.force) {
@@ -7837,7 +8190,7 @@ function buildUserPrompt(q, askedBy, ctx) {
 }
 function readSystemPrompt() {
   if (cachedSystemPrompt !== void 0) return cachedSystemPrompt;
-  const found = SYSTEM_PROMPT_CANDIDATES.find((p) => existsSync18(p));
+  const found = SYSTEM_PROMPT_CANDIDATES.find((p) => existsSync19(p));
   if (found === void 0) {
     throw new Error(
       `termrender-haiku-system.md not found in any candidate location: ${SYSTEM_PROMPT_CANDIDATES.join(", ")}`
@@ -7850,7 +8203,7 @@ function readFileHandler(realSessionCwd, requestedPath) {
   if (isAbsolute(requestedPath)) {
     return Promise.resolve(errorResult("path must be relative to session cwd"));
   }
-  const joined = resolve8(realSessionCwd, requestedPath);
+  const joined = resolve9(realSessionCwd, requestedPath);
   let realPath;
   try {
     const r = { p: fs.realpathSync(joined, { encoding: "utf-8" }) };
@@ -7907,23 +8260,23 @@ function errorResult(msg) {
   return { content: [{ type: "text", text: msg }], isError: true };
 }
 function spawnAsync(cmd, args, input, timeoutMs) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const chunks = [];
     const errChunks = [];
     const proc = spawn2(cmd, args, { stdio: ["pipe", "pipe", "pipe"], env: execEnv() });
     const timer = setTimeout(() => {
       proc.kill();
-      resolve11({ stdout: "", stderr: "", status: null, error: new Error(`timed out after ${timeoutMs}ms`) });
+      resolve12({ 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);
-      resolve11({ stdout: "", stderr: "", status: null, error: err });
+      resolve12({ stdout: "", stderr: "", status: null, error: err });
     });
     proc.on("close", (code) => {
       clearTimeout(timer);
-      resolve11({ stdout: Buffer.concat(chunks).toString("utf-8"), stderr: Buffer.concat(errChunks).toString("utf-8"), status: code });
+      resolve12({ stdout: Buffer.concat(chunks).toString("utf-8"), stderr: Buffer.concat(errChunks).toString("utf-8"), status: code });
     });
     proc.stdin.end(input, "utf-8");
   });
@@ -7998,22 +8351,22 @@ function setCompositor(c) {
 }
 var sessionTrackingMap = /* @__PURE__ */ new Map();
 function registryPath() {
-  return join18(globalDir(), "session-registry.json");
+  return join19(globalDir(), "session-registry.json");
 }
 function persistSessionRegistry() {
   const dir = globalDir();
-  mkdirSync10(dir, { recursive: true });
+  mkdirSync11(dir, { recursive: true });
   const registry = {};
   for (const [id, tracking] of sessionTrackingMap) {
     registry[id] = tracking.cwd;
   }
-  writeFileSync14(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
+  writeFileSync15(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync19(p)) return {};
+  if (!existsSync20(p)) return {};
   try {
-    return JSON.parse(readFileSync20(p, "utf-8"));
+    return JSON.parse(readFileSync21(p, "utf-8"));
   } catch (err) {
     console.warn("[sisyphus] Failed to parse session registry:", err instanceof Error ? err.message : err);
     return {};
@@ -8060,8 +8413,8 @@ function collectAllSessionIds() {
     scannedCwds.add(cwd);
     try {
       const dir = sessionsDir(cwd);
-      if (!existsSync19(dir)) continue;
-      for (const entry of readdirSync11(dir, { withFileTypes: true })) {
+      if (!existsSync20(dir)) continue;
+      for (const entry of readdirSync12(dir, { withFileTypes: true })) {
         if (entry.isDirectory() && !idToCwd.has(entry.name)) {
           idToCwd.set(entry.name, cwd);
         }
@@ -8261,7 +8614,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync19(stateFile)) {
+          if (existsSync20(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -8276,7 +8629,7 @@ async function handleRequest(req) {
       }
       case "clear-orphan": {
         const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-        if (!existsSync19(stateFile)) {
+        if (!existsSync20(stateFile)) {
           return { ok: false, error: `Unknown session: ${req.sessionId}. No state.json at ${stateFile}.` };
         }
         await Promise.all([
@@ -8327,7 +8680,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync19(stateFile)) {
+          if (existsSync20(stateFile)) {
             registerSessionCwd(req.sessionId, req.cwd);
             tracking = sessionTrackingMap.get(req.sessionId);
           } else {
@@ -8341,7 +8694,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync19(stateFile)) {
+          if (existsSync20(stateFile)) {
             registerSessionCwd(req.sessionId, req.cwd);
             tracking = sessionTrackingMap.get(req.sessionId);
           } else {
@@ -8358,7 +8711,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync19(stateFile)) {
+          if (existsSync20(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -8382,7 +8735,7 @@ async function handleRequest(req) {
           persistSessionRegistry();
         }
         const { sessionDir: sessionDir2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        rmSync7(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
+        rmSync8(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
         return { ok: true };
       }
       case "pane-exited": {
@@ -8409,9 +8762,26 @@ async function handleRequest(req) {
         await updateSession(tracking.cwd, req.sessionId, { effort: req.effort });
         return { ok: true };
       }
+      case "set-dangerous-mode": {
+        const tracking = sessionTrackingMap.get(req.sessionId);
+        if (!tracking) return unknownSessionError(req.sessionId);
+        await updateSession(tracking.cwd, req.sessionId, { dangerousMode: req.enabled });
+        let flushed = 0;
+        if (req.enabled) {
+          for (const askId of listAsks(tracking.cwd, req.sessionId)) {
+            const meta = readMeta(tracking.cwd, req.sessionId, askId);
+            if (!meta) continue;
+            if (meta.status !== "pending" && meta.status !== "in-progress") continue;
+            if (meta.orphaned) continue;
+            const ok = await autoResolveAsk(tracking.cwd, req.sessionId, askId);
+            if (ok) flushed += 1;
+          }
+        }
+        return { ok: true, data: { enabled: req.enabled, flushed } };
+      }
       case "set-upload-status": {
         const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-        if (!existsSync19(stateFile)) {
+        if (!existsSync20(stateFile)) {
           return unknownSessionError(req.sessionId);
         }
         try {
@@ -8434,19 +8804,19 @@ async function handleRequest(req) {
         const source = req.source ?? { type: "user" };
         const summary = req.content.length > 200 ? req.content.slice(0, 200) + "..." : req.content;
         if (req.agentId) {
-          const dir = join18(messagesDir(tracking.cwd, req.sessionId), req.agentId);
-          mkdirSync10(dir, { recursive: true });
-          const filePath2 = join18(dir, `${id}.md`);
-          writeFileSync14(filePath2, req.content, "utf-8");
+          const dir = join19(messagesDir(tracking.cwd, req.sessionId), req.agentId);
+          mkdirSync11(dir, { recursive: true });
+          const filePath2 = join19(dir, `${id}.md`);
+          writeFileSync15(filePath2, req.content, "utf-8");
           emitHistoryEvent(req.sessionId, "message", { source: source.type, agentId: req.agentId, content: req.content });
           return { ok: true };
         }
         let filePath;
         if (req.content.length > 200) {
           const dir = messagesDir(tracking.cwd, req.sessionId);
-          mkdirSync10(dir, { recursive: true });
-          filePath = join18(dir, `${id}.md`);
-          writeFileSync14(filePath, req.content, "utf-8");
+          mkdirSync11(dir, { recursive: true });
+          filePath = join19(dir, `${id}.md`);
+          writeFileSync15(filePath, req.content, "utf-8");
         }
         await appendMessage(tracking.cwd, req.sessionId, {
           id,
@@ -8622,9 +8992,9 @@ async function handleRequest(req) {
   }
 }
 function startServer() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const sock = socketPath();
-    if (existsSync19(sock)) {
+    if (existsSync20(sock)) {
       unlinkSync3(sock);
     }
     server = createServer((conn) => {
@@ -8667,23 +9037,23 @@ function startServer() {
       } catch {
       }
       console.log(`[sisyphus] Daemon listening on ${sock}`);
-      resolve11(server);
+      resolve12(server);
     });
   });
 }
 function stopServer() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     if (!server) {
-      resolve11();
+      resolve12();
       return;
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync19(sock)) {
+      if (existsSync20(sock)) {
         unlinkSync3(sock);
       }
       server = null;
-      resolve11();
+      resolve12();
     });
   });
 }
@@ -8691,7 +9061,7 @@ function stopServer() {
 // src/daemon/heartbeat-asks.ts
 import { ulid as ulid3 } from "ulid";
 init_paths();
-import { existsSync as existsSync20 } from "fs";
+import { existsSync as existsSync21 } from "fs";
 var HEARTBEAT_ASKED_BY2 = "system:heartbeat";
 var HEARTBEAT_THRESHOLD_MS = 60 * 60 * 1e3;
 var HEARTBEAT_SCAN_INTERVAL_MS = 15 * 60 * 1e3;
@@ -8774,7 +9144,7 @@ async function scanSessionForStaleAsks(cwd, sessionId) {
 async function scanAllSessionsForStaleAsks() {
   const reg = loadSessionRegistry();
   for (const [sessionId, cwd] of Object.entries(reg)) {
-    if (!existsSync20(statePath(cwd, sessionId))) continue;
+    if (!existsSync21(statePath(cwd, sessionId))) continue;
     try {
       await scanSessionForStaleAsks(cwd, sessionId);
     } catch (err) {
@@ -8829,15 +9199,15 @@ var DEFAULT_STATUS_BAR_CONFIG = {
 };
 
 // src/daemon/segments/compositor.ts
-import { readFileSync as readFileSync21, existsSync as existsSync21 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync22, existsSync as existsSync22 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join20 } from "path";
 var STATUS_BAR_BG = "#1d1e21";
-var SESSION_ORDER_PATH = join19(homedir7(), ".config", "tmux", "session-order");
+var SESSION_ORDER_PATH = join20(homedir8(), ".config", "tmux", "session-order");
 function getSessionOrder() {
   try {
-    if (!existsSync21(SESSION_ORDER_PATH)) return [];
-    return readFileSync21(SESSION_ORDER_PATH, "utf-8").split("\n").filter(Boolean);
+    if (!existsSync22(SESSION_ORDER_PATH)) return [];
+    return readFileSync22(SESSION_ORDER_PATH, "utf-8").split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -9374,8 +9744,8 @@ function writeEmptyManifest() {
 // src/daemon/updater.ts
 init_paths();
 import { execSync as execSync6 } from "child_process";
-import { writeFileSync as writeFileSync15, unlinkSync as unlinkSync4, lstatSync as lstatSync2 } from "fs";
-import { resolve as resolve9 } from "path";
+import { writeFileSync as writeFileSync16, unlinkSync as unlinkSync4, lstatSync as lstatSync2 } from "fs";
+import { resolve as resolve10 } from "path";
 import { get } from "https";
 function isNewer(latest, current) {
   const a = latest.split(".").map(Number);
@@ -9389,10 +9759,10 @@ function isNewer(latest, current) {
   return false;
 }
 function checkForUpdate() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const timeout = setTimeout(() => {
       console.error("[sisyphus] Update check timed out (5s)");
-      resolve11(null);
+      resolve12(null);
     }, 5e3);
     const req = get("https://registry.npmjs.org/sisyphi/latest", (res) => {
       let data = "";
@@ -9404,26 +9774,26 @@ function checkForUpdate() {
         try {
           const { version: latest } = JSON.parse(data);
           if (latest && isNewer(latest, getSisyphusVersion())) {
-            resolve11({ current: getSisyphusVersion(), latest });
+            resolve12({ current: getSisyphusVersion(), latest });
           } else {
-            resolve11(null);
+            resolve12(null);
           }
         } catch (err) {
           console.error("[sisyphus] Failed to parse registry response:", err);
-          resolve11(null);
+          resolve12(null);
         }
       });
     });
     req.on("error", (err) => {
       clearTimeout(timeout);
       console.error("[sisyphus] Update check failed:", err.message);
-      resolve11(null);
+      resolve12(null);
     });
   });
 }
 function applyUpdate(expectedVersion) {
   try {
-    const nodeDir = resolve9(process.execPath, "..");
+    const nodeDir = resolve10(process.execPath, "..");
     const env = { ...process.env, PATH: `${nodeDir}:${process.env.PATH ?? ""}` };
     execSync6("npm install -g sisyphi", { timeout: 15e3, stdio: "pipe", env });
     const result = execSync6("npm ls -g sisyphi --json --depth=0", {
@@ -9445,7 +9815,7 @@ function applyUpdate(expectedVersion) {
 }
 function markUpdating(version) {
   try {
-    writeFileSync15(daemonUpdatingPath(), version, "utf-8");
+    writeFileSync16(daemonUpdatingPath(), version, "utf-8");
   } catch {
   }
 }
@@ -9457,9 +9827,9 @@ function clearUpdating() {
 }
 function isLinkedInstall() {
   try {
-    const nodeDir = resolve9(process.execPath, "..");
+    const nodeDir = resolve10(process.execPath, "..");
     const globalPrefix = execSync6("npm prefix -g", { timeout: 5e3, encoding: "utf-8", env: { ...process.env, PATH: `${nodeDir}:${process.env.PATH ?? ""}` } }).trim();
-    const globalPkgDir = resolve9(globalPrefix, "lib", "node_modules", "sisyphi");
+    const globalPkgDir = resolve10(globalPrefix, "lib", "node_modules", "sisyphi");
     return lstatSync2(globalPkgDir).isSymbolicLink();
   } catch {
     return false;
@@ -9501,48 +9871,48 @@ function stopPeriodicUpdateCheck() {
 }
 
 // src/daemon/plugin-install.ts
-import { copyFileSync as copyFileSync4, mkdirSync as mkdirSync11, readdirSync as readdirSync12, statSync as statSync3, existsSync as existsSync22, readFileSync as readFileSync22, chmodSync as chmodSync2 } from "fs";
-import { join as join20, resolve as resolve10 } from "path";
-import { homedir as homedir8 } from "os";
+import { copyFileSync as copyFileSync5, mkdirSync as mkdirSync12, readdirSync as readdirSync13, statSync as statSync4, existsSync as existsSync23, readFileSync as readFileSync23, chmodSync as chmodSync2 } from "fs";
+import { join as join21, resolve as resolve11 } from "path";
+import { homedir as homedir9 } from "os";
 var PLUGIN_NAME = "sisyphus-tmux";
-var INSTALL_DIR = join20(homedir8(), ".claude", "plugins", PLUGIN_NAME);
+var INSTALL_DIR = join21(homedir9(), ".claude", "plugins", PLUGIN_NAME);
 function copyDir(src, dest) {
-  mkdirSync11(dest, { recursive: true });
-  for (const entry of readdirSync12(src)) {
-    const srcPath = join20(src, entry);
-    const destPath = join20(dest, entry);
-    if (statSync3(srcPath).isDirectory()) {
+  mkdirSync12(dest, { recursive: true });
+  for (const entry of readdirSync13(src)) {
+    const srcPath = join21(src, entry);
+    const destPath = join21(dest, entry);
+    if (statSync4(srcPath).isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      const srcMtime = statSync3(srcPath).mtimeMs;
-      const destMtime = existsSync22(destPath) ? statSync3(destPath).mtimeMs : 0;
+      const srcMtime = statSync4(srcPath).mtimeMs;
+      const destMtime = existsSync23(destPath) ? statSync4(destPath).mtimeMs : 0;
       if (srcMtime > destMtime) {
-        copyFileSync4(srcPath, destPath);
+        copyFileSync5(srcPath, destPath);
       }
     }
   }
 }
 function pluginNeedsUpdate(sourceDir) {
-  const srcHooks = join20(sourceDir, "hooks", "hooks.json");
-  const destHooks = join20(INSTALL_DIR, "hooks", "hooks.json");
-  if (!existsSync22(destHooks)) return true;
+  const srcHooks = join21(sourceDir, "hooks", "hooks.json");
+  const destHooks = join21(INSTALL_DIR, "hooks", "hooks.json");
+  if (!existsSync23(destHooks)) return true;
   try {
-    return readFileSync22(srcHooks, "utf-8") !== readFileSync22(destHooks, "utf-8");
+    return readFileSync23(srcHooks, "utf-8") !== readFileSync23(destHooks, "utf-8");
   } catch {
     return true;
   }
 }
 function installPlugin() {
-  const sourceDir = resolve10(import.meta.dirname, "../templates/sisyphus-tmux-plugin");
-  if (!existsSync22(sourceDir)) {
+  const sourceDir = resolve11(import.meta.dirname, "../templates/sisyphus-tmux-plugin");
+  if (!existsSync23(sourceDir)) {
     console.error(`[plugin-install] Source dir not found: ${sourceDir}`);
     return;
   }
   if (!pluginNeedsUpdate(sourceDir)) return;
   try {
     copyDir(sourceDir, INSTALL_DIR);
-    const hookScript = join20(INSTALL_DIR, "hooks", "tmux-state.sh");
-    if (existsSync22(hookScript)) {
+    const hookScript = join21(INSTALL_DIR, "hooks", "tmux-state.sh");
+    if (existsSync23(hookScript)) {
       try {
         chmodSync2(hookScript, 493);
       } catch {
@@ -9566,12 +9936,12 @@ var origError = console.error.bind(console);
 console.log = (...args) => origLog(`[${ts()}]`, ...args);
 console.error = (...args) => origError(`[${ts()}]`, ...args);
 function ensureDirs() {
-  mkdirSync12(globalDir(), { recursive: true });
+  mkdirSync13(globalDir(), { recursive: true });
 }
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync23(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync24(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -9583,7 +9953,7 @@ function acquirePidLock() {
     console.error(`[sisyphus] Daemon already running (pid ${pid}). Use 'sisyphusd restart' or 'sisyphusd stop' first.`);
     process.exit(0);
   }
-  writeFileSync16(daemonPidPath(), String(process.pid), "utf-8");
+  writeFileSync17(daemonPidPath(), String(process.pid), "utf-8");
 }
 function isLaunchdManaged() {
   try {
@@ -9642,11 +10012,11 @@ async function recoverSessions() {
   let recovered = 0;
   for (const [sessionId, cwd] of entries) {
     const stateFile = statePath(cwd, sessionId);
-    if (!existsSync23(stateFile)) {
+    if (!existsSync24(stateFile)) {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync23(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync24(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
         resetAgentCounterFromState(sessionId, session.agents ?? []);