@sema-agent/client-core 0.77.1 → 0.78.0

package/dist/hitl/sessionPolicyWire.js

@@ -1,57 +1,4 @@
-/**
- * hitl/sessionPolicyWire.ts — **会话策略写端口**:per-session 工具规则(`GET` / `PUT /v1/sessions/:id/policy`)
- * 的三端共用窄读 + 收紧编排(0.77.0 CC-105)。
- *
- * ── 它与常驻规则那一面是**两个面**,不是一个面的两半 ────────────────────────────────────────────
- * 常驻规则面是**跨会话**的治理清单(按内容寻址、可列举、可撤销);本面是**一条会话**上的一份记录:
- *   · 作用域 = 这条会话(键还是这条会话的属主,不是调用者;非属主读到的是「没有这条会话」);
- *   · 方向 = **只许收紧**,放宽方向由引擎拒(本包不复述那条判据,见下);
- *   · 并发 = 记录上盖着一枚单调版本号,写入带上它做乐观并发(不带 = 不做并发校验,本包从不这么发)。
- * 所以它**不住进**常驻规则那只门面;但失败分类与回执读口的**姿势**照它:错误按状态 + 机器码结构读
- * (不 `instanceof`:注入面可能是假件,打包后 `instanceof` 也不该是承重判据),回执只认已过窄化的形。
- *
- * ── 🔴 整份替换,所以「追加一条限制」必须把旧的一起发 ───────────────────────────────────────────
- * 写入口的语义是**整份记录替换**,不是逐字段合并:提交体里省掉的字段等于把那个字段的限制**清空**。
- * 于是「只发新增的那条」在引擎眼里是一次**放宽**,当场被拒。本编排因此是「读 → 已有 ∪ 新增 → 整份回写」:
- *   · 并集的**键**就是规则记录自己的那几只桶,键集由引擎型面**派生**(下面的 `RULE_FIELD_PRESENCE`
- *     `satisfies` 表)——引擎加一只桶 ⇒ 本文件**编译红**,而不是「静默丢一桶 + 回执说已生效」;
- *   · 每只桶内按**逐字去重**并集(旧的在前、新的在后,原样字节,不做规范化)。路径一类的规范拼写归引擎,
- *     壳替它改写会让两端对「同一条限制」各有一份判据;
- *   · 🔴 旧记录里**在场的空桶照样保留成空桶**:一只「设了但是空」的白名单与「没设」在语义上是相反的两件事
- *     (前者= 什么都不放行,后者 = 不设这类限制),把它丢掉就是一次放宽。
- *
- * ── 🔴 收紧到底怎么判,判官只有一个 ─────────────────────────────────────────────────────────────
- * 「哪些差异算放宽」的判据在引擎侧(逐桶方向各不相同:禁止名单删条目算放宽;白名单加条目、整只白名单
- * 消失算放宽;目录限制解除或多出一个不在原限制之内的目录算放宽)。本包**不铸第二份**:按「已有 ∪ 新增」
- * 写,判定留给引擎,收到放宽拒绝**原样上报、不吞不重试**。
- * ⚠️ 并集写在结构上消不掉**删除方向**的放宽(旧条目一条不少),但消不掉**加宽方向**的:
- * 端把一条放宽方向的条目(例如往白名单或目录限制里加一项)放进 `add`,并集里就真多一项,引擎会判放宽并拒。
- * **本包不预判这件事** —— 出现放宽拒绝时,事实就是「端喂了放宽方向的条目」,措辞据此指路。
- * 🔴 **但那条拒绝只对普通调用方成立**:上游的方向门是**身份门**,不是字段门 —— 被部署判为运维身份的调用方
- * 写入时方向判据**根本不跑**,于是同一份「已有 ∪ 新增」在运维身份上会**被接受**,而其中往白名单 / 目录限制里
- * 加的那一项就是一次真的放宽。所以本编排的 `written` 只承诺一件事:**记录现在等于原有的加上送来的**;
- * 它**不**承诺「这条会话变严了」,措辞也一个字都不这么说(方向的判官只有引擎一个,而它对运维身份不设门)。
- * 端要的若是「无论谁调用都只会更严」,那需要一个不受身份豁免的写模式,而这条 wire 上今天没有。
- *
- * ── 🔴 生效时机 ────────────────────────────────────────────────────────────────────────────────
- * 够新的引擎在**每一道工具门**重读这份记录 ⇒ 一条 run 跑着的时候写下的收紧,**同一条 run 的下一道工具门**
- * 就拒;更早的引擎只在起手读一次,收紧要等下一条 run。本包**不据此做任何判据**(它是引擎版本的函数,
- * 而这条 wire 上没有位回答它),只在措辞里如实说「下一道工具门」并且不承诺「立刻打断正在跑的那一步」。
- *
- * ── 🔴 三种「没读到」不许互折 ──────────────────────────────────────────────────────────────────
- * 窄读三向:**真空**(记录在、一条限制都没有 —— 这台引擎对一条还没写过策略的会话就这么答,版本号为 0)/
- * **读不懂**(信封、版本号、任一只桶的形不对)/ **调用失败**(带 typed 分类)。读不懂**绝不**折成「空策略」——
- * 折了之后并集写会把一份读不懂的旧记录当成空的整份覆盖上去,那是一次**静默的整面放宽**。
- * 同样,写回执读不懂**绝不**答「已写」:那一次很可能真的落了盘,答案是「不知道」,不是「成功」也不是「失败」。
- *
- * ── UNTRUSTED ─────────────────────────────────────────────────────────────────────────────────
- * 规则文本是部署侧/用户侧的内容,只当字节搬运与渲染,绝不当代码用;桶内逐条只判「是不是字符串」,
- * 内容文法归引擎。
- */
 import { hostLog } from '../host.js';
-// ── 桶名全集(派生,不是手抄)────────────────────────────────────────────────────────────────
-/** 🔴 **唯一**目的是让桶名集合从引擎的型面派生:引擎加一只桶 ⇒ 这里缺键 ⇒ **编译红**;删一只 ⇒ 多键 ⇒ 同样编译红。
- *  值无语义。这条纪律在整份替换的语义下是承重的:一只没被并集带上的桶 = 一次静默放宽。 */
 const RULE_FIELD_PRESENCE = {
     toolAllow: true,
     toolDeny: true,
@@ -59,13 +6,7 @@ const RULE_FIELD_PRESENCE = {
     commandAllow: true,
     commandDeny: true,
 };
-/**
- * 规则记录的桶名全集。**派生自上表**,不是另一份手抄件。
- * 🔴 形制:`Object.freeze` 的数组,**不是**只在类型面只读的 `readonly T[]` —— 后者一行 `.splice()` 就能改,
- *    而公面消费者拿到的正是这个实例。
- */
 export const SESSION_POLICY_RULE_FIELDS = Object.freeze(Object.keys(RULE_FIELD_PRESENCE));
-/** 一只桶最多认多少条。超过 ⇒ 判**读不懂**,而不是截断:一份被截短的授权记录整份回写就是一次放宽。 */
 const MAX_RULE_ENTRIES = 10_000;
 function errShape(e) {
     const o = (e ?? {});
@@ -75,15 +16,8 @@ function errShape(e) {
         message: typeof o.message === 'string' && o.message !== '' ? o.message : String(e),
     };
 }
-/**
- * 抛出来的东西 → 处置分类。
- * 🔴 **并发冲突按机器码逐字认,不按 409 状态认**:同一个 409 上骑着两个码(并发不符 / 会话无属主),
- * 而后者重试多少次都是同一个答案。没带码的 409 一律落通用臂 —— 猜一个码去重试,代价是无穷重试。
- */
 export function classifySessionPolicyFailure(e) {
     const { status, errorCode, message } = errShape(e);
-    // 🔴 出处先于状态码:没有机器码 ⇒ 证明不了是引擎在答(见 `no-verdict` 的注)。状态码本身在这里不是证据 ——
-    //    一页 HTML 405 与引擎的 405 状态码相同、出处相反,前者可能骑在一次已经落盘的写上。
     if (errorCode === undefined || errorCode === '')
         return { kind: 'no-verdict', message };
     if (status === 501 || errorCode === 'capability.session_store_required') {
@@ -91,8 +25,6 @@ export function classifySessionPolicyFailure(e) {
     }
     if (errorCode === 'loosen_forbidden')
         return { kind: 'loosen-forbidden', message };
-    // 🔴 与上一行**同一个状态码**、不同的机器码:规则店读不出记录的存活标记而拒盖新版本号。
-    //    没有这一行时它会落进通用臂,措辞就会去劝人改自己送的条目 —— 而条目一个字都没错。
     if (errorCode === 'corrupt')
         return { kind: 'store-corrupt', message };
     if (errorCode === 'conflict')
@@ -107,19 +39,10 @@ export function classifySessionPolicyFailure(e) {
         return { kind: 'unauthorized', message };
     if (status === 400 || status === 413 || status === 422)
         return { kind: 'request-rejected', message };
-    // 🔴 末两行的分界是**「引擎到底答没答」**,不是「认不认得这个码」:
-    //    · 没有状态码(一个带码却没状态的对象不是传输层交出来的形)⇒ 引擎的裁决**没到手**;
-    //    · 5xx ⇒ 引擎答了一句「我这边炸了」,那句话**证明不了**提交没落盘(提交成功而回程失败是同一形)。
-    //    这两种都归 `no-verdict`;剩下的(引擎带码答了一个客户端侧拒绝)才允许说「什么都没写」。
     if (status === undefined || status >= 500)
         return { kind: 'no-verdict', message };
     return { kind: 'error', message };
 }
-/**
- * 一只桶的逐条窄读:`length` 恰读一次、每个下标恰读一次(变化的数组读两遍会让一条限制静默消失)。
- * 🔴 **下标必须是数组自己的**(`hasOwn`):稀疏数组的洞在原型被污染时会读出一个别人放进去的值,
- *    而这里读出来的每一条都会被并集**原样写回**去 —— 那就等于把一条 wire 上根本不存在的限制写成真的。
- */
 function narrowBucket(raw, field) {
     if (!Array.isArray(raw))
         return { ok: false, detail: `rule field "${field}" is not an array` };
@@ -140,19 +63,10 @@ function narrowBucket(raw, field) {
     }
     return { ok: true, list };
 }
-/**
- * `{ rules }` 信封 → 承重键(版本号 + 五只桶)。
- * 🔴 **半坏就是坏**:一只桶好、另一只桶形不对 ⇒ 整份判读不懂。丢掉坏的那只再整份回写 = 把那只桶清空 =
- *    一次放宽,而调用方会看到一个 200。
- */
 function narrowStoredRecord(body) {
     if (body === null || typeof body !== 'object' || Array.isArray(body)) {
         return { ok: false, why: 'envelope', detail: 'policy response is not an object' };
     }
-    // 🔴 承重键**逐个按 own-property 读**(异源对抗复审 R2 [medium],真病):`src[field]` 会沿原型链取值,
-    //    于是一次原型污染(或一只被注入的假 facade 交出带继承键的对象)能让 wire 上**没有**的那只桶
-    //    出现在读数里 —— 而写口是整份替换,并集会把它当成一条真限制写回去。方向上这不是「多读了一格」,
-    //    是**凭空造出一条授权规则**。信封、版本号、五只桶、数组下标一律同律。
     if (!Object.hasOwn(body, 'rules')) {
         return { ok: false, why: 'envelope', detail: 'policy response carries no rules record of its own' };
     }
@@ -182,11 +96,6 @@ function narrowStoredRecord(body) {
     }
     return { ok: true, rev, rules };
 }
-/**
- * 读这条会话当前的规则记录。
- * 🔴 记录**真的空**(一只桶都没有、版本号 0)是这台引擎对「还没写过策略的会话」的诚实答案,
- *    它与「读不懂」是两个结局;调用方据此知道下一次写该带哪一个版本号。
- */
 export async function readSessionPolicy(facade, sessionId, opts) {
     let body;
     try {
@@ -200,29 +109,17 @@ export async function readSessionPolicy(facade, sessionId, opts) {
         read = narrowStoredRecord(body);
     }
     catch {
-        // 抛出的 getter / 被撤销的代理:与「形不对」同一处置,绝不外抛到调用方的编排里。
         read = { ok: false, why: 'envelope', detail: 'policy response could not be read' };
     }
     if (!read.ok)
         return { kind: 'malformed', why: read.why, detail: read.detail };
     return { kind: 'present', rev: read.rev, rules: read.rules };
 }
-// ── 并集(整份替换下的「追加一条限制」)────────────────────────────────────────────────────────
-/**
- * 「已有 ∪ 新增」。**只加不减**:旧记录的每一只桶、每一条条目都原样留在结果里(在场的空桶保留成空桶),
- * 新增的条目逐字去重后接在后面。两边都没有的桶**不铸**(凭空铸一只空桶 = 凭空加一条限制)。
- * 🔴 条目字节原样搬运:不 trim、不规范化路径、不排序 —— 那些都是引擎的判据,壳再做一遍就是第二份。
- */
 export function tightenedSessionRules(prior, add) {
-    // 🔴 两侧都过读腿那**同一只**窄化器(`hasOwn` 桶名 + `hasOwn` 下标 + 逐条是字符串),不信任任何一侧:
-    //    `hasOwn` 只护得住桶名,桶内若直接 `for…of`,走的是数组迭代器 —— 稀疏数组的洞会沿原型链读出别人放进去的值,
-    //    而并集结果是**整份写回去**的(读腿堵住的那条原型污染路径不许在写腿重新打开)。
-    //    坏的一侧是调用方的入参 ⇒ 抛具名错误(不是引擎的 request_rejected,不许混进那一臂)。
     const p = narrowRulesInput(prior, 'prior');
     const a = narrowRulesInput(add, 'add');
     const out = {};
     for (const field of SESSION_POLICY_RULE_FIELDS) {
-        // 窄化副本是普通对象:读桶仍按自有键(一次原型污染会让每只普通对象都「带着」一只桶)。
         const pl = Object.hasOwn(p, field) ? p[field] : undefined;
         const al = Object.hasOwn(a, field) ? a[field] : undefined;
         if (pl === undefined && al === undefined)
@@ -245,12 +142,6 @@ export function tightenedSessionRules(prior, add) {
     }
     return out;
 }
-/**
- * 调用方交来的一份规则记录 → 已窄化的副本(每只在场桶都是自有的、稠密的、逐条字符串的新数组)。
- * 🔴 与 wire 回体的窄读是**同一只**桶级判据(`narrowBucket`);差别只在处置:回体读不懂是「不知道」,
- *    入参读不懂是调用方的编程错误 ⇒ `TypeError` 点名是哪一侧、哪只桶(不回显条目内容)。
- *    显式 `undefined` 的桶 = 缺席;原型链上的桶不算在场(它们也上不了 wire)。
- */
 function narrowRulesInput(raw, side) {
     if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
         throw new TypeError(`tightenedSessionRules: "${side}" must be a rules record object`);
@@ -269,14 +160,6 @@ function narrowRulesInput(raw, side) {
     }
     return out;
 }
-/**
- * 写回执对提交体的**对账**:回执读得懂之后,还要证明它说的是**这一次**提交。
- * 上游契约:成功回执 = 规范化后的提交体 + 严格大于并发键的新版本号(戳 = max(当前, 高水位) + 1)。
- * 所以:版本号没推进 / 送出去的桶不在回执里 / 送出去的条目不在回执桶里 ⇒ 回执证明不了这次落了盘。
- * 目录桶由引擎做词法规范化(回执条目可以与送出的字节不同),那一只**只核在场**,逐条判据归引擎。
- * 回执桶是提交的超集不算失配(`written` 承诺的是「记录含有原有的加上送来的」,不是逐字相等)。
- * 返回 `null` = 对上了;否则一句可渲染的失配说明。
- */
 function receiptMismatch(sent, receipt, sentRev, receiptRev) {
     if (receiptRev <= sentRev) {
         return `policy write receipt did not advance the version stamp (sent with ${sentRev}, receipt says ${receiptRev})`;
@@ -298,7 +181,6 @@ function receiptMismatch(sent, receipt, sentRev, receiptRev) {
     }
     return null;
 }
-/** 成因闭集的运行期镜像(冻结)。 */
 export const SESSION_POLICY_TIGHTEN_UNKNOWN_WHY = Object.freeze([
     'face_unavailable',
     'session_not_found',
@@ -328,12 +210,8 @@ function unknownFrom(failure, leg) {
             return { kind: 'unknown', why: 'request_rejected', message };
         case 'store-corrupt':
             return { kind: 'unknown', why: 'store_corrupt', message };
-        // 🔴 读腿没有副作用 ⇒ 无论引擎答没答,「什么都没写」都是真的,两种失败合成 read_failed;
-        //    写腿必须把两者**分开**:引擎带码答了拒绝 ⇒ 确实没写;裁决没到手(含没码的 4xx)⇒ 可能已经落盘,不许说成没送到。
         case 'no-verdict':
             return { kind: 'unknown', why: leg === 'read' ? 'read_failed' : 'write_indeterminate', message };
-        // 下面两条在这条腿上不该出现(调用点已先行分流);真出现了 = 引擎在这条腿上说了另一条腿的话,
-        // 照通用臂报,绝不在这里替它改判。
         case 'loosen-forbidden':
         case 'cas-conflict':
         case 'error':
@@ -345,7 +223,6 @@ async function attemptTighten(facade, req, opts) {
     if (read.kind === 'failed')
         return { done: unknownFrom(read.failure, 'read') };
     if (read.kind === 'malformed') {
-        // 🔴 读不懂 ⇒ 停手。把它当空记录并集回写,等于用一份「什么限制都没有」的记录整份覆盖真记录。
         return { done: { kind: 'unknown', why: 'read_unreadable', message: read.detail } };
     }
     const rules = tightenedSessionRules(read.rules, req.add);
@@ -369,32 +246,14 @@ async function attemptTighten(facade, req, opts) {
         narrowed = { ok: false, why: 'envelope', detail: 'policy write receipt could not be read' };
     }
     if (!narrowed.ok) {
-        // 🔴 这一臂**不是**失败:写很可能落了盘,只是回执说不清。答「不知道」,绝不答「已写」。
         return { done: { kind: 'unknown', why: 'write_receipt_unreadable', message: narrowed.detail } };
     }
-    // 🔴 回执只验形就认 `written` 是谎报:一份形好、但版本号没推进或不含送出条目的回执(版本偏斜 / 错误回包 /
-    //    中间层缓存)证明不了这次提交落了盘。对账不过 ⇒ 与「回执读不懂」同一处置方向(可能已生效,先重读)。
     const mismatch = receiptMismatch(rules, narrowed.rules, read.rev, narrowed.rev);
     if (mismatch !== null)
         return { done: { kind: 'unknown', why: 'write_receipt_mismatch', message: mismatch } };
     return { done: { kind: 'written', rev: narrowed.rev } };
 }
-/**
- * 给这条会话**追加**一组限制:读当前记录 → 「已有 ∪ 新增」→ 带当前版本号整份回写。
- *
- * 🔴 **只重读重写一次**(结构上,不靠计数器:本函数里没有循环)。撞上并发键说明有别的写者在同一条
- * 会话上推进了记录;重来一趟是为了把对方刚写进去的限制也一并带上(并集只加不减,所以重来是**收敛**的)。
- * 第二趟仍撞 ⇒ 如实上报 `conflict`:第三趟不比第二趟更有理由成功,而一个自己会无限重试的写腿在争用下
- * 会把一条会话的规则记录变成两个写者的角力场。
- * 🔴 能力位明说没有这一面(或这份二进制比这一位还老)⇒ **一个请求都不发**;从没观测过 ⇒ **照发** ——
- * 「本进程没探过能力面」是本进程的缺陷,不是引擎的否定,把它当否定会让一次用户已经点过的动作凭空落空。
- * 那两条的分家写在 `sessionPolicyFaceAvailable` 的头注里(渲不渲入口 vs 动不动网络是两个问题)。
- */
 export async function tightenSessionPolicy(facade, req, opts) {
-    // 入参形先于一切(能力位判据、网络):坏的 `add` 是调用方的编程错误,在任何往返之前抛,不借引擎的 request_rejected。
-    // 🔴 入口窄化出的副本就是**发出去的那一份**,两趟(首趟 / CAS 重试)共用;`sessionId` / 能力位同样只读一次 ——
-    //    编排里有 await,调用方在 GET 等待期间复用 / 清空表单数组、或访问器第二次给别的值,都不许改动已声明的限制
-    //    (否则已声明的拒绝会静默消失,而回执对账只能核被改过的提交体)。
     const snapshot = {
         sessionId: req.sessionId,
         add: narrowRulesInput(req.add, 'add'),
@@ -413,14 +272,6 @@ export async function tightenSessionPolicy(facade, req, opts) {
         return second.done;
     return { kind: 'conflict', rev: second.retryAtRev };
 }
-// ── 措辞(唯一真源;端只拼接不另写)────────────────────────────────────────────────────────────
-/**
- * 一次收紧结局的人话,**唯一措辞真源**。
- * 🔴 三条不许说反:① 放宽被拒那一句要指向「送出去的那组条目里有放宽方向的」,不许说成引擎坏了或没权限;
- *    ② 并发那一句要说「记录又被别人动了」并把下一步交出去,不许说成已写;③ 回执读不懂那一句**必须**
- *    说「可能已经生效」——把它说成失败,人会再写一遍,而那一遍会把已经生效的那条当成新增重发。
- * 生效时机只说「下一道工具门」,不承诺打断正在跑的那一步。
- */
 export function sessionPolicyTightenNotice(outcome) {
     switch (outcome.kind) {
         case 'written':

package/dist/hitl/suspendedReopen.d.ts

@@ -1,30 +1,9 @@
-/**
- * suspendedReopen — durable `suspended` 事件上 server 的**重开侧记键** `reopened` 的三态读口(0.74.3 CC-73;
- * 契约 reopen 族段:`GET /v1/runs/{taskId}/events` 的 `suspended` 事件带 `reopened: <errorCode>`,「缺席 / null =
- * 这次 park 不是重开」;sdk `events.d.ts` `reopened?: string | null`,普通挂起帧不带此键)。
- *
- * ── 🔴 为什么是三态而不是「是 / 不是」两态 ─────────────────────────────────────────────────
- * 契约把「缺席」和「null」判成同一句话,但两者的**说话人不同**:`null` 是新 server 明说「不是重开」;键缺席既可能是
- * 新 server 的普通挂起帧,也可能是根本没有这个键的老 server。把两者折成一个值,消费方就再也分不出「server 说了不是」
- * 与「server 什么都没说」。读口把它们分开带出,消费方按契约把 `unstated` **当作**不是重开即可,但不替 server 说那句话。
- *
- * 码是**开集原词**(词表属主在 server:今天三员 `resume.env_failed` / `resume.tool_unavailable` /
- * `resume.tool_contract_mismatch`,见 `engineErrorCodes.ts` `RESUME_REOPEN_CODES`),本读口不过滤;要文案的消费方拿码去查表。
- */
-/** `suspended.reopened` 的读数。 */
-export type SuspendedReopenReading = 
-/** 键在场且是非空串:这条挂起是一次**重开**,`code` = server 给的 errorCode 原词。 */
-{
+export type SuspendedReopenReading = {
     readonly kind: 'reopened';
     readonly code: string;
-}
-/** 键在场且显式 `null`:server 明说这次 park 不是重开。 */
- | {
+} | {
     readonly kind: 'not_reopened';
-}
-/** 键缺席(或值读不出):server 没说;按契约当作不是重开,但不冒充 `null`。 */
- | {
+} | {
     readonly kind: 'unstated';
 };
-/** 任意事件体 → 三态读数;非对象 / 坏形一律 `unstated`,永不抛。 */
 export declare function suspendedReopenOf(ev: unknown): SuspendedReopenReading;

package/dist/hitl/suspendedReopen.js

@@ -1,19 +1,5 @@
-/**
- * suspendedReopen — durable `suspended` 事件上 server 的**重开侧记键** `reopened` 的三态读口(0.74.3 CC-73;
- * 契约 reopen 族段:`GET /v1/runs/{taskId}/events` 的 `suspended` 事件带 `reopened: <errorCode>`,「缺席 / null =
- * 这次 park 不是重开」;sdk `events.d.ts` `reopened?: string | null`,普通挂起帧不带此键)。
- *
- * ── 🔴 为什么是三态而不是「是 / 不是」两态 ─────────────────────────────────────────────────
- * 契约把「缺席」和「null」判成同一句话,但两者的**说话人不同**:`null` 是新 server 明说「不是重开」;键缺席既可能是
- * 新 server 的普通挂起帧,也可能是根本没有这个键的老 server。把两者折成一个值,消费方就再也分不出「server 说了不是」
- * 与「server 什么都没说」。读口把它们分开带出,消费方按契约把 `unstated` **当作**不是重开即可,但不替 server 说那句话。
- *
- * 码是**开集原词**(词表属主在 server:今天三员 `resume.env_failed` / `resume.tool_unavailable` /
- * `resume.tool_contract_mismatch`,见 `engineErrorCodes.ts` `RESUME_REOPEN_CODES`),本读口不过滤;要文案的消费方拿码去查表。
- */
 const UNSTATED = Object.freeze({ kind: 'unstated' });
 const NOT_REOPENED = Object.freeze({ kind: 'not_reopened' });
-/** 任意事件体 → 三态读数;非对象 / 坏形一律 `unstated`,永不抛。 */
 export function suspendedReopenOf(ev) {
     if (ev === null || typeof ev !== 'object' || Array.isArray(ev))
         return UNSTATED;