thincoder 0.8.1 → 0.8.3

package/src/tui/index.mjs

@@ -1,19 +1,19 @@
 /**
- * tui.mjs — 裸 ANSI 终端 UI
- * 零依赖：raw mode 键盘输入、ANSI 转义渲染、自研宽字符换行。
- * 布局：header / 对话区 (可滚动）/ todo 面板 (有任务时）/ 输入框 / 状态栏。
+ * tui.mjs — bare ANSI terminal UI
+ * Zero dependencies: raw mode keyboard input, ANSI escape rendering, custom wide-char wrapping.
+ * Layout: header / conversation (scrollable) / todo panel (when tasks exist) / input box / status bar.
  *
- * 大型逻辑块已拆到独立模块：
- *   agent-turn.mjs    — agent 循环 + 回调构建
- *   key-handler.mjs   — 键盘事件分发
- *   startup.mjs       — 启动画面 + 会话恢复 + 后台索引
- *   interaction.mjs   — 权限审批 + 问答
- *   pickers.mjs       — 通用列表选择器 + 模型选择器
- *   wizard.mjs        — 首次配置向导
- *   slash-commands.mjs — 斜杠命令分发
+ * Large logic blocks extracted to independent modules:
+ *   agent-turn.mjs    — agent loop + callback construction
+ *   key-handler.mjs   — keyboard event dispatch
+ *   startup.mjs       — startup screen + session restore + background indexing
+ *   interaction.mjs   — permission approval + Q&A
+ *   pickers.mjs       — generic list picker + model picker
+ *   wizard.mjs        — first-launch config wizard
+ *   slash-commands.mjs — slash command dispatch
  *   config-helpers.mjs — persistRaw / syncProviderField / maskKey
- *   clipboard.mjs     — 剪贴板图片粘贴
- *   distill-cmd.mjs   — /distill 命令
+ *   clipboard.mjs     — clipboard image paste
+ *   distill-cmd.mjs   — /distill command
  */
 
 import { emitKeypressEvents } from "node:readline"
@@ -36,9 +36,9 @@ import { showStartup, backgroundIndex } from "./startup.mjs"
 import { createConfigHelpers } from "./config-helpers.mjs"
 
 /**
- * 启动 TUI，接管终端直到退出。
- * agent: createAgent 的返回值
- * opts: { projectDir?, team?, author? } —— /distill 写入 project/team 层时用
+ * Start the TUI, taking over the terminal until exit.
+ * agent: return value of createAgent
+ * opts: { projectDir?, team?, author? } — used by /distill when writing to project/team layers
  */
 export async function startTUI(agent, opts = {}) {
   if (!process.stdin.isTTY) {
@@ -48,52 +48,106 @@ export async function startTUI(agent, opts = {}) {
   const distillOpts = opts
 
   const state = {
-    lines: [], // 对话区行：{ text, color }
-    streaming: "", // current流式缓冲
-    input: [], // 输入缓冲区 (码点数组）
+    lines: [], // conversation lines: { text, color }
+    streaming: "", // current streaming buffer
+    input: [], // input buffer (codepoint array)
     cursor: 0,
     history: [],
     historyIndex: -1,
-    scroll: 0, // 从底部向上的滚动行数
+    scroll: 0, // scroll lines from bottom upward
     processing: false,
     controller: null, // AbortController for current agent run
     permission: null, // { name, args, resolve }
-    permissionPreview: [], // 权限审批的内容预览行 (渲染在输入框上方，不分隔）
-    question: null, // { text, options, resolve } — agent 的 question 工具回调
-    picker: null, // 模型选择器 { entries, lines, index, scroll, selectedLine }
-    wizard: null, // 首次Config向导 { step, index, scroll, selectedLine, fields, error, lines }
-    tasks: agent.tasks ?? [], // task 工具的任务列表 (状态栏显示进度）；会话恢复时直接带上，全完成自动收起
-    tokens: { prompt: 0, completion: 0, cacheHit: 0, cacheMiss: 0 }, // 累计 token 用量 (状态栏显示）
-    ctxCache: { len: -1, tokens: 0 }, // 上下文占用估算缓存 (estimateTokens 是 O(n)，history 变长才重算）
-    reasoning: "", // 思考流缓冲 (暗色展示）
-    completion: null, // Tab 补全状态 { candidates, index }
-    toolStreams: {}, // 各工具的实时输出 (按工具名隔离，并行工具互不串扰）
-    subTasks: {}, // 子 agent 面板：{ roleName: { role, text, done } }，每 role 一行，完成后标记 done 停留片刻
-    currentTool: null, // 正在执行的工具名 (状态栏显示）
-    processingStarted: 0, // 本轮处理开始时间 (状态栏计时）
+    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 }
+    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)
+    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 }
+    toolStreams: {}, // per-tool live output (isolated by tool name, parallel tools don't interleave)
+    subTasks: {}, // sub-agent panel: { roleName: { role, text, done } }, one line per role, marked done briefly after completion
+    outputPanels: {}, // generic tool output panel: { toolName: { text, done } } — streamed live during execution, collapsed to summary on completion
+    currentTool: null, // currently executing tool name (shown in status bar)
+    processingStarted: 0, // current turn start time (status bar timer)
     status: "Ready",
-    queue: [], // 处理中排队的待执行消息：[{ text }]，处理完自动取下一条
+    queue: [], // queued messages while processing: [{ text }], auto-dequeued when current turn finishes
   }
 
-  // 恢复的会话如果所有任务completed，自动收起 todo 面板 (对齐运行时行为）
+  // On session restore, if all tasks are completed, auto-collapse the todo panel (match runtime behavior)
   if (state.tasks.length > 0 && state.tasks.every((t) => t.status === "done")) {
     state.tasks = []
   }
 
-  // 输入流先过一道滤网：鼠标序列 (滚轮）在这里拦截处理，剥净后才交给 keypress 解析，
-  // 防止序列残片 (如 "64;72;42M"）漏进输入框
+  // Input stream goes through a filter: mouse sequences (scroll wheel) are intercepted and handled here,
+  // stripped clean before passing to keypress parsing, preventing sequence fragments (e.g. "64;72;42M")
+  // from leaking into the input box
   const keyStream = new PassThrough()
-  let mousePending = "" // 跨 chunk 的不完整鼠标序列尾部
+  let mousePending = "" // incomplete mouse sequence tail spanning chunks
   let lastRenderedScroll = 0
   emitKeypressEvents(keyStream)
   process.stdin.setRawMode(true)
-  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn)
+  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn)
+
+  const utf8Decoder = new TextDecoder("utf-8", { fatal: false })
+
+  let pasteMode = false
+  let pasteAccum = ""
 
   process.stdin.on("data", (chunk) => {
-    let text = mousePending + chunk.toString("utf8")
+    let text = mousePending + utf8Decoder.decode(chunk, { stream: true })
     mousePending = ""
 
-    // 滚轮：\x1b[<64;…M 上滚，\x1b[<65;…M 下滚 (每次 3 行）
+    // Bracketed paste: terminal wraps pasted text in \x1b[200~ ... \x1b[201~
+    // Insert pasted content directly into state.input to avoid slow char-by-char keypress render
+    if (pasteMode) {
+      const endIdx = text.indexOf("\x1b[201~")
+      if (endIdx >= 0) {
+        pasteAccum += text.slice(0, endIdx)
+        pasteMode = false
+        const pasted = pasteAccum.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "  ")
+        pasteAccum = ""
+        if (pasted) {
+          const chars = [...pasted]
+          state.input.splice(state.cursor, 0, ...chars)
+          state.cursor += chars.length
+          render()
+        }
+        text = text.slice(endIdx + 6)
+      } else {
+        pasteAccum += text
+        return
+      }
+    }
+
+    // Check for paste start (may appear mid-chunk alongside other input)
+    const pasteStartIdx = text.indexOf("\x1b[200~")
+    if (pasteStartIdx >= 0) {
+      const before = text.slice(0, pasteStartIdx)
+      const after = text.slice(pasteStartIdx + 6)
+      const endIdx = after.indexOf("\x1b[201~")
+      if (endIdx >= 0) {
+        // Paste begin and end in the same chunk: insert pasted content directly
+        const pasted = after.slice(0, endIdx).replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\t/g, "  ")
+        if (pasted) {
+          const chars = [...pasted]
+          state.input.splice(state.cursor, 0, ...chars)
+          state.cursor += chars.length
+          render()
+        }
+        text = before + after.slice(endIdx + 6)
+      } else {
+        // Paste spans multiple chunks: write prefix, enter paste mode
+        if (before) keyStream.write(before)
+        pasteMode = true
+        pasteAccum = after
+        return
+      }
+    }
+
+    // Scroll wheel: \x1b[<64;…M = scroll up, \x1b[<65;…M = scroll down (3 lines each)
     for (const m of text.matchAll(/\x1b\[<(\d+);\d+;\d+([Mm])/g)) {
       if (Number(m[1]) === 64) {
         state.scroll += 3
@@ -102,7 +156,7 @@ export async function startTUI(agent, opts = {}) {
       }
     }
 
-    // 剥掉完整鼠标序列；不完整的尾部留到下一块数据再拼
+    // Strip complete mouse sequences; keep incomplete tail for reassembly with next chunk
     text = text.replace(/\x1b\[<\d+;\d+;\d+[Mm]/g, "")
     const tail = text.match(/\x1b\[<[\d;]*$/)
     if (tail) {
@@ -121,38 +175,41 @@ export async function startTUI(agent, opts = {}) {
   const cleanup = () => {
     if (cleanedUp) return
     cleanedUp = true
-    // 退出前保存会话 (同步写）；先归档current到槽位，再落新——不丢
+    // Save session before exit (synchronous write); archive current to a slot first, then save new — never lose data
     try {
       archiveCurrent(agent.cwd)
       saveSession(agent, state.lines)
     } catch {
-      // 存失败不耽误退出
+      // Save failure shouldn't block exit
     }
-    // Off MCP stdio 子进程，不留孤儿
+    // Kill MCP stdio subprocesses, don't leave orphans
     try {
       closeAllMcp(agent)
     } catch {
-      // 关不掉就算了，进程马上退出
+      // Can't close? fine, process is exiting anyway
     }
     process.stdin.setRawMode(false)
-    process.stdout.write(ansi.mouseOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
+    process.stdout.write(ansi.mouseOff + ansi.bracketedPasteOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
   }
   process.on("exit", cleanup)
 
   const pushLine = (text, color) => {
     state.lines.push({ text, color })
-    if (state.lines.length > 5000) state.lines.splice(0, 1000) // 防none限增长
+    if (state.lines.length > 5000) {
+      state.lines.splice(0, 1000)
+      state.lines.unshift({ text: `... [earlier messages trimmed — ${state.lines.length} lines remaining]`, color: C.dim })
+    }
     render()
   }
 
-  /** 消息块标签：空行 + 标签行。用户/助手消息之间留出呼吸空间 */
+  /** Message block label: blank line + label line. Breathing space between user/assistant messages */
   const pushLabel = (text, color) => {
     if (state.lines.length > 0) state.lines.push({ text: "", color: C.dim })
     state.lines.push({ text, color })
     render()
   }
 
-  // 每轮对话只打一次助手标签 (首个 token 或首个工具调用时）
+  // Only emit the assistant label once per turn (on first token or first tool call)
   let assistantLabeled = false
   const ensureAssistantLabel = () => {
     if (!assistantLabeled) {
@@ -161,9 +218,10 @@ export async function startTUI(agent, opts = {}) {
     }
   }
 
-  // ---------------------------------------------------------- 渲染
+  // ---------------------------------------------------------- Render
 
-  // 帧去重 + 流式限流：内容没变的帧不重写 (防闪屏）；token 洪流合并到 ~25fps
+  // Frame dedup + streaming rate limit: skip re-rendering unchanged frames (prevents flicker);
+  // merge token flood to ~25fps
   let lastFrame = ""
   let renderTimer = null
 
@@ -176,8 +234,8 @@ export async function startTUI(agent, opts = {}) {
   }
 
   function render() {
-    // 副作用：scroll 归位 + ctxCache 更新 + overlay scroll 归位
-    // (renderFrame 是纯函数，副作用集中在此)
+    // 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
@@ -202,9 +260,9 @@ export async function startTUI(agent, opts = {}) {
     })
     if (frame !== lastFrame) {
       lastFrame = frame
-      process.stdout.write(frame)
+      process.stdout.write(ansi.hideCursor + frame)
     }
-    // 光标：输入态定位到输入框内；权限确认/菜单态时隐藏
+    // Cursor: position inside input box when editing; hide during permission/menu mode
     if (state.permission || state.question || state.picker || state.wizard?.step === "provider") {
       process.stdout.write(ansi.hideCursor)
     } else {
@@ -214,7 +272,7 @@ export async function startTUI(agent, opts = {}) {
 
   process.stdout.on("resize", render)
 
-  // ---------------------------------------------------------- 提交
+  // ---------------------------------------------------------- Submit
 
   async function submit() {
     const text = state.input.join("").trim()
@@ -225,10 +283,11 @@ export async function startTUI(agent, opts = {}) {
     state.historyIndex = -1
     state.scroll = 0
 
-    // 斜杠Commands：本地处理，不进入 agent
+    // 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
@@ -245,7 +304,7 @@ export async function startTUI(agent, opts = {}) {
       return
     }
 
-    // 处理中：入队等待，不立即执行
+    // While processing: queue for later, don't execute immediately
     if (state.processing) {
       state.queue.push({ text })
       pushLabel(`❯ You: (queued #${state.queue.length})`, ansi.bold + C.user)
@@ -257,15 +316,15 @@ export async function startTUI(agent, opts = {}) {
     await turn(text)
   }
 
-  // 交互原语：权限审批 + 问答输入，实现在 interaction.mjs
+  // Interaction primitives: permission approval + Q&A input, implemented in interaction.mjs
   const { askPermission, askQuestion } = createInteraction({
     agent, state, pushLine, pushLabel, render, summarize,
   })
 
-  // 剪贴板图片粘贴：实现在 clipboard.mjs
+  // Clipboard image paste: implemented in clipboard.mjs
   const pasteClipboardImage = () => pasteClipboardImageImpl({ agent, state, pushLine, render })
 
-  // agent 循环：实现在 agent-turn.mjs
+  // Agent loop: implemented in agent-turn.mjs
   const turnCtx = {
     agent, state, pushLine, pushLabel, render, scheduleRender, ensureAssistantLabel,
     askPermission, askQuestion, handleSlash: null, summarize,
@@ -274,17 +333,17 @@ export async function startTUI(agent, opts = {}) {
   }
   const turn = (text) => runAgentTurn(turnCtx, text)
 
-  // ---------------------------------------------------------- 斜杠Commands
+  // ---------------------------------------------------------- Slash Commands
 
-  // 配置辅助：实现在 config-helpers.mjs
+  // Config helpers: implemented in config-helpers.mjs
   const { persistRaw, syncProviderField, maskKey } = createConfigHelpers(agent)
 
-  // 模型选择器 + 通用 picker：实现在 pickers.mjs
+  // Model picker + generic picker: implemented in pickers.mjs
   const { openPicker, closePicker, renderPickerLines, openModelPicker, setProviderKey } = createPickers({
     agent, state, render, ansi, C, pushLine, pushLabel, persistRaw, askQuestion, maskKey,
   })
 
-  // 初始 Config 向导：实现在 wizard.mjs，通过 ctx 传入闭包依赖
+  // First-launch config wizard: implemented in wizard.mjs, closure deps passed via ctx
   const { startWizard, renderWizard, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems } = createWizard({
     agent, state, pushLine, pushLabel, render, persistRaw,
     openModelPicker: () => openModelPicker(),
@@ -293,7 +352,7 @@ export async function startTUI(agent, opts = {}) {
   // /distill: impl in distill-cmd.mjs, ctx-passed
   const runDistill = () => runDistillImpl({ agent, state, pushLine, render, askPermission, distillOpts })
 
-  // 斜杠命令分发、Tab 补全：实现在 slash-commands.mjs，通过 ctx 传入闭包依赖
+  // Slash command dispatch + Tab completion: implemented in slash-commands.mjs, closure deps passed via ctx
   const { handleSlash, completions, handleTab } = createSlashCommands({
     agent, state, distillOpts,
     pushLine, pushLabel, render,
@@ -304,12 +363,12 @@ export async function startTUI(agent, opts = {}) {
     runDistill,
     exit: () => { cleanup(); setTimeout(() => process.exit(0), 100) },
   })
-  // handleSlash 被 turnCtx 引用（循环依赖：submit → turn → handleSlash），在此回填
+  // handleSlash is referenced by turnCtx (circular dep: submit → turn → handleSlash), backfilled here
   turnCtx.handleSlash = handleSlash
 
-  // ---------------------------------------------------------- 键盘 / 鼠标
+  // ---------------------------------------------------------- Keyboard / Mouse
 
-  // keypress 挂在过滤后的 keyStream 上：鼠标序列已在上游滤网中处理并剥除
+  // keypress is attached to filtered keyStream: mouse sequences already intercepted and stripped upstream
   const onKeypress = createKeyHandler({
     agent, state, render, closePicker, renderPickerLines,
     handleSlash, handleTab, submit, pasteClipboardImage,
@@ -318,7 +377,7 @@ export async function startTUI(agent, opts = {}) {
   })
   keyStream.on("keypress", onKeypress)
 
-  // ---------------------------------------------------------- 启动画面 + 后台索引
+  // ---------------------------------------------------------- Startup screen + background indexing
 
   showStartup({ agent, state, opts, pushLine, pushLabel, render, startWizard })
   backgroundIndex({ agent, state, render })

package/src/tui/interaction.mjs

@@ -1,22 +1,22 @@
 import { ansi, C } from "./ansi.mjs"
 
-/** 交互原语：权限审批 + 问答输入。
- *  从 index.mjs 抽出，通过 createInteraction(ctx) 接收闭包依赖。
+/** Interaction primitives: permission approval + question input.
+ *  Extracted from index.mjs, receives closure dependencies via createInteraction(ctx).
  *  ctx: { agent, state, pushLine, pushLabel, render, summarize } */
 export function createInteraction(ctx) {
   const { agent, state, pushLine, pushLabel, render, summarize } = ctx
 
-  /** 权限请求的关键信息 (按工具定制），返回行数组。name 可能带子 agent 前缀 ("coder/bash"），取基名匹配 */
+  /** Key info for permission request (customized by tool), returns array of lines. name may have subagent prefix ("coder/bash"), use base name to match */
   function formatPermission(name, args) {
     const cap = (s, n = 1000) => (s.length > n ? `${s.slice(0, n)}…(${s.length} chars total)` : s)
     const base = name.includes("/") ? name.split("/").pop() : name
     if (base === "bash") return cap(args.command ?? "").split("\n")
     if (base === "write") {
-      // 批准写文件必须看得到要写什么：路径 + 内容预览
+      // approving file writes must show what's being written: path + content preview
       return [`${args.path} (write ${(args.content ?? "").length} chars)`, ...cap(args.content ?? "", 1000).split("\n")]
     }
     if (base === "edit") {
-      // 简易 diff：- 旧内容 / + 新内容
+      // simple diff: - old content / + new content
       return [
         `${args.path}`,
         ...cap(args.old_string ?? "", 500).split("\n").map((l) => `- ${l}`),
@@ -25,7 +25,7 @@ export function createInteraction(ctx) {
       ]
     }
     if (base === "apply_patch") {
-      // 补丁本身就是可读的 diff，直接预览
+      // patches are readable diffs themselves, preview directly
       return cap(args.patch ?? "", 1500).split("\n")
     }
     if (base === "delete") return [`${args.path}${args.force ? " (force: also delete tracked files)" : ""}`]
@@ -35,12 +35,12 @@ export function createInteraction(ctx) {
   }
 
   function askPermission(name, args) {
-    // auto 模式：完全授权，不再询问
+    // auto mode: fully authorized, no more prompts
     if (agent.autoApprove) {
       pushLine(`  [auto] ${name} ${summarize(args)}`, C.warn)
       return Promise.resolve(true)
     }
-    // 预览内容存到 permissionPreview，渲染在输入框上方紧挨"Allow?"提示
+    // store preview content in permissionPreview, rendered above input box next to "Allow?" prompt
     state.permissionPreview = formatPermission(name, args)
     return new Promise((resolve) => {
       state.permission = { name, args, resolve }
@@ -50,13 +50,14 @@ export function createInteraction(ctx) {
   }
 
   function askQuestion(text, options = []) {
-    // 一次只能问一个：question 是只读工具走并行通道，同批第二个直接驳回，
-    // 否则后到的会覆盖 state.question，先到的 Promise 永远悬挂 (agent 死等）
+    // only one question at a time: question is a read-only tool on a parallel channel,
+    // a second concurrent one is rejected directly; otherwise the later one overwrites
+    // state.question and the first Promise hangs forever (agent deadlock)
     if (state.question) {
       return Promise.resolve("(error: another question is pending; ask one at a time and wait for the answer)")
     }
     if (!options.length) {
-      // 自由文本：打开输入态让用户打字，Enter 提交
+      // free text: open input mode for user typing, Enter to submit
       pushLabel(`❯ Question`, ansi.bold + C.tool)
       for (const line of text.split("\n")) pushLine(`  ${line}`, C.text)
       return new Promise((resolve) => {
@@ -65,7 +66,7 @@ export function createInteraction(ctx) {
         render()
       })
     }
-    // 选项模式：输入框内显示列表，方向键选，Enter 确认
+    // options mode: show list in input box, arrow keys to select, Enter to confirm
     pushLabel(`❯ Question`, ansi.bold + C.tool)
     for (const line of text.split("\n")) pushLine(`  ${line}`, C.text)
     return new Promise((resolve) => {

package/src/tui/key-handler.mjs

@@ -1,7 +1,7 @@
 import { ansi, C } from "./ansi.mjs"
 
-/** 键盘事件分发：权限确认 / 问答 / picker / wizard / 编辑 / 翻页 / 历史 / 粘贴。
- *  从 index.mjs 抽出。
+/** Keyboard event dispatch: permission confirm / question / picker / wizard / edit / scroll / history / paste.
+ *  Extracted from index.mjs.
  *  ctx: { agent, state, render, renderPickerLines, closePicker,
  *         handleSlash, handleTab, submit, pasteClipboardImage,
  *         wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems,
@@ -10,7 +10,7 @@ export function createKeyHandler(ctx) {
   const { agent, state, render, closePicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup } = ctx
 
   return function onKeypress(str, key = {}) {
-    // 权限确认态：y 批准 / n 拒绝 / a 批准并On AUTO (后续不再询问）
+    // permission confirm state: y approve / n deny / a approve + turn ON AUTO (no further prompts)
     if (state.permission) {
       const answer = (str || "").toLowerCase()
       const isContinue = state.permission.name === "continue"
@@ -27,7 +27,7 @@ export function createKeyHandler(ctx) {
           pushLine(`  [auto] AUTO ON: tool calls no longer prompt for approval (/auto to disable)`, C.warn)
         }
         const approved = answer === "y" || (answer === "a" && !isContinue)
-        // 决定落痕：对话区留下批准/拒绝记录 (continue 询问有自己的输出，不重复记）
+        // leave trail: record approval/denial in conversation (continue prompt has its own output, don't duplicate)
         if (!isContinue) {
           pushLine(`  [${approved ? "approved" : "denied"}] ${name}`, approved ? C.dim : C.error)
         }
@@ -37,11 +37,11 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // question 工具回调：自由文本 / 选项选择
+    // question tool callback: free text / option selection
     if (state.question) {
       const q = state.question
       if (q.options.length > 0) {
-        // 选项模式：↑↓ 选择，Enter 确认，Esc 取消
+        // options mode: ↑↓ select, Enter confirm, Esc cancel
         if (key.name === "escape") {
           q.resolve("(cancelled)")
           state.question = null
@@ -62,7 +62,7 @@ export function createKeyHandler(ctx) {
           render()
         }
       } else {
-        // 自由文本：键入答案，Enter 提交，Esc 取消
+        // free text: type answer, Enter submit, Esc cancel
         if (key.name === "escape") {
           q.resolve("(cancelled)")
           state.question = null
@@ -97,7 +97,7 @@ export function createKeyHandler(ctx) {
       setTimeout(() => process.exit(0), 100)
     }
 
-    // 通用列表选择器：↑↓ 移动，Enter 确认，Esc 取消
+    // generic list picker: ↑↓ move, Enter confirm, Esc cancel
     if (state.picker) {
       const items = state.picker?.entries.filter((e) => e.type === "item") ?? []
       if (key.name === "escape") {
@@ -111,8 +111,8 @@ export function createKeyHandler(ctx) {
       } else if (key.name === "return" && items.length) {
         const selected = items[state.picker.index]
         const handler = state.picker.onSelect
-        state.picker = null // 先关 picker，避免 onSelect 内部 render 时 picker 还在
-        // onSelect 是 async（如删 provider 要写文件），用 catch 兜住错误不被吞
+        state.picker = null // close picker first, avoid picker still being present during onSelect render
+        // onSelect is async (e.g. removing a provider writes file), catch errors so they aren't swallowed
         Promise.resolve(handler?.(selected)).catch((err) => {
           pushLine(`[error] ${err.message}`, C.error)
         }).finally(() => render())
@@ -120,7 +120,7 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // 初始Config向导：菜单步 ↑↓/Enter/Esc；文本步 Enter 提交、Esc 取消，编辑键落到正常输入
+    // initial config wizard: menu step ↑↓/Enter/Esc; text step Enter submit, Esc cancel, edit keys fall through to normal input
     if (state.wizard) {
       const w = state.wizard
       if (key.name === "escape") {
@@ -144,11 +144,11 @@ export function createKeyHandler(ctx) {
         wizardSubmitText()
         return
       }
-      // 文本步骤屏蔽翻页/历史，其余编辑键放行到下面的普通输入逻辑
+      // text steps: block scroll/history, remaining edit keys fall through to normal input logic below
       if (key.name === "up" || key.name === "down" || key.name === "pageup" || key.name === "pagedown") return
     }
 
-    // 翻页
+    // page scroll
     if (key.name === "pageup") {
       state.scroll += Math.max(1, (process.stdout.rows || 24) - 8)
       render()
@@ -161,9 +161,9 @@ export function createKeyHandler(ctx) {
     }
 
     if (state.processing) {
-      // 处理中允许输入（排队），但屏蔽方向键历史和 Tab 补全
+      // during processing, allow input (queued), but block arrow-key history and Tab completion
       if (key.name === "tab" || key.name === "up" || key.name === "down") return
-      // Ctrl+D：删除队列中最后一条
+      // Ctrl+D: remove last item from queue
       if (key.ctrl && key.name === "d") {
         if (state.queue.length > 0) {
           state.queue.pop()
@@ -171,16 +171,24 @@ export function createKeyHandler(ctx) {
         }
         return
       }
-      // 其余可打印字符正常进入输入框
+      // remaining printable characters go into input box normally
     }
 
-    // Tab：斜杠Commands补全 (循环候选）；其余输入忽略 (\t 会顶破输入框，永不直接插入）
+    // Tab: slash-command completion (cycle candidates); other input ignored (\t would blow up input box, never inserted directly)
     if (key.name === "tab") {
       handleTab()
       return
     }
 
-    // 输入历史
+    // Ctrl+U: clear entire input box
+    if ((key.name === "u" && key.ctrl) || str === "\x15") {
+      state.input = []
+      state.cursor = 0
+      render()
+      return
+    }
+
+    // input history
     if (key.name === "up") {
       if (state.history.length) {
         state.historyIndex = state.historyIndex === -1 ? state.history.length - 1 : Math.max(0, state.historyIndex - 1)
@@ -205,7 +213,7 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // 光标移动
+    // cursor movement
     if (key.name === "left") {
       state.cursor = Math.max(0, state.cursor - 1)
       render()
@@ -227,7 +235,7 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // 编辑
+    // editing
     if (key.name === "backspace") {
       if (state.cursor > 0) {
         state.input.splice(state.cursor - 1, 1)
@@ -248,15 +256,15 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // Ctrl+V (Unix) / Alt+V (Windows)：粘贴剪贴板图片 → 存临时文件 → 输入框插入 read_image
+    // Ctrl+V (Unix) / Alt+V (Windows): paste clipboard image → save temp file → insert read_image into input box
     const isPasteImage = (key.name === "v" && (key.ctrl || key.meta)) || (key.name === "v" && key.alt)
     if (isPasteImage) {
       pasteClipboardImage(agent).catch((e) => pushLine(`[error] ${e.message}`, C.error))
       return
     }
 
-    // 可打印字符 / 粘贴 (str 可能一次多个字符）；Tab 一律转成两个空格 (\t 显示宽度不定，会顶破输入框）
-    // \r\n 在 Windows raw mode 下可能漏进来冲乱页面
+    // printable characters / paste (str may contain multiple chars at once); Tab always converted to two spaces (\t has variable display width, would blow up input box)
+    // \r\n may leak through in Windows raw mode and scramble the display
     if (str && !key.ctrl && !key.meta) {
       const chars = [...str.replace(/[\r\n]+/g, "").replace(/\t/g, "  ")]
       state.input.splice(state.cursor, 0, ...chars)