@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/adapter/runStream.js

@@ -1,83 +1,27 @@
 import { eventSeq, } from './types.js';
 import { eventToSdkMessage, turnEndUsage } from './downstream/eventToSdkMessage.js';
 import { turnUsageToModelUsage } from './downstream/turnUsageToModelUsage.js';
-// D-3(0.66.0):终局对账臂与终帧超集键共用**同一个**成本读器(readRunCostFacts)。
 import { readRunCostFacts, terminalToSdkResult, TOOL_INPUT_JOIN_MAX_CALLS } from './downstream/terminalToSdkResult.js';
 import { coerceOutput, publishSubagentContentEvent } from '../subagentContentStore.js';
-/**
- * 409 session-busy 拒绝的 **canonical errorCode**([2377]C-1,server main `049ff2c`,随 5.0.0 发)。
- * 引擎把它 stamp 在 `done{status:'failed'}` / `failed` 终帧上,壳据此**结构判读**,不再读人话。
- * G1 去字面化(2026-08-04):字面收编进 `engineErrorCodes.ts` 单一真源,本文件只 import。
- */
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
-// 0.60.0(engine ≥7.64.0 / sdk 8.4.0):终局读数的单一读器(纯叶子:零 Node、零宿主端口)。
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
-/**
- * 本文件发的 chrome 事件全在 leader lane(子代内容在上面就被 divert 走了)。
- *
- * 🔴 **出厂口而不是常量**(0.76.1,与 A 层那半场同一条修法):车道证明在下游会被就地改写,
- *    一只模块级常量对象会让本文件三个发点(用量臂 / 停靠臂 / 对账臂)与**别的流**的同名事件共享
- *    同一只证明,一次改写打穿整个进程。每次新建一只。
- * 🔴 **刻意是本地的一行、不去 import A 层那只同名出厂口**:本文件是适配内核的闭包起点,闭包件数
- *    是只许降的棘轮 —— 为一行 `{lane:'main'}` 把 A 层(或 seam)拖进内核闭包是拿棘轮换重复,
- *    这一行字面量本来就是 `LaneProof` 主臂自己的形,不构成第二份判据。
- */
 const mainLane = () => ({ lane: 'main' });
-/**
- * **fire-and-forget 的 chrome 发射口**(0.66.0 / 异源对抗复审 [high] 逼出的同形族扫)。
- *
- * 病形:`try { void ctx.emitChrome(...) } catch {}` 只接得住**同步**抛出 —— 而端口的契约是
- * `void | Promise<void>`,一个返回被拒 Promise 的 sink 会在 try/catch **之外**变成
- * `unhandledRejection`;把未处理拒绝当致命错误的宿主(`--unhandled-rejections=strict`、
- * Electron 主进程的全局钩子)会**整只退出**。fail-soft 的承诺在那一刻反而成了最响的失败。
- *
- * ⇒ 两条腿一起接:同步抛在 `try` 里吞,异步拒绝挂 `.catch`。语义与此前逐字一致
- * (不 await、不改时序、sink 失败不影响流);`await` 的那一处(plan_review park)**不走本口**,
- * 它的时序是刻意的(卡片先于完成行上屏)。
- */
 function emitChromeFireAndForget(ctx, event) {
     try {
         const settled = ctx.emitChrome?.(event);
-        // thenable 才挂手柄:`void` 返回的同步 sink 上没有 `.catch` 可挂。
         if (settled !== undefined && settled !== null && typeof settled.catch === 'function') {
             void settled.catch(() => { });
         }
     }
-    catch { /* fail-soft — sink 抛错不影响流(原语义) */ }
+    catch { }
 }
-/**
- * `pendingGate` 的**单向**同一性判断(#285 件2,0.36.0):「我现在看到的这道门,能不能**证明**它
- * 不是刚才那一道?」
- *
- * `true` ⇔ 两侧都带 {@link ActiveRunPendingGate.checkpointId} **且**两者不等。其余一律 `false`。
- *
- * 🔴 **`false` 的语义是「证不出」,不是「同一道门」** —— 这不是措辞洁癖,是上游写死的可用性边界:
- * server 选行是无序 `LIMIT 1` 且同 session 可并存多条 pending 行,所以「id 相同」推不出「同一道门」
- * (id 不变而 `activeTaskId` 已换是成文的可能形),「id 缺席」更只是「不知道它叫什么」(三成因合流)。
- * 上游明确只背书**这一个方向**:「id 变了 ⇒ 我看到的确实不是刚才那一行」。
- *
- * 🔴 **为什么归包而不是让三端各写一遍**:这个谓词的价值全在**它拒绝回答的那一半**。三端各自手搓时,
- * 「两个 id 相等就当同一张卡去重」是最自然、也最容易写出来的一行 —— 而它恰恰是上游明说买不到的那个
- * 方向,写出来就是一条按错误前提去重的卡链。把可答的那半做成唯一入口,不可答的那半就没有顺手的写法。
- *
- * ⚠️ 它**不做**任何 kind/decidePath 比较:那两位回答的是「哪种门/去哪决议」,与「是不是同一行」正交
- * (同一行的 kind 不会变,不同行的 kind 完全可能相同)。要判种类变化请直接读 `kind`。
- */
 export function pendingGateIsProvablyDifferent(prev, next) {
     const a = prev?.checkpointId;
     const b = next?.checkpointId;
-    // 任一侧缺席 ⇒ 证不出(缺席 = 不知道这道门叫什么,三成因合流;绝不当成「不同」)。
     if (typeof a !== 'string' || typeof b !== 'string')
         return false;
     return a !== b;
 }
-/**
- * 判别一个**原始 AgentEvent** 是不是 409 active-run 拒收终帧;非 busy ⇒ null。
- * 判据=结构两腿(canonical `errorCode` 优先 → `activeTaskId` 在场);人话文案腿已随 #117 提货
- * 退役(§B8 禁按错误文案判别)。两种 wire 真形:
- *   ① `done{result:{status:'failed', errorCode|activeTaskId,…}}`(交互 tasks/stream 腿,409 骑终帧);
- *   ② `failed{errorCode|activeTaskId,…}`(任何把它投影成 failed 臂的上游形)。
- */
 export function activeRunBusySignal(ev) {
     if (typeof ev !== 'object' || ev === null || !('type' in ev))
         return null;
@@ -109,15 +53,7 @@ export function activeRunBusySignal(ev) {
     if (typeof rawGate === 'object' && rawGate !== null) {
         const k = rawGate.kind;
         const d = rawGate.decidePath;
-        // 出身位(A-028.1):**只认严格 true**。任何别的形(false / 'true' / 1 / 缺席)一律不置键 ——
-        // 键在场即渲徽标类文案,把一个含糊值读成「治理强制」= 对用户下一个证不出的断言。
         const g = rawGate.governanceForced;
-        // 身份位(#285 件2):**非空串才置键**,坏形一律降缺席 —— 与 kind/decidePath 同族口径。
-        // 🔴 **刻意不做 `cp_`+UUID 格式正则、也不叠长度上限**,与 server 铸点同裁:上游亲跑验过,严格
-        //    格式钉**买不到安全性**(32 位 hex token 按 uuid 分组后逐字满足该正则,剥掉装饰就是完整能力键),
-        //    只额外买来「core 换形我方静默丢键」的代价;长度域已在 server 投影处夹取,客户端再叠一道
-        //    **更窄**的域 = 上游放宽当天我方静默丢键,而丢键与 legacy 行在运维面上不可分辨。
-        //    窄读域只许等于或宽于铸点域([4050] 随批立的纪律)。
         const cp = rawGate.checkpointId;
         pendingGate = {
             kind: typeof k === 'string' && k.length > 0 ? k : null,
@@ -126,8 +62,6 @@ export function activeRunBusySignal(ev) {
             ...(typeof cp === 'string' && cp.length > 0 ? { checkpointId: cp } : {}),
         };
     }
-    // [4664] 活性证据位:只认**有限非负数**(NaN/Infinity/负数/串都是坏形 ⇒ 键不 stamp —— 一个
-    // 编造的「N 分钟无活动」比没有更坏)。
     const msIdle = carrier.msSinceLastActivity;
     return {
         activeTaskId: cls.handle,
@@ -136,16 +70,6 @@ export function activeRunBusySignal(ev) {
         ...(typeof msIdle === 'number' && Number.isFinite(msIdle) && msIdle >= 0 ? { msSinceLastActivity: msIdle } : {}),
     };
 }
-/**
- * 结构位优先的 409 判别(REF-CC-054 / dup-03 + 域词表-02,§B8 禁按错误文案判别)。
- *
- * 顺序即优先级:①引擎 canonical `errorCode`(结构位,机器码);②`activeTaskId` 在场(同样是
- * 结构性判据,[1833] G10 起就在 wire 上)。③人话子串锚已于 2026-08-03 随 #117 提货退役(见上)。
- *
- * 事故出处:此前整条判别是 `errText.includes(锚) || typeof activeTaskId === 'string'`,而 2026-07-31
- * 才发现锚曾是**全等**式、在今天的任何引擎上一次都命中不了 —— 判别一直只靠 activeTaskId 那一半在兜。
- * 上游把人话加长一句判别就死一半,这正是 B8 要禁的那类定时炸弹。
- */
 function classifyActiveRunBusy(input) {
     const handle = typeof input.activeTaskId === 'string' && input.activeTaskId.length > 0 ? input.activeTaskId : null;
     if (input.errorCode === ACTIVE_RUN_BUSY_ERROR_CODE)
@@ -154,73 +78,22 @@ function classifyActiveRunBusy(input) {
         return { busy: true, handle };
     return { busy: false, handle };
 }
-// ── 治理终态 vs provider/HTTP 真错(#289 批面③ / dogfood api C1+C2+案5)────────────────────────
-/**
- * 中性终态行的前缀。**刻意不是 `API Error`** —— 这一行说的是「这条 run 被本部署的治理旋钮停了」
- * (轮数/预算/墙钟/token 到限、结构化输出重试耗尽),不是 provider 或 HTTP 层出了故障。
- *
- * 事故形(台账 api C1/C2 逐坐标坐实):`sema -p --max-turns N` 的 STDERR 逐字是
- * `API Error: max turns exceeded`,交互面同一构造点也渲成红色「API 错误」行。用户读到 API Error
- * 会去查网络/密钥/额度,而真正的把手是他自己传的 `--max-turns`。CC 对同一件事写的是
- * `Error: Reached max turns (N)` —— 一个字的 `API` 都没有,本前缀与那条身份声明同向。
- */
 export const RUN_STOPPED_MESSAGE_PREFIX = 'Run stopped';
-/** blocked 终态自带的前缀(`Run blocked: <reason>`,见 errText 构造)。 */
 export const RUN_BLOCKED_MESSAGE_PREFIX = 'Run blocked';
-/**
- * 这条终态行是不是「治理/契约终态」而非 provider 故障 —— 渲染层据此给中性行同样的错误行 chrome
- * (它仍然是一条终态错误行,只是**身份**不是 API 错误),而不必按前缀猜。
- *
- * 🔴 与产出侧同一个真源:产出在 {@link runStream} 的 governance 臂,判别在这里,端只 import。
- * 各写一份正则必漂(记忆 `machine-readable-signal-not-visual-anchor`)。
- */
 export function isGovernanceStopRowText(text) {
     const t = text.trimStart();
     return t.startsWith(`${RUN_STOPPED_MESSAGE_PREFIX}:`) || t.startsWith(`${RUN_BLOCKED_MESSAGE_PREFIX}`);
 }
-/**
- * 第二条中性臂的前缀(0.72.8 CC-43;cli L-372 ③ 包侧正位):**模型这一轮的输出**坏了 —— core 三个 brain
- * (anthropic / openai / open-responses)把 `tool_use` 参数不是合法 JSON(最常见成因 = 输出被 max_tokens
- * 截断在参数中间)/ tool call 没带工具名 收成一句错误、run 以 `done{status:'failed', errorMessage}` 收口。
- * 这一族**没有一个 provider 请求失败过**:渲成 `API Error:` 把人指去查网络 / key / 配额,而该做的是调小请求、
- * 抬 output cap 或换个说法重问。与治理臂同律:身份换,行类旗(`isApiErrorMessage`)不换。
- */
 export const MODEL_OUTPUT_ERROR_PREFIX = 'Model output error';
-/**
- * 这条终态错误文本是不是「模型输出问题」(⇒ 中性行 `Model output error:`)。
- * 🔴 **只锚 core 原句的共同前缀,不做模糊匹配**:三个 brain 各带各的终止原因字段名(`stop_reason` /
- *    `finish_reason` / `status`)⇒ 只锚括号前那一段;`JSON` / `not valid` 这类词在别的错误里到处都是,放宽一个字
- *    就会把真的传输 / 服务端错误改渲成「模型输出问题」—— 方向相反、代价一样大。core 换句子 ⇒ 本锚当场失效 ⇒
- *    行回落 `API Error:`(开集兜底,不误报)。两句锚 = 同一铸点的两个分支(参数非 JSON / 无工具名),brain 用 ` | ` 连。
- */
 export function isModelOutputErrorText(text) {
-    // 🔴 0.72.9 CC-48(test 0.72.8 验收 #57):**按位置**认锚,不按子串 —— 真实 provider HTTP 400 的错误体会引用这句
-    //    (`offending text: "tool call argument(s) not valid JSON …"`),子串命中就把 API 侧拒请求说成模型输出坏了。
-    //    core 的铸点把这两句放在 errorMessage **开头**(两句都出现时 brain 用 " | " 连,第一句仍在开头)⇒ **只认消息开头**;
-    //    引用形、加前缀形、`<上游错误> | <引用锚句>` 形(异源复审第二轮抓出:任意段首也是子串匹配的变体)一律不命中。
     const anchors = ['tool call argument(s) not valid JSON', 'tool call(s) arrived with no tool name and cannot be executed'];
     const t = text.trimStart();
     return anchors.some((a) => t.startsWith(a));
 }
-/** 这一行是不是「模型输出问题」行(渲染面 / 归约面的谓词;与铸点同源,端别自抄前缀字面)。与 {@link isGovernanceStopRowText} 互斥。 */
 export function isModelOutputErrorRowText(text) {
     return text.trimStart().startsWith(`${MODEL_OUTPUT_ERROR_PREFIX}:`);
 }
-/**
- * 0.72.12 CC-50:第三条中性终局行身份 —— **结局不知道**(done 帧无终态记录 / 认不出的终态词)。
- * 三端渲染面按行首认它(与 `Model output error:` / `Run stopped:` 同律);它不是 API 错误、不是失败判决,
- * 是「别把这次结果当已验证」。铸点单源在 runStream 终局臂(读结果帧 `_sema_outcome`)。
- */
 export const OUTCOME_UNKNOWN_ROW_PREFIX = 'Outcome unknown';
-/**
- * 合成终态行的**唯一铸点**(0.72.12 起两处共用:`API Error:` / `Run stopped:` / `Model output error:` 那一行,与
- * `Outcome unknown:` 那一行)。
- * [2084]③:message 内部要有判别哨兵——外层 isApiErrorMessage/err- uuid 只护住读信封的消费者,而转录回喂/摘要器/
- * 评分器读的是 message 本体,没有 in-message 标记就会把这句引擎文案当成模型自己说的话。CC 2.1.220 同款哨兵 =
- * model:'<synthetic>'(下游投影层对 string 型 model 原样保留,不再回填真模型名)。
- * 🔴 `isApiErrorMessage: true` 是 CC 的**行类**旗(「这是合成的终态错误行,不是模型说的话」),不是「provider API
- *    错误」的断言:可见性过滤 / -p 契约投影 / tick 熔断都读它。
- */
 function syntheticTerminalRow(ctx, text) {
     return {
         session_id: ctx.sessionId ?? '',
@@ -231,21 +104,9 @@ function syntheticTerminalRow(ctx, text) {
         isApiErrorMessage: true,
     };
 }
-/** 这一行是不是「结局不知道」终局行(只认行首)。 */
 export function isOutcomeUnknownRowText(text) {
     return text.trimStart().startsWith(`${OUTCOME_UNKNOWN_ROW_PREFIX}:`);
 }
-/**
- * 终态是不是治理/契约面的(⇒ 中性行),而不是 provider/HTTP 面的(⇒ 保留 `API Error:`)。
- *
- * 🔴 **开集纪律**:只有**认得出**的治理码才走中性臂;认不出的码一律落回 `API Error:` 原臂
- * (原样透传引擎的话)。反过来做 = 替引擎断言「这不是 API 错误」,而那正是本修在骂的那类错档。
- *
- * 成员:
- *  · `status:'blocked'`(ReportBlocked 契约终态 —— agent 自己说它无法继续,零 provider 参与);
- *  · `limits.*` 全族(开集前缀,{@link isLimitsExceededCode});
- *  · `output.invalid`(结构化输出重试耗尽 —— CC 自己也有专门 subtype,同样不叫 API 错误)。
- */
 export function isGovernanceTerminal(input) {
     if (input.status === 'blocked')
         return true;
@@ -253,73 +114,15 @@ export function isGovernanceTerminal(input) {
         return true;
     return input.errorCode === OUTPUT_INVALID;
 }
-/**
- * 已上报过的未知帧类型(REF-CC-057:每种臂只吼一次,免得一条流刷屏)。
- * 🔴 单例登记见 `docs/refactor/p1-scan/singleton-manifest.json`:复制两份的后果 = 同一种臂多打
- * 几行 stderr,不影响正确性(dupRisk=low)。
- */
 const reportedDroppedTypes = new Set();
-/**
- * 去重表的容量上限(ADAPTER-F5,2026-08-02)。
- *
- * 表的键取自 **wire 值**(`String(ev.type)` —— 引擎发什么就是什么),而表是 module 级、生产期
- * 不清:一个乱发 `type` 的引擎/中间件能让它无界膨胀。上限到顶后**停止登记**(不是清空):
- * 清空会让同一批乱码 type 循环重登、每轮再吼一遍,交替序列下上限永远到不了
- * (记忆 `loop-termination-requires-reevaluation` 的兜底推论);停止登记的代价只是「顶之后的
- * 新臂每条都吼」—— 而那正是「引擎发了 64 种我不认识的臂」时应该吵的场面。
- */
 const DROPPED_TYPE_MEMO_CAP = 64;
-/** 留痕文案里 `type` 的呈现上限(超出截断);见 {@link sanitizeFrameType}。 */
 const DROPPED_TYPE_DISPLAY_CAP = 60;
-/**
- * 把不可信的 wire `type` 收拾成**一行日志安全**的呈现形(ADAPTER-F5)。
- *
- * 未处理时它原样进 `console.error` 的模板:一个带 `\n[client-core] …` 的 type 能在运维的 stderr
- * 里伪造出额外的整行(日志注入),控制符还能改终端状态。判据锚在「换行/控制符出不去 + 长度有界」,
- * 不锚在「引擎不会那么发」—— 后者是对上游的假设,不是本层的性质。
- */
 function sanitizeFrameType(type) {
-    // eslint-disable-next-line no-control-regex
     const flattened = type.replace(/[\u0000-\u001f\u007f-\u009f]/g, '\uFFFD');
     return flattened.length > DROPPED_TYPE_DISPLAY_CAP
         ? `${flattened.slice(0, DROPPED_TYPE_DISPLAY_CAP)}…`
         : flattened;
 }
-/**
- * 未知/畸形帧的**留痕**(§C5 丢弃必须留痕,且痕迹要到得了能处置它的人)。
- *
- * 为什么是 `console.error` 而不是 `hostLog`:runStream 是**可移植内核**,portability 门对它的
- * 传递闭包断言「零 Node 内建 + 文件数上限 6」,值级 import `host.ts` 会当场把闭包撑破。
- * console 在 Node 与浏览器都在,与 `host.ts` 自己那条「口没装就吼一声」的 miss 提示同款姿势。
- * 🔴 已知限制(诚实披露):Ink 挂载后宿主会吞 console,所以 TUI 里这行未必上屏 —— 那正是
- * `EventProjection.dropped` 存在的意义:想在自己那一端把它渲出来的宿主,读返回值即可。
- *
- * ── [C77]① 宿主出口 `ctx.onDroppedFrame`(2026-08-02,协作板 web-client 请托)────────────────
- * 上一段那条「读返回值即可」只对**自己驱动投影器**的宿主成立;经 `runStream` 消费的宿主
- * (web/desktop 都是)看不到 `EventProjection`,于是丢帧对它只剩一行 stderr。装了 sink 的宿主
- * 从此收到结构化的 `{type, why}`,自己那一端想渲成告警条还是计数器随它。
- *
- * 三条语义,各自的理由:
- *  ① **不去重**:去重表 `reportedDroppedTypes` 是给 console 防刷屏用的(一条流同一种臂只吼一次)。
- *     sink 那边**每一条都发** —— 宿主的告警面要的是真计数,包侧替它去重就是替它撒谎;它想
- *     去重是它自己一行的事,我们把真数给不出来才是不可逆的损失。
- *  ② **装了 sink ⇒ console 让位**:§C5 要的是「痕迹到得了能处置它的人」,不是「痕迹出现两次」。
- *     sink 是严格更强的通道(结构化 + 到得了 UI),而 console 这条腿自己承认在 Ink 宿主里会被
- *     吞;再者一个直写 stdout/stderr 的旁路会打乱 TUI 渲染。宿主显式装了 sink = 它认领了这件事。
- *     🔴 让位**不改缺省**:没装 sink 的宿主(含今天所有既有调用点)行为一字不变。
- *  ③ **sink 抛错 ⇒ 流照常 + 痕迹落回 console**:宿主的 bug 绝不许打断引擎流(与 `emitChrome`
- *     两处 fail-soft 同款);而②的让位前提是「sink 真接住了」,没接住就得把 console 那腿还回来
- *     —— 否则一个坏 sink 会让丢帧比装它之前更隐蔽(装了个东西反而更瞎,是最坏的一种)。
- */
-/**
- * 判词 → 这一行说给人听的那句话。**开集**(`why` 是投影器给的开集判词)⇒ 表外判词走缺省句,
- * 绝不因为多了一个判词就不说话。
- *
- * 🔴 为什么要分句而不是一句通用的:缺省那句逐字说「this build's projector has no arm for it」——
- * 对 `unknown_arm` / `malformed` 是真话,对 **0.68.0 的契约违约判词是假话**(本 build 有臂,
- * 是上游那一帧违了自己声明的契约)。一句说错方向的诊断会把读它的人指去升级客户端,而该做的是
- * 去看引擎那一侧。
- */
 const DROPPED_WHY_SENTENCE = Object.freeze({
     duplicate_seq: 'a frame with this event id was already consumed on this run stream, so it was dropped as a replay (durable idempotency, contract 02 §1.1). ' +
         'If the engine reuses an id across two DIFFERENT frames (server 7.77.0 does this for `reasoning_end`, fixed upstream in 7.78.1), the second one is lost here — this line is the only trace.',
@@ -327,13 +130,6 @@ const DROPPED_WHY_SENTENCE = Object.freeze({
         'The turn is counted as UNKNOWN spend (the run total is reported as a lower bound), and the frame itself renders NOWHERE.',
 });
 const DROPPED_WHY_SENTENCE_DEFAULT = "this build's projector has no arm for it (engine newer than the client, or a malformed frame). It renders NOWHERE.";
-/** 🔴 **按自有属性查表**(本仓对措辞表的既定纪律):`Object.freeze` 不移除原型,裸下标会让一个
- *  叫 `constructor` / `toString` 的判词命中 `Object.prototype` 上的**函数**并被拼进日志行。 */
-/**
- * CC-13(0.69.2)**出公面**:一条丢帧判词(`why` 开集进、缺省句兜底)。此前只在 console 兜底腿拼进日志,
- * `ctx.onDroppedFrame` 只收 `{ type, why }` ⇒ 自渲运维面的端只能手抄本表。现在载荷同时带 `sentence`,
- * 本函数给宿主在别处(存量留痕 / 别的 why 来源)复用同一份措辞。
- */
 export function droppedWhySentence(why) {
     const row = Object.hasOwn(DROPPED_WHY_SENTENCE, why) ? DROPPED_WHY_SENTENCE[why] : undefined;
     return typeof row === 'string' ? row : DROPPED_WHY_SENTENCE_DEFAULT;
@@ -341,49 +137,25 @@ export function droppedWhySentence(why) {
 function reportDroppedFrame(why, type, ctx) {
     if (ctx.onDroppedFrame) {
         try {
-            // 以 ctx 为 receiver 调用(宿主写成方法形时 `this` 不丢;与 ctx.emitChrome 同款姿势)。
             ctx.onDroppedFrame({ type, why, sentence: droppedWhySentence(why) });
-            return; // sink 接住了 ⇒ console 那行让位(理由 ② 见头注)
+            return;
         }
         catch (e) {
-            // 宿主 sink 抛错:不 rethrow(理由 ③),但**必须留痕**——先说 sink 自己坏了,
-            // 再走下面的 console 腿把这条丢帧本身补上。
-            // eslint-disable-next-line no-console
             console.error(`[client-core] ctx.onDroppedFrame threw (host sink); falling back to console: ${String(e)}`);
         }
     }
-    // ADAPTER-F5 ①:去重表有界。到顶后不再登记(也不清空,理由见 DROPPED_TYPE_MEMO_CAP 头注)——
-    // 键是不可信 wire 值,无界表是一条「引擎乱发 type 就能把宿主内存吃掉」的路。
     if (reportedDroppedTypes.has(type))
         return;
     if (reportedDroppedTypes.size < DROPPED_TYPE_MEMO_CAP)
         reportedDroppedTypes.add(type);
-    // eslint-disable-next-line no-console
-    console.error(
-    // ADAPTER-F5 ②:type 是 wire 值,进日志行前必须 sanitize(裸值能伪造额外的整行)。
-    `[client-core] dropped an engine frame (${why}): type="${sanitizeFrameType(type)}" — ${droppedWhySentence(why)}`);
+    console.error(`[client-core] dropped an engine frame (${why}): type="${sanitizeFrameType(type)}" — ${droppedWhySentence(why)}`);
 }
-/** 测试钩:清空「已上报过的臂」去重表(去重是**跨调用**状态,不清就只有第一条用例看得见)。 */
 export function _resetDroppedFrameReportForTest() {
     reportedDroppedTypes.clear();
 }
-/** 测试钩:去重表当前条数 —— ADAPTER-F5 的上限断言要读的**决定结果的量**(行数只证「吼了几次」,
- *  证不了「表有没有涨」;两者在到顶之后恰好分道扬镳,所以必须直接读表)。 */
 export function _droppedFrameMemoSizeForTest() {
     return reportedDroppedTypes.size;
 }
-/**
- * Drive one AgentEvent source into a CC SDKMessage stream.
- *
- * @param events  the SDK AgentEvent iterable (durable or live).
- * @param ctx     identity context (sessionId threaded onto every emitted arm).
- * @param handle  optional out-param updated with the latest folded usage.
- */
-// In-flight turn counter (module-level: every interactive turn flows through
-// runStream). Consumed by the engine versionDrift rolling-upgrade gate — the
-// engine must NEVER be hot-swapped mid-turn (it would sever this stream), so
-// the lifecycle loop defers the swap until this reads false (clay 2026-07-05
-// 滚动升级/一体化继承).
 let inFlightTurns = 0;
 export function isRunStreamActive() {
     return inFlightTurns > 0;
@@ -399,36 +171,10 @@ export async function* runStream(events, ctx, handle = {}) {
 }
 async function* runStreamInner(events, ctx, handle = {}) {
     const seen = new Set();
-    // P1-5 (print `--output-format json` 元数据失真): stamp the stream-open instant once so the terminal
-    // projector can emit a REAL `duration_ms` (the wire carries no duration; the old hardcoded 0 was fake).
     if (ctx.startedAtMs === undefined)
         ctx.startedAtMs = Date.now();
-    // ── L-228(0.67.0):per-subagent turn usage 的**流内**累加表 ─────────────────────────────────
-    // 🔴 **每条流一张**(局部量,不是模块级):两条并发的流各自攒各自看见的账;做成模块级单例会让
-    //    A 流的子代用量落进 B 流的终帧(本仓在册的「共享 store 跨流污染」病形)。
-    // 🔴 它**只在终帧那一拍**挂到 `ctx` 上(见下面 `done`/`failed` 分支),不是开流时就挂 ——
-    //    终帧的铸点在 `terminalToSdkResult`(单一 mint 点,见该文件顶注:给信封加一个位要改六处
-    //    正是它收编掉的病),而 `ctx` 是**调用方**的对象:宿主若把同一个 ctx 复用给两条并发的流,
-    //    开流时挂等于让后开的那条把先开的那条的表顶掉,先开的终帧于是报出别人的账。
-    //    挂在终帧那一拍 + 与 `terminalToSdkResult(...)` 在**同一个同步步**里,那个窗按构造不存在。
     const nestedUsageByTask = new Map();
-    // ── 🔴 0.67.2 / 车 I 件 I-1(异源对抗复审 [medium])—— usage 缺口观测位是 **per-stream** ──
-    // 修前它写在 `ctx.usageMissingObserved` 上:`EmitContext` 是**调用方的对象**、可以被复用给多条流
-    // (`startedAtMs` 本来就是这么用的;`run-subagent-usage-projection-test.mjs` 的 J3 段明确支持这一形),
-    // 而那一位**只置 true、永不清** ⇒
-    //   · 顺序复用:上一条流里的一轮缺口,让**下一条 usage 完整的流**的终帧铸出 `_sema_usage_lower_bound`、
-    //     同一拍的 `run_cost_reconciled` 也被标成下界 —— 宿主据此把一条账数得全的 run 渲成「≥」并持久化;
-    //   · 并发复用:两条流互相串这一位。
-    // 「别人那条流有缺口」不是「这条流的数字是下界」的证据。⇒ 观测位落在**本函数的局部量**上,终局
-    // 把**本流快照**同时交给两个投影口(终帧与对账臂),两面读同一份、且谁都读不到别人那份。
-    // 🔴 **不是**靠「终帧那一拍把 ctx 上那一位清掉」修的:并发的两条流会互相覆盖那次清除。
     let usageMissingObserved = false;
-    // ── 0.73.4 —— 本流 `toolCallId → tool_start.args` 快照(终帧拒绝清单第三键的来源)──
-    // 拒绝账本行带得出「哪一次调用」(`toolCallId`),带不出那次调用的入参对象;入参在同一条流的
-    // `tool_start` 帧上。与上面两格同款:**本函数的局部量**,终局那一拍作为按次入参交给终帧铸点,
-    // 绝不挂 `ctx`(调用方可复用给多条流 ⇒ 上一条流的入参会 join 到下一条流的拒绝行上)。
-    // 只存帧上那只对象的引用(转录里的 `tool_use.input` 是同一只),不复制;有条数上限。
-    // 同一个 id 见到两份**不同**的入参 ⇒ 判不出被拒的是哪一份 ⇒ 该 id 永久出表(不回头)。
     const toolInputByCallId = new Map();
     const toolInputAmbiguous = new Set();
     let toolInputOverflowed = false;
@@ -443,27 +189,19 @@ async function* runStreamInner(events, ctx, handle = {}) {
         }
     };
     for await (const ev of events) {
-        // event-id idempotency — drop a re-seen durable seq (contract 02 §1.1).
         const seq = eventSeq(ev);
         if (seq !== undefined) {
             if (seen.has(seq)) {
-                // CC-09(0.69.1;cli L-319 `-p` 真根因的包侧半场):**丢也要留痕**。server 7.77.0 给 `reasoning_end` 的
-                // SSE `id:` 复用了该段首枚 `reasoning_delta` 的 id ⇒ 这条去重把**权威段**当重放帧丢了,而修前这里是一条裸
-                // `continue` —— 比 0.68.2 的 `unknown_arm`(至少有痕)更静默。归口 = server 改铸唯一 id(7.78.1);本层
-                // 不猜「这是真重放还是 id 复用」(去重律不变,契约 02 §1.1),只把这次丢弃交给宿主的丢帧留痕口。
                 reportDroppedFrame('duplicate_seq', String(ev.type ?? 'unknown'), ctx);
                 continue;
             }
             seen.add(seq);
         }
-        // 0.73.4:记本流的 `tool_start` 入参(主会话与子代内部调用同记 —— 拒绝账本是整条 run 的)。
         if (ev.type === 'tool_start') {
             const callId = ev.toolCallId;
             if (typeof callId === 'string' && callId.length > 0 && !toolInputAmbiguous.has(callId)) {
                 const args = ev.args;
                 if (!toolInputByCallId.has(callId)) {
-                    // 溢出是单向闩:一旦有调用没记上,之后的新 id 一律不记(出表腾出的空位不回填 ——
-                    // 否则一只没记上首份入参的 id 会在重放时被当成首见,两份不同入参的判据就漏了)。
                     if (toolInputByCallId.size >= TOOL_INPUT_JOIN_MAX_CALLS)
                         toolInputOverflowed = true;
                     if (!toolInputOverflowed)
@@ -475,18 +213,6 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 }
             }
         }
-        // C1 — SUBAGENT content divert (service 1.89 forwardSubagentEvents): a CONTENT event stamped with
-        // parentToolCallId belongs to a SUBAGENT run (EventIdentity contract: present ONLY on sub-agent
-        // events) — side-channel it to the 查看态 transcript store and keep it OFF the main pipeline
-        // (a child's tokens rendering as the leader's text is the pollution failure mode). turn_end's
-        // sub-flow guard below stays as-is (usage rollup only).
-        //
-        // 🔴 0.62.0 —— 判据同时收 durable 腿的**聚合形**(`text` / `reasoning`,整段全文)。
-        //    修前判据只列了四个**活体**臂,于是 `runs/:id/events` 重放尾上带 parentToolCallId 的聚合帧
-        //    **漏过分流**,一路落进下面的通用投影口、渲成 leader 自己的 assistant 正文 —— 也就是本臂
-        //    整段头注在防的那个污染形,只是走了另一条腿进来(headless 断线续听 / 交互续听重放尾同踩)。
-        //    判据的锚仍是**同一个**:`parentToolCallId` 在场 = 这一帧属于子代;帧是增量还是整段与
-        //    「它属于谁」无关,所以两类臂必须共用这一条判据,而不是各判一次。
         if ((ev.type === 'text_delta' ||
             ev.type === 'reasoning_delta' ||
             ev.type === 'text' ||
@@ -497,229 +223,68 @@ async function* runStreamInner(events, ctx, handle = {}) {
             const sub = ev;
             publishSubagentContentEvent({
                 type: sub.type,
-                // 🔴 EventIdentity 上**没有** `taskId`(sdk events.d.ts 的 `interface EventIdentity` 只有
-                // eventId / parentToolCallId,加 LIVE 白名单四臂的 sourceTaskId / bgAgentId;`taskId` 只长在
-                // `meta` 首帧)⇒ 生产上这里恒走右臂,归账键由 store 的 `parentToTask` 补(canonicalKey)。
-                // `??` 保留是**容将来**:哪天上游真在内容帧上发 taskId,这条直接认,不必改形。
-                // (0.30.0 发包扫描订正:此前这行注释写「taskId is on every subagent event」,与 store 侧
-                //  `canonicalKey` 的注释互相矛盾,且被 .d.ts 直接证伪。)
                 taskId: sub.taskId ?? sub.parentToolCallId,
                 parentToolCallId: sub.parentToolCallId,
                 delta: sub.delta,
-                // 聚合两臂的载荷:整段全文。store 侧按**吸收**处置(活体已流过的那一段是它的前缀 ⇒
-                // 换掉而不是追加),所以「活体流过 + 重放聚合」不会双份。
                 text: sub.text,
-                // 聚合帧的**幂等键**:durable 重放会把整轮的段再送一遍,而缝前的事件序号去重只在**同一条**
-                // 流内有效(重连后是新的一条流)。把身份交给 store,让跨流的重放也只收一次。
-                // (工具两臂不读这一位 —— store 侧按 `toolCallId` 与账本上那张卡判,见 subagentContentStore。)
                 eventId: sub.eventId,
                 toolCallId: sub.toolCallId,
                 toolName: sub.toolName,
                 args: sub.args,
-                // #158 移交①([3674](d) 姊妹病,2026-08-12):此前是 `typeof sub.output === 'string' ?
-                // sub.output : undefined` —— 而 wire 的 `tool_end.output` 是非均匀的(块数组形合法),
-                // 于是子代 lane 的块数组 output 经本臂进内容账本**恒空**(查看态卡有工具、结果栏永远空白)。
-                // 换用 store 自己的那个唯一字符串化口(tail 腿 engineSubagentTail 用的同一份):两条腿喂
-                // 同一个账本,字符串化口就不能有第二份。
                 output: coerceOutput(sub.output),
                 isError: sub.isError,
             });
             continue;
         }
-        // Fold usage (footer counters), AND surface the per-turn `outputTokens` as a NEUTRAL `turn_usage` arm so
-        // the upstream bridge can drive 187's C1a `end` arm (responseLength reconciles to REAL output_tokens×4 —
-        // the spinner-token feeder, verify/TOKEN-187-PORT.md step 3). `turn_end` carries no renderable content, so
-        // this arm is metrics-only; the bridge converts it to a `message_delta{usage.output_tokens}` StreamEvent.
         if (ev.type === 'turn_end') {
-            // 🔴 L-215③ 异源对抗复审 [medium]②:`usageMissing` 是 core **刻意**造出来的诚实缺席位
-            //    (臂注逐字:「Consumers must treat the missing usage as UNKNOWN — not zero」;它与
-            //    `usage` **可以同帧**)。把它剥掉,本批新开的这条 usage 通道就会把「不知道」渲成一笔
-            //    全零的已知账 —— 与本批要根治的病(B-073 的成本 0/缺席)逐字同形,只是换了个量。
             const usageMissing = ev.usageMissing === true;
-            // 🔴 L-215③ 的**终局对偶**(异源对抗复审 [medium] 实抓):这条流上**只要有一轮**报过
-            //    「这一轮没有 usage」,终帧上那些数字就是**下界**。`stats.usageMissing` 只在带得出
-            //    `TaskResult` 的终帧上有,而 `failed` 事件帧 / 409 拒绝信封 / park 体**根本没有 stats**
-            //    ⇒ 只读 stats 的话,一条已经观测到缺口的 run 会在终帧上被读成「每一轮都报了 usage」
-            //    (而 `usage` 那几格恰好是 `flattenUsage(undefined)` 的全零)——「不知道」渲成了精确零。
-            //    ⇒ 流内观测到就记下来,终帧那一拍与 stats 的读数**取并**(见 costFactParts)。
             if (usageMissing)
                 usageMissingObserved = true;
             const stopReasonRaw = ev.stopReason;
             const stopWord = typeof stopReasonRaw === 'string' && stopReasonRaw.length > 0 ? stopReasonRaw : undefined;
-            // 🔴 `engineUsage` = 引擎**逐字原形**([2295] 裁 ②);`usage` = 它的 CC 镜像
-            //    (`turnUsageToModelUsage` 是唯一铸口,footer 折叠与本臂用的是**同一只产物**,不另铸第二份)。
-            //    两者同拍取、同拍过下面那道违约闸 —— 闸后**都恒在场**,下游一处条件判都不再需要。
-            // 🔴 0.68.0:除它们之外还要**第三只读数**,因为本层要答的是**两个不同的问题**:
-            //   · `engineUsage` —— 「这一帧有没有 usage 这个格子、而且它**成形**」(违约闸的判据);
-            //   · `measured`    —— 公面读器 `turnEndUsage` 的答案:`undefined` = **这一轮的账不知道**
-            //     (整格缺席 / 占位六零)。它与 `usage`(逐字镜像)刻意分开 —— 把两件事合成一个读数,
-            //     一条**合法**的占位帧就会在违约闸上被误判成违约并整帧丢掉。
-            // 🔴 **成形判据不是 `!== undefined`**(异源对抗复审轮四实抓):wire 是 JSON,SSE 解析**原样透传**
-            //    ⇒ `usage: null` / `usage: 7` 这类形真到得了这里。`null` 会让下面的映射在读 `costMicroUsd`
-            //    时抛 `TypeError` —— 那不是「一帧读不懂」,那是**整条流当场断掉**(后面的 `done` 一并丢);
-            //    标量则更坏:它会被映射成一份**看起来已测量**的全零账。⇒ 一律先判「非 null 的非数组对象」,
-            //    坏形与缺席走**同一条**违约路(响亮 + 不投影 + 立下界位)。
             const rawUsage = ev.usage;
             const engineUsage = typeof rawUsage === 'object' && rawUsage !== null && !Array.isArray(rawUsage)
                 ? rawUsage
                 : undefined;
             const usage = engineUsage !== undefined ? turnUsageToModelUsage(engineUsage) : undefined;
-            // 「这一轮的账知不知道」的**唯一判据**(与公面同一只;本层不另写一份「六格全零」的判断)。
             const measured = turnEndUsage(ev);
-            // ── 🔴 0.68.0 BREAKING(core 7.17.0 #711)—— `turn_end.usage` **恒在场** ────────────────
-            // core 的铸点自 7.17.0 起是无条件的:`const usage = rs.turn.turnUsage ?? {六个 0}` 后
-            // `queue.push({type:"turn_end", usage, ...(turnUsageUnknown ? {usageMissing:true} : {}), …})`
-            // (`run-harness-handlers.js` `onTurnEnd`)⇒ 「没有 usage 的 turn_end」**不再是一条合法形**:
-            // 那一轮真没量出账时,core 发的是**六个 0 + `usageMissing:true`**,而不是不发 usage。
-            // ⇒ 0.65.1 / B-088 那条「usage 缺席也要照发」的臂(以及它逼出来的三处
-            //    `usage !== undefined ? … : …` 条件)在本版**整条删掉**:它守的那个输入形已经不存在,
-            //    留着它等于给一个契约违约的帧准备一条静默通道。
-            //
-            // 🔴 **缺席 = 契约违约 ⇒ 响亮**(§32 的「违约无断言」纪律,本批的反钉格):
-            //    ① 走宿主的丢帧留痕口({@link EmitContext.onDroppedFrame},判词开集 ⇒ 宿主不必改型),
-            //       缺 sink 时落 console —— 两条腿都说得出「哪一帧、为什么」;
-            //    ② **这一轮的账确实不知道** ⇒ 同时立下界位,终帧那些数字按「≥」交付。不立的话,
-            //       一条丢了账的 run 会在终帧上被渲成一笔精确的账 —— 正是本仓反复在修的那条病;
-            //    ③ 整帧**不投影**:没有 usage 就没有任何数字可交,折 0 就是把「不知道」写成已知账。
-            //       丢掉的只有同帧可能带的 `stopReason` —— 一条违约帧上的附带位不值得为它保留一条
-            //       「半读」臂(那条臂就是 ① 要消灭的静默通道)。
             if (engineUsage === undefined || usage === undefined) {
                 usageMissingObserved = true;
-                // 🔴 违约帧同样让 footer 出口说实话:这一轮的账不知道,上面那两份读数属于更早的一轮。
                 handle.latestUsageMissing = true;
                 reportDroppedFrame('turn_end_usage_absent', ev.type, ctx);
                 continue;
             }
-            // §E2 identity (service 1.78) — a SUB-FLOW's turn_end (orchestration/subagent round, carries
-            // the identity envelope) must NOT drive the leader's C1a `end` reconcile: its outputTokens are
-            // the child's, and reconciling the leader's responseLength against them is the token-jump bug
-            // (blackboard dogfood #2 / upstreamBridge TODO #9). Fold its usage into the rollup only.
-            // ── 🔴 0.67.1 / B-090(下游验收轨实抓)—— **身份键盲区** ────────────────────────────────
-            // 修前这条判据只认 `parentToolCallId`,而 §32g「归属钥匙」段自己写的读法是「`sourceTaskId`
-            // 优先,wire 缺席时回落 `parentToolCallId`」—— 那句话隐含「只带 `sourceTaskId`」是一条合法
-            // 组合。于是那一形的子代轮被判成**主流**,后果双重且都是本件当初要防的病:
-            //   ① `!isSubFlow` 为真 ⇒ 它的 usage 去驱动 `last_turn_usage` chrome 臂与 `turn_usage` 消息臂
-            //      —— §E2 断闸要防的 token-jump 在这条路上原样重现(子代的窗口占用落进主会话 Context);
-            //   ② `isSubFlow` 为假 ⇒ 整条不进分表(下面那条 `if (isSubFlow)` 腿)—— 那只子代的账消失。
-            // 🔴 判据锚在 core 真字节上(`task-event.d.ts` `TaskEventIdentity`,不是本包的口味):
-            //    `sourceTaskId` 逐字「stamped ONLY on the content events of a task running AS A SUB-AGENT
-            //    (same condition as `parentToolCallId`)」,且「A TOP-LEVEL task's own events carry NO
-            //    `sourceTaskId`」⇒ **两键同条件盖章、顶层一个都不带** ⇒ 任一在场 = 这条帧属于子流。
-            // 🔴 判据是**键在不在**(`!== undefined`),不是「是不是非空串」:空串 / 坏形也算信封在场,
-            //    于是按子流走 —— 失效方向是安全的那一侧(宁可少发一拍主会话的 usage,也绝不把子代的账
-            //    混进主会话;反过来那一侧就是 token-jump)。**行键**那一层才做非空串窄化(见下面的
-            //    `parent` / `sourceTaskId`),两层问的不是同一个问题:信封在不在 vs 这一行归到谁名下。
             const isSubFlow = ev.parentToolCallId !== undefined ||
                 ev.sourceTaskId !== undefined;
-            // 🔴 0.68.0:此处修前是 `if (usage) {` —— 那条 `usage` 在不在的判据随 core 7.17.0 的
-            //    「恒在场」一起退役(缺席在上面的违约闸里已经整帧收口)。块保留是为了**不动缩进**,
-            //    读法上它已经是无条件的一段。
             {
-                // 🔴 0.68.0(异源对抗复审 [medium] 实抓,轮四再订正一次)—— 这个公开出口上**没有**判别位
-                //    可以让 footer 分辨「占位」与「真零」,所以它要分两件事各自决定:
-                //    ① **读数**:只有**占位**(`measured === undefined` 且这一帧成形)才不覆盖 —— 保留上一次
-                //       真读数,与 #711 之前的行为逐字相同(那时这种轮根本不带 usage)⇒ 没跟车的消费者零回归。
-                //       🔴 **缺账 ≠ 占位**:`usageMissing` 可以与**真数字同帧**(core 在同一轮里攒到过数字而
-                //       另一次调用报了缺账)—— 那些数字是真的量到过(是下界),blanket 跳过会把它们丢掉
-                //       (轮四实测:5 → 42+缺账位,main 的 handle 到 42,blanket 写法停在 5)。
-                //    ② **判别位**:只要这一轮报了缺账就立(never false;测到账的那一轮删键)。
-                //       两件事分开之后,「读数是最新的真值」与「最新那一轮的账不全」可以同时为真。
                 if (measured !== undefined) {
                     handle.latestUsage = usage;
-                    // [2295] 裁 ② 逐字通道:与镜像同拍存一份引擎原形(六键含 totalInputTokens)。
                     handle.latestEngineUsage = engineUsage;
                 }
                 if (usageMissing)
                     handle.latestUsageMissing = true;
                 else
                     delete handle.latestUsageMissing;
-                // plugins 专项 G1(2026-07-21):同一折叠点多发一份给 lastTurnUsageStore——StatusLine
-                // 的 statusline 命令 stdin(context_window.current_usage)在消息面无 usage(seam 合成
-                // 消息不带)时回落到这里,claude-hud 类插件的 Context 条才有真值。sub-flow 的 turn_end
-                // 不发(§E2 同判据):statusline 显示的是主会话窗口,子 agent 的 usage 会把 Context%
-                // 打成孩子的窗口占用(自查+对抗复审确认)。
-                // B3 切边:此前是 `void import('../../sema/lastTurnUsageStore.js').then(publishLastTurnUsage)`
-                // ——壳内向的动态边。改成 chrome 事件(宿主消费义务见 seam.ts `last_turn_usage` 臂);
-                // 与原式同样**不 await**(fire-and-forget),sink 抛错不影响流(fail-soft 原语义)。
                 if (!isSubFlow && ctx.emitChrome) {
                     {
-                        // engineUsage = [2295] 裁 ② 逐字原形(additive 键,契约见 seam.ts 本臂 doc):
-                        // 总量/命中率消费面吃它,镜像 usage 保纯。eopt:additive 键按「诚实缺席」= 键不在
-                        // (与 turn_end.usage 本身「整体 optional,缺席≠空对象」同一语义,不是「键在值 undefined」)。
                         emitChromeFireAndForget(ctx, {
                             kind: 'last_turn_usage',
                             laneProof: mainLane(),
                             usage,
-                            // 🔴 0.68.0:`engineUsage` 的条件 spread 退役 —— `turn_end.usage` 恒在场
-                            //    (缺席已在违约闸里整帧收口),这里再判一次就是给一个不可能的形留座位。
                             engineUsage,
-                            // L-215③:chrome 腿同批带这两位(message 腿的对偶在 `turn_usage` 臂的 `_sema_` 键上)。
-                            // 🔴 `usageMissing` 在这条腿上**不能**靠「不发 usage」表达 —— 本臂的 `usage` 是必填位
-                            //    (宿主义务是「落最近一次 turn 真 usage」),所以它只能以判别位在场:
-                            //    `usageMissing === true` ⇒ 同行那份 usage **不是**一笔已知的账,别当真值落槽。
                             ...(usageMissing ? { usageMissing: true } : {}),
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                         });
                     }
                 }
             }
-            // ── L-228(0.67.0):子流那条腿 —— **additive 第三条腿**,主臂两处 `!isSubFlow` 断闸不动 ────
-            // 病(车 E 件⑥ 实抓):core 终局只有合计 `stats.nested`(**无 per-task 分项**),而流里每条
-            // 子流 turn_end 都带着它自己那一轮的 usage —— 本包此前在 §E2 断闸处**折而未读**,于是壳的
-            // 子代详情面只渲得出 `_sema_usage_absent`。⇒ 分表只能由流内累加得出,这就是那条通道。
-            // 🔴 **归属钥匙**:`sourceTaskId` 优先,wire 缺席时回落 `parentToolCallId`(同一只子代的每一轮
-            //    至少归得到同一行)。两个都读不出 ⇒ **整条不入表**(编一个 `"unknown"` 行就是把几只子代的
-            //    账混成一只)。身份位为什么**不是** `taskId`,见下面那段 🔴。
-            // 🔴 **`usageMissing` 与数字同帧并存**:core 明说那一轮的 usage 是 UNKNOWN 不是 0 ⇒ 数字照
-            //    累加(它是**下界**),判别位在行上立起来;把那一轮整个丢掉会让下界更假。
             if (isSubFlow) {
                 const parentToolCallId = ev.parentToolCallId;
-                // 🔴 **身份键读 `sourceTaskId`,不是 `taskId`**(异源对抗复审 [high] 实抓,core 真字节直证):
-                //    core `TaskEventIdentity` 顶注逐字「the `WorkflowRun.sourceTaskId` family, **NOT a second
-                //    `taskId`** — that field already exists on `task_progress` and a duplicate would bite
-                //    consumers」⇒ 子代内容事件上**根本没有** `taskId` 这一位,读它恒缺席、恒回落到父调用 id,
-                //    于是**同一个父调用下的多只子任务会并成一行**(sdk 的 `turn_end` 臂也没有声明任何身份位,
-                //    两条腿都读 cast —— 这正是「按 d.ts 抄,不按印象猜」那条纪律要防的形)。
                 const rawSourceTaskId = ev.sourceTaskId;
                 const parent = typeof parentToolCallId === 'string' && parentToolCallId.length > 0 ? parentToolCallId : undefined;
                 const sourceTaskId = typeof rawSourceTaskId === 'string' && rawSourceTaskId.length > 0 ? rawSourceTaskId : undefined;
-                // 行键:`sourceTaskId` 优先,缺席回落父调用 id(同一只子代的每一轮至少归得到同一行)。
-                // ⚠️ 回落**有损**:同父调用多子任务会并成一行 —— 那时终帧那张表的 `partial` 判别位会因
-                //    行数对不上 `nested.tasks` 而立起来(诚实缺席优先于假装分得开)。
                 const taskId = sourceTaskId ?? parent;
-                // ── 🔴 0.67.2 / 车 I 件 I-2(异源对抗复审 [medium])—— **累加表的键按出身隔离** ──
-                // 病:`taskId` 有**两个命名空间**(真身份 `sourceTaskId` / 回落 `parentToolCallId`),而 core 的
-                // 合同**没有**保证两者互斥 —— 一只子任务的 id 与另一只子任务的父调用 id 完全可以撞字面。修前
-                // 直接拿裸 `taskId` 当累加键,于是撞字面的两行**在累加那一层就已经并掉**,而出身位
-                // (`keyFromParentFallback`)是**按行**记的 ⇒ 并掉之后那一行只剩一种出身,「出身混合」这道闸
-                // (`nestedUsageByTaskParts` 的 `mixedKeyOrigin`)当场读不出混合,于是被绕过。
-                // 三帧反例(异源复审逐字复现):`(sourceTaskId,parentToolCallId,inputTokens)` = ('p','a',10) / (缺席,'p',20) /
-                // (缺席,'a',30),终局 `nested={tasks:2,turns:3}` ⇒ 修前输出 `{p:30, a:30}`、行数与轮数两条对账
-                // **同时成立** ⇒ `partial` 不铸,而真相是父调用 `a` 那只花了 40、父调用 `p` 那只花了 20。
-                // ⇒ 累加键前缀化(`s:` = 真身份 / `p:` = 回落),**逐事件**把出身记进键本身;交付面的键仍是
-                //    裸 id(端零改),同字面的跨空间碰撞由 `nestedUsageByTaskParts` 判出来并如实标记。
-                // 🔴 前缀只活在**本层的累加表**里:它不是身份的一部分,wire 上自带 `s:`/`p:` 前缀的 id 因此
-                //    不会与别人串(两个空间的键各带自己的前缀,`s:` + `"p:x"` ≠ `p:` + `"s:x"`)。
-                // 🔴 0.67.1 / B-090:入表条件从「行键 **且** 父调用 id 都读得出」放宽到「**行键**读得出」。
-                //    修前那个 `&& parent !== undefined` 把「只带 `sourceTaskId`」的子代整条挡在表外 ——
-                //    而 `parent` 在这里的唯一用处是**铸 chrome 增量臂的车道证明**,不是行的身份。
-                //    行键读不出(两键都缺 / 都是空串)仍然整条不入表:编一个 `"unknown"` 行会把几只子代
-                //    的账混成一只(C3 那一格守的就是这条)。
                 if (taskId !== undefined) {
-                    // 🔴 0.68.0 BREAKING:发臂条件的「三者任一在场」整条退役 —— 它是 0.65.1 / B-088 为
-                    //    「裸 `{type:'turn_end', usageMissing:true}`(无 usage)」那一形写的,而 core 7.17.0
-                    //    起那一形不再存在(`usage` 恒在场,缺席在上面的违约闸里整帧收口)⇒ 走到这里就**恒有
-                    //    话可说**,条件判只剩车道证明那一条(`parent`)与宿主有没有装 sink。
-                    // 🔴 **`parent` 缺席时本臂不发,而行照进表**(0.67.1 定谳,理由如实写在这里):
-                    //    chrome 信封的车道证明 `LaneProof` 的子流臂是 `{lane:'subagent', parentToolCallId: string}`
-                    //    (`seam.ts`),座位门 `seatContract.checkLaneProof` 对它是**硬要求**(缺伴随位的信封
-                    //    当场被吃掉,且 `run-client-core-pure-test.mjs` FIX7 ④ 有专门的投毒格守着)。这一形上
-                    //    **没有**父调用 id ⇒ 唯一能把臂发出去的办法是拿 `sourceTaskId` 去填那一格,而那是在
-                    //    一个「父调用 id」的位上放一个**任务 id** —— 正是 C4/C5 两格守的身份位互串,也是
-                    //    车道纪律(REF-CC-064)存在的理由。放宽 `LaneProof` 则是**三端 BREAKING**(宿主今天
-                    //    按 `parentToolCallId: string` 读),不是一个 patch 能做的事。
-                    //    ⇒ 增量腿在这一形上静默,**收口快照(终帧 `_sema_nested_usage_by_task`)照带这一行**
-                    //    —— 账不丢,少的只是这一形的实时增量;两者本来就是「同一份账的两个时刻」。
                     if (parent !== undefined && ctx.emitChrome) {
                         emitChromeFireAndForget(ctx, {
                             kind: 'subagent_turn_usage',
@@ -733,39 +298,13 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             ...(stopWord !== undefined ? { stopReason: stopWord } : {}),
                         });
                     }
-                    // 累加键 = 出身前缀 + 裸 id(见上面那段 🔴)。`sourceTaskId` 缺席时 `taskId === parent`
-                    // (它就是 `sourceTaskId ?? parent`),所以这里不必再写一次回落判据。
                     const rowKey = sourceTaskId !== undefined ? `s:${sourceTaskId}` : `p:${taskId}`;
                     const row = nestedUsageByTask.get(rowKey) ?? { taskId, turns: 0, inputTokens: 0, outputTokens: 0 };
-                    // 🔴 0.67.1(异源复审 [medium] 实抓):记下**这一行的键是回落来的**(真身份缺席)。
-                    //    B-090 放宽入表条件之后行键可以有两种出身,而混合出身时「拆一行 + 并一行」的计数
-                    //    误差方向相反、可以恰好抵消 ⇒ 终帧那张表的 `partial` 判据要看得见出身
-                    //    (理由与反例逐字在 `MutableSubagentUsageRow.keyFromParentFallback` 的头注里)。
-                    //    🔴 0.67.2 / 件 I-2:出身按行均匀这件事现在由**键空间**保证(累加键带 `s:`/`p:` 前缀),
-                    //    不再依赖「`taskId = sourceTaskId ?? parent` 所以真身份在场的轮不会落到回落行上」这条
-                    //    推理 —— 那条推理在两个空间**撞字面**时不成立(见上面 `rowKey` 的头注)。
                     if (sourceTaskId === undefined)
                         row.keyFromParentFallback = true;
                     row.turns += 1;
-                    // 🔴 0.68.0:两处 `usage?.x ?? 0` 的 `?.`/`?? 0` 退役 —— `usage` 恒在场(违约闸在上面),
-                    //    留着「缺席折 0」的写法等于在代码里为一个不可能的形保留一条把「不知道」写成 0 的路。
                     row.inputTokens += usage.inputTokens;
                     row.outputTokens += usage.outputTokens;
-                    // 🔴 `cacheReadTokens` 读的是**引擎原形** `engineUsage`,不是 CC 镜像:镜像的
-                    //    `cacheReadInputTokens` 是**必填** number,缺席在那儿已经被折成 0
-                    //    (`toCcModelUsage` 的 `finiteOrZero`)⇒ 从镜像读就再也分不出「没报」与「零命中」。
-                    //    ⇒ 一轮都没报过 ⇒ 键**不铸**;报过之后再加 0 的那些轮是真的零命中。
-                    // 🔴 **0.68.0 跟车修(#711 的同形后果,族扫捞出;异源对抗复审轮一订正过一次)**:
-                    //    `usageMissing` 的那一轮,core 的 `usage` 是 `rs.turn.turnUsage ?? {六个 0}` ——
-                    //    ⚠️ **`usageMissing` 并不保证那六格是零**:core 在同一轮里可能已经攒到过真数字
-                    //    (`turnUsage` 有值)而**另一次**模型调用报了缺账,于是 `turnUsageMissing` 与真数字
-                    //    **同帧并存**(`run-harness-handlers.js:79-101` 与 `:289-293` 真字节)。
-                    //    ⇒ 判据只能锚在**能证明是真读数的那一半**:占位恒为 `0`,所以一个**非零有限数**
-                    //    必定是真的量到过 ⇒ 照累加;而 `0` 在这一形上**分不出**占位与「零命中」⇒ 不铸
-                    //    (本行的全部意义就是把「没报」与「零命中」分开,那一格会被 #711 悄悄抹平)。
-                    //    🔴 轮一的写法是「`usageMissing` 的轮整条跳过」,那会把**真的非零 cache 读数丢掉**
-                    //    (两帧 10 / 100 且第二帧带缺账位 ⇒ 修前 110、轮一写法 10,而 chrome 增量腿仍交
-                    //    10 与 100 ⇒ 实时面与终局分表对不上)。收窄成「只屏蔽零」两面就一致了。
                     const cacheRead = engineUsage.cacheReadTokens;
                     if (typeof cacheRead === 'number' && Number.isFinite(cacheRead) && (!usageMissing || cacheRead !== 0)) {
                         row.cacheReadTokens = (row.cacheReadTokens ?? 0) + cacheRead;
@@ -776,36 +315,10 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 }
             }
             const outputTokens = engineUsage.outputTokens;
-            // 🔴 0.68.0 BREAKING:发臂条件的「三者任一在场」整条退役(0.65.1 / B-088 那条判据的
-            //    输入形随 core 7.17.0 消失 —— 见本块顶部的违约闸)。走到这里 `usage` 恒在场 ⇒
-            //    **恒有话可说**:要么是镜像,要么是 `usageMissing` 判别位,两者必有其一。
-            //    ⚠️ 旧消费者零影响:`outputTokens` 读不出时仍然**整键不铸**,而 adapt 的 `turnUsageArm`
-            //    本来就以 `typeof m.outputTokens === 'number'` 开门 ⇒ 那种帧对它照旧是 no-op。
             if (!isSubFlow) {
-                // ── L-215③(0.65.0):assistant 行那两个**算不出来**的键的真值出口 ─────────────────
-                // `eventToSdkMessage` 的 `assistantArm` 刻意**不**在内容臂上铸 `usage` / `stop_reason`
-                // (帧序:内容臂先到、`turn_end` 后到 ⇒ 臂发出时引擎还没说这一轮花了多少;在那里铸只能
-                // 是估算,而估算正是本件要根治的病)。真值只能在**这里**给 —— 这条臂本来就是 turn 收尾
-                // 那一拍的中性出口。两个都是 `_sema_` 超集键,CC 同名键语义零改:
-                //   · `_sema_last_assistant_usage` —— 这一轮的 CC `ModelUsage` 镜像(与 footer 折叠用的
-                //     是**同一只** `turnUsageToModelUsage()` 产物,不另铸第二份 ⇒ 两面永远不会各漂各的);
-                //   · `_sema_stop_reason` —— `turn_end.stopReason` **原词透传**(core 归一化后的五词
-                //     `stop`/`length`/`toolUse`/`error`/`aborted`,sdk 型面是开放 string ⇒ 按开集读;
-                //     「这一轮是不是被 max_tokens 截了」就靠它,此前 stream 与 trace 两面互盲)。
-                // 缺席一律不铸(旧引擎不发 `stopReason`;`usage` 整体缺席的帧在违约闸那一拍就收口了)。
                 yield {
                     type: 'turn_usage',
-                    // 🔴 `usageMissing` 在场 ⇒ **不铸镜像**(0.65.x 起的既有规矩:全零的「不知道」绝不冒充
-                    //    一笔已知的零账),改铸判别位。
-                    // 🔴 `outputTokens` 的判据随 #711 多一条(与上面子代腿的 `cacheReadTokens` **同一条**):
-                    //    缺账轮的 `usage` 是 `turnUsage ?? {六个 0}`,而 `usageMissing` **不保证**那六格是零
-                    //    (同一轮里另一次调用报了缺账时,真数字与判别位同帧并存)⇒ 占位恒为 `0`,所以
-                    //    **非零有限数必定是真读数**(照铸),而 `0` 在这一形上分不出占位与真零 ⇒ 不铸 ——
-                    //    把占位 `0` 交出去,以 `typeof === 'number'` 开门的既有消费者(adapt 的 `turnUsageArm`
-                    //    → spinner 的 responseLength 对账)会拿它当一次真的「这一轮吐了 0 个 token」。
                     ...(usageMissing ? { _sema_usage_missing: true } : { _sema_last_assistant_usage: usage }),
-                    // `outputTokens` 仍按**值**判:`usage` 恒在场不等于它里面每一格都是有限数,而 wire 是
-                    // JSON —— 坏值折 0 就是把「读不出」写成一笔零账。读不出 ⇒ 整键不铸。
                     ...(typeof outputTokens === 'number' && Number.isFinite(outputTokens) && (!usageMissing || outputTokens !== 0)
                         ? { outputTokens }
                         : {}),
@@ -814,25 +327,8 @@ async function* runStreamInner(events, ctx, handle = {}) {
             }
             continue;
         }
-        // Terminals: project then END (the SDK generator also ends here).
         if (ev.type === 'done' || ev.type === 'failed') {
-            // clay P0 报错体系(2026-07-06,402 实测定谳):failed 终态此前只投影成 SDKResult
-            // (interactive REPL 不渲染 result 帧)= 上游 4xx/欠费/超限对用户完全静默。这里
-            // 额外合成一条 assistant 错误消息(CC 的 isApiErrorMessage 红字渲染线现成),
-            // 用户永远能看到 turn 为什么失败。
-            // 🔴 0.60.0(engine ≥7.64.0 / sdk 8.4.0):done 帧的终局读数换成带标因由,读法单源
-            //    `runTerminal.readRunTerminal`(它同时认扁平形的**三个**来源:读盘回放的历史行 /
-            //    server 自己的 409 拒绝信封 / 同步提交腿的 park 体)。本文件从此一个平面键都不直读。
             const doneTerminal = ev.type === 'done' ? readRunTerminal(ev.result) : null;
-            // [909]B1 — failed/blocked 终态同享可见性行(此前只 status:'failed' 有行,墙钟停/blocked
-            // 在 REPL 面完全静默)。park(suspended/needs_review)不进此行:有各自 overlay/文案线,
-            // 非 provider 故障([884]A1 断言零 assistant 行)。
-            //
-            // 留档(退役批,2026-08-04):此处曾有第三腿 `status === 'timeout'`(5.7 的墙钟停形)。
-            // core 5.8.0([2489])把该终态词退役 —— 墙钟到限改成 `status:'failed'` +
-            // `errorCode:'limits.max_walltime_exceeded'`,而 failed 腿本来就在(errorMessage ?? errorCode
-            // ?? 'run failed'),新形的可见性**已经**由它覆盖;server 6.0.0 捆 core 5.8.0 发车后旧形不再
-            // 上 wire,该腿随之删除,不留静默缺口。
             const errText = ev.type === 'failed'
                 ? (ev.errorMessage ?? ev.errorCode ?? 'run failed')
                 : doneTerminal?.kind === 'failed'
@@ -843,55 +339,15 @@ async function* runStreamInner(events, ctx, handle = {}) {
                             : 'Run blocked (the agent reported it cannot proceed)')
                         : null;
             if (errText) {
-                // 件2b(中断事故修复批 G,2026-07-15,症状2 第二环):409 active-run 拒绝的专属人话。引擎在
-                // session 已有挂起 run(上一 turn 的 AskUserQuestion park 未解锁等)时把
-                // errorMessage 'session already has an active run'(+ result.activeTaskId)骑在
-                // done{status:'failed'} 帧上(ai-agent-service server.ts:1526 同型)——裸 "API Error:" 行看着
-                // 像 provider 故障,是误导。识别该终帧 → 一行专属文案(告知在等什么 + 出路);其它错误保持
-                // 原 API Error 行(未知错误 fallback 不变)。引擎侧解锁腿已到货([868]:cancel 对
-                // suspended/needs_review 就地终态化 ⇒ claim 释放),所以文案指的就是那个端点;
-                // 自愈分诊腿(重开卡把决定权还给用户;cancel+重发臂已退役)在 `adapter/activeRunSelfHeal.ts`
-                // (A-028.1 上收,宿主经 deps 注入重开口),本层只负责:识别 + 说真话。
-                // `activeTaskId` 是**拒绝信封自己的**位(server 的 409 帧,不是引擎结果)⇒ 照旧从帧体直读,
-                // 不经因由读器(因由里没有这一位,也不该有)。
                 const activeTaskId = (ev.type === 'done' ? ev.result?.activeTaskId : undefined) ??
                     (ev.type === 'failed' ? ev.activeTaskId : undefined);
-                // REF-CC-054:判别**结构位两腿**(errorCode → activeTaskId;文案兜底腿 2026-08-03 已退役),
-                // 判别体见文件上方 `classifyActiveRunBusy`。
                 const busy = classifyActiveRunBusy({
                     errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
                     activeTaskId,
                 });
-                // 件14 rev2 (2026-07-14): provider max_tokens cap rejection (e.g. glm-5.2 preset 131072 >
-                // a third-party gateway's 128000) → append the way out. Keyword match on the upstream text,
-                // supplement never mask (raw provider words stay on the row).
-                // 🟢 B8 ALLOW 清单登记(REF-CC-域词表-08,属主=client-core 规范重构轮,单列一类:命中只
-                // 流向字符串拼接、不流向 if/return——supplement-only,零控制流。误判方向单侧:误命中只多
-                // 一行提示,误失效只少一行提示,行为面(哪一行 API Error / isError)不受影响。别把它跟
-                // 会改判别方向的判据(域词表-01/02 那种)混进同一张门里整体豁免)。
                 const maxTokHint = /max_tokens/i.test(errText)
                     ? '\nyour provider caps max_tokens lower — lower it in /model (press m, or M to type a value)'
                     : '';
-                // 🔴 2026-07-31 假承诺修复:这里原本写的是「Press Esc to cancel it, or retry shortly.」——
-                // 两条出路**都是假的**,而且不是「某个客户端没接」,是没有任何客户端能靠它们脱困:
-                //   · Esc:全 bundle 里 `/v1/runs/{id}/cancel` 在交互车道一处调用都没有,而且这一行上屏
-                //     时那条 turn 已经结束、取消键位根本没注册;
-                //   · "retry shortly":park(suspended/needs_review)会**永久**留住 session claim ——
-                //     重启引擎捞不回来(boot 期孤儿回收只捞 running)、时间型 reap 挂在
-                //     APPROVAL_TIMEOUT_SEC(默认 0 ⇒ 整条腿不跑),唯一兜底窗是 30 天。
-                // 换成真话 + 真的存在的两条动作(引擎的 cancel 端点 / 换一个会话)。
-                // #289 批面③ —— **错档前缀**(dogfood api C1/C2 + 案5)。轮数/预算/墙钟/token 到限、
-                // 结构化输出重试耗尽、ReportBlocked 的 blocked:这几种是**引擎侧治理/契约终态**,一个
-                // provider 请求都没失败过。此前它们与真 401/网关 502 共用 `API Error: ` 身份声明,把
-                // 「你自己设的 --max-turns 到了」说成 API 故障(判据与出处见 `isGovernanceTerminal`)。
-                // 认得出的治理终态 ⇒ 中性终态行;认不出的码一律走原 `API Error:` 臂(开集纪律)。
-                // 🔴 `isApiErrorMessage: true` 仍然置位:它是 CC 的**行类**旗(「这是合成的终态错误行,
-                //    不是模型说的话」),不是「这是 provider API 错误」的断言 —— 可见性过滤
-                //    (`Messages.filterForBriefTool`)、-p 契约投影、tick 熔断都读它,撤掉 = 这一行在
-                //    brief 模式里静默消失。改的是**身份文案**,不是行类。
-                // 🔴 `isGovernanceTerminal` 的入参仍是**词面**(它是一个纯谓词,公面签名不动)——
-                //    因由形下「被治理挡下」这件事由 `kind === 'blocked'` 承载,喂给它那一个词即可;
-                //    其余臂喂 `undefined`(码那一半照旧走 errorCode 腿)。
                 const governance = isGovernanceTerminal({
                     status: ev.type === 'failed' ? undefined : doneTerminal?.kind === 'blocked' ? 'blocked' : undefined,
                     errorCode: ev.type === 'failed' ? ev.errorCode : runTerminalCode(doneTerminal),
@@ -902,89 +358,43 @@ async function* runStreamInner(events, ctx, handle = {}) {
                         `has not been released, so this message was NOT sent. Nothing releases it on its own — ` +
                         `cancel that run (POST /v1/runs/${busyHandle ?? '<id>'}/cancel), or start a new session.`
                     : governance
-                        ? // blocked 的 errText 自己就以 `Run blocked` 开头(见上方 errText 构造),再套一层
-                            // `Run stopped:` 会变成两个前缀叠字;其余治理码用中性前缀 + 引擎原话。
+                        ?
                             `${isGovernanceStopRowText(errText) ? errText : `${RUN_STOPPED_MESSAGE_PREFIX}: ${errText}`}${maxTokHint}`
                         : isModelOutputErrorText(errText)
-                            ? // 0.72.8 CC-43:第二条中性臂 —— 模型输出坏了(core 原句锚),不是 API 错误;busy / 治理两臂优先(结构位赢过文本锚)。
+                            ?
                                 `${MODEL_OUTPUT_ERROR_PREFIX}: ${errText}${maxTokHint}`
                             : `API Error: ${errText}${maxTokHint}`;
                 yield syntheticTerminalRow(ctx, rowText);
             }
-            // plan_review park(core [508]③ 拍板形状):done `status:"needs_review"` + gate plan_review 不是
-            // 普通完成——壳弹审批卡(planReviewWire 合成 question 借 AskUserQuestion overlay;决断走
-            // /v1/assistant/tasks/:id/plan_review resume verb)。
-            // B3 切边:此前是 `await import('../../sema/planReviewWire.js')` —— **整棵 CC 树进闭包的
-            // 那一行**(设计稿 §5.2 根因链)。改成 chrome 事件;`await` 保留(cli 原本就在终帧**之前**
-            // 同步等 arm 完成,卡片先于完成行出现),sink 失败 fail-soft 照常投影终帧。
-            // 🔴 0.60.0:判据换成 `isReviewPark`,它**两个来源合读**(因由形的门种 ∪ 扁平形的 status 词)。
-            //    ⚠️ **扁平那一半是必须的,不是残留**(server 回帖确认):同步提交腿命中 park 时,server 自造
-            //    的 200 体是 `{taskId, sessionId, status:"suspended"|"needs_review"}` —— **既没有退役的八个
-            //    平面键、也没有 `terminal`、连门都不带**,它不是 `TaskResult` 而是独立于它的另一只形。
-            //    在那一形上 `status:"needs_review"` 是「这是一次复核」的**唯一**信号;只读门种会让整条
-            //    同步 park 腿的 plan-review 卡不弹。因由形那一半覆盖 done 帧的引擎结果,两半各管一条腿。
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
                     await ctx.emitChrome({ kind: 'plan_review_park', laneProof: mainLane(), result: ev.result });
                 }
-                catch { /* fail-soft — the terminal frame below still renders */ }
+                catch { }
             }
-            // D-3 / B-068 · L-198(0.66.0):**终局对账那一拍**。与终帧超集键
-            // (`_sema_cost_breakdown` / `_sema_nested_usage`)同一个读器 `readRunCostFacts` ⇒ 两面同源。
-            // 🔴 0.67.1 / B-091:「同源」此前只到**读器**这一层,取并那一层(下界位的两个来源)还留在
-            //    终帧那一面上 ⇒ 两面在「流内观测到缺口、终局 stats 缄默」这一形上各说各的。现在取并
-            //    在读器里面,两面读的是**同一次计算**(第二参就是那一半来源)。
-            // 🔴 没有账就不说话:`stats` 读不出(409 拒绝信封 / park 体 / `failed` 事件帧)⇒ 不发。
-            // 🔴 子流断闸(§E2)一字不动:子代花费只经本臂的 `nestedMicroUsd`(终局 stats.nested)到账。
-            // fail-soft 同 plan_review_park:sink 抛错不影响终帧照常投影。
             if (ev.type === 'done' && ctx.emitChrome) {
                 const doneStats = ev.result?.stats;
-                // 🔴 0.67.1 / B-091:**第二参必须传** —— 下界位的取并(`stats.usageMissing` ∪ 流内观测)
-                //    已经下沉进读器;不传就是把「臂绕开取并」那条不对称原样种回去(终帧铸了
-                //    `_sema_usage_lower_bound`、同一拍的臂上却没有 `usageLowerBound`)。
-                // 🔴 0.67.2 / 件 I-1:传的是**本流快照**(局部量按值包一层),不再是共享 ctx —— 与下面那行
-                //    `terminalToSdkResult(..., observed)` 是**同一份**读数。
                 const costFacts = readRunCostFacts(doneStats, { usageMissingObserved });
                 if (costFacts !== undefined) {
                     emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });
                 }
             }
-            // L-228 / 🔴 0.67.2 件 I-2b 订正:分表**不再挂到 `ctx` 上**,而是与观测位一起随第三参按值交给
-            //    终帧投影器。此前那句「挂表与铸终帧在同一个同步步里,复用 ctx 的并发流不会串账」只覆盖了
-            //    **两边都经 runStream** 的路径 —— 而这三只终帧投影器是**公面导出**,端完全可以「A 走
-            //    runStream、B 直调终帧投影」共用一个 ctx,那时 B 的终帧带出的是 A 的分表(B 的 `nested`
-            //    计数恰好对得上时连 `partial` 都不铸)。与件 I-1 逐字同形,所以同批一起摘掉。
-            // 🔴 0.67.2 / 件 I-1 订正:这里此前还写着「`usageMissingObserved` 是 per-ctx 的单调布尔,
-            //    复用 ctx 的两条流里只要有一条观测到缺口,两条都该按下界读 —— 取并是安全的那一侧」。
-            //    **那句话是错的**:下界位问的是「**这一条 run** 的账数全了没有」,别的流的缺口对它一个
-            //    字节的证据都不是;按那句话办,一条账数得全的 run 会被渲成「≥」并被宿主持久化成不完整状态
-            //    (失效方向在这里**不是**安全的那一侧,它是在断言一件没发生的事)。
-            //    ⇒ 观测位改为 per-stream 局部量,终帧按值收(第三参),与上面对账臂读的是同一份。
             const resultFrame = terminalToSdkResult(ev, ctx, { usageMissingObserved, nestedUsageByTask, toolInputByCallId });
-            // 0.72.12 CC-50(test [7541] G2-d「铸了就要有人读」):结果帧上的 `_sema_outcome:'unknown'`(终态记录整个
-            // 缺席 / 认不出的终态词;铸点与取舍见 terminalToSdkResult `ErrorResultParts.outcomeUnknown`)在**这里**被消费 ——
-            // 交互面合成一行 `Outcome unknown:` 终局行(句子与结果帧 `errors[0]` 单源),壳零接线即可见;它**不是**
-            // `API Error:`(那是 provider 故障身份),也不是「失败」:结果边界 fail-closed 是取舍,行文案把这一点说出来。
-            // 🔴 稀疏:真 completed / 真 failed 帧不带旗,这里零行(G2-e 负控)。
             const outcome = resultFrame.
                 _sema_outcome;
             if (outcome === 'unknown') {
                 const errs = resultFrame.errors;
                 const sentence = Array.isArray(errs) && typeof errs[0] === 'string' ? errs[0] : 'the run ended without a terminal record this client can read';
-                // 行类旗 isApiErrorMessage 置位(合成终态行),不是「provider 错误」断言 —— 同 Model output error 行。
                 yield syntheticTerminalRow(ctx, `${OUTCOME_UNKNOWN_ROW_PREFIX}: ${sentence}`);
             }
             yield resultFrame;
             return;
         }
-        // Every other arm → typed three-state projection(REF-CC-058)。
         const projection = eventToSdkMessage(ev, ctx);
         if (projection.kind === 'message') {
             yield projection.message;
             continue;
         }
-        // REF-CC-057:`dropped` 是「引擎发了一帧、这个 build 渲不出来」——**必须留痕**;
-        // `none` 是设计内无可渲染臂(usage 折叠/终帧代理/HITL 登记),不留痕才是对的。
         if (projection.kind === 'dropped')
             reportDroppedFrame(projection.why, projection.type, ctx);
     }