thincoder 0.12.60 → 0.12.61

package/src/tui/cmd-eng.mjs

@@ -1,14 +1,14 @@
 /** /eng command: toggle engineering mode.
- *  Requires METHODOLOGY.md in project root. Offers to create one if missing.
- *  ctx: { agent, pushLine, pushLabel, showPicker } */
-import { existsSync, copyFileSync, readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from "node:fs"
-import { join, dirname } from "node:path"
-import { fileURLToPath } from "node:url"
+ *  No prerequisites (FR11): the mode works on any project — no methodology file,
+ *  no docs tree, no git. The retired gate demanded a methodology file and offered
+ *  to create it from a template that no longer ships — that option crashed
+ *  (PORTABILITY P14). ctx: { agent, pushLine, pushLabel } */
+import { readFileSync, writeFileSync, mkdirSync, renameSync, unlinkSync } from "node:fs"
+import { dirname } from "node:path"
 import { ansi, C } from "./ansi.mjs"
 import { activeSlot, slotPath } from "../session.mjs"
 import { purgeExpiredDesignTokens } from "../token-ttl.mjs"
 
-const templateDir = join(fileURLToPath(import.meta.url), "..", "..", "prompts")
 import { ENG_OFF_REMINDER } from "../agent.mjs"
 
 /** Atomic slot write (same shape as session.mjs writeSessionFile — kept local to avoid a
@@ -26,29 +26,13 @@ export function writeSessionFile(p, data) {
 }
 
 export async function handleEngCommand(ctx) {
-  const { agent, pushLine, pushLabel, showPicker } = ctx
+  const { agent, pushLine, pushLabel } = ctx
   agent.config.agent ??= {}
-  const methodologyPath = join(agent.cwd, "METHODOLOGY.md")
-
-  // Toggle on: check METHODOLOGY.md exists
-  if (!agent.config.agent.engineering) {
-    if (!existsSync(methodologyPath)) {
-      pushLabel("❯ Eng", ansi.bold + C.tool)
-      pushLine("METHODOLOGY.md not found in project root.", C.warn)
-      const choice = await showPicker("Create METHODOLOGY.md?", [
-        { type: "header", text: "Engineering mode requires a methodology file" },
-        { type: "item", text: "Yes, create from template", action: "create" },
-        { type: "item", text: "No, cancel", action: "cancel" },
-      ])
-      if (!choice || choice.action !== "create") return
-      const src = join(templateDir, "methodology-template.md")
-      copyFileSync(src, methodologyPath)
-      pushLine(`Created METHODOLOGY.md (from template) → edit it to fit your project`, C.tool)
-    }
-  }
 
+  // Toggle on/off — no prerequisite check (FR11: engineering mode depends on no
+  // project file at all; a missing docs tree or git repo must not block it).
   agent.config.agent.engineering = !agent.config.agent.engineering
-  // §24 D-24b: per-review instances die with the mode (fresh convergence cycles
+  // §11.2 D-24b: per-review instances die with the mode (fresh convergence cycles
   // on the next toggle).
   agent._advisorRuns = new Map()
   if (!agent.config.agent.engineering) {
@@ -67,7 +51,7 @@ export async function handleEngCommand(ctx) {
   pushLabel("❯ Eng", ansi.bold + C.tool)
   pushLine(`Engineering mode: ${agent.config.agent.engineering ? "ON" : "OFF"} (session)`, C.tool)
   if (agent.config.agent.engineering) {
-    pushLine(`  → strictly following ${methodologyPath}`, C.dim)
+    pushLine(`  → design-before-code enforced (design review + user approval before code)`, C.dim)
     if (clearedExpired > 0) {
       pushLine(`  → cleared ${clearedExpired} expired design token${clearedExpired === 1 ? "" : "s"}; valid tokens from prior reviews stay usable`, C.dim)
     }

package/src/tui/cmd-exit.mjs

@@ -1,9 +1,7 @@
-/** /exit command: exit TUI (same path as Ctrl+C).
- *  Direct synchronous process.exit — prevents the post-handler render()
- *  from redrawing the TUI over the cleaned terminal. The actual cleanup
- *  (saveSession + closeMcp + terminal reset) runs once
- *  via the process.on("exit") handler registered in index.mjs.
- */
-export async function handleExitCommand(_ctx) {
-  process.exit(0)
+/** /exit command: exit TUI via ctx.exit（F-2——RESIZE-MOUSE-LEAK-FIX——与 Ctrl+C 同退出
+ *  形态：cleanup 同步执行 + 延迟 exit——非同派发路径）。不再直调 process.exit(0)（零提前量——
+ *  清理押 'exit' 事件）；handleSlash 返回后的无条件 render() 由 render-loop tuiActive 守卫
+ *  抑制（cleanup 已清活动态——不把 TUI 帧重绘到已恢复的主屏）。 */
+export async function handleExitCommand(ctx) {
+  ctx.exit?.() // ctx.exit 由 index.mjs 装配（cleanup + 100ms 延迟 exit）
 }

package/src/tui/cmd-model.mjs

@@ -1,23 +1,25 @@
 import { C } from "./ansi.mjs"
+import { parseModelRef } from "../config.mjs"
 
-/** /model command: open model picker, or switch provider directly via `/model <provider>[:model]`.
+/** /model command: open the session model picker, or switch the SESSION model directly via
+ *  `/model <provider>:<model>`（MODEL-MERGE-SESSION——裁定③：裸 provider 拒——显式 p:m；
+ *  MODEL-SELECTION v2：显式复合一律放行——仅[空值/裸值/未知 provider]无效（M4），候选清单
+ *  由运行期拉取决定——不再有成员校验）。
+ *  /model 是会话级操作（写槽——不写 config）——config 默认模型走 /config → 默认模型。
  *  ctx: { agent, openModelPicker, selectModel, pushLine } */
 export async function handleModelCommand(ctx, args = []) {
-  const raw = args[0]?.toLowerCase()
+  const raw = args[0]?.trim()
   if (!raw) {
     ctx.openModelPicker().catch((e) => ctx.pushLine(`[error] ${e.message}`, C.error))
     return
   }
-  // Parse "provider:model" syntax
-  const colonIdx = raw.indexOf(":")
-  const providerName = colonIdx >= 0 ? raw.slice(0, colonIdx) : raw
-  const modelName = colonIdx >= 0 ? raw.slice(colonIdx + 1) : null
-
-  const target = ctx.agent.providers.find((p) => p.name.toLowerCase() === providerName)
-  if (!target) {
-    const available = ctx.agent.providers.map((p) => p.name).join(", ")
-    ctx.pushLine(`Unknown provider: ${providerName} (available: ${available})`, C.error)
+  // 首冒号复合解析（parseModelRef——裸 provider / 未知 provider / 空模型段 → ok:false；
+  // 候选外/多冒号一律放行——M4）
+  const parsed = parseModelRef(raw, ctx.agent.providers)
+  if (!parsed.ok) {
+    ctx.pushLine(`[error] ${parsed.reason}`, C.error)
+    ctx.pushLine(`/model 用法: /model provider:model（会话级——config 默认走 /config → 默认模型）`, C.dim)
     return
   }
-  await ctx.selectModel({ provider: target.name, model: modelName || target.model }).catch((e) => ctx.pushLine(`[error] ${e.message}`, C.error))
+  await ctx.selectModel({ provider: parsed.provider.name, model: parsed.model }).catch((e) => ctx.pushLine(`[error] ${e.message}`, C.error))
 }

package/src/tui/cmd-reindex.mjs

@@ -40,5 +40,12 @@ export async function handleReindexCommand(ctx) {
   ])
   pushLine(`  code: ${cr.total} files, +${cr.updated} ~${cr.skipped} -${cr.removed}`, C.dim)
   pushLine(`  doc: ${dr.total} files, +${dr.updated} ~${dr.skipped} -${dr.removed}`, C.dim)
+  // Unlisted extensions (PORTABILITY PO-9): files the index skipped because no
+  // index claims their extension — visible here + declarable in the project.
+  const unlisted = cr?.unlistedExts?.count ? cr.unlistedExts : dr?.unlistedExts
+  if (unlisted?.count > 0) {
+    const sample = unlisted.exts.map((e) => e.ext).join(" ")
+    pushLine(`  ${unlisted.count} file(s) with unlisted extension(s) skipped (${sample}) — declare them in .thincoder/conventions.json (index.codeExtensions / index.docExtensions) to index them`, C.warn)
+  }
   pushLine(`[reindex] Done, ${total} entries total. Vectors will be lazily generated on next search.`, C.tool)
 }

package/src/tui/cmd-submodel.mjs

@@ -1,7 +1,7 @@
 import { ansi, C } from "./ansi.mjs"
 
 /** Subagent role slots — each has an independent model override slot */
-export const SUBMODEL_SLOTS = ["explore", "plan", "coder", "eng-coder"]
+export const SUBMODEL_SLOTS = ["explore", "plan", "coder", "eng-coder", "eng-designer"]
 
 /** Human-readable effective display with inheritance source. role=null → global slot.
  *  source semantics: "type" = role-specific override (subagentModels[role]),
@@ -21,12 +21,14 @@ function slotDisplay(agent, role) {
 
 /** /submodel command: subagent model config — picker menu (default) or direct args.
  *  ctx: { agent, pushLine, showPicker, askQuestion, persistRaw, pickModelForSlot }
- *  /submodel                        → picker: global + 4 role slots
+ *  /submodel                        → picker: global + 5 role slots
  *  /submodel <value>                → set global default
  *  /submodel <type> <value>         → set a role slot
  *  /submodel <type>                 → show a slot
  *  /submodel reset [type]           → clear global (or a slot)
- *  value forms: provider:model | provider name | model name (same as subagent tool model arg) */
+ *  value forms: provider:model | provider name | model name (same as subagent tool model arg) —
+ *  MODEL-MERGE-SESSION：会话模型 = provider:model 复合（agent.activeProvider/activeModel 双字段
+ *  恒非空——无渠道默认字段——父会话模型引用一律复合值）。 */
 export async function handleSubmodelCommand(ctx, args = []) {
   const { agent, pushLine, showPicker, askQuestion, persistRaw, pickModelForSlot } = ctx
   const input = args.join(" ").trim()
@@ -85,7 +87,7 @@ export async function handleSubmodelCommand(ctx, args = []) {
     return
   }
 
-  // ── Picker menu: global + 4 role slots ──
+  // ── Picker menu: global + 5 role slots ──
   // for(;;) loop relies on showPicker's async/Promise suspension — every iteration
   // awaits a user choice; Esc (null) exits. Mirrors openModelPicker's menu-loop pattern.
   for (;;) {
@@ -132,7 +134,8 @@ export async function handleSubmodelCommand(ctx, args = []) {
         pushLine(`Subagent global model set to \`${value}\`.`, C.text)
       }
     } else if (sub.action === "parent") {
-      const value = `${agent.activeProvider}:${agent.activeModel ?? agent.provider?.model}`
+      // 会话复合值语义（MODEL-MERGE-SESSION——activeModel 恒非空——不再回退渠道字段）
+      const value = `${agent.activeProvider}:${agent.activeModel ?? ""}`
       if (role) {
         await persist((a) => { a.subagentModels ??= {}; a.subagentModels[role] = value })
       } else {

package/src/tui/cmd-undo.mjs

@@ -6,7 +6,7 @@
  */
 
 import { existsSync, writeFileSync, unlinkSync, readFileSync } from "node:fs"
-import { join } from "node:path"
+import { isAbsolute, join } from "node:path"
 import { ansi, C } from "./ansi.mjs"
 
 const MAX_UNDO = 50
@@ -20,7 +20,8 @@ export function snapshotForUndo(agent, toolName, args, cwd) {
   const path = args.path ?? args.file
   if (!path || typeof path !== "string") return
 
-  const abs = join(cwd, ...path.split("/"))
+  // 绝对路径直接用（path.join 对绝对段不重置——Windows 反斜杠路径也不按 "/" 切分）；相对路径整段 join(cwd)。
+  const abs = isAbsolute(path) ? path : join(cwd, path)
   let backup = null
   try {
     if (existsSync(abs)) {
@@ -68,7 +69,7 @@ export async function handleUndoCommand(ctx) {
   const e = await showPicker("Undo", entries)
   if (!e) return
   const item = stack[e.idx]
-  const abs = join(agent.cwd, ...item.path.split("/"))
+  const abs = isAbsolute(item.path) ? item.path : join(agent.cwd, item.path)
 
   try {
     if (item.backup === null) {

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, 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（冻结锚点）, stopped, children: []（§27 R23 嵌套子代理子块载体——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（R23：子块计入外层同配额——树级 trim）
+    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")) {
@@ -160,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
@@ -209,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) {
@@ -314,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
@@ -323,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/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
 }