@sema-agent/client-core 0.12.2 → 0.13.0

package/dist/adapt/arms.js

@@ -0,0 +1,613 @@
+import { dropQueuedNotificationsForRun, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationDedupKey } from '../notifications.js';
+import { mapBrainStatusToRetry } from '../retryStatus.js';
+import { steeringInjectedToAttachments } from '../steering.js';
+import { projectDiagnosticsFrame } from '../diagnostics.js';
+import { recordEngineToolLabel } from '../engineToolLabelStore.js';
+import { registerSubagentAlias } from '../subagentContentStore.js';
+import { isWorkflowAgentTaskId, recordWorkflowAgentTaskId } from '../workflow.js';
+import { chrome, MAIN, transcript } from './ids.js';
+import { CANCEL_MESSAGE, decisionOf, flattenWireOutput, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, TASK_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './wireShapes.js';
+// ══ M2/M1 —— assistant(tool_use 半场 + durable 文本/思考半场)══════════════════════════════════
+const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
+    const message = m.message;
+    const blocks = Array.isArray(message?.content)
+        ? message.content
+        : [];
+    const toolUseIdx = blocks.findIndex(b => b?.type === 'tool_use');
+    // 拆分同批消掉一处 `!` 非空断言(规范禁用):`findIndex >= 0` 与「取到的不是 undefined」
+    // 本来就是同一件事(判别式 `b?.type === 'tool_use'` 对 undefined 恒假),写成显式取值即可。
+    // 收货裁定(codex 复审 #4):旧版此处直接取值使用,畸形帧(accessor/稀疏形,非 JSON 数据帧)
+    // 会抛 TypeError;guard 保留=有意的健壮性变化 —— 正常 wire 帧(JSON.parse 产物)下
+    // `findIndex >= 0 ⇒ 恒非 undefined`,零行为差。
+    const original = toolUseIdx >= 0 ? blocks[toolUseIdx] : undefined;
+    if (original !== undefined) {
+        const decision = decisionOf(original);
+        const san = sanitizeToolUseBlock(original);
+        const renderBlocks = blocks.map((b, i) => (i === toolUseIdx ? san.block : b));
+        const toolUseId = String(san.block.id);
+        const toolName = typeof san.block.name === 'string' ? san.block.name : 'unknown';
+        // P0-2 侧信道:core 展示名进本包台账(渲染块上已被 sanitize 摘掉)。cli 同位、同顺序
+        // (在任何 yield 之前),对 reject/cancel/error 三条早退路径同样生效。
+        // 🔴 时序留钉(矩阵 §2.1①):这必须是臂体的**第一条**副作用语句 —— 挪到下面任何 yield 之后,
+        //    reject/cancel/error 三条早退路径就永远登记不上 label,unknown-tool 卡按 id 查不到展示名。
+        recordEngineToolLabel(toolUseId, san.label);
+        // 引擎模式下壳工具 call() 从不执行 —— ctrl+t 面板台账只能靠这条侧信道(宿主义务)。
+        if (TASK_TOOL_NAMES.has(toolName)) {
+            yield chrome({
+                kind: 'task_ledger_sync',
+                laneProof: MAIN,
+                source: 'tool_use',
+                toolName,
+                toolUseId,
+                input: san.block.input,
+            });
+        }
+        // #27 段序:先把这张卡之前的散文提交,再提交它之前的思考(思考恒在卡上方)。
+        yield* text.takeAnswerSegment();
+        yield* text.takeThinking();
+        yield transcript({
+            type: 'assistant',
+            // S1:per-RESPONSE 铸 id —— CC 的 grouped-agent 渲染按 `${message.id}:${toolName}`
+            // 分组;id-less 帧会把整个 session 的 Agent 卡塌成一张。tool_use 帧才盖章。
+            message: { id: cards.mintResponseId(m), role: 'assistant', content: renderBlocks },
+            uuid: idOf(m),
+            session_id: ctx.sessionId,
+            parent_tool_use_id: null,
+        });
+        if (decision === 'reject' || decision === 'cancel') {
+            // S1:一个结果关闭该 model response。**yield 之前**复位 —— 矩阵 §2.2 定性为
+            // 「形不一致的技术债、不是缺陷」(L1 turn 级、下一句就 return、早退时无读者),
+            // 拆分同批前移成与 tool_end_result / sweep 一致的形,零行为差。
+            cards.resetResponseId();
+            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,
+            });
+            return;
+        }
+        if (decision === 'error') {
+            cards.resetResponseId(); // S1,同上:yield 之前复位
+            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,
+            });
+            return;
+        }
+        // ⟨帧序耦合 1/7 + 3/7⟩ 开卡:后到的 task_progress 才猜得到父、后到的 tool_end 才关得掉卡。
+        cards.open({
+            id: toolUseId,
+            name: toolName,
+            rawInput: san.rawInput,
+            ...(san.eventId !== undefined ? { eventId: san.eventId } : {}),
+            ...(san.parentToolCallId !== undefined ? { parentToolCallId: san.parentToolCallId } : {}),
+        });
+        // ⟨帧序耦合 2/7⟩ W1 判据③ 的素材:只有先见过这张 Workflow 卡,后到的 tick 才判得出 workflow lane。
+        if (WORKFLOW_TOOL_NAMES.has(toolName))
+            inst.markWorkflowCard(toolUseId);
+        return;
+    }
+    const textBlock = blocks.find(b => b?.type === 'text');
+    if (textBlock && typeof textBlock.text === 'string' && textBlock.text.length > 0) {
+        text.appendAnswer(textBlock.text);
+        yield* text.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,
+        });
+        text.markEmittedText();
+    }
+    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,
+        });
+    }
+};
+// ══ M5 纯投影臂(零适配器状态,类型即证明)══════════════════════════════════════════════════════
+/** DIVERGENCE-1 —— 现役 wire 不产 user 帧;透传是给 desktop 重放存量转录留的门。 */
+const userArm = function* (m, { ctx, idOf }) {
+    if (m.message === undefined)
+        return;
+    yield transcript({ ...m, uuid: idOf(m), session_id: ctx.sessionId });
+};
+const systemArm = function* (m, { idOf }) {
+    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,
+                },
+            });
+        }
+    }
+};
+const diagnosticsArm = function* (m, { idOf }) {
+    if (typeof m.parentToolCallId === 'string')
+        return; // 子流帧不上 leader 面
+    const att = projectDiagnosticsFrame(m);
+    if (att === null)
+        return;
+    yield chrome({ kind: 'attachment', laneProof: MAIN, id: idOf(m), attachment: att });
+};
+const steeringInjectedArm = function* (m, { idOf }) {
+    if (typeof m.parentToolCallId === 'string')
+        return;
+    const source = typeof m.source === 'string' ? m.source : '';
+    if (source.length === 0)
+        return;
+    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,
+        });
+    }
+};
+const workspaceChangedArm = function* (m, { idOf }) {
+    if (typeof m.parentToolCallId === 'string')
+        return;
+    const cwd = typeof m.cwd === 'string' ? m.cwd : '';
+    if (cwd.length === 0)
+        return;
+    yield chrome({
+        kind: 'attachment',
+        laneProof: MAIN,
+        id: idOf(m),
+        attachment: { type: 'workspace_changed', cwd },
+    });
+};
+const promptSuggestionsArm = function* (m) {
+    // T57 第五处断闸(#47 矩阵 #5 同族):子流(parentToolCallId 标)的建议绝不骑主 composer。
+    if (typeof m.parentToolCallId === 'string')
+        return;
+    const list = Array.isArray(m.suggestions)
+        ? m.suggestions.filter((s) => typeof s === 'string')
+        : [];
+    // 空批不发(cli 同门:`if (list.length > 0)`)—— 作废由 turn 开场那一发负责,
+    // 这里再发一次 null 会把本轮真产出的建议在极端交错下擦掉。
+    if (list.length > 0) {
+        yield chrome({ kind: 'prompt_suggestions', laneProof: MAIN, suggestions: list });
+    }
+};
+// ══ M2 —— tool_end_result(关卡 + B/D/E 层卡本体 + 两个侧产物)══════════════════════════════════
+const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
+    // B4 起本臂做三件:① P0-2 label 补位(只有 tool_end 带 label 的场景;台账自身幂等不覆盖)
+    // ② MF-10 **关卡 settle**(子代从不发终态 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;
+    // 🔴 时序留钉(矩阵 §2.1①):同 assistant 臂 —— label 登记恒在任何 yield 之前。
+    recordEngineToolLabel(callId, m.label);
+    if (callId !== undefined) {
+        // ⟨帧序耦合 4/7⟩ 关卡 settle(sweep 点 1/4)只结**已发布**的面板行:tick 没到过就没有行可结。
+        yield* panel.settle(callId, m.isError === true, m.output !== undefined ? flattenWireOutput(m.output) : undefined);
+    }
+    const p = callId !== undefined ? cards.peek(callId) : undefined;
+    // ⟨帧序耦合 3/7⟩ 无对应开卡的 tool_end(乱序 / 重复)直接丢(cli 同)。
+    if (p === undefined || callId === undefined)
+        return;
+    const structured = m.structured;
+    // 出栈 + S1 复位(**yield 之前**)已收进 close() —— 见 toolCards.ts 的拆分硬约束。
+    yield* cards.close(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,
+        });
+    }
+};
+// ══ M3 —— task_progress(引擎侧子代的累计 usage tick)══════════════════════════════════════════
+const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
+    // ── B4 A 层最后一臂(MF-10)—— 引擎侧子代的累计 usage tick。
+    // 只带 rollup 数字 = CC `AgentProgress` 同形 ⇒ 忠实的 CC-187 面是 footer 面板行
+    // (CC 自己对进程外 agent 的先例:面板行 + task-notification,从不合成 inline 消息轨)。
+    // **不产任何 transcript 消息**:全是 chrome。
+    const taskId = typeof m.taskId === 'string' ? m.taskId : undefined;
+    if (taskId === undefined)
+        return;
+    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)。
+    // 🔴 codex 独立发现的拆分风险:**本门必须先于任何 panel 写**,否则重造 workflow 幽灵前台行 ——
+    //    这也是它在本臂第一段、`bind()` 之前的原因,别按「先绑定再分类」重排。
+    const workflowRunId = typeof m.workflowRunId === 'string' ? m.workflowRunId : undefined;
+    if (workflowRunId !== undefined ||
+        isWorkflowAgentTaskId(taskId) ||
+        // ⟨帧序耦合 2/7⟩ 依赖 assistant 臂先登记过那张 Workflow 卡。
+        (explicitParent !== undefined && inst.isWorkflowCard(explicitParent))) {
+        // 判据④ 回植([1641] workflow 启动闪 subagent 行案):本门是「这条 taskId 属 workflow」的
+        // **权威判定**。同一 taskId 在 fleet 面还有一条 run 发布器双生行(`${runId} ${taskId}`)
+        // 且那行不带 workflowRunId —— 登进 belt 台账,fleet 行按尾段查它,双生行就再进不了
+        // footer task 树。🔴 写者在本包、读者(isKnownWorkflowAgentTaskId)也在本包 = R4 纪律,
+        // 做成 chrome 臂反而会让「宿主没接线 ⇒ Set 恒空 ⇒ 判据④ 静默失效」复活。
+        recordWorkflowAgentTaskId(taskId);
+        ctx.probe?.('tick', JSON.stringify({
+            t: ctx.now(),
+            taskId,
+            lane: 'workflow',
+            via: workflowRunId !== undefined
+                ? 'workflowRunId'
+                : isWorkflowAgentTaskId(taskId)
+                    ? 'wa-id'
+                    : 'workflow-card-parent',
+        }));
+        return;
+    }
+    // C1 alias:content 帧只带 parentToolCallId(EventIdentity 上没有 taskId),这条 tick
+    // **两者都带** —— 是 store 学到「停放的内容属哪条引擎行」的唯一位置(查看态按引擎 task id 查)。
+    if (explicitParent !== undefined)
+        registerSubagentAlias(explicitParent, taskId);
+    // 复审修 #1:含糊回落(无显式父 + >1 张未绑候选)⇒ 保持 unbound。
+    // ⟨帧序耦合 1/7⟩ FIFO 猜父只看**此刻还开着**的卡,所以 assistant 开卡帧必须先到。
+    const cardId = explicitParent === undefined && !panel.isBound(taskId) && panel.unboundCandidates() > 1
+        ? undefined
+        : panel.bind(taskId, explicitParent);
+    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 ? cards.peek(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;
+    // ⟨帧序耦合 5/7⟩ 首 tick 才 fire Start,而通知臂的 if-started 门读的就是它。
+    if (!panel.isLive(taskId)) {
+        // 这条引擎子代在壳侧**可观测的起点** = 本 turn 的首 tick。
+        const agentType = typeof m.name === 'string' && m.name.length > 0 ? m.name : 'subagent';
+        yield* panel.start(taskId, agentType);
+    }
+    // #6 常驻台账的两个写口整臂让位给 M3(module store 不许两个模块各写各的)。
+    panel.noteResidency(taskId);
+    panel.markLive(taskId);
+    yield chrome({
+        kind: 'panel_task',
+        laneProof: panel.laneOf(taskId),
+        event: {
+            kind: 'tick',
+            taskId,
+            ...(typeof m.name === 'string' && m.name.length > 0 ? { name: m.name } : {}),
+            ...(description !== undefined ? { description } : {}),
+            ...(prompt !== undefined ? { prompt } : {}),
+            ...(currentAction !== undefined ? { currentAction } : {}),
+            // 🔴 这里的 `: 0` 与 `fleetAgentPanelProjection` 那句「绝不在本层 `?? 0`」**不矛盾**,
+            // 因为不是同一条 lane 的同一种供给形(两层的分层实情写在 `engineAgentPanelStore.ts`
+            // 的 `PANEL_TOOLUSES_LANE_POLICY` 上,两条 lane 的可选性由编译钉锁住):
+            //   · **tick lane(本处)**:`usage` 是 core `task_progress` 臂的**必填**字段
+            //     (core 2.12.0 `dist/core/types.d.ts:606-610` 无 `?`),两处发帧点
+            //     (`runner/runtask.js:1080` 每轮边界 / `:2925` 终态 settle 拍)**无条件**构造
+            //     `{ totalTokens, toolUses: stats.toolCalls, durationMs }`,server 白名单整键透传
+            //     (`trace/project.js:118`)⇒ 缺席在这条 lane 上不是「不知道」,是**没有这种帧**。
+            //     值本身是**累计**计数(`stats.toolCalls`,从 0 起算),所以真值域含真 0。
+            //   · **fleet-row lane(那处)**:同名键是 server 1.278.0 才**新加**的可选位,老引擎
+            //     真的不发 ⇒ 缺席就是「不知道」,兜 0 会把它冒充成「跑了 0 个工具」,而且会把
+            //     台账里已知的累计值**擦回 0**。
+            // ⚠️ 别把两层「统一」:把本处改成传播缺席要先把事件形改成可选,而那正是本 lane
+            // 刻意不做的事(`engineAgentPanelStore.ts:54-57` 记的就是这条 —— 复用同一个可选形
+            // 会让 fleet-row lane 每秒把前台子代由真 tick 写进去的进度数字清一次)。
+            toolUses: typeof usage.toolUses === 'number' ? usage.toolUses : 0,
+            totalTokens: typeof usage.totalTokens === 'number' ? usage.totalTokens : 0,
+        },
+    });
+};
+// ══ M1 / M6a —— stream_event / turn_usage ══════════════════════════════════════════════════════
+const streamEventArm = function* (m, { text }) {
+    const ev = m.event;
+    if (ev && ev.type === 'text_delta' && typeof ev.delta === 'string') {
+        yield* text.feedText(ev.delta, m);
+    }
+    else if (ev && ev.type === 'thinking_delta' && typeof ev.delta === 'string') {
+        // 子流(parentToolCallId)的推理绝不喂 leader 的计数与预览(#9 的壳侧半场)。
+        if (ev.parentToolCallId !== undefined)
+            return;
+        yield* text.feedThinking(ev.delta, m);
+    }
+};
+const turnUsageArm = function* (m, { text, flags }) {
+    const ot = typeof m.outputTokens === 'number' ? m.outputTokens : undefined;
+    if (ot !== undefined) {
+        yield* text.drainLive();
+        // ⟨帧序耦合 7/7⟩ 这一拍置 endEmitted,后到的 result 臂据它决定要不要补发 end 度量。
+        yield* flags.emitTurnUsageEnd(ot);
+    }
+};
+// ══ M0 编排半场 —— result(收口三形之一;与 D7/D8 的次序差异见矩阵 §2.4,不可归一)═══════════════
+const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
+    yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+    // MF-10 防御 sweep(sweep 点 2/4):结掉那些卡从没关过的行(流被截断)。
+    // cli 同位:setRetryStatus(null) 之后、开卡兜底关闭之前。
+    yield* panel.settle(null, false);
+    // B5:开卡兜底关闭(cli 同位 —— 在终答文本**之前**,卡才不会挂着空白)。
+    yield* cards.sweep();
+    // 🔴 矩阵 §2.4(b):本臂 takeThinking 在 metrics **之前**、takeAnswerSegment 在 metrics **之后**,
+    //    与 T60 尾的连续两拍**不同序**。看着像可以归一,不能。
+    yield* text.takeThinking();
+    yield* flags.emitResultEndIfNeeded(() => {
+        const u = m.usage;
+        return typeof u?.outputTokens === 'number' ? u.outputTokens : undefined;
+    });
+    yield* text.takeAnswerSegment();
+    if (!text.emittedAssistantText) {
+        // 具名成 terminalText:M1 收编后 `text` 是流合并器的名字,原来的同名局部会遮蔽它。
+        const terminalText = typeof m.result === 'string' ? m.result : '';
+        if (terminalText.length > 0) {
+            yield transcript({
+                type: 'assistant',
+                message: { role: 'assistant', content: [{ type: 'text', text: terminalText }] },
+                uuid: idOf(m, 'terminal-text'),
+                session_id: ctx.sessionId,
+                parent_tool_use_id: null,
+            });
+            text.markEmittedText();
+        }
+    }
+};
+// ══ M4 —— 通知族 ═══════════════════════════════════════════════════════════════════════════════
+const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
+    const n = (m.notification ?? {});
+    const fields = normalizeTaskNotification(n);
+    if (fields === null)
+        return; // 空/缺 task_id:RB-75 同族,丢弃
+    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 } : {}),
+    });
+    // 🔴 时序留钉(矩阵 §2.1④ 的 1377 行判定:**有意序**,别挪):记号在 yield 之前落 ——
+    //    代价是早退窗内该通知既不渲也不再重放(丢一条),而反向(add-after-yield)是重放双渲,更坏。
+    if (inst.hasRenderedNotification(dedupKey))
+        return;
+    inst.addRenderedNotification(dedupKey);
+    // B1 + #6 —— 必须在 cardEnqueued 早退**之前**:probe 合成先入队的场景恰是双投主形。
+    if (n.task_type !== 'external' && terminal) {
+        yield chrome({
+            kind: 'notification_terminal',
+            laneProof: MAIN,
+            taskId,
+            status: rawStatus,
+            ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
+        });
+        // B1 —— 这帧 = 引擎 server-side steer-inject 的回声,模型已在引擎侧收到一遍;把还躺在
+        // 队列里的同 run Path B 条目(workflow_complete/probe/bg feeder)在 turn 收口 drain 前
+        // 丢弃,免得 idle auto-submit 再喂模型一遍(跨进程双投的客户端半场)。
+        // 🔴 B4 起由**适配器自持**(B2 已把队列端口搬进本包):此前挂在 `notification_terminal`
+        // 的宿主义务①,是「说得通但没人做」的典型 —— 宿主没接线就静默双投。
+        dropQueuedNotificationsForRun(taskId);
+        if (n.task_type !== 'background_bash') {
+            // ⟨帧序耦合 5/7⟩ #6 通知-settle 边(推送半场)整段让位给 M3 —— 拆分前这里直写
+            // endedPanelTasks 又直读实例台账的 firedSubagentStartHookTaskIds,是矩阵点名的两条跨模块面。
+            yield* panel.settleFromNotification(taskId, rawStatus !== 'completed');
+        }
+    }
+    // 双通道反向去重:probe 合成的完成卡已入队 ⇒ 后到的推送帧只做上面的记账,不渲第二条。
+    // 🔴 B5 ①:读的是 **module 台账**(cli `isWorkflowCompletionCardEnqueued` 逐字)——
+    //   记账方(两个 enqueue + idle watcher)与清账方(上面的 drop)都在那儿。
+    if (n.task_type !== 'external' && isWorkflowCompletionCardEnqueued(taskId))
+        return;
+    // 跨通道记账(cli markEngineWorkflowNotified 同位、同条件:非 external,不看终态):
+    // 这帧到达 = 引擎已 server-side steer-inject 过,补发通道(workflow_complete)不得再注入。
+    // external 豁免([769] 对抗复审收紧:external 从不经补发通道,mark 只会缴械 probe 兜底)。
+    if (n.task_type !== 'external')
+        markEngineWorkflowNotified(taskId);
+    yield transcript({
+        type: 'user',
+        message: { role: 'user', content: [{ type: 'text', text: renderTaskNotificationXml(fields) }] },
+        uuid: idOf(m),
+        session_id: ctx.sessionId,
+    });
+};
+/**
+ * ⚠️ 本臂声明成 `ProjectionArmFn`(碰不到五个适配器状态模块),但它**有副作用** ——
+ * 写 notifications.ts 的 module 台账。两级 deps 证明的是「不碰适配器状态」,不是「纯」。
+ */
+const workflowCompleteArm = function* (m) {
+    const runId = typeof m.runId === 'string' ? m.runId : undefined;
+    if (runId === undefined)
+        return;
+    // 跨通道去重(cli enqueueEngineWorkflowNotification 首行):该 run 已由推送帧记账过
+    // (引擎 server-side 注入过)⇒ Path B 绝不再喂模型一遍。
+    // 🔴 B5 ①:门与记账都在 module 台账 —— cli 里这一整段就是 enqueueEngineWorkflowNotification
+    //   的前三行,probe/idle watcher 合成的那两条链写的也是它。
+    // 🔴 B6 契约钉死(见 seam.ts 本臂注释「门归包、投递归宿主」):门 + 下面两条记号
+    //   (markEngineWorkflowNotified / noteWorkflowCompletionCardEnqueued)**都在库内**,
+    //   宿主拿到臂只管裸入队。宿主若借自带同一道门的老函数投递 ⇒ 恒早退、一条都进不了队列。
+    if (isEngineWorkflowNotified(runId))
+        return;
+    markEngineWorkflowNotified(runId);
+    const wfStatus = m.status === 'failed' ? 'failed' : 'completed';
+    const wfSummary = typeof m.summary === 'string' ? m.summary : '';
+    // 🔴 B6 时序修(先红后绿,pure 门「早退 ⇒ cardEnqueued 仍落」):这一行原本在 `yield`
+    //   **之后** —— 生成器在 yield 处挂起,后面的语句只有消费者**再要下一个值**时才跑;
+    //   消费者早退(turn 中止 / `it.return()`)时它**永不执行**。而同臂的
+    //   `markEngineWorkflowNotified` 在 yield 之前恒执行 ⇒ 两条记号一条恒落一条条件落,
+    //   且方向正好是坏的那个:notified 落了 ⇒ idle watcher 不补发;cardEnqueued 没落 ⇒
+    //   推送帧到达时判不出卡的所有权 ⇒ **渲第二张完成卡**(B1c 反钉②)。
+    //   现存驱动全是走完整流的 `for await`,所以这条路径此前从未被断言过([1521]F1 同形)。
+    //   两条记号必须同在 yield 之前落 —— 「臂已发出」这件事在 yield 那一刻就已成立。
+    noteWorkflowCompletionCardEnqueued(runId);
+    yield chrome({
+        kind: 'workflow_notification_enqueue',
+        laneProof: MAIN,
+        runId,
+        status: wfStatus,
+        summary: wfSummary,
+        // 模型面正文照铸(宿主直接入队即可,不必各自拼 XML;与 core 的 tag/段序同形)
+        message: renderTaskNotificationXml({ taskId: runId, status: wfStatus, summary: wfSummary }),
+    });
+};
+// ══ M6b —— retry_status ════════════════════════════════════════════════════════════════════════
+const retryStatusArm = function* (m, { ctx, flags }) {
+    // #47 矩阵 #5:子代 lane 帧绝不骑主 spinner(无判别守卫的无条件 store 写=默认可疑)。
+    if (typeof m.parentToolCallId === 'string')
+        return;
+    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()),
+    });
+    // ⟨帧序耦合 6/7⟩ 挂旗;下一个主 lane 内容帧到达时由 TurnFlags 的帧前置清掉(恢复即清)。
+    flags.noteRetryOverlay();
+};
+/**
+ * 帧类型 → 臂。**Map 而不是对象字面量**:`{type:'__proto__'}` 这种 UNTRUSTED 帧命中对象表
+ * 就是原型污染(codex verdict 3)。表里查不到 = 拆分前 `switch` 的 `default:` 空臂,行为同。
+ */
+export const ARMS = new Map([
+    ['assistant', assistantArm],
+    ['user', userArm],
+    ['tool_end_result', toolEndResultArm],
+    ['task_progress', taskProgressArm],
+    ['stream_event', streamEventArm],
+    ['turn_usage', turnUsageArm],
+    ['result', resultArm],
+    ['system', systemArm],
+    ['task_notification', taskNotificationArm],
+    ['workflow_complete', workflowCompleteArm],
+    ['diagnostics', diagnosticsArm],
+    ['steering_injected', steeringInjectedArm],
+    ['workspace_changed', workspaceChangedArm],
+    ['prompt_suggestions', promptSuggestionsArm],
+    ['retry_status', retryStatusArm],
+]);

package/dist/adapt/ids.d.ts

@@ -0,0 +1,22 @@
+import type { AdapterContext, AdapterOutput, ChromeEvent, LaneProof } from '../seam.js';
+/** 帧 = wire 投影出来的中性 arm(cli seam/adapter downstream 的 SDKMessage 形),结构化读取。 */
+export type Frame = Record<string, unknown>;
+/** 主车道证明——本批实现的臂全在 leader lane(子代/workflow lane 的 tick 面留 #52b)。 */
+export declare const MAIN: LaneProof;
+/** 帧 → 稳定转录 id(`suffix` = 同一帧派生多条消息时的去撞位)。 */
+export type IdOf = (frame: Frame, suffix?: string) => string;
+export declare const chrome: (event: ChromeEvent) => AdapterOutput;
+/**
+ * 🔴 入参从裸 `unknown` 收窄成 `Frame`(拆分同批的真收窄,不是搬运):调用点全是「按 CC 词汇
+ * 现拼的对象字面量」或「原样透传的 wire 帧」,两者都是 `Record<string, unknown>` ——
+ * 裸 `unknown` 把窄化义务外包给了每一个调用点,而这里本来就知道自己收的是什么形。
+ * 到 `SDKMessage` 的那一步仍是 cast:CC 词汇的字面形与 SDK 类型有已登记的分歧(DIVERGENCE-2/9),
+ * 这条 cast 是**有意**的边界,不是偷懒。
+ */
+export declare const transcript: (message: Frame) => AdapterOutput;
+/**
+ * [1653]:稳定键优先序 = 帧 id > seq > toolCallId,全缺才 ctx.uuid()。现役 wire 的稳定键落在
+ * `uuid` 字段(§E2 core 铸的 eventId / stamp 铸的帧 id),故映到 `id` 位喂进去(见 SEAM-GAP-1)。
+ * `suffix` = 同一帧派生多条消息时的去撞位(如 tool_use 卡 + 同帧的 reject 结果)。
+ */
+export declare function makeIdOf(ctx: AdapterContext): IdOf;