sisyphi 1.1.10 → 1.1.12

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,
@@ -339,6 +347,11 @@ function createAppState(cwd2) {
     cachedLogsLines: null,
     logsCacheKey: "",
     logsRenderedCache: { lines: [], ansi: [] },
+    nvimBridge: null,
+    nvimEnabled: true,
+    prevNvimFile: null,
+    nvimEditable: false,
+    nvimOpenTabs: /* @__PURE__ */ new Map(),
     cwd: cwd2
   };
 }
@@ -402,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";
@@ -791,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;
@@ -1291,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;
@@ -1333,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";
     }
@@ -1577,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");
@@ -1601,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;
   }
@@ -1673,7 +1700,7 @@ function copyRows(buf, src, startRow, count) {
     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]) {
@@ -1682,6 +1709,7 @@ function flushFrame(frame, prevFrame2) {
       out += frame[i];
     }
   }
+  if (suffix) out += suffix;
   out += "\x1B[?2026l";
   return out;
 }
@@ -2359,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;
@@ -2400,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 }));
@@ -2415,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 }));
@@ -2758,7 +2778,6 @@ function renderDetailRows(rect, state2, detailCtx) {
     cursorNode.type,
     state2.mode,
     state2.targetAgentId,
-    state2.showStrategy,
     rect.w,
     session.id,
     session.agents.length,
@@ -2781,14 +2800,14 @@ function renderDetailRows(rect, state2, detailCtx) {
   } else {
     switch (cursorNode.type) {
       case "session": {
-        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
+        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
         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);
+          lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
         } else {
           lines = buildCycleLines(cycle, session.agents, rect.w);
         }
@@ -2798,7 +2817,7 @@ function renderDetailRows(rect, state2, detailCtx) {
         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);
+          lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
         } else {
           lines = buildAgentLines(agent, detailReportBlocks, rect.w);
         }
@@ -2808,7 +2827,7 @@ function renderDetailRows(rect, state2, detailCtx) {
         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);
+          lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
           break;
         }
         const reportIdx = reportNode.reportIndex;
@@ -2900,7 +2919,7 @@ function renderDetailRows(rect, state2, detailCtx) {
         break;
       }
       default: {
-        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent, state2.showStrategy);
+        lines = buildSessionLines(session, state2.planContent, state2.goalContent, rect.w, state2.paneAlive, state2.strategyContent);
         break;
       }
     }
@@ -2941,6 +2960,52 @@ function renderLogsRows(rect, state2) {
   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
 function renderNotificationRow(buf, y, notification, error) {
   if (notification !== null) {
@@ -2995,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);
 }
@@ -3102,6 +3167,590 @@ 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;
@@ -3113,6 +3762,67 @@ 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") {
@@ -3122,6 +3832,16 @@ 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() {
@@ -3157,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;
@@ -3189,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) {
@@ -3209,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 {
@@ -3231,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;
@@ -3250,14 +3973,14 @@ function startApp(state2, cleanup2) {
       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();
@@ -3290,6 +4013,7 @@ function startApp(state2, cleanup2) {
       state2.logsScroll.reset();
       state2.cachedDetailLines = null;
       state2.detailCacheKey = "";
+      state2.prevNvimFile = null;
       state2.cachedLogsLines = null;
       state2.logsCacheKey = "";
     }
@@ -3314,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;
@@ -3341,15 +4065,15 @@ function startApp(state2, cleanup2) {
     prevOverlayMode = overlayMode;
     let treeRows;
     if (treeDirty) {
-      const treeBlank = " ".repeat(treeWidth);
+      const treeBlank = " ".repeat(treeWidth2);
       const treeBuf = {
         lines: Array.from({ length: contentHeight }, () => treeBlank),
-        width: treeWidth,
+        width: treeWidth2,
         height: contentHeight
       };
       renderTreePanel(
         treeBuf,
-        { x: 0, y: 0, w: treeWidth, h: contentHeight },
+        { x: 0, y: 0, w: treeWidth2, h: contentHeight },
         nodes,
         state2.cursorIndex,
         treeFocused
@@ -3367,7 +4091,23 @@ function startApp(state2, cleanup2) {
       detailReportBlocks,
       contextFileContent
     };
-    const detailRows = renderDetailRows(detailRect, state2, detailCtx);
+    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) {
@@ -3388,7 +4128,16 @@ function startApp(state2, cleanup2) {
       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 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;
   }
@@ -3444,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();
@@ -3456,6 +4210,7 @@ function startApp(state2, cleanup2) {
     stopResize();
     state2.detailScroll.destroy();
     state2.logsScroll.destroy();
+    state2.nvimBridge?.destroy();
     origCleanup();
   };
   requestRender();