@sema-agent/server 7.150.0 → 7.152.0

package/dist/http/route-ctx.d.ts

@@ -16,6 +16,7 @@
  */
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { HostDecision } from "../host-decision.js";
+import type { Refusal } from "./refusal-body.js";
 import type { EntryProblem } from "../entry-problems.js";
 import type { SessionNotifyDoor } from "../session-notify-door.js";
 import type { TaskStream, TaskSpec, TaskResult, QuestionAnswer, Checkpoint, CheckpointToken, ResumeOutcome, RunInternals, Runner, EngineNotice, PendingSteerInput } from "@sema-agent/core";
@@ -26,7 +27,9 @@ import type { ImagesLocal } from "./routes/images.js";
 import type { CapabilitiesLocal } from "./routes/capabilities.js";
 import type { SessionsLocal } from "./routes/sessions.js";
 import type { SessionSyncLocal } from "./routes/session-sync.js";
+import type { OperatorPower } from "../operator-roster.js";
 import type { PlanApprovePermissionModeAfter } from "../task-settings.js";
+import type { PermissionModeWrite } from "../permission-mode-admission.js";
 import type { GateSighting } from "../approval-gate-currency.js";
 import type { VerifyRoundsSpec } from "./verify-rounds.js";
 import type { RunAbort } from "../run-cancel-context.js";
@@ -36,6 +39,7 @@ import type { RootedTaskSpec } from "./execution-context.js";
 import type { GateCommitment, GateSettlementEvidence } from "../gate-settlement.js";
 import type { ResumeRestatement } from "./resume-restatement.js";
 import type { RememberLaneCannotRecord } from "../parked-decide.js";
+import type { ParsedPersistRule, RuleSlotReceipt } from "../tool-approval.js";
 import type { RowWayOut } from "./resume-legs.js";
 import type { KeyCaller } from "../owner-faces.js";
 import type { Subject } from "../owner-brands.js";
@@ -156,6 +160,14 @@ export interface PreparedTaskSubmission {
      * 它能不能展示在它第一次落盘时就定了,这一跑的受理座答不了。缺席 = 体是这次请求自己的,标不标由受理座定。
      */
     bodyFromScreenedCtx?: true;
+    /**
+     * `body` 是从一份存量续跑输入里取回的(与 {@link bodyFromScreenedCtx} 同一种提交:`/decide` 的宿主新 turn)⇒ 这一跑新写的续跑输入**照抄**那一份的写据
+     * (`CheckpointCtx.permissionModeWrite`):这一跑没有写体顶层 `permissionMode` 那一格,只是抄了体。`stored` 缺席 = 那一份没有写据(7.152.0 之前写下的)⇒ 照缺席。
+     * 本位缺席 = 体是这次请求自己的 ⇒ 写据是提交写者的那一张(`submit-ctx.ts` `persistSubmissionCtx`)。
+     */
+    bodyPermissionModeWrite?: {
+        readonly stored: PermissionModeWrite | undefined;
+    };
     /**
      * 这次执行的**执行上下文**(唯一解析器 `http/execution-context.ts` `resolveExecutionContext` 的产物:根 · 住客 · 放置态 · 车道 · device 车道的设备意图)。
      * 提交门在装配之前铸(fresh);`/decide` 的宿主新 turn 交续跑折叠器铸的那一只(continuation)。每个 `runStore.createRun(` 成功点**必须**把它交给
@@ -227,6 +239,25 @@ export interface CheckpointCtx {
      * 缺席 = 没继承(含 7.150.0 之前写下的行:不回填,续跑不继承 = 那时的行为)。
      */
     projectContext?: import("../project-context.js").ProjectContext;
+    /**
+     * 这条 run 的**登记簿默认读层种子**(`project-registry.ts` 的 {@link import("../project-registry.js").MemorySeed}:种子项目 + 判出它的那一位观者)—— 新提交腿判一次:
+     * 这次提交带的项目对提交者可见(与 `GET /v1/projects/:id` 同一只判,观者 = 读面同一只推导)⇒ 种子;带了而判不出 ⇒ `null`(判过,无);没带项目 ⇒ 缺席。**服务端写、不来自请求体**(与 {@link memoryScope} 同为
+     * `body` 的兄弟键:提交腿推导、落盘,续跑原样读回)。冻结的是**观者**不是词:续跑以这一位观者经同一只可见性判重读此刻的登记(停驻期间改了词 ⇒ 新词;删了 / 换了主人 /
+     * 不再对他可见 ⇒ 没有种子)。写点:`buildCheckpointCtx`(提交腿那一笔,经 `persistSubmissionCtx` 读这条腿的部署事实);leader worker 的写者不带(它的体不带项目)。
+     * 续跑腿的写回传原 ctx / 其展开 ⇒ 随行。读者只有一只:`resume-legs.ts` `resolveResumeSpec` 把它原样递给装配器(`opts.memorySeed`)—— 续跑腿不推观者、不按 `body.projectId` 现查。
+     * 缺席而存体带了项目 = 本格出现之前写下的行(不回填:那时的提交腿没有判过可见性)⇒ 续跑不取种子,装配器记运维一行 `resume_memory_seed_unjudged`。
+     * 形只有一种读法(`frozenMemorySeedOf`,读口 `resume-ctx-read.ts`)。
+     */
+    memorySeed?: import("../project-registry.js").MemorySeed | null;
+    /**
+     * **写据**:谁写了 `body` 顶层 `permissionMode` 那一格、写下的是什么(形与规则的属主 = `permission-mode-admission.ts` 顶注「写据」)。**服务端写、不来自请求体**
+     * (与 {@link unattendedLeg} 同为 `body` 的兄弟键,客户端够不着)。写点:`buildCheckpointCtx`(必填键:提交写口写 `submission`;`/decide` 宿主新 turn 照抄宿主那一行的,
+     * 见 {@link PreparedTaskSubmission.bodyPermissionModeWrite};leader worker 写 `submission`)与改写口 `withStoredPermissionMode`(切档 `switch` · 续跑口的钳 `replay` ·
+     * `plan_review` 出口 `plan_review`)。续跑腿的写回传原 ctx / 其展开 ⇒ 随行。读者只有一只:续跑口 `stampReplayEntryMode`(地板在场时问「这一格是不是这块地板的出口写下的、
+     * 且还是它写下的那一格」)。形只有一种读法(`permissionModeWriteOf`,读口 `resume-ctx-read.ts`:读不出 ⇒ 坏体)。
+     * 缺席 = 7.152.0 之前写下的行(不回填:没有证据可补),或从这样的行照抄的体 ⇒ 不是出口写的,地板在场时照钳。
+     */
+    permissionModeWrite?: PermissionModeWrite;
 }
 /**
  * `/decide` 第三条车道交给宿主投递腿(wake:`DriveResumeArgs` / fresh:`DurableRunLegArgs`)的**一件**:这一跑在内存里带着的决定,
@@ -378,7 +409,8 @@ export interface DriveResumeArgs {
     /**
      * 🔴 **[ref](codex 交叉复审 r2-[medium] 验真后修):这条腿是**调用方发起**的吗?**
      *
-     * `true` = 有人在 HTTP 上点了按钮(resume / plan_review / wake / decide / 赎回席)⇒ 吃按**付费方**
+     * `true` = 有人在 HTTP 上点了按钮(resume / plan_review / wake / decide / 赎回席),或这一跑交付的是一条**已受理的人的决定**
+     * (workflow 停驻卡的 run 收场送达把它交给宿主会话的下一跑 —— 没有请求,但花的是卡属主的钱)⇒ 吃按**付费方**
      * (卡属主)判的成本配额准入(`ownerCostQuotaDenied`)。缺席/`false` = **部署自己的结算腿**
      * (内部 D-D SLA deny-sweep)⇒ **不吃**那道门。
      *
@@ -392,9 +424,8 @@ export interface DriveResumeArgs {
      * 并且整段时间攥着会话 claim。**方向也自洽**:deny 是**停下**这条 run 的动作,为了省钱而拒绝执行「停」
      * 与 preempt 路由早就成文的那句同一条(「否则超顶租户连自己的花费都停不下来」)。
      *
-     * 判别子取 `req` 的在场与否 —— 这在 `resumeCheckpoint` 里**已经是**「系统腿 vs 调用方腿」的既有判据
-     * (绑定强制、parked 分流两处都写着 `req !== undefined` 与「内部 D-D SLA deny-sweep(req 缺席)豁免」),
-     * 本位只是把同一条判据显式化成一个有名字的位,而不是让下游去猜。
+     * 判别子**不再**只是 `req` 的在场与否:`req` 缺席的腿有两种 —— SLA 拒扫(结算,不吃门)与 workflow 停驻卡的 run 收场送达(交付一条人的决定,
+     * 吃门,fail-closed)。所以本位是一个**有名字的事实**,由起腿的那一处写明(wake 腿:`req` 在场 ∨ 这一跑带着一件决定投递),下游只读这一位、不去猜 `req`。
      * ⚠️ **射程覆盖两道门**:紧邻的 fleet-lease 准入(`ownerFleetLeaseDenied`)读**同一位** —— [ref] 件⑤②
      * (codex r3-[high])把它一并改吃了 `callerInitiated`,理由与三问逐字同 cost 半场。
      * 🔴 本句是 [ref] R4 改写的(2026-09-03,7.57.0 发车前合并重扫 wf_1abaaa9a):此处原文写着「紧邻的
@@ -417,7 +448,7 @@ export interface DriveResumeArgs {
      *
      * 所以由上游把「已受理」这个事实传下来,`driveResumeLeg` 据此跳过重复协商。**安全性**:两处的键是
      * **同一个表达式**(`decodeCheckpointScope(cp.scope)`,上游门与下游 `auth.principal` 同源),射程条件也
-     * 同一条(`req !== undefined` ⇔ `callerInitiated`)⇒ 跳过的是一次**逐字相同**的判定,不是一道门。
+     * 同一条(上游判过两门 ⇔ 下游 `callerInitiated`:`/decide` 与 workflow 停驻卡的 run 收场送达都在交下来之前按卡属主判过)⇒ 跳过的是一次**逐字相同**的判定,不是一道门。
      * 缺席/`false` ⇒ 照常自己判(其余三条驱动腿与 sweep 一字不变)。
      */
     ownerLeaseAdmitted?: boolean;
@@ -479,7 +510,9 @@ export interface RouteLegs {
      *  同一属主判(缺席 ⇒ 恒不造键;判据属主=server.ts 铸键点注)。 */
     decider?: KeyCaller, 
     /** 续跑请求的重述键(`mcpServers` / `a2aPeers`),门读出并判过的那一份;缺席 = 冻结读法。语义属主 = `resume-restatement.ts` 顶注。 */
-    restatement?: ResumeRestatement): Promise<ResumeCheckpointOutcome>;
+    restatement?: ResumeRestatement, 
+    /** 这次决定带着「不再询问」请求({@link PersistRuleRequest})⇒ 本函数是它的**唯一铸点**,结局的 `ruleReceipt` 是它的回执({@link ResumeCheckpointOutcome})。 */
+    persistRule?: PersistRuleRequest): Promise<ResumeCheckpointOutcome>;
     /** 全 resume 家族的共同下半场(lease admission + 写 run log + fleet 发布)。 */
     driveResumeIntoRunLog(args: DriveResumeArgs): Promise<ResumeLegOutcome>;
     /** assistant 抢占腿的复位(gate-kind 守卫 + 行级属主复核 + 驱动)。 */
@@ -675,15 +708,15 @@ export interface RouteDeclFacts {
      *  编排器片 2 件 2:值 = 这一种计费请求的**种类**(`submit` 新工作 / `hitl-answer` 对等人的卡作答 / `resume` 续跑;闭集属主
      *  `http/readiness.ts` 的 `BILLABLE_KINDS`)—— 排空与租约过期只拒 `submit`(放行闭集表 `ADMISSION_TABLE`),无凭证门不看种类。 */
     readonly billable?: import("./readiness.js").BillableKind;
-    /** 「本条 url 在**没有任何 service credential** 的部署形下,这几个方法必须 fail-closed」。
+    /** 「本条 url 上这几个方法在**请求没带凭据门认的凭据**(service 凭据 / 鉴权桥验过的登录令牌;`identity-source.ts` 头注律 5)时必须 fail-closed」。
      *  判据(两个合取项)= 「授权的唯一输入是 principal 头」∧「持久改写,或爆炸半径跨租户的治理读」;
      *  逐口论证在各 `routes/*.ts` 的头注里,声明行只记结论。 */
     readonly credentialGated?: readonly RouteMethod[];
     /** 「这条 url **是**计费提交面,但它到底提不提交由**请求体里的方法**决定」—— 单 URL 多方法的
      *  JSON-RPC 端点。两道**可用性** 503(drain / roster-pending)按 url 一刀切会把同端点上的纯读一起
      *  关掉,所以分派器对本行**跳过**那两道,改由域模块在写分支里施加同样的两道(文案逐字同源)。
-     *  🔴 只豁免那两道,**不豁免安全轴**:`billable` 本身仍为 true,无 service token 那道 fail-closed
-     *  503 照旧罩着(它判的是「这台机能不能收写」,与方法无关,且必须在解析请求体之前)。 */
+     *  🔴 只豁免那两道,**不豁免安全轴**:`billable` 本身仍为 true,写门那道 fail-closed
+     *  503 照旧罩着(它判的是「这次请求带没带过门的凭据」,与方法无关,且必须在解析请求体之前)。 */
     readonly methodDispatched?: true;
 }
 /** **可分派行**多出来的列([ref] 第三刀):身份 + 它真认的方法(+ [ref] 的订阅类)。纯门行一列都没有(见下)。 */
@@ -709,6 +742,12 @@ interface RouteDeclIdentity {
      * 不带它 —— 那条流就是 sync 腿本身(关流 = 断连语义),照旧算在飞。漏标一条订阅的方向是**多算在飞**(排空多等),不是少等。
      */
     readonly subscription?: true;
+    /**
+     * 「本路由对持这只运维权力的**非人档**开放;本口的运维门按它判」(档表 `operator-roster.ts`)。缺席 = 没声明 —— 非人档(服务主体)的身份在本路由上不算数,
+     * 分派层整次请求 403 `auth.principal_confined`(`principal-gate.ts` 的 `requestConfinedTier`,只扫带本列的行)。只住在可分派行上(纯门行是前缀、比任何路由都宽,
+     * 型上就开不出一段前缀的权力)。今天只有排空口声明 `power: "drain"`。
+     */
+    readonly power?: OperatorPower;
 }
 /**
  * **可分派行**:一条真路由。匹配式二选一 —— `path`(精确;标签**就是** path 自身,所以没有 label 列,
@@ -750,23 +789,60 @@ export interface ResumeLegOutcome {
     body: object;
 }
 /**
- * 「本会话不再询问」的请求 —— **两扇门同一只**:`/decide` 体上的 `remember:"session"`、应答口(`POST /v1/tool-approvals/:id/respond`)命中停驻行的
- * `allow_session`。铸点只有一只:{@link RouteLegs.resumeCheckpoint} —— 可记与否从**已属主校验的载入停驻行**判(`standingAnswerDurablyRecordable`,
+ * 「本会话不再询问」的请求 —— **两扇门同一只**:`/decide` 体上的 `remember:"session"`、决断口(`POST /v1/tasks/:taskId/asks/:askId/decision`)命中停驻行的
+ * `remember:"session"`。铸点只有一只:{@link RouteLegs.resumeCheckpoint} —— 可记与否从**已属主校验的载入停驻行**判(`standingAnswerDurablyRecordable`,
  * 与运维队列行的 `rememberRefused` 同一只判据)、锚由车道定(任务级 = 这个会话;bg 停驻子代 = 行的 root/host 会话)、落豁免店**只在**这次决定
  * 被证明已结清之后(`decisionCommittedOf`)、`rememberApplied` = 落没落(店抛 ⇒ `false` + warn,这次的放行不回滚)。门自己不写店、不判可记。
  * 两口唯一的差 = `laneCannotRecord`(记不住的车道上怎么答;闭集与理由的属主 = `parked-decide.ts` 的 {@link RememberLaneCannotRecord})。
  */
 export interface RememberSessionRequest {
-    /** 豁免行的签发人(`grantedBy`)= 门已验的身份(`/decide` 的决断方 / 应答口的调用方);匿名开放部署 ⇒ `null`。 */
+    /** 豁免行的签发人(`grantedBy`)= 门已验的身份(`/decide` 的决断方 / 决断口的调用方);匿名开放部署 ⇒ `null`。 */
     readonly grantedBy: string | null;
     readonly laneCannotRecord: RememberLaneCannotRecord;
 }
-/** {@link RouteLegs.resumeCheckpoint} 的结局 = 腿的应答 + 带了「本会话放行」请求时铸点的答(`rememberApplied`:落没落)。键只在证得出提交的两条车道
- *  (bg 停驻子代赎回 / 任务级续跑)的结清点上铸;其余出口(拒 / workflow 投递 / 抛)键缺席 ⇒ 门读作「没记住」(`=== true`)。
- *  这一位是进程内的结局位,不进 `body` —— 由门决定挂不挂到回执上(两扇门都只挂在这次真做了授予判定的回执上;幂等回放不挂)。 */
+/**
+ * 决定体上「本会话放行」那一键(`remember`)的**唯一读法** —— 两扇人决口同调:有问行的卡的决断口(`POST /v1/tasks/:taskId/asks/:askId/decision`)与
+ * 运维队列的耐久门(`POST /v1/approvals/:sessionId/decide`)。闭集一词 `"session"`;只配 `approve`(「记住的拒」是另一种语义,不从这一键带进来)。
+ * 拒句与码两口逐字同一(由本读法铸);各口自己的门(直连门的签名覆盖、豁免店在场)在本读法之后各判各的。
+ * 拒 = 一只 {@link Refusal}(码 + 句 + 机读位在本读法一处铸,冲突形的机读位随拒同铸),两扇口原样发 `400`、不再按码二次分支。
+ */
+export type RememberSlotReading = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "session";
+} | {
+    readonly kind: "refused";
+    readonly refusal: Refusal;
+};
+/** `remember` 闭集外的拒句(`400 request.field_invalid`;两扇人决口同一句,由 {@link readRememberSlot} 铸)。 */
+export declare const REMEMBER_MUST_BE_SESSION = "remember must be \"session\"";
+/** `remember` 配 deny 的拒句(`400 request.field_conflict` + 机读位 `remember_decision`;同上)。 */
+export declare const REMEMBER_REQUIRES_APPROVE = "remember requires decision 'approve'";
+export declare function readRememberSlot(raw: unknown, decision: "approve" | "deny"): RememberSlotReading;
+/**
+ * 「不再询问」的请求 —— **两扇门同一只**(「本会话放行」{@link RememberSessionRequest} 的孪生):`/decide` 体上的 `persistRule`、赎回席交来的那一问(活卡回决口
+ * 命中停驻行时卡上的 `persistRule`)。体形判官只有一只(`tool-approval.ts` 的 `readPersistRuleSlot`)。铸点只有一只:{@link RouteLegs.resumeCheckpoint} 在已属主
+ * 校验的载入停驻行上读这张卡的记录(有问行读问行,没有读停驻行),在结清点(`landAfterCommit`,与「本会话放行」同一读 `decisionCommittedOf`)交唯一兑付函数
+ * `redeemCardRule`。证不出提交 ⇒ 不兑,回执 `rulePersisted:false` + `rule_lane_unavailable`;**不 400**:规则位的成文律是「裁决本身绝不因规则没存上而改判」
+ * (与 `remember` 在 `/decide` 上「硬意图键,记不住就 400」刻意不同 —— 两个键各守各的成文律)。
+ */
+export interface PersistRuleRequest {
+    readonly slot: ParsedPersistRule;
+    /** 这次决定带了 `updatedInput`(编辑放行)⇒ 兑付答 `rule_input_edited`:生效的是编辑后的调用,候选是从原始命令铸的。 */
+    readonly inputWasEdited: boolean;
+}
+/** {@link RouteLegs.resumeCheckpoint} 的结局 = 腿的应答 + 带了「本会话放行」请求时铸点的答(`rememberApplied`:落没落)+ 带了「不再询问」请求时铸点的回执(`ruleReceipt`)。
+ *  两位只在证得出提交的两条车道(bg 停驻子代赎回 / 任务级续跑)的结清点上铸;其余出口(拒 / workflow 投递 / 抛)缺席 ⇒ 门读作「没记住」(`=== true`)/ 规则位
+ *  由 {@link ruleReceiptOf} 补成「没存上」。两位都是进程内的结局位,不进 `body` —— 由门挂到这次真做了授予判定的回执上(幂等回放不挂)。 */
 export type ResumeCheckpointOutcome = ResumeLegOutcome & {
     readonly rememberApplied?: boolean;
+    readonly ruleReceipt?: RuleSlotReceipt;
 };
+/**
+ * 一次带了 `persistRule` 的续跑在回执上的规则位(两扇门同调这一只:`/decide` 与赎回席)—— 结清点铸了就是它;没铸(不经结清点的出口:workflow 投递 / 证不出提交)
+ * ⇒ `rulePersisted:false` + `rule_lane_unavailable`(「请求带了、结局没答」只在这里补一处)。没带 ⇒ `undefined`(一个键都不加)。只在 2xx 上挂(调用方判)。
+ */
+export declare function ruleReceiptOf(out: ResumeCheckpointOutcome, persistRule: PersistRuleRequest | undefined): RuleSlotReceipt | undefined;
 /**
  * **「决定/续跑已受理」那一枚 200 收据的单一铸点**([ref])。
  *

package/dist/http/route-ctx.js

@@ -1,4 +1,5 @@
 import { sendJson } from "./send.js";
+import { fieldConflictFacts } from "../field-conflict.js";
 export function noteResumeClientGone(res, out, logger) {
     if (out.status !== 200 || out.body.status !== "resuming")
         return;
@@ -21,6 +22,22 @@ export function assertNever(x) {
     throw new Error(`unreachable route id: ${String(x)}`);
 }
 export const ROUTE_METHOD_ORDER = ["GET", "POST", "PUT", "PATCH", "DELETE"];
+export const REMEMBER_MUST_BE_SESSION = `remember must be "session"`;
+export const REMEMBER_REQUIRES_APPROVE = "remember requires decision 'approve'";
+export function readRememberSlot(raw, decision) {
+    if (raw === undefined)
+        return { kind: "absent" };
+    if (raw !== "session")
+        return { kind: "refused", refusal: { errorCode: "request.field_invalid", message: REMEMBER_MUST_BE_SESSION } };
+    if (decision !== "approve")
+        return { kind: "refused", refusal: { errorCode: "request.field_conflict", message: REMEMBER_REQUIRES_APPROVE, facts: fieldConflictFacts("remember_decision", ["remember", "decision"]) } };
+    return { kind: "session" };
+}
+export function ruleReceiptOf(out, persistRule) {
+    if (persistRule === undefined)
+        return undefined;
+    return out.ruleReceipt ?? { rulePersisted: false, ruleRefusal: "rule_lane_unavailable" };
+}
 export function acceptedResumingReceipt(taskId, sessionId, evidence) {
     return { status: 200, body: { taskId, sessionId, status: "resuming", bindingEnforced: true, ...evidence } };
 }

package/dist/http/route-table.d.ts

@@ -55,6 +55,7 @@ import type { FlatServiceDeps } from "./server.js";
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { RouteDecl, RouteDispatchDecl, RouteMatch, RouteCtx, RouteMethod } from "./route-ctx.js";
 import type { BillableKind } from "./readiness.js";
+import type { OperatorPower } from "../operator-roster.js";
 /** 一只域 handler 相对**全局服务凭据门**的位置。门前 = 未鉴权可达(每一只都要单独论证),门后 = 先过凭据。 */
 /**
  * 一行路由在全局服务凭据门的哪一侧、吃哪道门(闭集,三员;[ref] 起由两员拆成三员):
@@ -136,7 +137,7 @@ export declare function routeLabel(_method: string, url: string): string;
 export declare function isBillableSubmitPath(url: string): boolean;
 /** 编排器片 2 件 2:这条 url 是哪一**种**计费请求(`undefined` = 不在计费面)。声明序第一条命中的行定种类(今天每条 url 至多命中一行)。 */
 export declare function billableKindOf(url: string): BillableKind | undefined;
-/** [ref]([ref] 件5)—— **改写门**:不烧模型、但在没有任何 service credential 的部署形下必须
+/** [ref]([ref] 件5)—— **改写门**:不烧模型、但在请求没带凭据门认的凭据时(`identity-source.ts` 头注律 5)必须
  *  与 billable / bake 两族一样 fail-closed 的写门。与 `isBillableSubmitPath` **刻意分开**:这几扇门
  *  `billable=false`(零模型工作),塞进那张名单会让它们连带吃 drain 与 roster-pending 两道 503 ——
  *  而收编与规则读写在排空期/roster 未落时做完全无害。 */
@@ -144,6 +145,9 @@ export declare function isCredentialGatedRewrite(method: string, url: string): b
 /** [ref]:这次请求是不是一条**只读订阅**(`RouteDeclFacts.subscription` 那一列;方法也要对上 —— 订阅行恒只认 GET)。
  *  分派器在 admission 那一拍(第一个 await 之前)同步判它:订阅不进在飞计数,只进附着集与订阅集。 */
 export declare function isSubscriptionRequest(method: string, url: string): boolean;
+/** 这次请求(方法 + 路径)命中的那一行声明的运维权力(声明行的 `power` 列;`undefined` = 没命中任何带 `power` 的行)—— 分派层的圈禁判只读这一只
+ *  (`principal-gate.ts` 的 `requestConfinedTier`)。方法也要对上:路径命中而方法不在列的请求对非人档同答圈禁(不再区分 404 / 405)。 */
+export declare function declaredPowerOf(method: string, url: string): OperatorPower | undefined;
 /** 见 `RouteDeclFacts.methodDispatched` 的头注(单 URL 多方法端点)。 */
 export declare function isMethodDispatchedSubmitPath(url: string): boolean;
 /** 一次分派查找的结果:命中的行与它的参数,外加**这条路径上所有行**的方法并集(405 的 `Allow`)。 */

package/dist/http/route-table.js

@@ -122,6 +122,7 @@ const SHAPED_LABEL_DECLS = ROUTE_DECLARATIONS.filter((d) => !("path" in d) && ty
 const BILLABLE_DECLS = ROUTE_DECLARATIONS.filter((d) => d.billable !== undefined);
 const METHOD_DISPATCHED_DECLS = ROUTE_DECLARATIONS.filter((d) => d.methodDispatched === true);
 const SUBSCRIPTION_DECLS = ROUTE_DECLARATIONS.filter(isDispatchDecl).filter((d) => d.subscription === true);
+const POWER_DECLS = ROUTE_DECLARATIONS.filter(isDispatchDecl).filter((d) => d.power !== undefined);
 const CREDENTIAL_GATED_BY_METHOD = (() => {
     const m = new Map();
     for (const d of ROUTE_DECLARATIONS)
@@ -156,6 +157,9 @@ export function isCredentialGatedRewrite(method, url) {
 export function isSubscriptionRequest(method, url) {
     return SUBSCRIPTION_DECLS.some((d) => d.methods.includes(method) && matchDecl(d, url) !== null);
 }
+export function declaredPowerOf(method, url) {
+    return POWER_DECLS.find((d) => d.methods.includes(method) && matchDecl(d, url) !== null)?.power;
+}
 export function isMethodDispatchedSubmitPath(url) {
     return METHOD_DISPATCHED_DECLS.some((d) => declMatches(d, url));
 }

package/dist/http/routes/admin-config-refresh.js

@@ -13,11 +13,11 @@ export async function handleAdminConfigRefresh(req, res, match, ctx) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
-            if (!facts.operatorLane(deps).available) {
-                sendOperatorPrincipalsRequired(res);
+            if (!facts.operatorLane(deps, "operate").available) {
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             }
-            if (!explicitOperatorOk(principal, deps.config)) {
+            if (!explicitOperatorOk(principal, deps.config, "operate")) {
                 sendError(res, 403, "auth.operator_only", OPERATOR_ONLY_MESSAGE);
                 return;
             }

package/dist/http/routes/admin-drain.d.ts

@@ -6,6 +6,8 @@
  * 进入排空经 `drainState.enter`(收尾链装的唯一入口)。
  *  · 门序 = operator 面的既有口径(`routes/retention-ops.ts` 逐字):身份 → 授权 → 验型;billable=false,**刻意不吃排空 503**
  *    (排空中的重放必须能拿到 `already_draining` 回执,吃了就自锁)。
+ *  · 授权 = 持 `drain` 权力(声明行的 `power` 列,本口的门与分派层的圈禁判读同一格):全运维档(`OPERATOR_PRINCIPALS`,持每一只权力)∪ 排空档
+ *    (`OPERATOR_DRAIN_PRINCIPALS`,服务主体只持这一只 —— 它的身份只在本口算数,别的口 403 `auth.principal_confined`,见 `operator-roster.ts`)。
  *  · 判序:体坏(含动作号不是标识符形 —— settings-schema 11 `DRAIN_ACTION_ID`)⇒ 400 `request.field_invalid`(零状态变化)→ 没有收尾链(嵌入宿主 / 测试夹具)⇒ 501 `capability.drain_state_required`
  *    → 身份不符 ⇒ 409 `conflict.fleet_identity`(零状态变化;拒句点名不符的字段,不回显值)→ 入口:已在排空 / 硬停已在进行 ⇒ 200 回执
  *    (这一发的期限不会被采用);这一发会进入排空而 `deadlineAt` 离进入那一拍超过 `FLEET_LEASE_OUTAGE_MAX_MS`(`config.fleetLeaseOutageMaxMs`,
@@ -24,6 +26,7 @@ export declare const ADMIN_DRAIN_ROUTES: readonly [{
     readonly id: "admin-drain";
     readonly path: "/v1/admin/drain";
     readonly methods: readonly ["POST"];
+    readonly power: "drain";
 }];
 type AdminDrainRouteId = RouteIdsOf<typeof ADMIN_DRAIN_ROUTES>;
 export {};

package/dist/http/routes/admin-drain.js

@@ -7,7 +7,7 @@ import { drainIdentityMismatches } from "../../fleet/drain-entry.js";
 import { assertNever } from "../route-ctx.js";
 import { WEB_ADMIN_ENV } from "@sema-agent/settings-schema";
 export const ADMIN_DRAIN_PATH = "/v1/admin/drain";
-const OPERATOR_ONLY_MESSAGE = "drain declaration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS";
+const OPERATOR_ONLY_MESSAGE = "drain declaration is for this deployment's operators and drain principals only: the caller principal is in neither OPERATOR_PRINCIPALS nor OPERATOR_DRAIN_PRINCIPALS";
 export async function handleAdminDrain(req, res, match, ctx) {
     const { deps } = ctx;
     switch (match.decl.id) {
@@ -17,11 +17,12 @@ export async function handleAdminDrain(req, res, match, ctx) {
                 sendPrincipalRefusal(res, req, deps.config);
                 return;
             }
-            if (!facts.operatorLane(deps).available) {
-                sendOperatorPrincipalsRequired(res);
+            const power = ADMIN_DRAIN_DECL.power;
+            if (!facts.operatorLane(deps, power).available) {
+                sendOperatorPrincipalsRequired(res, power);
                 return;
             }
-            if (!explicitOperatorOk(principal, deps.config)) {
+            if (!explicitOperatorOk(principal, deps.config, power)) {
                 sendError(res, 403, "auth.operator_only", OPERATOR_ONLY_MESSAGE);
                 return;
             }
@@ -59,7 +60,6 @@ export async function handleAdminDrain(req, res, match, ctx) {
             return assertNever(match.decl.id);
     }
 }
-export const ADMIN_DRAIN_ROUTES = [
-    { id: "admin-drain", path: ADMIN_DRAIN_PATH, methods: ["POST"] },
-];
+const ADMIN_DRAIN_DECL = { id: "admin-drain", path: ADMIN_DRAIN_PATH, methods: ["POST"], power: "drain" };
+export const ADMIN_DRAIN_ROUTES = [ADMIN_DRAIN_DECL];
 //# sourceMappingURL=admin-drain.js.map

package/dist/http/routes/admin-memory-optout.d.ts

@@ -26,7 +26,7 @@
  * 的调用方不该从「这台有没有授权表」上读出部署形态。
  * 🔴 四口都在 `isCredentialGatedRewrite`(server.ts)门内(codex R1-[high] 验真后补):授权的**唯一**输入是
  * principal 头 ∧ 一次调用的爆炸半径跨租户(改缺省行 = 改整台部署每个 principal 的 verdict;读面 = 全部授权行 +
- * operator 手写的 note)—— 无 service 凭证且未开 `ALLOW_UNAUTHED_WRITES` 的 worker 上那个头**可自造**,与
+ * operator 手写的 note)—— 请求没带凭据门认的凭据(且部署未开 `ALLOW_UNAUTHED_WRITES`)时那个头**可自造**,与
  * `/v1/memory/erase` / `POST /v1/memory/export` 同一条论证。
  *
  * ── 为什么缺席形是 **501 `capability.*`** 而不是 404(与 consolidation 阀门刻意分家)──────────────────

package/dist/http/routes/admin-memory-optout.js

@@ -19,10 +19,10 @@ export async function handleMemoryOptOut(req, res, match, ctx) {
     }
     const fact = facts.memoryOptOutGrant(deps);
     if (!fact.available && fact.why === "operator_principals_empty") {
-        sendOperatorPrincipalsRequired(res);
+        sendOperatorPrincipalsRequired(res, "operate");
         return;
     }
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", "memory opt-out grant administration is operator-only: the caller principal is not in OPERATOR_PRINCIPALS");
         return;
     }
@@ -33,7 +33,7 @@ export async function handleMemoryOptOut(req, res, match, ctx) {
                 sendError(res, 501, "capability.memory_optout_grant_required", "this deployment has no memory opt-out grant table: the per-principal memory-capture opt-out authorization store lives on a SQL store backend (DB_BACKEND=mysql|pg) and the local backend deliberately keeps no companion store for forgetting — wire a SQL backend to administer opt-out grants");
                 return;
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             default:
                 return assertNever(fact.why);

package/dist/http/routes/adoption.js

@@ -69,10 +69,10 @@ async function operatorLane(req, res, id, params, ctx) {
     }
     const fact = facts.adoption(deps);
     if (!fact.available && fact.why === "operator_principals_empty") {
-        sendOperatorPrincipalsRequired(res);
+        sendOperatorPrincipalsRequired(res, "operate");
         return;
     }
-    if (!explicitOperatorOk(principal, deps.config)) {
+    if (!explicitOperatorOk(principal, deps.config, "operate")) {
         sendError(res, 403, "auth.operator_only", "adoption is an operator-only deployment action");
         return;
     }
@@ -82,7 +82,7 @@ async function operatorLane(req, res, id, params, ctx) {
                 sendAdoptionStoreRequired(res);
                 return;
             case "operator_principals_empty":
-                sendOperatorPrincipalsRequired(res);
+                sendOperatorPrincipalsRequired(res, "operate");
                 return;
             default:
                 return assertNever(fact.why);
@@ -129,8 +129,6 @@ async function operatorLane(req, res, id, params, ctx) {
                 return;
             }
             const out = await runner.start(fromPrincipal, toPrincipal);
-            if (out.kind === "receipt")
-                await deps.toolApproval?.followRowOwners();
             sendOutcome(res, out);
             return;
         }

package/dist/http/routes/agents-roster.js

@@ -2,8 +2,7 @@ import { chosenAgentName } from "@sema-agent/core";
 import { sendJson, sendError } from "../send.js";
 import { gatedSubject, sendUnauthorized } from "../principal-gate.js";
 import { PRINCIPAL_MAX_BYTES } from "../../principal-shape.js";
-import { partsOf } from "../../owner-brands.js";
-import { taskSpecIdentityOf } from "../../engine-identity.js";
+import { engineScopeOf } from "../../engine-identity.js";
 import { routeListFilter } from "../owner-access.js";
 import { assertNever } from "../route-ctx.js";
 import * as facts from "../../capability-facts.js";
@@ -99,7 +98,7 @@ export async function handleAgentRoster(req, res, match, ctx) {
             }
             const status = statusRaw === null ? undefined : statusRaw;
             const subject = gatedSubject(req, deps.config);
-            const ownScope = taskSpecIdentityOf(subject === undefined ? undefined : partsOf(subject)).principal ?? "default";
+            const ownScope = engineScopeOf(subject);
             let scope;
             if (gateOwner !== null) {
                 scope = ownScope;

package/dist/http/routes/approvals-assistant.d.ts

@@ -118,6 +118,7 @@ export type PendingRowForWire = PendingRow & {
     governanceForced?: true;
     rememberRefused?: true;
     agent?: SessionAgent;
+    askId?: string;
 };
 /**
  * 🔴 [ref]-2 / [ref]②:两条 durable 读面(`GET /v1/approvals` + `/v1/approvals/stream`)的**唯一**
@@ -153,7 +154,7 @@ export declare function streamApprovals(req: IncomingMessage, res: ServerRespons
  * 缺席,流的字节与 [ref] 之前逐字相同(能力缺席 = 零变化,不是空数组)。**位置在 `pollMs` 之前**
  * 与 `governance` 同一条理由:`pollMs` 只有测试传,而本参数是每个生产调用点都必须表态的那一个。
  */
-live: Pick<ToolApprovalCoordinator, "listLivePending"> | undefined, 
+live: Pick<ToolApprovalCoordinator, "listLivePending" | "readParkedAskOfGate"> | undefined, 
 /**
  * 🔴 [ref]:`pending` 车道的**第二个半场** —— 被扣的跨会话来信(`peer_inbound` 行),与 `GET /v1/approvals` 的 `pending[]`
  * **同一只**闭包({@link peerInboundRowsFor},已绑调用方自己的信箱 scope)。与停驻行同一条 delta 车道、同一对事件名