sisyphi 1.1.9 → 1.1.11

package/dist/tui.js

@@ -5,7 +5,7 @@ import {
   exec,
   execSafe,
   loadConfig
-} from "./chunk-Z32YVDMY.js";
+} from "./chunk-ZSIYQB45.js";
 import {
   buildSessionContext,
   computeActiveTimeMs,
@@ -13,7 +13,7 @@ import {
   rawSend,
   resolveReports,
   statusColor
-} from "./chunk-M7LZ2ZHD.js";
+} from "./chunk-HQZOAX6D.js";
 import {
   shellQuote
 } from "./chunk-6G226ZK7.js";
@@ -24,8 +24,9 @@ import {
   logsDir,
   roadmapPath,
   sessionDir,
-  strategyPath
-} from "./chunk-REUQ4B45.js";
+  strategyPath,
+  tuiScratchDir
+} from "./chunk-GSXF3TCZ.js";
 
 // src/tui/terminal.ts
 function emptyKey() {
@@ -172,10 +173,18 @@ function parseBuffer(buf) {
   }
   return { events, remaining: "" };
 }
+var rawBypassHandler = null;
+function setRawBypass(handler) {
+  rawBypassHandler = handler;
+}
 function startKeypressListener(handler) {
   let buffer = "";
   let escTimer = null;
   const onData = (data) => {
+    if (rawBypassHandler) {
+      const handled = rawBypassHandler(data);
+      if (handled) return;
+    }
     if (escTimer !== null) {
       clearTimeout(escTimer);
       escTimer = null;
@@ -311,8 +320,7 @@ function createAppState(cwd2) {
     targetAgentId: null,
     notification: null,
     notificationTimer: null,
-    showLogs: false,
-    showStrategy: false,
+    showCombinedView: false,
     inputText: "",
     inputCursorPos: 0,
     detailScroll,
@@ -333,6 +341,17 @@ function createAppState(cwd2) {
     cachedReportBlocks: /* @__PURE__ */ new Map(),
     cachedTreeNodes: null,
     treeCacheKey: "",
+    cachedDetailLines: null,
+    detailCacheKey: "",
+    detailRenderedCache: { lines: [], ansi: [] },
+    cachedLogsLines: null,
+    logsCacheKey: "",
+    logsRenderedCache: { lines: [], ansi: [] },
+    nvimBridge: null,
+    nvimEnabled: true,
+    prevNvimFile: null,
+    nvimEditable: false,
+    nvimOpenTabs: /* @__PURE__ */ new Map(),
     cwd: cwd2
   };
 }
@@ -396,8 +415,8 @@ function autoExpandCycle(state2) {
 }
 
 // src/tui/app.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync, statSync } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync3, readdirSync, statSync } from "fs";
+import { join as join5 } from "path";
 
 // src/tui/lib/tree.ts
 import { join } from "path";
@@ -785,6 +804,21 @@ function findParentIndex(nodes, index) {
 }
 
 // src/tui/input.ts
+function activateNvimBypass(state2) {
+  setRawBypass((data) => {
+    if (data === "	") {
+      deactivateNvimBypass();
+      state2.focusPane = state2.showCombinedView ? "logs" : "tree";
+      requestRender();
+      return true;
+    }
+    state2.nvimBridge.write(data);
+    return true;
+  });
+}
+function deactivateNvimBypass() {
+  setRawBypass(null);
+}
 function handleCancel(state2) {
   state2.mode = "navigate";
   state2.targetAgentId = null;
@@ -1285,10 +1319,14 @@ function handleNavigateKey(input, key, state2, actions) {
   if (key.leftArrow || input === "h") {
     if (state2.focusPane === "logs") {
       state2.focusPane = "detail";
+      if (state2.nvimEnabled && state2.nvimBridge?.ready) {
+        activateNvimBypass(state2);
+      }
       requestRender();
       return;
     }
     if (state2.focusPane === "detail") {
+      deactivateNvimBypass();
       state2.focusPane = "tree";
       requestRender();
       return;
@@ -1327,8 +1365,12 @@ function handleNavigateKey(input, key, state2, actions) {
   if (key.tab) {
     if (state2.focusPane === "tree") {
       state2.focusPane = "detail";
+      if (state2.nvimEnabled && state2.nvimBridge?.ready) {
+        activateNvimBypass(state2);
+      }
     } else if (state2.focusPane === "detail") {
-      state2.focusPane = state2.showLogs ? "logs" : "tree";
+      deactivateNvimBypass();
+      state2.focusPane = state2.showCombinedView ? "logs" : "tree";
     } else {
       state2.focusPane = "tree";
     }
@@ -1571,15 +1613,6 @@ function handleNavigateKey(input, key, state2, actions) {
     }
     return;
   }
-  if (input === "s") {
-    if (!state2.strategyContent) {
-      notify(state2, "No strategy for this session");
-      return;
-    }
-    state2.showStrategy = !state2.showStrategy;
-    requestRender();
-    return;
-  }
   if (input === "S") {
     if (!state2.selectedSessionId) {
       notify(state2, "No session selected");
@@ -1595,11 +1628,11 @@ function handleNavigateKey(input, key, state2, actions) {
     return;
   }
   if (input === "t") {
-    if (state2.showLogs) {
+    if (state2.showCombinedView) {
       if (state2.focusPane === "logs") state2.focusPane = "detail";
       state2.logsScroll.reset();
     }
-    state2.showLogs = !state2.showLogs;
+    state2.showCombinedView = !state2.showCombinedView;
     requestRender();
     return;
   }
@@ -1651,15 +1684,23 @@ function renderLine(segs) {
   }
   return out;
 }
+var cachedBlank = "";
+var cachedBlankWidth = 0;
 function createFrameBuffer(width, height) {
-  const blank = " ".repeat(width);
-  return {
-    lines: Array.from({ length: height }, () => blank),
-    width,
-    height
-  };
+  if (width !== cachedBlankWidth) {
+    cachedBlank = " ".repeat(width);
+    cachedBlankWidth = width;
+  }
+  const lines = new Array(height);
+  for (let i = 0; i < height; i++) lines[i] = cachedBlank;
+  return { lines, width, height };
+}
+function copyRows(buf, src, startRow, count) {
+  for (let i = 0; i < count && startRow + i < buf.height; i++) {
+    buf.lines[startRow + i] = src[startRow + i];
+  }
 }
-function flushFrame(frame, prevFrame2) {
+function flushFrame(frame, prevFrame2, suffix) {
   let out = "\x1B[?2026h";
   for (let i = 0; i < frame.length; i++) {
     if (frame[i] !== prevFrame2[i]) {
@@ -1668,10 +1709,76 @@ function flushFrame(frame, prevFrame2) {
       out += frame[i];
     }
   }
+  if (suffix) out += suffix;
   out += "\x1B[?2026l";
   return out;
 }
 var ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+function clipAnsi(content, maxWidth) {
+  let out = "";
+  let displayWidth = 0;
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "\x1B" && content[i + 1] === "[") {
+      const seqLen = ansiLen(content, i);
+      if (seqLen > 0) {
+        out += content.substring(i, i + seqLen);
+        i += seqLen;
+        continue;
+      }
+    }
+    const cp = content.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const chWidth = cp < 128 ? 1 : stringWidth2(ch);
+    if (displayWidth + chWidth > maxWidth) break;
+    out += ch;
+    displayWidth += chWidth;
+    i += ch.length;
+  }
+  if (out.includes("\x1B[") && !out.endsWith("\x1B[0m")) {
+    out += "\x1B[0m";
+  }
+  const remaining = maxWidth - displayWidth;
+  if (remaining > 0) out += " ".repeat(remaining);
+  return out;
+}
+function displayWidthFast(s) {
+  let w = 0;
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "\x1B" && s[i + 1] === "[") {
+      const len = ansiLen(s, i);
+      if (len > 0) {
+        i += len;
+        continue;
+      }
+    }
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    w += cp < 128 ? 1 : stringWidth2(ch);
+    i += ch.length;
+  }
+  return w;
+}
+function ansiLen(s, i) {
+  let j = i + 2;
+  const len = s.length;
+  while (j < len) {
+    const c = s.charCodeAt(j);
+    if (c >= 48 && c <= 57 || c === 59) {
+      j++;
+    } else {
+      break;
+    }
+  }
+  if (j < len) {
+    const c = s.charCodeAt(j);
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+      return j + 1 - i;
+    }
+  }
+  return 0;
+}
 function writeAt(buf, x, y, content) {
   if (y < 0 || y >= buf.height) return;
   if (x < 0 || x >= buf.width) return;
@@ -1691,16 +1798,16 @@ function writeClipped(buf, x, y, content, maxWidth) {
   let i = 0;
   while (i < content.length) {
     if (content[i] === "\x1B" && content[i + 1] === "[") {
-      const match = content.slice(i).match(/^\x1b\[[0-9;]*[a-zA-Z]/);
-      if (match) {
-        out += match[0];
-        i += match[0].length;
+      const seqLen = ansiLen(content, i);
+      if (seqLen > 0) {
+        out += content.substring(i, i + seqLen);
+        i += seqLen;
         continue;
       }
     }
     const cp = content.codePointAt(i);
     const ch = String.fromCodePoint(cp);
-    const chWidth = stringWidth2(ch);
+    const chWidth = cp < 128 ? 1 : stringWidth2(ch);
     if (displayWidth + chWidth > maxWidth) break;
     out += ch;
     displayWidth += chWidth;
@@ -1713,7 +1820,12 @@ function writeClipped(buf, x, y, content, maxWidth) {
   if (remaining > 0) {
     out += " ".repeat(remaining);
   }
-  writeAt(buf, x, y, out);
+  const existing = buf.lines[y];
+  const prefix = sliceDisplayCols(existing, 0, x);
+  const suffix = sliceDisplayCols(existing, x + maxWidth, buf.width);
+  const prefixDisplayW = displayWidthFast(prefix);
+  const paddedPrefix = prefixDisplayW < x ? prefix + " ".repeat(x - prefixDisplayW) : prefix;
+  buf.lines[y] = paddedPrefix + out + suffix;
 }
 function writeCenter(buf, row, content) {
   const textWidth = stringWidth2(content.replace(ANSI_RE, ""));
@@ -1730,28 +1842,75 @@ function drawBorder(buf, x, y, w, h, color) {
     writeAt(buf, x + w - 1, row, sgr + "\u2502" + reset);
   }
 }
-function renderPanel(buf, rect, lines, scrollOffset, focused, borderColor) {
-  const { x, y, w, h } = rect;
-  drawBorder(buf, x, y, w, h, focused ? "blue" : borderColor);
-  const innerX = x + 2;
+function buildPanelRows(rect, lines, scrollOffset, focused, borderColor, renderedCache) {
+  const { w, h } = rect;
+  const rows = new Array(h);
+  const color = focused ? "blue" : borderColor;
+  const sgr = `\x1B[${colorToSGR(color)}m`;
+  const reset = "\x1B[0m";
   const innerW = w - 4;
-  const innerY = y + 1;
   const innerH = h - 2;
-  if (innerW <= 0 || innerH <= 0) return;
+  const blankInner = " ".repeat(innerW);
+  rows[0] = sgr + "\u256D" + "\u2500".repeat(w - 2) + "\u256E" + reset;
+  rows[h - 1] = sgr + "\u2570" + "\u2500".repeat(w - 2) + "\u256F" + reset;
+  const borderL = sgr + "\u2502" + reset + " ";
+  const borderR = " " + sgr + "\u2502" + reset;
+  const emptyRow = borderL + blankInner + borderR;
+  for (let i = 1; i < h - 1; i++) rows[i] = emptyRow;
+  if (innerW <= 0 || innerH <= 0) return rows;
+  let ansiLines;
+  if (renderedCache && renderedCache.lines === lines) {
+    ansiLines = renderedCache.ansi;
+  } else {
+    ansiLines = new Array(lines.length);
+    for (let i = 0; i < lines.length; i++) {
+      ansiLines[i] = renderLine(lines[i]);
+    }
+    if (renderedCache) {
+      renderedCache.lines = lines;
+      renderedCache.ansi = ansiLines;
+    }
+  }
   const hasOverflow = lines.length > innerH;
   const viewableH = hasOverflow ? innerH - 1 : innerH;
   const maxScroll = Math.max(0, lines.length - viewableH);
   const effectiveOffset = Math.min(scrollOffset, maxScroll);
-  const visible = lines.slice(effectiveOffset, effectiveOffset + viewableH);
-  for (let i = 0; i < visible.length; i++) {
-    const ansi = renderLine(visible[i]);
-    writeClipped(buf, innerX, innerY + i, ansi, innerW);
+  for (let i = 0; i < viewableH && effectiveOffset + i < ansiLines.length; i++) {
+    const clipped = clipAnsi(ansiLines[effectiveOffset + i], innerW);
+    rows[1 + i] = borderL + clipped + borderR;
   }
   if (hasOverflow) {
     const scrollPct = maxScroll > 0 ? Math.round(effectiveOffset / maxScroll * 100) : 100;
     const indicator = `  \u2195 ${scrollPct}% \xB7 ${lines.length} lines`;
-    writeClipped(buf, innerX, innerY + viewableH, `\x1B[2m${indicator}\x1B[0m`, innerW);
+    const clipped = clipAnsi(`\x1B[2m${indicator}\x1B[0m`, innerW);
+    rows[1 + viewableH] = borderL + clipped + borderR;
   }
+  return rows;
+}
+function buildEmptyPanelRows(rect, focused, borderColor, centerText) {
+  const { w, h } = rect;
+  const rows = new Array(h);
+  const color = focused ? "blue" : borderColor;
+  const sgr = `\x1B[${colorToSGR(color)}m`;
+  const reset = "\x1B[0m";
+  const innerW = w - 4;
+  const borderL = sgr + "\u2502" + reset + " ";
+  const borderR = " " + sgr + "\u2502" + reset;
+  const emptyRow = borderL + " ".repeat(innerW) + borderR;
+  rows[0] = sgr + "\u256D" + "\u2500".repeat(w - 2) + "\u256E" + reset;
+  rows[h - 1] = sgr + "\u2570" + "\u2500".repeat(w - 2) + "\u256F" + reset;
+  for (let i = 1; i < h - 1; i++) rows[i] = emptyRow;
+  if (centerText) {
+    const midRow = Math.floor(h / 2);
+    if (midRow > 0 && midRow < h - 1) {
+      const clipped = clipAnsi(centerText, innerW);
+      const textW = displayWidthFast(centerText);
+      const pad = Math.max(0, Math.floor((innerW - textW) / 2));
+      const centered = " ".repeat(pad) + clipped;
+      rows[midRow] = borderL + clipAnsi(centered, innerW) + borderR;
+    }
+  }
+  return rows;
 }
 function sliceDisplayCols(s, start, end) {
   let out = "";
@@ -1761,19 +1920,20 @@ function sliceDisplayCols(s, start, end) {
   let hasOpenSGR = false;
   while (i < s.length && col < end) {
     if (s[i] === "\x1B" && s[i + 1] === "[") {
-      const match = s.slice(i).match(/^\x1b\[[0-9;]*[a-zA-Z]/);
-      if (match) {
+      const seqLen = ansiLen(s, i);
+      if (seqLen > 0) {
         if (col >= start) {
-          out += match[0];
-          hasOpenSGR = match[0] !== "\x1B[0m" && match[0] !== "\x1B[m";
+          const seq = s.substring(i, i + seqLen);
+          out += seq;
+          hasOpenSGR = seq !== "\x1B[0m" && seq !== "\x1B[m";
         }
-        i += match[0].length;
+        i += seqLen;
         continue;
       }
     }
     const cp = s.codePointAt(i);
     const ch = String.fromCodePoint(cp);
-    const chWidth = stringWidth2(ch);
+    const chWidth = cp < 128 ? 1 : stringWidth2(ch);
     if (col >= start) {
       inSlice = true;
       if (col + chWidth > end) break;
@@ -1788,6 +1948,76 @@ function sliceDisplayCols(s, start, end) {
   return out;
 }
 
+// src/tui/lib/tree-render.ts
+function renderTreePrefix(node, nodes, index) {
+  if (node.depth === 0) {
+    return node.expandable ? node.expanded ? "\u25BC " : "\u25B8 " : "  ";
+  }
+  const parts = [];
+  for (let d = 1; d < node.depth; d++) {
+    parts.push(isAncestorLastSibling(nodes, index, d) ? "  " : "\u2502 ");
+  }
+  parts.push(isLastSibling(nodes, index) ? "\u2514\u2500" : "\u251C\u2500");
+  if (node.expandable) {
+    parts.push(node.expanded ? "\u25BC " : "\u25B8 ");
+  } else {
+    parts.push(" ");
+  }
+  return parts.join("");
+}
+function isLastSibling(nodes, index) {
+  const depth = nodes[index].depth;
+  for (let i = index + 1; i < nodes.length; i++) {
+    if (nodes[i].depth === depth) return false;
+    if (nodes[i].depth < depth) return true;
+  }
+  return true;
+}
+function isAncestorLastSibling(nodes, index, depth) {
+  for (let i = index - 1; i >= 0; i--) {
+    if (nodes[i].depth === depth) {
+      return isLastSibling(nodes, i);
+    }
+    if (nodes[i].depth < depth) return true;
+  }
+  return true;
+}
+function precomputePrefixes(nodes) {
+  const len = nodes.length;
+  if (len === 0) return;
+  const isLast = new Array(len);
+  const lastSeenAtDepth = /* @__PURE__ */ new Map();
+  for (let i = len - 1; i >= 0; i--) {
+    const depth = nodes[i].depth;
+    isLast[i] = !lastSeenAtDepth.has(depth);
+    lastSeenAtDepth.set(depth, i);
+    for (const [d] of lastSeenAtDepth) {
+      if (d > depth) lastSeenAtDepth.delete(d);
+    }
+  }
+  const ancestorIsLast = [];
+  for (let i = 0; i < len; i++) {
+    const node = nodes[i];
+    if (node.depth === 0) {
+      node.prefix = node.expandable ? node.expanded ? "\u25BC " : "\u25B8 " : "  ";
+      ancestorIsLast[0] = isLast[i];
+      continue;
+    }
+    ancestorIsLast[node.depth] = isLast[i];
+    const parts = [];
+    for (let d = 1; d < node.depth; d++) {
+      parts.push(ancestorIsLast[d] ? "  " : "\u2502 ");
+    }
+    parts.push(isLast[i] ? "\u2514\u2500" : "\u251C\u2500");
+    if (node.expandable) {
+      parts.push(node.expanded ? "\u25BC " : "\u25B8 ");
+    } else {
+      parts.push(" ");
+    }
+    node.prefix = parts.join("");
+  }
+}
+
 // src/tui/lib/client.ts
 function send(request) {
   return rawSend(request, 5e3);
@@ -1804,8 +2034,13 @@ function selectWindow(windowId) {
 function selectPane(paneId) {
   execSafe(`tmux select-pane -t "${paneId}"`);
 }
-function windowExists(windowId) {
-  return execSafe(`tmux display-message -t "${windowId}" -p "#{window_id}"`) !== null;
+function listAllWindowIds() {
+  try {
+    const output = execSync('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();
+  }
 }
 var companionPaneId = null;
 function setupCompanionPlugin() {
@@ -1901,41 +2136,6 @@ function copyToClipboard(text) {
   execSync2("pbcopy", { input: text });
 }
 
-// src/tui/lib/tree-render.ts
-function renderTreePrefix(node, nodes, index) {
-  if (node.depth === 0) {
-    return node.expandable ? node.expanded ? "\u25BC " : "\u25B8 " : "  ";
-  }
-  const parts = [];
-  for (let d = 1; d < node.depth; d++) {
-    parts.push(isAncestorLastSibling(nodes, index, d) ? "  " : "\u2502 ");
-  }
-  parts.push(isLastSibling(nodes, index) ? "\u2514\u2500" : "\u251C\u2500");
-  if (node.expandable) {
-    parts.push(node.expanded ? "\u25BC " : "\u25B8 ");
-  } else {
-    parts.push(" ");
-  }
-  return parts.join("");
-}
-function isLastSibling(nodes, index) {
-  const depth = nodes[index].depth;
-  for (let i = index + 1; i < nodes.length; i++) {
-    if (nodes[i].depth === depth) return false;
-    if (nodes[i].depth < depth) return true;
-  }
-  return true;
-}
-function isAncestorLastSibling(nodes, index, depth) {
-  for (let i = index - 1; i >= 0; i--) {
-    if (nodes[i].depth === depth) {
-      return isLastSibling(nodes, i);
-    }
-    if (nodes[i].depth < depth) return true;
-  }
-  return true;
-}
-
 // src/tui/panels/tree.ts
 function renderNodeContent(node, maxWidth) {
   switch (node.type) {
@@ -2075,7 +2275,7 @@ function renderTreePanel(buf, rect, nodes, cursorIndex, focused) {
     const node = visible[i];
     const realIdx = scrollOffset + i;
     const isSelected = realIdx === cursorIndex;
-    const prefix = renderTreePrefix(node, nodes, realIdx);
+    const prefix = node.prefix ?? renderTreePrefix(node, nodes, realIdx);
     const contentWidth = innerW;
     const { icon, label, meta, color, dim, metaColor, suffix, suffixColor } = renderNodeContent(
       node,
@@ -2187,7 +2387,7 @@ function buildPlanLines(content, maxLines, width) {
   }
   return lines;
 }
-function buildSessionLines(session, planContent, goalContent, width, paneAlive, strategyContent = "", showStrategy = false) {
+function buildSessionLines(session, planContent, goalContent, width, paneAlive, strategyContent = "") {
   const lines = [];
   const contentWidth = width - 4;
   const agents = session.agents;
@@ -2228,12 +2428,8 @@ function buildSessionLines(session, planContent, goalContent, width, paneAlive,
     ]);
   }
   lines.push(singleLine(" "));
-  if (showStrategy && strategyContent) {
-    const stratHint = strategyContent ? "  [s] toggle plan" : "";
-    lines.push([
-      seg("  \u258E \u25C8 STRATEGY", { color: "yellow", bold: true }),
-      seg(stratHint, { dim: true })
-    ]);
+  if (strategyContent) {
+    lines.push([seg("  \u258E \u25C8 STRATEGY", { color: "yellow", bold: true })]);
     const stratLines = buildPlanLines(strategyContent, 99999, width);
     if (stratLines.length === 0) {
       lines.push(singleLine("    (empty)", { dim: true, italic: true }));
@@ -2243,11 +2439,7 @@ function buildSessionLines(session, planContent, goalContent, width, paneAlive,
       }
     }
   } else {
-    const toggleHint = strategyContent ? "  [s] toggle strategy" : "";
-    lines.push([
-      seg("  \u258E \u25C8 PLAN", { color: "yellow", bold: true }),
-      seg(toggleHint, { dim: true })
-    ]);
+    lines.push([seg("  \u258E \u25C8 PLAN", { color: "yellow", bold: true })]);
     const planLines = buildPlanLines(planContent, 99999, width);
     if (planLines.length === 0) {
       lines.push(singleLine("    orchestrator will create one", { dim: true, italic: true }));
@@ -2562,7 +2754,7 @@ function buildLogsLines(cycleLogs, width) {
   }
   return lines;
 }
-function renderDetailContent(buf, rect, state2, detailCtx) {
+function renderDetailRows(rect, state2, detailCtx) {
   const { session, agents, reportBlocks, detailReportBlocks, contextFileContent } = detailCtx;
   const scrollOffset = state2.detailScroll.offset;
   const focused = state2.focusPane === "detail";
@@ -2570,157 +2762,248 @@ function renderDetailContent(buf, rect, state2, detailCtx) {
     const reportAgent = agents.find((a) => a.id === state2.targetAgentId);
     if (reportAgent) {
       const lines2 = buildReportViewLines(reportAgent, reportBlocks, rect.w);
-      renderPanel(buf, rect, lines2, scrollOffset, focused, "cyan");
-      return;
+      return buildPanelRows(rect, lines2, scrollOffset, focused, "cyan");
     }
   }
   const cursorNode = detailCtx.nodes[state2.cursorIndex];
   if (!cursorNode || !session) {
-    drawBorder(buf, rect.x, rect.y, rect.w, rect.h, "gray");
-    const midRow = rect.y + Math.floor(rect.h / 2);
-    writeCenter(buf, midRow, "\x1B[2mSelect a session to view details\x1B[0m");
-    return;
-  }
+    return buildEmptyPanelRows(rect, false, "gray", "\x1B[2mSelect a session to view details\x1B[0m");
+  }
+  if (cursorNode.sessionId !== session.id) {
+    return buildEmptyPanelRows(rect, false, "gray");
+  }
+  const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
+  const cacheKey = [
+    cursorNode.id,
+    cursorNode.type,
+    state2.mode,
+    state2.targetAgentId,
+    rect.w,
+    session.id,
+    session.agents.length,
+    session.orchestratorCycles.length,
+    lastCycle?.completedAt ?? "",
+    lastCycle?.agentsSpawned.length ?? 0,
+    state2.planContent.length,
+    state2.goalContent.length,
+    state2.strategyContent.length,
+    state2.paneAlive,
+    detailReportBlocks.length,
+    session.messages.length,
+    state2.contextFiles.length,
+    contextFileContent?.length ?? -1
+  ].join(":");
   let lines;
   let borderColor = "gray";
-  switch (cursorNode.type) {
-    case "session": {
-      lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
-      break;
-    }
-    case "cycle": {
-      const cycleNode = cursorNode;
-      const cycle = session.orchestratorCycles.find((c) => c.cycle === cycleNode.cycleNumber);
-      if (!cycle) {
-        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
-      } else {
-        lines = buildCycleLines(cycle, session.agents, rect.w);
+  if (cacheKey === state2.detailCacheKey && state2.cachedDetailLines !== null) {
+    lines = state2.cachedDetailLines;
+  } else {
+    switch (cursorNode.type) {
+      case "session": {
+        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
+        break;
       }
-      break;
-    }
-    case "agent": {
-      const agentNode = cursorNode;
-      const agent = agents.find((a) => a.id === agentNode.agentId);
-      if (!agent) {
-        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
-      } else {
-        lines = buildAgentLines(agent, detailReportBlocks, rect.w);
+      case "cycle": {
+        const cycleNode = cursorNode;
+        const cycle = session.orchestratorCycles.find((c) => c.cycle === cycleNode.cycleNumber);
+        if (!cycle) {
+          lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
+        } else {
+          lines = buildCycleLines(cycle, session.agents, rect.w);
+        }
+        break;
       }
-      break;
-    }
-    case "report": {
-      const reportNode = cursorNode;
-      const agent = agents.find((a) => a.id === reportNode.agentId);
-      if (!agent) {
-        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
+      case "agent": {
+        const agentNode = cursorNode;
+        const agent = agents.find((a) => a.id === agentNode.agentId);
+        if (!agent) {
+          lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
+        } else {
+          lines = buildAgentLines(agent, detailReportBlocks, rect.w);
+        }
         break;
       }
-      const reportIdx = reportNode.reportIndex;
-      const specificBlock = detailReportBlocks.find((_b, i) => {
-        const originalIdx = agent.reports.length - 1 - i;
-        return originalIdx === reportIdx;
-      });
-      if (specificBlock) {
-        const { label: badge, color: badgeColor } = reportBadge(specificBlock.type);
-        lines = [
-          [seg(" "), seg(badge, { color: badgeColor }), seg(` ${agent.id} \xB7 ${agentDisplayName(agent)}`, { bold: true })],
-          singleLine(`  ${formatTime(specificBlock.timestamp)}`, { dim: true }),
-          singleLine(" "),
-          [seg("  \u258E CONTENT", { color: badgeColor, bold: true })],
-          ...wrapText(specificBlock.content.trim(), rect.w - 8).map((l) => singleLine(`    ${l}`))
-        ];
-        borderColor = badgeColor;
-      } else {
-        lines = buildAgentLines(agent, detailReportBlocks, rect.w);
+      case "report": {
+        const reportNode = cursorNode;
+        const agent = agents.find((a) => a.id === reportNode.agentId);
+        if (!agent) {
+          lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
+          break;
+        }
+        const reportIdx = reportNode.reportIndex;
+        const specificBlock = detailReportBlocks.find((_b, i) => {
+          const originalIdx = agent.reports.length - 1 - i;
+          return originalIdx === reportIdx;
+        });
+        if (specificBlock) {
+          const { label: badge, color: badgeColor } = reportBadge(specificBlock.type);
+          lines = [
+            [seg(" "), seg(badge, { color: badgeColor }), seg(` ${agent.id} \xB7 ${agentDisplayName(agent)}`, { bold: true })],
+            singleLine(`  ${formatTime(specificBlock.timestamp)}`, { dim: true }),
+            singleLine(" "),
+            [seg("  \u258E CONTENT", { color: badgeColor, bold: true })],
+            ...wrapText(specificBlock.content.trim(), rect.w - 8).map((l) => singleLine(`    ${l}`))
+          ];
+          borderColor = badgeColor;
+        } else {
+          lines = buildAgentLines(agent, detailReportBlocks, rect.w);
+        }
+        break;
       }
-      break;
-    }
-    case "messages": {
-      lines = [singleLine(` Messages (${session.messages.length})`, { bold: true })];
-      if (session.messages.length === 0) {
-        lines.push(singleLine("  No messages", { dim: true, italic: true }));
-      } else {
-        for (const msg of session.messages) {
-          const time = formatTime(msg.timestamp);
-          const agentId = msg.source.type === "agent" ? msg.source.agentId : void 0;
-          const label = messageSourceLabel(msg.source.type, agentId);
-          const labelColor = messageSourceColor(msg.source.type);
-          const maxContent = Math.max(10, rect.w - label.length - 20);
-          lines.push([
-            seg(`  [${time}] `, { dim: true }),
-            seg(`${label}: `, { color: labelColor, bold: true }),
-            seg(wrapText(msg.summary.length > 0 ? msg.summary : msg.content, maxContent)[0], {})
-          ]);
+      case "messages": {
+        lines = [singleLine(` Messages (${session.messages.length})`, { bold: true })];
+        if (session.messages.length === 0) {
+          lines.push(singleLine("  No messages", { dim: true, italic: true }));
+        } else {
+          for (const msg of session.messages) {
+            const time = formatTime(msg.timestamp);
+            const agentId = msg.source.type === "agent" ? msg.source.agentId : void 0;
+            const label = messageSourceLabel(msg.source.type, agentId);
+            const labelColor = messageSourceColor(msg.source.type);
+            const maxContent = Math.max(10, rect.w - label.length - 20);
+            lines.push([
+              seg(`  [${time}] `, { dim: true }),
+              seg(`${label}: `, { color: labelColor, bold: true }),
+              seg(wrapText(msg.summary.length > 0 ? msg.summary : msg.content, maxContent)[0], {})
+            ]);
+          }
         }
+        break;
       }
-      break;
-    }
-    case "message": {
-      const msgNode = cursorNode;
-      const msg = session.messages.find((m) => m.id === msgNode.messageId);
-      lines = [singleLine(" Message", { bold: true })];
-      if (msg) {
-        lines.push(singleLine(`  ${msgNode.source} \xB7 ${msgNode.timestamp}`, { dim: true }));
-        for (const l of wrapText(msg.content, rect.w - 8)) {
-          lines.push(singleLine(`  ${l}`));
+      case "message": {
+        const msgNode = cursorNode;
+        const msg = session.messages.find((m) => m.id === msgNode.messageId);
+        lines = [singleLine(" Message", { bold: true })];
+        if (msg) {
+          lines.push(singleLine(`  ${msgNode.source} \xB7 ${msgNode.timestamp}`, { dim: true }));
+          for (const l of wrapText(msg.content, rect.w - 8)) {
+            lines.push(singleLine(`  ${l}`));
+          }
+        } else {
+          lines.push(singleLine("  Message not found", { dim: true }));
         }
-      } else {
-        lines.push(singleLine("  Message not found", { dim: true }));
+        break;
       }
-      break;
-    }
-    case "context": {
-      lines = [
-        [seg(" "), seg("\u229E", { color: "white" }), seg(` Context (${state2.contextFiles.length})`, { bold: true })]
-      ];
-      if (state2.contextFiles.length === 0) {
-        lines.push(singleLine("  No context files found.", { dim: true }));
-      } else {
-        for (const f of state2.contextFiles) {
-          lines.push(singleLine(`  \xB7 ${f}`, { dim: true }));
+      case "context": {
+        lines = [
+          [seg(" "), seg("\u229E", { color: "white" }), seg(` Context (${state2.contextFiles.length})`, { bold: true })]
+        ];
+        if (state2.contextFiles.length === 0) {
+          lines.push(singleLine("  No context files found.", { dim: true }));
+        } else {
+          for (const f of state2.contextFiles) {
+            lines.push(singleLine(`  \xB7 ${f}`, { dim: true }));
+          }
         }
+        break;
       }
-      break;
-    }
-    case "context-file": {
-      const ctxFileNode = cursorNode;
-      lines = [
-        [seg(" "), seg("\u229E", { color: "white" }), seg(` ${ctxFileNode.label}`, { bold: true })],
-        singleLine(" ")
-      ];
-      if (contextFileContent == null) {
-        lines.push(singleLine("  File not found or unreadable.", { dim: true }));
-      } else {
-        const wrapped = wrapText(stripFrontmatter(contextFileContent), rect.w - 8);
-        if (wrapped.length === 0) {
-          lines.push(singleLine("  (empty)", { dim: true }));
+      case "context-file": {
+        const ctxFileNode = cursorNode;
+        lines = [
+          [seg(" "), seg("\u229E", { color: "white" }), seg(` ${ctxFileNode.label}`, { bold: true })],
+          singleLine(" ")
+        ];
+        if (contextFileContent == null) {
+          lines.push(singleLine("  File not found or unreadable.", { dim: true }));
         } else {
-          for (const l of wrapped) {
-            lines.push(singleLine(`    ${l}`));
+          const wrapped = wrapText(stripFrontmatter(contextFileContent), rect.w - 8);
+          if (wrapped.length === 0) {
+            lines.push(singleLine("  (empty)", { dim: true }));
+          } else {
+            for (const l of wrapped) {
+              lines.push(singleLine(`    ${l}`));
+            }
           }
         }
+        borderColor = "white";
+        break;
+      }
+      default: {
+        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
+        break;
       }
-      borderColor = "white";
-      break;
     }
-    default: {
-      lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
-      break;
+    state2.cachedDetailLines = lines;
+    state2.detailCacheKey = cacheKey;
+  }
+  if (cursorNode.type === "context-file") {
+    borderColor = "white";
+  } else if (cursorNode.type === "report") {
+    const reportNode = cursorNode;
+    const agent = agents.find((a) => a.id === reportNode.agentId);
+    if (agent) {
+      const reportIdx = reportNode.reportIndex;
+      const specificBlock = detailReportBlocks.find((_b, i) => {
+        const originalIdx = agent.reports.length - 1 - i;
+        return originalIdx === reportIdx;
+      });
+      if (specificBlock) borderColor = reportBadge(specificBlock.type).color;
     }
   }
-  renderPanel(buf, rect, lines, scrollOffset, focused, borderColor);
+  return buildPanelRows(rect, lines, scrollOffset, focused, borderColor, state2.detailRenderedCache);
 }
-function renderLogsContent(buf, rect, state2) {
+function renderLogsRows(rect, state2) {
   const focused = state2.focusPane === "logs";
   const scrollOffset = state2.logsScroll.offset;
   if (state2.logsCycles.length === 0) {
-    drawBorder(buf, rect.x, rect.y, rect.w, rect.h, focused ? "blue" : "gray");
-    const midRow = rect.y + Math.floor(rect.h / 2);
-    writeCenter(buf, midRow, "\x1B[2mNo logs\x1B[0m");
-    return;
+    return buildEmptyPanelRows(rect, focused, "gray", "\x1B[2mNo logs\x1B[0m");
+  }
+  const logsCacheKey = `${state2.logsCycles.length}:${rect.w}:${state2.logsCycles.map((c) => c.cycle).join(",")}`;
+  let lines;
+  if (logsCacheKey === state2.logsCacheKey && state2.cachedLogsLines !== null) {
+    lines = state2.cachedLogsLines;
+  } else {
+    lines = buildLogsLines(state2.logsCycles, rect.w);
+    state2.cachedLogsLines = lines;
+    state2.logsCacheKey = logsCacheKey;
   }
-  const lines = buildLogsLines(state2.logsCycles, rect.w);
-  renderPanel(buf, rect, lines, scrollOffset, focused, "gray");
+  return buildPanelRows(rect, lines, scrollOffset, focused, "gray", state2.logsRenderedCache);
+}
+
+// src/tui/panels/nvim-detail.ts
+function renderNvimDetailRows(rect, bridge, focused, editable, statusRows) {
+  const { w, h } = rect;
+  const rows = new Array(h);
+  const borderColor = focused ? "cyan" : "gray";
+  const sgr = `\x1B[${colorToSGR(borderColor)}m`;
+  const reset = "\x1B[0m";
+  const innerW = w - 4;
+  if (focused) {
+    const badgeText = editable ? " EDIT " : " NVIM ";
+    const badgeLen = badgeText.length;
+    const dashesLeft = 2;
+    const dashesRight = Math.max(0, w - 2 - dashesLeft - badgeLen);
+    rows[0] = sgr + "\u256D" + "\u2500".repeat(dashesLeft) + reset + `\x1B[${colorToSGR("cyan")};1m` + badgeText + reset + sgr + "\u2500".repeat(dashesRight) + "\u256E" + reset;
+  } else {
+    rows[0] = sgr + "\u256D" + "\u2500".repeat(w - 2) + "\u256E" + reset;
+  }
+  rows[h - 1] = sgr + "\u2570" + "\u2500".repeat(w - 2) + "\u256F" + reset;
+  const borderL = sgr + "\u2502" + reset + " ";
+  const borderR = " " + sgr + "\u2502" + reset;
+  const blankInner = " ".repeat(innerW);
+  const emptyRow = borderL + blankInner + borderR;
+  for (let i = 1; i < h - 1; i++) rows[i] = emptyRow;
+  if (innerW <= 0 || h <= 2) return rows;
+  const statusCount = statusRows.length;
+  for (let i = 0; i < statusCount && i < h - 3; i++) {
+    const clipped = clipAnsi(statusRows[i], innerW);
+    rows[1 + i] = borderL + clipped + borderR;
+  }
+  const separatorRow = 1 + statusCount;
+  if (separatorRow < h - 1) {
+    rows[separatorRow] = sgr + "\u251C" + "\u2500".repeat(w - 2) + "\u2524" + reset;
+  }
+  const nvimStartRow = separatorRow + 1;
+  const nvimRows = bridge.getRows();
+  for (let i = nvimStartRow; i < h - 1; i++) {
+    const nvimIdx = i - nvimStartRow;
+    const nvimRow = nvimRows[nvimIdx];
+    if (nvimRow !== void 0) {
+      const clipped = clipAnsi(nvimRow, innerW);
+      rows[i] = borderL + clipped + borderR;
+    }
+  }
+  return rows;
 }
 
 // src/tui/panels/bottom.ts
@@ -2777,13 +3060,13 @@ function renderStatusLine(buf, y, state2, cursorNodeType) {
   } else if (mode !== "navigate") {
     content = D("[enter] send  [esc] cancel");
   } else if (focusPane === "logs" || focusPane === "detail") {
-    content = B("[jk/\u2191\u2193]") + D(" scroll  ") + B("[h/\u2190/tab]") + D(" back  ") + B("[t]") + D("oggle logs  ") + SEP + B("[m]") + D("sg  ") + B("[g]") + D("oal  ") + B("[n]") + D("ew  ") + B("[p]") + D("lan  ") + B("[s]") + D("trat  ") + B("[w]") + D("indow  ") + B("[R]") + D("esume  ") + B("[q]") + D("uit");
+    content = B("[jk/\u2191\u2193]") + D(" scroll  ") + B("[h/\u2190/tab]") + D(" back  ") + B("[t]") + D("oggle view  ") + SEP + B("[m]") + D("sg  ") + B("[g]") + D("oal  ") + B("[n]") + D("ew  ") + B("[p]") + D("lan  ") + B("[w]") + D("indow  ") + B("[R]") + D("esume  ") + B("[q]") + D("uit");
   } else {
     let contextFilePart = "";
     if (cursorNodeType === "context-file") {
       contextFilePart = B("[e]") + D("dit  ") + B("[\u23CE]") + D(" open  ");
     }
-    content = B("[hjkl]") + D(" navigate  ") + SEP + contextFilePart + B("[space]") + D(" leader  ") + B("[tab]") + D(" detail  ") + B("[t]") + D("oggle logs  ") + SEP + B("[m]") + D("sg  ") + B("[n]") + D("ew  ") + B("[R]") + D("esume  ") + B("[q]") + D("uit");
+    content = B("[hjkl]") + D(" navigate  ") + SEP + contextFilePart + B("[space]") + D(" leader  ") + B("[tab]") + D(" detail  ") + B("[t]") + D("oggle view  ") + SEP + B("[m]") + D("sg  ") + B("[n]") + D("ew  ") + B("[R]") + D("esume  ") + B("[q]") + D("uit");
   }
   writeClipped(buf, 1, y, content, buf.width - 2);
 }
@@ -2884,13 +3167,662 @@ 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";
+var NvimBridge = class {
+  pty = null;
+  xterm = null;
+  _cols;
+  _rows;
+  onRender;
+  renderTimer = null;
+  currentFile = null;
+  ready = false;
+  dirty = true;
+  available = 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;
+  cmdFile;
+  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`);
+    try {
+      this.nvimPath = execSync3("which nvim", { stdio: "pipe" }).toString().trim();
+      this.available = true;
+    } catch {
+      this.available = false;
+      return;
+    }
+    this.spawn().catch(() => {
+      this.available = false;
+      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;
+        this.dirty = true;
+        this.cachedRows = null;
+        this.onRender();
+      }
+    }, 500);
+  }
+  debouncedRender() {
+    if (this.renderTimer !== null) return;
+    this.renderTimer = setTimeout(() => {
+      this.renderTimer = null;
+      this.onRender();
+    }, 16);
+  }
+  /**
+   * Execute lua in nvim without flashing the command line.
+   * Writes lua to a temp file — a libuv timer in nvim polls and executes it.
+   */
+  execLua(lua) {
+    writeFileSync2(this.cmdFile, lua);
+  }
+  openFile(path, readonly = true) {
+    if (!this.pty || !this.ready) return;
+    this.currentFile = path;
+    const escapeLua = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+    const ro = readonly ? "vim.bo.readonly = true; vim.bo.modifiable = false" : "vim.bo.readonly = false; vim.bo.modifiable = true";
+    this.execLua(`vim.cmd('edit! ${escapeLua(path)}'); ${ro}`);
+  }
+  openTabFiles(files) {
+    if (!this.pty || !this.ready || files.length === 0) return;
+    const key = files.map((f) => f.path).join("|");
+    this.pendingFiles = { files, key };
+    if (this.fileDebounceTimer !== null) clearTimeout(this.fileDebounceTimer);
+    this.fileDebounceTimer = setTimeout(() => {
+      this.fileDebounceTimer = null;
+      if (this.pendingFiles) {
+        this.executeOpenFiles(this.pendingFiles.files);
+        this.currentFile = this.pendingFiles.key;
+        this.pendingFiles = null;
+      }
+    }, 150);
+  }
+  executeOpenFiles(files) {
+    if (!this.pty || !this.ready) return;
+    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"
+    ];
+    for (let i = 0; i < files.length; i++) {
+      const path = escapeLua(files[i].path);
+      stmts.push(i === 0 ? `vim.cmd('edit! ${path}')` : `vim.cmd('edit ${path}')`);
+      if (files[i].readonly) {
+        stmts.push("vim.bo.readonly = true", "vim.bo.modifiable = false");
+      } else {
+        stmts.push("vim.bo.readonly = false", "vim.bo.modifiable = true");
+      }
+    }
+    stmts.push("vim.cmd('bfirst')");
+    this.execLua(`(function() ${stmts.join("; ")} end)()`);
+  }
+  openTabFile(path, readonly) {
+    if (!this.pty || !this.ready) return;
+    this.pty.write(`:tabedit ${path}\r`);
+    if (readonly) {
+      this.pty.write(":setlocal readonly nomodifiable\r");
+    } else {
+      this.pty.write(":setlocal noreadonly modifiable\r");
+    }
+  }
+  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!")');
+    this.currentFile = null;
+  }
+  resize(cols, rows) {
+    this._cols = cols;
+    this._rows = rows;
+    this.cachedRows = null;
+    this.dirty = true;
+    if (this.pty) this.pty.resize(cols, rows);
+    if (this.xterm) this.xterm.resize(cols, rows);
+  }
+  write(data) {
+    if (this.pty) this.pty.write(data);
+  }
+  getRows() {
+    if (!this.dirty && this.cachedRows) return this.cachedRows;
+    if (!this.xterm) return Array.from({ length: this._rows }, () => " ".repeat(this._cols));
+    const rows = [];
+    const buffer = this.xterm.buffer.active;
+    const reusableCell = buffer.getNullCell();
+    for (let y = 0; y < this._rows; y++) {
+      const line = buffer.getLine(y);
+      if (!line) {
+        rows.push(" ".repeat(this._cols));
+        continue;
+      }
+      let row = "";
+      let prevFg = void 0;
+      let prevBg = void 0;
+      let prevFgMode = "default";
+      let prevBgMode = "default";
+      let prevBold = false;
+      let prevDim = false;
+      let prevItalic = false;
+      let prevUnderline = false;
+      let prevInverse = false;
+      let hasOpenSGR = false;
+      for (let x = 0; x < this._cols; x++) {
+        const cell = line.getCell(x, reusableCell);
+        if (!cell) {
+          row += " ";
+          continue;
+        }
+        const char = cell.getChars() || " ";
+        const fgDefault = cell.isFgDefault();
+        const fgPalette = cell.isFgPalette();
+        const fgRGB = cell.isFgRGB();
+        const fg = fgDefault ? void 0 : cell.getFgColor();
+        let fgMode;
+        if (fgDefault) fgMode = "default";
+        else if (fgPalette) fgMode = "palette";
+        else if (fgRGB) fgMode = "rgb";
+        else throw new Error(`Unknown fg color mode at cell (${x}, ${y})`);
+        const bgDefault = cell.isBgDefault();
+        const bgPalette = cell.isBgPalette();
+        const bgRGB = cell.isBgRGB();
+        const bg = bgDefault ? void 0 : cell.getBgColor();
+        let bgMode;
+        if (bgDefault) bgMode = "default";
+        else if (bgPalette) bgMode = "palette";
+        else if (bgRGB) bgMode = "rgb";
+        else throw new Error(`Unknown bg color mode at cell (${x}, ${y})`);
+        const bold = cell.isBold() !== 0;
+        const dim = cell.isDim() !== 0;
+        const italic = cell.isItalic() !== 0;
+        const underline = cell.isUnderline() !== 0;
+        const inverse = cell.isInverse() !== 0;
+        const attrChanged = fg !== prevFg || bg !== prevBg || fgMode !== prevFgMode || bgMode !== prevBgMode || bold !== prevBold || dim !== prevDim || italic !== prevItalic || underline !== prevUnderline || inverse !== prevInverse;
+        if (attrChanged) {
+          if (hasOpenSGR) {
+            row += "\x1B[0m";
+            hasOpenSGR = false;
+          }
+          const codes = [];
+          if (bold) codes.push("1");
+          if (dim) codes.push("2");
+          if (italic) codes.push("3");
+          if (underline) codes.push("4");
+          if (inverse) codes.push("7");
+          if (fg !== void 0) {
+            if (fgMode === "palette") {
+              codes.push(`38;5;${fg}`);
+            } else if (fgMode === "rgb") {
+              const r = fg >> 16 & 255;
+              const g = fg >> 8 & 255;
+              const b = fg & 255;
+              codes.push(`38;2;${r};${g};${b}`);
+            }
+          }
+          if (bg !== void 0) {
+            if (bgMode === "palette") {
+              codes.push(`48;5;${bg}`);
+            } else if (bgMode === "rgb") {
+              const r = bg >> 16 & 255;
+              const g = bg >> 8 & 255;
+              const b = bg & 255;
+              codes.push(`48;2;${r};${g};${b}`);
+            }
+          }
+          if (codes.length > 0) {
+            row += `\x1B[${codes.join(";")}m`;
+            hasOpenSGR = true;
+          }
+          prevFg = fg;
+          prevBg = bg;
+          prevFgMode = fgMode;
+          prevBgMode = bgMode;
+          prevBold = bold;
+          prevDim = dim;
+          prevItalic = italic;
+          prevUnderline = underline;
+          prevInverse = inverse;
+        }
+        row += char;
+      }
+      if (hasOpenSGR) {
+        row += "\x1B[0m";
+      }
+      rows.push(row);
+    }
+    this.cachedRows = rows;
+    this.dirty = false;
+    return rows;
+  }
+  getCursorPos() {
+    if (!this.xterm) return { x: 0, y: 0 };
+    return {
+      x: this.xterm.buffer.active.cursorX,
+      y: this.xterm.buffer.active.cursorY
+    };
+  }
+  checktime() {
+    if (this.pty && this.ready) {
+      this.execLua('vim.cmd("checktime")');
+    }
+  }
+  destroy() {
+    if (this.renderTimer !== null) {
+      clearTimeout(this.renderTimer);
+      this.renderTimer = null;
+    }
+    if (this.fileDebounceTimer !== null) {
+      clearTimeout(this.fileDebounceTimer);
+      this.fileDebounceTimer = null;
+    }
+    try {
+      if (this.pty) {
+        this.pty.kill();
+        this.pty = null;
+      }
+    } catch {
+    }
+    if (this.xterm) {
+      this.xterm.dispose();
+      this.xterm = null;
+    }
+    this.ready = false;
+    try {
+      unlinkSync(this.cmdFile);
+    } catch {
+    }
+  }
+};
+
+// 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";
+function atomicWrite(filePath, content) {
+  const tmp = filePath + ".tmp." + process.pid;
+  writeFileSync3(tmp, content, "utf-8");
+  renameSync(tmp, filePath);
+}
+function ensureTuiDir(cwd2, sessionId) {
+  const dir = tuiScratchDir(cwd2, sessionId);
+  mkdirSync3(dir, { recursive: true });
+  return dir;
+}
+function formatTimestamp(iso) {
+  try {
+    const d = new Date(iso);
+    return d.toLocaleString("en-US", {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      hour12: false
+    });
+  } catch {
+    return iso;
+  }
+}
+function formatDurationMs(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rem = s % 60;
+  if (m < 60) return rem > 0 ? `${m}m ${rem}s` : `${m}m`;
+  const h = Math.floor(m / 60);
+  const remM = m % 60;
+  return remM > 0 ? `${h}h ${remM}m` : `${h}h`;
+}
+function sectionBreak() {
+  return ["", "", "---", "", ""];
+}
+function composeCycleDetail(session, cycle) {
+  const isRunning = !cycle.completedAt;
+  const dur = isRunning ? "running" : formatDurationMs(cycle.activeMs);
+  const cycleAgents = session.agents.filter((a) => cycle.agentsSpawned.includes(a.id));
+  const lines = [];
+  lines.push(`# Cycle ${cycle.cycle}`);
+  lines.push("");
+  lines.push(`**Status:** ${isRunning ? "running" : "completed"}  |  **Duration:** ${dur}`);
+  lines.push(`**Started:** ${formatTimestamp(cycle.timestamp)}`);
+  if (cycle.completedAt) {
+    lines.push(`**Completed:** ${formatTimestamp(cycle.completedAt)}`);
+  }
+  if (cycle.mode) {
+    lines.push(`**Mode:** ${cycle.mode}`);
+  }
+  if (cycle.claudeSessionId) {
+    lines.push(`**Claude Session:** ${cycle.claudeSessionId}`);
+  }
+  lines.push(...sectionBreak());
+  lines.push("## Agents");
+  lines.push("");
+  if (cycleAgents.length === 0) {
+    lines.push("_No agents spawned yet._");
+  } else {
+    for (const agent of cycleAgents) {
+      const agentDur = formatDurationMs(agent.activeMs);
+      lines.push(`### ${agent.id} \u2014 ${agent.name || agent.agentType || agent.id}`);
+      lines.push(`- **Status:** ${agent.status}  |  **Duration:** ${agentDur}`);
+      lines.push(`- **Type:** ${agent.agentType || "\u2014"}`);
+      if (agent.killedReason) {
+        lines.push(`- **Killed reason:** ${agent.killedReason}`);
+      }
+      lines.push("");
+      lines.push("**Instruction:**");
+      lines.push("");
+      lines.push(agent.instruction);
+      const latestReport = agent.reports.length > 0 ? agent.reports[agent.reports.length - 1] : null;
+      if (latestReport) {
+        lines.push("");
+        lines.push(`**Latest report** (${latestReport.type}, ${formatTimestamp(latestReport.timestamp)}):**`);
+        lines.push("");
+        lines.push(latestReport.summary);
+      }
+      lines.push("");
+    }
+  }
+  if (cycle.nextPrompt) {
+    lines.push(...sectionBreak());
+    lines.push("## Next Prompt");
+    lines.push("");
+    lines.push(cycle.nextPrompt.trim());
+    lines.push("");
+  }
+  return lines.join("\n") + "\n";
+}
+function composeAgentDetail(agent, reportBlocks) {
+  const dur = formatDurationMs(agent.activeMs);
+  const lines = [];
+  lines.push(`# ${agent.id} \u2014 ${agent.name || agent.agentType || agent.id}`);
+  lines.push("");
+  lines.push(
+    `**Status:** ${agent.status}  |  **Duration:** ${dur}  |  **Type:** ${agent.agentType || "\u2014"}`
+  );
+  lines.push(`**Spawned:** ${formatTimestamp(agent.spawnedAt)}`);
+  if (agent.completedAt) {
+    lines.push(`**Completed:** ${formatTimestamp(agent.completedAt)}`);
+  }
+  if (agent.killedReason) {
+    lines.push(`**Killed reason:** ${agent.killedReason}`);
+  }
+  if (agent.claudeSessionId) {
+    lines.push(`**Claude Session:** ${agent.claudeSessionId}`);
+  }
+  lines.push(...sectionBreak());
+  lines.push("## Instruction");
+  lines.push("");
+  lines.push(agent.instruction.trim());
+  if (reportBlocks.length > 0) {
+    lines.push(...sectionBreak());
+    lines.push(`## Reports (${reportBlocks.length})`);
+    for (const block of reportBlocks) {
+      lines.push("");
+      const badge = block.type === "final" ? "FINAL" : "UPDATE";
+      lines.push(`### ${badge} \u2014 ${formatTimestamp(block.timestamp)}`);
+      lines.push("");
+      lines.push(block.content.trim());
+    }
+  } else if (agent.reports.length > 0) {
+    lines.push(...sectionBreak());
+    lines.push(`## Reports (${agent.reports.length})`);
+    for (const report of agent.reports) {
+      const badge = report.type === "final" ? "FINAL" : "UPDATE";
+      lines.push("");
+      lines.push(`### ${badge} \u2014 ${formatTimestamp(report.timestamp)}`);
+      lines.push("");
+      lines.push(report.summary);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function composeMessages(session) {
+  const lines = [];
+  lines.push("# Messages");
+  lines.push("");
+  lines.push(`**Session:** ${session.name ?? session.task.slice(0, 60)}`);
+  lines.push(`**Total messages:** ${session.messages.length}`);
+  if (session.messages.length === 0) {
+    lines.push("");
+    lines.push("_No messages yet._");
+    return lines.join("\n") + "\n";
+  }
+  const sorted = [...session.messages].sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+  for (const msg of sorted) {
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+    const src = msg.source;
+    let sourceLabel;
+    if (src.type === "agent") {
+      sourceLabel = src.agentId;
+    } else if (src.type === "user") {
+      sourceLabel = "You";
+    } else {
+      sourceLabel = src.detail ? `system (${src.detail})` : "system";
+    }
+    lines.push(`**From:** ${sourceLabel}  |  **Time:** ${formatTimestamp(msg.timestamp)}`);
+    if (msg.summary && msg.summary !== msg.content) {
+      lines.push(`**Summary:** ${msg.summary}`);
+    }
+    lines.push("");
+    lines.push(msg.content.trim());
+  }
+  return lines.join("\n") + "\n";
+}
+function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
+  if (!cursorNode) return null;
+  const sessionId = cursorNode.sessionId;
+  if (!sessionId) return null;
+  const session = detailCtx.session;
+  switch (cursorNode.type) {
+    case "session": {
+      if (!session) return null;
+      const files = [];
+      const gp = goalPath(cwd2, sessionId);
+      if (existsSync2(gp)) files.push({ path: gp, readonly: false });
+      const rp = roadmapPath(cwd2, sessionId);
+      if (existsSync2(rp)) files.push({ path: rp, readonly: false });
+      const sp = strategyPath(cwd2, sessionId);
+      if (existsSync2(sp)) files.push({ path: sp, readonly: false });
+      if (files.length === 0) return null;
+      return { files };
+    }
+    case "cycle": {
+      if (!session) return null;
+      const cycle = session.orchestratorCycles.find(
+        (c) => c.cycle === cursorNode.cycleNumber
+      );
+      if (!cycle) return null;
+      const dir = ensureTuiDir(cwd2, sessionId);
+      const filePath = join4(dir, `cycle-${cursorNode.cycleNumber}.md`);
+      atomicWrite(filePath, composeCycleDetail(session, cycle));
+      return { files: [{ path: filePath, readonly: true }] };
+    }
+    case "agent": {
+      if (!session) return null;
+      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`);
+      atomicWrite(filePath, composeAgentDetail(agent, state2.cachedReportBlocks.get(agent.id) ?? []));
+      return { files: [{ path: filePath, readonly: true }] };
+    }
+    case "report": {
+      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)) {
+          return { files: [{ path: report.filePath, readonly: true }] };
+        }
+      }
+      return null;
+    }
+    case "context-file": {
+      if (cursorNode.filePath && existsSync2(cursorNode.filePath)) {
+        return { files: [{ path: cursorNode.filePath, readonly: false }] };
+      }
+      return null;
+    }
+    case "messages":
+    case "message": {
+      if (!session || session.messages.length === 0) return null;
+      const dir = ensureTuiDir(cwd2, sessionId);
+      const filePath = join4(dir, "messages.md");
+      atomicWrite(filePath, composeMessages(session));
+      return { files: [{ path: filePath, readonly: true }] };
+    }
+    case "context": {
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+
 // src/tui/app.ts
 var latestNodes = [];
 var cachedContextFilePath = null;
 var cachedContextFileContent = null;
 var prevFrame = [];
+var prevTreeInputs = "";
+var prevBottomInputs = "";
+var prevOverlayMode = "";
+var cachedTreeRows = [];
 var cachedLogSessionId = null;
 var cachedLogFiles = /* @__PURE__ */ new Map();
+var STATUS_ROW_COUNT = 2;
+function buildStatusRows(cursorNode, session, state2) {
+  if (!cursorNode || !session) {
+    return [ansiDim(" No session selected"), ""];
+  }
+  const dur = formatDuration(session.createdAt, session.completedAt);
+  const indicator = statusIndicator(session.status);
+  const sColor = statusColor(session.status);
+  const title = truncate(session.name ?? session.task, 40);
+  switch (cursorNode.type) {
+    case "session": {
+      return [
+        " " + ansiColor(indicator, sColor, true) + " " + ansiColor(title, "white", true),
+        " " + ansiDim(`${session.status} \xB7 ${session.orchestratorCycles.length} cycles \xB7 ${session.agents.length} agents \xB7 ${dur}`)
+      ];
+    }
+    case "cycle": {
+      const cycle = session.orchestratorCycles.find((c) => c.cycle === cursorNode.cycleNumber);
+      if (!cycle) return [" " + ansiColor(title, "white", true), ""];
+      const cDur = cycle.completedAt ? formatDuration(cycle.timestamp, cycle.completedAt) : "running";
+      const cStatus = cycle.completedAt ? "completed" : "running";
+      return [
+        " " + ansiColor(indicator, sColor, true) + " " + ansiColor(title, "white", true) + ansiDim(` \xB7 Cycle ${cycle.cycle}`),
+        " " + ansiDim(`${cStatus} \xB7 ${cDur} \xB7 ${cycle.agentsSpawned.length} agents`)
+      ];
+    }
+    case "agent":
+    case "report": {
+      const agentId = cursorNode.type === "agent" ? cursorNode.agentId : cursorNode.agentId;
+      const agent = session.agents.find((a) => a.id === agentId);
+      if (!agent) return [" " + ansiColor(title, "white", true), ""];
+      const aIcon = agentStatusIcon(agent.status);
+      const aDur = formatDuration(agent.spawnedAt, agent.completedAt);
+      const aName = agentDisplayName(agent);
+      return [
+        " " + ansiColor(aIcon, statusColor(agent.status === "running" ? "active" : agent.status), true) + " " + ansiColor(`${agent.id} \xB7 ${aName}`, "white", true),
+        " " + ansiDim(`${agent.status} \xB7 ${agent.agentType || "\u2014"} \xB7 ${aDur}`)
+      ];
+    }
+    case "context-file": {
+      const name = cursorNode.filePath.split("/").pop() ?? cursorNode.filePath;
+      return [
+        " " + ansiColor("\u229E", "white") + " " + ansiColor(name, "white", true),
+        " " + ansiDim(`context file \xB7 ${session.status}`)
+      ];
+    }
+    case "messages":
+    case "message": {
+      return [
+        " " + ansiColor(indicator, sColor, true) + " " + ansiColor(title, "white", true),
+        " " + ansiDim(`${session.messages.length} messages`)
+      ];
+    }
+    default: {
+      return [
+        " " + ansiColor(indicator, sColor, true) + " " + ansiColor(title, "white", true),
+        " " + ansiDim(`${session.status} \xB7 ${dur}`)
+      ];
+    }
+  }
+}
 function getAgentForNode(node, agents) {
   if (!node) return null;
   if (node.type === "agent" || node.type === "report") {
@@ -2900,7 +3832,18 @@ function getAgentForNode(node, agents) {
 }
 function startApp(state2, cleanup2) {
   const config = loadConfig(state2.cwd);
+  const treeWidth = 36;
+  const initialDetailW = state2.cols - treeWidth - 4;
+  const initialDetailH = state2.rows - 3 - 2 - STATUS_ROW_COUNT - 1;
+  const bridge = new NvimBridge(
+    Math.max(1, initialDetailW),
+    Math.max(1, initialDetailH),
+    requestRender
+  );
+  state2.nvimBridge = bridge.available ? bridge : null;
+  state2.nvimEnabled = bridge.available;
   let prevSelectedSessionId = void 0;
+  let debouncedPollTimer = null;
   async function poll() {
     try {
       let selectedSession = null;
@@ -2918,13 +3861,10 @@ function startApp(state2, cleanup2) {
         statusPromise ?? Promise.resolve(null)
       ]);
       const sessions = listRes.ok ? listRes.data?.sessions ?? [] : [];
+      const aliveWindows = listAllWindowIds();
       for (const s of sessions) {
         if (s.status !== "completed" && s.tmuxWindowId) {
-          try {
-            s.windowAlive = windowExists(s.tmuxWindowId);
-          } catch {
-            s.windowAlive = false;
-          }
+          s.windowAlive = aliveWindows.has(s.tmuxWindowId);
         }
       }
       if (state2.selectedSessionId) {
@@ -2937,28 +3877,28 @@ function startApp(state2, cleanup2) {
         }
         try {
           const pp = roadmapPath(state2.cwd, state2.selectedSessionId);
-          if (existsSync2(pp)) {
+          if (existsSync3(pp)) {
             planContent = readFileSync2(pp, "utf-8");
           }
         } catch {
         }
         try {
           const gp = goalPath(state2.cwd, state2.selectedSessionId);
-          if (existsSync2(gp)) {
+          if (existsSync3(gp)) {
             goalContent = readFileSync2(gp, "utf-8");
           }
         } catch {
         }
         try {
           const sp = strategyPath(state2.cwd, state2.selectedSessionId);
-          if (existsSync2(sp)) {
+          if (existsSync3(sp)) {
             strategyContent = readFileSync2(sp, "utf-8");
           }
         } catch {
         }
         try {
           const ld = logsDir(state2.cwd, state2.selectedSessionId);
-          if (existsSync2(ld)) {
+          if (existsSync3(ld)) {
             if (state2.selectedSessionId !== cachedLogSessionId) {
               cachedLogFiles = /* @__PURE__ */ new Map();
               cachedLogSessionId = state2.selectedSessionId;
@@ -2969,7 +3909,7 @@ function startApp(state2, cleanup2) {
               if (!fileSet.has(key)) cachedLogFiles.delete(key);
             }
             for (const f of files) {
-              const filePath = join3(ld, f);
+              const filePath = join5(ld, f);
               const mtime = statSync(filePath).mtimeMs;
               const cached = cachedLogFiles.get(f);
               if (!cached || cached.mtime !== mtime) {
@@ -2989,7 +3929,7 @@ function startApp(state2, cleanup2) {
         }
         try {
           const cd = contextDir(state2.cwd, state2.selectedSessionId);
-          if (existsSync2(cd)) {
+          if (existsSync3(cd)) {
             contextFiles = readdirSync(cd).filter((f) => !f.startsWith(".")).sort();
           }
         } catch {
@@ -3011,6 +3951,9 @@ function startApp(state2, cleanup2) {
       state2.paneAlive = paneAlive;
       state2.contextFiles = contextFiles;
       state2.error = null;
+      if (state2.nvimEnabled && state2.nvimBridge?.ready && state2.prevNvimFile) {
+        state2.nvimBridge.checktime();
+      }
       requestRender();
     } catch (err) {
       state2.error = err.message;
@@ -3027,17 +3970,17 @@ function startApp(state2, cleanup2) {
       writeCenter(buf, Math.floor(state2.rows / 2), "Terminal too small \u2014 resize to continue");
       const out2 = flushFrame(buf.lines, prevFrame);
       writeToStdout(out2);
-      prevFrame = [...buf.lines];
+      prevFrame = buf.lines;
       return;
     }
-    const treeWidth = 36;
-    const remaining = state2.cols - treeWidth;
-    const detailWidth = state2.showLogs ? Math.floor(remaining * 0.6) : remaining;
-    const logsWidth = state2.showLogs ? remaining - detailWidth : 0;
+    const treeWidth2 = 36;
+    const remaining = state2.cols - treeWidth2;
+    const detailWidth = state2.showCombinedView ? Math.floor(remaining * 0.6) : remaining;
+    const logsWidth = state2.showCombinedView ? remaining - detailWidth : 0;
     const contentHeight = state2.rows - 3;
-    const treeRect = { x: 0, y: 0, w: treeWidth, h: contentHeight };
-    const detailRect = { x: treeWidth, y: 0, w: detailWidth, h: contentHeight };
-    const logsRect = state2.showLogs ? { x: treeWidth + detailWidth, y: 0, w: logsWidth, h: contentHeight } : null;
+    const treeRect = { x: 0, y: 0, w: treeWidth2, h: contentHeight };
+    const detailRect = { x: treeWidth2, y: 0, w: detailWidth, h: contentHeight };
+    const logsRect = state2.showCombinedView ? { x: treeWidth2 + detailWidth, y: 0, w: logsWidth, h: contentHeight } : null;
     const bottomY = contentHeight;
     const filteredSessions = state2.searchFilter ? state2.sessions.filter((s) => {
       const q = state2.searchFilter.toLowerCase();
@@ -3055,6 +3998,7 @@ function startApp(state2, cleanup2) {
         state2.cwd,
         state2.contextFiles
       );
+      precomputePrefixes(nodes);
       state2.cachedTreeNodes = nodes;
       state2.treeCacheKey = cacheKey;
     }
@@ -3067,11 +4011,20 @@ function startApp(state2, cleanup2) {
       state2.selectedSessionId = newSessionId;
       state2.detailScroll.reset();
       state2.logsScroll.reset();
+      state2.cachedDetailLines = null;
+      state2.detailCacheKey = "";
+      state2.prevNvimFile = null;
+      state2.cachedLogsLines = null;
+      state2.logsCacheKey = "";
     }
     if (state2.selectedSessionId !== prevSelectedSessionId) {
       prevSelectedSessionId = state2.selectedSessionId;
+      if (debouncedPollTimer !== null) clearTimeout(debouncedPollTimer);
       if (state2.selectedSessionId !== null) {
-        void poll();
+        debouncedPollTimer = setTimeout(() => {
+          debouncedPollTimer = null;
+          void poll();
+        }, 80);
       }
     }
     autoExpandCycle(state2);
@@ -3085,7 +4038,7 @@ function startApp(state2, cleanup2) {
       if (cursorNode.filePath !== cachedContextFilePath) {
         cachedContextFilePath = cursorNode.filePath;
         try {
-          if (existsSync2(cursorNode.filePath)) {
+          if (existsSync3(cursorNode.filePath)) {
             cachedContextFileContent = readFileSync2(cursorNode.filePath, "utf-8");
           } else {
             cachedContextFileContent = null;
@@ -3099,13 +4052,37 @@ function startApp(state2, cleanup2) {
       cachedContextFilePath = null;
       cachedContextFileContent = null;
     }
-    renderTreePanel(
-      buf,
-      treeRect,
-      nodes,
-      state2.cursorIndex,
-      state2.mode === "navigate" && state2.focusPane === "tree"
-    );
+    const treeFocused = state2.mode === "navigate" && state2.focusPane === "tree";
+    const treeInputs = `${state2.treeCacheKey}:${state2.cursorIndex}:${treeFocused}`;
+    const bottomInputs = `${state2.notification}:${state2.error}:${state2.mode}:${state2.inputText}:${state2.inputCursorPos}:${cursorNode?.type}`;
+    const overlayMode = state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "help" ? state2.mode : "";
+    const hasPrev = prevFrame.length === buf.height;
+    const treeDirty = !hasPrev || treeInputs !== prevTreeInputs;
+    const bottomDirty = !hasPrev || bottomInputs !== prevBottomInputs;
+    const overlayDirty = !hasPrev || overlayMode !== prevOverlayMode;
+    prevTreeInputs = treeInputs;
+    prevBottomInputs = bottomInputs;
+    prevOverlayMode = overlayMode;
+    let treeRows;
+    if (treeDirty) {
+      const treeBlank = " ".repeat(treeWidth2);
+      const treeBuf = {
+        lines: Array.from({ length: contentHeight }, () => treeBlank),
+        width: treeWidth2,
+        height: contentHeight
+      };
+      renderTreePanel(
+        treeBuf,
+        { x: 0, y: 0, w: treeWidth2, h: contentHeight },
+        nodes,
+        state2.cursorIndex,
+        treeFocused
+      );
+      cachedTreeRows = treeBuf.lines;
+      treeRows = treeBuf.lines;
+    } else {
+      treeRows = cachedTreeRows;
+    }
     const detailCtx = {
       nodes,
       session: state2.selectedSession,
@@ -3114,19 +4091,55 @@ function startApp(state2, cleanup2) {
       detailReportBlocks,
       contextFileContent
     };
-    renderDetailContent(buf, detailRect, state2, detailCtx);
-    if (logsRect) {
-      renderLogsContent(buf, logsRect, state2);
-    }
-    renderNotificationRow(buf, bottomY, state2.notification, state2.error);
-    renderInputBar(buf, bottomY + 1, state2);
-    renderStatusLine(buf, bottomY + 2, state2, cursorNode?.type);
-    if (state2.mode === "leader") renderLeaderOverlay(buf, state2.rows, state2.cols);
-    if (state2.mode === "copy-menu") renderCopyMenuOverlay(buf, state2.rows, state2.cols);
-    if (state2.mode === "help") renderHelpOverlay(buf, state2.rows, state2.cols);
-    const out = flushFrame(buf.lines, prevFrame);
+    let detailRows;
+    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;
+      }
+      const statusRows = buildStatusRows(cursorNode, state2.selectedSession, state2);
+      detailRows = renderNvimDetailRows(detailRect, state2.nvimBridge, state2.focusPane === "detail", state2.nvimEditable, statusRows);
+    } else {
+      detailRows = renderDetailRows(detailRect, state2, detailCtx);
+    }
+    const logsRows = logsRect ? renderLogsRows(logsRect, state2) : null;
+    for (let i = 0; i < contentHeight; i++) {
+      if (logsRows) {
+        buf.lines[i] = treeRows[i] + detailRows[i] + logsRows[i];
+      } else {
+        buf.lines[i] = treeRows[i] + detailRows[i];
+      }
+    }
+    if (bottomDirty || overlayDirty) {
+      renderNotificationRow(buf, bottomY, state2.notification, state2.error);
+      renderInputBar(buf, bottomY + 1, state2);
+      renderStatusLine(buf, bottomY + 2, state2, cursorNode?.type);
+    } else {
+      copyRows(buf, prevFrame, bottomY, 3);
+    }
+    if (overlayMode) {
+      if (state2.mode === "leader") renderLeaderOverlay(buf, state2.rows, state2.cols);
+      if (state2.mode === "copy-menu") renderCopyMenuOverlay(buf, state2.rows, state2.cols);
+      if (state2.mode === "help") renderHelpOverlay(buf, state2.rows, state2.cols);
+    }
+    let cursorSuffix;
+    if (state2.focusPane === "detail" && state2.nvimBridge?.ready) {
+      const cursor = state2.nvimBridge.getCursorPos();
+      const absX = detailRect.x + 2 + cursor.x;
+      const absY = detailRect.y + 1 + STATUS_ROW_COUNT + 1 + cursor.y;
+      cursorSuffix = `\x1B[${state2.nvimBridge.cursorStyle} q\x1B[?25h\x1B[${absY + 1};${absX + 1}H`;
+    } else {
+      cursorSuffix = "\x1B[0 q\x1B[?25l";
+    }
+    const out = flushFrame(buf.lines, prevFrame, cursorSuffix);
     writeToStdout(out);
-    prevFrame = [...buf.lines];
+    prevFrame = buf.lines;
   }
   const inputActions = {
     getNodes: () => latestNodes,
@@ -3180,6 +4193,11 @@ function startApp(state2, cleanup2) {
     state2.rows = typeof stdoutRows === "number" && stdoutRows > 0 ? stdoutRows : 24;
     state2.cols = typeof stdoutCols === "number" && stdoutCols > 0 ? stdoutCols : 80;
     prevFrame = [];
+    if (state2.nvimBridge) {
+      const detailW = state2.cols - 36;
+      const contentH = state2.rows - 3;
+      state2.nvimBridge.resize(Math.max(1, detailW - 4), Math.max(1, contentH - 2 - STATUS_ROW_COUNT - 1));
+    }
     requestRender();
   });
   void poll();
@@ -3187,10 +4205,12 @@ function startApp(state2, cleanup2) {
   const origCleanup = inputActions.cleanup;
   inputActions.cleanup = () => {
     clearInterval(pollInterval);
+    if (debouncedPollTimer !== null) clearTimeout(debouncedPollTimer);
     stopKeypress();
     stopResize();
     state2.detailScroll.destroy();
     state2.logsScroll.destroy();
+    state2.nvimBridge?.destroy();
     origCleanup();
   };
   requestRender();