@sema-agent/client-core 0.75.1 → 0.76.1

package/dist/adapt/arms.js

@@ -1,4 +1,4 @@
-import { isSubFlowSegmentEnd } from '../adapter/types.js';
+import { isSubFlowSegmentEnd, SEGMENT_END_IDENTITY_KEYS, snapshotSegmentIdentity, snapshotIsSubFlow } from '../adapter/types.js';
 import { classifyPeerNotification, renderPeerFrameTranscriptText } from '../peerFrames.js';
 import { dropQueuedNotificationsForRun, isEngineWorkflowNotified, isWorkflowCompletionCardEnqueued, markEngineWorkflowNotified, noteOwnWorkflowRun, normalizeTaskNotification, noteWorkflowCompletionCardEnqueued, renderTaskNotificationXml, taskNotificationDedupKey } from '../notifications.js';
 import { mapBrainStatusToRetry } from '../retryStatus.js';
@@ -13,7 +13,7 @@ import { isTerminalStatus } from '../runTerminal.js';
 import { resolveEnginePanelTaskId } from '../engineAgentPanelStore.js';
 // 0.75.1 CC-95(b):子代类型的诚实来源台账(fleet 行帧折进 name 之前留的那一份;包内叶)。
 import { fleetRowAgentType } from '../fleet/fleetRowAgentType.js';
-import { chrome, MAIN, transcript, messageIdentityOf } from './ids.js';
+import { chrome, mainLane, transcript, messageIdentityOf } 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 }) {
@@ -53,7 +53,7 @@ const assistantArm = function* (m, { ctx, idOf, text, cards, inst }) {
         if (TASK_TOOL_NAMES.has(toolName)) {
             yield chrome({
                 kind: 'task_ledger_sync',
-                laneProof: MAIN,
+                laneProof: mainLane(),
                 source: 'tool_use',
                 toolName,
                 toolUseId,
@@ -190,7 +190,7 @@ const systemArm = function* (m, { ctx, idOf }) {
                 continue;
             yield chrome({
                 kind: 'attachment',
-                laneProof: MAIN,
+                laneProof: mainLane(),
                 id: idOf(m, `attached-file-${i++}`),
                 attachment: {
                     type: 'compact_file_reference',
@@ -207,7 +207,7 @@ const diagnosticsArm = function* (m, { idOf }) {
     const att = projectDiagnosticsFrame(m);
     if (att === null)
         return;
-    yield chrome({ kind: 'attachment', laneProof: MAIN, id: idOf(m), attachment: att });
+    yield chrome({ kind: 'attachment', laneProof: mainLane(), id: idOf(m), attachment: att });
 };
 const steeringInjectedArm = function* (m, { idOf }) {
     if (typeof m.parentToolCallId === 'string')
@@ -220,7 +220,7 @@ const steeringInjectedArm = function* (m, { idOf }) {
     for (const att of steeringInjectedToAttachments(source, preview)) {
         yield chrome({
             kind: 'attachment',
-            laneProof: MAIN,
+            laneProof: mainLane(),
             id: idOf(m, `steering-${i++}`),
             attachment: att,
         });
@@ -234,7 +234,7 @@ const workspaceChangedArm = function* (m, { idOf }) {
         return;
     yield chrome({
         kind: 'attachment',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         id: idOf(m),
         attachment: { type: 'workspace_changed', cwd },
     });
@@ -267,7 +267,7 @@ const humanInputArm = function* (m) {
         };
     yield chrome({
         kind: 'human_input',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         carrier,
         ...(str(m.inputId) !== undefined ? { inputId: str(m.inputId) } : {}),
         ...(typeof m.sessionSeq === 'number' && Number.isFinite(m.sessionSeq) ? { sessionSeq: m.sessionSeq } : {}),
@@ -301,7 +301,7 @@ const messageCommittedArm = function* (m) {
         return;
     yield chrome({
         kind: 'message_committed',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         entryId,
         role,
         ...(typeof m.toolCallId === 'string' && m.toolCallId.length > 0 ? { toolCallId: m.toolCallId } : {}),
@@ -336,7 +336,7 @@ const engineNoticeArm = function* (m) {
         : {};
     yield chrome({
         kind: 'engine_notice',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         code,
         message: typeof m.message === 'string' ? m.message : '',
         detail,
@@ -392,7 +392,7 @@ const wiringManifestArm = function* (m) {
         return;
     yield chrome({
         kind: 'wiring_manifest',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         ...(hasGate ? { modelGate: modelGate } : {}),
         ...(hasAuto ? { autoMode: autoMode } : {}),
         ...(hasMcp ? { mcp: mcp } : {}),
@@ -428,7 +428,7 @@ const approvalFrameArm = (kind) => function* (m) {
     const frame = m.frame;
     if (typeof frame !== 'object' || frame === null)
         return;
-    yield chrome({ kind, laneProof: MAIN, frame, schemaVersion });
+    yield chrome({ kind, laneProof: mainLane(), frame, schemaVersion });
 };
 /**
  * `text_end` 内部臂 → **权威段替换** + chrome `text_segment_end`(#323 / core #447;L-310,
@@ -485,7 +485,7 @@ const toolDisclosureArm = function* (m) {
         return; // 二道判:非投影口喂进来的帧
     yield chrome({
         kind: 'tool_disclosure',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         policy,
         ...(typeof m.thresholdPercent === 'number' ? { thresholdPercent: m.thresholdPercent } : {}),
         deferred,
@@ -508,7 +508,7 @@ const toolProgressArm = function* (m) {
     const output = typeof m.output === 'string' ? m.output : undefined;
     yield chrome({
         kind: 'tool_progress',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         toolCallId,
         toolName,
         ...(typeof m.elapsedTimeSeconds === 'number' ? { elapsedSeconds: m.elapsedTimeSeconds } : {}),
@@ -530,7 +530,7 @@ const toolRosterDeltaArm = function* (m) {
         return;
     yield chrome({
         kind: 'tool_roster_delta',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         delta: delta,
         ...(typeof m.eventId === 'string' && m.eventId.length > 0 ? { eventId: m.eventId } : {}),
     });
@@ -551,7 +551,7 @@ const contextUsageArm = function* (m) {
         return;
     yield chrome({
         kind: 'context_usage',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         ...(usedTokens !== undefined ? { usedTokens } : {}),
         ...(windowTokens !== undefined ? { windowTokens } : {}),
         ...(compactAtTokens !== undefined ? { compactAtTokens } : {}),
@@ -569,16 +569,21 @@ const compactionOutcomeArm = function* (m) {
     const outcome = str(m.outcome);
     if (outcome === undefined)
         return;
-    let laneProof = MAIN;
-    if (isSubFlowSegmentEnd(m)) {
-        const parent = str(m.parentToolCallId);
+    // 🔴 身份四键一次性快照(0.76.1;外部验收方对 0.76.0 的 F1):修前先 isSubFlowSegmentEnd(m) 再 str(m.parentToolCallId),
+    //    parentToolCallId 读了两次 ⇒ 值随读变的帧让直喂入口丢事件、经投影却出 subagent chrome —— 两入口分叉。
+    const idSnap = snapshotSegmentIdentity(m);
+    if (idSnap === null)
+        return; // 读身份就抛 ⇒ 整帧拒(与投影口判 malformed 同一处置,不发 chrome)
+    let laneProof = mainLane();
+    if (snapshotIsSubFlow(idSnap)) {
+        const parent = str(idSnap.parentToolCallId);
         if (parent === undefined)
             return;
         laneProof = { lane: 'subagent', parentToolCallId: parent };
     }
     const trigger = str(m.trigger);
     const reason = str(m.reason);
-    const eventId = str(m.eventId);
+    const eventId = str(idSnap.eventId);
     yield chrome({
         kind: 'compaction_outcome',
         laneProof,
@@ -588,6 +593,94 @@ const compactionOutcomeArm = function* (m) {
         ...(eventId !== undefined ? { eventId } : {}),
     });
 };
+/**
+ * CC-91(0.76.0):逐行**重建**白名单行(不是 `Array.isArray` 就整只透传)——
+ * 🔴 本臂与投影口是**两个入口**:宿主自建管线 / 重放存量转录可以绕过投影口直接把 wire 帧喂进 `adapt()`,
+ *    那条路上未校验的行会把本臂对外承诺的四条(零 `tokens`、零 digest 过境、`chars` 有限非负、全坏即缺席)
+ *    一起破掉,还可能把违反公开型的行(`null` / `chars: -1`)递到消费端手里
+ *    (异源对抗复审 R1 [medium] 实测可复现:`sections:[{id:'x',chars:-1,tokens:123,contentHash:'…'}]` 原样进 chrome)。
+ *    ⇒ 与投影口**同律同形**:好行留、坏行逐条丢、全丢光或非数组 ⇒ 键缺席(不铸 `[]`)。
+ *    两处实现由门逐字对拍(同一帧走投影口 vs 直喂 adapt,chrome 行必须一模一样),drift 即红。
+ */
+const promptManifestRows = (v, pick) => {
+    if (!Array.isArray(v))
+        return undefined;
+    const rows = [];
+    for (const r of v) {
+        if (typeof r !== 'object' || r === null || Array.isArray(r))
+            continue;
+        const row = pick(r);
+        if (row !== undefined)
+            rows.push(row);
+    }
+    return rows.length > 0 ? rows : undefined;
+};
+/**
+ * CC-91(0.76.0):`prompt_assembled` 内部臂 → chrome `prompt_assembled`。每帧一条;转录面零行。
+ * 🔴 **包不去重**:一次任务的每一次 prepare(cascade / verify 的每一 rung、resume 腿)各自一条,server 逐条保序落账 ⇒
+ *    每条都交出去,「只要最后一次」是**宿主**的动作(与 `context_usage` 同律;在包内按最后一条折会把先前已计费 rung 的组成面抹掉)。
+ *    ⚠️ 上游那条流的**重放去重**是另一件事,按 `eventSeq` 在 `adapter/runStream.ts` 做;本臂只说「同一条流上的多条 prepare 都算真事实」。
+ * 🔴 lane 如实:`parentToolCallId` 非空串 ⇒ subagent;只有 `sourceTaskId` / `bgAgentId`(或父键空串)的帧没有诚实的 lane 可挂 ⇒ 不发,
+ *    绝不落到主会话名下。一条组成面的键都读不出的帧不发(非投影口喂进来的坏帧兜底)。
+ * 🔴 **零 tokens 铸点**:本臂只搬 `chars`(上游真字节无 token 位),不在这一层编任何 token 数。
+ */
+const promptAssembledArm = function* (m) {
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const size = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined);
+    // ⚠️ 帧上的 `constitution` 刻意不过境(投影口头注写明理由:今天零消费场景,键即契约)。
+    const totalChars = size(m.totalChars);
+    const blocks = promptManifestRows(m.blocks, (o) => {
+        const id = str(o.id);
+        const chars = size(o.chars);
+        return id === undefined || chars === undefined ? undefined : { id, chars };
+    });
+    const sections = promptManifestRows(m.sections, (o) => {
+        const id = str(o.id);
+        const chars = size(o.chars);
+        if (id === undefined || chars === undefined)
+            return undefined;
+        // 🔴 语义槽在**两个入口上都只认一个键名** `slot`(上游的名字,本层不改名):投影口产物与 wire 原形同名,
+        //    所以两条路读的是同一个位。曾经的写法是「`kind` 优先、回退 `slot`」—— 那会让一条**同时**带
+        //    `kind` 与 `slot`(或只带 `kind`)的帧在两条路上读出不同的槽,而这种帧是合法的(上游行是开集)。
+        const slot = str(o.slot);
+        return { id, chars, ...(slot !== undefined ? { slot } : {}) };
+    });
+    const tools = promptManifestRows(m.tools, (o) => {
+        const wireName = str(o.wireName);
+        return wireName === undefined ? undefined : { wireName };
+    });
+    if (totalChars === undefined && blocks === undefined && sections === undefined && tools === undefined)
+        return;
+    // 🔴 身份四键**一次性快照**,与投影口的 `identitySnapshot` / `identityOrMalformed` 同律(每键只读一次、抛错整帧拒):
+    //    ① 三个子流键**逐个**过形门(在场即必须是串)—— 只守 `parentToolCallId` 的话,一条
+    //       `{parentToolCallId:'tc-9', sourceTaskId: 7}` 会在投影口被整帧判坏、在直喂这条路上照发一条 subagent chrome;
+    //    ② **不能就地多读**:进程内帧可以带 accessor,同一个键读两次拿到两个值时,「形门读一次、子流判定再读一次、
+    //       取 parent 又读一次」会让同一帧在两条路上归属不同 lane —— 子代的组成信息被洗成主会话的
+    //       (第三轮复审 [medium] 实测可复现)。所以这里**不**用 `isSubFlowSegmentEnd(m)`(它会再读一遍),
+    //       子流判定直接看快照里「三键有没有在场」,语义与它逐字同(键在场 = 子代帧,空串也算在场)。
+    const idSnap = snapshotSegmentIdentity(m);
+    if (idSnap === null)
+        return; // 读身份就抛 ⇒ 整帧拒(理由见 snapshotSegmentIdentity 头注与本臂上方的说明)
+    if (SEGMENT_END_IDENTITY_KEYS.some((k) => idSnap[k] !== undefined && typeof idSnap[k] !== 'string'))
+        return;
+    let laneProof = mainLane();
+    if (SEGMENT_END_IDENTITY_KEYS.some((k) => idSnap[k] !== undefined)) {
+        const parent = str(idSnap.parentToolCallId);
+        if (parent === undefined)
+            return;
+        laneProof = { lane: 'subagent', parentToolCallId: parent };
+    }
+    const eventId = str(idSnap.eventId);
+    yield chrome({
+        kind: 'prompt_assembled',
+        laneProof,
+        ...(totalChars !== undefined ? { totalChars } : {}),
+        ...(blocks !== undefined ? { blocks } : {}),
+        ...(sections !== undefined ? { sections } : {}),
+        ...(tools !== undefined ? { tools } : {}),
+        ...(eventId !== undefined ? { eventId } : {}),
+    });
+};
 const textSegmentEndArm = function* (m, { text }) {
     // 🔴 断闸按「**键在不在**」判,不按「是不是串」判(异源对抗复审第三轮 [medium] 采纳)。
     //    投影层已对坏 lane 位整帧 fail-closed;这一道是给**非投影口**喂进来的帧(宿主自建管线 /
@@ -606,7 +699,7 @@ const textSegmentEndArm = function* (m, { text }) {
     const r = text.replaceAnswerSegment(content, m);
     yield chrome({
         kind: 'text_segment_end',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         content,
         // CC-01:帧上带的是**轮换前**的段身份 —— 与本段已过境的 committed 行同值(归属的第二把钥匙)。
         segmentId: text.segmentId(),
@@ -638,7 +731,7 @@ const thinkingSegmentEndArm = function* (m, { text }) {
     const r = text.replaceThinkingSegment(content, m);
     yield chrome({
         kind: 'thinking_segment_end',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         content,
         ...(r.diverged ? { diverged: true } : {}),
         ...(r.committedPrefixDiverged ? { committedPrefixDiverged: true } : {}),
@@ -659,7 +752,7 @@ const promptSuggestionsArm = function* (m) {
     // 空批不发(cli 同门:`if (list.length > 0)`)—— 作废由 turn 开场那一发负责,
     // 这里再发一次 null 会把本轮真产出的建议在极端交错下擦掉。
     if (list.length > 0) {
-        yield chrome({ kind: 'prompt_suggestions', laneProof: MAIN, suggestions: list });
+        yield chrome({ kind: 'prompt_suggestions', laneProof: mainLane(), suggestions: list });
     }
 };
 // ══ M2 —— tool_end_result(关卡 + B/D/E 层卡本体 + 两个侧产物)══════════════════════════════════
@@ -705,14 +798,19 @@ const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
     if (p === undefined || callId === undefined)
         return;
     const structured = m.structured;
+    // 身份键各读一次(0.76.1:此前 typeof 再取值 = 读两次;值随读变的帧会让判形与取值各看一份)。
+    const closeEventIdRaw = m.eventId;
+    const closeParentRaw = m.parentToolCallId;
+    const closeEventId = typeof closeEventIdRaw === 'string' ? closeEventIdRaw : undefined;
+    const closeParent = typeof closeParentRaw === 'string' ? closeParentRaw : undefined;
     // 出栈 + 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,
+        eventId: closeEventId,
+        parentToolCallId: closeParent,
     });
     const s = structured !== undefined && structured !== null && typeof structured === 'object'
         ? structured
@@ -740,7 +838,7 @@ const toolEndResultArm = function* (m, { ctx, idOf, cards, panel }) {
     if (s && (s.type === 'task' || s.type === 'task-list')) {
         yield chrome({
             kind: 'task_ledger_sync',
-            laneProof: MAIN,
+            laneProof: mainLane(),
             source: 'structured',
             structuredType: s.type,
             structured: s,
@@ -763,10 +861,12 @@ const taskProgressArm = function* (m, { ctx, cards, panel, inst }) {
     // 只带 rollup 数字 = CC `AgentProgress` 同形 ⇒ 忠实的 CC-187 面是 footer 面板行
     // (CC 自己对进程外 agent 的先例:面板行 + task-notification,从不合成 inline 消息轨)。
     // **不产任何 transcript 消息**:全是 chrome。
-    const taskId = typeof m.taskId === 'string' ? m.taskId : undefined;
+    const taskIdRaw = m.taskId;
+    const taskId = typeof taskIdRaw === 'string' ? taskIdRaw : undefined;
     if (taskId === undefined)
         return;
-    const explicitParent = typeof m.parentToolCallId === 'string' ? m.parentToolCallId : undefined;
+    const explicitParentRaw = m.parentToolCallId; // 读一次(0.76.1:typeof 再取值 = 读两次)
+    const explicitParent = typeof explicitParentRaw === 'string' ? explicitParentRaw : 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
@@ -982,7 +1082,7 @@ function prefixOf(whole, part) {
     return null;
 }
 const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
-    yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+    yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
     // MF-10 防御 sweep(sweep 点 2/4):结掉那些卡从没关过的行(流被截断)。
     // cli 同位:setRetryStatus(null) 之后、开卡兜底关闭之前。
     yield* panel.settle(null, false);
@@ -1073,7 +1173,7 @@ const resultArm = function* (m, { ctx, idOf, text, cards, panel, flags }) {
         //    改口。两个位是**长度**不是内容 —— 不复述任何一份正文。
         yield chrome({
             kind: 'result_text_diverged',
-            laneProof: MAIN,
+            laneProof: mainLane(),
             committedLength: committed.length,
             resultLength: terminalText.length,
         });
@@ -1098,7 +1198,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
     if (settleAllowed && terminal) {
         yield chrome({
             kind: 'bgshell_settle',
-            laneProof: MAIN,
+            laneProof: mainLane(),
             taskId,
             status: rawStatus,
             ...(typeof n.output_file === 'string' && n.output_file.length > 0
@@ -1121,7 +1221,7 @@ const taskNotificationArm = function* (m, { ctx, idOf, panel, inst }) {
     if (n.task_type !== 'external' && terminal) {
         yield chrome({
             kind: 'notification_terminal',
-            laneProof: MAIN,
+            laneProof: mainLane(),
             taskId,
             status: rawStatus,
             ...(typeof n.task_type === 'string' ? { taskType: n.task_type } : {}),
@@ -1225,7 +1325,7 @@ const workflowCompleteArm = function* (m) {
     noteWorkflowCompletionCardEnqueued(runId);
     yield chrome({
         kind: 'workflow_notification_enqueue',
-        laneProof: MAIN,
+        laneProof: mainLane(),
         runId,
         status: wfStatus,
         summary: wfSummary,
@@ -1278,10 +1378,10 @@ const retryStatusArm = function* (m, { ctx, flags }) {
     // 首版写成「无条件发 + clearRetryOverlay」,在常态顺序上双清(对抗复审命中)。
     if (status === null) {
         if (flags.takeRetryOverlay())
-            yield chrome({ kind: 'retry_status', laneProof: MAIN, status: null });
+            yield chrome({ kind: 'retry_status', laneProof: mainLane(), status: null });
         return;
     }
-    yield chrome({ kind: 'retry_status', laneProof: MAIN, status });
+    yield chrome({ kind: 'retry_status', laneProof: mainLane(), status });
     // ⟨帧序耦合 6/7⟩ 挂旗;下一个主 lane 内容帧到达时由 TurnFlags 的帧前置清掉(恢复即清)。
     flags.noteRetryOverlay();
 };
@@ -1315,6 +1415,8 @@ export const ARMS = new Map([
     ['context_usage', contextUsageArm],
     // CC-89(0.75.0):压缩的非 compacted 结局(additive;不接 = 压缩失败对用户不可见)。
     ['compaction_outcome', compactionOutcomeArm],
+    // CC-91(0.76.0):这一次 prepare 的提示词装配清单(additive;不接 = 端只能按本地镜像自己估)。
+    ['prompt_assembled', promptAssembledArm],
     ['wiring_manifest', wiringManifestArm],
     // B-078 / L-208(0.65.0):design/172 流内审批两帧 —— 修前它们在投影层就 `dropped`,
     // 壳自己另接一份 ⇒ desktop/web 拿不到卡集与撤卡(归层违例)。

package/dist/adapt/ids.d.ts

@@ -1,8 +1,35 @@
 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;
+/**
+ * 主车道证明的**出厂口** —— 每次调用交出一只**新的** `{lane:'main'}`(本批实现的臂全在 leader
+ * lane;子代/workflow lane 的 tick 面留 #52b)。
+ *
+ * 🔴 **为什么是函数不是常量**(0.76.1)。此前这里是一只模块级常量对象,`laneOf(未登记 id)` 与本包
+ *    约五十个 `laneProof:` 主车道发点交出去的是**同一只**对象 —— 跨适配器实例、跨流、跨 turn 全是
+ *    它。实测(修前,本门 L1/L5 段的同一条路径):两个互不相干的消费者各取一次未登记行的证明,
+ *    `===` 为真;给第一只补上卡号之后,第二只当场读出 `{lane:'subagent', parentToolCallId:'…'}`,
+ *    开流序幕那四条主车道事件也一起变 —— **一次写打穿整个进程**,而且静默。
+ *
+ * 🔴 **判据如实**:这是**别名风险**,不是「已经在串味的现场」。修前逐站点穷举(语法树扫写表达式)
+ *    的结论是:本包内对车道证明**零就地写**(两处看起来像写的是给局部变量**换绑**新对象,不改旧的);
+ *    三个消费端的证明用法全是只读(读 `lane` 位 / 解构丢弃)。⇒ 本批修的是「交出去的可变引用被
+ *    当成缺省值别名」这一形,不是在修一条已经在错归因的行。发布文案不许把它写成用户可见的回归。
+ *    这条形本身仍然要修:`laneProof` 是**公开输出面**上的一位,拿它做 WeakMap 键 / 身份去重 /
+ *    视图层身份记忆的消费者,在两条无关行共享一只对象时会把它们认成同一条 —— **一个字都不写也照错**。
+ *    这也正是冻结那条修法救不了的一半。
+ *
+ * 🔴 **为什么不是冻结**(两条都摆过,这条落选):
+ *    ① 冻结只挡「写」,不解「别名」——上一段那三种按身份认物的消费面照错;每次新建两件一起解决。
+ *    ② 子代臂 `{lane:'subagent', parentToolCallId}` 与 workflow 臂本来就**逐次新建**且可写,只冻主
+ *       车道这一半 ⇒ 同一处写操作会因为「这条行恰好绑没绑卡」而一边抛一边收,失败随行漂成间歇形;
+ *       要对称就得连十几处内联字面量一起冻,比每次新建更大的改动换更小的收益。
+ *    ③ 证明是在宿主手里被写的:冻结把一条本包的别名缺陷变成宿主侧的抛错,而宿主的抛会顺着
+ *       `for await` 打断整条 adapt 流。适配层不该给主链添这种反噬。
+ * ⚠️ 代价如实:每条主车道事件多一只小对象(≈ 一个键的字面量)。别为了省它把出厂口缓存成模块级
+ *    单例(`const M = mainLane()` 就是把这一形原样种回来)—— 结构反钉门盯着这一形。
+ */
+export declare const mainLane: () => LaneProof;
 /** 帧 → 稳定转录 id(`suffix` = 同一帧派生多条消息时的去撞位)。 */
 export type IdOf = (frame: Frame, suffix?: string) => string;
 /**

package/dist/adapt/ids.js

@@ -1,6 +1,33 @@
 import { deriveTranscriptId } from '../seam.js';
-/** 主车道证明——本批实现的臂全在 leader lane(子代/workflow lane 的 tick 面留 #52b)。 */
-export const MAIN = { lane: 'main' };
+/**
+ * 主车道证明的**出厂口** —— 每次调用交出一只**新的** `{lane:'main'}`(本批实现的臂全在 leader
+ * lane;子代/workflow lane 的 tick 面留 #52b)。
+ *
+ * 🔴 **为什么是函数不是常量**(0.76.1)。此前这里是一只模块级常量对象,`laneOf(未登记 id)` 与本包
+ *    约五十个 `laneProof:` 主车道发点交出去的是**同一只**对象 —— 跨适配器实例、跨流、跨 turn 全是
+ *    它。实测(修前,本门 L1/L5 段的同一条路径):两个互不相干的消费者各取一次未登记行的证明,
+ *    `===` 为真;给第一只补上卡号之后,第二只当场读出 `{lane:'subagent', parentToolCallId:'…'}`,
+ *    开流序幕那四条主车道事件也一起变 —— **一次写打穿整个进程**,而且静默。
+ *
+ * 🔴 **判据如实**:这是**别名风险**,不是「已经在串味的现场」。修前逐站点穷举(语法树扫写表达式)
+ *    的结论是:本包内对车道证明**零就地写**(两处看起来像写的是给局部变量**换绑**新对象,不改旧的);
+ *    三个消费端的证明用法全是只读(读 `lane` 位 / 解构丢弃)。⇒ 本批修的是「交出去的可变引用被
+ *    当成缺省值别名」这一形,不是在修一条已经在错归因的行。发布文案不许把它写成用户可见的回归。
+ *    这条形本身仍然要修:`laneProof` 是**公开输出面**上的一位,拿它做 WeakMap 键 / 身份去重 /
+ *    视图层身份记忆的消费者,在两条无关行共享一只对象时会把它们认成同一条 —— **一个字都不写也照错**。
+ *    这也正是冻结那条修法救不了的一半。
+ *
+ * 🔴 **为什么不是冻结**(两条都摆过,这条落选):
+ *    ① 冻结只挡「写」,不解「别名」——上一段那三种按身份认物的消费面照错;每次新建两件一起解决。
+ *    ② 子代臂 `{lane:'subagent', parentToolCallId}` 与 workflow 臂本来就**逐次新建**且可写,只冻主
+ *       车道这一半 ⇒ 同一处写操作会因为「这条行恰好绑没绑卡」而一边抛一边收,失败随行漂成间歇形;
+ *       要对称就得连十几处内联字面量一起冻,比每次新建更大的改动换更小的收益。
+ *    ③ 证明是在宿主手里被写的:冻结把一条本包的别名缺陷变成宿主侧的抛错,而宿主的抛会顺着
+ *       `for await` 打断整条 adapt 流。适配层不该给主链添这种反噬。
+ * ⚠️ 代价如实:每条主车道事件多一只小对象(≈ 一个键的字面量)。别为了省它把出厂口缓存成模块级
+ *    单例(`const M = mainLane()` 就是把这一形原样种回来)—— 结构反钉门盯着这一形。
+ */
+export const mainLane = () => ({ lane: 'main' });
 /**
  * L-215③(0.65.0)—— 一条 assistant 转录消息的**身份键**(`message.id` / `message.model`)。
  *

package/dist/adapt/panelTasks.d.ts

@@ -40,8 +40,9 @@ export interface PanelTaskLedger {
     unboundCandidates(): number;
     /** 行的车道证明:绑到卡的 = subagent lane(带父卡 id),未绑的 = 主 lane。 */
     laneOf(taskId: string): LaneProof;
-    /** 这条行已经绑过卡了吗(含糊回落的前置判位;别拿 `laneOf(...) === MAIN` 代替 —— 那是
-     *  按引用相等在推断,判据锚在会决定结果的量上才对)。 */
+    /** 这条行已经绑过卡了吗(含糊回落的前置判位;别拿「`laneOf(...)` 是不是那只主车道常量」代替 ——
+     *  那是按引用相等在推断,判据锚在会决定结果的量上才对。0.76.1 起主车道证明**逐次新建**,
+     *  那种写法连偶然成立都做不到了)。 */
     isBound(taskId: string): boolean;
     /**
      * B-074 —— 这条行绑在一张**本 turn 还开着**的卡上吗(`liveBound`,#6 的 live/inert 判位)。
@@ -75,7 +76,7 @@ export interface PanelTaskLedger {
      * B-074(0.65.0)**终态 tick 边** —— core 明写的那一拍(`task_progress.status` = `completed`/
      * `failed`)按 taskId 直接落行。
      *
-     * 为什么不复用 {@link settleFromNotification}:那一条是**通知帧**那半场,它按 `MAIN` 车道发
+     * 为什么不复用 {@link settleFromNotification}:那一条是**通知帧**那半场,它按**主车道**发
      * end(bg 子代行本来就是 unbound 的),而终态 tick 的行**可能绑着一张前台委派卡** ⇒ 车道证明
      * 必须走 {@link laneOf},否则一条 subagent lane 的行会拿 main lane 的证明去落终态(帧×lane
      * 矩阵那一族的病)。也不复用 {@link settle}:那一条按**卡 id** 收(关卡/防御 sweep 的语义),

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;