@sema-agent/server 7.128.0 → 7.129.1

package/dist/web-admin-client/apply-effective.js

@@ -15,6 +15,7 @@ import { judgeModelRouteEndpoint } from "../model-route-endpoint.js";
 import { gateIntentUnserviceableReason } from "../approval.js";
 import { refusedGroups } from "./apply-ledger.js";
 import { judgeConfigCandidate } from "./candidate-gate.js";
+import { declareServerWithheldEnv, withdrawServerWithheldEnv } from "../server-secret-env.js";
 const charsPerTokenOf = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined);
 function envDerivedModel(config) {
     const m = config.envModel;
@@ -97,17 +98,21 @@ export function applyEffective(config, eff, logger, opts) {
         return false;
     }
     const mp = staged.modelPlaneGroup.stages.models;
-    if (mp !== undefined && opts.swapPlane !== undefined) {
-        try {
-            opts.swapPlane({ models: mp.models, tiers: mp.activeTiers });
-        }
-        catch (err) {
-            logger?.warn("web_admin_model_plane_swap_refused", {
-                version: staged.version,
-                error: err instanceof Error ? err.message : String(err),
-                note: "the Runner refused the candidate model plane (swapDeps screens the whole candidate atomically — the current generation stays in force untouched); candidate refused whole, re-judged next poll (/health shows target≠applied while it persists)",
-            });
-            return false;
+    if (mp !== undefined) {
+        declareCandidateWithheldEnv(mp.modelApiKeyEnv, staged.version);
+        if (opts.swapPlane !== undefined) {
+            try {
+                opts.swapPlane({ models: mp.models, tiers: mp.activeTiers });
+            }
+            catch (err) {
+                withdrawServerWithheldEnv();
+                logger?.warn("web_admin_model_plane_swap_refused", {
+                    version: staged.version,
+                    error: err instanceof Error ? err.message : String(err),
+                    note: "the Runner refused the candidate model plane (swapDeps screens the whole candidate atomically — the current generation stays in force untouched); candidate refused whole, re-judged next poll (/health shows target≠applied while it persists)",
+                });
+                return false;
+            }
         }
     }
     commitStaged(config, staged);
@@ -141,6 +146,18 @@ export function applyEffective(config, eff, logger, opts) {
         logger?.info("web_admin_projects", { projects: Object.keys(staged.projects) });
     return true;
 }
+function declareCandidateWithheldEnv(modelApiKeyEnv, version) {
+    try {
+        declareServerWithheldEnv(modelApiKeyEnv);
+    }
+    catch (err) {
+        const entries = Object.entries(modelApiKeyEnv)
+            .map(([model, envName]) => `${model}→${envName}`)
+            .join(", ");
+        throw new Error(`model catalog (effective v${version}): a model entry's apiKeyEnv names a variable the engine cannot withhold from model-driven shells — ` +
+            `the candidate is refused whole and the current generation keeps serving; fix that entry's apiKeyEnv (entries: ${entries}). Engine: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 function commitStaged(config, staged) {
     const mp = staged.modelPlaneGroup.stages.models;
     if (mp) {

package/dist/web-admin-client/facade.d.ts

@@ -51,6 +51,6 @@ export { fetchEffective, fetchPrincipalCaps, fetchPrincipalOrgMemory, WebAdminHt
 export { mutateInPlace, applyEffective, type ApplyReport, applyRuntimeGates, applyRuntimeHot, logEffectiveDiff, MODEL_PLANE_DOMAINS, type ModelPlaneDomain, type ModelPlaneOf, withModelPlaneOf, fullyLandedForLkg, } from "./apply-effective.js";
 export { restartReasons, modelPlaneChanged, type RestartSlice, type RestartSliceCtx, type EngineRestartSignal, } from "./restart-signal.js";
 export { applySkillsManifest, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./skills-mcp.js";
-export { applyCenterReadFace, CENTER_READ_FACE_LIVE_KEYS, type CenterReadFaceApply, type CenterReadFaceReport, type ReadFaceBaseline } from "./read-face.js";
+export { applyCenterReadFace, buildReadFaceBaseline, buildReadFaceSwapCandidate, restoreReadFaceBaseline, CENTER_READ_FACE_LIVE_KEYS, type CenterReadFaceApply, type CenterReadFaceReport, type ReadFaceBaseline, type ReadFaceSeat } from "./read-face.js";
 export type { CenterSkillManifest, CenterMcpServer, CenterA2aPeer, CenterModel, CenterReadFace, EffectiveConfig, ExecutionRuling, SessionMirrorRuling, } from "./types.js";
 //# sourceMappingURL=facade.d.ts.map

package/dist/web-admin-client/facade.js

@@ -2,5 +2,5 @@ export { fetchEffective, fetchPrincipalCaps, fetchPrincipalOrgMemory, WebAdminHt
 export { mutateInPlace, applyEffective, applyRuntimeGates, applyRuntimeHot, logEffectiveDiff, MODEL_PLANE_DOMAINS, withModelPlaneOf, fullyLandedForLkg, } from "./apply-effective.js";
 export { restartReasons, modelPlaneChanged, } from "./restart-signal.js";
 export { applySkillsManifest, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./skills-mcp.js";
-export { applyCenterReadFace, CENTER_READ_FACE_LIVE_KEYS } from "./read-face.js";
+export { applyCenterReadFace, buildReadFaceBaseline, buildReadFaceSwapCandidate, restoreReadFaceBaseline, CENTER_READ_FACE_LIVE_KEYS } from "./read-face.js";
 //# sourceMappingURL=facade.js.map

package/dist/web-admin-client/read-face.d.ts

@@ -1,22 +1,66 @@
+/**
+ * #A4([ref] 窗三件批 件1;[ref]/[ref] 承诺件)—— READ 容纳面四键的 **web-admin 消费腿**。
+ *
+ * 部署 env 的四键(`READ_FACE` / `READ_DENY_PATTERNS` / `READ_DENY_BUILTIN_TIERS` / `READ_DENY_BUILTIN_EXCLUDE`,见 config.ts)
+ * 此前是这条轴上的唯一入口:一个用 web-admin 管理整片 worker 的组织,想统一收紧 READ 面只能逐机改 env。本模块把
+ * `EffectiveConfig.readFace`(见 types.ts {@link CenterReadFace})投影到同样的四个 `ServiceConfig` 键上。
+ *
+ * ── 生效时机:**逐席由引擎答**(S-174 起 face;S-1560 / core 7.51.0 起四席全热)──────────────────────────
+ * 哪些席能热换,不是本仓的意见:`KEY_MAP` 每行的 `cfgKey` 就是 core 的席名,能不能热换由 core 的 `isSwappableDepSeat` 亲答
+ * ({@link CENTER_READ_FACE_LIVE_KEYS})。本模块按这**一个**判据分相({@link CenterReadFaceApply}):
+ *  · `boot` 相 —— 四键全落(Runner 还没建,每一席都还会 bake);
+ *  · `live` 相(refresh 拍)—— **只落引擎有活体席的键**,回执 {@link CenterReadFaceReport.changedSeats} 报这一拍换了值的席,
+ *    调用方据它向全部 boot Runner `swapDeps` 一次。引擎**没有**活体席的键 live 相**刻意不落**:写进 `config` 会让
+ *    `/health` / wiring 读面宣称一个引擎并没有在执行的 READ 姿态(而 `read-face` restart 片仍在为它要一次重启)—— 那正是这条
+ *    轴上最危险的谎(读面说收紧了、执行面没有)。
+ * 落配、`applied` 日志、换席候选、重启片的指纹读的是**同一个**判据 —— core 把某席移进 / 移出闭集,四处自动一起走
+ * (core 7.51.0 把读拒三席移了进去,而 live 相的落配当时是一句手写的「deny 三键只在 boot 相落」,与另三处的派生读法分家:
+ * 重启片说「热了」、落配说「不落」,组织收紧读拒规则 ⇒ 既不生效也不要求重启。S-1560 收成一个判据)。
+ *
+ * ── 三条规则,每条都有失败方向的论证 ──────────────────────────────────────────────────────────
+ *
+ * ① **env 显式恒赢,逐键判**(operator-knob 律)。env 是**这台机器**的部署主权表达,center 是组织下发;
+ *    冲突时保留 env 并留一条点名 warn。为什么不照 6 闸的「center 覆盖 env」:那六闸是**限额/治理**面
+ *    (组织比单机更知道该收多紧),而 READ 容纳面描述的是**这台机器的磁盘上有什么** —— 运维在这台机器上
+ *    写下 `READ_FACE=roots` 时知道的事情,组织的下发面不知道。静默盖掉它是本仓「部署级旋钮」纪律的反面。
+ *    逐键而非整域:env 只写了 face 时,center 的三个 deny 键照常落(否则一个 env 键会把整片组织策略挡掉)。
+ *    判据 = **键在场**(`!== undefined`):`readDenyBuiltinTiers: []` 是 env `none` 的显式空姿态,
+ *    不是「没设过」—— 用真值判会把「一档内建都不要」这个显式表态判成缺席。
+ *    🔴 判在**基线**上(本机 env / posture,center 之前的值),不是判「键现在在不在场」:center 自己上一拍写下的值
+ *    也让键在场,拿它当 env 就会把组织自己的第二次发布挡在门外。
+ *
+ * ② **坏值整域拒 + 响亮**([ref] 安全轴)。任何一个成员过不了引擎自己的校验器 ⇒ 整个 readFace 域不落,
+ *    保留 env 前值 + warn 点名。两个方向都要:半应用一份 READ 姿态(收紧了一半)会让运维以为策略生效;
+ *    而 throw 会让一次坏发布把常驻进程炸掉(env 腿 throw 是对的 —— 那是启动期、由本机运维自己写的值)。
+ *    与 `stageApprovalRequire` 的域级拒绝先例同形。
+ *
+ * ③ **校验一律交给引擎**(`compileReadDeny` / `resolveReadDenyBuiltins`)。宿主不自造第二份判定语义,
+ *    与 env 腿逐字同款;且校验跑在**合成后的最终姿态**上(env 键 + center 键混合形),否则
+ *    「env 选了档位、center 删了一个不在该档里的行名」这类跨腿坏组合会漏过。
+ */
+import { type SwappableDeps } from "@sema-agent/core";
 import type { ServiceConfig } from "../config-types.js";
 import type { ReadFaceSource } from "../read-face-posture.js";
 import type { Logger } from "../observability/logger.js";
 import type { CenterReadFace, EffectiveConfig } from "./types.js";
-/**
- * S-174 —— 哪些 center 键是**热换席**。判据**不是本仓的意见**:`KEY_MAP` 的 `cfgKey` 落在 core 的闭集
- * `SWAPPABLE_DEP_SEATS` 里(经 `isSwappableDepSeat` 亲问)⇒ 这个键 refresh 期可换;否则它是 boot-baked
- * 座,只有重启能换。core 加/删可换席 ⇒ 本集合与 `read-face` restart 片的指纹**同时**跟着走,不留第二份
- * 手抄表(restart-signal.ts 读的就是这一只)。
- */
-export declare const CENTER_READ_FACE_LIVE_KEYS: ReadonlySet<keyof CenterReadFace>;
-/** 本进程的**前 center** READ face 姿态(env / posture / 引擎默认)。`live` 相必带 —— 一次发布**撤回**
- *  `face` 键时,活席要还原到它,而不是把上一份发布的档位无限期latch 住(那是这条轴上的 fail-OPEN 方向:
- *  组织把 `open` 撤回之后,worker 还在 open)。boot 相不需要:那一刻 `config` 上的值就是基线。 */
-export interface ReadFaceBaseline {
-    readonly readFace?: "open" | "roots";
+/** 四个 center 成员落到的 `ServiceConfig` 键 —— 同时就是 core 的席名(`SWAPPABLE_DEP_SEATS` 的成员名)。 */
+export type ReadFaceSeat = "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude";
+type ReadFaceSeatValues = {
+    readonly [K in ReadFaceSeat]?: ServiceConfig[K];
+};
+/** 本进程的**前 center** READ 姿态(env / posture / 引擎默认)—— 四键的值 + `readFace` 的来源。三处读它:
+ *  ① env-wins 判据(基线上谁被 env 占住);② `live` 相的撤回臂(一次发布**撤回**某键时,活席要还原到它,而不是把上一份发布的
+ *  值无限期 latch 住 —— 那是这条轴上的 fail-OPEN 方向:组织把 `open` / 一条 deny 规则撤回之后,worker 还在旧姿态上);
+ *  ③ 换席抛时的整体回滚(由 {@link buildReadFaceBaseline} 在调用前现取一份)。boot 相不需要传:那一刻 `config` 上的值就是基线。 */
+export type ReadFaceBaseline = ReadFaceSeatValues & {
     readonly readFaceSource: ReadFaceSource;
-}
-/** 本次调用落在哪一相(见文件头注「一席热、三席重启」)。判别联合而不是可选字段:`baseline` 只在
+};
+/** 取 `config` 此刻的 READ 姿态快照(纯数据;数组按引用 —— 本模块只整值替换、从不原地改)。 */
+export declare function buildReadFaceBaseline(config: ServiceConfig): ReadFaceBaseline;
+/** 把 `config` 的 READ 姿态整体写回一份快照(换席抛时的回滚;快照里缺席的键写回 `undefined`)。 */
+export declare function restoreReadFaceBaseline(config: ServiceConfig, snap: ReadFaceBaseline): void;
+export declare const CENTER_READ_FACE_LIVE_KEYS: ReadonlySet<keyof CenterReadFace>;
+/** 本次调用落在哪一相(见文件头注「逐席由引擎答」)。判别联合而不是可选字段:`baseline` 只在
  *  `live` 相有意义,写成可选就等于允许一次「没有基线的 live 调用」——那正是撤回臂会静默失效的形。 */
 export type CenterReadFaceApply = {
     readonly phase: "boot";
@@ -24,20 +68,29 @@ export type CenterReadFaceApply = {
     readonly phase: "live";
     readonly baseline: ReadFaceBaseline;
 };
-/** 调用回执。`envHeld` 同旧返回值(喂 `RestartSliceCtx.readFaceEnvHeld`);`faceChanged` 是 live 相的
- *  换席信号 —— 真 ⇒ 调用方必须 `swapDeps({ readFace: config.readFace })` 一次,否则 config 与 Runner 分家。 */
+/** 调用回执。`envHeld` 同旧返回值(喂 `RestartSliceCtx.readFaceEnvHeld`);`changedSeats` 是 live 相的换席信号 ——
+ *  这一拍**值真的变了**的活体席(按 {@link ReadFaceSeat} 席名)。非空 ⇒ 调用方必须把这些席的值 `swapDeps` 给全部 boot
+ *  Runner 一次,否则 config 与 Runner 分家。boot 相无人消费(Runner 还没建)。 */
 export interface CenterReadFaceReport {
     readonly envHeld: readonly (keyof CenterReadFace)[];
-    readonly faceChanged: boolean;
+    readonly changedSeats: readonly ReadFaceSeat[];
 }
 /**
- * 应用 center 的 readFace 域(**boot-only**:调用点在 boot 拉取之后、`createRunnerDeps` 之前)。
- * 缺席 ⇒ 零触碰。规则见文件头注 ①②③。
+ * 换席候选:`changed`(回执的 {@link CenterReadFaceReport.changedSeats})里每一席取 `seats` 里的值。
+ * `seats` 由调用方从部署姿态座席族的唯一属主取(`boot/runner-deps.ts` `buildDeploymentPostureSeats`)—— 席的**值**是座席族
+ * 铸的(例如 `readDenyPatterns` 并入 LKG 派生行),本模块只决定**换哪几席**。键在场即指令:值为 `undefined` 的席也进候选
+ * (core 据此把那一席清回引擎缺省 —— 撤回臂靠它兑现)。
+ */
+export declare function buildReadFaceSwapCandidate(seats: Pick<SwappableDeps, ReadFaceSeat>, changed: readonly ReadFaceSeat[]): SwappableDeps;
+/**
+ * 应用 center 的 readFace 域(boot 相:调用点在 boot 拉取之后、`createRunnerDeps` 之前;live 相:refresh 拍两条 commit 腿)。
+ * 缺席 ⇒ 零触碰(live 相:撤回臂把活体席还原到基线)。规则见文件头注 ①②③。
  *
- * 返回值 = **本机 env 显式占住的 center 键名**(与本次发布内容无关的部署事实)。调用方把它喂给
+ * 返回值 `envHeld` = **本机 env 显式占住的 center 键名**(与本次发布内容无关的部署事实)。调用方把它喂给
  * `RestartSliceCtx.readFaceEnvHeld`,`read-face` restart 片于是只指纹「真会 boot-bake 的那部分」——
  * 否则 center 改一个本机永远用不上的键,整片 fleet 会为一次对自己毫无影响的发布滚动重启一遍
  * (codex 交叉复审 finding 2,验真后采纳的那一半)。
  */
 export declare function applyCenterReadFace(config: ServiceConfig, eff: EffectiveConfig, logger?: Logger, apply?: CenterReadFaceApply): CenterReadFaceReport;
+export {};
 //# sourceMappingURL=read-face.d.ts.map

package/dist/web-admin-client/read-face.js

@@ -1,11 +1,43 @@
 import { compileReadDeny, isSwappableDepSeat, resolveReadDenyBuiltins } from "@sema-agent/core";
+export function buildReadFaceBaseline(config) {
+    return {
+        ...(config.readFace !== undefined ? { readFace: config.readFace } : {}),
+        readFaceSource: config.readFaceSource,
+        ...(config.readDenyPatterns !== undefined ? { readDenyPatterns: config.readDenyPatterns } : {}),
+        ...(config.readDenyBuiltinTiers !== undefined ? { readDenyBuiltinTiers: config.readDenyBuiltinTiers } : {}),
+        ...(config.readDenyBuiltinExclude !== undefined ? { readDenyBuiltinExclude: config.readDenyBuiltinExclude } : {}),
+    };
+}
+export function restoreReadFaceBaseline(config, snap) {
+    config.readFace = snap.readFace;
+    config.readFaceSource = snap.readFaceSource;
+    config.readDenyPatterns = snap.readDenyPatterns;
+    config.readDenyBuiltinTiers = snap.readDenyBuiltinTiers;
+    config.readDenyBuiltinExclude = snap.readDenyBuiltinExclude;
+}
 const KEY_MAP = [
-    { centerKey: "face", cfgKey: "readFace", envHolds: (c) => c.readFaceSource === "env" },
-    { centerKey: "denyPatterns", cfgKey: "readDenyPatterns", envHolds: (c) => c.readDenyPatterns !== undefined },
-    { centerKey: "denyBuiltinTiers", cfgKey: "readDenyBuiltinTiers", envHolds: (c) => c.readDenyBuiltinTiers !== undefined },
-    { centerKey: "denyBuiltinExclude", cfgKey: "readDenyBuiltinExclude", envHolds: (c) => c.readDenyBuiltinExclude !== undefined },
+    { centerKey: "face", cfgKey: "readFace", envHolds: (b) => b.readFaceSource === "env" },
+    { centerKey: "denyPatterns", cfgKey: "readDenyPatterns", envHolds: (b) => b.readDenyPatterns !== undefined },
+    { centerKey: "denyBuiltinTiers", cfgKey: "readDenyBuiltinTiers", envHolds: (b) => b.readDenyBuiltinTiers !== undefined },
+    { centerKey: "denyBuiltinExclude", cfgKey: "readDenyBuiltinExclude", envHolds: (b) => b.readDenyBuiltinExclude !== undefined },
 ];
-export const CENTER_READ_FACE_LIVE_KEYS = new Set(KEY_MAP.filter((r) => isSwappableDepSeat(r.cfgKey)).map((r) => r.centerKey));
+const LIVE_SEATS = new Set(KEY_MAP.filter((r) => isSwappableDepSeat(r.cfgKey)).map((r) => r.cfgKey));
+export const CENTER_READ_FACE_LIVE_KEYS = new Set(KEY_MAP.filter((r) => LIVE_SEATS.has(r.cfgKey)).map((r) => r.centerKey));
+function putCandidateSeat(candidate, key, value) {
+    candidate[key] = value;
+}
+export function buildReadFaceSwapCandidate(seats, changed) {
+    const candidate = {};
+    for (const seat of changed)
+        putCandidateSeat(candidate, seat, seats[seat]);
+    return candidate;
+}
+function putSeat(config, key, value) {
+    config[key] = value;
+}
+function sameSeatValue(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
 class ReadFaceDomainError extends Error {
 }
 function normalizeDenyPatterns(raw) {
@@ -44,18 +76,25 @@ function normalizeNameList(field, raw) {
     });
 }
 export function applyCenterReadFace(config, eff, logger, apply = { phase: "boot" }) {
-    const envHeldKeys = KEY_MAP.filter((r) => r.envHolds(config)).map((r) => r.centerKey);
-    const faceBefore = config.readFace;
-    const report = () => ({ envHeld: envHeldKeys, faceChanged: config.readFace !== faceBefore });
-    const revertFaceToBaseline = () => {
-        if (apply.phase !== "live")
+    const base = apply.phase === "live" ? apply.baseline : buildReadFaceBaseline(config);
+    const envHeldKeys = KEY_MAP.filter((r) => r.envHolds(base)).map((r) => r.centerKey);
+    const lands = (seat) => apply.phase === "boot" || LIVE_SEATS.has(seat);
+    const before = buildReadFaceBaseline(config);
+    const report = () => ({
+        envHeld: envHeldKeys,
+        changedSeats: KEY_MAP.filter((r) => LIVE_SEATS.has(r.cfgKey) && !sameSeatValue(before[r.cfgKey], config[r.cfgKey])).map((r) => r.cfgKey),
+    });
+    const revertToBaseline = (r) => {
+        if (apply.phase !== "live" || !lands(r.cfgKey))
             return;
-        config.readFace = apply.baseline.readFace;
-        config.readFaceSource = apply.baseline.readFaceSource;
+        putSeat(config, r.cfgKey, base[r.cfgKey]);
+        if (r.cfgKey === "readFace")
+            config.readFaceSource = base.readFaceSource;
     };
     const domain = eff.readFace;
     if (domain === undefined || domain === null) {
-        revertFaceToBaseline();
+        for (const r of KEY_MAP)
+            revertToBaseline(r);
         return report();
     }
     if (typeof domain !== "object" || Array.isArray(domain)) {
@@ -66,7 +105,7 @@ export function applyCenterReadFace(config, eff, logger, apply = { phase: "boot"
         return report();
     }
     const d = domain;
-    const envHeld = KEY_MAP.filter((r) => d[r.centerKey] !== undefined && r.envHolds(config)).map((r) => `${r.cfgKey} (readFace.${r.centerKey})`);
+    const envHeld = KEY_MAP.filter((r) => d[r.centerKey] !== undefined && r.envHolds(base)).map((r) => `${r.cfgKey} (readFace.${r.centerKey})`);
     let staged;
     try {
         const normalized = {
@@ -80,10 +119,12 @@ export function applyCenterReadFace(config, eff, logger, apply = { phase: "boot"
         if (normalized.readDenyBuiltinTiers !== undefined || normalized.readDenyBuiltinExclude !== undefined) {
             resolveReadDenyBuiltins(builtinsArg(normalized.readDenyBuiltinTiers, normalized.readDenyBuiltinExclude));
         }
-        staged = Object.fromEntries(KEY_MAP.filter((r) => !r.envHolds(config)).map((r) => [r.cfgKey, normalized[r.cfgKey]]).filter(([, v]) => v !== undefined));
-        const finalPatterns = staged.readDenyPatterns ?? config.readDenyPatterns;
-        const finalTiers = staged.readDenyBuiltinTiers ?? config.readDenyBuiltinTiers;
-        const finalExclude = staged.readDenyBuiltinExclude ?? config.readDenyBuiltinExclude;
+        staged = Object.fromEntries(KEY_MAP.filter((r) => !r.envHolds(base)).map((r) => [r.cfgKey, normalized[r.cfgKey]]).filter(([, v]) => v !== undefined));
+        const baseSeats = base;
+        const finalOf = (k) => staged[k] ?? (lands(k) ? baseSeats[k] : config[k]);
+        const finalPatterns = finalOf("readDenyPatterns");
+        const finalTiers = finalOf("readDenyBuiltinTiers");
+        const finalExclude = finalOf("readDenyBuiltinExclude");
         if (finalPatterns !== undefined)
             compileReadDeny(finalPatterns);
         if (finalTiers !== undefined || finalExclude !== undefined)
@@ -96,20 +137,19 @@ export function applyCenterReadFace(config, eff, logger, apply = { phase: "boot"
         });
         return report();
     }
-    if (staged.readFace !== undefined) {
-        config.readFace = staged.readFace;
-        config.readFaceSource = "center";
-    }
-    else {
-        revertFaceToBaseline();
-    }
-    if (apply.phase === "boot") {
-        if (staged.readDenyPatterns !== undefined)
-            config.readDenyPatterns = staged.readDenyPatterns;
-        if (staged.readDenyBuiltinTiers !== undefined)
-            config.readDenyBuiltinTiers = staged.readDenyBuiltinTiers;
-        if (staged.readDenyBuiltinExclude !== undefined)
-            config.readDenyBuiltinExclude = staged.readDenyBuiltinExclude;
+    const landed = [];
+    for (const r of KEY_MAP) {
+        if (!lands(r.cfgKey))
+            continue;
+        const v = staged[r.cfgKey];
+        if (v === undefined) {
+            revertToBaseline(r);
+            continue;
+        }
+        putSeat(config, r.cfgKey, v);
+        if (r.cfgKey === "readFace")
+            config.readFaceSource = "center";
+        landed.push(r.cfgKey);
     }
     if (envHeld.length > 0) {
         logger?.warn("web_admin_read_face_env_wins", {
@@ -117,13 +157,13 @@ export function applyCenterReadFace(config, eff, logger, apply = { phase: "boot"
             note: "this machine's explicit env READ-face keys WIN over the published readFace domain (deployment sovereignty) — the published values for these keys were NOT applied; unset the env key if the org publication should own it",
         });
     }
-    if (Object.keys(staged).length > 0) {
+    if (landed.length > 0) {
         logger?.info("web_admin_read_face", {
-            applied: Object.keys(staged).filter((k) => apply.phase === "boot" || KEY_MAP.some((r) => r.cfgKey === k && CENTER_READ_FACE_LIVE_KEYS.has(r.centerKey))),
-            ...(staged.readFace !== undefined ? { face: staged.readFace } : {}),
+            applied: landed,
+            ...(staged.readFace !== undefined && landed.includes("readFace") ? { face: staged.readFace } : {}),
             note: apply.phase === "boot"
                 ? "boot phase — every seat still bakes into the runner deps that are about to be assembled"
-                : "live phase — the read FACE is hot-swapped into every boot Runner (core swapDeps seat); the deny seats stay boot-baked and keep asking for the `read-face` restart slice",
+                : "live phase — the landed seats are hot-swapped into every boot Runner (core swapDeps seats); a seat the engine cannot hot-swap is not written here and keeps asking for the `read-face` restart slice",
         });
     }
     return report();

package/dist/web-admin-client/skills-mcp.d.ts

@@ -1,4 +1,4 @@
-import type { A2aServerSpec, McpServerSpec } from "@sema-agent/core";
+import { type A2aServerSpec, type McpServerSpec } from "@sema-agent/core";
 import type { CenterMcp, ScopedA2aPeer } from "../config-types.js";
 import type { Logger } from "../observability/logger.js";
 import type { LoadedSkill } from "../capabilities/skills.js";

package/dist/web-admin-client/skills-mcp.js

@@ -1,7 +1,7 @@
 import { readMcpSourceLabel } from "../mcp-source-label.js";
 import { readMcpToolFaces } from "../mcp-tool-faces.js";
-import { readMcpToolAxes } from "../mcp-tool-axes.js";
 import { skillContentHash } from "@sema-agent/settings-schema";
+import { readMcpToolAxes } from "@sema-agent/core";
 import { CONTENT_ORIGIN_WORDS, describeBadContentOrigin, isContentOriginWord } from "../mcp-content-origin.js";
 import { noteMcpAssertionHeaderNotSent } from "../mcp-assertion-header.js";
 import { SHA256_HEX_RE } from "../digest-form.js";

package/dist/web-admin-client/types.d.ts

@@ -157,9 +157,9 @@ export interface CenterMcpServer {
      * `McpServerSpec.toolAxes`。
      *
      * 🔴 类型是 `unknown` 而不是那个结构,**刻意的**(与 {@link CenterMcpServer.toolFaces} 逐字同姿):本类型是两条部署腿的**承载形**
-     * (本地 config.d 经 `z.unknown()` 解析透明地过来、远端 /effective 是直读 JSON),形判与投影的单一属主是 `mcp-tool-axes.ts` 的
-     * `readMcpToolAxes`(`resolveMcpServers` 在铸 spec 那一刻调它;产出的型是引擎的 `McpServerSpec["toolAxes"]`)。坏形 ⇒ 整条
-     * server 不进 + 一行 `web_admin_mcp_tool_axes_invalid`。
+     * (本地 config.d 经 `z.unknown()` 解析透明地过来、远端 /effective 是直读 JSON),形判与投影的单一属主是**引擎**根导出的
+     * `readMcpToolAxes`(core 7.51.2 #1763;`resolveMcpServers` 在铸 spec 那一刻调它;产出的型是引擎的 `McpServerSpec["toolAxes"]`;本仓自铸的那一只
+     * 7.129.0 退役)。坏形 ⇒ 整条 server 不进 + 一行 `web_admin_mcp_tool_axes_invalid`。
      * (同批解析透明键 `authForm` / `entryKind` 的语义归连接器,本层仍只承载。)
      */
     toolAxes?: unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.128.0",
+  "version": "7.129.1",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -64,7 +64,7 @@
     "build:binary:run-local:darwin-arm64": "bun build --compile --target=bun-darwin-arm64 src/run-local.ts --outfile dist/run-local-darwin-arm64"
   },
   "dependencies": {
-    "@sema-agent/core": "7.50.2",
+    "@sema-agent/core": "7.51.2",
     "@sema-agent/settings-schema": "12.2.1",
     "e2b": "^2.28.0",
     "libsodium-wrappers": "^0.8.4",
@@ -80,7 +80,7 @@
     "sharp": "^0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "21.1.0",
+    "@sema-agent/sdk": "23.0.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",

package/dist/mcp-tool-axes.d.ts

@@ -1,62 +0,0 @@
-/**
- * `McpServerSpec.toolAxes` —— 部署侧为一台 MCP 服务器的**每只工具**声明的风险轴(`effect` / `egress` /
- * `irreversibility`),键 = 该 server 的**原始(未加命名空间)**工具名。声明面 = settings-schema 12.2.x 的 MCP 条目
- * 解析透明键(`z.unknown()`);引擎侧 = `McpServerSpec.toolAxes`(喂审批门与计划模式围栏的信任根轴)。
- *
- * ## 一只读器、一处投影
- * 两条部署腿(本地 `config.d/mcp.json` 经 `LocalConfigProvider` / 中心 `/effective.mcp` 经远端读腿)都落到
- * `web-admin-client/skills-mcp.ts resolveMcpServers` 这一只铸 spec 的函数(boot 与 run-local 共用),所以本模块
- * 的形判与投影**只有这一处**;本地承载腿(`config-provider.ts`)只搬运、不判形 —— 与 `mcp-tool-faces.ts`
- * 同一种「判据单点」的形。
- *
- * ## 词表来自哪(本模块一个词都不枚举)
- * `effect` / `irreversibility` 两个闭集词轴的判据是 `tool-axis-words.ts` 的**共用谓词**(`isToolEffect` /
- * `isToolAxisIrreversibility`;那一份词表的两向门钉死在引擎的型上:引擎加词 / 删词 ⇒ 编译红)。`egress` 是裸布尔,
- * 没有词表。条目的**成员集**同样不抄一份:`AXIS_MEMBERS` 以 `satisfies Record<keyof ToolAxisEntry, true>` 取引擎型的键,
- * 引擎给轴条目加新成员 ⇒ 这里编译红(而不是把一个合法的新成员当未知键拒、或当已知键漏判)。
- *
- * ## 为什么本层只判形,不判语义组合
- * 轴值之间的语义关系(例如 `effect:"read"` 与 `egress:true` 并存)归引擎的摄入侧判 —— 与 `toolFaces` 同一条分工:
- * 本层不复述引擎的规则表,只做引擎的校验器**假定成立**的那一件事:JSON 结构合不合 TS 型。原样透传一份任意 JSON
- * 不是「解析透明」,是把类型错误变成运行期的更难读的失败。
- *
- * ## 坏形的方向:整条 server 不进(fail-closed;与 `toolFaces` 同方向)
- * `toolAxes` 是**双向**声明:`effect:"read"` / `egress:false` / `irreversibility:"never"` 能让一次调用免审或降档(放宽),
- * `egress:true` / `irreversibility:"always"` 又能把一次调用的风险抬高(收窄)。所以对任何一个坏形,「丢掉那个键、留下
- * server」都落在安全轴上的静默一侧 —— 要么让一条写错的信任根声明静默失效(运维以为写了保护,引擎读到缺席),要么让它
- * 静默地以残缺形生效(留 `effect:"read"` 丢坏形 `egress`,拼出引擎判为更宽的形)。仓规([ref])不许安全轴上有静默兜底,
- * 判据因此回到本仓对收窄键成文的那一条:**一个键在场就必须合法,否则这条 server 整条不进**。每只工具的条目**整只**判,
- * 而**任一只**判不出形 ⇒ 整条 server 不进(「留下好的那几只」同样是让坏的那一只带着缺失的声明挂载)。
- *  ① 谁需要 —— 在部署侧为 MCP / 连接器工具声明效应轴的运维;
- *  ② 谁受伤 —— 写错的那台 server:它**整条**不挂(兄弟 server 照挂,名字仍被部署占着、请求腿补不了位)。代价是真的
- *     (少一套工具),但它**响亮且立刻**;反方向的代价是一条静默失效或静默走样的信任根声明;
- *  ③ 拿什么补偿 —— `web_admin_mcp_tool_axes_invalid{server,problem,note}` 一条点名 warn,`problem` 指到工具名与哪一段不合
- *     (只带工具名与成员名,不带值);运维照着改那一行重发布即可。
- *
- * ## 与请求腿的边界(刻意不同的信任根)
- * 请求腿(`task-mcp.ts`)对调用方自带的 `toolAxes` 另有一份**调用方信任根**的读法(单用户闸:调用方对自己的选择负责,
- * 坏成员逐键诚实剔除而不 400)。部署腿声明的是**运维对每一个租户、每一次任务**的担保,没有「调用方自己承担」这回事,
- * 所以坏形必须响亮地拒。两个读器今天并存、方向不同,是两个信任根各自的读法;本模块不替请求腿改判。
- */
-import type { McpServerSpec } from "@sema-agent/core";
-type ToolAxes = NonNullable<McpServerSpec["toolAxes"]>;
-/**
- * 一条 server 条目的 `toolAxes` 判形结果:
- *  · `{ ok: true, toolAxes }` —— 合形;`toolAxes` 缺席 = 这台 server 没有声明,或声明的全是空(`{}` / `{ t: {} }`:对引擎同义于缺席),不铸键;
- *  · `{ ok: false, problem }` —— 判不出形,**整条 server 不进**(方向与理由见模块头注),`problem` 是给运维的一句点名
- *    (只带工具名与成员名,不带值)。
- */
-export type McpToolAxesRead = {
-    ok: true;
-    toolAxes?: ToolAxes;
-} | {
-    ok: false;
-    problem: string;
-};
-/**
- * 从一条部署侧 server 条目的原始 `toolAxes` 读出引擎 spec 的 `toolAxes` —— **两条部署腿共用的唯一判据与投影点**。
- * 缺席 ⇒ 合形无声明;整只不是对象 / 工具名为空 / **任一只**工具的条目判不出形 ⇒ `ok:false`(调用方整条 server 不收)。
- */
-export declare function readMcpToolAxes(raw: unknown): McpToolAxesRead;
-export {};
-//# sourceMappingURL=mcp-tool-axes.d.ts.map

package/dist/mcp-tool-axes.js

@@ -1,47 +0,0 @@
-import { isToolAxisIrreversibility, isToolEffect } from "./tool-axis-words.js";
-const AXIS_MEMBERS = { effect: true, egress: true, irreversibility: true };
-const AXIS_MEMBER_NAMES = Object.keys(AXIS_MEMBERS);
-function isRecord(v) {
-    return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function describeKind(v) {
-    return v === null ? "null" : Array.isArray(v) ? "an array" : typeof v;
-}
-function readOneEntry(raw) {
-    if (!isRecord(raw))
-        return `the declaration is ${describeKind(raw)}, not an object of axes`;
-    for (const member of Object.keys(raw)) {
-        if (!AXIS_MEMBER_NAMES.includes(member))
-            return `unknown member ${JSON.stringify(member)}`;
-    }
-    const { effect, egress, irreversibility } = raw;
-    if (effect !== undefined && !isToolEffect(effect))
-        return "member effect is not a word the engine knows";
-    if (egress !== undefined && typeof egress !== "boolean")
-        return "member egress is not a boolean";
-    if (irreversibility !== undefined && !isToolAxisIrreversibility(irreversibility))
-        return "member irreversibility is not a word the override face accepts";
-    return {
-        ...(effect !== undefined ? { effect } : {}),
-        ...(egress !== undefined ? { egress } : {}),
-        ...(irreversibility !== undefined ? { irreversibility } : {}),
-    };
-}
-export function readMcpToolAxes(raw) {
-    if (raw === undefined)
-        return { ok: true };
-    if (!isRecord(raw))
-        return { ok: false, problem: `toolAxes is ${describeKind(raw)}, not an object of per-tool axis declarations` };
-    const entries = [];
-    for (const [tool, rawEntry] of Object.entries(raw)) {
-        if (tool.length === 0)
-            return { ok: false, problem: "toolAxes has an empty tool name" };
-        const entry = readOneEntry(rawEntry);
-        if (typeof entry === "string")
-            return { ok: false, problem: `the declared axes for tool ${JSON.stringify(tool)} do not fit: ${entry}` };
-        if (Object.keys(entry).length > 0)
-            entries.push([tool, entry]);
-    }
-    return entries.length > 0 ? { ok: true, toolAxes: Object.fromEntries(entries) } : { ok: true };
-}
-//# sourceMappingURL=mcp-tool-axes.js.map