@sema-agent/server 7.146.0 → 7.148.0

package/dist/env-facts.js

@@ -1,5 +1,7 @@
+import { writeLogText } from "./observability/logger.js";
 import { isAbsolute, join, resolve, sep } from "node:path";
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { ensureDir } from "@sema-agent/core";
 import { createHash } from "node:crypto";
 import { isAbsoluteHostPath } from "@sema-agent/settings-schema";
 import { dirCoversPath, normalizeAbsolutePathLexically } from "./task-cwd.js";
@@ -41,7 +43,7 @@ export function resumeFactsForLane(provider, caps) {
         case "device":
             return { scratch: "preserved" };
         case "host":
-        case undefined:
+        case "none":
             return { scratch: "preserved" };
         case "local-docker":
             return undefined;
@@ -57,7 +59,10 @@ export function scratchpadSessionSegment(sessionId) {
     return `${cleaned.length > 0 ? cleaned : "_"}-${digest}`;
 }
 export function scratchpadDirFor(localDataRoot, sessionId) {
-    return join(localDataRoot, "scratchpad", scratchpadSessionSegment(sessionId));
+    return join(scratchpadRootFor(localDataRoot), scratchpadSessionSegment(sessionId));
+}
+export function scratchpadRootFor(localDataRoot) {
+    return join(localDataRoot, "scratchpad");
 }
 export async function ensureScratchpadDir(localDataRoot, sessionId, warn) {
     const dir = scratchpadDirFor(localDataRoot, sessionId);
@@ -71,7 +76,7 @@ export async function ensureScratchpadDir(localDataRoot, sessionId, warn) {
         return undefined;
     }
     try {
-        await mkdir(dir, { recursive: true });
+        ensureDir(dir);
         return dir;
     }
     catch {
@@ -143,11 +148,11 @@ export async function purgeScratchpadDir(localDataRoot, sessionId) {
         await rm(dir, { recursive: true, force: true });
     }
     catch (err) {
-        console.warn(`scratchpad_purge_failed dir=${dir}: ${err instanceof Error ? err.message : String(err)}`);
+        writeLogText("stderr", `scratchpad_purge_failed dir=${dir}: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 export async function sweepStaleScratchpads(localDataRoot, opts) {
-    const root = join(localDataRoot, "scratchpad");
+    const root = scratchpadRootFor(localDataRoot);
     let names;
     try {
         names = await readdir(root);
@@ -175,9 +180,9 @@ export async function sweepStaleScratchpads(localDataRoot, opts) {
     return removed;
 }
 export function egressForRemoteExec(remoteExec) {
-    if (remoteExec?.provider === "e2b")
+    if (remoteExec.provider === "e2b")
         return remoteExec.allowInternetAccess === false ? "none" : "full";
-    if (remoteExec?.provider === "k8s")
+    if (remoteExec.provider === "k8s")
         return "full";
     return undefined;
 }

package/dist/env-witness.d.ts

@@ -0,0 +1,7 @@
+/** 出口座登记「这条 run 的环境一旦留下持久物就告诉我」;交回注销口(只注销自己登记的那一只)。 */
+export declare function listenEnvWitness(runId: string, onWitness: () => void): () => void;
+/** 环境留下了按会话键的持久物(run id 缺席 = 子 run / 服务自起的 run,不属任何提交 ⇒ 无事)。 */
+export declare function witnessEnv(runId: string | undefined): void;
+/** 在听的座数(测试读:收场后归零 = 不积累)。 */
+export declare function envWitnessListeners(): number;
+//# sourceMappingURL=env-witness.d.ts.map

package/dist/env-witness.js

@@ -0,0 +1,16 @@
+const listening = new Map();
+export function listenEnvWitness(runId, onWitness) {
+    listening.set(runId, onWitness);
+    return () => {
+        if (listening.get(runId) === onWitness)
+            listening.delete(runId);
+    };
+}
+export function witnessEnv(runId) {
+    if (runId !== undefined)
+        listening.get(runId)?.();
+}
+export function envWitnessListeners() {
+    return listening.size;
+}
+//# sourceMappingURL=env-witness.js.map

package/dist/execution-config-root.d.ts

@@ -1,16 +1,16 @@
-import { type LaneHomeDeployment, type RemoteExecProvider } from "./execution-lane-caps.js";
+import { type ExecutionLane, type LaneHomeDeployment } from "./execution-lane-caps.js";
 /** 选中车道转进沙箱的 env 那一座(`ServiceConfig.remoteExec` 的判别联合每一臂结构上都满足:e2b / k8s 的 `sandboxEnv`、local-docker 的 `env`,别的臂两键都没有)。 */
 export interface SandboxEnvSeat {
-    readonly remoteExec?: {
-        readonly provider: RemoteExecProvider;
+    readonly remoteExec: {
+        readonly provider: ExecutionLane;
         readonly sandboxEnv?: Readonly<Record<string, string>> | undefined;
         readonly env?: Readonly<Record<string, string>> | undefined;
-    } | undefined;
+    };
 }
 /** 求配置根要读的部署事实(`ServiceConfig` 结构上满足;存体预判的问点传活配置整份)。 */
 export interface ExecutionConfigRootDeployment extends LaneHomeDeployment, SandboxEnvSeat {
     readonly agentConfigDir?: string;
-    readonly remoteExec?: SandboxEnvSeat["remoteExec"];
+    readonly remoteExec: SandboxEnvSeat["remoteExec"];
 }
 /**
  * 被选中的沙箱车道上运维点名转进沙箱的 env(e2b / k8s 的 `sandboxEnv`、local-docker 的 `env` —— 名单型旋钮经 `allowlistedEnv` 取的原值);

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

@@ -3,14 +3,12 @@ import { type ExecutionLane as DeclarableLane, type ExecutionLaneRow } from "@se
 import type { ServiceConfigFlat } from "./config-types.js";
 import { type LaneHomeConfig } from "./lane-home-probe.js";
 /** 一位能力的三态。`single-user-only` = 车道支持,但只在单用户部署(`requirePrincipal !== true`)开 ——
- *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell/LSP 都是这一档,理由同源:
+ *  多租户下这一位必须关(host 家族的 cwd/scheduler/backgroundShell 都是这一档,理由同源 —— 本机语言服务器同理由,答者是部署形行 `callerOwnsWorkerDisk`:
  *  一个租户的输入不许把 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 能力位。每一位的注里点名**今天真正做判决的那处代码**——对账测试按这些坐标跑真函数,
  * 所以坐标漂了(重命名/搬家/改语义)门会红,注释不会烂在这里。
@@ -25,9 +23,7 @@ export interface ExecutionLaneCaps {
     /** 自唤醒 scheduler(`CronCreate`/…)。判别式:`boot/execution-env.ts` host 臂的 `hostScheduler`
      *  与 `http/routes/capabilities.ts` 的 `scheduler` 位(两处同判据)。 */
     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 +33,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`
@@ -61,8 +56,8 @@ export interface ExecutionLaneCaps {
  *    绑定验证),故不要求单用户。(部署形表行 `callerCwd` 直接读本位。)
  *  · `remoteScratchpad: supported` —— executor 平台闭集 = darwin|linux,`/tmp/scratchpad/<sessionId>`
  *    的惰性 mkdir 约定原样适用;不加词则 scratchpad envFact 对模型整块缺席。
- *  · scheduler / backgroundShell / lsp / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
- *    (不是遗漏:设备侧长驻进程、LSP sidecar、直传腿都是 follow-on,声明了就是谎)。
+ *  · scheduler / backgroundShell / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
+ *    (不是遗漏:设备侧长驻进程、直传腿都是 follow-on,声明了就是谎)。
  */
 export declare function executionLaneCaps(lane: ExecutionLane): ExecutionLaneCaps;
 /** 读地板旋钮的 env 名(拒起句与起服行点名它)。 */
@@ -88,16 +83,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 +100,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 +114,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 +130,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,90 +144,51 @@ 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] ③)。
+ * 一个**开放字符串**(外部输入、手搓的部署形)→ 车道词;认不出 ⇒ `undefined`,**调用方必须 fail-closed**(禁静默按某个默认车道处理)。
+ * 没有缺席入参:「没声明车道」只在执行车道合成步判一次(拒启),合成之后的配置型上 `remoteExec` 必在、`provider` 就是车道词 ——
+ * 读已合成配置的消费点直读 `config.remoteExec.provider`,不经本函数、不写兜底(门 `test/execution-lane-fold-ban.test.ts`:任何读者都不许把缺席 /
+ * 认不出折成某条车道)。闭集重载喂车道词 ⇒ 返回型无 `undefined`(成立依据是**构造**的:{@link isExecutionLane} 的集合就是由正本元组建成)。
  */
-export declare function executionLaneRequiredRefusal(deployment: {
-    readonly requireExecutionLane: boolean;
-    readonly remoteExec?: ServiceConfigFlat["remoteExec"];
-}): string | undefined;
+export declare function executionLaneOf(provider: ExecutionLane): ExecutionLane;
+export declare function executionLaneOf(provider: string): ExecutionLane | 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` 恒真(对账格逐词跑过)。
- */
-export declare function executionLaneOf(provider: RemoteExecProvider | undefined): ExecutionLane;
-export declare function executionLaneOf(provider: string | undefined): 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"`:
  *  ① 部署形表行 `toolsOnThisHost`(`deployment-shape.ts`)—— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
- *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针;
+ *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针、
+ *     本机语言服务器(`createLspManager`;这类车道的适配器必须绑得住读 `openBound`,对拍钉 `test/host-env-open-bound.test.ts`);
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生(它手里已有车道词,直接读本列)。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
-/**
- * core 7.50.0 —— 「这条车道的执行环境能不能把一次读**绑到判过的那只对象**上」(`FileSystem.openBound`:开着并持有,叶链接不跟,
- * 开后身份对拍)。LSP 会话的读口与路径附件只经它读;环境不实现 ⇒ 那两个读口在这条车道上一律拒。
- *
- * **一条律**:LSP 只在本谓词为真的车道挂(`boot/execution-env.ts` 的 LSP 管理器两臂都合取它;表的 `lsp` 位与之同向,
- * 对拍钉 `test/host-env-open-bound.test.ts`:本谓词 ⟺ 适配器类原型上有 `openBound`)。
- *  · `host` —— `RemoteHostExecutionEnv.openBound` 委托 core `NodeExecutionEnv` 的实现(唯一属主),真;
- *  · `in-process` —— 没有手(core 落桩环境),无物可绑;
- *  · 其余车道(沙箱 / 远端 shell / 设备)—— 读走 exec / sftp / 设备协议,本版不实现绑定读,假。实现之日翻这一格,LSP 沙箱桥随之回来。
- * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
- */
-export declare function laneBindsReads(lane: ExecutionLane): boolean;
 /**
  * 「这条车道的执行环境**自己读得出家目录**」—— 读得出 ⇒ 读数是真源:适配器持一只 `LaneHomeSeat`(取值律与座的唯一属主 = `lane-home-probe.ts`),
  * 部署给的主张({@link buildLaneHomeClaim})在每只环境开起来时被证,不一致 ⇒ 那只环境不开;没有主张 ⇒ 读数填 `ExecutionEnv.homeDir` 的座。
@@ -247,7 +197,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 +207,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 +223,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 +266,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 +294,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 +319,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 +332,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 才知道。
  */