@sema-agent/client-core 0.4.0 → 0.6.0

package/dist/adapt.js

@@ -1,12 +1,43 @@
 import { deriveTranscriptId } from './seam.js';
-import { normalizeTaskNotification, renderTaskNotificationXml, taskNotificationDedupKey } from './notifications.js';
+import { dropQueuedNotificationsForRun, normalizeTaskNotification, 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 臂只会凭空长出一条「宿主不实现就静默失效」的义务)。
+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' };
-/** cli COALESCER 节流(207 口径;187 时代是 16ms)。宿主无关,时钟从 ctx.now() 取。 */
+/**
+ * 活体增量攒批节拍的**默认值**(时钟从 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 臂同构。
+ */
 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']);
@@ -37,6 +68,32 @@ export function estimateCjkTokens(s) {
     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(' ');
@@ -57,6 +114,13 @@ export function sanitizeToolUseBlock(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') {
@@ -89,7 +153,13 @@ export function sanitizeToolUseBlock(block) {
             delete inp.subagent_type;
         }
     }
-    return { block: out, rawInput, ...(eventId !== undefined ? { eventId } : {}), ...(parentToolCallId !== undefined ? { parentToolCallId } : {}) };
+    return {
+        block: out,
+        rawInput,
+        ...(eventId !== undefined ? { eventId } : {}),
+        ...(parentToolCallId !== undefined ? { parentToolCallId } : {}),
+        ...(label !== undefined ? { label } : {}),
+    };
 }
 /** seam 的 reserved decision 哨兵(cli decisionOf 逐字)。 */
 function decisionOf(block) {
@@ -112,8 +182,10 @@ export const ADAPTER_COVERAGE = {
         'diagnostics',
         'steering_injected',
         'workspace_changed',
+        'prompt_suggestions',
         'retry_status',
-        'tool_end_result(仅 response-id 复位 + 开卡台账出栈,不铸 tool_result)',
+        'task_progress',
+        'tool_end_result(label 补位 + 关卡 settle + response-id 复位 + 开卡台账出栈;不铸 tool_result)',
     ],
     /** 已落码臂产出的 transcript 消息类目(差分守卫的比对域)。 */
     transcriptKinds: [
@@ -124,16 +196,29 @@ export const ADAPTER_COVERAGE = {
         'user_task_notification',
         'system_passthrough',
     ],
+    /** B3(0.5.0)新落码的臂/半场 —— 从 todo 移过来的,别再在 todo 里留同名条目。 */
+    b3: [
+        'T38 三清第三清 + T57 第五处断闸:prompt_suggestions(turn 开场作废 + 子流断闸)',
+        'T40 IDLE-FLUSH 1.5s 竞速(需 ctx.setTimer;缺席=不启用)',
+        'T58 手动 iterator 的 finally cleanup(early break/throw 都要关上游生成器)',
+        'T59 abort 半场(ctx.signal;中断后不产终答)',
+        'T60 无 result 收尾腿(泄尾增量 → 清 liveness → 尾思考 → 尾文本段)',
+    ],
+    /** B4(0.6.0)新落码的臂/半场 —— A 层收官批,同样别再在 todo 里留同名条目。 */
+    b4: [
+        'A 层第 14 臂 task_progress:workflow lane 三级门 + 判据④ belt 回植 + C1 alias + bindTaskCard(显式父/FIFO/含糊即 unbound)+ inline stats + T50 双形读 + SubagentStart + #6 resident 台账 + 面板 tick',
+        'settlePanelTasks 三处 sweep 全接线(tool_end 显式关卡带报告 / result 防御 sweep / turn 末 + abort sweep)',
+        'P0-2 tool label 侧信道(sanitizeToolUseBlock 摘 label + engineToolLabelStore 登记;0.5.0 真缺口,label 会随 tool_use block 落转录 → /compact 直发 provider 400)',
+        'task_notification 的两件宿主义务收回库内自持:dropQueuedNotificationsForRun + clearEnginePanelTaskResident;stop hook 的 if-started 门由库解',
+        'T8 flattenWireOutput 提为独立导出(A 层 settle 报告与 B 层卡体同一份)',
+    ],
     /** 如实留白——写不动/依赖未搬运资产的臂,#52b 起分批接。 */
     todo: [
-        'tool_end_result → user tool_result 正常路径(需搬 wireOutputToBody/structuredToToolUseResult/mock 合成器 + TodoWrite/ReportFindings 富卡片,约 600 行;workflow 轮询信封的人话投影已在 workflow.ts 就位,等这条接线)',
-        'tool_end_result 的两个侧产物:Remember → memory_saved 系统消息、task/task-list structured → 面板台账全量同步',
-        'result/turn 末的开卡兜底关闭(同上,依赖合成器)',
-        'task_progress → 面板行绑定(bindTaskCard FIFO/显式父、inline stats、alias、resident 台账、SubagentStart hook、workflow lane 三级门)',
-        'settlePanelTasks 三处 sweep(依赖上面的行台账)',
-        '#117a bg Bash 回执探测(detectEngineBgShellReceipt 文案锚定探测器)',
-        'abort/Esc 半场(AdapterContext 无 signal 位——见 SEAM-GAP-4)',
-        'IDLE_FLUSH 1.5s 竞速(件1 大 Write 静默窗;需 ctx 侧定时器能力)',
+        'tool_end_result → user tool_result 正常路径(需搬 wireOutputToBody/structuredToToolUseResult/mock 合成器 + TodoWrite/ReportFindings 富卡片,约 600 行;workflow 轮询信封的人话投影已在 workflow.ts 就位,等这条接线)= B5',
+        'tool_end_result 的两个侧产物:Remember → memory_saved 系统消息、task/task-list structured → 面板台账全量同步 = B5',
+        'result/turn 末的开卡兜底关闭(同上,依赖合成器)= B5',
+        '#117a bg Bash 回执探测(detectEngineBgShellReceipt 文案锚定探测器)= B5(E 层按工具名分臂)',
+        'abort 半场里依赖开卡合成器的那件(兜底关卡)= B5;行 sweep 半场 B4 已接',
         'macrotask 让渡(cli 在提交前让出宏任务给 Ink;宿主渲染策略,不进库)',
     ],
 };
@@ -143,8 +228,20 @@ export const ADAPTER_DIVERGENCES = [
         '现役 wire 不产 user 帧(eventToSdkMessage 无该出口),故对真流是惰性的;保留是为了 desktop 重放存量转录。',
     'DIVERGENCE-2:transcript uuid 取值形——cli 铸随机 v4 / 原样透传帧 uuid,adapt 一律走 ' +
         'deriveTranscriptId(稳定键前缀形 `wid_*`)。差分守卫按「别名结构」比对(同一侧内的复用/区分关系),不比字面值。',
-    'DIVERGENCE-3:合并节流的**分片边界**不比对——cli 用 Date.now() 真时钟,adapt 用 ctx.now()。' +
+    'DIVERGENCE-3:合并节流的**分片边界**不比对——cli 用 Date.now() 真时钟,adapt 用 ctx.now();' +
+        '且 B3 起节拍可由宿主 `ctx.coalesceIntervalMs` 覆盖(缺席=cli 同值 100ms)。' +
         '守卫比对的是 chrome 增量按 channel 拼接后的全文与顺序(语义不变量),不是 chunk 切分。',
+    'DIVERGENCE-4(B3):流探针的**开关与时间戳**不同形——cli 是 `process.env.SEMA_STREAM_PROBE` ' +
+        '文件探针写 `${Date.now()} text_flush len=N`,adapt 是 `ctx.probe(\'stream\', …)` 注入口写 ' +
+        '`${ctx.now()} text_flush len=N`。行格式与触发点(每次文本 flush 一次)逐字相同,' +
+        '差在时钟源与落地方式(宿主决定落文件/上报/丢弃)。',
+    'DIVERGENCE-5(B4):A 层行台账的三个探针同 DIVERGENCE-4 处理 —— cli 的 `SEMA_BIND_PROBE` / ' +
+        '`SEMA_TICK_PROBE` / `SEMA_HOOK_PROBE` 三个文件探针,在本包是 `ctx.probe(\'bind\'|\'tick\'|\'hook\', line)`。' +
+        '行载荷逐字同形(tick 是同键序 JSON),只把 `Date.now()` 换成 `ctx.now()`。',
+    'DIVERGENCE-6(B4):`subagent_lifecycle` 的**去重与 if-started 门在库里解**,cli 在 module 级 Set 上解。' +
+        '可观测后果相同(同一 taskId 的 Start 恒一次;没 Start 过的 taskId 收不到通知臂的 Stop),' +
+        '差在「谁持台账」:cli=进程级、本包=适配器实例级(= 一个 session)。多 session 宿主(web 一页两会话)' +
+        '上本包语义**更正确**——cli 的 module 形会让两个会话互吞对方的 Start。',
 ];
 const TASK_NOTIFICATION_TAG = 'task-notification';
 const TASK_ID_TAG = 'task-id';
@@ -159,6 +256,14 @@ class WireToCcAdapterImpl {
     cardEnqueuedRuns = new Set();
     /** 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)`)。
+     */
+    firedSubagentStartHookTaskIds = new Set();
     exportLedger() {
         return {
             version: 1,
@@ -243,6 +348,10 @@ class WireToCcAdapterImpl {
         this.cardEnqueuedRuns.add(runId);
     }
     async *adapt(frames, ctx) {
+        // 下面几个 `function*` 表达式(非箭头 —— generator 不能写成箭头)要访问实例台账,
+        // 它们的 `this` 不是适配器,所以在这里固定一个引用。
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
         const turnStartAt = ctx.now();
         // ── id 派生 ────────────────────────────────────────────────────────────────────────────────
         // [1653]:稳定键优先序 = 帧 id > seq > toolCallId,全缺才 ctx.uuid()。现役 wire 的稳定键落在
@@ -270,6 +379,10 @@ class WireToCcAdapterImpl {
         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;
@@ -277,12 +390,140 @@ class WireToCcAdapterImpl {
         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;
+        };
+        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 {
+                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 } : {}),
+                    },
+                });
+            }
+        };
         /** 提交累积的思考块(cli takeThinking:committed 形 + 关活体块 + 收活动行)。 */
         function* takeThinking() {
             if (thinking.length === 0)
@@ -338,6 +579,10 @@ class WireToCcAdapterImpl {
             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,
@@ -349,417 +594,660 @@ class WireToCcAdapterImpl {
                 textPending = '';
             }
         }
-        // turn 开场卫生(cli:清上一 turn 的 retry 覆盖层 + 思考活动行,再发 request-start)。
+        // turn 开场卫生(T38 三清,cli 逐条同序):清上一 turn 的 retry 覆盖层 + **上一轮的建议批** +
+        // 思考活动行,再发 request-start(T39)。三清缺一都是"上一轮的东西挂着不掉"。
         yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+        yield chrome({ kind: 'prompt_suggestions', laneProof: MAIN, suggestions: null });
         yield chrome({ kind: 'thinking_activity', laneProof: MAIN, active: false });
         yield chrome({ kind: 'request_start', laneProof: MAIN });
-        for await (const rawFrame of frames) {
-            const m = rawFrame;
-            if (m === null || typeof m !== 'object')
-                continue;
-            if (m.type === 'stream_event' && !messageStartEmitted) {
-                messageStartEmitted = true;
-                yield chrome({
-                    kind: 'response_metrics',
-                    laneProof: MAIN,
-                    phase: 'start',
-                    ttftMs: ctx.now() - turnStartAt,
-                });
-            }
-            // 持久臂之前先把活体增量泄干净(活体预览恒先于它 settle 成的 committed 消息)。
-            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';
-                        // 引擎模式下壳工具 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);
+        // ── T40/T58/T59:手动 iterator + IDLE-FLUSH 竞速 + abort 断流 ────────────────────────────────
+        // `for await` 换成手动 next():① 才能与 idle 计时器 race(T40);② 才能在 abort 时立刻停;
+        // 代价是失去 for-await 的隐式 cleanup ⇒ finally 里手动 return()(T58,少了它 = SSE 不拆)。
+        const iterator = frames[Symbol.asyncIterator]();
+        let iteratorDone = 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) {
+                        step = await nextPromise;
                         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;
+                    let idleTimer;
+                    const raced = await Promise.race([
+                        nextPromise.then(r => ({ tag: 'next', r })),
+                        new Promise(resolve => {
+                            idleTimer = ctx.setTimer?.(IDLE_FLUSH_MS, () => resolve({ tag: 'idle' }));
+                        }),
+                    ]);
+                    if (idleTimer !== undefined)
+                        ctx.clearTimer?.(idleTimer);
+                    if (raced.tag === 'next') {
+                        step = raced.r;
                     }
-                    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,
-                        });
+                    else {
+                        if (ctx.signal?.aborted)
+                            break;
+                        // Idle ≥1.5s 且有已生成未提交的内容:现在就上屏(活体预览在前,再按 思考→文本 的
+                        // committed 序 —— 与工具卡前的边界 flush 逐字同序,只是提前发生)。
+                        yield* drainLive();
+                        yield* takeThinking();
+                        yield* takeAnswerSegment();
+                        // 缓冲已空 ⇒ 下一圈直接 plain-await。
                     }
-                    break;
                 }
-                // DIVERGENCE-1 —— 现役 wire 不产 user 帧;透传是给 desktop 重放存量转录留的门。
-                case 'user': {
-                    if (m.message === undefined)
-                        break;
-                    yield transcript({ ...m, uuid: idOf(m), session_id: ctx.sessionId });
+                if (step === undefined)
+                    break; // abort while idle-waiting
+                if (step.done) {
+                    iteratorDone = true;
                     break;
                 }
-                case 'tool_end_result': {
-                    // 本批只做**卡台账出栈 + response-id 复位**(S1:一个结果关闭该 response,后续 tool_use
-                    // 必须换新 id 才不会被 CC 分组塌成一张卡)。tool_result 消息本体见 ADAPTER_COVERAGE.todo。
-                    const callId = typeof m.toolCallId === 'string' ? m.toolCallId : undefined;
-                    if (callId !== undefined && pending.has(callId)) {
-                        pending.delete(callId);
-                        assistantResponseId = null;
-                    }
+                const rawFrame = step.value;
+                // T59 — 信号一跳就停止投影(后续任何臂都不再渲染)。
+                if (ctx.signal?.aborted)
                     break;
+                const m = rawFrame;
+                if (m === null || typeof m !== 'object')
+                    continue;
+                if (m.type === 'stream_event' && !messageStartEmitted) {
+                    messageStartEmitted = true;
+                    yield chrome({
+                        kind: 'response_metrics',
+                        laneProof: MAIN,
+                        phase: 'start',
+                        ttftMs: ctx.now() - turnStartAt,
+                    });
                 }
-                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();
+                // 持久臂之前先把活体增量泄干净(活体预览恒先于它 settle 成的 committed 消息)。
+                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();
-                        }
-                        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)
+                            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;
-                        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 });
-                    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,
+                        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,
                             });
-                            endEmitted = true;
+                            emittedAssistantText = true;
                         }
-                    }
-                    yield* takeAnswerSegment();
-                    if (!emittedAssistantText) {
-                        const text = typeof m.result === 'string' ? m.result : '';
-                        if (text.length > 0) {
+                        const thinkingBlock = blocks.find(b => b?.type === 'thinking');
+                        if (thinkingBlock && typeof thinkingBlock.thinking === 'string') {
                             yield transcript({
                                 type: 'assistant',
-                                message: { role: 'assistant', content: [{ type: 'text', text }] },
-                                uuid: idOf(m, 'terminal-text'),
+                                message: { role: 'assistant', content: [thinkingBlock] },
+                                uuid: idOf(m, 'durable-thinking'),
                                 session_id: ctx.sessionId,
                                 parent_tool_use_id: null,
                             });
-                            emittedAssistantText = true;
                         }
+                        break;
                     }
-                    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;
+                    // 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)。
+                        // tool_result 消息本体(B 层结构化卡)仍见 ADAPTER_COVERAGE.todo → B5。
+                        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);
+                        }
+                        if (callId !== undefined && pending.has(callId)) {
+                            pending.delete(callId);
+                            assistantResponseId = null;
+                        }
+                        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: 'attachment',
-                                laneProof: MAIN,
-                                id: idOf(m, `attached-file-${i++}`),
-                                attachment: {
-                                    type: 'compact_file_reference',
-                                    filename: f.path,
-                                    displayPath: f.path,
+                                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 } : {}),
                                 },
                             });
                         }
-                    }
-                    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) {
+                        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: 'bgshell_settle',
-                            laneProof: MAIN,
-                            taskId,
-                            status: rawStatus,
-                            ...(typeof n.output_file === 'string' && n.output_file.length > 0
-                                ? { outputPath: n.output_file }
-                                : {}),
+                            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 } : {}),
+                                toolUses: typeof usage.toolUses === 'number' ? usage.toolUses : 0,
+                                totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
+                            },
                         });
+                        break;
                     }
-                    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))
+                    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;
-                    this.renderedNotifications.add(dedupKey);
-                    // B1 + #6 —— 必须在 cardEnqueued 早退**之前**:probe 合成先入队的场景恰是双投主形。
-                    if (n.task_type !== 'external' && terminal) {
-                        yield chrome({
-                            kind: 'notification_terminal',
-                            laneProof: MAIN,
+                    }
+                    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);
+                        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 (n.task_type !== 'background_bash') {
-                            yield chrome({
-                                kind: 'panel_task',
-                                laneProof: MAIN,
-                                event: { kind: 'end', taskId, isError: rawStatus !== 'completed' },
-                            });
+                        if (this.renderedNotifications.has(dedupKey))
+                            break;
+                        this.renderedNotifications.add(dedupKey);
+                        // B1 + #6 —— 必须在 cardEnqueued 早退**之前**:probe 合成先入队的场景恰是双投主形。
+                        if (n.task_type !== 'external' && terminal) {
                             yield chrome({
-                                kind: 'subagent_lifecycle',
+                                kind: 'notification_terminal',
                                 laneProof: MAIN,
-                                phase: 'stop',
                                 taskId,
-                                guard: 'if-started',
+                                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 合成的完成卡已入队 ⇒ 后到的推送帧只做上面的记账,不渲第二条。
-                    if (n.task_type !== 'external' && this.cardEnqueuedRuns.has(taskId))
-                        break;
-                    // 跨通道记账(cli markEngineWorkflowNotified 同位、同条件:非 external,不看终态):
-                    // 这帧到达 = 引擎已 server-side steer-inject 过,补发通道(workflow_complete)不得再注入。
-                    // external 豁免([769] 对抗复审收紧:external 从不经补发通道,mark 只会缴械 probe 兜底)。
-                    if (n.task_type !== 'external')
-                        this.notifiedRuns.add(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 绝不再喂模型一遍。适配器自持,不摊给宿主。
-                    if (this.notifiedRuns.has(runId))
+                        // 双通道反向去重:probe 合成的完成卡已入队 ⇒ 后到的推送帧只做上面的记账,不渲第二条。
+                        if (n.task_type !== 'external' && this.cardEnqueuedRuns.has(taskId))
+                            break;
+                        // 跨通道记账(cli markEngineWorkflowNotified 同位、同条件:非 external,不看终态):
+                        // 这帧到达 = 引擎已 server-side steer-inject 过,补发通道(workflow_complete)不得再注入。
+                        // external 豁免([769] 对抗复审收紧:external 从不经补发通道,mark 只会缴械 probe 兜底)。
+                        if (n.task_type !== 'external')
+                            this.notifiedRuns.add(taskId);
+                        yield transcript({
+                            type: 'user',
+                            message: { role: 'user', content: [{ type: 'text', text: renderTaskNotificationXml(fields) }] },
+                            uuid: idOf(m),
+                            session_id: ctx.sessionId,
+                        });
                         break;
-                    this.notifiedRuns.add(runId);
-                    const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
-                    const wfSummary = typeof m.summary === 'string' ? m.summary : '';
-                    yield chrome({
-                        kind: 'workflow_notification_enqueue',
-                        laneProof: MAIN,
-                        runId,
-                        status: wfStatus,
-                        summary: wfSummary,
-                        // 模型面正文照铸(宿主直接入队即可,不必各自拼 XML;与 core 的 tag/段序同形)
-                        message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
-                    });
-                    this.cardEnqueuedRuns.add(runId);
-                    break;
-                }
-                case 'diagnostics': {
-                    if (typeof m.parentToolCallId === 'string')
-                        break; // 子流帧不上 leader 面
-                    const att = projectDiagnosticsFrame(m);
-                    if (att === null)
+                    }
+                    case 'workflow_complete': {
+                        const runId = typeof m.runId === 'string' ? m.runId : undefined;
+                        if (runId === undefined)
+                            break;
+                        // 跨通道去重(cli enqueueEngineWorkflowNotification 首行):该 run 已由推送帧记账过
+                        // (引擎 server-side 注入过)⇒ Path B 绝不再喂模型一遍。适配器自持,不摊给宿主。
+                        if (this.notifiedRuns.has(runId))
+                            break;
+                        this.notifiedRuns.add(runId);
+                        const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
+                        const wfSummary = typeof m.summary === 'string' ? m.summary : '';
+                        yield chrome({
+                            kind: 'workflow_notification_enqueue',
+                            laneProof: MAIN,
+                            runId,
+                            status: wfStatus,
+                            summary: wfSummary,
+                            // 模型面正文照铸(宿主直接入队即可,不必各自拼 XML;与 core 的 tag/段序同形)
+                            message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
+                        });
+                        this.cardEnqueuedRuns.add(runId);
                         break;
-                    yield chrome({ kind: 'attachment', laneProof: MAIN, id: idOf(m), attachment: att });
-                    break;
-                }
-                case 'steering_injected': {
-                    if (typeof m.parentToolCallId === 'string')
+                    }
+                    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;
-                    const source = typeof m.source === 'string' ? m.source : '';
-                    if (source.length === 0)
+                    }
+                    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;
-                    const preview = typeof m.preview === 'string' ? m.preview : '';
-                    let i = 0;
-                    for (const att of steeringInjectedToAttachments(source, preview)) {
+                    }
+                    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, `steering-${i++}`),
-                            attachment: att,
+                            id: idOf(m),
+                            attachment: { type: 'workspace_changed', cwd },
                         });
+                        break;
                     }
-                    break;
-                }
-                case 'workspace_changed': {
-                    if (typeof m.parentToolCallId === 'string')
+                    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;
-                    const cwd = typeof m.cwd === 'string' ? m.cwd : '';
-                    if (cwd.length === 0)
+                    }
+                    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()),
+                        });
                         break;
-                    yield chrome({
-                        kind: 'attachment',
-                        laneProof: MAIN,
-                        id: idOf(m),
-                        attachment: { type: 'workspace_changed', cwd },
-                    });
-                    break;
-                }
-                case 'retry_status': {
-                    // #47 矩阵 #5:子代 lane 帧绝不骑主 spinner(无判别守卫的无条件 store 写=默认可疑)。
-                    if (typeof m.parentToolCallId === 'string')
+                    }
+                    default:
                         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()),
-                    });
-                    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;
+                    }
+                }
             }
-            // COALESCER 节拍:一个间隔至多一次 flush(同步 SSE 突发先攒着,过闸再一次泄干)。
-            if (m.type === 'stream_event') {
-                const now = ctx.now();
-                if ((textPending.length > 0 || thinkingPending.length > 0) && now - lastFlushAt >= FLUSH_INTERVAL_MS) {
-                    yield* drainLive();
-                    lastFlushAt = now;
+        }
+        finally {
+            // T58 — 手动 iterator 没有 for-await 的隐式 cleanup:early break(abort)或抛错都必须关上游
+            // 生成器(SSE 拆链)。正常跑完(done)不用关,上游自己结束了。
+            if (!iteratorDone) {
+                try {
+                    void iterator.return?.();
+                }
+                catch {
+                    // best-effort close — 绝不遮蔽原本的退出路径
                 }
             }
         }
-        // turn 收口(cli 尾部同序):泄尾增量 → 清 liveness → 提交尾思考 → 提交尾文本段。
+        // T59 — abort 后到此为止:不发合成终答、不做兜底(这个 turn 被打断了;CC 自己的 abort 路径
+        // 渲 InterruptedByUser chrome,那是宿主的事)。但**瞬态覆盖层必须收干净**,否则 Esc 之后
+        // 上一轮的 retry 行/思考活动行会一直挂着。
+        if (ctx.signal?.aborted) {
+            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);
+            ctx.log?.('debug', 'turn aborted (Esc) — no terminal answer emitted');
+            return;
+        }
+        // T60 —— turn 收口(cli 尾部同序,覆盖"流结束了但没有 result 臂"的路径):
+        // 泄尾增量 → 清 liveness → 提交尾思考 → 提交尾文本段。
         yield* drainLive();
         yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+        // 复审修 #2a 孪生:没有 `result` 臂的收尾路径同样 sweep(sweep 点 3/3)。
+        yield* settlePanelTasks(null, false);
         yield* takeThinking();
         yield* takeAnswerSegment();
+        ctx.log?.('debug', `turn done · emittedAssistantText=${emittedAssistantText} answerLen=${answer.length}`);
         void answer; // 全流无 text 臂时的兜底源(result 臂已消费);保留供调试/后续批
     }
 }