thincoder 0.12.59 → 0.12.61

package/src/tui/index.mjs

@@ -25,16 +25,16 @@ import { closeAllMcp } from "../mcp.mjs"
 import { ansi, C } from "./ansi.mjs"
 import { createRenderLoop } from "./render-loop.mjs"
 import { makeDimsState } from "./dims.mjs"
-import { SLASH_COMMANDS, SLASH_ALIASES, createSlashCommands } from "./slash-commands.mjs"
+import { SLASH_COMMANDS, createSlashCommands } from "./slash-commands.mjs"
 import { createWizard } from "./wizard.mjs"
-import { writeStartupSequence, createExitCleanup } from "./tui-lifecycle.mjs"
+import { writeStartupSequence, setTuiActive, createExitCleanup } from "./tui-lifecycle.mjs"
 import { createPickers } from "./pickers.mjs"
 import { runDistill as runDistillImpl } from "./distill-cmd.mjs"
 import { createInteraction } from "./interaction.mjs"
 import { pasteClipboardImage as pasteClipboardImageImpl, insertPastedText, translateShiftEnter, stripKeyboardProtocol } from "./clipboard.mjs"
-import { parseMouseClicks, handleWheel, createMouseDispatch } from "./mouse.mjs"
+import { parseMouseClicks, handleWheel, createMouseDispatch, mouseOob } from "./mouse.mjs"
 import { runAgentTurn } from "./agent-turn.mjs"
-import { createKeyHandler, convMaxScroll } from "./key-handler.mjs"
+import { createKeyHandler, convMaxScroll, clearAttention } from "./key-handler.mjs"
 import { showStartup, backgroundIndex, createLoadOlder } from "./startup.mjs"
 import { shiftFreezeAnchors } from "./subagent-blocks.mjs"
 import { createConfigHelpers } from "./config-helpers.mjs"
@@ -53,7 +53,12 @@ export async function promptProviderIfInvalid(agent, openModelPicker, pushLine)
   if (!(agent._providerInvalid || !agent.provider)) return false
   await openModelPicker()
   if (!agent.provider) {
-    pushLine("未配置有效 provider，可用 /model 选择或 /provider 配置", C.warn)
+    // MODEL-MERGE-SESSION 引导 A（F-6）：空槽 + defaultModel 未设 → 提示 /config 默认模型入口
+    // （index.mjs 本行为 D-S2 取消提示扩展——设计文件清单外——随批上报）
+    const hasProviders = (agent.providers?.length ?? 0) > 0
+    pushLine(hasProviders && !agent.config?.defaultModel
+      ? "尚未设置默认模型（config.defaultModel——新会话起点）：/config → 默认模型 设置一次；/model 仅改本会话"
+      : "未配置有效 provider，可用 /model 选择或 /provider 配置", C.warn)
   }
   return true
 }
@@ -106,12 +111,13 @@ export async function startTUI(agent, opts = {}) {
     reasoning: "", // thinking stream buffer (dimmed display)
     completion: null, // Tab completion state { candidates, index }
 
-    subTasks: {}, // sub-agent activity blocks (§7.2 D4): { "coder#1": { key, role, model, started, done, doneAt, blocks: [{kind,text}], currentTool, toolArgs, turn, maxTurns, approval, lastError, dropped, blockEpoch, awaitingDigest（§17 挂起中间态）, _freezeAt（冻结锚点） } } — rendered as collapsible in-conversation blocks; persists across turns (blocks are the child activity's ONLY carrier — child tool calls never enter the parent history); bounded by the N2 500-line per-child ring buffer
+    subTasks: {}, // sub-agent activity blocks (§7.2 D4): { "coder#1": { key, role, model, started, done, doneAt, blocks: [{kind,text}], currentTool, toolArgs, turn, maxTurns, approval, lastError, dropped, blockEpoch, awaitingDigest（§17 挂起中间态）, _freezeAt（冻结锚点）, stopped, children: []（SUBAGENT-TAIL：嵌套子代理**守护载体**——内容行并入本块 blocks——subagent-children.mjs） } } — rendered as collapsible in-conversation blocks; persists across turns (blocks are the child activity's ONLY carrier — child tool calls never enter the parent history); bounded by the N2 500-line per-child ring buffer（SUBAGENT-TAIL 单环：内层行同环计数、单载体最旧先行——TUI.md §6）
     currentTool: null, // currently executing tool name (shown in status bar)
     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
+    queue: [], // 交接残项单容器 [{ text }]（INPUT-LOCK：submit 不再排队——仅释放窗口兜底/挂起中止残余——回合尾队列循环续发，至多一条）
+    interruptPrompt: null, // Ctrl+I inject box（第 31 批——TUI-INPUT-BOX.md §8）: { chars: string[], cursor: number } or null
+    attentionAwaiting: false, // 第 33 批（TUI §14.3(f)）：回合结束等待输入——链尾置位 / 用户输入清位；不落盘、不进会话
     search: null, // Ctrl+F search mode: { query: "", matches: [{lineIndex, charIndex}], index: 0 } or null
     expandedBlocks: new Set(), // block hashes that are expanded (Enter toggles)
     foldEnabled: true, // global fold toggle — /fold on|off
@@ -121,13 +127,15 @@ export async function startTUI(agent, opts = {}) {
     _historyLoaded: 0, // messages loaded from the TAIL of _fullHistory
     _historyTotal: 0, // total messages in the restored session
     _hasOlder: false, // more earlier messages remain unloaded
-    _agent: null, // §19.6 D-P1 面板镜像挂载点：startTUI 装配时置 agent 引用——subagent-blocks
-    // syncPanelSnapshot 经此写 agent._panelSnapshot（块级状态变更即刷——subagent
-    // action:"panel" 读——模型可查面板视图 + 门控补发冻结）。headless/VS Code 无此
-    // 挂载 = 无镜像 → panel 动作恒降级池视图（CLI-only 完整能力——AC-P4）。
+    _agent: null, // TUI state → agent 回指挂载点：startTUI 装配时置 agent 引用——
+    // ① SYNC-CANCEL ⏹ 门控读 state._agent._syncChildAborts（subagent-panel.mjs，2026-09-09）；
+    // ② CLI-ACTIVITY-DEBLOAT F-3（2026-09-10）：agent._tuiState = state 反向挂载——
+    // action:"panel" 经 ctx.state（= agent._tuiState）**读时现算**面板块（computePanelBlocks
+    // ——subTasks 活值纯推导——单账本）。headless/VS Code 无此装配 = 无面板 → panel 动作
+    // 恒降级池视图（CLI-only 完整能力——AC-P4）。
   }
   state._agent = agent
-  agent._panelSnapshot = [] // 镜像初始态 = 空面板（非"无镜像"——[] 与 undefined 区分）
+  agent._tuiState = state // F-3：面板视图现算通道（替代退役的手工面板镜像）
 
   // 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")) {
@@ -147,6 +155,7 @@ export async function startTUI(agent, opts = {}) {
   // modifyOtherKeys lvl 2 (\x1b[>4;2m): Shift+Enter → \x1b[27;2;13~ (mintty / Git Bash)
   // translateShiftEnter (stdin layer) maps both to \x1b\r → meta+return → multiline branch.
   writeStartupSequence()
+  setTuiActive(true) // R25（F-R25a）：终端接管完成——置 TUI 活动态（崩溃钩子恢复判定源）
 
   const utf8Decoder = new TextDecoder("utf-8", { fatal: false })
 
@@ -159,6 +168,10 @@ export async function startTUI(agent, opts = {}) {
       let text = mousePending + utf8Decoder.decode(chunk, { stream: true })
       mousePending = ""
 
+    // 第 33 批（TUI §14.3(e) 鼠标点）：stdin 数据到达即用户在场 ⇒ 清 attention 位
+    // （单点覆盖下方滚轮分支与 onMouseClick；键盘入口在 key-handler）。
+    clearAttention(state, render)
+
     // Bracketed paste: terminal wraps pasted text in \x1b[200~ ... \x1b[201~
     // Route pasted content to the active text target (question answer / input box) in one shot,
     // avoiding slow char-by-char keypress render — see insertPastedText in clipboard.mjs
@@ -208,6 +221,10 @@ export async function startTUI(agent, opts = {}) {
     for (const m of text.matchAll(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g)) {
       const button = Number(m[1])
       if (button === 64 || button === 65) {
+        // F-3 sane-gate ③（RESIZE-MOUSE-LEAK-FIX）：越界 wheel 禁止会话滚动——handleWheel
+        // 对越界返回未消费会穿到 fallback 滚动（mouse.mjs 内 gate 覆盖不到此路径）
+        const dims = state.dims ? state.dims.get() : { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }
+        if (mouseOob(Number(m[2]), Number(m[3]), dims)) continue
         const consumed = handleWheel(mouseCtx(), button, Number(m[2]), Number(m[3]))
         if (!consumed) {
           if (button === 64) {
@@ -313,6 +330,14 @@ export async function startTUI(agent, opts = {}) {
   async function submit() {
     const text = state.input.join("").trim()
     if (!text) return
+    // INPUT-LOCK 防御（C'——2026-09-09）+ INPUT-LOCK-BEHAVIOR-REVISED（2026-09-09——白名单
+    // 已删——busy 全拒）：提交吞的门禁在 key-handler（busy Enter 已吞 + 提示，文本保留）——
+    // submit 只在非 busy 期达此；防御直呼/上游改动：busy 期拒绝（不清输入框不吞内容）。
+    if (state.processing) {
+      pushLine(`[主会话处理中 —— 消息未发送（回合结束后请重按 Enter）]`, C.warn)
+      render()
+      return
+    }
     state.input = []
     state.cursor = 0
     const wasInHistory = state.historyIndex !== -1
@@ -322,37 +347,14 @@ export async function startTUI(agent, opts = {}) {
     state.scroll = 0
     state._followTail = true // 2026-08-31 会诊 deepseek：新消息恢复跟随（注释曾承诺、实现缺漏）
 
-    // Slash commands: handled locally, don't enter agent loop
+    // Slash commands: handled locally, don't enter agent loop. busy 期提交在 key-handler
+    // 门禁被吞（白名单已删——斜杠同吞——INPUT-LOCK-BEHAVIOR-REVISED）——submit 仅非 busy 期可达。
     if (text.startsWith("/")) {
-      if (state.processing) {
-        // 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", "/submodel", "/shell", "/think", "/config", "/skills", "/mcp", "/goal", "/session"])
-        if (safeDuringProcessing.has(resolved0)) {
-          await handleSlash(text)
-          render()
-        } else {
-          state.queue.push({ text })
-          render()
-        }
-        return
-      }
       await handleSlash(text)
       render()
       return
     }
 
-    // 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 })
-      render()
-      return
-    }
-
     await turn(text)
   }
 

package/src/tui/interaction.mjs

@@ -47,9 +47,9 @@ export function createInteraction(ctx) {
       const action = String(args.action ?? "")
       if (action === "put") return [`[${args.type ?? ""}] ${args.title ?? ""}`, ...cap(args.content ?? "", 500).split("\n")]
       if (action === "delete") return args.id
-        ? [`delete single: ${args.id} (scope ${args.scope})`]
-        : [`batch delete scope=${args.scope} type=${args.type ?? ""} keyword=${args.keyword ?? ""}`, `confirm=${args.confirm}`]
-      if (action === "clear") return [`clear personal memory`, `scope=${args.scope} confirm=${args.confirm}`]
+        ? [`delete single: ${args.id}${args.layer ? ` (layer ${args.layer})` : ""}`]
+        : [`batch delete layer=${args.layer ?? ""} type=${args.type ?? ""} keyword=${args.keyword ?? ""}`, `confirm=${args.confirm}`]
+      if (action === "clear") return [`clear personal memory`, `layer=${args.layer ?? ""} confirm=${args.confirm}`]
       return [cap(summarize(args), 300)]
     }
     return [cap(summarize(args), 300)]

package/src/tui/key-handler.mjs

@@ -1,10 +1,22 @@
 import { ansi, C } from "./ansi.mjs"
 import { readClipboardText, insertPastedText } from "./clipboard.mjs"
-import { computeLayout } from "./layout.mjs"
+import { computeLayout, inputContentWidth } from "./layout.mjs"
+import { moveCursorVertical } from "./render.mjs"
 import { handleSearchKey } from "./key-handler-search.mjs"
 import { countConvLines } from "./render-conversation.mjs"
 import { handlePermissionMode, handleQuestionMode, handleInterruptMode } from "./key-modes.mjs"
 
+/** 第 33 批（TUI §14.3(e)——attention 清位）：输入即在场——仅当原值为真时置假 + `render()`
+ *  （已假则零副作用、零重绘）。键盘入口与本文件（`onKeypress`）与鼠标输入路径（index.mjs
+ *  stdin data 处理器）两点共用；blocked 两态无需清位（实时派生）。
+ *  @returns {boolean} 本次是否发生清位 */
+export function clearAttention(state, render) {
+  if (!state.attentionAwaiting) return false
+  state.attentionAwaiting = false
+  render()
+  return true
+}
+
 /** Current conversation max scroll offset (display lines beyond the visible panel). */
 export function convMaxScroll(state) {
   const d = state.dims ? state.dims.get() : {} // Single source (ConPTY instability, 2026-08-30) — cached dims
@@ -24,6 +36,9 @@ export function createKeyHandler(ctx) {
   const { agent, state, render, popPicker, renderPickerLines, handleSlash, handleTab, submit, pasteClipboardImage, wizardChooseProvider, wizardSubmitText, cancelWizard, wizardProviderItems, renderWizard, pushLine, cleanup, showPicker, loadOlder } = ctx
 
   return function onKeypress(str, key = {}) {
+    // 第 33 批（TUI §14.3(e) 键盘点）：模态分派**之前**——任意按键 = 用户在场 ⇒ 清 attention
+    // 位（仅复位呈现态字段，按键语义 / 模态判定 / busy 门禁零改）。
+    clearAttention(state, render)
     // permission confirm: y/n/a (a = approve + AUTO ON); batch (§16 D-B1): a/o/n (Esc = deny)
     // ——模态实现 key-modes.mjs handlePermissionMode（2026-09-03 D-S4）
     if (handlePermissionMode(str, key, { state, agent, pushLine, render })) return
@@ -59,12 +74,13 @@ export function createKeyHandler(ctx) {
           state.suspended
         if (hasStopTarget) {
           // 当前回合平 abort（无 interrupt——命中 agent.mjs 回合收尾清池分支——全停）
-          if (state.processing && state.controller) state.controller.abort()
+          // §20.3 站点 #11（第 24 批）：整批 / 会话级停 = stop（reason 载荷）
+          if (state.processing && state.controller) state.controller.abort({ abortTrigger: "stop", abortDetail: "session-stop" })
           // 会话 abort 集合 = 链条内全部 controller（含 Ctrl+I/ContinueError 重建的旧
           // controller——children 不逃逸，round1 偏差 #3）。挂起态才标记 _suspAborted +
           // 唤醒 driver（driver 收尾清池）——非挂起语境置位会粘滞阻塞未来挂起会话重入
           // （round2 偏差 #1 语义）。
-          for (const c of agent._sessionAbortAll ?? (agent._sessionAbort ? [agent._sessionAbort] : [])) c?.abort()
+          for (const c of agent._sessionAbortAll ?? (agent._sessionAbort ? [agent._sessionAbort] : [])) c?.abort({ abortTrigger: "stop", abortDetail: "session-stop" })
           if (state.suspended) {
             state._suspAborted = true
             state._suspWake?.()
@@ -159,7 +175,8 @@ export function createKeyHandler(ctx) {
     // 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: "" }
+        // 注入框状态模型（第 31 批——TUI-INPUT-BOX.md §1 不变量 9）：{ chars, cursor }，空态 = { chars: [], cursor: 0 }
+        state.interruptPrompt = { chars: [], cursor: 0 }
         render()
       }
       return
@@ -263,17 +280,19 @@ export function createKeyHandler(ctx) {
     }
 
     if (state.processing) {
-      // 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: remove last item from queue
-      if (key.ctrl && key.name === "d") {
-        if (state.queue.length > 0) {
-          state.queue.pop()
-          render()
-        }
+      // busy 门禁（INPUT-LOCK C'——2026-09-09 + INPUT-LOCK-BEHAVIOR-REVISED——2026-09-09）：
+      // processing（含 digest——单一判据）输入不禁——吞提交不吞字符（打字照常回显）；Enter
+      // 提交吞 + busy 提示——斜杠同禁发（白名单已删——/exit 也发不出——退出靠 Ctrl+C 终端
+      // 层通道——门禁前不误伤）；空 Enter 静默（text 非空才吞）；多行换行
+      // （meta/enter——编辑）照常放行。**第 31 批**：↑↓ 不再在此全屏蔽——分流下沉到下方
+      // 三规则块（竖移放行 / 历史导航禁；TUI-INPUT-BOX.md §3）；Tab 仍吞（死条件在案——原样保留）。
+      if (key.name === "tab") return
+      const isSend = (key.name === "return" && !key.meta) || (str === "\r" && !key.meta)
+      if (isSend && state.input.join("").trim()) {
+        pushLine(`[主会话处理中 —— 消息未发送（回合结束后请重按 Enter）]`, C.warn)
+        render()
         return
       }
-      // remaining printable characters go into input box normally
     }
 
     // Tab: slash-command completion (cycle candidates); other input ignored (\t would blow up input box, never inserted directly)
@@ -291,7 +310,24 @@ export function createKeyHandler(ctx) {
       return
     }
 
-    // input history
+    // ↑/↓ 三规则（TUI-INPUT-BOX.md §3——第 31 批）：① 翻历史中恒历史（多行条目不竖移）
+    // ② 竖移优先（可视行口径——折行与 \n 同权；显示列保持 + 短行端钳制）③ 边界回落历史（↑）
+    // ／无动作（↓）。processing 期：竖移放行（纯编辑——与字符/退格/←→ 同权）、历史导航禁
+    // （规则 ①/③ 的历史分支吞——不进入、不切换）。
+    if (key.name === "up" || key.name === "down") {
+      if (state.historyIndex === -1) { // 规则 ① 优先——翻历史中不竖移
+        const cols = (state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80)
+        const next = moveCursorVertical(state.input, state.cursor, inputContentWidth(cols), key.name)
+        if (next !== null) {
+          state.cursor = next // 规则 ②：竖移（草稿/历史指针零涉——D-31.6）
+          render()
+          return
+        }
+      }
+      if (state.processing) return // 规则 ①/③ 的历史分支吞——processing 期历史导航禁
+    }
+
+    // input history（规则 ① 恒历史 + 规则 ③ 边界回落——历史语义零改）
     if (key.name === "up") {
       if (state.history.length) {
         // Save current input as draft when entering history mode (historyIndex === -1).
@@ -372,15 +408,23 @@ export function createKeyHandler(ctx) {
         render()
       } else {
         const text = state.input.join("").trim()
-        // §17 D-S5/F3/F7 + 偏差 #1：挂起态（suspended 或释放窗口 _suspPending）Enter =
-        // 新回合输入（非打断）——入 pendingInput 由挂起会话调度；输入框零干扰（F3）。
+        // §17 D-S5/F3/F7 + 偏差 #1 + INPUT-LOCK 单槽化（F-6——2026-09-09）：挂起态
+        // （suspended 或释放窗口 _suspPending）Enter = 新回合输入（非打断）——填
+        // pendingInput 单槽（至多一条待交接——busy 提交吞在 L265 门禁先拦，digest 期
+        // 不会到这——仅挂起空闲/释放窗口触达）由挂起会话调度；输入框零干扰（F3）。
+        // 槽满（竞态防御——不覆盖不丢失）→ 吞 + 提示，文本保留在输入框。
         if ((state.suspended || state._suspPending) && text && !text.startsWith("/")) {
+          state.pendingInput ??= []
+          if (state.pendingInput.length > 0) {
+            pushLine(`[主会话处理中 —— 已有一条消息待发送，请等其处理完成后再发送]`, C.warn)
+            render()
+            return
+          }
           state.input = []
           state.cursor = 0
           state.history.push(text)
           state.historyIndex = -1
           state._draft = null
-          state.pendingInput ??= []
           state.pendingInput.push(text)
           state._suspWake?.()
           render()

package/src/tui/key-modes.mjs

@@ -8,6 +8,31 @@
 import { C } from "./ansi.mjs"
 import { readClipboardText, insertPastedText } from "./clipboard.mjs"
 import { QUESTION_CUSTOM } from "./interaction.mjs"
+import { inputContentWidth } from "./layout.mjs"
+import { moveCursorVertical } from "./render.mjs"
+
+/** SYNC-CANCEL v2 模态 deny 解绕（用户裁——2026-09-09）：⏹ 定向中止 sync child 时
+ *  顺带 deny 其 pending 权限/continue 模态——ask 不观 signal（R1——targeted abort 后
+ *  child 停在模态则 runChildPipeline 不返回、父回合阻塞至模态回答）。owner 判定：
+ *  工具权限 ask name 前缀 `${key}/`（subagent-spawn.mjs 装配——owner key 标识）；continue
+ *  ask args.agent === key（subagent.mjs askSubagentContinue 既有参数）。副作用镜像
+ *  handlePermissionMode deny 分支（清除模态 + deny 轨迹 + resolve(false)——子代理随即
+ *  在 abort 检出点解绕折叠）。返回 true = 本模态属该 child 且已 deny 解绕。鼠标 ⏹ 路径
+ *  （mouse.mjs cancelSubagent）调用——key-modes 是权限模态归属语义的驻点。 */
+export function denyModalForOwner(state, key, { pushLine, render } = {}) {
+  const p = state?.permission
+  if (!p) return false
+  const owned = (typeof p.name === "string" && p.name.startsWith(`${key}/`)) || p.args?.agent === key
+  if (!owned) return false
+  const { resolve, name } = p
+  state.permission = null
+  state.permissionPreview = []
+  state.status = "Processing..."
+  pushLine?.(`  [denied] ${name}`, C.error)
+  resolve(false)
+  render?.()
+  return true
+}
 
 /** permission 确认模态：y/n/a（a = approve + AUTO ON）；batch（§16 D-B1）：a/o/n（Esc = deny）。
  *  consume：valid 键或 Esc 走 resolve 分支；其余键静默吞掉（模态独占）。 */
@@ -68,10 +93,11 @@ export function handleQuestionMode(str, key, ctx) {
       state.status = "Processing..."
       render()
     } else if (key.name === "up") {
-      q.selected = Math.max(0, (q.selected ?? 0) - 1)
+      // A4（第 20 批 §12.4 契约——同义键同形）：↑↓ 环绕（原钳位——对齐 picker/wizard 既有语义）
+      q.selected = ((q.selected ?? 0) - 1 + q.options.length) % q.options.length
       render()
     } else if (key.name === "down") {
-      q.selected = Math.min(q.options.length - 1, (q.selected ?? 0) + 1)
+      q.selected = ((q.selected ?? 0) + 1) % q.options.length
       render()
     } else if (key.name === "return") {
       const answer = q.options[q.selected ?? 0]
@@ -182,16 +208,21 @@ export function handleQuestionMode(str, key, ctx) {
 }
 
 /** interruptPrompt 模态（Ctrl+I 后输入注入消息）：Enter 提交 → controller.abort
- *  { interrupt: true, message }；Esc 取消；字符进 prompt；其余键静默吞（模态独占）。
+ *  { interrupt: true, message }；Esc 取消；编辑键 = §7.2 最小集 + 四方向键（第 31 批：
+ *  `{ chars, cursor }` codepoint 模型——TUI-INPUT-BOX.md §8.1）；其余键静默吞（模态独占）。
  *  返回 false 当模态未激活（key-handler 先检 state.interruptPrompt 入口再调）。 */
 export function handleInterruptMode(str, key, ctx) {
   const { state, pushLine, render } = ctx
   if (!state.interruptPrompt) return false
+  const p = state.interruptPrompt
+  if (!Array.isArray(p.chars)) p.chars = p.chars ? [...p.chars] : [] // 形态防御（同 question 自由文本态）
+  p.cursor = Math.max(0, Math.min(p.cursor ?? p.chars.length, p.chars.length))
+  const len = p.chars.length
   if (key.name === "escape") {
     state.interruptPrompt = null
     render()
   } else if (key.name === "return") {
-    const msg = (state.interruptPrompt.text ?? "").trim()
+    const msg = p.chars.join("").trim()
     state.interruptPrompt = null
     if (msg) {
       // Guard: if the turn already finished while the user was typing, the controller
@@ -204,12 +235,59 @@ export function handleInterruptMode(str, key, ctx) {
       }
       render()
     }
-  } else if (key.name === "backspace") {
-    state.interruptPrompt.text = state.interruptPrompt.text.slice(0, -1)
+  } else if (key.name === "enter") {
+    // Ctrl+J（\n → name "enter"）= no-op 吞——单行不变式：不插换行（§8.1）
+  } else if (key.name === "left") {
+    p.cursor = Math.max(0, p.cursor - 1)
+    render()
+  } else if (key.name === "right") {
+    p.cursor = Math.min(len, p.cursor + 1)
+    render()
+  } else if (key.name === "up" || key.name === "down") {
+    // 折行竖移（§8.1）：显示列保持 + 短行端钳制；无邻行 = 吞（零副作用——无历史回落）
+    const cols = (state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80)
+    const next = moveCursorVertical(p.chars, p.cursor, inputContentWidth(cols), key.name)
+    if (next !== null) {
+      p.cursor = next
+      render()
+    }
+  } else if (key.name === "home") {
+    p.cursor = 0
     render()
-  } else if (str && !key.ctrl && !key.meta) {
-    state.interruptPrompt.text += str.replace(/[\r\n]+/g, "")
+  } else if (key.name === "end") {
+    p.cursor = len
     render()
+  } else if (key.ctrl && !key.alt && key.name === "u") {
+    p.chars = []
+    p.cursor = 0
+    render()
+  } else if (key.name === "backspace") {
+    if (p.cursor > 0) {
+      p.chars.splice(p.cursor - 1, 1) // codepoint 元素删除——emoji 不劈半
+      p.cursor--
+      render()
+    }
+  } else if (key.ctrl && !key.alt && !key.meta && key.name === "v") {
+    // Ctrl+V 粘贴：落 cursor 位置（\n/\r 去除、\t → 2 空格——insertPastedText 注入框分支）。
+    // 异步读剪贴板期间框可能已 Esc/Enter 关闭 → 回调守卫比对同一引用，防落主输入框
+    // （同 question 态 stale-paste 守卫语义；不加守卫会静默落 state.input）。
+    const target = p
+    readClipboardText().then((text) => {
+      if (text && state.interruptPrompt === target) {
+        insertPastedText(state, text)
+        render()
+      }
+    }).catch((e) => console.error(`[tui] clipboard paste failed: ${e.message}`))
+  } else if (str && !key.ctrl && !key.meta && key.name !== "tab" && key.name !== "enter") {
+    // 可打印字符插入光标位置（codepoint 拆字）；\r\n 剥离 + \t→2 空格（单行不变式）
+    const chars = [...str.replace(/[\r\n]+/g, "").replace(/\t/g, "  ")]
+    if (chars.length) {
+      p.chars.splice(p.cursor, 0, ...chars)
+      p.cursor += chars.length
+      render()
+    }
   }
+  // 未列键（Delete/PgUp/PgDn/F1/…）一律 consume return——无 fall-through（模态独占；§8.1：
+  // Delete 不引入——与 §7.2 最小集对齐）
   return true
 }

package/src/tui/layout.mjs

@@ -3,7 +3,7 @@
  * Computes position and height of each panel from state + terminal dimensions.
  * Does not modify state — side effects are performed by the caller before rendering.
  *
- *   header → conversation → subagent 面板 → todo → picker → permission → queue → input → status
+ *   header → conversation → subagent 面板 → todo → picker → permission → input → status
  * Running subagent activity renders in a FIXED bottom panel between the
  * conversation and the todo panel (AGENT-LOOP.md §7.2.1) — full adaptive height
  * (the conversation shrinks); compressed away first on small terminals (to 0 =
@@ -26,6 +26,13 @@ const MAX_INPUT_LINES = 5
 const MAX_TASK_LINES = 5
 const QWIN = 5
 
+/** 输入框内容宽度单源（第 31 批——TUI-INPUT-BOX.md §9.3 #3）：`computeLayout` 的输入框
+ *  layoutInput 宽度与键处理侧竖移（`moveCursorVertical`）共用——布局与竖移零漂移。
+ *  含 2 列行前缀（`▸ ` / 续行 2 空格）；layoutInput 内部再为前缀预留 2 列。 */
+export function inputContentWidth(cols) {
+  return Math.max(20, cols - 1) - 4
+}
+
 /** question 自由文本态渲染布局：与主输入框同实现（TUI-INPUT-BOX.md §7.2 round2 #1/#6）——
  *  折行展开（`▸ ` 首行 + 续行 2 空格缩进）+ 光标行列；answer 单行不变式（无 \n 字符）由
  *  输入侧硬守卫（Ctrl+J no-op / 粘贴 \n→空格），此处只复用 layoutInput 的折行/光标语义，
@@ -40,11 +47,14 @@ export function layoutAnswer(chars, cursor, width) {
  */
 export function computeLayout(state, { cols, rows }) {
   const W = Math.max(20, cols - 1)
+  const inputW = inputContentWidth(cols) // 输入框内容宽（= W - 4）——单源：布局与竖移共用
 
   // --- input box ---
-  const inputBuf = state.search ? [...state.search.query] : (state.interruptPrompt ? [...state.interruptPrompt.text] : state.input)
-  const inputCursor = state.search ? inputBuf.length : (state.interruptPrompt ? inputBuf.length : state.cursor)
-  const inputLayout = layoutInput(inputBuf, inputCursor, W - 4)
+  // Ctrl+I 注入框（第 31 批）：{ chars, cursor } codepoint 数组 + 光标——与主输入框同渲染路径（§8）。
+  const ip = state.interruptPrompt
+  const inputBuf = state.search ? [...state.search.query] : (ip ? ip.chars : state.input)
+  const inputCursor = state.search ? inputBuf.length : (ip ? Math.max(0, Math.min(ip.cursor ?? inputBuf.length, inputBuf.length)) : state.cursor)
+  const inputLayout = layoutInput(inputBuf, inputCursor, inputW)
   let inputOffset = 0
   if (inputLayout.lines.length > MAX_INPUT_LINES) {
     inputOffset = Math.min(inputLayout.cursorLine, inputLayout.lines.length - MAX_INPUT_LINES)
@@ -66,7 +76,7 @@ export function computeLayout(state, { cols, rows }) {
     } else {
       const answerChars = Array.isArray(q.answer) ? q.answer : q.answer ? [...q.answer] : []
       const qCursor = Math.max(0, Math.min(q.cursor ?? answerChars.length, answerChars.length))
-      questionLayout = layoutAnswer(answerChars, qCursor, W - 4)
+      questionLayout = layoutAnswer(answerChars, qCursor, inputW)
       if (questionLayout.lines.length > MAX_INPUT_LINES) {
         questionOffset = Math.min(questionLayout.cursorLine, questionLayout.lines.length - MAX_INPUT_LINES)
       }
@@ -127,11 +137,10 @@ export function computeLayout(state, { cols, rows }) {
     permPreviewH = 1 + permPreviewLines.length // 1 for header line
   }
 
-  // Queue preview (1 line when queue has items and processing)
-  const queueH = state.queue.length > 0 && state.processing ? 1 : 0
+  // Queue 面板已撤（INPUT-LOCK-ASYNC F-7——2026-09-09——busy 提交吞——无排队展示）
 
   // --- elastic panel: conversation takes remaining space ---
-  const fixedH = headerH + inputBoxH + statusH + pickerH + taskPanelH + permPreviewH + queueH + subagentH
+  const fixedH = headerH + inputBoxH + statusH + pickerH + taskPanelH + permPreviewH + subagentH
   let convH = Math.max(1, rows - fixedH)
 
   // 小终端高度补偿：subagent 面板最先让位（可至 0 隐藏，活动仍进缓冲区不丢），
@@ -183,13 +192,12 @@ export function computeLayout(state, { cols, rows }) {
   const todo = todoFinalH > 0 ? { y, h: todoFinalH } : null; y += todoFinalH
   const picker = pickerFinalH > 0 ? { y, h: pickerFinalH } : null; y += pickerFinalH
   const permission = permFinalH > 0 ? { y, h: permFinalH } : null; y += permFinalH
-  const queue = queueH > 0 ? { y, h: queueH } : null; y += queueH
   const inputBox = { y, h: inputBoxH }; y += inputBoxH
   const status = { y, h: statusH }
 
   return {
     W, cols, rows,
-    panels: { header, conversation, subagent, picker, todo, permission, queue, inputBox, status },
+    panels: { header, conversation, subagent, picker, todo, permission, inputBox, status },
     // precomputed content (affects height, reused during render)
     inputLayout,
     inputOffset,

package/src/tui/model-catalog.mjs

@@ -0,0 +1,89 @@
+/**
+ * model-catalog.mjs — 会话级模型清单 helper（PROVIDER.md §16.2 M2/M9——2026-09-10 MODEL-SELECTION）。
+ *
+ * 清单唯一权威 = provider 运行期拉取（`GET /models`——provider/list-models.mjs 按 format 分派）。
+ * 本模块提供：
+ * - `getProviderModels(providerConfig)`：拉取 + **会话级缓存**（TTL 60s；失败不缓存——下次重试）；
+ * - `probeChannelModels(providerConfig)`：配置阶段准入探（M9——探通入缓存候选直接可用 / 探不通返回
+ *   明示文案；调用方决定标注与「不入可选来源」——绝不阻断保存）；
+ * - `modelListFailureText(error)`：M8 失败消息本体（逐字长句——界面明示的唯一断言对象）；
+ * - `dedupeModels` / `modelSeries`：显示归并（自 model-picker.mjs 迁入——会话面与槽位面共用）。
+ *
+ * 缓存时钟可注入（`_catalogHooks.now`——先例 rate.mjs `_rateHooks`）：测试假时钟确定性断言 T6 不依赖壁钟。
+ */
+import { listModels } from "../provider/list-models.mjs"
+
+/** 会话级缓存 TTL（§16.4 a2：连续操作不重复付网络；60s 新鲜窗口）。 */
+const CACHE_TTL_MS = 60_000
+
+/** 测试钩子（先例 `rate.mjs` `_rateHooks`）：时钟可注入——T6 假时钟断言。 */
+export const _catalogHooks = { now: () => Date.now() }
+
+/** 会话内缓存：key = name + baseURL（同渠道不同端点各自成条）；value = { models, at }。 */
+const _cache = new Map()
+
+/** 测试缝：清空会话缓存（跨用例隔离——生产无调用点）。 */
+export function _clearModelCatalogCache() { _cache.clear() }
+
+function cacheKey(providerConfig) {
+  return `${providerConfig?.name ?? ""}\u0000${providerConfig?.baseURL ?? ""}`
+}
+
+/**
+ * 拉取渠道模型清单（会话缓存 TTL 60s）。命中缓存（TTL 内）直接返回，否则走 M1 拉取；
+ * **失败不缓存**（下次调用重试——失败态由调用方降级展示）。
+ * `fresh: true` 跳过缓存读（仍写回——M9 准入探必须真发一次请求：换 key 不得被旧 key 的缓存短路）。
+ * 抛错契约与 listModels 一致。
+ */
+export async function getProviderModels(providerConfig, { signal, fresh = false } = {}) {
+  const key = cacheKey(providerConfig)
+  if (!fresh) {
+    const hit = _cache.get(key)
+    if (hit && _catalogHooks.now() - hit.at < CACHE_TTL_MS) return hit.models
+  }
+  const models = await listModels(providerConfig, { signal })
+  _cache.set(key, { models, at: _catalogHooks.now() })
+  return models
+}
+
+/** M8 失败消息本体（逐字长句——状态 = HTTP 状态码或网络错误摘要；无绕过指引）。
+ *  分工：消息本体 = 本长句；状态标签 = `不可用`（列表行内短标）。 */
+export function modelListFailureText(error) {
+  const status = /GET \/models failed (\d+)/.exec(error?.message ?? "")?.[1]
+    ?? String(error?.message ?? error)
+  return `该渠道不提供模型列表（GET /models ${status}）——无法选择模型，请改用其他渠道`
+}
+
+/**
+ * M9 配置阶段准入探：对目标渠道探一次 `GET /models`（复用 M1 + 既有超时；**fresh——真发一次
+ * 请求**（换 key 不被旧缓存短路）；探通入会话缓存——该流内候选直接可用）。
+ * 返回 `{ ok:true, list }` | `{ ok:false, message }`——**不抛错**（探不通不是异常：调用方标注
+ * 不可用 + 明示原因，配置流不阻断）。
+ */
+export async function probeChannelModels(providerConfig) {
+  try {
+    return { ok: true, list: await getProviderModels(providerConfig, { fresh: true }) }
+  } catch (error) {
+    return { ok: false, message: modelListFailureText(error) }
+  }
+}
+
+/** Strip known version/date suffixes to get the "series" name of a model.
+ *  e.g. "qwen-max-latest" → "qwen-max", "qwen-max-2024-09-19" → "qwen-max" */
+export function modelSeries(name) {
+  return name
+    .replace(/-latest$/, "")
+    .replace(/-\d{4}-\d{2}-\d{2}$/, "") // date suffix like -2024-09-19
+    .replace(/-\d{8}$/, "")              // date suffix like -20240919
+}
+
+/** Dedupe model list: group by series, keep shortest name per group. */
+export function dedupeModels(models) {
+  const groups = new Map()
+  for (const m of models) {
+    const series = modelSeries(m)
+    const existing = groups.get(series)
+    if (!existing || m.length < existing.length) groups.set(series, m)
+  }
+  return [...groups.values()].sort()
+}