thincoder 0.12.52 → 0.12.54

package/src/tui/cmd-session.mjs

@@ -1,11 +1,14 @@
-import { listSlots, switchToSlot, applySession, renameSlot, activeSlot } from "../session.mjs"
+import { listSlots, switchToSlot, applySession, renameSlot, activeSlot, slotOccupancy } from "../session.mjs"
 import { ansi, C } from "./ansi.mjs"
 import { restoreLines } from "./startup.mjs"
+import { stringWidth, sliceByWidth } from "./render.mjs"
 
 /** /rename <title> — rename the ACTIVE session (slot file + manifest, shared with VS Code). */
 export async function handleRenameCommand(ctx, args) {
   const { agent, pushLine, pushLabel, render } = ctx
-  const slot = activeSlot(agent.cwd)
+  // 2026-09-01 会诊 glm 🟡：用粘性槽而非 activeSlot（后者有认领副作用）——与 saveSession
+  // 的 _slot ??= activeSlot 语义一致：已钉槽直接重命名，未钉才认领。
+  const slot = agent._slot ?? activeSlot(agent.cwd)
   const current = agent.title || "(untitled)"
   const title = args.join(" ").trim()
   if (!title) {
@@ -38,11 +41,15 @@ export async function handleSessionCommand(ctx) {
     const dt = new Date(d)
     return `${dt.getMonth() + 1}/${dt.getDate()} ${String(dt.getHours()).padStart(2, "0")}:${String(dt.getMinutes()).padStart(2, "0")}`
   }
-  const truncate = (s, n) => s.length <= n ? s : s.slice(0, n - 1) + "…"
+  const truncate = (s, n) => (stringWidth(s) <= n ? s : sliceByWidth(s, Math.max(1, n - 1)) + "…")
   const entries = [
     { type: "header", text: `Sessions (● = active, ↑↓ select, Enter switch, Esc cancel; /rename <title> renames the active one)` },
     ...slots.map((s) => {
-      const label = s.title || (s.firstMessage ? `"${truncate(s.firstMessage, 40)}"` : "(empty)")
+      // 2026-08-31 会诊：行宽必须按显示宽度截断（原按 UTF-16 length 截 40 = 中文 80 格，
+      // 顶到右边距后叠加二义字符宽度低估（│/—/● 渲染 2 格算 1 格）→ 行实际超宽 → 物理
+      // wrap → 残影）；title 此前完全不截断（可任意长）也是超宽源，一并宽度截断。
+      const rawLabel = s.title || (s.firstMessage ? `"${s.firstMessage}"` : "(empty)")
+      const label = truncate(rawLabel, 36)
       const turns = s.turnCount > 0 ? `${s.turnCount} turns` : "0 turns"
       const when = shortDate(s.updatedAt)
       const model = s.activeProvider ? ` — ${s.activeProvider}` : ""
@@ -56,11 +63,17 @@ export async function handleSessionCommand(ctx) {
   ]
   const e = await showPicker("Sessions", entries)
   if (!e) return
+  // 2026-08-31 会诊 deepseek 🔴：目标槽被另一活进程占用时 switchToSlot 不认领（避免
+  // 劫持对方 active），本次会话仍读到数据，但下次保存会 fork 到新槽——提前提示。
+  const occ = slotOccupancy(agent.cwd, e.slot)
   const data = switchToSlot(agent.cwd, e.slot)
   if (!data) {
     pushLine(`Slot ${e.slot} not found`, C.dim)
     return
   }
+  if (occ.occupied) {
+    pushLine(`⚠ Slot ${e.slot} is being used by another live process (${occ.owner}) — continuing here will create a new copy on the next save`, C.warn)
+  }
   applySession(agent, data)
   // Rebuild from history (lazy) — the display snapshot is deprecated.
   state.lines = []

package/src/tui/fold-block.mjs

@@ -36,8 +36,31 @@ export function isExpanded(state, foldKey) {
 /** Bidirectional toggle (mouse click / future keyboard path share this). */
 export function toggleFoldBlock(state, foldKey) {
   state.expandedBlocks ??= new Set()
-  if (state.expandedBlocks.has(foldKey)) state.expandedBlocks.delete(foldKey)
-  else state.expandedBlocks.add(foldKey)
+  if (state.expandedBlocks.has(foldKey)) {
+    state.expandedBlocks.delete(foldKey)
+    state._foldScroll?.delete(foldKey) // 2026-08-31 会诊 kimi：收起清理块内滚动残留（防 Map 缓涨）
+  } else {
+    state.expandedBlocks.add(foldKey)
+  }
+}
+
+/** 块内滚动：展开态窗口起点（2026-08-31 用户需求——60% 封顶保留、块内可滚动读全文）。
+ *  存在 = state._foldScroll: Map<foldKey, offset>（渲染读、点击/滚轮写）。 */
+export function foldScrollOffset(state, foldKey) {
+  return state._foldScroll?.get(foldKey) ?? 0
+}
+
+/** 块内滚动步长：▲/▼ 控制行 = 一整窗（winH）；滚轮 = 3 行（与外部会话滚动节拍一致）。
+ *  dir=+1 向下（offset 增）、-1 向上；upper = 合法上限（total-winH），提供时写时钳制
+ *  （2026-08-31 会诊 glm：▲▼ 过冲原靠渲染 clamp 收敛→每次点击双重建缓存）。 */
+export function scrollFoldBlock(state, foldKey, dir, step, upper) {
+  state._foldScroll ??= new Map()
+  const prev = state._foldScroll.get(foldKey) ?? 0
+  let next = prev + dir * Math.max(1, Math.floor(step))
+  if (upper != null) next = Math.min(next, upper)
+  next = Math.max(0, next)
+  state._foldScroll.set(foldKey, next)
+  return next
 }
 
 /** Fold marker line: bold-cyan icon + "click to …" phrase underlined (clickable affordance).
@@ -191,18 +214,43 @@ export function renderExpandedBlock({ body, foldKey, state, maxRows, label, cols
   })
   const out = [blankLine(), foldHintLine(`▼ … ${label} — click to collapse`, foldKey)]
   const cap = foldCapRows(maxRows)
-  if (lined.length <= cap) {
+  if (lined.length <= cap - 5) {
+    // 2026-08-31 用户需求：整块（含控制行）≤ 60% 屏时全量显示
     out.push(...lined)
     return out
   }
-  // Reserve room for blank + top control + cap marker + bottom control.
-  const keep = Math.max(1, cap - 4)
-  out.push(...lined.slice(0, keep))
-  out.push({
-    text: `│ … ${body.length - keep} more lines — expansion capped at 60% of screen (collapse to re-expand)`,
-    color: C.dim,
-    _skipDimFold: true,
-  })
+  // 块高 60% 封顶保留（用户 2026-08-30 拍板），正文改窗口显示（2026-08-31）：
+  // 窗口 = cap 内可读行数（扣除 blank+顶部控制+▲+▼+底部收起 = 5 行开销）；
+  // ▲/▼ 控制行点击翻窗（_foldScrollUp/_foldScrollDown 标记，mouse.mjs 分派）——
+  // 滚动读全文、收起控制行永远在块尾。
+  const winH = Math.max(1, cap - 5)
+  const total = lined.length
+  const offset = Math.min(Math.max(0, foldScrollOffset(state, foldKey)), Math.max(0, total - winH))
+  // 2026-08-31：clamp 写回状态——否则 scrollFoldBlock 越界累积（渲染只看 clamped、事件判定
+  // 却看原值），handleWheel 会误判"未到边界"→ 永远命中块 → 穿不出块 → 会话顶/懒加载不可达
+  if (state._foldScroll?.get(foldKey) !== offset) {
+    state._foldScroll ??= new Map()
+    state._foldScroll.set(foldKey, offset)
+  }
+  const window = lined.slice(offset, offset + winH).map((l) => ({
+    ...l,
+    _foldBlock: foldKey, // 2026-08-31 滚轮命中标记：每行自描述所属块（mouse handleWheel 用——无需区间簿记）
+    _foldWindow: winH,
+    _foldTotal: total,
+  }))
+  if (offset > 0) {
+    out.push({
+      text: `▲ 上方还有 ${offset} 行（点击向上翻窗）`,
+      color: C.dim, _skipDimFold: true, _foldScrollUp: foldKey, _foldWindow: winH, _foldTotal: total,
+    })
+  }
+  out.push(...window)
+  if (offset + winH < total) {
+    out.push({
+      text: `▼ 下方还有 ${total - offset - winH} 行（点击向下翻窗）`,
+      color: C.dim, _skipDimFold: true, _foldScrollDown: foldKey, _foldWindow: winH, _foldTotal: total,
+    })
+  }
   out.push(foldHintLine(`▼ … ${label} — click to collapse`, foldKey))
   return out
 }

package/src/tui/index.mjs

@@ -25,13 +25,14 @@ import { createRenderLoop } from "./render-loop.mjs"
 import { makeDimsState } from "./dims.mjs"
 import { SLASH_COMMANDS, SLASH_ALIASES, createSlashCommands } from "./slash-commands.mjs"
 import { createWizard } from "./wizard.mjs"
+import { writeStartupSequence, 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, handleMouseClick } from "./mouse.mjs"
+import { parseMouseClicks, handleMouseClick, handleWheel } from "./mouse.mjs"
 import { runAgentTurn } from "./agent-turn.mjs"
-import { createKeyHandler } from "./key-handler.mjs"
+import { createKeyHandler, convMaxScroll } from "./key-handler.mjs"
 import { showStartup, backgroundIndex, historyToLines, HISTORY_PAGE_MESSAGES } from "./startup.mjs"
 import { countConvLines } from "./render-conversation.mjs"
 import { createConfigHelpers } from "./config-helpers.mjs"
@@ -77,6 +78,8 @@ export async function startTUI(agent, opts = {}) {
     historyIndex: -1,
     _draft: null, // stashed unsent input while navigating history (restored on down past newest)
     scroll: 0, // scroll lines from bottom upward
+    _foldScroll: new Map(), // 2026-08-31 块内滚动：foldKey → 窗口 offset（展开块 ▲▼ 翻窗）
+    _followTail: true, // 2026-08-31 流式跟随：渲染前 scroll=0；用户上滚暂停、到底/新消息恢复
     processing: false,
     controller: null, // AbortController for current agent run
     permission: null, // { name, args, resolve }
@@ -127,15 +130,48 @@ export async function startTUI(agent, opts = {}) {
   // kitty push (\x1b[>1u): Shift+Enter → \x1b[13;2u (Windows Terminal 1.19+, VS Code, kitty, iTerm2)
   // 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.
-  process.stdout.write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn + ansi.keyboardPush + ansi.modifyOtherKeysOn)
+  writeStartupSequence()
 
   const utf8Decoder = new TextDecoder("utf-8", { fatal: false })
 
   let pasteMode = false
   let pasteAccum = ""
 
+  /** 懒加载更早历史（2026-08-31 用户约定："滚动到头自动加载"——滚轮/PgUp 到顶皆触发；
+   *  2026-08-31 前只挂 PgUp 键 = 违约，滚轮到头无反应）。加载后滚动补偿保持锚定。
+   *  外层作用域：data 回调（滚轮分支）与 createKeyHandler ctx（PgUp 分支）共用。 */
+  const loadOlder = () => {
+    if (!state._hasOlder) return
+    const full = agent._fullHistory ?? []
+    const loaded = state._historyLoaded
+    const start = Math.max(0, full.length - loaded - HISTORY_PAGE_MESSAGES)
+    const end = full.length - loaded
+    if (start >= end) return
+
+    const d = state.dims ? state.dims.get() : {}
+    const cols = d.cols ?? ((state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80))
+    const before = countConvLines(state, cols, d.rows ?? (process.stdout.rows || 24))
+
+    if (state.lines[0]?.text?.startsWith("… ")) state.lines.shift()
+    state._lineIdCounter = state._lineIdCounter ?? 0
+    const older = historyToLines(full, start, end)
+    for (const l of older) l._lineId = ++state._lineIdCounter
+    state.lines.unshift(...older)
+    state._historyLoaded += end - start
+    state._hasOlder = start > 0
+    if (state._hasOlder) {
+      state.lines.unshift({ text: `… ${start} more earlier messages (scroll to top to load)`, color: C.dim })
+    }
+
+    const after = countConvLines(state, cols, (state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24))
+    state.scroll += Math.max(0, after - before)
+    render()
+  }
+
+
   process.stdin.on("data", (chunk) => {
     try {
+
       let text = mousePending + utf8Decoder.decode(chunk, { stream: true })
       mousePending = ""
 
@@ -183,13 +219,24 @@ export async function startTUI(agent, opts = {}) {
       }
     }
 
-    // Scroll wheel: \x1b[<64;…M = scroll up, \x1b[<65;…M = scroll down (3 lines each)
+    // Scroll wheel: \x1b[<64;col;rowM = up, \x1b[<65;col;rowM = down（3 lines each）
+    // 2026-08-31：坐标命中展开块内容行 → 块内滚动（handleWheel）；未命中 → 会话滚动（现状）
   // eslint-disable-next-line no-control-regex -- 有意为之：控制字符协议/转义序列剥离正则（ANSI/⟦ev⟧/SGR/history 双线分隔）
-    for (const m of text.matchAll(/\x1b\[<(\d+);\d+;\d+([Mm])/g)) {
-      if (Number(m[1]) === 64) {
-        state.scroll += 3
-      } else if (Number(m[1]) === 65) {
-        state.scroll = Math.max(0, state.scroll - 3)
+    for (const m of text.matchAll(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g)) {
+      const button = Number(m[1])
+      if (button === 64 || button === 65) {
+        const consumed = handleWheel(mouseCtx(), button, Number(m[2]), Number(m[3]))
+        if (!consumed) {
+          if (button === 64) {
+            state.scroll += 3
+            state._followTail = false // 2026-08-31：用户上滚 = 暂停流式跟随（不抢视角）
+            // 2026-08-31 用户约定修复：滚动到头自动加载（原来只挂 PgUp 键——违约）
+            if (state._hasOlder && state.scroll >= convMaxScroll(state)) loadOlder()
+          } else {
+            state.scroll = Math.max(0, state.scroll - 3)
+            if (state.scroll === 0) state._followTail = true // 滚回底部恢复跟随
+          }
+        }
       }
     }
 
@@ -227,27 +274,7 @@ export async function startTUI(agent, opts = {}) {
     }
   })
 
-  let cleanedUp = false
-  const cleanup = () => {
-    if (cleanedUp) return
-    cleanedUp = true
-    // Save session before exit (synchronous write).
-    // Archiving to a slot is handled by /new and /session switch — not on every exit,
-    // otherwise simply opening and closing the TUI repeatedly would fill all slots with duplicates.
-    try {
-      saveSession(agent)
-    } catch {
-      // Save failure shouldn't block exit
-    }
-    // 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.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.keyboardPop + ansi.modifyOtherKeysOff + ansi.mainBuffer + ansi.showCursor + ansi.reset)
-  }
+  const cleanup = createExitCleanup({ agent, saveSession, closeAllMcp })
   process.on("exit", cleanup)
 
   const pushLine = (text, color, kind) => {
@@ -266,43 +293,6 @@ export async function startTUI(agent, opts = {}) {
     render()
   }
 
-  /**
-   * Load the next earlier page of restored history (lazy, parity with VS Code
-   * loadOlder). Prepends earlier source lines and compensates scroll so the
-   * visible content does not jump. Called from key-handler when PgUp hits the top.
-   */
-  const loadOlder = () => {
-    if (!state._hasOlder) return
-    const full = agent._fullHistory ?? []
-    const loaded = state._historyLoaded
-    const start = Math.max(0, full.length - loaded - HISTORY_PAGE_MESSAGES)
-    const end = full.length - loaded
-    if (start >= end) return
-
-    const d = state.dims ? state.dims.get() : {}
-    const cols = d.cols ?? ((state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80))
-    const before = countConvLines(state, cols, d.rows ?? (process.stdout.rows || 24))
-
-    // Drop the old placeholder, prepend the older page, re-add the placeholder
-    // (with an updated count) only if more remain.
-    if (state.lines[0]?.text?.startsWith("… ")) state.lines.shift()
-    state._lineIdCounter = state._lineIdCounter ?? 0
-    const older = historyToLines(full, start, end)
-    for (const l of older) l._lineId = ++state._lineIdCounter
-    state.lines.unshift(...older)
-    state._historyLoaded += end - start
-    state._hasOlder = start > 0
-    if (state._hasOlder) {
-      state.lines.unshift({ text: `… ${start} more earlier messages (PgUp at top to load)`, color: C.dim })
-    }
-
-    // Scroll compensation: prepending N display rows must move scroll by N to
-    // keep the previously-visible bottom-anchored content in place.
-    const after = countConvLines(state, cols, (state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24))
-    state.scroll += Math.max(0, after - before)
-    render()
-  }
-
   // Only emit the assistant label once per turn (on first token or first tool call)
   let assistantLabeled = false
   const ensureAssistantLabel = () => {
@@ -341,6 +331,7 @@ export async function startTUI(agent, opts = {}) {
     state.historyIndex = -1
     if (!wasInHistory) state._draft = null // submitted — the draft is now history. Keep draft when submitting from history mode (↓ can recover)
     state.scroll = 0
+    state._followTail = true // 2026-08-31 会诊 deepseek：新消息恢复跟随（注释曾承诺、实现缺漏）
 
     // Slash commands: handled locally, don't enter agent loop
     if (text.startsWith("/")) {
@@ -448,6 +439,7 @@ export async function startTUI(agent, opts = {}) {
 
   // Mouse clicks (SGR \x1b[<0;col;rowM) — picker selection + fold expansion.
   const onMouseClick = (col, row) => handleMouseClick({ state, render, popPicker }, col, row)
+  const mouseCtx = () => ({ state, render })
 
   // ---------------------------------------------------------- Startup screen + background indexing
 

package/src/tui/key-handler.mjs

@@ -6,7 +6,7 @@ import { countConvLines } from "./render-conversation.mjs"
 import { QUESTION_CUSTOM } from "./interaction.mjs"
 
 /** Current conversation max scroll offset (display lines beyond the visible panel). */
-function convMaxScroll(state) {
+export function convMaxScroll(state) {
   // Single source (Windows ConPTY instability, 2026-08-30) — cached dims.
   const d = state.dims ? state.dims.get() : {}
   const cols = d.cols ?? ((state.dims?.get() ?? {}).cols ?? (process.stdout.columns || 80))
@@ -298,11 +298,13 @@ export function createKeyHandler(ctx) {
       } else {
         state.scroll += Math.max(1, ((state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24)) - 8)
       }
+      state._followTail = false // 2026-08-31：用户上滚 = 暂停流式跟随
       render()
       return
     }
     if (key.name === "pagedown") {
       state.scroll = Math.max(0, state.scroll - Math.max(1, ((state.dims?.get() ?? {}).rows ?? (process.stdout.rows || 24)) - 8))
+      if (state.scroll === 0) state._followTail = true // 滚回底部恢复跟随
       render()
       return
     }

package/src/tui/layout.mjs

@@ -3,13 +3,17 @@
  * 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 → todo → picker → permission → queue → input → status
- * Subagent activity renders INSIDE the conversation as collapsible blocks
- * (AGENT-LOOP.md §7.2 D4) — no dedicated subagent/output panels anymore.
+ *   header → conversation → subagent 面板 → todo → picker → permission → queue → 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 =
+ * hidden, data stays in the buffer). Done children are frozen into the
+ * conversation stream (§7.2 D4, unchanged). Output panels abolished (§7.2 D6).
  * Fixed panels deducted first, conditional panels allocated by priority, remaining space to conversation.
  */
 import { layoutInput, wrapText } from "./render.mjs"
 import { QUESTION_CUSTOM } from "./interaction.mjs"
+import { renderSubagentPanel } from "./subagent-panel.mjs"
 
 /** 防御：question options 声明为 string[]，但 LLM 可能误传对象；取 label/text/title 兜底，避免渲染 "[object Object]"。 */
 function optText(opt) {
@@ -75,9 +79,20 @@ export function computeLayout(state, { cols, rows }) {
   const taskPanelH = visibleTasks.length > 0 ? visibleTasks.length + 1 : 0
   // Squeeze target: the divider line yields first under small terminals (the
   // task rows themselves never compress away — put() truncates by panel h).
-  let todoFinalH = taskPanelH
 
-  // Subagent activity: rendered inside the conversation (§7.2 D4) — no panel slot.
+  // Subagent panel (§7.2.1 D1): RUNNING blocks only, between conversation and
+  // todo. Height = the FULL rendered height of every running block (F2 — fully
+  // adaptive, no cap; the conversation shrinks accordingly). Precomputed here
+  // via renderSubagentPanel (neutral module, no layout↔render-frame cycle);
+  // render-frame puts `subagentLines` directly (no double render). Done
+  // children are frozen into state.lines (subagent-blocks.mjs
+  // freezeSubTaskLines) and excluded here — the panel only shows running blocks.
+  let subagentLines = []
+  let subagentH = 0
+  if (Object.values(state.subTasks ?? {}).some((s) => !s.done)) {
+    subagentLines = renderSubagentPanel(state, cols, rows)
+    subagentH = subagentLines.length
+  }
 
   // Permission preview (height depends on wrapped content)
   let permPreviewLines = []
@@ -97,32 +112,47 @@ export function computeLayout(state, { cols, rows }) {
   const queueH = state.queue.length > 0 && state.processing ? 1 : 0
 
   // --- elastic panel: conversation takes remaining space ---
-  const fixedH = headerH + inputBoxH + statusH + pickerH + taskPanelH + permPreviewH + queueH
+  const fixedH = headerH + inputBoxH + statusH + pickerH + taskPanelH + permPreviewH + queueH + subagentH
   let convH = Math.max(1, rows - fixedH)
 
-  // 小终端高度补偿：先压 conversation 到最小 1 行，再压 picker 到最小 3 行，
-  // 仍溢出再压 permission preview 到最小 1 行（仅标题）。
+  // 小终端高度补偿：subagent 面板最先让位（可至 0 隐藏，活动仍进缓冲区不丢），
+  // 再压 conversation 到最小 1 行，再压 picker 到最小 3 行，仍溢出再压
+  // permission preview 到最小 1 行（仅标题）——输入框/状态栏/会话区保留。
+  let subagentFinalH = subagentH
   let pickerFinalH = pickerH
   let permFinalH = permPreviewH
+  let todoFinalH = taskPanelH
   const overflow = fixedH + convH - rows
   if (overflow > 0) {
-    if (pickerH > 0) {
-      pickerFinalH = Math.max(Math.min(3, pickerH), pickerH - overflow)
-    }
-    const afterPicker = fixedH - pickerH + pickerFinalH
-    convH = Math.max(1, rows - afterPicker)
-    const remaining = afterPicker + convH - rows
-    if (remaining > 0 && permPreviewH > 0) {
-      permFinalH = Math.max(1, permPreviewH - remaining)
-      convH = Math.max(1, rows - (afterPicker - permPreviewH + permFinalH))
+    // 压缩链第 1 级（§7.2.1 NF1/评审 #2 措辞统一）：subagent 面板最先让位——
+    // 可压缩至 0 隐藏（运行中活动仍在缓冲区不丢），输入框/状态栏/会话区不可挤没。
+    let afterSub = fixedH
+    if (subagentH > 0) {
+      subagentFinalH = Math.max(0, subagentH - overflow)
+      afterSub = fixedH - subagentH + subagentFinalH
+      convH = Math.max(1, rows - afterSub)
     }
-    // 压缩链末级：todo 面板的分隔线行让位（任务行保留——put 按 h 截断自动
-    // 丢弃第一行的分隔线，2026-08-30 用户请求加的 divider 不得在小终端挤掉输入框）。
-    const afterPerm = afterPicker - permPreviewH + permFinalH
-    const finalOverflow = afterPerm + convH - rows
-    if (finalOverflow > 0 && taskPanelH > visibleTasks.length) {
-      todoFinalH = Math.max(visibleTasks.length, taskPanelH - finalOverflow)
-      convH = Math.max(1, rows - (afterPerm - taskPanelH + todoFinalH))
+    // 压缩链第 2/3 级（既有逻辑）：picker → 最小 3 行，permission → 最小 1 行
+    const overflow2 = afterSub + convH - rows
+    if (overflow2 > 0) {
+      if (pickerH > 0) {
+        pickerFinalH = Math.max(Math.min(3, pickerH), pickerH - overflow2)
+      }
+      const afterPicker = afterSub - pickerH + pickerFinalH
+      convH = Math.max(1, rows - afterPicker)
+      const remaining = afterPicker + convH - rows
+      if (remaining > 0 && permPreviewH > 0) {
+        permFinalH = Math.max(1, permPreviewH - remaining)
+        convH = Math.max(1, rows - (afterPicker - permPreviewH + permFinalH))
+      }
+      // 压缩链末级：todo 面板的分隔线行让位（任务行保留——put 按 h 截断自动
+      // 丢弃第一行的分隔线，2026-08-30 用户请求加的 divider 不得在小终端挤掉输入框）。
+      const afterPerm = afterPicker - permPreviewH + permFinalH
+      const finalOverflow = afterPerm + convH - rows
+      if (finalOverflow > 0 && taskPanelH > visibleTasks.length) {
+        todoFinalH = Math.max(visibleTasks.length, taskPanelH - finalOverflow)
+        convH = Math.max(1, rows - (afterPerm - taskPanelH + todoFinalH))
+      }
     }
   }
 
@@ -130,6 +160,7 @@ export function computeLayout(state, { cols, rows }) {
   let y = 0
   const header = { y, h: headerH }; y += headerH
   const conversation = { y, h: convH }; y += convH
+  const subagent = subagentFinalH > 0 ? { y, h: subagentFinalH } : null; y += subagentFinalH
   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
@@ -139,13 +170,38 @@ export function computeLayout(state, { cols, rows }) {
 
   return {
     W, cols, rows,
-    panels: { header, conversation, picker, todo, permission, queue, inputBox, status },
+    panels: { header, conversation, subagent, picker, todo, permission, queue, inputBox, status },
     // precomputed content (affects height, reused during render)
     inputLayout,
     inputOffset,
     boxLines,
     visibleTasks,
     permPreviewLines,
+    subagentLines,
     overlay,
   }
 }
+
+/**
+ * §7.2.1 评审 #4：面板部分压缩（subagentFinalH < subagentLines.length）时 render-frame
+ * 实际显示的行——**保底截断**：分隔线 + 末尾 (h-1) 行（最新启动区块优先；小终端上仍
+ * 能看到最新子 agent 活动，旧 slice(0,h) 保留顶部会把最新活动裁掉）。分隔线始终保留
+ * （面板边界语义）。h ≥ 全长 → 原样；h = 0 → []（layout 侧 panels.subagent 已为 null，
+ * 防御分支）；h = 1 → 只显示分隔线（极端小终端）。
+ */
+export function subagentVisibleLines(subagentLines, h) {
+  if (h >= subagentLines.length) return subagentLines
+  if (h <= 0) return []
+  if (h === 1) return [subagentLines[0]]
+  return [subagentLines[0], ...subagentLines.slice(-(h - 1))]
+}
+
+/** 与 subagentVisibleLines 同一几何契约：可见面板行（0-based 行内坐标）→
+ *  subagentLines 索引（mouse 命中映射用——保底截断后可见行 ≠ 前 h 行）；
+ *  localRow 越界 → -1。 */
+export function subagentLineIndex(subagentLines, h, localRow) {
+  if (localRow < 0 || localRow >= h) return -1
+  if (h >= subagentLines.length) return localRow
+  if (localRow === 0) return 0
+  return subagentLines.length - h + localRow
+}

package/src/tui/mouse.mjs

@@ -14,9 +14,60 @@
  *   - picker option click = select it
  *   - folded-block hint click = expand it
  */
-import { computeLayout } from "./layout.mjs"
-import { buildConvLines } from "./render-conversation.mjs"
-import { toggleFoldBlock } from "./fold-block.mjs"
+import { computeLayout, subagentLineIndex } from "./layout.mjs"
+import { buildConvLines, convViewport } from "./render-conversation.mjs"
+import { toggleFoldBlock, scrollFoldBlock, foldScrollOffset } from "./fold-block.mjs"
+
+/** 2026-08-31 滚轮事件分派（用户需求"展开块能滚动阅读全文"）：坐标命中展开块内容行 →
+ *  块内逐行滚动（scrollFoldBlock ±3）；未命中 → 会话滚动（调用方继续处理）。
+ *  ctx: { state, render }；返回 true = 已消费（块内滚动），false = 调用方走会话滚动。 */
+export function handleWheel(ctx, button, col, row) {
+  const { state } = ctx
+  const dir = button === 64 ? -1 : 1 // 64=滚上（offset 减）、65=滚下
+  const r = row - 1
+  if (r < 0) return false
+  const dims = state.dims ? state.dims.get() : { cols: process.stdout.columns || 80, rows: process.stdout.rows || 24 }
+  const layout = computeLayout(state, dims)
+  const P = layout.panels
+  // §7.2.1 D4: 固定子agent 面板（conversation 与 todo 之间）——面板行默认穿出
+  // 滚会话（F3，与 todo 面板同型）；命中展开区块内容行（_foldBlock 标记）→
+  // 块内滚动（现状能力不丢）。
+  if (P.subagent && r >= P.subagent.y && r < P.subagent.y + P.subagent.h) {
+    // 评审 #4：面板部分压缩（保底截断）后可见行 = 分隔线 + 末尾行——命中映射经
+    // subagentLineIndex（与 render-frame 同一几何契约），不再把行内坐标直接当索引用。
+    const lineEl = layout.subagentLines[subagentLineIndex(layout.subagentLines, P.subagent.h, r - P.subagent.y)]
+    if (!lineEl?._foldBlock || !lineEl._foldTotal) return false
+    // 穿出语义与会话区块一致：块内到边界（顶滚上 / 底滚下）→ 交还会话滚动
+    const before = foldScrollOffset(state, lineEl._foldBlock)
+    const winH = lineEl._foldWindow ?? 1
+    const total = lineEl._foldTotal
+    if (dir < 0 && before <= 0) return false
+    if (dir > 0 && before >= total - winH) return false
+    scrollFoldBlock(state, lineEl._foldBlock, dir, 3)
+    ctx.render?.()
+    return true
+  }
+  if (r < P.conversation.y || r >= P.conversation.y + P.conversation.h) return false
+  const convLines = buildConvLines(state, dims.cols, dims.rows)
+  const gIdx = convGlobalIndex(convLines.length, P.conversation.h, state.scroll ?? 0)(r - P.conversation.y)
+  if (gIdx === null) return false
+  const lineEl = convLines[gIdx]
+  if (!lineEl?._foldBlock) return false
+  // 2026-08-31 会诊 glm：标记不完整（_foldTotal 缺失=退化路径）不消费——交还会话滚动
+  // （total=0 会让下方边界守卫短路 → 卡在块里回归）
+  if (!lineEl._foldTotal) return false
+  // 2026-08-31 穿出语义：块内已到边界（向上滚在顶 / 向下滚在底）→ 交还会话滚动——
+  // 否则滚轮永远被块吃掉，会话顶/懒加载不可达（用户实测路径"经过展开块滚不到顶"）
+  const before = foldScrollOffset(state, lineEl._foldBlock)
+  const winH = lineEl._foldWindow ?? 1
+  const total = lineEl._foldTotal
+  if (dir < 0 && before <= 0) return false // 块顶滚上 → 穿出（会话滚动 → 顶部自动加载）
+  if (dir > 0 && before >= total - winH) return false // 块底滚下 → 穿出
+  scrollFoldBlock(state, lineEl._foldBlock, dir, 3)
+  ctx.render?.()
+  return true
+}
+
 
 /** Extract left-click presses from a chunk. Returns [{ col, row }] (1-based). */
 export function parseMouseClicks(text) {
@@ -30,13 +81,11 @@ export function parseMouseClicks(text) {
 
 /** Map a 0-based screen row to a conversation line index (same math as renderConversation). */
 export function convGlobalIndex(convLen, convH, scroll) {
-  const maxScroll = Math.max(0, convLen - convH)
-  const clamped = Math.min(scroll, maxScroll)
-  const end = convLen - clamped
-  const start = Math.max(0, end - convH) // content shorter than the panel: rows start at 0
+  const { start, pad } = convViewport(convLen, convH, scroll)
   return (localRow) => {
     if (localRow < 0 || localRow >= convH) return null
-    const idx = start + localRow
+    if (localRow < pad) return null // 顶部 pad 空行不是内容行（2026-08-31 会诊 kimi 缺陷 1）
+    const idx = start + localRow - pad
     return idx >= 0 && idx < convLen ? idx : null
   }
 }
@@ -70,12 +119,41 @@ export function handleMouseClick(ctx, col, row) {
     return true
   }
 
+  // ── §7.2.1 D4: 固定子agent 面板（conversation 与 todo 之间）——折叠/展开/翻窗
+  // 坐标映射到面板行（与 todo 面板同型；layout.subagentLines = 面板渲染行）。
+  if (P.subagent && r >= P.subagent.y && r < P.subagent.y + P.subagent.h) {
+    // 评审 #4：保底截断后可见行 ≠ 前 h 行——命中映射与 render-frame 同一几何契约
+    // （subagentLineIndex：分隔线 + 末尾区块行优先）。
+    const lineEl = layout.subagentLines[subagentLineIndex(layout.subagentLines, P.subagent.h, r - P.subagent.y)]
+    if (lineEl?._foldScrollUp || lineEl?._foldScrollDown) {
+      // ▲/▼ 控制行点击翻窗（60% 封顶保留、窗口随翻滚动，全文可达）
+      scrollFoldBlock(state, lineEl._foldScrollUp ?? lineEl._foldScrollDown,
+        lineEl._foldScrollUp ? -1 : 1, lineEl._foldWindow ?? 1,
+        typeof lineEl._foldTotal === "number" ? Math.max(0, lineEl._foldTotal - (lineEl._foldWindow ?? 1)) : undefined)
+      render()
+      return true
+    }
+    if (!lineEl?._foldToggle) return false
+    // 双向切换（fold-block.mjs 单源）：折叠头展开 / ▼ 控制收起
+    toggleFoldBlock(state, lineEl._foldToggle)
+    render()
+    return true
+  }
+
   // ── Conversation: click a fold marker (expand hint or collapse marker) toggles it ──
   if (r >= P.conversation.y && r < P.conversation.y + P.conversation.h) {
     const convLines = buildConvLines(state, dims.cols, dims.rows)
     const gIdx = convGlobalIndex(convLines.length, P.conversation.h, state.scroll ?? 0)(r - P.conversation.y)
     if (gIdx === null) return false
     const lineEl = convLines[gIdx]
+    if (lineEl?._foldScrollUp || lineEl?._foldScrollDown) {
+      // 2026-08-31 块内滚动：▲/▼ 控制行点击翻窗（60% 封顶保留、窗口随翻滚动，全文可达）
+      scrollFoldBlock(state, lineEl._foldScrollUp ?? lineEl._foldScrollDown,
+        lineEl._foldScrollUp ? -1 : 1, lineEl._foldWindow ?? 1,
+        typeof lineEl._foldTotal === "number" ? Math.max(0, lineEl._foldTotal - (lineEl._foldWindow ?? 1)) : undefined)
+      render()
+      return true
+    }
     if (!lineEl?._foldToggle) return false
     // Bidirectional toggle — single source in fold-block.mjs (expand a folded
     // block, collapse an expanded one).