thincoder 0.12.59 → 0.12.61

package/src/tui/subagent-children.mjs

@@ -0,0 +1,162 @@
+/**
+ * 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 }
+ * SUBAGENT-TAIL（D-ST1）后内层 relay 行**不再存子块**——append 目标上移外层块 blocks
+ * （单存储单账本；子块 blocks 恒空）。子块载体降为**守护元数据**，职责 = ① done 后
+ * 迟到 chunk 丢弃（F2 语义不回退）② 外层冻结时未收尾子块不悬空（closeOpenSubChildren
+ * ——写路径保留，无正读者）③ 内层工具 fresh 判别（leaf.currentTool）。
+ *
+ * N2 单环配额（D-ST4）：全部内容行（含内层并入行）就地计入外层 500 **显示行**环——
+ * trim = 单载体最旧先行（原树级 trim「子块先丢 / done 豁免」随子块内容层退役）。
+ * 省略计数真值（N6——D-ST5）：`…（已省略 N 行）` 的 N 只随内容移除增长；标记自身
+ * 不占额度、不被丢弃、不计入 N。
+ */
+export const SUB_BLOCK_LINE_LIMIT = 500
+
+/** 显示行计数（N6 口径）：块尾 `\n` 的空元素不计（行结束符非空行）。 */
+const countBlockLines = (text) => {
+  const lines = String(text ?? "").split("\n")
+  return lines[lines.length - 1] === "" ? lines.length - 1 : lines.length
+}
+
+/** 省略标记块判定（trim 产物——不占额度/不可被丢；N6）。 */
+const isTrimMarker = (b) => b?.kind === "meta" && b._trimMarker === true
+
+/** 载体级丢行（D-ST4 单环最旧先行）：从头部内容块 FIFO 丢行；省略标记跳过（不占额度/
+ *  不被丢弃/不计入 N——N6）。返回实际丢弃行数（= N 增量——无幽灵行）。 */
+function dropCarrierLines(carrier, want) {
+  if (want <= 0) return 0
+  let dropped = 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.splice(idx, 1)
+      dropped += lines
+    } else {
+      first.text = first.text.split("\n").slice(take).join("\n")
+      dropped += take
+    }
+  }
+  carrier._lineCount = Math.max(0, (carrier._lineCount ?? 0) - dropped)
+  carrier.dropped = (carrier.dropped ?? 0) + dropped
+  if (dropped > 0) {
+    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 }) // 标记不占额度（N6）
+  }
+  return dropped
+}
+
+/** 单载体 trim（原树级 trimSubTree 收窄——D-ST4）：超 500 显示行 → 最旧先行丢行。 */
+function trimSubCarrier(carrier) {
+  const over = (carrier._lineCount ?? 0) - SUB_BLOCK_LINE_LIMIT
+  if (over > 0) dropCarrierLines(carrier, over)
+}
+
+/** kind 合并追加（载体级）——净增行记账（显示行口径；省略标记不参与合并——N6）。 */
+function pushBlock(carrier, kind, text, fresh) {
+  if (!text) return
+  const last = carrier.blocks.at(-1)
+  if (!fresh && last && last.kind === kind && !isTrimMarker(last)) {
+    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 既有测试口径不变）。SUBAGENT-TAIL：内层行经 routeSub* 也
+ *  走本函数（append 目标上移——单一配额环）。 */
+export function appendSubBlock(sub, kind, text, { fresh = false } = {}) {
+  if (!text) return
+  pushBlock(sub, kind, text, fresh)
+  trimSubCarrier(sub)
+}
+
+/** R23 D-R23a：子块载体创建/定位——按段（role#N）在父载体 children 查找，缺失即建
+ *  （每层一子块——任意 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)
+  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 不悬空）。
+ *  SUBAGENT-TAIL 后 done 为 F2 正读者（迟到 chunk 丢弃守卫）；currentTool 为 fresh 判别源。
+ *  外层块头 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——不悬空。SUBAGENT-TAIL：② 语义照旧保留（防御性
+ *  写路径——定格后无正读者、不设断言；见 docs/design/TUI.md §6 守护字段类目 A）。
+ *  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,169 @@
+/**
+ * subagent-freeze.mjs — 子agent 区块完成/冻结族（2026-09-05 module-split：
+ * 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"
+
+// ─── §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 活值纯推导——无时点快照语义）。 */
+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")
+    blocks.push({ key: sub.key, role: sub.role ?? null, status, startedAt: sub.started ?? Date.now() })
+  }
+  return blocks
+}
+
+/** §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) {
+  void state; void roles; void lastError // 收窄后零副作用——参数仅签名兼容
+  return null
+}
+
+/** §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
+  return sub
+}
+
+/** 冻结完成/中断区块进 state.lines（§7.2 D4——_frozenSubTask 载体行，渲染端
+ *  render-conversation 识别；折叠交互 key = sub-${key} 与运行面板同源跨冻结延续）。
+ *  §27 R23 D-R23c2 收尾语义（T-R23c.2a）：外层先冻结而内层子块未收尾（外层 abort/
+ *  中断）→ 子块随外层冻结定格 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（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, {
+    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]
+  }
+}
+
+/** 按角色整组标记 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])
+  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
+    }
+  }
+}
+
+/** 回合尾/挂起退出清扫（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]
+  }
+}
+
+/** §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]
+  }
+  return targets.length
+}

package/src/tui/subagent-panel.mjs

@@ -12,7 +12,10 @@
  *
  * §19.5 D-M7 ⏹：运行中（非 done）折叠头右缘停止标记（dim，仅折叠头）——点击 =
  * cancel（mouse.mjs 列级命中 _stopCol——不触发折叠翻转）。
- * §19.5 D-M8：本模块同时承载子标行 dim 样式（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 预计算行（不重复
@@ -30,26 +33,6 @@ import { sliceByWidth, stringWidth } from "./render.mjs"
 import { isExpanded, renderBlockTimeline, renderExpandedBlock, foldTailLines } from "./fold-block.mjs"
 import { SUBAGENT_ROLES } from "./subagent-blocks.mjs"
 
-/** 子标行行首标记（`explore#1 · `——sublabelLine 写入的字面形态）。 */
-const SUB_LABEL_RE = /^([\w-]+#\d+(?:\/[\w-]+#\d+)* · )/
-
-/** §19.5 D-M8 子标行 dim 样式（最终渲染点注入——行对象单色外 wrap 无法表达行内
- *  双色）：行首 `explore#1 · ` 子标转 gray（90m），其后内容恢复该行 kind 色
- *  （tool=cyan / text=白 / think=默认 fg——dim 属性本就由 C.reason 施加，不受
- *  fg 切换影响）。折叠 tail / dim 行不需调用（整行已 dim）。返回新行对象。 */
-export function styleSubLabelRow(row) {
-  const content = String(row.text).replace(/^│ /, "")
-  const m = content.match(SUB_LABEL_RE)
-  if (!m) return row
-  const restore = row.color === C.tool ? ansi.fg(6)
-    : row.color === C.text ? ansi.fg(7)
-    : ansi.fg(9) // 默认 fg（think 行 C.reason=dim 属性——90m 后切回默认即还原 dim 白）
-  return {
-    ...row,
-    text: `│ ${ansi.gray}${m[1]}${restore}${content.slice(m[1].length)}`,
-  }
-}
-
 /**
  * 面板行构建（纯函数）：顶部分隔线 `─` + 各运行中区块（折叠头 + tail 3 /
  * 展开全量）。maxRows = 终端行数（展开态 60% 封顶窗口化）；省略 = 不封顶
@@ -71,18 +54,21 @@ export function renderSubagentPanel(state, cols, maxRows) {
     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 角色
+    // ⟦ev⟧async 标记置位；sync 区块（无标记）显式标 sync。真实 subagent 角色
     // （escalate/consult/compress 等复用面板槽的条目无语义——非 spawn 角色豁免）；
+    // §11.2 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)
+    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 启动后才置）。
+    // 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
@@ -123,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)) {
+    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} `
@@ -142,8 +136,7 @@ export function renderSubagentPanel(state, cols, maxRows) {
     out.push(line)
     if (isExpanded(state, foldKey)) {
       // 展开态：全量活动时间线（per-kind 着色，60% 屏封顶 + 块内滚动——公共组件）。
-      // §19.5 D-M8：时间线行过 styleSubLabelRow——行首子标 dim、内容恢复 kind 色。
-      const body = renderBlockTimeline(sub.blocks, cols).map(styleSubLabelRow)
+      const body = renderBlockTimeline(sub.blocks, cols)
       out.push(...renderExpandedBlock({ body, foldKey, state, maxRows, cols, label: "subagent activity" }))
     } else {
       // 折叠态：tail 3 非空 block 行（最近活动），dim。