@sema-agent/client-core 0.12.1 → 0.13.0

package/dist/adapt.js

@@ -1,174 +1,21 @@
-import { deriveTranscriptId } from './seam.js';
-import { dropQueuedNotificationsForRun, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, parseTranscriptNotificationSeeds, renderTaskNotificationXml, taskNotificationDedupKey, } from './notifications.js';
-import { mapBrainStatusToRetry } from './retryStatus.js';
-import { steeringInjectedToAttachments } from './steering.js';
-import { projectDiagnosticsFrame } from './diagnostics.js';
-// ── B4:A 层搬入后适配器**自持**的四个本包台账(写者与读者同包 = R4 单实例纪律;
-//    这四件都没有 UI 订阅面,做成 chrome 臂只会凭空长出一条「宿主不实现就静默失效」的义务)。
-// ── B5:B/D/E 层(工具结果卡)。纯投影 + 三个本包台账副作用,零宿主依赖。
-import { degradedToolResultBody, detectEngineBgShellReceipt, reportFindingsToolUseResult, structuredToToolUseResult, todoWriteToolUseResult, wireOutputToBody, } from './toolResult.js';
-import { recordEngineToolLabel } from './engineToolLabelStore.js';
-import { registerSubagentAlias } from './subagentContentStore.js';
-import { isWorkflowAgentTaskId, recordWorkflowAgentTaskId } from './workflow.js';
-import { clearEnginePanelTaskResident, markEnginePanelTaskResident } from './engineAgentPanelStore.js';
-/** 主车道证明——本批实现的臂全在 leader lane(子代/workflow lane 的 tick 面留 #52b)。 */
-const MAIN = { lane: 'main' };
+// 本文件只剩台账 import/export 那四个方法要用的四个口;15 条臂的全部依赖已随臂表落 adapt/arms.ts。
+import { isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, noteWorkflowCompletionCardEnqueued, parseTranscriptNotificationSeeds, } from './notifications.js';
 /**
- * 活体增量攒批节拍的**默认值**(时钟从 ctx.now() 取;宿主可用 `ctx.coalesceIntervalMs` 覆盖)。
- *
- * 取值依据(两个都是实测,别把其中一个当"唯一真相"):
- *  · **100ms** = 我们对标的 CC 2.1.207 CLI 口径(187 时代是 16ms,207 提到 100ms 降重绘频率,
- *    长回答滚动更稳)—— 壳是 207 fork,所以库的默认值取它,壳消费本包时行为零变化;
- *  · **16ms** = CC **桌面端**宿主 `makeStreamDeltaCoalescer` 的单帧攒批节拍(设计稿 R1 实测)。
- * ⇒ 结论:**节拍是宿主渲染策略,不是 wire 语义** —— CC 自己两个端就是两个值。web/桌面宿主
- *   想要 16ms 就传 `coalesceIntervalMs: 16`,合并**语义**(思考先于文本、段边界重开块、
- *   committed 恒随后)在库里,一份。
- *
- * 🔴 顺带钉一句反面事实(R1 证伪,别再写进任何注释/文档):**"UI 从不见裸 token" 是错的** ——
- * CC 攒批后 flush 的载荷仍是 `stream_event` 增量 delta,CC 的 UI 照样消费增量;
- * 完整 assistant 消息是 SDK 另发的一路。我们这里的 `stream_delta` chrome 臂同构。
+ * ── A 族拆分(REF-CC-SPLIT-01,2026-08-02)—— 帧形词表与双平面共用件已落 `src/adapt/` ─────────
+ * 本文件从此只留:公面契约表(coverage/divergences/ledger 形)+ 适配器实例(台账)+ **驱动壳**。
+ * 词表与纯助手在 `adapt/wireShapes.ts`,双平面包装与 id 派生在 `adapt/ids.ts`。
+ * 🔴 公面用**具名再导出**(不是 `export *`):`TASK_TOOL_NAMES` / `decisionOf` 是内部件,
+ *    `export *` 会把它们推上 npm 公面,public-export-baseline 双向门当场红。
  */
-export const FLUSH_INTERVAL_MS = 100;
-/**
- * T40 IDLE-FLUSH 竞速窗(cli upstreamBridge `IDLE_FLUSH_MS` 逐字同值)。
- *
- * 病:模型转入长工具参数生成(大 Write 的 input_json 不经本桥)时 SSE 增量停摆,而 thinking/
- * answerSegment 里**已经生成**的内容还押着陪等(pty 确证:11s 整屏 hash 恒定)。
- * 修:增量停 ≥1.5s 且缓冲非空 ⇒ 先 drainLive()(活体预览语义不变),再提交思考+文本段
- * (段序铁律不破:本来就该在下一张工具卡前 flush,这里只是提前)。
- * 🔴 这是**过渡修**,正解在 core [817](wire 侧给事件);且**需要宿主定时器**:
- * `ctx.setTimer` 缺席 ⇒ 整条竞速不启用(纯等下一帧),与 0.4.0 逐字同行为。
- */
-export const IDLE_FLUSH_MS = 1500;
-/** cli SUBAGENT_TOOL_NAMES / WORKFLOW_TOOL_NAMES 同源(判别资产,别各自重写)。 */
-export const SUBAGENT_TOOL_NAMES = new Set(['Task', 'Agent', 'Fork']);
-export const WORKFLOW_TOOL_NAMES = new Set(['Workflow', 'RunWorkflow', 'run_workflow']);
-/** 引擎侧 task 族工具(ctrl+t 面板台账同步的侧信道触发名;cli handleEngineTaskToolUse 受理的三名:
- *  TodoWrite 全量表 upsert + TaskCreate/TaskUpdate;其余工具该函数直接 return)。 */
-const TASK_TOOL_NAMES = new Set(['TodoWrite', 'TaskCreate', 'TaskUpdate']);
-/**
- * CC 自己的 reject/cancel 哨兵串(**数据**,非 CC 逻辑;cli src/utils/messages.ts:210-212 逐字)。
- * CC 的 UserToolResultMessage 按 content 串前缀路由到 reject/cancel 卡,不看 is_error 位。
- */
-export const REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
-export const CANCEL_MESSAGE = "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.";
-/** CJK 加权 token 估算(cli estimateCjkTokens 逐字:CJK≈0.6,其余≈0.25 tok/char)。 */
-export function estimateCjkTokens(s) {
-    let t = 0;
-    for (const c of s) {
-        const cp = c.codePointAt(0) ?? 0;
-        t +=
-            (cp >= 0x2e80 && cp <= 0x9fff) ||
-                (cp >= 0x3000 && cp <= 0x30ff) ||
-                (cp >= 0xac00 && cp <= 0xd7a3) ||
-                (cp >= 0xf900 && cp <= 0xfaff) ||
-                (cp >= 0xff00 && cp <= 0xffef) ||
-                (cp >= 0x20000 && cp <= 0x3ffff)
-                ? 0.6
-                : 0.25;
-    }
-    return Math.round(t);
-}
-/** 引擎 subagent 卡的短标签(cli shortTaskLabel 逐字)。 */
-/**
- * T8 —— 压平 §E1 wire `output`(**非均匀**:`string` | `(TextContent|ImageContent)[]`,events.d.ts:78)
- * 成一条纯文本(cli `flattenWireOutput` 逐字)。text 块贡献 `.text`,image 块贡献中性占位 `[image]`
- * (转录卡是文本粒度),裸字符串直通。
- * 🔴 载荷 UNTRUSTED + 仅供观测(events.d.ts:80-85):渲染可以,**绝不回喂模型**;`truncated` 的更不行。
- * B4 把它从 B 层(`wireOutputToBody`)提到独立导出:A 层的 `settlePanelTasks(report)` 也要用它
- * (关卡时把子代最终报告串到面板行 end 事件上),两处必须同一份实现。
- */
-export function flattenWireOutput(output) {
-    if (typeof output === 'string')
-        return output;
-    if (Array.isArray(output)) {
-        const parts = [];
-        for (const block of output) {
-            if (block && typeof block === 'object') {
-                const b = block;
-                if (b.type === 'text' && typeof b.text === 'string')
-                    parts.push(b.text);
-                else if (b.type === 'image')
-                    parts.push('[image]');
-            }
-        }
-        return parts.join('');
-    }
-    return '';
-}
-export function shortTaskLabel(task) {
-    const firstLine = (task.split('\n').find(l => l.trim()) ?? task).trim();
-    const words = firstLine.split(/\s+/).slice(0, 6).join(' ');
-    const label = words.length > 48 ? words.slice(0, 47) + '…' : words;
-    return label || 'subagent';
-}
-/**
- * tool_use 块的渲染面消毒(cli assistant 臂逐条搬运,**纯函数**,不改入参):
- *  ① 摘 §E2 wire 身份(eventId/parentToolCallId)并从渲染块剥掉;
- *  ② 剥所有 `_sema_*` 保留哨兵(CC 的 per-tool 渲染器 safeParse strictObject,多一个键就降级成通用卡);
- *  ③ 引擎 subagent 参数名 {agent,task,taskName} → CC 名 {subagent_type,description,prompt}
- *     (strict schema 拒绝多余键 ⇒ REPLACE 不 merge;taskName 缺席时从 task 派生短标签);
- *  ④ 件8 类型标签诚实化:引擎通道兑现不了的 subagent_type 值一律删(只留 fork/general-purpose/worker),
- *     否则卡头会显示 `Plan(…)` 而实跑 general-purpose。
- */
-export function sanitizeToolUseBlock(block) {
-    const out = { ...block };
-    const rawInput = out.input;
-    const eventId = typeof out.eventId === 'string' ? out.eventId : undefined;
-    const parentToolCallId = typeof out.parentToolCallId === 'string' ? out.parentToolCallId : undefined;
-    // 🔴 B4 补漏(0.5.0 真缺口,差分守卫此前无 fixture 携 label ⇒ 漏得静默):core 的**展示名**
-    // `tool_start.label` 同样是侧信道,必须在渲染前摘掉 —— tool_use block 会进壳 transcript,
-    // /compact 时原样直发 provider,多一个键 = 400 invalid_request(cli 头注记的「件1 事故同款」)。
-    // 摘下来的值由调用方交给 engineToolLabelStore(纯函数不做副作用),unknown-tool 卡按
-    // toolCallId 查。今天唯一的真命中族 = MCP 远端工具(name=mcp__srv__tool / label=srv:tool)。
-    const label = typeof out.label === 'string' ? out.label : undefined;
-    delete out.label;
-    delete out.eventId;
-    delete out.parentToolCallId;
-    if (out.input && typeof out.input === 'object') {
-        const cleaned = {};
-        for (const [k, val] of Object.entries(out.input)) {
-            if (!k.startsWith('_sema_'))
-                cleaned[k] = val;
-        }
-        out.input = cleaned;
-    }
-    if (out.input && typeof out.input === 'object') {
-        const inp = out.input;
-        const looksEngineSubagent = typeof inp.task === 'string' && inp.prompt === undefined && inp.description === undefined;
-        if (looksEngineSubagent) {
-            const task = inp.task;
-            const taskName = typeof inp.taskName === 'string' ? inp.taskName.trim() : '';
-            const label = taskName || shortTaskLabel(task);
-            const remapped = { description: label, prompt: task };
-            if (typeof inp.agent === 'string')
-                remapped.subagent_type = inp.agent;
-            if (typeof inp.model === 'string')
-                remapped.model = inp.model;
-            out.input = remapped;
-        }
-    }
-    if (SUBAGENT_TOOL_NAMES.has(out.name) && out.input && typeof out.input === 'object') {
-        const inp = out.input;
-        if (typeof inp.subagent_type === 'string' &&
-            !['fork', 'general-purpose', 'worker'].includes(inp.subagent_type)) {
-            delete inp.subagent_type;
-        }
-    }
-    return {
-        block: out,
-        rawInput,
-        ...(eventId !== undefined ? { eventId } : {}),
-        ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
-        ...(label !== undefined ? { label } : {}),
-    };
-}
-/** seam 的 reserved decision 哨兵(cli decisionOf 逐字)。 */
-function decisionOf(block) {
-    const input = block.input;
-    const d = input?._sema_decision;
-    return d === 'reject' || d === 'cancel' || d === 'error' ? d : undefined;
-}
+export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
+import { IDLE_FLUSH_MS } from './adapt/wireShapes.js';
+import { chrome, MAIN, makeIdOf } from './adapt/ids.js';
+import { createTextStream } from './adapt/textStream.js';
+import { createToolCardLedger } from './adapt/toolCards.js';
+import { createPanelTaskLedger } from './adapt/panelTasks.js';
+import { createAdapterInstanceLedger } from './adapt/instanceLedger.js';
+import { createTurnFlags } from './adapt/turnFlags.js';
+import { ARMS } from './adapt/arms.js';
 /** 本批覆盖清单——差分守卫按它区分「已覆盖臂必须逐字段等价」与「已声明未覆盖臂」。 */
 export const ADAPTER_COVERAGE = {
     /** 已落码的帧臂。 */
@@ -269,33 +116,25 @@ export const ADAPTER_DIVERGENCES = [
     'DIVERGENCE-9(B5):`tool_result` 消息的 uuid —— cli 在缺 `eventId` 时铸随机 v4,本包派生 ' +
         '`wtc_<toolUseId>`(DIVERGENCE-2 同族:同流重放 ⇒ 同 id 序列,[1653])。守卫按别名结构比,不比字面。',
 ];
-const TASK_NOTIFICATION_TAG = 'task-notification';
-const TASK_ID_TAG = 'task-id';
-const STATUS_TAG = 'status';
 /**
  * 适配器实例 —— **台账**(通知去重/跨通道记账)挂实例,`adapt()` 每 turn 调一次,turn 级状态在
  * 调用内。跨 turn 语义(进程级去重)因此靠「同一个实例贯穿 session」保证,重启靠 import/export。
  */
 class WireToCcAdapterImpl {
-    renderedNotifications = new Set();
-    // 🔴 B5 ①:`notifiedRuns` / `cardEnqueuedRuns` **不在实例上** —— 它们的配对半场(清账的
-    //   dropQueuedNotificationsForRun、记账的两个 enqueue、idle watcher)全在 notifications.ts 的
-    //   module 台账上,放实例 = 前提不共享 = 双卡/零显示/模型二收(0.6.0 真缺口,[1857])。
-    //   适配器一律经 notifications.ts 的四个口读写,别在这里再长一份影子副本。
-    /** W1 三级判据素材:本壳见过的 Workflow 工具 tool_use id(module 级台账的实例化)。 */
-    seenWorkflowToolCallIds = new Set();
     /**
-     * B4 —— SubagentStart 一生只许一次(frame-lane-matrix #4)。cli 是 **module 级** Set:跨 turn 存活的
-     * bg 子代在每个新 generator 的首 tick 都会走到 fire 点(`livePanelTasks` 是 per-turn 的),没有它
-     * 就每 turn 重 fire 一次。本包放**实例级** = 一个 session 一份,语义等价且不污染进程(多 session
-     * 宿主如 web 一个页面开两个会话,cli 的 module 形反而会互相吞)。
-     * 同时它也是 `task_notification` 臂发 stop 的门(cli:`firedSubagentStartHookTaskIds.has(taskId)`)。
+     * 三个**实例级** Set 的持有者(A 族 FIX-05:收成一个显式对象,消 `self.`/`this.` 双路径)——
+     * renderedNotifications / seenWorkflowToolCallIds / firedSubagentStartHookTaskIds,
+     * 逐条语义见 adapt/instanceLedger.ts 头注(含 DIVERGENCE-6 的实例级 vs module 级分界)。
+     * 🔴 B5 ①:`notifiedRuns` / `cardEnqueuedRuns` **不在实例上** —— 它们的配对半场(清账的
+     *   dropQueuedNotificationsForRun、记账的两个 enqueue、idle watcher)全在 notifications.ts 的
+     *   module 台账上,放实例 = 前提不共享 = 双卡/零显示/模型二收(0.6.0 真缺口,[1857])。
+     *   适配器一律经 notifications.ts 的四个口读写,别在这里再长一份影子副本。
      */
-    firedSubagentStartHookTaskIds = new Set();
+    ledger = createAdapterInstanceLedger();
     exportLedger() {
         return {
             version: 1,
-            renderedNotifications: [...this.renderedNotifications],
+            renderedNotifications: this.ledger.listRenderedNotifications(),
             // B5 ①:这两项是 module 台账的快照(不是实例私有),跨实例一致。
             notifiedRuns: listNotifiedRuns(),
             cardEnqueuedRuns: listWorkflowCompletionCardsEnqueued(),
@@ -303,17 +142,7 @@ class WireToCcAdapterImpl {
     }
     importLedger(state) {
         let n = 0;
-        const take = (v, into) => {
-            if (!Array.isArray(v))
-                return;
-            for (const k of v) {
-                if (typeof k === 'string' && k.length > 0 && !into.has(k)) {
-                    into.add(k);
-                    n++;
-                }
-            }
-        };
-        /** B5 ①:module 台账那两项经真源写口回植(has 判重 = 与 take 同样只数新增)。 */
+        /** B5 ①:module 台账那两项经真源写口回植(has 判重 = 与实例台账那条同样只数新增)。 */
         const takeModule = (v, has, add) => {
             if (!Array.isArray(v))
                 return;
@@ -325,7 +154,10 @@ class WireToCcAdapterImpl {
             }
         };
         const s = state;
-        take(s.renderedNotifications, this.renderedNotifications);
+        // 单次快照(codex 复审 #2 收货修):拆分前这里对 `renderedNotifications` 恰一次属性读。
+        const rendered = s.renderedNotifications;
+        if (Array.isArray(rendered))
+            n += this.ledger.takeRenderedNotifications(rendered);
         takeModule(s.notifiedRuns, isEngineWorkflowNotified, markEngineWorkflowNotified);
         takeModule(s.cardEnqueuedRuns, isWorkflowCompletionCardEnqueued, noteWorkflowCompletionCardEnqueued);
         return n;
@@ -342,7 +174,7 @@ class WireToCcAdapterImpl {
         //    看着都对)。壳侧 shim 化后两个入口都落到同一个解析器上。
         const { renderedKeys, notifiedKeys, seeded } = parseTranscriptNotificationSeeds(messages);
         for (const k of renderedKeys)
-            this.renderedNotifications.add(k);
+            this.ledger.addRenderedNotification(k);
         for (const taskId of notifiedKeys) {
             // cli seedEngineTaskNotificationDedupFromTranscript 同位:回植走 module 台账
             // (outstanding 药丸 / idle watcher 收摊那半场读的就是它)。
@@ -356,344 +188,22 @@ class WireToCcAdapterImpl {
         noteWorkflowCompletionCardEnqueued(runId);
     }
     async *adapt(frames, ctx) {
-        // 下面几个 `function*` 表达式(非箭头 —— generator 不能写成箭头)要访问实例台账,
-        // 它们的 `this` 不是适配器,所以在这里固定一个引用。
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
+        // FIX-05:实例台账走**唯一一条**显式路径(拆分前是 `self.` / `this.` 两条)。
+        const inst = this.ledger;
         const turnStartAt = ctx.now();
-        // ── id 派生 ────────────────────────────────────────────────────────────────────────────────
-        // [1653]:稳定键优先序 = 帧 id > seq > toolCallId,全缺才 ctx.uuid()。现役 wire 的稳定键落在
-        // `uuid` 字段(§E2 core 铸的 eventId / stamp 铸的帧 id),故映到 `id` 位喂进去(见 SEAM-GAP-1)。
-        // `suffix` = 同一帧派生多条消息时的去撞位(如 tool_use 卡 + 同帧的 reject 结果)。
-        const idOf = (frame, suffix) => {
-            const base = typeof frame.id === 'string' && frame.id.length > 0
-                ? frame.id
-                : typeof frame.uuid === 'string' && frame.uuid.length > 0
-                    ? frame.uuid
-                    : undefined;
-            return deriveTranscriptId({
-                ...(base !== undefined ? { id: suffix !== undefined ? `${base}#${suffix}` : base } : {}),
-                ...(typeof frame.seq === 'number' ? { seq: frame.seq } : {}),
-                ...(typeof frame.toolCallId === 'string' ? { toolCallId: frame.toolCallId } : {}),
-            }, ctx);
-        };
-        // ── turn 级状态(cli generator 局部变量的等价) ──────────────────────────────────────────────
-        let answer = '';
-        let answerSegment = '';
-        let thinking = '';
-        let emittedAssistantText = false;
-        let textPending = '';
-        let thinkingPending = '';
-        let textBlockOpen = false;
-        let thinkingBlockOpen = false;
-        let lastFlushAt = 0;
-        /** T29 攒批节拍:宿主策略优先(桌面/web 可传 16ms 对齐 CC 桌面端),缺席=207 CLI 口径 100ms。 */
-        const flushEveryMs = typeof ctx.coalesceIntervalMs === 'number' && ctx.coalesceIntervalMs >= 0
-            ? ctx.coalesceIntervalMs
-            : FLUSH_INTERVAL_MS;
-        let messageStartEmitted = false;
-        let endEmitted = false;
-        let assistantResponseId = null;
-        /** committed 消息的 id 锚 —— 该段/该思考块的**第一帧**(重放确定性:同流同 id)。 */
-        let segmentAnchor = null;
-        let thinkingAnchor = null;
-        const pending = new Map();
-        // ── B4 / MF-10:面板行台账(cli generator 局部变量逐个对位)────────────────────────────────
-        // 引擎侧子代的 tick 只带 rollup 数字({toolUses,totalTokens}) = CC `AgentProgress` 同形,
-        // 所以忠实的 CC-187 面是 footer 的 CoordinatorTaskPanel(CC 自己对进程外 agent 的先例:
-        // 面板行 + task-notification,从不合成 inline 消息轨)。下面这组把「tick → 哪张委派卡」的
-        // 归属、行的活性(live/inert/unbound)、以及 settle 的三处 sweep 全部管起来。
-        /** taskId → 绑定的 open tool_use id。 */
-        const taskCardBinding = new Map();
-        /** 已被某 taskId 认领的 tool_use id(一张卡只认一个子代)。 */
-        const boundToolCalls = new Set();
-        /** 本 turn 发布过面板行的全部 taskId(绑定与否都算)。 */
-        const livePanelTasks = new Set();
-        /** 已落终态的行(settle 幂等)。 */
-        const endedPanelTasks = new Set();
-        /**
-         * #6 —— 绑定时那张卡**正开着**的 taskId(= "live" 绑定)。只有这些行属本 turn 生命周期、
-         * 可被 turn 末防御 sweep 结掉。inert(显式父指向已关/没见过的卡 —— 跨 turn bg 子代的典型形)
-         * 与 unbound 行是 **session 常驻**:终态只认 task_notification / bg_notification。
-         */
-        const liveBoundPanelTasks = new Set();
-        /** taskId → 子代类型(Stop hook 查它;cli 同为 turn 局部)。 */
-        const subagentTypeById = new Map();
-        const chrome = (event) => ({ plane: 'chrome', event });
-        const transcript = (message) => ({
-            plane: 'transcript',
-            message: message,
-        });
-        const mintResponseId = (frame) => (assistantResponseId ??= `msg_sema_${idOf(frame, 'resp')}`);
-        // ── B4 / MF-10:行绑定 + 三处 sweep(cli bindTaskCard / unboundSubagentCandidates /
-        //    settlePanelTasks 逐条对位)───────────────────────────────────────────────────────────
-        /** 行的车道证明:绑到卡的 = subagent lane(带父卡 id),未绑的 = 主 lane(taskId 键的独立行)。 */
-        const laneOfTask = (taskId) => {
-            const card = taskCardBinding.get(taskId);
-            return card !== undefined ? { lane: 'subagent', parentToolCallId: card } : MAIN;
-        };
-        /**
-         * T32 行绑定。**typed 双键在场恒赢**(B6 定案):wire 点名了 `parentToolCallId` 时,下面的
-         * FIFO 臂**一次都不会被考虑** —— 连「点名的卡不合格」那一支也是直接返回 unbound,而不是
-         * 退回去猜。判据锚在这里:显式支的两条出口(绑定 / 拒绝)都不落进 else。
-         */
-        const bindTaskCard = (taskId, parentToolCallId) => {
-            const existing = taskCardBinding.get(taskId);
-            if (existing !== undefined)
-                return existing;
-            let target;
-            if (parentToolCallId !== undefined) {
-                // P1② 精确绑定 —— wire 点名了委派卡。信但不无条件信([1617]①,frame-lane-matrix #1):
-                // 被点名的卡**开着**且**不是** subagent 形工具(Task/Agent/Fork)时拒绝绑定 —— 否则
-                // workflow/Bash 卡一关就会把这条行 settle 掉、还会收走它的 inline stats(错归因)。
-                // 行保持 unbound(taskId 键的 rollup 仍是真的)。已关/没见过的 id 仍**惰性绑定**(inert):
-                // 终态由通知落,严格优于错绑另一张开着的卡。
-                const named = pending.get(parentToolCallId);
-                if (named !== undefined && !SUBAGENT_TOOL_NAMES.has(named.name))
-                    return undefined;
-                target = parentToolCallId;
-            }
-            else {
-                // ── old-engine fallback(FIFO 猜父)—— B6 P1-2 归属定案:**不删** ────────────────────
-                // 🔴 判据先摆正:这条臂不是「P1-2 之前的临时权宜」,它是 **tolerate-absent 的保护臂**。
-                //   决定后果方向的量 = 「这条子代行有没有归属」:
-                //     · 回落在 ⇒ 老引擎(不发 parentToolCallId)上行仍绑到唯一那张开着的委派卡 ⇒ 行有归属、
-                //       inline stats 有去处、关卡时被 settle;
-                //     · 回落删掉 ⇒ 老引擎上行恒 unbound ⇒ 转录里那条群组行永远不长统计、卡关了也不结,
-                //       用户看到一条转圈到 turn 末的行。
-                //   ⇒ **保护型缺席 = 漏保护**,与 `parked → awaiting approval` 同判(不删)。
-                //   猜错的风险已被两道门收窄:只考虑**未绑**且**subagent 形**的卡;≥2 张候选时上层
-                //   直接判含糊、保持 unbound(见 task_progress 臂的 unboundSubagentCandidates() > 1)。
-                // 退役条件(登记在 compensations.ts T32):P1-2 到货 **且** 达标线 ≥ server 1.290 —— 即
-                //   「不再支持不发 typed 双键的引擎」那一天,才是删它的日子;只要还能连老引擎就得留着。
-                // 覆盖:diff 门 14 条 task_progress 帧里有 6 条不带 parentToolCallId(其中 2 条走 workflow
-                //   lane 门、不到这里),真正压这条回落臂的是 4 条(FIFO 命中 / 含糊拒绝 / settle / 跨 turn)。
-                for (const [id, p] of pending) {
-                    if (!boundToolCalls.has(id) && SUBAGENT_TOOL_NAMES.has(p.name)) {
-                        target = id;
-                        break;
-                    }
-                }
-            }
-            if (target === undefined)
-                return undefined;
-            taskCardBinding.set(taskId, target);
-            boundToolCalls.add(target);
-            // #6 live vs inert:只有绑到**此刻开着**的卡才把行系进本 turn 的生命周期
-            // (FIFO 目标恒开着;显式目标可能已关 = inert)。
-            if (pending.has(target))
-                liveBoundPanelTasks.add(taskId);
-            // cli 的 `SEMA_BIND_PROBE` 文件探针 → 注入口(载荷逐字同形,见 ADAPTER_DIVERGENCES-5)。
-            ctx.probe?.('bind', `bind ${taskId} -> ${target} via=${parentToolCallId !== undefined ? 'explicit' : 'fifo'}`);
-            return target;
-        };
-        /** 对抗复审修(w0zwpa251 #1):≥2 张未绑的 subagent 形卡开着且 wire 没点名 ⇒ 任何猜都是错归因。 */
-        const unboundSubagentCandidates = () => {
-            let n = 0;
-            for (const [id, p] of pending) {
-                if (!boundToolCalls.has(id) && SUBAGENT_TOOL_NAMES.has(p.name))
-                    n++;
-            }
-            return n;
-        };
-        /** SubagentStart(cli fireSubagentStartHook 的臂化):类型恒记,fire 一生一次。 */
-        const fireSubagentStart = function* (taskId, agentType) {
-            subagentTypeById.set(taskId, agentType); // Stop 的类型查找恒记(fire 与否无关)
-            if (self.firedSubagentStartHookTaskIds.has(taskId))
-                return;
-            self.firedSubagentStartHookTaskIds.add(taskId);
-            ctx.probe?.('hook', `start ${taskId} type=${agentType}`);
-            yield chrome({ kind: 'subagent_lifecycle', laneProof: laneOfTask(taskId), phase: 'start', taskId, agentType });
-        };
-        /**
-         * 结掉一张关闭中的卡所绑的面板行(`cardId`),或 turn 末/abort 结掉**本 turn 活绑**的全部行
-         * (`cardId===null` 的防御 sweep —— 子代从不发终态 tick)。
-         * 拍1 查看态:显式关卡臂携委派卡的 output(= 子代最终报告)到 end 事件上;sweep 无报告。
-         */
-        const settlePanelTasks = function* (cardId, isError, report) {
-            // inline 群组行孪生(clay dogfood 2026-07-03):冻结该卡的 tick 终值,免得"N agents finished"
-            // 行把真实工具数/token 重置回 0。null-cardId 的 sweep 结掉每一条活着的 inline 条目。
-            if (cardId !== null) {
-                yield chrome({ kind: 'inline_task_stats', laneProof: { lane: 'subagent', parentToolCallId: cardId }, op: 'settle', cardId, isError });
-            }
-            else {
-                yield chrome({ kind: 'inline_task_stats', laneProof: MAIN, op: 'settle_all' });
-            }
-            for (const taskId of livePanelTasks) {
-                if (cardId !== null && taskCardBinding.get(taskId) !== cardId)
-                    continue;
-                // #6 —— 防御 sweep 只结**本 turn 活绑**的行(流被截断的形)。session 常驻行
-                // (inert 绑定 / unbound = 跨 turn bg 子代)绝不在这里冻成假 completed:它的终态真相
-                // 由 task_notification / bg_notification 落(通知-settle 边)。
-                if (cardId === null && !liveBoundPanelTasks.has(taskId))
-                    continue;
-                if (endedPanelTasks.has(taskId))
-                    continue;
-                endedPanelTasks.add(taskId);
-                const lane = laneOfTask(taskId);
-                const agentType = subagentTypeById.get(taskId);
-                yield chrome({
-                    kind: 'subagent_lifecycle',
-                    laneProof: lane,
-                    phase: 'stop',
-                    taskId,
-                    ...(agentType !== undefined ? { agentType } : {}),
-                });
-                yield chrome({
-                    kind: 'panel_task',
-                    laneProof: lane,
-                    event: {
-                        kind: 'end',
-                        taskId,
-                        isError,
-                        ...(cardId !== null && report !== undefined ? { report } : {}),
-                    },
-                });
-            }
-        };
-        // ══ B5 —— B/D/E 层:开卡 → `tool_result` 转录消息 ═══════════════════════════════════════
-        /**
-         * TodoWrite 划删线 diff 的 `oldTodos`。
-         * 🔴 **turn 级**(cli 同:`let lastLiveTodos` 声明在 generator 体内,不是 module 级 ——
-         *    cli 的注释写着「module-level, per-process」但代码不是,以**代码**为准,差分守卫认代码)。
-         */
-        let lastLiveTodos = [];
-        /**
-         * 一张开卡的收口(cli `buildToolResult` + 它内联的 #117a 桥)。产出顺序与 cli 的
-         * 「副作用先于 yield」一致:先 chrome(bg shell 建行),再 transcript(tool_result 卡)。
-         */
-        const buildToolResult = function* (p, end) {
-            const isError = end?.isError ?? false;
-            // D 层 / T7:wire 带正文 ⇒ 真身投影;没带 ⇒ **诚实缺席**(§8-4,不再 mock 反造)。
-            const body = end && end.output !== undefined
-                ? wireOutputToBody(p.name, end.output, isError, end.truncated === true, flattenWireOutput, end.structured)
-                : degradedToolResultBody(isError);
-            // ── E 层 ③:#117a 模型发起的后台 Bash 回执 → ctrl+B 面板行(判定在库、执行留宿主)。
-            if (p.name === 'Bash' && !isError && end?.output !== undefined) {
-                const reg = detectEngineBgShellReceipt(p.rawInput, flattenWireOutput(end.output));
-                if (reg) {
-                    yield chrome({ kind: 'bgshell_register', laneProof: MAIN, taskId: reg.taskId, registration: reg });
-                }
-            }
-            // B 层:structured → 逐工具 typed toolUseResult(卡的 outputSchema safeParse 过才渲富卡)。
-            let rich = end?.structured !== undefined
-                ? structuredToToolUseResult(end.structured, end.output !== undefined ? flattenWireOutput(end.output) : undefined)
-                : null;
-            // E 层 ④/⑤:两条按**工具名**的补位(引擎不发 type 判别位,B 层 switch 认领不了)。
-            if (rich === null && p.name === 'TodoWrite') {
-                const todo = todoWriteToolUseResult(p.rawInput, lastLiveTodos, isError);
-                if (todo !== null) {
-                    rich = { toolUseResult: todo.toolUseResult, isError: todo.isError };
-                    lastLiveTodos = todo.newTodos;
-                }
-            }
-            if (rich === null && !isError && p.name === 'ReportFindings') {
-                rich = reportFindingsToolUseResult(end?.structured, p.rawInput);
-            }
-            const eventId = end?.eventId ?? p.eventId;
-            const parentToolCallId = end?.parentToolCallId ?? p.parentToolCallId;
-            yield transcript({
-                type: 'user',
-                message: {
-                    role: 'user',
-                    content: [
-                        {
-                            type: 'tool_result',
-                            tool_use_id: p.id,
-                            content: body.content,
-                            is_error: rich?.isError === true || body.isError,
-                        },
-                    ],
-                },
-                // DIVERGENCE-2:cli 在缺 eventId 时铸随机 v4,本包一律**稳定键派生**
-                // (`wtc_<toolUseId>` —— 一张卡一个结果,天然唯一;同流重放 ⇒ 同 id 序列,[1653])。
-                uuid: eventId ?? deriveTranscriptId({ toolCallId: p.id }, ctx),
-                session_id: ctx.sessionId,
-                ...(parentToolCallId !== undefined ? { parent_tool_use_id: parentToolCallId } : {}),
-                // CC 结果卡读 sidecar 上的 typed 输出(不是 block content)。
-                toolUseResult: rich !== null ? rich.toolUseResult : (body.toolUseResult ?? body.content),
-                // T7:wire 没带正文的诚实标记 —— 在场 = 这张卡没有真实执行结果(UI 显示决策留端)。
-                ...(body.degraded !== undefined ? { _sema_degraded: body.degraded } : {}),
-            });
-        };
-        /** 关掉所有还开着的卡(流被截断 / 无 result 收尾;cli 两处同形,abort 路径**不做**)。 */
-        const sweepOpenCards = function* () {
-            for (const [id, p] of pending) {
-                pending.delete(id);
-                assistantResponseId = null; // S1
-                yield* buildToolResult(p);
-            }
-        };
-        /** 提交累积的思考块(cli takeThinking:committed 形 + 关活体块 + 收活动行)。 */
-        function* takeThinking() {
-            if (thinking.length === 0)
-                return;
-            const anchor = thinkingAnchor ?? {};
-            const msg = {
-                type: 'assistant',
-                message: { role: 'assistant', content: [{ type: 'thinking', thinking }] },
-                uuid: idOf(anchor, 'thinking'),
-                session_id: ctx.sessionId,
-                parent_tool_use_id: null,
-            };
-            thinking = '';
-            thinkingAnchor = null;
-            thinkingBlockOpen = false;
-            // P2d:活体 "∴ Thinking…" 行在 committed 块落地的**同一刻**收掉(先收行再上消息,cli 同序)
-            yield chrome({ kind: 'thinking_activity', laneProof: MAIN, active: false });
-            yield transcript(msg);
-        }
-        /** 提交累积的文本段(cli takeAnswerSegment:#27 段序铁律——工具卡前/turn 末各 flush 一次)。 */
-        function* takeAnswerSegment() {
-            if (answerSegment.length === 0)
-                return;
-            const anchor = segmentAnchor ?? {};
-            const msg = {
-                type: 'assistant',
-                message: { role: 'assistant', content: [{ type: 'text', text: answerSegment }] },
-                uuid: idOf(anchor, 'text'),
-                session_id: ctx.sessionId,
-                parent_tool_use_id: null,
-            };
-            answerSegment = '';
-            segmentAnchor = null;
-            emittedAssistantText = true;
-            textBlockOpen = false;
-            yield transcript(msg);
-        }
-        /** 合并后的活体增量下泄(cli drainLive:思考先于文本 = 持久臂序)。 */
-        function* drainLive() {
-            if (thinkingPending.length > 0) {
-                const opening = !thinkingBlockOpen;
-                thinkingBlockOpen = true;
-                yield chrome({
-                    kind: 'stream_delta',
-                    laneProof: MAIN,
-                    channel: 'thinking',
-                    text: thinkingPending,
-                    estimatedTokens: estimateCjkTokens(thinkingPending),
-                    opening,
-                });
-                thinkingPending = '';
-            }
-            if (textPending.length > 0) {
-                const opening = !textBlockOpen;
-                textBlockOpen = true;
-                // B3:cli 的 `SEMA_STREAM_PROBE` 文件探针换成 ctx.probe 口(体检 #5 同款用途:Ink 挂载后
-                // console 被吞,harness 只能靠这条证明「引擎是**逐 token 增量**到的」而不是整块一次性 dump)。
-                // 载荷格式与 cli 逐字同形,只把 Date.now() 换成 ctx.now()(注入时钟纪律)。
-                ctx.probe?.('stream', `${ctx.now()} text_flush len=${textPending.length}`);
-                yield chrome({
-                    kind: 'stream_delta',
-                    laneProof: MAIN,
-                    channel: 'text',
-                    text: textPending,
-                    estimatedTokens: estimateCjkTokens(textPending),
-                    opening,
-                });
-                textPending = '';
-            }
-        }
+        // ── id 派生(实现落 adapt/ids.ts;工厂形只为把 ctx 绑进去)────────────────────────────────
+        const idOf = makeIdOf(ctx);
+        // ── M1 流合并器(矩阵 §1.1 的 12 行状态整体落 adapt/textStream.ts)────────────────────────
+        const text = createTextStream(ctx, idOf);
+        // ── M2 工具卡台账(矩阵 §1.2 的 3 行状态整体落 adapt/toolCards.ts)────────────────────────
+        const cards = createToolCardLedger(ctx, idOf);
+        // ── M3 面板行台账(矩阵 §1.3 的 6 行状态 + 五个闭包整体落 adapt/panelTasks.ts)──────────
+        //    依赖只有两件:M2 的**只读**开卡视图、实例台账。反过来 M2 不依赖 M3(单向边)。
+        const panel = createPanelTaskLedger(ctx, cards, inst);
+        // ── M6a 响应度量 + M6b 重试覆盖层(两个小状态机;矩阵 §3.3:必须连驱动壳那一半一起搬)────
+        const flags = createTurnFlags(ctx, turnStartAt);
+        /** 臂表的注入面 —— 矩阵 §3.5 收窄成的六件,不做全量注入(全量注入 = 封闭性声明失去判别力)。 */
+        const deps = { ctx, idOf, text, cards, panel, flags, inst };
         // turn 开场卫生(T38 三清,cli 逐条同序):清上一 turn 的 retry 覆盖层 + **上一轮的建议批** +
         // 思考活动行,再发 request-start(T39)。三清缺一都是"上一轮的东西挂着不掉"。
         yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
@@ -705,22 +215,14 @@ class WireToCcAdapterImpl {
         // 代价是失去 for-await 的隐式 cleanup ⇒ finally 里手动 return()(T58,少了它 = SSE 不拆)。
         const iterator = frames[Symbol.asyncIterator]();
         let iteratorDone = false;
-        // R1(clay 五报 07-31):retry 覆盖层的四个清除点全在 turn 边界,缺「重试成功→清」的转移 ——
-        // 引擎重试成功那一刻什么都不发(BrainStatusPhase 无恢复终态,候 core [2163]),所以恢复只能由
-        // 「主 lane 又有内容在流」这个事实来证明。挂旗后首个主 lane 内容帧即清,CC 同位 = 重试循环
-        // 退出即 onRetryStatus(null)(pretty220 finally 清)。
-        let retryOverlayActive = false;
         try {
             for (;;) {
                 const nextPromise = iterator.next();
                 let step;
                 while (step === undefined) {
-                    const hasPendingContent = thinking.length > 0 ||
-                        answerSegment.length > 0 ||
-                        thinkingPending.length > 0 ||
-                        textPending.length > 0;
                     // 缓冲全空 ⇒ 零开销路径;宿主没给定时器 ⇒ 竞速整条不启用(绝不 setTimeout 兜底)。
-                    if (!hasPendingContent || ctx.setTimer === undefined) {
+                    // 判据本体(四项 or)已随 12 行状态收进 M1 —— 这里读的是它的具名形。
+                    if (!text.hasPendingContent() || ctx.setTimer === undefined) {
                         step = await nextPromise;
                         break;
                     }
@@ -741,9 +243,9 @@ class WireToCcAdapterImpl {
                             break;
                         // Idle ≥1.5s 且有已生成未提交的内容:现在就上屏(活体预览在前,再按 思考→文本 的
                         // committed 序 —— 与工具卡前的边界 flush 逐字同序,只是提前发生)。
-                        yield* drainLive();
-                        yield* takeThinking();
-                        yield* takeAnswerSegment();
+                        yield* text.drainLive();
+                        yield* text.takeThinking();
+                        yield* text.takeAnswerSegment();
                         // 缓冲已空 ⇒ 下一圈直接 plain-await。
                     }
                 }
@@ -760,655 +262,26 @@ class WireToCcAdapterImpl {
                 const m = rawFrame;
                 if (m === null || typeof m !== 'object')
                     continue;
-                if (retryOverlayActive &&
-                    (m.type === 'stream_event' ||
-                        m.type === 'assistant' ||
-                        m.type === 'tool_end_result' ||
-                        m.type === 'turn_usage') &&
-                    typeof m.parentToolCallId !== 'string' &&
-                    // stream_event 的子流标记在 event 里(:1230 thinking 臂同款判位),帧顶层没有。
-                    typeof m.event?.parentToolCallId !== 'string') {
-                    // 恢复即清:主 lane 内容帧到达 = 引擎那次重试已成功;子流帧(parentToolCallId)不算证据
-                    // (主 brain 仍可能在退避等待,#47 矩阵 #5 同族判别)。
-                    retryOverlayActive = false;
-                    yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
-                }
-                if (m.type === 'stream_event' && !messageStartEmitted) {
-                    messageStartEmitted = true;
-                    yield chrome({
-                        kind: 'response_metrics',
-                        laneProof: MAIN,
-                        phase: 'start',
-                        ttftMs: ctx.now() - turnStartAt,
-                    });
-                }
+                // ── 帧前置(M6a/M6b 两个小状态机的驱动壳那一半;两半同文件,见 turnFlags.ts 头注)──
+                //    ① R1 重试覆盖层「恢复即清」;② 首个 stream_event 的 TTFT 起拍。次序与拆分前逐字一致。
+                yield* flags.onFrameBeforeDispatch(m);
                 // 持久臂之前先把活体增量泄干净(活体预览恒先于它 settle 成的 committed 消息)。
+                // 🔴 矩阵 §2.4(a)留钉:`result` 臂**自己不带 drainLive**,靠的就是这一拍 ——
+                //    臂表化时若把「非 stream_event 先泄活体」的责任也挪进臂里,result 会漏泄。
                 if (m.type !== 'stream_event')
-                    yield* drainLive();
-                switch (m.type) {
-                    case 'assistant': {
-                        const message = m.message;
-                        const blocks = Array.isArray(message?.content)
-                            ? message.content
-                            : [];
-                        const toolUseIdx = blocks.findIndex(b => b?.type === 'tool_use');
-                        if (toolUseIdx >= 0) {
-                            const original = blocks[toolUseIdx];
-                            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 三条早退路径同样生效。
-                            recordEngineToolLabel(toolUseId, san.label);
-                            // 引擎模式下壳工具 call() 从不执行 —— ctrl+t 面板台账只能靠这条侧信道(宿主义务)。
-                            if (TASK_TOOL_NAMES.has(toolName)) {
-                                yield chrome({
-                                    kind: 'task_ledger_sync',
-                                    laneProof: MAIN,
-                                    source: 'tool_use',
-                                    toolName,
-                                    toolUseId,
-                                    input: san.block.input,
-                                });
-                            }
-                            // #27 段序:先把这张卡之前的散文提交,再提交它之前的思考(思考恒在卡上方)。
-                            yield* takeAnswerSegment();
-                            yield* takeThinking();
-                            yield transcript({
-                                type: 'assistant',
-                                // S1:per-RESPONSE 铸 id —— CC 的 grouped-agent 渲染按 `${message.id}:${toolName}`
-                                // 分组;id-less 帧会把整个 session 的 Agent 卡塌成一张。tool_use 帧才盖章。
-                                message: { id: mintResponseId(m), role: 'assistant', content: renderBlocks },
-                                uuid: idOf(m),
-                                session_id: ctx.sessionId,
-                                parent_tool_use_id: null,
-                            });
-                            if (decision === 'reject' || decision === 'cancel') {
-                                yield transcript({
-                                    type: 'user',
-                                    message: {
-                                        role: 'user',
-                                        content: [
-                                            {
-                                                type: 'tool_result',
-                                                tool_use_id: san.block.id,
-                                                content: decision === 'reject' ? REJECT_MESSAGE : CANCEL_MESSAGE,
-                                                is_error: false,
-                                            },
-                                        ],
-                                    },
-                                    uuid: idOf(m, decision),
-                                    session_id: ctx.sessionId,
-                                });
-                                assistantResponseId = null; // 一个结果关闭该 model response
-                                break;
-                            }
-                            if (decision === 'error') {
-                                yield transcript({
-                                    type: 'user',
-                                    message: {
-                                        role: 'user',
-                                        content: [
-                                            {
-                                                type: 'tool_result',
-                                                tool_use_id: san.block.id,
-                                                content: 'The tool failed to execute.',
-                                                is_error: true,
-                                            },
-                                        ],
-                                    },
-                                    uuid: idOf(m, 'error'),
-                                    session_id: ctx.sessionId,
-                                });
-                                assistantResponseId = null;
-                                break;
-                            }
-                            pending.set(toolUseId, {
-                                id: toolUseId,
-                                name: toolName,
-                                rawInput: san.rawInput,
-                                ...(san.eventId !== undefined ? { eventId: san.eventId } : {}),
-                                ...(san.parentToolCallId !== undefined ? { parentToolCallId: san.parentToolCallId } : {}),
-                            });
-                            if (WORKFLOW_TOOL_NAMES.has(toolName))
-                                this.seenWorkflowToolCallIds.add(toolUseId);
-                            break;
-                        }
-                        const textBlock = blocks.find(b => b?.type === 'text');
-                        if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) {
-                            answer += textBlock.text;
-                            yield* takeThinking();
-                            yield transcript({
-                                type: 'assistant',
-                                message: { role: 'assistant', content: [{ type: 'text', text: textBlock.text }] },
-                                uuid: idOf(m),
-                                session_id: ctx.sessionId,
-                                parent_tool_use_id: null,
-                            });
-                            emittedAssistantText = true;
-                        }
-                        const thinkingBlock = blocks.find(b => b?.type === 'thinking');
-                        if (thinkingBlock && typeof thinkingBlock.thinking === 'string') {
-                            yield transcript({
-                                type: 'assistant',
-                                message: { role: 'assistant', content: [thinkingBlock] },
-                                uuid: idOf(m, 'durable-thinking'),
-                                session_id: ctx.sessionId,
-                                parent_tool_use_id: null,
-                            });
-                        }
-                        break;
-                    }
-                    // DIVERGENCE-1 —— 现役 wire 不产 user 帧;透传是给 desktop 重放存量转录留的门。
-                    case 'user': {
-                        if (m.message === undefined)
-                            break;
-                        yield transcript({ ...m, uuid: idOf(m), session_id: ctx.sessionId });
-                        break;
-                    }
-                    case 'tool_end_result': {
-                        // B4 起本臂做三件:① P0-2 label 补位(只有 tool_end 带 label 的场景;台账自身幂等不覆盖)
-                        // ② MF-10 **关卡 settle**(子代从不发终态 tick,父卡的 tool_end 就是完成信号;卡的 output
-                        //    文本 = 子代最终报告,串到行 end 事件上)③ 卡台账出栈 + response-id 复位(S1)。
-                        // 🆕 B5:④ **B/D/E 层** —— 铸 `tool_result` 卡本体 + 三个侧产物
-                        //    (Remember→memory_saved / task 族 structured 台账 / #117a bg Bash 桥)。
-                        const callId = typeof m.toolCallId === 'string' ? m.toolCallId : undefined;
-                        recordEngineToolLabel(callId, m.label);
-                        if (callId !== undefined) {
-                            yield* settlePanelTasks(callId, m.isError === true, m.output !== undefined ? flattenWireOutput(m.output) : undefined);
-                        }
-                        const p = callId !== undefined ? pending.get(callId) : undefined;
-                        // 无对应开卡的 tool_end(乱序 / 重复)直接丢(cli 同)。
-                        if (p === undefined || callId === undefined)
-                            break;
-                        pending.delete(callId);
-                        // S1:结果关闭该 model response —— **yield 之前**复位(生成器会在 yield 上挂起)。
-                        assistantResponseId = null;
-                        const structured = m.structured;
-                        yield* buildToolResult(p, {
-                            output: m.output,
-                            structured,
-                            truncated: m.truncated === true,
-                            isError: m.isError === true,
-                            eventId: typeof m.eventId === 'string' ? m.eventId : undefined,
-                            parentToolCallId: typeof m.parentToolCallId === 'string' ? m.parentToolCallId : undefined,
-                        });
-                        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,
-                                });
-                            }
-                        }
-                        // ── 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',
-                                laneProof: MAIN,
-                                source: 'structured',
-                                structuredType: s.type,
-                                structured: s,
-                            });
-                        }
-                        break;
-                    }
-                    case 'task_progress': {
-                        // ── B4 A 层最后一臂(MF-10)—— 引擎侧子代的累计 usage tick。
-                        // 只带 rollup 数字 = CC `AgentProgress` 同形 ⇒ 忠实的 CC-187 面是 footer 面板行
-                        // (CC 自己对进程外 agent 的先例:面板行 + task-notification,从不合成 inline 消息轨)。
-                        // **不产任何 transcript 消息**:全是 chrome。
-                        const taskId = typeof m.taskId === 'string' ? m.taskId : undefined;
-                        if (taskId === undefined)
-                            break;
-                        const explicitParent = typeof m.parentToolCallId === 'string' ? m.parentToolCallId : 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)。
-                        const workflowRunId = typeof m.workflowRunId === 'string' ? m.workflowRunId : undefined;
-                        if (workflowRunId !== undefined ||
-                            isWorkflowAgentTaskId(taskId) ||
-                            (explicitParent !== undefined && this.seenWorkflowToolCallIds.has(explicitParent))) {
-                            // 判据④ 回植([1641] workflow 启动闪 subagent 行案):本门是「这条 taskId 属 workflow」的
-                            // **权威判定**。同一 taskId 在 fleet 面还有一条 run 发布器双生行(`${runId} ${taskId}`)
-                            // 且那行不带 workflowRunId —— 登进 belt 台账,fleet 行按尾段查它,双生行就再进不了
-                            // footer task 树。🔴 写者在本包、读者(isKnownWorkflowAgentTaskId)也在本包 = R4 纪律,
-                            // 做成 chrome 臂反而会让「宿主没接线 ⇒ Set 恒空 ⇒ 判据④ 静默失效」复活。
-                            recordWorkflowAgentTaskId(taskId);
-                            ctx.probe?.('tick', JSON.stringify({
-                                t: ctx.now(),
-                                taskId,
-                                lane: 'workflow',
-                                via: workflowRunId !== undefined
-                                    ? 'workflowRunId'
-                                    : isWorkflowAgentTaskId(taskId)
-                                        ? 'wa-id'
-                                        : 'workflow-card-parent',
-                            }));
-                            break;
-                        }
-                        // C1 alias:content 帧只带 parentToolCallId(EventIdentity 上没有 taskId),这条 tick
-                        // **两者都带** —— 是 store 学到「停放的内容属哪条引擎行」的唯一位置(查看态按引擎 task id 查)。
-                        if (explicitParent !== undefined)
-                            registerSubagentAlias(explicitParent, taskId);
-                        // 复审修 #1:含糊回落(无显式父 + >1 张未绑候选)⇒ 保持 unbound。
-                        const cardId = explicitParent === undefined && !taskCardBinding.has(taskId) && unboundSubagentCandidates() > 1
-                            ? undefined
-                            : bindTaskCard(taskId, explicitParent);
-                        const usage = (m.usage ?? {});
-                        ctx.probe?.('tick', JSON.stringify({
-                            t: ctx.now(),
-                            taskId,
-                            lane: 'foreground',
-                            parent: explicitParent ?? null,
-                            cardId: cardId ?? null,
-                            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;
-                        // inline 群组行孪生:**绑定了**的 tick 同时喂转录里那条行的统计(按委派卡 id 键)。
-                        if (cardId !== undefined) {
-                            yield chrome({
-                                kind: 'inline_task_stats',
-                                laneProof: { lane: 'subagent', parentToolCallId: cardId },
-                                op: 'tick',
-                                cardId,
-                                stats: {
-                                    toolUses: typeof usage.toolUses === 'number' ? usage.toolUses : 0,
-                                    totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
-                                    durationMs: typeof usage.durationMs === 'number' ? usage.durationMs : 0,
-                                    ...(currentAction !== undefined ? { currentAction } : {}),
-                                },
-                            });
-                        }
-                        const card = cardId !== undefined ? pending.get(cardId) : undefined;
-                        // T50 双形读:`rawInput` 是**改名前**捕获的,真 wire 上引擎子代的 input 是
-                        // {agent, task, taskName} —— 两形都读(CC 名优先)。
-                        const input = (card?.rawInput ?? {});
-                        const description = typeof input.description === 'string'
-                            ? input.description
-                            : typeof input.taskName === 'string' && input.taskName.trim().length > 0
-                                ? input.taskName
-                                : typeof input.task === 'string'
-                                    ? shortTaskLabel(input.task)
-                                    : undefined;
-                        const prompt = typeof input.prompt === 'string'
-                            ? input.prompt
-                            : typeof input.task === 'string'
-                                ? input.task
-                                : undefined;
-                        if (!livePanelTasks.has(taskId)) {
-                            // 这条引擎子代在壳侧**可观测的起点** = 本 turn 的首 tick。
-                            const agentType = typeof m.name === 'string' && m.name.length > 0 ? m.name : 'subagent';
-                            yield* fireSubagentStart(taskId, agentType);
-                        }
-                        // #6 session 常驻台账:live-bound(卡本 turn 开着)= 本 turn 生命周期,turn 末可 sweep;
-                        // inert/unbound(跨 turn bg 子代形)= 常驻,两处 sweep 都放行,终态只认通知帧。
-                        if (liveBoundPanelTasks.has(taskId))
-                            clearEnginePanelTaskResident(taskId);
-                        else
-                            markEnginePanelTaskResident(taskId);
-                        livePanelTasks.add(taskId);
-                        yield chrome({
-                            kind: 'panel_task',
-                            laneProof: laneOfTask(taskId),
-                            event: {
-                                kind: 'tick',
-                                taskId,
-                                ...(typeof m.name === 'string' && m.name.length > 0 ? { name: m.name } : {}),
-                                ...(description !== undefined ? { description } : {}),
-                                ...(prompt !== undefined ? { prompt } : {}),
-                                ...(currentAction !== undefined ? { currentAction } : {}),
-                                // 🔴 这里的 `: 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,
-                            },
-                        });
-                        break;
-                    }
-                    case 'stream_event': {
-                        const ev = m.event;
-                        if (ev && ev.type === 'text_delta' && typeof ev.delta === 'string') {
-                            // MOD-1 思考→回答边界:回答一起头就把思考块 committed 上屏(它推理的内容之前)。
-                            if (thinking.length > 0 || thinkingPending.length > 0) {
-                                yield* drainLive();
-                                yield* takeThinking();
-                            }
-                            if (answerSegment.length === 0)
-                                segmentAnchor = m;
-                            answer += ev.delta;
-                            answerSegment += ev.delta;
-                            textPending += ev.delta;
-                        }
-                        else if (ev && ev.type === 'thinking_delta' && typeof ev.delta === 'string') {
-                            // 子流(parentToolCallId)的推理绝不喂 leader 的计数与预览(#9 的壳侧半场)。
-                            if (ev.parentToolCallId !== undefined)
-                                break;
-                            if (thinking.length === 0) {
-                                thinkingAnchor = m;
-                                // P2d:elapsed 锚在**首条** leader 推理增量(token 累计由 stream_delta.estimatedTokens
-                                // 承载,宿主自加;>30s 无增量的 stall 提示同样由宿主按增量时间戳判)。
-                                yield chrome({ kind: 'thinking_activity', laneProof: MAIN, active: true });
-                            }
-                            thinking += ev.delta;
-                            thinkingPending += ev.delta;
-                        }
-                        break;
-                    }
-                    case 'turn_usage': {
-                        const ot = typeof m.outputTokens === 'number' ? m.outputTokens : undefined;
-                        if (ot != null) {
-                            yield* drainLive();
-                            yield chrome({ kind: 'response_metrics', laneProof: MAIN, phase: 'end', outputTokens: ot });
-                            endEmitted = true;
-                            messageStartEmitted = false; // 下一 model round 重新压基线
-                        }
-                        break;
-                    }
-                    case 'result': {
-                        yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
-                        // MF-10 防御 sweep(sweep 点 1/3):结掉那些卡从没关过的行(流被截断)。
-                        // cli 同位:setRetryStatus(null) 之后、开卡兜底关闭之前。
-                        yield* settlePanelTasks(null, false);
-                        // B5:开卡兜底关闭(cli 同位 —— 在终答文本**之前**,卡才不会挂着空白)。
-                        yield* sweepOpenCards();
-                        yield* takeThinking();
-                        if (!endEmitted) {
-                            const u = m.usage;
-                            if (typeof u?.outputTokens === 'number') {
-                                yield chrome({
-                                    kind: 'response_metrics',
-                                    laneProof: MAIN,
-                                    phase: 'end',
-                                    outputTokens: u.outputTokens,
-                                });
-                                endEmitted = true;
-                            }
-                        }
-                        yield* takeAnswerSegment();
-                        if (!emittedAssistantText) {
-                            const text = typeof m.result === 'string' ? m.result : '';
-                            if (text.length > 0) {
-                                yield transcript({
-                                    type: 'assistant',
-                                    message: { role: 'assistant', content: [{ type: 'text', text }] },
-                                    uuid: idOf(m, 'terminal-text'),
-                                    session_id: ctx.sessionId,
-                                    parent_tool_use_id: null,
-                                });
-                                emittedAssistantText = true;
-                            }
-                        }
-                        break;
-                    }
-                    case 'system': {
-                        yield transcript(m);
-                        // 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;
-                            for (const f of attachedFiles) {
-                                if (typeof f?.path !== 'string' || f.path.length === 0)
-                                    continue;
-                                yield chrome({
-                                    kind: 'attachment',
-                                    laneProof: MAIN,
-                                    id: idOf(m, `attached-file-${i++}`),
-                                    attachment: {
-                                        type: 'compact_file_reference',
-                                        filename: f.path,
-                                        displayPath: f.path,
-                                    },
-                                });
-                            }
-                        }
-                        break;
-                    }
-                    case 'task_notification': {
-                        const n = (m.notification ?? {});
-                        const fields = normalizeTaskNotification(n);
-                        if (fields === null)
-                            break; // 空/缺 task_id:RB-75 同族,丢弃
-                        const taskId = fields.taskId;
-                        const rawStatus = fields.status;
-                        const terminal = rawStatus === 'completed' || rawStatus === 'failed' || rawStatus === 'killed';
-                        // #117a settle 半场 —— **故意在渲染去重之前**:settle 幂等,重放帧仍须 settle 一条
-                        // 首投之后才注册的行。#47 矩阵 #7:只有 bash 行(或老引擎无 task_type)能被 settle。
-                        const settleAllowed = n.task_type === undefined || n.task_type === 'background_bash';
-                        if (settleAllowed && terminal) {
-                            yield chrome({
-                                kind: 'bgshell_settle',
-                                laneProof: MAIN,
-                                taskId,
-                                status: rawStatus,
-                                ...(typeof n.output_file === 'string' && n.output_file.length > 0
-                                    ? { outputPath: n.output_file }
-                                    : {}),
-                            });
-                        }
-                        const dedupKey = taskNotificationDedupKey({
-                            taskId,
-                            status: rawStatus,
-                            ...(typeof n.seq === 'number' || typeof n.seq === 'string' ? { seq: n.seq } : {}),
-                            ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
-                        });
-                        if (this.renderedNotifications.has(dedupKey))
-                            break;
-                        this.renderedNotifications.add(dedupKey);
-                        // B1 + #6 —— 必须在 cardEnqueued 早退**之前**:probe 合成先入队的场景恰是双投主形。
-                        if (n.task_type !== 'external' && terminal) {
-                            yield chrome({
-                                kind: 'notification_terminal',
-                                laneProof: MAIN,
-                                taskId,
-                                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);
-                            if (n.task_type !== 'background_bash') {
-                                // #6 通知-settle 边(推送半场):session 常驻的 bg 子代行不再被 turn sweep 假结,
-                                // 真终态在此落行(failed/killed ⇒ isError 真归因)。
-                                clearEnginePanelTaskResident(taskId);
-                                yield chrome({
-                                    kind: 'panel_task',
-                                    laneProof: MAIN,
-                                    event: { kind: 'end', taskId, isError: rawStatus !== 'completed' },
-                                });
-                                if (!endedPanelTasks.has(taskId)) {
-                                    endedPanelTasks.add(taskId);
-                                    // SubagentStop 只对**真 fire 过 Start** 的子代(workflow runId / 外来 id 不配对乱 fire)。
-                                    // cli 同门 `firedSubagentStartHookTaskIds.has(taskId)` —— B4 前本臂无条件发 stop,
-                                    // 宿主若照 guard 注释自建台账才不会乱 fire;台账在库里就该库来判。
-                                    if (this.firedSubagentStartHookTaskIds.has(taskId)) {
-                                        yield chrome({
-                                            kind: 'subagent_lifecycle',
-                                            laneProof: MAIN,
-                                            phase: 'stop',
-                                            taskId,
-                                            guard: 'if-started',
-                                        });
-                                    }
-                                }
-                            }
-                        }
-                        // 双通道反向去重:probe 合成的完成卡已入队 ⇒ 后到的推送帧只做上面的记账,不渲第二条。
-                        // 🔴 B5 ①:读的是 **module 台账**(cli `isWorkflowCompletionCardEnqueued` 逐字)——
-                        //   记账方(两个 enqueue + idle watcher)与清账方(上面的 drop)都在那儿。
-                        if (n.task_type !== 'external' && isWorkflowCompletionCardEnqueued(taskId))
-                            break;
-                        // 跨通道记账(cli markEngineWorkflowNotified 同位、同条件:非 external,不看终态):
-                        // 这帧到达 = 引擎已 server-side steer-inject 过,补发通道(workflow_complete)不得再注入。
-                        // external 豁免([769] 对抗复审收紧:external 从不经补发通道,mark 只会缴械 probe 兜底)。
-                        if (n.task_type !== 'external')
-                            markEngineWorkflowNotified(taskId);
-                        yield transcript({
-                            type: 'user',
-                            message: { role: 'user', content: [{ type: 'text', text: renderTaskNotificationXml(fields) }] },
-                            uuid: idOf(m),
-                            session_id: ctx.sessionId,
-                        });
-                        break;
-                    }
-                    case 'workflow_complete': {
-                        const runId = typeof m.runId === 'string' ? m.runId : undefined;
-                        if (runId === undefined)
-                            break;
-                        // 跨通道去重(cli enqueueEngineWorkflowNotification 首行):该 run 已由推送帧记账过
-                        // (引擎 server-side 注入过)⇒ Path B 绝不再喂模型一遍。
-                        // 🔴 B5 ①:门与记账都在 module 台账 —— cli 里这一整段就是 enqueueEngineWorkflowNotification
-                        //   的前三行,probe/idle watcher 合成的那两条链写的也是它。
-                        // 🔴 B6 契约钉死(见 seam.ts 本臂注释「门归包、投递归宿主」):门 + 下面两条记号
-                        //   (markEngineWorkflowNotified / noteWorkflowCompletionCardEnqueued)**都在库内**,
-                        //   宿主拿到臂只管裸入队。宿主若借自带同一道门的老函数投递 ⇒ 恒早退、一条都进不了队列。
-                        if (isEngineWorkflowNotified(runId))
-                            break;
-                        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',
-                            laneProof: MAIN,
-                            runId,
-                            status: wfStatus,
-                            summary: wfSummary,
-                            // 模型面正文照铸(宿主直接入队即可,不必各自拼 XML;与 core 的 tag/段序同形)
-                            message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
-                        });
-                        break;
-                    }
-                    case 'diagnostics': {
-                        if (typeof m.parentToolCallId === 'string')
-                            break; // 子流帧不上 leader 面
-                        const att = projectDiagnosticsFrame(m);
-                        if (att === null)
-                            break;
-                        yield chrome({ kind: 'attachment', laneProof: MAIN, id: idOf(m), attachment: att });
-                        break;
-                    }
-                    case 'steering_injected': {
-                        if (typeof m.parentToolCallId === 'string')
-                            break;
-                        const source = typeof m.source === 'string' ? m.source : '';
-                        if (source.length === 0)
-                            break;
-                        const preview = typeof m.preview === 'string' ? m.preview : '';
-                        let i = 0;
-                        for (const att of steeringInjectedToAttachments(source, preview)) {
-                            yield chrome({
-                                kind: 'attachment',
-                                laneProof: MAIN,
-                                id: idOf(m, `steering-${i++}`),
-                                attachment: att,
-                            });
-                        }
-                        break;
-                    }
-                    case 'workspace_changed': {
-                        if (typeof m.parentToolCallId === 'string')
-                            break;
-                        const cwd = typeof m.cwd === 'string' ? m.cwd : '';
-                        if (cwd.length === 0)
-                            break;
-                        yield chrome({
-                            kind: 'attachment',
-                            laneProof: MAIN,
-                            id: idOf(m),
-                            attachment: { type: 'workspace_changed', cwd },
-                        });
-                        break;
-                    }
-                    case 'prompt_suggestions': {
-                        // T57 第五处断闸(#47 矩阵 #5 同族):子流(parentToolCallId 标)的建议绝不骑主 composer。
-                        if (typeof m.parentToolCallId === 'string')
-                            break;
-                        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: MAIN, suggestions: list });
-                        }
-                        break;
-                    }
-                    case 'retry_status': {
-                        // #47 矩阵 #5:子代 lane 帧绝不骑主 spinner(无判别守卫的无条件 store 写=默认可疑)。
-                        if (typeof m.parentToolCallId === 'string')
-                            break;
-                        yield chrome({
-                            kind: 'retry_status',
-                            laneProof: MAIN,
-                            status: mapBrainStatusToRetry({
-                                phase: typeof m.phase === 'string' ? m.phase : '',
-                                ...(typeof m.detail === 'string' ? { detail: m.detail } : {}),
-                                ...(typeof m.retryInSec === 'number' ? { retryInSec: m.retryInSec } : {}),
-                            }, ctx.now()),
-                        });
-                        retryOverlayActive = true;
-                        break;
-                    }
-                    default:
-                        break;
-                }
-                // COALESCER 节拍:一个间隔至多一次 flush(同步 SSE 突发先攒着,过闸再一次泄干)。
-                if (m.type === 'stream_event') {
-                    const now = ctx.now();
-                    if ((textPending.length > 0 || thinkingPending.length > 0) && now - lastFlushAt >= flushEveryMs) {
-                        yield* drainLive();
-                        lastFlushAt = now;
-                    }
-                }
+                    yield* text.drainLive();
+                // ── 分派(拆分前是一个 600 行的 switch;`default:` 空臂 = 表里查不到,行为同)────────────
+                //    单读快照(codex 复审 #1 收货修):旧 switch 对 `m.type` 恰一次属性读,`typeof m.type
+                //    ? m.type` 是两读 —— 对 accessor 形帧可观测,降回一读。
+                const rawType = m.type;
+                const armKey = typeof rawType === 'string' ? rawType : undefined;
+                const arm = armKey !== undefined ? ARMS.get(armKey) : undefined;
+                if (arm !== undefined)
+                    yield* arm(m, deps);
+                // COALESCER 节拍尾(判据 + lastFlushAt 已收进 M1;`ctx.now()` 仍**只在 stream_event 那一拍**
+                // 取,与拆分前逐字同一处时钟读点)。
+                if (m.type === 'stream_event')
+                    yield* text.maybeFlushOnBeat(ctx.now());
             }
         }
         finally {
@@ -1430,23 +303,22 @@ class WireToCcAdapterImpl {
             yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
             yield chrome({ kind: 'thinking_activity', laneProof: MAIN, active: false });
             // 复审修 #2a:被打断的 turn 也**必须**结掉自己的面板行,否则 Esc 之后 footer 药丸永远
-            // 显示 "1 local agent"(sweep 点 2/3)。
-            yield* settlePanelTasks(null, false);
+            // 显示 "1 local agent"(sweep 点 3/4;四点各有正控,见 pure 门 SPLIT 段钉①)。
+            yield* panel.settle(null, false);
             ctx.log?.('debug', 'turn aborted (Esc) — no terminal answer emitted');
             return;
         }
         // T60 —— turn 收口(cli 尾部同序,覆盖"流结束了但没有 result 臂"的路径):
         // 泄尾增量 → 清 liveness → 提交尾思考 → 提交尾文本段。
-        yield* drainLive();
+        yield* text.drainLive();
         yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
-        // 复审修 #2a 孪生:没有 `result` 臂的收尾路径同样 sweep(sweep 点 3/3)。
-        yield* settlePanelTasks(null, false);
+        // 复审修 #2a 孪生:没有 `result` 臂的收尾路径同样 sweep(sweep 点 4/4)。
+        yield* panel.settle(null, false);
         // B5:无 `result` 收尾腿同样关掉还开着的卡(cli 同位;abort 路径**不做**,见上)。
-        yield* sweepOpenCards();
-        yield* takeThinking();
-        yield* takeAnswerSegment();
-        ctx.log?.('debug', `turn done · emittedAssistantText=${emittedAssistantText} answerLen=${answer.length}`);
-        void answer; // 全流无 text 臂时的兜底源(result 臂已消费);保留供调试/后续批
+        yield* cards.sweep();
+        yield* text.takeThinking();
+        yield* text.takeAnswerSegment();
+        ctx.log?.('debug', `turn done · emittedAssistantText=${text.emittedAssistantText} answerLen=${text.answerLength}`);
     }
 }
 /** 造一个带台账的适配器实例(**一个 session 一个**——跨 turn 去重靠实例存活,重启靠 import/export)。 */