beecork 2.4.2 → 2.5.1

package/dist/index.js

@@ -135,9 +135,10 @@ var config = {
 };
 
 // src/update.ts
-import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { readFile, writeFile, mkdir, realpath } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { join, dirname } from "node:path";
+import { join, dirname, basename, delimiter } from "node:path";
+import { fileURLToPath } from "node:url";
 import { spawn } from "node:child_process";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var cacheFile = () => join(homedir2(), ".beecork", "update-check.json");
@@ -149,6 +150,48 @@ async function currentVersion() {
     return "0.0.0";
   }
 }
+function runningPkgRoot() {
+  return fileURLToPath(new URL("..", import.meta.url));
+}
+function prefixFromPkgRoot(pkgRoot) {
+  const nm = dirname(pkgRoot);
+  if (basename(nm) !== "node_modules") return null;
+  const up = dirname(nm);
+  return basename(up) === "lib" ? dirname(up) : up;
+}
+function installPrefix() {
+  return prefixFromPkgRoot(runningPkgRoot());
+}
+async function findShadowingInstalls() {
+  let running;
+  try {
+    running = await realpath(runningPkgRoot());
+  } catch {
+    running = runningPkgRoot();
+  }
+  const names = process.platform === "win32" ? ["beecork.cmd", "beecork"] : ["beecork"];
+  const seenRoots = /* @__PURE__ */ new Set([running]);
+  const others = [];
+  for (const dir of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
+    for (const name of names) {
+      try {
+        const bin = join(dir, name);
+        const root = dirname(dirname(await realpath(bin)));
+        if (seenRoots.has(root)) continue;
+        seenRoots.add(root);
+        const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8"));
+        if (String(pkg.name) === "beecork") others.push({ bin, version: String(pkg.version ?? "?").replace(/[^\w.+-]/g, "") });
+      } catch {
+      }
+    }
+  }
+  return others;
+}
+async function shadowWarning() {
+  const others = await findShadowingInstalls();
+  if (!others.length) return null;
+  return "\u26A0 Another beecork is on your PATH and may shadow the version you just installed:\n" + others.map((o) => `    ${o.bin}  (v${o.version})`).join("\n") + "\n  Remove the stale one(s) so `beecork` always runs the newest install (may need sudo):\n" + others.map((o) => `    rm ${o.bin}`).join("\n");
+}
 function isNewer(a, b) {
   const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
   const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
@@ -195,8 +238,10 @@ async function checkForUpdate(current) {
 function selfUpdate(timeoutMs = 12e4) {
   return new Promise((resolve2) => {
     const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-    const child = spawn(npm, ["install", "-g", "beecork@latest"], { stdio: ["ignore", "pipe", "pipe"] });
-    let out2 = "", done = false;
+    const prefix = installPrefix();
+    const args = ["install", "-g", "beecork@latest", ...prefix ? ["--prefix", prefix] : []];
+    const child = spawn(npm, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out3 = "", done = false;
     const finish = (r) => {
       if (done) return;
       done = true;
@@ -208,13 +253,13 @@ function selfUpdate(timeoutMs = 12e4) {
         child.kill("SIGKILL");
       } catch {
       }
-      finish({ ok: false, output: `${out2.trim()}
+      finish({ ok: false, output: `${out3.trim()}
 (update timed out after ${timeoutMs}ms \u2014 run manually: npm install -g beecork@latest)`.trim() });
     }, timeoutMs);
-    child.stdout?.on("data", (d) => out2 += d);
-    child.stderr?.on("data", (d) => out2 += d);
+    child.stdout?.on("data", (d) => out3 += d);
+    child.stderr?.on("data", (d) => out3 += d);
     child.on("error", (e) => finish({ ok: false, output: e.message }));
-    child.on("close", (code) => finish({ ok: code === 0, output: out2.trim() }));
+    child.on("close", (code) => finish({ ok: code === 0, output: out3.trim() }));
   });
 }
 
@@ -256,27 +301,65 @@ function lineDiff(oldText, newText) {
       lcs[i2][j2] = a[i2] === b[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
     }
   }
-  const out2 = [];
+  const out3 = [];
   let i = 0;
   let j = 0;
   while (i < m && j < n) {
     if (a[i] === b[j]) {
-      out2.push("  " + a[i]);
+      out3.push("  " + a[i]);
       i++;
       j++;
     } else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
-      out2.push("- " + a[i]);
+      out3.push("- " + a[i]);
       i++;
     } else {
-      out2.push("+ " + b[j]);
+      out3.push("+ " + b[j]);
       j++;
     }
   }
-  while (i < m) out2.push("- " + a[i++]);
-  while (j < n) out2.push("+ " + b[j++]);
-  return out2.join("\n");
+  while (i < m) out3.push("- " + a[i++]);
+  while (j < n) out3.push("+ " + b[j++]);
+  return out3.join("\n");
 }
 
+// src/ansi.ts
+var ESC = "\x1B";
+var CSI = "\x1B[";
+var ansi = {
+  // --- cursor visibility ---
+  hideCursor: CSI + "?25l",
+  showCursor: CSI + "?25h",
+  // --- save / restore cursor (position + attributes) ---
+  saveCursor: ESC + "7",
+  restoreCursor: ESC + "8",
+  // --- clearing ---
+  clearLine: CSI + "2K",
+  // entire current line (cursor row unchanged)
+  clearToEnd: CSI + "J",
+  // cursor → end of screen
+  clearScreen: CSI + "2J",
+  // whole viewport
+  clearScrollback: CSI + "3J",
+  // scrollback buffer (xterm extension)
+  cr: "\r",
+  // carriage return (column 1, same row)
+  home: CSI + "H",
+  // row 1, col 1
+  // --- motion (n omitted → terminal default of 1) ---
+  up: (n = 1) => CSI + n + "A",
+  forward: (n = 1) => CSI + n + "C",
+  moveTo: (row, col = 1) => CSI + row + ";" + col + "H",
+  // --- scroll region (DECSTBM); 1-based, inclusive. reset → full screen ---
+  setRegion: (top, bottom) => CSI + top + ";" + bottom + "r",
+  resetRegion: CSI + "r",
+  // --- bracketed paste mode ---
+  bracketedPasteOn: CSI + "?2004h",
+  bracketedPasteOff: CSI + "?2004l",
+  // --- reverse video (used to draw the pinned input's block cursor) ---
+  reverse: CSI + "7m",
+  reverseOff: CSI + "27m"
+};
+
 // src/ui.ts
 var useColor = process.env.NO_COLOR ? false : process.env.FORCE_COLOR ? true : Boolean(process.stdout.isTTY);
 var paint = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
@@ -294,12 +377,12 @@ var color = {
 };
 var isPrintableCodePoint = (c) => c >= 32 && c !== 127 && !(c >= 128 && c <= 159);
 function stripControl(s) {
-  let out2 = "";
+  let out3 = "";
   for (const ch of s) {
     const c = ch.codePointAt(0);
-    if (c === 9 || c === 10 || isPrintableCodePoint(c)) out2 += ch;
+    if (c === 9 || c === 10 || isPrintableCodePoint(c)) out3 += ch;
   }
-  return out2;
+  return out3;
 }
 var stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
 function charWidth(cp) {
@@ -418,19 +501,19 @@ function startSpinner(label) {
   if (!process.stdout.isTTY || !useColor) return () => {
   };
   let i = 0;
-  const draw2 = () => {
+  const draw = () => {
     if (steeringOnScreen) return;
-    process.stdout.write("\r  " + color.brand(SPINNER[i = (i + 1) % SPINNER.length]) + " " + color.dim(label));
+    process.stdout.write(ansi.cr + "  " + color.brand(SPINNER[i = (i + 1) % SPINNER.length]) + " " + color.dim(label));
   };
-  process.stdout.write("\x1B[?25l");
-  draw2();
-  const timer = setInterval(draw2, 80);
+  process.stdout.write(ansi.hideCursor);
+  draw();
+  const timer = setInterval(draw, 80);
   let stopped = false;
   return () => {
     if (stopped) return;
     stopped = true;
     clearInterval(timer);
-    process.stdout.write("\r\x1B[2K");
+    process.stdout.write(ansi.cr + ansi.clearLine);
   };
 }
 function markLines(width) {
@@ -456,8 +539,9 @@ function markLines(width) {
   }
   return lines.filter((l) => l.length > 0);
 }
-function printBanner(model, sources) {
+function printBanner(model, version, sources) {
   const safeModel = stripControl(model);
+  const safeVersion = stripControl(version);
   const word = [
     "  _                              _    ",
     " | |__   ___  ___  ___ ___  _ __| | __",
@@ -465,21 +549,21 @@ function printBanner(model, sources) {
     " | |_) |  __/  __/ (_| (_) | |  |   < ",
     " |_.__/ \\___|\\___|\\___\\___/|_|  |_|\\_\\"
   ];
-  const mark = markLines(24);
-  const markW = Math.max(0, ...mark.map((l) => l.length));
+  const mark2 = markLines(24);
+  const markW = Math.max(0, ...mark2.map((l) => l.length));
   const wordW = Math.max(...word.map((l) => l.length));
-  const cols = process.stdout.columns || 80;
+  const cols2 = process.stdout.columns || 80;
   console.log();
-  if (cols >= markW + 3 + wordW + 2) {
-    const h = Math.max(mark.length, word.length);
-    const mPad = Math.floor((h - mark.length) / 2);
+  if (cols2 >= markW + 3 + wordW + 2) {
+    const h = Math.max(mark2.length, word.length);
+    const mPad = Math.floor((h - mark2.length) / 2);
     const wPad = Math.floor((h - word.length) / 2);
     for (let i = 0; i < h; i++) {
-      const m = (mark[i - mPad] ?? "").padEnd(markW);
+      const m = (mark2[i - mPad] ?? "").padEnd(markW);
       const w = word[i - wPad] ?? "";
       console.log("  " + color.brand(`${m}   ${w}`));
     }
-  } else if (cols >= wordW + 2) {
+  } else if (cols2 >= wordW + 2) {
     for (const w of word) console.log("  " + color.brand(w));
   } else {
     console.log("  " + color.brand("\u{1F41D} beecork"));
@@ -489,7 +573,7 @@ function printBanner(model, sources) {
   const mem = sources.filter((s) => s.endsWith("memory.md"));
   const cwd = tildify(process.cwd());
   const rows2 = [
-    ["", "\u{1F41D}  a tiny CLI coding agent"],
+    ["", `\u{1F41D}  a tiny CLI coding agent  \xB7  v${safeVersion}`],
     ["dir", cwd],
     ["model", safeModel],
     ["cork.md", cork.length ? cork.join(", ") : "none"],
@@ -500,7 +584,7 @@ function printBanner(model, sources) {
   const plain = (l, v) => l ? l.padEnd(lw) + "   " + v : v;
   const bw = Math.max(...rows2.map(([l, v]) => plain(l, v).length));
   const row = ([l, v]) => l ? color.bold(l.padEnd(lw)) + color.dim("   " + v) : color.dim(v);
-  if (cols < bw + 6) {
+  if (cols2 < bw + 6) {
     for (const r of rows2) console.log("  " + row(r));
   } else {
     console.log("  " + color.dim("\u256D\u2500" + "\u2500".repeat(bw) + "\u2500\u256E"));
@@ -518,6 +602,39 @@ import { readFile as readFile4 } from "node:fs/promises";
 
 // src/input.ts
 import { emitKeypressEvents } from "node:readline";
+
+// src/layout.ts
+function rowColOf(s) {
+  return { row: (s.match(/\n/g) || []).length, col: s.length - (s.lastIndexOf("\n") + 1) };
+}
+function inputLayout(text, before, promptW, cols2) {
+  const c = Math.max(1, cols2);
+  const physRows = text.split("\n").map((l) => Math.max(1, Math.ceil((promptW + displayWidth(l)) / c)));
+  const totalPhys = physRows.reduce((a, b) => a + b, 0);
+  const curLogicalRow = (before.match(/\n/g) || []).length;
+  const curCol = promptW + displayWidth(before.slice(before.lastIndexOf("\n") + 1));
+  const physBefore = physRows.slice(0, curLogicalRow).reduce((a, b) => a + b, 0);
+  const curPhysRow = physBefore + Math.floor(curCol / c);
+  const curPhysCol = curCol % c;
+  return { totalPhys, curPhysRow, curPhysCol };
+}
+function moveVertIndex(buf2, cur2, dir) {
+  const lines = buf2.split("\n");
+  const { row, col } = rowColOf(buf2.slice(0, cur2));
+  const target = row + dir;
+  if (target < 0 || target >= lines.length) return null;
+  let idx = 0;
+  for (let i = 0; i < target; i++) idx += lines[i].length + 1;
+  return idx + Math.min(col, lines[target].length);
+}
+function windowStart(text, cur2, avail) {
+  let start = 0;
+  if (displayWidth(text.slice(0, cur2)) >= avail)
+    while (start < cur2 && displayWidth(text.slice(start, cur2)) >= avail) start++;
+  return start;
+}
+
+// src/input.ts
 var out = (s) => process.stdout.write(s);
 var active = null;
 var started = false;
@@ -525,13 +642,13 @@ function initInput() {
   if (started || !process.stdin.isTTY) return;
   started = true;
   process.stdin.setRawMode(true);
-  out("\x1B[?2004l");
+  out(ansi.bracketedPasteOff);
   emitKeypressEvents(process.stdin);
   process.stdin.on("keypress", (str, key) => active?.(str, key));
 }
 function teardownInput() {
   if (started && process.stdin.isTTY) {
-    out("\x1B[?2004h\x1B[?25h");
+    out(ansi.bracketedPasteOn + ansi.showCursor);
     process.stdin.setRawMode(false);
     process.stdin.pause();
   }
@@ -553,27 +670,27 @@ function readPrompt(opts) {
     ...(opts.skills ?? []).map((n) => ({ name: "/" + n, desc: "skill" }))
   ];
   return new Promise((resolve2) => {
-    let buf = "";
-    let cur = 0;
+    let buf2 = "";
+    let cur2 = 0;
     let hist = history.length;
-    let sel = 0;
-    let menuHidden = false;
-    const BURST_IDLE_MS = 8;
-    let burstLen = 0;
-    let burstTimer = null;
-    let pendingRender = false;
+    let sel2 = 0;
+    let menuHidden2 = false;
+    const BURST_IDLE_MS2 = 8;
+    let burstLen2 = 0;
+    let burstTimer2 = null;
+    let pendingRender2 = false;
     const matches = () => {
       if (opts.mask) return [];
-      const m = buf.match(/^\/(\S*)$/);
+      const m = buf2.match(/^\/(\S*)$/);
       if (!m) return [];
       const pre = "/" + m[1];
       return all.filter((c) => c.name.startsWith(pre)).slice(0, MENU_MAX);
     };
-    const menu = () => menuHidden ? [] : matches();
+    const menu = () => menuHidden2 ? [] : matches();
     const highlight = () => {
-      if (opts.mask) return "*".repeat(buf.length);
-      const m = buf.match(/^(\/\S*)([\s\S]*)$/);
-      if (!m) return buf;
+      if (opts.mask) return "*".repeat(buf2.length);
+      const m = buf2.match(/^(\/\S*)([\s\S]*)$/);
+      if (!m) return buf2;
       const [, token, rest] = m;
       const known = all.some((c) => c.name === token);
       const partial = all.some((c) => c.name.startsWith(token));
@@ -581,7 +698,6 @@ function readPrompt(opts) {
       return styled + rest;
     };
     let lastCurRow = 0;
-    const rowColOf = (s) => ({ row: (s.match(/\n/g) || []).length, col: s.length - (s.lastIndexOf("\n") + 1) });
     function drawBlock() {
       const prompt = opts.promptString();
       const promptW = stripAnsi(prompt).length;
@@ -591,199 +707,189 @@ function readPrompt(opts) {
       for (let i = 1; i < lines.length; i++) out("\n" + indent + lines[i]);
       return { promptW };
     }
-    function render() {
+    function render2() {
       const mm = menu();
-      if (sel >= mm.length) sel = Math.max(0, mm.length - 1);
-      out("\x1B[?25l");
-      if (lastCurRow > 0) out(`\x1B[${lastCurRow}A`);
-      out("\r\x1B[J");
+      if (sel2 >= mm.length) sel2 = Math.max(0, mm.length - 1);
+      out(ansi.hideCursor);
+      if (lastCurRow > 0) out(ansi.up(lastCurRow));
+      out(ansi.cr + ansi.clearToEnd);
       const { promptW } = drawBlock();
-      const cols = Math.max(1, process.stdout.columns || 80);
+      const cols2 = Math.max(1, process.stdout.columns || 80);
       for (let i = 0; i < mm.length; i++) {
         const m = mm[i];
         const name = m.name.padEnd(10);
-        const maxDesc = Math.max(0, cols - name.length - 4);
+        const maxDesc = Math.max(0, cols2 - name.length - 4);
         const desc = m.desc.length > maxDesc ? m.desc.slice(0, Math.max(0, maxDesc - 1)) + "\u2026" : m.desc;
-        out("\n" + (i === sel ? color.green("\u203A " + name) + " " + color.dim(desc) : color.dim("  " + name + " " + desc)));
-      }
-      const text = opts.mask ? "*".repeat(buf.length) : buf;
-      const physRows = text.split("\n").map((l) => Math.max(1, Math.ceil((promptW + displayWidth(l)) / cols)));
-      const totalInputPhys = physRows.reduce((a, b) => a + b, 0);
-      const before = opts.mask ? text : buf.slice(0, cur);
-      const curLogicalRow = (before.match(/\n/g) || []).length;
-      const curCol = promptW + displayWidth(before.slice(before.lastIndexOf("\n") + 1));
-      const physBefore = physRows.slice(0, curLogicalRow).reduce((a, b) => a + b, 0);
-      const curPhysRow = physBefore + Math.floor(curCol / cols);
-      const curPhysCol = curCol % cols;
-      const lastDrawnRow = totalInputPhys - 1 + mm.length;
-      if (lastDrawnRow > curPhysRow) out(`\x1B[${lastDrawnRow - curPhysRow}A`);
-      out("\r" + (curPhysCol > 0 ? `\x1B[${curPhysCol}C` : "") + "\x1B[?25h");
+        out("\n" + (i === sel2 ? color.green("\u203A " + name) + " " + color.dim(desc) : color.dim("  " + name + " " + desc)));
+      }
+      const text = opts.mask ? "*".repeat(buf2.length) : buf2;
+      const before = opts.mask ? text : buf2.slice(0, cur2);
+      const { totalPhys, curPhysRow, curPhysCol } = inputLayout(text, before, promptW, cols2);
+      const lastDrawnRow = totalPhys - 1 + mm.length;
+      if (lastDrawnRow > curPhysRow) out(ansi.up(lastDrawnRow - curPhysRow));
+      out(ansi.cr + (curPhysCol > 0 ? ansi.forward(curPhysCol) : "") + ansi.showCursor);
       lastCurRow = curPhysRow;
     }
     function finish(result) {
       restore();
-      if (burstTimer) {
-        clearTimeout(burstTimer);
-        burstTimer = null;
-      }
-      pendingRender = false;
-      out("\x1B[?25l");
-      if (lastCurRow > 0) out(`\x1B[${lastCurRow}A`);
-      out("\r\x1B[J");
+      if (burstTimer2) {
+        clearTimeout(burstTimer2);
+        burstTimer2 = null;
+      }
+      pendingRender2 = false;
+      out(ansi.hideCursor);
+      if (lastCurRow > 0) out(ansi.up(lastCurRow));
+      out(ansi.cr + ansi.clearToEnd);
       drawBlock();
       out("\n");
       if (result.type === "line" && result.value.trim() && !opts.mask) history.push(result.value);
       resolve2(result);
     }
-    function insert(s) {
-      buf = buf.slice(0, cur) + s + buf.slice(cur);
-      cur += s.length;
-      menuHidden = false;
-      sel = 0;
-      pendingRender = true;
+    function insert2(s) {
+      buf2 = buf2.slice(0, cur2) + s + buf2.slice(cur2);
+      cur2 += s.length;
+      menuHidden2 = false;
+      sel2 = 0;
+      pendingRender2 = true;
     }
-    function onKey(str, key) {
+    function onKey2(str, key) {
       const mm = menu();
-      burstLen++;
-      if (burstTimer) clearTimeout(burstTimer);
-      burstTimer = setTimeout(() => {
-        burstTimer = null;
-        burstLen = 0;
-        if (pendingRender) {
-          pendingRender = false;
-          render();
+      burstLen2++;
+      if (burstTimer2) clearTimeout(burstTimer2);
+      burstTimer2 = setTimeout(() => {
+        burstTimer2 = null;
+        burstLen2 = 0;
+        if (pendingRender2) {
+          pendingRender2 = false;
+          render2();
         }
-      }, BURST_IDLE_MS);
+      }, BURST_IDLE_MS2);
       if (isEnter(key)) {
-        if (key?.shift || key?.meta || burstLen > 1) {
-          insert("\n");
+        if (key?.shift || key?.meta || burstLen2 > 1) {
+          insert2("\n");
           return;
         }
-        return finish({ type: "line", value: buf });
+        return finish({ type: "line", value: buf2 });
       }
       if (key?.ctrl && key.name === "c") {
-        if (buf) {
-          buf = "";
-          cur = 0;
-          render();
+        if (buf2) {
+          buf2 = "";
+          cur2 = 0;
+          render2();
         } else finish({ type: "quit" });
         return;
       }
       if (key?.ctrl && key.name === "d") {
-        if (!buf) finish({ type: "eof" });
+        if (!buf2) finish({ type: "eof" });
         return;
       }
       if (key?.name === "tab" && key.shift) {
         opts.onShiftTab?.();
-        render();
+        render2();
         return;
       }
       if (key?.name === "tab") {
         if (mm.length) {
-          buf = mm[sel].name + " ";
-          cur = buf.length;
-          menuHidden = false;
-          render();
+          buf2 = mm[sel2].name + " ";
+          cur2 = buf2.length;
+          menuHidden2 = false;
+          render2();
         }
         return;
       }
       if (key?.name === "up") {
         if (mm.length) {
-          sel = (sel - 1 + mm.length) % mm.length;
-          render();
-        } else if (buf.includes("\n")) moveVert(-1);
+          sel2 = (sel2 - 1 + mm.length) % mm.length;
+          render2();
+        } else if (buf2.includes("\n")) moveVert(-1);
         else histPrev();
         return;
       }
       if (key?.name === "down") {
         if (mm.length) {
-          sel = (sel + 1) % mm.length;
-          render();
-        } else if (buf.includes("\n")) moveVert(1);
+          sel2 = (sel2 + 1) % mm.length;
+          render2();
+        } else if (buf2.includes("\n")) moveVert(1);
         else histNext();
         return;
       }
       if (key?.name === "left") {
-        if (cur > 0) cur--;
-        render();
+        if (cur2 > 0) cur2--;
+        render2();
         return;
       }
       if (key?.name === "right") {
-        if (cur < buf.length) cur++;
-        render();
+        if (cur2 < buf2.length) cur2++;
+        render2();
         return;
       }
       if (key?.name === "home" || key?.ctrl && key.name === "a") {
-        cur = 0;
-        render();
+        cur2 = 0;
+        render2();
         return;
       }
       if (key?.name === "end" || key?.ctrl && key.name === "e") {
-        cur = buf.length;
-        render();
+        cur2 = buf2.length;
+        render2();
         return;
       }
       if (key?.ctrl && key.name === "u") {
-        buf = buf.slice(cur);
-        cur = 0;
-        menuHidden = false;
-        render();
+        buf2 = buf2.slice(cur2);
+        cur2 = 0;
+        menuHidden2 = false;
+        render2();
         return;
       }
       if (key?.name === "backspace") {
-        if (cur > 0) {
-          buf = buf.slice(0, cur - 1) + buf.slice(cur);
-          cur--;
-          menuHidden = false;
-          render();
+        if (cur2 > 0) {
+          buf2 = buf2.slice(0, cur2 - 1) + buf2.slice(cur2);
+          cur2--;
+          menuHidden2 = false;
+          render2();
         }
         return;
       }
       if (key?.name === "delete") {
-        if (cur < buf.length) {
-          buf = buf.slice(0, cur) + buf.slice(cur + 1);
-          menuHidden = false;
-          render();
+        if (cur2 < buf2.length) {
+          buf2 = buf2.slice(0, cur2) + buf2.slice(cur2 + 1);
+          menuHidden2 = false;
+          render2();
         }
         return;
       }
       if (key?.name === "escape") {
         if (mm.length) {
-          menuHidden = true;
-          render();
+          menuHidden2 = true;
+          render2();
         }
         return;
       }
       if (str && !key?.ctrl && !key?.meta && [...str].length === 1) {
-        if (isPrintableCodePoint(str.codePointAt(0))) insert(str);
+        if (isPrintableCodePoint(str.codePointAt(0))) insert2(str);
       }
     }
     function moveVert(dir) {
-      const lines = buf.split("\n");
-      const { row, col } = rowColOf(buf.slice(0, cur));
-      const target = row + dir;
-      if (target < 0 || target >= lines.length) return;
-      let idx = 0;
-      for (let i = 0; i < target; i++) idx += lines[i].length + 1;
-      cur = idx + Math.min(col, lines[target].length);
-      render();
+      const idx = moveVertIndex(buf2, cur2, dir);
+      if (idx === null) return;
+      cur2 = idx;
+      render2();
     }
     function histPrev() {
       if (history.length === 0) return;
       hist = Math.max(0, hist - 1);
-      buf = history[hist] ?? "";
-      cur = buf.length;
-      render();
+      buf2 = history[hist] ?? "";
+      cur2 = buf2.length;
+      render2();
     }
     function histNext() {
       if (hist >= history.length) return;
       hist += 1;
-      buf = hist === history.length ? "" : history[hist];
-      cur = buf.length;
-      render();
+      buf2 = hist === history.length ? "" : history[hist];
+      cur2 = buf2.length;
+      render2();
     }
-    const restore = pushKeyHandler(onKey);
-    render();
+    const restore = pushKeyHandler(onKey2);
+    render2();
   });
 }
 function readChoice(prompt) {
@@ -804,36 +910,36 @@ function readChoice(prompt) {
 function selectMenu(opts) {
   if (!process.stdin.isTTY || opts.items.length === 0) return Promise.resolve(null);
   return new Promise((resolve2) => {
-    let sel = Math.max(0, Math.min(opts.initial ?? 0, opts.items.length - 1));
+    let sel2 = Math.max(0, Math.min(opts.initial ?? 0, opts.items.length - 1));
     let drawn = 0;
-    function render() {
-      out("\x1B[?25l");
-      if (drawn > 0) out(`\x1B[${drawn}A`);
-      out("\r\x1B[J");
+    function render2() {
+      out(ansi.hideCursor);
+      if (drawn > 0) out(ansi.up(drawn));
+      out(ansi.cr + ansi.clearToEnd);
       out(color.dim(opts.title) + "\n");
       opts.items.forEach((it, i) => {
-        const row = i === sel ? color.green("\u203A " + it.label) : "  " + it.label;
+        const row = i === sel2 ? color.green("\u203A " + it.label) : "  " + it.label;
         out(row + (it.hint ? color.dim("  " + it.hint) : "") + "\n");
       });
       drawn = opts.items.length + 1;
     }
     function finish(v) {
       restore();
-      if (drawn > 0) out(`\x1B[${drawn}A\r\x1B[J`);
-      out("\x1B[?25h");
+      if (drawn > 0) out(ansi.up(drawn) + ansi.cr + ansi.clearToEnd);
+      out(ansi.showCursor);
       resolve2(v);
     }
     const restore = pushKeyHandler((_str, key) => {
       if (key?.name === "up") {
-        sel = (sel - 1 + opts.items.length) % opts.items.length;
-        render();
+        sel2 = (sel2 - 1 + opts.items.length) % opts.items.length;
+        render2();
       } else if (key?.name === "down") {
-        sel = (sel + 1) % opts.items.length;
-        render();
-      } else if (isEnter(key)) finish(opts.items[sel].value);
+        sel2 = (sel2 + 1) % opts.items.length;
+        render2();
+      } else if (isEnter(key)) finish(opts.items[sel2].value);
       else if (key?.name === "escape" || key?.name === "q" || key?.ctrl && key.name === "c") finish(null);
     });
-    render();
+    render2();
   });
 }
 
@@ -843,46 +949,46 @@ function renderFileBox(path, startLine, lines, hasMore) {
   const p = stripControl(path);
   const numW = String(startLine + Math.max(0, lines.length - 1)).length;
   const header = startLine === 1 && !hasMore ? `${lines.length} line${lines.length === 1 ? "" : "s"}` : `lines ${startLine}\u2013${startLine + lines.length - 1}${hasMore ? " (+ more)" : ""}`;
-  const out2 = [color.dim("\u256D\u2500 ") + color.bold(p) + color.dim(`  ${header}`)];
-  lines.forEach((l, i) => out2.push(color.dim("\u2502 ") + color.dim(String(startLine + i).padStart(numW)) + "  " + stripControl(l)));
-  if (hasMore) out2.push(color.dim("\u2502 ") + color.dim(`\u2026 more (show ${p} offset ${startLine + lines.length})`));
-  out2.push(color.dim("\u2570\u2500"));
-  return out2.join("\n") + "\n";
+  const out3 = [color.dim("\u256D\u2500 ") + color.bold(p) + color.dim(`  ${header}`)];
+  lines.forEach((l, i) => out3.push(color.dim("\u2502 ") + color.dim(String(startLine + i).padStart(numW)) + "  " + stripControl(l)));
+  if (hasMore) out3.push(color.dim("\u2502 ") + color.dim(`\u2026 more (show ${p} offset ${startLine + lines.length})`));
+  out3.push(color.dim("\u2570\u2500"));
+  return out3.join("\n") + "\n";
 }
 function renderListing(path, names) {
   const safe = names.map(stripControl);
-  const out2 = [color.dim("\u256D\u2500 ") + color.bold(stripControl(path)) + color.dim(`  ${safe.length} entr${safe.length === 1 ? "y" : "ies"}`)];
+  const out3 = [color.dim("\u256D\u2500 ") + color.bold(stripControl(path)) + color.dim(`  ${safe.length} entr${safe.length === 1 ? "y" : "ies"}`)];
   if (safe.length === 0) {
-    out2.push(color.dim("\u2502 ") + color.dim("(empty)"));
+    out3.push(color.dim("\u2502 ") + color.dim("(empty)"));
   } else {
     const avail = BOX_W() - 2;
     const colW = Math.min(Math.max(...safe.map((n) => n.length)) + 2, 40);
-    const cols = Math.max(1, Math.floor(avail / colW));
-    const rows2 = Math.ceil(safe.length / cols);
+    const cols2 = Math.max(1, Math.floor(avail / colW));
+    const rows2 = Math.ceil(safe.length / cols2);
     for (let r = 0; r < rows2; r++) {
       let line = "";
-      for (let c = 0; c < cols; c++) {
+      for (let c = 0; c < cols2; c++) {
         const idx = c * rows2 + r;
         if (idx >= safe.length) continue;
         const n = safe[idx];
         line += (n.endsWith("/") ? color.cyan(n) : n) + " ".repeat(Math.max(1, colW - n.length));
       }
-      out2.push(color.dim("\u2502 ") + line.replace(/\s+$/, ""));
+      out3.push(color.dim("\u2502 ") + line.replace(/\s+$/, ""));
     }
   }
-  out2.push(color.dim("\u2570\u2500"));
-  return out2.join("\n") + "\n";
+  out3.push(color.dim("\u2570\u2500"));
+  return out3.join("\n") + "\n";
 }
 function renderTree(path, items, truncated) {
   const dirs = items.filter((it) => it.isDir).length;
-  const out2 = [color.dim("\u256D\u2500 ") + color.bold(stripControl(path)) + color.dim(`  ${items.length} entries \xB7 ${dirs} folders`)];
+  const out3 = [color.dim("\u256D\u2500 ") + color.bold(stripControl(path)) + color.dim(`  ${items.length} entries \xB7 ${dirs} folders`)];
   for (const it of items) {
     const nm = stripControl(it.name);
-    out2.push(color.dim("\u2502 ") + color.dim(it.prefix) + (it.isDir ? color.cyan(nm) : nm));
+    out3.push(color.dim("\u2502 ") + color.dim(it.prefix) + (it.isDir ? color.cyan(nm) : nm));
   }
-  if (truncated) out2.push(color.dim("\u2502 ") + color.dim("\u2026 (truncated)"));
-  out2.push(color.dim("\u2570\u2500"));
-  return out2.join("\n") + "\n";
+  if (truncated) out3.push(color.dim("\u2502 ") + color.dim("\u2026 (truncated)"));
+  out3.push(color.dim("\u2570\u2500"));
+  return out3.join("\n") + "\n";
 }
 var SHOW_MARK = "
";
 var SHOW_KINDS = ["file", "dir", "tree"];
@@ -991,14 +1097,14 @@ function renderTable(rows2) {
     })
   );
   const width = Array.from({ length: ncol }, (_, c) => Math.max(...styled.map((r) => visLen(r[c]))));
-  const out2 = styled.map((r) => {
+  const out3 = styled.map((r) => {
     const cells = r.map((cell, c) => cell + " ".repeat(Math.max(0, width[c] - visLen(cell))));
     return "  " + cells.join(color.dim("  \u2502  "));
   });
-  return out2.join("\n") + "\n";
+  return out3.join("\n") + "\n";
 }
 function createMarkdownStream(write) {
-  let buf = "";
+  let buf2 = "";
   let scanFrom = 0;
   let inCode = false;
   let first = true;
@@ -1037,19 +1143,19 @@ function createMarkdownStream(write) {
   }
   return {
     push(text) {
-      buf += text;
+      buf2 += text;
       let i;
-      while ((i = buf.indexOf("\n", scanFrom)) >= 0) {
-        emit(buf.slice(0, i));
-        buf = buf.slice(i + 1);
+      while ((i = buf2.indexOf("\n", scanFrom)) >= 0) {
+        emit(buf2.slice(0, i));
+        buf2 = buf2.slice(i + 1);
         scanFrom = 0;
       }
-      scanFrom = buf.length;
+      scanFrom = buf2.length;
     },
     end() {
-      if (buf) {
-        emit(buf);
-        buf = "";
+      if (buf2) {
+        emit(buf2);
+        buf2 = "";
       }
       flushTable();
       if (inCode) {
@@ -1247,7 +1353,7 @@ async function runExplorer(task, focus, signal) {
 
 // src/safety.ts
 import { homedir as homedir3 } from "node:os";
-import { basename } from "node:path";
+import { basename as basename2 } from "node:path";
 function pathGuard(args) {
   const { abs, inRoot } = resolveInRoot(String(args.path ?? "."));
   return inRoot ? {} : { needsApproval: true, reason: `path is outside the project root: ${abs}`, cacheKey: `path:${abs}` };
@@ -1255,7 +1361,7 @@ function pathGuard(args) {
 var SECRET_FILE = /(^|\/)(\.env(\.[\w.-]+)?|[\w.-]*\.(env|pem|key|secret|pfx|p12|jks|keystore)|id_(rsa|ed25519|ecdsa|dsa)|credentials|\.git-credentials|\.pgpass|\.npmrc|\.netrc)$/i;
 function isSecretPath(userPath) {
   const { abs } = resolveInRoot(userPath);
-  return SECRET_FILE.test(abs) || SECRET_FILE.test(basename(abs));
+  return SECRET_FILE.test(abs) || SECRET_FILE.test(basename2(abs));
 }
 function secretGuard(args) {
   const p = pathGuard(args);
@@ -1471,13 +1577,13 @@ async function atomicWrite(abs, content) {
 }
 var READ_PREFIX = /^ *\d+ {2}/;
 function allIndexOf(hay, needle) {
-  const out2 = [];
+  const out3 = [];
   let i = hay.indexOf(needle);
   while (i !== -1) {
-    out2.push(i);
+    out3.push(i);
     i = hay.indexOf(needle, i + 1);
   }
-  return out2;
+  return out3;
 }
 function stripReadPrefix(text) {
   const lines = text.split("\n");
@@ -1972,11 +2078,11 @@ ${res.closest}` : `Re-read the file and copy the exact text (including whitespac
 ${stderr}` : "") || "(no output)";
       } catch (err) {
         const e = err;
-        const out2 = `${e.stdout ?? ""}${e.stderr ? `
+        const out3 = `${e.stdout ?? ""}${e.stderr ? `
 [stderr]
 ${e.stderr}` : ""}`.trim();
-        return `Error: command failed${out2 ? `:
-${out2}` : `: ${String(e.message ?? err)}`}`;
+        return `Error: command failed${out3 ? `:
+${out3}` : `: ${String(e.message ?? err)}`}`;
       }
     }
   },
@@ -2221,14 +2327,14 @@ function validateArgs(tool, args) {
 async function runVerify(signal) {
   try {
     const { stdout, stderr } = await runShell(config.verifyCommand, { timeout: config.verifyTimeoutMs, maxBuffer: config.maxToolBuffer, signal });
-    const out2 = `${stdout}${stderr}`.trim();
-    return `passed \u2713${out2 ? `
-${out2.slice(-800)}` : ""}`;
+    const out3 = `${stdout}${stderr}`.trim();
+    return `passed \u2713${out3 ? `
+${out3.slice(-800)}` : ""}`;
   } catch (err) {
     const e = err;
-    const out2 = `${e.stdout ?? ""}${e.stderr ?? ""}`.trim() || String(e.message ?? err);
+    const out3 = `${e.stdout ?? ""}${e.stderr ?? ""}`.trim() || String(e.message ?? err);
     return `FAILED \u2717
-${out2.slice(-1500)}`;
+${out3.slice(-1500)}`;
   }
 }
 
@@ -2261,12 +2367,12 @@ function parseSSELine(line) {
   }
   const delta = parsed.choices?.[0]?.delta;
   if (!delta) return null;
-  const out2 = {};
-  if (delta.content) out2.content = delta.content;
-  if (delta.tool_calls) out2.toolCalls = delta.tool_calls;
-  if (typeof delta.reasoning === "string" && delta.reasoning) out2.reasoning = delta.reasoning;
-  if (Array.isArray(delta.reasoning_details) && delta.reasoning_details.length) out2.reasoningDetails = delta.reasoning_details;
-  return out2;
+  const out3 = {};
+  if (delta.content) out3.content = delta.content;
+  if (delta.tool_calls) out3.toolCalls = delta.tool_calls;
+  if (typeof delta.reasoning === "string" && delta.reasoning) out3.reasoning = delta.reasoning;
+  if (Array.isArray(delta.reasoning_details) && delta.reasoning_details.length) out3.reasoningDetails = delta.reasoning_details;
+  return out3;
 }
 function buildRequestBody(opts) {
   const { model, messages, includeTools, effort, reasoningSupported, extra, tools } = opts;
@@ -2672,7 +2778,7 @@ async function saveSession(messages) {
 }
 function sanitizeSession(raw) {
   if (!Array.isArray(raw)) return null;
-  const out2 = [];
+  const out3 = [];
   for (const m of raw) {
     if (!m || typeof m !== "object") return null;
     const role = m.role;
@@ -2685,9 +2791,9 @@ function sanitizeSession(raw) {
     if (Array.isArray(tc)) msg.tool_calls = tc;
     const tcid = m.tool_call_id;
     if (typeof tcid === "string") msg.tool_call_id = tcid;
-    out2.push(msg);
+    out3.push(msg);
   }
-  return dropIncompleteToolTail(out2);
+  return dropIncompleteToolTail(out3);
 }
 function dropIncompleteToolTail(messages) {
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -2730,15 +2836,15 @@ async function loadLatestSession() {
 async function listSessions() {
   try {
     const files = (await readdir2(sessionsDir())).filter((f) => f.endsWith(".json"));
-    const out2 = [];
+    const out3 = [];
     for (const f of files) {
       const msgs = await readSession(f);
       if (!msgs || !msgs.length) continue;
       const firstUser = msgs.find((m) => m.role === "user");
       const preview = (firstUser?.content ?? "").replace(/\s+/g, " ").trim().slice(0, 60);
-      out2.push({ file: f, when: Number(f.replace(".json", "")) || 0, count: msgs.length, preview });
+      out3.push({ file: f, when: Number(f.replace(".json", "")) || 0, count: msgs.length, preview });
     }
-    return out2.sort((a, b) => b.when - a.when);
+    return out3.sort((a, b) => b.when - a.when);
   } catch {
     return [];
   }
@@ -2978,7 +3084,7 @@ ${content}` }];
   }
   return [...messages, { role: "user", content }];
 }
-async function runTurn(messages, userInput, ask, approvedTools, approvedGuardKeys, signal, steering) {
+async function runTurn(messages, userInput, ask, approvedTools, approvedGuardKeys, signal, steering2) {
   messages.push({ role: "user", content: userInput });
   const snapshot = messages.slice();
   try {
@@ -2992,7 +3098,7 @@ async function runTurn(messages, userInput, ask, approvedTools, approvedGuardKey
         console.error(color.red(`
 [compaction failed: ${err.message} \u2014 continuing]`) + "\n");
       }
-      if (steering?.length) messages = applySteering(messages, steering.splice(0));
+      if (steering2?.length) messages = applySteering(messages, steering2.splice(0));
       const message = await callModel(messages, true, signal);
       messages.push(message);
       if (!hasContent2(message)) {
@@ -3006,7 +3112,7 @@ async function runTurn(messages, userInput, ask, approvedTools, approvedGuardKey
           await handleToolCall(call, messages, step, deps);
         }
       } else {
-        answered = !steering?.length;
+        answered = !steering2?.length;
       }
     }
     if (signal?.aborted) {
@@ -3078,62 +3184,395 @@ async function runtimeContext() {
   });
 }
 
-// src/statusline.ts
+// src/chrome.ts
 import { execFile as execFile2 } from "node:child_process";
+var out2 = (s) => process.stdout.write(s);
+var rows = () => process.stdout.rows ?? 24;
+var cols = () => process.stdout.columns ?? 80;
 var active2 = false;
-var drawTimer = null;
-var gitTimer = null;
+var turnActive = false;
+var buf = "";
+var cur = 0;
+var allItems = [];
+var sel = 0;
+var menuHidden = false;
+var menuH = 0;
+var prevMenuH = 0;
+var lastRegionB = -1;
+var pickItems = null;
+var pickSel = 0;
+var pickTitle = "";
+var pickResolve = null;
 var branch = "";
-var tokensOf = null;
-var rows = () => process.stdout.rows ?? 24;
+var tokensOf = () => 0;
+var onResult = null;
+var onInterrupt = null;
+var steering = [];
+var restoreKeys = null;
+var gitTimer = null;
+var statusTimer = null;
+var lastRows = 0;
+var BURST_IDLE_MS = 8;
+var burstLen = 0;
+var burstTimer = null;
+var pendingRender = false;
+var statusRow = () => Math.max(1, rows());
+var borderBottomRow = () => Math.max(1, rows() - 1);
+var inputRow = () => Math.max(1, rows() - 2);
+var borderTopRow = () => Math.max(1, rows() - 3);
+var mark = () => color.green("\u203A ");
+var PW = 2;
+function modeSegment() {
+  return state.mode === "auto" ? color.yellow("auto-approve") : state.mode === "readonly" ? color.cyan("read-only") : color.green("normal");
+}
+function statusText() {
+  const model = state.model.split("/").pop() ?? state.model;
+  const tok = tokensOf();
+  const ctxK = Math.round(config.maxContextTokens / 1e3);
+  const parts = [
+    modeSegment(),
+    color.cyan(model),
+    color.dim(state.reasoningEffort),
+    ...branch ? [color.green(branch)] : [],
+    color.dim(`~${Math.round(tok / 1e3)}k/${ctxK}k`)
+  ];
+  const bg = runningTaskCount();
+  if (bg > 0) parts.push(color.yellow(`${bg} task${bg === 1 ? "" : "s"}`));
+  return parts.join(color.dim(" \xB7 "));
+}
 function pollGit() {
-  execFile2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: 1500, windowsHide: true }, (err, out2) => {
+  execFile2("git", ["rev-parse", "--abbrev-ref", "HEAD"], { timeout: 1500, windowsHide: true }, (err, o) => {
     if (err) {
       branch = "";
       return;
     }
-    const b = String(out2).trim();
-    execFile2("git", ["status", "--porcelain"], { timeout: 1500, windowsHide: true }, (e2, out22) => {
-      branch = b + (!e2 && String(out22).trim() ? "*" : "");
+    const b = String(o).trim();
+    execFile2("git", ["status", "--porcelain"], { timeout: 1500, windowsHide: true }, (e2, o2) => {
+      branch = b + (!e2 && String(o2).trim() ? "*" : "");
     });
   });
 }
-function segments() {
-  const parts = [state.model.split("/").pop() ?? state.model, state.reasoningEffort];
-  if (branch) parts.push(branch);
-  if (tokensOf) parts.push(`~${Math.round(tokensOf() / 1e3)}k`);
-  const bg = runningTaskCount();
-  if (bg > 0) parts.push(`${bg} task${bg === 1 ? "" : "s"}`);
-  return parts.join(" \xB7 ");
+function drawStatus() {
+  const s = statusText();
+  const vis = stripAnsi(s);
+  out2(ansi.moveTo(statusRow()) + ansi.clearLine + (vis.length <= cols() ? s : stripAnsi(s).slice(0, cols() - 1)));
 }
-function draw() {
+function drawBorder(row) {
+  out2(ansi.moveTo(row) + ansi.clearLine + color.dim("\u2500".repeat(Math.max(1, cols()))));
+}
+var closePick = () => {
+  pickItems = null;
+  pickSel = 0;
+  pickTitle = "";
+};
+function chromePick(items, initial = 0, title = "") {
+  return new Promise((resolve2) => {
+    if (!active2 || !items.length) {
+      resolve2(null);
+      return;
+    }
+    pickItems = items;
+    pickSel = Math.min(Math.max(0, initial), items.length - 1);
+    pickTitle = title;
+    pickResolve = resolve2;
+    render();
+  });
+}
+var flat = (s) => s.replace(/\n/g, "\u23CE");
+function drawInput() {
+  const disp = flat(buf);
+  const start = windowStart(disp, cur, Math.max(1, cols() - PW));
+  const shown = disp.slice(start);
+  const ci = cur - start;
+  let body;
+  if (!buf) {
+    body = ansi.reverse + " " + ansi.reverseOff + color.dim("type a message \xB7 / for commands \xB7 Shift+Tab mode");
+  } else {
+    const at = ci < shown.length ? shown[ci] : " ";
+    body = shown.slice(0, ci) + ansi.reverse + at + ansi.reverseOff + (ci < shown.length ? shown.slice(ci + 1) : "");
+  }
+  out2(ansi.moveTo(inputRow()) + ansi.clearLine + mark() + body);
+}
+function currentMenu() {
+  if (menuHidden || turnActive) return [];
+  const m = buf.match(/^\/(\S*)$/);
+  if (!m) return [];
+  const pre = "/" + m[1];
+  return allItems.filter((c) => c.name.startsWith(pre)).slice(0, 8);
+}
+function render() {
   if (!active2) return;
-  process.stdout.write(`\x1B7\x1B[${rows()};1H\x1B[2K${color.dim(segments())}\x1B8`);
+  const picker = pickItems;
+  const list = picker ? picker.slice(0, 12).map((it, i) => ({ text: it.label + (it.hint ? "  " + color.dim(it.hint) : ""), on: i === pickSel })) : currentMenu().map((it, i) => ({ text: it.name.padEnd(12) + " " + it.desc, on: i === sel }));
+  if (!picker && sel >= list.length) sel = Math.max(0, list.length - 1);
+  menuH = list.length;
+  out2(ansi.hideCursor + ansi.saveCursor);
+  const regionB = Math.max(1, rows() - 4 - menuH);
+  if (regionB !== lastRegionB) {
+    out2(ansi.setRegion(1, regionB));
+    lastRegionB = regionB;
+  }
+  for (let r = borderTopRow() - prevMenuH; r < borderTopRow() - menuH; r++) out2(ansi.moveTo(r) + ansi.clearLine);
+  prevMenuH = menuH;
+  const base = borderTopRow() - menuH;
+  for (let i = 0; i < list.length; i++) {
+    out2(ansi.moveTo(base + i) + ansi.clearLine + (list[i].on ? color.green("\u203A ") + list[i].text : color.dim("  ") + list[i].text));
+  }
+  drawBorder(borderTopRow());
+  if (picker) out2(ansi.moveTo(inputRow()) + ansi.clearLine + mark() + color.dim(pickTitle || "\u2191/\u2193 to choose \xB7 Enter to select \xB7 Esc to cancel"));
+  else drawInput();
+  drawBorder(borderBottomRow());
+  drawStatus();
+  out2(ansi.restoreCursor);
+  lastRows = rows();
+  pendingRender = false;
 }
 function onResize() {
   if (!active2) return;
-  process.stdout.write(`\x1B[1;${rows() - 1}r`);
-  draw();
+  const newRows = rows();
+  if (lastRows > 0 && newRows > lastRows) {
+    out2(ansi.saveCursor);
+    const oldTop = Math.max(1, lastRows - 3 - prevMenuH);
+    for (let r = oldTop; r <= lastRows; r++) out2(ansi.moveTo(r) + ansi.clearLine);
+    out2(ansi.restoreCursor);
+  }
+  lastRegionB = -1;
+  render();
+}
+function refreshChrome() {
+  if (!active2) return;
+  out2(ansi.hideCursor + ansi.saveCursor);
+  drawStatus();
+  out2(ansi.restoreCursor);
+}
+var edited = () => {
+  menuHidden = false;
+  sel = 0;
+};
+function insert(s) {
+  buf = buf.slice(0, cur) + s + buf.slice(cur);
+  cur += s.length;
+  edited();
+  pendingRender = true;
+}
+function resetBurst() {
+  if (burstTimer) {
+    clearTimeout(burstTimer);
+    burstTimer = null;
+  }
+  burstLen = 0;
+  pendingRender = false;
+}
+function onKey(str, key) {
+  if (pickItems) {
+    const n = pickItems.length;
+    if (key?.name === "up") {
+      pickSel = (pickSel - 1 + n) % n;
+      render();
+      return;
+    }
+    if (key?.name === "down") {
+      pickSel = (pickSel + 1) % n;
+      render();
+      return;
+    }
+    if (key?.name === "return" || key?.name === "enter") {
+      const v = pickItems[pickSel].value;
+      closePick();
+      render();
+      pickResolve?.(v);
+      pickResolve = null;
+      return;
+    }
+    if (key?.name === "escape" || key?.ctrl && key.name === "c") {
+      closePick();
+      render();
+      pickResolve?.(null);
+      pickResolve = null;
+      return;
+    }
+    return;
+  }
+  burstLen++;
+  if (burstTimer) clearTimeout(burstTimer);
+  burstTimer = setTimeout(() => {
+    burstTimer = null;
+    burstLen = 0;
+    if (pendingRender) render();
+  }, BURST_IDLE_MS);
+  const mm = currentMenu();
+  if (key?.ctrl && key.name === "c") {
+    if (buf) {
+      buf = "";
+      cur = 0;
+      edited();
+      resetBurst();
+      render();
+      return;
+    }
+    if (turnActive) onInterrupt?.();
+    else {
+      const r = onResult;
+      onResult = null;
+      r?.({ type: "quit" });
+    }
+    return;
+  }
+  if (key?.name === "escape") {
+    if (mm.length) {
+      menuHidden = true;
+      render();
+    } else if (buf) {
+      buf = "";
+      cur = 0;
+      render();
+    }
+    return;
+  }
+  if (key?.name === "tab" && key.shift) {
+    state.mode = nextMode(state.mode);
+    render();
+    return;
+  }
+  if (key?.name === "tab") {
+    if (mm.length) {
+      buf = mm[sel].name + " ";
+      cur = buf.length;
+      edited();
+      render();
+    }
+    return;
+  }
+  if (key?.name === "up") {
+    if (mm.length) {
+      sel = (sel - 1 + mm.length) % mm.length;
+      render();
+    }
+    return;
+  }
+  if (key?.name === "down") {
+    if (mm.length) {
+      sel = (sel + 1) % mm.length;
+      render();
+    }
+    return;
+  }
+  if (key?.name === "return" || key?.name === "enter") {
+    if (key?.shift || key?.meta || burstLen > 1) {
+      insert("\n");
+      return;
+    }
+    resetBurst();
+    const line = buf;
+    buf = "";
+    cur = 0;
+    edited();
+    render();
+    if (turnActive) {
+      if (line.trim()) steering.push(line.trim());
+      return;
+    }
+    if (line.trim()) out2("\n" + mark() + line + "\n");
+    const r = onResult;
+    onResult = null;
+    r?.({ type: "line", value: line });
+    return;
+  }
+  if (key?.name === "backspace") {
+    if (cur > 0) {
+      buf = buf.slice(0, cur - 1) + buf.slice(cur);
+      cur--;
+      edited();
+      render();
+    }
+    return;
+  }
+  if (key?.name === "delete") {
+    if (cur < buf.length) {
+      buf = buf.slice(0, cur) + buf.slice(cur + 1);
+      edited();
+      render();
+    }
+    return;
+  }
+  if (key?.name === "left") {
+    if (cur > 0) {
+      cur--;
+      render();
+    }
+    return;
+  }
+  if (key?.name === "right") {
+    if (cur < buf.length) {
+      cur++;
+      render();
+    }
+    return;
+  }
+  if (key && (key.name === "home" || key.ctrl && key.name === "a")) {
+    cur = 0;
+    render();
+    return;
+  }
+  if (key && (key.name === "end" || key.ctrl && key.name === "e")) {
+    cur = buf.length;
+    render();
+    return;
+  }
+  if (key?.ctrl && key.name === "u") {
+    buf = buf.slice(cur);
+    cur = 0;
+    edited();
+    render();
+    return;
+  }
+  if (str && !key?.ctrl && !key?.meta && [...str].length === 1 && isPrintableCodePoint(str.codePointAt(0))) {
+    insert(str);
+  }
 }
-function startStatusline(tokens) {
-  if (active2 || !process.stdout.isTTY || !config.statuslineEnabled) return;
+function startChrome(opts) {
+  if (active2 || !process.stdout.isTTY) return;
   active2 = true;
-  tokensOf = tokens;
-  process.stdout.write(`\x1B[1;${rows() - 1}r`);
+  tokensOf = opts.tokens;
+  allItems = opts.items;
+  onInterrupt = opts.onInterrupt;
+  out2(ansi.bracketedPasteOff);
   pollGit();
-  draw();
-  drawTimer = setInterval(draw, config.statuslineRefreshMs);
+  restoreKeys = pushKeyHandler(onKey);
+  render();
+  statusTimer = setInterval(refreshChrome, config.statuslineRefreshMs);
   gitTimer = setInterval(pollGit, 5e3);
   process.stdout.on("resize", onResize);
 }
-function stopStatusline() {
+function nextLine() {
+  return new Promise((resolve2) => {
+    turnActive = false;
+    render();
+    onResult = resolve2;
+  });
+}
+function beginTurn() {
+  steering.length = 0;
+  turnActive = true;
+  return steering;
+}
+function endTurn() {
+  turnActive = false;
+  render();
+}
+function stopChrome() {
   if (!active2) return;
   active2 = false;
-  if (drawTimer) clearInterval(drawTimer);
-  if (gitTimer) clearInterval(gitTimer);
+  restoreKeys?.();
+  restoreKeys = null;
   process.stdout.removeListener("resize", onResize);
-  process.stdout.write(`\x1B[r\x1B[${rows()};1H\x1B[2K`);
+  if (statusTimer) clearInterval(statusTimer);
+  if (gitTimer) clearInterval(gitTimer);
+  resetBurst();
+  out2(ansi.resetRegion);
+  for (const r of [statusRow(), borderBottomRow(), inputRow(), borderTopRow()]) out2(ansi.moveTo(r) + ansi.clearLine);
 }
+var chromeEnabled = () => config.statuslineEnabled && !!process.stdout.isTTY;
 
 // src/commands.ts
 import { writeFile as writeFile4, mkdir as mkdir4, chmod as chmod3 } from "node:fs/promises";
@@ -3187,6 +3626,13 @@ ${extra}` : "");
 }
 
 // src/commands.ts
+async function pick(opts) {
+  if (chromeEnabled()) {
+    const v = await chromePick(opts.items.map((it) => ({ label: it.label, hint: it.hint, value: it.value })), opts.initial, opts.title);
+    return v == null ? null : v;
+  }
+  return selectMenu(opts);
+}
 var SLASH_COMMANDS = [
   { name: "/model", desc: "switch model (menu; /model <term> searches)" },
   { name: "/effort", desc: "set reasoning effort (off/low/medium/high/max)" },
@@ -3264,20 +3710,23 @@ async function handleCommand(input, messages) {
   } else if (cmd === "/update") {
     console.log(color.dim("updating beecork\u2026 (npm install -g beecork@latest)"));
     const { ok, output } = await selfUpdate();
-    if (ok) console.log(color.green("\u2713 updated \u2014 restart beecork to use the new version.") + "\n");
-    else {
+    if (ok) {
+      console.log(color.green("\u2713 updated \u2014 restart beecork to use the new version.") + "\n");
+      const w = await shadowWarning();
+      if (w) console.log(color.yellow(w) + "\n");
+    } else {
       console.log(color.red("update failed: ") + output.split("\n").filter(Boolean).slice(-1)[0]);
       console.log(color.dim("  run manually: npm install -g beecork  (may need sudo / your version manager)") + "\n");
     }
   } else if (cmd === "/clear") {
     messages.splice(1);
-    if (process.stdout.isTTY) process.stdout.write("\x1B[2J\x1B[3J\x1B[H");
+    if (process.stdout.isTTY) process.stdout.write(ansi.clearScreen + ansi.clearScrollback + ansi.home);
     console.log(color.dim("conversation cleared (kept the system prompt, your model + settings).") + "\n");
   } else if (cmd === "/resume") {
     const sessions = process.stdin.isTTY ? await listSessions() : [];
     let restored = [];
     if (sessions.length > 1) {
-      const choice = await selectMenu({
+      const choice = await pick({
         title: "resume which session? \u2014 \u2191/\u2193 then Enter (Esc to cancel)",
         items: sessions.map((s) => ({
           label: s.preview || "(no first message)",
@@ -3330,7 +3779,7 @@ async function handleCommand(input, messages) {
 }
 async function pickModel() {
   if (!process.stdin.isTTY) return showRecommended();
-  const choice = await selectMenu({
+  const choice = await pick({
     title: "switch model \u2014 \u2191/\u2193 then Enter (Esc to cancel)",
     initial: Math.max(0, RECOMMENDED_MODELS.findIndex((m) => m.slug === state.model)),
     items: RECOMMENDED_MODELS.map((m) => ({
@@ -3353,7 +3802,7 @@ async function pickEffort() {
     console.log(color.cyan(`reasoning effort: ${state.reasoningEffort}`) + color.dim(`  (levels: ${EFFORTS.join(" / ")})`) + "\n");
     return;
   }
-  const choice = await selectMenu({
+  const choice = await pick({
     title: "reasoning effort \u2014 \u2191/\u2193 then Enter (Esc to cancel)",
     initial: Math.max(0, EFFORTS.indexOf(state.reasoningEffort)),
     items: EFFORTS.map((e) => ({
@@ -3388,7 +3837,7 @@ async function searchModels(term) {
     }
     const priceOf = (m) => m.pricing?.prompt != null ? `$${(parseFloat(m.pricing.prompt) * 1e6).toFixed(2)}/1M` : "?";
     if (process.stdin.isTTY) {
-      const choice = await selectMenu({
+      const choice = await pick({
         title: `models matching "${term}" \u2014 \u2191/\u2193 then Enter (Esc to cancel)`,
         items: matches.map((m) => ({
           label: m.id,
@@ -3435,8 +3884,11 @@ async function main() {
   if (process.argv[2] === "update") {
     console.log("Updating beecork\u2026");
     const { ok, output } = await selfUpdate();
-    if (ok) console.log(color.green("\u2713 beecork updated. Run `beecork` to use the new version."));
-    else {
+    if (ok) {
+      console.log(color.green("\u2713 beecork updated. Run `beecork` to use the new version."));
+      const w = await shadowWarning();
+      if (w) console.log("\n" + color.yellow(w));
+    } else {
       console.error(color.red("Update failed:") + "\n" + output);
       console.error(color.dim("\nTry manually: npm install -g beecork  (you may need sudo, or your Node version manager)."));
       process.exitCode = 1;
@@ -3497,7 +3949,7 @@ ${instr.trusted}`;
   };
   const tty = !!process.stdin.isTTY;
   process.on("exit", killAllTasks);
-  process.on("exit", stopStatusline);
+  process.on("exit", stopChrome);
   if (tty) {
     initInput();
     process.on("exit", teardownInput);
@@ -3516,12 +3968,13 @@ ${instr.trusted}`;
     });
   }
   const rl = tty ? null : createInterface({ input: process.stdin, output: process.stdout, completer });
-  printBanner(state.model, instr.sources.map(tildify));
+  if (chromeEnabled()) process.stdout.write(ansi.clearScreen + ansi.clearScrollback + ansi.home);
+  const version = await currentVersion();
+  printBanner(state.model, version, instr.sources.map(tildify));
   if (config.dangerouslySkipPermissions) {
     console.log(color.red("\u26A0  --dangerously-skip-permissions is ON: the approval gate is OFF. Out-of-root paths and risky") + "\n" + color.red("   shell commands will RUN unprompted. Use only in a disposable sandbox. (read-only mode + catastrophic-") + "\n" + color.red("   command refusal still apply.)") + "\n");
   }
   if (tty) {
-    const version = await currentVersion();
     const newer = await checkForUpdate(version);
     if (newer) console.log(color.dim(`\u25B8 beecork ${stripControl(newer)} is available (you have ${version}) \u2014 update: npm install -g beecork`) + "\n");
   }
@@ -3565,10 +4018,19 @@ ${instr.trusted}`;
       }
     });
   }
-  startStatusline(() => estimateTokens(messages));
+  if (chromeEnabled())
+    startChrome({
+      tokens: () => estimateTokens(messages),
+      items: [...SLASH_COMMANDS, ...skills.map((s) => ({ name: "/" + s.name, desc: "skill" }))],
+      onInterrupt: () => activeTurn?.abort()
+    });
   while (true) {
     let userInput;
-    if (tty) {
+    if (chromeEnabled()) {
+      const r = await nextLine();
+      if (r.type === "quit") break;
+      userInput = r.value;
+    } else if (tty) {
       const r = await readPrompt({
         promptString,
         commands: SLASH_COMMANDS,
@@ -3606,16 +4068,27 @@ ${instr.trusted}`;
         continue;
       }
     }
+    if (chromeEnabled()) {
+      activeTurn = new AbortController();
+      const steering3 = beginTurn();
+      try {
+        messages = await runTurn(messages, userInput, ask, approvedTools, approvedGuardKeys, activeTurn.signal, steering3);
+      } finally {
+        activeTurn = null;
+        endTurn();
+      }
+      continue;
+    }
     activeTurn = new AbortController();
     let modeChangedMidTurn = false;
-    const steering = [];
+    const steering2 = [];
     let typed = "";
-    const redrawSteer = () => process.stdout.write("\r\x1B[2K" + color.cyan("\xBB ") + color.dim(typed));
+    const redrawSteer = () => process.stdout.write(ansi.cr + ansi.clearLine + color.cyan("\xBB ") + color.dim(typed));
     const clearSteer = () => {
-      process.stdout.write("\r\x1B[2K");
+      process.stdout.write(ansi.cr + ansi.clearLine);
       setSteeringActive(false);
     };
-    const restoreKeys = tty ? pushKeyHandler((str, key) => {
+    const restoreKeys2 = tty ? pushKeyHandler((str, key) => {
       if (key && (key.name === "escape" || key.ctrl && key.name === "c")) {
         activeTurn?.abort();
         return;
@@ -3630,7 +4103,7 @@ ${instr.trusted}`;
         typed = "";
         clearSteer();
         if (note) {
-          steering.push(note);
+          steering2.push(note);
           console.log(color.dim(`\xBB queued for next step: ${note}`));
         }
         return;
@@ -3650,9 +4123,9 @@ ${instr.trusted}`;
     }) : () => {
     };
     try {
-      messages = await runTurn(messages, userInput, ask, approvedTools, approvedGuardKeys, activeTurn.signal, steering);
+      messages = await runTurn(messages, userInput, ask, approvedTools, approvedGuardKeys, activeTurn.signal, steering2);
     } finally {
-      restoreKeys();
+      restoreKeys2();
       setSteeringActive(false);
       activeTurn = null;
       if (modeChangedMidTurn) console.log(color.yellow(`\u25B8 mode: ${modeLabel(state.mode)}`));
@@ -3660,6 +4133,7 @@ ${instr.trusted}`;
       if (bg > 0) console.log(color.dim(`\u25B8 ${bg} background task${bg === 1 ? "" : "s"} running \u2014 check_task / stop_task`));
     }
   }
+  stopChrome();
   teardownInput();
   rl?.close();
   await persist();