@sema-agent/client-core 0.75.1 → 0.76.1

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

@@ -9,7 +9,7 @@
 import type { ModelUsage, SDKMessage } from '@sema-agent/agent-types';
 import type { EngineTurnUsage } from './adapter/downstream/turnUsageToModelUsage.js';
 import type { RunCostReconcile } from './adapter/downstream/terminalToSdkResult.js';
-import type { WiringManifestAutoMode, WiringManifestModelGate, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, ContextUsageSectionView } from './adapter/downstream/eventToSdkMessage.js';
+import type { WiringManifestAutoMode, WiringManifestModelGate, WiringManifestMcpEntryView, WiringManifestHookEntryView, WiringManifestLspSeamView, WiringManifestWriteProtectionView, WiringManifestAutoConsolidationView, WiringManifestReadDenyView, ContextUsageSectionView, PromptManifestSectionView, PromptManifestBlockView, PromptManifestToolView } from './adapter/downstream/eventToSdkMessage.js';
 import type { ToolRosterView, ToolRosterDeltaView } from './toolRoster.js';
 /**
  * `AbortSignal` 的结构型(B3 扩容,SEAM-GAP-4)。
@@ -153,9 +153,6 @@ export type ChromeEvent = {
     laneProof: LaneProof;
     taskId: string;
     registration: unknown;
-} | {
-    kind: 'tasks_expand';
-    laneProof: LaneProof;
 } | {
     kind: 'thinking_activity';
     laneProof: LaneProof;
@@ -545,7 +542,7 @@ export type ChromeEvent = {
  * ⚠️ **只有 live 腿有本帧**(server 7.69.0 亲读:durable/bg 腿把它喂给 rewind 锚而不入账本)
  * ⇒ replay/resume 上映射表是空的;那时正解是**不画分割线**,不是回退成「画在最后一条」。
  */
- | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent
+ | MessageCommittedChromeEvent | EngineNoticeChromeEvent | TextSegmentEndChromeEvent | ThinkingSegmentEndChromeEvent | ToolDisclosureChromeEvent | ToolProgressChromeEvent | ToolRosterDeltaChromeEvent | ContextUsageChromeEvent | CompactionOutcomeChromeEvent | PromptAssembledChromeEvent | WiringManifestChromeEvent | ResultTextDivergedChromeEvent
 /**
  * B-078 / L-208(0.65.0):design/172 流内审批协议的**两条帧**。修前它们在标准管线上落
  * `dropped('unsupported_arm')`,壳自己另接一份 ⇒ 只走包管线的宿主(desktop/web)拿不到
@@ -820,6 +817,57 @@ export interface CompactionOutcomeChromeEvent {
     reason?: string;
     eventId?: string;
 }
+/**
+ * CC-91(0.76.0;sdk `prompt_assembled` = `{type} & PromptManifest`):**这一次 prepare 的提示词装配清单** ——
+ * 系统提示词由哪些段 / 块组成、每段多大、这一腿挂了哪些工具。durable 腿的台账帧。
+ *
+ * 🔴 **没有 `tokens`,只有 `chars`** —— 上游真字节里就没有 token 位(core `prompt.assembled` 的 sections 是
+ *   `chars`,server 的白名单投影逐字段同形)。本包**刻意不铸** `tokens`:`chars / 系数` 是编的,不是真值。
+ *   要引擎自己的 token 估算去读 {@link ContextUsageChromeEvent} 的 `sections[].tokens`(引擎就是拿同一份
+ *   `chars` 估的)。🔴 **这条 join 只在两面的 `sections` 都在场时成立**(同一张 v2 段 id 词表):`context_usage`
+ *   那一面的段视图也是从同一份 manifest 段列投影的,manifest 没有段列时它同样缺席 ⇒ **v1-only 腿上没有这条 join**,
+ *   那时别拿 `blocks` 当 `sections` 的同名替代(见下,两张词表不同)。
+ * 🔴 **`chars` 与 `context_usage.usedTokens` 禁相减**(两个量纲不是一条账,且 chars ≠ tokens 更差一层);
+ *   `Σ chars` 也不构成「提示词占了窗口多少」——那句话只能由 `context_usage` 那一帧回答。
+ * 🔴 **一次任务可能多条**(cascade / verify 的每一 rung、resume 腿各自 re-prepare,server 逐条保序落账)⇒
+ *   本包每一条都交出去、**不去重**;要「当前组成」的宿主按**最后一条**取(与 `context_usage` 同律)。
+ * 🔴 `sections[].id` 与 `blocks[].id` 是**两张不同的词表**,不要混着分组:
+ *   · `sections[].id` = core pack 的**段** id(`core/<slot>.<name>` 命名空间,例 `core/role.base` / `core/harness.head`);
+ *   · `blocks[].id`   = v1 的**带标签块** id(`role.base` / `harness.context` / `env.context` / `memory.tail` …),
+ *     而且是**多对一**:多个段可以折进同一个块 ⇒ 块不是段的另一种写法,两面的行数与粒度都可以不同。
+ *   ⚠️ 两张词表**没有命名空间隔离的保证**(块 id 不带前缀、operator 声明的段 id 是自由串,理论上能撞同名)⇒
+ *     **按面各自分组**,别靠 id 形状判断自己在哪一面,更别拿块 id 去 join `context_usage` 的段面。
+ *   两张词表都是引擎**开集**原词:按成员渲染必须带 default 臂,认不得的原词照显示;**别**假定任何固定的分类闭集,
+ *   也别把某一类的缺席读成「那一类是零」(见下)。
+ * ⚠️ **这一面没有工具尺寸**:`tools[]` 只有名字,「工具 schema 占了多少」在这条 wire 上读不出来。
+ * 🔴 **缺席只说「本事件没有可读的这一面」,不是一句关于引擎的诊断**:上游整键缺席、发了空数组、逐行滤完只剩空
+ *   三种情形在本臂上**同形**(都折成键缺席)⇒ 看到 `sections` / `tools` / `blocks` 不在场,**不许**据此渲
+ *   「这个 provider 交的是不透明提示词」「这一腿没挂工具」之类的结论 —— 那需要别的独立证据。
+ * ⚠️ `sections[].slot` 是**语义槽**(`identity` / `security` / `harness` / `discovery` / `memory` …,开集),逐字沿用上游键名 ——
+ *   同一件事在 {@link ContextUsageChromeEvent} 的 `sections[].kind` 上叫 `kind`,两面各跟自己的上游,别指望同名。
+ * ⚠️ **skills 清单不在这一面**:core 已把它移出稳定前缀(观测口是 `steering_injected{source:"skills_listing"}`)⇒
+ *   清单里找不到 skills **不是**「skills 是 0」。
+ * ⚠️ `hash` / `contentHash` 等对账锚、以及帧上的 `constitution`(谁拥有宪法层)本包**不过境** —— 前者进程加盐跨重启不可比,后者今天零消费场景
+ *   (每个上公面的键都是一条要长期兑现的契约:additive 键晚加不破坏、早加删不掉)。要它们按表态制另提需求。
+ * 🔴 本臂**不是终态**、也不是一条转录消息(转录面零行);`laneProof.lane === 'subagent'` = 某只子代这一腿的清单
+ *   (server 今天的登记闸只登记 top-level run,所以这一支是防御性的,不是常态),别渲成主会话的。
+ */
+export interface PromptAssembledChromeEvent {
+    kind: 'prompt_assembled';
+    laneProof: LaneProof;
+    /** 整条提示词的渲染字符数。缺席 = 没报,**不是 0**。 */
+    totalChars?: number;
+    /** v1 面:带标签块(`role.base` / `harness.context` / …;与 `sections[].id` **不是同一张词表**,且段→块可多对一)。
+     *  缺席 = 本事件没有可读的块视图(上游缺席 / 空数组 / 逐行滤光三者同形),**不是**「没有块」。 */
+    blocks?: readonly PromptManifestBlockView[];
+    /** v2 面:编译 IR 的逐段视图。🔴 整键缺席 = **本事件没有可读的段视图**(上游整键缺席 / 空数组 / 逐行滤光同形),
+     *  **不是**各段为零、也**不能**反推「引擎没装配出段 IR」(那是上游缺席那一支的成因之一,本面分不出是哪一支)。 */
+    sections?: readonly PromptManifestSectionView[];
+    /** v2 面:这一腿挂载的工具名(MCP 类按名字前缀分组渲染靠它)。缺席 = 本事件没有可读的工具视图(三支同形),
+     *  **不是**「没挂工具」、更不是「工具占 0」(这一面本来就没有尺寸位)。 */
+    tools?: readonly PromptManifestToolView[];
+    eventId?: string;
+}
 export interface ToolDisclosureChromeEvent {
     kind: 'tool_disclosure';
     laneProof: LaneProof;

package/dist/seam.js

@@ -11,7 +11,6 @@ const CHROME_ARM_TABLE = {
     panel_task: { required: true, duty: 'publishEngineAgentPanelEvent(event) 原样转发' },
     bgshell_settle: { required: true, duty: '后台 shell 面板行落终态(含 outputPath)' },
     bgshell_register: { required: true, duty: '后台 shell 面板行建行 + 登记「句柄→宿主 run」' },
-    tasks_expand: { required: false, duty: '展开 ctrl+t 任务面板' },
     thinking_activity: { required: false, duty: '开/收活体 "∴ Thinking…" 行' },
     request_start: { required: false, duty: 'spinner 置 requesting 态' },
     stream_delta: { required: false, duty: '渲活体预览 + 推进 responseLength' },
@@ -93,6 +92,16 @@ const CHROME_ARM_TABLE = {
         duty: 'CC-89(0.75.0):一次压缩的非 compacted 结局(作废 / 失败等),给用户一条可见提示。`outcome` / `trigger` 是引擎开集原词,按成员渲染必带 default 臂、认不得照原词显示;' +
             '🔴 不是终态 —— 任务还在跑,别据它收 spinner;`laneProof.lane` 为 subagent = 子代的压缩结局,别渲成主会话的;成功压缩不走本臂(权威是转录的 compact_boundary)。不接 = 压缩失败对用户不可见。',
     },
+    prompt_assembled: {
+        required: false,
+        duty: 'CC-91(0.76.0):这一次 prepare 的提示词装配清单(每段 / 块多大、挂了哪些工具),/context 类面板的引擎侧真值来源。🔴 一次任务可能多条(cascade / verify / resume 各自 re-prepare)' +
+            ' ⇒ 包不去重,要「当前组成」的宿主按**最后一条**取(与 context_usage 同律);🔴 本面只有 chars **没有 tokens**(上游真字节无此位)—— 要 token 估算去读 context_usage.sections[].tokens,' +
+            '但那条 join **只在两面的 sections 都在场时成立**(同一张 v2 段 id 词表;v1-only 腿两面都没有段视图 ⇒ 没有这条 join);chars 与 usedTokens **禁相减**(量纲不是一条账,chars ≠ tokens 更差一层)、禁拿 chars/系数 自己编 token 数;' +
+            '🔴 sections[].id(core pack 段 id,core/<slot>.<name>)与 blocks[].id(v1 带标签块)是**两张不同词表**且段→块可多对一,别混着分组;两张都是引擎开集原词,按成员渲染必带 default 臂,别假定任何固定分类闭集;' +
+            '🔴 sections / blocks / tools 整键缺席只说「本事件没有可读的这一面」(上游缺席 / 空数组 / 逐行滤光三支同形)—— 不是各段为零、不许据此渲「provider 交的是不透明提示词」或「没挂工具」这类诊断;tools 只有名字没有尺寸;' +
+            'skills 清单不在本面(观测口是 steering_injected{source:"skills_listing"})⇒ 找不到 skills 不等于 skills 是 0;' +
+            '转录面零行,本臂不是终态;laneProof.lane 为 subagent = 子代那一腿的清单,别渲成主会话的。不接 = 同旧(端只能按本地镜像自己估)。',
+    },
     tool_disclosure: {
         required: false,
         duty: 'CC-08(0.71.0):这条腿的工具名字占位普查。`deferred` / `activated` 都是**全量快照,整只替换**(不做增量合并);' +

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