@sema-agent/client-core 0.75.1 → 0.76.1

package/dist/deviceExecutorManagementCapability.js

@@ -17,7 +17,7 @@
  *     present ∧ false 与 `lane_absent` ⇒ `'no'`(明确的否);其余 ⇒ `'unknown'`(别当 no,也别当 yes)。
  */
 import { engineWireTarget } from './engineWireTarget.js';
-import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+import { createEngineCapReader } from './engineCapReader.js';
 /** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写 ⇒ 读口答 `unobserved`)。 */
 export function projectDeviceExecutorManagementCapability(caps) {
     if (caps === null || typeof caps !== 'object')
@@ -45,41 +45,23 @@ export function projectDeviceExecutorManagementCapability(caps) {
         return undefined;
     return { kind: 'present', management: mgmt };
 }
-const readingByBase = new Map();
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 各只能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数 {@link projectDeviceExecutorManagementCapability}、doctor 措辞表,以及本位自己的判据助手(如有)。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'deviceExecutor.management',
+    project: projectDeviceExecutorManagementCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
 /** 宿主 caps probe 的读面 tee 落点(与五只兄弟并列)。绝不 throw;畸形 ⇒ 删格;`opts.generation` 关掉旧探测覆盖新读数的竞态。 */
 export function noteEngineCapsForDeviceExecutorManagement(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 = projectDeviceExecutorManagementCapability(caps);
-    }
-    catch {
-        // 🔴 抛 getter / Proxy 的回体 = 畸形(异源对抗复审 R1):与「投影答 undefined」同一处置 —— 删格,不许留着上一台的 yes / no。
-        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'}`。 */
 export function observedDeviceExecutorManagement(baseUrl = engineWireTarget()?.baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return { kind: 'unobserved' };
-    return readingByBase.get(baseUrl) ?? { kind: 'unobserved' };
+    return reader.observed(baseUrl);
 }
 /**
  * 「`/v1/devices/*` 管理动词能不能用」的判据单源(三态):只有引擎明说在场(present ∧ true)才 `'yes'`;
@@ -111,11 +93,9 @@ export function deviceExecutorManagementDoctorDetail(reading) {
 }
 /** 换代失效口(引擎温切成功后调):清成未观测。空串 ⇒ no-op;绝不 throw。 */
 export function forgetDeviceExecutorManagementReading(baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    readingByBase.delete(baseUrl);
+    reader.forget(baseUrl);
 }
 /** 测试钩子。 */
 export function __resetDeviceExecutorManagementReadingsForTests() {
-    readingByBase.clear();
+    reader.__resetForTests();
 }

package/dist/engineAgentPanelStore.js

@@ -549,7 +549,19 @@ export function publishEngineAgentPanelEvent(ev) {
                 //     换成「每行各自补一条 end」则要在这里替主路决定消费端键,会吞掉原 wire 键那一行自己的终态。身份对不上就
                 //     **一帧都不摘**是本包扣留表的既有律(见 `hitl/gateLedger.ts` 的「判不出 ⇒ 一条都不摘」)。代价 = 这种形下
                 //     那几条行的用量仍缺席(与本件修之前同),换来的是绝不凭空多长一行、绝不替谁编一条终态。
-                //     真字节里两个行尾段共享一个转录锚不成立(转录锚按代际唯一),所以这一支是防御面,不是常态路径。
+                //     🔴 **理由更正(0.76.0;外部验收方 [7764] 逐条回一级源码亲核后证伪了本句旧版)**:旧注释写的是「两个行尾段共享一个
+                //     **转录锚**不成立(转录锚按代际唯一),所以这一支是防御面」—— 那句话**只论证了转录钥匙那条腿**,而 `heldMatches`
+                //     是**转录锚腿 ∪ 委派卡腿**的并集,两条腿异质:
+                //       · 委派卡那条腿的前提**为假** —— workflow 扇出下一张卡整跑冻结成常量、尾段逐 callKey 不同,**最多 50 个**
+                //         尾段共享同一张卡且可同时在飞(上游坐标:core `workflow.ts` 的 `bceParentToolCall` 与 `waIdOf(callKey)`;
+                //         默认 `maxAgents` 50)。这正是本包 lane 判据里 `workflow-card-parent` 那一支的上游本体。
+                //         🔴 上游当事方 09-20 直讯确认了这一形:**一次扇出的全部子代共享同一张 `parentToolCallId`**(那次 workflow
+                //         工具调用自己的卡),逐子代能区分的键**只有 `taskId`**(`wa*` 形)—— 也就是说委派卡这条腿在扇出下**天然多对一**。
+                //       · 更要紧:**凑够 ≥2 根本不需要两行共享任何一个键** —— 一行只经转录锚命中、另一行只经委派卡命中即可。
+                //     ⇒ 今天这一支之所以罕见,**靠的不是上面那条律**,而是「workflow 子代的 tick 被 lane 门拦掉 ⇒ 委派卡那条腿的
+                //     `publishedWireByParent` 没有写入」这条**更脆**的保证 —— 它历史上塌过(上游投影白名单曾把 `workflowRunId` 整个剥掉)。
+                //     **失效条件**:workflow 子代的 tick 一旦上屏(白名单变宽 / lane 门放行),这一支立刻变成常态路径。
+                //     所以本分支**不是**「理论上才会走到的防御面」,它是**有真上游机制**的一支,只是今天被一条脆保证挡着。
                 // 🔴 无论放没放,**主路照走**:原 wire 键那一行(它可能早就上过屏)自己的 end 绝不能被这条腿吞掉。
                 const releasable = [];
                 for (const tail of heldMatches) {

package/dist/engineCapReader.d.ts

@@ -0,0 +1,77 @@
+/**
+ * engineCapReader — 能力位窄读器的**四口共用实现**(0.76.1 CC-75;包内叶,不出 barrel、不上公面)。
+ * 🔴 两个 interface 刻意**不导出**:消费方(各只读器)只需要 `createEngineCapReader`,型由推断得出 ⇒
+ *    不给包内再添一圈可依赖的型面,也不让边界 `unknown` 在导出签名上多占两格。
+ *
+ * ── 它收的是哪四份 ────────────────────────────────────────────────────────────────────────────
+ * `GET /v1/capabilities` 的每一个窄读器(`sqlEngineCapability` / `writeProtectionCapability` /
+ * `webSearchBackendCapability` / `executionLaneCapability` / `approvalsStreamLiveCapability` /
+ * `deviceExecutorManagementCapability`)此前各自持有**逐字相同**的四份代码(此后新增的读器直接建在本件上):
+ *   ① `note(baseUrl, caps, opts?)` 的 **tee**(宿主 caps 探测链上的读面落点);
+ *   ② `observed(baseUrl?)` 的 per-baseUrl 读口(空缺 ⇒ 未观测);
+ *   ③ `forget(baseUrl)` 的换代失效口;
+ *   ④ `__resetForTests()` 测试钩。
+ * 各只真正**互不相同**的只有两件:**投影函数**(键路径 / 在场判据 / 值形校验)与 **doctor 措辞表** ——
+ * 那两件留在各自文件里。
+ * 🔴 **刻意不做声明式键路径表**:`sql` 的三座、`writeProtection` 的三位、`deviceExecutor` 的对象臂 +
+ *    `why` 判别子各有自己的合形判据(开集串 / 非负有限整数 / 严格布尔 / `null` 是合法值还是畸形),
+ *    把它们压进一张通用描述表 = 给同一份判据立第二个判官(而投影函数本身**就是**那一份判据,不是它的抄件)。
+ *
+ * ── 🔴 tee 的五条纪律(逐条在 {@link createEngineCapReader} 里实现,各只共享同一份)──────────────
+ *   ① 空 / 非串 `baseUrl` ⇒ no-op(读账的键就是 baseUrl,没有键就没有格);
+ *   ② 代际只在**入口快照一次**(`opts` 是调用方的对象,回体上的 getter 能在投影中途改它);
+ *   ③ 投影抛出(getter / Proxy 的回体)⇒ 与「投影答 `undefined`」**同一处置**,当畸形;
+ *   ④ 投影**之后再核一次代际**(投影执行的是不可信 getter,它能在中途让这一格换代);
+ *   ⑤ 畸形 ⇒ **删格**,不留上一台引擎的旧读数。
+ * 并且 **绝不 throw** —— 读面腿不许反噬 caps 探测链。
+ * ⚠️ **不传 `opts.generation` = 与本件到货之前逐字节同行为**(照写):那是 additive 供给,不是强制门。
+ *    本件**不**替调用方补一个「自己抓号」的代际(tee 自己抓号是假判据 —— 陈旧那一发在这里读到的
+ *    永远是新代号),也不因为收编而把缺供给那一档悄悄变严。
+ */
+/**
+ * 一只能力位读器的**全部差异**(其余一律共用)。
+ *
+ * 🔴 `makeUnobserved` 是**工厂**而不是一个共享常量(异源对抗复审采纳,真病):各只读器的读数是**可变对象**
+ *    (`{ kind: 'unobserved' }`),共享同一份会在两个方向上出事 —— ① 一个消费端就地改了拿到的读数
+ *    (`r.kind = …`),另一个 baseUrl、另一个会话下次读到的「未观测」就已经不是未观测了,而 `forget` /
+ *    `__resetForTests` 只清 Map、救不回那份被改坏的常量;② 即使无人改值,「两次未命中的返回值**引用相等**」
+ *    本身就是收编**新增**的别名关系(六只原码每次未命中都新建一个对象)。冻结共享对象**不算**等价替代:
+ *    那把一次静默串味换成了一次抛错,仍与原行为不同。
+ * 🔴 `R` 不绑任何词表:`executionLane` / `approvalsStreamLive` 只有三种 `kind`,`sql` / `writeProtection` /
+ *    `webSearchBackend` 四种,`deviceExecutor.management` 四种带判别子 —— 工厂只管缓存 / 代际 / tee / forget,
+ *    读数的域由各读器自己的型说,本件一个词都不认识。
+ */
+interface EngineCapReaderSpec<R> {
+    /** 这只读器守的能力位名(阅读与诊断锚;**不参与任何判定** —— 读账按 baseUrl 键,每只各持一份闭包 Map)。 */
+    name: string;
+    /** caps 回体 → 本格读数;畸形一律 `undefined`(= 这一格不写)。抛出与 `undefined` 同一处置。 */
+    project: (caps: unknown) => R | undefined;
+    /** 这一格空缺时铸的读数;**每次**未命中都调一次(见上)。 */
+    makeUnobserved: () => R;
+}
+/** 一只能力位读器的四口(名字由各读器的公面导出逐字包装,型与行为逐字不变)。 */
+interface EngineCapReader<R> {
+    /** 宿主 caps probe 的读面 tee 落点;绝不 throw。 */
+    note(baseUrl: string, caps: unknown, opts?: {
+        generation?: number;
+    }): void;
+    /**
+     * 本进程观测到的读数;空 / 非串 `baseUrl` ⇒ `makeUnobserved()`。
+     *
+     * 🔴 **缺省读锚不在这里**:`engineWireTarget()?.baseUrl` 写在**每只读器公面函数的默认参数**上
+     *    (d.ts 上它显形为 `observedSqlEngine(baseUrl?: string | undefined)` —— 默认值表达式不进声明面,
+     *    但**求值时机**是对外行为的一部分:零参与显式 `undefined` 都在**调用那一刻**取读锚)。两处都写默认值 ⇒
+     *    没装读锚时 `engineWireTarget()` 会被调**两次**;所以这一口收**必填可空**参数,默认值留在各读器。
+     */
+    observed(baseUrl: string | undefined): R;
+    /** 换代失效口:清成未观测。空 / 非串 ⇒ no-op;绝不 throw。 */
+    forget(baseUrl: string | undefined): void;
+    /** 测试钩:只清**本只**读器的那张 Map —— 不动装好的读锚、不动 caps 缓存的代际号、不动别只读器的表。 */
+    __resetForTests(): void;
+}
+/**
+ * 建一只能力位读器。per-baseUrl 读账 = **本次调用闭包里**的一张 Map ⇒ 一只读器一张表,
+ * 一只读器收到畸形回体删自己的格,绝不连坐另一只(这是六只原码分表的理由,收编后逐字保留)。
+ */
+export declare function createEngineCapReader<R>(spec: EngineCapReaderSpec<R>): EngineCapReader<R>;
+export {};

package/dist/engineCapReader.js

@@ -0,0 +1,87 @@
+/**
+ * engineCapReader — 能力位窄读器的**四口共用实现**(0.76.1 CC-75;包内叶,不出 barrel、不上公面)。
+ * 🔴 两个 interface 刻意**不导出**:消费方(各只读器)只需要 `createEngineCapReader`,型由推断得出 ⇒
+ *    不给包内再添一圈可依赖的型面,也不让边界 `unknown` 在导出签名上多占两格。
+ *
+ * ── 它收的是哪四份 ────────────────────────────────────────────────────────────────────────────
+ * `GET /v1/capabilities` 的每一个窄读器(`sqlEngineCapability` / `writeProtectionCapability` /
+ * `webSearchBackendCapability` / `executionLaneCapability` / `approvalsStreamLiveCapability` /
+ * `deviceExecutorManagementCapability`)此前各自持有**逐字相同**的四份代码(此后新增的读器直接建在本件上):
+ *   ① `note(baseUrl, caps, opts?)` 的 **tee**(宿主 caps 探测链上的读面落点);
+ *   ② `observed(baseUrl?)` 的 per-baseUrl 读口(空缺 ⇒ 未观测);
+ *   ③ `forget(baseUrl)` 的换代失效口;
+ *   ④ `__resetForTests()` 测试钩。
+ * 各只真正**互不相同**的只有两件:**投影函数**(键路径 / 在场判据 / 值形校验)与 **doctor 措辞表** ——
+ * 那两件留在各自文件里。
+ * 🔴 **刻意不做声明式键路径表**:`sql` 的三座、`writeProtection` 的三位、`deviceExecutor` 的对象臂 +
+ *    `why` 判别子各有自己的合形判据(开集串 / 非负有限整数 / 严格布尔 / `null` 是合法值还是畸形),
+ *    把它们压进一张通用描述表 = 给同一份判据立第二个判官(而投影函数本身**就是**那一份判据,不是它的抄件)。
+ *
+ * ── 🔴 tee 的五条纪律(逐条在 {@link createEngineCapReader} 里实现,各只共享同一份)──────────────
+ *   ① 空 / 非串 `baseUrl` ⇒ no-op(读账的键就是 baseUrl,没有键就没有格);
+ *   ② 代际只在**入口快照一次**(`opts` 是调用方的对象,回体上的 getter 能在投影中途改它);
+ *   ③ 投影抛出(getter / Proxy 的回体)⇒ 与「投影答 `undefined`」**同一处置**,当畸形;
+ *   ④ 投影**之后再核一次代际**(投影执行的是不可信 getter,它能在中途让这一格换代);
+ *   ⑤ 畸形 ⇒ **删格**,不留上一台引擎的旧读数。
+ * 并且 **绝不 throw** —— 读面腿不许反噬 caps 探测链。
+ * ⚠️ **不传 `opts.generation` = 与本件到货之前逐字节同行为**(照写):那是 additive 供给,不是强制门。
+ *    本件**不**替调用方补一个「自己抓号」的代际(tee 自己抓号是假判据 —— 陈旧那一发在这里读到的
+ *    永远是新代号),也不因为收编而把缺供给那一档悄悄变严。
+ */
+import { snapshotCapsGeneration, capsGenerationStillCurrent } from './engineCapsGenerationGuard.js';
+/**
+ * 建一只能力位读器。per-baseUrl 读账 = **本次调用闭包里**的一张 Map ⇒ 一只读器一张表,
+ * 一只读器收到畸形回体删自己的格,绝不连坐另一只(这是六只原码分表的理由,收编后逐字保留)。
+ */
+export function createEngineCapReader(spec) {
+    const readingByBase = new Map();
+    return {
+        note(baseUrl, caps, opts) {
+            // ① 空 baseUrl no-op
+            if (typeof baseUrl !== 'string' || baseUrl === '')
+                return;
+            // ② 代际只在入口**快照一次**:`opts` 是调用方的对象,回体上的 getter 能在投影中途改它;首末两次核对都用这份快照,
+            //    读 opts / 读代际抛出 ⇒ 不动格(与陈旧代际同一处置)。
+            const gen = snapshotCapsGeneration(opts);
+            if (gen === null)
+                return; // 调用方 opts 的 getter 抛出 = 供给坏了 ⇒ 不动格
+            // 陈旧代际在**投影之前**就退场:不执行回体上的 getter,也不动格。
+            if (!capsGenerationStillCurrent(baseUrl, gen))
+                return;
+            let reading;
+            try {
+                reading = spec.project(caps);
+            }
+            catch {
+                // ③ 抛 getter / Proxy 的回体 = 畸形,与「投影答 undefined」同一处置 —— 删格,不许留着上一台的读数。
+                reading = undefined;
+            }
+            // ④ 投影之后**再核一次代际**:投影会执行回体上不可信的 getter,它可以在中途让这一格换代
+            //    (失效 + 新代际的 tee 已写入);此时无论投影返回还是抛出,都不许动新代际的格。
+            if (!capsGenerationStillCurrent(baseUrl, gen))
+                return;
+            // ⑤ 畸形 ⇒ 删格
+            if (reading === undefined) {
+                readingByBase.delete(baseUrl);
+                return;
+            }
+            readingByBase.set(baseUrl, reading);
+        },
+        observed(baseUrl) {
+            if (typeof baseUrl !== 'string' || baseUrl === '')
+                return spec.makeUnobserved();
+            const hit = readingByBase.get(baseUrl);
+            if (hit !== undefined)
+                return hit;
+            return spec.makeUnobserved();
+        },
+        forget(baseUrl) {
+            if (typeof baseUrl !== 'string' || baseUrl === '')
+                return;
+            readingByBase.delete(baseUrl);
+        },
+        __resetForTests() {
+            readingByBase.clear();
+        },
+    };
+}

package/dist/engineErrorCodes.d.ts

@@ -66,6 +66,10 @@ export declare const CONFIG_LIMIT_UNKNOWN_KEY = "config.limit_unknown_key";
  * 🔴 与本族其余成员同律:**坏旋钮响亮拒,绝不静默折回缺省**。
  */
 export declare const CONFIG_DELEGATION_ENTRY_CAPS = "config.delegation_entry_caps";
+/** 记忆面 project key 的拼写不合法(**400**;构造期拒,什么都没跑)。 */
+export declare const CONFIG_MEMORY_PROJECT_KEY_SPELLING = "config.memory_project_key_spelling";
+/** 这次请求的记忆写入范围与已生效的那一份不一致(**409**;构造期拒,什么都没跑 —— 冲突,不是拼写错)。 */
+export declare const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = "config.memory_write_scope_mismatch";
 /**
  * 已知的配置拒绝码(**识别表,非白名单**)。判「这是不是一条配置拒绝」请用
  * {@link isConfigRefusalCode} —— 它按 `config.` 前缀判,未来新成员自动落进来。

package/dist/engineErrorCodes.js

@@ -76,6 +76,18 @@ export const CONFIG_LIMIT_UNKNOWN_KEY = 'config.limit_unknown_key';
  * 🔴 与本族其余成员同律:**坏旋钮响亮拒,绝不静默折回缺省**。
  */
 export const CONFIG_DELEGATION_ENTRY_CAPS = 'config.delegation_entry_caps';
+// ── 记忆面的两个**构造期**拒码(CC-96;`agents[].memory` / 请求记忆面的同族第二波)────────────
+//
+// 两码与本族其余成员同律(「配置错了」不是「跑失败了」),但**多一条**:它们拒在**受理之前** ——
+// 这一次运行什么都没跑,所以出路一律是「改请求再发」,不是等、也不是去查运行结果。
+// 🔴 **分诊归引擎,本包不预铸第二判官**:拼写合不合法 / 范围算不算不匹配,判据都在引擎侧;本端照码渲一句话
+//    (单铸口 = `src/memorySpecWire.ts` 的 `memoryConfigRefusalNoteOf`),绝不自己先算一遍再「帮」它判。
+// ⚠️ 两码的 HTTP 状态**不同**(本族此前清一色 400):拼写 400 / 不匹配 409。状态不是判据(判据是码),
+//    但它是**处置差**的来源 —— 一条是打字错,一条是与已生效的那一份冲突,渲成同一句会把两种出路混掉。
+/** 记忆面 project key 的拼写不合法(**400**;构造期拒,什么都没跑)。 */
+export const CONFIG_MEMORY_PROJECT_KEY_SPELLING = 'config.memory_project_key_spelling';
+/** 这次请求的记忆写入范围与已生效的那一份不一致(**409**;构造期拒,什么都没跑 —— 冲突,不是拼写错)。 */
+export const CONFIG_MEMORY_WRITE_SCOPE_MISMATCH = 'config.memory_write_scope_mismatch';
 /**
  * 已知的配置拒绝码(**识别表,非白名单**)。判「这是不是一条配置拒绝」请用
  * {@link isConfigRefusalCode} —— 它按 `config.` 前缀判,未来新成员自动落进来。
@@ -86,6 +98,8 @@ export const CONFIG_REFUSAL_CODES = new Set([
     CONFIG_STRATEGY_MAX_SIZE_INVALID,
     CONFIG_LIMIT_UNKNOWN_KEY,
     CONFIG_DELEGATION_ENTRY_CAPS,
+    CONFIG_MEMORY_PROJECT_KEY_SPELLING,
+    CONFIG_MEMORY_WRITE_SCOPE_MISMATCH,
 ]);
 // ── 委派席位到限族(core 5.48.0 design/323,[4743] @cli 点名的「两新 coded 拒绝」)──────────────
 //

package/dist/executionLaneCapability.js

@@ -25,7 +25,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`)。
  * 键不在 / `undefined` ⇒ `not_reported`(老 server);`null` / 数组 / 非对象 / 缺任一座 / 座坏形 ⇒ 畸形。
@@ -48,47 +48,26 @@ export function projectExecutionLaneCapability(caps) {
         return undefined;
     return { kind: 'present', view: { provider, toolsOnThisHost } };
 }
-const readingByBase = new Map();
+/**
+ * 本格的 per-baseUrl 读账 + tee / 读口 / 失效口 / 测试钩四口 —— 各只能力位读器**共用同一份实现**
+ * ({@link createEngineCapReader});本文件只留这一格真正不同的部分:投影函数 {@link projectExecutionLaneCapability}、doctor 措辞表,以及本位自己的判据助手(如有)。
+ * 🔴 Map 在工厂闭包里,**一只读器一张**:收到读不懂的回体只删自己这一格,绝不连坐别的能力面。
+ */
+const reader = createEngineCapReader({
+    name: 'executionLane',
+    project: projectExecutionLaneCapability,
+    makeUnobserved: () => ({ kind: 'unobserved' }),
+});
 /**
  * 宿主 caps probe 的**读面 tee** 落点(与三只兄弟并列;宿主在同一处按序调)。绝不 throw。
  * 投影 `undefined`(畸形)⇒ 这一格**被删**而不是留着上一台引擎的旧值;`opts.generation` 关掉「旧探测覆盖新读数」竞态。
  */
 export function noteEngineCapsForExecutionLane(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 = projectExecutionLaneCapability(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'}`(**绝不**编一条车道)。 */
 export function observedExecutionLane(baseUrl = engineWireTarget()?.baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return { kind: 'unobserved' };
-    const hit = readingByBase.get(baseUrl);
-    if (hit !== undefined)
-        return hit;
-    return { kind: 'unobserved' };
+    return reader.observed(baseUrl);
 }
 /**
  * 「工具是否跑在本机」的**判据单源**(此前三端各拼旁证三合取):读到位就用位 —— `true` 是发 `baseDir` 的必要条件、
@@ -126,11 +105,9 @@ export function executionLaneDoctorDetail(reading) {
 }
 /** **换代失效口**(由宿主在引擎温切成功后调):清成未观测,不是留旧值。空串 ⇒ no-op;绝不 throw。 */
 export function forgetExecutionLaneReading(baseUrl) {
-    if (typeof baseUrl !== 'string' || baseUrl === '')
-        return;
-    readingByBase.delete(baseUrl);
+    reader.forget(baseUrl);
 }
 /** 测试钩子。 */
 export function __resetExecutionLaneReadingsForTests() {
-    readingByBase.clear();
+    reader.__resetForTests();
 }

package/dist/fleet/fleetRowAgentType.js

@@ -8,7 +8,7 @@
  *
  * 诚实来源亲核(sdk 9.8.1 实装字节):
  *   · `task_progress` 臂(`dist/events.d.ts`)上**没有** `agentType`、也没有 `spawnAgentType` —— tick 这条
- *     lane 今天根本不报类型,所以本层**不读**无出处的键(读了就是替上游发明一个字段);
+ *     lane 今天根本不报类型,所以本层**不读**无出处的键(读了就是替上游发明一个字段)。🔴 **措辞更正(外部验收方 [7764])**:因此 tick 这一档**不是一条「今天恒不命中的路径」,它根本没有代码** —— 本文件里 `agentType` 的三处出现全在注释,唯一的代码走的是 fleet 行帧那一档。相应地,「上游铸位当天零改生效」这句**不成立**:上游若铸出 `spawnAgentType`,本包**没有读口**,仍需改码补一档;
  *   · `FleetTaskRow.agentType`(`dist/resources/fleet.d.ts`,§K-7 的短类型 label,如 `Explore` /
  *     `general-purpose`)**有出处** —— 但 `fleet/fleetProjection.ts` 把它**折进** `FleetTaskView.name`
  *     (`deriveAgentLabel` = `agentName ?? agentType`,登记在

package/dist/hitl/approvalOutcomeNote.d.ts

@@ -1,13 +1,3 @@
-/**
- * approvalOutcomeNote — 流内帧腿的审批结局回交(`AskGateWireDeps.onToolApprovalOutcome(frame, outcome)`,0.74.1 CC-68)
- * 到宿主「审批结局便签」的**单源映射**(0.74.5 CC-88;此前三端装配点各手拼一份,语义以 cli 1.0.123 现行为准):
- *   · `approvalId` = 帧上的原词;
- *   · `settled` = `outcome.decision !== 'unresolved'`(respond 送达并落定;**不看** ack 在不在 —— ack 是 server 的回执形,宿主不读);
- *   · `retracted` 只在 `outcome.retracted === true` 时带键(**独立判别位**,不折进 detail:撤卡 ≠ 投递失败 —— 释放认领但不扣重出卡预算);
- *     `editRefused` **不算** retracted,只折进 detail;
- *   · `detail` 三支优先序:撤卡固定句 → 编辑被拒固定句 → `respondRefusal` 的 errorCode / message 过滤非空后 ` · ` 拼接;
- *     拼出空串 ⇒ 键缺席(绝不编一句;不用决断词、不用 ack 摘要)。
- */
 import type { ToolApprovalFrame, ToolApprovalFrameOutcome } from './toolApprovalWire.js';
 /** 宿主便签形(三端同一形;`retracted` / `detail` 在场才带)。 */
 export interface StreamApprovalOutcomeNote {

package/dist/hitl/approvalOutcomeNote.js

@@ -1,20 +1,47 @@
+/**
+ * approvalOutcomeNote — 流内帧腿的审批结局回交(`AskGateWireDeps.onToolApprovalOutcome(frame, outcome)`,0.74.1 CC-68)
+ * 到宿主「审批结局便签」的**单源映射**(0.74.5 CC-88;此前三端装配点各手拼一份,语义以 cli 1.0.123 现行为准):
+ *   · `approvalId` = 帧上的原词;
+ *   · `settled` = 这次决断**落定了**(respond 送达并落定;**不看** ack 在不在 —— ack 是 server 的回执形,宿主不读);
+ *     判据 = {@link approvalResolutionOf} 的落定臂,与旧口径 `outcome.decision !== 'unresolved'` 在实装可达的每一形上同值
+ *     (撤卡 / 编辑被拒两形只与 `'unresolved'` 同场铸出);
+ *   · `retracted` 只在 `outcome.retracted === true` 时带键(**独立判别位**,不折进 detail:撤卡 ≠ 投递失败 —— 释放认领但不扣重出卡预算);
+ *     `editRefused` **不算** retracted,只折进 detail;
+ *   · `detail` 三支优先序:撤卡固定句 → 编辑被拒固定句 → `respondRefusal` 的 errorCode / message 过滤非空后 ` · ` 拼接;
+ *     拼出空串 ⇒ 键缺席(绝不编一句;不用决断词、不用 ack 摘要)。
+ *
+ * 🔴 **三位的判据自本版起由 {@link approvalResolutionOf} 派生**(「一次决断最后怎么了」的单源判别联合):
+ *    `settled` = 落定臂;`retracted` = 「零字节 · 撤卡」这一 cause;`detail` 的三支 = 那三个臂/cause 的
+ *    三个分支。本便签的**导出形与逐字输出不变** —— 变的只是判据不再在这里第二次手读旁挂布尔位
+ *    (同一个问题两处各判一次 = 两份判据必然分叉)。
+ */
+import { approvalNotSentCause, approvalResolutionOf, isApprovalDecided, } from './approvalResolution.js';
 export const APPROVAL_NOTE_RETRACTED_DETAIL = 'the card was retracted (this host no longer has a decision port for it)';
 export const APPROVAL_NOTE_EDIT_REFUSED_DETAIL = 'edits are not accepted on this card';
 function nonEmpty(v) {
     return typeof v === 'string' && v.length > 0 ? v : undefined;
 }
+/** 结局的三支 detail(与 {@link ApprovalResolution} 的臂/cause 一一对应;拼出空串 = 没有可交的原文)。 */
+function detailOf(r) {
+    const cause = approvalNotSentCause(r);
+    if (cause === 'retracted')
+        return APPROVAL_NOTE_RETRACTED_DETAIL;
+    if (cause === 'edit_refused')
+        return APPROVAL_NOTE_EDIT_REFUSED_DETAIL;
+    // 引擎那一头给的原文:机器码 + 拒句,各自非空才进,` · ` 拼(不复述决断词、不摘 ack)。
+    if (r.kind === 'unsettled') {
+        return [nonEmpty(r.errorCode), nonEmpty(r.detail)].filter((x) => x !== undefined).join(' · ');
+    }
+    return '';
+}
 /** 帧 + 结局 → 便签(纯函数;结局上的坏形按缺席读,不抛)。 */
 export function approvalOutcomeNoteOf(frame, outcome) {
-    const retracted = outcome.retracted === true;
-    const refusal = outcome.respondRefusal;
-    const detail = retracted
-        ? APPROVAL_NOTE_RETRACTED_DETAIL
-        : outcome.editRefused === true
-            ? APPROVAL_NOTE_EDIT_REFUSED_DETAIL
-            : [nonEmpty(refusal?.errorCode), nonEmpty(refusal?.message)].filter((x) => x !== undefined).join(' · ');
+    const r = approvalResolutionOf(outcome);
+    const retracted = approvalNotSentCause(r) === 'retracted';
+    const detail = detailOf(r);
     return {
         approvalId: frame.approvalId,
-        settled: outcome.decision !== 'unresolved',
+        settled: isApprovalDecided(r),
         ...(retracted ? { retracted: true } : {}),
         ...(detail.length > 0 ? { detail } : {}),
     };

package/dist/hitl/approvalResolution.d.ts

@@ -0,0 +1,148 @@
+/**
+ * approvalResolution — 「**一次审批决断最后怎么了**」的单源判别联合({@link ApprovalResolution})
+ * 与它的唯一映射口({@link approvalResolutionOf})。
+ *
+ * ── 这一件修的是什么 ────────────────────────────────────────────────────────────────────────
+ * 同一个问题今天有**两种结局形**,而且第二种把三件互斥的事挤进同一个词:
+ *   · durable-park 腿 {@link import('./toolApprovalWire.js').FsApprovalOutcome} —— 四个 `kind`
+ *     + `failed.stage` 五词;
+ *   · 流内帧腿 / 悬挂 ask(盲卡)腿 {@link import('./toolApprovalWire.js').ToolApprovalFrameOutcome}
+ *     —— `decision` 四词,其中 `'unresolved'` 有 **3 种互斥含义**(宿主撤卡 / 编辑被拒 / respond 没落定),
+ *     要再读兄弟布尔位(`retracted` / `editRefused`)才分得开。
+ * ⇒ 本模块给出**一个**判别联合,两条腿的每一种结局各落恰一个臂 + 一个 cause 词,`'unresolved'`
+ *   的三义各落一臂。消费端从此一次判别拿到答案,不再靠读旁挂布尔位。
+ *
+ * ── 🔴 本版是 **additive**:既有型面一字未动 ───────────────────────────────────────────────
+ * `FsApprovalOutcome` / `ToolApprovalFrameOutcome` / `ApprovalCardDecision` 的键、值、语义
+ * **逐字节不变**;本模块只是**读**它们。端可以立刻改读本联合,也可以照旧读原结局对象。
+ *
+ * ── 三个臂各自答什么(边界写清,别处不许重铸)────────────────────────────────────────────────
+ *   · `decided` —— 决断**送到了引擎并拿到语义答复**;
+ *   · `not_sent` —— 包侧**一个字节都没发**(引擎那头的 ask 照旧挂着,`'no_pending'` 这一 cause 例外:
+ *     那一行本来就已经不在了);
+ *   · `unsettled` —— **没落定**。🔴 它**刻意不承诺**「字节已经出站」:见
+ *     {@link ApprovalUnsettledCause} 的 `'safety_stop'` / `'orchestration'` 两词的头注 ——
+ *     那两格在今天的结局对象上**分不出**决断有没有出站,而一个「保证发了」的承诺在这里是编的。
+ */
+import type { DecideReceiptView } from '../decideReceipt.js';
+import type { HitlSafetyCode } from './hitlBridge.js';
+import type { FsApprovalOutcome, ToolApprovalFrameOutcome, ToolApprovalRespondAckView, ToolApprovalRespondDecision } from './toolApprovalWire.js';
+/**
+ * 「包侧一个字节都没发」的因由闭集(**唯一真源**;端零手抄)。
+ *  · `'retracted'` —— 宿主撤掉了一张已经没有决断口的卡(两条腿都有这一形)。
+ *  · `'edit_refused'` —— 入参不可得的卡(悬挂 ask)上收到「编辑后批准」:丢掉改写再批准、或把改写
+ *    转发出去,两条都不是人按下的那个决定 ⇒ 整次不发。
+ *  · `'no_pending'` —— 取件那一拍队列里没有本 run 的可决行(结构化判别位,不是文案猜的)。
+ *  · `'fetch_failed'` —— 取件这一步**自己**失败了(与上一词结构可分:那是「没有行」,这是「问不出来」)。
+ *  · `'no_input'` —— 行上没有可呈现的工具入参,卡渲不出来。
+ *  · `'card_unavailable'` —— 卡口那一段失败(没装卡口 / 卡口自报失败)。
+ */
+export declare const APPROVAL_NOT_SENT_CAUSES: readonly ["retracted", "edit_refused", "no_pending", "fetch_failed", "no_input", "card_unavailable"];
+/** {@link APPROVAL_NOT_SENT_CAUSES} 的成员型。 */
+export type ApprovalNotSentCause = (typeof APPROVAL_NOT_SENT_CAUSES)[number];
+/**
+ * 「没落定」的因由闭集(**唯一真源**;端零手抄)。
+ *  · `'engine_refused'` —— 决断发出去了,引擎**真的答复并拒了**(卡通常仍 pending、决定没被消费)。
+ *    🔴 **只在有肯定证据时才给这个词**:结局对象上带着引擎的 wire 机器码,或带着引擎在拒体上铸的指路键。
+ *    没有证据的 decide 失败落 `'decide_failed'` —— 见下一词。
+ *  · `'decide_failed'` —— decide 这一段失败了,而结局对象上**没有任何「引擎答复过」的证据**:
+ *    调用方中止(人按了 Esc,出站前就抛)、抛出物身上根本没有码、老引擎的无码失败,三形同落这里。
+ *    🔴 **不许**据此说「引擎拒了」:那三形里有两形连字节都没出去。要不要重呈看别的位,不看这个词。
+ *  · `'transport_exhausted'` —— 出站瞬断类失败重试后仍未送达:**两发都没拿到语义答复**。
+ *  · `'safety_stop'` —— 本包的安全停闭集({@link HitlSafetyCode})命中 ⇒ 要重新呈现给人,**绝不自动重发**。
+ *    🔴 **这一格不承诺字节已出站**:`'binding_mismatch'` 既可能是本地绑定守卫在发送**前**拦下的,
+ *    也可能是引擎 409 答复重抛的 —— 今天的结局对象上这两个出处**不可分**,所以这里只说「没落定」。
+ *  · `'respond_failed'` —— 流内帧腿的 respond 抛错:这次决断没落定,**引擎按 TTL / abort 自决**。
+ *  · `'interrupted'` —— turn 被中断:包侧**发起**了一次工具级拒绝来结算挂着的 ask,但那一发是不观察结果的,
+ *    而且它自己也可能在出站前本地失败(绑定键缺失一类)。⇒ 既不能说落定,也**不能**说「一个字节都没发」。
+ *    🔴 它**不是** `not_sent`:`not_sent` 是「零字节」的承诺,这一格给不出那个承诺。
+ *  · `'orchestration'` —— 重挂环在硬上限 / 连续零进展上收口:那不属于决断链的任何一段,
+ *    结局对象上**分不出**决断有没有出站。
+ *  · `'unreadable'` —— 这个结局对象读不出来(不是对象 / 两个判别位都不成词 / 段词不认识)。
+ *    🔴 读不出**绝不猜 `decided`**,也不敢说「零字节」——两个方向猜错的代价都是替人说一句他没说的话。
+ */
+export declare const APPROVAL_UNSETTLED_CAUSES: readonly ["engine_refused", "decide_failed", "transport_exhausted", "safety_stop", "respond_failed", "interrupted", "orchestration", "unreadable"];
+/** {@link APPROVAL_UNSETTLED_CAUSES} 的成员型。 */
+export type ApprovalUnsettledCause = (typeof APPROVAL_UNSETTLED_CAUSES)[number];
+/** 决断送到了引擎并拿到语义答复。 */
+export interface ApprovalResolutionDecided {
+    kind: 'decided';
+    /**
+     * 落定的决断词,**原样透传**。
+     * 🔴 **不在这里复校闭集**:帧腿的词已经在它自己的发送段窄化过,边界上再校一遍等于装第二个判官
+     *    (一个表外的词会被降成「读不出」,而它其实是引擎收下的那个决断)。
+     * 🔴 durable-park 腿只可能给 `'allow'` / `'deny'`:那一腿的结局对象上**没有**「remember 送成了」
+     *    这一位,所以这里**不铸** `'allow_session'`(铸一个就是替引擎说一句它没说的话)。
+     * 🔴 流内帧腿上 **fail-closed 的拒绝与人按的拒绝不可分**(卡口的 `aborted` / `failed` 与 `deny`
+     *    在发送段折成同一个词)—— 今天的真相如实说,本联合不发明新位。
+     */
+    decision: ToolApprovalRespondDecision;
+    /** 待批 call 身份(durable-park 腿在场;帧腿没有这一位 —— 身份在帧的 `approvalId` 上,**不是**「没有身份」)。 */
+    gatedCallId?: string;
+    /** decide 的 200 回执读数(缺席 = 老 server / 终局形 / 回体读不动,三形同缺);🔴 它**不是**「门已解决」的证据。 */
+    receipt?: DecideReceiptView;
+    /** respond 的 200 ack(缺席 = **未知**:注入面回 void / 旧 server / 相关性门丢弃,绝不当成 false)。 */
+    ack?: ToolApprovalRespondAckView;
+}
+/** 包侧一个字节都没发。 */
+export interface ApprovalResolutionNotSent {
+    kind: 'not_sent';
+    cause: ApprovalNotSentCause;
+    gatedCallId?: string;
+    /** 本包铸的诊断文案(原样;读不出 / 空串 ⇒ 键缺席,绝不编一句)。 */
+    detail?: string;
+}
+/** 没落定(见模块顶注:**不承诺**字节已出站)。 */
+export interface ApprovalResolutionUnsettled {
+    kind: 'unsettled';
+    cause: ApprovalUnsettledCause;
+    gatedCallId?: string;
+    /** 本包的安全停判别位(`'safety_stop'` 这一 cause 上在场)。 */
+    safetyCode?: HitlSafetyCode;
+    /** 引擎的 wire 机器码(开集,原样;缺席**不带语义** —— 缺席 ≠「不是引擎拒的」)。 */
+    errorCode?: string;
+    /** 应答的 HTTP 状态(在场 = 引擎真应答了;缺席 = 传输层失败 / 注入面自抛,**不许**反推成 0)。 */
+    status?: number;
+    /** 可呈现的原文(帧腿 = 引擎的拒句原文;durable 腿 = 本包铸的诊断文案)。读不出 ⇒ 键缺席。 */
+    detail?: string;
+}
+/**
+ * 一次审批决断的**结局**(判别联合;三臂穷举,`'unresolved'` 的三义各落一臂)。
+ *
+ * 与旧读法的对照(消费端迁移判据一句话):
+ *   · `out.decision !== 'unresolved'`(帧腿)⇒ `approvalResolutionOf(out).kind === 'decided'`;
+ *   · `out.retracted === true` ⇒ `approvalNotSentCause(r) === 'retracted'`;
+ *   · `out.editRefused === true` ⇒ `approvalNotSentCause(r) === 'edit_refused'`;
+ *   · 裸 `'unresolved'` ⇒ `approvalUnsettledCause(r) === 'respond_failed'`。
+ *
+ * 🔴 **不并表的位**:指路键(`currentPending`)、ack 的逐位解释、receipt 的逐位语义照旧读原结局
+ *    对象 —— 本联合只答「怎么了」这一个问题。
+ */
+export type ApprovalResolution = ApprovalResolutionDecided | ApprovalResolutionNotSent | ApprovalResolutionUnsettled;
+/**
+ * {@link approvalResolutionOf} 认的入参:两条腿今天的结局对象。
+ * 🔴 ask / plan-review 腿的 `GateOutcome` **刻意不在**这个联合里(它多一个 `answered` 位与一张
+ *    另外的失败码闭集),plan-review 的决断生效读数也不在(它自己是另一张六词表)。
+ * ⚠️ **这是分工边界,不是一道编译期围栏**,如实说:只有 `failed` 那一臂因为失败码闭集不同而赋不进来;
+ *    `decided` / `aborted` 两臂在结构上仍然兼容,硬喂进来会被按本腿的口径读(`answered` 被忽略、
+ *    别的码表词读不出判别位)。把别的腿的结局喂进本口是调用方的错,本函数不替它兜。
+ */
+export type ApprovalLegOutcome = FsApprovalOutcome | ToolApprovalFrameOutcome;
+/**
+ * 今天各腿的结局对象 → {@link ApprovalResolution}。**纯函数,永不抛,永不造**。
+ *
+ * 判别序(固定,不随键序变):
+ *   ① `kind` 是 durable-park 腿的闭四词 ⇒ 按那一腿读;
+ *   ② 否则决断词是串 ⇒ 按流内帧腿 / 盲卡腿读;
+ *   ③ 都不成立 ⇒ `unsettled{cause:'unreadable'}`(🔴 不猜 `decided`,也不说「零字节」)。
+ *
+ * 🔴 **旁挂位在场压过决断词**(帧腿):撤卡 / 编辑被拒这两形是「一个字节都没发」,而它们今天与
+ *    `decision` 同在一只对象上;先读决断词就会把一张没发出去的卡说成「批过了」。
+ */
+export declare function approvalResolutionOf(outcome: ApprovalLegOutcome): ApprovalResolution;
+/** 这次决断**落定了吗**(唯一判据;`true` ⇒ 决断送到并拿到语义答复)。坏形入参 ⇒ `false`。 */
+export declare function isApprovalDecided(r: ApprovalResolution): r is ApprovalResolutionDecided;
+/** 「一个字节都没发」的因由;不是那一臂 ⇒ `undefined`(**不是**「发了」的证据,只是「不是这一臂」)。 */
+export declare function approvalNotSentCause(r: ApprovalResolution): ApprovalNotSentCause | undefined;
+/** 「没落定」的因由;不是那一臂 ⇒ `undefined`。 */
+export declare function approvalUnsettledCause(r: ApprovalResolution): ApprovalUnsettledCause | undefined;