thincoder 0.12.58 → 0.12.60

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)
+}

package/src/tui/subagent-freeze.mjs

@@ -0,0 +1,172 @@
+/**
+ * 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 等）。
+ */
+
+import { C } from "./ansi.mjs"
+import { closeOpenSubChildren } from "./subagent-children.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 侧判定）。
+
+/** 刷新面板镜像（调用点 = 本模块全部 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 态入镜（镜像与面板
+    // 所见一致——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
+}
+
+/** 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} 与运行面板同源跨冻结延续）。
+ *  §27 R23 D-R23c2 收尾语义（T-R23c.2a）：外层先冻结而内层子块未收尾（外层 abort/
+ *  中断）→ 子块随外层冻结定格 stopped（closeOpenSubChildren——不悬空）。
+ *  锚点插入（2026-09-03 修复轮）：settled 块带 _freezeAt（settle 时刻流位置）——
+ *  splice 落位使挂起期补发冻结块位于其 digest 总览文本之前；无锚点尾推不变；
+ *  多锚点批量冻结按降序（绝对位置 splice——先插小锚点会移走大锚点目标）。 */
+export function freezeSubTaskLines(state, sub) {
+  if (!sub) return
+  closeOpenSubChildren(sub) // R23 D-R23c2——开子块随外层冻结定格 stopped
+  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 状态变更刷镜
+}
+
+/** 回合尾/挂起退出清扫（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
+}

package/src/tui/subagent-panel.mjs

@@ -6,7 +6,14 @@
  * 运行中区块的渲染行数（F2，会话区被挤小）；无运行中区块 → 返回 []（F6 空态，
  * 无悬空分隔线）。子 agent 完成后立即冻结进会话流（subagent-blocks.mjs
  * freezeSubTaskLines，✓ 头 + 可展开，§7.2 D4 现状不变），面板下一帧自然移除
- * 该区块（F5）——本模块只渲染 `!done` 条目。
+ * 该区块（F5）——本模块只渲染 `!done` 条目。§17 T-S14 中间态例外：挂起期已结算
+ * 区块（sub.done && sub.awaitingDigest）冻结被延迟，驻留面板显示
+ * "done · awaiting digestion"，池空补发冻结后才移除。
+ *
+ * §19.5 D-M7 ⏹：运行中（非 done）折叠头右缘停止标记（dim，仅折叠头）——点击 =
+ * cancel（mouse.mjs 列级命中 _stopCol——不触发折叠翻转）。
+ * §27 R23（supersede §19.5 D-M8 子标方案）：嵌套子代理渲染为子块段（renderSubChildSections
+ * ——子块头 + 独立折叠键——面板与冻结渲染共用——styleSubLabelRow 已随子标机制退役）。
  *
  * 中立模块（D1 评审 #6）：layout.mjs 调 renderSubagentPanel 预计算面板高度
  * （subagentLines → subagentH），render-frame.mjs 直接 put 预计算行（不重复
@@ -19,10 +26,66 @@
  * 折叠状态 key = `sub-${key}` 跨 turn 保持（D5，与冻结区块同一 key——冻结边界
  * 无缝衔接）。
  */
-import { C } from "./ansi.mjs"
+import { ansi, C } from "./ansi.mjs"
 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% 封顶窗口化）；省略 = 不封顶
@@ -30,7 +93,7 @@ import { isExpanded, renderBlockTimeline, renderExpandedBlock, foldTailLines } f
  * @returns {Array<{text: string, color: string, ...}>}
  */
 export function renderSubagentPanel(state, cols, maxRows) {
-  const runningSubs = Object.values(state.subTasks ?? {}).filter((s) => !s.done)
+  const runningSubs = Object.values(state.subTasks ?? {}).filter((s) => !s.done || s.awaitingDigest)
   if (runningSubs.length === 0) return []
   const out = []
   // 面板顶部边界线（现状分隔线语义迁移，§7.2.1 D2/NF2）——面板存在即画线，
@@ -41,8 +104,26 @@ export function renderSubagentPanel(state, cols, maxRows) {
     // 头部摘要：`[▶ coder#1 · glm-5.3 · 45s · turn 12/100] bash — npm test`
     // ⏸ = 等待审批态（sub.approval 非空，评审 #5 定义）；图标在括号内，
     // 与冻结头 `[✓ …]` 格式统一（任务简报 UI 决策）。
-    const icon = sub.approval ? "⏸" : "▶"
-    const elapsed = Math.floor((Date.now() - sub.started) / 1000)
+    const icon = sub.approval ? "⏸" : sub.done ? "✓" : "▶"
+    const elapsed = Math.floor(((sub.done ? (sub.doneAt ?? Date.now()) : Date.now()) - sub.started) / 1000)
+    // §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）。
+    // 冻结后保留（与 model 标识同生命周期——render-conversation frozenSubTaskLines
+    // 同款 modePart）。**颜色后置注入**（code review 🔵#4）：bracket 宽度预算用纯文
+    // 本（dim ANSI 内嵌会被 sliceByWidth 截断在 restore 之前 → 行尾残留 dim）——
+    // 截断后对完整存活的 mode word 单独套 dim + 恢复行色（自闭合——截断落在词内
+    // 则 replace 不命中 → 无 ANSI 泄漏，词以行色显示）。
+    const isSubRole = SUBAGENT_ROLES.includes(sub.role) || sub.role === "advisor"
+    // §20 D-SD3b waiting 块（sub.queued——排队 spawn 返回即建——未启动无 relay 流）：
+    // 括号状态词 = waiting（依赖/域冲突等位——detail 即原因）或 queued（槽满等位——
+    // 状态区显示 position）；不显示 sync/async 词（尚未启动——无 async 标记可言——
+    // sync 词会误导：async spawn 排队的块不是 sync）；⏹ 门控不变（async 启动后才置）。
+    const queued = sub.queued ?? null
+    const statusWord = queued ? (queued.kind === "slot" ? "queued" : "waiting") : null
+    const modeWord = isSubRole && !queued ? (sub.async === true ? "async" : "sync") : null
+    const modePart = modeWord ? ` · ${modeWord}` : (statusWord ? ` · ${statusWord}` : "")
     // 评审 #1 宽度预算：模型名先单独按显示宽度截断（[model] token 原样记录可长
     // 20-30+ 字符，不截断则括号前缀宽度不可预算、状态区被挤出终端右边距）；
     // 再量括号前缀实际显示宽度，状态区按 cols - bracketWidth - 2 截断——整行
@@ -52,20 +133,50 @@ export function renderSubagentPanel(state, cols, maxRows) {
       ? ` · ${sliceByWidth(sub.model, Math.max(8, Math.floor(cols / 3)))}`
       : ""
     const turnPart = sub.maxTurns > 0 ? ` · turn ${sub.turn}/${sub.maxTurns}` : ""
-    const bracket = sliceByWidth(`[${icon} ${sub.key}${modelPart} · ${elapsed}s${turnPart}]`, Math.max(1, cols - 2))
+    const bracketRaw = `[${icon} ${sub.key}${modePart}${modelPart} · ${elapsed}s${turnPart}]`
+    let bracket = sliceByWidth(bracketRaw, Math.max(1, cols - 2))
+    if (modeWord) {
+      const painted = bracket.replace(` · ${modeWord}`, ` · ${ansi.dim}${modeWord}${C.tool}`)
+      if (painted !== bracket) bracket = painted // 词被截断则保持纯文本（不泄漏 dim）
+    }
+    if (statusWord) {
+      const painted = bracket.replace(` · ${statusWord}`, ` · ${ansi.dim}${statusWord}${C.tool}`)
+      if (painted !== bracket) bracket = painted
+    }
     const bracketWidth = stringWidth(bracket)
     let statePart
-    if (sub.approval) statePart = `等待审批: ${sub.approval}`
+    if (queued) {
+      // waiting 块状态区：detail 即原因文本（waiting for: …/dependency cancelled: …）；
+      // slot 等位 → queued · position N（槽满）。
+      statePart = queued.kind === "slot"
+        ? `queued · position ${queued.position ?? "?"}（槽满等位）`
+        : (queued.detail || "queued")
+    } else if (sub.approval) statePart = `等待审批: ${sub.approval}`
+    else if (sub.awaitingDigest) statePart = "done · awaiting digestion"
     else if (sub.currentTool) statePart = sub.currentTool
     else statePart = "thinking..."
     const argSummary = sub.currentTool && sub.toolArgs?.command
       ? ` — ${String(sub.toolArgs.command).replace(/\s+/g, " ").trim().slice(0, 60)}`
       : ""
-    out.push({
-      text: `${bracket} ${sliceByWidth(statePart + argSummary, Math.max(0, cols - 2 - bracketWidth))}`,
-      color: C.tool,
-      _foldToggle: foldKey,
-    })
+    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
+    // 🟡#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 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} `
+      line._stopSub = sub.key
+      line._stopCol = Math.max(1, cols - 1)
+    } else {
+      line.text = headText
+    }
+    out.push(line)
     if (isExpanded(state, foldKey)) {
       // 展开态：全量活动时间线（per-kind 着色，60% 屏封顶 + 块内滚动——公共组件）。
       const body = renderBlockTimeline(sub.blocks, cols)
@@ -76,6 +187,8 @@ 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
 }