@sema-agent/server 7.151.0 → 7.152.0

package/dist/operator-roster.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 🔴 **运维名册的档表**(唯一一张)——「这位验过的人在这台部署上持哪几只运维权力」只在这里答。
+ *
+ * ## 律(一句)
+ * 一张闭集档表、一只读法({@link rosterTierOf}:读验过的人、读部署配置里的名册);档表一行 = 名单在哪格配置(`field` / `env`)· 这一档持哪几只权力(`powers`)·
+ * 持有者是不是人(`person`)。**不是人的档**(服务主体)的身份只在声明了它所持权力的路由上算数(路由声明行的 `power` 列,`http/route-ctx.ts`),别处整次请求
+ * 403 `auth.principal_confined`(判官 `http/principal-gate.ts` 的 `confinedTierOf`:请求的人、决定证明推出的决定者、设备行的属主三个读点同判 —— 最后一个在设备 hello 准入,
+ * 设备车道不经 HTTP、没有声明过权力的路由,落在非人档的属主登记的设备连不上),`GET /health` 按没出示凭据分档。
+ * 全运维档(`operator`)持 {@link OPERATOR_POWERS} 全集 —— 加一只权力词,现有运维不掉权。
+ *
+ * ## 读者
+ *  · 档:{@link rosterTierOf}(人 → 档;单用户声明 `OPERATOR_SINGLE_USER=true` ⇒ 每个调用方落 `operator` 档)。
+ *  · 授权 / 有无 / 圈禁 / 出路句:`http/principal-gate.ts` 的 `explicitOperatorOk(人, 名册, 权力)` / `operatorRosterPresent(名册, 权力)` / `confinedTierOf` /
+ *    `buildOperatorRosterWayOut(权力)`,都经本表的 {@link rosterTierOf} / {@link tierHolds} / {@link rosterNamesOf},不另写一份「哪几格是名单」。
+ *  · 起服不变量:`config-invariants.ts` 的 `operator-roster-well-formed`(名单是名字列表 · 非人档的名字是主体名 · 一个名字只在一档)与 `operator-single-user`(单用户声明与任一档名单互斥)按本表逐档读。
+ *
+ * 叶子:只取型(`config-types` / `owner-brands`),不 import http 层 —— 配置层(不变量)与门(`principal-gate`)读同一张表。
+ */
+import type { ServiceConfig } from "./config-types.js";
+import type { Person } from "./owner-brands.js";
+/** 运维权力(闭集)。加词 ⇒ 档表与每个按权力穷举的读者编译红。`operate` = 运维面的全部门与放宽位;`drain` = 排空口 `POST /v1/admin/drain`。 */
+export declare const OPERATOR_POWERS: readonly ["operate", "drain"];
+export type OperatorPower = (typeof OPERATOR_POWERS)[number];
+/** 名册读的几格配置:各档的名单 + 单用户声明(只住在部署配置里;env 独有、起服冻结)。 */
+export type OperatorRoster = Pick<ServiceConfig, "operatorPrincipals" | "operatorDrainPrincipals" | "operatorSingleUser">;
+/** 档表(闭集;一档一格配置、一格 env)。 */
+export declare const ROSTER_TIERS: {
+    readonly operator: {
+        readonly field: "operatorPrincipals";
+        readonly env: "OPERATOR_PRINCIPALS";
+        readonly holders: "operator principals";
+        readonly powers: readonly ["operate", "drain"];
+        readonly person: true;
+    };
+    readonly drain: {
+        readonly field: "operatorDrainPrincipals";
+        readonly env: "OPERATOR_DRAIN_PRINCIPALS";
+        readonly holders: "drain-only service principals";
+        readonly powers: readonly ["drain"];
+        readonly person: false;
+    };
+};
+export type RosterTier = keyof typeof ROSTER_TIERS;
+/** 不是人的档(圈禁的那几档)。 */
+export type NonPersonTier = {
+    [T in RosterTier]: (typeof ROSTER_TIERS)[T]["person"] extends false ? T : never;
+}[RosterTier];
+/** 档的规范序(出路句按它列档;判档时人档排在非人档之后,见 {@link rosterTierOf})。漏一档 / 名册多一格名单不进表 ⇒ 编译红。 */
+export declare const ROSTER_TIER_ORDER: readonly ["operator", "drain"];
+/**
+ * 一档的名单(缺席 ≡ 空 = 这一档没人)。名单必须是列表:绕过类型手搓的配置在这一格放一串字符串 ⇒ 响亮抛(`includes` 会把它读成子串匹配 = 放宽;
+ * 读成空又会让非人档的服务主体落回普通身份 = 也是放宽)。装配座与起服在此之前已按 `operator-roster-well-formed` 拒,这一臂只是读法本身不说假话。
+ */
+export declare function rosterNamesOf(tier: RosterTier, roster: OperatorRoster): readonly string[];
+/** 这一档持不持这只权力。 */
+export declare function tierHolds(tier: RosterTier, power: OperatorPower): boolean;
+/** 这一档是不是人档。 */
+export declare function tierIsPerson(tier: RosterTier): boolean;
+/**
+ * 🔴 **人 → 档的唯一读法**。`person` 必须是验过的人(`gatedPerson` / `personOf(主体)` / 决定证明推出的人),绝不是自述头,也不是带场景的主体(名册登记的是人)。
+ *  · 人在某档名单里 ⇒ 那一档(非人档先判,见 {@link TIER_MATCH_ORDER});
+ *  · 否则单用户声明 `OPERATOR_SINGLE_USER=true` ⇒ `operator`(单用户形只有一位用户,能到这台部署的就是他;没有人也成立 —— 与改前 `explicitOperatorOk` 同读);
+ *  · 否则 ⇒ 不在名册(空名单 = 没人在)。
+ */
+export declare function rosterTierOf(person: Person | undefined, roster: OperatorRoster): RosterTier | undefined;
+/** 名册里有没有**非人档**的名字(圈禁判只在它为真时读人 —— 没声明非人档的部署零新读、逐字节同今天)。 */
+export declare function rosterHasNonPersonNames(roster: OperatorRoster): boolean;
+//# sourceMappingURL=operator-roster.d.ts.map

package/dist/operator-roster.js

@@ -0,0 +1,32 @@
+export const OPERATOR_POWERS = ["operate", "drain"];
+export const ROSTER_TIERS = {
+    operator: { field: "operatorPrincipals", env: "OPERATOR_PRINCIPALS", holders: "operator principals", powers: OPERATOR_POWERS, person: true },
+    drain: { field: "operatorDrainPrincipals", env: "OPERATOR_DRAIN_PRINCIPALS", holders: "drain-only service principals", powers: ["drain"], person: false },
+};
+export const ROSTER_TIER_ORDER = ["operator", "drain"];
+const TIER_MATCH_ORDER = [...ROSTER_TIER_ORDER.filter((t) => !ROSTER_TIERS[t].person), ...ROSTER_TIER_ORDER.filter((t) => ROSTER_TIERS[t].person)];
+export function rosterNamesOf(tier, roster) {
+    const names = roster[ROSTER_TIERS[tier].field];
+    if (names === undefined)
+        return [];
+    if (!Array.isArray(names))
+        throw new Error(`operator roster: ${ROSTER_TIERS[tier].env} is not a list of principal names (invariant operator-roster-well-formed)`);
+    return names;
+}
+export function tierHolds(tier, power) {
+    return ROSTER_TIERS[tier].powers.includes(power);
+}
+export function tierIsPerson(tier) {
+    return ROSTER_TIERS[tier].person;
+}
+export function rosterTierOf(person, roster) {
+    if (person !== undefined)
+        for (const tier of TIER_MATCH_ORDER)
+            if (rosterNamesOf(tier, roster).includes(person))
+                return tier;
+    return roster.operatorSingleUser === true ? "operator" : undefined;
+}
+export function rosterHasNonPersonNames(roster) {
+    return ROSTER_TIER_ORDER.some((t) => !ROSTER_TIERS[t].person && rosterNamesOf(t, roster).length > 0);
+}
+//# sourceMappingURL=operator-roster.js.map

package/dist/orchestration/workflow-park-decision.d.ts

@@ -55,7 +55,7 @@ export type WorkflowRecordFenceStore = import("../plugins/workflow-run-store-sql
  */
 export declare function holderFenceAdmits(run: WorkflowRun, d: Pick<WorkflowParkDecision, "runId" | "token">, restated: boolean): "not_held" | "restated" | "land";
 /**
- * 决定行的店契约(SQL 两方言 / local 文件 / 内存三形同律)。写者两个:`/decide` 与应答口的 workflow 车道(记录栅栏那一笔 / 续跑车道开跑之前那一笔)、
+ * 决定行的店契约(SQL 两方言 / local 文件 / 内存三形同律)。写者两个:`/decide` 与决断口停驻形的 workflow 车道(7.151.x 及以前:应答口的)(记录栅栏那一笔 / 续跑车道开跑之前那一笔)、
  * run 收场送达的转交(续跑车道那一笔,带条件);读者是起跑读者、持有进程的拉取腿、收场送达与 `/decide` 自己的回执幂等判;删除只有 SQL 收割的级联。
  */
 export interface WorkflowParkDecisionStore {

package/dist/outbound-dispatcher.d.ts

@@ -163,18 +163,45 @@ export declare function createOutboundDispatcher(env?: NodeJS.ProcessEnv): {
     env: OutboundProxyEnv;
 };
 /**
- * 建连期失败码 —— **闭集**(码 → 给运维的一句读法)。只收**只可能**在建立连接时出现的码:undici 的建连截止
+ * 建连失败**类** —— 闭集(三类),说「这一次建连失败的出路在哪一头」,由 {@link OUTBOUND_CONNECT_FAILURE_CODES} 的每个码各认一类(`failureClass`):
+ *  · `refused`     —— 对端把连接拒了(那个地址上没人监听 / 防火墙复位):出路在**地址那一头**(服务在不在、地址配得对不对);
+ *  · `unresolved`  —— 主机名解析不了(地址写错,或 DNS / VPN 不通):出路在**地址写法与名字解析**;
+ *  · `unreachable` —— 建连没在时限内完成 / 无路由 / 网络不可达:出路在**网络路径**(VPN / 代理)。
+ * 建连失败的出路取自这三类上的一张表({@link MODEL_UNREACHABLE_REMEDIES},选句 {@link connectFailureRemedyOf}):用户面通告 `server.model_unreachable`
+ * (`model-unreachable-notice.ts`)与运维日志 `outbound_connect_failed` 的 `hint` 同读它,都不另写码 → 类的映射。
+ */
+export type OutboundConnectFailureClass = "refused" | "unresolved" | "unreachable";
+/**
+ * 建连期失败码 —— **闭集**(码 → { 失败类,给运维的一句读法 })。只收**只可能**在建立连接时出现的码:undici 的建连截止
  * (`UND_ERR_CONNECT_TIMEOUT`,TCP + TLS 没在传输层的建连时限内完成)与 OS 的拒连 / 解析不了 / 无路由。可能出现在**已建立**
  * 连接上的码(`ECONNRESET` / `ETIMEDOUT` / `UND_ERR_SOCKET`)刻意不收 —— 它们判不出「够不着」,收进来就会把一次中途断流
- * 说成「模型不可达、去查 VPN」。加一个码 = 加一行并写明它为什么只可能在建连时出现。
+ * 说成「模型不可达、去查 VPN」。加一个码 = 加一行并写明它为什么只可能在建连时出现、它属哪一失败类(类缺 ⇒ 编译红)。
  */
 export declare const OUTBOUND_CONNECT_FAILURE_CODES: {
-    readonly UND_ERR_CONNECT_TIMEOUT: "the TCP + TLS connect did not complete within the transport's connect deadline";
-    readonly ECONNREFUSED: "the peer actively refused the connection (nothing listening there, or a firewall reset it)";
-    readonly ENOTFOUND: "the host name did not resolve";
-    readonly EAI_AGAIN: "the DNS lookup failed temporarily";
-    readonly EHOSTUNREACH: "there is no route to the host";
-    readonly ENETUNREACH: "the network is unreachable";
+    readonly UND_ERR_CONNECT_TIMEOUT: {
+        readonly failureClass: "unreachable";
+        readonly reading: "the TCP + TLS connect did not complete within the transport's connect deadline";
+    };
+    readonly ECONNREFUSED: {
+        readonly failureClass: "refused";
+        readonly reading: "the peer actively refused the connection (nothing listening there, or a firewall reset it)";
+    };
+    readonly ENOTFOUND: {
+        readonly failureClass: "unresolved";
+        readonly reading: "the host name did not resolve";
+    };
+    readonly EAI_AGAIN: {
+        readonly failureClass: "unresolved";
+        readonly reading: "the DNS lookup failed temporarily";
+    };
+    readonly EHOSTUNREACH: {
+        readonly failureClass: "unreachable";
+        readonly reading: "there is no route to the host";
+    };
+    readonly ENETUNREACH: {
+        readonly failureClass: "unreachable";
+        readonly reading: "the network is unreachable";
+    };
 };
 export type OutboundConnectFailureCode = keyof typeof OUTBOUND_CONNECT_FAILURE_CODES;
 /** 一次建连失败的事实(纯数据:日志行、诊断段、模型调用结局同一份)。`proxyInUse` = 这一跳走的代理**变量名**(不打值),直连 ⇒ `null`。 */
@@ -183,6 +210,42 @@ export interface OutboundConnectFailure {
     readonly code: OutboundConnectFailureCode;
     readonly proxyInUse: string | null;
 }
+/**
+ * 一个码的失败类({@link OutboundConnectFailureClass});闭集之外的码 ⇒ `undefined`(调用方必须处置这一臂,不是静默的一类)。纯函数、不抛。
+ * 类型上到不了 `undefined`(`OutboundConnectFailure.code` 是闭集型),但读者收 `string`:手造的失败事实、将来码型变宽,都落在这一臂上而不是 `undefined.failureClass` 抛。
+ */
+export declare function connectFailureClassOf(code: string): OutboundConnectFailureClass | undefined;
+/**
+ * 一次建连失败的**出路** —— 同一件事的两种写法:`advice` 是给人读的一句(用户面通告的正文末句),`remedy` 是短句(通告的 `detail.remedy`,
+ * 也是运维日志 `outbound_connect_failed` 的 `hint` 尾句)。三张脸读**同一行**,不各写各的。
+ */
+export interface ConnectFailureRemedy {
+    readonly advice: string;
+    readonly remedy: string;
+}
+/**
+ * **失败类上的一张闭表**(键集 = {@link OutboundConnectFailureClass},加一类不补一行 ⇒ 编译红)。行说的是**模型端点**(端点地址、模型网关地址配置):
+ * 用户面通告只为模型调用铸,运维日志只在失败的请求属一次模型调用时读类行。契约附录 D.3 与 USAGE 列的就是这三行
+ * (`test/model-unreachable-notice.test.ts` 的「文书与表同源」一格读本表对文书)。
+ */
+export declare const MODEL_UNREACHABLE_REMEDIES: {
+    readonly refused: {
+        readonly advice: "Check that a service is listening at that address and that the model gateway address is configured correctly.";
+        readonly remedy: "check that a service is listening at the model endpoint address; check the model gateway address configuration";
+    };
+    readonly unresolved: {
+        readonly advice: "Check that the model gateway address is written correctly in the configuration and that DNS (and the VPN, if one is in use) can resolve it.";
+        readonly remedy: "check the model gateway address configuration; check DNS / VPN";
+    };
+    readonly unreachable: ConnectFailureRemedy;
+};
+/**
+ * 选句 —— **唯一一处**(用户面通告与运维日志 `hint` 同调),规则先到先得:
+ *  ① 失败的请求不属一次模型调用(`request: "other"`:中心、工具、MCP …)⇒ 通用句(类行说的是模型端点与网关地址配置,对别的主机不成立);
+ *  ② 这一跳走了代理(`proxyInUse` 非空)⇒ 通用句(拒连 / 解析不了可能是**代理**那一头的事,出路仍是「查 VPN / 代理」);
+ *  ③ 否则按失败类读闭表;码不在闭集里(类型上到不了,读者收 `string`)⇒ 通用句 —— 声明的未分类臂,不抛、不静默。
+ */
+export declare function connectFailureRemedyOf(failure: OutboundConnectFailure, request: "model_call" | "other"): ConnectFailureRemedy;
 /** 一只请求错误的建连期失败码与它走的代理变量名(`undefined` = 不是建连失败)。原句不在这里 —— 它只给运维日志。 */
 export declare function classifyOutboundConnectFailure(error: unknown): {
     readonly code: OutboundConnectFailureCode;

package/dist/outbound-dispatcher.js

@@ -339,14 +339,55 @@ export function createOutboundDispatcher(env = process.env) {
     return { dispatcher: new OutboundDispatcher(new Agent(), proxied), posture: postureOf(v), env: v };
 }
 export const OUTBOUND_CONNECT_FAILURE_CODES = {
-    UND_ERR_CONNECT_TIMEOUT: "the TCP + TLS connect did not complete within the transport's connect deadline",
-    ECONNREFUSED: "the peer actively refused the connection (nothing listening there, or a firewall reset it)",
-    ENOTFOUND: "the host name did not resolve",
-    EAI_AGAIN: "the DNS lookup failed temporarily",
-    EHOSTUNREACH: "there is no route to the host",
-    ENETUNREACH: "the network is unreachable",
+    UND_ERR_CONNECT_TIMEOUT: { failureClass: "unreachable", reading: "the TCP + TLS connect did not complete within the transport's connect deadline" },
+    ECONNREFUSED: { failureClass: "refused", reading: "the peer actively refused the connection (nothing listening there, or a firewall reset it)" },
+    ENOTFOUND: { failureClass: "unresolved", reading: "the host name did not resolve" },
+    EAI_AGAIN: { failureClass: "unresolved", reading: "the DNS lookup failed temporarily" },
+    EHOSTUNREACH: { failureClass: "unreachable", reading: "there is no route to the host" },
+    ENETUNREACH: { failureClass: "unreachable", reading: "the network is unreachable" },
 };
 const isConnectFailureCode = (c) => typeof c === "string" && Object.hasOwn(OUTBOUND_CONNECT_FAILURE_CODES, c);
+export function connectFailureClassOf(code) {
+    return isConnectFailureCode(code) ? OUTBOUND_CONNECT_FAILURE_CODES[code].failureClass : undefined;
+}
+const NETWORK_PATH_REMEDY = {
+    advice: "Check the VPN / proxy; if the proxy changed since the server started, restart it (proxy settings are read once at startup).",
+    remedy: "check VPN / proxy; restart if the proxy changed since boot",
+};
+export const MODEL_UNREACHABLE_REMEDIES = {
+    refused: {
+        advice: "Check that a service is listening at that address and that the model gateway address is configured correctly.",
+        remedy: "check that a service is listening at the model endpoint address; check the model gateway address configuration",
+    },
+    unresolved: {
+        advice: "Check that the model gateway address is written correctly in the configuration and that DNS (and the VPN, if one is in use) can resolve it.",
+        remedy: "check the model gateway address configuration; check DNS / VPN",
+    },
+    unreachable: NETWORK_PATH_REMEDY,
+};
+export function connectFailureRemedyOf(failure, request) {
+    switch (request) {
+        case "other":
+            return NETWORK_PATH_REMEDY;
+        case "model_call":
+            break;
+        default: {
+            const unhandled = request;
+            throw new Error(`connectFailureRemedyOf: unhandled request kind ${String(unhandled)}`);
+        }
+    }
+    if (failure.proxyInUse !== null)
+        return NETWORK_PATH_REMEDY;
+    const failureClass = connectFailureClassOf(failure.code);
+    switch (failureClass) {
+        case undefined:
+            return NETWORK_PATH_REMEDY;
+        case "refused":
+        case "unresolved":
+        case "unreachable":
+            return MODEL_UNREACHABLE_REMEDIES[failureClass];
+    }
+}
 function scanConnectFailure(error) {
     const queue = [error];
     let proxyInUse = null;
@@ -438,7 +479,7 @@ function startConnectObserver(logger, nowMs) {
             ...(found.proxyHop !== null ? { proxyHop: found.proxyHop } : {}),
             proxyReadAtMs: current.proxyReadAtMs,
             sinceBootMs: Math.round(process.uptime() * 1000),
-            hint: `${OUTBOUND_CONNECT_FAILURE_CODES[failure.code]} — ${failure.proxyInUse !== null ? `this hop went through the proxy from ${failure.proxyInUse} (read once at boot)` : "this hop was a direct connection"}; if the VPN / proxy changed since boot, restart the server so it re-reads HTTP(S)_PROXY / NO_PROXY`,
+            hint: `${OUTBOUND_CONNECT_FAILURE_CODES[failure.code].reading} — ${failure.proxyInUse !== null ? `this hop went through the proxy from ${failure.proxyInUse} (read once at boot)` : "this hop was a direct connection"}; ${connectFailureRemedyOf(failure, call !== undefined ? "model_call" : "other").remedy}`,
         });
         if (call !== undefined)
             call.last = { kind: "connect_failed", failure };

package/dist/owner-faces.d.ts

@@ -77,7 +77,7 @@ export declare function ownerKeyOf(persisted: string | null): DurableOwnerKey |
  */
 export declare function ownerCellOf(owner: string | null | undefined): SessionOwnerCell | undefined;
 /**
- * **收纯串的协议内部口**的主体读法(恢复管线;不是铸点):活登记的应答口 / 按问读口(`tool-approval.ts` 协调器)、活问的应答口(`elicitation.ts` / `question.ts`)、
+ * **收纯串的协议内部口**的主体读法(恢复管线;不是铸点):活登记的按问读口 / 决断口的停驻赎回席(`tool-approval.ts` 协调器)、活问的应答口(`elicitation.ts` / `question.ts`)、
  * 迟到决定的赎回席(`http/approval-sweeps.ts`)、停驻完成收件箱的排空门、peer 目录席 —— 这几扇口经纯串收「上游已铸的那一只主体」(HTTP 路由层的 `gatedSubject`
  * 读数、续跑腿交来的 run 属主、引擎交来的 scope)。串就是一只已落成字节的属主键,按 {@link ownerKeyOf} → `partsOf` 恢复(坏形的 `_scn:` 串响亮抛),
  * 不重判保留前缀 / 在册 / 宽度(那三判只在外部管线)。公开面改收 `Subject` 品牌是另一车(这几扇口的测试调用面数以百计)。

package/dist/parked-decide.d.ts

@@ -250,7 +250,7 @@ export interface ParkedDecideDeps {
  * 「本会话放行」落在**记不住的车道**上怎么答(闭集;两扇门之间唯一允许的差 —— 其余两口同读同答,铸点只有续跑腿一只):
  *  · `refuse` —— `/decide` 体上的 `remember:"session"`:那是一个硬意图键,认领之前 400 点名车道(`decide.workflow_remember_unsupported` /
  *    `decide.parked_remember_unsupported`),去掉它再决即可,零副作用;
- *  · `decide_once` —— 应答口命中停驻行的 `allow_session`:那是卡上的一个选项,主内容是「放行」。照常放行这一次、不落豁免、回执
+ *  · `decide_once` —— 决断口命中停驻行的 `remember:"session"`(7.151.x 及以前是应答口的 `allow_session`):那是卡上的一个选项,主内容是「放行」。照常放行这一次、不落豁免、回执
  *    `rememberApplied:false` —— 与活卡上「记不住的卡点 allow_session」同一答法;不把一次已经成立的批准改成 400(窗到期那一拍的按键今天是成的)。
  * 记不住的车道 = workflow 车道(它的 200 证不出引擎已提交这次决定)、无会话锚的 bg 停驻行(豁免无处可锚)。
  */
@@ -283,7 +283,7 @@ export interface ParkedDecideRequest {
     /** D-1 决断绑定:决断方点名它看到的那一对(必在 —— 续跑腿的判官 `decidedActionOf` 判过才交下来)与决定体的其余两位;
      *  server 绝不重算、绝不从停驻行补,core resume 侧做 fail-closed 等值校验 —— 与 legacy 腿同姿势。 */
     binding: Omit<DecideBinding, "checkpointToken" | "boundCallId" | "boundInputHash"> & DecidedAction;
-    /** 这次决定带着「本会话放行」请求(`/decide` 的 `remember:"session"` / 应答口命中停驻行的 `allow_session`,两口同一只请求;
+    /** 这次决定带着「本会话放行」请求(`/decide` 的 `remember:"session"` / 决断口命中停驻行的 `remember:"session"`,两口同一只请求;
      *  铸点 = 续跑腿 `resumeCheckpoint`)时,续跑腿交下来的**锚点记录器** + 记不住时怎么答({@link ParkedRemember})。 */
     remember?: ParkedRemember;
     /** [ref](core 5.7.0,F6 翻案):AskUserQuestion 的 approve 携操作员答案——原样透传进

package/dist/permission-mode-admission.d.ts

@@ -9,7 +9,7 @@
  * ① 只动 `auto`、③ 只看开写面的词,两者互不相交。
  *
  * ## 三口的调用形(同一组函数、同一个序;提交口与切档口:同一个词 × 同一份部署事实 × 同一份任务 settings ⇒ 同一个结果,钉 `test/run-permission-mode-admission.test.ts` 的两口表;
- *    续跑口与它们只差地板的出口词一个事实,钉 `test/entry-permission-mode.test.ts` 的续跑口表)
+ *    续跑口与它们只差一张写据,钉 `test/entry-permission-mode.test.ts` 的续跑口表)
  *  · 在飞 run 的切档口(`http/routes/run-permission-mode.ts`:`POST /v1/runs/:id/permission-mode` 的 `mode`,本任务 settings 读存储体)调整只判官 {@link admitPermissionModeWord}。
  *  · 提交口(`POST /v1/tasks|/v1/tasks/stream|/v1/runs` 的词 = 顶层 `permissionMode` ?? bundle `settings.permissions.defaultMode`)把两步落在**上一版就在的两处**:
  *    入口一步在受理门盖章({@link stampSubmissionEntryMode},`http/admission.ts`:值形门之后、装配之前 —— 首跑装配与 `buildCheckpointCtx` 读的都是盖过章的体);
@@ -17,21 +17,22 @@
  *    属主 / 会话 / 执行上下文与装配期其余值判之前答(拒序变了 —— 钉同一文件的拒序组)。
  *  · 续跑口(一条 HTTP 车道停驻 run 的存储体被重放之前;`http/resume-legs.ts` 的 `replayCtxOf`,五个续跑读点同调;leader 车道的行按那条车道「一 run 一读」照写下的体重放,
  *    规则在 `replayCtxOf` 头注)调 {@link stampReplayEntryMode}:体上的词过与提交口**同一只**入口一步
- *    ({@link bodyEntry}:同一只折叠、同一只 `entryPermissionMode`、地板读同一份**活** config)、盖同一只章 —— 提交之后运维把 `AUTONOMY` 改严,或体是更早的写者留下的请求原词,
+ *    ({@link bodyEntry}:同一只折叠、同一只 `entryPermissionMode`、地板读同一份**活** config)—— 提交之后运维把 `AUTONOMY` 改严,或体是更早的写者留下的请求原词,
  *    重放照**现**地板钳;被钳 = 钳到地板放行(与提交口同形,不拒、不新增码),生效词由这条腿的 `wiring_manifest.permissionMode` 说;钳过的体随 CAS 赢点写回,
- *    存储体仍是这条 run 模式词唯一的源。与提交口只差一个**事实**(不是续跑专用臂,见下一节):体**顶层** `permissionMode` 上写着的是这块地板的出口词({@link floorExitWords})⇒ 原样读。
+ *    存储体仍是这条 run 模式词唯一的源。与提交口只差一张**写据**(不是续跑专用臂,见下一节):写据说体顶层那一格是这块地板的出口写下的、且仍是它写下的那一格 ⇒ 原样读。
  *    托管一步照旧在装配期判。
  *
- * ## 为什么地板的出口词在续跑口原样读
- * 存储体上的模式词有三个写者:提交口(盖过地板)、切档口(盖过地板)、`plan_review` 的批准 / 编辑写回(`http/resume-legs.ts` `drivePlanReview`:把计划带出 plan,
- * 写 `PLAN_APPROVE_PERMISSION_MODES_AFTER` 里的词 —— 这就是 plan 地板的出口:一个人批了这份计划)。提交口与切档口收的是**调用方**的词,出口词照钳(没有人批过计划);
- * 续跑口读的是**存储体**的词,出口词是批准写下的 ⇒ 对它也钳 = 每一次挂起→续跑都把批过的计划拉回 plan(上一版撤掉按段重钳模式词的那条理由,`runtime-governance.ts`
- * `autonomyOverrides` 顶注)。出口词以外的词(`bypassPermissions` / `auto` / `dontAsk` / 缺席)在这块地板下没有任何写者写得出来 —— 只能是更松的地板(改严之前)
- * 或更早的写者(7.121.x 及以前的请求原词)留下的 ⇒ 照现地板钳。出口写者只写**顶层** `permissionMode`(`drivePlanReview` 的写回;bundle 的 `defaultMode` 不动),
- * 所以出口判读的是顶层那一格的**原字**(严格读):只在 bundle 拼法里的词、经本任务 kill-switch 折出来的词(顶层 `auto` × `disableAutoMode` ⇒ `default`)、
- * 词表外的串(重放的宽读把它折成 `default`)都不是出口写下的,照钳。
- * ⚠️ 射程如实:顶层的出口词本身读不出是谁写的 —— 改严之前提交的顶层 `default` / `acceptEdits`、7.121.x 及以前的同字原词与批准写回逐字相同,原样重放
- * (MIGRATION 如实写);要分开它们得给行补一个「谁写的」事实,本模块不猜。
+ * ## 写据:存储体上的模式词谁写的(一条规则)
+ * 存储体顶层 `permissionMode` 那一格谁写,谁就在同一笔写里留一张写据({@link PermissionModeWrite} `{ by, mode }`,`CheckpointCtx.permissionModeWrite`:服务端写、
+ * 客户端够不着)。写者闭集四个({@link PERMISSION_MODE_WRITERS}):`submission`(提交写口 `buildCheckpointCtx`,经 `http/submit-ctx.ts` `persistSubmissionCtx`;leader worker 的续跑体)、
+ * `switch`(在飞切档的写回)、`replay`(本模块续跑口的钳)、`plan_review`(`http/resume-legs.ts` `drivePlanReview` 批准 / 编辑把计划带出 plan 的写回 —— plan 地板的出口:一个人批了这份计划)。
+ * 新的持久化写经构造口(写据是它的必填键,漏写 = 编译红);改写那一格经一只改写口 {@link withStoredPermissionMode}(一笔换词、换写据)。
+ * 读者只有一个:续跑口。地板在场时只问「这块地板的出口是谁」({@link floorExitWriter})—— 写据的 `by` 就是它、且写据的 `mode` 仍等于体顶层的原值 ⇒ 原样;
+ * 其余一律照现地板钳(缺写据 = 7.152.0 之前写下的行,或从这样的行照抄的体;别的写者写下的同字词;bundle 拼法;kill-switch 折出来的词;词表外的串 —— 都落在这一个「否」里)。
+ * `mode` 绑定为什么承重:更早版本的副本(滚动升级窗、回滚再升回)读 ctx 时把不认识的兄弟键展开带走,把词改成另一个词却不改写据 ⇒ 写据对不上那一格 ⇒ 照钳(失效关闭,不读版本号)。
+ * ⚠️ 射程如实:旧副本把词切走又切回写据上的同一个词(批准写下 `acceptEdits` 之后在旧副本上 `acceptEdits → default → acceptEdits` 切档),写据仍对得上 ⇒ 原样 ——
+ * 与 7.151.0 同读(不比上一版宽);只看 `mode` 分不出这一形,要分开得让写据记下「最后写这一行的进程认得写据」(未闭项,MIGRATION 如实写)。
+ * 无地板时写据不参与判定;读口照样判形(读不出 = 坏体,不论地板)。写据的形只有一种读法({@link permissionModeWriteOf},续跑上下文读口经它判)。
  *
  * ## 为什么切档口必须经这只判官(而不是靠引擎的 deny 位)
  * 引擎在根腿上只认两只模式拒位(`RuntimeCaps.bypassPermissions` / `RuntimeCaps.autoMode`,本仓由 center 与本地 kill-switch 写);上面三问
@@ -44,6 +45,7 @@
  *    `foldedBy`(本判官把词改了的那一站;没改 ⇒ 缺席。① ② 都改了 ⇒ `entry_floor`:落定的词是地板给的)。
  */
 import type { PermissionMode } from "@sema-agent/core";
+import type { CheckpointCtx } from "./http/route-ctx.js";
 import { type Autonomy, type EntryPermissionMode } from "./runtime-governance.js";
 import { HOST_POSTURE_REFUSED_CODE, type TaskWriteFaceInput } from "./hosted-posture.js";
 import { type ParsedTaskSettings } from "./task-settings.js";
@@ -83,22 +85,53 @@ export declare function stampSubmissionEntryMode<B extends {
     readonly body: B;
     readonly entry: EntryPermissionMode;
 };
+/** 存储体顶层 `permissionMode` 那一格的写者闭集(顶注「写据」)。加一个写者 ⇒ 加一词;它默认不是任何地板的出口(失效关闭),要当出口必须改 {@link floorExitWriter} 的穷尽表。 */
+export declare const PERMISSION_MODE_WRITERS: readonly ["submission", "switch", "replay", "plan_review"];
+export type PermissionModeWriter = (typeof PERMISSION_MODE_WRITERS)[number];
 /**
- * 一块入口地板的**出口词** —— 存储体上由地板自己的出口写下的词(续跑口原样读它们,理由见顶注「为什么地板的出口词在续跑口原样读」)。
- * 闭集穷尽 switch:引擎的模式词表加一词 ⇒ 编译红,逼着回答「这个词当地板时靠什么出口」。`plan` 的出口是人审(`plan_review` 的批准 / 编辑把计划带出 plan,
- * 写回的词表 = `task-settings.ts` `PLAN_APPROVE_PERMISSION_MODES_AFTER`,那张表是唯一的源);其余五词今天不是任何档的地板(`runtime-governance.ts` `autonomyModeFloor`
- * 只答 `plan` 或缺席),当地板也没有出口 ⇒ 空(失效关闭:比它松的词照钳)。
+ * 写据:谁写了存储体顶层 `permissionMode` 那一格、写下的是什么(`mode` = 写完那一刻顶层的原值;缺席 = 那一格写完是空的,或不是引擎的模式词)。
+ * 每个写者都写自己的那一张(一条规则,不分写者);读者只在 `by` 是这块地板的出口时拿 `mode` 去对体顶层(绑定,见顶注)。
  */
-export declare function floorExitWords(floor: PermissionMode): readonly PermissionMode[];
+export interface PermissionModeWrite {
+    readonly by: PermissionModeWriter;
+    readonly mode?: PermissionMode;
+}
+/**
+ * 一块入口地板的**出口写者** —— 存储体上由它写下的那一格,续跑口原样读(顶注「写据」)。闭集穷尽 switch:引擎的模式词表加一词 ⇒ 编译红,
+ * 逼着回答「这个词当地板时靠什么出口」。`plan` 的出口是人审(`plan_review` 的批准 / 编辑把计划带出 plan);其余五词今天不是任何档的地板
+ * (`runtime-governance.ts` `autonomyModeFloor` 只答 `plan` 或缺席),当地板也没有出口 ⇒ 缺席(失效关闭:比它松的词照钳)。
+ */
+export declare function floorExitWriter(floor: PermissionMode): PermissionModeWriter | undefined;
+/** 提交写者的那一张写据:`mode` = 这份要落盘的体顶层的原值(严格读;不是引擎的模式词 ⇒ 缺席)。调用点 = 两只构造口调用方(`http/submit-ctx.ts` `persistSubmissionCtx`、`leader/wire.ts` 的 worker 续跑体)。 */
+export declare function submissionPermissionModeWrite(body: {
+    readonly permissionMode?: unknown;
+}): PermissionModeWrite;
+/**
+ * **改写口**(唯一):把存储体顶层 `permissionMode` 那一格换成 `mode`,同一笔换上写者 `by` 的写据;其余位(含 bundle 拼法、无人值守标、写者版本)随行。
+ * 三个调用点:切档写回(`switch`)、续跑口的钳(`replay`,本模块 {@link stampReplayEntryMode})、`plan_review` 的出口写回(`plan_review`)。提交写者不经它(新行经构造口)。
+ */
+export declare function withStoredPermissionMode(ctx: CheckpointCtx, mode: PermissionMode, by: Exclude<PermissionModeWriter, "submission">): CheckpointCtx;
+/** {@link permissionModeWriteOf} 的结局:缺席 / 读得出 / 形不对(读口答坏体)。 */
+export type PermissionModeWriteReading = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "ok";
+    readonly write: PermissionModeWrite;
+} | {
+    readonly kind: "malformed";
+};
+/**
+ * 落盘写据(持久化 JSON,不信型面)的**唯一**读法:缺席 ⇒ `absent`;对象、键只在 `by` / `mode` 之内、`by` 在写者闭集里、`mode` 缺席或是引擎的模式词 ⇒ `ok`(交读法铸的那一份);
+ * 其余(不是对象、多键、`by` 不认得 —— 含更新版本加的写者、`mode` 在场却不是模式词)⇒ `malformed`。唯一调用方 = 续跑上下文读口(`http/resume-ctx-read.ts`:`malformed` ⇒ 坏体)。
+ */
+export declare function permissionModeWriteOf(stored: unknown): PermissionModeWriteReading;
 /**
- * 续跑口的入口一步:一条停驻 run 的存储体被重放之前,体上的词过 {@link bodyEntry}(与提交口同一只,地板读此刻的活 config),入口词盖进体
- * (同一只 `stampEntryPermissionMode`);体顶层 `permissionMode` 的原字是 `bodyEntry` 读到的那块地板的出口词({@link floorExitWords})⇒ 体**原物**交回
- * (出口写者只写顶层;那个词已经过了地板)。
- * 地板缺席 ⇒ 体原物(零字节变化)。不拒:钳到地板放行,与提交口同形(见顶注「三口的调用形」)。
+ * 续跑口的入口一步:一条停驻 run 的存储体被重放之前,体上的词过 {@link bodyEntry}(与提交口同一只,地板读此刻的活 config)。
+ *  · 地板缺席 ⇒ ctx **原物**(零字节变化;写据不被读);
+ *  · 写据说体顶层那一格是这块地板的出口写下的({@link floorExitWriter})、且 `mode` 仍等于顶层原值 ⇒ ctx **原物**(那一格已经过了地板);
+ *  · 其余 ⇒ 经改写口盖入口词、写据换成 `replay`(顶注「写据」:缺写据、别的写者写下的同字词、bundle 拼法、折出来的词都在这里)。
+ * 不拒:钳到地板放行,与提交口同形(见顶注「三口的调用形」)。入参是 ctx(写据是体的兄弟键)。
  * 唯一调用点:`http/resume-legs.ts` 的 `replayCtxOf`(五个续跑读点同调;之后的存体预判、重建、plan_review 的模式词门与驱动段、CAS 赢点的写回读的都是它交回的那一份)。
  */
-export declare function stampReplayEntryMode<B extends {
-    permissionMode?: unknown;
-    settings?: unknown;
-}>(body: B, deployment: PermissionModeAdmissionFacts["deployment"]): B;
+export declare function stampReplayEntryMode(ctx: CheckpointCtx, deployment: PermissionModeAdmissionFacts["deployment"]): CheckpointCtx;
 //# sourceMappingURL=permission-mode-admission.d.ts.map

package/dist/permission-mode-admission.js

@@ -1,6 +1,6 @@
 import { autonomyModeFloor, entryPermissionMode } from "./runtime-governance.js";
 import { HOST_POSTURE_REFUSED_CODE, permissionModeWriteFaceRefusal } from "./hosted-posture.js";
-import { PLAN_APPROVE_PERMISSION_MODES_AFTER, coercePermissionModeStrict, foldDisableAutoMode, parseTaskSettings, requestedPermissionMode, stampEntryPermissionMode } from "./task-settings.js";
+import { coercePermissionModeStrict, foldDisableAutoMode, parseTaskSettings, requestedPermissionMode, stampEntryPermissionMode } from "./task-settings.js";
 export const PERMISSION_MODE_ADMISSION_FOLDS = ["entry_floor", "disable_auto_mode"];
 function entryStep(word, facts) {
     const folded = foldDisableAutoMode(word, facts.settings);
@@ -23,27 +23,54 @@ export function stampSubmissionEntryMode(body, deployment) {
     const entry = bodyEntry(body, deployment);
     return { body: stampEntryPermissionMode(body, entry), entry };
 }
-export function floorExitWords(floor) {
+export const PERMISSION_MODE_WRITERS = ["submission", "switch", "replay", "plan_review"];
+export function floorExitWriter(floor) {
     switch (floor) {
         case "plan":
-            return PLAN_APPROVE_PERMISSION_MODES_AFTER;
+            return "plan_review";
         case "default":
         case "acceptEdits":
         case "auto":
         case "bypassPermissions":
         case "dontAsk":
-            return [];
+            return undefined;
         default: {
             const unhandled = floor;
             throw new Error(`entry floor "${String(unhandled)}" has no exit arm`);
         }
     }
 }
-export function stampReplayEntryMode(body, deployment) {
-    const entry = bodyEntry(body, deployment);
-    const top = coercePermissionModeStrict(body.permissionMode);
-    if (entry.floor !== undefined && top !== undefined && floorExitWords(entry.floor).includes(top))
-        return body;
-    return stampEntryPermissionMode(body, entry);
+export function submissionPermissionModeWrite(body) {
+    const mode = coercePermissionModeStrict(body.permissionMode);
+    return { by: "submission", ...(mode !== undefined ? { mode } : {}) };
+}
+export function withStoredPermissionMode(ctx, mode, by) {
+    return { ...ctx, body: { ...ctx.body, permissionMode: mode }, permissionModeWrite: { by, mode } };
+}
+export function permissionModeWriteOf(stored) {
+    if (stored === undefined)
+        return { kind: "absent" };
+    if (typeof stored !== "object" || stored === null || Array.isArray(stored))
+        return { kind: "malformed" };
+    if (!Object.keys(stored).every((k) => k === "by" || k === "mode"))
+        return { kind: "malformed" };
+    const by = Object.hasOwn(stored, "by") ? stored["by"] : undefined;
+    const raw = Object.hasOwn(stored, "mode") ? stored["mode"] : undefined;
+    const writer = PERMISSION_MODE_WRITERS.find((w) => w === by);
+    if (writer === undefined)
+        return { kind: "malformed" };
+    if (raw === undefined)
+        return { kind: "ok", write: { by: writer } };
+    const mode = coercePermissionModeStrict(raw);
+    return mode === undefined ? { kind: "malformed" } : { kind: "ok", write: { by: writer, mode } };
+}
+export function stampReplayEntryMode(ctx, deployment) {
+    const { floor, effective } = bodyEntry(ctx.body, deployment);
+    if (floor === undefined || effective === undefined)
+        return ctx;
+    const write = ctx.permissionModeWrite;
+    if (write !== undefined && write.by === floorExitWriter(floor) && write.mode !== undefined && write.mode === ctx.body.permissionMode)
+        return ctx;
+    return withStoredPermissionMode(ctx, effective, "replay");
 }
 //# sourceMappingURL=permission-mode-admission.js.map

package/dist/plugins/approval-ask-store-file.d.ts

@@ -235,6 +235,10 @@ export declare class FileApprovalAskStore implements ApprovalAskStore {
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
     listByCall(call: AskCallCoordinate): Promise<AskRow[]>;
     listParkingBySourceSession(sourceSessionId: string): Promise<AskRow[]>;
+    listAsksAtGate(sourceSessionId: string, binding: {
+        readonly boundCallId: string;
+        readonly boundInputHash: string;
+    }): Promise<AskRow[]>;
     getAsk(askId: string): Promise<AskRow | null>;
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     getBatch(batchId: string): Promise<BatchRow | null>;

package/dist/plugins/approval-ask-store-file.js

@@ -386,6 +386,9 @@ export class FileApprovalAskStore {
     listParkingBySourceSession(sourceSessionId) {
         return this.core.listParkingBySourceSession(sourceSessionId);
     }
+    listAsksAtGate(sourceSessionId, binding) {
+        return this.core.listAsksAtGate(sourceSessionId, binding);
+    }
     getAsk(askId) {
         return this.core.getAsk(askId);
     }

package/dist/plugins/approval-ask-store-memory.d.ts

@@ -129,6 +129,10 @@ export declare class InMemoryApprovalAskStore implements ApprovalAskStore {
     listPendingBySession(sessionId: string, owner: string | null, signal?: AbortSignal): Promise<AskRow[]>;
     listByCall(call: AskCallCoordinate): Promise<AskRow[]>;
     listParkingBySourceSession(sourceSessionId: string): Promise<AskRow[]>;
+    listAsksAtGate(sourceSessionId: string, binding: {
+        readonly boundCallId: string;
+        readonly boundInputHash: string;
+    }): Promise<AskRow[]>;
     getAsk(askId: string): Promise<AskRow | null>;
     getByIdempotencyKey(taskId: string, key: string): Promise<AskRow | null>;
     resolveProvisional(askId: string, from: AskState, to: AskState, patch: AskTransitionPatch): Promise<boolean>;

package/dist/plugins/approval-ask-store-memory.js

@@ -1,6 +1,6 @@
 import { ASK_TERMINAL, canAskTransition } from "../approval-ask-machine.js";
 import { APPROVAL_ENDING_CAUSES } from "../approval-deny-reasons.js";
-import { askAttachedToSession, askRowCarriesOwner, askRowOnCall, assertDecideSource, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
+import { askAtGate, askAttachedToSession, askRowCarriesOwner, askRowOnCall, assertDecideSource, assertIdempotencyKeyShape, assertIntegralEpochMs, assertReapBounds, ApprovalAskReadAbortedError, claimTargetState, POLICY_REFUSAL_DECISION, projectAskTerminalClaimTruth, projectDecideReading } from "./approval-ask-store-sql.js";
 function applyDecisionRecord(row, record, now) {
     row.decision = record.decision;
     row.decisionActor = record.decisionActor ?? null;
@@ -384,6 +384,12 @@ export class InMemoryApprovalAskStore {
             .sort((a, b) => a.createdAtMs - b.createdAtMs || (a.askId < b.askId ? -1 : a.askId > b.askId ? 1 : 0))
             .map((r) => ({ ...r }));
     }
+    async listAsksAtGate(sourceSessionId, binding) {
+        return [...this.asks.values()]
+            .filter((r) => askAtGate(r, sourceSessionId, binding))
+            .sort((a, b) => a.createdAtMs - b.createdAtMs || (a.askId < b.askId ? -1 : a.askId > b.askId ? 1 : 0))
+            .map((r) => ({ ...r }));
+    }
     async getAsk(askId) {
         const r = this.asks.get(askId);
         return r ? { ...r } : null;