sisyphi 1.1.12 → 1.1.13

package/dist/tui.js

@@ -5,7 +5,7 @@ import {
   exec,
   execSafe,
   loadConfig
-} from "./chunk-ZSIYQB45.js";
+} from "./chunk-CAJEBTUE.js";
 import {
   buildSessionContext,
   computeActiveTimeMs,
@@ -226,6 +226,15 @@ function onResize(callback) {
 }
 
 // src/tui/state.ts
+var OPTIONAL_COMPOSE = /* @__PURE__ */ new Set(["resume", "continue"]);
+var COMPOSE_HEADERS = {
+  "new-session": "New Session",
+  "message-orchestrator": "Message Orchestrator",
+  "resume": "Resume Session",
+  "continue": "Continue Session",
+  "spawn-agent": "Spawn Agent",
+  "message-agent": "Message Agent"
+};
 var INPUT_MODES = /* @__PURE__ */ new Set([
   "resume",
   "continue",
@@ -352,6 +361,11 @@ function createAppState(cwd2) {
     prevNvimFile: null,
     nvimEditable: false,
     nvimOpenTabs: /* @__PURE__ */ new Map(),
+    composeAction: null,
+    composeTempFile: null,
+    composeSignalFile: null,
+    composePollTimer: null,
+    composePrevNvimFile: null,
     cwd: cwd2
   };
 }
@@ -415,8 +429,13 @@ function autoExpandCycle(state2) {
 }
 
 // src/tui/app.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, statSync } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync5, readdirSync, statSync as statSync2 } from "fs";
+import { join as join6 } from "path";
+
+// src/tui/input.ts
+import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "fs";
+import { join as join2 } from "path";
+import { tmpdir } from "os";
 
 // src/tui/lib/tree.ts
 import { join } from "path";
@@ -806,7 +825,18 @@ function findParentIndex(nodes, index) {
 // src/tui/input.ts
 function activateNvimBypass(state2) {
   setRawBypass((data) => {
+    if (!state2.nvimBridge?.ready) {
+      deactivateNvimBypass();
+      state2.focusPane = "tree";
+      if (state2.mode === "compose") cancelCompose(state2);
+      requestRender();
+      return false;
+    }
     if (data === "	") {
+      if (state2.mode === "compose") {
+        cancelCompose(state2);
+        return true;
+      }
       deactivateNvimBypass();
       state2.focusPane = state2.showCombinedView ? "logs" : "tree";
       requestRender();
@@ -819,6 +849,148 @@ function activateNvimBypass(state2) {
 function deactivateNvimBypass() {
   setRawBypass(null);
 }
+var COMPOSE_DIR = join2(tmpdir(), "sisyphus-nvim");
+function enterComposeMode(state2, action, actions) {
+  if (!state2.nvimEnabled || !state2.nvimBridge?.ready) return false;
+  mkdirSync(COMPOSE_DIR, { recursive: true });
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const tempFile = join2(COMPOSE_DIR, `compose-${id}.md`);
+  const signalFile = join2(COMPOSE_DIR, `compose-signal-${id}`);
+  writeFileSync(tempFile, "", "utf-8");
+  state2.composePrevNvimFile = state2.prevNvimFile;
+  state2.composeAction = action;
+  state2.composeTempFile = tempFile;
+  state2.composeSignalFile = signalFile;
+  state2.mode = "compose";
+  state2.focusPane = "detail";
+  state2.nvimBridge.openComposeFile(tempFile, signalFile);
+  activateNvimBypass(state2);
+  state2.composePollTimer = setInterval(() => {
+    checkComposeSignal(state2, actions);
+  }, 100);
+  requestRender();
+  return true;
+}
+function cancelCompose(state2) {
+  if (state2.composePollTimer !== null) {
+    clearInterval(state2.composePollTimer);
+    state2.composePollTimer = null;
+  }
+  if (state2.composeTempFile) {
+    try {
+      unlinkSync(state2.composeTempFile);
+    } catch {
+    }
+  }
+  if (state2.composeSignalFile) {
+    try {
+      unlinkSync(state2.composeSignalFile);
+    } catch {
+    }
+  }
+  state2.prevNvimFile = null;
+  state2.composePrevNvimFile = null;
+  state2.composeAction = null;
+  state2.composeTempFile = null;
+  state2.composeSignalFile = null;
+  state2.mode = "navigate";
+  state2.focusPane = "tree";
+  deactivateNvimBypass();
+  requestRender();
+}
+function checkComposeSignal(state2, actions) {
+  if (!state2.composeSignalFile || !state2.composeAction) return;
+  if (!state2.nvimBridge?.ready) {
+    cancelCompose(state2);
+    return;
+  }
+  if (!existsSync(state2.composeSignalFile)) return;
+  let signalContent = "";
+  try {
+    signalContent = readFileSync(state2.composeSignalFile, "utf-8").trim();
+  } catch {
+  }
+  if (signalContent === "cancel") {
+    cancelCompose(state2);
+    return;
+  }
+  let content = "";
+  if (state2.composeTempFile) {
+    try {
+      content = readFileSync(state2.composeTempFile, "utf-8").trim();
+    } catch {
+    }
+  }
+  const action = state2.composeAction;
+  const required = !OPTIONAL_COMPOSE.has(action.kind);
+  if (required && !content) {
+    try {
+      unlinkSync(state2.composeSignalFile);
+    } catch {
+    }
+    notify(state2, "Content required");
+    return;
+  }
+  dispatchComposeAction(action, content, state2, actions);
+  cancelCompose(state2);
+}
+function dispatchComposeAction(action, content, state2, actions) {
+  switch (action.kind) {
+    case "new-session":
+      actions.sendAndNotify(
+        { type: "start", task: content, cwd: state2.cwd },
+        "Session created"
+      );
+      break;
+    case "message-orchestrator":
+      actions.sendAndNotify(
+        { type: "message", sessionId: action.sessionId, content },
+        "Message queued"
+      );
+      break;
+    case "resume":
+      actions.sendAndNotify(
+        { type: "resume", sessionId: action.sessionId, cwd: state2.cwd, message: content || void 0 },
+        "Session resumed"
+      );
+      break;
+    case "continue":
+      void (async () => {
+        try {
+          const contRes = await actions.send({ type: "continue", sessionId: action.sessionId });
+          if (!contRes.ok) {
+            notify(state2, `Error: ${contRes.error}`);
+            return;
+          }
+          actions.sendAndNotify(
+            { type: "resume", sessionId: action.sessionId, cwd: state2.cwd, message: content || void 0 },
+            "Session continued"
+          );
+        } catch (err) {
+          notify(state2, `Error: ${err.message}`);
+        }
+      })();
+      break;
+    case "spawn-agent":
+      actions.sendAndNotify(
+        {
+          type: "spawn",
+          sessionId: action.sessionId,
+          agentType: "default",
+          name: "agent",
+          instruction: content
+        },
+        "Agent spawned"
+      );
+      break;
+    case "message-agent":
+      actions.sendAndNotify(
+        { type: "message", sessionId: action.sessionId, content, source: { type: "agent", agentId: action.agentId } },
+        `Message sent to ${action.agentId}`
+      );
+      break;
+  }
+}
 function handleCancel(state2) {
   state2.mode = "navigate";
   state2.targetAgentId = null;
@@ -1128,6 +1300,7 @@ function handleLeaderAction(action, state2, actions) {
         notify(state2, "No session selected");
         break;
       }
+      if (enterComposeMode(state2, { kind: "spawn-agent", sessionId: selectedSessionId }, actions)) return;
       state2.mode = "spawn-agent";
       requestRender();
       return;
@@ -1138,6 +1311,7 @@ function handleLeaderAction(action, state2, actions) {
         notify(state2, "Cursor must be on an agent");
         break;
       }
+      if (enterComposeMode(state2, { kind: "message-agent", sessionId: selectedSessionId, agentId: agent.id }, actions)) return;
       state2.targetAgentId = agent.id;
       state2.mode = "message-agent";
       requestRender();
@@ -1408,6 +1582,7 @@ function handleNavigateKey(input, key, state2, actions) {
       notify(state2, "No session selected");
       return;
     }
+    if (enterComposeMode(state2, { kind: "message-orchestrator", sessionId: state2.selectedSessionId }, actions)) return;
     const editor = actions.resolveEditor();
     try {
       const content = actions.editInPopup(state2.cwd, editor);
@@ -1427,6 +1602,22 @@ function handleNavigateKey(input, key, state2, actions) {
       notify(state2, "No session selected");
       return;
     }
+    if (session.status === "completed") {
+      const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
+      const claudeSessionId = lastCycle?.claudeSessionId;
+      if (!claudeSessionId) {
+        notify(state2, "No orchestrator Claude session ID available");
+        return;
+      }
+      try {
+        const label = session.name ?? state2.selectedSessionId.slice(0, 8);
+        const sessionName = actions.openClaudeResumeSession(state2.cwd, claudeSessionId, label);
+        actions.switchToSession(sessionName);
+      } catch {
+        notify(state2, "Failed to open Claude session");
+      }
+      return;
+    }
     if (state2.paneAlive && session.tmuxWindowId) {
       if (session.tmuxSessionName) actions.switchToSession(session.tmuxSessionName);
       actions.selectWindow(session.tmuxWindowId);
@@ -1487,6 +1678,7 @@ function handleNavigateKey(input, key, state2, actions) {
     return;
   }
   if (input === "n") {
+    if (enterComposeMode(state2, { kind: "new-session" }, actions)) return;
     const editor = actions.resolveEditor();
     try {
       const content = actions.editInPopup(state2.cwd, editor);
@@ -1553,6 +1745,7 @@ function handleNavigateKey(input, key, state2, actions) {
       notify(state2, "Session already active");
       return;
     }
+    if (enterComposeMode(state2, { kind: "resume", sessionId: state2.selectedSessionId }, actions)) return;
     state2.mode = "resume";
     state2.inputText = "";
     state2.inputCursorPos = 0;
@@ -1568,6 +1761,7 @@ function handleNavigateKey(input, key, state2, actions) {
       notify(state2, "Session not completed");
       return;
     }
+    if (enterComposeMode(state2, { kind: "continue", sessionId: state2.selectedSessionId }, actions)) return;
     state2.mode = "continue";
     state2.inputText = "";
     state2.inputCursorPos = 0;
@@ -1638,6 +1832,7 @@ function handleNavigateKey(input, key, state2, actions) {
   }
 }
 function handleKeypress(input, key, state2, actions) {
+  if (state2.mode === "compose") return;
   if (INPUT_MODES.has(state2.mode)) {
     handleInputBarKey(input, key, state2, actions);
   } else if (state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "help") {
@@ -2025,9 +2220,9 @@ function send(request) {
 
 // src/tui/lib/tmux.ts
 import { execSync } from "child_process";
-import { join as join2 } from "path";
-import { readFileSync, writeFileSync, mkdtempSync, rmSync, cpSync, existsSync, mkdirSync } from "fs";
-import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdtempSync, rmSync, cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
 function selectWindow(windowId) {
   execSafe(`tmux select-window -t "${windowId}"`);
 }
@@ -2044,9 +2239,9 @@ function listAllWindowIds() {
 }
 var companionPaneId = null;
 function setupCompanionPlugin() {
-  const srcDir = join2(import.meta.dirname, "templates", "companion-plugin");
-  const destDir = join2(globalDir(), "companion-plugin");
-  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+  const srcDir = join3(import.meta.dirname, "templates", "companion-plugin");
+  const destDir = join3(globalDir(), "companion-plugin");
+  if (!existsSync2(destDir)) mkdirSync2(destDir, { recursive: true });
   cpSync(srcDir, destDir, { recursive: true });
   return destDir;
 }
@@ -2059,18 +2254,18 @@ function openCompanionPane(cwd2) {
     return;
   }
   const pluginDir = setupCompanionPlugin();
-  const templatePath = join2(import.meta.dirname, "templates", "dashboard-claude.md");
+  const templatePath = join3(import.meta.dirname, "templates", "dashboard-claude.md");
   let template;
   try {
-    template = readFileSync(templatePath, "utf-8");
+    template = readFileSync2(templatePath, "utf-8");
   } catch {
     template = `You are a Sisyphus dashboard companion. Help the user manage multi-agent sessions.
 Project: ${cwd2}
 Run \`sisyphus list\` and \`sisyphus status\` to see current state.`;
   }
   const rendered = template.replace(/\{\{CWD\}\}/g, cwd2);
-  const promptPath = join2(globalDir(), "dashboard-companion-prompt.md");
-  writeFileSync(promptPath, rendered, "utf-8");
+  const promptPath = join3(globalDir(), "dashboard-companion-prompt.md");
+  writeFileSync2(promptPath, rendered, "utf-8");
   const pathEnv = augmentedPath();
   const claudeCmd = `SISYPHUS_COMPANION_CWD=${shellQuote(cwd2)} PATH=${shellQuote(pathEnv)} claude --dangerously-skip-permissions --plugin-dir ${shellQuote(pluginDir)} --append-system-prompt "$(cat ${shellQuote(promptPath)})"`;
   const result = exec(
@@ -2083,12 +2278,12 @@ function switchToSession(sessionName) {
   execSafe(`tmux switch-client -t "${sessionName}"`);
 }
 function editInPopup(cwd2, editor, opts) {
-  const tmpDir = mkdtempSync(join2(tmpdir(), "sisyphus-"));
-  const filePath = join2(tmpDir, "input.md");
+  const tmpDir = mkdtempSync(join3(tmpdir2(), "sisyphus-"));
+  const filePath = join3(tmpDir, "input.md");
   try {
-    writeFileSync(filePath, opts?.content ? opts.content : "", "utf-8");
+    writeFileSync2(filePath, opts?.content ? opts.content : "", "utf-8");
     openEditorPopup(cwd2, editor, filePath, opts?.size);
-    const result = readFileSync(filePath, "utf-8").trim();
+    const result = readFileSync2(filePath, "utf-8").trim();
     return result || null;
   } finally {
     rmSync(tmpDir, { recursive: true, force: true });
@@ -2117,6 +2312,19 @@ function openClaudeResumePopup(cwd2, claudeSessionId) {
     { stdio: "inherit", env: EXEC_ENV }
   );
 }
+function openClaudeResumeSession(cwd2, claudeSessionId, sessionLabel) {
+  const pathEnv = augmentedPath();
+  const cmd = `PATH=${shellQuote(pathEnv)} claude --resume ${shellQuote(claudeSessionId)}`;
+  const sessionName = `sisyphus-${sessionLabel}-resume`;
+  exec(`tmux new-session -d -s ${shellQuote(sessionName)} -c ${shellQuote(cwd2)} ${shellQuote(cmd)}`);
+  execSafe(`tmux set-option -t ${shellQuote(sessionName)} @sisyphus_cwd ${shellQuote(cwd2.replace(/\/+$/, ""))}`);
+  const paneTarget = `${sessionName}:`;
+  execSafe(`tmux set -w -t ${shellQuote(paneTarget)} pane-border-status top`);
+  execSafe(`tmux set -w -t ${shellQuote(paneTarget)} allow-rename off`);
+  execSafe(`tmux set -w -t ${shellQuote(paneTarget)} automatic-rename off`);
+  execSafe(`tmux select-pane -t ${shellQuote(paneTarget)} -T ${shellQuote(`ssph:resume ${sessionLabel}`)}`);
+  return sessionName;
+}
 function openEditorPopup(cwd2, editor, filePath, size) {
   const { w = "90%", h = "90%" } = size ?? {};
   const editorBin = editor.split(/\s+/)[0].split("/").pop();
@@ -2961,7 +3169,7 @@ function renderLogsRows(rect, state2) {
 }
 
 // src/tui/panels/nvim-detail.ts
-function renderNvimDetailRows(rect, bridge, focused, editable, statusRows) {
+function renderNvimDetailRows(rect, bridge, focused, editable, statusRows, composing = false) {
   const { w, h } = rect;
   const rows = new Array(h);
   const borderColor = focused ? "cyan" : "gray";
@@ -2969,7 +3177,7 @@ function renderNvimDetailRows(rect, bridge, focused, editable, statusRows) {
   const reset = "\x1B[0m";
   const innerW = w - 4;
   if (focused) {
-    const badgeText = editable ? " EDIT " : " NVIM ";
+    const badgeText = composing ? " COMPOSE " : editable ? " EDIT " : " NVIM ";
     const badgeLen = badgeText.length;
     const dashesLeft = 2;
     const dashesRight = Math.max(0, w - 2 - dashesLeft - badgeLen);
@@ -3019,6 +3227,13 @@ function renderNotificationRow(buf, y, notification, error) {
 }
 function renderInputBar(buf, y, state2) {
   const { mode, inputText, inputCursorPos } = state2;
+  if (mode === "compose") {
+    const action = state2.composeAction;
+    const label = action ? COMPOSE_HEADERS[action.kind] : "Compose";
+    const content2 = `\x1B[1;33mCOMPOSE\x1B[0m\x1B[2m  ${label} \xB7 :w to submit \xB7 Tab to cancel\x1B[0m`;
+    writeClipped(buf, 1, y, content2, buf.width - 2);
+    return;
+  }
   if (mode === "navigate") {
     const content2 = `\x1B[2mPress [m] to message orchestrator, [n] for new session\x1B[0m`;
     writeClipped(buf, 1, y, content2, buf.width - 2);
@@ -3040,6 +3255,7 @@ var SEP = D("\u2502 ");
 function renderStatusLine(buf, y, state2, cursorNodeType) {
   const { mode, focusPane } = state2;
   if (mode === "report-detail") return;
+  if (mode === "compose") return;
   let content;
   if (mode === "leader") {
     content = `\x1B[1;35mLEADER\x1B[0m` + D("  press a command key or [esc] to cancel");
@@ -3169,9 +3385,17 @@ function renderHelpOverlay(buf, rows, cols) {
 
 // src/tui/lib/nvim-bridge.ts
 import { execSync as execSync3 } from "child_process";
-import { writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync } from "fs";
-import { join as join3 } from "path";
-import { tmpdir as tmpdir2 } from "os";
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, readFileSync as readFileSync3, statSync, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
 var NvimBridge = class {
   pty = null;
   xterm = null;
@@ -3183,20 +3407,28 @@ var NvimBridge = class {
   ready = false;
   dirty = true;
   available = false;
+  respawning = false;
+  /** Set true once nvim has been ready at least once — prevents respawn during initial startup */
+  wasReady = false;
   /** DECSCUSR cursor style: 0=default, 1=blinking block, 2=steady block, 3=blinking underline, 4=steady underline, 5=blinking bar, 6=steady bar */
   cursorStyle = 0;
   cachedRows = null;
   nvimPath = "nvim";
   pendingFiles = null;
   fileDebounceTimer = null;
+  cmdDir;
   cmdFile;
+  /** Tracked editable files: path → { basePath (snapshot), mtimeMs } */
+  editableFiles = /* @__PURE__ */ new Map();
+  mergeStatusFile;
   constructor(cols, rows, onRender) {
     this._cols = cols;
     this._rows = rows;
     this.onRender = onRender;
-    const cmdDir = join3(tmpdir2(), "sisyphus-nvim");
-    mkdirSync2(cmdDir, { recursive: true });
-    this.cmdFile = join3(cmdDir, `cmd-${process.pid}.lua`);
+    this.cmdDir = join4(tmpdir3(), "sisyphus-nvim");
+    mkdirSync3(this.cmdDir, { recursive: true });
+    this.cmdFile = join4(this.cmdDir, `cmd-${process.pid}.lua`);
+    this.mergeStatusFile = join4(this.cmdDir, `merge-status-${process.pid}.txt`);
     try {
       this.nvimPath = execSync3("which nvim", { stdio: "pipe" }).toString().trim();
       this.available = true;
@@ -3209,71 +3441,111 @@ var NvimBridge = class {
       this.ready = false;
     });
   }
-  async spawn() {
-    const { spawn } = await import("node-pty");
-    const xtermModule = await import("@xterm/headless");
-    const { Terminal } = xtermModule.default;
-    this.xterm = new Terminal({
-      cols: this._cols,
-      rows: this._rows,
-      allowProposedApi: true
-    });
-    const nvimArgs = [
-      // Pre-init: only settings needed before user config loads
-      "--cmd",
-      [
-        "set noswapfile",
-        "set nobackup",
-        "set nowritebackup",
-        "set hidden",
-        "set autoread"
-      ].join(" | "),
-      // Post-init: cosmetic overrides applied AFTER user config (LazyVim, etc.)
-      "-c",
-      [
-        "set laststatus=0",
-        "set showtabline=2",
-        "set signcolumn=no",
-        "set nonumber",
-        "set noruler",
-        "set noshowcmd",
-        "set noshowmode",
-        "set shortmess+=F",
-        "set fillchars=eob:\\ ",
-        "set scrolloff=3"
-      ].join(" | "),
-      // Suppress LSP — prevent servers from ever starting (avoids exit warnings)
-      "--cmd",
-      "lua vim.lsp.start = function() end",
-      // Poll-based command executor: reads lua from temp file — no command-line flash
-      "-c",
-      `lua local _t = vim.loop.new_timer(); _t:start(100, 50, vim.schedule_wrap(function() local f = io.open('${this.cmdFile.replace(/'/g, "\\'")}', 'r'); if not f then return end; local c = f:read('*a'); f:close(); os.remove('${this.cmdFile.replace(/'/g, "\\'")}'); if c and #c > 0 then local fn = loadstring(c); if fn then pcall(fn) end end end))`
-    ];
-    this.pty = spawn(this.nvimPath, nvimArgs, {
-      name: "xterm-256color",
-      cols: this._cols,
-      rows: this._rows,
-      env: { ...process.env, TERM: "xterm-256color" }
-    });
-    this.pty.onData((data) => {
-      const csMatch = data.match(/\x1b\[(\d+) q/);
-      if (csMatch) this.cursorStyle = parseInt(csMatch[1], 10);
-      this.xterm.write(data);
-      this.dirty = true;
-      this.cachedRows = null;
-      this.debouncedRender();
-    });
-    this.pty.onExit(() => {
-      this.ready = false;
-    });
-    setTimeout(() => {
-      if (this.pty) {
-        this.ready = true;
+  spawn() {
+    return Promise.all([
+      import("node-pty"),
+      import("@xterm/headless")
+    ]).then(([nodePty, xtermModule]) => new Promise((resolve) => {
+      const { spawn } = nodePty;
+      const { Terminal } = xtermModule.default;
+      this.xterm = new Terminal({
+        cols: this._cols,
+        rows: this._rows,
+        allowProposedApi: true
+      });
+      const nvimArgs = [
+        // Pre-init: only settings needed before user config loads
+        "--cmd",
+        [
+          "set noswapfile",
+          "set nobackup",
+          "set nowritebackup",
+          "set hidden",
+          "set autoread"
+        ].join(" | "),
+        // Post-init: cosmetic overrides applied AFTER user config (LazyVim, etc.)
+        "-c",
+        [
+          "set laststatus=0",
+          "set showtabline=2",
+          "set signcolumn=no",
+          "set nonumber",
+          "set noruler",
+          "set noshowcmd",
+          "set noshowmode",
+          "set shortmess+=F",
+          "set fillchars=eob:\\ ",
+          "set scrolloff=3"
+        ].join(" | "),
+        // Suppress LSP — prevent servers from ever starting (avoids exit warnings)
+        "--cmd",
+        "lua vim.lsp.start = function() end",
+        // Poll-based command executor: reads lua from temp file — no command-line flash
+        "-c",
+        `lua local _t = vim.loop.new_timer(); _t:start(100, 50, vim.schedule_wrap(function() local f = io.open('${this.cmdFile.replace(/'/g, "\\'")}', 'r'); if not f then return end; local c = f:read('*a'); f:close(); os.remove('${this.cmdFile.replace(/'/g, "\\'")}'); if c and #c > 0 then local fn = loadstring(c); if fn then pcall(fn) end end end))`
+      ];
+      this.pty = spawn(this.nvimPath, nvimArgs, {
+        name: "xterm-256color",
+        cols: this._cols,
+        rows: this._rows,
+        env: { ...process.env, TERM: "xterm-256color" }
+      });
+      let settled = false;
+      this.pty.onData((data) => {
+        const csMatch = data.match(/\x1b\[(\d+) q/);
+        if (csMatch) this.cursorStyle = parseInt(csMatch[1], 10);
+        this.xterm.write(data);
+        this.dirty = true;
+        this.cachedRows = null;
+        this.debouncedRender();
+      });
+      this.pty.onExit(() => {
+        this.ready = false;
         this.dirty = true;
         this.cachedRows = null;
         this.onRender();
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        if (this.pty) {
+          this.ready = true;
+          this.wasReady = true;
+          this.dirty = true;
+          this.cachedRows = null;
+          this.onRender();
+        }
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      }, 500);
+    }));
+  }
+  /**
+   * Respawn nvim after it exited (e.g. user quit during compose).
+   * Cleans up dead instances and re-runs spawn().
+   */
+  async respawn() {
+    if (!this.available) return;
+    if (this.xterm) {
+      this.xterm.dispose();
+      this.xterm = null;
+    }
+    if (this.pty) {
+      try {
+        this.pty.kill();
+      } catch {
       }
-    }, 500);
+      this.pty = null;
+    }
+    this.ready = false;
+    this.dirty = true;
+    this.cachedRows = null;
+    this.currentFile = null;
+    await this.spawn();
   }
   debouncedRender() {
     if (this.renderTimer !== null) return;
@@ -3287,7 +3559,7 @@ var NvimBridge = class {
    * Writes lua to a temp file — a libuv timer in nvim polls and executes it.
    */
   execLua(lua) {
-    writeFileSync2(this.cmdFile, lua);
+    writeFileSync3(this.cmdFile, lua);
   }
   openFile(path, readonly = true) {
     if (!this.pty || !this.ready) return;
@@ -3312,6 +3584,7 @@ var NvimBridge = class {
   }
   executeOpenFiles(files) {
     if (!this.pty || !this.ready) return;
+    this.trackEditableFiles(files);
     const escapeLua = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
     const stmts = [
       "for _, b in ipairs(vim.api.nvim_list_bufs()) do pcall(vim.api.nvim_buf_delete, b, {force=true}) end"
@@ -3337,6 +3610,37 @@ var NvimBridge = class {
       this.pty.write(":setlocal noreadonly modifiable\r");
     }
   }
+  /**
+   * Open a temp file for compose mode: clears buffers, opens writable,
+   * installs BufWritePost autocmd that writes a signal file on :w,
+   * and enters insert mode.
+   */
+  openComposeFile(tempPath, signalPath) {
+    if (!this.pty || !this.ready) return;
+    if (this.fileDebounceTimer !== null) {
+      clearTimeout(this.fileDebounceTimer);
+      this.fileDebounceTimer = null;
+      this.pendingFiles = null;
+    }
+    const escapeLua = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    const eSig = escapeLua(signalPath);
+    const lua = [
+      // Clear all existing buffers
+      "for _, b in ipairs(vim.api.nvim_list_bufs()) do pcall(vim.api.nvim_buf_delete, b, {force=true}) end",
+      // Open temp file as writable
+      `vim.cmd('edit! ${escapeLua(tempPath)}')`,
+      "vim.bo.readonly = false",
+      "vim.bo.modifiable = true",
+      // Install BufWritePost autocmd — writes submit signal on :w
+      `vim.api.nvim_create_autocmd('BufWritePost', { buffer = 0, callback = function() local f = io.open('${eSig}', 'w'); if f then f:write('1'); f:close() end end })`,
+      // Install QuitPre autocmd — writes cancel signal if no submit signal exists (quit proceeds, nvim may exit)
+      `vim.api.nvim_create_autocmd('QuitPre', { buffer = 0, callback = function() local sf = io.open('${eSig}', 'r'); if sf then sf:close() else local f = io.open('${eSig}', 'w'); if f then f:write('cancel'); f:close() end end end })`,
+      // Enter insert mode
+      "vim.cmd('startinsert')"
+    ].join("; ");
+    this.execLua(`(function() ${lua} end)()`);
+    this.currentFile = tempPath;
+  }
   closeAllTabs() {
     if (!this.pty || !this.ready) return;
     this.execLua('for _, b in ipairs(vim.api.nvim_list_bufs()) do pcall(vim.api.nvim_buf_delete, b, {force=true}) end; vim.cmd("enew!")');
@@ -3470,6 +3774,113 @@ var NvimBridge = class {
       y: this.xterm.buffer.active.cursorY
     };
   }
+  /**
+   * Snapshot editable files on disk so we have a base for 3-way merge.
+   * Called when files are opened in nvim tabs.
+   */
+  trackEditableFiles(files) {
+    for (const [, info] of this.editableFiles) {
+      try {
+        unlinkSync2(info.basePath);
+      } catch {
+      }
+    }
+    this.editableFiles.clear();
+    for (const file of files) {
+      if (file.readonly) continue;
+      try {
+        const content = readFileSync3(file.path, "utf-8");
+        const mtime = statSync(file.path).mtimeMs;
+        const basePath = join4(this.cmdDir, `base-${simpleHash(file.path)}.md`);
+        writeFileSync3(basePath, content, "utf-8");
+        this.editableFiles.set(file.path, { basePath, mtimeMs: mtime });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Check editable files for external changes and 3-way merge if the buffer
+   * is dirty. Falls back to regular checktime for clean/readonly buffers.
+   *
+   * Returns a merge status string from the *previous* cycle ('clean' or 'union')
+   * if a merge completed, or null.
+   */
+  mergeCheckOrReload() {
+    if (!this.pty || !this.ready) return null;
+    let mergeResult = null;
+    try {
+      if (existsSync3(this.mergeStatusFile)) {
+        const content = readFileSync3(this.mergeStatusFile, "utf-8").trim();
+        unlinkSync2(this.mergeStatusFile);
+        if (content) {
+          const lines = content.split("\n");
+          mergeResult = lines.some((l) => l === "union") ? "union" : "clean";
+        }
+      }
+    } catch {
+    }
+    if (mergeResult) {
+      for (const [filePath, info] of this.editableFiles) {
+        try {
+          info.mtimeMs = statSync(filePath).mtimeMs;
+        } catch {
+        }
+      }
+      this.execLua('vim.cmd("checktime")');
+      return mergeResult;
+    }
+    const changedFiles = [];
+    for (const [filePath, info] of this.editableFiles) {
+      try {
+        const currentMtime = statSync(filePath).mtimeMs;
+        if (currentMtime !== info.mtimeMs) {
+          changedFiles.push({ filePath, basePath: info.basePath });
+          info.mtimeMs = currentMtime;
+        }
+      } catch {
+      }
+    }
+    if (changedFiles.length === 0) {
+      this.execLua('vim.cmd("checktime")');
+      return null;
+    }
+    const esc = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    const mergeBlocks = changedFiles.map(({ filePath, basePath }) => `
+    do
+      local bufnr = vim.fn.bufnr('${esc(filePath)}')
+      if bufnr ~= -1 and vim.api.nvim_buf_is_loaded(bufnr) then
+        if vim.bo[bufnr].modified then
+          local buf_lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+          local buf_content = table.concat(buf_lines, '\\n') .. '\\n'
+          local tmp = '${esc(this.cmdDir)}/merge-current-${process.pid}.md'
+          local f = io.open(tmp, 'w')
+          if f then f:write(buf_content); f:close() end
+          local result = vim.fn.system({'git', 'merge-file', '-p', '--union', tmp, '${esc(basePath)}', '${esc(filePath)}'})
+          local merged_lines = vim.split(result, '\\n', {trimempty = false})
+          if #merged_lines > 0 and merged_lines[#merged_lines] == '' then
+            table.remove(merged_lines)
+          end
+          vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, merged_lines)
+          local out = io.open('${esc(filePath)}', 'w')
+          if out then out:write(result); out:close() end
+          vim.bo[bufnr].modified = false
+          local bf = io.open('${esc(basePath)}', 'w')
+          if bf then bf:write(result); bf:close() end
+          local sf = io.open('${esc(this.mergeStatusFile)}', 'a')
+          if sf then sf:write(vim.v.shell_error == 0 and 'clean' or 'union'); sf:write('\\n'); sf:close() end
+        else
+          local lines = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
+          local bf = io.open('${esc(basePath)}', 'w')
+          if bf then bf:write(table.concat(lines, '\\n') .. '\\n'); bf:close() end
+        end
+      end
+    end`).join("\n");
+    this.execLua(`(function()
+    pcall(function() vim.cmd('checktime') end)
+    ${mergeBlocks}
+    end)()`);
+    return null;
+  }
   checktime() {
     if (this.pty && this.ready) {
       this.execLua('vim.cmd("checktime")');
@@ -3497,23 +3908,34 @@ var NvimBridge = class {
     }
     this.ready = false;
     try {
-      unlinkSync(this.cmdFile);
+      unlinkSync2(this.cmdFile);
     } catch {
     }
+    try {
+      unlinkSync2(this.mergeStatusFile);
+    } catch {
+    }
+    for (const [, info] of this.editableFiles) {
+      try {
+        unlinkSync2(info.basePath);
+      } catch {
+      }
+    }
+    this.editableFiles.clear();
   }
 };
 
 // src/tui/lib/overview-writer.ts
-import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, renameSync, existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, renameSync, existsSync as existsSync4 } from "fs";
+import { join as join5 } from "path";
 function atomicWrite(filePath, content) {
   const tmp = filePath + ".tmp." + process.pid;
-  writeFileSync3(tmp, content, "utf-8");
+  writeFileSync4(tmp, content, "utf-8");
   renameSync(tmp, filePath);
 }
 function ensureTuiDir(cwd2, sessionId) {
   const dir = tuiScratchDir(cwd2, sessionId);
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync4(dir, { recursive: true });
   return dir;
 }
 function formatTimestamp(iso) {
@@ -3691,11 +4113,11 @@ function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
       if (!session) return null;
       const files = [];
       const gp = goalPath(cwd2, sessionId);
-      if (existsSync2(gp)) files.push({ path: gp, readonly: false });
+      if (existsSync4(gp)) files.push({ path: gp, readonly: false });
       const rp = roadmapPath(cwd2, sessionId);
-      if (existsSync2(rp)) files.push({ path: rp, readonly: false });
+      if (existsSync4(rp)) files.push({ path: rp, readonly: false });
       const sp = strategyPath(cwd2, sessionId);
-      if (existsSync2(sp)) files.push({ path: sp, readonly: false });
+      if (existsSync4(sp)) files.push({ path: sp, readonly: false });
       if (files.length === 0) return null;
       return { files };
     }
@@ -3706,7 +4128,7 @@ function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
       );
       if (!cycle) return null;
       const dir = ensureTuiDir(cwd2, sessionId);
-      const filePath = join4(dir, `cycle-${cursorNode.cycleNumber}.md`);
+      const filePath = join5(dir, `cycle-${cursorNode.cycleNumber}.md`);
       atomicWrite(filePath, composeCycleDetail(session, cycle));
       return { files: [{ path: filePath, readonly: true }] };
     }
@@ -3715,7 +4137,7 @@ function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
       const agent = session.agents.find((a) => a.id === cursorNode.agentId);
       if (!agent) return null;
       const dir = ensureTuiDir(cwd2, sessionId);
-      const filePath = join4(dir, `${agent.id}.md`);
+      const filePath = join5(dir, `${agent.id}.md`);
       atomicWrite(filePath, composeAgentDetail(agent, state2.cachedReportBlocks.get(agent.id) ?? []));
       return { files: [{ path: filePath, readonly: true }] };
     }
@@ -3723,14 +4145,14 @@ function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
       const agent = session?.agents.find((a) => a.id === cursorNode.agentId);
       if (agent && agent.reports.length > 0) {
         const report = agent.reports[cursorNode.reportIndex];
-        if (report?.filePath && existsSync2(report.filePath)) {
+        if (report?.filePath && existsSync4(report.filePath)) {
           return { files: [{ path: report.filePath, readonly: true }] };
         }
       }
       return null;
     }
     case "context-file": {
-      if (cursorNode.filePath && existsSync2(cursorNode.filePath)) {
+      if (cursorNode.filePath && existsSync4(cursorNode.filePath)) {
         return { files: [{ path: cursorNode.filePath, readonly: false }] };
       }
       return null;
@@ -3739,7 +4161,7 @@ function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
     case "message": {
       if (!session || session.messages.length === 0) return null;
       const dir = ensureTuiDir(cwd2, sessionId);
-      const filePath = join4(dir, "messages.md");
+      const filePath = join5(dir, "messages.md");
       atomicWrite(filePath, composeMessages(session));
       return { files: [{ path: filePath, readonly: true }] };
     }
@@ -3877,28 +4299,28 @@ function startApp(state2, cleanup2) {
         }
         try {
           const pp = roadmapPath(state2.cwd, state2.selectedSessionId);
-          if (existsSync3(pp)) {
-            planContent = readFileSync2(pp, "utf-8");
+          if (existsSync5(pp)) {
+            planContent = readFileSync4(pp, "utf-8");
           }
         } catch {
         }
         try {
           const gp = goalPath(state2.cwd, state2.selectedSessionId);
-          if (existsSync3(gp)) {
-            goalContent = readFileSync2(gp, "utf-8");
+          if (existsSync5(gp)) {
+            goalContent = readFileSync4(gp, "utf-8");
           }
         } catch {
         }
         try {
           const sp = strategyPath(state2.cwd, state2.selectedSessionId);
-          if (existsSync3(sp)) {
-            strategyContent = readFileSync2(sp, "utf-8");
+          if (existsSync5(sp)) {
+            strategyContent = readFileSync4(sp, "utf-8");
           }
         } catch {
         }
         try {
           const ld = logsDir(state2.cwd, state2.selectedSessionId);
-          if (existsSync3(ld)) {
+          if (existsSync5(ld)) {
             if (state2.selectedSessionId !== cachedLogSessionId) {
               cachedLogFiles = /* @__PURE__ */ new Map();
               cachedLogSessionId = state2.selectedSessionId;
@@ -3909,13 +4331,13 @@ function startApp(state2, cleanup2) {
               if (!fileSet.has(key)) cachedLogFiles.delete(key);
             }
             for (const f of files) {
-              const filePath = join5(ld, f);
-              const mtime = statSync(filePath).mtimeMs;
+              const filePath = join6(ld, f);
+              const mtime = statSync2(filePath).mtimeMs;
               const cached = cachedLogFiles.get(f);
               if (!cached || cached.mtime !== mtime) {
                 const match = f.match(/cycle-(\d+)\.md$/);
                 const cycle = match ? parseInt(match[1], 10) : 0;
-                const content = readFileSync2(filePath, "utf-8");
+                const content = readFileSync4(filePath, "utf-8");
                 cachedLogFiles.set(f, { mtime, cycle, content });
               }
             }
@@ -3929,7 +4351,7 @@ function startApp(state2, cleanup2) {
         }
         try {
           const cd = contextDir(state2.cwd, state2.selectedSessionId);
-          if (existsSync3(cd)) {
+          if (existsSync5(cd)) {
             contextFiles = readdirSync(cd).filter((f) => !f.startsWith(".")).sort();
           }
         } catch {
@@ -3952,7 +4374,12 @@ function startApp(state2, cleanup2) {
       state2.contextFiles = contextFiles;
       state2.error = null;
       if (state2.nvimEnabled && state2.nvimBridge?.ready && state2.prevNvimFile) {
-        state2.nvimBridge.checktime();
+        const mergeStatus = state2.nvimBridge.mergeCheckOrReload();
+        if (mergeStatus === "clean") {
+          notify(state2, "Auto-merged external changes");
+        } else if (mergeStatus === "union") {
+          notify(state2, "Auto-merged overlapping edits \u2014 review buffer");
+        }
       }
       requestRender();
     } catch (err) {
@@ -4038,8 +4465,8 @@ function startApp(state2, cleanup2) {
       if (cursorNode.filePath !== cachedContextFilePath) {
         cachedContextFilePath = cursorNode.filePath;
         try {
-          if (existsSync3(cursorNode.filePath)) {
-            cachedContextFileContent = readFileSync2(cursorNode.filePath, "utf-8");
+          if (existsSync5(cursorNode.filePath)) {
+            cachedContextFileContent = readFileSync4(cursorNode.filePath, "utf-8");
           } else {
             cachedContextFileContent = null;
           }
@@ -4092,19 +4519,42 @@ function startApp(state2, cleanup2) {
       contextFileContent
     };
     let detailRows;
+    const composing = state2.mode === "compose";
+    if (state2.nvimEnabled && state2.nvimBridge && state2.nvimBridge.wasReady && !state2.nvimBridge.ready && !state2.nvimBridge.respawning) {
+      state2.nvimBridge.respawning = true;
+      state2.prevNvimFile = null;
+      state2.nvimBridge.respawn().then(() => {
+        state2.nvimBridge.respawning = false;
+        requestRender();
+      }).catch(() => {
+        state2.nvimBridge.respawning = false;
+        state2.nvimEnabled = false;
+        requestRender();
+      });
+    }
     if (state2.nvimEnabled && state2.nvimBridge?.ready) {
-      const result = resolveNvimFile(state2, cursorNode, detailCtx, state2.cwd);
-      const resultKey = result ? result.files.map((f) => f.path).join("|") : null;
-      if (resultKey && resultKey !== state2.prevNvimFile) {
-        state2.nvimBridge.openTabFiles(result.files);
-        state2.prevNvimFile = resultKey;
-        state2.nvimEditable = result.files.some((f) => !f.readonly);
-      } else if (!resultKey) {
-        state2.prevNvimFile = null;
-        state2.nvimEditable = false;
+      if (composing) {
+        const action = state2.composeAction;
+        const label = action ? COMPOSE_HEADERS[action.kind] : "Compose";
+        const statusRows = [
+          " " + ansiColor(label, "yellow", true),
+          " " + ansiDim(":w to submit \xB7 Tab to cancel")
+        ];
+        detailRows = renderNvimDetailRows(detailRect, state2.nvimBridge, true, false, statusRows, true);
+      } else {
+        const result = resolveNvimFile(state2, cursorNode, detailCtx, state2.cwd);
+        const resultKey = result ? result.files.map((f) => f.path).join("|") : null;
+        if (resultKey && resultKey !== state2.prevNvimFile) {
+          state2.nvimBridge.openTabFiles(result.files);
+          state2.prevNvimFile = resultKey;
+          state2.nvimEditable = result.files.some((f) => !f.readonly);
+        } else if (!resultKey) {
+          state2.prevNvimFile = null;
+          state2.nvimEditable = false;
+        }
+        const statusRows = buildStatusRows(cursorNode, state2.selectedSession, state2);
+        detailRows = renderNvimDetailRows(detailRect, state2.nvimBridge, state2.focusPane === "detail", state2.nvimEditable, statusRows);
       }
-      const statusRows = buildStatusRows(cursorNode, state2.selectedSession, state2);
-      detailRows = renderNvimDetailRows(detailRect, state2.nvimBridge, state2.focusPane === "detail", state2.nvimEditable, statusRows);
     } else {
       detailRows = renderDetailRows(detailRect, state2, detailCtx);
     }
@@ -4165,6 +4615,7 @@ function startApp(state2, cleanup2) {
     editInPopup,
     openCompanionPane,
     openClaudeResumePopup,
+    openClaudeResumeSession,
     selectWindow,
     selectPane,
     switchToSession,
@@ -4206,6 +4657,7 @@ function startApp(state2, cleanup2) {
   inputActions.cleanup = () => {
     clearInterval(pollInterval);
     if (debouncedPollTimer !== null) clearTimeout(debouncedPollTimer);
+    if (state2.composePollTimer !== null) clearInterval(state2.composePollTimer);
     stopKeypress();
     stopResize();
     state2.detailScroll.destroy();