@sema-agent/server 7.146.0 → 7.147.0

package/dist/execution-config-root.js

@@ -1,17 +1,17 @@
 import { posix } from "node:path";
 import { DEPLOYMENT_SHAPE_PREDICATES } from "./deployment-shape.js";
-import { executionLaneHomeDir, executionLaneOf } from "./execution-lane-caps.js";
+import { executionLaneHomeDir } from "./execution-lane-caps.js";
 import { configRootOf } from "./sema-config-dir.js";
 const CONFIG_DIR_ENV = "SEMA_CONFIG_DIR";
 export function sandboxForwardedEnvOf(deployment) {
-    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    const lane = deployment.remoteExec.provider;
     switch (lane) {
         case "e2b":
         case "k8s":
-            return deployment.remoteExec?.sandboxEnv ?? {};
+            return deployment.remoteExec.sandboxEnv ?? {};
         case "local-docker":
-            return deployment.remoteExec?.env ?? {};
-        case "in-process":
+            return deployment.remoteExec.env ?? {};
+        case "none":
         case "host":
         case "ssh":
         case "adb":

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

@@ -0,0 +1,14 @@
+import type { ExecutionEnvFactoryContext, RewindFilesRequest, RewindFilesResult, Runner } from "@sema-agent/core";
+/**
+ * run 外回退调引擎的唯一入口:在用途 `rewind-files` 里调引擎的回退动词 `rewindFiles`,原样交回引擎的结果(引擎的拒原样上抛)。
+ * 唯一调用方 = `http/routes/sessions.ts` 的 `session-rewind-files` 臂(钉 `test/session-rewind-files.test.ts` (f))。
+ */
+export declare function rewindFilesUnderPurpose(runner: Pick<Runner, "rewindFiles">, request: RewindFilesRequest): Promise<RewindFilesResult>;
+/**
+ * 会话附件物化层(D-1 半场③;只装在没有恢复点的车道上,装配见 `boot/execution-env.ts`):建好内层环境之后,把这只会话绑定的附件写进工作目录。
+ * 写失败即抛(环境建立失败 —— objective 已向模型宣告文件在场,静默缺文件比任务失败更糟)。用途 `rewind-files` ⇒ 不写(没有模型、没有宣告;回退只碰被跟踪的文件)。
+ * `materialize` = 写附件的那一只(`task-attachment-store.ts` 的 `materializeAttachmentsInto`),返回写了几只(按工厂上下文的会话写);`onMaterialized` = 写了 ≥ 1 只时的运维行。
+ * 环境型是泛型参数:层不看环境的形,只把内层交回的那一只原样交回。
+ */
+export declare function createAttachmentMaterializingFactory<E>(inner: (ctx: ExecutionEnvFactoryContext) => E | Promise<E>, materialize: (env: E, ctx: ExecutionEnvFactoryContext) => Promise<number>, onMaterialized: (sessionId: string, count: number) => void): (ctx: ExecutionEnvFactoryContext) => Promise<E>;
+//# sourceMappingURL=execution-env-purpose.d.ts.map

package/dist/execution-env-purpose.js

@@ -0,0 +1,29 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const purposeSeat = new AsyncLocalStorage();
+export function rewindFilesUnderPurpose(runner, request) {
+    return purposeSeat.run("rewind-files", () => runner.rewindFiles(request));
+}
+function materializesAttachments(purpose) {
+    switch (purpose) {
+        case undefined:
+            return true;
+        case "rewind-files":
+            return false;
+        default: {
+            const unhandled = purpose;
+            throw new Error(`materializesAttachments: no ruling for purpose ${String(unhandled)}`);
+        }
+    }
+}
+export function createAttachmentMaterializingFactory(inner, materialize, onMaterialized) {
+    return async (ctx) => {
+        const env = await inner(ctx);
+        if (!materializesAttachments(purposeSeat.getStore()))
+            return env;
+        const n = await materialize(env, ctx);
+        if (n > 0)
+            onMaterialized(ctx.sessionId, n);
+        return env;
+    };
+}
+//# sourceMappingURL=execution-env-purpose.js.map

package/dist/execution-lane-caps.d.ts

@@ -6,11 +6,9 @@ import { type LaneHomeConfig } from "./lane-home-probe.js";
  *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell/LSP 都是这一档,理由同源:
  *  一个租户的输入不许把 agent 指向 worker 宿主上另一个租户/运维的文件与进程)。 */
 export type LaneCapability = "supported" | "unsupported" | "single-user-only";
-/** `REMOTE_EXEC` 能写下去的车道词全集 = settings-schema 词表正本的 `ExecutionLane`(**派生**,本仓零手抄)。 */
-export type RemoteExecProvider = DeclarableLane;
-/** 闭集:执行车道全集 = 表的可声明车道 + `in-process`(`REMOTE_EXEC` 未设的进程内 stub 形 —— 它是「没有 remoteExec」
- *  这个状态的名字,不在表里)。表加词 ⇒ {@link executionLaneCaps} 的穷举 switch 编译红,这正是要的(「加词必须逐位表态」)。 */
-export type ExecutionLane = "in-process" | RemoteExecProvider;
+/** 闭集:执行车道全集 = settings-schema 词表正本的可声明车道(**派生**,本仓零手抄;`REMOTE_EXEC` 能写下去的词就是这些)。
+ *  表加词 ⇒ {@link executionLaneCaps} 的穷举 switch 编译红,这正是要的(「加词必须逐位表态」)。 */
+export type ExecutionLane = DeclarableLane;
 /**
  * per-lane 能力位。每一位的注里点名**今天真正做判决的那处代码**——对账测试按这些坐标跑真函数,
  * 所以坐标漂了(重命名/搬家/改语义)门会红,注释不会烂在这里。
@@ -27,7 +25,7 @@ export interface ExecutionLaneCaps {
     readonly scheduler: LaneCapability;
     /** LSP。判别式:`boot/execution-env.ts` 的 `lspManager` 两臂(沙箱桥 e2b/k8s;host 本地 NodeLspManager)。 */
     readonly lsp: LaneCapability;
-    /** SendUserFile 的**沙箱直传腿**(host/in-process 的本机 fs 源是另一条腿,不是本位)。
+    /** SendUserFile 的**沙箱直传腿**(host 的本机 fs 源是另一条腿,不是本位)。
      *  读者:部署形表行 `sandboxSendUserFile`(本位即判据;判定依据在 `capabilities/sandbox-file-send.ts` 头注)。 */
     readonly sandboxSendUserFile: LaneCapability;
     /** `/tmp/scratchpad/<sessionId>` 远端约定。读者:部署形表行 `remoteScratchpad`(本位即判据;改前对账 `isRemoteScratchpadLane` 的 Set)。 */
@@ -37,13 +35,12 @@ export interface ExecutionLaneCaps {
     /**
      * 这条车道**分不分租户**(裁定语义 = **租户不共宿主**)。
      *  · `supported` = 每个租户的命令落在各自的目标上(每任务一只沙箱:e2b / k8s / local-docker;发起者自己的设备:device,
-     *    归属由 deviceId↔principal 绑定验过),或根本没有手(in-process:没有可共享的执行目标);
+     *    归属由 deviceId↔principal 绑定验过),或根本没有手(none:没有可共享的执行目标);
      *  · `single-user-only` = 所有任务落在**同一个共享目标**上(worker 宿主:host;一台常驻 SSH 对端:ssh;一台 ADB 设备:adb)
      *    ⇒ 只许单用户部署用。
      * 本位**没有** `unsupported` 这一档(那会读成「谁都不许用」,不是车道事实)—— 型上收窄掉,每条车道必须在两档里表态。
      * 🔴 **本位的值不在本仓写**:七条可声明车道读 settings-schema 词表正本的表行(`executionLaneRow(lane).tenantSeparation`;
-     * 中心写闸的 `requirePrincipal ∧ single-user-only` 交叉判与本仓 `multi-tenant-shared-lane` 拒启读的是同一个值,不会分叉);
-     * 只有 `in-process` 一格是本仓自己的事实(它不在表里)。
+     * 中心写闸的 `requirePrincipal ∧ single-user-only` 交叉判与本仓 `multi-tenant-shared-lane` 拒启读的是同一个值,不会分叉)。
      * 唯一消费点是 `config-invariants.ts` 的 `multi-tenant-shared-lane`(经部署形表行 `laneSeparatesTenants` 落成布尔)。本位值与本仓**运行期事实**
      * 不矛盾的对账 = `test/execution-lanes-schema-conformance.test.ts`(执行环境块的隔离位 / 路径是不是本机的 ⇒ 租户档的蕴含 + 唯一一条「不隔离却分租户」
      * 的车道 = device 点名);ssh / adb 「两租户同一目标」的行为预言机 = `test/multi-tenant-shared-lane.test.ts`
@@ -88,16 +85,16 @@ export declare function sandboxReadFloorState(lane: SandboxFloorLane, knob: Sand
 /** {@link capabilitiesFor} 读的部署配置:已装配的 `remoteExec` 里决定块的两键(`ServiceConfig` 的判别联合每一臂结构上都满足)+ 部署级读地板旋钮
  *  (`SANDBOX_READ_FLOOR`;缺席 ⇒ 缺省 `keep`,与 loader 同一只常量)。 */
 export interface CapabilitiesDeployment {
-    readonly remoteExec?: {
-        readonly provider?: string | undefined;
+    readonly remoteExec: {
+        readonly provider: string;
         readonly s3Snapshot?: unknown;
-    } | undefined;
+    };
     readonly sandboxReadFloor?: SandboxReadFloorKnob | undefined;
 }
 /**
  * 「这份部署上 run 所在的执行环境能做什么」—— 引擎能力块(八键)的**唯一作者**。
  *
- * 七只适配器的 `capabilities` 由它铸(适配器源码里没有能力字面量);`in-process` 答引擎桩环境的块。读者读块,不另存一位:
+ * 七只适配器的 `capabilities` 由它铸(适配器源码里没有能力字面量);`none` 答引擎桩环境的块。读者读块,不另存一位:
  * 起服行 `remote_exec_enabled`(`isolated` / `suspendable` / `keepsReadFloor`)、部署形表行 `sandboxPathAdjudication` / `suspendableHands`、
  * {@link laneIsolated} / {@link laneWiresExecutionEnv} / {@link handsOnWorkerFilePlane}、记忆边界审计的文件平面位。改一条车道的能力 = 改本函数一处,
  * 适配器、行、起服行、wire 同翻(门 `test/execution-env-capabilities-one-source.test.ts`)。
@@ -105,10 +102,10 @@ export interface CapabilitiesDeployment {
  * 认不出的车道词 ⇒ `undefined`(调用方 fail-closed;生产链上不可达,`loadConfig` 先拒启)。两个重载同 {@link executionLaneOf}:喂已装配的车道词 ⇒ 返回型无 `undefined`。
  */
 export declare function capabilitiesFor(deployment: {
-    readonly remoteExec?: {
-        readonly provider: RemoteExecProvider;
+    readonly remoteExec: {
+        readonly provider: ExecutionLane;
         readonly s3Snapshot?: unknown;
-    } | undefined;
+    };
     readonly sandboxReadFloor?: SandboxReadFloorKnob | undefined;
 }): ExecutionEnvCapabilities;
 export declare function capabilitiesFor(deployment: CapabilitiesDeployment): ExecutionEnvCapabilities | undefined;
@@ -119,21 +116,15 @@ export declare function capabilitiesFor(deployment: CapabilitiesDeployment): Exe
  */
 export declare function laneSandboxReadFloorState(deployment: CapabilitiesDeployment): SandboxReadFloorState | undefined;
 /**
- * 车道普查全集 = 本仓内部状态名 `in-process` + 词表正本的可声明车道(次序 = 正本声明序;对账测试按它逐 lane 跑真判别式)。
- * 由正本派生、不手维护(手维护的「全表」已被代码反证漏过行)。
+ * 车道全集 = settings-schema 词表正本的 `EXECUTION_LANE_WORDS`(冻结副本,次序逐字同;对账测试按它逐 lane 跑真判别式)。由正本派生、不手维护。
+ * 读者:{@link isExecutionLane} 的底座;配置目录 `REMOTE_EXEC` 行的 `enumValues`(**就用它本人**,身份相等有钉 —— [ref] 修过「目录手抄一份词表」的病);
+ * `multi-tenant-shared-lane` 拒启句的出路车道。`REMOTE_EXEC` 真能写下去的就是这些词 —— 7.147.0 起没有表外的状态名。
  */
 export declare const ALL_EXECUTION_LANES: readonly ExecutionLane[];
 /** 一个开放字符串是不是闭集里的词(不做前缀 / 大小写宽容)。 */
 export declare function isExecutionLane(word: string): word is ExecutionLane;
-/**
- * `REMOTE_EXEC` **真能写下去的**那几个词 = settings-schema 词表正本的 `EXECUTION_LANE_WORDS`(冻结副本,次序逐字同)。
- * 读者:配置目录 `REMOTE_EXEC` 行的 `enumValues`(**就用它本人**,身份相等有钉 —— [ref] 修过「目录手抄一份词表」的病)、
- * [ref] 拒启句的 `valid:` 列表、`REQUIRE_EXECUTION_LANE` 拒启句的出路、`multi-tenant-shared-lane` 拒启句的出路车道。
- * 7.114.0 起全仓唯一的车道词来源是正本;本常量只是它在本仓的那一个读口。
- */
-export declare const REMOTE_EXEC_PROVIDER_WORDS: readonly RemoteExecProvider[];
-/** 一条可声明车道在词表正本里的那一行(必需 / 可选 env 四栏 + 租户档)。加载期自检过完备性,所以对任何 {@link RemoteExecProvider} 都有行。 */
-export declare function executionLaneRow(lane: RemoteExecProvider): ExecutionLaneRow;
+/** 一条车道在词表正本里的那一行(必需 / 可选 env 四栏 + 租户档)。加载期自检过完备性,所以对任何 {@link ExecutionLane} 都有行。 */
+export declare function executionLaneRow(lane: ExecutionLane): ExecutionLaneRow;
 /**
  * 一条车道**必需**的 env 键名 = 正本表行的 `requiredEnv ∪ requiredSecretEnv`(次序:非密坐标在前、密钥在后 —— 与 7.113.0 本仓手写表逐字同)。
  * 读者:`config.ts` 的 [ref] 拒启门(点了名却缺件 ⇒ 点名缺哪几键)、部署面门(`test/deploy-lanes-contract.test.ts`:`lanes.json` 每行登记
@@ -141,7 +132,7 @@ export declare function executionLaneRow(lane: RemoteExecProvider): ExecutionLan
  * 每条车道的必需键都在这一张表上、缺席都由下面的 {@link laneMissingEnv} 一只判官判 —— device 行也是(契约包 16.0.0 起 `requiredEnv: ["DEVICE_RELAY_URL"]`):缺席 / 空串 / 只含空白在 `declaredExecutionLane` 的必需 env 门被拒,
  * 走到 `config.ts` 的设备入口解析器 `parseDeviceRelayUrlEnv` 时值一定在,它只判值的文法与凭据形。没有哪个必需键另有一臂缺席判官。
  */
-export declare function laneRequiredEnv(lane: RemoteExecProvider): readonly string[];
+export declare function laneRequiredEnv(lane: ExecutionLane): readonly string[];
 /**
  * 一个必需 env 的值**算不算缺**的唯一判官 —— 两半各有归属:
  *  · **空白半边**(空串、只含空白)归契约包:`isBlankCoordinate`(函数体住在 `execution-lanes` 叶模块,包根转口同一个函数对象)是这件事唯一的实现,契约包的写闸(车道声明保存时)问的是同一只函数,本仓不另抄一份;
@@ -155,70 +146,42 @@ export declare function isBlankRequiredEnvValue(value: string | undefined): bool
  * 一条车道此刻**缺**的必需 env 键名(次序同 {@link laneRequiredEnv};「缺」的判官是 {@link isBlankRequiredEnvValue})。
  * 读者:`config.ts` 的 [ref] 拒启门(非空 ⇒ 拒启并点名缺哪几键);判的是调用方交来的 env 快照,本函数不读 `process.env`。
  */
-export declare function laneMissingEnv(lane: RemoteExecProvider, env: Readonly<Record<string, string | undefined>>): readonly string[];
-/** {@link readDeclaredLaneTable} 的答案:合文法 ⇒ 有序车道表(非空;首项 = 缺省);不合 ⇒ 拒句(点名那一段)。 */
+export declare function laneMissingEnv(lane: ExecutionLane, env: Readonly<Record<string, string | undefined>>): readonly string[];
+/** {@link readDeclaredLaneTable} 的答案:合法 ⇒ 有序车道表(非空;首项 = 缺省);不合法 ⇒ 拒句(点名每一条拒因)。 */
 export type DeclaredLaneTableReading = {
-    readonly lanes: readonly [RemoteExecProvider, ...RemoteExecProvider[]];
+    readonly lanes: readonly [ExecutionLane, ...ExecutionLane[]];
 } | {
     readonly refusal: string;
 };
 /**
  * `REMOTE_EXEC` 的**唯一读法** —— 部署声明的有序执行车道表。它是契约 `runtime.execution.lanes`(settings-schema 16.0.0 起是车道集)渲成 env 的形:
- * `lanes.join(",")`,首项 = 缺省;单词 = 一元表,与此前的单值读法逐字同。
+ * `lanes.join(",")`,首项 = 缺省;单词 = 一元表。
  *
- * 文法(契约写闸对 `lanes` 的同一组规则,在 env 串上的读法):逗号分段;每段**逐字**是一个可声明车道词({@link REMOTE_EXEC_PROVIDER_WORDS} = 契约词表,
- * 不 trim、不折大小写 —— 渲染器不写空白,` k8s` 不是车道词);段不空;一条车道至多出现一次。`in-process` 是「没点名」这个状态的名字,不是可写词。
- * 未设 / 空串**不是表**(没有声明 —— 调用方先判,本函数只收非空串)。
- * 不合文法 ⇒ `refusal`,拒句点名那一段;只有一段时与单值时代的拒句逐字同。契约的退役车道值(墓碑 `RETIRED_LANE_WORDS`)拒句取契约的
- * `retiredLaneWordRefusal`(出路在源头给,一句 —— 车道文件 `provider` 读到同一个旧词时契约给的是同一句)。本函数只判文法;本引擎版本能服务几条车道、
- * 每条车道缺不缺必需键,是调用方的门。
+ * **本函数只切段**(按逗号,不 trim、不折大小写 —— 渲染器不写空白,` k8s` 不是车道词);这张表合不合法只有一个答者:契约判官 `laneSetFlaws`
+ * (settings-schema 18.0.0;写闸、web-admin 表单与本函数问同一只)—— 非空、每段是不是车道词(空白段 / 不认识的词 / 车道值墓碑里的旧词)、一条车道至多一次、
+ * 独占车道(依据 `no-execution-target`,今天 = `none`)只能独成一集,全是它答;判官交回全部拒因,拒句逐条点名,以契约规则句 `LANE_SET_RULE` 收尾
+ * (车道词表与独占形从契约表派生,本仓不手抄)。墓碑词的那一条用契约的墓碑句(出路在源头给;车道文件 `provider` 读到同一个旧词时契约给的是同一句)。
+ * `in-process`(7.146.0 及更早的「没点名」状态名)不是车道词(判官答 `unknown`;拒句列合法词,含 `none`)。未设 / 空串**不是表**(没有声明 —— 调用方先判,本函数只收非空串)。
+ * 本引擎版本能服务几条车道、每条车道缺不缺必需键,是调用方的门。
  */
 export declare function readDeclaredLaneTable(raw: string): DeclaredLaneTableReading;
 /**
- * [ref] 件③ / [ref] —— **「`REQUIRE_EXECUTION_LANE=true` ∧ 没有任何车道被点名 ⇒ 拒启」的判据与拒因句的唯一属主**(`modelProviderRefusal` /
- * `modelRouteEndpointRefusal` 同形:属主在叶模块,执法点各自调它,登记在 `config-invariants.ts`)。
- *
- * 🔴 病([ref],test d327-g6-engine-7112 OBS-4 / OBS-5;2026-10-03 亲核):修前**两份句子**。运行期真拒启的是 `config.ts` 手写 throw
- * (点名 `REQUIRE_EXECUTION_LANE` / `REMOTE_EXEC` + 修法,用户在 stderr 读到的就是它);注册表条目另写了一句短的
- * 「the deployment asked to refuse this state」,而它只在 `web-admin-client/stage-limits.ts` 的全表校验里被调 —— 候选视图只装
- * `BATCH1_LIMIT_KEYS` 的限额键,带不上这两键 ⇒ 对本条恒 `next === live`,**那一句没有任何读者**(test 六个拒启格 stderr 里零命中)。
- * 改一份另一份不跟。现形:boot 的 throw 与注册表条目的 `check` **都**调本函数 —— 一只判据、一句话,没有第二份文本可漂。
- *
- * 判据读**装配结果**(`executionLaneOf` = 全仓唯一的缺席归一读口,缺席 ⇒ `in-process`),不重判 env:`remoteExec` 缺席**就是**
- * 「`REMOTE_EXEC` 未设/空串 ∧ `CONFIG_PROVIDER ≠ local`」这条三元链尾臂的落点;点了名却配不齐 / 认不出归 [ref] 那条既有拒启(两句话各说各的问题)。
- *
- * 句子的量词纪律([ref] ②):stub 车道上**手带族**(`wiring_manifest.tools.entries[].mountedBy === "hands"`)整族不挂,名册里其余工具
- * 照常执行(test R1n:`Now` 真执行成功)—— 不写「零工具」;名册**总条数**随 core 版本走,不写进句子([ref] ③)。
- */
-export declare function executionLaneRequiredRefusal(deployment: {
-    readonly requireExecutionLane: boolean;
-    readonly remoteExec?: ServiceConfigFlat["remoteExec"];
-}): string | undefined;
-/**
- * `config.remoteExec?.provider` → 车道词。**全仓唯一**的缺席归一读口([ref] 门 D:`?? "in-process"` 只许住在这里,
- * `?? "host"` 与 `lane === undefined || lane === "host"` 同义折零容忍)。
- *
- * · `undefined`(REMOTE_EXEC 未设)⇒ `"in-process"`,那是真车道不是缺席;
- * · 认不出的词 ⇒ `undefined`,**调用方必须 fail-closed**(禁静默按某个默认车道处理)。生产链上这一臂
- *   不可达:`loadConfig` 的 [ref] 拒启门先咬未知词;它存在是为了消费点自卫时有个响亮出口。
- *
- * 两个重载 = 类型收窄([ref] §2.2 A):喂**已装配的** config 形(`RemoteExecProvider | undefined`)⇒
- * 返回型里没有 `undefined`,调用点不必为一条不可达的臂写兜底(兜底写多了就是下一处折词);喂开放字符串
- * (测试、外部输入)⇒ 返回含 `undefined`,逼调用点表态。第一个重载的成立依据是**构造**的:
- * `RemoteExecProvider` 是正本元组 `EXECUTION_LANE_WORDS` 的元素型,而 {@link isExecutionLane} 的集合正是由那只元组
- * (加 `in-process`)建成 ⇒ 对 `RemoteExecProvider` 的每一个值 `isExecutionLane` 恒真(对账格逐词跑过)。
+ * 一个**开放字符串**(外部输入、手搓的部署形)→ 车道词;认不出 ⇒ `undefined`,**调用方必须 fail-closed**(禁静默按某个默认车道处理)。
+ * 没有缺席入参:「没声明车道」只在执行车道合成步判一次(拒启),合成之后的配置型上 `remoteExec` 必在、`provider` 就是车道词 ——
+ * 读已合成配置的消费点直读 `config.remoteExec.provider`,不经本函数、不写兜底(门 `test/execution-lane-fold-ban.test.ts`:任何读者都不许把缺席 /
+ * 认不出折成某条车道)。闭集重载喂车道词 ⇒ 返回型无 `undefined`(成立依据是**构造**的:{@link isExecutionLane} 的集合就是由正本元组建成)。
  */
-export declare function executionLaneOf(provider: RemoteExecProvider | undefined): ExecutionLane;
-export declare function executionLaneOf(provider: string | undefined): ExecutionLane | undefined;
+export declare function executionLaneOf(provider: ExecutionLane): ExecutionLane;
+export declare function executionLaneOf(provider: string): ExecutionLane | undefined;
 /**
- * 本部署声明的**有序执行车道表**(首项 = 缺省 = 服务车道)的唯一读法。本版 `REMOTE_EXEC` 单值 ⇒ 一元表 `[executionLaneOf(provider)]`;
+ * 本部署声明的**有序执行车道表**(首项 = 缺省 = 服务车道)的唯一读法。本版 `REMOTE_EXEC` 单值 ⇒ 一元表 `[provider]`;
  * 车道表配置面落地时只改这一只。读者:执行放置切换的回填(一次性迁移 M32 与它的 DDL 前探针 —— 回填只在一元表下有唯一答案)。
  */
 export declare function deployedExecutionLanes(config: Pick<ServiceConfigFlat, "remoteExec">): readonly ExecutionLane[];
 /**
  * 「这条车道的**手**就在本 worker 的盘上吗」= 块 `io ∧ hostLocalPaths`(读 {@link capabilitiesFor} 的块,不手抄)。今天只有 `host` 两键同真。
  *
- * 🔴 **只读 `hostLocalPaths` 是错的**:`in-process` 的桩块那一键是 true(进程内读确实在本机盘上),而它**没有手**(`io: false`)——
+ * 🔴 **只读 `hostLocalPaths` 是错的**:`none` 的桩块那一键是 true(进程内读确实在本机盘上),而它**没有手**(`io: false`)——
  * 只读一键会让无手部署**继续**挂 SendUserFile,与「无手不挂」的意图相反。
  *
  * 读者问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
@@ -234,7 +197,7 @@ export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
  * **一条律**:LSP 只在本谓词为真的车道挂(`boot/execution-env.ts` 的 LSP 管理器两臂都合取它;表的 `lsp` 位与之同向,
  * 对拍钉 `test/host-env-open-bound.test.ts`:本谓词 ⟺ 适配器类原型上有 `openBound`)。
  *  · `host` —— `RemoteHostExecutionEnv.openBound` 委托 core `NodeExecutionEnv` 的实现(唯一属主),真;
- *  · `in-process` —— 没有手(core 落桩环境),无物可绑;
+ *  · `none` —— 没有手(执行环境两座都不给),无物可绑;
  *  · 其余车道(沙箱 / 远端 shell / 设备)—— 读走 exec / sftp / 设备协议,本版不实现绑定读,假。实现之日翻这一格,LSP 沙箱桥随之回来。
  * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
  */
@@ -247,7 +210,7 @@ export declare function laneBindsReads(lane: ExecutionLane): boolean;
  *  · `host` —— 命令是本进程的子进程,子进程拿到的 `HOME` 由适配器自己组合(继承面 + 会话 `settings.env` 授予),不 spawn 就读得出,真;
  *  · `device` —— 设备协议(hello / 指令集)没有家目录读数:读它要么走协议新增一格(协议对端在别仓),要么往员工自己的机器上多跑一条未经策略门的命令,都不是本函数能替它定的,假
  *    (声明就是座,起服披露「来自声明、未实测」,见 {@link buildLaneHomeBootNote});
- *  · `in-process` —— 没有手,无环境可读,假。
+ *  · `none` —— 没有手,无环境可读,假。
  * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。对拍钉:读得出 ⟺ 该车道的适配器源码恰持一只座(`test/lane-home-claim-verified.test.ts`)。
  */
 export declare function laneMeasuresHome(lane: ExecutionLane): boolean;
@@ -257,7 +220,7 @@ export type LaneReadFaceDefault = "open" | "roots";
  * [ref](clay 裁 [ref])—— **车道行显式声明读面缺省 `readFaceDefault`**:`READ_FACE` 没人表态时,这条车道自己的执行体该不该读面放开。
  *  · `open` —— 隔离型车道(`e2b` / `k8s` / `local-docker`:每任务一只沙箱,OS 级隔离边界,`tenantSeparationBasis === "isolation"`):沙箱内部就是模型的整个世界,
  *    读面缺省放开(`auto` 连续干活不再每碰一个根外路径就出卡;写面 / deny 表 / 审批模式不受影响)。
- *  · `roots` —— 其余车道(`host` / `in-process` / `ssh` / `adb` / `device`):车道本身不给读面任何放开的理由 —— 手落在一台真机 / 共享目标 / 员工设备上。
+ *  · `roots` —— 其余车道(`host` / `none` / `ssh` / `adb` / `device`):车道本身不给读面任何放开的理由 —— 手落在一台真机 / 共享目标 / 员工设备上。
  *    **`roots` 不是「钉死 roots」**:它的意思是「本车道不替运维声明缺省」,缺省回到既有的 posture 派生(单用户 turnkey ⇒ `open`〔来源 `posture`〕;多租户 ⇒ 引擎默认 `roots`),
  *    这些车道上的读面一个字节不变。优先序见 `posture-source.ts`(`env` > `center` > `lane` > `posture` > `engine-default`)。
  *
@@ -273,12 +236,12 @@ export declare const LANE_OPEN_READ_FACE_CAUTION = "a deployment that mounts hos
  * `remote_exec_real_system` 那一行、`config.d/remote-exec.json` 抢占披露的「隔离降级」判、wire `executionLane.isolated` + 诊断面同位、那一行 note 列的沙箱出路、
  * 部署面 `lanes.json` 的 `isolation` 列。
  * ⚠️ 口径 = **OS 级边界**(容器即算),**不是**「独立内核」强度 —— 那是部署形表行 `vmIsolatedHands`(A 值路由读它),不是本函数的第二份。
- * ⚠️ 本函数对 `in-process` 也答(桩块 false)—— 那一格是「表」的完整性,不是 wire 的说法:无手部署**没有执行边界可言**,wire 上 `executionLane.isolated`
+ * ⚠️ 本函数对 `none` 也答(桩块 false)—— 那一格是「表」的完整性,不是 wire 的说法:无手部署**没有执行边界可言**,wire 上 `executionLane.isolated`
  * 按 present-iff 缺席(`capabilities/execution-lane.ts`),不是 false。
  */
 export declare function laneIsolated(lane: ExecutionLane): boolean;
 /**
- * 这条车道**有没有手**(块 `io`:文件与 shell 两面真到达目标;`in-process` 的桩块 false)的唯一布尔口。读者四处:路由的「有没有执行环境」(`boot/resolve-spec.ts`)、
+ * 这条车道**有没有手**(块 `io`:文件与 shell 两面真到达目标;`none` 的桩块 false)的唯一布尔口。读者四处:路由的「有没有执行环境」(`boot/resolve-spec.ts`)、
  * wire `executionLane.isolated` 的在场判据(`capabilities/execution-lane.ts`)、场景详情的附件供给集(`boot/stage-07-capability-layer.ts` 把它填进
  * `ScenarioDeps.handsLane`:「这一 run 有没有工作区」的车道半场)、起服家目录那一行({@link buildLaneHomeBootNote})—— 同读这一只。
  */
@@ -316,9 +279,9 @@ export declare const PLANNED_LANE_DIVERGENCES: readonly PlannedLaneDivergence[];
 export declare const E2B_SANDBOX_HOME = "/home/user";
 /** {@link executionLaneHomeDir} 读的那两位部署配置(`ServiceConfig` 结构上满足)。 */
 export interface LaneHomeDeployment {
-    readonly remoteExec?: {
-        readonly provider: RemoteExecProvider;
-    } | undefined;
+    readonly remoteExec: {
+        readonly provider: ExecutionLane;
+    };
     /** `REMOTE_EXEC_HOME_DIR` —— 运维显式声明的执行环境 home(绝对路径;坏值在 config 层拒启)。 */
     readonly remoteExecHomeDir?: string | undefined;
 }
@@ -344,8 +307,8 @@ export interface LaneHomeDeployment {
  * ## 一条规则,不是七条特判
  * **运维显式声明恒赢**(`REMOTE_EXEC_HOME_DIR`,部署级旋钮,不挂任何客户端表态);没有声明时,
  * 只有「home 是**车道本身**的属性」的那几条车道才有答案:
- *  · `host` / `in-process` —— 命令就跑在本进程这台机器、这个用户下,`os.homedir()` 读的就是它
- *    (core 自己的 `NodeExecutionEnv` 同判);
+ *  · `host` —— 命令就跑在本进程这台机器、这个用户下,`os.homedir()` 读的就是它
+ *    (core 自己的 `NodeExecutionEnv` 同判);`none` 没有手,同答本进程用户的 home(只作 `~/` 规则的基);
  *  · `e2b` —— 平台固定用户,见 {@link E2B_SANDBOX_HOME};
  *  · `k8s` / `local-docker` —— home 是**镜像**的属性,boot 期无从得知;
  *  · `ssh` —— home 是**目标机上那个登录用户**的属性(root 是 `/root`、macOS 是 `/Users/<u>`),
@@ -369,7 +332,7 @@ export declare function buildLaneHomeClaim(deployment: LaneHomeDeployment): Pick
 /**
  * 起服关于本部署执行环境家目录的那一行(纯数据 ⇒ `build*`):`{ event, note }`,或 `undefined`(不出这一行)。只有**读不了**家目录的车道才由起服说 ——
  * 读得出的车道({@link laneMeasuresHome})在每只环境开起来时自己证 / 自己量,出问题由那只环境说(拒,或同一只 `execution_lane_home_undeclared`)。
- *  · 无手(in-process)/ 认不出的车道 ⇒ 不出;
+ *  · 无手(none)⇒ 不出;
  *  · 读不了 ∧ 没有答案 ⇒ `execution_lane_home_undeclared`:代价如实(引擎 7.52.0 起家锚拒读行放不下 ⇒ 每一次泄内容的递归读在全 shell 面强制问人、只读面拒;
  *    `~/` 形规则下单 422),出路 = 声明家目录;
  *  · 读不了 ∧ 声明了 ⇒ `execution_lane_home_unmeasured`:座 = 声明、没有读数证过它 —— 对不上时规则守错目录,运维要守住「声明 = 环境里命令看到的 `$HOME`」。
@@ -382,7 +345,7 @@ export declare function buildLaneHomeBootNote(deployment: LaneHomeDeployment): {
 } | undefined;
 /**
  * 「部署要求读拒表的字节地板(`READ_DENY_FLOOR_REQUIRED=true`),而本部署车道的执行环境块不守地板」时起服那一行的 `note`(纯字符串 ⇒ `build*`);否则 `undefined`。
- * 判据只读部署的要求与 {@link capabilitiesFor} 的 `keepsReadFloor`(认不出的车道答不出块 ⇒ 按不守说,不静默)。`in-process` 的桩块守地板 ⇒ 不出。
+ * 判据只读部署的要求与 {@link capabilitiesFor} 的 `keepsReadFloor`(认不出的车道答不出块 ⇒ 按不守说,不静默)。`none` 的桩块守地板 ⇒ 不出。
  * 句子点名车道与键:这条车道上每个读拒表有行的 run(出厂读拒档在岗时就有行)都在准备期拒,一个命令都不起 —— 起服先把后果与两条出路说出来,
  * 不让运维从第一条 409 才知道。
  */

package/dist/execution-lane-caps.js

@@ -1,13 +1,13 @@
 import { homedir } from "node:os";
 import { StubExecutionEnv } from "@sema-agent/core";
-import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES, isBlankCoordinate, retiredLaneWordRefusal } from "@sema-agent/settings-schema/execution-lanes";
+import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES, LANE_SET_RULE, isBlankCoordinate, laneSetFlaws, retiredLaneWordRefusal } from "@sema-agent/settings-schema/execution-lanes";
 import { DECLARE_HOME_REMEDY, LANE_HOME_UNDECLARED_EVENT, LANE_HOME_UNMEASURED_EVENT, buildHomeAbsentNote, buildHomeUnmeasuredNote } from "./lane-home-probe.js";
 const NO = "unsupported";
 const YES = "supported";
 const SU = "single-user-only";
 export function executionLaneCaps(lane) {
     switch (lane) {
-        case "in-process":
+        case "none":
             return {
                 callerCwd: NO,
                 backgroundShell: NO,
@@ -16,7 +16,7 @@ export function executionLaneCaps(lane) {
                 sandboxSendUserFile: NO,
                 remoteScratchpad: NO,
                 worktreeIsolation: NO,
-                tenantSeparation: YES,
+                tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "host":
             return {
@@ -119,7 +119,7 @@ export function sandboxReadFloorState(lane, knob) {
             return readFloorStateOf(k, false);
     }
 }
-const IN_PROCESS_BLOCK = new StubExecutionEnv().capabilities;
+const NONE_BLOCK = new StubExecutionEnv().capabilities;
 const HOST_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: true, canonicalPathAuthoritative: true, hostLocalPaths: true, externalContentTarget: false, io: true, keepsReadFloor: false });
 const E2B_SHAPE = Object.freeze({ isolation: true, suspendable: true, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true });
 const K8S_SHAPE = Object.freeze({ isolation: true, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true });
@@ -144,8 +144,8 @@ const DEVICE_BLOCK = Object.freeze({ isolation: false, suspendable: false, share
 const NO_SUB_KNOBS = Object.freeze({ snapshotStore: false, sandboxReadFloor: undefined });
 function laneBlock(lane, sub) {
     switch (lane) {
-        case "in-process":
-            return IN_PROCESS_BLOCK;
+        case "none":
+            return NONE_BLOCK;
         case "host":
             return HOST_BLOCK;
         case "e2b":
@@ -161,13 +161,13 @@ function laneBlock(lane, sub) {
     }
 }
 export function capabilitiesFor(deployment) {
-    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    const lane = executionLaneOf(deployment.remoteExec.provider);
     if (lane === undefined)
         return undefined;
-    return laneBlock(lane, { snapshotStore: lane === "k8s" && Boolean(deployment.remoteExec?.s3Snapshot), sandboxReadFloor: deployment.sandboxReadFloor });
+    return laneBlock(lane, { snapshotStore: lane === "k8s" && Boolean(deployment.remoteExec.s3Snapshot), sandboxReadFloor: deployment.sandboxReadFloor });
 }
 export function laneSandboxReadFloorState(deployment) {
-    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    const lane = executionLaneOf(deployment.remoteExec.provider);
     if (lane === undefined)
         return undefined;
     switch (lane) {
@@ -175,7 +175,7 @@ export function laneSandboxReadFloorState(deployment) {
         case "k8s":
         case "local-docker":
             return sandboxReadFloorState(lane, deployment.sandboxReadFloor);
-        case "in-process":
+        case "none":
         case "host":
         case "ssh":
         case "adb":
@@ -183,12 +183,11 @@ export function laneSandboxReadFloorState(deployment) {
             return undefined;
     }
 }
-export const ALL_EXECUTION_LANES = Object.freeze(["in-process", ...DECLARABLE_LANE_WORDS]);
+export const ALL_EXECUTION_LANES = Object.freeze([...DECLARABLE_LANE_WORDS]);
 const EXECUTION_LANE_SET = new Set(ALL_EXECUTION_LANES);
 export function isExecutionLane(word) {
     return EXECUTION_LANE_SET.has(word);
 }
-export const REMOTE_EXEC_PROVIDER_WORDS = Object.freeze([...DECLARABLE_LANE_WORDS]);
 const LANE_ROWS = (() => {
     const rows = new Map();
     for (const row of EXECUTION_LANES) {
@@ -217,53 +216,48 @@ export function isBlankRequiredEnvValue(value) {
 export function laneMissingEnv(lane, env) {
     return laneRequiredEnv(lane).filter((name) => isBlankRequiredEnvValue(env[name]));
 }
+const LANE_ROW_OF_WORD = LANE_ROWS;
+function laneSetFlawPhrase(flaw) {
+    switch (flaw.kind) {
+        case "empty_set":
+            return "it has no entries";
+        case "blank_entry":
+            return `entry ${flaw.at + 1} is empty or whitespace-only`;
+        case "unknown":
+            return `"${String(flaw.word)}" (entry ${flaw.at + 1}) is not an execution lane`;
+        case "retired":
+            return retiredLaneWordRefusal(flaw.word) ?? `"${flaw.word}" (entry ${flaw.at + 1}) is a retired execution lane`;
+        case "duplicate":
+            return `"${flaw.lane}" is listed twice (again at entry ${flaw.at + 1})`;
+        case "not_alone":
+            return `"${flaw.lane}" (no execution environment for the agent's tools) must be the only entry`;
+    }
+}
 export function readDeclaredLaneTable(raw) {
     const segments = raw.split(",");
-    const lanes = [];
-    for (const [i, segment] of segments.entries()) {
-        if (segment === "") {
-            return { refusal: `REMOTE_EXEC="${raw}" has an empty entry at position ${i + 1} — it is an ordered, comma-separated list of execution lanes (the first is the default) with no blank entries; valid lanes: ${REMOTE_EXEC_PROVIDER_WORDS.join(" | ")}.` };
-        }
-        const lane = REMOTE_EXEC_PROVIDER_WORDS.find((w) => w === segment);
-        const retired = lane === undefined ? retiredLaneWordRefusal(segment) : undefined;
-        if (retired !== undefined)
-            return { refusal: `REMOTE_EXEC="${raw}": ${retired}.` };
-        if (lane === undefined) {
-            return {
-                refusal: `REMOTE_EXEC="${raw}"${segments.length > 1 ? ` lists "${segment}", which` : ""} is not an execution lane — valid: ${REMOTE_EXEC_PROVIDER_WORDS.join(" | ")}. ` +
-                    `An unrecognized value used to fall through to the host/in-process lane silently; refusing to start instead (#157).`,
-            };
-        }
-        if (lanes.includes(lane))
-            return { refusal: `REMOTE_EXEC="${raw}" lists "${lane}" twice — each execution lane appears once (the first one is the default).` };
-        lanes.push(lane);
+    const flaws = laneSetFlaws(segments);
+    if (flaws.length > 0) {
+        return {
+            refusal: `REMOTE_EXEC="${raw}" is not a valid execution lane set: ${flaws.map(laneSetFlawPhrase).join("; ")}. ` +
+                `REMOTE_EXEC (the lane set, comma-separated) ${LANE_SET_RULE}. Refusing to start rather than guessing a lane (#157).`,
+        };
     }
+    const lanes = segments.map((segment) => {
+        const row = LANE_ROW_OF_WORD.get(segment);
+        if (row === undefined)
+            throw new Error(`readDeclaredLaneTable: the lane-set judge accepted "${segment}" but the lane table has no row for it`);
+        return row.lane;
+    });
     const [first, ...rest] = lanes;
     if (first === undefined)
         throw new Error(`readDeclaredLaneTable: "${raw}" split into no segments`);
     return { lanes: [first, ...rest] };
 }
-export function executionLaneRequiredRefusal(deployment) {
-    if (!deployment.requireExecutionLane || executionLaneOf(deployment.remoteExec?.provider) !== "in-process")
-        return undefined;
-    return (`REQUIRE_EXECUTION_LANE=true but NO execution lane is named on this deployment — refusing to start. ` +
-        `With no lane the engine falls back to its in-process stub environment: the hands band (the roster entries whose ` +
-        `wiring_manifest mountedBy is "hands", Bash among them) is not mounted, while the rest of the roster still executes, ` +
-        `and every task still returns status=completed — for any request that needs a hand, indistinguishable from "the model ` +
-        `chose not to use its tools". (How much of the roster is mounted is a per-run fact: read the wiring_manifest event and ` +
-        `count entries whose mountedBy is "hands" — never judge by tool names.) ` +
-        `Cause: REMOTE_EXEC is unset/empty AND CONFIG_PROVIDER is not "local". ` +
-        `Fix: set REMOTE_EXEC to one of ${REMOTE_EXEC_PROVIDER_WORDS.join(" | ")} (and that lane's required env), ` +
-        `or set CONFIG_PROVIDER=local to take the single-machine \`host\` default, ` +
-        `or unset REQUIRE_EXECUTION_LANE to keep running without hands on purpose.`);
-}
 export function executionLaneOf(provider) {
-    if (provider === undefined)
-        return "in-process";
     return isExecutionLane(provider) ? provider : undefined;
 }
 export function deployedExecutionLanes(config) {
-    return [executionLaneOf(config.remoteExec?.provider)];
+    return [config.remoteExec.provider];
 }
 export function handsOnWorkerFilePlane(lane) {
     const block = laneBlock(lane, NO_SUB_KNOBS);
@@ -273,7 +267,7 @@ export function laneBindsReads(lane) {
     switch (lane) {
         case "host":
             return true;
-        case "in-process":
+        case "none":
         case "e2b":
         case "k8s":
         case "ssh":
@@ -293,7 +287,7 @@ export function laneMeasuresHome(lane) {
         case "host":
             return true;
         case "device":
-        case "in-process":
+        case "none":
             return false;
     }
 }
@@ -304,7 +298,7 @@ export function laneReadFaceDefault(lane) {
         case "local-docker":
             return "open";
         case "host":
-        case "in-process":
+        case "none":
         case "ssh":
         case "adb":
         case "device":
@@ -324,11 +318,8 @@ export function executionLaneHomeDir(deployment) {
     const declared = deployment.remoteExecHomeDir;
     if (declared !== undefined)
         return declared;
-    const lane = executionLaneOf(deployment.remoteExec?.provider);
-    if (lane === undefined)
-        return undefined;
-    switch (lane) {
-        case "in-process":
+    switch (deployment.remoteExec.provider) {
+        case "none":
         case "host":
             return homedir();
         case "e2b":
@@ -348,23 +339,22 @@ export function buildLaneHomeClaim(deployment) {
     return { homeDir: home, homeDirSource: deployment.remoteExecHomeDir !== undefined ? "declared" : "lane" };
 }
 export function buildLaneHomeBootNote(deployment) {
-    const lane = executionLaneOf(deployment.remoteExec?.provider);
-    if (lane === undefined || !laneWiresExecutionEnv(lane))
+    const homeLane = deployment.remoteExec.provider;
+    if (!laneWiresExecutionEnv(homeLane))
         return undefined;
-    if (laneMeasuresHome(lane))
+    if (laneMeasuresHome(homeLane))
         return undefined;
     const home = executionLaneHomeDir(deployment);
     if (home === undefined)
-        return { event: LANE_HOME_UNDECLARED_EVENT, note: buildHomeAbsentNote(lane, "REMOTE_EXEC_HOME_DIR is unset, and this lane cannot read its execution environment's home", DECLARE_HOME_REMEDY) };
-    return { event: LANE_HOME_UNMEASURED_EVENT, note: buildHomeUnmeasuredNote(lane, home) };
+        return { event: LANE_HOME_UNDECLARED_EVENT, note: buildHomeAbsentNote(homeLane, "REMOTE_EXEC_HOME_DIR is unset, and this lane cannot read its execution environment's home", DECLARE_HOME_REMEDY) };
+    return { event: LANE_HOME_UNMEASURED_EVENT, note: buildHomeUnmeasuredNote(homeLane, home) };
 }
 export function buildReadDenyFloorUnkeptNote(deployment) {
     if (!deployment.readDenyFloorRequired)
         return undefined;
     if (capabilitiesFor(deployment)?.keepsReadFloor === true)
         return undefined;
-    const lane = executionLaneOf(deployment.remoteExec?.provider) ?? String(deployment.remoteExec?.provider);
-    return (`READ_DENY_FLOOR_REQUIRED=true, but the "${lane}" execution lane does not keep the read-deny byte floor (a program its commands run can open a path ` +
+    return (`READ_DENY_FLOOR_REQUIRED=true, but the "${deployment.remoteExec.provider}" execution lane does not keep the read-deny byte floor (a program its commands run can open a path ` +
         `the read-deny table refuses). Every run whose read-deny table has rows — the shipped default tiers put rows there unless READ_DENY_BUILTIN_TIERS=none — ` +
         `is refused before any command starts (config.read_deny_floor_unkept; a synchronous submit answers 409). ` +
         `Either run on a lane that keeps the floor, or unset READ_DENY_FLOOR_REQUIRED to run with one operator notice per run instead.`);