thincoder 0.8.11 → 0.8.13

package/src/tui/cmd-advisor.mjs

@@ -0,0 +1,68 @@
+/** /advisor command: toggle advisor on/off, select model.
+ *  ctx: { agent, openPicker, pushLine } */
+import { C } from "./ansi.mjs"
+
+export async function handleAdvisorCommand(ctx) {
+  const { agent, openPicker, pushLine } = ctx
+  const cfg = agent.config.advisor ??= {}
+  const enabled = cfg.enabled === true
+  const curProvider = cfg.provider || agent.activeProvider
+  const curModel = cfg.model || agent.provider.model
+
+  const entries = [
+    { type: "item", text: `Advisor: ${enabled ? "ON" : "OFF"}`, action: "toggle" },
+    { type: "item", text: `Model: ${curProvider}/${curModel}`, action: "model" },
+  ]
+
+  openPicker({
+    title: "Advisor",
+    entries,
+    onSelect: async (e) => {
+      if (e.action === "toggle") {
+        cfg.enabled = !cfg.enabled
+        agent._pendingReminders = agent._pendingReminders ?? []
+        if (cfg.enabled) {
+          agent._pendingReminders.push("[系统提醒: Advisor 审查已开启。每轮操作后，你的输出将被审查，观察结果可能作为系统提醒注入。请批判性参考——这是观察，不是命令。]")
+        } else {
+          agent._pendingReminders.push("[系统提醒: Advisor 审查已关闭。后续轮次不再自动审查。]")
+        }
+      } else if (e.action === "model") {
+        await openAdvisorModelPicker(ctx).catch(err => pushLine(`[error] ${err.message}`, C.error))
+      }
+    },
+  })
+}
+
+async function openAdvisorModelPicker(ctx) {
+  const { agent, openPicker, pushLine } = ctx
+  const providers = agent.providers || []
+
+  // Build flat list: each provider's name + a "use current model" entry
+  const entries = []
+  let idx = 0
+  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 })
+    idx++
+  }
+
+  openPicker({
+    title: "Advisor Model",
+    entries,
+    onSelect: async (e) => {
+      if (e.action === "set_provider") {
+        const cfg = agent.config.advisor ??= {}
+        if (e.provider === agent.activeProvider && e.model === agent.provider.model) {
+          // Same as main — clear override (use main pool)
+          delete cfg.provider
+          delete cfg.model
+          pushLine(`Advisor: 使用主模型 (${agent.activeProvider}/${agent.provider.model})`, C.dim)
+        } else {
+          cfg.provider = e.provider
+          cfg.model = e.model
+          pushLine(`Advisor: ${e.provider}/${e.model}`, C.dim)
+        }
+      }
+    },
+  })
+}

package/src/tui/cmd-think.mjs

@@ -4,20 +4,26 @@
 export async function handleThinkCommand(ctx) {
   const { agent, openPicker, syncProviderField } = ctx
   const cur = agent.provider
-  const thinkingEnabled = cur.thinking?.type === "enabled" || cur.thinking?.type === undefined
   const { specForModel } = await import("../config.mjs")
   const spec = specForModel(cur.model)
   const isEffortOnly = spec.thinkApi === "effort"
+  const thinkOnValue = spec.thinkOnValue ?? "enabled"
+  const isCustomThink = thinkOnValue !== "enabled"
+  // "enabled" when thinking.type matches the model's enabled value, or when thinking is absent and the model is NOT a custom-think model (defaults to on for standard models)
+  const thinkingEnabled = cur.thinking?.type === thinkOnValue || (cur.thinking?.type === undefined && !isCustomThink)
   const entries = []
+  // Auto-think: classify difficulty per-prompt and auto-set reasoning effort
+  const autoThinkEnabled = agent.config?.agent?.autoThink === true
+  entries.push({ type: "item", text: `Auto: ${autoThinkEnabled ? "ON" : "OFF"}`, action: "auto" })
   if (!isEffortOnly) {
-    entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
+    if (!autoThinkEnabled) entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
   }
-  if (spec.reasoningEffortEnum) {
+  if (spec.reasoningEffortEnum && !autoThinkEnabled) {
     for (const level of spec.reasoningEffortEnum) {
       const mark = cur.reasoningEffort === level ? "▸ " : "  "
       entries.push({ type: "item", text: `${mark}effort: ${level}`, action: "effort", level })
     }
-  } else {
+  } else if (!autoThinkEnabled) {
     entries.push({ type: "item", text: "effort: high", action: "effort", level: "high" })
     entries.push({ type: "item", text: "effort: max", action: "effort", level: "max" })
   }
@@ -25,7 +31,19 @@ export async function handleThinkCommand(ctx) {
     title: "Think",
     entries,
     onSelect: async (e) => {
-      if (e.action === "effort") {
+      if (e.action === "auto") {
+        const cfg = agent.config.agent ??= {}
+        cfg.autoThink = !cfg.autoThink
+        agent._pendingReminders = agent._pendingReminders ?? []
+        if (cfg.autoThink) {
+          // Turn off manual effort — auto will set it per-turn
+          delete cur.reasoningEffort
+          await syncProviderField("reasoningEffort", undefined)
+          agent._pendingReminders.push("[System reminder: Auto-think is now ON. Reasoning effort will be automatically set per-task based on difficulty classification.]")
+        } else {
+          agent._pendingReminders.push("[System reminder: Auto-think is now OFF. Reasoning effort will remain at its current manual setting.]")
+        }
+      } else if (e.action === "effort") {
         cur.reasoningEffort = e.level
         await syncProviderField("reasoningEffort", e.level)
       } else {
@@ -36,12 +54,20 @@ export async function handleThinkCommand(ctx) {
           if (!enable) await syncProviderField("reasoningEffort", undefined)
           else await syncProviderField("reasoningEffort", cur.reasoningEffort)
         } else {
-          cur.thinking = enable ? { type: "enabled" } : { type: "disabled" }
-          if (!enable) delete cur.reasoningEffort
-          else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+          if (enable) {
+            cur.thinking = { type: thinkOnValue }
+            if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+          } else {
+            // Custom-think models (MiniMax "adaptive") don't support "disabled" — remove the field instead
+            cur.thinking = isCustomThink ? undefined : { type: "disabled" }
+            delete cur.reasoningEffort
+          }
           await syncProviderField("thinking", cur.thinking)
-          if (!enable) await syncProviderField("reasoningEffort", undefined)
-          else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          if (enable) {
+            await syncProviderField("reasoningEffort", cur.reasoningEffort)
+          } else {
+            await syncProviderField("reasoningEffort", undefined)
+          }
         }
       }
     },

package/src/tui/index.mjs

@@ -22,7 +22,12 @@ 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 } from "./render-frame.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 { SLASH_COMMANDS, createSlashCommands } from "./slash-commands.mjs"
 import { createWizard } from "./wizard.mjs"
@@ -63,7 +68,7 @@ export async function startTUI(agent, opts = {}) {
     picker: null, // model picker { entries, lines, index, scroll, selectedLine }
     wizard: null, // first-launch config wizard { step, index, scroll, selectedLine, fields, error, lines }
     tasks: agent.tasks ?? [], // task list from task tool (progress shown in status bar); carried over on session restore, auto-collapsed when all done
-    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0 }, // cumulative token usage (shown in status bar)
+    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0, reasoningTokens: 0 }, // cumulative token usage (shown in status bar)
     ctxCache: { len: -1, tokens: 0 }, // context utilization estimate cache (estimateTokens is O(n), only recompute when history grows)
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
@@ -74,6 +79,7 @@ export async function startTUI(agent, opts = {}) {
     processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
     queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
+    interruptPrompt: null, // Ctrl+I interrupt message input: { text: "" } or null
   }
 
   // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)
@@ -190,7 +196,7 @@ export async function startTUI(agent, opts = {}) {
       // Can't close? fine, process is exiting anyway
     }
     process.stdin.setRawMode(false)
-    process.stdout.write(ansi.mouseOff + ansi.bracketedPasteOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
+    process.stdout.write(ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
   }
   process.on("exit", cleanup)
 
@@ -221,66 +227,171 @@ export async function startTUI(agent, opts = {}) {
 
   // ---------------------------------------------------------- Render
 
-  // Frame dedup + streaming rate limit: skip re-rendering unchanged frames (prevents flicker);
-  // merge token flood to ~25fps
-  let lastFrame = ""
-  let lastCursorRow = -1, lastCursorCol = -1
-  let renderTimer = null
+  // 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
-      render()
-    }, 40)
+      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() {
-    try {
-      // Side effects: reset scroll + update ctxCache + clamp overlay scroll
-    // (renderFrame is pure, side effects concentrated here)
-    const dims = { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }
-    const layout = computeLayout(state, dims)
-    // clamp conversation scroll
-    const convLines = countConvLines(state, dims.cols)
-    const maxScroll = Math.max(0, convLines - layout.panels.conversation.h)
-    state.scroll = Math.min(state.scroll, maxScroll)
-    // clamp overlay scroll
-    const overlay = state.picker ?? state.wizard
-    if (overlay && layout.panels.picker) {
-      const winH = layout.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 (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
     }
-    // update ctxCache
-    if (state.ctxCache.len !== agent.history.length) {
-      state.ctxCache = { len: agent.history.length, tokens: estimateTokens(agent.history) }
+    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("")
+  }
 
-    const { frame, cursorRow, cursorCol } = renderFrame(state, agent, {
-      ...dims,
-      slashCommands: SLASH_COMMANDS,
-    })
-    if (frame !== lastFrame) {
-      lastFrame = frame
-      // Single write: home + hide cursor + frame + clear-tail + cursor position — prevents flicker
-      let out = ansi.home + ansi.hideCursor + frame + ansi.clearToEnd
-      if (state.permission || state.question || state.picker || state.wizard?.step === "provider") {
-        out += ansi.hideCursor
-      } else {
-        out += `\x1b[${cursorRow};${cursorCol}H${ansi.showCursor}`
-        lastCursorRow = cursorRow
-        lastCursorCol = cursorCol
+  /** 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 || 80, rows: process.stdout.rows || 24 }
+      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
       }
-      process.stdout.write(out)
-    } else if (cursorRow !== lastCursorRow || cursorCol !== lastCursorCol) {
-      // Frame unchanged but cursor moved (e.g. arrow keys) — only reposition cursor
-      lastCursorRow = cursorRow
-      lastCursorCol = cursorCol
-      if (!(state.permission || state.question || state.picker || state.wizard?.step === "provider")) {
-        process.stdout.write(`\x1b[${cursorRow};${cursorCol}H${ansi.showCursor}`)
+      if (state.ctxCache.len !== agent.history.length) {
+        state.ctxCache = { len: agent.history.length, tokens: estimateTokens(agent.history) }
       }
-    }
+
+      // 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).
+        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
     }
@@ -312,6 +423,7 @@ export async function startTUI(agent, opts = {}) {
         const safeDuringProcessing = new Set(["/help", "/exit", "/model", "/think", "/config", "/skills", "/mcp", "/goal", "/session"])
         if (safeDuringProcessing.has(resolved0)) {
           await handleSlash(text)
+          render()
         } else {
           state.queue.push({ text })
           render()
@@ -319,14 +431,15 @@ export async function startTUI(agent, opts = {}) {
         return
       }
       await handleSlash(text)
+      render()
       return
     }
 
-    // While processing: queue for later, don't execute immediately
+    // While processing: queue for later, don't execute immediately.
+    // The queue panel (renderQueue) already shows pending items — don't also
+    // push to the conversation area, or the text scrolls up with streaming tokens.
     if (state.processing) {
       state.queue.push({ text })
-      pushLabel(`❯ You: (queued #${state.queue.length})`, ansi.bold + C.user)
-      pushLine(text, C.dim)
       render()
       return
     }
@@ -344,7 +457,7 @@ export async function startTUI(agent, opts = {}) {
 
   // Agent loop: implemented in agent-turn.mjs
   const turnCtx = {
-    agent, state, pushLine, pushLabel, render, scheduleRender, ensureAssistantLabel,
+    agent, state, pushLine, pushLabel, render, scheduleRender: render, ensureAssistantLabel,
     askPermission, askQuestion, handleSlash: null, summarize,
     get assistantLabeled() { return assistantLabeled },
     set assistantLabeled(v) { assistantLabeled = v },

package/src/tui/key-handler.mjs

@@ -91,7 +91,10 @@ export function createKeyHandler(ctx) {
               insertPastedText(state, text)
               render()
             }
-          }).catch(() => { q._pasting = false })
+          }).catch((e) => {
+            q._pasting = false
+            console.error(`[tui] clipboard paste failed: ${e.message}`)
+          })
         } else if (str && !key.ctrl && !key.meta) {
           q.answer = (q.answer ?? "") + str
           render()
@@ -111,6 +114,38 @@ export function createKeyHandler(ctx) {
       setTimeout(() => process.exit(0), 100)
     }
 
+    // Ctrl+I (or Tab during processing): interrupt and inject a message
+    if ((key.ctrl && !key.alt && key.name === "i") || (key.name === "tab" && state.processing && !state.interruptPrompt)) {
+      if (state.processing && state.controller && !state.interruptPrompt) {
+        state.interruptPrompt = { text: "" }
+        render()
+      }
+      return
+    }
+
+    // Interrupt prompt mode: type message, Enter to inject, Esc to cancel
+    if (state.interruptPrompt) {
+      if (key.name === "escape") {
+        state.interruptPrompt = null
+        render()
+      } else if (key.name === "return") {
+        const msg = (state.interruptPrompt.text ?? "").trim()
+        state.interruptPrompt = null
+        if (msg) {
+          pushLine(`  [inject] ${msg}`, C.warn)
+          state.controller.abort({ interrupt: true, message: msg })
+          render()
+        }
+      } else if (key.name === "backspace") {
+        state.interruptPrompt.text = state.interruptPrompt.text.slice(0, -1)
+        render()
+      } else if (str && !key.ctrl && !key.meta) {
+        state.interruptPrompt.text += str.replace(/[\r\n]+/g, "")
+        render()
+      }
+      return
+    }
+
     // generic list picker: ↑↓ move, Enter confirm, Esc cancel
     if (state.picker) {
       const items = state.picker?.entries.filter((e) => e.type === "item") ?? []

package/src/tui/layout.mjs

@@ -3,8 +3,8 @@
  * Computes position and height of each panel from state + terminal dimensions.
  * Does not modify state — side effects are performed by the caller before rendering.
  *
- * Panel layout (top to bottom):
- *   header → conversation → subagent → output → todo → permission → queue → input → status
+ *   header → conversation → subagent → output → todo → picker → permission → queue → input → status
+ *   header → conversation → todo → subagent → output → picker → permission → queue → input → status
  * Fixed panels deducted first, conditional panels allocated by priority, remaining space to conversation.
  */
 import { layoutInput, wrapText } from "./render.mjs"
@@ -22,7 +22,9 @@ export function computeLayout(state, { cols, rows }) {
   const W = Math.max(20, cols - 1)
 
   // --- input box ---
-  const inputLayout = layoutInput(state.input, state.cursor, W - 4)
+  const inputBuf = state.interruptPrompt ? [...state.interruptPrompt.text] : state.input
+  const inputCursor = state.interruptPrompt ? inputBuf.length : state.cursor
+  const inputLayout = layoutInput(inputBuf, inputCursor, W - 4)
   let inputOffset = 0
   if (inputLayout.lines.length > MAX_INPUT_LINES) {
     inputOffset = Math.min(inputLayout.cursorLine, inputLayout.lines.length - MAX_INPUT_LINES)
@@ -98,8 +100,8 @@ export function computeLayout(state, { cols, rows }) {
   const conversation = { y, h: convH }; y += convH
   const subagent = subPanelH > 0 ? { y, h: subPanelH } : null; y += subPanelH
   const output = outputPanelsH > 0 ? { y, h: outputPanelsH } : null; y += outputPanelsH
-  const picker = pickerH > 0 ? { y, h: pickerH } : null; y += pickerH
   const todo = taskPanelH > 0 ? { y, h: taskPanelH } : null; y += taskPanelH
+  const picker = pickerH > 0 ? { y, h: pickerH } : null; y += pickerH
   const permission = permPreviewH > 0 ? { y, h: permPreviewH } : null; y += permPreviewH
   const queue = queueH > 0 ? { y, h: queueH } : null; y += queueH
   const inputBox = { y, h: inputBoxH }; y += inputBoxH

package/src/tui/pickers.mjs

@@ -185,27 +185,27 @@ export function createPickers(ctx) {
     openPicker({
       title: "Add Provider",
       entries: presetEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         if (se.kind === "custom") {
           const name = await askQuestion("Enter provider name:")
-          if (!name) { openModelPicker().catch(() => {}); return }
-          if (agent.providers.some((p) => p.name === name)) { openModelPicker().catch(() => {}); return }
+          if (!name) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
+          if (agent.providers.some((p) => p.name === name)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const baseURLRaw = await askQuestion("Enter baseURL (e.g. https://api.example.com/v1):")
-          if (!baseURLRaw) { openModelPicker().catch(() => {}); return }
+          if (!baseURLRaw) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const baseURL = baseURLRaw.replace(/\/+$/, "")
-          if (!/^https?:\/\//.test(baseURL)) { openModelPicker().catch(() => {}); return }
+          if (!/^https?:\/\//.test(baseURL)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           const model = await askQuestion("Enter model name:")
-          if (!model) { openModelPicker().catch(() => {}); return }
+          if (!model) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
           agent.providers.push({ name, baseURL, model })
           await persistRaw((raw) => { raw.providers = agent.providers })
           const key = await askQuestion(`Enter API key for ${name} (leave empty to skip):`)
           if (key) { await setProviderKey(name, key) }
-          openModelPicker().catch(() => {})
+          openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
           return
         }
         // preset
-        if (agent.providers.some((p) => p.name === se.name)) { openModelPicker().catch(() => {}); return }
+        if (agent.providers.some((p) => p.name === se.name)) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
         const preset = PRESETS[se.name]
         const providerCfg = { name: se.name, baseURL: preset.baseURL, model: preset.model }
         if (preset.thinking) providerCfg.thinking = preset.thinking
@@ -217,7 +217,7 @@ export function createPickers(ctx) {
         await persistRaw((raw) => { raw.providers = agent.providers })
         const presetKey = await askQuestion(`Enter API key for ${se.name} (leave empty to skip):`)
         if (presetKey) await setProviderKey(se.name, presetKey)
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }
@@ -225,7 +225,7 @@ export function createPickers(ctx) {
   /** Remove provider (cannot remove the currently active one) */
   async function removeProviderFlow() {
     const candidates = agent.providers.filter((p) => p.name !== agent.activeProvider)
-    if (candidates.length === 0) { openModelPicker().catch(() => {}); return }
+    if (candidates.length === 0) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
     const removeEntries = [
       { type: "header", text: "Select provider to remove (current one cannot be removed)" },
       ...candidates.map((p) => ({ type: "item", text: `${p.name} (${p.model})`, name: p.name })),
@@ -233,12 +233,12 @@ export function createPickers(ctx) {
     openPicker({
       title: "Remove Provider",
       entries: removeEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         const at = agent.providers.findIndex((p) => p.name === se.name)
         agent.providers.splice(at, 1)
         await persistRaw((raw) => { raw.providers = agent.providers })
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }
@@ -256,12 +256,12 @@ export function createPickers(ctx) {
     openPicker({
       title: "Configure API Key",
       entries: keyEntries,
-      onCancel: () => openModelPicker().catch(() => {}),
+      onCancel: () => openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)),
       onSelect: async (se) => {
         const key = await askQuestion(`Enter API key for ${se.name}:`)
-        if (!key) { openModelPicker().catch(() => {}); return }
+        if (!key) { openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error)); return }
         await setProviderKey(se.name, key)
-        openModelPicker().catch(() => {})
+        openModelPicker().catch((e) => pushLine(`[error] ${e.message}`, C.error))
       },
     })
   }