netheriteai-code 0.1.0

package/src/tui.js

@@ -0,0 +1,1490 @@
+const ESC = "\u001b[";
+const RESET = "\u001b[0m";
+const BEL = "\u0007";
+
+const COLORS = {
+  fg: "\u001b[38;2;232;232;232m",
+  muted: "\u001b[38;2;138;138;138m",
+  dim: "\u001b[38;2;103;103;103m",
+  blue: "\u001b[38;2;83;149;255m",
+  blueSoft: "\u001b[38;2;66;118;204m",
+  blueFaint: "\u001b[38;2;49;82;138m",
+  amber: "\u001b[38;2;217;170;78m",
+  bg: "\u001b[48;2;0;0;0m",
+  panel: "\u001b[48;2;24;24;24m",
+  panelAlt: "\u001b[48;2;31;31;31m",
+  peach: "\u001b[48;2;246;180;130m",
+  blackFg: "\u001b[38;2;0;0;0m",
+};
+
+const LOGO_TOP = [
+  "NN   NN EEEEEEE TTTTTTT H   H EEEEEEE RRRRR  IIIII TTTTTTT EEEEEEE",
+  "NNN  NN EE         T    H   H EE      RR  RR  III     T    EE     ",
+  "NN N NN EEEEE      T    HHHHH EEEEE   RRRRR   III     T    EEEEE  ",
+  "NN  NNN EE         T    H   H EE      RR RR   III     T    EE     ",
+  "NN   NN EEEEEEE    T    H   H EEEEEEE RR  RR IIIII    T    EEEEEEE",
+];
+
+const LOGO_BOTTOM = [
+  " CCC   OOO   DDDD   EEEEEEE",
+  "CC    OO OO  DD  DD EE     ",
+  "CC    OO OO  DD   DD EEEEE  ",
+  "CC    OO OO  DD  DD EE     ",
+  " CCC   OOO   DDDD   EEEEEEE",
+];
+
+const SLASH_COMMANDS = [
+  { command: "/agents", description: "Switch agent" },
+  { command: "/clear", description: "Clear transcript" },
+  { command: "/compact", description: "Compact session" },
+  { command: "/copy", description: "Copy session transcript" },
+  { command: "/help", description: "Help" },
+  { command: "/model", description: "Switch model" },
+  { command: "/new", description: "New session" },
+  { command: "/pwd", description: "Show workspace" },
+];
+
+function setTerminalTitle(title) {
+  process.stdout.write(`\u001b]2;${title}${BEL}`);
+}
+
+function move(row, col) {
+  return `${ESC}${row};${col}H`;
+}
+
+function style(text, ...codes) {
+  const hasBackground = codes.some((code) => code.includes("[48;"));
+  const applied = hasBackground ? codes : [...codes, COLORS.bg];
+  return `${applied.join("")}${text}${RESET}`;
+}
+
+function truncate(text, width) {
+  const value = String(text ?? "");
+  if (width <= 0) return "";
+  if (value.length <= width) return value;
+  return width === 1 ? value.slice(0, 1) : `${value.slice(0, width - 1)}…`;
+}
+
+function pad(text, width) {
+  const value = truncate(text, width);
+  return value + " ".repeat(Math.max(0, width - value.length));
+}
+
+function wrapText(text, width) {
+  const words = String(text ?? "").split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const next = current ? `${current} ${word}` : word;
+    if (next.length <= width) current = next;
+    else {
+      if (current) lines.push(current);
+      current = word;
+    }
+  }
+  if (current) lines.push(current);
+  return lines.length ? lines : [""];
+}
+
+function paintStatusBadge(frame, row, col, panelColor, agentName) {
+  frame.paintText(row, col, "▣", `${panelColor}${COLORS.blue}`);
+  frame.paintText(row, col + 2, agentName, `${panelColor}${COLORS.fg}`);
+  frame.paintText(row, col + 2 + agentName.length + 1, "·", `${panelColor}${COLORS.dim}`);
+}
+
+function displayModelName(model) {
+  const name = String(model || "");
+  if (name.toLowerCase().includes("glm5") || name.toLowerCase().includes("glm-5")) return "NetheriteAI:Code";
+  return name;
+}
+
+function safeJsonParse(value, fallback = {}) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function compactCodeLines(text, maxLines = 8, width = 120) {
+  const lines = String(text || "").replace(/\r/g, "").split("\n");
+  const clipped = lines.slice(0, maxLines).map((line) => truncate(line, width));
+  if (lines.length > maxLines) {
+    clipped.push(`... ${lines.length - maxLines} more line${lines.length - maxLines === 1 ? "" : "s"}`);
+  }
+  return clipped;
+}
+
+function visibleCodeLines(text, width) {
+  return String(text || "").replace(/\r/g, "").split("\n").map((line) => truncate(line, width));
+}
+
+function compactWrappedText(text, width, maxLines = 6) {
+  const wrapped = wrapText(text, width);
+  return wrapped.slice(0, maxLines);
+}
+
+function getInputLines(text, width) {
+  return wrapText(text || "", Math.max(1, width));
+}
+
+function paintInputCursor(frame, row, col) {
+  frame.paintText(row, col, " ", `\u001b[48;2;232;232;232m\u001b[38;2;24;24;24m`);
+}
+
+function keywordColor(word) {
+  const keywords = new Set([
+    "const", "let", "var", "function", "return", "if", "else", "for", "while", "switch", "case",
+    "break", "continue", "class", "new", "import", "from", "export", "default", "async", "await",
+    "try", "catch", "finally", "throw", "true", "false", "null", "undefined",
+  ]);
+  return keywords.has(word) ? COLORS.blue : COLORS.fg;
+}
+
+function codeSegments(line) {
+  const text = String(line ?? "");
+  const commentIndex = text.indexOf("//");
+  const source = commentIndex === -1 ? text : text.slice(0, commentIndex);
+  const segments = [];
+  const tokenPattern = /(".*?"|'.*?'|`.*?`|\b[A-Za-z_][A-Za-z0-9_]*\b)/g;
+  let lastIndex = 0;
+  let match = tokenPattern.exec(source);
+  while (match) {
+    if (match.index > lastIndex) {
+      segments.push({ text: source.slice(lastIndex, match.index), color: COLORS.fg });
+    }
+    const token = match[0];
+    const isString = token.startsWith("\"") || token.startsWith("'") || token.startsWith("`");
+    segments.push({ text: token, color: isString ? COLORS.amber : keywordColor(token) });
+    lastIndex = match.index + token.length;
+    match = tokenPattern.exec(source);
+  }
+  if (lastIndex < source.length) {
+    segments.push({ text: source.slice(lastIndex), color: COLORS.fg });
+  }
+  if (commentIndex !== -1) {
+    segments.push({ text: text.slice(commentIndex), color: COLORS.dim });
+  }
+  return segments.length ? segments : [{ text, color: COLORS.fg }];
+}
+
+function paintCodeLine(frame, row, col, text, panelColor, width) {
+  const clipped = truncate(text, width);
+  let cursor = col;
+  for (const segment of codeSegments(clipped)) {
+    frame.paintText(row, cursor, segment.text, `${panelColor}${segment.color}`);
+    cursor += segment.text.length;
+  }
+}
+
+function extractLiveCode(text) {
+  const source = String(text || "").replace(/\r/g, "");
+  const fenced = source.match(/```[a-zA-Z0-9_-]*\n([\s\S]*?)```/);
+  if (fenced?.[1]?.trim()) {
+    return fenced[1].trimEnd();
+  }
+
+  const lines = source.split("\n");
+  const codeSignals = [
+    /<!DOCTYPE html>/i,
+    /<html|<head|<body|<div|<script|<style/i,
+    /\b(function|const|let|var|return|class|import|export)\b/,
+    /[{}();]/,
+    /^\s{2,}\S/m,
+  ];
+  const score = codeSignals.reduce((sum, pattern) => sum + (pattern.test(source) ? 1 : 0), 0);
+  if (score >= 2 && lines.length >= 2) {
+    return source.trimEnd();
+  }
+
+  return "";
+}
+
+function getToolPreview(name, rawArgs, contentWidth) {
+  const args = safeJsonParse(rawArgs, {});
+  const previewWidth = Math.max(20, contentWidth - 12);
+
+  if (name === "write_file" || name === "create_file" || name === "append_file") {
+    return {
+      command: `${name.replace("_file", "")} ${args.path || ""}`.trim(),
+      output: compactCodeLines(args.content || "", 8, previewWidth),
+      outputKind: "code",
+      pendingLabel: "Writing",
+    };
+  }
+
+  if (name === "edit_file") {
+    return {
+      command: `edit ${args.path || ""}`.trim(),
+      output: compactCodeLines(args.newText || "", 8, previewWidth),
+      outputKind: "code",
+      pendingLabel: "Editing",
+    };
+  }
+
+  if (name === "run_command" || name === "batch_command") {
+    return {
+      command: args.commandLine || [args.command, ...(args.args || [])].filter(Boolean).join(" ") || name,
+      output: ["Running command..."],
+      outputKind: "code",
+      pendingLabel: "Executing",
+    };
+  }
+
+  return {
+    command: `${name} ${rawArgs || ""}`.trim(),
+    output: ["Working..."],
+    outputKind: "text",
+    pendingLabel: "Working",
+  };
+}
+
+function parseAssistantBlocks(text) {
+  const source = String(text ?? "").replace(/\r/g, "");
+  const parts = source.split("```");
+  const blocks = [];
+
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index];
+    if (!part.trim()) continue;
+
+    if (index % 2 === 1) {
+      const code = part.split("\n").slice(1).join("\n") || part;
+      blocks.push({ kind: "code", text: code.trimEnd() });
+      continue;
+    }
+
+    const normalized = part
+      .replace(/\*\*(.*?)\*\*/g, "$1")
+      .replace(/`([^`]+)`/g, "$1")
+      .split("\n")
+      .map((line) => line.trimEnd());
+
+    let paragraph = [];
+    for (const line of normalized) {
+      if (!line.trim()) {
+        if (paragraph.length) {
+          blocks.push({ kind: "text", text: paragraph.join(" ").trim() });
+          paragraph = [];
+        }
+        continue;
+      }
+
+      if (/^[-*]\s+/.test(line) || /^\d+\.\s+/.test(line)) {
+        if (paragraph.length) {
+          blocks.push({ kind: "text", text: paragraph.join(" ").trim() });
+          paragraph = [];
+        }
+        blocks.push({ kind: "bullet", text: line.replace(/^[-*]\s+/, "").trim() });
+        continue;
+      }
+
+      paragraph.push(line.trim());
+    }
+
+    if (paragraph.length) {
+      blocks.push({ kind: "text", text: paragraph.join(" ").trim() });
+    }
+  }
+
+  return blocks.length ? blocks : [{ kind: "text", text: source.trim() }];
+}
+
+function flattenRenderRows(items, contentWidth) {
+  const rows = [];
+  let groupId = 0;
+  for (const item of items) {
+    if (item.kind === "header") {
+      rows.push({ kind: "header_top", groupId: -1 });
+      rows.push({ kind: "header_line", text: item.text, meta: item.meta, groupId: -1 });
+      rows.push({ kind: "header_bottom", groupId: -1 });
+      rows.push({ kind: "spacer" });
+      continue;
+    }
+    if (item.kind === "user_box") {
+      groupId += 1;
+      rows.push({ kind: "user_top", groupId });
+      for (const line of item.lines) rows.push({ kind: "user_line", text: line, groupId });
+      rows.push({ kind: "user_bottom", groupId });
+      rows.push({ kind: "spacer" });
+      continue;
+    }
+    if (item.kind === "thinking") {
+      groupId += 1;
+      item.lines.forEach((line, index) => rows.push({ kind: "thinking_line", text: line, first: index === 0, groupId }));
+      rows.push({ kind: "spacer" });
+      continue;
+    }
+    if (item.kind === "code_block") {
+      groupId += 1;
+      rows.push({ kind: "code_top", groupId });
+      for (const line of item.lines) rows.push({ kind: "code_line", text: line, groupId });
+      rows.push({ kind: "code_bottom", groupId });
+      rows.push({ kind: "spacer" });
+      continue;
+    }
+    if (item.kind === "tool_block") {
+      groupId += 1;
+      rows.push({ kind: "tool_top", groupId });
+      rows.push({ kind: "tool_label", text: item.label || "# Execute", groupId });
+      for (const line of item.command) rows.push({ kind: "tool_command", text: line, groupId });
+      if (item.output.length) rows.push({ kind: "tool_gap", groupId });
+      for (const line of item.output) rows.push({ kind: "tool_output", text: line, outputKind: item.outputKind || "text", groupId });
+      rows.push({ kind: "tool_bottom", groupId });
+      rows.push({ kind: "spacer" });
+      continue;
+    }
+    if (item.kind === "assistant" || item.kind === "assistant_live") {
+      groupId += 1;
+      rows.push({ kind: item.kind, text: item.text, groupId });
+      continue;
+    }
+    if (item.kind === "meta") {
+      rows.push({ kind: "meta", text: item.text, groupId });
+      rows.push({ kind: "spacer" });
+      continue;
+    }
+    rows.push({ kind: "spacer" });
+  }
+  return rows.map((row) => ({
+    ...row,
+    text: row.text ? truncate(row.text, contentWidth - 8) : row.text,
+    meta: row.meta ? truncate(row.meta, 24) : row.meta,
+  }));
+}
+
+function center(total, size) {
+  return Math.max(1, Math.floor((total - size) / 2));
+}
+
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+function parseMouseSequence(text) {
+  const match = text.match(/^\u001b\[<(\d+);(\d+);(\d+)([Mm])$/);
+  if (!match) return null;
+  return {
+    button: Number(match[1]),
+    col: Number(match[2]),
+    row: Number(match[3]),
+    state: match[4],
+  };
+}
+
+function parseMousePrefix(text) {
+  const match = text.match(/^\u001b\[<(\d+);(\d+);(\d+)([Mm])/);
+  if (!match) return null;
+  return {
+    raw: match[0],
+    button: Number(match[1]),
+    col: Number(match[2]),
+    row: Number(match[3]),
+    state: match[4],
+  };
+}
+
+function paintBusyIndicator(frame, row, col, now = Date.now()) {
+  const width = 8;
+  const cycleMs = 680;
+  const travel = width + 7;
+  const t = now % cycleMs;
+  const head = -3 + (t / cycleMs) * travel;
+
+  for (let index = 0; index < width; index += 1) {
+    const distance = Math.abs(index - head);
+    let color = COLORS.dim;
+    let char = "·";
+    if (distance < 0.7) {
+      color = COLORS.blue;
+      char = "■";
+    } else if (distance < 1.5) {
+      color = COLORS.blueSoft;
+      char = "■";
+    } else if (distance < 2.3) {
+      color = COLORS.blueFaint;
+      char = "▪";
+    }
+    frame.paintText(row, col + index, char, `${COLORS.bg}${color}`);
+  }
+}
+
+function makeFrame(width, height) {
+  const rows = Array.from({ length: height }, () => Array(width).fill(" "));
+  const styles = Array.from({ length: height }, () => Array(width).fill(`${COLORS.bg}${COLORS.fg}`));
+
+  function paintText(row, col, text, code = `${COLORS.bg}${COLORS.fg}`) {
+    if (row < 1 || row > height) return;
+    const chars = [...text];
+    for (let i = 0; i < chars.length; i += 1) {
+      const x = col + i;
+      if (x < 1 || x > width) continue;
+      rows[row - 1][x - 1] = chars[i];
+      styles[row - 1][x - 1] = code;
+    }
+  }
+
+  function fillRect(row, col, w, h, code = `${COLORS.panel}${COLORS.fg}`, char = " ") {
+    for (let y = 0; y < h; y += 1) {
+      for (let x = 0; x < w; x += 1) {
+        const rr = row + y;
+        const cc = col + x;
+        if (rr < 1 || rr > height || cc < 1 || cc > width) continue;
+        rows[rr - 1][cc - 1] = char;
+        styles[rr - 1][cc - 1] = code;
+      }
+    }
+  }
+
+  function flush(cursorRow, cursorCol) {
+    const output = [`${ESC}2J${ESC}H${COLORS.bg}`];
+    for (let r = 0; r < height; r += 1) {
+      output.push(move(r + 1, 1));
+      let currentStyle = "";
+      let line = "";
+      for (let c = 0; c < width; c += 1) {
+        const nextStyle = styles[r][c];
+        if (nextStyle !== currentStyle) {
+          if (line) output.push(line);
+          output.push(nextStyle);
+          line = rows[r][c];
+          currentStyle = nextStyle;
+        } else {
+          line += rows[r][c];
+        }
+      }
+      output.push(line, RESET);
+    }
+    output.push(move(cursorRow, cursorCol));
+    process.stdout.write(output.join(""));
+  }
+
+  return { paintText, fillRect, flush };
+}
+
+export function runTui({
+  model,
+  getModel,
+  agentName,
+  providerName,
+  version,
+  workspaceLabel,
+  sessionId,
+  initialSessionTitle = "",
+  initialTranscript = [],
+  onTranscriptChange,
+  onTitleChange,
+  onSubmit,
+}) {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdout.write("\u001b[?1049h\u001b[?25l\u001b[?1000h\u001b[?1006h");
+    setTerminalTitle("NetheriteAI:Code by hurdacu");
+
+    let mode = "home";
+    let input = "";
+    let busy = false;
+    let status = 'Ask anything...  "Fix broken tests"';
+    let activity = "";
+    let streamingText = "";
+    let sessionTitle = initialSessionTitle || "New Session";
+    let scrollOffset = 0;
+    let busyAnimationTime = Date.now();
+    let historyIndex = -1;
+    let historyDraft = "";
+    let picker = null;
+    let slashIndex = 0;
+    let selectedGroup = 1;
+    let cursorVisible = true;
+    let lastCursorToggle = Date.now();
+    let currentAbortController = null;
+    let autoFollow = true;
+    let busyStartedAt = 0;
+    let lastProgressAt = 0;
+    let currentPhase = "";
+    const promptHistory = [];
+    const transcript = Array.isArray(initialTranscript) ? [...initialTranscript] : [];
+    let liveReasoning = "";
+    let inputBuffer = "";
+
+    const timer = setInterval(() => {
+      const now = Date.now();
+      const hasAnimatingTool = transcript.some((item) =>
+        item.role === "tool"
+        && item.pending
+        && item.streamSource
+        && ((item.streamOffset || 0) < item.streamSource.length || item.finalPreview),
+      );
+      if (now - lastCursorToggle >= 650) {
+        cursorVisible = !cursorVisible;
+        lastCursorToggle = now;
+      }
+      if (busy) {
+        busyAnimationTime = now;
+        const elapsed = ((now - busyStartedAt) / 1000).toFixed(1);
+        const idleFor = lastProgressAt ? ((now - lastProgressAt) / 1000).toFixed(1) : "0.0";
+        const phase = currentPhase || activity || status || "Working";
+        upsertLiveMessage("status_live", `${phase} · ${elapsed}s elapsed · ${idleFor}s since update`);
+      } else {
+        removeLiveMessage("status_live");
+      }
+      if (busy || hasAnimatingTool) {
+        for (const item of transcript) {
+          if (item.role !== "tool" || !item.pending || !item.streamSource) continue;
+          const nextOffset = Math.min(item.streamSource.length, (item.streamOffset || 0) + 140);
+          if (nextOffset !== item.streamOffset) {
+            item.streamOffset = nextOffset;
+            item.outputLines = visibleCodeLines(item.streamSource.slice(0, nextOffset), Math.max(20, (process.stdout.columns || 120) - 18));
+            onTranscriptChange?.([...transcript]);
+          }
+          if (item.streamOffset >= item.streamSource.length && item.finalPreview) {
+            finalizeToolMessage(item, item.finalPreview);
+            onTranscriptChange?.([...transcript]);
+          }
+        }
+      }
+      render();
+    }, 45);
+
+    function addPromptHistory(prompt) {
+      if (!prompt.trim()) return;
+      if (promptHistory[0] !== prompt) promptHistory.unshift(prompt);
+      historyIndex = -1;
+      historyDraft = "";
+    }
+
+    function makeTitleFromPrompt(prompt, maxLength = 36) {
+      const text = String(prompt || "").trim().replace(/\s+/g, " ");
+      if (!text) return "";
+      if (text.length <= maxLength) return text;
+      return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+    }
+
+    function ensureSessionTitle(prompt) {
+      if (sessionTitle && sessionTitle !== "New Session") return;
+      const nextTitle = makeTitleFromPrompt(prompt);
+      if (!nextTitle) return;
+      sessionTitle = nextTitle;
+      onTitleChange?.(nextTitle);
+    }
+
+    function resetTranscriptView() {
+      transcript.length = 0;
+      streamingText = "";
+      liveReasoning = "";
+      activity = "";
+      status = 'Ask anything...  "Fix broken tests"';
+      scrollToBottom();
+      onTranscriptChange?.([]);
+    }
+
+    function resetSessionView() {
+      resetTranscriptView();
+      sessionTitle = "New Session";
+      onTitleChange?.("");
+    }
+
+    function browseHistory(direction) {
+      if (!promptHistory.length) return;
+      if (historyIndex === -1) {
+        historyDraft = input;
+      }
+      const next = Math.max(-1, Math.min(promptHistory.length - 1, historyIndex + direction));
+      historyIndex = next;
+      input = next === -1 ? historyDraft : promptHistory[next];
+    }
+
+    function pushMessage(role, text, meta = "", extra = {}) {
+      transcript.push({ role, text, meta, ...extra });
+      if (transcript.length > 200) transcript.shift();
+      onTranscriptChange?.([...transcript]);
+      autoFollow = true;
+    }
+
+    function upsertLiveMessage(role, text, meta = "", extra = {}) {
+      const existingIndex = transcript.findIndex((item) => item.role === role);
+      if (existingIndex !== -1) {
+        transcript[existingIndex] = { ...transcript[existingIndex], text, meta, ...extra };
+      } else {
+        transcript.push({ role, text, meta, ...extra });
+      }
+      if (transcript.length > 200) transcript.shift();
+      onTranscriptChange?.([...transcript]);
+      autoFollow = true;
+    }
+
+    function removeLiveMessage(role) {
+      const index = transcript.findIndex((item) => item.role === role);
+      if (index !== -1) {
+        transcript.splice(index, 1);
+        onTranscriptChange?.([...transcript]);
+      }
+    }
+
+    function finalizeToolMessage(item, preview) {
+      if (!preview.preserveCommand && preview.command) {
+        item.text = preview.command;
+      }
+      item.meta = preview.output;
+      item.outputLines = String(preview.output || "").split("\n");
+      item.outputKind = preview.outputKind || "text";
+      item.label = preview.label || "# Done";
+      item.pending = false;
+      delete item.streamSource;
+      delete item.streamOffset;
+      delete item.finalPreview;
+    }
+
+    function scrollToBottom() {
+      autoFollow = true;
+      scrollOffset = Number.MAX_SAFE_INTEGER;
+    }
+
+    function scrollBy(delta) {
+      scrollOffset = Math.max(0, scrollOffset + delta);
+      if (delta < 0) {
+        autoFollow = false;
+        return;
+      }
+      if (scrollOffset === 0) {
+        autoFollow = true;
+      }
+    }
+
+    function previewToolResult(name, result) {
+      if (result && result.ok === false) {
+        return {
+          command: "",
+          output: `Error: ${result.error || "Tool failed."}`,
+          label: "# Error",
+          outputKind: "text",
+          preserveCommand: true,
+        };
+      }
+
+      if (name === "run_command") {
+        const command = result.commandLine || [result.command, ...(result.args || [])].filter(Boolean).join(" ");
+        const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+        return {
+          command: command || "command",
+          output: truncate(output || "Completed with no output.", 500),
+          label: "# Done",
+          outputKind: "text",
+        };
+      }
+
+      if (name === "batch_command") {
+        const first = (result.results || [])[0] || {};
+        const command = first.commandLine || [first.command, ...(first.args || [])].filter(Boolean).join(" ") || "batch command";
+        const output = [first.stdout, first.stderr].filter(Boolean).join("\n").trim();
+        return {
+          command,
+          output: truncate(output || `Ran ${result.results?.length || 0} commands.`, 500),
+          label: "# Done",
+          outputKind: "text",
+        };
+      }
+
+      if (name === "read_file") {
+        return { command: `read ${result.path}`, output: truncate(result.content || "", 500), label: "# Done", outputKind: "text" };
+      }
+
+      if (name === "create_file") {
+        return { command: `create ${result.path}`, output: `${result.bytesWritten || 0} bytes written`, label: "# Done", outputKind: "text" };
+      }
+
+      if (name === "write_file") {
+        return { command: `write ${result.path}`, output: `${result.bytesWritten || 0} bytes written`, label: "# Done", outputKind: "text" };
+      }
+
+      if (name === "append_file") {
+        return { command: `append ${result.path}`, output: `${result.bytesWritten || 0} bytes appended`, label: "# Done", outputKind: "text" };
+      }
+
+      if (name === "edit_file") {
+        return { command: `edit ${result.path}`, output: `${result.replacements || 0} replacement${result.replacements === 1 ? "" : "s"}`, label: "# Done", outputKind: "text" };
+      }
+
+      if (name === "make_dir") {
+        return { command: `mkdir ${result.path}`, output: "Directory ready", label: "# Done", outputKind: "text" };
+      }
+
+      if (name === "list_files") {
+        const entries = (result.entries || []).slice(0, 10).map((entry) => entry.path).join("\n");
+        return { command: "ls", output: entries || "No entries", label: "# Done", outputKind: "text" };
+      }
+
+      return { command: name, output: truncate(JSON.stringify(result), 500), label: "# Done", outputKind: "text" };
+    }
+
+    function renderHome(frame, width, height) {
+      const currentModel = displayModelName(getModel ? getModel() : model);
+      const logoWidth = Math.max(LOGO_TOP[0].length, LOGO_BOTTOM[0].length);
+      const logoLeft = center(width, logoWidth);
+      const logoTop = Math.max(4, Math.floor(height / 2) - 10);
+      frame.fillRect(logoTop, logoLeft, logoWidth, LOGO_TOP.length + LOGO_BOTTOM.length + 1, `${COLORS.bg}${COLORS.fg}`);
+      LOGO_TOP.forEach((line, index) => {
+        frame.paintText(logoTop + index, logoLeft, line, `${COLORS.bg}${COLORS.dim}`);
+      });
+      const bottomLeft = center(width, LOGO_BOTTOM[0].length);
+      LOGO_BOTTOM.forEach((line, index) => {
+        frame.paintText(logoTop + LOGO_TOP.length + 1 + index, bottomLeft, line, `${COLORS.bg}${COLORS.fg}`);
+      });
+
+      const panelWidth = Math.min(74, width - 14);
+      const panelLeft = center(width, panelWidth);
+      const promptText = input || status;
+      const promptLines = getInputLines(promptText, panelWidth - 4);
+      const panelHeight = promptLines.length + 3;
+      const panelTop = logoTop + LOGO_TOP.length + LOGO_BOTTOM.length + 3;
+      frame.fillRect(panelTop, panelLeft, panelWidth, panelHeight, `${COLORS.panel}${COLORS.fg}`);
+      for (let y = 0; y < panelHeight; y += 1) frame.paintText(panelTop + y, panelLeft, "│", `${COLORS.panel}${COLORS.blue}`);
+      promptLines.forEach((line, index) => {
+        frame.paintText(panelTop + 1 + index, panelLeft + 2, pad(line, panelWidth - 4), `${COLORS.panel}${input ? COLORS.fg : COLORS.dim}`);
+      });
+      if (cursorVisible && input) {
+        const cursorLine = promptLines.length - 1;
+        const cursorCol = panelLeft + 2 + promptLines[cursorLine].length;
+        paintInputCursor(frame, panelTop + 1 + cursorLine, cursorCol);
+      }
+      paintStatusBadge(frame, panelTop + promptLines.length + 1, panelLeft + 2, COLORS.panel, agentName);
+      renderSlashMenu(frame, panelLeft + 1, panelTop + promptLines.length + 1, panelWidth - 2);
+
+      const hints = "ctrl+t variants   tab agents   ctrl+p commands";
+      frame.paintText(panelTop + panelHeight + 1, center(width, hints.length), hints, `${COLORS.bg}${COLORS.fg}`);
+      frame.paintText(height, 2, truncate(workspaceLabel, width - 14), `${COLORS.bg}${COLORS.dim}`);
+      frame.paintText(height, width - version.length - 1, version, `${COLORS.bg}${COLORS.dim}`);
+    }
+
+    function renderPicker(frame, width, height) {
+      if (!picker) return;
+      const boxWidth = Math.min(72, width - 20);
+      const visibleCount = Math.min(8, picker.items.length);
+      const boxHeight = visibleCount + 4;
+      const top = center(height, boxHeight);
+      const left = center(width, boxWidth);
+      frame.fillRect(top, left, boxWidth, boxHeight, `${COLORS.panel}${COLORS.fg}`);
+      frame.paintText(top + 1, left + 2, truncate(picker.title, boxWidth - 4), `${COLORS.panel}${COLORS.fg}`);
+      for (let i = 0; i < visibleCount; i += 1) {
+        const item = picker.items[i];
+        const active = i === picker.selected;
+        frame.paintText(
+          top + 2 + i,
+          left + 2,
+          `${active ? "›" : " "} ${truncate(item.label, boxWidth - 6)}`,
+          `${COLORS.panel}${active ? COLORS.blue : COLORS.fg}`,
+        );
+      }
+    }
+
+    function getSlashMatches() {
+      if (!input.startsWith("/")) return [];
+      const term = input.trim().toLowerCase();
+      return SLASH_COMMANDS.filter((item) => item.command.startsWith(term) || item.command.includes(term.slice(1)));
+    }
+
+    function renderSlashMenu(frame, left, bottomRow, widthLimit) {
+      const matches = getSlashMatches();
+      if (!matches.length || picker) return;
+      slashIndex = clamp(slashIndex, 0, matches.length - 1);
+      const visibleCount = Math.min(8, matches.length);
+      const boxWidth = Math.min(widthLimit, 64);
+      const boxHeight = visibleCount + 1;
+      const top = Math.max(2, bottomRow - boxHeight);
+
+      frame.fillRect(top, left, boxWidth, boxHeight, `${COLORS.panel}${COLORS.fg}`);
+      for (let i = 0; i < visibleCount; i += 1) {
+        const item = matches[i];
+        const active = i === slashIndex;
+        const bg = active ? COLORS.peach : COLORS.panel;
+        const fg = active ? COLORS.blackFg : COLORS.fg;
+        frame.fillRect(top + i, left, boxWidth, 1, `${bg}${fg}`);
+        frame.paintText(top + i, left + 1, truncate(item.command, 12), `${bg}${fg}`);
+        frame.paintText(top + i, left + 14, truncate(item.description, boxWidth - 16), `${bg}${active ? COLORS.blackFg : COLORS.muted}`);
+      }
+    }
+
+    function buildTranscriptLines(contentWidth) {
+      const currentModel = displayModelName(getModel ? getModel() : model);
+      const lines = [];
+      const hasPendingTool = transcript.some((item) => item.role === "tool" && item.pending);
+      lines.push({ kind: "header", text: `# ${sessionTitle}`, meta: sessionId || "local session" });
+      lines.push({ kind: "spacer", text: "" });
+      for (const item of transcript) {
+        if (item.role === "user") {
+          const wrapped = wrapText(item.text, contentWidth - 6);
+          lines.push({ kind: "user_box", lines: wrapped });
+          lines.push({ kind: "spacer", text: "" });
+          continue;
+        }
+        if (item.role === "thinking") {
+          const wrapped = wrapText(item.text, contentWidth - 8);
+          lines.push({ kind: "thinking", lines: wrapped });
+          lines.push({ kind: "spacer", text: "" });
+          continue;
+        }
+        if (item.role === "thinking_live") {
+          const wrapped = compactWrappedText(`Thinking: ${String(item.text || "").replace(/\s+/g, " ")}`, contentWidth - 8, 8);
+          lines.push({ kind: "thinking", lines: wrapped });
+          lines.push({ kind: "spacer", text: "" });
+          continue;
+        }
+        if (item.role === "tool") {
+          const commandLines = wrapText(item.text, contentWidth - 10);
+          const sourceOutput = Array.isArray(item.outputLines)
+            ? item.outputLines
+            : String(item.meta || "").split("\n").flatMap((line) => wrapText(line, contentWidth - 10));
+          lines.push({
+            kind: "tool_block",
+            command: commandLines,
+            output: sourceOutput.slice(0, 8),
+            outputKind: item.outputKind || "text",
+            label: item.label || "# Execute",
+          });
+          lines.push({ kind: "spacer", text: "" });
+          continue;
+        }
+        if (item.role === "status_live") {
+          lines.push({ kind: "meta", text: item.text });
+          lines.push({ kind: "spacer", text: "" });
+          continue;
+        }
+        if (item.role === "assistant_live") {
+          const liveCode = extractLiveCode(item.text);
+          if (liveCode) {
+            const codeLines = visibleCodeLines(liveCode, contentWidth - 8);
+            lines.push({ kind: "code_block", lines: codeLines });
+            lines.push({ kind: "spacer", text: "" });
+            continue;
+          }
+          const wrapped = compactWrappedText(item.text, contentWidth - 4, 10);
+          lines.push(...wrapped.map((line) => ({ kind: "assistant_live", text: line })));
+          lines.push({ kind: "spacer", text: "" });
+          continue;
+        }
+        const blocks = parseAssistantBlocks(item.text);
+        for (const block of blocks) {
+          if (block.kind === "code") {
+            const codeLines = compactCodeLines(block.text, 10, contentWidth - 8);
+            lines.push({ kind: "code_block", lines: codeLines });
+            lines.push({ kind: "spacer", text: "" });
+            continue;
+          }
+          const prefix = block.kind === "bullet" ? "• " : "";
+          const wrapped = wrapText(prefix + block.text, contentWidth - 6);
+          lines.push(...wrapped.map((line) => ({ kind: "assistant", text: line })));
+          lines.push({ kind: "spacer", text: "" });
+        }
+        lines.push({ kind: "meta", text: `${agentName} · ${currentModel}${item.meta ? ` · ${item.meta}` : ""}` });
+        lines.push({ kind: "spacer", text: "" });
+      }
+      if (busy && !transcript.some((item) => item.role === "thinking_live") && (liveReasoning || !streamingText)) {
+        const reasoningText = liveReasoning.trim()
+          ? `Thinking: ${liveReasoning.trim().replace(/\s+/g, " ")}`
+          : activity || (status && status !== "idle" ? `Thinking: ${status}` : "Thinking: Working on your request...");
+        const wrapped = compactWrappedText(reasoningText, contentWidth - 8, hasPendingTool ? 4 : 8);
+        lines.push({ kind: "thinking", lines: wrapped });
+        lines.push({ kind: "spacer", text: "" });
+      }
+      if (busy && !transcript.some((item) => item.role === "assistant_live") && streamingText && !hasPendingTool) {
+        const liveCode = extractLiveCode(streamingText);
+        if (liveCode) {
+            const codeLines = visibleCodeLines(liveCode, contentWidth - 8);
+          lines.push({ kind: "code_block", lines: codeLines });
+        } else {
+          const wrapped = compactWrappedText(streamingText, contentWidth - 4, 8);
+          lines.push(...wrapped.map((line) => ({ kind: "assistant_live", text: line })));
+        }
+      }
+      return lines;
+    }
+
+    function renderSession(frame, width, height) {
+      const currentModel = displayModelName(getModel ? getModel() : model);
+      const hasSidebar = width >= 120;
+      const sidebarWidth = hasSidebar ? 30 : 0;
+      const contentWidth = width - sidebarWidth - 6;
+      const inputLines = getInputLines(input, contentWidth - 5);
+      const inputHeight = inputLines.length + 3;
+      const inputTop = height - inputHeight - 1;
+      const contentHeight = Math.max(1, inputTop - 2);
+      const scrollCol = hasSidebar ? contentWidth + 1 : width - 2;
+
+      frame.paintText(1, center(width, `NetheriteAI:Code | ${sessionTitle}`.length), `NetheriteAI:Code | ${sessionTitle}`, `${COLORS.bg}${COLORS.fg}`);
+      if (hasSidebar) {
+        for (let r = 2; r <= height; r += 1) {
+          frame.paintText(r, contentWidth + 3, "│", `${COLORS.bg}${COLORS.dim}`);
+        }
+        const sideCol = contentWidth + 6;
+        const sideWidth = sidebarWidth - 8;
+        frame.paintText(3, sideCol, truncate(sessionTitle, sideWidth), `${COLORS.bg}${COLORS.fg}`);
+        frame.paintText(4, sideCol, "made by hurdacu", `${COLORS.bg}${COLORS.dim}`);
+        frame.paintText(6, sideCol, "Context", `${COLORS.bg}${COLORS.fg}`);
+        frame.paintText(7, sideCol, truncate("local session", sideWidth), `${COLORS.bg}${COLORS.muted}`);
+        frame.paintText(8, sideCol, truncate(busy ? "streaming" : "idle", sideWidth), `${COLORS.bg}${COLORS.muted}`);
+        frame.paintText(10, sideCol, "LSP", `${COLORS.bg}${COLORS.fg}`);
+        frame.paintText(11, sideCol, truncate("LSPs activate as files are read", sideWidth), `${COLORS.bg}${COLORS.muted}`);
+        frame.paintText(height - 3, sideCol, truncate(workspaceLabel, sideWidth), `${COLORS.bg}${COLORS.muted}`);
+        frame.paintText(height - 1, sideCol, truncate(`• NetheriteAI:Code ${version}`, sideWidth), `${COLORS.bg}${COLORS.fg}`);
+      }
+
+      const rows = flattenRenderRows(buildTranscriptLines(contentWidth), contentWidth);
+      const maxGroup = Math.max(1, ...rows.map((item) => item.groupId || 0));
+      selectedGroup = clamp(selectedGroup, 1, maxGroup);
+      const maxOffset = Math.max(0, rows.length - contentHeight);
+      if (autoFollow) {
+        scrollOffset = maxOffset;
+      } else {
+        scrollOffset = Math.max(0, Math.min(scrollOffset, maxOffset));
+        if (scrollOffset >= maxOffset) {
+          autoFollow = true;
+        }
+      }
+      const visible = rows.slice(scrollOffset, scrollOffset + contentHeight);
+
+      let row = 2;
+      for (const item of visible) {
+        if (row > contentHeight + 1) break;
+        const selected = item.groupId > 0 && item.groupId === selectedGroup;
+        const linePanel = `${selected ? COLORS.panelAlt : COLORS.panel}${COLORS.fg}`;
+        const lineBg = `${COLORS.bg}${COLORS.fg}`;
+        const lineMuted = `${selected ? COLORS.panelAlt : COLORS.panel}${COLORS.muted}`;
+        const borderStyle = `${selected ? COLORS.panelAlt : COLORS.panel}${COLORS.blue}`;
+        if (item.kind === "header_top" || item.kind === "header_bottom") {
+          frame.fillRect(row, 2, contentWidth, 1, `${COLORS.panel}${COLORS.fg}`);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "header_line") {
+          frame.fillRect(row, 2, contentWidth, 1, `${COLORS.panel}${COLORS.fg}`);
+          frame.paintText(row, 4, item.text, `${COLORS.panel}${COLORS.fg}`);
+          frame.paintText(row, Math.max(4, contentWidth - String(item.meta || "").length), item.meta || "", `${COLORS.panel}${COLORS.muted}`);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "user_top" || item.kind === "user_bottom") {
+          frame.fillRect(row, 2, contentWidth - 1, 1, linePanel);
+          frame.paintText(row, 2, "│", borderStyle);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "user_line") {
+          frame.fillRect(row, 2, contentWidth - 1, 1, linePanel);
+          frame.paintText(row, 2, "│", borderStyle);
+          frame.paintText(row, 4, pad(item.text, contentWidth - 5), linePanel);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "thinking_line") {
+          if (selected) frame.fillRect(row, 3, contentWidth - 3, 1, `${COLORS.bg}${COLORS.fg}`);
+          frame.paintText(row, 3, "│", `${COLORS.bg}${COLORS.dim}`);
+          if (item.first && item.text.startsWith("Thinking:")) {
+            frame.paintText(row, 5, "Thinking:", `${COLORS.bg}${COLORS.amber}`);
+            frame.paintText(row, 15, ` ${item.text.slice(9).trim()}`, `${COLORS.bg}${COLORS.muted}`);
+          } else {
+            frame.paintText(row, 5, item.text, `${COLORS.bg}${COLORS.muted}`);
+          }
+          row += 1;
+          continue;
+        }
+        if (item.kind === "assistant" || item.kind === "assistant_live") {
+          if (selected) frame.fillRect(row, 3, contentWidth - 3, 1, `${COLORS.bg}${COLORS.fg}`);
+          frame.paintText(row, 4, truncate(item.text, contentWidth - 8), lineBg);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "code_top" || item.kind === "code_bottom") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "code_line") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          paintCodeLine(frame, row, 5, item.text, selected ? COLORS.panelAlt : COLORS.panel, contentWidth - 11);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "tool_top" || item.kind === "tool_bottom") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "tool_label") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          frame.paintText(row, 5, item.text, `${selected ? COLORS.panelAlt : COLORS.panel}${COLORS.blueSoft}`);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "tool_command") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          frame.paintText(row, 5, `$ ${truncate(item.text, contentWidth - 13)}`, linePanel);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "tool_gap") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          row += 1;
+          continue;
+        }
+        if (item.kind === "tool_output") {
+          frame.fillRect(row, 3, contentWidth - 7, 1, linePanel);
+          if (item.outputKind === "code") {
+            paintCodeLine(frame, row, 5, item.text, selected ? COLORS.panelAlt : COLORS.panel, contentWidth - 11);
+          } else {
+            frame.paintText(row, 5, truncate(item.text, contentWidth - 11), lineMuted);
+          }
+          row += 1;
+          continue;
+        }
+        if (item.kind === "meta") {
+          if (selected) frame.fillRect(row, 3, contentWidth - 3, 1, `${COLORS.bg}${COLORS.fg}`);
+          frame.paintText(row, 4, `◻ ${truncate(item.text, contentWidth - 8)}`, `${COLORS.bg}${selected ? COLORS.fg : COLORS.blue}`);
+          row += 1;
+          continue;
+        }
+        row += 1;
+      }
+      for (let r = 2; r < inputTop; r += 1) {
+        frame.paintText(r, scrollCol, "│", `${COLORS.bg}${COLORS.dim}`);
+      }
+      if (maxOffset > 0) {
+        const trackHeight = Math.max(1, inputTop - 2);
+        const thumbHeight = Math.max(3, Math.floor((contentHeight / rows.length) * trackHeight));
+        const thumbTravel = Math.max(0, trackHeight - thumbHeight);
+        const thumbTop = 2 + Math.floor((scrollOffset / maxOffset) * thumbTravel);
+        for (let r = 0; r < thumbHeight; r += 1) {
+          frame.paintText(thumbTop + r, scrollCol, "█", `${COLORS.bg}${COLORS.muted}`);
+        }
+      }
+
+      frame.fillRect(inputTop, 2, contentWidth - 1, inputHeight, `${COLORS.panel}${COLORS.fg}`);
+      for (let y = 0; y < inputHeight; y += 1) frame.paintText(inputTop + y, 2, "│", `${COLORS.panel}${COLORS.blue}`);
+      paintStatusBadge(frame, inputTop + inputLines.length + 1, 4, COLORS.panel, agentName);
+      inputLines.forEach((line, index) => {
+        frame.paintText(inputTop + 1 + index, 4, pad(line, contentWidth - 5), `${COLORS.panel}${COLORS.fg}`);
+      });
+      if (cursorVisible) {
+        const cursorLine = inputLines.length - 1;
+        const cursorCol = 4 + inputLines[cursorLine].length;
+        paintInputCursor(frame, inputTop + 1 + cursorLine, cursorCol);
+      }
+      renderSlashMenu(frame, 3, inputTop + inputLines.length + 1, contentWidth - 2);
+
+      const hints = "tab agents   ctrl+p commands";
+      if (busy) {
+        paintBusyIndicator(frame, height, 2, busyAnimationTime);
+        frame.paintText(height, 12, "esc interrupt", `${COLORS.bg}${COLORS.fg}`);
+        const busyLabel = truncate(activity || status || "Working...", Math.max(10, contentWidth - hints.length - 20));
+        frame.paintText(height - 1, 2, busyLabel, `${COLORS.bg}${COLORS.muted}`);
+      }
+      frame.paintText(height, contentWidth - hints.length, hints, `${COLORS.bg}${COLORS.fg}`);
+    }
+
+    async function submit() {
+      const prompt = input.trim();
+      if (!prompt || busy) return;
+      if (mode === "home") mode = "session";
+
+      addPromptHistory(prompt);
+      ensureSessionTitle(prompt);
+      input = "";
+      busy = true;
+      busyStartedAt = Date.now();
+      lastProgressAt = busyStartedAt;
+      currentPhase = "Thinking";
+      status = "thinking";
+      activity = "";
+      streamingText = "";
+      liveReasoning = "";
+      pushMessage("user", prompt);
+      render();
+
+      try {
+        const started = Date.now();
+        currentAbortController = new AbortController();
+        await onSubmit(prompt, {
+          signal: currentAbortController.signal,
+          onStatus(message) {
+            status = message;
+            currentPhase = message;
+            lastProgressAt = Date.now();
+            render();
+          },
+          onEvent(message) {
+            activity = message;
+            currentPhase = message;
+            lastProgressAt = Date.now();
+            render();
+          },
+          onToolStart(event) {
+            currentPhase = `${event.name}`;
+            lastProgressAt = Date.now();
+            if (liveReasoning.trim()) {
+              pushMessage("thinking", liveReasoning.trim());
+              liveReasoning = "";
+            }
+            if (streamingText.trim()) {
+              pushMessage("assistant", streamingText.trim());
+              streamingText = "";
+            }
+            removeLiveMessage("thinking_live");
+            removeLiveMessage("assistant_live");
+            const preview = getToolPreview(event.name, event.args, process.stdout.columns || 120);
+            pushMessage("tool", preview.command, "", {
+              outputLines: preview.outputKind === "code" ? [] : preview.output,
+              outputKind: preview.outputKind,
+              label: `# ${preview.pendingLabel}`,
+              pending: true,
+              streamSource: preview.outputKind === "code" ? preview.output.join("\n") : "",
+              streamOffset: 0,
+            });
+            scrollToBottom();
+            render();
+          },
+          onToolResult(event) {
+            currentPhase = `${event.name} done`;
+            lastProgressAt = Date.now();
+            const preview = previewToolResult(event.name, event.result || {});
+            for (let index = transcript.length - 1; index >= 0; index -= 1) {
+              if (transcript[index].role === "tool" && transcript[index].pending) {
+                if (transcript[index].streamSource && (transcript[index].streamOffset || 0) < transcript[index].streamSource.length) {
+                  transcript[index].finalPreview = preview;
+                } else {
+                  finalizeToolMessage(transcript[index], preview);
+                }
+                onTranscriptChange?.([...transcript]);
+                break;
+              }
+            }
+            scrollToBottom();
+            render();
+          },
+          onToolProgress(event) {
+            currentPhase = `${event.name}`;
+            lastProgressAt = Date.now();
+            for (let index = transcript.length - 1; index >= 0; index -= 1) {
+              if (transcript[index].role === "tool" && transcript[index].pending) {
+                const nextLines = String(event.progress?.text || "").replace(/\r/g, "").split("\n");
+                const existing = Array.isArray(transcript[index].outputLines) ? transcript[index].outputLines : [];
+                transcript[index].outputLines = visibleCodeLines([...existing, ...nextLines].join("\n"), Math.max(20, (process.stdout.columns || 120) - 18));
+                transcript[index].outputKind = "code";
+                transcript[index].label = "# Executing";
+                onTranscriptChange?.([...transcript]);
+                break;
+              }
+            }
+            scrollToBottom();
+            render();
+          },
+          onPicker(data) {
+            picker = { ...data, selected: 0 };
+            render();
+          },
+          onClearTranscript() {
+            resetTranscriptView();
+            render();
+          },
+          onResetSession() {
+            resetSessionView();
+            render();
+          },
+          onReasoning(chunk) {
+            liveReasoning += chunk;
+            currentPhase = "Thinking";
+            lastProgressAt = Date.now();
+            upsertLiveMessage("thinking_live", liveReasoning.trim());
+            scrollToBottom();
+            render();
+          },
+          onReasoningDone(text) {
+            if (text?.trim()) {
+              liveReasoning = text;
+            }
+            removeLiveMessage("thinking_live");
+            render();
+          },
+          onStream(chunk) {
+            streamingText += chunk;
+            currentPhase = "Writing response";
+            lastProgressAt = Date.now();
+            upsertLiveMessage("assistant_live", streamingText);
+            scrollToBottom();
+            render();
+          },
+          onAssistant(message) {
+            const seconds = ((Date.now() - started) / 1000).toFixed(1);
+            currentPhase = "Done";
+            lastProgressAt = Date.now();
+            if (liveReasoning.trim()) {
+              pushMessage("thinking", liveReasoning.trim());
+            }
+            removeLiveMessage("thinking_live");
+            removeLiveMessage("assistant_live");
+            pushMessage("assistant", message, `${seconds}s`);
+            streamingText = "";
+            liveReasoning = "";
+            scrollToBottom();
+            render();
+          },
+        });
+      } catch (error) {
+        const aborted = currentAbortController?.signal.aborted
+          || error?.name === "AbortError"
+          || String(error).includes("AbortError");
+        if (aborted) {
+          if (liveReasoning.trim()) {
+            pushMessage("thinking", liveReasoning.trim());
+          }
+          if (streamingText.trim()) {
+            pushMessage("assistant", streamingText.trim(), "interrupted");
+          } else {
+            pushMessage("assistant", "Interrupted.", "");
+          }
+          removeLiveMessage("thinking_live");
+          removeLiveMessage("assistant_live");
+        } else {
+          removeLiveMessage("thinking_live");
+          removeLiveMessage("assistant_live");
+          pushMessage("assistant", `Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      } finally {
+        busy = false;
+        status = "idle";
+        activity = "";
+        liveReasoning = "";
+        currentPhase = "";
+        busyStartedAt = 0;
+        lastProgressAt = 0;
+        currentAbortController = null;
+        render();
+      }
+    }
+
+    function render() {
+      const width = process.stdout.columns || 120;
+      const height = process.stdout.rows || 36;
+      const frame = makeFrame(width, height);
+      if (mode === "home") renderHome(frame, width, height);
+      else renderSession(frame, width, height);
+      renderPicker(frame, width, height);
+      frame.flush(height, width);
+    }
+
+    function cleanup(reason = "close") {
+      clearInterval(timer);
+      process.stdin.removeListener("data", onData);
+      process.stdout.removeListener("resize", render);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdout.write("\u001b[?1000l\u001b[?1006l\u001b[?25h\u001b[?1049l");
+      resolve({ reason, transcript: [...transcript] });
+    }
+
+    function handleMouse(mouse) {
+      const isWheel = mouse.button === 64 || mouse.button === 65;
+      if (!isWheel || mode !== "session") return;
+      if (mouse.button === 64) {
+        scrollBy(-3);
+      } else {
+        scrollBy(3);
+      }
+      render();
+    }
+
+    function handleKey(str, key = {}) {
+      const slashMatches = getSlashMatches();
+      if (picker) {
+        if (key.name === "escape") {
+          picker = null;
+          return render();
+        }
+        if (key.name === "up") {
+          picker.selected = Math.max(0, picker.selected - 1);
+          return render();
+        }
+        if (key.name === "down") {
+          picker.selected = Math.min(picker.items.length - 1, picker.selected + 1);
+          return render();
+        }
+        if (key.name === "return") {
+          const selected = picker.items[picker.selected];
+          const onSelect = picker.onSelect;
+          picker = null;
+          Promise.resolve(onSelect?.(selected.value)).then((message) => {
+            if (message) {
+              pushMessage("assistant", message);
+            }
+            render();
+          });
+          return;
+        }
+        return;
+      }
+      if (key.ctrl && key.name === "c") return cleanup();
+      if (key.ctrl && key.name === "l") return render();
+      if (key.ctrl && key.name === "p") {
+        activity = "Command palette not wired yet";
+        return render();
+      }
+      if (key.name === "escape" && busy) {
+        activity = "Interrupt requested";
+        currentAbortController?.abort();
+        return render();
+      }
+      if (key.name === "pageup") {
+        scrollBy(-8);
+        return render();
+      }
+      if (key.name === "pagedown") {
+        scrollBy(8);
+        return render();
+      }
+      if (key.name === "up") {
+        if (slashMatches.length) {
+          slashIndex = Math.max(0, slashIndex - 1);
+          return render();
+        }
+        if (input || historyIndex !== -1 || promptHistory.length) browseHistory(1);
+        else scrollBy(-3);
+        return render();
+      }
+      if (key.name === "down") {
+        if (slashMatches.length) {
+          slashIndex = Math.min(slashMatches.length - 1, slashIndex + 1);
+          return render();
+        }
+        if (historyIndex !== -1 || input) browseHistory(-1);
+        else scrollBy(3);
+        return render();
+      }
+      if (key.name === "return") {
+        if (slashMatches.length) {
+          const selected = slashMatches[slashIndex];
+          if (input.trim() !== selected.command) {
+            input = selected.command;
+            if (selected.command === "/model") input += " ";
+            return render();
+          }
+        }
+        return submit();
+      }
+      if (key.name === "backspace") {
+        input = input.slice(0, -1);
+        historyIndex = -1;
+        if (!input.startsWith("/")) slashIndex = 0;
+        return render();
+      }
+      if (key.name === "tab") {
+        activity = "Agent switching UI not wired yet";
+        return render();
+      }
+      if (mode === "session" && key.name === "left") {
+        selectedGroup = Math.max(1, selectedGroup - 1);
+        return render();
+      }
+      if (mode === "session" && key.name === "right") {
+        selectedGroup += 1;
+        return render();
+      }
+      if (typeof str === "string" && !key.ctrl && !key.meta) {
+        input += str;
+        historyIndex = -1;
+        if (input.startsWith("/")) slashIndex = 0;
+        return render();
+      }
+    }
+
+    function onData(chunk) {
+      inputBuffer += chunk.toString("utf8");
+
+      while (inputBuffer.length) {
+        const mouse = parseMousePrefix(inputBuffer);
+        if (mouse) {
+          inputBuffer = inputBuffer.slice(mouse.raw.length);
+          handleMouse(mouse);
+          continue;
+        }
+
+        if (inputBuffer.startsWith("\u0003")) {
+          inputBuffer = inputBuffer.slice(1);
+          cleanup("interrupt");
+          return;
+        }
+        if (inputBuffer.startsWith("\u000c")) {
+          inputBuffer = inputBuffer.slice(1);
+          render();
+          continue;
+        }
+        if (inputBuffer.startsWith("\u0010")) {
+          inputBuffer = inputBuffer.slice(1);
+          activity = "Command palette not wired yet";
+          render();
+          continue;
+        }
+        if (inputBuffer.startsWith("\t")) {
+          inputBuffer = inputBuffer.slice(1);
+          handleKey("", { name: "tab" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\r")) {
+          inputBuffer = inputBuffer.slice(1);
+          handleKey("", { name: "return" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u007f")) {
+          inputBuffer = inputBuffer.slice(1);
+          handleKey("", { name: "backspace" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b[A")) {
+          inputBuffer = inputBuffer.slice(3);
+          handleKey("", { name: "up" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b[B")) {
+          inputBuffer = inputBuffer.slice(3);
+          handleKey("", { name: "down" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b[C")) {
+          inputBuffer = inputBuffer.slice(3);
+          handleKey("", { name: "right" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b[D")) {
+          inputBuffer = inputBuffer.slice(3);
+          handleKey("", { name: "left" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b[5~")) {
+          inputBuffer = inputBuffer.slice(4);
+          handleKey("", { name: "pageup" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b[6~")) {
+          inputBuffer = inputBuffer.slice(4);
+          handleKey("", { name: "pagedown" });
+          continue;
+        }
+        if (inputBuffer.startsWith("\u001b")) {
+          if (/^\u001b\[<[\d;Mm]*$/.test(inputBuffer)) {
+            return;
+          }
+          inputBuffer = inputBuffer.slice(1);
+          handleKey("", { name: "escape" });
+          continue;
+        }
+
+        const char = [...inputBuffer][0];
+        const size = char.length;
+        inputBuffer = inputBuffer.slice(size);
+        if (char >= " " || char === "\n") {
+          handleKey(char, { name: char });
+        }
+      }
+    }
+
+    process.stdin.on("data", onData);
+    process.stdout.on("resize", render);
+    render();
+  });
+}