@sema-agent/server 7.150.0 → 7.152.0

package/dist/approval-card.d.ts

@@ -590,8 +590,8 @@ export declare const ApprovalCardSchema: z.ZodObject<{
     inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
     allowRuleShadowed: z.ZodOptional<z.ZodArray<z.ZodObject<{
         member: z.ZodEnum<{
-            request: "request";
             deployment: "deployment";
+            request: "request";
             skill: "skill";
             hook: "hook";
             persisted: "persisted";
@@ -723,7 +723,7 @@ export type ApprovalCard = z.infer<typeof ApprovalCardSchema>;
  * `schema_version` 列同值,列供 SQL 侧过滤,信封里这份供读面在解出内容**之前**判形)。
  *
  * `approvalId` = 这张卡**呈出时**的 wire 身份。7.133.0 起它恒等于行的键 `askId`(一只 ask 一只 wire 身份),本服务的活读者(重放帧 /
- * 应答口 / 读口)一律读行的键、不读这一格;写它是给滚动升级窗里上一版的副本(它们的 strict 信封 schema 要求这一格并照它重放)。
+ * 决断口 / 读口)一律读行的键、不读这一格;写它是给滚动升级窗里上一版的副本(它们的 strict 信封 schema 要求这一格并照它重放)。
  * 唯一读这一格的是 local 车道的启动收敛 —— 拿它去审计账里查前世这只 ask 的成因:审计行记的就是当时呈出的那个 id
  * (更早写下的行上是当年的登记本地 id)。
  *
@@ -768,8 +768,8 @@ export declare const ApprovalCardEnvelopeSchema: z.ZodObject<{
         inputHasBidi: z.ZodOptional<z.ZodLiteral<true>>;
         allowRuleShadowed: z.ZodOptional<z.ZodArray<z.ZodObject<{
             member: z.ZodEnum<{
-                request: "request";
                 deployment: "deployment";
+                request: "request";
                 skill: "skill";
                 hook: "hook";
                 persisted: "persisted";
@@ -1032,8 +1032,8 @@ export declare function buildApprovalRequestFrame(input: {
  * ({@link adoptStoredLiveFacts};行 = 真源)。带 NUL / 孤代理的一组不落座(某个后端存不下逐字的那一份,见 {@link buildApprovalCardEnvelope})。
  * 卡面(`ApprovalCardSchema`)照旧不带这十一位(`approvalCard` 除外,见本注末段):
  * 它们在帧顶层、不在 `card` 里,信封上是卡旁边的一座,不是卡的键。
- * `readRootCandidate` 随重放的射程与卡上 `ruleOffers` 同一句(`ApprovalCardSchema.ruleOffers` 顶注):回授经重放帧自己的 `approvalId` 走活应答口,
- * 有等待腿的副本兑得动;接管登记 / 耐久回决口上没有等待腿,应答照收、目录不加(没有 `approval.read_root_granted` 通告 = 什么都没加)。
+ * `readRootCandidate` 随重放的射程与卡上 `ruleOffers` 同一句(`ApprovalCardSchema.ruleOffers` 顶注):回授经重放帧自己的 `askId` 走决断口的 live 形(体键 `readRootGrant`),
+ * 有等待腿的副本兑得动;接管登记上没有等待腿,决定照收、目录不加;停驻形带它 ⇒ 400、没有等待腿可交(没有 `approval.read_root_granted` 通告 = 什么都没加)。
  *
  * `requiresRealApproval` 不在表里:卡上 `risk.requiresRealApproval` 是同一个事实(铸卡第三参就是它),一个事实一个读法。
  * ⚠️ **`approvalCard` 是表里唯一一位 7.136.0 起同时在卡上的座**(`ApprovalCardSchema.approvalCard`:断连重放的卡要渲回同一张专卡,卡词必须进卡;
@@ -1054,9 +1054,8 @@ export declare function adoptStoredLiveFacts(frame: ApprovalRequestLiveFacts, se
 /**
  * [ref] §3.1 的呈卡帧(设计稿 §4.1 逐字)。
  *
- * 🔴 **一条腿一个帧族**:呈卡协议在一条腿上场(腿的审批上下文族词 `approval_request`)⇒ 这条腿上一只 ask 的开卡 / 消卡 / 撤卡只走本族
- * (`approval_request` / {@link ApprovalCompleteFrame} / {@link ApprovalRevokeFrame}),旧族 `tool_approval` / `tool_approval_complete`
- * 一帧都不发;协议未上场的腿只发旧族。同一只 ask 在同一条腿上不再有两种开卡帧,消费方不再按 `approvalId` 去重。
+ * 🔴 **审批只有这一个帧族**:一只 ask 的开卡 / 消卡 / 撤卡只走本族(`approval_request` / {@link ApprovalCompleteFrame} / {@link ApprovalRevokeFrame});
+ * 呈卡协议不上场的 worker 不呈卡(问交无人值守政策口),没有回退发的另一族。
  * 开卡的全部事实因此在本帧上:卡(`card`,耐久信封)+ 活面事实座({@link ApprovalRequestLiveFacts};活铸帧与重放帧同一份,见 {@link APPROVAL_REQUEST_LIVE_FACT_KEYS} 顶注)。
  */
 export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
@@ -1066,7 +1065,7 @@ export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
      * 活铸帧恒不带;行上有座的重放帧不带(座里缺的那一位就是真缺席)。不回填:存量行随窗到期收敛。
      */
     liveFactsUnknown?: true;
-    /** = SSE 具名事件名(与 `tool_approval` 同约定)。 */
+    /** = SSE 具名事件名。 */
     type: "approval_request";
     schemaVersion: 1;
     /** `deriveAskId` 派生(持久层主键;八元身份元组 —— 7.109.0 起含这一问的类集,7.143.0 起含展示的动作(工具名 + 入参摘要) —— 见 approval-ask-machine.ts)。 */
@@ -1082,22 +1081,21 @@ export interface ApprovalRequestFrame extends ApprovalRequestLiveFacts {
     expiresAtMs: number;
     serverNowMs: number;
     /**
-     * server 扩(不在设计字面):`POST /v1/tool-approvals/:id/respond` / `GET /v1/tool-approvals/:id` 的 id —— **恒等于 `askId`**(行的键就是这只 ask
-     * 唯一的 wire 身份;本族的消卡帧({@link ApprovalCompleteFrame})同带它)。
+     * server 扩(不在设计字面):**恒等于 `askId`**(行的键就是这只 ask 唯一的 wire 身份;本族的消卡帧({@link ApprovalCompleteFrame})同带它)。
+     * 7.152.0 起读它的两条口已删(决断口 / 读口按 `askId` 寻址),这一键只剩自指。
      */
     approvalId: string;
 }
 /**
  * 呈卡族的**单卡消卡帧**(`approval_complete`)—— 一只 ask 落定时发给每一条**收到过它的呈卡帧**的呈卡腿连接。
  *
- * 语义与旧族 `tool_approval_complete` 逐字同一件事(同一次 settle 的同一份判决:`outcome` 三词、非人结局的 `cause`、park 路由的
- * `parked`),只是它属于本族:键与开卡帧对位(`askId` / `taskId` / `approvalId`,开卡帧上有的身份这里都有),消卡按开卡那一帧的键。
+ * 一次 settle 的判决(`outcome` 三词、非人结局的 `cause`、park 路由的 `parked`):键与开卡帧对位(`askId` / `taskId` / `approvalId`,开卡帧上有的身份这里都有),消卡按开卡那一帧的键。
  * 与 {@link ApprovalRevokeFrame} 的分工:撤卡帧是**批级**的(兄弟被赢家连坐成 `VOID` 的那一批,名单 = 那一次原子事务的行集,
  * 不带逐卡终局);本帧是**单卡**的终局(人答 / 窗到期 / park 路由 / 取消 …)。同一只 ask 两帧都可能收到(被撤的兄弟自己的
  * 登记也按 settle 收场)—— 按 `askId` 清卡即可,两帧不冲突。
  *
  * 投递 = 开卡帧的同一只腿传输(`hitl-delivery.ts`:先本 run 账本、再直写 —— sync 腿有 durable run 行时两只都有,bg / resume 腿只有账本)。
- * 门 = 这条连接上**接下过开卡帧的那几只 sink**(没见过开卡帧的 sink 收到消卡帧就是孤儿 close,与旧族同一条门;配对在竞速机一处)。
+ * 门 = 这条连接上**接下过开卡帧的那几只 sink**(没见过开卡帧的 sink 收到消卡帧就是孤儿 close;配对在竞速机一处)。
  */
 export interface ApprovalCompleteFrame {
     /** = SSE 具名事件名(同 `approval_request` 约定)。 */

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

@@ -1,20 +1,20 @@
 /**
- * 一张停驻审批卡的「门」此刻还是不是它 —— 应答口判 `approval_stale` 与按问读口 `state` 的**同一只判官**。
+ * 一张停驻审批卡的「门」此刻还是不是它 —— 续跑腿判 `approval_stale`(`/decide` 与决断口的停驻形都经它)与按问读口 `state` 的**同一只判官**。
  *
  * ## 病灶(为什么要有这一只)
  * 问账行 `PARKED` 是终态(`approval-ask-machine.ts`:`PARKED: []`):赎回腿的单赢者是 **checkpoint 的 CAS**,取消腿动的也是 checkpoint(先 `expire` 门、再驱 run 终局),
- * 两条腿都不写 ask 行。于是「这张卡的门还在不在」这件事只有 checkpoint 店知道;读口若只看行,就会在卡被答过 / run 被取消之后继续说 `parked` 并指路去决定,
- * 而应答口对同一张卡早已答 `409 approval_stale`。同一件事两个读法 —— 本模块把它收成一个:读的是同一个问题、同一个来源。
+ * 两条腿都不改 ask 行的态(赎回受理之后只把决定记在行上,行仍 `PARKED`;门被引擎重开了行也不知道)。于是「这张卡的门还在不在」这件事只有 checkpoint 店知道;读口若只看行,就会在卡被答过 / run 被取消之后继续说 `parked` 并指路去决定,
+ * 而 7.151.x 及以前的应答口(7.152.0 起已删)对同一张卡早已答 `409 approval_stale`。同一件事两个读法 —— 本模块把它收成一个:读的是同一个问题、同一个来源。
  *
  * ## 判官
- * 问题:**这把 gate token 是不是该会话当前待决的审批门?**(应答口的答法:`resumeCheckpoint` 的 stale 臂 —— 回显的 token ≠ 该会话当前待决的审批门 ⇒ `409 approval_stale`。)
+ * 问题:**这把 gate token 是不是该会话当前待决的审批门?**(续跑腿的答法:`resumeCheckpoint` 的 stale 臂 —— 回显的 token ≠ 该会话当前待决的审批门 ⇒ `409 approval_stale`。)
  *  · {@link sightsCurrentGate} —— 「决断方回显的**门身份**(token / `checkpointId`)是不是当前门的同一面」的**唯一**比较(`approval_stale` 律,两道决断门一条,见下一节);
  *    本仓每一处拿**决断方 / 读口给的那把**门身份比「是不是当前门」都经它(`/decide` 的 token 回显、计划审阅的身份回显、下面的 {@link readGateCurrency});
  *    服务端对**自己选出的那张卡**的复核不是回显比较,不经它(`drivePlanReview` 的卡令牌复核答认领输家 `409 conflict.not_resumable`、唤醒腿的赢家比较);
  *    射程:本判官问的是「**哪扇门**」;`/decide` 的 [ref] 第二源问的是「**哪只调用**」(回显的 `boundCallId` vs 载入行的 `toolCallId`)—— 两问不同,所以是两条比较,
  *    不是「不能并」:它们共用同一个 409 答复,缺值规则各按各的问题定(说不出门身份 ⇒ 判「不是」;行上没有 `toolCallId` ⇒ 那一问不判,交引擎的绑定等值校验 fail-closed 兜)。
  *    过期决断的 409 一族(门身份 / 调用绑定两问怎么排成一族、老行那一形答哪个码)是 7.138.0 的设计票(DEBTS-server,主会话开票);
- *  · {@link currentApprovalGateToken} —— 该会话当前待决的审批门(审批门型优先,没有再退到任一待决行);应答口读它,读口读它,别处不再内联第二份;
+ *  · {@link currentApprovalGateToken} —— 该会话当前待决的审批门(审批门型优先,没有再退到任一待决行);续跑腿的 stale 臂读它,读口读它,别处不再内联第二份;
  *  · {@link readGateCurrency} —— 一把 token 对着它的读数:`current`(带那一行)/ `absent`(店里没有这一行)/ `settled`(行在,但不再是当前待决门:已结算、已过期、被取代);
  *  · {@link createParkedGateRead} —— 协调器读口的门读席:把读数译成读口要的四种读法({@link ParkedGateReading}),`state` 闭集不加字。
  *
@@ -46,19 +46,19 @@
  * ## `settled` 怎么译(读口只说 checkpoint 上有凭据的话;一条规矩)
  * 落盘的行不受类型面约束(旧版 / 手改 / 坏体 / 更新版本 core 写下的行可带闭集外的词或坏形),所以已结算门只按**一条规矩**读:
  *  ① 两个闭集词(行的 `status`、结算记录的种类 `settlement.kind`)各查一张穷举表,**同一查法**({@link throughTable}:只认表自己的键,非字符串不进表):
- *    表明说 `decided` ⇒ 往下读;明说 `void` ⇒ `void`(没有人决过它,答案无处兑现 —— 已过期〔取消 / 收割〕、仍待决却不是当前门〔被取代,应答口答 stale〕、
+ *    表明说 `decided` ⇒ 往下读;明说 `void` ⇒ `void`(没有人决过它,答案无处兑现 —— 已过期〔取消 / 收割〕、仍待决却不是当前门〔被取代,决断口的停驻形答 `approval_stale`〕、
  *    结算种类是引擎窗到期 / 宿主 SLA 扫 / 无人可答的失败族);**表外 ⇒ `unknown`**(读不懂的词撑不起「有人决过」,也撑不起「没有人决过它」);
  *  ② 结算赢家的门记录 `resolvedOutcome.gateOutcome` 先过 core 唯一的门记录筛 `screenGateOutcome`(**档案读法**:读回的耐久行,闭集 = 今日成员 ∪ 已退役词;
  *    坏形记缺陷、绝不抛;本仓 `trace/project.ts` 投影同一种记录也只经这一只筛),有缺陷 ⇒ `unknown`,过了筛才读它的成员。core 7.56.0 [ref] 起筛自己判
  *    I10(`settlement.when` 是有限数)与 I11(调用方把赢家的 `decision` 一并交给筛:它是赢家拿得出的词,方向与记录的结算种类 / 处置同向)—— 本判官在同一次筛调用里
  *    交 `winnerDecision`,时刻与方向的手判随之退役;
  *  ③ 分类之前记录要**读得全**:有结算记录、赢家绑的是这一行的调用且判词是 allow / deny(与
- *    `findDecidedApprovalsForBinding` 同一只 {@link approvalDecisionOfWinner})—— 缺一个都是 `unknown`(**不编一个首决**;读口答 404,应答口对已结算的门答 409 `approval_stale`,两口不同判;
+ *    `findDecidedApprovalsForBinding` 同一只 {@link approvalDecisionOfWinner})—— 缺一个都是 `unknown`(**不编一个首决**;读口答 404,决断口的停驻臂读作门上没站着决定;
  *    `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` 同判)。
+ * 行没了 ⇒ `unknown`(`row_absent`;赎回席对「checkpoint 行没了」的 404 `not_found.approval`〔决断口渲成 `not_found.ask`〕同判)。
  *
  * ## 盲区(core 的筛仍不判的一处,如实写下)
  *  · 种类 × 当事方的配对(结算种类与 `settlement.who` 的当事方是否相配)—— 筛不判(core [ref]),本判官也不核:读的是种类。只有坏行 / 手改行才走得到。
@@ -99,7 +99,7 @@ export interface GateCurrencyStore {
 }
 /**
  * 该会话**当前待决的审批门**的 token:审批门型({@link APPROVAL_GATE_KINDS})优先 —— 同会话 `task_done` 纯 park 与新 run 的审批 park 可以并存(表无 per-session pending 唯一约束),
- * 无序读会选中别的门型 —— 没有审批门才退到任一待决行(错门型诊断由 `/decide` 的 gate-kind 守卫点名)。应答口的 stale 臂与按问读口读这一只。
+ * 无序读会选中别的门型 —— 没有审批门才退到任一待决行(错门型诊断由 `/decide` 的 gate-kind 守卫点名)。续跑腿的 stale 臂与按问读口读这一只。
  */
 export declare function currentApprovalGateToken(cs: Pick<GateCurrencyStore, "findPendingTokenBySession">, sessionId: string): Promise<CheckpointToken | null | undefined>;
 /** 一把 gate token 对着判官的读数(`current` / `settled` 带分类用的那一行)。 */

package/dist/approval-gate-currency.js

@@ -91,21 +91,20 @@ function readWinner(checkpoint, gateBoundCallId) {
     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 } : {}) };
+    return { kind: "decided", decision: direction, decidedAtMs: settlement.when, ...(note !== undefined ? { decisionNote: note } : {}) };
 }
 function isReopenReason(word) {
     return typeof word === "string" && REOPEN_REASONS.includes(word);
 }
 function openReading(checkpoint, gateBoundCallId) {
-    const generation = checkpointRevOf(checkpoint);
     const reason = checkpoint.reopenReason;
     if (!isReopenReason(reason))
-        return { kind: "open", generation };
+        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", generation, reopened };
+    return { kind: "open", reopened };
 }
 export function createParkedGateRead(cs) {
     return async ({ gateToken, gateBoundCallId }) => {

package/dist/approval-hmac.d.ts

@@ -1,3 +1,4 @@
+import type { ParsedPersistRule } from "./tool-approval.js";
 import type { QuestionAnswer } from "@sema-agent/core";
 import type { ApprovalHmacKey } from "./auth-keys.js";
 /**
@@ -76,6 +77,15 @@ export declare function projectQuestionAnswer(a: QuestionAnswer): QuestionAnswer
  *  而是先投影(签它)、再由本函数重建(送它)—— 中间没有第二条路径,所以「签了 A 却转发了 A′」
  *  在结构上不可能。`note` 为 `null` ⇒ **不造键**(与 core `QuestionAnswerItem.note?` 的缺席同义)。 */
 export declare function questionAnswerFromProjection(p: QuestionAnswerProjection): QuestionAnswer;
+/**
+ * 「不再询问」规则位(`/decide` 体上的 `persistRule`,已过唯一体形判官)在签名载荷里的**投影**:一只定序元组 —— batch 臂 `["batch", 下标]`,文本两臂
+ * `["text", 规则文本, edited]`。签的是投影、转发的是由同一份投影重建的那一位({@link persistRuleFromProjection}),「签了 A 却兑了 A′」结构上不可能(与 `answer` 同形)。
+ * 不送它的签名器零改动(扩展位,缺席 ⇒ 一个字节都不追加)。
+ */
+export type PersistRuleProjection = readonly ["batch", number] | readonly ["text", string, boolean];
+export declare function projectPersistRule(slot: ParsedPersistRule): PersistRuleProjection;
+/** 投影 → 兑付收的那一位(**「签的 = 兑的」的兑现点**)。 */
+export declare function persistRuleFromProjection(p: PersistRuleProjection): ParsedPersistRule;
 /**
  * 信封的**扩展键闭集**(字典序 = 声明序 = `ext` 的 JSON 键序)。
  *
@@ -83,7 +93,7 @@ export declare function questionAnswerFromProjection(p: QuestionAnswerProjection
  * 下面那两条编译期门当场红。**不许有第三种在场判**:恒 `!== undefined`(不是真值判、也不是 `?? null`
  * 折叠)—— `null` 与缺席在扩展位上是两个不同的被签值(「签名方明说这次不动」≠「签名方不知道有这个键」)。
  */
-export declare const APPROVAL_ENVELOPE_EXT_KEYS: readonly ["answer", "checkpointId", "permissionModeAfter"];
+export declare const APPROVAL_ENVELOPE_EXT_KEYS: readonly ["answer", "checkpointId", "permissionModeAfter", "persistRule"];
 export type ApprovalEnvelopeExtKey = (typeof APPROVAL_ENVELOPE_EXT_KEYS)[number];
 /** The canonical envelope both {@link approvalHmacMessage} (the signer's/verifier's shared byte-rule) and
  *  {@link verifyApprovalHmac} take — ONE named type so the two signatures cannot silently drift into two
@@ -128,6 +138,12 @@ export interface ApprovalEnvelope {
      * —— 证明是瞬时物不是持久数据,没有迁移面,消费方的 401 就是通知(宪法「hard breaking 三句」)。
      */
     permissionModeAfter?: string | null;
+    /**
+     * `/decide` 的「不再询问」规则位(投影形 {@link PersistRuleProjection})进签名载荷。一条规则就是一条常驻放行 —— 与 `answer` / `permissionModeAfter` 同一条判据:
+     * **凡改变续跑能做什么 / 落什么账的决裁字段都在签名信封里**。直连门部署上停驻卡只有 `/decide` 这一扇口,拒收它就在这里造出一处「行说有、门拒键」。
+     * 在场才进扩展对象;缺席 ⇒ 字节与不认识它的签名器逐字相同(既有签名器零改动);带了不签 ⇒ `401 approval_mac_invalid`。
+     */
+    persistRule?: PersistRuleProjection;
 }
 export declare function approvalHmacMessage(env: ApprovalEnvelope): string;
 /** 签名载荷里 `reason` 的字符上限。**拒**而不是截 —— 截断在这条路径上**结构上不可行**:服务端截过的字节

package/dist/approval-hmac.js

@@ -5,7 +5,13 @@ export function projectQuestionAnswer(a) {
 export function questionAnswerFromProjection(p) {
     return { answers: p.map(([header, selected, note]) => ({ header, selected: [...selected], ...(note === null ? {} : { note }) })) };
 }
-export const APPROVAL_ENVELOPE_EXT_KEYS = ["answer", "checkpointId", "permissionModeAfter"];
+export function projectPersistRule(slot) {
+    return slot.kind === "batch" ? ["batch", slot.batchOfferIndex] : ["text", slot.rule, slot.edited];
+}
+export function persistRuleFromProjection(p) {
+    return p[0] === "batch" ? { kind: "batch", batchOfferIndex: p[1] } : { kind: "text", rule: p[1], edited: p[2] };
+}
+export const APPROVAL_ENVELOPE_EXT_KEYS = ["answer", "checkpointId", "permissionModeAfter", "persistRule"];
 const APPROVAL_ENVELOPE_HEAD_KEYS = ["sessionId", "boundCallId", "boundInputHash", "decision", "reason"];
 export function approvalHmacMessage(env) {
     const head = [env.sessionId, env.boundCallId ?? null, env.boundInputHash ?? null, env.decision, env.reason ?? null];

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

@@ -4,7 +4,7 @@
  * ## 规则(一句)
  * `GET /v1/approvals` 的 `pending[]`(与 `/v1/approvals/stream` 的 `pending` / `resolved` 帧)= **决断口是 `POST /v1/approvals/:id/decide` 的全部行**;
  * 每一行自报它属于哪一族(`kind`,本闭集一词),消费方**先按 `kind` 分支**,再读那一族的键。数组名仍是决断口的判据(`livePending[]` 的口是
- * `POST /v1/tool-approvals/:approvalId/respond`,不在本闭集里);本闭集回答的是「同一扇门后面是哪一种卡」。
+ * 决断口 `POST /v1/tasks/:taskId/asks/:askId/decision`,不在本闭集里);本闭集回答的是「同一扇门后面是哪一种卡」。
  *
  *  · `checkpoint` —— 停驻门(durable park):行 = 店的 `listPending` 那一行(键集照旧,另带 `kind`),门的 `:id` = 行的 `sessionId`,
  *    再按 `gateKind`(core 的门型闭集)分路;

package/dist/approval.d.ts

@@ -71,8 +71,8 @@ export declare function gateIntentUnserviceableReason(config: GateIntentView, ch
 /**
  * [ref] C3 —— 「**无应答面**」两条 boot warn 的判据与文案(纯函数;stage-07 只负责打日志)。
  *
- * 两条 warn 警的是同一类失败:一个 `ask` 发生了,而这台部署既没有活体协调器(`TOOL_APPROVAL_ENABLED`)也没有
- * durable 停车(`DURABLE_APPROVAL`)⇒ core `resolveAsk` 无 onAsk ⇒ headless 自动拒(fail-closed,写进转录)。
+ * 两条 warn 警的是同一类失败:一个 `ask` 发生了,而这台部署既没有活体协调器(只在呈卡协议上场时构造:`TOOL_APPROVAL_ENABLED` ∧ store backend ∧
+ * park 设施)也没有 durable 停车(`DURABLE_APPROVAL`)⇒ core `resolveAsk` 无 onAsk ⇒ headless 自动拒(fail-closed,写进转录)。
  * 运维要在 **boot** 就知道,否则会把随之而来的拒绝读成故障。两条 warn 按「ask 从哪来」**划分车道**,互补不重叠:
  *  · `fs_write_gate_no_responder` —— 写门的 Write/Edit ask。它只在**手写本机盘**时才会发生(写门挂在 host
  *    语义上,而 ask 要有手去触发)⇒ 判据 = {@link handsOnWorkerFilePlane}(今天 = `host`)。改前写的是

package/dist/approval.js

@@ -39,7 +39,7 @@ export function buildNoResponderBootWarns(input) {
         out.push({
             event: "fs_write_gate_no_responder",
             fields: {
-                hint: "host-semantics lane with no approval face: the engine's write-gate asks (permissionMode default/auto, absent reads as default; acceptEdits outside the write roots) will auto-deny (fail-closed); wire TOOL_APPROVAL_ENABLED=true or DURABLE_APPROVAL=true to answer them",
+                hint: "host-semantics lane with no approval face: the engine's write-gate asks (permissionMode default/auto, absent reads as default; acceptEdits outside the write roots) will auto-deny (fail-closed); wire DURABLE_APPROVAL=true on a store backend (DB_BACKEND) to answer them (approval cards additionally need TOOL_APPROVAL_ENABLED)",
             },
         });
     }
@@ -47,7 +47,7 @@ export function buildNoResponderBootWarns(input) {
         out.push({
             event: "workflow_gate_no_responder",
             fields: {
-                hint: "self-orchestration with no approval face: run_workflow asks (every permission mode but bypassPermissions, which releases them, and dontAsk, which refuses them; absent reads as default) will auto-deny (fail-closed); wire TOOL_APPROVAL_ENABLED=true or DURABLE_APPROVAL=true to answer them",
+                hint: "self-orchestration with no approval face: run_workflow asks (every permission mode but bypassPermissions, which releases them, and dontAsk, which refuses them; absent reads as default) will auto-deny (fail-closed); wire DURABLE_APPROVAL=true on a store backend (DB_BACKEND) to answer them (approval cards additionally need TOOL_APPROVAL_ENABLED)",
             },
         });
     }

package/dist/auth-bridge.d.ts

@@ -1,5 +1,6 @@
 import { VerifiedIdentity, type AuthBridgeErrorCode } from "@sema-agent/settings-schema/api/auth-bridge";
 import { type TokenScopeRefusal } from "@sema-agent/settings-schema/api/scopes";
+import type { ServiceConfig } from "./config-types.js";
 import type { Logger } from "./observability/logger.js";
 import type { Metrics } from "./observability/metrics.js";
 export interface WebAdminJwtVerifierOptions {
@@ -58,6 +59,25 @@ type ReportedOutcome = {
  * (调用方按验证失败处置:不设身份 ⇒ 门答 generic 401)。验证失败的结局验证器自己已记过账,这里只答「不装」。
  */
 export declare function admitBridgeIdentity(outcome: ReportedOutcome, sinks: BridgeSinks): BridgeIdentity | undefined;
+/**
+ * [ref] —— 「本 worker 把登录令牌绑在哪个 scope」的**唯一读口**(判官 {@link ssoForeignScope} 与起服行 `auth_bridge_enabled` 同读)。
+ *  · fleet 成员(`FLEET_GENERATION` 在场 —— 「是不是 fleet 形」在本仓的那一个读数,配置目录行「缺席 ⇔ 非 fleet 成员」)⇒ `config.fleetScope`:
+ *    env `FLEET_SCOPE` 的唯一读数(缺席 = 契约缺省 scope),排空口的身份比对读的就是这一个值 —— 一个事实一个读数,不另读 env。
+ *    编排器给每台受管引擎同拍渲成员代际与 `FLEET_SCOPE`;成员却缺 `FLEET_SCOPE` ⇒ 绑在缺省 scope(偏多拒,与排空口同读,不读成「不绑」)。
+ *  · 非成员(手接 / 壳起的个人引擎)⇒ `undefined` = 不绑:令牌的 scope 就是它的用户自己的空间,准入不比对(本仓不为这一形猜一个空间)。
+ */
+export declare function ssoBoundScopeOf(config: Pick<ServiceConfig, "fleetGeneration" | "fleetScope">): string | undefined;
+/**
+ * [ref] —— **sso 准入的 scope 相等判**(唯一判官;唯一调用点 = `http/dispatch.ts` 的入口预认证)。入参是**已装**的桥身份({@link admitBridgeIdentity} 交出的,
+ * scope 已由 `readTokenScope` 读定、恒在)。本 worker 绑了 scope 而令牌的 scope 不是它 ⇒ 拒,交回两只 scope(只进运维日志;HTTP 体不带本 worker 的 scope ——
+ * 那是另一个空间的名字);不绑或相等 ⇒ `undefined`(装)。逐字比较,不规范化(两边都是 scope id 形;不同就是不同)。
+ */
+export declare function ssoForeignScope(identity: {
+    readonly scope: string;
+}, config: Pick<ServiceConfig, "fleetGeneration" | "fleetScope">): {
+    readonly tokenScope: string;
+    readonly boundScope: string;
+} | undefined;
 /**
  * The live object `createWebAdminJwtVerifier` produces — a single `verify` entry point over the process-level JWKS cache, and the issuer it verifies for.
  * This is also the type of the injected seat (`ServiceDeps.webAdminJwtVerifier`): an embedder's verifier states which issuer it verifies, so `createHttpServer`

package/dist/auth-bridge.js

@@ -23,6 +23,15 @@ export function admitBridgeIdentity(outcome, sinks) {
     }
     return { ...rest, scope: scoped.scope, ...(inc.data !== undefined ? { principalInc: inc.data } : {}) };
 }
+export function ssoBoundScopeOf(config) {
+    return config.fleetGeneration === undefined ? undefined : config.fleetScope;
+}
+export function ssoForeignScope(identity, config) {
+    const boundScope = ssoBoundScopeOf(config);
+    if (boundScope === undefined || identity.scope === boundScope)
+        return undefined;
+    return { tokenScope: identity.scope, boundScope };
+}
 export const DEFAULT_JWKS_TTL_SEC = 15 * 60;
 export const JWKS_FETCH_TIMEOUT_MS = 10_000;
 const MAX_JWKS_BYTES = 256 * 1024;

package/dist/background-session-reap.d.ts

@@ -42,7 +42,7 @@ export interface SessionHardReap {
  *     `no_pgid`(未确认)、linux ⇒ `killed`;已收割 ⇒ `already_gone`。受据按观察答([ref] 车PA 删了「已硬收过」闩:组信号任一成员收到即
  *     成功,闩在部分送达时把活着读成没了),本函数也不为「让硬面先打」挪任何一拍。
  *
- * `scope` = 会话行属主 `owner ?? "default"`(与 core 注册铸值 `spec.principal ?? "default"` 同源 —— 缺席 scope 在 core 的
+ * `scope` = 会话的引擎租户分区 `sessionTenantScope`(唯一换算 `engineScopeOfOwner`,与 core 注册铸值同源 —— 缺席 scope 在 core 的
  * `canAccess` 上 fail-closed、一行都收不到,[ref] 钉过这一病)。
  *
  * 两处调用(见文件头 ①),都 `await`:E21 删除级联 `includeRetained:false`(显式活服务照留);停止口照传请求体。应答在硬面之后发,

package/dist/bake-runner/main.d.ts

@@ -16,7 +16,8 @@ interface RunnerEnv {
 }
 /**
  * bake-runner 的 **env 契约**(本进程只读这些;成文另见 USAGE.md §9.7):
- *  · 必填:`IMAGE_API_BASE`(image-api 根,尾斜杠去掉)、`BAKE_RUNNER_TOKEN`(claim / heartbeat 的运维主体 bearer;不进日志、不进子进程)。
+ *  · 必填:`IMAGE_API_BASE`(image-api 根,尾斜杠去掉)、`BAKE_RUNNER_TOKEN`(claim / heartbeat 的运维主体 bearer;不进日志、不进子进程 —— 它是本包的自有凭据,
+ *    登记在 `config-catalog.ts` `BAKE_RUNNER_CREDENTIAL_ENV`,起服第一步按名与按值向引擎声明:任何子进程组都拿不到它与它的同值副本,`BAKE_ENV_ALLOW` 点到它 ⇒ 拒启)。
  *  · `BAKE_RUNNER_ID`(缺省 `bake-runner-<HOSTNAME>`)、`RECIPE_REF`(缺省 `HEAD` = 用现成 checkout)、`RECIPE_DIR`(缺省 `/opt/recipes`)、
  *    `BUILD_SH_PATH`(缺省 `e2b-template/dev-sandbox/build.sh`)、`BAKE_DATA_DIR`(缺省 `/data`)、`LOG_LEVEL`(缺省 info)。
  *  · 数值四键(`parseNumOrFailNonNegative`,非数 / 负数拒启):`BAKE_HEARTBEAT_MS`(30000)、`BAKE_IDLE_POLL_MS`(5000)、
@@ -24,7 +25,8 @@ interface RunnerEnv {
  *  · `BAKE_ENV_ALLOW=NAME,NAME`(7.103.0,[ref] 残余):本进程 spawn 的每一只子进程组(build.sh 与 git fetch / docker push /
  *    docker image inspect / df)的 env 缺省 = 本进程 env 剥密(runner 自己的 `BAKE_RUNNER_TOKEN` 在内);名单点到的键从本进程 env **原样**
  *    放回(部署方显式承担 —— 例如配方脚本真要一枚 `*_PASSWORD` 做 registry 登录)。与服务侧 `LSP_ENV_ALLOW` **同一只**解析器
- *    (`config.ts` `parseEnvNameAllowlist`)与同一只放行谓词:形错(空段 / 尾逗号 / 非变量名形 / 点名任一只名单型旋钮)⇒ **拒启**,拒句点名
+ *    (`config.ts` `parseEnvNameAllowlist`)与同一只放行谓词:形错(空段 / 尾逗号 / 非变量名形 / 点名任一只名单型旋钮 / 点名本包自有凭据 —— 名是,
+ *    或值是,runner 自己的 `BAKE_RUNNER_TOKEN` 在内)⇒ **拒启**,拒句点名
  *    旋钮与段号、不回显值;本进程环境里没有的名 ⇒ 起服 `config_env_entry_rejected` 只报序号、不放行;旋钮原文本身按凭据类,不进子进程。
  *    没有多租户姿态(构建宿主守护进程没有主体 / 租户);生效名单见起服行 `bake_runner_start.envAllow`(只键名)。
  *    ⚠️ 这不是服务配置目录里的键(目录 `BAKE_*` 行是服务侧 bake API 的旋钮),服务进程不读它。

package/dist/bind-host.d.ts

@@ -1,19 +1,16 @@
 /** 读监听地址要的那几格(取自配置的同名键)。 */
 export interface BindHostConfig {
     bindHost?: string;
-    /** 缝合审 M5:`bindHost` 的**来源**决定它算不算 operator 明示,见 {@link resolveBindHost}。 */
-    bindHostSource?: "BIND_HOST" | "HOST";
     allowUnauthedWrites?: boolean;
     authToken?: string;
     authTokens?: Record<string, string>;
 }
-/** 这台部署配了任何一把 service 凭据吗(`SERVICE_AUTH_TOKEN` / `SERVICE_AUTH_TOKENS`)。 */
-export declare function anyServiceCredential(config: Pick<BindHostConfig, "authToken" | "authTokens">): boolean;
-/** 无鉴权写面(`ALLOW_UNAUTHED_WRITES`)+ 零凭据 ⇒ 起服把监听地址收窄到 loopback(见 {@link resolveBindHost})。 */
+/** 无鉴权写面(`ALLOW_UNAUTHED_WRITES`)+ 全局凭据门不武装(没配 service 凭据,`hasServiceAuth`)⇒ 起服把监听地址收窄到 loopback(见 {@link resolveBindHost})。
+ *  逃生口开着时写门不拒,而门不武装 ⇒ 能连上这个口的都能写 —— 鉴权桥在不在不改这一句(验不过 / 不带令牌的调用方照样过)。 */
 export declare function bindMustNarrow(config: Pick<BindHostConfig, "allowUnauthedWrites" | "authToken" | "authTokens">): boolean;
 /**
  * 这台进程的监听地址(绑址旋钮 + 无鉴权自收窄)。`undefined` = Node 缺省全接口。
- * `BIND_HOST`(兼容 `HOST`)显式值恒生效;缺省:**无鉴权写面(`allowUnauthedWrites` 且零凭据)自动收窄到 127.0.0.1**,其余维持全接口。
+ * `BIND_HOST` 显式值恒生效(绑址的唯一来源:`HOST` 不读);缺省:**无鉴权写面(`allowUnauthedWrites` 且零凭据)自动收窄到 127.0.0.1**,其余维持全接口。
  */
 export declare function resolveBindHost(config: BindHostConfig): string | undefined;
 /**

package/dist/bind-host.js

@@ -1,16 +1,13 @@
 import { isIP } from "node:net";
 import { canonicalAddress } from "./net-address.js";
-export function anyServiceCredential(config) {
-    return Boolean(config.authToken) || Object.keys(config.authTokens ?? {}).length > 0;
-}
+import { hasServiceAuth } from "./identity-source.js";
 export function bindMustNarrow(config) {
-    return Boolean(config.allowUnauthedWrites) && !anyServiceCredential(config);
+    return Boolean(config.allowUnauthedWrites) && !hasServiceAuth(config);
 }
 export function resolveBindHost(config) {
-    const mustNarrow = bindMustNarrow(config);
-    if (config.bindHost && !(mustNarrow && config.bindHostSource === "HOST"))
+    if (config.bindHost)
         return config.bindHost;
-    return mustNarrow ? "127.0.0.1" : undefined;
+    return bindMustNarrow(config) ? "127.0.0.1" : undefined;
 }
 export function listensLoopbackOnly(bindHost) {
     if (bindHost === undefined)

package/dist/boot/budget-tracing.js

@@ -34,7 +34,7 @@ export function createBudgetAndTracing(ctx) {
     const tracer = createTracer(metrics, costQuota, modelUsageTracker, fleetUsage, fleetLease, (m) => config.modelQuotaWeights[m] ?? 1, promptManifestTracker);
     const sideQueryAccounting = createSideQueryAccountant(metrics, costQuota, fleetUsage, fleetLease, (m) => config.modelQuotaWeights[m] ?? 1);
     const toolResultStore = backend?.toolResult ? backend.toolResult() : undefined;
-    const sessionPolicyStore = backend ? backend.sessionPolicy(logger) : undefined;
+    const sessionPolicyStore = backend ? backend.sessionPolicy() : undefined;
     const { store: fileHistoryStore, erasure: fileHistoryErasure } = assembleFileHistory(backend);
     return {
         brain, degradeRouteWatch, pricing, counterDegradeHook, costQuota, modelUsageTracker, promptManifestTracker,

package/dist/boot/coordinators.d.ts

@@ -38,7 +38,7 @@ export interface LiveCoordinatorsCtx {
      *  提交了没有」—— 审计 settle 行等 park 提交落定才写。缺席 = 没有 park 设施(core 在 ask 回调处就收场,没有提交这一步)。 */
     parkCommits?: ParkCommitWatch;
     /** [ref]:checkpoint 店(stage-06 的**同一只**,与 `parkCommits` 同源;在场 ⇔ 有 park 设施)。协调器的按问读口据它判一张 `PARKED` 卡的门此刻还是不是该会话当前待决的审批门
-     *  (判官 = `approval-gate-currency.ts`,应答口判 `approval_stale` 读的同一只)。缺席 ⇒ 读口只能说行说的话(`parked`)。
+     *  (判官 = `approval-gate-currency.ts`,续跑腿判 `approval_stale` 读的同一只)。缺席 ⇒ 读口只能说行说的话(`parked`)。
      *  也是流内审批协议上场门的 park 设施位:在场性与实例是一个事实 —— 门的 `active` 臂交出去的就是这一只,缺席 ⇒ 协议不上场(`no_park_facility`)。 */
     checkpointStore?: GateCurrencyStore;
 }

package/dist/boot/coordinators.js

@@ -19,18 +19,18 @@ export function createLiveCoordinators(ctx) {
     const durableEnabled = parkStore !== undefined;
     const streamApprovalGate = resolveStreamApprovalGate({
         toolApprovalEnabled: config.toolApprovalEnabled === true,
-        streamApprovalEnabled: config.streamApproval.enabled,
         backend,
         checkpointStore: parkStore,
     });
-    if (config.streamApproval.enabled && !streamApprovalGate.active) {
-        logger.info("stream_approval_disabled", {
+    if (!streamApprovalGate.active && streamApprovalGate.reason !== "no_tool_approval") {
+        logger.warn("approval_cards_unavailable", {
             reason: streamApprovalGate.reason,
             backendKind: backend?.kind ?? null,
             checkpointStore: backend?.checkpoint !== undefined,
             durableApproval: config.durableApproval === true,
-            toolApproval: config.toolApprovalEnabled === true,
-            askWindowMs: config.streamApproval.windowMs,
+            unattendedPolicy: config.unattendedApprovalPolicy,
+            note: "no approval card is presented on ANY leg of this worker (approval cards need a durable approval ledger: a store backend plus a park facility), so every gated tool call is refused fail-closed. " +
+                "Set DURABLE_APPROVAL=true on a store backend (DB_BACKEND) to get approval cards.",
         });
     }
     if (config.toolApprovalEnabled === true && config.streamApproval.windowMs === 0) {
@@ -47,12 +47,11 @@ export function createLiveCoordinators(ctx) {
         ? new FileApprovalAskAuditStore(config.localDataRoot)
         : undefined;
     const approvalExemptionStore = backend ? backend.approvalExemption() : undefined;
-    const toolApproval = config.toolApprovalEnabled
+    const toolApproval = streamApprovalGate.active
         ? new ToolApprovalCoordinator({
             ttlMs: config.streamApproval.windowMs,
-            ...(streamApprovalGate.active
-                ? { askStore: streamApprovalGate.askStore, unreachedTtlMs: config.streamApproval.unreachedTtlMs }
-                : {}),
+            askStore: streamApprovalGate.askStore,
+            unreachedTtlMs: config.streamApproval.unreachedTtlMs,
             windowMarginMs: config.streamAskWindowMarginMs,
             admitMaxPerTask: config.streamApproval.admitMaxPerTask,
             admitMaxPerOwner: config.streamApproval.admitMaxPerOwner,
@@ -103,7 +102,7 @@ export function createLiveCoordinators(ctx) {
         const send = sendFileLedger
             ? withLedgerRecording(rawSend, {
                 ledger: sendFileLedger,
-                deleteObject: (bucket, key) => issuer.deleteObject(bucket, key),
+                deleteObject: (bucket, key, track) => issuer.deleteObject(bucket, key, track),
                 warn: (msg, meta) => logger.warn(msg, meta),
             })
             : rawSend;

package/dist/boot/device-lane.js

@@ -1,5 +1,6 @@
 import { createDeviceEnrollment, createFixedWindowRateLimiter } from "../device-enrollment.js";
 import { createDeviceWsHub } from "../device-ws-hub.js";
+import { deviceOwnerConfinedTier } from "../http/principal-gate.js";
 export const DEVICE_ENROLL_RATE_POLICY = { limit: 10, windowMs: 60_000 };
 export function createDeviceLane(ctx) {
     const { config, logger, metrics, backend, replicaId, seat } = ctx;
@@ -20,6 +21,7 @@ export function createDeviceLane(ctx) {
         store,
         enrollment,
         replicaId,
+        ownerConfinedTier: (owner) => deviceOwnerConfinedTier(owner, config),
         logger: {
             warn: (msg, fields) => logger.warn(msg, fields),
             error: (msg, fields) => logger.error(msg, fields),

package/dist/boot/engine-lease.d.ts

@@ -245,6 +245,9 @@ export interface EngineLeaseExitReport {
  *  · `tickMs` = 自退检查的采样拍。自退发生在**生效窗**满之后、至多再晚一拍(顶注 8);生效窗恒 ≥ `lingerMs`(`lingerMs` 是各窗里最短的一个),所以触点比 `lingerMs` 密 ⇒ 在任何状态下都先于自退。
  *    读数**不预言**自退时刻:父还活着时生效的是 owned 窗,自退只会更晚。
  *  · `lane`([ref])= 此刻的车道(与自退判据同一只派生函数,每次现读)。
+ *  · `attached`([ref])= 本副本此刻**打开着的 SSE 流**条数 —— 与自退判据第一合取(`attachedStreams() === 0`)读**同一只**读口(`deps.attachedStreams()`),每次现读,不是采样拍的缓存。
+ *    哪些算、哪些不算写在契约 `/health` 节计法表的「附着」一列(与 `inflightBreakdown` 的「总数 / 阻断」两列同一张表):订阅流与流式提交腿算,后台腿、无流的同步腿、leader 腿不算。
+ *    它是**附着流条数,不是活跃调用方**:纯轮询壳(零 SSE)与毫秒级请求的下采样读到 0 合法 —— 判「这台引擎此刻有没有人在用」要连 `inflight` 与最近触点一起读(顶注 3),不能拿 `attached === 0` 当「没人」。
  *
  * ## 一源
  * 与租约腿自己的行为同一处铸出:`engine_lease_armed` 日志、自退判据用的窗、拍频推导(`tickMs = min(15s, 最短窗)`)和本读数读的是同一组数 ——
@@ -255,6 +258,8 @@ export interface EngineLeaseFacts {
     readonly tickMs: number;
     /** [ref]:此刻的车道。 */
     readonly lane: EngineLane;
+    /** [ref]:此刻打开着的 SSE 附着流条数(整数,≥ 0;语义与读口见上「报的是什么」一条 —— 附着流条数,不是活跃调用方)。 */
+    readonly attached: number;
     /** [ref] 首窗格({@link EngineLeaseFirstAttachFacts}):候首触窗有限(owned 窗有限)才在场 —— 永不到期的窗不上 wire(同上一段那条律)。 */
     readonly firstAttach?: EngineLeaseFirstAttachFacts;
     /** [ref] 交接格({@link EngineHandoverFacts}):只在 handover 车道在场。 */

package/dist/boot/engine-lease.js

@@ -184,6 +184,7 @@ export function createEngineLeaseTracker(deps) {
                 lingerMs: shortestLingerMs,
                 tickMs,
                 lane: laneNow().lane,
+                attached: deps.attachedStreams(),
                 ...(firstAttach !== undefined ? { firstAttach } : {}),
                 ...(handover !== undefined ? { handover } : {}),
             });

package/dist/boot/execution-env.d.ts

@@ -19,6 +19,7 @@ import { type LocalDockerCapacity } from "../plugins/local-docker-capacity.js";
 import * as facts from "../capability-facts.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { TaskInheritEnv } from "../request-value-closure.js";
+import { type SessionBindings, type SessionBindingSeat } from "../session-bindings.js";
 import { type HeadRead } from "../session-incarnation.js";
 import type { SpaceReclaimer } from "../workspace-space.js";
 import { type SessionResidentCounts } from "../session-resident-background.js";
@@ -43,20 +44,11 @@ import { type SessionResidentCounts } from "../session-resident-background.js";
  * 那一个副本上发生。跨副本的陈值靠「读面必经本副本的一次提交 ⇒ 必过本副本的围栏」兜住 —— 这条推理成立
  * 是因为 run 在受理它的那个副本上执行(ARCHITECTURE 副本模型)。device lane 的部署形本身也是单副本(§4.6)。
  */
-export interface SessionScopedRegistries {
+export interface SessionScopedRegistries extends SessionBindingSeat {
     readonly perSessionCwd: Map<string, string>;
     readonly perSessionShellEnv: Map<string, Record<string, string>>;
-    /** [ref]:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装;写只经 {@link setSessionInheritEnv}。 */
+    /** [ref]:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装。 */
     readonly perSessionInheritEnv: ReadonlyMap<string, TaskInheritEnv>;
-    setSessionCwd(sid: string, cwd: string): void;
-    setSessionShellEnv(sid: string, env: Record<string, string>): void;
-    /**
-     * [ref] —— 第三只 per-session 绑定(与 cwd / shellEnv 同一只 LRU 权威、同一条围栏、同一条删除)。
-     * `undefined` = **清掉**这一格(不是「不动」):`inheritEnv` 是「本条请求要什么」,缺席的请求要的是缺省清洗 ——
-     * 与 cwd / shellEnv 的「缺席 = 留着上一条的值」刻意不同(那两位由壳每条请求重发,粘住无害;这一位粘住 = 替一个没说话的
-     * 请求放宽凭据面)。
-     */
-    setSessionInheritEnv(sid: string, policy: TaskInheritEnv | undefined): void;
     /** 本进程见过的会话 → 属主(围栏表本身,只读视图;`null` = 匿名)。**会话驻留后台行的枚举源**:`session-resident-background.ts` 逐会话问注册表
      *  (core 的访问元组要带 scope,没有进程总数的读口),读的就是这一张 —— 每次提交写一笔、`dropSession` 清一笔、LRU 有界,不另立第二张会话名册。 */
     readonly sessionOwners: ReadonlyMap<string, string | null>;
@@ -178,9 +170,11 @@ export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     perTaskImage: PerTaskImageRegistry;
     sessionEnvSelection: SessionEnvironmentSelection;
     perSessionCwd: Map<string, string>;
-    setSessionCwd: (sid: string, cwd: string) => void;
-    setSessionShellEnv: (sid: string, env: Record<string, string>) => void;
-    setSessionInheritEnv: (sid: string, policy: TaskInheritEnv | undefined) => void;
+    sessionBindings: {
+        commitSessionBindings: (sessionId: string, bindings: SessionBindings) => import("../session-bindings.js").SessionBindingReceipt;
+        withdrawSessionBindings: (receipt: import("../session-bindings.js").SessionBindingReceipt) => boolean;
+        settleSessionBindings: (receipt: import("../session-bindings.js").SessionBindingReceipt) => boolean;
+    };
     fenceSessionOwner: (sid: string, owner: string | null, incarnation?: string) => void;
     dropSessionScoped: (sid: string) => void;
     dropSessionScopedOf: (sid: string, incarnation: string) => boolean;
@@ -190,6 +184,7 @@ export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     sendUserFileTaskEnvs: TaskEnvRegistry | undefined;
     lspManager: import("@sema-agent/core").NodeLspManager | undefined;
     spaceReclaimer: SpaceReclaimer | undefined;
+    sandboxApiCredentialsGate: (() => void) | undefined;
     sandboxSecretSeatGate: (() => Promise<void>) | undefined;
     sandboxReaper: SandboxReaper | undefined;
     sandboxGitPlane: SandboxGitPlaneSeat;