@botconnector/bccli 0.4.0-beta.5 → 0.4.0-beta.51

package/dist/ui-6HJVYI46.js

@@ -0,0 +1,2370 @@
+#!/usr/bin/env node
+import {
+  CATALOG,
+  fillTemplate
+} from "./chunk-4WVIPZFV.js";
+import {
+  MAX_VERIFY_ROUNDS,
+  runVerify,
+  toolLabel,
+  verifyFollowup,
+  worktreeListText
+} from "./chunk-TQWCM5RO.js";
+import {
+  BUILTIN_AGENTS,
+  appendMemory,
+  ignorePatterns,
+  instructionFiles,
+  normalizeGlobPath,
+  parseFrontmatter,
+  parseMemoryArgs,
+  renderBackgroundTasks,
+  runHooks,
+  validateGlobPattern
+} from "./chunk-YIYX3FFS.js";
+import "./chunk-PSO7R5AD.js";
+import {
+  nextMode
+} from "./chunk-GAFJEQTJ.js";
+import {
+  hasKey,
+  providerName,
+  writeGlobalConfig
+} from "./chunk-2QYHSESB.js";
+import {
+  Session
+} from "./chunk-F6ACN47V.js";
+import {
+  contentText
+} from "./chunk-R4BJBTWC.js";
+import {
+  REASONING_LEVELS,
+  assertReasoningSupported,
+  parseReasoningLevel,
+  supportedReasoningLevels
+} from "./chunk-SNKVS26H.js";
+import {
+  addGlobalServer,
+  globalMcpPath,
+  readMcpFile,
+  removeGlobalServer
+} from "./chunk-H73FO5YK.js";
+import {
+  ACCENT,
+  PRESETS,
+  color,
+  matchKeybind,
+  removeCredential
+} from "./chunk-NDEJUL44.js";
+import {
+  getLanguage,
+  locale,
+  parseLang,
+  setLanguage,
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/ui/index.tsx
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { execFile as execFile3 } from "child_process";
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { dirname, join as join3, relative, resolve } 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, useState as useState8 } from "react";
+
+// src/commands.ts
+var SLASH_COMMANDS = [
+  { name: "help", description: "list of commands and shortcuts" },
+  { 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: "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((resolve2) => {
+    execFile(
+      bin,
+      args,
+      { cwd, maxBuffer: 20 * 1024 * 1024 },
+      (error, stdout, stderr) => resolve2({ 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;
+  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`,
+    t("Context: ~{pct}% of 128k", { pct: Math.round(s.lastInputTokens / 128e3 * 100) })
+  ].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 wrappedRows = body.some((b) => b.height > 1);
+  const out = [...head.lines, rule];
+  body.forEach((b, i) => {
+    if (wrappedRows && i > 0) out.push(rule);
+    out.push(...b.lines);
+  });
+  return out;
+}
+
+// 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);
+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 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, (stdout?.columns ?? 80) - 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";
+function EditableText({ state, mask = false, showCursor = true }) {
+  const view = mask ? masked(state) : state;
+  if (!showCursor) return /* @__PURE__ */ jsx2(Fragment, { children: view.value });
+  const { before, at, after } = splitAtCursor(view);
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    before,
+    /* @__PURE__ */ jsx2(Text2, { inverse: true, children: at }),
+    after
+  ] });
+}
+
+// src/ui/focusReport.ts
+var isFocusReport = (input) => input === "[I" || input === "[O";
+
+// 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, 46);
+}
+function isMouseControlInput(input) {
+  return /^\[<(?:\d+;){2}\d+[mM]$/.test(input) || /^\[(?:\d+;)\d+R$/.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 (isMouseControlInput(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 && !isFocusReport(input)) {
+      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 (key.upArrow) setIndex(Math.max(0, cursor - 1));
+    else if (key.downArrow) setIndex(Math.min(shown.length - 1, cursor + 1));
+    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 && !isFocusReport(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 cursor = selectable[Math.min(index, selectable.length - 1)] ?? -1;
+  useInput3((input, key) => {
+    if (key.upArrow) setIndex((i) => Math.max(0, i - 1));
+    else if (key.downArrow) setIndex((i) => Math.min(selectable.length - 1, i + 1));
+    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 && !isFocusReport(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.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";
+
+// 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" };
+function PermissionPrompt({
+  request,
+  onAnswer
+}) {
+  useInput5((input, key) => {
+    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(", ") });
+  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 })}` }),
+    request.preview ? /* @__PURE__ */ jsx8(DiffView, { diff: request.preview }) : 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, useState as useState5 } from "react";
+
+// src/ui/complete.ts
+import { globSync } from "fs";
+import { statSync } from "fs";
+import { join } from "path";
+function completeFile(value, cwd) {
+  const match = /(^|\s)@([^\s]*)$/.exec(value);
+  if (!match) return value;
+  const prefix = match[2];
+  const escaped = prefix.replace(/([*?[\]{}()!])/g, "\\$1");
+  const pattern = `${escaped}*`;
+  if (validateGlobPattern(pattern)) return value;
+  const found = globSync(pattern, { cwd, exclude: ignorePatterns(cwd) }).map((entry2) => {
+    const normalized = normalizeGlobPath(entry2);
+    try {
+      return statSync(join(cwd, entry2)).isDirectory() ? `${normalized}/` : normalized;
+    } catch {
+      return normalized;
+    }
+  }).sort();
+  if (!found.length) return value;
+  const pick = found[0];
+  return `${value.slice(0, value.length - prefix.length)}${pick}${pick.endsWith("/") ? "" : " "}`;
+}
+
+// src/ui/vim.ts
+var clamp = (s) => ({ value: s.value, cursor: Math.min(s.cursor, Math.max(0, s.value.length - 1)) });
+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") {
+    if (input === "d") return { state: deleteLine(s), mode, 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, handled: true };
+    }
+    return { state: s, mode, handled: true };
+  }
+  switch (input) {
+    case "h":
+      return { state: { ...s, cursor: Math.max(lineStart(s.value, s.cursor), s.cursor - 1) }, mode, handled: true };
+    case "l":
+      return { state: { ...s, cursor: Math.min(lineEnd(s.value, s.cursor), s.cursor + 1) }, 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 "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 };
+      return { state: { value: s.value.slice(0, s.cursor) + s.value.slice(s.cursor + 1), cursor: s.cursor }, mode, handled: true };
+    }
+    case "i":
+      return { state: s, mode: "insert", handled: true };
+    case "a":
+      return { state: { ...s, cursor: Math.min(s.cursor + 1, s.value.length) }, 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":
+      return { state: s, mode, pending: "d", 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 }) {
+  const [line, setLine] = useState5({ value: "", cursor: 0 });
+  const { value } = line;
+  const [historyIndex, setHistoryIndex] = useState5(null);
+  const [selected, setSelected] = useState5(0);
+  const [vimMode, setVimMode] = useState5("insert");
+  const [vimPending, setVimPending] = useState5(void 0);
+  const injectedSeen = useState5(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 = value.startsWith("/") && !/\s/.test(value) ? all.filter((c) => c.name.startsWith(value.slice(1))).slice(0, 8) : [];
+  const highlighted = Math.min(selected, Math.max(0, suggestions.length - 1));
+  const typed = (text) => ({ value: text, cursor: text.length });
+  const edit = (next) => {
+    setLine(next);
+    setSelected(0);
+  };
+  useInput6(
+    (input, key) => {
+      if (isMouseControlInput(input)) return;
+      if (suggestions.length) {
+        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) {
+          edit(typed(""));
+          setHistoryIndex(null);
+          onSubmit(`/${suggestions[highlighted].name}`);
+          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) {
+        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);
+        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;
+        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 ? "" : history[i]));
+        return;
+      }
+      if (key.tab && !key.shift) {
+        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 || isFocusReport(input)) 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))
+  ] });
+}
+
+// src/ui/Spinner.tsx
+import { Text as Text10 } from "ink";
+import { useEffect as useEffect2, useState as useState6 } 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] = useState6(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, busy, model, reasoning = "auto" }) {
+  const danger = mode === "allowAll";
+  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 ${t("{n} tokens", { n: formatTokens(tokens) })} \xB7 ${busy ? t("esc to cancel") : t("/ for commands")}` });
+}
+
+// src/ui/McpMenu.tsx
+import { Box as Box9, Text as Text12, useInput as useInput7 } from "ink";
+import { useState as useState7 } 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] = useState7(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.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 { jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
+function PlanApproval({ plan, onAnswer }) {
+  useInput8((input, key) => {
+    const k2 = input.toLowerCase();
+    if (k2 === "a") onAnswer("acceptEdits");
+    else if (k2 === "y") onAnswer("default");
+    else if (k2 === "n" || key.escape) onAnswer("no");
+  });
+  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: plan, indent: 5 }),
+    /* @__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 { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+var PREVIEW_LINES = 5;
+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, { marginLeft: 3, children: /* @__PURE__ */ jsx15(DiffView, { diff: display }) }) : output && (isError || tool === "bash") && !(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 }) }) : 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({ ...t2, live: [...t2.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, 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((resolve2) => {
+  execFile2(cmd, args, { timeout: 15e3, windowsHide: true }, (error, stdout) => {
+    const code = error ? error.code ?? 1 : 0;
+    resolve2({ 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") && existsSync(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 }) {
+  const { exit } = useApp();
+  const [transcript, setTranscript] = useState8(() => ({
+    done: [entry({ kind: "header" }), ...runtime.agent.messages.length ? replayEntries(runtime.session.loadHistory()) : []],
+    live: []
+  }));
+  const [busy, setBusy] = useState8(false);
+  const [cancelling, setCancelling] = useState8(false);
+  const [startedAt, setStartedAt] = useState8(0);
+  const [mode, setMode] = useState8(runtime.agent.permissions.mode);
+  const [reasoning, setReasoning] = useState8(runtime.reasoning);
+  const [tokens, setTokens] = useState8(runtime.agent.totalUsage.inputTokens + runtime.agent.totalUsage.outputTokens);
+  const [asks, setAsks] = useState8([]);
+  const pending = asks[0] ?? null;
+  const askId = useRef(0);
+  const [picker, setPicker] = useState8(null);
+  const [providerMenu, setProviderMenu] = useState8(null);
+  const [prompt, setPrompt] = useState8(null);
+  const ask = useCallback((label, mask = false) => new Promise((resolve2) => setPrompt({ label, mask, resolve: resolve2 })), []);
+  const [modelLabel, setModelLabel] = useState8(() => labelFor(runtime, runtime.modelRef));
+  const [history, setHistory] = useState8([]);
+  const controller = useRef(null);
+  const [todos, setTodos] = useState8(runtime.todos.items);
+  const [mcpMenu, setMcpMenu] = useState8(null);
+  const [listPicker, setListPicker] = useState8(null);
+  const [planAsk, setPlanAsk] = useState8(null);
+  const [queued, setQueued] = useState8([]);
+  const [showThinking, setShowThinking] = useState8(runtime.config.thinkingVisible === true);
+  const showThinkingRef = useRef(showThinking);
+  const [lastThinking, setLastThinking] = useState8("");
+  const hasThinking = !!lastThinking.trim();
+  const { stdin } = useStdin();
+  const { stdout } = useStdout2();
+  const liveRootRef = useRef(null);
+  const thinkingTargetRef = useRef(null);
+  const [injected, setInjected] = useState8();
+  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 = useRef(null);
+  const toolTargets = useRef(/* @__PURE__ */ new Map());
+  const editedInTurn = useRef(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") setTokens(event.inputTokens + event.outputTokens);
+    if (event.type === "thinking" && event.delta) setLastThinking((prev) => prev + event.delta);
+    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((resolve2) => setAsks((q) => [...q, { id: askId.current++, request, resolve: resolve2 }]));
+    runtime.interaction.approvePlan = (plan) => new Promise((resolve2) => setPlanAsk({ plan, resolve: resolve2 }));
+    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);
+      setLastThinking("");
+      setStartedAt(Date.now());
+      editedInTurn.current = false;
+      controller.current = new AbortController();
+      const signal = controller.current.signal;
+      await runtime.agent.run(text, 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 runSlashCommand = useCallback(
+    async (name, args) => {
+      switch (name) {
+        case "help":
+          notice(helpText(runtime));
+          return;
+        case "exit":
+          exit();
+          return;
+        case "clear":
+          runtime.agent.clear();
+          setTokens(0);
+          setLastThinking("");
+          notice(t("Conversation cleared."));
+          return;
+        case "cost": {
+          const u = runtime.agent.totalUsage;
+          notice(t("{input} tokens in \xB7 {output} tokens out", { input: u.inputTokens.toLocaleString(locale()), output: u.outputTokens.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":
+          runtime.newSession();
+          setTokens(0);
+          setLastThinking("");
+          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);
+              setTokens(0);
+              setLastThinking("");
+              setTranscript({ done: [entry({ kind: "header" }), ...replayEntries(chosen.session.loadHistory())], live: [] });
+            }
+          });
+          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
+            })
+          );
+          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);
+          const envName = runtime.config.providers[id]?.apiKeyEnv;
+          if (envName && runtime.env[envName]) {
+            notice(t("Key for {provider} saved, but {env} in the environment takes precedence and is still used.", { provider: runtime.providerLabel(), env: envName }), "warn");
+            return;
+          }
+          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) => relative(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) => relative(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;
+          }
+          const rel = (p) => relative(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 = resolve(runtime.cwd, name2);
+          if (existsSync2(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;
+        }
+        default:
+          notice(t("Unknown command: /{name}. Type /help.", { name }), "warn");
+      }
+    },
+    [runtime, notice, exit, version, runTurn, ask]
+  );
+  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]);
+      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) || !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(readFileSync(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) setQueued((q) => [...q, text]);
+      else submit(text);
+    },
+    [busy, submit]
+  );
+  useEffect3(() => {
+    if (busy || pending || planAsk || !queued.length) return;
+    const [next, ...rest] = queued;
+    setQueued(rest);
+    submit(next);
+  }, [busy, pending, planAsk, queued, submit]);
+  const initialSent = useRef(false);
+  useEffect3(() => {
+    if (initialPrompt && !initialSent.current) {
+      initialSent.current = true;
+      submit(initialPrompt);
+    }
+  }, [initialPrompt, submit]);
+  const toggleThinking = useCallback(() => {
+    const next = !showThinkingRef.current;
+    showThinkingRef.current = next;
+    setShowThinking(next);
+    try {
+      writeGlobalConfig({ thinkingVisible: next }, runtime.env);
+    } catch (error) {
+      notice(t("Could not save thinking visibility: {error}", { error: error.message }), "warn");
+    }
+  }, [runtime, notice]);
+  useEffect3(() => {
+    if (!runtime.config.thinkingClickCollapse || !busy && !hasThinking || pending || !stdin.isTTY || !stdout.isTTY || !thinkingTargetRef.current) return;
+    let click;
+    let mouseBuffer = "";
+    const onData = (data) => {
+      mouseBuffer += String(data);
+      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 && thinkingTargetRef.current) {
+          const current = click;
+          click = void 0;
+          const root = measureElement(liveRootRef.current);
+          const target = measureElement(thinkingTargetRef.current);
+          if (clickedThinking(current, report.cursor.row, root.height, target)) toggleThinking();
+        }
+      }
+    };
+    stdin.on("data", onData);
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    return () => {
+      stdin.off("data", onData);
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+    };
+  }, [busy, pending, stdin, stdout, toggleThinking, hasThinking, runtime.config.thinkingClickCollapse]);
+  useInput9((input, key) => {
+    if (key.tab && key.shift) {
+      const next = nextMode(runtime.agent.permissions.mode);
+      runtime.agent.permissions.mode = next;
+      setMode(next);
+    } else if (key.escape && busy && !pending) {
+      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)) {
+      toggleThinking();
+    } else if (matchKeybind(runtime.config.keybinds.toolOutput, input, key) && lastTool.current) {
+      const t2 = lastTool.current;
+      notice(`\u23BF ${t2.tool} ${t2.target}
+${t2.output}`);
+    }
+  });
+  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) => {
+    pending?.resolve(a);
+    setAsks((q) => q.slice(1));
+    if (a === "all") setMode("allowAll");
+  };
+  const cwd = runtime.cwd.startsWith(homedir()) ? `~${runtime.cwd.slice(homedir().length)}` : runtime.cwd;
+  const renderEntry = (e) => {
+    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":
+        if (e.cont) {
+          return e.text ? /* @__PURE__ */ jsx16(Box13, { paddingLeft: 2, children: /* @__PURE__ */ jsx16(Markdown, { text: e.text }) }, e.id) : null;
+        }
+        if (!e.text.trim()) return null;
+        return /* @__PURE__ */ jsxs12(Box13, { marginTop: 1, children: [
+          /* @__PURE__ */ jsx16(Text16, { color: color(ACCENT), children: "\u25CF " }),
+          /* @__PURE__ */ jsx16(Markdown, { text: e.text.replace(/^\s+/, "") })
+        ] }, e.id);
+      case "thinking":
+        return null;
+      case "tool":
+        return /* @__PURE__ */ jsx16(ToolBlock, { tool: e.tool, target: e.target, output: e.output, display: e.display, isError: e.isError, done: e.done, 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);
+    }
+  };
+  return /* @__PURE__ */ jsxs12(Box13, { ref: liveRootRef, flexDirection: "column", children: [
+    /* @__PURE__ */ jsx16(Static, { items: transcript.done, children: renderEntry }),
+    transcript.live.map(renderEntry),
+    busy && !pending && !planAsk || !busy && hasThinking ? /* @__PURE__ */ jsxs12(Box13, { ref: thinkingTargetRef, marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs12(Box13, { flexDirection: "row", children: [
+        busy ? /* @__PURE__ */ jsx16(Spinner, { label: cancelling ? t("Cancelling") : t("Thinking"), startedAt }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("\u273B Thinking") }),
+        /* @__PURE__ */ jsxs12(Text16, { dimColor: true, children: [
+          " \xB7 ",
+          runtime.config.keybinds.thinking.spec,
+          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 }) }),
+        lastThinking.trim() ? /* @__PURE__ */ jsx16(Text16, { dimColor: true, italic: true, children: lastThinking.trim() }) : /* @__PURE__ */ jsx16(Text16, { dimColor: true, children: t("No reasoning summary received yet; tool activity remains visible above.") })
+      ] }) : 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, extraCommands, injected, vim: runtime.config.editor === "vim" }),
+    /* @__PURE__ */ jsx16(StatusBar, { mode, tokens, busy, model: modelLabel, reasoning })
+  ] });
+}
+
+// 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-F6MG3UCU.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();
+      const chosen = list[answer - 1];
+      if (chosen) rt.resume(chosen.session);
+    }
+  }
+  const { serversToStart, setProjectTrust } = await import("./config-AZZFOXKV.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();
+  }
+  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 instance = render(/* @__PURE__ */ jsx17(App, { runtime: rt, initialPrompt: opts.initialPrompt, version: opts.version }), { exitOnCtrlC: true });
+  await instance.waitUntilExit();
+  await rt.mcp.stop();
+  return 0;
+}
+export {
+  startInteractive
+};