sisyphi 1.1.34 → 1.1.35

package/dist/cli.js

@@ -84,6 +84,9 @@ function askOutputPath(cwd, sessionId, askId) {
 function askVisualsDir(cwd, sessionId, askId) {
   return join(askEntryDir(cwd, sessionId, askId), "visuals");
 }
+function tmuxSessionName(cwd, sessionLabel) {
+  return `ssyph_${basename(cwd)}_${sessionLabel}`;
+}
 function sessionsManifestPath() {
   return join(globalDir(), "sessions-manifest.json");
 }
@@ -141,13 +144,34 @@ var init_paths = __esm({
   }
 });
 
+// src/shared/shell.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+function shellQuoteHomePath(path) {
+  if (path === "~") return "~";
+  if (path.startsWith("~/")) return `~/${shellQuote(path.slice(2))}`;
+  return shellQuote(path);
+}
+function validateRepoName(repo) {
+  return !repo.includes("/") && !repo.includes("\\") && !repo.includes("..");
+}
+function escapeAppleScript(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+var init_shell = __esm({
+  "src/shared/shell.ts"() {
+    "use strict";
+  }
+});
+
 // src/daemon/lib/atomic.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { dirname as dirname4, join as join8 } from "path";
+import { dirname as dirname4, join as join9 } from "path";
 import { renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
 function atomicWrite(filePath, data) {
   const dir = dirname4(filePath);
-  const tmpPath = join8(dir, `.atomic.${randomUUID2()}.tmp`);
+  const tmpPath = join9(dir, `.atomic.${randomUUID2()}.tmp`);
   writeFileSync4(tmpPath, data, "utf-8");
   renameSync2(tmpPath, filePath);
 }
@@ -176,6 +200,333 @@ var init_atomic = __esm({
   }
 });
 
+// src/shared/env.ts
+import { resolve as resolve3 } from "path";
+function augmentedPath() {
+  const rawPath = process.env["PATH"];
+  const basePath = rawPath !== void 0 && rawPath.length > 0 ? rawPath : "/usr/bin:/bin";
+  const home = process.env["HOME"];
+  const candidates = [
+    ...home ? [`${home}/.local/bin`] : [],
+    // Claude CLI, pipx, user-local installs
+    resolve3(process.execPath, ".."),
+    // Node.js bin dir (ensures node/npm available)
+    "/opt/homebrew/bin",
+    // Homebrew (Apple Silicon macOS)
+    "/opt/homebrew/sbin",
+    // Homebrew sbin
+    "/usr/local/bin",
+    // Homebrew (Intel macOS), manual installs
+    "/usr/local/sbin",
+    // Manual installs
+    "/opt/local/bin",
+    // MacPorts
+    "/opt/local/sbin",
+    // MacPorts
+    "/home/linuxbrew/.linuxbrew/bin"
+    // Linuxbrew
+  ];
+  const nixProfile = process.env["NIX_PROFILES"];
+  if (nixProfile) {
+    for (const p of nixProfile.split(" ").reverse()) {
+      candidates.push(`${p}/bin`);
+    }
+  }
+  const existing = new Set(basePath.split(":"));
+  const prepend = candidates.filter((dir) => !existing.has(dir));
+  return prepend.length > 0 ? `${prepend.join(":")}:${basePath}` : basePath;
+}
+function execEnv() {
+  return {
+    ...process.env,
+    PATH: augmentedPath()
+  };
+}
+var init_env = __esm({
+  "src/shared/env.ts"() {
+    "use strict";
+  }
+});
+
+// src/shared/exec.ts
+import { execSync as execSync8 } from "child_process";
+function exec2(cmd, cwd, timeoutMs = 3e4) {
+  return execSync8(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, timeout: timeoutMs }).trim();
+}
+function execSafe(cmd, cwd, timeoutMs) {
+  try {
+    return execSync8(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, stdio: ["pipe", "pipe", "pipe"], timeout: timeoutMs }).trim();
+  } catch {
+    return null;
+  }
+}
+var EXEC_ENV;
+var init_exec = __esm({
+  "src/shared/exec.ts"() {
+    "use strict";
+    init_env();
+    EXEC_ENV = execEnv();
+  }
+});
+
+// src/tui/lib/tmux.ts
+var tmux_exports = {};
+__export(tmux_exports, {
+  editInPopup: () => editInPopup,
+  getWindowId: () => getWindowId,
+  listAllWindowIds: () => listAllWindowIds,
+  openClaudeResumePopup: () => openClaudeResumePopup,
+  openClaudeResumeSession: () => openClaudeResumeSession,
+  openCompanionPane: () => openCompanionPane,
+  openEditorPopup: () => openEditorPopup,
+  openInFileManager: () => openInFileManager,
+  openLogPopup: () => openLogPopup,
+  openShellPopup: () => openShellPopup,
+  paneExists: () => paneExists,
+  promptInPopup: () => promptInPopup,
+  registerDashboardWindow: () => registerDashboardWindow,
+  selectPane: () => selectPane,
+  selectWindow: () => selectWindow,
+  switchToSession: () => switchToSession,
+  windowExists: () => windowExists
+});
+import { execSync as execSync17 } from "child_process";
+import { join as join27 } from "path";
+import { readFileSync as readFileSync29, writeFileSync as writeFileSync16, mkdtempSync, rmSync as rmSync6, cpSync as cpSync3, existsSync as existsSync26, mkdirSync as mkdirSync13 } from "fs";
+import { tmpdir as tmpdir3 } from "os";
+function getWindowId() {
+  const pane = process.env["TMUX_PANE"];
+  if (pane) {
+    return exec2(`tmux display-message -t ${shellQuote(pane)} -p "#{window_id}"`);
+  }
+  return exec2('tmux display-message -p "#{window_id}"');
+}
+function selectWindow(windowId) {
+  execSafe(`tmux select-window -t ${shellQuote(windowId)}`);
+}
+function selectPane(paneId) {
+  execSafe(`tmux select-pane -t ${shellQuote(paneId)}`);
+}
+function windowExists(windowId) {
+  return execSafe(`tmux display-message -t ${shellQuote(windowId)} -p "#{window_id}"`) !== null;
+}
+function listAllWindowIds() {
+  try {
+    const output = execSync17('tmux list-windows -a -F "#{window_id}"', { encoding: "utf-8", env: EXEC_ENV });
+    return new Set(output.trim().split("\n").filter(Boolean));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function registerDashboardWindow(cwd) {
+  const wid = getWindowId();
+  const pane = process.env["TMUX_PANE"];
+  let sessionTarget = null;
+  if (pane) {
+    sessionTarget = execSafe(`tmux display-message -t ${shellQuote(pane)} -p "#{session_id}"`)?.trim() || null;
+  }
+  if (sessionTarget) {
+    execSafe(`tmux set-option -t ${shellQuote(sessionTarget)} @sisyphus_dashboard ${wid}`);
+  } else {
+    execSafe(`tmux set-option @sisyphus_dashboard ${wid}`);
+  }
+  if (cwd) {
+    const normalizedCwd = cwd.replace(/\/+$/, "");
+    const target = sessionTarget;
+    const existing = target ? execSafe(`tmux show-options -t ${shellQuote(target)} -v @sisyphus_cwd`)?.trim() : execSafe(`tmux show-options -v @sisyphus_cwd`)?.trim();
+    if (!existing) {
+      if (target) {
+        execSafe(`tmux set-option -t ${shellQuote(target)} @sisyphus_cwd ${shellQuote(normalizedCwd)}`);
+      } else {
+        execSafe(`tmux set-option @sisyphus_cwd ${shellQuote(normalizedCwd)}`);
+      }
+    }
+  }
+}
+function setupCompanionPlugin() {
+  const srcDir = join27(import.meta.dirname, "templates", "companion-plugin");
+  const destDir = join27(globalDir(), "companion-plugin");
+  if (!existsSync26(destDir)) mkdirSync13(destDir, { recursive: true });
+  cpSync3(srcDir, destDir, { recursive: true });
+  return destDir;
+}
+function paneExists(paneId) {
+  return execSafe(`tmux display-message -t ${shellQuote(paneId)} -p "#{pane_id}"`) !== null;
+}
+function findCompanionPaneForCwd(normalizedCwd) {
+  const out = execSafe(`tmux list-panes -aF "#{pane_id}	#{@sisyphus_companion}"`);
+  if (!out) return null;
+  for (const line of out.split("\n")) {
+    const tabIdx = line.indexOf("	");
+    if (tabIdx < 0) continue;
+    const paneId = line.slice(0, tabIdx);
+    const marker = line.slice(tabIdx + 1);
+    if (paneId && marker === normalizedCwd) return paneId;
+  }
+  return null;
+}
+function openCompanionPane(cwd) {
+  const normalizedCwd = cwd.replace(/\/+$/, "");
+  const existing = findCompanionPaneForCwd(normalizedCwd);
+  if (existing) {
+    execSafe(`tmux select-pane -t ${shellQuote(existing)}`);
+    return;
+  }
+  const pluginDir = setupCompanionPlugin();
+  const templatePath2 = join27(import.meta.dirname, "templates", "dashboard-claude.md");
+  let template;
+  try {
+    template = readFileSync29(templatePath2, "utf-8");
+  } catch {
+    template = `You are a Sisyphus dashboard companion. Help the user manage multi-agent sessions.
+Project: ${cwd}
+Run \`sis list\` and \`sis status\` to see current state.`;
+  }
+  const rendered = template.replace(/\{\{CWD\}\}/g, cwd);
+  const promptPath = join27(globalDir(), "dashboard-companion-prompt.md");
+  writeFileSync16(promptPath, rendered, "utf-8");
+  const pathEnv = augmentedPath();
+  const claudeCmd = `SISYPHUS_COMPANION_CWD=${shellQuote(cwd)} PATH=${shellQuote(pathEnv)} claude --dangerously-skip-permissions --plugin-dir ${shellQuote(pluginDir)} --append-system-prompt "$(cat ${shellQuote(promptPath)})"`;
+  const result = exec2(
+    `tmux split-window -h -l 33% -P -F "#{pane_id}" -c ${shellQuote(cwd)} ${shellQuote(claudeCmd)}`
+  );
+  const newPaneId = result.trim();
+  if (newPaneId) {
+    execSafe(`tmux set-option -p -t ${shellQuote(newPaneId)} @sisyphus_companion ${shellQuote(normalizedCwd)}`);
+  }
+}
+function switchToSession(sessionName) {
+  execSafe(`tmux switch-client -t ${shellQuote(sessionName)}`);
+}
+function editInPopup(cwd, editor, opts) {
+  const tmpDir = mkdtempSync(join27(tmpdir3(), "sisyphus-"));
+  const filePath = join27(tmpDir, "input.md");
+  try {
+    writeFileSync16(filePath, opts?.content ? opts.content : "", "utf-8");
+    openEditorPopup(cwd, editor, filePath, opts?.size);
+    const result = readFileSync29(filePath, "utf-8").trim();
+    return result || null;
+  } finally {
+    rmSync6(tmpDir, { recursive: true, force: true });
+  }
+}
+function promptInPopup(prompt, opts) {
+  const { w = "50%", h = "3" } = opts ?? {};
+  const tmpDir = mkdtempSync(join27(tmpdir3(), "sisyphus-"));
+  const outFile = join27(tmpDir, "result");
+  try {
+    const script = `printf ${shellQuote(prompt + " ")} && read -r line && printf '%s' "$line" > ${shellQuote(outFile)}`;
+    execSync17(
+      `tmux display-popup -E -w ${w} -h ${h} ${shellQuote(`bash -c ${shellQuote(script)}`)}`,
+      { stdio: "inherit", env: EXEC_ENV }
+    );
+    if (!existsSync26(outFile)) return null;
+    const result = readFileSync29(outFile, "utf-8").trim();
+    return result || null;
+  } finally {
+    rmSync6(tmpDir, { recursive: true, force: true });
+  }
+}
+function openLogPopup() {
+  execSync17(
+    `tmux display-popup -E -w 90% -h 80% ${shellQuote("tail -f ~/.sisyphus/daemon.log")}`,
+    { stdio: "inherit", env: EXEC_ENV }
+  );
+}
+function openShellPopup(cwd, command) {
+  execSync17(
+    `tmux display-popup -E -w 90% -h 80% -d ${shellQuote(cwd)} ${shellQuote(`sh -c '${command.replace(/'/g, "'\\''")}; echo; echo "Press enter to close"; read'`)}`,
+    { stdio: "inherit", env: EXEC_ENV }
+  );
+}
+function openInFileManager(path) {
+  execSync17(`open ${shellQuote(path)}`, { stdio: "inherit", env: EXEC_ENV });
+}
+function openClaudeResumePopup(cwd, claudeSessionId, resumeEnv, resumeArgs) {
+  const pathEnv = augmentedPath();
+  const envPrefix = resumeEnv ? `${resumeEnv} && ` : "";
+  const args2 = resumeArgs ? `${resumeArgs} --resume ${shellQuote(claudeSessionId)}` : `--resume ${shellQuote(claudeSessionId)}`;
+  const cmd = `${envPrefix}PATH=${shellQuote(pathEnv)} claude ${args2}`;
+  execSync17(
+    `tmux display-popup -E -w 90% -h 80% -d ${shellQuote(cwd)} ${shellQuote(cmd)}`,
+    { stdio: "inherit", env: EXEC_ENV }
+  );
+}
+function openClaudeResumeSession(cwd, sessionId, claudeSessionId, sessionLabel, resumeEnv, resumeArgs, cycleNum, mode) {
+  const sessionName = tmuxSessionName(cwd, sessionLabel);
+  const cycleLabel = cycleNum != null ? `c${cycleNum}` : "";
+  const paneTitle = cycleLabel ? `ssph:orch ${sessionLabel} ${cycleLabel}` : `ssph:orch ${sessionLabel}`;
+  const existing = execSafe('tmux list-sessions -F "#{session_id}|#{session_name}"');
+  const existingLine = existing?.split("\n").find((line) => line.slice(line.indexOf("|") + 1) === sessionName);
+  if (existingLine) {
+    const existingSessId = existingLine.slice(0, existingLine.indexOf("|"));
+    execSafe(`tmux set-option -t ${shellQuote(existingSessId)} @sisyphus_cwd ${shellQuote(cwd.replace(/\/+$/, ""))}`);
+    execSafe(`tmux set-option -t ${shellQuote(existingSessId)} @sisyphus_session_id ${shellQuote(sessionId)}`);
+    const firstPaneId2 = execSafe(`tmux list-panes -t ${shellQuote(existingSessId)} -F '#{pane_id}'`)?.split("\n")[0];
+    if (firstPaneId2) applyOrchestratorPaneStyle(firstPaneId2, paneTitle, sessionLabel, cycleLabel, mode);
+    return sessionName;
+  }
+  const pathEnv = augmentedPath();
+  const envPrefix = resumeEnv ? `${resumeEnv} && ` : "";
+  const args2 = resumeArgs ? `${resumeArgs} --resume ${shellQuote(claudeSessionId)}` : `--resume ${shellQuote(claudeSessionId)}`;
+  const cmd = `${envPrefix}PATH=${shellQuote(pathEnv)} claude ${args2}`;
+  const createOut = exec2(`tmux new-session -d -s ${shellQuote(sessionName)} -n main -c ${shellQuote(cwd)} -P -F '#{session_id}|#{pane_id}' ${shellQuote(cmd)}`).trim();
+  const pipeIdx = createOut.indexOf("|");
+  const newSessId = createOut.slice(0, pipeIdx);
+  const firstPaneId = createOut.slice(pipeIdx + 1);
+  execSafe(`tmux set-option -t ${shellQuote(newSessId)} @sisyphus_cwd ${shellQuote(cwd.replace(/\/+$/, ""))}`);
+  execSafe(`tmux set-option -t ${shellQuote(newSessId)} @sisyphus_session_id ${shellQuote(sessionId)}`);
+  execSafe(`tmux set -w -t ${shellQuote(newSessId + ":")} pane-border-status top`);
+  execSafe(`tmux set -w -t ${shellQuote(newSessId + ":")} allow-rename off`);
+  execSafe(`tmux set -w -t ${shellQuote(newSessId + ":")} automatic-rename off`);
+  if (firstPaneId) applyOrchestratorPaneStyle(firstPaneId, paneTitle, sessionLabel, cycleLabel, mode);
+  return sessionName;
+}
+function applyOrchestratorPaneStyle(paneId, title, sessionLabel, cycleLabel, mode) {
+  const color = "yellow";
+  execSafe(`tmux select-pane -t ${shellQuote(paneId)} -T ${shellQuote(title)}`);
+  execSafe(`tmux set -p -t ${shellQuote(paneId)} @pane_role ${shellQuote("orch")}`);
+  execSafe(`tmux set -p -t ${shellQuote(paneId)} @pane_session ${shellQuote(sessionLabel)}`);
+  if (cycleLabel) execSafe(`tmux set -p -t ${shellQuote(paneId)} @pane_cycle ${shellQuote(cycleLabel)}`);
+  if (mode) execSafe(`tmux set -p -t ${shellQuote(paneId)} @pane_mode ${shellQuote(mode)}`);
+  const gitBranch = `#(cd #{pane_current_path} && git branch --show-current 2>/dev/null)`;
+  const branchSuffix = `#(cd #{pane_current_path} && git branch --show-current 2>/dev/null | grep -q . && echo ' |') ${gitBranch}`;
+  const homePath = `#(echo '#{pane_current_path}' | sed "s|^$HOME|~|")`;
+  const modeSegment = `#{?#{@pane_mode}, #[fg=${color}\\,italics]#{@pane_mode}#[default],}`;
+  const fmt = [
+    `#[bg=${color},fg=black,bold] #{@pane_role} #[default]`,
+    ` #[fg=${color},bold]#{@pane_session}`,
+    modeSegment,
+    ` #[default,dim]#{@pane_cycle}`,
+    `  ${homePath}${branchSuffix}`,
+    `#[default]`
+  ].join("");
+  execSafe(`tmux set -p -t ${shellQuote(paneId)} pane-border-format ${shellQuote(fmt)}`);
+}
+function openEditorPopup(cwd, editor, filePath, size) {
+  const { w = "90%", h = "90%" } = size ?? {};
+  const editorBin = editor.split(/\s+/)[0].split("/").pop();
+  if (TERMINAL_EDITORS.has(editorBin)) {
+    execSync17(
+      `tmux display-popup -E -w ${w} -h ${h} -d ${shellQuote(cwd)} ${shellQuote(`${editor} ${shellQuote(filePath)}`)}`,
+      { stdio: "inherit", env: EXEC_ENV }
+    );
+  } else {
+    execSync17(`${editor} ${shellQuote(filePath)}`, { stdio: "inherit", cwd, env: EXEC_ENV });
+  }
+}
+var TERMINAL_EDITORS;
+var init_tmux = __esm({
+  "src/tui/lib/tmux.ts"() {
+    "use strict";
+    init_paths();
+    init_env();
+    init_shell();
+    init_exec();
+    TERMINAL_EDITORS = /* @__PURE__ */ new Set(["nvim", "vim", "vi", "nano", "emacs", "micro", "helix", "hx", "joe", "ne", "kak"]);
+  }
+});
+
 // src/cli/deploy/creds.ts
 var creds_exports = {};
 __export(creds_exports, {
@@ -188,14 +539,14 @@ __export(creds_exports, {
   readTailscaleEnv: () => readTailscaleEnv,
   writeTailscaleEnv: () => writeTailscaleEnv
 });
-import { chmodSync as chmodSync3, existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync27 } from "fs";
+import { chmodSync as chmodSync3, existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync30 } from "fs";
 import { createInterface as createInterface4 } from "readline";
 function isValidProvider(value) {
   return PROVIDERS.includes(value);
 }
 function ensureDeployDir() {
   const dir = deployDir();
-  if (!existsSync24(dir)) mkdirSync12(dir, { recursive: true, mode: 448 });
+  if (!existsSync27(dir)) mkdirSync14(dir, { recursive: true, mode: 448 });
 }
 function parseEnvFile(text) {
   const out = {};
@@ -221,8 +572,8 @@ function serializeEnvFile(values) {
   return lines.join("\n") + "\n";
 }
 function readEnvFile(path) {
-  if (!existsSync24(path)) return null;
-  return parseEnvFile(readFileSync27(path, "utf-8"));
+  if (!existsSync27(path)) return null;
+  return parseEnvFile(readFileSync30(path, "utf-8"));
 }
 function writeEnvFile(path, values) {
   ensureDeployDir();
@@ -317,8 +668,8 @@ var init_creds = __esm({
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { existsSync as existsSync30, mkdirSync as mkdirSync14, readFileSync as readFileSync31 } from "fs";
-import { dirname as dirname12, join as join27 } from "path";
+import { existsSync as existsSync33, mkdirSync as mkdirSync16, readFileSync as readFileSync34 } from "fs";
+import { dirname as dirname12, join as join30 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/cli/commands/start.ts
@@ -366,18 +717,18 @@ function rawSend(request, timeoutMs = 1e4) {
 // src/cli/install.ts
 init_paths();
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { connect as connect2 } from "net";
-import { homedir as homedir4 } from "os";
-import { dirname, join as join4, resolve } from "path";
+import { homedir as homedir5 } from "os";
+import { dirname, join as join5, resolve } from "path";
 import { fileURLToPath } from "url";
 
 // src/cli/tmux-setup.ts
 init_paths();
 import { execSync } from "child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, unlinkSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync, chmodSync, unlinkSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
 import { createInterface } from "readline";
 
 // src/shared/keymap.ts
@@ -438,7 +789,8 @@ var KEYMAP = {
       { key: "/", label: "  Search / filter", action: { type: "script", name: "sisyphus-search-reports" }, tuiAction: "search" },
       { key: " ", label: "  Open popup explicitly", action: { type: "tui", action: "show-leader" } },
       { key: "y", label: "  Yank \u203A", action: { type: "submenu", ref: "copy" } },
-      { key: "c", label: "  Companion \u203A", action: { type: "submenu", ref: "companion" } },
+      { key: "c", label: "  Side claude pane", action: { type: "script", name: "sisyphus-companion-pane" }, tuiAction: "companion-pane" },
+      { key: "C", label: "  Companion (gamification) \u203A", action: { type: "submenu", ref: "companion" } },
       { key: "o", label: "  Open \u203A", action: { type: "submenu", ref: "open" } },
       { key: "a", label: "  Agent \u203A", action: { type: "submenu", ref: "agent" } },
       { key: "S", label: "  Session \u203A", action: { type: "submenu", ref: "session" } },
@@ -450,8 +802,7 @@ var KEYMAP = {
       title: " Companion ",
       items: [
         { key: "p", label: "  profile (overlay)", action: { type: "tui", action: "companion-overlay" } },
-        { key: "d", label: "  debug (mood signals)", action: { type: "tui", action: "companion-debug" } },
-        { key: "t", label: "  open in tmux pane", action: { type: "tui", action: "companion-pane" } }
+        { key: "d", label: "  debug (mood signals)", action: { type: "tui", action: "companion-debug" } }
       ]
     },
     copy: {
@@ -521,22 +872,41 @@ var KEYMAP = {
   }
 };
 
+// src/shared/sisyphus-init-lua.ts
+import { mkdirSync, existsSync, cpSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var initLuaEnsured = false;
+function ensureSisyphusInitLua() {
+  if (initLuaEnsured) return;
+  initLuaEnsured = true;
+  try {
+    const destDir = join2(homedir2(), ".config", "sisyphus");
+    const destPath = join2(destDir, "init.lua");
+    if (existsSync(destPath)) return;
+    mkdirSync(destDir, { recursive: true });
+    const srcPath = join2(import.meta.dirname, "templates", "sisyphus-init.lua");
+    cpSync(srcPath, destPath);
+  } catch {
+  }
+}
+
 // src/cli/tmux-setup.ts
 var DEFAULT_CYCLE_KEY = "M-s";
 var DEFAULT_PREFIX_KEY = "C-s";
 var KEY_TABLE = "sisyphus";
 var SISYPHUS_CONF_MARKER = "# sisyphus-managed \u2014 do not edit";
 function scriptPath(name) {
-  return join2(globalDir(), "bin", name);
+  return join3(globalDir(), "bin", name);
 }
 function cycleScriptPath() {
   return scriptPath("sisyphus-cycle");
 }
 function keymapJsonPath() {
-  return join2(globalDir(), "keymap.json");
+  return join3(globalDir(), "keymap.json");
 }
 function writeKeymapJson() {
-  mkdirSync(globalDir(), { recursive: true });
+  mkdirSync2(globalDir(), { recursive: true });
   writeFileSync(keymapJsonPath(), JSON.stringify(KEYMAP, null, 2), "utf8");
 }
 function tmuxVersionAtLeast(major, minor) {
@@ -553,7 +923,7 @@ function tmuxVersionAtLeast(major, minor) {
 function menuItemCommand(action, scriptsDir) {
   switch (action.type) {
     case "script":
-      return `run-shell ${join2(scriptsDir, action.name)}`;
+      return `run-shell ${join3(scriptsDir, action.name)}`;
     case "popup": {
       const { w, h, borderStyle, title, cwd } = action.popup;
       let args2 = "-E";
@@ -562,10 +932,10 @@ function menuItemCommand(action, scriptsDir) {
       if (borderStyle) args2 += ` -S '${borderStyle}'`;
       if (title) args2 += ` -T '${title}'`;
       if (cwd === "current") args2 += ` -d '#{pane_current_path}'`;
-      return `display-popup ${args2} ${join2(scriptsDir, action.name)}`;
+      return `display-popup ${args2} ${join3(scriptsDir, action.name)}`;
     }
     case "submenu":
-      return `run-shell ${join2(scriptsDir, `sisyphus-menu-${action.ref}`)}`;
+      return `run-shell ${join3(scriptsDir, `sisyphus-menu-${action.ref}`)}`;
     case "tmux":
       return action.cmd;
     case "tui":
@@ -591,13 +961,13 @@ function generateTopLevelBinding(prefixKey, def, scriptsDir) {
   return `bind-key -T root ${prefixKey} display-menu -T '${def.title}' -x R -y S ${args2}`;
 }
 function sisyphusTmuxConfPath() {
-  return join2(globalDir(), "tmux.conf");
+  return join3(globalDir(), "tmux.conf");
 }
 function userTmuxConfPath() {
-  const dotfile = join2(homedir2(), ".tmux.conf");
-  const xdg = join2(homedir2(), ".config", "tmux", "tmux.conf");
-  if (existsSync(xdg)) return xdg;
-  if (existsSync(dotfile)) return dotfile;
+  const dotfile = join3(homedir3(), ".tmux.conf");
+  const xdg = join3(homedir3(), ".config", "tmux", "tmux.conf");
+  if (existsSync2(xdg)) return xdg;
+  if (existsSync2(dotfile)) return dotfile;
   return null;
 }
 var CYCLE_SCRIPT = `#!/bin/bash
@@ -663,7 +1033,7 @@ resolve_home() {
   return 1
 }`.trim();
 function homeScript() {
-  const tuiPath = join2(import.meta.dirname, "tui.js");
+  const tuiPath = join3(import.meta.dirname, "tui.js");
   return `#!/bin/bash
 # Jump to the dashboard window for the home session matching this cwd.
 ${RESOLVE_HOME}
@@ -716,9 +1086,9 @@ fi
 `;
 var NEW_PROMPT_SCRIPT = `#!/bin/bash
 # Open nvim to compose a new sisyphus task, then start a session
-tmpfile=$(mktemp /tmp/sisyphus-new-XXXXXX.md)
+tmpfile=$(mktemp /tmp/sisyphus-new.XXXXXX)
 trap 'rm -f "$tmpfile"' EXIT
-nvim "$tmpfile"
+NVIM_APPNAME=sisyphus nvim "$tmpfile"
 grep -q '[^[:space:]]' "$tmpfile" || exit 0
 exec sis start "$(cat "$tmpfile")"
 `;
@@ -747,9 +1117,9 @@ fi
 
 [ -z "$session_id" ] && { echo "No active sisyphus session found"; sleep 1; exit 1; }
 
-tmpfile=$(mktemp /tmp/sisyphus-msg-XXXXXX.md)
+tmpfile=$(mktemp /tmp/sisyphus-msg.XXXXXX)
 trap 'rm -f "$tmpfile"' EXIT
-nvim "$tmpfile"
+NVIM_APPNAME=sisyphus nvim "$tmpfile"
 grep -q '[^[:space:]]' "$tmpfile" || exit 0
 exec sis message --session "$session_id" "$(cat "$tmpfile")"
 `;
@@ -806,6 +1176,12 @@ ${formatHelpForKeymap(KEYMAP)}
 EOF_HELP
 read -n 1 -s -r -p "  Press any key to close"
 `;
+var COMPANION_PANE_SCRIPT = `#!/bin/bash
+tmux_sid=$(tmux display-message -p '#{session_id}')
+cwd=$(tmux show-options -t "$tmux_sid" -v @sisyphus_cwd 2>/dev/null)
+[ -z "$cwd" ] && cwd=$(tmux display-message -p '#{pane_current_path}')
+exec sis companion pane --cwd "$cwd"
+`;
 var STATUS_POPUP_SCRIPT = `#!/bin/bash
 # Show session status \u2014 if no sisyphus session here, list all.
 # -t targeting uses $N session id \u2014 -t <name> can substring-match under sparse env.
@@ -1005,10 +1381,10 @@ ${SESSION_RESOLVE}
 short_id="\${session_id:0:8}"
 
 # Optional message \u2014 leave empty to resume with no extra instructions.
-tmpfile=$(mktemp /tmp/sisyphus-resume-XXXXXX.md)
+tmpfile=$(mktemp /tmp/sisyphus-resume.XXXXXX)
 trap 'rm -f "$tmpfile"' EXIT
 printf "# Resume session %s\\n# (Optional) Add follow-up instructions for the orchestrator below.\\n# Save & quit empty to resume with no message.\\n\\n" "$short_id" > "$tmpfile"
-nvim "$tmpfile"
+NVIM_APPNAME=sisyphus nvim "$tmpfile"
 
 # Strip comment + blank lines to detect empty submission
 body=$(grep -v '^[[:space:]]*#' "$tmpfile" | sed '/^[[:space:]]*$/d')
@@ -1099,10 +1475,10 @@ var SPAWN_AGENT_SCRIPT = `#!/bin/bash
 # Run from a sisyphus session pane, not the home dashboard.
 ${SESSION_RESOLVE}
 
-tmpfile=$(mktemp /tmp/sisyphus-spawn-XXXXXX.md)
+tmpfile=$(mktemp /tmp/sisyphus-spawn.XXXXXX)
 trap 'rm -f "$tmpfile"' EXIT
 printf "# Spawn agent in session %s\\n# Write the agent's instruction below. Empty = abort.\\n\\n" "\${session_id:0:8}" > "$tmpfile"
-nvim "$tmpfile"
+NVIM_APPNAME=sisyphus nvim "$tmpfile"
 
 body=$(grep -v '^[[:space:]]*#' "$tmpfile" | sed '/^[[:space:]]*$/d')
 [ -z "$body" ] && exit 0
@@ -1226,9 +1602,9 @@ else
   (( idx >= 0 && idx < \${#entries[@]} )) || exit 0
 fi
 
-tmpfile=$(mktemp /tmp/sisyphus-msg-agent-XXXX.md)
+tmpfile=$(mktemp /tmp/sisyphus-msg-agent.XXXXXX)
 trap 'rm -f "$tmpfile"' EXIT
-nvim "$tmpfile"
+NVIM_APPNAME=sisyphus nvim "$tmpfile"
 grep -q '[^[:space:]]' "$tmpfile" || exit 0
 exec sis message --session "$session_id" --agent "\${ids[$idx]}" "$(cat "$tmpfile")"
 `;
@@ -1668,12 +2044,13 @@ var OPEN_SCRATCH_SCRIPT = `#!/bin/bash
 exec sis admin scratch
 `;
 function installScript(name, content) {
-  mkdirSync(join2(globalDir(), "bin"), { recursive: true });
+  mkdirSync2(join3(globalDir(), "bin"), { recursive: true });
   const path = scriptPath(name);
   writeFileSync(path, content, "utf8");
   chmodSync(path, 493);
 }
 function installAllScripts() {
+  ensureSisyphusInitLua();
   installScript("sisyphus-cycle", CYCLE_SCRIPT);
   installScript("sisyphus-home", homeScript());
   installScript("sisyphus-kill-pane", KILL_PANE_SCRIPT);
@@ -1688,7 +2065,7 @@ function installAllScripts() {
   installScript("sisyphus-open-roadmap", OPEN_ROADMAP_SCRIPT);
   installScript("sisyphus-open-strategy", OPEN_STRATEGY_SCRIPT);
   installScript("sisyphus-export-session", EXPORT_SESSION_SCRIPT);
-  const scriptsDir = join2(globalDir(), "bin");
+  const scriptsDir = join3(globalDir(), "bin");
   for (const [id, def] of Object.entries(KEYMAP.submenus)) {
     installScript(`sisyphus-menu-${id}`, generateSubmenuScript(id, def, scriptsDir));
   }
@@ -1721,6 +2098,7 @@ function installAllScripts() {
   installScript("sisyphus-reconnect", RECONNECT_SCRIPT);
   installScript("sisyphus-open-scratch", OPEN_SCRATCH_SCRIPT);
   installScript("sisyphus-help", HELP_SCRIPT);
+  installScript("sisyphus-companion-pane", COMPANION_PANE_SCRIPT);
 }
 function getExistingBinding(key, table = "root") {
   try {
@@ -1770,18 +2148,43 @@ async function setupTmuxKeybind(cycleKey = DEFAULT_CYCLE_KEY, prefixKey = DEFAUL
       message: `tmux 3.2+ required for sisyphus keybindings; got ${version}`
     };
   }
-  for (const [label, key] of [["cycle", cycleKey], ["prefix", prefixKey]]) {
-    const existing = getExistingBinding(key);
-    if (existing !== null && !isSisyphusBinding(existing)) {
+  if (!opts.force) {
+    for (const [label, key] of [["cycle", cycleKey], ["prefix", prefixKey]]) {
+      const existing = getExistingBinding(key);
+      if (existing !== null && !isSisyphusBinding(existing)) {
+        return {
+          status: "conflict",
+          message: `Tmux key ${key} (${label}) is already bound to something else. Re-run with --force to overwrite, or pass an alternate cycle key (e.g. "sis admin setup-keybind M-w").`,
+          existingBinding: existing,
+          conflictKey: key
+        };
+      }
+    }
+  }
+  const userConfPreview = userTmuxConfPath();
+  const sisyphusConfPathPreview = sisyphusTmuxConfPath();
+  const markedSourceLinePreview = `source-file ${sisyphusConfPathPreview} ${SISYPHUS_CONF_MARKER}`;
+  if (userConfPreview !== null && !opts.force && !opts.assumeYes) {
+    let alreadySources = false;
+    try {
+      alreadySources = readFileSync(userConfPreview, "utf8").includes(sisyphusConfPathPreview);
+    } catch {
+    }
+    if (!alreadySources) {
       return {
-        status: "conflict",
-        message: `Tmux key ${key} (${label}) is already bound to something else. Run "sis admin setup-keybind <key>" to use a different key.`,
-        existingBinding: existing
+        status: "requires-force",
+        reason: "would-modify-user-conf",
+        userConf: userConfPreview,
+        manualLine: markedSourceLinePreview,
+        message: `Refusing to modify ${userConfPreview} without explicit consent.
+Re-run with --force (persist) or --yes (same effect, conf-append only) to append:
+  ${markedSourceLinePreview}
+Or run "sis admin check-keybinds" for the full decision tree (live-only install is also an option).`
       };
     }
   }
   writeKeymapJson();
-  const scriptsDir = join2(globalDir(), "bin");
+  const scriptsDir = join3(globalDir(), "bin");
   const bindings = [
     // C-s → display-menu top-level (descriptor-driven)
     generateTopLevelBinding(prefixKey, KEYMAP.topLevel, scriptsDir),
@@ -1803,7 +2206,7 @@ ${bindings.join("\n")}
     if (contents.includes(confPath)) {
       persistedToConf = true;
     } else {
-      const shouldAppend = opts.assumeYes ? true : await confirmConfAppend(userConf, markedSourceLine);
+      const shouldAppend = opts.assumeYes || opts.force ? true : await confirmConfAppend(userConf, markedSourceLine);
       if (shouldAppend) {
         const separator = contents.endsWith("\n") ? "" : "\n";
         writeFileSync(userConf, `${contents}${separator}${markedSourceLine}
@@ -1846,8 +2249,8 @@ Note: No tmux.conf found. Add this to your tmux config for persistence:
 }
 function removeTmuxKeybind() {
   const confPath = sisyphusTmuxConfPath();
-  for (const candidate of [join2(homedir2(), ".tmux.conf"), join2(homedir2(), ".config", "tmux", "tmux.conf")]) {
-    if (existsSync(candidate)) {
+  for (const candidate of [join3(homedir3(), ".tmux.conf"), join3(homedir3(), ".config", "tmux", "tmux.conf")]) {
+    if (existsSync2(candidate)) {
       const contents = readFileSync(candidate, "utf8");
       const filtered = contents.split("\n").filter((line) => !line.includes(confPath)).join("\n");
       if (filtered !== contents) {
@@ -1855,7 +2258,7 @@ function removeTmuxKeybind() {
       }
     }
   }
-  if (existsSync(confPath)) {
+  if (existsSync2(confPath)) {
     unlinkSync(confPath);
   }
   try {
@@ -1871,7 +2274,7 @@ function removeTmuxKeybind() {
   } catch {
   }
   const kmPath = keymapJsonPath();
-  if (existsSync(kmPath)) unlinkSync(kmPath);
+  if (existsSync2(kmPath)) unlinkSync(kmPath);
   const scripts = [
     "sisyphus-cycle",
     "sisyphus-home",
@@ -1922,7 +2325,7 @@ function removeTmuxKeybind() {
   ];
   for (const name of scripts) {
     const path = scriptPath(name);
-    if (existsSync(path)) unlinkSync(path);
+    if (existsSync2(path)) unlinkSync(path);
   }
 }
 
@@ -1987,10 +2390,10 @@ function loadConfig(cwd) {
 // src/daemon/plugins.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { execFileSync } from "child_process";
-import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
 function installedPluginsPath() {
-  return join3(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  return join4(homedir4(), ".claude", "plugins", "installed_plugins.json");
 }
 function resolveInstalledPlugin(name) {
   let data;
@@ -2071,10 +2474,10 @@ async function ensureRequiredPlugins(cwd) {
 var PLIST_LABEL = "com.sisyphus.daemon";
 var PLIST_FILENAME = `${PLIST_LABEL}.plist`;
 function launchAgentDir() {
-  return join4(homedir4(), "Library", "LaunchAgents");
+  return join5(homedir5(), "Library", "LaunchAgents");
 }
 function plistPath() {
-  return join4(launchAgentDir(), PLIST_FILENAME);
+  return join5(launchAgentDir(), PLIST_FILENAME);
 }
 function daemonBinPath() {
   const installDir = dirname(fileURLToPath(import.meta.url));
@@ -2105,7 +2508,7 @@ function generatePlist(nodePath, daemonPath, logPath) {
 `;
 }
 function isInstalled() {
-  return existsSync2(plistPath());
+  return existsSync3(plistPath());
 }
 async function ensureDaemonInstalled() {
   if (process.platform !== "darwin") return;
@@ -2114,8 +2517,8 @@ async function ensureDaemonInstalled() {
     const nodePath = process.execPath;
     const daemonPath = daemonBinPath();
     const logPath = daemonLogPath();
-    mkdirSync2(globalDir(), { recursive: true });
-    mkdirSync2(launchAgentDir(), { recursive: true });
+    mkdirSync3(globalDir(), { recursive: true });
+    mkdirSync3(launchAgentDir(), { recursive: true });
     const plist = generatePlist(nodePath, daemonPath, logPath);
     writeFileSync2(plistPath(), plist, "utf8");
     execSync3(`launchctl load -w ${plistPath()}`);
@@ -2131,7 +2534,7 @@ async function uninstallDaemon(purge) {
     return;
   }
   const plist = plistPath();
-  if (existsSync2(plist)) {
+  if (existsSync3(plist)) {
     try {
       execSync3(`launchctl unload -w ${plist}`, { stdio: "pipe" });
     } catch {
@@ -2144,7 +2547,7 @@ async function uninstallDaemon(purge) {
   removeTmuxKeybind();
   if (purge) {
     const dir = globalDir();
-    if (existsSync2(dir)) {
+    if (existsSync3(dir)) {
       rmSync(dir, { recursive: true, force: true });
       console.log(`Removed ${dir}`);
     }
@@ -2158,8 +2561,9 @@ function printGettingStarted(keybindResult, sisyphusPlugin) {
   ];
   if (keybindResult.status === "installed") {
     lines.push(`Tmux keybind: ${keybindResult.message}`, "");
-  } else if (keybindResult.status === "conflict") {
+  } else if (keybindResult.status === "conflict" || keybindResult.status === "requires-force") {
     lines.push(`Keybind: ${keybindResult.message}`, "");
+    lines.push("Run `sis admin check-keybinds` to see options, then `sis admin setup --force`.", "");
   } else if (keybindResult.status === "conf-modification-declined") {
     lines.push(keybindResult.message, "");
   }
@@ -2195,7 +2599,7 @@ async function waitForDaemon(maxWaitMs = 6e3) {
   let updatingLogged = false;
   while (Date.now() - start < maxWaitMs) {
     const updatingPath = daemonUpdatingPath();
-    if (existsSync2(updatingPath)) {
+    if (existsSync3(updatingPath)) {
       if (!updatingLogged) {
         try {
           const version = readFileSync4(updatingPath, "utf-8").trim();
@@ -2207,7 +2611,7 @@ async function waitForDaemon(maxWaitMs = 6e3) {
       }
       maxWaitMs = Math.max(maxWaitMs, 3e4);
     }
-    if (existsSync2(socketPath())) {
+    if (existsSync3(socketPath())) {
       try {
         await testConnection();
         return;
@@ -2322,25 +2726,13 @@ function getTmuxSessionInfo() {
   return { id: out.slice(0, pipeIdx), name: out.slice(pipeIdx + 1) };
 }
 
-// src/shared/shell.ts
-function shellQuote(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function shellQuoteHomePath(path) {
-  if (path === "~") return "~";
-  if (path.startsWith("~/")) return `~/${shellQuote(path.slice(2))}`;
-  return shellQuote(path);
-}
-function validateRepoName(repo) {
-  return !repo.includes("/") && !repo.includes("\\") && !repo.includes("..");
-}
-function escapeAppleScript(s) {
-  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
+// src/cli/commands/start.ts
+init_shell();
 
 // src/cli/commands/dashboard.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { execSync as execSync5 } from "child_process";
+init_shell();
 function openDashboardWindow(tmuxSession, cwd) {
   try {
     const storedId = execSync5(
@@ -2360,7 +2752,7 @@ function openDashboardWindow(tmuxSession, cwd) {
     }
   } catch {
   }
-  const tuiPath = join5(import.meta.dirname, "tui.js");
+  const tuiPath = join6(import.meta.dirname, "tui.js");
   const windowId = execSync5(
     `tmux new-window -t ${shellQuote(tmuxSession + ":")} -n "sisyphus-dashboard" -c ${shellQuote(cwd)} -P -F "#{window_id}"`,
     { encoding: "utf-8" }
@@ -2378,7 +2770,7 @@ function openDashboardWindow(tmuxSession, cwd) {
 function registerDashboard(program2) {
   program2.command("dashboard").description("Launch the TUI dashboard for monitoring and managing sessions").action(async () => {
     assertTmux();
-    const tuiPath = join5(import.meta.dirname, "tui.js");
+    const tuiPath = join6(import.meta.dirname, "tui.js");
     execSync5(`node ${shellQuote(tuiPath)} --cwd ${shellQuote(process.cwd())}`, {
       stdio: "inherit"
     });
@@ -2471,10 +2863,10 @@ function registerStart(program2) {
     const sessionId = response.data?.sessionId;
     console.log(`Task handed off to sisyphus orchestrator (session ${sessionId})`);
     if (opts.tmuxCheck === false) {
-      const tmuxSessionName = response.data?.tmuxSessionName;
-      if (tmuxSessionName) {
-        console.log(`Tmux session: ${tmuxSessionName}`);
-        console.log(`  tmux attach -t ${tmuxSessionName}`);
+      const tmuxSessionName2 = response.data?.tmuxSessionName;
+      if (tmuxSessionName2) {
+        console.log(`Tmux session: ${tmuxSessionName2}`);
+        console.log(`  tmux attach -t ${tmuxSessionName2}`);
       }
       console.log(`Monitor: sis status ${sessionId}`);
       return;
@@ -2526,7 +2918,7 @@ function registerStart(program2) {
 
 // src/cli/commands/status.ts
 import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
 
 // src/shared/utils.ts
 function computeActiveTimeMs(session2) {
@@ -2672,7 +3064,7 @@ function readRoadmap(cwd, sessionId) {
 function readCycleLog(cwd, sessionId, cycle) {
   try {
     const path = cycleLogPath(cwd, sessionId, cycle);
-    if (!existsSync3(path)) return null;
+    if (!existsSync4(path)) return null;
     return readFileSync5(path, "utf8");
   } catch {
     return null;
@@ -2932,16 +3324,16 @@ function registerTell(program2) {
 }
 
 // src/cli/commands/read.ts
-import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
 var ORCH_ALIASES2 = /* @__PURE__ */ new Set(["orchestrator", "orch", "o"]);
 var TURN_TYPES = /* @__PURE__ */ new Set(["user", "assistant"]);
 function projectDirFromCwd(cwd) {
   return cwd.replace(/\//g, "-");
 }
 function transcriptPath(cwd, claudeSessionId) {
-  return join6(homedir5(), ".claude", "projects", projectDirFromCwd(cwd), `${claudeSessionId}.jsonl`);
+  return join7(homedir6(), ".claude", "projects", projectDirFromCwd(cwd), `${claudeSessionId}.jsonl`);
 }
 function truncate(s, max) {
   if (s.length <= max) return s;
@@ -3057,7 +3449,7 @@ function registerRead(program2) {
       process.exit(1);
     }
     const path = transcriptPath(session2.cwd, claudeSessionId);
-    if (!existsSync4(path)) {
+    if (!existsSync5(path)) {
       console.error(`Error: transcript not found at ${path}`);
       process.exit(1);
     }
@@ -3145,13 +3537,13 @@ function registerMessage(program2) {
 }
 
 // src/cli/commands/ask.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13, watchFile, unwatchFile } from "fs";
-import { join as join12, resolve as resolve4 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync13, watchFile, unwatchFile } from "fs";
+import { join as join13, resolve as resolve4 } from "path";
 import { ulid } from "ulid";
 
 // src/shared/ask-schema.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync5, lstatSync, readFileSync as readFileSync8, realpathSync } from "fs";
+import { existsSync as existsSync6, lstatSync, readFileSync as readFileSync8, realpathSync } from "fs";
 import { dirname as dirname2, resolve as resolve2, sep } from "path";
 import { z } from "zod";
 var interactionOptionSchema = z.object({
@@ -3219,7 +3611,7 @@ function runTermrenderCheck(content) {
 function inlineBodyPath(deckPath, bodyPath) {
   const deckDir = dirname2(deckPath);
   const joined = resolve2(deckDir, bodyPath);
-  if (!existsSync5(joined)) {
+  if (!existsSync6(joined)) {
     throw new Error(
       `bodyPath does not exist: '${bodyPath}' (resolved against deck dir '${deckDir}'). bodyPath is interpreted relative to the deck JSON's directory; place the body file there and use a relative path (e.g. "completion-summary.md").`
     );
@@ -3266,17 +3658,17 @@ function parseDeck(deckPath) {
 
 // src/daemon/ask-store.ts
 init_paths();
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync12, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync12, readdirSync as readdirSync3 } from "fs";
 
 // src/daemon/history.ts
 init_paths();
-import { appendFileSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, renameSync, readdirSync, readFileSync as readFileSync9, rmSync as rmSync2, statSync } from "fs";
+import { appendFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, renameSync, readdirSync, readFileSync as readFileSync9, rmSync as rmSync2, statSync } from "fs";
 import { randomUUID } from "crypto";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname3, join as join8 } 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) {
@@ -3291,12 +3683,12 @@ function emitHistoryEvent(sessionId, event, data) {
 // src/daemon/state.ts
 init_atomic();
 init_paths();
-import { copyFileSync, cpSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync11, readdirSync as readdirSync2, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join10 } from "path";
+import { copyFileSync, cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync11, readdirSync as readdirSync2, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
 
 // src/shared/gitignore.ts
-import { existsSync as existsSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
+import { join as join10 } from "path";
 
 // src/shared/types.ts
 var ORCHESTRATOR_ASKED_BY = "orchestrator";
@@ -3358,10 +3750,11 @@ async function incrementUserBlockedMs(cwd, sessionId, deltaMs, askedAt, askedBy)
 init_atomic();
 
 // src/daemon/notify.ts
+init_shell();
 import { spawn, execFile } from "child_process";
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, existsSync as existsSync8 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir6 } from "os";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync9 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir7 } from "os";
 var TMUX_SOCKET = `/tmp/tmux-${process.getuid?.() ?? 0}/default`;
 var SWITCH_SCRIPT = [
   "#!/bin/bash",
@@ -3403,24 +3796,24 @@ var SWITCH_SCRIPT = [
   ""
 ].join("\n");
 function ensureSwitchScript() {
-  const dir = join11(homedir6(), ".sisyphus");
-  const scriptPath2 = join11(dir, "notify-switch.sh");
+  const dir = join12(homedir7(), ".sisyphus");
+  const scriptPath2 = join12(dir, "notify-switch.sh");
   try {
-    mkdirSync5(dir, { recursive: true });
+    mkdirSync6(dir, { recursive: true });
     writeFileSync7(scriptPath2, SWITCH_SCRIPT, { mode: 493 });
   } catch {
   }
 }
 var notifyProcess = null;
 function getNotifyBinary() {
-  return join11(homedir6(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
+  return join12(homedir7(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
 }
 function ensureNotifyProcess() {
   if (notifyProcess && !notifyProcess.killed && notifyProcess.stdin?.writable) {
     return notifyProcess;
   }
   const binary = getNotifyBinary();
-  if (!existsSync8(binary)) {
+  if (!existsSync9(binary)) {
     return null;
   }
   notifyProcess = spawn(binary, [], {
@@ -3500,7 +3893,7 @@ function maybeNotifyOnAskCreated(cwd, sessionId, meta) {
   }
 }
 function createAsk(cwd, sessionId, params) {
-  mkdirSync6(askVisualsDir(cwd, sessionId, params.askId), { recursive: true });
+  mkdirSync7(askVisualsDir(cwd, sessionId, params.askId), { recursive: true });
   const askedAt = (/* @__PURE__ */ new Date()).toISOString();
   const meta = {
     askId: params.askId,
@@ -3547,7 +3940,7 @@ function writeOutput(cwd, sessionId, askId, responses, completedAt) {
 }
 function readMeta(cwd, sessionId, askId) {
   const p = askMetaPath(cwd, sessionId, askId);
-  if (!existsSync9(p)) {
+  if (!existsSync10(p)) {
     return null;
   }
   return JSON.parse(readFileSync12(p, "utf-8"));
@@ -3574,7 +3967,7 @@ function buildAutoResponses(deck) {
 }
 async function autoResolveAsk(cwd, sessionId, askId, deck) {
   try {
-    if (existsSync9(askOutputPath(cwd, sessionId, askId))) return false;
+    if (existsSync10(askOutputPath(cwd, sessionId, askId))) return false;
     const d = deck ?? readDecisions(cwd, sessionId, askId);
     if (!d) return false;
     const responses = buildAutoResponses(d);
@@ -3600,64 +3993,8 @@ async function maybeAutoResolveAsk(cwd, sessionId, askId, deck) {
 
 // src/cli/commands/ask.ts
 init_paths();
-
-// src/shared/exec.ts
-import { execSync as execSync8 } from "child_process";
-
-// src/shared/env.ts
-import { resolve as resolve3 } from "path";
-function augmentedPath() {
-  const rawPath = process.env["PATH"];
-  const basePath = rawPath !== void 0 && rawPath.length > 0 ? rawPath : "/usr/bin:/bin";
-  const home = process.env["HOME"];
-  const candidates = [
-    ...home ? [`${home}/.local/bin`] : [],
-    // Claude CLI, pipx, user-local installs
-    resolve3(process.execPath, ".."),
-    // Node.js bin dir (ensures node/npm available)
-    "/opt/homebrew/bin",
-    // Homebrew (Apple Silicon macOS)
-    "/opt/homebrew/sbin",
-    // Homebrew sbin
-    "/usr/local/bin",
-    // Homebrew (Intel macOS), manual installs
-    "/usr/local/sbin",
-    // Manual installs
-    "/opt/local/bin",
-    // MacPorts
-    "/opt/local/sbin",
-    // MacPorts
-    "/home/linuxbrew/.linuxbrew/bin"
-    // Linuxbrew
-  ];
-  const nixProfile = process.env["NIX_PROFILES"];
-  if (nixProfile) {
-    for (const p of nixProfile.split(" ").reverse()) {
-      candidates.push(`${p}/bin`);
-    }
-  }
-  const existing = new Set(basePath.split(":"));
-  const prepend = candidates.filter((dir) => !existing.has(dir));
-  return prepend.length > 0 ? `${prepend.join(":")}:${basePath}` : basePath;
-}
-function execEnv() {
-  return {
-    ...process.env,
-    PATH: augmentedPath()
-  };
-}
-
-// src/shared/exec.ts
-var EXEC_ENV = execEnv();
-function execSafe(cmd, cwd, timeoutMs) {
-  try {
-    return execSync8(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, stdio: ["pipe", "pipe", "pipe"], timeout: timeoutMs }).trim();
-  } catch {
-    return null;
-  }
-}
-
-// src/cli/commands/ask.ts
+init_exec();
+init_shell();
 var ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/;
 function validateAskId(askId) {
   if (!ULID_RE.test(askId)) {
@@ -3726,7 +4063,7 @@ function mintAskId() {
   return ulid();
 }
 function resolveClaudeSessionId(cwd, sessionId, askedBy) {
-  if (!existsSync10(statePath(cwd, sessionId))) return void 0;
+  if (!existsSync11(statePath(cwd, sessionId))) return void 0;
   const session2 = getSession(cwd, sessionId);
   if (askedBy === ORCHESTRATOR_ASKED_BY) {
     const last = session2.orchestratorCycles[session2.orchestratorCycles.length - 1];
@@ -3763,7 +4100,7 @@ async function markAnswered(cwd, sessionId, askId) {
   });
   if (meta.blocking && durationMs > 0) {
     try {
-      if (existsSync10(statePath(cwd, sessionId))) {
+      if (existsSync11(statePath(cwd, sessionId))) {
         await incrementUserBlockedMs(cwd, sessionId, durationMs, meta.askedAt, meta.askedBy);
       }
     } catch {
@@ -3772,7 +4109,7 @@ async function markAnswered(cwd, sessionId, askId) {
 }
 function waitForOutput(cwd, sessionId, askId, initialPpid) {
   const outputPath = askOutputPath(cwd, sessionId, askId);
-  if (existsSync10(outputPath)) {
+  if (existsSync11(outputPath)) {
     return Promise.resolve(JSON.parse(readFileSync13(outputPath, "utf-8")));
   }
   return new Promise((res, _rej) => {
@@ -3783,7 +4120,7 @@ function waitForOutput(cwd, sessionId, askId, initialPpid) {
       process.removeListener("SIGINT", onSigint);
     };
     const onChange = () => {
-      if (!existsSync10(outputPath)) return;
+      if (!existsSync11(outputPath)) return;
       try {
         const out = JSON.parse(readFileSync13(outputPath, "utf-8"));
         cleanup();
@@ -3816,7 +4153,7 @@ function maybeSpawnAskPane(cwd, sessionId, askId) {
   const callerPane = process.env.TMUX_PANE;
   if (!callerPane) return;
   if (process.env.SISYPHUS_DISABLE_ASK_PANE === "1") return;
-  const tuiPath = join12(import.meta.dirname, "tui.js");
+  const tuiPath = join13(import.meta.dirname, "tui.js");
   const cmd = `node ${shellQuote(tuiPath)} --cwd ${shellQuote(cwd)} --session-id ${shellQuote(sessionId)} --ask ${shellQuote(askId)}`;
   execSafe(`tmux split-window -d -h -t ${shellQuote(callerPane)} -c ${shellQuote(cwd)} ${shellQuote(cmd)}`);
 }
@@ -3824,7 +4161,7 @@ async function submit(file, opts) {
   const { cwd, sessionId } = resolveSessionEnv(opts);
   const askedBy = process.env.SISYPHUS_AGENT_ID ?? ORCHESTRATOR_ASKED_BY;
   const deckPath = resolve4(file);
-  if (!existsSync10(deckPath)) {
+  if (!existsSync11(deckPath)) {
     console.error(`Error: deck file not found: ${deckPath}`);
     process.exit(1);
   }
@@ -3883,7 +4220,7 @@ async function peek(askId, opts) {
   };
   if (meta.completedAt) result.completedAt = meta.completedAt;
   try {
-    if (existsSync10(outputPath)) {
+    if (existsSync11(outputPath)) {
       result.output = JSON.parse(readFileSync13(outputPath, "utf-8"));
     }
   } catch (err) {
@@ -3951,11 +4288,11 @@ function registerResume(program2) {
     const request = { type: "resume", sessionId, cwd, message };
     const response = await sendRequest(request);
     if (response.ok) {
-      const tmuxSessionName = response.data?.tmuxSessionName;
+      const tmuxSessionName2 = response.data?.tmuxSessionName;
       console.log(`Session ${sessionId} resumed`);
-      if (tmuxSessionName) {
-        console.log(`Tmux session: ${tmuxSessionName}`);
-        console.log(`  tmux attach -t ${tmuxSessionName}`);
+      if (tmuxSessionName2) {
+        console.log(`Tmux session: ${tmuxSessionName2}`);
+        console.log(`  tmux attach -t ${tmuxSessionName2}`);
       }
     } else {
       console.error(`Error: ${response.error}`);
@@ -4038,9 +4375,9 @@ function registerReconnect(program2) {
     const request = { type: "reconnect", sessionId, cwd };
     const response = await sendRequest(request);
     if (response.ok) {
-      const tmuxSessionName = response.data?.tmuxSessionName;
+      const tmuxSessionName2 = response.data?.tmuxSessionName;
       const tmuxWindowId = response.data?.tmuxWindowId;
-      console.log(`Reconnected to ${tmuxSessionName} (window ${tmuxWindowId})`);
+      console.log(`Reconnected to ${tmuxSessionName2} (window ${tmuxWindowId})`);
     } else {
       console.error(`Error: ${response.error}`);
       process.exit(1);
@@ -4130,6 +4467,65 @@ function registerSessionEffort(program2) {
   });
 }
 
+// src/cli/commands/set-dangerous.ts
+var VALID_STATES = ["on", "off", "toggle"];
+function registerSessionDangerous(program2) {
+  program2.command("dangerous [sessionId] [state]").description("Toggle dangerous mode (auto-accept first option for every ask). state: on|off|toggle (default: toggle)").action(async (sessionIdArg, stateArg) => {
+    let sessionId;
+    if (sessionIdArg) {
+      sessionId = sessionIdArg;
+    } else if (process.env.SISYPHUS_SESSION_ID) {
+      sessionId = process.env.SISYPHUS_SESSION_ID;
+    } else {
+      console.error("Error: provide <sessionId> or set SISYPHUS_SESSION_ID environment variable");
+      process.exit(1);
+    }
+    let state;
+    if (!stateArg) {
+      state = "toggle";
+    } else {
+      const stateInput = stateArg.toLowerCase();
+      if (!VALID_STATES.includes(stateInput)) {
+        console.error(`Error: state must be one of: ${VALID_STATES.join(", ")}`);
+        process.exit(1);
+      }
+      state = stateInput;
+    }
+    let enabled;
+    if (state === "toggle") {
+      const cwd = process.env["SISYPHUS_CWD"] ? process.env["SISYPHUS_CWD"] : process.cwd();
+      const statusResp = await sendRequest({ type: "status", sessionId, cwd });
+      if (!statusResp.ok) {
+        console.error(`Error: ${statusResp.error}`);
+        process.exit(1);
+      }
+      const session2 = statusResp.data?.session;
+      if (!session2) {
+        console.error(`Error: session ${sessionId} not found`);
+        process.exit(1);
+      }
+      enabled = !session2.dangerousMode;
+    } else {
+      enabled = state === "on";
+    }
+    const request = { type: "set-dangerous-mode", sessionId, enabled };
+    const response = await sendRequest(request);
+    if (response.ok) {
+      const flushedRaw = response.data?.flushed;
+      const flushed = typeof flushedRaw === "number" ? flushedRaw : 0;
+      const label = enabled ? "ON" : "OFF";
+      let msg = `DANGEROUS mode ${label} for session ${sessionId}`;
+      if (enabled && flushed > 0) {
+        msg += ` \u2014 ${flushed} pending ask${flushed === 1 ? "" : "s"} auto-resolved`;
+      }
+      console.log(msg);
+    } else {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+  });
+}
+
 // src/tui/lib/context.ts
 init_paths();
 import { readFileSync as readFileSync15, readdirSync as readdirSync4 } from "fs";
@@ -4293,14 +4689,14 @@ function registerSessionContext(program2) {
 }
 
 // src/cli/commands/spawn.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join14, resolve as resolve5 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join15, resolve as resolve5 } from "path";
 
 // src/daemon/frontmatter.ts
 init_paths();
-import { readFileSync as readFileSync16, existsSync as existsSync11, readdirSync as readdirSync5 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join13, basename as basename4 } from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync12, readdirSync as readdirSync5 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join14, basename as basename4 } from "path";
 function parseAgentFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---/);
   if (!match) return {};
@@ -4350,7 +4746,7 @@ function discoverAgentTypes(pluginDir, cwd) {
       if (seen.has(qualifiedName)) continue;
       seen.add(qualifiedName);
       try {
-        const content = readFileSync16(join13(dir, file), "utf-8");
+        const content = readFileSync16(join14(dir, file), "utf-8");
         const fm = parseAgentFrontmatter(content);
         results.push({ qualifiedName, source, description: fm.description, model: fm.model });
       } catch {
@@ -4358,13 +4754,13 @@ function discoverAgentTypes(pluginDir, cwd) {
       }
     }
   }
-  scanDir(join13(projectAgentPluginDir(cwd), "agents"), null, "project-sis");
-  scanDir(join13(userAgentPluginDir(), "agents"), null, "user-sis");
-  scanDir(join13(cwd, ".claude", "agents"), null, "project");
-  scanDir(join13(homedir7(), ".claude", "agents"), null, "user");
-  scanDir(join13(pluginDir, "agents"), "sisyphus", "bundled");
+  scanDir(join14(projectAgentPluginDir(cwd), "agents"), null, "project-sis");
+  scanDir(join14(userAgentPluginDir(), "agents"), null, "user-sis");
+  scanDir(join14(cwd, ".claude", "agents"), null, "project");
+  scanDir(join14(homedir8(), ".claude", "agents"), null, "user");
+  scanDir(join14(pluginDir, "agents"), "sisyphus", "bundled");
   try {
-    const registryPath = join13(homedir7(), ".claude", "plugins", "installed_plugins.json");
+    const registryPath = join14(homedir8(), ".claude", "plugins", "installed_plugins.json");
     const registry = JSON.parse(readFileSync16(registryPath, "utf-8"));
     const pluginEntries = registry.plugins ?? registry;
     for (const key of Object.keys(pluginEntries)) {
@@ -4374,7 +4770,7 @@ function discoverAgentTypes(pluginDir, cwd) {
       const entry = pluginEntries[key];
       const installPath = Array.isArray(entry) ? entry[0]?.installPath : entry?.installPath;
       if (installPath) {
-        scanDir(join13(installPath, "agents"), namespace, "plugin");
+        scanDir(join14(installPath, "agents"), namespace, "plugin");
       }
     }
   } catch {
@@ -4444,8 +4840,8 @@ function registerSpawn(program2) {
       process.exit(1);
     }
     if (opts.repo && opts.repo !== ".") {
-      const repoPath = join14(sisyphusCwd, opts.repo);
-      if (!existsSync12(repoPath)) {
+      const repoPath = join15(sisyphusCwd, opts.repo);
+      if (!existsSync13(repoPath)) {
         console.error(`Error: repo directory does not exist: ${repoPath}`);
         process.exit(1);
       }
@@ -4552,7 +4948,7 @@ function registerReport(program2) {
 }
 
 // src/cli/commands/await.ts
-import { existsSync as existsSync13, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync17 } from "fs";
 var AWAIT_TIMEOUT_MS = 24 * 60 * 60 * 1e3;
 function registerAwait(program2) {
   program2.command("await").description("Block until an agent reaches a terminal status, then print its final report inline. Marks the agent as consumed-inline so its report is suppressed from the next cycle.").argument("<agentId>", "Agent ID to await").option("--session <sessionId>", "Session ID (defaults to SISYPHUS_SESSION_ID env var)").action(async (agentId, opts) => {
@@ -4576,7 +4972,7 @@ function registerAwait(program2) {
     const shortType = agentType && agentType !== "worker" ? agentType.replace(/^sisyphus:/, "") : "";
     const label = shortType ? `${shortType}-${agentName}` : agentName;
     console.log(`[${status}] ${agentId} (${label})`);
-    if (reportPath && existsSync13(reportPath)) {
+    if (reportPath && existsSync14(reportPath)) {
       try {
         const body = readFileSync17(reportPath, "utf-8");
         if (body.length > 0) {
@@ -4706,9 +5102,9 @@ import { execSync as execSync10 } from "child_process";
 
 // src/cli/onboard.ts
 import { execSync as execSync9 } from "child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
-import { homedir as homedir8 } from "os";
-import { dirname as dirname5, join as join15 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir9 } from "os";
+import { dirname as dirname5, join as join16 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function detectTerminal() {
   const termProgram = process.env["TERM_PROGRAM"] || "";
@@ -4745,8 +5141,8 @@ function checkItermOptionKey() {
   if (process.platform !== "darwin") {
     return { checked: false, allCorrect: true, incorrectProfiles: [] };
   }
-  const plistPath2 = join15(homedir8(), "Library", "Preferences", "com.googlecode.iterm2.plist");
-  if (!existsSync14(plistPath2)) {
+  const plistPath2 = join16(homedir9(), "Library", "Preferences", "com.googlecode.iterm2.plist");
+  if (!existsSync15(plistPath2)) {
     return { checked: false, allCorrect: false, incorrectProfiles: [] };
   }
   try {
@@ -4770,7 +5166,7 @@ function checkItermOptionKey() {
   }
 }
 function hasExistingTmuxConf() {
-  return existsSync14(join15(homedir8(), ".tmux.conf")) || existsSync14(join15(homedir8(), ".config", "tmux", "tmux.conf"));
+  return existsSync15(join16(homedir9(), ".tmux.conf")) || existsSync15(join16(homedir9(), ".config", "tmux", "tmux.conf"));
 }
 var SISYPHUS_DEFAULTS_MARKER = "# sisyphus-managed \u2014 do not edit";
 function buildTmuxDefaults() {
@@ -4882,7 +5278,7 @@ source-file -q ${sisyphusConf} ${SISYPHUS_DEFAULTS_MARKER}
 `;
 }
 function writeTmuxDefaults() {
-  const confPath = join15(homedir8(), ".tmux.conf");
+  const confPath = join16(homedir9(), ".tmux.conf");
   writeFileSync8(confPath, buildTmuxDefaults(), "utf8");
 }
 function isNvimAvailable() {
@@ -4901,19 +5297,19 @@ function getNvimVersion() {
   }
 }
 function hasLazyVimConfig() {
-  return existsSync14(join15(homedir8(), ".config", "nvim", "lazy-lock.json"));
+  return existsSync15(join16(homedir9(), ".config", "nvim", "lazy-lock.json"));
 }
 function bundledBaleiaPluginPath() {
   const distDir = dirname5(fileURLToPath2(import.meta.url));
-  return join15(distDir, "templates", "baleia.lua");
+  return join16(distDir, "templates", "baleia.lua");
 }
 function installBaleiaPlugin() {
-  const pluginsDir = join15(homedir8(), ".config", "nvim", "lua", "plugins");
-  if (!existsSync14(pluginsDir)) return false;
-  const dest = join15(pluginsDir, "sisyphus-baleia.lua");
-  if (existsSync14(dest)) return true;
+  const pluginsDir = join16(homedir9(), ".config", "nvim", "lua", "plugins");
+  if (!existsSync15(pluginsDir)) return false;
+  const dest = join16(pluginsDir, "sisyphus-baleia.lua");
+  if (existsSync15(dest)) return true;
   const src = bundledBaleiaPluginPath();
-  if (!existsSync14(src)) return false;
+  if (!existsSync15(src)) return false;
   try {
     writeFileSync8(dest, readFileSync18(src, "utf-8"), "utf8");
     return true;
@@ -4938,9 +5334,9 @@ function tryAutoInstallNvim() {
   if (!isNvimAvailable()) {
     return { installed: false, autoInstalled: false, version: "", lazyVimInstalled: false, baleiaInstalled: false };
   }
-  const nvimConfigDir = join15(homedir8(), ".config", "nvim");
+  const nvimConfigDir = join16(homedir9(), ".config", "nvim");
   let lazyVimInstalled = false;
-  if (!existsSync14(nvimConfigDir)) {
+  if (!existsSync15(nvimConfigDir)) {
     const cloneCmd = [
       "git",
       "-c core.hooksPath=/dev/null",
@@ -4956,8 +5352,8 @@ function tryAutoInstallNvim() {
         stdio: "inherit",
         env: { ...process.env, GIT_LFS_SKIP_SMUDGE: "1" }
       });
-      const gitDir = join15(nvimConfigDir, ".git");
-      if (existsSync14(gitDir)) {
+      const gitDir = join16(nvimConfigDir, ".git");
+      if (existsSync15(gitDir)) {
         execSync9(`rm -rf "${gitDir}"`, { stdio: "pipe" });
       }
       lazyVimInstalled = true;
@@ -5128,7 +5524,7 @@ function printResults(result, daemonOk, keybindMsg) {
   console.log("");
 }
 function registerSetup(program2) {
-  program2.command("setup").description("One-time setup: install dependencies, daemon, keybindings, and commands").option("-y, --yes", "Skip confirmation prompts (e.g. before modifying ~/.tmux.conf)").action(async (opts) => {
+  program2.command("setup").description("One-time setup: install dependencies, daemon, keybindings, and commands").option("-y, --yes", "Skip the y/N prompt before modifying ~/.tmux.conf").option("-f, --force", "Override safety refusals: overwrite existing key bindings AND auto-append source-file to ~/.tmux.conf").action(async (opts) => {
     const result = runOnboarding();
     let daemonOk = false;
     try {
@@ -5140,11 +5536,15 @@ function registerSetup(program2) {
     const keybindResult = await setupTmuxKeybind(
       DEFAULT_CYCLE_KEY,
       DEFAULT_PREFIX_KEY,
-      { assumeYes: opts.yes }
+      { assumeYes: opts.yes, force: opts.force }
     );
     let keybindMsg;
     if (keybindResult.status === "installed" || keybindResult.status === "already-installed") {
       keybindMsg = `${DEFAULT_CYCLE_KEY} cycle, ${DEFAULT_PREFIX_KEY} prefix (h=dashboard, x=kill)`;
+    } else if (keybindResult.status === "requires-force" || keybindResult.status === "conflict") {
+      keybindMsg = `${keybindResult.message}
+    Run "sis admin check-keybinds" for the full decision tree, then re-run "sis admin setup --force" to proceed.`;
+      process.exitCode = 1;
     } else {
       keybindMsg = keybindResult.message;
     }
@@ -5154,9 +5554,12 @@ function registerSetup(program2) {
 
 // src/cli/commands/setup-keybind.ts
 function registerSetupKeybind(program2) {
-  program2.command("setup-keybind [cycle-key]").description("Install sisyphus tmux keybindings (default: M-s cycle, C-s prefix)").option("-y, --yes", "Skip confirmation prompt before modifying ~/.tmux.conf").action(async (key, opts) => {
-    const resolvedKey = key ?? DEFAULT_CYCLE_KEY;
-    const result = await setupTmuxKeybind(resolvedKey, void 0, { assumeYes: opts.yes });
+  program2.command("setup-keybind [cycle-key]").description("Install sisyphus tmux keybindings (default: M-s cycle, C-s prefix)").option("-y, --yes", "Auto-accept the y/N prompt before appending source-file to ~/.tmux.conf").option("-f, --force", "Override safety refusals: overwrite existing key bindings AND auto-append the source-file line").action(async (key, opts) => {
+    const resolvedKey = key === void 0 ? DEFAULT_CYCLE_KEY : key;
+    const result = await setupTmuxKeybind(resolvedKey, void 0, {
+      assumeYes: opts.yes,
+      force: opts.force
+    });
     switch (result.status) {
       case "installed":
         console.log(result.message);
@@ -5166,28 +5569,602 @@ function registerSetupKeybind(program2) {
         console.log(result.message);
         break;
       case "conflict":
-        console.log(`Key ${resolvedKey} is already bound:`);
+        console.log(`Key ${result.conflictKey} is already bound:`);
         console.log(`  ${result.existingBinding}`);
         console.log("");
-        console.log("Use a different key, e.g.:");
-        console.log("  sis admin setup-keybind M-S");
-        console.log("  sis admin setup-keybind M-w");
-        console.log("  sis admin setup-keybind M-j");
+        console.log("Options:");
+        console.log("  - Pick a different cycle key:  sis admin setup-keybind M-w");
+        console.log('  - Run "sis admin check-keybinds" for a full breakdown');
+        console.log("  - Override and overwrite:      sis admin setup-keybind --force");
+        process.exitCode = 1;
         break;
       case "unsupported-tmux":
         console.log(result.message);
+        process.exitCode = 1;
+        break;
+      case "requires-force":
+        console.log(result.message);
+        console.log("");
+        console.log('Run "sis admin check-keybinds" first if you want the full decision tree before deciding.');
+        process.exitCode = 1;
         break;
       case "conf-modification-declined":
         console.log(result.message);
         console.log("");
-        console.log("Re-run with --yes to skip the prompt.");
+        console.log("Re-run with --force to append automatically.");
         break;
     }
   });
 }
 
-// src/cli/commands/home-init.ts
+// src/cli/commands/check-keybinds.ts
 import { execSync as execSync11 } from "child_process";
+import { readFileSync as readFileSync19 } from "fs";
+function isTmuxInstalled2() {
+  try {
+    execSync11("which tmux", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getTmuxVersion2() {
+  try {
+    return execSync11("tmux -V", { stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+function isTmuxServerRunning() {
+  try {
+    execSync11("tmux list-sessions", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getTmuxPrefix() {
+  try {
+    return execSync11("tmux show-options -gv prefix", { stdio: ["pipe", "pipe", "pipe"] }).toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+function classifyKey(key, serverRunning) {
+  if (!serverRunning) return { kind: "unbound" };
+  const binding = getExistingBinding(key);
+  if (binding === null) return { kind: "unbound" };
+  if (isSisyphusBinding(binding)) return { kind: "sisyphus", binding };
+  return { kind: "conflict", binding };
+}
+function runCheck() {
+  const tmuxInstalled = isTmuxInstalled2();
+  const tmuxVersion = tmuxInstalled ? getTmuxVersion2() : null;
+  const tmuxVersionOk = tmuxInstalled ? tmuxVersionAtLeast(3, 2) : false;
+  const tmuxServerRunning = tmuxInstalled ? isTmuxServerRunning() : false;
+  const inTmux = !!process.env["TMUX"];
+  const cycleKey = { key: DEFAULT_CYCLE_KEY, ...classifyKey(DEFAULT_CYCLE_KEY, tmuxServerRunning) };
+  const prefixKey = { key: DEFAULT_PREFIX_KEY, ...classifyKey(DEFAULT_PREFIX_KEY, tmuxServerRunning) };
+  const tmuxPrefix = tmuxServerRunning ? getTmuxPrefix() : null;
+  const prefixCollision = tmuxPrefix !== null && tmuxPrefix === DEFAULT_PREFIX_KEY;
+  const sisyphusConfPath = sisyphusTmuxConfPath();
+  const userConfPath = userTmuxConfPath();
+  let userConfAlreadySources = false;
+  if (userConfPath !== null) {
+    try {
+      userConfAlreadySources = readFileSync19(userConfPath, "utf-8").includes(sisyphusConfPath);
+    } catch {
+    }
+  }
+  return {
+    tmuxInstalled,
+    tmuxServerRunning,
+    tmuxVersion,
+    tmuxVersionOk,
+    inTmux,
+    cycleKey,
+    prefixKey,
+    tmuxPrefix,
+    prefixCollision,
+    userConfPath,
+    userConfAlreadySources,
+    sisyphusConfPath
+  };
+}
+function fmtKeyState(k) {
+  switch (k.kind) {
+    case "sisyphus":
+      return `${k.key}: sisyphus (${k.binding})`;
+    case "conflict":
+      return `${k.key}: CONFLICT \u2014 already bound: ${k.binding}`;
+    case "unbound":
+      return `${k.key}: unbound`;
+  }
+}
+function printInstructions(r) {
+  const bothSisyphus = r.cycleKey.kind === "sisyphus" && r.prefixKey.kind === "sisyphus";
+  const anyConflict = r.cycleKey.kind === "conflict" || r.prefixKey.kind === "conflict";
+  const wouldModifyUserConf = r.userConfPath !== null && !r.userConfAlreadySources;
+  const safeAutoInstall = !anyConflict && !r.prefixCollision && !wouldModifyUserConf;
+  const tmuxVersionLabel = r.tmuxVersion === null ? "(none)" : r.tmuxVersion;
+  const tmuxPrefixLabel = r.tmuxPrefix === null ? "(default C-b)" : r.tmuxPrefix;
+  const userConfLabel = r.userConfPath === null ? "(none found)" : r.userConfPath;
+  const userConfForCopy = r.userConfPath === null ? "~/.tmux.conf" : r.userConfPath;
+  console.log(`
+<claude-instructions>
+# Sisyphus Keybind Precheck
+
+Run this BEFORE asking the user to try any sisyphus keybind (e.g. \`Right Option+s\`,
+\`C-s h\`, \`C-s ?\`). If the keybinds aren't actually wired up, the user will press
+the key and nothing will happen \u2014 confusing, looks broken.
+
+## Environment Data
+- tmuxInstalled: ${r.tmuxInstalled}
+- tmuxVersion: ${tmuxVersionLabel}
+- tmuxVersionOk: ${r.tmuxVersionOk}  (sisyphus needs 3.2+ for display-menu)
+- tmuxServerRunning: ${r.tmuxServerRunning}
+- inTmux ($TMUX set): ${r.inTmux}
+- ${fmtKeyState(r.cycleKey)}
+- ${fmtKeyState(r.prefixKey)}
+- tmuxPrefix (\`set -g prefix\`): ${tmuxPrefixLabel}
+- prefixCollision: ${r.prefixCollision}  (true = user's tmux prefix is ${DEFAULT_PREFIX_KEY}; binding it in root would shadow it)
+- userConfPath: ${userConfLabel}
+- userConfAlreadySources: ${r.userConfAlreadySources}
+- sisyphusConfPath: ${r.sisyphusConfPath}
+
+## Decision
+
+Pick exactly one path. Do NOT proceed past this check until both keys read "sisyphus".
+
+### Path A \u2014 All wired, proceed
+**Trigger:** cycleKey is "sisyphus" AND prefixKey is "sisyphus".
+**Action:** ${bothSisyphus ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"} Confirm briefly and continue with the onboarding step that needs keybinds.
+
+### Path B \u2014 Safe to auto-install
+**Trigger:** No conflicts, no prefix collision, AND (no user tmux.conf OR it already sources sisyphus).
+**Action:** ${safeAutoInstall && !bothSisyphus ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"} Run:
+\`\`\`
+sis admin setup-keybind --yes
+\`\`\`
+This installs the helper scripts in ~/.sisyphus/bin/ and applies the bindings to the live
+tmux server. No user files are clobbered (none to clobber, or already wired).
+
+### Path C \u2014 Would append a line to the user's tmux.conf
+**Trigger:** No conflicts, no prefix collision, but ${userConfForCopy} exists and doesn't yet source ${r.sisyphusConfPath}.
+**Action:** ${!safeAutoInstall && !anyConflict && !r.prefixCollision && wouldModifyUserConf && !bothSisyphus ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"} Ask the user to choose:
+
+  1. **Persistent (recommended).** "I'll add one line to ${userConfForCopy} so the bindings survive tmux restarts. The line is marked \`# sisyphus-managed \u2014 do not edit\` and is grep-removable later."
+     Run: \`sis admin setup-keybind --yes\`
+
+  2. **Live only, no file changes.** "I'll wire the bindings into your current tmux server without touching any config file. They'll vanish when you restart tmux, and you can re-run \`sis admin setup-keybind\` anytime to make them stick."
+     Run: \`sis admin setup-keybind\` (no --yes; non-TTY auto-declines the conf prompt while still applying live bindings + installing helper scripts)
+
+### Path D \u2014 Conflict on ${DEFAULT_CYCLE_KEY} or ${DEFAULT_PREFIX_KEY}
+**Trigger:** cycleKey or prefixKey is "CONFLICT".
+**Action:** ${anyConflict ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"} The user already has these keys bound to something else. Show them the conflicting bindings (above) and offer:
+
+  1. **Pick alternate keys.** Re-run with a different cycle key \u2014 e.g. \`M-S\`, \`M-w\`, \`M-j\`, \`M-\\\`\`:
+     \`\`\`
+     sis admin setup-keybind M-w
+     \`\`\`
+     This still uses C-s for the prefix; if the prefix also conflicts, you'll need to wire
+     directly (option 3 below), since setup-keybind only takes a custom cycle key.
+
+  2. **Skip keybinds entirely.** The user can drive sisyphus from the CLI: \`sis dashboard\`,
+     \`sis status\`, \`sis start\`, \`sis session resume\`. Lose tmux quick-actions, keep
+     existing bindings.
+
+  3. **Wire commands directly (advanced).** Bypass setup-keybind and bind individual
+     sisyphus actions to keys the user picks. Helper scripts must already exist \u2014 if
+     ~/.sisyphus/bin/sisyphus-cycle is missing, you cannot use this path until setup-keybind
+     has run at least once successfully (try option 1 first).
+     \`\`\`
+     # cycle sessions on a key the user chooses (replace M-w):
+     tmux bind-key -T root M-w run-shell "$HOME/.sisyphus/bin/sisyphus-cycle"
+
+     # open the dashboard directly on a key (replace M-h):
+     tmux bind-key -T root M-h run-shell "$HOME/.sisyphus/bin/sisyphus-home"
+     \`\`\`
+     These apply only to the running tmux server. To persist, append the same lines to
+     ${userConfForCopy}.
+
+### Path E \u2014 Hidden prefix collision
+**Trigger:** prefixCollision is true (the user's \`set -g prefix\` is already ${DEFAULT_PREFIX_KEY}).
+**Action:** ${r.prefixCollision ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"} \`tmux list-keys\` won't surface this as a binding conflict, but installing the C-s root-table menu would shadow the user's prefix. Tell the user:
+
+  > "Your tmux prefix is set to ${DEFAULT_PREFIX_KEY}. Sisyphus wants to bind ${DEFAULT_PREFIX_KEY} in the root table for its menu, which would shadow your prefix. Options: (a) move your prefix (e.g. \`set -g prefix C-a\`) and let sisyphus take ${DEFAULT_PREFIX_KEY}, or (b) skip the menu binding \u2014 only \`${DEFAULT_CYCLE_KEY}\` cycle gets installed."
+
+  For (b), wire just the cycle key directly:
+  \`\`\`
+  sis admin setup-keybind ${DEFAULT_CYCLE_KEY}
+  # then unbind C-s if setup-keybind ended up taking it:
+  tmux unbind-key -T root ${DEFAULT_PREFIX_KEY}
+  \`\`\`
+
+### Path F \u2014 tmux not ready
+**Trigger:** any of: tmuxInstalled=false, tmuxVersionOk=false, tmuxServerRunning=false.
+**Action:** ${!r.tmuxInstalled || !r.tmuxVersionOk || !r.tmuxServerRunning ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"} Don't install keybinds yet. Fix the precondition:
+- tmuxInstalled=false \u2192 \`brew install tmux\` (macOS) or your package manager
+- tmuxVersionOk=false \u2192 upgrade tmux to 3.2+
+- tmuxServerRunning=false \u2192 user needs to run \`tmux\` (or attach to an existing session) before live bindings can be installed or tested
+
+After fixing, re-run \`sis admin check-keybinds\`.
+
+## After acting
+Re-run \`sis admin check-keybinds\` to confirm both keys read "sisyphus", THEN ask the
+user to try the keybind. Don't skip the verification \u2014 \`setup-keybind\` can fail silently
+if the tmux server dies between commands.
+</claude-instructions>
+`);
+}
+function registerCheckKeybinds(program2) {
+  program2.command("check-keybinds").description("Verify tmux keybind state before asking the user to try a sisyphus keybind").option("--json", "Print raw JSON state instead of Claude instructions").action((opts) => {
+    const result = runCheck();
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printInstructions(result);
+  });
+}
+
+// src/cli/commands/check-statusbar.ts
+init_paths();
+import { execSync as execSync12 } from "child_process";
+import { existsSync as existsSync16, readFileSync as readFileSync20 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join17 } from "path";
+var SISYPHUS_LEFT_TOKEN = "@sisyphus_left";
+var SISYPHUS_RIGHT_TOKEN = "@sisyphus_right";
+var TMUX_DEFAULT_STATUS_LEFT = "[#S] ";
+var TMUX_DEFAULT_STATUS_RIGHT_PREFIX = '"#{=21:pane_title}"';
+function isTmuxInstalled3() {
+  try {
+    execSync12("which tmux", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isTmuxServerRunning2() {
+  try {
+    execSync12("tmux list-sessions", { stdio: ["pipe", "pipe", "pipe"] });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isDaemonRunning() {
+  const pidFile = daemonPidPath();
+  if (!existsSync16(pidFile)) return false;
+  try {
+    const pid = parseInt(readFileSync20(pidFile, "utf-8").trim(), 10);
+    if (Number.isNaN(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function showOption(name) {
+  try {
+    const out = execSync12(`tmux show-options -g ${name}`, { stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+    if (out.length === 0) return null;
+    const prefix = `${name} `;
+    const stripped = out.startsWith(prefix) ? out.slice(prefix.length) : out;
+    if (stripped.startsWith('"') && stripped.endsWith('"') && stripped.length >= 2) {
+      return stripped.slice(1, -1);
+    }
+    return stripped;
+  } catch {
+    return null;
+  }
+}
+function probeTmuxOptions(serverRunning) {
+  if (!serverRunning) {
+    return {
+      status: null,
+      statusLeft: null,
+      statusRight: null,
+      statusPosition: null,
+      statusStyle: null,
+      statusInterval: null
+    };
+  }
+  return {
+    status: showOption("status"),
+    statusLeft: showOption("status-left"),
+    statusRight: showOption("status-right"),
+    statusPosition: showOption("status-position"),
+    statusStyle: showOption("status-style"),
+    statusInterval: showOption("status-interval")
+  };
+}
+function findUserTmuxConf() {
+  const xdg = join17(homedir10(), ".config", "tmux", "tmux.conf");
+  const dotfile = join17(homedir10(), ".tmux.conf");
+  if (existsSync16(xdg)) return xdg;
+  if (existsSync16(dotfile)) return dotfile;
+  return null;
+}
+function probeUserConf() {
+  const path = findUserTmuxConf();
+  if (path === null) {
+    return { path: null, setsStatusLeft: false, setsStatusRight: false, sourcesSisyphusManaged: false };
+  }
+  let contents = "";
+  try {
+    contents = readFileSync20(path, "utf-8");
+  } catch {
+    return { path, setsStatusLeft: false, setsStatusRight: false, sourcesSisyphusManaged: false };
+  }
+  const lines = contents.split("\n").filter((line) => !line.trim().startsWith("#"));
+  const setsStatusLeft = lines.some((line) => /^\s*(set|set-option)\s+-g(?:\s+-\w+)*\s+status-left\b/.test(line));
+  const setsStatusRight = lines.some((line) => /^\s*(set|set-option)\s+-g(?:\s+-\w+)*\s+status-right\b/.test(line));
+  const sourcesSisyphusManaged = contents.includes(join17(homedir10(), ".sisyphus", "tmux.conf"));
+  return { path, setsStatusLeft, setsStatusRight, sourcesSisyphusManaged };
+}
+function loadGlobalSisyphusConfig() {
+  const path = globalConfigPath();
+  if (!existsSync16(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync20(path, "utf-8"));
+    return parsed.statusBar === void 0 ? null : parsed.statusBar;
+  } catch {
+    return null;
+  }
+}
+function classifyState(opts, serverRunning) {
+  if (!serverRunning) {
+    return { state: "tmux-not-ready", referencesSisyphusLeft: false, referencesSisyphusRight: false };
+  }
+  if (opts.status === "off") {
+    return { state: "disabled", referencesSisyphusLeft: false, referencesSisyphusRight: false };
+  }
+  const referencesSisyphusLeft = opts.statusLeft !== null && opts.statusLeft.includes(SISYPHUS_LEFT_TOKEN);
+  const referencesSisyphusRight = opts.statusRight !== null && opts.statusRight.includes(SISYPHUS_RIGHT_TOKEN);
+  if (referencesSisyphusLeft && referencesSisyphusRight) {
+    return { state: "wired", referencesSisyphusLeft, referencesSisyphusRight };
+  }
+  if (referencesSisyphusLeft) {
+    return { state: "partial-left-only", referencesSisyphusLeft, referencesSisyphusRight };
+  }
+  if (referencesSisyphusRight) {
+    return { state: "partial-right-only", referencesSisyphusLeft, referencesSisyphusRight };
+  }
+  const isStock = (opts.statusLeft === TMUX_DEFAULT_STATUS_LEFT || opts.statusLeft === null) && (opts.statusRight === null || opts.statusRight.includes(TMUX_DEFAULT_STATUS_RIGHT_PREFIX));
+  return {
+    state: isStock ? "tmux-default" : "custom-no-sisyphus",
+    referencesSisyphusLeft,
+    referencesSisyphusRight
+  };
+}
+function runCheck2() {
+  const tmuxInstalled = isTmuxInstalled3();
+  const tmuxServerRunning = tmuxInstalled ? isTmuxServerRunning2() : false;
+  const tmuxOptions = probeTmuxOptions(tmuxServerRunning);
+  const userConf = probeUserConf();
+  const globalConfig = loadGlobalSisyphusConfig();
+  const daemonRunning = isDaemonRunning();
+  const { state, referencesSisyphusLeft, referencesSisyphusRight } = classifyState(tmuxOptions, tmuxServerRunning);
+  return {
+    tmuxInstalled,
+    tmuxServerRunning,
+    daemonRunning,
+    tmuxOptions,
+    userConf,
+    globalConfig,
+    state,
+    referencesSisyphusLeft,
+    referencesSisyphusRight
+  };
+}
+function fmtOption(value) {
+  if (value === null) return "(unset)";
+  return JSON.stringify(value);
+}
+function renderConfigSummary(cfg) {
+  if (cfg === null) return "(no statusBar block in ~/.sisyphus/config.json \u2014 defaults apply)";
+  const parts = [];
+  if (cfg.enabled === false) parts.push("enabled: false (DISABLED)");
+  if (cfg.left !== void 0) parts.push(`left: [${cfg.left.join(", ")}]`);
+  if (cfg.right !== void 0) parts.push(`right: [${cfg.right.join(", ")}]`);
+  if (cfg.colors !== void 0) parts.push(`colors: ${JSON.stringify(cfg.colors)}`);
+  if (cfg.segments !== void 0) {
+    const segNames = Object.keys(cfg.segments);
+    if (segNames.length > 0) parts.push(`per-segment overrides: ${segNames.join(", ")}`);
+  }
+  if (parts.length === 0) return "(statusBar block exists but is empty \u2014 defaults apply)";
+  return parts.join("\n  ");
+}
+function printInstructions2(r) {
+  const userConfPath = r.userConf.path === null ? "~/.tmux.conf (none found)" : r.userConf.path;
+  const userConfForCopy = r.userConf.path === null ? "~/.tmux.conf" : r.userConf.path;
+  console.log(`
+<claude-instructions>
+# Sisyphus Statusbar Helper
+
+This is a READ-ONLY check. Use it to figure out how to help the user improve their
+tmux statusbar with sisyphus segments WITHOUT clobbering their existing setup. The
+user's tmux config is theirs \u2014 never overwrite it. Append, suggest snippets, or
+nudge them to edit ~/.sisyphus/config.json.
+
+## Environment Data
+- tmuxInstalled: ${r.tmuxInstalled}
+- tmuxServerRunning: ${r.tmuxServerRunning}
+- daemonRunning: ${r.daemonRunning}  (false = @sisyphus_left/@sisyphus_right won't get populated, statusbar will look broken until daemon is up)
+
+### Live tmux options
+- status: ${fmtOption(r.tmuxOptions.status)}
+- status-left: ${fmtOption(r.tmuxOptions.statusLeft)}
+- status-right: ${fmtOption(r.tmuxOptions.statusRight)}
+- status-position: ${fmtOption(r.tmuxOptions.statusPosition)}
+- status-style: ${fmtOption(r.tmuxOptions.statusStyle)}
+- status-interval: ${fmtOption(r.tmuxOptions.statusInterval)}
+- referencesSisyphusLeft: ${r.referencesSisyphusLeft}
+- referencesSisyphusRight: ${r.referencesSisyphusRight}
+
+### User tmux config
+- path: ${userConfPath}
+- setsStatusLeft: ${r.userConf.setsStatusLeft}
+- setsStatusRight: ${r.userConf.setsStatusRight}
+- sourcesSisyphusManaged: ${r.userConf.sourcesSisyphusManaged}  (sources ~/.sisyphus/tmux.conf \u2014 keybinds, NOT statusbar; included for context)
+
+### Sisyphus statusbar config (~/.sisyphus/config.json \u2192 statusBar)
+  ${renderConfigSummary(r.globalConfig)}
+
+### Available segments
+- session-name (left default) \u2014 current tmux session name
+- windows (left default) \u2014 tmux window list with active highlight
+- sessions (right default) \u2014 all tmux sessions with claude-state colors
+- sisyphus-sessions (right default) \u2014 sisyphus-managed sessions with phase indicators
+- companion (right default) \u2014 companion mood/state pill
+- clock \u2014 separate %H:%M (NOT a sisyphus segment; tmux renders it inline; the default
+  ~/.tmux.conf appends \`#[fg=...]#[bg=...] %H:%M \` after #{E:@sisyphus_right})
+
+## Detected state: **${r.state}**
+
+Pick exactly one path. Each path tells you what to ask the user and what to do.
+
+### Path A \u2014 Already wired (state: wired)
+**Trigger:** status-left and status-right both reference @sisyphus_left/@sisyphus_right.
+**Action:** ${r.state === "wired" ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"}
+
+The plumbing is correct. ${r.daemonRunning ? "" : "BUT daemon is not running \u2014 run `sisyphusd start` (or restart) so the @sisyphus_* options get populated. "}Now offer to **customize** what's shown:
+
+  1. **Reorder or hide segments.** Edit \`~/.sisyphus/config.json\`, set \`statusBar.left\` / \`statusBar.right\` to the array of segment ids you want (in order). Example to hide windows and reorder:
+     \`\`\`json
+     {
+       "statusBar": {
+         "left": ["session-name"],
+         "right": ["sisyphus-sessions", "companion"]
+       }
+     }
+     \`\`\`
+  2. **Recolor.** \`statusBar.colors\` overrides processing/stopped/idle/activeBg/activeText/inactiveText. \`statusBar.segments.<id>.bg\` overrides per-segment band background.
+  3. **Disable a single segment.** Remove its id from the left/right arrays.
+  4. **Disable the whole bar.** \`statusBar.enabled: false\` \u2014 daemon stops writing the options; the user's status-left/right will then render as literal \`#{E:@sisyphus_left}\` (which tmux silently treats as empty).
+  5. **Restart the daemon** after any config change: \`sisyphusd restart\`. Changes don't auto-apply.
+
+Ask the user what they want to change. Edit \`~/.sisyphus/config.json\` for them \u2014 that file is sisyphus-managed config, safe to edit. Don't touch their \`~/.tmux.conf\`.
+
+### Path B \u2014 Partial wiring (state: partial-left-only or partial-right-only)
+**Trigger:** Only one side references sisyphus.
+**Action:** ${r.state === "partial-left-only" || r.state === "partial-right-only" ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"}
+
+Their config is half-wired. Show them the missing side:
+  - Missing left \u2192 suggest adding \`set -g status-left "#{E:@sisyphus_left}"\` to ${userConfForCopy}
+  - Missing right \u2192 suggest adding \`set -g status-right "#{E:@sisyphus_right}#[fg=#2d2f33]#[bg=#2d2f33,fg=#b0a898] %H:%M "\`
+
+Don't auto-edit their config \u2014 present the snippet and ask if they want you to append it.
+
+### Path C \u2014 Stock tmux statusbar (state: tmux-default)
+**Trigger:** status-left/right are tmux defaults; user has no custom statusbar.
+**Action:** ${r.state === "tmux-default" ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"}
+
+Easiest case. Two options to offer:
+
+  1. **Full sisyphus statusbar.** Append these lines to ${userConfForCopy} (NOT a clobber \u2014 pure additive):
+     \`\`\`tmux
+     # --- Sisyphus statusbar ---
+     set -g status on
+     set -g status-style "bg=#1d1e21,fg=#d4cbb8"
+     set -g status-position bottom
+     set -g status-left "#{E:@sisyphus_left}"
+     set -g status-left-length 250
+     set -g status-right "#{E:@sisyphus_right}#[fg=#2d2f33]#[bg=#2d2f33,fg=#b0a898] %H:%M "
+     set -g status-right-length 250
+     set -g status-interval 2
+     set -g window-status-format ""
+     set -g window-status-current-format ""
+     set -g window-status-separator ""
+     \`\`\`
+     ${r.userConf.path === null ? `Note: no tmux config exists yet. Create ${userConfForCopy} with these lines.` : ""}
+
+  2. **Minimal sisyphus pill on the right.** If they want to keep the stock left side and just add a single sisyphus pill on the right:
+     \`\`\`tmux
+     set -g status-right "#{E:@sisyphus_right}#[default] %H:%M "
+     set -g status-right-length 200
+     \`\`\`
+
+After appending, run \`tmux source-file ${userConfForCopy}\` so the change takes effect immediately.
+
+### Path D \u2014 User has a custom statusbar (state: custom-no-sisyphus)
+**Trigger:** status-left/right are user-customized but don't reference sisyphus tokens.
+**Action:** ${r.state === "custom-no-sisyphus" ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"}
+
+This is the most delicate case \u2014 they care enough to have customized their bar. **Do not overwrite.** Show them the current contents and offer additive integration:
+
+Their current right side is currently:
+  \`\`\`
+  ${r.tmuxOptions.statusRight === null ? "(unset)" : r.tmuxOptions.statusRight}
+  \`\`\`
+And left side:
+  \`\`\`
+  ${r.tmuxOptions.statusLeft === null ? "(unset)" : r.tmuxOptions.statusLeft}
+  \`\`\`
+
+Offer three integration patterns and let the user pick:
+
+  1. **Append sisyphus to the right side** (most common \u2014 leaves their left alone):
+     \`\`\`tmux
+     set -g status-right "${r.tmuxOptions.statusRight === null ? "" : r.tmuxOptions.statusRight}#{E:@sisyphus_right}"
+     \`\`\`
+     Or prepend it (sisyphus content appears first/leftmost):
+     \`\`\`tmux
+     set -g status-right "#{E:@sisyphus_right}${r.tmuxOptions.statusRight === null ? "" : r.tmuxOptions.statusRight}"
+     \`\`\`
+
+  2. **Append to the left side** (if they want session/windows pills at the start):
+     \`\`\`tmux
+     set -g status-left "${r.tmuxOptions.statusLeft === null ? "" : r.tmuxOptions.statusLeft}#{E:@sisyphus_left}"
+     \`\`\`
+
+  3. **Slim sisyphus only.** If they only want one specific signal (e.g., just sisyphus-sessions), they can set \`statusBar.right: ["sisyphus-sessions"]\` in \`~/.sisyphus/config.json\` and then append \`#{E:@sisyphus_right}\` to their existing right side. The composed string will only contain that one segment.
+
+Important: the user's existing string may include format conditionals or special characters; use the exact value above when proposing the snippet (do not retype). Confirm with the user before editing ${userConfForCopy} \u2014 present the diff first.
+
+### Path E \u2014 Statusbar is disabled (state: disabled)
+**Trigger:** \`set -g status off\`.
+**Action:** ${r.state === "disabled" ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"}
+
+The user explicitly turned off the statusbar. Don't enable it without asking. Suggest:
+  - "I noticed you have the statusbar disabled (\`set -g status off\` in your config). Sisyphus needs it on to show session state. Want me to enable it and add a minimal sisyphus pill, or leave it as-is?"
+
+If they say yes \u2192 fall through to Path C, option 2 (minimal pill).
+
+### Path F \u2014 tmux not ready (state: tmux-not-ready)
+**Trigger:** tmux isn't installed or no server is running.
+**Action:** ${r.state === "tmux-not-ready" ? "\u2713 THIS IS YOUR PATH." : "(not applicable)"}
+
+Don't propose statusbar changes yet:
+  - tmuxInstalled=false \u2192 install tmux first (\`brew install tmux\` on macOS)
+  - tmuxServerRunning=false \u2192 user needs to run \`tmux\` (or attach to a session)
+
+Re-run \`sis admin check-statusbar\` once tmux is up.
+
+## Daemon reminder
+Even with status-left/right perfectly wired, the bar will show literal \`#{E:@sisyphus_left}\` (rendered as empty) until the daemon is running and has populated the option at least once. Always end this flow by checking \`daemonRunning: true\` above; if false, run \`sisyphusd start\` (or \`sisyphusd restart\` if it's stuck).
+
+## After acting
+Re-run \`sis admin check-statusbar\` to verify the new state. If anything looks wrong, the JSON form (\`sis admin check-statusbar --json\`) is easier to diff against expected values.
+</claude-instructions>
+`);
+}
+function registerCheckStatusbar(program2) {
+  program2.command("check-statusbar").description("Inspect tmux statusbar state and emit a Claude decision tree for non-clobbering integration").option("--json", "Print raw JSON state instead of Claude instructions").action((opts) => {
+    const result = runCheck2();
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    printInstructions2(result);
+  });
+}
+
+// src/cli/commands/home-init.ts
+init_shell();
+import { execSync as execSync13 } from "child_process";
 function registerHomeInit(parent) {
   parent.command("home-init <name> <cwd>").description("Bootstrap a tmux home session with the sisyphus dashboard.").action((name, cwd) => {
     ensureSession(name, cwd);
@@ -5197,7 +6174,7 @@ function registerHomeInit(parent) {
 }
 function sessionExists(name) {
   try {
-    execSync11(`tmux has-session -t ${shellQuote(name)}`, { stdio: "pipe" });
+    execSync13(`tmux has-session -t ${shellQuote(name)}`, { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -5205,13 +6182,13 @@ function sessionExists(name) {
 }
 function ensureSession(name, cwd) {
   if (sessionExists(name)) return;
-  execSync11(
+  execSync13(
     `tmux new-session -d -s ${shellQuote(name)} -c ${shellQuote(cwd)}`,
     { stdio: "pipe" }
   );
 }
 function setSessionCwd(name, cwd) {
-  execSync11(
+  execSync13(
     `tmux set-option -t ${shellQuote(name)} @sisyphus_cwd ${shellQuote(cwd.replace(/\/+$/, ""))}`,
     { stdio: "pipe" }
   );
@@ -5219,10 +6196,10 @@ function setSessionCwd(name, cwd) {
 
 // src/cli/commands/doctor.ts
 init_paths();
-import { execSync as execSync12 } from "child_process";
-import { existsSync as existsSync15, statSync as statSync3 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join16 } from "path";
+import { execSync as execSync14 } from "child_process";
+import { existsSync as existsSync17, statSync as statSync3 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join18 } from "path";
 function checkNodeVersion() {
   const major = parseInt(process.versions.node.split(".")[0], 10);
   if (major < 22) {
@@ -5232,7 +6209,7 @@ function checkNodeVersion() {
 }
 function checkClaudeCli() {
   try {
-    execSync12("which claude", { stdio: "pipe" });
+    execSync14("which claude", { stdio: "pipe" });
     return { name: "Claude CLI", status: "ok", detail: "Found on PATH" };
   } catch {
     return {
@@ -5245,7 +6222,7 @@ function checkClaudeCli() {
 }
 function checkGit() {
   try {
-    const version = execSync12("git --version", { encoding: "utf-8", stdio: "pipe" }).trim();
+    const version = execSync14("git --version", { encoding: "utf-8", stdio: "pipe" }).trim();
     return { name: "git", status: "ok", detail: version };
   } catch {
     return { name: "git", status: "fail", detail: "Not found on PATH", fix: "Install git: https://git-scm.com/downloads" };
@@ -5253,7 +6230,7 @@ function checkGit() {
 }
 function checkTmuxVersion() {
   try {
-    const version = execSync12("tmux -V", { encoding: "utf-8", stdio: "pipe" }).trim();
+    const version = execSync14("tmux -V", { encoding: "utf-8", stdio: "pipe" }).trim();
     const match = version.match(/(\d+\.\d+)/);
     if (!match) return { name: "tmux version", status: "warn", detail: `Could not parse version: ${version}` };
     const ver = parseFloat(match[1]);
@@ -5279,7 +6256,7 @@ function checkDaemonInstalled() {
     };
   }
   const pid = daemonPidPath();
-  if (existsSync15(pid)) {
+  if (existsSync17(pid)) {
     return { name: "Daemon setup", status: "ok", detail: `PID file found at ${pid}` };
   }
   return {
@@ -5291,7 +6268,7 @@ function checkDaemonInstalled() {
 }
 function checkDaemonRunning() {
   const pid = daemonPidPath();
-  if (!existsSync15(pid)) {
+  if (!existsSync17(pid)) {
     const fix = process.platform === "darwin" ? "launchctl load -w ~/Library/LaunchAgents/com.sisyphus.daemon.plist" : "sisyphusd & \u2014 or check if the process is running";
     return {
       name: "Daemon process",
@@ -5302,7 +6279,7 @@ function checkDaemonRunning() {
   }
   try {
     const sock = socketPath();
-    execSync12(`test -S "${sock}"`, { stdio: "pipe" });
+    execSync14(`test -S "${sock}"`, { stdio: "pipe" });
     return { name: "Daemon process", status: "ok", detail: `Socket at ${sock}` };
   } catch {
     return {
@@ -5315,13 +6292,13 @@ function checkDaemonRunning() {
 }
 function checkTmux() {
   try {
-    execSync12("which tmux", { stdio: "pipe" });
+    execSync14("which tmux", { stdio: "pipe" });
   } catch {
     const installHint = process.platform === "darwin" ? "brew install tmux" : "apt install tmux (Debian/Ubuntu) or your package manager";
     return { name: "tmux", status: "fail", detail: "Not found on PATH", fix: installHint };
   }
   try {
-    execSync12("tmux list-sessions", { stdio: "pipe" });
+    execSync14("tmux list-sessions", { stdio: "pipe" });
     return { name: "tmux", status: "ok", detail: "Running" };
   } catch {
     return { name: "tmux", status: "warn", detail: "Installed but no server running" };
@@ -5329,7 +6306,7 @@ function checkTmux() {
 }
 function checkCycleScript() {
   const path = cycleScriptPath();
-  if (!existsSync15(path)) {
+  if (!existsSync17(path)) {
     return {
       name: "Cycle script",
       status: "fail",
@@ -5354,7 +6331,7 @@ function checkCycleScript() {
 function checkTmuxKeybind() {
   const existing = getExistingBinding(DEFAULT_CYCLE_KEY);
   if (existing === null) {
-    if (existsSync15(sisyphusTmuxConfPath())) {
+    if (existsSync17(sisyphusTmuxConfPath())) {
       return {
         name: `Tmux keybind (${DEFAULT_CYCLE_KEY})`,
         status: "warn",
@@ -5380,7 +6357,7 @@ function checkTmuxKeybind() {
 }
 function checkGlobalDir() {
   const dir = globalDir();
-  if (existsSync15(dir)) {
+  if (existsSync17(dir)) {
     return { name: "Data directory", status: "ok", detail: dir };
   }
   return { name: "Data directory", status: "warn", detail: `${dir} does not exist (created on first use)` };
@@ -5432,7 +6409,7 @@ function checkSisyphusPlugin() {
 function checkTermrender() {
   if (isTermrenderAvailable()) {
     try {
-      const version = execSync12("termrender --version", { encoding: "utf-8", stdio: "pipe" }).trim();
+      const version = execSync14("termrender --version", { encoding: "utf-8", stdio: "pipe" }).trim();
       return { name: "termrender", status: "ok", detail: version };
     } catch {
       return { name: "termrender", status: "ok", detail: "installed" };
@@ -5451,7 +6428,7 @@ function checkNvim() {
     return { name: "nvim", status: "warn", detail: "Not installed", fix };
   }
   try {
-    const version = execSync12("nvim --version", { encoding: "utf-8", stdio: "pipe" }).split("\n")[0]?.replace("NVIM ", "");
+    const version = execSync14("nvim --version", { encoding: "utf-8", stdio: "pipe" }).split("\n")[0]?.replace("NVIM ", "");
     return { name: "nvim", status: "ok", detail: version ?? "installed" };
   } catch {
     return { name: "nvim", status: "ok", detail: "installed" };
@@ -5459,8 +6436,8 @@ function checkNvim() {
 }
 function checkNotifyBinary() {
   if (process.platform !== "darwin") return null;
-  const binary = join16(homedir9(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
-  if (existsSync15(binary)) {
+  const binary = join18(homedir11(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
+  if (existsSync17(binary)) {
     return { name: "Notifications", status: "ok", detail: "SisyphusNotify.app built" };
   }
   return {
@@ -5513,8 +6490,8 @@ function registerDoctor(program2) {
 }
 
 // src/cli/commands/init.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync7, writeFileSync as writeFileSync9 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, writeFileSync as writeFileSync9 } from "fs";
+import { join as join19 } from "path";
 var DEFAULT_CONFIG2 = {};
 var ORCHESTRATOR_TEMPLATE = `# Custom Orchestrator Prompt
 
@@ -5525,18 +6502,18 @@ var ORCHESTRATOR_TEMPLATE = `# Custom Orchestrator Prompt
 function registerInit(program2) {
   program2.command("init").description("Initialize sisyphus configuration for this project").option("--orchestrator", "Also create a custom orchestrator prompt template").action((opts) => {
     const cwd = process.cwd();
-    const sisDir = join17(cwd, ".sisyphus");
-    const configPath = join17(sisDir, "config.json");
-    if (existsSync16(configPath)) {
+    const sisDir = join19(cwd, ".sisyphus");
+    const configPath = join19(sisDir, "config.json");
+    if (existsSync18(configPath)) {
       console.log(`Already initialized: ${configPath}`);
       return;
     }
-    mkdirSync7(sisDir, { recursive: true });
+    mkdirSync8(sisDir, { recursive: true });
     writeFileSync9(configPath, JSON.stringify(DEFAULT_CONFIG2, null, 2) + "\n", "utf-8");
     console.log(`Created ${configPath}`);
     if (opts.orchestrator) {
-      const orchPath = join17(sisDir, "orchestrator.md");
-      if (!existsSync16(orchPath)) {
+      const orchPath = join19(sisDir, "orchestrator.md");
+      if (!existsSync18(orchPath)) {
         writeFileSync9(orchPath, ORCHESTRATOR_TEMPLATE, "utf-8");
         console.log(`Created ${orchPath}`);
       }
@@ -5579,7 +6556,7 @@ function registerUninstall(program2) {
 
 // src/cli/commands/configure-upload.ts
 init_paths();
-import { chmodSync as chmodSync2, existsSync as existsSync17, mkdirSync as mkdirSync8, readFileSync as readFileSync19, writeFileSync as writeFileSync10 } from "fs";
+import { chmodSync as chmodSync2, existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync21, writeFileSync as writeFileSync10 } from "fs";
 import { createInterface as createInterface3 } from "readline";
 import { dirname as dirname6 } from "path";
 async function readUrlFromInput(interactive) {
@@ -5637,16 +6614,16 @@ function registerConfigureUpload(program2) {
     const url = parsed.origin + (strippedPath.length > 0 ? strippedPath : "");
     const configPath = globalConfigPath();
     let existing = {};
-    if (existsSync17(configPath)) {
+    if (existsSync19(configPath)) {
       try {
-        existing = JSON.parse(readFileSync19(configPath, "utf-8"));
+        existing = JSON.parse(readFileSync21(configPath, "utf-8"));
       } catch {
         console.error(`Error: ${configPath} could not be parsed \u2014 fix or delete it first`);
         process.exit(1);
       }
     }
     const merged = { ...existing, upload: { url, token } };
-    mkdirSync8(dirname6(configPath), { recursive: true });
+    mkdirSync9(dirname6(configPath), { recursive: true });
     writeFileSync10(configPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
     chmodSync2(configPath, 384);
     console.log(`\u2713 upload configured (${configPath})`);
@@ -5654,11 +6631,11 @@ function registerConfigureUpload(program2) {
 }
 
 // src/cli/commands/getting-started.ts
-import { execSync as execSync13 } from "child_process";
-import { dirname as dirname7, join as join18 } from "path";
+import { execSync as execSync15 } from "child_process";
+import { dirname as dirname7, join as join20 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function templatePath(name) {
-  return join18(dirname7(fileURLToPath3(import.meta.url)), "templates", name);
+  return join20(dirname7(fileURLToPath3(import.meta.url)), "templates", name);
 }
 function isClaudeCode() {
   return !!process.env["CLAUDECODE"];
@@ -5983,18 +6960,30 @@ Two keybinds to remember (both use the RIGHT Option key):
 | Right Option + s | Cycle through sisyphus sessions |
 | Right Option + Shift + s | Jump back to dashboard |
 
-### 4. Verify keybinds are installed
+### 4. Verify keybinds are installed (REQUIRED before step 5)
+
+Run \`sis admin check-keybinds\` and follow the decision tree it emits. The output is
+structured for you \u2014 it tells you the current state and which path to take (Path A
+through Path F). Do NOT skip this and do NOT ask the user to test a keybind until
+both \`M-s\` and \`C-s\` read "sisyphus" in that command's output.
 
-Run \`sis admin doctor\` and check the output. Look for:
-- "Cycle script" \u2014 should be \u2713
-- "Tmux keybind" \u2014 should be \u2713
-- "Right Option Key" \u2014 should be "Esc+"
+Common paths:
+- **Path A (already wired):** confirm and move on.
+- **Path B (safe auto-install):** run \`sis admin setup-keybind --yes\`.
+- **Path C (would touch user's tmux.conf):** ask the user \u2014 persistent (\`--force\`) or
+  live-only (no flag, non-TTY auto-declines the conf write).
+- **Path D (binding conflict):** pick alternate keys or wire directly.
+- **Path E (hidden prefix collision):** their tmux prefix is C-s; explain and offer
+  alternatives.
+- **Path F (tmux not ready):** fix the precondition first.
 
-If cycle script or keybind is missing, run: \`sis admin setup-keybind\`
+After acting, re-run \`sis admin check-keybinds\` to confirm success.
 
 ### 5. Test the keybind
 
-Have the user try pressing Right Option + s. Nothing should happen yet (no sisyphus session running) \u2014 and that's fine. The important thing is no special character appears.
+Once check-keybinds reports both keys as "sisyphus", have the user try pressing
+Right Option + s. Nothing should happen yet (no sisyphus session running) \u2014 and that's
+fine. The important thing is no special character appears.
 
 If they see \`\xDF\` or similar, circle back to the Right Option Key setup above.
 
@@ -6134,11 +7123,11 @@ function printStep5() {
   let recentCommits = "";
   let topLevelFiles = "";
   try {
-    recentCommits = execSync13("git log --oneline -15 2>/dev/null", { encoding: "utf-8" }).trim();
+    recentCommits = execSync15("git log --oneline -15 2>/dev/null", { encoding: "utf-8" }).trim();
   } catch {
   }
   try {
-    topLevelFiles = execSync13("ls -1 2>/dev/null", { encoding: "utf-8" }).trim();
+    topLevelFiles = execSync15("ls -1 2>/dev/null", { encoding: "utf-8" }).trim();
   } catch {
   }
   console.log(`
@@ -6616,7 +7605,7 @@ function registerGettingStarted(program2) {
 
 // src/cli/commands/history.ts
 init_paths();
-import { readdirSync as readdirSync6, readFileSync as readFileSync20, existsSync as existsSync18 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync22, existsSync as existsSync20 } from "fs";
 import { resolve as resolve6 } from "path";
 var RESET3 = "\x1B[0m";
 var BOLD3 = "\x1B[1m";
@@ -6656,13 +7645,13 @@ function splitAgentTime(agents) {
 }
 function loadAllSummaries() {
   const base = historyBaseDir();
-  if (!existsSync18(base)) return [];
+  if (!existsSync20(base)) return [];
   const results = [];
   for (const name of readdirSync6(base)) {
     const summaryPath = historySessionSummaryPath(name);
-    if (existsSync18(summaryPath)) {
+    if (existsSync20(summaryPath)) {
       try {
-        const raw = readFileSync20(summaryPath, "utf-8");
+        const raw = readFileSync22(summaryPath, "utf-8");
         results.push({ id: name, summary: JSON.parse(raw) });
         continue;
       } catch {
@@ -6676,10 +7665,10 @@ function loadAllSummaries() {
 }
 function buildLiveSummary(sessionId) {
   const eventsPath = historyEventsPath(sessionId);
-  if (!existsSync18(eventsPath)) return null;
+  if (!existsSync20(eventsPath)) return null;
   let cwd = null;
   try {
-    const lines = readFileSync20(eventsPath, "utf-8").split("\n");
+    const lines = readFileSync22(eventsPath, "utf-8").split("\n");
     for (const line of lines) {
       if (!line.trim()) continue;
       try {
@@ -6697,10 +7686,10 @@ function buildLiveSummary(sessionId) {
   }
   if (!cwd) return null;
   const sPath = statePath(cwd, sessionId);
-  if (!existsSync18(sPath)) return null;
+  if (!existsSync20(sPath)) return null;
   let session2;
   try {
-    session2 = JSON.parse(readFileSync20(sPath, "utf-8"));
+    session2 = JSON.parse(readFileSync22(sPath, "utf-8"));
   } catch {
     return null;
   }
@@ -6761,8 +7750,8 @@ function buildLiveSummary(sessionId) {
 }
 function loadEvents(sessionId) {
   const eventsPath = historyEventsPath(sessionId);
-  if (!existsSync18(eventsPath)) return [];
-  const lines = readFileSync20(eventsPath, "utf-8").split("\n").filter((l) => l.trim());
+  if (!existsSync20(eventsPath)) return [];
+  const lines = readFileSync22(eventsPath, "utf-8").split("\n").filter((l) => l.trim());
   const events = [];
   for (const line of lines) {
     try {
@@ -6775,13 +7764,13 @@ function loadEvents(sessionId) {
 }
 function findSession(idOrName) {
   const summaryPath = historySessionSummaryPath(idOrName);
-  if (existsSync18(summaryPath)) {
+  if (existsSync20(summaryPath)) {
     try {
-      return { id: idOrName, summary: JSON.parse(readFileSync20(summaryPath, "utf-8")) };
+      return { id: idOrName, summary: JSON.parse(readFileSync22(summaryPath, "utf-8")) };
     } catch {
     }
   }
-  if (existsSync18(historySessionDir(idOrName))) {
+  if (existsSync20(historySessionDir(idOrName))) {
     const live = buildLiveSummary(idOrName);
     if (live) return { id: idOrName, summary: live };
   }
@@ -7170,21 +8159,21 @@ function registerHistory(program2) {
 init_paths();
 import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
-import { existsSync as existsSync19, readFileSync as readFileSync21, mkdirSync as mkdirSync9, symlinkSync, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join20 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync23, mkdirSync as mkdirSync10, symlinkSync, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
+import { homedir as homedir12 } from "os";
+import { join as join22 } 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 = join20(dir, `${base}.zip`);
+  let candidate = join22(dir, `${base}.zip`);
   let counter = 1;
-  while (existsSync19(candidate)) {
+  while (existsSync21(candidate)) {
     counter++;
-    candidate = join20(dir, `${base}-${counter}.zip`);
+    candidate = join22(dir, `${base}-${counter}.zip`);
   }
   return candidate;
 }
@@ -7246,33 +8235,33 @@ async function exportSessionToZip(sessionId, cwd, options) {
   const reveal = options?.reveal ?? true;
   const sessDir = sessionDir(cwd, sessionId);
   const histDir = historySessionDir(sessionId);
-  const sessExists = existsSync19(sessDir);
-  const histExists = existsSync19(histDir);
+  const sessExists = existsSync21(sessDir);
+  const histExists = existsSync21(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 (existsSync19(stPath)) {
+  if (existsSync21(stPath)) {
     try {
-      const state = JSON.parse(readFileSync21(stPath, "utf-8"));
+      const state = JSON.parse(readFileSync23(stPath, "utf-8"));
       if (state.name) {
         label = sanitizeName(state.name);
       }
     } catch {
     }
   }
-  const dir = options?.outputDir ?? join20(homedir10(), "Downloads");
+  const dir = options?.outputDir ?? join22(homedir12(), "Downloads");
   const outputPath = buildOutputPath(label, dir);
   const tmpDir = `/tmp/sisyphus-export-${sessionId.slice(0, 8)}-${Date.now()}`;
   try {
-    mkdirSync9(tmpDir, { recursive: true });
-    writeFileSync11(join20(tmpDir, "CLAUDE.md"), generateGuide(), "utf-8");
+    mkdirSync10(tmpDir, { recursive: true });
+    writeFileSync11(join22(tmpDir, "CLAUDE.md"), generateGuide(), "utf-8");
     if (sessExists) {
-      symlinkSync(sessDir, join20(tmpDir, "session"));
+      symlinkSync(sessDir, join22(tmpDir, "session"));
     }
     if (histExists) {
-      symlinkSync(histDir, join20(tmpDir, "history"));
+      symlinkSync(histDir, join22(tmpDir, "history"));
     }
     const parts = ["CLAUDE.md", sessExists ? "session/" : "", histExists ? "history/" : ""].filter(Boolean);
     await execFileAsync("zip", ["-rq", outputPath, ...parts], { cwd: tmpDir });
@@ -7394,12 +8383,12 @@ function buildManifest(args2) {
 }
 
 // src/shared/version.ts
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync24 } from "fs";
 import { resolve as resolve7 } from "path";
 function readSisyphusVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync22(resolve7(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync24(resolve7(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -7494,12 +8483,13 @@ function registerUpload(program2) {
 }
 
 // src/cli/commands/scratch.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync16 } from "child_process";
+init_shell();
 function findHomeSession(cwd) {
   const normalizedCwd = cwd.replace(/\/+$/, "");
   let output;
   try {
-    output = execSync14('tmux list-sessions -F "#{session_id}|#{session_name}"', {
+    output = execSync16('tmux list-sessions -F "#{session_id}|#{session_name}"', {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -7513,7 +8503,7 @@ function findHomeSession(cwd) {
     const name = line.slice(pipeIdx + 1);
     if (name.startsWith("ssyph_")) continue;
     try {
-      const val = execSync14(
+      const val = execSync16(
         `tmux show-options -t ${shellQuote(sessId)} -v @sisyphus_cwd`,
         { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
       ).trim();
@@ -7529,7 +8519,7 @@ function registerScratch(program2) {
     const cwd = opts.cwd ?? process.env["SISYPHUS_CWD"] ?? process.cwd();
     const homeSession = findHomeSession(cwd);
     if (!homeSession) {
-      const current = execSync14('tmux display-message -p "#{session_name}"', {
+      const current = execSync16('tmux display-message -p "#{session_name}"', {
         encoding: "utf-8"
       }).trim();
       openScratchWindow(current, cwd, promptParts.join(" "));
@@ -7539,7 +8529,7 @@ function registerScratch(program2) {
   });
 }
 function openScratchWindow(tmuxSession, cwd, prompt) {
-  const windowId = execSync14(
+  const windowId = execSync16(
     `tmux new-window -t ${shellQuote(tmuxSession + ":")} -n "scratch" -c ${shellQuote(cwd)} -P -F "#{window_id}"`,
     { encoding: "utf-8" }
   ).trim();
@@ -7547,7 +8537,7 @@ function openScratchWindow(tmuxSession, cwd, prompt) {
   if (prompt) {
     cmd += ` -p ${shellQuote(prompt)}`;
   }
-  execSync14(
+  execSync16(
     `tmux send-keys -t ${shellQuote(windowId)} ${shellQuote(cmd)} Enter`
   );
   console.log(`Scratch session opened in ${tmuxSession}`);
@@ -7555,27 +8545,27 @@ function openScratchWindow(tmuxSession, cwd, prompt) {
 
 // src/cli/commands/review.ts
 init_paths();
-import { join as join21, resolve as resolve8, dirname as dirname8 } from "path";
-import { existsSync as existsSync20, readFileSync as readFileSync23, writeFileSync as writeFileSync12, renameSync as renameSync3, readdirSync as readdirSync7 } from "fs";
+import { join as join23, resolve as resolve8, dirname as dirname8 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync25, writeFileSync as writeFileSync12, renameSync as renameSync3, readdirSync as readdirSync7 } from "fs";
 var _statusCheck = ["draft", "question", "approved", "rejected", "deferred"];
 function resolveContextArtifact(file, opts, filename, notFoundMessage) {
   const cwd = opts.cwd || process.env.SISYPHUS_CWD || process.cwd();
   if (file) return resolve8(file);
   const sessionId = opts.sessionId || process.env.SISYPHUS_SESSION_ID;
   if (sessionId) {
-    const target = join21(contextDir(cwd, sessionId), filename);
-    if (!existsSync20(target)) {
+    const target = join23(contextDir(cwd, sessionId), filename);
+    if (!existsSync22(target)) {
       console.error(`Error: File not found: ${target}`);
       process.exit(1);
     }
     return target;
   }
   const dir = sessionsDir(cwd);
-  if (existsSync20(dir)) {
+  if (existsSync22(dir)) {
     const sessions = readdirSync7(dir);
     for (const session2 of sessions.reverse()) {
-      const candidate = join21(dir, session2, "context", filename);
-      if (existsSync20(candidate)) return candidate;
+      const candidate = join23(dir, session2, "context", filename);
+      if (existsSync22(candidate)) return candidate;
     }
   }
   console.error(`Error: ${notFoundMessage}`);
@@ -7617,16 +8607,16 @@ Examples:
         "requirements.json",
         "No requirements.json found. Provide a path or use --session-id."
       );
-      if (!existsSync20(targetPath)) {
+      if (!existsSync22(targetPath)) {
         console.error(`Error: File not found: ${targetPath}`);
         process.exit(1);
       }
-      const parsed = JSON.parse(readFileSync23(targetPath, "utf-8"));
+      const parsed = JSON.parse(readFileSync25(targetPath, "utf-8"));
       const rendered = renderRequirementsMarkdown(parsed);
-      const outPath = join21(dirname8(targetPath), "requirements.md");
+      const outPath = join23(dirname8(targetPath), "requirements.md");
       const tmpPath = outPath + ".tmp";
-      if (existsSync20(outPath)) {
-        const existing = readFileSync23(outPath, "utf-8");
+      if (existsSync22(outPath)) {
+        const existing = readFileSync25(outPath, "utf-8");
         if (existing !== rendered) {
           if (!opts.force) {
             process.stderr.write(
@@ -9192,20 +10182,21 @@ function createBadgeGallery(unlockedAchievements, startIndex) {
 
 // src/daemon/companion-memory.ts
 init_paths();
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync25, renameSync as renameSync5, writeFileSync as writeFileSync14 } from "fs";
-import { dirname as dirname10, join as join23 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync27, renameSync as renameSync5, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname10, join as join25 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { z as z2 } from "zod";
 
 // src/daemon/haiku.ts
+init_env();
 import { query, createSdkMcpServer } from "@r-cli/sdk";
 var COOLDOWN_MS = 5 * 60 * 1e3;
 
 // src/daemon/companion.ts
 init_paths();
-import { existsSync as existsSync21, mkdirSync as mkdirSync10, readFileSync as readFileSync24, renameSync as renameSync4, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync11, readFileSync as readFileSync26, renameSync as renameSync4, writeFileSync as writeFileSync13 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import { dirname as dirname9, join as join22 } from "path";
+import { dirname as dirname9, join as join24 } from "path";
 
 // src/shared/companion-normalize.ts
 function emptyStats() {
@@ -9254,20 +10245,20 @@ function normalizeCompanion(state) {
 // src/daemon/companion.ts
 function loadCompanion() {
   const path = companionPath();
-  if (!existsSync21(path)) {
+  if (!existsSync23(path)) {
     const state2 = createDefaultCompanion();
     saveCompanion(state2);
     return state2;
   }
-  const raw = readFileSync24(path, "utf-8");
+  const raw = readFileSync26(path, "utf-8");
   const state = JSON.parse(raw);
   return normalizeCompanion(state);
 }
 function saveCompanion(state) {
   const path = companionPath();
   const dir = dirname9(path);
-  mkdirSync10(dir, { recursive: true });
-  const tmp = join22(dir, `.companion.${randomUUID3()}.tmp`);
+  mkdirSync11(dir, { recursive: true });
+  const tmp = join24(dir, `.companion.${randomUUID3()}.tmp`);
   writeFileSync13(tmp, JSON.stringify(state, null, 2), "utf-8");
   renameSync4(tmp, path);
 }
@@ -9340,10 +10331,10 @@ function fillDefaults(state) {
 }
 function loadMemoryStrict() {
   const path = resolvedMemoryPath();
-  if (!existsSync22(path)) return defaultMemoryState();
+  if (!existsSync24(path)) return defaultMemoryState();
   let raw;
   try {
-    raw = readFileSync25(path, "utf-8");
+    raw = readFileSync27(path, "utf-8");
   } catch (err) {
     throw new MemoryStoreParseError(err);
   }
@@ -9386,15 +10377,17 @@ var ObservationZodSchema = z2.object({
 });
 
 // src/daemon/companion-popup.ts
-import { writeFileSync as writeFileSync15, readFileSync as readFileSync26, unlinkSync as unlinkSync3, existsSync as existsSync23 } from "fs";
+import { writeFileSync as writeFileSync15, readFileSync as readFileSync28, unlinkSync as unlinkSync3, existsSync as existsSync25 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
-import { join as join24, resolve as resolve9 } from "path";
+import { join as join26, resolve as resolve9 } from "path";
+init_exec();
+init_shell();
 var POPUP_WIDTH = 38;
 var INNER_WIDTH = POPUP_WIDTH - 6;
 var POPUP_DURATION = 15;
-var POPUP_TMP_PREFIX = join24(tmpdir2(), "sisyphus-popup");
-var POPUP_SCRIPT = join24(tmpdir2(), "sisyphus-popup.sh");
-var POPUP_RESULT_PREFIX = join24(tmpdir2(), "sisyphus-popup-result");
+var POPUP_TMP_PREFIX = join26(tmpdir2(), "sisyphus-popup");
+var POPUP_SCRIPT = join26(tmpdir2(), "sisyphus-popup.sh");
+var POPUP_RESULT_PREFIX = join26(tmpdir2(), "sisyphus-popup-result");
 var WHIP_ANIMATION_PATH = resolve9(import.meta.dirname, "../templates/whip-animation.sh");
 var WHIP_ANIMATION_ROWS = 12;
 function wrapText2(text, width) {
@@ -9438,7 +10431,7 @@ function showCommentaryPopupQueue(pages) {
       if (contentHeight > maxContentHeight) maxContentHeight = contentHeight;
       writeFileSync15(`${POPUP_TMP_PREFIX}-${i}.txt`, content);
     }
-    const whipAvailable = existsSync23(WHIP_ANIMATION_PATH);
+    const whipAvailable = existsSync25(WHIP_ANIMATION_PATH);
     if (whipAvailable && maxContentHeight < WHIP_ANIMATION_ROWS + 2) {
       maxContentHeight = WHIP_ANIMATION_ROWS + 2;
     }
@@ -9512,7 +10505,7 @@ fi
     }
     let raw;
     try {
-      raw = readFileSync26(POPUP_RESULT_PREFIX, "utf8").trim();
+      raw = readFileSync28(POPUP_RESULT_PREFIX, "utf8").trim();
     } catch {
       return null;
     } finally {
@@ -9689,6 +10682,10 @@ function registerCompanion(program2) {
     const context = buildCompanionContext(opts.cwd);
     process.stdout.write(JSON.stringify({ additionalContext: context }));
   });
+  companion.command("pane").description("Open (or focus) a side claude pane next to the dashboard").option("--cwd <path>", "Project directory", process.cwd()).action(async (opts) => {
+    const { openCompanionPane: openCompanionPane2 } = await Promise.resolve().then(() => (init_tmux(), tmux_exports));
+    openCompanionPane2(opts.cwd);
+  });
   companion.command("popup-test").description("Show a test commentary popup to validate feedback key handling").option("--text <text>", "Custom popup text", "Cycle complete. Everything went exactly as planned. Nothing suspicious here.").action((opts) => {
     const feedback = showCommentaryPopup(opts.text);
     if (feedback === null) {
@@ -9705,14 +10702,15 @@ function registerCompanion(program2) {
 }
 
 // src/cli/commands/deploy.ts
-import { homedir as homedir11 } from "os";
-import { join as join25 } from "path";
+import { homedir as homedir13 } from "os";
+import { join as join28 } from "path";
 
 // src/cli/deploy/runner.ts
 init_paths();
-import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
-import { copyFileSync as copyFileSync2, existsSync as existsSync27, mkdirSync as mkdirSync13, readFileSync as readFileSync29 } from "fs";
+init_exec();
 init_creds();
+import { spawn as spawn2, spawnSync as spawnSync3 } from "child_process";
+import { copyFileSync as copyFileSync2, existsSync as existsSync30, mkdirSync as mkdirSync15, readFileSync as readFileSync32 } from "fs";
 
 // src/cli/deploy/pricing.ts
 var LAST_VERIFIED = "2026-05-06";
@@ -9747,12 +10745,12 @@ function formatCostLine(provider, instanceType) {
 // src/cli/deploy/runtime.ts
 init_atomic();
 init_paths();
-import { existsSync as existsSync25, readFileSync as readFileSync28, unlinkSync as unlinkSync4 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync31, unlinkSync as unlinkSync4 } from "fs";
 function readRuntimeState(provider) {
   const path = deployRuntimePath(provider);
-  if (!existsSync25(path)) return null;
+  if (!existsSync28(path)) return null;
   try {
-    return JSON.parse(readFileSync28(path, "utf-8"));
+    return JSON.parse(readFileSync31(path, "utf-8"));
   } catch {
     return null;
   }
@@ -9762,10 +10760,11 @@ function writeRuntimeState(provider, state) {
 }
 function clearRuntimeState(provider) {
   const path = deployRuntimePath(provider);
-  if (existsSync25(path)) unlinkSync4(path);
+  if (existsSync28(path)) unlinkSync4(path);
 }
 
 // src/cli/deploy/tailnet.ts
+init_exec();
 function discoverNode(requestedName) {
   const json = execSafe("tailscale status --json");
   if (!json) return null;
@@ -9811,15 +10810,15 @@ function isTailscaleAvailable() {
 }
 
 // src/cli/deploy/templates.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync29 } from "fs";
 import { dirname as dirname11, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 function deployRoot() {
   const here = dirname11(fileURLToPath4(import.meta.url));
   const bundled = resolve10(here, "..", "deploy");
-  if (existsSync26(bundled)) return bundled;
+  if (existsSync29(bundled)) return bundled;
   const sourceRoot = resolve10(here, "..", "..", "..", "deploy");
-  if (existsSync26(sourceRoot)) return sourceRoot;
+  if (existsSync29(sourceRoot)) return sourceRoot;
   throw new Error(
     `Could not locate deploy/ templates. Looked at:
   ${bundled}
@@ -10003,14 +11002,14 @@ function ensureTerraformInstalled() {
 function ensureProviderStateDir(provider) {
   ensureDeployDir();
   const dir = deployProviderDir(provider);
-  if (!existsSync27(dir)) mkdirSync13(dir, { recursive: true, mode: 448 });
+  if (!existsSync30(dir)) mkdirSync15(dir, { recursive: true, mode: 448 });
 }
 function backupState(provider) {
   const src = deployStatePath(provider);
-  if (existsSync27(src)) copyFileSync2(src, deployStateBackupPath(provider));
+  if (existsSync30(src)) copyFileSync2(src, deployStateBackupPath(provider));
 }
 function readSshPubkey(path) {
-  if (!existsSync27(path)) {
+  if (!existsSync30(path)) {
     const privateKeyPath = path.replace(/\.pub$/, "");
     throw new Error(
       `SSH pubkey not found at ${path}. Generate one with:
@@ -10018,7 +11017,7 @@ function readSshPubkey(path) {
 or pass --ssh-key <path>.`
     );
   }
-  return readFileSync29(path, "utf-8").trim();
+  return readFileSync32(path, "utf-8").trim();
 }
 function readOutputs(provider) {
   const result = spawnSync3("terraform", ["output", "-json", `-state=${deployStatePath(provider)}`], {
@@ -10045,7 +11044,7 @@ function readOutputs(provider) {
   }
 }
 function isProvisioned(provider) {
-  if (!existsSync27(deployStatePath(provider))) return false;
+  if (!existsSync30(deployStatePath(provider))) return false;
   return readOutputs(provider) !== null;
 }
 async function deployUp(provider, opts) {
@@ -10131,7 +11130,7 @@ Applied \u2014 but could not parse outputs. Run \`sis deploy ${provider} status\
   console.log("");
 }
 async function deployDown(provider, opts) {
-  if (!existsSync27(deployStatePath(provider))) {
+  if (!existsSync30(deployStatePath(provider))) {
     console.log(`No ${provider} state found at ${deployStatePath(provider)}. Nothing to destroy.`);
     return;
   }
@@ -10296,7 +11295,7 @@ function registerDeploy(program2) {
   });
   for (const provider of PROVIDERS) {
     const sub = deploy.command(provider).description(`${provider} commands.`);
-    sub.command("up").description(`Provision the ${provider} box (terraform init \u2192 plan \u2192 apply).`).option("--region <region>", `Provider region (defaults: hetzner=nbg1, aws=us-east-1).`).option("--arch <arch>", "'arm' (default) or 'x86'. Picks the default --size and image.", "arm").option("--size <size>", "Instance type override (defaults follow --arch).").option("--ssh-key <path>", "Path to SSH public key.", join25(homedir11(), ".ssh", "id_ed25519.pub")).option("--no-chromium", "Skip headless Chromium install.").option("--no-auto-update", "Skip the daily auto-update systemd timer.").option("--name <name>", "Box hostname / Tailscale node name.", "sisyphus").option("-y, --yes", "Skip the re-provision confirmation prompt when state already exists.").action(async (raw) => {
+    sub.command("up").description(`Provision the ${provider} box (terraform init \u2192 plan \u2192 apply).`).option("--region <region>", `Provider region (defaults: hetzner=nbg1, aws=us-east-1).`).option("--arch <arch>", "'arm' (default) or 'x86'. Picks the default --size and image.", "arm").option("--size <size>", "Instance type override (defaults follow --arch).").option("--ssh-key <path>", "Path to SSH public key.", join28(homedir13(), ".ssh", "id_ed25519.pub")).option("--no-chromium", "Skip headless Chromium install.").option("--no-auto-update", "Skip the daily auto-update systemd timer.").option("--name <name>", "Box hostname / Tailscale node name.", "sisyphus").option("-y, --yes", "Skip the re-provision confirmation prompt when state already exists.").action(async (raw) => {
       const opts = resolveUpOptions(provider, raw);
       await deployUp(provider, opts);
     });
@@ -10320,11 +11319,14 @@ function registerDeploy(program2) {
 
 // src/cli/cloud/runner.ts
 init_paths();
+init_shell();
+init_exec();
+init_creds();
 import { spawn as spawn4 } from "child_process";
 import { hostname } from "os";
-init_creds();
 
 // src/cli/deploy/ssh-exec.ts
+init_exec();
 import { spawn as spawn3, spawnSync as spawnSync4 } from "child_process";
 function runOnBox(provider, cmd) {
   const target = effectiveSshTarget(provider);
@@ -10355,6 +11357,7 @@ function runOnBoxStreaming(provider, cmd) {
 }
 
 // src/cli/cloud/grove.ts
+init_shell();
 var GROVE_VERSION = "0.2.13";
 function ensureGroveInstalled(provider) {
   const probe = runOnBox(provider, "command -v grove >/dev/null 2>&1");
@@ -10374,9 +11377,10 @@ function ensureGroveRegistered(provider, repo, instancePath) {
 }
 
 // src/cli/cloud/repo.ts
+init_exec();
 import { spawnSync as spawnSync5 } from "child_process";
-import { existsSync as existsSync28 } from "fs";
-import { basename as basename6, join as join26 } from "path";
+import { existsSync as existsSync31 } from "fs";
+import { basename as basename6, join as join29 } from "path";
 function captureGit(args2) {
   const result = spawnSync5("git", args2, {
     encoding: "utf-8",
@@ -10427,10 +11431,10 @@ function buildRsyncArgs(localDir, remoteTarget) {
   ];
 }
 function detectPackageManager(toplevel) {
-  if (existsSync28(join26(toplevel, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync28(join26(toplevel, "bun.lockb"))) return "bun";
-  if (existsSync28(join26(toplevel, "yarn.lock"))) return "yarn";
-  if (existsSync28(join26(toplevel, "package-lock.json"))) return "npm";
+  if (existsSync31(join29(toplevel, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync31(join29(toplevel, "bun.lockb"))) return "bun";
+  if (existsSync31(join29(toplevel, "yarn.lock"))) return "yarn";
+  if (existsSync31(join29(toplevel, "package-lock.json"))) return "npm";
   return null;
 }
 function packageManagerInstallCmd(pm) {
@@ -10450,6 +11454,7 @@ function packageManagerInstallCmd(pm) {
 
 // src/cli/cloud/sidecar.ts
 init_paths();
+init_shell();
 function readSidecar(provider, repo) {
   const path = boxCloudSidecarPath(repo);
   const result = runOnBox(provider, `cat ${shellQuoteHomePath(path)} 2>/dev/null`);
@@ -10658,6 +11663,7 @@ function pickProvider(explicit) {
 }
 
 // src/cli/commands/cloud.ts
+init_shell();
 function resolve11(raw) {
   const provider = pickProvider(raw.provider);
   const repo = raw.name ? raw.name : inferRepoName();
@@ -10712,8 +11718,8 @@ function attachNotify(diagnostic2) {
 
 // src/cli/commands/tmux-sessions.ts
 init_paths();
-import { execSync as execSync15 } from "child_process";
-import { readFileSync as readFileSync30, existsSync as existsSync29 } from "fs";
+import { execSync as execSync18 } from "child_process";
+import { readFileSync as readFileSync33, existsSync as existsSync32 } from "fs";
 var DOT_MAP = {
   "orchestrator:processing": { icon: "\u25CF", color: "#d4ad6a" },
   "orchestrator:idle": { icon: "\u25CF", color: "#d47766" },
@@ -10724,16 +11730,16 @@ var DOT_MAP = {
 };
 function readManifest() {
   const p = sessionsManifestPath();
-  if (!existsSync29(p)) return null;
+  if (!existsSync32(p)) return null;
   try {
-    return JSON.parse(readFileSync30(p, "utf-8"));
+    return JSON.parse(readFileSync33(p, "utf-8"));
   } catch {
     return null;
   }
 }
 function tmuxExec(cmd) {
   try {
-    return execSync15(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execSync18(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return null;
   }
@@ -10772,7 +11778,7 @@ if (nodeVersion < 22) {
 var program = new Command();
 program.name("sis").description("tmux-integrated orchestration daemon for Claude Code").version(
   JSON.parse(
-    readFileSync31(join27(dirname12(fileURLToPath5(import.meta.url)), "..", "package.json"), "utf-8")
+    readFileSync34(join30(dirname12(fileURLToPath5(import.meta.url)), "..", "package.json"), "utf-8")
   ).version
 );
 program.configureHelp({
@@ -10797,6 +11803,7 @@ registerReconnect(session);
 registerClone(session);
 registerSessionTask(session);
 registerSessionEffort(session);
+registerSessionDangerous(session);
 registerSessionContext(session);
 var agent = program.command("agent").description("Manage agents");
 registerSpawn(agent);
@@ -10813,6 +11820,8 @@ registerSegmentUnregister(segment);
 var admin = program.command("admin").description("Admin / setup commands");
 registerSetup(admin);
 registerSetupKeybind(admin);
+registerCheckKeybinds(admin);
+registerCheckStatusbar(admin);
 registerHomeInit(admin);
 registerDoctor(admin);
 registerInit(admin);
@@ -10843,8 +11852,8 @@ Run 'sis admin getting-started' for a complete usage guide.
 var args = process.argv.slice(2);
 var firstArg = args[0];
 var skipWelcome = ["admin", "help", "--help", "-h", "--version", "-V"];
-if (!existsSync30(globalDir()) && firstArg && !skipWelcome.includes(firstArg)) {
-  mkdirSync14(globalDir(), { recursive: true });
+if (!existsSync33(globalDir()) && firstArg && !skipWelcome.includes(firstArg)) {
+  mkdirSync16(globalDir(), { recursive: true });
   console.log("");
   console.log("  Welcome to Sisyphus. Run 'sis admin setup' to get started.");
   console.log("");