@wrongstack/tui 0.1.0

package/dist/index.js

@@ -0,0 +1,2421 @@
+import React, { useReducer, useRef, useEffect, useMemo } from 'react';
+import { render, useApp, Box, useStdout, Static, Text, useInput } from 'ink';
+import * as path2 from 'path';
+import * as fs2 from 'fs/promises';
+import { InputBuilder } from '@wrongstack/core';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { spawn } from 'child_process';
+import * as os from 'os';
+
+// src/run-tui.ts
+
+// src/markdown-table.ts
+function renderMarkdownTables(text, maxWidth) {
+  if (!text.includes("|")) return text;
+  const lines = text.split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const end = detectTable(lines, i);
+    if (end > i) {
+      out.push(renderTable(lines.slice(i, end), Math.max(20, maxWidth)));
+      i = end;
+    } else {
+      out.push(lines[i] ?? "");
+      i++;
+    }
+  }
+  return out.join("\n");
+}
+var ROW_RE = /^\s*\|.*\|\s*$/;
+var SEP_RE = /^\s*\|[\s\-:|]+\|\s*$/;
+function detectTable(lines, start) {
+  if (start + 1 >= lines.length) return start;
+  if (!ROW_RE.test(lines[start] ?? "")) return start;
+  const sep = lines[start + 1] ?? "";
+  if (!SEP_RE.test(sep) || !/-/.test(sep)) return start;
+  let end = start + 2;
+  while (end < lines.length && ROW_RE.test(lines[end] ?? "")) end++;
+  return end;
+}
+function parseCells(line) {
+  const inner = line.trim().replace(/^\||\|$/g, "");
+  const parts = [];
+  let buf = "";
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch === "\\" && inner[i + 1] === "|") {
+      buf += "|";
+      i++;
+      continue;
+    }
+    if (ch === "|") {
+      parts.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
+  }
+  parts.push(buf);
+  return parts.map((c) => c.trim());
+}
+function parseAlign(sep) {
+  const t = sep.trim();
+  const left = t.startsWith(":");
+  const right = t.endsWith(":");
+  if (left && right) return "center";
+  if (right) return "right";
+  return "left";
+}
+function renderTable(tableLines, maxWidth) {
+  const header = parseCells(tableLines[0] ?? "");
+  const sepCells = parseCells(tableLines[1] ?? "");
+  const cols = header.length;
+  const aligns = [];
+  for (let c = 0; c < cols; c++) {
+    aligns.push(parseAlign(sepCells[c] ?? ""));
+  }
+  const dataRows = tableLines.slice(2).map(parseCells);
+  for (const row of dataRows) {
+    while (row.length < cols) row.push("");
+    row.length = cols;
+  }
+  const widths = computeWidths([header, ...dataRows], cols, maxWidth);
+  const lines = [];
+  lines.push(border("\u250C", "\u252C", "\u2510", widths));
+  lines.push(...renderRow(header, widths, aligns));
+  lines.push(border("\u251C", "\u253C", "\u2524", widths));
+  for (const row of dataRows) {
+    lines.push(...renderRow(row, widths, aligns));
+  }
+  lines.push(border("\u2514", "\u2534", "\u2518", widths));
+  return lines.join("\n");
+}
+function computeWidths(allRows, cols, maxWidth) {
+  const overhead = 3 * cols + 1;
+  const avail = Math.max(cols * MIN_COL_WIDTH, maxWidth - overhead);
+  const natural = new Array(cols).fill(0);
+  for (const row of allRows) {
+    for (let c = 0; c < cols; c++) {
+      const cell = row[c] ?? "";
+      const w = longestWord(cell);
+      const total = cell.length;
+      natural[c] = Math.max(natural[c], total);
+      if (w > natural[c]) natural[c] = Math.min(total + 1, w);
+    }
+  }
+  const sumNatural = natural.reduce((s, n) => s + n, 0);
+  if (sumNatural <= avail) return natural;
+  const widths = natural.slice();
+  let sum = sumNatural;
+  while (sum > avail) {
+    let maxIdx = -1;
+    let maxVal = MIN_COL_WIDTH;
+    for (let i = 0; i < cols; i++) {
+      const w = widths[i];
+      if (w > maxVal) {
+        maxVal = w;
+        maxIdx = i;
+      }
+    }
+    if (maxIdx < 0) break;
+    widths[maxIdx]--;
+    sum--;
+  }
+  return widths;
+}
+var MIN_COL_WIDTH = 4;
+function longestWord(s) {
+  let max = 0;
+  for (const w of s.split(/\s+/)) if (w.length > max) max = w.length;
+  return max;
+}
+function border(left, mid, right, widths) {
+  return left + widths.map((w) => "\u2500".repeat(w + 2)).join(mid) + right;
+}
+function renderRow(cells, widths, aligns) {
+  const wrapped = cells.map((c, i) => wrapCell(c, widths[i] ?? MIN_COL_WIDTH));
+  const height = Math.max(1, ...wrapped.map((w) => w.length));
+  const out = [];
+  for (let line = 0; line < height; line++) {
+    const parts = [];
+    for (let c = 0; c < widths.length; c++) {
+      const w = widths[c] ?? MIN_COL_WIDTH;
+      const text = wrapped[c]?.[line] ?? "";
+      parts.push(padCell(text, w, aligns[c] ?? "left"));
+    }
+    out.push("\u2502 " + parts.join(" \u2502 ") + " \u2502");
+  }
+  return out;
+}
+function wrapCell(text, width) {
+  if (text.length <= width) return [text];
+  const out = [];
+  const words = text.split(/(\s+)/);
+  let cur = "";
+  for (const word of words) {
+    if (!word) continue;
+    if (cur.length + word.length <= width) {
+      cur += word;
+      continue;
+    }
+    if (cur) {
+      out.push(cur.trimEnd());
+      cur = "";
+    }
+    if (word.length > width) {
+      let rest = word;
+      while (rest.length > width) {
+        out.push(rest.slice(0, width));
+        rest = rest.slice(width);
+      }
+      cur = rest;
+    } else if (!/^\s+$/.test(word)) {
+      cur = word;
+    }
+  }
+  if (cur) out.push(cur.trimEnd());
+  return out.length === 0 ? [""] : out;
+}
+function padCell(text, width, align) {
+  if (text.length >= width) return text.slice(0, width);
+  const pad = width - text.length;
+  if (align === "right") return " ".repeat(pad) + text;
+  if (align === "center") {
+    const l = Math.floor(pad / 2);
+    return " ".repeat(l) + text + " ".repeat(pad - l);
+  }
+  return text + " ".repeat(pad);
+}
+function History({ entries, streamingText }) {
+  const { stdout } = useStdout();
+  const termWidth = stdout?.columns ?? 80;
+  const tail = streamingText ? tailForDisplay(streamingText, MAX_STREAM_DISPLAY_CHARS) : "";
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Static, { items: entries, children: (entry) => /* @__PURE__ */ jsx(Box, { marginBottom: entry.kind === "turn-summary" ? 1 : 0, children: /* @__PURE__ */ jsx(Entry, { entry, termWidth }) }, entry.id) }),
+    tail ? /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "> " }),
+      /* @__PURE__ */ jsx(Text, { children: tail })
+    ] }) : null
+  ] });
+}
+var MAX_STREAM_DISPLAY_CHARS = 480;
+function tailForDisplay(text, maxChars) {
+  if (text.length <= maxChars) return text;
+  const cut = text.length - maxChars;
+  const nl = text.indexOf("\n", cut);
+  if (nl !== -1 && nl < cut + 80) {
+    return `\u2026 ${text.slice(nl + 1)}`;
+  }
+  return `\u2026 ${text.slice(cut)}`;
+}
+function DiffBlock({ rows, hidden }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 4, marginTop: 0, children: [
+    rows.map((row, i) => {
+      if (row.kind === "hunk") {
+        return /* @__PURE__ */ jsx(Text, { color: "cyan", dimColor: true, children: row.text }, i);
+      }
+      if (row.kind === "meta") {
+        return /* @__PURE__ */ jsx(Text, { dimColor: true, children: row.text }, i);
+      }
+      if (row.kind === "ctx") {
+        return /* @__PURE__ */ jsx(Text, { dimColor: true, children: row.text }, i);
+      }
+      const bg = row.kind === "add" ? "green" : "red";
+      const fg = row.kind === "add" ? "black" : "white";
+      return /* @__PURE__ */ jsx(Text, { backgroundColor: bg, color: fg, children: row.text }, i);
+    }),
+    hidden > 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: `  \u2026 ${hidden} more line${hidden === 1 ? "" : "s"}` }) : null
+  ] });
+}
+function Entry({ entry, termWidth }) {
+  switch (entry.kind) {
+    case "user":
+      return /* @__PURE__ */ jsxs(Text, { children: [
+        /* @__PURE__ */ jsx(Text, { color: entry.queued ? "yellow" : "cyan", children: entry.queued ? "\u231B" : "\u203A" }),
+        " ",
+        /* @__PURE__ */ jsx(Text, { dimColor: entry.queued ?? false, children: entry.text }),
+        entry.queued ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: " (queued)" }) : null
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsx(Text, { children: renderMarkdownTables(entry.text, termWidth) });
+    case "tool": {
+      const argSummary = formatToolArgs(entry.name, entry.input);
+      const outLines = formatToolOutput(entry.name, entry.output, entry.ok);
+      const diff = entry.ok ? extractDiffPreview(entry.name, entry.output) : void 0;
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: entry.ok ? "green" : "red", children: entry.ok ? "\u25CF" : "\u2717" }),
+          " ",
+          /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: entry.name }),
+          argSummary ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { children: "  " }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: argSummary })
+          ] }) : null,
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \xB7  ${fmtDuration(entry.durationMs)}` })
+        ] }),
+        outLines.map((line, i) => {
+          const isLast = i === outLines.length - 1 && !diff;
+          const prefix = isLast ? "  \u2514\u2500 " : "  \u251C\u2500 ";
+          const errish = !entry.ok || line.startsWith("!");
+          return /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: prefix }),
+            /* @__PURE__ */ jsx(Text, { color: errish ? "red" : void 0, dimColor: !errish, children: line })
+          ] }, i);
+        }),
+        diff ? /* @__PURE__ */ jsx(DiffBlock, { rows: diff.rows, hidden: diff.hidden }) : null
+      ] });
+    }
+    case "info":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: entry.text });
+    case "warn":
+      return /* @__PURE__ */ jsx(Text, { color: "yellow", children: entry.text });
+    case "error":
+      return /* @__PURE__ */ jsx(Text, { color: "red", children: entry.text });
+    case "turn-summary":
+      return /* @__PURE__ */ jsx(Text, { dimColor: true, children: entry.text });
+    case "banner":
+      return /* @__PURE__ */ jsx(Banner, { entry });
+  }
+}
+function Banner({
+  entry
+}) {
+  const cwdShort = shortenPath(entry.cwd, 48);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor: "magenta",
+      paddingX: 2,
+      paddingY: 0,
+      children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: "  \u259F\u259B  " }),
+          /* @__PURE__ */ jsx(Text, { color: "magenta", bold: true, children: "WrongStack" }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  v" }),
+          /* @__PURE__ */ jsx(Text, { children: entry.version })
+        ] }),
+        /* @__PURE__ */ jsx(Text, { dimColor: true, italic: true, children: "      Built on the wrong stack. Shipped anyway." }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: "      provider  " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            entry.provider,
+            "/",
+            entry.model
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: "      cwd       " }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: cwdShort })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: "      hints     " }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "/help \xB7 /init \xB7 /memory \xB7 /queue \xB7 /exit" })
+        ] })
+      ]
+    }
+  );
+}
+function shortenPath(p, max) {
+  if (p.length <= max) return p;
+  return `\u2026${p.slice(p.length - (max - 1))}`;
+}
+function fmtDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const totalSec = Math.floor(ms / 1e3);
+  return `${Math.floor(totalSec / 60)}m${totalSec % 60}s`;
+}
+var ARG_BUDGET = 60;
+var OUT_BUDGET = 80;
+function formatToolArgs(toolName, input) {
+  if (!input || typeof input !== "object") return "";
+  const obj = input;
+  switch (toolName) {
+    case "read":
+    case "write":
+    case "edit":
+    case "patch":
+    case "document":
+    case "list_dir":
+    case "ls":
+    case "tree": {
+      const p = stringOf(obj["path"]) ?? stringOf(obj["file"]);
+      return p ? shortenPath(p, ARG_BUDGET) : "";
+    }
+    case "grep":
+    case "search":
+    case "replace": {
+      const pat = stringOf(obj["pattern"]) ?? stringOf(obj["query"]);
+      const scope = stringOf(obj["path"]) ?? stringOf(obj["glob"]);
+      const head = pat ? `"${truncMid(pat, 36)}"` : "";
+      const tail = scope ? ` in ${shortenPath(scope, 28)}` : "";
+      return `${head}${tail}` || (stringOf(obj["command"]) ?? "");
+    }
+    case "glob": {
+      const pat = stringOf(obj["pattern"]) ?? stringOf(obj["glob"]);
+      return pat ? `"${truncMid(pat, ARG_BUDGET - 2)}"` : "";
+    }
+    case "bash":
+    case "shell":
+    case "exec":
+    case "install":
+    case "git": {
+      const cmd = stringOf(obj["command"]) ?? stringOf(obj["args"]);
+      return cmd ? truncMid(cmd, ARG_BUDGET) : "";
+    }
+    case "diff": {
+      const files = Array.isArray(obj["files"]) ? obj["files"] : void 0;
+      if (files && files.length > 0) {
+        const head = stringOf(files[0]) ?? "";
+        const rest = files.length > 1 ? ` (+${files.length - 1})` : "";
+        return head ? `${shortenPath(head, 50)}${rest}` : "";
+      }
+      const mode = stringOf(obj["mode"]);
+      return mode ? `mode: ${mode}` : "";
+    }
+    case "fetch":
+    case "webfetch":
+    case "web_fetch": {
+      const u = stringOf(obj["url"]);
+      return u ? truncMid(u, ARG_BUDGET) : "";
+    }
+    case "todo": {
+      const list = obj["todos"];
+      if (Array.isArray(list)) return `${list.length} item${list.length === 1 ? "" : "s"}`;
+      return "";
+    }
+    case "lint":
+    case "format":
+    case "typecheck":
+    case "test":
+    case "audit":
+    case "outdated": {
+      const files = obj["files"];
+      if (Array.isArray(files) && files.length > 0) {
+        const first = stringOf(files[0]);
+        const more = files.length > 1 ? ` (+${files.length - 1})` : "";
+        return first ? `${shortenPath(first, 50)}${more}` : `${files.length} files`;
+      }
+      const filter = stringOf(obj["filter"]) ?? stringOf(obj["pattern"]);
+      return filter ? `"${truncMid(filter, ARG_BUDGET - 2)}"` : "";
+    }
+    case "json": {
+      const file = stringOf(obj["file"]);
+      const q = stringOf(obj["query"]);
+      if (file) return q ? `${shortenPath(file, 40)}  ${q}` : shortenPath(file, ARG_BUDGET);
+      return q ? truncMid(q, ARG_BUDGET) : "";
+    }
+    case "scaffold": {
+      const tmpl = stringOf(obj["template"]) ?? stringOf(obj["type"]);
+      const name = stringOf(obj["name"]);
+      if (tmpl && name) return `${tmpl} \u2192 ${truncMid(name, ARG_BUDGET - tmpl.length - 4)}`;
+      return name ?? tmpl ?? "";
+    }
+    case "remember":
+    case "forget":
+    case "memory": {
+      const key = stringOf(obj["key"]) ?? stringOf(obj["name"]);
+      return key ? truncMid(key, ARG_BUDGET) : "";
+    }
+    case "mode": {
+      const m = stringOf(obj["mode"]) ?? stringOf(obj["name"]);
+      return m ? truncMid(m, ARG_BUDGET) : "";
+    }
+    case "logs": {
+      const target = stringOf(obj["target"]) ?? stringOf(obj["service"]) ?? stringOf(obj["path"]);
+      return target ? truncMid(target, ARG_BUDGET) : "";
+    }
+  }
+  for (const key of ["path", "file", "url", "name", "query", "pattern", "command"]) {
+    const v = stringOf(obj[key]);
+    if (v) return truncMid(v, ARG_BUDGET);
+  }
+  try {
+    return truncMid(JSON.stringify(obj), ARG_BUDGET);
+  } catch {
+    return "";
+  }
+}
+function formatToolOutput(toolName, output, ok) {
+  if (!output) return ok ? [] : ["failed"];
+  const text = output.trim();
+  if (!text) return ok ? [] : ["failed"];
+  const json = tryParseJson(text);
+  if (toolName === "write") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const bytes = numOf(o["bytes_written"]) ?? numOf(o["bytes"]);
+      const created = o["created"] === true;
+      const tag = created ? "created" : "updated";
+      if (bytes !== void 0) return [`${tag} \xB7 ${fmtBytes(bytes)}`];
+      return [tag];
+    }
+  }
+  if (toolName === "edit") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const reps = numOf(o["replacements"]);
+      if (reps !== void 0) return [`${reps} replacement${reps === 1 ? "" : "s"}`];
+    }
+  }
+  if (toolName === "patch") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const applied = numOf(o["applied"]);
+      const rejected = numOf(o["rejected"]);
+      const files = Array.isArray(o["files"]) ? o["files"] : void 0;
+      const lines = [];
+      if (applied !== void 0 || rejected !== void 0) {
+        const parts = [];
+        if (applied !== void 0) parts.push(`${applied} applied`);
+        if (rejected !== void 0 && rejected > 0) parts.push(`${rejected} rejected`);
+        lines.push(parts.join(" \xB7 "));
+      }
+      if (files && files.length > 0) {
+        const first = stringOf(files[0]) ?? "";
+        const more = files.length > 1 ? ` (+${files.length - 1})` : "";
+        lines.push(`${shortenPath(first, 60)}${more}`);
+      }
+      if (lines.length > 0) return lines;
+    }
+  }
+  if (toolName === "replace") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const files = numOf(o["files_modified"]);
+      const reps = numOf(o["total_replacements"]);
+      if (files !== void 0 && reps !== void 0) {
+        return [
+          `${reps} replacement${reps === 1 ? "" : "s"} in ${files} file${files === 1 ? "" : "s"}`
+        ];
+      }
+    }
+  }
+  if (toolName === "diff") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const files = Array.isArray(o["files"]) ? o["files"] : void 0;
+      const truncated = o["truncated"] === true;
+      const mode = stringOf(o["mode"]);
+      const diff = stringOf(o["diff"]);
+      if (!diff) return [files && files.length === 0 ? "no changes" : "empty diff"];
+      const head = [];
+      if (mode) head.push(mode);
+      if (files && files.length > 0) head.push(`${files.length} file${files.length === 1 ? "" : "s"}`);
+      if (truncated) head.push("truncated");
+      return head.length > 0 ? [head.join(" \xB7 ")] : [];
+    }
+  }
+  if (toolName === "read") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const bytes = numOf(o["bytes"]);
+      if (bytes !== void 0) return [`${fmtBytes(bytes)} read`];
+    }
+    const range = scanNumberedRange(text);
+    if (range.count > 0 && range.first !== void 0 && range.last !== void 0) {
+      if (range.first === range.last) {
+        return [`L${range.first} \xB7 ${fmtBytes(text.length)}`];
+      }
+      const contiguous = range.count === range.last - range.first + 1;
+      const head = `L${range.first}\u2013${range.last}`;
+      const tail = contiguous ? `${range.count} line${range.count === 1 ? "" : "s"}` : `${range.count} lines (gaps)`;
+      return [`${head} \xB7 ${tail} \xB7 ${fmtBytes(text.length)}`];
+    }
+  }
+  if (toolName === "grep" || toolName === "glob") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const matches = Array.isArray(o["matches"]) ? o["matches"] : void 0;
+      const count = numOf(o["count"]) ?? matches?.length;
+      const truncated = o["truncated"] === true;
+      if (count !== void 0) {
+        if (count === 0) return ["no matches"];
+        const lines = [
+          `${count} match${count === 1 ? "" : "es"}${truncated ? " (truncated)" : ""}`
+        ];
+        const firstHit = matches && matches.length > 0 ? formatMatchHit(matches[0]) : void 0;
+        if (firstHit) lines.push(firstHit);
+        return lines;
+      }
+    }
+  }
+  if (toolName === "bash" || toolName === "shell") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const exit = numOf(o["exit_code"]) ?? numOf(o["exitCode"]);
+      const stdout = stringOf(o["stdout"]) ?? "";
+      const stderr = stringOf(o["stderr"]) ?? "";
+      const stdoutLines = countLines(stdout);
+      const stderrLines = countLines(stderr);
+      const head = [];
+      if (exit !== void 0) head.push(`exit ${exit}`);
+      const lineParts = [];
+      if (stdoutLines > 0) lineParts.push(`${stdoutLines} out`);
+      if (stderrLines > 0) lineParts.push(`${stderrLines} err`);
+      if (lineParts.length > 0) head.push(lineParts.join(" \xB7 "));
+      const lines = [];
+      if (head.length > 0) lines.push(head.join(" \xB7 "));
+      const stdoutPreview = firstNonEmpty(stdout);
+      const stderrPreview = firstNonEmpty(stderr);
+      if (stdoutPreview) lines.push(`"${truncMid(stdoutPreview, 70)}"`);
+      if (stderrPreview && stderrPreview !== stdoutPreview) {
+        lines.push(`! "${truncMid(stderrPreview, 70)}"`);
+      }
+      if (lines.length > 0) return lines;
+    }
+  }
+  if (toolName === "todo") {
+    return ok ? [] : [text.split("\n")[0] ?? ""];
+  }
+  if (toolName === "fetch" || toolName === "webfetch" || toolName === "web_fetch") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const status = numOf(o["status"]);
+      const ct = stringOf(o["content_type"]);
+      const url = stringOf(o["url"]);
+      const content = stringOf(o["content"]);
+      const head = [];
+      if (status !== void 0) head.push(`HTTP ${status}`);
+      if (ct) head.push(ct.split(";")[0] ?? ct);
+      if (content) head.push(fmtBytes(Buffer.byteLength(content, "utf8")));
+      const lines = [];
+      if (head.length > 0) lines.push(head.join(" \xB7 "));
+      if (url && status !== void 0 && (status < 200 || status >= 400)) {
+        lines.push(shortenPath(url, 70));
+      }
+      if (lines.length > 0) return lines;
+    }
+  }
+  if (toolName === "git") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const exit = numOf(o["exitCode"]) ?? numOf(o["exit_code"]);
+      const stdout = stringOf(o["stdout"]) ?? "";
+      const stderr = stringOf(o["stderr"]) ?? "";
+      const head = [];
+      if (exit !== void 0) head.push(`exit ${exit}`);
+      const stdoutLines = countLines(stdout);
+      const stderrLines = countLines(stderr);
+      const lparts = [];
+      if (stdoutLines > 0) lparts.push(`${stdoutLines} out`);
+      if (stderrLines > 0) lparts.push(`${stderrLines} err`);
+      if (lparts.length > 0) head.push(lparts.join(" \xB7 "));
+      const lines = [];
+      if (head.length > 0) lines.push(head.join(" \xB7 "));
+      const preview = firstNonEmpty(stdout) ?? firstNonEmpty(stderr);
+      if (preview) lines.push(`"${truncMid(preview, 70)}"`);
+      if (lines.length > 0) return lines;
+    }
+  }
+  if (toolName === "lint") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const linter = stringOf(o["linter"]);
+      const files = numOf(o["files_checked"]);
+      const errors = numOf(o["errors"]) ?? 0;
+      const warnings = numOf(o["warnings"]) ?? 0;
+      const fix = o["fix_applied"] === true;
+      const head = [];
+      if (linter && linter !== "none") head.push(linter);
+      head.push(`${errors} error${errors === 1 ? "" : "s"}`);
+      head.push(`${warnings} warning${warnings === 1 ? "" : "s"}`);
+      if (files !== void 0) head.push(`${files} file${files === 1 ? "" : "s"}`);
+      if (fix) head.push("fixed");
+      return [head.join(" \xB7 ")];
+    }
+  }
+  if (toolName === "format") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const fixer = stringOf(o["fixer"]);
+      const checked = numOf(o["files_checked"]);
+      const changed = numOf(o["files_changed"]);
+      const head = [];
+      if (fixer && fixer !== "none") head.push(fixer);
+      if (changed !== void 0 && checked !== void 0) {
+        head.push(`${changed}/${checked} changed`);
+      } else if (changed !== void 0) {
+        head.push(`${changed} changed`);
+      }
+      return head.length > 0 ? [head.join(" \xB7 ")] : [];
+    }
+  }
+  if (toolName === "typecheck") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const exit = numOf(o["exit_code"]) ?? numOf(o["exitCode"]);
+      const errors = numOf(o["errors"]);
+      const head = [];
+      if (errors !== void 0) head.push(`${errors} error${errors === 1 ? "" : "s"}`);
+      if (exit !== void 0) head.push(`exit ${exit}`);
+      const stdout = stringOf(o["output"]) ?? stringOf(o["stdout"]) ?? "";
+      const lines = [];
+      if (head.length > 0) lines.push(head.join(" \xB7 "));
+      const preview = firstNonEmpty(stdout);
+      if (preview && (!errors || errors > 0)) lines.push(`"${truncMid(preview, 70)}"`);
+      if (lines.length > 0) return lines;
+    }
+  }
+  if (toolName === "test") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const runner = stringOf(o["runner"]);
+      const total = numOf(o["tests_run"]) ?? 0;
+      const passed = numOf(o["passed"]) ?? 0;
+      const failed = numOf(o["failed"]) ?? 0;
+      const duration = numOf(o["duration_ms"]);
+      const head = [];
+      if (runner && runner !== "none") head.push(runner);
+      head.push(`${passed}/${total} passed`);
+      if (failed > 0) head.push(`${failed} failed`);
+      if (duration !== void 0) head.push(fmtDuration(duration));
+      return [head.join(" \xB7 ")];
+    }
+  }
+  if (toolName === "audit") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const total = numOf(o["total"]) ?? 0;
+      const summary = stringOf(o["summary"]);
+      if (total === 0) return ["no vulnerabilities"];
+      const head = `${total} vulnerabilit${total === 1 ? "y" : "ies"}`;
+      return summary && summary.toLowerCase() !== head.toLowerCase() ? [head, truncMid(summary, OUT_BUDGET)] : [head];
+    }
+  }
+  if (toolName === "outdated") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const total = numOf(o["total"]) ?? 0;
+      const pkgs = Array.isArray(o["packages"]) ? o["packages"] : void 0;
+      if (total === 0) return ["all up to date"];
+      const lines = [`${total} outdated`];
+      if (pkgs && pkgs.length > 0) {
+        const first = pkgs[0];
+        if (first && typeof first === "object") {
+          const p = first;
+          const name = stringOf(p["name"]) ?? stringOf(p["package"]);
+          const cur = stringOf(p["current"]);
+          const wanted = stringOf(p["wanted"]) ?? stringOf(p["latest"]);
+          if (name && cur && wanted) lines.push(`${name}: ${cur} \u2192 ${wanted}`);
+          else if (name) lines.push(name);
+        }
+      }
+      return lines;
+    }
+  }
+  if (toolName === "tree") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const files = numOf(o["total_files"]);
+      const dirs = numOf(o["total_dirs"]);
+      const truncated = o["truncated"] === true;
+      const parts = [];
+      if (files !== void 0) parts.push(`${files} file${files === 1 ? "" : "s"}`);
+      if (dirs !== void 0) parts.push(`${dirs} dir${dirs === 1 ? "" : "s"}`);
+      if (truncated) parts.push("truncated");
+      return parts.length > 0 ? [parts.join(" \xB7 ")] : [];
+    }
+  }
+  if (toolName === "json") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const err = stringOf(o["error"]);
+      if (err) return [truncMid(err, OUT_BUDGET)];
+      const type = stringOf(o["type"]);
+      const keys = Array.isArray(o["keys"]) ? o["keys"] : void 0;
+      const parts = [];
+      if (type) parts.push(type);
+      if (keys) parts.push(`${keys.length} key${keys.length === 1 ? "" : "s"}`);
+      return parts.length > 0 ? [parts.join(" \xB7 ")] : [];
+    }
+  }
+  if (toolName === "install") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const exit = numOf(o["exit_code"]) ?? numOf(o["exitCode"]);
+      const added = numOf(o["added"]);
+      const removed = numOf(o["removed"]);
+      const head = [];
+      if (exit !== void 0) head.push(`exit ${exit}`);
+      if (added !== void 0) head.push(`+${added}`);
+      if (removed !== void 0) head.push(`-${removed}`);
+      const stdout = stringOf(o["stdout"]) ?? stringOf(o["output"]) ?? "";
+      const lines = [];
+      if (head.length > 0) lines.push(head.join(" \xB7 "));
+      const preview = firstNonEmpty(stdout);
+      if (preview) lines.push(`"${truncMid(preview, 70)}"`);
+      if (lines.length > 0) return lines;
+    }
+  }
+  if (toolName === "scaffold") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const created = Array.isArray(o["created"]) ? o["created"] : void 0;
+      const skipped = Array.isArray(o["skipped"]) ? o["skipped"] : void 0;
+      const parts = [];
+      if (created !== void 0) parts.push(`${created.length} created`);
+      if (skipped !== void 0 && skipped.length > 0) parts.push(`${skipped.length} skipped`);
+      if (parts.length > 0) return [parts.join(" \xB7 ")];
+    }
+  }
+  if (toolName === "remember" || toolName === "forget" || toolName === "memory") {
+    return ok ? [toolName === "forget" ? "removed" : "saved"] : [text.split("\n")[0] ?? ""];
+  }
+  if (toolName === "mode") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const mode = stringOf(o["mode"]) ?? stringOf(o["active"]) ?? stringOf(o["name"]);
+      if (mode) return [`mode: ${mode}`];
+    }
+  }
+  if (toolName === "search") {
+    if (json && typeof json === "object") {
+      const o = json;
+      const matches = Array.isArray(o["matches"]) ? o["matches"] : Array.isArray(o["results"]) ? o["results"] : void 0;
+      const count = numOf(o["count"]) ?? matches?.length;
+      if (count !== void 0) {
+        if (count === 0) return ["no results"];
+        const lines = [`${count} result${count === 1 ? "" : "s"}`];
+        const firstHit = matches && matches.length > 0 ? formatMatchHit(matches[0]) : void 0;
+        if (firstHit) lines.push(firstHit);
+        return lines;
+      }
+    }
+  }
+  if (toolName === "logs") {
+    const lines = text.split("\n").filter((l) => l.trim());
+    if (lines.length === 0) return [];
+    const head = `${lines.length} line${lines.length === 1 ? "" : "s"}`;
+    const lastLine = lines[lines.length - 1];
+    return lastLine ? [head, `"${truncMid(lastLine.trim(), 70)}"`] : [head];
+  }
+  const firstLine = text.split("\n").find((l) => l.trim()) ?? text;
+  return [truncMid(firstLine.replace(/\s+/g, " "), OUT_BUDGET)];
+}
+function firstNonEmpty(text) {
+  if (!text) return void 0;
+  const line = text.split("\n").find((l) => l.trim());
+  return line ? line.replace(/\s+/g, " ").trim() : void 0;
+}
+function formatMatchHit(hit) {
+  if (typeof hit === "string") return truncMid(hit, 70);
+  if (hit && typeof hit === "object") {
+    const o = hit;
+    const file = stringOf(o["file"]) ?? stringOf(o["path"]);
+    const line = numOf(o["line"]) ?? numOf(o["lineNumber"]);
+    const snippet = stringOf(o["text"]) ?? stringOf(o["match"]) ?? stringOf(o["preview"]);
+    if (file) {
+      const head = line !== void 0 ? `${shortenPath(file, 40)}:${line}` : shortenPath(file, 50);
+      return snippet ? `${head}  ${truncMid(snippet.replace(/\s+/g, " "), 40)}` : head;
+    }
+    if (snippet) return truncMid(snippet, 70);
+  }
+  return void 0;
+}
+var DIFF_MAX_LINES = 8;
+function extractDiffPreview(toolName, output) {
+  if (!output) return void 0;
+  const text = output.trim();
+  if (!text) return void 0;
+  let diff;
+  if (toolName === "edit" || toolName === "diff") {
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+      diff = stringOf(parsed["diff"]);
+    }
+  } else if (toolName === "patch") {
+    const parsed = tryParseJson(text);
+    if (parsed && typeof parsed === "object") {
+      diff = stringOf(parsed["diff"]) ?? stringOf(parsed["stdout"]);
+    } else if (text.includes("@@") || text.startsWith("---")) {
+      diff = text;
+    }
+  }
+  if (!diff || !diff.trim() || diff.startsWith("(no-op")) return void 0;
+  return parseUnifiedDiff(diff, DIFF_MAX_LINES);
+}
+function parseUnifiedDiff(diff, maxLines) {
+  const all = [];
+  for (const raw of diff.split("\n")) {
+    const line = raw.replace(/\r$/, "");
+    if (line.startsWith("+++") || line.startsWith("---")) continue;
+    if (line.startsWith("diff --git") || line.startsWith("index ")) continue;
+    if (line.startsWith("@@")) {
+      all.push({ kind: "hunk", text: truncMid(line, 60) });
+      continue;
+    }
+    if (line.startsWith("+")) {
+      all.push({ kind: "add", text: truncMid(line, 100) });
+      continue;
+    }
+    if (line.startsWith("-")) {
+      all.push({ kind: "del", text: truncMid(line, 100) });
+      continue;
+    }
+    if (line.startsWith("\\ No newline")) {
+      all.push({ kind: "meta", text: line });
+      continue;
+    }
+    if (line.length === 0) continue;
+    all.push({ kind: "ctx", text: truncMid(line, 100) });
+  }
+  if (all.length === 0) return { rows: [], hidden: 0 };
+  if (all.length <= maxLines) return { rows: all, hidden: 0 };
+  return { rows: all.slice(0, maxLines), hidden: all.length - maxLines };
+}
+function stringOf(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function numOf(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function tryParseJson(s) {
+  const t = s.trimStart();
+  if (!t.startsWith("{") && !t.startsWith("[")) return void 0;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return void 0;
+  }
+}
+function scanNumberedRange(text) {
+  let first;
+  let last;
+  let count = 0;
+  for (const line of text.split("\n")) {
+    const m = line.match(/^\s*(\d+)→/);
+    if (m && m[1]) {
+      const n = Number.parseInt(m[1], 10);
+      if (Number.isFinite(n)) {
+        if (first === void 0) first = n;
+        last = n;
+        count++;
+      }
+    }
+  }
+  return { first, last, count };
+}
+function countLines(text) {
+  if (!text) return 0;
+  return text.replace(/\n$/, "").split("\n").length;
+}
+function fmtBytes(n) {
+  if (n < 1024) return `${n}B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)}KB`;
+  return `${(n / (1024 * 1024)).toFixed(1)}MB`;
+}
+function truncMid(s, max) {
+  if (s.length <= max) return s;
+  return `${s.slice(0, max - 1)}\u2026`;
+}
+function Input({
+  prompt = "\u203A ",
+  value,
+  cursor,
+  placeholders,
+  disabled,
+  hint,
+  onKey
+}) {
+  useInput((input, key) => {
+    if (disabled) return;
+    onKey(input, key);
+  });
+  const before = value.slice(0, cursor);
+  const at = value.slice(cursor, cursor + 1) || " ";
+  const after = value.slice(cursor + 1);
+  const borderColor = disabled ? "red" : value.length > 0 ? "cyan" : "gray";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    placeholders.map((p, i) => /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "  \u21B3 ",
+      p
+    ] }, i)),
+    /* @__PURE__ */ jsx(
+      Box,
+      {
+        borderStyle: "round",
+        borderColor,
+        paddingX: 1,
+        width: "100%",
+        children: /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", children: prompt }),
+          before,
+          /* @__PURE__ */ jsx(Text, { inverse: true, children: at }),
+          after
+        ] })
+      }
+    ),
+    hint ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: hint }) : null
+  ] });
+}
+function StatusBar({
+  model,
+  state,
+  tokenCounter,
+  hint,
+  queueCount = 0,
+  yolo = false,
+  elapsedMs,
+  todos,
+  git,
+  subagentCount = 0,
+  context
+}) {
+  const usage = tokenCounter?.total();
+  const cost = tokenCounter?.estimateCost();
+  const cache2 = tokenCounter?.cacheStats();
+  const stateColor = state === "idle" ? "cyan" : state === "aborting" ? "yellow" : "green";
+  const stateLabel = state === "idle" ? "idle" : state === "aborting" ? "aborting\u2026" : "thinking\u2026";
+  const hasSecondLine = yolo || elapsedMs !== void 0 || todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) || git !== null && git !== void 0 || subagentCount > 0;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      borderStyle: "single",
+      borderTop: true,
+      borderBottom: false,
+      borderLeft: false,
+      borderRight: false,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 2, children: [
+          /* @__PURE__ */ jsxs(Text, { color: stateColor, children: [
+            "\u25CF ",
+            stateLabel
+          ] }),
+          /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+          /* @__PURE__ */ jsx(Text, { color: "magenta", children: model }),
+          context && context.max > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsx(ContextChip, { ctx: context })
+          ] }) : null,
+          usage ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              "\u2191 ",
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: fmtTok(usage.input) }),
+              " \u2193",
+              " ",
+              /* @__PURE__ */ jsx(Text, { color: "cyan", children: fmtTok(usage.output) })
+            ] })
+          ] }) : null,
+          cache2 && cache2.hitRatio > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              "cache ",
+              (cache2.hitRatio * 100).toFixed(0),
+              "%"
+            ] })
+          ] }) : null,
+          cost && cost.total > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+              "$",
+              cost.total.toFixed(4)
+            ] })
+          ] }) : null,
+          queueCount > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+              "\u231B queued: ",
+              queueCount
+            ] })
+          ] }) : null,
+          hint ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: hint })
+          ] }) : null
+        ] }),
+        hasSecondLine ? /* @__PURE__ */ jsxs(Box, { flexDirection: "row", gap: 2, children: [
+          yolo ? /* @__PURE__ */ jsx(Text, { color: "red", bold: true, children: "\u26A0 YOLO" }) : null,
+          elapsedMs !== void 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            yolo ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
+            /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+              "\u23F1 ",
+              fmtElapsed(elapsedMs)
+            ] })
+          ] }) : null,
+          git ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            yolo || elapsedMs !== void 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }) : null,
+            /* @__PURE__ */ jsxs(Text, { children: [
+              /* @__PURE__ */ jsxs(Text, { color: "magenta", children: [
+                "\u2387 ",
+                git.branch
+              ] }),
+              git.added > 0 ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+                " +",
+                git.added
+              ] }) : null,
+              git.deleted > 0 ? /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+                " -",
+                git.deleted
+              ] }) : null,
+              git.untracked > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                " ?",
+                git.untracked
+              ] }) : null
+            ] })
+          ] }) : null,
+          todos && (todos.pending > 0 || todos.inProgress > 0 || todos.completed > 0) ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsxs(Text, { children: [
+              todos.inProgress > 0 ? /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+                "\u231B ",
+                todos.inProgress
+              ] }) : null,
+              todos.inProgress > 0 && (todos.pending > 0 || todos.completed > 0) ? " " : "",
+              todos.pending > 0 ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+                "\u2610 ",
+                todos.pending
+              ] }) : null,
+              todos.pending > 0 && todos.completed > 0 ? " " : "",
+              todos.completed > 0 ? /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+                "\u2713 ",
+                todos.completed
+              ] }) : null
+            ] })
+          ] }) : null,
+          subagentCount > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2502" }),
+            /* @__PURE__ */ jsxs(Text, { color: "blue", children: [
+              "\u{1F310} ",
+              subagentCount,
+              " agent",
+              subagentCount === 1 ? "" : "s"
+            ] })
+          ] }) : null
+        ] }) : null
+      ]
+    }
+  );
+}
+function ContextChip({ ctx }) {
+  const ratio = Math.max(0, Math.min(1, ctx.used / ctx.max));
+  const pct = Math.round(ratio * 100);
+  const color = ratio >= 0.85 ? "red" : ratio >= 0.65 ? "yellow" : "cyan";
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "ctx " }),
+    /* @__PURE__ */ jsx(Text, { color, children: renderProgress(ratio, 10) }),
+    /* @__PURE__ */ jsxs(Text, { color, children: [
+      " ",
+      pct,
+      "%"
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      " ",
+      "(",
+      fmtTok(ctx.used),
+      "/",
+      fmtTok(ctx.max),
+      ")"
+    ] })
+  ] });
+}
+var FILLED = "\u2588";
+var EMPTY = "\u2591";
+function renderProgress(ratio, width) {
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const filled = clamped === 0 ? 0 : Math.max(1, Math.round(clamped * width));
+  const capped = Math.min(width, filled);
+  return FILLED.repeat(capped) + EMPTY.repeat(width - capped);
+}
+function fmtTok(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+function fmtElapsed(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  if (h > 0) {
+    return `${h}:${pad2(m)}:${pad2(s)}`;
+  }
+  return `${pad2(m)}:${pad2(s)}`;
+}
+function pad2(n) {
+  return n < 10 ? `0${n}` : String(n);
+}
+function FilePicker({ query, matches, selected }) {
+  if (matches.length === 0) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "@",
+      query,
+      " \u2014 no matches"
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      "@",
+      query || "\u2026",
+      " \u2014 \u2191/\u2193 select, Enter attach, Esc cancel"
+    ] }),
+    matches.map((m, i) => /* @__PURE__ */ jsxs(Text, { color: i === selected ? "cyan" : void 0, inverse: i === selected, children: [
+      i === selected ? "\u203A " : "  ",
+      highlight(m)
+    ] }, m))
+  ] });
+}
+function highlight(path4, query) {
+  return path4;
+}
+function SlashMenu({ query, matches, selected }) {
+  const placeholder = query ? `/${query}` : "/";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+      placeholder || "/",
+      " \u2014 \u2191/\u2193 select, Enter dispatch, Tab autocomplete, Esc close"
+    ] }),
+    matches.map((m, i) => /* @__PURE__ */ jsxs(Text, { color: i === selected ? "cyan" : void 0, inverse: i === selected, children: [
+      i === selected ? "\u203A " : "  ",
+      /* @__PURE__ */ jsx(Text, { bold: true, children: m.name }),
+      m.argsHint ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " ",
+        m.argsHint
+      ] }) : null,
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        " \u2014 ",
+        m.description
+      ] })
+    ] }, m.name)),
+    matches.length === 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "No matching commands" })
+  ] });
+}
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".idea",
+  ".vscode"
+]);
+var MAX_FILES_INDEXED = 5e3;
+var MAX_DEPTH = 8;
+var cache = null;
+var CACHE_TTL_MS = 3e4;
+async function loadIndex(root) {
+  const now = Date.now();
+  if (cache && cache.root === root && now - cache.loadedAt < CACHE_TTL_MS) {
+    return cache.files;
+  }
+  const files = [];
+  await walk(root, "", 0, files);
+  files.sort();
+  cache = { root, files, loadedAt: now };
+  return files;
+}
+async function walk(root, rel, depth, out) {
+  if (out.length >= MAX_FILES_INDEXED) return;
+  if (depth > MAX_DEPTH) return;
+  const dir = rel ? path2.join(root, rel) : root;
+  let entries;
+  try {
+    entries = await fs2.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    if (out.length >= MAX_FILES_INDEXED) return;
+    if (e.name.startsWith(".") && e.name !== ".env.example") continue;
+    if (IGNORED_DIRS.has(e.name)) continue;
+    const next = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      await walk(root, next, depth + 1, out);
+    } else if (e.isFile()) {
+      out.push(next);
+    }
+  }
+}
+function score(s, query) {
+  if (!query) return s.length;
+  const ql = query.toLowerCase();
+  const sl = s.toLowerCase();
+  let si = 0;
+  let firstHit = -1;
+  let lastHit = -1;
+  for (let qi = 0; qi < ql.length; qi++) {
+    const c = ql.charCodeAt(qi);
+    while (si < sl.length && sl.charCodeAt(si) !== c) si++;
+    if (si >= sl.length) return null;
+    if (firstHit < 0) firstHit = si;
+    lastHit = si;
+    si++;
+  }
+  const span = lastHit - firstHit;
+  return span * 100 + firstHit * 2 + s.length;
+}
+async function searchFiles(root, query, limit = 8) {
+  const all = await loadIndex(root);
+  if (!query) return all.slice(0, limit);
+  const scored = [];
+  for (const f of all) {
+    const sc = score(f, query);
+    if (sc !== null) scored.push({ path: f, score: sc });
+  }
+  scored.sort((a, b) => a.score - b.score);
+  return scored.slice(0, limit).map((x) => x.path);
+}
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+async function readClipboardImage() {
+  const platform = process.platform;
+  if (platform === "win32") return readWindows();
+  if (platform === "darwin") return readDarwin();
+  if (platform === "linux") return readLinux();
+  return null;
+}
+async function readWindows() {
+  const tmp = path2.join(os.tmpdir(), `wstack-clip-${Date.now()}.png`);
+  const ps = [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "Add-Type -AssemblyName System.Drawing",
+    "$img = [System.Windows.Forms.Clipboard]::GetImage()",
+    'if ($img -eq $null) { Write-Output "NO_IMAGE"; exit 0 }',
+    `$img.Save('${tmp.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png)`,
+    'Write-Output "OK"'
+  ].join("; ");
+  const out = await runCmd("powershell", ["-NoProfile", "-Command", ps]);
+  if (!out || out.trim() === "NO_IMAGE") return null;
+  if (!out.includes("OK")) return null;
+  return readPngFile(tmp);
+}
+async function readDarwin() {
+  const tmp = path2.join(os.tmpdir(), `wstack-clip-${Date.now()}.png`);
+  const script = [
+    "try",
+    `  set the_file to (open for access POSIX file "${tmp}" with write permission)`,
+    "  write (the clipboard as \xABclass PNGf\xBB) to the_file",
+    "  close access the_file",
+    "on error",
+    "  try",
+    '    close access POSIX file "' + tmp + '"',
+    "  end try",
+    '  return "NO_IMAGE"',
+    "end try",
+    'return "OK"'
+  ].join("\n");
+  const out = await runCmd("osascript", ["-e", script]);
+  if (!out || out.trim() !== "OK") return null;
+  return readPngFile(tmp);
+}
+async function readLinux() {
+  const tmp = path2.join(os.tmpdir(), `wstack-clip-${Date.now()}.png`);
+  const tries = [
+    ["wl-paste", ["--type", "image/png"]],
+    ["xclip", ["-selection", "clipboard", "-t", "image/png", "-o"]]
+  ];
+  for (const [cmd, args] of tries) {
+    const ok = await runCmdToFile(cmd, args, tmp).catch(() => false);
+    if (ok) return readPngFile(tmp);
+  }
+  return null;
+}
+async function readPngFile(p) {
+  try {
+    const buf = await fs2.readFile(p);
+    if (buf.length === 0) {
+      await fs2.unlink(p).catch(() => void 0);
+      return null;
+    }
+    if (buf.length > MAX_IMAGE_BYTES) {
+      await fs2.unlink(p).catch(() => void 0);
+      throw new Error(`Clipboard image exceeds ${MAX_IMAGE_BYTES / 1024 / 1024}MB limit`);
+    }
+    if (buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71) {
+      await fs2.unlink(p).catch(() => void 0);
+      return null;
+    }
+    await fs2.unlink(p).catch(() => void 0);
+    return { base64: buf.toString("base64"), mediaType: "image/png", bytes: buf.length };
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+function runCmd(cmd, args) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    child.stdout.on("data", (c) => out += String(c));
+    child.on("error", () => resolve(null));
+    child.on("exit", (code) => resolve(code === 0 ? out : null));
+  });
+}
+function runCmdToFile(cmd, args, outPath) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const chunks = [];
+    child.stdout.on("data", (c) => chunks.push(c));
+    child.on("error", () => resolve(false));
+    child.on("exit", async (code) => {
+      if (code !== 0 || chunks.length === 0) return resolve(false);
+      try {
+        await fs2.writeFile(outPath, Buffer.concat(chunks));
+        resolve(true);
+      } catch {
+        resolve(false);
+      }
+    });
+  });
+}
+
+// src/queue-slash.ts
+var USAGE = "Usage:\n  /queue              \u2014 list pending messages\n  /queue list         \u2014 same as /queue\n  /queue clear        \u2014 drop all pending messages\n  /queue delete N M\u2026  \u2014 drop messages at 1-based positions";
+function createQueueSlashCommand(deps) {
+  return {
+    name: "queue",
+    description: "List, clear, or delete pending messages typed while the agent was running.",
+    async run(args) {
+      const out = handleQueueCommand(args, deps);
+      return { message: out };
+    }
+  };
+}
+function handleQueueCommand(args, deps) {
+  const trimmed = args.trim();
+  const [sub, ...rest] = trimmed.split(/\s+/);
+  const subcommand = sub?.toLowerCase() ?? "";
+  if (subcommand === "" || subcommand === "list") {
+    return renderList(deps.getQueue());
+  }
+  if (subcommand === "clear") {
+    const before = deps.getQueue().length;
+    if (before === 0) return "Queue is already empty.";
+    deps.clear();
+    return `Cleared ${before} queued message${before === 1 ? "" : "s"}.`;
+  }
+  if (subcommand === "delete" || subcommand === "del" || subcommand === "rm") {
+    if (rest.length === 0) return "Usage: /queue delete <position> [<position>\u2026]";
+    const queue = deps.getQueue();
+    if (queue.length === 0) return "Queue is empty \u2014 nothing to delete.";
+    const parsed = [];
+    const invalid = [];
+    const outOfRange = [];
+    for (const tok of rest) {
+      if (!/^\d+$/.test(tok)) {
+        invalid.push(tok);
+        continue;
+      }
+      const n = Number.parseInt(tok, 10);
+      if (n < 1 || n > queue.length) {
+        outOfRange.push(n);
+        continue;
+      }
+      parsed.push(n);
+    }
+    const uniqueValid = [...new Set(parsed)];
+    if (uniqueValid.length === 0) {
+      const parts2 = ["No valid positions to delete."];
+      if (invalid.length > 0) parts2.push(`Invalid: ${invalid.join(", ")}.`);
+      if (outOfRange.length > 0) parts2.push(`Out of range (queue has ${queue.length}): ${outOfRange.join(", ")}.`);
+      return parts2.join(" ");
+    }
+    deps.deleteAt(uniqueValid);
+    const parts = [
+      `Deleted ${uniqueValid.length} of ${queue.length} (positions ${uniqueValid.sort((a, b) => a - b).join(", ")}).`
+    ];
+    if (invalid.length > 0) parts.push(`Ignored invalid: ${invalid.join(", ")}.`);
+    if (outOfRange.length > 0) parts.push(`Ignored out of range: ${outOfRange.join(", ")}.`);
+    return parts.join(" ");
+  }
+  return `Unknown subcommand "${sub}".
+${USAGE}`;
+}
+function renderList(queue) {
+  if (queue.length === 0) return "Queue is empty.";
+  const lines = [`Queue (${queue.length}):`];
+  for (let i = 0; i < queue.length; i++) {
+    const item = queue[i];
+    if (!item) continue;
+    const preview = oneLine(item.displayText, 100);
+    lines.push(`  ${i + 1}. ${preview}`);
+  }
+  return lines.join("\n");
+}
+function oneLine(s, max) {
+  const collapsed = s.replace(/\s+/g, " ").trim();
+  return collapsed.length <= max ? collapsed : `${collapsed.slice(0, max - 1)}\u2026`;
+}
+async function readGitInfo(cwd) {
+  const [branchRes, numstatRes, statusRes] = await Promise.all([
+    runGit(cwd, ["branch", "--show-current"]),
+    runGit(cwd, ["diff", "HEAD", "--numstat"]),
+    runGit(cwd, ["status", "--porcelain"])
+  ]);
+  if (!branchRes.ok || !numstatRes.ok || !statusRes.ok) return null;
+  const branch = branchRes.stdout.trim();
+  const branchLabel = branch || await detachedShortSha(cwd) || "detached";
+  let added = 0;
+  let deleted = 0;
+  for (const line of numstatRes.stdout.split("\n")) {
+    if (!line) continue;
+    const [a, d] = line.split("	");
+    if (a && a !== "-") added += Number.parseInt(a, 10) || 0;
+    if (d && d !== "-") deleted += Number.parseInt(d, 10) || 0;
+  }
+  let untracked = 0;
+  for (const line of statusRes.stdout.split("\n")) {
+    if (line.startsWith("?? ")) untracked++;
+  }
+  return { branch: branchLabel, added, deleted, untracked };
+}
+async function detachedShortSha(cwd) {
+  const res = await runGit(cwd, ["rev-parse", "--short", "HEAD"]);
+  return res.ok ? res.stdout.trim() : null;
+}
+function runGit(cwd, args) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    try {
+      const child = spawn("git", args, {
+        cwd,
+        // Inherit stderr (silent) — we don't care about git's noise.
+        stdio: ["ignore", "pipe", "ignore"],
+        // Don't let a slow git hang the TUI.
+        timeout: 3e3,
+        windowsHide: true
+      });
+      child.stdout.setEncoding("utf8");
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk;
+      });
+      child.on("error", () => resolve({ ok: false, stdout: "" }));
+      child.on("close", (code) => {
+        resolve({ ok: code === 0, stdout });
+      });
+    } catch {
+      resolve({ ok: false, stdout: "" });
+    }
+  });
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "addEntry": {
+      const appended = [
+        ...state.entries,
+        { ...action.entry, id: state.nextId }
+      ];
+      return { ...state, entries: appended, nextId: state.nextId + 1 };
+    }
+    case "setBuffer":
+      return { ...state, buffer: action.buffer, cursor: action.cursor };
+    case "addPlaceholder":
+      return { ...state, placeholders: [...state.placeholders, action.ph] };
+    case "clearInput":
+      return {
+        ...state,
+        buffer: "",
+        cursor: 0,
+        placeholders: [],
+        picker: { open: false, query: "", matches: [], selected: 0 },
+        slashPicker: { open: false, query: "", matches: [], selected: 0 }
+      };
+    case "streamDelta":
+      return { ...state, streamingText: state.streamingText + action.delta };
+    case "streamReset":
+      return { ...state, streamingText: "" };
+    case "status":
+      return { ...state, status: action.status };
+    case "interrupt":
+      return { ...state, interrupts: state.interrupts + 1 };
+    case "resetInterrupts":
+      return { ...state, interrupts: 0 };
+    case "hint":
+      return { ...state, hint: action.text };
+    case "pickerOpen":
+      return {
+        ...state,
+        picker: { open: true, query: action.query, matches: state.picker.matches, selected: 0 }
+      };
+    case "pickerClose":
+      return {
+        ...state,
+        picker: { open: false, query: "", matches: [], selected: 0 }
+      };
+    case "pickerSetMatches":
+      if (!state.picker.open || state.picker.query !== action.query) return state;
+      return {
+        ...state,
+        picker: {
+          ...state.picker,
+          matches: action.matches,
+          selected: Math.min(state.picker.selected, Math.max(0, action.matches.length - 1))
+        }
+      };
+    case "pickerMove": {
+      const n = state.picker.matches.length;
+      if (n === 0) return state;
+      const next = (state.picker.selected + action.delta + n) % n;
+      return { ...state, picker: { ...state.picker, selected: next } };
+    }
+    case "toolStarted": {
+      const next = new Map(state.runningTools);
+      next.set(action.id, { name: action.name, startedAt: Date.now() });
+      return { ...state, runningTools: next };
+    }
+    case "toolEnded": {
+      const next = new Map(state.runningTools);
+      if (action.id !== void 0 && next.has(action.id)) {
+        next.delete(action.id);
+        return { ...state, runningTools: next };
+      }
+      if (action.name !== void 0) {
+        for (const [id, info] of next) {
+          if (info.name === action.name) {
+            next.delete(id);
+            return { ...state, runningTools: next };
+          }
+        }
+      }
+      return state;
+    }
+    case "enqueue": {
+      const item = { ...action.item, id: state.nextQueueId };
+      return {
+        ...state,
+        queue: [...state.queue, item],
+        nextQueueId: state.nextQueueId + 1
+      };
+    }
+    case "dequeueFirst": {
+      if (state.queue.length === 0) return state;
+      return { ...state, queue: state.queue.slice(1) };
+    }
+    case "queueClear": {
+      if (state.queue.length === 0) return state;
+      return { ...state, queue: [] };
+    }
+    case "queueDelete": {
+      if (state.queue.length === 0 || action.positions.length === 0) return state;
+      const drop = new Set(action.positions.map((p) => p - 1).filter((i) => i >= 0));
+      const filtered = state.queue.filter((_, i) => !drop.has(i));
+      if (filtered.length === state.queue.length) return state;
+      return { ...state, queue: filtered };
+    }
+    case "slashPickerOpen":
+      return {
+        ...state,
+        slashPicker: { open: true, query: action.query, matches: action.matches, selected: 0 }
+      };
+    case "slashPickerClose":
+      return {
+        ...state,
+        slashPicker: { open: false, query: "", matches: [], selected: 0 }
+      };
+    case "slashPickerMove": {
+      const n = state.slashPicker.matches.length;
+      if (n === 0) return state;
+      const next = (state.slashPicker.selected + action.delta + n) % n;
+      return { ...state, slashPicker: { ...state.slashPicker, selected: next } };
+    }
+    case "historyPush": {
+      if (action.text === "" || action.text === state.inputHistory[0]) return state;
+      return { ...state, inputHistory: [action.text, ...state.inputHistory].slice(0, 100) };
+    }
+    case "historyUp": {
+      if (state.inputHistory.length === 0) return state;
+      const next = Math.min(state.historyIndex + 1, state.inputHistory.length);
+      const entry = state.inputHistory[next - 1] ?? "";
+      return { ...state, historyIndex: next, buffer: entry, cursor: entry.length };
+    }
+    case "historyDown": {
+      if (state.historyIndex === 0) return state;
+      const next = state.historyIndex - 1;
+      const entry = next === 0 ? "" : state.inputHistory[next - 1] ?? "";
+      return { ...state, historyIndex: next, buffer: entry, cursor: entry.length };
+    }
+  }
+}
+var PASTE_THRESHOLD_CHARS = 200;
+function App({
+  agent,
+  slashRegistry,
+  attachments,
+  events,
+  tokenCounter,
+  model,
+  banner = true,
+  queueStore,
+  yolo = false,
+  appVersion,
+  provider,
+  effectiveMaxContext,
+  onExit
+}) {
+  const { exit } = useApp();
+  const [state, dispatch] = useReducer(reducer, {
+    entries: banner ? [
+      {
+        id: 0,
+        kind: "banner",
+        version: appVersion ?? "dev",
+        provider: provider ?? "agent",
+        model,
+        cwd: agent.ctx.cwd
+      }
+    ] : [],
+    buffer: "",
+    cursor: 0,
+    placeholders: [],
+    streamingText: "",
+    status: "idle",
+    interrupts: 0,
+    hint: "",
+    nextId: 1,
+    picker: { open: false, query: "", matches: [], selected: 0 },
+    slashPicker: { open: false, query: "", matches: [], selected: 0 },
+    runningTools: /* @__PURE__ */ new Map(),
+    queue: [],
+    nextQueueId: 1,
+    inputHistory: [],
+    historyIndex: 0
+  });
+  const builderRef = useRef(null);
+  if (builderRef.current === null) {
+    builderRef.current = new InputBuilder({ store: attachments });
+  }
+  const activeCtrlRef = useRef(null);
+  const projectRoot = agent.ctx.projectRoot;
+  const streamingTextRef = useRef("");
+  const pendingDeltaRef = useRef("");
+  const flushTimerRef = useRef(null);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const startedAtRef = useRef(Date.now());
+  const [nowTick, setNowTick] = React.useState(Date.now());
+  useEffect(() => {
+    const t = setInterval(() => setNowTick(Date.now()), 1e3);
+    return () => clearInterval(t);
+  }, []);
+  const elapsedMs = nowTick - startedAtRef.current;
+  const [gitInfo, setGitInfo] = React.useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    const refresh = () => {
+      readGitInfo(agent.ctx.cwd).then((info) => {
+        if (!cancelled) setGitInfo(info);
+      }).catch(() => void 0);
+    };
+    refresh();
+    const t = setInterval(refresh, 5e3);
+    return () => {
+      cancelled = true;
+      clearInterval(t);
+    };
+  }, [agent.ctx.cwd]);
+  const [lastInputTokens, setLastInputTokens] = React.useState(0);
+  useEffect(() => {
+    const off = events.on("provider.response", (e) => {
+      setLastInputTokens(e.usage.input);
+    });
+    return () => {
+      off();
+    };
+  }, [events]);
+  const maxContext = effectiveMaxContext ?? agent.ctx.provider.capabilities.maxContext;
+  const contextWindow = useMemo(
+    () => lastInputTokens > 0 && maxContext > 0 ? { used: lastInputTokens, max: maxContext } : void 0,
+    [lastInputTokens, maxContext]
+  );
+  const todos = useMemo(() => {
+    const counts = { pending: 0, inProgress: 0, completed: 0 };
+    for (const t of agent.ctx.todos) {
+      if (t.status === "pending") counts.pending++;
+      else if (t.status === "in_progress") counts.inProgress++;
+      else if (t.status === "completed") counts.completed++;
+    }
+    return counts;
+  }, [nowTick, agent.ctx.todos]);
+  useEffect(() => {
+    const detected = detectAtToken(state.buffer, state.cursor);
+    if (!detected) {
+      if (state.picker.open) dispatch({ type: "pickerClose" });
+      return;
+    }
+    if (!state.picker.open || state.picker.query !== detected.query) {
+      dispatch({ type: "pickerOpen", query: detected.query });
+    }
+    let cancelled = false;
+    searchFiles(projectRoot, detected.query, 8).then((matches) => {
+      if (!cancelled) {
+        dispatch({ type: "pickerSetMatches", query: detected.query, matches });
+      }
+    }).catch(() => void 0);
+    return () => {
+      cancelled = true;
+    };
+  }, [state.buffer, state.cursor, projectRoot]);
+  useEffect(() => {
+    const trimmed = state.buffer.trimStart();
+    if (!trimmed.startsWith("/")) {
+      if (state.slashPicker.open) dispatch({ type: "slashPickerClose" });
+      return;
+    }
+    const query = (trimmed.slice(1).split(/\s/)[0] ?? "").toLowerCase();
+    const allCommands = slashRegistry.listWithOwner();
+    const matches = allCommands.filter(({ cmd }) => {
+      const name = cmd.name.toLowerCase();
+      const aliases = cmd.aliases ?? [];
+      return name.includes(query) || aliases.some((a) => a.toLowerCase().includes(query));
+    }).slice(0, 12).map(({ cmd, owner }) => ({
+      name: cmd.name,
+      description: cmd.description,
+      argsHint: void 0,
+      isBuiltin: owner === "core"
+    }));
+    if (!state.slashPicker.open) {
+      dispatch({ type: "slashPickerOpen", query, matches });
+    } else if (state.slashPicker.query !== query) {
+      dispatch({ type: "slashPickerOpen", query, matches });
+    }
+  }, [state.buffer, slashRegistry]);
+  const pasteClipboardImage = async () => {
+    const builder = builderRef.current;
+    if (!builder) return;
+    try {
+      const img = await readClipboardImage();
+      if (!img) {
+        dispatch({
+          type: "addEntry",
+          entry: { kind: "info", text: "No image on the clipboard." }
+        });
+        return;
+      }
+      const placeholder = await builder.appendImage(img.base64, img.mediaType);
+      const kb = (img.bytes / 1024).toFixed(0);
+      dispatch({ type: "addPlaceholder", ph: `${placeholder} (PNG ${kb}KB)` });
+    } catch (err) {
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "error",
+          text: `Clipboard image error: ${err instanceof Error ? err.message : String(err)}`
+        }
+      });
+    }
+  };
+  const acceptPickerSelection = async () => {
+    const { open, matches, selected } = state.picker;
+    if (!open || matches.length === 0) return;
+    const picked = matches[selected];
+    if (!picked) return;
+    const builder = builderRef.current;
+    if (!builder) return;
+    const tok = detectAtToken(state.buffer, state.cursor);
+    if (!tok) {
+      dispatch({ type: "pickerClose" });
+      return;
+    }
+    const absPath = path2.isAbsolute(picked) ? picked : path2.join(projectRoot, picked);
+    try {
+      const data = await fs2.readFile(absPath, "utf8");
+      const placeholder = await builder.appendFile({
+        kind: "file",
+        data,
+        meta: { filename: picked, label: picked }
+      });
+      const before = state.buffer.slice(0, tok.start);
+      const after = state.buffer.slice(tok.end);
+      const next = `${before}${placeholder}${after}`;
+      dispatch({
+        type: "setBuffer",
+        buffer: next,
+        cursor: tok.start + placeholder.length
+      });
+      dispatch({ type: "pickerClose" });
+    } catch (err) {
+      dispatch({
+        type: "addEntry",
+        entry: { kind: "error", text: `Attach failed: ${err instanceof Error ? err.message : String(err)}` }
+      });
+      dispatch({ type: "pickerClose" });
+    }
+  };
+  const acceptSlashPickerSelection = () => {
+    const { open, matches, selected } = state.slashPicker;
+    if (!open || matches.length === 0) return;
+    const picked = matches[selected];
+    if (!picked) return;
+    const cmd = picked.argsHint !== void 0 ? `/${picked.name} ` : `/${picked.name}`;
+    dispatch({ type: "setBuffer", buffer: cmd, cursor: cmd.length });
+    dispatch({ type: "slashPickerClose" });
+  };
+  useEffect(() => {
+    if (!queueStore) return;
+    let cancelled = false;
+    queueStore.read().then((items) => {
+      if (cancelled || items.length === 0) return;
+      for (const item of items) {
+        dispatch({
+          type: "enqueue",
+          item: { displayText: item.displayText, blocks: item.blocks }
+        });
+      }
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "info",
+          text: `Restored ${items.length} queued message${items.length === 1 ? "" : "s"} from a previous run.`
+        }
+      });
+    }).catch(() => void 0);
+    return () => {
+      cancelled = true;
+    };
+  }, [queueStore]);
+  useEffect(() => {
+    if (!queueStore) return;
+    queueStore.write(state.queue.map(({ displayText, blocks }) => ({ displayText, blocks }))).catch(() => void 0);
+  }, [state.queue, queueStore]);
+  useEffect(() => {
+    const cmd = createQueueSlashCommand({
+      getQueue: () => stateRef.current.queue,
+      clear: () => dispatch({ type: "queueClear" }),
+      deleteAt: (positions) => dispatch({ type: "queueDelete", positions })
+    });
+    slashRegistry.register(cmd);
+    return () => {
+      slashRegistry.unregister("queue");
+    };
+  }, [slashRegistry]);
+  useEffect(() => {
+    const FLUSH_MS = 100;
+    const flush = () => {
+      if (pendingDeltaRef.current) {
+        dispatch({ type: "streamDelta", delta: pendingDeltaRef.current });
+        pendingDeltaRef.current = "";
+      }
+      flushTimerRef.current = null;
+    };
+    const offDelta = events.on("provider.text_delta", (e) => {
+      const text = e.text.replace(/\x1b\[200~|\x1b\[201~/g, "");
+      streamingTextRef.current += text;
+      pendingDeltaRef.current += text;
+      if (!flushTimerRef.current) flushTimerRef.current = setTimeout(flush, FLUSH_MS);
+    });
+    const offToolStart = events.on("tool.started", (e) => {
+      dispatch({ type: "toolStarted", id: e.id, name: e.name });
+    });
+    const offTool = events.on("tool.executed", (e) => {
+      dispatch({
+        type: "addEntry",
+        entry: {
+          kind: "tool",
+          name: e.name,
+          durationMs: e.durationMs,
+          ok: e.ok,
+          input: e.input,
+          output: e.output
+        }
+      });
+      dispatch({ type: "toolEnded", name: e.name });
+    });
+    const offRetry = events.on("provider.retry", (e) => {
+      const secs = (e.delayMs / 1e3).toFixed(e.delayMs >= 1e3 ? 1 : 2);
+      dispatch({
+        type: "addEntry",
+        entry: { kind: "warn", text: `\u27F3 retry ${e.attempt} in ${secs}s \u2014 ${e.description}` }
+      });
+    });
+    const offProvErr = events.on("provider.error", (e) => {
+      dispatch({
+        type: "addEntry",
+        entry: { kind: "error", text: e.description }
+      });
+    });
+    return () => {
+      offDelta();
+      offToolStart();
+      offTool();
+      offRetry();
+      offProvErr();
+      if (flushTimerRef.current) clearTimeout(flushTimerRef.current);
+    };
+  }, [events]);
+  useEffect(() => {
+    const onSigint = () => {
+      if (state.interrupts >= 1 && state.status === "idle") {
+        exit();
+        onExit(130);
+        return;
+      }
+      dispatch({ type: "interrupt" });
+      if (activeCtrlRef.current) {
+        activeCtrlRef.current.abort();
+        dispatch({ type: "status", status: "aborting" });
+        const droppedCount = stateRef.current.queue.length;
+        if (droppedCount > 0) {
+          dispatch({ type: "queueClear" });
+          dispatch({
+            type: "addEntry",
+            entry: {
+              kind: "warn",
+              text: `Iteration cancelled. Dropped ${droppedCount} queued message${droppedCount === 1 ? "" : "s"}. Press Ctrl+C again to exit.`
+            }
+          });
+        } else {
+          dispatch({
+            type: "addEntry",
+            entry: { kind: "warn", text: "Iteration cancelled. Press Ctrl+C again to exit." }
+          });
+        }
+      } else {
+        dispatch({
+          type: "addEntry",
+          entry: { kind: "warn", text: "Press Ctrl+C again to exit." }
+        });
+      }
+    };
+    process.on("SIGINT", onSigint);
+    return () => {
+      process.off("SIGINT", onSigint);
+    };
+  }, [state.interrupts, state.status, exit, onExit]);
+  const handleKey = async (input, key) => {
+    if (state.status === "aborting") return;
+    if (state.slashPicker.open) {
+      if (key.escape) {
+        dispatch({ type: "slashPickerClose" });
+        return;
+      }
+      if (key.upArrow) {
+        dispatch({ type: "slashPickerMove", delta: -1 });
+        return;
+      }
+      if (key.downArrow) {
+        dispatch({ type: "slashPickerMove", delta: 1 });
+        return;
+      }
+      if (key.return) {
+        await acceptSlashPickerSelection();
+        return;
+      }
+      if (key.tab && state.slashPicker.matches.length > 0) {
+        const sel = state.slashPicker.matches[state.slashPicker.selected];
+        if (sel) {
+          dispatch({ type: "setBuffer", buffer: `/${sel.name} `, cursor: sel.name.length + 2 });
+          dispatch({ type: "slashPickerClose" });
+        }
+        return;
+      }
+    }
+    if (state.picker.open) {
+      if (key.escape) {
+        dispatch({ type: "pickerClose" });
+        return;
+      }
+      if (key.upArrow) {
+        dispatch({ type: "pickerMove", delta: -1 });
+        return;
+      }
+      if (key.downArrow) {
+        dispatch({ type: "pickerMove", delta: 1 });
+        return;
+      }
+      if (key.return) {
+        await acceptPickerSelection();
+        return;
+      }
+    }
+    if (key.return) {
+      await submit();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      if (key.ctrl) {
+        const { cursor, buffer } = state;
+        if (key.backspace) {
+          if (cursor === 0) return;
+          const beforeCursor = buffer.slice(0, cursor);
+          const lastWordStart = beforeCursor.lastIndexOf(" ") + 1;
+          const next3 = buffer.slice(0, lastWordStart) + buffer.slice(cursor);
+          dispatch({ type: "setBuffer", buffer: next3, cursor: lastWordStart });
+        } else {
+          if (cursor >= buffer.length) return;
+          const afterCursor = buffer.slice(cursor);
+          const nextWordStart = afterCursor.indexOf(" ");
+          const end = nextWordStart === -1 ? buffer.length : cursor + nextWordStart + 1;
+          const next3 = buffer.slice(0, cursor) + buffer.slice(end);
+          dispatch({ type: "setBuffer", buffer: next3, cursor });
+        }
+        return;
+      }
+      if (state.cursor === 0) return;
+      const next2 = state.buffer.slice(0, state.cursor - 1) + state.buffer.slice(state.cursor);
+      dispatch({ type: "setBuffer", buffer: next2, cursor: state.cursor - 1 });
+      return;
+    }
+    if (key.leftArrow) {
+      if (key.ctrl) {
+        const { cursor, buffer } = state;
+        if (cursor === 0) return;
+        const beforeCursor = buffer.slice(0, cursor);
+        const prevWordStart = beforeCursor.lastIndexOf(" ");
+        const target = prevWordStart === -1 ? 0 : prevWordStart + 1;
+        dispatch({ type: "setBuffer", buffer, cursor: target });
+        return;
+      }
+      if (state.cursor > 0) dispatch({ type: "setBuffer", buffer: state.buffer, cursor: state.cursor - 1 });
+      return;
+    }
+    if (key.rightArrow) {
+      if (key.ctrl) {
+        const { cursor, buffer } = state;
+        if (cursor >= buffer.length) return;
+        const afterCursor = buffer.slice(cursor);
+        const nextWordStart = afterCursor.indexOf(" ");
+        const target = nextWordStart === -1 ? buffer.length : cursor + nextWordStart + 1;
+        dispatch({ type: "setBuffer", buffer, cursor: target });
+        return;
+      }
+      if (state.cursor < state.buffer.length) dispatch({ type: "setBuffer", buffer: state.buffer, cursor: state.cursor + 1 });
+      return;
+    }
+    if (key.upArrow) {
+      if (state.inputHistory.length > 0) dispatch({ type: "historyUp" });
+      return;
+    }
+    if (key.downArrow) {
+      if (state.historyIndex > 0) dispatch({ type: "historyDown" });
+      return;
+    }
+    if (key.ctrl && input === "a") {
+      dispatch({ type: "setBuffer", buffer: state.buffer, cursor: 0 });
+      return;
+    }
+    if (key.ctrl && input === "e") {
+      dispatch({ type: "setBuffer", buffer: state.buffer, cursor: state.buffer.length });
+      return;
+    }
+    if (key.ctrl && input === "u") {
+      dispatch({ type: "setBuffer", buffer: "", cursor: 0 });
+      return;
+    }
+    if (key.ctrl && input === "w") {
+      const { cursor, buffer } = state;
+      if (cursor === 0) return;
+      const beforeCursor = buffer.slice(0, cursor);
+      const lastWordStart = beforeCursor.lastIndexOf(" ") + 1;
+      const next2 = buffer.slice(0, lastWordStart) + buffer.slice(cursor);
+      dispatch({ type: "setBuffer", buffer: next2, cursor: lastWordStart });
+      return;
+    }
+    if (key.meta && input === "v") {
+      await pasteClipboardImage();
+      return;
+    }
+    if (!input || key.ctrl || key.meta) return;
+    let bracketedPaste = false;
+    if (input.includes("\x1B[200~") || input.includes("\x1B[201~")) {
+      input = input.replace(/\x1b\[200~/g, "").replace(/\x1b\[201~/g, "");
+      bracketedPaste = true;
+    }
+    if (bracketedPaste || input.length > PASTE_THRESHOLD_CHARS || input.includes("\n")) {
+      const builder = builderRef.current;
+      if (!builder) return;
+      const ph = await builder.appendPaste(input);
+      if (ph) {
+        const lineCount = input.split("\n").length;
+        dispatch({ type: "addPlaceholder", ph: `${ph} (${lineCount} lines)` });
+      } else {
+        const next2 = state.buffer.slice(0, state.cursor) + input + state.buffer.slice(state.cursor);
+        dispatch({ type: "setBuffer", buffer: next2, cursor: state.cursor + input.length });
+      }
+      return;
+    }
+    const next = state.buffer.slice(0, state.cursor) + input + state.buffer.slice(state.cursor);
+    dispatch({ type: "setBuffer", buffer: next, cursor: state.cursor + input.length });
+  };
+  const runBlocks = async (blocks) => {
+    const ctrl = new AbortController();
+    activeCtrlRef.current = ctrl;
+    dispatch({ type: "status", status: "running" });
+    try {
+      const startedAt = Date.now();
+      const before = tokenCounter?.total();
+      const costBefore = tokenCounter?.estimateCost().total ?? 0;
+      const result = await agent.run(blocks, { signal: ctrl.signal });
+      const streamed = streamingTextRef.current;
+      const text = result.status === "done" && result.finalText ? result.finalText : streamed;
+      if (text && text.trim()) {
+        dispatch({ type: "addEntry", entry: { kind: "assistant", text } });
+      }
+      streamingTextRef.current = "";
+      pendingDeltaRef.current = "";
+      if (flushTimerRef.current) {
+        clearTimeout(flushTimerRef.current);
+        flushTimerRef.current = null;
+      }
+      dispatch({ type: "streamReset" });
+      if (result.status === "aborted") {
+        dispatch({ type: "addEntry", entry: { kind: "warn", text: "Aborted." } });
+      } else if (result.status === "failed") {
+        dispatch({
+          type: "addEntry",
+          entry: {
+            kind: "error",
+            text: `Failed: ${result.error instanceof Error ? result.error.message : String(result.error)}`
+          }
+        });
+      } else if (result.status === "max_iterations") {
+        dispatch({
+          type: "addEntry",
+          entry: { kind: "warn", text: `Hit max iterations (${result.iterations}).` }
+        });
+      }
+      if (tokenCounter && before) {
+        const after = tokenCounter.total();
+        const costAfter = tokenCounter.estimateCost().total;
+        dispatch({
+          type: "addEntry",
+          entry: {
+            kind: "turn-summary",
+            text: `[in: ${fmtTok2(after.input - before.input)}  out: ${fmtTok2(after.output - before.output)}  iters: ${result.iterations}  cost: ${(costAfter - costBefore).toFixed(4)}  ${((Date.now() - startedAt) / 1e3).toFixed(1)}s]`
+          }
+        });
+      }
+    } catch (err) {
+      dispatch({
+        type: "addEntry",
+        entry: { kind: "error", text: err instanceof Error ? err.message : String(err) }
+      });
+    } finally {
+      activeCtrlRef.current = null;
+      dispatch({ type: "status", status: "idle" });
+    }
+    const head = stateRef.current.queue[0];
+    if (head) {
+      dispatch({ type: "dequeueFirst" });
+      await runBlocks(head.blocks);
+    }
+  };
+  const submit = async () => {
+    const raw = state.buffer;
+    const trimmed = raw.trim();
+    if (!trimmed && state.placeholders.length === 0) return;
+    dispatch({ type: "resetInterrupts" });
+    if (trimmed.startsWith("/")) {
+      dispatch({ type: "addEntry", entry: { kind: "user", text: trimmed } });
+      if (state.historyIndex > 0) dispatch({ type: "historyPush", text: trimmed });
+      dispatch({ type: "clearInput" });
+      try {
+        const res = await slashRegistry.dispatch(trimmed, agent.ctx);
+        if (res?.message) {
+          dispatch({ type: "addEntry", entry: { kind: "info", text: res.message } });
+        }
+        if (res?.exit) {
+          exit();
+          onExit(0);
+        }
+      } catch (err) {
+        dispatch({
+          type: "addEntry",
+          entry: { kind: "error", text: err instanceof Error ? err.message : String(err) }
+        });
+      }
+      return;
+    }
+    const builder = builderRef.current;
+    if (!builder) return;
+    if (trimmed) builder.appendText(trimmed);
+    const blocks = await builder.submit();
+    const displayText = trimmed || "(attachments only)";
+    dispatch({ type: "clearInput" });
+    if (state.status !== "idle") {
+      dispatch({
+        type: "addEntry",
+        entry: { kind: "user", text: displayText, queued: true }
+      });
+      dispatch({ type: "enqueue", item: { displayText, blocks } });
+      if (state.historyIndex > 0) dispatch({ type: "historyPush", text: trimmed });
+      return;
+    }
+    dispatch({ type: "addEntry", entry: { kind: "user", text: displayText } });
+    if (state.historyIndex > 0) dispatch({ type: "historyPush", text: trimmed });
+    await runBlocks(blocks);
+  };
+  const inputHint = useMemo(() => {
+    if (state.status !== "idle") return "";
+    if (state.buffer.startsWith("/")) return "slash command \u2014 Enter to dispatch";
+    if (state.picker.open) return "";
+    return "";
+  }, [state.buffer, state.status, state.picker.open]);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(History, { entries: state.entries, streamingText: state.streamingText }),
+    /* @__PURE__ */ jsx(
+      Input,
+      {
+        value: state.buffer,
+        cursor: state.cursor,
+        placeholders: state.placeholders,
+        disabled: state.status === "aborting",
+        hint: inputHint,
+        onKey: handleKey
+      }
+    ),
+    state.picker.open ? /* @__PURE__ */ jsx(
+      FilePicker,
+      {
+        query: state.picker.query,
+        matches: state.picker.matches,
+        selected: state.picker.selected
+      }
+    ) : null,
+    state.slashPicker.open ? /* @__PURE__ */ jsx(
+      SlashMenu,
+      {
+        query: state.slashPicker.query,
+        matches: state.slashPicker.matches,
+        selected: state.slashPicker.selected
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        model,
+        state: state.status,
+        tokenCounter,
+        hint: renderRunningTools(state.runningTools) || state.hint,
+        queueCount: state.queue.length,
+        yolo,
+        elapsedMs,
+        todos,
+        git: gitInfo,
+        context: contextWindow
+      }
+    )
+  ] });
+}
+function renderRunningTools(running) {
+  if (running.size === 0) return "";
+  let oldest = null;
+  for (const info of running.values()) {
+    if (!oldest || info.startedAt < oldest.startedAt) oldest = info;
+  }
+  if (!oldest) return "";
+  const elapsedSec = ((Date.now() - oldest.startedAt) / 1e3).toFixed(1);
+  const more = running.size > 1 ? ` (+${running.size - 1})` : "";
+  return `running: ${oldest.name} ${elapsedSec}s${more}`;
+}
+function detectAtToken(buffer, cursor) {
+  let i = cursor - 1;
+  while (i >= 0) {
+    const ch = buffer.charCodeAt(i);
+    if (ch === 64) {
+      if (i === 0 || /\s/.test(buffer[i - 1] ?? "")) {
+        return { start: i, end: cursor, query: buffer.slice(i + 1, cursor) };
+      }
+      return null;
+    }
+    if (ch === 32 || ch === 9 || ch === 10) return null;
+    i--;
+  }
+  return null;
+}
+function fmtTok2(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(n < 1e4 ? 1 : 0)}k`;
+  return `${(n / 1e6).toFixed(1)}M`;
+}
+
+// src/run-tui.ts
+var BRACKETED_PASTE_ON = "\x1B[?2004h";
+var BRACKETED_PASTE_OFF = "\x1B[?2004l";
+var ALT_SCREEN_ON = "\x1B[?1049h";
+var ALT_SCREEN_OFF = "\x1B[?1049l";
+var CURSOR_HOME = "\x1B[H";
+async function runTui(opts) {
+  const stdout = process.stdout;
+  const stdin = process.stdin;
+  if (!stdout.isTTY || !stdin.isTTY) {
+    process.stderr.write(
+      "wstack: --tui requires an interactive terminal on both stdin and stdout.\n       Drop the flag (use the plain REPL) or run wstack directly without piping.\n"
+    );
+    return 2;
+  }
+  const useAltScreen = opts.altScreen === true;
+  if (useAltScreen) {
+    stdout.write(ALT_SCREEN_ON);
+    stdout.write(CURSOR_HOME);
+  }
+  stdout.write(BRACKETED_PASTE_ON);
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    try {
+      stdout.write(BRACKETED_PASTE_OFF);
+      if (useAltScreen) {
+        stdout.write(ALT_SCREEN_OFF);
+      }
+    } catch {
+    }
+  };
+  const signals = ["SIGTERM", "SIGHUP", "SIGINT"];
+  const signalHandler = () => cleanup();
+  const exitHandler = () => cleanup();
+  for (const s of signals) process.on(s, signalHandler);
+  process.on("exit", exitHandler);
+  const detachListeners = () => {
+    for (const s of signals) process.off(s, signalHandler);
+    process.off("exit", exitHandler);
+  };
+  return new Promise((resolve) => {
+    let exitCode = 0;
+    const onExit = (code) => {
+      exitCode = code;
+    };
+    const settle = (code) => {
+      cleanup();
+      detachListeners();
+      if (useAltScreen && opts.onAfterExit) {
+        try {
+          opts.onAfterExit();
+        } catch {
+        }
+      }
+      resolve(code);
+    };
+    let instance;
+    try {
+      instance = render(
+        React.createElement(App, {
+          agent: opts.agent,
+          slashRegistry: opts.slashRegistry,
+          attachments: opts.attachments,
+          events: opts.events,
+          tokenCounter: opts.tokenCounter,
+          model: opts.model,
+          banner: opts.banner ?? true,
+          queueStore: opts.queueStore,
+          yolo: opts.yolo,
+          appVersion: opts.appVersion,
+          provider: opts.provider,
+          effectiveMaxContext: opts.effectiveMaxContext,
+          onExit
+        }),
+        { exitOnCtrlC: false }
+      );
+    } catch (err) {
+      process.stderr.write(
+        `wstack: TUI failed to start: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      settle(1);
+      return;
+    }
+    instance.waitUntilExit().then(() => settle(exitCode)).catch(() => settle(1));
+  });
+}
+
+export { runTui };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map