thincoder 0.12.54 → 0.12.59

package/src/tui/subagent-panel.mjs

@@ -6,7 +6,13 @@
  * 运行中区块的渲染行数（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——不触发折叠翻转）。
+ * §19.5 D-M8：本模块同时承载子标行 dim 样式（styleSubLabelRow——面板与冻结渲染共用）。
  *
  * 中立模块（D1 评审 #6）：layout.mjs 调 renderSubagentPanel 预计算面板高度
  * （subagentLines → subagentH），render-frame.mjs 直接 put 预计算行（不重复
@@ -19,9 +25,30 @@
  * 折叠状态 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"
+
+/** 子标行行首标记（`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 /
@@ -30,7 +57,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 +68,25 @@ 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 角色豁免）；
+    // 冻结后保留（与 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)
+    // §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,23 +96,54 @@ 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)) {
+      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)
+      // §19.5 D-M8：时间线行过 styleSubLabelRow——行首子标 dim、内容恢复 kind 色。
+      const body = renderBlockTimeline(sub.blocks, cols).map(styleSubLabelRow)
       out.push(...renderExpandedBlock({ body, foldKey, state, maxRows, cols, label: "subagent activity" }))
     } else {
       // 折叠态：tail 3 非空 block 行（最近活动），dim。

package/src/tui/tool-args.mjs

@@ -48,8 +48,16 @@ export function describeToolArgs(name, args) {
     case "advisor": return String(a.type ?? "review")
     case "read_image": return String(a.path ?? "")
     case "question": return String(a.question ?? "").replace(/\s+/g, " ").trim().slice(0, 60)
-    case "memory_put": return String(a.title ?? "")
-    case "memory_search": return String(a.query ?? "")
+    case "memory": {
+      // §6 action-routed summary (D-M5): one readable line per action
+      const action = String(a.action ?? "")
+      if (action === "put") return String(a.title ?? "")
+      if (action === "search") return String(a.query ?? "")
+      if (action === "list") return [a.scope && `scope ${a.scope}`, a.type && `type ${a.type}`, a.keyword && `kw ${a.keyword}`].filter(Boolean).join(" ")
+      if (action === "delete") return a.id ? `id ${a.id} (${a.scope ?? ""})` : `batch ${a.scope ?? ""} ${a.type ? `type ${a.type} ` : ""}${a.keyword ? `kw ${a.keyword}` : ""}`.trim()
+      if (action === "clear") return `clear ${a.scope ?? ""}`
+      return action || JSON.stringify(a)
+    }
     case "lsp": return [a.subcommand, a.uri].filter(Boolean).map(String).join(" ")
     case "repo_outline": return a.path ? String(a.path) : ""
     case "checkpoint": return [a.checkpointAction ?? a.action, a.checkpointId, a.path].filter(Boolean).map(String).join(" ")

package/src/tui/tool-events.mjs

@@ -3,22 +3,25 @@
  * 满足 500 行硬限）。只做「事件 → TUI 状态/对话行」的映射：
  *
  *  - onToken/onReasoning  : 子agent 前缀分流（routeSub*）→ 主流 streaming/reasoning
- *  - onToolCall           : 状态栏 + `❯ name args` 标题行 + 计时
+ *  - onToolCall           : 状态栏 + `❯ name args` 标题行 + 计时 + §19 action 记录
  *  - onToolResult         : 子agent 完成冻结（finishSubTask + freezeDoneSubTasks）、
- *                           _live 行清理、done 行、advisor 评审冻结框
- *  - onToolOutput         : advisor 有序块缓冲 / `_live` 滚动预览（N 行 + `│ …` 折叠）
+ *                           工具块结果入块、advisor 评审冻结框
+ *  - onToolOutput         : advisor 有序块缓冲 / 工具块输出流
  *  - 其余                 : usage 累计、等待提示、task 面板、回合末增量落盘
  *
  * flushStream 同时返回给调用方（回合循环 / onTurnEnd 共用）。纯回调装配，无终端副作用
- * （除经 deps 注入的 pushLine/render）。
+ * （除经 deps 注入的 pushLine/render）。§19: subagent_check/escalate 工具退役后，
+ * subagent 家族全部调用以工具名 "subagent" + action 到达——完成路由按 onToolCall 时
+ * 记录的 action 分流（spawn 区块 / escalate 区块 / check·status 普通工具块）。
  */
 import { C } from "./ansi.mjs"
 import { formatToolSummary } from "./tool-summaries.mjs"
 import { describeToolArgs, toolArgsLines } from "./tool-args.mjs"
 import { ADVISOR_THINKING_PLACEHOLDER, resolveAdvisorProvider } from "../advisor/run.mjs"
 import {
-  SUBAGENT_ROLES, routeSubToken, routeSubReasoning, routeSubToolCall,
-  routeSubToolOutput, finishSubTask, finishSubTasksByRole, finishSubTaskByModel, freezeDoneSubTasks,
+  SUB_PREFIX_RE, SUBAGENT_ROLES, routeSubToken, routeSubReasoning, routeSubToolCall,
+  routeSubToolOutput, finishSubTask, finishSubTaskKey, finishSubTasksByRole, finishSubTaskByModel, freezeDoneSubTasks,
+  ensureCompressPanel, markCompressFailed, markCompressDone, markCompressFallback,
 } from "./subagent-blocks.mjs"
 import { TURN_CAP_MARK } from "../agent/spawn-child.mjs"
 
@@ -37,6 +40,11 @@ const REMINDER_CAP = 3                    // max pending reminders shown on turn
 const REMINDER_PERSIST_TURNS = 5          // persist reminders every N turns
 
 const _toolTicks = new Map()
+// §19 action registry: tool_call id → subagent action (non-spawn only — spawn is
+// the default when no record exists). onToolCall sees the args, onToolResult only
+// the name; without the record every subagent result would route as a spawn.
+const _subActions = new Map()
+const _subActionQ = [] // FIFO for subagent calls without a tool id (same fallback as tick queue)
 
 function tickStart(name, toolId) {
   const key = toolId ?? name
@@ -73,6 +81,8 @@ export function sweepToolBlocks(state) {
     }
   }
   _toolTicks.clear()
+  _subActions.clear()
+  _subActionQ.length = 0
 }
 
 /** Shared display guard for tool results — LIVE and RESTORE use the same
@@ -93,9 +103,8 @@ export function slimToolResultForDisplay(result, maxRows = 400) {
     : rows
 }
 /** Mark the dispatch-level tool carrier done when its result is consumed by a
- *  dedicated branch (subagent/escalate/advisor blocks) instead of the carrier
- *  body — without this the turn sweep mislabels successful calls as
- *  "(interrupted)" (consult P1, 2026-08-30). */
+ *  dedicated branch (subagent/escalate/advisor blocks) — without this the turn
+ *  sweep mislabels successful calls as "(interrupted)" (consult P1, 2026-08-30). */
 function settleToolBlock(state, name, toolId, summary) {
   const block = findToolBlock(state, name, toolId)
   if (block) {
@@ -106,6 +115,32 @@ function settleToolBlock(state, name, toolId, summary) {
   }
 }
 
+/** Async spawn detection (§15 D-A1): the subagent tool's async:true result is a
+ *  status JSON ({id, role, status: running|queued}), NOT a report — the child
+ *  keeps running, so its activity block must not be frozen at spawn time (it
+ *  freezes via the ⟦ev⟧done event at settle — §15 D-A3). */
+function isAsyncSpawnResult(result) {
+  try {
+    const o = JSON.parse(result)
+    return Boolean(o && typeof o === "object" && typeof o.id !== "undefined" && (o.status === "running" || o.status === "queued"))
+  } catch {
+    return false
+  }
+}
+
+/** §7.2.3 spawn 门拒错误探测（T-F5）：subagent spawn 的机械拒绝以 {status:"error"}
+ *  JSON 返回（例：manual auto-turn digest spawn 门——digest 语义 organize-only）——
+ *  错误路径不得触发完成冻结（round1 #1——错误路径不冻结任何 running 块）。该形态只
+ *  出现在无 subKey 的拒绝路径（成功路径恒带 dispatch 传的 ctx._subagentKey）。 */
+function isSpawnErrorResult(result) {
+  try {
+    const o = JSON.parse(result)
+    return Boolean(o && typeof o === "object" && o.status === "error")
+  } catch {
+    return false
+  }
+}
+
 
 
 /** Find the live tool-block carrier for a tool event: exact id match when the
@@ -130,8 +165,7 @@ function findToolBlock(state, name, toolId) {
 /** Build the agent callbacks + the shared flushStream for one turn.
  *          askPermission, askQuestion, saveSessionImpl } */
 export function buildToolCallbacks(deps) {
-  const { agent, state, pushLine, render, scheduleRender, ensureAssistantLabel, askPermission, askQuestion, saveSessionImpl } = deps
-
+  const { agent, state, pushLine, render, scheduleRender, ensureAssistantLabel, askPermission, askBatchPermission, askQuestion, saveSessionImpl } = deps
   // NOTE: advisor buffers (_advisorThink/advisorStreaming) are cleared here too.
   // Timing safety: onToolResult flushes _advisorThink into history and empties
   // the buffers BEFORE onTurnEnd can call flushStream (tool result is
@@ -141,11 +175,8 @@ export function buildToolCallbacks(deps) {
   const flushStream = () => {
     if (state.reasoning) {
       pushLine(state.reasoning, C.reason, "thinking")
-      // Reasoning folds IMMEDIATELY on flush (user ruling 2026-08-30: the old
-      // "stay expanded until next turn" auto-expand was a leftover of the
-      // rejected pre-fold plan — thinking must be DEFAULT FOLDED in the exact
-      // unified form: named header + tail 3, expand ≤60%, click back). Same
-      // shape as the restore path — zero exceptions on either path.
+      // Reasoning folds IMMEDIATELY on flush (user ruling 2026-08-30): default-folded,
+      // named header + tail 3 — same shape as the restore path, zero exceptions.
       state.reasoning = ""
     }
     if (state.streaming) {
@@ -166,9 +197,8 @@ export function buildToolCallbacks(deps) {
       scheduleRender()
     },
     onReasoning: (t) => {
-      // Subagent reasoning tokens also carry role#id/ prefix — appended into the
-      // block buffer as kind=think (F2: same treatment as the main reasoning stream;
-      // previously the token only created the entry and the content was discarded).
+      // Subagent reasoning tokens also carry role#id/ prefix — appended into the block
+      // buffer as kind=think (F2: same treatment as the main reasoning stream).
       if (routeSubReasoning(state, t, scheduleRender)) return
       ensureAssistantLabel()
       state.reasoning += t
@@ -178,9 +208,14 @@ export function buildToolCallbacks(deps) {
       // Subagent tool call: prefix role#id/toolName → open a fresh tool block and
       // set currentTool for the header summary line.
       if (routeSubToolCall(state, name, args, scheduleRender)) return
-      // Redundant with flushStream() below (it clears both buffers) — kept as
-      // defense-in-depth so a future flushStream change cannot leak advisor
-      // buffers into the next tool's view.
+      // §19: record the action of a merged subagent-family call (spawn is the
+      // default — only non-spawn actions need a record for result-time routing).
+      if (name === "subagent" && args?.action && args.action !== "spawn") {
+        if (toolId !== undefined && toolId !== null) _subActions.set(toolId, args.action)
+        else _subActionQ.push(args.action)
+      }
+      // Redundant with flushStream() below (it clears both buffers) — defense-in-depth
+      // so a future flushStream change cannot leak advisor buffers into the next view.
       if (name === "advisor") { state._advisorBlocks = [] }
       flushStream()
       ensureAssistantLabel()
@@ -208,17 +243,12 @@ export function buildToolCallbacks(deps) {
       // is unreliable (it glues onto the previous line), so the round belongs here.
       // Also show the advisor's effective model (it may differ from the main agent's).
       const roundTag = name === "advisor" ? ` (round ${(agent._advisorRound || 0) + 1}${advModel ? " · " + advModel : ""})` : ""
-      // Readable key-args summary (vscode card-header parity, 2026-08-30) —
-      // replaces the raw JSON.stringify-80 slice: long paths landed mid-string,
-      // and the crucial argument was often past the cut. Unknown/MCP tools
-      // fall back to compact JSON inside describeToolArgs.
+      // Readable key-args summary (vscode card-header parity, 2026-08-30) — replaces
+      // the raw JSON.stringify-80 slice. Unknown/MCP tools fall back to compact JSON.
       const argSummary = describeToolArgs(name, args)
-      // ONE BLOCK PER TOOL CALL (user ruling 2026-08-30: "为什么不把名称和参数行
-      // 直接作为流式输出 block 的 title" — the four-piece ❯ title / _live scroll /
-      // done-line arrangement was pre-fold-era residue). The carrier line holds
-      // the whole call: header = name+args+live status, body = args JSON +
-      // streaming output + result. buildConvLines renders it via the shared
-      // fold-block component; restore (historyToLines) emits the SAME carrier.
+      // ONE BLOCK PER TOOL CALL (user ruling 2026-08-30): header = name+args+live
+      // status, body = args JSON + streaming output + result. buildConvLines renders
+      // it via the shared fold-block component; restore emits the SAME carrier.
       state.lines.push({
         text: "", color: C.tool,
         _lineId: (state._lineIdCounter = (state._lineIdCounter ?? 0) + 1),
@@ -235,47 +265,78 @@ export function buildToolCallbacks(deps) {
       })
       tickStart(name, toolId)
     },
-    onToolResult: (name, result, toolId) => {
+    // §7.2.3（方案 e）：dispatch runOne 把工具 ctx 上的 _subagentKey（sync spawn/
+    // escalate 成功路径设置——relayPrefix 去尾）作为第 4 参传来——undefined 兼容既有
+    // 签名（普通工具/老回调/错误路径不带 key）。
+    onToolResult: (name, result, toolId, subKey) => {
       state.currentTool = null
+      // §19 merged family: route per the action recorded at onToolCall (no record = default spawn).
+      let subAction = null
+      if (name === "subagent") {
+        subAction = (toolId !== undefined && toolId !== null)
+          ? _subActions.get(toolId) ?? null
+          : _subActionQ.shift() ?? null
+        if (toolId !== undefined && toolId !== null) _subActions.delete(toolId)
+      }
+      const isSubagent = name === "subagent" && subAction !== "check" && subAction !== "status" && subAction !== "escalate" && subAction !== "cancel" && subAction !== "panel"
+      const isEscalate = name === "subagent" && subAction === "escalate"
       // Subagent complete: mark the earliest running child as done — the block
       // persists (✓ frozen elapsed header, expandable) as the ONLY carrier of the
-      // child's activity (D4: no 3-second cleanup anymore). The report preview
-      // (max 8 lines) still enters the conversation via the existing path below.
-      // Block buffers survive the turn (no wipe in runAgentTurn start/finally):
-      // child tool calls never enter the parent's history, so the block is the
-      // only trace of what the child did — memory bounded by the N2 line cap.
-      const isSubagent = name === "subagent"
+      // child's activity; memory bounded by the N2 line cap.
+      // §19.5: cancel 动作排除在 isSubagent 外——ack/错误 JSON 走普通工具块；区块冻结由
+      // ⟦ev⟧stopped settle 事件承担（此处 finishSubTask 会误冻最早 running 区块）。
       if (isSubagent) {
         // The dispatch-level tool-block carrier for this call would otherwise
         // never be marked done (its result lands in the subagent block, not the
-        // carrier) and the turn sweep would mislabel it "(interrupted)" — every
-        // successful subagent call showed that banner (consult P1, 2026-08-30).
+        // carrier) and the turn sweep would mislabel it "(interrupted)".
         settleToolBlock(state, name, toolId, "completed")
-        finishSubTask(state, SUBAGENT_ROLES, result.includes(TURN_CAP_MARK) ? "turn cap reached — work may be partial" : null)
-        // Freeze the finished blocks into the conversation stream (user report
-        // 2026-08-30): a pinned tail section left every ✓ block stuck above the
-        // input box forever. As lines they scroll away, stay expandable via the
-        // dim auto-fold, and subTasks releases the entry.
-        freezeDoneSubTasks(state)
-        // Subagent report preview (max 8 lines) displayed directly in conversation
-        const lines = result.split("\n")
-        const preview = lines.slice(0, SUBAGENT_PREVIEW_LINES).map((l) => l.slice(0, PREVIEW_LINE_CHARS)).join("\n")
-        if (preview) pushLine(preview, C.dim)
-        if (lines.length > SUBAGENT_PREVIEW_LINES) pushLine(`  ... (${lines.length - SUBAGENT_PREVIEW_LINES} more lines)`, C.dim)
-      } else if (name === "escalate") {
-        // 飞刀 post-op report landed → freeze its block into the conversation too.
+        // Async spawn (§15 D-A1): the result is a status JSON, not a report — the
+        // child KEEPS running; skip the freeze (it would tombstone a live block and
+        // drop its relay stream). The block freezes on the ⟦ev⟧done settle event.
+        if (!isAsyncSpawnResult(result)) {
+          // §7.2.3 sync spawn 完成精确冻结：结果按 key 归属三支——
+          // ① dispatch 同步成功路径带 subKey（ctx._subagentKey = relayPrefix 去尾）：
+          //    finishSubTaskKey 按 key 精确冻——不再落 finishSubTask 的"最早 started"
+          //    启发式（async eng-coder 先启动时 explore 完成会误冻其块——7.2.3.1/T-F2）；
+          // ② spawn 门拒错误（{status:"error"} JSON——auto-turn digest spawn 拒绝）：
+          //    不冻结任何块（round1 #1——错误路径不冻结 running 块——T-F5）；
+          // ③ subKey undefined 非错误（老回调/测试直调——成功路径未知工具）→ 启发式
+          //    兜底（既有行为不变——面板单块时与精确冻同效——T-F1）。
+          const lastError = result.includes(TURN_CAP_MARK) ? "turn cap reached — work may be partial" : null
+          const hasSubKey = subKey !== undefined && subKey !== null && subKey !== ""
+          if (hasSubKey) {
+            finishSubTaskKey(state, String(subKey), lastError)
+            freezeDoneSubTasks(state)
+          } else if (!isSpawnErrorResult(result)) {
+            finishSubTask(state, SUBAGENT_ROLES, lastError)
+            freezeDoneSubTasks(state)
+          }
+          // Subagent report preview (max 8 lines) displayed directly in conversation
+          const lines = result.split("\n")
+          const preview = lines.slice(0, SUBAGENT_PREVIEW_LINES).map((l) => l.slice(0, PREVIEW_LINE_CHARS)).join("\n")
+          if (preview) pushLine(preview, C.dim)
+          if (lines.length > SUBAGENT_PREVIEW_LINES) pushLine(`  ... (${lines.length - SUBAGENT_PREVIEW_LINES} more lines)`, C.dim)
+        }
+      } else if (isEscalate) {
+        // 飞刀 post-op report landed under the subagent tool name — freeze the
+        // escalate#N activity block (no preview; legacy surface).
         settleToolBlock(state, name, toolId, "completed")
-        finishSubTask(state, ["escalate"], result.includes(TURN_CAP_MARK) ? "turn cap reached — work may be partial" : null)
+        // §7.2.3（round1 #2）：escalate 成功返回带 subKey（escalate#N）→ 精确冻；
+        // 失败/老回调无 subKey → escalate 角色启发式兜底（escalate 串行 + 角色限定——
+        // 既有行为）。
+        const lastError = result.includes(TURN_CAP_MARK) ? "turn cap reached — work may be partial" : null
+        if (subKey !== undefined && subKey !== null && subKey !== "") {
+          finishSubTaskKey(state, String(subKey), lastError)
+        } else {
+          finishSubTask(state, ["escalate"], lastError)
+        }
         freezeDoneSubTasks(state)
       } else if (name === "consult_check" || name === "consult_stop") {
-        // Consult session-level settle (2026-08-30 consult review): a session
-        // spawns N parallel children, so completion must settle ALL of them.
-        // The single-shot finishSubTask here only froze the EARLIEST running
-        // block — the other N-1 stayed "running" pinned above the input box
-        // all through the final answer, then got mislabeled "interrupted".
-        //   - individual reply (done:false): settle precisely by r.model —
-        //     models settle out of order; the earliest-running heuristic froze
-        //     the wrong block.
+        // Consult session-level settle (2026-08-30 consult review): a session spawns
+        // N parallel children, so completion must settle ALL of them (single-shot
+        // finishSubTask froze only the earliest — N-1 stayed "running" then got
+        // mislabeled "interrupted").
+        //   - individual reply (done:false): settle precisely by r.model.
         //   - done:true / stopped: settle every remaining consult block.
         try {
           const r = JSON.parse(result)
@@ -293,7 +354,7 @@ export function buildToolCallbacks(deps) {
           }
         } /* non-JSON result — leave blocks as-is */
       }
-      if (!isSubagent && name !== "advisor") {
+      if (!isSubagent && !isEscalate && name !== "advisor") {
         // Result lands INSIDE the block (restore parity — the restored carrier
         // carries the same fields). The done line is gone: status/elapsed live
         // in the header now.
@@ -316,16 +377,11 @@ export function buildToolCallbacks(deps) {
         // the frozen box, but the dispatch-level tool carrier must still be
         // marked done (consult P1, 2026-08-30: sweep mislabeled it interrupted).
         settleToolBlock(state, name, toolId, "completed")
-        // The review's thinking must survive into the conversation history like
-        // the main agent's reasoning (flushStream does for state.reasoning) —
-        // discarding it left the thought process visible only mid-review, then
-        // gone. Flush BEFORE the done line so the block sits above it.
-        // 2026-08-30: flushed as a COLLAPSIBLE box (frozen-folded semantics,
-        // aligned with subagent blocks) instead of a flat auto-expanded line —
-        // the flat form flooded the conversation. Full text still lives in the
-        // tool result message; the box is the reviewable record. Live
-        // _advisorBlocks keep rendering the running view until cleared in the
-        // turn finally.
+        // The review's thinking must survive into the conversation history like the
+        // main agent's reasoning — flushed as a COLLAPSIBLE box before the done
+        // line (frozen-folded semantics, aligned with subagent blocks; the flat
+        // form flooded the conversation). Full text lives in the tool result;
+        // _advisorBlocks keep rendering the running view until cleared at turn end.
         const blocks = state._advisorBlocks ?? []
         if (blocks.length > 0) {
           const text = blocks
@@ -347,17 +403,17 @@ export function buildToolCallbacks(deps) {
       }
     },
     onToolOutput: (name, chunk, toolId) => {
-      // All tools use inline conversation blocks — panel area is abolished.
-      // Stream up to N preview lines (config ?? per-tool ?? 5); the full result
-      // is in the tool message.
-      const part = typeof chunk === "string"
-        ? { kind: "text", text: chunk.trimEnd() }
-        : { kind: chunk?.kind ?? "text", text: String(chunk?.text ?? "").trimEnd() }
+      // Subagent relays (name "role#id/tool", D1) route RAW — chunks are
+      // child-stdout/SSE fragments at arbitrary byte boundaries; trimEnd eats
+      // real trailing newlines and routeSubToolOutput's verbatim concat would
+      // glue lines (2026-09-03 修复轮; main path keeps the trimmed form below).
+      const isSubRelay = SUB_PREFIX_RE.test(name)
+      const rawText = typeof chunk === "string" ? chunk : String(chunk?.text ?? "")
+      const part = {
+        kind: typeof chunk === "string" ? "text" : (chunk?.kind ?? "text"),
+        text: isSubRelay ? rawText : rawText.trimEnd(),
+      }
       if (!part.text) return
-      // Subagent tool output (D1: childCallbacks.onToolOutput relays under the
-      // prefixed name "role#id/toolName") → append into the CURRENT tool block of
-      // that child's activity buffer. Render throttled at 250ms (N1); the data
-      // append itself is never delayed.
       if (routeSubToolOutput(state, name, part, scheduleRender)) return
       if (name === "advisor") {
         // Accumulate to buffer — formatTables + wrapText in render-conversation
@@ -365,13 +421,9 @@ export function buildToolCallbacks(deps) {
         // NOTE: the advisor tool ALWAYS emits {kind, text} objects (run.mjs's
         // emit() wrapper) — a raw string chunk is never think; if that ever
         // changes, plain-string think would land in advisorStreaming.
-        // ORDERED block buffer — preserves the interleaved emission order
-        // (think → tool → think → … → final). Two separate buffers (_advisorThink
-        // vs advisorStreaming) rendered think-block-then-main-block, which
-        // regrouped ALL thinking above ALL tool progress — the alternating
-        // timeline was destroyed. Consecutive chunks of the same kind merge
-        // into one block; kind flips start a new block; render walks the
-        // blocks in order with per-kind colors.
+        // ORDERED block buffer — preserves the interleaved emission order (think →
+        // tool → think → … → final); consecutive chunks of the same kind merge
+        // into one block, kind flips start a new block, render walks them in order.
         const isString = typeof chunk === "string"
         const raw = isString ? chunk : String(chunk?.text ?? "")
         const kind = isString ? "text" : (chunk?.kind ?? "text")
@@ -397,10 +449,35 @@ export function buildToolCallbacks(deps) {
       }
       scheduleRender()
     },
-    onPermissionRequest: (name, args) => askPermission(name, args),
-    onQuestion: (text, options) => askQuestion(text, options),
-    onCompress: () => {
-      pushLine("  [context] Context too long, auto-compacted (early conversation summarized by LLM, task state preserved)", C.warn)
+    // Manual-tier auto-turn digests (agent-turn.mjs suspension driver) pass null
+    // handlers — permission requests then deny WITHOUT a panel (§17 D-S7: no modal
+    // during unattended digestion) and question errors out instead of hanging.
+    ...(askPermission ? { onPermissionRequest: (name, args) => askPermission(name, args) } : {}),
+    // Merged batch ask (§16 D-B1): one confirmation for N non-readonly tools in
+    // the same response — "approve all / one by one / deny" (key-handler resolves
+    // the verdict string; approveAll is batch-scope only, never the AUTO flag).
+    ...(askBatchPermission ? { onBatchPermissionRequest: (req) => askBatchPermission(req) } : {}),
+    ...(askQuestion ? { onQuestion: (text, options) => askQuestion(text, options) } : {}),
+    // Compression lifecycle (CONTEXT-COMPACTION.md §7 D-C2): the compression session
+    // renders as a subagent-style panel block — start → running panel ("Compressing
+    // context…" + "summarizing N messages" + elapsed ticker), fail → error text only,
+    // success → frozen "Compressed: N tokens freed → summary (Xs)" / fallback →
+    // "truncated to N messages". The summary BODY never enters the panel or stream.
+    onCompressStart: (info) => {
+      ensureCompressPanel(state, info)
+      scheduleRender()
+    },
+    onCompressFail: (error) => {
+      // Q3 (CONTEXT-COMPACTION §7 F3): failure is no longer silent — visible on the panel AND
+      // logged to stderr so the error is traceable (400/timeout/network).
+      console.error("[context] compression failed:", error?.message ?? error)
+      markCompressFailed(state, error)
+      scheduleRender()
+    },
+    onCompress: (info) => {
+      if (info?.mode === "fallback") markCompressFallback(state, info)
+      else markCompressDone(state, info)
+      scheduleRender()
     },
     // Async distillation landed (SEND-STALL-DISTILL §2.3): the machine line was replaced by
     // the compressed version — persist it so the session file ends up compressed. Silent: