@sema-agent/server 7.133.0 → 7.135.0

package/dist/approval-content-kind.d.ts

@@ -1,12 +1,12 @@
 /**
  * 审批卡的**卡词**读口(server 侧唯一一处)与保留问答工具名的再导出。
  *
- * ── 规则(core 7.49.0 #1414 / #1468 A-S4)────────────────────────────────────────────────────────────
+ * ── 规则(core 7.49.0 [ref] / [ref] A-S4)────────────────────────────────────────────────────────────
  * 「这一问 / 这一行用哪张卡」只有一个事实源 = **引擎铸的 `approvalCard`**(闭集 core `TOOL_APPROVAL_CARDS`):活 ask 上是
  * `AskRequest.approvalCard`,停驻行上是门的 `gate.approvalCard`(core `summarizeCheckpoint` 投给 `CheckpointSummary.approvalCard`
  * 的同一个词)。停驻行到期走哪条路只有一个判官 = core `facetOf(gate)`(问答卡 ⇒ `B`,到期作废;其余审批门 ⇒ `A`,SLA 拒扫腿 deny)。
  * 本仓**不从工具名回推卡**:此前的 `contentKindOf`(工具名 ⇒ `"content_ask"`)、两只店里按 `tool_name` 判问答的 SQL 字面臂与 LOCAL
- * 比较,以及 wire 上的第二个卡词 `contentKind`,随 #1414 整删(零别名、零双读)。
+ * 比较,以及 wire 上的第二个卡词 `contentKind`,随 [ref] 整删(零别名、零双读)。
  *
  * ── 存量行(7.49.0 之前的引擎停驻、门上没有卡)────────────────────────────────────────────────────────
  * 按 core 的读法:**无卡 = 不是一问**(core 不从名字回推,本仓也不)。持久数据面不留第二种读法 —— 按工具名回退的臂一旦留下,
@@ -14,12 +14,12 @@
  * 本仓 CHANGELOG 对应条目:旧问答行在队列上不带卡词;过了 deadline 走 SLA 拒扫腿(模型拿到一次「拒」),不再作废整条 run。
  *
  * ── 为什么保留工具名常量 ────────────────────────────────────────────────────────────────────────────
- * `ASK_USER_QUESTION_TOOL_NAME` 是 core 根导出的那一枚(S-213①:本仓一个字节都不自铸),仍有**决断面**的读者(回决时「批准问答必须
+ * `ASK_USER_QUESTION_TOOL_NAME` 是 core 根导出的那一枚([ref]①:本仓一个字节都不自铸),仍有**决断面**的读者(回决时「批准问答必须
  * 带答」、问答不可记为会话放行、durable 问答门的政策臂)—— 那几处与 core 自己的答案绑定(`engineCardOf`,按 wire 名)同读法,
  * 不是卡的渲染读法,不在本模块的规则里。
  */
 export { ASK_USER_QUESTION_TOOL_NAME } from "@sema-agent/core";
-import { type ToolApprovalCard } from "@sema-agent/core";
+import { PAUSE_REGISTRY, type GateKind, type ToolApprovalCard } from "@sema-agent/core";
 /**
  * 一格卡词的**闭集窄读**(三个载体共用这一只:活 ask、LOCAL 店的停驻门、SQL 店读出的门子树)。成员 ⇒ 那个词;缺席 ⇒ `undefined`(不计);
  * 在场却不是成员(世代差 —— 新引擎加了卡词而本版没跟上 —— 或手改行)⇒ `undefined` + 计一次 `server.approval-card.closed-word-out-of-set`
@@ -32,8 +32,11 @@ export interface ParkedGateFace {
     readonly approvalCard?: unknown;
 }
 /**
- * 停驻行的卡 = core `summarizeCheckpoint` 投给 `CheckpointSummary.approvalCard` 的那一个词:只在审批门(门型的寄存臂是
- * `tool_approval`,读 core `PAUSE_REGISTRY`)上读,词经 {@link readApprovalCard}。非审批门(计划审阅 / 资源 / 收尾)恒无卡。
+ * 停驻行的卡 —— 读法只有引擎那一只:core 包根导出 `parkedApprovalCardOf(gate)`(core 7.54.0 [ref] K2;审批门 = 门型的寄存臂是 `tool_approval`,
+ * 只在那里读卡,只有闭集成员算卡)。四态逐一处置(穷举 `switch`:core 加一态 ⇒ 编译红):`card` ⇒ 那个词;`no_card` / `not_approval` ⇒ 无卡;
+ * `unknown_word`(引擎交回**未经筛**的存储原值)⇒ 无卡 + 响亮:计一次 `server.approval-card.closed-word-out-of-set`(与 {@link readApprovalCard} 同一只计数、
+ * 同一只回显口径 —— 截 40、脱敏,对象只报形名)。修前本函数自己判「是不是审批门」(读 `PAUSE_REGISTRY` 的寄存臂)再交 {@link readApprovalCard},
+ * 与引擎的 `summarizeCheckpoint` 是两份读法。
  */
 export declare function parkedApprovalCard(gate: ParkedGateFace | undefined): ToolApprovalCard | undefined;
 /**
@@ -41,4 +44,21 @@ export declare function parkedApprovalCard(gate: ParkedGateFace | undefined): To
  * 门型不是 core 登记的门(存量行无门型 / 手改)⇒ `undefined`,调用方按「不是 `A`」处置(与无门型存量行的既有作废路同向)。
  */
 export declare function parkedFacetOf(gate: ParkedGateFace | undefined): "A" | "B" | "-" | undefined;
+/**
+ * 审批门型 = core `PAUSE_REGISTRY` 里寄存臂是 `tool_approval` 的登记门 —— 与 core `parkedApprovalCardOf` 判「是不是审批门」同一条判据(只在这些门上读卡)。
+ * **派生,不手写**(core 7.55.0 [ref] P1 阶段二):此前本仓手写一份二员词表([ref] 时 core 没有导出词表),一次性迁移 M21 又自派生一份;
+ * core 加一行审批味的门,这里跟着变,零处要改。读者:决断口与拒扫腿按门型绑定取行(`gateKinds`)、`/decide` 的门型守卫、M21 / M29 的候选扫描。
+ * 到期分法**不**读这张表 —— SQL 里是由 core 两张表生成的 facet 谓词(`plugins/checkpoint-index-columns.ts`),JS 里是 {@link denySweepOwns}。
+ */
+export type ApprovalGateKind = {
+    [K in GateKind]: (typeof PAUSE_REGISTRY)[K]["pending"] extends "tool_approval" ? K : never;
+}[GateKind];
+export declare const APPROVAL_GATE_KINDS: readonly ApprovalGateKind[];
+export declare function isApprovalGateKind(k: string | undefined): k is ApprovalGateKind;
+/**
+ * 停驻行的到期归 SLA 拒扫腿(deny)而不是作废(expire)?—— **一只谓词** = core `facetOf(gate)` 读作 `A`(按 core 的定义,`A` 就是「审批门、deadline 是 SLA 拒」;
+ * 问答卡 ⇒ `B`,到期作废;非审批门 / 未登记门 / 无门 ⇒ 不归拒扫)。LOCAL 孪生的拒扫选行与作废腿的补集读这一只;SQL 孪生读由同两张表生成的谓词,逐行与它同答
+ * (`test/checkpoint-index-columns.test.ts` B 节)。修前多一个「∧ 审批门型」合取 —— 在 core 的登记表下恒真,删。
+ */
+export declare function denySweepOwns(gate: ParkedGateFace | undefined): boolean;
 //# sourceMappingURL=approval-content-kind.d.ts.map

package/dist/approval-content-kind.js

@@ -1,5 +1,5 @@
 export { ASK_USER_QUESTION_TOOL_NAME } from "@sema-agent/core";
-import { PAUSE_REGISTRY, TOOL_APPROVAL_CARDS, facetOf, isGateKind } from "@sema-agent/core";
+import { PAUSE_REGISTRY, TOOL_APPROVAL_CARDS, facetOf, isGateKind, parkedApprovalCardOf } from "@sema-agent/core";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { redactSecrets } from "./trace/redact.js";
 export function readApprovalCard(raw) {
@@ -13,11 +13,31 @@ export function readApprovalCard(raw) {
     return undefined;
 }
 export function parkedApprovalCard(gate) {
-    if (gate === undefined || !isGateKind(gate.kind) || PAUSE_REGISTRY[gate.kind].pending !== "tool_approval")
+    if (gate === undefined)
         return undefined;
-    return readApprovalCard(gate.approvalCard);
+    const reading = parkedApprovalCardOf({ kind: gate.kind, approvalCard: gate.approvalCard });
+    switch (reading.kind) {
+        case "card":
+            return reading.card;
+        case "no_card":
+        case "not_approval":
+            return undefined;
+        case "unknown_word":
+            return readApprovalCard(reading.word);
+        default: {
+            const unreachable = reading;
+            throw new Error(`unhandled parked approval card reading: ${JSON.stringify(unreachable)}`);
+        }
+    }
 }
 export function parkedFacetOf(gate) {
     return gate !== undefined && isGateKind(gate.kind) ? facetOf({ kind: gate.kind, approvalCard: gate.approvalCard }) : undefined;
 }
+export const APPROVAL_GATE_KINDS = Object.keys(PAUSE_REGISTRY).filter((k) => PAUSE_REGISTRY[k].pending === "tool_approval");
+export function isApprovalGateKind(k) {
+    return k !== undefined && APPROVAL_GATE_KINDS.includes(k);
+}
+export function denySweepOwns(gate) {
+    return parkedFacetOf(gate) === "A";
+}
 //# sourceMappingURL=approval-content-kind.js.map

package/dist/approval-deny-reasons.d.ts

@@ -95,7 +95,7 @@ export type ApprovalEndingCause = (typeof APPROVAL_ENDING_CAUSES)[keyof typeof A
 /** 全部成因词(机器判据用:值域互不相同 + 列宽 ≤ 64 的钉子在 test/approval-reconciler.test.ts)。 */
 export declare const ALL_APPROVAL_ENDING_CAUSES: readonly ApprovalEndingCause[];
 /**
- * 审计 settle 行 `cause` 的读盘词表(S-929 形):{@link SettleCause} 的穷举,`satisfies Record<SettleCause, true>` ⇒ 闭集加一个非决断类的词而本表没跟 = **编译红**(多一个词同样红);
+ * 审计 settle 行 `cause` 的读盘词表([ref] 形):{@link SettleCause} 的穷举,`satisfies Record<SettleCause, true>` ⇒ 闭集加一个非决断类的词而本表没跟 = **编译红**(多一个词同样红);
  * 判定走 `Object.hasOwn`,原型链上的名字不算词。决断类三词({@link DecisionRefusalCause})拒一次决议、不结束一张卡 ⇒ 不是 settle 行的成因,读到它们照词表外处置(计坏行)。
  * 唯一读者 = {@link isSettleCause}。
  */

package/dist/approval-gate-currency.d.ts

@@ -0,0 +1,91 @@
+/**
+ * 一张停驻审批卡的「门」此刻还是不是它 —— 应答口判 `approval_stale` 与按问读口 `state` 的**同一只判官**。
+ *
+ * ## 病灶(为什么要有这一只)
+ * 问账行 `PARKED` 是终态(`approval-ask-machine.ts`:`PARKED: []`):赎回腿的单赢者是 **checkpoint 的 CAS**,取消腿动的也是 checkpoint(先 `expire` 门、再驱 run 终局),
+ * 两条腿都不写 ask 行。于是「这张卡的门还在不在」这件事只有 checkpoint 店知道;读口若只看行,就会在卡被答过 / run 被取消之后继续说 `parked` 并指路去决定,
+ * 而应答口对同一张卡早已答 `409 approval_stale`。同一件事两个读法 —— 本模块把它收成一个:读的是同一个问题、同一个来源。
+ *
+ * ## 判官
+ * 问题:**这把 gate token 是不是该会话当前待决的审批门?**(应答口的答法:`resumeCheckpoint` 的 stale 臂 —— 回显的 token ≠ 该会话当前待决的审批门 ⇒ `409 approval_stale`。)
+ *  · {@link currentApprovalGateToken} —— 该会话当前待决的审批门(审批门型优先,没有再退到任一待决行);应答口读它,读口读它,别处不再内联第二份;
+ *  · {@link readGateCurrency} —— 一把 token 对着它的读数:`current`(带那一行)/ `absent`(店里没有这一行)/ `settled`(行在,但不再是当前待决门:已结算、已过期、被取代);
+ *  · {@link createParkedGateRead} —— 协调器读口的门读席:把读数译成读口要的四种读法({@link ParkedGateReading}),`state` 闭集不加字。
+ *
+ * ## 一个读数只取自一个时刻([ref])
+ * 门身份就是 token:引擎重开一张门(`reopen`:续跑腿在被批准的动作开跑之前失败)翻的是**同一行**(resolved → pending,token 不变)。所以「这张卡此刻在哪」可以在两次店读之间
+ * 来回变(待决 → 被决 → 被重开);判官的分类只用**同一时刻成立**的读数:
+ *  ① 行不在 ⇒ `absent`;行不 pending ⇒ 按这一行分类(不 pending 的行不可能是「当前待决」的那一把,不必再问);
+ *  ② 行 pending ⇒ 问「当前待决」,**问完再读一次行**:世代号没动(`rev`:core 的单调世代号,每一次 resolve / reopen 都推它)⇒ 两次行读之间没有 resolve / reopen 落地 ⇒
+ *     「当前待决」那一读时它就是这一行(连同行上的重开事实)⇒ 答的是它 ⇒ `current`(带这一行),答的不是它 ⇒ 被取代(`settled`);
+ *     世代号动了 ⇒ 两次行读之间这张卡被决又被重开 ⇒ 用新的那一行**从 ① 重判**(有界 {@link GATE_READ_ROUNDS};摸到上界 ⇒ 抛,读口按店故障姿势处置);
+ *     第二读不在 / 不再 pending ⇒ 从 ① 按它分类。两个答案(是 / 不是当前待决)过的是**同一道**世代号核对:
+ *     拿「被决那一瞬」读到的当前待决与「重开之后」读到的 pending 拼出 `void`,或拿第一读的旧行(那一刻它还不是当前待决、也还没被重开)答「当前待决」,都是同一种拼法。
+ *
+ * ## 被重开的门怎么读([ref])
+ * `current` 的那一行上若带 core 的重开事实(`reopenReason`,闭集 `REOPEN_REASONS`;下一次 resolve 清掉它),读法是 `open` + `reopened`:core 的因由词原样 +
+ * **重开之前的决议**(core 跨重开保留赢家 `resolvedOutcome`;读它的是已结算门 `decided` 的**同一只**决议读法 {@link decisionReading} —— 一个记录一个读者)。
+ * 那只读法读不出决议 ⇒ 只带因由词,不编一个决议;因由词不在 core 的闭集里(只有手改行带得出)⇒ 不带 `reopened`(读不懂的词说不出「重开」是哪一种)。
+ *
+ * ## `settled` 怎么译(读口只说 checkpoint 上有凭据的话;一条规矩)
+ * 落盘的行不受类型面约束(旧版 / 手改 / 坏体 / 更新版本 core 写下的行可带闭集外的词或坏形),所以已结算门只按**一条规矩**读:
+ *  ① 两个闭集词(行的 `status`、结算记录的种类 `settlement.kind`)各查一张穷举表,**同一查法**({@link throughTable}:只认表自己的键,非字符串不进表):
+ *    表明说 `decided` ⇒ 往下读;明说 `void` ⇒ `void`(没有人决过它,答案无处兑现 —— 已过期〔取消 / 收割〕、仍待决却不是当前门〔被取代,应答口答 stale〕、
+ *    结算种类是引擎窗到期 / 宿主 SLA 扫 / 无人可答的失败族);**表外 ⇒ `unknown`**(读不懂的词撑不起「有人决过」,也撑不起「没有人决过它」);
+ *  ② 结算赢家的门记录 `resolvedOutcome.gateOutcome` 先过 core 唯一的门记录筛 `screenGateOutcome`(**档案读法**:读回的耐久行,闭集 = 今日成员 ∪ 已退役词;
+ *    坏形记缺陷、绝不抛;本仓 `trace/project.ts` 投影同一种记录也只经这一只筛),有缺陷 ⇒ `unknown`,过了筛才读它的成员;
+ *  ③ 分类之前记录要**读得全**:有结算记录、时刻(引擎写进赢家的 `settlement.when`)是有限数、赢家绑的是这一行的调用且判词是 allow / deny(与
+ *    `findDecidedApprovalsForBinding` 同一只 {@link approvalDecisionOfWinner})—— 缺一个都是 `unknown`(**不编一个首决**;读口答 404,应答口对已结算的门答 409 `approval_stale`,两口不同判;
+ *    `void` 也要读得全:绑在别的调用上的结算说的不是这张卡);读全了再按**结算种类**表分类:人 / 策略的四个种类 ⇒ `decided`(理由取自赢家的 `reason`),其余十个 ⇒ `void`
+ *    (按种类不按当事方:跨版本稳定的是种类词,变过义的是当事方词 —— 此前版本的策略拒记 `policy_refused` + `who.party:"none"`,此后记 `"policy"`,按当事方查会把那一代合法历史记录读成 `void`);
+ *  ④ 读的只是行的内容、不碰店:内容坏到读的时候抛(行上缺了必填成员)同样是坏行 ⇒ `unknown`,不冒成店故障(读口对店故障退回 `parked`)。
+ * `unknown` 的这一类(`decision_unreadable`)带上读不出的那几处(缺陷句,非空):读口答 404 `tool_approval.not_pending`,并记一行 error(首句 + 计数)。
+ * 行没了 ⇒ `unknown`(`row_absent`;应答口 PARKED 臂的 404 `not_found.approval` 同判)。
+ *
+ * ## 盲区(core 的筛不判的两处,如实写下:一处本判官手判有限数,一处本判官也不核)
+ *  · 结算时刻 `settlement.when`:筛不判,本判官手判「有限数」;而本仓另一个读同一种记录的读者(trace 投影)把 `when` 原样放上 wire —— 同一个坏时刻,两个读者两种答法;
+ *  · 方向与配对:赢家的方向(`resolvedOutcome.decision`)与记录自己的种类 / 处置说的方向是否一致,以及种类 × 当事方的配对 —— 筛不判,本判官也不核:读口以赢家的方向为准、读的是种类。
+ * 只有坏行 / 手改行才走得到这两处。候引擎的筛把时刻、方向与种类 × 当事方配对一并判了,两个读者同时退掉各自的手判(配对今天没有手判可退 —— 它无人判)。
+ */
+import { type Checkpoint, type CheckpointToken, type SettlementKind } from "@sema-agent/core";
+import { type PendingRowBinding } from "./plugins/checkpoint-store-sql.js";
+import { type ParkedGateRead } from "./tool-approval.js";
+/** 判官要的两个店口(三后端同形;窄接口让测试与装配都不必拿整只店)。 */
+export interface GateCurrencyStore {
+    get(token: CheckpointToken): Promise<Checkpoint | null>;
+    findPendingTokenBySession(sessionId: string, scope?: string, binding?: PendingRowBinding): Promise<CheckpointToken | null | undefined>;
+}
+/**
+ * 该会话**当前待决的审批门**的 token:审批门型({@link APPROVAL_GATE_KINDS})优先 —— 同会话 `task_done` 纯 park 与新 run 的审批 park 可以并存(表无 per-session pending 唯一约束),
+ * 无序读会选中别的门型 —— 没有审批门才退到任一待决行(错门型诊断由 `/decide` 的 gate-kind 守卫点名)。应答口的 stale 臂与按问读口读这一只。
+ */
+export declare function currentApprovalGateToken(cs: Pick<GateCurrencyStore, "findPendingTokenBySession">, sessionId: string): Promise<CheckpointToken | null | undefined>;
+/** 一把 gate token 对着判官的读数(`current` / `settled` 带分类用的那一行)。 */
+export type GateCurrency = {
+    readonly kind: "current";
+    readonly checkpoint: Checkpoint;
+} | {
+    readonly kind: "absent";
+} | {
+    readonly kind: "settled";
+    readonly checkpoint: Checkpoint;
+};
+/**
+ * 这把 gate token 是不是它那条会话当前待决的审批门 —— 分类只用同一时刻成立的读数(规矩见模块头注「一个读数只取自一个时刻」)。
+ * 读不出(店抛错)⇒ 原样上抛,由调用方的故障姿势处置;行一直在动、摸到 {@link GATE_READ_ROUNDS} ⇒ 抛。
+ */
+export declare function readGateCurrency(cs: GateCurrencyStore, gateToken: string): Promise<GateCurrency>;
+/** 一个闭集词对已结算门的读法类:有人 / 有策略决过(往下读决议),或没有人决过它。 */
+type SettledClass = "decided" | "void";
+/**
+ * 结算种类(core `SETTLEMENT_KINDS`)→ 这次结算算不算「有人 / 有策略决过」。`human_*`(人)与 `policy_*`(部署的策略)四个词是仅有的决议种类;其余十个 ——
+ * 引擎自己的窗到期 · 宿主窗 / 宿主 SLA 扫 · 无人可答的失败族 —— 没有人决过它,不读成「决议:deny」(那会让壳把一次宿主超时清算渲成「被拒绝」)。
+ * 表的键是**种类**不是当事方:种类词跨版本稳定,当事方词变过义(此前版本的策略拒记 `who.party:"none"`),按当事方查会把那一代合法历史记录读错。core 现成的两张种类表
+ * (是不是拒绝 / 有没有人评判过)答的是别的问题:`human_refused` 与 `approval_window_expired` 同是拒绝,这里一个是决议、一个不是,所以不从它们派生。
+ * 表穷举(与上面 `status` 表同形、同一查法):core 给种类闭集加词而不在此表态 ⇒ 编译红。
+ */
+export declare const SETTLEMENT_KIND_READING: Record<SettlementKind, SettledClass>;
+/** 协调器读口的门读席({@link ParkedGateRead}):装配点把 checkpoint 店递进来,协调器本身不认识 checkpoint 的形。 */
+export declare function createParkedGateRead(cs: GateCurrencyStore): ParkedGateRead;
+export {};
+//# sourceMappingURL=approval-gate-currency.d.ts.map

package/dist/approval-gate-currency.js

@@ -0,0 +1,120 @@
+import { REOPEN_REASONS, screenGateOutcome } from "@sema-agent/core";
+import { approvalDecisionOfWinner } from "./plugins/checkpoint-store-sql.js";
+import {} from "./tool-approval.js";
+import { APPROVAL_GATE_KINDS } from "./approval-content-kind.js";
+export async function currentApprovalGateToken(cs, sessionId) {
+    return (await cs.findPendingTokenBySession(sessionId, undefined, { gateKinds: APPROVAL_GATE_KINDS })) ?? (await cs.findPendingTokenBySession(sessionId));
+}
+function revisionOf(cp) {
+    return cp.rev ?? 0;
+}
+const GATE_READ_ROUNDS = 3;
+export async function readGateCurrency(cs, gateToken) {
+    const token = gateToken;
+    let row = await cs.get(token);
+    for (let round = 1;; round += 1) {
+        if (row === null)
+            return { kind: "absent" };
+        if (row.status !== "pending")
+            return { kind: "settled", checkpoint: row };
+        const isCurrent = (await currentApprovalGateToken(cs, row.sessionId)) === gateToken;
+        const again = await cs.get(token);
+        if (again !== null && again.status === "pending") {
+            if (revisionOf(again) === revisionOf(row))
+                return isCurrent ? { kind: "current", checkpoint: again } : { kind: "settled", checkpoint: again };
+            if (round === GATE_READ_ROUNDS)
+                throw new Error(`the checkpoint row moved between reads in ${GATE_READ_ROUNDS} rounds in a row (decided and reopened each time): there is no single-instant reading of its gate`);
+        }
+        row = again;
+    }
+}
+const SETTLED_GATE_READING = { resolved: "decided", expired: "void", pending: "void" };
+export const SETTLEMENT_KIND_READING = {
+    human_allowed: "decided",
+    human_refused: "decided",
+    policy_allowed: "decided",
+    policy_refused: "decided",
+    approval_window_expired: "void",
+    denial_limit_window_expired: "void",
+    park_sla_expired: "void",
+    no_approver: "void",
+    approver_unavailable: "void",
+    approver_error: "void",
+    approver_contract: "void",
+    presentation_failed: "void",
+    blanket_allow_refused: "void",
+    task_aborted: "void",
+};
+function unreadable(defects) {
+    return { kind: "unknown", why: "decision_unreadable", defects };
+}
+function throughTable(table, word, field) {
+    if (typeof word !== "string" || !Object.hasOwn(table, word))
+        return unreadable([`${field} has no reading in this server's table of its closed set`]);
+    return table[word] === "decided" ? "decided" : { kind: "void" };
+}
+function settledReading(checkpoint, gateBoundCallId) {
+    const byStatus = throughTable(SETTLED_GATE_READING, checkpoint.status, "checkpoint status");
+    return byStatus === "decided" ? decisionReading(checkpoint, gateBoundCallId) : byStatus;
+}
+function decisionReading(checkpoint, gateBoundCallId) {
+    try {
+        return readWinner(checkpoint, gateBoundCallId);
+    }
+    catch (e) {
+        return unreadable([`the settled row could not be read (${e instanceof Error ? e.name : "non-Error throw"})`]);
+    }
+}
+function readWinner(checkpoint, gateBoundCallId) {
+    const winner = checkpoint.resolvedOutcome;
+    const recorded = winner?.gateOutcome;
+    const [defect, ...more] = screenGateOutcome(recorded, { reading: "archive" });
+    if (defect !== undefined)
+        return unreadable([defect, ...more]);
+    const settlement = recorded?.settlement;
+    if (settlement === undefined)
+        return unreadable(["the gate record carries no settlement: no decider and no time"]);
+    if (!Number.isFinite(settlement.when))
+        return unreadable(["settlement.when is not a finite epoch-ms time"]);
+    const boundCallId = gateBoundCallId ?? (checkpoint.pendingAction.kind === "tool_approval" ? checkpoint.pendingAction.toolCallId : "");
+    const direction = approvalDecisionOfWinner(winner, boundCallId);
+    if (direction === null)
+        return unreadable([`the resolved winner is not an allow / deny bound to call "${boundCallId}"`]);
+    const byKind = throughTable(SETTLEMENT_KIND_READING, settlement.kind, "settlement.kind");
+    if (byKind !== "decided")
+        return byKind;
+    const note = typeof winner?.reason === "string" && winner.reason !== "" ? winner.reason : undefined;
+    return { kind: "decided", decision: direction === "approve" ? "allow" : "deny", decidedAtMs: settlement.when, ...(note !== undefined ? { decisionNote: note } : {}) };
+}
+function isReopenReason(word) {
+    return typeof word === "string" && REOPEN_REASONS.includes(word);
+}
+function openReading(checkpoint, gateBoundCallId) {
+    const reason = checkpoint.reopenReason;
+    if (!isReopenReason(reason))
+        return { kind: "open" };
+    const prior = decisionReading(checkpoint, gateBoundCallId);
+    const reopened = prior.kind === "decided"
+        ? { reason, decision: prior.decision, decidedAtMs: prior.decidedAtMs, ...(prior.decisionNote !== undefined ? { decisionNote: prior.decisionNote } : {}) }
+        : { reason };
+    return { kind: "open", reopened };
+}
+export function createParkedGateRead(cs) {
+    return async ({ gateToken, gateBoundCallId }) => {
+        const currency = await readGateCurrency(cs, gateToken);
+        switch (currency.kind) {
+            case "current":
+                return openReading(currency.checkpoint, gateBoundCallId);
+            case "absent":
+                return { kind: "unknown", why: "row_absent" };
+            case "settled":
+                return settledReading(currency.checkpoint, gateBoundCallId);
+            default: {
+                const unhandled = currency;
+                void unhandled;
+                return { kind: "unknown", why: "row_absent" };
+            }
+        }
+    };
+}
+//# sourceMappingURL=approval-gate-currency.js.map

package/dist/approval-hmac.d.ts

@@ -13,25 +13,25 @@ import type { ApprovalHmacKey } from "./auth-keys.js";
  * 被接管的客户端 —— 正是 HMAC 要防的风险模型)可以在操作员批准同一个动作的那次决定里,把落账理由换成
  * 别的:动作没变,**审计记录变了**。三方裁定纳入签名载荷,不留 `reasonUnsigned` 宽限代际(未上生产)。
  *
- * ── 🔴 **两把绑定的分工**(S-433 F1 立此,别再把它们当成一回事)─────────────────────────────────
+ * ── 🔴 **两把绑定的分工**([ref] F1 立此,别再把它们当成一回事)─────────────────────────────────
  * `principal-jwt.ts` 的 `approvalBnd`(JWT `cnf.bnd`)只哈希**前三位** `[sessionId, boundCallId, boundInputHash]`
  * —— 它绑的是**「哪一张卡」**(这份身份凭据被签发去决哪一次待决动作),所以决定内容改了它**不该**变。
  * 本文件的 HMAC 信封绑的是**「决了什么」**—— 决定本身的每一个会改变后果的字段都在里面(`decision`、
- * `reason`,以及 S-433 起的 `permissionModeAfter`)。⇒ 「同一张卡上把 approve 的档偷偷调宽」这件事,
+ * `reason`,以及 [ref] 起的 `permissionModeAfter`)。⇒ 「同一张卡上把 approve 的档偷偷调宽」这件事,
  * 结构上只有 HMAC 这一把拦得住;往 `cnf.bnd` 里加位既不解决它,还会把一份合法 JWT 绑死在一个它签发时
- * 根本不知道的值上。**本次(S-433 F1)只动 HMAC 这一把,`approvalBnd` 一个字节不动。**
+ * 根本不知道的值上。**本次([ref] F1)只动 HMAC 这一把,`approvalBnd` 一个字节不动。**
  *
  * ── 🔴 字节构造规则(权威定义;跨仓签名器照此实现,docs/ASSISTANT-WIRE-CONTRACT.md §6.2 同源)──────────
  * 被 HMAC 的是下面这个字符串的 **UTF-8 字节**:
  *   1. **恒 5 元素、定序**的紧凑 JSON 数组(元素间**无空格**):
  *      `[sessionId, boundCallId|null, boundInputHash|null, decision, reason|null]`
  *      —— 恒定长度是刻意的:签名器里少一个"有 reason 才追加"的条件分支,就少一类跨实现漂移。
- *      🔴 **唯一的例外是尾位**(S-452,server 7.87.0 起是**一只扩展对象**;7.86.0 的裸尾位形已删除):
+ *      🔴 **唯一的例外是尾位**([ref],server 7.87.0 起是**一只扩展对象**;7.86.0 的裸尾位形已删除):
  *      对扩展键**闭集** {@link APPROVAL_ENVELOPE_EXT_KEYS}(字典序即声明序)逐键判 `!== undefined`,
  *      在场的收进一只对象 `ext`;**`ext` 为空 ⇒ 一个字节都不追加**(消息与 7.85.0 逐字节相同),
  *      非空 ⇒ 追加为第 6 位 `[…head, ext]`。`JSON.stringify` 对 `ext` 的键序 = 插入序 = 闭集字典序,
  *      所以规范化无歧义,**与调用方给键的顺序无关**。
- *      为什么不继续用「裸的第 6、7 格」(S-433 的形):两个扩展位都可选 ⇒ 只有 `answer` 在场时它落在
+ *      为什么不继续用「裸的第 6、7 格」([ref] 的形):两个扩展位都可选 ⇒ 只有 `answer` 在场时它落在
  *      第 6 格、与 `permissionModeAfter` 撞位,靠类型猜是谁 = 签名歧义。扩展对象让「在场的是谁」自带
  *      名字,而且以后再加决裁字段不动数组形(规则集不再长)。
  *      向后兼容仍然成立的那一半:**不带任何扩展键的体**,字节与 7.85.0 逐字相同 ⇒ 不签这些位的既有
@@ -95,7 +95,7 @@ export interface ApprovalEnvelope {
     decision: string;
     reason?: string | null;
     /**
-     * 🔴 **S-452(7.87.0)—— 操作员对一次 AskUserQuestion 的回答进签名载荷。**
+     * 🔴 **[ref](7.87.0)—— 操作员对一次 AskUserQuestion 的回答进签名载荷。**
      *
      * 它此前**不在**信封里 ⇒ 一个能改写线上字节的中间人(反代 / 被接管的客户端 —— 正是 HMAC 的风险
      * 模型)可以在操作员签过的那次批准里只换 `answer`:动作没变、MAC 照过,**模型收到的答案变了**。
@@ -106,7 +106,7 @@ export interface ApprovalEnvelope {
      */
     answer?: QuestionAnswerProjection;
     /**
-     * 🔴 **S-433 合并复审 F1 [high]**(7.86.0 立,S-452 把它从裸尾位挪进扩展对象)—— `plan_review` 的
+     * 🔴 **[ref] 合并复审 F1 [high]**(7.86.0 立,[ref] 把它从裸尾位挪进扩展对象)—— `plan_review` 的
      * `permissionModeAfter` 选的是**批准之后这条 run 有没有手**(`acceptEdits` = 工作目录内的写不再逐次
      * 征询)。它铸下来时没有进签名载荷 ⇒ 中间人可以把操作员签的那次 `default` 批准原地改成 `acceptEdits`:
      * 动作没变、MAC 照过,**权限变了**。

package/dist/approval-policy-settlement.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-702 / S-706 —— 「无人可答」的**政策感知终态 claim**:全仓唯一一只(NP-2 的政策结算抽出来,四处调用,不写第二份)。
+ * [ref] / [ref] —— 「无人可答」的**政策感知终态 claim**:全仓唯一一只(NP-2 的政策结算抽出来,四处调用,不写第二份)。
  *
  * 一句话:一只没人答的 ask 在持久 ask 行上**落什么终局**,由部署政策(`UNATTENDED_APPROVAL_POLICY`)一处决定 ——
  *  · `park` ⇒ `expire` 意图:STREAM_PENDING→PARKING、批转投递面、同批流内兄弟连坐 VOID(park 路由的单位是整批,core 随后
@@ -15,7 +15,7 @@
  *  3. 两兜底臂 —— `ensureAsk` 行不可用 / ensure 身份不定(`tool-approval.ts` `landUnattendedOutcome`,只在交给 core 的是**结算**时
  *     调:park 路由不是结算,行留给投递面的既有机器,park 行为逐字不变),以及后者迟到落盘那条行的收尾;
  *  4. 崩溃恢复腿 —— 对账收敛器段二的孤儿 STREAM_PENDING 代打(`approval-reconciler.ts`):它就是窗到期竞争者在崩溃后的补位,
- *     同一只 claim、同一个转移(S-706 之前它无条件 `expireAsk`,deny 部署上崩溃后行进 PARKING,run 完成后成不带来源的 DENIED)。
+ *     同一只 claim、同一个转移([ref] 之前它无条件 `expireAsk`,deny 部署上崩溃后行进 PARKING,run 完成后成不带来源的 DENIED)。
  *
  * 形:纯委托 —— 店的原子终局 claim(`ApprovalAskStore.claimTerminal`,三 twin 一台 CAS 机器,律 2)+ 政策→意图的穷举映射。
  * 答案自足(律 1):赢 ⇒ `{claimed:true, voidedSiblings}`(refuse 恒空名单);输 ⇒ 携行真相;抛错 ⇒ 什么也不证明。

package/dist/approval-reconciler.d.ts

@@ -192,7 +192,7 @@ export interface ReconcileStats {
      *  (见 {@link RECONCILE_SEGMENT_BUDGET_MS})。 */
     budgetExhausted: number;
     /** 段二:被代打**窗到期终局 claim** 的孤儿 `STREAM_PENDING` 行数(赢 CAS 的)。「expired」指触发(窗过了没人收),
-     *  不指意图 —— 与 live 腿 `window_expired` 同一个读法:park 部署 ⇒ expire(进投递面);deny 部署 ⇒ refuse(当场落政策结算,S-706)。 */
+     *  不指意图 —— 与 live 腿 `window_expired` 同一个读法:park 部署 ⇒ expire(进投递面);deny 部署 ⇒ refuse(当场落政策结算,[ref])。 */
     orphansExpired: number;
 }
 /** 撤卡帧的投递面(逐 ctx 分发:durable 腿落账本、sync 腿 live,见 `ApprovalRevokeFrame` 顶注)。
@@ -226,13 +226,13 @@ export interface ApprovalReconcilerDeps {
     adhocGraceMs: number;
     orphanTtlMs: number;
     /**
-     * S-706:部署的无人值守政策(`UNATTENDED_APPROVAL_POLICY`)—— 段二孤儿代打打的是哪个终局 claim。**必填**、恒传(与协调器
+     * [ref]:部署的无人值守政策(`UNATTENDED_APPROVAL_POLICY`)—— 段二孤儿代打打的是哪个终局 claim。**必填**、恒传(与协调器
      * 读同一个部署值;没有缺省 —— 缺省 park 会让 deny 部署在崩溃恢复这一形上静默退回「进投递面 → 不带来源的 DENIED」)。
      */
     unattendedPolicy: UnattendedApprovalPolicy;
     emitRevoke?: ApprovalRevokeEmitter | undefined;
     /**
-     * S-1280:park 提交的唯一观察点(`plugins/park-commit-watch.ts`;在场 ⇔ 本部署有 checkpoint 店)。在场 ⇒ 收敛器订阅它:一只审批停车行
+     * [ref]:park 提交的唯一观察点(`plugins/park-commit-watch.ts`;在场 ⇔ 本部署有 checkpoint 店)。在场 ⇒ 收敛器订阅它:一只审批停车行
      * 提交的那一拍,对**这次调用**的 `PARKING` 行即时跑判据 1(与周期扫同一只执行体),`put` 等它收完才交还 core。缺席 ⇒ 只有周期扫(修前形)。
      */
     parkCommits?: Pick<ParkCommitWatch, "onParkCommitted" | "track"> | undefined;

package/dist/approval.d.ts

@@ -9,7 +9,7 @@ import { type ExecutionLane } from "./execution-lane-caps.js";
 import { type ApprovalExemptionStore } from "./plugins/approval-exemption-store.js";
 /**
  * 门意图判据读的五个量(`ServiceConfig` 结构满足)。单独成型是为了让**热路径**能拿「候选视图」来判
- * (S-668 波 2:`{ ...config, approvalRequire: 候选名单 }`)—— 判据只有一份,输入可以是活配置也可以是候选。
+ * ([ref] 波 2:`{ ...config, approvalRequire: 候选名单 }`)—— 判据只有一份,输入可以是活配置也可以是候选。
  */
 export interface GateIntentView {
     readonly approvalRequire: readonly string[];
@@ -21,7 +21,7 @@ export interface GateIntentView {
 /**
  * 三张审批名单(require / deny / never-auto)里**有没有一张在场** —— 「这台部署有一份要执行的审批策略」。
  *
- * 🔴 S-668 波 2(codex r1 F1):leader 车道的 durable 审批席曾只按 `approvalRequire` 非空给出。require 名单转热之后,
+ * 🔴 [ref] 波 2(codex r1 F1):leader 车道的 durable 审批席曾只按 `approvalRequire` 非空给出。require 名单转热之后,
  * 中心热撤空它就把 leader worker 上**独立**的 deny / never-auto 两张表一起撤掉(主车道照旧 deny / ask)—— 三张表是
  * 三条独立的限制,任何一张在场都要装策略。{@link hasOperatorGateIntent} 的名单三格就是本函数(同一判据,不写两份)。
  */
@@ -42,9 +42,9 @@ export declare function hasApprovalListIntent(config: Pick<GateIntentView, "appr
  */
 export declare function hasOperatorGateIntent(config: GateIntentView): boolean;
 /**
- * 单用户 turnkey 的 **auto-accept 基线**适用吗 —— 单用户(未开 `REQUIRE_PRINCIPAL`)∧ 运维零门意图。
+ * 单用户 turnkey 的 **auto-accept 基线**适用吗 —— 单用户(部署形表行 `multiTenant` 不成立)∧ 运维零门意图。
  *
- * 🔴 S-668 波 2 ③:**每请求现算**,不是 boot 常量。判据的输入 `approvalRequire` 自本批起在进程内会被中心
+ * 🔴 [ref] 波 2 ③:**每请求现算**,不是 boot 常量。判据的输入 `approvalRequire` 自本批起在进程内会被中心
  * 热换;boot 期算好的一个布尔会让「名单从空变非空」之后 allow-all 基线仍挂在每个新任务上 —— 运维刚表达的
  * 门意图被基线静默吞掉([ref] 方向)。所以消费点(`boot/resolve-spec.ts` 每个任务、stage-07 的 boot 姿态行、
  * run-local 的补偿 warn)一律调本函数,谁也不持有它的快照。
@@ -58,10 +58,10 @@ export declare function singleUserAutoAcceptBaselineApplies(config: GateIntentVi
  *    HIGH;与 env 墓碑族同谱系)。v4.3.0 的轮询门形(APPROVAL_REQUIRE + DB backend + DURABLE_APPROVAL 未设)在
  *    5.0.0 只剩 core 每任务 warn——**原先拦、现在放**(方向反转)。「留 undefined 让 core warn」对新配置是
  *    曝露误配,对升级存量是门静默消失,后者必须响亮。
- *  · **热路径**(S-668 波 2 ④,`web-admin-client/apply-effective.ts` 的审批组 stage):对**候选视图**
+ *  · **热路径**([ref] 波 2 ④,`web-admin-client/apply-effective.ts` 的审批组 stage):对**候选视图**
  *    (活配置 + 候选名单)判,拒因 ⇒ 审批组**整组拒**、活配置零变化、世代账停旧代。进程在跑,拒启不是选项;
  *    而放行一份「没有 checkpoint 店可停车」的名单 = 单用户 auto-accept 基线仍在、名单静默不生效。
- *  · **每个任务的装配**(S-1144,`boot/resolve-spec.ts` 的 `resolveSpec` 头一道):对**活配置**判,拒因 ⇒ 请求 501
+ *  · **每个任务的装配**([ref],`boot/resolve-spec.ts` 的 `resolveSpec` 头一道):对**活配置**判,拒因 ⇒ 请求 501
  *    `capability.checkpoint_store_required`。部署形到不了(boot 已拒启);可达的是嵌入方装配 / 直调 `resolveSpec`(自己递 ctx、没经 stage-07)。
  *    修前这一形把审批基线静默铸成 `undefined`,请求的 allow 清「普通问」后任务零卡落盘 —— 同一条规则在起服层拒、在装配层静默 = 一事两读。
  * `checkpointStorePresent` 是**部署事实**(本进程建没建出 checkpoint 店),不在 `ServiceConfig` 里 ⇒ 调用方显式递。
@@ -69,7 +69,7 @@ export declare function singleUserAutoAcceptBaselineApplies(config: GateIntentVi
  */
 export declare function gateIntentUnserviceableReason(config: GateIntentView, checkpointStorePresent: boolean): string | undefined;
 /**
- * S-602 C3 —— 「**无应答面**」两条 boot warn 的判据与文案(纯函数;stage-07 只负责打日志)。
+ * [ref] C3 —— 「**无应答面**」两条 boot warn 的判据与文案(纯函数;stage-07 只负责打日志)。
  *
  * 两条 warn 警的是同一类失败:一个 `ask` 发生了,而这台部署既没有活体协调器(`TOOL_APPROVAL_ENABLED`)也没有
  * durable 停车(`DURABLE_APPROVAL`)⇒ core `resolveAsk` 无 onAsk ⇒ headless 自动拒(fail-closed,写进转录)。
@@ -185,7 +185,13 @@ export declare function createDeploymentListExemption(store: Pick<ApprovalExempt
     warn(event: string, fields?: Record<string, unknown>): void;
 }, leg?: "parked_revive"): DeploymentListExemption;
 /**
- * **请求叶策略:`settings.permissions.neverAuto`**(S-1351)—— 命中名单的工具恒问真人;名单外「本层没有意见」(裸 allow)。叶只管请求自己写的那张表,部署的 `APPROVAL_NEVER_AUTO`
+ * **每腿自动批额度的审批人名**(本仓闭词;core `AskOutcome.approver` 契约逐字「a closed word the host owns, never a person」)。
+ * 结算记录读 `policy_allowed` / `who.party: "policy"` / `who.approver` = 本词 —— 审计读者按它认出「这一次放行是部署的自动批额度答的」,
+ * 与无人值守腿的 `unattended_class_answer`(`unattended-permission-mode.ts`)同族。
+ */
+export declare const AUTO_APPROVE_BUDGET_APPROVER = "auto_approve_budget";
+/**
+ * **请求叶策略:`settings.permissions.neverAuto`**([ref])—— 命中名单的工具恒问真人;名单外「本层没有意见」(裸 allow)。叶只管请求自己写的那张表,部署的 `APPROVAL_NEVER_AUTO`
  * 在基线里({@link createDurableAskPolicy}),两者经 `tightenGoverned` 的 deny-wins 折叠取并:请求叶只会**多**问,删不掉基线里的任何一行。
  *
  * 名字读法与部署名单是**同一只**({@link createApprovalListVerdict} → 精确 ∪ covering,收紧臂读调用答得上的全部名字):一条规则只有一种读法。问的铸点是

package/dist/approval.js

@@ -1,8 +1,10 @@
-import { isNamespacedCoveringRuleName, namespacedRuleNameCovers } from "@sema-agent/core";
+import { createApprovalPolicy, isNamespacedCoveringRuleName, namespacedRuleNameCovers } from "@sema-agent/core";
 import { operatorAlwaysHumanAsk, operatorAsk, requestAlwaysHumanAsk } from "./operator-ask.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "./approval-content-kind.js";
 import { isExplicitPosture } from "./posture-source.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
 import { handsOnWorkerFilePlane } from "./execution-lane-caps.js";
+import { NAME_TABLE_BEHAVIOR } from "./namespaced-rule-name.js";
 import { heldRuleName } from "./tool-rule-names.js";
 import { DURABLE_CONVERGE_READ_TIMEOUT_MS, policyAskStandingAnswerFacts, standingAnswerDurablyRecordable } from "./tool-approval.js";
 import { APPROVAL_EXEMPTED_EVENT } from "./plugins/approval-exemption-store.js";
@@ -16,7 +18,7 @@ export function hasOperatorGateIntent(config) {
         (config.durableApproval && isExplicitPosture(config.durableApprovalSource)));
 }
 export function singleUserAutoAcceptBaselineApplies(config) {
-    return config.requirePrincipal !== true && !hasOperatorGateIntent(config);
+    return !DEPLOYMENT_SHAPE_PREDICATES.multiTenant.holds(config) && !hasOperatorGateIntent(config);
 }
 export function gateIntentUnserviceableReason(config, checkpointStorePresent) {
     if (!hasOperatorGateIntent(config) || checkpointStorePresent)
@@ -114,13 +116,22 @@ export function createDeploymentListExemption(store, sessionId, logger, leg) {
 }
 function createNameSetMatcher(names) {
     const exact = new Set(names);
-    const covering = names.filter(isNamespacedCoveringRuleName);
+    const covering = names.filter((name) => isNamespacedCoveringRuleName(name, NAME_TABLE_BEHAVIOR));
     if (covering.length === 0)
         return (toolName) => exact.has(toolName);
     return (toolName) => exact.has(toolName) || covering.some((rule) => namespacedRuleNameCovers(rule, toolName));
 }
-function grantedByRule() {
-    return { action: "allow", decisionReason: "rule" };
+export const AUTO_APPROVE_BUDGET_APPROVER = "auto_approve_budget";
+function budgetSeatAnswer(req, requireHit, signal) {
+    let answered = false;
+    const seat = createApprovalPolicy({
+        requireApproval: [requireHit],
+        approve: () => {
+            answered = true;
+            return { allow: true, settledBy: "policy", approver: AUTO_APPROVE_BUDGET_APPROVER };
+        },
+    });
+    return { answered: () => answered, verdict: Promise.resolve(seat.check(req, signal)) };
 }
 export function createRequestNeverAutoPolicy(names, source) {
     const verdictOf = createApprovalListVerdict({ requireApproval: [], neverAuto: names });
@@ -149,7 +160,7 @@ export function createDurableAskPolicy(opts) {
     let autoApproved = 0;
     const isQuestionTool = (name) => name === ASK_USER_QUESTION_TOOL_NAME;
     return {
-        check: (req) => {
+        check: (req, signal) => {
             const verdict = verdictOf(req);
             switch (verdict.list) {
                 case "deny":
@@ -157,7 +168,7 @@ export function createDurableAskPolicy(opts) {
                 case "never_auto":
                     return operatorAlwaysHumanAsk(`APPROVAL_NEVER_AUTO(${verdict.hit})`, `human approval required to run "${req.toolName}"`);
                 case "require":
-                    return decideRequired(req, verdict.hit);
+                    return decideRequired(req, verdict.hit, signal);
                 case "none":
                     return { action: "allow" };
                 default: {
@@ -167,7 +178,7 @@ export function createDurableAskPolicy(opts) {
             }
         },
     };
-    function decideRequired(req, requireHit) {
+    function decideRequired(req, requireHit, signal) {
         const rem = req.budget?.resourceRemainingMicroUsd;
         if (rem !== undefined && rem <= 0) {
             return operatorAlwaysHumanAsk("RESOURCE_SUSPEND budget exhausted", `durable resource budget exhausted — human approval required to run "${req.toolName}"`);
@@ -180,17 +191,25 @@ export function createDurableAskPolicy(opts) {
                     exemption.onExempted(req.toolName);
                     return { action: "allow" };
                 }
-                return budgetOrAsk(req, ask);
+                return budgetOrAsk(req, ask, requireHit, signal);
             })();
         }
-        return budgetOrAsk(req, ask);
+        return budgetOrAsk(req, ask, requireHit, signal);
     }
-    function budgetOrAsk(req, ask) {
-        if (heldRuleName(req, isQuestionTool) === undefined && budget > 0 && autoApproved < budget) {
-            autoApproved++;
-            return grantedByRule();
-        }
-        return ask;
+    function budgetOrAsk(req, ask, requireHit, signal) {
+        if (heldRuleName(req, isQuestionTool) !== undefined || budget <= 0 || autoApproved >= budget)
+            return ask;
+        autoApproved++;
+        const { answered, verdict } = budgetSeatAnswer(req, requireHit, signal);
+        return verdict.then((d) => {
+            if (answered() && d.action === "allow")
+                return d;
+            autoApproved--;
+            return ask;
+        }, (err) => {
+            autoApproved--;
+            throw err;
+        });
     }
 }
 //# sourceMappingURL=approval.js.map

package/dist/auth-bridge.d.ts

@@ -3,7 +3,7 @@ import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";
 export type { VerifiedIdentity } from "@sema-agent/settings-schema/api/auth-bridge";
 /**
- * S-866 ② —— 鉴权桥 issuer 的**唯一**取值(装配 `boot/stage-09-leader.ts` 与 caps `centerWiring.issuer` 同读,不各写一份回退):
+ * [ref] ② —— 鉴权桥 issuer 的**唯一**取值(装配 `boot/stage-09-leader.ts` 与 caps `centerWiring.issuer` 同读,不各写一份回退):
  * 显式 `AUTH_BRIDGE_ISSUER`(`config.authBridgeIssuer`)恒赢 ⇒ `source:"explicit"`;缺席则回退中心基址 `webAdmin.baseUrl`
  * (配了中心即默认开桥)⇒ `source:"fallback"`;两者都没有 ⇒ `undefined`(桥不装)。
  */