thincoder 0.12.11 → 0.12.12

package/src/tui/agent-turn.mjs

@@ -2,11 +2,17 @@ import { runAgent, ContinueError } from "../agent.mjs"
 import { saveSession } from "../session.mjs"
 import { sliceByWidth } from "./render.mjs"
 import { ansi, C } from "./ansi.mjs"
+import { formatToolSummary } from "./tool-summaries.mjs"
+import { ADVISOR_THINKING_PLACEHOLDER } from "../advisor/run.mjs"
 
 /** Tool execution start timestamps (performance.now ms), keyed by tool name. */
 const _toolTicks = Object.create(null)
 
-/** Per-tool streaming preview line limits — tools with verbose output get more lines */
+/** Per-tool streaming preview line limits — tools with verbose output get more lines.
+ *  NOTE: `advisor` is intentionally NOT pruned by the live-line mechanism: its
+ *  streaming returns early (kind-split into _advisorThink/advisorStreaming) and
+ *  is rendered full-length in render-conversation. The entry is kept for
+ *  symmetry with the map's other tools. */
 const LIVE_LINE_LIMITS = {
   bash: 10,
   advisor: 15,
@@ -43,8 +49,7 @@ export async function runAgentTurn(ctx, text) {
   state.status = "Processing..."
   state.streaming = ""
   state.reasoning = ""
-  state.advisorStreaming = ""
-  state._advisorThink = ""
+  state._advisorBlocks = []
   state.subTasks = {}
   state.currentTool = null
   state.processingStarted = Date.now()
@@ -56,6 +61,12 @@ export async function runAgentTurn(ctx, text) {
   }, 1000)
   render()
 
+  // NOTE: advisor buffers (_advisorThink/advisorStreaming) are cleared here too.
+  // Timing safety: onToolResult flushes _advisorThink into history and empties
+  // the buffers BEFORE onTurnEnd can call flushStream (tool result is
+  // dispatched inside executeToolCalls; onTurnEnd fires after the turn loop
+  // resumes). If a future change calls flushStream mid-advisor-execution the
+  // in-progress thinking WOULD be lost — keep the ordering, or flush here too.
   const flushStream = () => {
     if (state.reasoning) {
       const idx = state.lines.length
@@ -77,8 +88,7 @@ export async function runAgentTurn(ctx, text) {
       state._autoExpand.push(idx)
       state.streaming = ""
     }
-    state.advisorStreaming = ""
-    state._advisorThink = ""
+    state._advisorBlocks = []
   }
 
   const callbacks = {
@@ -132,7 +142,10 @@ export async function runAgentTurn(ctx, text) {
         scheduleRender()
         return
       }
-      if (name === "advisor") { state.advisorStreaming = ""; state._advisorThink = "" }
+      // Redundant with flushStream() below (it clears both buffers) — kept as
+      // defense-in-depth so a future flushStream change cannot leak advisor
+      // buffers into the next tool's view.
+      if (name === "advisor") { state._advisorBlocks = [] }
       flushStream()
       ensureAssistantLabel()
       state.currentTool = name
@@ -197,7 +210,37 @@ export async function runAgentTurn(ctx, text) {
         const summary = formatToolSummary(name, result)
         if (summary) pushLine(`  ${summary}`, C.dim)
       }
-      if (name === "advisor") { state.advisorStreaming = ""; state._advisorThink = "" }
+      if (name === "advisor") {
+        // The review's thinking must survive into the conversation history like
+        // the main agent's reasoning (flushStream does for state.reasoning) —
+        // discarding it left the thought process visible only mid-review, then
+        // gone. Flush BEFORE the done line so the block sits above it.
+        // NOTE (rendering): the flushed block has NO "│ " gutter prefix while
+        // the live streaming view adds one — same convention as the main
+        // agent's reasoning (live gutter, history plain). Intentional.
+        const blocks = state._advisorBlocks ?? []
+        if (blocks.length > 0) {
+          // Flush the ordered blocks in sequence — thinking and tool progress
+          // alternate in history exactly as they were emitted. The live
+          // "[thinking…]" placeholders are stripped (wait indicators, not
+          // review content); literal replaceAll of the shared constant can
+          // never drift.
+          const text = blocks
+            .map((b) => b.text.replaceAll(ADVISOR_THINKING_PLACEHOLDER, ""))
+            .join("")
+            .replace(/\n{3,}/g, "\n\n")
+            .trim()
+          if (text) {
+            const idx = state.lines.length
+            pushLine(text, C.reason)
+            // Completed review output stays expanded (user is reading it).
+            state.expandedBlocks ??= new Set()
+            state.expandedBlocks.add("long-" + idx)
+            state._autoExpand ??= []
+            state._autoExpand.push(idx)
+          }
+        }
+      }
       // Done line for ALL tools (panel area abolished — inline only).
       if (!isSubagent) {
         const elapsed = _toolTicks[name] ? ` (${Math.round(performance.now() - _toolTicks[name])}ms)` : ""
@@ -217,13 +260,23 @@ export async function runAgentTurn(ctx, text) {
       if (name === "advisor") {
         // Accumulate to buffer — formatTables + wrapText in render-conversation
         // handles markdown formatting, same as main agent response.
-        const raw = typeof chunk === "string" ? chunk : String(chunk?.text ?? "")
-        const kind = typeof chunk === "string" ? "text" : (chunk?.kind ?? "text")
-        if (kind === "think") {
-          state._advisorThink = (state._advisorThink || "") + raw
-        } else {
-          state.advisorStreaming += raw
-        }
+        // NOTE: the advisor tool ALWAYS emits {kind, text} objects (run.mjs's
+        // emit() wrapper) — a raw string chunk is never think; if that ever
+        // changes, plain-string think would land in advisorStreaming.
+        // ORDERED block buffer — preserves the interleaved emission order
+        // (think → tool → think → … → final). Two separate buffers (_advisorThink
+        // vs advisorStreaming) rendered think-block-then-main-block, which
+        // regrouped ALL thinking above ALL tool progress — the alternating
+        // timeline was destroyed. Consecutive chunks of the same kind merge
+        // into one block; kind flips start a new block; render walks the
+        // blocks in order with per-kind colors.
+        const isString = typeof chunk === "string"
+        const raw = isString ? chunk : String(chunk?.text ?? "")
+        const kind = isString ? "text" : (chunk?.kind ?? "text")
+        const blocks = state._advisorBlocks ??= []
+        const last = blocks.at(-1)
+        if (last && last.kind === kind) last.text += raw
+        else blocks.push({ kind, text: raw })
         scheduleRender()
         return
       }
@@ -295,7 +348,11 @@ export async function runAgentTurn(ctx, text) {
         // pushback messages appear in the conversation at the right spot.
         const last = agent.history.at(-1)
         if (last?.role === "user" && typeof last.content === "string" && last.content.startsWith("[System reminder:")) {
-          pushLine(last.content, C.warn)
+          // Reminders can embed long prior tables — show only the first lines
+          // (the full text is in agent.history); 3 lines + ellipsis.
+          const lines = last.content.split("\n")
+          const shown = lines.length > 3 ? lines.slice(0, 3).join("\n") + "\n…" : last.content
+          pushLine(shown, C.warn)
         }
         if (++n % 5 !== 0) return
         try { saveSessionImpl(agent, state.lines) } catch (e) { console.error(`[session] incremental save failed: ${e.message}`) }
@@ -357,8 +414,7 @@ export async function runAgentTurn(ctx, text) {
     clearInterval(ticker)
     state.processing = false
     state.subTasks = {}
-    state.advisorStreaming = ""
-    state._advisorThink = ""
+    state._advisorBlocks = []
     state.controller = null
     state.status = "Ready"
     // Auto-collapse todo panel when all tasks done (matching kimi-code TUI; agent.tasks are preserved)
@@ -403,107 +459,3 @@ export async function runAgentTurn(ctx, text) {
     return
   }
 }
-
-/** Extract a one-line summary from tool output for the done line */
-function formatToolSummary(name, result) {
-  if (name === "verify") return _verifySummary(result)
-  if (name === "bash") return _bashSummary(result)
-  if (name === "advisor") return _advisorSummary(result)
-  if (name === "read" || name === "read_file") return _readSummary(result)
-  if (name === "write" || name === "write_file") return _writeSummary(result)
-  if (name === "grep" || name === "search") return _grepSummary(result)
-  if (name === "glob") return _globSummary(result)
-  // Default: first non-empty line
-  const first = result.split("\n").find((l) => l.trim())
-  return first ? `${name}: ${first.slice(0, 100)}` : null
-}
-
-function _readSummary(result) {
-  const lines = result.split("\n")
-  // Look for line count in result
-  const countMatch = result.match(/(\d+) lines?/)
-  if (countMatch) return `${countMatch[1]} lines`
-  // Fallback: count actual lines
-  return `${lines.length} lines`
-}
-
-function _writeSummary(result) {
-  // Extract file size or confirmation
-  if (result.includes("wrote") || result.includes("created")) {
-    const sizeMatch = result.match(/(\d+)(?:\s*(?:bytes?|chars?))/i)
-    return sizeMatch ? `wrote ${sizeMatch[1]} bytes` : "wrote file"
-  }
-  const first = result.split("\n").find((l) => l.trim())
-  return first ? first.slice(0, 80) : "wrote"
-}
-
-function _grepSummary(result) {
-  const lines = result.split("\n").filter((l) => l.trim())
-  const count = lines.length
-  if (count === 0) return "no matches"
-  if (count === 1) return "1 match"
-  return `${count} matches`
-}
-
-function _globSummary(result) {
-  const lines = result.split("\n").filter((l) => l.trim())
-  const count = lines.length
-  if (count === 0) return "no files"
-  if (count === 1) return "1 file"
-  return `${count} files`
-}
-
-/**
- * bash result format: "[stdout]:\n<out>\n\n[stderr]:\n<err>\n\n(exit code 0)".
- * The first non-empty line is always the "[stdout]:" marker — useless as a summary.
- * Show the LAST output line (usually the meaningful tail) plus the exit status.
- */
-function _bashSummary(result) {
-  const isMarker = (l) => /^\[(stdout|stderr)\]:$/.test(l) || /^\((exit code|killed)/.test(l)
-  const lines = result.split("\n").map((l) => l.trim()).filter((l) => l && !isMarker(l))
-  const status = result.match(/\((?:exit code|killed)[^)]*\)/)?.[0]
-  const parts = []
-  if (lines.length > 0) parts.push(lines[lines.length - 1].slice(0, 100))
-  if (status) parts.push(status)
-  return parts.length > 0 ? `bash: ${parts.join(" ")}` : null
-}
-
-function _advisorSummary(result) {
-  const text = String(result ?? "")
-  if (/no 🔴|all.*(?:resolved|fixed|pass)/im.test(text)) return "advisor: passed"
-  // Error / skip messages — extract the reason after "Advisor:"
-  const errMatch = text.trimStart().match(/^Advisor:\s*(.+)/)
-  if (errMatch) return `advisor: ${errMatch[1].split(".")[0]}`
-  const critical = (text.match(/\| \d+ \|.*\| 🔴/g) || []).length
-  const advisory = (text.match(/\| \d+ \|.*\| 🟡/g) || []).length
-  const style = (text.match(/\| \d+ \|.*\| 🔵/g) || []).length
-  const parts = []
-  if (critical) parts.push(`${critical} critical`)
-  if (advisory) parts.push(`${advisory} advisory`)
-  if (style) parts.push(`${style} style`)
-  if (parts.length === 0) return null
-  return `advisor: ${parts.join(", ")}`
-}
-
-function _verifySummary(result) {
-  const lines = result.split("\n")
-  const summary = []
-  // Changed files count
-  const changed = lines.find((l) => l.startsWith("Changed files:"))
-  if (changed) {
-    const m = changed.match(/files changed/) ? changed.replace(/^Changed files \(.*?\)/, "Changed files") : changed
-    summary.push(m)
-  }
-  // Syntax check results
-  const syntax = lines.filter((l) => l.startsWith("  ✗"))
-  if (syntax.length > 0) {
-    summary.push(`${syntax.length} syntax error(s)`)
-  }
-  // Test results
-  const testLine = lines.find((l) => l.startsWith("✓ Tests passed.") || l.startsWith("✗ Tests FAILED"))
-  if (testLine) summary.push(testLine.trim())
-  // Task list
-  const taskLine = lines.find((l) => l.startsWith("Task list:"))
-  if (taskLine) summary.push(taskLine)
-  return summary.length > 0 ? `verify: ${summary.join(" — ")}` : ""
-}

package/src/tui/index.mjs

@@ -60,7 +60,7 @@ export async function startTUI(agent, opts = {}) {
   const state = {
     lines: [], // conversation lines: { text, color }
     streaming: "", // current streaming buffer
-    advisorStreaming: "", // advisor streaming buffer (formatted like main response)
+    _advisorBlocks: [], // advisor ordered blocks: [{ kind: "think"|"text", text }] — preserves emission order (think ↔ tool interleaving)
     input: [], // input buffer (codepoint array)
     cursor: 0,
     history: [],

package/src/tui/markdown.mjs

@@ -5,9 +5,11 @@
  * model replies stop showing literal `**`, `##`, backtick markers (IK5VW3).
  *
  * Design constraints:
- * - Operates on ALREADY-WRAPPED single lines (call after wrapText): inserting ANSI
- *   here cannot break width math, because wrapping already happened.
- * - Uses narrow-scope SGR resets (22 = bold off, 27 = reverse off, 29 = strikethrough off)
+ * - Display-only rendering. renderMarkdownHeading handles multi-line input
+ *   (splits internally); renderMarkdownInline expects single lines (its
+ *   regexes use [^*\n]+ — no cross-line matches). Callers pass pre-wrapped
+ *   lines so the inserted ANSI never skews width math.
+ * - Uses narrow-scope SGR resets (22 = bold off, 24 = underline off, 29 = strikethrough off)
  *   instead of reset(0), so the line's base color (C.text etc.) survives.
  * - Code spans are extracted FIRST: anything inside backticks is styled as code and
  *   its `**`/`__` markers are NOT interpreted (markdown semantics).
@@ -15,6 +17,10 @@
  */
 
 const BOLD = "\x1b[1m"
+// NOTE: \x1b[22m resets BOTH bold and faint/dim (SGR 2). Today no C.reason
+// (dim) line passes through markdown rendering (reasoning/think blocks skip
+// it), so this is latent — if dim text ever gains markdown, bold segments
+// would clear the dim effect after them.
 const BOLD_OFF = "\x1b[22m"
 const UNDERLINE = "\x1b[4m"
 const UNDERLINE_OFF = "\x1b[24m"
@@ -23,7 +29,10 @@ const STRIKE_OFF = "\x1b[29m"
 
 /** Render inline markers on a single text line: `code` spans, **bold**, __bold__, ~~strike~~. */
 export function renderMarkdownInline(line) {
-  if (!line || line.indexOf("*") === -1 && line.indexOf("`") === -1 && line.indexOf("_") === -1 && line.indexOf("~") === -1) {
+  // Single underscore lines (snake_case identifiers) must short-circuit too —
+  // __bold__ needs a DOUBLE underscore; a lone "_" would otherwise run the
+  // whole split/replace pipeline for nothing.
+  if (!line || (line.indexOf("*") === -1 && line.indexOf("`") === -1 && line.indexOf("__") === -1 && line.indexOf("~") === -1)) {
     return line
   }
 
@@ -44,9 +53,18 @@ export function renderMarkdownInline(line) {
   return out
 }
 
-/** Render a heading line: strip leading `#` markers and bold the whole line. Returns original when not a heading. */
+/** Render heading markers: strip leading `#` markers and bold the heading.
+ *  Inline markers inside the heading are stripped too — the heading is already
+ *  fully bold, so `**bold**` inside it would wrap another bold sequence whose
+ *  `\x1b[22m` turns bold OFF for the rest of the heading text.
+ *  Line-by-line (split on \n): without the m flag, `^`/`$` anchor the whole
+ *  string, so a multi-line input never matched and headings stayed raw —
+ *  the old call sites passed single wrapped lines and hid the defect.
+ *  Returns the original text when no line is a heading. */
 export function renderMarkdownHeading(line) {
-  const m = /^\s{0,3}(#{1,6})\s+(.*)$/.exec(line)
-  if (!m || !m[2]) return line
-  return `${BOLD}${m[2]}${BOLD_OFF}`
+  return line.split("\n").map((l) => {
+    const m = /^\s{0,3}(#{1,6})\s+(.*)$/.exec(l)
+    if (!m || !m[2]) return l
+    return `${BOLD}${m[2].replace(/\*\*|__|~~/g, "")}${BOLD_OFF}`
+  }).join("\n")
 }

package/src/tui/render-conversation.mjs

@@ -17,17 +17,29 @@ let _convCache = { key: "", cols: 0, lines: [] }
  * @returns {string} ANSI-rendered line whose display width equals stringWidth(text)
  */
 function renderMarkdownPreservingWidth(text) {
-  const rendered = renderMarkdownInline(renderMarkdownHeading(text))
-  const diff = stringWidth(text) - stringWidth(rendered)
-  return diff > 0 ? rendered + " ".repeat(diff) : rendered
+  // Line-by-line: render + compensate per line. The per-line padding serves
+  // NON-table text (so `**bold** text` next to plain text keeps its width).
+  // Table alignment is NOT provided by the padding — formatTables strips cell
+  // padding during trim and recomputes widths from the RENDERED text (that is
+  // the render-before-measure contract).
+  return text.split("\n").map((line) => {
+    const rendered = renderMarkdownInline(renderMarkdownHeading(line))
+    const diff = stringWidth(line) - stringWidth(rendered)
+    return diff > 0 ? rendered + " ".repeat(diff) : rendered
+  }).join("\n")
 }
+// Test seam (mirrors the _-prefixed seams in run.mjs).
+export { renderMarkdownPreservingWidth as _renderMarkdownPreservingWidth }
 
 
 export function convCacheKey(state) {
   const lastLine = state.lines.length > 0 ? state.lines[state.lines.length - 1] : null
   // expandedBlocks participates: expanding/folding a block must invalidate the cache
   const exp = state.expandedBlocks ? [...state.expandedBlocks].sort().join(",") : ""
-  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${state.advisorStreaming?.length ?? 0}|${state._advisorThink?.length ?? 0}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
+  // Content prefix in the signature: same kind+length with different content
+  // would otherwise collide (stale render); 8 chars disambiguate in practice.
+  const blocksSig = (state._advisorBlocks ?? []).map((b) => `${b.kind}:${b.text?.length ?? 0}:${String(b.text ?? "").slice(0, 8)}`).join(",")
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${blocksSig}|${state.foldEnabled !== false ? "f" : "u"}|${exp}`
 }
 
 /** Fold marker line: bold-cyan icon + "click to …" phrase underlined (clickable affordance).
@@ -70,6 +82,13 @@ function highlightSearchMatches(text, query, matchesInLine, globalCurrentIndex,
   return result
 }
 
+/**
+ * Build the conversation lines for the given state.
+ * NOTE: module-level _convCache is read/written as a side effect (keyed by
+ * convCacheKey + cols) — the function is pure w.r.t. its input except for
+ * that cache; direct callers outside renderConversation/countConvLines
+ * should be aware the cache persists across calls.
+ */
 function buildConvLines(state, cols) {
   const key = convCacheKey(state)
   if (_convCache.key === key && _convCache.cols === cols) return _convCache.lines
@@ -90,19 +109,25 @@ function buildConvLines(state, cols) {
 
     // Long-message folding: ANY single line (main output C.text, thinking C.reason,
     // tool summaries C.dim — whatever wraps beyond LONG_FOLD_LINES display rows)
-    // collapses to [blank, ▶, first 4, last] — 5 content lines. Main output and
-    // thinking are the REAL long content; bidirectional folding (collapse markers
-    // + click toggle) keeps them readable — the 0.12.7 dim-only restriction was a
-    // temporary fix for the single-direction era and is now reverted. Keyed by the
-    // source-line index (`long-${i}`) so the toggle survives re-renders.
+    // collapses to [first 4, ▶, last]; expanded long blocks render as
+    // [blank, ▼, every line]. Main output and thinking are the REAL long
+    // content; bidirectional folding (collapse markers + click toggle) keeps
+    // them readable — the 0.12.7 dim-only restriction was a temporary fix for
+    // the single-direction era and is now reverted. Keyed by the source-line
+    // index (`long-${i}`) so the toggle survives re-renders.
     const longKey = `long-${i}`
     const folded = state.foldEnabled !== false && !state.expandedBlocks?.has(longKey)
     const block = []
-    for (const line of formatTables(sanitizeDisplay(text), cols - 1)) {
+    // Lightweight markdown display (IK5VW3): render BEFORE measuring — the
+    // table column math (formatTables) and wrapping must see the RENDERED
+    // text (ANSI consumes zero display width; the width functions are
+    // ANSI-aware). Rendering after wrapping measured raw markdown
+    // (`**bold**` = 8) against displayed text (4) and sliced markers
+    // mid-sequence — the table misalignment the user kept reporting.
+    const renderedText = renderMarkdownPreservingWidth(sanitizeDisplay(text))
+    for (const line of formatTables(renderedText, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        // Lightweight markdown display (IK5VW3): headings bold + inline markers styled.
-        // Runs AFTER wrapping so the ANSI it inserts never skews width math.
-        block.push({ text: renderMarkdownPreservingWidth(wrapped), color: l.color, _foldId: l._foldId, _src: i })
+        block.push({ text: wrapped, color: l.color, _foldId: l._foldId, _src: i })
       }
     }
     if (folded && block.length > LONG_FOLD_LINES) {
@@ -114,15 +139,21 @@ function buildConvLines(state, cols) {
       convLines.push(foldHintLine(`▶ … ${block.length - FOLD_KEEP} more lines — click to expand`, longKey, i))
       convLines.push(block[block.length - 1])
     } else if (block.length > LONG_FOLD_LINES) {
-      // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
-      // before the content. DIM blocks must not re-trigger the consecutive-dim
-      // folding below (folding stacked on folding — reported regression).
-      if (l.color === C.dim) {
-        for (const line of block) line._skipDimFold = true
+      if (state.foldEnabled === false) {
+        // Folding fully off — content already fully visible; a "click to
+        // collapse" hint would be misleading (toggling has no effect).
+        convLines.push(...block)
+      } else {
+        // EXPANDED long block: blank line + ▼ control line at the HEAD, directly
+        // before the content. DIM blocks must not re-trigger the consecutive-dim
+        // folding below (folding stacked on folding — reported regression).
+        if (l.color === C.dim) {
+          for (const line of block) line._skipDimFold = true
+        }
+        convLines.push(blankLine())
+        convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
+        convLines.push(...block)
       }
-      convLines.push(blankLine())
-      convLines.push(foldHintLine(`▼ … ${block.length} lines — click to collapse`, longKey, i))
-      convLines.push(...block)
     } else {
       convLines.push(...block)
     }
@@ -132,25 +163,40 @@ function buildConvLines(state, cols) {
       convLines.push({ text: wrapped, color: C.reason })
     }
   }
-  if (state._advisorThink || state.advisorStreaming) {
-    const thinkLines = state._advisorThink ? sanitizeDisplay(state._advisorThink).split("\n") : []
-    const mainLines = state.advisorStreaming
-      ? formatTables(sanitizeDisplay(state.advisorStreaming), cols - 3)
-      : []
-    const allLines = [...thinkLines.map(l => ({ text: l, color: C.reason })), ...mainLines.map(l => ({ text: l, color: C.text }))]
-    const truncated = allLines.length > 5
-    if (truncated) convLines.push({ text: "│ …", color: C.dim })
-    const shown = truncated ? allLines.slice(-5) : allLines
-    for (const { text, color } of shown) {
-      for (const wrapped of wrapText(text, cols - 3)) {
-        convLines.push({ text: `│ ${wrapped}`, color })
+  const advisorBlocks = state._advisorBlocks ?? []
+  if (advisorBlocks.length > 0) {
+    // ORDERED block display — the blocks preserve the emission order
+    // (think → tool → think → … → final) and render as one interleaved
+    // stream: thinking in reasoning color, tool progress/final in text color.
+    // Full-length, no preview truncation; long content scrolls via the
+    // conversation window like everything else.
+    // NOTE: formatTables returns an ARRAY of lines (not a string) — calling
+    // .split on it crashed the whole render (tools/final never displayed).
+    for (const block of advisorBlocks) {
+      const color = { think: C.reason, tool: C.tool, text: C.text }[block.kind] ?? C.text
+      const source = sanitizeDisplay(block.text)
+      // kind:"text" (the final review prose) gets the same lightweight markdown
+      // styling as the main agent response. Rendered BEFORE measuring: the
+      // width math (formatTables / wrapText) must see the RENDERED text —
+      // measuring raw markdown (`**bold**` = 8) against displayed text (4)
+      // misaligned table columns; wrapping raw markdown sliced markers
+      // mid-sequence (`**bo` + `ld**`) so the renderer never saw complete ones.
+      const rows = block.kind === "think"
+        ? source.split("\n")
+        : formatTables(block.kind === "text" ? renderMarkdownPreservingWidth(source) : source, cols - 3)
+      for (const line of rows) {
+        for (const wrapped of wrapText(line, cols - 3)) {
+          convLines.push({ text: `│ ${wrapped}`, color })
+        }
       }
     }
   }
   if (state.streaming) {
-    for (const line of formatTables(sanitizeDisplay(state.streaming), cols - 1)) {
+    // Rendered BEFORE formatTables — see the advisor-block comment above.
+    const rendered = renderMarkdownPreservingWidth(sanitizeDisplay(state.streaming))
+    for (const line of formatTables(rendered, cols - 1)) {
       for (const wrapped of wrapText(line, cols - 1)) {
-        convLines.push({ text: renderMarkdownPreservingWidth(wrapped), color: C.text })
+        convLines.push({ text: wrapped, color: C.text })
       }
     }
   }
@@ -177,10 +223,15 @@ function buildConvLines(state, cols) {
           i = j
           continue
         }
-        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line
-        folded.push(blankLine())
-        folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
-        for (let k = i; k < j; k++) folded.push(convLines[k])
+        // EXPANDED consecutive-dim block: blank + ▼ at the HEAD, then every line.
+        // foldEnabled=false → raw block, no hint (toggling would be a no-op).
+        if (state.foldEnabled === false) {
+          for (let k = i; k < j; k++) folded.push(convLines[k])
+        } else {
+          folded.push(blankLine())
+          folded.push(foldHintLine(`▼ … ${blockLen} lines — click to collapse`, foldKey))
+          for (let k = i; k < j; k++) folded.push(convLines[k])
+        }
         i = j
         continue
       }

package/src/tui/tool-summaries.mjs

@@ -0,0 +1,113 @@
+/**
+ * tool-summaries.mjs — one-line tool-result summaries for the TUI "done" lines.
+ * Extracted from agent-turn.mjs (file-size split): pure functions, no state.
+ */
+
+/** Extract a one-line summary from tool output for the done line */
+export function formatToolSummary(name, result) {
+  if (name === "verify") return _verifySummary(result)
+  if (name === "bash") return _bashSummary(result)
+  if (name === "advisor") return _advisorSummary(result)
+  if (name === "read" || name === "read_file") return _readSummary(result)
+  if (name === "write" || name === "write_file") return _writeSummary(result)
+  if (name === "grep" || name === "search") return _grepSummary(result)
+  if (name === "glob") return _globSummary(result)
+  // Default: first non-empty line
+  const first = result.split("\n").find((l) => l.trim())
+  return first ? `${name}: ${first.slice(0, 100)}` : null
+}
+
+function _readSummary(result) {
+  const lines = result.split("\n")
+  // Look for line count in result
+  const countMatch = result.match(/(\d+) lines?/)
+  if (countMatch) return `${countMatch[1]} lines`
+  // Fallback: count actual lines
+  return `${lines.length} lines`
+}
+
+function _writeSummary(result) {
+  // Extract file size or confirmation
+  if (result.includes("wrote") || result.includes("created")) {
+    const sizeMatch = result.match(/(\d+)(?:\s*(?:bytes?|chars?))/i)
+    return sizeMatch ? `wrote ${sizeMatch[1]} bytes` : "wrote file"
+  }
+  const first = result.split("\n").find((l) => l.trim())
+  return first ? first.slice(0, 80) : "wrote"
+}
+
+function _grepSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no matches"
+  if (count === 1) return "1 match"
+  return `${count} matches`
+}
+
+function _globSummary(result) {
+  const lines = result.split("\n").filter((l) => l.trim())
+  const count = lines.length
+  if (count === 0) return "no files"
+  if (count === 1) return "1 file"
+  return `${count} files`
+}
+
+/**
+ * bash result format: "[stdout]:\n<out>\n\n[stderr]:\n<err>\n\n(exit code 0)".
+ * The first non-empty line is always the "[stdout]:" marker — useless as a summary.
+ * Show the LAST output line (usually the meaningful tail) plus the exit status.
+ */
+function _bashSummary(result) {
+  const isMarker = (l) => /^\[(stdout|stderr)\]:$/.test(l) || /^\((exit code|killed)/.test(l)
+  const lines = result.split("\n").map((l) => l.trim()).filter((l) => l && !isMarker(l))
+  const status = result.match(/\((?:exit code|killed)[^)]*\)/)?.[0]
+  const parts = []
+  if (lines.length > 0) parts.push(lines[lines.length - 1].slice(0, 100))
+  if (status) parts.push(status)
+  return parts.length > 0 ? `bash: ${parts.join(" ")}` : null
+}
+
+function _advisorSummary(result) {
+  const text = String(result ?? "")
+  // Error / skip messages — extract the reason after "Advisor:"
+  const errMatch = text.trimStart().match(/^Advisor:\s*(.+)/)
+  if (errMatch) return `advisor: ${errMatch[1].split(".")[0]}`
+  const critical = (text.match(/\| \d+ \|.*\| 🔴/g) || []).length
+  const advisory = (text.match(/\| \d+ \|.*\| 🟡/g) || []).length
+  const style = (text.match(/\| \d+ \|.*\| 🔵/g) || []).length
+  // Protocol: zero 🔴 rows in the review table = pass (phrase fallback for
+  // table-free summaries like "No issues found").
+  if (critical === 0 && (/\| \d+ \|/.test(text)
+    || /no\s+🔴|all.*(?:resolved|fixed|pass)|pass(?:es|ed)?\b|no\s+(?:critical\s+)?issues?/i.test(text))) {
+    return "advisor: passed"
+  }
+  const parts = []
+  if (critical) parts.push(`${critical} critical`)
+  if (advisory) parts.push(`${advisory} advisory`)
+  if (style) parts.push(`${style} style`)
+  if (parts.length === 0) return null
+  return `advisor: ${parts.join(", ")}`
+}
+
+function _verifySummary(result) {
+  const lines = result.split("\n")
+  const summary = []
+  // Changed files count
+  const changed = lines.find((l) => l.startsWith("Changed files:"))
+  if (changed) {
+    const m = changed.match(/files changed/) ? changed.replace(/^Changed files \(.*?\)/, "Changed files") : changed
+    summary.push(m)
+  }
+  // Syntax check results
+  const syntax = lines.filter((l) => l.startsWith("  ✗"))
+  if (syntax.length > 0) {
+    summary.push(`${syntax.length} syntax error(s)`)
+  }
+  // Test results
+  const testLine = lines.find((l) => l.startsWith("✓ Tests passed.") || l.startsWith("✗ Tests FAILED"))
+  if (testLine) summary.push(testLine.trim())
+  // Task list
+  const taskLine = lines.find((l) => l.startsWith("Task list:"))
+  if (taskLine) summary.push(taskLine)
+  return summary.length > 0 ? `verify: ${summary.join(" — ")}` : ""
+}