@oxbit/cli 0.9.0 → 0.10.0

package/agent/dist/assets/index-BrBnidfI.js

@@ -0,0 +1,1954 @@
+#!/usr/bin/env node
+import { jsx, jsxs } from "react/jsx-runtime";
+import { renderToString, Box, Text, useAnimation, measureElement, useInput, useWindowSize, usePaste, Static, render } from "ink";
+import { createContext, useContext, useMemo, useState, useRef, useEffect, useSyncExternalStore } from "react";
+import { M as MODES, w as walkFiles } from "../index.js";
+import { mkdirSync, appendFileSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import "node:util";
+import "node:readline";
+import "node:fs/promises";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+const FENCE = /^ {0,3}(`{3,}|~{3,})\s*([^\s`]*)/;
+const HEADING = /^ {0,3}(#{1,6})(?:\s+(.*?))?\s*#*\s*$/;
+const RULE = /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const LIST = /^(\s*)([-*+]|\d{1,9}[.)])(?:\s+(.*))?$/;
+const QUOTE = /^ {0,3}>\s?(.*)$/;
+const TABLE_SEPARATOR = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+const cells = (line) => line.trim().replace(/^\|/, "").replace(/(?<!\\)\|$/, "").split(/(?<!\\)\|/).map((cell) => cell.trim().replace(/\\\|/g, "|"));
+const closes = (line, fence) => line.trim().startsWith(fence) && /^[`~]+$/.test(line.trim()) && line.trim()[0] === fence[0];
+const startsBlock = (line, next) => FENCE.test(line) || HEADING.test(line) || RULE.test(line) || LIST.test(line) || QUOTE.test(line) || line.includes("|") && next !== void 0 && TABLE_SEPARATOR.test(next) && next.includes("-");
+function parseBlocks(text) {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (!line.trim()) {
+      index++;
+      continue;
+    }
+    const fence = FENCE.exec(line);
+    if (fence) {
+      const body2 = [];
+      const indent = line.length - line.trimStart().length;
+      index++;
+      while (index < lines.length && !closes(lines[index], fence[1])) body2.push(lines[index++].replace(new RegExp(`^ {0,${indent}}`), ""));
+      blocks.push({ type: "code", lang: fence[2] ?? "", lines: body2, open: index >= lines.length });
+      index++;
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      blocks.push({ type: "heading", level: heading[1].length, text: heading[2] ?? "" });
+      index++;
+      continue;
+    }
+    if (RULE.test(line)) {
+      blocks.push({ type: "rule" });
+      index++;
+      continue;
+    }
+    if (QUOTE.test(line)) {
+      const body2 = [];
+      while (index < lines.length && lines[index].trim()) {
+        const quoted = QUOTE.exec(lines[index]);
+        if (!quoted && startsBlock(lines[index])) break;
+        body2.push(quoted ? quoted[1] : lines[index].trim());
+        index++;
+      }
+      blocks.push({ type: "quote", blocks: parseBlocks(body2.join("\n")) });
+      continue;
+    }
+    if (line.includes("|") && index + 1 < lines.length && TABLE_SEPARATOR.test(lines[index + 1]) && lines[index + 1].includes("-")) {
+      const head = cells(line);
+      const align = cells(lines[index + 1]).map((cell) => cell.endsWith(":") ? cell.startsWith(":") ? "center" : "right" : "left");
+      const rows = [];
+      index += 2;
+      while (index < lines.length && lines[index].includes("|") && lines[index].trim()) rows.push(cells(lines[index++]));
+      blocks.push({ type: "table", head, align, rows });
+      continue;
+    }
+    if (LIST.test(line)) {
+      index = parseList(lines, index, blocks);
+      continue;
+    }
+    const body = [line.trim()];
+    index++;
+    while (index < lines.length && lines[index].trim() && !startsBlock(lines[index], lines[index + 1])) {
+      if (/^ {0,3}=+\s*$/.test(lines[index]) || /^ {0,3}-+\s*$/.test(lines[index])) break;
+      body.push(lines[index++].trim());
+    }
+    const setext = lines[index]?.trim();
+    if (setext && /^(=+|-+)$/.test(setext)) {
+      blocks.push({ type: "heading", level: setext[0] === "=" ? 1 : 2, text: body.join(" ") });
+      index++;
+    } else blocks.push({ type: "paragraph", text: body.join("\n") });
+  }
+  return blocks;
+}
+function parseList(lines, start, blocks) {
+  const items = [];
+  const indents = [];
+  const counters = [];
+  let index = start;
+  while (index < lines.length) {
+    const line = lines[index];
+    const match = LIST.exec(line);
+    if (match && !RULE.test(line)) {
+      const indent = match[1].length;
+      while (indents.length && indent < indents.at(-1)) {
+        indents.pop();
+        counters.pop();
+      }
+      if (!indents.length || indent > indents.at(-1) + 1) {
+        indents.push(indent);
+        counters.push(0);
+      }
+      const depth = indents.length - 1;
+      const ordered = /\d/.test(match[2]);
+      counters[depth] = ordered ? (counters[depth] || Number.parseInt(match[2], 10) - 1) + 1 : 0;
+      const task = /^\[([ xX])\]\s+(.*)$/.exec(match[3] ?? "");
+      items.push({
+        depth,
+        marker: ordered ? `${counters[depth]}.` : "-",
+        text: task ? task[2] : match[3] ?? "",
+        ...task ? { checked: task[1] !== " " } : {}
+      });
+      index++;
+    } else if (line.trim() && items.length && !startsBlock(line)) {
+      items.at(-1).text += `
+${line.trim()}`;
+      index++;
+    } else if (!line.trim() && index + 1 < lines.length && (LIST.test(lines[index + 1]) || /^\s{2,}\S/.test(lines[index + 1]))) index++;
+    else break;
+  }
+  blocks.push({ type: "list", items });
+  return index;
+}
+const flanked = (text, at, size) => text[at + size] !== void 0 && !/\s/.test(text[at + size]);
+const merge = (spans) => spans.reduce((out, span) => {
+  const last = out.at(-1);
+  const { text: _a, ...left2 } = last ?? { text: "" };
+  const { text: _b, ...right2 } = span;
+  if (last && JSON.stringify(left2) === JSON.stringify(right2)) last.text += span.text;
+  else if (span.text) out.push({ ...span });
+  return out;
+}, []);
+function parseInline(text, style = {}) {
+  const spans = [];
+  let plain = "";
+  const push = (...items) => {
+    if (plain) spans.push({ ...style, text: plain });
+    plain = "";
+    spans.push(...items);
+  };
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    const rest = text.slice(index);
+    if (char === "\\" && /[\\`*_{}[\]()#+\-.!|~<>]/.test(text[index + 1] ?? "")) {
+      plain += text[index + 1];
+      index += 2;
+      continue;
+    }
+    if (char === "`") {
+      const run2 = /^`+/.exec(rest)[0];
+      const end2 = text.indexOf(run2, index + run2.length);
+      if (end2 > 0 && text[end2 + run2.length] !== "`") {
+        const body = text.slice(index + run2.length, end2);
+        push({ ...style, code: true, text: /^ .* $/.test(body) ? body.slice(1, -1) : body });
+        index = end2 + run2.length;
+        continue;
+      }
+      plain += run2;
+      index += run2.length;
+      continue;
+    }
+    const strong = /^(\*\*|__|~~)/.exec(rest)?.[1];
+    if (strong && flanked(text, index, 2)) {
+      const end2 = text.indexOf(strong, index + 2);
+      if (end2 > index + 2 && !/\s/.test(text[end2 - 1])) {
+        push(...parseInline(text.slice(index + 2, end2), { ...style, ...strong === "~~" ? { strike: true } : { bold: true } }));
+        index = end2 + 2;
+        continue;
+      }
+    }
+    if ((char === "*" || char === "_") && text[index + 1] !== char && flanked(text, index, 1) && !(char === "_" && /\w/.test(text[index - 1] ?? ""))) {
+      let end2 = index + 1;
+      while ((end2 = text.indexOf(char, end2)) > 0 && (text[end2 + 1] === char || /\s/.test(text[end2 - 1]) || char === "_" && /\w/.test(text[end2 + 1] ?? "")))
+        end2 += text[end2 + 1] === char ? 2 : 1;
+      if (end2 > index + 1) {
+        push(...parseInline(text.slice(index + 1, end2), { ...style, italic: true }));
+        index = end2 + 1;
+        continue;
+      }
+    }
+    const link = /^\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/.exec(rest);
+    if (link) {
+      push(...parseInline(link[1], { ...style, link: link[2] }));
+      index += link[0].length;
+      continue;
+    }
+    const auto = /^<(https?:\/\/[^>\s]+)>/.exec(rest) ?? (/[\s(]|^$/.test(text[index - 1] ?? "") ? /^(https?:\/\/[^\s<>()]+[^\s<>().,;:!?'"])/.exec(rest) : null);
+    if (auto) {
+      push({ ...style, link: auto[1], text: auto[1] });
+      index += auto[0].length;
+      continue;
+    }
+    plain += char;
+    index++;
+  }
+  push();
+  return merge(spans);
+}
+const plainText = (text) => parseInline(text).map((span) => span.text).join("");
+function stableLength(text) {
+  let fence;
+  let offset = 0;
+  let cut = 0;
+  let seen = false;
+  const lines = text.split("\n");
+  for (let index = 0; index < lines.length - 1; index++) {
+    const line = lines[index];
+    offset += line.length + 1;
+    if (fence) {
+      if (closes(line, fence)) {
+        fence = void 0;
+        cut = offset;
+      }
+      continue;
+    }
+    const open = FENCE.exec(line);
+    if (open) fence = open[1];
+    else if (line.trim()) seen = true;
+    else if (seen) cut = offset;
+  }
+  return cut;
+}
+function tailLines(text, count) {
+  const lines = text.split("\n");
+  if (lines.length <= count) return { text, hidden: 0 };
+  const hidden = lines.length - count;
+  let fence;
+  for (const line of lines.slice(0, hidden)) {
+    if (fence) {
+      if (closes(line, fence.match(/[`~]+/)[0])) fence = void 0;
+    } else if (FENCE.test(line)) fence = line;
+  }
+  return { text: [...fence ? [fence] : [], ...lines.slice(hidden)].join("\n"), hidden };
+}
+const KEYWORDS = new Set("abstract as async await break case catch class const continue def default defer del do elif else enum export extends false final finally fn for from func function go if impl import in interface is lambda let loop match mod module mut new nil none None null package pass private protected pub public raise return self static struct super switch this throw throws trait true True False try type typeof undefined unless use val var void where while with yield echo then fi esac done local readonly".split(" "));
+const HASH = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "shell", "console", "py", "python", "rb", "ruby", "yaml", "yml", "toml", "ini", "conf", "dockerfile", "make", "makefile", "r", "perl", "pl", "nix"]);
+const SLASH = /(\/\/.*$|\/\*.*?(?:\*\/|$))/;
+const POUND = /((?:^|\s)#.*$)/;
+const COMMON = /("(?:\\.|[^"\\])*"?|'(?:\\.|[^'\\])*'?|`(?:\\.|[^`\\])*`?|\b\d[\d_]*(?:\.\d+)?(?:e[+-]?\d+)?\b|\b0x[\da-f]+\b|[A-Za-z_$][\w$]*)/i;
+const NAMES = { js: "javascript", ts: "typescript", tsx: "tsx", jsx: "jsx", py: "python", rb: "ruby", sh: "shell", rs: "rust", md: "markdown", yml: "yaml" };
+const languageLabel = (lang) => NAMES[lang.toLowerCase()] ?? lang.toLowerCase();
+function highlight(line, lang) {
+  const name = lang.toLowerCase();
+  if (name === "diff" || name === "patch") {
+    const kind = line.startsWith("+") ? "added" : line.startsWith("-") ? "removed" : line.startsWith("@@") ? "meta" : void 0;
+    return [{ text: line, ...kind ? { kind } : {} }];
+  }
+  if (!name || name === "text" || name === "txt" || name === "markdown" || name === "md") return [{ text: line }];
+  const comment = HASH.has(name) ? POUND : name === "json" ? void 0 : SLASH;
+  const pattern = new RegExp(`${comment ? `${comment.source}|` : ""}${COMMON.source}`, "gi");
+  const tokens = [];
+  let last = 0;
+  for (const match of line.matchAll(pattern)) {
+    const text = match[0];
+    const at = match.index;
+    if (at > last) tokens.push({ text: line.slice(last, at) });
+    const first = text.trimStart()[0];
+    const kind = comment && match[1] !== void 0 ? "comment" : first === '"' || first === "'" || first === "`" ? "string" : /^\d/.test(text) ? "number" : KEYWORDS.has(text) ? "keyword" : void 0;
+    tokens.push({ text, ...kind ? { kind } : {} });
+    last = at + text.length;
+  }
+  if (last < line.length) tokens.push({ text: line.slice(last) });
+  return tokens;
+}
+const THEMES = {
+  dark: {
+    name: "dark",
+    accent: "#8ab4f8",
+    muted: "gray",
+    user: "#c8d3f5",
+    success: "#9ece6a",
+    error: "#f7768e",
+    warning: "#e0af68",
+    link: "#7dcfff",
+    code: "#e0af68",
+    keyword: "#bb9af7",
+    string: "#9ece6a",
+    number: "#ff9e64",
+    added: "#9ece6a",
+    removed: "#f7768e",
+    addedBg: "#1d3325",
+    removedBg: "#3b1f27",
+    border: "gray",
+    modes: { ask: "gray", "accept-edits": "#bb9af7", "full-auto": "#e0af68" }
+  },
+  light: {
+    name: "light",
+    accent: "#1d4ed8",
+    muted: "gray",
+    user: "#1e293b",
+    success: "#15803d",
+    error: "#b91c1c",
+    warning: "#b45309",
+    link: "#0369a1",
+    code: "#9a3412",
+    keyword: "#7c3aed",
+    string: "#15803d",
+    number: "#c2410c",
+    added: "#166534",
+    removed: "#991b1b",
+    addedBg: "#dcfce7",
+    removedBg: "#fee2e2",
+    border: "gray",
+    modes: { ask: "gray", "accept-edits": "#7c3aed", "full-auto": "#b45309" }
+  }
+};
+function resolveTheme(choice = "auto", env = process.env) {
+  if (choice !== "auto") return THEMES[choice];
+  const background = Number(env.COLORFGBG?.split(";").at(-1));
+  return THEMES[Number.isInteger(background) && (background === 7 || background >= 9) ? "light" : "dark"];
+}
+const ThemeContext = createContext(THEMES.dark);
+const useTheme = () => useContext(ThemeContext);
+const segmenter = new Intl.Segmenter();
+const ANSI = /\x1b\[[0-9;:?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g;
+const ZERO = /^[\p{Mn}\p{Me}\p{Cf}\p{Cc}]+$/u;
+const EMOJI = new RegExp("\\p{Emoji_Presentation}|\\p{Extended_Pictographic}️|\\p{Regional_Indicator}", "u");
+const WIDE = [
+  [4352, 4447],
+  [11904, 12350],
+  [12353, 13311],
+  [13312, 19903],
+  [19968, 40959],
+  [40960, 42191],
+  [44032, 55203],
+  [63744, 64255],
+  [65072, 65103],
+  [65280, 65376],
+  [65504, 65510],
+  [127744, 128591],
+  [129280, 129535],
+  [131072, 262141]
+];
+const stripAnsi = (text) => text.replace(ANSI, "");
+const graphemes = (text) => Array.from(segmenter.segment(text), (part) => part.segment);
+function cellWidth(grapheme) {
+  if (!grapheme || ZERO.test(grapheme)) return 0;
+  if (EMOJI.test(grapheme)) return 2;
+  const code = grapheme.codePointAt(0);
+  return WIDE.some(([low, high]) => code >= low && code <= high) ? 2 : 1;
+}
+function width(text) {
+  let total = 0;
+  for (const grapheme of graphemes(stripAnsi(text))) total += cellWidth(grapheme);
+  return total;
+}
+function truncate(text, max) {
+  if (max <= 0) return "";
+  if (width(text) <= max) return text;
+  let out = "";
+  let used = 0;
+  for (const grapheme of graphemes(text)) {
+    const size = cellWidth(grapheme);
+    if (used + size > max - 1) break;
+    out += grapheme;
+    used += size;
+  }
+  return `${out}…`;
+}
+function truncateStart(text, max) {
+  if (width(text) <= max) return text;
+  const parts = graphemes(text);
+  let out = "";
+  let used = 0;
+  for (let index = parts.length - 1; index >= 0; index--) {
+    const size = cellWidth(parts[index]);
+    if (used + size > max - 1) break;
+    out = parts[index] + out;
+    used += size;
+  }
+  return `…${out}`;
+}
+const BULLETS = ["•", "◦", "▪"];
+const JUSTIFY = { left: "flex-start", center: "center", right: "flex-end" };
+function spanNodes(spans, theme) {
+  return spans.flatMap((span, index) => {
+    const node = /* @__PURE__ */ jsx(
+      Text,
+      {
+        bold: span.bold,
+        italic: span.italic,
+        strikethrough: span.strike,
+        underline: !!span.link,
+        color: span.code ? theme.code : span.link ? theme.link : void 0,
+        children: span.text
+      },
+      index
+    );
+    return span.link && span.link !== span.text && !span.link.startsWith("#") ? [node, /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      " (",
+      span.link,
+      ")"
+    ] }, `${index}-url`)] : [node];
+  });
+}
+function Inline({ text, color, dim, bold }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx(Text, { color, dimColor: dim, bold, wrap: "wrap", children: spanNodes(parseInline(text), theme) });
+}
+function tokenColor$1(kind, theme) {
+  if (!kind) return void 0;
+  if (kind === "comment" || kind === "meta") return theme.muted;
+  if (kind === "added") return theme.added;
+  if (kind === "removed") return theme.removed;
+  return theme[kind];
+}
+function Code({ lang, lines, open }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { color: theme.border, children: [
+      "╭─",
+      lang ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+        " ",
+        languageLabel(lang)
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", borderStyle: "single", borderTop: false, borderRight: false, borderBottom: false, borderColor: theme.border, paddingLeft: 1, children: (lines.length ? lines : [""]).map((line, index) => /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: line ? highlight(line, lang).map((token, at) => /* @__PURE__ */ jsx(Text, { color: tokenColor$1(token.kind, theme), italic: token.kind === "comment", children: token.text }, at)) : " " }, index)) }),
+    open ? null : /* @__PURE__ */ jsx(Text, { color: theme.border, children: "╰─" })
+  ] });
+}
+function List({ items }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items.map((item, index) => {
+    const marker = item.checked !== void 0 ? item.checked ? "☒" : "☐" : item.marker === "-" ? BULLETS[item.depth % BULLETS.length] : item.marker;
+    return /* @__PURE__ */ jsxs(Box, { marginLeft: item.depth * 2, children: [
+      /* @__PURE__ */ jsx(Box, { flexShrink: 0, width: width(marker) + 1, children: /* @__PURE__ */ jsx(Text, { color: theme.accent, children: marker }) }),
+      /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexShrink: 1, children: /* @__PURE__ */ jsx(Inline, { text: item.text, dim: item.checked }) })
+    ] }, index);
+  }) });
+}
+function fitColumns(natural, available) {
+  const widths = natural.map((value) => Math.max(1, value));
+  if (widths.length * 3 > available) return void 0;
+  while (widths.reduce((sum, value) => sum + value, 0) > available) {
+    const widest = widths.indexOf(Math.max(...widths));
+    widths[widest]--;
+  }
+  return widths;
+}
+function Table({ head, align, rows, width: width$1 }) {
+  const theme = useTheme();
+  const count = Math.max(head.length, ...rows.map((row2) => row2.length));
+  const grid = [head, ...rows].map((row2) => Array.from({ length: count }, (_, index) => row2[index] ?? ""));
+  const natural = Array.from({ length: count }, (_, column) => Math.max(...grid.map((row2) => width(plainText(row2[column])))));
+  const widths = fitColumns(natural, width$1 - count * 3 - 1);
+  if (!widths) return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: rows.map((row2, index) => /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: index ? 1 : 0, children: head.map((name, column) => /* @__PURE__ */ jsx(Inline, { text: `**${name}:** ${row2[column] ?? ""}` }, column)) }, index)) });
+  const line = (left2, middle2, right2) => /* @__PURE__ */ jsxs(Text, { color: theme.border, children: [
+    left2,
+    widths.map((size) => "─".repeat(size + 2)).join(middle2),
+    right2
+  ] });
+  const row = (values, header) => /* @__PURE__ */ jsx(Box, { children: values.map((value, column) => /* @__PURE__ */ jsx(
+    Box,
+    {
+      width: widths[column] + 3 + (column === count - 1 ? 1 : 0),
+      borderStyle: "single",
+      borderTop: false,
+      borderBottom: false,
+      borderRight: column === count - 1,
+      borderColor: theme.border,
+      paddingX: 1,
+      justifyContent: JUSTIFY[align[column] ?? "left"],
+      children: /* @__PURE__ */ jsx(Inline, { text: value, bold: header })
+    },
+    column
+  )) });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    line("┌", "┬", "┐"),
+    row(grid[0], true),
+    line("├", "┼", "┤"),
+    grid.slice(1).map((values, index) => /* @__PURE__ */ jsx(Box, { children: row(values, false) }, index)),
+    line("└", "┴", "┘")
+  ] });
+}
+function BlockView({ block, width: width2, dim }) {
+  const theme = useTheme();
+  switch (block.type) {
+    case "heading":
+      return /* @__PURE__ */ jsx(Text, { bold: true, underline: block.level === 1, color: block.level <= 2 ? theme.accent : void 0, wrap: "wrap", children: spanNodes(parseInline(block.text), theme) });
+    case "paragraph":
+      return /* @__PURE__ */ jsx(Inline, { text: block.text, dim });
+    case "code":
+      return /* @__PURE__ */ jsx(Code, { ...block });
+    case "list":
+      return /* @__PURE__ */ jsx(List, { items: block.items });
+    case "rule":
+      return /* @__PURE__ */ jsx(Text, { color: theme.border, children: "─".repeat(Math.max(1, Math.min(width2, 80))) });
+    case "table":
+      return /* @__PURE__ */ jsx(Table, { ...block, width: width2 });
+    case "quote":
+      return /* @__PURE__ */ jsx(Box, { borderStyle: "bold", borderTop: false, borderRight: false, borderBottom: false, borderColor: theme.border, paddingLeft: 1, flexDirection: "column", children: block.blocks.map((inner, index) => /* @__PURE__ */ jsx(Box, { marginTop: index ? 1 : 0, children: /* @__PURE__ */ jsx(BlockView, { block: inner, width: width2 - 2, dim: true }) }, index)) });
+  }
+}
+function Markdown({ text, width: width2, tail, dim }) {
+  const theme = useTheme();
+  const cut = tail ? tailLines(text, tail) : { text, hidden: 0 };
+  const blocks = parseBlocks(cut.text);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: width2, children: [
+    cut.hidden ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      "… ",
+      cut.hidden,
+      " lines above"
+    ] }) : null,
+    blocks.map((block, index) => /* @__PURE__ */ jsx(Box, { marginTop: index ? 1 : 0, flexDirection: "column", children: /* @__PURE__ */ jsx(BlockView, { block, width: width2, dim }) }, index))
+  ] });
+}
+function markdownToAnsi(text, columns = 80, theme = THEMES.dark) {
+  return renderToString(/* @__PURE__ */ jsx(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx(Markdown, { text, width: columns }) }), { columns });
+}
+const MAX_CELLS = 4e6;
+const split = (text) => {
+  const lines = text.replace(/\r\n?/g, "\n").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+};
+function middle(a, b) {
+  if (!a.length || !b.length || a.length * b.length > MAX_CELLS)
+    return [...a.map(() => "-"), ...b.map(() => "+")];
+  const columns = b.length + 1;
+  const table = new Uint32Array((a.length + 1) * columns);
+  for (let i2 = a.length - 1; i2 >= 0; i2--)
+    for (let j2 = b.length - 1; j2 >= 0; j2--)
+      table[i2 * columns + j2] = a[i2] === b[j2] ? table[(i2 + 1) * columns + j2 + 1] + 1 : Math.max(table[(i2 + 1) * columns + j2], table[i2 * columns + j2 + 1]);
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      ops.push("=");
+      i++;
+      j++;
+    } else if (table[(i + 1) * columns + j] >= table[i * columns + j + 1]) {
+      ops.push("-");
+      i++;
+    } else {
+      ops.push("+");
+      j++;
+    }
+  }
+  while (i++ < a.length) ops.push("-");
+  while (j++ < b.length) ops.push("+");
+  return ops;
+}
+function diffLines(oldText, newText, context = 3) {
+  const a = oldText ? split(oldText) : [];
+  const b = split(newText);
+  let head = 0;
+  while (head < a.length && head < b.length && a[head] === b[head]) head++;
+  let tail = 0;
+  while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail]) tail++;
+  const ops = [...Array(head).fill("="), ...middle(a.slice(head, a.length - tail), b.slice(head, b.length - tail)), ...Array(tail).fill("=")];
+  const all = [];
+  let oldNo = 0;
+  let newNo = 0;
+  for (const op of ops) {
+    if (op === "=") all.push({ type: "context", text: b[newNo], oldNo: ++oldNo, newNo: ++newNo });
+    else if (op === "-") all.push({ type: "removed", text: a[oldNo], oldNo: ++oldNo });
+    else all.push({ type: "added", text: b[newNo], newNo: ++newNo });
+  }
+  const near = all.map(() => false);
+  all.forEach((line, index) => {
+    if (line.type === "context") return;
+    for (let k = Math.max(0, index - context); k <= Math.min(all.length - 1, index + context); k++) near[k] = true;
+  });
+  const lines = [];
+  let skipped = 0;
+  all.forEach((line, index) => {
+    if (near[index]) {
+      if (skipped) lines.push({ type: "gap", count: skipped });
+      skipped = 0;
+      lines.push(line);
+    } else skipped++;
+  });
+  if (skipped && lines.length) lines.push({ type: "gap", count: skipped });
+  return { lines, added: all.filter((line) => line.type === "added").length, removed: all.filter((line) => line.type === "removed").length };
+}
+const ICONS = { read: "→", edit: "✎", delete: "✗", move: "⇄", search: "⌕", execute: "$", think: "∴", fetch: "⇣", other: "◆" };
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SUFFIX = { pending: "waiting for approval", failed: "failed", cancelled: "interrupted" };
+const relative = (cwd, text) => cwd === "/" ? text : text.split(`${cwd}/`).join("");
+function Gutter({ children }) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Box, { width: 5, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "  ⎿ " }) }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children })
+  ] });
+}
+function More({ count, unit = "line" }) {
+  const theme = useTheme();
+  return count > 0 ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+    "… +",
+    count,
+    " ",
+    unit,
+    count === 1 ? "" : "s",
+    " (ctrl+o to expand)"
+  ] }) : null;
+}
+const extension = (path) => /\.([a-z0-9]+)$/i.exec(path)?.[1] ?? "";
+function DiffView({ diff, cwd, limit }) {
+  const theme = useTheme();
+  const { lines, added, removed } = useMemo(() => diffLines(diff.oldText, diff.newText), [diff]);
+  const path = relative(cwd, diff.path);
+  const numbers = lines.flatMap((line) => line.type === "gap" ? [] : [line.newNo ?? line.oldNo ?? 0]);
+  const size = String(Math.max(1, ...numbers)).length;
+  const lang = extension(path);
+  const summary = diff.oldText === null ? `Created ${path} with ${added} ${added === 1 ? "line" : "lines"}` : `Updated ${path}: ${added} added, ${removed} removed`;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { color: theme.muted, children: summary }),
+    lines.slice(0, limit).map((line, index) => {
+      if (line.type === "gap") return /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+        " ".repeat(size),
+        "   ⋮ ",
+        line.count,
+        " unchanged"
+      ] }, index);
+      const sign = line.type === "added" ? "+" : line.type === "removed" ? "-" : " ";
+      const background = line.type === "added" ? theme.addedBg : line.type === "removed" ? theme.removedBg : void 0;
+      const color = line.type === "added" ? theme.added : line.type === "removed" ? theme.removed : theme.muted;
+      return /* @__PURE__ */ jsxs(Box, { backgroundColor: background, children: [
+        /* @__PURE__ */ jsx(Box, { width: size + 1, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.muted, children: String(line.type === "removed" ? line.oldNo : line.newNo).padStart(size) }) }),
+        /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color, bold: true, children: sign }) }),
+        /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: line.text ? highlight(line.text, lang).map((token, at) => /* @__PURE__ */ jsx(Text, { color: tokenColor(token.kind, theme), children: token.text }, at)) : " " })
+      ] }, index);
+    }),
+    /* @__PURE__ */ jsx(More, { count: lines.length - limit })
+  ] });
+}
+function tokenColor(kind, theme) {
+  return kind === "keyword" ? theme.keyword : kind === "string" ? theme.string : kind === "number" ? theme.number : kind === "comment" ? theme.muted : void 0;
+}
+function Output({ tool: tool2, expanded }) {
+  const theme = useTheme();
+  const lines = (tool2.output ?? "").replace(/\s+$/, "").split("\n");
+  if (!tool2.output?.trim()) return tool2.status === "in_progress" && tool2.terminal ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "Running…" }) : null;
+  if (tool2.status === "completed" && tool2.kind === "read" && !expanded)
+    return /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      lines.length,
+      " ",
+      lines.length === 1 ? "line" : "lines"
+    ] });
+  const limit = expanded ? 200 : tool2.status === "failed" ? 8 : 5;
+  const tail = tool2.kind === "execute" && tool2.status !== "failed";
+  const shown = tail ? lines.slice(-limit) : lines.slice(0, limit);
+  const hidden = lines.length - shown.length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    tail && hidden > 0 ? /* @__PURE__ */ jsx(More, { count: hidden }) : null,
+    shown.map((line, index) => /* @__PURE__ */ jsx(Text, { wrap: "wrap", color: tool2.status === "failed" ? theme.error : void 0, children: line || " " }, index)),
+    !tail && hidden > 0 ? /* @__PURE__ */ jsx(More, { count: hidden }) : null
+  ] });
+}
+function Icon({ tool: tool2, live }) {
+  const theme = useTheme();
+  const running = live && tool2.status === "in_progress";
+  const { frame } = useAnimation({ interval: 80, isActive: running });
+  const color = { completed: theme.success, failed: theme.error, cancelled: theme.muted, pending: theme.warning }[tool2.status] ?? theme.accent;
+  return /* @__PURE__ */ jsx(Text, { color, children: running ? SPINNER[frame % SPINNER.length] : ICONS[tool2.kind] ?? ICONS.other });
+}
+function ToolCard({ tool: view, live, expanded, cwd, awaiting }) {
+  const theme = useTheme();
+  const tool2 = awaiting && view.status === "in_progress" ? { ...view, status: "pending" } : view;
+  if (tool2.kind === "think" && tool2.title === "Update plan" && tool2.status !== "failed") return null;
+  const title = tool2.kind === "execute" ? tool2.title.replace(/^\$\s*/, "") : relative(cwd, tool2.title);
+  const suffix = SUFFIX[tool2.status];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Icon, { tool: tool2, live }) }),
+      /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, children: title }),
+        suffix ? /* @__PURE__ */ jsxs(Text, { color: tool2.status === "failed" ? theme.error : theme.muted, children: [
+          " · ",
+          suffix
+        ] }) : null
+      ] })
+    ] }),
+    tool2.diffs.length || tool2.output?.trim() || tool2.terminal && tool2.status === "in_progress" ? /* @__PURE__ */ jsxs(Gutter, { children: [
+      tool2.diffs.map((diff, index) => /* @__PURE__ */ jsx(DiffView, { diff, cwd, limit: expanded ? 400 : 14 }, index)),
+      tool2.diffs.length && tool2.status === "completed" ? null : /* @__PURE__ */ jsx(Output, { tool: tool2, expanded })
+    ] }) : null
+  ] });
+}
+const home$1 = (path) => {
+  const user = process.env.HOME;
+  return user && (path === user || path.startsWith(`${user}/`)) ? `~${path.slice(user.length)}` : path;
+};
+function Banner({ width: width2, cwd, version }) {
+  const theme = useTheme();
+  const size = Math.min(width2, 64);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, width: size, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: theme.accent, children: "✻" }),
+      " ",
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Oxbit Agent" }),
+      version ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+        " ",
+        version
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: theme.muted, children: truncateStart(home$1(cwd), size - 4) }),
+    /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "/help for help · shift+tab to switch modes" })
+  ] });
+}
+const PLAN_ICONS = { completed: "☒", in_progress: "▶", pending: "☐" };
+function Plan({ entries, expanded }) {
+  const theme = useTheme();
+  const done = entries.filter((entry) => entry.status === "completed").length;
+  const limit = expanded ? entries.length : 12;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: theme.accent, children: "☰" }),
+      " ",
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Plan" }),
+      /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+        " · ",
+        done,
+        "/",
+        entries.length,
+        " done"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Gutter, { children: [
+      entries.slice(0, limit).map((entry, index) => {
+        const active = entry.status === "in_progress";
+        const finished = entry.status === "completed";
+        return /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: active ? theme.accent : finished ? theme.success : theme.muted, children: PLAN_ICONS[entry.status] ?? "☐" }) }),
+          /* @__PURE__ */ jsx(Text, { wrap: "wrap", bold: active, dimColor: finished, strikethrough: finished, children: entry.content })
+        ] }, index);
+      }),
+      /* @__PURE__ */ jsx(More, { count: entries.length - limit, unit: "step" })
+    ] })
+  ] });
+}
+function Thought({ text, live, expanded, width: width2 }) {
+  const theme = useTheme();
+  const lines = text.trim().split("\n").filter((line) => line.trim());
+  const shown = expanded ? lines : live ? lines.slice(-3) : [];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, width: width2, children: [
+    /* @__PURE__ */ jsxs(Text, { color: theme.muted, italic: true, children: [
+      "∴ ",
+      live ? "Thinking…" : "Thought",
+      !expanded && !live && lines.length ? " (ctrl+o to expand)" : ""
+    ] }),
+    shown.length ? /* @__PURE__ */ jsx(Gutter, { children: shown.map((line, index) => /* @__PURE__ */ jsx(Text, { color: theme.muted, italic: true, wrap: "wrap", children: line }, index)) }) : null
+  ] });
+}
+function ItemView({ item, live = false, context }) {
+  const theme = useTheme();
+  const { width: width2, rows, expanded, cwd } = context;
+  switch (item.type) {
+    case "banner":
+      return /* @__PURE__ */ jsx(Banner, { ...context });
+    case "user": {
+      const lines = item.text.split("\n");
+      const shown = item.continuation && !expanded ? lines.slice(0, 3) : lines;
+      return /* @__PURE__ */ jsxs(Box, { marginTop: 1, width: width2, children: [
+        /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: item.continuation ? theme.muted : theme.accent, bold: true, children: item.continuation ? "↻" : "›" }) }),
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: [
+          /* @__PURE__ */ jsx(Text, { color: item.continuation ? theme.muted : theme.user, wrap: "wrap", children: shown.join("\n") }),
+          /* @__PURE__ */ jsx(More, { count: lines.length - shown.length })
+        ] })
+      ] });
+    }
+    case "assistant": {
+      const text = item.text.replace(/^\n+|\s+$/g, "");
+      if (!text) return null;
+      return /* @__PURE__ */ jsxs(Box, { marginTop: 1, width: width2, children: [
+        /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.accent, children: item.part ? " " : "●" }) }),
+        /* @__PURE__ */ jsx(Markdown, { text, width: Math.max(10, width2 - 2), tail: live ? Math.max(6, rows - 14) : void 0 })
+      ] });
+    }
+    case "thought":
+      return item.text.trim() ? /* @__PURE__ */ jsx(Thought, { text: item.text, live: live && !item.done, expanded, width: width2 }) : null;
+    case "tool":
+      return /* @__PURE__ */ jsx(ToolCard, { tool: item.tool, live, expanded, cwd, awaiting: context.awaiting === item.tool.toolCallId });
+    case "plan":
+      return /* @__PURE__ */ jsx(Plan, { entries: item.entries, expanded });
+    case "notice":
+      return item.tone === "error" ? /* @__PURE__ */ jsxs(Box, { marginTop: 1, width: width2, children: [
+        /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.error, children: "✗" }) }),
+        /* @__PURE__ */ jsx(Text, { color: theme.error, wrap: "wrap", children: item.text })
+      ] }) : /* @__PURE__ */ jsx(Box, { width: width2, children: /* @__PURE__ */ jsx(Gutter, { children: /* @__PURE__ */ jsx(Text, { color: item.tone === "warn" ? theme.warning : theme.muted, wrap: "wrap", children: item.text }) }) });
+    case "divider": {
+      const label = ` ${item.text} `;
+      return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { color: theme.muted, wrap: "truncate-end", children: [
+        "──",
+        label,
+        "─".repeat(Math.max(0, width2 - label.length - 2))
+      ] }) });
+    }
+  }
+}
+const emptyTranscript = () => ({ flushed: [{ id: 0, type: "banner" }], live: [], next: 1 });
+const STREAMING = /* @__PURE__ */ new Set(["assistant", "thought", "plan"]);
+const FINAL = /* @__PURE__ */ new Set(["banner", "user", "notice", "divider"]);
+const isDone = (item) => FINAL.has(item.type) || !!item.done;
+const textOf = (content) => {
+  const block = content;
+  if (block?.type === "text" && typeof block.text === "string") return block.text;
+  return block?.type === "image" ? "[image]" : block?.type === "resource_link" ? `[${block.name ?? block.uri}]` : "";
+};
+const outputOf = (value) => value === void 0 || value === null ? void 0 : typeof value === "string" ? value : JSON.stringify(value, null, 2);
+function flush(state) {
+  let { flushed, live, next } = state;
+  let count = 0;
+  while (count < live.length && isDone(live[count])) count++;
+  if (count) {
+    flushed = [...flushed, ...live.slice(0, count)];
+    live = live.slice(count);
+  }
+  const head = live[0];
+  if (head?.type === "assistant" && !head.done) {
+    const cut = stableLength(head.text);
+    if (cut > 0 && head.text.slice(cut).trim()) {
+      flushed = [...flushed, { ...head, text: head.text.slice(0, cut), done: true }];
+      live = [{ ...head, id: next++, text: head.text.slice(cut), part: true }, ...live.slice(1)];
+    }
+  }
+  return flushed === state.flushed && live === state.live ? state : { flushed, live, next };
+}
+function append(state, item) {
+  const live = state.live.map((entry) => STREAMING.has(entry.type) && !isDone(entry) ? { ...entry, done: true } : entry);
+  return flush({ ...state, live: [...live, { ...item, id: state.next }], next: state.next + 1 });
+}
+const replace = (state, index, item) => flush({ ...state, live: state.live.map((entry, at) => at === index ? item : entry) });
+function stream(state, type, text) {
+  if (!text) return state;
+  const index = state.live.length - 1;
+  const last = state.live[index];
+  if (last?.type === type && !last.done) return replace(state, index, { ...last, text: last.text + text });
+  return append(state, { type, text: type === "assistant" ? text.replace(/^\n+/, "") : text });
+}
+function tool(state, update) {
+  const index = state.live.findIndex((item) => item.type === "tool" && item.tool.toolCallId === update.toolCallId);
+  const current = index >= 0 ? state.live[index].tool : void 0;
+  const content = Array.isArray(update.content) ? update.content : void 0;
+  const diffs = content?.filter((block) => block.type === "diff").map((block) => ({ path: String(block.path ?? ""), oldText: block.oldText ?? null, newText: String(block.newText ?? "") }));
+  const text = content?.filter((block) => block.type === "content").map((block) => textOf(block.content)).join("\n");
+  const next = {
+    toolCallId: String(update.toolCallId ?? ""),
+    title: typeof update.title === "string" ? update.title : current?.title ?? "Tool",
+    kind: typeof update.kind === "string" ? update.kind : current?.kind ?? "other",
+    status: typeof update.status === "string" ? update.status : current?.status ?? "pending",
+    rawInput: "rawInput" in update ? update.rawInput : current?.rawInput,
+    output: outputOf(update.rawOutput) ?? (text || current?.output),
+    diffs: diffs?.length ? diffs : current?.diffs ?? [],
+    terminal: current?.terminal || !!content?.some((block) => block.type === "terminal")
+  };
+  const done = next.status === "completed" || next.status === "failed";
+  if (index < 0 && state.flushed.slice(-50).some((item) => item.type === "tool" && item.tool.toolCallId === next.toolCallId)) return state;
+  if (index < 0) return append(state, { type: "tool", tool: next, done });
+  return replace(state, index, { id: state.live[index].id, type: "tool", tool: next, done });
+}
+function applyUpdate(state, update) {
+  switch (update.sessionUpdate) {
+    case "agent_message_chunk":
+      return stream(state, "assistant", textOf(update.content));
+    case "agent_thought_chunk":
+      return stream(state, "thought", textOf(update.content));
+    case "user_message_chunk": {
+      const text = textOf(update.content);
+      return text ? append(state, { type: "user", text, continuation: !!update._meta?.oxbit?.continuation }) : state;
+    }
+    case "tool_call":
+    case "tool_call_update":
+      return tool(state, update);
+    case "plan": {
+      const entries = Array.isArray(update.entries) ? update.entries : [];
+      const index = state.live.length - 1;
+      const last = state.live[index];
+      if (last?.type === "plan" && !last.done) return replace(state, index, { ...last, entries });
+      return append(state, { type: "plan", entries });
+    }
+  }
+  return state;
+}
+function endTurn(state) {
+  const live = state.live.map((item) => item.type === "tool" && !item.done ? { ...item, done: true, tool: { ...item.tool, status: item.tool.status === "failed" ? "failed" : "cancelled" } } : FINAL.has(item.type) ? item : { ...item, done: true });
+  return flush({ ...state, live });
+}
+function expandable(item) {
+  if (item.type === "thought") return !!item.text.trim();
+  if (item.type === "tool") return !!item.tool.output?.trim() || item.tool.diffs.length > 0;
+  return item.type === "user" && !!item.continuation && item.text.split("\n").length > 3;
+}
+function Details({ id, transcript, context }) {
+  const theme = useTheme();
+  const items = [...transcript.flushed, ...transcript.live].filter(expandable);
+  const at = Math.max(0, items.findIndex((entry) => entry.id === id));
+  const item = items[at];
+  const height = Math.max(4, context.rows - 9);
+  const [scroll, setScroll] = useState(0);
+  const [total, setTotal] = useState(0);
+  const content = useRef(null);
+  useEffect(() => {
+    if (content.current) setTotal(measureElement(content.current).height);
+  });
+  const max = Math.max(0, total - height);
+  const top = Math.min(scroll, max);
+  useInput((_input, key) => {
+    const page = height - 1;
+    const step = key.upArrow ? -1 : key.downArrow ? 1 : key.pageUp ? -page : key.pageDown ? page : key.home ? -total : key.end ? total : 0;
+    if (step) setScroll(Math.min(max, Math.max(0, top + step)));
+  });
+  if (!item) return null;
+  const live = transcript.live.includes(item);
+  const position = max ? ` · lines ${top + 1}-${Math.min(total, top + height)} of ${total}` : "";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, width: context.width, marginTop: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, wrap: "truncate-end", children: [
+      "Details ",
+      /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+        at + 1,
+        "/",
+        items.length,
+        position
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { height: total ? Math.min(height, total) : height, overflow: "hidden", flexDirection: "column", children: /* @__PURE__ */ jsx(Box, { ref: content, flexDirection: "column", flexShrink: 0, marginTop: -top, children: /* @__PURE__ */ jsx(ItemView, { item, live, context: { ...context, width: context.width - 4, expanded: true } }) }) }),
+    /* @__PURE__ */ jsxs(Text, { color: theme.muted, wrap: "truncate-end", children: [
+      max ? "↑↓ pgup pgdn scroll · " : "",
+      "←→ earlier/later · esc close"
+    ] })
+  ] });
+}
+function commandToken({ text, cursor }) {
+  if (!text.startsWith("/")) return void 0;
+  const space = text.search(/\s/);
+  const end2 = space < 0 ? text.length : space;
+  return cursor <= end2 ? { query: text.slice(1, end2), start: 0, end: end2 } : void 0;
+}
+function fileToken({ text, cursor }) {
+  const match = /(?:^|\s)@([^\s@]*)$/.exec(text.slice(0, cursor));
+  if (!match) return void 0;
+  let end2 = cursor;
+  while (end2 < text.length && !/\s/.test(text[end2])) end2++;
+  return { query: match[1], start: cursor - match[1].length - 1, end: end2 };
+}
+function score(candidate, query) {
+  if (!query) return 0;
+  const text = candidate.toLowerCase();
+  const wanted = query.toLowerCase();
+  if (text.startsWith(wanted)) return 3e3 - text.length;
+  const at = text.indexOf(wanted);
+  if (at >= 0) return 2e3 - at;
+  let position = -1;
+  let gaps = 0;
+  for (const char of wanted) {
+    const next = text.indexOf(char, position + 1);
+    if (next < 0) return void 0;
+    gaps += next - position - 1;
+    position = next;
+  }
+  return 1e3 - gaps;
+}
+function rank(items, key, query, limit = 50) {
+  return items.map((item) => ({ item, score: score(key(item), query) })).filter((entry) => entry.score !== void 0).sort((a, b) => b.score - a.score).slice(0, limit).map((entry) => entry.item);
+}
+function commandItems(commands, query) {
+  return rank(commands, (command) => command.name, query).map((command) => ({
+    value: `/${command.name}`,
+    label: `/${command.name}${command.hint ? ` ${command.hint}` : ""}`,
+    detail: command.description
+  }));
+}
+function fileItems(paths, query) {
+  const base = (path) => path.replace(/\/$/, "").split("/").pop() ?? path;
+  const scored = rank(paths, (path) => query.includes("/") ? path : base(path), query, 50);
+  const extra = query.includes("/") ? [] : rank(paths.filter((path) => !scored.includes(path)), (path) => path, query, 50 - scored.length);
+  return [...scored, ...extra].map((path) => ({ value: `@${path}`, label: path }));
+}
+function accept(draft, completion, item) {
+  const value = item.value.endsWith("/") ? item.value : `${item.value} `;
+  const rest = draft.text.slice(completion.end).replace(/^ /, "");
+  return { text: draft.text.slice(0, completion.start) + value + rest, cursor: completion.start + value.length };
+}
+const emptyDraft = { text: "", cursor: 0 };
+const draftOf = (text) => ({ text, cursor: text.length });
+const lineStartOf = (text, at) => text.lastIndexOf("\n", at - 1) + 1;
+const lineEndOf = (text, at) => {
+  const end2 = text.indexOf("\n", at);
+  return end2 < 0 ? text.length : end2;
+};
+const previous = (text, at) => at - (graphemes(text.slice(Math.max(0, at - 16), at)).at(-1)?.length ?? 0);
+const following = (text, at) => at + (graphemes(text.slice(at, at + 16))[0]?.length ?? 0);
+const insert = ({ text, cursor }, value) => ({ text: text.slice(0, cursor) + value + text.slice(cursor), cursor: cursor + value.length });
+const backspace = ({ text, cursor }) => {
+  const at = previous(text, cursor);
+  return { text: text.slice(0, at) + text.slice(cursor), cursor: at };
+};
+const deleteForward = ({ text, cursor }) => ({ text: text.slice(0, cursor) + text.slice(following(text, cursor)), cursor });
+const left = ({ text, cursor }) => ({ text, cursor: previous(text, cursor) });
+const right = ({ text, cursor }) => ({ text, cursor: following(text, cursor) });
+const home = ({ text, cursor }) => ({ text, cursor: lineStartOf(text, cursor) });
+const end = ({ text, cursor }) => ({ text, cursor: lineEndOf(text, cursor) });
+function wordLeft({ text, cursor }) {
+  let at = cursor;
+  while (at > 0 && /\s/.test(text[at - 1])) at--;
+  while (at > 0 && !/\s/.test(text[at - 1])) at--;
+  return { text, cursor: at };
+}
+function wordRight({ text, cursor }) {
+  let at = cursor;
+  while (at < text.length && /\s/.test(text[at])) at++;
+  while (at < text.length && !/\s/.test(text[at])) at++;
+  return { text, cursor: at };
+}
+const deleteWordLeft = (draft) => {
+  const at = wordLeft(draft).cursor;
+  return { text: draft.text.slice(0, at) + draft.text.slice(draft.cursor), cursor: at };
+};
+const killLineLeft = ({ text, cursor }) => {
+  const start = lineStartOf(text, cursor);
+  const at = start === cursor && cursor > 0 ? cursor - 1 : start;
+  return { text: text.slice(0, at) + text.slice(cursor), cursor: at };
+};
+const killLineRight = ({ text, cursor }) => {
+  const stop = lineEndOf(text, cursor);
+  return { text: text.slice(0, cursor) + text.slice(stop === cursor ? cursor + 1 : stop), cursor };
+};
+function vertical({ text, cursor }, direction) {
+  const start = lineStartOf(text, cursor);
+  const column = graphemes(text.slice(start, cursor)).length;
+  const target = direction < 0 ? start - 1 : lineEndOf(text, cursor) + 1;
+  if (target < 0 || target > text.length || direction > 0 && lineEndOf(text, cursor) === text.length) return void 0;
+  const lineStart = lineStartOf(text, target);
+  const line = graphemes(text.slice(lineStart, lineEndOf(text, lineStart)));
+  return { text, cursor: lineStart + line.slice(0, column).join("").length };
+}
+function cursorLines({ text, cursor }) {
+  const lines = text.split("\n");
+  let offset = 0;
+  return lines.map((line) => {
+    const start = offset;
+    offset += line.length + 1;
+    if (cursor < start || cursor > start + line.length) return { before: line };
+    const at = cursor - start;
+    const under = graphemes(line.slice(at, at + 16))[0] ?? "";
+    return { before: line.slice(0, at), under: under || " ", after: line.slice(at + under.length) };
+  });
+}
+const DECISIONS = ["once", "session", "deny"];
+const option = (options, kinds, ids) => options.find((item) => kinds.includes(item.kind)) ?? options.find((item) => ids.includes(item.optionId));
+const selected = (optionId) => ({ outcome: { outcome: "selected", optionId } });
+const cancelled = { outcome: { outcome: "cancelled" } };
+function commandOf(request) {
+  const input = request.toolCall.rawInput;
+  return typeof input?.command === "string" ? input.command : request.toolCall.title ?? "";
+}
+function ruleKey(request) {
+  const kind = request.toolCall.kind ?? "other";
+  if (kind !== "execute") return kind;
+  return `execute:${commandOf(request).trim().split(/\s+/)[0] ?? ""}`;
+}
+function decisionLabel(request, decision) {
+  if (decision === "once") return "Yes";
+  if (decision === "deny") return "No, tell the agent what to do instead";
+  const kind = request.toolCall.kind ?? "other";
+  if (kind === "execute") return `Yes, and allow \`${ruleKey(request).slice(8) || "these"}\` commands for this session`;
+  if (kind === "edit") return "Yes, and allow edits for this session";
+  return `Yes, and allow ${kind} tools for this session`;
+}
+function question(request) {
+  const kind = request.toolCall.kind ?? "other";
+  if (kind === "execute") return "Run this command?";
+  if (kind === "edit") return "Apply this edit?";
+  if (kind === "delete") return "Delete this?";
+  return `Allow ${request.toolCall.title ?? "this tool call"}?`;
+}
+function outcomeOf(request, decision) {
+  const once = option(request.options, ["allow_once"], ["allow"]);
+  const always = option(request.options, ["allow_always"], []);
+  const reject = option(request.options, ["reject_once", "reject_always"], ["reject", "deny"]);
+  if (decision === "deny") return { outcome: reject ? selected(reject.optionId) : cancelled, remember: false };
+  if (decision === "session" && always) return { outcome: selected(always.optionId), remember: false };
+  const allow = once ?? always;
+  return { outcome: allow ? selected(allow.optionId) : cancelled, remember: decision === "session" };
+}
+const cancelOutcome = () => cancelled;
+const emptyStatus = () => ({ mode: "ask", models: [], commands: [] });
+function fromConfig(options) {
+  if (!Array.isArray(options)) return {};
+  const list = options;
+  const model = list.find((option2) => option2.id === "model" || option2.category === "model");
+  const reasoning = list.find((option2) => option2.id === "reasoning" || option2.category === "thought_level");
+  const mode = list.find((option2) => option2.id === "mode" || option2.category === "mode");
+  return {
+    ...model ? { model: model.currentValue, models: model.options.map(({ value, name }) => ({ value, name })) } : {},
+    ...reasoning ? { reasoning } : {},
+    ...mode ? { mode: mode.currentValue } : {}
+  };
+}
+function fromSession(session) {
+  const models = session.models?.availableModels.map((model) => ({ value: model.modelId, name: model.name })) ?? [];
+  return {
+    ...emptyStatus(),
+    sessionId: session.sessionId,
+    mode: session.modes?.currentModeId ?? "ask",
+    model: session.models?.currentModelId,
+    models,
+    ...fromConfig(session.configOptions)
+  };
+}
+const commandsOf = (value) => Array.isArray(value) ? value.filter((item) => typeof item?.name === "string").map((item) => ({
+  name: item.name.replace(/^\//, ""),
+  description: typeof item.description === "string" ? item.description : "",
+  ...typeof item.input?.hint === "string" ? { hint: item.input.hint } : {}
+})) : [];
+function applyStatus(status, update) {
+  let next = status;
+  switch (update.sessionUpdate) {
+    case "available_commands_update":
+      next = { ...status, commands: commandsOf(update.availableCommands) };
+      break;
+    case "current_mode_update":
+      if (typeof update.currentModeId === "string") next = { ...status, mode: update.currentModeId };
+      break;
+    case "session_info_update":
+      if (typeof update.title === "string") next = { ...status, title: update.title };
+      break;
+    case "config_option_update":
+      next = { ...status, ...fromConfig(update.configOptions) };
+      break;
+    case "usage_update":
+      if (typeof update.used === "number" && typeof update.size === "number" && update.size > 0) next = { ...status, usage: { used: update.used, size: update.size } };
+      break;
+  }
+  const meta = update._meta?.oxbit;
+  if (meta && "goal" in meta) next = { ...next, goal: meta.goal && typeof meta.goal.status === "string" ? meta.goal : void 0 };
+  if (meta && "loop" in meta) next = { ...next, loop: meta.loop ?? void 0 };
+  return next;
+}
+const modelName = (status) => status.models.find((model) => model.value === status.model)?.name ?? status.model;
+const STOP_NOTES = {
+  cancelled: "Interrupted",
+  max_tokens: "The response reached the output token limit",
+  max_turn_requests: "Stopped after the maximum number of model requests",
+  refusal: "The model declined to answer"
+};
+const message = (error) => error instanceof Error ? error.message : String(error);
+class SessionController {
+  constructor(connection, cwd) {
+    this.connection = connection;
+    this.cwd = cwd;
+    this.state = {
+      cwd,
+      transcript: emptyTranscript(),
+      draft: emptyDraft,
+      running: false,
+      queued: [],
+      status: emptyStatus(),
+      info: connection.info()
+    };
+    this.stop = [connection.onUpdate(this.onUpdate), connection.onPermission(this.onPermission)];
+  }
+  connection;
+  cwd;
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  permissions = [];
+  rules = /* @__PURE__ */ new Set();
+  timer;
+  hintTimer;
+  early;
+  stop;
+  onExit;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => void this.listeners.delete(listener);
+  };
+  getState = () => this.state;
+  notify() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    for (const listener of this.listeners) listener();
+  }
+  /** `soon` coalesces streaming updates into one render per 16 ms. */
+  set(patch, soon = false) {
+    this.state = { ...this.state, ...patch };
+    if (!soon) this.notify();
+    else this.timer ??= setTimeout(() => this.notify(), 16);
+  }
+  transcript(change) {
+    this.set({ transcript: change(this.state.transcript) });
+  }
+  notice(text, tone = "info") {
+    this.transcript((transcript) => append(transcript, { type: "notice", text, tone }));
+  }
+  flash(hint) {
+    clearTimeout(this.hintTimer);
+    this.set({ hint });
+    this.hintTimer = setTimeout(() => this.state.hint === hint && this.set({ hint: void 0 }), 2e3);
+  }
+  onUpdate = (sessionId, update) => {
+    if (this.early) return void this.early.push([sessionId, update]);
+    if (sessionId !== this.state.status.sessionId) return;
+    this.set({ transcript: applyUpdate(this.state.transcript, update), status: applyStatus(this.state.status, update), info: this.connection.info() }, true);
+    if (update.sessionUpdate === "available_commands_update") this.commandsChanged();
+  };
+  commandsChanged() {
+  }
+  onPermission = (request) => new Promise((resolve) => {
+    if (this.rules.has(ruleKey(request))) return resolve(outcomeOf(request, "once").outcome);
+    this.permissions.push({ request, resolve, index: 0 });
+    if (this.permissions.length === 1) this.set({ permission: this.permissions[0] });
+  });
+  /** Opens `sessionId` (or a new session) and replays updates that arrived before the response. */
+  async open(sessionId, label) {
+    if (this.state.running) return this.notice("Wait for the agent to finish, or press Esc to stop it", "warn");
+    this.rules.clear();
+    if (label) this.transcript((transcript) => append(transcript, { type: "divider", text: label }));
+    this.early = [];
+    let session;
+    try {
+      session = sessionId ? await this.connection.loadSession(sessionId, this.cwd) : await this.connection.newSession(this.cwd);
+    } catch (error) {
+      this.notice(message(error), "error");
+    }
+    const early = this.early;
+    this.early = void 0;
+    if (!session) return;
+    this.set({ status: fromSession(session), info: this.connection.info() });
+    for (const [id, update] of early) this.onUpdate(id, update);
+    this.transcript(endTurn);
+  }
+  async send(text) {
+    const sessionId = this.state.status.sessionId;
+    if (!sessionId) return this.notice("There is no open session. Run /new to start one.", "error");
+    this.set({ transcript: append(this.state.transcript, { type: "user", text }), running: true, startedAt: Date.now() });
+    let failed;
+    let stopReason = "end_turn";
+    try {
+      stopReason = (await this.connection.prompt(sessionId, [{ type: "text", text }])).stopReason;
+    } catch (error) {
+      failed = message(error);
+    }
+    let transcript = endTurn(this.state.transcript);
+    if (STOP_NOTES[stopReason]) transcript = append(transcript, { type: "notice", text: STOP_NOTES[stopReason], tone: "warn" });
+    if (failed) transcript = append(transcript, { type: "notice", text: failed, tone: "error" });
+    const [next, ...queued] = this.state.queued;
+    const draft = failed && !this.state.draft.text ? draftOf(text) : this.state.draft;
+    this.set({ transcript, running: false, startedAt: void 0, info: this.connection.info(), draft, queued: failed || !next ? this.state.queued : queued });
+    if (next && !failed) void this.send(next);
+  }
+  /** Stops the running turn; queued prompts return to the input. */
+  cancel() {
+    const sessionId = this.state.status.sessionId;
+    for (const pending of this.permissions.splice(0)) pending.resolve(cancelOutcome());
+    const queued = this.state.queued.join("\n\n");
+    this.set({ permission: void 0, queued: [], ...queued && !this.state.draft.text ? { draft: draftOf(queued) } : {} });
+    if (sessionId && this.state.running) void Promise.resolve(this.connection.cancel(sessionId)).catch(() => {
+    });
+  }
+  decide(decision) {
+    const pending = this.permissions.shift();
+    if (!pending) return;
+    const { outcome, remember } = outcomeOf(pending.request, decision);
+    if (remember) this.rules.add(ruleKey(pending.request));
+    pending.resolve(outcome);
+    this.set({ permission: this.permissions[0] });
+  }
+  cycleMode() {
+    const ids = MODES.map((mode2) => mode2.id);
+    const mode = ids[(ids.indexOf(this.state.status.mode) + 1) % ids.length];
+    const sessionId = this.state.status.sessionId;
+    this.set({ status: { ...this.state.status, mode } });
+    if (sessionId) this.connection.setMode(sessionId, mode).catch((error) => this.notice(message(error), "error"));
+  }
+  openModels() {
+    const { models, model } = this.state.status;
+    if (!models.length) return this.notice("The model list is empty. Check the provider settings.", "warn");
+    this.set({ overlay: { kind: "models", filter: "", index: Math.max(0, models.findIndex((item) => item.value === model)) } });
+  }
+  async chooseModel(modelId) {
+    const { status } = this.state;
+    this.set({ overlay: void 0, status: { ...status, model: modelId } });
+    if (!status.sessionId) return;
+    try {
+      const result = await this.connection.setModel(status.sessionId, modelId);
+      if (result?.configOptions) this.set({ status: { ...this.state.status, ...fromConfig(result.configOptions) } });
+    } catch (error) {
+      this.set({ status: { ...this.state.status, model: status.model } });
+      this.notice(message(error), "error");
+    }
+  }
+  async cycleReasoning(step) {
+    const { reasoning, sessionId } = this.state.status;
+    if (!reasoning || !sessionId || !this.connection.setConfigOption) return;
+    const values = reasoning.options.map((option2) => option2.value);
+    const value = values[(values.indexOf(reasoning.currentValue) + step + values.length) % values.length];
+    this.set({ status: { ...this.state.status, reasoning: { ...reasoning, currentValue: value } } });
+    try {
+      const result = await this.connection.setConfigOption(sessionId, reasoning.id, value);
+      if (result?.configOptions) this.set({ status: { ...this.state.status, ...fromConfig(result.configOptions) } });
+    } catch (error) {
+      this.notice(message(error), "error");
+    }
+  }
+  async openSessions() {
+    try {
+      const sessions = await this.connection.listSessions?.(this.cwd) ?? [];
+      if (!sessions.length) return this.notice("There are no saved sessions for this folder.");
+      this.set({ overlay: { kind: "sessions", filter: "", index: 0, sessions } });
+    } catch (error) {
+      this.notice(message(error), "error");
+    }
+  }
+  commands() {
+    return this.state.status.commands;
+  }
+  exit() {
+    if (this.state.running) this.cancel();
+    this.dispose();
+    this.onExit?.();
+  }
+  dispose() {
+    for (const stop of this.stop.splice(0)) stop();
+    for (const pending of this.permissions.splice(0)) pending.resolve(cancelOutcome());
+    clearTimeout(this.timer);
+    clearTimeout(this.hintTimer);
+  }
+  liveTool(toolCallId) {
+    const item = this.state.transcript.live.find((entry) => entry.type === "tool" && entry.tool.toolCallId === toolCallId);
+    return item?.tool;
+  }
+}
+const LOCAL_COMMANDS = [
+  { name: "model", description: "Choose the model and reasoning effort", hint: "[model]" },
+  { name: "new", description: "Start a new session" },
+  { name: "resume", description: "Resume a saved session" },
+  { name: "help", description: "Show keys and commands" },
+  { name: "exit", description: "Quit" }
+];
+const picker = (overlay) => overlay?.kind === "models" || overlay?.kind === "sessions" ? overlay : void 0;
+function overlayItems(state) {
+  const overlay = state.overlay;
+  if (overlay?.kind === "models")
+    return rank(state.status.models, (model) => `${model.name} ${model.value}`, overlay.filter, 200).map((model) => ({ value: model.value, label: model.name, ...model.name !== model.value ? { detail: model.value } : {} }));
+  if (overlay?.kind === "sessions")
+    return rank(overlay.sessions, (session) => session.title ?? session.sessionId, overlay.filter, 200).map((session) => ({ value: session.sessionId, label: session.title || session.sessionId, detail: session.updatedAt?.slice(0, 16).replace("T", " ") }));
+  return [];
+}
+class Controller extends SessionController {
+  constructor(connection, options) {
+    super(connection, options.cwd);
+    this.options = options;
+    this.history = options.history?.load() ?? [];
+  }
+  options;
+  history;
+  historyIndex = -1;
+  stash = emptyDraft;
+  dismissed;
+  fileTimer;
+  files = /* @__PURE__ */ new Map();
+  lastInterrupt = 0;
+  commands() {
+    const local = LOCAL_COMMANDS.filter((command) => command.name !== "resume" || this.connection.listSessions);
+    return [...this.state.status.commands.filter((command) => !local.some((item) => item.name === command.name)), ...local];
+  }
+  submit() {
+    const text = this.state.draft.text.replace(/\s+$/, "");
+    if (!text.trim()) return;
+    if (this.history.at(-1) !== text) {
+      this.history.push(text);
+      this.options.history?.save(text);
+    }
+    this.historyIndex = -1;
+    this.dismissed = void 0;
+    this.set({ draft: emptyDraft, completion: void 0 });
+    if (text.startsWith("/") && this.local(text)) return;
+    if (this.state.running) this.set({ queued: [...this.state.queued, text] });
+    else void this.send(text);
+  }
+  local(text) {
+    const [, name, rest] = /^\/(\S+)\s*([\s\S]*)$/.exec(text) ?? [];
+    const args = rest?.trim() ?? "";
+    switch (name) {
+      case "model":
+        if (args) void this.chooseModel(args);
+        else this.openModels();
+        return true;
+      case "new":
+        void this.open(void 0, "New session");
+        return true;
+      case "resume":
+        if (!this.connection.listSessions && !args) return false;
+        if (args) void this.open(args, "Resumed session");
+        else void this.openSessions();
+        return true;
+      case "help":
+        this.set({ overlay: { kind: "help" } });
+        return true;
+      case "exit":
+      case "quit":
+        this.exit();
+        return true;
+    }
+    return false;
+  }
+  commandsChanged() {
+    if (commandToken(this.state.draft)) this.set({ completion: this.completionFor(this.state.draft) }, true);
+  }
+  /** Sets the draft and recomputes slash and @file completion. */
+  setDraft(draft) {
+    this.set({ draft, completion: this.completionFor(draft) });
+  }
+  paste(text) {
+    const clean = text.replace(/\r\n?/g, "\n");
+    const overlay = this.state.overlay;
+    if (picker(overlay)) return this.filter(picker(overlay).filter + clean.replace(/\n/g, " "));
+    if (overlay) return;
+    this.setDraft(insert(this.state.draft, clean));
+  }
+  completionFor(draft) {
+    if (this.dismissed === draft.text) return void 0;
+    this.dismissed = void 0;
+    const command = commandToken(draft);
+    if (command) {
+      const items2 = commandItems(this.commands(), command.query);
+      return items2.length ? { kind: "command", items: items2, index: 0, ...command } : void 0;
+    }
+    const file = fileToken(draft);
+    if (!file || !this.connection.listFiles) return void 0;
+    const known = this.files.get(file.query);
+    if (!known) this.lookup(file.query);
+    const items = fileItems(known ?? [...new Set([...this.files.values()].flat())], file.query);
+    return items.length ? { kind: "file", items, index: 0, ...file } : void 0;
+  }
+  lookup(query) {
+    clearTimeout(this.fileTimer);
+    this.fileTimer = setTimeout(() => {
+      void this.connection.listFiles(query, this.options.cwd).then((paths) => {
+        this.files.set(query, paths);
+        if (fileToken(this.state.draft)?.query === query) this.set({ completion: this.completionFor(this.state.draft) });
+      }, () => {
+      });
+    }, 50);
+  }
+  moveCompletion(step) {
+    const completion = this.state.completion;
+    if (completion) this.set({ completion: { ...completion, index: (completion.index + step + completion.items.length) % completion.items.length } });
+  }
+  dismissCompletion() {
+    this.dismissed = this.state.draft.text;
+    this.set({ completion: void 0 });
+  }
+  /** Inserts the selected item; with `run`, a command that takes no arguments is sent at once. */
+  acceptCompletion(run2) {
+    const completion = this.state.completion;
+    if (!completion) return;
+    const item = completion.items[completion.index];
+    const command = completion.kind === "command" ? this.commands().find((entry) => `/${entry.name}` === item.value) : void 0;
+    if (run2 && command && !command.hint) {
+      this.set({ draft: draftOf(item.value) });
+      return this.submit();
+    }
+    this.setDraft(accept(this.state.draft, completion, item));
+  }
+  /** Walks prompt history; false when there is nothing to recall, so the caller can move the cursor instead. */
+  recall(step) {
+    if (!this.history.length || this.historyIndex < 0 && step > 0) return false;
+    if (this.historyIndex < 0) this.stash = this.state.draft;
+    const index = this.historyIndex < 0 ? this.history.length - 1 : this.historyIndex + step;
+    if (index < 0) return true;
+    this.historyIndex = index >= this.history.length ? -1 : index;
+    this.setDraft(this.historyIndex < 0 ? this.stash : draftOf(this.history[index]));
+    return true;
+  }
+  filter(text) {
+    const overlay = picker(this.state.overlay);
+    if (overlay) this.set({ overlay: { ...overlay, filter: text, index: 0 } });
+  }
+  moveOverlay(step) {
+    const overlay = picker(this.state.overlay);
+    const count = overlayItems(this.state).length;
+    if (overlay && count) this.set({ overlay: { ...overlay, index: (overlay.index + step + count) % count } });
+  }
+  confirmOverlay() {
+    const overlay = picker(this.state.overlay);
+    const item = overlay ? overlayItems(this.state)[overlay.index] : void 0;
+    this.set({ overlay: void 0 });
+    if (item && overlay?.kind === "models") void this.chooseModel(item.value);
+    if (item && overlay?.kind === "sessions") void this.open(item.value, `Resumed ${item.label}`);
+  }
+  /** Ctrl+O: shows the latest thought, tool output or diff in full; `step` moves to an earlier or later one. */
+  showDetails(step = 0) {
+    const { transcript, overlay } = this.state;
+    const items = [...transcript.flushed, ...transcript.live].filter(expandable);
+    if (!items.length) return this.flash("Nothing to expand yet");
+    const at = overlay?.kind === "details" ? items.findIndex((item) => item.id === overlay.id) : items.length;
+    const next = items[Math.min(items.length - 1, Math.max(0, at + step - (overlay?.kind === "details" ? 0 : 1)))];
+    this.set({ overlay: { kind: "details", id: next.id } });
+  }
+  /** Ctrl+C: stop the turn, close or clear, and exit on a second press within two seconds. */
+  interrupt() {
+    const now = Date.now();
+    if (now - this.lastInterrupt < 2e3) return this.exit();
+    this.lastInterrupt = now;
+    if (this.state.running || this.state.permission) this.cancel();
+    else if (this.state.overlay) this.set({ overlay: void 0 });
+    else if (this.state.draft.text) this.setDraft(emptyDraft);
+    this.flash("Press Ctrl+C again to exit");
+  }
+  dispose() {
+    super.dispose();
+    clearTimeout(this.fileTimer);
+  }
+}
+const KEYS = [
+  ["enter", "send"],
+  ["shift+enter, alt+enter, ctrl+j, \\ enter", "new line"],
+  ["↑ ↓", "history, or move between lines"],
+  ["esc", "stop the agent, close a menu"],
+  ["ctrl+c", "stop, then press again to exit"],
+  ["shift+tab", "switch the mode"],
+  ["ctrl+o", "show tool output, diffs and thinking in full"],
+  ["ctrl+p, /model", "choose the model"],
+  ["/ and @", "complete commands and files"],
+  ["ctrl+a e u k w", "line editing"]
+];
+function windowOf(items, index, size) {
+  const start = Math.min(Math.max(0, index - size + 1), Math.max(0, items.length - size));
+  return { start, rows: items.slice(start, start + size) };
+}
+function PickList({ items, index, width: width$1, size = 8 }) {
+  const theme = useTheme();
+  const { start, rows } = windowOf(items, index, size);
+  const label = Math.min(Math.max(...rows.map((item) => width(item.label)), 8) + 3, Math.floor(width$1 * 0.5));
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: width$1, children: [
+    start > 0 ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      "  ↑ ",
+      start,
+      " more"
+    ] }) : null,
+    rows.map((item, at) => {
+      const selected2 = start + at === index;
+      return /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: label, flexShrink: 0, children: /* @__PURE__ */ jsxs(Text, { color: selected2 ? theme.accent : void 0, bold: selected2, wrap: "truncate-end", children: [
+          selected2 ? "❯ " : "  ",
+          item.label
+        ] }) }),
+        item.detail ? /* @__PURE__ */ jsx(Box, { flexShrink: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.muted, wrap: "truncate-end", children: item.detail }) }) : null
+      ] }, item.value);
+    }),
+    start + rows.length < items.length ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      "  ↓ ",
+      items.length - start - rows.length,
+      " more"
+    ] }) : null
+  ] });
+}
+function PermissionDialog({ pending, controller, width: width2, cwd }) {
+  const theme = useTheme();
+  const { request, index } = pending;
+  const call = request.toolCall;
+  const diffs = (call.content ?? []).filter((block) => block.type === "diff").map((block) => ({ path: String(block.path ?? ""), oldText: block.oldText ?? null, newText: String(block.newText ?? "") }));
+  const shown = controller.liveTool(call.toolCallId)?.diffs.length ? [] : diffs;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.warning, paddingX: 1, width: width2, marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: theme.warning, children: question(request) }),
+    /* @__PURE__ */ jsxs(Box, { marginY: 1, flexDirection: "column", children: [
+      call.kind === "execute" ? /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+        /* @__PURE__ */ jsx(Text, { color: theme.accent, children: "$ " }),
+        commandOf(request)
+      ] }) : /* @__PURE__ */ jsx(Text, { bold: true, wrap: "wrap", children: relative(cwd, call.title ?? "Tool call") }),
+      shown.map((diff, at) => /* @__PURE__ */ jsx(DiffView, { diff, cwd, limit: 10 }, at))
+    ] }),
+    DECISIONS.map((decision, at) => /* @__PURE__ */ jsxs(Text, { color: at === index ? theme.accent : void 0, bold: at === index, wrap: "wrap", children: [
+      at === index ? "❯" : " ",
+      " ",
+      at + 1,
+      ". ",
+      decisionLabel(request, decision)
+    ] }, decision)),
+    /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "↑↓ select · enter confirm · 1-3 · esc deny" })
+  ] });
+}
+function OverlayView({ state, width: width2 }) {
+  const theme = useTheme();
+  const overlay = state.overlay;
+  if (overlay.kind === "help") {
+    const key = Math.min(40, Math.floor(width2 * 0.45));
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, width: width2, marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "Keys" }),
+      KEYS.map(([keys, action]) => /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx(Box, { width: key, flexShrink: 0, paddingRight: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.accent, wrap: "wrap", children: keys }) }),
+        /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: action })
+      ] }, keys)),
+      /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+        "\n",
+        "Modes"
+      ] }),
+      MODES.map((mode) => /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+        /* @__PURE__ */ jsx(Text, { color: theme.modes[mode.id], children: mode.name }),
+        /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+          " · ",
+          mode.description
+        ] })
+      ] }, mode.id)),
+      /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+        "\n",
+        "Type / to list commands. esc closes this help."
+      ] })
+    ] });
+  }
+  if (overlay.kind === "details") return null;
+  const items = overlayItems(state);
+  const reasoning = overlay.kind === "models" ? state.status.reasoning : void 0;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, width: width2, marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, children: overlay.kind === "models" ? "Choose a model" : "Resume a session" }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { color: theme.accent, children: "› " }),
+      overlay.filter,
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+      overlay.filter ? null : /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "type to filter" })
+    ] }),
+    items.length ? /* @__PURE__ */ jsx(PickList, { items, index: overlay.index, width: width2 - 4, size: 10 }) : /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "No matches" }),
+    reasoning ? /* @__PURE__ */ jsxs(Text, { children: [
+      "Reasoning ",
+      /* @__PURE__ */ jsx(Text, { color: theme.muted, children: "◂ " }),
+      /* @__PURE__ */ jsx(Text, { color: theme.accent, children: reasoning.options.find((option2) => option2.value === reasoning.currentValue)?.name ?? reasoning.currentValue }),
+      /* @__PURE__ */ jsx(Text, { color: theme.muted, children: " ▸" })
+    ] }) : null,
+    /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      "↑↓ select · enter choose",
+      reasoning ? " · ←→ reasoning" : "",
+      " · esc close"
+    ] })
+  ] });
+}
+function permissionKey(controller, input, key) {
+  const pending = controller.getState().permission;
+  const choose = (index) => controller.decide(DECISIONS[index]);
+  if (key.upArrow || key.downArrow) {
+    const index = (pending.index + (key.upArrow ? -1 : 1) + DECISIONS.length) % DECISIONS.length;
+    return controller.set({ permission: { ...pending, index } });
+  }
+  if (key.return) return choose(pending.index);
+  if (key.escape) return controller.decide("deny");
+  const shortcut = { 1: 0, 2: 1, 3: 2, y: 0, a: 1, n: 2 }[input.toLowerCase()];
+  if (shortcut !== void 0) choose(shortcut);
+}
+function overlayKey(controller, input, key) {
+  const overlay = controller.getState().overlay;
+  if (overlay.kind === "details") {
+    if (key.escape || key.return || input === "q" || key.ctrl && input === "o") controller.set({ overlay: void 0 });
+    else if (key.leftArrow || key.rightArrow) controller.showDetails(key.leftArrow ? -1 : 1);
+    return;
+  }
+  if (overlay.kind === "help") {
+    if (key.escape || key.return || input === "q") controller.set({ overlay: void 0 });
+    return;
+  }
+  if (key.escape) return controller.set({ overlay: void 0 });
+  if (key.upArrow || key.downArrow) return controller.moveOverlay(key.upArrow ? -1 : 1);
+  if (key.return) return controller.confirmOverlay();
+  if (overlay.kind === "models" && (key.leftArrow || key.rightArrow)) return void controller.cycleReasoning(key.leftArrow ? -1 : 1);
+  if (key.backspace || key.delete) return controller.filter(overlay.filter.slice(0, -1));
+  if (input && !key.ctrl && !key.meta && !key.tab) controller.filter(overlay.filter + input);
+}
+function handleKey(controller, input, key) {
+  const state = controller.getState();
+  const draft = state.draft;
+  const edit = controller.setDraft.bind(controller);
+  if (key.ctrl && input === "c") return controller.interrupt();
+  if (state.permission) return permissionKey(controller, input, key);
+  if (state.overlay) return overlayKey(controller, input, key);
+  if (key.tab && key.shift) return controller.cycleMode();
+  if (key.ctrl && input === "o") return controller.showDetails();
+  if (key.ctrl && input === "p") return controller.openModels();
+  if (key.ctrl && input === "d") return draft.text ? edit(deleteForward(draft)) : controller.exit();
+  if (key.escape) {
+    if (state.completion) return controller.dismissCompletion();
+    if (state.running) return controller.cancel();
+    return;
+  }
+  if (state.completion) {
+    if (key.upArrow || key.downArrow) return controller.moveCompletion(key.upArrow ? -1 : 1);
+    if (key.tab) return controller.acceptCompletion(false);
+    if (key.return && !key.shift && !key.meta) return controller.acceptCompletion(true);
+  }
+  if (key.return) {
+    if (key.shift || key.meta) return edit(insert(draft, "\n"));
+    if (draft.text[draft.cursor - 1] === "\\") return edit(insert(backspace(draft), "\n"));
+    return controller.submit();
+  }
+  if (input === "\n" || key.ctrl && input === "j") return edit(insert(draft, "\n"));
+  if (key.upArrow || key.downArrow) {
+    const step = key.upArrow ? -1 : 1;
+    const moved = vertical(draft, step);
+    if (moved) return edit(moved);
+    return void controller.recall(step);
+  }
+  if (key.leftArrow) return edit(key.meta || key.ctrl ? wordLeft(draft) : left(draft));
+  if (key.rightArrow) return edit(key.meta || key.ctrl ? wordRight(draft) : right(draft));
+  if (key.home || key.ctrl && input === "a") return edit(home(draft));
+  if (key.end || key.ctrl && input === "e") return edit(end(draft));
+  if (key.backspace) return edit(key.meta || key.ctrl ? deleteWordLeft(draft) : backspace(draft));
+  if (key.delete) return edit(deleteForward(draft));
+  if (key.ctrl && input === "w") return edit(deleteWordLeft(draft));
+  if (key.ctrl && input === "u") return edit(killLineLeft(draft));
+  if (key.ctrl && input === "k") return edit(killLineRight(draft));
+  if (key.meta && input === "b") return edit(wordLeft(draft));
+  if (key.meta && input === "f") return edit(wordRight(draft));
+  if (input && !key.ctrl && !key.meta && !key.tab) edit(insert(draft, input.replace(/\r\n?/g, "\n")));
+}
+const MODE_LABELS = { ask: "◇ ask", "accept-edits": "⏵⏵ accept edits", "full-auto": "⏵⏵⏵ full auto" };
+function PromptBox({ state, width: width2 }) {
+  const theme = useTheme();
+  const empty = !state.draft.text;
+  const placeholder = state.running ? "Queue a message · esc to stop the agent" : "Ask anything · / for commands · @ for files";
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: theme.border, paddingX: 1, width: width2, children: [
+    /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.accent, bold: true, children: "›" }) }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", flexGrow: 1, flexShrink: 1, children: empty ? /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+      /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: theme.muted, children: placeholder })
+    ] }) : cursorLines(state.draft).map((line, index) => /* @__PURE__ */ jsxs(Text, { wrap: "wrap", children: [
+      line.before,
+      line.under === void 0 ? line.before ? "" : " " : /* @__PURE__ */ jsx(Text, { inverse: true, children: line.under }),
+      line.after ?? ""
+    ] }, index)) })
+  ] });
+}
+const elapsed = (ms) => {
+  const seconds = Math.floor(ms / 1e3);
+  return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
+};
+function Working({ state }) {
+  const theme = useTheme();
+  const { frame } = useAnimation({ interval: 100 });
+  const last = state.transcript.live.at(-1);
+  const label = last?.type === "thought" && !last.done ? "Thinking" : last?.type === "tool" && !last.done ? "Running" : "Working";
+  return /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+    /* @__PURE__ */ jsxs(Text, { color: theme.accent, children: [
+      SPINNER[frame % SPINNER.length],
+      " ",
+      label,
+      "…"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: theme.muted, children: [
+      " (",
+      elapsed(Date.now() - (state.startedAt ?? Date.now())),
+      " · esc to interrupt)"
+    ] })
+  ] }) });
+}
+function fitSegments(segments, budget, separator = " · ") {
+  const kept = /* @__PURE__ */ new Set();
+  let used = 0;
+  for (const segment of [...segments].sort((a, b) => a.priority - b.priority)) {
+    const size = width(segment.text) + (kept.size ? width(separator) : 0);
+    if (used + size <= budget) {
+      kept.add(segment);
+      used += size;
+    }
+  }
+  return segments.filter((segment) => kept.has(segment));
+}
+function StatusLine({ state, width: width$1 }) {
+  const theme = useTheme();
+  const { status, info, hint } = state;
+  const usage = status.usage ? Math.min(100, Math.round(status.usage.used / status.usage.size * 100)) : void 0;
+  const effort = status.reasoning && status.reasoning.currentValue !== "default" ? ` (${status.reasoning.currentValue})` : "";
+  const model = modelName(status);
+  const budget = Math.max(10, width$1 - 2);
+  const loopText = status.loop && [
+    `↻ loop`,
+    status.loop.iteration ? ` ${status.loop.iteration}${status.loop.max ? `/${status.loop.max}` : ""}` : "",
+    status.loop.status ? ` ${status.loop.status}` : "",
+    status.loop.interval ? ` · every ${status.loop.interval}` : ""
+  ].join("");
+  const left2 = fitSegments([
+    hint ? { text: hint, color: theme.warning, priority: 0 } : { text: `${MODE_LABELS[status.mode] ?? status.mode}${width$1 >= 80 ? " (shift+tab)" : ""}`, color: theme.modes[status.mode], priority: 0 },
+    ...status.goal ? [{ text: `◎ goal ${status.goal.status}`, color: theme.accent, priority: 1 }] : [],
+    ...loopText ? [{ text: loopText, color: theme.accent, priority: 2 }] : []
+  ], budget, "  ");
+  const beside = budget - width(left2.map((segment) => segment.text).join("  ")) - 2;
+  const segments = [
+    ...status.title ? [{ text: truncate(status.title, 32), priority: 4 }] : [],
+    ...model ? [{ text: truncate(`${model}${effort}`, 40), priority: 0 }] : [],
+    ...info.usingChatGPTPlan ? [{ text: "Using ChatGPT plan", color: theme.success, priority: 1 }] : info.provider ? [{ text: info.provider, priority: 3 }] : [],
+    ...usage !== void 0 ? [{ text: `${usage}% context`, color: usage >= 90 ? theme.error : usage >= 70 ? theme.warning : void 0, priority: 2 }] : [],
+    { text: truncateStart(state.cwd.replace(process.env.HOME ?? "\0", "~"), 30), priority: 5 }
+  ];
+  const inline = fitSegments(segments, beside);
+  const right2 = inline.length >= segments.filter((segment) => segment.priority < 5).length ? inline : fitSegments(segments, budget);
+  return /* @__PURE__ */ jsxs(Box, { width: width$1, paddingX: 1, flexWrap: "wrap", justifyContent: "space-between", columnGap: 2, children: [
+    /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", children: left2.map((segment, index) => /* @__PURE__ */ jsxs(Text, { color: segment.color, children: [
+      index ? "  " : "",
+      segment.text
+    ] }, index)) }),
+    /* @__PURE__ */ jsx(Text, { wrap: "truncate-end", color: theme.muted, children: right2.map((segment, index) => /* @__PURE__ */ jsxs(Text, { color: segment.color, children: [
+      index ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: " · " }) : null,
+      segment.text
+    ] }, index)) })
+  ] });
+}
+function Screen({ controller, version }) {
+  const state = useSyncExternalStore(controller.subscribe, controller.getState);
+  const theme = useTheme();
+  const { columns, rows } = useWindowSize();
+  const width2 = Math.max(20, columns);
+  useInput((input, key) => handleKey(controller, input, key));
+  usePaste((text) => controller.paste(text));
+  const context = { width: width2, rows, expanded: false, cwd: state.cwd, version, awaiting: state.permission?.request.toolCall.toolCallId };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: width2, children: [
+    /* @__PURE__ */ jsx(Static, { items: state.transcript.flushed, children: (item) => /* @__PURE__ */ jsx(Box, { width: width2, flexDirection: "column", children: /* @__PURE__ */ jsx(ItemView, { item, context }) }, item.id) }),
+    state.transcript.live.map((item) => /* @__PURE__ */ jsx(ItemView, { item, live: true, context }, item.id)),
+    state.permission ? /* @__PURE__ */ jsx(PermissionDialog, { pending: state.permission, controller, width: width2, cwd: state.cwd }) : state.overlay?.kind === "details" ? /* @__PURE__ */ jsx(Details, { id: state.overlay.id, transcript: state.transcript, context }, state.overlay.id) : state.overlay ? /* @__PURE__ */ jsx(OverlayView, { state, width: width2 }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      state.running ? /* @__PURE__ */ jsx(Working, { state }) : null,
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+        state.queued.map((text, index) => /* @__PURE__ */ jsxs(Text, { color: theme.muted, wrap: "truncate-end", children: [
+          "  ⏎ queued: ",
+          truncate(text.replace(/\n/g, " "), width2 - 14)
+        ] }, index)),
+        /* @__PURE__ */ jsx(PromptBox, { state, width: width2 })
+      ] }),
+      state.completion ? /* @__PURE__ */ jsx(PickList, { items: state.completion.items, index: state.completion.index, width: width2 }) : null
+    ] }),
+    /* @__PURE__ */ jsx(StatusLine, { state, width: width2 })
+  ] });
+}
+function App({ controller, theme, version }) {
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value: theme, children: /* @__PURE__ */ jsx(Screen, { controller, version }) });
+}
+const FILE_LIST_TTL_MS = 1e4;
+const FILE_MATCHES = 2e3;
+const HISTORY_LIMIT = 500;
+const subsequence = (query, path) => {
+  let at = 0;
+  for (const char of query) {
+    at = path.indexOf(char, at) + 1;
+    if (!at) return false;
+  }
+  return true;
+};
+function memoryTuiConnection(connection, options = {}) {
+  const listed = /* @__PURE__ */ new Map();
+  const files = (cwd) => {
+    const cached = listed.get(cwd);
+    if (cached && Date.now() - cached.at < FILE_LIST_TTL_MS) return cached.files;
+    const entry = { at: Date.now(), files: walkFiles(cwd).catch(() => []) };
+    listed.set(cwd, entry);
+    return entry.files;
+  };
+  return {
+    info: () => ({ provider: options.provider, usingChatGPTPlan: options.usingChatGPTPlan }),
+    async newSession(cwd) {
+      const state = await connection.newSession({ cwd });
+      if (!options.mode || !state.modes || state.modes.currentModeId === options.mode) return state;
+      await connection.setMode(state.sessionId, options.mode);
+      return { ...state, modes: { ...state.modes, currentModeId: options.mode } };
+    },
+    loadSession: async (sessionId, cwd) => await connection.loadSession(sessionId, { cwd }),
+    listSessions: async (cwd) => (await connection.listSessions(cwd)).sessions,
+    prompt: (sessionId, prompt) => connection.prompt(sessionId, prompt),
+    cancel: (sessionId) => connection.cancel(sessionId),
+    setMode: (sessionId, modeId) => connection.setMode(sessionId, modeId),
+    setModel: async (sessionId, modelId) => await connection.setModel(sessionId, modelId),
+    setConfigOption: async (sessionId, configId, value) => await connection.setConfigOption(sessionId, configId, value),
+    onUpdate: (listener) => connection.onUpdate((sessionId, update) => listener(sessionId, update)),
+    onPermission: (handler) => connection.onPermission(async (request) => (await handler(request)).outcome),
+    async listFiles(query, cwd) {
+      const term = query.toLowerCase();
+      return (await files(cwd)).filter((path) => subsequence(term, path.toLowerCase())).slice(0, FILE_MATCHES);
+    }
+  };
+}
+function fileHistory(path) {
+  return {
+    load() {
+      try {
+        return readFileSync(path, "utf8").split("\n").flatMap((line) => {
+          try {
+            const entry = JSON.parse(line);
+            return typeof entry === "string" ? [entry] : [];
+          } catch {
+            return [];
+          }
+        }).slice(-HISTORY_LIMIT);
+      } catch {
+        return [];
+      }
+    },
+    save(entry) {
+      try {
+        mkdirSync(dirname(path), { recursive: true, mode: 448 });
+        appendFileSync(path, `${JSON.stringify(entry)}
+`, { mode: 384 });
+        const lines = readFileSync(path, "utf8").split("\n").filter(Boolean);
+        if (lines.length > HISTORY_LIMIT * 2) writeFileSync(path, `${lines.slice(-HISTORY_LIMIT).join("\n")}
+`, { mode: 384 });
+      } catch {
+      }
+    }
+  };
+}
+async function run(connection, options) {
+  const controller = new Controller(connection, { cwd: options.cwd, history: options.history });
+  const exited = new Promise((resolve) => {
+    controller.onExit = resolve;
+  });
+  const streams = Object.fromEntries(Object.entries({ stdin: options.stdin, stdout: options.stdout, stderr: options.stderr }).filter(([, value]) => value));
+  const instance = render(/* @__PURE__ */ jsx(App, { controller, theme: resolveTheme(options.theme), version: options.version }), {
+    ...streams,
+    exitOnCtrlC: false,
+    ...options.debug ? { debug: true } : { kittyKeyboard: { mode: "auto" } }
+  });
+  void controller.open(options.sessionId).then(() => {
+    if (!options.prompt) return;
+    controller.setDraft(draftOf(options.prompt));
+    controller.submit();
+  });
+  try {
+    await Promise.race([exited, instance.waitUntilExit()]);
+  } finally {
+    controller.dispose();
+    instance.unmount();
+  }
+  return { sessionId: controller.getState().status.sessionId };
+}
+async function runTui(options) {
+  const connection = memoryTuiConnection(
+    options.connection,
+    { provider: options.providerLabel, usingChatGPTPlan: options.usingChatGPTPlan, mode: options.mode }
+  );
+  const { sessionId } = await run(connection, {
+    cwd: options.cwd,
+    sessionId: options.sessionId,
+    prompt: options.prompt,
+    version: options.version,
+    history: options.historyPath ? fileHistory(options.historyPath) : void 0,
+    stdin: options.stdin,
+    stdout: options.stdout,
+    stderr: options.stderr
+  });
+  if (sessionId) (options.stderr ?? process.stderr).write(`Resume this session with: oxbit-agent -r ${sessionId}
+`);
+  return 0;
+}
+export {
+  markdownToAnsi,
+  run,
+  runTui
+};
+//# sourceMappingURL=index-BrBnidfI.js.map