@sema-agent/client-core 0.57.0 → 0.59.0

package/dist/hitl/toolApprovalWire.js

@@ -83,6 +83,19 @@ import { createSessionSlot, DEFAULT_SESSION_KEY } from '../sessionSlot.js';
 import { readEngineActiveBgTasks } from '../fleet/fleetLedger.js';
 import { observeCancelByDeny, surfaceRememberNotApplied, surfaceEditNotForwarded, surfaceRuleArmNotSent, surfaceRuleArmRejected } from './hitlHostSurface.js';
 import { approvalCallKey, liveFrameCallKey } from './gateIdentity.js';
+// ── sdk 8.2.0 单源闭词表(S-134 锚②;0.58.0 提货批 / B-025 修根)──────────────────────────────
+// 🔴 **值级 import,不是 type-only**:三张 `as const` 数组是**运行期**判据(窄读器按它判 kind /
+//    match 是不是闭集成员)。本包此前把 `match` 的二词闭集**手抄**在读器里,而 core design/382 /
+//    #510 把词表扩到四员、batch 成员加了 `directoryRead` 臂 —— 手抄的那份没跟,合法候选被整条/
+//    整只丢掉(B-025)。单源化之后「词表加员」这件事在**上游一处**发生,本包跟着走。
+// 🔴 值级 import 的代价已记账:peer 地板随本批抬到 `>=8.2.0`(run-sdk-floor-test.mjs 的 ①c 把
+//    声明与门常量逐位绑死),包总入口闭包的外部包集合仍恒等于 `{diff, @sema-agent/sdk}`(singleton 门)。
+// ── sdk 8.3.0 单源闭词表(S-125③ / S-114 / S-15 第五单;0.59.0 提货批)────────────────────────
+// 同上一条纪律的第二例:`ruleOffersAbsence` 的三词、`denialLimitFallback.limit` 的二词都是
+// **上游属主**的闭集。本包**不拿它们做窄读判定**(两处都按开集透传,见各自帧键 JSDoc),再导出
+// 的用途是让三端写 `switch` 时有一份**与包同一个数组对象**的词表可数,而不是各自抄字面量 ——
+// B-025 的根因正是手抄。⇒ 值级 import 让 peer 地板在编译期真被钉到 8.3.0。
+import { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS, RULE_OFFERS_ABSENCE_REASONS, DENIAL_LIMIT_KINDS, } from '@sema-agent/sdk';
 /** fs 写权限 gate 判定:未来的一等 kind(tool_approval)或按 toolName(server 桥首批=fs 写三件,
  *  [820] 表)。AskUserQuestion 永不进这里(ask 桥先判)。 */
 export function isFsApprovalGate(gate) {
@@ -132,6 +145,22 @@ export function structurallyEqual(a, b) {
         return false;
     return ka.every(k => structurallyEqual(a[k], b[k]));
 }
+/**
+ * 三张闭词表的**运行期**再导出(sdk 8.2.0 `as const` 单源)。
+ *
+ * 🔴 **端拿它做判定,别再手抄字面量** —— 本包自己的窄读器就读这两张表(B-025 的根因正是手抄);
+ *    再导出让三端与包**共用同一份数组对象**,词表加员时一处改、四处跟。
+ */
+export { RULE_OFFER_MATCHES, RULE_OFFER_BATCH_MEMBER_KINDS, RULE_OFFER_UNCOVERED_REASONS };
+/**
+ * 两张新闭词表的**运行期**再导出(sdk 8.3.0 `as const` 单源;与上面三张同一条纪律)。
+ *
+ * ⚠️ **本包自己不拿它们做窄读判定**,这与 `RULE_OFFER_MATCHES` 一族刻意不同,理由写在两处帧键的
+ *    JSDoc 里:`origin` 与 `ruleOffersAbsence` 的词表属主是 core、server 侧已按闭集拒过词表外的值,
+ *    包再校一遍只会在 core 加员当天把一个**合法**值判没(`wiring_manifest.autoMode.reason` 的
+ *    透传纪律逐字同规)。再导出是给端的 `switch` 一份可数的表 —— 端仍必须带 `default` 臂。
+ */
+export { RULE_OFFERS_ABSENCE_REASONS, DENIAL_LIMIT_KINDS };
 // W1(design/161):sessionKey → 注册表;零参 API = DEFAULT_SESSION_KEY 兼容层(cli 装配不动)。
 const cardPortByKey = createSessionSlot();
 const cardPortMissesByKey = new Map();
@@ -424,16 +453,29 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'governanceForced',
     // sdk 6.14.0 追平(#225 件1,client-core 0.26.0):server 7.12.0 起真发规则候选 —— 门
     // (run-approval-frame-keys-test.mjs)在 bump SDK 当天恰红抓获本键缺席,本次补齐。
-    // ⚠️ **退役键**(server 7.46.0 起同文件 0 命中):留在镜像里是因为 sdk 7.2.0 的运行期锚仍含它,
+    // ⚠️ **退役键**(server 7.46.0 起同文件 0 命中):留在镜像里是因为 sdk 8.2.0 的运行期锚仍含它,
     // 删了对账门的「SDK 锚的每个键本仓都有」当场红;本包对它只做归一读(见帧上同名键的 JSDoc)。
     'ruleSuggestions',
     // #334/[5223](client-core 0.43.0):server 7.46.0 起把规则候选整体换成判别联合 `ruleOffers`
     // (core 5.58.0 design/375;engine 7.46.0 fixture 的 `@sema-agent/server/dist/tool-approval.d.ts`
-    // 直证,同文件旧键 0 命中)。sdk 7.2.0 锚**尚无**本键 ⇒ 与 `requiresRealApproval`/窗三键同形=
-    // **领先**,进对账门 AHEAD_OF_ANCHOR 带退出条件登记。
+    // 直证,同文件旧键 0 命中)。✅ **sdk 8.2.0 锚已含本键**(S-134 锚②)⇒ 0.58.0 提货批按退出
+    // 条件删掉了对账门里那条 AHEAD_OF_ANCHOR 领先登记,本键回到「逐元素相等」的常态。
     'ruleOffers',
+    // S-15 第五单(client-core 0.59.0):server 7.55.0 起真发 `ruleOffersAbsence`(core #490 修②;
+    // engine 7.60.0 fixture 直证)。⚠️ 与 `ruleOffers` **同形不同命**:它是**追平**不是领先 ——
+    // sdk 8.3.0 的运行期锚已含本键(node 直读 27 项实证)⇒ **不**进 AHEAD_OF_ANCHOR
+    // (往那张表里塞一个锚已有的键,它的第二条退出条件当场红)。
+    'ruleOffersAbsence',
+    // S-114(client-core 0.59.0):server 7.57.0 起真发 `denialLimitFallback`(core 7.4.0 #548;
+    // engine 7.60.0 fixture 直证)。同上一条:sdk 8.3.0 锚已含本键 ⇒ 追平,不进领先表。
+    // 🔴 本键与 `requiresRealApproval` 是孪生键,但两者在镜像里各占一格 —— 合并会让「只有一位在场」
+    //    的坏形无处显形。
+    'denialLimitFallback',
+    // S-125③/#564(client-core 0.59.0):server 7.57.0 起真发 `origin`(core 7.5.0 `ASK_ORIGINS`
+    // 八词;engine 7.60.0 fixture 直证)。同上:sdk 8.3.0 锚已含本键 ⇒ 追平,不进领先表。
+    'origin',
     // #341/[5214]③(client-core 0.43.0):server 7.46.0 起真发 `inputHasBidi`(E-14 Trojan Source 族;
-    // 7.44 fixture 同文件 0 命中)。同样**领先** sdk 7.2.0 锚 ⇒ AHEAD_OF_ANCHOR 登记。
+    // 7.44 fixture 同文件 0 命中)。仍**领先** sdk 8.2.0 锚(node 直读 18 项无本键)⇒ AHEAD_OF_ANCHOR 登记。
     'inputHasBidi',
     // 🔴 **同形族扫的产物**(client-core 0.43.0,[same-shape-residue-constitution]):本批的病形是
     // 「镜像滞后于 server 实发键」。族扫 = 把 engine 7.46.0 fixture 的 `ToolApprovalFrame` 23 个声明键
@@ -463,7 +505,7 @@ export const TOOL_APPROVAL_FRAME_KEYS_MIRROR = [
     'requiresRealApproval',
     // [4851] 头号请托(client-core 0.38.2):server 7.34.0 起真发窗三键(#288/[4429]② cli 自己请托,
     // server src/tool-approval.ts 三键声明+条件 stamp)。⚠️ 与 requiresRealApproval 同形=**领先** SDK
-    // 运行期锚(sdk 7.2.0 锚 17 项,node 直读实证无三键)⇒ 进对账门 AHEAD_OF_ANCHOR 带退出条件登记
+    // 运行期锚(sdk 8.2.0 锚 18 项,node 直读实证无三键)⇒ 进对账门 AHEAD_OF_ANCHOR 带退出条件登记
     // (SDK 追平当天登记自红逼删)。0.38.1 把三键丢在包边界外 = [4845]「卡到期屏幕零反应」的直接成因
     // (壳读器 readAskDeadlineMs 早已预埋,缺的一直是包边界这一格——#283 逐字同形第四例)。
     'expiresInMs',
@@ -816,8 +858,56 @@ function isWireRecordCarrier(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
 /**
- * 一条 offer / 一个 batch 成员共用的三位窄化(`rule` 非空串 + `match` 二词闭集 + `command` 非空串)。
- * 任一不合形 ⇒ `undefined`(半条候选渲出来是一格没有正文、按下去必被 server 拒的选项)。
+ * `denialLimitFallback` 的**窄读器**(S-114,0.59.0)—— wire 是 JSON:注入面 / 旧 server / 比本包新
+ * 一版的 server 都可能给别的形,坏形一律降**缺席**(与 `readToolApprovalDelegation` 同族纪律)。
+ *
+ * 🔴 **四成员全必填,缺一整只丢**(与 server `approval-card.ts` 的 `readDenialLimitFallback`
+ *    `.strict()` 同判据,与 core 的形一字不差):半只对象上的 `consecutive` 会被人当成**真实的
+ *    连续拒次数**读,而它可能只是一个恰好在场的键。「一格空白的计数」比不渲这张卡更坏。
+ * 🔴 **两个计数与窗按「有限非负数」判,不折 0**:`Number.isFinite` 单独会放行负数,而三者的定义域
+ *    按上游契约本就非负(计数是次数,窗是 ms 且 `0` = 不武装,是**合法读数**不是缺席)。
+ *    NaN / Infinity / 负数 = 坏形降缺席,**绝不猜**(同文件 `delegation.depth` 的旧教训)。
+ * 🔴 **`limit` 按开集读**(非空串即收):闭二词表 `DENIAL_LIMIT_KINDS` 只作再导出给端数,
+ *    包内**不拿它做判定** —— 词表属主是 core,抄一份就是给自己立第二个判官(B-025 的病形);
+ *    server 侧已按闭集拒过词表外的值,包再校一遍只会在 core 加员当天把一个合法值判没。
+ *    ⚠️ 这条与「四成员全必填」不矛盾:必填说的是**在场性**,开集说的是**取值域**。
+ */
+function readDenialLimitFallback(v) {
+    if (!isWireRecordCarrier(v))
+        return undefined;
+    const d = v;
+    if (!isNonNegativeFinite(d.consecutive))
+        return undefined;
+    if (!isNonNegativeFinite(d.total))
+        return undefined;
+    if (!isNonNegativeFinite(d.autoDenyAfterMs))
+        return undefined;
+    if (typeof d.limit !== 'string' || d.limit === '')
+        return undefined;
+    return {
+        consecutive: d.consecutive,
+        total: d.total,
+        limit: d.limit,
+        autoDenyAfterMs: d.autoDenyAfterMs,
+    };
+}
+/**
+ * `match` 是不是**闭词表成员** —— 表来自 sdk 8.2.0 `RULE_OFFER_MATCHES`(`exact` / `prefix` /
+ * `wildcard` / `subpath`),**本包不再手抄字面量**。
+ *
+ * 🔴 **B-025 的根因就是手抄**:0.43.0 铸这只读器时按当时 server 的两员词表写死
+ *    `match !== 'exact' && match !== 'prefix'`,core design/382 / #510 扩到四员之后这里没跟 ⇒
+ *    一条合法的 `wildcard` / `subpath` 候选被判成坏形丢掉。读同一张 `as const` 数组之后,
+ *    「词表加员」在上游一处发生,本包自动跟上;门里另有**双向全等钉**(本包认的词集 ≡ sdk 数组
+ *    成员集,任一侧加员而另一侧没跟 ⇒ 当场红)。
+ */
+function isRuleOfferMatch(v) {
+    return typeof v === 'string' && RULE_OFFER_MATCHES.includes(v);
+}
+/**
+ * 一条 `single` offer / 一个 `command` 成员共用的三位窄化(`rule` 非空串 + `match` **四词闭集** +
+ * `command` 非空串)。任一不合形 ⇒ `undefined`(半条候选渲出来是一格没有正文、按下去必被 server
+ * 拒的选项)。
  */
 function readRuleTriple(v) {
     if (v === null || typeof v !== 'object')
@@ -825,13 +915,94 @@ function readRuleTriple(v) {
     const o = v;
     if (typeof o.rule !== 'string' || o.rule === '')
         return undefined;
-    if (o.match !== 'exact' && o.match !== 'prefix')
+    if (!isRuleOfferMatch(o.match))
         return undefined;
     // 上游形上 `command` 必填(渲染用的命令模式)——缺席/非串 ⇒ 整项不合形丢弃。
     if (typeof o.command !== 'string' || o.command === '')
         return undefined;
     return { rule: o.rule, match: o.match, command: o.command };
 }
+/**
+ * 一个 `batch` 成员的窄化(sdk 8.2.0 判别联合 {@link RuleOfferBatchMember};B-025 修根)。
+ *
+ * 判别位 `kind` 读 sdk `RULE_OFFER_BATCH_MEMBER_KINDS`(`command` / `directoryRead`),外加一条
+ * **pre-B3 兼容臂**:`kind` **缺席**的成员按 `command` 归一(server ≥7.46.0 到 design/382 §2.3 B3
+ * 落地之间铸的成员没有判别位 —— 窄读域只许等于或宽于铸点域,绝不更窄)。
+ *
+ * 🔴 **不识的 `kind`(在场但不是表里的词)⇒ `undefined`,调用方据此丢掉整只 batch**,
+ *    绝不丢单个成员:core design/382 §2.3 规范性降级臂逐字 "drops the WHOLE batch offer —
+ *    never the single member"(少一条成员的合取批把「对 N 条说 yes」渲成「对 N−1 条说 yes」,
+ *    比不渲更坏),旁边那条完整诚实的 `single` 照留。
+ * 🔴 `segment` 是每个臂都必带的渲染座(非空串);`directoryRead` 臂**没有** `match`/`command`,
+ *    拿三元组窄读器去读它正是 0.57.0 把整只 batch 判假的那一形。
+ */
+function readRuleOfferBatchMember(v) {
+    if (v === null || typeof v !== 'object')
+        return undefined;
+    const o = v;
+    const seg = o.segment;
+    if (typeof seg !== 'string' || seg === '')
+        return undefined;
+    // pre-B3 兼容臂:判别位**缺席** = 历史形的 `command` 成员(那一代 wire 上根本没有 `kind`)。
+    // 🔴 归一放在最前面,后面只有**一个**成员性判据 —— 缺席与在场两条路走同一道闸,不留第二个判官。
+    const kind = o.kind === undefined ? 'command' : o.kind;
+    // 🔴 **成员性判到 sdk 的闭词表,不手抄字面量**(异源对抗复审 r1 [medium] 逼出的同形残余):
+    //    本函数初稿把 `'directoryRead'` / `'command'` 两个词**手写**在分支条件里,导入的
+    //    `RULE_OFFER_BATCH_MEMBER_KINDS` 只被再导出、运行期一次都没读 —— 那正是 B-025 本身的病形
+    //    (`match` 手抄两员)在成员这一维上的**残余**,只是当天恰好抄对了。抄对的表明天也会过期。
+    if (typeof kind !== 'string')
+        return undefined;
+    if (!RULE_OFFER_BATCH_MEMBER_KINDS.includes(kind))
+        return undefined;
+    if (kind === 'directoryRead') {
+        const rule = o.rule;
+        const dir = o.directory;
+        if (typeof rule !== 'string' || rule === '')
+            return undefined;
+        if (typeof dir !== 'string' || dir === '')
+            return undefined;
+        return { kind: 'directoryRead', rule, directory: dir, segment: seg };
+    }
+    if (kind === 'command') {
+        const triple = readRuleTriple(v);
+        if (triple === undefined)
+            return undefined;
+        return { kind: 'command', ...triple, segment: seg };
+    }
+    // 🔴 **表内、但本包还没有读器的 kind** ⇒ 与表外同处置(丢 ⇒ 调用方丢整只 batch),绝不猜一个形。
+    //    上游往闭词表加员而本包没跟时走这条路:行为是 fail toward asking(合取批不渲,兄弟 single 照留),
+    //    而门 ⑨c 的「⊇ 成员 kind 在读器里走得通」那一腿会**当天红**,逼人补读器 —— 静默降级与显形二者兼得。
+    return undefined;
+}
+/**
+ * `uncoveredDetail`(design/382 §3.5 **additive** 明细座)的窄化。
+ *
+ * 🔴 **只丢坏行,绝不因为它否决整只 batch**:additive 位到货**不许回头削弱既有位的现行为** ——
+ *    老引擎压根不铸这一位,server 自己对坏形的座也是「只丢座不丢批」。整只读空 ⇒ 本位缺席
+ *    (**不是**空数组:空数组会被端读成「已确认没有未覆盖段」,而真源恒是 `uncoveredSegments`)。
+ * 🔴 `reason` 判到 sdk 8.2.0 的闭三词集(`redirection` / `no_rule_form` / `cap_overflow`);
+ *    不识的 reason 只丢那一行 —— 它是**给人看的因由**,不驱动任何兑付动作。
+ */
+function readUncoveredDetail(v) {
+    if (!Array.isArray(v))
+        return undefined;
+    if (v.length === 0 || v.length > MAX_RULE_OFFER_UNCOVERED_DETAIL_TOLERATED)
+        return undefined;
+    const out = [];
+    for (const raw of v) {
+        if (raw === null || typeof raw !== 'object')
+            continue;
+        const o = raw;
+        if (typeof o.segment !== 'string' || o.segment === '')
+            continue;
+        if (typeof o.reason !== 'string')
+            continue;
+        if (!RULE_OFFER_UNCOVERED_REASONS.includes(o.reason))
+            continue;
+        out.push({ segment: o.segment, reason: o.reason });
+    }
+    return out.length > 0 ? out : undefined;
+}
 /** offer **条数**的坏形帽。server 侧执法帽是 `MAX_RULE_OFFERS`=4(core 契约本就 ≤2),本包留 8 ——
  *  [4050] 随批立的纪律:**窄读域只许等于或宽于铸点域,绝不更窄**;超帽 = 坏形/注入,整只降缺席
  *  (截了不留痕会掩盖注入)。 */
@@ -839,6 +1010,23 @@ const MAX_RULE_OFFERS_TOLERATED = 8;
 /** 一条 `batch` 的**成员**条数坏形帽(core 契约 1..5,server 容忍帽 8)。与上面那个刻意分家:
  *  两者数的是不同的东西(几个选项 vs 一个选项里几条规则),混成一个数会让上游放宽任一维时误伤另一维。 */
 const MAX_RULE_OFFER_BATCH_MEMBERS_TOLERATED = 8;
+/**
+ * `uncoveredDetail` 的**行数**坏形帽(0.58.0)。
+ *
+ * 🔴 **锚在上游的铸点域上,不是按兄弟帽类比**(异源对抗复审 r1 [medium] 真病修):本位初稿写的是
+ *    `8`,理由「与成员帽同源同量级」—— 那是**类比不是取证**,而且判错了源。真实铸点域:
+ *      · server 的执法帽是 `MAX_UNCOVERED_DETAIL_ROWS = **32**`(`@sema-agent/server`
+ *        `src/approval-card.ts`:zod `.max(32)` 与座级预筛 `screenUncoveredDetailSeat` 同用);
+ *      · 未覆盖段数**根本不受成员帽约束** —— core 逐字 `uncoveredSegments: uncoveredDetail.length`
+ *        (`permission-rule-model.ts`),一只**只有 1 个成员**的 batch 可以带 9 条明细(9 个带重定向
+ *        的段各自 mint 不出规则形,进不了 `rules[]` 却每段都要给一个「为什么还会问」)。
+ *    ⇒ 帽 8 是**比铸点域更窄**的窄读域,正是 [4050] 那条纪律禁的形:一只合法的 9~32 行明细座被整座
+ *    静默丢掉,人失去「这几段为什么还会问」。边界钉在门 ⑨d(9 / 32 必收、33 才丢)。
+ * 🔴 **取等于而不是再加倍**:与 {@link MAX_RULE_OFFERS_TOLERATED}(server 执法帽 4,本包留 8)不同 ——
+ *    那一位没有可锚的上游常量,余量是纯容忍;本位有**具名铸点常量**,取等于就是「窄读域等于铸点域」,
+ *    再自行加倍反而是又一次凭感觉编数。上游哪天放宽,门 ⑨d 的 33 行负控会当天红,逼人跟着抬。
+ */
+const MAX_RULE_OFFER_UNCOVERED_DETAIL_TOLERATED = 32;
 /**
  * `ruleOffers`(server ≥7.46.0 的判别联合)的结构读。
  *
@@ -893,19 +1081,28 @@ export function readRuleOffers(v) {
             const members = [];
             let memberShapeOk = true;
             for (const raw of o.rules) {
-                const triple = readRuleTriple(raw);
-                const seg = raw?.segment;
                 // 🔴 batch 成员**不逐条丢**:合取批是「对全体成员一次说是」,少一条成员就是另一次授权 ——
-                //    渲一个缺了成员的批,人点的与引擎兑的不是同一批规则。任一成员不合形 ⇒ 整条 batch 丢。
-                if (triple === undefined || typeof seg !== 'string' || seg === '') {
+                //    渲一个缺了成员的批,人点的与引擎兑的不是同一批规则。任一成员不合形(含 `kind` 不识)
+                //    ⇒ 整条 batch 丢。这是 core design/382 §2.3 的**规范性**降级臂,不是本包的保守选择:
+                //    逐字 "drops the WHOLE batch offer — never the single member ... and never the whole card"。
+                const member = readRuleOfferBatchMember(raw);
+                if (member === undefined) {
                     memberShapeOk = false;
                     break;
                 }
-                members.push({ ...triple, segment: seg });
+                members.push(member);
             }
             if (!memberShapeOk)
                 continue;
-            out.push({ kind: 'batch', offerIndex: i, rules: members, uncoveredSegments: uncovered });
+            // additive 明细座(0.58.0):只丢坏行、读空即缺席,**绝不**因为它否决整只 batch。
+            const detail = readUncoveredDetail(item.uncoveredDetail);
+            out.push({
+                kind: 'batch',
+                offerIndex: i,
+                rules: members,
+                uncoveredSegments: uncovered,
+                ...(detail !== undefined ? { uncoveredDetail: detail } : {}),
+            });
             continue;
         }
         // 不认识的 kind(含 kind 缺席)⇒ 丢这一条,原始下标照旧不给后面的成员用。
@@ -1029,6 +1226,9 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
     // #334(0.43.0):新键 `ruleOffers`(server ≥7.46.0 判别联合)优先,旧键 `ruleSuggestions`
     // (≤7.45)归一成 `kind:'single'` 兜底 —— 两代经同一把窄读器,包内出口只有一个形。
     const ruleOffers = readRuleOfferSupply(frame.ruleOffers, frame.ruleSuggestions);
+    // S-114(0.59.0):限额回落卡的四成员窄读**算一次**(读器是纯函数,但两次调用会让「上卡的那一份
+    // 与判在场的那一份是不是同一个对象」在读代码时需要推理 —— 单点求值把它变成显然的)。
+    const denialLimitFallback = readDenialLimitFallback(frame.denialLimitFallback);
     const card = await surfaceApprovalCard({
         toolName,
         args: args,
@@ -1101,6 +1301,23 @@ export async function surfaceToolApprovalFrameAndRespond(frame, respond, streamA
         // 「没扫到」渲成「已确认干净」,而这一位存在的全部理由就是「人眼读到的顺序 ≠ 真跑的字节顺序」。
         // 🔴 披露不清洗:args 字节在本层一个都不改(清洗会让卡上显示的与真跑的不是同一个东西)。
         ...(frame.inputHasBidi === true ? { inputHasBidi: true } : {}),
+        // ── S-15 第五单(0.59.0):报价缺席因由透传 ────────────────────────────────────────────────
+        // **非空串才 stamp**,词表**不校**(开集;server 已按闭集拒过词表外的值,包再校一遍只会在
+        // core 加员当天把合法值判没 —— `autoMode.reason` 的透传纪律逐字同规)。缺席/坏形 ⇒ 键不 stamp。
+        // 🔴 与 `ruleOffers` 引擎侧互斥,但本层**不据此互删**:两者同时在场是上游坏形,原样上卡让端
+        //    看得见,包替上游把矛盾湮灭掉只会让排障说不清是谁窄没的。
+        ...(typeof frame.ruleOffersAbsence === 'string' && frame.ruleOffersAbsence !== ''
+            ? { ruleOffersAbsence: frame.ruleOffersAbsence }
+            : {}),
+        // ── S-114(0.59.0):auto 分类器限额回落卡透传 ──────────────────────────────────────────────
+        // 经 `readDenialLimitFallback` 四成员窄读(缺一整只丢;判据本体在该函数顶注)。
+        // 🔴 stamp 的是**窄读产物**而不是原对象:端拿到的四座恒是有限非负数 + 非空 limit 串,
+        //    不必各自再写一遍同样的判断(三端各写一遍 = 三份会漂的判官)。
+        ...(denialLimitFallback !== undefined ? { denialLimitFallback } : {}),
+        // ── S-125③/#564(0.59.0):ask 出身透传 ────────────────────────────────────────────────────
+        // 非空串才 stamp,词表**不校**(同 ruleOffersAbsence)。🔴 缺席 ⇒ 键不 stamp,**绝不折成
+        // `"policy"`**:那是一个正面事实(出自部署 ToolPolicy),把「老引擎没报」折进去 = 替引擎编话。
+        ...(typeof frame.origin === 'string' && frame.origin !== '' ? { origin: frame.origin } : {}),
     });
     const decision = card.kind === 'allow' ? (card.allowSession ? 'allow_session' : 'allow') : 'deny';
     if (card.kind === 'failed') {

package/dist/index.d.ts

@@ -148,6 +148,7 @@ export * from './liveQuestionStore.js';
 export * from './engineInlineTaskStats.js';
 export * from './printToolResultFrame.js';
 export * from './engineCapsCache.js';
+export * from './sqlEngineCapability.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
 export type * from './types/engineState.js';
@@ -215,6 +216,7 @@ export * from './engineSessionParam.js';
 export * from './engineWireTarget.js';
 export * from './principalWire.js';
 export * from './wireErrorTriage.js';
+export * from './resumeRefusalCopy.js';
 export * from './sessionMap.js';
 export * from './detachWire.js';
 export * from './workflowMonitor.js';

package/dist/index.js

@@ -160,6 +160,8 @@ export * from './liveQuestionStore.js';
 export * from './engineInlineTaskStats.js';
 export * from './printToolResultFrame.js';
 export * from './engineCapsCache.js';
+// S-131(0.59.0):`Capabilities.sql` 的四态窄读器 —— 壳侧那份逐字上收(导出名同名 = drift-lock)。
+export * from './sqlEngineCapability.js';
 export * from './engineToolLabelStore.js';
 export * from './fleetTaskDesc.js';
 // ── B2 批:通知族合并 / caps-wire 门族 / 模型面纯逻辑 / control 路由(2026-07-27)──────────────
@@ -300,6 +302,11 @@ export * from './principalWire.js';
 // · wireErrorTriage:turn 错误分型判定半场(A-028.11;文案/渲染归端)+ scenario 拒绝判型
 //   (A-028.13;web 逐字节同形过滤行的正主)。码字面引 engineErrorCodes。
 export * from './wireErrorTriage.js';
+// · resumeRefusalCopy:L-102 下半场(0.58.0)—— resume 拒绝的**人话铸点**三端单源。
+//   与上面那口分工:`wireErrorTriage.resumeRetryLaterFromError` 答「能不能等」(事实读数),
+//   本口答「该对人说什么」(文案),`preflight_rejected` 的窗与可等性**转调**前者不复制判定。
+//   壳侧对位 = cli `src/sema/resumeRefusalCopy.ts`(1.0.101 起改薄成适配层)。
+export * from './resumeRefusalCopy.js';
 // · sessionMap:「客户端会话 id ↔ 引擎会话 id」映射单一键形 + merge 判定(A-028.12;存储经
 //   SessionMapStorePort 归端 —— cli 文件锁/原子写,web localStorage)。
 export * from './sessionMap.js';

package/dist/printToolResultFrame.d.ts

@@ -105,6 +105,24 @@ export interface ToolEndResultArmLike {
      * 🔴 本形同样是**防御性读形**(`unknown`):九词是引擎的闭集,消费方分支已知值 + 永远带 default。
      */
     resolution?: unknown;
+    /**
+     * 这次 deny 是**引擎的窗自己拒的**(S-125⑧,0.59.0;core 7.4.0 auto 模式分类器的限额回落窗 →
+     * server ≥7.57.0 `tool_end.autoDenied`)。`eventToSdkMessage` 的 `case 'tool_end'` 臂**严格
+     * `true` 才上臂**,与 {@link settledBy}/{@link approver}/{@link resolution} 同款「臂带、卡不带」。
+     *
+     * 🔴 **它答的是既有两键答不了的那一问**:`settledBy:"timeout"` 与 `resolution:"window_expired"`
+     * 覆盖**一切**审批窗到期(普通 ask 的 TTL 也在内),分不出「这一次到期是**自动拒**收的场」还是
+     * 「park 了等人」。要渲「自动拒(限额回落)」而不是「已转后台候批」,判据只有这一位。
+     * 🔴 **缺席不带语义,不许反推**:缺席同时覆盖「不是自动拒」「老引擎(<7.57.0)不报」「这次根本
+     * 没走审批」三形 ⇒ **禁**读成「是人拒的」。
+     * 🔴 **机读位是二值的**:`true` 才有意义,「在场但不是 true」没有语义 —— 消费端同样只认严格 `true`。
+     * 🔴 **不据它自铸第二只定时器/第二张资格表**:窗的执行全在引擎(上游
+     * `tool_approval.denialLimitFallback` 顶注的同一条禁令),本位是**事后**的判别位。
+     * ⇄ 卡面那一侧的孪生位 = `ApprovalCardRequest.denialLimitFallback`(带触限计数与窗),两者是
+     * 同一件事的**事前 / 事后**两个面:卡上告诉人「再拒就到限额了,这一次必须你来批」,本位告诉人
+     * 「那张卡的窗走完了,引擎替你拒了」。
+     */
+    autoDenied?: unknown;
     parentToolCallId?: unknown;
     uuid?: unknown;
     session_id?: unknown;

package/dist/resumeRefusalCopy.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 本模块认识的 resume 拒绝码(**闭集**)—— 「有人话可补」的那两个。
+ *
+ * 🔴 **冻结数组,不是 `ReadonlySet`**(与 {@link RESUME_RETRY_LATER_CODES} 同一条已定谳的病形):
+ *    `ReadonlySet` 只在类型面只读,运行期是一只普通 `Set`,而判定查的就是这个实例 —— 公面上任何
+ *    JS 消费者一次 `.add('resume.evicted')` 就能让一条「重开吧」的拒绝挂上「你的决定没被消费」
+ *    这句安全声明。冻结数组在运行期真的改不动(ESM 恒 strict:`push` / 下标赋值直接抛)。
+ * 🔴 新增成员必须**同批**补文案 + 判据,不许靠前缀放宽。
+ */
+export declare const RESUME_REFUSAL_CODES: readonly string[];
+/** {@link resumeRefusalFromError} 的结构化读数。 */
+export interface ResumeRefusalDetail {
+    /** 命中的那一个码({@link RESUME_REFUSAL_CODES} 的成员之一)。 */
+    code: string;
+    /**
+     * server 给的**等待秒数**(整数 ∧ ≥1;窄读域与 §21 同律,见模块顶注)。
+     * 🔴 **缺席 = 服务端没给窗**,不是 0、不是「立刻」——绝不渲一个编出来的倒计时
+     *    ([honest-absence-not-fabricated-zero])。`resume.placement_mismatch` 上**恒缺席**
+     *    (server 只在时间性二码上铸这一位);`resume.preflight_rejected` 上按 server 供给。
+     */
+    retryAfterSec?: number;
+    /**
+     * **等一会儿再赎有没有用**(处置位;文案据它选第三句)。
+     *
+     * 🔴 **两个码上的 `false` 是两种「不」,别合并读**:
+     *   · `resume.preflight_rejected` 的 `false` = **不可判**(转调 {@link resumeRetryLaterFromError}
+     *     的同名位:core 侧那条 `terminal` 臂与缺省 `retry_later` 臂的判别位只在 message 散文里,
+     *     本包不按文案分臂 ⇒ 只认「server 真给了窗」这条正向证据);
+     *   · `resume.placement_mismatch` 的 `false` = **等没有用**(出路是换参数不是等时间,见该码顶注)。
+     *   两者在文案上落到**不同的第三句**,所以消费端不必自己再分。
+     */
+    waitable: boolean;
+}
+/**
+ * 被 catch 的错误 → resume 拒绝读数;不是这两个码 ⇒ `null`(绝不误吃别的 4xx)。
+ *
+ * 🔴 **duck-typed 不 `instanceof`**:三端注入面可能是宿主的裸 fetch、desktop 的 IPC 转投、web 跨
+ *    bundle 的 plain object(跨 bundle 同名类是两个类),这些形上 `instanceof` 一律为假而
+ *    `errorCode` 恒在。键位**只认 `errorCode`**([2055] 死键纪律,退役 `code` 槽不做兼容)。
+ * 🔴 **判据只有 `errorCode`,不看 HTTP 数字**(与 §21 同口径):`resume.*` 那一族成员全是 409,
+ *    按数字分支等于把几种不同处置压成一种。
+ * 🔴 **`preflight_rejected` 的窗与可等性全部转调 §21 那一口**,本文件不复制判定。
+ */
+export declare function resumeRefusalFromError(err: unknown): ResumeRefusalDetail | null;
+/**
+ * 结构化读数 → 人话补充行(`·` 分段,与端上 quota / scenario 两个兄弟同形)。
+ *
+ * 三句的分工固定:①**发生了什么**(用户看得懂的那句)· ②**这次拒绝有没有消费掉你的决定**
+ * (安全声明,两条臂都成立时才敢说)· ③**接下来怎么办 / 还能不能再决**。
+ *
+ * 🔴 第三句由 {@link ResumeRefusalDetail.waitable} 选,**不由 message 文本选**:按上游散文分支
+ *    正是「上游改一个词、壳的判定静默空转」的形(wire 锚契约门要挡的就是它)。
+ * 🔴 `preflight_rejected` 且 `waitable === false` 时说的是**两条臂都为真**的那句(cli 1.0.x 的现行
+ *    文案逐字),把「还能不能再赎」交给屏上那行引擎原文;`waitable === true` 时 server 真给了窗
+ *    ——那是 `retry_later` 臂的**充分证据**(core 的 `terminal` 臂抛的 `CheckpointError` 一个
+ *    detail 都不带,窗结构上到不了客户端)⇒ 可以放心说「障碍清掉之后这个 token 还能再赎」。
+ */
+export declare function resumeRefusalContent(detail: ResumeRefusalDetail): string;

package/dist/resumeRefusalCopy.js

@@ -0,0 +1,115 @@
+/**
+ * src/resumeRefusalCopy.ts — resume 族**拒绝文案的三端单一铸点**(L-102 下半场,0.58.0)。
+ *
+ * ── 这一件上收的是什么 ──────────────────────────────────────────────────────────────────────
+ * 0.57.0 已经把 L-102 的**事实读数**上收了({@link resumeRetryLaterFromError}:命中哪个码、
+ * server 给没给窗、等一会儿有没有用)。留在壳里的另一半是**人话** —— cli 1.0.x 的
+ * `src/sema/resumeRefusalCopy.ts` 自铸了一份判型 + 三句 `·` 分段文案,而 web-client / desktop
+ * 各自要么没有、要么将来会再抄一份。三端各抄一份文案 = 同一次拒绝在三个端上说三句不一样的话,
+ * 而这三句话回答的是**同一个安全问题**:「这次拒绝有没有消费掉我的决定 / 这张卡还能不能再决」。
+ * ⇒ 文案与判型同属**判定归包、呈现归端**里的「判定」那一半,本模块是它的单一铸点。
+ *
+ * ── 与 0.57.0 §21 那一口的分工(两个闭集刻意分家)──────────────────────────────────────────
+ * · {@link RESUME_RETRY_LATER_CODES}(engineErrorCodes.ts,0.57.0)闭的是「**server 在哪些码上铸
+ *   `retryAfterSec`**」——它回答**能不能等**;
+ * · {@link RESUME_REFUSAL_CODES}(本文件)闭的是「**哪些 resume 拒绝有人话可补**」——它回答
+ *   **该对人说什么**。
+ * 两集**交于** `resume.preflight_rejected` 一码、**各有**一个独占成员
+ * (`resume.usage_window_exhausted` 只在前者 / `resume.placement_mismatch` 只在后者),所以它们
+ * 不是同一张表的两个名字。🔴 **本模块不复制判定**:`preflight_rejected` 的窗与可等性一律**转调**
+ * `resumeRetryLaterFromError`,本文件里没有第二个 `retryAfterSec` 窄读器
+ * ([paired-mechanisms-must-share-premise]:两处各自判必然在某一格上分叉)。
+ *
+ * ── `retryAfterSec` 的窄读域比 cli 1.0.x 现行的更窄(端提货时要知道的差分)──────────────────
+ * cli 那份自铸读器收的是「有限数 ∧ ≥0」;本口沿用 §21 的域 =「**整数 ∧ ≥1**」,坏值一律降缺席:
+ *   · server 的铸键逐字是「ms → 秒**向上取整**、**下限 1**」⇒ 真供给里不存在 0 / 负数 / 小数;
+ *   · 放行 `0` 就是对端说「立刻重试」,而 resume 是 AT-MOST-ONCE 的**有副作用**动作(叫醒 = 真跑
+ *     一轮)—— 一个 0 会把「等一会儿」变成热循环;
+ *   · 放行小数会让端渲出「等 0.4 秒」这种上游从未说过的量。
+ * ⇒ 壳提货后在这三形上的**行为会变**(从「渲一个 0 秒等待」变成「不渲等待行」),这是**修好**
+ * 不是回归([verdict-must-accept-stronger-form])。
+ *
+ * ── 开集纪律(与 cli 那份逐字同律)────────────────────────────────────────────────────────
+ * 🔴 判型是**闭集**的(只认下面两个码),消费面是**开集**的:不认识的码一律 `null` ⇒ 端一个字
+ *    都不补 ⇒ 机器可读那一行(`API Error: <status> <errorCode> · <msg>`)原样上屏。
+ *    **绝不按前缀/子串猜一族码的语义** —— `resume.` 前缀下同时住着「等就好」「换参数」「没救了」
+ *    三种处置。
+ * 🔴 文案**不复述** server 的 message(那一行已经在屏上了),只补 message 里没有的那件事。
+ * 🔴 文案里**不铸等待的秒数**:那一行由端用 {@link ResumeRefusalDetail.retryAfterSec} 单独渲
+ *    (cli 的 `retryAfterHint` 是那一位的唯一取值口),在这里再说一遍就是同一个数字上屏两遍。
+ */
+import { RESUME_PLACEMENT_MISMATCH, RESUME_PREFLIGHT_REJECTED, } from './engineErrorCodes.js';
+import { resumeRetryLaterFromError } from './wireErrorTriage.js';
+/**
+ * 本模块认识的 resume 拒绝码(**闭集**)—— 「有人话可补」的那两个。
+ *
+ * 🔴 **冻结数组,不是 `ReadonlySet`**(与 {@link RESUME_RETRY_LATER_CODES} 同一条已定谳的病形):
+ *    `ReadonlySet` 只在类型面只读,运行期是一只普通 `Set`,而判定查的就是这个实例 —— 公面上任何
+ *    JS 消费者一次 `.add('resume.evicted')` 就能让一条「重开吧」的拒绝挂上「你的决定没被消费」
+ *    这句安全声明。冻结数组在运行期真的改不动(ESM 恒 strict:`push` / 下标赋值直接抛)。
+ * 🔴 新增成员必须**同批**补文案 + 判据,不许靠前缀放宽。
+ */
+export const RESUME_REFUSAL_CODES = Object.freeze([
+    RESUME_PLACEMENT_MISMATCH,
+    RESUME_PREFLIGHT_REJECTED,
+]);
+/**
+ * 被 catch 的错误 → resume 拒绝读数;不是这两个码 ⇒ `null`(绝不误吃别的 4xx)。
+ *
+ * 🔴 **duck-typed 不 `instanceof`**:三端注入面可能是宿主的裸 fetch、desktop 的 IPC 转投、web 跨
+ *    bundle 的 plain object(跨 bundle 同名类是两个类),这些形上 `instanceof` 一律为假而
+ *    `errorCode` 恒在。键位**只认 `errorCode`**([2055] 死键纪律,退役 `code` 槽不做兼容)。
+ * 🔴 **判据只有 `errorCode`,不看 HTTP 数字**(与 §21 同口径):`resume.*` 那一族成员全是 409,
+ *    按数字分支等于把几种不同处置压成一种。
+ * 🔴 **`preflight_rejected` 的窗与可等性全部转调 §21 那一口**,本文件不复制判定。
+ */
+export function resumeRefusalFromError(err) {
+    if (typeof err !== 'object' || err === null)
+        return null;
+    const code = err.errorCode;
+    if (typeof code !== 'string' || !RESUME_REFUSAL_CODES.includes(code))
+        return null;
+    if (code === RESUME_PLACEMENT_MISMATCH) {
+        // 时间性闭集里没有本码,也不该有(见该码顶注):无窗、且等一会儿对它毫无用处。
+        return { code, waitable: false };
+    }
+    // `resume.preflight_rejected` —— 两集的交点,事实读数**只有一个来源**。
+    const timed = resumeRetryLaterFromError(err);
+    // 🔴 `null` 在今天不可达(本码同在两个闭集里,交点由门双向钉死)。真出现 = 上游把本码移出了
+    //    时间性闭集 ⇒ 「有没有窗」这件事**本包不再知道**,按诚实缺席读作不可判,绝不自己再判一次。
+    if (timed === null)
+        return { code, waitable: false };
+    return {
+        code,
+        waitable: timed.waitable,
+        ...(timed.retryAfterSec !== undefined ? { retryAfterSec: timed.retryAfterSec } : {}),
+    };
+}
+/**
+ * 结构化读数 → 人话补充行(`·` 分段,与端上 quota / scenario 两个兄弟同形)。
+ *
+ * 三句的分工固定:①**发生了什么**(用户看得懂的那句)· ②**这次拒绝有没有消费掉你的决定**
+ * (安全声明,两条臂都成立时才敢说)· ③**接下来怎么办 / 还能不能再决**。
+ *
+ * 🔴 第三句由 {@link ResumeRefusalDetail.waitable} 选,**不由 message 文本选**:按上游散文分支
+ *    正是「上游改一个词、壳的判定静默空转」的形(wire 锚契约门要挡的就是它)。
+ * 🔴 `preflight_rejected` 且 `waitable === false` 时说的是**两条臂都为真**的那句(cli 1.0.x 的现行
+ *    文案逐字),把「还能不能再赎」交给屏上那行引擎原文;`waitable === true` 时 server 真给了窗
+ *    ——那是 `retry_later` 臂的**充分证据**(core 的 `terminal` 臂抛的 `CheckpointError` 一个
+ *    detail 都不带,窗结构上到不了客户端)⇒ 可以放心说「障碍清掉之后这个 token 还能再赎」。
+ */
+export function resumeRefusalContent(detail) {
+    const parts = [];
+    if (detail.code === RESUME_PLACEMENT_MISMATCH) {
+        parts.push('This resume named a different placement root than the one recorded when the work was parked');
+        parts.push('The engine refused it before consuming anything — the parked work is untouched');
+        parts.push('Retry with the recorded root, or omit the placement root to inherit it');
+        return parts.join(' · ');
+    }
+    parts.push("The deployment's resume preflight refused this attempt");
+    parts.push('The refusal happened before the commit — your decision was not consumed');
+    parts.push(detail.waitable
+        ? 'The engine supplied a wait, so this token stays redeemable once the obstacle clears'
+        : 'The engine line above says whether this token can still be redeemed');
+    return parts.join(' · ');
+}