@sema-agent/client-core 0.5.0 → 0.7.0

package/dist/adapt.js

@@ -1,8 +1,16 @@
 import { deriveTranscriptId } from './seam.js';
-import { normalizeTaskNotification, renderTaskNotificationXml, taskNotificationDedupKey } from './notifications.js';
+import { dropQueuedNotificationsForRun, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifiedRuns, listWorkflowCompletionCardsEnqueued, markEngineWorkflowNotified, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, 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' };
 /**
@@ -62,6 +70,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(' ');
@@ -82,6 +116,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') {
@@ -114,7 +155,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) {
@@ -137,8 +184,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: [
@@ -157,15 +206,26 @@ export const ADAPTER_COVERAGE = {
         '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 层卡体同一份)',
+    ],
+    /** B5(0.7.0)新落码的臂/半场 —— B/D/E 层收批,同样别再在 todo 里留同名条目。 */
+    b5: [
+        'B 层 structuredToToolUseResult 14 case(ask-user-question/bash/edit/create/update/text/grep/glob/notebook-edit/cron-create/cron-delete/cron-list/agent/task-output)+ workflow-run 登记副作用',
+        'D 层 wireOutputToBody 3 臂(bash / taskoutput / 泛化);structured 白名单在场时 T11+T14 正则退位,缺席保回落',
+        'E 层 4 臂:#117a bg Bash 回执(判定在库→chrome bgshell_register)· TodoWrite oldTodos 富卡 · ReportFindings 按名认领 · Remember→memory_saved 系统消息',
+        'tool_end_result → user tool_result 正常路径(卡本体);result 与 turn 末两处开卡兜底关闭(abort 不兜底,cli 同)',
+        'task/task-list structured → chrome task_ledger_sync{source:"structured"}(判定归一在库、落盘留宿主)',
+        'T7 诚实缺席(§8-4:不搬 mock 合成器,改 degraded 标记)· T20 diff hunks 进包(src/diff/patch.ts)',
+    ],
     /** 如实留白——写不动/依赖未搬运资产的臂,#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 半场里依赖行台账的两件:settlePanelTasks 兜底 sweep + 开卡合成器兜底关卡(见上面两条)',
+        'T13 的 **D 层** 半场(taskoutput block content)未随 structured 退位:退位会改 block content 形状(cli 那里是裸对象 = 件1 隐患),属行为面改动,无真实需求驱动 ⇒ 见 DIVERGENCE-8',
         'macrotask 让渡(cli 在提交前让出宏任务给 Ink;宿主渲染策略,不进库)',
     ],
 };
@@ -182,6 +242,29 @@ export const ADAPTER_DIVERGENCES = [
         '文件探针写 `${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。' +
+        '⚠️ B5 更正范围:同批把 `notifiedRuns`/`cardEnqueuedRuns` **折回 module 台账**(它们与队列 port/' +
+        'idle watcher/outstanding 药丸配对,per-session 会造成前提不共享);本条只剩 ' +
+        '`firedSubagentStartHookTaskIds` 与 `renderedNotifications` 两项仍是实例级。',
+    'DIVERGENCE-7(B5,§8-4 裁定的**有意**分歧):`tool_end.output === undefined` 时 —— cli 用 mock ' +
+        'toolIO 注册表**反造**结果体(卡片显示「看起来像真的、但不是这次执行产物」的内容);本包**诚实缺席**:' +
+        '`content: \'\'` + 消息上打 `_sema_degraded: \'wire_carried_no_output\'`,显示决策留端。' +
+        '依据=宪法「诚实优先于产出」+ 多端复制会各自编不同的假话。差分守卫按「哨兵成对替换 + 独立 oracle」' +
+        '比对(标记集必须恰等于「有 tool_end 但没带 output 的开卡集」,少标/多标两向都红)。',
+    'DIVERGENCE-8(B5):**structured 在场时正则反解退位**(T11/T14;[1840]§一 白名单 + 设计稿 R9②)。' +
+        '同一帧上 cli 从模型面框架文本反解 {stdout,stderr,exitCode},本包直接读 `structured.bash.*`。' +
+        '框架**自洽**时两者逐字节相等(差分守卫 6 条 bash 双路 fixture 实证);不自洽时本包跟 structured ' +
+        '(框架里的尾换行等是渲染副产物)。T13/T24 的 **B 层**半场同款惰性退位(structured 带齐 ' +
+        'status+content 就根本不解模型面文本);T13 的 **D 层** block-content 半场本批**未**退位 —— ' +
+        '那一步会改 block content 形状(cli 在这里是裸对象,件1 隐患),无真实需求驱动,如实留白。',
+    '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';
@@ -192,16 +275,27 @@ const STATUS_TAG = 'status';
  */
 class WireToCcAdapterImpl {
     renderedNotifications = new Set();
-    notifiedRuns = new Set();
-    cardEnqueuedRuns = 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)`)。
+     */
+    firedSubagentStartHookTaskIds = new Set();
     exportLedger() {
         return {
             version: 1,
             renderedNotifications: [...this.renderedNotifications],
-            notifiedRuns: [...this.notifiedRuns],
-            cardEnqueuedRuns: [...this.cardEnqueuedRuns],
+            // B5 ①:这两项是 module 台账的快照(不是实例私有),跨实例一致。
+            notifiedRuns: listNotifiedRuns(),
+            cardEnqueuedRuns: listWorkflowCompletionCardsEnqueued(),
         };
     }
     importLedger(state) {
@@ -216,10 +310,21 @@ class WireToCcAdapterImpl {
                 }
             }
         };
+        /** B5 ①:module 台账那两项经真源写口回植(has 判重 = 与 take 同样只数新增)。 */
+        const takeModule = (v, has, add) => {
+            if (!Array.isArray(v))
+                return;
+            for (const k of v) {
+                if (typeof k === 'string' && k.length > 0 && !has(k)) {
+                    add(k);
+                    n++;
+                }
+            }
+        };
         const s = state;
         take(s.renderedNotifications, this.renderedNotifications);
-        take(s.notifiedRuns, this.notifiedRuns);
-        take(s.cardEnqueuedRuns, this.cardEnqueuedRuns);
+        takeModule(s.notifiedRuns, isEngineWorkflowNotified, markEngineWorkflowNotified);
+        takeModule(s.cardEnqueuedRuns, isWorkflowCompletionCardEnqueued, noteWorkflowCompletionCardEnqueued);
         return n;
     }
     /**
@@ -268,7 +373,9 @@ class WireToCcAdapterImpl {
                     const external = /\btype="external"/.test(attrs);
                     this.renderedNotifications.add(`${external ? 'external:' : ''}${taskId}:${status}`);
                     if (!external && (status === 'completed' || status === 'failed' || status === 'killed')) {
-                        this.notifiedRuns.add(taskId);
+                        // cli seedEngineTaskNotificationDedupFromTranscript 同位:回植走 module 台账
+                        // (outstanding 药丸 / idle watcher 收摊那半场读的就是它)。
+                        markEngineWorkflowNotified(taskId);
                     }
                     seeded++;
                 }
@@ -277,9 +384,15 @@ class WireToCcAdapterImpl {
         return seeded;
     }
     noteCardEnqueued(runId) {
-        this.cardEnqueuedRuns.add(runId);
+        // B5 ①:写 module 台账(与 dropQueuedNotificationsForRun 的清账半场共享前提)。
+        // 壳 B4 的队列端口回钩仍可调它 —— 三条入队链本来就写同一个集合,回钩因此变成幂等 no-op。
+        noteWorkflowCompletionCardEnqueued(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 的稳定键落在
@@ -318,12 +431,213 @@ 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 } : {}),
+                    },
+                });
+            }
+        };
+        // ══ 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)
@@ -481,6 +795,9 @@ class WireToCcAdapterImpl {
                             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({
@@ -588,15 +905,184 @@ class WireToCcAdapterImpl {
                         break;
                     }
                     case 'tool_end_result': {
-                        // 本批只做**卡台账出栈 + response-id 复位**(S1:一个结果关闭该 response,后续 tool_use
-                        // 必须换新 id 才不会被 CC 分组塌成一张卡)。tool_result 消息本体见 ADAPTER_COVERAGE.todo。
+                        // 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;
-                        if (callId !== undefined && pending.has(callId)) {
-                            pending.delete(callId);
-                            assistantResponseId = null;
+                        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 } : {}),
+                                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') {
@@ -638,6 +1124,11 @@ class WireToCcAdapterImpl {
                     }
                     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;
@@ -731,29 +1222,48 @@ class WireToCcAdapterImpl {
                                 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' },
                                 });
-                                yield chrome({
-                                    kind: 'subagent_lifecycle',
-                                    laneProof: MAIN,
-                                    phase: 'stop',
-                                    taskId,
-                                    guard: 'if-started',
-                                });
+                                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))
+                        // 🔴 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')
-                            this.notifiedRuns.add(taskId);
+                            markEngineWorkflowNotified(taskId);
                         yield transcript({
                             type: 'user',
                             message: { role: 'user', content: [{ type: 'text', text: renderTaskNotificationXml(fields) }] },
@@ -767,10 +1277,12 @@ class WireToCcAdapterImpl {
                         if (runId === undefined)
                             break;
                         // 跨通道去重(cli enqueueEngineWorkflowNotification 首行):该 run 已由推送帧记账过
-                        // (引擎 server-side 注入过)⇒ Path B 绝不再喂模型一遍。适配器自持,不摊给宿主。
-                        if (this.notifiedRuns.has(runId))
+                        // (引擎 server-side 注入过)⇒ Path B 绝不再喂模型一遍。
+                        // 🔴 B5 ①:门与记账都在 module 台账 —— cli 里这一整段就是 enqueueEngineWorkflowNotification
+                        //   的前三行,probe/idle watcher 合成的那两条链写的也是它。
+                        if (isEngineWorkflowNotified(runId))
                             break;
-                        this.notifiedRuns.add(runId);
+                        markEngineWorkflowNotified(runId);
                         const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
                         const wfSummary = typeof m.summary === 'string' ? m.summary : '';
                         yield chrome({
@@ -782,7 +1294,7 @@ class WireToCcAdapterImpl {
                             // 模型面正文照铸(宿主直接入队即可,不必各自拼 XML;与 core 的 tag/段序同形)
                             message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
                         });
-                        this.cardEnqueuedRuns.add(runId);
+                        noteWorkflowCompletionCardEnqueued(runId);
                         break;
                     }
                     case 'diagnostics': {
@@ -886,6 +1398,9 @@ class WireToCcAdapterImpl {
         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;
         }
@@ -893,6 +1408,10 @@ class WireToCcAdapterImpl {
         // 泄尾增量 → 清 liveness → 提交尾思考 → 提交尾文本段。
         yield* drainLive();
         yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+        // 复审修 #2a 孪生:没有 `result` 臂的收尾路径同样 sweep(sweep 点 3/3)。
+        yield* settlePanelTasks(null, false);
+        // B5:无 `result` 收尾腿同样关掉还开着的卡(cli 同位;abort 路径**不做**,见上)。
+        yield* sweepOpenCards();
         yield* takeThinking();
         yield* takeAnswerSegment();
         ctx.log?.('debug', `turn done · emittedAssistantText=${emittedAssistantText} answerLen=${answer.length}`);