@sema-agent/client-core 0.76.0 → 0.76.2

package/dist/memoryOriginCapability.js

@@ -0,0 +1,102 @@
+/**
+ * memoryOriginCapability — `GET /v1/capabilities.memoryOrigin` 的三端共用读面(0.76.1 CC-97a;
+ * 与 `memoryCompliance` 及其余能力位兄弟同一套四态词汇,四口走共用工厂 {@link createEngineCapReader})。
+ *
+ * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
+ * 「**外源标记人面三口**(`GET /v1/memory/origin/external` · `GET /v1/memory/origin/clearances` ·
+ * `POST /v1/memory/origin/entries/:entryId/clear`,operator 车道)在这台引擎上在不在」。引擎侧的谓词
+ * 是**两项合取**:外源面在挂载期判出后端自带引擎控制面归属(缺则整口不挂),且 operator 名单**非空**
+ * (空名单下三口对任何身份恒 403)。
+ * ⚠️ 位为真**只**保证「门能过 + 面在场」,**不**保证这一次调用成功:清标账本损坏是**运行期**事实
+ *    (typed 500)。
+ * ⚠️ 与 `memoryCompliance` **同判据不同位**:两族今天查后端的同一个面,但它们是**两个产品面**
+ *    (合规问询 / 抹除 · 外源审计 / 清标),一个部署可以只想开其中一族 —— 引擎**刻意不合并**,
+ *    即使今天两位恒同值。🔴 本包跟着不合并:两只读器各持一张 per-baseUrl 表,喂其中一只畸形回体
+ *    只删它自己那一格,{@link import('./memoryComplianceCapability.js')} 的读数一字不变。把两位
+ *    折成一只读器 = 在未来的分家上让消费端读到假话。
+ * 🔴 位为真**也不**保证 `GET …/external` 的答案**完备**:引擎 v1 没有 scope 枚举读面,答案只覆盖
+ *    调用方点名的那些 scope ⇒ **空答绝不读作「本店干净」**。那是**发现链**的事,能力位表达不了它 ——
+ *    本包把这句话实现在导出条目面的判词口上(`scopeExternalOriginVerdict`),不是只写在注释里。
+ *
+ * ── 🔴 读法(与 `memoryCompliance` 逐条同律,但**各自一张表**)─────────────────────────────
+ *  ① 引擎铸这一位时**恒在场**(一格布尔)⇒ **键缺席 = 老引擎不报这一位** ⇒ `not_reported`(判不出),
+ *     绝不折成 `false`;
+ *  ② `false` 是**明确的否** ⇒ `absent`;成因(后端无控制面归属 / operator 名单为空)在 wire 上不可分,
+ *     措辞不推因由;
+ *  ③ 严格布尔;`null` / 串 / `0` / `1` / 数组 / 对象一律畸形 ⇒ 删格 ⇒ `unobserved`,🔴 绝不折 `absent`;
+ *  ③b caps 回体本身不是对象(`null` / 数组 / 串 / 数)⇒ 畸形删格,**不是** `not_reported`(那一态只说「这是
+ *      一份 caps,但没有这一格」)。
+ *  ④ 判在场用 `hasOwn`(原型键永不上 wire);
+ *  ⑤ 「三口能不能用」的判据归包:{@link memoryOriginVerbsAvailable}。
+ */
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+import { MEMORY_ENGINE_REQUIRED_CODE } from './memoryComplianceCapability.js';
+/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
+export function projectMemoryOriginCapability(caps) {
+    // 🔴 数组也是畸形:一个数组回体**不是**引擎对 caps 的回答,从它上面读出「老引擎不报这一位」是替引擎
+    //    编了一句它没说的话。`not_reported` 只留给**真的是 caps 对象、但这一格不在**那一形。
+    if (caps === null || typeof caps !== 'object' || Array.isArray(caps))
+        return undefined;
+    const c = caps;
+    if (!Object.hasOwn(c, 'memoryOrigin'))
+        return { kind: 'not_reported' };
+    // 🔴 只读一次(与兄弟同律):变化的 getter 不许让校验与分臂看到两个不同的值。
+    const v = c.memoryOrigin;
+    if (v === undefined)
+        return { kind: 'not_reported' };
+    if (typeof v !== 'boolean')
+        return undefined;
+    return v ? { kind: 'present' } : { kind: 'absent' };
+}
+/**
+ * 本格的 per-baseUrl 读账 + 四口 —— 走共用工厂;本文件只留投影函数、doctor 措辞表与本位判据助手。
+ * 🔴 这一张 Map 与 `memoryCompliance` 那一张**是两张**:同判据不同位,读账也不共用。
+ */
+const reader = createEngineCapReader({
+    name: 'memoryOrigin',
+    project: projectMemoryOriginCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+/** 宿主 caps probe 的读面 tee 落点。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
+export function noteEngineCapsForMemoryOrigin(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
+export function observedMemoryOrigin(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+/**
+ * 「外源标记人面三口能不能用」的判据单源(三态):只有引擎明说在场才 `'yes'`;明说不在 ⇒ `'no'`;
+ * 老引擎不报 / 从没观测 ⇒ `'unknown'`。
+ * 🔴 `'yes'` **只**说三口够得着,对外源清单的**完备性**一个字都没说(那一问归
+ * `scopeExternalOriginVerdict`)。
+ */
+export function memoryOriginVerbsAvailable(reading) {
+    if (reading.kind === 'present')
+        return 'yes';
+    if (reading.kind === 'absent')
+        return 'no';
+    return 'unknown';
+}
+/** doctor 那一行的 detail 串,唯一措辞真源。🔴 两种「读不出」的句子都不许暗示「这台没有外源面」。 */
+export function memoryOriginDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'external-origin face not observed — the engine reports it on /v1/capabilities (memoryOrigin); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+        case 'not_reported':
+            return 'external-origin face not reported by this engine — only newer engines advertise it; this does not say whether the origin listing and clearance endpoints exist, probe them directly';
+        case 'absent':
+            return `external-origin face off on this deployment — the origin listing and clearance 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 'external-origin face on — the origin listing and clearance endpoints are mounted and the operator roster is non-empty on this engine; this says the door opens, not that any one call succeeds, and it says nothing about the listing being complete (the engine has no scope-enumeration read face, so an answer covers only the scopes the caller named and an empty one must never be read as a clean store)';
+    }
+}
+/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
+export function forgetMemoryOriginReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+/** 测试钩子。 */
+export function __resetMemoryOriginReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/peerLaneCapability.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    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

@@ -0,0 +1,100 @@
+/**
+ * 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;
+    if (!('peerLane' in caps))
+        return { kind: 'not_reported' };
+    // 🔴 只读一次:在场判据与取值同一次读(变化的 getter 不会让两处判断看到两个不同的值)。
+    const v = caps.peerLane;
+    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 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';
+    if (reading.kind === 'absent' || reading.kind === 'not_reported')
+        return 'no';
+    return 'unknown';
+}
+/** doctor 那一行的 detail 串,唯一措辞真源。🔴 `unobserved` 那句不许暗示「有」或「没有」;`not_reported` 那句按上游成文语义说
+ *  「老 worker,没有跨会话车道」,并把「为什么缺席就是没有」(在场性即版本信号)说清,不让端把它读成第二种「判不出」。 */
+export function peerLaneDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'cross-session lane not observed — the engine reports it on /v1/capabilities (peerLane); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+        case 'not_reported':
+            return 'cross-session lane not reported by this engine — the engine predates the lane, so this deployment has no cross-session discovery or delivery (the key itself is the version signal; addressing another session by id is refused as unknown)';
+        case 'absent':
+            return 'no cross-session lane on this deployment — cross-session discovery and delivery (listing other sessions, addressing one by id) are unavailable';
+        case 'present':
+            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/permissionRulesWriteCapability.d.ts

@@ -0,0 +1,64 @@
+/**
+ * permissionRulesWriteCapability — `GET /v1/capabilities.permissionRulesWrite`(server ≥7.91.1;sdk 9.8.1
+ * 尚未声明该键 ⇒ 结构读)的三端共用读面(0.76.1 CC-102;与 sql / writeProtection / webSearch.backend /
+ * executionLane / approvalsStreamLive / deviceExecutor.management / peerLane 各只兄弟同一套四态词汇)。
+ *
+ * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
+ * 「收紧方向的单步规则写入口(把某条工具规则改成 deny/ask 的那一步)对**这一次调用方**够不够得着」。
+ * 这一位与「规则车道整体在不在」是上游同一个内部表达式的两次读——车道在场 ∧ 这次调用带得到可验明
+ * 的身份——所以两者永远同真同假;但它们**不是同一个位**,原因见下。
+ *
+ * ── 🔴 读法(两处上游源码逐字一致,别按撤销面那一位类推)─────────────────────────────────────
+ *  ① **键缺席 ⇒ 这份二进制比单步写口本身还老**:更早的引擎上,规则车道的其它几口已经在正常
+ *     应答(甚至已经报真),但这一条写口压根没有路由——键缺席就是这件事的信号,消费端据此**藏起**
+ *     这个写入口(真打了也能认:那类拒绝是裸的「方法不许」形,但不必打了才知道)。
+ *  ② **键在场 ⇒ 按这一位自己的值判「这次够不够得着」**:值为 `true`/`false` 直接就是答案,不需要
+ *     再去核对车道整体那一位。
+ *  ③ ⚠️ **与撤销面那一只存在性信号刻意不同源**:那一位是**部署级**的、与调用方身份无关的布尔(它的
+ *     值本身要当版本探针用);本位不是——本位的值同时编码了「车道在不在」与「这次调用带没带得到
+ *     身份」两件事,上游明确说这两位的读法不能互相套用。
+ *  ④ 位为真**不**保证任意一次写都成功:方向 / 规则文本 / scope 的合法性由每次调用自己的应答逐次
+ *     回答,这一位只回答「入口在不在、这次摸不摸得到」。
+ *
+ * ── 🔴 四态,不是两态([honest-absence-not-fabricated-zero])──────────────────────────────────
+ *   ① `unobserved`   —— 本进程一次 caps 响应都没观测到。
+ *   ② `not_reported` —— caps 观测到了,而回体上**没有**这个键 ⇒ 引擎比这条写口老(见①),藏入口。
+ *   ③ `absent`       —— 键在、值**明确是** `false`:这次调用够不着这条写口(车道没开,或这次调用
+ *      带不到可验明的身份)。**正面事实**,与 `not_reported`(判不出)是两件不同的事。
+ *   ④ `present`      —— 键在、值为 `true`:这次调用摸得到这条写口。
+ * 值既不是 `true` 也不是 `false` ⇒ 畸形 ⇒ 删格(⇒ `unobserved`)。
+ * 🔴 三种「没有」(`unobserved` / `not_reported` / `absent`)**不许互折**。
+ */
+/** 四态读数。`unobserved` 由读口在这一格空缺时铸,不由投影铸。 */
+export type PermissionRulesWriteReading = {
+    kind: 'unobserved';
+} | {
+    kind: 'not_reported';
+} | {
+    kind: 'absent';
+} | {
+    kind: 'present';
+};
+/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
+export declare function projectPermissionRulesWriteCapability(caps: unknown): PermissionRulesWriteReading | undefined;
+/** 宿主 caps probe 的读面 tee 落点。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
+export declare function noteEngineCapsForPermissionRulesWrite(baseUrl: string, caps: unknown, opts?: {
+    generation?: number;
+}): void;
+/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
+export declare function observedPermissionRulesWrite(baseUrl?: string | undefined): PermissionRulesWriteReading;
+/**
+ * 「这次调用摸不摸得到单步写入口」的判据单源(布尔):只有 `present` 才 `true`;其余三态
+ * (`absent` / `not_reported` / `unobserved`)一律 `false`——藏入口的默认方向是**保守**的,
+ * 判不出与明确没有对「要不要露出这个写按钮」是同一个答案。
+ *
+ * 🔴 本函数是本位**唯一**的派生点:{@link "./hitl/persistedRulesWire.js".persistedRulesWriteAvailable}
+ * 只调用它,不再合取别的位、也不再另读一遍 caps——同一件事只许有一个判官。
+ */
+export declare function permissionRulesWriteAvailable(reading: PermissionRulesWriteReading): boolean;
+/** doctor 那一行的 detail 串,唯一措辞真源。🔴 两种「读不出」都不许暗示「够得着」或「够不着」。 */
+export declare function permissionRulesWriteDoctorDetail(reading: PermissionRulesWriteReading): string;
+/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
+export declare function forgetPermissionRulesWriteReading(baseUrl: string | undefined): void;
+/** 测试钩子。 */
+export declare function __resetPermissionRulesWriteReadingsForTests(): void;

package/dist/permissionRulesWriteCapability.js

@@ -0,0 +1,98 @@
+/**
+ * permissionRulesWriteCapability — `GET /v1/capabilities.permissionRulesWrite`(server ≥7.91.1;sdk 9.8.1
+ * 尚未声明该键 ⇒ 结构读)的三端共用读面(0.76.1 CC-102;与 sql / writeProtection / webSearch.backend /
+ * executionLane / approvalsStreamLive / deviceExecutor.management / peerLane 各只兄弟同一套四态词汇)。
+ *
+ * ── 这一位答的是哪一个问题 ────────────────────────────────────────────────────────────────
+ * 「收紧方向的单步规则写入口(把某条工具规则改成 deny/ask 的那一步)对**这一次调用方**够不够得着」。
+ * 这一位与「规则车道整体在不在」是上游同一个内部表达式的两次读——车道在场 ∧ 这次调用带得到可验明
+ * 的身份——所以两者永远同真同假;但它们**不是同一个位**,原因见下。
+ *
+ * ── 🔴 读法(两处上游源码逐字一致,别按撤销面那一位类推)─────────────────────────────────────
+ *  ① **键缺席 ⇒ 这份二进制比单步写口本身还老**:更早的引擎上,规则车道的其它几口已经在正常
+ *     应答(甚至已经报真),但这一条写口压根没有路由——键缺席就是这件事的信号,消费端据此**藏起**
+ *     这个写入口(真打了也能认:那类拒绝是裸的「方法不许」形,但不必打了才知道)。
+ *  ② **键在场 ⇒ 按这一位自己的值判「这次够不够得着」**:值为 `true`/`false` 直接就是答案,不需要
+ *     再去核对车道整体那一位。
+ *  ③ ⚠️ **与撤销面那一只存在性信号刻意不同源**:那一位是**部署级**的、与调用方身份无关的布尔(它的
+ *     值本身要当版本探针用);本位不是——本位的值同时编码了「车道在不在」与「这次调用带没带得到
+ *     身份」两件事,上游明确说这两位的读法不能互相套用。
+ *  ④ 位为真**不**保证任意一次写都成功:方向 / 规则文本 / scope 的合法性由每次调用自己的应答逐次
+ *     回答,这一位只回答「入口在不在、这次摸不摸得到」。
+ *
+ * ── 🔴 四态,不是两态([honest-absence-not-fabricated-zero])──────────────────────────────────
+ *   ① `unobserved`   —— 本进程一次 caps 响应都没观测到。
+ *   ② `not_reported` —— caps 观测到了,而回体上**没有**这个键 ⇒ 引擎比这条写口老(见①),藏入口。
+ *   ③ `absent`       —— 键在、值**明确是** `false`:这次调用够不着这条写口(车道没开,或这次调用
+ *      带不到可验明的身份)。**正面事实**,与 `not_reported`(判不出)是两件不同的事。
+ *   ④ `present`      —— 键在、值为 `true`:这次调用摸得到这条写口。
+ * 值既不是 `true` 也不是 `false` ⇒ 畸形 ⇒ 删格(⇒ `unobserved`)。
+ * 🔴 三种「没有」(`unobserved` / `not_reported` / `absent`)**不许互折**。
+ */
+import { engineWireTarget } from './engineWireTarget.js';
+import { createEngineCapReader } from './engineCapReader.js';
+/** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
+export function projectPermissionRulesWriteCapability(caps) {
+    if (caps === null || typeof caps !== 'object')
+        return undefined;
+    if (!('permissionRulesWrite' in caps))
+        return { kind: 'not_reported' };
+    // 🔴 只读一次:在场判据与取值同一次读。
+    const v = caps.permissionRulesWrite;
+    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 projectPermissionRulesWriteCapability}、doctor 措辞表,以及本位自己的判据助手。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'permissionRulesWrite',
+    project: projectPermissionRulesWriteCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
+/** 宿主 caps probe 的读面 tee 落点。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
+export function noteEngineCapsForPermissionRulesWrite(baseUrl, caps, opts) {
+    reader.note(baseUrl, caps, opts);
+}
+/** 本进程观测到的读数;这一格空缺 ⇒ `{kind:'unobserved'}`。 */
+export function observedPermissionRulesWrite(baseUrl = engineWireTarget()?.baseUrl) {
+    return reader.observed(baseUrl);
+}
+/**
+ * 「这次调用摸不摸得到单步写入口」的判据单源(布尔):只有 `present` 才 `true`;其余三态
+ * (`absent` / `not_reported` / `unobserved`)一律 `false`——藏入口的默认方向是**保守**的,
+ * 判不出与明确没有对「要不要露出这个写按钮」是同一个答案。
+ *
+ * 🔴 本函数是本位**唯一**的派生点:{@link "./hitl/persistedRulesWire.js".persistedRulesWriteAvailable}
+ * 只调用它,不再合取别的位、也不再另读一遍 caps——同一件事只许有一个判官。
+ */
+export function permissionRulesWriteAvailable(reading) {
+    return reading.kind === 'present';
+}
+/** doctor 那一行的 detail 串,唯一措辞真源。🔴 两种「读不出」都不许暗示「够得着」或「够不着」。 */
+export function permissionRulesWriteDoctorDetail(reading) {
+    switch (reading.kind) {
+        case 'unobserved':
+            return 'permission-rule write entry not observed — the engine reports it on /v1/capabilities (permissionRulesWrite); this process has no usable capabilities reading cached for it (none received, or the last one was unreadable)';
+        case 'not_reported':
+            return 'permission-rule write entry not reported by this engine — this binary predates the entry itself; hide it rather than calling it';
+        case 'absent':
+            return 'permission-rule write entry unreachable for this call — either the rules lane is not open on this deployment, or this call cannot bring a verifiable identity';
+        case 'present':
+            return 'permission-rule write entry reachable for this call — a per-call attempt still answers for itself whether the direction, text, and scope are accepted';
+    }
+}
+/** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
+export function forgetPermissionRulesWriteReading(baseUrl) {
+    reader.forget(baseUrl);
+}
+/** 测试钩子。 */
+export function __resetPermissionRulesWriteReadingsForTests() {
+    reader.__resetForTests();
+}

package/dist/selfOrchestrationDenial.js

@@ -160,8 +160,13 @@ export function stripSelfOrchestrationIntent(req) {
     }
     return out;
 }
-const ABSENT = { kind: 'absent' };
-const ACCESSOR = { kind: 'accessor' };
+// 🔴 0.76.1 族扫收编(与主车道证明那半场同族、**处置刻意不同**):这两只也是「模块级对象当缺省值
+//    往外交」的形,但它们的暴露面完全不同 —— `ownRead` 是本文件私有、结果只被读 `kind` / `value`、
+//    一只都不出模块,所以「两个消费者按身份把两件事认成一件」这一半在这里不成立;剩下的唯一风险是
+//    本模块将来有人往上写,而那正是冻结接得住的。⇒ 这里冻结代价为零、判别力刚好;主车道那半场是
+//    交给宿主的公开输出面,只能靠**逐次新建**解别名(见 `adapt/ids.ts` 的 `mainLane`)。
+const ABSENT = Object.freeze({ kind: 'absent' });
+const ACCESSOR = Object.freeze({ kind: 'accessor' });
 /**
  * 从一个**不可信**对象上取一位:只认**自有数据描述符**的 `value`。
  *

package/dist/sqlEngineCapability.js

@@ -43,7 +43,7 @@
  */
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { createEngineCapReader } from './engineCapReader.js';
 /**
  * caps 回体 → 本格读数;**畸形一律 `undefined`**(= 这一格不写 ⇒ 读口答 `unobserved`)。
  *
@@ -80,7 +80,16 @@ export function projectSqlEngineCapability(caps) {
         return undefined;
     return { kind: 'present', view: { engine, isolation, txnMode } };
 }
-const readingByBase = new Map();
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 各只能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数 {@link projectSqlEngineCapability}、doctor 措辞表,以及本位自己的判据助手(如有)。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'sql',
+    project: projectSqlEngineCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
 /**
  * 宿主 caps probe 的**读面 tee** 落点(壳侧与 mcpGate / sessionBackground / projectContext /
  * crashConverged / workflowsGate 五条并列)。绝不 throw —— 读面腿不许反噬 caps 探测链。
@@ -103,32 +112,7 @@ const readingByBase = new Map();
  *    有任何东西变坏。🔴 **tee 自己抓号是假判据**(陈旧那一发在这里读到的是新代号,永远像当代的)。
  */
 export function noteEngineCapsForSqlEngine(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 = projectSqlEngineCapability(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);
 }
 /**
  * 本进程观测到的 SQL 姿态;这一格空缺 ⇒ `{kind:'unobserved'}`(**绝不**折成 `none`)。
@@ -138,9 +122,7 @@ export function noteEngineCapsForSqlEngine(baseUrl, caps, opts) {
  * ⇒ Node 壳上行为一字节不变,浏览器/桌面宿主则由 `installEngineWireTarget()` 显式装)。
  */
 export function observedSqlEngine(baseUrl = engineWireTarget()?.baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return { kind: 'unobserved' };
-    return readingByBase.get(baseUrl) ?? { kind: 'unobserved' };
+    return reader.observed(baseUrl);
 }
 /** 单行 UNTRUSTED 座的展示上限(UTF-16 单元;与壳侧那份同值)。 */
 const SQL_DETAIL_MAX = 40;
@@ -210,11 +192,9 @@ export function sqlEngineDoctorDetail(reading) {
  * 空串 ⇒ no-op;绝不 throw(它跑在引擎温切路径上)。
  */
 export function forgetSqlEngineReading(baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    readingByBase.delete(baseUrl);
+    reader.forget(baseUrl);
 }
 /** 测试钩子。 */
 export function __resetSqlEngineReadingsForTests() {
-    readingByBase.clear();
+    reader.__resetForTests();
 }

package/dist/webSearchBackendCapability.js

@@ -38,7 +38,7 @@
  */
 import { capForDisplay } from './fleetTaskDesc.js';
 import { engineWireTarget } from './engineWireTarget.js';
-import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { createEngineCapReader } from './engineCapReader.js';
 /** `backend: "none"` —— 唯一带独立语义的词(见文件头);其余词按开集读。 */
 export const WEB_SEARCH_BACKEND_NONE = 'none';
 /**
@@ -66,7 +66,16 @@ export function projectWebSearchBackendCapability(caps) {
         return { kind: 'none' };
     return { kind: 'present', view: { backend } };
 }
-const readingByBase = new Map();
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 各只能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数 {@link projectWebSearchBackendCapability}、doctor 措辞表,以及本位自己的判据助手(如有)。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'webSearch.backend',
+    project: projectWebSearchBackendCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
 /**
  * 宿主 caps probe 的**读面 tee** 落点(与 `noteEngineCapsForSqlEngine` / `noteEngineCapsForWriteProtection`
  * 并列;宿主在同一处按序调三只)。绝不 throw —— 读面腿不许反噬 caps 探测链。
@@ -77,38 +86,11 @@ const readingByBase = new Map();
  *    那一刻 `engineCapsGeneration(baseUrl)` 抓号、在这里原样交回,陈旧那一发整只丢掉;不传 ⇒ 照写。
  */
 export function noteEngineCapsForWebSearchBackend(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 = projectWebSearchBackendCapability(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'}`(**绝不**折成 `none`)。 */
 export function observedWebSearchBackend(baseUrl = engineWireTarget()?.baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return { kind: 'unobserved' };
-    return readingByBase.get(baseUrl) ?? { kind: 'unobserved' };
+    return reader.observed(baseUrl);
 }
 /** provider 词的展示上限(UTF-16 单元;与两只兄弟同值同理由 —— 开集词按 UNTRUSTED-for-display 处置)。 */
 const WS_DETAIL_MAX = 40;
@@ -144,11 +126,9 @@ export function webSearchBackendDoctorDetail(reading) {
  * 处置是**清成未观测**,不是留旧值也不是铸一个 `none`。空串 ⇒ no-op;绝不 throw。
  */
 export function forgetWebSearchBackendReading(baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    readingByBase.delete(baseUrl);
+    reader.forget(baseUrl);
 }
 /** 测试钩子。 */
 export function __resetWebSearchBackendReadingsForTests() {
-    readingByBase.clear();
+    reader.__resetForTests();
 }