@sema-agent/client-core 0.76.0 → 0.76.2

package/dist/adapt/panelTasks.js

@@ -1,5 +1,5 @@
 import { clearEnginePanelTaskResident, clearEnginePanelTaskResidentByWire, markEnginePanelTaskResident } from '../engineAgentPanelStore.js';
-import { chrome, MAIN } from './ids.js';
+import { chrome, mainLane } from './ids.js';
 import { SUBAGENT_TOOL_NAMES } from './wireShapes.js';
 export function createPanelTaskLedger(ctx, cards, inst) {
     /** taskId → 绑定的 open tool_use id。 */
@@ -22,7 +22,25 @@ export function createPanelTaskLedger(ctx, cards, inst) {
     const subagentTypeById = new Map();
     const laneOf = (taskId) => {
         const card = taskCardBinding.get(taskId);
-        return card !== undefined ? { lane: 'subagent', parentToolCallId: card } : MAIN;
+        return card !== undefined ? { lane: 'subagent', parentToolCallId: card } : mainLane();
+    };
+    /**
+     * 一条行要发**多条**事件时的车道证明来源(0.76.1,异源对抗复审 R1 [medium] 实测逼出)。
+     *
+     * 病形:终态那两处(关卡 / 终态 tick)此前 `const lane = laneOf(taskId)` 取一次,然后 stop 与
+     * end **两条事件共用那一只** —— 消费者拿到 stop 后改它的归属,同一条行的 end 跟着变;逐条消费
+     * 的宿主甚至能在 end 那一次 `yield` **之前**就把它污染掉(生成器在两条之间是挂起的)。
+     *
+     * 修法**不是**在每条事件那里各调一次 `laneOf`:两次调用之间生成器会挂起,消费者若在这中间绑了卡,
+     * 同一条行的两条事件就会**分流到两个归属**上(一条算主车道、一条算子代)——那比别名更坏。
+     * ⇒ **归属判一次、证明铸多只**:这里把归属(绑到哪张卡 / 没绑)先定死,返回的铸口每次交出一只
+     *   新对象、值恒相同。
+     */
+    const laneMinterFor = (taskId) => {
+        const card = taskCardBinding.get(taskId);
+        return card !== undefined
+            ? () => ({ lane: 'subagent', parentToolCallId: card })
+            : mainLane;
     };
     return {
         laneOf,
@@ -131,7 +149,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 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' });
+                yield chrome({ kind: 'inline_task_stats', laneProof: mainLane(), op: 'settle_all' });
             }
             for (const taskId of livePanelTasks) {
                 if (cardId !== null && taskCardBinding.get(taskId) !== cardId)
@@ -144,18 +162,18 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 if (endedPanelTasks.has(taskId))
                     continue;
                 endedPanelTasks.add(taskId);
-                const lane = laneOf(taskId);
+                const mintLane = laneMinterFor(taskId);
                 const agentType = subagentTypeById.get(taskId);
                 yield chrome({
                     kind: 'subagent_lifecycle',
-                    laneProof: lane,
+                    laneProof: mintLane(),
                     phase: 'stop',
                     taskId,
                     ...(agentType !== undefined ? { agentType } : {}),
                 });
                 yield chrome({
                     kind: 'panel_task',
-                    laneProof: lane,
+                    laneProof: mintLane(),
                     event: {
                         kind: 'end',
                         taskId,
@@ -184,7 +202,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             endedPanelTasks.add(taskId);
             yield chrome({
                 kind: 'panel_task',
-                laneProof: MAIN,
+                laneProof: mainLane(),
                 event: { kind: 'end', taskId, isError },
             });
             // SubagentStop 只对**真 fire 过 Start** 的子代(workflow runId / 外来 id 不配对乱 fire)。
@@ -193,7 +211,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             if (inst.hasFiredSubagentStart(taskId)) {
                 yield chrome({
                     kind: 'subagent_lifecycle',
-                    laneProof: MAIN,
+                    laneProof: mainLane(),
                     phase: 'stop',
                     taskId,
                     guard: 'if-started',
@@ -215,7 +233,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 return;
             endedPanelTasks.add(taskId);
             clearResidencyBothKeys(taskId);
-            const lane = laneOf(taskId);
+            const mintLane = laneMinterFor(taskId);
             const card = taskCardBinding.get(taskId);
             if (card !== undefined) {
                 yield chrome({
@@ -231,7 +249,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
                 const agentType = subagentTypeById.get(taskId);
                 yield chrome({
                     kind: 'subagent_lifecycle',
-                    laneProof: lane,
+                    laneProof: mintLane(),
                     phase: 'stop',
                     taskId,
                     ...(agentType !== undefined ? { agentType } : {}),
@@ -240,7 +258,7 @@ export function createPanelTaskLedger(ctx, cards, inst) {
             }
             yield chrome({
                 kind: 'panel_task',
-                laneProof: lane,
+                laneProof: mintLane(),
                 event: { kind: 'end', taskId, isError },
             });
         },

package/dist/adapt/textStream.js

@@ -1,4 +1,4 @@
-import { chrome, MAIN, transcript, messageIdentityOf } from './ids.js';
+import { chrome, mainLane, transcript, messageIdentityOf } from './ids.js';
 import { estimateCjkTokens, FLUSH_INTERVAL_MS } from './wireShapes.js';
 // L-318:六形判决单源(两条车道同吃;落账各归各层,见 textSegmentAuthority.ts 头注)。
 import { resolveTextSegmentAuthority } from './textSegmentAuthority.js';
@@ -196,7 +196,7 @@ export function createTextStream(ctx, idOf) {
         thinkingAnchor = null;
         thinkingBlockOpen = false;
         // P2d:活体 "∴ Thinking…" 行在 committed 块落地的**同一刻**收掉(先收行再上消息,cli 同序)
-        yield chrome({ kind: 'thinking_activity', laneProof: MAIN, active: false });
+        yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });
         yield transcript(msg, ctx.now());
     }
     /** 段提交的**唯一本体**(两个入口 `takeAnswerSegment` / `takeAnswerSegmentOnIdle` 共用;
@@ -266,7 +266,7 @@ export function createTextStream(ctx, idOf) {
             thinkingBlockOpen = true;
             yield chrome({
                 kind: 'stream_delta',
-                laneProof: MAIN,
+                laneProof: mainLane(),
                 channel: 'thinking',
                 text: thinkingPending,
                 estimatedTokens: estimateCjkTokens(thinkingPending),
@@ -283,7 +283,7 @@ export function createTextStream(ctx, idOf) {
             ctx.probe?.('stream', `${ctx.now()} text_flush len=${textPending.length}`);
             yield chrome({
                 kind: 'stream_delta',
-                laneProof: MAIN,
+                laneProof: mainLane(),
                 channel: 'text',
                 text: textPending,
                 estimatedTokens: estimateCjkTokens(textPending),
@@ -328,7 +328,7 @@ export function createTextStream(ctx, idOf) {
                 //    对照物只在 `reasoning_end` 用过之后清(段界由引擎说了算),turn 结束整只丢,天然有界。
                 // P2d:elapsed 锚在**首条** leader 推理增量(token 累计由 stream_delta.estimatedTokens
                 // 承载,宿主自加;>30s 无增量的 stall 提示同样由宿主按增量时间戳判)。
-                yield chrome({ kind: 'thinking_activity', laneProof: MAIN, active: true });
+                yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: true });
             }
             thinking += delta;
             thinkingPending += delta;

package/dist/adapt/toolCards.js

@@ -1,6 +1,6 @@
 import { deriveTranscriptId } from '../seam.js';
 import { degradedToolResultBody, detectEngineBgShellReceipt, reportFindingsToolUseResult, structuredToToolUseResult, todoWriteToolUseResult, wireOutputToBody, } from '../toolResult.js';
-import { chrome, MAIN, transcript } from './ids.js';
+import { chrome, mainLane, transcript } from './ids.js';
 import { flattenWireOutput } from './wireShapes.js';
 export function createToolCardLedger(ctx, idOf) {
     const pending = new Map();
@@ -26,7 +26,7 @@ export function createToolCardLedger(ctx, idOf) {
         if ((p.name === 'Bash' || p.name === 'Monitor') && !isError && end?.output !== undefined) {
             const reg = detectEngineBgShellReceipt(p.name, p.rawInput, flattenWireOutput(end.output));
             if (reg) {
-                yield chrome({ kind: 'bgshell_register', laneProof: MAIN, taskId: reg.taskId, registration: reg });
+                yield chrome({ kind: 'bgshell_register', laneProof: mainLane(), taskId: reg.taskId, registration: reg });
             }
         }
         // B 层:structured → 逐工具 typed toolUseResult(卡的 outputSchema safeParse 过才渲富卡)。

package/dist/adapt/turnFlags.js

@@ -1,4 +1,4 @@
-import { chrome, MAIN } from './ids.js';
+import { chrome, mainLane } from './ids.js';
 export function createTurnFlags(ctx, turnStartAt) {
     let messageStartEmitted = false;
     let endEmitted = false;
@@ -29,20 +29,20 @@ export function createTurnFlags(ctx, turnStartAt) {
                 // (主 brain 仍可能在退避等待,#47 矩阵 #5 同族判别)。落旗后 `takeRetryOverlay()` 会对随后
                 // 到达的 `recovered` 直报帧返回 false ⇒ 不补第二发(两条腿合计恰好一发)。
                 retryOverlayActive = false;
-                yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+                yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
             }
             if (m.type === 'stream_event' && !messageStartEmitted) {
                 messageStartEmitted = true;
                 yield chrome({
                     kind: 'response_metrics',
-                    laneProof: MAIN,
+                    laneProof: mainLane(),
                     phase: 'start',
                     ttftMs: ctx.now() - turnStartAt,
                 });
             }
         },
         *emitTurnUsageEnd(outputTokens) {
-            yield chrome({ kind: 'response_metrics', laneProof: MAIN, phase: 'end', outputTokens });
+            yield chrome({ kind: 'response_metrics', laneProof: mainLane(), phase: 'end', outputTokens });
             endEmitted = true;
             messageStartEmitted = false; // 下一 model round 重新压基线(与 noteModelRoundBoundary 同一件事)
         },
@@ -55,7 +55,7 @@ export function createTurnFlags(ctx, turnStartAt) {
             const outputTokens = readOutputTokens();
             if (outputTokens === undefined)
                 return;
-            yield chrome({ kind: 'response_metrics', laneProof: MAIN, phase: 'end', outputTokens });
+            yield chrome({ kind: 'response_metrics', laneProof: mainLane(), phase: 'end', outputTokens });
             endEmitted = true;
         },
         noteRetryOverlay: () => {

package/dist/adapt.d.ts

@@ -16,7 +16,7 @@
  * ── A 族拆分后的地图(REF-CC-SPLIT-01~05 / FIX-05,2026-08-02;设计=docs/refactor/ADAPT-RW-MATRIX.md)
  * `adapt()` 曾是 1139 行单方法(26 个 turn 级可变量 + 14 个闭包 + 15 个 case)。现在:
  *   本文件  = 公面契约表 + 适配器实例(台账)+ **驱动壳**(迭代器竞速 / abort / finally / 收口三形)
- *   adapt/ids.ts          零状态共用件(双平面包装、Frame、MAIN、id 派生工厂)
+ *   adapt/ids.ts          零状态共用件(双平面包装、Frame、主车道证明出厂口、id 派生工厂)
  *   adapt/wireShapes.ts   帧形词表 + 纯投影助手(公面十件由本文件具名再导出)
  *   adapt/textStream.ts   M1 流合并器(矩阵 §1.1 十二行状态 + 竞速/节拍两处判据)
  *   adapt/toolCards.ts    M2 工具卡台账(§1.2 三行;S1 复位收进 close() 第一个 yield 前)

package/dist/adapt.js

@@ -9,7 +9,7 @@ import { isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, listNotifie
  */
 export { CANCEL_MESSAGE, estimateCjkTokens, flattenWireOutput, FLUSH_INTERVAL_MS, IDLE_FLUSH_MS, REJECT_MESSAGE, sanitizeToolUseBlock, shortTaskLabel, SUBAGENT_TOOL_NAMES, WORKFLOW_TOOL_NAMES, } from './adapt/wireShapes.js';
 import { IDLE_FLUSH_MS } from './adapt/wireShapes.js';
-import { chrome, MAIN, makeIdOf } from './adapt/ids.js';
+import { chrome, mainLane, makeIdOf } from './adapt/ids.js';
 import { createTextStream } from './adapt/textStream.js';
 import { createToolCardLedger } from './adapt/toolCards.js';
 import { createPanelTaskLedger } from './adapt/panelTasks.js';
@@ -237,10 +237,10 @@ class WireToCcAdapterImpl {
         const deps = { ctx, idOf, text, cards, panel, flags, inst };
         // turn 开场卫生(T38 三清,cli 逐条同序):清上一 turn 的 retry 覆盖层 + **上一轮的建议批** +
         // 思考活动行,再发 request-start(T39)。三清缺一都是"上一轮的东西挂着不掉"。
-        yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
-        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 });
+        yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
+        yield chrome({ kind: 'prompt_suggestions', laneProof: mainLane(), suggestions: null });
+        yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });
+        yield chrome({ kind: 'request_start', laneProof: mainLane() });
         // ── T40/T58/T59:手动 iterator + IDLE-FLUSH 竞速 + abort 断流 ────────────────────────────────
         // `for await` 换成手动 next():① 才能与 idle 计时器 race(T40);② 才能在 abort 时立刻停;
         // 代价是失去 for-await 的隐式 cleanup ⇒ finally 里手动 return()(T58,少了它 = SSE 不拆)。
@@ -342,8 +342,8 @@ class WireToCcAdapterImpl {
         // 渲 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 });
+            yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
+            yield chrome({ kind: 'thinking_activity', laneProof: mainLane(), active: false });
             // 复审修 #2a:被打断的 turn 也**必须**结掉自己的面板行,否则 Esc 之后 footer 药丸永远
             // 显示 "1 local agent"(sweep 点 3/4;四点各有正控,见 pure 门 SPLIT 段钉①)。
             yield* panel.settle(null, false);
@@ -353,7 +353,7 @@ class WireToCcAdapterImpl {
         // T60 —— turn 收口(cli 尾部同序,覆盖"流结束了但没有 result 臂"的路径):
         // 泄尾增量 → 清 liveness → 提交尾思考 → 提交尾文本段。
         yield* text.drainLive();
-        yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+        yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
         // 复审修 #2a 孪生:没有 `result` 臂的收尾路径同样 sweep(sweep 点 4/4)。
         yield* panel.settle(null, false);
         // B5:无 `result` 收尾腿同样关掉还开着的卡(cli 同位;abort 路径**不做**,见上)。

package/dist/adapter/downstream/eventToSdkMessage.d.ts

@@ -35,6 +35,7 @@
  */
 import type { AgentEvent, CheckpointGate } from '@sema-agent/sdk';
 import { type SDKMessage, type EmitContext, type ModelUsage } from '../types.js';
+import { type McpLivenessView } from '../../mcpLiveness.js';
 /**
  * 本适配器铸出的**内部臂** `type` 全集(A-004.4 上游半场,2026-08-08)——「内部臂」= 桥面
  * (bridge-facing)消息,**不是** CC SDK stdout 联合体里的帧形(那些是 assistant/stream_event/
@@ -230,6 +231,17 @@ export interface WiringManifestMcpEntryView {
      *    包再校一遍只会在上游合法演进的当天把一个真读数判没(与 `errorCode` 的开集纪律同规)。
      */
     httpStatus?: number;
+    /**
+     * 引擎最后一次**活性观察**(CC-36;第六键,引擎侧自 core 7.24.3 / server 7.91.2 起)。判据、词表与
+     * 「缺席 = 没有可用观察记录」那四句话的单一铸点在 {@link readMcpLiveness} 的顶注。
+     * 🔴 **缺席不铸**,且缺席**不是** `unknown`:后者是一句更强的断言(引擎看了,看不出来)。
+     * 🔴 与同行的 {@link status} / re-dial 回执**各说各的**,三者不合并、不互证(`status:'failed'` 与
+     *    `liveness.state:'reachable'` 同行是真行:活着,且配错了)。
+     */
+    liveness?: McpLivenessView;
+    /** never false:这一行的活性格**在场而读不出**(与整格缺席不是一句话 —— 「送来一份我读不懂的」要
+     *  能与「引擎没报」分开,否则腿级判词会拿读不出当可达的证据)。 */
+    livenessUnreadable?: true;
 }
 export declare function projectMcpSection(raw: unknown): WiringManifestMcpEntryView[] | undefined;
 /** core 7.20.1(0.71.4):`wiring_manifest.writeProtection` 第七段 —— 写保护判官自报的目标视图(present-iff 这条腿编译出了判官)。 */

package/dist/adapter/downstream/eventToSdkMessage.js

@@ -1,9 +1,10 @@
-import { stamp, } from '../types.js';
+import { stamp, snapshotSegmentIdentity, } from '../types.js';
 import { turnUsageToModelUsage } from './turnUsageToModelUsage.js';
 // 0.60.0(engine ≥7.64.0 / sdk 8.4.0):`tool_end.gate` 的三端共用窄读器(判定归包,端不许自拼)。
 import { gateOutcomeOf } from '../../gateOutcome.js';
 // CC-08(0.71.0):名册与名册增量的窄读器归 toolRoster.ts(0.63.0 起在),本层只接线。
 import { projectToolRoster, projectToolRosterDelta } from '../../toolRoster.js';
+import { readMcpLiveness } from '../../mcpLiveness.js';
 import { SEGMENT_END_IDENTITY_KEYS } from '../types.js';
 // 0.65.0(core 7.12.0 CHANGELOG「Removed (BREAKING)」`WiringManifest.autoMode.breaker`):
 // 熔断族整只退役 ⇒ 本臂此前对 `autoMode.breaker` 的窄读(`classifierBreakerOf`)与它的型位一并
@@ -948,15 +949,8 @@ export function eventToSdkMessage(ev, ctx) {
  * ⚠️ 仍按 `ev[k]` 读(**走原型链**:进程内对象的身份键常长在原型上),只是每键只读一次。
  */
 function identitySnapshot(ev) {
-    const snap = {};
-    try {
-        for (const k of ['eventId', ...SEGMENT_END_IDENTITY_KEYS])
-            snap[k] = ev[k];
-    }
-    catch {
-        return null; // 读身份都会抛的帧不可信 ⇒ 调用方判坏(绝不带着半份身份继续走)
-    }
-    return snap;
+    // 0.76.1:单源 —— 与 adapt 侧各臂共用同一只快照助手(见 adapter/types.ts 的 snapshotSegmentIdentity 头注)。
+    return snapshotSegmentIdentity(ev);
 }
 /** CC-08:三键身份(sdk `EventIdentity`)—— 在场非串 ⇒ 坏值不买路;在场(含空串)⇒ 原样透传;`eventId` 非空才带。
  *  🔴 判据与抄写都取 {@link identitySnapshot} 的**同一份**读数(每键只读一次)。 */
@@ -1119,18 +1113,14 @@ function segmentEndProjection(ev, ctx, arm) {
     // 只带 `sourceTaskId`(无 `parentToolCallId`)是合法的子代帧形。修前只透 `parentToolCallId`,臂只按它断闸 ⇒ 那一形的
     // 子代段末帧被当 leader 投上来,端据它换 leader 的思考/文本行 = 子代推理覆盖 leader 推理面。⇒ 三键**原样穿上内部臂**,
     // 任一键在场却非串 ⇒ 整帧 malformed(与 `parentToolCallId` 同一条 B3-DIRTY 律:坏值不许买路)。
-    for (const k of SEGMENT_END_IDENTITY_KEYS) {
-        if (ev[k] !== undefined && typeof ev[k] !== 'string')
-            return dropped('malformed', arm);
-    }
+    // 0.76.1(外部验收方对 0.76.0 的 F2):此前在同一个表达式里把每只身份键读了两次 ⇒ 「每键恰读一次」在这两条臂上不成立
+    //   (方向 fail-closed:值随读变的合法子代帧被判 malformed)。改走与其余七条内部臂同一只 identityOrMalformed(一次性快照:
+    //   在场非串 ⇒ malformed;在场含空串 ⇒ 原样;`eventId` 非空才带)。
+    const { identity, bad } = identityOrMalformed(ev, arm);
+    if (bad !== null)
+        return bad;
     if (content.length === 0)
         return nothing('empty_payload');
-    const identity = {
-        ...(typeof ev.eventId === 'string' ? { eventId: ev.eventId } : {}),
-        ...(typeof ev.parentToolCallId === 'string' ? { parentToolCallId: ev.parentToolCallId } : {}),
-        ...(typeof ev.sourceTaskId === 'string' ? { sourceTaskId: ev.sourceTaskId } : {}),
-        ...(typeof ev.bgAgentId === 'string' ? { bgAgentId: ev.bgAgentId } : {}),
-    };
     // 两处字面量铸点(不是一处参数化):内部臂词表门按 `armBody({ type: '<字面量>'` 抽铸点,参数化会让两臂在账上「多登记」。
     return arm === 'text_end'
         ? projected(stamp(ctx, armBody({ type: 'text_end', content, ...identity })))
@@ -1159,6 +1149,9 @@ export function projectMcpSection(raw) {
             // S6-B(0.60.0):两位与既有五位同律 —— 逐键挑、开集读、缺席不铸。
             ...(typeof r.delivered === 'string' && r.delivered.length > 0 ? { delivered: r.delivered } : {}),
             ...(typeof r.httpStatus === 'number' && Number.isFinite(r.httpStatus) ? { httpStatus: r.httpStatus } : {}),
+            // CC-36(0.76.1):第六位活性格 —— 判据不在这里写第二遍,全在 readMcpLiveness 那一只铸点里
+            // (三向读数:缺席不铸 / 在场读不出立 never-false 位 / 读得出铸那次观察)。
+            ...((cell) => cell.kind === 'observation' ? { liveness: cell.liveness } : cell.kind === 'unreadable' ? { livenessUnreadable: true } : {})(readMcpLiveness(r)),
         });
     }
     // 🔴 见顶注:`raw.length === 0` 是**正面事实**(照铸 `[]`);非空却零行幸存 = 读不出来 ⇒ 段缺席。

package/dist/adapter/runStream.js

@@ -12,8 +12,17 @@ import { coerceOutput, publishSubagentContentEvent } from '../subagentContentSto
 import { ACTIVE_RUN_BUSY_ERROR_CODE, OUTPUT_INVALID, isLimitsExceededCode } from '../engineErrorCodes.js';
 // 0.60.0(engine ≥7.64.0 / sdk 8.4.0):终局读数的单一读器(纯叶子:零 Node、零宿主端口)。
 import { isReviewPark, readRunTerminal, runTerminalCode } from '../runTerminal.js';
-/** 本文件发的 chrome 事件全在 leader lane(子代内容在上面就被 divert 走了)。 */
-const MAIN = { lane: 'main' };
+/**
+ * 本文件发的 chrome 事件全在 leader lane(子代内容在上面就被 divert 走了)。
+ *
+ * 🔴 **出厂口而不是常量**(0.76.1,与 A 层那半场同一条修法):车道证明在下游会被就地改写,
+ *    一只模块级常量对象会让本文件三个发点(用量臂 / 停靠臂 / 对账臂)与**别的流**的同名事件共享
+ *    同一只证明,一次改写打穿整个进程。每次新建一只。
+ * 🔴 **刻意是本地的一行、不去 import A 层那只同名出厂口**:本文件是适配内核的闭包起点,闭包件数
+ *    是只许降的棘轮 —— 为一行 `{lane:'main'}` 把 A 层(或 seam)拖进内核闭包是拿棘轮换重复,
+ *    这一行字面量本来就是 `LaneProof` 主臂自己的形,不构成第二份判据。
+ */
+const mainLane = () => ({ lane: 'main' });
 /**
  * **fire-and-forget 的 chrome 发射口**(0.66.0 / 异源对抗复审 [high] 逼出的同形族扫)。
  *
@@ -639,7 +648,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                         // (与 turn_end.usage 本身「整体 optional,缺席≠空对象」同一语义,不是「键在值 undefined」)。
                         emitChromeFireAndForget(ctx, {
                             kind: 'last_turn_usage',
-                            laneProof: MAIN,
+                            laneProof: mainLane(),
                             usage,
                             // 🔴 0.68.0:`engineUsage` 的条件 spread 退役 —— `turn_end.usage` 恒在场
                             //    (缺席已在违约闸里整帧收口),这里再判一次就是给一个不可能的形留座位。
@@ -916,7 +925,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
             //    同步 park 腿的 plan-review 卡不弹。因由形那一半覆盖 done 帧的引擎结果,两半各管一条腿。
             if (ev.type === 'done' && isReviewPark(doneTerminal) && ctx.emitChrome) {
                 try {
-                    await ctx.emitChrome({ kind: 'plan_review_park', laneProof: MAIN, result: ev.result });
+                    await ctx.emitChrome({ kind: 'plan_review_park', laneProof: mainLane(), result: ev.result });
                 }
                 catch { /* fail-soft — the terminal frame below still renders */ }
             }
@@ -937,7 +946,7 @@ async function* runStreamInner(events, ctx, handle = {}) {
                 //    `terminalToSdkResult(..., observed)` 是**同一份**读数。
                 const costFacts = readRunCostFacts(doneStats, { usageMissingObserved });
                 if (costFacts !== undefined) {
-                    emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: MAIN, ...costFacts.reconcile });
+                    emitChromeFireAndForget(ctx, { kind: 'run_cost_reconciled', laneProof: mainLane(), ...costFacts.reconcile });
                 }
             }
             // L-228 / 🔴 0.67.2 件 I-2b 订正:分表**不再挂到 `ctx` 上**,而是与观测位一起随第三参按值交给

package/dist/adapter/types.d.ts

@@ -129,3 +129,15 @@ export declare const SEGMENT_END_IDENTITY_KEYS: readonly ["parentToolCallId", "s
  * 参数收任意对象(帧型不限;typeshape 纪律:边界层不让 `unknown` 出境)。
  */
 export declare function isSubFlowSegmentEnd(m: object): boolean;
+/**
+ * 身份四键(`eventId` + 三只子流键)的**一次性快照**:每键恰读一次,读取抛错 ⇒ `null`(= 整帧不可信,调用方拒帧)。
+ *
+ * 🔴 投影口与 adapt 侧的**每一条**读身份的臂都必须走这一只(0.76.1;外部验收方对 0.76.0 的两条发现):
+ *    0.76.0 只把投影口换成了一次性快照,adapt 侧的 compaction 臂仍先判子流再取 `parentToolCallId`(读两次),
+ *    text_end / reasoning_end 的投影更是在同一个表达式里读两次 ⇒ 值随读变的帧让「投影口 → 内部臂」与
+ *    「直喂 adapt()」两条路分叉 —— 正是一次性快照要消灭的那一形,却只修了一侧。
+ *    读了两次的两个值不能相信任何一个;读一次的那一份,两条路都拿同一份。
+ */
+export declare function snapshotSegmentIdentity(m: object): Record<string, unknown> | null;
+/** 与 {@link isSubFlowSegmentEnd} 同一条判据,但吃的是快照(不再回头读帧)。 */
+export declare function snapshotIsSubFlow(snap: Record<string, unknown>): boolean;

package/dist/adapter/types.js

@@ -39,3 +39,33 @@ export function isSubFlowSegmentEnd(m) {
             return true;
     return false;
 }
+/**
+ * 身份四键(`eventId` + 三只子流键)的**一次性快照**:每键恰读一次,读取抛错 ⇒ `null`(= 整帧不可信,调用方拒帧)。
+ *
+ * 🔴 投影口与 adapt 侧的**每一条**读身份的臂都必须走这一只(0.76.1;外部验收方对 0.76.0 的两条发现):
+ *    0.76.0 只把投影口换成了一次性快照,adapt 侧的 compaction 臂仍先判子流再取 `parentToolCallId`(读两次),
+ *    text_end / reasoning_end 的投影更是在同一个表达式里读两次 ⇒ 值随读变的帧让「投影口 → 内部臂」与
+ *    「直喂 adapt()」两条路分叉 —— 正是一次性快照要消灭的那一形,却只修了一侧。
+ *    读了两次的两个值不能相信任何一个;读一次的那一份,两条路都拿同一份。
+ */
+export function snapshotSegmentIdentity(m) {
+    const rec = m;
+    const snap = {};
+    try {
+        for (const k of ['eventId', ...SEGMENT_END_IDENTITY_KEYS])
+            snap[k] = rec[k];
+    }
+    catch {
+        // §C1 带理由的吞:读身份键本身抛 = 这一帧连自己是谁都说不出 ⇒ 整帧拒,由调用方决定「丢」的姿势
+        // (投影口判 malformed 留痕、adapt 侧零 chrome);再向上抛会从两个入口逸出、打断整条 adapt 流。
+        return null;
+    }
+    return snap;
+}
+/** 与 {@link isSubFlowSegmentEnd} 同一条判据,但吃的是快照(不再回头读帧)。 */
+export function snapshotIsSubFlow(snap) {
+    for (const k of SEGMENT_END_IDENTITY_KEYS)
+        if (snap[k] !== undefined)
+            return true;
+    return false;
+}

package/dist/approvalsStreamLiveCapability.js

@@ -13,7 +13,7 @@
  *  ③ 「要不要对账」的判据归包:{@link livePendingNeedsReconcile} —— 只有 present 且 true 才 false;其余一律 true(少查一次 = 一只等人的 ask 迟迟不出现)。
  */
 import { engineWireTarget } from './engineWireTarget.js';
-import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { createEngineCapReader } from './engineCapReader.js';
 /** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
 export function projectApprovalsStreamLiveCapability(caps) {
     if (caps === null || typeof caps !== 'object')
@@ -27,41 +27,23 @@ export function projectApprovalsStreamLiveCapability(caps) {
         return undefined;
     return { kind: 'present', live: v };
 }
-const readingByBase = new Map();
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 各只能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数 {@link projectApprovalsStreamLiveCapability}、doctor 措辞表,以及本位自己的判据助手(如有)。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'approvalsStreamLive',
+    project: projectApprovalsStreamLiveCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
 /** 宿主 caps probe 的读面 tee 落点(与四只兄弟并列)。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
 export function noteEngineCapsForApprovalsStreamLive(baseUrl, caps, opts) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    // 🔴 代际只在入口**快照一次**(异源对抗复审 R3):opts 是调用方的对象,回体上的 getter 能在投影中途改它;首末两次核对都用这份快照,
-    //    读 opts / 读代际抛出 ⇒ 不动格(与陈旧代际同一处置)。
-    const gen = snapshotCapsGeneration(opts);
-    if (gen === null)
-        return; // 调用方 opts 的 getter 抛出 = 供给坏了 ⇒ 不动格
-    if (!capsGenerationStillCurrent(baseUrl, gen))
-        return;
-    let reading;
-    try {
-        reading = projectApprovalsStreamLiveCapability(caps);
-    }
-    catch {
-        // 🔴 0.74.2 同形存量(CC-69 复审 R1 族扫):抛 getter / Proxy 的回体 = 畸形,与「投影答 undefined」同一处置 —— 删格,不许留着上一台的读数。
-        reading = undefined;
-    }
-    // 🔴 投影之后**再核一次代际**(异源对抗复审 R2):投影会执行回体上不可信的 getter,它可以在中途让这一格换代
-    //    (invalidate + 新代际的 tee 已写入);此时无论投影返回还是抛出,都不许动新代际的格。
-    if (!capsGenerationStillCurrent(baseUrl, gen))
-        return;
-    if (reading === undefined) {
-        readingByBase.delete(baseUrl);
-        return;
-    }
-    readingByBase.set(baseUrl, reading);
+    reader.note(baseUrl, caps, opts);
 }
 /** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
 export function observedApprovalsStreamLive(baseUrl = engineWireTarget()?.baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return { kind: 'unobserved' };
-    return readingByBase.get(baseUrl) ?? { kind: 'unobserved' };
+    return reader.observed(baseUrl);
 }
 /**
  * feed 消费方「要不要靠对账节拍拉悬挂 ask」的判据单源:只有引擎明说会推(present ∧ true)才 `false`;
@@ -85,11 +67,9 @@ export function approvalsStreamLiveDoctorDetail(reading) {
 }
 /** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
 export function forgetApprovalsStreamLiveReading(baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    readingByBase.delete(baseUrl);
+    reader.forget(baseUrl);
 }
 /** 测试钩子。 */
 export function __resetApprovalsStreamLiveReadingsForTests() {
-    readingByBase.clear();
+    reader.__resetForTests();
 }

package/dist/deviceExecutorManagementCapability.js

@@ -17,7 +17,7 @@
  *     present ∧ false 与 `lane_absent` ⇒ `'no'`(明确的否);其余 ⇒ `'unknown'`(别当 no,也别当 yes)。
  */
 import { engineWireTarget } from './engineWireTarget.js';
-import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { createEngineCapReader } from './engineCapReader.js';
 /** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
 export function projectDeviceExecutorManagementCapability(caps) {
     if (caps === null || typeof caps !== 'object')
@@ -45,41 +45,23 @@ export function projectDeviceExecutorManagementCapability(caps) {
         return undefined;
     return { kind: 'present', management: mgmt };
 }
-const readingByBase = new Map();
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 各只能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数 {@link projectDeviceExecutorManagementCapability}、doctor 措辞表,以及本位自己的判据助手(如有)。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'deviceExecutor.management',
+    project: projectDeviceExecutorManagementCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
 /** 宿主 caps probe 的读面 tee 落点(与五只兄弟并列)。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
 export function noteEngineCapsForDeviceExecutorManagement(baseUrl, caps, opts) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    // 🔴 代际只在入口**快照一次**(异源对抗复审 R3):opts 是调用方的对象,回体上的 getter 能在投影中途改它;首末两次核对都用这份快照,
-    //    读 opts / 读代际抛出 ⇒ 不动格(与陈旧代际同一处置)。
-    const gen = snapshotCapsGeneration(opts);
-    if (gen === null)
-        return; // 调用方 opts 的 getter 抛出 = 供给坏了 ⇒ 不动格
-    if (!capsGenerationStillCurrent(baseUrl, gen))
-        return;
-    let reading;
-    try {
-        reading = projectDeviceExecutorManagementCapability(caps);
-    }
-    catch {
-        // 🔴 抛 getter / Proxy 的回体 = 畸形(异源对抗复审 R1):与「投影答 undefined」同一处置 —— 删格,不许留着上一台的 yes / no。
-        reading = undefined;
-    }
-    // 🔴 投影之后**再核一次代际**(异源对抗复审 R2):投影会执行回体上不可信的 getter,它可以在中途让这一格换代
-    //    (invalidate + 新代际的 tee 已写入);此时无论投影返回还是抛出,都不许动新代际的格。
-    if (!capsGenerationStillCurrent(baseUrl, gen))
-        return;
-    if (reading === undefined) {
-        readingByBase.delete(baseUrl);
-        return;
-    }
-    readingByBase.set(baseUrl, reading);
+    reader.note(baseUrl, caps, opts);
 }
 /** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
 export function observedDeviceExecutorManagement(baseUrl = engineWireTarget()?.baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return { kind: 'unobserved' };
-    return readingByBase.get(baseUrl) ?? { kind: 'unobserved' };
+    return reader.observed(baseUrl);
 }
 /**
  * 「`/v1/devices/*` 管理动词能不能用」的判据单源(三态):只有引擎明说在场(present ∧ true)才 `'yes'`;
@@ -111,11 +93,9 @@ export function deviceExecutorManagementDoctorDetail(reading) {
 }
 /** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
 export function forgetDeviceExecutorManagementReading(baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    readingByBase.delete(baseUrl);
+    reader.forget(baseUrl);
 }
 /** 测试钩子。 */
 export function __resetDeviceExecutorManagementReadingsForTests() {
-    readingByBase.clear();
+    reader.__resetForTests();
 }