@sema-agent/settings-schema 17.1.0 → 18.0.0

package/dist/env-model-table.js

@@ -5,7 +5,7 @@
  * ## 律
  *  · **env 两槽只在这里读一次**({@link readEnvModelSlots}):`MODEL_ID` 缺席或空串 = 没有主槽(纯空白算在场 —— 与引擎的 env 路由读口同尺);
  *    cheap 槽四态({@link EnvCheapSlot})。「env 模型表已声明」({@link envModelTableDeclared})与角色底({@link buildEnvModelBaseline})都由它派生 ——
- *    这道闸的执行方(引擎一侧;今天引擎还不强制)与写者的计划助手调同一份(一次性迁移 SS-M11 只用两槽点名被顶替的 env 模型,铸不铸不看它),不各写一份。env 快照按「读到即算」(下标读;原型分层的快照里继承来的键算在场)。
+ *    这道闸的执行方(服务端的本地配置腿)与写者的计划助手调同一份(一次性迁移 SS-M11 只用两槽点名被顶替的 env 模型,铸不铸不看它),不各写一份。env 快照按「读到即算」(下标读;原型分层的快照里继承来的键算在场)。
  *    引擎另有「名册占位 ⇒ env 表算空」一格,那是引擎自己的部署事实,不在本包。
  *  · **计划助手判序**({@link planEnvModelTableWrite}):目标腿不读 `config.d`(remote / none)⇒ 照写 → 候选不管模型面 ⇒ 照写 →
  *    env 表未声明 ⇒ 照写、**不写确认** → 配置根的决定是 `replaced` ⇒ 照写 →
@@ -18,7 +18,7 @@
  *    读成未设、按角色回退链落下一级并说一次 —— 没有哪种读法因它拒组;它照样写在回执里(`dangles`),要确认的写法把它给用户看。
  */
 import { z } from "zod";
-import { entryEnabledFlag, catalogManagesModelPlane } from "./catalog-manages.js";
+import { catalogManagesModelPlane, isExplicitlyDisabledEntry } from "./catalog-manages.js";
 import { parseDomainSalvaged, isDisclosableIdentity, resolveActiveTiers, withheldNameToken } from "./config-fns.js";
 import { ENV_MODELS_DOCUMENT } from "./config-root-documents.js";
 import { resolveCatalogDefaultModel } from "./default-model.js";
@@ -128,7 +128,7 @@ function candidateView(candidate) {
     }
 }
 function buildReceipt(baseline, view, decision) {
-    const enabled = view.models.filter((m) => entryEnabledFlag(m) !== false).map((m) => ({ name: m.name, id: m.id }));
+    const enabled = view.models.filter((m) => !isExplicitlyDisabledEntry(m)).map((m) => ({ name: m.name, id: m.id }));
     const byName = new Map(enabled.map((e) => [e.name, e]));
     const tiers = resolveActiveTiers(view);
     /** 一个名采纳后落到哪条:经与引擎同一张档位展开(目录键先赢;env 底继承来的 `flash` 一类档位词按活跃组解)。 */

package/dist/execution-lanes.d.ts

@@ -1,6 +1,6 @@
 /**
- * 执行车道 + 存储后端的**词表正本**(7.0.0,M-R2 WorkerSpec 结构块)。纯数据常量,外加两只纯判官函数(退役车道词的拒句 `retiredLaneWordRefusal`、
- * 车道坐标的空白判官 `isBlankCoordinate`),零依赖(叶模块:本文件不 import 任何东西,`types.ts` 反过来引它)。
+ * 执行车道 + 存储后端的**词表正本**(7.0.0,M-R2 WorkerSpec 结构块)。纯数据常量,外加三只纯判官函数(退役车道词的拒句 `retiredLaneWordRefusal`、
+ * 车道坐标的空白判官 `isBlankCoordinate`、车道表合法性的唯一判官 `laneSetFlaws`〔18.0.0〕),零依赖(叶模块:本文件不 import 任何东西,`types.ts` 反过来引它)。
  *
  * ## 为什么在这里
  * 车道词、每条车道读哪些 env、哪条车道分租户、存储后端词 —— 这几张表以前在四处各抄一份(引擎的能力表、
@@ -12,8 +12,8 @@
  * 写闸与起服读同一张表 ⇒ 不会分叉。
  *
  * ## 行内容的出处(逐行抄自引擎真码,坐标 = server 7.112.0 树)
- *  · 车道词与次序:`src/execution-lane-caps.ts` `EXECUTION_LANE_WORDS`(:335)去掉 `in-process` =
- *    `REMOTE_EXEC_PROVIDER_WORDS`(:366)。次序照抄,于是引擎改派生之后,拒启句里的 `valid:` 列表与出路列表逐字不变。
+ *  · 车道词与次序:前七词抄自 `src/execution-lane-caps.ts` `REMOTE_EXEC_PROVIDER_WORDS`(:366)。次序照抄,于是引擎改派生之后,拒启句里的 `valid:` 列表与出路列表逐字不变。
+ *    `none`(18.0.0)尾插:它的出处就是本表(见下「`none`」一节),引擎提货本版后从本表派生词表与拒句。
  *  · `tenantSeparation`:同文件 `executionLaneCaps` 每臂的 `tenantSeparation` 位(:209 host / :230 e2b / :249 k8s /
  *    :269 ssh / :288 adb / :308 local-docker / :327 device)。`tenantSeparationBasis`(11.0.0):分租户的那几臂凭什么分 ——
  *    e2b / k8s / local-docker 每任务一只隔离目标(`isolation`),device 是发起者自己的设备(`principal-binding`)。
@@ -30,15 +30,22 @@
  *    收进车道栏会把它们保留成「k8s 专属」,别的车道就再也设不了快照对象存储。也**不收**臂外的适配器调参键
  *    (`HOST_BG_*` / `E2B_BG_*` / `K8S_BG_*` / `HOST_SHELL_PATH` …):它们不是车道坐标,照旧走 `env` 逃生口。
  *
+ * ## `none`:不给智能体的工具提供执行环境(18.0.0)
+ * 每个部署都点名自己的执行车道;没有执行环境的部署点名 `none` —— 这是一个声明,不是「没写车道」的副作用。用户面可观察的事实:
+ *  · 每个 run:工具的手不挂(两个执行环境座都缺席;引擎的装配清单报 hands 未挂、原因是没有执行环境);
+ *  · 部署级:执行车道读数是 `none`、工具不在本机执行、没有隔离读数;引擎能力表的 `none` 行除分租户外整排不支持;
+ *  · 分租户(依据 `no-execution-target`):没有执行目标,也就没有跨租户共享的目标;不挂在副本上(`singleReplica: false`);四栏 env 全空(没有要配的坐标与密钥);
+ *  · 只能独成一集:含依据为 `no-execution-target` 的车道的车道表恰好一项 —— 判官 {@link laneSetFlaws} 按依据列判(拒因 `not_alone`),不点名车道词。
+ * 不在它的射程内(各有自己的属主轴,不随车道):请求体里的 hook 命令条目与 stdio MCP 服务器条目在 worker 宿主上起进程,它们的闸是多租户姿态 / 锁键 / 合规档。
+ * 它取代引擎内部「没有声明车道」那个状态的名字 `in-process`(那从来不是可声明的词,本表也从未收过);引擎侧的改名随它提货本版的那一版。
+ *
  * ## 不在表里的词
- *  · `in-process`:引擎内部「没有 remoteExec」这个状态的名字,不是可声明的车道 —— 显式「无手」的 worker 在模型要用工具时
- *    仍回 completed + 零工具,就是那个病换了个合法名字。要无手 worker 先另立设计、定用户面行为再给词。
  *  · `remote-docker`:引擎有一只没接线的适配器工厂,但没有任何读点能把这个词变成一条在跑的车道
  *    (`REMOTE_EXEC=remote-docker` 起服即拒;远端 docker 守护进程今天的真形 = `local-docker` + `DOCKER_HOST`)。
  *    它在退役词墓碑 {@link RETIRED_LANE_WORDS} 里:读到即拒,拒句带出路。
  */
-/** 可声明的执行车道闭集(= 引擎 `REMOTE_EXEC` 收的词,逐字同序)。 */
-export declare const EXECUTION_LANE_WORDS: readonly ["host", "e2b", "k8s", "ssh", "adb", "local-docker", "device"];
+/** 可声明的执行车道闭集(= 引擎 `REMOTE_EXEC` 收的词,逐字同序;18.0.0 尾插 `none`)。 */
+export declare const EXECUTION_LANE_WORDS: readonly ["host", "e2b", "k8s", "ssh", "adb", "local-docker", "device", "none"];
 export type ExecutionLane = (typeof EXECUTION_LANE_WORDS)[number];
 /**
  * 已退役的车道**值** —— 墓碑(与退役 env 名的墓碑表 `RETIRED_ENVS` 同一条线:永久、只增不减、一跳 —— 去向恒是现行车道词)。
@@ -53,9 +60,10 @@ export declare function retiredLaneWordRefusal(word: unknown): string | undefine
  *  `supported` = 每个租户的命令落在各自的目标上;`single-user-only` = 所有任务落同一个共享目标 ⇒ 只许单用户 worker。 */
 export declare const TENANT_SEPARATION_WORDS: readonly ["supported", "single-user-only"];
 export type TenantSeparation = (typeof TENANT_SEPARATION_WORDS)[number];
-/** 分租户车道**凭什么**分租户(两档):`isolation` = 每个任务一只隔离的目标(microVM / pod / 容器);`principal-binding` = 目标绑在
- *  发起者身上(设备 ↔ principal 绑定),目标本身不隔离。只有 `tenantSeparation: "supported"` 的车道有依据。 */
-export declare const TENANT_SEPARATION_BASES: readonly ["isolation", "principal-binding"];
+/** 分租户车道**凭什么**分租户(三档):`isolation` = 每个任务一只隔离的目标(microVM / pod / 容器);`principal-binding` = 目标绑在
+ *  发起者身上(设备 ↔ principal 绑定),目标本身不隔离;`no-execution-target`(18.0.0)= 根本没有执行目标(工具没有执行环境),也就没有跨租户共享的目标 ——
+ *  这一档还带一条集合规则:含这档车道的车道表只能有它这一项(判官 {@link laneSetFlaws} 读这一列)。只有 `tenantSeparation: "supported"` 的车道有依据。 */
+export declare const TENANT_SEPARATION_BASES: readonly ["isolation", "principal-binding", "no-execution-target"];
 export type TenantSeparationBasis = (typeof TENANT_SEPARATION_BASES)[number];
 /** 车道的租户分离位与它的依据 —— 判别联合:分租户 ⇔ 依据在场(类型保证,不靠一句注释)。消费方的规则读依据列,不点名车道。 */
 export type LaneTenancy = {
@@ -78,6 +86,102 @@ export type ExecutionLaneRow = {
     readonly optionalEnv: readonly string[];
     readonly optionalSecretEnv: readonly string[];
 } & LaneTenancy;
+/** 逐车道一行。`satisfies Record<ExecutionLane, …>` = 词表加词而这里不加行 ⇒ 编译红。 */
+declare const LANE_ROWS: {
+    /** server `config.ts` :4014 臂(无必需键);`execution-lane-caps.ts` :209 `single-user-only`(所有任务落 worker 宿主)。 */
+    readonly host: {
+        readonly tenantSeparation: "single-user-only";
+        readonly singleReplica: true;
+        readonly requiredEnv: readonly [];
+        readonly requiredSecretEnv: readonly [];
+        readonly optionalEnv: readonly ["HOST_WORKSPACE_BASE", "HOST_COMMAND_TIMEOUT_MS"];
+        readonly optionalSecretEnv: readonly [];
+    };
+    /** server `config.ts` :3925 臂;`E2B_API_KEY` 目录 :351 类型 `secret`、`E2B_SANDBOX_ENV` :359 类型 `secret`;
+     *  `execution-lane-caps.ts` :230 `supported`(每任务一只 microVM)。 */
+    readonly e2b: {
+        readonly tenantSeparation: "supported";
+        readonly tenantSeparationBasis: "isolation";
+        readonly singleReplica: false;
+        readonly requiredEnv: readonly [];
+        readonly requiredSecretEnv: readonly ["E2B_API_KEY"];
+        readonly optionalEnv: readonly ["E2B_TEMPLATE", "E2B_TIMEOUT_MS", "E2B_LIVENESS_MS", "E2B_ALLOW_NET", "E2B_MOUNT_PATH", "E2B_ORPHAN_RECLAIM"];
+        readonly optionalSecretEnv: readonly ["E2B_SANDBOX_ENV"];
+    };
+    /** server `config.ts` :3957 臂;`K8S_TOKEN` 目录 :412 类型 `secret`、`K8S_CA_CERT_B64` :403 类型 `opaque`;
+     *  `execution-lane-caps.ts` :249 `supported`(每任务一只 pod)。`MINIO_*` 刻意不收(见文件头)。
+     *  `K8S_NAMESPACE`(沙箱 pod 所在的命名空间)是**必需**坐标:pod 住哪是部署自己的声明,表不替它留缺省;服务端的必需 env 门按本行 `requiredEnv` 拒启,
+     *  所以这里没有「可选」一说。 */
+    readonly k8s: {
+        readonly tenantSeparation: "supported";
+        readonly tenantSeparationBasis: "isolation";
+        readonly singleReplica: false;
+        readonly requiredEnv: readonly ["K8S_SANDBOX_IMAGE", "K8S_NAMESPACE"];
+        readonly requiredSecretEnv: readonly [];
+        readonly optionalEnv: readonly ["K8S_API_URL", "K8S_INSECURE_TLS", "K8S_RUNTIME_CLASS", "K8S_MOUNT_PATH", "K8S_TIMEOUT_MS", "K8S_MEMORY", "K8S_CPU", "WORKSPACE_SNAPSHOT_BUCKET", "WORKSPACE_SNAPSHOT_PREFIX", "WORKSPACE_SNAPSHOT_TTL_SEC"];
+        readonly optionalSecretEnv: readonly ["K8S_TOKEN", "K8S_CA_CERT_B64"];
+    };
+    /** server `config.ts` :3991 臂 + `parseSshHostKeyEnv` :1521;`SSH_PRIVATE_KEY` 目录 :687 类型 `secret`;
+     *  `execution-lane-caps.ts` :269 `single-user-only`(一台跨任务共享的常驻真机)。 */
+    readonly ssh: {
+        readonly tenantSeparation: "single-user-only";
+        readonly singleReplica: false;
+        readonly requiredEnv: readonly ["SSH_HOST", "SSH_USER"];
+        readonly requiredSecretEnv: readonly ["SSH_PRIVATE_KEY"];
+        readonly optionalEnv: readonly ["SSH_PORT", "SSH_MOUNT_PATH", "SSH_HOST_FINGERPRINT", "SSH_KNOWN_HOSTS"];
+        readonly optionalSecretEnv: readonly [];
+    };
+    /** server `config.ts` :4006 臂;`execution-lane-caps.ts` :288 `single-user-only`(一台跨任务共享的设备)。 */
+    readonly adb: {
+        readonly tenantSeparation: "single-user-only";
+        readonly singleReplica: false;
+        readonly requiredEnv: readonly ["ADB_SERIAL"];
+        readonly requiredSecretEnv: readonly [];
+        readonly optionalEnv: readonly ["ADB_PATH", "ADB_MOUNT_PATH"];
+        readonly optionalSecretEnv: readonly [];
+    };
+    /** server `config.ts` :4026 臂;`DOCKER_SANDBOX_ENV` 目录 :345 类型 `secret`;`execution-lane-caps.ts` :308 `supported`
+     *  (每任务一只容器)。`DOCKER_HOST` 在本行:远端 docker 守护进程 = 本车道 + `coords.DOCKER_HOST`。 */
+    readonly "local-docker": {
+        readonly tenantSeparation: "supported";
+        readonly tenantSeparationBasis: "isolation";
+        readonly singleReplica: false;
+        readonly requiredEnv: readonly ["DOCKER_IMAGE"];
+        readonly requiredSecretEnv: readonly [];
+        readonly optionalEnv: readonly ["DOCKER_MOUNT_PATH", "DOCKER_PATH", "DOCKER_HOST", "DOCKER_MEMORY", "DOCKER_CPUS", "DOCKER_PIDS_LIMIT", "DOCKER_DROP_CAPS", "DOCKER_NETWORK", "DOCKER_COMMAND_TIMEOUT_MS"];
+        readonly optionalSecretEnv: readonly ["DOCKER_SANDBOX_ENV"];
+    };
+    /** server `config.ts` :4055 臂 + `parseDevicePreAuthPerRemoteEnv` :871 / `parseDeviceEnrollTokenTtlEnv` :857;`execution-lane-caps.ts` :327
+     *  `supported`(发起者自己的设备)。16.0.0:`DEVICE_RELAY_URL`(设备拨哪里)是**必需**坐标 —— 引擎的 device 臂缺它即拒启
+     *  (`parseDeviceRelayUrlEnv`;此前它是 device 臂读而本表漏登记的键),值只有两种:ws(s) 绝对 URL 或字面 `none`(值的文法见 `./device-relay`)。
+     *  17.1.0:`DEVICE_TRUSTED_PROXY_CIDRS`(可选)= 设备 WS 未鉴权握手 per-remote 帽键的可信代理名单(CIDR 闭集,缺省空 = 不读任何代理头);值文法由引擎起服判。 */
+    readonly device: {
+        readonly tenantSeparation: "supported";
+        readonly tenantSeparationBasis: "principal-binding";
+        readonly singleReplica: true;
+        readonly requiredEnv: readonly ["DEVICE_RELAY_URL"];
+        readonly requiredSecretEnv: readonly [];
+        readonly optionalEnv: readonly ["DEVICE_DELIVERY_TIMEOUT_MS", "DEVICE_RECONNECT_GRACE_MS", "DEVICE_EXEC_TIMEOUT_MS", "DEVICE_MAX_INFLIGHT_PER_DEVICE", "DEVICE_MAX_PREAUTH_PER_REMOTE", "DEVICE_ENROLL_TOKEN_TTL_SEC", "DEVICE_TRUSTED_PROXY_CIDRS", "DEVICE_SUPERSEDE"];
+        readonly optionalSecretEnv: readonly [];
+    };
+    /** 18.0.0:没有执行环境(见文件头「`none`」一节)。分租户,依据 `no-execution-target`(没有执行目标,就没有跨租户共享的目标);不挂在副本上;
+     *  四栏全空(没有要配的坐标与密钥)。本行先于引擎:引擎提货本版后它的能力表 / 必需键门 / 拒句从本行派生。 */
+    readonly none: {
+        readonly tenantSeparation: "supported";
+        readonly tenantSeparationBasis: "no-execution-target";
+        readonly singleReplica: false;
+        readonly requiredEnv: readonly [];
+        readonly requiredSecretEnv: readonly [];
+        readonly optionalEnv: readonly [];
+        readonly optionalSecretEnv: readonly [];
+    };
+};
+/** 依据为 `no-execution-target` 的车道(型从表行的依据列派生,不点名车道词;今天 = `none`):声明了它的车道表只能有它这一项。 */
+export type StandaloneLane = {
+    [L in ExecutionLane]: (typeof LANE_ROWS)[L] extends {
+        readonly tenantSeparationBasis: "no-execution-target";
+    } ? L : never;
+}[ExecutionLane];
 /** 车道表(次序 = {@link EXECUTION_LANE_WORDS})。整张表深冻结 —— 它是唯一正本,消费方拿到的不许被改。 */
 export declare const EXECUTION_LANES: readonly ExecutionLaneRow[];
 /**
@@ -90,6 +194,48 @@ export declare const EXECUTION_LANES: readonly ExecutionLaneRow[];
  * 车道表的派生索引与写闸也从这里 import,全包只有这一处函数体。
  */
 export declare function isBlankCoordinate(value: string): boolean;
+/**
+ * 一张车道表**不合法**的拒因 —— 闭集,判别字段 `kind`(消费方穷举 `switch`:加一种拒因 ⇒ 消费方编译红,不会静默落进「别的」)。`at` = 那一项在表里的下标(从 0 起)。
+ *  · `empty_set`:表是空的(一项都没有);
+ *  · `blank_entry`:那一项是空串或只含空白(判官 {@link isBlankCoordinate});
+ *  · `unknown`:那一项不是车道词({@link EXECUTION_LANE_WORDS};逐字比:不 trim、不折大小写),也不是车道值墓碑里的旧词 —— 包括根本不是字符串的项(数、`null`、对象 …:
+ *    读 JSON 的写闸会见到;`word` 是那一项的原值,判官只比较、不读它的任何属性,渲染给人看时由调用方自己描述它的形);
+ *  · `retired`:那一项是车道值墓碑 {@link RETIRED_LANE_WORDS} 里的旧词(出路取 {@link retiredLaneWordRefusal},一句);
+ *  · `duplicate`:那一项是车道词,但表里更早已经有它了(报在第二次及以后出现的那一格;不是车道词的重复不报这一条 —— 它们各自已是拒因);
+ *  · `not_alone`(18.0.0):表里有独占车道({@link StandaloneLane},依据列为 `no-execution-target`),却还有不是它的项 —— 独占车道只能独成一集。
+ *    这是整张表的拒因(没有 `at`);独占车道自己的重复只报 `duplicate`。
+ */
+export type LaneSetFlaw = {
+    readonly kind: "empty_set";
+} | {
+    readonly kind: "blank_entry";
+    readonly at: number;
+} | {
+    readonly kind: "unknown";
+    readonly at: number;
+    readonly word: unknown;
+} | {
+    readonly kind: "retired";
+    readonly at: number;
+    readonly word: string;
+} | {
+    readonly kind: "duplicate";
+    readonly at: number;
+    readonly lane: ExecutionLane;
+} | {
+    readonly kind: "not_alone";
+    readonly lane: StandaloneLane;
+};
+/** 车道表的规则句(不含值,与 `DEVICE_RELAY_RULE` 同形):写闸的拒句、引擎的拒启句、表单的提示读这一句,句子只在这里写。 */
+export declare const LANE_SET_RULE: string;
+/**
+ * 车道表合不合法的**唯一判官**:合法 ⇒ `[]`;否则按表的次序交回每一条拒因({@link LaneSetFlaw})。纯函数,不抛。
+ * 谁问它:写闸(`WorkerSpec` 的 `runtime.execution.lanes`)逐条映射成 issue;引擎把 `REMOTE_EXEC` 按逗号切段后交给它(引擎只留切段);web-admin 表单同问。
+ * 入参是任意值的表(读 JSON 的写闸原样交进来;引擎切段后交的是字符串):不是字符串的项不是车道词 ⇒ `unknown`,与写错的词同一条拒因 —— 「每一项都是车道词」只有这一处判。
+ * 按下标读(`0 … length-1`):稀疏表的空洞读成 `undefined`,是一项不是字符串的项 —— 与写闸的下标快照同答(`forEach` / `some` 会跳过空洞)。
+ * 只判「这张表合不合法」;每条车道缺不缺必需坐标、本引擎版本服务不服务这条车道,是调用方各自的门。
+ */
+export declare function laneSetFlaws(lanes: readonly unknown[]): readonly LaneSetFlaw[];
 /** 存储后端(→ `DB_BACKEND`)。= server `src/config-types.ts` `DB_BACKEND_WORDS`(:67)逐字同序。 */
 export declare const STORE_BACKENDS: readonly ["mysql", "pg", "local", "memory"];
 export type StoreBackend = (typeof STORE_BACKENDS)[number];
@@ -101,3 +247,4 @@ export type SessionBackend = (typeof SESSION_BACKENDS)[number];
  *  收成一个字,与 {@link STORE_BACKENDS} 同字;硬破坏,`tidb` 读写两面拒、指路一次性迁移 SS-M12)。次序 file → pg → mysql。 */
 export declare const MEMORY_ENGINE_BACKENDS: readonly ["file", "pg", "mysql"];
 export type MemoryEngineBackend = (typeof MEMORY_ENGINE_BACKENDS)[number];
+export {};

package/dist/execution-lanes.js

@@ -1,6 +1,6 @@
 /**
- * 执行车道 + 存储后端的**词表正本**(7.0.0,M-R2 WorkerSpec 结构块)。纯数据常量,外加两只纯判官函数(退役车道词的拒句 `retiredLaneWordRefusal`、
- * 车道坐标的空白判官 `isBlankCoordinate`),零依赖(叶模块:本文件不 import 任何东西,`types.ts` 反过来引它)。
+ * 执行车道 + 存储后端的**词表正本**(7.0.0,M-R2 WorkerSpec 结构块)。纯数据常量,外加三只纯判官函数(退役车道词的拒句 `retiredLaneWordRefusal`、
+ * 车道坐标的空白判官 `isBlankCoordinate`、车道表合法性的唯一判官 `laneSetFlaws`〔18.0.0〕),零依赖(叶模块:本文件不 import 任何东西,`types.ts` 反过来引它)。
  *
  * ## 为什么在这里
  * 车道词、每条车道读哪些 env、哪条车道分租户、存储后端词 —— 这几张表以前在四处各抄一份(引擎的能力表、
@@ -12,8 +12,8 @@
  * 写闸与起服读同一张表 ⇒ 不会分叉。
  *
  * ## 行内容的出处(逐行抄自引擎真码,坐标 = server 7.112.0 树)
- *  · 车道词与次序:`src/execution-lane-caps.ts` `EXECUTION_LANE_WORDS`(:335)去掉 `in-process` =
- *    `REMOTE_EXEC_PROVIDER_WORDS`(:366)。次序照抄,于是引擎改派生之后,拒启句里的 `valid:` 列表与出路列表逐字不变。
+ *  · 车道词与次序:前七词抄自 `src/execution-lane-caps.ts` `REMOTE_EXEC_PROVIDER_WORDS`(:366)。次序照抄,于是引擎改派生之后,拒启句里的 `valid:` 列表与出路列表逐字不变。
+ *    `none`(18.0.0)尾插:它的出处就是本表(见下「`none`」一节),引擎提货本版后从本表派生词表与拒句。
  *  · `tenantSeparation`:同文件 `executionLaneCaps` 每臂的 `tenantSeparation` 位(:209 host / :230 e2b / :249 k8s /
  *    :269 ssh / :288 adb / :308 local-docker / :327 device)。`tenantSeparationBasis`(11.0.0):分租户的那几臂凭什么分 ——
  *    e2b / k8s / local-docker 每任务一只隔离目标(`isolation`),device 是发起者自己的设备(`principal-binding`)。
@@ -30,15 +30,22 @@
  *    收进车道栏会把它们保留成「k8s 专属」,别的车道就再也设不了快照对象存储。也**不收**臂外的适配器调参键
  *    (`HOST_BG_*` / `E2B_BG_*` / `K8S_BG_*` / `HOST_SHELL_PATH` …):它们不是车道坐标,照旧走 `env` 逃生口。
  *
+ * ## `none`:不给智能体的工具提供执行环境(18.0.0)
+ * 每个部署都点名自己的执行车道;没有执行环境的部署点名 `none` —— 这是一个声明,不是「没写车道」的副作用。用户面可观察的事实:
+ *  · 每个 run:工具的手不挂(两个执行环境座都缺席;引擎的装配清单报 hands 未挂、原因是没有执行环境);
+ *  · 部署级:执行车道读数是 `none`、工具不在本机执行、没有隔离读数;引擎能力表的 `none` 行除分租户外整排不支持;
+ *  · 分租户(依据 `no-execution-target`):没有执行目标,也就没有跨租户共享的目标;不挂在副本上(`singleReplica: false`);四栏 env 全空(没有要配的坐标与密钥);
+ *  · 只能独成一集:含依据为 `no-execution-target` 的车道的车道表恰好一项 —— 判官 {@link laneSetFlaws} 按依据列判(拒因 `not_alone`),不点名车道词。
+ * 不在它的射程内(各有自己的属主轴,不随车道):请求体里的 hook 命令条目与 stdio MCP 服务器条目在 worker 宿主上起进程,它们的闸是多租户姿态 / 锁键 / 合规档。
+ * 它取代引擎内部「没有声明车道」那个状态的名字 `in-process`(那从来不是可声明的词,本表也从未收过);引擎侧的改名随它提货本版的那一版。
+ *
  * ## 不在表里的词
- *  · `in-process`:引擎内部「没有 remoteExec」这个状态的名字,不是可声明的车道 —— 显式「无手」的 worker 在模型要用工具时
- *    仍回 completed + 零工具,就是那个病换了个合法名字。要无手 worker 先另立设计、定用户面行为再给词。
  *  · `remote-docker`:引擎有一只没接线的适配器工厂,但没有任何读点能把这个词变成一条在跑的车道
  *    (`REMOTE_EXEC=remote-docker` 起服即拒;远端 docker 守护进程今天的真形 = `local-docker` + `DOCKER_HOST`)。
  *    它在退役词墓碑 {@link RETIRED_LANE_WORDS} 里:读到即拒,拒句带出路。
  */
-/** 可声明的执行车道闭集(= 引擎 `REMOTE_EXEC` 收的词,逐字同序)。 */
-export const EXECUTION_LANE_WORDS = ["host", "e2b", "k8s", "ssh", "adb", "local-docker", "device"];
+/** 可声明的执行车道闭集(= 引擎 `REMOTE_EXEC` 收的词,逐字同序;18.0.0 尾插 `none`)。 */
+export const EXECUTION_LANE_WORDS = ["host", "e2b", "k8s", "ssh", "adb", "local-docker", "device", "none"];
 export const RETIRED_LANE_WORDS = Object.freeze([
     Object.freeze(["remote-docker", "local-docker", "point it at the remote docker daemon with DOCKER_HOST (in a worker spec: runtime.execution.coords.DOCKER_HOST)"]),
 ]);
@@ -50,9 +57,10 @@ export function retiredLaneWordRefusal(word) {
 /** 车道分不分租户(引擎能力表的 `tenantSeparation` 位,两档,没有「不表态」)。
  *  `supported` = 每个租户的命令落在各自的目标上;`single-user-only` = 所有任务落同一个共享目标 ⇒ 只许单用户 worker。 */
 export const TENANT_SEPARATION_WORDS = ["supported", "single-user-only"];
-/** 分租户车道**凭什么**分租户(两档):`isolation` = 每个任务一只隔离的目标(microVM / pod / 容器);`principal-binding` = 目标绑在
- *  发起者身上(设备 ↔ principal 绑定),目标本身不隔离。只有 `tenantSeparation: "supported"` 的车道有依据。 */
-export const TENANT_SEPARATION_BASES = ["isolation", "principal-binding"];
+/** 分租户车道**凭什么**分租户(三档):`isolation` = 每个任务一只隔离的目标(microVM / pod / 容器);`principal-binding` = 目标绑在
+ *  发起者身上(设备 ↔ principal 绑定),目标本身不隔离;`no-execution-target`(18.0.0)= 根本没有执行目标(工具没有执行环境),也就没有跨租户共享的目标 ——
+ *  这一档还带一条集合规则:含这档车道的车道表只能有它这一项(判官 {@link laneSetFlaws} 读这一列)。只有 `tenantSeparation: "supported"` 的车道有依据。 */
+export const TENANT_SEPARATION_BASES = ["isolation", "principal-binding", "no-execution-target"];
 /** 逐车道一行。`satisfies Record<ExecutionLane, …>` = 词表加词而这里不加行 ⇒ 编译红。 */
 const LANE_ROWS = {
     /** server `config.ts` :4014 臂(无必需键);`execution-lane-caps.ts` :209 `single-user-only`(所有任务落 worker 宿主)。 */
@@ -161,7 +169,25 @@ const LANE_ROWS = {
         ],
         optionalSecretEnv: [],
     },
+    /** 18.0.0:没有执行环境(见文件头「`none`」一节)。分租户,依据 `no-execution-target`(没有执行目标,就没有跨租户共享的目标);不挂在副本上;
+     *  四栏全空(没有要配的坐标与密钥)。本行先于引擎:引擎提货本版后它的能力表 / 必需键门 / 拒句从本行派生。 */
+    none: {
+        tenantSeparation: "supported",
+        tenantSeparationBasis: "no-execution-target",
+        singleReplica: false,
+        requiredEnv: [],
+        requiredSecretEnv: [],
+        optionalEnv: [],
+        optionalSecretEnv: [],
+    },
 };
+/** 一条车道是不是独占车道 —— 读表行的依据列(运行期判据与 {@link StandaloneLane} 的型读同一列)。 */
+function isStandaloneLane(lane) {
+    const row = LANE_ROWS[lane];
+    return row.tenantSeparation === "supported" && row.tenantSeparationBasis === "no-execution-target";
+}
+/** 独占车道,按词表次序(从依据列现算)。 */
+const STANDALONE_LANES = EXECUTION_LANE_WORDS.filter(isStandaloneLane);
 /** 车道表(次序 = {@link EXECUTION_LANE_WORDS})。整张表深冻结 —— 它是唯一正本,消费方拿到的不许被改。 */
 export const EXECUTION_LANES = Object.freeze(EXECUTION_LANE_WORDS.map((lane) => {
     const row = LANE_ROWS[lane];
@@ -188,6 +214,45 @@ export const EXECUTION_LANES = Object.freeze(EXECUTION_LANE_WORDS.map((lane) =>
 export function isBlankCoordinate(value) {
     return value.trim() === "";
 }
+/** 车道表的规则句(不含值,与 `DEVICE_RELAY_RULE` 同形):写闸的拒句、引擎的拒启句、表单的提示读这一句,句子只在这里写。 */
+export const LANE_SET_RULE = `must be a non-empty list — the ordered execution lane set (the first one is the default) of ${EXECUTION_LANE_WORDS.join(" | ")}, each at most once; a lane set with no execution environment for the agent's tools is ${STANDALONE_LANES.map((lane) => `[${JSON.stringify(lane)}]`).join(" or ")}, alone`;
+/**
+ * 车道表合不合法的**唯一判官**:合法 ⇒ `[]`;否则按表的次序交回每一条拒因({@link LaneSetFlaw})。纯函数,不抛。
+ * 谁问它:写闸(`WorkerSpec` 的 `runtime.execution.lanes`)逐条映射成 issue;引擎把 `REMOTE_EXEC` 按逗号切段后交给它(引擎只留切段);web-admin 表单同问。
+ * 入参是任意值的表(读 JSON 的写闸原样交进来;引擎切段后交的是字符串):不是字符串的项不是车道词 ⇒ `unknown`,与写错的词同一条拒因 —— 「每一项都是车道词」只有这一处判。
+ * 按下标读(`0 … length-1`):稀疏表的空洞读成 `undefined`,是一项不是字符串的项 —— 与写闸的下标快照同答(`forEach` / `some` 会跳过空洞)。
+ * 只判「这张表合不合法」;每条车道缺不缺必需坐标、本引擎版本服务不服务这条车道,是调用方各自的门。
+ */
+export function laneSetFlaws(lanes) {
+    if (lanes.length === 0)
+        return [{ kind: "empty_set" }];
+    const flaws = [];
+    const seen = [];
+    const entries = Array.from({ length: lanes.length }, (_, at) => lanes[at]); // 按下标:空洞 ⇒ undefined(见上)
+    for (const [at, entry] of entries.entries()) {
+        if (typeof entry !== "string") {
+            flaws.push({ kind: "unknown", at, word: entry }); // 不是字符串:不是车道词(不读它的属性)
+            continue;
+        }
+        if (isBlankCoordinate(entry)) {
+            flaws.push({ kind: "blank_entry", at });
+            continue;
+        }
+        const lane = EXECUTION_LANE_WORDS.find((w) => w === entry); // 裸比较让编译器收窄(不把开放串断言成闭集词)
+        if (lane !== undefined) {
+            if (seen.includes(lane))
+                flaws.push({ kind: "duplicate", at, lane });
+            else
+                seen.push(lane);
+            continue;
+        }
+        flaws.push(retiredLaneWordRefusal(entry) === undefined ? { kind: "unknown", at, word: entry } : { kind: "retired", at, word: entry });
+    }
+    for (const lane of STANDALONE_LANES)
+        if (seen.includes(lane) && entries.some((entry) => entry !== lane))
+            flaws.push({ kind: "not_alone", lane });
+    return flaws;
+}
 /** 存储后端(→ `DB_BACKEND`)。= server `src/config-types.ts` `DB_BACKEND_WORDS`(:67)逐字同序。 */
 export const STORE_BACKENDS = ["mysql", "pg", "local", "memory"];
 /** session 店(→ `SESSION_BACKEND`)。= server `src/config.ts` :1760 `enumEnv("SESSION_BACKEND", …)` 的词表逐字同序

package/dist/file-edit.d.ts

@@ -30,7 +30,7 @@ export interface RequiredEnvName {
     /** true if this env-NAME resolves in the supplied environment (.env merged over process.env). */
     present: boolean;
 }
-/** LIST every env-NAME the current local config requires (across models/workers/mcp + the
+/** LIST every env-NAME the current local config requires (across models/workers/mcp/a2a + the
  *  remote-exec backend), marking which are MISSING from the resolved env — the TOC "you still need to set
  *  these secrets" panel. Reuses collectEnvRefs for the domain side, then appends the remoteExec secret refs. */
 export declare function listRequiredEnvNames(eff: EffectiveConfig, remoteExec: RemoteExecSpec | undefined, resolvedEnv: Record<string, string | undefined>): RequiredEnvName[];

package/dist/file-edit.js

@@ -69,7 +69,7 @@ export async function writeDomainFile(root, domain, value) {
     writeFileAtomic(path.join(dir, `${domain}.json`), configDDocumentText(parsed), "config-document");
     return parsed;
 }
-/** LIST every env-NAME the current local config requires (across models/workers/mcp + the
+/** LIST every env-NAME the current local config requires (across models/workers/mcp/a2a + the
  *  remote-exec backend), marking which are MISSING from the resolved env — the TOC "you still need to set
  *  these secrets" panel. Reuses collectEnvRefs for the domain side, then appends the remoteExec secret refs. */
 export function listRequiredEnvNames(eff, remoteExec, resolvedEnv) {
@@ -108,6 +108,7 @@ export function listRequiredEnvNames(eff, remoteExec, resolvedEnv) {
             case "adb":
             case "host":
             case "local-docker":
+            case "none":
                 break; // these carry no secret env-NAME refs
             default: {
                 const unhandled = re;

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export * from "./url-shape.js";
 export * from "./device-relay.js";
 export * from "./url-credential.js";
 export * from "./default-model.js";
-export { catalogManagesModelPlane, enabledEntryCount } from "./catalog-manages.js";
+export { catalogManagesModelPlane, enabledEntryCount, isExplicitlyDisabledEntry } from "./catalog-manages.js";
 export { DEFAULT_MODEL_KEY, ENV_MODEL_TABLE_KEYS, buildEnvModelBaseline, envModelTableDeclared, envModelTableWriteRefusal, mintedCheapId, planEnvModelTableWrite, readEnvModelSlots, type EnvCheapSlot, type EnvModelBaseline, type EnvModelTableEntry, type EnvModelTableKey, type EnvModelTableLanding, type EnvModelTableReceipt, type EnvModelTableRoleRow, type EnvModelTableTarget, type EnvModelTableWriteInput, type EnvModelTableWriteIntent, type EnvModelTableWritePlan, type EnvRoleBinding, type EnvSnapshot, } from "./env-model-table.js";
 export { CONFIG_ROOT_DOCUMENTS, ENV_MODELS_DECISIONS, ENV_MODELS_DOCUMENT, ROOT_DOCUMENT_UNREADABLE_REASONS, envModelsDecisionTag, type ConfigRootDocument, type EnvModelsDecision, type EnvModelsDecisionWord, type MarkedMigrationId, type MigrationMarker, type RootDocumentUnreadableReason } from "./config-root-documents.js";
 export * from "./loopback.js";

package/dist/index.js

@@ -9,7 +9,7 @@ export * from "./url-shape.js"; // 11.0.0: THE URL shape judge (httpUrlFlaws / h
 export * from "./device-relay.js"; // 16.0.0: THE value grammar of the device lane's DEVICE_RELAY_URL (DEVICE_RELAY_NONE / deviceRelayFlaws / DEVICE_RELAY_RULE), pure/browser-safe
 export * from "./url-credential.js"; // 14.5.0: THE "does this URL carry a credential" judge (findUrlCredential / findUrlUserinfo / URL_CREDENTIAL_REASONS / CREDENTIAL_PARAM_NAMES …), pure/browser-safe
 export * from "./default-model.js"; // 11.0.0: THE catalog-default resolver (roles.default → active tier ladder → fallback), pure/browser-safe
-export { catalogManagesModelPlane, enabledEntryCount } from "./catalog-manages.js"; // THE "does this models document manage the model plane" judge (raw half: at least one entry not explicitly disabled) + the log count it is derived from, pure/browser-safe
+export { catalogManagesModelPlane, enabledEntryCount, isExplicitlyDisabledEntry } from "./catalog-manages.js"; // THE "does this models document manage the model plane" judge (raw half: at least one entry not explicitly disabled) + the log count it is derived from + THE "is this one entry explicitly disabled" predicate they (and every per-entry consumer) read (the three-state `enabled` reading stays package-private), pure/browser-safe
 export { DEFAULT_MODEL_KEY, ENV_MODEL_TABLE_KEYS, buildEnvModelBaseline, envModelTableDeclared, envModelTableWriteRefusal, mintedCheapId, planEnvModelTableWrite, readEnvModelSlots, } from "./env-model-table.js"; // the env model table (MODEL_ID / MODEL_CHEAP_ID) read once: readEnvModelSlots / envModelTableDeclared / buildEnvModelBaseline + the writer's plan planEnvModelTableWrite (receipt by id, confirmKey) + envModelTableWriteRefusal, pure/browser-safe (named: the env snapshot helper stays package-private)
 export { CONFIG_ROOT_DOCUMENTS, ENV_MODELS_DECISIONS, ENV_MODELS_DOCUMENT, ROOT_DOCUMENT_UNREADABLE_REASONS, envModelsDecisionTag } from "./config-root-documents.js"; // the config-root documents (config.env-models.json + the per-id migration marker config.migration.<id>.json): names + closed answer tables + the one tagged identity of a decision reading (envModelsDecisionTag); the readers / writer are in ./node
 export * from "./loopback.js"; // 11.0.0: the two「本机」predicates (auth relaxation — narrow / connection routing — wide), pure/browser-safe

package/dist/mcp-request-entry.d.ts

@@ -1,4 +1,5 @@
 import { type McpContentOrigin } from "./types.js";
+import { type ReservedMemberName } from "./reserved-member-name.js";
 /** 值的**种类**(不回显值本身)。总(不抛):形状只问座位,读不出的对象说全包唯一的「检视不了」那一句。 */
 export declare function describeValueShape(v: unknown): string;
 /** 「不是字符串数组」的种类:数组里混了非串元素说那一句,否则回落到 {@link describeValueShape}。总(不抛):`isJsonArray` 是座位的总版。 */
@@ -12,19 +13,13 @@ export declare function describeNotStringRecord(v: unknown): string;
  */
 export declare function isStringArray(v: unknown): v is string[];
 /**
- * 纯数据的「名 → 串」记录(空对象合法;数组、`Map`、类实例、自有 `__proto__` 成员、有非串成员的对象都不是)—— 类型守卫,所以是**严归类**:成员经内核的
+ * 纯数据的「名 → 串」记录(空对象合法;数组、`Map`、类实例、有保留名成员({@link isReservedMemberName})、有非串成员的对象都不是)—— 类型守卫,所以是**严归类**:成员经内核的
  * `ownEntriesOf` 读(整容器读的严归类:每个自有串键一份描述符;访问器成员或不可枚举的成员 ⇒ 不是,getter 一次都不调 —— 守卫为真,调用方随后的普通读读到的就是判过的那一份)。
- * 传输读器读 `env` / `headers`({@link readPlainStringRecord})交出去的是**副本**,按宽归类读(不可枚举的成员照读、访问器调一次);值与成员名的判据(是串、不叫 `__proto__`)两边同一条。
+ * 传输读器读 `env` / `headers`({@link readPlainStringRecord})交出去的是**副本**,按宽归类读(不可枚举的成员照读、访问器调一次);值与成员名的判据(是串、不是保留名)两边同一条。
  */
 export declare function isStringRecord(v: unknown): v is Record<string, string>;
-/** 引擎 `TOOL_WIRE_NAME_MAX_CHARS` 的镜像:一台 MCP server(或 A2A 对端)的申报名会成为线上工具名的命名空间段,引擎对超界名是**拒**(不截断)。 */
-export declare const TOOL_WIRE_NAME_MAX_CHARS = 128;
-/**
- * 这个申报名能用吗。严判:非串、空串、超 {@link TOOL_WIRE_NAME_MAX_CHARS}、**首尾带空白**一律不可用。不截断、不 trim、不规范化 —— 截短或剥掉一个名字就是**换一个身份**,
- * 而被换掉身份的那台 server 上挂的 allowTools / toolFaces 收窄声明会一起对不上号。首尾空白 = 坏名(它不是另一个名字:名字是 `mcp__<server>__<tool>` 的身份片,
- * 带着空白的一端无从与不带的那个对上号);内部空白(`a b`)照旧是合法名,本判官不扩判。
- */
-export declare function isUsableWireName(v: unknown): v is string;
+export { TOOL_WIRE_NAME_MAX_CHARS, isUsableWireName } from "./wire-name.js";
+export { RESERVED_MEMBER_NAMES, isReservedMemberName, type ReservedMemberName } from "./reserved-member-name.js";
 /**
  * 坏名的**可打印**摘要(进拒句 / 告警元数据):种类、`empty`,或引号形的回显加原因 —— 绝不把任意长度的申报串原样回显。回显口径见 {@link quotedCallerText}
  * (剥控制与双向字符、截 64 字)。串的原因是:超界 ⇒ `N chars > 128`(N 是送来的原长度,不是剥完的);首尾带空白 ⇒ `leading or trailing whitespace`
@@ -82,7 +77,7 @@ export type RequestMcpTransport = {
  * `env` / `headers` 这两张「名 → 串」记录上的坏形另带两格机读位,调用方分流不必解析句子:`fault` = 闭集词({@link PLAIN_STRING_RECORD_FAULTS},与公开的记录读器 {@link readPlainStringRecord} 同一张表)——
  *  · `not_plain_record`:这个键的值不是纯数据记录(不是对象 / 数组 / `null`,或不是朴素 JSON 对象 —— 原型链比座位的判据长:`Map`、`Set`、类实例;读形状就抛的对象同);整张记录不交;
  *  · `member_not_string`:有一个成员的值不是串,或它读不出(它的访问器抛了,或读它的描述符时代理陷阱抛了);整张记录不交,`member` 点名它,两种情形句子分说;
- *  · `member_name_reserved`:有一个成员叫 `__proto__`(引擎的声明收据拒这个名)。成员的值是串 ⇒ 只剔这个成员、其余照交,`path` 是成员级(`transport.env.__proto__`);
+ *  · `member_name_reserved`:有成员叫保留名({@link RESERVED_MEMBER_NAMES}:`__proto__` / `constructor` / `prototype`)。值是串 ⇒ 只剔它、其余照交,每个一条、`path` 是成员级(`transport.env.__proto__`);
  *    成员的值也不是串(或读不出)⇒ 整张记录不交,`path` 是键级,句子一次说全两件事 —— 名坏优先、值坏并列,所以词仍是 `member_name_reserved`。
  * `member` 是成员名的**回显形**(剥控制与双向字符、截 64 字加 `…`),可直接进日志与句子,不是回查原对象的键。其余的坏形(`args` / `url` / `principalHeader` / ……)两格都不带。
  */
@@ -107,16 +102,11 @@ export type RequestMcpTransportRead = {
  *  · 软坏形(`args` 不是串数组 / `env` `headers` 不是纯数据的串记录 / `principalHeader` 非串)⇒ 读器**丢这个键**(重放存量提交体时的升级前读法),并把它记进 `lost`
  *    (受理新提交的门据它响亮拒)。`assertionHeader` 不在 `lost` 里:两个身份头的键组合与 `assertionHeader` 的值形由调用方在读之前对原始传输判。
  *  · `env` / `headers` 只收**纯数据**的记录({@link readPlainStringRecord}):必须是朴素 JSON 对象(`./plain-json-object` 的判据;`Map`、`Set`、类实例整张不收),每个自有成员的值都是串;
- *    交出的是**副本**(不是调用方的对象,改原对象不影响读后的形)。名叫 `__proto__` 的成员(JSON 文本铸得出这个自有键,对象字面量写不出)不进副本、单独记进 `lost`。
+ *    交出的是**副本**(不是调用方的对象,改原对象不影响读后的形)。名叫保留名({@link RESERVED_MEMBER_NAMES})的成员不进副本、每个单独记进 `lost`。
  *    坏形的 `lost` 条目带机读位(见 {@link McpEntryKeyIssue})。
  * url 的拒句不回显值:它常规地带凭据(userinfo)。
  */
 export declare function readRequestMcpTransport(t: unknown): RequestMcpTransportRead;
-/**
- * 引擎的声明收据不收的成员名(core `mcp-server-spec`:按赋值拷贝它会变成原型):JSON 文本铸得出这个**自有**键,对象字面量写不出。
- * 公开,因为读器交出 `reservedMember: true` 时消费方要点名它 —— 名字只在这里定一次。
- */
-export declare const PLAIN_STRING_RECORD_RESERVED_MEMBER = "__proto__";
 /**
  * 「名 → 串」记录读不交(或交时点名保留名)的**原因词**,闭集,三个词、一张表:
  * 整张一词(`not_plain_record`)· 成员级一词(`member_not_string`:值读成了别的种类,或读成员时抛了 —— 句子分说)· 名字级一词(`member_name_reserved`)。
@@ -127,12 +117,12 @@ export declare const PLAIN_STRING_RECORD_FAULTS: readonly ["not_plain_record", "
 export type PlainStringRecordFault = (typeof PLAIN_STRING_RECORD_FAULTS)[number];
 /**
  * {@link readPlainStringRecord} 的读数:`ok:false` = 记录不交(`fault` = 原因词;`detail` 是接在 `must be a plain object of string values — ` 后面的句子;坏在某个成员时 `member` 点名它的回显形);
- * `ok:true` = 交出去的纯数据副本,`reservedMember` = 记录里有一个名叫 {@link PLAIN_STRING_RECORD_RESERVED_MEMBER} 的成员(它没进副本)。
+ * `ok:true` = 交出去的纯数据副本,`reservedMembers` = 记录里名叫保留名({@link RESERVED_MEMBER_NAMES})的成员,按自有键序(它们没进副本)。
  */
 export type PlainStringRecordRead = {
     readonly ok: true;
     readonly record: Record<string, string>;
-    readonly reservedMember: boolean;
+    readonly reservedMembers: readonly ReservedMemberName[];
 } | {
     readonly ok: false;
     readonly detail: string;
@@ -143,7 +133,7 @@ export type PlainStringRecordRead = {
  * 读一份「名 → 串」记录 —— **公开读口**:传输读器读 `env` / `headers` 用的就是它,消费方读自己的「名 → 串」记录(中心名册的引用表)调同一只,不抄镜像。从不抛。记录交不交:是朴素 JSON 对象(座位的判据,见 `./plain-json-object`:原型是 `null`,或原型自己的原型是 `null`;纯数据 —— `Map`、`Set`、类实例、建在原型上的记录都不是),
  * 且每个成员的值都是串。成员 = `Object.getOwnPropertyNames` 的每一个名字(不可枚举的也算 —— 引擎的收据按全部自有属性名读),值经内核 `readKey` 读(一份描述符:数据属性取值,访问器调一次,不问 `get` 陷阱;访问器或描述符 trap 抛了同判为坏 —— 词与「值不是串」同是 `member_not_string`,句子说读不出)。
  * 读原型与成员名时代理 trap 抛了 ⇒ 整张不交(读器对调用方递来的任何对象都不抛;`JSON` 存体里不会有代理,这条只落在直接调读器的嵌入方身上)。
- * 交出去的是副本(原型 `Object.prototype`、成员全可枚举),调用方的对象不被交出去、也不被改;名叫 `__proto__` 的成员不进副本,`reservedMember` 记下它。
- * 名叫 `__proto__` 而值也坏的成员,句子一次说全两件事(名坏在前、值坏并列):调用方照值改完再撞第二条是两步才改对。
+ * 交出去的是副本(原型 `Object.prototype`、成员全可枚举),调用方的对象不被交出去、也不被改;名叫保留名({@link isReservedMemberName})的成员不进副本,`reservedMembers` 记下它们。
+ * 名叫保留名而值也坏的成员,句子一次说全两件事(名坏在前、值坏并列):调用方照值改完再撞第二条是两步才改对。
  */
 export declare function readPlainStringRecord(v: unknown): PlainStringRecordRead;