@sema-agent/client-core 0.75.1 → 0.76.1

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 这条腿编译出了判官)。 */
@@ -276,6 +288,51 @@ export interface ContextUsageSectionView {
     tokens: number;
     kind?: string;
 }
+/**
+ * CC-91(0.76.0):`prompt_assembled.sections[]` 一行 —— 编译 IR 面的**一段**(core `prompt.assembled` 的 v2 面)。
+ *
+ * 🔴 **只有 `chars`,没有 `tokens`** —— 这不是本层的取舍,是上游真字节里就没有这一位:core 的臂声明
+ *   (`core/trace.ts` `kind:"prompt.assembled"` 的 `sections?: Array<{id, slot, carrier, cadence, cacheClass, chars, hash, contentHash?}>`)
+ *   与 server 的逐字段白名单(`observability/prompt-manifest.ts` `promptManifestRecordOf`)两面都是 `chars`。
+ *   ⇒ 本层**不铸** `tokens`:拿 `chars / 系数` 编一个数就是把「不知道」渲成一个看起来精确的假值。
+ *   要引擎自己的 token 估算,读 **`context_usage.sections[].tokens`**(core `prompt-assembly/section-usage.ts`
+ *   `contextUsageSections` 就是拿同一份 `chars` 按引擎系数估的)。🔴 这条 join **只在两面的段视图都在场时成立**:
+ *   那一面也是从同一份 manifest 段列投影的,段列缺席时它同样缺席 ⇒ v1-only 腿上没有这条 join,那时**别**拿
+ *   `blocks` 当段的同名替代({@link PromptManifestBlockView}:两张词表不同,且段→块可多对一)。
+ * 🔴 `id` 是 core pack 的 `core/<slot>.<name>` 命名空间**开集**(`core/role.base` / `core/harness.head` /
+ *   `core/discovery.mcp-instructions` / `core/environment.context` / `core/memory.tail` …),**不是**任何端
+ *   /context 面板的展示分类名;本层按开集读,认不得的 id 原词照带。
+ * `slot` = 语义槽(让视图不必认识每个 id 就能分组),**逐字沿用上游的键名**:同一件事在 `context_usage.sections[]`
+ *   那一面叫 `kind`,在本面叫 `slot`,两边各自跟自己的上游,本层**不改名**。改名看着整齐,代价是同一个事实在包内
+ *   多一个只有本包知道的别名 —— 而本层有两个入口(投影口 / 直喂 `adapt()`),别名一多两条路就会读出不同的值。
+ *   缺席 = 那个条目没声明槽,不是没语义。
+ */
+export interface PromptManifestSectionView {
+    id: string;
+    /** 这一段**渲染出来的字符数**(prepare 期冻结)。🔴 不是 token 数;别拿它与 `context_usage.usedTokens` 相减。 */
+    chars: number;
+    slot?: string;
+}
+/** CC-91(0.76.0):`prompt_assembled.blocks[]` 一行 —— v1 面的**带标签块**(`role.base` / `harness.context` /
+ *  `env.context` / `memory.tail` …)。🔴 与 `sections[].id` 是**两张不同的词表**,而且**多对一**:多个段可折进
+ *  同一个块(core `prompt-assembly/types.ts` 的 `blockId`)⇒ 块不是段的另一种写法,别把两面混着分组。
+ *  v1-only 引擎上段视图整键缺席,这一面是那时唯一的组成视图 —— 🔴 **那时没有与 `context_usage` 的 token join**
+ *  (那一面的段视图同样是从 manifest 段列投影的,段列缺席时它也缺席)⇒ 别拿块 id 去 join 段面。
+ *  ⚠️ 两张词表**没有命名空间隔离的保证**:v1 块 id 不带前缀(`role.base`),而 operator 声明的段 id 是自由串
+ *  (core 的 `EpochDeclaredSections.id`)⇒ 理论上能撞出同名。所以「join 不上」不是唯一的失败形,
+ *  **按面各自分组**才是安全读法,别靠 id 形状猜自己在哪一面。
+ *  `chars` 同律:不是 token 数。 */
+export interface PromptManifestBlockView {
+    id: string;
+    chars: number;
+}
+/** CC-91(0.76.0):`prompt_assembled.tools[]` 一行,**只留 wireName**(这一腿挂载了哪些工具;MCP 类按 server 分组渲染靠它)。
+ *  🔴 上游那一行的其余位(`aliases` / `contractId` / `implementationRevision` / `cardId` / `shapeDigest` / `wireSchemaDigest`)
+ *  是**内容寻址对账锚**、不是尺寸面,本层刻意不过境(要它们另立票,别顺手整只透传)。⚠️ 这一面**没有任何尺寸位** ——
+ *  「工具 schema 占了多少」在这条 wire 上读不出来,缺席不是零。 */
+export interface PromptManifestToolView {
+    wireName: string;
+}
 /**
  * CS-7 §2.7 — turn_end usage → CC `ModelUsage` (pinned name mapping;
  * costMicroUsd/1e6 → costUSD). Surfaced separately because the slice has no

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`)与它的型位一并
@@ -46,6 +47,8 @@ export const INTERNAL_SDK_ARM_TYPES = new Set([
     'context_usage',
     // CC-89(0.75.0):压缩的非 compacted 结局 → 中性内部臂(print 车道同律:吞或转,裸透传 = 越界帧)。
     'compaction_outcome',
+    // CC-91(0.76.0):这一次 prepare 的提示词装配清单 → 中性内部臂(print 车道同律:吞或转,裸透传 = 越界帧)。
+    'prompt_assembled',
     'workflow_complete',
     'tool_end_result',
     'retry_status',
@@ -831,13 +834,14 @@ export function eventToSdkMessage(ev, ctx) {
         // `meta`:流首帧的 taskId/sessionId 一等信号 —— 本切片无可渲染内容(runStream 只按 `eventSeq` 去重)。
         //   ⚠️ 活性普查(2026-09-19)更正:传输层**不**替宿主消费它;需要 sessionId / taskId 的端(desktop / web-client)各自直读本帧。
         case 'meta':
-        // `file_link` / `prompt_assembled` / `model_usage` / `context_usage` / `config_assembled`:
+        // `file_link` / `model_usage` / `config_assembled`:
         //   引擎的可观测/审计面帧,本切片(CC transcript 投影)无对位渲染物;
         //   消费它们的是 fleet/审计面而不是会话转录。
         // ⚠️ `message_committed` **已在 0.65.0 搬出本档**(B-072 ④):它不是「没有对位物」——
         //   它是 `compacted.preserved_segment` 的唯一解析腿。新臂见本文件 `case 'message_committed'`。
+        // ⚠️ `context_usage` 自 0.71.0 CC-08 ③、`compaction_outcome` 自 0.75.0 CC-89、`prompt_assembled` 自
+        //   0.76.0 CC-91 起各自**进切片**为内部臂 → chrome 臂,不再在本组(见各自的 case)。
         case 'file_link':
-        case 'prompt_assembled':
         case 'model_usage':
         case 'config_assembled':
         // `needs_review`:plan-review park 的**事件**形;壳消费的是 done{status:'needs_review'} 终帧
@@ -920,6 +924,11 @@ export function eventToSdkMessage(ev, ctx) {
         //   没有任何一端看得见。转录里没有对位物(`compact_boundary` 只对成功压缩)⇒ 走内部臂 → chrome 臂,不编消息。
         case 'compaction_outcome':
             return compactionOutcomeProjection(ev, ctx);
+        // CC-91(0.76.0):`prompt_assembled` 从 not_in_slice 组里拿出来 —— 这一次 prepare 的**提示词装配清单**
+        //   (每段多大、挂了哪些工具)是 /context 类面板的唯一引擎侧真值来源;此前三端只能按本地镜像自己估。
+        //   转录里没有对位物(它是 ids/digests/counts 的观测面,不是一条消息)⇒ 走内部臂 → chrome 臂,不编消息。
+        case 'prompt_assembled':
+            return promptAssembledProjection(ev, ctx);
         case 'tool_progress':
             return toolProgressProjection(ev, ctx);
         default:
@@ -930,18 +939,35 @@ export function eventToSdkMessage(ev, ctx) {
             return dropped('unknown_arm', String(ev.type ?? 'unknown'));
     }
 }
-/** CC-08:三键身份(sdk `EventIdentity`)—— 在场非串 ⇒ 坏值不买路;在场(含空串)⇒ 原样透传;`eventId` 非空才带。 */
+/**
+ * 身份四键(`eventId` + 三个子流键)的**一次性快照**:每键**只读一次**,读取抛错 ⇒ 整份不可信。
+ *
+ * 🔴 为什么是快照而不是就地多读(异源对抗复审第三轮 [medium],实测可复现):wire 是 JSON,但**进程内**的帧
+ *    (宿主自建管线 / 重放存量转录 / 测试替身)可以带 accessor。同一个键读两次拿到两个值时,「形门读一次、
+ *    抄写再读一次、lane 判定又读一次」会让同一帧在不同读点上归属**不同 lane** —— 一条子代帧能被洗成主会话的
+ *    组成信息。读一次、全程用同一份,是这条歧义唯一的关门方式;抛错的 getter 同样在这里被关住(此前会从投影口逸出)。
+ * ⚠️ 仍按 `ev[k]` 读(**走原型链**:进程内对象的身份键常长在原型上),只是每键只读一次。
+ */
+function identitySnapshot(ev) {
+    // 0.76.1:单源 —— 与 adapt 侧各臂共用同一只快照助手(见 adapter/types.ts 的 snapshotSegmentIdentity 头注)。
+    return snapshotSegmentIdentity(ev);
+}
+/** CC-08:三键身份(sdk `EventIdentity`)—— 在场非串 ⇒ 坏值不买路;在场(含空串)⇒ 原样透传;`eventId` 非空才带。
+ *  🔴 判据与抄写都取 {@link identitySnapshot} 的**同一份**读数(每键只读一次)。 */
 function identityOrMalformed(ev, arm) {
+    const snap = identitySnapshot(ev);
+    if (snap === null)
+        return { identity: {}, bad: dropped('malformed', arm) };
     for (const k of SEGMENT_END_IDENTITY_KEYS) {
-        if (ev[k] !== undefined && typeof ev[k] !== 'string')
+        if (snap[k] !== undefined && typeof snap[k] !== 'string')
             return { identity: {}, bad: dropped('malformed', arm) };
     }
     const identity = {};
     for (const k of ['eventId', ...SEGMENT_END_IDENTITY_KEYS]) {
         // 🔴 三键**空串也透**:子流律是「键在场 = 子代帧」(`isSubFlowSegmentEnd` / `text_end` 投影同律),按 length>0 才抄会把
         //    `sourceTaskId: ''` 的子代帧洗成主流(异源对抗复审第 1 轮 finding③);`eventId` 是幂等键,仍要非空。
-        if (typeof ev[k] === 'string' && (k === 'eventId' ? ev[k].length > 0 : true))
-            identity[k] = ev[k];
+        if (typeof snap[k] === 'string' && (k === 'eventId' ? snap[k].length > 0 : true))
+            identity[k] = snap[k];
     }
     return { identity, bad: null };
 }
@@ -1087,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 })))
@@ -1127,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` 是**正面事实**(照铸 `[]`);非空却零行幸存 = 读不出来 ⇒ 段缺席。
@@ -1357,6 +1382,89 @@ function compactionOutcomeProjection(frame, ctx) {
         ...identity,
     }))));
 }
+/**
+ * CC-91(0.76.0):`prompt_assembled`(一次 prepare 的提示词装配清单)→ 中性内部臂。
+ *
+ * 逐键诚实:`totalChars` 有限非负才在场(缺席 ≠ 0);`blocks` / `sections` / `tools` 三面**逐行**挑
+ * (`id` / `wireName` 非空串 ∧ `chars` 有限非负),坏行逐条丢、全丢光或非数组 ⇒ 该键缺席。
+ * 🔴 于是键缺席是**三支合流**(上游整键缺席 / 空数组 / 逐行滤完只剩空),本层分不出是哪一支 ⇒ 对外只能说
+ *    「本事件没有可读的这一面」,**不许**把它写成一句关于引擎的诊断(如「这条腿没装配出段 IR」)。不铸 `[]`:
+ *    空数组会被读成「装配出来是空的」,那是另一件事。
+ * 🔴 一条组成面的键都读不出 ⇒ `malformed`:core 把 `blocks` / `totalChars` 声明为必填,两件全丢的帧是坏 producer,
+ *    投一份空清单会让消费端把「读不出」渲成「提示词是空的」。
+ * 🔴 帧上的 `constitution`(谁拥有宪法层)**刻意不过境**:本包与三端今天没有任何消费场景,而每一个上了公面的键都是
+ *    一条要长期兑现的契约 —— additive 键晚加不破坏、早加却删不掉。哪天有端点名要它,再按表态制加(本层零改动成本)。
+ * 🔴 **零 `tokens` 铸点**(见 {@link PromptManifestSectionView} 头注):真字节里没有这一位。
+ */
+function promptAssembledProjection(frame, ctx) {
+    // 🔴 不浅拷(与 compaction_outcome 同律):展开会擦掉原型链上的身份键(进程内对象把子代帧洗成主会话)、
+    //    还会执行无关的可枚举 getter;就在同一份记录上逐键各读一次。
+    const ev = frame;
+    const { identity, bad } = identityOrMalformed(ev, 'prompt_assembled');
+    if (bad !== null)
+        return bad;
+    const str = (v) => (typeof v === 'string' && v.length > 0 ? v : undefined);
+    const size = (v) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? v : undefined);
+    const totalChars = size(ev.totalChars);
+    const sections = (() => {
+        if (!Array.isArray(ev.sections))
+            return undefined;
+        const rows = [];
+        for (const r of ev.sections) {
+            if (typeof r !== 'object' || r === null || Array.isArray(r))
+                continue;
+            const o = r;
+            const id = str(o.id);
+            const chars = size(o.chars);
+            if (id === undefined || chars === undefined)
+                continue;
+            const slot = str(o.slot);
+            rows.push({ id, chars, ...(slot !== undefined ? { slot } : {}) });
+        }
+        return rows.length > 0 ? rows : undefined;
+    })();
+    const blocks = (() => {
+        if (!Array.isArray(ev.blocks))
+            return undefined;
+        const rows = [];
+        for (const r of ev.blocks) {
+            if (typeof r !== 'object' || r === null || Array.isArray(r))
+                continue;
+            const o = r;
+            const id = str(o.id);
+            const chars = size(o.chars);
+            if (id === undefined || chars === undefined)
+                continue;
+            rows.push({ id, chars });
+        }
+        return rows.length > 0 ? rows : undefined;
+    })();
+    const tools = (() => {
+        if (!Array.isArray(ev.tools))
+            return undefined;
+        const rows = [];
+        for (const r of ev.tools) {
+            if (typeof r !== 'object' || r === null || Array.isArray(r))
+                continue;
+            const wireName = str(r.wireName);
+            if (wireName === undefined)
+                continue;
+            rows.push({ wireName });
+        }
+        return rows.length > 0 ? rows : undefined;
+    })();
+    if (totalChars === undefined && sections === undefined && blocks === undefined && tools === undefined) {
+        return dropped('malformed', 'prompt_assembled');
+    }
+    return projected(internalArmExit(stamp(ctx, armBody({
+        type: 'prompt_assembled',
+        ...(totalChars !== undefined ? { totalChars } : {}),
+        ...(blocks !== undefined ? { blocks } : {}),
+        ...(sections !== undefined ? { sections } : {}),
+        ...(tools !== undefined ? { tools } : {}),
+        ...identity,
+    }))));
+}
 function engineNoticeProjection(ev, ctx) {
     const code = typeof ev.code === 'string' && ev.code.length > 0 ? ev.code : undefined;
     if (code === undefined)

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/agentsWireCaps.d.ts

@@ -18,10 +18,23 @@ export type TaskAgentWireSkill = {
 };
 /** CC 形自定义 agent 的 `memory:` 三词(cli `loadAgentsDir` 的 zod 枚举同源)。 */
 export declare const AGENT_MEMORY_WORDS: ReadonlySet<string>;
-/** `agents[].memory` 上 wire 的形(server `spec-fields.ts` `memoryOk` 闭合白名单的子集:只用 `scopes` + `writeScope`)。 */
+/**
+ * `agents[].memory` 上 wire 的形(上游闭合白名单 `{ scopes?, writeScope?, enabled?, scopeContract? }` 的子集:本包只用前两键)。
+ *
+ * 🔴 **CC-96 放宽**:`writeScope` 此前写死成 `string`(恒在、且不可为 `null`),而 wire 的取值域是 `string | null`
+ *    (上游直讯确认该域不变)。写死的后果是**读得出却铸不出** —— {@link import('./memorySpecWire.js').readAgentMemorySpec}
+ *    能把显式 `null` 读成「这一次 run 对记忆面只读」(无 remember 工具、不做 consolidation 写,recall 仍可),
+ *    而端**没有任何办法经本包声明**这一形:只剩「写到某一层」一条路。半条腿的读面比没有更坏,因为它让
+ *    「本端支持只读记忆」看起来是真的。
+ *    · `writeScope: null`      = 显式声明只读;
+ *    · `writeScope` 键缺席     = 未指定(缺省归引擎);
+ *    · `writeScope: '<层名>'`  = 写到那一层。
+ * 🔴 放宽的是**类型**,不是本包投影器的纪律:{@link projectAgentsForWire} 仍**恒显式钉** `writeScope`
+ *    (见下方投影处的 🔴 注),漏钉会让新条目静默写进全局层 —— 那条约束一个字都没松。
+ */
 export type TaskAgentWireMemory = {
     scopes: string[];
-    writeScope: string;
+    writeScope?: string | null;
 };
 /** 发往 server 的单个 agent 定义(白名单内字段的壳侧子集——observer 面壳无语义,恒不发;`memory` 自 0.72.3 按定义发)。 */
 export type TaskAgentWireItem = {

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();
 }