thincoder 0.10.0 → 0.11.1

package/src/tui/cmd-think.mjs

@@ -1,19 +1,87 @@
+import { C } from "./ansi.mjs"
+
 /** /think command: toggle thinking mode, set reasoning effort.
  *  Extracted from slash-commands.mjs.
- *  ctx: { agent, openPicker, syncProviderField } */
-export async function handleThinkCommand(ctx) {
-  const { agent, openPicker, syncProviderField } = ctx
+ *  ctx: { agent, showPicker, syncProviderField, pushLine } */
+export async function handleThinkCommand(ctx, args = []) {
+  const { agent, showPicker, syncProviderField, pushLine } = ctx
   const cur = agent.provider
   const { specForModel } = await import("../config.mjs")
   const spec = specForModel(cur.model)
   const isEffortOnly = spec.thinkApi === "effort"
-  const thinkOnValue = spec.thinkOnValue ?? "enabled"
+  const thinkOnValue = spec.thinkEnabledValue ?? "enabled"
   const isCustomThink = thinkOnValue !== "enabled"
+  const effortLevels = spec.reasoningEffortEnum ?? ["high", "max"]
+
+  async function apply(e) {
+    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 {
+      const enable = e.action === "on"
+      if (isEffortOnly) {
+        if (!enable) delete cur.reasoningEffort
+        else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
+        if (!enable) await syncProviderField("reasoningEffort", undefined)
+        else await syncProviderField("reasoningEffort", cur.reasoningEffort)
+      } else {
+        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", cur.reasoningEffort)
+        } else {
+          await syncProviderField("reasoningEffort", undefined)
+        }
+      }
+    }
+  }
+
+  // Direct args: /think on|off │ /think effort <level>
+  // autoThink 开启时手动值每轮被覆盖（picker 里也隐藏了开关/effort 项），直参同样拒绝
+  const autoThinkEnabled = agent.config?.agent?.autoThink === true
+  const sub = args[0]?.toLowerCase()
+  if (sub === "on" || sub === "off") {
+    if (autoThinkEnabled) { pushLine("Auto-think is ON — manual settings are overridden each turn; turn Auto off first via /think", C.error); return }
+    await apply({ action: sub })
+    pushLine(`Thinking: ${sub}`, C.dim)
+    return
+  }
+  if (sub === "effort") {
+    const level = args[1]?.toLowerCase()
+    if (!level || !effortLevels.includes(level)) {
+      pushLine(`Usage: /think effort <${effortLevels.join("|")}>`, C.error)
+      return
+    }
+    if (autoThinkEnabled) { pushLine("Auto-think is ON — manual settings are overridden each turn; turn Auto off first via /think", C.error); return }
+    await apply({ action: "effort", level })
+    pushLine(`Thinking effort: ${level}`, C.dim)
+    return
+  }
+  if (sub) { pushLine("Usage: /think [on|off|effort <level>]", C.error); return }
+
   // "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) {
     if (!autoThinkEnabled) entries.push({ type: "item", text: `Thinking: ${thinkingEnabled ? "ON" : "OFF"}`, action: thinkingEnabled ? "off" : "on" })
@@ -27,49 +95,6 @@ export async function handleThinkCommand(ctx) {
     entries.push({ type: "item", text: "effort: high", action: "effort", level: "high" })
     entries.push({ type: "item", text: "effort: max", action: "effort", level: "max" })
   }
-  openPicker({
-    title: "Think",
-    entries,
-    onSelect: async (e) => {
-      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 {
-        const enable = e.action === "on"
-        if (isEffortOnly) {
-          if (!enable) delete cur.reasoningEffort
-          else if (!cur.reasoningEffort) cur.reasoningEffort = "high"
-          if (!enable) await syncProviderField("reasoningEffort", undefined)
-          else await syncProviderField("reasoningEffort", cur.reasoningEffort)
-        } else {
-          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", cur.reasoningEffort)
-          } else {
-            await syncProviderField("reasoningEffort", undefined)
-          }
-        }
-      }
-    },
-  })
+  const e = await showPicker("Think", entries)
+  if (e) await apply(e)
 }

package/src/tui/cmd-undo.mjs

@@ -41,7 +41,7 @@ export function snapshotForUndo(agent, toolName, args, cwd) {
 }
 
 export async function handleUndoCommand(ctx) {
-  const { agent, pushLine, openPicker } = ctx
+  const { agent, pushLine, showPicker } = ctx
   const stack = agent._undoStack ?? []
 
   if (stack.length === 0) {
@@ -65,27 +65,23 @@ export async function handleUndoCommand(ctx) {
     }),
   ]
 
-  openPicker({
-    title: "Undo",
-    entries,
-    onSelect: async (e) => {
-      const item = stack[e.idx]
-      const abs = join(agent.cwd, ...item.path.split("/"))
+  const e = await showPicker("Undo", entries)
+  if (!e) return
+  const item = stack[e.idx]
+  const abs = join(agent.cwd, ...item.path.split("/"))
 
-      try {
-        if (item.backup === null) {
-          // File was created — undo deletes it
-          if (existsSync(abs)) unlinkSync(abs)
-        } else {
-          // File was modified — undo restores original
-          writeFileSync(abs, item.backup, "utf8")
-        }
-        // Remove this and all newer entries (can't undo out of order)
-        stack.splice(e.idx)
-        pushLine(`[undo] Reverted: ${item.tool} ${item.path}`, C.tool)
-      } catch (err) {
-        pushLine(`[undo] Failed to revert ${item.path}: ${err.message}`, C.error)
-      }
-    },
-  })
+  try {
+    if (item.backup === null) {
+      // File was created — undo deletes it
+      if (existsSync(abs)) unlinkSync(abs)
+    } else {
+      // File was modified — undo restores original
+      writeFileSync(abs, item.backup, "utf8")
+    }
+    // Remove this and all newer entries (can't undo out of order)
+    stack.splice(e.idx)
+    pushLine(`[undo] Reverted: ${item.tool} ${item.path}`, C.tool)
+  } catch (err) {
+    pushLine(`[undo] Failed to revert ${item.path}: ${err.message}`, C.error)
+  }
 }

package/src/tui/cmd-upgrade.mjs

@@ -1,7 +1,9 @@
+import { ansi, C } from "./ansi.mjs"
+
 /** /upgrade command: check for updates and optionally upgrade.
- *  ctx: { agent, pushLine, pushLabel, openPicker, ansi, C } */
+ *  ctx: { agent, pushLine, pushLabel, showPicker } */
 export async function handleUpgradeCommand(ctx) {
-  const { pushLine, pushLabel, openPicker, ansi, C } = ctx
+  const { pushLine, pushLabel, showPicker } = ctx
   const { checkForUpdate } = await import("../upgrade.mjs")
   const { readFileSync } = await import("node:fs")
 
@@ -19,29 +21,23 @@ export async function handleUpgradeCommand(ctx) {
     return
   }
   pushLine(`thincoder ${result.latest} is available (current: ${result.local}).`, C.tool)
-  openPicker({
-    title: `Update: ${result.local} → ${result.latest}`,
-    entries: [
-      { type: "header", text: `New version: ${result.latest}` },
-      { type: "item", text: "Upgrade now", action: "upgrade" },
-      { type: "item", text: "Later", action: "later" },
-    ],
-    onSelect: async (sel) => {
-      if (sel.action === "upgrade") {
-        pushLabel(`❯ Upgrade`, ansi.bold + C.tool)
-        pushLine(`Upgrading to ${result.latest}...`, C.tool)
-        const { exec } = await import("node:child_process")
-        const cp = exec("npm install -g thincoder@latest", { windowsHide: true })
-        cp.stdout?.on("data", () => {})
-        cp.stderr?.on("data", () => {})
-        cp.on("close", (code) => {
-          if (code === 0) {
-            pushLine(`✓ Upgraded to ${result.latest}. Restart to apply.`, C.tool)
-          } else {
-            pushLine(`✗ Upgrade failed (exit ${code}). Run \`thincoder upgrade\` manually.`, C.error)
-          }
-        })
-      }
-    },
+  const sel = await showPicker(`Update: ${result.local} → ${result.latest}`, [
+    { type: "header", text: `New version: ${result.latest}` },
+    { type: "item", text: "Upgrade now", action: "upgrade" },
+    { type: "item", text: "Later", action: "later" },
+  ])
+  if (sel?.action !== "upgrade") return
+  pushLabel(`❯ Upgrade`, ansi.bold + C.tool)
+  pushLine(`Upgrading to ${result.latest}...`, C.tool)
+  const { exec } = await import("node:child_process")
+  const cp = exec("npm install -g thincoder@latest", { windowsHide: true })
+  cp.stdout?.on("data", () => {})
+  cp.stderr?.on("data", () => {})
+  cp.on("close", (code) => {
+    if (code === 0) {
+      pushLine(`✓ Upgraded to ${result.latest}. Restart to apply.`, C.tool)
+    } else {
+      pushLine(`✗ Upgrade failed (exit ${code}). Run \`thincoder upgrade\` manually.`, C.error)
+    }
   })
 }

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,16 +20,9 @@ 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 { SLASH_COMMANDS, createSlashCommands } from "./slash-commands.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"
 import { runDistill as runDistillImpl } from "./distill-cmd.mjs"
@@ -40,6 +33,17 @@ import { createKeyHandler } from "./key-handler.mjs"
 import { showStartup, backgroundIndex } from "./startup.mjs"
 import { createConfigHelpers } from "./config-helpers.mjs"
 
+/** 升级失败提示文案：附 npm 输出尾部（最多 3 行），方便定位失败原因。 */
+export function upgradeFailureText(code, output) {
+  const tail = (output ?? "").trimEnd().split("\n").slice(-3).join("\n")
+  return `✗ Upgrade failed (exit ${code}). Run \`thincoder upgrade\` manually.${tail ? `\n${tail}` : ""}`
+}
+
+/** 后台更新提示可弹出的条件：无任何交互弹层（picker/permission/question）激活。 */
+export function pendingNoticeReady(state) {
+  return Boolean(state.pendingNotice && !state.picker && !state.permission && !state.question)
+}
+
 /**
  * Start the TUI, taking over the terminal until exit.
  * agent: return value of createAgent
@@ -65,7 +69,9 @@ export async function startTUI(agent, opts = {}) {
     permission: null, // { name, args, resolve }
     permissionPreview: [], // content preview lines for permission approval (rendered above input box, without separation)
     question: null, // { text, options, resolve } — agent question tool callback
-    picker: null, // model picker { entries, lines, index, scroll, selectedLine }
+    picker: null, // active picker (stack top) { title, entries, lines, index, scroll, selectedLine, filter }
+    pickerStack: [], // picker 栈：showPicker push，Enter/Esc pop；state.picker 始终指向栈顶
+    pendingNotice: null, // 后台更新提示：有 picker 打开时挂起，picker 全部关闭后再弹
     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, reasoningTokens: 0 }, // cumulative token usage (shown in status bar)
@@ -95,6 +101,11 @@ export async function startTUI(agent, opts = {}) {
   const keyStream = new PassThrough()
   let mousePending = "" // incomplete mouse sequence tail spanning chunks
   let lastRenderedScroll = 0
+  // Capture terminal dimensions before raw mode & alt buffer switch.
+  // On Windows, process.stdout.columns/rows can briefly return falsy after the mode switch
+  // (ConPTY buffer transition), causing the ||80/||24 fallback to produce a cramped initial layout.
+  const startupCols = process.stdout.columns || 80
+  const startupRows = process.stdout.rows || 24
   emitKeypressEvents(keyStream)
   process.stdin.setRawMode(true)
   process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn)
@@ -229,175 +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 || 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
-      }
-      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
-    }
-  }
+  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 */ }
@@ -417,11 +264,10 @@ export async function startTUI(agent, opts = {}) {
     // Slash commands: handled locally, don't enter agent loop
     if (text.startsWith("/")) {
       if (state.processing) {
-        // While processing: read-only commands (switch/view/help) execute directly;
-        // side-effect commands (clear/new/reindex/extract) are queued
-        const cmd0 = text.split(/\s+/)[0]
-        const ALIASES = { "/h": "/help", "/x": "/exit", "/m": "/model", "/p": "/plan", "/t": "/think", "/c": "/clear", "/n": "/new" }
-        const resolved0 = ALIASES[cmd0] ?? cmd0
+        // While processing: allowlisted commands execute directly (they only touch
+        // local TUI/agent config, never the in-flight turn); the rest are queued
+        const cmd0 = text.split(/\s+/)[0].toLowerCase()
+        const resolved0 = SLASH_ALIASES[cmd0] ?? cmd0
         const safeDuringProcessing = new Set(["/help", "/exit", "/model", "/think", "/config", "/skills", "/mcp", "/goal", "/session"])
         if (safeDuringProcessing.has(resolved0)) {
           await handleSlash(text)
@@ -472,7 +318,7 @@ export async function startTUI(agent, opts = {}) {
   const { persistRaw, syncProviderField, maskKey } = createConfigHelpers(agent)
 
   // Model picker + generic picker: implemented in pickers.mjs
-  const { openPicker, closePicker, renderPickerLines, openModelPicker, setProviderKey } = createPickers({
+  const { closePicker, showPicker, popPicker, renderPickerLines, openModelPicker, selectModel, setProviderKey } = createPickers({
     agent, state, render, ansi, C, pushLine, pushLabel, persistRaw, askQuestion, maskKey,
   })
 
@@ -489,9 +335,10 @@ export async function startTUI(agent, opts = {}) {
   const { handleSlash, completions, handleTab } = createSlashCommands({
     agent, state, distillOpts,
     pushLine, pushLabel, render,
-    openPicker, askQuestion, askPermission,
+    showPicker, closePicker, askQuestion, askPermission,
     persistRaw, syncProviderField, maskKey,
     openModelPicker: () => openModelPicker(),
+    selectModel,
     setProviderKey,
     runDistill,
     exit: () => { cleanup(); setTimeout(() => process.exit(0), 100) },
@@ -503,7 +350,7 @@ export async function startTUI(agent, opts = {}) {
 
   // keypress is attached to filtered keyStream: mouse sequences already intercepted and stripped upstream
   const onKeypress = createKeyHandler({
-    agent, state, render, closePicker, renderPickerLines,
+    agent, state, render, popPicker, renderPickerLines,
     handleSlash, handleTab, submit, pasteClipboardImage,
     wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
     renderWizard, pushLine, cleanup,
@@ -523,6 +370,30 @@ export async function startTUI(agent, opts = {}) {
   backgroundIndex({ agent, state, render })
 
   // Check for updates (non-blocking, after startup screen)
+  // 有 picker 打开时不硬抢：挂到 state.pendingNotice，picker 全部关闭后由 doRender 弹出
+  const showUpdateNotice = async (result) => {
+    const sel = await showPicker(`Update available: ${result.local} → ${result.latest}`, [
+      { type: "header", text: `thincoder ${result.latest} is available (current: ${result.local})` },
+      { type: "item", text: "Upgrade now", action: "upgrade" },
+      { type: "item", text: "Later", action: "later" },
+    ])
+    if (sel?.action !== "upgrade") return
+    pushLabel(`❯ Upgrade`, ansi.bold + C.tool)
+    pushLine(`Upgrading to ${result.latest}...`, C.tool)
+    const { exec } = await import("node:child_process")
+    const cp = exec("npm install -g thincoder@latest", { windowsHide: true })
+    let stdout = ""
+    cp.stdout?.on("data", (d) => { stdout += d })
+    cp.stderr?.on("data", (d) => { stdout += d })
+    cp.on("close", (code) => {
+      if (code === 0) {
+        pushLine(`✓ Upgraded to ${result.latest}. Restart to apply.`, C.tool)
+      } else {
+        pushLine(upgradeFailureText(code, stdout), C.error)
+      }
+      render()
+    })
+  }
   ;(async () => {
     try {
       const { readFileSync } = await import("node:fs")
@@ -535,33 +406,8 @@ export async function startTUI(agent, opts = {}) {
           pushLine(`Tip: thincoder ${result.latest} is available (run /upgrade later or restart)`, C.dim)
           render()
         } else {
-          openPicker({
-            title: `Update available: ${result.local} → ${result.latest}`,
-            entries: [
-              { type: "header", text: `thincoder ${result.latest} is available (current: ${result.local})` },
-              { type: "item", text: "Upgrade now", action: "upgrade" },
-              { type: "item", text: "Later", action: "later" },
-            ],
-            onSelect: async (sel) => {
-              if (sel.action === "upgrade") {
-                pushLabel(`❯ Upgrade`, ansi.bold + C.tool)
-                pushLine(`Upgrading to ${result.latest}...`, C.tool)
-                const { exec } = await import("node:child_process")
-                const cp = exec("npm install -g thincoder@latest", { windowsHide: true })
-                let stdout = ""
-                cp.stdout?.on("data", (d) => { stdout += d })
-                cp.stderr?.on("data", (d) => { stdout += d })
-                cp.on("close", (code) => {
-                  if (code === 0) {
-                    pushLine(`✓ Upgraded to ${result.latest}. Restart to apply.`, C.tool)
-                  } else {
-                    pushLine(`✗ Upgrade failed (exit ${code}). Run \`thincoder upgrade\` manually.`, C.error)
-                  }
-                  render()
-                })
-              }
-            },
-          })
+          state.pendingNotice = result
+          render()
         }
       }
     } catch { /* network error or timeout — silently skip */ }