@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/hitl/crashConverged.js

@@ -1,134 +1,21 @@
-/**
- * crashConverged.ts — `GET /v1/approvals` 的 additive 键 `crashConverged` 的**三端公共读面**
- * (L-38;server 7.55.0 起在场,fixture 直证坐标 `dist/boot/coordinators.js` 的 `GET /v1/approvals`
- * 分支 + `dist/approval-ask-audit-store.d.ts` 的 `CrashConvergedRow`)。
- *
- * ## 这一格是什么(先把语义说准,文案才有得写)
- * local 引擎在**人还挂在审批门上**的时候崩了:那一条 ask 既没被批也没被拒,进程一死就成了孤儿。
- * server 重启后把这些孤儿**收敛成 DENIED 同码**(`decision:'denied'` + `cause:'crashed_before_park'`),
- * 并把收敛结果作为一条 `crashConverged` 行挂在同一个 `/v1/approvals` 信封上。
- * 对端(TUI / web / desktop)而言这是**上一条命的残留**:重连 / `--resume` 之后,人有权知道
- * 「上次那次崩溃,把哪些审批替我拒掉了、其中哪几件可能已经落了一半副作用」。
- *
- * ## 两个桶的语义(端**唯一**需要分的那一刀)
- *   · `orphanState === 'pending'` = 崩的时候**工具一步都没执行**(还停在门上)。这一档配
- *     `resumeSafe === true` 时,重跑同一件事是安全的 ⇒ **resumeSafe 桶**。
- *   · `orphanState === 'decided'` = 人**当时已经批了 approve**,收敛把它翻成了 denied ——
- *     可能有半截副作用落地了(文件写了一半 / 命令跑了一半)。⇒ **needsHuman 桶**,人工确认。
- *   · 其余一切(`resumeSafe === false`、字段自相矛盾、说不清的组合)一律进 **needsHuman**:
- *     判**不**安全的代价是多问人一句(可恢复);判**错**安全的代价是让人闭眼重跑一件已经落过
- *     副作用的事(不可恢复)。凡证不出来一律落保守侧。
- *
- * ## 🔴 caveat(DEBTS L-38 收执逐字,写文案前必读)
- * `resumeSafe` 是**以账本完整为前提**算出来的**缺省值**,不是铁证 —— 崩溃现场本来就是账本最可能
- * 缺页的时刻。⇒ 端的文案只许写「按记录看可以重跑」,**绝不**写「已确认没有副作用」。
- * 同理:**键在场 ≠ 流内协议上场**。`crashConverged` 只是这一次 `list()` 回体上的一个 additive 键,
- * 它既不宣示引擎具备什么能力,也不代表有一条推送通道会再告诉端第二次。别拿它当能力位读。
- *
- * ## 🔴 非目标与已知边界(对手模型成文,详见 `docs/INTEGRATION-CLIENTS.md` §12e)
- * 真供给 = server JSON → SDK `JSON.parse` → 端:每一位都是**自有数据属性**,无代理、无 accessor、
- * 原型恒 `Object.prototype`。**被中间层合成的非 JSON 载荷 / 敌意 `Proxy` / 原型注射**这一族**不在
- * 射程内**:本件对它们只承诺三件 —— **不抛**、**不同步阻塞**、**绝不产出「可安全重跑」这个判决**
- * (一律落 needsHuman 或 dropped);**不承诺**还原出「真实内容到底是什么」。一只代理在它唯一那次
- * 被观察时就能给出假答案,而那与「宿主注入了一个会撒谎的传输层」是同一件事 —— 那种进程里每个对象
- * 都不可信,本件不是能修好它的那一层。下面那一串防御的**唯一**目的是把这一族挡在「安全」判决之外
- * 并保住线程,不是为了在敌意宿主上还原真相。
- *
- * ## 分工(与仓内既有形同款)
- * **纯投影,零 IO、零 module 级可变态、零文案**:本件不构造 client、不认 baseUrl、不碰凭据,
- * 也**一句面向用户的话都不铸** —— 措辞、是否上屏、排序与折叠全归端。
- * 取件仍走既有的权威 `client.approvals.list()`(见 `hitlBridge.ts` 的 `ApprovalsResourceLike`),
- * 本件只吃它的回体。
- */
-/**
- * 🔴 **校验的尺子 = 类型面地板,不是「数据好不好看」**(L-38 复审采纳)。
- * 本文件产出的行被声明成 {@link CrashConvergedRow},所以**类型对不上必须丢**(放过去就是在类型面
- * 撒谎,端读到 `undefined` 时编译器不会提醒任何人)。但**超出类型面的严格**是另一回事:
- * `ts: NaN`、`toolName: ''` 这类**退化但合型**的值只是难看,而为它们丢掉整行的代价是
- * **一条真孤儿审批从人眼前消失** —— 那正是本面存在要防的那件事。⇒ 只在两处越过类型面:
- *   · `approvalId` 要**非空**(它是行身份:重复取件时的去重键、端要引用的那个 id;空串让这一行
- *     结构上不可用,而不只是难看);
- *   · 三个闭集判别式(`decision`/`cause`/`orphanState`)—— 对不上不是「退化」,是**别族的行**。
- * 其余一律只判类型。`dropped` 因此只数「**类型面**读不出的行」,不数「数据不好看的行」。
- */
 const isString = (v) => typeof v === 'string';
 const isNumber = (v) => typeof v === 'number';
-/** 行身份位:空串既去不了重也引用不了,结构上不可用(唯一一处越过类型面的串判)。 */
 const nonEmptyString = (v) => typeof v === 'string' && v.length > 0;
-/**
- * 从一个**不可信**对象上取一位:只认**自有数据描述符**的 `value`。
- *
- * 🔴 为什么不用 `obj[key]`(复审采纳,L-38):普通属性读取会 ① **执行** accessor,② 一路查到
- *    **原型**上去。执行意味着同步跑别人的代码 —— 而 `try/catch` 接得住「抛」,接不住「不返回」:
- *    一只忙等 / 死循环的 getter 会把启动 / `--resume` 路的线程**永久**钉住,行数上限对它无效。
- *    ⇒ 三处不可信读取(信封的 `crashConverged`、载体的 `length`、载体的每个数字下标)统一走这里:
- *    accessor / 缺席 / 只挂在原型上的东西**一律当缺席**,一次别人的代码都不执行。
- *    真供给来自 `JSON.parse`,每一位都是自有数据位 ⇒ 这条对真行零影响。
- *    ⚠️ `Object.getOwnPropertyDescriptor` 自己对代理会触发 trap(可能抛)⇒ 调用点都在保护块内。
- */
 const ownDataValue = (obj, key) => {
     const d = Object.getOwnPropertyDescriptor(obj, key);
     if (d === undefined || 'get' in d || 'set' in d)
         return undefined;
     return d.value;
 };
-/**
- * 载体行数的**硬上限**(复审采纳,L-38)。`length` 只判「非负整数」是不够的:一个只装着一行、
- * 却让 `length` trap 答十亿的数组代理能过掉那道判据,随后本函数**同步**空转十亿次 —— 浏览器 /
- * TUI 主线程当场冻住,而这条面恰恰跑在**启动/`--resume` 路**上。
- * 取值理由:`/v1/approvals` 是 per-scope 的挂起队列,真实供给远在这个数量级之下;
- * 10 万行的遍历是毫秒级,而十亿行不是「多等一会」而是「回不来」。
- * 超限 ⇒ 与「载体读不出」同一档(`undefined`,端零渲染):一个说不清有多少行的供给,
- * 本包不假装数得清。
- */
 const MAX_CRASH_CONVERGED_ROWS = 100_000;
 function readCrashConvergedRow(v) {
-    // 🔴 **载体形判也在 try 内**(复审采纳,L-38):`Array.isArray(v)` 对一只**已撤销**的 `Proxy`
-    //    会抛 —— 它此前在 try 之外,于是一行读不出的载荷会把异常一路交给**外层**的 catch,
-    //    整只投影退化成 `undefined`:一条坏行**连坐**抹掉同批全部真孤儿,而端还会把这个结果
-    //    读成「本部署没提供这个面」。坏行的正确归宿是 `dropped` 一格,不是整批消失。
-    //    (`typeof` 自己不会抛;会抛的是 `Array.isArray` 与后面每一次取属性。)
-    // 🔴 取属性本身要设防:供给来自宿主注入的传输层,它完全可以是一个带抛错 getter 的对象或敌意
-    //    `Proxy`(与 `classifyMemoryStatusFailure` 同一条理由)。读一下就抛 ⇒ 判这一行读不出,
-    //    而不是让整只投影向外 reject —— 调用方是照着「本函数不抛」写的。
     try {
         if (typeof v !== 'object' || v === null || Array.isArray(v))
             return null;
-        // 🔴 **恰一次枚举**(见头注):`Object.getOwnPropertyDescriptors` 是本函数对这一行的
-        //    **唯一**一次观察 —— 它一次性拿到键集 + 每一位的描述符,且**不触发任何 getter**。
-        //    🔴 判据与快照必须出自**同一次**枚举:上一版先用它判 accessor、再用 `{ ...v }` **重新枚举
-        //    一遍**取值,于是一只**不抛**的 `Proxy` 只要在第一次 `ownKeys` 里亮出
-        //    `originalDecision:'approve'`(⇒ 判定为纯数据、`unstable=false`)、在第二次 `ownKeys` 里
-        //    把这个可配置位**省掉**,快照就成了「pending + resumeSafe 且无已批证据」⇒ 落进 resumeSafe。
-        //    两次独立观察之间的任何不一致都是攻击面;一次观察则没有「另一次」可以与之矛盾。
-        //    (代理仍可能在这唯一一次观察里撒谎 —— 那等同于「宿主注入了会撒谎的传输层」,见 §12 边界。)
         const descs = Object.getOwnPropertyDescriptors(v);
         const o = Object.create(null);
-        // 🔴 **自带原型的行一律 `unstable`**(复审采纳,L-38):快照只枚举**自有**位,所以挂在
-        //    原型上的 `originalDecision` / `decidedAtMs` 进不了快照 —— 跨位矛盾闸于是看不见证据,
-        //    一个**普通、无代理、无 accessor、观察完全稳定**的对象
-        //    (`Object.assign(Object.create({originalDecision:'approve'}), row)`)就能落进 resumeSafe。
-        //    这不在「宿主注入的传输层整体撒谎」那条边界之内:它没撒谎,是本包少看了一层。
-        //    ⇒ 原型不是 `Object.prototype` / `null` 的行,一律只挡「安全」这一侧(落 needsHuman,不丢)。
-        //    真供给来自 `JSON.parse`,原型恒是 `Object.prototype` ⇒ 这条对真行零影响。
         const proto = Object.getPrototypeOf(v);
         let unstable = proto !== Object.prototype && proto !== null;
-        // 🔴 **校验用的字典是 null 原型**(复审采纳,L-38):下面每一次 `o.xxx` 都是一次属性查找,
-        //    普通 `{}` 的查找会**落到 `Object.prototype` 上**。如果本进程里那份原型被污染过
-        //    ——例如 `Object.prototype.sessionId` 被装成一只 `delete this.originalDecision` 的 getter——
-        //    那么「校验可选位」这一步就会把**快照里的已批证据**抹掉,随后跨位矛盾闸看不见证据,
-        //    危险行落进 resumeSafe(实测修前如此)。null 原型的字典**没有可查找的上一层**,
-        //    这条路径按构造消失。
-        // 🔴 **落键一律走 `Object.defineProperty`,绝不用 `o[k] = …`**(复审采纳,L-38):
-        //    `'__proto__'` 是一个**合法的自有可枚举键**(JSON 里就出得来),而普通赋值对它**不是存值**
-        //    —— 它会调用 `Object.prototype.__proto__` 的 **setter**,把那个值装成快照的**原型**。
-        //    于是一行「自有位全是纯数据」(⇒ `unstable` 为假)的载荷,可以把一只带 `sessionId` getter 的
-        //    对象注射成快照的原型;下面校验可选位读 `o.sessionId` 时那只 getter 就跑起来,
-        //    `delete this.originalDecision` 把**快照里**的已批证据抹掉 ⇒ 危险行落进 resumeSafe
-        //    (实测修前 `resumeSafe=1`)。accessor 闸看不见它:抛错的那一位在**注射进来的原型**上,
-        //    不在被枚举的行上。
-        //    `defineProperty` 不触发任何 setter ⇒ `__proto__` 老老实实变成一个自有数据位
-        //    (它遮住原型上那个 accessor),快照的原型仍是 `Object.prototype`,additive 键照样保全。
         const put = (k, value) => {
             Object.defineProperty(o, k, { value, enumerable: true, writable: true, configurable: true });
         };
@@ -137,23 +24,13 @@ function readCrashConvergedRow(v) {
             if (d === undefined || d.enumerable !== true)
                 continue;
             if ('get' in d || 'set' in d) {
-                // 🔴 **accessor 一律不执行**(复审采纳,L-38):`d.get.call(v)` 是**同步**执行别人的代码,
-                //    而 `catch` 只接得住「抛」,接不住「不返回」—— 一只死循环 / 忙等的 getter 会把
-                //    启动 / `--resume` 路的线程**永久**钉住,10 万行上限对这一形完全无效。
-                //    ⇒ 这一位当**缺席**处理,并把整行标 `unstable`。后果分两档,都是可接受的一侧:
-                //      · 缺的是**必填位** ⇒ 校验过不了 ⇒ 这一行计入 `dropped`(响亮,不是静默);
-                //      · 缺的是**可选 / additive 位** ⇒ 行照留,只是永远拿不到「可安全重跑」这个判决。
-                //    真供给来自 `JSON.parse`,每一位都是数据描述符 ⇒ 这条对真行零影响。
                 unstable = true;
                 continue;
             }
             put(k, d.value);
         }
-        // 行身份:唯一一处越过类型面的严格(空 id 结构上不可用,见 nonEmptyString 头注)。
         if (!nonEmptyString(o.approvalId))
             return null;
-        // 其余必填位:只判**类型**。退化但合型的值(空 toolName / NaN 时刻)难看归难看,
-        // 为它丢掉整行 = 让一条真孤儿从人眼前消失。
         if (!isString(o.toolName))
             return null;
         if (!isString(o.taskId))
@@ -166,23 +43,18 @@ function readCrashConvergedRow(v) {
             return null;
         if (typeof o.resumeSafe !== 'boolean')
             return null;
-        // 判别式三位:对不上 = 这不是本族的行(见 CrashConvergedRow 头注的闭集说明)。
         if (o.decision !== 'denied')
             return null;
         if (o.cause !== 'crashed_before_park')
             return null;
         if (o.orphanState !== 'pending' && o.orphanState !== 'decided')
             return null;
-        // 可选三位:缺席合法,在场必须**合型**(同上,不再加类型面之外的严格)。
         if (o.sessionId !== undefined && !isString(o.sessionId))
             return null;
         if (o.originalDecision !== undefined && o.originalDecision !== 'approve')
             return null;
         if (o.decidedAtMs !== undefined && !isNumber(o.decidedAtMs))
             return null;
-        // 🔴 交还的是**普通原型**的对象(端拿到的是一只正常对象:`hasOwnProperty` / `toString` 都在),
-        //    但它的每一位都逐字来自上面那份 null 原型快照 —— 校验与分桶都发生在快照上,
-        //    交付只是把同一批值换个原型装出去。落键仍走 `defineProperty`(`__proto__` 同理)。
         const delivered = {};
         for (const k of Object.keys(o)) {
             Object.defineProperty(delivered, k, { value: o[k], enumerable: true, writable: true, configurable: true });
@@ -196,97 +68,24 @@ function readCrashConvergedRow(v) {
         };
     }
     catch {
-        // 敌意行(已撤销 Proxy / 抛错 getter):判**这一行**读不出,由调用方计入 `dropped`。
-        // 不向外抛,更不让它连坐同批的好行。
         return null;
     }
 }
-/**
- * `GET /v1/approvals` 回体 → `crashConverged` 的**分桶投影**。纯函数,**永不抛**。
- *
- * ## 🔴 缺席 vs 空数组:两件不同的事,判据不许合流
- *   · **键缺席**(老 server / deps 不在场 / 读不动)⇒ 返回 `undefined` ——「本部署没告诉我这件事」。
- *     端此时**零渲染**:绝不渲「0 个」「本次无崩溃遗留」之类的话,那是替 server 下一个它没说过的
- *     断言([honest-absence-not-fabricated-zero])。
- *   · **键在场且是空数组** ⇒ 返回 `{ total: 0, resumeSafe: [], needsHuman: [], dropped: 0 }` ——
- *     「server 明说:一条都没有」。这一档端**可以**渲「没有崩溃遗留」。
- *   ⇒ 两档的**返回形不同**(`undefined` vs 对象),端拿 `=== undefined` 一刀分开,不必读计数。
- *
- * ## 🔴 载体在场却不是数组 ⇒ 同样 `undefined`(**不**折成 `total:0`)
- * 那是形漂了或中间层改写了,本包**读不出**这次的供给。折成 `{total:0}` 会让端渲出
- * 「没有崩溃遗留」——在一条给人判断「能不能闭眼重跑」的面上,这是最坏方向的假断言。
- * 两档合流的代价只是「都零渲染」,而分错的代价是一句用户会照着去操作的谎。
- *
- * ## 🔴 三处不可信读取只认**自有数据位**
- * 信封的 `crashConverged`、载体的 `length`、载体的每个数字下标 —— 三处都走 `ownDataValue`:
- * accessor / 缺席 / 只挂在原型上的东西一律**当缺席**,一次别人的代码都不执行(`catch` 接得住
- * 「抛」,接不住「不返回」)。真供给来自 `JSON.parse`,每一位都是自有数据位 ⇒ 对真行零影响。
- *
- * ## 🔴 载体**读不出**(已撤销 `Proxy` / `length` 或描述符取值抛)⇒ 也是 `undefined`
- * 触碰载体的每一处都在保护内 —— 连 `Array.isArray()` 自己都是(对已撤销的 `Proxy` 调用它直接抛)。
- * 走到一半炸掉时刻意**不交还半程结果**:一个自己都知道不全的计数,拿去渲「上次崩溃影响了 N 件」
- * 比不说话更坏。
- * 🔴 遍历**按数字下标**,不用载体自己的迭代协议:自带 `Symbol.iterator` 覆盖的数组能一条都不产出
- * (于是真孤儿被伪造成「server 明说一条都没有」),也能把危险行替换成安全行。下标读不问载体
- * 「有哪些行」这个问题。⚠️ 边界:代理仍能在 `length`/下标 trap 上撒谎 —— 那等同于「宿主注入了
- * 会撒谎的传输层」,本包挡不住也不假装挡得住;本条守的是协议面。
- *
- * ## 🔴 进 resumeSafe 桶的合取有**五项**(两项主判据 + 两项跨位自洽 + 一项载体自证)
- * `orphanState==='pending'`(工具零执行)∧ `resumeSafe===true` ∧ `originalDecision` 缺席 ∧
- * `decidedAtMs` 缺席 ∧ 这一行**不带 accessor**。中间两项是**矛盾闸**:`pending` 说「一步都没执行」,
- * 而那两位是「人已经按下过 approve」的证据 —— 同时在场 = 自相矛盾的载荷。最后一项是**顺序重入闸**:
- * 带 getter 的行能在展开过程中把证据位删掉(见行读口头注的实测)。三者都**只挡「安全」这一侧**,
- * 一律落 needsHuman 而**不丢** —— 它们可能是真孤儿,而且恰恰是最该给人看的那几条。
- *
- * ## 🔴 行数硬上限
- * `length` 超过 100000 ⇒ 与「载体读不出」同一档(`undefined`)。判在遍历**之前**,所以一个谎报
- * 十亿的 `length` trap 连一次下标读都触发不了 —— 否则同步空转会把启动/`--resume` 路的主线程冻住。
- *
- * ## 🔴 入参是 `unknown`,不是「带一个可选 `crashConverged` 的对象」
- * 写成 `{ crashConverged?: unknown }` 会造出一个 TypeScript **弱类型**(成员全可选):把真
- * `client.approvals.list()` 的回体喂进来时,SDK 7.4.0 声明的 `{ pending; livePending? }` 与它
- * **一个共同属性都没有** ⇒ TS2559「has no properties in common」,文档里那句最主要的用法当场编不过
- * (而只用本包自己的 `ApprovalsListEnvelope` 去测发现不了 —— 那个形恰好声明了 `crashConverged`)。
- * 收 `unknown` 也更诚实:本函数对入参的全部工作**就是**窄化它,形状是运行期才知道的事。
- *
- * @param env 任意 `/v1/approvals` 回体(只读 `crashConverged` 一键;非对象 / `null` ⇒ `undefined`)。
- */
 export function projectCrashConverged(env) {
     const resumeSafe = [];
     const needsHuman = [];
     let dropped = 0;
-    // 🔴 **整段读取都在保护内**(复审采纳,L-38):载体上的每一次触碰都可能执行**别人的**代码。
-    //    ① 信封取属性(抛错 getter / `Proxy`);
-    //    ② `Array.isArray()` 自己 —— 对一只**已撤销**的 `Proxy` 调用它直接抛 `TypeError`
-    //       (它此前在 try 之外,那正是「永不抛」承诺上最后一个没堵的洞);
-    //    ③ `length` 与逐个下标取值。
-    //    任一处抛 ⇒ 与「载体不是数组」同一档:这次供给**读不出** ⇒ 诚实缺席。
-    //    ⚠️ 刻意**不**交还半程结果:走到一半才炸,已读到的行数说明不了总数,拿它去渲
-    //    「上次崩溃影响了 N 件」就是拿一个自己都知道不全的数当结论。
     try {
         if (typeof env !== 'object' || env === null)
             return undefined;
-        // 🔴 信封这一位也只认**自有数据描述符**(见 `ownDataValue` 头注):普通读取会执行 accessor,
-        //    而一只不返回的 getter 挡不住 —— `catch` 接不住「不返回」。
         const raw = ownDataValue(env, 'crashConverged');
         if (raw === undefined)
             return undefined;
         if (!Array.isArray(raw))
             return undefined;
-        // 🔴 **按数字下标走,不用载体自己的迭代协议**(复审采纳,L-38):`for…of` 把「这个数组里
-        //    到底有哪些元素」这件事**交给载体自己回答** —— 一个自带 `Symbol.iterator` 覆盖的数组
-        //    (中间层改写 / 反序列化器的产物都造得出)可以:一条都不产出 ⇒ 本函数答
-        //    `{total:0}`,而端会把它读成「server 明说一条都没有」,一条真孤儿就此人间蒸发;
-        //    或者把一条 `decided` 的危险行换成一条 `pending/resumeSafe` 的安全行 ⇒ 直接误导重跑。
-        //    下标读**读不到**这两种伪造(它不问载体「你有几个元素」以外的任何问题)。
-        //    ⚠️ 边界说清楚:一只**代理**仍然能在 `length` / 下标 trap 上撒谎 —— 那与「宿主注入了一个
-        //    会撒谎的传输层」是同一件事,本包挡不住也不假装挡得住。本条守的是**协议面**:
-        //    不把「有哪些行」的解释权交给载体的迭代器。
         const len = ownDataValue(raw, 'length');
         if (typeof len !== 'number' || !Number.isInteger(len) || len < 0)
             return undefined;
-        // 🔴 行数硬上限(见 MAX_CRASH_CONVERGED_ROWS 头注):**先判再遍历** —— 判在循环之前,
-        //    所以一个谎报十亿的 `length` 连一次下标读都触发不了。
         if (len > MAX_CRASH_CONVERGED_ROWS)
             return undefined;
         for (let i = 0; i < len; i++) {
@@ -296,18 +95,6 @@ export function projectCrashConverged(env) {
                 continue;
             }
             const row = reading.row;
-            // 🔴 **保守侧的合取有四项**(复审采纳,L-38):前两项是主判据,后两项是
-            //    **跨位自洽**——`orphanState:'pending'` 的含义是「崩的时候工具一步都没执行」,而
-            //    `originalDecision`/`decidedAtMs` 是「人当时已经按下过 approve」的证据。两者同时在场
-            //    是**自相矛盾**的载荷(版本斜差 / 畸形体 / 中间层改写都造得出),而它落错方向的代价正是
-            //    本面要防的那件事:让人闭眼重跑一件**可能已经开始落副作用**的事。
-            //    ⇒ 矛盾形不产出「安全」这个确定判决,落 needsHuman(与 `readCaptureOptOut` 的完整
-            //    真值表同一条纪律:不在契约表上的组合一律不给确定答案)。
-            //    🔴 **不丢**:它是一条真孤儿,而且恰恰是最该给人看的那一条 —— 丢掉它比渲错更坏。
-            //    🔴 第五项:`unstable`(这一行的载体带 accessor 或自带原型,见行读口头注)—— 同样只把它
-            //    挡在「安全」这一侧,不丢。
-            //    🔴 三个判据一律读 `reading` 而**不是** `row`(见 {@link CrashConvergedRowReading} 头注):
-            //    它们是校验那一刻定下来的值,回头再读一遍交付物等于开第二次观察窗口。
             const consistentlyUnexecuted = reading.orphanState === 'pending' && !reading.hasApprovalEvidence;
             if (!reading.unstable && consistentlyUnexecuted && reading.resumeSafe === true)
                 resumeSafe.push(row);
@@ -316,7 +103,6 @@ export function projectCrashConverged(env) {
         }
     }
     catch {
-        // 敌意/坏载体(已撤销 Proxy / `length` 或下标取值抛):供给读不出 ⇒ 诚实缺席,不向外抛。
         return undefined;
     }
     return { total: resumeSafe.length + needsHuman.length, resumeSafe, needsHuman, dropped };

package/dist/hitl/editedRuleTextPrecheck.d.ts

@@ -1,127 +1,18 @@
-/**
- * editedRuleTextPrecheck.ts — 编辑臂的「边打字边校验」判官**转出口**(#225 / [5076] 自领件,0.42.0)。
- *
- * ## 这一格要解决的问题
- * 卡上的规则编辑框想在人还在打字的时候就说「这条能不能提交」。唯一合法的判官是引擎自己那只 ——
- * core 5.57.0 导出的纯函数 `precheckEditedRuleText(text, command)`,它与 `confirmRuleApproval` 的
- * fresh-edit 臂**跑同一个函数体**(`checkEditedRuleText`),所以预检面与真裁判**结构性不可分歧**。
- * 在边界上复读一遍 `parseAllowRuleText` 是**装第二个更严的判官**:`Bash(adb *)` 这类肌肉记忆形
- * 会被它当场误杀,而编辑面本来先跑拼写归一(`normalizeEditedSpelling`)再接受
- * ——[5071] 定界②的原话,core [5075] 复核确认。
- *
- * ## 🔴 为什么是**端口注入**而不是 `export { precheckEditedRuleText } from '@sema-agent/core'`
- * [5076] 的自领件原话是「re-export + 类型面」。**逐字照做在本包里是不可能的**,而且不是口味问题,
- * 是本仓门族的硬约束(0.42.0 施工时实测,证据两条):
- *   · `scripts/run-client-core-portability-test.mjs` 的 `EXPECTED_PACKAGES_INDEX` 是**等值门**
- *     ——包总入口闭包的外部包集合恒等于 `{diff, @sema-agent/sdk}`,多一个当场红;
- *   · 同门 ③ 段拿 esbuild `--platform=browser` **真打一次包**。`@sema-agent/core` 的 barrel 值级
- *     拉进 `node:crypto`(`engine/session/log-digest.js`)、`node:fs`/`node:path`
- *     (`core/skills-directory.js`)…… 浏览器腿当场打不成。
- * ⇒ 一个 value 级 re-export 会把**整台引擎**焊进每一个装 client-core 的端(web/desktop 首当其冲),
- *   换来一只纯函数。本包的存在理由正是「三端共用的**客户端**运行时」,这条边不能连。
- *
- * 于是转出口取**同等效力的第二形**:
- *   ① **类型面**逐形转出({@link EditedRuleTextPrecheck} / {@link EditedRuleTextPrechecker}),
- *      三端从此对着同一份形写代码,谁都不用自己抄一份返回型;
- *   ② **注入口**({@link installEditedRuleTextPrechecker}):Node 宿主(TUI / desktop 主进程 /
- *      server 侧渲染)在启动时把 core 那只函数原样装进来 —— **原样装,不许包一层判断**;
- *   ③ **读口**({@link precheckEditedRuleText}):没装 ⇒ 返 `undefined`(**诚实缺席**),
- *      绝不返一个编出来的 `{ok:true}`。缺席时呈现面的正解是退「提交后才知道」的往返形
- *      ——[5076] 施工要点③ 已经把这两段写成互不阻塞的两腿。
- * 🔴 浏览器 lane(web)结构上装不了这只函数(引擎不在那一侧),它**本就该**留缺席走往返形;
- *   本口的缺席语义因此不是「宿主忘了装」的同义词,别拿它去判部署形态。
- *
- * ## 🔴 两点语义预披露(core [5075],消费侧写文案前必读;[5076] 已落账为 #225 施工要点)
- *   · `ok` = **可提交**,不是「confirm 必成」。记录级闸(binding 回声 / 记录 owner 与 state /
- *     scope 继承 / 部署开关)**不在**预检覆盖面,由 `confirmRuleApproval` 对着记录重判。
- *     ⇒ UI 文案只许写「可提交」,**绝不**写「将被批准」。
- *   · `canonicalRule` 可能与输入**字节不同**(拼写归一)。它是真正会落库的那一形,所以内联反馈
- *     应当显示 **canonical 形**,而不是把人的输入原样回显。
- *
- * ## 调用面契约(core 逐字,注入口不许替它软化)
- *   · `text` 是**人**的输入 ⇒ 任何畸形拼写都是一个**答案**(refusal),永不抛;
- *   · `command` 是**调用方**的上下文(卡所依据的被裁决命令)⇒ 缺席/非串是**调用方 bug**,
- *     core 响亮抛(`config.invalid_argument`)。本包的读口**不吞这个抛**(见 {@link precheckEditedRuleText}
- *     的 `@throws`):把它折成一个 refusal 会让人读到「你的规则不接受空命令」——把调用方的错
- *     误归到人头上,正是 core 那段头注点名要避免的事。
- *   · 卡上**压根没有被裁决命令**(老记录 / 店丢了这一列)⇒ 那是**记录级**拒绝,不该问本函数;
- *     宿主此时的正解是**根本不给编辑框**。
- */
-/**
- * `text × command` 三步门(拼写归一 → 语法门 → coverage 闸)的判决 —— core 5.57.0
- * `EditedRuleTextPrecheck` 的**逐形镜像**(结构等价,故 core 那只函数可直接装进
- * {@link EditedRuleTextPrechecker} 而无需任何适配)。
- *
- * 🔴 `code` 的**在场规则**与提交面的 `edit_rejected.detail` 同源:验证器自己拒时**在场**,
- *    coverage 闸拒时**缺席** —— 同一具函数体出来的同一批值。缺席不许被读成「没有理由」。
- * 🔴 `code` 是**开集串**:core 的 `RuleRejectCode` 词表属主是引擎,本包**刻意不镜像那张枚举**
- *    (镜像 = 引擎加员当天把一个合法值判没,#157 词表纪律的反面)。要分支就按串比,未知值原样呈现。
- */
-/**
- * core 7.3.0(design/382 §3.3-5)—— 关于一条**已被接受**的规则的**宽度提示**。
- * 🔴 **提示不是拒绝**:拒绝集一字未动,这一位说的是「这条规则比这张卡宽,持有人该知道」
- *    (`Bash(adb:*)` admits every argument form of `adb`)。渲不渲、怎么渲是端的事;引擎保证的是
- *    另一半 —— 走 edit 臂确认时命中码会写进记录(`edited.warnings`),「宽度在点头之前被说出来过」
- *    因此是可审计的事实。
- * 🔴 `code` 在本包是**开集串**,与本文件 `code?: string` 那一位同一条纪律:core 的
- *    `EditedRuleBreadthWarning['code']` 今天是 `'broad_prefix' | 'compound_prefix'` 两员,
- *    镜像那张枚举 = 引擎加员当天把一个合法值判没(#157 词表纪律的反面)。
- */
 export interface EditedRuleBreadthWarning {
-    /** 开集串(见类型注)。未知码原样呈现,绝不因为不认得就丢掉这条提示。 */
     readonly code: string;
-    /** 基线措辞(端可改写,**绝不可反转**;与 §3.5 的 reason 基线同契约)。 */
     readonly message: string;
 }
 export type EditedRuleTextPrecheck = {
     ok: true;
-    /** 真正会落库的那一形(可能与输入字节不同 —— 拼写归一)。内联反馈显示**这一形**。 */
     canonicalRule: string;
-    /**
-     * core 7.3.0 跟车一位(B-003 批抬 devDep core ^7.1.0 → ~7.3.0 时由 engine-vocab G4 形对账
-     * 抓出:「ok 臂键集恰 {ok, canonicalRule}」当场翻红,core 真返回三键)。**ADDITIVE,缺席 =
-     * 没什么可说的**(不是「没有提示 = 规则很窄」的反推位)。
-     * 🔴 本包只做**类型面转出**:这条腿是端口注入(值从 core 原样穿过,本层零加工),所以镜像
-     *    漏这一位不会剥掉运行期的值,漏掉的是**消费端的类型面可见性** —— 端读不到就不会渲,
-     *    「宽度在点头之前被说出来」这件事就只剩引擎那半边。
-     */
     warnings?: readonly EditedRuleBreadthWarning[];
 } | {
     ok: false;
-    /** 验证器自己拒时在场;coverage 闸拒时缺席(开集串,见类型注)。 */
     code?: string;
-    /** 拒绝措辞(与 `edit_rejected.detail` 同词汇)。原样呈现,包边界零加工。 */
     message: string;
 };
-/**
- * 判官的形:`(text, command) => 判决`。**唯一合法的实参** = core 5.57.0 导出的
- * `precheckEditedRuleText`,原样装,不许在外面包一层自己的判断
- * ——包一层就是把「同一函数体」这条唯一的抗漂移保证亲手拆掉。
- */
 export type EditedRuleTextPrechecker = (text: string, command: string) => EditedRuleTextPrecheck;
-/**
- * 装/卸判官。返回**还原函数**(装口族统一姿势:还原到装之前那一只,不是无脑清空 —— 嵌套装载
- * 时无脑清空会把外层那只一起抹掉)。
- *
- * Node 宿主的装法(**逐字**,别加工):
- * ```ts
- * import { precheckEditedRuleText } from '@sema-agent/core'
- * installEditedRuleTextPrechecker(precheckEditedRuleText)
- * ```
- */
 export declare function installEditedRuleTextPrechecker(fn: EditedRuleTextPrechecker | null): () => void;
-/**
- * 装没装(存在性读口哨兵:`boolean` 形 —— 见 `docs/INTEGRATION-CLIENTS.md` §5a 的三形分野)。
- * 呈现面据它决定**给不给编辑框的内联反馈**;`false` 时编辑框本身仍然可用(走往返形)。
- */
 export declare function hasEditedRuleTextPrechecker(): boolean;
-/**
- * 预检一段编辑过的规则文本。**没装判官 ⇒ 返 `undefined`**(诚实缺席,不是 `{ok:true}`
- * 也不是 `{ok:false}` —— 两者都是在替一只不在场的判官发言)。
- *
- * @throws core 判官对**调用方 bug**(`command` 缺席/非串/不可渲染)的响亮拒**原样上抛**
- *         ——本包不吞它:吞掉会让一个调用方错误变成一句对人的判决(见模块头注「调用面契约」)。
- */
 export declare function precheckEditedRuleText(text: string, command: string): EditedRuleTextPrecheck | undefined;
-/** 测试钩:卸口。 */
 export declare function _resetEditedRuleTextPrecheckerForTest(): void;

package/dist/hitl/editedRuleTextPrecheck.js

@@ -1,63 +1,4 @@
-/**
- * editedRuleTextPrecheck.ts — 编辑臂的「边打字边校验」判官**转出口**(#225 / [5076] 自领件,0.42.0)。
- *
- * ## 这一格要解决的问题
- * 卡上的规则编辑框想在人还在打字的时候就说「这条能不能提交」。唯一合法的判官是引擎自己那只 ——
- * core 5.57.0 导出的纯函数 `precheckEditedRuleText(text, command)`,它与 `confirmRuleApproval` 的
- * fresh-edit 臂**跑同一个函数体**(`checkEditedRuleText`),所以预检面与真裁判**结构性不可分歧**。
- * 在边界上复读一遍 `parseAllowRuleText` 是**装第二个更严的判官**:`Bash(adb *)` 这类肌肉记忆形
- * 会被它当场误杀,而编辑面本来先跑拼写归一(`normalizeEditedSpelling`)再接受
- * ——[5071] 定界②的原话,core [5075] 复核确认。
- *
- * ## 🔴 为什么是**端口注入**而不是 `export { precheckEditedRuleText } from '@sema-agent/core'`
- * [5076] 的自领件原话是「re-export + 类型面」。**逐字照做在本包里是不可能的**,而且不是口味问题,
- * 是本仓门族的硬约束(0.42.0 施工时实测,证据两条):
- *   · `scripts/run-client-core-portability-test.mjs` 的 `EXPECTED_PACKAGES_INDEX` 是**等值门**
- *     ——包总入口闭包的外部包集合恒等于 `{diff, @sema-agent/sdk}`,多一个当场红;
- *   · 同门 ③ 段拿 esbuild `--platform=browser` **真打一次包**。`@sema-agent/core` 的 barrel 值级
- *     拉进 `node:crypto`(`engine/session/log-digest.js`)、`node:fs`/`node:path`
- *     (`core/skills-directory.js`)…… 浏览器腿当场打不成。
- * ⇒ 一个 value 级 re-export 会把**整台引擎**焊进每一个装 client-core 的端(web/desktop 首当其冲),
- *   换来一只纯函数。本包的存在理由正是「三端共用的**客户端**运行时」,这条边不能连。
- *
- * 于是转出口取**同等效力的第二形**:
- *   ① **类型面**逐形转出({@link EditedRuleTextPrecheck} / {@link EditedRuleTextPrechecker}),
- *      三端从此对着同一份形写代码,谁都不用自己抄一份返回型;
- *   ② **注入口**({@link installEditedRuleTextPrechecker}):Node 宿主(TUI / desktop 主进程 /
- *      server 侧渲染)在启动时把 core 那只函数原样装进来 —— **原样装,不许包一层判断**;
- *   ③ **读口**({@link precheckEditedRuleText}):没装 ⇒ 返 `undefined`(**诚实缺席**),
- *      绝不返一个编出来的 `{ok:true}`。缺席时呈现面的正解是退「提交后才知道」的往返形
- *      ——[5076] 施工要点③ 已经把这两段写成互不阻塞的两腿。
- * 🔴 浏览器 lane(web)结构上装不了这只函数(引擎不在那一侧),它**本就该**留缺席走往返形;
- *   本口的缺席语义因此不是「宿主忘了装」的同义词,别拿它去判部署形态。
- *
- * ## 🔴 两点语义预披露(core [5075],消费侧写文案前必读;[5076] 已落账为 #225 施工要点)
- *   · `ok` = **可提交**,不是「confirm 必成」。记录级闸(binding 回声 / 记录 owner 与 state /
- *     scope 继承 / 部署开关)**不在**预检覆盖面,由 `confirmRuleApproval` 对着记录重判。
- *     ⇒ UI 文案只许写「可提交」,**绝不**写「将被批准」。
- *   · `canonicalRule` 可能与输入**字节不同**(拼写归一)。它是真正会落库的那一形,所以内联反馈
- *     应当显示 **canonical 形**,而不是把人的输入原样回显。
- *
- * ## 调用面契约(core 逐字,注入口不许替它软化)
- *   · `text` 是**人**的输入 ⇒ 任何畸形拼写都是一个**答案**(refusal),永不抛;
- *   · `command` 是**调用方**的上下文(卡所依据的被裁决命令)⇒ 缺席/非串是**调用方 bug**,
- *     core 响亮抛(`config.invalid_argument`)。本包的读口**不吞这个抛**(见 {@link precheckEditedRuleText}
- *     的 `@throws`):把它折成一个 refusal 会让人读到「你的规则不接受空命令」——把调用方的错
- *     误归到人头上,正是 core 那段头注点名要避免的事。
- *   · 卡上**压根没有被裁决命令**(老记录 / 店丢了这一列)⇒ 那是**记录级**拒绝,不该问本函数;
- *     宿主此时的正解是**根本不给编辑框**。
- */
 let installed = null;
-/**
- * 装/卸判官。返回**还原函数**(装口族统一姿势:还原到装之前那一只,不是无脑清空 —— 嵌套装载
- * 时无脑清空会把外层那只一起抹掉)。
- *
- * Node 宿主的装法(**逐字**,别加工):
- * ```ts
- * import { precheckEditedRuleText } from '@sema-agent/core'
- * installEditedRuleTextPrechecker(precheckEditedRuleText)
- * ```
- */
 export function installEditedRuleTextPrechecker(fn) {
     const prev = installed;
     installed = fn;
@@ -65,27 +6,15 @@ export function installEditedRuleTextPrechecker(fn) {
         installed = prev;
     };
 }
-/**
- * 装没装(存在性读口哨兵:`boolean` 形 —— 见 `docs/INTEGRATION-CLIENTS.md` §5a 的三形分野)。
- * 呈现面据它决定**给不给编辑框的内联反馈**;`false` 时编辑框本身仍然可用(走往返形)。
- */
 export function hasEditedRuleTextPrechecker() {
     return installed !== null;
 }
-/**
- * 预检一段编辑过的规则文本。**没装判官 ⇒ 返 `undefined`**(诚实缺席,不是 `{ok:true}`
- * 也不是 `{ok:false}` —— 两者都是在替一只不在场的判官发言)。
- *
- * @throws core 判官对**调用方 bug**(`command` 缺席/非串/不可渲染)的响亮拒**原样上抛**
- *         ——本包不吞它:吞掉会让一个调用方错误变成一句对人的判决(见模块头注「调用面契约」)。
- */
 export function precheckEditedRuleText(text, command) {
     const fn = installed;
     if (fn === null)
         return undefined;
     return fn(text, command);
 }
-/** 测试钩:卸口。 */
 export function _resetEditedRuleTextPrecheckerForTest() {
     installed = null;
 }