sisyphi 1.1.16 → 1.1.18

package/dist/tui.js

@@ -4,20 +4,28 @@ import {
   augmentedPath,
   exec,
   execSafe
-} from "./chunk-6TIO23U3.js";
+} from "./chunk-22ZGZTGY.js";
 import {
   buildSessionContext,
   computeActiveTimeMs,
+  createBadgeGallery,
   formatDuration,
+  galleryNext,
+  galleryPrev,
   rawSend,
+  renderBadgeCard,
   resolveReports,
   statusColor
-} from "./chunk-HQZOAX6D.js";
+} from "./chunk-C2XKXERJ.js";
 import {
+  ACHIEVEMENTS,
+  getMoodFace,
   loadConfig,
+  renderCompanion,
   shellQuote
-} from "./chunk-IF55HPWX.js";
+} from "./chunk-V36NXMHP.js";
 import {
+  companionPath,
   contextDir,
   globalDir,
   goalPath,
@@ -25,8 +33,9 @@ import {
   roadmapPath,
   sessionDir,
   strategyPath,
+  tmuxSessionName,
   tuiScratchDir
-} from "./chunk-GSXF3TCZ.js";
+} from "./chunk-TMBAVPHH.js";
 
 // src/tui/terminal.ts
 function emptyKey() {
@@ -235,27 +244,6 @@ var COMPOSE_HEADERS = {
   "spawn-agent": "Spawn Agent",
   "message-agent": "Message Agent"
 };
-var INPUT_MODES = /* @__PURE__ */ new Set([
-  "resume",
-  "continue",
-  "rollback",
-  "delete-confirm",
-  "spawn-agent",
-  "search",
-  "message-agent",
-  "shell-command"
-]);
-var OPTIONAL_INPUT = /* @__PURE__ */ new Set(["resume", "continue", "search"]);
-var PROMPTS = {
-  resume: "resume instructions (optional)",
-  continue: "new direction (optional)",
-  rollback: "cycle number",
-  "delete-confirm": "type 'yes' to confirm delete:",
-  "spawn-agent": "agent instruction:",
-  search: "filter:",
-  "message-agent": "message:",
-  "shell-command": "$ "
-};
 var renderScheduled = false;
 var renderFn = null;
 function setRenderFunction(fn) {
@@ -326,12 +314,11 @@ function createAppState(cwd2) {
     focusPane: "tree",
     selectedSessionId: null,
     searchFilter: null,
+    searchText: "",
     targetAgentId: null,
     notification: null,
     notificationTimer: null,
     showCombinedView: false,
-    inputText: "",
-    inputCursorPos: 0,
     detailScroll,
     logsScroll,
     sessions: [],
@@ -822,356 +809,911 @@ function findParentIndex(nodes, index) {
   return 0;
 }
 
-// src/tui/input.ts
-function activateNvimBypass(state2) {
-  setRawBypass((data) => {
-    if (!state2.nvimBridge?.ready) {
-      deactivateNvimBypass();
-      state2.focusPane = "tree";
-      if (state2.mode === "compose") cancelCompose(state2);
-      requestRender();
-      return false;
-    }
-    if (data === "	") {
-      if (state2.mode === "compose") {
-        cancelCompose(state2);
-        return true;
-      }
-      deactivateNvimBypass();
-      state2.focusPane = state2.showCombinedView ? "logs" : "tree";
-      requestRender();
-      return true;
-    }
-    state2.nvimBridge.write(data);
-    return true;
-  });
-}
-function deactivateNvimBypass() {
-  setRawBypass(null);
+// src/tui/render.ts
+import stringWidth2 from "string-width";
+var COLOR_SGR = {
+  black: 30,
+  red: 31,
+  green: 32,
+  yellow: 33,
+  blue: 34,
+  magenta: 35,
+  cyan: 36,
+  white: 37,
+  gray: 90
+};
+function colorToSGR(color) {
+  const code = COLOR_SGR[color];
+  if (code === void 0) throw new Error(`Unknown color: ${color}`);
+  return code;
 }
-var COMPOSE_DIR = join2(tmpdir(), "sisyphus-nvim");
-function enterComposeMode(state2, action, actions) {
-  if (!state2.nvimEnabled || !state2.nvimBridge?.ready) return false;
-  mkdirSync(COMPOSE_DIR, { recursive: true });
-  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-  const tempFile = join2(COMPOSE_DIR, `compose-${id}.md`);
-  const signalFile = join2(COMPOSE_DIR, `compose-signal-${id}`);
-  writeFileSync(tempFile, "", "utf-8");
-  state2.composePrevNvimFile = state2.prevNvimFile;
-  state2.composeAction = action;
-  state2.composeTempFile = tempFile;
-  state2.composeSignalFile = signalFile;
-  state2.mode = "compose";
-  state2.focusPane = "detail";
-  state2.nvimBridge.openComposeFile(tempFile, signalFile);
-  activateNvimBypass(state2);
-  state2.composePollTimer = setInterval(() => {
-    checkComposeSignal(state2, actions);
-  }, 100);
-  requestRender();
-  return true;
+function renderLine(segs) {
+  let out = "";
+  for (const s of segs) {
+    const codes = [];
+    if (s.bold) codes.push(1);
+    if (s.dim) codes.push(2);
+    if (s.italic) codes.push(3);
+    if (s.inverse) codes.push(7);
+    if (s.color) codes.push(colorToSGR(s.color));
+    if (codes.length > 0) {
+      out += `\x1B[${codes.join(";")}m${s.text}\x1B[0m`;
+    } else {
+      out += s.text;
+    }
+  }
+  return out;
 }
-function cancelCompose(state2) {
-  if (state2.composePollTimer !== null) {
-    clearInterval(state2.composePollTimer);
-    state2.composePollTimer = null;
+var cachedBlank = "";
+var cachedBlankWidth = 0;
+function createFrameBuffer(width, height) {
+  if (width !== cachedBlankWidth) {
+    cachedBlank = " ".repeat(width);
+    cachedBlankWidth = width;
   }
-  if (state2.composeTempFile) {
-    try {
-      unlinkSync(state2.composeTempFile);
-    } catch {
-    }
+  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];
   }
-  if (state2.composeSignalFile) {
-    try {
-      unlinkSync(state2.composeSignalFile);
-    } catch {
+}
+function flushFrame(frame, prevFrame2, suffix) {
+  let out = "\x1B[?2026h";
+  for (let i = 0; i < frame.length; i++) {
+    if (frame[i] !== prevFrame2[i]) {
+      out += `\x1B[${i + 1};1H`;
+      out += "\x1B[2K";
+      out += frame[i];
     }
   }
-  state2.prevNvimFile = null;
-  state2.composePrevNvimFile = null;
-  state2.composeAction = null;
-  state2.composeTempFile = null;
-  state2.composeSignalFile = null;
-  state2.mode = "navigate";
-  state2.focusPane = "tree";
-  deactivateNvimBypass();
-  requestRender();
+  if (suffix) out += suffix;
+  out += "\x1B[?2026l";
+  return out;
 }
-function checkComposeSignal(state2, actions) {
-  if (!state2.composeSignalFile || !state2.composeAction) return;
-  if (!state2.nvimBridge?.ready) {
-    cancelCompose(state2);
-    return;
+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 (!existsSync(state2.composeSignalFile)) return;
-  let signalContent = "";
-  try {
-    signalContent = readFileSync(state2.composeSignalFile, "utf-8").trim();
-  } catch {
+  if (out.includes("\x1B[") && !out.endsWith("\x1B[0m")) {
+    out += "\x1B[0m";
   }
-  if (signalContent === "cancel") {
-    cancelCompose(state2);
-    return;
+  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;
   }
-  let content = "";
-  if (state2.composeTempFile) {
-    try {
-      content = readFileSync(state2.composeTempFile, "utf-8").trim();
-    } catch {
+  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;
     }
   }
-  const action = state2.composeAction;
-  const required = !OPTIONAL_COMPOSE.has(action.kind);
-  if (required && !content) {
-    try {
-      unlinkSync(state2.composeSignalFile);
-    } catch {
+  if (j < len) {
+    const c = s.charCodeAt(j);
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+      return j + 1 - i;
     }
-    notify(state2, "Content required");
-    return;
   }
-  dispatchComposeAction(action, content, state2, actions);
-  cancelCompose(state2);
+  return 0;
 }
-function dispatchComposeAction(action, content, state2, actions) {
-  switch (action.kind) {
-    case "new-session":
-      actions.sendAndNotify(
-        { type: "start", task: content, cwd: state2.cwd },
-        "Session created"
-      );
-      break;
-    case "message-orchestrator":
-      actions.sendAndNotify(
-        { type: "message", sessionId: action.sessionId, content },
-        "Message queued"
-      );
-      break;
-    case "resume":
-      actions.sendAndNotify(
-        { type: "resume", sessionId: action.sessionId, cwd: state2.cwd, message: content || void 0 },
-        "Session resumed"
-      );
-      break;
-    case "continue":
-      void (async () => {
-        try {
-          const contRes = await actions.send({ type: "continue", sessionId: action.sessionId });
-          if (!contRes.ok) {
-            notify(state2, `Error: ${contRes.error}`);
-            return;
-          }
-          actions.sendAndNotify(
-            { type: "resume", sessionId: action.sessionId, cwd: state2.cwd, message: content || void 0 },
-            "Session continued"
-          );
-        } catch (err) {
-          notify(state2, `Error: ${err.message}`);
-        }
-      })();
-      break;
-    case "spawn-agent":
-      actions.sendAndNotify(
-        {
-          type: "spawn",
-          sessionId: action.sessionId,
-          agentType: "default",
-          name: "agent",
-          instruction: content
-        },
-        "Agent spawned"
-      );
-      break;
-    case "message-agent":
-      actions.sendAndNotify(
-        { type: "message", sessionId: action.sessionId, content, source: { type: "agent", agentId: action.agentId } },
-        `Message sent to ${action.agentId}`
-      );
-      break;
+function writeAt(buf, x, y, content) {
+  if (y < 0 || y >= buf.height) return;
+  if (x < 0 || x >= buf.width) return;
+  const existing = buf.lines[y];
+  const contentDisplayWidth = stringWidth2(content.replace(ANSI_RE, ""));
+  const prefix = sliceDisplayCols(existing, 0, x);
+  const suffix = sliceDisplayCols(existing, x + contentDisplayWidth, buf.width, true);
+  const prefixWidth = stringWidth2(prefix.replace(ANSI_RE, ""));
+  const paddedPrefix = prefix + " ".repeat(Math.max(0, x - prefixWidth));
+  buf.lines[y] = paddedPrefix + content + suffix;
+}
+function writeClipped(buf, x, y, content, maxWidth) {
+  if (y < 0 || y >= buf.height) return;
+  if (x < 0 || x >= buf.width) return;
+  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);
+  }
+  const existing = buf.lines[y];
+  const prefix = sliceDisplayCols(existing, 0, x);
+  const suffix = sliceDisplayCols(existing, x + maxWidth, buf.width, true);
+  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, ""));
+  const x = Math.max(0, Math.floor((buf.width - textWidth) / 2));
+  writeAt(buf, x, row, content);
+}
+function drawBorder(buf, x, y, w, h, color) {
+  const sgr = `\x1B[${colorToSGR(color)}m`;
+  const reset = "\x1B[0m";
+  writeAt(buf, x, y, sgr + "\u256D" + "\u2500".repeat(w - 2) + "\u256E" + reset);
+  writeAt(buf, x, y + h - 1, sgr + "\u2570" + "\u2500".repeat(w - 2) + "\u256F" + reset);
+  for (let row = y + 1; row < y + h - 1; row++) {
+    writeAt(buf, x, row, sgr + "\u2502" + reset);
+    writeAt(buf, x + w - 1, row, sgr + "\u2502" + reset);
+  }
+}
+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 innerH = h - 2;
+  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);
+  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`;
+    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, restoreState = false) {
+  let out = "";
+  let col = 0;
+  let i = 0;
+  let inSlice = false;
+  let hasOpenSGR = false;
+  let pendingSGR = "";
+  while (i < s.length && col < end) {
+    if (s[i] === "\x1B" && s[i + 1] === "[") {
+      const seqLen = ansiLen(s, i);
+      if (seqLen > 0) {
+        const seq = s.substring(i, i + seqLen);
+        if (col >= start) {
+          out += seq;
+          hasOpenSGR = seq !== "\x1B[0m" && seq !== "\x1B[m";
+        } else if (restoreState) {
+          if (seq === "\x1B[0m" || seq === "\x1B[m") {
+            pendingSGR = "";
+          } else {
+            pendingSGR += seq;
+          }
+        }
+        i += seqLen;
+        continue;
+      }
+    }
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const chWidth = cp < 128 ? 1 : stringWidth2(ch);
+    if (col >= start) {
+      inSlice = true;
+      if (col + chWidth > end) break;
+      out += ch;
+    }
+    col += chWidth;
+    i += ch.length;
+  }
+  if (inSlice && hasOpenSGR) {
+    out += "\x1B[0m";
+  }
+  if (restoreState && pendingSGR) {
+    out = pendingSGR + out;
+  }
+  return out;
+}
+
+// src/tui/panels/overlays.ts
+var LEADER_WIDTH = 26;
+var LEADER_HEIGHT = 20;
+var COPY_HEIGHT = 9;
+var HELP_WIDTH = 62;
+var COMPANION_WIDTH = 52;
+var DEBUG_WIDTH = 50;
+function helpRow(left, right, innerWidth) {
+  const col = Math.floor(innerWidth / 2);
+  return (left.padEnd(col) + right).padEnd(innerWidth);
+}
+function renderLeaderOverlay(buf, rows, cols) {
+  const x = cols - LEADER_WIDTH - 1;
+  const y = rows - LEADER_HEIGHT - 2;
+  const innerWidth = LEADER_WIDTH - 2;
+  drawBorder(buf, x, y, LEADER_WIDTH, LEADER_HEIGHT, "magenta");
+  const lines = [
+    ansiColor("  LEADER".padEnd(innerWidth), "magenta", true),
+    " ".padEnd(innerWidth),
+    "  y  copy menu".padEnd(innerWidth),
+    "  d  delete session".padEnd(innerWidth),
+    "  l  daemon logs".padEnd(innerWidth),
+    "  o  open session dir".padEnd(innerWidth),
+    "  a  spawn agent".padEnd(innerWidth),
+    "  m  message agent".padEnd(innerWidth),
+    "  /  search".padEnd(innerWidth),
+    "  !  shell command".padEnd(innerWidth),
+    "  j  jump to pane".padEnd(innerWidth),
+    "  k  kill session/agent".padEnd(innerWidth),
+    "  c  companion overlay".padEnd(innerWidth),
+    "  q  quit".padEnd(innerWidth),
+    "  ?  help".padEnd(innerWidth),
+    " 1-9  jump to session".padEnd(innerWidth),
+    " ".padEnd(innerWidth),
+    ansiDim("  esc  dismiss".padEnd(innerWidth))
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    writeClipped(buf, x + 1, y + 1 + i, lines[i], innerWidth);
+  }
+}
+function renderCopyMenuOverlay(buf, rows, cols) {
+  const x = cols - LEADER_WIDTH - 1;
+  const y = rows - COPY_HEIGHT - 2;
+  const innerWidth = LEADER_WIDTH - 2;
+  drawBorder(buf, x, y, LEADER_WIDTH, COPY_HEIGHT, "cyan");
+  const lines = [
+    ansiColor("  COPY".padEnd(innerWidth), "cyan", true),
+    " ".padEnd(innerWidth),
+    "  p  session path".padEnd(innerWidth),
+    "  C  LLM context".padEnd(innerWidth),
+    "  l  logs content".padEnd(innerWidth),
+    "  s  session ID".padEnd(innerWidth),
+    ansiDim("  esc  cancel".padEnd(innerWidth))
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    writeClipped(buf, x + 1, y + 1 + i, lines[i], innerWidth);
+  }
+}
+function renderHelpOverlay(buf, rows, cols) {
+  const innerWidth = HELP_WIDTH - 2;
+  const x = Math.max(0, Math.floor((cols - HELP_WIDTH) / 2));
+  const contentLines = [
+    helpRow("  hjkl/\u2191\u2193\u2190\u2192  navigate", "  tab  switch pane", innerWidth),
+    helpRow("  enter  expand/open", "  t  toggle logs", innerWidth),
+    " ".padEnd(innerWidth),
+    helpRow("  n  new session", "  m  message orch.", innerWidth),
+    helpRow("  R  resume session", "  C  continue session", innerWidth),
+    helpRow("  b  rollback cycle", "  x  restart agent", innerWidth),
+    helpRow("  r  re-run agent", "  g  edit goal", innerWidth),
+    helpRow("  p  open roadmap", "  s  toggle strategy", innerWidth),
+    helpRow("  S  edit strategy", "  w  go to window", innerWidth),
+    helpRow("  o  resume claude session", "  c  claude companion", innerWidth),
+    helpRow("  q  quit", "", innerWidth),
+    " ".padEnd(innerWidth),
+    helpRow("  space \u2192 y  copy submenu", "  space \u2192 d  delete session", innerWidth),
+    helpRow("  space \u2192 j  jump to pane", "  space \u2192 k  kill", innerWidth),
+    helpRow("  space \u2192 q  quit", "  space \u2192 o  open dir", innerWidth),
+    helpRow("  space \u2192 l  tail logs", "  space \u2192 /  search", innerWidth),
+    helpRow("  space \u2192 a  spawn agent", "  space \u2192 m  msg agent", innerWidth),
+    helpRow("  space \u2192 ?  help", "  space \u2192 1-9  jump", innerWidth),
+    " ".padEnd(innerWidth),
+    helpRow("  y \u2192 p  session path", "  y \u2192 C  LLM context", innerWidth),
+    helpRow("  y \u2192 l  logs content", "  y \u2192 s  session ID", innerWidth)
+  ];
+  const height = Math.min(contentLines.length + 4, rows - 2);
+  const y = Math.max(0, Math.floor((rows - height) / 2));
+  drawBorder(buf, x, y, HELP_WIDTH, height, "yellow");
+  writeClipped(buf, x + 1, y + 1, ansiColor("  KEYBINDINGS  (esc or ? to close)".padEnd(innerWidth), "yellow", true), innerWidth);
+  writeClipped(buf, x + 1, y + 2, " ".padEnd(innerWidth), innerWidth);
+  const availableContentRows = height - 4;
+  for (let i = 0; i < Math.min(contentLines.length, availableContentRows); i++) {
+    writeClipped(buf, x + 1, y + 3 + i, contentLines[i], innerWidth);
+  }
+  const trailingBlankRow = y + 3 + Math.min(contentLines.length, availableContentRows);
+  if (trailingBlankRow < y + height - 1) {
+    writeClipped(buf, x + 1, trailingBlankRow, " ".padEnd(innerWidth), innerWidth);
+  }
+}
+var _page = "profile";
+var _prevPage = "profile";
+var _gallery = null;
+function companionOverlayNextPage() {
+  if (_page === "help") {
+    _page = _prevPage;
+    return;
   }
+  _page = _page === "profile" ? "badges" : "profile";
+}
+function companionOverlayShowHelp() {
+  if (_page !== "help") _prevPage = _page;
+  _page = "help";
+}
+function companionOverlayDismissHelp() {
+  _page = _prevPage;
+}
+function badgeGalleryLeft() {
+  if (_gallery) _gallery.currentIndex = galleryPrev(_gallery);
+}
+function badgeGalleryRight() {
+  if (_gallery) _gallery.currentIndex = galleryNext(_gallery);
+}
+function closeBadgeGallery() {
+  _page = "profile";
+  _gallery = null;
+  _badgeScroll = 0;
+}
+function getCompanionPage() {
+  return _page;
+}
+var MOOD_ICONS = {
+  happy: "\u25C9",
+  grinding: "\u25C8",
+  frustrated: "\u25C6",
+  zen: "\u25CE",
+  sleepy: "\u25CC",
+  excited: "\u2726",
+  existential: "\u25C9"
+};
+var MOOD_COLORS = {
+  happy: "green",
+  grinding: "yellow",
+  frustrated: "red",
+  zen: "cyan",
+  sleepy: "gray",
+  excited: "white",
+  existential: "magenta"
+};
+function statBar(value, max, width, color) {
+  const filled = max > 0 ? Math.min(width, Math.round(value / max * width)) : 0;
+  const bar = ansiColor("\u2593".repeat(filled), color) + ansiDim("\u2591".repeat(width - filled));
+  return bar;
+}
+function wrapText2(text, maxWidth) {
+  const words = text.split(" ");
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (current.length + word.length + 1 > maxWidth && current.length > 0) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = current.length > 0 ? `${current} ${word}` : word;
+    }
+  }
+  if (current.length > 0) lines.push(current);
+  return lines;
+}
+function renderProfilePage(buf, rows, cols, companion) {
+  const innerWidth = COMPANION_WIDTH - 2;
+  const x = Math.max(0, Math.floor((cols - COMPANION_WIDTH) / 2));
+  const unlockedCount = companion.achievements.length;
+  const totalAchievements = ACHIEVEMENTS.length;
+  const endH = Math.floor(companion.stats.endurance / 36e5);
+  const face = getMoodFace(companion.mood);
+  const moodColor = MOOD_COLORS[companion.mood];
+  const moodIcon = MOOD_ICONS[companion.mood];
+  const faceColored = ansiColor(`(${face})`, moodColor, true);
+  const repoNicknames = Object.values(companion.repos).map((r) => r.nickname).filter((n) => n !== null);
+  const repoDisplay = repoNicknames.length > 0 ? ansiDim(` "${repoNicknames[0]}"`) : "";
+  const barW = 18;
+  const xpInLevel = companion.xp % 50;
+  const xpBar = statBar(xpInLevel, 50, 20, "cyan");
+  const lastAchievement = companion.achievements.length > 0 ? companion.achievements[companion.achievements.length - 1] : null;
+  const lastDef = lastAchievement ? ACHIEVEMENTS.find((a) => a.id === lastAchievement.id) : null;
+  const contentLines = [];
+  contentLines.push(`  ${faceColored} .${repoDisplay}`.padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(`  ${ansiColor(`Lv ${companion.level}`, "cyan", true)}  ${ansiBold(companion.title)}`.padEnd(innerWidth));
+  contentLines.push(`  ${xpBar}  ${ansiDim(`${companion.xp} xp`)}`.padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(`  ${ansiColor(moodIcon, moodColor)} ${ansiColor(companion.mood, moodColor)}`.padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(`  ${ansiColor("STR", "red")} ${String(companion.stats.strength).padStart(4)}  ${statBar(companion.stats.strength, 100, barW, "red")}`.padEnd(innerWidth));
+  contentLines.push(`  ${ansiColor("END", "yellow")} ${String(endH + "h").padStart(4)}  ${statBar(endH, 500, barW, "yellow")}`.padEnd(innerWidth));
+  contentLines.push(`  ${ansiColor("WIS", "blue")} ${String(companion.stats.wisdom).padStart(4)}  ${statBar(companion.stats.wisdom, 50, barW, "blue")}`.padEnd(innerWidth));
+  contentLines.push(`  ${ansiColor("PAT", "magenta")} ${String(companion.stats.patience).padStart(4)}  ${statBar(companion.stats.patience, 200, barW, "magenta")}`.padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  if (lastDef) {
+    contentLines.push(`  ${ansiColor("\u2605", "yellow")} ${lastDef.name}  ${ansiDim(`${unlockedCount}/${totalAchievements}`)}`.padEnd(innerWidth));
+  } else {
+    contentLines.push(`  ${ansiDim(`\u25C7 ${unlockedCount}/${totalAchievements} achievements`)}`.padEnd(innerWidth));
+  }
+  contentLines.push(" ".padEnd(innerWidth));
+  if (companion.lastCommentary) {
+    const raw = companion.lastCommentary.text;
+    const wrapped = wrapText2(raw, innerWidth - 6);
+    contentLines.push(`  ${ansiDim("\u250A")} ${ansiColor(wrapped[0] ?? "", "white")}`.padEnd(innerWidth));
+    for (let i = 1; i < wrapped.length; i++) {
+      contentLines.push(`  ${ansiDim("\u250A")} ${ansiColor(wrapped[i] ?? "", "white")}`.padEnd(innerWidth));
+    }
+  }
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(`  ${ansiDim("tab \u2192 badges  ? \u2192 stat guide")}`.padEnd(innerWidth));
+  const height = Math.min(contentLines.length + 4, rows - 2);
+  const y = Math.max(0, Math.floor((rows - height) / 2));
+  drawBorder(buf, x, y, COMPANION_WIDTH, height, "cyan");
+  writeClipped(buf, x + 1, y + 1, ansiColor("  COMPANION  (esc to close)".padEnd(innerWidth), "cyan", true), innerWidth);
+  writeClipped(buf, x + 1, y + 2, " ".padEnd(innerWidth), innerWidth);
+  const availableContentRows = height - 4;
+  for (let i = 0; i < Math.min(contentLines.length, availableContentRows); i++) {
+    writeClipped(buf, x + 1, y + 3 + i, contentLines[i], innerWidth);
+  }
+}
+var GALLERY_WIDTH = 50;
+var _badgeScroll = 0;
+function badgeListScrollUp() {
+  _badgeScroll = Math.max(0, _badgeScroll - 1);
+}
+function badgeListScrollDown() {
+  _badgeScroll++;
+}
+function renderBadgesPage(buf, rows, cols, companion) {
+  if (!_gallery) _gallery = createBadgeGallery(companion.achievements);
+  const gallery = _gallery;
+  const innerWidth = GALLERY_WIDTH - 2;
+  const x = Math.max(0, Math.floor((cols - GALLERY_WIDTH) / 2));
+  const unlockedCount = companion.achievements.length;
+  const totalAchievements = ACHIEVEMENTS.length;
+  const currentDef = gallery.achievements[gallery.currentIndex];
+  const currentUnlock = gallery.unlocked.get(currentDef.id) ?? null;
+  const card = renderBadgeCard(currentDef, currentUnlock);
+  const contentLines = [];
+  for (const cardLine of card.lines) {
+    const stripped = cardLine.replace(/\x1b\[[0-9;]*m/g, "");
+    const pad = Math.max(0, Math.floor((innerWidth - stripped.length) / 2));
+    const padded = " ".repeat(pad) + cardLine + " ".repeat(Math.max(0, innerWidth - stripped.length - pad));
+    contentLines.push(padded);
+  }
+  contentLines.push(" ".padEnd(innerWidth));
+  const navIdx = gallery.currentIndex + 1;
+  const navTotal = gallery.total;
+  const unlockLabel = currentUnlock !== null ? "  \u2713 unlocked" : "  \xB7 locked";
+  const navLine = `  \u2190 ${navIdx}/${navTotal} \u2192   ${unlockedCount}/${totalAchievements} earned${unlockLabel}`;
+  contentLines.push(navLine.padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  const listStartIdx = contentLines.length;
+  const maxListRows = Math.min(6, Math.max(4, rows - 2 - 4 - listStartIdx - 2));
+  const maxScroll = Math.max(0, gallery.total - maxListRows + 1);
+  if (_badgeScroll > maxScroll) _badgeScroll = maxScroll;
+  if (gallery.currentIndex < _badgeScroll) _badgeScroll = gallery.currentIndex;
+  for (let pass = 0; pass < 3; pass++) {
+    const a = _badgeScroll > 0 ? 1 : 0;
+    const b = _badgeScroll + maxListRows < gallery.total ? 1 : 0;
+    const vis = maxListRows - a - b;
+    if (gallery.currentIndex >= _badgeScroll + vis) {
+      _badgeScroll = gallery.currentIndex - vis + 1;
+    } else break;
+  }
+  if (_badgeScroll > maxScroll) _badgeScroll = maxScroll;
+  const hasMoreAbove = _badgeScroll > 0;
+  const hasMoreBelow = _badgeScroll + maxListRows < gallery.total;
+  const itemRows = maxListRows - (hasMoreAbove ? 1 : 0) - (hasMoreBelow ? 1 : 0);
+  if (hasMoreAbove) {
+    contentLines.push(ansiDim(`  \u2191 ${_badgeScroll} more`.padEnd(innerWidth)));
+  }
+  for (let i = 0; i < itemRows && _badgeScroll + i < gallery.total; i++) {
+    const idx = _badgeScroll + i;
+    const def = gallery.achievements[idx];
+    const u = gallery.unlocked.has(def.id);
+    const icon = u ? "\u2713" : "\xB7";
+    const isCurrent = idx === gallery.currentIndex;
+    let line = `  ${icon} ${def.name}`.padEnd(innerWidth);
+    if (isCurrent) line = ansiColor(line, "cyan", false);
+    else if (!u) line = ansiDim(line);
+    contentLines.push(line);
+  }
+  if (hasMoreBelow) {
+    const below = gallery.total - _badgeScroll - itemRows;
+    contentLines.push(ansiDim(`  \u2193 ${below} more`.padEnd(innerWidth)));
+  }
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(ansiDim("  tab \u2192 profile  ? \u2192 stat guide".padEnd(innerWidth)));
+  const height = Math.min(contentLines.length + 4, rows - 2);
+  const y = Math.max(0, Math.floor((rows - height) / 2));
+  drawBorder(buf, x, y, GALLERY_WIDTH, height, "cyan");
+  writeClipped(buf, x + 1, y + 1, ansiColor("  BADGES  (\u2191\u2193 navigate, esc close)".padEnd(innerWidth), "cyan", true), innerWidth);
+  writeClipped(buf, x + 1, y + 2, " ".padEnd(innerWidth), innerWidth);
+  const availableContentRows = height - 4;
+  for (let i = 0; i < Math.min(contentLines.length, availableContentRows); i++) {
+    writeClipped(buf, x + 1, y + 3 + i, contentLines[i], innerWidth);
+  }
+}
+function renderHelpPage(buf, rows, cols) {
+  const innerWidth = COMPANION_WIDTH - 2;
+  const x = Math.max(0, Math.floor((cols - COMPANION_WIDTH) / 2));
+  const divider2 = (label, color) => {
+    const rest = innerWidth - label.length - 5;
+    return `  ${ansiColor(label, color, true)} ${ansiDim("\u2500".repeat(Math.max(0, rest)))}`;
+  };
+  const contentLines = [];
+  contentLines.push(divider2("STR (Strength)", "red"));
+  contentLines.push("  +1 per completed session".padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(divider2("END (Endurance)", "yellow"));
+  contentLines.push("  Total active time across sessions".padEnd(innerWidth));
+  contentLines.push("  (displayed in hours)".padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(divider2("WIS (Wisdom)", "blue"));
+  contentLines.push("  +1 per efficient session".padEnd(innerWidth));
+  contentLines.push(ansiDim("  agents have <30% stddev in active").padEnd(innerWidth));
+  contentLines.push(ansiDim("  time, 2+ agents required").padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(divider2("PAT (Patience)", "magenta"));
+  contentLines.push("  +cycles per completed session".padEnd(innerWidth));
+  contentLines.push(ansiDim("  +3 if validation mode").padEnd(innerWidth));
+  contentLines.push(ansiDim("  +2 if completion mode").padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(divider2("XP & Level", "cyan"));
+  contentLines.push("  STR\xD780 + END/h\xD715 + WIS\xD740".padEnd(innerWidth));
+  contentLines.push("  + PAT\xD75".padEnd(innerWidth));
+  contentLines.push(ansiDim("  level: 150 base xp, \xD71.35/lvl").padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(divider2("Mood", "white"));
+  contentLines.push("  Real-time scoring from signals:".padEnd(innerWidth));
+  contentLines.push(ansiDim("  time of day, idle time, crashes,").padEnd(innerWidth));
+  contentLines.push(ansiDim("  streaks, session length, agents").padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(divider2("Badges", "yellow"));
+  contentLines.push("  Milestones, session feats, time".padEnd(innerWidth));
+  contentLines.push("  patterns, and behavioral checks".padEnd(innerWidth));
+  contentLines.push(" ".padEnd(innerWidth));
+  contentLines.push(ansiDim("  tab \u2192 back  ? \u2192 close".padEnd(innerWidth)));
+  const height = Math.min(contentLines.length + 4, rows - 2);
+  const y = Math.max(0, Math.floor((rows - height) / 2));
+  drawBorder(buf, x, y, COMPANION_WIDTH, height, "cyan");
+  writeClipped(buf, x + 1, y + 1, ansiColor("  STAT GUIDE  (? or esc to close)".padEnd(innerWidth), "cyan", true), innerWidth);
+  writeClipped(buf, x + 1, y + 2, " ".padEnd(innerWidth), innerWidth);
+  const availableContentRows = height - 4;
+  for (let i = 0; i < Math.min(contentLines.length, availableContentRows); i++) {
+    writeClipped(buf, x + 1, y + 3 + i, contentLines[i], innerWidth);
+  }
+  const trailingBlankRow = y + 3 + Math.min(contentLines.length, availableContentRows);
+  if (trailingBlankRow < y + height - 1) {
+    writeClipped(buf, x + 1, trailingBlankRow, " ".padEnd(innerWidth), innerWidth);
+  }
+}
+function renderCompanionOverlay(buf, rows, cols, companion) {
+  if (_page === "help") {
+    renderHelpPage(buf, rows, cols);
+  } else if (_page === "badges") {
+    renderBadgesPage(buf, rows, cols, companion);
+  } else {
+    renderProfilePage(buf, rows, cols, companion);
+  }
+}
+function renderCompanionDebugOverlay(buf, rows, cols, companion) {
+  const innerWidth = DEBUG_WIDTH - 2;
+  const x = Math.max(0, Math.floor((cols - DEBUG_WIDTH) / 2));
+  const face = getMoodFace(companion.mood);
+  const debug = companion.debugMood;
+  const contentLines = [
+    `  (${face})  mood: ${companion.mood}`.padEnd(innerWidth),
+    " ".padEnd(innerWidth)
+  ];
+  if (debug) {
+    const { signals, scores } = debug;
+    contentLines.push(ansiDim("  \u2500\u2500 Signals \u2500\u2500".padEnd(innerWidth)));
+    contentLines.push(`  hourOfDay: ${signals.hourOfDay}`.padEnd(innerWidth));
+    contentLines.push(`  sessionLengthMs: ${signals.sessionLengthMs}  (${Math.round(signals.sessionLengthMs / 6e4)}min)`.padEnd(innerWidth));
+    contentLines.push(`  idleDurationMs: ${signals.idleDurationMs}  (${Math.round(signals.idleDurationMs / 6e4)}min)`.padEnd(innerWidth));
+    contentLines.push(`  recentCrashes: ${signals.recentCrashes}`.padEnd(innerWidth));
+    contentLines.push(`  cleanStreak: ${signals.cleanStreak}`.padEnd(innerWidth));
+    contentLines.push(`  justCompleted: ${signals.justCompleted}`.padEnd(innerWidth));
+    contentLines.push(`  justCrashed: ${signals.justCrashed}`.padEnd(innerWidth));
+    contentLines.push(`  justLeveledUp: ${signals.justLeveledUp}`.padEnd(innerWidth));
+    contentLines.push(" ".padEnd(innerWidth));
+    contentLines.push(ansiDim("  \u2500\u2500 Scores \u2500\u2500".padEnd(innerWidth)));
+    const moodOrder = ["happy", "grinding", "frustrated", "zen", "sleepy", "excited", "existential"];
+    for (const mood of moodOrder) {
+      const score = scores[mood] ?? 0;
+      const bar = score > 0 ? ansiDim("\u2588".repeat(Math.min(Math.round(score / 5), 12))) : "";
+      const marker = mood === debug.winner ? " \u25C0" : "";
+      contentLines.push(`  ${mood.padEnd(12)} ${String(score).padStart(3)} ${bar}${marker}`.padEnd(innerWidth));
+    }
+  } else {
+    contentLines.push(ansiDim("  No mood signals yet".padEnd(innerWidth)));
+    contentLines.push(ansiDim("  (mood is time-of-day only)".padEnd(innerWidth)));
+  }
+  contentLines.push(" ".padEnd(innerWidth));
+  const height = Math.min(contentLines.length + 4, rows - 2);
+  const y = Math.max(0, Math.floor((rows - height) / 2));
+  drawBorder(buf, x, y, DEBUG_WIDTH, height, "yellow");
+  writeClipped(buf, x + 1, y + 1, ansiColor("  COMPANION DEBUG  (esc to close)".padEnd(innerWidth), "yellow", true), innerWidth);
+  writeClipped(buf, x + 1, y + 2, " ".padEnd(innerWidth), innerWidth);
+  const availableContentRows = height - 4;
+  for (let i = 0; i < Math.min(contentLines.length, availableContentRows); i++) {
+    writeClipped(buf, x + 1, y + 3 + i, contentLines[i], innerWidth);
+  }
+  const trailingRow = y + 3 + Math.min(contentLines.length, availableContentRows);
+  if (trailingRow < y + height - 1) {
+    writeClipped(buf, x + 1, trailingRow, " ".padEnd(innerWidth), innerWidth);
+  }
+}
+
+// src/tui/input.ts
+function activateNvimBypass(state2) {
+  setRawBypass((data) => {
+    if (!state2.nvimBridge?.ready) {
+      deactivateNvimBypass();
+      state2.focusPane = "tree";
+      if (state2.mode === "compose") cancelCompose(state2);
+      requestRender();
+      return false;
+    }
+    if (data === "	") {
+      if (state2.mode === "compose") {
+        cancelCompose(state2);
+        return true;
+      }
+      deactivateNvimBypass();
+      state2.focusPane = state2.showCombinedView ? "logs" : "tree";
+      requestRender();
+      return true;
+    }
+    state2.nvimBridge.write(data);
+    return true;
+  });
+}
+function deactivateNvimBypass() {
+  setRawBypass(null);
+}
+var COMPOSE_DIR = join2(tmpdir(), "sisyphus-nvim");
+function enterComposeMode(state2, action, actions) {
+  if (!state2.nvimEnabled || !state2.nvimBridge?.ready) return false;
+  mkdirSync(COMPOSE_DIR, { recursive: true });
+  const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const tempFile = join2(COMPOSE_DIR, `compose-${id}.md`);
+  const signalFile = join2(COMPOSE_DIR, `compose-signal-${id}`);
+  writeFileSync(tempFile, "", "utf-8");
+  state2.composePrevNvimFile = state2.prevNvimFile;
+  state2.composeAction = action;
+  state2.composeTempFile = tempFile;
+  state2.composeSignalFile = signalFile;
+  state2.mode = "compose";
+  state2.focusPane = "detail";
+  state2.nvimBridge.openComposeFile(tempFile, signalFile);
+  activateNvimBypass(state2);
+  state2.composePollTimer = setInterval(() => {
+    checkComposeSignal(state2, actions);
+  }, 100);
+  requestRender();
+  return true;
 }
-function handleCancel(state2) {
+function cancelCompose(state2) {
+  if (state2.composePollTimer !== null) {
+    clearInterval(state2.composePollTimer);
+    state2.composePollTimer = null;
+  }
+  if (state2.composeTempFile) {
+    try {
+      unlinkSync(state2.composeTempFile);
+    } catch {
+    }
+  }
+  if (state2.composeSignalFile) {
+    try {
+      unlinkSync(state2.composeSignalFile);
+    } catch {
+    }
+  }
+  state2.prevNvimFile = null;
+  state2.composePrevNvimFile = null;
+  state2.composeAction = null;
+  state2.composeTempFile = null;
+  state2.composeSignalFile = null;
   state2.mode = "navigate";
-  state2.targetAgentId = null;
-  state2.inputText = "";
-  state2.inputCursorPos = 0;
+  state2.focusPane = "tree";
+  deactivateNvimBypass();
   requestRender();
 }
-function expandSessionLatestCycle(state2, node) {
-  if (node.type === "session" && state2.selectedSession?.id === node.sessionId) {
-    const cycles = state2.selectedSession.orchestratorCycles;
-    if (cycles.length > 0) {
-      const latest = cycles[cycles.length - 1];
-      state2.expanded.add(`cycle:${node.sessionId}:${latest.cycle}`);
+function checkComposeSignal(state2, actions) {
+  if (!state2.composeSignalFile || !state2.composeAction) return;
+  if (!state2.nvimBridge?.ready) {
+    cancelCompose(state2);
+    return;
+  }
+  if (!existsSync(state2.composeSignalFile)) return;
+  let signalContent = "";
+  try {
+    signalContent = readFileSync(state2.composeSignalFile, "utf-8").trim();
+  } catch {
+  }
+  if (signalContent === "cancel") {
+    cancelCompose(state2);
+    return;
+  }
+  let content = "";
+  if (state2.composeTempFile) {
+    try {
+      content = readFileSync(state2.composeTempFile, "utf-8").trim();
+    } catch {
+    }
+  }
+  const action = state2.composeAction;
+  const required = !OPTIONAL_COMPOSE.has(action.kind);
+  if (required && !content) {
+    try {
+      unlinkSync(state2.composeSignalFile);
+    } catch {
     }
+    notify(state2, "Content required");
+    return;
   }
+  dispatchComposeAction(action, content, state2, actions);
+  cancelCompose(state2);
 }
-async function handleSubmit(text, state2, actions) {
-  const selectedSessionId = state2.selectedSessionId;
-  switch (state2.mode) {
-    case "resume": {
-      if (!selectedSessionId) break;
+function dispatchComposeAction(action, content, state2, actions) {
+  switch (action.kind) {
+    case "new-session":
       actions.sendAndNotify(
-        { type: "resume", sessionId: selectedSessionId, cwd: state2.cwd, message: text || void 0 },
-        "Session resumed"
+        { type: "start", task: content, cwd: state2.cwd },
+        "Session created"
       );
       break;
-    }
-    case "continue": {
-      if (!selectedSessionId) break;
-      try {
-        const contRes = await actions.send({ type: "continue", sessionId: selectedSessionId });
-        if (!contRes.ok) {
-          notify(state2, `Error: ${contRes.error}`);
-          break;
-        }
-        actions.sendAndNotify(
-          { type: "resume", sessionId: selectedSessionId, cwd: state2.cwd, message: text || void 0 },
-          "Session continued"
-        );
-      } catch (err) {
-        notify(state2, `Error: ${err.message}`);
-      }
-      break;
-    }
-    case "rollback": {
-      if (!selectedSessionId) break;
-      const toCycle = parseInt(text, 10);
-      if (isNaN(toCycle) || toCycle < 1) {
-        notify(state2, "Invalid cycle number");
-        break;
-      }
+    case "message-orchestrator":
       actions.sendAndNotify(
-        { type: "rollback", sessionId: selectedSessionId, cwd: state2.cwd, toCycle },
-        `Rolled back to cycle ${toCycle} \u2014 use [R]esume to respawn`
+        { type: "message", sessionId: action.sessionId, content },
+        "Message queued"
       );
       break;
-    }
-    case "delete-confirm": {
-      if (!selectedSessionId) break;
-      if (text !== "yes") {
-        notify(state2, 'Delete cancelled (type "yes" to confirm)');
-        break;
-      }
+    case "resume":
       actions.sendAndNotify(
-        { type: "delete", sessionId: selectedSessionId, cwd: state2.cwd },
-        "Session deleted"
+        { type: "resume", sessionId: action.sessionId, cwd: state2.cwd, message: content || void 0 },
+        "Session resumed"
       );
       break;
-    }
-    case "spawn-agent": {
-      if (!selectedSessionId) break;
-      if (!text.trim()) {
-        notify(state2, "Instruction required");
-        break;
-      }
+    case "continue":
+      void (async () => {
+        try {
+          const contRes = await actions.send({ type: "continue", sessionId: action.sessionId });
+          if (!contRes.ok) {
+            notify(state2, `Error: ${contRes.error}`);
+            return;
+          }
+          actions.sendAndNotify(
+            { type: "resume", sessionId: action.sessionId, cwd: state2.cwd, message: content || void 0 },
+            "Session continued"
+          );
+        } catch (err) {
+          notify(state2, `Error: ${err.message}`);
+        }
+      })();
+      break;
+    case "spawn-agent":
       actions.sendAndNotify(
         {
           type: "spawn",
-          sessionId: selectedSessionId,
+          sessionId: action.sessionId,
           agentType: "default",
           name: "agent",
-          instruction: text
+          instruction: content
         },
         "Agent spawned"
       );
       break;
-    }
-    case "search": {
-      state2.searchFilter = text.trim() || null;
-      break;
-    }
-    case "message-agent": {
-      if (!selectedSessionId || !state2.targetAgentId) break;
+    case "message-agent":
       actions.sendAndNotify(
-        { type: "message", sessionId: selectedSessionId, content: text, source: { type: "agent", agentId: state2.targetAgentId } },
-        `Message sent to ${state2.targetAgentId}`
+        { type: "message", sessionId: action.sessionId, content, source: { type: "agent", agentId: action.agentId } },
+        `Message sent to ${action.agentId}`
       );
-      state2.targetAgentId = null;
-      break;
-    }
-    case "shell-command": {
-      if (!text.trim()) break;
-      try {
-        actions.openShellPopup(state2.cwd, text);
-      } catch {
-        notify(state2, "Failed to run shell command");
-      }
       break;
-    }
   }
-  state2.mode = "navigate";
-  state2.inputText = "";
-  state2.inputCursorPos = 0;
-  requestRender();
 }
-function handleInputBarKey(input, key, state2, actions) {
-  if (key.return) {
-    if (OPTIONAL_INPUT.has(state2.mode) || state2.inputText.trim()) {
-      void handleSubmit(state2.inputText.trim(), state2, actions);
-    }
-    return;
-  }
-  if (key.escape) {
-    handleCancel(state2);
-    return;
-  }
-  if (key.leftArrow) {
-    state2.inputCursorPos = Math.max(0, state2.inputCursorPos - 1);
-    requestRender();
-    return;
-  }
-  if (key.rightArrow) {
-    state2.inputCursorPos = Math.min(state2.inputText.length, state2.inputCursorPos + 1);
-    requestRender();
-    return;
-  }
-  if (key.ctrl && input === "a") {
-    state2.inputCursorPos = 0;
-    requestRender();
-    return;
-  }
-  if (key.ctrl && input === "e") {
-    state2.inputCursorPos = state2.inputText.length;
-    requestRender();
-    return;
-  }
-  if (key.ctrl && input === "k") {
-    state2.inputText = state2.inputText.slice(0, state2.inputCursorPos);
-    requestRender();
-    return;
-  }
-  if (key.ctrl && input === "u") {
-    state2.inputText = state2.inputText.slice(state2.inputCursorPos);
-    state2.inputCursorPos = 0;
-    requestRender();
-    return;
-  }
-  if (key.backspace) {
-    if (state2.inputCursorPos > 0) {
-      state2.inputText = state2.inputText.slice(0, state2.inputCursorPos - 1) + state2.inputText.slice(state2.inputCursorPos);
-      state2.inputCursorPos -= 1;
-      requestRender();
-    }
-    return;
-  }
-  if (key.delete) {
-    if (state2.inputCursorPos < state2.inputText.length) {
-      state2.inputText = state2.inputText.slice(0, state2.inputCursorPos) + state2.inputText.slice(state2.inputCursorPos + 1);
-      requestRender();
+function expandSessionLatestCycle(state2, node) {
+  if (node.type === "session" && state2.selectedSession?.id === node.sessionId) {
+    const cycles = state2.selectedSession.orchestratorCycles;
+    if (cycles.length > 0) {
+      const latest = cycles[cycles.length - 1];
+      state2.expanded.add(`cycle:${node.sessionId}:${latest.cycle}`);
     }
-    return;
-  }
-  if (input && !key.ctrl && !key.meta) {
-    state2.inputText = state2.inputText.slice(0, state2.inputCursorPos) + input + state2.inputText.slice(state2.inputCursorPos);
-    state2.inputCursorPos += input.length;
-    requestRender();
   }
 }
-function handleReportDetailKey(input, key, state2, actions) {
+function handleReportDetailKey(input, key, state2, _actions) {
   if (key.escape || key.return) {
-    handleCancel(state2);
+    state2.mode = "navigate";
+    requestRender();
     return;
   }
   if (key.upArrow) {
@@ -1253,9 +1795,18 @@ function handleLeaderAction(action, state2, actions) {
         notify(state2, "No session selected");
         break;
       }
-      state2.mode = "delete-confirm";
-      requestRender();
-      return;
+      const editor = actions.resolveEditor();
+      try {
+        const text = actions.editInPopup(state2.cwd, editor);
+        if (text?.trim() === "yes") {
+          actions.sendAndNotify({ type: "delete", sessionId: selectedSessionId, cwd: state2.cwd }, "Session deleted");
+        } else {
+          notify(state2, 'Delete cancelled (type "yes" to confirm)');
+        }
+      } catch {
+        notify(state2, "Failed to open editor");
+      }
+      break;
     }
     case "open-logs": {
       try {
@@ -1277,10 +1828,12 @@ function handleLeaderAction(action, state2, actions) {
       }
       break;
     }
-    case "search":
+    case "search": {
       state2.mode = "search";
+      state2.searchText = "";
       requestRender();
       return;
+    }
     case "jump-to-session": {
       let count = 0;
       for (let i = 0; i < nodes.length; i++) {
@@ -1301,9 +1854,21 @@ function handleLeaderAction(action, state2, actions) {
         break;
       }
       if (enterComposeMode(state2, { kind: "spawn-agent", sessionId: selectedSessionId }, actions)) return;
-      state2.mode = "spawn-agent";
-      requestRender();
-      return;
+      {
+        const editor = actions.resolveEditor();
+        try {
+          const content = actions.editInPopup(state2.cwd, editor);
+          if (content?.trim()) {
+            actions.sendAndNotify(
+              { type: "spawn", sessionId: selectedSessionId, agentType: "default", name: "agent", instruction: content },
+              "Agent spawned"
+            );
+          }
+        } catch {
+          notify(state2, "Failed to open editor");
+        }
+      }
+      break;
     }
     case "message-agent": {
       const agent = actions.getAgentForNode(cursorNode);
@@ -1312,23 +1877,49 @@ function handleLeaderAction(action, state2, actions) {
         break;
       }
       if (enterComposeMode(state2, { kind: "message-agent", sessionId: selectedSessionId, agentId: agent.id }, actions)) return;
-      state2.targetAgentId = agent.id;
-      state2.mode = "message-agent";
-      requestRender();
-      return;
+      {
+        const editor = actions.resolveEditor();
+        try {
+          const content = actions.editInPopup(state2.cwd, editor);
+          if (content?.trim()) {
+            actions.sendAndNotify(
+              { type: "message", sessionId: selectedSessionId, content, source: { type: "agent", agentId: agent.id } },
+              `Message sent to ${agent.id}`
+            );
+          }
+        } catch {
+          notify(state2, "Failed to open editor");
+        }
+      }
+      break;
     }
     case "help":
       state2.mode = "help";
       requestRender();
       return;
+    case "companion-overlay":
+      state2.mode = "companion-overlay";
+      requestRender();
+      return;
+    case "companion-debug":
+      state2.mode = "companion-debug";
+      requestRender();
+      return;
     case "shell-command": {
       if (!selectedSessionId) {
         notify(state2, "No session selected");
         break;
       }
-      state2.mode = "shell-command";
-      requestRender();
-      return;
+      const editor = actions.resolveEditor();
+      try {
+        const text = actions.editInPopup(state2.cwd, editor);
+        if (text?.trim()) {
+          actions.openShellPopup(state2.cwd, text.trim());
+        }
+      } catch {
+        notify(state2, "Failed to open editor");
+      }
+      break;
     }
     case "jump-to-pane": {
       const agent = actions.getAgentForNode(cursorNode);
@@ -1364,6 +1955,7 @@ function handleLeaderAction(action, state2, actions) {
       actions.cleanup();
       return;
     case "dismiss":
+      closeBadgeGallery();
       break;
   }
   state2.mode = "navigate";
@@ -1407,6 +1999,14 @@ function handleLeaderKey(input, key, state2, actions) {
       handleLeaderAction({ type: "help" }, state2, actions);
       return;
     }
+    if (input === "c") {
+      handleLeaderAction({ type: "companion-overlay" }, state2, actions);
+      return;
+    }
+    if (input === "D") {
+      handleLeaderAction({ type: "companion-debug" }, state2, actions);
+      return;
+    }
     if (input === "!") {
       handleLeaderAction({ type: "shell-command" }, state2, actions);
       return;
@@ -1461,6 +2061,54 @@ function handleLeaderKey(input, key, state2, actions) {
       return;
     }
   }
+  if (state2.mode === "companion-overlay") {
+    if (input === "?") {
+      if (getCompanionPage() === "help") companionOverlayDismissHelp();
+      else companionOverlayShowHelp();
+      requestRender();
+      return;
+    }
+    if (key.escape) {
+      if (getCompanionPage() === "help") {
+        companionOverlayDismissHelp();
+        requestRender();
+        return;
+      }
+      handleLeaderAction({ type: "dismiss" }, state2, actions);
+      return;
+    }
+    if (key.tab) {
+      companionOverlayNextPage();
+      requestRender();
+      return;
+    }
+    if (getCompanionPage() === "badges") {
+      if (key.upArrow || input === "k") {
+        badgeGalleryLeft();
+        requestRender();
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        badgeGalleryRight();
+        requestRender();
+        return;
+      }
+      if (key.leftArrow || input === "h") {
+        badgeListScrollUp();
+        requestRender();
+        return;
+      }
+      if (key.rightArrow || input === "l") {
+        badgeListScrollDown();
+        requestRender();
+        return;
+      }
+    }
+    return;
+  }
+  if (state2.mode === "companion-debug") {
+    handleLeaderAction({ type: "dismiss" }, state2, actions);
+  }
 }
 function handleNavigateKey(input, key, state2, actions) {
   const nodes = actions.getNodes();
@@ -1602,41 +2250,24 @@ function handleNavigateKey(input, key, state2, actions) {
       notify(state2, "No session selected");
       return;
     }
-    if (session.status === "completed") {
-      const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
-      const claudeSessionId = lastCycle?.claudeSessionId;
-      if (!claudeSessionId) {
-        notify(state2, "No orchestrator Claude session ID available");
-        return;
-      }
-      try {
-        const label = session.name ?? state2.selectedSessionId.slice(0, 8);
-        const sessionName = actions.openClaudeResumeSession(state2.cwd, claudeSessionId, label);
-        actions.switchToSession(sessionName);
-      } catch {
-        notify(state2, "Failed to open Claude session");
-      }
-      return;
-    }
-    if (state2.paneAlive && session.tmuxWindowId) {
+    if (session.status !== "completed" && state2.paneAlive && session.tmuxWindowId) {
       if (session.tmuxSessionName) actions.switchToSession(session.tmuxSessionName);
       actions.selectWindow(session.tmuxWindowId);
       return;
     }
-    void (async () => {
-      try {
-        const res = await actions.send({ type: "reopen-window", sessionId: state2.selectedSessionId, cwd: state2.cwd });
-        if (!res.ok) {
-          notify(state2, `Error: ${res.error}`);
-          return;
-        }
-        const data = res.data;
-        actions.switchToSession(data.tmuxSessionName);
-        actions.selectWindow(data.tmuxWindowId);
-      } catch (err) {
-        notify(state2, `Error: ${err.message}`);
-      }
-    })();
+    const lastCycle = session.orchestratorCycles[session.orchestratorCycles.length - 1];
+    const claudeSessionId = lastCycle?.claudeSessionId;
+    if (!claudeSessionId) {
+      notify(state2, "No orchestrator Claude session ID available");
+      return;
+    }
+    try {
+      const label = session.name ?? state2.selectedSessionId.slice(0, 8);
+      const sessionName = actions.openClaudeResumeSession(state2.cwd, claudeSessionId, label, lastCycle.resumeEnv, lastCycle.resumeArgs);
+      actions.switchToSession(sessionName);
+    } catch {
+      notify(state2, "Failed to open Claude session");
+    }
     return;
   }
   if (input === "o") {
@@ -1645,19 +2276,25 @@ function handleNavigateKey(input, key, state2, actions) {
       return;
     }
     let claudeSessionId;
+    let resumeEnv;
+    let resumeArgs;
     if (cursorNode.type === "agent" || cursorNode.type === "report") {
       const agent = actions.getAgentForNode(cursorNode);
       claudeSessionId = agent?.claudeSessionId ?? void 0;
+      resumeEnv = agent?.resumeEnv;
+      resumeArgs = agent?.resumeArgs;
     } else if (cursorNode.type === "cycle" && session) {
       const cycle = session.orchestratorCycles.find((c) => c.cycle === cursorNode.cycleNumber);
       claudeSessionId = cycle?.claudeSessionId;
+      resumeEnv = cycle?.resumeEnv;
+      resumeArgs = cycle?.resumeArgs;
     }
     if (!claudeSessionId) {
       notify(state2, "No Claude session ID available");
       return;
     }
     try {
-      actions.openClaudeResumePopup(state2.cwd, claudeSessionId);
+      actions.openClaudeResumePopup(state2.cwd, claudeSessionId, resumeEnv, resumeArgs);
     } catch {
       notify(state2, "Failed to open Claude session");
     }
@@ -1668,479 +2305,245 @@ function handleNavigateKey(input, key, state2, actions) {
       notify(state2, "No session selected");
       return;
     }
-    const gp = goalPath(state2.cwd, state2.selectedSessionId);
-    const editor = actions.resolveEditor();
-    try {
-      actions.openEditorPopup(state2.cwd, editor, gp, { w: "80", h: "50%" });
-    } catch {
-      notify(state2, `Failed to open goal in ${editor}`);
-    }
-    return;
-  }
-  if (input === "n") {
-    if (enterComposeMode(state2, { kind: "new-session" }, actions)) return;
-    const editor = actions.resolveEditor();
-    try {
-      const content = actions.editInPopup(state2.cwd, editor);
-      if (content) {
-        actions.sendAndNotify(
-          { type: "start", task: content, cwd: state2.cwd },
-          "Session created"
-        );
-      }
-    } catch {
-      notify(state2, "Failed to open editor");
-    }
-    return;
-  }
-  if (input === "c") {
-    try {
-      actions.openCompanionPane(state2.cwd);
-    } catch {
-      notify(state2, "Failed to open companion pane");
-    }
-    return;
-  }
-  if (input === "p") {
-    if (!state2.selectedSessionId) {
-      notify(state2, "No session selected");
-      return;
-    }
-    const pp = roadmapPath(state2.cwd, state2.selectedSessionId);
-    const editor = actions.resolveEditor();
-    try {
-      actions.openEditorPopup(state2.cwd, editor, pp);
-    } catch {
-      notify(state2, `Failed to open roadmap in ${editor}`);
-    }
-    return;
-  }
-  if (input === "q") {
-    actions.cleanup();
-  }
-  if (input === "r") {
-    const agent = actions.getAgentForNode(cursorNode);
-    if (!agent || !state2.selectedSessionId) {
-      notify(state2, "Select an agent to re-run");
-      return;
-    }
-    actions.sendAndNotify(
-      {
-        type: "spawn",
-        sessionId: state2.selectedSessionId,
-        agentType: agent.agentType,
-        name: `${agent.name}-retry`,
-        instruction: agent.instruction
-      },
-      `Re-spawned ${agent.name}`
-    );
-    return;
-  }
-  if (input === "R") {
-    if (!state2.selectedSessionId) {
-      notify(state2, "No session selected");
-      return;
-    }
-    if (session?.status === "active" && state2.paneAlive) {
-      notify(state2, "Session already active");
-      return;
-    }
-    if (enterComposeMode(state2, { kind: "resume", sessionId: state2.selectedSessionId }, actions)) return;
-    state2.mode = "resume";
-    state2.inputText = "";
-    state2.inputCursorPos = 0;
-    requestRender();
-    return;
-  }
-  if (input === "C") {
-    if (!state2.selectedSessionId) {
-      notify(state2, "No session selected");
-      return;
-    }
-    if (session?.status !== "completed") {
-      notify(state2, "Session not completed");
-      return;
-    }
-    if (enterComposeMode(state2, { kind: "continue", sessionId: state2.selectedSessionId }, actions)) return;
-    state2.mode = "continue";
-    state2.inputText = "";
-    state2.inputCursorPos = 0;
-    requestRender();
-    return;
-  }
-  if (input === "x") {
-    const agent = actions.getAgentForNode(cursorNode);
-    if (!agent || !state2.selectedSessionId) {
-      notify(state2, "Select an agent to restart");
-      return;
-    }
-    actions.sendAndNotify(
-      { type: "restart-agent", sessionId: state2.selectedSessionId, agentId: agent.id },
-      `Restarted ${agent.id}`
-    );
-    return;
-  }
-  if (input === "b") {
-    if (!state2.selectedSessionId) {
-      notify(state2, "No session selected");
-      return;
-    }
-    const defaultText = cursorNode?.type === "cycle" ? String(cursorNode.cycleNumber) : void 0;
-    state2.mode = "rollback";
-    if (defaultText) {
-      state2.inputText = defaultText;
-      state2.inputCursorPos = defaultText.length;
-    } else {
-      state2.inputText = "";
-      state2.inputCursorPos = 0;
-    }
-    requestRender();
-    return;
-  }
-  if (input === "e") {
-    if (!cursorNode || cursorNode.type !== "context-file") return;
-    const editor = actions.resolveEditor();
-    try {
-      actions.openEditorPopup(state2.cwd, editor, cursorNode.filePath);
-    } catch {
-      notify(state2, "Failed to open file in editor");
-    }
-    return;
-  }
-  if (input === "S") {
-    if (!state2.selectedSessionId) {
-      notify(state2, "No session selected");
-      return;
-    }
-    const sp = strategyPath(state2.cwd, state2.selectedSessionId);
-    const editor = actions.resolveEditor();
-    try {
-      actions.openEditorPopup(state2.cwd, editor, sp);
-    } catch {
-      notify(state2, `Failed to open strategy in ${editor}`);
-    }
-    return;
-  }
-  if (input === "t") {
-    if (state2.showCombinedView) {
-      if (state2.focusPane === "logs") state2.focusPane = "detail";
-      state2.logsScroll.reset();
-    }
-    state2.showCombinedView = !state2.showCombinedView;
-    requestRender();
-    return;
-  }
-}
-function handleKeypress(input, key, state2, actions) {
-  if (state2.mode === "compose") return;
-  if (INPUT_MODES.has(state2.mode)) {
-    handleInputBarKey(input, key, state2, actions);
-  } else if (state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "help") {
-    handleLeaderKey(input, key, state2, actions);
-  } else if (state2.mode === "report-detail") {
-    handleReportDetailKey(input, key, state2, actions);
-  } else {
-    handleNavigateKey(input, key, state2, actions);
-  }
-}
-
-// src/tui/render.ts
-import stringWidth2 from "string-width";
-var COLOR_SGR = {
-  black: 30,
-  red: 31,
-  green: 32,
-  yellow: 33,
-  blue: 34,
-  magenta: 35,
-  cyan: 36,
-  white: 37,
-  gray: 90
-};
-function colorToSGR(color) {
-  const code = COLOR_SGR[color];
-  if (code === void 0) throw new Error(`Unknown color: ${color}`);
-  return code;
-}
-function renderLine(segs) {
-  let out = "";
-  for (const s of segs) {
-    const codes = [];
-    if (s.bold) codes.push(1);
-    if (s.dim) codes.push(2);
-    if (s.italic) codes.push(3);
-    if (s.inverse) codes.push(7);
-    if (s.color) codes.push(colorToSGR(s.color));
-    if (codes.length > 0) {
-      out += `\x1B[${codes.join(";")}m${s.text}\x1B[0m`;
-    } else {
-      out += s.text;
-    }
-  }
-  return out;
-}
-var cachedBlank = "";
-var cachedBlankWidth = 0;
-function createFrameBuffer(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, suffix) {
-  let out = "\x1B[?2026h";
-  for (let i = 0; i < frame.length; i++) {
-    if (frame[i] !== prevFrame2[i]) {
-      out += `\x1B[${i + 1};1H`;
-      out += "\x1B[2K";
-      out += frame[i];
-    }
+    const gp = goalPath(state2.cwd, state2.selectedSessionId);
+    const editor = actions.resolveEditor();
+    try {
+      actions.openEditorPopup(state2.cwd, editor, gp, { w: "80", h: "50%" });
+    } catch {
+      notify(state2, `Failed to open goal in ${editor}`);
+    }
+    return;
   }
-  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;
+  if (input === "n") {
+    if (enterComposeMode(state2, { kind: "new-session" }, actions)) return;
+    const editor = actions.resolveEditor();
+    try {
+      const content = actions.editInPopup(state2.cwd, editor);
+      if (content) {
+        actions.sendAndNotify(
+          { type: "start", task: content, cwd: state2.cwd },
+          "Session created"
+        );
       }
+    } catch {
+      notify(state2, "Failed to open editor");
     }
-    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";
+    return;
   }
-  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;
-      }
+  if (input === "c") {
+    try {
+      actions.openCompanionPane(state2.cwd);
+    } catch {
+      notify(state2, "Failed to open companion pane");
     }
-    const cp = s.codePointAt(i);
-    const ch = String.fromCodePoint(cp);
-    w += cp < 128 ? 1 : stringWidth2(ch);
-    i += ch.length;
+    return;
   }
-  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 (input === "p") {
+    if (!state2.selectedSessionId) {
+      notify(state2, "No session selected");
+      return;
+    }
+    const pp = roadmapPath(state2.cwd, state2.selectedSessionId);
+    const editor = actions.resolveEditor();
+    try {
+      actions.openEditorPopup(state2.cwd, editor, pp);
+    } catch {
+      notify(state2, `Failed to open roadmap in ${editor}`);
     }
+    return;
   }
-  if (j < len) {
-    const c = s.charCodeAt(j);
-    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
-      return j + 1 - i;
+  if (input === "q") {
+    actions.cleanup();
+  }
+  if (input === "r") {
+    const agent = actions.getAgentForNode(cursorNode);
+    if (!agent || !state2.selectedSessionId) {
+      notify(state2, "Select an agent to re-run");
+      return;
     }
+    actions.sendAndNotify(
+      {
+        type: "spawn",
+        sessionId: state2.selectedSessionId,
+        agentType: agent.agentType,
+        name: `${agent.name}-retry`,
+        instruction: agent.instruction
+      },
+      `Re-spawned ${agent.name}`
+    );
+    return;
   }
-  return 0;
-}
-function writeAt(buf, x, y, content) {
-  if (y < 0 || y >= buf.height) return;
-  if (x < 0 || x >= buf.width) return;
-  const existing = buf.lines[y];
-  const contentDisplayWidth = stringWidth2(content.replace(ANSI_RE, ""));
-  const prefix = sliceDisplayCols(existing, 0, x);
-  const suffix = sliceDisplayCols(existing, x + contentDisplayWidth, buf.width);
-  const prefixWidth = stringWidth2(prefix.replace(ANSI_RE, ""));
-  const paddedPrefix = prefix + " ".repeat(Math.max(0, x - prefixWidth));
-  buf.lines[y] = paddedPrefix + content + suffix;
-}
-function writeClipped(buf, x, y, content, maxWidth) {
-  if (y < 0 || y >= buf.height) return;
-  if (x < 0 || x >= buf.width) return;
-  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;
+  if (input === "R") {
+    if (!state2.selectedSessionId) {
+      notify(state2, "No session selected");
+      return;
+    }
+    if (session?.status === "active" && state2.paneAlive) {
+      notify(state2, "Session already active");
+      return;
+    }
+    if (enterComposeMode(state2, { kind: "resume", sessionId: state2.selectedSessionId }, actions)) return;
+    {
+      const sessionId = state2.selectedSessionId;
+      const editor = actions.resolveEditor();
+      try {
+        const content = actions.editInPopup(state2.cwd, editor);
+        actions.sendAndNotify(
+          { type: "resume", sessionId, cwd: state2.cwd, message: content?.trim() || void 0 },
+          "Session resumed"
+        );
+      } catch {
+        notify(state2, "Failed to open editor");
       }
     }
-    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";
+    return;
   }
-  const remaining = maxWidth - displayWidth;
-  if (remaining > 0) {
-    out += " ".repeat(remaining);
+  if (input === "C") {
+    if (!state2.selectedSessionId) {
+      notify(state2, "No session selected");
+      return;
+    }
+    if (session?.status !== "completed") {
+      notify(state2, "Session not completed");
+      return;
+    }
+    if (enterComposeMode(state2, { kind: "continue", sessionId: state2.selectedSessionId }, actions)) return;
+    {
+      const sessionId = state2.selectedSessionId;
+      const editor = actions.resolveEditor();
+      void (async () => {
+        try {
+          const content = actions.editInPopup(state2.cwd, editor);
+          const contRes = await actions.send({ type: "continue", sessionId });
+          if (!contRes.ok) {
+            notify(state2, `Error: ${contRes.error}`);
+            return;
+          }
+          actions.sendAndNotify(
+            { type: "resume", sessionId, cwd: state2.cwd, message: content?.trim() || void 0 },
+            "Session continued"
+          );
+        } catch (err) {
+          notify(state2, `Error: ${err.message}`);
+        }
+      })();
+    }
+    return;
   }
-  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, ""));
-  const x = Math.max(0, Math.floor((buf.width - textWidth) / 2));
-  writeAt(buf, x, row, content);
-}
-function drawBorder(buf, x, y, w, h, color) {
-  const sgr = `\x1B[${colorToSGR(color)}m`;
-  const reset = "\x1B[0m";
-  writeAt(buf, x, y, sgr + "\u256D" + "\u2500".repeat(w - 2) + "\u256E" + reset);
-  writeAt(buf, x, y + h - 1, sgr + "\u2570" + "\u2500".repeat(w - 2) + "\u256F" + reset);
-  for (let row = y + 1; row < y + h - 1; row++) {
-    writeAt(buf, x, row, sgr + "\u2502" + reset);
-    writeAt(buf, x + w - 1, row, sgr + "\u2502" + reset);
+  if (input === "x") {
+    const agent = actions.getAgentForNode(cursorNode);
+    if (!agent || !state2.selectedSessionId) {
+      notify(state2, "Select an agent to restart");
+      return;
+    }
+    actions.sendAndNotify(
+      { type: "restart-agent", sessionId: state2.selectedSessionId, agentId: agent.id },
+      `Restarted ${agent.id}`
+    );
+    return;
   }
-}
-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 innerH = h - 2;
-  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 (input === "b") {
+    if (!state2.selectedSessionId) {
+      notify(state2, "No session selected");
+      return;
+    }
+    {
+      const sessionId = state2.selectedSessionId;
+      const editor = actions.resolveEditor();
+      try {
+        const text = actions.editInPopup(state2.cwd, editor);
+        if (text?.trim()) {
+          const toCycle = parseInt(text.trim(), 10);
+          if (isNaN(toCycle) || toCycle < 1) {
+            notify(state2, "Invalid cycle number");
+            return;
+          }
+          actions.sendAndNotify(
+            { type: "rollback", sessionId, cwd: state2.cwd, toCycle },
+            `Rolled back to cycle ${toCycle} \u2014 use [R]esume to respawn`
+          );
+        }
+      } catch {
+        notify(state2, "Failed to open editor");
+      }
     }
-    if (renderedCache) {
-      renderedCache.lines = lines;
-      renderedCache.ansi = ansiLines;
+    return;
+  }
+  if (input === "e") {
+    if (!cursorNode || cursorNode.type !== "context-file") return;
+    const editor = actions.resolveEditor();
+    try {
+      actions.openEditorPopup(state2.cwd, editor, cursorNode.filePath);
+    } catch {
+      notify(state2, "Failed to open file in editor");
     }
+    return;
   }
-  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);
-  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 (input === "S") {
+    if (!state2.selectedSessionId) {
+      notify(state2, "No session selected");
+      return;
+    }
+    const sp = strategyPath(state2.cwd, state2.selectedSessionId);
+    const editor = actions.resolveEditor();
+    try {
+      actions.openEditorPopup(state2.cwd, editor, sp);
+    } catch {
+      notify(state2, `Failed to open strategy in ${editor}`);
+    }
+    return;
   }
-  if (hasOverflow) {
-    const scrollPct = maxScroll > 0 ? Math.round(effectiveOffset / maxScroll * 100) : 100;
-    const indicator = `  \u2195 ${scrollPct}% \xB7 ${lines.length} lines`;
-    const clipped = clipAnsi(`\x1B[2m${indicator}\x1B[0m`, innerW);
-    rows[1 + viewableH] = borderL + clipped + borderR;
+  if (input === "/") {
+    state2.mode = "search";
+    state2.searchText = "";
+    requestRender();
+    return;
   }
-  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;
+  if (input === "t") {
+    if (state2.showCombinedView) {
+      if (state2.focusPane === "logs") state2.focusPane = "detail";
+      state2.logsScroll.reset();
     }
+    state2.showCombinedView = !state2.showCombinedView;
+    requestRender();
+    return;
   }
-  return rows;
 }
-function sliceDisplayCols(s, start, end) {
-  let out = "";
-  let col = 0;
-  let i = 0;
-  let inSlice = false;
-  let hasOpenSGR = false;
-  while (i < s.length && col < end) {
-    if (s[i] === "\x1B" && s[i + 1] === "[") {
-      const seqLen = ansiLen(s, i);
-      if (seqLen > 0) {
-        if (col >= start) {
-          const seq = s.substring(i, i + seqLen);
-          out += seq;
-          hasOpenSGR = seq !== "\x1B[0m" && seq !== "\x1B[m";
-        }
-        i += seqLen;
-        continue;
-      }
-    }
-    const cp = s.codePointAt(i);
-    const ch = String.fromCodePoint(cp);
-    const chWidth = cp < 128 ? 1 : stringWidth2(ch);
-    if (col >= start) {
-      inSlice = true;
-      if (col + chWidth > end) break;
-      out += ch;
-    }
-    col += chWidth;
-    i += ch.length;
+function handleSearchKey(input, key, state2) {
+  if (key.return) {
+    state2.mode = "navigate";
+    requestRender();
+    return;
   }
-  if (inSlice && hasOpenSGR) {
-    out += "\x1B[0m";
+  if (key.escape) {
+    state2.searchFilter = null;
+    state2.searchText = "";
+    state2.mode = "navigate";
+    requestRender();
+    return;
+  }
+  if (key.backspace) {
+    state2.searchText = state2.searchText.slice(0, -1);
+    state2.searchFilter = state2.searchText || null;
+    requestRender();
+    return;
+  }
+  if (key.ctrl || key.meta || !input || input.length !== 1) return;
+  state2.searchText += input;
+  state2.searchFilter = state2.searchText;
+  requestRender();
+}
+function handleKeypress(input, key, state2, actions) {
+  if (state2.mode === "compose") return;
+  if (state2.mode === "search") {
+    handleSearchKey(input, key, state2);
+  } else if (state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "help" || state2.mode === "companion-overlay" || state2.mode === "companion-debug") {
+    handleLeaderKey(input, key, state2, actions);
+  } else if (state2.mode === "report-detail") {
+    handleReportDetailKey(input, key, state2, actions);
+  } else {
+    handleNavigateKey(input, key, state2, actions);
   }
-  return out;
 }
 
 // src/tui/lib/tree-render.ts
@@ -2310,18 +2713,22 @@ function openShellPopup(cwd2, command) {
 function openInFileManager(path) {
   execSync(`open ${shellQuote(path)}`, { stdio: "inherit", env: EXEC_ENV });
 }
-function openClaudeResumePopup(cwd2, claudeSessionId) {
+function openClaudeResumePopup(cwd2, claudeSessionId, resumeEnv, resumeArgs) {
   const pathEnv = augmentedPath();
-  const cmd = `PATH=${shellQuote(pathEnv)} claude --resume ${shellQuote(claudeSessionId)}`;
+  const envPrefix = resumeEnv ? `${resumeEnv} && ` : "";
+  const args2 = resumeArgs ? `${resumeArgs} --resume ${shellQuote(claudeSessionId)}` : `--resume ${shellQuote(claudeSessionId)}`;
+  const cmd = `${envPrefix}PATH=${shellQuote(pathEnv)} claude ${args2}`;
   execSync(
     `tmux display-popup -E -w 90% -h 80% -d ${shellQuote(cwd2)} ${shellQuote(cmd)}`,
     { stdio: "inherit", env: EXEC_ENV }
   );
 }
-function openClaudeResumeSession(cwd2, claudeSessionId, sessionLabel) {
+function openClaudeResumeSession(cwd2, claudeSessionId, sessionLabel, resumeEnv, resumeArgs) {
   const pathEnv = augmentedPath();
-  const cmd = `PATH=${shellQuote(pathEnv)} claude --resume ${shellQuote(claudeSessionId)}`;
-  const sessionName = `sisyphus-${sessionLabel}-resume`;
+  const envPrefix = resumeEnv ? `${resumeEnv} && ` : "";
+  const args2 = resumeArgs ? `${resumeArgs} --resume ${shellQuote(claudeSessionId)}` : `--resume ${shellQuote(claudeSessionId)}`;
+  const cmd = `${envPrefix}PATH=${shellQuote(pathEnv)} claude ${args2}`;
+  const sessionName = tmuxSessionName(cwd2, `${sessionLabel}-resume`);
   exec(`tmux new-session -d -s ${shellQuote(sessionName)} -c ${shellQuote(cwd2)} ${shellQuote(cmd)}`);
   execSafe(`tmux set-option -t ${shellQuote(sessionName)} @sisyphus_cwd ${shellQuote(cwd2.replace(/\/+$/, ""))}`);
   const paneTarget = `${sessionName}:`;
@@ -2449,7 +2856,7 @@ function renderNodeContent(node, maxWidth) {
     }
   }
 }
-function renderTreePanel(buf, rect, nodes, cursorIndex, focused) {
+function renderTreePanel(buf, rect, nodes, cursorIndex, focused, companion) {
   const { x, y, w, h } = rect;
   drawBorder(buf, x, y, w, h, focused ? "yellow" : "gray");
   const innerX = x + 2;
@@ -2464,7 +2871,26 @@ function renderTreePanel(buf, rect, nodes, cursorIndex, focused) {
     writeClipped(buf, innerX, innerY + 3, "\x1B[2mPress [?] for all keybindings.\x1B[0m", innerW);
     return;
   }
-  const maxVisible = Math.max(1, innerH);
+  let companionRows = 0;
+  let _companionCommentaryLines = [];
+  if (companion) {
+    const commentaryText = companion.lastCommentary?.text;
+    if (commentaryText) {
+      const words = commentaryText.split(" ");
+      let current = "";
+      for (const word of words) {
+        if (current.length + word.length + 1 > innerW && current.length > 0) {
+          _companionCommentaryLines.push(current);
+          current = word;
+        } else {
+          current = current.length > 0 ? `${current} ${word}` : word;
+        }
+      }
+      if (current.length > 0) _companionCommentaryLines.push(current);
+    }
+    companionRows = 1 + 1 + _companionCommentaryLines.length;
+  }
+  const maxVisible = Math.max(1, innerH - companionRows);
   const halfVisible = Math.floor(maxVisible / 2);
   const scrollOffset = Math.max(
     0,
@@ -2524,6 +2950,15 @@ function renderTreePanel(buf, rect, nodes, cursorIndex, focused) {
     const bottomRow = rowStart + availRows;
     writeClipped(buf, innerX, bottomRow, `\x1B[2m\u2193 ${bottomMore} more\x1B[0m`, innerW);
   }
+  if (companion) {
+    const commentaryCount = _companionCommentaryLines.length;
+    const faceRow = y + h - 2 - commentaryCount;
+    const faceLine = renderCompanion(companion, ["face", "boulder"], { maxWidth: innerW, color: true });
+    writeClipped(buf, innerX, faceRow, faceLine, innerW);
+    for (let i = 0; i < commentaryCount; i++) {
+      writeClipped(buf, innerX, faceRow + 1 + i, `\x1B[2m${_companionCommentaryLines[i]}\x1B[0m`, innerW);
+    }
+  }
 }
 
 // src/tui/panels/detail.ts
@@ -3221,66 +3656,28 @@ function renderNvimDetailRows(rect, bridge, focused, editable, statusRows, compo
 }
 
 // src/tui/panels/bottom.ts
-function renderNotificationRow(buf, y, notification, error) {
-  if (notification !== null) {
-    const icon = /error|failed/i.test(notification) ? "\u2715" : /success|created|killed|sent|copied|deleted/i.test(notification) ? "\u2713" : "\u2139";
-    const content = `\x1B[1;33m${icon} ${notification}\x1B[0m`;
-    writeClipped(buf, 1, y, content, buf.width - 2);
-  } else if (error !== null) {
-    const content = `\x1B[31m\u26A0 ${error}\x1B[0m`;
-    writeClipped(buf, 1, y, content, buf.width - 2);
-  }
-}
-function renderInputBar(buf, y, state2) {
-  const { mode, inputText, inputCursorPos } = state2;
-  if (mode === "compose") {
-    const action = state2.composeAction;
-    const label = action ? COMPOSE_HEADERS[action.kind] : "Compose";
-    const content2 = `\x1B[1;33mCOMPOSE\x1B[0m\x1B[2m  ${label} \xB7 :w to submit \xB7 Tab to cancel\x1B[0m`;
-    writeClipped(buf, 1, y, content2, buf.width - 2);
-    return;
-  }
-  if (mode === "navigate") {
-    const content2 = `\x1B[2mPress [m] to message orchestrator, [n] for new session\x1B[0m`;
-    writeClipped(buf, 1, y, content2, buf.width - 2);
-    return;
-  }
-  if (mode === "report-detail" || mode === "leader" || mode === "copy-menu" || mode === "help" || !INPUT_MODES.has(mode)) {
-    return;
-  }
-  const prompt = PROMPTS[mode] ?? mode;
-  const cursorChar = inputCursorPos < inputText.length ? inputText[inputCursorPos] : " ";
-  const before = inputText.slice(0, inputCursorPos);
-  const after = inputText.slice(inputCursorPos + 1);
-  const content = `\x1B[33m${prompt} > \x1B[0m` + before + `\x1B[7m${cursorChar}\x1B[0m` + after + `\x1B[2m  (enter to send, esc to cancel)\x1B[0m`;
-  writeClipped(buf, 1, y, content, buf.width - 2);
-}
 var B = ansiBold;
 var D = ansiDim;
 var SEP = D("\u2502 ");
 function renderStatusLine(buf, y, state2, cursorNodeType) {
-  const { mode, focusPane } = state2;
+  const { mode, focusPane, notification, error } = state2;
   if (mode === "report-detail") return;
   if (mode === "compose") return;
   let content;
-  if (mode === "leader") {
+  if (notification !== null) {
+    const icon = /error|failed/i.test(notification) ? "\u2715" : /success|created|killed|sent|copied|deleted/i.test(notification) ? "\u2713" : "\u2139";
+    content = `\x1B[1;33m${icon} ${notification}\x1B[0m`;
+  } else if (error !== null) {
+    content = `\x1B[31m\u26A0 ${error}\x1B[0m`;
+  } else if (mode === "search") {
+    const cursor = `\x1B[7m \x1B[0m`;
+    content = `\x1B[1;34m/\x1B[0m${state2.searchText}${cursor}` + D("  enter to apply \xB7 esc to clear");
+  } else if (mode === "leader") {
     content = `\x1B[1;35mLEADER\x1B[0m` + D("  press a command key or [esc] to cancel");
   } else if (mode === "copy-menu") {
     content = `\x1B[1;36mCOPY\x1B[0m` + D("  [p] path  [C] context  [l] logs  [s] session ID  [esc] cancel");
   } else if (mode === "help") {
     content = `\x1B[1;33mHELP\x1B[0m` + D("  [esc] or [?] to dismiss");
-  } else if (mode === "delete-confirm") {
-    content = `\x1B[1;31mDELETE\x1B[0m` + D("  type 'yes' to confirm, [esc] to cancel");
-  } else if (mode === "spawn-agent") {
-    content = `\x1B[1;32mSPAWN\x1B[0m` + D("  enter agent instruction, [esc] to cancel");
-  } else if (mode === "search") {
-    content = `\x1B[1;34mSEARCH\x1B[0m` + D("  type to filter, enter to apply, [esc] to cancel");
-  } else if (mode === "message-agent") {
-    content = `\x1B[1;36mMESSAGE\x1B[0m` + D("  enter message for agent, [esc] to cancel");
-  } else if (mode === "shell-command") {
-    content = `\x1B[1;35mSHELL\x1B[0m` + D("  enter command, [esc] to cancel");
-  } 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 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 {
@@ -3293,102 +3690,6 @@ function renderStatusLine(buf, y, state2, cursorNodeType) {
   writeClipped(buf, 1, y, content, buf.width - 2);
 }
 
-// src/tui/panels/overlays.ts
-var LEADER_WIDTH = 26;
-var LEADER_HEIGHT = 19;
-var COPY_HEIGHT = 9;
-var HELP_WIDTH = 62;
-function helpRow(left, right, innerWidth) {
-  const col = Math.floor(innerWidth / 2);
-  return (left.padEnd(col) + right).padEnd(innerWidth);
-}
-function renderLeaderOverlay(buf, rows, cols) {
-  const x = cols - LEADER_WIDTH - 1;
-  const y = rows - LEADER_HEIGHT - 2;
-  const innerWidth = LEADER_WIDTH - 2;
-  drawBorder(buf, x, y, LEADER_WIDTH, LEADER_HEIGHT, "magenta");
-  const lines = [
-    ansiColor("  LEADER".padEnd(innerWidth), "magenta", true),
-    " ".padEnd(innerWidth),
-    "  y  copy menu".padEnd(innerWidth),
-    "  d  delete session".padEnd(innerWidth),
-    "  l  daemon logs".padEnd(innerWidth),
-    "  o  open session dir".padEnd(innerWidth),
-    "  a  spawn agent".padEnd(innerWidth),
-    "  m  message agent".padEnd(innerWidth),
-    "  /  search".padEnd(innerWidth),
-    "  !  shell command".padEnd(innerWidth),
-    "  j  jump to pane".padEnd(innerWidth),
-    "  k  kill session/agent".padEnd(innerWidth),
-    "  q  quit".padEnd(innerWidth),
-    "  ?  help".padEnd(innerWidth),
-    " 1-9  jump to session".padEnd(innerWidth),
-    " ".padEnd(innerWidth),
-    ansiDim("  esc  dismiss".padEnd(innerWidth))
-  ];
-  for (let i = 0; i < lines.length; i++) {
-    writeClipped(buf, x + 1, y + 1 + i, lines[i], innerWidth);
-  }
-}
-function renderCopyMenuOverlay(buf, rows, cols) {
-  const x = cols - LEADER_WIDTH - 1;
-  const y = rows - COPY_HEIGHT - 2;
-  const innerWidth = LEADER_WIDTH - 2;
-  drawBorder(buf, x, y, LEADER_WIDTH, COPY_HEIGHT, "cyan");
-  const lines = [
-    ansiColor("  COPY".padEnd(innerWidth), "cyan", true),
-    " ".padEnd(innerWidth),
-    "  p  session path".padEnd(innerWidth),
-    "  C  LLM context".padEnd(innerWidth),
-    "  l  logs content".padEnd(innerWidth),
-    "  s  session ID".padEnd(innerWidth),
-    ansiDim("  esc  cancel".padEnd(innerWidth))
-  ];
-  for (let i = 0; i < lines.length; i++) {
-    writeClipped(buf, x + 1, y + 1 + i, lines[i], innerWidth);
-  }
-}
-function renderHelpOverlay(buf, rows, cols) {
-  const innerWidth = HELP_WIDTH - 2;
-  const x = Math.max(0, Math.floor((cols - HELP_WIDTH) / 2));
-  const contentLines = [
-    helpRow("  hjkl/\u2191\u2193\u2190\u2192  navigate", "  tab  switch pane", innerWidth),
-    helpRow("  enter  expand/open", "  t  toggle logs", innerWidth),
-    " ".padEnd(innerWidth),
-    helpRow("  n  new session", "  m  message orch.", innerWidth),
-    helpRow("  R  resume session", "  C  continue session", innerWidth),
-    helpRow("  b  rollback cycle", "  x  restart agent", innerWidth),
-    helpRow("  r  re-run agent", "  g  edit goal", innerWidth),
-    helpRow("  p  open roadmap", "  s  toggle strategy", innerWidth),
-    helpRow("  S  edit strategy", "  w  go to window", innerWidth),
-    helpRow("  o  resume claude session", "  c  claude companion", innerWidth),
-    helpRow("  q  quit", "", innerWidth),
-    " ".padEnd(innerWidth),
-    helpRow("  space \u2192 y  copy submenu", "  space \u2192 d  delete session", innerWidth),
-    helpRow("  space \u2192 j  jump to pane", "  space \u2192 k  kill", innerWidth),
-    helpRow("  space \u2192 q  quit", "  space \u2192 o  open dir", innerWidth),
-    helpRow("  space \u2192 l  tail logs", "  space \u2192 /  search", innerWidth),
-    helpRow("  space \u2192 a  spawn agent", "  space \u2192 m  msg agent", innerWidth),
-    helpRow("  space \u2192 ?  help", "  space \u2192 1-9  jump", innerWidth),
-    " ".padEnd(innerWidth),
-    helpRow("  y \u2192 p  session path", "  y \u2192 C  LLM context", innerWidth),
-    helpRow("  y \u2192 l  logs content", "  y \u2192 s  session ID", innerWidth)
-  ];
-  const height = Math.min(contentLines.length + 4, rows - 2);
-  const y = Math.max(0, Math.floor((rows - height) / 2));
-  drawBorder(buf, x, y, HELP_WIDTH, height, "yellow");
-  writeClipped(buf, x + 1, y + 1, ansiColor("  KEYBINDINGS  (esc or ? to close)".padEnd(innerWidth), "yellow", true), innerWidth);
-  writeClipped(buf, x + 1, y + 2, " ".padEnd(innerWidth), innerWidth);
-  const availableContentRows = height - 4;
-  for (let i = 0; i < Math.min(contentLines.length, availableContentRows); i++) {
-    writeClipped(buf, x + 1, y + 3 + i, contentLines[i], innerWidth);
-  }
-  const trailingBlankRow = y + 3 + Math.min(contentLines.length, availableContentRows);
-  if (trailingBlankRow < y + height - 1) {
-    writeClipped(buf, x + 1, trailingBlankRow, " ".padEnd(innerWidth), innerWidth);
-  }
-}
-
 // src/tui/lib/nvim-bridge.ts
 import { execSync as execSync3 } from "child_process";
 import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2, readFileSync as readFileSync3, statSync, existsSync as existsSync3 } from "fs";
@@ -4180,6 +4481,19 @@ function resolveNvimFile(state2, cursorNode, detailCtx, cwd2) {
 }
 
 // src/tui/app.ts
+var _cachedCompanion = null;
+var _companionMtime = 0;
+function getCompanion() {
+  try {
+    const { mtimeMs } = statSync2(companionPath());
+    if (_cachedCompanion && mtimeMs === _companionMtime) return _cachedCompanion;
+    _companionMtime = mtimeMs;
+    _cachedCompanion = JSON.parse(readFileSync4(companionPath(), "utf-8"));
+    return _cachedCompanion;
+  } catch {
+    return _cachedCompanion;
+  }
+}
 var latestNodes = [];
 var cachedContextFilePath = null;
 var cachedContextFileContent = null;
@@ -4262,7 +4576,7 @@ 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 initialDetailH = state2.rows - 1 - 2 - STATUS_ROW_COUNT - 1;
   const bridge = new NvimBridge(
     Math.max(1, initialDetailW),
     Math.max(1, initialDetailH),
@@ -4410,7 +4724,7 @@ function startApp(state2, cleanup2) {
     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 contentHeight = state2.rows - 1;
     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;
@@ -4487,15 +4801,24 @@ function startApp(state2, cleanup2) {
     }
     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 bottomInputs = `${state2.notification}:${state2.error}:${state2.mode}:${state2.searchText}:${cursorNode?.type}`;
+    const overlayMode = state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "help" || state2.mode === "companion-overlay" || state2.mode === "companion-debug" ? state2.mode : "";
+    let companionFP = "";
+    if (state2.mode === "companion-overlay" || state2.mode === "companion-debug") {
+      const c = getCompanion();
+      const ts = c && c.lastCommentary ? c.lastCommentary.timestamp : "";
+      const xp = c ? c.xp : 0;
+      const dm = c?.debugMood ? `${c.debugMood.winner}:${c.debugMood.scores[c.debugMood.winner]}` : "";
+      companionFP = `${ts}:${xp}:${dm}`;
+    }
+    const overlayInputs = `${overlayMode}:${companionFP}`;
     const hasPrev = prevFrame.length === buf.height;
     const treeDirty = !hasPrev || treeInputs !== prevTreeInputs;
     const bottomDirty = !hasPrev || bottomInputs !== prevBottomInputs;
-    const overlayDirty = !hasPrev || overlayMode !== prevOverlayMode;
+    const overlayDirty = !hasPrev || overlayInputs !== prevOverlayMode;
     prevTreeInputs = treeInputs;
     prevBottomInputs = bottomInputs;
-    prevOverlayMode = overlayMode;
+    prevOverlayMode = overlayInputs;
     let treeRows;
     if (treeDirty) {
       const treeBlank = " ".repeat(treeWidth2);
@@ -4509,7 +4832,8 @@ function startApp(state2, cleanup2) {
         { x: 0, y: 0, w: treeWidth2, h: contentHeight },
         nodes,
         state2.cursorIndex,
-        treeFocused
+        treeFocused,
+        getCompanion()
       );
       cachedTreeRows = treeBuf.lines;
       treeRows = treeBuf.lines;
@@ -4573,16 +4897,22 @@ function startApp(state2, cleanup2) {
       }
     }
     if (bottomDirty || overlayDirty) {
-      renderNotificationRow(buf, bottomY, state2.notification, state2.error);
-      renderInputBar(buf, bottomY + 1, state2);
-      renderStatusLine(buf, bottomY + 2, state2, cursorNode?.type);
+      renderStatusLine(buf, bottomY, state2, cursorNode?.type);
     } else {
-      copyRows(buf, prevFrame, bottomY, 3);
+      copyRows(buf, prevFrame, bottomY, 1);
     }
     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);
+      if (state2.mode === "companion-overlay") {
+        const companion = getCompanion();
+        if (companion) renderCompanionOverlay(buf, state2.rows, state2.cols, companion);
+      }
+      if (state2.mode === "companion-debug") {
+        const companion = getCompanion();
+        if (companion) renderCompanionDebugOverlay(buf, state2.rows, state2.cols, companion);
+      }
     }
     let cursorSuffix;
     if (state2.focusPane === "detail" && state2.nvimBridge?.ready) {
@@ -4652,7 +4982,7 @@ function startApp(state2, cleanup2) {
     prevFrame = [];
     if (state2.nvimBridge) {
       const detailW = state2.cols - 36;
-      const contentH = state2.rows - 3;
+      const contentH = state2.rows - 1;
       state2.nvimBridge.resize(Math.max(1, detailW - 4), Math.max(1, contentH - 2 - STATUS_ROW_COUNT - 1));
     }
     requestRender();