@sema-agent/server 7.134.0 → 7.135.0

package/dist/deployment-shape.d.ts

@@ -0,0 +1,127 @@
+/**
+ * [ref] —— **部署形谓词的唯一一张表**(消费点读表;吸收 [ref] / [ref] / [ref])。
+ *
+ * ## 规则
+ * 「这台部署是什么形」的每一个布尔判断只有一个答者:{@link DEPLOYMENT_SHAPE_PREDICATES} 的一行。消费点写
+ * `DEPLOYMENT_SHAPE_PREDICATES.<行>.holds(config)`,不 import 散落函数;表外不许再长出一只自读部署形事实的布尔判据
+ * (反向门 `test/deployment-shape-gate.test.ts` 按语法树判,判据逐字写在那份门的头注里)。
+ *
+ * ## 两根轴,每根轴一个读口(原始配置键只在这两个函数里被读)
+ *  · `principal` —— 运维的 `REQUIRE_PRINCIPAL` 声明({@link readPrincipalAxis})。
+ *  · `lane` —— `REMOTE_EXEC` 的归一车道词(`executionLaneOf`,认不出 ⇒ `undefined`,行必须 fail-closed)+ 那条车道的能力表行 +
+ *    车道子旋钮(k8s 运行时类 / 快照店、隐式 host 尾臂记号)({@link readLaneAxis})。
+ *
+ * ## 轴列不是注释,是型
+ * 每行的判官只收到它**声明**的那几根轴的事实({@link DeploymentShapeFacts}),读不到配置本身 —— 判官碰一根没声明的轴 = 编译红;
+ * `holds` 的入参型 = 所声明轴读入形的交叉({@link DeploymentShapeInput}),所以调用方递完整 `ServiceConfig` 或只递那几键的窄形都行。
+ *
+ * ## 什么进表、什么不进
+ * 进表的是**形规则**:只由部署形事实决定的布尔(去重后 14 行;同一条规则的多个消费者读同一行,不各成一行)。
+ * 把一行与**非形事实**(锁键、合规档位、审批意图、请求身份、请求体)合取的能力判据是**消费者**,住在它自己的模块
+ * (`a2aInjectionHonored` = 锁 ∧ 合规 ∧ `!multiTenant`;`taskHooksHonored`;身份门 …),读行、不读原始键。
+ * 车道表(`execution-lane-caps.ts`)按车道词键控的布尔列(`laneIsolated` 等)是车道轴自己的事实表,不是「部署」的谓词;行读它们。
+ *
+ * 依赖纪律:叶模块 —— 值导入只有 `execution-lane-caps.ts`(它本身是叶),零运行期环。
+ */
+import { type ExecutionLane, type ExecutionLaneCaps } from "./execution-lane-caps.js";
+/** `principal` 轴读的配置键(`ServiceConfig` 结构上满足)。 */
+export interface PrincipalAxisInput {
+    readonly requirePrincipal?: boolean | undefined;
+}
+/** `principal` 轴的事实。 */
+export interface PrincipalAxisFacts {
+    /** 运维声明了 `REQUIRE_PRINCIPAL=true`。 */
+    readonly declared: boolean;
+}
+/** `lane` 轴读的配置键:已装配的 `remoteExec` 里本表用得到的那几键(`ServiceConfig` 的判别联合每一臂结构上都满足)。 */
+export interface LaneAxisInput {
+    readonly remoteExec?: {
+        readonly provider?: string | undefined;
+        readonly runtimeClass?: string | undefined;
+        readonly s3Snapshot?: unknown;
+        readonly singleMachineDefault?: boolean | undefined;
+    } | undefined;
+}
+/** `lane` 轴的事实。 */
+export interface LaneAxisFacts {
+    /** 归一车道词;认不出 ⇒ `undefined`(生产链上不可达:`loadConfig` 的 [ref] 先拒启;行在这一格必须 fail-closed)。 */
+    readonly lane: ExecutionLane | undefined;
+    /** 那条车道的能力表行(认不出 ⇒ `undefined`)。 */
+    readonly caps: ExecutionLaneCaps | undefined;
+    /** k8s 的 `runtimeClass`(别的车道 `undefined`)。 */
+    readonly k8sRuntimeClass: string | undefined;
+    /** k8s 配了 S3 工作区快照店(别的车道 `false`)。 */
+    readonly k8sSnapshotStore: boolean;
+    /** host 车道值上带「单机形缺省」记号(唯一写者 = `config.ts` 三元链的隐式 host 尾臂;显式 `REMOTE_EXEC=host` 与文件覆写都不带)。 */
+    readonly singleMachineDefault: boolean;
+}
+/** 轴全集(闭集)→ 读入形与事实型。加一根轴 = 在这里加一键 + {@link readAxis} 的穷举 switch 加一臂(漏一处即编译红)。 */
+interface AxisShapes {
+    readonly principal: {
+        readonly input: PrincipalAxisInput;
+        readonly facts: PrincipalAxisFacts;
+    };
+    readonly lane: {
+        readonly input: LaneAxisInput;
+        readonly facts: LaneAxisFacts;
+    };
+}
+/** 部署形轴(闭集)。 */
+export type DeploymentShapeAxis = keyof AxisShapes;
+type UnionToIntersection<U> = (U extends unknown ? (u: U) => void : never) extends (i: infer I) => void ? I : never;
+/** 一行的入参型 = 它声明的各轴读入形的交叉。 */
+export type DeploymentShapeInput<A extends DeploymentShapeAxis> = UnionToIntersection<AxisShapes[A]["input"]>;
+/** 一行的判官看得见的事实 = 它声明的那几根轴(恰这几键)。 */
+export type DeploymentShapeFacts<A extends DeploymentShapeAxis> = {
+    readonly [K in A]: AxisShapes[K]["facts"];
+};
+/** 表的一行。 */
+export interface DeploymentShapePredicate<A extends DeploymentShapeAxis> {
+    /** 这一行读哪几根轴(= 判官入参的型;不是注释)。 */
+    readonly axes: readonly A[];
+    /** 这一行回答的那一句话(含它判的语义轴:租户 / 车道 / 设备归属 / 隔离强度 …)。 */
+    readonly question: string;
+    /** 在这台部署上成立吗。 */
+    holds(deployment: DeploymentShapeInput<A>): boolean;
+}
+export declare const DEPLOYMENT_SHAPE_PREDICATES: Readonly<{
+    /** 身份门的问法。读者:请求面的身份 / 属主门(`http/principal-gate.ts`、`http/request-guards.ts`、`security.ts`)。 */
+    principalRequired: DeploymentShapePredicate<"principal">;
+    /**
+     * 租户轴的问法。今天与 {@link DEPLOYMENT_SHAPE_PREDICATES.principalRequired} 读**同一个声明**([ref] ①:托管 / 多租 ⇔ `REQUIRE_PRINCIPAL=true`,
+     * 签发方配置是身份验签轴、不算租户证据)—— 两个问题、一根轴、一个读口;「鉴权必需」与「多租形」拆成两个声明时只改这一行的判官。
+     */
+    multiTenant: DeploymentShapePredicate<"principal">;
+    /** 读能力表 `callerCwd` 位(host = 单主才开;device = 路径落在发起者自己的设备上,归属由 `device_session` 绑定验过,不要求单主)。 */
+    callerCwd: DeploymentShapePredicate<"principal" | "lane">;
+    /** 调用方给的宿主绝对路径(附加目录 / 项目上下文 / 本机 SendUserFile / 指令文件探针)只在「手就在本 worker 的盘上 ∧ 单主」时指向调用方自己的东西。 */
+    callerOwnsWorkerDisk: DeploymentShapePredicate<"principal" | "lane">;
+    /** wire `executionLane.toolsOnThisHost` 与出厂 / 中心技能的 `baseDir`:只问文件系统同一性,与租户无关(出厂内容每个租户拿到同一份)。 */
+    toolsOnThisHost: DeploymentShapePredicate<"lane">;
+    /** `REMOTE_EXEC` 未设的进程内形(没有手)且单主:进程级消费者(hooks 命令、项目上下文本机读、卡批规则 root)看到的就是引擎自己的进程 cwd / env。 */
+    inProcessSingleUser: DeploymentShapePredicate<"principal" | "lane">;
+    /** 任务层替部署声明宿主姿态(bypassPermissions 开写面 / host shell 继承整份环境)的射程:device 车道上跨租户宿主穿越结构性不存在(clay 裁定③)。 */
+    taskHostPostureDeclarations: DeploymentShapePredicate<"principal" | "lane">;
+    /** 写门走 [ref] 代理裁决(文件平面不在 worker 本机);认不出的词 ⇒ 走代理(代理 slot 空 ⇒ 写门 fail-closed)。 */
+    sandboxPathAdjudication: DeploymentShapePredicate<"lane">;
+    /** 读能力表 `sandboxSendUserFile` 位(e2b / k8s 每任务一只沙箱 ⇒ 任何租户;ssh 共享一台真机 ⇒ 只单主)。 */
+    sandboxSendUserFile: DeploymentShapePredicate<"principal" | "lane">;
+    /** 读能力表 `remoteScratchpad` 位(`/tmp/scratchpad/<sessionId>` 远端约定)。 */
+    remoteScratchpad: DeploymentShapePredicate<"lane">;
+    /** 读能力表 `tenantSeparation` 位(值来自 settings-schema 车道词表正本);唯一读者 = 跨域不变量 `multi-tenant-shared-lane`。 */
+    laneSeparatesTenants: DeploymentShapePredicate<"principal" | "lane">;
+    /**
+     * [ref] —— **VM 级**隔离强度(独立内核:e2b 的 Firecracker microVM;k8s 只在 Kata / gVisor 运行时类上)。与能力表 `isolation` 位
+     * (OS 级边界,容器即算;wire `executionLane.isolated` 的属主 `laneIsolated`)是两个问题,所以不叫「isolated」。读者:A 值路由。
+     */
+    vmIsolatedHands: DeploymentShapePredicate<"lane">;
+    /**
+     * [ref] —— 执行环境可挂起:能力表 `suspendable` 位(「结构上能不能」)∧ k8s 的前提旋钮(配了 S3 快照店)。真作者是各适配器对 core 的
+     * `capabilities.suspendable` 声明(对账:`test/execution-lane-caps.test.ts` 拿真适配器实例逐车道核)。读者:boot `remote_exec_enabled.suspendable`。
+     */
+    suspendableHands: DeploymentShapePredicate<"lane">;
+    /** 读者两处:`config.ts` 车道落点一行的 `source`(覆写之前)与 `boot/execution-env.ts` 的 `remote_exec_real_system.note`(覆写之后)—— 同一个记号、两个时刻。 */
+    singleMachineDefaultLane: DeploymentShapePredicate<"lane">;
+}>;
+export {};
+//# sourceMappingURL=deployment-shape.d.ts.map

package/dist/deployment-shape.js

@@ -0,0 +1,72 @@
+import { executionLaneCaps, executionLaneOf, handsOnWorkerFilePlane } from "./execution-lane-caps.js";
+function readPrincipalAxis(deployment) {
+    return { declared: deployment.requirePrincipal === true };
+}
+function readLaneAxis(deployment) {
+    const declaration = deployment.remoteExec;
+    const lane = executionLaneOf(declaration?.provider);
+    return {
+        lane,
+        caps: lane === undefined ? undefined : executionLaneCaps(lane),
+        k8sRuntimeClass: lane === "k8s" ? declaration?.runtimeClass : undefined,
+        k8sSnapshotStore: lane === "k8s" && Boolean(declaration?.s3Snapshot),
+        singleMachineDefault: lane === "host" && declaration?.singleMachineDefault === true,
+    };
+}
+function readAxis(axis, deployment) {
+    switch (axis) {
+        case "principal":
+            return readPrincipalAxis(deployment);
+        case "lane":
+            return readLaneAxis(deployment);
+    }
+}
+function createPredicate(axes, question, judge) {
+    const declared = Object.freeze([...axes]);
+    return Object.freeze({
+        axes: declared,
+        question,
+        holds(deployment) {
+            const input = deployment;
+            const facts = {};
+            for (const axis of declared)
+                facts[axis] = readAxis(axis, input);
+            return judge(facts);
+        },
+    });
+}
+function capabilityHolds(cap, principal) {
+    switch (cap) {
+        case "supported":
+            return true;
+        case "unsupported":
+            return false;
+        case "single-user-only":
+            return !principal.declared;
+    }
+}
+const VM_ISOLATION_RUNTIME_CLASSES = new Set(["kata", "kata-qemu", "kata-clh", "kata-fc", "gvisor", "runsc"]);
+export const DEPLOYMENT_SHAPE_PREDICATES = Object.freeze({
+    principalRequired: createPredicate(["principal"], "身份轴:运维声明了 REQUIRE_PRINCIPAL=true —— 每个调用方都必须带一个验过的主体。", ({ principal }) => principal.declared),
+    multiTenant: createPredicate(["principal"], "租户轴:这台部署服务不止一个主人(托管 / 多租;C-R100 ① 由 REQUIRE_PRINCIPAL=true 声明)。", ({ principal }) => principal.declared),
+    callerCwd: createPredicate(["lane", "principal"], "车道 × 租户 / 设备归属:调用方送来的 cwd(与 settings.env)被尊重 —— host 车道且单主,或 device 车道。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.callerCwd, principal)),
+    callerOwnsWorkerDisk: createPredicate(["lane", "principal"], "车道 × 租户:手就在本 worker 的盘上且部署只有一个主人 —— 这块盘上的路径就是调用方自己的。", ({ lane, principal }) => lane.lane !== undefined && handsOnWorkerFilePlane(lane.lane) && !principal.declared),
+    toolsOnThisHost: createPredicate(["lane"], "车道:工具跑的那台机器就是本进程这台(手挂上了且文件平面在本 worker 盘上;车道列 handsOnWorkerFilePlane)。", ({ lane }) => lane.lane !== undefined && handsOnWorkerFilePlane(lane.lane)),
+    inProcessSingleUser: createPredicate(["lane", "principal"], "车道 × 租户:进程内车道(REMOTE_EXEC 未设)且部署只有一个主人。", ({ lane, principal }) => lane.lane === "in-process" && !principal.declared),
+    taskHostPostureDeclarations: createPredicate(["lane", "principal"], "车道 × 租户 / 设备归属:任务层可以替部署声明宿主姿态 —— device 车道(发起者自己的设备),或单主部署。", ({ lane, principal }) => lane.lane === "device" || !principal.declared),
+    sandboxPathAdjudication: createPredicate(["lane"], "车道:写门的路径事实要经代理到执行环境里取(文件平面不在本 worker 盘上;认不出的车道也走代理)。", ({ lane }) => lane.caps === undefined || lane.caps.hostFilePlane !== "supported"),
+    sandboxSendUserFile: createPredicate(["lane", "principal"], "车道 × 租户:SendUserFile 的沙箱直传腿可以挂(沙箱盘 = 租户自己的任务工作区,或共享真机上的单主部署)。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.sandboxSendUserFile, principal)),
+    remoteScratchpad: createPredicate(["lane"], "车道:执行环境里按会话分的远端 scratchpad 约定适用。", ({ lane }) => lane.caps !== undefined && lane.caps.remoteScratchpad === "supported"),
+    laneSeparatesTenants: createPredicate(["lane", "principal"], "车道 × 租户:这条车道在这台部署上不让两个租户的命令落在同一个共享目标上(单主部署恒成立;认不出的车道不成立)。", ({ lane, principal }) => lane.caps !== undefined && capabilityHolds(lane.caps.tenantSeparation, principal)),
+    vmIsolatedHands: createPredicate(["lane"], "车道 / 隔离强度:手跑在 VM 级边界里(独立内核);runc / 共享内核 / 真机 / 认不出 ⇒ 否。", ({ lane }) => {
+        if (lane.lane === "e2b")
+            return true;
+        if (lane.lane !== "k8s")
+            return false;
+        const runtimeClass = (lane.k8sRuntimeClass ?? "").trim().toLowerCase();
+        return runtimeClass.startsWith("kata") || VM_ISOLATION_RUNTIME_CLASSES.has(runtimeClass);
+    }),
+    suspendableHands: createPredicate(["lane"], "车道:执行环境可挂起(e2b;k8s 以配了 S3 工作区快照店为前提)。", ({ lane }) => lane.caps !== undefined && lane.caps.suspendable === "supported" && (lane.lane !== "k8s" || lane.k8sSnapshotStore)),
+    singleMachineDefaultLane: createPredicate(["lane"], "车道:host 车道是单机形缺省落点(REMOTE_EXEC 未设 ∧ CONFIG_PROVIDER=local,没人点名)。", ({ lane }) => lane.singleMachineDefault),
+});
+//# sourceMappingURL=deployment-shape.js.map

package/dist/device-store.d.ts

@@ -50,7 +50,7 @@ export declare const DEVICE_RATE_LIMIT_CODE: "limit.rate_exceeded";
  * 排空/停机拒绝复用**既有**的通用码(`draining`,`docs/ASSISTANT-WIRE-CONTRACT.md` 附录 A 已收录,503)。
  *
  * 🔴 刻意不铸 `device.draining`([ref]/[ref]):§4.8 的 device 闭集**冻结**且无 draining 成员,而排空
- * 语义面全部署早有属主词 —— HTTP 计费提交拒臂(`http/readiness.ts` 的 `billableRefusalOf` 唯一铸点,S-739 前是 `sendError(res, 503, "draining", …)`;SDK spec 逐字引用
+ * 语义面全部署早有属主词 —— HTTP 计费提交拒臂(`http/readiness.ts` 的 `billableRefusalOf` 唯一铸点,[ref] 前是 `sendError(res, 503, "draining", …)`;SDK spec 逐字引用
  * 的冻结字面)、drain 期新 upgrade 拒(503)、WS hello 拒帧 / bye 帧的 `draining` 分支键。为同一语义再铸
  * `device.*` 同义码 = 消费端要认两套(上面 rate-limit 条的同一判据);且 `device.draining` 在 HTTP 层
  * 零发送点,写进附录 A 即幽灵行(`error-code-catalog-live` 的「文档多码」臂当场红)。

package/dist/device-ws-hub.d.ts

@@ -180,7 +180,7 @@ export interface DeviceWsHub {
     isDraining(): boolean;
     connectedDeviceIds(): string[];
     /**
-     * S-470(车C C-G2「吊销后活连接 5s 内断」)—— **立刻**对这台设备的活连接重跑一次世代围栏。
+     * [ref](车C C-G2「吊销后活连接 5s 内断」)—— **立刻**对这台设备的活连接重跑一次世代围栏。
      *
      * 🔴 为什么是「重跑围栏」而不是一条新的断连路径:吊销已经在**店内同事务**作废租约并把
      * `conn_generation` 推进一格(§4.6 步 2),所以本连接的下一次带世代谓词的写必然影响 0 行 ——

package/dist/egress-redirect.d.ts

@@ -1,6 +1,6 @@
 /**
  * 本服务**自己**发往配置端点的出站请求(hook 直连模型腿 `hooks/hook-llm.ts`、记忆 embedder `plugins/memory-embedder.ts`)的
- * 重定向律 —— 与 core 7.51.0(#1531)一方 brain 的请求同一条:请求以 `redirect: "manual"` 发出,端点回重定向 ⇒ 拒;
+ * 重定向律 —— 与 core 7.51.0([ref])一方 brain 的请求同一条:请求以 `redirect: "manual"` 发出,端点回重定向 ⇒ 拒;
  * 不跟、不重试、拒句不点名目标。
  *
  * 为什么:请求只去被判过的那个根。传输层(undici)跟随 POST 307 / 308 时把请求体(用户内容 / 记忆正文)原样送到

package/dist/entry-mode-clamp-notice.d.ts

@@ -1,5 +1,5 @@
 /**
- * S-1306 —— **入口地板钳制**通告(`engine_notice` 码 `permission.entry_mode_clamped`)的唯一铸点(core 7.51.0 #1527 入册:受众 user、
+ * [ref] —— **入口地板钳制**通告(`engine_notice` 码 `permission.entry_mode_clamped`)的唯一铸点(core 7.51.0 [ref] 入册:受众 user、
  * 铸者 `NOTICE_MINTER` = `"server"`,引擎从不铸它)。
  *
  * ## 这件事为什么归本仓
@@ -23,7 +23,7 @@
  */
 import type { EngineNotice, EngineNoticeCode } from "@sema-agent/core";
 import type { EntryPermissionMode } from "./runtime-governance.js";
-/** 码常量型 = core 码册(#1527 入册:受众 user、铸者 `"server"`)。 */
+/** 码常量型 = core 码册([ref] 入册:受众 user、铸者 `"server"`)。 */
 export declare const ENTRY_MODE_CLAMPED: EngineNoticeCode;
 /** 一次受理门盖章的读数 → 至多一条通告(读法见文件头)。 */
 export declare function buildEntryModeClampNotice(entry: EntryPermissionMode, sessionId: string | undefined): EngineNotice | undefined;

package/dist/env-facts.d.ts

@@ -34,8 +34,8 @@ export interface SandboxEnvFacts {
 /**
  * 一条 scratchpad 路径能不能被**原样**宣告(core 的渲染上限 {@link MAX_PATH} 之内)—— scratchpad 的**铸造条件**之一。
  * 两个铸点(server 自算 {@link ensureScratchpadDir}、壳供 {@link screenShellScratchpadDir})读这同一只:渲染不下的路径
- * **根本不铸**(不建目录、不进写门豁免、不宣告 —— 宣告是根围栏那个洞的唯一写者,S-842,于是也不开洞)。
- * 🔴 S-842 codex r1 [medium]:删 [ref] 折叠之后,只在宣告那一步丢长路径会留下「建了、豁免了、却不宣告也不开洞」的目录;
+ * **根本不铸**(不建目录、不进写门豁免、不宣告 —— 宣告是根围栏那个洞的唯一写者,[ref],于是也不开洞)。
+ * 🔴 [ref] codex r1 [medium]:删 [ref] 折叠之后,只在宣告那一步丢长路径会留下「建了、豁免了、却不宣告也不开洞」的目录;
  * 规则挪到铸点,四件同有同无。(远程车道的 `/tmp/scratchpad/<sessionId>` 恒在上限内:sessionId ≤ 64,见 prepareSpec。)
  */
 export declare function scratchpadPathRenderable(path: string): boolean;
@@ -79,13 +79,13 @@ export declare function scratchpadDirFor(localDataRoot: string, sessionId: strin
  *  {@link purgeScratchpadDir}(session delete)+ {@link sweepStaleScratchpads}(mtime 周期扫),keyed by the
  *  same scratchpadDirFor convention;接线(E21 DELETE purge + 周期 sweep)在 main.ts 侧(D 组)。 */
 export declare function ensureScratchpadDir(localDataRoot: string, sessionId: string, 
-/** 渲染不下(铸造条件不成立)时的那一行 —— 调用方交日志口(S-842 codex r1:不铸必须说出来,否则「本会话没有 scratchpad」无从排查)。 */
+/** 渲染不下(铸造条件不成立)时的那一行 —— 调用方交日志口([ref] codex r1:不铸必须说出来,否则「本会话没有 scratchpad」无从排查)。 */
 warn: (msg: string, meta?: object) => void): Promise<string | undefined>;
 /** G3([ref] 壳侧承诺③/[ref]③,[ref]§四接单):**壳供** scratchpad 路径的验收门。
  *
  *  壳(cli)vendored getScratchpadDir 算出 per-session scratchpad 路径随 `TaskRequest.scratchpadDir` 发来;
  *  接受后它**优先于** server 自算(ensureScratchpadDir),喂 resolve-spec 的同一单点(envFacts 宣告 ——
- *  core 据它开根围栏的洞,S-842 起是那个洞的唯一写者 —— + fs-write gate exemptDirs)。「没到货引擎忽略 = 无害 additive」。
+ *  core 据它开根围栏的洞,[ref] 起是那个洞的唯一写者 —— + fs-write gate exemptDirs)。「没到货引擎忽略 = 无害 additive」。
  *
  *  信任边界:这是 exemptDirs **放宽**输入,验收 fail-closed(任何拒收形回落自算,不 fault 任务):
  *   - 多租户(requirePrincipal)一律拒——共享 worker 盘上租户自选豁免目录=超范围面;
@@ -109,9 +109,9 @@ export declare function acceptShellScratchpadDir(raw: unknown, opts: {
     warn: (msg: string, meta?: object) => void;
 }): Promise<string | undefined>;
 /**
- * {@link acceptShellScratchpadDir} 的**词法半场**(S-351 拆出):零 I/O、可在请求的任何一点问。
+ * {@link acceptShellScratchpadDir} 的**词法半场**([ref] 拆出):零 I/O、可在请求的任何一点问。
  *
- * 为什么拆:S-351 的前判要在**任何副作用之前**回答「这条请求会把哪个目录当写门豁免域」,而验收门的
+ * 为什么拆:[ref] 的前判要在**任何副作用之前**回答「这条请求会把哪个目录当写门豁免域」,而验收门的
  * 后半场是 `mkdir`(副作用 + I/O)。把判据抄一份到前判处 = 两份验收规则,而两份规则漂移的那天,前判
  * 会替一条**根本不会被接受**的壳供路径拒掉请求(或反过来放过一条会被接受的)。所以规则只有这一份,
  * 两个调用点各取所需:验收门 = 本函数 + mkdir;前判 = 本函数。
@@ -124,7 +124,7 @@ export declare function screenShellScratchpadDir(raw: unknown, opts: {
     warn: (msg: string, meta?: object) => void;
 }): string | undefined;
 /**
- * S-351(core 7.20.0 / [ref])—— **这条请求会不会把任务根放进写门的豁免域里**。
+ * [ref](core 7.20.0 / [ref])—— **这条请求会不会把任务根放进写门的豁免域里**。
  *
  * ## 病形(引擎侧的硬拒,不是判决期的宽严)
  * 写门的豁免域就是 scratchpad(`exemptDirs: [scratchpadDir]`,`task-settings.ts` 的
@@ -142,7 +142,7 @@ export declare function screenShellScratchpadDir(raw: unknown, opts: {
  * canonical 就是承诺一件此刻做不到的事(软链形的真身要到裁决时刻才问 fs,那是写门自己的第二道)。
  *
  * ## 射程(每一条都是「不这样写就会误拒」)
- *  · **只在 cwd 真会被尊重时判**:`cwdHonored` 为假的部署(多租户 / 非 host 车道)把 cwd 直接忽略,
+ *  · **只在 cwd 落在本 worker 盘上时判**:部署形表行 `callerOwnsWorkerDisk` 为假的部署(多租户 / 手不在本 worker 盘上的车道)不把 cwd 落到这块盘上,
  *    它永远不会变成门的根 —— 在那里拒等于凭空多一条 400;
  *  · **豁免域取这条会话可能挂上的每一只**(不是「这一次挂哪只」):server 自算那条恒是候选(有 session
  *    就算得出),壳供 `body.scratchpadDir` **过了词法验收**才追加为候选(过不了的那条永远挂不上,拿它拒
@@ -158,7 +158,8 @@ export declare function scratchpadCoveringTaskRoot(args: {
     localDataRoot: string;
     sessionId: string | undefined;
     requirePrincipal: boolean;
-    cwdHonored: boolean;
+    /** 部署形表行 `callerOwnsWorkerDisk`(调用方递表的答案,本模块不判部署形)。 */
+    callerOwnsWorkerDisk: boolean;
 }): {
     cwd: {
         asSpelled: string;

package/dist/env-facts.js

@@ -119,7 +119,7 @@ export function screenShellScratchpadDir(raw, opts) {
     return canonical;
 }
 export function scratchpadCoveringTaskRoot(args) {
-    if (!args.cwdHonored || !isAbsoluteHostPath(args.cwd))
+    if (!args.callerOwnsWorkerDisk || !isAbsoluteHostPath(args.cwd))
         return undefined;
     const candidates = [];
     const shell = screenShellScratchpadDir(args.shellScratchpadDir, { requirePrincipal: args.requirePrincipal, hostSemanticsLane: true, warn: () => { } });

package/dist/env-name-allowlist-knobs.d.ts

@@ -1,20 +1,20 @@
 /**
- * S-699 / S-713 —— **名单型 env 旋钮**的闭集表(纯叶:零值依赖,任何层都可值引而不成装载环)。
+ * [ref] / [ref] —— **名单型 env 旋钮**的闭集表(纯叶:零值依赖,任何层都可值引而不成装载环)。
  *
  * 解析规则(未设 / 形错拒启 / 姿态 / 生效名单)的全文在 `config.ts` `parseEnvNameAllowlist` 的头注;本表只装**各旋钮自己的**事实,
  * 不是解析规则:
  *  · `example` 进拒句;
  *  · `multiTenant` = `REQUIRE_PRINCIPAL=true` 下名单作不作数 —— **只有服务进程读的旋钮有这一列**(姿态是服务进程的概念):
- *    - `LSP_ENV_ALLOW` ⇒ ignored:host 腿语言服务器在多租户姿态下本来就不起,名单无处作数,设了要说出来(S-699)。
- *    - 三只沙箱名单(e2b / local-docker / k8s 各一只) ⇒ honored:S-713 照录修前语义(任何姿态下都转发),S-715 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
+ *    - `LSP_ENV_ALLOW` ⇒ ignored:host 腿语言服务器在多租户姿态下本来就不起,名单无处作数,设了要说出来([ref])。
+ *    - 三只沙箱名单(e2b / local-docker / k8s 各一只) ⇒ honored:[ref] 照录修前语义(任何姿态下都转发),[ref] 主会话裁定维持 —— 沙箱 env 是部署方为隔离沙箱显式配的
  *      带外凭据(e2b / docker / k8s 车道本来就是多租户 fleet 的主形),与 LSP 那条「本机子进程」的形不同;多租户下起服说一句。
- *  · `BAKE_ENV_ALLOW`(S-684 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
+ *  · `BAKE_ENV_ALLOW`([ref] 残余,7.103.0)由 **bake-runner 进程**读(构建宿主守护进程:没有主体、没有租户 ⇒ 没有姿态列,
  *    不进 {@link describeAllowlistPostures} 的姿态句)。它与服务侧四只旋钮同一只解析器、同一只「点名放行」谓词、同一条「原文按凭据类」律。
  *  · `channel` = 这张名单**交给谁、在谁的减法之上**(闭集两词,解析器按它定「不许点哪些名」):
  *    - `host-put-back`(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)—— 剥后放回形:宿主子进程的 env 先经唯一组合(引擎扣掉本服务自有凭据 + 形状剥),
  *      名单点到的键再从本进程环境**原样**取回叠上去。点到本服务自有凭据名 = 把引擎刚扣下的那枚交回去 ⇒ 起服拒,判官 = 引擎同一只
  *      (`inheritEnvPolicyProblem`,读起服声明;与引擎拒嵌入方白名单同句)。
- *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据(S-715 照转发);
+ *    - `sandbox-grant`(三只沙箱名单)—— 沙箱 env 的唯一来源(沙箱不从本进程继承任何东西),部署方显式交出的带外凭据([ref] 照转发);
  *      本列不在「自有凭据」律的射程里,只拒点名名单型旋钮(原文按凭据类)。
  * 表是 `Record<旋钮, …>`:闭集加一只旋钮而不补行 = 编译红;行形随读它的进程定(服务进程 ⇒ 必须写姿态列)。
  *

package/dist/exec-bounds.d.ts

@@ -12,7 +12,7 @@
  * 是它报的那一界。
  *
  * 与 core 远端契约(`ExecStreamOptions.readTimeoutMs`:「缺省也 SHOULD 有活性界,一条命令不得等到环境死」)的对齐:
- * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令,在有活性界的车道(k8s / e2b)上仍由它兜底。**切断码按触发的那一界**(core 7.52.0 #1795:
+ * 说了墙钟的命令被墙钟兜住,不会无限等;两界都没说的命令,在有活性界的车道(k8s / e2b)上仍由它兜底。**切断码按触发的那一界**(core 7.52.0 [ref]:
  * 两套执行码闭集各有一词):墙钟 ⇒ `timeout`;静默界(调用方的 `readTimeoutMs` 或车道活性界)⇒ `liveness_no_output`,带窗口秒数 `noOutputSec`(车道的界 /
  * 调用方说的静默界,从不是请求的预算)—— 两者解释自己用的是两个数,消费方(core 的 Bash 工具:「no output for N s」对「timed out after N s」)按码分。
  * 静默切断的码、句、秒数只在 {@link buildLivenessCut} 一处铸,六车道同读。
@@ -68,7 +68,7 @@ export declare function firstBoundOf(bounds: CommandBounds): {
 } | undefined;
 /**
  * 🔴 **一次静默切断 —— 唯一铸点**(六条车道 host / e2b / k8s / ssh / adb / local-docker 同读;纯数据,车道用它构造自己那一型的错误):
- * 码恒为 `liveness_no_output`(core 7.52.0 #1795;墙钟切断照旧 `timeout`,不经本函数),句子 = {@link livenessCutMessage},`noOutputSec` = 静默窗口的整秒数
+ * 码恒为 `liveness_no_output`(core 7.52.0 [ref];墙钟切断照旧 `timeout`,不经本函数),句子 = {@link livenessCutMessage},`noOutputSec` = 静默窗口的整秒数
  * (core `ExecutionError` 第五构造参;core 读它时向下取整、不足 1 秒不说 —— 本函数同读:不足 1 秒的窗口不带这一位)。远端流式错误(`RemoteExecutionError`)没有这一位的座,只带码与句。
  */
 export declare function buildLivenessCut(bound: LivenessBound): {

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

@@ -14,7 +14,7 @@ export type ExecutionLane = "in-process" | RemoteExecProvider;
  * 所以坐标漂了(重命名/搬家/改语义)门会红,注释不会烂在这里。
  */
 export interface ExecutionLaneCaps {
-    /** 调用方送来的 `cwd` 是否被尊重。判别式:`task-cwd.ts` 的 `cwdHonored`。 */
+    /** 调用方送来的 `cwd` 是否被尊重。读者:部署形表行 `callerCwd`([ref] 起本位即判据;改前对账 `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,48 +26,49 @@ export interface ExecutionLaneCaps {
     /** LSP。判别式:`boot/execution-env.ts` 的 `lspManager` 两臂(沙箱桥 e2b/k8s;host 本地 NodeLspManager)。 */
     readonly lsp: LaneCapability;
     /** SendUserFile 的**沙箱直传腿**(host/in-process 的本机 fs 源是另一条腿,不是本位)。
-     *  判别式:`capabilities/sandbox-file-send.ts` 的 `sandboxSendLaneEnabled`。 */
+     *  读者:部署形表行 `sandboxSendUserFile`([ref] 起本位即判据;判定依据在 `capabilities/sandbox-file-send.ts` 头注)。 */
     readonly sandboxSendUserFile: LaneCapability;
     /**
      * OS 级隔离边界(手跑在容器 / microVM / Kata pod 里,而不是一台真机上)。
-     * 🔴 S-281 起**本位即判别式**:全仓读它的唯一布尔口是 {@link laneIsolated}(boot `remote_exec_enabled.isolated` 与
+     * 🔴 [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),**不是**「独立内核」强度。
-     * 另一根轴 `router/route-orchestration.ts` 的 `isIsolatedExecEnv`(A 值路由,只认 e2b 与 kata / gvisor 运行时,runc / local-docker
-     * fail-closed 判否)问的是 VM 级强度 —— 两个不同的问题,不是本位的第二份;收成一只会让其中一边答错(S-281 收车档登记)。
+     * VM 级强度(独立内核:只认 e2b 与 k8s 的 kata / gvisor 运行时,runc / local-docker fail-closed 判否)是**另一个问题、另一个词**:
+     * 部署形表行 `vmIsolatedHands`(A 值路由读它,路由上下文键 `vmIsolatedExecEnv`;[ref] 拆开同词异义)—— 不是本位的第二份。
      */
     readonly isolation: Exclude<LaneCapability, "single-user-only">;
-    /** 可挂起(k8s 以配了 `s3Snapshot` 为前提 —— 「结构上能不能」的口径)。判别式:同上的 `suspendable`。 */
+    /** 可挂起(k8s 以配了 `s3Snapshot` 为前提 —— 「结构上能不能」的口径)。读者:部署形表行 `suspendableHands`(本位 ∧ k8s 快照店;
+     *  [ref] 起 boot `remote_exec_enabled.suspendable` 只读那一行,不再手写车道词)。独立作者 = 各适配器的 `capabilities.suspendable`。 */
     readonly suspendable: LaneCapability;
-    /** `/tmp/scratchpad/<sessionId>` 远端约定。判别式:`plugins/remote-scratchpad.ts` 的 `isRemoteScratchpadLane`。 */
+    /** `/tmp/scratchpad/<sessionId>` 远端约定。读者:部署形表行 `remoteScratchpad`([ref] 起本位即判据;改前对账 `isRemoteScratchpadLane` 的 Set)。 */
     readonly remoteScratchpad: LaneCapability;
     /** 写门走 [ref] 的 `DeferredSandboxPathEnv` 代理裁决(而不是直接拿 worker 本机 fs 裁)。
-     *  判别式:`boot/deferred-sandbox-path-env.ts` 的 `isSandboxPathAdjudicationLane`。 */
+     *  判别式:部署形表行 `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`)。🔴 S-602 起**消费点读本位**,不再各写判别式
+    /** 文件平面是否就在 worker 本机(= `hostSemanticsLane`)。🔴 [ref] 起**消费点读本位**,不再各写判别式
      *  (改前 `resolve-spec` / `stores` / `memory-scope` / `deferred-sandbox-path-env` 各写一份
      *  `lane === undefined || lane === "host"` 的同义形,分叉过就是记忆边界判错盘)。读本位的真装配点:
-     *  `boot/deferred-sandbox-path-env.ts` 的 `isSandboxPathAdjudicationLane`(resolve-spec 写门 / parked 赎回腿 /
+     *  部署形表行 `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` 写指令撤不撤。🔴 S-602 起消费点读本位(改前各写 `config.remoteExec !== undefined`);
+     *  5.26.0 起它决定 `# Memory` 写指令撤不撤。🔴 [ref] 起消费点读本位(改前各写 `config.remoteExec !== undefined`);
      *  对账测试拿 core 自己的 `isRemoteExecutionEnv` 问**真 adapter 实例**来核本位的值。 */
     readonly coreRemoteExecutionEnv: LaneCapability;
     /**
-     * S-354 / core 7.20.0([ref]):这条车道的适配器**声明**了 `capabilities.canonicalPathAuthoritative`
+     * [ref] / core 7.20.0([ref]):这条车道的适配器**声明**了 `capabilities.canonicalPathAuthoritative`
      * 没有 —— 即「我的 `canonicalPath` 是路径落点的权威,整链答不出来是解析器出了事,不是一个我看不见的
      * 命名空间」。声明 ⇒ 读边界的执行期复核在解析器沉默时**拒**;缺席 ⇒ 今天每个适配器的读法(词法判决
      * 成立、命令照跑)—— **缺席不是「声明为 false」**,所以这一位的 `unsupported` 读作「本车道没表态」。
@@ -79,7 +80,7 @@ export interface ExecutionLaneCaps {
      */
     readonly canonicalPathAuthority: LaneCapability;
     /**
-     * 车PI 修复轮 ②(S-775 / clay C-R91A ②,主会话裁「按表不按词」;裁定语义 = **租户不共宿主**)—— 这条车道**分不分租户**。
+     * 车PI 修复轮 ②([ref] / clay C-R91A ②,主会话裁「按表不按词」;裁定语义 = **租户不共宿主**)—— 这条车道**分不分租户**。
      *  · `supported` = 每个租户的命令落在各自的目标上(每任务一只沙箱:e2b / k8s / local-docker;发起者自己的设备:device,
      *    归属由 deviceId↔principal 绑定验过),或根本没有手(in-process:没有可共享的执行目标);
      *  · `single-user-only` = 所有任务落在**同一个共享目标**上(worker 宿主:host;一台常驻 SSH 对端:ssh;一台 ADB 设备:adb)
@@ -88,7 +89,7 @@ export interface ExecutionLaneCaps {
      * 🔴 **7.114.0 起本位的值不在本仓写**:七条可声明车道读 settings-schema 词表正本的表行(`executionLaneRow(lane).tenantSeparation`;
      * 中心写闸的 `requirePrincipal ∧ single-user-only` 交叉判与本仓 `multi-tenant-shared-lane` 拒启读的是同一个值,不会分叉);
      * 只有 `in-process` 一格是本仓自己的事实(它不在表里)。
-     * 唯一消费点是 `config-invariants.ts` 的 `multi-tenant-shared-lane`(经 {@link laneCapabilityHolds} 落成布尔)。本位值与本仓**运行期事实**
+     * 唯一消费点是 `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`
      * (两个租户的任务铸出的 env 报同一个 `workspaceHandle().sandboxId`)。
@@ -101,7 +102,7 @@ export interface ExecutionLaneCaps {
  * device 行的表态来自 v2 §4.1/§4.3:
  *  · `callerCwd: supported` —— 员工在自己设备的项目目录里干活是这条车道的**存在理由**;host 闸防的
  *    「跨租户宿主路径穿越」在此结构性不存在(路径落在发起者自己的设备上,归属已由 deviceId↔principal
- *    绑定验证),故不要求单用户。今天 `cwdHonored` 还答 false ⇒ 登记在 {@link PLANNED_LANE_DIVERGENCES}。
+ *    绑定验证),故不要求单用户。(车A-4 前判别式答 false、登记过 {@link PLANNED_LANE_DIVERGENCES},已销行;[ref] 起部署形表行 `callerCwd` 直接读本位。)
  *  · `sandboxPathAdjudication: supported` —— 自动判真且**这是深思后的正确默认**:写门经 [ref] 代理把四读
  *    原语转发到设备取真文件系统事实,云盘永不参与设备写目标的裁决。
  *  · `remoteScratchpad: supported` —— executor 平台闭集 = darwin|linux,`/tmp/scratchpad/<sessionId>`
@@ -124,7 +125,7 @@ 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`(**就用它本人**,身份相等有钉 —— S-426 修过「目录手抄一份词表」的病)、
+ * 读者:配置目录 `REMOTE_EXEC` 行的 `enumValues`(**就用它本人**,身份相等有钉 —— [ref] 修过「目录手抄一份词表」的病)、
  * [ref] 拒启句的 `valid:` 列表、`REQUIRE_EXECUTION_LANE` 拒启句的出路、`multi-tenant-shared-lane` 拒启句的出路车道。
  * 7.114.0 起全仓唯一的车道词来源是正本;本常量只是它在本仓的那一个读口。
  */
@@ -139,10 +140,10 @@ export declare function executionLaneRow(lane: RemoteExecProvider): ExecutionLan
  */
 export declare function laneRequiredEnv(lane: RemoteExecProvider): readonly string[];
 /**
- * S-598 件③ / S-1008 —— **「`REQUIRE_EXECUTION_LANE=true` ∧ 没有任何车道被点名 ⇒ 拒启」的判据与拒因句的唯一属主**(`modelProviderRefusal` /
+ * [ref] 件③ / [ref] —— **「`REQUIRE_EXECUTION_LANE=true` ∧ 没有任何车道被点名 ⇒ 拒启」的判据与拒因句的唯一属主**(`modelProviderRefusal` /
  * `modelRouteEndpointRefusal` 同形:属主在叶模块,执法点各自调它,登记在 `config-invariants.ts`)。
  *
- * 🔴 病(S-1008,test d327-g6-engine-7112 OBS-4 / OBS-5;2026-10-03 亲核):修前**两份句子**。运行期真拒启的是 `config.ts` 手写 throw
+ * 🔴 病([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 里零命中)。
@@ -151,15 +152,15 @@ export declare function laneRequiredEnv(lane: RemoteExecProvider): readonly stri
  * 判据读**装配结果**(`executionLaneOf` = 全仓唯一的缺席归一读口,缺席 ⇒ `in-process`),不重判 env:`remoteExec` 缺席**就是**
  * 「`REMOTE_EXEC` 未设/空串 ∧ `CONFIG_PROVIDER ≠ local`」这条三元链尾臂的落点;点了名却配不齐 / 认不出归 [ref] 那条既有拒启(两句话各说各的问题)。
  *
- * 句子的量词纪律(S-1008 ②):stub 车道上**手带族**(`wiring_manifest.tools.entries[].mountedBy === "hands"`)整族不挂,名册里其余工具
- * 照常执行(test R1n:`Now` 真执行成功)—— 不写「零工具」;名册**总条数**随 core 版本走,不写进句子(S-1008 ③)。
+ * 句子的量词纪律([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` → 车道词。**全仓唯一**的缺席归一读口(S-602 门 D:`?? "in-process"` 只许住在这里,
+ * `config.remoteExec?.provider` → 车道词。**全仓唯一**的缺席归一读口([ref] 门 D:`?? "in-process"` 只许住在这里,
  * `?? "host"` 与 `lane === undefined || lane === "host"` 同义折零容忍)。
  *
  * · `undefined`(REMOTE_EXEC 未设)⇒ `"in-process"`,那是真车道不是缺席;
@@ -175,7 +176,7 @@ export declare function executionLaneRequiredRefusal(deployment: {
 export declare function executionLaneOf(provider: RemoteExecProvider | undefined): ExecutionLane;
 export declare function executionLaneOf(provider: string | undefined): ExecutionLane | undefined;
 /**
- * S-602 —— 「这条车道的**手**就在本 worker 的盘上吗」。**两位合取,都读表**(不手抄):
+ * [ref] —— 「这条车道的**手**就在本 worker 的盘上吗」。**两位合取,都读表**(不手抄):
  *  · `coreRemoteExecutionEnv` —— core 拿到了执行环境 = 手带真挂上(`in-process` 答 NO:core 落 `StubExecutionEnv`);
  *  · `hostFilePlane` —— 那套手的文件平面就是本 worker 的盘(沙箱 / 远端 / 设备车道答 NO)。
  * 今天只有 `host` 两位同 YES。
@@ -184,10 +185,10 @@ export declare function executionLaneOf(provider: string | undefined): Execution
  * **没有手**。clay 裁 [ref] ③ 的字面写「判据读 `hostFilePlane`」,意图是同一句的「无手不挂」—— 照字面
  * 实现会让无手部署**继续**挂 SendUserFile,与意图相反;本函数按意图实现(收车档 che-MA 写明)。
  *
- * 三个消费点问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
- *  ① `task-cwd.ts` 的 `toolsRunOnThisHost` —— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
- *  ② `boot/coordinators.ts` 的 SendUserFile 本机腿(经 ①;[ref] ③「无手不挂」);
- *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生。
+ * 读者问的都是这一句,**同一只函数**,不许各写一份 `=== "host"`:
+ *  ① 部署形表行 `toolsOnThisHost`(`deployment-shape.ts`)—— wire `executionLane.toolsOnThisHost` + 出厂自扫技能与中心 plugin 技能的 `baseDir`;
+ *  ② 部署形表行 `callerOwnsWorkerDisk`(本列 ∧ 单主)—— SendUserFile 本机腿([ref] ③「无手不挂」)、调用方宿主路径(附加目录 / 项目上下文)、指令文件探针;
+ *  ③ `approval.ts` 的 `buildNoResponderBootWarns` —— 写门的 ask 只在「有手写本机盘」时才会发生(它手里已有车道词,直接读本列)。
  */
 export declare function handsOnWorkerFilePlane(lane: ExecutionLane): boolean;
 /**
@@ -215,7 +216,7 @@ export declare function laneMeasuresHome(lane: ExecutionLane): boolean;
 /** 车道行声明的读面缺省(`READ_FACE` 缺席时,这条车道自己的那一份)。 */
 export type LaneReadFaceDefault = "open" | "roots";
 /**
- * S-1492(clay 裁 [ref])—— **车道行显式声明读面缺省 `readFaceDefault`**:`READ_FACE` 没人表态时,这条车道自己的执行体该不该读面放开。
+ * [ref](clay 裁 [ref])—— **车道行显式声明读面缺省 `readFaceDefault`**:`READ_FACE` 没人表态时,这条车道自己的执行体该不该读面放开。
  *  · `open` —— 隔离型车道(`e2b` / `k8s` / `local-docker`:每任务一只沙箱,OS 级隔离边界,`tenantSeparationBasis === "isolation"`):沙箱内部就是模型的整个世界,
  *    读面缺省放开(`auto` 连续干活不再每碰一个根外路径就出卡;写面 / deny 表 / 审批模式不受影响)。
  *  · `roots` —— 其余车道(`host` / `in-process` / `ssh` / `adb` / `device`):车道本身不给读面任何放开的理由 —— 手落在一台真机 / 共享目标 / 员工设备上。
@@ -230,7 +231,7 @@ export declare function laneReadFaceDefault(lane: ExecutionLane): LaneReadFaceDe
 /** 声明 `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";
 /**
- * S-281 —— 「这条车道的手在不在 OS 级隔离边界里」。**全仓唯一**的布尔判别式(读表 `isolation` 位,见该位头注的读者清单)。
+ * [ref] —— 「这条车道的手在不在 OS 级隔离边界里」。**全仓唯一**的布尔判别式(读表 `isolation` 位,见该位头注的读者清单)。
  * 穷举 switch、无 default 臂:`isolation` 的型只有两档,加档 = 编译红。
  *
  * ⚠️ 本函数对 `in-process` 也答(表上那一行是 unsupported ⇒ false)—— 那一格是「表」的完整性,不是 wire 的说法:
@@ -245,19 +246,6 @@ export declare function laneIsolated(lane: ExecutionLane): boolean;
  * 穷举 switch、无 default 臂:该位的型三档(supported / unsupported / single-user-only)都要表态,加档 = 编译红。
  */
 export declare function laneWiresExecutionEnv(lane: ExecutionLane): boolean;
-/**
- * S-281 —— 这条车道是不是**单机形缺省**落点(`REMOTE_EXEC` 未设 / 空串 ∧ `CONFIG_PROVIDER=local`,没人点名)。
- * 判据 = 装配出的车道值自己带的记号 `singleMachineDefault`(唯一写者 = `config.ts` 三元链的隐式 host 尾臂;显式 `REMOTE_EXEC=host`
- * 与 `config.d/remote-exec.json` 覆写都铸不带它的新值)。**唯一读口**,读者两处:`config.ts` 车道落点一行的 `source`
- * (`exec_lane_selected`,文件覆写之前播)与 `boot/execution-env.ts` 的 `remote_exec_real_system.note`(覆写之后打)——
- * 同一个记号、两个时刻,不另按 env 原文重判。
- */
-export declare function isSingleMachineDefaultLane(remoteExec: ServiceConfigFlat["remoteExec"]): boolean;
-/** 把一位能力在**具体部署**上落成布尔:租户面是唯一入参(旋钮由消费点自己再合取)。
- *  穷举 switch,无 default 臂 —— {@link LaneCapability} 加词而此处不加臂 = 编译红。 */
-export declare function laneCapabilityHolds(cap: LaneCapability, deployment: {
-    requirePrincipal?: boolean;
-}): boolean;
 /** 一条**已登记**的分叉:表写的是目标态,今天的判别式还答别的。 */
 export interface PlannedLaneDivergence {
     readonly lane: ExecutionLane;
@@ -272,7 +260,7 @@ export interface PlannedLaneDivergence {
  * 分叉登记簿 —— **闭集**。对账测试双向咬:表外分叉 = 漂移(红),表内分叉被补齐而不销行 = 陈账(红)。
  *
  * 🟢 **空表 = 今天的真实状态**(车A-4,2026-08-28 销行)。唯一那条(device 的 `callerCwd`)已按登记的
- * 条件补齐:`deviceCwdHonored`(`task-cwd.ts`)+ 写侧闸(`boot/resolve-spec.ts` 的同一处单写者)+ 读侧
+ * 条件补齐:当年的 `deviceCwdHonored`([ref] 起并入部署形表行 `callerCwd`,读本表那一位)+ 写侧闸(`boot/resolve-spec.ts` 的同一处单写者)+ 读侧
  * 消费(`plugins/remote-env-device.ts` 的 `effectiveDeviceCwd`)**同批**落地,于是能力表写的 `supported`
  * 与判别式给的答案一致,分叉自然消失 —— 对账测试的双向咬(表外分叉 = 红 / 表内陈账 = 红)因此对本表
  * 只剩「保持空」这一条要求。
@@ -301,7 +289,7 @@ export interface LaneHomeDeployment {
 /**
  * 「**这条部署的执行环境**以哪个 home 运行」—— `~/…` 形权限规则(`Edit(~/.ssh/**)`)唯一的基。
  *
- * ## 病(接入审计 M13 / DEBTS S-213④)
+ * ## 病(接入审计 M13 / DEBTS [ref]④)
  * core 的 `ExecutionEnv.homeDir` 是**由 adapter 声明**的座(`engine/harness/types.d.ts`,可选):
  * 缺席 ⇒ core 的 `resolvePathPattern` 回 `{missingBase:"home"}` ⇒ 该规则对这条腿判 `unreadable`
  * (fail-closed 的 ask)。四只远端 adapter(e2b/k8s/host/ssh)一个都没声明,而 server 侧的 422 前置门