@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/peerFrames.js

@@ -1,61 +1,9 @@
-/**
- * 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';
@@ -66,22 +14,12 @@ 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;
@@ -90,7 +28,6 @@ function dataProp(o, key) {
         d = Object.getOwnPropertyDescriptor(o, key);
     }
     catch {
-        // 已撤销的 Proxy / 敌意 trap:当缺席(读不出来 ≠ 有值)
         return undefined;
     }
     if (d === undefined || !('value' in d))
@@ -103,45 +40,12 @@ function nonEmptyString(v) {
 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;
@@ -151,16 +55,8 @@ function provenanceAgrees(n, lane, carrierFrom) {
     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));
@@ -177,7 +73,6 @@ export function classifyPeerNotification(n) {
         }
         return null;
     }
-    // ② 跨会话信封(§4.1)
     const crossSessionMessage = dataProp(n, WIRE_KEY_CROSS_SESSION_MESSAGE);
     if (crossSessionMessage !== undefined) {
         const from = cleanName(dataProp(crossSessionMessage, WIRE_KEY_FROM));
@@ -189,8 +84,6 @@ export function classifyPeerNotification(n) {
         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,
@@ -202,7 +95,6 @@ export function classifyPeerNotification(n) {
             ...(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);
@@ -214,17 +106,6 @@ export function classifyPeerNotification(n) {
     }
     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 —— 拆掉的权威标签就该永远是拆掉的。
- */
 const AUTHORITY_ENVELOPE_TAGS = Object.freeze([
     'system-reminder',
     'task-notification',
@@ -240,53 +121,25 @@ const AUTHORITY_BREAKOUT_RE = new RegExp(`<\\s*\\/?\\s*(?:${AUTHORITY_ENVELOPE_T
 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') {
@@ -305,8 +158,6 @@ export function renderPeerFrameTranscriptText(p) {
     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="([^"]*)")?` +
@@ -314,18 +165,6 @@ const CROSS_SESSION_RE = new RegExp(`^<${CROSS_SESSION_MESSAGE_TAG} ${FROM_ATTR}
     `(?: 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);
 }
@@ -333,9 +172,6 @@ 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] ?? '') };
@@ -360,10 +196,6 @@ export function parsePeerFrameText(text) {
         ...(fromScope !== undefined ? { fromScope } : {}),
     };
 }
-/**
- * 端渲「@谁」时该用的那个名字 —— 判定在包,端不许自己排优先序。
- * 跨会话:`fromName`(人取的名)优先于 `from`(地址);同进程:只有 `from`。
- */
 export function peerFrameDisplayName(p) {
     return p.lane === 'cross_session_message' && p.fromName !== undefined ? p.fromName : p.from;
 }

package/dist/peerLaneCapability.d.ts

@@ -1,32 +1,3 @@
-/**
- * peerLaneCapability — `GET /v1/capabilities.peerLane`(server ≥7.91.1;sdk 9.8.1 尚未声明该键 ⇒ 结构读)
- * 的三端共用读面(0.76.1 CC-102;与 sql / writeProtection / webSearch.backend / executionLane /
- * approvalsStreamLive / deviceExecutor.management 各只兄弟同一套四态词汇)。
- *
- * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
- * 「本部署的会话之间能不能互相发现并投递」——引擎的跨会话目录席是否已挂(会话枚举面 ∧ 耐久
- * mailbox ∧ 该 mailbox 的收件人生命周期面,三缺一即缺席)。位为真时模型侧多出 `ListAgents`
- * (列同一 principal 的其它会话)、`SendMessage` 的 `session.<id>` 地址臂,以及每 turn 边界对本
- * 会话那只会话盒的排水。
- *
- * ── 🔴 本位不是 HTTP 面 ────────────────────────────────────────────────────────────────────
- * 上游没有为这一族能力单开任何新端点 —— 会话清单仍走既有的会话列举口。所以本位的消费方式是
- * **渲染 / 预期**(要不要露出跨会话的入口),不是拿它去 gate 某一个动词的调用。
- * ⚠️ 辖域只到「席」:上游另有一道装配期挂载判据(mailbox 必须显式声明跨进程安全),不齐时会在
- * 装配期响亮拒挂并通告运维;本读面刻意不复判那一道 —— 复判 = 给同一件事立第二个判官。
- *
- * ── 🔴 四态,不是两态([honest-absence-not-fabricated-zero])──────────────────────────────────
- *   ① `unobserved`   —— 本进程一次 caps 响应都没观测到。
- *   ② `not_reported` —— caps 观测到了,而回体上**没有** `peerLane` 这个键 ⇒ 老 worker(比 7.91.1 老)。
- *      这台部署有没有跨会话车道**判不出**,不是「没有」。
- *   ③ `absent`       —— 键在、值**明确是** `false`:这台部署没有挂跨会话目录席。**正面事实**,
- *      与 `not_reported`(判不出)是两件不同的事,处置也相反。
- *   ④ `present`      —— 键在、值为 `true`:席已挂。
- * 值既不是 `true` 也不是 `false`(串 / 数 / null / 数组 / 对象)⇒ 畸形 ⇒ 删格(⇒ `unobserved`)。
- * 🔴 三种「没有」(`unobserved` / `not_reported` / `absent`)**不许互折** —— 折起来会把「判不出」
- * 说成「引擎明说没有」,或把「一次都没问过」说成「问过、答案是没有」。
- */
-/** 四态读数。`unobserved` 由读口在这一格空缺时铸,不由投影铸。 */
 export type PeerLaneReading = {
     kind: 'unobserved';
 } | {
@@ -36,27 +7,12 @@ export type PeerLaneReading = {
 } | {
     kind: 'present';
 };
-/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
 export declare function projectPeerLaneCapability(caps: unknown): PeerLaneReading | undefined;
-/** 宿主 caps probe 的读面 tee 落点。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
 export declare function noteEngineCapsForPeerLane(baseUrl: string, caps: unknown, opts?: {
     generation?: number;
 }): void;
-/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
 export declare function observedPeerLane(baseUrl?: string | undefined): PeerLaneReading;
-/**
- * 「要不要在壳上露出跨会话入口(`ListAgents` / `SendMessage` 的 `session.<id>` 地址臂)」的判据
- * 单源(三态):只有引擎明说挂了(`present`)才 `'yes'`;明说没挂(`absent`)⇒ `'no'`;
- * **键缺席(`not_reported`)也是 `'no'`** —— 这一位的在场性本身就是版本信号,上游对缺席的成文语义是
- * 「老 worker:本部署没有跨会话车道,按会话 id 投递按查无此会话拒」,所以缺席**不是**判不出,是一句
- * 有内容的否定(与写键那一位「缺席 ⇒ 藏入口」同一条读法);只有本进程**从没观测过**(`unobserved`)
- * 才是真的判不出 ⇒ `'unknown'`(别预判成有也别预判成没有)。
- */
 export declare function peerLaneAvailable(reading: PeerLaneReading): 'yes' | 'no' | 'unknown';
-/** doctor 那一行的 detail 串,唯一措辞真源。🔴 `unobserved` 那句不许暗示「有」或「没有」;`not_reported` 那句按上游成文语义说
- *  「老 worker,没有跨会话车道」,并把「为什么缺席就是没有」(在场性即版本信号)说清,不让端把它读成第二种「判不出」。 */
 export declare function peerLaneDoctorDetail(reading: PeerLaneReading): string;
-/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
 export declare function forgetPeerLaneReading(baseUrl: string | undefined): void;
-/** 测试钩子。 */
 export declare function __resetPeerLaneReadingsForTests(): void;

package/dist/peerLaneCapability.js

@@ -1,44 +1,12 @@
-/**
- * peerLaneCapability — `GET /v1/capabilities.peerLane`(server ≥7.91.1;sdk 9.8.1 尚未声明该键 ⇒ 结构读)
- * 的三端共用读面(0.76.1 CC-102;与 sql / writeProtection / webSearch.backend / executionLane /
- * approvalsStreamLive / deviceExecutor.management 各只兄弟同一套四态词汇)。
- *
- * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
- * 「本部署的会话之间能不能互相发现并投递」——引擎的跨会话目录席是否已挂(会话枚举面 ∧ 耐久
- * mailbox ∧ 该 mailbox 的收件人生命周期面,三缺一即缺席)。位为真时模型侧多出 `ListAgents`
- * (列同一 principal 的其它会话)、`SendMessage` 的 `session.<id>` 地址臂,以及每 turn 边界对本
- * 会话那只会话盒的排水。
- *
- * ── 🔴 本位不是 HTTP 面 ────────────────────────────────────────────────────────────────────
- * 上游没有为这一族能力单开任何新端点 —— 会话清单仍走既有的会话列举口。所以本位的消费方式是
- * **渲染 / 预期**(要不要露出跨会话的入口),不是拿它去 gate 某一个动词的调用。
- * ⚠️ 辖域只到「席」:上游另有一道装配期挂载判据(mailbox 必须显式声明跨进程安全),不齐时会在
- * 装配期响亮拒挂并通告运维;本读面刻意不复判那一道 —— 复判 = 给同一件事立第二个判官。
- *
- * ── 🔴 四态,不是两态([honest-absence-not-fabricated-zero])──────────────────────────────────
- *   ① `unobserved`   —— 本进程一次 caps 响应都没观测到。
- *   ② `not_reported` —— caps 观测到了,而回体上**没有** `peerLane` 这个键 ⇒ 老 worker(比 7.91.1 老)。
- *      这台部署有没有跨会话车道**判不出**,不是「没有」。
- *   ③ `absent`       —— 键在、值**明确是** `false`:这台部署没有挂跨会话目录席。**正面事实**,
- *      与 `not_reported`(判不出)是两件不同的事,处置也相反。
- *   ④ `present`      —— 键在、值为 `true`:席已挂。
- * 值既不是 `true` 也不是 `false`(串 / 数 / null / 数组 / 对象)⇒ 畸形 ⇒ 删格(⇒ `unobserved`)。
- * 🔴 三种「没有」(`unobserved` / `not_reported` / `absent`)**不许互折** —— 折起来会把「判不出」
- * 说成「引擎明说没有」,或把「一次都没问过」说成「问过、答案是没有」。
- */
 import { engineWireTarget } from './engineWireTarget.js';
 import { createEngineCapReader } from './engineCapReader.js';
-/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
 export function projectPeerLaneCapability(caps) {
     if (caps === null || typeof caps !== 'object')
         return undefined;
-    // 0.77.0 整族改齐:① 非对象 / 数组 caps 不是能力表 ⇒ 畸形(投影答 undefined ⇒ 删格 ⇒ 读口答 unobserved),不再答 not_reported
-    //    (那是把「取不到」冒充「报了但没提」);② 在场判据改 hasOwn —— 原型链上的同名键永远不会被序列化上 wire,读成在场 = 凭空造一格。
     if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
         return undefined;
     if (!Object.hasOwn(caps, 'peerLane'))
         return { kind: 'not_reported' };
-    // 🔴 只读一次:在场判据与取值同一次读(变化的 getter 不会让两处判断看到两个不同的值)。
     const v = caps.peerLane;
     if (v === undefined)
         return { kind: 'not_reported' };
@@ -46,33 +14,17 @@ export function projectPeerLaneCapability(caps) {
         return undefined;
     return v ? { kind: 'present' } : { kind: 'absent' };
 }
-/**
- * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 能力位读器**共用同一份实现**
- * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数
- * {@link projectPeerLaneCapability}、doctor 措辞表,以及本位自己的判据助手。
- * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
- */
 const reader = createEngineCapReader({
     name: 'peerLane',
     project: projectPeerLaneCapability,
     makeUnobserved: () => ({ kind: 'unobserved' }),
 });
-/** 宿主 caps probe 的读面 tee 落点。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
 export function noteEngineCapsForPeerLane(baseUrl, caps, opts) {
     reader.note(baseUrl, caps, opts);
 }
-/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
 export function observedPeerLane(baseUrl = engineWireTarget()?.baseUrl) {
     return reader.observed(baseUrl);
 }
-/**
- * 「要不要在壳上露出跨会话入口(`ListAgents` / `SendMessage` 的 `session.<id>` 地址臂)」的判据
- * 单源(三态):只有引擎明说挂了(`present`)才 `'yes'`;明说没挂(`absent`)⇒ `'no'`;
- * **键缺席(`not_reported`)也是 `'no'`** —— 这一位的在场性本身就是版本信号,上游对缺席的成文语义是
- * 「老 worker:本部署没有跨会话车道,按会话 id 投递按查无此会话拒」,所以缺席**不是**判不出,是一句
- * 有内容的否定(与写键那一位「缺席 ⇒ 藏入口」同一条读法);只有本进程**从没观测过**(`unobserved`)
- * 才是真的判不出 ⇒ `'unknown'`(别预判成有也别预判成没有)。
- */
 export function peerLaneAvailable(reading) {
     if (reading.kind === 'present')
         return 'yes';
@@ -80,8 +32,6 @@ export function peerLaneAvailable(reading) {
         return 'no';
     return 'unknown';
 }
-/** doctor 那一行的 detail 串,唯一措辞真源。🔴 `unobserved` 那句不许暗示「有」或「没有」;`not_reported` 那句按上游成文语义说
- *  「老 worker,没有跨会话车道」,并把「为什么缺席就是没有」(在场性即版本信号)说清,不让端把它读成第二种「判不出」。 */
 export function peerLaneDoctorDetail(reading) {
     switch (reading.kind) {
         case 'unobserved':
@@ -94,11 +44,9 @@ export function peerLaneDoctorDetail(reading) {
             return 'cross-session lane on — this engine can discover and deliver across sessions for the same caller';
     }
 }
-/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
 export function forgetPeerLaneReading(baseUrl) {
     reader.forget(baseUrl);
 }
-/** 测试钩子。 */
 export function __resetPeerLaneReadingsForTests() {
     reader.__resetForTests();
 }

package/dist/permissionRuleIssue.d.ts

@@ -1,33 +1,3 @@
-/**
- * 引擎**真会铸**的规则 lint 拒因码(core `PermissionRuleIssue.code`,7.9.x = 十五码)。
- * 顺序与 core 声明同源。
- * 🔴 这是一份**抄件**,不是本包的意见 —— 改它必须同 commit 附 core 坐标,且门会先红。
-
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
 export declare const PERMISSION_RULE_ISSUE_CODES: readonly string[];
-/**
- * 在 core 的**声明**联合里还留着、但引擎**再也不铸**的码(记账用,不进呈现表)。
- *   · `unsupported.unknown_param` —— core 7.8.0(B15)改名成 `unsupported.param_unknown`,
- *     联合里的旧名没删干净。
- * 🔴 这张表**不是**给消费端查的,它是给门的:`表 ∪ 退役表 == 声明联合` 这条等式让「上游删掉那一员」
- *    与「上游又留下一个新的 stale 成员」都当场红。查码一律查 {@link PERMISSION_RULE_ISSUE_CODES}。
- * ⚠️ 另有一个更早的退役名 `unsupported.bash_prefix_rules_store`(sdk README 记的减员)——它在 core
- *    7.9.x 的**声明里已经没有了**,所以不登记在这里(登记一个两个真源都不认的名字,门会红)。
-
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
 export declare const RETIRED_PERMISSION_RULE_ISSUE_CODES: readonly string[];
-/**
- * 一个 lint 拒因 → 一句人话(+ 引擎自己那句更具体的散文)。**唯一措辞铸点**(三端共用;端零自拼)。
- *
- * 🔴 表外码的那一句说的是「**这个码比这一端新**」——码表的属主是引擎,加码不该被渲成故障;
- *    原样带上那个码(运维要拿它去问上游),并**照样带上 `message`**:码读不懂不代表引擎那句话
- *    读不懂,而那句话往往才是能动手改的那条信息。
- * 🔴 `message` 是**散文不是码**:只渲染、呈前消毒 + 封长,绝不做等值匹配、绝不当分类位。
- * 🔴 坏码 / 坏 message 一律不抛 —— 这条路径跑在「用户规则写错了」的那一刻,读器自己再抛一次
- *    只会把一个可以说清的错误换成一个说不清的崩。
- */
 export declare function permissionRuleIssueDetail(code: unknown, message: unknown): string;

package/dist/permissionRuleIssue.js

@@ -1,48 +1,4 @@
-/**
- * src/permissionRuleIssue.ts — 权限规则 lint 的**拒因码表 + 唯一措辞铸点**
- * (0.63.0;L-162 ②;engine >=7.67.0 / core 7.9.x)。
- *
- * -- 这张表为什么是**铸**的而不是**取**的(以及它什么时候该被换掉)---------------------------
- * 引擎在装配一份权限规则表时,对每条它不接的规则出一个 `{rule, code, message}`。`code` 是**机读
- * 的处置分类**,`message` 是给人看的**散文**。sdk 8.8.0 **既无 spec schema 也无导出型**(sdk 自己的
- * README 在「如实登记(本版没做的)」一节里写了这一格),所以本包没有可以 `import` 的上游码表。
- * => 按引擎真字节铸一张。
- *
- * 🔴 **候上游导出即换**:sdk 哪天导出 `PermissionRuleIssue` 的码表(型或 `as const` 值表),本表
- *    应当**整只退役**、改成从 sdk 取(与本包对 `RULE_OFFER_MATCHES` 那几张表的处置同形)。
- *    给下游的反漂移锚:`dts-pattern` 盯 sdk 的 `PermissionRuleIssue` 上出现 `code` 声明。
- * 🔴 **镜像的代价用门付,不用「记得同步」付**:`run-permission-rule-issue-codes-test.mjs` 直接读
- *    实装 `@sema-agent/core` 的两份产物做双向对账(见下一段),core 一动这里就先红。
- *
- * -- 两个真源,而且它们**不相等** ------------------------------------------------------------
- *   (1) core 的 `permission-rules.js` 里**真被铸出来**的码 —— 这是 wire 上真会到达消费端的集合,
- *       {@link PERMISSION_RULE_ISSUE_CODES} 与它逐码等值;
- *   (2) core 的 `permission-rules.d.ts` 里 `code` 的**声明**联合 —— 它比 (1) 多一员
- *       `unsupported.unknown_param`。core 自己的 CHANGELOG(B15)写着那一员已**改名**成
- *       `unsupported.param_unknown`,联合里的旧名只是没删干净。收它进呈现表 = 复活一个引擎再也
- *       不会铸的码(一个永不触发的分支),所以它单列在 {@link RETIRED_PERMISSION_RULE_ISSUE_CODES}
- *       里记账,门按 `表 ∪ 退役表 == 声明联合` 对账。
- *
- * -- 两族码的**处置**不同,措辞必须说得出来 --------------------------------------------------
- *   · `invalid.*` = 这条规则**写错了**(语法/语义)—— 下一步是改规则;
- *   · `unsupported.*` = 规则本身合法,但**这条车道不接**(CC 里合法而 v1 不支持的 lane,或该去
- *     另一个面落的常驻同意)—— 下一步是换一种写法、或把它落到规则店而不是策略折叠里。
- *   两族绝不共用一句 —— 上游把它们分成两个前缀,正是因为「以为挡住了」比没挡更危险
- *   (`Bash(npm run:*)` 被当成 generic 参数规则接受后永不匹配,是这条面上最危险的失败形态)。
- *
- * -- UNTRUSTED --------------------------------------------------------------------------------
- * `message` 是引擎/用户 settings 侧的内容(里面会带用户自己写的规则文本):只渲染,呈前**先转义、
- * 后按转义结果封长**(与本包其余 detail 铸点同一条纪律),绝不当码用、绝不做等值匹配。
- */
 import { capForDisplay, escapeDisplayControlChars } from './fleetTaskDesc.js';
-/**
- * 引擎**真会铸**的规则 lint 拒因码(core `PermissionRuleIssue.code`,7.9.x = 十五码)。
- * 顺序与 core 声明同源。
- * 🔴 这是一份**抄件**,不是本包的意见 —— 改它必须同 commit 附 core 坐标,且门会先红。
-
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
 export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'invalid.empty_tool',
     'invalid.paren',
@@ -60,26 +16,9 @@ export const PERMISSION_RULE_ISSUE_CODES = Object.freeze([
     'unsupported.mcp_paren',
     'unsupported.covering_paren',
 ]);
-/**
- * 在 core 的**声明**联合里还留着、但引擎**再也不铸**的码(记账用,不进呈现表)。
- *   · `unsupported.unknown_param` —— core 7.8.0(B15)改名成 `unsupported.param_unknown`,
- *     联合里的旧名没删干净。
- * 🔴 这张表**不是**给消费端查的,它是给门的:`表 ∪ 退役表 == 声明联合` 这条等式让「上游删掉那一员」
- *    与「上游又留下一个新的 stale 成员」都当场红。查码一律查 {@link PERMISSION_RULE_ISSUE_CODES}。
- * ⚠️ 另有一个更早的退役名 `unsupported.bash_prefix_rules_store`(sdk README 记的减员)——它在 core
- *    7.9.x 的**声明里已经没有了**,所以不登记在这里(登记一个两个真源都不认的名字,门会红)。
-
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()`
- *    就能改,而公面消费者拿到的正是这个实例(本仓已定谳的病形,同 `RESUME_RETRY_LATER_CODES`)。
- */
 export const RETIRED_PERMISSION_RULE_ISSUE_CODES = Object.freeze(['unsupported.unknown_param']);
-/** `message` 上屏封长(UTF-16 单元,按**转义后**长度算;它是一句话,给得比词宽)。 */
 const ISSUE_MESSAGE_MAX = 200;
-/**
- * 逐码一句人话。**十五句刻意逐字互异**:每一条对写规则的人是一条不同的下一步。
- */
 const ISSUE_SENTENCES = Object.freeze({
-    // -- invalid.*:规则写错了 ------------------------------------------------------------------
     'invalid.empty_tool': 'this rule is invalid: it names no tool',
     'invalid.paren': 'this rule is invalid: its parentheses do not parse (escape a literal one as \\( or \\))',
     'invalid.param_split': 'this rule is invalid: the part before the colon is not a parameter name',
@@ -87,7 +26,6 @@ const ISSUE_SENTENCES = Object.freeze({
     'invalid.primary_field': "this rule is invalid: it patterns the tool's primary field, which matches the whole trimmed string rather than a prefix",
     'invalid.cap_exceeded': 'this rule set is invalid: it is over one of the deployment caps (rule count, rule length, pattern length, or star count)',
     'invalid.command_rule': 'this rule is invalid: the command pattern was rejected by the command-rule validator',
-    // -- unsupported.*:规则合法,但这条车道不接 ------------------------------------------------
     'unsupported.bash_prefix': 'a standing approval for a command belongs in the persisted-rule store, so this allow rule is not supported here (deny and ask rules with the same shape do compile)',
     'unsupported.param_unknown': 'this parameter rule is not supported: the tool carries no such parameter, so it could never match',
     'unsupported.param_non_scalar': 'this parameter rule is not supported: that parameter holds an object or an array, so it could never match',
@@ -97,27 +35,11 @@ const ISSUE_SENTENCES = Object.freeze({
     'unsupported.mcp_paren': 'a parenthesised parameter rule is not supported on an MCP tool name',
     'unsupported.covering_paren': 'a parenthesised parameter rule is not supported on a covering protocol name — the parameter grammar is keyed by an exact tool name, so no mounted tool could ever bear it',
 });
-/**
- * 一个 lint 拒因 → 一句人话(+ 引擎自己那句更具体的散文)。**唯一措辞铸点**(三端共用;端零自拼)。
- *
- * 🔴 表外码的那一句说的是「**这个码比这一端新**」——码表的属主是引擎,加码不该被渲成故障;
- *    原样带上那个码(运维要拿它去问上游),并**照样带上 `message`**:码读不懂不代表引擎那句话
- *    读不懂,而那句话往往才是能动手改的那条信息。
- * 🔴 `message` 是**散文不是码**:只渲染、呈前消毒 + 封长,绝不做等值匹配、绝不当分类位。
- * 🔴 坏码 / 坏 message 一律不抛 —— 这条路径跑在「用户规则写错了」的那一刻,读器自己再抛一次
- *    只会把一个可以说清的错误换成一个说不清的崩。
- */
 export function permissionRuleIssueDetail(code, message) {
-    // 🔴 自有属性判据(异源对抗复审 [medium]):`Object.freeze` 不移除原型,`ISSUE_SENTENCES['toString']`
-    //    会命中 `Object.prototype` 上的函数并被当成「一句话」交出去。
     const known = typeof code === 'string' && Object.hasOwn(ISSUE_SENTENCES, code) ? ISSUE_SENTENCES[code] : undefined;
     const text = typeof message === 'string' && message.length > 0
         ? capForDisplay(message, ISSUE_MESSAGE_MAX)
         : '';
-    // 🔴 **码原样带上,不封长**(0.63.1,G-11):`code` 是**引擎产的标识符**,不是散文 —— 运维要拿它
-    //    整只去问上游,截一半的码谁也查不出来,而且长得像一个完整答案。呈前只做**不可见字符消毒**
-    //    (走本包同一只 {@link escapeDisplayControlChars};不封长 ≠ 不消毒)。`message` 半场的封长
-    //    照旧:那半场确实是散文,屏上的列宽预算是给它的。两半场判据分家是刻意的。
     const codeWord = typeof code === 'string' && code.length > 0 ? escapeDisplayControlChars(code) : '(no code)';
     const head = known !== undefined
         ? known