@sema-agent/client-core 0.76.0 → 0.76.2

package/dist/mcpLiveness.js

@@ -0,0 +1,218 @@
+/**
+ * mcpLiveness.ts — 引擎托管的 MCP 服务器**活性观察**(`wiring_manifest.mcp[].liveness`)的三端共用
+ * **结构读口** + 三词闭集词表 + 腿级判词(CC-36,0.76.1)。引擎内核自 7.24.3 起铸这一格,服务端的转发层自 7.91.2 起把它送上 wire ——
+ * 更老的服务端上这一格**恒缺席**(读数 = `indeterminate`,正是缺席语义要兜的那一档,不是故障)。
+ *
+ * ── 这一格答的是哪一个问题 ────────────────────────────────────────────────────────────────────
+ * 「这台服务器**还够得着吗**」。引擎不为它发任何自己的流量 —— 每条记录都是那条腿**已经做过的工作**
+ * (拨号、re-dial、传输关闭、一次发现传输没了的请求)顺带盖的章,自带盖章时刻 `observedAt`。
+ * ⇒ 它是**每条腿的一张快照**,不是心跳、不是轮询、更不是「此刻」。
+ *
+ * 🔴 **同一行上的三个位各说各的,谁都不许顶替谁、不许互相校验、不许据其一推另一个**:
+ *  · `status`(申报 / 连接时判决)—— 这条腿**拨号那一刻**的判词,引擎**有意冻结**它(服务器中途死了这一格
+ *    仍读 `connected`);
+ *  · re-dial 回执的 `outcome`(动作判决)—— **一次动作**的判词,过去式;
+ *  · `liveness`(本件)—— 连接层**最后学到的那件事**,自带时戳。
+ *  最直白的一格:`status: 'failed'` 与 `liveness.state: 'reachable'` **同一行并存是真行** —— 服务器答了
+ *  握手、答的是协议错(**活着,且配错了**)。判据是「两格都在」,不是「两格一致」。
+ *
+ * ── 🔴 四种读数(三个词 + 缺席),缺席**不是**其中任何一个词 ────────────────────────────────────
+ *  · `reachable`   —— **一次交换完成了**(连上并列出了,或服务器自己答了 —— MCP 级的拒绝**也是答**,所以
+ *    它证明够得着,即便那次调用失败);
+ *  · `unreachable` —— 试过,丢在传输或时钟上(拒连 / 重置 / 关闭 / 起不来 / 超时);
+ *  · `unknown`     —— **试过,而回来的东西答不了这个问题**(服务器前面那台网关写的 HTTP 状态、非 MCP 载荷、
+ *    没有结构的抛出值)。它是一句**更强**的断言:引擎看了,看不出来。
+ *  · **缺席 = indeterminate** —— 这一行**没有可用的观察记录**。四个来源在 wire 上**同形**,消费端分不出也
+ *    不需要分:① 这条腿没走到那台服务器(`status: 'skipped'`);② 那份声明从来没被拨过(`invalid_config`);
+ *    ③ 这是一条老引擎 / 老服务端的帧;④ 上游判形没过、那一格被摘掉了。
+ *    🔴 **不许据缺席反推「这条腿拨没拨过号」**,也不许把它折进 `unknown`、折成「健康」、折成「关着」。
+ *    这四句话在本包里是四句不同的话,任何折叠都是「把不知道说成没有 / 说成好着呢」的变体。
+ *
+ * ── 为什么是结构读(不靠型面) ─────────────────────────────────────────────────────────────────
+ * 本包 peer 地板上的 wire 型面里**还没有这一格**(键形是引擎侧先出、型面后出的常态)。所以本件按契约
+ * **结构读**:从 `unknown` 起按键路径窄化,判据自带(见下),**不抬 peer 地板、不等型面**。安全性不靠型
+ * 而靠三条:① 三词按**闭集恰等**判,认不得的词一律畸形(词表属主在上游,本包**不放宽**成开集 —— 放宽了
+ * 就会把一个没人定义过的词当成一句真话往屏上送);② `observedAt` 按**有限数**判;③ 判形没过 ⇒ 这一格
+ * 摘掉、那一行照读(与上游同判),而摘掉的**理由**留在 {@link McpLivenessCell} 的 `unreadable` 臂上,
+ * 与「引擎没报」分开。型面出键那天由包侧门逼一次显式处置(见 `run-mcp-liveness-test.mjs` 的上游见证臂)。
+ *
+ * ── `errorCode` 只随 `unreachable` ────────────────────────────────────────────────────────────
+ * 它是那句话的**注脚**(为什么够不着),不是那句话本身。上游的单点铸造保证它**只随 `unreachable`** 出现,
+ * 理由逐字可查:`unknown` 的全部意思就是「那次失败并没有决定可达性」,把失败类别挂在那个词上等于请消费端
+ * 拿一份说明不了可达性的证据去决定下一步动作。⇒ 本读口在**非 `unreachable`** 臂上**丢掉这只注脚**
+ * (整格仍在、`state` 仍读):去掉的恰是上游点名要防的那条误读路,而 `state` 那句话一个字没动。
+ * 注脚自己形坏(空串 / 非串)同样**只丢它自己不拆整格** —— 代价如实:此时读到的是「够不着,原因没说」,
+ * **不是**「这条记录坏了」。词按**开集**读(十词闭集的属主在上游,抄一张会把新词吞成缺席)。
+ */
+/**
+ * 活性词的**三词闭集**(与上游同序:能完成交换 / 完不成 / 答不了)。
+ *
+ * 🔴 **它只有三个词**。腿级判词的第四个读数 `indeterminate`(见 {@link McpLegLivenessReading})**不是**
+ *    本表成员,也绝不许被加进来:本表是**上游的词表**,那第四个读数是**缺席**在本包里的名字。
+ * 🔴 消费端按本表写的 `switch` 判**恰等**(不 trim、不折大小写、不按前缀猜);上游加词的唯一处置是
+ *    **本表同批加一格 + 补一条读数格**,而不是在消费点放宽判据。
+ */
+export const MCP_LIVENESS_STATES = Object.freeze(['reachable', 'unreachable', 'unknown']);
+/** 三词闭集的**唯一**判据(恰等;行级读口与腿级判词共用这一只,不各写一遍)。 */
+const isLivenessState = (v) => typeof v === 'string' && MCP_LIVENESS_STATES.includes(v);
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/**
+ * 从**一行** MCP 名册条目里读这一格(结构读;单一铸点,别在消费点再写一遍判据)。
+ *
+ * 缺席答什么:`{kind:'absent'}` —— 判据是**自有键在不在**(`Object.hasOwn`),不按真值判。原型链上的
+ *   同名键**永远不会**上 wire,拿它当在场 = 把本进程对象的形状当成引擎说过的话;`null` / `undefined`
+ *   显式在场是**坏形**(走 `unreadable`),不是缺席形。
+ * 畸形答什么:`{kind:'unreadable'}` —— 整行不是对象、整格不是对象(含 `null` / 数组 / 串 / 数)、
+ *   `state` 不是三词之一(含空串、近形拼法、大小写变体)、`observedAt` 非有限数(含缺席 / 串 / `NaN`)。
+ *   🔴 **绝不**折成 `{kind:'absent'}`(会把「送来一份读不懂的」说成「引擎没报」),更**绝不**折成
+ *   `reachable` 或任何一个词(那是把读不出说成好着呢)。
+ * 为什么不折:这三句话在本包下游各对一种不同的处置 —— 缺席 = 什么都不渲(**不许**渲「一台都够不着」也
+ *   **不许**渲「都好着」);读不出 = 渲「这一格读不出」并让运维去看引擎版本与投影层;观察 = 渲那个词
+ *   + 那个时刻。折任何一对,渲出来的都是一句谁都没说过的话。
+ *
+ * ⚠️ 本口**只读这一格**:同行的 `status` / `errorCode` / `delivered` 一个字节都不碰,也不拿它们互相校验
+ *    (三个位各说各的,见文件顶注)。
+ */
+export function readMcpLiveness(row) {
+    // 整行不是对象:说「引擎没报」就是替引擎发言 —— 我们连有没有这一行都没读出来。
+    if (!isRecord(row))
+        return { kind: 'unreadable' };
+    if (!Object.hasOwn(row, 'liveness'))
+        return { kind: 'absent' };
+    const cell = row.liveness;
+    if (!isRecord(cell))
+        return { kind: 'unreadable' };
+    const state = cell.state;
+    if (!isLivenessState(state))
+        return { kind: 'unreadable' };
+    const observedAt = cell.observedAt;
+    if (typeof observedAt !== 'number' || !Number.isFinite(observedAt))
+        return { kind: 'unreadable' };
+    const liveness = { state, observedAt };
+    // 注脚:只随 unreachable 收,且形坏只丢它自己(见文件顶注最后一段)。
+    if (state === 'unreachable' && typeof cell.errorCode === 'string' && cell.errorCode.length > 0) {
+        liveness.errorCode = cell.errorCode;
+    }
+    return { kind: 'observation', liveness };
+}
+/**
+ * 一条腿的名册 → 活性判词(**唯一铸点**:别在各端的状态行装配里另写一遍这套合成规则)。
+ *
+ * 合成规则 = **最坏事实优先**,不是多数票、不是取最新一格:
+ *  ① 任一行 `unreachable` ⇒ `unreachable`(有一台**可证**打不通时说「够得着」,就是把坏消息折成健康);
+ *  ② 否则任一行 `unknown` **或任一行的格读不出**(`livenessUnreadable`,或入参自带一格形坏的 `liveness`)
+ *     ⇒ `unknown`。在**腿**这一层,`unknown` 的意思恰是
+ *     「有观察在场而答不了这个问题」,而一份读不懂的格**同样答不了** ⇒ 🔴 **读不出的格绝不作可达的证据**
+ *     (否则「一行读不出 + 一行 reachable」会合成一句「这条腿够得着」,而那行读不出的格完全可能本来写着
+ *     `unreachable`)。为什么答不了,由 {@link McpEngineLegHealth.unreadableCells} 分辨;
+ *  ③ 否则任一行 `reachable` ⇒ `reachable`(其余行缺席 = 没观察,不是反证);
+ *  ④ 否则 ⇒ `indeterminate`。
+ *
+ * 缺席答什么:`{reading:'indeterminate'}` —— 三种入参落这一档且**刻意同形**:段读不出(`undefined`)、
+ *   零申报(`[]`,这条腿一台服务器都没申报 ⇒ 没有服务器就没有观察)、每一行的活性格都缺席(老引擎 /
+ *   都没走到)。要分「一台都没申报」与「有服务器但没报活性」,问名册本身(行数)或在场判词,**不要**
+ *   让本口替那一问答话。
+ * 畸形答什么:整个入参不是数组 ⇒ `indeterminate`;行本身不是对象 ⇒ **那一行什么都不贡献**(连「有没有
+ *   这一格」都没读出来,不替它认领一格);行在而那一格形坏 ⇒ 按上面的 ② 算「读不出」。**永不抛**。
+ * 为什么不折:`indeterminate` 与三个词之间**没有**默认值可回落 —— 回落到 `reachable` 是谎、回落到
+ *   `unreachable` 是恐慌、回落到 `unknown` 是替引擎认领一次它没做过的观察。
+ */
+export function mcpLivenessRollupOf(rows) {
+    if (!Array.isArray(rows))
+        return { reading: 'indeterminate' };
+    let unreachable = false;
+    let unknown = false;
+    let reachable = false;
+    let unreadable = false;
+    // 按**词**分别记最新时刻:判词定下来之后只取那个词自己的(见 McpEngineLegHealth.observedAt 的理由)。
+    const newestByWord = {};
+    for (const row of rows) {
+        if (row === null || typeof row !== 'object')
+            continue;
+        if (row.livenessUnreadable === true)
+            unreadable = true;
+        const lv = row.liveness;
+        // `undefined` = 这一格不在 = 没有观察(JSON 上根本没有这一键):什么都不贡献,也不算「读不出」。
+        if (lv === undefined)
+            continue;
+        // 形再核一次(本口是公面,入参可能来自宿主自建管线而不是本包的读器):整格不是对象、词出闭集、
+        // 时刻非有限数 ⇒ 与 `livenessUnreadable` **同判**(算「在场而读不出」)。🔴 刻意不让它「什么都不贡献」:
+        // 那样一行读不懂的格会被另一行的 `reachable` 盖过去,合成一句「这条腿够得着」—— 正是本件要防的那一折。
+        if (lv === null || typeof lv !== 'object' || Array.isArray(lv)) {
+            unreadable = true;
+            continue;
+        }
+        const word = lv.state;
+        if (!isLivenessState(word)) {
+            unreadable = true;
+            continue;
+        }
+        if (typeof lv.observedAt !== 'number' || !Number.isFinite(lv.observedAt)) {
+            unreadable = true;
+            continue;
+        }
+        if (word === 'unreachable')
+            unreachable = true;
+        else if (word === 'unknown')
+            unknown = true;
+        else
+            reachable = true;
+        const seen = newestByWord[word];
+        if (seen === undefined || lv.observedAt > seen)
+            newestByWord[word] = lv.observedAt;
+    }
+    const reading = unreachable
+        ? 'unreachable'
+        : unknown || unreadable
+            ? 'unknown'
+            : reachable
+                ? 'reachable'
+                : 'indeterminate';
+    // 时刻与判词同源:`indeterminate` 没有时刻;`unknown` 若只由读不出的格决定,那个词一格可读观察都没有 ⇒ 同样没有时刻。
+    const at = reading === 'indeterminate' ? undefined : newestByWord[reading];
+    return {
+        reading,
+        ...(unreadable ? { unreadableCells: true } : {}),
+        ...(at !== undefined ? { observedAt: at } : {}),
+    };
+}
+/** 观察时刻的呈前写法:ISO(与本包其余时刻面同形)。🔴 **超出 `Date` 可表示区间的有限数原样印数字,
+ *  绝不抛、也绝不回落到一个编出来的时刻** —— 那一格是引擎给的读数,不是本包的时钟。 */
+const epochLabel = (ms) => Math.abs(ms) <= 8.64e15 ? new Date(ms).toISOString() : String(ms);
+/**
+ * 活性那一行措辞的**唯一铸点**(三端共用;别在各端的行装配里另写一遍)。
+ *
+ * 🔴 四句刻意逐字互异,且**没有一句**把 `indeterminate` 说成「都好着」或「一台都够不着」:
+ *  ① `reachable`     —— 上次交换完成了(这条腿的观察,带时刻);
+ *  ② `unreachable`   —— 至少一台**可证**够不着;
+ *  ③ `unknown`       —— 看过了,答不了(读不出的格同落这一档,附注多一句);
+ *  ③′ `unknown` 且**只**由读不出的格决定(判词无时刻 ∧ `unreadableCells`)—— 另一句:记录在场而**本端读不出**。
+ *     ③ 那句的主语是「回来的东西」(引擎看了、看不出来),③′ 的主语是本端的读器 —— 上游哪天加了第四个词,
+ *     老客户端落的正是 ③′;把它说成 ③ 等于替引擎认领一次它没做过的「看不出来」。
+ *  ④ `indeterminate` —— **没报**:这条腿上没有可用的观察记录,**不武断咎为引擎版本**(四源同形)。
+ * 🔴 句子里**不出现**服务器台数与「健康 / 正常」这类词:台数在名册上,而「健康」是本格答不了的问题
+ *    (它只答「还够得着吗」)。
+ * 🔴 句尾那个时刻**属于句子里那个判词**(见 {@link McpEngineLegHealth.observedAt}):说「至少有一台够不着」
+ *    时它是最新那次**够不着**的观察时刻,不是这条腿上任何一次观察的最大值 —— 否则一句旧故障的判词会跟上
+ *    一个属于别的词的新时刻,读起来像刚刚又确认了一次。时刻缺席时句子里就没有时刻,不编「刚刚」。
+ */
+export function mcpEngineLegHealthDetail(health) {
+    if (health === undefined)
+        return 'mcp liveness not reported (no liveness observation is available to this client)';
+    const unreadable = health.unreadableCells === true ? ' (one or more liveness records could not be read)' : '';
+    const at = health.observedAt !== undefined ? `, last observed at ${epochLabel(health.observedAt)}` : '';
+    switch (health.reading) {
+        case 'reachable':
+            return `mcp liveness: an exchange completed for every server that was observed on this leg${at}${unreadable}`;
+        case 'unreachable':
+            return `mcp liveness: at least one server was observed unreachable on this leg${at}${unreadable}`;
+        case 'unknown':
+            // ③′:时刻缺席 ∧ 有读不出的格 ⇒ 这个 unknown 一格可读观察都没有(时刻与判词同源,见 McpEngineLegHealth.observedAt)。
+            if (health.observedAt === undefined && health.unreadableCells === true) {
+                return 'mcp liveness: liveness records are present on this leg, but this client could not read them';
+            }
+            return `mcp liveness: observed on this leg, but what came back does not answer whether the server can be reached${at}${unreadable}`;
+        default:
+            return `mcp liveness not reported (no observation record on this leg's roster)${unreadable}`;
+    }
+}

package/dist/mcpPanel.d.ts

@@ -36,6 +36,7 @@
  */
 import type { AgentClient } from '@sema-agent/sdk';
 import { type WiringManifestMcpEntryView } from './adapter/downstream/eventToSdkMessage.js';
+import { type McpEngineLegHealth } from './mcpLiveness.js';
 /** 面板 `servers[]` 一行(sdk `McpServerStatus` 的窄读;开集键不透传,逐键挑)。 */
 export interface McpPanelServerView {
     /** 配置名(引擎产的标识,非用户内容)。 */
@@ -120,3 +121,19 @@ export declare function mcpPanelLastLegDetail(view: McpPanelView | undefined, op
  */
 export type McpEngineLegPresence = 'present' | 'absent' | 'unknown';
 export declare function mcpEngineLegPresence(view: McpPanelView | undefined): McpEngineLegPresence;
+/**
+ * CC-36(0.76.1):**这条腿的 MCP 活性判词**,只从本包的面板视图求(不自拼第二份判据、不发第二次请求)。
+ * 合成规则、四个读数与「缺席 ≠ unknown」那几句话的单一铸点在 {@link mcpLivenessRollupOf};本口只做一件事 ——
+ * 把面板上**带活性格的那一面**交给它。
+ *
+ * 🔴 **活性只在「最近那条腿的名册」这一面上**(`lastLegMcp.mcp[]`)。面板自己的 `servers[]` 半场**没有**
+ *    这一格:那一面是**部署缺省场景**此刻按需物化出来的台账,它的投影是逐键挑的白名单,今天不带活性位 ——
+ *    所以本口读不到它**不是漏读,是那一面今天没有这句话**。哪天它带上了,处置是同批补一格读数 + 判据,
+ *    而**不是**拿这一面的词去顶另一面(两面合法可不同,视图上从来没有、也不会有「一致/不一致」位)。
+ * 🔴 **判词说的是「那条腿」,不是「此刻」**:`observedAt` 属于那条腿的观察时刻,与面板的 `asOf` 不同源、
+ *    **不比**。壳渲这一行必须带腿的时刻,别渲成一个实时健康灯。
+ * 🔴 `view === undefined`(传输失败 / 体读不出 / 空 sessionId,三形同形)与「面板读到了但没有那条腿的
+ *    名册」**都答 `indeterminate`**:两者的共同点正是这句话本身 —— 本包**说不出**这条腿的活性。
+ *    要分辨「这次读没读到面板」问 {@link mcpPanelLastLegDetail} 的 `reachable` 位,**不要**让本口替它答。
+ */
+export declare function mcpEngineLegHealthOf(view: McpPanelView | undefined): McpEngineLegHealth;

package/dist/mcpPanel.js

@@ -1,6 +1,7 @@
 import { hostLog } from './host.js';
 import { projectMcpSection } from './adapter/downstream/eventToSdkMessage.js';
 import { capForDisplay } from './fleetTaskDesc.js';
+import { mcpLivenessRollupOf } from './mcpLiveness.js';
 /** `error` 上屏前的封长(server 侧 `slice(200)`,同值)。 */
 const MCP_PANEL_ERROR_MAX = 200;
 /** 名字类词形的封长(与本包其余 detail 铸点同值同理由)。 */
@@ -140,3 +141,23 @@ export function mcpEngineLegPresence(view) {
         return 'present';
     return 'absent';
 }
+/**
+ * CC-36(0.76.1):**这条腿的 MCP 活性判词**,只从本包的面板视图求(不自拼第二份判据、不发第二次请求)。
+ * 合成规则、四个读数与「缺席 ≠ unknown」那几句话的单一铸点在 {@link mcpLivenessRollupOf};本口只做一件事 ——
+ * 把面板上**带活性格的那一面**交给它。
+ *
+ * 🔴 **活性只在「最近那条腿的名册」这一面上**(`lastLegMcp.mcp[]`)。面板自己的 `servers[]` 半场**没有**
+ *    这一格:那一面是**部署缺省场景**此刻按需物化出来的台账,它的投影是逐键挑的白名单,今天不带活性位 ——
+ *    所以本口读不到它**不是漏读,是那一面今天没有这句话**。哪天它带上了,处置是同批补一格读数 + 判据,
+ *    而**不是**拿这一面的词去顶另一面(两面合法可不同,视图上从来没有、也不会有「一致/不一致」位)。
+ * 🔴 **判词说的是「那条腿」,不是「此刻」**:`observedAt` 属于那条腿的观察时刻,与面板的 `asOf` 不同源、
+ *    **不比**。壳渲这一行必须带腿的时刻,别渲成一个实时健康灯。
+ * 🔴 `view === undefined`(传输失败 / 体读不出 / 空 sessionId,三形同形)与「面板读到了但没有那条腿的
+ *    名册」**都答 `indeterminate`**:两者的共同点正是这句话本身 —— 本包**说不出**这条腿的活性。
+ *    要分辨「这次读没读到面板」问 {@link mcpPanelLastLegDetail} 的 `reachable` 位,**不要**让本口替它答。
+ */
+export function mcpEngineLegHealthOf(view) {
+    if (view === undefined)
+        return { reading: 'indeterminate' };
+    return mcpLivenessRollupOf(view.lastLegMcp?.mcp);
+}

package/dist/memoryComplianceCapability.d.ts

@@ -0,0 +1,73 @@
+/**
+ * memoryComplianceCapability — `GET /v1/capabilities.memoryCompliance` 的三端共用读面(0.76.1 CC-97a;
+ * 与 sql / writeProtection / webSearch.backend / executionLane / approvalsStreamLive /
+ * deviceExecutor.management 诸只兄弟同一套四态词汇,四口走共用工厂 {@link createEngineCapReader})。
+ *
+ * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
+ * 「**出处问询 / 抹除**两口(`GET /v1/memory/entries/:entryId/provenance` ·
+ * `POST /v1/memory/erase`,operator 车道)在这台引擎上在不在」。引擎侧的谓词是**两项合取**:
+ *  ① 合规面挂上了 —— 挂载期判后端自带引擎控制面归属,缺则整口不挂;
+ *  ② 这台部署的 operator 名单**非空** —— 空名单下两口对任何身份恒 403。
+ * ⚠️ 位为真**只**保证「门能过 + 面在场」,**不**保证这一次调用成功:控制面账本损坏是**运行期**事实
+ *    (typed 500),引擎刻意不把它编进部署级布尔。
+ * ⚠️ 与「治理携出 bundle」那一位**不同源**:两位的第一项查的是后端的**不同面**,一个部署可以有 bundle
+ *    复合面而没有控制面归属,反之亦然 —— 任一侧都不许拿来替另一侧作答(合成一位会对其中一半撒谎)。
+ * ⚠️ 与 `memoryOrigin`(外源标记人面三口)**同判据不同位**:两族今天查后端的同一个面,但它们是**两个
+ *    产品面**,一个部署可以只开其中一族。引擎刻意不合并,即使今天两位恒同值 ⇒ **本包也不合并**:
+ *    两只读器各持一张 per-baseUrl 表,一只收到读不懂的回体只删自己那一格
+ *    ({@link observedMemoryOrigin} 的读数一字不变)。
+ *
+ * ── 🔴 读法 ─────────────────────────────────────────────────────────────────────────────────
+ *  ① 引擎铸这一位时**恒在场**(一格布尔,不是条件在场)⇒ **键缺席 = 老引擎根本不报这一位** ⇒
+ *     `not_reported`(判不出)。折成 `false` 就是替引擎断言「这台没有合规面」。
+ *  ② `false` 是**明确的否** ⇒ `absent`。wire 上分不出「后端没有控制面归属」与「operator 名单为空」
+ *     两种成因(引擎的谓词是合取,回体只有一格布尔)⇒ 措辞**不推因由**。
+ *  ③ 严格布尔;`null` / 串 / `0` / `1` / 数组 / 对象一律畸形 ⇒ 删格 ⇒ `unobserved`,🔴 绝不折 `absent`
+ *     (读不懂与「明确的否」是两回事)。
+ *  ③b caps 回体本身不是对象(`null` / 数组 / 串 / 数)⇒ 畸形删格,**不是** `not_reported`(那一态只说「这是
+ *      一份 caps,但没有这一格」)。
+ *  ④ 判在场用 `hasOwn`:原型链上的同名键永远不会被序列化上 wire,把它读成在场就是凭空造一格读数。
+ *  ⑤ 「两口能不能用」的判据归包:{@link memoryComplianceVerbsAvailable} —— 只有 `present` 才 `'yes'`,
+ *     `absent` ⇒ `'no'`(明确的否),其余 ⇒ `'unknown'`(端按 501 试探,不预判)。
+ */
+/**
+ * 记忆治理面缺席时两族(合规两口 / 外源三口)共用的 501 码 —— **本包唯一铸点**,
+ * {@link memoryComplianceDoctorDetail} 与 {@link import('./memoryOriginCapability.js')} 的措辞表都取这一个常量,
+ * 两处不许各写一遍字面(码字面漂移时只有一处要改)。
+ */
+export declare const MEMORY_ENGINE_REQUIRED_CODE = "capability.memory_engine_required";
+/** 四态读数。`unobserved` 由读口在这一格空缺时铸,不由投影铸。 */
+export type MemoryComplianceReading = {
+    kind: 'unobserved';
+}
+/** 键缺席:老引擎不报这一位 ⇒ 判不出(**不是** `absent`)。 */
+ | {
+    kind: 'not_reported';
+}
+/** 位在场且为 `false`:这台部署上两口用不了(成因在 wire 上不可分)。 */
+ | {
+    kind: 'absent';
+}
+/** 位在场且为 `true`:门能过 + 面在场(不承诺这一次调用成功)。 */
+ | {
+    kind: 'present';
+};
+/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
+export declare function projectMemoryComplianceCapability(caps: unknown): MemoryComplianceReading | undefined;
+/** 宿主 caps probe 的读面 tee 落点(与诸只兄弟并列)。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
+export declare function noteEngineCapsForMemoryCompliance(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
+export declare function observedMemoryCompliance(baseUrl?: string | undefined): MemoryComplianceReading;
+/**
+ * 「出处问询 / 抹除两口能不能用」的判据单源(三态):只有引擎明说在场才 `'yes'`;明说不在 ⇒ `'no'`;
+ * 老引擎不报 / 从没观测 ⇒ `'unknown'`(端按 501 试探,不预判,也不预先藏掉入口)。
+ */
+export declare function memoryComplianceVerbsAvailable(reading: MemoryComplianceReading): 'yes' | 'no' | 'unknown';
+/** doctor 那一行的 detail 串,唯一措辞真源。🔴 两种「读不出」的句子都不许暗示「这台没有合规面」。 */
+export declare function memoryComplianceDoctorDetail(reading: MemoryComplianceReading): string;
+/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
+export declare function forgetMemoryComplianceReading(baseUrl: string | undefined): void;
+/** 测试钩子。 */
+export declare function __resetMemoryComplianceReadingsForTests(): void;

package/dist/memoryComplianceCapability.js

@@ -0,0 +1,109 @@
+/**
+ * memoryComplianceCapability — `GET /v1/capabilities.memoryCompliance` 的三端共用读面(0.76.1 CC-97a;
+ * 与 sql / writeProtection / webSearch.backend / executionLane / approvalsStreamLive /
+ * deviceExecutor.management 诸只兄弟同一套四态词汇,四口走共用工厂 {@link createEngineCapReader})。
+ *
+ * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
+ * 「**出处问询 / 抹除**两口(`GET /v1/memory/entries/:entryId/provenance` ·
+ * `POST /v1/memory/erase`,operator 车道)在这台引擎上在不在」。引擎侧的谓词是**两项合取**:
+ *  ① 合规面挂上了 —— 挂载期判后端自带引擎控制面归属,缺则整口不挂;
+ *  ② 这台部署的 operator 名单**非空** —— 空名单下两口对任何身份恒 403。
+ * ⚠️ 位为真**只**保证「门能过 + 面在场」,**不**保证这一次调用成功:控制面账本损坏是**运行期**事实
+ *    (typed 500),引擎刻意不把它编进部署级布尔。
+ * ⚠️ 与「治理携出 bundle」那一位**不同源**:两位的第一项查的是后端的**不同面**,一个部署可以有 bundle
+ *    复合面而没有控制面归属,反之亦然 —— 任一侧都不许拿来替另一侧作答(合成一位会对其中一半撒谎)。
+ * ⚠️ 与 `memoryOrigin`(外源标记人面三口)**同判据不同位**:两族今天查后端的同一个面,但它们是**两个
+ *    产品面**,一个部署可以只开其中一族。引擎刻意不合并,即使今天两位恒同值 ⇒ **本包也不合并**:
+ *    两只读器各持一张 per-baseUrl 表,一只收到读不懂的回体只删自己那一格
+ *    ({@link observedMemoryOrigin} 的读数一字不变)。
+ *
+ * ── 🔴 读法 ─────────────────────────────────────────────────────────────────────────────────
+ *  ① 引擎铸这一位时**恒在场**(一格布尔,不是条件在场)⇒ **键缺席 = 老引擎根本不报这一位** ⇒
+ *     `not_reported`(判不出)。折成 `false` 就是替引擎断言「这台没有合规面」。
+ *  ② `false` 是**明确的否** ⇒ `absent`。wire 上分不出「后端没有控制面归属」与「operator 名单为空」
+ *     两种成因(引擎的谓词是合取,回体只有一格布尔)⇒ 措辞**不推因由**。
+ *  ③ 严格布尔;`null` / 串 / `0` / `1` / 数组 / 对象一律畸形 ⇒ 删格 ⇒ `unobserved`,🔴 绝不折 `absent`
+ *     (读不懂与「明确的否」是两回事)。
+ *  ③b caps 回体本身不是对象(`null` / 数组 / 串 / 数)⇒ 畸形删格,**不是** `not_reported`(那一态只说「这是
+ *      一份 caps,但没有这一格」)。
+ *  ④ 判在场用 `hasOwn`:原型链上的同名键永远不会被序列化上 wire,把它读成在场就是凭空造一格读数。
+ *  ⑤ 「两口能不能用」的判据归包:{@link memoryComplianceVerbsAvailable} —— 只有 `present` 才 `'yes'`,
+ *     `absent` ⇒ `'no'`(明确的否),其余 ⇒ `'unknown'`(端按 501 试探,不预判)。
+ */
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+/**
+ * 记忆治理面缺席时两族(合规两口 / 外源三口)共用的 501 码 —— **本包唯一铸点**,
+ * {@link memoryComplianceDoctorDetail} 与 {@link import('./memoryOriginCapability.js')} 的措辞表都取这一个常量,
+ * 两处不许各写一遍字面(码字面漂移时只有一处要改)。
+ */
+export const MEMORY_ENGINE_REQUIRED_CODE = 'capability.memory_engine_required';
+/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
+export function projectMemoryComplianceCapability(caps) {
+    // 🔴 数组也是畸形:一个数组回体**不是**引擎对 caps 的回答,从它上面读出「老引擎不报这一位」是替引擎
+    //    编了一句它没说的话。`not_reported` 只留给**真的是 caps 对象、但这一格不在**那一形。
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    const c = caps;
+    if (!Object.hasOwn(c, 'memoryCompliance'))
+        return { kind: 'not_reported' };
+    // 🔴 只读一次:校验与分臂若各读一次,变化的 getter 能让校验读到布尔、分臂读到别的东西。
+    const v = c.memoryCompliance;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数
+ * {@link projectMemoryComplianceCapability}、doctor 措辞表与本位的判据助手。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面
+ * (尤其不连坐同判据的 `memoryOrigin`)。
+ */
+const reader = createEngineCapReader({
+    name: 'memoryCompliance',
+    project: projectMemoryComplianceCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+/** 宿主 caps probe 的读面 tee 落点(与诸只兄弟并列)。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
+export function noteEngineCapsForMemoryCompliance(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
+export function observedMemoryCompliance(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+/**
+ * 「出处问询 / 抹除两口能不能用」的判据单源(三态):只有引擎明说在场才 `'yes'`;明说不在 ⇒ `'no'`;
+ * 老引擎不报 / 从没观测 ⇒ `'unknown'`(端按 501 试探,不预判,也不预先藏掉入口)。
+ */
+export function memoryComplianceVerbsAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+/** doctor 那一行的 detail 串,唯一措辞真源。🔴 两种「读不出」的句子都不许暗示「这台没有合规面」。 */
+export function memoryComplianceDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'memory compliance face not observed — the engine reports it on /v1/capabilities (memoryCompliance); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+        case 'not_reported':
+            return 'memory compliance face not reported by this engine — only newer engines advertise it; this does not say whether the provenance and erasure endpoints exist, probe them directly';
+        case 'absent':
+            return `memory compliance face off on this deployment — the entry-provenance and erasure endpoints are unavailable (${MEMORY_ENGINE_REQUIRED_CODE}); the engine does not say which half is missing (a memory backend that does not own the engine control plane, or an empty operator roster), so do not guess`;
+        case 'present':
+            return 'memory compliance face on — the entry-provenance and erasure endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds (a damaged control-plane ledger is a runtime fact and arrives as a typed 500)';
+    }
+}
+/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
+export function forgetMemoryComplianceReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+/** 测试钩子。 */
+export function __resetMemoryComplianceReadingsForTests() {
+    reader.__resetForTests();
+}