thincoder 0.12.59 → 0.12.61

package/src/tui/render.mjs

@@ -161,14 +161,19 @@ export function layoutInput(chars, cursor, width) {
   const PROMPT = "\u25b8 "  // first-line prefix (display width 2)
   const CONT = "  "         // continuation prefix (width 2) — keeps left edge aligned
   const lines = []
+  const starts = []         // lineStarts so far（第 31 批 additive）：每个可视行的行首下标
+  let lineStart = 0         // 当前行的行首下标（chars 索引空间）
   let cursorLine = 0
   let cursorCol = 0
   let cur = ""
   let col = 0
   let firstLine = true
   const avail = () => width - 2 // every line reserves 2 cols for its prefix
-  const flush = () => {
+  // next = 下一行的行首下标（折行 = 当前字符 i；行尾 \n 之后 = i + 1）
+  const flush = (next) => {
     lines.push((firstLine ? PROMPT : CONT) + cur)
+    starts.push(lineStart)
+    lineStart = next
     firstLine = false
     cur = ""
     col = 0
@@ -177,7 +182,7 @@ export function layoutInput(chars, cursor, width) {
     const ch = chars[i]
     if (ch !== undefined && ch !== "\n") {
       const w = charWidth(ch.codePointAt(0))
-      if (col + w > avail()) flush()
+      if (col + w > avail()) flush(i)
       if (i === cursor) {
         cursorLine = lines.length
         cursorCol = 2 + col
@@ -189,12 +194,39 @@ export function layoutInput(chars, cursor, width) {
         cursorLine = lines.length
         cursorCol = 2 + col
       }
-      if (ch === "\n") flush()
+      if (ch === "\n") flush(i + 1)
     }
   }
   const endsWithNewline = chars.length > 0 && chars[chars.length - 1] === "\n"
-  if (cur || lines.length === 0 || endsWithNewline) flush()
-  return { lines, cursorLine, cursorCol }
+  if (cur || lines.length === 0 || endsWithNewline) flush(chars.length)
+  // lineStarts[k] = 第 k 行行首；行 k 区间 = [lineStarts[k], lineStarts[k+1])（含行尾 \n）；
+  // 末项哨兵 = chars.length（上界、不指向行）——竖移定位用（TUI-INPUT-BOX.md §1 不变量 5）。
+  return { lines, cursorLine, cursorCol, lineStarts: [...starts, chars.length] }
+}
+
+/** 竖直移动定位（第 31 批——TUI-INPUT-BOX.md §3 规则 2 / §9.3 #2）：纯函数，
+ *  `(chars, cursor, width, dir) → number | null`（null = 该方向无邻行）。
+ *  目标行显示列 = 当前光标显示列（列保持——`layoutInput` 同源行列；行前缀 2 列等宽故整体
+ *  相减）；目标行更短则钳制到行尾（行尾含 \n → 落在 \n 前）。逐键现算——不记忆列（D-31.2）。
+ *  不读不写任何 state。 */
+export function moveCursorVertical(chars, cursor, width, dir) {
+  const { cursorLine, cursorCol, lineStarts } = layoutInput(chars, cursor, width)
+  const lineCount = lineStarts.length - 1
+  const targetLine = dir === "up" ? cursorLine - 1 : cursorLine + 1
+  if (targetLine < 0 || targetLine >= lineCount) return null
+  const targetCol = Math.max(0, cursorCol - 2) // 2 列行前缀（`▸ ` / 续行空格）——各行等宽
+  const start = lineStarts[targetLine]
+  let end = lineStarts[targetLine + 1]
+  if (end > start && chars[end - 1] === "\n") end -= 1 // 行尾 \n 不占显示列
+  let col = 0
+  let idx = start
+  while (idx < end) {
+    const w = charWidth(chars[idx].codePointAt(0))
+    if (col + w > targetCol) break // 宽字符列中不落点——落在该字符起点
+    col += w
+    idx += 1
+  }
+  return idx
 }
 
 /**

package/src/tui/slash-commands.mjs

@@ -42,7 +42,7 @@ export const SLASH_COMMANDS = [
   { name: "/eng", group: "Agent", desc: "toggle engineering mode — strict methodology enforcement" },
   { name: "/advisor", group: "Agent", desc: "advisor settings (model, thinking, review gate)" },
   { name: "/model", group: "Agent", desc: "select model & manage providers" },
-  { name: "/submodel", group: "Agent", desc: "subagent model per type (explore/plan/coder/eng-coder)" },
+  { name: "/submodel", group: "Agent", desc: "subagent model per type (explore/plan/coder/eng-coder/eng-designer)" },
   { name: "/shell", group: "System", desc: "bash tool shell (git-bash/pwsh path; win11 cmd encoding fix)" },
   { name: "/goal", group: "Agent", desc: "set/view/cancel long-term goal" },
   { name: "/think", group: "Agent", desc: "thinking mode & reasoning effort" },
@@ -144,7 +144,7 @@ export function createSlashCommands(ctx) {
     const match = (cands) => cands.filter((c) => c.startsWith(last)).map((c) => `${head} ${c}`)
     if (cmd === "/model" && argIndex === 0) return match(agent.providers.map((p) => p.name))
     if (cmd === "/submodel") {
-      if (argIndex === 0) return match(["explore", "plan", "coder", "eng-coder", "reset"])
+      if (argIndex === 0) return match(["explore", "plan", "coder", "eng-coder", "eng-designer", "reset"])
       if (parts[1] && !["reset"].includes(parts[1]) && argIndex === 1) return match(agent.providers.map((p) => p.name))
     }
     if (cmd === "/think") {

package/src/tui/startup.mjs

@@ -187,6 +187,10 @@ export function showStartup(ctx) {
   }
   pushLine(`Tools: ${agent.tools.map((t) => t.name).join(", ")}`, C.dim)
 
+  // R25（F-R25c）：上次运行异常终止提示——bin 入口扫描 crash-reports（24h 窗）经
+  // startTUI opts.crashNotice 传入——无匹配为 undefined → 不提示（负例）
+  if (opts.crashNotice) pushLine(opts.crashNotice, C.warn)
+
   // Recover previous session: rebuild from history (lazy — display snapshot is
   // deprecated; it drifted out of sync with history on VS Code writes).
   if (opts.restored?.history?.length) {

package/src/tui/subagent-blocks.mjs

@@ -3,16 +3,35 @@
  * state.subTasks[key] = { key, role, model, async（§19.5 D-M7b——⟦ev⟧async 标记——
  * undefined = sync）, started, done, doneAt, blocks:
  * [{kind,text}], currentTool, toolArgs, turn, maxTurns, approval, lastError,
- * dropped, blockEpoch, awaitingDigest（§17）, _freezeAt（冻结锚点）, stopped（§19.5）}。
- * 职责：前缀路由（parseRelayPath 嵌套段→子标）、事件 token 解析、kind 合并、
- * N2 环形上限、N1 渲染节流、完成冻结（freezeSubTaskLines 家族——锚点 splice）。
+ * dropped, blockEpoch, awaitingDigest（§17）, _freezeAt（冻结锚点）, stopped（§19.5）,
+ * children: []（SUBAGENT-TAIL：嵌套子代理**守护载体**——内容并入本块 blocks——见
+ * subagent-children.mjs）}。
+ * 职责：前缀路由（parseRelayPath——**SUBAGENT-TAIL（D-ST1）：嵌套段内容行并入外层
+ * blocks——append 目标上移，子块载体只余守护元数据**）、
+ * 事件 token 解析（**内层 ⟦ev⟧done/stopped 生成侧补发射（D-R23c1）路由到子块
+ * 定格；F2：done 后完全定格——迟到 chunk 丢弃**）、kind 合并、N2 单环 500 显示行上限
+ * （SUBAGENT-TAIL D-ST4——内层行同环计数、单载体最旧先行）、N1 渲染节流、
+ * 完成冻结（freezeSubTaskLines 家族——锚点 splice）。显示契约 = docs/design/TUI.md §6。
  */
 
 import { C } from "./ansi.mjs"
+// 第 27 批 §12.3①/②：relay 前缀文法单一权威 = src/agent/relay-prefix.mjs——本文件
+// 不再自持前缀正则/解析副本（防第二套平行正则再漂移）。
+import { parseRelayPath } from "../agent/relay-prefix.mjs"
 import { describeToolArgs } from "./tool-args.mjs"
-
-/** `role#id/` prefix router — hyphen included since the eng-coder fix (2026-08-21). */
-export const SUB_PREFIX_RE = /^([\w-]+)#(\d+)\//
+import {
+  appendSubBlock, descendSubChild,
+  closeSubChild,
+} from "./subagent-children.mjs"
+export { SUB_BLOCK_LINE_LIMIT, appendSubBlock } from "./subagent-children.mjs"
+// 2026-09-05 module-split：finish/freeze 族 + §19.6 面板现算迁 subagent-freeze.mjs——
+// routeSub*/compression panel 内部用本地 import；re-export 保外部 import 面（index.mjs 等）
+// CLI-ACTIVITY-DEBLOAT F-3（2026-09-10）：面板手工镜像退役——re-export 面换现算导出
+// computePanelBlocks（读时现算），本文件全部刷镜调用点删除（单账本——变更点不再手动同步）。
+import { freezeSubTaskLines, finishSubTaskKey, finishSubTask, freezeDoneSubTasks, finishSubTasksByRole, freezeAllSubTasks, freezeReclaimDigestedBlocks, shiftFreezeAnchors } from "./subagent-freeze.mjs"
+export { computePanelBlocks, finishSubTask, finishSubTaskKey, freezeSubTaskLines, shiftFreezeAnchors, freezeDoneSubTasks, finishSubTasksByRole, freezeAllSubTasks, freezeReclaimDigestedBlocks } from "./subagent-freeze.mjs"
+
+// 前缀文法/解析已迁 src/agent/relay-prefix.mjs（第 27 批 §12.3②）——本文件不自持副本。
 /** ⟦ev⟧ token parser：`⟦ev⟧<name>\x1e<n>\x1e<max>\x1e<phase>\x1e<detail>`。phase done
  *  = async 完成即冻结（settle 时发）；settled = 挂起期完成——冻结延迟至 digest 消化
  *  完成（§17.5.5 freezeReclaimDigestedBlocks 逐条回收——不等池空）或池空退出兜底补发；
@@ -26,64 +45,14 @@ export const SUB_PREFIX_RE = /^([\w-]+)#(\d+)\//
  *  （块尚未创建）缓冲 `state._pendingAsyncKeys`——ensureSubTaskKey 块创建时应用（兜底）。 */
 export const SUB_EVENT_RE = /^⟦ev⟧(turn|approval|done|settled|stopped|queued)\x1e([^\x1e]*)\x1e([^\x1e]*)\x1e([^\x1e]*)\x1e?([\s\S]*)$/
 
-/** §19.5 D-M8 嵌套 relay 前缀通用解析（循环解析任意深度）：
- *  `eng-coder#2/explore#1/read` → { head（块路由）, inner[], label（子标）, rest }。
- *  单层 = inner[]/label ""——与既有单段匹配语义零改；无前缀 → null。 */
-export function parseRelayPath(text) {
-  const segments = []
-  let rest = String(text)
-  for (;;) {
-    const m = rest.match(SUB_PREFIX_RE)
-    if (!m) break
-    segments.push(`${m[1]}#${m[2]}`)
-    rest = rest.slice(m[0].length)
-  }
-  if (segments.length === 0) return null
-  return {
-    head: segments[0],
-    inner: segments.slice(1),
-    label: segments.slice(1).join("/"),
-    rest,
-  }
-}
+// parseRelayPath 自 src/agent/relay-prefix.mjs import（第 27 批 §12.3①——文法单一权威，
+// 语义与迁移前逐字一致；“嵌套解析任意深度/无前缀 → null”见该模块）。
 
-/** §19.5 D-M8 子标行首变换（文本/think）：parseRelayPath 已消费完整前缀段——此处只
- *  判行首（块首或上一内容以 \n 收尾——chunk 边界碎片在前缀段消费后自然无声剥除，
- *  防 explore#1/ 字样泄漏）；行首 → 前置字面子标 `explore#1 · `（渲染端套 dim）。 */
-export function sublabelLine(sub, text, label) {
-  if (!label) return String(text)
-  const last = sub.blocks.at(-1)
-  const atLineHead = !last || String(last.text).endsWith("\n")
-  return atLineHead ? `${label} · ${text}` : String(text)
-}
-/** N2: per-child display-line ring buffer cap — oldest lines drop with a marker. */
-export const SUB_BLOCK_LINE_LIMIT = 500
 /** N1: render-layer throttle for child tool-output appends (generation relays verbatim). */
 export const SUB_RELAY_THROTTLE_MS = 250
-/** Roles a subagent tool child can take (finishSubTask matches the block's role). */
-export const SUBAGENT_ROLES = ["sub", "explore", "plan", "coder", "eng-coder"]
-
-// ─── §19.6 D-P1 面板镜像（subagent panel 检查工具）───
-// TUI 装配处（index.mjs startTUI）state._agent = agent——块级状态变更点经
-// syncPanelSnapshot 刷新 agent._panelSnapshot（区块数组快照：{key, role,
-// status: running|done|awaitingDigest, startedAt}——状态变更即刷——O(n) 小——
-// 不逐 token——NF-P）。agent 层 subagent action:"panel" 读此镜像（视图与用户
-// 所见一致）+ 冻结门控（D-P3）。未挂载（headless/mock——无 state._agent）=
-// 无镜像——no-op（降级路径由 agent 侧判定）。
-
-/** 刷新面板镜像（调用点 = 本模块全部 state.subTasks 块级变更点末尾——map 已稳定）。 */
-function syncPanelSnapshot(state) {
-  const agent = state._agent
-  if (!agent) return // 未挂载（headless/mock 无 TUI 装配）——无镜像
-  const snap = []
-  for (const sub of Object.values(state.subTasks ?? {})) {
-    // §20 D-SD3b：waiting/等位块（sub.queued——未启动）以 queued 态入镜（镜像与面板
-    // 所见一致——action:'panel' 视图 + freeze 门控读此态）。
-    const status = sub.done ? (sub.awaitingDigest ? "awaitingDigest" : "done") : (sub.queued ? "queued" : "running")
-    snap.push({ key: sub.key, role: sub.role ?? null, status, startedAt: sub.started ?? Date.now() })
-  }
-  agent._panelSnapshot = snap
-}
+/** Roles a subagent tool child can take（⏹ 门控/渲染角色判据；F-2 后角色匹配完成面 =
+ *  finishSubTasksByRole——finishSubTask 已收窄 no-op）。 */
+export const SUBAGENT_ROLES = ["sub", "explore", "plan", "coder", "eng-coder", "eng-designer"]
 
 let _subRenderLast = 0
 let _subRenderTimer = null
@@ -119,12 +88,12 @@ export function ensureSubTaskKey(state, key, role) {
       blocks: [], currentTool: null, toolArgs: null, turn: 0, maxTurns: 0, approval: null,
       lastError: null, dropped: 0,
       stopped: false, // §19.5: ⟦ev⟧stopped 冻结标记（标题 "stopped"）
+      children: [], // SUBAGENT-TAIL: 嵌套子代理守护载体（内容并入本块——subagent-children.mjs）
     }
     // §19.5 D-M7b ①（处置 #4 兜底——2026-09-03）：缺失 key 的 ⟦ev⟧async 事件已缓冲
     // pending 标志（routeSubToken——async 先于块创建到达：排队条目补位启动的时序窗口）
     // ——块创建（此处）即应用——sub.async 区块创建即知（⏹ 门控/头标判定源保真）。
     if (state._pendingAsyncKeys?.delete(key)) state.subTasks[key].async = true
-    syncPanelSnapshot(state) // §19.6 D-P1: 块创建 → running 入镜
   }
   return state.subTasks[key]
 }
@@ -133,213 +102,10 @@ export function ensureSubTask(state, subMatch) {
   return ensureSubTaskKey(state, `${subMatch[1]}#${subMatch[2]}`, subMatch[1])
 }
 
-const countBlockLines = (text) => text.split("\n").length
-
-/** Append（kind 合并追加）+ N2 环形上限；fresh=true 强制新块（每工具调用）。 */
-export function appendSubBlock(sub, kind, text, { fresh = false } = {}) {
-  if (!text) return
-  const last = sub.blocks.at(-1)
-  if (!fresh && last && last.kind === kind) {
-    // 合并只算净增行数（逐 chunk 全量 split 会把单行碎片虚计成 2 段——P1, 2026-08-30）
-    const before = countBlockLines(last.text)
-    last.text += text
-    sub._lineCount = (sub._lineCount ?? 0) + countBlockLines(last.text) - before
-  } else {
-    sub.blocks.push({ kind, text })
-    sub._lineCount = (sub._lineCount ?? 0) + countBlockLines(text)
-  }
-  sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-  trimSubBlocks(sub)
-}
-
-/** N2：超限丢最旧行 + 留一条累计省略标记行（done 块同受约束）。 */
-export function trimSubBlocks(sub) {
-  // 增量行记账（P1）：appendSubBlock 维护 _lineCount——旧实现每 chunk 全量 reduce
-  sub._lineCount = (sub._lineCount ?? 0)
-  let over = sub._lineCount - SUB_BLOCK_LINE_LIMIT
-  if (over <= 0) return
-  let droppedNow = 0
-  while (over > 0 && sub.blocks.length > 0) {
-    const first = sub.blocks[0]
-    const lines = countBlockLines(first.text)
-    const take = Math.min(lines, over)
-    if (take >= lines) {
-      sub.blocks.shift()
-      droppedNow += lines
-    } else {
-      first.text = first.text.split("\n").slice(take).join("\n")
-      droppedNow += take
-    }
-    over -= take
-  }
-  sub._lineCount -= droppedNow
-  sub.dropped += droppedNow
-  const marker = `…（已省略 ${sub.dropped} 行）`
-  const first = sub.blocks[0]
-  if (first && first.kind === "meta") first.text = marker
-  else { sub.blocks.unshift({ kind: "meta", text: marker }); sub._lineCount += 1 }
-}
-
-/** Mark the earliest running child of the given role(s) as done (✓ header, frozen elapsed). */
-export function finishSubTask(state, roles, lastError = null) {
-  state.subTasks ??= {}
-  const roleSet = new Set(Array.isArray(roles) ? roles : [roles])
-  const running = Object.values(state.subTasks)
-    .filter((s) => !s.done && roleSet.has(s.role))
-    .sort((a, b) => a.started - b.started)
-  if (running.length === 0) return
-  const sub = running[0]
-  sub.done = true
-  sub.doneAt = Date.now()
-  sub.currentTool = null
-  sub.approval = null
-  if (lastError) sub.lastError = lastError
-  sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-  syncPanelSnapshot(state) // §19.6 D-P1: done 状态变更刷镜
-}
-
-/** §7.2.3 sync spawn 完成精确冻结（2026-09-03）：按 relay key 精确 settle。finishSubTask
- *  的"最早 started"启发式只在面板单 running 块时成立——§15 async 化后 async eng-coder
- *  （先启动）与 sync explore 并存时 explore 完成会误冻先启动的 eng-coder 块（7.2.3.1）。
- *  dispatch 沿 ctx._subagentKey（relayPrefix 去尾 = `role#N`）把 key 传进 onToolResult——
- *  有 key 即精确标 done（冻结载体进流 + 删条目由调用方 freezeDoneSubTasks 承接——与
- *  finishSubTask 同一契约）；无匹配块（已冻结 tombstone/不存在）返回 null——调用方不得
- *  落启发式兜底（精确 key 无匹配 = 无从归属——不误冻他块）。 */
-export function finishSubTaskKey(state, key, lastError = null) {
-  const sub = state.subTasks?.[key]
-  if (!sub) return null
-  sub.done = true
-  sub.doneAt = Date.now()
-  sub.currentTool = null
-  sub.approval = null
-  if (lastError) sub.lastError = lastError
-  sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-  syncPanelSnapshot(state) // §19.6 D-P1: done 状态变更刷镜
-  return sub
-}
-
-/** 冻结完成/中断区块进 state.lines（§7.2 D4——_frozenSubTask 载体行，渲染端
- *  render-conversation 识别；折叠交互 key = sub-${key} 与运行面板同源跨冻结延续）。
- *  锚点插入（2026-09-03 修复轮）：settled 块带 _freezeAt（settle 时刻流位置）——
- *  splice 落位使挂起期补发冻结块位于其 digest 总览文本之前；无锚点尾推不变；
- *  多锚点批量冻结按降序（绝对位置 splice——先插小锚点会移走大锚点目标）。 */
-export function freezeSubTaskLines(state, sub) {
-  if (!sub) return
-  state._frozenSubKeys ??= new Set()
-  state._frozenSubKeys.add(sub.key)
-  sub.done = true
-  sub.doneAt = sub.doneAt ?? Date.now()
-  const anchor = sub._freezeAt ?? state.lines.length
-  state.lines.splice(Math.min(anchor, state.lines.length), 0, {
-    text: `subagent activity: ${sub.key}`, color: C.dim, _frozenSubTask: sub,
-  })
-}
-
-/** 头裁锚点校正（index.mjs pushLine 调用）：裁 removedCount 补 1 标记行 = 净位移
- *  removedCount−1（code review round1 #3）；在途锚点前移，min 0 兜底。 */
-export function shiftFreezeAnchors(state, removedCount) {
-  const shift = removedCount - 1
-  for (const sub of Object.values(state.subTasks ?? {})) {
-    if (sub._freezeAt !== undefined) sub._freezeAt = Math.max(0, sub._freezeAt - shift)
-  }
-}
-
-/** 冻结 + 释放全部已 done 块（工具结果清扫路径）。锚点降序（后 settle 先插——
- *  绝对位置 splice 语义）；无锚点（-1）排末尾推；sort 稳定。 */
-export function freezeDoneSubTasks(state) {
-  const subs = Object.values(state.subTasks ?? {})
-    .filter((s) => s.done)
-    .sort((a, b) => (b._freezeAt ?? -1) - (a._freezeAt ?? -1))
-  for (const sub of subs) {
-    freezeSubTaskLines(state, sub)
-    delete state.subTasks[sub.key]
-  }
-  syncPanelSnapshot(state) // §19.6 D-P1: 删除后刷镜（块移出面板）
-}
-
-/** 按角色整组标记 done——consult N 并行 children 的会话级 settle（单发
- *  finishSubTask 只结最早一个——consult 残项 2026-08-30）。 */
-export function finishSubTasksByRole(state, roles, lastError = null) {
-  state.subTasks ??= {}
-  const roleSet = new Set(Array.isArray(roles) ? roles : [roles])
-  for (const sub of Object.values(state.subTasks)) {
-    if (!sub.done && roleSet.has(sub.role)) {
-      sub.done = true
-      sub.doneAt = Date.now()
-      sub.currentTool = null
-      sub.approval = null
-      if (lastError) sub.lastError = lastError
-      sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-    }
-  }
-  syncPanelSnapshot(state) // §19.6 D-P1: done 状态变更刷镜
-}
-
-/** 按 [model] 记录的 model 精确 settle（consult_check 返回 provider:model——
- *  乱序 settle 时最早启发式冻错块）。比对尾段（bare ↔ provider:model）。 */
-export function finishSubTaskByModel(state, role, model, lastError = null) {
-  state.subTasks ??= {}
-  const want = String(model ?? "").includes(":") ? String(model).split(":").pop() : String(model ?? "")
-  for (const sub of Object.values(state.subTasks)) {
-    const have = String(sub.model ?? "")
-    const haveTail = have.includes(":") ? have.split(":").pop() : have
-    if (!sub.done && sub.role === role && haveTail === want) {
-      sub.done = true
-      sub.doneAt = Date.now()
-      sub.currentTool = null
-      sub.approval = null
-      if (lastError) sub.lastError = lastError
-      sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-      syncPanelSnapshot(state) // §19.6 D-P1: done 状态变更刷镜
-      return sub
-    }
-  }
-  return null
-}
-
-/** 回合尾/挂起退出清扫（runAgentTurn finally / suspensionSession finally）：冻结全部
- *  剩余块——中断（Ctrl+C/错误）不留下钉住输入框的 ghost；未 done 者
- *  lastError="interrupted"（Ready 态跳过）。§17.5.5：挂起自然退出时本函数只兜底
- *  **未消化残项**（已消化块由 freezeReclaimDigestedBlocks 逐条先行回收——块回收与
- *  池空解耦）。锚点降序同 freezeDoneSubTasks（挂起期 settle 锚点交错批次各按其
- *  settle 位置落位）。 */
-export function freezeAllSubTasks(state) {
-  const subs = Object.values(state.subTasks ?? {})
-    .sort((a, b) => (b._freezeAt ?? -1) - (a._freezeAt ?? -1))
-  for (const sub of subs) {
-    if (!sub.done) {
-      sub.done = true
-      sub.doneAt = Date.now()
-      if (!sub.lastError && state.status !== "Ready") sub.lastError = "interrupted"
-    }
-    freezeSubTaskLines(state, sub)
-    delete state.subTasks[sub.key]
-  }
-  syncPanelSnapshot(state) // §19.6 D-P1: 冻结回收后刷镜（块移出面板）
-}
-
-/** §17.5.5 消化完成逐条冻结回收（2026-09-03 实测修订 + round1 #1 位置裁定）：digest/会话内
- *  用户回合消化完 pending 条目（run 首行已注入）后调用——把"已消化但仍驻留面板"的
- *  awaitingDigest 块立即冻结进流（不等池空——块回收与池空解耦；池空 freezeAllSubTasks
- *  仅兜底未消化残项）。归属不变式：会话内任何 run 开始前 pinned 块的条目必在 pending
- *  （settle 即移交）；run 消费后条目不在 pending 的 pinned 块 = 本 run 消化者——无需
- *  快照即精确归属。位置（round1 #1 裁定——与 17.5.5 早版文本的矛盾已消解，见
- *  AGENT-LOOP.md §17.5.5）：**settle 锚点 splice 落位——digest 总览文本之前**——同
- *  §7.2 D4 修复轮/D-S8 锚点语义（T-S6/T-S14 位置断言同口径）——锚点降序逐块冻结
- *  （splice 绝对位互不位移）。@returns {number} 回收块数 */
-export function freezeReclaimDigestedBlocks(state, pendingList) {
-  const pend = pendingList ?? []
-  const targets = Object.values(state.subTasks ?? {})
-    .filter((s) => s.awaitingDigest && !pend.some((e) => `${e.role}#${e.id}` === s.key))
-    .sort((a, b) => (b._freezeAt ?? -1) - (a._freezeAt ?? -1)) // 锚点降序（同 freezeAllSubTasks）
-  for (const sub of targets) {
-    freezeSubTaskLines(state, sub) // splice 落 settle 锚点（digest 总览文本之前）
-    delete state.subTasks[sub.key]
-  }
-  syncPanelSnapshot(state) // §19.6 D-P1: 逐条回收后刷镜（块移出面板）
-  return targets.length
-}
-
+/** Append（kind 合并追加）+ N2 单环 500 显示行上限；fresh=true 强制新块（每工具调用）。
+ *  R23（2026-09-07）：appendSubBlock/trimSubBlocks 实现迁 subagent-children.mjs——
+ *  SUBAGENT-TAIL（D-ST4）后为单载体最旧先行（内层并入行同环计数）；本文件 import +
+ *  re-export 保 import 面（压缩面板等）。 */
 /** 事件 token → 区块头部（turn/approval 更新 turn n/max + 等待态）。事件永不进
  *  blocks/主流——仅头部。@returns {boolean} 良构事件（已消费） */
 export function applySubEvent(sub, payload) {
@@ -359,8 +125,12 @@ export function applySubEvent(sub, payload) {
 
 // ─── Prefix routing（agent-turn callbacks 委派）：true = 带前缀已消费；false = 主路径
 
-/** onToken 分支：子文本 / [model] 元数据 / ⟦ev⟧ 事件。§19.5 D-M8 嵌套：head 段路由块，
- *  内层内容走子标行首变换，内层 ⟦ev⟧/[model] 剥除不路由（防外层块头污染——round1 #4）。 */
+/** onToken 分支：子文本 / [model] 元数据 / ⟦ev⟧ 事件。SUBAGENT-TAIL（D-ST1——supersede
+ *  R23 子块段方案，显示契约 docs/design/TUI.md §6）：head 段路由块——inner 段**内容行
+ *  并入外层块 blocks**（append 目标上移），子块载体只余守护元数据（done 守卫——F2
+ *  迟到丢弃；currentTool——fresh 判别）；内层 [model] 记子块模型；内层 ⟦ev⟧ 除
+ *  done/stopped（生成侧补发射——D-R23c1——路由子块定格）外剥除不路由（防 explore
+ *  进度污染外层块头——round1 #4）。 */
 export function routeSubToken(state, t, scheduleRender) {
   const path = parseRelayPath(t)
   if (!path) return false
@@ -384,7 +154,6 @@ export function routeSubToken(state, t, scheduleRender) {
       if (live.queued) {
         delete live.queued
         live.started = Date.now()
-        syncPanelSnapshot(state) // §19.6 D-P1: queued → running 状态变更刷镜
       }
     }
     else {
@@ -403,7 +172,6 @@ export function routeSubToken(state, t, scheduleRender) {
     const live = state.subTasks?.[path.head]
     if (live && !live.done && live.async !== true) {
       delete state.subTasks[path.head]
-      syncPanelSnapshot(state) // §19.6 D-P1: 移除后刷镜（块出面板）
     }
     scheduleRender()
     return true
@@ -416,7 +184,23 @@ export function routeSubToken(state, t, scheduleRender) {
   // queued（§20 D-SD3b）= 排队 spawn 等待块（spawn 返回即建/状态变迁刷新——覆盖式
   // 更新 sub.queued——块不可展开（无活动流）；启动后 async 事件清标转 running）。
   if (payload.startsWith("⟦ev⟧")) {
-    if (nested) return true // 内层事件剥除不路由（防 explore 进度污染外层块头）
+    // 内层完成信号（沿革：D-M8 子标 → R23 子块段 → SUBAGENT-TAIL 并入——显示契约
+    // docs/design/TUI.md §6）：done/stopped = 生成侧补发射（D-R23c1——sync 同步收尾段带
+    // 完整嵌套前缀）→ 路由到子块定格（closeSubChild——不冻结外层、不落 preview）；
+    // 缺失子块（迟到事件/
+    // 从未开块）→ 不建幻影（no-op）。其余内层事件（turn/approval/queued/settled/
+    // async/cancelled）剥除不路由（防 explore 进度污染外层块头——round1 #4）。
+    if (nested) {
+      const innerEv = payload.match(SUB_EVENT_RE)
+      if (innerEv && (innerEv[1] === "done" || innerEv[1] === "stopped")) {
+        const leaf = descendSubChild(sub, path.inner, { create: false })
+        // F2 保全：done 子块完全定格——迟到 done/stopped 丢弃（重复 done 不重放
+        // 定格；stopped 不打回 done 定格块）
+        if (leaf && !leaf.done) closeSubChild(sub, leaf, innerEv[1] === "stopped", path.label)
+        scheduleRender()
+      }
+      return true
+    }
     const ev = payload.match(SUB_EVENT_RE)
     if (ev?.[1] === "queued") {
       // 防御：已启动块（async 标记已置）收到迟到的 queued 刷新 → 丢弃（事件序保证
@@ -430,7 +214,6 @@ export function routeSubToken(state, t, scheduleRender) {
       sub.currentTool = null
       sub.approval = null
       sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-      syncPanelSnapshot(state) // §19.6 D-P1: waiting 块建/刷新刷镜
       scheduleRender()
       return true
     }
@@ -445,7 +228,6 @@ export function routeSubToken(state, t, scheduleRender) {
       sub.currentTool = null
       sub.approval = null
       sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
-      syncPanelSnapshot(state) // §19.6 D-P1: settled → awaitingDigest 状态变更刷镜
       scheduleRender()
       return true
     }
@@ -457,7 +239,6 @@ export function routeSubToken(state, t, scheduleRender) {
       sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
       freezeSubTaskLines(state, sub)
       delete state.subTasks[sub.key]
-      syncPanelSnapshot(state) // §19.6 D-P1: 冻结删除后刷镜
       scheduleRender()
       return true
     }
@@ -470,7 +251,6 @@ export function routeSubToken(state, t, scheduleRender) {
       sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
       freezeSubTaskLines(state, sub)
       delete state.subTasks[sub.key]
-      syncPanelSnapshot(state) // §19.6 D-P1: 冻结删除后刷镜
       scheduleRender()
       return true
     }
@@ -482,62 +262,95 @@ export function routeSubToken(state, t, scheduleRender) {
   // parent's) — shown in the block header, NOT appended to its content stream.
   // Only treat as metadata when the model isn't set yet (it's always the FIRST token);
   // a child content token that happens to start with "[model]" must not be swallowed.
+  // SUBAGENT-TAIL：内层 [model] 记到守护载体（类目 B 字面量——不渲染、无正读者；
+  // docs/design/TUI.md §6）；单层规则不变。
   if (payload.startsWith("[model]") && (nested || sub.model === undefined)) {
-    if (!nested) {
+    if (nested) {
+      const leaf = descendSubChild(sub, path.inner)
+      // F2: done 子块完全定格——迟到 [model] 不写定格块头
+      if (!leaf.done && leaf.model === undefined) {
+        leaf.model = payload.slice(7)
+        scheduleRender()
+      }
+    } else if (sub.model === undefined) {
       sub.model = payload.slice(7)
       scheduleRender()
-    } // 内层 [model] 剥除不路由（防嵌套块头污染）——单层 model 已设时 [model] 开头视为内容
+    }
     return true
   }
-  // Child LLM text → text block (N2 cap inside appendSubBlock).
-  appendSubBlock(sub, "text", nested ? sublabelLine(sub, payload, path.label) : payload)
+  // Child LLM text → text block (N2 cap inside appendSubBlock). SUBAGENT-TAIL（D-ST1）：
+  // 内层文本**并入外层 blocks**（append 目标上移——子块不再承载内容行，取代小节）。
+  // F2：done 子块完全定格——迟到 chunk 丢弃（leaf.done 守卫——免无谓 render）。
+  const leaf = nested ? descendSubChild(sub, path.inner) : null
+  if (leaf?.done) return true
+  appendSubBlock(sub, "text", payload)
   scheduleRender()
   return true
 }
 
 /** Child reasoning token → think block (F2: same treatment as main reasoning).
- *  §19.5 D-M8 nested think: 同文本行规则——行首 dim 子标后接思考行。 */
+ *  SUBAGENT-TAIL：内层 think 并入外层 blocks（append 目标上移——显示契约 TUI.md §6）。 */
 export function routeSubReasoning(state, t, scheduleRender) {
   const path = parseRelayPath(t)
   if (!path) return false
   const sub = ensureSubTaskKey(state, path.head, path.head.slice(0, path.head.lastIndexOf("#")))
   if (!sub) return true // frozen tombstone — drop late token
   const nested = path.inner.length > 0
-  appendSubBlock(sub, "think", nested ? sublabelLine(sub, path.rest, path.label) : path.rest)
+  const leaf = nested ? descendSubChild(sub, path.inner) : null
+  if (leaf?.done) return true // F2: done 子块完全定格——迟到 think 丢弃
+  appendSubBlock(sub, "think", path.rest)
   scheduleRender()
   return true
 }
 
-/** Child tool call → fresh tool block + header currentTool。§19.5 D-M8 嵌套：
- *  `explore#1/read` → dim 子标 + 既有工具行形态；currentTool 存全路径
- *  （`explore#1/read`——输出归属判别 + 折叠头可辨嵌套）。 */
+/** Child tool call → fresh tool block + header currentTool。SUBAGENT-TAIL（D-ST1）：内层
+ *  工具行并入外层 blocks（同款 `❯ tool` 行——取代小节）；currentTool 外层存全路径
+ *  （`explore#1/read`——评审 #8：外层块头状态区现状保持不缩改）+ 子块存工具名（守护
+ *  元数据——fresh 判别源，routeSubToolOutput 读）。 */
 export function routeSubToolCall(state, name, args, scheduleRender) {
   const path = parseRelayPath(name)
   if (!path) return false
   const sub = ensureSubTaskKey(state, path.head, path.head.slice(0, path.head.lastIndexOf("#")))
   if (!sub) return true // frozen tombstone — drop late token
   const nested = path.inner.length > 0
+  // F2: done 子块完全定格——迟到 tool call 丢弃（不复活外层 currentTool/子块状态）
+  const leaf = nested ? descendSubChild(sub, path.inner) : null
+  if (leaf?.done) return true
   sub.currentTool = nested ? `${path.label}/${path.rest}` : path.rest
   sub.toolArgs = args
   sub.approval = null
   const argsDesc = describeToolArgs(path.rest, args)
-  appendSubBlock(sub, "tool", `${nested ? `${path.label} · ` : ""}❯ ${path.rest}${argsDesc ? " " + argsDesc : ""}\n`, { fresh: true })
+  if (leaf) {
+    leaf.currentTool = path.rest
+    leaf.toolArgs = args
+    leaf.approval = null
+  }
+  appendSubBlock(sub, "tool", `❯ ${path.rest}${argsDesc ? " " + argsDesc : ""}\n`, { fresh: true })
   scheduleRender()
   return true
 }
 
 /** Child tool output（D1 前缀 name relay）→ 追加当前 tool block。RAW 拼接（2026-09-03
  *  修复轮——relay chunk 是任意字节边界碎片，逐 chunk 补 \n 会把词拦腰断行 + 烧 N2
- *  配额；emit 端自带换行结构无损还原）。§19.5 D-M8 嵌套：输出跟随最近工具行（不重复
- *  前缀——块内顺序天然归属）；fresh 判别用全路径——防内外同名工具串块。 */
+ *  配额；emit 端自带换行结构无损还原）。SUBAGENT-TAIL（D-ST1）：内层输出并入外层
+ *  blocks（append 目标上移）；fresh 判别照旧在子块层（守护元数据 leaf.currentTool=
+ *  工具名）——内外/同层同名工具互不串块。 */
 export function routeSubToolOutput(state, name, part, scheduleRender) {
   const path = parseRelayPath(name)
   if (!path) return false
   const sub = ensureSubTaskKey(state, path.head, path.head.slice(0, path.head.lastIndexOf("#")))
   if (!sub) return true // frozen tombstone — drop late token
-  const toolName = path.inner.length > 0 ? `${path.label}/${path.rest}` : path.rest
-  appendSubBlock(sub, "tool", part.text, { fresh: sub.currentTool !== toolName })
-  if (sub.currentTool !== toolName) sub.currentTool = toolName
+  const nested = path.inner.length > 0
+  const leaf = nested ? descendSubChild(sub, path.inner) : null
+  if (leaf?.done) return true // F2: done 子块完全定格——迟到输出丢弃（不复活 currentTool）
+  const toolName = path.rest
+  if (leaf) {
+    appendSubBlock(sub, "tool", part.text, { fresh: leaf.currentTool !== toolName })
+    if (leaf.currentTool !== toolName) leaf.currentTool = toolName
+  } else {
+    appendSubBlock(sub, "tool", part.text, { fresh: sub.currentTool !== toolName })
+    if (sub.currentTool !== toolName) sub.currentTool = toolName
+  }
   throttleSubRender(scheduleRender)
   return true
 }
@@ -578,7 +391,6 @@ export function ensureCompressPanel(state, info = {}) {
   const messages = Number.isInteger(info.messages) && info.messages >= 0 ? info.messages : "?"
   appendSubBlock(panel, "status", "Compressing context…\n", { fresh: true })
   appendSubBlock(panel, "meta", `summarizing ${messages} messages\n`, { fresh: true })
-  syncPanelSnapshot(state) // §19.6 D-P1: 压缩面板建/重置刷镜
   return panel
 }
 
@@ -595,7 +407,6 @@ export function markCompressFailed(state, error) {
 function freezeCompressPanel(state, panel) {
   freezeSubTaskLines(state, panel)
   delete state.subTasks[panel.key]
-  syncPanelSnapshot(state) // §19.6 D-P1: 压缩面板冻结删除后刷镜
 }
 
 /** 完成态（onCompress）："Compressed: N tokens freed → summary (Xs)"——冻结可折叠。 */