@sema-agent/server 7.139.0 → 7.140.0

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

@@ -1,5 +1,7 @@
+import { type ExecutionEnvCapabilities } from "@sema-agent/core";
 import { type ExecutionLane as DeclarableLane, type ExecutionLaneRow } from "@sema-agent/settings-schema/execution-lanes";
 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 都是这一档,理由同源:
  *  一个租户的输入不许把 agent 指向 worker 宿主上另一个租户/运维的文件与进程)。 */
@@ -14,7 +16,7 @@ export type ExecutionLane = "in-process" | RemoteExecProvider;
  * 所以坐标漂了(重命名/搬家/改语义)门会红,注释不会烂在这里。
  */
 export interface ExecutionLaneCaps {
-    /** 调用方送来的 `cwd` 是否被尊重。读者:部署形表行 `callerCwd`([ref] 起本位即判据;改前对账 `task-cwd.ts` 的 `cwdHonored || deviceCwdHonored`)。 */
+    /** 调用方送来的 `cwd` 是否被尊重。读者:部署形表行 `callerCwd`(本位即判据;改前对账 `task-cwd.ts` 的 `cwdHonored || deviceCwdHonored`)。 */
     readonly callerCwd: LaneCapability;
     /** core 的后台 shell 面(`run_in_background`/`BashOutput`/`KillShell`)。判别式:各 adapter 的
      *  `backgroundCapabilities.supported`(`plugins/remote-env-{host,e2b,k8s}.ts`);host 腿的闸在
@@ -26,96 +28,67 @@ export interface ExecutionLaneCaps {
     /** LSP。判别式:`boot/execution-env.ts` 的 `lspManager` 两臂(沙箱桥 e2b/k8s;host 本地 NodeLspManager)。 */
     readonly lsp: LaneCapability;
     /** SendUserFile 的**沙箱直传腿**(host/in-process 的本机 fs 源是另一条腿,不是本位)。
-     *  读者:部署形表行 `sandboxSendUserFile`([ref] 起本位即判据;判定依据在 `capabilities/sandbox-file-send.ts` 头注)。 */
+     *  读者:部署形表行 `sandboxSendUserFile`(本位即判据;判定依据在 `capabilities/sandbox-file-send.ts` 头注)。 */
     readonly sandboxSendUserFile: LaneCapability;
-    /**
-     * OS 级隔离边界(手跑在容器 / microVM / Kata pod 里,而不是一台真机上)。
-     * 🔴 [ref] 起**本位即判别式**:全仓读它的唯一布尔口是 {@link laneIsolated}(boot `remote_exec_enabled.isolated` 与
-     * `remote_exec_real_system` 那一行、`config.d/remote-exec.json` 抢占披露的「隔离降级」判、wire `executionLane.isolated`
-     * + 诊断面同位、那一行 note 列的沙箱出路 —— 改前 boot 另手写一份 `e2b || k8s || local-docker`,与本表两处各算)。
-     * 本位的**独立作者** = 各 adapter 对 core 的 `capabilities.isolation` 声明:对账测试拿 core 自己的严格读器 `isIsolated`
-     * 问每条车道的**真 adapter 实例**,与本表、与 boot 行三方对拍。
-     * 型上**没有** `single-user-only` 这一档(隔离是车道的结构事实,不随租户面变)⇒ {@link laneIsolated} 的布尔化是穷举、无兜底。
-     * ⚠️ 口径 = **OS 级边界**(容器即算:共享宿主内核的 `local-docker`、runc 上的 k8s pod 都答 supported),**不是**「独立内核」强度。
-     * VM 级强度(独立内核:只认 e2b 与 k8s 的 kata / gvisor 运行时,runc / local-docker fail-closed 判否)是**另一个问题、另一个词**:
-     * 部署形表行 `vmIsolatedHands`(A 值路由读它,路由上下文键 `vmIsolatedExecEnv`;[ref] 拆开同词异义)—— 不是本位的第二份。
-     */
-    readonly isolation: Exclude<LaneCapability, "single-user-only">;
-    /** 可挂起(k8s 以配了 `s3Snapshot` 为前提 —— 「结构上能不能」的口径)。读者:部署形表行 `suspendableHands`(本位 ∧ k8s 快照店;
-     *  [ref] 起 boot `remote_exec_enabled.suspendable` 只读那一行,不再手写车道词)。独立作者 = 各适配器的 `capabilities.suspendable`。 */
-    readonly suspendable: LaneCapability;
-    /** `/tmp/scratchpad/<sessionId>` 远端约定。读者:部署形表行 `remoteScratchpad`([ref] 起本位即判据;改前对账 `isRemoteScratchpadLane` 的 Set)。 */
+    /** `/tmp/scratchpad/<sessionId>` 远端约定。读者:部署形表行 `remoteScratchpad`(本位即判据;改前对账 `isRemoteScratchpadLane` 的 Set)。 */
     readonly remoteScratchpad: LaneCapability;
-    /** 写门走 [ref] 的 `DeferredSandboxPathEnv` 代理裁决(而不是直接拿 worker 本机 fs 裁)。
-     *  判别式:部署形表行 `sandboxPathAdjudication`(读 `hostFilePlane` 的反面;对账钉逼本位与它同值)。 */
-    readonly sandboxPathAdjudication: LaneCapability;
     /** git-worktree 隔离。判别式:`boot/execution-env.ts` 的 host 臂 vs `worktree_isolation_unsupported_lane` warn。 */
     readonly worktreeIsolation: LaneCapability;
-    /** 记忆持久面的**自动**表态(部署可用 `MEMORY_PERSISTENCE_CAPABLE` 显式覆盖,那是旋钮不是车道位)。
-     *  判别式:`boot/memory-boundary.ts` 的 `effectiveMemoryPersistenceCapable`。 */
-    readonly memoryPersistenceCapable: LaneCapability;
-    /** 文件平面是否就在 worker 本机(= `hostSemanticsLane`)。🔴 [ref] 起**消费点读本位**,不再各写判别式
-     *  (改前 `resolve-spec` / `stores` / `memory-scope` / `deferred-sandbox-path-env` 各写一份
-     *  `lane === undefined || lane === "host"` 的同义形,分叉过就是记忆边界判错盘)。读本位的真装配点:
-     *  部署形表行 `sandboxPathAdjudication`(resolve-spec 写门 / parked 赎回腿 /
-     *  执行环境装配三处的唯一属主)、`memory-scope.ts` 的 `memoryEngineRemoteLanePosture`、
-     *  `boot/memory-boundary.ts` 的 `buildMemoryBoundaryLaneFacts`(stores)。(「本会话没有持久记忆」的披露归引擎判、引擎渲染 ——
-     *  目录条目 `core/memory.no-persistent-store`,本仓只交 spec 上的事实,不再读本位做判别。)⚠️ `in-process` 在本位上是 YES(hooks/进程内读确实在本机盘上),
-     *  但它**没有手** —— 问「手在不在本机盘上」要读 {@link handsOnWorkerFilePlane},不是只读本位。 */
-    readonly hostFilePlane: LaneCapability;
-    /** core 的 `isRemoteExecutionEnv` 对本车道的判决(鸭子类型,**含 host**)= core 拿没拿到执行环境 = 手带挂没挂。
-     *  5.26.0 起它决定 `# Memory` 写指令撤不撤。🔴 [ref] 起消费点读本位(改前各写 `config.remoteExec !== undefined`);
-     *  对账测试拿 core 自己的 `isRemoteExecutionEnv` 问**真 adapter 实例**来核本位的值。 */
-    readonly coreRemoteExecutionEnv: LaneCapability;
-    /**
-     * [ref] / core 7.20.0([ref]):这条车道的适配器**声明**了 `capabilities.canonicalPathAuthoritative`
-     * 没有 —— 即「我的 `canonicalPath` 是路径落点的权威,整链答不出来是解析器出了事,不是一个我看不见的
-     * 命名空间」。声明 ⇒ 读边界的执行期复核在解析器沉默时**拒**;缺席 ⇒ 今天每个适配器的读法(词法判决
-     * 成立、命令照跑)—— **缺席不是「声明为 false」**,所以这一位的 `unsupported` 读作「本车道没表态」。
-     *
-     * 判别式:各 adapter 的 `capabilities` 字面量(`plugins/remote-env-{host,ssh,adb,k8s,device,e2b,local-docker}.ts`),
-     * 由 core 的严格读器 `canonicalPathIsAuthoritative(env)` 读;对账测试逐 lane 拿**真 adapter 实例**问它。
-     * 本位存在的理由 = 让「新车道/新适配器不表态」变成**编译红**(穷举 switch 少一行即 tsc 红),而不是
-     * 静默继承一个没人表过态的缺席。
-     */
-    readonly canonicalPathAuthority: LaneCapability;
     /**
-     * 车PI 修复轮 ②([ref] / clay C-R91A ②,主会话裁「按表不按词」;裁定语义 = **租户不共宿主**)—— 这条车道**分不分租户**。
+     * 这条车道**分不分租户**(裁定语义 = **租户不共宿主**)。
      *  · `supported` = 每个租户的命令落在各自的目标上(每任务一只沙箱:e2b / k8s / local-docker;发起者自己的设备:device,
      *    归属由 deviceId↔principal 绑定验过),或根本没有手(in-process:没有可共享的执行目标);
      *  · `single-user-only` = 所有任务落在**同一个共享目标**上(worker 宿主:host;一台常驻 SSH 对端:ssh;一台 ADB 设备:adb)
      *    ⇒ 只许单用户部署用。
      * 本位**没有** `unsupported` 这一档(那会读成「谁都不许用」,不是车道事实)—— 型上收窄掉,每条车道必须在两档里表态。
-     * 🔴 **7.114.0 起本位的值不在本仓写**:七条可声明车道读 settings-schema 词表正本的表行(`executionLaneRow(lane).tenantSeparation`;
+     * 🔴 **本位的值不在本仓写**:七条可声明车道读 settings-schema 词表正本的表行(`executionLaneRow(lane).tenantSeparation`;
      * 中心写闸的 `requirePrincipal ∧ single-user-only` 交叉判与本仓 `multi-tenant-shared-lane` 拒启读的是同一个值,不会分叉);
      * 只有 `in-process` 一格是本仓自己的事实(它不在表里)。
      * 唯一消费点是 `config-invariants.ts` 的 `multi-tenant-shared-lane`(经部署形表行 `laneSeparatesTenants` 落成布尔)。本位值与本仓**运行期事实**
-     * 不矛盾的对账 = `test/execution-lanes-schema-conformance.test.ts`(隔离位 / 共享文件平面 ⇒ 租户档的蕴含 + 唯一一条「不隔离却分租户」
+     * 不矛盾的对账 = `test/execution-lanes-schema-conformance.test.ts`(执行环境块的隔离位 / 路径是不是本机的 ⇒ 租户档的蕴含 + 唯一一条「不隔离却分租户」
      * 的车道 = device 点名);ssh / adb 「两租户同一目标」的行为预言机 = `test/multi-tenant-shared-lane.test.ts`
      * (两个租户的任务铸出的 env 报同一个 `workspaceHandle().sandboxId`)。
      */
     readonly tenantSeparation: Exclude<LaneCapability, "unsupported">;
 }
 /**
- * per-lane 能力表。**穷举 switch,禁 default 臂**(hands-lane.ts:39-46 先例)。
+ * per-lane 能力表。**穷举 switch,禁 default 臂**(hands-lane.ts:39-46 先例)。执行环境自己的能力(隔离 / 可挂起 / 路径是不是本机的 / 有没有手 …)
+ * 不在这张表上 —— 它们是引擎能力块,唯一作者 {@link capabilitiesFor}。
  *
  * device 行的表态来自 v2 §4.1/§4.3:
  *  · `callerCwd: supported` —— 员工在自己设备的项目目录里干活是这条车道的**存在理由**;host 闸防的
  *    「跨租户宿主路径穿越」在此结构性不存在(路径落在发起者自己的设备上,归属已由 deviceId↔principal
- *    绑定验证),故不要求单用户。(车A-4 前判别式答 false、登记过 {@link PLANNED_LANE_DIVERGENCES},已销行;[ref] 起部署形表行 `callerCwd` 直接读本位。)
- *  · `sandboxPathAdjudication: supported` —— 自动判真且**这是深思后的正确默认**:写门经 [ref] 代理把四读
- *    原语转发到设备取真文件系统事实,云盘永不参与设备写目标的裁决。
+ *    绑定验证),故不要求单用户。(部署形表行 `callerCwd` 直接读本位。)
  *  · `remoteScratchpad: supported` —— executor 平台闭集 = darwin|linux,`/tmp/scratchpad/<sessionId>`
  *    的惰性 mkdir 约定原样适用;不加词则 scratchpad envFact 对模型整块缺席。
  *  · scheduler / backgroundShell / lsp / sandboxSendUserFile / worktreeIsolation = v1 **诚实关闭**
  *    (不是遗漏:设备侧长驻进程、LSP sidecar、直传腿都是 follow-on,声明了就是谎)。
- *  · `isolation`/`suspendable` = false/false —— 真设备,不隔离不可快照(与 ssh/adb 同宣告);
- *    `suspendable:false` 在 core 契约里同时断言「工作区在目标上外部持久」,员工机磁盘满足,park-only
- *    赎回腿因此合法。
- *  · `memoryPersistenceCapable: unsupported` —— 设备的手够不着云 SQL 记忆店,默认撤 `# Memory` 写指令
- *    恰是诚实形(§4.3.4)。
  */
 export declare function executionLaneCaps(lane: ExecutionLane): ExecutionLaneCaps;
+/** {@link capabilitiesFor} 读的部署配置:已装配的 `remoteExec` 里决定块的两键(`ServiceConfig` 的判别联合每一臂结构上都满足)。 */
+export interface CapabilitiesDeployment {
+    readonly remoteExec?: {
+        readonly provider?: string | undefined;
+        readonly s3Snapshot?: unknown;
+    } | undefined;
+}
+/**
+ * 「这份部署上 run 所在的执行环境能做什么」—— 引擎能力块(八键)的**唯一作者**。
+ *
+ * 七只适配器的 `capabilities` 由它铸(适配器源码里没有能力字面量);`in-process` 答引擎桩环境的块。读者读块,不另存一位:
+ * 起服行 `remote_exec_enabled`(`isolated` / `suspendable` / `keepsReadFloor`)、部署形表行 `sandboxPathAdjudication` / `suspendableHands`、
+ * {@link laneIsolated} / {@link laneWiresExecutionEnv} / {@link handsOnWorkerFilePlane}、记忆边界审计的文件平面位。改一条车道的能力 = 改本函数一处,
+ * 适配器、行、起服行、wire 同翻(门 `test/execution-env-capabilities-one-source.test.ts`)。
+ *
+ * 认不出的车道词 ⇒ `undefined`(调用方 fail-closed;生产链上不可达,`loadConfig` 先拒启)。两个重载同 {@link executionLaneOf}:喂已装配的车道词 ⇒ 返回型无 `undefined`。
+ */
+export declare function capabilitiesFor(deployment: {
+    readonly remoteExec?: {
+        readonly provider: RemoteExecProvider;
+        readonly s3Snapshot?: unknown;
+    } | undefined;
+}): ExecutionEnvCapabilities;
+export declare function capabilitiesFor(deployment: CapabilitiesDeployment): ExecutionEnvCapabilities | undefined;
 /**
  * 车道普查全集 = 本仓内部状态名 `in-process` + 词表正本的可声明车道(次序 = 正本声明序;对账测试按它逐 lane 跑真判别式)。
  * 由正本派生、不手维护(手维护的「全表」已被代码反证漏过行)。
@@ -141,7 +114,7 @@ export declare function executionLaneRow(lane: RemoteExecProvider): ExecutionLan
 export declare function laneRequiredEnv(lane: RemoteExecProvider): readonly string[];
 /**
  * 一个必需 env 的值**算不算缺**的唯一判官 —— 两半各有归属:
- *  · **空白半边**(空串、只含空白)归契约包:包根导出的 `isBlankCoordinate` 是这件事唯一的实现,契约包的写闸(车道声明保存时)问的是同一只函数,本仓不另抄一份;
+ *  · **空白半边**(空串、只含空白)归契约包:`isBlankCoordinate`(函数体住在 `execution-lanes` 叶模块,包根转口同一个函数对象)是这件事唯一的实现,契约包的写闸(车道声明保存时)问的是同一只函数,本仓不另抄一份;
  *  · **未设半边**(`undefined`)归本仓:契约包的判官只收字符串,「这一键根本没设」由调用方先判,所以这一臂留在这里。
  * 合起来:`undefined`、空串、只含空白一律按缺 —— 引擎把空值读成未设,纯空白拼进坐标(镜像名、命名空间、主机名)也只会在第一次用的时候才失败。
  * 所有车道、所有必需键同判一只,没有「某个键另有一套缺席 / 空白判法」。
@@ -195,18 +168,14 @@ export declare function executionLaneOf(provider: string | undefined): Execution
  */
 export declare function deployedExecutionLanes(config: Pick<ServiceConfigFlat, "remoteExec">): readonly ExecutionLane[];
 /**
- * [ref] —— 「这条车道的**手**就在本 worker 的盘上吗」。**两位合取,都读表**(不手抄):
- *  · `coreRemoteExecutionEnv` —— core 拿到了执行环境 = 手带真挂上(`in-process` 答 NO:core 落 `StubExecutionEnv`);
- *  · `hostFilePlane` —— 那套手的文件平面就是本 worker 的盘(沙箱 / 远端 / 设备车道答 NO)。
- * 今天只有 `host` 两位同 YES。
+ * 「这条车道的**手**就在本 worker 的盘上吗」= 块 `io ∧ hostLocalPaths`(读 {@link capabilitiesFor} 的块,不手抄)。今天只有 `host` 两键同真。
  *
- * 🔴 **只读 `hostFilePlane` 是错的**:`in-process` 那一位是 YES(hooks / 进程内读确实在本机盘上),而它
- * **没有手**。clay 裁 [ref] ③ 的字面写「判据读 `hostFilePlane`」,意图是同一句的「无手不挂」—— 照字面
- * 实现会让无手部署**继续**挂 SendUserFile,与意图相反;本函数按意图实现(收车档 che-MA 写明)。
+ * 🔴 **只读 `hostLocalPaths` 是错的**:`in-process` 的桩块那一键是 true(进程内读确实在本机盘上),而它**没有手**(`io: false`)——
+ * 只读一键会让无手部署**继续**挂 SendUserFile,与「无手不挂」的意图相反。
  *
  * 读者问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
  *  ① 部署形表行 `toolsOnThisHost`(`deployment-shape.ts`)—— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
- *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿([ref] ③「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针;
+ *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿(「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针;
  *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生(它手里已有车道词,直接读本列)。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
@@ -223,13 +192,15 @@ export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
  */
 export declare function laneBindsReads(lane: ExecutionLane): boolean;
 /**
- * 「这条车道的执行环境**自己读得出家目录**」—— 没声明 `REMOTE_EXEC_HOME_DIR` 时,车道建环境那一拍问一次执行环境的 `$HOME` 填 `ExecutionEnv.homeDir` 的座
- * (取值律与座的唯一属主 = `lane-home-probe.ts` 的 `LaneHomeSeat`)。
- *  · `k8s` / `local-docker` / `ssh` / `adb` —— 家目录是镜像 / 目标机登录用户 / 设备 shell 的属性,执行环境开起来之后一条命令就读得出,真;
- *  · `device` —— 设备协议(hello / 指令集)没有家目录读数:读它要么走协议新增一格(协议对端在别仓),要么往员工自己的机器上多跑一条未经策略门的命令,都不是本函数能替它定的,假;
- *  · `host` / `in-process` / `e2b` —— 家目录是车道自己的事实(`executionLaneHomeDir` 在 boot 期就有答案),无物可测,假。
- * 起服的「家目录答不出」那一行只留给 **家目录答不出 ∧ 车道又读不了** 的车道({@link buildUndeclaredHomeNote});读得了的车道缺席时由环境自己响(`LaneHomeSeat`)。
- * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。
+ * 「这条车道的执行环境**自己读得出家目录**」—— 读得出 ⇒ 读数是真源:适配器持一只 `LaneHomeSeat`(取值律与座的唯一属主 = `lane-home-probe.ts`),
+ * 部署给的主张({@link buildLaneHomeClaim})在每只环境开起来时被证,不一致 ⇒ 那只环境不开;没有主张 ⇒ 读数填 `ExecutionEnv.homeDir` 的座。
+ *  · `k8s` / `local-docker` / `ssh` / `adb` / `e2b` —— 家目录是镜像 / 目标机登录用户 / 设备 shell / 沙箱模板用户的属性,执行环境开起来之后一条命令就读得出(e2b:`commands.run`
+ *    不带 user ⇒ 模板的缺省用户,自定义模板可以换掉它),真;
+ *  · `host` —— 命令是本进程的子进程,子进程拿到的 `HOME` 由适配器自己组合(继承面 + 会话 `settings.env` 授予),不 spawn 就读得出,真;
+ *  · `device` —— 设备协议(hello / 指令集)没有家目录读数:读它要么走协议新增一格(协议对端在别仓),要么往员工自己的机器上多跑一条未经策略门的命令,都不是本函数能替它定的,假
+ *    (声明就是座,起服披露「来自声明、未实测」,见 {@link buildLaneHomeBootNote});
+ *  · `in-process` —— 没有手,无环境可读,假。
+ * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。对拍钉:读得出 ⟺ 该车道的适配器源码恰持一只座(`test/lane-home-claim-verified.test.ts`)。
  */
 export declare function laneMeasuresHome(lane: ExecutionLane): boolean;
 /** 车道行声明的读面缺省(`READ_FACE` 缺席时,这条车道自己的那一份)。 */
@@ -244,25 +215,24 @@ export type LaneReadFaceDefault = "open" | "roots";
  *
  * 🔴 这是**部署信任决定**不是技术默认:`open` 读面在沙箱里等于「沙箱能看见的都可读」—— 共享卷 / 镜像内凭据 / bind mount 进沙箱的宿主文件,在 `roots` 面上本有强制问
  * (`bypass` 也清不掉),`open` 面零问。所以声明是**显式属性**(可审计,本函数的每个臂都要有人写),告诫句 {@link LANE_OPEN_READ_FACE_CAUTION} 随它走。
- * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。与能力表 `isolation` 位的关系由对账测试钉死(`open` ⟺ `laneIsolated`)。
+ * 穷举 switch、无 default 臂:车道加词而此处不表态 = 编译红。与执行环境块 `isolation` 的关系由对账测试钉死(`open` ⟺ `laneIsolated`)。
  */
 export declare function laneReadFaceDefault(lane: ExecutionLane): LaneReadFaceDefault;
 /** 声明 `open` 的那一句**挂载告诫**(运维面指路句与车道文档同读这一句):把宿主目录 / 共享卷挂进隔离沙箱的部署,在 `open` 面上宿主文件对模型零问可读。 */
 export declare const LANE_OPEN_READ_FACE_CAUTION = "a deployment that mounts host paths or shared volumes into the sandbox (hostPath, bind mount) exposes those host files to reads on an open face \u2014 pin READ_FACE=roots or add read-deny rows (READ_DENY_PATTERNS) for them";
 /**
- * [ref] —— 「这条车道的手在不在 OS 级隔离边界里」。**全仓唯一**的布尔判别式(读表 `isolation` 位,见该位头注的读者清单)。
- * 穷举 switch、无 default 臂:`isolation` 的型只有两档,加档 = 编译红。
- *
- * ⚠️ 本函数对 `in-process` 也答(表上那一行是 unsupported ⇒ false)—— 那一格是「表」的完整性,不是 wire 的说法:
- * 无手部署**没有执行边界可言**,wire 上 `executionLane.isolated` 按 present-iff 缺席(`capabilities/execution-lane.ts`),
- * 不是 false。boot 行只在装出了执行环境工厂时才打,够不着那一格。
+ * 「这条车道的手在不在 OS 级隔离边界里」= 块 `isolation`(读 {@link capabilitiesFor} 的块)。**全仓唯一**的布尔口:boot `remote_exec_enabled.isolated` 与
+ * `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`
+ * 按 present-iff 缺席(`capabilities/execution-lane.ts`),不是 false。
  */
 export declare function laneIsolated(lane: ExecutionLane): boolean;
 /**
- * core 拿没拿到执行环境 = 这条车道**有没有手**(能力表 `coreRemoteExecutionEnv` 位)的唯一布尔口。读者四处:路由的「有没有执行环境」(`boot/resolve-spec.ts`)、
- * wire `executionLane.isolated` 的在场判据(`capabilities/execution-lane.ts`)、记忆边界审计的车道位(`boot/memory-boundary.ts`)、场景详情的附件供给集
- * (`boot/stage-07-capability-layer.ts` 把它填进 `ScenarioDeps.handsLane`:「这一 run 有没有工作区」的车道半场)—— 同读这一只,没有各写一份 `=== "supported"`。
- * 穷举 switch、无 default 臂:该位的型三档(supported / unsupported / single-user-only)都要表态,加档 = 编译红。
+ * 这条车道**有没有手**(块 `io`:文件与 shell 两面真到达目标;`in-process` 的桩块 false)的唯一布尔口。读者四处:路由的「有没有执行环境」(`boot/resolve-spec.ts`)、
+ * wire `executionLane.isolated` 的在场判据(`capabilities/execution-lane.ts`)、场景详情的附件供给集(`boot/stage-07-capability-layer.ts` 把它填进
+ * `ScenarioDeps.handsLane`:「这一 run 有没有工作区」的车道半场)、起服家目录那一行({@link buildLaneHomeBootNote})—— 同读这一只。
  */
 export declare function laneWiresExecutionEnv(lane: ExecutionLane): boolean;
 /** 一条**已登记**的分叉:表写的是目标态,今天的判别式还答别的。 */
@@ -290,11 +260,10 @@ export declare const PLANNED_LANE_DIVERGENCES: readonly PlannedLaneDivergence[];
 /**
  * E2B 沙箱里 agent 跑成的那个用户的 home。
  *
- * 这是 **E2B 平台的事实**,不是本仓的猜:E2B 的基础模板建 `user` 这个用户,每个 sandbox 的进程都以它
- * 运行,home 恒 `/home/user`;本仓 adapter 自己的工作区根默认值(`plugins/remote-env-e2b.ts` 的
- * `DEFAULT_MOUNT_PATH`)用的就是同一个目录。**若某个部署的自定义模板换了用户**,运维用
- * `REMOTE_EXEC_HOME_DIR` 显式声明覆盖 —— 那条旋钮恒赢,见 {@link executionLaneHomeDir}。
- * ⚠️ 本值**未经真机实测**(本批无 e2b 真机),按平台约定 + 仓内既有默认常量登记。
+ * 这是 **E2B 平台的约定**:E2B 的基础模板建 `user` 这个用户,`commands.run` 不带 user 时以模板的缺省用户运行(SDK 2.36.0,envd ≥ 0.4.0),
+ * 基础模板上 home = `/home/user`;本仓 adapter 自己的工作区根默认值(`plugins/remote-env-e2b.ts` 的 `DEFAULT_MOUNT_PATH`)用的就是同一个目录。
+ * 它是 e2b 车道的**出厂主张**(声明缺席时),不是真源:每只沙箱建起来 / 恢复时与沙箱里的 `$HOME` 对证,自定义模板换了用户 ⇒ 那只沙箱不开,
+ * 拒句点名两值、改法 = 把 `REMOTE_EXEC_HOME_DIR` 设成实测值(那条旋钮恒赢,见 {@link executionLaneHomeDir})。
  */
 export declare const E2B_SANDBOX_HOME = "/home/user";
 /** {@link executionLaneHomeDir} 读的那两位部署配置(`ServiceConfig` 结构上满足)。 */
@@ -306,7 +275,7 @@ export interface LaneHomeDeployment {
     readonly remoteExecHomeDir?: string | undefined;
 }
 /**
- * 「**这条部署的执行环境**以哪个 home 运行」—— `~/…` 形权限规则(`Edit(~/.ssh/**)`)唯一的基。
+ * 「**这条部署的执行环境**以哪个 home 运行」的 boot 期答案(主张)—— `~/…` 形权限规则(`Edit(~/.ssh/**)`)唯一的基。
  *
  * ## 病(接入审计 M13 / DEBTS [ref]④)
  * core 的 `ExecutionEnv.homeDir` 是**由 adapter 声明**的座(`engine/harness/types.d.ts`,可选):
@@ -315,14 +284,14 @@ export interface LaneHomeDeployment {
  * (`task-settings.ts` 的 `rejectUnmatchableSettingsNames`)在 home 未知时整表拒 `~/` 形 ——
  * **于是远端部署根本写不出 `~/` 规则**,恒 422。
  *
- * ## 本函数 = **boot 期就答得出的** home 的单一属主
+ * ## 本函数 = **boot 期就答得出的** home(主张)的单一属主
  * 三个消费面读同一份,不许各算各的(两处不同 = 一条规则在 422 门上被拒、却在引擎里编得出来,或反之):
- *  ① 每只 adapter 的 `homeDir` 座的**声明那一半**(`boot/execution-env.ts` 把本函数的答案递进 adapter 配置;
- *     k8s / local-docker / ssh / adb 四条车道的座 = 本函数答案 ∨ 车道建环境时实测,取值律在 `lane-home-probe.ts` 的 `LaneHomeSeat`);
+ *  ① 每只 adapter 的 `homeDir` 座的**主张那一半**(`boot/execution-env.ts` 把 {@link buildLaneHomeClaim} 递进 adapter 配置;读得出家目录的车道
+ *     ({@link laneMeasuresHome})在每只环境开起来时拿读数证它,不一致 ⇒ 那只环境不开;没有主张 ⇒ 座 = 读数,取值律在 `lane-home-probe.ts` 的 `LaneHomeSeat`);
  *  ② 规则基 `PathRuleBases.home`(`boot/resolve-spec.ts` / `boot/parked-revive-gate.ts` 的 `pathAdjudication.taskHome`);
  *  ③ 422 前置门与能力披露(`task-settings.ts` / `deployment-governance.ts`)。
  * ②③ 在下单那一刻就要答,那一刻执行环境还没开 —— 它们只读本函数,**读不到实测值**:没声明的 k8s / local-docker / ssh / adb 部署上,座有实测值而 ②③ 仍按「缺席」办
- * (`~/` 形规则下单拒 —— 偏严的方向,不会出现「门放行而引擎编不出」)。
+ * (`~/` 形规则下单拒 —— 偏严的方向,不会出现「门放行而引擎编不出」);本函数答了的部署上,②③ 按主张办,而主张对不上的环境根本不开(①)。
  *
  * ## 一条规则,不是七条特判
  * **运维显式声明恒赢**(`REMOTE_EXEC_HOME_DIR`,部署级旋钮,不挂任何客户端表态);没有声明时,
@@ -333,21 +302,43 @@ export interface LaneHomeDeployment {
  *  · `k8s` / `local-docker` —— home 是**镜像**的属性,boot 期无从得知;
  *  · `ssh` —— home 是**目标机上那个登录用户**的属性(root 是 `/root`、macOS 是 `/Users/<u>`),
  *    连上之前无从得知,而 422 门要在下单那一刻回答;
- *  · `adb` —— Android 没有 POSIX 意义上的登录 home;
+ *  · `adb` —— 设备 shell 的属性(Android 没有 POSIX 意义上的登录 home),连上之前无从得知;
  *  · `device` —— 员工自己的机器,运行期才连进来。
  * 这五条一律**缺席**(诚实:不猜一个目录去守)。缺席的后果是 `~/` 规则在下单时被 422 响亮拒,
  * 与 core 的 `missingBase:"home"` 同向 —— 这正是负控要的那一格。其中 `k8s` / `local-docker` / `ssh` / `adb` 的**引擎手里那一只座**另有实测的来源
  * (建环境时问 `$HOME`,{@link laneMeasuresHome});本函数不替它回答 —— boot 期确实不知道。
+ * 本函数答出的每一个值(声明,或 host / e2b 的出厂答案)都只是主张:读得出家目录的车道在环境开起来时证它({@link laneMeasuresHome})。
  *
  * 认不出的车道 ⇒ `undefined`(调用方 fail-closed)。生产链上不可达:`loadConfig` 的 [ref] 拒启门先咬。
  */
 export declare function executionLaneHomeDir(deployment: LaneHomeDeployment): string | undefined;
 /**
- * 「这条部署的执行车道**有手**、家目录答不出、**而车道又没有读数办法**」时起服那一行的 `note`(纯字符串 ⇒ `build*`);否则 `undefined`(不出这一行)。
- * 判据只读 {@link executionLaneHomeDir}(boot 期的家目录)、能力表 `coreRemoteExecutionEnv` 位(有没有手)与 {@link laneMeasuresHome}(读不读得出):不另写车道清单。
- * 读得出的车道(k8s / local-docker / ssh / adb)没声明时由环境建起来那一拍实测,实测缺席才由那只环境响同一只事件码(`LaneHomeSeat`)—— 起服不替它们先说。
- * 代价如实:引擎 7.52.0 起家锚拒读行放不下 ⇒ 每一次泄内容的递归读在全 shell 面强制问人(allow / 模式 / bypass 都放不掉)、只读面拒;`~/` 形规则在下单时
- * 就被 422 拒。出路只有一条:声明执行环境的家目录(`$HOME` 读出来的那个绝对路径)。这句话陈述的是事实,不是告警 —— 要它消失就声明家目录。
+ * 部署交给适配器的家目录主张 —— `LaneHomeConfig` 的 `homeDir` / `homeDirSource` 两键(纯数据 ⇒ `build*`;唯一构造点:boot 装配、run-local 的 host 腿与
+ * leader 静态 e2b 腿都展开它)。值 = {@link executionLaneHomeDir};来源 = 运维声明在场 ⇒ `declared`,否则 `lane`(车道出厂答案)—— 只进拒句的改法。
+ * 本函数答不出(车道 boot 期不可知、运维也没声明)⇒ `{}`:适配器没有主张,读得出的车道自己量。
  */
-export declare function buildUndeclaredHomeNote(deployment: LaneHomeDeployment): string | undefined;
+export declare function buildLaneHomeClaim(deployment: LaneHomeDeployment): Pick<LaneHomeConfig, "homeDir" | "homeDirSource">;
+/**
+ * 起服关于本部署执行环境家目录的那一行(纯数据 ⇒ `build*`):`{ event, note }`,或 `undefined`(不出这一行)。只有**读不了**家目录的车道才由起服说 ——
+ * 读得出的车道({@link laneMeasuresHome})在每只环境开起来时自己证 / 自己量,出问题由那只环境说(拒,或同一只 `execution_lane_home_undeclared`)。
+ *  · 无手(in-process)/ 认不出的车道 ⇒ 不出;
+ *  · 读不了 ∧ 没有答案 ⇒ `execution_lane_home_undeclared`:代价如实(引擎 7.52.0 起家锚拒读行放不下 ⇒ 每一次泄内容的递归读在全 shell 面强制问人、只读面拒;
+ *    `~/` 形规则下单 422),出路 = 声明家目录;
+ *  · 读不了 ∧ 声明了 ⇒ `execution_lane_home_unmeasured`:座 = 声明、没有读数证过它 —— 对不上时规则守错目录,运维要守住「声明 = 环境里命令看到的 `$HOME`」。
+ * 判据只读 {@link executionLaneHomeDir}、{@link laneWiresExecutionEnv}(有没有手)与 {@link laneMeasuresHome}(读不读得出):不另写车道清单。
+ * 这两句陈述的是事实,不是告警 —— 要它们消失,换读得出家目录的车道(或对未声明的那一句:声明家目录)。
+ */
+export declare function buildLaneHomeBootNote(deployment: LaneHomeDeployment): {
+    readonly event: string;
+    readonly note: string;
+} | undefined;
+/**
+ * 「部署要求读拒表的字节地板(`READ_DENY_FLOOR_REQUIRED=true`),而本部署车道的执行环境块不守地板」时起服那一行的 `note`(纯字符串 ⇒ `build*`);否则 `undefined`。
+ * 判据只读部署的要求与 {@link capabilitiesFor} 的 `keepsReadFloor`(认不出的车道答不出块 ⇒ 按不守说,不静默)。`in-process` 的桩块守地板 ⇒ 不出。
+ * 句子点名车道与键:这条车道上每个读拒表有行的 run(出厂读拒档在岗时就有行)都在准备期拒,一个命令都不起 —— 起服先把后果与两条出路说出来,
+ * 不让运维从第一条 409 才知道。
+ */
+export declare function buildReadDenyFloorUnkeptNote(deployment: CapabilitiesDeployment & {
+    readonly readDenyFloorRequired: boolean;
+}): string | undefined;
 //# sourceMappingURL=execution-lane-caps.d.ts.map

package/dist/execution-lane-caps.js

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
-import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES } from "@sema-agent/settings-schema/execution-lanes";
-import { isBlankCoordinate } from "@sema-agent/settings-schema";
-import { DECLARE_HOME_REMEDY, buildHomeAbsentNote } from "./lane-home-probe.js";
+import { StubExecutionEnv } from "@sema-agent/core";
+import { EXECUTION_LANE_WORDS as DECLARABLE_LANE_WORDS, EXECUTION_LANES, isBlankCoordinate } 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";
@@ -14,15 +14,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: NO,
-                sandboxPathAdjudication: NO,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: YES,
-                coreRemoteExecutionEnv: NO,
-                canonicalPathAuthority: NO,
                 tenantSeparation: YES,
             };
         case "host":
@@ -32,15 +25,8 @@ export function executionLaneCaps(lane) {
                 scheduler: SU,
                 lsp: SU,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: NO,
-                sandboxPathAdjudication: NO,
                 worktreeIsolation: YES,
-                memoryPersistenceCapable: YES,
-                hostFilePlane: YES,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "e2b":
@@ -50,15 +36,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: YES,
-                isolation: YES,
-                suspendable: YES,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "k8s":
@@ -68,15 +47,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: YES,
-                isolation: YES,
-                suspendable: YES,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "ssh":
@@ -86,15 +58,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: SU,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "adb":
@@ -104,15 +69,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: NO,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "local-docker":
@@ -122,15 +80,8 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: YES,
-                suspendable: NO,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
         case "device":
@@ -140,19 +91,47 @@ export function executionLaneCaps(lane) {
                 scheduler: NO,
                 lsp: NO,
                 sandboxSendUserFile: NO,
-                isolation: NO,
-                suspendable: NO,
                 remoteScratchpad: YES,
-                sandboxPathAdjudication: YES,
                 worktreeIsolation: NO,
-                memoryPersistenceCapable: NO,
-                hostFilePlane: NO,
-                coreRemoteExecutionEnv: YES,
-                canonicalPathAuthority: YES,
                 tenantSeparation: executionLaneRow(lane).tenantSeparation,
             };
     }
 }
+const IN_PROCESS_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_BLOCK = Object.freeze({ isolation: true, suspendable: true, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const K8S_BLOCK = Object.freeze({ isolation: true, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const K8S_SNAPSHOT_BLOCK = Object.freeze({ ...K8S_BLOCK, suspendable: true });
+const LOCAL_DOCKER_BLOCK = Object.freeze({ isolation: true, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const SSH_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const ADB_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: false, io: true, keepsReadFloor: false });
+const DEVICE_BLOCK = Object.freeze({ isolation: false, suspendable: false, sharesProcessTable: false, canonicalPathAuthoritative: true, hostLocalPaths: false, externalContentTarget: true, io: true, keepsReadFloor: false });
+function laneBlock(lane, snapshotStore) {
+    switch (lane) {
+        case "in-process":
+            return IN_PROCESS_BLOCK;
+        case "host":
+            return HOST_BLOCK;
+        case "e2b":
+            return E2B_BLOCK;
+        case "k8s":
+            return snapshotStore ? K8S_SNAPSHOT_BLOCK : K8S_BLOCK;
+        case "local-docker":
+            return LOCAL_DOCKER_BLOCK;
+        case "ssh":
+            return SSH_BLOCK;
+        case "adb":
+            return ADB_BLOCK;
+        case "device":
+            return DEVICE_BLOCK;
+    }
+}
+export function capabilitiesFor(deployment) {
+    const lane = executionLaneOf(deployment.remoteExec?.provider);
+    if (lane === undefined)
+        return undefined;
+    return laneBlock(lane, lane === "k8s" && Boolean(deployment.remoteExec?.s3Snapshot));
+}
 export const ALL_EXECUTION_LANES = Object.freeze(["in-process", ...DECLARABLE_LANE_WORDS]);
 const EXECUTION_LANE_SET = new Set(ALL_EXECUTION_LANES);
 export function isExecutionLane(word) {
@@ -210,8 +189,8 @@ export function deployedExecutionLanes(config) {
     return [executionLaneOf(config.remoteExec?.provider)];
 }
 export function handsOnWorkerFilePlane(lane) {
-    const caps = executionLaneCaps(lane);
-    return caps.hostFilePlane === "supported" && caps.coreRemoteExecutionEnv === "supported";
+    const block = laneBlock(lane, false);
+    return block.io && block.hostLocalPaths;
 }
 export function laneBindsReads(lane) {
     switch (lane) {
@@ -233,11 +212,11 @@ export function laneMeasuresHome(lane) {
         case "local-docker":
         case "ssh":
         case "adb":
+        case "e2b":
+        case "host":
             return true;
         case "device":
-        case "host":
         case "in-process":
-        case "e2b":
             return false;
     }
 }
@@ -257,23 +236,10 @@ export function laneReadFaceDefault(lane) {
 }
 export const LANE_OPEN_READ_FACE_CAUTION = "a deployment that mounts host paths or shared volumes into the sandbox (hostPath, bind mount) exposes those host files to reads on an open face — pin READ_FACE=roots or add read-deny rows (READ_DENY_PATTERNS) for them";
 export function laneIsolated(lane) {
-    const isolation = executionLaneCaps(lane).isolation;
-    switch (isolation) {
-        case "supported":
-            return true;
-        case "unsupported":
-            return false;
-    }
+    return laneBlock(lane, false).isolation;
 }
 export function laneWiresExecutionEnv(lane) {
-    const wired = executionLaneCaps(lane).coreRemoteExecutionEnv;
-    switch (wired) {
-        case "supported":
-            return true;
-        case "unsupported":
-        case "single-user-only":
-            return false;
-    }
+    return laneBlock(lane, false).io;
 }
 export const PLANNED_LANE_DIVERGENCES = Object.freeze([]);
 export const E2B_SANDBOX_HOME = "/home/user";
@@ -298,14 +264,32 @@ export function executionLaneHomeDir(deployment) {
             return undefined;
     }
 }
-export function buildUndeclaredHomeNote(deployment) {
-    if (executionLaneHomeDir(deployment) !== undefined)
-        return undefined;
+export function buildLaneHomeClaim(deployment) {
+    const home = executionLaneHomeDir(deployment);
+    if (home === undefined)
+        return {};
+    return { homeDir: home, homeDirSource: deployment.remoteExecHomeDir !== undefined ? "declared" : "lane" };
+}
+export function buildLaneHomeBootNote(deployment) {
     const lane = executionLaneOf(deployment.remoteExec?.provider);
-    if (lane === undefined || executionLaneCaps(lane).coreRemoteExecutionEnv !== "supported")
+    if (lane === undefined || !laneWiresExecutionEnv(lane))
         return undefined;
     if (laneMeasuresHome(lane))
         return undefined;
-    return buildHomeAbsentNote(lane, "REMOTE_EXEC_HOME_DIR is unset, and this lane cannot read its execution environment's home", DECLARE_HOME_REMEDY);
+    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) };
+}
+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 ` +
+        `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.`);
 }
 //# sourceMappingURL=execution-lane-caps.js.map

package/dist/http/memory-compliance-failure-reply.d.ts

@@ -8,7 +8,9 @@
  * core 的另外三只 409 与 `ControlPlaneCorruptError` 全落 500 `internal.error` —— 「同一个 requestId 拿去抹另一个会话」这种**调用方自己
  * 能改**的错被说成服务器坏了。两份分类 = 两个判官,少的那份恒是静默的一份。现在**码与状态**只在这里判一次,两面同读。
  *
- * ## 规则(三层,与 operator 面既有层序逐字同序)
+ * ## 规则(三层,与 operator 面既有层序逐字同序;另有本服务自铸的一只,先判)
+ *  ⓪ 本服务的抹除店护栏拒 {@link MemoryErasureStoreUnjudged} —— 409 `memory.erasure_store_unjudged`(抹除落到部署的店之外的那只店:本部署此刻判不了
+ *     同一个 `requestId` 跨店的幂等;什么都没删)。文案按受众,同下一节的规则;
  *  ① core 的**本口专属**码(闭集穷举 `switch`,见 {@link sentCoreCode})—— 码与状态两面同;文案按受众(下一节,一条规则);
  *  ② **店形拒**两码 `memory.target_outside_store`(core 7.31.1 [ref])/ `memory.scope_home_not_directory`(core 7.44.0 [ref])—— 跨面 store 状态码,409、码原样
  *     (判据 `memory-store-refusal.ts` 一只;运维行 `memory_store_form_refused { code, path?, form? }` 两受众同一只铸点,路径只在那里);