@sema-agent/client-core 0.52.0 → 0.54.0

package/dist/peerFrames.d.ts

@@ -0,0 +1,117 @@
+/**
+ * peerFrames.ts — design/385 的三条**引擎注入帧**在客户端的类型化投影(判定单源在包,端只装配)。
+ *
+ * ── 这一件守的是什么 ────────────────────────────────────────────────────────────────
+ * 引擎把三类东西塞进 **同一条** `task_notification` 车道,而它们在模型面根本不是同一种东西
+ * (core `renderTaskNotificationXml` 对这三类**不套** `<task-notification>` 壳):
+ *   · `agentMessage`         同进程子代 → 父会话的 uplink(`SendMessage("main")`,§1.4 d1);
+ *   · `crossSessionMessage`  另一个会话的消息,从本会话自己的信箱里 drain 出来(§4.1);
+ *   · `crossSessionNotice`   关于**本会话自己发出去的**那条消息的回执 / idle 通知(§4.4 / §5.2)。
+ * 端如果照 `task_notification` 泛化卡去渲,用户看到的是一张「后台任务完成」卡,而模型读到的是
+ * 一条同事发来的话 —— 两个面说的不是同一件事。
+ *
+ * 🔴 **判别位是类型化载体的在场,永远不是 `summary` 文本**。这三条载体只有引擎的注入腿铸得出
+ *    (`ExternalNotificationInput` 是 `TaskNotificationPayload` 的**真子集**,外部 `notify()` 一个
+ *    都穿不上);而 `summary`/`result` 是任何一条通知都填的字段,拿它做判据 = 任何一个后台任务
+ *    只要把 `<agent-message from="…">` 写进 summary 就能冒充一条同事消息。
+ *
+ * 🔴 **身份三条等式**:`_sema_provenance` 必须在场、`kind` 与车道相符,且 `from`/`taskId`/`seq`
+ *    与载体和载荷逐一相等(三条都由 core 铸点直证,见 `provenanceAgrees`)。只核 `kind` 拦得住
+ *    半截载荷,拦不住**同 kind 的伪造**——载体署一个可信名字、provenance 三位全不对,屏上照样
+ *    出现一条署着那个名字的消息。
+ *
+ * 🔴 **fail-closed**:载体在场但形不合(`from` 空、`body` 非串、notice 的 `kind` 不在闭集里)⇒
+ *    返回 `null` = 退回泛化卡。退回泛化卡是**诚实降级**(用户仍看得见这条通知,只是没有专用形);
+ *    而放一个半截形出去,端就会拿 `undefined` 去渲一张署名为空的「来自 @undefined 的消息」卡。
+ *
+ * 🔴 **优先序照抄 core 的渲染腿**(`agentMessage` → `crossSessionMessage` → `crossSessionNotice`)。
+ *    多载体同时在场是矛盾载荷,但**模型那一面已经按 core 的顺序读过了** —— 端按同一个顺序判,
+ *    两个面才说同一件事;这里另立一套「矛盾就退泛化」会让屏上那张卡与模型读到的帧对不上。
+ *
+ * ── 为什么渲染/解析两半都在包里 ─────────────────────────────────────────────────────
+ * 端的消息面(CC 血统:`UserTextMessage` 按标签分派)拿到的只有**文本**,没有帧。所以包必须同时
+ * 给出「帧 → 文本」与「文本 → 帧」两半,且**同源**(同一组标签常量、同一套属性序),端才可能
+ * 做到零字符串判定。两半的往返在常驻门里逐形对拍。
+ *
+ * ── 与上游的锚 ──────────────────────────────────────────────────────────────────────
+ * 两个标签字面量是 core 的铸点镜像(`core/task-notification.js::AGENT_MESSAGE_TAG` /
+ * `agents/cross-session-envelope.js::CROSS_SESSION_MESSAGE_TAG`),登记在壳的 wire 锚契约表里
+ * (cli `scripts/wire-anchor-registry.mjs`)—— core 改词当天那道门就红,而不是等到用户发现
+ * 「同事消息又变回一张后台任务卡了」。
+ */
+/** core `core/task-notification.ts::AGENT_MESSAGE_TAG` 的镜像(同进程 uplink 的模型面标签)。 */
+export declare const AGENT_MESSAGE_TAG = "agent-message";
+/** core `agents/cross-session-envelope.ts::CROSS_SESSION_MESSAGE_TAG` 的镜像(跨会话信封标签)。 */
+export declare const CROSS_SESSION_MESSAGE_TAG = "cross-session-message";
+/** core `_sema_provenance.kind` 的闭集(7.4.0 三员;7.2.0 只有第一员 —— 缺员按「上游还没发」处理,
+ *  不是「上游改词」:本模块从不要求 provenance 在场,只要求**在场时不自相矛盾**)。 */
+export declare const PEER_FRAME_LANES: readonly ["agent_message", "cross_session_message", "cross_session_notice"];
+export type PeerFrameLane = (typeof PEER_FRAME_LANES)[number];
+/** core `crossSessionNotice.kind` 的闭集(§4.4:投递回执 / idle 回执两形)。 */
+export declare const CROSS_SESSION_NOTICE_KINDS: readonly ["delivery_notice", "idle_notice"];
+export type CrossSessionNoticeKind = (typeof CROSS_SESSION_NOTICE_KINDS)[number];
+/** core `PermissionModeClass`(发送方**自述**的权限模式类,不是被证实的事实)。 */
+export declare const PEER_MODE_CLASSES: readonly ["bypass", "prompting"];
+export type PeerModeClass = (typeof PEER_MODE_CLASSES)[number];
+export type AgentMessageFrame = {
+    lane: 'agent_message';
+    /** 帧的 `from="…"` 属性所拼的那个署名(子代的名字 / 标签)。 */
+    from: string;
+    body: string;
+    agentType?: string;
+    /** 生产者的 per-frame 计数器(= 本 payload 的 `seq`);缺席不补 0。 */
+    seq?: number;
+};
+export type CrossSessionMessageFrame = {
+    lane: 'cross_session_message';
+    /** 发送方的**地址**(可回信的那一个;§4.1 provenance 的 `from` 同值)。 */
+    from: string;
+    body: string;
+    fromSession?: string;
+    fromName?: string;
+    fromMode?: PeerModeClass;
+    fromScope?: string;
+    seq?: number;
+};
+export type CrossSessionNoticeFrame = {
+    lane: 'cross_session_notice';
+    kind: CrossSessionNoticeKind;
+    /** 引擎自铸的整行文本(`[Cross-session delivery notice] …` / `[Cross-session idle notice] …`)。
+     *  🔴 端**原样渲一行**:这行是引擎按类型化 `peerMeta.notice` 铸的,端再解析一遍就是拿散文当数据。 */
+    text: string;
+};
+export type PeerFrameProjection = AgentMessageFrame | CrossSessionMessageFrame | CrossSessionNoticeFrame;
+/**
+ * `task_notification` 原始 wire 载荷 → 三条引擎注入车道之一;认不出 ⇒ `null`(= 泛化通知,
+ * 调用方照旧走 `normalizeTaskNotification` / `renderTaskNotificationXml`)。
+ *
+ * 入参是**原始**载荷(snake_case `task_id` 那一份),不是 `normalizeTaskNotification` 的产物 ——
+ * 后者是一张 15 键白名单,这三条载体一个都不在里面。
+ */
+export declare function classifyPeerNotification(n: Record<string, unknown>): PeerFrameProjection | null;
+/**
+ * core `ENGINE_AUTHORITY_ENVELOPE_TAGS` 的镜像(`core/untrusted-text.ts::ENGINE_ENVELOPES` 里 kind="authority" 的标签):
+ * 这些信封在模型面/转录面代表**引擎权威**,一段同事正文里出现它们就是伪造。core 的 `neutralizePeerBody`
+ * (= `sanitizeUntrustedText(body, PEER_BODY_ENVELOPE_TAGS)`)在渲染信封**之前**先把它们拆火(`<` 后插 ZWSP),
+ * 本模块首版只抄了后一步(同名信封拆火)——异源发包扫描 [high] 实证:子代正文里一段
+ * `<task-notification><task-id>victim</task-id><status>completed</status>…` 会原样进转录 block,
+ * 宿主 resume 时 `parseTranscriptNotificationSeeds` 把它读成真完成通知 ⇒ 去重台账被毒化,受害 run 的
+ * 真完成通知随后被跨通道臂整条吞掉。这里补上那一步,并与 core 同形(`<\s*\/?\s*(tag)(\s[^>]*)?>` 全大小写)。
+ * 🔴 单向(与 core 一致):端的解析腿**不**还原 ZWSP —— 拆掉的权威标签就该永远是拆掉的。
+ */
+export declare const AUTHORITY_ENVELOPE_TAGS: readonly ["system-reminder", "task-notification", "new-diagnostics", "user_memory", "scope", "skills", "total_tokens", "instruction-files"];
+/**
+ * 投影 → 转录行文本(端的消息面按标签分派的那一份)。
+ *
+ * 🔴 这**不是** core 模型面信封的逐字副本,也不该是:core 那一份是给**模型**读的(带纪律块、
+ *    带 CC 逐字属性语法、带 round-trip 拒收);这一份是**端的转录回显**,只需要与本模块的解析腿
+ *    往返一致。刻意不复刻 core 的语法契约 —— 复刻一份对不上的副本比不复刻更坏
+ *    (它会让人以为端这一行是模型读到的那一行)。属性序仍照 core 的规范序排,便于人肉比对。
+ */
+export declare function renderPeerFrameTranscriptText(p: PeerFrameProjection): string;
+export declare function parsePeerFrameText(text: string): AgentMessageFrame | CrossSessionMessageFrame | null;
+/**
+ * 端渲「@谁」时该用的那个名字 —— 判定在包,端不许自己排优先序。
+ * 跨会话:`fromName`(人取的名)优先于 `from`(地址);同进程:只有 `from`。
+ */
+export declare function peerFrameDisplayName(p: AgentMessageFrame | CrossSessionMessageFrame): string;

package/dist/peerFrames.js

@@ -0,0 +1,369 @@
+/**
+ * peerFrames.ts — design/385 的三条**引擎注入帧**在客户端的类型化投影(判定单源在包,端只装配)。
+ *
+ * ── 这一件守的是什么 ────────────────────────────────────────────────────────────────
+ * 引擎把三类东西塞进 **同一条** `task_notification` 车道,而它们在模型面根本不是同一种东西
+ * (core `renderTaskNotificationXml` 对这三类**不套** `<task-notification>` 壳):
+ *   · `agentMessage`         同进程子代 → 父会话的 uplink(`SendMessage("main")`,§1.4 d1);
+ *   · `crossSessionMessage`  另一个会话的消息,从本会话自己的信箱里 drain 出来(§4.1);
+ *   · `crossSessionNotice`   关于**本会话自己发出去的**那条消息的回执 / idle 通知(§4.4 / §5.2)。
+ * 端如果照 `task_notification` 泛化卡去渲,用户看到的是一张「后台任务完成」卡,而模型读到的是
+ * 一条同事发来的话 —— 两个面说的不是同一件事。
+ *
+ * 🔴 **判别位是类型化载体的在场,永远不是 `summary` 文本**。这三条载体只有引擎的注入腿铸得出
+ *    (`ExternalNotificationInput` 是 `TaskNotificationPayload` 的**真子集**,外部 `notify()` 一个
+ *    都穿不上);而 `summary`/`result` 是任何一条通知都填的字段,拿它做判据 = 任何一个后台任务
+ *    只要把 `<agent-message from="…">` 写进 summary 就能冒充一条同事消息。
+ *
+ * 🔴 **身份三条等式**:`_sema_provenance` 必须在场、`kind` 与车道相符,且 `from`/`taskId`/`seq`
+ *    与载体和载荷逐一相等(三条都由 core 铸点直证,见 `provenanceAgrees`)。只核 `kind` 拦得住
+ *    半截载荷,拦不住**同 kind 的伪造**——载体署一个可信名字、provenance 三位全不对,屏上照样
+ *    出现一条署着那个名字的消息。
+ *
+ * 🔴 **fail-closed**:载体在场但形不合(`from` 空、`body` 非串、notice 的 `kind` 不在闭集里)⇒
+ *    返回 `null` = 退回泛化卡。退回泛化卡是**诚实降级**(用户仍看得见这条通知,只是没有专用形);
+ *    而放一个半截形出去,端就会拿 `undefined` 去渲一张署名为空的「来自 @undefined 的消息」卡。
+ *
+ * 🔴 **优先序照抄 core 的渲染腿**(`agentMessage` → `crossSessionMessage` → `crossSessionNotice`)。
+ *    多载体同时在场是矛盾载荷,但**模型那一面已经按 core 的顺序读过了** —— 端按同一个顺序判,
+ *    两个面才说同一件事;这里另立一套「矛盾就退泛化」会让屏上那张卡与模型读到的帧对不上。
+ *
+ * ── 为什么渲染/解析两半都在包里 ─────────────────────────────────────────────────────
+ * 端的消息面(CC 血统:`UserTextMessage` 按标签分派)拿到的只有**文本**,没有帧。所以包必须同时
+ * 给出「帧 → 文本」与「文本 → 帧」两半,且**同源**(同一组标签常量、同一套属性序),端才可能
+ * 做到零字符串判定。两半的往返在常驻门里逐形对拍。
+ *
+ * ── 与上游的锚 ──────────────────────────────────────────────────────────────────────
+ * 两个标签字面量是 core 的铸点镜像(`core/task-notification.js::AGENT_MESSAGE_TAG` /
+ * `agents/cross-session-envelope.js::CROSS_SESSION_MESSAGE_TAG`),登记在壳的 wire 锚契约表里
+ * (cli `scripts/wire-anchor-registry.mjs`)—— core 改词当天那道门就红,而不是等到用户发现
+ * 「同事消息又变回一张后台任务卡了」。
+ */
+// ── wire 键名 / 属性名的单源(**刻意放在本文件第一个 `export` 之前**)────────────────────────
+// 两个作用,第二个是被逼出来的:
+//   ① 键名单源 —— 读口与渲染口用同一个字节,不给手抄留缝;
+//   ② 绕开 client-core 闭包扫描器的一处误匹配:`run-client-core-portability-test.mjs` 的
+//      `import/export … from '…'` 边扫描按 `from` + 引号这个**字节序列**认依赖,于是源码里任何
+//      一个 `'from'` 字面量(本模块读的正是 wire 上那个 `from` 键)都会被当成一条外部包依赖,
+//      把「A 层闭包外部包 === {diff}」判红。扫描器的锚起点是**行首的 `export`**,所以键名收在
+//      首个 export 之前就落在它的射程外。⚠️ 这是绕过一处**扫描器误报**,不是绕过判据本身 ——
+//      本模块真实的外部依赖是零(纯叶,零 import)。
+const WIRE_KEY_FROM = 'from';
+const WIRE_KEY_BODY = 'body';
+const WIRE_KEY_KIND = 'kind';
+const WIRE_KEY_TEXT = 'text';
+const WIRE_KEY_SEQ = 'seq';
+const WIRE_KEY_TASK_ID = 'task_id';
+/** 🔴 载荷那一边是 **snake** `task_id`,provenance 那一边是 **camel** `taskId` —— 同一个量、两个拼法,
+ *  写混了等式恒不成立、整条车道静默死掉(本模块首版就写混过一次,当场被门抓住)。 */
+const WIRE_KEY_PROV_TASK_ID = 'taskId';
+const WIRE_KEY_AGENT_TYPE = 'agentType';
+const WIRE_KEY_AGENT_MESSAGE = 'agentMessage';
+const WIRE_KEY_CROSS_SESSION_MESSAGE = 'crossSessionMessage';
+const WIRE_KEY_CROSS_SESSION_NOTICE = 'crossSessionNotice';
+const WIRE_KEY_PROVENANCE = '_sema_provenance';
+const WIRE_KEY_FROM_SESSION = 'fromSession';
+const WIRE_KEY_FROM_NAME = 'fromName';
+const WIRE_KEY_FROM_MODE = 'fromMode';
+const WIRE_KEY_FROM_SCOPE = 'fromScope';
+/** 信封上的 `from` 属性名(与上面的 wire 键同字节,渲染/解析两腿共用)。 */
+const FROM_ATTR = WIRE_KEY_FROM;
+/** core `core/task-notification.ts::AGENT_MESSAGE_TAG` 的镜像(同进程 uplink 的模型面标签)。 */
+export const AGENT_MESSAGE_TAG = 'agent-message';
+/** core `agents/cross-session-envelope.ts::CROSS_SESSION_MESSAGE_TAG` 的镜像(跨会话信封标签)。 */
+export const CROSS_SESSION_MESSAGE_TAG = 'cross-session-message';
+/** core `_sema_provenance.kind` 的闭集(7.4.0 三员;7.2.0 只有第一员 —— 缺员按「上游还没发」处理,
+ *  不是「上游改词」:本模块从不要求 provenance 在场,只要求**在场时不自相矛盾**)。 */
+export const PEER_FRAME_LANES = Object.freeze(['agent_message', 'cross_session_message', 'cross_session_notice']);
+/** core `crossSessionNotice.kind` 的闭集(§4.4:投递回执 / idle 回执两形)。 */
+export const CROSS_SESSION_NOTICE_KINDS = Object.freeze(['delivery_notice', 'idle_notice']);
+/** core `PermissionModeClass`(发送方**自述**的权限模式类,不是被证实的事实)。 */
+export const PEER_MODE_CLASSES = Object.freeze(['bypass', 'prompting']);
+// ── 防御式读口 ────────────────────────────────────────────────────────────────────────
+// 载荷是 wire JSON,正常路径上全是数据属性;但读一个 getter = 同步跑别人的代码,而
+// `try/catch` 接得住抛错、接不住「永不返回」。⇒ 只认自有**数据**描述符,访问器一律当缺席。
+function dataProp(o, key) {
+    if (o === null || typeof o !== 'object')
+        return undefined;
+    let d;
+    try {
+        d = Object.getOwnPropertyDescriptor(o, key);
+    }
+    catch {
+        // 已撤销的 Proxy / 敌意 trap:当缺席(读不出来 ≠ 有值)
+        return undefined;
+    }
+    if (d === undefined || !('value' in d))
+        return undefined;
+    return d.value;
+}
+function nonEmptyString(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function finiteNumber(v) {
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
+/**
+ * `_sema_provenance` 的一致性判据 —— **必须在场、且 `kind` 与载体所属车道相符**。
+ *
+ * 🔴 首版写的是「只否决不认证、缺席放行」,理由是「core 7.2.0 的闭集只有一员,要求在场会让另外
+ *    两条车道在老引擎上恒死」。**那条理由是错的**(异源对抗复审 r1 [high] 证伪,当场采纳):
+ *    老引擎上另外两条车道**连载体键都不存在**,本函数根本走不到;而 core 契约明写 provenance
+ *    「present exactly when the carrier is」——今天在跑的那一版(7.2.0 `agents/send-message-tool.js`
+ *    的 uplink 腿)就是**同一处**同时铸载体与 provenance 的。所以要求它在场:
+ *      · 对**真**载荷零代价(真载荷从来都带着它);
+ *      · 对畸形/半截注入/版本漂移的载荷则关上了一道门 —— 否则只凭 `from`/`body` 两个字符串就能
+ *        让屏上出现一张署着任意名字的「来自某人的消息」卡,而那正是本模块存在的理由的反面。
+ *
+ * 判据 = **在场 + 四等式**(`kind` 与车道相符;`from`/`taskId`/`seq` 三位必须在场且与载体、载荷逐一相等,
+ * 见函数体内三条铸点直证)。首版曾写「判据只到 kind、刻意不比三位」——那一版的顾虑(上游编码差一格
+ * ⇒ 车道静默死)由 cli 侧 wire 锚 A-K24 的同址探针接管:铸点一改门先红,不会变成静默死。
+ */
+function provenanceAgrees(n, lane, carrierFrom) {
+    const prov = dataProp(n, WIRE_KEY_PROVENANCE);
+    if (prov === null || typeof prov !== 'object')
+        return false;
+    if (dataProp(prov, WIRE_KEY_KIND) !== lane)
+        return false;
+    // 🔴 三条等式**每一条都有铸点直证**(不是从散文里推的):
+    //    · uplink 腿(core 7.2.0 `dist/agents/send-message-tool.js`)一个对象字面量里同时写下
+    //      `task_id: senderId` / `seq: uplinkSeq` / `agentMessage:{from: senderLabel}` 与
+    //      `_sema_provenance:{from: senderLabel, taskId: senderId, seq: uplinkSeq}`;
+    //    · 跨会话 drain 腿(core 7.4.0 `agents/peer-session-drain.ts` 的两个 build*Payload)同形:
+    //      `task_id: boxHandle` / `seq: m.seq` 与 provenance 的 `taskId`/`seq` 同值,
+    //      消息臂的 `crossSessionMessage.from` 与 provenance 的 `from` 同为 `fields.from`。
+    //    ⇒ 三位不一致 = 这不是引擎那条腿铸出来的载荷。只核 `kind` 只拦得住半截载荷,拦不住
+    //      **同 kind 的伪造**:载体署一个可信的名字、provenance 三位全对不上,屏上照样出现一条
+    //      署着那个名字的消息(异源对抗复审 r2 [medium] 实测)。
+    //    🔴 铸点一改这三条就该跟着改 —— 由壳的 wire 锚 A-K24 同址探针钉住那一行字面量,
+    //      上游改词当天门就红,不会变成一条静默死掉的车道。
+    // 🔴 **在场也是判据的一半**(异源对抗复审 r3 [medium] 采纳):`SemaProvenance` 的 `from`/`taskId`/
+    //    `seq` 在 core 的类型面上**全是必填**,三个铸点也都同址写下它们 —— 所以「两侧都缺」不是一种
+    //    合法的兼容形,而是一个半截载荷。首版只写 `a === b`,于是 `undefined === undefined` 把它放行了
+    //    (实测:去掉两侧 seq、或去掉载荷的 task_id,半截载荷照样投影成一条 agent_message)。
+    //    ⇒ 先各自核在场与类型,再比值。
+    const provFrom = cleanName(dataProp(prov, WIRE_KEY_FROM));
+    if (provFrom === undefined || (carrierFrom !== undefined && provFrom !== carrierFrom))
+        return false;
+    const taskId = nonEmptyString(dataProp(n, WIRE_KEY_TASK_ID));
+    if (taskId === undefined || nonEmptyString(dataProp(prov, WIRE_KEY_PROV_TASK_ID)) !== taskId)
+        return false;
+    const seq = finiteNumber(dataProp(n, WIRE_KEY_SEQ));
+    return seq !== undefined && finiteNumber(dataProp(prov, WIRE_KEY_SEQ)) === seq;
+}
+/**
+ * `task_notification` 原始 wire 载荷 → 三条引擎注入车道之一;认不出 ⇒ `null`(= 泛化通知,
+ * 调用方照旧走 `normalizeTaskNotification` / `renderTaskNotificationXml`)。
+ *
+ * 入参是**原始**载荷(snake_case `task_id` 那一份),不是 `normalizeTaskNotification` 的产物 ——
+ * 后者是一张 15 键白名单,这三条载体一个都不在里面。
+ */
+export function classifyPeerNotification(n) {
+    const seq = finiteNumber(dataProp(n, WIRE_KEY_SEQ));
+    // ① 同进程 uplink(§1.4 d1)
+    const agentMessage = dataProp(n, WIRE_KEY_AGENT_MESSAGE);
+    if (agentMessage !== undefined) {
+        const from = cleanName(dataProp(agentMessage, WIRE_KEY_FROM));
+        const body = dataProp(agentMessage, WIRE_KEY_BODY);
+        if (from !== undefined && typeof body === 'string' && provenanceAgrees(n, 'agent_message', from)) {
+            const agentType = nonEmptyString(dataProp(dataProp(n, WIRE_KEY_PROVENANCE), WIRE_KEY_AGENT_TYPE));
+            return {
+                lane: 'agent_message',
+                from,
+                body,
+                ...(agentType !== undefined ? { agentType } : {}),
+                ...(seq !== undefined ? { seq } : {}),
+            };
+        }
+        return null;
+    }
+    // ② 跨会话信封(§4.1)
+    const crossSessionMessage = dataProp(n, WIRE_KEY_CROSS_SESSION_MESSAGE);
+    if (crossSessionMessage !== undefined) {
+        const from = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM));
+        const body = dataProp(crossSessionMessage, WIRE_KEY_BODY);
+        if (from === undefined || typeof body !== 'string' || !provenanceAgrees(n, 'cross_session_message', from))
+            return null;
+        const fromSession = nonEmptyString(dataProp(crossSessionMessage, WIRE_KEY_FROM_SESSION));
+        const fromName = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM_NAME));
+        const fromModeRaw = dataProp(crossSessionMessage, WIRE_KEY_FROM_MODE);
+        const fromMode = PEER_MODE_CLASSES.find(m => m === fromModeRaw);
+        const fromScope = nonEmptyString(dataProp(crossSessionMessage, WIRE_KEY_FROM_SCOPE));
+        // 🔴 可选位形不合 ⇒ **只丢那一位**,不丢整帧:少一个 `from-mode` 是少一句注,
+        //    丢整帧是把一条同事消息从用户眼前拿走(与必填位的 fail-closed 是两码事)。
+        return {
+            lane: 'cross_session_message',
+            from,
+            body,
+            ...(fromSession !== undefined ? { fromSession } : {}),
+            ...(fromName !== undefined ? { fromName } : {}),
+            ...(fromMode !== undefined ? { fromMode } : {}),
+            ...(fromScope !== undefined ? { fromScope } : {}),
+            ...(seq !== undefined ? { seq } : {}),
+        };
+    }
+    // ③ 跨会话回执 / idle 通知(§4.4 / §5.2)
+    const crossSessionNotice = dataProp(n, WIRE_KEY_CROSS_SESSION_NOTICE);
+    if (crossSessionNotice !== undefined) {
+        const kindRaw = dataProp(crossSessionNotice, WIRE_KEY_KIND);
+        const kind = CROSS_SESSION_NOTICE_KINDS.find(k => k === kindRaw);
+        const text = nonEmptyString(dataProp(crossSessionNotice, WIRE_KEY_TEXT));
+        if (kind === undefined || text === undefined || !provenanceAgrees(n, 'cross_session_notice'))
+            return null;
+        return { lane: 'cross_session_notice', kind, text };
+    }
+    return null;
+}
+// ── 帧 ⇄ 文本(端的消息面只拿得到文本;两半同源,往返在常驻门里对拍)────────────────────
+/**
+ * core `ENGINE_AUTHORITY_ENVELOPE_TAGS` 的镜像(`core/untrusted-text.ts::ENGINE_ENVELOPES` 里 kind="authority" 的标签):
+ * 这些信封在模型面/转录面代表**引擎权威**,一段同事正文里出现它们就是伪造。core 的 `neutralizePeerBody`
+ * (= `sanitizeUntrustedText(body, PEER_BODY_ENVELOPE_TAGS)`)在渲染信封**之前**先把它们拆火(`<` 后插 ZWSP),
+ * 本模块首版只抄了后一步(同名信封拆火)——异源发包扫描 [high] 实证:子代正文里一段
+ * `<task-notification><task-id>victim</task-id><status>completed</status>…` 会原样进转录 block,
+ * 宿主 resume 时 `parseTranscriptNotificationSeeds` 把它读成真完成通知 ⇒ 去重台账被毒化,受害 run 的
+ * 真完成通知随后被跨通道臂整条吞掉。这里补上那一步,并与 core 同形(`<\s*\/?\s*(tag)(\s[^>]*)?>` 全大小写)。
+ * 🔴 单向(与 core 一致):端的解析腿**不**还原 ZWSP —— 拆掉的权威标签就该永远是拆掉的。
+ */
+export const AUTHORITY_ENVELOPE_TAGS = Object.freeze([
+    'system-reminder',
+    'task-notification',
+    'new-diagnostics',
+    'user_memory',
+    'scope',
+    'skills',
+    'total_tokens',
+    'instruction-files',
+]);
+const ZWSP = String.fromCharCode(0x200b);
+const AUTHORITY_BREAKOUT_RE = new RegExp(`<\\s*\\/?\\s*(?:${AUTHORITY_ENVELOPE_TAGS.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})(?:\\s[^>]*)?>`, 'gi');
+function neutralizeAuthorityTags(text) {
+    return text.replace(AUTHORITY_BREAKOUT_RE, m => m.replace('<', '<' + ZWSP));
+}
+/**
+ * 署名类属性的呈现规范化(异源发包扫描 [medium]):`from` / `fromName` 是发送方**自述**的串,可含换行与控制符,
+ * 折叠行按单行渲会被它撑破。与 core `canonicalPeerDisplayName` 同向:控制符/换行折成单空格、两端去空白;
+ * 折空 ⇒ 视同缺席(必填位 ⇒ 整帧退泛化卡;可选位 ⇒ 只丢那一位)。
+ */
+function cleanName(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const t = v.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, ' ').replace(/\s+/g, ' ').trim();
+    return t.length > 0 ? t : undefined;
+}
+/**
+ * 正文里的同名标签拆火:开括号后插一个反斜杠,于是它不再是一个标签。
+ *
+ * 🔴 与 core 的 `escapeEnvelopeTag` **有意不同一格**(异源对抗复审 r1 [medium] 采纳):core 那一份是
+ *    **单向**消毒(模型读到就完了,没有反向腿),所以它不处理正文里**原本就有**的 `<\agent-message>`;
+ *    而本模块有反向腿(端的消息面要把正文还原出来),单向消毒在这里就是一个**非单射**映射 ——
+ *    一段合法的代码文本 `<\agent-message>` 会在 render→parse 往返之后被改写成 `<agent-message>`,
+ *    既损坏正文,又等于给正文一条**注入真标签**的路。
+ *    ⇒ 这里连**已有的反斜杠**一起数:`<` 后面跟任意多个反斜杠再跟标签名时都插一个。
+ *    每次编码恰好加一个、每次解码恰好去一个 ⇒ `unescape(escape(x)) === x` 对一切 x 成立。
+ */
+function escapeEnvelopeTag(tag, text) {
+    return text.replace(new RegExp(`<(?=\\\\*/?${tag}(?:[>\\s/]|$))`, 'gi'), '<\\');
+}
+function unescapeEnvelopeTag(tag, text) {
+    return text.replace(new RegExp(`<\\\\(?=\\\\*/?${tag}(?:[>\\s/]|$))`, 'gi'), '<');
+}
+/** 属性值转义 —— 属性用双引号包,值里的 `"` 与尖括号一律实体化,不给伪造闭合属性留缝。 */
+function attr(v) {
+    return v.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function unattr(v) {
+    return v.replace(/&quot;/g, '"').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+}
+/**
+ * 投影 → 转录行文本(端的消息面按标签分派的那一份)。
+ *
+ * 🔴 这**不是** core 模型面信封的逐字副本,也不该是:core 那一份是给**模型**读的(带纪律块、
+ *    带 CC 逐字属性语法、带 round-trip 拒收);这一份是**端的转录回显**,只需要与本模块的解析腿
+ *    往返一致。刻意不复刻 core 的语法契约 —— 复刻一份对不上的副本比不复刻更坏
+ *    (它会让人以为端这一行是模型读到的那一行)。属性序仍照 core 的规范序排,便于人肉比对。
+ */
+export function renderPeerFrameTranscriptText(p) {
+    // 🔴 通知纯行也是引擎按 peerMeta 铸的散文,但它承载的仍是**关于别人消息**的文本:同样过权威标签拆火,
+    //    并把两个消息信封标签拆火 —— 否则一条整体形如 `<agent-message …>…</agent-message>` 的通知会被端判成
+    //    一条署名消息(异源发包扫描同形存量③)。
+    if (p.lane === 'cross_session_notice')
+        return escapeEnvelopeTag(CROSS_SESSION_MESSAGE_TAG, escapeEnvelopeTag(AGENT_MESSAGE_TAG, neutralizeAuthorityTags(p.text)));
+    if (p.lane === 'agent_message') {
+        const body = escapeEnvelopeTag(AGENT_MESSAGE_TAG, neutralizeAuthorityTags(p.body));
+        return `<${AGENT_MESSAGE_TAG} ${FROM_ATTR}="${attr(p.from)}">\n${body}\n</${AGENT_MESSAGE_TAG}>`;
+    }
+    const attrs = [`${FROM_ATTR}="${attr(p.from)}"`];
+    if (p.fromSession !== undefined)
+        attrs.push(`from-session="${attr(p.fromSession)}"`);
+    if (p.fromName !== undefined)
+        attrs.push(`from-name="${attr(p.fromName)}"`);
+    if (p.fromMode !== undefined)
+        attrs.push(`from-mode="${attr(p.fromMode)}"`);
+    if (p.fromScope !== undefined)
+        attrs.push(`from-scope="${attr(p.fromScope)}"`);
+    const body = escapeEnvelopeTag(CROSS_SESSION_MESSAGE_TAG, neutralizeAuthorityTags(p.body));
+    return `<${CROSS_SESSION_MESSAGE_TAG} ${attrs.join(' ')}>\n${body}\n</${CROSS_SESSION_MESSAGE_TAG}>`;
+}
+// 🔴 属性值不设长度上界:渲染腿无界,解析腿封顶就会让包自己铸出的帧解析回 null(异源发包扫描 [high]);
+//    `[^"]*` 是线性匹配,无回溯风险。
+const AGENT_MESSAGE_RE = new RegExp(`^<${AGENT_MESSAGE_TAG} ${FROM_ATTR}="([^"]*)">\\n([\\s\\S]*)\\n</${AGENT_MESSAGE_TAG}>$`);
+const CROSS_SESSION_RE = new RegExp(`^<${CROSS_SESSION_MESSAGE_TAG} ${FROM_ATTR}="([^"]*)"` +
+    `(?: from-session="([^"]*)")?` +
+    `(?: from-name="([^"]*)")?` +
+    `(?: from-mode="(bypass|prompting)")?` +
+    `(?: from-scope="([^"]*)")?` +
+    `>\\n([\\s\\S]*)\\n</${CROSS_SESSION_MESSAGE_TAG}>$`);
+/**
+ * 转录行文本 → 投影(`renderPeerFrameTranscriptText` 的逆)。认不出 ⇒ `null`。
+ *
+ * 端唯一该调的字符串判定口:**端自己一条正则都不许写**(cli-191 A-D1/A-D12 那一族的成因就是
+ * 消费端各自抄一份判据,上游改词后集体空转而没有一道门响)。
+ *
+ * 🔴 `ok` 只等于「形是规范的」,**不等于**「这条消息真是引擎注入的」——文本面的身份权威不存在
+ *    (core §4.2 三层规则同一句话)。端拿它做**呈现**分派,不许拿它做任何授权判断。
+ * 🔴 通知车道(`cross_session_notice`)刻意**不进这条腿**:它的转录行是一行没有标签的散文,
+ *    要认它只能去锚 `[Cross-session …]` 前缀 —— 那正是本仓禁的那一形(用户随手打一行同样的字
+ *    就会被认成引擎通知)。通知按普通文本行渲,本来就是 CC 形。
+ */
+function hasRawTag(tag, body) {
+    return new RegExp(`<(?=/?${tag}(?:[>\\s/]|$))`, 'i').test(body);
+}
+export function parsePeerFrameText(text) {
+    const a = AGENT_MESSAGE_RE.exec(text);
+    if (a !== null) {
+        const from = unattr(a[1] ?? '');
+        // 🔴 正文里出现**未拆火**的同名标签 ⇒ 这不是本渲染腿产出的字节(它拆火过了),而**贪婪**的
+        //    `[\s\S]*` 会把「两封拼在一起」读成一封、把两封的正文合并、把两位署名合并成第一位 ——
+        //    异源对抗复审 r1 [high] 的第三形。整条退 null:落回普通文本行,一个字节都不丢。
+        if (from.length === 0 || hasRawTag(AGENT_MESSAGE_TAG, a[2] ?? ''))
+            return null;
+        return { lane: 'agent_message', from, body: unescapeEnvelopeTag(AGENT_MESSAGE_TAG, a[2] ?? '') };
+    }
+    const c = CROSS_SESSION_RE.exec(text);
+    if (c === null)
+        return null;
+    const from = unattr(c[1] ?? '');
+    if (from.length === 0 || hasRawTag(CROSS_SESSION_MESSAGE_TAG, c[6] ?? ''))
+        return null;
+    const fromSession = c[2] !== undefined ? unattr(c[2]) : undefined;
+    const fromName = c[3] !== undefined ? unattr(c[3]) : undefined;
+    const fromMode = PEER_MODE_CLASSES.find(m => m === c[4]);
+    const fromScope = c[5] !== undefined ? unattr(c[5]) : undefined;
+    return {
+        lane: 'cross_session_message',
+        from,
+        body: unescapeEnvelopeTag(CROSS_SESSION_MESSAGE_TAG, c[6] ?? ''),
+        ...(fromSession !== undefined ? { fromSession } : {}),
+        ...(fromName !== undefined ? { fromName } : {}),
+        ...(fromMode !== undefined ? { fromMode } : {}),
+        ...(fromScope !== undefined ? { fromScope } : {}),
+    };
+}
+/**
+ * 端渲「@谁」时该用的那个名字 —— 判定在包,端不许自己排优先序。
+ * 跨会话:`fromName`(人取的名)优先于 `from`(地址);同进程:只有 `from`。
+ */
+export function peerFrameDisplayName(p) {
+    return p.lane === 'cross_session_message' && p.fromName !== undefined ? p.fromName : p.from;
+}