@codemap-ai/cli 0.1.0

package/dist/pi-tui-app-GVZ3AN42.js

@@ -0,0 +1,2073 @@
+import{createRequire as __cmr}from"node:module";import{fileURLToPath as __f2p}from"node:url";import{dirname as __dn}from"node:path";var require=__cmr(import.meta.url);var __filename=__f2p(import.meta.url);var __dirname=__dn(__filename);
+import {
+  isGatewayOffline
+} from "./chunk-A2QHID6K.js";
+import {
+  getCommandList,
+  searchIndexedFiles
+} from "./chunk-KWYP3ADN.js";
+import {
+  getMastraMessages
+} from "./chunk-FFFJKKKM.js";
+import {
+  BG_USER,
+  BOLD,
+  C_ACTION,
+  C_AI,
+  C_ARCH,
+  C_CYAN,
+  C_ERROR,
+  C_GRAY,
+  C_GREEN,
+  C_MUTED,
+  C_PURPLE,
+  C_RED,
+  C_SUCCESS,
+  C_WARNING,
+  C_WHITE,
+  DIM,
+  RESET,
+  SPINNER,
+  formatElapsed,
+  formatTime,
+  formatTokenCount,
+  gradientStr,
+  truncate
+} from "./chunk-YRXVMFXS.js";
+import "./chunk-AXGGL47C.js";
+
+// src/cli-agent/chat/ui/pi-tui-app.ts
+import {
+  Editor,
+  Key,
+  matchesKey,
+  ProcessTerminal,
+  TUI
+} from "@earendil-works/pi-tui";
+
+// src/cli-agent/chat/ui/pi-tui/message-renderer.ts
+import cfonts from "cfonts";
+import { truncateToWidth, visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
+
+// src/cli-agent/chat/ui/pi-tui/text.ts
+import { CURSOR_MARKER, visibleWidth } from "@earendil-works/pi-tui";
+import { DiffLineType, DiffParser } from "@git-diff-view/core";
+import { Marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+
+// src/cli-agent/chat/ui/pi-tui/shiki-highlight.ts
+var THEME = "dracula";
+var LANGS = [
+  "typescript",
+  "javascript",
+  "dart",
+  "php",
+  "python",
+  "java",
+  "kotlin",
+  "json",
+  "bash",
+  "diff",
+  "sql",
+  "markdown",
+  "yaml",
+  "toml",
+  "html",
+  "css",
+  "rust",
+  "go",
+  "ruby",
+  "swift",
+  "c",
+  "cpp",
+  "vue"
+];
+var LANG_ALIASES = {
+  ts: "typescript",
+  tsx: "typescript",
+  js: "javascript",
+  jsx: "javascript",
+  mjs: "javascript",
+  cjs: "javascript",
+  shell: "bash",
+  sh: "bash",
+  kt: "kotlin",
+  kts: "kotlin",
+  py: "python",
+  jsonc: "json",
+  md: "markdown",
+  mdx: "markdown",
+  yml: "yaml",
+  rs: "rust",
+  rb: "ruby",
+  cs: "c"
+  // C# approximation
+};
+var highlighter = null;
+var initPromise = null;
+async function initShiki() {
+  if (highlighter || initPromise) return;
+  initPromise = (async () => {
+    const { createHighlighter } = await import("shiki");
+    highlighter = await createHighlighter({ themes: [THEME], langs: [...LANGS] });
+  })();
+  return initPromise;
+}
+function hexToAnsi(hex) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+function resolveLang(raw) {
+  const lower = raw.toLowerCase().trim();
+  const resolved = LANG_ALIASES[lower] ?? lower;
+  return LANGS.includes(resolved) ? resolved : null;
+}
+function highlightBlock(code, rawLang) {
+  const lang = resolveLang(rawLang);
+  if (!highlighter || !lang) return code.split("\n");
+  try {
+    const tokenLines = highlighter.codeToTokensBase(code, { lang, theme: THEME });
+    return tokenLines.map((tokens) => {
+      if (tokens.length === 0) return "";
+      return tokens.map(
+        (t) => t.color ? `${hexToAnsi(t.color)}${t.content}${RESET}` : t.content
+      ).join("") + RESET;
+    });
+  } catch {
+    return code.split("\n");
+  }
+}
+function isShikiReady() {
+  return highlighter !== null;
+}
+
+// src/cli-agent/chat/ui/pi-tui/text.ts
+function workspaceStateCardLines(state, mode, width) {
+  const project = state.projectName ?? state.repoName ?? "local workspace";
+  const branch = state.branch ?? "unknown branch";
+  const indexColor = state.isIndexStale ? C_WARNING : state.indexStatus === "failed" ? C_ERROR : C_SUCCESS;
+  const index = `${indexColor}${state.indexStatus}${RESET}${state.indexUpdatedAt ? `${C_GRAY} \xB7 ${state.indexUpdatedAt}${RESET}` : ""}`;
+  const changes = state.hasLocalChanges ? `${C_WARNING}${state.changedFilesCount} files${RESET}` : `${C_SUCCESS}none${RESET}`;
+  const basis = state.includeDiff ? "indexed + local diff" : "indexed only";
+  const lines = [
+    `${BOLD}Workspace${RESET} ${C_GRAY}Project:${RESET} ${project}  ${C_GRAY}Branch:${RESET} ${branch}  ${C_GRAY}Mode:${RESET} ${mode}`,
+    `${C_GRAY}Index:${RESET} ${index}  ${C_GRAY}Local changes:${RESET} ${changes}  ${C_GRAY}Basis:${RESET} ${basis}`
+  ];
+  if (state.isIndexStale) lines.push(`${C_WARNING}Index may be stale. Use current diff or refresh index before relying on graph-only answers.${RESET}`);
+  return lines.flatMap((line) => wrapPlain(line, Math.max(20, width)));
+}
+var RENDERER_METHODS = [
+  "blockquote",
+  "br",
+  "code",
+  "codespan",
+  "del",
+  "em",
+  "heading",
+  "hr",
+  "html",
+  "image",
+  "link",
+  "list",
+  "listitem",
+  "paragraph",
+  "strong",
+  "table",
+  "text"
+];
+var BG_DIFF_DELETE = "\x1B[48;2;69;10;10m";
+var BG_DIFF_ADD = "\x1B[48;2;0;55;18m";
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(CURSOR_MARKER, "");
+}
+function padToWidth(line, width) {
+  const pad = Math.max(0, width - visibleWidth(line));
+  return line + " ".repeat(pad);
+}
+function truncateVisible(line, width) {
+  if (visibleWidth(line) <= width) return line;
+  let out = "";
+  for (const ch of line) {
+    if (visibleWidth(out + ch) > Math.max(0, width - 1)) break;
+    out += ch;
+  }
+  return out + "\u2026";
+}
+function fitLine(line, width) {
+  return padToWidth(truncateVisible(line, width), width);
+}
+function wrapPlain(text, width) {
+  const max = Math.max(1, width);
+  const out = [];
+  for (const para of text.split("\n")) {
+    let remaining = para;
+    if (remaining.length === 0) {
+      out.push("");
+      continue;
+    }
+    while (visibleWidth(remaining) > max) {
+      let vis = 0;
+      let i = 0;
+      let lastSpaceI = -1;
+      while (i < remaining.length) {
+        if (remaining.charCodeAt(i) === 27 && remaining[i + 1] === "[") {
+          const end = remaining.indexOf("m", i + 2);
+          if (end !== -1) {
+            i = end + 1;
+            continue;
+          }
+        }
+        if (remaining[i] === " ") lastSpaceI = i;
+        vis++;
+        i++;
+        if (vis >= max) break;
+      }
+      const breakAt = lastSpaceI > 0 ? lastSpaceI : i;
+      out.push(remaining.slice(0, breakAt).trimEnd());
+      remaining = remaining.slice(breakAt).trimStart();
+    }
+    out.push(remaining);
+  }
+  return out;
+}
+var CODE_LANG_ALIASES = {
+  bash: "sh",
+  shell: "sh",
+  javascript: "js",
+  jsx: "js",
+  jsonc: "json",
+  kotlin: "kt",
+  typescript: "ts",
+  tsx: "ts"
+};
+var KEYWORD_LANGS = /* @__PURE__ */ new Set(["ts", "js", "dart", "java", "kt", "kotlin"]);
+var KEYWORDS = /\b(abstract|as|async|await|break|case|catch|class|const|continue|default|do|else|enum|export|extends|final|finally|for|fun|function|if|implements|import|in|interface|let|new|null|override|package|private|protected|public|return|static|super|switch|this|throw|throws|try|type|val|var|void|when|while|yield)\b/g;
+var STRING_RE = /("([^"\\]|\\.)*"|'([^'\\]|\\.)*'|`([^`\\]|\\.)*`)/g;
+var COMMENT_RE = /(\/\/.*|#.*)$/;
+function normalizeLang(lang) {
+  const lower = lang.toLowerCase().trim();
+  return CODE_LANG_ALIASES[lower] ?? lower;
+}
+function langFromPath(path) {
+  const clean = path.replace(/^[ab]\//, "").split("?")[0] ?? "";
+  const ext = clean.split(".").pop()?.toLowerCase() ?? "";
+  const byExt = {
+    bash: "sh",
+    cjs: "js",
+    css: "css",
+    dart: "dart",
+    java: "java",
+    js: "js",
+    json: "json",
+    jsonc: "json",
+    jsx: "js",
+    kt: "kt",
+    kts: "kt",
+    md: "markdown",
+    mdx: "markdown",
+    mjs: "js",
+    php: "php",
+    py: "python",
+    sh: "sh",
+    ts: "ts",
+    tsx: "ts",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    sql: "sql",
+    html: "html",
+    xml: "xml",
+    rs: "rust",
+    go: "go",
+    rb: "ruby",
+    swift: "swift",
+    cs: "csharp",
+    cpp: "cpp",
+    c: "c",
+    vue: "vue"
+  };
+  return byExt[ext] ?? "";
+}
+function highlightCodeLineFallback(raw, lang) {
+  const normalized = normalizeLang(lang);
+  if (normalized === "diff") {
+    if (raw.startsWith("+") && !raw.startsWith("+++"))
+      return `${C_SUCCESS}${raw}${RESET}`;
+    if (raw.startsWith("-") && !raw.startsWith("---"))
+      return `${C_ERROR}${raw}${RESET}`;
+    if (raw.startsWith("@@")) return `${C_ACTION}${raw}${RESET}`;
+    if (raw.startsWith("diff ") || raw.startsWith("index ") || raw.startsWith("---") || raw.startsWith("+++")) {
+      return `${C_WARNING}${raw}${RESET}`;
+    }
+    return `${C_MUTED}${raw}${RESET}`;
+  }
+  if (normalized === "json") {
+    return raw.replace(
+      /("(?:[^"\\]|\\.)*")(\s*:)?/g,
+      (_m, key, colon) => colon ? `${C_ACTION}${key}${RESET}${colon}` : `${C_SUCCESS}${key}${RESET}`
+    ).replace(/\b(true|false|null)\b/g, `${C_WARNING}$1${RESET}`);
+  }
+  if (normalized === "sh") {
+    const comment = raw.match(COMMENT_RE);
+    const body = comment && comment.index !== void 0 ? raw.slice(0, comment.index) : raw;
+    const suffix = comment ? `${C_GRAY}${comment[0]}${RESET}` : "";
+    return body.replace(
+      /\b(cd|cp|echo|export|find|git|grep|ls|mkdir|npm|pnpm|rm|sed|yarn)\b/g,
+      `${C_ACTION}$1${RESET}`
+    ).replace(STRING_RE, `${C_SUCCESS}$1${RESET}`) + suffix;
+  }
+  if (KEYWORD_LANGS.has(normalized)) {
+    const comment = raw.match(COMMENT_RE);
+    const body = comment && comment.index !== void 0 ? raw.slice(0, comment.index) : raw;
+    const suffix = comment ? `${C_GRAY}${comment[0]}${RESET}` : "";
+    return body.replace(STRING_RE, `${C_SUCCESS}$1${RESET}`).replace(KEYWORDS, `${C_ACTION}$1${RESET}`) + suffix;
+  }
+  return raw;
+}
+function isToken(value) {
+  return typeof value === "object" && value !== null;
+}
+function tokenText(value) {
+  if (!isToken(value)) return String(value ?? "");
+  const text = value.text;
+  if (typeof text === "string") return text;
+  const raw = value.raw;
+  return typeof raw === "string" ? raw : "";
+}
+function stripTrailingBlankLines(lines) {
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function reapplyBackground(line, bg) {
+  return bg + line.replace(/\x1b\[0m/g, `${RESET}${bg}`) + RESET;
+}
+function parseDiffFilePath(header) {
+  const plus = header.split("\n").find((line) => line.startsWith("+++ "));
+  const minus = header.split("\n").find((line) => line.startsWith("--- "));
+  const raw = (plus ?? minus ?? "").replace(/^[+-]{3}\s+/, "").trim();
+  if (!raw || raw === "/dev/null") return "";
+  return raw.replace(/^[ab]\//, "");
+}
+function langFromHunkHeader(hunkText) {
+  const match = hunkText.match(/@@ .+? @@ (.+?)(?::\d+(?:-\d+)?)?$/);
+  return match?.[1] ? langFromPath(match[1].trim()) : "";
+}
+function renderUnifiedDiff(source, width, noHighlight) {
+  const cleanSource = source.split("\n").filter((l) => !/^\.\.\. \d+ more line\(s\)/.test(l)).join("\n");
+  let parsed = null;
+  try {
+    parsed = new DiffParser().parse(cleanSource);
+  } catch {
+    parsed = null;
+  }
+  if (!parsed || parsed.hunks.length === 0) {
+    const srcLines = cleanSource.split("\n");
+    const hunkIdx = srcLines.findIndex((l) => l.startsWith("@@"));
+    if (hunkIdx !== -1) {
+      const body = srcLines.slice(hunkIdx + 1);
+      const adds = body.filter((l) => l.startsWith("+")).length;
+      const dels = body.filter((l) => l.startsWith("-")).length;
+      const oldRange = dels > 0 ? `1,${dels}` : "0,0";
+      const newRange = adds > 0 ? `1,${adds}` : "0,0";
+      const ctx = (srcLines[hunkIdx] ?? "").replace(/^@@ .+? @@/, "");
+      const fixedHunk = `@@ -${oldRange} +${newRange} @@${ctx}`;
+      const fixedSrc = [...srcLines.slice(0, hunkIdx), fixedHunk, ...body].join("\n");
+      try {
+        parsed = new DiffParser().parse(fixedSrc);
+      } catch {
+        return null;
+      }
+    }
+    if (!parsed || parsed.hunks.length === 0) return null;
+  }
+  const filePath = parseDiffFilePath(parsed.header);
+  const language = langFromPath(filePath) || langFromHunkHeader(parsed.hunks[0]?.lines[0]?.text ?? "");
+  const contentTexts = [];
+  for (const hunk of parsed.hunks) {
+    for (const line of hunk.lines.slice(1)) {
+      contentTexts.push(line.text.replace(/\n$/, ""));
+    }
+  }
+  let preHighlighted;
+  if (!noHighlight && isShikiReady() && language) {
+    preHighlighted = highlightBlock(contentTexts.join("\n"), language);
+  } else if (!noHighlight) {
+    preHighlighted = contentTexts.map(
+      (t) => highlightCodeLineFallback(t.length === 0 ? " " : t, language)
+    );
+  } else {
+    preHighlighted = contentTexts;
+  }
+  const hasContextLines = parsed.hunks.some(
+    (h) => h.lines.slice(1).some((l) => l.type !== DiffLineType.Add && l.type !== DiffLineType.Delete)
+  );
+  let maxLineNo = 0;
+  if (!hasContextLines) {
+    for (const hunk of parsed.hunks)
+      for (const line of hunk.lines.slice(1)) {
+        const n = (line.type === DiffLineType.Add ? line.newLineNumber : line.oldLineNumber) ?? 0;
+        if (n > maxLineNo) maxLineNo = n;
+      }
+  }
+  const lineNoW = maxLineNo > 0 ? Math.max(2, String(maxLineNo).length) : 0;
+  const gutterWidth = lineNoW > 0 ? 1 + lineNoW + 3 : 2;
+  const codeWidth = Math.max(8, width - gutterWidth);
+  const out = [];
+  if (filePath) out.push(`${C_GRAY}${filePath}${RESET}`);
+  let lineIdx = 0;
+  for (const hunk of parsed.hunks) {
+    out.push(`${C_ACTION}${hunk.lines[0]?.text ?? ""}${RESET}`);
+    for (const line of hunk.lines.slice(1)) {
+      const isAdd = line.type === DiffLineType.Add;
+      const isDelete = line.type === DiffLineType.Delete;
+      const marker = isAdd ? "+" : isDelete ? "-" : " ";
+      const markerColor = isAdd ? C_SUCCESS : isDelete ? C_ERROR : C_MUTED;
+      const highlighted = preHighlighted[lineIdx++] ?? "";
+      const wrapped = wrapPlain(highlighted, codeWidth);
+      const bg = isAdd ? BG_DIFF_ADD : isDelete ? BG_DIFF_DELETE : "";
+      for (const [index, segment] of wrapped.entries()) {
+        let gutter;
+        if (index === 0 && lineNoW > 0) {
+          const lineNo = (isAdd ? line.newLineNumber : line.oldLineNumber) ?? null;
+          const num = lineNo != null ? String(lineNo).padStart(lineNoW) : " ".repeat(lineNoW);
+          gutter = `${markerColor}${marker}${RESET}${C_GRAY} ${num} \u2502${RESET}${bg} `;
+        } else {
+          gutter = index === 0 ? `${markerColor}${marker}${RESET} ` : " ".repeat(gutterWidth);
+        }
+        const rendered = `${gutter}${segment}${RESET}`;
+        out.push(
+          bg ? reapplyBackground(padToWidth(rendered, width), bg) : rendered
+        );
+      }
+    }
+  }
+  return out;
+}
+var CodeMapTerminalRenderer = class extends TerminalRenderer {
+  constructor(width, noHighlight) {
+    super({
+      reflowText: false,
+      showSectionPrefix: false,
+      width
+    });
+    this.width = width;
+    this.noHighlight = noHighlight;
+  }
+  width;
+  noHighlight;
+  code(code, lang) {
+    const source = isToken(code) ? tokenText(code) : String(code ?? "");
+    const language = isToken(code) && typeof code.lang === "string" ? code.lang : lang ?? "";
+    if (normalizeLang(language) === "diff") {
+      const diffLines = renderUnifiedDiff(source, this.width, this.noHighlight);
+      if (diffLines) return diffLines.join("\n") + "\n";
+    }
+    const separator = `${C_MUTED}${"-".repeat(Math.min(this.width, 40))}${RESET}`;
+    const useShiki = !this.noHighlight && isShikiReady() && normalizeLang(language) !== "diff";
+    const highlighted = useShiki ? highlightBlock(source, language) : source.split("\n").map(
+      (line) => this.noHighlight ? line : highlightCodeLineFallback(
+        line.length === 0 ? " " : line,
+        language
+      )
+    );
+    const codeWidth = Math.max(8, this.width - 4);
+    const body = highlighted.flatMap(
+      (line) => wrapPlain(line, codeWidth).map((wrapped) => `    ${wrapped}${RESET}`)
+    );
+    return [separator, ...body, separator].join("\n") + "\n";
+  }
+  heading(heading, level) {
+    const depth = isToken(heading) && typeof heading.depth === "number" ? heading.depth : level ?? 1;
+    const text = this.inlineFrom(heading);
+    const color = depth <= 2 ? `${C_ACTION}${BOLD}` : `${C_AI}${BOLD}`;
+    const lines = wrapPlain(text, Math.max(8, this.width - 2));
+    return lines.map(
+      (line, index) => index === 0 ? `${color}${line}${RESET}` : `  ${line}`
+    ).join("\n") + "\n";
+  }
+  paragraph(paragraph) {
+    const text = this.inlineFrom(paragraph);
+    return wrapPlain(text, this.width).join("\n") + "\n";
+  }
+  list(list, ordered) {
+    if (isToken(list) && Array.isArray(list.items)) {
+      const isOrdered = Boolean(list.ordered);
+      const start = typeof list.start === "number" ? list.start : 1;
+      const rendered = list.items.map((item, index) => {
+        const marker = isOrdered ? `${start + index}. ` : "- ";
+        return this.formatListItem(marker, item);
+      });
+      return rendered.join("\n") + "\n";
+    }
+    const body = String(list ?? "").trim();
+    if (!body) return "";
+    return body.split("\n").map((line, index) => {
+      const marker = ordered ? `${index + 1}. ` : "- ";
+      return this.formatListLine(marker, line);
+    }).join("\n") + "\n";
+  }
+  listitem(item) {
+    return this.formatListItem("- ", item);
+  }
+  blockquote(quote) {
+    const text = isToken(quote) && Array.isArray(quote.tokens) ? this.parser.parse(quote.tokens).trim() : String(quote ?? "").trim();
+    if (!text) return "";
+    return text.split("\n").flatMap(
+      (line) => wrapPlain(line.trimStart(), Math.max(8, this.width - 2)).map(
+        (wrapped) => wrapped ? `${C_MUTED}\u2502${RESET} ${C_GRAY}${wrapped}${RESET}` : ""
+      )
+    ).join("\n") + "\n";
+  }
+  hr() {
+    return `${C_MUTED}${"\u2500".repeat(Math.min(this.width, 60))}${RESET}
+`;
+  }
+  codespan(code) {
+    return `${C_ACTION}${tokenText(code)}${RESET}`;
+  }
+  strong(strong) {
+    return `${BOLD}${this.inlineFrom(strong)}${RESET}`;
+  }
+  em(emphasis) {
+    return this.inlineFrom(emphasis);
+  }
+  del(deleted) {
+    return this.inlineFrom(deleted);
+  }
+  link(hrefOrToken, _title, text) {
+    const href = isToken(hrefOrToken) && typeof hrefOrToken.href === "string" ? hrefOrToken.href : String(hrefOrToken ?? "");
+    const label = isToken(hrefOrToken) ? this.inlineFrom(hrefOrToken) : text ?? href;
+    if (!href || label === href) return `${C_GRAY}${label || href}${RESET}`;
+    return `${label} ${C_MUTED}(${href})${RESET}`;
+  }
+  image(hrefOrToken, title, text) {
+    const href = isToken(hrefOrToken) && typeof hrefOrToken.href === "string" ? hrefOrToken.href : String(hrefOrToken ?? "");
+    const label = isToken(hrefOrToken) ? tokenText(hrefOrToken) : text ?? "image";
+    const suffix = title ? ` - ${title}` : "";
+    return `${C_GRAY}![${label}${suffix}]${RESET}${href ? ` ${C_MUTED}(${href})${RESET}` : ""}`;
+  }
+  text(text) {
+    return tokenText(text);
+  }
+  br() {
+    return "\n";
+  }
+  html() {
+    return "";
+  }
+  table(token) {
+    if (!isToken(token)) return "";
+    const header = Array.isArray(token.header) ? token.header : [];
+    const rows = Array.isArray(token.rows) ? token.rows : [];
+    const renderCell = (cell) => {
+      if (isToken(cell) && Array.isArray(cell.tokens)) {
+        return this.parser.parseInline(cell.tokens);
+      }
+      return tokenText(cell);
+    };
+    const headerTexts = header.map(renderCell);
+    const bodyTexts = rows.map(
+      (row) => row.map(renderCell)
+    );
+    const colCount = headerTexts.length;
+    const colWidths = Array.from({ length: colCount }, (_, i) => {
+      const candidates = [
+        visibleWidth(stripAnsi(headerTexts[i] ?? "")),
+        ...bodyTexts.map((row) => visibleWidth(stripAnsi(row[i] ?? "")))
+      ];
+      return Math.max(3, ...candidates);
+    });
+    const totalNeeded = colWidths.reduce((s, w) => s + w + 3, 1);
+    if (totalNeeded > this.width) {
+      const available = Math.max(colCount * 3, this.width - colCount * 3 - 1);
+      const total = colWidths.reduce((s, w) => s + w, 0);
+      for (let i = 0; i < colWidths.length; i++) {
+        colWidths[i] = Math.max(
+          3,
+          Math.floor((colWidths[i] ?? 3) / total * available)
+        );
+      }
+    }
+    const sep = (l, m, r) => `${C_MUTED}${l}${colWidths.map((w) => "\u2500".repeat(w + 2)).join(m)}${r}${RESET}`;
+    const renderRow = (cells, isHeader) => {
+      const rendered = cells.map((text, i) => {
+        const w = colWidths[i] ?? 3;
+        const plain = stripAnsi(text);
+        const display = isHeader ? `${BOLD}${plain}${RESET}` : text;
+        const pad = Math.max(0, w - visibleWidth(plain));
+        return ` ${display}${" ".repeat(pad)} `;
+      });
+      return `${C_MUTED}\u2502${RESET}${rendered.join(`${C_MUTED}\u2502${RESET}`)}${C_MUTED}\u2502${RESET}`;
+    };
+    return [
+      sep("\u250C", "\u252C", "\u2510"),
+      renderRow(headerTexts, true),
+      sep("\u251C", "\u253C", "\u2524"),
+      ...bodyTexts.map((row) => renderRow(row, false)),
+      sep("\u2514", "\u2534", "\u2518"),
+      ""
+    ].join("\n");
+  }
+  inlineFrom(value) {
+    if (isToken(value) && Array.isArray(value.tokens)) {
+      return this.parser.parseInline(value.tokens);
+    }
+    return tokenText(value);
+  }
+  formatListItem(marker, item) {
+    const checkbox = item.task ? `[${item.checked ? "x" : " "}] ` : "";
+    const text = this.listItemText(item);
+    return this.formatListLine(marker, `${checkbox}${text}`);
+  }
+  listItemText(item) {
+    if (!Array.isArray(item.tokens)) return tokenText(item);
+    const inlineLines = item.tokens.map((token) => {
+      if (!isToken(token) || token.type !== "text") return null;
+      return Array.isArray(token.tokens) ? this.parser.parseInline(token.tokens) : tokenText(token);
+    });
+    if (inlineLines.every((line) => line !== null)) {
+      return inlineLines.join("\n");
+    }
+    return this.parser.parse(item.tokens, Boolean(item.loose)).trim();
+  }
+  formatListLine(marker, text) {
+    const markerWidth = visibleWidth(marker);
+    const markerColor = marker.trim() === "-" ? `${C_ACTION}-${RESET} ` : `${C_ACTION}${marker}${RESET}`;
+    const continuation = " ".repeat(markerWidth);
+    const bodyWidth = Math.max(8, this.width - markerWidth);
+    const lines = stripTrailingBlankLines(text.split("\n"));
+    const out = [];
+    for (const [lineIndex, line] of lines.entries()) {
+      const wrapped = wrapPlain(line, bodyWidth);
+      for (const [wrapIndex, wrappedLine] of wrapped.entries()) {
+        if (lineIndex === 0 && wrapIndex === 0) {
+          out.push(`${markerColor}${wrappedLine}`);
+        } else {
+          out.push(`${continuation}${wrappedLine}`);
+        }
+      }
+    }
+    return out.join("\n");
+  }
+};
+function renderMarkdownish(text, width, options) {
+  const renderer = new CodeMapTerminalRenderer(
+    width,
+    options?.noHighlight ?? false
+  );
+  const rendererMethods = {};
+  for (const method of RENDERER_METHODS) {
+    rendererMethods[method] = function(...args) {
+      renderer.options = this.options;
+      renderer.parser = this.parser;
+      const fn = renderer[method];
+      return typeof fn === "function" ? fn.apply(renderer, args) : "";
+    };
+  }
+  const parser = new Marked({
+    async: false,
+    breaks: false,
+    gfm: true
+  });
+  parser.use({ renderer: rendererMethods, useNewRenderer: true });
+  const rendered = parser.parse(text);
+  const lines = stripTrailingBlankLines(rendered.split("\n"));
+  return lines.reduce((acc, line) => {
+    if (line === "" && acc[acc.length - 1] === "") return acc;
+    acc.push(line);
+    return acc;
+  }, []);
+}
+
+// src/cli-agent/core/html-utils.ts
+function normalizeHtml(text) {
+  return text.replace(/<table[^>]*>([\s\S]*?)<\/table>/gi, (_match, body) => {
+    const rows = [];
+    const rowRe = /<tr[^>]*>([\s\S]*?)<\/tr>/gi;
+    let row;
+    while ((row = rowRe.exec(body)) !== null) {
+      const cells = [];
+      const cellRe = /<t[hd][^>]*>([\s\S]*?)<\/t[hd]>/gi;
+      let cell;
+      while ((cell = cellRe.exec(row[1] ?? "")) !== null) {
+        cells.push((cell[1] ?? "").replace(/<[^>]+>/g, "").trim());
+      }
+      if (cells.length > 0) rows.push(cells.join(" | "));
+    }
+    return rows.join("\n");
+  }).replace(/<table[^>]*>[\s\S]*/gi, "").replace(/<[^>]+>/g, "").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+}
+
+// src/cli-agent/chat/ui/pi-tui/message-renderer.ts
+function formatExpandedContent(content, width, opts = {}) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed && typeof parsed === "object") {
+      const record = parsed;
+      const structured = record.structuredContent && typeof record.structuredContent === "object" && !Array.isArray(record.structuredContent) ? record.structuredContent : record;
+      const summary = structured.summary;
+      const data = structured.data;
+      const error = structured.error;
+      const lines = [];
+      if (typeof summary === "string" && (data !== void 0 || error !== void 0)) {
+        const summaryLines = renderMarkdownish(summary, width);
+        lines.push(...summaryLines);
+        const raw = data !== void 0 ? data : error;
+        const verbosity = getToolResultVerbosity(structured, raw);
+        const showRaw = opts.showRawData || verbosity === "verbose" || verbosity === "debug";
+        if (showRaw) {
+          lines.push("");
+          lines.push(`${C_MUTED}Raw data${RESET}`);
+          const jsonStr = JSON.stringify(raw, null, 2);
+          const highlighted = highlightBlock(jsonStr, "json");
+          const codeWidth = Math.max(8, width - 4);
+          for (const line of highlighted) {
+            lines.push(...wrapPlain(line, codeWidth));
+          }
+        }
+        return lines;
+      }
+    }
+  } catch {
+  }
+  return renderMarkdownish(content, width);
+}
+function getToolResultVerbosity(...values) {
+  for (const value of values) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    const record = value;
+    const direct = record.verbosity;
+    if (typeof direct === "string") return direct;
+    if (record.verbose === true) return "verbose";
+    const meta = record.meta;
+    if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+      const metaVerbosity = meta.verbosity;
+      if (typeof metaVerbosity === "string") return metaVerbosity;
+    }
+  }
+  return void 0;
+}
+function generateBanner() {
+  const result = cfonts.render("CODEMAP", {
+    font: "simple3d",
+    gradient: ["cyan", "magenta"],
+    env: "node"
+  });
+  const raw = result.string ?? "";
+  const lines = raw.split("\n");
+  let start = 0;
+  let end = lines.length - 1;
+  while (start <= end && stripAnsi(lines[start] ?? "").trim() === "") start++;
+  while (end >= start && stripAnsi(lines[end] ?? "").trim() === "") end--;
+  return lines.slice(start, end + 1);
+}
+var BANNER_LINES = generateBanner();
+function renderPreviewLines(preview, bodyW, prefixW) {
+  const normalized = preview.replace(/^~~~([^\n]*)/gm, "```$1").replace(/^~~~$/gm, "```");
+  const body = normalized.split("\n").filter((line) => !line.startsWith("File:"));
+  const added = body.filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
+  const removed = body.filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
+  const sourceLines = body.filter(
+    (line) => line.trim() !== "" && !line.startsWith("```") && !line.startsWith("---") && !line.startsWith("+++")
+  ).length;
+  const summary = added > 0 || removed > 0 ? `+${added} -${removed} lines` : `${sourceLines} line${sourceLines === 1 ? "" : "s"}`;
+  const previewIndentW = 3;
+  const renderW = Math.max(20, bodyW - previewIndentW);
+  const rendered = renderMarkdownish(normalized, renderW);
+  const indent = " ".repeat(prefixW);
+  const fitPreviewLine = (line) => truncateVisible(`${indent}${line}`, prefixW + bodyW);
+  const out = [fitPreviewLine(`${C_MUTED}\u23BF  ${summary}${RESET}`)];
+  out.push(...rendered.map((line) => fitPreviewLine(`${" ".repeat(previewIndentW)}${line}`)));
+  return out;
+}
+function headerLines(state) {
+  const workspace = state.workspace?.repoName ?? state.config.model;
+  if (state.messages.length > 0) {
+    return [
+      `${C_ACTION}${BOLD}codemap${RESET} ${C_GRAY}${workspace}${RESET} ${C_MUTED}|${RESET} ${C_WHITE}${truncate(state.config.model, 28)}${RESET} ${C_MUTED}|${RESET} ${C_ACTION}MCP connected${RESET}`,
+      `${C_MUTED}${"-".repeat(72)}${RESET}`
+    ];
+  }
+  return [
+    "",
+    ...BANNER_LINES,
+    gradientStr(
+      "  AI-POWERED CODE INTELLIGENCE & AGENT PLATFORM",
+      { r: 88, g: 213, b: 247 },
+      { r: 244, g: 114, b: 182 },
+      false
+    ),
+    "",
+    [
+      `${C_ARCH}o${RESET} ${C_WHITE}v0.1.0${RESET}`,
+      `${C_ACTION}@${RESET} ${C_WHITE}${truncate(workspace, 20)}${RESET}`,
+      `${C_AI}*${RESET} ${C_WHITE}${truncate(state.config.model, 28)}${RESET}`,
+      `${C_ACTION}#${RESET} ${C_ACTION}Connected${RESET}`
+    ].join(`  ${C_MUTED}|${RESET}  `).padStart(2),
+    `  ${C_ACTION}${BOLD}> Quick Start:${RESET} ${C_GRAY}/help for commands  .  @ for files  .  Tab for suggestions  .  Ctrl+C cancel${RESET}`,
+    ""
+  ];
+}
+function stripBase64Images(text) {
+  return text.replace(
+    /!\[([^\]]*)\]\(data:image\/[^;]+;base64,[a-zA-Z0-9+/=\s]+\)/g,
+    (_match, alt) => `[image${alt ? `: ${alt}` : ""}]`
+  );
+}
+function safeRender(content, width, opts) {
+  const cleaned = normalizeHtml(stripBase64Images(content));
+  let lines;
+  try {
+    lines = renderMarkdownish(cleaned, width, opts);
+  } catch {
+    lines = cleaned.split("\n").flatMap((l) => wrapPlain(l, width));
+  }
+  return lines.map(
+    (line) => visibleWidth2(line) > width ? truncateToWidth(line, width) : line
+  );
+}
+function messageLines(messages, width, frame = 0, opts = {}) {
+  return renderMessageLines(messages, width, frame, opts);
+}
+function renderMessageLines(messages, width, frame = 0, opts = {}) {
+  if (messages.length === 0) {
+    return [
+      `${C_ACTION}${BOLD}Welcome to CodeMap Agent${RESET}`,
+      `${C_GRAY}Ask a question, mention files with @, or type /help.${RESET}`,
+      ""
+    ];
+  }
+  const out = [];
+  for (const msg of messages) {
+    const time = `${C_MUTED}${formatTime(msg.timestamp)}${RESET}`;
+    if (msg.role === "user") {
+      const bg = (raw) => BG_USER + padToWidth(raw, width).replace(/\x1b\[0m/g, `\x1B[0m${BG_USER}`) + RESET;
+      const prefixW = 11;
+      const bodyW = Math.max(20, width - prefixW - 2);
+      const lines = safeRender(msg.content, bodyW);
+      out.push(bg(`${time} ${C_ACTION}>${RESET} ${lines[0] ?? ""}`));
+      for (const line of lines.slice(1))
+        out.push(bg(`${" ".repeat(prefixW)}${line}`));
+    } else if (msg.role === "assistant") {
+      if (!msg.content?.trim()) continue;
+      const prefixW = 9;
+      const bodyW = Math.max(20, width - prefixW);
+      const lines = safeRender(stripAnsi(msg.content), bodyW);
+      out.push(`${time} ${lines[0] ?? ""}`);
+      for (const line of lines.slice(1))
+        out.push(`${" ".repeat(prefixW)}${line}`);
+    } else if (msg.role === "tool_call") {
+      const toolName = truncate(msg.name ?? "tool", 20);
+      const isPlan = (msg.name ?? "").toLowerCase() === "plan";
+      const prefixW = 9;
+      const bodyW = Math.max(20, width - prefixW);
+      const rawContent = msg.content;
+      const hasResult = (msg.toolResults?.length ?? 0) > 0;
+      const hasFailed = (msg.toolResults ?? []).some((r) => !r.success);
+      const allSucceeded = hasResult && !hasFailed;
+      let icon;
+      let toolColor;
+      if (msg.expanded) {
+        icon = "\u2193";
+        toolColor = isPlan ? C_AI : C_WARNING;
+      } else if (hasFailed) {
+        icon = "\u2717";
+        toolColor = C_ERROR;
+      } else if (allSucceeded) {
+        icon = "\u2713";
+        toolColor = C_SUCCESS;
+      } else {
+        icon = SPINNER[frame % SPINNER.length] ?? "\u2026";
+        toolColor = isPlan ? C_AI : C_WARNING;
+      }
+      const canExpand = !hasFailed && (hasResult || !!msg.expandedContent);
+      const suffix = canExpand ? " (Ctrl+O to expand)" : "";
+      const headerPrefix = `${time} ${toolColor}${icon}${RESET} ${toolColor}${toolName}:${RESET} `;
+      const headerSuffix = `${C_MUTED}${suffix}${RESET}`;
+      const headerBodyW = Math.max(
+        0,
+        width - visibleWidth2(headerPrefix) - visibleWidth2(headerSuffix)
+      );
+      const lines = safeRender(rawContent, Math.max(20, bodyW));
+      const headerContent = truncateToWidth(lines[0] ?? "", headerBodyW);
+      out.push(`${headerPrefix}${headerContent}${headerSuffix}`);
+      if (msg.previewContent)
+        out.push(...renderPreviewLines(msg.previewContent, bodyW, prefixW));
+      if (msg.expanded && msg.expandedContent) {
+        const expandedLines = formatExpandedContent(
+          stripAnsi(msg.expandedContent),
+          bodyW,
+          { showRawData: opts.showRawToolData }
+        );
+        out.push(
+          `${" ".repeat(prefixW)}${C_MUTED}${"\u2500".repeat(Math.min(bodyW, 60))}${RESET}`
+        );
+        for (const line of expandedLines)
+          out.push(`${" ".repeat(prefixW)}${C_GRAY}${line}${RESET}`);
+        out.push(
+          `${" ".repeat(prefixW)}${C_MUTED}${"\u2500".repeat(Math.min(bodyW, 60))}${RESET}`
+        );
+      }
+    } else if (msg.role === "system") {
+      const prefixW = 17;
+      const bodyW = Math.max(20, width - prefixW);
+      const hasAnsi = /\x1b\[/.test(msg.content);
+      const lines = hasAnsi ? msg.content.split("\n").flatMap((l) => wrapPlain(l, bodyW)) : safeRender(msg.content, bodyW);
+      out.push(`${time} ${C_MUTED}system:${RESET} ${lines[0] ?? ""}`);
+      for (const line of lines.slice(1))
+        out.push(`${" ".repeat(prefixW)}${line}`);
+    } else {
+      out.push(...safeRender(msg.content, width));
+    }
+    out.push("");
+  }
+  return out.map(
+    (line) => visibleWidth2(line) > width ? truncateToWidth(line, width) : line
+  );
+}
+
+// src/cli-agent/chat/ui/pi-tui/input.ts
+var ModelPickerProvider = class {
+  constructor(getModels, getCurrentModel, onSelect, onClose) {
+    this.getModels = getModels;
+    this.getCurrentModel = getCurrentModel;
+    this.onSelect = onSelect;
+    this.onClose = onClose;
+  }
+  getModels;
+  getCurrentModel;
+  onSelect;
+  onClose;
+  async getSuggestions(lines, cursorLine, cursorCol, _options) {
+    const current = this.getCurrentModel();
+    const available = this.getModels();
+    if (available.length === 0) return null;
+    const query = (lines[cursorLine] ?? "").slice(0, cursorCol).toLowerCase();
+    const filtered = query ? available.filter((m) => m.id.toLowerCase().includes(query)) : available;
+    if (filtered.length === 0) {
+      return { prefix: query, items: [{ value: "", label: "No matches", description: "" }] };
+    }
+    const items = filtered.map((m) => ({
+      value: m.id,
+      label: m.id,
+      description: m.id === current ? "\u2713 active" : m.ownedBy ?? ""
+    }));
+    return { prefix: query, items };
+  }
+  applyCompletion(lines, cursorLine, _cursorCol, item, _prefix) {
+    if (!item.value) {
+      return { lines: [...lines], cursorLine, cursorCol: 0 };
+    }
+    this.onSelect(item.value);
+    setTimeout(() => this.onClose(), 0);
+    const newLines = [...lines];
+    newLines[cursorLine] = "";
+    return { lines: newLines, cursorLine, cursorCol: 0 };
+  }
+};
+var AT_DELIMITERS = /* @__PURE__ */ new Set([" ", "	", '"', "'", "="]);
+function extractAtPrefix(textBeforeCursor) {
+  let lastDelimIdx = -1;
+  for (let i = textBeforeCursor.length - 1; i >= 0; i--) {
+    if (AT_DELIMITERS.has(textBeforeCursor[i] ?? "")) {
+      lastDelimIdx = i;
+      break;
+    }
+  }
+  const tokenStart = lastDelimIdx === -1 ? 0 : lastDelimIdx + 1;
+  if (textBeforeCursor[tokenStart] === "@") {
+    return textBeforeCursor.slice(tokenStart);
+  }
+  return null;
+}
+var MentionAutocompleteProvider = class {
+  commands;
+  constructor(commandsOrOptions = []) {
+    if (Array.isArray(commandsOrOptions)) {
+      this.commands = commandsOrOptions;
+    } else {
+      this.commands = commandsOrOptions.commands ?? [];
+    }
+  }
+  async getSuggestions(lines, cursorLine, cursorCol, options) {
+    const currentLine = lines[cursorLine] ?? "";
+    const textBeforeCursor = currentLine.slice(0, cursorCol);
+    const atPrefix = extractAtPrefix(textBeforeCursor);
+    if (atPrefix !== null) {
+      const query = atPrefix.slice(1);
+      const files = await searchIndexedFiles(query);
+      if (options.signal.aborted) return null;
+      if (files.length === 0) return null;
+      return {
+        prefix: atPrefix,
+        items: files.map((f) => ({
+          value: f.path,
+          label: f.label ?? f.path
+        }))
+      };
+    }
+    if (!options.force && textBeforeCursor.trimStart().startsWith("/")) {
+      const spaceIdx = textBeforeCursor.indexOf(" ");
+      if (spaceIdx === -1) {
+        const typed = textBeforeCursor.trimStart();
+        const filtered = this.commands.filter((c) => c.value.startsWith(typed));
+        if (filtered.length === 0) return null;
+        return {
+          prefix: typed,
+          items: filtered.map((c) => ({
+            value: c.value,
+            label: c.value,
+            description: c.description
+          }))
+        };
+      }
+    }
+    return null;
+  }
+  applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+    const line = lines[cursorLine] ?? "";
+    const before = line.slice(0, cursorCol - prefix.length);
+    const after = line.slice(cursorCol);
+    const replacement = prefix.startsWith("@") ? `@${item.value} ` : `${item.value} `;
+    const newLine = before + replacement + after;
+    const newLines = [...lines];
+    newLines[cursorLine] = newLine;
+    return { lines: newLines, cursorLine, cursorCol: before.length + replacement.length };
+  }
+};
+
+// src/cli-agent/chat/ui/pi-tui/image-paste.ts
+import { readFile, stat } from "fs/promises";
+import { execFile } from "child_process";
+import { fileURLToPath } from "url";
+import { basename, extname, isAbsolute, resolve } from "path";
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var MIME_BY_EXT = {
+  ".gif": "image/gif",
+  ".heic": "image/heic",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+async function readClipboardImage() {
+  if (process.platform !== "darwin") return null;
+  return new Promise((resolve2) => {
+    execFile(
+      "osascript",
+      ["-e", 'set imgData to the clipboard as \xABclass PNGf\xBB\nset out to do shell script "xxd -p" with input imgData\nreturn out'],
+      { maxBuffer: MAX_IMAGE_BYTES * 2 },
+      (err, stdout) => {
+        if (err || !stdout.trim()) {
+          resolve2(null);
+          return;
+        }
+        try {
+          const hex = stdout.trim().replace(/\s+/g, "");
+          const buf = Buffer.from(hex, "hex");
+          resolve2(buf.toString("base64"));
+        } catch {
+          resolve2(null);
+        }
+      }
+    );
+  });
+}
+async function imageFromPaste(data) {
+  const bracketedContent = data.match(/^\x1b\[200~([\s\S]*?)\x1b\[201~$/);
+  const trimmed = (bracketedContent ? bracketedContent[1] : data).trim();
+  if (!trimmed) return null;
+  const dataUrl = trimmed.match(/^data:(image\/(?:png|jpe?g|webp|gif));base64,([a-z0-9+/=\s]+)$/i);
+  if (dataUrl) {
+    const mime2 = dataUrl[1].toLowerCase();
+    const base64 = dataUrl[2].replace(/\s+/g, "");
+    const approxBytes = Math.floor(base64.length * 3 / 4);
+    if (approxBytes > MAX_IMAGE_BYTES) {
+      throw new Error("Image paste is too large. Max size is 5 MB.");
+    }
+    return {
+      marker: `[image: pasted ${mime2.split("/")[1]}]`,
+      data: base64,
+      mimeType: mime2
+    };
+  }
+  const pathText = extractSinglePath(trimmed);
+  if (!pathText) return null;
+  const ext = extname(pathText).toLowerCase();
+  const mime = MIME_BY_EXT[ext];
+  if (!mime) return null;
+  const candidates = [pathText, tryUrlDecode(pathText)].filter(
+    (p, i, arr) => p !== null && arr.indexOf(p) === i
+  );
+  for (const candidate of candidates) {
+    const filePath = isAbsolute(candidate) ? candidate : resolve(process.cwd(), candidate);
+    try {
+      const info = await stat(filePath);
+      if (!info.isFile()) continue;
+      if (info.size > MAX_IMAGE_BYTES) {
+        throw new Error(`Image is too large (${Math.ceil(info.size / 1024 / 1024)} MB). Max size is 5 MB.`);
+      }
+      const bytes = await readFile(filePath);
+      const base64 = bytes.toString("base64");
+      const name = basename(filePath);
+      return {
+        marker: `[image: ${name}]`,
+        data: base64,
+        mimeType: mime
+      };
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  if (ext === ".png" || mime === "image/png") {
+    const clipBase64 = await readClipboardImage();
+    if (clipBase64) {
+      const name = basename(pathText);
+      return {
+        marker: `[image: ${name}]`,
+        data: clipBase64,
+        mimeType: "image/png"
+      };
+    }
+  }
+  throw new Error(`Image not found: ${basename(pathText)}`);
+}
+function extractSinglePath(value) {
+  const unquoted = value.replace(/^['"]|['"]$/g, "");
+  if (unquoted.startsWith("file://")) {
+    try {
+      return fileURLToPath(unquoted);
+    } catch {
+      return null;
+    }
+  }
+  if (/[\r\n]/.test(unquoted)) return null;
+  const unescaped = unquoted.replace(/\\(.)/g, "$1");
+  if (isAbsolute(unescaped) || unescaped.startsWith("./") || unescaped.startsWith("../")) {
+    return unescaped;
+  }
+  return null;
+}
+function tryUrlDecode(p) {
+  try {
+    const decoded = decodeURIComponent(p);
+    return decoded !== p ? decoded : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli-agent/chat/ui/pi-tui/editor-renderer.ts
+import { CURSOR_MARKER as CURSOR_MARKER2 } from "@earendil-works/pi-tui";
+var PROMPT_W = 2;
+function stripFirstVisibleChar(line) {
+  let i = 0;
+  while (i < line.length) {
+    if (line.charCodeAt(i) === 27 && line[i + 1] === "[") {
+      const end = line.indexOf("m", i + 2);
+      if (end !== -1) {
+        i = end + 1;
+        continue;
+      }
+    }
+    if (line.charCodeAt(i) === 27 && line[i + 1] === "_") {
+      const end = line.indexOf("\x07", i + 2);
+      if (end !== -1) {
+        i = end + 1;
+        continue;
+      }
+    }
+    return line.slice(0, i) + line.slice(i + 1);
+  }
+  return line;
+}
+function renderEditor(editor, w, shellMode, debugMode) {
+  const promptFirst = shellMode ? `${C_SUCCESS}!${RESET} ` : debugMode ? `${C_ERROR}>${RESET} ` : `${C_ACTION}>${RESET} `;
+  const promptCont = " ".repeat(PROMPT_W);
+  return editor.render(Math.max(8, w - PROMPT_W)).map((l) => {
+    const hasCursor = l.indexOf(CURSOR_MARKER2) >= 0;
+    if (hasCursor) {
+      const raw = shellMode ? stripFirstVisibleChar(l) : l;
+      return promptFirst + raw;
+    }
+    return promptCont + l;
+  });
+}
+
+// src/cli-agent/chat/ui/pi-tui/panel-builder.ts
+function commitsDiffer(localCommit, cloudCommit) {
+  if (!localCommit || !cloudCommit) return false;
+  const local = localCommit.trim();
+  const cloud = cloudCommit.trim();
+  if (!local || !cloud) return false;
+  return !(local.startsWith(cloud) || cloud.startsWith(local));
+}
+function isActiveTaskPhase(phase) {
+  return phase === "thinking" || phase === "tool" || phase === "streaming" || phase === "classifying" || phase === "planning" || phase === "executing" || phase === "reviewing";
+}
+function buildStatusBar(state, w, debugMode, statusMessage = "") {
+  const workspace = state.workspace?.repoName ?? state.config.model;
+  const branch = state.workspace?.branch ? `/${state.workspace.branch}` : "";
+  const gatewayTag = isGatewayOffline() ? ` ${C_MUTED}\xB7 \u2717 models.dev${RESET}` : "";
+  const right = statusMessage ? `${C_WARNING}${statusMessage}${RESET}` : state.planMode ? `${C_AI}\u25C8 PLAN MODE${RESET}${C_MUTED} \xB7 /plan to exit${RESET}` : debugMode ? `${C_ERROR}\u23FA DEBUG${RESET}${C_MUTED} \xB7 /debug to stop${RESET}` : `${C_ACTION}MCP connected${RESET}${gatewayTag}`;
+  const reimportHint = commitsDiffer(
+    state.workspace?.localCommit,
+    state.workspace?.cloudCommit
+  ) ? `${C_WARNING}\u26A0 reimport recommended${RESET}` : "";
+  const left = `${C_WHITE}${workspace}${RESET}${C_MUTED}${branch} \xB7 ${RESET}${C_WHITE}${truncate(state.config.model, 28)}${RESET}${C_MUTED} \xB7 ${RESET}` + right;
+  if (!reimportHint) return fitLine(left, w);
+  const hintWidth = stripAnsi(reimportHint).length;
+  const gap = "  ";
+  const maxLeftWidth = Math.max(0, w - hintWidth - gap.length);
+  const clippedLeft = truncateVisible(left, maxLeftWidth);
+  const paddingWidth = Math.max(
+    0,
+    w - stripAnsi(clippedLeft).length - hintWidth
+  );
+  return fitLine(clippedLeft + " ".repeat(paddingWidth) + reimportHint, w);
+}
+function formatTaskStatusIcon(status) {
+  switch (status) {
+    case "completed":
+      return `${C_SUCCESS}\u2713${RESET}`;
+    case "in_progress":
+      return `${C_AI}\u25CF${RESET}`;
+    default:
+      return `${C_MUTED}\u25CB${RESET}`;
+  }
+}
+function renderTaskList(tasks, w) {
+  const lines = [];
+  const completed = tasks.filter((t) => t.status === "completed").length;
+  const total = tasks.length;
+  const header = ` ${C_WHITE}${BOLD}Tasks${RESET} ${C_MUTED}(${completed}/${total})${RESET}`;
+  lines.push(fitLine(header, w));
+  for (const task of tasks) {
+    const icon = formatTaskStatusIcon(task.status);
+    const text = task.status === "completed" ? `${C_MUTED}${task.content}${RESET}` : task.status === "in_progress" ? `${C_WHITE}${BOLD}${task.content}${RESET}` : `${C_WHITE}${task.content}${RESET}`;
+    const activeForm = task.status === "in_progress" && task.activeForm ? ` ${C_MUTED}${task.activeForm}${RESET}` : "";
+    lines.push(fitLine(`  ${icon} ${text}${activeForm}`, w));
+  }
+  return lines;
+}
+function buildPanel(state, w, ctx) {
+  const { editor, frame, shellMode, debugMode, statusMessage, modelPickerActive } = ctx;
+  const out = [];
+  const sep = `${DIM}${C_MUTED}${"\u2500".repeat(Math.min(w - 4, 40))}${RESET}`;
+  if (state.screen === "help") {
+    const cmds = getCommandList();
+    const half = Math.ceil(cmds.length / 2);
+    const colW = Math.max(24, Math.floor((w - 4) / 2));
+    const NAME_W = 13;
+    const descW = Math.max(4, colW - NAME_W - 1);
+    const fmtCol = (c) => {
+      if (!c) return " ".repeat(colW);
+      const namePart = `${C_ACTION}/${c.name.padEnd(NAME_W - 1)}${RESET} `;
+      const descPart = `${C_GRAY}${truncate(c.description, descW)}${RESET}`;
+      return padToWidth(namePart + descPart, colW);
+    };
+    out.push(fitLine(`${C_ACTION}${BOLD} Commands${RESET}`, w));
+    for (let i = 0; i < half; i++) {
+      out.push(fitLine(`  ${fmtCol(cmds[i])}  ${fmtCol(cmds[i + half])}`, w));
+    }
+    out.push(
+      fitLine("", w),
+      fitLine(
+        `  ${C_ACTION}@${RESET} ${C_GRAY}mention file${RESET}  ${C_ACTION}!<cmd>${RESET} ${C_GRAY}shell${RESET}  ${C_ACTION}PgUp/Dn${RESET} ${C_GRAY}scroll${RESET}  ${C_ACTION}Ctrl+T${RESET} ${C_GRAY}tasks${RESET}`,
+        w
+      ),
+      fitLine(`  ${C_ACTION}Esc${RESET} ${C_GRAY}to close${RESET}`, w),
+      fitLine("", w)
+    );
+  }
+  if (state.subprocess.active) {
+    out.push(
+      fitLine(`${C_WARNING}Running:${RESET} ${state.subprocess.command}`, w)
+    );
+    for (const l of state.subprocess.logLines.slice(-4)) {
+      out.push(fitLine(`${C_GRAY}${l}${RESET}`, w));
+    }
+  }
+  if (state.task.phase !== "idle") {
+    const active = isActiveTaskPhase(state.task.phase);
+    const endTime = active ? Date.now() : state.task.endTime ?? Date.now();
+    const elapsed = state.task.startTime ? formatElapsed(Math.max(0, endTime - state.task.startTime)) : "0s";
+    const promptTok = state.task.usage?.promptTokens ?? 0;
+    const completionTok = state.task.usage?.completionTokens ?? 0;
+    const usage = promptTok > 0 || completionTok > 0 ? ` \xB7 ${[
+      promptTok > 0 ? `\u2191${formatTokenCount(promptTok)}` : "",
+      completionTok > 0 ? `\u2193${formatTokenCount(completionTok)}` : ""
+    ].filter(Boolean).join(" ")} tok` : "";
+    const tool = state.task.phase === "tool" && state.task.toolName ? ` \xB7 ${state.task.toolName}` : "";
+    const displayModel = state.task.model ?? "";
+    const model = displayModel ? ` ${C_GRAY}${truncate(displayModel, 28)}${RESET}` : "";
+    const effort = state.task.effort ? ` ${C_MUTED}\xB7 ${state.task.effort}${RESET}` : "";
+    const phaseLabel = {
+      classifying: "classifying...",
+      planning: "planning...",
+      executing: "executing...",
+      reviewing: "reviewing...",
+      thinking: "thinking",
+      streaming: "streaming",
+      tool: "tool",
+      done: "done"
+    };
+    const label = phaseLabel[state.task.phase] ?? state.task.phase;
+    const phaseColor = state.task.phase === "done" ? C_SUCCESS : state.task.phase === "classifying" || state.task.phase === "planning" || state.task.phase === "reviewing" || state.task.phase === "thinking" ? C_AI : C_ACTION;
+    const marker = state.task.phase === "done" ? `${C_SUCCESS}\u2713${RESET}` : `${phaseColor}${SPINNER[frame]}${RESET}`;
+    out.push(
+      fitLine(
+        ` ${marker} ${phaseColor}${label}${RESET}${model}${effort}${tool} ${C_MUTED}\xB7 ${elapsed}${usage}${RESET}`,
+        w
+      )
+    );
+  }
+  if (state.taskListVisible && state.taskList.length > 0) {
+    out.push(...renderTaskList(state.taskList, w));
+  }
+  if (state.synthRunning) {
+    out.push(
+      fitLine(
+        ` ${C_AI}${SPINNER[frame]}${RESET} ${C_GRAY}synthesizing context ${C_MUTED}(conventions \xB7 rules \xB7 skills)\u2026${RESET}`,
+        w
+      )
+    );
+  }
+  if (state.askQuestion?.active) {
+    const { question, options, selection, selectionMode, selected = [] } = state.askQuestion;
+    const isMultiSelect = selectionMode === "multi_select";
+    const questionLines = question.split("\n");
+    out.push(fitLine(`  ${sep}`, w));
+    for (let i = 0; i < questionLines.length; i++) {
+      const ql = questionLines[i];
+      if (i === 0) {
+        out.push(fitLine(`    ${C_AI}? ${RESET}${C_WHITE}${BOLD}${ql}${RESET}`, w));
+      } else {
+        out.push(fitLine(`      ${C_WHITE}${ql}${RESET}`, w));
+      }
+    }
+    out.push(fitLine(`    ${DIM}${C_MUTED}${"\u2500".repeat(Math.min(w - 8, 36))}${RESET}`, w));
+    if (options && options.length > 0) {
+      for (const [idx, opt] of options.entries()) {
+        const focused = idx === (selection ?? 0);
+        const checked = selected.includes(idx);
+        const num = `${C_MUTED}${idx + 1}.${RESET}`;
+        const checkbox = isMultiSelect ? `${C_MUTED}[${checked ? "x" : " "}]${RESET}` : "";
+        const prefix = focused ? `${C_ACTION}>${RESET}` : " ";
+        const label = focused ? `${C_WHITE}${BOLD}${opt.label}${RESET}` : `${C_WHITE}${opt.label}${RESET}`;
+        const desc = opt.description ? `  ${C_GRAY}${opt.description}${RESET}` : "";
+        out.push(fitLine(`    ${prefix} ${num} ${checkbox}${checkbox ? " " : ""}${label}${desc}`, w));
+      }
+      out.push(fitLine(``, w));
+      out.push(
+        fitLine(
+          isMultiSelect ? `    ${C_ACTION}\u2191\u2193${RESET} ${C_GRAY}move \xB7 ${RESET}${C_ACTION}Space${RESET} ${C_GRAY}toggle \xB7 ${RESET}${C_ACTION}Enter${RESET} ${C_GRAY}confirm \xB7 ${RESET}${C_ACTION}Esc${RESET} ${C_GRAY}skip${RESET}` : `    ${C_ACTION}\u2191\u2193${RESET} ${C_GRAY}select \xB7 ${RESET}${C_ACTION}Enter${RESET} ${C_GRAY}confirm \xB7 ${RESET}${C_ACTION}Esc${RESET} ${C_GRAY}skip${RESET}`,
+          w
+        )
+      );
+    } else {
+      out.push(fitLine(``, w));
+      out.push(
+        fitLine(
+          `    ${C_GRAY}Type answer + ${RESET}${C_ACTION}Enter${RESET}${C_GRAY} to reply \xB7 ${RESET}${C_ACTION}Esc${RESET} ${C_GRAY}skip${RESET}`,
+          w
+        )
+      );
+    }
+    out.push(fitLine(`  ${sep}`, w));
+  } else if (state.planReview?.active) {
+    const sel = state.planReview.selection ?? 0;
+    const reviseMode = state.planReview.reviseMode ?? false;
+    const PLAN_OPTIONS = [
+      {
+        label: "apply",
+        desc: "Proceed with implementation (planner \u2192 coder \u2192 reviewer)"
+      },
+      { label: "no", desc: "Cancel \u2014 don't implement this plan" },
+      { label: "revise", desc: "Request changes to the plan" }
+    ];
+    out.push(fitLine(`  ${sep}`, w));
+    if (reviseMode) {
+      out.push(
+        fitLine(`    ${C_WARNING}\u25C8${RESET} ${C_WHITE}${BOLD}Revise plan${RESET}`, w)
+      );
+      out.push(fitLine(`    ${DIM}${C_MUTED}${"\u2500".repeat(Math.min(w - 8, 36))}${RESET}`, w));
+      out.push(
+        fitLine(`    ${C_GRAY}Describe what to change, then press ${RESET}${C_ACTION}Enter${RESET}${C_GRAY} to submit${RESET}`, w)
+      );
+      out.push(fitLine(``, w));
+      out.push(
+        fitLine(
+          `    ${C_ACTION}Esc${RESET} ${C_GRAY}back to options${RESET}`,
+          w
+        )
+      );
+    } else {
+      out.push(
+        fitLine(`    ${C_AI}\u25C8${RESET} ${C_WHITE}${BOLD}Plan ready${RESET}`, w)
+      );
+      out.push(fitLine(`    ${DIM}${C_MUTED}${"\u2500".repeat(Math.min(w - 8, 36))}${RESET}`, w));
+      for (const [idx, opt] of PLAN_OPTIONS.entries()) {
+        const selected = idx === sel;
+        const num = `${C_MUTED}${idx + 1}.${RESET}`;
+        const prefix = selected ? `${C_ACTION}>${RESET}` : " ";
+        const isNo = opt.label === "no";
+        const isRevise = opt.label === "revise";
+        const labelColor = isNo ? C_ERROR : isRevise ? C_WARNING : C_WHITE;
+        const label = selected ? `${labelColor}${BOLD}${opt.label}${RESET}` : `${labelColor}${opt.label}${RESET}`;
+        out.push(
+          fitLine(`    ${prefix} ${num} ${label}  ${C_GRAY}${opt.desc}${RESET}`, w)
+        );
+      }
+      out.push(fitLine(``, w));
+      out.push(
+        fitLine(
+          `    ${C_ACTION}\u2191\u2193${RESET} ${C_GRAY}select \xB7 ${RESET}${C_ACTION}Enter${RESET} ${C_GRAY}confirm${RESET}`,
+          w
+        )
+      );
+    }
+    out.push(fitLine(`  ${sep}`, w));
+  } else {
+    out.push(
+      fitLine(
+        `  ${C_ACTION}Tab${RESET} ${C_GRAY}complete${RESET}  ${C_ACTION}\u2191\u2193${RESET} ${C_GRAY}history${RESET}  ${C_ACTION}@${RESET} ${C_GRAY}files${RESET}  ${C_ACTION}!${RESET} ${C_GRAY}shell${RESET}  ${C_ACTION}/help${RESET} ${C_GRAY}commands${RESET}  ${C_ACTION}Ctrl+T${RESET} ${C_GRAY}tasks${RESET}  ${C_ACTION}Ctrl+C${RESET} ${C_GRAY}exit${RESET}`,
+        w
+      )
+    );
+  }
+  if (modelPickerActive) {
+    out.push(
+      fitLine(
+        `  ${C_ACTION}\u2191\u2193${RESET} ${C_GRAY}navigate  ${RESET}${C_ACTION}Enter${RESET}${C_GRAY}/${RESET}${C_ACTION}Tab${RESET} ${C_GRAY}select model  ${RESET}${C_ACTION}Esc${RESET} ${C_GRAY}cancel${RESET}`,
+        w
+      )
+    );
+  }
+  const editorLines = renderEditor(editor, w, shellMode, debugMode);
+  out.push(...editorLines);
+  out.push(buildStatusBar(state, w, debugMode, statusMessage));
+  return { lines: out };
+}
+
+// src/cli-agent/chat/ui/pi-tui-app.ts
+var EXIT_CONFIRM_WINDOW_MS = 2e3;
+function extractToolResultText(result) {
+  if (typeof result === "string") return result;
+  if (Array.isArray(result)) {
+    return result.map((r) => {
+      if (typeof r === "string") return r;
+      if (typeof r === "object" && r !== null && "text" in r)
+        return String(r.text);
+      return JSON.stringify(r, null, 2);
+    }).join("\n");
+  }
+  return JSON.stringify(result, null, 2);
+}
+async function toggleAllToolCallsExpanded(chatTerminal) {
+  const state = chatTerminal.store.getState();
+  const messages = state.messages;
+  const toolCallIdxs = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "tool_call") toolCallIdxs.push(i);
+  }
+  if (toolCallIdxs.length === 0) {
+    chatTerminal.store.dispatch((prev) => ({
+      messages: [
+        ...prev.messages,
+        {
+          role: "system",
+          content: "No tool call to expand yet.",
+          timestamp: Date.now()
+        }
+      ]
+    }));
+    return;
+  }
+  const anyExpanded = toolCallIdxs.some((i) => messages[i].expanded);
+  if (anyExpanded) {
+    chatTerminal.store.dispatch((prev) => {
+      const msgs = [...prev.messages];
+      for (const idx of toolCallIdxs) {
+        msgs[idx] = { ...msgs[idx], expanded: false };
+      }
+      return { messages: msgs };
+    });
+    return;
+  }
+  const needsFetch = toolCallIdxs.filter((i) => !messages[i].expandedContent);
+  let fetchedResults = /* @__PURE__ */ new Map();
+  if (needsFetch.length > 0) {
+    try {
+      const threadMessages = await getMastraMessages(300);
+      const allResults = [];
+      for (const m of threadMessages) {
+        if (!m) continue;
+        for (const block of m.content) {
+          if (block.type === "tool_result") {
+            allResults.push(
+              extractToolResultText(block.result)
+            );
+          }
+        }
+      }
+      for (let j = 0; j < needsFetch.length && j < allResults.length; j++) {
+        const result = allResults[allResults.length - 1 - j];
+        const msgIdx = needsFetch[needsFetch.length - 1 - j];
+        if (result?.trim()) fetchedResults.set(msgIdx, result);
+      }
+    } catch {
+    }
+  }
+  chatTerminal.store.dispatch((prev) => {
+    const msgs = [...prev.messages];
+    for (const idx of toolCallIdxs) {
+      const existing = msgs[idx];
+      const latestResult = existing.toolResults?.at(-1);
+      const fetched = fetchedResults.get(idx);
+      if (existing.expandedContent) {
+        msgs[idx] = { ...existing, expanded: true };
+      } else if (latestResult?.fullContent || latestResult?.content) {
+        msgs[idx] = {
+          ...existing,
+          expanded: true,
+          expandedContent: latestResult.fullContent ?? latestResult.content
+        };
+      } else if (fetched) {
+        msgs[idx] = { ...existing, expanded: true, expandedContent: fetched };
+      } else {
+        msgs[idx] = { ...existing, expanded: true };
+      }
+    }
+    return { messages: msgs };
+  });
+}
+async function startPiTuiApp(chatTerminal) {
+  const terminal = new ProcessTerminal();
+  const tui = new TUI(terminal, true);
+  let stopped = false;
+  let shellMode = false;
+  let debugMode = false;
+  let planMode = false;
+  let frame = 0;
+  let lastExitConfirmAt = 0;
+  let exitConfirmTimer;
+  let statusMessage = "";
+  let tick;
+  let unsubscribe;
+  const pendingImages = [];
+  let _cachedBlocks = [];
+  let _cachedChromeLines = [];
+  let _cachedWidth = -1;
+  let _cachedChromeSignature = "";
+  let _cachedMessageCount = 0;
+  function messageRenderSignature(msg, idx) {
+    return [
+      idx,
+      msg.role,
+      msg.name ?? "",
+      msg.expanded ? "1" : "0",
+      msg.expandedResultIndex ?? "",
+      chatTerminal.store.getState().config.debug ? "debug" : "",
+      msg.toolCalls?.length ?? 0,
+      msg.toolResults?.length ?? 0
+    ].join(":");
+  }
+  function chromeRenderSignature(state) {
+    return JSON.stringify([state.chatMode, state.workspaceState]);
+  }
+  function renderMessageLines2(state, w) {
+    const contentWidth = w - 2;
+    const widthChanged = w !== _cachedWidth;
+    const chromeSignature = chromeRenderSignature(state);
+    const chromeChanged = chromeSignature !== _cachedChromeSignature;
+    if (widthChanged || chromeChanged) {
+      _cachedChromeLines = [
+        ...headerLines(state),
+        ...workspaceStateCardLines(
+          state.workspaceState,
+          state.chatMode,
+          contentWidth
+        )
+      ];
+      _cachedChromeSignature = chromeSignature;
+    }
+    let firstDirty = 0;
+    if (!widthChanged && !chromeChanged && _cachedMessageCount === state.messages.length) {
+      firstDirty = state.messages.length;
+      for (let idx = 0; idx < state.messages.length; idx += 1) {
+        const msg = state.messages[idx];
+        const prev = _cachedBlocks[idx];
+        if (!msg || !prev) {
+          firstDirty = idx;
+          break;
+        }
+        const signature = messageRenderSignature(msg, idx);
+        if (prev.signature !== signature || prev.contentRef !== msg.content) {
+          firstDirty = idx;
+          break;
+        }
+      }
+    }
+    const nextBlocks = _cachedBlocks.slice(0, firstDirty);
+    for (let idx = firstDirty; idx < state.messages.length; idx += 1) {
+      const msg = state.messages[idx];
+      if (!msg) continue;
+      const signature = messageRenderSignature(msg, idx);
+      const prev = !widthChanged ? _cachedBlocks[idx] : void 0;
+      const lines = prev?.signature === signature && prev.contentRef === msg.content ? prev.lines : messageLines([msg], contentWidth, frame, {
+        showRawToolData: state.config.debug
+      });
+      nextBlocks[idx] = { signature, contentRef: msg.content, lines };
+    }
+    _cachedBlocks = nextBlocks;
+    _cachedWidth = w;
+    _cachedMessageCount = state.messages.length;
+    const out = [];
+    for (const line of _cachedChromeLines) {
+      out.push(line);
+    }
+    for (const block of _cachedBlocks) {
+      if (block) {
+        out.push(...block.lines);
+      }
+    }
+    return out;
+  }
+  const editorTheme = {
+    borderColor: (str) => {
+      if (shellMode) return `${C_GREEN}${str}${RESET}`;
+      if (planMode) return `${C_PURPLE}${str}${RESET}`;
+      if (debugMode) return `${C_RED}${str}${RESET}`;
+      return `${C_GRAY}${str}${RESET}`;
+    },
+    selectList: {
+      selectedPrefix: (s) => `${C_CYAN}> ${RESET}${s}`,
+      selectedText: (s) => `\x1B[1m${s}${RESET}`,
+      description: (s) => `${C_GRAY}${s}${RESET}`,
+      scrollInfo: (s) => `${C_GRAY}${s}${RESET}`,
+      noMatch: (s) => `${C_GRAY}${s}${RESET}`
+    }
+  };
+  const editor = new Editor(tui, editorTheme);
+  editor.focused = true;
+  const slashCommands = [
+    {
+      value: "/plan",
+      description: "Plan then implement: planner \u2192 coder \u2192 reviewer"
+    },
+    ...getCommandList().map((c) => ({
+      value: `/${c.name}`,
+      description: c.description
+    }))
+  ].sort((a, b) => a.value.localeCompare(b.value));
+  const defaultAutocompleteProvider = new MentionAutocompleteProvider({
+    commands: slashCommands
+  });
+  let modelPickerActive = false;
+  const switchModel = (model) => {
+    const prev = chatTerminal.store.getState();
+    chatTerminal.store.dispatch((s) => ({ config: { ...s.config, model } }));
+    chatTerminal.store.dispatch((s) => ({
+      messages: [
+        ...s.messages,
+        {
+          role: "system",
+          content: `Switched model: ${prev.config.model} \u2192 ${model}`
+        }
+      ]
+    }));
+  };
+  const closeModelPicker = () => {
+    if (!modelPickerActive) return;
+    modelPickerActive = false;
+    editor.setAutocompleteProvider(defaultAutocompleteProvider);
+    editor.setText("");
+  };
+  const openModelPicker = () => {
+    const state = chatTerminal.store.getState();
+    if (state.config.availableModels.length === 0) return;
+    modelPickerActive = true;
+    editor.setText("");
+    editor.setAutocompleteProvider(
+      new ModelPickerProvider(
+        () => chatTerminal.store.getState().config.availableModels,
+        () => chatTerminal.store.getState().config.model,
+        switchModel,
+        closeModelPicker
+      )
+    );
+    editor.handleInput("	");
+  };
+  editor.setAutocompleteProvider(defaultAutocompleteProvider);
+  editor.onChange = (text) => {
+    if (!modelPickerActive && /^\/models?\s$/i.test(text)) {
+      openModelPicker();
+    }
+  };
+  editor.onSubmit = (value) => {
+    const trimmed = value.trim();
+    const state = chatTerminal.store.getState();
+    if (state.planReview?.active && trimmed) {
+      if (state.planReview.reviseMode) {
+        editor.setText("");
+        chatTerminal.resolvePlanReview(`revise: ${trimmed}`);
+        return;
+      }
+      return;
+    }
+    if (state.askQuestion?.active && trimmed && !state.askQuestion.options?.length) {
+      editor.setText("");
+      chatTerminal.resolveAskQuestion(trimmed);
+      return;
+    }
+    if (!trimmed || state.input.busy) return;
+    if (/^\/models?$/i.test(trimmed)) {
+      openModelPicker();
+      return;
+    }
+    const imageFiles = pendingImages.map((img) => ({
+      data: img.data,
+      mimeType: img.mimeType
+    }));
+    pendingImages.length = 0;
+    chatTerminal.store.dispatch((prev) => ({
+      input: { ...prev.input, history: [...prev.input.history, trimmed] }
+    }));
+    editor.addToHistory(trimmed);
+    editor.setText("");
+    shellMode = false;
+    void chatTerminal.handleSubmitWithContent(
+      trimmed,
+      false,
+      imageFiles.length > 0 ? imageFiles : void 0
+    );
+  };
+  class MessagesComponent {
+    invalidate() {
+      _cachedWidth = -1;
+    }
+    render(width) {
+      return renderMessageLines2(chatTerminal.store.getState(), width);
+    }
+  }
+  class PanelComponent {
+    invalidate() {
+    }
+    render(width) {
+      const state = chatTerminal.store.getState();
+      debugMode = state.debug;
+      planMode = state.planMode;
+      const result = buildPanel(state, width, {
+        editor,
+        frame,
+        shellMode,
+        debugMode,
+        statusMessage,
+        modelPickerActive
+      });
+      return result.lines;
+    }
+  }
+  tui.addChild(new MessagesComponent());
+  tui.addChild(new PanelComponent());
+  tui.setFocus(editor);
+  function clearExitConfirm() {
+    lastExitConfirmAt = 0;
+    statusMessage = "";
+    if (exitConfirmTimer) {
+      clearTimeout(exitConfirmTimer);
+      exitConfirmTimer = void 0;
+    }
+  }
+  function handleInterrupt() {
+    const state = chatTerminal.store.getState();
+    if (editor.getText().length > 0) {
+      editor.setText("");
+      shellMode = false;
+      clearExitConfirm();
+      tui.requestRender();
+      return;
+    }
+    if (state.input.busy) {
+      const canceledPrompt = chatTerminal.cancelTask();
+      if (canceledPrompt) {
+        editor.setText(canceledPrompt);
+        shellMode = canceledPrompt.startsWith("!");
+      }
+      clearExitConfirm();
+      tui.requestRender();
+      return;
+    }
+    if (state.planMode) {
+      chatTerminal.store.dispatch({ planMode: false });
+      clearExitConfirm();
+      tui.requestRender();
+      return;
+    }
+    requestExit();
+  }
+  function requestExit() {
+    const now = Date.now();
+    if (now - lastExitConfirmAt <= EXIT_CONFIRM_WINDOW_MS) {
+      cleanup();
+      process.exit(0);
+    }
+    lastExitConfirmAt = now;
+    statusMessage = "Press Ctrl+C again within 2s to exit";
+    if (exitConfirmTimer) clearTimeout(exitConfirmTimer);
+    exitConfirmTimer = setTimeout(() => {
+      clearExitConfirm();
+      tui.requestRender();
+    }, EXIT_CONFIRM_WINDOW_MS);
+    tui.requestRender();
+  }
+  async function handleEditorInput(data) {
+    try {
+      const image = await imageFromPaste(data);
+      if (image) {
+        pendingImages.push(image);
+        const current = editor.getText();
+        editor.setText(current ? `${current} ${image.marker}` : image.marker);
+        tui.requestRender();
+        return;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      chatTerminal.store.dispatch((prev) => ({
+        messages: [
+          ...prev.messages,
+          {
+            role: "system",
+            content: `Image paste skipped: ${message}`,
+            timestamp: Date.now()
+          }
+        ]
+      }));
+      tui.requestRender();
+      return;
+    }
+    if (matchesKey(data, Key.backspace)) {
+      const lines = editor.getLines();
+      const { line, col } = editor.getCursor();
+      const textBeforeCursor = (lines[line] ?? "").slice(0, col);
+      const markerMatch = textBeforeCursor.match(/\[image:[^\]]+\]$/);
+      if (markerMatch) {
+        const marker = markerMatch[0];
+        const fullText = lines.join("\n");
+        editor.setText(
+          fullText.slice(0, fullText.lastIndexOf(marker)) + fullText.slice(fullText.lastIndexOf(marker) + marker.length)
+        );
+        for (let i = pendingImages.length - 1; i >= 0; i--) {
+          if (pendingImages[i].marker === marker) {
+            pendingImages.splice(i, 1);
+            break;
+          }
+        }
+        tui.requestRender();
+        return;
+      }
+    }
+    editor.handleInput(data);
+    if (modelPickerActive && matchesKey(data, Key.escape)) {
+      closeModelPicker();
+    }
+    const currentText = editor.getText();
+    for (let i = pendingImages.length - 1; i >= 0; i--) {
+      if (!currentText.includes(pendingImages[i].marker))
+        pendingImages.splice(i, 1);
+    }
+    shellMode = currentText.startsWith("!");
+    tui.requestRender();
+  }
+  tui.addInputListener((data) => {
+    if (matchesKey(data, Key.ctrl("c"))) {
+      handleInterrupt();
+      return { consume: true };
+    }
+    const state = chatTerminal.store.getState();
+    if (matchesKey(data, Key.escape) && state.screen === "help") {
+      chatTerminal.store.dispatch({ screen: "main" });
+      tui.requestRender();
+      return { consume: true };
+    }
+    if (matchesKey(data, Key.ctrl("o"))) {
+      void toggleAllToolCallsExpanded(chatTerminal);
+      return { consume: true };
+    }
+    if (matchesKey(data, Key.ctrl("t"))) {
+      chatTerminal.store.dispatch((prev) => ({
+        taskListVisible: !prev.taskListVisible
+      }));
+      tui.requestRender();
+      return { consume: true };
+    }
+    if (state.askQuestion?.active) {
+      const aq = state.askQuestion;
+      const options = aq.options ?? [];
+      if (options.length > 0) {
+        const sel = aq.selection ?? 0;
+        const isMultiSelect = aq.selectionMode === "multi_select";
+        if (editor.getText().trim() === "") {
+          if (matchesKey(data, Key.up)) {
+            chatTerminal.store.dispatch({
+              askQuestion: {
+                ...aq,
+                selection: (sel + options.length - 1) % options.length
+              }
+            });
+            tui.requestRender();
+            return { consume: true };
+          }
+          if (matchesKey(data, Key.down)) {
+            chatTerminal.store.dispatch({
+              askQuestion: { ...aq, selection: (sel + 1) % options.length }
+            });
+            tui.requestRender();
+            return { consume: true };
+          }
+          if (isMultiSelect && data === " ") {
+            const selected = aq.selected.includes(sel) ? aq.selected.filter((idx) => idx !== sel) : [...aq.selected, sel];
+            chatTerminal.store.dispatch({ askQuestion: { ...aq, selected } });
+            tui.requestRender();
+            return { consume: true };
+          }
+          if (matchesKey(data, Key.enter)) {
+            if (isMultiSelect) {
+              chatTerminal.resolveAskQuestion(
+                aq.selected.map((idx) => options[idx]?.label).filter((label) => Boolean(label))
+              );
+            } else {
+              const selected = options[sel];
+              if (selected) chatTerminal.resolveAskQuestion(selected.label);
+            }
+            return { consume: true };
+          }
+        }
+        if (matchesKey(data, Key.escape)) {
+          chatTerminal.resolveAskQuestion(isMultiSelect ? [] : "(skipped)");
+          return { consume: true };
+        }
+        return { consume: true };
+      }
+      if (matchesKey(data, Key.escape)) {
+        chatTerminal.resolveAskQuestion("(skipped)");
+        return { consume: true };
+      }
+    }
+    if (state.planReview?.active && editor.getText().trim() === "") {
+      const pr = state.planReview;
+      if (pr.reviseMode) {
+        if (matchesKey(data, Key.escape)) {
+          chatTerminal.store.dispatch({
+            planReview: { active: true, selection: 2, reviseMode: false }
+          });
+          tui.requestRender();
+          return { consume: true };
+        }
+        void handleEditorInput(data);
+        return { consume: true };
+      }
+      if (!pr.reviseMode) {
+        if (!matchesKey(data, Key.up) && !matchesKey(data, Key.down) && !matchesKey(data, Key.enter) && !matchesKey(data, Key.escape)) {
+          return { consume: true };
+        }
+      }
+      const PLAN_OPTIONS = ["apply", "no", "revise"];
+      const sel = pr.selection ?? 0;
+      if (matchesKey(data, Key.up)) {
+        chatTerminal.store.dispatch({
+          planReview: {
+            active: true,
+            selection: (sel + PLAN_OPTIONS.length - 1) % PLAN_OPTIONS.length
+          }
+        });
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (matchesKey(data, Key.down)) {
+        chatTerminal.store.dispatch({
+          planReview: {
+            active: true,
+            selection: (sel + 1) % PLAN_OPTIONS.length
+          }
+        });
+        tui.requestRender();
+        return { consume: true };
+      }
+      if (matchesKey(data, Key.enter)) {
+        const chosen = PLAN_OPTIONS[sel] ?? "apply";
+        if (chosen === "revise") {
+          chatTerminal.store.dispatch({
+            planReview: { active: true, selection: sel, reviseMode: true }
+          });
+          tui.requestRender();
+          return { consume: true };
+        }
+        chatTerminal.resolvePlanReview(chosen);
+        return { consume: true };
+      }
+      if (matchesKey(data, Key.escape)) {
+        chatTerminal.resolvePlanReview("cancel");
+        return { consume: true };
+      }
+    }
+    if (state.planReview?.active && !state.planReview.reviseMode) {
+      if (matchesKey(data, Key.up) || matchesKey(data, Key.down) || matchesKey(data, Key.enter) || matchesKey(data, Key.escape)) {
+        return { consume: true };
+      }
+      return { consume: true };
+    }
+    void handleEditorInput(data);
+    return { consume: true };
+  });
+  function cleanup() {
+    if (stopped) return;
+    stopped = true;
+    if (exitConfirmTimer) {
+      clearTimeout(exitConfirmTimer);
+      exitConfirmTimer = void 0;
+    }
+    if (tick) {
+      clearInterval(tick);
+      tick = void 0;
+    }
+    unsubscribe?.();
+    process.off("SIGINT", handleInterrupt);
+    tui.stop();
+  }
+  process.once("exit", cleanup);
+  process.once("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGINT", handleInterrupt);
+  await initShiki().catch(() => {
+  });
+  tui.start();
+  tick = setInterval(() => {
+    const state = chatTerminal.store.getState();
+    if (state.planReview?.active) return;
+    if (isActiveTaskPhase(state.task.phase) || state.synthRunning) {
+      frame = (frame + 1) % SPINNER.length;
+      tui.requestRender();
+    }
+  }, 120);
+  unsubscribe = chatTerminal.bus.on("screen:refresh", () => {
+    tui.requestRender();
+  });
+  await new Promise((resolve2) => {
+    const interval = setInterval(() => {
+      if (stopped) {
+        clearInterval(interval);
+        resolve2();
+      }
+    }, 50);
+  });
+}
+export {
+  isActiveTaskPhase,
+  startPiTuiApp
+};