thincoder 0.12.60 → 0.12.61

package/src/tui/subagent-children.mjs

@@ -1,82 +1,74 @@
 /**
- * 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。
  */
 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
+/** 显示行计数（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
+
+/** 载体级丢行（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]
+  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
     } else {
       first.text = first.text.split("\n").slice(take).join("\n")
       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 }
+  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
 }
 
-/** 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)
+/** 单载体 trim（原树级 trimSubTree 收窄——D-ST4）：超 500 显示行 → 最旧先行丢行。 */
+function trimSubCarrier(carrier) {
+  const over = (carrier._lineCount ?? 0) - SUB_BLOCK_LINE_LIMIT
+  if (over > 0) dropCarrierLines(carrier, over)
 }
 
-/** kind 合并追加（载体级）——既有 appendSubBlock 数学（净增行记账——P1）。 */
+/** kind 合并追加（载体级）——净增行记账（显示行口径；省略标记不参与合并——N6）。 */
 function pushBlock(carrier, kind, text, fresh) {
   if (!text) return
   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
     carrier._lineCount = (carrier._lineCount ?? 0) + countBlockLines(last.text) - before
@@ -87,27 +79,18 @@ function pushBlock(carrier, kind, text, fresh) {
   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)
@@ -142,6 +125,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 +142,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,52 @@
 /**
  * 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"
 
-// ─── §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,20 +65,20 @@ 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
@@ -107,11 +108,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 +125,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 +145,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 +165,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
 }

package/src/tui/suspension-drive.mjs

@@ -4,10 +4,11 @@
  * re-import（runAgentTurn ↔ suspensionSession 函数级静态环——模块求值期无顶层调用，
  * 环安全——session-slots ↔ session.mjs 同款先例）。
  *
- * §17（2026-09-02，AGENT-LOOP.md §17 D-S1..S9）：回合尾后台池非空 → 不阻塞等待，
- * 进入挂起态——输入放开（Enter = 新回合 / digest 中 Enter 排队 pendingInput）、
- * settle 事件驱动 auto-turn 消化（手动档 organize-only / AUTO 档全语义）、池空 + 无
- * 待处理输入 → 补发 done 冻结自然退出。状态机行表见 AGENT-LOOP.md §17 D-S9。
+ * §17（2026-09-02，AGENT-LOOP.md §9 D-S1..S9）：回合尾后台池非空 → 不阻塞等待，
+ * 进入挂起态——挂起空闲输入开放（Enter = 新回合填单槽 + 唤醒）、busy（processing 含
+ * digest）输入禁用（INPUT-LOCK-ASYNC C'——提交吞——2026-09-09）、settle 事件驱动
+ * auto-turn 消化（手动档 organize-only / AUTO 档全语义）、池空 + 无待处理输入 → 补发
+ * done 冻结自然退出。状态机行表见 AGENT-LOOP.md §9.2。
  */
 
 // 函数级静态环（2026-09-05）：drive 的 digestTurn/用户回合经 runAgentTurn 递归进入
@@ -20,57 +21,13 @@ import { C } from "./ansi.mjs"
 // ASYNC-RESULT-CONTAINER.md D1/D2：池 accessor（双池 absorb）+ pending 单容器停靠
 import { getAsyncPool, parkAsyncPending } from "../agent-tools/async-settle.mjs"
 
-// ── §24 D-24c（R15——2026-09-06）排队用户指令合并常量：单批 ≤8 条且合并注入
-// ≤2000 字符（双端逐字一致——§22 D-Q3 常量先例）；超限截批先行（余下下批——不丢
-// 不截断单条）；单条 >2000 字符直发不进批；/cmd 不进合并（逐条保序即时）。──
-export const MAX_MERGE_ITEMS = 8
-export const MAX_MERGE_CHARS = 2000
-
-/** 合并注入形态（编号逐条——模型一次处理全部——设计措辞锚）。 */
-export function formatMergedMessages(items) {
-  return `你排队了 ${items.length} 条消息：\n${items.map((m, i) => `${i + 1}. ${m}`).join("\n")}\n——一次处理`
-}
-
-/**
- * R15 攒批计划（纯函数——消费点共享同一事实源）：按队列顺序产出动作序列。
- * - { kind:"slash", text, count:1 }——/cmd 逐条即时执行（保序——不进合并缓冲）；
- * - { kind:"turn", text, count, merged }——文本批次：连续非 / 条目攒批（单批 ≤8 条；
- *   合并注入（格式化后）≤2000 字符；count ≥2 → merged 编号注入；count === 1 → 原文
- *   直发（含单条 >2000 字符——不进批）；超限截批先行——余下条目留待下批（不丢）。
- * 消费者每次取动作 [0] 并按 count 从源队列移除——下轮重新计划余项（边界幂等）。
- */
-export function planQueuedInput(items) {
-  const actions = []
-  const n = items.length
-  let i = 0
-  while (i < n) {
-    const cur = String(items[i])
-    if (cur.startsWith("/")) { actions.push({ kind: "slash", text: cur, count: 1 }); i++; continue }
-    let j = i
-    for (;;) {
-      if (j - i >= MAX_MERGE_ITEMS || j >= n) break
-      const it = String(items[j])
-      if (it.startsWith("/")) break
-      if (it.length > MAX_MERGE_CHARS) break // 单条超长——不进批（留作直发）
-      const cand = items.slice(i, j + 1)
-      if (cand.length > 1 && formatMergedMessages(cand).length > MAX_MERGE_CHARS) break // 批总长超限——截批
-      j++
-    }
-    // 超长条目堵头（内环一步未进）→ 该条直发（不进批——也不与前后合并）
-    if (j === i) { actions.push({ kind: "turn", text: String(items[i]), count: 1, merged: false }); i++; continue }
-    const taken = items.slice(i, j)
-    if (taken.length === 1) {
-      actions.push({ kind: "turn", text: String(taken[0]), count: 1, merged: false })
-    } else {
-      actions.push({ kind: "turn", text: formatMergedMessages(taken), count: taken.length, merged: true })
-    }
-    i = j
-  }
-  return actions
-}
+// INPUT-LOCK-ASYNC（C'——2026-09-09，本档 INPUT-LOCK-ASYNC.md）：R15 排队
+// 用户指令合并（§11.3 D-24c——攒批计划/合并文案/上限常量）整批废弃
+// ——busy 提交吞 + pendingInput 单槽化（至多一条待交接——单消息逐发不攒批）。
+// 废弃记录见 AGENT-LOOP.md §11.3。
 
 /** 后台池计数（LOGGING susp/digest 事件字段——pendingN/poolN）。
- *  poolN = _asyncSubagents + _asyncAdvisors（§24 D-24b advisor 池同面板计数——queued
+ *  poolN = _asyncSubagents + _asyncAdvisors（§11.2 D-24b advisor 池同面板计数——queued
  *  条目同样在 map 内——2026-09-03 code review #2：不再 +queue.length 双计）。
  *  R17（§25 D-R17a/b）：pendingN = pending 单容器 `_pendingAsyncResults` 条数（
  *  ASYNC-RESULT-CONTAINER.md D2——四族统一停靠——digest 驱动判据同单容器）。 */
@@ -117,7 +74,7 @@ export function allPendingEntries(agent) {
 /** 后台池存活判据（D-S2/F5 口径）：running/queued 子代理或后台评审，或已 settle 未注入结果
  *  （pending 单容器非空 = D-S3 "未注入"），或 running consult 会话（会诊跨回合——
  *  §25 D-R17a 挂起活度钩子——consult 启动回合尾即入挂起态）。回合尾与每次轮末都用它
- *  评估退出。§24 D-24b：_asyncAdvisors（后台评审池）与子代理池同判——评审飞行中挂起
+ *  评估退出。§11.2 D-24b：_asyncAdvisors（后台评审池）与子代理池同判——评审飞行中挂起
  *  会话必须存活。 */
 export function poolLive(agent) {
   const map = agent._asyncSubagents
@@ -173,7 +130,7 @@ function waitForSettleOrWake(agent, state) {
 }
 
 /** 后台模式状态行文本（D-S8；17.5.4 #6 顺手对齐）："后台 N 子代理运行中 · M 完成待消化"
- *  ——"运行中" = running + queued（含后台评审——§24 D-24b 同面板计数）+ running consult
+ *  ——"运行中" = running + queued（含后台评审——§11.2 D-24b 同面板计数）+ running consult
  *  children（R17——会诊跨回合）；"完成待消化" = pending 任一族移交项 + §17.5 回合尾留池
  *  的 settled 未消费项（挂起会话 sweep 前的可见窗口）。 */
 function backgroundStatusText(agent) {
@@ -217,7 +174,8 @@ async function digestTurn(ctx) {
 /**
  * §17 挂起会话驱动（D-S9 行表；由 runAgentTurn 回合尾进入，池空自然退出）：
  * - suspension：池项 settle → 入 pending → 开 auto-turn（合并消化近邻 settle）；
- *   用户 Enter → pendingInput（digest 运行中排队，D-S5）——用户输入优先于 digest；
+ *   挂起空闲用户 Enter → pendingInput 单槽（busy 含 digest 提交吞——INPUT-LOCK-ASYNC）
+ *   ——用户输入优先于 digest；
  * - auto-turn：消化中 settle 不并发开新轮（单 runAgent 循环），轮末按 pending/池态
  *   续开合并消化轮或回挂起；pendingInput 非空 → 以该消息开新回合（不触发新 digest）；
  * - §17.5.5：每次消化/会话内用户回合消费 pending 后 → freezeReclaimDigestedBlocks
@@ -250,25 +208,14 @@ export async function suspensionSession(ctx) {
   try {
     while (!state._suspAborted && !agent._sessionAbort.signal.aborted) {
       sweepSettledToPending(agent)
-      // 1. 用户输入优先（D-S5）：pendingInput（digest 期排队）→ queue（处理期排队）。
-      //    §24 D-24c（R15）：空闲消费攒批合并——同源连续文本合成单条注入（编号逐条
-      //    ——单批 ≤8 条 / ≤2000 字符；单条超长直发不进批；余下留待下批——不丢）；
-      //    /cmd 不进合并——逐条保序即时（位置 = 源内队列序）。每次取计划动作 [0]——
-      //    单回合消费后回环续取（新到消息自然并进下一回合——不设延迟窗口）。
-      const fromPending = state.pendingInput.length > 0
-      const srcLen = fromPending ? state.pendingInput.length : state.queue.length
-      if (srcLen > 0) {
-        const src = fromPending ? state.pendingInput : state.queue.map((q) => q.text)
-        const head = planQueuedInput(src)[0]
-        if (fromPending) state.pendingInput.splice(0, head.count)
-        else state.queue.splice(0, head.count)
-        if (head.kind === "slash") {
-          await ctx.handleSlash?.(head.text)
-          render()
-          continue
-        }
+      // 1. 用户输入优先（D-S5）：pendingInput 单槽（INPUT-LOCK-ASYNC C'——busy（processing
+      //    含 digest）提交吞——Enter 只可能落在挂起空闲/释放窗口——至多一条待交接——driver
+      //    消费清槽即开新回合）。R15 攒批/queue 双源已随排队机制废弃收敛（2026-09-09——
+      //    单消息交接——无合并无 /cmd 分流——key-handler 只收非斜杠文本——单消息逐发）。
+      if ((state.pendingInput?.length ?? 0) > 0) {
+        const head = String(state.pendingInput.shift())
         agent._suspended = false // 用户回合 = 普通回合语义（① 直注入 + settle 即冻结）
-        await runAgentTurn(ctx, head.text, { skipSession: true })
+        await runAgentTurn(ctx, head, { skipSession: true })
         agent._suspended = true
         // §17.5.5：该回合消化完 pending（run 首行注入）→ 逐条冻结回收驻留块
         // （不等池空——settle 锚点 splice——digest 总览文本之前；与 digest 回收同规则）
@@ -319,14 +266,13 @@ export async function suspensionSession(ctx) {
       agent._pendingAsyncResults = []
       const { cleanupConsultSessions } = await import("../agent-tools/consult.mjs")
       cleanupConsultSessions(agent)
-      // §17 round2 偏差 #2-CLI（code review round2 #2-CLI）：中止时不静默丢弃挂起期
-      // 排队的用户消息——Enter 已清空输入框并入 pendingInput（用户视为已发送），
-      // 残余转回 state.queue（{text} 条目，下个普通回合的队列循环续发——零丢失）
-      // + 提示行明示去向（不静默丢）。
-      const queuedN = state.pendingInput?.length ?? 0
-      if (queuedN > 0) {
-        state.queue.push(...state.pendingInput.splice(0).map((t) => ({ text: String(t) })))
-        pushLine(`[background work stopped — ${queuedN} queued message${queuedN > 1 ? "s" : ""} will run as a normal turn]`, C.warn)
+      // §17 round2 偏差 #2-CLI（code review round2 #2-CLI）+ INPUT-LOCK 单槽化：中止时
+      // 不静默丢弃挂起期输入——Enter 已清空输入框并入 pendingInput（用户视为已发送）——
+      // 单槽语义下残余至多一条——转回 state.queue（{text} 单条目，下个普通回合的队列
+      // 循环续发——零丢失）+ 提示行明示去向（不静默丢）。
+      if ((state.pendingInput?.length ?? 0) > 0) {
+        state.queue.push({ text: String(state.pendingInput.shift()) })
+        pushLine(`[background work stopped — the message you entered will run as a normal turn]`, C.warn)
       }
     } else {
       // D-S3 ③ 兜底：退出前残余（极端竞态）直注入再退——结果零丢失（AC-S2；