sisyphi 1.1.19 → 1.1.23

package/dist/tui.js

@@ -1,70 +1,1014 @@
 #!/usr/bin/env node
-import {
-  KEYMAP,
-  MENU_FOR_MODE,
-  buildSessionContext,
-  computeActiveTimeMs,
-  createBadgeGallery,
-  galleryNext,
-  galleryPrev,
-  rawSend,
-  renderBadgeCard,
-  resolveReports
-} from "./chunk-M6Z3KHOH.js";
-import {
-  ACHIEVEMENTS,
-  EXEC_ENV,
-  augmentedPath,
-  computeLevelProgress,
-  exec,
-  execSafe,
-  exportSessionToZip,
-  formatDuration,
-  getMoodAnsiCode,
-  getMoodFace,
-  renderCompanion,
-  statusColor
-} from "./chunk-36VJ7ZBD.js";
-import {
-  buildEmptyPanelRows,
-  buildPanelRows,
-  clipAnsi,
-  colorToSGR,
-  copyRows,
-  createFrameBuffer,
-  drawBorder,
-  flushFrame,
-  onResize,
-  renderLine,
-  setupTerminal,
-  startKeypressListener,
-  writeCenter,
-  writeClipped,
-  writeToStdout
-} from "./chunk-O4ZHSQ5R.js";
-import {
-  loadConfig,
-  readDecisions,
-  readMeta,
-  readProgress,
-  shellQuote,
-  updateMeta,
-  writeOutput
-} from "./chunk-SVGIQ2G4.js";
-import {
-  askProgressPath,
-  companionPath,
-  contextDir,
-  digestPath,
-  globalDir,
-  goalPath,
-  logsDir,
-  reportsDir,
-  roadmapPath,
-  sessionDir,
-  strategyPath,
-  tmuxSessionName
-} from "./chunk-PNDCVKBN.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/tui/terminal.ts
+function emptyKey() {
+  return {
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageUp: false,
+    pageDown: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false
+  };
+}
+function setupTerminal() {
+  let cleaned = false;
+  const cleanup2 = () => {
+    if (cleaned) return;
+    cleaned = true;
+    process.stdout.write("\x1B[?25h\x1B[?1049l");
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+  };
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding("utf-8");
+  process.stdout.write("\x1B[?1049h\x1B[?25l\x1B[2J");
+  process.on("SIGINT", () => {
+    cleanup2();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup2();
+    process.exit(0);
+  });
+  process.on("exit", cleanup2);
+  process.on("uncaughtException", (err) => {
+    cleanup2();
+    console.error(err);
+    process.exit(1);
+  });
+  return cleanup2;
+}
+function writeToStdout(data) {
+  process.stdout.write(data);
+}
+function parseBuffer(buf) {
+  const events = [];
+  let i = 0;
+  while (i < buf.length) {
+    const ch = buf[i];
+    if (ch === "\x1B") {
+      const rest = buf.slice(i + 1);
+      if (rest.startsWith("[")) {
+        const after = rest.slice(1);
+        const shiftArrow = after.match(/^1;2([ABCD])/);
+        if (shiftArrow) {
+          const key2 = emptyKey();
+          key2.shift = true;
+          const dir = shiftArrow[1];
+          if (dir === "A") key2.upArrow = true;
+          else if (dir === "B") key2.downArrow = true;
+          else if (dir === "C") key2.rightArrow = true;
+          else if (dir === "D") key2.leftArrow = true;
+          const seq = `\x1B[1;2${dir}`;
+          events.push([seq, key2]);
+          i += seq.length;
+          continue;
+        }
+        if (after.length >= 1 && after[0] === "Z") {
+          const key2 = emptyKey();
+          key2.tab = true;
+          key2.shift = true;
+          const seq = `\x1B[Z`;
+          events.push([seq, key2]);
+          i += seq.length;
+          continue;
+        }
+        if (after.length >= 1 && "ABCD".includes(after[0])) {
+          const key2 = emptyKey();
+          const dir = after[0];
+          if (dir === "A") key2.upArrow = true;
+          else if (dir === "B") key2.downArrow = true;
+          else if (dir === "C") key2.rightArrow = true;
+          else if (dir === "D") key2.leftArrow = true;
+          const seq = `\x1B[${dir}`;
+          events.push([seq, key2]);
+          i += seq.length;
+          continue;
+        }
+        const tildeMatch = after.match(/^(\d+)~/);
+        if (tildeMatch) {
+          const num = tildeMatch[1];
+          const key2 = emptyKey();
+          if (num === "5") key2.pageUp = true;
+          else if (num === "6") key2.pageDown = true;
+          else if (num === "3") key2.delete = true;
+          const seq = `\x1B[${num}~`;
+          events.push([seq, key2]);
+          i += seq.length;
+          continue;
+        }
+        return { events, remaining: buf.slice(i) };
+      }
+      if (rest.length === 0) {
+        return { events, remaining: buf.slice(i) };
+      }
+      const metaCh = rest[0];
+      const key = emptyKey();
+      key.meta = true;
+      events.push([metaCh, key]);
+      i += 2;
+      continue;
+    }
+    if (ch === "\r") {
+      const key = emptyKey();
+      key.return = true;
+      events.push([ch, key]);
+      i++;
+      continue;
+    }
+    if (ch === "	") {
+      const key = emptyKey();
+      key.tab = true;
+      events.push([ch, key]);
+      i++;
+      continue;
+    }
+    if (ch === "\x7F" || ch === "\b") {
+      const key = emptyKey();
+      key.backspace = true;
+      events.push([ch, key]);
+      i++;
+      continue;
+    }
+    const code = ch.charCodeAt(0);
+    if (code >= 1 && code <= 26) {
+      const key = emptyKey();
+      key.ctrl = true;
+      const letter = String.fromCharCode(code + 96);
+      events.push([letter, key]);
+      i++;
+      continue;
+    }
+    events.push([ch, emptyKey()]);
+    i++;
+  }
+  return { events, remaining: "" };
+}
+function startKeypressListener(handler) {
+  let buffer = "";
+  let escTimer = null;
+  const onData = (data) => {
+    if (rawBypassHandler) {
+      const handled = rawBypassHandler(data);
+      if (handled) return;
+    }
+    if (escTimer !== null) {
+      clearTimeout(escTimer);
+      escTimer = null;
+    }
+    buffer += data;
+    const { events, remaining } = parseBuffer(buffer);
+    buffer = remaining;
+    for (const [input, key] of events) {
+      handler(input, key);
+    }
+    if (buffer === "\x1B") {
+      escTimer = setTimeout(() => {
+        escTimer = null;
+        buffer = "";
+        const key = emptyKey();
+        key.escape = true;
+        handler("\x1B", key);
+      }, 50);
+    }
+  };
+  process.stdin.on("data", onData);
+  return () => {
+    process.stdin.off("data", onData);
+    if (escTimer !== null) {
+      clearTimeout(escTimer);
+      escTimer = null;
+    }
+  };
+}
+function onResize(callback) {
+  const onStdoutResize = () => callback();
+  const onSigwinch = () => callback();
+  process.stdout.on("resize", onStdoutResize);
+  process.on("SIGWINCH", onSigwinch);
+  return () => {
+    process.stdout.off("resize", onStdoutResize);
+    process.off("SIGWINCH", onSigwinch);
+  };
+}
+var rawBypassHandler;
+var init_terminal = __esm({
+  "src/tui/terminal.ts"() {
+    "use strict";
+    rawBypassHandler = null;
+  }
+});
+
+// src/shared/paths.ts
+import { homedir } from "os";
+import { basename, join } from "path";
+function globalDir() {
+  return join(homedir(), ".sisyphus");
+}
+function socketPath() {
+  return join(globalDir(), "daemon.sock");
+}
+function globalConfigPath() {
+  return join(globalDir(), "config.json");
+}
+function projectDir(cwd2) {
+  return join(cwd2, ".sisyphus");
+}
+function projectConfigPath(cwd2) {
+  return join(projectDir(cwd2), "config.json");
+}
+function sessionsDir(cwd2) {
+  return join(projectDir(cwd2), "sessions");
+}
+function sessionDir(cwd2, sessionId2) {
+  return join(sessionsDir(cwd2), sessionId2);
+}
+function statePath(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "state.json");
+}
+function reportsDir(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "reports");
+}
+function contextDir(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "context");
+}
+function roadmapPath(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "roadmap.md");
+}
+function goalPath(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "goal.md");
+}
+function strategyPath(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "strategy.md");
+}
+function digestPath(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "digest.json");
+}
+function logsDir(cwd2, sessionId2) {
+  return join(sessionDir(cwd2, sessionId2), "logs");
+}
+function askDir(cwd2, sessionId2) {
+  return join(contextDir(cwd2, sessionId2), "ask");
+}
+function askEntryDir(cwd2, sessionId2, askId2) {
+  return join(askDir(cwd2, sessionId2), askId2);
+}
+function askMetaPath(cwd2, sessionId2, askId2) {
+  return join(askEntryDir(cwd2, sessionId2, askId2), "meta.json");
+}
+function askDecisionsPath(cwd2, sessionId2, askId2) {
+  return join(askEntryDir(cwd2, sessionId2, askId2), "decisions.json");
+}
+function askOutputPath(cwd2, sessionId2, askId2) {
+  return join(askEntryDir(cwd2, sessionId2, askId2), "output.json");
+}
+function askProgressPath(cwd2, sessionId2, askId2) {
+  return join(askEntryDir(cwd2, sessionId2, askId2), "progress.json");
+}
+function tmuxSessionName(cwd2, sessionLabel) {
+  return `ssyph_${basename(cwd2)}_${sessionLabel}`;
+}
+function companionPath() {
+  return join(globalDir(), "companion.json");
+}
+function historyBaseDir() {
+  return join(globalDir(), "history");
+}
+function historySessionDir(sessionId2) {
+  return join(historyBaseDir(), sessionId2);
+}
+var init_paths = __esm({
+  "src/shared/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/tui/render.ts
+import stringWidth2 from "string-width";
+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.strikethrough) codes.push("9");
+    if (s.inverse) codes.push("7");
+    if (s.fg) codes.push(s.fg);
+    else if (s.color) codes.push(String(colorToSGR(s.color)));
+    if (s.bg) codes.push(s.bg);
+    if (codes.length > 0) {
+      out += `\x1B[${codes.join(";")}m${s.text}\x1B[0m`;
+    } else {
+      out += s.text;
+    }
+  }
+  return out;
+}
+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];
+    }
+  }
+  if (suffix) out += suffix;
+  out += "\x1B[?2026l";
+  return out;
+}
+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);
+    if (cp < 32 && cp !== 27) {
+      i++;
+      continue;
+    }
+    const ch = String.fromCodePoint(cp);
+    const chWidth = cp < 128 ? 1 : stringWidth2(ch);
+    if (displayWidth + chWidth > maxWidth) break;
+    out += ch;
+    displayWidth += chWidth;
+    i += ch.length;
+  }
+  if (out.includes("\x1B[") && !out.endsWith("\x1B[0m")) {
+    out += "\x1B[0m";
+  }
+  const remaining = maxWidth - displayWidth;
+  if (remaining > 0) out += " ".repeat(remaining);
+  return out;
+}
+function displayWidthFast(s) {
+  let w = 0;
+  let i = 0;
+  while (i < s.length) {
+    if (s[i] === "\x1B" && s[i + 1] === "[") {
+      const len = ansiLen(s, i);
+      if (len > 0) {
+        i += len;
+        continue;
+      }
+    }
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    w += cp < 128 ? 1 : stringWidth2(ch);
+    i += ch.length;
+  }
+  return w;
+}
+function ansiLen(s, i) {
+  let j = i + 2;
+  const len = s.length;
+  while (j < len) {
+    const c = s.charCodeAt(j);
+    if (c >= 48 && c <= 57 || c === 59) {
+      j++;
+    } else {
+      break;
+    }
+  }
+  if (j < len) {
+    const c = s.charCodeAt(j);
+    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
+      return j + 1 - i;
+    }
+  }
+  return 0;
+}
+function writeAt(buf, x, y, content) {
+  if (y < 0 || y >= buf.height) return;
+  if (x < 0 || x >= buf.width) return;
+  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);
+    if (cp < 32 && cp !== 27) {
+      i++;
+      continue;
+    }
+    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, scroll, focused, borderColor, renderedCache) {
+  const { w, h } = rect;
+  const rows = new Array(h);
+  const color = focused ? "cyan" : "gray";
+  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);
+  scroll.setMax(maxScroll);
+  const effectiveOffset = scroll.offset;
+  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 ? "cyan" : "gray";
+  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;
+}
+var COLOR_SGR, cachedBlank, cachedBlankWidth, ANSI_RE;
+var init_render = __esm({
+  "src/tui/render.ts"() {
+    "use strict";
+    COLOR_SGR = {
+      black: 30,
+      red: 31,
+      green: 32,
+      yellow: 33,
+      blue: 34,
+      magenta: 35,
+      cyan: 36,
+      white: 37,
+      gray: 90
+    };
+    cachedBlank = "";
+    cachedBlankWidth = 0;
+    ANSI_RE = /\x1b\[[0-9;]*[a-zA-Z]/g;
+  }
+});
+
+// src/shared/config.ts
+import { readFileSync as readFileSync4 } from "fs";
+function readJsonFile(filePath) {
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function loadConfig(cwd2) {
+  const globalConfig = readJsonFile(globalConfigPath());
+  const projectConfig = readJsonFile(projectConfigPath(cwd2));
+  if (projectConfig.upload !== void 0) {
+    console.warn(
+      "ignoring `upload` block from project-local .sisyphus/config.json \u2014 only the global config can set upload credentials"
+    );
+    delete projectConfig.upload;
+  }
+  const merged = { ...DEFAULT_CONFIG, ...globalConfig, ...projectConfig };
+  if (globalConfig.statusBar || projectConfig.statusBar) {
+    merged.statusBar = {
+      ...merged.statusBar,
+      ...globalConfig.statusBar,
+      ...projectConfig.statusBar,
+      colors: {
+        ...merged.statusBar?.colors,
+        ...globalConfig.statusBar?.colors,
+        ...projectConfig.statusBar?.colors
+      },
+      segments: {
+        ...merged.statusBar?.segments,
+        ...globalConfig.statusBar?.segments,
+        ...projectConfig.statusBar?.segments
+      }
+    };
+  }
+  return merged;
+}
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/shared/config.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT_CONFIG = {
+      model: "claude-opus-4-7[1m]",
+      pollIntervalMs: 5e3,
+      orchestratorEffort: "xhigh",
+      agentEffort: "medium",
+      notifications: {
+        enabled: true,
+        sound: "/System/Library/Sounds/Hero.aiff"
+      },
+      companionPopup: true,
+      requiredPlugins: [
+        { name: "devcore", marketplace: "crouton-kit" }
+      ]
+    };
+  }
+});
+
+// src/daemon/history.ts
+import { appendFileSync, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4, renameSync as renameSync3, readdirSync as readdirSync2, readFileSync as readFileSync5, rmSync as rmSync2, statSync } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import { dirname as dirname3, join as join6 } from "path";
+var init_history = __esm({
+  "src/daemon/history.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// src/daemon/lib/atomic.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import { dirname as dirname4, join as join7 } from "path";
+import { renameSync as renameSync4, writeFileSync as writeFileSync5 } from "fs";
+function atomicWrite(filePath, data) {
+  const dir = dirname4(filePath);
+  const tmpPath = join7(dir, `.atomic.${randomUUID4()}.tmp`);
+  writeFileSync5(tmpPath, data, "utf-8");
+  renameSync4(tmpPath, filePath);
+}
+async function withLock(key, fn) {
+  const prev = locks.get(key) ?? Promise.resolve();
+  let resolve2;
+  const next = new Promise((r) => {
+    resolve2 = r;
+  });
+  locks.set(key, next);
+  await prev;
+  try {
+    return fn();
+  } finally {
+    resolve2();
+    if (locks.get(key) === next) {
+      locks.delete(key);
+    }
+  }
+}
+var locks;
+var init_atomic = __esm({
+  "src/daemon/lib/atomic.ts"() {
+    "use strict";
+    locks = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/shared/shell.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+var init_shell = __esm({
+  "src/shared/shell.ts"() {
+    "use strict";
+  }
+});
+
+// src/daemon/notify.ts
+import { spawn, execFile as execFile2 } from "child_process";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync4 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir3 } from "os";
+var TMUX_SOCKET, SWITCH_SCRIPT;
+var init_notify = __esm({
+  "src/daemon/notify.ts"() {
+    "use strict";
+    init_shell();
+    TMUX_SOCKET = `/tmp/tmux-${process.getuid?.() ?? 0}/default`;
+    SWITCH_SCRIPT = [
+      "#!/bin/bash",
+      'SESSION="$1"',
+      `TMUX_SOCKET="${TMUX_SOCKET}"`,
+      "TMUX=/opt/homebrew/bin/tmux",
+      "",
+      "# Find any attached client (user is likely on a different session)",
+      `CLIENT_TTY=$("$TMUX" -S "$TMUX_SOCKET" list-clients -F '#{client_tty}' 2>/dev/null | head -1)`,
+      '[ -z "$CLIENT_TTY" ] && exit 0',
+      "",
+      "# Switch that client to the target session",
+      '"$TMUX" -S "$TMUX_SOCKET" switch-client -c "$CLIENT_TTY" -t "$SESSION" 2>/dev/null',
+      '"$TMUX" -S "$TMUX_SOCKET" select-window -t "$SESSION" 2>/dev/null',
+      "",
+      "# Bring iTerm2 to front and select the tab with this client",
+      `TTY_SHORT=$(echo "$CLIENT_TTY" | sed 's|/dev/||')`,
+      'osascript -e "',
+      '  tell application \\"iTerm2\\"',
+      "    activate",
+      "    repeat with w in windows",
+      "      tell w",
+      "        repeat with t in tabs",
+      "          tell t",
+      "            repeat with s in sessions",
+      "              tell s",
+      '                if tty contains \\"$TTY_SHORT\\" then',
+      "                  select t",
+      "                  return",
+      "                end if",
+      "              end tell",
+      "            end repeat",
+      "          end tell",
+      "        end repeat",
+      "      end tell",
+      "    end repeat",
+      "  end tell",
+      `" 2>/dev/null || osascript -e 'tell application "iTerm2" to activate' 2>/dev/null`,
+      ""
+    ].join("\n");
+  }
+});
+
+// src/shared/gitignore.ts
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
+var init_gitignore = __esm({
+  "src/shared/gitignore.ts"() {
+    "use strict";
+  }
+});
+
+// src/shared/types.ts
+var init_types = __esm({
+  "src/shared/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/daemon/state.ts
+import { copyFileSync, cpSync, existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync8 } from "fs";
+import { join as join10 } from "path";
+var init_state = __esm({
+  "src/daemon/state.ts"() {
+    "use strict";
+    init_atomic();
+    init_paths();
+    init_gitignore();
+    init_types();
+  }
+});
+
+// src/daemon/ask-store.ts
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync8, readdirSync as readdirSync4 } from "fs";
+function readDecisions(cwd2, sessionId2, askId2) {
+  const p = askDecisionsPath(cwd2, sessionId2, askId2);
+  try {
+    return JSON.parse(readFileSync8(p, { encoding: "utf-8" }));
+  } catch (_e) {
+    return null;
+  }
+}
+function readProgress(cwd2, sessionId2, askId2) {
+  const p = askProgressPath(cwd2, sessionId2, askId2);
+  try {
+    const data = JSON.parse(readFileSync8(p, { encoding: "utf-8" }));
+    if (!Array.isArray(data["responses"])) return null;
+    return { responses: data["responses"], savedAt: data["savedAt"] };
+  } catch (_e) {
+    return null;
+  }
+}
+function writeOutput(cwd2, sessionId2, askId2, responses, completedAt) {
+  atomicWrite(askOutputPath(cwd2, sessionId2, askId2), JSON.stringify({
+    responses,
+    completedAt: completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+}
+function readMeta(cwd2, sessionId2, askId2) {
+  const p = askMetaPath(cwd2, sessionId2, askId2);
+  if (!existsSync7(p)) {
+    return null;
+  }
+  return JSON.parse(readFileSync8(p, "utf-8"));
+}
+async function updateMeta(cwd2, sessionId2, askId2, patch) {
+  return withLock(askId2, () => {
+    const cur = readMeta(cwd2, sessionId2, askId2);
+    if (!cur) {
+      throw new Error(`updateMeta: askId ${askId2} not found`);
+    }
+    const next = { ...cur, ...patch };
+    atomicWrite(askMetaPath(cwd2, sessionId2, askId2), JSON.stringify(next, null, 2));
+    return next;
+  });
+}
+var init_ask_store = __esm({
+  "src/daemon/ask-store.ts"() {
+    "use strict";
+    init_paths();
+    init_config();
+    init_history();
+    init_atomic();
+    init_notify();
+    init_state();
+  }
+});
+
+// src/tui/single-ask.ts
+var single_ask_exports = {};
+__export(single_ask_exports, {
+  runSingleAsk: () => runSingleAsk
+});
+import { existsSync as existsSync11, watchFile, unwatchFile } from "fs";
+import { mountPanel as mountPanel2 } from "@crouton-kit/humanloop";
+async function runSingleAsk(opts) {
+  const { cwd: cwd2, sessionId: sessionId2, askId: askId2 } = opts;
+  const meta = readMeta(cwd2, sessionId2, askId2);
+  if (!meta || meta.status === "answered") {
+    return;
+  }
+  const deck = readDecisions(cwd2, sessionId2, askId2);
+  if (!deck) return;
+  const cleanupTerminal = setupTerminal();
+  let exiting = false;
+  let panel = null;
+  let prevFrame2 = [];
+  let stopKeypress = null;
+  let stopResize = null;
+  const outputPath = askOutputPath(cwd2, sessionId2, askId2);
+  const exit = (code) => {
+    if (exiting) return;
+    exiting = true;
+    try {
+      stopKeypress?.();
+    } catch {
+    }
+    try {
+      stopResize?.();
+    } catch {
+    }
+    try {
+      panel?.unmount();
+    } catch {
+    }
+    try {
+      unwatchFile(outputPath, onExternalChange);
+    } catch {
+    }
+    cleanupTerminal();
+    process.exit(code);
+  };
+  const flushHost = (lines) => {
+    const out = flushFrame(lines, prevFrame2, "\x1B[?25l");
+    writeToStdout(out);
+    prevFrame2 = lines;
+  };
+  const onExternalChange = () => {
+    if (exiting) return;
+    if (!existsSync11(outputPath)) return;
+    exit(0);
+  };
+  let lastResponses = [];
+  const submit = (responses) => {
+    if (exiting) return;
+    void (async () => {
+      const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeOutput(cwd2, sessionId2, askId2, responses, completedAt);
+      try {
+        await updateMeta(cwd2, sessionId2, askId2, { status: "answered", completedAt });
+      } catch {
+      }
+      exit(0);
+    })();
+  };
+  const cols = process.stdout.columns ?? 80;
+  const rows = process.stdout.rows ?? 24;
+  panel = mountPanel2({
+    deck,
+    cols,
+    rows,
+    progressPath: askProgressPath(cwd2, sessionId2, askId2),
+    onProgress: (responses) => {
+      lastResponses = responses;
+      const cur = readMeta(cwd2, sessionId2, askId2);
+      if (cur?.status === "pending") {
+        void updateMeta(cwd2, sessionId2, askId2, { status: "in-progress", startedAt: (/* @__PURE__ */ new Date()).toISOString() }).catch(() => {
+        });
+      }
+      if (panel) flushHost(panel.render());
+    },
+    onComplete: (responses) => {
+      submit(responses);
+    },
+    // Final-phase Enter on an incomplete deck — submit what we have.
+    onExit: () => {
+      submit(lastResponses);
+    }
+  });
+  stopKeypress = startKeypressListener((input, key) => {
+    if (exiting || !panel) return;
+    panel.handleKey(input, key);
+    flushHost(panel.render());
+  });
+  stopResize = onResize(() => {
+    if (exiting || !panel) return;
+    const newCols = process.stdout.columns ?? 80;
+    const newRows = process.stdout.rows ?? 24;
+    panel.handleResize(newCols, newRows);
+    prevFrame2 = [];
+    flushHost(panel.render());
+  });
+  watchFile(outputPath, { interval: 250 }, onExternalChange);
+  if (existsSync11(outputPath)) {
+    exit(0);
+    return;
+  }
+  flushHost(panel.render());
+  await new Promise(() => {
+  });
+}
+var init_single_ask = __esm({
+  "src/tui/single-ask.ts"() {
+    "use strict";
+    init_ask_store();
+    init_paths();
+    init_terminal();
+    init_render();
+  }
+});
+
+// src/tui/index.ts
+init_terminal();
 
 // src/tui/state.ts
 var OPTIONAL_COMPOSE = /* @__PURE__ */ new Set(["resume", "continue"]);
@@ -271,19 +1215,184 @@ function autoExpandCycle(state2) {
 }
 
 // src/tui/app.ts
-import { readFileSync as readFileSync5, existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync10, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
+import { join as join14 } from "path";
 
 // src/tui/input.ts
 import { execSync } from "child_process";
-import { readFileSync as readFileSync2, readdirSync, statSync } from "fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
+import { join as join11 } from "path";
+
+// src/shared/session-export.ts
+init_paths();
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync, readFileSync, mkdirSync, symlinkSync, rmSync, writeFileSync } from "fs";
+import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function buildOutputPath(label, dir) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  mkdirSync(dir, { recursive: true });
+  const base = `sisyphus-${label}-${date}`;
+  let candidate = join2(dir, `${base}.zip`);
+  let counter = 1;
+  while (existsSync(candidate)) {
+    counter++;
+    candidate = join2(dir, `${base}-${counter}.zip`);
+  }
+  return candidate;
+}
+function generateGuide() {
+  return `# Sisyphus Session Export
+
+## Quick Orientation
+
+Start with \`session/state.json\` for the full session state, or \`history/session.json\` for a compact summary with metrics.
+
+## session/
+
+Project-local session data \u2014 the orchestrator's working directory.
+
+### Top-level files
+- **state.json** \u2014 Complete session state: id, task, status, timing, and the full \`agents[]\` array (each agent has id, type, instruction, status, reports, Claude session ID, and resume args)
+- **goal.md** \u2014 The task description; updated if the goal evolves across phases
+- **initial-prompt.md** \u2014 Verbatim user input that started the session
+- **roadmap.md** \u2014 Orchestrator's working memory: current stage, exit criteria, active context files, next steps
+- **strategy.md** \u2014 Work breakdown: completed stages, current stage decomposition (concerns/phases), and what's ahead
+- **digest.json** \u2014 4-field snapshot: \`recentWork\`, \`unusualEvents\`, \`currentActivity\`, \`whatsNext\`
+
+### Subdirectories
+
+**context/** \u2014 Research artifacts produced by agents and consumed by downstream agents
+- \`explore-*.md\` \u2014 Codebase exploration findings (key files, architecture notes)
+- \`requirements*.md/json\` \u2014 Feature requirements (structured + human-readable)
+- \`design*.md/json\` \u2014 Architecture specs, decision records, diagrams
+- \`{agent-id}/plan*.md\` \u2014 Implementation plans (tasks, files to touch, dependencies) \u2014 per plan-lead subdirectory
+- \`e2e-recipe.md\` \u2014 End-to-end validation steps
+- \`review-*.md\` \u2014 Code review findings (severity-ranked)
+- \`completion-summary.md\` \u2014 Final handoff document
+
+**logs/** \u2014 One \`cycle-NNN.md\` per orchestrator cycle. Each logs what happened, agents spawned, user decisions, and key findings.
+
+**prompts/** \u2014 Full agent configs, one set per agent:
+- \`agent-NNN-system.md\` \u2014 System prompt (instructions, tools, output format)
+- \`agent-NNN-run.sh\` \u2014 Executable bash script to resume the agent (contains env, CLI args, instruction)
+- \`agent-NNN-plugin/\` \u2014 Plugin directory (hooks, sub-agent configs)
+
+**reports/** \u2014 Agent deliverables:
+- \`agent-NNN-final.md\` \u2014 Final report (findings, implementation summary, or review results)
+- \`agent-NNN-00N.md\` \u2014 Interim progress reports (optional)
+
+**snapshots/** \u2014 Point-in-time checkpoints (\`snapshots/cycle-N/\`). Each contains state.json, roadmap.md, strategy.md, and logs/ as they were at that cycle boundary. Used for rollback.
+
+**.tui/** \u2014 Lightweight TUI render cache (cycle summaries for display). Regenerable; not primary data.
+
+## history/
+
+Global telemetry from the daemon \u2014 timing, events, and aggregate metrics.
+
+- **events.jsonl** \u2014 Newline-delimited JSON event stream. Each line: \`{ ts, event, sessionId, data }\`. Events include session-start, agent-spawned, agent-completed, cycle-boundary, signals-snapshot, session-end, etc. Complete audit trail.
+- **session.json** \u2014 Summary: id, name, task, status, timing (activeMs, wallClockMs, efficiency), agent/cycle counts, crash/rollback counts, completion report, and a compact agents array.
+`;
+}
+var execFileAsync = promisify(execFile);
+async function exportSessionToZip(sessionId2, cwd2, options) {
+  const reveal = options?.reveal ?? true;
+  const sessDir = sessionDir(cwd2, sessionId2);
+  const histDir = historySessionDir(sessionId2);
+  const sessExists = existsSync(sessDir);
+  const histExists = existsSync(histDir);
+  if (!sessExists && !histExists) {
+    throw new Error(`No data found for session ${sessionId2}`);
+  }
+  let label = sessionId2.slice(0, 8);
+  const stPath = statePath(cwd2, sessionId2);
+  if (existsSync(stPath)) {
+    try {
+      const state2 = JSON.parse(readFileSync(stPath, "utf-8"));
+      if (state2.name) {
+        label = sanitizeName(state2.name);
+      }
+    } catch {
+    }
+  }
+  const dir = options?.outputDir ?? join2(homedir2(), "Downloads");
+  const outputPath = buildOutputPath(label, dir);
+  const tmpDir = `/tmp/sisyphus-export-${sessionId2.slice(0, 8)}-${Date.now()}`;
+  try {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join2(tmpDir, "CLAUDE.md"), generateGuide(), "utf-8");
+    if (sessExists) {
+      symlinkSync(sessDir, join2(tmpDir, "session"));
+    }
+    if (histExists) {
+      symlinkSync(histDir, join2(tmpDir, "history"));
+    }
+    const parts = ["CLAUDE.md", sessExists ? "session/" : "", histExists ? "history/" : ""].filter(Boolean);
+    await execFileAsync("zip", ["-rq", outputPath, ...parts], { cwd: tmpDir });
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+  if (reveal) {
+    try {
+      await execFileAsync("open", ["-R", outputPath]);
+    } catch {
+    }
+  }
+  return outputPath;
+}
+
+// src/tui/input.ts
+init_paths();
 
 // src/tui/lib/tree.ts
-import { join } from "path";
+import { join as join3 } from "path";
 
 // src/tui/lib/format.ts
 import stringWidth from "string-width";
+
+// src/shared/format.ts
+function formatDuration(startOrMs, endIso) {
+  let totalMs;
+  if (typeof startOrMs === "number") {
+    totalMs = startOrMs;
+  } else {
+    const start = new Date(startOrMs).getTime();
+    const end = endIso ? new Date(endIso).getTime() : Date.now();
+    totalMs = end - start;
+  }
+  const totalSeconds = Math.floor(totalMs / 1e3);
+  if (totalSeconds < 0) return "0s";
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h${minutes}m`;
+  if (minutes > 0) return `${minutes}m${seconds}s`;
+  return `${seconds}s`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "active":
+    case "running":
+      return "green";
+    case "completed":
+      return "cyan";
+    case "paused":
+      return "yellow";
+    case "killed":
+    case "crashed":
+      return "red";
+    case "lost":
+      return "gray";
+    default:
+      return "white";
+  }
+}
+
+// src/tui/lib/format.ts
 function formatTimeAgo(iso) {
   const diff = Date.now() - new Date(iso).getTime();
   const minutes = Math.floor(diff / 6e4);
@@ -493,6 +1602,7 @@ function wrapText(text, width) {
 }
 
 // src/tui/lib/tree.ts
+init_paths();
 function sessionSortKey(s) {
   if (s.status === "completed") return 4;
   const open = s.windowAlive ?? false;
@@ -669,7 +1779,7 @@ function buildTree(sessions, selectedSession, expanded, cwd2, polledContextFiles
           expanded: false,
           sessionId: s.id,
           label: filename,
-          filePath: join(contextDir(cwd2, s.id), filename)
+          filePath: join3(contextDir(cwd2, s.id), filename)
         });
       }
     }
@@ -741,6 +1851,1339 @@ function findParentIndex(nodes, index) {
   return 0;
 }
 
+// src/tui/panels/overlays.ts
+init_render();
+
+// src/shared/companion-render.ts
+import stringWidth3 from "string-width";
+function sliceToWidth(s, maxCols) {
+  let w = 0;
+  let i = 0;
+  while (i < s.length) {
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const cw = stringWidth3(ch);
+    if (w + cw > maxCols) break;
+    w += cw;
+    i += ch.length;
+  }
+  return s.slice(0, i);
+}
+var IDLE_HOBBIES = [
+  "reading Camus",
+  "stacking pebbles",
+  "watching clouds",
+  "sketching boulders",
+  "counting stars",
+  "writing haiku",
+  "practicing zen",
+  "studying geology",
+  "polishing rocks",
+  "mapping the hill",
+  "resting",
+  "stargazing",
+  "whittling",
+  "collecting fossils",
+  "napping on summit",
+  "journaling",
+  "stretching",
+  "humming",
+  "doodling",
+  "tending moss",
+  "making tea",
+  "reading Myth of Sisyphus",
+  "reorganizing rocks",
+  "people watching",
+  "whistling"
+];
+var SPINNER_VERBS = [
+  // physical
+  "pushing",
+  "hauling",
+  "heaving",
+  "toiling",
+  "straining",
+  "trudging",
+  "laboring",
+  "rolling",
+  "ascending",
+  "dragging",
+  "shouldering",
+  "hoisting",
+  "lugging",
+  "schlepping",
+  "grinding",
+  "lifting",
+  "bracing",
+  "climbing",
+  "leaning in",
+  "digging in",
+  // philosophical
+  "philosophizing",
+  "contemplating",
+  "pondering",
+  "musing",
+  "ruminating",
+  "reflecting",
+  "meditating",
+  "wondering",
+  "questioning",
+  "theorizing",
+  "considering",
+  "deliberating",
+  "introspecting",
+  "cogitating",
+  "brooding",
+  // endurance
+  "persevering",
+  "enduring",
+  "persisting",
+  "sustaining",
+  "weathering",
+  "carrying on",
+  "pressing on",
+  "holding steady",
+  "keeping at it",
+  "not stopping",
+  // light/silly
+  "napping",
+  "procrastinating",
+  "daydreaming",
+  "vibing",
+  "winging it",
+  "hoping",
+  "improvising",
+  "making do",
+  "whistling"
+];
+function getBaseForm(level) {
+  if (level <= 2) return "(FACE) {BOULDER}";
+  if (level <= 4) return "(FACE)/ {BOULDER}";
+  if (level <= 7) return "/(FACE)/ {BOULDER}";
+  if (level <= 11) return "\\(FACE)/ {BOULDER}";
+  if (level <= 19) return "\u1566(FACE)\u1564 {BOULDER}";
+  return "\u265B\u1566(FACE)\u1564 {BOULDER}";
+}
+var MOOD_FACES = {
+  happy: ["^.^", "^\u203F^", "\u2727\u203F\u2727"],
+  grinding: [">.<", ">_<", "\xF2.\xF3"],
+  frustrated: [">.<#", "\u0CA0_\u0CA0", "\u0CA0\u76CA\u0CA0"],
+  zen: ["\u203E.\u203E", "\u203E\u203F\u203E", "\u02D8\u203F\u02D8"],
+  sleepy: ["-.-)zzZ", "-_-)zzZ", "\u02D8.\u02D8)zzZ"],
+  excited: ["*o*", "*\u25E1*", "\u2726\u25E1\u2726"],
+  existential: ["\u25C9_\u25C9", "\u2299_\u2299", "\u25C9\u2038\u25C9"]
+};
+function getMoodFace(mood, intensity = 0) {
+  const faces = MOOD_FACES[mood];
+  if (!faces) throw new Error(`Unknown mood: ${mood}`);
+  const tier = intensity < 30 ? 0 : intensity <= 70 ? 1 : 2;
+  return faces[tier];
+}
+function getStatCosmetics(stats) {
+  const cosmetics = [];
+  if (stats.wisdom > 5) cosmetics.push("wisps");
+  if (stats.endurance > 36e6) cosmetics.push("trail");
+  if (stats.patience > 50) cosmetics.push("zen-prefix");
+  return cosmetics;
+}
+function getBoulderForm(agentCount, repoNickname) {
+  let boulder;
+  if (agentCount === void 0 || agentCount <= 0) {
+    boulder = "";
+  } else if (agentCount <= 2) {
+    boulder = "o";
+  } else if (agentCount <= 6) {
+    boulder = "O";
+  } else if (agentCount <= 15) {
+    boulder = "\u25C9";
+  } else if (agentCount <= 35) {
+    boulder = "@";
+  } else {
+    boulder = "@@";
+  }
+  if (repoNickname !== void 0) {
+    boulder = `${boulder} "${repoNickname}"`;
+  }
+  return boulder;
+}
+function composeLine(body, cosmetics, boulder) {
+  let b = boulder;
+  let hasZenPrefix = false;
+  if (boulder !== "") {
+    for (const c of cosmetics) {
+      switch (c) {
+        case "wisps":
+          b = `~${b}~`;
+          break;
+        case "trail":
+          b = `${b} ...`;
+          break;
+        case "zen-prefix":
+          hasZenPrefix = true;
+          break;
+      }
+    }
+  } else {
+    if (cosmetics.includes("zen-prefix")) hasZenPrefix = true;
+  }
+  let line = b === "" ? body.replace(" {BOULDER}", "") : body.replace("{BOULDER}", b);
+  if (hasZenPrefix) line = `\u262F ${line}`;
+  return line;
+}
+var MOOD_COLORS = {
+  happy: { ansi: 32, tmux: "green" },
+  grinding: { ansi: 33, tmux: "yellow" },
+  frustrated: { ansi: 31, tmux: "red" },
+  zen: { ansi: 36, tmux: "cyan" },
+  sleepy: { ansi: 90, tmux: "colour245" },
+  excited: { ansi: 97, tmux: "white" },
+  existential: { ansi: 35, tmux: "magenta" }
+};
+function getMoodAnsiCode(mood) {
+  return MOOD_COLORS[mood].ansi;
+}
+function colorize(text, mood, tmux) {
+  const { ansi, tmux: tmuxColor } = MOOD_COLORS[mood];
+  if (tmux) {
+    return `#[fg=${tmuxColor}]${text}#[fg=default]`;
+  }
+  return `\x1B[${ansi}m${text}\x1B[0m`;
+}
+function statSummary(stats) {
+  const endH = Math.floor(stats.endurance / 36e5);
+  return `STR:${stats.strength} END:${endH}h WIS:${stats.wisdom} PAT:${stats.patience}`;
+}
+function renderCompanion(companion, fields, opts) {
+  const hasFace = fields.includes("face");
+  const hasBoulder = fields.includes("boulder");
+  const repoNickname = opts?.repoPath !== void 0 ? companion.repos[opts.repoPath]?.nickname ?? void 0 : void 0;
+  const boulder = getBoulderForm(opts?.agentCount, repoNickname);
+  const cosmetics = getStatCosmetics(companion.stats);
+  let facePart = null;
+  let boulderOnlyPart = null;
+  if (hasFace) {
+    const baseForm = getBaseForm(companion.level);
+    const intensity = companion.debugMood?.scores[companion.mood] ?? 0;
+    const face = getMoodFace(companion.mood, intensity);
+    const bodyWithFace = baseForm.replace("FACE", face);
+    facePart = composeLine(bodyWithFace, cosmetics, boulder);
+  } else if (hasBoulder) {
+    boulderOnlyPart = boulder;
+  }
+  let commentary = fields.includes("commentary") ? companion.lastCommentary?.text ?? "" : null;
+  const parts = [];
+  for (const field of fields) {
+    switch (field) {
+      case "face":
+        if (facePart !== null) parts.push(facePart);
+        break;
+      case "boulder":
+        if (!hasFace && boulderOnlyPart !== null) parts.push(boulderOnlyPart);
+        break;
+      case "title":
+        parts.push(companion.title);
+        break;
+      case "commentary":
+        if (commentary !== null) parts.push(commentary);
+        break;
+      case "mood":
+        parts.push(`[${companion.mood}]`);
+        break;
+      case "level":
+        parts.push(`Lv ${companion.level}`);
+        break;
+      case "stats":
+        parts.push(statSummary(companion.stats));
+        break;
+      case "achievements":
+        parts.push(`${companion.achievements.length} achievements`);
+        break;
+      case "verb": {
+        const idx = (opts?.verbIndex ?? companion.spinnerVerbIndex) % SPINNER_VERBS.length;
+        parts.push(SPINNER_VERBS[idx]);
+        break;
+      }
+      case "hobby": {
+        const hobbyIdx = ((/* @__PURE__ */ new Date()).getHours() + companion.level) % IDLE_HOBBIES.length;
+        parts.push(IDLE_HOBBIES[hobbyIdx]);
+        break;
+      }
+    }
+  }
+  if (opts?.maxWidth !== void 0) {
+    const maxWidth = opts.maxWidth;
+    const joined = parts.join("  ");
+    const joinedWidth = stringWidth3(joined);
+    if (joinedWidth > maxWidth && commentary !== null && commentary.length > 0) {
+      const commentaryIdx = parts.indexOf(commentary);
+      if (commentaryIdx !== -1) {
+        const commentaryWidth = stringWidth3(commentary);
+        const overhead = joinedWidth - commentaryWidth;
+        const available = maxWidth - overhead - 2;
+        if (available < 0) {
+          parts[commentaryIdx] = "";
+        } else {
+          parts[commentaryIdx] = sliceToWidth(commentary, available);
+        }
+        commentary = parts[commentaryIdx];
+      }
+    }
+    const result2 = parts.filter((p) => p.length > 0).join("  ");
+    const resultWidth = stringWidth3(result2);
+    const final = resultWidth > maxWidth ? sliceToWidth(result2, maxWidth - 1) + "\u2026" : result2;
+    return applyColor(final, fields, facePart, companion.mood, opts);
+  }
+  const result = parts.filter((p) => p.length > 0).join("  ");
+  return applyColor(result, fields, facePart, companion.mood, opts);
+}
+function applyColor(result, fields, facePart, mood, opts) {
+  const useColor = opts?.color === true || opts?.tmuxFormat === true;
+  if (!useColor || facePart === null || !fields.includes("face")) return result;
+  const tmux = opts?.tmuxFormat === true;
+  const coloredFace = colorize(facePart, mood, tmux);
+  return result.replace(facePart, coloredFace);
+}
+
+// src/daemon/companion.ts
+init_paths();
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname as dirname2, join as join5 } from "path";
+
+// src/shared/companion-normalize.ts
+function emptyStats() {
+  return { count: 0, mean: 0, m2: 0 };
+}
+function defaultBaselines() {
+  return {
+    sessionMs: emptyStats(),
+    cycleCount: emptyStats(),
+    agentCount: emptyStats(),
+    sessionsPerDay: emptyStats(),
+    recentAgentThroughput: emptyStats(),
+    lastCountedDay: null,
+    pendingDayCount: 0
+  };
+}
+function normalizeCompanion(state2) {
+  if (state2.stats == null) state2.stats = { strength: 0, endurance: 0, wisdom: 0, patience: 0 };
+  if (state2.level == null) state2.level = 1;
+  if (state2.xp == null) state2.xp = 0;
+  if (state2.title == null) state2.title = "Boulder Intern";
+  if (state2.mood == null) state2.mood = "sleepy";
+  if (state2.achievements == null) state2.achievements = [];
+  if (state2.repos == null) state2.repos = {};
+  if (state2.lastCommentary === void 0) state2.lastCommentary = null;
+  if (state2.sessionsCompleted == null) state2.sessionsCompleted = 0;
+  if (state2.sessionsCrashed == null) state2.sessionsCrashed = 0;
+  if (state2.totalActiveMs == null) state2.totalActiveMs = 0;
+  if (state2.consecutiveCleanSessions == null) state2.consecutiveCleanSessions = 0;
+  if (state2.consecutiveDaysActive == null) state2.consecutiveDaysActive = 0;
+  if (state2.lastActiveDate === void 0) state2.lastActiveDate = null;
+  if (state2.taskHistory == null) state2.taskHistory = {};
+  if (state2.dailyRepos == null) state2.dailyRepos = {};
+  if (state2.recentCompletions == null) state2.recentCompletions = [];
+  if (state2.lifetimeAgentsSpawned == null) state2.lifetimeAgentsSpawned = 0;
+  if (state2.consecutiveEfficientSessions == null) state2.consecutiveEfficientSessions = 0;
+  if (state2.consecutiveHighCycleSessions == null) state2.consecutiveHighCycleSessions = 0;
+  if (state2.spinnerVerbIndex == null) state2.spinnerVerbIndex = 0;
+  if (state2.baselines == null) state2.baselines = defaultBaselines();
+  if (state2.baselines.recentAgentThroughput == null) state2.baselines.recentAgentThroughput = emptyStats();
+  if (state2.commentaryHistory == null) state2.commentaryHistory = [];
+  if (state2.feedbackHistory == null) state2.feedbackHistory = [];
+  return state2;
+}
+
+// src/shared/companion-types.ts
+var OBSERVATION_CATEGORIES = ["session-sentiments", "repo-impressions", "user-patterns", "notable-moments"];
+var ACHIEVEMENTS = [
+  // Milestone (25)
+  { id: "first-blood", name: "First Blood", category: "milestone", description: "Complete your first session.", badge: null },
+  { id: "regular", name: "Regular", category: "milestone", description: "Complete 10 sessions.", badge: null },
+  { id: "centurion", name: "Centurion", category: "milestone", description: "Complete 100 sessions.", badge: null },
+  { id: "veteran", name: "Veteran", category: "milestone", description: "Complete 500 sessions.", badge: null },
+  { id: "thousand-boulder", name: "Thousand Boulder", category: "milestone", description: "Complete 1,000 sessions.", badge: null },
+  { id: "cartographer", name: "Cartographer", category: "milestone", description: "Work in 5 different repos.", badge: "+" },
+  { id: "world-traveler", name: "World Traveler", category: "milestone", description: "Work in 15 different repos.", badge: null },
+  { id: "omnipresent", name: "Omnipresent", category: "milestone", description: "Work in 30 different repos.", badge: null },
+  { id: "swarm-starter", name: "Swarm Starter", category: "milestone", description: "Spawn 50 agents over a lifetime.", badge: null },
+  { id: "hive-mind", name: "Hive Mind", category: "milestone", description: "Spawn 500 agents over a lifetime.", badge: null },
+  { id: "legion", name: "Legion", category: "milestone", description: "Spawn 2,000 agents over a lifetime.", badge: null },
+  { id: "army-of-thousands", name: "Army of Thousands", category: "milestone", description: "Spawn 5,000 agents over a lifetime.", badge: null },
+  { id: "singularity", name: "Singularity", category: "milestone", description: "Spawn 10,000 agents over a lifetime.", badge: null },
+  { id: "first-shift", name: "First Shift", category: "milestone", description: "10 hours of total agent active time.", badge: null },
+  { id: "workaholic", name: "Workaholic", category: "milestone", description: "100 hours of total agent active time.", badge: null },
+  { id: "time-lord", name: "Time Lord", category: "milestone", description: "500 hours of total agent active time.", badge: null },
+  { id: "eternal-grind", name: "Eternal Grind", category: "milestone", description: "2,000 hours of total agent active time.", badge: null },
+  { id: "epoch", name: "Epoch", category: "milestone", description: "5,000 hours of total agent active time.", badge: null },
+  { id: "old-growth", name: "Old Growth", category: "milestone", description: "Companion is 14 days old.", badge: null },
+  { id: "seasoned", name: "Seasoned", category: "milestone", description: "Companion is 90 days old.", badge: null },
+  { id: "ancient", name: "Ancient", category: "milestone", description: "Companion is 365 days old.", badge: null },
+  { id: "apprentice", name: "Apprentice", category: "milestone", description: "Reach level 5.", badge: null },
+  { id: "journeyman", name: "Journeyman", category: "milestone", description: "Reach level 15.", badge: null },
+  { id: "master", name: "Master", category: "milestone", description: "Reach level 30.", badge: null },
+  { id: "grandmaster", name: "Grandmaster", category: "milestone", description: "Reach level 50.", badge: null },
+  // Session (19)
+  { id: "marathon", name: "Marathon", category: "session", description: "Complete a session with 15+ agents.", badge: "~^~" },
+  { id: "squad", name: "Squad Up", category: "session", description: "Complete a session with 10+ agents.", badge: null },
+  { id: "battalion", name: "Battalion", category: "session", description: "Complete a session with 25+ agents.", badge: null },
+  { id: "swarm", name: "The Swarm", category: "session", description: "Complete a session with 50+ agents.", badge: null },
+  { id: "blitz", name: "Blitz", category: "session", description: "Complete a session in under 5 minutes.", badge: null },
+  { id: "speed-run", name: "Speed Run", category: "session", description: "Complete a session in under 15 minutes.", badge: null },
+  { id: "flash", name: "Flash", category: "session", description: "Complete a session in under 2 minutes.", badge: null },
+  { id: "flawless", name: "Flawless", category: "session", description: "Complete a session with 10+ agents and zero crashes.", badge: "*" },
+  { id: "speed-demon", name: "Speed Demon", category: "session", description: "10 consecutive sessions completing in 3 or fewer cycles.", badge: "\u26A1" },
+  { id: "iron-will", name: "Iron Will", category: "session", description: "5 consecutive sessions each with 8+ orchestrator cycles.", badge: "[]" },
+  { id: "glass-cannon", name: "Glass Cannon", category: "session", description: "5+ agents, all crashed, but session completed anyway.", badge: null },
+  { id: "solo", name: "Solo", category: "session", description: "Complete a session with exactly one agent.", badge: null },
+  { id: "one-more-cycle", name: "One More Cycle", category: "session", description: "A session with 10+ orchestrator cycles.", badge: null },
+  { id: "deep-dive", name: "Deep Dive", category: "session", description: "A session with 15+ orchestrator cycles.", badge: null },
+  { id: "abyss", name: "Into the Abyss", category: "session", description: "A session with 25+ orchestrator cycles.", badge: null },
+  { id: "eternal-recurrence", name: "Eternal Recurrence", category: "session", description: "A session with 40+ orchestrator cycles.", badge: null },
+  { id: "endurance", name: "Endurance", category: "session", description: "A single session running 4+ hours.", badge: null },
+  { id: "ultramarathon", name: "Ultramarathon", category: "session", description: "A single session running 6+ hours.", badge: null },
+  { id: "one-shot", name: "One Shot", category: "session", description: "Complete with 5+ agents in exactly 1 orchestrator cycle.", badge: null },
+  { id: "quick-draw", name: "Quick Draw", category: "session", description: "First agent spawned within 20s of session start.", badge: null },
+  // Time (6)
+  { id: "night-owl", name: "Night Owl", category: "time", description: "Complete a session started between 1am and 5am.", badge: ")" },
+  { id: "dawn-patrol", name: "Dawn Patrol", category: "time", description: "Session running 3+ hours that spans midnight to 6am.", badge: null },
+  { id: "early-bird", name: "Early Bird", category: "time", description: "Start a session before 6am.", badge: null },
+  { id: "weekend-warrior", name: "Weekend Warrior", category: "time", description: "Complete a session on a Saturday or Sunday.", badge: null },
+  { id: "all-nighter", name: "All-Nighter", category: "time", description: "Single session running 5+ hours.", badge: null },
+  { id: "witching-hour", name: "Witching Hour", category: "time", description: "Start a session between 3am and 4am.", badge: null },
+  // Behavioral (16)
+  { id: "sisyphean", name: "Sisyphean", category: "behavioral", description: "Restart the same task 3+ times.", badge: ";" },
+  { id: "stubborn", name: "Stubborn", category: "behavioral", description: "Restart the same task 5+ times and eventually complete it.", badge: null },
+  { id: "one-must-imagine", name: "One Must Imagine", category: "behavioral", description: "Restart the same task 10+ times.", badge: null },
+  { id: "creature-of-habit", name: "Creature of Habit", category: "behavioral", description: "Visit the same repo 10 times.", badge: null },
+  { id: "loyal", name: "Loyal", category: "behavioral", description: "Visit the same repo 30 times.", badge: null },
+  { id: "wanderer", name: "Wanderer", category: "behavioral", description: "3+ different repos in a single calendar day.", badge: null },
+  { id: "streak", name: "Streak", category: "behavioral", description: "7 consecutive days with at least one session.", badge: null },
+  { id: "iron-streak", name: "Iron Streak", category: "behavioral", description: "14 consecutive days with at least one session.", badge: null },
+  { id: "hot-streak", name: "Hot Streak", category: "behavioral", description: "15 consecutive clean sessions.", badge: null },
+  { id: "momentum", name: "Momentum", category: "behavioral", description: "5 sessions completed within 4 hours.", badge: null },
+  { id: "overdrive", name: "Overdrive", category: "behavioral", description: "Complete 6+ sessions in a single calendar day.", badge: null },
+  { id: "patient-one", name: "Patient One", category: "behavioral", description: "Idle 30+ minutes between cycles in a session.", badge: null },
+  { id: "message-in-a-bottle", name: "Message in a Bottle", category: "behavioral", description: "10+ messages sent to a single session.", badge: null },
+  { id: "deep-conversation", name: "Deep Conversation", category: "behavioral", description: "Send 20+ messages to a single session.", badge: null },
+  { id: "comeback-kid", name: "Comeback Kid", category: "behavioral", description: "Resume a paused/killed session and complete it.", badge: null },
+  { id: "pair-programming", name: "Pair Programming", category: "behavioral", description: "8+ user messages during a single active session.", badge: null }
+];
+
+// src/daemon/companion-memory.ts
+init_paths();
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join4 } from "path";
+import { randomUUID } from "crypto";
+import { z } from "zod";
+
+// src/daemon/haiku.ts
+import { query, createSdkMcpServer } from "@r-cli/sdk";
+
+// src/shared/env.ts
+import { resolve } from "path";
+function augmentedPath() {
+  const rawPath = process.env["PATH"];
+  const basePath = rawPath !== void 0 && rawPath.length > 0 ? rawPath : "/usr/bin:/bin";
+  const home = process.env["HOME"];
+  const candidates = [
+    ...home ? [`${home}/.local/bin`] : [],
+    // Claude CLI, pipx, user-local installs
+    resolve(process.execPath, ".."),
+    // Node.js bin dir (ensures node/npm available)
+    "/opt/homebrew/bin",
+    // Homebrew (Apple Silicon macOS)
+    "/opt/homebrew/sbin",
+    // Homebrew sbin
+    "/usr/local/bin",
+    // Homebrew (Intel macOS), manual installs
+    "/usr/local/sbin",
+    // Manual installs
+    "/opt/local/bin",
+    // MacPorts
+    "/opt/local/sbin",
+    // MacPorts
+    "/home/linuxbrew/.linuxbrew/bin"
+    // Linuxbrew
+  ];
+  const nixProfile = process.env["NIX_PROFILES"];
+  if (nixProfile) {
+    for (const p of nixProfile.split(" ").reverse()) {
+      candidates.push(`${p}/bin`);
+    }
+  }
+  const existing = new Set(basePath.split(":"));
+  const prepend = candidates.filter((dir) => !existing.has(dir));
+  return prepend.length > 0 ? `${prepend.join(":")}:${basePath}` : basePath;
+}
+function execEnv() {
+  return {
+    ...process.env,
+    PATH: augmentedPath()
+  };
+}
+
+// src/daemon/haiku.ts
+var COOLDOWN_MS = 5 * 60 * 1e3;
+
+// src/daemon/companion-memory.ts
+var OBSERVATION_TEXT_REJECT_RE = /[<>]/;
+var CONTROL_CHARS_DETECT_RE = /[\x00-\x1f\x7f]/;
+function isSafeObservationText(text) {
+  if (OBSERVATION_TEXT_REJECT_RE.test(text)) return false;
+  if (CONTROL_CHARS_DETECT_RE.test(text)) return false;
+  return true;
+}
+var writeQueue = Promise.resolve();
+var OBSERVATION_JSON_SCHEMA = {
+  type: "object",
+  properties: {
+    category: {
+      type: "string",
+      enum: [...OBSERVATION_CATEGORIES],
+      description: "Which of the four observation categories best fits this observation"
+    },
+    text: {
+      type: "string",
+      minLength: 10,
+      maxLength: 180,
+      description: "One sentence, first-person, no angle brackets or control characters"
+    }
+  },
+  required: ["category", "text"],
+  additionalProperties: false
+};
+var ObservationZodSchema = z.object({
+  category: z.enum(OBSERVATION_CATEGORIES),
+  text: z.string().min(10).max(180).refine(isSafeObservationText, "contains unsafe characters")
+});
+
+// src/daemon/companion.ts
+function computeLevelProgress(xp) {
+  let threshold = 150;
+  let cumulative = 0;
+  while (cumulative + threshold <= xp) {
+    cumulative += threshold;
+    threshold = Math.floor(threshold * 1.35);
+  }
+  return { xpIntoLevel: xp - cumulative, xpForNextLevel: threshold };
+}
+
+// src/shared/companion-badges.ts
+var BADGE_ART = {
+  // ── Milestone ─────────────────────────────────────────────────────────────
+  "first-blood": [
+    "        \u2571\u2572        ",
+    "       \u2571  \u2572       ",
+    "      \u2571 \u25C6\u25C6 \u2572      ",
+    "     \u2571  \u25C6\u25C6  \u2572     ",
+    "    \u2571   \u25C6\u25C6   \u2572    ",
+    "   \u2571    \u25C6\u25C6    \u2572   ",
+    "  \u2571\u2500\u2500\u2500\u2500\u2500\u25C6\u25C6\u2500\u2500\u2500\u2500\u2500\u2572  ",
+    "  \u2572     \u25C6\u25C6     \u2571  ",
+    "   \u2572    \u25C6\u25C6    \u2571   ",
+    "    \u2572\u2500\u2500\u2500\u25C6\u25C6\u2500\u2500\u2500\u2571    ",
+    "        \u2502\u2502        ",
+    "      \u2550\u2550\u256A\u256A\u2550\u2550      "
+  ],
+  "centurion": [
+    "    \u250C\u2500\u2500\u2550\u2550\u2550\u2550\u2550\u2500\u2500\u2510    ",
+    "    \u2502  \u2554\u2550\u2550\u2550\u2557  \u2502    ",
+    "   \u2571\u2502  \u2551100\u2551  \u2502\u2572   ",
+    "  \u2571 \u2502  \u255A\u2550\u2550\u2550\u255D  \u2502 \u2572  ",
+    " \u2571  \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518  \u2572 ",
+    " \u2572   \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510   \u2571 ",
+    "  \u2572  \u2502 \u2605 \u2605 \u2605 \u2502  \u2571  ",
+    "   \u2572 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518 \u2571   ",
+    "    \u2572\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2571    "
+  ],
+  "thousand-boulder": [
+    "       \u256D\u2501\u2501\u2501\u256E       ",
+    "     \u256D\u2501\u252B1K \u2523\u2501\u256E     ",
+    "   \u256D\u2501\u252B \u2570\u2501\u2501\u2501\u256F \u2523\u2501\u256E   ",
+    "   \u2503  \u25C9\u25C9\u25C9\u25C9\u25C9\u25C9   \u2503   ",
+    "   \u2503 \u25C9\u25C9\u25C9\u25C9\u25C9\u25C9\u25C9\u25C9  \u2503   ",
+    "   \u2503  \u25C9\u25C9\u25C9\u25C9\u25C9\u25C9   \u2503   ",
+    "   \u2570\u2501\u252B       \u2523\u2501\u256F   ",
+    "     \u2570\u2501\u252B   \u2523\u2501\u256F     ",
+    "       \u2570\u2501\u2501\u2501\u256F       "
+  ],
+  "cartographer": [
+    "        N         ",
+    "        \u25B3         ",
+    "   \u256D\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u256E    ",
+    "   \u2502 \xB7  \u2502  \xB7 \u2502    ",
+    "  W\u253C\xB7\xB7\xB7\xB7+\xB7\xB7\xB7\xB7\u253CE   ",
+    "   \u2502 \xB7  \u2502  \xB7 \u2502    ",
+    "   \u2570\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u256F    ",
+    "        \u25BD         ",
+    "        S         "
+  ],
+  "world-traveler": [
+    "      \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u256E      ",
+    "   \u256D\u2500\u2500\u2524      \u251C\u2500\u2500\u256E   ",
+    "  \u2571  \xB7\u2502 \u25E0\u25E1\u25E0  \u2502\xB7  \u2572  ",
+    " \u2502 \xB7  \u2502\u25E0    \u25E1\u2502  \xB7 \u2502 ",
+    " \u2502  \xB7 \u2502 \u25E1\u25E0\u25E1  \u2502 \xB7  \u2502 ",
+    "  \u2572  \xB7\u2502      \u2502\xB7  \u2571  ",
+    "   \u2570\u2500\u2500\u2524      \u251C\u2500\u2500\u256F   ",
+    "      \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u256F      "
+  ],
+  "hive-mind": [
+    "     \u2571\u2572  \u2571\u2572  \u2571\u2572     ",
+    "    \u2571\u25C6\u25C6\u2572\u2571\u25C6\u25C6\u2572\u2571\u25C6\u25C6\u2572    ",
+    "    \u2572\u25C6\u25C6\u2571\u2572\u25C6\u25C6\u2571\u2572\u25C6\u25C6\u2571    ",
+    "   \u2571\u2572\u2571\u2571\u25C6\u2572\u2571\u2571\u25C6\u2572\u2572\u2571\u2572   ",
+    "  \u2571\u25C6\u25C6\u2572\u2572\u25C6\u25C6\u2572\u2572\u25C6\u25C6\u2571\u25C6\u25C6\u2572  ",
+    "  \u2572\u25C6\u25C6\u2571\u2571\u25C6\u25C6\u2571\u2571\u25C6\u25C6\u2572\u25C6\u25C6\u2571  ",
+    "   \u2572\u2571\u2572\u2572\u25C6\u2571\u2572\u2572\u25C6\u2571\u2571\u2572\u2571   ",
+    "    \u2572\u25C6\u25C6\u2571\u2572\u25C6\u25C6\u2571\u2572\u25C6\u25C6\u2571    ",
+    "     \u2572\u2571  \u2572\u2571  \u2572\u2571     "
+  ],
+  "old-growth": [
+    "        \u2571\u2572         ",
+    "       \u2571\u2571\u2572\u2572        ",
+    "      \u2571\u2571  \u2572\u2572       ",
+    "     \u2571\u2571\u2571\u2572\u2571\u2572\u2572\u2572      ",
+    "    \u2571\u2571\u2571    \u2572\u2572\u2572     ",
+    "   \u2571\u2571\u2571\u2571\u2572\u2571\u2572\u2571\u2572\u2572\u2572\u2572    ",
+    "       \u2551\u2551\u2551         ",
+    "       \u2551\u2551\u2551         ",
+    "    \u2550\u2550\u2550\u2569\u2569\u2569\u2550\u2550\u2550      "
+  ],
+  "ancient": [
+    "    \u250C\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2510    ",
+    "    \u2502 \u2502 \u25C9 \u25C9 \u2502 \u2502    ",
+    "    \u2502 \u2502  \u25BD  \u2502 \u2502    ",
+    "  \u2554\u2550\u2567\u2550\u2567\u2550\u2550\u2550\u2550\u2550\u2567\u2550\u2567\u2550\u2557  ",
+    "  \u2551 A N C I E N \u2551  ",
+    "  \u2551     T       \u2551  ",
+    "  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D  ",
+    "   \u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571   ",
+    "   \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594   "
+  ],
+  "regular": [
+    "      \u256D\u2500\u2500\u2500\u2500\u2500\u256E      ",
+    "    \u256D\u2500\u2524  10 \u251C\u2500\u256E    ",
+    "   \u2571  \u2570\u2500\u2500\u2500\u2500\u2500\u256F  \u2572   ",
+    "  \u2502   \u256D\u2500\u2500\u2500\u2500\u2500\u256E   \u2502  ",
+    "  \u2502   \u2502  \u25C9  \u2502   \u2502  ",
+    "  \u2502   \u2570\u2500\u2500\u2500\u2500\u2500\u256F   \u2502  ",
+    "   \u2572            \u2571   ",
+    "    \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F   "
+  ],
+  "veteran": [
+    "   \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557   ",
+    "   \u2551  \u2554\u2550\u2550\u2550\u2550\u2550\u2557  \u2551   ",
+    "   \u2551  \u2551  V  \u2551  \u2551   ",
+    "   \u2551  \u2551 500 \u2551  \u2551   ",
+    "   \u2551  \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u2551   ",
+    "   \u2551 \u2605 \u2605 \u2605 \u2605 \u2605 \u2551   ",
+    "   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D   ",
+    "    \u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571    ",
+    "    \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594    "
+  ],
+  "swarm-starter": [
+    "                    ",
+    "   \u25C6  \u25C6  \u25C6  \u25C6  \u25C6   ",
+    "  \u25C6  \u25C6  \u25C6  \u25C6  \u25C6    ",
+    "   \u25C6  \u25C6  \u25C6  \u25C6  \u25C6   ",
+    "  \u25C6  \u25C6  \u25C6  \u25C6  \u25C6    ",
+    "   \u25C6  \u25C6  \u25C6  \u25C6  \u25C6   ",
+    "                    ",
+    "     \xB7 50 out \xB7     "
+  ],
+  "legion": [
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6   ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6   ",
+    "  \u25C6\u25C6\u25C6  2K  \u25C6\u25C6\u25C6\u25C6\u25C6   ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6   ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6   ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6   ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6   "
+  ],
+  "army-of-thousands": [
+    " \xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7 ",
+    " \xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6 ",
+    " \xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7 ",
+    " \xB7\u25C6\xB7\u25C6\xB75K\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7 ",
+    " \xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7 ",
+    " \xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6 ",
+    " \xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7 ",
+    " \xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6 ",
+    " \xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7\xB7 "
+  ],
+  "singularity": [
+    "  \u2572  \u2502  \u2571  \u2500  \xB7   ",
+    "   \u2572 \u2502 \u2571           ",
+    "    \u2572\u2502\u2571            ",
+    " \u2500\u2500\u2500\u2500\u25C6\u2500\u2500\u2500\u2500         ",
+    "    \u2571\u2502\u2572            ",
+    "   \u2571 \u2502 \u2572           ",
+    "  \u2571  \u2502  \u2572  \u2500  \xB7   ",
+    "   10000 agents    "
+  ],
+  "first-shift": [
+    "      \u250C\u2500\u2500\u2500\u2500\u2500\u2510      ",
+    "      \u2502 \u2572   \u2502      ",
+    "     \u2571\u2502  \u2572  \u2502\u2572     ",
+    "    \u2571 \u2502   \u2572 \u2502 \u2572    ",
+    "    \u2572 \u2502    \u2572\u2502 \u2571    ",
+    "     \u2572\u2502     \u2502\u2571     ",
+    "      \u2502   \u2571 \u2502      ",
+    "      \u2514\u2500\u2500\u2500\u2500\u2500\u2518      ",
+    "       10 hrs       "
+  ],
+  "workaholic": [
+    "     \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E    ",
+    "    \u2571  12       \u2572   ",
+    "   \u2502 \xB7    \u2502      \u2502  ",
+    "   \u25029  \xB7  \u2502    3 \u2502  ",
+    "   \u2502       \u2572     \u2502  ",
+    "    \u2572      6 \xB7  \u2571   ",
+    "     \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F    ",
+    "       100 hrs       "
+  ],
+  "time-lord": [
+    "    \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557   ",
+    "   \u2571             \u2572  ",
+    "  \u2502 \xB7 11 12 1 \xB7   \u2502 ",
+    "  \u2502 10  \u2572    2    \u2502 ",
+    "  \u2502 9    \xB7    3   \u2502 ",
+    "  \u2502  8       4    \u2502 ",
+    "   \u2572   7   5     \u2571  ",
+    "    \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D   ",
+    "       500 hrs       "
+  ],
+  "eternal-grind": [
+    "    \u256D\u2500\u2500\u2500\u256E   \u256D\u2500\u2500\u2500\u256E   ",
+    "   \u2571     \u2572 \u2571     \u2572  ",
+    "  \u2502   \u221E   \u2573   \u221E   \u2502 ",
+    "   \u2572     \u2571 \u2572     \u2571  ",
+    "    \u2570\u2500\u2500\u2500\u256F   \u2570\u2500\u2500\u2500\u256F   ",
+    "      \u250C\u2500\u2500\u2500\u2500\u2500\u2510       ",
+    "      \u2502 \u2572 \u2571 \u2502       ",
+    "      \u2502  \xD7  \u2502       ",
+    "      \u2514\u2500\u2500\u2500\u2500\u2500\u2518       "
+  ],
+  "epoch": [
+    "      \xB7  \u2605  \xB7       ",
+    "   \xB7    \u2571\u2502\u2572    \xB7    ",
+    "    \u2572  \u2571 \u2502 \u2572  \u2571     ",
+    "     \u2572\u2571  \u2502  \u2572\u2571      ",
+    "  \u2500\u2500\u2500\u2500\u25C6\u2500\u2500\u253C\u2500\u2500\u25C6\u2500\u2500\u2500\u2500   ",
+    "     \u2571\u2572  \u2502  \u2571\u2572      ",
+    "    \u2571  \u2572 \u2502 \u2571  \u2572     ",
+    "   \xB7    \u2572\u2502\u2571    \xB7    ",
+    "      5000 hrs       "
+  ],
+  "seasoned": [
+    "        \u2571\u2572          ",
+    "       \u2571  \u2572         ",
+    "      \u2571\u2571\u2572\u2571\u2572\u2572        ",
+    "     \u2571\u2571    \u2572\u2572     ",
+    "    \u2571\u2571\u2571\u2571\u2572\u2571\u2572\u2572\u2572\u2572    ",
+    "        \u2551\u2551         ",
+    "   \u2500\u2500\u2500\u2500\u2500\u2568\u2568\u2500\u2500\u2500\u2500\u2500   ",
+    "  \u2572\u2572\u2572\u2572\u2572\u2572\u2572\u2572\u2572\u2572\u2572\u2572\u2572    ",
+    "    90 day roots     "
+  ],
+  "omnipresent": [
+    "         N          ",
+    "     \xB7   \u25B3   \xB7      ",
+    "   NW  \u256D\u2500\u253C\u2500\u256E  NE   ",
+    "  \xB7  \u256D\u2500\u2524\xB7+\xB7\u251C\u2500\u256E  \xB7  ",
+    "  W\u2500\u2500\u2524\xB7\u2502 \xB7 \u2502\xB7\u251C\u2500\u2500E   ",
+    "  \xB7  \u2570\u2500\u2524\xB7+\xB7\u251C\u2500\u256F  \xB7  ",
+    "   SW  \u2570\u2500\u253C\u2500\u256F  SE   ",
+    "     \xB7   \u25BD   \xB7      ",
+    "         S          "
+  ],
+  "apprentice": [
+    "                    ",
+    "         \u2571\u2572         ",
+    "        \u2571  \u2572        ",
+    "       \u2571    \u2572       ",
+    "      \u2571      \u2572      ",
+    "     \u2571\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2572     ",
+    "    \u2571 level 5  \u2572   ",
+    "    \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594    "
+  ],
+  "journeyman": [
+    "        \u2571\u2572          ",
+    "       \u2571  \u2572   \u2571\u2572    ",
+    "      \u2571    \u2572 \u2571  \u2572   ",
+    "     \u2571      \u2573    \u2572  ",
+    "    \u2571      \u2571 \u2572    \u2572 ",
+    "   \u2571\u2500\u2500\u2500\u2500\u2500\u2500\u2571\u2500\u2500\u2500\u2572\u2500\u2500\u2500\u2500\u2572",
+    "  \u2571  level 15       ",
+    "  \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594  "
+  ],
+  "master": [
+    "       \u2605\u2572\u2571\u2605         ",
+    "        \u2571\u2572          ",
+    "       \u2571  \u2572         ",
+    "      \u2571\u2571\u2572\u2571\u2572\u2572        ",
+    "     \u2571\u2571    \u2572\u2572       ",
+    "    \u2571\u2571      \u2572\u2572      ",
+    "   \u2571\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2572\u2572     ",
+    "  \u2571  level 30  \u2572    ",
+    "  \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594    "
+  ],
+  "grandmaster": [
+    "      \u2605 \u2605 \u2605         ",
+    "       \u2572\u2502\u2571          ",
+    "        \u2571\u2572          ",
+    "       \u2571  \u2572         ",
+    "      \u2571\u2571\u2572\u2571\u2572\u2572        ",
+    "     \u2571\u2571    \u2572\u2572       ",
+    "    \u2571\u2571  \u2605   \u2572\u2572      ",
+    "   \u2571\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2572\u2572     ",
+    "  \u2571  level 50  \u2572    "
+  ],
+  // ── Session ───────────────────────────────────────────────────────────────
+  "marathon": [
+    "  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E  ",
+    "  \u2502 \u2571\u2572 \u2571\u2572 \u2571\u2572 \u2571\u2572  \u2502  ",
+    "  \u2502\u2571  \u2573  \u2573  \u2573  \u2572 \u2502  ",
+    "  \u2502   \u2571\u2572 \u2571\u2572 \u2571\u2572   \u2502  ",
+    "  \u2502  \u2571  \u2573  \u2573  \u2572  \u2502  ",
+    "  \u2502 \u2571  \u2571 \u2572\u2571 \u2572  \u2572 \u2502  ",
+    "  \u2502\u2571  \u2571      \u2572  \u2572\u2502  ",
+    "  \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524  ",
+    "  \u2502   ~  ^  ~    \u2502  ",
+    "  \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F  "
+  ],
+  "blitz": [
+    "       \u2571\u2571         ",
+    "      \u2571\u2571          ",
+    "     \u2571\u2571           ",
+    "    \u2571\u2571\u2571\u2571\u2571\u2571        ",
+    "       \u2571\u2571         ",
+    "      \u2571\u2571          ",
+    "     \u2571\u2571           ",
+    "    \u2571\u2571             "
+  ],
+  "speed-run": [
+    "    \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E    ",
+    "   \u2571            \u2572   ",
+    "  \u2502   10   \u2571\u2571    \u2502  ",
+    "  \u2502   \xB7   \u2571\u2571     \u2502  ",
+    "  \u2502  \u2571   \u2571\u2571      \u2502  ",
+    "  \u2502 \u2571   \u2571\u2571       \u2502  ",
+    "   \u2572   \u2571\u2571       \u2571   ",
+    "    \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F    "
+  ],
+  "flawless": [
+    "      \u2726       \u2726      ",
+    "   \u2726     \u2571\u2572     \u2726   ",
+    "      \u2554\u2550\u2550\u2567\u2550\u2550\u2550\u2557      ",
+    "   \u2726  \u2551      \u2551  \u2726   ",
+    "      \u2551   \u25C6  \u2551       ",
+    "      \u2551      \u2551       ",
+    "   \u2726  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D  \u2726   ",
+    "      \u2726       \u2726      "
+  ],
+  "speed-demon": [
+    "                    ",
+    "       \u2571\u2571          ",
+    "      \u2571\u2571           ",
+    "     \u2571\u2571\u2571\u2571\u2571\u2571        ",
+    "        \u2571\u2571         ",
+    "       \u2571\u2571          ",
+    "    \u26A1 \u22643 \u26A1        ",
+    "    x10 streak      "
+  ],
+  "iron-will": [
+    "   \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557   ",
+    "   \u2551 \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510 \u2551   ",
+    "   \u2551 \u2502\u2554\u2550\u2550\u2550\u2550\u2550\u2557\u2502 \u2551   ",
+    "   \u2551 \u2502\u2551 8+  \u2551\u2502 \u2551   ",
+    "   \u2551 \u2502\u2551cycle\u2551\u2502 \u2551   ",
+    "   \u2551 \u2502\u255A\u2550\u2550\u2550\u2550\u2550\u255D\u2502 \u2551   ",
+    "   \u2551 \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518 \u2551   ",
+    "   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D   "
+  ],
+  "glass-cannon": [
+    "        \u2571\u2572         ",
+    "       \u2571\u2571\u2572\u2572        ",
+    "      \u2571\u2571  \u2572\u2572       ",
+    "     \u2571\u2571 \u2573\u2573 \u2572\u2572      ",
+    "    \u2571\u2571  \u2573\u2573  \u2572\u2572     ",
+    "    \u2572\u2572  \u2573\u2573  \u2571\u2571     ",
+    "     \u2572\u2572    \u2571\u2571      ",
+    "      \u2572\u2572  \u2571\u2571       ",
+    "       \u2572\u2572\u2571\u2571        ",
+    "     \u2550\u2550\u2550\u2567\u2567\u2550\u2550\u2550      "
+  ],
+  "solo": [
+    "                    ",
+    "     \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E   ",
+    "     \u2502         \u2502   ",
+    "     \u2502    \u25C6    \u2502   ",
+    "     \u2502         \u2502   ",
+    "     \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F   ",
+    "                    "
+  ],
+  "one-more-cycle": [
+    "     \u256D\u2500\u2500\u2192\u2500\u2500\u256E       ",
+    "     \u2502     \u2502       ",
+    "     \u2191  \u221E  \u2193       ",
+    "     \u2502     \u2502       ",
+    "     \u2570\u2500\u2500\u2190\u2500\u2500\u256F       ",
+    "                    ",
+    "    \u256D\u2500\u2500\u2192\u2500\u2500\u256E        ",
+    "    \u2502     \u2502        ",
+    "    \u2191  \u221E  \u2193        ",
+    "    \u2502     \u2502        ",
+    "    \u2570\u2500\u2500\u2190\u2500\u2500\u256F        "
+  ],
+  "quick-draw": [
+    "         \u2571\u2502        ",
+    "        \u2571 \u2502        ",
+    "     \u2500\u2500\u2571\u2500\u2500\u2502\u2500\u2500      ",
+    "      \u2571   \u2502        ",
+    "     \u2571  \u256D\u2500\u256F        ",
+    "    \u2571   \u2502          ",
+    "   \u2571  \u256D\u2500\u256F          ",
+    "      \u2502            ",
+    "    \u2500\u2500\u2568\u2500\u2500           "
+  ],
+  "squad": [
+    "                    ",
+    "   \u25C6  \u25C6  \u25C6  \u25C6      ",
+    "                    ",
+    "   \u25C6  \u25C6  \u25C6  \u25C6      ",
+    "                    ",
+    "   \u25C6  \u25C6             ",
+    "                    ",
+    "    \xB7 10 strong \xB7   "
+  ],
+  "battalion": [
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6    ",
+    "                    ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6    ",
+    "                    ",
+    "  \u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6\u25C6    ",
+    "                    ",
+    "    \xB7 25 strong \xB7   "
+  ],
+  "swarm": [
+    " \u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7  ",
+    " \xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6  ",
+    " \u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7  ",
+    " \xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6  ",
+    " \u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7  ",
+    " \xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6\xB7\u25C6  ",
+    "    \xB7 50 strong \xB7   "
+  ],
+  "deep-dive": [
+    "   \u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248    ",
+    "       \u2193            ",
+    "      \u2571\u2502\u2572           ",
+    "       \u2502            ",
+    "       \u2502            ",
+    "       \u25BC            ",
+    "   \xB7 \xB7 \xB7 \xB7 \xB7 \xB7 \xB7    ",
+    "      15 deep        "
+  ],
+  "abyss": [
+    "  \u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248    ",
+    "       \u2502            ",
+    "       \u2502            ",
+    "       \u2502            ",
+    "       \u25BC            ",
+    "       \u2502            ",
+    "       \u2502            ",
+    "       \u25BC            ",
+    "      25 deep        "
+  ],
+  "eternal-recurrence": [
+    "    \u256D\u2500\u2500\u2192\u2500\u2500\u256E         ",
+    "   \u2571   \u221E   \u2572        ",
+    "  \u2502  \u256D\u2500\u2500\u2500\u256E  \u2502       ",
+    "  \u2502  \u2502 \u221E \u2502  \u2502       ",
+    "  \u2502  \u2570\u2500\u2500\u2500\u256F  \u2502       ",
+    "   \u2572   \u221E   \u2571        ",
+    "    \u2570\u2500\u2500\u2190\u2500\u2500\u256F         ",
+    "      40 cycles      "
+  ],
+  "endurance": [
+    "                    ",
+    "  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557  ",
+    "  \u2551\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2551  ",
+    "  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D  ",
+    "                    ",
+    "  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557  ",
+    "  \u2551\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593    \u2551  ",
+    "  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D  ",
+    "       4 hours       "
+  ],
+  "ultramarathon": [
+    "  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557  ",
+    "  \u2551\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2551  ",
+    "  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D  ",
+    "   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2192   ",
+    "                \xB7   ",
+    "               \xB7    ",
+    "              \xB7     ",
+    "             \xB7      ",
+    "       6 hours       "
+  ],
+  "one-shot": [
+    "     \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E      ",
+    "     \u2502 \u256D\u2500\u2500\u2500\u256E \u2502      ",
+    "     \u2502 \u2502 \u25C9 \u2502 \u2502      ",
+    "     \u2502 \u2570\u2500\u2500\u2500\u256F \u2502      ",
+    "     \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F      ",
+    "         \u2191          ",
+    "        \u2571\u2502          ",
+    "       \u2571 \u2502          ",
+    "    \u2192 \u25C9  \u2502          "
+  ],
+  "flash": [
+    "       \u2571\u2571           ",
+    "      \u2571\u2571            ",
+    "     \u2571\u2571             ",
+    "    \u2571\u2571\u2571\u2571\u2571\u2571          ",
+    "       \u2571\u2571           ",
+    "      \u2571\u2571            ",
+    "     \u2571\u2571             ",
+    "    \u2571\u2571              ",
+    "    < 2 min          "
+  ],
+  // ── Time ──────────────────────────────────────────────────────────────────
+  "night-owl": [
+    "       \u263D            ",
+    "    \u256D\u2500\u2500\u2500\u2500\u2500\u256E    \xB7    ",
+    "   \u2571  \u25C9 \u25C9  \u2572   \xB7   ",
+    "  \u2502    \u25BD    \u2502  \xB7    ",
+    "  \u2502  \u2571\u2500\u2500\u2500\u2572  \u2502       ",
+    "   \u2572\u2571     \u2572\u2571        ",
+    "   \u2571\u2572     \u2571\u2572   \xB7    ",
+    "  \u2571  \u2572\u2500\u2500\u2500\u2571  \u2572  \xB7   ",
+    "  \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594       "
+  ],
+  "dawn-patrol": [
+    "                    ",
+    "  \u2500 \u2500 \u2500 \u2500 \u2500 \u2500 \u2500 \u2500  ",
+    "   \u2572  \u2502  \u2571         ",
+    "    \u2572 \u2502 \u2571          ",
+    " \u2500\u2500\u2500\u2500\u25D1\u2500\u2500\u2500\u2500         ",
+    " \u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593  ",
+    " \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591  ",
+    "                    "
+  ],
+  "early-bird": [
+    "            \u2571\u2571      ",
+    "    \u25E0      \u2571\u2571       ",
+    "   \u2571 \u2572   \u2571\u2571        ",
+    "  \u2502 \u25C9 \u2572>\u2571          ",
+    "  \u2502   \u2550\u2571           ",
+    "   \u2572  \u2571            ",
+    "    \u2572\u2571\u2572            ",
+    "     \u2572 \u2572           ",
+    "      \u2594\u2594           "
+  ],
+  "weekend-warrior": [
+    "   \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557   ",
+    "   \u2551 S M T W T \u2551   ",
+    "   \u2551           \u2551   ",
+    "   \u2551         \u25C6 \u2551   ",
+    "   \u2551 \u25C6         \u2551   ",
+    "   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D   "
+  ],
+  "all-nighter": [
+    "     \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E    ",
+    "    \u2571  12       \u2572   ",
+    "   \u2502 \xB7    \u2502      \u2502  ",
+    "   \u25029     \u2502    3 \u2502  ",
+    "   \u2502      \xB7      \u2502  ",
+    "    \u2572      6    \u2571   ",
+    "     \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F    ",
+    "       \u221E \u221E \u221E        "
+  ],
+  "witching-hour": [
+    "    \xB7  \xB7  \u2726  \xB7  \xB7   ",
+    "   \xB7    \u2571\u2572    \xB7     ",
+    "      \u2571    \u2572        ",
+    "     \u2502 3:00 \u2502       ",
+    "     \u2502  AM  \u2502       ",
+    "      \u2572    \u2571        ",
+    "   \xB7    \u2572\u2571    \xB7     ",
+    "    \xB7  \xB7  \u2726  \xB7  \xB7   "
+  ],
+  // ── Behavioral ────────────────────────────────────────────────────────────
+  "sisyphean": [
+    "          \u2571         ",
+    "         \u2571  \u25C9       ",
+    "        \u2571 \u25C9\u25C9\u25C9       ",
+    "       \u2571  \u25C9\u25C9\u25C9       ",
+    "      \u2571    \u25C9        ",
+    "     \u2571     ;        ",
+    "    \u2571    (>.<)      ",
+    "   \u2571    \u2571\u2571  \u2572\u2572      ",
+    "  \u2571    \u2571      \u2572     "
+  ],
+  "stubborn": [
+    "     \u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571      ",
+    "    \u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571      ",
+    "         \u25C9          ",
+    "        \u25C9\u25C9\u25C9         ",
+    "       (>.<)        ",
+    "     \u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571      ",
+    "    \u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571\u2571      ",
+    "         \u2713          "
+  ],
+  "creature-of-habit": [
+    "   \u256D\u2500\u2500\u2500\u256E \u256D\u2500\u2500\u2500\u256E     ",
+    "   \u2502 \u2192 \u2502\u2192\u2502 \u2192 \u2502\u2192    ",
+    "   \u2570\u2500\u2500\u2500\u256F \u2570\u2500\u2500\u2500\u256F     ",
+    "   \u256D\u2500\u2500\u2500\u256E \u256D\u2500\u2500\u2500\u256E     ",
+    "   \u2502 \u2192 \u2502\u2192\u2502 \u2192 \u2502\u2192    ",
+    "   \u2570\u2500\u2500\u2500\u256F \u2570\u2500\u2500\u2500\u256F     ",
+    "   \u256D\u2500\u2500\u2500\u256E \u256D\u2500\u2500\u2500\u256E     ",
+    "   \u2502 \u2192 \u2502\u2192\u2502 \u2192 \u2502\u2192    ",
+    "   \u2570\u2500\u2500\u2500\u256F \u2570\u2500\u2500\u2500\u256F     "
+  ],
+  "loyal": [
+    "      \u2571\u2572            ",
+    "     \u2571  \u2572           ",
+    "    \u2571 \u2665\u2665 \u2572          ",
+    "   \u2571  \u2665\u2665  \u2572         ",
+    "   \u2572  50  \u2571         ",
+    "    \u2572    \u2571          ",
+    "     \u2572  \u2571           ",
+    "      \u2572\u2571            "
+  ],
+  "wanderer": [
+    "   \xB7    \xB7    \xB7      ",
+    "    \u2572   \u2502   \u2571       ",
+    "     \u2572  \u2502  \u2571        ",
+    "      \xB7 + \xB7         ",
+    "     \u2571  \u2502  \u2572        ",
+    "    \u2571   \u2502   \u2572       ",
+    "   \xB7    \xB7    \xB7      "
+  ],
+  "streak": [
+    "  \u2554\u2550\u2550\u2557\u2554\u2550\u2550\u2557\u2554\u2550\u2550\u2557\u2554\u2550\u2550\u2557  ",
+    "  \u2551M \u2551\u2551T \u2551\u2551W \u2551\u2551T \u2551  ",
+    "  \u2551\u25C6 \u2551\u2551\u25C6 \u2551\u2551\u25C6 \u2551\u2551\u25C6 \u2551  ",
+    "  \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D  ",
+    "  \u2554\u2550\u2550\u2557\u2554\u2550\u2550\u2557\u2554\u2550\u2550\u2557      ",
+    "  \u2551F \u2551\u2551S \u2551\u2551S \u2551      ",
+    "  \u2551\u25C6 \u2551\u2551\u25C6 \u2551\u2551\u25C6 \u2551      ",
+    "  \u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D\u255A\u2550\u2550\u255D      "
+  ],
+  "hot-streak": [
+    "       \u2571\u2572           ",
+    "      \u2571\u2571\u2572\u2572          ",
+    "     \u2571\u2571\u25C6\u25C6\u2572\u2572         ",
+    "    \u2571\u2571 \u25C6\u25C6 \u2572\u2572        ",
+    "    \u2572\u2572 \u25C6\u25C6 \u2571\u2571        ",
+    "     \u2572\u2572\u25C6\u25C6\u2571\u2571         ",
+    "      \u2572\u2572\u2571\u2571          ",
+    "    \xD77 clean        "
+  ],
+  "momentum": [
+    "   \u25C9        \u25C9       ",
+    "   \u2502\u2572      \u2571\u2502       ",
+    "   \u2502 \u2572    \u2571 \u2502       ",
+    "   \u2502  \u2572  \u2571  \u2502       ",
+    "   \u2502   \u25C9\u25C9   \u2502       ",
+    "   \u2502  \u2571  \u2572  \u2502       ",
+    "   \u2502 \u2571    \u2572 \u2502       ",
+    "   \u2502\u2571      \u2572\u2502       ",
+    "   \u25C9        \u25C9       "
+  ],
+  "patient-one": [
+    "     \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E      ",
+    "     \u2502 \u203E.\u203E   \u2502      ",
+    "     \u2502       \u2502      ",
+    "     \u2502  zzz  \u2502      ",
+    "     \u2502   zz  \u2502      ",
+    "     \u2502    z  \u2502      ",
+    "     \u2502       \u2502      ",
+    "     \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F      ",
+    "      30 min+       "
+  ],
+  "message-in-a-bottle": [
+    "     \u256D\u2500\u256E            ",
+    "     \u2502\xD7\u2502            ",
+    "   \u256D\u2500\u2534\u2500\u2534\u2500\u256E          ",
+    "   \u2502 \u2591\u2591\u2591 \u2502          ",
+    "   \u2502 \u2591\u2591\u2591 \u2502          ",
+    "   \u2502 \u2591\u2591\u2591 \u2502          ",
+    "   \u2570\u2500\u2500\u2500\u2500\u2500\u256F          ",
+    "  \u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248\u2248         ",
+    "   \u2248\u2248\u2248\u2248\u2248\u2248\u2248          "
+  ],
+  "comeback-kid": [
+    "    \u2571\u2572     \u2571\u2572       ",
+    "   \u2571  \u2572   \u2571  \u2572      ",
+    "  \u2571    \u2572 \u2571    \u2572     ",
+    " \u2571      \u2573      \u2572    ",
+    " \u2572      \u2571\u2572     \u2571    ",
+    "  \u2572    \u2571  \u2572   \u2571     ",
+    "   \u2572  \u2571    \u2572 \u2571      ",
+    "    \u2572\u2571      \u2572\u2571  \u2713   "
+  ],
+  "pair-programming": [
+    "   \u256D\u2500\u2500\u2500\u2500\u2500\u256E\u256D\u2500\u2500\u2500\u2500\u2500\u256E   ",
+    "   \u2502 \u25C9 \u25C9 \u2502\u2502 \u25C9 \u25C9 \u2502   ",
+    "   \u2502  \u25BD  \u2502\u2502  \u25BD  \u2502   ",
+    "   \u2570\u2500\u2500\u252C\u2500\u2500\u256F\u2570\u2500\u2500\u252C\u2500\u2500\u256F   ",
+    "      \u2502 \u2571\u2500\u2500\u2572 \u2502      ",
+    "      \u2502\u2571    \u2572\u2502      ",
+    "      \u2571  \u2550\u2550  \u2572      ",
+    "     \u2571  \u2550\u2550\u2550\u2550  \u2572     ",
+    "     \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594     "
+  ],
+  "overdrive": [
+    "    \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E    ",
+    "   \u2571  \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u256E  \u2572   ",
+    "  \u2502  \u2571   \xD76   \u2572  \u2502  ",
+    "  \u2502 \u2502    \u25C9     \u2502 \u2502  ",
+    "  \u2502  \u2572         \u2571  \u2502  ",
+    "   \u2572   \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u256F   \u2571  ",
+    "    \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F    ",
+    "     same day \xD76    "
+  ],
+  "iron-streak": [
+    "  \u2554\u2550\u2550\u2557\u2500\u2554\u2550\u2550\u2557\u2500\u2554\u2550\u2550\u2557   ",
+    "  \u2551\u25C6 \u2551 \u2551\u25C6 \u2551 \u2551\u25C6 \u2551   ",
+    "  \u255A\u2550\u2550\u255D\u2500\u255A\u2550\u2550\u255D\u2500\u255A\u2550\u2550\u255D   ",
+    "    \u2502         \u2502     ",
+    "  \u2554\u2550\u2550\u2557\u2500\u2554\u2550\u2550\u2557\u2500\u2554\u2550\u2550\u2557   ",
+    "  \u2551\u25C6 \u2551 \u2551\u25C6 \u2551 \u2551\u25C6 \u2551   ",
+    "  \u255A\u2550\u2550\u255D\u2500\u255A\u2550\u2550\u255D\u2500\u255A\u2550\u2550\u255D   ",
+    "     14 day chain   "
+  ],
+  "deep-conversation": [
+    "     \u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E    ",
+    "    \u2571  \u256D\u2500\u2500\u256E 20  \u2572   ",
+    "   \u2502   \u2502  \u2502      \u2502  ",
+    "   \u2502   \u2570\u2500\u2500\u256F      \u2502  ",
+    "   \u2502  \xB7 \xB7 \xB7 \xB7 \xB7  \u2502  ",
+    "    \u2572            \u2571   ",
+    "     \u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F   ",
+    "      \u2572             ",
+    "       \u25CF            "
+  ],
+  "one-must-imagine": [
+    "   \u25C9\u25C9\u25C9\u25C9\u25C9            ",
+    "  \u2571  \u25C9\u25C9\u25C9\u25C9           ",
+    " \u2571   \u25C9 \u2571  \u2190\u2500\u256E      ",
+    "\u2571  (>.<)    \u2502       ",
+    "   \u2571\u2571  \u2572\u2572   \u2502       ",
+    "  \u2571      \u2572  \u2502       ",
+    " \u2571        \u2572\u2500\u256F       ",
+    " \u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594\u2594        ",
+    "  \xD710 restarts       "
+  ]
+};
+var CARD_WIDTH = 34;
+var CARD_HEIGHT = 18;
+var CARD_INNER = CARD_WIDTH - 2;
+function centerLine(text, width) {
+  const stripped = stripAnsiForWidth(text);
+  if (stripped.length >= width) return text.slice(0, width);
+  const pad = Math.floor((width - stripped.length) / 2);
+  return " ".repeat(pad) + text + " ".repeat(width - stripped.length - pad);
+}
+function stripAnsiForWidth(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function renderBadgeCard(def, unlock, opts) {
+  const dim = opts?.dim === true || unlock === null;
+  const art = BADGE_ART[def.id] ?? [];
+  const lines = [];
+  const category = def.category.toUpperCase();
+  const borderLabel = ` ${category} `;
+  const topPad = CARD_INNER - borderLabel.length - 2;
+  const topLeft = Math.floor(topPad / 2);
+  const topRight = topPad - topLeft;
+  lines.push(`\u250C${"\u2500".repeat(topLeft)}${borderLabel}${"\u2500".repeat(topRight)}\u2510`);
+  lines.push(`\u2502${" ".repeat(CARD_INNER)}\u2502`);
+  const artMaxLines = 9;
+  const artSlice = art.slice(0, artMaxLines);
+  for (const artLine of artSlice) {
+    const centered = centerLine(artLine, CARD_INNER);
+    lines.push(`\u2502${dim ? dimText(centered) : centered}\u2502`);
+  }
+  for (let i = artSlice.length; i < artMaxLines; i++) {
+    lines.push(`\u2502${" ".repeat(CARD_INNER)}\u2502`);
+  }
+  lines.push(`\u2502${" ".repeat(CARD_INNER)}\u2502`);
+  const nameText = unlock !== null ? def.name : `? ${def.name} ?`;
+  lines.push(`\u2502${centerLine(nameText, CARD_INNER)}\u2502`);
+  const descLines = wrapText2(def.description, CARD_INNER - 4);
+  for (const dl of descLines.slice(0, 2)) {
+    const centered = centerLine(dl, CARD_INNER);
+    lines.push(`\u2502${dim ? dimText(centered) : centered}\u2502`);
+  }
+  const usedContent = 1 + 1 + artMaxLines + 1 + 1 + Math.min(descLines.length, 2);
+  const remaining = CARD_HEIGHT - 2 - usedContent;
+  for (let i = 0; i < remaining; i++) {
+    if (i === remaining - 1 && unlock !== null) {
+      const dateStr = unlock.unlockedAt.slice(0, 10);
+      lines.push(`\u2502${centerLine(dimText(dateStr), CARD_INNER)}\u2502`);
+    } else {
+      lines.push(`\u2502${" ".repeat(CARD_INNER)}\u2502`);
+    }
+  }
+  lines.push(`\u2514${"\u2500".repeat(CARD_INNER)}\u2518`);
+  return { lines, width: CARD_WIDTH, height: lines.length };
+}
+function dimText(text) {
+  return `\x1B[2m${text}\x1B[22m`;
+}
+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 createBadgeGallery(unlockedAchievements, startIndex) {
+  const unlocked = /* @__PURE__ */ new Map();
+  for (const a of unlockedAchievements) {
+    unlocked.set(a.id, a);
+  }
+  const sorted = [...ACHIEVEMENTS].sort((a, b) => {
+    const aUnlocked = unlocked.has(a.id);
+    const bUnlocked = unlocked.has(b.id);
+    if (aUnlocked && !bUnlocked) return -1;
+    if (!aUnlocked && bUnlocked) return 1;
+    if (aUnlocked && bUnlocked) {
+      const aDate = unlocked.get(a.id).unlockedAt;
+      const bDate = unlocked.get(b.id).unlockedAt;
+      return aDate.localeCompare(bDate);
+    }
+    return 0;
+  });
+  return {
+    achievements: sorted,
+    unlocked,
+    currentIndex: startIndex ?? 0,
+    total: sorted.length
+  };
+}
+function galleryNext(gallery) {
+  return (gallery.currentIndex + 1) % gallery.total;
+}
+function galleryPrev(gallery) {
+  return (gallery.currentIndex - 1 + gallery.total) % gallery.total;
+}
+
 // src/tui/panels/overlays.ts
 var HELP_WIDTH = 62;
 var COMPANION_WIDTH = 52;
@@ -865,7 +3308,7 @@ var MOOD_ICONS = {
   excited: "\u2726",
   existential: "\u25C9"
 };
-var MOOD_COLORS = {
+var MOOD_COLORS2 = {
   happy: "green",
   grinding: "yellow",
   frustrated: "red",
@@ -879,7 +3322,7 @@ function statBar(value, max, width, color) {
   const bar = ansiColor("\u2593".repeat(filled), color) + ansiDim("\u2591".repeat(width - filled));
   return bar;
 }
-function wrapText2(text, maxWidth) {
+function wrapText3(text, maxWidth) {
   const words = text.split(" ");
   const lines = [];
   let current = "";
@@ -902,7 +3345,7 @@ function renderProfilePage(buf, rows, cols, companion) {
   const endH = Math.floor(companion.stats.endurance / 36e5);
   const intensity = companion.debugMood?.scores[companion.mood] ?? 0;
   const face = getMoodFace(companion.mood, intensity);
-  const moodColor = MOOD_COLORS[companion.mood];
+  const moodColor = MOOD_COLORS2[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);
@@ -933,7 +3376,7 @@ function renderProfilePage(buf, rows, cols, companion) {
   contentLines.push(" ".padEnd(innerWidth));
   if (companion.lastCommentary) {
     const raw = companion.lastCommentary.text;
-    const wrapped = wrapText2(raw, innerWidth - 6);
+    const wrapped = wrapText3(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));
@@ -1144,8 +3587,50 @@ function renderCompanionDebugOverlay(buf, rows, cols, companion) {
 }
 
 // src/tui/panels/mounted-humanloop.ts
-import { readFileSync } from "fs";
+init_ask_store();
+init_paths();
+import { readFileSync as readFileSync9 } from "fs";
 import { mountPanel } from "@crouton-kit/humanloop";
+
+// src/shared/client.ts
+init_paths();
+import { connect } from "net";
+function rawSend(request, timeoutMs = 1e4) {
+  const sock = socketPath();
+  return new Promise((resolve2, reject) => {
+    const socket = connect(sock);
+    let data = "";
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      reject(new Error(`Request timed out after ${(timeoutMs / 1e3).toFixed(0)}s. The daemon may be overloaded.
+  Check: sisyphus admin doctor
+  Logs: tail -20 ~/.sisyphus/daemon.log`));
+    }, timeoutMs);
+    socket.on("connect", () => {
+      socket.write(JSON.stringify(request) + "\n");
+    });
+    socket.on("data", (chunk) => {
+      data += chunk.toString();
+      const newlineIdx = data.indexOf("\n");
+      if (newlineIdx !== -1) {
+        clearTimeout(timeout);
+        const line = data.slice(0, newlineIdx);
+        socket.destroy();
+        try {
+          resolve2(JSON.parse(line));
+        } catch {
+          reject(new Error(`Invalid JSON response from daemon: ${line}`));
+        }
+      }
+    });
+    socket.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+// src/tui/panels/mounted-humanloop.ts
 async function dispatchOrphanResolution(orphanTarget, selectedOptionId, deps) {
   if (selectedOptionId === "takeover" && orphanTarget.kind === "agent") {
     await deps.onOrphanTakeover?.({
@@ -1203,7 +3688,7 @@ function mountResolutionPanel(opts, state2) {
       }, 6e4);
       if (res.ok) {
         const ansiPath = res.data.ansiPath;
-        const ansi = readFileSync(ansiPath, "utf-8");
+        const ansi = readFileSync9(ansiPath, "utf-8");
         state2.visuals.set(qid, { status: "ready", content: ansi, visible: true });
       } else {
         state2.visuals.set(qid, { status: "error", content: "", visible: true, error: res.error });
@@ -1383,6 +3868,116 @@ function enterResolutionMode(state2, askId2, daemonSend, onOrphanTakeover) {
   requestRender();
 }
 
+// src/shared/keymap.ts
+var MENU_FOR_MODE = {
+  "leader": "topLevel",
+  "copy-menu": "copy",
+  "open-menu": "open",
+  "agent-menu": "agent",
+  "session-menu": "session",
+  "go-menu": "go",
+  "companion-menu": "companion"
+};
+var KEYMAP = {
+  version: 1,
+  topLevel: {
+    title: " Sisyphus ",
+    items: [
+      { key: "s", label: "  Cycle session", action: { type: "script", name: "sisyphus-cycle" } },
+      { key: "h", label: "  Home / dashboard", action: { type: "script", name: "sisyphus-home" } },
+      { key: "n", label: "  New session", action: { type: "popup", name: "sisyphus-new", popup: { w: "80%", h: "60%", cwd: "current" } } },
+      { key: "m", label: "  Message orchestrator", action: { type: "popup", name: "sisyphus-msg", popup: { w: "80%", h: "60%", cwd: "current" } } },
+      { key: "t", label: "  Status (where am I?)", action: { type: "popup", name: "sisyphus-status-popup", popup: { w: "90%", h: "90%", cwd: "current" } } },
+      { key: "l", label: "  Session picker", action: { type: "popup", name: "sisyphus-pick-session", popup: { w: "60%", h: "60%", cwd: "current" } } },
+      { key: "z", label: "  Zoom pane", action: { type: "tmux", cmd: "resize-pane -Z" } },
+      { key: "x", label: "  Kill pane (smart)", action: { type: "script", name: "sisyphus-kill-pane" } },
+      { key: "?", label: "  Full help reference", action: { type: "popup", name: "sisyphus-help", popup: { w: "80", h: "32", title: " Keybindings " } } },
+      { key: "/", label: "  Search / filter", action: { type: "script", name: "sisyphus-search-reports" }, tuiAction: "search" },
+      { key: " ", label: "  Open popup explicitly", action: { type: "tui", action: "show-leader" } },
+      { key: "y", label: "  Yank \u203A", action: { type: "submenu", ref: "copy" } },
+      { key: "c", label: "  Companion \u203A", action: { type: "submenu", ref: "companion" } },
+      { key: "o", label: "  Open \u203A", action: { type: "submenu", ref: "open" } },
+      { key: "a", label: "  Agent \u203A", action: { type: "submenu", ref: "agent" } },
+      { key: "S", label: "  Session \u203A", action: { type: "submenu", ref: "session" } },
+      { key: "g", label: "  Go \u203A", action: { type: "submenu", ref: "go" } }
+    ]
+  },
+  submenus: {
+    companion: {
+      title: " Companion ",
+      items: [
+        { key: "p", label: "  profile (overlay)", action: { type: "tui", action: "companion-overlay" } },
+        { key: "d", label: "  debug (mood signals)", action: { type: "tui", action: "companion-debug" } },
+        { key: "t", label: "  open in tmux pane", action: { type: "tui", action: "companion-pane" } }
+      ]
+    },
+    copy: {
+      title: " Copy ",
+      items: [
+        { key: "p", label: "  session dir path", action: { type: "script", name: "sisyphus-copy-path" } },
+        { key: "i", label: "  session UUID", action: { type: "script", name: "sisyphus-copy-id" } },
+        { key: "c", label: "  full session context XML", action: { type: "script", name: "sisyphus-copy-context" } },
+        { key: "l", label: "  logs (last 200 lines)", action: { type: "script", name: "sisyphus-copy-logs" } },
+        { key: "r", label: "  latest report content", action: { type: "script", name: "sisyphus-copy-latest-report" } },
+        { key: "a", label: "  agent ID (picker)", action: { type: "script", name: "sisyphus-copy-agent-id" } }
+      ]
+    },
+    open: {
+      title: " Open ",
+      items: [
+        { key: "g", label: "  goal.md", action: { type: "popup", name: "sisyphus-open-goal", popup: { w: "95%", h: "95%", cwd: "current" } } },
+        { key: "r", label: "  roadmap.md", action: { type: "popup", name: "sisyphus-open-roadmap", popup: { w: "95%", h: "95%", cwd: "current" } } },
+        { key: "s", label: "  strategy.md", action: { type: "popup", name: "sisyphus-open-strategy", popup: { w: "95%", h: "95%", cwd: "current" } } },
+        { key: "l", label: "  logs popup (tail)", action: { type: "popup", name: "sisyphus-open-logs", popup: { w: "90%", h: "90%", cwd: "current" } } },
+        { key: "d", label: "  session dir in file mgr", action: { type: "script", name: "sisyphus-open-dir" } },
+        { key: "R", label: "  latest report file", action: { type: "popup", name: "sisyphus-open-latest-report", popup: { w: "95%", h: "95%", cwd: "current" } } },
+        { key: "c", label: "  scratch", action: { type: "popup", name: "sisyphus-open-scratch", popup: { w: "95%", h: "95%", cwd: "current" } } },
+        { key: "e", label: "  edit context file", action: { type: "popup", name: "sisyphus-edit-context-file", popup: { w: "95%", h: "95%", cwd: "current" } }, tuiAction: "edit-context-file" }
+      ]
+    },
+    agent: {
+      title: " Agent ",
+      items: [
+        { key: "s", label: "  spawn agent", action: { type: "popup", name: "sisyphus-spawn-agent", popup: { w: "80%", h: "70%", cwd: "current" } } },
+        { key: "m", label: "  message agent (picker)", action: { type: "popup", name: "sisyphus-msg-agent", popup: { w: "80%", h: "60%", cwd: "current" } } },
+        { key: "r", label: "  restart agent (picker)", action: { type: "popup", name: "sisyphus-restart-agent-popup", popup: { w: "70%", h: "50%", cwd: "current" } } },
+        { key: "R", label: "  re-run agent (picker)", action: { type: "popup", name: "sisyphus-rerun-agent", popup: { w: "70%", h: "50%", cwd: "current" } } },
+        { key: "j", label: "  jump to agent's pane", action: { type: "popup", name: "sisyphus-jump-to-pane", popup: { w: "60%", h: "60%" } } },
+        { key: "o", label: "  open claude --resume", action: { type: "popup", name: "sisyphus-open-claude-agent", popup: { w: "60%", h: "60%", cwd: "current" } } },
+        { key: "t", label: "  tail agent logs (picker)", action: { type: "popup", name: "sisyphus-tail-agent-logs", popup: { w: "90%", h: "90%", cwd: "current" } } },
+        { key: "k", label: "  kill agent (picker)", action: { type: "popup", name: "sisyphus-kill-agent", popup: { w: "60%", h: "40%", cwd: "current" } } },
+        { key: "e", label: "  quick-spawn Explore", action: { type: "script", name: "sisyphus-quick-spawn-explore" } },
+        { key: "d", label: "  quick-spawn Debug", action: { type: "script", name: "sisyphus-quick-spawn-debug" } }
+      ]
+    },
+    session: {
+      title: " Session ",
+      items: [
+        { key: "n", label: "  new session", action: { type: "popup", name: "sisyphus-new", popup: { w: "80%", h: "60%", cwd: "current" } } },
+        { key: "r", label: "  resume", action: { type: "popup", name: "sisyphus-resume-session", popup: { w: "80%", h: "60%", cwd: "current" } } },
+        { key: "c", label: "  continue", action: { type: "popup", name: "sisyphus-continue-session", popup: { w: "50", h: "5", borderStyle: "fg=yellow", title: " Continue Session ", cwd: "current" } } },
+        { key: "b", label: "  rollback (prompts cycle)", action: { type: "popup", name: "sisyphus-rollback-session", popup: { w: "50", h: "5", title: " Rollback ", cwd: "current" } } },
+        { key: "k", label: "  kill", action: { type: "popup", name: "sisyphus-kill-session", popup: { w: "40", h: "5", borderStyle: "fg=red", title: " Kill Session ", cwd: "current" } } },
+        { key: "d", label: "  delete (confirms)", action: { type: "popup", name: "sisyphus-delete-session", popup: { w: "40", h: "5", borderStyle: "fg=red", title: " Delete Session ", cwd: "current" } } },
+        { key: "e", label: "  export to ~/Downloads", action: { type: "popup", name: "sisyphus-export-session", popup: { w: "60", h: "8", title: " Export Session ", cwd: "current" } } },
+        { key: "w", label: "  go to session window", action: { type: "popup", name: "sisyphus-go-to-window", popup: { w: "70%", h: "60%", cwd: "current" } } },
+        { key: "C", label: "  clone (sisyphus session clone)", action: { type: "popup", name: "sisyphus-clone-session", popup: { w: "60%", h: "60%", cwd: "current" } } },
+        { key: "i", label: "  history", action: { type: "popup", name: "sisyphus-history", popup: { w: "95%", h: "95%", cwd: "current" } } }
+      ]
+    },
+    go: {
+      title: " Go ",
+      items: [
+        { key: "w", label: "  go to session window", action: { type: "popup", name: "sisyphus-go-to-window", popup: { w: "70%", h: "60%", cwd: "current" } } },
+        { key: "p", label: "  jump to pane (picker)", action: { type: "popup", name: "sisyphus-jump-to-pane", popup: { w: "60%", h: "60%" } } },
+        { key: "s", label: "  session picker", action: { type: "popup", name: "sisyphus-pick-session", popup: { w: "60%", h: "60%", cwd: "current" } } },
+        { key: "n", label: "  next session", action: { type: "script", name: "sisyphus-cycle" } },
+        { key: "r", label: "  reconnect", action: { type: "popup", name: "sisyphus-reconnect", popup: { w: "80%", h: "40%", cwd: "current" } } }
+      ]
+    }
+  }
+};
+
 // src/tui/input.ts
 function dispatchComposeAction(action, content, state2, actions) {
   switch (action.kind) {
@@ -1446,12 +4041,16 @@ var ENTER_FOR_REF = {
   open: "enter-open-menu",
   agent: "enter-agent-menu",
   session: "enter-session-menu",
-  go: "enter-go-menu"
+  go: "enter-go-menu",
+  companion: "enter-companion-menu"
 };
 var TUI_ACTION_FOR_NAME = {
   "search": "search",
   "edit-context-file": "edit-context-file",
-  "show-leader": "help"
+  "show-leader": "help",
+  "companion-overlay": "companion-overlay",
+  "companion-debug": "companion-debug",
+  "companion-pane": "companion-pane"
 };
 var TUI_HANDLERS = {
   "sisyphus-copy-path": "copy-path",
@@ -1499,18 +4098,18 @@ var TUI_HANDLERS = {
 function findLatestReport(cwd2, sessionId2) {
   const dir = reportsDir(cwd2, sessionId2);
   try {
-    const files = readdirSync(dir);
+    const files = readdirSync5(dir);
     if (files.length === 0) return null;
     let latestFile = files[0];
-    let latestMtime = statSync(join2(dir, latestFile)).mtimeMs;
+    let latestMtime = statSync3(join11(dir, latestFile)).mtimeMs;
     for (let i = 1; i < files.length; i++) {
-      const m = statSync(join2(dir, files[i])).mtimeMs;
+      const m = statSync3(join11(dir, files[i])).mtimeMs;
       if (m > latestMtime) {
         latestMtime = m;
         latestFile = files[i];
       }
     }
-    return join2(dir, latestFile);
+    return join11(dir, latestFile);
   } catch {
     return null;
   }
@@ -1758,6 +4357,10 @@ function handleLeaderAction(action, state2, actions) {
       state2.mode = "help";
       requestRender();
       return;
+    case "enter-companion-menu":
+      state2.mode = "companion-menu";
+      requestRender();
+      return;
     case "companion-overlay":
       state2.mode = "companion-overlay";
       requestRender();
@@ -1766,6 +4369,13 @@ function handleLeaderAction(action, state2, actions) {
       state2.mode = "companion-debug";
       requestRender();
       return;
+    case "companion-pane":
+      try {
+        actions.openCompanionPane(state2.cwd);
+      } catch {
+        notify(state2, "Failed to open companion pane");
+      }
+      return;
     case "shell-command": {
       if (!selectedSessionId) {
         notify(state2, "No session selected");
@@ -1849,7 +4459,7 @@ function handleLeaderAction(action, state2, actions) {
         break;
       }
       try {
-        const content = readFileSync2(latest, "utf-8");
+        const content = readFileSync10(latest, "utf-8");
         actions.copyToClipboard(content);
         notify(state2, `Copied latest report (${content.length} chars)`);
       } catch {
@@ -1909,7 +4519,7 @@ function handleLeaderAction(action, state2, actions) {
       }
       const editor = actions.resolveEditor();
       try {
-        actions.openEditorPopup(state2.cwd, editor, join2(sessionDir(state2.cwd, selectedSessionId), "scratch.md"));
+        actions.openEditorPopup(state2.cwd, editor, join11(sessionDir(state2.cwd, selectedSessionId), "scratch.md"));
       } catch {
         notify(state2, "Failed to open scratch");
       }
@@ -2705,7 +5315,7 @@ function handleKeypress(input, key, state2, actions) {
   }
   if (state2.mode === "search") {
     handleSearchKey(input, key, state2);
-  } else if (state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "open-menu" || state2.mode === "agent-menu" || state2.mode === "session-menu" || state2.mode === "go-menu" || state2.mode === "help" || state2.mode === "companion-overlay" || state2.mode === "companion-debug") {
+  } else if (state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "open-menu" || state2.mode === "agent-menu" || state2.mode === "session-menu" || state2.mode === "go-menu" || state2.mode === "companion-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);
@@ -2714,6 +5324,10 @@ function handleKeypress(input, key, state2, actions) {
   }
 }
 
+// src/tui/app.ts
+init_render();
+init_terminal();
+
 // src/tui/lib/tree-render.ts
 function renderTreePrefix(node, nodes, index) {
   if (node.depth === 0) {
@@ -2784,6 +5398,24 @@ function precomputePrefixes(nodes) {
   }
 }
 
+// src/tui/lib/reports.ts
+import { readFileSync as readFileSync11 } from "fs";
+function loadReportContent(report) {
+  try {
+    return readFileSync11(report.filePath, "utf-8");
+  } catch {
+    return report.summary;
+  }
+}
+function resolveReports(reports) {
+  return [...reports].reverse().map((r) => ({
+    type: r.type,
+    timestamp: r.timestamp,
+    content: loadReportContent(r),
+    summary: r.summary
+  }));
+}
+
 // src/tui/lib/client.ts
 function send(request) {
   return rawSend(request, 8e3);
@@ -2795,10 +5427,28 @@ async function inboxList() {
 }
 
 // src/tui/lib/tmux.ts
-import { execSync as execSync2 } from "child_process";
-import { join as join3 } from "path";
-import { readFileSync as readFileSync3, writeFileSync, mkdtempSync, rmSync, cpSync, existsSync, mkdirSync } from "fs";
+init_paths();
+import { execSync as execSync3 } from "child_process";
+import { join as join12 } from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdtempSync, rmSync as rmSync4, cpSync as cpSync2, existsSync as existsSync8, mkdirSync as mkdirSync8 } from "fs";
 import { tmpdir } from "os";
+init_shell();
+
+// src/shared/exec.ts
+import { execSync as execSync2 } from "child_process";
+var EXEC_ENV = execEnv();
+function exec(cmd, cwd2, timeoutMs = 3e4) {
+  return execSync2(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd: cwd2, timeout: timeoutMs }).trim();
+}
+function execSafe(cmd, cwd2, timeoutMs) {
+  try {
+    return execSync2(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd: cwd2, stdio: ["pipe", "pipe", "pipe"], timeout: timeoutMs }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/tui/lib/tmux.ts
 function getWindowId() {
   const pane = process.env["TMUX_PANE"];
   if (pane) {
@@ -2814,7 +5464,7 @@ function selectPane(paneId) {
 }
 function listAllWindowIds() {
   try {
-    const output = execSync2('tmux list-windows -a -F "#{window_id}"', { encoding: "utf-8", env: EXEC_ENV });
+    const output = execSync3('tmux list-windows -a -F "#{window_id}"', { encoding: "utf-8", env: EXEC_ENV });
     return new Set(output.trim().split("\n").filter(Boolean));
   } catch {
     return /* @__PURE__ */ new Set();
@@ -2834,10 +5484,10 @@ function registerDashboardWindow() {
 }
 var companionPaneId = null;
 function setupCompanionPlugin() {
-  const srcDir = join3(import.meta.dirname, "templates", "companion-plugin");
-  const destDir = join3(globalDir(), "companion-plugin");
-  if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
-  cpSync(srcDir, destDir, { recursive: true });
+  const srcDir = join12(import.meta.dirname, "templates", "companion-plugin");
+  const destDir = join12(globalDir(), "companion-plugin");
+  if (!existsSync8(destDir)) mkdirSync8(destDir, { recursive: true });
+  cpSync2(srcDir, destDir, { recursive: true });
   return destDir;
 }
 function paneExists(paneId) {
@@ -2849,18 +5499,18 @@ function openCompanionPane(cwd2) {
     return;
   }
   const pluginDir = setupCompanionPlugin();
-  const templatePath = join3(import.meta.dirname, "templates", "dashboard-claude.md");
+  const templatePath = join12(import.meta.dirname, "templates", "dashboard-claude.md");
   let template;
   try {
-    template = readFileSync3(templatePath, "utf-8");
+    template = readFileSync12(templatePath, "utf-8");
   } catch {
     template = `You are a Sisyphus dashboard companion. Help the user manage multi-agent sessions.
 Project: ${cwd2}
 Run \`sisyphus list\` and \`sisyphus status\` to see current state.`;
   }
   const rendered = template.replace(/\{\{CWD\}\}/g, cwd2);
-  const promptPath = join3(globalDir(), "dashboard-companion-prompt.md");
-  writeFileSync(promptPath, rendered, "utf-8");
+  const promptPath = join12(globalDir(), "dashboard-companion-prompt.md");
+  writeFileSync9(promptPath, rendered, "utf-8");
   const pathEnv = augmentedPath();
   const claudeCmd = `SISYPHUS_COMPANION_CWD=${shellQuote(cwd2)} PATH=${shellQuote(pathEnv)} claude --dangerously-skip-permissions --plugin-dir ${shellQuote(pluginDir)} --append-system-prompt "$(cat ${shellQuote(promptPath)})"`;
   const result = exec(
@@ -2873,55 +5523,55 @@ function switchToSession(sessionName) {
   execSafe(`tmux switch-client -t ${shellQuote(sessionName)}`);
 }
 function editInPopup(cwd2, editor, opts) {
-  const tmpDir = mkdtempSync(join3(tmpdir(), "sisyphus-"));
-  const filePath = join3(tmpDir, "input.md");
+  const tmpDir = mkdtempSync(join12(tmpdir(), "sisyphus-"));
+  const filePath = join12(tmpDir, "input.md");
   try {
-    writeFileSync(filePath, opts?.content ? opts.content : "", "utf-8");
+    writeFileSync9(filePath, opts?.content ? opts.content : "", "utf-8");
     openEditorPopup(cwd2, editor, filePath, opts?.size);
-    const result = readFileSync3(filePath, "utf-8").trim();
+    const result = readFileSync12(filePath, "utf-8").trim();
     return result || null;
   } finally {
-    rmSync(tmpDir, { recursive: true, force: true });
+    rmSync4(tmpDir, { recursive: true, force: true });
   }
 }
 function promptInPopup(prompt, opts) {
   const { w = "50%", h = "3" } = opts ?? {};
-  const tmpDir = mkdtempSync(join3(tmpdir(), "sisyphus-"));
-  const outFile = join3(tmpDir, "result");
+  const tmpDir = mkdtempSync(join12(tmpdir(), "sisyphus-"));
+  const outFile = join12(tmpDir, "result");
   try {
     const script = `printf ${shellQuote(prompt + " ")} && read -r line && printf '%s' "$line" > ${shellQuote(outFile)}`;
-    execSync2(
+    execSync3(
       `tmux display-popup -E -w ${w} -h ${h} ${shellQuote(`bash -c ${shellQuote(script)}`)}`,
       { stdio: "inherit", env: EXEC_ENV }
     );
-    if (!existsSync(outFile)) return null;
-    const result = readFileSync3(outFile, "utf-8").trim();
+    if (!existsSync8(outFile)) return null;
+    const result = readFileSync12(outFile, "utf-8").trim();
     return result || null;
   } finally {
-    rmSync(tmpDir, { recursive: true, force: true });
+    rmSync4(tmpDir, { recursive: true, force: true });
   }
 }
 function openLogPopup() {
-  execSync2(
+  execSync3(
     `tmux display-popup -E -w 90% -h 80% ${shellQuote("tail -f ~/.sisyphus/daemon.log")}`,
     { stdio: "inherit", env: EXEC_ENV }
   );
 }
 function openShellPopup(cwd2, command) {
-  execSync2(
+  execSync3(
     `tmux display-popup -E -w 90% -h 80% -d ${shellQuote(cwd2)} ${shellQuote(`sh -c '${command.replace(/'/g, "'\\''")}; echo; echo "Press enter to close"; read'`)}`,
     { stdio: "inherit", env: EXEC_ENV }
   );
 }
 function openInFileManager(path) {
-  execSync2(`open ${shellQuote(path)}`, { stdio: "inherit", env: EXEC_ENV });
+  execSync3(`open ${shellQuote(path)}`, { stdio: "inherit", env: EXEC_ENV });
 }
 function openClaudeResumePopup(cwd2, claudeSessionId, resumeEnv, resumeArgs) {
   const pathEnv = augmentedPath();
   const envPrefix = resumeEnv ? `${resumeEnv} && ` : "";
   const args2 = resumeArgs ? `${resumeArgs} --resume ${shellQuote(claudeSessionId)}` : `--resume ${shellQuote(claudeSessionId)}`;
   const cmd = `${envPrefix}PATH=${shellQuote(pathEnv)} claude ${args2}`;
-  execSync2(
+  execSync3(
     `tmux display-popup -E -w 90% -h 80% -d ${shellQuote(cwd2)} ${shellQuote(cmd)}`,
     { stdio: "inherit", env: EXEC_ENV }
   );
@@ -2981,23 +5631,83 @@ function openEditorPopup(cwd2, editor, filePath, size) {
   const { w = "90%", h = "90%" } = size ?? {};
   const editorBin = editor.split(/\s+/)[0].split("/").pop();
   if (TERMINAL_EDITORS.has(editorBin)) {
-    execSync2(
+    execSync3(
       `tmux display-popup -E -w ${w} -h ${h} -d ${shellQuote(cwd2)} ${shellQuote(`${editor} ${shellQuote(filePath)}`)}`,
       { stdio: "inherit", env: EXEC_ENV }
     );
   } else {
-    execSync2(`${editor} ${shellQuote(filePath)}`, { stdio: "inherit", cwd: cwd2, env: EXEC_ENV });
+    execSync3(`${editor} ${shellQuote(filePath)}`, { stdio: "inherit", cwd: cwd2, env: EXEC_ENV });
   }
 }
 
 // src/tui/lib/clipboard.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function copyToClipboard(text) {
-  execSync3("pbcopy", { input: text });
+  execSync4("pbcopy", { input: text });
+}
+
+// src/tui/lib/context.ts
+init_paths();
+import { readFileSync as readFileSync13, readdirSync as readdirSync6 } from "fs";
+function readFileSafe(filePath) {
+  try {
+    return readFileSync13(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildSessionContext(session, cwd2) {
+  const goal = readFileSafe(goalPath(cwd2, session.id));
+  const roadmap = readFileSafe(roadmapPath(cwd2, session.id));
+  const agentsXml = session.agents.map((agent) => {
+    const reportBlocks = resolveReports(agent.reports);
+    const reportsXml = [...reportBlocks].reverse().map((block) => {
+      return `      <report type="${block.type}" time="${escapeXml(block.timestamp)}">${escapeXml(block.content)}</report>`;
+    }).join("\n");
+    return [
+      `    <agent id="${escapeXml(agent.id)}" name="${escapeXml(agent.name)}" type="${escapeXml(agent.agentType)}" status="${escapeXml(agent.status)}">`,
+      `      <instruction>${escapeXml(agent.instruction)}</instruction>`,
+      ...reportsXml ? [reportsXml] : [],
+      `    </agent>`
+    ].join("\n");
+  }).join("\n");
+  const cyclesXml = session.orchestratorCycles.map((cycle) => {
+    const agents = cycle.agentsSpawned.join(", ");
+    const mode = cycle.mode ? ` mode="${escapeXml(cycle.mode)}"` : "";
+    return `    <cycle number="${cycle.cycle}"${mode} agents="${escapeXml(agents)}" />`;
+  }).join("\n");
+  const lines = [
+    "<context>",
+    `<session id="${escapeXml(session.id)}" status="${escapeXml(session.status)}">`,
+    `  <task>${escapeXml(session.task)}</task>`,
+    `  <cwd>${escapeXml(session.cwd)}</cwd>`
+  ];
+  if (goal) lines.push(`  <goal>${escapeXml(goal)}</goal>`);
+  if (roadmap) lines.push(`  <roadmap>${escapeXml(roadmap)}</roadmap>`);
+  if (session.agents.length > 0) {
+    lines.push("  <agents>");
+    lines.push(agentsXml);
+    lines.push("  </agents>");
+  }
+  if (session.orchestratorCycles.length > 0) {
+    lines.push("  <cycles>");
+    lines.push(cyclesXml);
+    lines.push("  </cycles>");
+  }
+  if (session.completionReport) {
+    lines.push(`  <completion-report>${escapeXml(session.completionReport)}</completion-report>`);
+  }
+  lines.push("</session>");
+  lines.push("</context>");
+  return lines.join("\n");
 }
 
 // src/tui/panels/tree.ts
-import stringWidth2 from "string-width";
+init_render();
+import stringWidth4 from "string-width";
 function renderNodeContent(node, maxWidth) {
   switch (node.type) {
     case "section": {
@@ -3171,7 +5881,7 @@ function renderTreePanel(buf, rect, nodes, cursorIndex, focused, companion) {
       let current = "";
       let currentWidth = 0;
       for (const word of words) {
-        const wordWidth = stringWidth2(word);
+        const wordWidth = stringWidth4(word);
         if (currentWidth + wordWidth + 1 > innerW && currentWidth > 0) {
           _companionCommentaryLines.push(current);
           current = word;
@@ -3266,8 +5976,16 @@ function renderTreePanel(buf, rect, nodes, cursorIndex, focused, companion) {
   }
 }
 
+// src/tui/panels/detail.ts
+init_render();
+
+// src/shared/utils.ts
+function computeActiveTimeMs(session) {
+  return session.activeMs;
+}
+
 // src/tui/panels/cycle-flow.ts
-import stringWidth3 from "string-width";
+import stringWidth5 from "string-width";
 var BG_TINTS = {
   yellow: "48;2;40;35;20",
   blue: "48;2;20;25;45",
@@ -3304,7 +6022,7 @@ function getCurrentPhase(session) {
   return "orchestrator";
 }
 function padTo(text, w) {
-  const tw = stringWidth3(text);
+  const tw = stringWidth5(text);
   if (tw >= w) return truncate(text, w);
   return text + " ".repeat(w - tw);
 }
@@ -3327,8 +6045,8 @@ function buildOrchestratorNode(cycle, agents, width, bright, showConnectorBottom
     rightText = `${dur}   ${time}`;
   }
   const leftContent = `${icon} ${cycleLabel}  ${modeLabel}`;
-  const leftW = stringWidth3(leftContent);
-  const rightW = stringWidth3(rightText);
+  const leftW = stringWidth5(leftContent);
+  const rightW = stringWidth5(rightText);
   const gap = Math.max(1, inner - 2 - leftW - rightW);
   lines.push([seg("\u256D" + "\u2500".repeat(inner) + "\u256E", { color: "yellow", dim })]);
   const contentSegs = [
@@ -3345,7 +6063,7 @@ function buildOrchestratorNode(cycle, agents, width, bright, showConnectorBottom
     contentSegs.push(seg(rightText, { bg: bg2, dim }));
   }
   contentSegs.push(seg(" ", { bg: bg2 }));
-  const usedWidth = 1 + 1 + 1 + 1 + stringWidth3(cycleLabel) + 2 + stringWidth3(modeLabel) + gap + stringWidth3(rightText) + 1;
+  const usedWidth = 1 + 1 + 1 + 1 + stringWidth5(cycleLabel) + 2 + stringWidth5(modeLabel) + gap + stringWidth5(rightText) + 1;
   if (usedWidth < inner) {
     contentSegs.push(seg(" ".repeat(inner - usedWidth), { bg: bg2 }));
   }
@@ -3506,7 +6224,7 @@ function buildAgentBoxRows(agents, boxWidth, totalWidth, bright, maxPerRow) {
       const dim = !bright;
       const icon = agentStatusIcon(a.status);
       const iconColor = statusColor(a.status);
-      const idPadded = padTo(`  ${a.id}`, innerW - stringWidth3(icon));
+      const idPadded = padTo(`  ${a.id}`, innerW - stringWidth5(icon));
       line1Segs.push(seg("\u2502", { color: borderColor, dim }));
       line1Segs.push(seg(icon, { bg: agentBg, color: iconColor, bold: bright }));
       line1Segs.push(seg(idPadded, { bg: agentBg, dim, bold: bright && a.status === "running" }));
@@ -3642,7 +6360,7 @@ function buildCompleteNode(session, width) {
   const cycles = session.orchestratorCycles.length;
   const leftText = "\u25C9 complete";
   const rightText = `${dur} total`;
-  const gap = Math.max(1, inner - 2 - stringWidth3(leftText) - stringWidth3(rightText));
+  const gap = Math.max(1, inner - 2 - stringWidth5(leftText) - stringWidth5(rightText));
   let summaryParts = `${cycles} cycle${cycles !== 1 ? "s" : ""} \xB7 ${totalAgents} agent${totalAgents !== 1 ? "s" : ""}`;
   if (totalAgents > 0) {
     const parts = [];
@@ -4558,8 +7276,11 @@ function renderDigestRows(rect, state2) {
   return buildPanelRows(rect, lines, state2.digestScroll, focused, "cyan", state2.digestRenderedCache);
 }
 
+// src/tui/panels/stacked-detail.ts
+init_render();
+
 // src/tui/lib/markdown-highlight.ts
-import stringWidth4 from "string-width";
+import stringWidth6 from "string-width";
 
 // src/tui/lib/gloam.ts
 function fg(r, g, b) {
@@ -4665,7 +7386,7 @@ function tokenizeInline(line, baseFg, baseStyle) {
 }
 function segsDisplayWidth(segs) {
   let w = 0;
-  for (const s of segs) w += stringWidth4(s.text);
+  for (const s of segs) w += stringWidth6(s.text);
   return w;
 }
 function segsToAtoms(segs) {
@@ -4678,7 +7399,7 @@ function segsToAtoms(segs) {
       const piece = m[0];
       atoms.push({
         text: piece,
-        width: stringWidth4(piece),
+        width: stringWidth6(piece),
         style,
         space: /^\s+$/.test(piece)
       });
@@ -4701,7 +7422,7 @@ function wrapSegs(segs, width, contIndent) {
     while (current.length > 0) {
       const last = current[current.length - 1];
       if (/^\s+$/.test(last.text) && !last.bg) {
-        currentWidth -= stringWidth4(last.text);
+        currentWidth -= stringWidth6(last.text);
         current.pop();
       } else break;
     }
@@ -4723,14 +7444,14 @@ function wrapSegs(segs, width, contIndent) {
           flushLine();
           if (contIndent) {
             current.push({ text: contIndent });
-            currentWidth = stringWidth4(contIndent);
+            currentWidth = stringWidth6(contIndent);
           }
           continue;
         }
         let cut = 0;
         let cutW = 0;
         for (let k = 0; k < remaining.length; k++) {
-          const cw = stringWidth4(remaining[k]);
+          const cw = stringWidth6(remaining[k]);
           if (cutW + cw > spaceLeft) break;
           cutW += cw;
           cut = k + 1;
@@ -4739,7 +7460,7 @@ function wrapSegs(segs, width, contIndent) {
           flushLine();
           if (contIndent) {
             current.push({ text: contIndent });
-            currentWidth = stringWidth4(contIndent);
+            currentWidth = stringWidth6(contIndent);
           }
           continue;
         }
@@ -4750,7 +7471,7 @@ function wrapSegs(segs, width, contIndent) {
           flushLine();
           if (contIndent) {
             current.push({ text: contIndent });
-            currentWidth = stringWidth4(contIndent);
+            currentWidth = stringWidth6(contIndent);
           }
         }
       }
@@ -4760,7 +7481,7 @@ function wrapSegs(segs, width, contIndent) {
       flushLine();
       if (contIndent) {
         current.push({ text: contIndent });
-        currentWidth = stringWidth4(contIndent);
+        currentWidth = stringWidth6(contIndent);
       }
     }
     pushAtom(atom);
@@ -4831,7 +7552,7 @@ function buildCodeFenceLine(fence, innerW) {
   return [
     { text: "  ", fg: GLOAM.fg4 },
     {
-      text: fence + " ".repeat(Math.max(0, innerW - 2 - stringWidth4(fence))),
+      text: fence + " ".repeat(Math.max(0, innerW - 2 - stringWidth6(fence))),
       fg: GLOAM.fg4,
       bg: GLOAM.bg_bg1
     }
@@ -4839,7 +7560,7 @@ function buildCodeFenceLine(fence, innerW) {
 }
 function buildCodeLine(content, innerW) {
   const cleaned = stripDisplayHazards(content);
-  const cw = stringWidth4(cleaned);
+  const cw = stringWidth6(cleaned);
   const padW = Math.max(0, innerW - 2 - cw);
   return [
     { text: "  ", bg: GLOAM.bg_bg1 },
@@ -4888,7 +7609,7 @@ function parseTableSeparator(line) {
   return aligns;
 }
 function padCell(text, width, align) {
-  const w = stringWidth4(text);
+  const w = stringWidth6(text);
   const pad = Math.max(0, width - w);
   let left = 0;
   let right = 0;
@@ -4913,7 +7634,7 @@ function wrapCell(text, width, align) {
   };
   for (const piece of cleaned.match(/\s+|\S+/g) ?? []) {
     const isSpace = /^\s+$/.test(piece);
-    const pw = stringWidth4(piece);
+    const pw = stringWidth6(piece);
     if (isSpace) {
       if (curW === 0) continue;
       if (curW + pw > width) flush();
@@ -4935,7 +7656,7 @@ function wrapCell(text, width, align) {
         let cut = 0;
         let cutW = 0;
         for (let k = 0; k < rem.length; k++) {
-          const cw = stringWidth4(rem[k]);
+          const cw = stringWidth6(rem[k]);
           if (cutW + cw > width) break;
           cutW += cw;
           cut = k + 1;
@@ -4944,7 +7665,7 @@ function wrapCell(text, width, align) {
         const slice = rem.slice(0, cut);
         if (cut === rem.length) {
           cur = slice;
-          curW = stringWidth4(slice);
+          curW = stringWidth6(slice);
         } else {
           out.push(padCell(slice, width, align));
         }
@@ -4977,7 +7698,7 @@ function buildTableLines(headers, alignsIn, rowsIn, innerW) {
   const naturalW = new Array(ncols).fill(0);
   const measure = (cells) => {
     for (let i = 0; i < ncols; i++) {
-      const w = stringWidth4(cleanMarkdown(cells[i]));
+      const w = stringWidth6(cleanMarkdown(cells[i]));
       if (w > naturalW[i]) naturalW[i] = w;
     }
   };
@@ -5348,6 +8069,7 @@ function renderCycleLogMode(rect, state2, focused) {
 }
 
 // src/tui/panels/bottom.ts
+init_render();
 var B = ansiBold;
 var D = ansiDim;
 var SEP = D("\u2502 ");
@@ -5392,6 +8114,7 @@ function renderStatusLine(buf, y, state2, cursorNodeType) {
 }
 
 // src/tui/panels/cross-session-inbox.ts
+init_render();
 var KIND_ICON = {
   notify: "\u2709",
   validation: "\u2713",
@@ -5456,38 +8179,42 @@ function renderCrossSessionInboxRows(rect, state2) {
   return buildPanelRows(rect, lines, state2.crossSessionInboxScroll, focused, "red", state2.inboxRenderedCache);
 }
 
+// src/tui/app.ts
+init_paths();
+
 // src/tui/lib/popup-compose.ts
-import { execSync as execSync4 } from "child_process";
-import { mkdtempSync as mkdtempSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync4, rmSync as rmSync2, existsSync as existsSync2, cpSync as cpSync2 } from "fs";
-import { join as join4 } from "path";
-import { tmpdir as tmpdir2, homedir } from "os";
+init_shell();
+import { execSync as execSync5 } from "child_process";
+import { mkdtempSync as mkdtempSync2, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync14, rmSync as rmSync5, existsSync as existsSync9, cpSync as cpSync3 } from "fs";
+import { join as join13 } from "path";
+import { tmpdir as tmpdir2, homedir as homedir4 } from "os";
 var initLuaEnsured = false;
 function ensureSisyphusInitLua() {
   if (initLuaEnsured) return;
   initLuaEnsured = true;
   try {
-    const destDir = join4(homedir(), ".config", "sisyphus");
-    const destPath = join4(destDir, "init.lua");
-    if (existsSync2(destPath)) return;
-    mkdirSync2(destDir, { recursive: true });
-    const srcPath = join4(import.meta.dirname, "templates", "sisyphus-init.lua");
-    cpSync2(srcPath, destPath);
+    const destDir = join13(homedir4(), ".config", "sisyphus");
+    const destPath = join13(destDir, "init.lua");
+    if (existsSync9(destPath)) return;
+    mkdirSync9(destDir, { recursive: true });
+    const srcPath = join13(import.meta.dirname, "templates", "sisyphus-init.lua");
+    cpSync3(srcPath, destPath);
   } catch {
   }
 }
 function composeViaPopup(action, state2, actions) {
-  const tmpDir = mkdtempSync2(join4(tmpdir2(), "sisyphus-popup-"));
-  const tempFile = join4(tmpDir, "compose.md");
+  const tmpDir = mkdtempSync2(join13(tmpdir2(), "sisyphus-popup-"));
+  const tempFile = join13(tmpDir, "compose.md");
   try {
-    writeFileSync2(tempFile, "", "utf-8");
+    writeFileSync10(tempFile, "", "utf-8");
     const cmd = `NVIM_APPNAME=sisyphus nvim ${shellQuote(tempFile)}`;
-    execSync4(
+    execSync5(
       `tmux display-popup -E -w 90% -h 90% -d ${shellQuote(state2.cwd)} ${shellQuote(cmd)}`,
       { stdio: "inherit", env: EXEC_ENV }
     );
     let rawContent = "";
     try {
-      rawContent = readFileSync4(tempFile, "utf-8");
+      rawContent = readFileSync14(tempFile, "utf-8");
     } catch {
     }
     const required = !OPTIONAL_COMPOSE.has(action.kind);
@@ -5498,19 +8225,21 @@ function composeViaPopup(action, state2, actions) {
   } catch (err) {
     notify(state2, `Failed to open compose popup: ${err.message}`);
   } finally {
-    rmSync2(tmpDir, { recursive: true, force: true });
+    rmSync5(tmpDir, { recursive: true, force: true });
   }
 }
 
 // src/tui/app.ts
+init_config();
+init_paths();
 var _cachedCompanion = null;
 var _companionMtime = 0;
 function getCompanion() {
   try {
-    const { mtimeMs } = statSync2(companionPath());
+    const { mtimeMs } = statSync4(companionPath());
     if (_cachedCompanion && mtimeMs === _companionMtime) return _cachedCompanion;
     _companionMtime = mtimeMs;
-    _cachedCompanion = JSON.parse(readFileSync5(companionPath(), "utf-8"));
+    _cachedCompanion = normalizeCompanion(JSON.parse(readFileSync15(companionPath(), "utf-8")));
     return _cachedCompanion;
   } catch {
     return _cachedCompanion;
@@ -5637,52 +8366,52 @@ function startApp(state2, cleanup2) {
           }
           try {
             const pp = roadmapPath(state2.cwd, state2.selectedSessionId);
-            if (existsSync3(pp)) {
-              planContent = readFileSync5(pp, "utf-8");
+            if (existsSync10(pp)) {
+              planContent = readFileSync15(pp, "utf-8");
             }
           } catch {
           }
           try {
             const gp = goalPath(state2.cwd, state2.selectedSessionId);
-            if (existsSync3(gp)) {
-              goalContent = readFileSync5(gp, "utf-8");
+            if (existsSync10(gp)) {
+              goalContent = readFileSync15(gp, "utf-8");
             }
           } catch {
           }
           try {
             const sp = strategyPath(state2.cwd, state2.selectedSessionId);
-            if (existsSync3(sp)) {
-              strategyContent = readFileSync5(sp, "utf-8");
+            if (existsSync10(sp)) {
+              strategyContent = readFileSync15(sp, "utf-8");
             }
           } catch {
           }
           try {
-            const cp = join5(contextDir(state2.cwd, state2.selectedSessionId), "completion-summary.md");
-            if (existsSync3(cp)) {
-              completionSummaryContent = readFileSync5(cp, "utf-8");
+            const cp = join14(contextDir(state2.cwd, state2.selectedSessionId), "completion-summary.md");
+            if (existsSync10(cp)) {
+              completionSummaryContent = readFileSync15(cp, "utf-8");
             }
           } catch {
           }
           try {
             const ld = logsDir(state2.cwd, state2.selectedSessionId);
-            if (existsSync3(ld)) {
+            if (existsSync10(ld)) {
               if (state2.selectedSessionId !== cachedLogSessionId) {
                 cachedLogFiles = /* @__PURE__ */ new Map();
                 cachedLogSessionId = state2.selectedSessionId;
               }
-              const files = readdirSync2(ld).filter((f) => f.startsWith("cycle-")).sort();
+              const files = readdirSync7(ld).filter((f) => f.startsWith("cycle-")).sort();
               const fileSet = new Set(files);
               for (const key of cachedLogFiles.keys()) {
                 if (!fileSet.has(key)) cachedLogFiles.delete(key);
               }
               for (const f of files) {
-                const filePath = join5(ld, f);
-                const mtime = statSync2(filePath).mtimeMs;
+                const filePath = join14(ld, f);
+                const mtime = statSync4(filePath).mtimeMs;
                 const cached = cachedLogFiles.get(f);
                 if (!cached || cached.mtime !== mtime) {
                   const match = f.match(/cycle-(\d+)\.md$/);
                   const cycle = match ? parseInt(match[1], 10) : 0;
-                  const content = readFileSync5(filePath, "utf-8");
+                  const content = readFileSync15(filePath, "utf-8");
                   cachedLogFiles.set(f, { mtime, cycle, content });
                 }
               }
@@ -5696,13 +8425,13 @@ function startApp(state2, cleanup2) {
           }
           try {
             const cd = contextDir(state2.cwd, state2.selectedSessionId);
-            if (existsSync3(cd)) {
-              const entries = readdirSync2(cd, { withFileTypes: true }).filter((e) => !e.name.startsWith("."));
+            if (existsSync10(cd)) {
+              const entries = readdirSync7(cd, { withFileTypes: true }).filter((e) => !e.name.startsWith("."));
               const flat = [];
               for (const e of entries) {
                 if (e.isDirectory()) {
                   try {
-                    const sub = readdirSync2(join5(cd, e.name)).filter((f) => !f.startsWith(".")).map((f) => `${e.name}/${f}`);
+                    const sub = readdirSync7(join14(cd, e.name)).filter((f) => !f.startsWith(".")).map((f) => `${e.name}/${f}`);
                     flat.push(...sub);
                   } catch {
                   }
@@ -5716,8 +8445,8 @@ function startApp(state2, cleanup2) {
           }
           try {
             const dp = digestPath(state2.cwd, state2.selectedSessionId);
-            if (existsSync3(dp)) {
-              const raw = JSON.parse(readFileSync5(dp, "utf-8"));
+            if (existsSync10(dp)) {
+              const raw = JSON.parse(readFileSync15(dp, "utf-8"));
               if (raw && typeof raw.recentWork === "string" && typeof raw.currentActivity === "string" && typeof raw.whatsNext === "string" && Array.isArray(raw.unusualEvents)) {
                 digestData = raw;
               }
@@ -5860,8 +8589,8 @@ function startApp(state2, cleanup2) {
       if (cursorNode.filePath !== cachedContextFilePath) {
         cachedContextFilePath = cursorNode.filePath;
         try {
-          if (existsSync3(cursorNode.filePath)) {
-            cachedContextFileContent = readFileSync5(cursorNode.filePath, "utf-8");
+          if (existsSync10(cursorNode.filePath)) {
+            cachedContextFileContent = readFileSync15(cursorNode.filePath, "utf-8");
           } else {
             cachedContextFileContent = null;
           }
@@ -5877,7 +8606,7 @@ 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.searchText}:${cursorNode?.type}`;
-    const overlayMode = state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "open-menu" || state2.mode === "agent-menu" || state2.mode === "session-menu" || state2.mode === "go-menu" || state2.mode === "help" || state2.mode === "companion-overlay" || state2.mode === "companion-debug" ? state2.mode : "";
+    const overlayMode = state2.mode === "leader" || state2.mode === "copy-menu" || state2.mode === "open-menu" || state2.mode === "agent-menu" || state2.mode === "session-menu" || state2.mode === "go-menu" || state2.mode === "companion-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();
@@ -5947,7 +8676,8 @@ function startApp(state2, cleanup2) {
         open: "green",
         agent: "blue",
         session: "red",
-        go: "yellow"
+        go: "yellow",
+        companion: "magenta"
       };
       const menuId = MENU_FOR_MODE[state2.mode];
       if (menuId) {
@@ -6063,8 +8793,8 @@ var cwd = getArg("cwd") ?? process.cwd();
 var askId = getArg("ask");
 var sessionId = getArg("session-id");
 if (askId && sessionId) {
-  const { runSingleAsk } = await import("./single-ask-6G4BIVY2.js");
-  await runSingleAsk({ cwd, sessionId, askId });
+  const { runSingleAsk: runSingleAsk2 } = await Promise.resolve().then(() => (init_single_ask(), single_ask_exports));
+  await runSingleAsk2({ cwd, sessionId, askId });
   process.exit(0);
 }
 registerDashboardWindow();