thincoder 0.12.60 → 0.12.62

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 递归进入
@@ -18,59 +19,15 @@ import { sweepToolBlocks } from "./tool-events.mjs"
 import { logEvent } from "../log.mjs"
 import { C } from "./ansi.mjs"
 // ASYNC-RESULT-CONTAINER.md D1/D2：池 accessor（双池 absorb）+ pending 单容器停靠
-import { getAsyncPool, parkAsyncPending } from "../agent-tools/async-settle.mjs"
+import { getAsyncPool, parkAsyncPending, releaseSettledEntry } 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；
@@ -339,6 +285,8 @@ export async function suspensionSession(ctx) {
         for (const e of residual.splice(0)) {
           if (e.role === "consult") await injectConsultResult(agent, e)
           else await injectAsyncResult(agent, e)
+          // TUI-OOM-ROOTCAUSE（§23.3.1 消费点③——挂起残差注入）：注入完成 → 释放条目持有
+          releaseSettledEntry(e)
         }
       }
     }

package/src/tui/tool-args.mjs

@@ -12,6 +12,7 @@
  * 全量必须落行）。
  */
 import { sliceByWidth } from "./render.mjs"
+import { capLines, ARGS_JSON_MAX_CHARS } from "./display-budget.mjs"
 
 /** 单行参数摘要：按工具挑关键字段（vscode 卡片头对齐），未知工具回退 JSON。 */
 export function describeToolArgs(name, args) {
@@ -41,9 +42,11 @@ export function describeToolArgs(name, args) {
       return a.filter ? `${p}  (filter: ${String(a.filter)})` : p
     }
     case "websearch": return String(a.query ?? "")
-    case "subagent": case "coder": case "explore": case "plan": case "eng-coder": {
+    case "subagent": case "coder": case "explore": case "plan": case "eng-coder": case "eng-designer": {
       const task = String(a.task ?? "").replace(/\s+/g, " ").trim()
-      return task ? task.slice(0, 60) + (task.length > 60 ? "…" : "") : ""
+      if (task) return task.slice(0, 60) + (task.length > 60 ? "…" : "")
+      // action-only 调用（status/observe/send/cancel/escalate/consume-design…）无 task——action 兜底（2.4 批）
+      return a.action ? `(${String(a.action)})` : ""
     }
     case "advisor": return String(a.type ?? "review")
     case "read_image": return String(a.path ?? "")
@@ -72,8 +75,10 @@ export function describeToolArgs(name, args) {
 }
 
 /** 恢复路径用：全量参数 pretty JSON 的 dim 行（非空才输出）。
- *  与工具结果的恢复惯例一致——完整落行，超长由连续 dim 折叠收纳。 */
+ *  与工具结果的恢复惯例一致——完整落行；**总量额度**（TUI-OOM-ROOTCAUSE §15.3.1
+ *  ARGS_JSON_MAX_CHARS——`write`/`apply_patch` 整文件内容进显示层的堵口）：超出尾截断
+ *  + 标记，首行保真。 */
 export function toolArgsLines(args) {
   if (!args || typeof args !== "object" || Object.keys(args).length === 0) return []
-  return JSON.stringify(args, null, 2).split("\n")
+  return capLines(JSON.stringify(args, null, 2).split("\n"), ARGS_JSON_MAX_CHARS)
 }

package/src/tui/tool-display.mjs

@@ -7,6 +7,9 @@
  * 不禁内容变更（.set/.delete/.push），调用方行为与同模块时代一致。
  */
 
+// TUI-OOM-ROOTCAUSE（TUI.md §15.3.1）：显示层额度常量/工具行定位（display-budget 叶子）。
+import { capLines, TOOL_RESULT_MAX_CHARS } from "./display-budget.mjs"
+
 // Tool execution start timestamps (performance.now ms). Keyed by tool_call id
 // when available (parallel same-name tools each get their own tick — the
 // P0-3 fix, 2026-08-30), falling back to a per-name FIFO queue for callers
@@ -14,10 +17,11 @@
 // a parallel same-name batch finishing out of order swaps durations between
 // siblings — same magnitude, both keep an elapsed (display-level, acceptable).
 
-// Named caps (consult P2, 2026-08-30): inline 200/8/120/3/5 were magic numbers.
+// Named caps (consult P2, 2026-08-30): inline 200/3/5 were magic numbers.
+// CLI-ACTIVITY-DEBLOAT F-1 (2026-09-10): the report preview constants (former named caps)
+// deleted with the conversation-stream preview (tool-events onToolResult) — the
+// frozen block is the ONLY carrier of a child's report.
 export const TOOL_OUTPUT_LINE_CAP = 200     // per-call streaming output ring buffer
-export const SUBAGENT_PREVIEW_LINES = 8     // report preview rows in the conversation
-export const PREVIEW_LINE_CHARS = 120       // per-line preview slice
 export const REMINDER_CAP = 3               // max pending reminders shown on turn end
 export const REMINDER_PERSIST_TURNS = 5     // persist reminders every N turns
 
@@ -72,7 +76,9 @@ export function sweepToolBlocks(state) {
  *  1) Multimodal results (read_image) embed FULL base64 images in the JSON —
  *     the human needs only the text part (model gets images via the multimodal
  *     channel); 2) results beyond maxRows are truncated in the block (full
- *     text always lives in history for the model). Returns row array. */
+ *     text always lives in history for the model). Returns row array.
+ *  TUI-OOM-ROOTCAUSE（§15.3.1 TOOL_RESULT_MAX_CHARS）：总量额度与 400 行双维
+ *  （单行任意大——无 `\n` 巨 chunk/JSON 尾行），尾截断 + 标记。 */
 export function slimToolResultForDisplay(result, maxRows = 400) {
   let displayResult = result
   try {
@@ -80,9 +86,18 @@ export function slimToolResultForDisplay(result, maxRows = 400) {
     if (parsed?.images?.length) displayResult = parsed.text ?? result
   } catch { /* not JSON — show as-is */ }
   const rows = String(displayResult).split("\n").filter((l) => l.trim())
-  return rows.length > maxRows
+  const capped = rows.length > maxRows
     ? [...rows.slice(0, maxRows), `… (result truncated at ${maxRows} rows — full text in history)`]
     : rows
+  return capLines(capped, TOOL_RESULT_MAX_CHARS)
+}
+
+/** 按块定位其载体行（字符账 re-account 用——块对象唯一）。 */
+export function findToolLine(state, name, toolId) {
+  const block = findToolBlock(state, name, toolId)
+  if (!block) return null
+  for (const l of state.lines ?? []) if (l._toolBlock === block) return l
+  return null
 }
 /** Mark the dispatch-level tool carrier done when its result is consumed by a
  *  dedicated branch (subagent/escalate/advisor blocks) — without this the turn

package/src/tui/tool-events.mjs

@@ -4,7 +4,8 @@
  *
  *  - onToken/onReasoning  : 子agent 前缀分流（routeSub*）→ 主流 streaming/reasoning
  *  - onToolCall           : 状态栏 + `❯ name args` 标题行 + 计时 + §19 action 记录
- *  - onToolResult         : 子agent 完成冻结（finishSubTask + freezeDoneSubTasks）、
+ *  - onToolResult         : 子agent 完成冻结（finishSubTaskKey 精确冻 + freezeDoneSubTasks——
+ *                           F-2 后 finishSubTask 为 no-op 兼容保留）、
  *                           工具块结果入块、advisor 评审冻结框
  *  - onToolOutput         : advisor 有序块缓冲 / 工具块输出流
  *  - 其余                 : usage 累计、等待提示、task 面板、回合末增量落盘
@@ -20,25 +21,56 @@ import { formatToolSummary } from "./tool-summaries.mjs"
 import { describeToolArgs, toolArgsLines } from "./tool-args.mjs"
 import { ADVISOR_THINKING_PLACEHOLDER, resolveAdvisorProvider } from "../advisor/run.mjs"
 import {
-  SUB_PREFIX_RE, SUBAGENT_ROLES, routeSubToken, routeSubReasoning, routeSubToolCall,
+  SUBAGENT_ROLES, routeSubToken, routeSubReasoning, routeSubToolCall,
   routeSubToolOutput, finishSubTask, finishSubTaskKey, finishSubTasksByRole, freezeDoneSubTasks,
   ensureCompressPanel, markCompressFailed, markCompressDone, markCompressFallback,
+  shiftFreezeAnchors,
 } from "./subagent-blocks.mjs"
-import { TURN_CAP_MARK } from "../agent/spawn-child.mjs"
+// 第 27 批 §12.3②：前缀正则换名 + import 源改文法模块（纯换名——语义零改）。
+import { RELAY_PREFIX_RE } from "../agent/relay-prefix.mjs"
+import { TURN_CAP_MARK, STOPPED_MARK } from "../agent/spawn-child.mjs"
 // 2026-09-05 module-split：ticks/maps/sweep/slim/settle/探测/find 族迁 tool-display.mjs——
 // buildToolCallbacks 内部引用用本地 import；sweepToolBlocks re-export（agent-turn 消费面）
 import {
-  TOOL_OUTPUT_LINE_CAP, SUBAGENT_PREVIEW_LINES, PREVIEW_LINE_CHARS, REMINDER_CAP, REMINDER_PERSIST_TURNS,
+  TOOL_OUTPUT_LINE_CAP, REMINDER_CAP, REMINDER_PERSIST_TURNS,
   _toolTicks, _subActions, _subActionQ,
   tickStart, tickTake, settleToolBlock, isAsyncSpawnResult, isSpawnErrorResult,
-  findToolBlock, slimToolResultForDisplay, sweepToolBlocks,
+  findToolBlock, findToolLine, slimToolResultForDisplay, sweepToolBlocks,
 } from "./tool-display.mjs"
 export { sweepToolBlocks, slimToolResultForDisplay } from "./tool-display.mjs"
+// TUI-OOM-ROOTCAUSE（TUI.md §15.3.1/§15.3.3）：显示层额度（行/载体/输出环/评审/流式）。
+import {
+  capText, capLine, capLines, appendCapped, capAdvisorText, accountLine, syncLineBudget,
+  LINE_TRUNC_MARKER, MIDDLE_TRUNC_MARKER, ADVISOR_CAP_OPTS, STREAM_CAP_OPTS,
+  TOOL_OUTPUT_ENTRY_MAX_CHARS, TOOL_OUTPUT_TOTAL_MAX_CHARS, ADVISOR_TEXT_MAX_CHARS,
+} from "./display-budget.mjs"
+
+/** 输出环字符维总量（§15.3.1 TOOL_OUTPUT_TOTAL_MAX_CHARS——与 200 条目环同款丢最旧）。 */
+function trimOutputChars(block) {
+  let total = 0
+  for (const s of block.output) total += s.length
+  while (total > TOOL_OUTPUT_TOTAL_MAX_CHARS && block.output.length > 0) {
+    total -= block.output.shift().length
+  }
+}
 
 /** 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, askBatchPermission, askQuestion, saveSessionImpl } = deps
+  // 行集总量对账便捷式（§15.3.3——冻结锚点平移交 subagent 族函数）
+  const budgetSync = () => syncLineBudget(state, { onTrim: (st, n) => shiftFreezeAnchors(st, n) })
+  /** Advisor 有序块累积 + 额度（§15.3.1 ADVISOR_TEXT_MAX_CHARS——头 32K/尾 96K/中段标记）。 */
+  const pushAdvisorChunk = (raw, kind) => {
+    const blocks = state._advisorBlocks ??= []
+    const last = blocks.at(-1)
+    if (last && last.kind === kind) last.text = appendCapped(last.text, raw, ADVISOR_CAP_OPTS)
+    else blocks.push({ kind, text: appendCapped("", raw, ADVISOR_CAP_OPTS) })
+    // 多块总量：丢最旧块直至 ≤ 额度（裁决尾部优先）
+    let total = 0
+    for (const b of blocks) total += b.text.length
+    while (total > ADVISOR_TEXT_MAX_CHARS && blocks.length > 1) total -= blocks.shift().text.length
+  }
   // 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
@@ -66,7 +98,7 @@ export function buildToolCallbacks(deps) {
       // block content, never the main stream (D1). Routing details in subagent-blocks.
       if (routeSubToken(state, t, scheduleRender)) return
       ensureAssistantLabel()
-      state.streaming += t
+      state.streaming = appendCapped(state.streaming, t, STREAM_CAP_OPTS) // §15.3.1 STREAM_MAX_CHARS
       scheduleRender()
     },
     onReasoning: (t) => {
@@ -74,7 +106,7 @@ export function buildToolCallbacks(deps) {
       // buffer as kind=think (F2: same treatment as the main reasoning stream).
       if (routeSubReasoning(state, t, scheduleRender)) return
       ensureAssistantLabel()
-      state.reasoning += t
+      state.reasoning = appendCapped(state.reasoning, t, STREAM_CAP_OPTS) // §15.3.1 STREAM_MAX_CHARS
       scheduleRender()
     },
     onToolCall: (name, args, toolId) => {
@@ -136,6 +168,8 @@ export function buildToolCallbacks(deps) {
           done: false,
         },
       })
+      accountLine(state, state.lines[state.lines.length - 1]) // 载体入总量账（§15.3.4）
+      budgetSync()
       tickStart(name, toolId)
     },
     // §7.2.3（方案 e）：dispatch runOne 把工具 ctx 上的 _subagentKey（sync spawn/
@@ -173,9 +207,12 @@ export function buildToolCallbacks(deps) {
           //    启发式（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
+          // ③ subKey undefined 非错误（老回调/测试直调——成功路径未知工具）→ 不冻结
+          //    任何块（CLI-ACTIVITY-DEBLOAT F-2 收窄：finishSubTask 恒 no-op——无 key
+          //    无从精确归属，宁可 no-op 不误冻；块由回合尾 freezeAllSubTasks 兜底清场）。
+          // SYNC-CANCEL（R6）：⏹ 折叠报告带 STOPPED_MARK——块冻结标 stopped 而非 done
+          // （lastError 注记 + 事件定格——兜底竞态窗口的 dispatch 精确冻路径）
+          const lastError = result.includes(TURN_CAP_MARK) ? "turn cap reached — work may be partial" : result.includes(STOPPED_MARK) ? "stopped by user — work may be partial" : null
           const hasSubKey = subKey !== undefined && subKey !== null && subKey !== ""
           if (hasSubKey) {
             finishSubTaskKey(state, String(subKey), lastError)
@@ -184,11 +221,10 @@ export function buildToolCallbacks(deps) {
             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)
+          // CLI-ACTIVITY-DEBLOAT F-1 (2026-09-10): the conversation-stream report
+          // preview (max 8 dim lines) is deleted — the frozen block is the ONLY
+          // carrier of the child's report (full text also lives in history for the
+          // model; escalate#N keeps its no-preview surface unchanged).
         }
       } else if (isEscalate) {
         // 飞刀 post-op report landed under the subagent tool name — freeze the
@@ -200,9 +236,11 @@ export function buildToolCallbacks(deps) {
         // event at flight end). Sync results (async:false) freeze below.
         if (!isAsyncSpawnResult(result)) {
           // §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
+          // 失败/老回调无 subKey → 不冻结任何块（F-2 收窄——finishSubTask 恒 no-op，
+          // 块由回合尾 freezeAllSubTasks 兜底清场）。
+          // SYNC-CANCEL（R6）：同上——escalate 路径同款扩展（sync escalate 无 registry——
+          // 恒不折叠——扩展仅口径一致——零行为变化）
+          const lastError = result.includes(TURN_CAP_MARK) ? "turn cap reached — work may be partial" : result.includes(STOPPED_MARK) ? "stopped by user — work may be partial" : null
           if (subKey !== undefined && subKey !== null && subKey !== "") {
             finishSubTaskKey(state, String(subKey), lastError)
           } else {
@@ -229,11 +267,13 @@ export function buildToolCallbacks(deps) {
           // screen of garbage (user report 2026-08-30). The model gets the image
           // via the multimodal channel (agent.mjs), the human needs only the
           // text part: strip image parts from the displayed result.
-          block.result = slimToolResultForDisplay(result)
+          block.result = slimToolResultForDisplay(result) // §15.3.1 RESULT 额度（行 400 + 字符 64K 双维）
           block.summary = formatToolSummary(name, result)
           block.done = true
           const started = tickTake(name, toolId)
           block.elapsed = started !== null ? Math.round(performance.now() - started) : null
+          accountLine(state, findToolLine(state, name, toolId)) // 载体原地变更 → 重新入账
+          budgetSync()
         }
       }
       if (name === "advisor") {
@@ -248,17 +288,22 @@ export function buildToolCallbacks(deps) {
         // _advisorBlocks keep rendering the running view until cleared at turn end.
         const blocks = state._advisorBlocks ?? []
         if (blocks.length > 0) {
-          const text = blocks
+          // 冻结文本额度（§15.3.1：头 32K + 尾 96K 保裁决尾部 + 中段标记——非静默截断，
+          // 代码评审 #3：capLines(...)[0] 会丢标记且截尾）
+          const text = capAdvisorText(blocks
             .map((b) => b.text.replaceAll(ADVISOR_THINKING_PLACEHOLDER, ""))
             .join("")
             .replace(/\n{3,}/g, "\n\n")
-            .trim()
+            .trim())
           if (text) {
-            state.lines.push({
+            const line = {
               text: "advisor review",
               color: C.dim,
               _frozenAdvisor: text,
-            })
+            }
+            state.lines.push(line)
+            accountLine(state, line)
+            budgetSync()
           }
         }
       }
@@ -271,7 +316,7 @@ export function buildToolCallbacks(deps) {
       // 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 isSubRelay = RELAY_PREFIX_RE.test(name)
       const rawText = typeof chunk === "string" ? chunk : String(chunk?.text ?? "")
       const part = {
         kind: typeof chunk === "string" ? "text" : (chunk?.kind ?? "text"),
@@ -291,25 +336,26 @@ export function buildToolCallbacks(deps) {
         const isString = typeof chunk === "string"
         const raw = isString ? chunk : String(chunk?.text ?? "")
         const kind = isString ? "text" : (chunk?.kind ?? "text")
-        const blocks = state._advisorBlocks ??= []
-        const last = blocks.at(-1)
-        if (last && last.kind === kind) last.text += raw
-        else blocks.push({ kind, text: raw })
+        pushAdvisorChunk(raw, kind) // §15.3.1 累积额度（多块丢最旧）
         scheduleRender()
         return
       }
       // Append into the CURRENT tool block's output buffer (the block is the
       // display; no _live scroll lines anymore). N2-style cap keeps memory
-      // bounded: keep the LAST 200 output lines per call.
+      // bounded: keep the LAST 200 output lines per call; 字符维双维
+      // （§15.3.1：单条目 ≤ TOOL_OUTPUT_ENTRY_MAX_CHARS、总量 ≤ TOOL_OUTPUT_TOTAL_MAX_CHARS 丢最旧）。
       const block = findToolBlock(state, name, toolId)
       if (block) {
         for (const line of part.text.split("\n")) {
           const trimmed = line.trimEnd()
-          if (trimmed) block.output.push(trimmed)
+          if (trimmed) block.output.push(capText(trimmed, { max: TOOL_OUTPUT_ENTRY_MAX_CHARS, keepHead: 6_000, keepTail: 2_000, marker: MIDDLE_TRUNC_MARKER }))
         }
         if (block.output.length > TOOL_OUTPUT_LINE_CAP) {
           block.output.splice(0, block.output.length - TOOL_OUTPUT_LINE_CAP)
         }
+        trimOutputChars(block)
+        accountLine(state, findToolLine(state, name, toolId))
+        budgetSync()
       }
       scheduleRender()
     },

package/src/tui/tui-lifecycle.mjs

@@ -15,9 +15,16 @@ export function writeStartupSequence(write = (s) => process.stdout.write(s)) {
   write(ansi.altBuffer + ansi.hideCursor + ansi.mouseOn + ansi.bracketedPasteOn + ansi.keyboardPush + ansi.modifyOtherKeysOn + ansi.wrapOff)
 }
 
-/** TUI 清理序列：清屏 + 关闭鼠标/粘贴/键盘增强 + 退出 alt buffer + 显示光标 + 恢复环绕。 */
+/** TUI 清理序列 = 异常退出恢复序列（单一来源——§9.2 表 2 候选 1）：清屏 + 关闭鼠标/
+ *  粘贴/键盘增强 + 退出 alt buffer + 显示光标 + 恢复环绕。
+ *  TUI-OOM-ROOTCAUSE（CRASH-REPORTS.md §9.3）：提取为导出常量 `RECOVERY_SEQUENCE`——
+ *  包装父在子异常退出（V8 fatal——不走 JS 钩子）时补发同一序列（单一来源，禁第三份
+ *  副本）；writeCleanupSequence 引用同常量（行为逐字不变——既有字节锁测试保持，AC-RT3）。 */
+export const RECOVERY_SEQUENCE =
+  ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.keyboardPop + ansi.modifyOtherKeysOff + ansi.mainBuffer + ansi.showCursor + ansi.reset + ansi.wrapOn
+
 export function writeCleanupSequence(write = (s) => process.stdout.write(s)) {
-  write(ansi.clearScreen + ansi.mouseOff + ansi.bracketedPasteOff + ansi.keyboardPop + ansi.modifyOtherKeysOff + ansi.mainBuffer + ansi.showCursor + ansi.reset + ansi.wrapOn)
+  write(RECOVERY_SEQUENCE)
 }
 
 // R25（ARCHITECTURE.md §R25 F-R25a——复审 #1）：TUI 活动态标志——index.mjs 在终端接管
@@ -32,6 +39,11 @@ export function setTuiActive(active) {
   tuiActive = active === true
 }
 
+/** 读 TUI 活动态（F-2 渲染抑制守卫——render-loop doRender 前查——cleanup 清 false 后不再重绘已恢复的主屏）。 */
+export function isTuiActive() {
+  return tuiActive
+}
+
 /** R25 崩溃恢复：仅 TUI 活动态执行 writeCleanupSequence（复用本模块清理序列——符号锚）。
  *  测试缝（T-R25a.2——env 门注入）：THINCODER_TEST_CLEANUP_OUT 指向文件时序列写入该文件
  *  （观察恢复被调 + stdout 管道零 ANSI）——生产不设该 env → 恒 stdout（零变化）。
@@ -47,8 +59,10 @@ export function restoreTerminalAfterCrash() {
   return true
 }
 
-/** 退出清理闭包：保存会话（同步）+ 关闭 MCP 子进程 + 恢复终端。幂等（cleanedUp 守卫）。 */
-export function createExitCleanup({ agent, saveSession, closeAllMcp }) {
+/** 退出清理闭包：保存会话 + 关闭 MCP + 恢复终端。幂等（cleanedUp 守卫）。stdin/write 注入缝（测试锁序——缺省生产零变化）。
+ *  F-1 唯一权威序（RESIZE-MOUSE-LEAK-FIX）：① mouseOff DECRST → ② settle ~20ms（DECRST 往返——raw 仍开回显仍关）→
+ *  ③ raw off → ④ stdin 排空 → ⑤ 恢复屏幕 → ⑥ 清 TUI 活动态。 */
+export function createExitCleanup({ agent, saveSession, closeAllMcp, stdin = process.stdin, write = (s) => process.stdout.write(s) }) {
   let cleanedUp = false
   return () => {
     if (cleanedUp) return
@@ -67,8 +81,14 @@ export function createExitCleanup({ agent, saveSession, closeAllMcp }) {
     } catch {
       // Can't close? fine, process is exiting anyway
     }
-    process.stdin.setRawMode(false)
-    writeCleanupSequence()
-    setTuiActive(false) // R25：清理完成即清活动态（崩溃钩子不再收到误判）
+    // ① mouseOff 单独写（DECRST——不整包 writeCleanupSequence）：先于 raw off 停鼠标——消除「回显开而鼠标未停」暴露窗口
+    write(ansi.mouseOff)
+    // ② settle 20ms：Atomics.wait 同步等（不拆注册点——cleanup 亦挂 process.on("exit") 兜底异常退出——exit 事件仅同步合法）
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20)
+    // ③ raw off（DECRST 已被终端处理——无新上报可回显）→ ④ 排空：摘 data 监听 + pause——不依赖限时读——在途已读字节丢弃不归 shell
+    stdin.setRawMode(false); stdin.removeAllListeners("data"); stdin.pause()
+    // ⑤ writeCleanupSequence 余部（mouseOff 已单写——clearScreen/bracketedPasteOff/…/wrapOn 恢复屏幕）
+    write(ansi.clearScreen + ansi.bracketedPasteOff + ansi.keyboardPop + ansi.modifyOtherKeysOff + ansi.mainBuffer + ansi.showCursor + ansi.reset + ansi.wrapOn)
+    setTuiActive(false) // ⑥ R25：清理完即清活动态（崩溃钩子不再误判——渲染抑制锚）
   }
 }