@sema-agent/client-core 0.77.0 → 0.77.2

package/dist/adapt/arms.js

@@ -8,48 +8,27 @@ import { recordEngineToolLabel } from '../engineToolLabelStore.js';
 import { registerSubagentAlias, registerSubagentContentAlias } from '../subagentContentStore.js';
 import { readAsyncLaunchedAgentReceipt } from '../toolResult.js';
 import { isWorkflowAgentTaskId, recordWorkflowAgentTaskId } from '../workflow.js';
-// L-215+(0.65.0;core [6908]):终局状态词的单铸谓词(三处同形一次改齐)。
 import { isTerminalStatus } from '../runTerminal.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
-// 0.75.1 CC-95(b):子代类型的诚实来源台账(fleet 行帧折进 name 之前留的那一份;包内叶)。
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
 import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
 import { CANCEL_MESSAGE, decisionOf, flattenWireOutput, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, TASK_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './wireShapes.js';
-// ══ M2/M1 —— assistant(tool_use 半场 + durable 文本/思考半场)══════════════════════════════════
 const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
     const message = m.message;
     const blocks = Array.isArray(message?.content)
         ? message.content
         : [];
     const toolUseIdx = blocks.findIndex(b => b?.type === 'tool_use');
-    // 拆分同批消掉一处 `!` 非空断言(规范禁用):`findIndex >= 0` 与「取到的不是 undefined」
-    // 本来就是同一件事(判别式 `b?.type === 'tool_use'` 对 undefined 恒假),写成显式取值即可。
-    // 收货裁定(对抗复审 #4):旧版此处直接取值使用,畸形帧(accessor/稀疏形,非 JSON 数据帧)
-    // 会抛 TypeError;guard 保留=有意的健壮性变化 —— 正常 wire 帧(JSON.parse 产物)下
-    // `findIndex >= 0 ⇒ 恒非 undefined`,零行为差。
-    //
-    // 🔴 ADAPT-F9 收口(2026-08-02 全窗复审):上面那句「零行为差」只覆盖了正常帧。**非正常帧上**
-    // 旧码抛 TypeError(响亮),而首版 guard 写成 `if (original !== undefined) {…}` ⇒ 取不到块时
-    // 不 return,而是**继续往下落进 text/thinking 半场** —— 后果不是「静默降级」而是**落进另一条臂**:
-    // 可能产出一条不该有的 assistant 文本消息 + 置 `markEmittedText()`(压掉 `result` 臂的终答兜底),
-    // 而卡永远不开 ⇒ 后到的 `tool_end_result` 被当「无对应开卡」直接丢。fail-loud→fail-soft 可以,
-    // 但绝不许 fail 到隔壁臂上去。判据锚在**决定分支的量**:`toolUseIdx >= 0` 就是「这是一条 tool_use
-    // 帧」,它一旦成立,text/thinking 半场就与本帧无关 —— 取不到块只能早退。
     if (toolUseIdx >= 0) {
         const original = blocks[toolUseIdx];
         if (original === undefined)
-            return; // 畸形:声称有 tool_use 块却取不到 ⇒ 本帧到此为止
+            return;
         const decision = decisionOf(original);
         const san = sanitizeToolUseBlock(original);
         const renderBlocks = blocks.map((b, i) => (i === toolUseIdx ? san.block : b));
         const toolUseId = String(san.block.id);
         const toolName = typeof san.block.name === 'string' ? san.block.name : 'unknown';
-        // P0-2 侧信道:core 展示名进本包台账(渲染块上已被 sanitize 摘掉)。cli 同位、同顺序
-        // (在任何 yield 之前),对 reject/cancel/error 三条早退路径同样生效。
-        // 🔴 时序留钉(矩阵 §2.1①):这必须是臂体的**第一条**副作用语句 —— 挪到下面任何 yield 之后,
-        //    reject/cancel/error 三条早退路径就永远登记不上 label,unknown-tool 卡按 id 查不到展示名。
         recordEngineToolLabel(toolUseId, san.label);
-        // 引擎模式下壳工具 call() 从不执行 —— ctrl+t 面板台账只能靠这条侧信道(宿主义务)。
         if (TASK_TOOL_NAMES.has(toolName)) {
             yield chrome({
                 kind: 'task_ledger_sync',
@@ -60,21 +39,12 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
                 input: san.block.input,
             });
         }
-        // #27 段序:先把这张卡之前的散文提交,再提交它之前的思考(思考恒在卡上方)。
         yield* text.takeAnswerSegment();
         yield* text.takeThinking();
-        // 0.62.0:卡之前的散文已经落账,卡**之后**的散文属于下一条 assistant 消息 —— 划界。
-        // (终帧 `result` 在引擎侧只取**最后一条** assistant 消息的文本,补差判据的两边必须是同一种东西。)
         text.beginAssistantMessage();
-        // L-215③:身份位取一次(下面只用 `model` —— `id` 是 per-RESPONSE 分组键,见块内注)。
         const cardIdentity = messageIdentityOf(m, ctx);
         yield transcript({
             type: 'assistant',
-            // S1:per-RESPONSE 铸 id —— CC 的 grouped-agent 渲染按 `${message.id}:${toolName}`
-            // 分组;id-less 帧会把整个 session 的 Agent 卡塌成一张。tool_use 帧才盖章。
-            // 🔴 L-215③:这条臂**只接 `model`,不接上游那个 `id`** —— 两个 `id` 是**两种身份**
-            //    (上游铸的是 per-EVENT 引擎身份,这里要的是 per-RESPONSE 分组键);换掉会把一张
-            //    Agent 卡拆成 N 张。`model` 没有这层冲突,照接(不接就在重建时原地丢掉)。
             message: {
                 id: cards.mintResponseId(m),
                 role: 'assistant',
@@ -86,9 +56,6 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             parent_tool_use_id: null,
         }, ctx.now());
         if (decision === 'reject' || decision === 'cancel') {
-            // S1:一个结果关闭该 model response。**yield 之前**复位 —— 矩阵 §2.2 定性为
-            // 「形不一致的技术债、不是缺陷」(L1 turn 级、下一句就 return、早退时无读者),
-            // 拆分同批前移成与 tool_end_result / sweep 一致的形,零行为差。
             cards.resetResponseId();
             yield transcript({
                 type: 'user',
@@ -109,7 +76,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             return;
         }
         if (decision === 'error') {
-            cards.resetResponseId(); // S1,同上:yield 之前复位
+            cards.resetResponseId();
             yield transcript({
                 type: 'user',
                 message: {
@@ -128,7 +95,6 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             }, ctx.now());
             return;
         }
-        // ⟨帧序耦合 1/7 + 3/7⟩ 开卡:后到的 task_progress 才猜得到父、后到的 tool_end 才关得掉卡。
         cards.open({
             id: toolUseId,
             name: toolName,
@@ -136,7 +102,6 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
             ...(san.eventId !== undefined ? { eventId: san.eventId } : {}),
             ...(san.parentToolCallId !== undefined ? { parentToolCallId: san.parentToolCallId } : {}),
         });
-        // ⟨帧序耦合 2/7⟩ W1 判据③ 的素材:只有先见过这张 Workflow 卡,后到的 tick 才判得出 workflow lane。
         if (WORKFLOW_TOOL_NAMES.has(toolName))
             inst.markWorkflowCard(toolUseId);
         return;
@@ -144,26 +109,21 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
     const textBlock = blocks.find(b => b?.type === 'text');
     if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) {
         text.appendAnswer(textBlock.text);
-        // 0.62.0:durable 的这一帧**本身就是一整条** assistant 消息 —— 先划界,再把它记成这条消息的全部
-        // (`+=` 会把上一条消息的正文算进来,补差判据当场看到一个从不存在的「更长的消息」)。
         text.beginAssistantMessage();
         yield* text.takeThinking();
         yield transcript({
             type: 'assistant',
-            // L-215③ 族扫:durable 内容腿也是**重建**点,身份位在这里接力(见 ids.ts messageIdentityOf)。
             message: { role: 'assistant', content: [{ type: 'text', text: textBlock.text }], ...messageIdentityOf(m, ctx) },
             uuid: idOf(m),
             session_id: ctx.sessionId,
             parent_tool_use_id: null,
         }, ctx.now());
-        // 0.62.0:把**真上屏的这一段**记进已提交账(终帧补差判据读它;不传会让补差少算一截)。
         text.markEmittedText(textBlock.text);
     }
     const thinkingBlock = blocks.find(b => b?.type === 'thinking');
     if (thinkingBlock && typeof thinkingBlock.thinking === 'string') {
         yield transcript({
             type: 'assistant',
-            // L-215③ 族扫:同上(durable 思考块)。
             message: { role: 'assistant', content: [thinkingBlock], ...messageIdentityOf(m, ctx) },
             uuid: idOf(m, 'durable-thinking'),
             session_id: ctx.sessionId,
@@ -171,8 +131,6 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
         }, ctx.now());
     }
 };
-// ══ M5 纯投影臂(零适配器状态,类型即证明)══════════════════════════════════════════════════════
-/** DIVERGENCE-1 —— 现役 wire 不产 user 帧;透传是给 desktop 重放存量转录留的门。 */
 const userArm = function* (m, { ctx, idOf }) {
     if (m.message === undefined)
         return;
@@ -180,8 +138,6 @@ const userArm = function* (m, { ctx, idOf }) {
 };
 const systemArm = function* (m, { ctx, idOf }) {
     yield transcript(m, ctx.now());
-    // core 1.219 attachWorkingFiles:compact_boundary 可携 attachedFiles → CC 的
-    // "Referenced file {path}" 行(post-compact attachment,零新 UI)。
     const attachedFiles = m.attachedFiles;
     if (Array.isArray(attachedFiles)) {
         let i = 0;
@@ -203,7 +159,7 @@ const systemArm = function* (m, { ctx, idOf }) {
 };
 const diagnosticsArm = function* (m, { idOf }) {
     if (typeof m.parentToolCallId === 'string')
-        return; // 子流帧不上 leader 面
+        return;
     const att = projectDiagnosticsFrame(m);
     if (att === null)
         return;
@@ -239,21 +195,12 @@ const workspaceChangedArm = function* (m, { idOf }) {
         attachment: { type: 'workspace_changed', cwd },
     });
 };
-/**
- * FIX⑦(2026-08-07,[3017]/[3020])—— `human_input` 生命周期账本帧。
- *
- * 姿势抄同族的 `steering_injected` / `workspace_changed`(都是「引擎侧发生了一件事,壳记一笔」的
- * 非持久帧,归 chrome),但**不走 `attachment` 臂**:那三条 attachment 是要在转录流里渲出一行给
- * 用户看的东西,而本帧**不带正文** —— 没有可渲的内容。硬造一行「有人输入了什么」的空 attachment
- * 就是在编内容。所以它有自己的 chrome 臂,宿主义务是「可选地记进审计/时间线」。
- * 子流帧(带 parentToolCallId)同族让位:不上 leader 面。
- */
 const humanInputArm = function* (m) {
     if (typeof m.parentToolCallId === 'string')
         return;
     const carrier = typeof m.carrier === 'string' ? m.carrier : '';
     if (carrier.length === 0)
-        return; // 无载体的账本行渲出去只是噪声(投影层已判 malformed,这里是第二道)
+        return;
     const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
     const rawActor = typeof m.actor === 'object' && m.actor !== null && !Array.isArray(m.actor)
         ? m.actor
@@ -276,22 +223,9 @@ const humanInputArm = function* (m) {
         ...(str(m.issuer) !== undefined ? { issuer: str(m.issuer) } : {}),
         ...(actor !== undefined && Object.keys(actor).length > 0 ? { actor } : {}),
         ...(str(m.entryId) !== undefined ? { entryId: str(m.entryId) } : {}),
-        // 宿主幂等落账的键(对抗复审二轮):重放同一条账本帧必须得到同一个 eventId。
         ...(str(m.eventId) !== undefined ? { eventId: str(m.eventId) } : {}),
     });
 };
-/**
- * B-072 ④(0.65.0)—— `message_committed` **定位账本帧**。
- *
- * 姿势逐条抄同族的 `human_input`(引擎侧发生了一件事、壳记一笔的非持久帧,归 chrome;**不走
- * attachment / 不铸 transcript**:本帧不带正文,铸一行就是替引擎编一句它没说过的话)。
- * 它与 `human_input` 的唯一差别是**用途**:那一条是审计,这一条是**定位** —— 端拿它自建
- * `entryId → 已渲消息` 的映射表,压缩分割线(`compact_metadata._sema_preserved_segment`)
- * 就是靠这张表落到「保留尾段的第一条消息之前」。
- *
- * 子流帧(带 parentToolCallId)同族让位:不上 leader 面(子代的条目属子代那条流)。
- * 两个必填位的**形**已由投影层判过(读不出即 malformed 留痕);这里是第二道,读不出就不发。
- */
 const messageCommittedArm = function* (m) {
     if (typeof m.parentToolCallId === 'string')
         return;
@@ -305,25 +239,9 @@ const messageCommittedArm = function* (m) {
         entryId,
         role,
         ...(typeof m.toolCallId === 'string' && m.toolCallId.length > 0 ? { toolCallId: m.toolCallId } : {}),
-        // 宿主幂等落表的键(同 human_input):durable 续读会重放同一条账本帧。
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
-/**
- * #310 / #318 件① —— `engine_notice` 引擎结构化通告(server ≥7.36,契约 = ASSISTANT-WIRE-CONTRACT 附录 D)。
- *
- * 姿势抄同族的 `human_input`(引擎侧发生了一件事、壳记一笔的非持久帧,归 chrome;**不走 attachment**:
- * 通告要带结构化事实与幂等键,折成一行文案会逼消费端反解 code)。
- *
- * 🔴 **开集:一个码都不判**。这里没有识别表、没有 switch、没有「已知才投」—— `code` 认不认得是
- * **渲染面**的事,投影面只负责把事实原样送到。`detail` 同理**整对象透传**(禁挑键:逐码不同且开集,
- * 挑键 = 新码的事实在本层静默蒸发)。
- * 🔴 **不读能力位**:帧到了就投影(A-022「到帧即服务」)。拿探测位 gate 一条已经到手的事实,只会在
- * 探测未判/失败时把真事实丢掉。
- * 🔴 子流帧(带 `parentToolCallId`)同族让位:不上 leader 面。
- * ⚠️ 第二道 `code` 在场判(投影层已判 malformed):同 `human_input` 的 carrier 二道判,防的是**非投影
- * 口喂进来的帧**(宿主自建管线 / 重放存量转录),不是重复判据。
- */
 const engineNoticeArm = function* (m) {
     if (typeof m.parentToolCallId === 'string')
         return;
@@ -343,34 +261,15 @@ const engineNoticeArm = function* (m) {
         ...(typeof m.sessionId === 'string' && m.sessionId.length > 0 ? { sessionId: m.sessionId } : {}),
         ...(typeof m.ts === 'number' && Number.isFinite(m.ts) ? { ts: m.ts } : {}),
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
-        // durable 重放的第二层身份(SDK 从 SSE `id:` stamp 的 per-task 序号)—— 两个键两个命名空间,
-        // 见投影层同位的长注。消费端幂等序:eventId > eventSeq > (都缺才退) code+ts。
         ...(typeof m.eventSeq === 'string' && m.eventSeq.length > 0 ? { eventSeq: m.eventSeq } : {}),
     });
 };
-/**
- * `wiring_manifest` 内部臂 → chrome `wiring_manifest`(core #524 + core 147③,server ≥7.58.0)。
- *
- * 契约本体在 `seam.ts` 的 {@link WiringManifestChromeEvent} 头注(它是宿主要读的那一份)。
- * 本臂只做两件:
- *  🔴 **子流断闸**(与 `engine_notice`/`text_segment_end` 同族):带 `parentToolCallId` 的接线自述
- *     属于子代/编排腿,把它的门卸清单渲到 leader 面上,用户会以为**自己这一 turn**少了工具。
- *     断闸按「**键在不在**」判不按「是不是串」判(与 `textSegmentEndArm` 同因:本臂决定的是
- *     「这份自述算谁的」,方向必须更严;`null` 算在场,不给坏值开口子)。
- *  🔴 **第二道成形判**:投影层已把两段各自校验过并保证「至少一段在场」,这里只再确认一次
- *     ——防的是**非投影口**喂进来的帧(宿主自建管线 / 重放存量转录),不是重复判据。
- *     两段都不在场 ⇒ 不产事件(与投影层的「不铸空臂」同一条规矩,两层不许各说各话)。
- * 🔴 **一个字都不改**:段内容原样转发(`restore` 逐字、`reason` 六词不映射)——任何加工都必须
- *    发生在渲染面,理由见臂注义务②③。
- */
 const wiringManifestArm = function* (m) {
-    // 三键断闸(修前只判 parentToolCallId:sourceTaskId / bgAgentId 两形的子代快照漏上 leader 面;与 tool_roster_delta 同律)
     if (isSubFlowSegmentEnd(m))
         return;
     const modelGate = m._sema_modelGate;
     const autoMode = m._sema_autoMode;
     const mcp = m._sema_mcp;
-    // CC-08 ①(0.71.0):第四/五/六段
     const tools = m._sema_tools;
     const hooks = m._sema_hooks;
     const lsp = m._sema_lsp;
@@ -385,8 +284,6 @@ const wiringManifestArm = function* (m) {
     const hasLsp = typeof lsp === 'object' && lsp !== null;
     const hasGate = typeof modelGate === 'object' && modelGate !== null;
     const hasAuto = typeof autoMode === 'object' && autoMode !== null;
-    // S-124(0.59.0):🔴 `Array.isArray` 判在场,**不判 `.length`** —— `mcp: []` 是「这条腿一台都
-    //    没申报」这句正面事实,按长度判会把它和「老 mint 没报」折成同一件事(core 顶注点名的读法)。
     const hasMcp = Array.isArray(mcp);
     if (!hasGate && !hasAuto && !hasMcp && !hasTools && !hasHooks && !hasLsp && !hasWriteProtection && !hasAutoConsolidation && !hasReadDeny)
         return;
@@ -405,22 +302,6 @@ const wiringManifestArm = function* (m) {
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
-/**
- * `approval_request` / `approval_revoke` 内部臂 → 同名 chrome 臂(B-078 / L-208,0.65.0;design/172)。
- *
- * 契约本体在 `seam.ts` 的 {@link import('../seam.js').ApprovalRequestChromeEvent} /
- * {@link import('../seam.js').ApprovalRevokeChromeEvent} 头注(那是宿主要读的那一份)。
- * 本臂只做两件:
- *  🔴 **一个字节都不加工**:`frame` 原样转发(信封纪律 —— 窄化到 v1 是宿主拿 sdk 谓词做的动作,
- *     在这里替它窄化会让一条 `schemaVersion: 2` 的合法帧冒充 v1;见投影层头注)。
- *  🔴 **第二道信封判**:投影层已经判过 `schemaVersion` 是有限数,这里再确认一次 —— 防的是
- *     **非投影口**喂进来的帧(宿主自建管线 / 重放存量转录),不是重复判据(与 `wiringManifestArm`
- *     的第二道成形判同因)。
- * 🔴 **刻意没有子流断闸**(与 `engine_notice` / `text_segment_end` 那三条相反,这是有理由的差别):
- *    那几条断闸挡的是「把子代腿的东西渲到 leader 面上」;而审批卡**必须**上到人面前——一张属于
- *    子代调用的卡也要人来点,断掉它等于把那条 run 挂死在没人看得见的地方。归属过滤由宿主按
- *    帧上的 `taskId` 做(撤卡臂的纪律①),那是**过滤**不是**丢弃**。
- */
 const approvalFrameArm = (kind) => function* (m) {
     const schemaVersion = m.schemaVersion;
     if (typeof schemaVersion !== 'number' || !Number.isFinite(schemaVersion))
@@ -430,51 +311,6 @@ const approvalFrameArm = (kind) => function* (m) {
         return;
     yield chrome({ kind, laneProof: mainLane(), frame, schemaVersion });
 };
-/**
- * `text_end` 内部臂 → **权威段替换** + chrome `text_segment_end`(#323 / core #447;L-310,
- * server ≥7.75.3)。
- *
- * 契约本体在 `seam.ts` 的 {@link TextSegmentEndChromeEvent} 头注(它是宿主要读的那一份)。
- * 本臂做四件:
- *  🔴 **子流断闸**(与 `engine_notice`/`prompt_suggestions`/thinking 半场同族):带 `parentToolCallId`
- *     的段边界属于子代/编排流,上 leader 面就是跨 lane 状态破坏 —— 直接不产事件,
- *     **也不动 leader 的文本缓冲**(断闸在替换之前,顺序不许倒过来)。
- *  🔴 **整段替换文本缓冲**(0.68.1 改口;修前这里写的是「本批不动文本缓冲」)。改口的事实依据:
- *     server 7.75.3 起 `text_end.content` 与 `result`/账本走**同一只脱敏器**,而 `text_delta` 仍
- *     逐字(跨 chunk 的凭据无法就地判)⇒ 两者**可以不相等**,而此前包内 committed 出去的是 delta
- *     拼文 = **未脱敏**字节留在本地转录里。契约原文逐字要求消费端「在 `text_end` 到达时以它整段
- *     替换已攒的 delta,而不是只当段界信号」。替换语义(四形处置 / 已提交前缀 / 活体尾巴重算)
- *     全在 {@link TextStream.replaceAnswerSegment} 的头注。
- *     ⚠️ **这不等于撤掉 idle-flush 启发式**:那条要按 core 的「诚实缺席」纪律做 **per-stream** 判据
- *     (整条流一帧都没有才回落启发式),仍未做 —— 替换是**兼容**启发式的(半段已被 flush 那一形
- *     由 `committedPrefixLen` / `committedPrefixDiverged` 如实交代),不是它的继任。
- *  🔴 **三个 additive 键,全部 never-false**(缺席 = 否定;与包内 `_sema_usage_absent` 同律)。
- *     铸一个 `false`/`0` 出来 = 把「这一段没分歧」与「这台引擎不报分歧」折成同一个字节,宿主分不出。
- *     **为什么恰是三个**(「宿主能不能只凭一帧就知道要不要重渲」的最小解):
- *       · `diverged` —— **活体面**那份(`stream_delta` 拼出来的)是不是过期的 ⇒ 要不要重渲;
- *       · `committedPrefixDiverged` —— **转录面**已经 committed 的那一截是不是过期的。它是真正的
- *         分水岭:缺席时本臂随后交的 transcript 消息是**尾段**(前缀 + 尾段拼起来 = `content`,
- *         宿主什么都不用丢);在场时本包**一个字节都不再交**(撤不回的那截拼不出 `content`,
- *         再补一条就是同一段话上屏两遍)⇒ 该段唯一算数的那一份就是帧上的 `content`,
- *         宿主用它换掉 `committedPrefixLen` 指的那一截。两个键合成一个位办不到:
- *         b1/b2 两形的 `diverged` 与 `committedPrefixLen` 完全同形,而宿主动作正相反。
- *       · `committedPrefixLen` —— **定位量**。单位 = **JS 字符串长度(UTF-16 代码单元)**,
- *         🔴 **不是 UTF-8 字节**(轮三 finding① 订正:按字节截会在非 ASCII 正文上截错位置,凭据
- *         原样留在屏上)、🔴 **也不是「几条消息」**(轮二 finding② 订正:本包在 idle-flush 那一形下
- *         会把「上一段的定稿 + 这一段的半截」合并进**同一条**消息,按消息丢会把已经定稿的上一段
- *         一起删掉,而本包不会再补发它)。宿主照抄
- *         `已committed正文.slice(0, 长度 - committedPrefixLen) + content` 即可。
- *     📋 **刻意没有第四个键 `authoritative: true`**(设计取舍,写明免得下一棒再问):它会在**每一帧**
- *        上恒为真 ⇒ 零判别力,既分不出新旧引擎(引擎版本不在帧上,本包不猜版本 —— 与 §33b 那条
- *        「刻意不留按引擎版本分岔的兼容读」同一条纪律),也不驱动宿主的任何分支。
- *  · 第二道 `content` 在场判(投影层已判 malformed/empty):同 `engine_notice` 的 carrier 二道判,
- *    防的是**非投影口喂进来的帧**(宿主自建管线 / 重放存量转录),不是重复判据。
- */
-// CC-10 子流身份三键判定 `isSubFlowSegmentEnd`:CC-13(0.69.2)起住在 `adapter/types.ts` 出公面(端改调,不再复刻)。
-/**
- * CC-08(0.71.0):`tool_disclosure` 内部臂 → chrome `tool_disclosure`(名字占位普查;全量快照整只替换)。
- * 🔴 子流断闸与 `text_segment_end` 同族(三键任一在场 = 子代帧,不上 leader 面)。
- */
 const toolDisclosureArm = function* (m) {
     if (isSubFlowSegmentEnd(m))
         return;
@@ -482,7 +318,7 @@ const toolDisclosureArm = function* (m) {
     const deferred = Array.isArray(m.deferred) ? m.deferred.filter((x) => typeof x === 'string') : null;
     const activated = Array.isArray(m.activated) ? m.activated.filter((x) => typeof x === 'string') : null;
     if (policy.length === 0 || deferred === null || activated === null)
-        return; // 二道判:非投影口喂进来的帧
+        return;
     yield chrome({
         kind: 'tool_disclosure',
         laneProof: mainLane(),
@@ -493,11 +329,6 @@ const toolDisclosureArm = function* (m) {
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
-/**
- * CC-08(0.71.0):`tool_progress` 内部臂 → chrome `tool_progress`(C-R50 一帧两拍:Bash 带尾巴三键 / 其他只 elapsed)。
- * 🔴 `output` 是 UNTRUSTED RAW(与 `tool_end.output` 同类,server 已脱敏一次),宿主可再封顶展示,**绝不**回喂模型。
- * 🔴 子流断闸同族:子代工具的进度属子代那条流,不上 leader 面。
- */
 const toolProgressArm = function* (m) {
     if (isSubFlowSegmentEnd(m))
         return;
@@ -518,10 +349,6 @@ const toolProgressArm = function* (m) {
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
-/**
- * CC-08 ①(0.71.0):`tool_roster_delta` 内部臂 → chrome `tool_roster_delta`(名册增量;LIVE only,重连按 wiring_manifest.tools 快照重同步)。
- * 🔴 包不持名册:`delta` 原样(已窄读)交宿主,宿主用 `applyToolRosterDelta` 与手上那份比 digest。三键子流断闸同族。
- */
 const toolRosterDeltaArm = function* (m) {
     if (isSubFlowSegmentEnd(m))
         return;
@@ -535,10 +362,6 @@ const toolRosterDeltaArm = function* (m) {
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
-/**
- * CC-08 ③(0.71.0):`context_usage` 内部臂 → chrome `context_usage`。每个压缩边界都报 ⇒ 一次任务多条,宿主按**最后一条**取当前值;
- * 🔴 `sections[].tokens` 与 `usedTokens` 不是同一坐标系,禁相减、禁拿一段比 `compactAtTokens`;`windowTokens` 是 autocompact 窗不是模型上下文大小。
- */
 const contextUsageArm = function* (m) {
     if (isSubFlowSegmentEnd(m))
         return;
@@ -559,21 +382,14 @@ const contextUsageArm = function* (m) {
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
-/**
- * CC-89(0.75.0):`compaction_outcome` 内部臂 → chrome `compaction_outcome`。每帧一条;转录面零行。
- * 🔴 lane 如实:`parentToolCallId` 非空串 ⇒ subagent;只有 `sourceTaskId` / `bgAgentId`(或父键空串)的帧没有诚实的 lane 可挂 ⇒ 不发,
- *    绝不落到主会话名下。`outcome` 非空串才发(非投影口喂进来的坏帧兜底)。
- */
 const compactionOutcomeArm = function* (m) {
     const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
     const outcome = str(m.outcome);
     if (outcome === undefined)
         return;
-    // 🔴 身份四键一次性快照(0.76.1;外部验收方对 0.76.0 的 F1):修前先 isSubFlowSegmentEnd(m) 再 str(m.parentToolCallId),
-    //    parentToolCallId 读了两次 ⇒ 值随读变的帧让直喂入口丢事件、经投影却出 subagent chrome —— 两入口分叉。
     const idSnap = snapshotSegmentIdentity(m);
     if (idSnap === null)
-        return; // 读身份就抛 ⇒ 整帧拒(与投影口判 malformed 同一处置,不发 chrome)
+        return;
     let laneProof = mainLane();
     if (snapshotIsSubFlow(idSnap)) {
         const parent = str(idSnap.parentToolCallId);
@@ -593,15 +409,6 @@ const compactionOutcomeArm = function* (m) {
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
-/**
- * CC-91(0.76.0):逐行**重建**白名单行(不是 `Array.isArray` 就整只透传)——
- * 🔴 本臂与投影口是**两个入口**:宿主自建管线 / 重放存量转录可以绕过投影口直接把 wire 帧喂进 `adapt()`,
- *    那条路上未校验的行会把本臂对外承诺的四条(零 `tokens`、零 digest 过境、`chars` 有限非负、全坏即缺席)
- *    一起破掉,还可能把违反公开型的行(`null` / `chars: -1`)递到消费端手里
- *    (异源对抗复审 R1 [medium] 实测可复现:`sections:[{id:'x',chars:-1,tokens:123,contentHash:'…'}]` 原样进 chrome)。
- *    ⇒ 与投影口**同律同形**:好行留、坏行逐条丢、全丢光或非数组 ⇒ 键缺席(不铸 `[]`)。
- *    两处实现由门逐字对拍(同一帧走投影口 vs 直喂 adapt,chrome 行必须一模一样),drift 即红。
- */
 const promptManifestRows = (v, pick) => {
     if (!Array.isArray(v))
         return undefined;
@@ -615,19 +422,9 @@ const promptManifestRows = (v, pick) => {
     }
     return rows.length > 0 ? rows : undefined;
 };
-/**
- * CC-91(0.76.0):`prompt_assembled` 内部臂 → chrome `prompt_assembled`。每帧一条;转录面零行。
- * 🔴 **包不去重**:一次任务的每一次 prepare(cascade / verify 的每一 rung、resume 腿)各自一条,server 逐条保序落账 ⇒
- *    每条都交出去,「只要最后一次」是**宿主**的动作(与 `context_usage` 同律;在包内按最后一条折会把先前已计费 rung 的组成面抹掉)。
- *    ⚠️ 上游那条流的**重放去重**是另一件事,按 `eventSeq` 在 `adapter/runStream.ts` 做;本臂只说「同一条流上的多条 prepare 都算真事实」。
- * 🔴 lane 如实:`parentToolCallId` 非空串 ⇒ subagent;只有 `sourceTaskId` / `bgAgentId`(或父键空串)的帧没有诚实的 lane 可挂 ⇒ 不发,
- *    绝不落到主会话名下。一条组成面的键都读不出的帧不发(非投影口喂进来的坏帧兜底)。
- * 🔴 **零 tokens 铸点**:本臂只搬 `chars`(上游真字节无 token 位),不在这一层编任何 token 数。
- */
 const promptAssembledArm = function* (m) {
     const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
     const size = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined);
-    // ⚠️ 帧上的 `constitution` 刻意不过境(投影口头注写明理由:今天零消费场景,键即契约)。
     const totalChars = size(m.totalChars);
     const blocks = promptManifestRows(m.blocks, (o) => {
         const id = str(o.id);
@@ -639,9 +436,6 @@ const promptAssembledArm = function* (m) {
         const chars = size(o.chars);
         if (id === undefined || chars === undefined)
             return undefined;
-        // 🔴 语义槽在**两个入口上都只认一个键名** `slot`(上游的名字,本层不改名):投影口产物与 wire 原形同名,
-        //    所以两条路读的是同一个位。曾经的写法是「`kind` 优先、回退 `slot`」—— 那会让一条**同时**带
-        //    `kind` 与 `slot`(或只带 `kind`)的帧在两条路上读出不同的槽,而这种帧是合法的(上游行是开集)。
         const slot = str(o.slot);
         return { id, chars, ...(slot !== undefined ? { slot } : {}) };
     });
@@ -651,16 +445,9 @@ const promptAssembledArm = function* (m) {
     });
     if (totalChars === undefined && blocks === undefined && sections === undefined && tools === undefined)
         return;
-    // 🔴 身份四键**一次性快照**,与投影口的 `identitySnapshot` / `identityOrMalformed` 同律(每键只读一次、抛错整帧拒):
-    //    ① 三个子流键**逐个**过形门(在场即必须是串)—— 只守 `parentToolCallId` 的话,一条
-    //       `{parentToolCallId:'tc-9', sourceTaskId: 7}` 会在投影口被整帧判坏、在直喂这条路上照发一条 subagent chrome;
-    //    ② **不能就地多读**:进程内帧可以带 accessor,同一个键读两次拿到两个值时,「形门读一次、子流判定再读一次、
-    //       取 parent 又读一次」会让同一帧在两条路上归属不同 lane —— 子代的组成信息被洗成主会话的
-    //       (第三轮复审 [medium] 实测可复现)。所以这里**不**用 `isSubFlowSegmentEnd(m)`(它会再读一遍),
-    //       子流判定直接看快照里「三键有没有在场」,语义与它逐字同(键在场 = 子代帧,空串也算在场)。
     const idSnap = snapshotSegmentIdentity(m);
     if (idSnap === null)
-        return; // 读身份就抛 ⇒ 整帧拒(理由见 snapshotSegmentIdentity 头注与本臂上方的说明)
+        return;
     if (SEGMENT_END_IDENTITY_KEYS.some((k) => idSnap[k] !== undefined && typeof idSnap[k] !== 'string'))
         return;
     let laneProof = mainLane();
@@ -682,46 +469,27 @@ const promptAssembledArm = function* (m) {
     });
 };
 const textSegmentEndArm = function* (m, { text }) {
-    // 🔴 断闸按「**键在不在**」判,不按「是不是串」判(异源对抗复审第三轮 [medium] 采纳)。
-    //    投影层已对坏 lane 位整帧 fail-closed;这一道是给**非投影口**喂进来的帧(宿主自建管线 /
-    //    重放存量转录)兜底 —— 那里若沿用同族其它臂的 `typeof === 'string'` 写法,一个坏值就会把
-    //    子代的段边界**擦成 leader 的**上到宿主面。同族臂的 `typeof` 写法在它们那里只影响一行装饰,
-    //    在本臂上决定的是「这条边界算谁的」,方向必须更严。
-    //    ⚠️ `null` 也算在场(不给它开口子):wire schema 只允许缺席或 string,`null` 是坏值不是缺席。
-    //    CC-10(0.69.1):三键任一在场即断(只带 `sourceTaskId` 的子代帧是合法形,修前漏断 = 子代覆盖 leader)。
     if (isSubFlowSegmentEnd(m))
         return;
     const content = typeof m.content === 'string' ? m.content : '';
     if (content.length === 0)
         return;
-    // 🔴 替换在**发事件之前**:宿主拿到 `diverged` 那一刻,包内的转录面已经是权威全文了 ——
-    //    反过来(先发信号再改缓冲)会有一拍窗口,宿主按信号去读转录面读到的还是旧拼文。
     const r = text.replaceAnswerSegment(content, m);
     yield chrome({
         kind: 'text_segment_end',
         laneProof: mainLane(),
         content,
-        // CC-01:帧上带的是**轮换前**的段身份 —— 与本段已过境的 committed 行同值(归属的第二把钥匙)。
         segmentId: text.segmentId(),
         ...(r.diverged ? { diverged: true } : {}),
         ...(r.committedPrefixDiverged ? { committedPrefixDiverged: true } : {}),
         ...(r.committedPrefixLen > 0 ? { committedPrefixLen: r.committedPrefixLen } : {}),
-        // CC-16(0.71.0):本窗口已提交行归属交全;`[]` 也透传(在场但空 = 零行),只有形 (f) 才整键缺席。
         ...(r.committedUuids !== undefined ? { committedUuids: r.committedUuids } : {}),
         ...(r.committedUuid !== undefined ? { committedUuid: r.committedUuid } : {}),
         ...(r.committedRows !== undefined ? { committedRows: r.committedRows } : {}),
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
-    // CC-01:段界到此为止 —— 事件已交到宿主手上之后才轮换(宿主按帧上的身份认行时,行上盖的还是同一个)。
     text.rotateSegmentIdentity(m);
 };
-/**
- * `reasoning_end` 内部臂 → 思考块**权威段替换** + chrome `thinking_segment_end`(CC-02,0.68.3;
- * server ≥7.77.0 S-310,sdk ≥9.4.0 `SegmentEndFields` 与 `text_end` 单源)。
- * 与 {@link textSegmentEndArm} 逐条同律:子流断闸(`parentToolCallId` 键在不在)/ 第二道 `content` 在场判 /
- * 替换在**发事件之前**。差别只在两形(见 `TextStream.replaceThinkingSegment` 头注)与多一把 `committedUuid`。
- * 🔴 **不轮换段身份**:段身份是文本行的(CC-01),思考块的收口与它无关。
- */
 const thinkingSegmentEndArm = function* (m, { text }) {
     if (isSubFlowSegmentEnd(m))
         return;
@@ -737,73 +505,39 @@ const thinkingSegmentEndArm = function* (m, { text }) {
         ...(r.committedPrefixDiverged ? { committedPrefixDiverged: true } : {}),
         ...(r.committedPrefixLen > 0 ? { committedPrefixLen: r.committedPrefixLen } : {}),
         ...(r.committedUuid !== undefined ? { committedUuid: r.committedUuid } : {}),
-        // CC-15:`[]` 也透传(形 (a) 的正面事实「零已提交行」);只有 `undefined`(形 (f) 零经手)才不铸键。
         ...(r.committedUuids !== undefined ? { committedUuids: r.committedUuids } : {}),
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
 };
 const promptSuggestionsArm = function* (m) {
-    // T57 第五处断闸(#47 矩阵 #5 同族):子流(parentToolCallId 标)的建议绝不骑主 composer。
     if (typeof m.parentToolCallId === 'string')
         return;
     const list = Array.isArray(m.suggestions)
         ? m.suggestions.filter((s) => typeof s === 'string')
         : [];
-    // 空批不发(cli 同门:`if (list.length > 0)`)—— 作废由 turn 开场那一发负责,
-    // 这里再发一次 null 会把本轮真产出的建议在极端交错下擦掉。
     if (list.length > 0) {
         yield chrome({ kind: 'prompt_suggestions', laneProof: mainLane(), suggestions: list });
     }
 };
-// ══ M2 —— tool_end_result(关卡 + B/D/E 层卡本体 + 两个侧产物)══════════════════════════════════
 const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
-    // B4 起本臂做三件:① P0-2 label 补位(只有 tool_end 带 label 的场景;台账自身幂等不覆盖)
-    // ② MF-10 **关卡 settle**(父卡的 tool_end 是完成信号;⚠️ 0.65.0/B-074 订正:「子代从不发
-    //    终态 tick」这句旧前提已被 core 7.x 推翻 —— 终态 tick 现在会发,由 taskProgressArm 的
-    //    `TERMINAL_TICK_STATUSES` 分支落行,两条腿共用 `endedPanelTasks` 判重;卡的 output
-    //    文本 = 子代最终报告,串到行 end 事件上)③ 卡台账出栈 + response-id 复位(S1)。
-    // 🆕 B5:④ **B/D/E 层** —— 铸 `tool_result` 卡本体 + 三个侧产物
-    //    (Remember→memory_saved / task 族 structured 台账 / #117a+#158 bg Bash+Monitor 桥)。
     const callId = typeof m.toolCallId === 'string' ? m.toolCallId : undefined;
-    // 🔴 时序留钉(矩阵 §2.1①):同 assistant 臂 —— label 登记恒在任何 yield 之前。
     recordEngineToolLabel(callId, m.label);
-    // ── #158② bg 子代 alias(2026-08-12)────────────────────────────────────────────────────────
-    // `async_launched` 回执是**唯一**同时握着 {本卡 callId, 引擎 taskId} 这一对的帧,而内容帧
-    // (EventIdentity)只带 parentToolCallId = 本卡 callId。此前 `registerSubagentAlias` 的唯一喂点
-    // 是 task_progress tick,而 bg(async)子代**恒零 tick** ⇒ C1 分流进来的内容永远停在
-    // parentToolCallId 键下,查看态按引擎 taskId 一律取不到(详情页拿不到 per-tool 历史)。
-    // 🔴 位置两条硬理由:① 恒在任何 yield 之前(同 label 登记,矩阵 §2.1①);② 在下面「无对应
-    //    开卡即丢」的早退**之前** —— alias 是 store 的事实,不该由「这张卡还在不在台账里」决定
-    //    (durable 重放/乱序时开卡可能已出栈,而内容账本照样需要这条键)。
-    // 🔴 **只登记内容归账那一半**(`registerSubagentContentAlias`,不是 `registerSubagentAlias`;
-    //    复审收货定形,2026-08-12):那张表承载两件不同的事,方向与基数都不同(分家说明见 store 侧
-    //    该函数头注)。回执**足以**宣告「这个 callId 下的内容属于这个 taskId」(多对一,加一条只会
-    //    更全),但**不足以**改写单值的 `taskToParent` —— 那一位的读口 `parentToolCallIdOf` 是对外的
-    //    C2 steer 投递目标,权威来源是 **wire 的内容帧**;而 SendMessage 复活会为同一 taskId 再发一条
-    //    回执、骑的是**复活那次调用**的 toolCallId,拿它盖掉真正的委派调用 = 用户插话投到错的目标
-    //    (「复活后该按哪个 target 投」要 server 语义作证,本包无从判定 ⇒ 不猜、不写那一位)。
-    //    于是本喂点在 steer 面**零影响**:冲突向不存在,也就不需要「先到者持号」那类到达序启发式。
-    // 幂等:同对重复登记 = 同一个 set 覆盖同值 + 迁移块第二次自然空转。
     if (callId !== undefined) {
         const launched = readAsyncLaunchedAgentReceipt(m.structured);
         if (launched !== null)
             registerSubagentContentAlias(callId, launched.taskId);
     }
     if (callId !== undefined) {
-        // ⟨帧序耦合 4/7⟩ 关卡 settle(sweep 点 1/4)只结**已发布**的面板行:tick 没到过就没有行可结。
         yield* panel.settle(callId, m.isError === true, m.output !== undefined ? flattenWireOutput(m.output) : undefined);
     }
     const p = callId !== undefined ? cards.peek(callId) : undefined;
-    // ⟨帧序耦合 3/7⟩ 无对应开卡的 tool_end(乱序 / 重复)直接丢(cli 同)。
     if (p === undefined || callId === undefined)
         return;
     const structured = m.structured;
-    // 身份键各读一次(0.76.1:此前 typeof 再取值 = 读两次;值随读变的帧会让判形与取值各看一份)。
     const closeEventIdRaw = m.eventId;
     const closeParentRaw = m.parentToolCallId;
     const closeEventId = typeof closeEventIdRaw === 'string' ? closeEventIdRaw : undefined;
     const closeParent = typeof closeParentRaw === 'string' ? closeParentRaw : undefined;
-    // 出栈 + S1 复位(**yield 之前**)已收进 close() —— 见 toolCards.ts 的拆分硬约束。
     yield* cards.close(p, {
         output: m.output,
         structured,
@@ -815,26 +549,18 @@ const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
     const s = structured !== undefined && structured !== null && typeof structured === 'object'
         ? structured
         : undefined;
-    // ── E 层 ①:CC198 gap #2 —— 引擎 Remember 工具 → CC198 automemory「Saved N memories」卡
-    //    (system{subtype:'memory_saved'})。引擎不发写入路径,note 本身就是那一条 writtenPaths。
-    //    上面的 tool_result 照旧走泛化兜底卡(双覆盖);structuredToToolUseResult 的白名单不动
-    //    (Remember 从不进那个 switch)。core 1.217 形 {type:'memory-saved', ok, note, …}。
     if (p.name === 'Remember' && m.isError !== true) {
         if (s && s.ok === true && typeof s.note === 'string' && s.note.length > 0) {
             yield transcript({
                 type: 'system',
                 subtype: 'memory_saved',
                 writtenPaths: [s.note],
-                // cli 用 `new Date().toISOString()` + randomUUID();本包一律走 ctx(可重放)。
-                // 见 DIVERGENCE-7。
                 timestamp: new Date(ctx.now()).toISOString(),
                 uuid: idOf(m, 'memory-saved'),
                 isMeta: false,
             }, ctx.now());
         }
     }
-    // ── E 层 ②:core 1.217 task 族 structured —— 权威全量态精确同步 ctrl+t 面板(引擎真实 id)。
-    //    落盘是宿主职责(T44 拆缝:判定+归一进库、落盘留宿主)。
     if (s && (s.type === 'task' || s.type === 'task-list')) {
         yield chrome({
             kind: 'task_ledger_sync',
@@ -845,49 +571,19 @@ const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
         });
     }
 };
-/**
- * B-074(0.65.0)—— core 明写的**终态那一拍**的两个词。
- *
- * 🔴 **闭二词,而 `status` 本身按开集读** —— 这两件事不矛盾,分工是:投影层原样透传任何词
- *    (词表属主在 core),本表只回答「哪些词**是**终态」。一个包不认识的新词(比如上游哪天加
- *    `cancelled`)走 **running 那条路**,而不是被猜成终态:猜错的代价是把一条还在跑的行提前
- *    结掉,而「多渲一拍 running」只是慢一点。core 的臂注也只承诺这两个词
- *    (`timeout/blocked fold to failed`,即上游自己已经折过了)。
- */
 const TERMINAL_TICK_STATUSES = new Set(['completed', 'failed']);
-// ══ M3 —— task_progress(引擎侧子代的累计 usage tick)══════════════════════════════════════════
 const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
-    // ── B4 A 层最后一臂(MF-10)—— 引擎侧子代的累计 usage tick。
-    // 只带 rollup 数字 = CC `AgentProgress` 同形 ⇒ 忠实的 CC-187 面是 footer 面板行
-    // (CC 自己对进程外 agent 的先例:面板行 + task-notification,从不合成 inline 消息轨)。
-    // **不产任何 transcript 消息**:全是 chrome。
     const taskIdRaw = m.taskId;
     const taskId = typeof taskIdRaw === 'string' ? taskIdRaw : undefined;
     if (taskId === undefined)
         return;
-    const explicitParentRaw = m.parentToolCallId; // 读一次(0.76.1:typeof 再取值 = 读两次)
+    const explicitParentRaw = m.parentToolCallId;
     const explicitParent = typeof explicitParentRaw === 'string' ? explicitParentRaw : undefined;
-    // ── W1 段2([1617]②,frame-lane-matrix #2/#8)workflow lane 门:workflow 子代的 tick 属
-    // fleet lane 自描述行(footer 只渲 workflow 聚合行),**绝不**进前台 subagent lane
-    // (不登 alias、不 bind、不 livePanelTasks、不发 panel tick —— 修前每个 workflow agent
-    // 都在 footer 铸一条幽灵 local_agent 行,还能骑错 run_workflow 卡的 inline stats)。
-    // 判据三级:① 帧带 workflowRunId(一手证据)② wa+16hex 形 id(core BCE 合成 id)
-    // ③ 显式父指向本会话见过的 Workflow 工具卡(实例台账,覆盖 uuid 形子代 id + 跨 turn 迟到 tick)。
-    // 🔴 复审独立发现的拆分风险:**本门必须先于任何 panel 写**,否则重造 workflow 幽灵前台行 ——
-    //    这也是它在本臂第一段、`bind()` 之前的原因,别按「先绑定再分类」重排。
     const workflowRunId = typeof m.workflowRunId === 'string' ? m.workflowRunId : undefined;
     if (workflowRunId !== undefined ||
         isWorkflowAgentTaskId(taskId) ||
-        // ⟨帧序耦合 2/7⟩ 依赖 assistant 臂先登记过那张 Workflow 卡。
         (explicitParent !== undefined && inst.isWorkflowCard(explicitParent))) {
-        // 判据④ 回植([1641] workflow 启动闪 subagent 行案):本门是「这条 taskId 属 workflow」的
-        // **权威判定**。同一 taskId 在 fleet 面还有一条 run 发布器双生行(`${runId} ${taskId}`)
-        // 且那行不带 workflowRunId —— 登进 belt 台账,fleet 行按尾段查它,双生行就再进不了
-        // footer task 树。🔴 写者在本包、读者(isKnownWorkflowAgentTaskId)也在本包 = R4 纪律,
-        // 做成 chrome 臂反而会让「宿主没接线 ⇒ Set 恒空 ⇒ 判据④ 静默失效」复活。
         recordWorkflowAgentTaskId(taskId);
-        // CC-37(0.72.2):own 台账同拍登记 —— 只在「帧带 workflowRunId ∧ 父是本会话见过的 Workflow 卡」这一形
-        // (own-run 正向证明);光有 workflowRunId 不够(老引擎对 fleet 行帧广播,别的会话的 run 也会带它)。
         if (workflowRunId !== undefined && explicitParent !== undefined && inst.isWorkflowCard(explicitParent))
             noteOwnWorkflowRun(workflowRunId);
         ctx.probe?.('tick', JSON.stringify({
@@ -902,12 +598,8 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         }));
         return;
     }
-    // C1 alias:content 帧只带 parentToolCallId(EventIdentity 上没有 taskId),这条 tick
-    // **两者都带** —— 是 store 学到「停放的内容属哪条引擎行」的唯一位置(查看态按引擎 task id 查)。
     if (explicitParent !== undefined)
         registerSubagentAlias(explicitParent, taskId);
-    // 复审修 #1:含糊回落(无显式父 + >1 张未绑候选)⇒ 保持 unbound。
-    // ⟨帧序耦合 1/7⟩ FIFO 猜父只看**此刻还开着**的卡,所以 assistant 开卡帧必须先到。
     const cardId = explicitParent === undefined && !panel.isBound(taskId) && panel.unboundCandidates() > 1
         ? undefined
         : panel.bind(taskId, explicitParent);
@@ -921,14 +613,8 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         currentAction: m.currentAction ?? null,
         toolUses: usage.toolUses ?? null,
     }));
-    // core 1.262.0 [558]B / service 1.154.0 [579] —— 子代的活体"我在干什么"一行
-    // ("Bash npm test"),service 已 redact。PROGRESS 语义(喂状态/摘要显示槽),不是诊断。
-    // 老引擎缺席 ⇒ 两个消费面维持今天的显示。
     const currentAction = typeof m.currentAction === 'string' && m.currentAction.length > 0 ? m.currentAction : undefined;
-    // 0.75.1 CC-95(a)—— `spawnName`:sdk 9.8.1 的 `task_progress` 臂上还没有这一位(新形才铸),所以按
-    //   **结构读**取(不靠型面),非空串才算数;缺席 = 旧形,不编。
     const spawnName = m.spawnName;
-    // inline 群组行孪生:**绑定了**的 tick 同时喂转录里那条行的统计(按委派卡 id 键)。
     if (cardId !== undefined) {
         yield chrome({
             kind: 'inline_task_stats',
@@ -944,8 +630,6 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         });
     }
     const card = cardId !== undefined ? cards.peek(cardId) : undefined;
-    // T50 双形读:`rawInput` 是**改名前**捕获的,真 wire 上引擎子代的 input 是
-    // {agent, task, taskName} —— 两形都读(CC 名优先)。
     const input = (card?.rawInput ?? {});
     const description = typeof input.description === 'string'
         ? input.description
@@ -959,20 +643,8 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
         : typeof input.task === 'string'
             ? input.task
             : undefined;
-    // #6 常驻台账的两个写口整臂让位给 M3(module store 不许两个模块各写各的)。
-    // 0.74.3 CC-70:常驻标记在**归一后的键**下(fleet 尾段 = 通知车道清标用的那把);此前 UUID 记、17 位清 ⇒ 永不清。
-    // 🔴 0.75.1 CC-95(b):归一必须在 `panel.start` **之前**算 —— 子代类型的诚实来源是 fleet 行帧的 `agentType`,
-    //    而那本账按**行 id 尾段**记,拿 wire 的 UUID 是查不到的。
     const identity = resolveEnginePanelTaskId(taskId, explicitParent);
-    // ⟨帧序耦合 5/7⟩ 首 tick 才 fire Start,而通知臂的 if-started 门读的就是它。
     if (!panel.isLive(taskId)) {
-        // 这条引擎子代在壳侧**可观测的起点** = 本 turn 的首 tick。
-        // 🔴 0.75.1 CC-95(b)子代**类型**的诚实来源(此前取的是 `m.name` = 上游由委派卡 description 派生的**展示名**
-        //    ⇒ 宿主的子代启动 hook 收到的是任务描述,一个看起来合理的错答案):
-        //      ① wire `task_progress` 上的结构读类型键 —— 亲核 sdk 9.8.1 `dist/events.d.ts` 的 `task_progress` 臂:
-        //         **没有** `agentType`、也没有 `spawnAgentType`,这条 lane 今天不报类型 ⇒ **有出处才读**,所以不读;
-        //      ② fleet 行帧的 `agentType`(sdk `FleetTaskRow.agentType`,§K-7 短类型 label)—— 按归一后的尾段查;
-        //      ③ 都没有 ⇒ **键缺席**(宿主 hook 侧按 absent 兜底,不编 `subagent`)。
         yield* panel.start(taskId, fleetRowAgentType(identity.taskId));
     }
     panel.noteResidency(taskId, identity.taskId);
@@ -984,65 +656,27 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
             kind: 'tick',
             taskId,
             ...(typeof m.name === 'string' && m.name.length > 0 ? { name: m.name } : {}),
-            // 0.75.1 CC-95(a):派生这只子代时被声明的名字(wire `task_progress.spawnName`)。结构读、非空串才带;
-            //   缺席 = 旧形的产生者 ⇒ 键不落(不编、不拿展示名 `name` 冒充 —— 两位是两位)。
             ...(typeof spawnName === 'string' && spawnName.length > 0 ? { spawnName } : {}),
             ...(description !== undefined ? { description } : {}),
             ...(prompt !== undefined ? { prompt } : {}),
             ...(currentAction !== undefined ? { currentAction } : {}),
-            // 0.74.3 CC-70:身份归一的两把钥匙 —— 退路键 + 发布方提示(绑卡 = 同步委派,漏斗不用等 fleet 行)。
             ...(explicitParent !== undefined ? { parentToolCallId: explicitParent } : {}),
             ...(panel.isLiveBound(taskId) ? { cardBound: true } : {}),
-            // 🔴 这里的 `: 0` 与 `fleetAgentPanelProjection` 那句「绝不在本层 `?? 0`」**不矛盾**,
-            // 因为不是同一条 lane 的同一种供给形(两层的分层实情写在 `engineAgentPanelStore.ts`
-            // 的 `PANEL_TOOLUSES_LANE_POLICY` 上,两条 lane 的可选性由编译钉锁住):
-            //   · **tick lane(本处)**:`usage` 是 core `task_progress` 臂的**必填**字段
-            //     (core 2.12.0 `dist/core/types.d.ts:606-610` 无 `?`),两处发帧点
-            //     (`runner/runtask.js:1080` 每轮边界 / `:2925` 终态 settle 拍)**无条件**构造
-            //     `{ totalTokens, toolUses: stats.toolCalls, durationMs }`,server 白名单整键透传
-            //     (`trace/project.js:118`)⇒ 缺席在这条 lane 上不是「不知道」,是**没有这种帧**。
-            //     值本身是**累计**计数(`stats.toolCalls`,从 0 起算),所以真值域含真 0。
-            //   · **fleet-row lane(那处)**:同名键是 server 1.278.0 才**新加**的可选位,老引擎
-            //     真的不发 ⇒ 缺席就是「不知道」,兜 0 会把它冒充成「跑了 0 个工具」,而且会把
-            //     台账里已知的累计值**擦回 0**。
-            // ⚠️ 别把两层「统一」:把本处改成传播缺席要先把事件形改成可选,而那正是本 lane
-            // 刻意不做的事(`engineAgentPanelStore.ts:54-57` 记的就是这条 —— 复用同一个可选形
-            // 会让 fleet-row lane 每秒把前台子代由真 tick 写进去的进度数字清一次)。
             toolUses: typeof usage.toolUses === 'number' ? usage.toolUses : 0,
             totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
         },
     });
-    // ── B-074(0.65.0)终态那一拍 ────────────────────────────────────────────────────────────
-    // 修前本臂的头注写着「**子代从不发终态 tick**,父卡的 tool_end 就是完成信号」—— 那句话在
-    // core 7.x 上已经是假的(`task_progress.status` 的臂注逐字:`ONE final tick fires at the
-    // sub-run's settle with the terminal face`,理由也写死了:`so a uuid-lane consumer sees the
-    // row finish instead of a bare removal after the last running beat`)。
-    //
-    // 🔴 **为什么落在臂尾、而不是一进来就早退**(异源对抗复审实抓的两条真回归,别按「先判终态再
-    //    干活」重排):终态那一拍带的是子代的**最终**累计数字。早退会让
-    //    ① 面板行与 inline 群组行**冻在倒数第二拍**(实测 3 次工具 /150 tokens 被冻成 2 次 /100);
-    //    ② 后到的关卡 settle 撞 `endedPanelTasks` 判重而整条让位 ⇒ 子代的**最终报告**(委派卡的
-    //       output,只有关卡那条腿带得动)从此到不了面板行。
-    //    所以这一拍**照常走完上面的 tick 半场**(数字先落地),只在最后多一件事:落终态。
-    //
-    // 🔴 **只落「关卡腿不会来收」的那些行**(`!panel.isLiveBound`):绑在本 turn 还开着的卡上的行
-    //    由 `panel.settle(cardId, isError, report)` 收 —— 那条腿带着最终报告,在这里抢先落行就是
-    //    把报告挤掉(上面 ②)。未绑 / inert 绑定(跨 turn bg 子代)= session 常驻行,关卡腿不碰它,
-    //    它今天只认通知帧 —— 那正是 core 说的 uuid lane,也正是本件要救的那一条。
-    // 🔴 **开集第四词不当终态**:词表属主在 core(`TERMINAL_TICK_STATUSES` 头注)。
     if (typeof m.status === 'string' && TERMINAL_TICK_STATUSES.has(m.status) && !panel.isLiveBound(taskId)) {
         ctx.probe?.('tick', JSON.stringify({ t: ctx.now(), taskId, lane: 'foreground', settle: m.status }));
         yield* panel.settleFromTerminalTick(taskId, m.status === 'failed');
     }
 };
-// ══ M1 / M6a —— stream_event / turn_usage ══════════════════════════════════════════════════════
 const streamEventArm = function* (m, { text }) {
     const ev = m.event;
     if (ev && ev.type === 'text_delta' && typeof ev.delta === 'string') {
         yield* text.feedText(ev.delta, m);
     }
     else if (ev && ev.type === 'thinking_delta' && typeof ev.delta === 'string') {
-        // 子流(parentToolCallId)的推理绝不喂 leader 的计数与预览(#9 的壳侧半场)。
         if (ev.parentToolCallId !== undefined)
             return;
         yield* text.feedThinking(ev.delta, m);
@@ -1050,29 +684,14 @@ const streamEventArm = function* (m, { text }) {
 };
 const turnUsageArm = function* (m, { text, flags }) {
     const ot = typeof m.outputTokens === 'number' ? m.outputTokens : undefined;
-    // 🔴 0.68.0(异源对抗复审轮五实抓)——**两件事分家**:
-    //   · 「这一轮结束了」⇒ 无条件 drain + 压下一 model round 的基线(TTFT 那一拍);
-    //   · 「这一轮花了多少」⇒ 只有**真有数字**时才发 end 度量。
-    //  #711 之后,缺账轮这一拍**没有数字可发**(占位零不许当读数)。修前两件事合在
-    //  `emitTurnUsageEnd` 一个动作里 ⇒ 过滤掉数字就连**模型轮边界**也一起过滤掉了:下一轮不再发
-    //  `response_metrics{start}`,它的用量按**上一轮**的基线对账(整链实测:首轮 400 字符缺账、
-    //  次轮 4 字符 + 50 tokens,计数从 150 掉到 101,下一轮的 TTFT 记录一并丢失)。
     yield* text.drainLive();
     if (ot !== undefined) {
-        // ⟨帧序耦合 7/7⟩ 这一拍置 endEmitted,后到的 result 臂据它决定要不要补发 end 度量。
         yield* flags.emitTurnUsageEnd(ot);
     }
     else {
-        // 🔴 不发假零度量,但边界照压(`endEmitted` **不置** —— 终帧若真有一笔账,补发腿仍该补)。
         flags.noteModelRoundBoundary();
     }
 };
-// ══ M0 编排半场 —— result(收口三形之一;与 D7/D8 的次序差异见矩阵 §2.4,不可归一)═══════════════
-/**
- * `whole` 是不是以 `part` 开头 —— 先逐字节比,再容忍**引擎侧的首部修剪**(`result` 出厂 `.trim()` 过,
- * 而屏上那份是原文)。命中时返回**真正对上的那个前缀**(调用方按它的长度切后缀,切点才不会错位)。
- * 两条都不成立 ⇒ `null`(= 不是前缀关系,由调用方落分岔臂)。
- */
 function prefixOf(whole, part) {
     if (whole.startsWith(part))
         return part;
@@ -1083,46 +702,22 @@ function prefixOf(whole, part) {
 }
 const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
     yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
-    // MF-10 防御 sweep(sweep 点 2/4):结掉那些卡从没关过的行(流被截断)。
-    // cli 同位:setRetryStatus(null) 之后、开卡兜底关闭之前。
     yield* panel.settle(null, false);
-    // B5:开卡兜底关闭(cli 同位 —— 在终答文本**之前**,卡才不会挂着空白)。
     yield* cards.sweep();
-    // 🔴 矩阵 §2.4(b):本臂 takeThinking 在 metrics **之前**、takeAnswerSegment 在 metrics **之后**,
-    //    与 T60 尾的连续两拍**不同序**。看着像可以归一,不能。
     yield* text.takeThinking();
     yield* flags.emitResultEndIfNeeded(() => {
         const u = m.usage;
         const ot = typeof u?.outputTokens === 'number' && Number.isFinite(u.outputTokens) ? u.outputTokens : undefined;
-        // ── 🔴 0.68.0(#711 同形的**第四处**,异源对抗复审轮二实抓)────────────────────────────────
-        // 这是终帧的**补发腿**:`turn_usage` 那一拍没发过 end 度量时,由它拿终帧的 usage 补一发。
-        // 而 core 7.17.0 之后,一轮没量出账的 run,它的终帧 usage 是**占位全零**(同帧的
-        // `_sema_usage_lower_bound` 才是那句「这笔账不知道」)⇒ 修前这里会补发一条**没有任何判别位**
-        // 的 `response_metrics{phase:'end', outputTokens: 0}`,而本臂的宿主义务逐字是「驱动
-        // responseLength reducer(ttft/对账)」—— 一条精确零会被当成一次真的「这一轮吐了 0 个 token」。
-        // 同一条判据在本包一共五处:公面读器 `turnEndUsage`(`eventToSdkMessage.ts`)/
-        // `turn_usage.outputTokens` / 子代分表 `cacheReadTokens` / `RunStreamHandle`(三处在
-        // `adapter/runStream.ts`)/ **本处**。前四处收口了而这条**消费链的末端**没跟上 = 过滤没贯穿到底。
-        // ⇒ 同一条判据:**下界位在场且读数是 `0` ⇒ 那是占位,不补发**(`outputTokens` 读不出时本来
-        //    就不发,这一形沿用既有的那条路);**非零照发** —— 占位恒为 0,非零必是真的量到过,
-        //    连带丢掉它会让一条有产出的缺账轮在对账面上凭空少一笔。
         const lowerBound = m._sema_usage_lower_bound === true;
         return lowerBound && ot === 0 ? undefined : ot;
     });
     yield* text.takeAnswerSegment();
-    // 具名成 terminalText:M1 收编后 `text` 是流合并器的名字,原来的同名局部会遮蔽它。
     const terminalText = typeof m.result === 'string' ? m.result : '';
-    // 🔴 比较对象 = 引擎「最后一条 assistant 消息」在屏上那段(0.63.2):卡后零散文时回退到卡前那条
-    //    (provider 一条消息 = [text, tool_use];空串是任何终帧的前缀 ⇒ 拿空串比会把整段终帧再渲一遍)。
     const committed = text.lastCommittedAnswerText;
-    // L-215③:同上,身份位取一次(终帧补差腿**只接 `model`**,理由见块内注)。
     const terminalIdentity = messageIdentityOf(m, ctx);
     const emitTerminal = function* (body, tag) {
         yield transcript({
             type: 'assistant',
-            // L-215③ 族扫:终帧补差腿。🔴 这条消息的**正文是终帧的 `result`**,不是某条内容帧 ——
-            //    所以只接 `model`(那是整条流的事实),**不接 `id`**:把终帧的 eventId 当成一条
-            //    assistant 消息的身份,会让宿主把「补差出来的那一段」与终帧本身当成同一条东西。
             message: {
                 role: 'assistant',
                 content: [{ type: 'text', text: body }],
@@ -1134,43 +729,23 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
         }, ctx.now());
         text.markEmittedText(body);
     };
-    // ── 终答与已上屏正文的五格(0.62.0 补后四格;修前只有第一格)────────────────────────────────
-    // 病形:断线前已经流过一部分正文、重连后终帧带的是**完整**那份 ⇒ `emittedAssistantText` 为真,
-    // 于是整条终答兜底被跳过,而屏上永远缺断线期间那一截,且没有任何东西说少了。
-    //
-    // 🔴 **比较的两边必须是同一种东西**(车内异源复审逼出的真病):终帧 `result` 在引擎侧取的是
-    //    **最后一条** assistant 消息的文本、且 `.trim()` 过,不是整轮正文的拼接。所以左边读的是
-    //    `committedAnswerText`(**当前这条消息**已上屏的正文,工具边界重置),不是本 turn 全部正文;
-    //    并且相等判定先过一次 `trim()`——否则「散文 → 工具 → 散文」这种再正常不过的多步回答,
-    //    以及任何只差首尾空白的回答,都会被判成分岔。
     if (!text.emittedAssistantText) {
-        // ① 一个字都还没上屏 ⇒ 终帧那份就是全部答复,整段渲(修前的唯一行为,逐字保留)。
         if (terminalText.length > 0)
             yield* emitTerminal(terminalText, 'terminal-text');
     }
     else if (terminalText.length === 0) {
-        // ② 终帧没带正文 ⇒ 无事可做(它不是「答复是空的」这句话)。
     }
     else if (committed.trim() === terminalText.trim()) {
-        // ③ 两份**是同一段话**(引擎那一位出厂就 `.trim()` 过,所以逐字节比会在纯空白差上假红)⇒ 无事可做。
-        //    这一格必须排在前缀两格**之前**:否则一个只差首尾空白的正常 turn 会掉进补差或分岔臂。
     }
     else if (prefixOf(terminalText, committed) !== null) {
-        // ④ 已上屏那段是终帧那份的**前缀** ⇒ 只补吐**后缀**那一截。
-        // 🔴 只补差不重渲:重渲整段会让屏上出现同一段话两遍(前半还是逐字重复的),那比缺一截更坏。
         const matched = prefixOf(terminalText, committed);
         const suffix = terminalText.slice(matched.length);
         if (suffix.length > 0)
             yield* emitTerminal(suffix, 'terminal-text-suffix');
     }
     else if (committed.startsWith(terminalText)) {
-        // ⑤ 终帧那份是已上屏那段的前缀(引擎侧修剪/截断)⇒ **不动**:屏上已经不少任何东西,
-        //    补吐没有对象,而拿一份更短的去覆盖更长的会把用户已经读到的内容抹掉。
     }
     else {
-        // ⑤ 两份**互相都不是对方的前缀** ⇒ 从某处起就分了岔。库刻意**什么都不补吐**(谁算数只有引擎
-        //    说得清;把终帧那份接在屏上那段后面会拼出一段谁都没说过的话),只给宿主一个事实位让转录行
-        //    改口。两个位是**长度**不是内容 —— 不复述任何一份正文。
         yield chrome({
             kind: 'result_text_diverged',
             laneProof: mainLane(),
@@ -1179,21 +754,14 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
         });
     }
 };
-// ══ M4 —— 通知族 ═══════════════════════════════════════════════════════════════════════════════
 const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
     const n = (m.notification ?? {});
     const fields = normalizeTaskNotification(n);
     if (fields === null)
-        return; // 空/缺 task_id:RB-75 同族,丢弃
+        return;
     const taskId = fields.taskId;
     const rawStatus = fields.status;
-    // L-215② 族扫(0.65.0):终局判据走单铸谓词 —— 修前手抄三词,core [6908] 的 `blocked`
-    //   漏在外面 ⇒ 一条自报走不下去的后台行**永远不 settle**(面板上挂着一条不会再动的「在跑」)。
     const terminal = isTerminalStatus(rawStatus);
-    // #117a settle 半场 —— **故意在渲染去重之前**:settle 幂等,重放帧仍须 settle 一条
-    // 首投之后才注册的行。#47 矩阵 #7:只有 bash/monitor 行(或老引擎无 task_type)能被 settle
-    // (#158:monitor 行注册进面板后,它的终局通知也得能关行;事件帧 status="event" 非终态,
-    // 由下方 terminal 门挡——事件流绝不错关行)。
     const settleAllowed = n.task_type === undefined || n.task_type === 'background_bash' || n.task_type === 'monitor';
     if (settleAllowed && terminal) {
         yield chrome({
@@ -1212,12 +780,9 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { seq: n.seq } : {}),
         ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
     });
-    // 🔴 时序留钉(矩阵 §2.1④ 的 1377 行判定:**有意序**,别挪):记号在 yield 之前落 ——
-    //    代价是早退窗内该通知既不渲也不再重放(丢一条),而反向(add-after-yield)是重放双渲,更坏。
     if (inst.hasRenderedNotification(dedupKey))
         return;
     inst.addRenderedNotification(dedupKey);
-    // B1 + #6 —— 必须在 cardEnqueued 早退**之前**:probe 合成先入队的场景恰是双投主形。
     if (n.task_type !== 'external' && terminal) {
         yield chrome({
             kind: 'notification_terminal',
@@ -1226,59 +791,16 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
             status: rawStatus,
             ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
         });
-        // B1 —— 这帧 = 引擎 server-side steer-inject 的回声,模型已在引擎侧收到一遍;把还躺在
-        // 队列里的同 run Path B 条目(workflow_complete/probe/bg feeder)在 turn 收口 drain 前
-        // 丢弃,免得 idle auto-submit 再喂模型一遍(跨进程双投的客户端半场)。
-        // 🔴 B4 起由**适配器自持**(B2 已把队列端口搬进本包):此前挂在 `notification_terminal`
-        // 的宿主义务①,是「说得通但没人做」的典型 —— 宿主没接线就静默双投。
         dropQueuedNotificationsForRun(taskId);
-        // 🔴 这道门与上面的 `settleAllowed` 配对的是**显式的 bash/monitor 两族**:它们被
-        //    bgshell_settle 关过一次的行,就不该再被**子代面板**的 settleFromNotification 关第二次。
-        //    ⚠️ 两半**不是**字面同一个谓词,别顺手写成 `if (!settleAllowed)`:settleAllowed 还放行
-        //    `task_type === undefined`(老引擎缺类型位的兼容腿),那一支是**有意**的双投兼容 ——
-        //    不知道它是哪族,两个面板都关一次比漏关一个面板好。只有显式说了自己是 bash/monitor 的
-        //    帧才配对排除。#158 复审车B 修:放行 monitor 那一批漏了这半 ——
-        //    monitor 终局帧同时发 `bgshell_settle` 与 `panel_task{kind:'end'}` 两条,同一个 taskId
-        //    在两个面板语义上各关一次。壳侧只是**碰巧**没出事(bgshell_settle 先 yield 把行翻成终态,
-        //    随后 useEngineAgentPanelBridge 的 settle() 撞上 `status !== 'running'` 早退 —— 但那个
-        //    settle() 根本没有行类型门,靠的是 yield 顺序而不是判据);sema-web 那端是**真错**:
-        //    turn-mapping.ts panel_task/end 臂固定发 `status: isError ? 'failed' : 'completed'`,
-        //    于是 killed 的 monitor 行先被 bgshell_settle 正确记成 killed,再被这条覆盖成 failed。
         if (n.task_type !== 'background_bash' && n.task_type !== 'monitor') {
-            // ⟨帧序耦合 5/7⟩ #6 通知-settle 边(推送半场)整段让位给 M3 —— 拆分前这里直写
-            // endedPanelTasks 又直读实例台账的 firedSubagentStartHookTaskIds,是矩阵点名的两条跨模块面。
             yield* panel.settleFromNotification(taskId, rawStatus !== 'completed');
         }
     }
-    // ── design/385:三条引擎注入车道的判定**必须在下面那道完成卡早退之前**做 ────────────────
-    // 🔴 异源对抗复审 r2 [high] 实测的吞消息形:`isWorkflowCompletionCardEnqueued(taskId)` 回答的是
-    //    「这个 run 的**完成卡**是不是已经入过队」,与「这一帧是不是一条同事消息」毫无关系。而一个
-    //    子代**续跑**时复用同一个 taskId(`_sema_provenance.taskId === task_id === senderId`,core
-    //    7.2.0 uplink 铸点直证),它的合法 `agentMessage` 帧就会在这道早退上被整条丢掉:零转录输出,
-    //    且渲染去重账已经记过 ⇒ 重放也补不回来。复现序:先 `noteWorkflowCompletionCardEnqueued(id)`,
-    //    再送同 id 的 uplink 帧 ⇒ 修前只剩 chrome 收尾事件、消息正文完全缺席。
-    //    ⇒ peer 帧**豁免**这道早退(它不是完成卡,不参与完成卡的双通道去重)。
     const peerFrame = classifyPeerNotification(n);
-    // 双通道反向去重:probe 合成的完成卡已入队 ⇒ 后到的推送帧只做上面的记账,不渲第二条。
-    // 🔴 B5 ①:读的是 **module 台账**(cli `isWorkflowCompletionCardEnqueued` 逐字)——
-    //   记账方(两个 enqueue + idle watcher)与清账方(上面的 drop)都在那儿。
     if (peerFrame === null && n.task_type !== 'external' && isWorkflowCompletionCardEnqueued(taskId))
         return;
-    // 跨通道记账(cli markEngineWorkflowNotified 同位、同条件:非 external,不看终态):
-    // 这帧到达 = 引擎已 server-side steer-inject 过,补发通道(workflow_complete)不得再注入。
-    // external 豁免([769] 对抗复审收紧:external 从不经补发通道,mark 只会缴械 probe 兜底)。
-    // 🔴 **peer 帧同样豁免**(异源对抗复审 r3 [high],实测:投一条合法 uplink 之后再给同 taskId 入队
-    //    `{status:'completed'}`,队列恒 0、`bgCrossChannelDropped` +1)。这本账问的是「这个 run 的
-    //    **完成**是不是已经被引擎注入过」——而一条同事**消息**不是完成事件(三条 peer 铸点的
-    //    `status` 都是 `"event"`,core 直证)。子代跑到一半发了句话就把这本账写脏,它自己真正的
-    //    空闲期完成通知随后被补发通道整条丢掉,用户只能等下一次开流才可能看见。
     if (peerFrame === null && n.task_type !== 'external')
         markEngineWorkflowNotified(taskId);
-    // 判定单源 = `classifyPeerNotification`(载体在场判别,绝不锚 summary 文本);认不出 ⇒ `null`
-    // ⇒ 这一行与本臂此前**逐字节等价**(三条载体一个都不在场的载荷 = 今天的全部载荷,老宿主零差异)。
-    // 🔴 除上面那道完成卡早退之外,其余账**全不动**:去重键 / settle / 面板 / 跨通道 mark 判的是
-    //    「哪个 task 的哪个状态」,与这条通知在模型面穿哪件外衣无关,跟着换会把几条独立的账搅成一本。
-    //    (uplink 帧的 `status` 是 `"event"` —— core 7.2.0 铸点直证 ⇒ 终态那几条腿本来就不会对它开火。)
     yield transcript({
         type: 'user',
         message: {
@@ -1294,34 +816,15 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
         session_id: ctx.sessionId,
     }, ctx.now());
 };
-/**
- * ⚠️ 本臂声明成 `ProjectionArmFn`(碰不到五个适配器状态模块),但它**有副作用** ——
- * 写 notifications.ts 的 module 台账。两级 deps 证明的是「不碰适配器状态」,不是「纯」。
- */
 const workflowCompleteArm = function* (m) {
     const runId = typeof m.runId === 'string' ? m.runId : undefined;
     if (runId === undefined)
         return;
-    // 跨通道去重(cli enqueueEngineWorkflowNotification 首行):该 run 已由推送帧记账过
-    // (引擎 server-side 注入过)⇒ Path B 绝不再喂模型一遍。
-    // 🔴 B5 ①:门与记账都在 module 台账 —— cli 里这一整段就是 enqueueEngineWorkflowNotification
-    //   的前三行,probe/idle watcher 合成的那两条链写的也是它。
-    // 🔴 B6 契约钉死(见 seam.ts 本臂注释「门归包、投递归宿主」):门 + 下面两条记号
-    //   (markEngineWorkflowNotified / noteWorkflowCompletionCardEnqueued)**都在库内**,
-    //   宿主拿到臂只管裸入队。宿主若借自带同一道门的老函数投递 ⇒ 恒早退、一条都进不了队列。
     if (isEngineWorkflowNotified(runId))
         return;
     markEngineWorkflowNotified(runId);
     const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
     const wfSummary = typeof m.summary === 'string' ? m.summary : '';
-    // 🔴 B6 时序修(先红后绿,pure 门「早退 ⇒ cardEnqueued 仍落」):这一行原本在 `yield`
-    //   **之后** —— 生成器在 yield 处挂起,后面的语句只有消费者**再要下一个值**时才跑;
-    //   消费者早退(turn 中止 / `it.return()`)时它**永不执行**。而同臂的
-    //   `markEngineWorkflowNotified` 在 yield 之前恒执行 ⇒ 两条记号一条恒落一条条件落,
-    //   且方向正好是坏的那个:notified 落了 ⇒ idle watcher 不补发;cardEnqueued 没落 ⇒
-    //   推送帧到达时判不出卡的所有权 ⇒ **渲第二张完成卡**(B1c 反钉②)。
-    //   现存驱动全是走完整流的 `for await`,所以这条路径此前从未被断言过([1521]F1 同形)。
-    //   两条记号必须同在 yield 之前落 —— 「臂已发出」这件事在 yield 那一刻就已成立。
     noteWorkflowCompletionCardEnqueued(runId);
     yield chrome({
         kind: 'workflow_notification_enqueue',
@@ -1329,19 +832,12 @@ const workflowCompleteArm = function* (m) {
         runId,
         status: wfStatus,
         summary: wfSummary,
-        // 模型面正文照铸(宿主直接入队即可,不必各自拼 XML;与 core 的 tag/段序同形)
         message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
     });
 };
-// ══ M6b —— retry_status ════════════════════════════════════════════════════════════════════════
 const retryStatusArm = function* (m, { ctx, flags }) {
-    // #47 矩阵 #5:子代 lane 帧绝不骑主 spinner(无判别守卫的无条件 store 写=默认可疑)。
     if (typeof m.parentToolCallId === 'string')
         return;
-    // 🔴 十一键全转(0.55.0;首建 #3004 跟修批 2026-08-08):此前这里只挑 phase/detail/retryInSec 三键,attempt /
-    //    maxRetries / retryInMs 被剥在本层 —— 而 server 两腿的 brainStatusEventData 是全发的,
-    //    `RetryStatus` 上也早就留好了 attempt/maxRetries 两位。键集真源 =
-    //    `BRAIN_STATUS_PAYLOAD_KEYS`(engine-vocab G2-c 对实装 core 对账)。
     const status = mapBrainStatusToRetry({
         phase: typeof m.phase === 'string' ? m.phase : '',
         ...(typeof m.detail === 'string' ? { detail: m.detail } : {}),
@@ -1349,46 +845,20 @@ const retryStatusArm = function* (m, { ctx, flags }) {
         ...(typeof m.retryInMs === 'number' ? { retryInMs: m.retryInMs } : {}),
         ...(typeof m.attempt === 'number' ? { attempt: m.attempt } : {}),
         ...(typeof m.maxRetries === 'number' ? { maxRetries: m.maxRetries } : {}),
-        // 七键(#307 S44,2026-08-19):core 5.43.0 起 `BrainStatus` 带 `errClass`(等待原因分桶)。
-        // 剥掉它 = 用户看得到「在等」看不到「为什么等」,而供给方是发了的。
         ...(typeof m.errClass === 'string' ? { errClass: m.errClass } : {}),
-        // ── 九键(0.48.0;core 7.0.x #506 ㋑,server ≥7.53 `brainStatusEventData` 两腿全发)────
-        // 🔴 与上面那条 errClass 是**同一个病形的第三、第四例**:上游真发、本层这层白名单闭形剥掉。
-        //    族扫真源 = 实装 core 的 `BrainStatus` 整个键集(engine-vocab G2-c 逐键等值门),
-        //    不是「派工单点名了哪一个」——本批点名的只有 errorStatus,retryAtMs 是族扫捞出的存量漏键。
-        //  · `retryAtMs`   产生者铸的墙钟截止点(端渲倒计时的权威锚;剥掉它端只能自己 now+剩余量
-        //                  现算,而那个算法在每个 30s 重播片上重新起跳 —— core 顶注点名的病)。
-        //  · `errorStatus` 刚失败那次尝试的 HTTP 状态(CC `system/api_retry.error_status` 同一个数;
-        //                  剥掉它 = 用户看得到「在重试」却看不到「谁失败了/该不该等」)。
         ...(typeof m.retryAtMs === 'number' ? { retryAtMs: m.retryAtMs } : {}),
         ...(typeof m.errorStatus === 'number' ? { errorStatus: m.errorStatus } : {}),
-        // ── 十一键(0.55.0;core 7.3.0 #530,server ≥7.58 `brainStatusEventData` 放行)──────────
-        // 🔴 **同一个病形的第五、第六例**,而且这一次剥掉的是**新相的全部内容**:
-        //    `waiting_first_token` 帧上除了 phase 就只有这两位携带信息(它不带 retryIn*/attempt/
-        //    errClass/errorStatus —— core 明说本相不宣告等待)。这层白名单不跟车,`mapBrainStatusToRetry`
-        //    的新 `waiting` 臂就只能收到一个空壳:kind 对了、秒数永远缺席,屏上那行渲不出「等了多久」。
-        //    ⇒ 加相**必同批加键**;键集真源仍是实装 core 的 `BrainStatus` 整个键集(G2-c 逐键等值门)。
         ...(typeof m.elapsedMs === 'number' ? { elapsedMs: m.elapsedMs } : {}),
         ...(typeof m.timeoutMs === 'number' ? { timeoutMs: m.timeoutMs } : {}),
     }, ctx.now());
-    // `status === null` = 引擎直报 `recovered`(重试成功)。这一拍是**清除腿之一** —— 但间接腿
-    // (TurnFlags 的「主 lane 内容帧到达即清」)可能已经清过了:已安装 core 在内容流跑完的 finally
-    // 里发 `recovered`,所以 `retrying → 内容 → recovered` 才是常态顺序。故用 `takeRetryOverlay()`
-    // 的**原子读落**决定要不要发:旗还在 ⇒ 发这一发并落旗;旗已落 ⇒ 沉默(没有覆盖层可摘)。
-    // 首版写成「无条件发 + clearRetryOverlay」,在常态顺序上双清(对抗复审命中)。
     if (status === null) {
         if (flags.takeRetryOverlay())
             yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
         return;
     }
     yield chrome({ kind: 'retry_status', laneProof: mainLane(), status });
-    // ⟨帧序耦合 6/7⟩ 挂旗;下一个主 lane 内容帧到达时由 TurnFlags 的帧前置清掉(恢复即清)。
     flags.noteRetryOverlay();
 };
-/**
- * 帧类型 → 臂。**Map 而不是对象字面量**:`{type:'__proto__'}` 这种 UNTRUSTED 帧命中对象表
- * 就是原型污染(复审结论 3)。表里查不到 = 拆分前 `switch` 的 `default:` 空臂,行为同。
- */
 export const ARMS = new Map([
     ['assistant', assistantArm],
     ['user', userArm],
@@ -1408,18 +878,13 @@ export const ARMS = new Map([
     ['engine_notice', engineNoticeArm],
     ['text_end', textSegmentEndArm],
     ['reasoning_end', thinkingSegmentEndArm],
-    // CC-08(0.71.0):两条新帧的 chrome 臂(additive;不接 = 看不见,不属行为丢失)。
     ['tool_disclosure', toolDisclosureArm],
     ['tool_progress', toolProgressArm],
     ['tool_roster_delta', toolRosterDeltaArm],
     ['context_usage', contextUsageArm],
-    // CC-89(0.75.0):压缩的非 compacted 结局(additive;不接 = 压缩失败对用户不可见)。
     ['compaction_outcome', compactionOutcomeArm],
-    // CC-91(0.76.0):这一次 prepare 的提示词装配清单(additive;不接 = 端只能按本地镜像自己估)。
     ['prompt_assembled', promptAssembledArm],
     ['wiring_manifest', wiringManifestArm],
-    // B-078 / L-208(0.65.0):design/172 流内审批两帧 —— 修前它们在投影层就 `dropped`,
-    // 壳自己另接一份 ⇒ desktop/web 拿不到卡集与撤卡(归层违例)。
     ['approval_request', approvalFrameArm('approval_request')],
     ['approval_revoke', approvalFrameArm('approval_revoke')],
     ['prompt_suggestions', promptSuggestionsArm],