thincoder 0.12.60 → 0.12.62

package/src/tui/subagent-children.mjs

@@ -1,113 +1,168 @@
 /**
- * subagent-children.mjs — 嵌套子代理子块载体数据层（AGENT-LOOP.md §27 R23 D-R23a/c2/NFR）。
+ * subagent-children.mjs — 嵌套子代理子块载体数据层（显示契约：docs/design/TUI.md §6
+ * 「内层活动并入外层流（SUBAGENT-TAIL）」节——2026-09-11 批）。
  *
  * 子块 = 外层 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 输出全在子块）。
+ *               blockEpoch, children: [], _lineCount }
+ * SUBAGENT-TAIL（D-ST1）后内层 relay 行**不再存子块**——append 目标上移外层块 blocks
+ * （单存储单账本；子块 blocks 恒空）。子块载体降为**守护元数据**，职责 = ① done 后
+ * 迟到 chunk 丢弃（F2 语义不回退）② 外层冻结时未收尾子块不悬空（closeOpenSubChildren
+ * ——写路径保留，无正读者）③ 内层工具 fresh 判别（leaf.currentTool）。
  *
- * N2 共享配额（R23 NFR——评审 #6）：子块行数计入**外层** 500 行环形上限——树级 trim
- * （子块批量输出先丢、外层叙述保留优先——见 trimSubTree）——子块不独立扩容——面板
- * 不无限增长。
+ * N2 单环配额（D-ST4）：全部内容行（含内层并入行）就地计入外层 500 **显示行**环——
+ * trim = 单载体最旧先行（原树级 trim「子块先丢 / done 豁免」随子块内容层退役）。
+ * 省略计数真值（N6——D-ST5）：`…（已省略 N 行）` 的 N 只随内容移除增长；标记自身
+ * 不占额度、不被丢弃、不计入 N。
+ *
+ * TUI-OOM-ROOTCAUSE（TUI.md §15.1 事实 3 / §15.3.3）：原环按 `\n` 计数——无换行巨 chunk
+ * 净增 0 行 → 环永不触发、文本无界。本模块加**字符维**（第二维——行数维逐字不动，D-TB5）：
+ * `carrier._charCount` 与 `SUB_BLOCK_CHAR_LIMIT` 双维同时满足（先到先裁）；字符维裁剪
+ * 按被裁文本行数折算 N（无幽灵计数——N6）。
  */
+import { SUB_BLOCK_CHAR_LIMIT, MIDDLE_TRUNC_MARKER, capText } from "./display-budget.mjs"
+
 export const SUB_BLOCK_LINE_LIMIT = 500
 
-const countBlockLines = (text) => text.split("\n").length
+/** 单块自身额度（TUI-OOM-ROOTCAUSE §15.1 事实 3：无换行巨 chunk —— 行数维净增 0、
+ *  环永不触发；入块文本先过本条（头 3/4 + 尾 1/4 + 中段标记）——单行内容不因字符维
+ *  裁剪被整行丢光（环总量裁剪仍按最旧先行）。 */
+const SUB_BLOCK_CAP_OPTS = {
+  max: SUB_BLOCK_CHAR_LIMIT,
+  keepHead: 90_000,
+  keepTail: 30_000,
+  marker: MIDDLE_TRUNC_MARKER,
+}
 
-/** 载体树总行数（根自身 + 全部子孙块）——共享配额记账。 */
-export function carrierTreeLines(carrier) {
-  let n = carrier._lineCount ?? 0
-  for (const c of carrier.children ?? []) n += carrierTreeLines(c)
-  return n
+/** 显示行计数（N6 口径）：块尾 `\n` 的空元素不计（行结束符非空行）。 */
+const countBlockLines = (text) => {
+  const lines = String(text ?? "").split("\n")
+  return lines[lines.length - 1] === "" ? lines.length - 1 : lines.length
 }
 
-/** 载体级丢行（原 trimSubBlocks 逐块丢弃数学——整块 shift、末块按行裁切）；返回实际
- *  丢弃行数。每载体独立 dropped 计数 + meta 省略标记（同既有 trimSubBlocks 语义）。 */
+/** 省略标记块判定（trim 产物——不占额度/不可被丢；N6）。 */
+const isTrimMarker = (b) => b?.kind === "meta" && b._trimMarker === true
+
+/** 省略标记幂等更新（不占额度/不计入字符账——N6）。 */
+function updateTrimMarker(carrier) {
+  const marker = `…（已省略 ${carrier.dropped} 行）`
+  const head = carrier.blocks[0]
+  if (head && isTrimMarker(head)) head.text = marker // 既有标记原位更新（不重复 unshift）
+  else carrier.blocks.unshift({ kind: "meta", text: marker, _trimMarker: true })
+}
+
+/** 单行丢弃（最旧内容块首行——字符维/行维共用）：返回释放字符数（行级元数据同步）。 */
+function dropFirstContentLine(carrier) {
+  for (;;) {
+    const idx = carrier.blocks.findIndex((b) => !isTrimMarker(b))
+    if (idx === -1) return 0 // 仅余省略标记（内容耗尽）——不再产生幽灵行
+    const first = carrier.blocks[idx]
+    const before = countBlockLines(first.text)
+    if (before <= 0) { carrier.blocks.splice(idx, 1); continue }
+    const parts = String(first.text).split("\n")
+    const droppedLine = parts.shift() ?? ""
+    const kept = parts.join("\n")
+    if (kept === "") carrier.blocks.splice(idx, 1)
+    else first.text = kept
+    const lineDelta = before - (kept === "" ? 0 : countBlockLines(kept))
+    carrier._lineCount = Math.max(0, (carrier._lineCount ?? 0) - lineDelta)
+    carrier.dropped = (carrier.dropped ?? 0) + lineDelta
+    // 释放字符数 = 本行正文 + 行分隔符（parts.join("\n") 同步移除——代码评审 #6：少记 1
+    // 字符会使 _charCount 偏高、触发早裁）
+    return droppedLine.length + (kept === "" ? 0 : 1)
+  }
+}
+
+/** 载体级丢行（D-ST4 单环最旧先行）：从头部内容块 FIFO 丢行；省略标记跳过（不占额度/
+ *  不被丢弃/不计入 N——N6）。返回实际丢弃行数（= N 增量——无幽灵行）。字符账同步扣减。 */
 function dropCarrierLines(carrier, want) {
-  if (want <= 0 || carrier.blocks.length === 0) return 0
+  if (want <= 0) return 0
   let dropped = 0
-  while (want > dropped && carrier.blocks.length > 0) {
-    const first = carrier.blocks[0]
+  let freedChars = 0
+  while (want > dropped) {
+    const idx = carrier.blocks.findIndex((b) => !isTrimMarker(b))
+    if (idx === -1) break // 仅余省略标记（内容耗尽）——不再产生幽灵行
+    const first = carrier.blocks[idx]
     const lines = countBlockLines(first.text)
+    if (lines <= 0) { carrier.blocks.splice(idx, 1); continue } // 空块无显示行：移除不计数
     const take = Math.min(lines, want - dropped)
     if (take >= lines) {
-      carrier.blocks.shift()
+      carrier.blocks.splice(idx, 1)
       dropped += lines
+      freedChars += String(first.text).length
     } else {
-      first.text = first.text.split("\n").slice(take).join("\n")
+      const kept = String(first.text).split("\n").slice(take).join("\n")
+      freedChars += String(first.text).length - kept.length
+      first.text = kept
       dropped += take
     }
   }
-  carrier._lineCount = (carrier._lineCount ?? 0) - dropped
+  carrier._lineCount = Math.max(0, (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 }
+  carrier._charCount = Math.max(0, (carrier._charCount ?? 0) - freedChars)
+  if (dropped > 0) updateTrimMarker(carrier)
   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)
+/** 字符维裁剪（§15.3.3——无换行巨 chunk 的堵口）：逐行丢最旧直至释放 ≥ want 字符；
+ *  行数按实际被丢行折算 N（无幽灵计数——N6）；标记不占额度。返回释放字符数。 */
+function dropCarrierChars(carrier, want) {
+  if (!(want > 0)) return 0
+  let freed = 0
+  while (freed < want) {
+    const got = dropFirstContentLine(carrier)
+    if (got <= 0) break // 内容耗尽（不再产生幽灵行）
+    freed += got
+  }
+  if (freed > 0) {
+    carrier._charCount = Math.max(0, (carrier._charCount ?? 0) - freed)
+    updateTrimMarker(carrier)
   }
-  walk(root)
+  return freed
 }
 
-/** kind 合并追加（载体级）——既有 appendSubBlock 数学（净增行记账——P1）。 */
+/** 单载体 trim（原树级 trimSubTree 收窄——D-ST4）：超 500 显示行 → 最旧先行丢行；
+ *  超 SUB_BLOCK_CHAR_LIMIT 字符 → 同款最旧先行（双维先到先裁——TUI.md §15.3.4）。 */
+function trimSubCarrier(carrier) {
+  const over = (carrier._lineCount ?? 0) - SUB_BLOCK_LINE_LIMIT
+  if (over > 0) dropCarrierLines(carrier, over)
+  const overChars = (carrier._charCount ?? 0) - SUB_BLOCK_CHAR_LIMIT
+  if (overChars > 0) dropCarrierChars(carrier, overChars)
+}
+
+/** kind 合并追加（载体级）——净增行记账（显示行口径；省略标记不参与合并——N6）；
+ *  字符账同步累加（第二维——§15.3.4）。 */
 function pushBlock(carrier, kind, text, fresh) {
   if (!text) return
+  const capped = capText(text, SUB_BLOCK_CAP_OPTS) // 单块自身额度（无换行巨 chunk 堵口）
   const last = carrier.blocks.at(-1)
-  if (!fresh && last && last.kind === kind) {
+  if (!fresh && last && last.kind === kind && !isTrimMarker(last)) {
     const before = countBlockLines(last.text)
-    last.text += text
+    const beforeChars = last.text.length
+    last.text = capText(last.text + capped, SUB_BLOCK_CAP_OPTS)
     carrier._lineCount = (carrier._lineCount ?? 0) + countBlockLines(last.text) - before
+    carrier._charCount = (carrier._charCount ?? 0) + (last.text.length - beforeChars)
   } else {
-    carrier.blocks.push({ kind, text })
-    carrier._lineCount = (carrier._lineCount ?? 0) + countBlockLines(text)
+    carrier.blocks.push({ kind, text: capped })
+    carrier._lineCount = (carrier._lineCount ?? 0) + countBlockLines(capped)
+    carrier._charCount = (carrier._charCount ?? 0) + capped.length
   }
   carrier.blockEpoch = (carrier.blockEpoch ?? 0) + 1
 }
 
-/** 追加到根载体（外层块/压缩面板——无父载体者自身即配额树根）。树级 trim——
- *  无子块时与既有 trimSubBlocks 同效（N2 既有测试口径不变）。 */
+/** 追加到块载体（外层块/压缩面板——自身即配额环）：单载体 trim——无子块时与既有
+ *  trimSubBlocks 同效（N2 既有测试口径不变）。SUBAGENT-TAIL：内层行经 routeSub* 也
+ *  走本函数（append 目标上移——单一配额环）。 */
 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)
+  trimSubCarrier(sub)
 }
 
 /** R23 D-R23a：子块载体创建/定位——按段（role#N）在父载体 children 查找，缺失即建
- *  （每层一子块——任意 inner 深度同路径——D-R23d）。@returns 子块载体 */
+ *  （每层一子块——任意 inner 深度同路径——D-R23d）。SUBAGENT-TAIL 后子块只承载守护
+ *  元数据（done/currentTool/children——内容行归外层 blocks）。@returns 子块载体 */
 export function ensureSubChild(carrier, seg) {
   carrier.children ??= []
   let c = carrier.children.find((x) => x.key === seg)
@@ -119,7 +174,7 @@ export function ensureSubChild(carrier, seg) {
       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,
+      blockEpoch: 0, children: [], _lineCount: 0, _charCount: 0,
     }
     carrier.children.push(c)
   }
@@ -142,6 +197,7 @@ export function descendSubChild(root, inner, { create = true } = {}) {
 
 /** R23 D-R23c2 子块完成定格（内层 ⟦ev⟧done/stopped → 子块尾定格——不落 preview、不冻结
  *  外层）；stopped = interrupted（外层 abort 传播/内层错误收尾——T-R23a.3 不悬空）。
+ *  SUBAGENT-TAIL 后 done 为 F2 正读者（迟到 chunk 丢弃守卫）；currentTool 为 fresh 判别源。
  *  外层块头 currentTool 若指向该子块（innerPath 前缀——评审 #8 全路径现状保持）→ 清空
  *  （子块已定格——工具不再是 current）。 */
 export function closeSubChild(root, child, stopped, innerPath) {
@@ -158,7 +214,9 @@ export function closeSubChild(root, child, stopped, innerPath) {
 }
 
 /** R23 D-R23c2 收尾语义（T-R23c.2a）：外层先冻结而内层未收尾（外层 abort/中断）→
- *  内层子块随外层冻结时定格 stopped——不悬空。freezeSubTaskLines 冻结前调用。 */
+ *  内层子块随外层冻结时定格 stopped——不悬空。SUBAGENT-TAIL：② 语义照旧保留（防御性
+ *  写路径——定格后无正读者、不设断言；见 docs/design/TUI.md §6 守护字段类目 A）。
+ *  freezeSubTaskLines 冻结前调用。 */
 export function closeOpenSubChildren(sub) {
   const walk = (carrier) => {
     for (const c of carrier.children ?? []) {

package/src/tui/subagent-freeze.mjs

@@ -1,51 +1,54 @@
 /**
  * subagent-freeze.mjs — 子agent 区块完成/冻结族（2026-09-05 module-split：
- * subagent-blocks.mjs 625 > 500 硬限——§19.6 面板镜像 syncPanelSnapshot + finish/
- * freeze 家族 verbatim 迁入，语义零变；subagent-blocks.mjs import 回（routeSub* 与
- * compression panel 调用点）+ re-export 保外部 import 面（index.mjs 等）。
+ * subagent-blocks.mjs 625 > 500 硬限——§19.6 面板现算 computePanelBlocks + finish/
+ * freeze 家族迁入；subagent-blocks.mjs import 回（routeSub* 与 compression panel
+ * 调用点）+ re-export 保外部 import 面（index.mjs 等）。
+ * CLI-ACTIVITY-DEBLOAT F-3（2026-09-10）：§19.6 面板**手工镜像退役**（镜像读写
+ * 全删）——改读时现算 computePanelBlocks(state)：四字段 key/
+ * role/status/startedAt 均为 state.subTasks 活值纯推导（评审 #2 确证），读时现算
+ * 与 sync 时刻镜像等价——双账本结构性漂移根治（单账本）。完成/冻结族不再逐点刷镜
+ * （无镜像可刷——调用点全清）。
  */
 
 import { C } from "./ansi.mjs"
 import { closeOpenSubChildren } from "./subagent-children.mjs"
+// TUI-OOM-ROOTCAUSE（TUI.md §15.3.3 落点表末行）：state.lines 总量账——splice 插入路径过账。
+import { accountLine } from "./display-budget.mjs"
 
-// ─── §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 侧判定）。
+// ─── §19.6 D-P1 面板视图（subagent panel 检查工具）───
+// CLI-ACTIVITY-DEBLOAT F-3：面板区块列表由消费面**读时现算**（action:"panel" 经
+// ctx.state = agent._tuiState（index.mjs startTUI 装配）取 TUI state——subTasks
+// 活值纯推导——视图与用户所见一致（同一数据源单账本））。未挂载（headless/VSC/
+// 子代理——agent._tuiState 缺省）→ 返 null = 无面板——消费面降级池视图/freeze 报
+// 不可用（T-P5 语义不变）。status 三态映射（纯函数）：done+awaitingDigest →
+// "awaitingDigest"；done → "done"；queued（waiting/等位未启动）→ "queued"；
+// 其余 → "running"（§20 D-SD3b queued 态入镜口径保留）。
 
-/** 刷新面板镜像（调用点 = 本模块全部 state.subTasks 块级变更点末尾——map 已稳定）。 */
-export 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 态入镜（镜像与面板
+/** 现算面板块列表（state.subTasks 活值纯推导——无时点快照语义）。 */
+export function computePanelBlocks(state) {
+  const subs = state?.subTasks
+  if (!subs) return null // 未挂载（headless/mock 无 TUI state）——无面板
+  const blocks = []
+  for (const sub of Object.values(subs)) {
+    // §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() })
+    blocks.push({ key: sub.key, role: sub.role ?? null, status, startedAt: sub.started ?? Date.now() })
   }
-  agent._panelSnapshot = snap
+  return blocks
 }
 
-/** Mark the earliest running child of the given role(s) as done (✓ header, frozen elapsed). */
+/** §7.2.3 完成冻结——CLI-ACTIVITY-DEBLOAT F-2（2026-09-10）收窄：本函数是历史启发式
+ *  入口（"最早 started"角色匹配——§15 async 化后的 7.2.3.1 实测误冻源：async eng-coder
+ *  先启动时 explore 完成会误冻其块）。评审 #4 路线定死：签名保留、函数体收窄为精确
+ *  匹配校验——本签名无 key 参数，无从精确归属 → 恒 no-op 返 null，不再猜任何块
+ *  （宁可 no-op 不误冻——被否决备选"保留兜底加告警日志"：冻错块是错动作，日志救不回）。
+ *  finishSubTaskKey 为唯一完成路径；roles/lastError 仅签名兼容保留（老调用面 import
+ *  不断——误冻面归零，无 key 窗口的块由回合尾 freezeAllSubTasks 兜底清场）。
+ *  @returns {null} 恒 null（无精确 key 命中面——无从归属不归属）。 */
 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 状态变更刷镜
+  void state; void roles; void lastError // 收窄后零副作用——参数仅签名兼容
+  return null
 }
 
 /** §7.2.3 sync spawn 完成精确冻结（2026-09-03）：按 relay key 精确 settle。finishSubTask
@@ -64,28 +67,32 @@ export function finishSubTaskKey(state, key, lastError = 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} 与运行面板同源跨冻结延续）。
  *  §27 R23 D-R23c2 收尾语义（T-R23c.2a）：外层先冻结而内层子块未收尾（外层 abort/
- *  中断）→ 子块随外层冻结定格 stopped（closeOpenSubChildren——不悬空）。
+ *  中断）→ 子块随外层冻结定格 stopped（closeOpenSubChildren——不悬空）。SUBAGENT-TAIL：
+ *  ② 语义照旧（防御性保留——无正读者、不设断言；显示契约 docs/design/TUI.md §6）。
  *  锚点插入（2026-09-03 修复轮）：settled 块带 _freezeAt（settle 时刻流位置）——
  *  splice 落位使挂起期补发冻结块位于其 digest 总览文本之前；无锚点尾推不变；
  *  多锚点批量冻结按降序（绝对位置 splice——先插小锚点会移走大锚点目标）。 */
 export function freezeSubTaskLines(state, sub) {
   if (!sub) return
-  closeOpenSubChildren(sub) // R23 D-R23c2——开子块随外层冻结定格 stopped
+  closeOpenSubChildren(sub) // R23 D-R23c2——开子块随外层冻结定格 stopped（SUBAGENT-TAIL：② 防御性保留）
   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, {
+  const line = {
     text: `subagent activity: ${sub.key}`, color: C.dim, _frozenSubTask: sub,
-  })
+  }
+  state.lines.splice(Math.min(anchor, state.lines.length), 0, line)
+  // TUI-OOM-ROOTCAUSE（TUI.md §15.3.3 落点表末行「冻结子代理 splice 插入——经
+  // syncLineBudget 同款对账」）：冻结行进 state.lines 总量账（splice 插入路径）。
+  accountLine(state, line)
 }
 
 /** 头裁锚点校正（index.mjs pushLine 调用）：裁 removedCount 补 1 标记行 = 净位移
@@ -107,11 +114,10 @@ export function freezeDoneSubTasks(state) {
     freezeSubTaskLines(state, sub)
     delete state.subTasks[sub.key]
   }
-  syncPanelSnapshot(state) // §19.6 D-P1: 删除后刷镜（块移出面板）
 }
 
-/** 按角色整组标记 done——consult N 并行 children 的会话级 settle（单发
- *  finishSubTask 只结最早一个——consult 残项 2026-08-30）。 */
+/** 按角色整组标记 done——consult N 并行 children 的会话级 settle（2026-08-30；
+ *  F-2 收窄后 finishSubTask 已退役 no-op——本函数为唯一按角色完成面）。 */
 export function finishSubTasksByRole(state, roles, lastError = null) {
   state.subTasks ??= {}
   const roleSet = new Set(Array.isArray(roles) ? roles : [roles])
@@ -125,7 +131,6 @@ export function finishSubTasksByRole(state, roles, lastError = null) {
       sub.blockEpoch = (sub.blockEpoch ?? 0) + 1
     }
   }
-  syncPanelSnapshot(state) // §19.6 D-P1: done 状态变更刷镜
 }
 
 /** 回合尾/挂起退出清扫（runAgentTurn finally / suspensionSession finally）：冻结全部
@@ -146,7 +151,6 @@ export function freezeAllSubTasks(state) {
     freezeSubTaskLines(state, sub)
     delete state.subTasks[sub.key]
   }
-  syncPanelSnapshot(state) // §19.6 D-P1: 冻结回收后刷镜（块移出面板）
 }
 
 /** §17.5.5 消化完成逐条冻结回收（2026-09-03 实测修订 + round1 #1 位置裁定）：digest/会话内
@@ -167,6 +171,5 @@ export function freezeReclaimDigestedBlocks(state, pendingList) {
     freezeSubTaskLines(state, sub) // splice 落 settle 锚点（digest 总览文本之前）
     delete state.subTasks[sub.key]
   }
-  syncPanelSnapshot(state) // §19.6 D-P1: 逐条回收后刷镜（块移出面板）
   return targets.length
 }

package/src/tui/subagent-panel.mjs

@@ -12,8 +12,10 @@
  *
  * §19.5 D-M7 ⏹：运行中（非 done）折叠头右缘停止标记（dim，仅折叠头）——点击 =
  * cancel（mouse.mjs 列级命中 _stopCol——不触发折叠翻转）。
- * §27 R23（supersede §19.5 D-M8 子标方案）：嵌套子代理渲染为子块段（renderSubChildSections
- * ——子块头 + 独立折叠键——面板与冻结渲染共用——styleSubLabelRow 已随子标机制退役）。
+ * SUBAGENT-TAIL（supersede §27 R23 子块段方案；显示契约 docs/design/TUI.md §6）：嵌套
+ * 子代理内容行并入本块 blocks（数据层——append 目标上移）——面板与冻结渲染只读
+ * sub.blocks（无子块段/无子块头/无每层折叠键）；折叠键只剩 `sub-${key}`（面板 ↔
+ * 冻结同键——D5 无缝衔接不变）。
  *
  * 中立模块（D1 评审 #6）：layout.mjs 调 renderSubagentPanel 预计算面板高度
  * （subagentLines → subagentH），render-frame.mjs 直接 put 预计算行（不重复
@@ -31,61 +33,6 @@ import { sliceByWidth, stringWidth } from "./render.mjs"
 import { isExpanded, renderBlockTimeline, renderExpandedBlock, foldTailLines } from "./fold-block.mjs"
 import { SUBAGENT_ROLES } from "./subagent-blocks.mjs"
 
-/**
- * §27 R23 子块（嵌套子代理）段渲染——面板与冻结渲染共用（中立纯函数模块）：
- * 每子块 = 工具式头行（`❯ explore#N · model · elapsed`——D-R23b，dim ❯ + role#N 亮 +
- * model/elapsed dim——与 C 工具头同排式；done/stopped 定格动词——D-R23c2）+ 折叠态
- * tail 2 / 展开态全量窗口（60% 封顶 + 块内滚动——fold-block 公共组件）；孙块递归
- * （任意 inner 深度——D-R23d——每层独立折叠键）。折叠键 = `sub-{outerKey}/{innerPath}`
- * （D-R23e——与既有 sub-{key} 同族——_foldToggle 命中映射复用 fold-block 通用通道——
- * mouse.mjs 零改动）。行数配额在数据层（子块计入外层 500 行环——NFR）。
- */
-
-/** 子块折叠键（D-R23e）：sub-{outerKey}/{innerPath}。 */
-export function subChildFoldKey(rootKey, innerPath) {
-  return `sub-${rootKey}/${innerPath}`
-}
-
-/** 子块头行（D-R23b/c2）——返回带 _foldToggle 的行（可点击折叠/展开——fold-block 通道）。 */
-function subChildHeadRow(rootKey, child, innerPath, cols) {
-  const foldKey = subChildFoldKey(rootKey, innerPath)
-  const end = child.done ? (child.doneAt ?? Date.now()) : Date.now()
-  const secs = Math.max(0, Math.floor((end - (child.started ?? end)) / 1000))
-  const verb = child.done ? (child.stopped ? `stopped ${secs}s` : `done ${secs}s`) : `${secs}s`
-  const raw = `❯ ${child.key}${child.model ? ` · ${child.model}` : ""} · ${verb}`
-  let text = sliceByWidth(raw, Math.max(1, cols - 2))
-  // dim 注入（截断后——自闭合：行末由打印端 reset 兜底；灰色段间 restore 恢复行基色）。
-  const restore = ansi.fg(6) // 行基色 C.tool（cyan）
-  if (text.startsWith("❯")) text = `${ansi.gray}❯${restore}${text.slice(1)}`
-  const sep = text.indexOf(" · ")
-  if (sep > 0) text = `${text.slice(0, sep)}${ansi.gray}${text.slice(sep)}`
-  return { text, color: C.tool, _foldToggle: foldKey }
-}
-
-/** 子块段行（head + 折叠 tail2 / 展开窗口）——递归孙块。root = 外层块（key 为折叠前缀源）。 */
-export function renderSubChildSections(state, root, cols, maxRows) {
-  const out = []
-  const walk = (carrier, path) => {
-    for (const child of carrier.children ?? []) {
-      const innerPath = path ? `${path}/${child.key}` : child.key
-      out.push(subChildHeadRow(root.key, child, innerPath, cols))
-      const foldKey = subChildFoldKey(root.key, innerPath)
-      if (isExpanded(state, foldKey)) {
-        // 展开：全量时间线窗口化（per-kind 着色，60% 封顶 + 块内滚动——公共组件）
-        const body = renderBlockTimeline(child.blocks, cols)
-        out.push(...renderExpandedBlock({ body, foldKey, state, maxRows, cols, label: `${child.key} activity` }))
-      } else {
-        // 折叠：tail 2 非空行（最近活动）——dim（与既有外层折叠 tail 同型）
-        for (const line of foldTailLines(child.blocks, 2)) {
-          out.push({ text: `│ ${sliceByWidth(line, cols - 4)}`, color: C.dim, _skipDimFold: true })
-        }
-      }
-      walk(child, innerPath)
-    }
-  }
-  walk(root, "")
-  return out
-}
 /**
  * 面板行构建（纯函数）：顶部分隔线 `─` + 各运行中区块（折叠头 + tail 3 /
  * 展开全量）。maxRows = 终端行数（展开态 60% 封顶窗口化）；省略 = 不封顶
@@ -109,7 +56,7 @@ export function renderSubagentPanel(state, cols, maxRows) {
     // §19.5 D-M7b ②: sync/async 显式头标（B 形态——不靠"没标推断"）——async 由
     // ⟦ev⟧async 标记置位；sync 区块（无标记）显式标 sync。真实 subagent 角色
     // （escalate/consult/compress 等复用面板槽的条目无语义——非 spawn 角色豁免）；
-    // §24 D-24b：role "advisor" 伪角色同面板（块/⏹/冻结复用——ruling ②-4 A）。
+    // §11.2 D-24b：role "advisor" 伪角色同面板（块/⏹/冻结复用——ruling ②-4 A）。
     // 冻结后保留（与 model 标识同生命周期——render-conversation frozenSubTaskLines
     // 同款 modePart）。**颜色后置注入**（code review 🔵#4）：bracket 宽度预算用纯文
     // 本（dim ANSI 内嵌会被 sliceByWidth 截断在 restore 之前 → 行尾残留 dim）——
@@ -119,7 +66,9 @@ export function renderSubagentPanel(state, cols, maxRows) {
     // §20 D-SD3b waiting 块（sub.queued——排队 spawn 返回即建——未启动无 relay 流）：
     // 括号状态词 = waiting（依赖/域冲突等位——detail 即原因）或 queued（槽满等位——
     // 状态区显示 position）；不显示 sync/async 词（尚未启动——无 async 标记可言——
-    // sync 词会误导：async spawn 排队的块不是 sync）；⏹ 门控不变（async 启动后才置）。
+    // sync 词会误导：async spawn 排队的块不是 sync）；⏹ 门控（QUEUED-VISIBILITY F-2——
+    // 2026-09-09）：queued 块头即置取消 ⏹（slot/wait/depc 三态——用户可撤销排队决策——
+    // 点击 = 出队——覆盖 SESSION-ACTIVITY-REVISED F-6“接受无取消”旧裁）。
     const queued = sub.queued ?? null
     const statusWord = queued ? (queued.kind === "slot" ? "queued" : "waiting") : null
     const modeWord = isSubRole && !queued ? (sub.async === true ? "async" : "sync") : null
@@ -160,14 +109,22 @@ export function renderSubagentPanel(state, cols, maxRows) {
       : ""
     let headText = `${bracket} ${sliceByWidth(statePart + argSummary, Math.max(0, cols - 2 - bracketWidth))}`
     const line = { color: C.tool, _foldToggle: foldKey }
-    // §19.5 D-M7 ⏹ + D-M7b ③ 门控：⏹ 只对 async 区块（running && SUBAGENT_ROLES &&
-    // sub.async——sync 区块无 ⏹——杜绝"可见但不可中止"误导——用户裁定 B 形态）。
-    // done/awaitingDigest/压缩面板（role compress）/consult 无标记（点击只对池内
-    // async 子代理有意义）：dim 停止标记钉在折叠头右缘**内收一列**（code review
+    // §19.5 D-M7 ⏹ + D-M7b ③ 门控 + SYNC-CANCEL F3（2026-09-09）：⏹ 只对 **live 可中止**
+    // 区块——async（running && sub.async——⟦ev⟧async 置位）∪ **sync registry live**
+    // （state._agent?._syncChildAborts?.has(sub.key)——阻塞 spawn 运行期注册——成功/折叠/
+    // 整回合停后 finally 注销——门控自动放下）——杜绝"可见但不可中止"误导。真实 subagent
+    // 角色（SUBAGENT_ROLES）+ advisor；escalate/consult/compress 无 registry 无 ⏹。
+    // **headless/测试无 _agent → sync 不钉 ⏹**（registry miss——零回归——AC6）；async
+    // 区块不依赖 _agent（sub.async 置位即钉）。done/awaitingDigest 无标记（点击只对池内/
+    // registry 内 live 子代理有意义）：dim 停止标记钉在折叠头右缘**内收一列**（code review
     // 🟡#1——glyph 在 cols−1、最右列留 margin——避免终端最末列点击不可靠/全角字形
     // 顶格被裁；命中区 = col ≥ _stopCol = cols−1——含 glyph 与其右 margin，左邻
     // padding 空格仍走折叠）。整行 ≤ cols：内容先按 cols−3 截断。
-    if (!sub.done && sub.async === true && (SUBAGENT_ROLES.includes(sub.role) || sub.role === "advisor")) {
+    const registryLive = state._agent?._syncChildAborts?.has(sub.key) === true
+    // F-2（QUEUED-VISIBILITY——2026-09-09）：门控扩 queued——排队块（sub.queued——
+    // slot/wait/depc 三态）头置取消 ⏹（用户可撤销排队决策）——queued 恒先于 async 置位
+    // （subagent-blocks queued 分支守卫）——async/registry-live 判定不变（running 停面）。
+    if (!sub.done && (sub.async === true || registryLive || !!queued) && (SUBAGENT_ROLES.includes(sub.role) || sub.role === "advisor")) {
       const cut = sliceByWidth(headText, Math.max(0, cols - 3))
       headText = cut + " ".repeat(Math.max(0, cols - 3 - stringWidth(cut)))
       line.text = `${headText} ${ansi.dim}⏹${ansi.reset} `
@@ -187,8 +144,6 @@ export function renderSubagentPanel(state, cols, maxRows) {
         out.push({ text: `│ ${sliceByWidth(line, cols - 4)}`, color: C.dim })
       }
     }
-    // §27 R23：子块段（嵌套子代理——头 + tail2/展开窗口）随外层块渲染（面板与冻结共用）。
-    out.push(...renderSubChildSections(state, sub, cols, maxRows))
   }
   return out
 }