bonecode 1.1.0 → 1.2.1

package/src/tui.ts

@@ -1,19 +1,16 @@
-/**
- * BoneCode TUI — styled after OpenCode's terminal interface
+/**
+ * BoneCode TUI — terminal interface modeled after OpenCode
+ *
+ * Three core behaviours:
+ *   1. Tool activity is displayed as concise status lines
+ *      (← Edit src/foo.ts, → Read package.json, $ npm test) — never raw code dumps.
+ *      Assistant text is shown inline; tool calls and tool outputs are summarized.
+ *
+ *   2. Typing "/" shows an inline command menu above the prompt with
+ *      arrow-key selection and tab/enter to insert.
  *
- * Layout:
- *   ┌─────────────────────────────────────────────────┐
- *   │  [message history — scrolls up]                 │
- *   │  ┃ User message (left border, panel bg)         │
- *   │     ← tool  $ shell  → read  ✱ glob            │
- *   │     response text                               │
- *   │     ▣  Build · model · 2.1s                     │
- *   ├─────────────────────────────────────────────────┤
- *   │  ┃ [input textarea]                             │
- *   │  ┃ Build · model                                │
- *   │  ╹▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀  │
- *   │  ~/project/dir              esc interrupt        │
- *   └─────────────────────────────────────────────────┘
+ *   3. Ctrl+C aborts the in-flight LLM stream by aborting the fetch
+ *      AND notifying the server to cancel the agent loop.
  */
 
 import * as path from "path";
@@ -24,37 +21,36 @@ import * as http from "http";
 // ─── ANSI ─────────────────────────────────────────────────────────────────────
 
 const ESC = "\x1b";
-const R    = `${ESC}[0m`;       // reset
-const BOLD = `${ESC}[1m`;
-const DIM  = `${ESC}[2m`;
-const CYAN = `${ESC}[96m`;      // bright cyan  — primary accent
-const GREEN= `${ESC}[92m`;      // bright green — success
-const YELLOW=`${ESC}[93m`;      // warning
-const RED  = `${ESC}[91m`;      // error
-const GRAY = `${ESC}[90m`;      // textMuted
-const WHITE= `${ESC}[97m`;      // text
-const BG_PANEL = `${ESC}[48;5;235m`; // backgroundPanel
-const BG_ELEM  = `${ESC}[48;5;237m`; // backgroundElement (input area)
-
-// Box-drawing — OpenCode uses exactly these
-const VERT  = "┃";   // U+2503 heavy vertical — left border on messages/prompt
-const CORN  = "╹";   // U+2579 heavy up — bottom-left corner of prompt box
-const SHADE = "▀";   // upper half block — decorative shadow line under prompt
-const BLOCK = "▣";   // U+25A3 — end-of-turn marker
-const ARROW_R = "→"; // read tool
-const ARROW_L = "←"; // write/edit tool
-const DOLLAR  = "$"; // shell tool
-const STAR    = "✱"; // glob/grep tool
-const PCT     = "%"; // webfetch tool
-const GEAR    = "⚙"; // generic tool
-const THINK   = "▶"; // collapsed thinking
-
-function cols() { return process.stdout.columns || 80; }
+const R     = `${ESC}[0m`;
+const BOLD  = `${ESC}[1m`;
+const DIM   = `${ESC}[2m`;
+const CYAN  = `${ESC}[96m`;
+const GREEN = `${ESC}[92m`;
+const YELLOW= `${ESC}[93m`;
+const RED   = `${ESC}[91m`;
+const GRAY  = `${ESC}[90m`;
+const WHITE = `${ESC}[97m`;
+const BLUE  = `${ESC}[94m`;
+
+// Box drawing
+const VERT  = "┃";
+const CORN  = "╹";
+const SHADE = "▀";
+const BLOCK = "▣";
+const ARROW_R = "→";
+const ARROW_L = "←";
+const DOLLAR  = "$";
+const STAR    = "✱";
+const PCT     = "%";
+const GEAR    = "⚙";
+const HASH    = "#";
+
+function cols(): number { return process.stdout.columns || 80; }
 function out(s: string) { process.stdout.write(s); }
 function nl(s = "") { process.stdout.write(s + "\n"); }
+function clearLine() { out(`\r${ESC}[2K`); }
 
 // ─── Logo ─────────────────────────────────────────────────────────────────────
-// "BONECODE" in block characters
 
 function printLogo() {
   nl();
@@ -64,16 +60,42 @@ function printLogo() {
   nl();
 }
 
-// ─── Config ───────────────────────────────────────────────────────────────────
+// ─── Package version ──────────────────────────────────────────────────────────
 
-const PKG_ROOT = path.resolve(__dirname, "..");
+const PKG_ROOT = (() => {
+  const fromSrc = path.resolve(__dirname, "..");
+  const fromDist = path.resolve(__dirname, "..", "..");
+  if (fs.existsSync(path.join(fromDist, "package.json"))) return fromDist;
+  return fromSrc;
+})();
 
 function getVersion(): string {
   try { return JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8")).version; }
   catch { return "0.0.0"; }
 }
 
-// ─── @file autocomplete ───────────────────────────────────────────────────────
+// ─── Slash command catalog ────────────────────────────────────────────────────
+
+interface Command {
+  name: string;
+  description: string;
+  args?: string;
+}
+
+const COMMANDS: Command[] = [
+  { name: "/new",        description: "Start a new session" },
+  { name: "/session",    description: "Show current session ID" },
+  { name: "/sessions",   description: "List recent sessions" },
+  { name: "/model",      description: "Switch model",          args: "<provider/model>" },
+  { name: "/provider",   description: "Switch provider",       args: "<id>" },
+  { name: "/providers",  description: "List all providers" },
+  { name: "/clear",      description: "Clear screen" },
+  { name: "/history",    description: "Show last 10 prompts" },
+  { name: "/help",       description: "Show this help" },
+  { name: "/exit",       description: "Exit BoneCode" },
+];
+
+// ─── @file autocomplete helpers ───────────────────────────────────────────────
 
 const IGNORED_DIRS = new Set([
   "node_modules", ".git", "dist", "build", ".next", "__pycache__",
@@ -109,29 +131,19 @@ function listFiles(worktree: string, prefix: string): string[] {
   return results.sort();
 }
 
-// ─── Completers ───────────────────────────────────────────────────────────────
-
-const COMMANDS = [
-  "/new", "/session", "/model", "/provider", "/providers",
-  "/clear", "/history", "/help", "/exit", "/quit",
-];
-
 function buildCompleter(worktree: string) {
   return (line: string): [string[], string] => {
-    // /command autocomplete
     if (line.startsWith("/")) {
-      const matches = COMMANDS.filter(c => c.startsWith(line));
+      // Tab-complete commands too (in addition to the inline menu)
+      const matches = COMMANDS.map(c => c.name).filter(c => c.startsWith(line));
       return [matches, line];
     }
-
-    // @file autocomplete
     const atIdx = line.lastIndexOf("@");
     if (atIdx !== -1) {
       const prefix = line.slice(atIdx + 1);
       const completions = listFiles(worktree, prefix).map(f => line.slice(0, atIdx + 1) + f);
       return [completions, line];
     }
-
     return [[], line];
   };
 }
@@ -156,6 +168,12 @@ async function waitForServer(port: number, maxMs = 30_000): Promise<boolean> {
 
 // ─── API ──────────────────────────────────────────────────────────────────────
 
+async function apiGet<T>(url: string, token: string): Promise<T> {
+  const r = await fetch(url, { headers: { "Authorization": `Bearer ${token}` } });
+  if (!r.ok) throw new Error(`API ${r.status}`);
+  return r.json() as Promise<T>;
+}
+
 async function apiPost(url: string, body: object, token: string): Promise<Response> {
   return fetch(url, {
     method: "POST",
@@ -164,10 +182,8 @@ async function apiPost(url: string, body: object, token: string): Promise<Respon
   });
 }
 
-async function apiGet<T>(url: string, token: string): Promise<T> {
-  const r = await fetch(url, { headers: { "Authorization": `Bearer ${token}` } });
-  if (!r.ok) throw new Error(`API ${r.status}`);
-  return r.json() as Promise<T>;
+async function apiDelete(url: string, token: string): Promise<void> {
+  await fetch(url, { method: "DELETE", headers: { "Authorization": `Bearer ${token}` } });
 }
 
 async function createSession(port: number, token: string, worktree: string, title: string): Promise<string> {
@@ -178,6 +194,172 @@ async function createSession(port: number, token: string, worktree: string, titl
   return sess.id;
 }
 
+// ─── Tool display rules — modeled after opencode's tool.ts ────────────────────
+
+interface ToolDisplay {
+  icon: string;
+  color: string;
+  title: string;
+  detail?: string;
+}
+
+function relPath(p: string | undefined, worktree: string): string {
+  if (!p) return "";
+  try {
+    if (path.isAbsolute(p)) {
+      const rel = path.relative(worktree, p);
+      if (!rel.startsWith("..")) return rel.replace(/\\/g, "/");
+    }
+    return p.replace(/\\/g, "/");
+  } catch { return p; }
+}
+
+function describeTool(toolName: string, input: any, worktree: string): ToolDisplay {
+  const n = (toolName || "").toLowerCase();
+  const inp = input || {};
+
+  // Map BoneCode's tool names AND opencode's names
+  const isWrite = n === "write" || n === "write_file";
+  const isEdit = n === "edit" || n === "edit_file";
+  const isRead = n === "read" || n === "read_file";
+  const isShell = n === "bash" || n === "shell" || n === "run_command";
+  const isGlob = n === "glob";
+  const isGrep = n === "grep" || n === "search_files";
+  const isList = n === "list_directory" || n === "list" || n === "ls";
+  const isWebfetch = n === "webfetch";
+  const isWebsearch = n === "websearch";
+  const isPatch = n === "apply_patch" || n === "patch";
+  const isTodo = n === "todo_write" || n === "todowrite" || n === "todo";
+  const isTask = n === "task" || n === "subagent";
+
+  if (isWrite) {
+    return { icon: ARROW_L, color: CYAN, title: "Write", detail: relPath(inp.path || inp.filePath, worktree) };
+  }
+  if (isEdit) {
+    return { icon: ARROW_L, color: CYAN, title: "Edit", detail: relPath(inp.path || inp.filePath, worktree) };
+  }
+  if (isPatch) {
+    return { icon: PCT, color: CYAN, title: "Patch", detail: inp.patch ? `${String(inp.patch).split("\n").length} lines` : "" };
+  }
+  if (isRead) {
+    let detail = relPath(inp.path || inp.filePath, worktree);
+    if (inp.start_line || inp.end_line) {
+      detail += ` ${GRAY}[${inp.start_line || 1}-${inp.end_line || ""}]${R}`;
+    }
+    return { icon: ARROW_R, color: GRAY, title: "Read", detail };
+  }
+  if (isShell) {
+    const cmd = String(inp.command || "").trim();
+    const short = cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+    return { icon: DOLLAR, color: YELLOW, title: short || "Shell" };
+  }
+  if (isGlob) {
+    return { icon: STAR, color: GRAY, title: "Glob", detail: inp.pattern || "" };
+  }
+  if (isGrep) {
+    const pattern = inp.pattern || "";
+    const glob = inp.glob ? ` in ${inp.glob}` : "";
+    return { icon: STAR, color: GRAY, title: "Grep", detail: `"${pattern}"${glob}` };
+  }
+  if (isList) {
+    return { icon: ARROW_R, color: GRAY, title: "List", detail: relPath(inp.path, worktree) };
+  }
+  if (isWebfetch) {
+    return { icon: PCT, color: BLUE, title: "WebFetch", detail: inp.url || "" };
+  }
+  if (isWebsearch) {
+    return { icon: PCT, color: BLUE, title: "WebSearch", detail: inp.query ? `"${inp.query}"` : "" };
+  }
+  if (isTodo) {
+    const todos = Array.isArray(inp.todos) ? inp.todos : [];
+    const done = todos.filter((t: any) => t.status === "completed").length;
+    return { icon: HASH, color: GRAY, title: "Todos", detail: `${done}/${todos.length} done` };
+  }
+  if (isTask) {
+    return { icon: HASH, color: CYAN, title: "Task", detail: inp.description || "" };
+  }
+
+  // Fallback
+  return { icon: GEAR, color: GRAY, title: toolName };
+}
+
+function renderToolStart(d: ToolDisplay) {
+  const detail = d.detail ? ` ${GRAY}${d.detail}${R}` : "";
+  nl(`   ${d.color}${d.icon}${R} ${WHITE}${d.title}${R}${detail}`);
+}
+
+function renderToolDone(d: ToolDisplay, ms?: number) {
+  const detail = d.detail ? ` ${GRAY}${d.detail}${R}` : "";
+  const time = ms !== undefined ? `  ${GRAY}${(ms / 1000).toFixed(1)}s${R}` : "";
+  // Replace the "..." with a checkmark (or just write a new line if not interactive)
+  nl(`   ${GREEN}✓${R} ${GRAY}${d.title}${R}${detail}${time}`);
+}
+
+function renderToolError(d: ToolDisplay, err: string) {
+  const detail = d.detail ? ` ${GRAY}${d.detail}${R}` : "";
+  nl(`   ${RED}✗${R} ${GRAY}${d.title}${R}${detail}  ${RED}${err}${R}`);
+}
+
+// ─── User message rendering ───────────────────────────────────────────────────
+
+function renderUserMessage(text: string) {
+  nl();
+  for (const line of text.split("\n")) {
+    nl(`${GRAY}${VERT}${R}  ${WHITE}${line}${R}`);
+  }
+  nl();
+}
+
+function renderTurnEnd(model: string, elapsedMs: number, interrupted: boolean) {
+  const elapsed = (elapsedMs / 1000).toFixed(1);
+  const dur = interrupted ? `${YELLOW}interrupted${R}` : `${GRAY}${elapsed}s${R}`;
+  nl();
+  nl(`   ${CYAN}${BLOCK}${R}  ${WHITE}Build${R}${GRAY} · ${model} · ${R}${dur}`);
+}
+
+// ─── Help / providers / commands menu ─────────────────────────────────────────
+
+function printHelp() {
+  nl();
+  nl(`${CYAN}${BOLD}BoneCode${R} ${GRAY}commands${R}`);
+  nl();
+  for (const c of COMMANDS) {
+    const args = c.args ? ` ${GRAY}${c.args}${R}` : "";
+    nl(`  ${CYAN}${c.name.padEnd(12)}${R}${args.padEnd(20)}  ${GRAY}${c.description}${R}`);
+  }
+  nl();
+  nl(`  ${CYAN}Ctrl+C${R}        ${GRAY}Interrupt current request${R}`);
+  nl(`  ${CYAN}Ctrl+D${R}        ${GRAY}Exit BoneCode${R}`);
+  nl(`  ${CYAN}↑ / ↓${R}         ${GRAY}Prompt history${R}`);
+  nl(`  ${CYAN}@<path>${R}       ${GRAY}Attach a file (Tab completes)${R}`);
+  nl();
+}
+
+async function fetchProviders(port: number, token: string): Promise<any[]> {
+  try { return await apiGet<any[]>(`http://localhost:${port}/v2/provider`, token); }
+  catch { return []; }
+}
+
+function printProviders(providers: any[], currentProvider: string) {
+  const width = cols();
+  nl();
+  nl(`${CYAN}${BOLD}Providers${R}`);
+  nl(`${GRAY}${"─".repeat(Math.min(width, 56))}${R}`);
+  for (const p of providers) {
+    const active = p.id === currentProvider;
+    const dot = active ? `${GREEN}●${R}` : `${GRAY}○${R}`;
+    const free = p.free ? ` ${GREEN}free${R}` : "";
+    const local = p.id === "local" ? ` ${CYAN}local config${R}` : "";
+    nl(`  ${dot} ${active ? CYAN + BOLD : WHITE}${p.id}${R}${free}${local}  ${GRAY}${p.name}${R}`);
+    if (p.freeNote) nl(`       ${GRAY}${p.freeNote}${R}`);
+    if (p.models?.length) nl(`       ${GRAY}${p.models.slice(0, 3).join("  ")}${R}`);
+    if (p.keyEnv) nl(`       ${GRAY}${p.keyEnv}${R}`);
+  }
+  nl(`${GRAY}${"─".repeat(Math.min(width, 56))}${R}`);
+  nl(`  ${GRAY}/provider <id>   /model <id>${R}`);
+  nl();
+}
+
 // ─── Streaming ────────────────────────────────────────────────────────────────
 
 interface StreamResult {
@@ -188,15 +370,155 @@ interface StreamResult {
   interrupted: boolean;
 }
 
+interface ToolTrack {
+  callId: string;
+  display: ToolDisplay;
+  startedAt: number;
+}
+
+/**
+ * Stateful code-fence collapser.
+ *
+ * The LLM streams text token-by-token, including ```python\n...\n``` blocks.
+ * We don't want to dump that raw to the terminal because:
+ *   (a) The code is going to be saved via a tool call anyway, so showing it
+ *       twice (raw stream + saved file path) is redundant.
+ *   (b) It can be 100s of lines long and overwhelms the TUI.
+ *
+ * Strategy: buffer everything between ``` and ```. When the closing fence
+ * arrives, emit a one-line marker like  [code: python, 42 lines]
+ * instead of the buffered content.
+ *
+ * State machine:
+ *   "text"  — pass deltas through verbatim (with partial-fence detection)
+ *   "fence" — buffer everything; emit marker on close fence
+ */
+function makeCodeFenceCollapser() {
+  let mode: "text" | "fence" = "text";
+  let lang = "";
+  let buffered = ""; // bytes accumulated inside a fence
+  let pending = "";  // partial-fence buffer (when we see backticks but don't know yet)
+
+  const lines = (s: string) => s.split("\n").length;
+
+  function flushPending(): string {
+    const out = pending;
+    pending = "";
+    return out;
+  }
+
+  return {
+    feed(chunk: string): string {
+      let result = "";
+      let i = 0;
+      const buf = pending + chunk;
+      pending = "";
+
+      while (i < buf.length) {
+        if (mode === "text") {
+          // Look for ``` to enter fence mode
+          const fenceIdx = buf.indexOf("```", i);
+          if (fenceIdx === -1) {
+            // No fence in remaining text — emit it all, but hold the last 2 chars
+            // in case they're part of an upcoming fence.
+            const safeEnd = Math.max(i, buf.length - 2);
+            result += buf.slice(i, safeEnd);
+            pending = buf.slice(safeEnd);
+            i = buf.length;
+            break;
+          }
+          // Emit text up to the fence
+          result += buf.slice(i, fenceIdx);
+          // Read the language (everything until newline)
+          const nlIdx = buf.indexOf("\n", fenceIdx + 3);
+          if (nlIdx === -1) {
+            // Don't have the full opening line yet — buffer
+            pending = buf.slice(fenceIdx);
+            i = buf.length;
+            break;
+          }
+          lang = buf.slice(fenceIdx + 3, nlIdx).trim() || "code";
+          i = nlIdx + 1;
+          mode = "fence";
+          buffered = "";
+          // Print a leading marker (will be amended when we close)
+          result += `${GRAY}┃ code: ${lang}…${R}`;
+          continue;
+        }
+
+        // mode === "fence" — look for closing ```
+        const closeIdx = buf.indexOf("```", i);
+        if (closeIdx === -1) {
+          buffered += buf.slice(i);
+          // Hold last 2 chars in case they're part of an upcoming close fence
+          const safeEnd = Math.max(i, buf.length - 2);
+          buffered = buffered.slice(0, buffered.length - (buf.length - safeEnd));
+          pending = buf.slice(safeEnd);
+          i = buf.length;
+          break;
+        }
+        // Closing fence found
+        buffered += buf.slice(i, closeIdx);
+        const lineCount = lines(buffered.replace(/\n+$/, ""));
+        // Replace the placeholder we already wrote with the final marker.
+        // Carriage return + clear line + reprint marker.
+        result += `\r${ESC}[2K   ${GRAY}┃ code: ${lang}, ${lineCount} line${lineCount === 1 ? "" : "s"}${R}\n`;
+        i = closeIdx + 3;
+        // Skip optional newline after closing fence
+        if (buf[i] === "\n") i++;
+        mode = "text";
+        lang = "";
+        buffered = "";
+      }
+
+      return result;
+    },
+    flush(): string {
+      const tail = flushPending();
+      if (mode === "fence") {
+        // Stream ended mid-fence — close it with an approximate count
+        const lineCount = lines(buffered.replace(/\n+$/, ""));
+        mode = "text";
+        return tail + `\r${ESC}[2K   ${GRAY}┃ code: ${lang}, ${lineCount}+ lines${R}\n`;
+      }
+      return tail;
+    },
+  };
+}
+
 async function streamPrompt(opts: {
   port: number; token: string; sessionId: string;
   model: string; provider: string; message: string;
-  abortSignal: AbortSignal; onDelta: (t: string) => void;
+  worktree: string;
+  abortSignal: AbortSignal;
 }): Promise<StreamResult> {
-  const { port, token, sessionId, model, provider, message, abortSignal, onDelta } = opts;
+  const { port, token, sessionId, model, provider, message, worktree, abortSignal } = opts;
   const t0 = Date.now();
   let fullText = "";
   let tokens = 0;
+  let inAssistantText = false;
+  let tools = new Map<string, ToolTrack>();
+
+  // Code-fence collapser — replaces ```...``` blocks with [code: lang, N lines]
+  // markers across delta boundaries.
+  const fence = makeCodeFenceCollapser();
+  const collapseCodeFences = (chunk: string): string => fence.feed(chunk);
+
+  // Track which message the deltas belong to so we can detect tool boundaries
+  // The compat adapter emits these event types:
+  //   part.delta       — text chunk
+  //   tool.requested   — tool call started
+  //   message.updated  — message saved
+  //   session.updated  — session state changed
+  //   error            — error event
+
+  const flushTextLine = () => {
+    if (inAssistantText) {
+      // Make sure assistant text ends with a newline before the next thing
+      if (fullText && !fullText.endsWith("\n")) out("\n");
+      inAssistantText = false;
+    }
+  };
 
   try {
     const r = await fetch(`http://localhost:${port}/v2/session/${sessionId}/prompt`, {
@@ -205,148 +527,201 @@ async function streamPrompt(opts: {
       body: JSON.stringify({ content: message, modelID: model, providerID: provider }),
       signal: abortSignal,
     });
-    if (!r.ok) return { text: "", tokens: 0, elapsedMs: Date.now() - t0, error: `HTTP ${r.status}: ${await r.text()}`, interrupted: false };
+    if (!r.ok) {
+      return { text: "", tokens: 0, elapsedMs: Date.now() - t0, error: `HTTP ${r.status}: ${await r.text()}`, interrupted: false };
+    }
 
     const reader = r.body!.getReader();
     const dec = new TextDecoder();
     let buf = "";
+
     while (true) {
       const { value, done } = await reader.read();
       if (done) break;
       buf += dec.decode(value, { stream: true });
       const lines = buf.split("\n");
       buf = lines.pop() || "";
+
       for (const raw of lines) {
         if (!raw.startsWith("data: ")) continue;
         const json = raw.slice(6).trim();
         if (!json || json === "[DONE]") continue;
+
         try {
           const ev = JSON.parse(json);
+
+          // Text delta — assistant is generating prose
           if (ev.type === "part.delta" && ev.delta?.type === "text") {
-            fullText += ev.delta.text;
-            onDelta(ev.delta.text);
+            const text = ev.delta.text || "";
+            if (!text) continue;
+            if (!inAssistantText) {
+              // Start of assistant text — print the indent prefix once
+              out(`   `);
+              inAssistantText = true;
+            }
+            // Process the delta through the code-fence collapser so streaming
+            // code blocks appear as "[code: lang]" placeholders instead of
+            // dumping raw source.
+            const piece = collapseCodeFences(text);
+            // Print with leading-newline indenting (so each new line gets the 3-space prefix)
+            const indented = piece.replace(/\n/g, `\n   `);
+            out(indented);
+            fullText += text;
+            continue;
+          }
+
+          // Tool requested — show concise activity line
+          if (ev.type === "tool.requested") {
+            flushTextLine();
+            const callId = ev.tool_call_id || ev.id || `${ev.tool_name}-${Date.now()}`;
+            const display = describeTool(ev.tool_name || "tool", ev.tool_input || {}, worktree);
+            tools.set(callId, { callId, display, startedAt: Date.now() });
+            renderToolStart(display);
+            continue;
           }
-          if (ev.type === "error") return { text: fullText, tokens, elapsedMs: Date.now() - t0, error: ev.properties?.message || "error", interrupted: false };
-        } catch {}
+
+          // Tool completed
+          if (ev.type === "tool.completed" || ev.type === "tool.success") {
+            flushTextLine();
+            const callId = ev.tool_call_id || ev.id || "";
+            const tracked = tools.get(callId);
+            if (tracked) {
+              const ms = Date.now() - tracked.startedAt;
+              renderToolDone(tracked.display, ms);
+              tools.delete(callId);
+            }
+            continue;
+          }
+
+          // Tool failed
+          if (ev.type === "tool.failed" || ev.type === "tool.error") {
+            flushTextLine();
+            const callId = ev.tool_call_id || ev.id || "";
+            const tracked = tools.get(callId);
+            const err = ev.error || ev.message || "failed";
+            if (tracked) {
+              renderToolError(tracked.display, err);
+              tools.delete(callId);
+            } else {
+              nl(`   ${RED}✗ ${err}${R}`);
+            }
+            continue;
+          }
+
+          // Retry notification
+          if (ev.type === "session.retry") {
+            flushTextLine();
+            nl(`   ${YELLOW}⟳ Retry ${ev.attempt || ""}: ${ev.message || ""}${R}`);
+            continue;
+          }
+
+          // Server-side error
+          if (ev.type === "error") {
+            flushTextLine();
+            return {
+              text: fullText,
+              tokens,
+              elapsedMs: Date.now() - t0,
+              error: ev.properties?.message || "error",
+              interrupted: false,
+            };
+          }
+
+          // Compaction
+          if (ev.type === "session.compacted") {
+            flushTextLine();
+            nl(`   ${BLUE}⊕ Context compacted${R}`);
+            continue;
+          }
+        } catch {
+          // Ignore malformed events
+        }
       }
     }
 
+    flushTextLine();
+
+    // Drain any tools that didn't get a completion event
+    for (const tracked of tools.values()) {
+      const ms = Date.now() - tracked.startedAt;
+      renderToolDone(tracked.display, ms);
+    }
+    tools.clear();
+
+    // Flush any unclosed code fence
+    const tail = fence.flush();
+    if (tail) out(tail);
+
+    // Fetch the final message to get token totals
     try {
       const msgs = await apiGet<any[]>(`http://localhost:${port}/v2/session/${sessionId}/message`, token);
       const last = msgs.filter((m: any) => m.role === "assistant").slice(-1)[0];
       tokens = (last?.tokens?.input || 0) + (last?.tokens?.output || 0);
+      // If we didn't get any text deltas but the stored message has text, render it now
+      if (!fullText && last?.parts) {
+        for (const p of last.parts) {
+          if (p.type === "text" && p.text) {
+            out(`   ${p.text.replace(/\n/g, `\n   `)}\n`);
+            fullText = p.text;
+            break;
+          }
+        }
+      }
     } catch {}
 
     return { text: fullText, tokens, elapsedMs: Date.now() - t0, interrupted: false };
   } catch (e: any) {
-    if (e.name === "AbortError") return { text: fullText, tokens, elapsedMs: Date.now() - t0, interrupted: true };
+    flushTextLine();
+    if (e.name === "AbortError") {
+      return { text: fullText, tokens, elapsedMs: Date.now() - t0, interrupted: true };
+    }
     return { text: fullText, tokens, elapsedMs: Date.now() - t0, error: e.message, interrupted: false };
   }
 }
 
-// ─── Rendering helpers ────────────────────────────────────────────────────────
-
-// User message: ┃ left border, panel background
-function renderUserMessage(text: string) {
-  nl();
-  const lines = text.split("\n");
-  for (const l of lines) {
-    nl(`${GRAY}${VERT}${R}  ${WHITE}${l}${R}`);
-  }
-  nl();
-}
-
-// Tool call line — inline style matching OpenCode
-function renderToolCall(toolName: string, summary: string, done: boolean) {
-  const icon = toolIcon(toolName);
-  const color = done ? GRAY : WHITE;
-  nl(`   ${color}${icon} ${summary}${R}`);
-}
-
-function toolIcon(name: string): string {
-  const n = name.toLowerCase();
-  if (n === "write" || n === "edit" || n === "apply_patch") return ARROW_L;
-  if (n === "read") return ARROW_R;
-  if (n === "shell" || n === "bash") return DOLLAR;
-  if (n === "glob" || n === "grep") return STAR;
-  if (n === "webfetch") return PCT;
-  return GEAR;
-}
-
-// End-of-turn marker: ▣  Build · model · 2.1s
-function renderTurnEnd(model: string, elapsedMs: number, interrupted: boolean) {
-  const elapsed = (elapsedMs / 1000).toFixed(1);
-  const dur = interrupted ? `${YELLOW}interrupted${R}` : `${GRAY}${elapsed}s${R}`;
-  nl();
-  nl(`   ${CYAN}${BLOCK}${R}  ${WHITE}Build${R}${GRAY} · ${model} · ${R}${dur}`);
-}
-
-// Prompt box — matches OpenCode's input area design
-function renderPromptBox(model: string, provider: string, sessionId: string, worktree: string) {
-  const width = cols();
-  const dir = worktree.replace(/\\/g, "/").replace(/^.*\/([^/]+\/[^/]+)$/, "$1"); // last 2 path segments
-  const modelLabel = `${WHITE}Build${R}${GRAY} · ${model}${R}`;
-  const shadow = SHADE.repeat(Math.min(width - 2, 60));
+// ─── Slash command menu — inline, above the prompt ────────────────────────────
 
-  nl();
-  nl(`${GRAY}${VERT}${R}`);
-  nl(`${GRAY}${VERT}${R}  ${GRAY}${DIM}Type a message...${R}`);
-  nl(`${GRAY}${VERT}${R}`);
-  nl(`${GRAY}${VERT}${R}  ${modelLabel}`);
-  nl(`${GRAY}${CORN}${shadow}${R}`);
-  nl(`${GRAY}${dir}${R}                                    ${GRAY}esc ${DIM}interrupt${R}`);
+interface MenuState {
+  visible: boolean;
+  options: Command[];
+  selected: number;
+  rowsRendered: number;
 }
 
-// Help text
-function printHelp() {
-  nl();
-  nl(`${CYAN}${BOLD}BoneCode${R} ${GRAY}commands${R}`);
-  nl();
-  nl(`  ${CYAN}/new${R}                  New session`);
-  nl(`  ${CYAN}/session${R}              Show session ID`);
-  nl(`  ${CYAN}/model <id>${R}           Switch model`);
-  nl(`  ${CYAN}/provider <id>${R}        Switch provider`);
-  nl(`  ${CYAN}/providers${R}            List all providers`);
-  nl(`  ${CYAN}/clear${R}                Clear screen`);
-  nl(`  ${CYAN}/history${R}              Last 10 prompts`);
-  nl(`  ${CYAN}/exit${R}                 Exit`);
-  nl();
-  nl(`  ${CYAN}Ctrl+C${R}                Interrupt current request`);
-  nl(`  ${CYAN}Ctrl+D${R}                Exit`);
-  nl(`  ${CYAN}↑ / ↓${R}                 Prompt history`);
-  nl(`  ${CYAN}@<path>${R}               Attach file — Tab to autocomplete`);
-  nl();
-  nl(`  ${GRAY}Model shorthand:  /model groq/llama-3.3-70b-versatile${R}`);
-  nl(`  ${GRAY}Local config:     /model local${R}`);
-  nl();
+function filterCommands(query: string): Command[] {
+  if (!query || query === "/") return COMMANDS;
+  const q = query.toLowerCase();
+  return COMMANDS.filter(c => c.name.toLowerCase().startsWith(q));
 }
 
-async function fetchProviders(port: number, token: string): Promise<any[]> {
-  try { return await apiGet<any[]>(`http://localhost:${port}/v2/provider`, token); }
-  catch { return []; }
+function renderCommandMenu(state: MenuState): number {
+  if (!state.visible || state.options.length === 0) return 0;
+  const max = Math.min(state.options.length, 8);
+  for (let i = 0; i < max; i++) {
+    const c = state.options[i]!;
+    const selected = i === state.selected;
+    const prefix = selected ? `${CYAN}▌${R} ` : `  `;
+    const name = selected ? `${CYAN}${BOLD}${c.name}${R}` : `${WHITE}${c.name}${R}`;
+    const args = c.args ? ` ${GRAY}${c.args}${R}` : "";
+    const desc = `${GRAY}${c.description}${R}`;
+    nl(`${prefix}${name}${args}  ${desc}`);
+  }
+  if (state.options.length > max) {
+    nl(`  ${GRAY}... ${state.options.length - max} more (keep typing)${R}`);
+    return max + 1;
+  }
+  return max;
 }
 
-function printProviders(providers: any[], currentProvider: string) {
-  const width = cols();
-  nl();
-  nl(`${CYAN}${BOLD}Providers${R}`);
-  nl(`${GRAY}${"─".repeat(Math.min(width, 56))}${R}`);
-  for (const p of providers) {
-    const active = p.id === currentProvider;
-    const dot = active ? `${GREEN}●${R}` : `${GRAY}○${R}`;
-    const free = p.free ? ` ${GREEN}free${R}` : "";
-    const local = p.id === "local" ? ` ${CYAN}local config${R}` : "";
-    nl(`  ${dot} ${active ? CYAN + BOLD : WHITE}${p.id}${R}${free}${local}  ${GRAY}${p.name}${R}`);
-    if (p.freeNote) nl(`       ${GRAY}${p.freeNote}${R}`);
-    if (p.models?.length) nl(`       ${GRAY}${p.models.slice(0, 3).join("  ")}${R}`);
-    if (p.keyEnv) nl(`       ${GRAY}${p.keyEnv}${R}`);
+function clearMenu(rows: number) {
+  if (rows <= 0) return;
+  // Move up `rows` lines and clear each one
+  for (let i = 0; i < rows; i++) {
+    out(`${ESC}[1A${ESC}[2K`);
   }
-  nl(`${GRAY}${"─".repeat(Math.min(width, 56))}${R}`);
-  nl(`  ${GRAY}/provider <id>   /model <id>${R}`);
-  nl();
 }
 
-// ─── Main TUI ─────────────────────────────────────────────────────────────────
+// ─── Main TUI loop ────────────────────────────────────────────────────────────
 
 export async function runTUI(opts: {
   port: number; token: string; model: string;
@@ -355,98 +730,217 @@ export async function runTUI(opts: {
   let { model, provider } = opts;
   const { port, token, worktree } = opts;
   let sessionId = opts.sessionId || null;
-  let turnCount = 0;
   const history: string[] = [];
   let abort: AbortController | null = null;
   let streaming = false;
 
-  // Create initial session
+  // Initial session
   if (!sessionId) {
     try { sessionId = await createSession(port, token, worktree, "BoneCode Session"); }
-    catch (e: any) { process.stderr.write(`${RED}Failed to create session: ${e.message}${R}\n`); process.exit(1); }
+    catch (e: any) {
+      process.stderr.write(`${RED}Failed to create session: ${e.message}${R}\n`);
+      process.exit(1);
+    }
   }
 
   // Header
   printLogo();
-  const VERSION = getVersion();
-  nl(`  ${GRAY}v${VERSION}  ·  ${model}  ·  ${path.basename(worktree)}${R}`);
-  nl(`  ${GRAY}session ${sessionId!.slice(0, 8)}${R}`);
+  nl(`  ${GRAY}v${getVersion()}  ·  ${model}  ·  ${path.basename(worktree)}${R}`);
+  nl(`  ${GRAY}session ${sessionId.slice(0, 8)}${R}`);
   nl();
-  nl(`  ${GRAY}/help for commands  ·  Ctrl+C interrupt  ·  Ctrl+D exit${R}`);
+  nl(`  ${GRAY}Type ${R}${CYAN}/${R}${GRAY} to see commands  ·  Ctrl+C interrupt  ·  Ctrl+D exit${R}`);
   nl();
-  nl(); // extra blank line — ghost hint uses the line above the prompt
 
+  // ─── Slash command menu state ──────────────────────────────────────────────
+  const menu: MenuState = {
+    visible: false,
+    options: [],
+    selected: 0,
+    rowsRendered: 0,
+  };
+
+  // Set up readline AFTER setting up SIGINT so we control it
   const rl = readline.createInterface({
-    input: process.stdin, output: process.stdout,
-    terminal: true, historySize: 200,
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true,
+    historySize: 200,
     completer: buildCompleter(worktree),
   });
 
   const promptStr = () => `${CYAN}${BOLD}>${R} `;
 
-  const sigint = () => {
+  // ─── Ctrl+C handling ──────────────────────────────────────────────────────
+  // When streaming: abort the request AND notify server
+  // When idle: clear menu/input or hint to use /exit
+  const onSigint = async () => {
     if (streaming && abort) {
       abort.abort();
-      nl(`\n${YELLOW}interrupted${R}`);
-    } else {
-      nl(`\n${GRAY}(Ctrl+D or /exit to quit)${R}`);
+      // Also tell the server to cancel the agent loop
+      try {
+        await fetch(`http://localhost:${port}/v2/session/${sessionId}/cancel`, {
+          method: "POST",
+          headers: { "Authorization": `Bearer ${token}` },
+        });
+      } catch { /* server may not have the endpoint, abort is enough */ }
+      // Don't reprompt here — the streamPrompt finally block will handle UI
+      return;
     }
+
+    // Idle: clear menu if visible, else hint
+    if (menu.visible) {
+      clearMenu(menu.rowsRendered);
+      menu.visible = false;
+      menu.rowsRendered = 0;
+      menu.selected = 0;
+    }
+    out(`\n${GRAY}(Ctrl+D or /exit to quit)${R}\n`);
     rl.setPrompt(promptStr());
     rl.prompt();
   };
-  process.on("SIGINT", sigint);
+
+  // Detach readline's default SIGINT (which closes the line buffer)
+  // and route it to our handler.
+  rl.on("SIGINT", onSigint);
 
   rl.on("close", () => {
-    process.removeListener("SIGINT", sigint);
+    if (streaming && abort) abort.abort();
     nl(`\n${GRAY}Goodbye.${R}`);
     process.exit(0);
   });
 
-  rl.setPrompt(promptStr());
-  rl.prompt();
+  // ─── Live menu update on every keystroke ──────────────────────────────────
+  // We hook into the keypress events of stdin to redraw the menu.
+  // The menu sits ABOVE the prompt line.
+  const stdin: any = (rl as any).input;
+
+  const updateMenu = () => {
+    if (streaming) return;
+
+    const line: string = (rl as any).line || "";
+    const startsWithSlash = line.startsWith("/");
+    const shouldShow = startsWithSlash && !line.includes(" ");
+
+    if (!shouldShow) {
+      if (menu.visible) {
+        // Need to clear the menu — but we need to preserve the current input line.
+        // Strategy: save current line content & cursor, clear menu lines above,
+        // then restore the prompt and content.
+        const cursor = (rl as any).cursor || 0;
+        out(`\r${ESC}[2K`);                // clear current prompt line
+        clearMenu(menu.rowsRendered);       // clear menu lines above
+        menu.visible = false;
+        menu.rowsRendered = 0;
+        menu.selected = 0;
+        // Redraw prompt + line
+        out(promptStr() + line);
+        // Restore cursor position
+        const drawn = line.length;
+        if (cursor < drawn) {
+          out(`${ESC}[${drawn - cursor}D`);
+        }
+      }
+      return;
+    }
 
-  // Ghost-text hint: when user types /x show matching commands above prompt
-  let lastHint = "";
-  (rl as any).input?.on("keypress", (_: any, key: any) => {
+    // Filter and reset selection if list changed
+    const newOptions = filterCommands(line);
+    if (newOptions.length === 0) {
+      // Clear menu if visible
+      if (menu.visible) {
+        const cursor = (rl as any).cursor || 0;
+        out(`\r${ESC}[2K`);
+        clearMenu(menu.rowsRendered);
+        menu.visible = false;
+        menu.rowsRendered = 0;
+        out(promptStr() + line);
+        if (cursor < line.length) out(`${ESC}[${line.length - cursor}D`);
+      }
+      return;
+    }
+
+    // Save current input line
+    const cursor = (rl as any).cursor || 0;
+    out(`\r${ESC}[2K`);                  // clear prompt line
+    clearMenu(menu.rowsRendered);         // clear old menu
+
+    menu.options = newOptions;
+    menu.selected = Math.min(menu.selected, newOptions.length - 1);
+    if (menu.selected < 0) menu.selected = 0;
+    menu.visible = true;
+
+    // Render the menu (each item ends in newline)
+    menu.rowsRendered = renderCommandMenu(menu);
+
+    // Redraw prompt + line
+    out(promptStr() + line);
+    if (cursor < line.length) {
+      out(`${ESC}[${line.length - cursor}D`);
+    }
+  };
+
+  // Capture special keys for menu navigation
+  const onKeypress = (_chunk: any, key: any) => {
     if (!key) return;
-    // Small delay so readline has updated its line buffer
-    setImmediate(() => {
-      const current: string = (rl as any).line || "";
-      if (!current.startsWith("/") || current.includes(" ")) {
-        if (lastHint) {
-          // Clear the hint line
-          process.stdout.write(`${ESC}[s`);           // save cursor
-          process.stdout.write(`${ESC}[1A${ESC}[2K`); // up 1, clear line
-          process.stdout.write(`${ESC}[u`);           // restore cursor
-          lastHint = "";
-        }
+    if (streaming) return;
+
+    if (menu.visible && menu.options.length > 0) {
+      // Arrow up/down navigate the menu
+      if (key.name === "up") {
+        menu.selected = (menu.selected - 1 + menu.options.length) % menu.options.length;
+        updateMenu();
         return;
       }
-      const matches = COMMANDS.filter(c => c.startsWith(current) && c !== current);
-      const hint = matches.length ? matches[0] : "";
-      if (hint === lastHint) return;
-      lastHint = hint;
-      // Print hint above the prompt line
-      process.stdout.write(`${ESC}[s`);           // save cursor
-      process.stdout.write(`${ESC}[1A${ESC}[2K`); // up 1, clear line
-      if (hint) {
-        // Show current typed part normal, rest in grey
-        const ghost = hint.slice(current.length);
-        process.stdout.write(`${promptStr()}${current}${GRAY}${ghost}${R}`);
+      if (key.name === "down") {
+        menu.selected = (menu.selected + 1) % menu.options.length;
+        updateMenu();
+        return;
       }
-      process.stdout.write(`${ESC}[u`);           // restore cursor
-    });
-  });
+      // Tab: replace input with the selected command
+      if (key.name === "tab") {
+        const sel = menu.options[menu.selected];
+        if (sel) {
+          // Replace the line buffer with the command + space
+          (rl as any).line = sel.name + " ";
+          (rl as any).cursor = sel.name.length + 1;
+          updateMenu();
+          out(`\r${ESC}[2K`);
+          out(promptStr() + (rl as any).line);
+        }
+        return;
+      }
+    }
+
+    // Default: trigger menu update on the next tick (after readline updates the buffer)
+    setImmediate(updateMenu);
+  };
+
+  stdin.on("keypress", onKeypress);
+
+  rl.setPrompt(promptStr());
+  rl.prompt();
 
+  // ─── Main input loop ──────────────────────────────────────────────────────
   for await (const rawLine of rl) {
     const text = rawLine.trim();
 
-    if (!text) { rl.setPrompt(promptStr()); rl.prompt(); continue; }
+    // Clear any visible menu before processing
+    if (menu.visible) {
+      menu.visible = false;
+      menu.rowsRendered = 0;
+      menu.selected = 0;
+    }
+
+    if (!text) {
+      rl.setPrompt(promptStr());
+      rl.prompt();
+      continue;
+    }
 
     history.push(text);
     if (history.length > 200) history.shift();
 
-    // ── Commands ──────────────────────────────────────────────────────────────
+    // ── Slash commands ──────────────────────────────────────────────────────
     if (text.startsWith("/")) {
       const parts = text.slice(1).trim().split(/\s+/);
       const cmd = parts[0]?.toLowerCase() || "";
@@ -460,7 +954,6 @@ export async function runTUI(opts: {
         case "new":
           try {
             sessionId = await createSession(port, token, worktree, "New Session");
-            turnCount = 0;
             nl(`${GREEN}✓${R} ${GRAY}session ${sessionId.slice(0, 8)}${R}`);
           } catch (e: any) { nl(`${RED}✗ ${e.message}${R}`); }
           break;
@@ -469,21 +962,35 @@ export async function runTUI(opts: {
           nl(`${GRAY}${sessionId}${R}`);
           break;
 
+        case "sessions": {
+          try {
+            const list = await apiGet<any[]>(`http://localhost:${port}/v2/session?limit=10`, token);
+            if (!list.length) { nl(`${GRAY}No sessions${R}`); break; }
+            nl();
+            for (const s of list) {
+              const active = s.id === sessionId;
+              const dot = active ? `${GREEN}●${R}` : `${GRAY}○${R}`;
+              const t = new Date(s.time?.updated || Date.now()).toLocaleString();
+              nl(`  ${dot} ${WHITE}${(s.title || "untitled").slice(0, 50).padEnd(50)}${R}  ${GRAY}${t}${R}`);
+            }
+            nl();
+          } catch (e: any) { nl(`${RED}✗ ${e.message}${R}`); }
+          break;
+        }
+
         case "model":
           if (args[0]) {
             if (args[0] === "local") {
               provider = process.env.DEFAULT_PROVIDER || "openai_compatible";
               model = process.env.DEFAULT_MODEL || "local-model";
-              nl(`${GREEN}✓${R} ${WHITE}${provider}/${model}${R}`);
             } else if (args[0].includes("/")) {
               const i = args[0].indexOf("/");
               provider = args[0].slice(0, i);
               model = args[0].slice(i + 1);
-              nl(`${GREEN}✓${R} ${WHITE}${provider}/${model}${R}`);
             } else {
               model = args[0];
-              nl(`${GREEN}✓${R} ${WHITE}${provider}/${model}${R}`);
             }
+            nl(`${GREEN}✓${R} ${WHITE}${provider}/${model}${R}`);
           } else {
             nl(`${GRAY}${provider}/${model}${R}`);
           }
@@ -517,7 +1024,7 @@ export async function runTUI(opts: {
           break;
 
         case "history":
-          if (!history.length) { nl(`${GRAY}No history${R}`); }
+          if (!history.length) nl(`${GRAY}No history${R}`);
           else history.slice(-10).forEach((h, i) => nl(`  ${GRAY}${i + 1}.${R} ${h.slice(0, 80)}`));
           break;
 
@@ -527,7 +1034,7 @@ export async function runTUI(opts: {
           break;
 
         default:
-          nl(`${YELLOW}Unknown: /${cmd}${R}  ${GRAY}/help${R}`);
+          nl(`${YELLOW}Unknown: /${cmd}${R}  ${GRAY}Type /help for available commands${R}`);
       }
 
       rl.setPrompt(promptStr());
@@ -535,60 +1042,53 @@ export async function runTUI(opts: {
       continue;
     }
 
-    // ── Prompt ────────────────────────────────────────────────────────────────
-
+    // ── Prompt to the agent ─────────────────────────────────────────────────
     if (!sessionId) {
       try { sessionId = await createSession(port, token, worktree, text.slice(0, 50)); }
-      catch (e: any) { nl(`${RED}✗ ${e.message}${R}`); rl.setPrompt(promptStr()); rl.prompt(); continue; }
+      catch (e: any) {
+        nl(`${RED}✗ ${e.message}${R}`);
+        rl.setPrompt(promptStr());
+        rl.prompt();
+        continue;
+      }
     }
 
-    // Resolve @file mentions
+    // Resolve @file mentions to absolute paths
     const resolved = text.replace(/@([\w./\-]+)/g, (match, fp) => {
       const abs = path.isAbsolute(fp) ? fp : path.resolve(worktree, fp);
       return fs.existsSync(abs) ? `@${abs}` : match;
     });
 
-    // Render user message with ┃ border
-    renderUserMessage(resolved !== text ? `${text} ${GRAY}(files resolved)${R}` : text);
+    renderUserMessage(text);
 
-    // Thinking indicator
-    out(`   ${GRAY}⋯${R}`);
+    // Show "..." spinner so the user knows something is happening
+    out(`   ${GRAY}thinking...${R}`);
 
     rl.pause();
     streaming = true;
     abort = new AbortController();
-    let firstDelta = true;
 
+    const t0 = Date.now();
     const result = await streamPrompt({
-      port, token, sessionId: sessionId!, model, provider,
-      message: resolved, abortSignal: abort.signal,
-      onDelta: (delta) => {
-        if (firstDelta) {
-          // Clear the thinking indicator, print indent once
-          out(`\r${ESC}[2K`);
-          nl();
-          out(`   `);
-          firstDelta = false;
-        }
-        // Strip markdown fences for terminal rendering
-        const clean = delta.replace(/^```\w*\n?/gm, "").replace(/^```\n?/gm, "");
-        if (clean) out(clean);
-      },
+      port, token, sessionId,
+      model, provider,
+      message: resolved,
+      worktree,
+      abortSignal: abort.signal,
     });
 
     streaming = false;
     abort = null;
 
-    if (firstDelta) {
-      // No deltas arrived — clear thinking indicator
-      out(`\r${ESC}[2K`);
+    // Clear the thinking spinner if no output happened
+    if (!result.text && !result.error) {
+      clearLine();
+    } else {
+      // Make sure the next render starts on a clean line
+      const cur = (process.stdout as any).cursor;
+      if (cur && cur.col !== 0) out("\n");
     }
 
-    if (result.text && !result.text.endsWith("\n")) nl();
-
-    turnCount++;
-
-    // End-of-turn marker: ▣  Build · model · 2.1s
     renderTurnEnd(model, result.elapsedMs, result.interrupted);
 
     if (result.error && !result.interrupted) {
@@ -599,9 +1099,10 @@ export async function runTUI(opts: {
 
     rl.resume();
     rl.setPrompt(promptStr());
-    nl(); // blank line for ghost hint
     rl.prompt();
   }
+
+  stdin.removeListener("keypress", onKeypress);
 }
 
 // ─── Entry point ──────────────────────────────────────────────────────────────