thincoder 0.12.59 → 0.12.60

package/src/tui/subagent-blocks.mjs

@@ -3,13 +3,25 @@
  * 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: []（R23——嵌套子代理子块载体——见 subagent-children.mjs）}。
+ * 职责：前缀路由（parseRelayPath——**R23：嵌套段不再子标渲染——建子块载体归属**）、
+ * 事件 token 解析（**R23：内层 ⟦ev⟧done/stopped 生成侧补发射（D-R23c1）路由到子块
+ * 定格；§27.1 F2：done 后完全定格——迟到 chunk 丢弃**）、kind 合并、N2 树级环形上限（R23 NFR——子块计入外层配额）、N1 渲染节流、
+ * 完成冻结（freezeSubTaskLines 家族——锚点 splice）。
  */
 
 import { C } from "./ansi.mjs"
 import { describeToolArgs } from "./tool-args.mjs"
+import {
+  SUB_BLOCK_LINE_LIMIT, appendSubBlock, appendSubChild, ensureSubChild, 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 等）
+import { freezeSubTaskLines, syncPanelSnapshot, finishSubTaskKey, finishSubTask, freezeDoneSubTasks, finishSubTasksByRole, freezeAllSubTasks, freezeReclaimDigestedBlocks, shiftFreezeAnchors } from "./subagent-freeze.mjs"
+export { syncPanelSnapshot, finishSubTask, finishSubTaskKey, freezeSubTaskLines, shiftFreezeAnchors, freezeDoneSubTasks, finishSubTasksByRole, freezeAllSubTasks, freezeReclaimDigestedBlocks } from "./subagent-freeze.mjs"
 
 /** `role#id/` prefix router — hyphen included since the eng-coder fix (2026-08-21). */
 export const SUB_PREFIX_RE = /^([\w-]+)#(\d+)\//
@@ -26,8 +38,9 @@ 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 }。
+/** §19.5 D-M8 嵌套 relay 前缀通用解析（循环解析任意深度——R23 保持为路由源）：
+ *  `eng-coder#2/explore#1/read` → { head（块路由）, inner[], label（inner 链——R23：
+ *  子块折叠键/外层 currentTool 全路径用）, rest }。
  *  单层 = inner[]/label ""——与既有单段匹配语义零改；无前缀 → null。 */
 export function parseRelayPath(text) {
   const segments = []
@@ -47,44 +60,11 @@ export function parseRelayPath(text) {
   }
 }
 
-/** §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
-}
-
 let _subRenderLast = 0
 let _subRenderTimer = null
 
@@ -119,6 +99,7 @@ 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: [], // R23: 嵌套子代理子块载体（subagent-children.mjs——D-R23a）
     }
     // §19.5 D-M7b ①（处置 #4 兜底——2026-09-03）：缺失 key 的 ⟦ev⟧async 事件已缓冲
     // pending 标志（routeSubToken——async 先于块创建到达：排队条目补位启动的时序窗口）
@@ -133,213 +114,9 @@ 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 树级环形上限；fresh=true 强制新块（每工具调用）。
+ *  R23（2026-09-07）：appendSubBlock/trimSubBlocks 实现迁 subagent-children.mjs（树级
+ *  配额——子块计入外层 500 行环）——本文件 import + re-export 保 import 面（压缩面板等）。 */
 /** 事件 token → 区块头部（turn/approval 更新 turn n/max + 等待态）。事件永不进
  *  blocks/主流——仅头部。@returns {boolean} 良构事件（已消费） */
 export function applySubEvent(sub, payload) {
@@ -359,8 +136,10 @@ 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⟧ 事件。§27 R23（supersede §19.5 D-M8
+ *  子标方案）：head 段路由块——inner 段**建子块载体归属内容**（D-R23a——subagent-children.mjs）；
+ *  内层 [model] 记子块模型；内层 ⟦ev⟧ 除 done/stopped（生成侧补发射——D-R23c1——路由
+ *  子块定格）外剥除不路由（防 explore 进度污染外层块头——round1 #4）。 */
 export function routeSubToken(state, t, scheduleRender) {
   const path = parseRelayPath(t)
   if (!path) return false
@@ -416,7 +195,22 @@ 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 进度污染外层块头）
+    // R23（supersede D-M8"内层事件剥除不路由"——评审 #1 🅰）：done/stopped 完成信号 =
+    // 生成侧补发射（D-R23c1——sync 同步收尾段带完整嵌套前缀）→ 路由到子块定格
+    // （D-R23c2——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 })
+        // §27.1 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 刷新 → 丢弃（事件序保证
@@ -482,62 +276,100 @@ 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.
+  // R23：内层 [model] 记到子块（D-R23a 子块状态字段——不再剥除丢弃）；单层规则不变。
   if (payload.startsWith("[model]") && (nested || sub.model === undefined)) {
-    if (!nested) {
+    if (nested) {
+      const leaf = descendSubChild(sub, path.inner)
+      // §27.1 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). R23：内层文本归属子块
+  // （D-R23b——子块行——不再混外层 blocks/子标）。§27.1 F2：done 子块完全定格——
+  // 迟到 chunk 丢弃（与 appendSubChild 数据层守卫同义——此处免无谓 render）。
+  if (nested) {
+    const leaf = descendSubChild(sub, path.inner)
+    if (leaf.done) return true
+    appendSubChild(sub, leaf, "text", payload)
+  } else 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 子标后接思考行。 */
+ *  §27 R23 nested think：归属内层子块（supersede D-M8 子标渲染——D-R23a/b）。 */
 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)
+  if (nested) {
+    const leaf = descendSubChild(sub, path.inner)
+    if (leaf.done) return true // §27.1 F2: done 子块完全定格——迟到 think 丢弃
+    appendSubChild(sub, leaf, "think", path.rest)
+  } else 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。§27 R23 嵌套（supersede
+ *  D-M8 子标工具行）：工具行归属内层子块（子块内 `❯ tool`）；currentTool 外层存全路径
+ *  （`explore#1/read`——评审 #8：外层块头状态区现状保持不缩改）+ 子块存工具名（子块内
+ *  输出归属判别）。 */
 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
+  // §27.1 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 (nested) {
+    leaf.currentTool = path.rest
+    leaf.toolArgs = args
+    leaf.approval = null
+    appendSubChild(sub, leaf, "tool", `❯ ${path.rest}${argsDesc ? " " + argsDesc : ""}\n`, { fresh: true })
+  } else {
+    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 端自带换行结构无损还原）。§27 R23 嵌套：输出归属内层子块（T-R23a.2——
+ *  输出全在子块——外层流无混入）；fresh 判别在子块层（子块 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
+  if (path.inner.length > 0) {
+    const leaf = descendSubChild(sub, path.inner)
+    if (leaf.done) return true // §27.1 F2: done 子块完全定格——迟到输出丢弃（不复活 currentTool）
+    const leafTool = path.rest
+    appendSubChild(sub, leaf, "tool", part.text, { fresh: leaf.currentTool !== leafTool })
+    if (leaf.currentTool !== leafTool) leaf.currentTool = leafTool
+  } else {
+    const toolName = path.rest
+    appendSubBlock(sub, "tool", part.text, { fresh: sub.currentTool !== toolName })
+    if (sub.currentTool !== toolName) sub.currentTool = toolName
+  }
   throttleSubRender(scheduleRender)
   return true
 }

package/src/tui/subagent-children.mjs

@@ -0,0 +1,176 @@
+/**
+ * subagent-children.mjs — 嵌套子代理子块载体数据层（AGENT-LOOP.md §27 R23 D-R23a/c2/NFR）。
+ *
+ * 子块 = 外层 state.subTasks 块内的嵌套载体（外层 .children[]——每层一子块——D-R23d）：
+ *   carrier = { key（父内段标 role#N）, role, model, started, done, doneAt, stopped,
+ *               blocks, currentTool, toolArgs, approval, lastError, dropped,
+ *               blockEpoch, children: [], _lineCount }——与外层块同形（渲染复用
+ *               renderBlockTimeline/renderExpandedBlock 公共组件）。
+ * 内容/工具/模型全部归属子块（D-R23b——不再混外层 blocks——T-R23a.2 输出全在子块）。
+ *
+ * N2 共享配额（R23 NFR——评审 #6）：子块行数计入**外层** 500 行环形上限——树级 trim
+ * （子块批量输出先丢、外层叙述保留优先——见 trimSubTree）——子块不独立扩容——面板
+ * 不无限增长。
+ */
+export const SUB_BLOCK_LINE_LIMIT = 500
+
+const countBlockLines = (text) => text.split("\n").length
+
+/** 载体树总行数（根自身 + 全部子孙块）——共享配额记账。 */
+export function carrierTreeLines(carrier) {
+  let n = carrier._lineCount ?? 0
+  for (const c of carrier.children ?? []) n += carrierTreeLines(c)
+  return n
+}
+
+/** 载体级丢行（原 trimSubBlocks 逐块丢弃数学——整块 shift、末块按行裁切）；返回实际
+ *  丢弃行数。每载体独立 dropped 计数 + meta 省略标记（同既有 trimSubBlocks 语义）。 */
+function dropCarrierLines(carrier, want) {
+  if (want <= 0 || carrier.blocks.length === 0) return 0
+  let dropped = 0
+  while (want > dropped && carrier.blocks.length > 0) {
+    const first = carrier.blocks[0]
+    const lines = countBlockLines(first.text)
+    const take = Math.min(lines, want - dropped)
+    if (take >= lines) {
+      carrier.blocks.shift()
+      dropped += lines
+    } else {
+      first.text = first.text.split("\n").slice(take).join("\n")
+      dropped += take
+    }
+  }
+  carrier._lineCount = (carrier._lineCount ?? 0) - dropped
+  carrier.dropped = (carrier.dropped ?? 0) + dropped
+  const marker = `…（已省略 ${carrier.dropped} 行）`
+  const first = carrier.blocks[0]
+  if (first && first.kind === "meta") first.text = marker
+  else { carrier.blocks.unshift({ kind: "meta", text: marker }); carrier._lineCount = (carrier._lineCount ?? 0) + 1 }
+  return dropped
+}
+
+/** R23 NFR：树级配额 trim——总行（根 + 子块树）超限 → 丢行。丢序 = **子树递归先于
+ *  根载体**（后序：叶子/子块先、根最后）——子块承载批量输出（explore 工具流），外层
+ *  叙述行（折叠头 tail/状态区的展示源）保留优先；每载体内部仍最旧行先行（dropCarrierLines
+ *  逐块 FIFO）。单载体（无子块）情形与既有 trimSubBlocks 行为逐字同效。
+ *  §27.1 F1（2026-09-07 三缺陷修复批——缺陷③主修）：丢行遍历**跳过 done 子块**——
+ *  done = 定格快照——配额压力不再蚕食已定格子块行，丢行落点移到外层自身行（live
+ *  块「已省略 N 行」增长语义正确）。边界（评审 #6）：live 行耗尽（全树皆 done）→
+ *  允许超限（定格快照优先于配额——N2 上限对 done 存量 best-effort）。 */
+export function trimSubTree(root) {
+  let over = carrierTreeLines(root) - SUB_BLOCK_LINE_LIMIT
+  if (over <= 0) return
+  const walk = (carrier) => {
+    for (const c of carrier.children ?? []) {
+      if (over <= 0) return
+      if (c.done) continue // §27.1 F1: done 子块 = 定格快照——丢行遍历跳过（豁免）
+      walk(c)
+    }
+    if (over <= 0) return
+    over -= dropCarrierLines(carrier, over)
+  }
+  walk(root)
+}
+
+/** kind 合并追加（载体级）——既有 appendSubBlock 数学（净增行记账——P1）。 */
+function pushBlock(carrier, kind, text, fresh) {
+  if (!text) return
+  const last = carrier.blocks.at(-1)
+  if (!fresh && last && last.kind === kind) {
+    const before = countBlockLines(last.text)
+    last.text += text
+    carrier._lineCount = (carrier._lineCount ?? 0) + countBlockLines(last.text) - before
+  } else {
+    carrier.blocks.push({ kind, text })
+    carrier._lineCount = (carrier._lineCount ?? 0) + countBlockLines(text)
+  }
+  carrier.blockEpoch = (carrier.blockEpoch ?? 0) + 1
+}
+
+/** 追加到根载体（外层块/压缩面板——无父载体者自身即配额树根）。树级 trim——
+ *  无子块时与既有 trimSubBlocks 同效（N2 既有测试口径不变）。 */
+export function appendSubBlock(sub, kind, text, { fresh = false } = {}) {
+  if (!text) return
+  pushBlock(sub, kind, text, fresh)
+  trimSubTree(sub)
+}
+
+/** R23：追加到子块载体——行数计入根（外层）树配额（NFR——同配额不独立扩容）。
+ *  §27.1 F2（2026-09-07）：child.done 守卫——done 后完全定格，迟到 chunk 丢弃
+ *  （与 §7.2 D4 完成态冻结语义统一——数据层 tombstone 拒绝）。 */
+export function appendSubChild(root, child, kind, text, { fresh = false } = {}) {
+  if (!text) return
+  if (child.done) return
+  pushBlock(child, kind, text, fresh)
+  root.blockEpoch = (root.blockEpoch ?? 0) + 1
+  trimSubTree(root)
+}
+
+/** R23 D-R23a：子块载体创建/定位——按段（role#N）在父载体 children 查找，缺失即建
+ *  （每层一子块——任意 inner 深度同路径——D-R23d）。@returns 子块载体 */
+export function ensureSubChild(carrier, seg) {
+  carrier.children ??= []
+  let c = carrier.children.find((x) => x.key === seg)
+  if (!c) {
+    c = {
+      key: seg,
+      role: seg.slice(0, seg.lastIndexOf("#")),
+      model: undefined,
+      started: Date.now(), done: false, doneAt: null, stopped: false,
+      blocks: [], currentTool: null, toolArgs: null,
+      approval: null, lastError: null, dropped: 0,
+      blockEpoch: 0, children: [], _lineCount: 0,
+    }
+    carrier.children.push(c)
+  }
+  return c
+}
+
+/** 沿 inner 段逐层下降。create=false 时缺层返回 null（事件关闭路径——不建幻影空块）。 */
+export function descendSubChild(root, inner, { create = true } = {}) {
+  let carrier = root
+  for (const seg of inner) {
+    if (create) carrier = ensureSubChild(carrier, seg)
+    else {
+      const next = (carrier.children ?? []).find((x) => x.key === seg)
+      if (!next) return null
+      carrier = next
+    }
+  }
+  return carrier === root ? null : carrier
+}
+
+/** R23 D-R23c2 子块完成定格（内层 ⟦ev⟧done/stopped → 子块尾定格——不落 preview、不冻结
+ *  外层）；stopped = interrupted（外层 abort 传播/内层错误收尾——T-R23a.3 不悬空）。
+ *  外层块头 currentTool 若指向该子块（innerPath 前缀——评审 #8 全路径现状保持）→ 清空
+ *  （子块已定格——工具不再是 current）。 */
+export function closeSubChild(root, child, stopped, innerPath) {
+  child.done = true
+  child.doneAt = Date.now()
+  if (stopped) child.stopped = true
+  child.currentTool = null
+  child.approval = null
+  child.blockEpoch = (child.blockEpoch ?? 0) + 1
+  if (root.currentTool && innerPath && String(root.currentTool).startsWith(`${innerPath}/`)) {
+    root.currentTool = null
+    root.toolArgs = null
+  }
+}
+
+/** R23 D-R23c2 收尾语义（T-R23c.2a）：外层先冻结而内层未收尾（外层 abort/中断）→
+ *  内层子块随外层冻结时定格 stopped——不悬空。freezeSubTaskLines 冻结前调用。 */
+export function closeOpenSubChildren(sub) {
+  const walk = (carrier) => {
+    for (const c of carrier.children ?? []) {
+      if (!c.done) {
+        c.done = true
+        c.doneAt = Date.now()
+        c.stopped = true
+        c.currentTool = null
+        c.approval = null
+      }
+      walk(c)
+    }
+  }
+  walk(sub)
+}