@sema-agent/server 7.146.0 → 7.148.0

package/dist/deleted-session-ids.d.ts

@@ -2,10 +2,11 @@ import type { DeploymentShapeInput } from "./deployment-shape.js";
 /** 表的条数上限(一条约百字节量级)。引擎的会话暂存自己按会话数有上限(超了整会话驱逐最旧);本表的上限比它宽得多。 */
 export declare const DELETED_SESSION_ID_CAP = 50000;
 /**
- * **铸点**(唯一):本进程的在线删除协调器在删除会话本体之前记一笔 —— 围栏先立,id 才空出来。删除随后失败也无害:
+ * **铸点**(唯一的函数;两处调用者):本进程的在线删除协调器在删除会话本体之前记一笔 —— 围栏先立,id 才空出来;提交出口撤回一只被拒提交铸下的会话之后同步记一笔
+ * (`submission-exit.ts`,判撤才记)。删除随后失败也无害:
  * 这一笔只拒「别的属主」,而会话还在时别的属主本来就用不了它。
  * 同一只 id 再删一次:这一次的删前属主对已记的每一位都等价(同一只等价律判)⇒ 收进集合(前几位一位不丢 —— 等价律有方向、不传递,只记最新一位会让
- * 「哨兵删 → 无主重登再删 → `default` 用」绕过「哨兵 ≢ `default`」);对某一位不等价 ⇒ 记成「谁都不是」。后一次删除从不覆盖前一位(前一位的暂存仍可能在本进程)。
+ * 「无主删 → `default` 重登再删 → 无主体的调用方用」绕过「`default` 的行 ≢ 无主体的调用方」);对某一位不等价 ⇒ 记成「谁都不是」。后一次删除从不覆盖前一位(前一位的暂存仍可能在本进程)。
  * `deployment` = 部署形(等价律的窄互认臂读它;调用方递 `ServiceConfig` 整份)。
  */
 export declare function retireSessionId(sessionId: string, owner: string | null, deployment: DeploymentShapeInput<"principal">): void;

package/dist/deploy-facts.js

@@ -1,5 +1,6 @@
 import { TENANT_SEPARATION_WORDS } from "@sema-agent/settings-schema/execution-lanes";
-import { CHECKPOINT_CTX_KEY_SUBDIR, SEALED_KEY_DIR_MODE, SEALED_KEY_FILE_MODE } from "./sealed-key-layout.js";
+import { CHECKPOINT_CTX_KEY_SUBDIR, SEALED_KEY_DIR_MODE } from "./sealed-key-layout.js";
+import { OWNER_ONLY_FILE_MODE } from "./plugins/owner-only-file-mode.js";
 export const DEPLOY_FACTS_DIR = "deploy/facts";
 export const DEPLOY_FACTS_MEMBERS = ["lanes", "sandbox-rbac", "sealed-key"];
 export const DEPLOY_FACTS_CHANGES_FILE = "CHANGES.json";
@@ -65,7 +66,7 @@ export const SEALED_KEY_FACTS = {
     dirPath: SEALED_KEY_DIR_PATH_FORMS[0],
     subdirs: [CHECKPOINT_CTX_KEY_SUBDIR],
     dirMode: octal(SEALED_KEY_DIR_MODE),
-    fileMode: octal(SEALED_KEY_FILE_MODE),
+    fileMode: octal(OWNER_ONLY_FILE_MODE),
     requirements: SEALED_KEY_REQUIREMENTS,
 };
 export const SEALED_KEY_FACTS_SCHEMA = {

package/dist/deployment-governance.d.ts

@@ -1,5 +1,5 @@
 import { FileError, StubExecutionEnv, type ExecutionEnv, type PathFamily, type Result, type ToolPolicy } from "@sema-agent/core";
-import { type DeploymentListExemption } from "./approval.js";
+import { type SessionExemptionRead } from "./approval.js";
 import type { ServiceConfig } from "./config.js";
 import type { applyRuntimeGovernance } from "./runtime-governance.js";
 /** `applyRuntimeGovernance` 的 governance 实参 —— 从折叠属主的签名位**推导**,不复制形状
@@ -84,8 +84,8 @@ export interface DurableApprovalSeat {
     readonly kind: "durable";
     /** 活体问答面;`undefined` ⇒ 恒 durable park 的原形门。 */
     readonly question: LiveQuestionFace | undefined;
-    /** 本会话的「本会话放行」读面(部署名单那一问的站着的答案;铸点 `approval.ts` 的 `createDeploymentListExemption`)。缺席 = 这条腿没有会话 / 没有豁免店 ⇒ 名单照问。 */
-    readonly exemption?: DeploymentListExemption;
+    /** 本会话的「本会话放行」读面(部署名单那一问的站着的答案;铸点 `approval.ts` 的 `createSessionExemptionRead`)。缺席 = 这条腿没有会话 / 没有豁免店 ⇒ 名单照问。 */
+    readonly exemption?: SessionExemptionRead;
 }
 /** live 席:Runner 的活 onAsk 当场服 ask(无 park、无会话豁免店:run-local 一次性腿)。 */
 export interface LiveApprovalSeat {

package/dist/deployment-shape.d.ts

@@ -6,25 +6,27 @@
  * `DEPLOYMENT_SHAPE_PREDICATES.<行>.holds(config)`,不 import 散落函数;表外不许再长出一只自读部署形事实的布尔判据
  * (反向门 `test/deployment-shape-gate.test.ts` 按语法树判,判据逐字写在那份门的头注里)。
  *
- * ## 两根轴,每根轴一个读口(原始配置键只在这两个函数里被读)
+ * ## 三根轴,每根轴一个读口(原始配置键只在这三个函数里被读)
  *  · `principal` —— 运维的 `REQUIRE_PRINCIPAL` 声明({@link readPrincipalAxis})。
+ *  · `identity` —— 这台部署在**配置**上接了哪几个已验身份来源(唯一读法 `configuredIdentitySources`,`identity-source.ts`)+ 有没有声明只读 trace 凭据({@link readIdentityAxis})。
  *  · `lane` —— `REMOTE_EXEC` 的归一车道词(`executionLaneOf`,认不出 ⇒ `undefined`,行必须 fail-closed)+ 那条车道的能力表行 +
- *    这份部署上执行环境的能力块(唯一作者 `capabilitiesFor`;k8s 的快照店是它的输入)+ 车道子旋钮(k8s 运行时类、隐式 host 尾臂记号)({@link readLaneAxis})。
+ *    这份部署上执行环境的能力块(唯一作者 `capabilitiesFor`;k8s 的快照店是它的输入)+ 车道子旋钮(k8s 运行时类)({@link readLaneAxis})。
  *
  * ## 轴列不是注释,是型
  * 每行的判官只收到它**声明**的那几根轴的事实({@link DeploymentShapeFacts}),读不到配置本身 —— 判官碰一根没声明的轴 = 编译红;
  * `holds` 的入参型 = 所声明轴读入形的交叉({@link DeploymentShapeInput}),所以调用方递完整 `ServiceConfig` 或只递那几键的窄形都行。
  *
  * ## 什么进表、什么不进
- * 进表的是**形规则**:只由部署形事实决定的布尔(去重后 14 行;同一条规则的多个消费者读同一行,不各成一行)。
+ * 进表的是**形规则**:只由部署形事实决定的布尔(去重后 15 行;同一条规则的多个消费者读同一行,不各成一行)。
  * 把一行与**非形事实**(锁键、合规档位、审批意图、请求身份、请求体)合取的能力判据是**消费者**,住在它自己的模块
  * (`mcpInjectionHonored` = 锁 ∧ 合规 ∧ `!multiTenant`;`taskHooksHonored`;身份门 …),读行、不读原始键。
  * 车道表(`execution-lane-caps.ts`)按车道词键控的布尔列(`laneIsolated` 等)是车道轴自己的事实表,不是「部署」的谓词;行读它们。
  *
- * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts`(它本身是叶),零运行期环(引擎只 type-import)。
+ * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts` 与 `identity-source.ts`(两者本身是叶),零运行期环(引擎只 type-import)。
  */
 import type { ExecutionEnvCapabilities } from "@sema-agent/core";
 import { type ExecutionLane, type ExecutionLaneCaps } from "./execution-lane-caps.js";
+import { type IdentitySource, type IdentitySourceConfig } from "./identity-source.js";
 /** `principal` 轴读的配置键(`ServiceConfig` 结构上满足)。 */
 export interface PrincipalAxisInput {
     readonly requirePrincipal?: boolean | undefined;
@@ -34,14 +36,25 @@ export interface PrincipalAxisFacts {
     /** 运维声明了 `REQUIRE_PRINCIPAL=true`。 */
     readonly declared: boolean;
 }
-/** `lane` 轴读的配置键:已装配的 `remoteExec` 里本表用得到的那几键(`ServiceConfig` 的判别联合每一臂结构上都满足)。 */
+/** `identity` 轴读的配置键(`ServiceConfig` 结构上满足):身份来源的配置面 + 只读 trace 凭据。 */
+export interface IdentityAxisInput extends IdentitySourceConfig {
+    readonly traceToken?: string | undefined;
+}
+/** `identity` 轴的事实。 */
+export interface IdentityAxisFacts {
+    /** 配置接了线的已验身份来源(`configuredIdentitySources`,序同 `IDENTITY_SOURCES`)。鉴权桥那一格 = 配置里有 issuer(显式或中心回退)—— 验签器由起服第 9 段按同一个读数建。 */
+    readonly sources: readonly IdentitySource[];
+    /** 声明了只读 trace 凭据(不是身份来源:它不验任何主体,但这台部署因此有一道凭据门)。 */
+    readonly traceTokenDeclared: boolean;
+}
+/** `lane` 轴读的配置键:**已合成**的 `remoteExec` 里本表用得到的那几键(`ServiceConfig` 的判别联合每一臂结构上都满足;车道必在 ——
+ *  没有声明的部署在执行车道合成步拒启)。`provider` 收开放串:手搓的部署形 / 外部输入上认不出的词 ⇒ 行在 `lane` 那一格 fail-closed。 */
 export interface LaneAxisInput {
-    readonly remoteExec?: {
-        readonly provider?: string | undefined;
+    readonly remoteExec: {
+        readonly provider: string;
         readonly runtimeClass?: string | undefined;
         readonly s3Snapshot?: unknown;
-        readonly singleMachineDefault?: boolean | undefined;
-    } | undefined;
+    };
 }
 /** `lane` 轴的事实。 */
 export interface LaneAxisFacts {
@@ -53,8 +66,6 @@ export interface LaneAxisFacts {
     readonly block: ExecutionEnvCapabilities | undefined;
     /** k8s 的 `runtimeClass`(别的车道 `undefined`)。 */
     readonly k8sRuntimeClass: string | undefined;
-    /** host 车道值上带「单机形缺省」记号(唯一写者 = `config.ts` 三元链的隐式 host 尾臂;显式 `REMOTE_EXEC=host` 与文件覆写都不带)。 */
-    readonly singleMachineDefault: boolean;
 }
 /** 轴全集(闭集)→ 读入形与事实型。加一根轴 = 在这里加一键 + {@link readAxis} 的穷举 switch 加一臂(漏一处即编译红)。 */
 interface AxisShapes {
@@ -62,6 +73,10 @@ interface AxisShapes {
         readonly input: PrincipalAxisInput;
         readonly facts: PrincipalAxisFacts;
     };
+    readonly identity: {
+        readonly input: IdentityAxisInput;
+        readonly facts: IdentityAxisFacts;
+    };
     readonly lane: {
         readonly input: LaneAxisInput;
         readonly facts: LaneAxisFacts;
@@ -88,6 +103,14 @@ export interface DeploymentShapePredicate<A extends DeploymentShapeAxis> {
 export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
     /** 身份门的问法。读者:请求面的身份 / 属主门(`http/principal-gate.ts`、`http/request-guards.ts`、`security.ts`)。 */
     principalRequired: DeploymentShapePredicate<"principal">;
+    /**
+     * 「这台部署有没有身份边界」的问法 —— 有 = 请求里有东西替主体作保或拦在门外:声明了 `REQUIRE_PRINCIPAL`,或配置接了任一已验身份来源
+     * (service 凭据 / 鉴权桥 issuer,含中心回退 / 直连门),或声明了只读 trace 凭据。没有 = dev-open:主体头是谁都能自报的标签。
+     * 只读配置(验签器在起服第 9 段按同一个配置读数建 ⇒「验签器在场」≡「配置里有桥」),所以先于验签器的起服段(第 3 段的一次性迁移)与请求面读到同一个答案。
+     * 读者:请求面的 dev-open 判据(`http/principal-gate.ts` 的 `devOpenDeployment`:属主存取器的 fleet 一格与 `/metrics` 族的免凭据臂)、
+     * 一次性迁移 M48 的输入(`plugins/store-backend.ts`:有边界 ⇒ 不改写哨兵属主)。
+     */
+    identityBoundary: DeploymentShapePredicate<"identity" | "principal">;
     /**
      * 租户轴的问法。今天与 {@link DEPLOYMENT_SHAPE_PREDICATES.principalRequired} 读**同一个声明**([ref] ①:托管 / 多租 ⇔ `REQUIRE_PRINCIPAL=true`,
      * 签发方配置是身份验签轴、不算租户证据)—— 两个问题、一根轴、一个读口;「鉴权必需」与「多租形」拆成两个声明时只改这一行的判官。
@@ -95,12 +118,13 @@ export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
     multiTenant: DeploymentShapePredicate<"principal">;
     /** 读能力表 `callerCwd` 位(host = 单主才开;device = 路径落在发起者自己的设备上,归属由根会话行执行格上的设备绑定验过,不要求单主)。 */
     callerCwd: DeploymentShapePredicate<"lane" | "principal">;
-    /** 调用方给的宿主绝对路径(附加目录 / 项目上下文 / 本机 SendUserFile / 指令文件探针)只在「手就在本 worker 的盘上 ∧ 单主」时指向调用方自己的东西。 */
+    /** 调用方给的宿主绝对路径(附加目录 / 项目上下文 / 本机 SendUserFile / 指令文件探针)只在「手就在本 worker 的盘上 ∧ 单主」时指向调用方自己的东西;
+     *  本机语言服务器(`createLspManager`:本机子进程、在 worker 盘上找根)同问这一句,读这一行 × `LSP_HOST_ENABLED`。 */
     callerOwnsWorkerDisk: DeploymentShapePredicate<"lane" | "principal">;
     /** wire `executionLane.toolsOnThisHost` 与出厂 / 中心技能的 `baseDir`:只问文件系统同一性,与租户无关(出厂内容每个租户拿到同一份)。 */
     toolsOnThisHost: DeploymentShapePredicate<"lane">;
-    /** `REMOTE_EXEC` 未设的进程内形(没有手)且单主:进程级消费者(hooks 命令、项目上下文本机读、卡批规则 root)看到的就是引擎自己的进程 cwd / env。 */
-    inProcessSingleUser: DeploymentShapePredicate<"lane" | "principal">;
+    /** 无手形(声明 `none`;判据读执行环境块 `io`,不点名车道词)且单主:进程级消费者(hooks 命令、项目上下文本机读、卡批规则 root)看到的就是引擎自己的进程 cwd / env。 */
+    noHandsSingleUser: DeploymentShapePredicate<"lane" | "principal">;
     /** 任务层替部署声明宿主姿态(bypassPermissions 开写面 / host shell 继承整份环境)的射程:device 车道上跨租户宿主穿越结构性不存在(clay 裁定③)。 */
     taskHostPostureDeclarations: DeploymentShapePredicate<"lane" | "principal">;
     /** 写门走代理裁决(执行环境块 `hostLocalPaths` 为假:路径不是本 worker 盘上的文件);认不出的词 ⇒ 走代理(代理 slot 空 ⇒ 写门 fail-closed)。 */
@@ -121,8 +145,19 @@ export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
      * 读者:boot `remote_exec_enabled.suspendable`。
      */
     suspendableHands: DeploymentShapePredicate<"lane">;
-    /** 读者两处:`config.ts` 车道落点一行的 `source`(覆写之前)与 `boot/execution-env.ts` 的 `remote_exec_real_system.note`(覆写之后)—— 同一个记号、两个时刻。 */
-    singleMachineDefaultLane: DeploymentShapePredicate<"lane">;
+    /**
+     * 即时回退的工作区是否活过一次执行 —— run 外回退口(`POST /v1/sessions/:id/rewind-files`)写下的文件要落在一棵下一次执行就从它开始的工作区里;
+     * 工作区随执行结束一起没了(或下一次执行从别处重建它)的部署上,引擎照样恢复、台账照样报「恢复了」,结果却到不了任何人手里(静默的写面 fail-open)。
+     * 按车道穷举(新车道 = 编译红;认不出的车道 ⇒ 不成立):
+     *  · `host`:调用方声明的项目目录 ⇔ 车道能力 `callerCwd` 在这台部署上成立(单主;多租形上每个任务一只用完即删的目录)。单只会话还要本进程登记过它的 cwd、且那只目录实在 —— 那一半是口的 409,不是部署形;
+     *  · `device` / `ssh` / `adb`:一台常驻的真机器,环境拆毁 = 断连,不删文件;
+     *  · `local-docker`(拆毁 = `docker rm -f`)/ `e2b`(拆毁 = 杀 VM):每个任务一只新环境;
+     *  · `k8s`:不开工作区持久化 ⇒ 一次性 pod;开了 ⇒ 下一次执行从快照店恢复工作区,而工作区填充链(恢复后的附件填充)与拆毁时的快照持久化都还没纳入回退用途
+     *    (回退那一次取环境照样填充附件、存新快照,存失败也进不了回退的应答)⇒ 本版不成立,重开另票(用途感知的填充 + 持久化结果进回退应答);
+     *  · `none`:没有执行环境(能力事实先判无手车道,这里照样表态)。
+     * 读者:能力事实 `sessionRewindFiles`(能力位与该口的 501 同读这一行)。
+     */
+    rewindableWorkspace: DeploymentShapePredicate<"lane" | "principal">;
 }>;
 export {};
 //# sourceMappingURL=deployment-shape.d.ts.map

package/dist/deployment-shape.js

@@ -1,22 +1,27 @@
-import { capabilitiesFor, executionLaneCaps, executionLaneOf, handsOnWorkerFilePlane } from "./execution-lane-caps.js";
+import { capabilitiesFor, executionLaneCaps, executionLaneOf, handsOnWorkerFilePlane, laneWiresExecutionEnv } from "./execution-lane-caps.js";
+import { configuredIdentitySources } from "./identity-source.js";
 function readPrincipalAxis(deployment) {
     return { declared: deployment.requirePrincipal === true };
 }
+function readIdentityAxis(deployment) {
+    return { sources: configuredIdentitySources(deployment), traceTokenDeclared: Boolean(deployment.traceToken) };
+}
 function readLaneAxis(deployment) {
     const declaration = deployment.remoteExec;
-    const lane = executionLaneOf(declaration?.provider);
+    const lane = executionLaneOf(declaration.provider);
     return {
         lane,
         caps: lane === undefined ? undefined : executionLaneCaps(lane),
         block: capabilitiesFor(deployment),
-        k8sRuntimeClass: lane === "k8s" ? declaration?.runtimeClass : undefined,
-        singleMachineDefault: lane === "host" && declaration?.singleMachineDefault === true,
+        k8sRuntimeClass: lane === "k8s" ? declaration.runtimeClass : undefined,
     };
 }
 function readAxis(axis, deployment) {
     switch (axis) {
         case "principal":
             return readPrincipalAxis(deployment);
+        case "identity":
+            return readIdentityAxis(deployment);
         case "lane":
             return readLaneAxis(deployment);
     }
@@ -48,11 +53,12 @@ function capabilityHolds(cap, principal) {
 const VM_ISOLATION_RUNTIME_CLASSES = new Set(["kata", "kata-qemu", "kata-clh", "kata-fc", "gvisor", "runsc"]);
 export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
     principalRequired: createPredicate(["principal"], "身份轴:运维声明了 REQUIRE_PRINCIPAL=true —— 每个调用方都必须带一个验过的主体。", ({ principal }) => principal.declared),
+    identityBoundary: createPredicate(["principal", "identity"], "身份轴:这台部署有身份边界 —— 声明了 REQUIRE_PRINCIPAL,或配置接了任一已验身份来源(service 凭据 / 鉴权桥 / 直连门),或声明了只读 trace 凭据。", ({ principal, identity }) => principal.declared || identity.sources.length > 0 || identity.traceTokenDeclared),
     multiTenant: createPredicate(["principal"], "租户轴:这台部署服务不止一个主人(托管 / 多租;C-R100 ① 由 REQUIRE_PRINCIPAL=true 声明)。", ({ principal }) => principal.declared),
     callerCwd: createPredicate(["lane", "principal"], "车道 × 租户 / 设备归属:调用方送来的 cwd(与 settings.env)被尊重 —— host 车道且单主,或 device 车道。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.callerCwd, principal)),
     callerOwnsWorkerDisk: createPredicate(["lane", "principal"], "车道 × 租户:手就在本 worker 的盘上且部署只有一个主人 —— 这块盘上的路径就是调用方自己的。", ({ lane, principal }) => lane.lane !== undefined && handsOnWorkerFilePlane(lane.lane) && !principal.declared),
     toolsOnThisHost: createPredicate(["lane"], "车道:工具跑的那台机器就是本进程这台(手挂上了且文件平面在本 worker 盘上;车道列 handsOnWorkerFilePlane)。", ({ lane }) => lane.lane !== undefined && handsOnWorkerFilePlane(lane.lane)),
-    inProcessSingleUser: createPredicate(["lane", "principal"], "车道 × 租户:进程内车道(REMOTE_EXEC 未设)且部署只有一个主人。", ({ lane, principal }) => lane.lane === "in-process" && !principal.declared),
+    noHandsSingleUser: createPredicate(["lane", "principal"], "车道 × 租户:无手车道(声明 none;车道列 laneWiresExecutionEnv 为假)且部署只有一个主人。", ({ lane, principal }) => lane.lane !== undefined && !laneWiresExecutionEnv(lane.lane) && !principal.declared),
     taskHostPostureDeclarations: createPredicate(["lane", "principal"], "车道 × 租户 / 设备归属:任务层可以替部署声明宿主姿态 —— device 车道(发起者自己的设备),或单主部署。", ({ lane, principal }) => lane.lane === "device" || !principal.declared),
     sandboxPathAdjudication: createPredicate(["lane"], "车道:写门的路径事实要经代理到执行环境里取(文件平面不在本 worker 盘上;认不出的车道也走代理)。", ({ lane }) => lane.block === undefined || !lane.block.hostLocalPaths),
     sandboxSendUserFile: createPredicate(["lane", "principal"], "车道 × 租户:SendUserFile 的沙箱直传腿可以挂(沙箱盘 = 租户自己的任务工作区,或共享真机上的单主部署)。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.sandboxSendUserFile, principal)),
@@ -67,6 +73,25 @@ export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
         return runtimeClass.startsWith("kata") || VM_ISOLATION_RUNTIME_CLASSES.has(runtimeClass);
     }),
     suspendableHands: createPredicate(["lane"], "车道:执行环境可挂起(e2b;k8s 以配了 S3 工作区快照店为前提)。", ({ lane }) => lane.block?.suspendable === true),
-    singleMachineDefaultLane: createPredicate(["lane"], "车道:host 车道是单机形缺省落点(REMOTE_EXEC 未设 ∧ CONFIG_PROVIDER=local,没人点名)。", ({ lane }) => lane.singleMachineDefault),
+    rewindableWorkspace: createPredicate(["lane", "principal"], "车道 × 租户:即时回退的工作区活过一次执行 —— 单主 host、device、ssh、adb 成立;多租 host、local-docker、e2b 每个任务重建工作区;k8s 的工作区填充与快照持久化尚未纳入回退。", ({ lane, principal }) => {
+        switch (lane.lane) {
+            case "host":
+                return lane.caps !== undefined && capabilityHolds(lane.caps.callerCwd, principal);
+            case "device":
+            case "ssh":
+            case "adb":
+                return true;
+            case "k8s":
+            case "local-docker":
+            case "e2b":
+            case "none":
+            case undefined:
+                return false;
+            default: {
+                const unhandled = lane.lane;
+                throw new Error(`rewindableWorkspace: no ruling for lane ${String(unhandled)}`);
+            }
+        }
+    }),
 });
 //# sourceMappingURL=deployment-shape.js.map

package/dist/egress-redirect.d.ts

@@ -1,12 +1,30 @@
 /**
- * 本服务**自己**发往配置端点的出站请求(hook 直连模型腿 `hooks/hook-llm.ts`、记忆 embedder `plugins/memory-embedder.ts`)的
- * 重定向律 —— 与 core 7.51.0([ref])一方 brain 的请求同一条:请求以 `redirect: "manual"` 发出,端点回重定向 ⇒ 拒;
- * 不跟、不重试、拒句不点名目标。
+ * 本服务**自己**发出的每一个出站 HTTP 请求的重定向律 —— 与 core 7.51.0([ref])一方 brain 的请求同一条:
+ * 请求以 `redirect: "manual"` 发出,对端回重定向 ⇒ 拒;不跟、不重试,拒句不点名目标。
  *
  * 为什么:请求只去被判过的那个根。传输层(undici)跟随 POST 307 / 308 时把请求体(用户内容 / 记忆正文)原样送到
- * `Location`,跨 origin 只剥 `authorization` —— anthropic 形的 `x-api-key` 随行(`test/hook-llm.test.ts` 的 G1 格在
- * 7.128.x 上实测送达重定向目标)。判据与拒句与 core 的 brain 请求门同形(`opaqueredirect` 或 3xx)。
+ * `Location`,跨 origin 只剥 `authorization` —— 自定义凭据头(`x-api-key` / `X-Subscription-Token` / OTLP 的 `headers` / S3 预签名的 query)
+ * 随行,同 origin 的跟随连 `authorization` 一起带走(`test/hook-llm.test.ts` 的 G1 格在 7.128.x 上实测送达重定向目标)。
+ *
+ * **一只出口**:{@link createEgressFetch} 是本仓里全局 `fetch` 的**唯一**值引用(`test/egress-redirect-surfaces.test.ts` 的语法树门:
+ * 全树零第二处全局 `fetch`、`redirect` 选项只写这里一处、`createEgressFetch(` 调用点闭集登记 —— 新加出站面必登)。
+ * 每个出站面各自造一只带「出路」句的出口,请求只经它发出;注入的 `fetchImpl`(测试座 / 嵌入方)同样被它包住 ——
+ * 注入不是绕过判据的门。判据 {@link egressRedirectRefusal} 不导出:没有「自己设 `redirect: manual` 再自己判」的第二种写法。
+ *
+ * 响亮:对端回重定向 ⇒ 抛 {@link EgressRedirectRefusedError}(带对端回的码),拒句前面由各面的失败臂冠上自己的面名。
+ * 各面既有的失败臂(日志 / 失败码 / 终态)照旧收它 —— 没有哪一面把它吞成「没拿到结果」而不留话。
+ */
+/** 对端回了重定向、本服务按律不跟:`status` 是对端回的码(0 = `opaqueredirect`)。`message` = 拒句,不回显 `Location` / 凭据 / 请求体。 */
+export declare class EgressRedirectRefusedError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * 造一只出站 `fetch`:`redirect: "manual"` 强制(调用方传的 `redirect` 不作数),回重定向 ⇒ 抛 {@link EgressRedirectRefusedError}。
+ *
+ *  · `fix` = 出路一句(「把最终地址写进哪一席」),由各面按自己打的那一席给;拼进拒句。
+ *  · `fetchImpl` 缺席 ⇒ 调用时现取全局 `fetch`(不在造出口时捕获:测试对全局 `fetch` 的替换在造出口之后也生效);在场 ⇒ 用它,同样被判。
+ *  · 其余答复(2xx / 4xx / 5xx / 304)原样交回,各面自己的失败臂照旧。
  */
-/** 端点回的是重定向 ⇒ 拒句(调用方在前面冠上自己的面名);否则 `undefined`。命中时丢弃响应体(不读、不留连接)。 */
-export declare function egressRedirectRefusal(res: Response, fix: string): string | undefined;
+export declare function createEgressFetch(fix: string, fetchImpl?: typeof fetch): typeof fetch;
 //# sourceMappingURL=egress-redirect.d.ts.map

package/dist/egress-redirect.js

@@ -1,7 +1,25 @@
-export function egressRedirectRefusal(res, fix) {
-    if (res.type !== "opaqueredirect" && !(res.status >= 300 && res.status < 400))
+export class EgressRedirectRefusedError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = "EgressRedirectRefusedError";
+        this.status = status;
+    }
+}
+const NOT_MODIFIED = 304;
+function egressRedirectRefusal(res, fix) {
+    if (res.type !== "opaqueredirect" && !(res.status >= 300 && res.status < 400 && res.status !== NOT_MODIFIED))
         return undefined;
     void res.body?.cancel().catch(() => undefined);
     return `endpoint answered with a redirect${res.status > 0 ? ` (HTTP ${res.status})` : ""}; it was not followed and no credential was sent anywhere else — ${fix}`;
 }
+export function createEgressFetch(fix, fetchImpl) {
+    return async (input, init) => {
+        const res = await (fetchImpl ?? fetch)(input, { ...init, redirect: "manual" });
+        const refusal = egressRedirectRefusal(res, fix);
+        if (refusal !== undefined)
+            throw new EgressRedirectRefusedError(res.status, refusal);
+        return res;
+    };
+}
 //# sourceMappingURL=egress-redirect.js.map

package/dist/elicitation.d.ts

@@ -1,4 +1,5 @@
 import { type McpElicitRequest, type McpElicitResponse } from "@sema-agent/core";
+import { type HitlTransport } from "./hitl-delivery.js";
 /** A live elicitation frame delivered to whoever is tailing this run's stream. `type` IS the SSE event name
  *  (mirrors the named-event convention: the payload also carries `type` so a proxy that strips event names still
  *  works). The shell renders the `elicitation` frame as a dialog and dismisses on `elicitation_complete`. */
@@ -27,13 +28,13 @@ export interface ElicitationFrame {
     /** "elicitation" only: `serverNowMs + expiresInMs` — the absolute deadline on the server's clock. */
     expiresAtMs?: number;
 }
-/** The per-run context `onElicit` recovers via ALS. `emit` delivers a frame to the run's live stream;
- *  `abortSignal` (the run's own cancel signal) lets a run-abort promptly cancel an elicitation parked awaiting a
- *  human, since the MCP per-request signal may not be chained to the run abort. */
+/** The per-run context `onElicit` recovers via ALS. `transport` = the leg's ONE HITL transport (shared with the question and
+ *  approval contexts of the same leg); `abortSignal` (the run's own cancel signal) lets a run-abort promptly cancel an
+ *  elicitation parked awaiting a human, since the MCP per-request signal may not be chained to the run abort. */
 export interface ElicitationRunContext {
     taskId: string;
     owner: string | null;
-    emit: (frame: ElicitationFrame) => void | Promise<void>;
+    transport: HitlTransport<ElicitationFrame>;
     abortSignal?: AbortSignal;
 }
 export interface ElicitationThrottle {
@@ -81,7 +82,7 @@ export declare class ElicitationCoordinator {
     elicit: (req: McpElicitRequest, signal?: AbortSignal) => Promise<McpElicitResponse>;
     /** `POST /v1/elicitations/:id/respond` — resolve a parked elicitation with the shell's answer. Owner-gated with a
      *  404 (no existence oracle): a non-owner AND an unknown id (answered / expired / wrong replica) both get 404.
-     *  Returns the HTTP {status, body}; the HTTP layer owns auth (gatedPrincipal + REQUIRE_PRINCIPAL) before calling. */
+     *  Returns the HTTP {status, body}; the HTTP layer owns auth (gatedSubject + REQUIRE_PRINCIPAL) before calling. */
     respond(id: string, principal: string | undefined, body: unknown): {
         status: number;
         body: unknown;

package/dist/elicitation.js

@@ -3,6 +3,8 @@ import { uuidv7, delimitUntrusted } from "@sema-agent/core";
 import { redactSecrets, redactDeep } from "./trace/redact.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { refusalBody } from "./http/refusal-body.js";
+import { keyAdmits, ownerCellOf, recoveredSubject } from "./owner-faces.js";
+import { createHitlOpenRace } from "./hitl-delivery.js";
 const MAX_ELICIT_MESSAGE_CHARS = 4096;
 const MAX_ELICIT_SCHEMA_BYTES = 8192;
 const RELEASE_ACTION = { refused: "decline", unanswered: "cancel" };
@@ -114,34 +116,33 @@ export class ElicitationCoordinator {
         signal?.addEventListener("abort", onAbort, { once: true });
         ctx.abortSignal?.addEventListener("abort", onAbort, { once: true });
         this.pending.set(id, { settle, owner: ctx.owner, taskId: ctx.taskId });
-        const emitted = (async () => {
-            const now = this.now();
-            return ctx.emit({ type: "elicitation", elicitationId: id, mcpServerName: req.server, message, ...(requestedSchema !== undefined ? { requestedSchema } : {}), mode: "form", serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs });
-        })().then(() => "ok", () => "failed");
-        const delivery = await Promise.race([emitted, answerP.then(() => "stalled")]);
-        if (delivery === "ok") {
+        const now = this.now();
+        const race = createHitlOpenRace({
+            targets: [{ transport: ctx.transport, frame: { type: "elicitation", elicitationId: id, mcpServerName: req.server, message, ...(requestedSchema !== undefined ? { requestedSchema } : {}), mode: "form", serverNowMs: now, expiresInMs: this.throttle.ttlMs, expiresAtMs: now + this.throttle.ttlMs } }],
+            settled: answerP,
+        });
+        const charge = () => {
             rc.total += 1;
             rc.lastByServer.set(req.server, t);
+        };
+        const phase = await race.phase;
+        if (phase === "delivered") {
+            charge();
         }
-        else if (delivery === "failed") {
+        else if (phase === "undelivered") {
             recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
             settle({ action: RELEASE_ACTION.unanswered });
         }
-        const answer = await answerP;
-        void emitted
-            .then((result) => {
-            if (result === "failed") {
-                if (delivery === "stalled")
+        else {
+            void race.landing.then((late) => {
+                if (late === "delivered")
+                    charge();
+                else
                     recordFailOpen("server.elicitation.open-frame-undelivered", `elicitation=${id} server=${req.server}`);
-                return undefined;
-            }
-            if (delivery === "stalled") {
-                rc.total += 1;
-                rc.lastByServer.set(req.server, t);
-            }
-            return ctx.emit({ type: "elicitation_complete", elicitationId: id, mcpServerName: req.server, action: answer.action, serverNowMs: this.now() });
-        })
-            .catch(() => recordFailOpen("server.elicitation.complete-breadcrumb-dropped", `elicitation=${id}`));
+            });
+        }
+        const answer = await answerP;
+        race.close({ type: "elicitation_complete", elicitationId: id, mcpServerName: req.server, action: answer.action, serverNowMs: this.now() });
         return answer;
     };
     respond(id, principal, body) {
@@ -149,7 +150,7 @@ export class ElicitationCoordinator {
         if (!parsed.ok)
             return { status: 400, body: refusalBody({ errorCode: "request.body_shape", message: parsed.error }) };
         const entry = this.pending.get(id);
-        if (!entry || (entry.owner !== null && entry.owner !== principal)) {
+        if (!entry || !keyAdmits("ask.answer", { subject: recoveredSubject(principal), operator: false }, ownerCellOf(entry.owner))) {
             return { status: 404, body: refusalBody({ errorCode: "elicitation.not_pending", message: "no pending elicitation for this id (answered, expired, or not on this replica)" }) };
         }
         entry.settle(parsed.value);

package/dist/engine-identity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 🔴 **引擎交界的身份**(唯一一处;叶子):一只主体的三格(`owner-brands.ts` 的 `partsOf`)怎么落进引擎 `TaskSpec` 的身份格。
+ *
+ * 二元形:`principal` = **人**(引擎的成文契约「终端用户 / MCP RBAC / 治理键」:用量窗扣账、出站 MCP / A2A 身份、事件归因、检查点的 `principal` 格都按人,
+ * 与本仓的人面汇点同轴);`isolationScope` = **带场景的主体**(只在请求带了场景时有;引擎按它分登记域 / offload 租界 / 后台登记 / peer 目录 / 工作流 scope,
+ * 引擎的读法是「隔离格缺席 ⇒ 读 `principal`」)。没带场景的请求只有 `principal`,与今天逐字节同。检查点的分区走本仓自己供的 `scope` 格。
+ *
+ * 今天的引擎还没有隔离格:{@link taskSpecIdentityOf} 是**唯一的落点**,今天只写 `principal`;隔离格到货后改那一行(钉在 `test/scenario-subject.test.ts`)。
+ * 落点之前引擎自己按 `spec.principal` 分的那几面按人分(同一个人的各场景在那几面互见)—— 本仓镜像这几面的读口(工作流读面、后台登记簿的停止标记、
+ * leader 子任务的 spec)同读 {@link taskSpecIdentityOf},读到的就是引擎写下的那一个值,不各写一份。
+ */
+import type { Person, Subject, SubjectParts } from "./owner-brands.js";
+/** 引擎交界的身份(本仓的类型;二元)。 */
+export interface EngineIdentity {
+    readonly principal: Person | undefined;
+    /** 带场景的主体;没带场景 ⇒ 缺席(引擎读 `principal`)。 */
+    readonly isolationScope?: Subject;
+}
+/** 一只主体(没有 ⇒ 匿名)在引擎交界上的身份。 */
+export declare function specIdentityOf(parts: SubjectParts | undefined): EngineIdentity;
+/**
+ * 落进 `TaskSpec` 的身份格(**唯一落点**)。今天的引擎没有隔离格 ⇒ 只写 `principal`,`isolationScope` 在这里不落(引擎按人分它自己的那几面);
+ * 引擎的隔离格到货 ⇒ 这里加一格,别处不动。
+ */
+export declare function taskSpecIdentityOf(parts: SubjectParts | undefined): {
+    readonly principal?: string;
+};
+//# sourceMappingURL=engine-identity.d.ts.map

package/dist/engine-identity.js

@@ -0,0 +1,10 @@
+export function specIdentityOf(parts) {
+    if (parts === undefined)
+        return { principal: undefined };
+    return parts.scenario === undefined ? { principal: parts.person } : { principal: parts.person, isolationScope: parts.subject };
+}
+export function taskSpecIdentityOf(parts) {
+    const { principal } = specIdentityOf(parts);
+    return principal === undefined ? {} : { principal };
+}
+//# sourceMappingURL=engine-identity.js.map

package/dist/entry-problems.d.ts

@@ -18,14 +18,12 @@ export interface EntryProblem {
 }
 /** 铸一条问题:`entry` 收**原串**,这里过脱敏(调用方没有「忘了脱敏」的可能)。 */
 export declare function entryProblem(code: string, field: string, rawEntry: string, reason: string): EntryProblem;
-/** 拒体上的机读位(原样进 `HttpError.extra` / `refusalBody` 的 `facts`:顶层 `field` + 对象形 `detail`)。 */
-export interface EntryProblemsFacts {
+/** 拒体上的机读位(原样摊在拒体根上:`HttpError.extra` / `refusalBody` 的 `facts`)。型别名而不是接口 —— 要能直接当 `Record<string, unknown>` 用。 */
+export type EntryProblemsFacts = {
     readonly field: string;
-    readonly detail: {
-        readonly problems: readonly EntryProblem[];
-        readonly total: number;
-    };
-}
+    readonly problems: readonly EntryProblem[];
+    readonly total: number;
+};
 /**
  * 一遍判下来的全部问题 ⇒ 拒体的机读位。**不能空**:没有问题就没有拒(调用方只在命中时调),空表是调用点的错,响亮抛。
  * 顶层 `field` = 第一条问题的坐标(句子点名的那一张清单)。

package/dist/entry-problems.js

@@ -9,6 +9,6 @@ export function entryProblemsFacts(found) {
     const first = found[0];
     if (first === undefined)
         throw new Error("entryProblemsFacts: a refusal needs at least one problem");
-    return { field: first.field, detail: { problems: found.length > MAX_ENTRY_PROBLEMS ? found.slice(0, MAX_ENTRY_PROBLEMS) : found, total: found.length } };
+    return { field: first.field, problems: found.length > MAX_ENTRY_PROBLEMS ? found.slice(0, MAX_ENTRY_PROBLEMS) : found, total: found.length };
 }
 //# sourceMappingURL=entry-problems.js.map

package/dist/env-facts.d.ts

@@ -1,5 +1,5 @@
 import type { ImageCapabilities } from "./plugins/store-contracts.js";
-import type { RemoteExecProvider } from "./execution-lane-caps.js";
+import type { ExecutionLane } from "./execution-lane-caps.js";
 export interface SandboxEnvFacts {
     profile?: string;
     capabilities?: string[];
@@ -54,7 +54,7 @@ export declare function buildEnvFacts(opts: {
  *  codex 复审 medium:k8s 必须按**有效快照能力**分叉,不能只看车道名——s3Snapshot 未配=park-only,
  *  resume 是全新 pod 且**工作区不恢复**,「文件已从快照恢复」那句会让模型信赖不存在的文件(比缺席
  *  更糟的谎)。 */
-export declare function resumeFactsForLane(provider: RemoteExecProvider | undefined, // 车道词 = settings-schema 词表正本(经本仓读口取型,不手抄;表加词 ⇒ 下方穷举 switch 编译红)
+export declare function resumeFactsForLane(provider: ExecutionLane, // 车道词 = settings-schema 词表正本(经本仓读口取型,不手抄;表加词 ⇒ 下方穷举 switch 编译红)
 caps?: {
     k8sSnapshot?: boolean;
 }): SandboxEnvFacts["resumeFacts"] | undefined;
@@ -73,6 +73,8 @@ export declare function scratchpadSessionSegment(sessionId: string): string;
  *  intermediate artifacts survive across turns/resume legs). Exported as the single source both the envFacts
  *  composer (below) and the future createFsWriteGatePolicy `exemptDirs` wiring ([ref]①, 1.290) must use. */
 export declare function scratchpadDirFor(localDataRoot: string, sessionId: string): string;
+/** 所有会话段的父目录 `<localDataRoot>/scratchpad`(段路径、过期清扫与一次性迁移 M39 的名册同读这一只)。 */
+export declare function scratchpadRootFor(localDataRoot: string): string;
 /** Resolve + CREATE the session scratchpad dir (mkdir -p, idempotent). Returns the path, or undefined when
  *  creation fails (honest-facts posture: never advertise a directory that does not exist — same class as
  *  egress/pkgSource "don't declare what you don't know"). Lifecycle: the reaper primitives live below —
@@ -149,7 +151,7 @@ export declare function screenShellScratchpadDir(raw: unknown, opts: {
  *    就是凭空多一条 400)。只判其一会留一条**跨请求**的洞:一条请求供一只合法壳 scratchpad 把判据引开、
  *    同时把 cwd 指进自算那只,放行后 cwd 坐进会话表,下一条不带路径字段的请求回落自算形、死在引擎构造期,
  *    而它根本没送过 cwd(codex r2 [medium] 实证);
- *  · **`in-process` 车道(provider 未设)不在射程**:那条腿的门根是**进程自己的 cwd**,与请求字段无关 ——
+ *  · **无手的 `none` 车道不在射程**:那条腿的门根是**进程自己的 cwd**,与请求字段无关 ——
  *    对着一个请求字段拒一件不是它造成的事,是把诊断指向错的地方(如实登记,不假装覆盖)。
  */
 export declare function scratchpadCoveringTaskRoot(args: {
@@ -183,7 +185,7 @@ export declare function sweepStaleScratchpads(localDataRoot: string, opts: {
 }): Promise<number>;
 /** Map the exec-lane posture to the egress fact (the model must know when downloads can't work). */
 export declare function egressForRemoteExec(remoteExec: {
-    provider?: string;
+    provider: string;
     allowInternetAccess?: boolean;
-} | undefined): "none" | "full" | undefined;
+}): "none" | "full" | undefined;
 //# sourceMappingURL=env-facts.d.ts.map