beecork 2.3.0 → 2.4.0

package/dist/index.js

@@ -52,6 +52,20 @@ var num = (name, fallback) => {
   return Number.isFinite(v) ? v : fallback;
 };
 var bool = (name) => ["1", "true", "yes", "on"].includes((process.env[name] ?? "").trim().toLowerCase());
+var EFFORTS = ["off", "low", "medium", "high", "max"];
+function normalizeEffort(raw) {
+  const v = (raw ?? "").trim().toLowerCase();
+  return EFFORTS.includes(v) ? v : void 0;
+}
+function parseExtra(raw) {
+  if (!raw || !raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
 var config = {
   apiUrl: "https://openrouter.ai/api/v1/chat/completions",
   modelsUrl: "https://openrouter.ai/api/v1/models",
@@ -87,6 +101,19 @@ var config = {
   // overall search traversal budget
   searchMaxFileBytes: num("SEARCH_MAX_FILE_BYTES", 2e6),
   // skip files larger than this
+  // Reasoning / thinking
+  reasoningEffort: normalizeEffort(process.env.REASONING_EFFORT) ?? "medium",
+  // startup default; changed live via /effort
+  openRouterExtra: parseExtra(process.env.OPENROUTER_EXTRA),
+  // advanced: extra request-body params (sampling, provider routing, …)
+  // Background tasks (run_bash background:true → check_task / stop_task)
+  maxBackgroundTasks: num("MAX_BG_TASKS", 5),
+  // per-session cap on concurrent background commands
+  backgroundTailChars: num("BG_TAIL_CHARS", 1e5),
+  // rolling tail buffer per task (drops oldest)
+  // Sub-agent (explore tool)
+  subAgentMaxSteps: num("SUBAGENT_MAX_STEPS", 15),
+  // child explorer's step budget (bounds cost/latency)
   // Integrations / modes
   verifyCommand: process.env.VERIFY_COMMAND ?? "",
   // auto-run after edits (e.g. "npm run typecheck")
@@ -191,6 +218,8 @@ function modeLabel(m) {
 var state = {
   model: config.defaultModel,
   // changed at runtime via the /model command
+  reasoningEffort: config.reasoningEffort,
+  // "thinking" depth; changed live via /effort, persisted like /model
   apiKey: "",
   // resolved at startup in index.ts: shell env → ~/.beecork/config.json → prompt
   braveKey: "",
@@ -370,11 +399,18 @@ function summarizeResult(name, a, result) {
   }
 }
 var SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var steeringOnScreen = false;
+function setSteeringActive(on) {
+  steeringOnScreen = on;
+}
 function startSpinner(label) {
   if (!process.stdout.isTTY || !useColor) return () => {
   };
   let i = 0;
-  const draw = () => process.stdout.write("\r  " + color.brand(SPINNER[i = (i + 1) % SPINNER.length]) + " " + color.dim(label));
+  const draw = () => {
+    if (steeringOnScreen) return;
+    process.stdout.write("\r  " + color.brand(SPINNER[i = (i + 1) % SPINNER.length]) + " " + color.dim(label));
+  };
   process.stdout.write("\x1B[?25l");
   draw();
   const timer = setInterval(draw, 80);
@@ -469,752 +505,1394 @@ function printBanner(model, sources) {
 // src/agent.ts
 import { readFile as readFile4 } from "node:fs/promises";
 
-// src/show.ts
-var BOX_W = () => Math.min(process.stdout.columns || 80, 100);
-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";
-}
-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"}`)];
-  if (safe.length === 0) {
-    out2.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 rows = Math.ceil(safe.length / cols);
-    for (let r = 0; r < rows; r++) {
-      let line = "";
-      for (let c = 0; c < cols; c++) {
-        const idx = c * rows + 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+$/, ""));
-    }
-  }
-  out2.push(color.dim("\u2570\u2500"));
-  return out2.join("\n") + "\n";
+// src/input.ts
+import { emitKeypressEvents } from "node:readline";
+var out = (s) => process.stdout.write(s);
+var active = null;
+var started = false;
+function initInput() {
+  if (started || !process.stdin.isTTY) return;
+  started = true;
+  process.stdin.setRawMode(true);
+  out("\x1B[?2004l");
+  emitKeypressEvents(process.stdin);
+  process.stdin.on("keypress", (str, key) => active?.(str, key));
 }
-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`)];
-  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));
+function teardownInput() {
+  if (started && process.stdin.isTTY) {
+    out("\x1B[?2004h\x1B[?25h");
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
   }
-  if (truncated) out2.push(color.dim("\u2502 ") + color.dim("\u2026 (truncated)"));
-  out2.push(color.dim("\u2570\u2500"));
-  return out2.join("\n") + "\n";
 }
-var SHOW_MARK = "
";
-var SHOW_KINDS = ["file", "dir", "tree"];
-var SHOW_RE = new RegExp(`^${SHOW_MARK}(${SHOW_KINDS.join("|")})${SHOW_MARK}`);
-function showPayload(kind, obj) {
-  return SHOW_MARK + kind + SHOW_MARK + JSON.stringify(obj);
+function pushKeyHandler(h) {
+  const prev = active;
+  active = h;
+  return () => {
+    active = prev;
+  };
 }
-function renderShow(raw) {
-  const m = raw.match(SHOW_RE);
-  if (!m) return null;
-  let p;
-  try {
-    p = JSON.parse(raw.slice(m[0].length));
-  } catch {
-    return null;
-  }
-  if (m[1] === "file") {
-    const range = `lines ${p.startLine}\u2013${p.startLine + p.lines.length - 1}${p.hasMore ? ", more follow" : ""}`;
-    return {
-      display: renderFileBox(p.path, p.startLine, p.lines, p.hasMore),
-      note: `Shown ${p.path} (${range}) on the user's screen \u2014 they can see it now. Do NOT paste, re-list, or re-describe its contents; add at most a one-line comment, or ask what's next. (If YOU need the contents to answer something, use read_file.)`
+var isEnter = (k) => k?.name === "return" || k?.name === "enter";
+var MENU_MAX = 8;
+function readPrompt(opts) {
+  if (!process.stdin.isTTY) return Promise.resolve({ type: "eof" });
+  const history = opts.history ?? [];
+  const all = [
+    ...opts.commands ?? [],
+    ...(opts.skills ?? []).map((n) => ({ name: "/" + n, desc: "skill" }))
+  ];
+  return new Promise((resolve2) => {
+    let buf = "";
+    let cur = 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;
+    const matches = () => {
+      if (opts.mask) return [];
+      const m = buf.match(/^\/(\S*)$/);
+      if (!m) return [];
+      const pre = "/" + m[1];
+      return all.filter((c) => c.name.startsWith(pre)).slice(0, MENU_MAX);
     };
-  }
-  if (m[1] === "dir") {
-    return {
-      display: renderListing(p.path, p.names),
-      note: `Shown the contents of ${p.path} (${p.names.length} entries) on the user's screen. Do NOT re-list or re-format them \u2014 a one-line comment at most, or ask what's next.`
+    const menu = () => menuHidden ? [] : matches();
+    const highlight = () => {
+      if (opts.mask) return "*".repeat(buf.length);
+      const m = buf.match(/^(\/\S*)([\s\S]*)$/);
+      if (!m) return buf;
+      const [, token, rest] = m;
+      const known = all.some((c) => c.name === token);
+      const partial = all.some((c) => c.name.startsWith(token));
+      const styled = known ? color.green(token) : partial ? color.cyan(token) : color.red(token);
+      return styled + rest;
     };
-  }
-  const dirs = p.items.filter((it) => it.isDir).length;
-  return {
-    display: renderTree(p.path, p.items, p.truncated),
-    note: `Shown the file tree of ${p.path} (${p.items.length} entries, ${dirs} folders${p.truncated ? ", truncated" : ""}) on the user's screen. Do NOT re-type or re-format the tree \u2014 a one-line comment at most.`
-  };
-}
-
-// src/markdown.ts
-var NUL = "\0";
-var visLen = (s) => stripAnsi(s).length;
-var HR_RE = /^\s*([-*_])(\s*\1){2,}\s*$/;
-var CODE_SPAN_RE = new RegExp(`${NUL}(\\d+)${NUL}`, "g");
-function inline(s) {
-  const code = [];
-  s = s.replace(/`([^`]+)`/g, (_m, c) => {
-    code.push(c);
-    return `${NUL}${code.length - 1}${NUL}`;
-  });
-  s = s.replace(/\*\*([^*]+)\*\*/g, (_m, t) => color.bold(t));
-  s = s.replace(/__([^_]+)__/g, (_m, t) => color.bold(t));
-  s = s.replace(/(^|[^\\*])\*([^*\s][^*]*?)\*/g, (_m, p, t) => p + color.italic(t));
-  s = s.replace(/~~([^~]+)~~/g, (_m, t) => color.strike(t));
-  s = s.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, txt, url) => color.cyan(txt) + color.dim(` (${url})`));
-  s = s.replace(CODE_SPAN_RE, (_m, i) => color.cyan(code[+i]));
-  return s;
-}
-function blockLine(line) {
-  const h = line.match(/^(#{1,6})\s+(.*)$/);
-  if (h) return color.bold(color.cyan(inline(h[2])));
-  if (HR_RE.test(line)) return color.dim("\u2500".repeat(40));
-  const q = line.match(/^\s*>\s?(.*)$/);
-  if (q) return color.dim("\u2502 " + inline(q[1]));
-  const b = line.match(/^(\s*)[-*+]\s+(.*)$/);
-  if (b) return b[1] + color.cyan("\u2022") + " " + inline(b[2]);
-  const n = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
-  if (n) return n[1] + color.cyan(n[2] + ".") + " " + inline(n[3]);
-  return inline(line);
-}
-function renderTable(rows) {
-  const parse = (r) => r.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
-  const grid = rows.map(parse);
-  const isSep = (cells) => cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));
-  const sepIdx = grid.findIndex(isSep);
-  const body = grid.filter((_, i) => i !== sepIdx);
-  if (body.length === 0) return "";
-  const ncol = Math.max(...body.map((r) => r.length));
-  const styled = body.map(
-    (r, ri) => Array.from({ length: ncol }, (_, c) => {
-      const raw = r[c] ?? "";
-      return sepIdx >= 0 && ri === 0 ? color.bold(inline(raw)) : inline(raw);
-    })
-  );
-  const width = Array.from({ length: ncol }, (_, c) => Math.max(...styled.map((r) => visLen(r[c]))));
-  const out2 = 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";
-}
-function createMarkdownStream(write) {
-  let buf = "";
-  let scanFrom = 0;
-  let inCode = false;
-  let first = true;
-  let table = [];
-  const isRow = (l) => /^\s*\|.*\|\s*$/.test(l);
-  const flushTable = () => {
-    if (table.length) {
-      write(renderTable(table));
-      table = [];
-    }
-  };
-  function emit(line) {
-    const fence = line.match(/^\s*```(\w*)\s*$/);
-    if (first && line.trim()) {
-      first = false;
-      const block = !!fence || isRow(line) || HR_RE.test(line) || /^#{1,6}\s/.test(line);
-      if (block) write("\n");
+    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;
+      const indent = " ".repeat(promptW);
+      const lines = highlight().split("\n");
+      out(prompt + lines[0]);
+      for (let i = 1; i < lines.length; i++) out("\n" + indent + lines[i]);
+      return { promptW };
     }
-    if (fence) {
-      flushTable();
-      inCode = !inCode;
-      write(color.dim("\u2504".repeat(40)) + "\n");
-      return;
+    function render() {
+      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");
+      const { promptW } = drawBlock();
+      const cols = 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 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");
+      lastCurRow = curPhysRow;
     }
-    if (inCode) {
-      flushTable();
-      write(color.dim("  " + line) + "\n");
-      return;
+    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");
+      drawBlock();
+      out("\n");
+      if (result.type === "line" && result.value.trim() && !opts.mask) history.push(result.value);
+      resolve2(result);
     }
-    if (isRow(line)) {
-      table.push(line);
-      return;
+    function insert(s) {
+      buf = buf.slice(0, cur) + s + buf.slice(cur);
+      cur += s.length;
+      menuHidden = false;
+      sel = 0;
+      pendingRender = true;
     }
-    flushTable();
-    write(blockLine(line) + "\n");
-  }
-  return {
-    push(text) {
-      buf += text;
-      let i;
-      while ((i = buf.indexOf("\n", scanFrom)) >= 0) {
-        emit(buf.slice(0, i));
-        buf = buf.slice(i + 1);
-        scanFrom = 0;
+    function onKey(str, key) {
+      const mm = menu();
+      burstLen++;
+      if (burstTimer) clearTimeout(burstTimer);
+      burstTimer = setTimeout(() => {
+        burstTimer = null;
+        burstLen = 0;
+        if (pendingRender) {
+          pendingRender = false;
+          render();
+        }
+      }, BURST_IDLE_MS);
+      if (isEnter(key)) {
+        if (key?.shift || key?.meta || burstLen > 1) {
+          insert("\n");
+          return;
+        }
+        return finish({ type: "line", value: buf });
       }
-      scanFrom = buf.length;
-    },
-    end() {
-      if (buf) {
-        emit(buf);
-        buf = "";
+      if (key?.ctrl && key.name === "c") {
+        if (buf) {
+          buf = "";
+          cur = 0;
+          render();
+        } else finish({ type: "quit" });
+        return;
       }
-      flushTable();
-      if (inCode) {
-        write(color.dim("\u2504".repeat(40)) + "\n");
-        inCode = false;
+      if (key?.ctrl && key.name === "d") {
+        if (!buf) finish({ type: "eof" });
+        return;
+      }
+      if (key?.name === "tab" && key.shift) {
+        opts.onShiftTab?.();
+        render();
+        return;
+      }
+      if (key?.name === "tab") {
+        if (mm.length) {
+          buf = mm[sel].name + " ";
+          cur = buf.length;
+          menuHidden = false;
+          render();
+        }
+        return;
+      }
+      if (key?.name === "up") {
+        if (mm.length) {
+          sel = (sel - 1 + mm.length) % mm.length;
+          render();
+        } else if (buf.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);
+        else histNext();
+        return;
+      }
+      if (key?.name === "left") {
+        if (cur > 0) cur--;
+        render();
+        return;
+      }
+      if (key?.name === "right") {
+        if (cur < buf.length) cur++;
+        render();
+        return;
+      }
+      if (key?.name === "home" || key?.ctrl && key.name === "a") {
+        cur = 0;
+        render();
+        return;
+      }
+      if (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;
+        menuHidden = false;
+        render();
+        return;
+      }
+      if (key?.name === "backspace") {
+        if (cur > 0) {
+          buf = buf.slice(0, cur - 1) + buf.slice(cur);
+          cur--;
+          menuHidden = false;
+          render();
+        }
+        return;
+      }
+      if (key?.name === "delete") {
+        if (cur < buf.length) {
+          buf = buf.slice(0, cur) + buf.slice(cur + 1);
+          menuHidden = false;
+          render();
+        }
+        return;
+      }
+      if (key?.name === "escape") {
+        if (mm.length) {
+          menuHidden = true;
+          render();
+        }
+        return;
+      }
+      if (str && !key?.ctrl && !key?.meta && [...str].length === 1) {
+        if (isPrintableCodePoint(str.codePointAt(0))) insert(str);
       }
     }
-  };
-}
-
-// src/tools.ts
-import { readFile as readFile2, writeFile as writeFile2, appendFile, readdir, mkdir as mkdir2, stat, rename, chmod } from "node:fs/promises";
-import { createReadStream } from "node:fs";
-import { createInterface as createLineReader } from "node:readline";
-import { spawn as spawn2 } from "node:child_process";
-import { join as join2 } from "node:path";
-import { lookup as dnsLookup } from "node:dns";
-import { request as httpRequest } from "node:http";
-import { request as httpsRequest } from "node:https";
-import { isIP } from "node:net";
-
-// src/safety.ts
-import { homedir as homedir3 } from "node:os";
-import { basename } 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}` };
-}
-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));
+    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();
+    }
+    function histPrev() {
+      if (history.length === 0) return;
+      hist = Math.max(0, hist - 1);
+      buf = history[hist] ?? "";
+      cur = buf.length;
+      render();
+    }
+    function histNext() {
+      if (hist >= history.length) return;
+      hist += 1;
+      buf = hist === history.length ? "" : history[hist];
+      cur = buf.length;
+      render();
+    }
+    const restore = pushKeyHandler(onKey);
+    render();
+  });
 }
-function secretGuard(args) {
-  const p = pathGuard(args);
-  if (p.needsApproval) return p;
-  const path = String(args.path ?? "");
-  return isSecretPath(path) ? { needsApproval: true, reason: `this looks like a secrets file (${path}) \u2014 approve before continuing` } : {};
+function readChoice(prompt) {
+  if (!process.stdin.isTTY) return Promise.resolve("n");
+  return new Promise((resolve2) => {
+    out(prompt);
+    const restore = pushKeyHandler((str, key) => {
+      let ch;
+      if (key?.ctrl && key.name === "c" || key?.name === "escape" || isEnter(key)) ch = "n";
+      else if (str && /^[yna]$/i.test(str)) ch = str.toLowerCase();
+      else return;
+      restore();
+      out(ch + "\n");
+      resolve2(ch);
+    });
+  });
 }
-var readGuard = secretGuard;
-var writeGuard = secretGuard;
-var DANGEROUS_BASH = [
-  /\brm\b[\s\S]*\s(\/|~|\$\{?HOME\}?)\/?(\s*$|\*|\/\*)/,
-  // rm of / ~ $HOME (and their immediate /*)
-  /\brm\b[\s\S]*\s\/(etc|usr|bin|sbin|lib|var|boot|dev|sys|proc|root|System|Library|Applications)(\/|\s|$|\*)/,
-  // rm of a system root
-  /:\s*\(\s*\)\s*\{[^}]*\}\s*;\s*:/,
-  // fork bomb :(){ :|:& };:
-  /\bmkfs\.?\w*/,
-  // format a filesystem
-  /\bdd\b[^\n]*\bof=\/dev\//,
-  // dd to a raw device
-  /\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(sh|bash|zsh)\b/,
-  // pipe-to-shell
-  />\s*\/dev\/(sd|nvme|disk)/
-  // overwrite a disk device
-];
-var RISKY_BASH = [
-  /\b(rm|rmdir|shred|unlink)\b/,
-  // deleting files
-  /\bfind\b[\s\S]*\s-(delete|exec)\b/,
-  // find -delete / -exec (mass mutate without "rm")
-  /\btruncate\b/,
-  // truncate files to a size
-  /(^|[\s;&|])(:|true)\s*>\s*\S/,
-  // `: > file` / `true > file` truncation idiom
-  /\b(dd|fdisk|parted|wipefs|sgdisk)\b/,
-  // raw disk tools
-  /\bmkfs\.?\w*/,
-  // make a filesystem
-  /\bsudo\b/,
-  // privilege escalation
-  /[<>]\s*\/dev\/\w/,
-  // raw device I/O
-  /\|\s*(sudo\s+)?(sh|bash|zsh|python\d?|node|perl|ruby|php)\b/,
-  // pipe INTO an interpreter
-  /\b(eval|source)\b[\s\S]*\$\(\s*(curl|wget|fetch)\b/
-  // eval/source of a download
-];
-function refsOutsideRoot(cmd) {
-  const norm = cmd.replace(/\$\{?IFS\}?/g, " ").replace(/\$\{?HOME\}?/g, homedir3()).replace(/\$\{?PWD\}?/g, process.cwd()).replace(/(^|[\s"'`=(])~(?=\/|$)/g, (_m, p) => p + homedir3());
-  if (/(^|[\s"'`=(])(\.\.\/|~(\/|$))/.test(norm)) return true;
-  for (const m of norm.matchAll(/(?:^|[\s"'`=(])(\/[^\s"'`;|&()<>]*)/g)) {
-    if (!resolveInRoot(m[1]).inRoot) return true;
+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 drawn = 0;
+    function render() {
+      out("\x1B[?25l");
+      if (drawn > 0) out(`\x1B[${drawn}A`);
+      out("\r\x1B[J");
+      out(color.dim(opts.title) + "\n");
+      opts.items.forEach((it, i) => {
+        const row = i === sel ? 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");
+      resolve2(v);
+    }
+    const restore = pushKeyHandler((_str, key) => {
+      if (key?.name === "up") {
+        sel = (sel - 1 + opts.items.length) % opts.items.length;
+        render();
+      } else if (key?.name === "down") {
+        sel = (sel + 1) % opts.items.length;
+        render();
+      } else if (isEnter(key)) finish(opts.items[sel].value);
+      else if (key?.name === "escape" || key?.name === "q" || key?.ctrl && key.name === "c") finish(null);
+    });
+    render();
+  });
+}
+
+// src/show.ts
+var BOX_W = () => Math.min(process.stdout.columns || 80, 100);
+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";
+}
+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"}`)];
+  if (safe.length === 0) {
+    out2.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 rows = Math.ceil(safe.length / cols);
+    for (let r = 0; r < rows; r++) {
+      let line = "";
+      for (let c = 0; c < cols; c++) {
+        const idx = c * rows + 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+$/, ""));
+    }
   }
-  return false;
+  out2.push(color.dim("\u2570\u2500"));
+  return out2.join("\n") + "\n";
 }
-function bashGuard(args) {
-  const cmd = String(args.command ?? "");
-  const risky = RISKY_BASH.find((re) => re.test(cmd));
-  if (risky) return { needsApproval: true, reason: `this shell command looks risky (matched ${risky})` };
-  if (refsOutsideRoot(cmd)) return { needsApproval: true, reason: "this shell command references a path outside the project root" };
-  return {};
+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`)];
+  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));
+  }
+  if (truncated) out2.push(color.dim("\u2502 ") + color.dim("\u2026 (truncated)"));
+  out2.push(color.dim("\u2570\u2500"));
+  return out2.join("\n") + "\n";
 }
-function isPrivateAddr(ip) {
-  const m = ip.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
-  if (m) {
-    const a = +m[1], b = +m[2];
-    return a === 0 || a === 127 || a === 10 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+var SHOW_MARK = "
";
+var SHOW_KINDS = ["file", "dir", "tree"];
+var SHOW_RE = new RegExp(`^${SHOW_MARK}(${SHOW_KINDS.join("|")})${SHOW_MARK}`);
+function showPayload(kind, obj) {
+  return SHOW_MARK + kind + SHOW_MARK + JSON.stringify(obj);
+}
+function renderShow(raw) {
+  const m = raw.match(SHOW_RE);
+  if (!m) return null;
+  let p;
+  try {
+    p = JSON.parse(raw.slice(m[0].length));
+  } catch {
+    return null;
   }
-  const ip6 = ip.toLowerCase();
-  const dotted = ip6.match(/(?:^|:)(\d+\.\d+\.\d+\.\d+)$/);
-  if (dotted) return isPrivateAddr(dotted[1]);
-  const g = expandIPv6(ip6);
-  if (!g) return true;
-  if (g.every((h) => h === 0)) return true;
-  if (g.slice(0, 7).every((h) => h === 0) && g[7] === 1) return true;
-  const embeddedV4 = () => `${g[6] >> 8 & 255}.${g[6] & 255}.${g[7] >> 8 & 255}.${g[7] & 255}`;
-  if (g[0] === 0 && g[1] === 0 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 65535) {
-    return isPrivateAddr(embeddedV4());
+  if (m[1] === "file") {
+    const range = `lines ${p.startLine}\u2013${p.startLine + p.lines.length - 1}${p.hasMore ? ", more follow" : ""}`;
+    return {
+      display: renderFileBox(p.path, p.startLine, p.lines, p.hasMore),
+      note: `Shown ${p.path} (${range}) on the user's screen \u2014 they can see it now. Do NOT paste, re-list, or re-describe its contents; add at most a one-line comment, or ask what's next. (If YOU need the contents to answer something, use read_file.)`
+    };
   }
-  if (g[0] === 100 && g[1] === 65435 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 0 || g[0] === 0 && g[1] === 0 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 0) {
-    return isPrivateAddr(embeddedV4());
+  if (m[1] === "dir") {
+    return {
+      display: renderListing(p.path, p.names),
+      note: `Shown the contents of ${p.path} (${p.names.length} entries) on the user's screen. Do NOT re-list or re-format them \u2014 a one-line comment at most, or ask what's next.`
+    };
   }
-  if ((g[0] & 65472) === 65152) return true;
-  if ((g[0] & 65024) === 64512) return true;
-  return false;
+  const dirs = p.items.filter((it) => it.isDir).length;
+  return {
+    display: renderTree(p.path, p.items, p.truncated),
+    note: `Shown the file tree of ${p.path} (${p.items.length} entries, ${dirs} folders${p.truncated ? ", truncated" : ""}) on the user's screen. Do NOT re-type or re-format the tree \u2014 a one-line comment at most.`
+  };
 }
-function expandIPv6(ip) {
-  const halves = ip.split("::");
-  if (halves.length > 2) return null;
-  const parse = (s) => s ? s.split(":").map((h) => parseInt(h, 16)) : [];
-  const head = parse(halves[0]);
-  if (halves.length === 1) return head.length === 8 && head.every((n) => n >= 0 && n <= 65535) ? head : null;
-  const tail = parse(halves[1]);
-  const fill = 8 - head.length - tail.length;
-  if (fill < 0) return null;
-  const g = [...head, ...Array(fill).fill(0), ...tail];
-  return g.length === 8 && g.every((n) => Number.isFinite(n) && n >= 0 && n <= 65535) ? g : null;
+
+// src/capabilities.ts
+var capable = null;
+var started2 = false;
+function loadCatalog() {
+  if (started2) return;
+  started2 = true;
+  fetch(config.modelsUrl, { signal: AbortSignal.timeout(config.webTimeoutMs) }).then((res) => res.json()).then((json) => {
+    const data = json.data;
+    if (!Array.isArray(data)) return;
+    const ids = /* @__PURE__ */ new Set();
+    for (const m of data) {
+      const id = m.id;
+      const params = m.supported_parameters;
+      if (typeof id === "string" && Array.isArray(params) && params.includes("reasoning")) ids.add(id);
+    }
+    if (ids.size) capable = ids;
+  }).catch(() => {
+  });
+}
+var baseId = (slug) => slug.split(":")[0];
+function shouldSendReasoning(model) {
+  loadCatalog();
+  if (!capable) return true;
+  return capable.has(model) || capable.has(baseId(model));
 }
 
-// src/html.ts
-function htmlToText(html) {
-  let s = html;
-  s = s.replace(/<(script|style|noscript|template|svg|head)[\s\S]*?<\/\1>/gi, " ");
-  s = s.replace(/<!--[\s\S]*?-->/g, " ");
-  s = s.replace(/<br\s*\/?>/gi, "\n");
-  s = s.replace(/<\/(p|div|li|tr|h[1-6]|section|article|header|footer|ul|ol|table|blockquote)\s*>/gi, "\n");
-  s = s.replace(/<[^>]+>/g, " ");
-  s = decodeEntities(s);
-  s = s.replace(/[ \t\f\v]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n");
-  return s.trim();
+// src/markdown.ts
+var NUL = "\0";
+var visLen = (s) => stripAnsi(s).length;
+var HR_RE = /^\s*([-*_])(\s*\1){2,}\s*$/;
+var CODE_SPAN_RE = new RegExp(`${NUL}(\\d+)${NUL}`, "g");
+function inline(s) {
+  const code = [];
+  s = s.replace(/`([^`]+)`/g, (_m, c) => {
+    code.push(c);
+    return `${NUL}${code.length - 1}${NUL}`;
+  });
+  s = s.replace(/\*\*([^*]+)\*\*/g, (_m, t) => color.bold(t));
+  s = s.replace(/__([^_]+)__/g, (_m, t) => color.bold(t));
+  s = s.replace(/(^|[^\\*])\*([^*\s][^*]*?)\*/g, (_m, p, t) => p + color.italic(t));
+  s = s.replace(/~~([^~]+)~~/g, (_m, t) => color.strike(t));
+  s = s.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, txt, url) => color.cyan(txt) + color.dim(` (${url})`));
+  s = s.replace(CODE_SPAN_RE, (_m, i) => color.cyan(code[+i]));
+  return s;
 }
-function decodeEntities(s) {
-  const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
-  return s.replace(/&(#x?[0-9a-f]+|[a-z][a-z0-9]*);/gi, (m, code) => {
-    if (code[0] === "#") {
-      const n = code[1].toLowerCase() === "x" ? parseInt(code.slice(2), 16) : parseInt(code.slice(1), 10);
-      return Number.isFinite(n) && n >= 0 && n <= 1114111 && !(n >= 55296 && n <= 57343) ? String.fromCodePoint(n) : m;
-    }
-    return named[code.toLowerCase()] ?? m;
+function blockLine(line) {
+  const h = line.match(/^(#{1,6})\s+(.*)$/);
+  if (h) return color.bold(color.cyan(inline(h[2])));
+  if (HR_RE.test(line)) return color.dim("\u2500".repeat(40));
+  const q = line.match(/^\s*>\s?(.*)$/);
+  if (q) return color.dim("\u2502 " + inline(q[1]));
+  const b = line.match(/^(\s*)[-*+]\s+(.*)$/);
+  if (b) return b[1] + color.cyan("\u2022") + " " + inline(b[2]);
+  const n = line.match(/^(\s*)(\d+)\.\s+(.*)$/);
+  if (n) return n[1] + color.cyan(n[2] + ".") + " " + inline(n[3]);
+  return inline(line);
+}
+function renderTable(rows) {
+  const parse = (r) => r.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+  const grid = rows.map(parse);
+  const isSep = (cells) => cells.length > 0 && cells.every((c) => /^:?-+:?$/.test(c));
+  const sepIdx = grid.findIndex(isSep);
+  const body = grid.filter((_, i) => i !== sepIdx);
+  if (body.length === 0) return "";
+  const ncol = Math.max(...body.map((r) => r.length));
+  const styled = body.map(
+    (r, ri) => Array.from({ length: ncol }, (_, c) => {
+      const raw = r[c] ?? "";
+      return sepIdx >= 0 && ri === 0 ? color.bold(inline(raw)) : inline(raw);
+    })
+  );
+  const width = Array.from({ length: ncol }, (_, c) => Math.max(...styled.map((r) => visLen(r[c]))));
+  const out2 = 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";
 }
-
-// src/tools.ts
-function runShell(command, opts) {
-  return new Promise((resolve2, reject) => {
-    const unix = process.platform !== "win32";
-    const child = spawn2(command, { shell: true, detached: unix, stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "", stderr = "", outLen = 0, errLen = 0, timedOut = false, aborted = false;
-    let settled = false, exitCode = null;
-    const kill = () => {
-      try {
-        if (unix && child.pid) process.kill(-child.pid, "SIGKILL");
-        else child.kill("SIGKILL");
-      } catch {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-      }
-    };
-    const timer = setTimeout(() => {
-      timedOut = true;
-      kill();
-    }, opts.timeout);
-    const onAbort = () => {
-      aborted = true;
-      kill();
-    };
-    if (opts.signal) {
-      if (opts.signal.aborted) onAbort();
-      else opts.signal.addEventListener("abort", onAbort, { once: true });
+function createMarkdownStream(write) {
+  let buf = "";
+  let scanFrom = 0;
+  let inCode = false;
+  let first = true;
+  let table = [];
+  const isRow = (l) => /^\s*\|.*\|\s*$/.test(l);
+  const flushTable = () => {
+    if (table.length) {
+      write(renderTable(table));
+      table = [];
     }
-    child.stdout?.on("data", (d) => {
-      if (outLen < opts.maxBuffer) {
-        stdout += d;
-        outLen += d.length;
+  };
+  function emit(line) {
+    const fence = line.match(/^\s*```(\w*)\s*$/);
+    if (first && line.trim()) {
+      first = false;
+      const block = !!fence || isRow(line) || HR_RE.test(line) || /^#{1,6}\s/.test(line);
+      if (block) write("\n");
+    }
+    if (fence) {
+      flushTable();
+      inCode = !inCode;
+      write(color.dim("\u2504".repeat(40)) + "\n");
+      return;
+    }
+    if (inCode) {
+      flushTable();
+      write(color.dim("  " + line) + "\n");
+      return;
+    }
+    if (isRow(line)) {
+      table.push(line);
+      return;
+    }
+    flushTable();
+    write(blockLine(line) + "\n");
+  }
+  return {
+    push(text) {
+      buf += text;
+      let i;
+      while ((i = buf.indexOf("\n", scanFrom)) >= 0) {
+        emit(buf.slice(0, i));
+        buf = buf.slice(i + 1);
+        scanFrom = 0;
       }
-    });
-    child.stderr?.on("data", (d) => {
-      if (errLen < opts.maxBuffer) {
-        stderr += d;
-        errLen += d.length;
+      scanFrom = buf.length;
+    },
+    end() {
+      if (buf) {
+        emit(buf);
+        buf = "";
       }
-    });
-    const cleanup = () => {
-      clearTimeout(timer);
-      opts.signal?.removeEventListener("abort", onAbort);
-    };
-    const finalize = () => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      if (aborted) reject(Object.assign(new Error("cancelled"), { stdout, stderr }));
-      else if (timedOut) reject(Object.assign(new Error(`timed out after ${opts.timeout}ms`), { stdout, stderr }));
-      else if (exitCode !== 0 && exitCode !== null) reject(Object.assign(new Error(`exited with code ${exitCode}`), { stdout, stderr }));
-      else resolve2({ stdout, stderr });
-    };
-    child.on("error", (err) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      reject(Object.assign(err, { stdout, stderr }));
-    });
-    child.on("close", finalize);
-    child.on("exit", (code) => {
-      exitCode = code;
-      setTimeout(finalize, 100);
-    });
-  });
+      flushTable();
+      if (inCode) {
+        write(color.dim("\u2504".repeat(40)) + "\n");
+        inCode = false;
+      }
+    }
+  };
 }
-var fail = (verb, err) => `Error ${verb}: ${err.message}`;
-async function atomicWrite(abs, content) {
-  const tmp = `${abs}.beecork-${process.pid}.tmp`;
-  await writeFile2(tmp, content, "utf8");
+
+// src/tools.ts
+import { readFile as readFile2, writeFile as writeFile2, appendFile, readdir, mkdir as mkdir2, stat, rename, chmod } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { createInterface as createLineReader } from "node:readline";
+import { spawn as spawn3 } from "node:child_process";
+import { join as join2 } from "node:path";
+import { lookup as dnsLookup } from "node:dns";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+
+// src/tasks.ts
+import { spawn as spawn2 } from "node:child_process";
+var tasks = /* @__PURE__ */ new Map();
+var counter = 0;
+var unix = process.platform !== "win32";
+function appendTail(buffer, chunk, cap) {
+  const combined = buffer + chunk;
+  if (combined.length <= cap) return { buffer: combined, dropped: false };
+  return { buffer: combined.slice(combined.length - cap), dropped: true };
+}
+function readSince(buffer, totalLen, readLen) {
+  const fresh = totalLen - readLen;
+  if (fresh <= 0) return { output: "", dropped: false };
+  if (fresh >= buffer.length) return { output: buffer, dropped: fresh > buffer.length };
+  return { output: buffer.slice(buffer.length - fresh), dropped: false };
+}
+function killTask(task) {
   try {
-    await chmod(tmp, (await stat(abs)).mode);
+    if (unix && task.child.pid) process.kill(-task.child.pid, "SIGKILL");
+    else task.child.kill("SIGKILL");
   } catch {
-  }
-  await rename(tmp, abs);
-}
-var todos = [];
-function httpGet(rawUrl, maxBytes, signal) {
-  return new Promise((resolve2, reject) => {
-    let u;
     try {
-      u = new URL(rawUrl);
+      task.child.kill("SIGKILL");
     } catch {
-      reject(new Error(`invalid URL: ${rawUrl}`));
-      return;
     }
-    const isHttps = u.protocol === "https:";
-    const reqFn = isHttps ? httpsRequest : httpRequest;
-    if (isIP(u.hostname) && isPrivateAddr(u.hostname)) {
-      reject(new Error(`refused: ${u.hostname} is a private/internal address`));
-      return;
+  }
+}
+function startTask(command) {
+  const running = [...tasks.values()].filter((t) => t.status === "running").length;
+  if (running >= config.maxBackgroundTasks) {
+    return { error: `too many background tasks (${running}/${config.maxBackgroundTasks}) \u2014 stop one with stop_task first.` };
+  }
+  const child = spawn2(command, { shell: true, detached: unix, stdio: ["ignore", "pipe", "pipe"] });
+  const id = `bg_${++counter}`;
+  const task = { id, command, child, buffer: "", totalLen: 0, readLen: 0, status: "running", exitCode: null, startedAt: Date.now() };
+  const onData = (d) => {
+    const chunk = d.toString();
+    task.totalLen += chunk.length;
+    task.buffer = appendTail(task.buffer, chunk, config.backgroundTailChars).buffer;
+  };
+  child.stdout?.on("data", onData);
+  child.stderr?.on("data", onData);
+  child.on("exit", (code) => {
+    task.status = "exited";
+    task.exitCode = code;
+  });
+  child.on("error", () => {
+    task.status = "exited";
+    task.exitCode = task.exitCode ?? -1;
+  });
+  tasks.set(id, task);
+  return { id };
+}
+function checkTask(id) {
+  const task = tasks.get(id);
+  if (!task) return `Error: no background task with id "${id}". (Ids look like bg_1.)`;
+  const { output, dropped } = readSince(task.buffer, task.totalLen, task.readLen);
+  task.readLen = task.totalLen;
+  const header = task.status === "running" ? `Task ${id} is running (${task.command}).` : `Task ${id} has exited (code ${task.exitCode ?? "unknown"}): ${task.command}`;
+  const body = output ? `${dropped ? "\u2026[earlier output dropped]\n" : ""}${output}` : "(no new output since last check)";
+  return `${header}
+${body}`;
+}
+function stopTask(id) {
+  const task = tasks.get(id);
+  if (!task) return `Error: no background task with id "${id}". (Ids look like bg_1.)`;
+  if (task.status === "exited") return `Task ${id} had already exited (code ${task.exitCode ?? "unknown"}).`;
+  killTask(task);
+  task.status = "exited";
+  return `Stopped background task ${id}.`;
+}
+function runningTaskCount() {
+  return [...tasks.values()].filter((t) => t.status === "running").length;
+}
+function killAllTasks() {
+  for (const task of tasks.values()) {
+    if (task.status === "running") {
+      killTask(task);
+      task.status = "exited";
     }
-    const lookup = (hostname, options, cb) => {
-      dnsLookup(hostname, options, (err, address, family) => {
-        if (err) return cb(err, "", 0);
-        if (Array.isArray(address)) {
-          for (const a of address) {
-            if (isPrivateAddr(a.address)) return cb(new Error(`refused: ${hostname} \u2192 private/internal address (${a.address})`), "", 0);
-          }
-          return cb(null, address);
-        }
-        const addr = String(address);
-        if (isPrivateAddr(addr)) return cb(new Error(`refused: ${hostname} \u2192 private/internal address (${addr})`), "", 0);
-        cb(null, addr, family);
-      });
-    };
-    const req = reqFn(
-      {
-        protocol: u.protocol,
-        hostname: u.hostname,
-        port: Number(u.port) || (isHttps ? 443 : 80),
-        path: u.pathname + u.search,
-        method: "GET",
-        lookup,
-        signal,
-        // user cancel (Ctrl-C) aborts the request
-        headers: {
-          "User-Agent": "beecork (+https://github.com/beecork/beecork)",
-          Accept: "text/html,text/plain,*/*",
-          "Accept-Encoding": "identity"
+  }
+}
+
+// src/subagent.ts
+var EXPLORER_TOOLS = /* @__PURE__ */ new Set(["read_file", "search", "list_dir", "web_fetch", "web_search"]);
+var EMPTY_SET = /* @__PURE__ */ new Set();
+var EXPLORER_SYSTEM_PROMPT = `You are a focused code explorer \u2014 a read-only sub-agent spawned to investigate ONE question and report back. Your only tools are read_file, search, list_dir, web_fetch, and web_search. You CANNOT edit files, run commands, or ask the user anything.
+
+- Use search to locate code, list_dir to orient, read_file to read it for yourself; web_search + web_fetch when the question needs external/library docs. Follow the trail until you can answer.
+- Be efficient \u2014 you have a limited step budget. Go straight for the answer, don't wander.
+- When you have enough, STOP calling tools and write your findings.
+
+Your FINAL message must be a concise, self-contained summary that answers the task: the key files with line references, how the relevant pieces fit together, and anything the parent agent needs to act. Prefer exact paths and symbol names over prose. Do not ask questions \u2014 give your best answer from what you found.`;
+var hasContent = (m) => Boolean(m.content) || (m.tool_calls?.length ?? 0) > 0;
+async function exploreLoop(deps, task, focus, signal) {
+  const messages = [
+    { role: "system", content: EXPLORER_SYSTEM_PROMPT },
+    { role: "user", content: `Task: ${task}` + (focus ? `
+
+Start by looking at: ${focus}` : "") }
+  ];
+  for (let step = 0; step < deps.maxSteps && !signal?.aborted; step++) {
+    const message = await deps.call(messages, true, signal);
+    if (!hasContent(message)) break;
+    messages.push(message);
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      for (const call of message.tool_calls) {
+        if (signal?.aborted) break;
+        let args = {};
+        try {
+          args = JSON.parse(call.function.arguments || "{}");
+        } catch {
         }
-      },
-      (res) => {
-        const status = res.statusCode ?? 0;
-        const location = res.headers.location ?? null;
-        const contentType = String(res.headers["content-type"] ?? "");
-        if (status >= 300 && status < 400 && location) {
-          res.resume();
-          resolve2({ status, location, contentType, body: "" });
-          return;
+        const g = deps.gate(call.function.name, args);
+        if (!g.ok) {
+          messages.push({ role: "tool", tool_call_id: call.id, content: `Denied: ${g.reason}. You are a read-only explorer confined to the project \u2014 work with what you can read in-root.` });
+          deps.onStep?.(call.function.name, args, null, g.reason);
+          continue;
         }
-        const chunks = [];
-        let total = 0;
-        res.on("data", (d) => {
-          if (total < maxBytes) {
-            chunks.push(d);
-            total += d.length;
-          }
-          if (total >= maxBytes) res.destroy();
-        });
-        const done = () => resolve2({ status, location, contentType, body: Buffer.concat(chunks).toString("utf8").slice(0, maxBytes) });
-        res.on("end", done);
-        res.on("close", done);
-        res.on("error", reject);
+        const result = await deps.dispatch(call, signal);
+        messages.push({ role: "tool", tool_call_id: call.id, content: result });
+        deps.onStep?.(call.function.name, args, result);
       }
-    );
-    req.setTimeout(config.webTimeoutMs, () => req.destroy(new Error(`timed out after ${config.webTimeoutMs}ms`)));
-    req.on("error", reject);
-    req.end();
-  });
+    } else {
+      return message.content ?? "(the explorer returned no findings)";
+    }
+  }
+  if (signal?.aborted) return "(exploration cancelled)";
+  const wrap = await deps.call(
+    [...messages, { role: "system", content: "Stop exploring now. Write your findings summary from what you've gathered so far; do not call any tools." }],
+    false,
+    signal
+  );
+  return wrap.content ?? "(the explorer reached its step budget without a conclusion)";
 }
-var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next"]);
-var TREE_CAP = 400;
-var sortDirents = (entries) => entries.sort((a, b) => a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? -1 : 1);
-async function walkTree(abs, prefix, items, cap) {
-  if (items.length >= cap) return;
-  let entries;
-  try {
-    entries = await readdir(abs, { withFileTypes: true });
-  } catch {
+function narrate(name, args, result, blocked) {
+  const arg = name === "read_file" || name === "list_dir" ? String(args.path ?? "") : name === "search" ? String(args.pattern ?? "") : name === "web_fetch" ? String(args.url ?? "") : name === "web_search" ? String(args.query ?? "") : "";
+  if (blocked) {
+    console.log(color.dim(`      ${name} ${stripControl(arg)} \u2014 denied`));
     return;
   }
-  const kept = sortDirents(entries.filter((e) => !SKIP_DIRS.has(e.name)));
-  for (let i = 0; i < kept.length; i++) {
-    if (items.length >= cap) return;
-    const e = kept[i];
-    const last = i === kept.length - 1;
-    items.push({ prefix: prefix + (last ? "\u2514\u2500 " : "\u251C\u2500 "), name: e.name + (e.isDirectory() ? "/" : ""), isDir: e.isDirectory() });
-    if (e.isDirectory()) await walkTree(join2(abs, e.name), prefix + (last ? "   " : "\u2502  "), items, cap);
+  const lines = result ? result.split("\n").length : 0;
+  console.log(color.dim(`      ${name} ${stripControl(arg)}${lines ? ` \xB7 ${lines} lines` : ""}`));
+}
+async function runExplorer(task, focus, signal) {
+  const defs = toolDefs.filter((t) => EXPLORER_TOOLS.has(t.name));
+  const childSchema = defs.map((t) => ({ type: "function", function: { name: t.name, description: t.description, parameters: t.parameters } }));
+  const childByName = new Map(defs.map((t) => [t.name, t]));
+  const cap = config.maxToolResultChars;
+  const deps = {
+    call: (m, incl, sig) => callModel(m, incl, sig, { tools: childSchema, quiet: true }),
+    dispatch: async (c, sig) => {
+      const r = await runTool(c, sig, childByName);
+      return r.length > cap ? r.slice(0, cap) + `
+\u2026[truncated ${r.length - cap} chars]` : r;
+    },
+    gate: (name, args) => {
+      const d = decideApproval(childByName.get(name), args, { mode: "readonly", autoApprove: true, approvedTools: EMPTY_SET, toolName: name });
+      return d.action === "run" ? { ok: true } : { ok: false, reason: d.reason ?? "not allowed for the read-only explorer" };
+    },
+    onStep: narrate,
+    maxSteps: config.subAgentMaxSteps
+  };
+  try {
+    console.log(color.dim(`  \u21B3 exploring: ${stripControl(task)}`));
+    const findings = await exploreLoop(deps, task, focus, signal);
+    console.log(color.dim(`  \u21B3 findings ready`));
+    return findings;
+  } catch (err) {
+    if (signal?.aborted || err?.name === "AbortError") return "(exploration cancelled)";
+    return `Error exploring: ${err.message}`;
   }
 }
-function parseRange(args, defLimit) {
-  const o = Number(args.offset), l = Number(args.limit);
-  return { off: Number.isFinite(o) && o > 0 ? o : 1, lim: Number.isFinite(l) && l > 0 ? l : defLimit };
+
+// src/safety.ts
+import { homedir as homedir3 } from "node:os";
+import { basename } 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}` };
 }
-async function readLineWindow(abs, offset1, limit) {
-  const start = Math.max(0, offset1 - 1);
-  const end = start + Math.max(1, limit);
-  const lines = [];
-  let i = 0;
-  let hasMore = false;
-  const stream = createReadStream(abs, { encoding: "utf8" });
-  const rl = createLineReader({ input: stream, crlfDelay: Infinity });
-  try {
-    for await (const line of rl) {
-      if (i >= end) {
-        hasMore = true;
-        break;
-      }
-      if (i >= start) lines.push(line);
-      i++;
-    }
-  } finally {
-    rl.close();
-    stream.destroy();
+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));
+}
+function secretGuard(args) {
+  const p = pathGuard(args);
+  if (p.needsApproval) return p;
+  const path = String(args.path ?? "");
+  return isSecretPath(path) ? { needsApproval: true, reason: `this looks like a secrets file (${path}) \u2014 approve before continuing` } : {};
+}
+var readGuard = secretGuard;
+var writeGuard = secretGuard;
+var DANGEROUS_BASH = [
+  /\brm\b[\s\S]*\s(\/|~|\$\{?HOME\}?)\/?(\s*$|\*|\/\*)/,
+  // rm of / ~ $HOME (and their immediate /*)
+  /\brm\b[\s\S]*\s\/(etc|usr|bin|sbin|lib|var|boot|dev|sys|proc|root|System|Library|Applications)(\/|\s|$|\*)/,
+  // rm of a system root
+  /:\s*\(\s*\)\s*\{[^}]*\}\s*;\s*:/,
+  // fork bomb :(){ :|:& };:
+  /\bmkfs\.?\w*/,
+  // format a filesystem
+  /\bdd\b[^\n]*\bof=\/dev\//,
+  // dd to a raw device
+  /\b(curl|wget)\b[^|]*\|\s*(sudo\s+)?(sh|bash|zsh)\b/,
+  // pipe-to-shell
+  />\s*\/dev\/(sd|nvme|disk)/
+  // overwrite a disk device
+];
+var RISKY_BASH = [
+  /\b(rm|rmdir|shred|unlink)\b/,
+  // deleting files
+  /\bfind\b[\s\S]*\s-(delete|exec)\b/,
+  // find -delete / -exec (mass mutate without "rm")
+  /\btruncate\b/,
+  // truncate files to a size
+  /(^|[\s;&|])(:|true)\s*>\s*\S/,
+  // `: > file` / `true > file` truncation idiom
+  /\b(dd|fdisk|parted|wipefs|sgdisk)\b/,
+  // raw disk tools
+  /\bmkfs\.?\w*/,
+  // make a filesystem
+  /\bsudo\b/,
+  // privilege escalation
+  /[<>]\s*\/dev\/\w/,
+  // raw device I/O
+  /\|\s*(sudo\s+)?(sh|bash|zsh|python\d?|node|perl|ruby|php)\b/,
+  // pipe INTO an interpreter
+  /\b(eval|source)\b[\s\S]*\$\(\s*(curl|wget|fetch)\b/
+  // eval/source of a download
+];
+function refsOutsideRoot(cmd) {
+  const norm = cmd.replace(/\$\{?IFS\}?/g, " ").replace(/\$\{?HOME\}?/g, homedir3()).replace(/\$\{?PWD\}?/g, process.cwd()).replace(/(^|[\s"'`=(])~(?=\/|$)/g, (_m, p) => p + homedir3());
+  if (/(^|[\s"'`=(])(\.\.\/|~(\/|$))/.test(norm)) return true;
+  for (const m of norm.matchAll(/(?:^|[\s"'`=(])(\/[^\s"'`;|&()<>]*)/g)) {
+    if (!resolveInRoot(m[1]).inRoot) return true;
   }
-  return { lines, startLine: start + 1, hasMore, empty: i === 0 };
+  return false;
 }
-var toolDefs = [
-  {
-    name: "read_file",
-    description: "Read a text file, returned WITH line numbers (for reference only). For large files, pass offset (1-based start line) and limit (number of lines) to read a range.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "Path to the file." },
-        offset: { type: "number", description: "1-based line to start from (optional)." },
-        limit: { type: "number", description: "Max number of lines to return (optional)." }
-      },
-      required: ["path"]
-    },
-    guard: readGuard,
-    run: async (args) => {
-      try {
-        const { abs } = resolveInRoot(String(args.path ?? "."));
-        const { off, lim } = parseRange(args, 1e5);
-        const { lines, startLine, hasMore, empty } = await readLineWindow(abs, off, lim);
-        if (lines.length === 0) return empty ? "(empty file)" : `(offset ${off} is past the end of the file)`;
-        const numbered = lines.map((line, i) => `${String(startLine + i).padStart(5)}  ${line}`).join("\n");
-        const more = hasMore ? `
-\u2026(more lines; read again with offset ${startLine + lines.length})` : "";
-        return numbered + more;
-      } catch (err) {
-        return fail("reading file", err);
-      }
+function bashGuard(args) {
+  const cmd = String(args.command ?? "");
+  const risky = RISKY_BASH.find((re) => re.test(cmd));
+  if (risky) return { needsApproval: true, reason: `this shell command looks risky (matched ${risky})` };
+  if (refsOutsideRoot(cmd)) return { needsApproval: true, reason: "this shell command references a path outside the project root" };
+  return {};
+}
+function isPrivateAddr(ip) {
+  const m = ip.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (m) {
+    const a = +m[1], b = +m[2];
+    return a === 0 || a === 127 || a === 10 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 100 && b >= 64 && b <= 127;
+  }
+  const ip6 = ip.toLowerCase();
+  const dotted = ip6.match(/(?:^|:)(\d+\.\d+\.\d+\.\d+)$/);
+  if (dotted) return isPrivateAddr(dotted[1]);
+  const g = expandIPv6(ip6);
+  if (!g) return true;
+  if (g.every((h) => h === 0)) return true;
+  if (g.slice(0, 7).every((h) => h === 0) && g[7] === 1) return true;
+  const embeddedV4 = () => `${g[6] >> 8 & 255}.${g[6] & 255}.${g[7] >> 8 & 255}.${g[7] & 255}`;
+  if (g[0] === 0 && g[1] === 0 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 65535) {
+    return isPrivateAddr(embeddedV4());
+  }
+  if (g[0] === 100 && g[1] === 65435 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 0 || g[0] === 0 && g[1] === 0 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 0) {
+    return isPrivateAddr(embeddedV4());
+  }
+  if ((g[0] & 65472) === 65152) return true;
+  if ((g[0] & 65024) === 64512) return true;
+  return false;
+}
+function expandIPv6(ip) {
+  const halves = ip.split("::");
+  if (halves.length > 2) return null;
+  const parse = (s) => s ? s.split(":").map((h) => parseInt(h, 16)) : [];
+  const head = parse(halves[0]);
+  if (halves.length === 1) return head.length === 8 && head.every((n) => n >= 0 && n <= 65535) ? head : null;
+  const tail = parse(halves[1]);
+  const fill = 8 - head.length - tail.length;
+  if (fill < 0) return null;
+  const g = [...head, ...Array(fill).fill(0), ...tail];
+  return g.length === 8 && g.every((n) => Number.isFinite(n) && n >= 0 && n <= 65535) ? g : null;
+}
+
+// src/html.ts
+function htmlToText(html) {
+  let s = html;
+  s = s.replace(/<(script|style|noscript|template|svg|head)[\s\S]*?<\/\1>/gi, " ");
+  s = s.replace(/<!--[\s\S]*?-->/g, " ");
+  s = s.replace(/<br\s*\/?>/gi, "\n");
+  s = s.replace(/<\/(p|div|li|tr|h[1-6]|section|article|header|footer|ul|ol|table|blockquote)\s*>/gi, "\n");
+  s = s.replace(/<[^>]+>/g, " ");
+  s = decodeEntities(s);
+  s = s.replace(/[ \t\f\v]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+function decodeEntities(s) {
+  const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " " };
+  return s.replace(/&(#x?[0-9a-f]+|[a-z][a-z0-9]*);/gi, (m, code) => {
+    if (code[0] === "#") {
+      const n = code[1].toLowerCase() === "x" ? parseInt(code.slice(2), 16) : parseInt(code.slice(1), 10);
+      return Number.isFinite(n) && n >= 0 && n <= 1114111 && !(n >= 55296 && n <= 57343) ? String.fromCodePoint(n) : m;
     }
-  },
-  {
-    name: "show",
-    description: "Display a file's contents or a directory's contents to the USER in a clean view. Use this whenever the user asks to see a file or list a folder \u2014 instead of pasting or describing them in your reply. For a whole/recursive listing or the project structure, pass recursive:true (a tree). It returns only a confirmation; the user sees the rendered view.",
-    parameters: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: "File or directory to show." },
-        recursive: { type: "boolean", description: "For a directory, show the full nested tree (folders + files). Use for a whole/recursive/full listing." },
-        offset: { type: "number", description: "1-based start line (files only, optional)." },
-        limit: { type: "number", description: "Max lines to show (files only, optional; default 80)." }
-      },
-      required: ["path"]
-    },
-    guard: readGuard,
-    // Returns a tagged payload (\x01file\x01… / \x01dir\x01…) that the agent loop
-    // renders for the user; the model gets a short note instead (see ui.renderShow).
-    run: async (args) => {
+    return named[code.toLowerCase()] ?? m;
+  });
+}
+
+// src/tools.ts
+function runShell(command, opts) {
+  return new Promise((resolve2, reject) => {
+    const unix2 = process.platform !== "win32";
+    const child = spawn3(command, { shell: true, detached: unix2, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "", stderr = "", outLen = 0, errLen = 0, timedOut = false, aborted = false;
+    let settled = false, exitCode = null;
+    const kill = () => {
       try {
-        const { abs } = resolveInRoot(String(args.path ?? "."));
-        const st = await stat(abs);
-        if (st.isDirectory()) {
-          if (args.recursive) {
-            const items = [];
-            await walkTree(abs, "", items, TREE_CAP);
-            return showPayload("tree", { path: String(args.path), items, truncated: items.length >= TREE_CAP });
-          }
-          const entries = sortDirents(await readdir(abs, { withFileTypes: true }));
-          const names = entries.map((e) => e.isDirectory() ? e.name + "/" : e.name);
-          return showPayload("dir", { path: String(args.path), names });
+        if (unix2 && child.pid) process.kill(-child.pid, "SIGKILL");
+        else child.kill("SIGKILL");
+      } catch {
+        try {
+          child.kill("SIGKILL");
+        } catch {
         }
-        const { off, lim } = parseRange(args, 80);
-        const { lines, startLine, hasMore } = await readLineWindow(abs, off, lim);
-        return showPayload("file", { path: String(args.path), startLine, lines, hasMore });
-      } catch (err) {
-        return fail("showing", err);
       }
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      kill();
+    }, opts.timeout);
+    const onAbort = () => {
+      aborted = true;
+      kill();
+    };
+    if (opts.signal) {
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
     }
-  },
-  {
-    name: "search",
-    description: "Search for a regular-expression pattern across files in a directory (recursively), returning matching 'path:line: text'. Read-only. Use this to find where a name is defined or used.",
-    parameters: {
-      type: "object",
-      properties: {
-        pattern: { type: "string", description: "Regular expression to search for." },
-        path: { type: "string", description: "Directory to search. Defaults to the current directory." }
-      },
-      required: ["pattern"]
-    },
-    guard: pathGuard,
-    run: async (args) => {
-      if (/\([^()]*[+*{][^()]*\)\s*[+*{]/.test(String(args.pattern ?? ""))) {
-        return `Error: that pattern has nested quantifiers that can hang the search (catastrophic backtracking). Simplify it.`;
+    child.stdout?.on("data", (d) => {
+      if (outLen < opts.maxBuffer) {
+        stdout += d;
+        outLen += d.length;
       }
-      let regex;
-      try {
-        regex = new RegExp(args.pattern);
-      } catch {
-        return `Error: invalid regular expression: ${args.pattern}`;
+    });
+    child.stderr?.on("data", (d) => {
+      if (errLen < opts.maxBuffer) {
+        stderr += d;
+        errLen += d.length;
       }
-      const IGNORE = SKIP_DIRS;
-      const results = [];
-      const MAX = config.searchMaxResults;
-      const deadline = Date.now() + config.searchTimeoutMs;
-      let truncated = false;
-      async function walk(dir) {
-        if (results.length >= MAX) return;
-        if (Date.now() > deadline) {
-          truncated = true;
-          return;
-        }
-        let entries;
-        try {
-          entries = await readdir(dir, { withFileTypes: true });
-        } catch {
+    });
+    const cleanup = () => {
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+    };
+    const finalize = () => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (aborted) reject(Object.assign(new Error("cancelled"), { stdout, stderr }));
+      else if (timedOut) reject(Object.assign(new Error(`timed out after ${opts.timeout}ms`), { stdout, stderr }));
+      else if (exitCode !== 0 && exitCode !== null) reject(Object.assign(new Error(`exited with code ${exitCode}`), { stdout, stderr }));
+      else resolve2({ stdout, stderr });
+    };
+    child.on("error", (err) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(Object.assign(err, { stdout, stderr }));
+    });
+    child.on("close", finalize);
+    child.on("exit", (code) => {
+      exitCode = code;
+      setTimeout(finalize, 100);
+    });
+  });
+}
+var fail = (verb, err) => `Error ${verb}: ${err.message}`;
+async function atomicWrite(abs, content) {
+  const tmp = `${abs}.beecork-${process.pid}.tmp`;
+  await writeFile2(tmp, content, "utf8");
+  try {
+    await chmod(tmp, (await stat(abs)).mode);
+  } catch {
+  }
+  await rename(tmp, abs);
+}
+var READ_PREFIX = /^ *\d+ {2}/;
+function allIndexOf(hay, needle) {
+  const out2 = [];
+  let i = hay.indexOf(needle);
+  while (i !== -1) {
+    out2.push(i);
+    i = hay.indexOf(needle, i + 1);
+  }
+  return out2;
+}
+function stripReadPrefix(text) {
+  const lines = text.split("\n");
+  const nonBlank = lines.filter((l) => l.trim() !== "");
+  if (nonBlank.length === 0 || !nonBlank.every((l) => READ_PREFIX.test(l))) return null;
+  return lines.map((l) => l.replace(READ_PREFIX, "")).join("\n");
+}
+var leadWs = (l) => l.match(/^[ \t]*/)[0];
+function lineOffsets(text) {
+  const starts = [0];
+  for (let i = 0; i < text.length; i++) if (text[i] === "\n") starts.push(i + 1);
+  return starts;
+}
+function matchWhitespace(file, oldText, newText) {
+  const fileLines = file.split("\n");
+  const oldLines = oldText.split("\n");
+  const n = oldLines.length;
+  const trim = (l) => l.trim();
+  const oldTrim = oldLines.map(trim);
+  const starts = [];
+  for (let s2 = 0; s2 + n <= fileLines.length; s2++) {
+    let hit = true;
+    for (let i = 0; i < n; i++) if (trim(fileLines[s2 + i]) !== oldTrim[i]) {
+      hit = false;
+      break;
+    }
+    if (hit) starts.push(s2);
+  }
+  if (starts.length === 0) return null;
+  if (starts.length > 1) return { ok: false, reason: "ambiguous", count: starts.length };
+  const s = starts[0];
+  let shift = null;
+  let mode = "same";
+  for (let i = 0; i < n; i++) {
+    if (oldTrim[i] === "") continue;
+    const fLead = leadWs(fileLines[s + i]);
+    const oLead = leadWs(oldLines[i]);
+    let thisShift, thisMode;
+    if (fLead === oLead) {
+      thisShift = "";
+      thisMode = "same";
+    } else if (fLead.endsWith(oLead)) {
+      thisShift = fLead.slice(0, fLead.length - oLead.length);
+      thisMode = "add";
+    } else if (oLead.endsWith(fLead)) {
+      thisShift = oLead.slice(0, oLead.length - fLead.length);
+      thisMode = "strip";
+    } else return null;
+    if (shift === null) {
+      shift = thisShift;
+      mode = thisMode;
+    } else if (thisShift !== shift || thisMode !== mode && thisShift !== "") return null;
+  }
+  shift = shift ?? "";
+  const reindented = newText.split("\n").map((l) => {
+    if (l.trim() === "") return l;
+    if (mode === "add") return shift + l;
+    if (mode === "strip") return l.startsWith(shift) ? l.slice(shift.length) : l;
+    return l;
+  }).join("\n");
+  const offs = lineOffsets(file);
+  const start = offs[s];
+  const end = s + n < offs.length ? offs[s + n] - 1 : file.length;
+  return { ok: true, start, end, after: reindented, healedVia: "whitespace" };
+}
+function closestRegion(file, oldText) {
+  const anchor = oldText.split("\n").map((l) => l.trim()).find((l) => l !== "");
+  if (!anchor) return void 0;
+  const fileLines = file.split("\n");
+  const fmt = (i) => `${String(i + 1).padStart(5)}  ${fileLines[i]}`;
+  const exact = [];
+  for (let i = 0; i < fileLines.length && exact.length < 3; i++) {
+    if (fileLines[i].trim() === anchor) exact.push(fmt(i));
+  }
+  if (exact.length) return exact.join("\n");
+  const words = anchor.split(/\W+/).filter((w) => w.length >= 2);
+  if (words.length === 0) return void 0;
+  let best = -1;
+  let bestScore = 0;
+  for (let i = 0; i < fileLines.length; i++) {
+    let score = 0;
+    for (const w of words) if (fileLines[i].includes(w)) score++;
+    if (score > bestScore) {
+      bestScore = score;
+      best = i;
+    }
+  }
+  return best >= 0 && bestScore >= Math.max(2, Math.ceil(words.length / 2)) ? fmt(best) : void 0;
+}
+function resolveEdit(file, oldText, newText) {
+  if (oldText === "") return { ok: false, reason: "not_found" };
+  const exact = allIndexOf(file, oldText);
+  if (exact.length === 1) return { ok: true, start: exact[0], end: exact[0] + oldText.length, after: newText, healedVia: "exact" };
+  if (exact.length > 1) return { ok: false, reason: "ambiguous", count: exact.length };
+  const strippedOld = stripReadPrefix(oldText);
+  if (strippedOld !== null && strippedOld !== oldText) {
+    const hits = allIndexOf(file, strippedOld);
+    if (hits.length === 1) {
+      const strippedNew = newText.split("\n").map((l) => l.replace(READ_PREFIX, "")).join("\n");
+      return { ok: true, start: hits[0], end: hits[0] + strippedOld.length, after: strippedNew, healedVia: "prefix" };
+    }
+    if (hits.length > 1) return { ok: false, reason: "ambiguous", count: hits.length };
+  }
+  const ws = matchWhitespace(file, oldText, newText);
+  if (ws) return ws;
+  return { ok: false, reason: "not_found", closest: closestRegion(file, oldText) };
+}
+var todos = [];
+function httpGet(rawUrl, maxBytes, signal) {
+  return new Promise((resolve2, reject) => {
+    let u;
+    try {
+      u = new URL(rawUrl);
+    } catch {
+      reject(new Error(`invalid URL: ${rawUrl}`));
+      return;
+    }
+    const isHttps = u.protocol === "https:";
+    const reqFn = isHttps ? httpsRequest : httpRequest;
+    if (isIP(u.hostname) && isPrivateAddr(u.hostname)) {
+      reject(new Error(`refused: ${u.hostname} is a private/internal address`));
+      return;
+    }
+    const lookup = (hostname, options, cb) => {
+      dnsLookup(hostname, options, (err, address, family) => {
+        if (err) return cb(err, "", 0);
+        if (Array.isArray(address)) {
+          for (const a of address) {
+            if (isPrivateAddr(a.address)) return cb(new Error(`refused: ${hostname} \u2192 private/internal address (${a.address})`), "", 0);
+          }
+          return cb(null, address);
+        }
+        const addr = String(address);
+        if (isPrivateAddr(addr)) return cb(new Error(`refused: ${hostname} \u2192 private/internal address (${addr})`), "", 0);
+        cb(null, addr, family);
+      });
+    };
+    const req = reqFn(
+      {
+        protocol: u.protocol,
+        hostname: u.hostname,
+        port: Number(u.port) || (isHttps ? 443 : 80),
+        path: u.pathname + u.search,
+        method: "GET",
+        lookup,
+        signal,
+        // user cancel (Ctrl-C) aborts the request
+        headers: {
+          "User-Agent": "beecork (+https://github.com/beecork/beecork)",
+          Accept: "text/html,text/plain,*/*",
+          "Accept-Encoding": "identity"
+        }
+      },
+      (res) => {
+        const status = res.statusCode ?? 0;
+        const location = res.headers.location ?? null;
+        const contentType = String(res.headers["content-type"] ?? "");
+        if (status >= 300 && status < 400 && location) {
+          res.resume();
+          resolve2({ status, location, contentType, body: "" });
           return;
         }
-        for (const e of entries) {
-          if (results.length >= MAX || truncated) return;
-          if (Date.now() > deadline) {
-            truncated = true;
-            return;
-          }
-          if (IGNORE.has(e.name)) continue;
-          const full = `${dir}/${e.name}`;
-          if (e.isDirectory()) {
-            await walk(full);
-          } else if (e.isFile()) {
-            if (SECRET_FILE.test(e.name)) continue;
-            const info = await stat(full).catch(() => null);
-            if (info && info.size > config.searchMaxFileBytes) continue;
-            let lines;
-            try {
-              lines = (await readFile2(full, "utf8")).split("\n");
-            } catch {
-              continue;
-            }
-            for (let i = 0; i < lines.length; i++) {
-              if (lines[i].length > 1e4) continue;
-              if (regex.test(lines[i])) {
-                results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
-                if (results.length >= MAX) break;
-              }
-            }
+        const chunks = [];
+        let total = 0;
+        res.on("data", (d) => {
+          if (total < maxBytes) {
+            chunks.push(d);
+            total += d.length;
           }
-        }
+          if (total >= maxBytes) res.destroy();
+        });
+        const done = () => resolve2({ status, location, contentType, body: Buffer.concat(chunks).toString("utf8").slice(0, maxBytes) });
+        res.on("end", done);
+        res.on("close", done);
+        res.on("error", reject);
       }
-      await walk(resolveInRoot(String(args.path ?? ".")).abs);
-      if (results.length === 0) return truncated ? `No matches yet \u2014 search stopped at the time budget. Narrow the path or pattern.` : `No matches for "${args.pattern}".`;
-      const note = results.length >= MAX ? `
-\u2026(showing first ${MAX} matches)` : truncated ? `
-\u2026(search stopped at the time budget \u2014 results may be incomplete)` : "";
-      return results.join("\n") + note;
+    );
+    req.setTimeout(config.webTimeoutMs, () => req.destroy(new Error(`timed out after ${config.webTimeoutMs}ms`)));
+    req.on("error", reject);
+    req.end();
+  });
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next"]);
+var TREE_CAP = 400;
+var sortDirents = (entries) => entries.sort((a, b) => a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? -1 : 1);
+async function walkTree(abs, prefix, items, cap) {
+  if (items.length >= cap) return;
+  let entries;
+  try {
+    entries = await readdir(abs, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const kept = sortDirents(entries.filter((e) => !SKIP_DIRS.has(e.name)));
+  for (let i = 0; i < kept.length; i++) {
+    if (items.length >= cap) return;
+    const e = kept[i];
+    const last = i === kept.length - 1;
+    items.push({ prefix: prefix + (last ? "\u2514\u2500 " : "\u251C\u2500 "), name: e.name + (e.isDirectory() ? "/" : ""), isDir: e.isDirectory() });
+    if (e.isDirectory()) await walkTree(join2(abs, e.name), prefix + (last ? "   " : "\u2502  "), items, cap);
+  }
+}
+function parseRange(args, defLimit) {
+  const o = Number(args.offset), l = Number(args.limit);
+  return { off: Number.isFinite(o) && o > 0 ? o : 1, lim: Number.isFinite(l) && l > 0 ? l : defLimit };
+}
+async function readLineWindow(abs, offset1, limit) {
+  const start = Math.max(0, offset1 - 1);
+  const end = start + Math.max(1, limit);
+  const lines = [];
+  let i = 0;
+  let hasMore = false;
+  const stream = createReadStream(abs, { encoding: "utf8" });
+  const rl = createLineReader({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (i >= end) {
+        hasMore = true;
+        break;
+      }
+      if (i >= start) lines.push(line);
+      i++;
     }
-  },
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  return { lines, startLine: start + 1, hasMore, empty: i === 0 };
+}
+var toolDefs = [
   {
-    name: "write_file",
-    description: "Create a NEW file (or fully overwrite an existing one) with the given content. To change PART of an existing file, prefer edit_file instead.",
-    needsApproval: true,
-    guard: writeGuard,
-    // out-of-root OR a secrets file (.env/.npmrc/key…) → per-call prompt, never cached
+    name: "read_file",
+    description: "Read a text file, returned WITH line numbers (for reference only). For large files, pass offset (1-based start line) and limit (number of lines) to read a range.",
     parameters: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Path to the file to write." },
-        content: { type: "string", description: "The full text to write into the file." }
+        path: { type: "string", description: "Path to the file." },
+        offset: { type: "number", description: "1-based line to start from (optional)." },
+        limit: { type: "number", description: "Max number of lines to return (optional)." }
       },
-      required: ["path", "content"]
+      required: ["path"]
     },
+    guard: readGuard,
     run: async (args) => {
       try {
         const { abs } = resolveInRoot(String(args.path ?? "."));
-        const content = String(args.content ?? "");
-        await atomicWrite(abs, content);
-        return `Wrote ${content.length} characters to ${args.path}`;
+        const { off, lim } = parseRange(args, 1e5);
+        const { lines, startLine, hasMore, empty } = await readLineWindow(abs, off, lim);
+        if (lines.length === 0) return empty ? "(empty file)" : `(offset ${off} is past the end of the file)`;
+        const numbered = lines.map((line, i) => `${String(startLine + i).padStart(5)}  ${line}`).join("\n");
+        const more = hasMore ? `
+\u2026(more lines; read again with offset ${startLine + lines.length})` : "";
+        return numbered + more;
       } catch (err) {
-        return fail("writing file", err);
+        return fail("reading file", err);
       }
     }
   },
   {
-    name: "edit_file",
-    description: "Make a precise edit to an EXISTING file: replace an exact snippet (old_text) with new_text. old_text must match the file exactly (including whitespace) and appear EXACTLY ONCE. Use the file's RAW text \u2014 do NOT include the line-number prefixes that read_file shows. Prefer this over write_file when changing existing files.",
-    needsApproval: true,
-    guard: writeGuard,
-    // out-of-root OR a secrets file → per-call prompt, never cached
+    name: "show",
+    description: "Display a file's contents or a directory's contents to the USER in a clean view. Use this whenever the user asks to see a file or list a folder \u2014 instead of pasting or describing them in your reply. For a whole/recursive listing or the project structure, pass recursive:true (a tree). It returns only a confirmation; the user sees the rendered view.",
     parameters: {
       type: "object",
       properties: {
-        path: { type: "string", description: "Path to the file to edit." },
-        old_text: {
-          type: "string",
-          description: "The exact text to find and replace. Must match the file exactly and appear once. Include enough surrounding lines to make it unique."
-        },
-        new_text: { type: "string", description: "The text to replace old_text with." }
+        path: { type: "string", description: "File or directory to show." },
+        recursive: { type: "boolean", description: "For a directory, show the full nested tree (folders + files). Use for a whole/recursive/full listing." },
+        offset: { type: "number", description: "1-based start line (files only, optional)." },
+        limit: { type: "number", description: "Max lines to show (files only, optional; default 80)." }
       },
-      required: ["path", "old_text", "new_text"]
+      required: ["path"]
     },
+    guard: readGuard,
+    // Returns a tagged payload (\x01file\x01… / \x01dir\x01…) that the agent loop
+    // renders for the user; the model gets a short note instead (see ui.renderShow).
     run: async (args) => {
       try {
         const { abs } = resolveInRoot(String(args.path ?? "."));
-        const original = await readFile2(abs, "utf8");
-        const count = original.split(args.old_text).length - 1;
-        if (count === 0) {
-          return `Error: old_text not found in ${args.path}. Re-read the file and copy the exact text (including whitespace/indentation).`;
-        }
-        if (count > 1) {
-          return `Error: old_text appears ${count} times in ${args.path}. Include more surrounding context so it matches exactly once.`;
-        }
-        await atomicWrite(abs, original.replace(args.old_text, () => String(args.new_text)));
-        return `Edited ${args.path} \u2014 replaced 1 occurrence.`;
-      } catch (err) {
-        return fail("editing file", err);
-      }
-    }
-  },
+        const st = await stat(abs);
+        if (st.isDirectory()) {
+          if (args.recursive) {
+            const items = [];
+            await walkTree(abs, "", items, TREE_CAP);
+            return showPayload("tree", { path: String(args.path), items, truncated: items.length >= TREE_CAP });
+          }
+          const entries = sortDirents(await readdir(abs, { withFileTypes: true }));
+          const names = entries.map((e) => e.isDirectory() ? e.name + "/" : e.name);
+          return showPayload("dir", { path: String(args.path), names });
+        }
+        const { off, lim } = parseRange(args, 80);
+        const { lines, startLine, hasMore } = await readLineWindow(abs, off, lim);
+        return showPayload("file", { path: String(args.path), startLine, lines, hasMore });
+      } catch (err) {
+        return fail("showing", err);
+      }
+    }
+  },
+  {
+    name: "search",
+    description: "Search for a regular-expression pattern across files in a directory (recursively), returning matching 'path:line: text'. Read-only. Use this to find where a name is defined or used.",
+    parameters: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Regular expression to search for." },
+        path: { type: "string", description: "Directory to search. Defaults to the current directory." }
+      },
+      required: ["pattern"]
+    },
+    guard: pathGuard,
+    run: async (args) => {
+      if (/\([^()]*[+*{][^()]*\)\s*[+*{]/.test(String(args.pattern ?? ""))) {
+        return `Error: that pattern has nested quantifiers that can hang the search (catastrophic backtracking). Simplify it.`;
+      }
+      let regex;
+      try {
+        regex = new RegExp(args.pattern);
+      } catch {
+        return `Error: invalid regular expression: ${args.pattern}`;
+      }
+      const IGNORE = SKIP_DIRS;
+      const results = [];
+      const MAX = config.searchMaxResults;
+      const deadline = Date.now() + config.searchTimeoutMs;
+      let truncated = false;
+      async function walk(dir) {
+        if (results.length >= MAX) return;
+        if (Date.now() > deadline) {
+          truncated = true;
+          return;
+        }
+        let entries;
+        try {
+          entries = await readdir(dir, { withFileTypes: true });
+        } catch {
+          return;
+        }
+        for (const e of entries) {
+          if (results.length >= MAX || truncated) return;
+          if (Date.now() > deadline) {
+            truncated = true;
+            return;
+          }
+          if (IGNORE.has(e.name)) continue;
+          const full = `${dir}/${e.name}`;
+          if (e.isDirectory()) {
+            await walk(full);
+          } else if (e.isFile()) {
+            if (SECRET_FILE.test(e.name)) continue;
+            const info = await stat(full).catch(() => null);
+            if (info && info.size > config.searchMaxFileBytes) continue;
+            let lines;
+            try {
+              lines = (await readFile2(full, "utf8")).split("\n");
+            } catch {
+              continue;
+            }
+            for (let i = 0; i < lines.length; i++) {
+              if (lines[i].length > 1e4) continue;
+              if (regex.test(lines[i])) {
+                results.push(`${full}:${i + 1}: ${lines[i].trim()}`);
+                if (results.length >= MAX) break;
+              }
+            }
+          }
+        }
+      }
+      await walk(resolveInRoot(String(args.path ?? ".")).abs);
+      if (results.length === 0) return truncated ? `No matches yet \u2014 search stopped at the time budget. Narrow the path or pattern.` : `No matches for "${args.pattern}".`;
+      const note = results.length >= MAX ? `
+\u2026(showing first ${MAX} matches)` : truncated ? `
+\u2026(search stopped at the time budget \u2014 results may be incomplete)` : "";
+      return results.join("\n") + note;
+    }
+  },
+  {
+    name: "write_file",
+    description: "Create a NEW file (or fully overwrite an existing one) with the given content. To change PART of an existing file, prefer edit_file instead.",
+    needsApproval: true,
+    guard: writeGuard,
+    // out-of-root OR a secrets file (.env/.npmrc/key…) → per-call prompt, never cached
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file to write." },
+        content: { type: "string", description: "The full text to write into the file." }
+      },
+      required: ["path", "content"]
+    },
+    run: async (args) => {
+      try {
+        const { abs } = resolveInRoot(String(args.path ?? "."));
+        const content = String(args.content ?? "");
+        await atomicWrite(abs, content);
+        return `Wrote ${content.length} characters to ${args.path}`;
+      } catch (err) {
+        return fail("writing file", err);
+      }
+    }
+  },
+  {
+    name: "edit_file",
+    description: "Make a precise edit to an EXISTING file: replace an exact snippet (old_text) with new_text. old_text must match the file exactly (including whitespace) and appear EXACTLY ONCE. Use the file's RAW text \u2014 do NOT include the line-number prefixes that read_file shows. Prefer this over write_file when changing existing files.",
+    needsApproval: true,
+    guard: writeGuard,
+    // out-of-root OR a secrets file → per-call prompt, never cached
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path to the file to edit." },
+        old_text: {
+          type: "string",
+          description: "The exact text to find and replace. Must match the file exactly and appear once. Include enough surrounding lines to make it unique."
+        },
+        new_text: { type: "string", description: "The text to replace old_text with." }
+      },
+      required: ["path", "old_text", "new_text"]
+    },
+    run: async (args) => {
+      try {
+        const { abs } = resolveInRoot(String(args.path ?? "."));
+        const original = await readFile2(abs, "utf8");
+        const res = resolveEdit(original, String(args.old_text ?? ""), String(args.new_text ?? ""));
+        if (!res.ok) {
+          if (res.reason === "ambiguous") {
+            return `Error: old_text matches ${res.count} places in ${args.path}. Include more surrounding context so it matches exactly once.`;
+          }
+          return `Error: old_text not found in ${args.path}. ` + (res.closest ? `The closest matching text in the file is (copy it EXACTLY, without the line-number prefix):
+${res.closest}` : `Re-read the file and copy the exact text (including whitespace/indentation).`);
+        }
+        if (original.slice(res.start, res.end) === res.after) {
+          return `Error: old_text and new_text are identical in ${args.path} \u2014 nothing to change.`;
+        }
+        await atomicWrite(abs, original.slice(0, res.start) + res.after + original.slice(res.end));
+        const healed = res.healedVia === "prefix" ? " (auto-healed: stripped read_file line-number prefixes)" : res.healedVia === "whitespace" ? " (auto-healed: normalized whitespace/indentation)" : "";
+        return `Edited ${args.path} \u2014 replaced 1 occurrence.${healed}`;
+      } catch (err) {
+        return fail("editing file", err);
+      }
+    }
+  },
   {
     name: "list_dir",
     description: "List the files and folders in a directory. Use this to list or COUNT files \u2014 do NOT shell out to run_bash/ls for that.",
@@ -1249,7 +1927,8 @@ var toolDefs = [
       type: "object",
       properties: {
         command: { type: "string", description: "The shell command to run." },
-        explanation: { type: "string", description: "One sentence: WHAT this command does and WHY you need it now. Shown to the user before they approve." }
+        explanation: { type: "string", description: "One sentence: WHAT this command does and WHY you need it now. Shown to the user before they approve." },
+        background: { type: "boolean", description: "Run detached in the background (dev servers, watchers, long tasks). Returns a task id immediately; poll it with check_task and stop it with stop_task. Do NOT use for commands whose output you need right now." }
       },
       required: ["command", "explanation"]
     },
@@ -1258,6 +1937,10 @@ var toolDefs = [
       if (danger) {
         return `Error: refused \u2014 the command matches a known-catastrophic pattern (${danger}). If this is genuinely intended, the user must run it manually.`;
       }
+      if (args.background) {
+        const { id, error } = startTask(String(args.command));
+        return error ? `Error: ${error}` : `Started background task ${id} \u2014 running detached. Poll new output with check_task("${id}"), stop it with stop_task("${id}"). Stop it once you no longer need it.`;
+      }
       try {
         const { stdout, stderr } = await runShell(args.command, { timeout: config.execTimeoutMs, maxBuffer: config.maxToolBuffer, signal });
         return (stdout || "") + (stderr ? `
@@ -1407,6 +2090,77 @@ ${list}`;
         return fail("saving memory", err);
       }
     }
+  },
+  {
+    name: "check_task",
+    description: "Read status + new output from a background task started by run_bash (background:true). Returns only output produced since your last check. Use to see if a dev server started, a build finished, etc.",
+    parameters: {
+      type: "object",
+      properties: { task_id: { type: "string", description: "The bg_\u2026 id returned by run_bash." } },
+      required: ["task_id"]
+    },
+    run: async (args) => checkTask(String(args.task_id ?? ""))
+  },
+  {
+    name: "stop_task",
+    description: "Stop (kill) a background task started by run_bash (background:true). Stop tasks you no longer need.",
+    parameters: {
+      type: "object",
+      properties: { task_id: { type: "string", description: "The bg_\u2026 id to stop." } },
+      required: ["task_id"]
+    },
+    run: async (args) => stopTask(String(args.task_id ?? ""))
+  },
+  {
+    name: "explore",
+    description: "Delegate a focused, READ-ONLY investigation to a sub-agent. It explores on its own (reading, searching, listing, and browsing the web) and returns a concise written summary \u2014 so open-ended questions ('how does X work', 'where is Y handled', 'trace Z', 'research library W') get answered in a SEPARATE context, keeping yours clean. It cannot modify anything, run commands, or ask questions.",
+    parameters: {
+      type: "object",
+      properties: {
+        task: { type: "string", description: "What to find out \u2014 one clear, self-contained question." },
+        focus: { type: "string", description: "Optional starting point: files, directories, symbols, or a URL to look at first." }
+      },
+      required: ["task"]
+    },
+    run: async (args, signal) => {
+      const task = String(args.task ?? "").trim();
+      if (!task) return 'Error: explore needs a non-empty "task".';
+      return runExplorer(task, args.focus ? String(args.focus) : void 0, signal);
+    }
+  },
+  {
+    name: "ask_user",
+    description: "Ask the user to choose between concrete options when the task is genuinely ambiguous or has several valid approaches with different outcomes AND you can't pick a sensible default. Provide 2\u20134 clear options. Use SPARINGLY \u2014 for low-stakes choices, just proceed with a reasonable default.",
+    parameters: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "One specific question to ask." },
+        options: {
+          type: "array",
+          description: "2\u20134 concrete choices.",
+          items: {
+            type: "object",
+            properties: {
+              label: { type: "string", description: "Short label for the choice." },
+              description: { type: "string", description: "Optional one-line explanation of this choice." }
+            },
+            required: ["label"]
+          }
+        }
+      },
+      required: ["question", "options"]
+    },
+    // The turn loop intercepts ask_user to show beecork's native picker on a TTY (tools don't get
+    // the keyboard). Reaching run() means no interactive session (headless / a direct call), so we
+    // just validate and tell the model to proceed on its own.
+    run: async (args) => {
+      const options = Array.isArray(args.options) ? args.options : [];
+      const question = String(args.question ?? "").trim();
+      if (!question || options.length === 0) {
+        return `Error: ask_user needs a "question" and a non-empty "options" array (2\u20134 concrete choices, each with a label).`;
+      }
+      return `No interactive user is available (headless run). Proceed with the most reasonable option for "${question}" and state the assumption you made.`;
+    }
   }
 ];
 var TOOLS = toolDefs.map((t) => ({
@@ -1414,8 +2168,8 @@ var TOOLS = toolDefs.map((t) => ({
   function: { name: t.name, description: t.description, parameters: t.parameters }
 }));
 var toolsByName = new Map(toolDefs.map((t) => [t.name, t]));
-async function runTool(call, signal) {
-  const tool = toolsByName.get(call.function.name);
+async function runTool(call, signal, byName = toolsByName) {
+  const tool = byName.get(call.function.name);
   if (!tool) return `Error: unknown tool "${call.function.name}".`;
   let args;
   try {
@@ -1489,19 +2243,52 @@ function parseSSELine(line) {
   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;
 }
-async function callModel(messages, includeTools = true, signal) {
-  const body = {
+function buildRequestBody(opts) {
+  const { model, messages, includeTools, effort, reasoningSupported, extra, tools } = opts;
+  const body = { ...extra };
+  body.model = model;
+  body.messages = messages;
+  body.stream = true;
+  if (includeTools) body.tools = tools ?? TOOLS;
+  if (reasoningSupported && !("reasoning" in extra)) {
+    body.reasoning = effort === "off" ? { enabled: false } : { effort };
+  }
+  return body;
+}
+function pruneReasoningForSend(messages) {
+  let lastUser = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  return messages.map((m, i) => {
+    if (i > lastUser || m.reasoning === void 0 && m.reasoning_details === void 0) return m;
+    const { reasoning, reasoning_details, ...rest } = m;
+    return rest;
+  });
+}
+async function callModel(messages, includeTools = true, signal, opts) {
+  const quiet = opts?.quiet ?? false;
+  const body = buildRequestBody({
     model: state.model,
-    messages,
-    ...includeTools ? { tools: TOOLS } : {},
-    stream: true
-  };
+    messages: pruneReasoningForSend(messages),
+    includeTools,
+    effort: state.reasoningEffort,
+    reasoningSupported: shouldSendReasoning(state.model),
+    extra: config.openRouterExtra,
+    tools: opts?.tools
+  });
   const tries = config.retryAttempts;
   for (let attempt = 1; attempt <= tries; attempt++) {
     const sig = signal ? AbortSignal.any([signal, AbortSignal.timeout(config.apiTimeoutMs)]) : AbortSignal.timeout(config.apiTimeoutMs);
-    const stopSpinner = startSpinner("thinking\u2026");
+    const stopSpinner = quiet ? () => {
+    } : startSpinner("thinking\u2026");
     let response;
     try {
       response = await openRouterChat(body, sig);
@@ -1528,13 +2315,37 @@ async function callModel(messages, includeTools = true, signal) {
     }
     let content = "";
     const toolCalls = [];
+    let reasoning = "";
+    const reasoningDetails = [];
+    let printedReasoning = false;
     let printedText = false;
     let streamBroke = false;
     let streamError = null;
     let streamErrorCode;
     const decoder = new TextDecoder();
     let buffer = "";
-    const md = process.stdout.isTTY ? createMarkdownStream((s) => process.stdout.write(s)) : null;
+    const md = process.stdout.isTTY && !quiet ? createMarkdownStream((s) => process.stdout.write(s)) : null;
+    const displayThinking = (s) => {
+      if (quiet || !process.stdout.isTTY || !s) return;
+      stopSpinner();
+      if (!printedReasoning) {
+        process.stdout.write("\n" + color.dim("thinking: "));
+        printedReasoning = true;
+      }
+      process.stdout.write(color.dim(stripControl(s)));
+    };
+    const mergeDetail = (d) => {
+      const i = typeof d.index === "number" ? d.index : reasoningDetails.length ? reasoningDetails.length - 1 : 0;
+      const slot = reasoningDetails[i] ??= {};
+      if (d.type) slot.type = d.type;
+      if (d.format) slot.format = d.format;
+      if (d.id) slot.id = d.id;
+      if (d.signature) slot.signature = d.signature;
+      if (typeof d.index === "number") slot.index = d.index;
+      if (typeof d.text === "string") slot.text = (slot.text ?? "") + d.text;
+      if (typeof d.summary === "string") slot.summary = (slot.summary ?? "") + d.summary;
+      if (typeof d.data === "string") slot.data = (slot.data ?? "") + d.data;
+    };
     const handleLine = (line) => {
       const ev = parseSSELine(line);
       if (!ev) return;
@@ -1543,15 +2354,27 @@ async function callModel(messages, includeTools = true, signal) {
         streamErrorCode = ev.errorCode;
         return;
       }
+      if (ev.reasoning) {
+        reasoning += ev.reasoning;
+        displayThinking(ev.reasoning);
+      }
+      if (ev.reasoningDetails) {
+        for (const d of ev.reasoningDetails) {
+          mergeDetail(d);
+          if (!ev.reasoning) displayThinking(typeof d.text === "string" ? d.text : typeof d.summary === "string" ? d.summary : "");
+        }
+      }
       if (ev.content) {
         stopSpinner();
-        if (!printedText) {
-          process.stdout.write("\n" + color.cyan("bee: "));
-          printedText = true;
+        if (!quiet) {
+          if (!printedText) {
+            process.stdout.write("\n" + color.cyan("bee: "));
+            printedText = true;
+          }
+          const safe = stripControl(ev.content);
+          if (md) md.push(safe);
+          else process.stdout.write(safe);
         }
-        const safe = stripControl(ev.content);
-        if (md) md.push(safe);
-        else process.stdout.write(safe);
         content += ev.content;
       }
       if (ev.toolCalls) {
@@ -1590,6 +2413,8 @@ async function callModel(messages, includeTools = true, signal) {
         md.end();
         process.stdout.write("\n");
       } else process.stdout.write("\n\n");
+    } else if (printedReasoning) {
+      process.stdout.write("\n");
     }
     if (streamError) {
       const transient = streamErrorCode !== void 0 && Number.isFinite(streamErrorCode) && isTransientStatus(streamErrorCode) || /rate.?limit|overloaded|temporar|timeout|try again|\b(429|500|502|503|504)\b/i.test(streamError);
@@ -1609,6 +2434,9 @@ async function callModel(messages, includeTools = true, signal) {
     const message = { role: "assistant", content: content || null };
     const calls = toolCalls.filter(Boolean).map((c, i) => c.id ? c : { ...c, id: `call_${i}` });
     if (calls.length > 0) message.tool_calls = calls;
+    if (reasoning) message.reasoning = reasoning;
+    const details = reasoningDetails.filter(Boolean);
+    if (details.length > 0) message.reasoning_details = details;
     return message;
   }
   return { role: "assistant", content: null };
@@ -1637,7 +2465,7 @@ async function summarize(old, signal) {
     messages: [
       {
         role: "system",
-        content: "You compress conversations. Summarize the transcript into concise notes that preserve key facts, decisions, file contents discovered, and the user's goals, so the assistant can continue seamlessly."
+        content: "You are compacting a long coding session to fit the context window. Summarize the transcript below into structured notes the assistant can continue from WITHOUT losing important context. Use exactly these headings:\n- Goal: what the user ultimately wants (and any explicit instructions/preferences).\n- Done: key steps taken, decisions made, and files created or edited \u2014 keep the essential code/exact changes.\n- Facts: important things discovered about the codebase (structure, conventions, file contents that matter).\n- Errors & fixes: problems hit and how they were resolved, plus any user corrections.\n- Pending: what still remains to do.\nBe concise but specific \u2014 keep names, signatures, and paths; omit chit-chat."
       },
       { role: "user", content: transcript(old) }
     ]
@@ -1755,18 +2583,20 @@ async function readJsonFile(path) {
 async function loadSettings() {
   const paths = beecorkPaths("settings.json");
   let model;
+  let reasoningEffort;
   let alwaysAllow = [];
   let projectAlwaysAllowIgnored = false;
   for (let i = 0; i < paths.length; i++) {
     const parsed = await readJsonFile(paths[i]);
     if (!parsed) continue;
     if (typeof parsed.model === "string") model = parsed.model;
+    if (typeof parsed.reasoningEffort === "string") reasoningEffort = normalizeEffort(parsed.reasoningEffort) ?? reasoningEffort;
     if (Array.isArray(parsed.alwaysAllow)) {
       if (i === 0) alwaysAllow = parsed.alwaysAllow.map(String);
       else projectAlwaysAllowIgnored = true;
     }
   }
-  return { model, alwaysAllow, projectAlwaysAllowIgnored };
+  return { model, reasoningEffort, alwaysAllow, projectAlwaysAllowIgnored };
 }
 function userConfigPath() {
   return join3(homedir4(), BEECORK, "config.json");
@@ -1793,6 +2623,15 @@ async function saveModelPreference(model) {
   } catch {
   }
 }
+async function saveReasoningPreference(reasoningEffort) {
+  try {
+    const file = join3(homedir4(), BEECORK, "settings.json");
+    await mkdir3(dirname2(file), { recursive: true });
+    const current = await readJsonFile(file) ?? {};
+    await writeFile3(file, JSON.stringify({ ...current, reasoningEffort }, null, 2), "utf8");
+  } catch {
+  }
+}
 var sessionsDir = () => join3(process.cwd(), BEECORK, "sessions");
 async function saveSession(messages) {
   try {
@@ -1894,13 +2733,10 @@ async function addProjectApproval(tool) {
 // src/agent.ts
 var SYSTEM_PROMPT = `You are beecork, a coding assistant working in a terminal on the user's machine.
 
-Environment:
-- Working directory: ${process.cwd()}
-- Platform: ${process.platform}
-
 # How to work
 - For multi-step tasks, call \`update_todos\` to write a short plan, then work through it \u2014 mark each item in_progress when you start it and completed when done. Keep the list current.
 - Keep going until the task is FULLY complete. Don't stop after one step or hand back a half-finished task to ask what's next \u2014 unless you are genuinely blocked or need a real decision from the user.
+- When you genuinely need a decision (an ambiguous request, or several valid approaches with different outcomes) and can't pick a sensible default, call \`ask_user\` with 2\u20134 concrete options instead of guessing. Use it SPARINGLY \u2014 for low-stakes choices, just proceed with a reasonable default.
 - Work in small steps and VERIFY: after changes, run the relevant test/build/command. An automatic check may also run after each edit \u2014 if it reports FAILED, fix the problem before continuing. Read the output and fix anything that broke.
 - Use your tools to find facts instead of guessing.
 - When the user shares a durable preference, project convention, or fact worth keeping across sessions, call \`remember\` to save it.
@@ -1960,7 +2796,33 @@ function decideApproval(tool, args, ctx) {
   }
   return { action: "run" };
 }
-var hasContent = (m) => Boolean(m.content) || (m.tool_calls?.length ?? 0) > 0;
+var hasContent2 = (m) => Boolean(m.content) || (m.tool_calls?.length ?? 0) > 0;
+function askUserMessage(question, choice, interactive) {
+  if (!interactive) {
+    return `No interactive user is available (headless run). Proceed with the most reasonable option for "${question}" and state the assumption you made.`;
+  }
+  if (!choice) {
+    return `The user dismissed "${question}" without choosing. Use your best judgment to proceed, or ask again only if you are truly blocked.`;
+  }
+  return `The user selected: "${choice.label}"${choice.description ? ` \u2014 ${choice.description}` : ""}. Continue with this choice.`;
+}
+async function handleAskUser(args) {
+  const question = String(args.question ?? "").trim();
+  const raw = Array.isArray(args.options) ? args.options : [];
+  const options = raw.map((o) => ({ label: String(o?.label ?? "").trim(), description: o?.description ? String(o.description) : "" })).filter((o) => o.label);
+  if (!question || options.length === 0) {
+    return `Error: ask_user needs a "question" and a non-empty "options" array (2\u20134 concrete choices, each with a label).`;
+  }
+  if (!process.stdin.isTTY) return askUserMessage(question, null, false);
+  console.log();
+  const choice = await selectMenu({
+    title: stripControl(question),
+    // question is model-supplied — never let it carry raw escapes
+    items: options.map((o) => ({ label: stripControl(o.label), value: o, hint: o.description ? stripControl(o.description) : void 0 }))
+  });
+  if (choice) console.log(color.green(`  \u2192 ${stripControl(choice.label)}`) + "\n");
+  return askUserMessage(question, choice, true);
+}
 async function handleToolCall(call, messages, step, deps) {
   const { approvedTools, callCounts, ask, signal } = deps;
   const pushTool = (content) => messages.push({ role: "tool", tool_call_id: call.id, content });
@@ -1978,6 +2840,11 @@ async function handleToolCall(call, messages, step, deps) {
     callArgs = JSON.parse(call.function.arguments);
   } catch {
   }
+  if (call.function.name === "ask_user") {
+    if (config.traceFile) trace.push({ tool: call.function.name, args: call.function.arguments, step });
+    pushTool(await handleAskUser(callArgs));
+    return;
+  }
   const decision = decideApproval(tool, callArgs, {
     mode: state.mode,
     autoApprove: config.autoApprove,
@@ -1999,484 +2866,221 @@ async function handleToolCall(call, messages, step, deps) {
     if (answer === "deny") {
       console.log(color.red("   \u21B3 denied") + "\n");
       pushTool(decision.cacheable ? "The user DENIED permission to run this tool. Do not retry it." : `The user DENIED this (${decision.reason}). Do not retry, and do not route around it with run_bash/cat or another tool.`);
-      return;
-    }
-    if (decision.cacheable && answer === "always") {
-      approvedTools.add(call.function.name);
-      void addProjectApproval(call.function.name);
-    }
-  }
-  if (config.traceFile) trace.push({ tool: call.function.name, args: call.function.arguments, step });
-  const isTodo = call.function.name === "update_todos";
-  const isShow = call.function.name === "show";
-  process.stdout.write("  " + renderToolCall(call.function.name, callArgs) + (isTodo || isShow ? "\n" : ""));
-  let result = await runTool(call, signal);
-  if (isShow) {
-    const shown = renderShow(result);
-    if (shown) {
-      process.stdout.write(shown.display);
-      pushTool(shown.note);
-    } else {
-      process.stdout.write("  " + color.red(stripControl(result)) + "\n");
-      pushTool(result);
-    }
-    return;
-  }
-  const summary = summarizeResult(call.function.name, callArgs, result);
-  let verifyOut = "";
-  if (config.verifyCommand && (call.function.name === "write_file" || call.function.name === "edit_file")) {
-    verifyOut = await runVerify(signal);
-    result += `
-
-[auto-check: ${config.verifyCommand}]
-${verifyOut}`;
-  }
-  if (result.length > config.maxToolResultChars) {
-    result = result.slice(0, config.maxToolResultChars) + `
-\u2026[truncated ${result.length - config.maxToolResultChars} chars]`;
-  }
-  if (isTodo) {
-    console.log(color.cyan(stripControl(result).split("\n").map((l) => "  " + l).join("\n")));
-  } else {
-    process.stdout.write(summary + "\n");
-  }
-  if (verifyOut) {
-    const ok = verifyOut.startsWith("passed");
-    console.log("  " + color.dim(`auto-check ${config.verifyCommand}`) + "  " + (ok ? color.green("\u2713 passed") : color.red("\u2717 failed")));
-  }
-  pushTool(result);
-}
-async function runTurn(messages, userInput, ask, approvedTools, signal) {
-  messages.push({ role: "user", content: userInput });
-  const snapshot = messages.slice();
-  try {
-    let answered = false;
-    const callCounts = /* @__PURE__ */ new Map();
-    const deps = { approvedTools, callCounts, ask, signal };
-    for (let step = 0; step < config.maxSteps && !answered && !signal?.aborted; step++) {
-      try {
-        messages = await compactIfNeeded(messages, signal);
-      } catch (err) {
-        console.error(color.red(`
-[compaction failed: ${err.message} \u2014 continuing]`) + "\n");
-      }
-      const message = await callModel(messages, true, signal);
-      messages.push(message);
-      if (!hasContent(message)) {
-        messages.pop();
-        console.log(color.dim("\n[the model returned an empty response \u2014 ending the turn]") + "\n");
-        break;
-      }
-      if (message.tool_calls && message.tool_calls.length > 0) {
-        for (const call of message.tool_calls) {
-          if (signal?.aborted) break;
-          await handleToolCall(call, messages, step, deps);
-        }
-      } else {
-        answered = true;
-      }
-    }
-    if (signal?.aborted) {
-      console.log(color.dim("\n[cancelled]") + "\n");
-      return snapshot;
-    }
-    if (!answered) {
-      console.log(color.dim(`
-[reached the ${config.maxSteps}-step limit \u2014 wrapping up]`));
-      const wrapPrompt = {
-        role: "system",
-        content: `You have reached the ${config.maxSteps}-step limit for this turn. Do not call any more tools. Briefly tell the user what you accomplished and what still remains.`
-      };
-      const wrap = await callModel([...messages, wrapPrompt], false, signal);
-      if (hasContent(wrap)) messages.push(wrap);
-    }
-    return messages;
-  } catch (err) {
-    if (signal?.aborted || err?.name === "AbortError") {
-      console.log(color.dim("\n[cancelled]") + "\n");
-      return snapshot;
-    }
-    console.error(color.red(`
-[error] ${err.message}`) + "\n");
-    return snapshot;
-  }
-}
-
-// src/commands.ts
-import { writeFile as writeFile4, mkdir as mkdir4, chmod as chmod3 } from "node:fs/promises";
-
-// src/skills.ts
-import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
-import { join as join4 } from "node:path";
-import { homedir as homedir5 } from "node:os";
-var registry = /* @__PURE__ */ new Map();
-function skillNames() {
-  return [...registry.keys()];
-}
-function getSkill(name) {
-  return registry.get(name);
-}
-async function loadSkills() {
-  registry.clear();
-  const dirs = [
-    [join4(homedir5(), ".beecork", "skills"), "global"],
-    [join4(process.cwd(), ".beecork", "skills"), "project"]
-  ];
-  for (const [dir, source] of dirs) {
-    let entries;
-    try {
-      entries = await readdir3(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const e of entries) {
-      if (!e.isFile() || !e.name.endsWith(".md")) continue;
-      const name = e.name.slice(0, -3);
-      if (!/^[a-z0-9][a-z0-9_-]*$/i.test(name)) continue;
-      try {
-        const content = (await readFile5(join4(dir, e.name), "utf8")).trim();
-        if (!content) continue;
-        if (source === "project" && registry.has(name)) {
-          console.error(color.yellow(`\u26A0 project skill /${name} ignored \u2014 a global skill of that name takes precedence`));
-          continue;
-        }
-        registry.set(name, { name, content, source });
-      } catch {
-      }
-    }
-  }
-  return [...registry.values()];
-}
-function expandSkill(skill, extra) {
-  return skill.content.includes("$ARGUMENTS") ? skill.content.replaceAll("$ARGUMENTS", extra) : skill.content + (extra ? `
-
-${extra}` : "");
-}
-
-// src/input.ts
-import { emitKeypressEvents } from "node:readline";
-var out = (s) => process.stdout.write(s);
-var active = null;
-var started = false;
-function initInput() {
-  if (started || !process.stdin.isTTY) return;
-  started = true;
-  process.stdin.setRawMode(true);
-  out("\x1B[?2004l");
-  emitKeypressEvents(process.stdin);
-  process.stdin.on("keypress", (str, key) => active?.(str, key));
-}
-function teardownInput() {
-  if (started && process.stdin.isTTY) {
-    out("\x1B[?2004h\x1B[?25h");
-    process.stdin.setRawMode(false);
-    process.stdin.pause();
-  }
-}
-function pushKeyHandler(h) {
-  const prev = active;
-  active = h;
-  return () => {
-    active = prev;
-  };
-}
-var isEnter = (k) => k?.name === "return" || k?.name === "enter";
-var MENU_MAX = 8;
-function readPrompt(opts) {
-  if (!process.stdin.isTTY) return Promise.resolve({ type: "eof" });
-  const history = opts.history ?? [];
-  const all = [
-    ...opts.commands ?? [],
-    ...(opts.skills ?? []).map((n) => ({ name: "/" + n, desc: "skill" }))
-  ];
-  return new Promise((resolve2) => {
-    let buf = "";
-    let cur = 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;
-    const matches = () => {
-      if (opts.mask) return [];
-      const m = buf.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 highlight = () => {
-      if (opts.mask) return "*".repeat(buf.length);
-      const m = buf.match(/^(\/\S*)([\s\S]*)$/);
-      if (!m) return buf;
-      const [, token, rest] = m;
-      const known = all.some((c) => c.name === token);
-      const partial = all.some((c) => c.name.startsWith(token));
-      const styled = known ? color.green(token) : partial ? color.cyan(token) : color.red(token);
-      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;
-      const indent = " ".repeat(promptW);
-      const lines = highlight().split("\n");
-      out(prompt + lines[0]);
-      for (let i = 1; i < lines.length; i++) out("\n" + indent + lines[i]);
-      return { promptW };
-    }
-    function render() {
-      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");
-      const { promptW } = drawBlock();
-      const cols = 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 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");
-      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");
-      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 onKey(str, key) {
-      const mm = menu();
-      burstLen++;
-      if (burstTimer) clearTimeout(burstTimer);
-      burstTimer = setTimeout(() => {
-        burstTimer = null;
-        burstLen = 0;
-        if (pendingRender) {
-          pendingRender = false;
-          render();
-        }
-      }, BURST_IDLE_MS);
-      if (isEnter(key)) {
-        if (key?.shift || key?.meta || burstLen > 1) {
-          insert("\n");
-          return;
-        }
-        return finish({ type: "line", value: buf });
-      }
-      if (key?.ctrl && key.name === "c") {
-        if (buf) {
-          buf = "";
-          cur = 0;
-          render();
-        } else finish({ type: "quit" });
-        return;
-      }
-      if (key?.ctrl && key.name === "d") {
-        if (!buf) finish({ type: "eof" });
-        return;
-      }
-      if (key?.name === "tab" && key.shift) {
-        opts.onShiftTab?.();
-        render();
-        return;
-      }
-      if (key?.name === "tab") {
-        if (mm.length) {
-          buf = mm[sel].name + " ";
-          cur = buf.length;
-          menuHidden = false;
-          render();
-        }
-        return;
-      }
-      if (key?.name === "up") {
-        if (mm.length) {
-          sel = (sel - 1 + mm.length) % mm.length;
-          render();
-        } else if (buf.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);
-        else histNext();
-        return;
-      }
-      if (key?.name === "left") {
-        if (cur > 0) cur--;
-        render();
-        return;
-      }
-      if (key?.name === "right") {
-        if (cur < buf.length) cur++;
-        render();
-        return;
-      }
-      if (key?.name === "home" || key?.ctrl && key.name === "a") {
-        cur = 0;
-        render();
-        return;
-      }
-      if (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;
-        menuHidden = false;
-        render();
-        return;
-      }
-      if (key?.name === "backspace") {
-        if (cur > 0) {
-          buf = buf.slice(0, cur - 1) + buf.slice(cur);
-          cur--;
-          menuHidden = false;
-          render();
-        }
-        return;
+      return;
+    }
+    if (decision.cacheable && answer === "always") {
+      approvedTools.add(call.function.name);
+      void addProjectApproval(call.function.name);
+    }
+  }
+  if (config.traceFile) trace.push({ tool: call.function.name, args: call.function.arguments, step });
+  const isTodo = call.function.name === "update_todos";
+  const isShow = call.function.name === "show";
+  const isExplore = call.function.name === "explore";
+  process.stdout.write("  " + renderToolCall(call.function.name, callArgs) + (isTodo || isShow || isExplore ? "\n" : ""));
+  let result = await runTool(call, signal);
+  if (isShow) {
+    const shown = renderShow(result);
+    if (shown) {
+      process.stdout.write(shown.display);
+      pushTool(shown.note);
+    } else {
+      process.stdout.write("  " + color.red(stripControl(result)) + "\n");
+      pushTool(result);
+    }
+    return;
+  }
+  const summary = summarizeResult(call.function.name, callArgs, result);
+  let verifyOut = "";
+  if (config.verifyCommand && (call.function.name === "write_file" || call.function.name === "edit_file")) {
+    verifyOut = await runVerify(signal);
+    result += `
+
+[auto-check: ${config.verifyCommand}]
+${verifyOut}`;
+  }
+  if (result.length > config.maxToolResultChars) {
+    result = result.slice(0, config.maxToolResultChars) + `
+\u2026[truncated ${result.length - config.maxToolResultChars} chars]`;
+  }
+  if (isTodo) {
+    console.log(color.cyan(stripControl(result).split("\n").map((l) => "  " + l).join("\n")));
+  } else {
+    process.stdout.write(summary + "\n");
+  }
+  if (verifyOut) {
+    const ok = verifyOut.startsWith("passed");
+    console.log("  " + color.dim(`auto-check ${config.verifyCommand}`) + "  " + (ok ? color.green("\u2713 passed") : color.red("\u2717 failed")));
+  }
+  pushTool(result);
+}
+var STEER_PREAMBLE = "[The user sent this while you were working \u2014 treat it as additional guidance and keep going on the current task too, don't discard the work in progress]\n";
+function applySteering(messages, notes) {
+  if (notes.length === 0) return messages;
+  const content = STEER_PREAMBLE + notes.join("\n");
+  const last = messages[messages.length - 1];
+  if (last?.role === "user") {
+    return [...messages.slice(0, -1), { ...last, content: `${last.content ?? ""}
+
+${content}` }];
+  }
+  return [...messages, { role: "user", content }];
+}
+async function runTurn(messages, userInput, ask, approvedTools, signal, steering) {
+  messages.push({ role: "user", content: userInput });
+  const snapshot = messages.slice();
+  try {
+    let answered = false;
+    const callCounts = /* @__PURE__ */ new Map();
+    const deps = { approvedTools, callCounts, ask, signal };
+    for (let step = 0; step < config.maxSteps && !answered && !signal?.aborted; step++) {
+      try {
+        messages = await compactIfNeeded(messages, signal);
+      } catch (err) {
+        console.error(color.red(`
+[compaction failed: ${err.message} \u2014 continuing]`) + "\n");
       }
-      if (key?.name === "delete") {
-        if (cur < buf.length) {
-          buf = buf.slice(0, cur) + buf.slice(cur + 1);
-          menuHidden = false;
-          render();
-        }
-        return;
+      if (steering?.length) messages = applySteering(messages, steering.splice(0));
+      const message = await callModel(messages, true, signal);
+      messages.push(message);
+      if (!hasContent2(message)) {
+        messages.pop();
+        console.log(color.dim("\n[the model returned an empty response \u2014 ending the turn]") + "\n");
+        break;
       }
-      if (key?.name === "escape") {
-        if (mm.length) {
-          menuHidden = true;
-          render();
+      if (message.tool_calls && message.tool_calls.length > 0) {
+        for (const call of message.tool_calls) {
+          if (signal?.aborted) break;
+          await handleToolCall(call, messages, step, deps);
         }
-        return;
-      }
-      if (str && !key?.ctrl && !key?.meta && [...str].length === 1) {
-        if (isPrintableCodePoint(str.codePointAt(0))) insert(str);
+      } else {
+        answered = !steering?.length;
       }
     }
-    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();
+    if (signal?.aborted) {
+      console.log(color.dim("\n[cancelled]") + "\n");
+      return snapshot;
     }
-    function histPrev() {
-      if (history.length === 0) return;
-      hist = Math.max(0, hist - 1);
-      buf = history[hist] ?? "";
-      cur = buf.length;
-      render();
+    if (!answered) {
+      console.log(color.dim(`
+[reached the ${config.maxSteps}-step limit \u2014 wrapping up]`));
+      const wrapPrompt = {
+        role: "system",
+        content: `You have reached the ${config.maxSteps}-step limit for this turn. Do not call any more tools. Briefly tell the user what you accomplished and what still remains.`
+      };
+      const wrap = await callModel([...messages, wrapPrompt], false, signal);
+      if (hasContent2(wrap)) messages.push(wrap);
     }
-    function histNext() {
-      if (hist >= history.length) return;
-      hist += 1;
-      buf = hist === history.length ? "" : history[hist];
-      cur = buf.length;
-      render();
+    return messages;
+  } catch (err) {
+    if (signal?.aborted || err?.name === "AbortError") {
+      console.log(color.dim("\n[cancelled]") + "\n");
+      return snapshot;
     }
-    const restore = pushKeyHandler(onKey);
-    render();
-  });
+    console.error(color.red(`
+[error] ${err.message}`) + "\n");
+    return snapshot;
+  }
 }
-function readChoice(prompt) {
-  if (!process.stdin.isTTY) return Promise.resolve("n");
+
+// src/env.ts
+import { execFile } from "node:child_process";
+import { platform, arch } from "node:os";
+function tryExec(cmd, args, timeout = 2e3) {
   return new Promise((resolve2) => {
-    out(prompt);
-    const restore = pushKeyHandler((str, key) => {
-      let ch;
-      if (key?.ctrl && key.name === "c" || key?.name === "escape" || isEnter(key)) ch = "n";
-      else if (str && /^[yna]$/i.test(str)) ch = str.toLowerCase();
-      else return;
-      restore();
-      out(ch + "\n");
-      resolve2(ch);
-    });
+    try {
+      execFile(cmd, args, { timeout, windowsHide: true }, (err, stdout) => resolve2(err ? null : String(stdout).trim()));
+    } catch {
+      resolve2(null);
+    }
   });
 }
-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 drawn = 0;
-    function render() {
-      out("\x1B[?25l");
-      if (drawn > 0) out(`\x1B[${drawn}A`);
-      out("\r\x1B[J");
-      out(color.dim(opts.title) + "\n");
-      opts.items.forEach((it, i) => {
-        const row = i === sel ? color.green("\u203A " + it.label) : "  " + it.label;
-        out(row + (it.hint ? color.dim("  " + it.hint) : "") + "\n");
-      });
-      drawn = opts.items.length + 1;
+async function gitStatus() {
+  const branch = await tryExec("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+  if (branch === null) return "not a git repo";
+  const porcelain = await tryExec("git", ["status", "--porcelain"]);
+  if (porcelain === null) return `branch ${branch}`;
+  const dirty = porcelain ? porcelain.split("\n").filter(Boolean).length : 0;
+  return `branch ${branch} (${dirty ? `${dirty} uncommitted change${dirty === 1 ? "" : "s"}` : "clean"})`;
+}
+function formatRuntimeContext(f) {
+  return [
+    "# Environment",
+    `- Date: ${f.date}`,
+    `- Working directory: ${f.cwd}`,
+    `- Platform: ${f.platform}`,
+    `- Node: ${f.node}`,
+    `- Git: ${f.git}`,
+    `- ripgrep (rg): ${f.ripgrep ? "available" : "not installed"}`
+  ].join("\n");
+}
+async function runtimeContext() {
+  const [git, rg] = await Promise.all([gitStatus(), tryExec("rg", ["--version"])]);
+  return formatRuntimeContext({
+    date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    cwd: process.cwd(),
+    platform: `${platform()} ${arch()}`,
+    node: process.version,
+    git,
+    ripgrep: rg !== null
+  });
+}
+
+// src/commands.ts
+import { writeFile as writeFile4, mkdir as mkdir4, chmod as chmod3 } from "node:fs/promises";
+
+// src/skills.ts
+import { readdir as readdir3, readFile as readFile5 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+var registry = /* @__PURE__ */ new Map();
+function skillNames() {
+  return [...registry.keys()];
+}
+function getSkill(name) {
+  return registry.get(name);
+}
+async function loadSkills() {
+  registry.clear();
+  const dirs = [
+    [join4(homedir5(), ".beecork", "skills"), "global"],
+    [join4(process.cwd(), ".beecork", "skills"), "project"]
+  ];
+  for (const [dir, source] of dirs) {
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch {
+      continue;
     }
-    function finish(v) {
-      restore();
-      if (drawn > 0) out(`\x1B[${drawn}A\r\x1B[J`);
-      out("\x1B[?25h");
-      resolve2(v);
+    for (const e of entries) {
+      if (!e.isFile() || !e.name.endsWith(".md")) continue;
+      const name = e.name.slice(0, -3);
+      if (!/^[a-z0-9][a-z0-9_-]*$/i.test(name)) continue;
+      try {
+        const content = (await readFile5(join4(dir, e.name), "utf8")).trim();
+        if (!content) continue;
+        if (source === "project" && registry.has(name)) {
+          console.error(color.yellow(`\u26A0 project skill /${name} ignored \u2014 a global skill of that name takes precedence`));
+          continue;
+        }
+        registry.set(name, { name, content, source });
+      } catch {
+      }
     }
-    const restore = pushKeyHandler((_str, key) => {
-      if (key?.name === "up") {
-        sel = (sel - 1 + opts.items.length) % opts.items.length;
-        render();
-      } else if (key?.name === "down") {
-        sel = (sel + 1) % opts.items.length;
-        render();
-      } else if (isEnter(key)) finish(opts.items[sel].value);
-      else if (key?.name === "escape" || key?.name === "q" || key?.ctrl && key.name === "c") finish(null);
-    });
-    render();
-  });
+  }
+  return [...registry.values()];
+}
+function expandSkill(skill, extra) {
+  return skill.content.includes("$ARGUMENTS") ? skill.content.replaceAll("$ARGUMENTS", extra) : skill.content + (extra ? `
+
+${extra}` : "");
 }
 
 // src/commands.ts
 var SLASH_COMMANDS = [
   { name: "/model", desc: "switch model (menu; /model <term> searches)" },
+  { name: "/effort", desc: "set reasoning effort (off/low/medium/high/max)" },
   { name: "/context", desc: "conversation size in tokens" },
   { name: "/clear", desc: "clear the conversation" },
   { name: "/key", desc: "set + save your OpenRouter API key" },
@@ -2492,6 +3096,10 @@ function applyModel(slug) {
   void saveModelPreference(slug);
   return slug;
 }
+function applyEffort(level) {
+  state.reasoningEffort = level;
+  void saveReasoningPreference(level);
+}
 function ago(ms) {
   const s = Math.floor((Date.now() - ms) / 1e3);
   if (!ms || s < 0) return "unknown";
@@ -2520,6 +3128,16 @@ async function handleCommand(input, messages) {
     } else {
       await searchModels(arg);
     }
+  } else if (cmd === "/effort") {
+    if (!arg) await pickEffort();
+    else {
+      const level = normalizeEffort(arg);
+      if (!level) console.log(color.red(`unknown effort "${arg}" \u2014 use: ${EFFORTS.join(" / ")}`) + "\n");
+      else {
+        applyEffort(level);
+        console.log(color.green(`reasoning effort: ${level}`) + (level === "off" ? color.dim(" (thinking disabled)") : "") + "\n");
+      }
+    }
   } else if (cmd === "/key") {
     if (!arg) {
       console.log(color.dim("usage: /key <your-openrouter-key>  (saved to ~/.beecork/config.json)") + "\n");
@@ -2614,6 +3232,32 @@ async function pickModel() {
   });
   if (choice) console.log(color.green(`switched to: ${applyModel(choice)}`) + "\n");
 }
+var EFFORT_NOTES = {
+  off: "no thinking \u2014 fastest, cheapest",
+  low: "a light nudge to think first",
+  medium: "balanced (default)",
+  high: "deeper reasoning, more tokens",
+  max: "maximum reasoning depth"
+};
+async function pickEffort() {
+  if (!process.stdin.isTTY) {
+    console.log(color.cyan(`reasoning effort: ${state.reasoningEffort}`) + color.dim(`  (levels: ${EFFORTS.join(" / ")})`) + "\n");
+    return;
+  }
+  const choice = await selectMenu({
+    title: "reasoning effort \u2014 \u2191/\u2193 then Enter (Esc to cancel)",
+    initial: Math.max(0, EFFORTS.indexOf(state.reasoningEffort)),
+    items: EFFORTS.map((e) => ({
+      label: (e === state.reasoningEffort ? "\u25CF " : "  ") + e,
+      value: e,
+      hint: EFFORT_NOTES[e]
+    }))
+  });
+  if (choice) {
+    applyEffort(choice);
+    console.log(color.green(`reasoning effort: ${choice}`) + (choice === "off" ? color.dim(" (thinking disabled)") : "") + "\n");
+  }
+}
 function showRecommended() {
   console.log(color.cyan("recommended models (all support tools):") + "\n");
   for (const m of RECOMMENDED_MODELS) {
@@ -2664,6 +3308,11 @@ function completer(line) {
     const hits = all.filter((c) => c.startsWith(line));
     return [hits.length ? hits : all, line];
   }
+  if (line.startsWith("/effort ")) {
+    const all = EFFORTS.map((e) => `/effort ${e}`);
+    const hits = all.filter((c) => c.startsWith(line));
+    return [hits.length ? hits : all, line];
+  }
   if (line.startsWith("/")) {
     const all = [...COMMANDS, ...skillNames().map((n) => "/" + n)];
     const hits = all.filter((c) => c.startsWith(line));
@@ -2685,7 +3334,7 @@ async function main() {
     }
     return;
   }
-  const [userCfg, instr, settings, skills, projectApprovals] = await Promise.all([
+  const [userCfg, instr, settings, skills, projectApprovals, runtimeCtx] = await Promise.all([
     loadUserConfig(),
     // ~/.beecork/config.json (API keys)
     loadInstructions(),
@@ -2694,14 +3343,19 @@ async function main() {
     // settings.json (model pref + global alwaysAllow)
     loadSkills(),
     // user-defined slash commands from .beecork/skills/
-    loadProjectApprovals()
+    loadProjectApprovals(),
     // per-project "always" from past sessions
+    runtimeContext()
+    // real environment facts (date, git state, tool availability)
   ]);
   const savedKey = String(userCfg.OPENROUTER_API_KEY ?? "");
   let apiKey = API_KEY || savedKey;
   state.braveKey = process.env.BRAVE_API_KEY || String(userCfg.BRAVE_API_KEY ?? "");
   if (settings.model && !process.env.OPENROUTER_MODEL) state.model = settings.model;
-  let systemContent = SYSTEM_PROMPT;
+  if (settings.reasoningEffort && !process.env.REASONING_EFFORT) state.reasoningEffort = settings.reasoningEffort;
+  let systemContent = `${SYSTEM_PROMPT}
+
+${runtimeCtx}`;
   if (instr.trusted) {
     systemContent += `
 
@@ -2732,6 +3386,7 @@ ${instr.trusted}`;
     }
   };
   const tty = !!process.stdin.isTTY;
+  process.on("exit", killAllTasks);
   if (tty) {
     initInput();
     process.on("exit", teardownInput);
@@ -2838,21 +3493,56 @@ ${instr.trusted}`;
     }
     activeTurn = new AbortController();
     let modeChangedMidTurn = false;
-    const restoreKeys = tty ? pushKeyHandler((_s, key) => {
-      if (!key) return;
-      if (key.name === "escape" || key.ctrl && key.name === "c") activeTurn?.abort();
-      else if (key.name === "tab" && key.shift) {
+    const steering = [];
+    let typed = "";
+    const redrawSteer = () => process.stdout.write("\r\x1B[2K" + color.cyan("\xBB ") + color.dim(typed));
+    const clearSteer = () => {
+      process.stdout.write("\r\x1B[2K");
+      setSteeringActive(false);
+    };
+    const restoreKeys = tty ? pushKeyHandler((str, key) => {
+      if (key && (key.name === "escape" || key.ctrl && key.name === "c")) {
+        activeTurn?.abort();
+        return;
+      }
+      if (key && key.name === "tab" && key.shift) {
         state.mode = nextMode(state.mode);
         modeChangedMidTurn = true;
+        return;
+      }
+      if (key && (key.name === "return" || key.name === "enter")) {
+        const note = typed.trim();
+        typed = "";
+        clearSteer();
+        if (note) {
+          steering.push(note);
+          console.log(color.dim(`\xBB queued for next step: ${note}`));
+        }
+        return;
+      }
+      if (key && (key.name === "backspace" || key.name === "delete")) {
+        if (typed) {
+          typed = typed.slice(0, -1);
+          typed ? redrawSteer() : clearSteer();
+        }
+        return;
+      }
+      if (str && !key?.ctrl && !key?.meta && [...str].length === 1 && isPrintableCodePoint(str.codePointAt(0))) {
+        typed += str;
+        setSteeringActive(true);
+        redrawSteer();
       }
     }) : () => {
     };
     try {
-      messages = await runTurn(messages, userInput, ask, approvedTools, activeTurn.signal);
+      messages = await runTurn(messages, userInput, ask, approvedTools, activeTurn.signal, steering);
     } finally {
       restoreKeys();
+      setSteeringActive(false);
       activeTurn = null;
       if (modeChangedMidTurn) console.log(color.yellow(`\u25B8 mode: ${modeLabel(state.mode)}`));
+      const bg = runningTaskCount();
+      if (bg > 0) console.log(color.dim(`\u25B8 ${bg} background task${bg === 1 ? "" : "s"} running \u2014 check_task / stop_task`));
     }
   }
   teardownInput();