@botconnector/bccli 0.5.0-rc.4 → 0.5.1

package/dist/ui-TAZMRXRI.js

@@ -0,0 +1,3044 @@
+#!/usr/bin/env node
+import {
+  CATALOG,
+  fillTemplate
+} from "./chunk-6PJRWKVI.js";
+import {
+  MAX_VERIFY_ROUNDS,
+  runVerify,
+  toolLabel,
+  verifyFollowup,
+  worktreeListText
+} from "./chunk-5CVHTYBQ.js";
+import {
+  BUILTIN_AGENTS,
+  appendMemory,
+  ignorePatterns,
+  instructionFiles,
+  normalizeGlobPath,
+  parseFrontmatter,
+  parseMemoryArgs,
+  recordFileMtime,
+  renderBackgroundTasks,
+  resolveShell,
+  runCommand,
+  runHooks,
+  validateGlobPattern
+} from "./chunk-7U7CMKKI.js";
+import "./chunk-PSO7R5AD.js";
+import {
+  nextMode,
+  requiresSensitiveToolApproval
+} from "./chunk-YYTFJUO2.js";
+import {
+  hasKey,
+  providerName,
+  writeGlobalConfig
+} from "./chunk-FY543EQW.js";
+import {
+  Session
+} from "./chunk-6LO6YRDY.js";
+import {
+  contentText
+} from "./chunk-OCEQ2TRJ.js";
+import {
+  REASONING_LEVELS,
+  assertReasoningSupported,
+  parseReasoningLevel,
+  supportedReasoningLevels
+} from "./chunk-NGFWBVHD.js";
+import {
+  addGlobalServer,
+  globalMcpPath,
+  readMcpFile,
+  removeGlobalServer
+} from "./chunk-VPFCIUC6.js";
+import {
+  ACCENT,
+  PRESETS,
+  color,
+  matchKeybind,
+  removeCredential
+} from "./chunk-ZXWRLN7E.js";
+import {
+  getLanguage,
+  locale,
+  parseLang,
+  setLanguage,
+  t
+} from "./chunk-IDZLHEVL.js";
+
+// src/ui/index.tsx
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { execFile as execFile3 } from "child_process";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { dirname, join as join3, relative as relative2, resolve as resolve2 } from "path";
+import { Box as Box13, Static, Text as Text16, measureElement, useApp, useInput as useInput9, useStdin, useStdout as useStdout2 } from "ink";
+import { useCallback, useEffect as useEffect3, useRef as useRef2, useState as useState10 } from "react";
+
+// src/commands.ts
+var SLASH_COMMANDS = [
+  { name: "help", description: "list of commands and shortcuts" },
+  { name: "thinking", description: "show/hide the model\u2019s thinking" },
+  { name: "model", description: "change model" },
+  { name: "reasoning", description: "set reasoning: auto/off/low/medium/high/max" },
+  { name: "provider", description: "add/choose an AI provider" },
+  { name: "mcp", description: "install/manage MCP servers" },
+  { name: "new", description: "new session (the old one stays saved)" },
+  { name: "resume", description: "continue another session in this folder" },
+  { name: "session", description: "info about this session" },
+  { name: "status", description: "version, model, permission mode, MCP, context" },
+  { name: "permissions", description: "view/revoke permissions" },
+  { name: "undo", description: "undo the file edits of the last turn" },
+  { name: "redo", description: "re-apply the file edits that /undo just reverted" },
+  { name: "rewind", description: "step back turns: conversation and file edits (/rewind 2)" },
+  { name: "diff", description: "git diff of the project" },
+  { name: "worktree", description: "list git worktrees; create one with bccli -w <name>" },
+  { name: "pr", description: "review a pull request (/pr <n|url|branch>)" },
+  { name: "copy", description: "copy the last answer" },
+  { name: "export", description: "save the conversation as markdown" },
+  { name: "memory", description: "project instructions (/memory <text>, /memory global <text>)" },
+  { name: "init", description: "create/update AGENTS.md for this project" },
+  { name: "agents", description: "list subagents" },
+  { name: "skills", description: "list skills and custom commands" },
+  { name: "doctor", description: "check installation health" },
+  { name: "login", description: "save the API key of the current provider" },
+  { name: "logout", description: "delete the API key of the current provider" },
+  { name: "language", description: "set the interface language: en/id" },
+  { name: "clear", description: "start a new conversation" },
+  { name: "compact", description: "summarize the conversation" },
+  { name: "cost", description: "token usage of this session" },
+  { name: "config", description: "view or change configuration settings" },
+  { name: "tasks", description: "list background tasks" },
+  { name: "exit", description: "quit" }
+];
+function parseSlash(text) {
+  if (!text.startsWith("/")) return void 0;
+  const [name, ...rest] = text.slice(1).trim().split(/\s+/);
+  return { name: name.toLowerCase(), args: rest.join(" ") };
+}
+function expandCommand(def, args) {
+  if (def.body.includes("$ARGUMENTS")) return def.body.replaceAll("$ARGUMENTS", args);
+  return args ? `${def.body}
+
+${args}` : def.body;
+}
+function prReviewPrompt(selector) {
+  const target = selector.trim();
+  const refs = target ? `Use "${target}" as the PR selector: run gh pr view ${target} --json url,title,body,baseRefName,headRefName,files,additions,deletions and gh pr diff ${target}.` : "Start with `gh pr view --json url,title,baseRefName,headRefName` for the PR of the current branch, then fetch the change with `gh pr diff`. If the branch has no open PR, review its changes against the default branch instead: find the default branch (`gh repo view --json defaultBranchRef` or `git remote show origin`), then `git diff origin/<default-branch>...HEAD`.";
+  return `Review this pull request like a senior reviewer.
+${refs}
+Read the changed files in the repository when the diff alone is not enough to judge the change.
+Never change the repository state while reviewing: do not check out, switch, create, delete, merge or rebase branches, do not reset, stash, commit, pull, or fetch into the working tree, and do not write, edit or delete any file. The review is strictly read-only. To read a file as it exists in another revision, use read-only commands such as \`git show <ref>:<path>\` or \`gh pr diff\`.
+Write the review as: a 2-3 sentence summary; concrete problems (bugs, security, race conditions, error handling), each with file:line and why it matters; missing or weak tests; smaller style/nit issues; then a final verdict \u2014 approve, request changes, or comment \u2014 with the single most important reason.`;
+}
+
+// src/slash/copy.ts
+function osc52(text, inTmux) {
+  const seq = `\x1B]52;c;${Buffer.from(text).toString("base64")}\x07`;
+  return inTmux ? `\x1BPtmux;${seq.replaceAll("\x1B", "\x1B\x1B")}\x1B\\` : seq;
+}
+
+// src/slash/diff.ts
+import { execFile } from "child_process";
+function git(cwd, args, bin = "git") {
+  return new Promise((resolve3) => {
+    execFile(
+      bin,
+      args,
+      { cwd, maxBuffer: 20 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve3({ ok: !error, out: error ? stderr : stdout, missing: error?.code === "ENOENT" })
+    );
+  });
+}
+async function gitDiff(cwd, maxLines = 400, bin = "git") {
+  const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], bin);
+  if (inside.missing) return t("git is not installed or not on PATH, so /diff cannot be used.");
+  if (!inside.ok || inside.out.trim() !== "true") return t("This folder is not a git repository, so there is no diff.");
+  const base = (await git(cwd, ["rev-parse", "--verify", "-q", "HEAD"])).ok ? "HEAD" : "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+  const [stat, diff, untracked] = await Promise.all([
+    git(cwd, ["diff", "--stat", base]),
+    git(cwd, ["diff", base]),
+    git(cwd, ["ls-files", "--others", "--exclude-standard"])
+  ]);
+  const fresh = untracked.out.split("\n").filter(Boolean);
+  if (!diff.out.trim() && !fresh.length) return t("No uncommitted changes.");
+  const lines = diff.out.trimEnd().split("\n");
+  const more = lines.length > maxLines ? `
+${t("\u2026 {n} more lines", { n: lines.length - maxLines })}` : "";
+  return [stat.out.trim(), lines.slice(0, maxLines).join("\n") + more, fresh.length ? t("New files (untracked): {files}", { files: fresh.join(", ") }) : ""].filter(Boolean).join("\n\n");
+}
+
+// src/slash/doctor.ts
+async function doctorText(input, deps) {
+  const major = Number(deps.nodeVersion.replace(/^v/, "").split(".")[0]);
+  const lines = [major >= 22 ? `\u2713 Node ${deps.nodeVersion}` : t("\u2717 Node {version} (needs \u2265 22)", { version: deps.nodeVersion })];
+  for (const p of input.providers) lines.push(p.ready ? `\u2713 ${p.name}` : t("\u25CB {name} (no key yet)", { name: p.name }));
+  const cmds = ["rg", "git", "npx", "uvx"];
+  const [connection, found] = await Promise.all([
+    deps.listModels().then(
+      (models) => t("\u2713 Connection {provider} ({n} models)", { provider: input.activeProvider, n: models.length }),
+      (error) => t("\u2717 Connection {provider}: {error}", { provider: input.activeProvider, error: error.message })
+    ),
+    Promise.all(cmds.map(async (cmd) => deps.which(cmd)))
+  ]);
+  lines.push(connection);
+  for (const m of input.mcp) lines.push(m.status === "error" ? `\u2717 MCP ${m.name}: ${m.error ?? ""}` : `\u2713 MCP ${m.name} (${m.status})`);
+  for (const [i, cmd] of cmds.entries()) lines.push(`${found[i] ? "\u2713" : "\u2717"} ${cmd}`);
+  return lines.join("\n");
+}
+
+// src/slash/export.ts
+function exportMarkdown(messages, title) {
+  const parts = [`# ${title}`, ""];
+  for (const m of messages) {
+    if (m.role === "user") parts.push("## User", "", contentText(m.content), "");
+    else if (m.role === "assistant") {
+      for (const c of m.tool_calls ?? []) parts.push(`\u23BF ${c.function.name} ${c.function.arguments.slice(0, 200)}`, "");
+      if (m.content) parts.push("## BCCLI", "", m.content, "");
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/slash/info.ts
+var k = (n) => n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+function statusText(s) {
+  const ready = s.mcp.filter((m) => m.status === "ready").length;
+  const errors = s.mcp.filter((m) => m.status === "error").length;
+  const win = s.contextWindow && s.contextWindow > 0 ? s.contextWindow : 128e3;
+  const ctxLine = t("Context: ~{pct}% of 128k", { pct: Math.round(s.lastInputTokens / win * 100) }).replace("128k", k(win));
+  return [
+    `BCCLI ${s.version}`,
+    `Model: ${s.modelRef} (${s.providerLabel})`,
+    t("Permission mode: {mode}", { mode: s.mode }),
+    t("Folder: {cwd}", { cwd: s.cwd }),
+    t("MCP: {ready} active, {errors} errors", { ready, errors }),
+    t("Session tokens: {input} in \xB7 {output} out", { input: k(s.usage.inputTokens), output: k(s.usage.outputTokens) }),
+    `Cache: ${k(s.usage.cachedInputTokens ?? 0)} read \xB7 ${k(s.usage.cacheWriteTokens ?? 0)} write`,
+    ctxLine
+  ].join("\n");
+}
+function agentsText(defs) {
+  return defs.map((d) => t("{name} \u2014 {description} \xB7 tools: {tools} \xB7 model: {model}", { name: d.name, description: d.description, tools: d.tools ? d.tools.join(", ") : t("all"), model: d.model ?? t("same as main") })).join("\n");
+}
+function skillsText(skills, commands) {
+  const s = skills.length ? skills.map((x) => `${x.name} \u2014 ${x.description.slice(0, 80)} (${x.dir})`).join("\n") : t("(no skills)");
+  const c = commands.length ? commands.map((x) => `/${x.name} \u2014 ${x.description ?? ""}`).join("\n") : t("(no custom commands)");
+  return `${t("Skills")}:
+${s}
+
+${t("Custom commands")}:
+${c}`;
+}
+function sessionText(s) {
+  return [
+    t("Started: {when}", { when: s.started.toLocaleString(locale()) }),
+    t("{messages} messages \xB7 {input} tokens in \xB7 {output} out", { messages: s.messages, input: k(s.usage.inputTokens), output: k(s.usage.outputTokens) }),
+    `Model: ${s.modelRef}`,
+    t("File: {file}", { file: s.file })
+  ].join("\n");
+}
+
+// src/ui/Markdown.tsx
+import { Box, Text, useStdout } from "ink";
+
+// src/ui/table.ts
+var WIDE = [
+  [4352, 4447],
+  [8986, 8987],
+  [9193, 9196],
+  [9200, 9200],
+  [9203, 9203],
+  [9725, 9726],
+  [9748, 9749],
+  [9800, 9811],
+  [9855, 9855],
+  [9875, 9875],
+  [9889, 9889],
+  [9898, 9899],
+  [9917, 9918],
+  [9924, 9925],
+  [9934, 9934],
+  [9940, 9940],
+  [9962, 9962],
+  [9970, 9971],
+  [9973, 9973],
+  [9978, 9978],
+  [9981, 9981],
+  [9989, 9989],
+  [9994, 9995],
+  [10024, 10024],
+  [10060, 10060],
+  [10062, 10062],
+  [10067, 10069],
+  [10071, 10071],
+  [10133, 10135],
+  [10160, 10160],
+  [10175, 10175],
+  [11035, 11036],
+  [11088, 11088],
+  [11093, 11093],
+  [11904, 42191],
+  [44032, 55203],
+  [63744, 64255],
+  [65072, 65135],
+  [65280, 65376],
+  [65504, 65510],
+  [127744, 128591],
+  [128640, 128767],
+  [129280, 129791],
+  [131072, 262141]
+];
+var ZERO = [
+  [768, 879],
+  [6832, 6911],
+  [7616, 7679],
+  [8203, 8207],
+  [8400, 8447],
+  [65024, 65039],
+  [65279, 65279],
+  [917760, 917999]
+];
+var inRanges = (cp, ranges) => ranges.some(([a, b]) => cp >= a && cp <= b);
+function charWidth(cp) {
+  if (cp < 32 || cp >= 127 && cp < 160) return 0;
+  if (cp < 768) return 1;
+  if (inRanges(cp, ZERO)) return 0;
+  return inRanges(cp, WIDE) ? 2 : 1;
+}
+function displayWidth(text) {
+  let width = 0;
+  for (const ch of text) width += charWidth(ch.codePointAt(0));
+  return width;
+}
+var segsWidth = (segs) => segs.reduce((sum, s) => sum + displayWidth(s.text), 0);
+var INLINE = /(`[^`]+`|\*\*[^*]+\*\*|~~[^~]+~~|!?\[[^\]\n]+\]\([^)\s]+\)|(?<![\w*])\*(?![\s*])[^*\n]+?(?<![\s*])\*(?![\w*])|(?<!\w)_(?![\s_])[^_\n]+?(?<![\s_])_(?!\w))/g;
+function parseInline(text) {
+  const segs = [];
+  for (const part of text.split(INLINE)) {
+    if (part === "") continue;
+    if (part.length > 2 && part.startsWith("`") && part.endsWith("`")) segs.push({ text: part.slice(1, -1), style: "code" });
+    else if (part.length > 4 && part.startsWith("**") && part.endsWith("**")) segs.push({ text: part.slice(2, -2), style: "bold" });
+    else if (part.length > 4 && part.startsWith("~~") && part.endsWith("~~")) segs.push({ text: part.slice(2, -2), style: "strike" });
+    else if (/^!?\[[^\]\n]+\]\([^)\s]+\)$/.test(part)) {
+      const m = /^(!?)\[([^\]]+)\]\(([^)\s]+)\)$/.exec(part);
+      const [, image, label, url] = m;
+      segs.push({ text: label, style: image ? "plain" : "link" });
+      if (label !== url && !url.startsWith("#")) segs.push({ text: ` (${url})`, style: "dim" });
+    } else if (part.length > 2 && (part.startsWith("*") && part.endsWith("*") || part.startsWith("_") && part.endsWith("_"))) {
+      segs.push({ text: part.slice(1, -1), style: "italic" });
+    } else segs.push({ text: part, style: "plain" });
+  }
+  return segs;
+}
+function splitRow(line) {
+  let s = line.trim();
+  if (s.startsWith("|")) s = s.slice(1);
+  if (s.endsWith("|") && !s.endsWith("\\|")) s = s.slice(0, -1);
+  const cells = [];
+  let current = "";
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\\" && s[i + 1] === "|") {
+      current += "|";
+      i++;
+    } else if (s[i] === "|") {
+      cells.push(current);
+      current = "";
+    } else current += s[i];
+  }
+  cells.push(current);
+  return cells.map((c) => c.trim());
+}
+var SEPARATOR = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+var isSeparator = (line) => line.includes("|") && SEPARATOR.test(line);
+var cell = (raw) => parseInline(raw.replace(/<br\s*\/?>/gi, "\n"));
+function parseTable(lines, start) {
+  if (start + 1 >= lines.length || !lines[start].includes("|") || !isSeparator(lines[start + 1])) return void 0;
+  const header = splitRow(lines[start]);
+  const sep = splitRow(lines[start + 1]);
+  if (sep.length !== header.length) return void 0;
+  const body = [];
+  let end = start + 2;
+  while (end < lines.length && lines[end].trim() && lines[end].includes("|")) body.push(splitRow(lines[end++]));
+  const columns = Math.max(header.length, ...body.map((r) => r.length));
+  const pad2 = (row, fill) => [...row, ...Array.from({ length: columns - row.length }, () => fill)];
+  const align = pad2(
+    sep.map((s) => s.startsWith(":") && s.endsWith(":") ? "center" : s.endsWith(":") ? "right" : "left"),
+    "left"
+  );
+  return { table: { header: pad2(header, "").map(cell), align, rows: body.map((r) => pad2(r, "").map(cell)) }, end };
+}
+function tokenize(segs) {
+  const tokens = [];
+  let word = [];
+  const endWord = () => {
+    if (word.length) tokens.push(word);
+    word = [];
+  };
+  for (const seg of segs) {
+    for (const piece of seg.text.match(/\n|[^\S\n]+|[^\s]+/g) ?? []) {
+      if (piece === "\n") {
+        endWord();
+        tokens.push("br");
+      } else if (/^\s+$/.test(piece)) endWord();
+      else word.push({ text: piece, style: seg.style });
+    }
+  }
+  endWord();
+  return tokens;
+}
+function splitWord(word, width) {
+  const pieces = [];
+  let current = [];
+  let used = 0;
+  for (const seg of word) {
+    let text = "";
+    for (const ch of seg.text) {
+      const w = charWidth(ch.codePointAt(0));
+      if (used + w > width && used > 0) {
+        if (text) current.push({ text, style: seg.style });
+        pieces.push(current);
+        current = [];
+        text = "";
+        used = 0;
+      }
+      text += ch;
+      used += w;
+    }
+    if (text) current.push({ text, style: seg.style });
+  }
+  if (current.length) pieces.push(current);
+  return pieces;
+}
+function wrap(tokens, width) {
+  const lines = [];
+  let line = [];
+  let used = 0;
+  const flush = () => {
+    lines.push(line);
+    line = [];
+    used = 0;
+  };
+  for (const token of tokens) {
+    if (token === "br") {
+      flush();
+      continue;
+    }
+    const w = segsWidth(token);
+    if (w > width) {
+      if (used > 0) flush();
+      const pieces = splitWord(token, width);
+      for (const piece of pieces.slice(0, -1)) {
+        line = piece;
+        flush();
+      }
+      line = pieces.at(-1) ?? [];
+      used = segsWidth(line);
+    } else if (used === 0) {
+      line = [...token];
+      used = w;
+    } else if (used + 1 + w <= width) {
+      line.push({ text: " ", style: "plain" }, ...token);
+      used += 1 + w;
+    } else {
+      flush();
+      line = [...token];
+      used = w;
+    }
+  }
+  flush();
+  return lines;
+}
+var SEP = " \u2502 ";
+var RULE_JOIN = "\u2500\u253C\u2500";
+var MAX_MIN_WIDTH = 12;
+var dim = (text) => ({ text, style: "dim" });
+function rtrim(line) {
+  const out = [...line];
+  while (out.length) {
+    const last = out[out.length - 1];
+    const text = last.text.trimEnd();
+    if (text) {
+      out[out.length - 1] = { ...last, text };
+      break;
+    }
+    out.pop();
+  }
+  return out;
+}
+var bold = (segs) => segs.map((s) => s.style === "plain" ? { ...s, style: "bold" } : s);
+function pad(segs, width, align, last) {
+  const space = Math.max(0, width - segsWidth(segs));
+  const left = align === "right" ? space : align === "center" ? Math.floor(space / 2) : 0;
+  const right = last ? 0 : space - left;
+  return [...left ? [{ text: " ".repeat(left), style: "plain" }] : [], ...segs, ...right ? [{ text: " ".repeat(right), style: "plain" }] : []];
+}
+function columnWidths(table, available) {
+  const columns = table.align.length;
+  const all = [table.header, ...table.rows];
+  const natural = [];
+  const minimum = [];
+  for (let c = 0; c < columns; c++) {
+    let widest = 1;
+    let longestWord = 1;
+    for (const row of all) {
+      const tokens = tokenize(row[c]);
+      for (const line of wrap(tokens, Number.POSITIVE_INFINITY)) widest = Math.max(widest, segsWidth(line));
+      for (const token of tokens) if (token !== "br") longestWord = Math.max(longestWord, segsWidth(token));
+    }
+    natural.push(widest);
+    minimum.push(Math.min(longestWord, MAX_MIN_WIDTH, widest));
+  }
+  if (minimum.reduce((a, b) => a + b, 0) > available) return void 0;
+  const widths = [...natural];
+  let total = widths.reduce((a, b) => a + b, 0);
+  while (total > available) {
+    let pick = -1;
+    for (let c = 0; c < columns; c++) if (widths[c] > minimum[c] && (pick < 0 || widths[c] > widths[pick])) pick = c;
+    if (pick < 0) return void 0;
+    widths[pick]--;
+    total--;
+  }
+  return widths;
+}
+function stacked(table, width) {
+  const lines = [];
+  table.rows.forEach((row, r) => {
+    if (r > 0) lines.push([dim("\u2500".repeat(Math.min(width, 40)))]);
+    row.forEach((value, c) => {
+      const label = [...bold(table.header[c]), { text: ": ", style: "plain" }, ...value];
+      lines.push(...wrap(tokenize(label), width));
+    });
+  });
+  return lines.length ? lines : [bold(table.header.flat())];
+}
+function layoutTable(table, width) {
+  const columns = table.align.length;
+  const available = Math.max(columns, width - (columns - 1) * SEP.length);
+  const widths = columnWidths(table, available);
+  if (!widths) return stacked(table, Math.max(10, width));
+  const renderRow = (cells, header) => {
+    const wrapped = cells.map((segs, c) => wrap(tokenize(header ? bold(segs) : segs), widths[c]));
+    const height = Math.max(...wrapped.map((w) => w.length));
+    const lines = [];
+    for (let l = 0; l < height; l++) {
+      const line = [];
+      wrapped.forEach((w, c) => {
+        if (c > 0) line.push(dim(SEP));
+        line.push(...pad(w[l] ?? [], widths[c], table.align[c], c === columns - 1));
+      });
+      lines.push(rtrim(line));
+    }
+    return { lines, height };
+  };
+  const rule = [dim(widths.map((w) => "\u2500".repeat(w)).join(RULE_JOIN))];
+  const head = renderRow(table.header, true);
+  const body = table.rows.map((r) => renderRow(r, false));
+  const wrappedRows2 = body.some((b) => b.height > 1);
+  const out = [...head.lines, rule];
+  body.forEach((b, i) => {
+    if (wrappedRows2 && i > 0) out.push(rule);
+    out.push(...b.lines);
+  });
+  return out;
+}
+
+// src/ui/markdownLayout.ts
+var HEADING = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/;
+var RULE = /^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/;
+var QUOTE = /^\s{0,3}((?:>\s?)+)(.*)$/;
+var BULLET = /^(\s*)[-*+]\s+(.*)$/;
+var NUMBERED = /^(\s*)(\d{1,9})[.)]\s+(.*)$/;
+var BULLETS = ["\u2022", "\u25E6", "\u25AA"];
+var bulletFor = (spaces) => BULLETS[spaces === 0 ? 0 : spaces <= 4 ? 1 : 2];
+function wrappedRows(text, width) {
+  const usable = Math.max(1, width);
+  const lines = text.split("\n");
+  return lines.reduce((sum, line) => sum + Math.max(1, Math.ceil(displayWidth(line) / usable)), 0);
+}
+var plain = (line) => parseInline(line).map((seg) => seg.text).join("");
+var hangingRows = (marker, body, width, padding = 0) => {
+  const textWidth = Math.max(10, width - padding - displayWidth(marker) - 1);
+  return wrappedRows(plain(body), textWidth);
+};
+function markdownRowCount(text, width) {
+  const lines = text.split("\n");
+  let rows = 0;
+  let inCode = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      inCode = !inCode;
+      continue;
+    }
+    if (inCode) {
+      rows += wrappedRows(`  ${line}`, width);
+      continue;
+    }
+    const table = parseTable(lines, i);
+    if (table) {
+      rows += layoutTable(table.table, width).length;
+      i = table.end - 1;
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      rows += wrappedRows(plain(heading[2]), width);
+      continue;
+    }
+    if (RULE.test(line)) {
+      rows += 1;
+      continue;
+    }
+    const quote = QUOTE.exec(line);
+    if (quote) {
+      rows += hangingRows("\u258E".repeat(quote[1].replace(/\s/g, "").length), quote[2], width);
+      continue;
+    }
+    const bullet = BULLET.exec(line);
+    if (bullet) {
+      const padding = Math.min(bullet[1].replace(/\t/g, "    ").length, 16);
+      const task = /^\[([ xX])\]\s+(.*)$/.exec(bullet[2]);
+      rows += task ? hangingRows(task[1] === " " ? "\u2610" : "\u2611", task[2], width, padding) : hangingRows(bulletFor(padding), bullet[2], width, padding);
+      continue;
+    }
+    const numbered = NUMBERED.exec(line);
+    if (numbered) {
+      const padding = Math.min(numbered[1].replace(/\t/g, "    ").length, 16);
+      rows += hangingRows(`${numbered[2]}.`, numbered[3], width, padding);
+      continue;
+    }
+    rows += line ? wrappedRows(plain(line), width) : 1;
+  }
+  return rows;
+}
+
+// src/ui/tty.ts
+function isTtyStream(stream) {
+  return typeof stream === "object" && stream !== null && stream.isTTY === true;
+}
+function isRealTty(stream) {
+  return isTtyStream(stream) && typeof stream.fd === "number";
+}
+function streamColumns(stream) {
+  const columns = typeof stream === "object" && stream !== null ? stream.columns : void 0;
+  return typeof columns === "number" && columns > 0 ? columns : 80;
+}
+function streamRows(stream) {
+  const rows = typeof stream === "object" && stream !== null ? stream.rows : void 0;
+  return typeof rows === "number" && rows > 0 ? rows : 24;
+}
+
+// src/ui/Markdown.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function segment(seg, key) {
+  switch (seg.style) {
+    case "bold":
+      return /* @__PURE__ */ jsx(Text, { bold: true, children: seg.text }, key);
+    case "italic":
+      return /* @__PURE__ */ jsx(Text, { italic: true, children: seg.text }, key);
+    case "strike":
+      return /* @__PURE__ */ jsx(Text, { strikethrough: true, children: seg.text }, key);
+    case "link":
+      return /* @__PURE__ */ jsx(Text, { underline: true, color: color("cyan"), children: seg.text }, key);
+    case "code":
+      return /* @__PURE__ */ jsx(Text, { color: color("cyan"), children: seg.text }, key);
+    case "dim":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: seg.text }, key);
+    default:
+      return seg.text;
+  }
+}
+var inline = (line) => parseInline(line).map(segment);
+function hanging(key, marker, body, width, padding = 0) {
+  const textWidth = Math.max(10, width - padding - displayWidth(marker) - 1);
+  return /* @__PURE__ */ jsxs(Box, { paddingLeft: padding, children: [
+    /* @__PURE__ */ jsx(Box, { flexShrink: 0, marginRight: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: marker }) }),
+    /* @__PURE__ */ jsx(Box, { width: textWidth, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { children: body }) })
+  ] }, key);
+}
+function Markdown({ text, indent = 2 }) {
+  const { stdout } = useStdout();
+  const width = Math.max(20, streamColumns(stdout) - indent - 1);
+  const lines = text.split("\n");
+  const rows = [];
+  let inCode = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      inCode = !inCode;
+      continue;
+    }
+    if (inCode) {
+      rows.push(
+        /* @__PURE__ */ jsx(Text, { color: color("cyan"), children: `  ${line}` }, i)
+      );
+      continue;
+    }
+    const parsed = parseTable(lines, i);
+    if (parsed) {
+      layoutTable(parsed.table, width).forEach((tableLine, n) => {
+        rows.push(/* @__PURE__ */ jsx(Text, { children: tableLine.length ? tableLine.map(segment) : " " }, `${i}-${n}`));
+      });
+      i = parsed.end - 1;
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      const level = heading[1].length;
+      rows.push(
+        /* @__PURE__ */ jsx(Text, { bold: true, underline: level === 1, color: level <= 2 ? color(ACCENT) : void 0, children: parseInline(heading[2]).map((s) => s.text).join("") }, i)
+      );
+      continue;
+    }
+    if (RULE.test(line)) {
+      rows.push(
+        /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2500".repeat(Math.min(width, 80)) }, i)
+      );
+      continue;
+    }
+    const quote = QUOTE.exec(line);
+    if (quote) {
+      const depth = quote[1].replace(/\s/g, "").length;
+      rows.push(hanging(i, "\u258E".repeat(depth), /* @__PURE__ */ jsx(Text, { italic: true, children: inline(quote[2]) }), width));
+      continue;
+    }
+    const bullet = BULLET.exec(line);
+    if (bullet) {
+      const padding = Math.min(bullet[1].replace(/\t/g, "    ").length, 16);
+      const task = /^\[([ xX])\]\s+(.*)$/.exec(bullet[2]);
+      rows.push(
+        task ? hanging(i, task[1] === " " ? "\u2610" : "\u2611", inline(task[2]), width, padding) : hanging(i, bulletFor(padding), inline(bullet[2]), width, padding)
+      );
+      continue;
+    }
+    const numbered = NUMBERED.exec(line);
+    if (numbered) {
+      const padding = Math.min(numbered[1].replace(/\t/g, "    ").length, 16);
+      rows.push(hanging(i, `${numbered[2]}.`, inline(numbered[3]), width, padding));
+      continue;
+    }
+    rows.push(/* @__PURE__ */ jsx(Text, { children: line ? inline(line) : " " }, i));
+  }
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rows });
+}
+
+// src/ui/LinePrompt.tsx
+import { Box as Box2, Text as Text3, useInput } from "ink";
+import { useState } from "react";
+
+// src/ui/EditableText.tsx
+import { Text as Text2 } from "ink";
+
+// src/ui/lineEdit.ts
+var segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function boundaries(text) {
+  const out = [];
+  for (const { index } of segmenter.segment(text)) out.push(index);
+  out.push(text.length);
+  return out;
+}
+function prevBoundary(text, pos) {
+  let previous = 0;
+  for (const b of boundaries(text)) {
+    if (b >= pos) return previous;
+    previous = b;
+  }
+  return previous;
+}
+function nextBoundary(text, pos) {
+  for (const b of boundaries(text)) if (b > pos) return b;
+  return text.length;
+}
+var isSpace = (ch) => /\s/.test(ch);
+function wordLeft(text, pos) {
+  let i = pos;
+  while (i > 0 && isSpace(text[i - 1])) i--;
+  while (i > 0 && !isSpace(text[i - 1])) i--;
+  return i;
+}
+function wordRight(text, pos) {
+  let i = pos;
+  while (i < text.length && isSpace(text[i])) i++;
+  while (i < text.length && !isSpace(text[i])) i++;
+  return i;
+}
+var lineStart = (text, pos) => text.lastIndexOf("\n", pos - 1) + 1;
+function lineEnd(text, pos) {
+  const i = text.indexOf("\n", pos);
+  return i === -1 ? text.length : i;
+}
+function position(text, pos) {
+  const before = text.slice(0, pos);
+  const start = lineStart(text, pos);
+  return { line: before.split("\n").length - 1, column: boundaries(text.slice(start, pos)).length - 1 };
+}
+function moveLine(text, pos, direction) {
+  const { line, column } = position(text, pos);
+  const lines = text.split("\n");
+  const target = line + direction;
+  if (target < 0 || target >= lines.length) return void 0;
+  let start = 0;
+  for (let i = 0; i < target; i++) start += lines[i].length + 1;
+  const chars = boundaries(lines[target]);
+  return start + chars[Math.min(column, chars.length - 1)];
+}
+var atEnd = (s) => s.cursor >= s.value.length;
+function insert(s, text) {
+  return { value: s.value.slice(0, s.cursor) + text + s.value.slice(s.cursor), cursor: s.cursor + text.length };
+}
+function remove(s, from, to) {
+  return { value: s.value.slice(0, from) + s.value.slice(to), cursor: from };
+}
+function applyEditKey(s, input, key) {
+  const { value, cursor } = s;
+  const word = !!(key.ctrl || key.meta);
+  if (key.leftArrow) return { value, cursor: word ? wordLeft(value, cursor) : prevBoundary(value, cursor) };
+  if (key.rightArrow) return { value, cursor: word ? wordRight(value, cursor) : nextBoundary(value, cursor) };
+  if (key.home) return { value, cursor: lineStart(value, cursor) };
+  if (key.end) return { value, cursor: lineEnd(value, cursor) };
+  if (key.backspace) {
+    if (key.meta) return remove(s, wordLeft(value, cursor), cursor);
+    return cursor > 0 ? remove(s, prevBoundary(value, cursor), cursor) : s;
+  }
+  if (key.delete) {
+    if (atEnd(s)) return cursor > 0 ? remove(s, prevBoundary(value, cursor), cursor) : s;
+    return remove(s, cursor, nextBoundary(value, cursor));
+  }
+  if (key.ctrl) {
+    switch (input) {
+      case "a":
+        return { value, cursor: lineStart(value, cursor) };
+      case "e":
+        return { value, cursor: lineEnd(value, cursor) };
+      case "b":
+        return { value, cursor: prevBoundary(value, cursor) };
+      case "f":
+        return { value, cursor: nextBoundary(value, cursor) };
+      case "w":
+        return remove(s, wordLeft(value, cursor), cursor);
+      case "u":
+        return remove(s, lineStart(value, cursor), cursor);
+      case "k":
+        return remove(s, cursor, lineEnd(value, cursor));
+    }
+    return void 0;
+  }
+  if (key.meta) {
+    switch (input) {
+      case "b":
+        return { value, cursor: wordLeft(value, cursor) };
+      case "f":
+        return { value, cursor: wordRight(value, cursor) };
+      case "d":
+        return remove(s, cursor, wordRight(value, cursor));
+    }
+  }
+  return void 0;
+}
+function splitAtCursor(s) {
+  const before = s.value.slice(0, s.cursor);
+  if (s.cursor >= s.value.length) return { before, at: " ", after: "" };
+  const end = nextBoundary(s.value, s.cursor);
+  const char = s.value.slice(s.cursor, end);
+  if (char === "\n") return { before, at: " ", after: s.value.slice(s.cursor) };
+  return { before, at: char, after: s.value.slice(end) };
+}
+var graphemes = (text) => Array.from(segmenter.segment(text), (s) => s.segment);
+function masked(s) {
+  return { value: "\u2022".repeat(graphemes(s.value).length), cursor: graphemes(s.value.slice(0, s.cursor)).length };
+}
+
+// src/ui/EditableText.tsx
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var MAX_VISIBLE_LINES = 10;
+function windowedState(s) {
+  const lines = s.value.split("\n");
+  if (lines.length <= MAX_VISIBLE_LINES) return { view: s, hiddenAbove: 0, hiddenBelow: 0 };
+  const cursorLine = s.value.slice(0, s.cursor).split("\n").length - 1;
+  const startLine = Math.max(0, Math.min(cursorLine - Math.floor(MAX_VISIBLE_LINES / 2), lines.length - MAX_VISIBLE_LINES));
+  const endLine = Math.min(lines.length, startLine + MAX_VISIBLE_LINES);
+  let charStart = 0;
+  for (let i = 0; i < startLine; i++) charStart += lines[i].length + 1;
+  const sliced = lines.slice(startLine, endLine).join("\n");
+  const relCursor = Math.max(0, Math.min(sliced.length, s.cursor - charStart));
+  return {
+    view: { value: sliced, cursor: relCursor },
+    hiddenAbove: startLine,
+    hiddenBelow: lines.length - endLine
+  };
+}
+function EditableText({ state, mask = false, showCursor = true }) {
+  const raw = mask ? masked(state) : state;
+  const { view, hiddenAbove, hiddenBelow } = windowedState(raw);
+  const prefix = hiddenAbove > 0 ? `\u2026 (+${hiddenAbove} lines above)
+` : "";
+  const suffix = hiddenBelow > 0 ? `
+\u2026 (+${hiddenBelow} lines below)` : "";
+  if (!showCursor) return /* @__PURE__ */ jsx2(Fragment, { children: `${prefix}${view.value}${suffix}` });
+  const { before, at, after } = splitAtCursor(view);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    prefix ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: prefix }) : null,
+    before,
+    /* @__PURE__ */ jsx2(Text2, { inverse: true, children: at }),
+    after,
+    suffix ? /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: suffix }) : null
+  ] });
+}
+
+// src/ui/thinkingMouse.ts
+function parseMousePress(value) {
+  const start = value.indexOf("\x1B[<");
+  if (start < 0) return void 0;
+  const match = /^<(\d+);(\d+);(\d+)M/.exec(value.slice(start + 2));
+  if (!match) return void 0;
+  const button = Number(match[1]);
+  if (button !== 0) return void 0;
+  const x = Number(match[2]);
+  const y = Number(match[3]);
+  if (x < 1 || y < 1) return void 0;
+  return { x, y };
+}
+function parseCursorPosition(value) {
+  const start = value.indexOf("\x1B[");
+  if (start < 0) return void 0;
+  const match = /^(\d+);(\d+)R/.exec(value.slice(start + 2));
+  if (!match) return void 0;
+  const row = Number(match[1]);
+  const col = Number(match[2]);
+  if (row < 1 || col < 1) return void 0;
+  return { row, col };
+}
+function clickedThinking(click, cursorRow, rootHeight, target) {
+  if (!rootHeight || !target.width || !target.height) return false;
+  const origin = cursorRow - rootHeight + 1;
+  const row = origin + target.y;
+  const col = target.x + 1;
+  return (click.y === row || click.y === row - 1) && click.x >= col && click.x < col + Math.min(target.width, 72);
+}
+function hasMouseWheelSequence(chunk) {
+  return chunk.includes("\x1B[") && /\[<?6[4567];\d+;\d+[mM]/.test(chunk);
+}
+function isControlReportFragment(input) {
+  return /^\[<[\d;]*[mM]?$/.test(input) || /^\[(?:\d+;){2}\d+[mM]$/.test(input) || /^\[(?:\d+;)+\d*R?$/.test(input) || /^\[M[\s\S]{0,3}$/.test(input);
+}
+function parseThinkingReports(value) {
+  const events = [];
+  let offset = 0;
+  while (true) {
+    const start = value.indexOf("\x1B[", offset);
+    if (start < 0) break;
+    const finish = /[a-zA-Z~]/.exec(value.slice(start + 2));
+    if (!finish) return { events, rest: value.slice(start) };
+    const end = start + 2 + finish.index + 1;
+    const raw = value.slice(start, end);
+    const press = parseMousePress(raw);
+    const cursor = parseCursorPosition(raw);
+    if (press) events.push({ type: "mouse", press });
+    else if (cursor) events.push({ type: "cursor", cursor });
+    offset = end;
+  }
+  const remaining = value.lastIndexOf("\x1B[");
+  if (remaining >= offset) return { events, rest: value.slice(remaining) };
+  return { events, rest: value.endsWith("\x1B") ? "\x1B" : "" };
+}
+
+// src/ui/LinePrompt.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function LinePrompt({ label, mask, onSubmit, onCancel }) {
+  const [line, setLine] = useState({ value: "", cursor: 0 });
+  useInput((input, key) => {
+    if (isControlReportFragment(input)) return;
+    if (key.return) onSubmit(line.value.trim());
+    else if (key.escape) onCancel();
+    else if (applyEditKey(line, input, key)) setLine((current) => applyEditKey(current, input, key) ?? current);
+    else if (!key.ctrl && !key.meta && !key.tab && !key.upArrow && !key.downArrow) {
+      const text = input.replace(/[\r\n]/g, "");
+      if (text) setLine((current) => insert(current, text));
+    }
+  });
+  return /* @__PURE__ */ jsx3(Box2, { borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: /* @__PURE__ */ jsxs3(Text3, { children: [
+    `${label}: `,
+    /* @__PURE__ */ jsx3(EditableText, { state: line, mask }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: t("   enter save \xB7 esc cancel") })
+  ] }) });
+}
+
+// src/ui/ListPicker.tsx
+import { Box as Box3, Text as Text4, useInput as useInput2 } from "ink";
+import { useState as useState2 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var VISIBLE = 12;
+function ListPicker({ title, items, onPick }) {
+  const [filter, setFilter] = useState2("");
+  const [index, setIndex] = useState2(0);
+  const shown = items.filter((i) => i.label.toLowerCase().includes(filter.toLowerCase()));
+  const cursor = Math.min(index, Math.max(0, shown.length - 1));
+  useInput2((input, key) => {
+    if (isControlReportFragment(input)) return;
+    if (key.upArrow) setIndex(Math.max(0, cursor - 1));
+    else if (key.downArrow) setIndex(Math.min(Math.max(0, shown.length - 1), cursor + 1));
+    else if (key.pageUp) setIndex(Math.max(0, cursor - VISIBLE));
+    else if (key.pageDown) setIndex(Math.min(Math.max(0, shown.length - 1), cursor + VISIBLE));
+    else if (key.return && !shown[cursor]?.disabled) onPick(shown[cursor]?.id);
+    else if (key.escape) onPick(void 0);
+    else if (key.backspace || key.delete) {
+      setFilter((f) => f.slice(0, -1));
+      setIndex(0);
+    } else if (!key.ctrl && !key.meta && !key.tab && input) {
+      setFilter((f) => f + input);
+      setIndex(0);
+    }
+  });
+  const start = Math.max(0, Math.min(cursor - 5, shown.length - VISIBLE));
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: t("{title} (\u2191\u2193 enter \xB7 type to filter{filter} \xB7 esc cancel)", { title, filter: filter ? `: ${filter}` : "" }) }),
+    shown.slice(start, start + VISIBLE).map((item, i) => /* @__PURE__ */ jsxs4(Text4, { color: start + i === cursor && !item.disabled ? color("green") : void 0, dimColor: item.disabled, children: [
+      `${start + i === cursor ? "\u203A" : " "} ${item.label}`,
+      item.hint ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `   ${item.hint}` }) : null
+    ] }, item.id)),
+    shown.length ? null : /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: t("No matches.") })
+  ] });
+}
+
+// src/ui/ModelPicker.tsx
+import { Box as Box4, Text as Text5, useInput as useInput3 } from "ink";
+import { useState as useState3 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var VISIBLE2 = 14;
+function ModelPicker({ groups, current, onPick }) {
+  const [filter, setFilter] = useState3("");
+  const [index, setIndex] = useState3(0);
+  const needle = filter.toLowerCase();
+  const rows = [];
+  for (const g of groups) {
+    if (g.error) continue;
+    const models = g.models.filter((m) => m.toLowerCase().includes(needle));
+    if (!models.length) continue;
+    rows.push({ kind: "header", text: g.providerName });
+    for (const m of models) rows.push({ kind: "model", ref: `${g.providerId}/${m}`, label: m });
+  }
+  const selectable = rows.flatMap((r, i) => r.kind === "model" ? [i] : []);
+  const clampedIndex = Math.min(index, Math.max(0, selectable.length - 1));
+  const cursor = selectable[clampedIndex] ?? -1;
+  useInput3((input, key) => {
+    if (isControlReportFragment(input)) return;
+    if (key.upArrow) setIndex(Math.max(0, clampedIndex - 1));
+    else if (key.downArrow) setIndex(Math.min(Math.max(0, selectable.length - 1), clampedIndex + 1));
+    else if (key.pageUp) setIndex(Math.max(0, clampedIndex - VISIBLE2));
+    else if (key.pageDown) setIndex(Math.min(Math.max(0, selectable.length - 1), clampedIndex + VISIBLE2));
+    else if (key.return) {
+      const row = rows[cursor];
+      if (row?.kind === "model") onPick(row.ref);
+    } else if (key.escape) onPick(void 0);
+    else if (key.backspace || key.delete) {
+      setFilter((f) => f.slice(0, -1));
+      setIndex(0);
+    } else if (!key.ctrl && !key.meta && !key.tab && input) {
+      setFilter((f) => f + input);
+      setIndex(0);
+    }
+  });
+  const start = Math.max(0, Math.min(cursor - 5, rows.length - VISIBLE2));
+  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: t("Choose a model (type to filter{filter} \xB7 \u2191\u2193 enter \xB7 esc cancel)", { filter: filter ? `: ${filter}` : "" }) }),
+    rows.slice(start, start + VISIBLE2).map(
+      (row, i) => row.kind === "header" ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: `\u2500\u2500 ${row.text} ` }, `h${start + i}`) : /* @__PURE__ */ jsx5(Text5, { color: start + i === cursor ? color("green") : void 0, children: `${start + i === cursor ? "\u203A" : " "} ${row.label}${row.ref === current ? "  (aktif)" : ""}` }, row.ref)
+    ),
+    !selectable.length ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: t("No matching models.") }) : null,
+    groups.filter((g) => g.error).map((g) => /* @__PURE__ */ jsx5(Text5, { color: color("yellow"), children: `${g.providerName} \u2014 ${g.error}` }, `e-${g.providerId}`))
+  ] });
+}
+
+// src/ui/ProviderMenu.tsx
+import { Box as Box5, Text as Text6, useInput as useInput4 } from "ink";
+import { useState as useState4 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function ProviderMenu({ entries, onPick }) {
+  const rows = [...entries.map((e) => e.id), "custom"];
+  const [index, setIndex] = useState4(0);
+  useInput4((_input, key) => {
+    if (key.upArrow) setIndex((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setIndex((i) => Math.min(rows.length - 1, i + 1));
+    else if (key.pageUp) setIndex((i) => Math.max(0, i - 10));
+    else if (key.pageDown) setIndex((i) => Math.min(rows.length - 1, i + 10));
+    else if (key.return) onPick(rows[index]);
+    else if (key.escape) onPick(void 0);
+  });
+  return /* @__PURE__ */ jsxs6(Box5, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: t("Provider (\u2191\u2193 enter, esc cancel) \xB7 \u2713 ready \xB7 \u25CB needs API key") }),
+    entries.map((e, i) => /* @__PURE__ */ jsxs6(Text6, { color: i === index ? color("green") : void 0, children: [
+      `${i === index ? "\u203A" : " "} ${e.ready ? "\u2713" : "\u25CB"} ${e.name}`,
+      /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: `  ${e.baseURL}` })
+    ] }, e.id)),
+    /* @__PURE__ */ jsx6(Text6, { color: index === rows.length - 1 ? color("green") : void 0, children: `${index === rows.length - 1 ? "\u203A" : " "}   Custom\u2026` })
+  ] });
+}
+
+// src/ui/PermissionPrompt.tsx
+import { Box as Box7, Text as Text8, useInput as useInput5 } from "ink";
+import { useState as useState5 } from "react";
+
+// src/ui/DiffView.tsx
+import { Box as Box6, Text as Text7 } from "ink";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function DiffView({ diff }) {
+  return /* @__PURE__ */ jsx7(Box6, { flexDirection: "column", children: diff.split("\n").map((line, i) => {
+    const mark = line[6];
+    const c = mark === "+" ? color("green") : mark === "-" ? color("red") : void 0;
+    return /* @__PURE__ */ jsx7(Text7, { color: c, dimColor: mark !== "+" && mark !== "-", children: line }, i);
+  }) });
+}
+
+// src/ui/PermissionPrompt.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var VERB = { edit: "edit", write: "write", bash: "run", fetch: "fetch" };
+var MAX_DIFF_LINES = 16;
+function PermissionPrompt({
+  request,
+  onAnswer
+}) {
+  const diffLines = request.preview ? request.preview.split("\n") : [];
+  const maxOffset = Math.max(0, diffLines.length - MAX_DIFF_LINES);
+  const [offset, setOffset] = useState5(0);
+  useInput5((input, key) => {
+    if (key.upArrow) {
+      setOffset((o) => Math.max(0, o - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setOffset((o) => Math.min(maxOffset, o + 1));
+      return;
+    }
+    if (key.pageUp) {
+      setOffset((o) => Math.max(0, o - MAX_DIFF_LINES));
+      return;
+    }
+    if (key.pageDown) {
+      setOffset((o) => Math.min(maxOffset, o + MAX_DIFF_LINES));
+      return;
+    }
+    const k2 = input.toLowerCase();
+    if (k2 === "y") onAnswer("yes");
+    else if (k2 === "a" && request.sessionRules?.length) onAnswer("session");
+    else if (k2 === "s") onAnswer("all");
+    else if (k2 === "n" || key.escape) onAnswer("no");
+  });
+  const rules = request.sessionRules ?? [];
+  const sessionLabel = !rules.length ? null : request.kind === "edit" ? t("yes for all edits in this project, this session") : t("yes this session for {rules}", { rules: rules.join(", ") });
+  const visibleDiff = diffLines.length > MAX_DIFF_LINES ? diffLines.slice(offset, offset + MAX_DIFF_LINES).join("\n") : request.preview;
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: color("yellow"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { bold: true, children: `${request.agent ? `[${request.agent}] ` : ""}${t("Allow {verb} {target}?", { verb: t(VERB[request.tool] ?? request.tool), target: request.target })}` }),
+    visibleDiff ? /* @__PURE__ */ jsx8(DiffView, { diff: visibleDiff }) : null,
+    diffLines.length > MAX_DIFF_LINES ? /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: `\u2191\u2193 scroll (${offset + 1}\u2013${Math.min(diffLines.length, offset + MAX_DIFF_LINES)} / ${diffLines.length})` }) : null,
+    /* @__PURE__ */ jsxs7(Text8, { children: [
+      /* @__PURE__ */ jsx8(Text8, { color: color("green"), children: t("[y] yes") }),
+      "   ",
+      sessionLabel ? /* @__PURE__ */ jsx8(Text8, { color: color("cyan"), children: `[a] ${sessionLabel}   ` }) : null,
+      /* @__PURE__ */ jsx8(Text8, { color: color("yellow"), children: t("[s] yes to all   ") }),
+      /* @__PURE__ */ jsx8(Text8, { color: color("red"), children: t("[n] no") })
+    ] })
+  ] });
+}
+
+// src/ui/PromptInput.tsx
+import { Box as Box8, Text as Text9, useInput as useInput6 } from "ink";
+import { useEffect, useRef, useState as useState6 } from "react";
+
+// src/ui/complete.ts
+import { existsSync, globSync, readFileSync, statSync } from "fs";
+import { isAbsolute, join, relative, resolve } from "path";
+var MAX_ATTACH_BYTES = 32768;
+function listFileSuggestions(value, cwd, limit = 8) {
+  const match = /(^|\s)@([^\s]*)$/.exec(value);
+  if (!match) return [];
+  const prefix = match[2];
+  const escaped = prefix.replace(/([*?[\]{}()!])/g, "\\$1");
+  const pattern = `${escaped}*`;
+  if (validateGlobPattern(pattern)) return [];
+  const exclude = ignorePatterns(cwd);
+  const formatEntry = (entry2) => {
+    const normalized = normalizeGlobPath(entry2);
+    try {
+      return statSync(join(cwd, entry2)).isDirectory() ? `${normalized}/` : normalized;
+    } catch {
+      return normalized;
+    }
+  };
+  try {
+    let found = globSync(pattern, { cwd, exclude }).map(formatEntry).sort();
+    if (!found.length && prefix && !prefix.includes("/")) {
+      const deepPattern = `**/*${escaped}*`;
+      if (!validateGlobPattern(deepPattern)) {
+        found = globSync(deepPattern, { cwd, exclude }).map(formatEntry).sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b));
+      }
+    }
+    return found.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+function applyFileSuggestion(value, pick) {
+  const match = /(^|\s)@([^\s]*)$/.exec(value);
+  if (!match) return value;
+  const prefix = match[2];
+  return `${value.slice(0, value.length - prefix.length)}${pick}${pick.endsWith("/") ? "" : " "}`;
+}
+function completeFile(value, cwd) {
+  const found = listFileSuggestions(value, cwd, 1);
+  if (!found.length) return value;
+  return applyFileSuggestion(value, found[0]);
+}
+function expandAtFileMentions(prompt, cwd, readFiles) {
+  const matches = [...prompt.matchAll(/(?:^|\s)@([^\s]+)/g)];
+  if (!matches.length) return prompt;
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of matches) {
+    const rawPath = m[1];
+    if (!rawPath || seen.has(rawPath)) continue;
+    seen.add(rawPath);
+    if (requiresSensitiveToolApproval({ tool: "read", kind: "read", target: rawPath })) continue;
+    const abs = resolve(cwd, rawPath);
+    const rel = relative(cwd, abs);
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) continue;
+    try {
+      if (!existsSync(abs) || !statSync(abs).isFile() || statSync(abs).size > MAX_ATTACH_BYTES) continue;
+      const buf = readFileSync(abs);
+      if (buf.subarray(0, 4e3).includes(0)) continue;
+      if (readFiles) recordFileMtime(readFiles, abs);
+      blocks.push(`<file path="${rawPath}">
+${buf.toString("utf8")}
+</file>`);
+    } catch {
+    }
+  }
+  return blocks.length ? `${prompt}
+
+${blocks.join("\n\n")}` : prompt;
+}
+
+// src/ui/vim.ts
+var clamp = (s) => {
+  const start = lineStart(s.value, s.cursor);
+  const end = lineEnd(s.value, s.cursor);
+  if (s.cursor < end) return s;
+  return { value: s.value, cursor: Math.max(start, prevBoundary(s.value, end)) };
+};
+var wordStart = (text, pos) => {
+  let i = wordRight(text, pos);
+  while (i < text.length && /\s/.test(text[i])) i++;
+  return i;
+};
+var deleteLine = (s) => {
+  const from = lineStart(s.value, s.cursor);
+  const nl = s.value.indexOf("\n", s.cursor);
+  if (nl === -1) {
+    const start = from > 0 ? from - 1 : 0;
+    return { value: s.value.slice(0, start), cursor: start };
+  }
+  return { value: s.value.slice(0, from) + s.value.slice(nl + 1), cursor: from };
+};
+function applyVim(s, mode, input, key, pending) {
+  if (key.escape) return { state: clamp(s), mode: "normal", handled: true };
+  if (mode === "insert") return { state: s, mode, handled: false };
+  if (key.upArrow || key.downArrow || key.leftArrow || key.rightArrow || key.ctrl || key.meta || key.tab || key.return) {
+    return { state: s, mode, pending, handled: false };
+  }
+  if (pending === "d" || pending === "c") {
+    const nextMode2 = pending === "c" ? "insert" : mode;
+    if (input === pending) return { state: deleteLine(s), mode: nextMode2, handled: true };
+    if (input === "w") {
+      const to = wordStart(s.value, s.cursor);
+      return { state: { value: s.value.slice(0, s.cursor) + s.value.slice(to), cursor: s.cursor }, mode: nextMode2, handled: true };
+    }
+    return { state: s, mode, handled: true };
+  }
+  switch (input) {
+    case "h":
+      return { state: { ...s, cursor: Math.max(lineStart(s.value, s.cursor), prevBoundary(s.value, s.cursor)) }, mode, handled: true };
+    case "l":
+      return { state: { ...s, cursor: Math.min(lineEnd(s.value, s.cursor), nextBoundary(s.value, s.cursor)) }, mode, handled: true };
+    case "j": {
+      const moved = moveLine(s.value, s.cursor, 1);
+      return { state: moved === void 0 ? s : { ...s, cursor: moved }, mode, handled: true };
+    }
+    case "k": {
+      const moved = moveLine(s.value, s.cursor, -1);
+      return { state: moved === void 0 ? s : { ...s, cursor: moved }, mode, handled: true };
+    }
+    case "w":
+      return { state: { ...s, cursor: wordStart(s.value, s.cursor) }, mode, handled: true };
+    case "e":
+      return { state: { ...s, cursor: Math.max(s.cursor, prevBoundary(s.value, wordRight(s.value, s.cursor))) }, mode, handled: true };
+    case "b":
+      return { state: { ...s, cursor: wordLeft(s.value, s.cursor) }, mode, handled: true };
+    case "0":
+      return { state: { ...s, cursor: lineStart(s.value, s.cursor) }, mode, handled: true };
+    case "$":
+      return { state: { ...s, cursor: lineEnd(s.value, s.cursor) }, mode, handled: true };
+    case "x": {
+      if (s.cursor >= s.value.length || s.value[s.cursor] === "\n") return { state: s, mode, handled: true };
+      const next = nextBoundary(s.value, s.cursor);
+      return { state: { value: s.value.slice(0, s.cursor) + s.value.slice(next), cursor: s.cursor }, mode, handled: true };
+    }
+    case "D": {
+      const end = lineEnd(s.value, s.cursor);
+      return { state: { value: s.value.slice(0, s.cursor) + s.value.slice(end), cursor: s.cursor }, mode, handled: true };
+    }
+    case "C": {
+      const end = lineEnd(s.value, s.cursor);
+      return { state: { value: s.value.slice(0, s.cursor) + s.value.slice(end), cursor: s.cursor }, mode: "insert", handled: true };
+    }
+    case "i":
+      return { state: s, mode: "insert", handled: true };
+    case "I": {
+      const start = lineStart(s.value, s.cursor);
+      const end = lineEnd(s.value, s.cursor);
+      let pos = start;
+      while (pos < end && (s.value[pos] === " " || s.value[pos] === "	")) pos++;
+      return { state: { ...s, cursor: pos }, mode: "insert", handled: true };
+    }
+    case "a":
+      return { state: { ...s, cursor: Math.min(lineEnd(s.value, s.cursor), nextBoundary(s.value, s.cursor)) }, mode: "insert", handled: true };
+    case "A":
+      return { state: { ...s, cursor: lineEnd(s.value, s.cursor) }, mode: "insert", handled: true };
+    case "o": {
+      const end = lineEnd(s.value, s.cursor);
+      return { state: { value: `${s.value.slice(0, end)}
+${s.value.slice(end)}`, cursor: end + 1 }, mode: "insert", handled: true };
+    }
+    case "O": {
+      const start = lineStart(s.value, s.cursor);
+      return { state: { value: `${s.value.slice(0, start)}
+${s.value.slice(start)}`, cursor: start }, mode: "insert", handled: true };
+    }
+    case "d":
+    case "c":
+      return { state: s, mode, pending: input, handled: true };
+    default:
+      return { state: s, mode, handled: true };
+  }
+}
+
+// src/ui/PromptInput.tsx
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function PromptInput({ disabled, history, cwd, onSubmit, extraCommands, injected, vim, onEmptyTab }) {
+  const [line, setLine] = useState6({ value: "", cursor: 0 });
+  const { value } = line;
+  const [historyIndex, setHistoryIndex] = useState6(null);
+  const draftRef = useRef("");
+  const [selected, setSelected] = useState6(0);
+  const [dismissed, setDismissed] = useState6(false);
+  const [vimMode, setVimMode] = useState6("insert");
+  const [vimPending, setVimPending] = useState6(void 0);
+  const injectedSeen = useState6(0);
+  useEffect(() => {
+    if (injected && injected.n !== injectedSeen[0]) {
+      injectedSeen[1](injected.n);
+      setLine((current) => insert(current, injected.text));
+      setSelected(0);
+    }
+  }, [injected, injectedSeen]);
+  const all = [...SLASH_COMMANDS, ...(extraCommands ?? []).filter((c) => !SLASH_COMMANDS.some((b) => b.name === c.name))];
+  const suggestions = historyIndex === null && !dismissed && value.startsWith("/") && !/\s/.test(value) ? all.filter((c) => c.name.startsWith(value.slice(1))).slice(0, 8) : [];
+  const beforeCursor = value.slice(0, line.cursor);
+  const fileSuggestions = historyIndex === null && !dismissed && !suggestions.length && /(^|\s)@([^\s]*)$/.test(beforeCursor) ? listFileSuggestions(beforeCursor, cwd, 8) : [];
+  const activeCount = suggestions.length || fileSuggestions.length;
+  const highlighted = Math.min(selected, Math.max(0, activeCount - 1));
+  const typed = (text) => ({ value: text, cursor: text.length });
+  const edit = (next) => {
+    setLine(next);
+    setSelected(0);
+    setDismissed(false);
+    setHistoryIndex(null);
+  };
+  useInput6(
+    (input, key) => {
+      if (isControlReportFragment(input)) return;
+      if (suggestions.length) {
+        if (key.escape) {
+          setDismissed(true);
+          return;
+        }
+        if (key.upArrow) {
+          setSelected(Math.max(0, highlighted - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelected(Math.min(suggestions.length - 1, highlighted + 1));
+          return;
+        }
+        if (key.tab && !key.shift) {
+          edit(typed(`/${suggestions[highlighted].name} `));
+          return;
+        }
+        if (key.return && !key.meta && !key.shift) {
+          edit(typed(""));
+          setHistoryIndex(null);
+          draftRef.current = "";
+          onSubmit(`/${suggestions[highlighted].name}`);
+          return;
+        }
+      }
+      if (fileSuggestions.length) {
+        if (key.escape) {
+          setDismissed(true);
+          return;
+        }
+        if (key.upArrow) {
+          setSelected(Math.max(0, highlighted - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelected(Math.min(fileSuggestions.length - 1, highlighted + 1));
+          return;
+        }
+        if (key.tab && !key.shift) {
+          const completed = applyFileSuggestion(beforeCursor, fileSuggestions[highlighted]);
+          edit({ value: completed + value.slice(line.cursor), cursor: completed.length });
+          return;
+        }
+      }
+      if (vim) {
+        const r = applyVim(line, vimMode, input, key, vimPending);
+        if (r.handled) {
+          setLine(r.state);
+          setVimMode(r.mode);
+          setVimPending(r.pending);
+          setSelected(0);
+          return;
+        }
+      }
+      if (key.return && (key.meta || key.shift) || key.ctrl && input.toLowerCase() === "j" || input === "\n") {
+        edit((current) => insert(current, "\n"));
+        return;
+      }
+      if (key.return) {
+        const before = value.slice(0, line.cursor);
+        if (before.endsWith("\\")) {
+          edit({ value: `${before.slice(0, -1)}
+${value.slice(line.cursor)}`, cursor: before.length });
+          return;
+        }
+        const text2 = value.trim();
+        if (!text2) return;
+        edit(typed(""));
+        setHistoryIndex(null);
+        draftRef.current = "";
+        setVimMode("insert");
+        setVimPending(void 0);
+        onSubmit(text2);
+        return;
+      }
+      const edited = applyEditKey(line, input, key);
+      if (edited) {
+        edit((current) => applyEditKey(current, input, key) ?? current);
+        return;
+      }
+      if (key.upArrow || key.downArrow) {
+        const moved = moveLine(value, line.cursor, key.upArrow ? -1 : 1);
+        if (moved !== void 0) {
+          setLine({ value, cursor: moved });
+          return;
+        }
+      }
+      if (key.upArrow) {
+        if (!history.length) return;
+        if (historyIndex === null) draftRef.current = value;
+        const i = historyIndex === null ? history.length - 1 : Math.max(0, historyIndex - 1);
+        setHistoryIndex(i);
+        setLine(typed(history[i]));
+        return;
+      }
+      if (key.downArrow) {
+        if (historyIndex === null) return;
+        const i = historyIndex + 1;
+        setHistoryIndex(i >= history.length ? null : i);
+        setLine(typed(i >= history.length ? draftRef.current : history[i]));
+        return;
+      }
+      if (key.tab && !key.shift) {
+        if (!value.trim() && onEmptyTab) {
+          onEmptyTab();
+          return;
+        }
+        const before = value.slice(0, line.cursor);
+        const completed = completeFile(before, cwd);
+        if (completed !== before) edit({ value: completed + value.slice(line.cursor), cursor: completed.length });
+        return;
+      }
+      if (key.ctrl || key.meta || key.escape || key.tab) return;
+      const text = input.replace(/\r\n?/g, "\n");
+      if (text) edit((current) => insert(current, text));
+    },
+    { isActive: !disabled }
+  );
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(Box8, { borderStyle: "round", borderColor: color("gray"), paddingX: 1, children: /* @__PURE__ */ jsxs8(Text9, { children: [
+      /* @__PURE__ */ jsx9(Text9, { color: color("green"), children: "> " }),
+      /* @__PURE__ */ jsx9(EditableText, { state: line, showCursor: !disabled }),
+      vim && vimMode === "normal" && /* @__PURE__ */ jsxs8(Text9, { color: color("green"), children: [
+        " ",
+        t("NORMAL")
+      ] })
+    ] }) }),
+    suggestions.map((s, i) => /* @__PURE__ */ jsx9(Text9, { color: i === highlighted ? color("green") : void 0, dimColor: i !== highlighted, children: `${i === highlighted ? "\u203A" : " "} /${s.name}  ${t(s.description)}` }, s.name)),
+    fileSuggestions.map((f, i) => /* @__PURE__ */ jsx9(Text9, { color: i === highlighted ? color("green") : void 0, dimColor: i !== highlighted, children: `${i === highlighted ? "\u203A" : " "} @${f}` }, f))
+  ] });
+}
+
+// src/ui/Spinner.tsx
+import { Text as Text10 } from "ink";
+import { useEffect as useEffect2, useState as useState7 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var FRAMES = ["\xB7", "\u2722", "\u2733", "\u2736", "\u273B", "\u273D"];
+function Spinner({ label, startedAt }) {
+  const [tick, setTick] = useState7(0);
+  useEffect2(() => {
+    const id = setInterval(() => setTick((t2) => t2 + 1), 120);
+    return () => clearInterval(id);
+  }, []);
+  const seconds = Math.floor((Date.now() - startedAt) / 1e3);
+  return /* @__PURE__ */ jsx10(Text10, { color: color(ACCENT), children: `${FRAMES[tick % FRAMES.length]} ${t("{label}\u2026 ({seconds}s \xB7 esc to cancel)", { label, seconds })}` });
+}
+
+// src/ui/StatusBar.tsx
+import { Text as Text11 } from "ink";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var LABEL = {
+  default: "\u23F5 default",
+  acceptEdits: "\u23F5 accept edits",
+  plan: "\u23F8 plan mode",
+  allowAll: "\u23F5\u23F5 allow all"
+};
+function formatTokens(n) {
+  return n >= 1e3 ? `${Math.round(n / 1e3)}k` : String(n);
+}
+function StatusBar({
+  mode,
+  tokens,
+  cached = 0,
+  estimated = false,
+  busy,
+  model,
+  reasoning = "auto"
+}) {
+  const danger = mode === "allowAll";
+  const cacheText = cached > 0 ? ` \xB7 ${t("{n} cached", { n: formatTokens(cached) })}` : "";
+  return /* @__PURE__ */ jsx11(Text11, { color: danger ? color("red") : void 0, dimColor: !danger, children: `  ${LABEL[mode]}${model ? ` \xB7 ${model}` : ""} \xB7 reasoning: ${reasoning} \xB7 ${t("shift+tab switch mode")} \xB7 ${estimated ? "~" : ""}${t("{n} tokens in context", { n: formatTokens(tokens) })}${cacheText} \xB7 ${busy ? t("esc to cancel") : t("/ for commands")}` });
+}
+
+// src/ui/liveCap.ts
+function liveRowCaps(wanted, budget) {
+  const caps = new Array(wanted.length).fill(0);
+  let room = Math.max(0, budget);
+  for (let i = wanted.length - 1; i >= 0; i--) {
+    const take = Math.max(0, Math.min(wanted[i], room));
+    caps[i] = take;
+    room -= take;
+  }
+  return caps;
+}
+function capLiveText(raw, options) {
+  if (!options.isRealTty) return raw;
+  if (options.maxRows <= 0) return "";
+  if (wrappedRows(raw, options.width) <= options.maxRows) return raw;
+  const lines = raw.split("\n");
+  const room = Math.max(1, options.maxRows - 1);
+  let kept = 0;
+  while (kept < lines.length && wrappedRows(lines.slice(lines.length - kept - 1).join("\n"), options.width) <= room) kept++;
+  const hidden = lines.length - kept;
+  return `\u2026 (${hidden} lines above) \u2026
+${lines.slice(hidden).join("\n")}`;
+}
+function capLiveMarkdown(raw, options) {
+  if (!options.isRealTty) return raw;
+  if (options.maxRows <= 0) return "";
+  if (markdownRowCount(raw, options.width) <= options.maxRows) return raw;
+  const lines = raw.split("\n");
+  const room = Math.max(1, options.maxRows - 1);
+  let lo = 0;
+  let hi = lines.length;
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (markdownRowCount(lines.slice(mid).join("\n"), options.width) <= room) hi = mid;
+    else lo = mid + 1;
+  }
+  if (lo >= lines.length) return `\u2026 (${lines.length} lines above) \u2026`;
+  const dropped = lines.slice(0, lo);
+  const fences = dropped.filter((line) => line.trimStart().startsWith("```"));
+  const opener = fences.length % 2 === 1 ? fences.at(-1) : void 0;
+  return `${opener ? `${opener}
+` : ""}\u2026 (${lo} lines above) \u2026
+${lines.slice(lo).join("\n")}`;
+}
+
+// src/ui/McpMenu.tsx
+import { Box as Box9, Text as Text12, useInput as useInput7 } from "ink";
+import { useState as useState8 } from "react";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+var MARK = { ready: "\u2713", error: "\u2717", starting: "\u2026", off: "\u25CB" };
+function McpMenu({ items, onPick }) {
+  const [index, setIndex] = useState8(0);
+  useInput7((_input, key) => {
+    if (key.upArrow) setIndex((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setIndex((i) => Math.min(items.length - 1, i + 1));
+    else if (key.pageUp) setIndex((i) => Math.max(0, i - 10));
+    else if (key.pageDown) setIndex((i) => Math.min(items.length - 1, i + 10));
+    else if (key.return) onPick(items[index]?.name);
+    else if (key.escape) onPick(void 0);
+  });
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx12(Text12, { bold: true, children: t("MCP servers (enter: install / remove \xB7 esc close) \xB7 \u2713 active \u25CB not installed \u2717 error") }),
+    items.map((item, i) => /* @__PURE__ */ jsxs9(Text12, { color: i === index ? color("green") : void 0, children: [
+      `${i === index ? "\u203A" : " "} ${MARK[item.status]} ${item.name.padEnd(12)}`,
+      /* @__PURE__ */ jsx12(Text12, { dimColor: true, children: item.status === "error" ? ` ${item.error ?? ""}` : ` ${item.description}` })
+    ] }, item.name))
+  ] });
+}
+
+// src/ui/PlanApproval.tsx
+import { Box as Box10, Text as Text13, useInput as useInput8 } from "ink";
+import { useState as useState9 } from "react";
+import { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+var MAX_PLAN_LINES = 16;
+function PlanApproval({ plan, onAnswer }) {
+  const planLines = plan.split("\n");
+  const maxOffset = Math.max(0, planLines.length - MAX_PLAN_LINES);
+  const [offset, setOffset] = useState9(0);
+  useInput8((input, key) => {
+    if (key.upArrow) {
+      setOffset((o) => Math.max(0, o - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setOffset((o) => Math.min(maxOffset, o + 1));
+      return;
+    }
+    if (key.pageUp) {
+      setOffset((o) => Math.max(0, o - MAX_PLAN_LINES));
+      return;
+    }
+    if (key.pageDown) {
+      setOffset((o) => Math.min(maxOffset, o + MAX_PLAN_LINES));
+      return;
+    }
+    const k2 = input.toLowerCase();
+    if (k2 === "a") onAnswer("acceptEdits");
+    else if (k2 === "y") onAnswer("default");
+    else if (k2 === "n" || key.escape) onAnswer("no");
+  });
+  const visiblePlan = planLines.length > MAX_PLAN_LINES ? planLines.slice(offset, offset + MAX_PLAN_LINES).join("\n") : plan;
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", borderStyle: "round", borderColor: color("cyan"), paddingX: 1, children: [
+    /* @__PURE__ */ jsx13(Text13, { bold: true, children: t("Plan from the agent") }),
+    /* @__PURE__ */ jsx13(Markdown, { text: visiblePlan, indent: 5 }),
+    planLines.length > MAX_PLAN_LINES ? /* @__PURE__ */ jsx13(Text13, { dimColor: true, children: `\u2191\u2193 scroll (${offset + 1}\u2013${Math.min(planLines.length, offset + MAX_PLAN_LINES)} / ${planLines.length})` }) : null,
+    /* @__PURE__ */ jsxs10(Text13, { children: [
+      /* @__PURE__ */ jsx13(Text13, { color: color("green"), children: t("[a] yes, auto-edit") }),
+      "   ",
+      /* @__PURE__ */ jsx13(Text13, { color: color("cyan"), children: t("[y] yes, ask at each step") }),
+      "   ",
+      /* @__PURE__ */ jsx13(Text13, { color: color("red"), children: t("[n] not yet, revise first") })
+    ] })
+  ] });
+}
+
+// src/ui/TodoList.tsx
+import { Box as Box11, Text as Text14 } from "ink";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var MARK2 = { completed: "\u2611", in_progress: "\u25FC", pending: "\u2610" };
+function TodoList({ items }) {
+  if (!items.length || items.every((t2) => t2.status === "completed")) return null;
+  return /* @__PURE__ */ jsx14(Box11, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: items.map((t2, i) => /* @__PURE__ */ jsx14(Text14, { dimColor: t2.status === "completed", color: t2.status === "in_progress" ? color("yellow") : void 0, children: `${MARK2[t2.status]} ${t2.content}` }, i)) });
+}
+
+// src/ui/ToolBlock.tsx
+import { Box as Box12, Text as Text15 } from "ink";
+import { Fragment as Fragment2, jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+var PREVIEW_LINES = 5;
+var DIFF_PREVIEW_LINES = 20;
+function ToolBlock({ tool, target, output, display, isError, done, expanded, sub, moreBind = "ctrl+o" }) {
+  const isTask = tool === "task";
+  const isDiff = !!display && /^\s*\d+ [+\- ] /.test(display);
+  const lines = (output ?? "").split("\n");
+  const shown = expanded ? lines : lines.slice(0, PREVIEW_LINES);
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginLeft: 2, children: [
+    /* @__PURE__ */ jsxs11(Text15, { children: [
+      /* @__PURE__ */ jsx15(Text15, { color: isError ? color("red") : done ? color("green") : color("yellow"), children: "\u23BF " }),
+      /* @__PURE__ */ jsx15(Text15, { bold: true, children: toolLabel(tool) }),
+      /* @__PURE__ */ jsx15(Text15, { children: `  ${target}` }),
+      display && !isDiff && !isTask ? /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: `  (${display})` }) : null
+    ] }),
+    sub?.length ? /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginLeft: 3, children: [
+      sub.slice(-6).map((s) => /* @__PURE__ */ jsx15(Text15, { dimColor: s.done && !s.isError, color: s.isError ? color("red") : void 0, children: `\u23BF ${toolLabel(s.tool)}  ${s.target}` }, s.id)),
+      sub.length > 6 ? /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u2026 {n} earlier steps", { n: sub.length - 6 }) }) : null
+    ] }) : null,
+    isTask && done ? /* @__PURE__ */ jsx15(Box12, { marginLeft: 3, children: /* @__PURE__ */ jsx15(Text15, { color: isError ? color("red") : color("green"), children: `${isError ? t("\u2717 failed") : t("\u2713 done")}${display ? ` \xB7 ${display}` : ""}` }) }) : null,
+    isDiff ? /* @__PURE__ */ jsx15(Box12, { flexDirection: "column", marginLeft: 3, children: (() => {
+      const diffLines = display.split("\n");
+      const shownDiff = expanded ? diffLines : diffLines.slice(0, DIFF_PREVIEW_LINES);
+      return /* @__PURE__ */ jsxs11(Fragment2, { children: [
+        /* @__PURE__ */ jsx15(DiffView, { diff: shownDiff.join("\n") }),
+        diffLines.length > shownDiff.length ? /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u2026 {n} more lines ({bind})", { n: diffLines.length - shownDiff.length, bind: moreBind }) }) : expanded && diffLines.length > DIFF_PREVIEW_LINES ? /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u2026 ({bind} to collapse)", { bind: moreBind }) }) : null
+      ] });
+    })() }) : output && (isError || tool === "bash" || expanded) && !(isTask && !isError) ? /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", marginLeft: 3, children: [
+      shown.map((line, i) => /* @__PURE__ */ jsx15(Text15, { dimColor: !isError, color: isError ? color("red") : void 0, children: line }, i)),
+      lines.length > shown.length ? /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u2026 {n} more lines ({bind})", { n: lines.length - shown.length, bind: moreBind }) }) : expanded && lines.length > PREVIEW_LINES ? /* @__PURE__ */ jsx15(Text15, { dimColor: true, children: t("\u2026 ({bind} to collapse)", { bind: moreBind }) }) : null
+    ] }) : null
+  ] });
+}
+
+// src/ui/transcript.ts
+var nextId = 0;
+var entry = (e) => ({ ...e, id: nextId++ });
+var NOTICES = {
+  compacted: ["Conversation summarized to fit the model context.", "info"],
+  stepLimit: ['Step limit of {n} reached. Type "continue" to keep going.', "warn"],
+  aborted: ["Cancelled.", "warn"]
+};
+var isEmptyCont = (e) => e.kind === "assistant" && e.cont && !e.text;
+function endTurn(t2) {
+  return { done: [...t2.done, ...t2.live.filter((e) => !isEmptyCont(e))], live: [] };
+}
+var TOOL_MARKUP = /<\/?tool_call>|<\/?arg_(?:key|value)>|Tool call list|^\s*\d+\.\s*Tool:|`\s*=\s*`/;
+function finishedCut(text) {
+  let inFence = false;
+  let pos = 0;
+  let cut = -1;
+  const lines = text.split("\n");
+  for (const line of lines.slice(0, -1)) {
+    if (TOOL_MARKUP.test(line)) break;
+    if (line.trimStart().startsWith("```")) inFence = !inFence;
+    const tableRow = !inFence && !line.trimStart().startsWith("```") && line.includes("|") && line.trim() !== "";
+    pos += line.length + 1;
+    if (!inFence && !tableRow) cut = pos - 1;
+  }
+  return cut;
+}
+function flushLines(t2) {
+  const last = t2.live.at(-1);
+  if (last?.kind !== "assistant") return t2;
+  const cut = finishedCut(last.text);
+  if (cut < 0) return t2;
+  const chunk = last.text.slice(0, cut);
+  if (!last.cont && !chunk.trim()) return t2;
+  const rest = entry({ kind: "assistant", text: last.text.slice(cut + 1), cont: true, flushed: (last.flushed ?? 0) + cut + 1 });
+  return { done: [...t2.done, ...t2.live.slice(0, -1).filter((e) => !isEmptyCont(e)), { ...last, text: chunk || " " }], live: [rest] };
+}
+function applyEvent(t2, event) {
+  switch (event.type) {
+    case "text": {
+      const last = t2.live.at(-1);
+      if (last?.kind === "assistant") return flushLines({ ...t2, live: [...t2.live.slice(0, -1), { ...last, text: last.text + event.delta }] });
+      return flushLines({
+        done: [...t2.done, ...t2.live.filter((e) => !isEmptyCont(e))],
+        live: [entry({ kind: "assistant", text: event.delta })]
+      });
+    }
+    case "thinking": {
+      const last = t2.live.at(-1);
+      if (last?.kind === "thinking") return { ...t2, live: [...t2.live.slice(0, -1), { ...last, text: last.text + event.delta }] };
+      return { ...t2, live: [...t2.live, entry({ kind: "thinking", text: event.delta })] };
+    }
+    case "textReplace": {
+      const last = t2.live.at(-1);
+      if (last?.kind !== "assistant") return t2;
+      return { ...t2, live: [...t2.live.slice(0, -1), { ...last, text: event.text.slice(last.flushed ?? 0) }] };
+    }
+    case "toolStart": {
+      const running = t2.live.some((e) => e.kind === "tool" && !e.done);
+      const tool = entry({ kind: "tool", callId: event.id, tool: event.tool, target: event.target, done: false });
+      return running ? { ...t2, live: [...t2.live, tool] } : { done: [...t2.done, ...t2.live.filter((e) => !isEmptyCont(e))], live: [tool] };
+    }
+    case "toolEnd": {
+      const live = t2.live.map(
+        (e) => e.kind === "tool" && e.callId === event.id ? { ...e, output: event.output, display: event.display, isError: event.isError, done: true } : e
+      );
+      const firstRunning = live.findIndex((e) => e.kind === "tool" && !e.done);
+      const cut = firstRunning === -1 ? live.length : firstRunning;
+      return { done: [...t2.done, ...live.slice(0, cut)], live: live.slice(cut) };
+    }
+    case "subagent": {
+      const inner = event.event;
+      if (inner.type !== "toolStart" && inner.type !== "toolEnd") return t2;
+      const update = (e) => {
+        if (e.kind !== "tool" || e.callId !== event.parentId) return e;
+        const sub = e.sub ?? [];
+        if (inner.type === "toolStart") return { ...e, sub: [...sub, { id: inner.id, tool: inner.tool, target: inner.target, done: false }] };
+        return { ...e, sub: sub.map((s) => s.id === inner.id ? { ...s, done: true, isError: inner.isError } : s) };
+      };
+      return { ...t2, live: t2.live.map(update) };
+    }
+    case "error":
+      return { ...t2, live: [...t2.live, entry({ kind: "notice", text: `Error: ${event.message}`, tone: "error" })] };
+    case "stepLimit": {
+      const limit = event.maxSteps;
+      const notice = NOTICES.stepLimit;
+      return notice ? { ...t2, live: [...t2.live, entry({ kind: "notice", text: t(notice[0], { n: limit }), tone: notice[1] })] } : t2;
+    }
+    default: {
+      const notice = NOTICES[event.type];
+      return notice ? { ...t2, live: [...t2.live, entry({ kind: "notice", text: t(notice[0]), tone: notice[1] })] } : t2;
+    }
+  }
+}
+
+// src/ui/replay.ts
+function replayEntries(history) {
+  const chat = history.map((m) => m.role === "user" ? { role: "user", text: contentText(m.content) } : m.role === "assistant" && typeof m.content === "string" ? { role: "assistant", text: m.content } : void 0).filter((m) => !!m && !!m.text.trim());
+  return [
+    entry({ kind: "notice", text: t("Resuming the session ({messages} messages saved \xB7 {chat} user/assistant chats shown).", { messages: history.length, chat: chat.length }), tone: "info" }),
+    ...chat.map((m) => entry(m.role === "user" ? { kind: "user", text: m.text } : { kind: "assistant", text: m.text }))
+  ];
+}
+
+// src/clipboardImage.ts
+import { execFile as execFile2 } from "child_process";
+import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { join as join2 } from "path";
+function clipboardTarget(tmpdir2, now) {
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+  return join2(tmpdir2, `bccli-clipboard-${stamp}.png`);
+}
+function clipboardCommand(platform, target) {
+  if (platform === "win32") {
+    const escaped = target.replace(/'/g, "''");
+    return {
+      cmd: "powershell.exe",
+      args: [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Add-Type -AssemblyName System.Drawing; $img = Get-Clipboard -Format Image -ErrorAction SilentlyContinue; if ($img) { $img.Save('${escaped}', [System.Drawing.Imaging.ImageFormat]::Png); 'OK' } else { 'EMPTY' }`
+      ]
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      cmd: "osascript",
+      args: [
+        "-e",
+        "try",
+        "-e",
+        "set d to the clipboard as \xABclass PNGf\xBB",
+        "-e",
+        `set f to open for access POSIX file "${target}" with write permission`,
+        "-e",
+        "set eof f to 0",
+        "-e",
+        "write d to f",
+        "-e",
+        "close access f",
+        "-e",
+        '"OK"',
+        "-e",
+        "on error",
+        "-e",
+        '"EMPTY"',
+        "-e",
+        "end try"
+      ]
+    };
+  }
+  if (platform === "linux") {
+    return { cmd: "sh", args: ["-c", `xclip -selection clipboard -t image/png -o > '${target}' 2>/dev/null && echo OK || echo EMPTY`] };
+  }
+  return void 0;
+}
+var defaultRun = (cmd, args) => new Promise((resolve3) => {
+  execFile2(cmd, args, { timeout: 15e3, windowsHide: true }, (error, stdout) => {
+    const code = error ? error.code ?? 1 : 0;
+    resolve3({ code: typeof code === "number" ? code : 1, output: String(stdout ?? "") });
+  });
+});
+async function grabClipboardImage(deps) {
+  const target = clipboardTarget(deps.tmpdir, deps.now);
+  const command = clipboardCommand(deps.platform, target);
+  if (!command) return void 0;
+  const run = deps.run ?? defaultRun;
+  const r = await run(command.cmd, command.args);
+  if (r.code === 0 && r.output.includes("OK") && existsSync2(target) && statSync2(target).size > 0) return target;
+  return void 0;
+}
+
+// src/ui/App.tsx
+import { jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
+function helpText(runtime) {
+  const custom = runtime.commands.filter((c) => !SLASH_COMMANDS.some((b) => b.name === c.name));
+  const kb = runtime.config.keybinds;
+  return [
+    ...SLASH_COMMANDS.map((c) => `/${c.name.padEnd(12)} ${t(c.description)}`),
+    ...custom.length ? ["", t("Custom commands:"), ...custom.map((c) => `/${c.name.padEnd(8)} ${c.description ?? ""}`)] : [],
+    ...runtime.skills.length ? ["", t("Skills:"), ...runtime.skills.map((s) => `/${s.name.padEnd(8)} ${s.description.slice(0, 60)}`)] : [],
+    "",
+    t("shift+tab  switch permission mode    esc  cancel the turn"),
+    t("{bind} full output of the last tool    \\ + enter  new line", { bind: kb.toolOutput.spec.padEnd(10) }),
+    t("{bind} show/hide the model\u2019s thinking", { bind: kb.thinking.spec.padEnd(10) }),
+    t("@file + tab  complete file names    \u2191\u2193  input history")
+  ].join("\n");
+}
+var INIT_PROMPT = "Study this project (folder structure, package/build files, test and lint commands, visible code conventions). Then create AGENTS.md in the project root, or update it if it already exists, covering: how to build, test, and lint; a short structure overview; important conventions. Keep it concise and factual, only what actually exists in the project.";
+var labelFor = (runtime, ref) => `${ref.slice(ref.indexOf("/") + 1)} \xB7 ${runtime.providerLabel()}`;
+function App({ runtime, initialPrompt, version, updateMessage }) {
+  const { exit } = useApp();
+  const [transcript, setTranscript] = useState10(() => ({
+    done: [entry({ kind: "header" }), ...updateMessage ? [entry({ kind: "notice", text: updateMessage, tone: "warn" })] : [], ...runtime.agent.messages.length ? replayEntries(runtime.session.loadHistory()) : []],
+    live: []
+  }));
+  const [busy, setBusy] = useState10(false);
+  const [cancelling, setCancelling] = useState10(false);
+  const [startedAt, setStartedAt] = useState10(0);
+  const [mode, setMode] = useState10(runtime.agent.permissions.mode);
+  const [reasoning, setReasoning] = useState10(runtime.reasoning);
+  const [tokens, setTokens] = useState10(runtime.agent.lastInputTokens);
+  const [cachedTokens, setCachedTokens] = useState10(runtime.agent.totalUsage.cachedInputTokens ?? 0);
+  const [tokensEstimated, setTokensEstimated] = useState10(runtime.agent.lastInputEstimated);
+  const [asks, setAsks] = useState10([]);
+  const pending = asks[0] ?? null;
+  const askId = useRef2(0);
+  const [picker, setPicker] = useState10(null);
+  const [providerMenu, setProviderMenu] = useState10(null);
+  const [prompt, setPrompt] = useState10(null);
+  const ask = useCallback((label, mask = false) => new Promise((resolve3) => setPrompt({ label, mask, resolve: resolve3 })), []);
+  const [modelLabel, setModelLabel] = useState10(() => labelFor(runtime, runtime.modelRef));
+  const [history, setHistory] = useState10([]);
+  const controller = useRef2(null);
+  const [todos, setTodos] = useState10(runtime.todos.items);
+  const [mcpMenu, setMcpMenu] = useState10(null);
+  const [listPicker, setListPicker] = useState10(null);
+  const [planAsk, setPlanAsk] = useState10(null);
+  const [queued, setQueued] = useState10([]);
+  const [showThinking, setShowThinking] = useState10(runtime.config.thinkingVisible === true);
+  const showThinkingRef = useRef2(showThinking);
+  const [showToolOutput, setShowToolOutput] = useState10(false);
+  const [staticKey, setStaticKey] = useState10(0);
+  const [, setConfigRev] = useState10(0);
+  const lastUserIdx = transcript.done.findLastIndex((e) => e.kind === "user");
+  const { stdin } = useStdin();
+  const { stdout } = useStdout2();
+  const realStdout = isRealTty(stdout);
+  const liveWidth = Math.max(20, streamColumns(stdout) - 3);
+  const liveRowBudget = Math.max(8, streamRows(stdout) - 10);
+  const maxSplitIdxRef = useRef2(0);
+  const refreshStatic = useCallback(() => {
+    if (realStdout) {
+      stdout.write("\x1B[2J\x1B[3J\x1B[H");
+    }
+    maxSplitIdxRef.current = 0;
+    setStaticKey((k2) => k2 + 1);
+  }, [stdout, realStdout]);
+  let splitIdx = Math.max(maxSplitIdxRef.current, lastUserIdx > 0 ? lastUserIdx : 0);
+  const entryRows = (e) => {
+    if (e.kind === "thinking") {
+      return showThinking ? Math.min(liveRowBudget, wrappedRows(e.text, liveWidth) + 3) : 2;
+    }
+    if (e.kind === "tool") {
+      return showToolOutput ? Math.min(liveRowBudget, wrappedRows(e.output ?? e.display ?? "", liveWidth) + 2) : 5;
+    }
+    if (e.kind === "assistant") return markdownRowCount(e.text, liveWidth) + 1;
+    if (e.kind === "notice" || e.kind === "user") return wrappedRows(e.text, Math.max(20, liveWidth - 2)) + 1;
+    return 2;
+  };
+  if (realStdout) {
+    const liveLines = transcript.live.reduce((acc, e) => acc + entryRows(e), 0);
+    let doneLines = transcript.done.slice(splitIdx).reduce((acc, e) => acc + entryRows(e), 0);
+    while (splitIdx < transcript.done.length && doneLines + liveLines > liveRowBudget) {
+      doneLines -= entryRows(transcript.done[splitIdx]);
+      splitIdx++;
+    }
+    maxSplitIdxRef.current = splitIdx;
+  }
+  const staticDone = transcript.done.slice(0, splitIdx);
+  const activeTurnDone = transcript.done.slice(splitIdx);
+  const doneRows = realStdout ? activeTurnDone.reduce((acc, e) => acc + entryRows(e), 0) : 0;
+  const liveCaps = transcript.live.map(() => Number.POSITIVE_INFINITY);
+  if (realStdout) {
+    for (const [i, cap] of liveRowCaps(transcript.live.map(entryRows), liveRowBudget - doneRows).entries()) liveCaps[i] = cap;
+  }
+  const activeTurnEntries = [...activeTurnDone, ...transcript.live];
+  const lastThinkingEntryId = activeTurnEntries.findLast((e) => e.kind === "thinking" && !!e.text.trim())?.id;
+  const hasThinking = lastThinkingEntryId !== void 0 || transcript.done.some((e) => e.kind === "thinking" && !!e.text.trim());
+  const liveRootRef = useRef2(null);
+  const thinkingTargetRef = useRef2(null);
+  const spinnerTargetRef = useRef2(null);
+  const thinkingEntryRefs = useRef2(/* @__PURE__ */ new Map());
+  const [injected, setInjected] = useState10();
+  useEffect3(() => runtime.todos.subscribe(setTodos), [runtime]);
+  const extraCommands = [
+    ...runtime.commands.filter((c) => !SLASH_COMMANDS.some((b) => b.name === c.name.toLowerCase())).map((c) => ({ name: c.name.toLowerCase(), description: c.description ?? t("custom command") })),
+    ...runtime.skills.filter((s) => !runtime.commands.some((c) => c.name.toLowerCase() === s.name.toLowerCase())).filter((s) => !SLASH_COMMANDS.some((b) => b.name === s.name.toLowerCase())).map((s) => ({ name: s.name, description: t("skill \xB7 {description}", { description: s.description.slice(0, 50) }) }))
+  ];
+  const lastTool = useRef2(null);
+  const toolTargets = useRef2(/* @__PURE__ */ new Map());
+  const editedInTurn = useRef2(false);
+  const notice = useCallback((text, tone = "info") => {
+    setTranscript((t2) => ({ ...t2, done: [...t2.done, entry({ kind: "notice", text, tone })] }));
+  }, []);
+  const onEvent = useCallback((event) => {
+    if (event.type === "toolStart") toolTargets.current.set(event.id, event.target);
+    if (event.type === "toolEnd") {
+      lastTool.current = { tool: event.tool, target: toolTargets.current.get(event.id) ?? "", output: event.output };
+      if ((event.tool === "edit" || event.tool === "write") && !event.isError) editedInTurn.current = true;
+    }
+    if (event.type === "usage") {
+      if (event.lastInputTokens !== void 0) {
+        setTokens(event.lastInputTokens);
+        setCachedTokens(event.lastCachedInputTokens ?? 0);
+        setTokensEstimated(event.estimated ?? false);
+      }
+    }
+    if (event.type === "budgetExceeded") {
+      notice(
+        t("Budget exceeded ({kind}): {used} of {limit}. Further model calls are blocked; raise usageCap in ~/.bccli/config.json.", {
+          kind: event.kind,
+          used: Math.round(event.used * 100) / 100,
+          limit: event.limit
+        }),
+        "warn"
+      );
+    }
+    setTranscript((t2) => applyEvent(t2, event));
+  }, [notice]);
+  useEffect3(() => {
+    runtime.agent.onEvent = onEvent;
+    runtime.agent.askPermission = (request) => new Promise((resolve3) => setAsks((q) => [...q, { id: askId.current++, request, resolve: resolve3 }]));
+    runtime.interaction.approvePlan = (plan) => new Promise((resolve3) => setPlanAsk({ plan, resolve: resolve3 }));
+    runHooks(runtime.config.hooks, "SessionStart", {}, { env: runtime.env, cwd: runtime.cwd }).then((outcome) => {
+      for (const w of outcome.warnings) notice(w, "warn");
+    }).catch(() => {
+    });
+    runtime.emitPlugins("SessionStart").catch(() => {
+    });
+  }, [runtime, onEvent, notice]);
+  const runTurn = useCallback(
+    async (text) => {
+      setTranscript((t2) => ({ ...t2, done: [...t2.done, entry({ kind: "user", text })] }));
+      setBusy(true);
+      setShowToolOutput(false);
+      setStartedAt(Date.now());
+      editedInTurn.current = false;
+      controller.current = new AbortController();
+      const signal = controller.current.signal;
+      const expandedText = expandAtFileMentions(text, runtime.cwd, runtime.agent.readFiles);
+      await runtime.agent.run(expandedText, signal);
+      const commands = runtime.config.verifyCommands;
+      if (editedInTurn.current && commands.length && !signal.aborted) {
+        for (let round = 0; round < MAX_VERIFY_ROUNDS; round++) {
+          notice(t("Verifying edits: {cmds}", { cmds: commands.join(", ") }));
+          const failures = await runVerify(commands, { cwd: runtime.cwd, env: runtime.env, signal });
+          if (!failures.length) {
+            notice(t("Verification passed."));
+            break;
+          }
+          if (round === MAX_VERIFY_ROUNDS - 1 || signal.aborted) {
+            notice(t("Verification still failing after {n} fix round(s). Run the commands manually to see why.", { n: MAX_VERIFY_ROUNDS }), "warn");
+            break;
+          }
+          await runtime.agent.run(verifyFollowup(failures), signal);
+        }
+      }
+      controller.current = null;
+      runHooks(runtime.config.hooks, "Stop", {}, { env: runtime.env, cwd: runtime.cwd }).then((outcome) => {
+        for (const w of outcome.warnings) notice(w, "warn");
+      }).catch(() => {
+      });
+      runtime.emitPlugins("Stop").catch(() => {
+      });
+      setTranscript(endTurn);
+      setBusy(false);
+      setCancelling(false);
+    },
+    [runtime, notice]
+  );
+  const toggleThinking = useCallback(() => {
+    const next = !showThinkingRef.current;
+    showThinkingRef.current = next;
+    setShowThinking(next);
+    if (maxSplitIdxRef.current > 0) refreshStatic();
+    try {
+      writeGlobalConfig({ thinkingVisible: next }, runtime.env);
+    } catch (error) {
+      notice(t("Could not save thinking visibility: {error}", { error: error.message }), "warn");
+    }
+  }, [runtime, notice, refreshStatic]);
+  const runSlashCommand = useCallback(
+    async (name, args) => {
+      switch (name) {
+        case "help":
+          notice(helpText(runtime));
+          return;
+        case "thinking":
+        case "t": {
+          const v = args.trim().toLowerCase();
+          if (v === "on" || v === "true") {
+            if (!showThinkingRef.current) toggleThinking();
+          } else if (v === "off" || v === "false") {
+            if (showThinkingRef.current) toggleThinking();
+          } else {
+            toggleThinking();
+          }
+          return;
+        }
+        case "output":
+        case "o":
+          setShowToolOutput((prev) => !prev);
+          if (maxSplitIdxRef.current > 0) refreshStatic();
+          return;
+        case "exit":
+        case "quit":
+          exit();
+          return;
+        case "clear":
+          controller.current?.abort();
+          controller.current = null;
+          setQueued([]);
+          setBusy(false);
+          setCancelling(false);
+          runtime.agent.clear();
+          setTokens(0);
+          setCachedTokens(0);
+          setTokensEstimated(false);
+          setShowToolOutput(false);
+          setTranscript({ done: [entry({ kind: "header" })], live: [] });
+          refreshStatic();
+          notice(t("Conversation cleared."));
+          return;
+        case "cost": {
+          const u = runtime.agent.totalUsage;
+          const cache = u.cachedInputTokens ?? 0;
+          notice(
+            t("{input} tokens in \xB7 {output} tokens out", { input: u.inputTokens.toLocaleString(locale()), output: u.outputTokens.toLocaleString(locale()) }) + (cache > 0 ? ` \xB7 ${t("{n} cached", { n: cache.toLocaleString(locale()) })}` : "") + ` \xB7 ${tokensEstimated ? "~" : ""}${t("{n} tokens in context", { n: runtime.agent.lastInputTokens.toLocaleString(locale()) })}`
+          );
+          return;
+        }
+        case "tasks":
+          notice(renderBackgroundTasks());
+          return;
+        case "compact": {
+          setBusy(true);
+          setStartedAt(Date.now());
+          controller.current = new AbortController();
+          try {
+            await runtime.agent.compact(controller.current.signal);
+          } catch (error) {
+            notice(t("Could not summarize: {error}", { error: error.message }), "error");
+          }
+          controller.current = null;
+          setBusy(false);
+          setCancelling(false);
+          return;
+        }
+        case "reasoning": {
+          const apply = (value) => {
+            try {
+              const level = parseReasoningLevel(value, "/reasoning");
+              const providerId2 = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
+              assertReasoningSupported(providerId2, level);
+              runtime.setReasoning(level);
+              writeGlobalConfig({ reasoning: level }, runtime.env);
+              setReasoning(level);
+              notice(t("Reasoning: {level} (saved as default)", { level }));
+            } catch (error) {
+              notice(error.message, "error");
+            }
+          };
+          if (args) {
+            apply(args);
+            return;
+          }
+          const providerId = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
+          const supported = supportedReasoningLevels(providerId);
+          setListPicker({
+            title: "Reasoning",
+            items: REASONING_LEVELS.map((level) => ({
+              id: level,
+              label: level === "auto" ? "Auto (model default)" : level.charAt(0).toUpperCase() + level.slice(1),
+              disabled: !supported.includes(level),
+              hint: supported.includes(level) ? void 0 : t("not supported by this provider")
+            })),
+            onPick: (id) => {
+              setListPicker(null);
+              if (id) apply(id);
+            }
+          });
+          return;
+        }
+        case "model": {
+          if (args) {
+            try {
+              runtime.setModel(args);
+              writeGlobalConfig({ model: args }, runtime.env);
+              setModelLabel(labelFor(runtime, args));
+              notice(t("Model: {model} (saved as default)", { model: args }));
+            } catch (error) {
+              notice(error.message, "error");
+            }
+            return;
+          }
+          try {
+            setPicker(await runtime.listModels());
+          } catch (error) {
+            notice(t("Cannot fetch the model list: {error}", { error: error.message }), "error");
+          }
+          return;
+        }
+        case "mcp": {
+          const installed = readMcpFile(globalMcpPath(runtime.home));
+          const states = runtime.mcp.states();
+          const items = [
+            ...CATALOG.map((c) => ({ name: c.name, description: t(c.description), installed: !!installed[c.name] })),
+            ...Object.keys(installed).filter((n) => !CATALOG.some((c) => c.name === n)).map((n) => ({ name: n, description: "(custom)", installed: true }))
+          ].map((i) => {
+            const s = states.find((st) => st.name === i.name);
+            return { ...i, status: s?.status ?? "off", error: s?.error };
+          });
+          setMcpMenu(items);
+          return;
+        }
+        case "new":
+          controller.current?.abort();
+          controller.current = null;
+          setQueued([]);
+          setBusy(false);
+          setCancelling(false);
+          runtime.newSession();
+          setTokens(0);
+          setCachedTokens(0);
+          setTokensEstimated(false);
+          setShowToolOutput(false);
+          setTranscript({ done: [entry({ kind: "header" })], live: [] });
+          refreshStatic();
+          notice(t("New session started. The previous session stays saved (/resume)."));
+          return;
+        case "session":
+          notice(
+            sessionText({
+              file: runtime.session.file,
+              started: runtime.startedAt,
+              messages: runtime.agent.messages.length,
+              usage: runtime.agent.totalUsage,
+              modelRef: runtime.modelRef
+            })
+          );
+          return;
+        case "resume": {
+          const others = Session.list(runtime.home, runtime.cwd).filter((s) => s.session.file !== runtime.session.file);
+          if (!others.length) {
+            notice(t("No other sessions in this folder yet."));
+            return;
+          }
+          setListPicker({
+            title: t("Continue a session"),
+            items: others.map((s) => ({
+              id: s.session.file,
+              label: `${s.mtime.toLocaleString(locale())}  ${s.preview || t("(empty)")}`,
+              hint: t("{n} messages", { n: s.session.load().length })
+            })),
+            onPick: (id) => {
+              setListPicker(null);
+              const chosen = others.find((s) => s.session.file === id);
+              if (!chosen) return;
+              runtime.resume(chosen.session);
+              setModelLabel(labelFor(runtime, runtime.modelRef));
+              setTokens(runtime.agent.lastInputTokens);
+              setCachedTokens(0);
+              setTokensEstimated(runtime.agent.lastInputEstimated);
+              setShowToolOutput(false);
+              setTranscript({ done: [entry({ kind: "header" }), ...replayEntries(chosen.session.loadHistory())], live: [] });
+              refreshStatic();
+            }
+          });
+          return;
+        }
+        case "status":
+          notice(
+            statusText({
+              version,
+              modelRef: runtime.modelRef,
+              providerLabel: runtime.providerLabel(),
+              mode: runtime.agent.permissions.mode,
+              cwd: runtime.cwd,
+              mcp: runtime.mcp.states(),
+              usage: runtime.agent.totalUsage,
+              lastInputTokens: runtime.agent.lastInputTokens,
+              contextWindow: runtime.agent.getContextWindow()
+            })
+          );
+          return;
+        case "agents":
+          notice(agentsText([...BUILTIN_AGENTS, ...runtime.agentDefs]));
+          return;
+        case "skills":
+          notice(skillsText(runtime.skills, runtime.commands));
+          return;
+        case "doctor": {
+          notice(t("Checking\u2026"));
+          const c = runtime.config;
+          notice(
+            await doctorText(
+              {
+                providers: Object.keys(c.providers).map((id) => ({ id, name: providerName(c, id), ready: hasKey(c, id, runtime.env) })),
+                mcp: runtime.mcp.states(),
+                activeProvider: runtime.providerLabel()
+              },
+              {
+                which: (cmd) => new Promise((done) => execFile3(process.platform === "win32" ? "where" : "which", [cmd], (error) => done(!error))),
+                nodeVersion: process.version,
+                listModels: () => runtime.agent.provider.listModels()
+              }
+            )
+          );
+          return;
+        }
+        case "permissions": {
+          const rules = runtime.agent.permissions.list();
+          if (!rules.length) {
+            notice(t("No saved permissions yet. Permissions from [a] answers and from the config will appear here."));
+            return;
+          }
+          setListPicker({
+            title: t("Active permissions (enter: revoke a session permission)"),
+            items: rules.map((r) => ({ id: r.rule, label: r.rule, hint: r.source === "config" ? "config" : t("this session") })),
+            onPick: (id) => {
+              setListPicker(null);
+              const rule = rules.find((r) => r.rule === id);
+              if (!rule) return;
+              if (rule.source === "config") notice(t("{rule} comes from the config/flag; remove it from ~/.bccli/config.json to revoke it.", { rule: rule.rule }), "warn");
+              else {
+                runtime.agent.permissions.revoke(rule.rule);
+                notice(t("Permission {rule} revoked.", { rule: rule.rule }));
+              }
+            }
+          });
+          return;
+        }
+        case "memory": {
+          if (!args) {
+            const files = instructionFiles(runtime.cwd, runtime.home);
+            notice(files.length ? files.map((f) => t("{path} ({lines} lines)", { path: f.path, lines: f.lines })).join("\n") : t("No AGENTS.md / BCCLI.md yet. Add one with /memory <text>."));
+            return;
+          }
+          const { global, text } = parseMemoryArgs(args);
+          if (!text) {
+            notice(t("Write the text: /memory global <text>."), "warn");
+            return;
+          }
+          const file = global ? join3(runtime.home, "BCCLI.md") : join3(runtime.cwd, "AGENTS.md");
+          try {
+            mkdirSync(dirname(file), { recursive: true });
+            appendMemory(file, text);
+          } catch (error) {
+            notice(t("Could not write {file}: {error}", { file, error: error.message }), "error");
+            return;
+          }
+          runtime.rebuildSystemPrompt();
+          notice(t("Added to {file}.", { file }));
+          return;
+        }
+        case "init":
+          void runTurn(INIT_PROMPT);
+          return;
+        case "language": {
+          if (!args) {
+            notice(t("Language: {lang}. Change it with /language en or /language id.", { lang: getLanguage() }));
+            return;
+          }
+          const wanted = parseLang(args);
+          if (!wanted) {
+            notice(t('Unknown language "{lang}". Use en or id.', { lang: args }), "warn");
+            return;
+          }
+          setLanguage(wanted);
+          try {
+            writeGlobalConfig({ language: wanted }, runtime.env);
+          } catch (error) {
+            notice(t("Could not save the language: {error}", { error: error.message }), "error");
+          }
+          notice(t("Language set to {lang} (saved as default).", { lang: wanted }));
+          return;
+        }
+        case "login": {
+          const id = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
+          const key = await ask(t("API key for {provider}", { provider: runtime.providerLabel() }), true);
+          if (!key) return;
+          const result = await runtime.addProviderKey(id, key);
+          if (!result.ok) {
+            notice(result.error, "error");
+            return;
+          }
+          runtime.setModel(runtime.modelRef);
+          notice(t("Key for {provider} saved \xB7 {n} models.", { provider: runtime.providerLabel(), n: result.models }));
+          return;
+        }
+        case "logout": {
+          const id = runtime.modelRef.slice(0, runtime.modelRef.indexOf("/"));
+          const removed = removeCredential(id, runtime.env);
+          const envName = runtime.config.providers[id]?.apiKeyEnv;
+          if (envName && runtime.env[envName]) {
+            notice(
+              removed ? t("Stored key deleted, but {env} is still set in the environment and is still used.", { env: envName }) : t("No stored key; {env} is still set in the environment and is still used.", { env: envName }),
+              "warn"
+            );
+            return;
+          }
+          if (!removed) {
+            notice(t("No stored key for {provider}.", { provider: runtime.providerLabel() }));
+            return;
+          }
+          try {
+            runtime.setModel(runtime.modelRef);
+          } catch (error) {
+            const fail = async () => {
+              throw error;
+            };
+            runtime.agent.provider = { chat: fail, listModels: fail };
+          }
+          notice(t("Key for {provider} deleted. Use /login or /provider to add one again.", { provider: runtime.providerLabel() }));
+          return;
+        }
+        case "diff":
+          notice(await gitDiff(runtime.cwd));
+          return;
+        case "worktree":
+          notice(await worktreeListText(runtime.cwd));
+          return;
+        case "pr":
+          void runTurn(prReviewPrompt(args));
+          return;
+        case "undo": {
+          const result = await runtime.checkpoints.undo();
+          if (!result) {
+            notice(t("No file edits to undo."));
+            return;
+          }
+          const rel = (p) => relative2(runtime.cwd, p) || p;
+          notice(
+            [
+              result.failed.length ? t("Could not restore: {files}", { files: result.failed.map(rel).join(", ") }) : "",
+              result.restored.length ? t("Restored: {files}", { files: result.restored.map(rel).join(", ") }) : "",
+              result.deleted.length ? t("Deleted (new files): {files}", { files: result.deleted.map(rel).join(", ") }) : "",
+              result.skipped.length ? t("Too large to back up, left unchanged: {files}", { files: result.skipped.map(rel).join(", ") }) : "",
+              t("Note: changes made through bash commands cannot be undone.")
+            ].filter(Boolean).join("\n")
+          );
+          return;
+        }
+        case "redo": {
+          const result = await runtime.checkpoints.redo();
+          if (!result) {
+            notice(t("No file edits to redo."));
+            return;
+          }
+          const rel = (p) => relative2(runtime.cwd, p) || p;
+          notice(
+            [
+              result.failed.length ? t("Could not restore: {files}", { files: result.failed.map(rel).join(", ") }) : "",
+              result.restored.length ? t("Re-applied: {files}", { files: result.restored.map(rel).join(", ") }) : "",
+              result.deleted.length ? t("Deleted again: {files}", { files: result.deleted.map(rel).join(", ") }) : "",
+              result.skipped.length ? t("Too large to back up, left unchanged: {files}", { files: result.skipped.map(rel).join(", ") }) : ""
+            ].filter(Boolean).join("\n")
+          );
+          return;
+        }
+        case "rewind": {
+          const parsed = Number.parseInt(args.trim(), 10);
+          const result = await runtime.rewindTurns(Number.isFinite(parsed) && parsed > 0 ? parsed : 1);
+          if (!result) {
+            notice(t("Nothing to rewind."));
+            return;
+          }
+          setTranscript((tr) => {
+            const userIndices = [];
+            tr.done.forEach((e, idx) => {
+              if (e.kind === "user") userIndices.push(idx);
+            });
+            const cutIdx = userIndices[Math.max(0, userIndices.length - result.turns)];
+            return cutIdx !== void 0 ? { done: tr.done.slice(0, cutIdx), live: [] } : tr;
+          });
+          refreshStatic();
+          const rel = (p) => relative2(runtime.cwd, p) || p;
+          notice(
+            [
+              result.failed.length ? t("Could not restore: {files}", { files: result.failed.map(rel).join(", ") }) : "",
+              result.restored.length ? t("Restored: {files}", { files: result.restored.map(rel).join(", ") }) : "",
+              result.deleted.length ? t("Deleted (new files): {files}", { files: result.deleted.map(rel).join(", ") }) : "",
+              result.skipped.length ? t("Too large to back up, left unchanged: {files}", { files: result.skipped.map(rel).join(", ") }) : "",
+              t("Rewound {n} turn(s): the conversation continues from before them.", { n: result.turns })
+            ].filter(Boolean).join("\n")
+          );
+          return;
+        }
+        case "copy": {
+          const last = runtime.agent.messages.findLast((m) => m.role === "assistant" && typeof m.content === "string" && m.content.trim());
+          if (!last || typeof last.content !== "string") {
+            notice(t("No answer to copy yet."));
+            return;
+          }
+          process.stdout.write(osc52(last.content, !!process.env.TMUX));
+          const file = join3(runtime.home, "last-answer.md");
+          mkdirSync(runtime.home, { recursive: true });
+          writeFileSync(file, last.content);
+          notice(t("Copied to the clipboard (if the terminal supports OSC 52) and saved to {file}.", { file }));
+          return;
+        }
+        case "export": {
+          const name2 = args || `bccli-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace(/[:T]/g, "-")}.md`;
+          const file = resolve2(runtime.cwd, name2);
+          if (existsSync3(file)) {
+            const answer2 = await ask(t("{file} already exists. Overwrite? (y/N)", { file }));
+            if (!answer2 || !/^y(a|es)?$/i.test(answer2.trim())) {
+              notice(t("Export cancelled."));
+              return;
+            }
+          }
+          try {
+            writeFileSync(file, exportMarkdown(runtime.agent.messages, t("BCCLI session {when}", { when: runtime.startedAt.toLocaleString(locale()) })));
+          } catch (error) {
+            notice(t("Could not write {file}: {error}", { file, error: error.message }), "error");
+            return;
+          }
+          notice(t("Conversation saved to {file}.", { file }));
+          return;
+        }
+        case "provider": {
+          const c = runtime.config;
+          setProviderMenu(
+            Object.keys(c.providers).map((id) => ({ id, name: providerName(c, id), ready: hasKey(c, id, runtime.env), baseURL: c.providers[id].baseURL }))
+          );
+          return;
+        }
+        case "config": {
+          const c = runtime.config;
+          const applySetting = (key, val) => {
+            if (key === "theme") writeGlobalConfig({ theme: val }, runtime.env);
+            else if (key === "editor" && (val === "emacs" || val === "vim")) writeGlobalConfig({ editor: val }, runtime.env);
+            else if (key === "repoMap") writeGlobalConfig({ repoMap: val === "true" || val === "on" }, runtime.env);
+            else if (key === "thinkingVisible") {
+              const next = val === "true" || val === "on";
+              writeGlobalConfig({ thinkingVisible: next }, runtime.env);
+              showThinkingRef.current = next;
+              setShowThinking(next);
+              refreshStatic();
+            } else if (key === "thinkingClickCollapse") writeGlobalConfig({ thinkingClickCollapse: val === "true" || val === "on" }, runtime.env);
+            else if (key === "sandbox" && (val === "on" || val === "off")) writeGlobalConfig({ sandbox: val }, runtime.env);
+            else if (key === "networkPolicy" && (val === "allow" || val === "offline")) writeGlobalConfig({ networkPolicy: val }, runtime.env);
+            else return false;
+            runtime.reloadConfig();
+            setConfigRev((n) => n + 1);
+            notice(`${key} = ${val}`);
+            return true;
+          };
+          if (args.trim()) {
+            const [k2, v] = args.trim().split(/\s+/);
+            if (k2 && v && applySetting(k2, v)) return;
+          }
+          setListPicker({
+            title: "Config",
+            items: [
+              { id: `editor:${c.editor === "vim" ? "emacs" : "vim"}`, label: `editor: ${c.editor}`, hint: "toggle emacs/vim" },
+              { id: `repoMap:${!c.repoMap}`, label: `repoMap: ${c.repoMap}`, hint: "toggle true/false" },
+              { id: `thinkingVisible:${!c.thinkingVisible}`, label: `thinkingVisible: ${!!c.thinkingVisible}`, hint: "toggle true/false" },
+              { id: `thinkingClickCollapse:${!c.thinkingClickCollapse}`, label: `thinkingClickCollapse: ${!!c.thinkingClickCollapse}`, hint: "toggle true/false" },
+              { id: `sandbox:${c.sandbox === "on" ? "off" : "on"}`, label: `sandbox: ${c.sandbox}`, hint: "toggle on/off" },
+              { id: `networkPolicy:${c.networkPolicy === "offline" ? "allow" : "offline"}`, label: `networkPolicy: ${c.networkPolicy ?? "allow"}`, hint: "toggle allow/offline" }
+            ],
+            onPick: (picked) => {
+              setListPicker(null);
+              if (!picked) return;
+              const [k2, v] = picked.split(":");
+              if (k2 && v) applySetting(k2, v);
+            }
+          });
+          return;
+        }
+        default:
+          notice(t("Unknown command: /{name}. Type /help.", { name }), "warn");
+      }
+    },
+    [runtime, notice, exit, version, runTurn, ask, refreshStatic, toggleThinking, tokensEstimated]
+  );
+  const runSlash = useCallback(
+    (name, args) => runSlashCommand(name, args).catch((error) => notice(`/${name}: ${error.message}`, "error")),
+    [runSlashCommand, notice]
+  );
+  const submit = useCallback(
+    (text) => {
+      setHistory((h) => [...h, text]);
+      if (text.startsWith("#") && text.slice(1).trim()) {
+        void runSlash("memory", text.slice(1).trim());
+        return;
+      }
+      if (text.startsWith("!") && text.slice(1).trim()) {
+        const cmd = text.slice(1).trim();
+        setTranscript((tr) => ({ ...tr, done: [...tr.done, entry({ kind: "user", text })] }));
+        setBusy(true);
+        setStartedAt(Date.now());
+        const ctrl = new AbortController();
+        controller.current = ctrl;
+        const shell = resolveShell({ platform: process.platform, env: runtime.env, exists: existsSync3 });
+        void runCommand(cmd, { cwd: runtime.cwd, timeoutMs: 6e4, signal: ctrl.signal, shell }).then((r) => {
+          const out = r.output.trim() || "(no output)";
+          notice(`$ ${cmd}
+${out}`, r.exitCode ? "error" : "info");
+          const ctxMsg = { role: "user", content: `Local shell command executed:
+$ ${cmd}
+${out}` };
+          runtime.agent.messages.push(ctxMsg);
+          runtime.session.append(ctxMsg);
+        }).finally(() => {
+          controller.current = null;
+          setBusy(false);
+          setCancelling(false);
+        });
+        return;
+      }
+      const slash = parseSlash(text);
+      if (!slash) {
+        void runTurn(text);
+        return;
+      }
+      const command = runtime.commands.find((c) => c.name.toLowerCase() === slash.name);
+      const skill = runtime.skills.find((s) => s.name.toLowerCase() === slash.name);
+      if (SLASH_COMMANDS.some((b) => b.name === slash.name) || slash.name === "t" || slash.name === "output" || slash.name === "o" || slash.name === "quit" || !command && !skill) void runSlash(slash.name, slash.args);
+      else if (command) void runTurn(expandCommand(command, slash.args));
+      else if (skill) {
+        let body;
+        try {
+          body = parseFrontmatter(readFileSync2(skill.file, "utf8")).body;
+        } catch (error) {
+          notice(t("Skill {name} cannot be read: {error}", { name: skill.name, error: error.code ?? error.message }), "error");
+          return;
+        }
+        void runTurn(`${body}
+
+ARGUMENTS: ${slash.args}`);
+      }
+    },
+    [runSlash, runTurn, runtime, notice]
+  );
+  const onPrompt = useCallback(
+    (text) => {
+      if (!busy) {
+        submit(text);
+        return;
+      }
+      if (text.startsWith("#") && text.slice(1).trim()) {
+        submit(text);
+        return;
+      }
+      const slash = parseSlash(text);
+      if (slash) {
+        const turnMutating = /* @__PURE__ */ new Set(["init", "pr", "compact", "rewind", "undo", "redo", "resume"]);
+        const isCustomTurn = !SLASH_COMMANDS.some((b) => b.name === slash.name) && slash.name !== "t" && slash.name !== "output" && slash.name !== "o" && slash.name !== "quit" && (runtime.commands.some((c) => c.name.toLowerCase() === slash.name) || runtime.skills.some((s) => s.name.toLowerCase() === slash.name));
+        if (!turnMutating.has(slash.name) && !isCustomTurn) {
+          submit(text);
+          return;
+        }
+      }
+      setQueued((q) => [...q, text]);
+    },
+    [busy, submit, runtime]
+  );
+  useEffect3(() => {
+    if (busy || pending || planAsk || !queued.length) return;
+    const [next, ...rest] = queued;
+    setQueued(rest);
+    submit(next);
+  }, [busy, pending, planAsk, queued, submit]);
+  const initialSent = useRef2(false);
+  useEffect3(() => {
+    if (initialPrompt && !initialSent.current) {
+      initialSent.current = true;
+      submit(initialPrompt);
+    }
+  }, [initialPrompt, submit]);
+  useEffect3(() => {
+    if (!isRealTty(stdout)) return;
+    stdout.write("\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?2004h");
+    return () => {
+      stdout.write("\x1B[?1000l\x1B[?1002l\x1B[?1003l\x1B[?1006l\x1B[?2004l");
+    };
+  }, [stdout]);
+  useEffect3(() => {
+    const modalOpen = !!(pending || planAsk || picker || listPicker || mcpMenu || providerMenu || prompt);
+    if (!runtime.config.thinkingClickCollapse || !busy && !hasThinking || modalOpen || !isTtyStream(stdin) || !isTtyStream(stdout)) return;
+    let click;
+    let mouseBuffer = "";
+    let wheelTimer;
+    const onData = (data) => {
+      const chunk = String(data);
+      if (hasMouseWheelSequence(chunk)) {
+        stdout.write("\x1B[?1000l\x1B[?1006l");
+        if (wheelTimer) clearTimeout(wheelTimer);
+        wheelTimer = setTimeout(() => {
+          stdout.write("\x1B[?1000h\x1B[?1006h");
+        }, 1200);
+      }
+      mouseBuffer += chunk;
+      const reports = parseThinkingReports(mouseBuffer);
+      mouseBuffer = reports.rest.slice(-80);
+      for (const report of reports.events) {
+        if (report.type === "mouse") {
+          click = report.press;
+          stdout.write("\x1B[6n");
+        } else if (click && liveRootRef.current) {
+          const current = click;
+          click = void 0;
+          const root = measureElement(liveRootRef.current);
+          const candidates = [];
+          if (thinkingTargetRef.current) candidates.push(thinkingTargetRef.current);
+          if (spinnerTargetRef.current) candidates.push(spinnerTargetRef.current);
+          for (const el of thinkingEntryRefs.current.values()) {
+            if (!candidates.includes(el)) candidates.push(el);
+          }
+          if (candidates.some((el) => clickedThinking(current, report.cursor.row, root.height, measureElement(el)))) {
+            toggleThinking();
+          }
+        }
+      }
+    };
+    stdin.on("data", onData);
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    return () => {
+      if (wheelTimer) clearTimeout(wheelTimer);
+      stdin.off("data", onData);
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+    };
+  }, [busy, hasThinking, pending, planAsk, picker, listPicker, mcpMenu, providerMenu, prompt, stdin, stdout, toggleThinking, runtime.config.thinkingClickCollapse]);
+  useInput9((input, key) => {
+    const modalOpen = !!(pending || planAsk || picker || listPicker || mcpMenu || providerMenu || prompt);
+    if (key.tab && key.shift) {
+      const next = nextMode(runtime.agent.permissions.mode);
+      runtime.agent.permissions.mode = next;
+      setMode(next);
+    } else if (key.escape && busy && !modalOpen) {
+      controller.current?.abort();
+      setCancelling(true);
+      if (queued.length) {
+        setQueued([]);
+        notice(t("{n} queued messages cancelled.", { n: queued.length }), "warn");
+      }
+    } else if (matchKeybind(runtime.config.keybinds.pasteImage, input, key)) {
+      void (async () => {
+        const path = await grabClipboardImage({ platform: process.platform, tmpdir: tmpdir(), now: /* @__PURE__ */ new Date() });
+        if (path) {
+          setInjected((prev) => ({ text: `${path} `, n: (prev?.n ?? 0) + 1 }));
+          notice(t("Clipboard image saved to {path} \u2014 the path is inserted in the input; the model sees it when you send.", { path }));
+        } else {
+          notice(t("No image on the clipboard."), "warn");
+        }
+      })();
+    } else if (matchKeybind(runtime.config.keybinds.thinking, input, key) || key.meta && !key.ctrl && input.toLowerCase() === "t") {
+      toggleThinking();
+    } else if (matchKeybind(runtime.config.keybinds.toolOutput, input, key) || key.meta && !key.ctrl && input.toLowerCase() === "o") {
+      setShowToolOutput((prev) => !prev);
+      if (maxSplitIdxRef.current > 0) refreshStatic();
+    } else if (key.ctrl && input.toLowerCase() === "l") {
+      refreshStatic();
+    }
+  });
+  const pickMcp = async (name) => {
+    const item = mcpMenu?.find((i) => i.name === name);
+    setMcpMenu(null);
+    if (!item) return;
+    if (item.installed) {
+      removeGlobalServer(runtime.home, item.name);
+      await runtime.mcp.remove(item.name);
+      notice(t("MCP {name} removed.", { name: item.name }));
+      return;
+    }
+    const entry2 = CATALOG.find((c) => c.name === item.name);
+    if (!entry2) return;
+    const values = {};
+    for (const input of entry2.inputs ?? []) {
+      const v = await ask(t(input.label), !!input.secret);
+      if (!v) return;
+      values[input.key] = v;
+    }
+    const config = fillTemplate(entry2.config, values);
+    addGlobalServer(runtime.home, entry2.name, config);
+    notice(t("MCP {name} installed, connecting\u2026", { name: entry2.name }));
+    await runtime.mcp.add({ name: entry2.name, config, source: "global" });
+    const state = runtime.mcp.states().find((s) => s.name === entry2.name);
+    if (state?.status === "ready") notice(t("MCP {name} active \xB7 {n} tools.", { name: entry2.name, n: state.tools }));
+    else notice(t("MCP {name} failed: {error}", { name: entry2.name, error: state?.error ?? t("unknown") }), "error");
+  };
+  const pickProvider = async (id) => {
+    setProviderMenu(null);
+    if (!id) return;
+    let target = id;
+    if (id === "custom") {
+      const name = await ask("Id provider (huruf kecil, mis. corp)");
+      const url = name ? await ask("Base URL OpenAI-compatible") : void 0;
+      if (!name || !url) return;
+      writeGlobalConfig({ providers: { [name]: { baseURL: url } } }, runtime.env);
+      runtime.reloadConfig();
+      target = name;
+    }
+    const c = runtime.config;
+    const keyless = !c.providers[target].apiKeyEnv && PRESETS.some((p) => p.id === target);
+    if (!hasKey(c, target, runtime.env) || id === "custom") {
+      const key = keyless ? "" : await ask(t("API key for {provider}", { provider: providerName(c, target) }), true);
+      if (key === void 0) return;
+      const result = await runtime.addProviderKey(target, key);
+      if (!result.ok) {
+        notice(result.error, "error");
+        return;
+      }
+      notice(`${providerName(c, target)} siap \xB7 ${result.models} model.`);
+    }
+    setPicker(await runtime.listModels(target));
+  };
+  const answer = (a) => {
+    if (a === "all") {
+      for (const item of asks) item.resolve("all");
+      setAsks([]);
+      setMode("allowAll");
+      return;
+    }
+    pending?.resolve(a);
+    setAsks((q) => q.slice(1));
+  };
+  const capLive = (raw, rows) => capLiveMarkdown(raw, { isRealTty: realStdout, maxRows: rows, width: liveWidth });
+  const cwd = runtime.cwd.startsWith(homedir()) ? `~${runtime.cwd.slice(homedir().length)}` : runtime.cwd;
+  const renderEntry = (e, liveRows) => {
+    const isLive = transcript.live.some((le) => le.id === e.id);
+    if (isLive && liveRows === 0) return null;
+    switch (e.kind) {
+      case "header":
+        return /* @__PURE__ */ jsx16(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Text16, { children: [
+          /* @__PURE__ */ jsx16(Text16, { color: color(ACCENT), bold: true, children: " \u273B " }),
+          /* @__PURE__ */ jsx16(Text16, { bold: true, children: `BCCLI ${version}` }),
+          /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: ` \xB7 ${runtime.modelRef} (${runtime.providerLabel()}) \xB7 ${cwd}` })
+        ] }) }, e.id);
+      case "user":
+        return /* @__PURE__ */ jsx16(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: `> ${e.text}` }) }, e.id);
+      case "assistant": {
+        const displayText = isLive ? capLive(e.text, liveRows ?? liveRowBudget) : e.text;
+        if (e.cont) {
+          return displayText ? /* @__PURE__ */ jsx16(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsx16(Markdown, { text: displayText }) }, e.id) : null;
+        }
+        if (!displayText.trim()) return null;
+        return /* @__PURE__ */ jsxs12(Box13, { marginTop: 1, children: [
+          /* @__PURE__ */ jsx16(Text16, { color: color(ACCENT), children: "\u25CF " }),
+          /* @__PURE__ */ jsx16(Markdown, { text: displayText.replace(/^\s+/, "") })
+        ] }, e.id);
+      }
+      case "thinking": {
+        const text = e.text.trim();
+        if (!text) return null;
+        const allLines = text.split("\n");
+        const lines = allLines.length;
+        const shownText = isLive && showThinking ? capLiveText(text, { isRealTty: realStdout, maxRows: (liveRows ?? liveRowBudget) - 3, width: liveWidth }) : text;
+        const isTarget = e.id === lastThinkingEntryId;
+        return /* @__PURE__ */ jsxs12(
+          Box13,
+          {
+            ref: (el) => {
+              if (isTarget) thinkingTargetRef.current = el;
+              if (el) thinkingEntryRefs.current.set(e.id, el);
+              else thinkingEntryRefs.current.delete(e.id);
+            },
+            marginTop: 1,
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsxs12(Box13, { flexDirection: "row", children: [
+                /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: showThinking ? t("\u273B Thinking") : t("\u273B Thinking \xB7 {n} lines", { n: lines }) }),
+                /* @__PURE__ */ jsxs12(Text16, { dimColor: true, children: [
+                  " \xB7 ",
+                  runtime.config.keybinds.thinking.spec,
+                  " / tab",
+                  runtime.config.thinkingClickCollapse ? ` \xB7 ${t("click to toggle")}` : ""
+                ] })
+              ] }),
+              showThinking ? /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingLeft: 2, children: [
+                /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("Model: {model} \xB7 reasoning: {level}", { model: runtime.modelRef, level: reasoning }) }),
+                /* @__PURE__ */ jsx16(Text16, { dimColor: true, italic: true, children: shownText })
+              ] }) : null
+            ]
+          },
+          e.id
+        );
+      }
+      case "tool":
+        return /* @__PURE__ */ jsx16(ToolBlock, { tool: e.tool, target: e.target, output: e.output, display: e.display, isError: e.isError, done: e.done, expanded: showToolOutput, sub: e.sub, moreBind: runtime.config.keybinds.toolOutput.spec }, e.id);
+      case "notice":
+        return /* @__PURE__ */ jsx16(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx16(Text16, { color: e.tone === "error" ? color("red") : e.tone === "warn" ? color("yellow") : void 0, dimColor: e.tone === "info", children: e.text }) }, e.id);
+    }
+  };
+  const activeToolEntry = transcript.live.findLast((e) => e.kind === "tool" && !e.done);
+  const activeSub = activeToolEntry?.sub?.findLast((s) => !s.done);
+  const activeTarget = (activeSub ? `${toolLabel(activeSub.tool)} ${activeSub.target}` : activeToolEntry?.target ?? "").replace(/\s+/g, " ").trim();
+  const activeSpinnerSummary = activeToolEntry ? `${toolLabel(activeToolEntry.tool)}${activeTarget ? ` ${activeTarget.length > 20 ? `${activeTarget.slice(0, 20)}\u2026` : activeTarget}` : ""}` : "";
+  const activeToolSummary = activeToolEntry ? `${toolLabel(activeToolEntry.tool)}${activeTarget ? ` ${activeTarget.length > 68 ? `${activeTarget.slice(0, 68)}\u2026` : activeTarget}` : ""}` : "";
+  return /* @__PURE__ */ jsxs12(Box13, { ref: liveRootRef, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx16(Static, { items: staticDone, children: (e) => renderEntry(e) }, `static-${staticKey}`),
+    activeTurnDone.map((e) => renderEntry(e)),
+    transcript.live.map((e, i) => renderEntry(e, liveCaps[i])),
+    busy && !pending && !planAsk ? /* @__PURE__ */ jsxs12(
+      Box13,
+      {
+        ref: (el) => {
+          spinnerTargetRef.current = el;
+          if (lastThinkingEntryId === void 0) thinkingTargetRef.current = el;
+        },
+        marginTop: 1,
+        flexDirection: "column",
+        children: [
+          /* @__PURE__ */ jsxs12(Box13, { flexDirection: "row", children: [
+            /* @__PURE__ */ jsx16(Spinner, { label: cancelling ? t("Cancelling") : activeSpinnerSummary ? `${t("Thinking")} \xB7 ${activeSpinnerSummary}` : t("Thinking"), startedAt }),
+            /* @__PURE__ */ jsxs12(Text16, { dimColor: true, children: [
+              " \xB7 ",
+              runtime.config.keybinds.thinking.spec,
+              " / tab",
+              runtime.config.thinkingClickCollapse ? ` \xB7 ${t("click to toggle")}` : ""
+            ] })
+          ] }),
+          showThinking && lastThinkingEntryId === void 0 ? /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", paddingLeft: 2, children: [
+            /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("Model: {model} \xB7 reasoning: {level}", { model: runtime.modelRef, level: reasoning }) }),
+            activeToolSummary ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: `\u25B6 ${activeToolSummary}` }) : null,
+            !activeToolSummary ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("No reasoning summary received yet; tool activity remains visible above.") }) : null
+          ] }) : null
+        ]
+      }
+    ) : null,
+    pending ? /* @__PURE__ */ jsx16(PermissionPrompt, { request: pending.request, onAnswer: answer }, pending.id) : null,
+    picker ? /* @__PURE__ */ jsx16(
+      ModelPicker,
+      {
+        groups: picker,
+        current: runtime.modelRef,
+        onPick: (m) => {
+          setPicker(null);
+          if (m) void runSlash("model", m);
+        }
+      }
+    ) : null,
+    listPicker ? /* @__PURE__ */ jsx16(ListPicker, { title: listPicker.title, items: listPicker.items, onPick: listPicker.onPick }) : null,
+    mcpMenu ? /* @__PURE__ */ jsx16(McpMenu, { items: mcpMenu, onPick: (n) => void pickMcp(n) }) : null,
+    providerMenu ? /* @__PURE__ */ jsx16(ProviderMenu, { entries: providerMenu, onPick: (id) => void pickProvider(id) }) : null,
+    prompt ? /* @__PURE__ */ jsx16(
+      LinePrompt,
+      {
+        label: prompt.label,
+        mask: prompt.mask,
+        onSubmit: (v) => {
+          setPrompt(null);
+          prompt.resolve(v);
+        },
+        onCancel: () => {
+          setPrompt(null);
+          prompt.resolve(void 0);
+        }
+      }
+    ) : null,
+    planAsk ? /* @__PURE__ */ jsx16(
+      PlanApproval,
+      {
+        plan: planAsk.plan,
+        onAnswer: (d) => {
+          planAsk.resolve(d);
+          setPlanAsk(null);
+          if (d !== "no") setMode(d);
+        }
+      }
+    ) : null,
+    /* @__PURE__ */ jsx16(TodoList, { items: todos }),
+    queued.map((q, i) => /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("  \u23F3 queued: {q}", { q }) }, `${i}-${q}`)),
+    /* @__PURE__ */ jsx16(PromptInput, { disabled: !!pending || !!picker || !!providerMenu || !!prompt || !!planAsk || !!mcpMenu || !!listPicker, history, cwd: runtime.cwd, onSubmit: onPrompt, onEmptyTab: toggleThinking, extraCommands, injected, vim: runtime.config.editor === "vim" }),
+    /* @__PURE__ */ jsx16(StatusBar, { mode, tokens, cached: cachedTokens, estimated: tokensEstimated, busy, model: modelLabel, reasoning })
+  ] });
+}
+
+// src/ui/stdinFilter.ts
+var X10_START = "\x1B[M";
+var X10_PAYLOAD = 3;
+function stripLegacyMouseReports(chunk, carry = "") {
+  const input = carry + chunk;
+  let text = "";
+  let index = 0;
+  while (index < input.length) {
+    if (input[index] === "\x1B") {
+      const remaining = input.length - index;
+      if (remaining < X10_START.length) {
+        const tail = input.slice(index);
+        if (X10_START.startsWith(tail)) return { text, carry: tail };
+      } else if (input.startsWith(X10_START, index)) {
+        if (remaining < X10_START.length + X10_PAYLOAD) return { text, carry: input.slice(index) };
+        index += X10_START.length + X10_PAYLOAD;
+        continue;
+      }
+    }
+    text += input[index];
+    index++;
+  }
+  return { text, carry: "" };
+}
+function installLegacyMouseFilter(source) {
+  const mutable = source;
+  const original = mutable.read.bind(source);
+  let carry = "";
+  mutable.read = (size) => {
+    const chunk = original(size);
+    if (chunk === null) return null;
+    const stripped = stripLegacyMouseReports(String(chunk), carry);
+    carry = stripped.carry;
+    return stripped.text;
+  };
+  return () => {
+    mutable.read = original;
+  };
+}
+
+// src/ui/index.tsx
+import { jsx as jsx17 } from "react/jsx-runtime";
+async function startInteractive(rt, opts) {
+  if (opts.resume) {
+    const { Session: Session2 } = await import("./session-YM36TGU7.js");
+    const list = Session2.list(rt.home, rt.cwd).slice(0, 20);
+    if (!list.length) console.log(t("No sessions in this folder yet; starting a new one."));
+    else {
+      list.forEach((s, i) => {
+        console.log(`${String(i + 1).padStart(2)}. ${s.mtime.toLocaleString(locale())}  ${s.preview}`);
+      });
+      const { createInterface } = await import("readline/promises");
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = Number(await rl.question(t("Session number (enter = new): ")));
+      rl.close();
+      process.stdin.resume();
+      const chosen = list[answer - 1];
+      if (chosen) rt.resume(chosen.session);
+    }
+  }
+  const { serversToStart, setProjectTrust } = await import("./config-OVWCUVY7.js");
+  const plan = serversToStart(rt.home, rt.cwd);
+  if (plan.needTrust.length) {
+    const { createInterface } = await import("readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    for (const s of plan.needTrust) {
+      const what = s.config.type === "http" ? s.config.url : [s.config.command, ...s.config.args ?? []].join(" ");
+      const answer = (await rl.question(t('This repo wants to run the MCP server "{name}" ({what}). Allow? [y/N] ', { name: s.name, what }))).trim().toLowerCase();
+      setProjectTrust(rt.home, rt.cwd, s.name, answer === "y", s.config);
+      if (answer === "y") plan.start.push(s);
+    }
+    rl.close();
+    process.stdin.resume();
+  }
+  void rt.startMcp(plan.start).catch((error) => {
+    console.error(t("Could not start MCP servers: {error}", { error: error instanceof Error ? error.message : String(error) }));
+  });
+  const disposeMouseFilter = process.stdin.isTTY ? installLegacyMouseFilter(process.stdin) : void 0;
+  const instance = render(/* @__PURE__ */ jsx17(App, { runtime: rt, initialPrompt: opts.initialPrompt, version: opts.version, updateMessage: opts.updateMessage }), { exitOnCtrlC: true });
+  await instance.waitUntilExit();
+  disposeMouseFilter?.();
+  await rt.mcp.stop();
+  return 0;
+}
+export {
+  startInteractive
+};