@sema-agent/settings-schema 14.7.0 → 15.0.0

package/dist/one-time-migrations.js

@@ -11,7 +11,13 @@
  * **迁移只认形、不认义**:每一步的输入形在新契约下非法、输出形合法 ⇒ 重跑恒等,新写入的数据永远不会被当成旧数据再改一次,不需要版本围栏;
  * 同一串字节换意思的改动一律**换表示**(SS-M6 因此是「`atModelAllowlist` → `atMention`」换字段,而不是翻 `[]` 的义)。
  *
- * ## 入口(纯函数:不读环境、不读墙钟、不改入参、**不抬任何版本号**)
+ * ## 第二种机制:在配置根上铸一次事实(只有 SS-M11)
+ * 上面的「只认形」律管的是**改写存储文档**的迁移。SS-M11 不改写任何存储形:它在一份文档**缺席**处铸一份部署决定(配置根的 `config.env-models.json`,收据词 `minted`),
+ * 而「缺席」本身没有形可认 —— 所以它不归上面的律,另有三条:① 它读 env、碰文件系统,住 `./node`(`migrateEnvModelsDecision`),不在下面的纯函数入口里;
+ * ② 它靠**按 id 一份的运行记录**(`config.migration.SS-M11.json`,「不存在才建」)跑恰一次,建成运行记录的进程是本根唯一的执行者;
+ * ③ 它的旧形待遇是 `read-as-default`(缺席按读者的缺省 `kept` 读,没有拒句可点名)。窗、删法与删后由谁接住照样只写在登记表那一行。
+ *
+ * ## 入口(纯函数:不读环境、不读墙钟、不改入参、**不抬任何版本号**;SS-M11 除外,见上一节)
  *  · {@link migrateStoredDocuments} —— 一组**存储文档**(域名 → 文档;还有本机的 `remote-exec` —— `config.d/remote-exec.json`,
  *    只有 SS-M7 的座位走查读它)。一个 scope 的全部草稿、一个 principal 层(个人 models / mcp / skills / plugins)、回滚史里的一条单域行,各调一次;`coverage` 说这组文档是不是一个 scope 的全集(只有 SS-M1 要知道:缺席的
  *    `governance` 是「从未设过」还是「没给」)。缺的域 = 不动。
@@ -176,6 +182,28 @@ export const ONE_TIME_MIGRATIONS = [
         afterRemoval: "the prompts `bindings` / `catalog` tombstone fields (permanent): a residual key is refused on read and write (the prompts domain degrades " +
             "to its default — no center layer is served)",
     },
+    {
+        id: "SS-M11",
+        oldForm: "read-as-default",
+        introducedIn: "14.8.0",
+        releasedOn: "2026-10-27",
+        removableAfter: "2026-11-26",
+        rewrites: "nothing stored is rewritten — the config root's env-model-table decision is minted once (migrateEnvModelsDecision, ./node): when the run " +
+            "marker config.migration.SS-M11.json is absent (a marker that does not read counts as run), the decision and whether config.d/models.json " +
+            "manages the model plane (catalogManagesModelPlane) are read first; then the marker is created exclusively — the one process that creates " +
+            "it is the only one that may mint on this root, any other stops for good — and that minter creates {\"envModels\":\"replaced\"} " +
+            "exclusively only when the decision it read before the election is absent and the catalog manages the model plane (whether an env model " +
+            "table is declared does not matter: the env only names the replaced env models) — the reading before the decision existed (a managing " +
+            "catalog replaced the env model table). Outcomes: minted / exists (only EEXIST) / failed (errno + a manual way out); an interruption after the marker is " +
+            "never retried. An absent root is created owner-only, holding only the marker; config.d is never created",
+        removal: "the next major after the window: delete migrateEnvModelsDecision (the SS-M11 body), this row, SS-M11 from ONE_TIME_MIGRATION_IDS, the " +
+            "`minted` receipt word and the `read-as-default` oldForm word; the marker then has no reader — readMigrationMarker and the marker's " +
+            "entry in CONFIG_ROOT_DOCUMENTS go with it (a marker left on disk is inert)",
+        afterRemoval: "an absent decision reads as kept — the reading the group-refusal code config.catalog_replaces_env_models is for: this package exports " +
+            "that code constant and the decision document for the engine to read, enforcing it is the engine's side, and the engine does not " +
+            "refuse on it today. Where the engine refuses, the way out is to write config.env-models.json = {\"envModels\":\"replaced\"} in the " +
+            "config root; no signpost in this package",
+    },
     {
         // 一条 wire 位的删码登记,不是数据迁移(id 在 WIRE_RETIREMENT_IDS,不在收据闭集)。
         id: "SS-W1",

package/dist/own-key-read.d.ts

@@ -24,7 +24,7 @@
  *    以及交回原引用 / 作类型守卫 / 对原值下判决的读口:`isStringArray` / `isStringRecord` / `isSchedulerRecord`、`readSettingsUnit` 的列表单元与环境变量表、比较器的串集合(`tightenVerdict` 的集合规则)。
  *  内核覆盖声明键读与整容器读;**仍自带读法的读者按名登记**(各自写明契约;普查钉按「文件 → 函数 → 读法 API」逐处数,登记外出现即红):
  *    既有、未经内核的数据读者:`tightenVerdict` 的 `none` 规则(`strictJsonCopy`:对象的不可枚举键跳过、访问器 ⇒ 整份 `unreadable`;数组按 `length` 逐位读描述符 —— `length` 走一次 `[[Get]]`、不可枚举的下标照读)·
- *    被丢条目的身份(`readEntryIdentity`:访问器 ⇒ 当缺席,从不调)· 传输记录读法(`readPlainStringRecord`:自己枚举成员名 `getOwnPropertyNames`,值经 {@link readKey});
+ *    被丢条目的身份(`readEntryIdentity` 读 `name` / `id`,它调的 `ownEnabledFlag`(`./catalog-manages`,与原文判官共用)读 `enabled` —— 同一读法:访问器 ⇒ 当缺席,从不调)· 传输记录读法(`readPlainStringRecord`:自己枚举成员名 `getOwnPropertyNames`,值经 {@link readKey});
  *    不是数据读的:安全判官 `extraBodyUnsafe` 的审计读(`./types`:问「任何自有键上有没有可疑」,含符号键与会抛的描述符,访问器 ⇒ 判不安全,从不调)。
  *  直接用 `[[Get]]` 的几处(不经内核,按名登记):hooks 分类器(`Object.keys` + 成员读;闭包可抄的内建写法,随闭包契约变更收)· `collectDropped` / `collectionSlots`(`./config-fns`:
  *  未知键扫描与条目集合的位置表,自己枚举容器再 `[[Get]]`;既有)· http hook 名单读器与判官的**普通读对拍**(安全轴的名单、判官的 `layers` / `hookVars` 要描述符视图

package/dist/remote-exec.d.ts

@@ -63,7 +63,7 @@ export declare const RemoteExecSpec: z.ZodDiscriminatedUnion<[z.ZodObject<{
     tokenEnv: z.ZodOptional<z.ZodString>;
     caCertEnv: z.ZodOptional<z.ZodString>;
     insecureTls: z.ZodOptional<z.ZodBoolean>;
-    namespace: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodString;
     runtimeClass: z.ZodOptional<z.ZodString>;
     mountPath: z.ZodOptional<z.ZodString>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;

package/dist/remote-exec.js

@@ -84,7 +84,7 @@ export const RemoteExecSpec = z.discriminatedUnion("provider", [
         /** Which of THIS process's env-NAMEs to forward into the sandbox (service: E2B_SANDBOX_ENV, a CSV of NAMEs). */
         sandboxEnv: z.array(ENV_NAME).optional(),
     }),
-    // ── k8s: per-task Kata pod (service provider "k8s"; REMOTE_EXEC=k8s + K8S_SANDBOX_IMAGE).
+    // ── k8s: per-task Kata pod (service provider "k8s"; REMOTE_EXEC=k8s + K8S_SANDBOX_IMAGE + K8S_NAMESPACE).
     z.object({
         provider: z.literal("k8s"),
         /** Sandbox container image (service: K8S_SANDBOX_IMAGE). Required so a run is reproducible. */
@@ -97,7 +97,9 @@ export const RemoteExecSpec = z.discriminatedUnion("provider", [
         /** env-NAME holding the base64 CA cert (service: K8S_CA_CERT_B64). NEVER the cert bytes. */
         caCertEnv: ENV_NAME.optional(),
         insecureTls: z.boolean().optional(),
-        namespace: execStr.optional(),
+        /** The namespace the sandbox pods live in (service: K8S_NAMESPACE). Required — the deployment declares where its pods run and nothing here guesses one;
+         *  the execution-lane table lists K8S_NAMESPACE as a required coordinate of the k8s lane, and this file contract says the same. */
+        namespace: execStr,
         runtimeClass: execStr.optional(),
         mountPath: execStr.optional(),
         timeoutMs: INTEGER.positive().optional(),

package/dist/retired-form.d.ts

@@ -7,6 +7,9 @@
  *
  * 墓碑是**拒**,不是第二种读法:它不把旧形读成任何值,只说「这里有一份没迁的旧形」以及去哪儿迁。迁移族按登记表的窗整族删,
  * 墓碑留下 —— 到那时拒句里的迁移 id 由删码那一车改写(登记表那一行的 `removal` 点名了这件事)。
+ *
+ * **墓碑表**:每个 {@link retiredKey} 铸出的墓碑在铸造时登记一行({@link RetiredKeyRow}:键名、形、整句)。表的读者两个 —— 读面的终判
+ * ({@link retiredKeyOfSentence}:一条 zod issue 的 message 恰是某个墓碑的整句 ⇒ 这是一条墓碑 issue)与测试({@link retiredKeyTable}:从表读名单,不手抄)。
  */
 import { z } from "zod";
 /** 迁移命令行的唯一拼写:`npx` 全名形 —— 没装本包的运维粘贴即可跑(裸 bin 名在没装本包的机器上是 `command not found`)。参数是一个 `config.d` 目录。
@@ -29,8 +32,24 @@ export interface RetiredForm {
     readonly migration: string;
 }
 export declare function retiredFormSentence(form: string, t: RetiredForm): string;
+/** 墓碑表的一行:`key` 是墓碑字段在它所在对象里的点路径(例:`runtime.sessionBackend`),`sentence` 是它的拒句整句(= 那条 zod issue 的 message)。 */
+export interface RetiredKeyRow {
+    readonly key: string;
+    readonly form: RetiredForm;
+    readonly sentence: string;
+}
 /**
  * retired**键**的墓碑字段:放在该键原来所在的对象形里,键缺席 = 合法,键在场(任何值)= 一条 issue(路径就是那个键、句子点名迁移)。
  * 输出形里它恒缺席(型上是 `?: undefined`),JSON Schema 上是 `not: {}`(「不许出现」)—— 墓碑写在旧键原来的位置上,schema 自己说明它retired了。
  */
 export declare function retiredKey(key: string, t: RetiredForm): z.ZodOptional<z.ZodNever>;
+/** 墓碑表(一份副本,按铸造次序)。 */
+export declare function retiredKeyTable(): readonly RetiredKeyRow[];
+/** 一条 zod issue 的 message 恰是某个墓碑的整句 ⇒ 那一行;否则 `undefined`。 */
+export declare function retiredKeyOfSentence(message: string): RetiredKeyRow | undefined;
+/**
+ * 墓碑在**读面**(终判扣下一行时的拒句)的说法:不点名那个旧字段的名字 —— 它就在盘上那一行里,结构化的坐标(`field`)已经指到它;
+ * 文字说现行位、迁移是一条出路,以及「迁移拒过这一行」的出路。读面是纯函数、无 I/O,不知道这一行跑没跑过迁移,所以两种情形都要成立:
+ * 没跑过 ⇒ 跑迁移;跑过且拒了(迁移不写回半成品,原行留在盘上)⇒ 手写现行形、删掉旧字段。
+ */
+export declare function retiredKeyHeldSentence(t: RetiredForm): string;

package/dist/retired-form.js

@@ -7,6 +7,9 @@
  *
  * 墓碑是**拒**,不是第二种读法:它不把旧形读成任何值,只说「这里有一份没迁的旧形」以及去哪儿迁。迁移族按登记表的窗整族删,
  * 墓碑留下 —— 到那时拒句里的迁移 id 由删码那一车改写(登记表那一行的 `removal` 点名了这件事)。
+ *
+ * **墓碑表**:每个 {@link retiredKey} 铸出的墓碑在铸造时登记一行({@link RetiredKeyRow}:键名、形、整句)。表的读者两个 —— 读面的终判
+ * ({@link retiredKeyOfSentence}:一条 zod issue 的 message 恰是某个墓碑的整句 ⇒ 这是一条墓碑 issue)与测试({@link retiredKeyTable}:从表读名单,不手抄)。
  */
 import { z } from "zod";
 import { shellQuote } from "./shell-quote.js";
@@ -27,10 +30,30 @@ export function migrationSignpost(migration, before) {
 export function retiredFormSentence(form, t) {
     return `${form} was retired in ${t.retiredIn} — now ${t.now}; ${migrationSignpost(t.migration, t.retiredIn)}`;
 }
+/** 整句 → 行。同一个键在两处 schema 里以同一个形退役(整句逐字同)只占一行。 */
+const TOMBSTONES = new Map();
 /**
  * retired**键**的墓碑字段:放在该键原来所在的对象形里,键缺席 = 合法,键在场(任何值)= 一条 issue(路径就是那个键、句子点名迁移)。
  * 输出形里它恒缺席(型上是 `?: undefined`),JSON Schema 上是 `not: {}`(「不许出现」)—— 墓碑写在旧键原来的位置上,schema 自己说明它retired了。
  */
 export function retiredKey(key, t) {
-    return z.never({ error: retiredFormSentence(key, t) }).optional();
+    const sentence = retiredFormSentence(key, t);
+    TOMBSTONES.set(sentence, Object.freeze({ key, form: t, sentence }));
+    return z.never({ error: sentence }).optional();
+}
+/** 墓碑表(一份副本,按铸造次序)。 */
+export function retiredKeyTable() {
+    return [...TOMBSTONES.values()];
+}
+/** 一条 zod issue 的 message 恰是某个墓碑的整句 ⇒ 那一行;否则 `undefined`。 */
+export function retiredKeyOfSentence(message) {
+    return TOMBSTONES.get(message);
+}
+/**
+ * 墓碑在**读面**(终判扣下一行时的拒句)的说法:不点名那个旧字段的名字 —— 它就在盘上那一行里,结构化的坐标(`field`)已经指到它;
+ * 文字说现行位、迁移是一条出路,以及「迁移拒过这一行」的出路。读面是纯函数、无 I/O,不知道这一行跑没跑过迁移,所以两种情形都要成立:
+ * 没跑过 ⇒ 跑迁移;跑过且拒了(迁移不写回半成品,原行留在盘上)⇒ 手写现行形、删掉旧字段。
+ */
+export function retiredKeyHeldSentence(t) {
+    return `a field retired in ${t.retiredIn} is still in the row — now ${t.now}; ${migrationSignpost(t.migration, t.retiredIn)}; if that migration already refused this row, write the current form by hand and delete the old field`;
 }

package/dist/safety-merge-spec.d.ts

@@ -92,8 +92,8 @@ export declare const MIN_TRUST_WORDS: readonly ["local", "session", "project", "
 export declare const MinTrust: z.ZodEnum<{
     local: "local";
     session: "session";
-    project: "project";
     global: "global";
+    project: "project";
     managed: "managed";
     task: "task";
 }>;
@@ -151,8 +151,8 @@ export declare const MemberAdmission: z.ZodObject<{
     minTrust: z.ZodOptional<z.ZodEnum<{
         local: "local";
         session: "session";
-        project: "project";
         global: "global";
+        project: "project";
         managed: "managed";
         task: "task";
     }>>;
@@ -161,8 +161,8 @@ export declare const MemberAdmission: z.ZodObject<{
         minTrust: z.ZodEnum<{
             local: "local";
             session: "session";
-            project: "project";
             global: "global";
+            project: "project";
             managed: "managed";
             task: "task";
         }>;
@@ -264,8 +264,8 @@ export declare const MergeCategorySpec: z.ZodObject<{
     minTrust: z.ZodEnum<{
         local: "local";
         session: "session";
-        project: "project";
         global: "global";
+        project: "project";
         managed: "managed";
         task: "task";
     }>;
@@ -314,8 +314,8 @@ export declare const MergeCategorySpec: z.ZodObject<{
         minTrust: z.ZodOptional<z.ZodEnum<{
             local: "local";
             session: "session";
-            project: "project";
             global: "global";
+            project: "project";
             managed: "managed";
             task: "task";
         }>>;
@@ -324,8 +324,8 @@ export declare const MergeCategorySpec: z.ZodObject<{
             minTrust: z.ZodEnum<{
                 local: "local";
                 session: "session";
-                project: "project";
                 global: "global";
+                project: "project";
                 managed: "managed";
                 task: "task";
             }>;

package/dist/tier-words.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 档位词(纯、零 I/O、浏览器安全;**包内叶子模块,不出包**):引擎的档序与 CC 档位别名、从某档起向低档的梯,与「一个目录词在档位展开之后落到哪条条目」。
+ * 本包里档位词的唯一一处:default 角色的档梯(`./default-model`)与写者计划助手的落点(`./env-model-table`)都从这里取。
+ * 镜像 core(`DEFAULT_TIER_ORDER` / `CC_MODEL_TIER_ALIASES` / `expandTiers`):`test/tier-words-parity-14.8.0` 对 devDependency 里精确钉住的那一版 core 对拍。
+ */
+/** 引擎的档序(高 → 低)。 */
+export declare const TIER_ORDER: readonly ["ultra", "max", "pro", "flash", "lite"];
+/** 一个档位词。 */
+export type TierWord = (typeof TIER_ORDER)[number];
+/** CC 档位词 → 引擎档位。 */
+export declare const CC_TIER_ALIASES: {
+    readonly fable: "max";
+    readonly mythos: "max";
+    readonly opus: "pro";
+    readonly sonnet: "flash";
+    readonly haiku: "lite";
+};
+/** 档序里从 `S` 起(含)向低档的那一段,字面元组型。 */
+type LadderFrom<S extends TierWord, T extends readonly TierWord[] = typeof TIER_ORDER> = T extends readonly [infer H, ...infer R extends readonly TierWord[]] ? H extends S ? Readonly<T> : LadderFrom<S, R> : readonly [];
+/** 一档的梯:档序里从它起(含)向低档的那一段(没绑的档沿它往下落)。 */
+export declare function tierLadderFrom<S extends TierWord>(tier: S): LadderFrom<S>;
+/**
+ * 一个目录词(条目名 / 档位词 / CC 档位别名 / `best`)在**档位展开之后**落到哪条目录条目名 —— 与引擎装配档位表的两步同答:
+ * 先摘掉活跃组里绑定目标不可服务的档(引擎的生效装配在交给 core 之前做这一步,并 warn 点名),再按 core `expandTiers` 展开
+ * (对拍 devDependency 那一版 core 的「摘后表」)。所以这里只有一条绑定规则:**一档的绑定只在它点名一条可服务条目时算数**,否则当作没绑。展开规则:
+ *  · 目录自己的键先赢(`has(word)`;一条就叫 `flash` 的条目遮住档位词);
+ *  · 档位词 ⇒ 它的梯({@link tierLadderFrom})上第一个有绑定的档;摘完没有任何绑定 ⇒ 只认目录键;
+ *  · CC 档位别名 ⇒ 经它对应的档位;`best` ⇒ 档序里第一个有绑定的档;别的词 ⇒ 落不到。
+ * `has` = 调用方的「这个名是目录里一条可服务(启用)的条目」;`tiers` = `resolveActiveTiers` 的读数(原表,未摘)—— 它的键只有五个档位词
+ * (档位组的绑定表在 schema 里只收这五个键,别的键被剥掉),所以只按档位词读表。
+ */
+export declare function landCatalogWord(word: string, has: (name: string) => boolean, tiers: Readonly<Partial<Record<TierWord, string>>> | undefined): string | undefined;
+export {};

package/dist/tier-words.js

@@ -0,0 +1,43 @@
+/**
+ * 档位词(纯、零 I/O、浏览器安全;**包内叶子模块,不出包**):引擎的档序与 CC 档位别名、从某档起向低档的梯,与「一个目录词在档位展开之后落到哪条条目」。
+ * 本包里档位词的唯一一处:default 角色的档梯(`./default-model`)与写者计划助手的落点(`./env-model-table`)都从这里取。
+ * 镜像 core(`DEFAULT_TIER_ORDER` / `CC_MODEL_TIER_ALIASES` / `expandTiers`):`test/tier-words-parity-14.8.0` 对 devDependency 里精确钉住的那一版 core 对拍。
+ */
+/** 引擎的档序(高 → 低)。 */
+export const TIER_ORDER = ["ultra", "max", "pro", "flash", "lite"];
+/** CC 档位词 → 引擎档位。 */
+export const CC_TIER_ALIASES = { fable: "max", mythos: "max", opus: "pro", sonnet: "flash", haiku: "lite" };
+/** 一档的梯:档序里从它起(含)向低档的那一段(没绑的档沿它往下落)。 */
+export function tierLadderFrom(tier) {
+    return TIER_ORDER.slice(TIER_ORDER.indexOf(tier));
+}
+const isTierWord = (word) => TIER_ORDER.includes(word);
+/**
+ * 一个目录词(条目名 / 档位词 / CC 档位别名 / `best`)在**档位展开之后**落到哪条目录条目名 —— 与引擎装配档位表的两步同答:
+ * 先摘掉活跃组里绑定目标不可服务的档(引擎的生效装配在交给 core 之前做这一步,并 warn 点名),再按 core `expandTiers` 展开
+ * (对拍 devDependency 那一版 core 的「摘后表」)。所以这里只有一条绑定规则:**一档的绑定只在它点名一条可服务条目时算数**,否则当作没绑。展开规则:
+ *  · 目录自己的键先赢(`has(word)`;一条就叫 `flash` 的条目遮住档位词);
+ *  · 档位词 ⇒ 它的梯({@link tierLadderFrom})上第一个有绑定的档;摘完没有任何绑定 ⇒ 只认目录键;
+ *  · CC 档位别名 ⇒ 经它对应的档位;`best` ⇒ 档序里第一个有绑定的档;别的词 ⇒ 落不到。
+ * `has` = 调用方的「这个名是目录里一条可服务(启用)的条目」;`tiers` = `resolveActiveTiers` 的读数(原表,未摘)—— 它的键只有五个档位词
+ * (档位组的绑定表在 schema 里只收这五个键,别的键被剥掉),所以只按档位词读表。
+ */
+export function landCatalogWord(word, has, tiers) {
+    if (has(word))
+        return word;
+    if (tiers === undefined)
+        return undefined;
+    /** 一档的绑定:只在它点名一条可服务条目时算数(否则引擎已摘掉它)。 */
+    const bound = (tier) => {
+        const target = Object.hasOwn(tiers, tier) ? tiers[tier] : undefined;
+        return target !== undefined && has(target) ? target : undefined;
+    };
+    const firstBound = (ladder) => ladder.map(bound).find((landed) => landed !== undefined);
+    if (isTierWord(word))
+        return firstBound(tierLadderFrom(word));
+    if (Object.hasOwn(CC_TIER_ALIASES, word))
+        return firstBound(tierLadderFrom(CC_TIER_ALIASES[word]));
+    if (word === "best")
+        return firstBound(TIER_ORDER);
+    return undefined;
+}

package/dist/types.d.ts

@@ -1885,6 +1885,8 @@ export declare const McpServerSpec: z.ZodObject<{
         local: "local";
         execution: "execution";
     }>>;
+    sessionMetaKey: z.ZodOptional<z.ZodUnknown>;
+    startupTimeoutMs: z.ZodOptional<z.ZodUnknown>;
     source: z.ZodOptional<z.ZodUnknown>;
     toolFaces: z.ZodOptional<z.ZodUnknown>;
     toolAxes: z.ZodOptional<z.ZodUnknown>;
@@ -1918,6 +1920,8 @@ export declare const McpConfig: z.ZodObject<{
             local: "local";
             execution: "execution";
         }>>;
+        sessionMetaKey: z.ZodOptional<z.ZodUnknown>;
+        startupTimeoutMs: z.ZodOptional<z.ZodUnknown>;
         source: z.ZodOptional<z.ZodUnknown>;
         toolFaces: z.ZodOptional<z.ZodUnknown>;
         toolAxes: z.ZodOptional<z.ZodUnknown>;
@@ -2520,6 +2524,8 @@ export declare const DOMAIN_SCHEMAS: {
                 local: "local";
                 execution: "execution";
             }>>;
+            sessionMetaKey: z.ZodOptional<z.ZodUnknown>;
+            startupTimeoutMs: z.ZodOptional<z.ZodUnknown>;
             source: z.ZodOptional<z.ZodUnknown>;
             toolFaces: z.ZodOptional<z.ZodUnknown>;
             toolAxes: z.ZodOptional<z.ZodUnknown>;

package/dist/types.js

@@ -30,7 +30,7 @@ import { PREVIOUS_WEB_ADMIN_ENV } from "./previous-web-admin-env.js"; // the pre
 import { retiredEnvRefusal } from "./retired-envs.js"; // the worker env write gate asks the retired-env tombstone table too (one table, one refusal sentence)
 import { Sha256Digest } from "./sha256.js"; // the one `sha256:<hex>` digest form
 import { EXECUTION_LANES, EXECUTION_LANE_WORDS, MEMORY_ENGINE_BACKENDS, SESSION_BACKENDS, STORE_BACKENDS, retiredLaneWordRefusal } from "./execution-lanes.js"; // 7.0.0 M-R2: the lane / store vocabulary (one exported table)
-import { LANE_ENV_OWNER, isMigratableEnvKey, laneEnvSeat, laneRowOf } from "./execution-lane-index.js"; // package-private indexes derived from that table (not in the barrel)
+import { LANE_ENV_OWNER, isBlankCoordinate, isMigratableEnvKey, laneEnvSeat, laneRowOf } from "./execution-lane-index.js"; // package-private indexes derived from that table (not in the barrel)
 import { migrationSignpost, retiredFormSentence, retiredKey } from "./retired-form.js"; // 11.0.0: the ONE retired-form sentence + key tombstone (package-private)
 import { retiredRoleWordsRefusal } from "./retired-role-words.js"; // 12.0.0: the retired role-word tombstone (package-private; SS-M8)
 import { buildQuotedIssue, fixed } from "./quoted-issue.js"; // THE minting point of custom issues (package-private)
@@ -456,6 +456,20 @@ export const PARSE_TRANSPARENT_KEYS = [
         validatedBy: "consumer",
         why: "它的形由同一条 override 的 `key` 决定(一个 key 一种形),执法点在读那个 key 的消费方;在这里写死形等于把所有可覆盖键的形表搬进本包。",
     },
+    {
+        domain: "mcp",
+        path: "servers[].sessionMetaKey",
+        since: "14.8.0",
+        validatedBy: "engine-ingest",
+        why: "引擎在发给这台服务器的请求 `_meta` 里放发送腿会话 id 的那把键;它只有一只判官 = 引擎根导出 `judgeSessionMetaKey`(类型、非空、上界、MCP `_meta` 键名文法、MCP 保留前缀、`progressToken`、引擎的 `sema/` 命名空间一并判;坏键在引擎的准备门整条拒、点名这把键),投影它的消费方在交给引擎之前可调同一只;本包只承载 —— 这里哪怕只判类型与长度,也是第二只判官的一部分,与引擎那只各答各的。",
+    },
+    {
+        domain: "mcp",
+        path: "servers[].startupTimeoutMs",
+        since: "14.8.0",
+        validatedBy: "engine-ingest",
+        why: "引擎的逐服务器启动界(握手与首次工具列举各带它);它只有一只判官 = 引擎根导出的 `mcpStartupTimeoutMs`(是不是数、整数性、范围一并判;坏值在引擎的拨号门拒这一台服务器、点名 `config.mcp_startup_timeout_invalid`,其余服务器照挂),投影它的消费方在交给引擎之前可调同一只;本包只承载 —— 这里哪怕只判「是不是数」,也是第二只判官的一部分,与引擎那只各答各的。",
+    },
 ];
 /** A catalog model's price / capability tier — fuels core 1.25 `selectModel({ tier })` role resolution. ONE closed set for both
  *  places that name it (`ModelEntry.tier`, `RoleTarget.select.tier`). Not the tier-group ladder of {@link TierBindings}
@@ -1875,8 +1889,8 @@ const nonSecretLiteral = (minLength) => z
 /**
  * `runtime.execution` —— 这台 worker 的执行车道(渲染:`REMOTE_EXEC=<lane>` + `REQUIRE_EXECUTION_LANE=true` + coords / secretRefs 逐键)。
  *  - `lane`:{@link EXECUTION_LANE_WORDS} 之一。没有「无手」词。
- *  - `coords`:该车道的**非密坐标**(服务变量名 → 字面值),键 ⊆ 表[lane] 的 `requiredEnv ∪ optionalEnv`;必需键在场且非空串
- *    (引擎把空串读作未设)。可选键的空串照收(例:`K8S_RUNTIME_CLASS=""` 在引擎里是「不用 Kata」)。
+ *  - `coords`:该车道的**非密坐标**(服务变量名 → 字面值),键 ⊆ 表[lane] 的 `requiredEnv ∪ optionalEnv`;必需键在场且不是空白
+ *    (空串或只含空白按缺 —— 唯一判官 `isBlankCoordinate`)。可选键的空串照收(例:`K8S_RUNTIME_CLASS=""` 在引擎里是「不用 Kata」)。
  *  - `secretRefs`:该车道的**密钥**(服务变量名 → 宿主 env-NAME),键 ⊆ 表[lane] 的 `requiredSecretEnv ∪ optionalSecretEnv`,必需键在场。
  *  别车道的键 ⇒ 拒并点名它属于哪条车道;本车道的密钥写进 coords / 坐标写进 secretRefs ⇒ 拒并指路另一栏。
  */
@@ -1911,8 +1925,8 @@ const ExecutionBlock = z
         return true;
     };
     for (const [key, value] of Object.entries(x.coords)) {
-        if (judgeKey("coords", key) && value === "" && LANE_ENV_OWNER.get(key)?.required === true) {
-            issue("coords", key, buildQuotedIssue `required coordinate ${key} of lane "${x.lane}" is empty — the engine reads an empty value as unset and refuses to start`);
+        if (judgeKey("coords", key) && isBlankCoordinate(value) && LANE_ENV_OWNER.get(key)?.required === true) {
+            issue("coords", key, buildQuotedIssue `required coordinate ${key} of lane "${x.lane}" is empty or whitespace-only — it counts as absent, and the engine refuses to start without it`);
         }
     }
     for (const key of Object.keys(x.secretRefs))
@@ -2486,6 +2500,16 @@ export const McpServerSpec = z.object({
      *  declared `"local"`, the engine read ABSENT. A value outside the table is REJECTED at parse — a mistyped trust
      *  word must never be read as a legal one (the consumer's gate is equally severe: no case-folding). */
     contentOrigin: z.enum(MCP_CONTENT_ORIGINS).optional(),
+    /** 引擎在发给这台服务器的每个 `tools/call` / `resources/read` 的 `params._meta[key]` 里放发送腿自己的会话 id 的那把键 —— 一一对应引擎的
+     *  `McpServerSpec.sessionMetaKey`。缺席 = 什么都不送(`.optional()`,不铸默认:会话 id 出进程是部署自己选的关联)。
+     *
+     *  **解析透明** —— 形归谁校验、为什么不放这里:{@link PARSE_TRANSPARENT_KEYS}(`mcp.servers[].sessionMetaKey`)。 */
+    sessionMetaKey: z.unknown().optional(),
+    /** 这一台服务器自己的启动界(整数毫秒):握手(连接 + initialize)与首次工具列举各带它 —— 一一对应引擎的 `McpServerSpec.startupTimeoutMs`。
+     *  缺席 = 引擎读进程级的缺省界(`.optional()`,不铸默认:没声明就是没声明);它只界启动阶段,不动单次调用的超时。
+     *
+     *  **解析透明** —— 形归谁校验、为什么不放这里:{@link PARSE_TRANSPARENT_KEYS}(`mcp.servers[].startupTimeoutMs`)。 */
+    startupTimeoutMs: z.unknown().optional(),
     /** Declaration-plane GROUPING LABEL for this server — maps 1:1 onto the engine's `McpServerSpec.source`
      *  (core ≥7.5.0 echoes it verbatim on `wiring_manifest.mcp[].source`, single-line + 80-char cap, so a
      *  consumer can group servers by where they were declared). An OPEN set: CC's `plugin` / `user` /

package/dist/worker-row-verdict.js

@@ -10,6 +10,7 @@ import { formatConfigPath, outgoingPath } from "./config-fns.js";
 import { issuePath } from "./issue-path.js";
 import { guardedSafeParse } from "./own-key-read.js";
 import { jsonShapeOf } from "./plain-json-object.js";
+import { retiredKeyHeldSentence, retiredKeyOfSentence } from "./retired-form.js";
 import { WorkersConfig } from "./types.js";
 /** 每一形的拒句主语 —— 穷举映射型:加一形不补这里即编译红。 */
 const SUBJECT = {
@@ -63,6 +64,11 @@ export function safeIssueMessage(issue) {
 function rowRelative(path) {
     return path[0] === "workers" && path[1] === 0 ? path.slice(2) : path;
 }
+/** 一条 issue 在拒句里的样子:`<坐标>: <句子>`;墓碑 issue(旧形字段还在盘上)换成读面的说法 —— 坐标就是退役键名,拒句的文字里不点名它(结构化的 `field` 已经指到它),指现行位与出路。 */
+function issueText(i) {
+    const tombstone = retiredKeyOfSentence(i.message);
+    return tombstone !== undefined ? retiredKeyHeldSentence(tombstone.form) : `${formatConfigPath(outgoingPath(rowRelative(issuePath(i))))}: ${i.message}`;
+}
 /** 一行的终判:读得进 ⇒ `undefined`;读不进 ⇒ 第一条 issue 的路径(相对该行)+ 拒句(见文件头)。 */
 export function workerRowVerdict(row, form) {
     // 校验过程抛(会抛的 getter / 陷阱:读侧交进来的是调用方的活对象;zod 4.6 首读 `error` 时拼句子抛 —— 被污染的运行时、另一 realm 的怪形值)⇒ 这一行判「读不出」
@@ -74,7 +80,7 @@ export function workerRowVerdict(row, form) {
     if (verdict.success)
         return undefined;
     const issues = verdict.error.issues;
-    const shown = issues.slice(0, 3).map((i) => `${formatConfigPath(outgoingPath(rowRelative(issuePath(i))))}: ${i.message}`);
+    const shown = issues.slice(0, 3).map(issueText);
     const more = issues.length > shown.length ? ` (+${issues.length - shown.length} more)` : "";
     const first = issues[0];
     return { field: first === undefined ? [] : rowRelative(issuePath(first)), reason: `${SUBJECT[form]} is not a valid WorkerSpec — ${shown.join("; ")}${more}` };