thincoder 0.11.0 → 0.11.1

package/src/tui/cmd-advisor.mjs

@@ -1,56 +1,157 @@
-/** /advisor command: toggle advisor on/off, select model.
- *  ctx: { agent, showPicker, pushLine } */
+/** /advisor command: toggle advisor on/off, select model, configure thinking.
+ *  ctx: { agent, showPicker, pushLine, persistRaw } */
 import { C } from "./ansi.mjs"
 
 export async function handleAdvisorCommand(ctx) {
   const { agent, showPicker, pushLine } = ctx
   const cfg = agent.config.advisor ??= {}
   const enabled = cfg.enabled === true
-  const curProvider = cfg.provider || agent.activeProvider
+  const curProvider = cfg.provider || "(main)"
   const curModel = cfg.model || agent.provider.model
+  const thinkInfo = cfg.thinking === null ? "off"
+    : cfg.thinking?.type === "disabled" ? "off"
+    : cfg.reasoningEffort ? `on (${cfg.reasoningEffort})`
+    : cfg.thinking ? `on (${cfg.thinking.type})` : "(main)"
 
   const entries = [
     { type: "item", text: `Advisor: ${enabled ? "ON" : "OFF"}`, action: "toggle" },
-    { type: "item", text: `Model: ${curProvider}/${curModel}`, action: "model" },
+    { type: "item", text: `Model: ${curModel}`, action: "model", note: `Provider: ${curProvider}` },
+    { type: "item", text: `Thinking: ${thinkInfo}`, action: "thinking" },
   ]
 
   const e = await showPicker("Advisor", entries)
   if (!e) return
+
+  const persist = async () => {
+    if (ctx.persistRaw) {
+      await ctx.persistRaw((raw) => {
+        raw.agent ??= {}
+        raw.agent.advisor = cfg
+      })
+    }
+  }
+
   if (e.action === "toggle") {
     cfg.enabled = !cfg.enabled
     agent._pendingReminders = agent._pendingReminders ?? []
     if (cfg.enabled) {
-      agent._pendingReminders.push("[System reminder: Advisor review is now ON. After each turn your output will be reviewed, and observations may be injected as system reminders. Treat them critically — they are observations, not commands.]")
+      agent._pendingReminders.push("[System reminder: Advisor review is now ON. You can call the `advisor` tool to get an independent code review before finalising your work. The advisor is an independent read-only sub-agent that explores the codebase, runs git diff, reads files, and traces callers via grep/lsp.]")
     } else {
-      agent._pendingReminders.push("[System reminder: Advisor review is now OFF. Future turns will not be reviewed automatically.]")
+      agent._pendingReminders.push("[System reminder: Advisor review is now OFF. The `advisor` tool will not produce results.]")
     }
+    await persist().catch(err => pushLine(`[error] Advisor toggle: ${err.message}`, C.error))
   } else if (e.action === "model") {
-    await openAdvisorModelPicker(ctx).catch(err => pushLine(`[error] ${err.message}`, C.error))
+    await openAdvisorModelPicker(ctx, persist).catch(err => pushLine(`[error] ${err.message}`, C.error))
+  } else if (e.action === "thinking") {
+    await openAdvisorThinkingPicker(ctx, persist).catch(err => pushLine(`[error] ${err.message}`, C.error))
   }
 }
 
-async function openAdvisorModelPicker(ctx) {
+async function openAdvisorModelPicker(ctx, persist) {
   const { agent, showPicker, pushLine } = ctx
   const providers = agent.providers || []
+  const cfg = agent.config.advisor ??= {}
 
-  // Build flat list: each provider's name + a "use current model" entry
-  const entries = []
+  const entries = [
+    { type: "item", text: "Use main model", action: "inherit", marker: !cfg.provider ? "●" : "" },
+  ]
   for (const p of providers) {
-    const mark = p.name === agent.activeProvider ? "* " : "  "
-    entries.push({ type: "item", text: `${mark}${p.name} — ${p.baseURL}`, action: "set_provider", provider: p.name, model: p.model })
+    entries.push({ type: "header", text: p.name, note: `${p.baseURL}${agent.activeProvider === p.name ? " ← active" : ""}  loading…` })
+    const mark = cfg.provider === p.name && cfg.model === p.model ? "● " : "  "
+    entries.push({ type: "item", text: `${mark}${p.model}`, action: "switch", provider: p.name, model: p.model })
   }
 
+  // Fetch models first, then show picker
+  await fetchAdvisorModels(entries, providers, agent)
+
   const e = await showPicker("Advisor Model", entries)
-  if (e?.action !== "set_provider") return
-  const cfg = agent.config.advisor ??= {}
-  if (e.provider === agent.activeProvider && e.model === agent.provider.model) {
-    // Same as main — clear override (use main pool)
+  if (!e) return
+
+  if (e.action === "inherit") {
     delete cfg.provider
     delete cfg.model
-    pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`, C.dim)
-  } else {
+    pushLine("Advisor: using main model", C.dim)
+  } else if (e.action === "switch") {
     cfg.provider = e.provider
     cfg.model = e.model
     pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
   }
+  await persist()
+}
+
+async function fetchAdvisorModels(entries, providers, agent) {
+  const { listModels } = await import("../provider/index.mjs")
+  await Promise.all(providers.map(async (p) => {
+    try {
+      const envKey = { deepseek: "DEEPSEEK_API_KEY", openai: "OPENAI_API_KEY" }[p.name]
+      let apiKey = p.apiKey
+      if (!apiKey && envKey && process.env[envKey]) apiKey = process.env[envKey]
+      if (!apiKey) apiKey = process.env.THINCODER_API_KEY
+      const models = await listModels({ baseURL: p.baseURL, apiKey: apiKey ?? "" }, { signal: AbortSignal.timeout(10000) })
+      const at = entries.findLastIndex((e) => e.type === "header" && e.text === p.name)
+      if (at < 0) return
+      entries.splice(at + 2, 0, ...models
+        .filter((m) => m !== p.model)
+        .map((m) => ({ type: "item", text: `   ${m}`, action: "switch", provider: p.name, model: m })))
+      const header = entries[at]
+      header.note = `${p.baseURL}${p.apiKey ? "" : " (no key)"}${agent.activeProvider === p.name ? " ← active" : ""}`
+  } catch (err) {
+      const header = entries.find((e) => e.type === "header" && e.text === p.name)
+      if (header) header.note = `${p.baseURL}${p.apiKey ? "" : " (no key)"}${agent.activeProvider === p.name ? " ← active" : ""}  (fetch failed: ${err.message.slice(0, 40)})`
+    }
+  }))
+}
+
+async function openAdvisorThinkingPicker(ctx, persist) {
+  const { agent, showPicker, pushLine } = ctx
+  const { specForModel } = await import("../config.mjs")
+  const cfg = agent.config.advisor ??= {}
+
+  const providerForDefaults = cfg.provider
+    ? agent.providers?.find(p => p.name === cfg.provider) || agent.provider
+    : agent.provider
+  const effectiveModel = cfg.model || providerForDefaults.model
+  const spec = specForModel(effectiveModel)
+  const thinkOnValue = spec.thinkEnabledValue ?? "enabled"
+  const isCustomThink = thinkOnValue !== "enabled"
+  const isEffortOnly = spec.thinkApi === "effort"
+  const effortLevels = spec.reasoningEffortEnum ?? ["high", "max"]
+
+  const curEffort = cfg.reasoningEffort ?? providerForDefaults.reasoningEffort
+  const curThinking = cfg.thinking ?? providerForDefaults.thinking
+  const thinkingEnabled = curThinking?.type === thinkOnValue
+    || (curThinking?.type === undefined && !isCustomThink)
+
+  const entries = [
+    { type: "item", text: "Use main model settings", action: "inherit" },
+  ]
+  if (!isEffortOnly) {
+    entries.push({ type: "header", text: "Thinking mode" })
+    entries.push({ type: "item", text: `Enabled ${thinkingEnabled ? "← current" : ""}`, action: "think_on" })
+    entries.push({ type: "item", text: `Disabled ${curThinking?.type === "disabled" || curThinking === null ? "← current" : ""}`, action: "think_off" })
+  }
+  entries.push({ type: "header", text: "Reasoning effort" })
+  for (const level of effortLevels) {
+    entries.push({ type: "item", text: `${level} ${curEffort === level ? "← current" : ""}`, action: `effort_${level}` })
+  }
+
+  const e = await showPicker("Advisor Thinking", entries)
+  if (!e) return
+
+  if (e.action === "inherit") {
+    delete cfg.thinking
+    delete cfg.reasoningEffort
+    pushLine("Advisor: using main model thinking settings", C.dim)
+  } else if (e.action === "think_on") {
+    cfg.thinking = { type: thinkOnValue }
+    if (isEffortOnly) delete cfg.thinking
+    pushLine(`Advisor: thinking ON (${thinkOnValue})`, C.dim)
+  } else if (e.action === "think_off") {
+    cfg.thinking = isCustomThink ? null : { type: "disabled" }
+    pushLine("Advisor: thinking OFF", C.dim)
+  } else if (e.action.startsWith("effort_")) {
+    cfg.reasoningEffort = e.action.slice(7)
+    pushLine(`Advisor: reasoning effort = ${cfg.reasoningEffort}`, C.dim)
+  }
+  await persist()
 }

package/src/tui/index.mjs

@@ -5,7 +5,7 @@
  *
  * Large logic blocks extracted to independent modules:
  *   agent-turn.mjs    — agent loop + callback construction
- *   key-handler.mjs   — keyboard event dispatch
+ *   render-loop.mjs  — frame scheduler + incremental panel rendering
  *   startup.mjs       — startup screen + session restore + background indexing
  *   interaction.mjs   — permission approval + Q&A
  *   pickers.mjs       — generic list picker + model picker
@@ -20,15 +20,8 @@ import { emitKeypressEvents } from "node:readline"
 import { PassThrough } from "node:stream"
 import { saveSession, archiveCurrent, listSlots } from "../session.mjs"
 import { closeAllMcp } from "../mcp.mjs"
-import { estimateTokens } from "../context.mjs"
 import { ansi, C } from "./ansi.mjs"
-import {
-  renderFrame, countConvLines, convCacheKey,
-  renderHeader, renderConversation, renderTodo, renderSubagent,
-  renderOutput, renderPermission, renderQueue, renderPicker,
-  renderInputBox, renderStatus,
-} from "./render-frame.mjs"
-import { computeLayout } from "./layout.mjs"
+import { createRenderLoop } from "./render-loop.mjs"
 import { SLASH_COMMANDS, SLASH_ALIASES, createSlashCommands } from "./slash-commands.mjs"
 import { createWizard } from "./wizard.mjs"
 import { createPickers } from "./pickers.mjs"
@@ -247,184 +240,11 @@ export async function startTUI(agent, opts = {}) {
 
   // ---------------------------------------------------------- Render
 
-  // Panel cache for incremental rendering: panelName → { y, h, content }
-  const panelCache = new Map()
-  let lastCols = 0, lastRows = 0
-  let lastConvKey = "", lastConvCols = 0, lastConvScroll = -1
-  const convLineCache = []  // line-level cache for conversation panel (per-line diff)
-  let renderRequested = false, renderTimer = null, lastRenderAt = 0
-  const MIN_RENDER_INTERVAL_MS = 16  // ~60fps cap, matching pi-tui
-
-  function scheduleRender() {
-    if (renderTimer) return
-    const elapsed = performance.now() - lastRenderAt
-    const delay = Math.max(0, MIN_RENDER_INTERVAL_MS - elapsed)
-    renderTimer = setTimeout(() => {
-      renderTimer = null
-      if (!renderRequested) return
-      renderRequested = false
-      lastRenderAt = performance.now()
-      doRender()
-      if (renderRequested) scheduleRender()  // more requests arrived during render
-    }, delay)
-  }
-
-  /** Rate-limited render entry point. All call sites use this. */
-  function render() {
-    if (renderRequested) return
-    renderRequested = true
-    // process.nextTick merges multiple synchronous render() calls
-    // within the same tick into a single scheduleRender call.
-    process.nextTick(() => scheduleRender())
-  }
-
-  /** Build ANSI content for a panel at its layout position. Returns null if unchanged. */
-  function buildPanel(name, panelLayout, lines, cacheKey) {
-    if (!panelLayout) {
-      if (panelCache.has(name)) panelCache.delete(name)
-      return null
-    }
-    const content = lines.join("\r\n")
-    const cached = panelCache.get(name)
-    const effectiveKey = cacheKey ?? content
-    if (cached && cached.y === panelLayout.y && cached.h === panelLayout.h && cached.key === effectiveKey) return null
-    const rows = []
-    for (let i = 0; i < panelLayout.h; i++) {
-      rows.push(`\x1b[${panelLayout.y + 1 + i};1H${lines[i] ?? ""}\x1b[K`)
-    }
-    panelCache.set(name, { y: panelLayout.y, h: panelLayout.h, key: effectiveKey })
-    return rows.join("")
-  }
-
-  /** Detect if panel layout structure changed (appeared/disappeared/shifted).
-   *  Only checks panels that are ALREADY cached — new panels (not yet written)
-   *  are not a structural change; the incremental path will write them naturally. */
-  function layoutStructureChanged(layout) {
-    for (const [name, cached] of panelCache) {
-      const p = layout.panels[name] ?? null
-      if (p == null) return true  // cached panel disappeared → layout changed
-      if (p.y !== cached.y || p.h !== cached.h) return true  // shifted/resized
-    }
-    return false
-  }
-
-  function doRender() {
-    try {
-      const dims = { cols: process.stdout.columns || startupCols, rows: process.stdout.rows || startupRows }
-      const layout = computeLayout(state, dims)
-      const { W, panels, inputLayout, inputOffset, boxLines, visibleTasks, allSubs, permPreviewLines, overlay } = layout
-
-      // Side effects: clamp scroll + overlay + update ctxCache
-      const convLines = countConvLines(state, dims.cols)
-      state.scroll = Math.min(state.scroll, Math.max(0, convLines - panels.conversation.h))
-      if (overlay && panels.picker) {
-        const winH = panels.picker.h - 1
-        if (overlay.selectedLine < overlay.scroll) overlay.scroll = overlay.selectedLine
-        if (overlay.selectedLine >= overlay.scroll + winH) overlay.scroll = overlay.selectedLine - winH + 1
-      }
-      if (state.ctxCache.len !== agent.history.length) {
-        state.ctxCache = { len: agent.history.length, tokens: estimateTokens(agent.history) }
-      }
-
-      // 后台更新提示：等 picker/权限确认/提问弹层全部关闭后再弹，不硬抢
-      // （key-handler 分支顺序 permission → question → picker，任一激活时弹了也摸不到）
-      if (pendingNoticeReady(state)) {
-        const notice = state.pendingNotice
-        state.pendingNotice = null
-        showUpdateNotice(notice).catch((e) => pushLine(`[error] ${e.message}`, C.error))
-      }
-
-      // Terminal resize or panel layout shift → full redraw (using legacy renderFrame).
-      // Don't clear panelCache — update positions so the next incremental check
-      // sees correct Y/h. Content keys will be stale, forcing a one-time rewrite
-      // per panel on the next frame (much cheaper than another full redraw).
-      if (dims.cols !== lastCols || dims.rows !== lastRows || layoutStructureChanged(layout)) {
-        lastCols = dims.cols; lastRows = dims.rows
-        // Update cached panel positions (content stays stale → next frame rewrites)
-        for (const [name, panelLayout] of Object.entries(panels)) {
-          if (!panelLayout) { panelCache.delete(name); continue }
-          const cached = panelCache.get(name)
-          if (cached) { cached.y = panelLayout.y; cached.h = panelLayout.h }
-        }
-        const isStreaming = state.processing && !state.permission && !state.question && !state.picker
-        const isWizard = state.wizard?.step === "provider"
-        // Content + cursor in a single write. Hardware cursor stays hidden —
-        // the visual cursor is drawn in the input box as SGR reverse video.
-        // Position for IME, hide for visual (matching pi-tui).
-        const { frame, cursorRow, cursorCol } = renderFrame(state, agent, { cols: dims.cols, rows: dims.rows, slashCommands: SLASH_COMMANDS })
-        if (isStreaming) {
-          process.stdout.write(ansi.syncUpdateStart + ansi.home + frame + ansi.clearToEnd + ansi.syncUpdateEnd + `\x1b[${cursorRow};${cursorCol}H${ansi.hideCursor}`)
-        } else if (isWizard) {
-          process.stdout.write(ansi.syncUpdateStart + ansi.home + frame + ansi.clearToEnd + ansi.syncUpdateEnd + ansi.hideCursor)
-        } else {
-          process.stdout.write(ansi.syncUpdateStart + ansi.home + frame + ansi.clearToEnd + ansi.syncUpdateEnd + `\x1b[${cursorRow};${cursorCol}H${ansi.hideCursor}`)
-        }
-        return
-      }
-
-      // ---- Incremental rendering (layout stable) ----
-      // pi-tui pattern: content inside sync-update block; cursor outside.
-      // DECSET 2026 buffers all panel writes and renders them atomically.
-      // Cursor hide/show/position MUST be outside — otherwise the terminal's
-      // internal cursor state machine and the sync render buffer can disagree.
-      const out = []
-      const push = (s) => { if (s != null) out.push(s) }
-
-      // Always-visible panels
-      push(buildPanel("header", panels.header, [renderHeader(agent, dims.cols)]))
-      push(buildPanel("status", panels.status, [renderStatus(state, agent, dims.cols, SLASH_COMMANDS)]))
-      push(buildPanel("inputBox", panels.inputBox, renderInputBox(state, W, boxLines, dims.cols, inputLayout, inputOffset)))
-
-      // Conversation: line-level cache — only push changed lines
-      const convKey = convCacheKey(state)
-      const convChanged = convKey !== lastConvKey || dims.cols !== lastConvCols || state.scroll !== lastConvScroll
-      if (convChanged) {
-        lastConvKey = convKey; lastConvCols = dims.cols; lastConvScroll = state.scroll
-        const lines = renderConversation(state, dims.cols, panels.conversation.h, state.scroll)
-        const y = panels.conversation.y + 1
-        for (let i = 0; i < lines.length; i++) {
-          if (lines[i] !== convLineCache[i]) {
-            out.push(`\x1b[${y + i};1H${lines[i]}\x1b[K`)
-            convLineCache[i] = lines[i]
-          }
-        }
-        if (convLineCache.length > lines.length) {
-          for (let i = lines.length; i < convLineCache.length; i++) {
-            out.push(`\x1b[${y + i};1H\x1b[K`)
-          }
-        }
-        convLineCache.length = lines.length
-      }
-
-      // Conditional panels
-      push(buildPanel("todo", panels.todo, renderTodo(visibleTasks, dims.cols)))
-      push(buildPanel("subagent", panels.subagent, renderSubagent(allSubs, W)))
-      push(buildPanel("output", panels.output, renderOutput(state, W, panels.output?.h ?? 0)))
-      push(buildPanel("permission", panels.permission, renderPermission(permPreviewLines)))
-      if (panels.queue) push(buildPanel("queue", panels.queue, [renderQueue(state, W)]))
-      else panelCache.delete("queue")
-      if (panels.picker) push(buildPanel("picker", panels.picker, renderPicker(state, dims.cols, panels.picker, overlay)))
-      else panelCache.delete("picker")
-
-      // Determine cursor suffix — appended to the same write() as the sync block.
-      // MUST position the cursor at the input box even when hidden: the terminal's
-      // cursor position determines where the IME candidate window appears.
-      // pi-tui's positionHardwareCursor does the same — positions first, then
-      // decides show/hide based on showHardwareCursor.
-      // Hardware cursor stays hidden — the visual cursor is drawn in the input
-      // box text as SGR reverse video (matching pi-tui's approach).
-      // We still position the hardware cursor for IME candidate window placement.
-      const cr = panels.inputBox.y + 1 + (inputLayout.cursorLine - inputOffset) + 1
-      const cc = 3 + inputLayout.cursorCol
-      const hasOverlay = state.permission || state.question || state.picker || state.wizard?.step === "provider"
-      const cursorSuffix = hasOverlay ? "" : `\x1b[${cr};${cc}H${ansi.hideCursor}`
-
-      // Single write: sync markers + content + cursor — atomic as far as the terminal is concerned
-      if (out.length || cursorSuffix) process.stdout.write(ansi.syncUpdateStart + out.join("") + ansi.syncUpdateEnd + cursorSuffix)
-    } catch (e) {
-      // Don't let a render error crash the TUI
-    }
-  }
+  const renderLoop = createRenderLoop(state, agent,
+    { startupDims: { cols: startupCols, rows: startupRows }, SLASH_COMMANDS,
+      pendingNoticeReady, get showUpdateNotice() { return showUpdateNotice } },
+    pushLine)
+  const { render, scheduleRender } = renderLoop
 
   process.stdout.on("resize", () => {
     try { render() } catch { /* resize error — ignore */ }

package/src/tui/key-handler.mjs

@@ -140,8 +140,14 @@ export function createKeyHandler(ctx) {
         const msg = (state.interruptPrompt.text ?? "").trim()
         state.interruptPrompt = null
         if (msg) {
-          pushLine(`  [inject] ${msg}`, C.warn)
-          state.controller.abort({ interrupt: true, message: msg })
+          // Guard: if the turn already finished while the user was typing, the controller
+          // may have been replaced or already aborted — don't abort a live turn by mistake.
+          if (state.processing && state.controller && !state.controller.signal.aborted) {
+            pushLine(`  [inject] ${msg}`, C.warn)
+            state.controller.abort({ interrupt: true, message: msg })
+          } else {
+            pushLine(`  [inject — turn ended, message queued] ${msg}`, C.dim)
+          }
           render()
         }
       } else if (key.name === "backspace") {

package/src/tui/layout.mjs

@@ -70,7 +70,7 @@ export function computeLayout(state, { cols, rows }) {
     : 0
 
   // Tool output panels: max 8 lines per panel, capped at reasonable total
-  const panels = Object.values(state.outputPanels).filter((p) => !p.done)
+  const panels = Object.values(state.outputPanels).filter((p) => !p.done || p._pendingDone)
   const outputPanelsH = panels.length > 0 ? Math.min(panels.length * 8, rows - 10) : 0
 
   // Permission preview (height depends on wrapped content)

package/src/tui/render-conversation.mjs

@@ -0,0 +1,92 @@
+/**
+ * render-conversation.mjs — conversation panel line builder
+ * Extracted from render-frame.mjs.
+ */
+import { ansi, C } from "./ansi.mjs"
+import { formatTables, sanitizeDisplay, wrapText } from "./render.mjs"
+
+let _convCache = { key: "", cols: 0, lines: [] }
+
+export function convCacheKey(state) {
+  const lastLine = state.lines.length > 0 ? state.lines[state.lines.length - 1] : null
+  return `${state.lines.length}|${lastLine?.text.length ?? 0}|${state.streaming.length}|${state.reasoning.length}|${Object.keys(state.toolStreams).length}|${state.foldEnabled !== false ? "f" : "u"}`
+}
+
+function buildConvLines(state, cols) {
+  const key = convCacheKey(state)
+  if (_convCache.key === key && _convCache.cols === cols) return _convCache.lines
+
+  const convLines = []
+  for (const l of state.lines) {
+    for (const line of formatTables(sanitizeDisplay(l.text), cols - 1)) {
+      for (const wrapped of wrapText(line, cols - 1)) {
+        convLines.push({ text: wrapped, color: l.color, _foldId: l._foldId })
+      }
+    }
+  }
+  if (state.reasoning) {
+    for (const wrapped of wrapText(sanitizeDisplay(state.reasoning), cols - 1)) {
+      convLines.push({ text: wrapped, color: C.reason })
+    }
+  }
+  if (state.streaming) {
+    for (const line of formatTables(sanitizeDisplay(state.streaming), cols - 1)) {
+      for (const wrapped of wrapText(line, cols - 1)) {
+        convLines.push({ text: wrapped, color: C.text })
+      }
+    }
+  }
+  const allStreams = Object.values(state.toolStreams).join("")
+  if (allStreams) {
+    const tail = sanitizeDisplay(allStreams.slice(-4000))
+    for (const wrapped of wrapText(tail, cols - 1)) {
+      convLines.push({ text: wrapped, color: C.dim })
+    }
+  }
+
+  // Fold long blocks (> 8 consecutive dim lines)
+  const FOLD_LINES = 8
+  let foldCounter = 0
+  const folded = []
+  let i = 0
+  while (i < convLines.length) {
+    const line = convLines[i]
+    if (line.color === C.dim) {
+      let j = i
+      while (j < convLines.length && convLines[j].color === C.dim) j++
+      const blockLen = j - i
+      if (blockLen > FOLD_LINES) {
+        const foldKey = `fold-${foldCounter++}`
+        if (state.foldEnabled !== false && !state.expandedBlocks?.has(foldKey)) {
+          folded.push(convLines[i])
+          if (blockLen > 2) folded.push(convLines[i + 1])
+          folded.push({ text: `  … ${blockLen - 2} more lines — Enter to expand`, color: C.fold, _foldToggle: foldKey })
+          i = j
+          continue
+        }
+      }
+    }
+    folded.push(line)
+    i++
+  }
+
+  _convCache = { key, cols, lines: folded }
+  return folded
+}
+
+export function countConvLines(state, cols) {
+  return buildConvLines(state, cols).length
+}
+
+export function renderConversation(state, cols, visibleH, scroll) {
+  const convLines = buildConvLines(state, cols)
+  const maxScroll = Math.max(0, convLines.length - visibleH)
+  const clamped = Math.min(scroll, maxScroll)
+  const end = convLines.length - clamped
+  const visible = convLines.slice(Math.max(0, end - visibleH), end)
+  const pad = visibleH - visible.length
+  const out = []
+  for (let p = 0; p < pad; p++) out.push("")
+  for (const l of visible) out.push(`${l.color ?? ""}${l.text}${ansi.reset}`)
+  return out
+}