@sema-agent/server 7.43.0 → 7.44.0

package/dist/config-center/restart-signal.js

@@ -1,15 +1,6 @@
-/**
- * Restart-to-apply CHANGE detection — the structured `RestartSignal` an orchestrator consumes (GET /health →
- * `restart`), computed against the process's BOOT config (not presence, else a refresh would re-fire the same
- * diff and loop-restart). Also owns the model-plane deferral predicates (`planeHasActiveTiers`/
- * `modelPlaneChanged`) main.ts uses to decide whether a hot-apply is safe under a tier-frozen Runner. Split out
- * of `facade.ts` (design/158 A13, internal-lossless — the facade re-exports every symbol below unchanged).
- */
 import { resolveActiveTiers } from "@sema-agent/registry-core";
 import { RUNTIME_GATE_KEYS, HOT_RUNTIME_GATE_KEYS, runtimeGatePresent, resolveDefaultModelName } from "./apply-effective.js";
 const RESTART_SLICES = ["skills", "mcp", "a2a", "scenarios", "runtime-gates", "models-tiers", "degrade-route", "read-face"];
-/** Canonical, key-sorted JSON (array order preserved) so two semantically-equal effective slices fingerprint
- *  identically regardless of object key order from the center serializer. */
 function stableStringify(v) {
     if (v === null || typeof v !== "object")
         return JSON.stringify(v) ?? "null";
@@ -21,43 +12,15 @@ function stableStringify(v) {
         .map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`)
         .join(",")}}`;
 }
-/** The comparable value of one restart-to-apply slice (undefined config / unpublished slice → null, so
- *  "center started/stopped publishing skills" is itself a detectable change). Skills/MCP/scenarios fingerprint
- *  ONLY the ENABLED entries — the runtime consumers (applyCenterSkills / resolveMcpServers / centerScenarios) skip
- *  `enabled:false`, so a disabled entry's content has zero runtime effect and must NOT trigger a restart.
- *  Every enable/disable FLIP still changes the filtered set → still triggers, correctly. */
 function enabledOnly(rows) {
     if (!rows)
         return null;
     return rows.filter((r) => r.enabled !== false);
 }
-/** One catalog entry, reduced to the fields whose change is genuinely restart-to-apply. Consumers of a
- *  boot-frozen catalog entry read almost every field on the FULLY-DERIVED Model (`toModel`) — id → body.model,
- *  baseUrl → the endpoint, provider → which brain, maxTokens/compat/extraBody/input → the request body,
- *  apiKeyEnv/sealedApiKey → the credential — so we fingerprint the WHOLE entry minus the three provably HOT
- *  fields:
- *    - `cost`        — refreshed by `mutateInPlace(pricing, buildPricing(config.models))`, and core prefers
- *                      `deps.pricing[model.id]` over the (possibly frozen) `Model.cost`; `toModel` always emits
- *                      a cost object, so every center-lane model has a live pricing entry.
- *    - `quotaWeight` — refreshed by `mutateInPlace(config.modelQuotaWeights, …)`, read live per burn.
- *    - `enabled`     — `enabledOnly` already filtered on it, so among the entries that reach here it is
- *                      `true`-or-absent: two encodings of ONE state. Keeping it would let a center serializer
- *                      that starts/stops emitting the explicit `true` manufacture a restart out of nothing.
- *                      Every real enable/disable FLIP changes the filtered SET, so it still signals.
- *  A DENY-list (not an allow-list) on purpose: a catalog field added later rides the fingerprint automatically,
- *  so the failure mode of drift is a spurious restart, never a silently missed one.
- *
- *  Shared by BOTH catalog-entry fingerprints (`degrade-route`, `models-tiers` + `modelPlaneChanged`) since the
- *  复审 2026-07-29 留档: models-tiers had kept all three, so on a tiers-active deployment a pure re-pricing /
- *  weight tweak / serializer writing `enabled:true` rolling-restarted the fleet. The two fingerprints must
- *  subtract the SAME set — under active tiers `modelPlaneChanged` defers the plane and the refresh loop then
- *  FORCE-pushes the `models-tiers` reason for a deferred candidate (boot/config-center.ts R15/R22), so
- *  subtracting in only one of them is either no-op (restart still fires) or incoherent (applied yet signalled). */
 function catalogEntryFingerprint(entry) {
     const { cost: _cost, quotaWeight: _quotaWeight, enabled: _enabled, ...route } = entry;
     return route;
 }
-/** The enabled entries of a model plane, each reduced by `catalogEntryFingerprint` (null = no plane published). */
 function planeEntriesFingerprint(rows) {
     const enabled = enabledOnly(rows);
     return enabled ? enabled.map((m) => catalogEntryFingerprint(m)) : null;
@@ -71,9 +34,6 @@ function restartSliceValue(eff, slice, ctx) {
         case "mcp":
             return enabledOnly(eff.mcp?.servers);
         case "a2a":
-            // 与 mcp 逐字同形:只指纹 ENABLED 条目(`resolveA2aPeers` 跳过 `enabled:false`,所以被禁条目的
-            // 内容零运行期效果),整条记录进指纹(url/cardUrl/headerRefs/principalHeader/allowSkills/scenarios
-            // 全是运行期相关字段;DENY-list 都不需要——本域没有 cost/quotaWeight 那种热字段)。
             return enabledOnly(eff.a2a?.peers);
         case "scenarios":
             return enabledOnly(eff.scenarios?.scenarios);
@@ -82,38 +42,21 @@ function restartSliceValue(eff, slice, ctx) {
             if (!rt)
                 return null;
             const present = {};
-            // #322 批1:限额五闸已转热(stage-limits 双腿写入)⇒ **不再进指纹**。留在里面的话,一次纯限额发布
-            // 会让整片 fleet 为一个已经生效的变更滚动重启一遍——而重启后的姿态与重启前逐字相同(read-face 的
-            // env-held 剔除同族论证)。剩下的 approvalRequire 仍是 boot-baked,归批2。
             for (const k of RUNTIME_GATE_KEYS)
                 if (!HOT_RUNTIME_GATE_KEYS.has(k) && runtimeGatePresent(rt, k))
                     present[k] = rt[k];
             return Object.keys(present).length ? present : null;
         }
         case "models-tiers": {
-            // Fingerprint the models+tiers pair ONLY when this side resolves an active tier table (the Runner-copy
-            // decoupling only exists under tiers). Tier-less side → null: both sides tier-less never signals (hot-apply
-            // is real there); a tiers on/off FLIP is itself a detectable change (null vs object) — correctly signals,
-            // because the flip only takes effect at Runner construction.
             const active = eff.models ? resolveActiveTiers(eff.models) : undefined;
             if (!active || Object.keys(active).length === 0)
                 return null;
             const enabled = enabledOnly(eff.models?.models);
-            // codex R8: the resolved DEFAULT rides the fingerprint too — the Runner's frozen copy carries its own
-            // boot-time `default` entry, so a refresh that ONLY moves the default source (models.default /
-            // roles.default / tier binding) re-points config.models.default while spec.model="default" keeps routing
-            // the stale Runner entry. SAME resolver as applyEffective (resolveDefaultModelName, single source);
-            // dangling candidates fall through silently here — applyEffective owns the warn.
             const names = new Set((enabled ?? []).map((m) => m.name));
             const def = resolveDefaultModelName(eff, (n) => names.has(n), enabled?.[0]?.name ?? "");
-            // Entries reduced by the shared deny-list (cost/quotaWeight/enabled are hot — see catalogEntryFingerprint).
             return { models: planeEntriesFingerprint(eff.models?.models), tiers: active, default: def.name };
         }
         case "read-face": {
-            // 指纹的是**真会 boot-bake 的那部分**:域里被本机 env 占住的成员剔除(codex finding 2 —— 旧实现
-            // 指纹原始域,于是 center 改一个本机永远用不上的键也会让整片 fleet 滚动重启一遍,而重启后姿态
-            // 逐字不变)。域缺席、或全部成员都被 env 占住 ⇒ null:两者对**本机**是同一件事(这条腿不存在),
-            // 于是「组织开始/停止发布 READ 面」在真会生效的那些键上仍然可检测。
             const d = eff.readFace;
             if (!d)
                 return null;
@@ -124,30 +67,18 @@ function restartSliceValue(eff, slice, ctx) {
         case "degrade-route": {
             const to = ctx?.reactiveDegradeTo;
             if (to === undefined)
-                return null; // lane off — no degrading brain exists to go stale
-            // Present↔absent is itself a change: with no enabled entry named `to`, createBrain composes NO
-            // degrading shell at all, so the flip only takes effect at the next boot.
+                return null;
             const target = (enabledOnly(eff.models?.models) ?? []).find((m) => m.name === to);
             return target ? catalogEntryFingerprint(target) : null;
         }
     }
 }
-/** Restart-to-apply slices that DIFFER between this process's BOOT config and a freshly-pulled one. Empty =
- *  nothing baked-at-boot changed (only hot-apply slices moved, or nothing) → no restart needed. An orchestrator
- *  can auto rolling-restart on a non-empty result WITHOUT a restart loop, because the comparison is always
- *  against boot (a refresh that re-fires the same diff is idempotent, not a fresh trigger). */
 export function restartReasons(boot, current, ctx) {
     return RESTART_SLICES.filter((s) => {
         const b = restartSliceValue(boot, s, ctx);
         const c = restartSliceValue(current, s, ctx);
         if (stableStringify(b) === stableStringify(c))
             return false;
-        // #324:撤销台账腿在场时,mcp 片的**纯删除向**不签 —— 删除已被台账即时承接(core 每次 dispatch 前
-        // 探 isRevoked),签了就是为一个已生效的变更滚动重启 fleet。判据=**保序严格子序列**(codex F3,
-        // confirmed:旧判据用 Set 成员测,[A,B]→[B,A] 纯重排两侧指纹不等、每条又都在 boot 集 ⇒ 被误豁免,
-        // 而服务器顺序是 mount 语义〔工具串接序〕,重排只能 restart 生效;删除+重排混合同理——存留条目的
-        // 相对顺序必须与 boot 逐字一致才是「纯删除」)。任何新增/改形/重排照签;域整体出现/消失(null↔数组)
-        // 不是删除向,保守照签。ctx 键缺席 = 席没接线 ⇒ 旧语义照签(fail-closed,#157)。
         if (s === "mcp" && ctx?.mcpRevocationLive === true && Array.isArray(b) && Array.isArray(c) && c.length < b.length) {
             const bootFps = b.map(stableStringify);
             let bi = 0;
@@ -163,18 +94,6 @@ export function restartReasons(boot, current, ctx) {
         return true;
     });
 }
-/** codex R10 (models-tiers 窗收口): TRUE when the MODEL PLANE (enabled models + active tier table + resolved
- *  default) of `next` differs from the last-APPLIED plane `prev`. Under a tier-frozen Runner (tiers non-empty at
- *  construction → private expanded copy) main.ts DEFERS the whole plane mutation until restart when this is true —
- *  admission (/v1/models, the catalog gates) and the Runner then stay on ONE generation through the restart
- *  window, so a same-key retarget can never silently route/bill the stale Model object. `prev === undefined`
- *  (env-boot plane, no EffectiveConfig to compare) is conservatively "changed" — one deferred adoption + restart
- *  converges. Deliberately NOT gated on tier activity of either side (unlike the restart slice): a frozen Runner
- *  goes stale on ANY plane change, including a tiers-off flip. */
-/** codex R12: TRUE when this candidate resolves an ACTIVE tier table. Used by main.ts's defer predicate — a
- *  tier-less-booted Runner never re-runs expandTiers, so hot-applying an ARRIVING tier table splits admission
- *  (tier words pass the expanded gate) from execution (core throws "Unknown model ref"). Hot-apply of the model
- *  plane is safe only when BOTH the constructed generation and the candidate are tier-less. */
 export function planeHasActiveTiers(eff) {
     const active = eff.models ? resolveActiveTiers(eff.models) : undefined;
     return active !== undefined && Object.keys(active).length > 0;
@@ -187,9 +106,6 @@ export function modelPlaneChanged(prev, next) {
         const active = e.models ? (resolveActiveTiers(e.models) ?? null) : null;
         const names = new Set((enabled ?? []).map((m) => m.name));
         const def = resolveDefaultModelName(e, (n) => names.has(n), enabled?.[0]?.name ?? "");
-        // Same reduction as the models-tiers slice — the two MUST subtract the same hot fields (see
-        // catalogEntryFingerprint): a deferred candidate force-pushes that slice's reason, so any divergence
-        // either re-manufactures the restart we just subtracted or signals a plane that was applied hot.
         return stableStringify({ models: planeEntriesFingerprint(e.models?.models), tiers: active, default: def.name });
     };
     return fp(prev) !== fp(next);

package/dist/config-center/skills-mcp.d.ts

@@ -28,7 +28,7 @@ export declare function resolveMcpServers(mcp: {
     servers: CenterMcpServer[];
 }, logger?: Logger): ScopedMcpServer[];
 /** The MCP servers applicable to a scenario: tagged with it, or untagged (global). undefined when none.
- *  #273 alias 窗:标签写**旧场景名**的条目同样命中(`scenarioConfigKeys`,同 `skillsForScenario`)。 */
+ *  #342:alias 窗撤销,单键命中(同 `skillsForScenario`)。 */
 export declare function mcpForScenario(servers: ScopedMcpServer[] | undefined, scenario: string): McpServerSpec[] | undefined;
 /**
  * DESIGN-269 §2.1 —— resolve center A2A peers (`/effective.a2a`) into core `A2aServerSpec`s + the scenarios

package/dist/config-center/skills-mcp.js

@@ -1,30 +1,7 @@
-/**
- * Small consumption lanes that all project a center manifest domain onto a per-request runtime shape:
- * skills application (`applyCenterSkills` — merge center skills OVER the image baseline, content-addressed
- * fetch+verify+cache), MCP server resolution (`resolveMcpServers`/`mcpForScenario` — env-NAME ref
- * resolution + per-scenario filtering) and — since DESIGN-269 车1 — A2A peer resolution
- * (`resolveA2aPeers`/`a2aForScenario`, the same two rules on the agent-to-agent lane; it lives HERE rather
- * than in a new file because it shares `resolveRefs`, and a secret-boundary rule with two implementations
- * is a rule with one that will drift). Split out of `facade.ts` (design/158 A13, internal-lossless —
- * the facade re-exports every symbol below unchanged).
- */
 import { skillContentHash } from "@sema-agent/registry-core";
-import { scenarioConfigKeys } from "../capabilities/scenario-alias.js";
 import { fetchSkillContent } from "./http-client.js";
 import { SHA256_HEX_RE } from "../digest-form.js";
-/**
- * Merge center skills OVER the image baseline (design/41-sibling B1; `sema-registry docs/MCP-SKILLS.md`). Load order =
- * `loadSkills(SKILLS_DIR)` baseline → center skills lazily fetched by hash and overlaid BY NAME (center
- * wins on a clash → can override a built-in; guarded center-side by publisher RBAC + the publish gate).
- * `enabled:false` is skipped. Content is verified + cached by hash (same hash fetched once). A skill whose
- * content fetch/verify fails is skipped (the baseline version, if any, stays) — never blocks startup.
- * Restart-to-apply: this runs at boot, before `buildScenarios` bakes skills into scenarios.
- */
-export async function applyCenterSkills(baseline, manifest, baseUrl, token, logger, fetchImpl = fetch, 
-/** LKG 姊妹面(clay 拍 2026-07-18):skill 正文的 content-addressed 盘缓存目录。读序=内存→盘(验
- *  hash,坏文件忽略)→中心(成功后 best-effort 回写)。让 LKG-boot 在中心不可达时不再于正文拉取上
- *  挂数秒(live 实测黑洞 +5.3s/skill 批),顺带省正常 refresh 的重复拉取。undefined=无盘缓存(原行为)。 */
-diskCacheDir) {
+export async function applyCenterSkills(baseline, manifest, baseUrl, token, logger, fetchImpl = fetch, diskCacheDir) {
     const { promises: fsp } = await import("node:fs");
     const { join: joinPath } = await import("node:path");
     const diskRead = async (hash) => {
@@ -32,21 +9,17 @@ diskCacheDir) {
             return undefined;
         const hex = hash.replace(/^sha256:/, "");
         if (!SHA256_HEX_RE.test(hex))
-            return undefined; // hash 形不对=不碰盘(路径安全)
+            return undefined;
         try {
             const text = await fsp.readFile(joinPath(diskCacheDir, hex), "utf8");
             if (skillContentHash(text) === hash)
-                return text; // content-addressed:必验,坏文件=undefined 走中心
+                return text;
             logger?.warn("sema_registry_skill_cache_corrupt", { hash, note: "on-disk body fails its own hash — ignored, refetching from center" });
         }
         catch {
-            /* absent/unreadable → center */
         }
         return undefined;
     };
-    // F5(LKG 复审三轮):写盘 promises 收集、函数返回前 await——fire-and-forget 会让 persistLkgDurable
-    // 的「先落正文再发信号」序失效(await 只等到 fetch,rename 还在飞,窗口内重启=离线 boot 缺 skill)。
-    // 单写失败仍 warn 软降级(收集的是 catch 过的 promise,Promise.all 不会炸)。
     const pendingWrites = [];
     const diskWrite = (hash, content) => {
         if (!diskCacheDir)
@@ -60,8 +33,8 @@ diskCacheDir) {
         })().catch((err) => logger?.warn("sema_registry_skill_cache_write_failed", { hash, err: String(err) })));
     };
     const byName = new Map(baseline.map((s) => [s.spec.name, s]));
-    const contentCache = new Map(); // content-addressed: same hash fetched once
-    const seenNames = new Set(); // duplicate names WITHIN the center manifest collapse last-wins — warn so a bad publish is diagnosable
+    const contentCache = new Map();
+    const seenNames = new Set();
     for (const m of manifest.skills ?? []) {
         if (m.enabled === false)
             continue;
@@ -74,7 +47,7 @@ diskCacheDir) {
                 content = await diskRead(m.contentHash);
             if (content === undefined) {
                 content = await fetchSkillContent(baseUrl, token, m.contentHash, fetchImpl);
-                diskWrite(m.contentHash, content); // best-effort 回写(content-addressed,幂等)
+                diskWrite(m.contentHash, content);
             }
             contentCache.set(m.contentHash, content);
             const overrodeBuiltin = byName.has(m.name);
@@ -85,16 +58,9 @@ diskCacheDir) {
             logger?.warn("sema_registry_skill_failed", { name: m.name, hash: m.contentHash, err: String(err), note: "keeping baseline if any; skipping center version" });
         }
     }
-    await Promise.all(pendingWrites); // F5:返回=正文已 durable(或已 warn),调用方的落盘序才成立
+    await Promise.all(pendingWrites);
     return [...byName.values()];
 }
-/** Resolve env-NAME refs (target-key → ENV_NAME) to real values from THIS service's env. Returns null when
- *  ANY referenced env var is unset → the caller skips the whole server (fail-safe: never wire a half-credentialed
- *  endpoint). Mirrors the missing-apiKeyEnv handling for models (the secret boundary is unchanged).
- *
- *  `event`/`skipNote` are per-lane so an operator reading logs sees WHICH lane dropped an entry (MCP server vs
- *  A2A peer) — the resolution rule itself is one function on purpose (two copies of a secret-boundary rule is
- *  how one of them drifts open). */
 function resolveRefs(refs, server, kind, logger, event = "sema_registry_mcp_env_missing", skipNote = "skipping this MCP server — referenced env var is unset in this service") {
     if (!refs)
         return {};
@@ -109,20 +75,12 @@ function resolveRefs(refs, server, kind, logger, event = "sema_registry_mcp_env_
     }
     return out;
 }
-/**
- * Resolve center MCP servers (`/effective.mcp`) into core `McpServerSpec`s + the scenarios each applies to.
- * env-NAME refs → real values from THIS service's env (secret boundary unchanged); a server with any missing
- * ref is skipped (`resolveRefs` → null). `enabled:false` skipped. Restart-to-apply (filtered per scenario in
- * `resolveSpec` via `mcpForScenario`).
- */
 export function resolveMcpServers(mcp, logger) {
     const out = [];
     for (const s of mcp.servers ?? []) {
         if (s.enabled === false)
             continue;
         const allow = s.allowTools && s.allowTools.length > 0 ? { allowTools: s.allowTools } : {};
-        // E23 (shell-host contract): carry the per-server inbound-elicitation opt-in onto McpServerSpec.elicitation. Only when
-        // explicitly true (default OFF / fail-closed) — core advertises the capability only when this AND onElicit hold.
         const elicit = s.elicitation === true ? { elicitation: true } : {};
         if (s.transport.kind === "stdio") {
             const env = resolveRefs(s.transport.envRefs, s.name, "env", logger);
@@ -147,32 +105,12 @@ export function resolveMcpServers(mcp, logger) {
         logger?.info("sema_registry_mcp", { servers: out.map((s) => s.spec.name) });
     return out;
 }
-/** The MCP servers applicable to a scenario: tagged with it, or untagged (global). undefined when none.
- *  #273 alias 窗:标签写**旧场景名**的条目同样命中(`scenarioConfigKeys`,同 `skillsForScenario`)。 */
 export function mcpForScenario(servers, scenario) {
     if (!servers || servers.length === 0)
         return undefined;
-    const keys = scenarioConfigKeys(scenario);
-    const hit = servers.filter((s) => s.scenarios.length === 0 || keys.some((n) => s.scenarios.includes(n))).map((s) => s.spec);
+    const hit = servers.filter((s) => s.scenarios.length === 0 || s.scenarios.includes(scenario)).map((s) => s.spec);
     return hit.length > 0 ? hit : undefined;
 }
-/**
- * DESIGN-269 §2.1 —— resolve center A2A peers (`/effective.a2a`) into core `A2aServerSpec`s + the scenarios
- * each applies to. Exact sibling of {@link resolveMcpServers}, same three rules:
- *   · header-NAME refs → real values from THIS service's env (the secret boundary is unchanged — the center
- *     never holds the bearer). A peer with ANY missing ref is SKIPPED wholesale (`resolveRefs` → null):
- *     dialing a remote AGENT with half the credentials is the wrong failure direction.
- *   · `enabled:false` skipped.
- *   · restart-to-apply (filtered per scenario in `resolveSpec` via {@link a2aForScenario}).
- *
- * ⚠️ **No `toolAxes` on the center face, deliberately** (this is where the A2A lane STOPS mirroring MCP):
- * core's ruling is that a caller override is the ONLY trusted way down from the fail-closed
- * `egress:true`+`effect:"write"` default, and it names the CALLER as that trust root. An operator lowering
- * an axis in center config would be vouching, on behalf of every future task, that a REMOTE agent's skill
- * only reads — a claim the operator cannot actually verify and which core's own doc-comment reserves for
- * the caller. Absent face > a face that quietly launders trust. (`allowSkills` is the operator's real
- * knob here: narrow WHAT mounts, never re-label what it does.)
- */
 export function resolveA2aPeers(a2a, logger) {
     const out = [];
     for (const p of a2a.peers ?? []) {
@@ -197,15 +135,10 @@ export function resolveA2aPeers(a2a, logger) {
         logger?.info("sema_registry_a2a", { peers: out.map((p) => p.spec.name) });
     return out;
 }
-/** The A2A peers applicable to a scenario: tagged with it, or untagged (global). undefined when none.
- *  Twin of {@link mcpForScenario} — `undefined` (not `[]`) is load-bearing: an empty array would put an
- *  `a2a: []` key on the spec, i.e. "this deployment declares an empty peer set", where absence means
- *  "this leg does not exist here". */
 export function a2aForScenario(peers, scenario) {
     if (!peers || peers.length === 0)
         return undefined;
-    const keys = scenarioConfigKeys(scenario); // #273 alias 窗:旧场景名标签同样命中(同 mcpForScenario)
-    const hit = peers.filter((p) => p.scenarios.length === 0 || keys.some((n) => p.scenarios.includes(n))).map((p) => p.spec);
+    const hit = peers.filter((p) => p.scenarios.length === 0 || p.scenarios.includes(scenario)).map((p) => p.spec);
     return hit.length > 0 ? hit : undefined;
 }
 //# sourceMappingURL=skills-mcp.js.map

package/dist/config-center/stage-limits.js

@@ -5,18 +5,12 @@ const INFRA_RATE_KEYS = ["toolCallMicroUsd", "sandboxSecMicroUsd", "egressGbMicr
 const okNum = (v) => typeof v === "number" && Number.isFinite(v);
 const atLeast = (key, v, min) => okNum(v) && v >= min ? { ok: true, value: v } : { ok: false, reason: `${key} must be a finite number >= ${min}` };
 const positive = (key, v) => okNum(v) && v > 0 ? { ok: true, value: v } : { ok: false, reason: `${key} must be a finite number > 0` };
-/** 逐键判据。**坏值一律拒整批**(不夹取、不丢弃)——见文件头注纪律 3。 */
 const VALIDATORS = {
-    rateLimitPerMin: (v) => atLeast("rateLimitPerMin", v, 0), // 0 = 关断哨兵
-    maxPrincipalCostUsd: (v) => atLeast("maxPrincipalCostUsd", v, 0), // 0 = 无配额
-    costQuotaWindowSec: (v) => positive("costQuotaWindowSec", v), // core 拿它做除数
+    rateLimitPerMin: (v) => atLeast("rateLimitPerMin", v, 0),
+    maxPrincipalCostUsd: (v) => atLeast("maxPrincipalCostUsd", v, 0),
+    costQuotaWindowSec: (v) => positive("costQuotaWindowSec", v),
     maxTaskCostUsd: (v) => atLeast("maxTaskCostUsd", v, 0),
     maxTaskTokens: (v) => atLeast("maxTaskTokens", v, 0),
-    // 🔴 codex R1-F2(真 finding,红先钉在 batch1-codex-r1.test.ts):**部分发布必须按基线补齐**。
-    // 修前这里从**空对象**重建,于是只发 `toolCallMicroUsd` 的一次发布会把 sandbox/egress 费率变成
-    // undefined —— 而消费端(routes/runs.ts 的 supervisorCost)把它们当 0 算,结果是**静默漏计费**:
-    // 账面看起来正常,只是少了两条轴。同一条 finding 的另一半:未知成员(拼错)修前被**忽略**,
-    // 极端情形下提交一个空费率对象;现在拼错=整批响亮拒(一个拼错的费率名等于「这条轴没在计费」)。
     infraCostRates: (v, baseline) => {
         if (v === null || typeof v !== "object" || Array.isArray(v))
             return { ok: false, reason: "infraCostRates must be an object of non-negative micro-USD rates" };
@@ -29,7 +23,7 @@ const VALIDATORS = {
         for (const k of INFRA_RATE_KEYS) {
             const raw = src[k];
             if (raw === undefined) {
-                out[k] = base[k] ?? 0; // 缺席成员 = 本域不管这一条轴 ⇒ 回 env 基线(非粘),**不是**清零
+                out[k] = base[k] ?? 0;
                 continue;
             }
             if (!okNum(raw) || raw < 0)
@@ -38,7 +32,7 @@ const VALIDATORS = {
         }
         return { ok: true, value: out };
     },
-    attachmentOrphanGraceMs: (v) => atLeast("attachmentOrphanGraceMs", v, 0), // 0 = 关掉孤儿清扫腿
+    attachmentOrphanGraceMs: (v) => atLeast("attachmentOrphanGraceMs", v, 0),
     workspaceFileMaxBytes: (v) => positive("workspaceFileMaxBytes", v),
     attachmentMaxBytes: (v) => atLeast("attachmentMaxBytes", v, LIMITS_HTTP_FLOORS.attachmentMaxBytes),
     attachmentMimeAllowlist: (v) => {
@@ -51,10 +45,9 @@ const VALIDATORS = {
     },
     attachmentUnboundTtlMs: (v) => atLeast("attachmentUnboundTtlMs", v, LIMITS_HTTP_FLOORS.attachmentUnboundTtlMs),
     drainGraceMs: (v) => atLeast("drainGraceMs", v, LIMITS_HTTP_FLOORS.drainGraceMs),
-    runStaleSec: (v) => positive("runStaleSec", v), // 与心跳的关系由跨键不变量表判(单源)
-    toolResultTtlSec: (v) => positive("toolResultTtlSec", v), // 0 ⇒ cutoff=now ⇒ 一拍收光所有卸载结果
+    runStaleSec: (v) => positive("runStaleSec", v),
+    toolResultTtlSec: (v) => positive("toolResultTtlSec", v),
 };
-/** env 派生基线(**首次** stage 时快照;boot 序 = loadConfig → applyEffective,此刻 config 尚是纯 env)。 */
 const limitsEnvBaseline = new WeakMap();
 function baselineOf(config) {
     const known = limitsEnvBaseline.get(config);
@@ -67,21 +60,13 @@ function baselineOf(config) {
     return snap;
 }
 const same = (a, b) => (typeof a === "object" || typeof b === "object" ? JSON.stringify(a ?? null) === JSON.stringify(b ?? null) : a === b);
-/** 候选视图 = 现役 + 本批 staged 赋值(跨键不变量判的就是这个「如果落地会怎样」)。 */
 function candidateView(config, assignments) {
     const view = { ...config };
-    // 写口窄化到「本批键 → unknown」的可选记录:值的真类型已在 VALIDATORS 里逐键判过,这里只是把判过的值
-    // 放回同名槽位(窄 `as`,不是 `as unknown as` —— ServiceConfig 本就可赋给这个形)。
     const writable = view;
     for (const [k, v] of assignments)
         writable[k] = v;
     return view;
 }
-/**
- * STAGE:算出本世代 limitsHttp 组要 COMMIT 的全部赋值(纯计算,零变异)。
- *
- * 返回 `rejected` 时 `assignments`/`deletions` 恒为空 —— 整批拒的物理保证在返回值形上,不靠调用方自律。
- */
 export function stageLimits(config, eff, logger) {
     const baseline = baselineOf(config);
     const legacy = eff.legacyGates ?? {};
@@ -91,10 +76,6 @@ export function stageLimits(config, eff, logger) {
     const deferred = [];
     const badKeys = [];
     let reason;
-    // 🔴 codex R1-F1(真 finding,红先):`limits` 是 **open-world wire 数据**(无 schema 保证),所以
-    // 容器本身必须先判形。修前只对它做可选索引 ⇒ `"bad"` / 数组 / null 让**每个键都看起来缺席** ⇒ 全体
-    // 回 env 底,而且该世代被当作合法提交:中心刚把 rate/cost 门从 0 打开的部署上,一次畸形发布就把保护
-    // 一声不响地关回去了。方向与本域其余判据一致 —— 读不懂就更严不更松(整批拒,旧值继续服务)。
     const rawLimits = eff.limits;
     if (rawLimits !== undefined && (rawLimits === null || typeof rawLimits !== "object" || Array.isArray(rawLimits))) {
         const rejected = { keys: [...BATCH1_LIMIT_KEYS], reason: `the published limits domain must be a JSON object — got ${rawLimits === null ? "null" : Array.isArray(rawLimits) ? "array" : typeof rawLimits}` };
@@ -106,9 +87,6 @@ export function stageLimits(config, eff, logger) {
         return { assignments: [], deletions: [], changed: [], deferred: [], rejected };
     }
     const limits = rawLimits;
-    // LANDING-7.38 接线件④:limits 域是 open-world(registry-core 0.19.0 承运未知键并点名),但**键表
-    // 属主在这里**——发布了、本批却不消费的键(拼错/超前批次)至少要 warn,否则「registry-core 点了名、
-    // 部署里没人听」= 配置写了不生效的静默形。DEFERRED_LIMIT_KEYS(如 costQuotaWindowSec)不算未知。
     if (limits !== undefined) {
         const known = new Set([...BATCH1_LIMIT_KEYS, ...DEFERRED_LIMIT_KEYS.map((d) => d.key)]);
         const unconsumed = Object.keys(limits).filter((k) => !known.has(k));
@@ -121,12 +99,10 @@ export function stageLimits(config, eff, logger) {
         }
     }
     for (const key of BATCH1_LIMIT_KEYS) {
-        // 🔴 用**存在性**判新位优先级,不用 `??`(codex R1-F1 的另一半):`{rateLimitPerMin: null}` 在 `??`
-        // 下会当成「缺席」而回底/落旧位,一个显式的坏值就这样变成了静默撤回。存在即判 ⇒ null 走坏值拒。
         const published = limits !== undefined && Object.prototype.hasOwnProperty.call(limits, key) ? limits[key] : legacy[key];
         let next;
         if (published === undefined) {
-            next = baseline[key]; // 非粘:center 不管这一键 ⇒ 回 env 底
+            next = baseline[key];
         }
         else {
             const verdict = VALIDATORS[key](published, baseline[key]);
@@ -140,8 +116,6 @@ export function stageLimits(config, eff, logger) {
         const current = config[key];
         if (same(current, next))
             continue;
-        // 🔴 codex R2-F2:**显式 deferred 的键不落地** —— 值已验过(坏值照样整批拒),但它的变更只能重启生效,
-        // 所以这里逐键 defer(不是整批拒:同批的热键该生效还得生效)+ 铸因进世代账 + 一条响亮 warn。
         const deferral = DEFERRED_LIMIT_KEYS.find((d) => d.key === key);
         if (deferral) {
             deferred.push({ key, reason: deferral.restartReason });
@@ -162,7 +136,6 @@ export function stageLimits(config, eff, logger) {
         });
         return { assignments: [], deletions: [], changed: [], deferred: [], rejected };
     }
-    // 跨键不变量:本批任一键触发**全表**校验(design/322 §2 A′,codex F2)。
     const verdict = checkCrossInvariants({ live: config, next: candidateView(config, assignments) });
     if (!verdict.ok) {
         const involved = changed.length > 0 ? changed : BATCH1_LIMIT_KEYS.slice();

package/dist/config-invariants.js

@@ -1,15 +1,7 @@
 import { assertGuardPatternsUsable } from "./deployment-governance.js";
-/**
- * 活体心跳周期(ms)——`runs.ts` 的 `HEARTBEAT_MS` 就是它(那边 re-export,单源在此)。
- *
- * 为什么常量住在不变量文件里:它唯一的**判据用途**是「陈旧窗必须大于心跳」这条不变量,而该不变量现在
- * 有 boot 与 stage 两个消费面。放在这里,两面读的是同一个数,`runs.ts` 的心跳环也读同一个数。
- */
 export const LIVENESS_HEARTBEAT_MS = 30_000;
 const anyServiceAuth = (v) => Boolean(v.authToken) || Object.keys(v.authTokens ?? {}).length > 0;
-/** 与 `resolveBindHost` 逐字同判:无鉴权写面 + 零凭据 ⇒ boot 期把监听地址收窄到 loopback。 */
 const mustNarrowBind = (v) => Boolean(v.allowUnauthedWrites) && !anyServiceAuth(v);
-/** 直连门的合取项(config.ts:2788 的同一组);任一项翻转 = 门姿态变更。 */
 const directDoorConjuncts = (v) => Boolean(v.directApprovalDoor) && Boolean(v.durableApproval) && v.approvalHmacKeys.length > 0 && v.principalJwtPubkeys.length > 0 && Boolean(v.principalJwtIss) && Boolean(v.principalJwtAud);
 export const CONFIG_CROSS_INVARIANTS = [
     {
@@ -22,9 +14,6 @@ export const CONFIG_CROSS_INVARIANTS = [
             : undefined,
     },
     {
-        // 转换型:boot 期算一次的绑址收窄(resolveBindHost → server.listen)在运行期无法重算,所以任何
-        // **让收窄条件从不成立变成成立**的热切都是谎:写门确实收紧了,监听面却还在原来的接口上。
-        // 反向(窄→宽,例如加了凭据)不拒:那是收紧姿态,已绑的 loopback 只会更严。
         id: "bind-posture",
         keys: ["authToken", "authTokens", "allowUnauthedWrites"],
         restartReason: "bind-posture",
@@ -42,8 +31,6 @@ export const CONFIG_CROSS_INVARIANTS = [
             : undefined,
     },
     {
-        // 状态 + 转换两面都判:半开的直连门(boot 会拒启的那些组合)绝不许经热路径造出来;门**姿态**
-        // (激活/未激活)的翻转同样只许重启 —— 消费面(/health directDoorActive、鉴权腿)在 boot 期定形。
         id: "direct-door-anchors",
         keys: ["directApprovalDoor", "durableApproval", "approvalHmacKeys", "principalJwtPubkeys", "principalJwtIss", "principalJwtAud", "requirePrincipal", "operatorPrincipals"],
         restartReason: "direct-door",
@@ -83,8 +70,6 @@ export const CONFIG_CROSS_INVARIANTS = [
             : undefined,
     },
     {
-        // bake 门是 build-host-RCE 面,空 operator 名单让 isOperator 变 true-for-all = world-writable RCE。
-        // 与上一条同族但**判据不同**(那条判多租户 durable 审批的读面),故各自登记、各自锚。
         id: "bake-operator-principals",
         keys: ["imageBakes", "operatorPrincipals"],
         restartReason: "operator-principals",
@@ -127,7 +112,6 @@ export const CONFIG_CROSS_INVARIANTS = [
             : undefined,
     },
 ];
-/** 全表校验(**第一条不过即拒**:候选是整批的,报第一个成因足够行动,继续跑其余条目只会淹掉它)。 */
 export function checkCrossInvariants(input) {
     for (const inv of CONFIG_CROSS_INVARIANTS) {
         const reason = inv.check(input);

package/dist/config-lkg.js

@@ -1,44 +1,16 @@
-/**
- * LKG 落盘(clay 拍,2026-07-18)——干净配置候选的本机持久化,boot 的第三级来源:
- *   中心(预算窗内)> 盘上 LKG > env 兜底。
- *
- * 为什么存在(1.222.0 发版复审的残余环,clay 重裁量证据):boot 抢答窗让慢中心不再阻塞启动,但
- * skills/mcp/scenarios/runtime-gates 四个 restart-to-apply 面是 boot 烤进进程的——配置迟到只能发
- * restartRequired 信号。center 发布了这些面 + 中心**持续**慢于预算 + orchestrator 自动重启 ⇒ 每个
- * 新进程都为真缺失的面发一次信号 = 反复重启环。盘上 LKG 让下一进程 boot 直读上一进程验证过的干净
- * 候选(全部面进 buildScenarios),到货后与之比较通常零差异 ⇒ 无信号无环;中心恢复自然收敛。
- * 白拿的第二收益:重启秒起且配置齐全(不再有「起服后几秒 roster pending」窗口)。
- *
- * 安全边界:config plane 恒只携带 env-NAME 引用(apiKeyEnv/tokenEnv/…),真实秘密从不入 effective
- * ——落盘物按同一纪律无秘密;文件 0600 + 原子写(tmp+rename)。**只存干净候选**(候选门通过的:
- * boot clean / refresh LKG advance / deferred clean),所以读侧只需防「文件坏形/被改」:JSON+信封
- * 判形+prompts 面复判(validatePromptsDomain,与候选门同函数),任何不对 ⇒ 忽略文件走 env(warn
- * 点名,绝不让坏缓存挡启动)。
- *
- * 范围:**remote lane only**——local lane 的 FileConfigStore 本来就是盘上即时读,无此需要。
- * 文件按 worker 键控(`config-lkg-<worker|global>.json`),同宿主多 worker 不互踩。
- */
 import { promises as fs } from "node:fs";
 import { homedir } from "node:os";
 import { join, dirname } from "node:path";
 import { randomBytes } from "node:crypto";
 import { validatePromptsDomain } from "./prompts-domain-validate.js";
-/** skill 正文的 content-addressed 盘缓存目录(LKG 的姊妹面):LKG 只含 skills MANIFEST(正文按
- *  hash 另拉)——黑洞中心下 LKG-boot 会在 skill 正文拉取上再挂数秒(live 实测 +5.3s)。正文按
- *  `<dir>/<sha-hex>` 落盘,读侧**必验 hash**(content-addressed 的全部意义;坏文件=忽略重拉)。 */
 export function defaultSkillCacheDir() {
     return join(process.env.SEMA_CONFIG_DIR ?? join(homedir(), ".sema"), "skill-cache");
 }
-/** 默认路径(scheduler store 同门:SEMA_CONFIG_DIR → ~/.sema)。`CONFIG_LKG_PATH` 覆写;
- *  `CONFIG_LKG_ENABLED=false` 关闭(读写双关)。🪦 正名前的 `CONFIG_LKG_DISABLED` 自 server 3.0.0 起是
- *  **fail-loud 墓碑**——设了(任何值)即拒启并指路新名,不再被读取。 */
 export function defaultLkgPath(worker) {
     const dir = process.env.SEMA_CONFIG_DIR ?? join(homedir(), ".sema");
     const key = (worker ?? "global").replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 64);
     return join(dir, `config-lkg-${key}.json`);
 }
-/** 原子落盘一个干净候选(tmp+rename,0600)。BEST-EFFORT:失败=一条 warn 的素材(调用方发),绝不
- *  影响在飞的应用链——LKG 缓存丢失的代价只是下次冷启动回到 env 兜底。 */
 export async function saveLkg(path, worker, effective, etag) {
     const body = { formatVersion: 1, savedAt: new Date().toISOString(), worker: worker ?? "global", ...(etag !== undefined ? { etag } : {}), effective };
     const tmp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
@@ -46,10 +18,6 @@ export async function saveLkg(path, worker, effective, etag) {
     await fs.writeFile(tmp, JSON.stringify(body), { mode: 0o600 });
     await fs.rename(tmp, path);
 }
-/**
- * 读盘上 LKG。返回 undefined 的所有情形都「安静地回 env 兜底」(调用方 warn 点名 reason):
- * 文件缺席/JSON 坏/信封形不对/worker 不匹配(防同名文件跨 worker 串包)/prompts 面复判失败。
- */
 export async function loadLkg(path, worker) {
     let text;
     try {
@@ -76,18 +44,9 @@ export async function loadLkg(path, worker) {
         return { reason: "bad effective" };
     if (p.etag !== undefined && typeof p.etag !== "string")
         return { reason: "bad etag" };
-    // 浅域判形(LKG 复审 F4):applyEffective 是 in-place mutate——半程炸=混态。载荷信任面与 live 远端
-    // 相同(config plane、本机文件=operator 权限),这里防的是**跨版本 schema 漂移/文件被改**的结构性坏形:
-    // 各域存在时必须是对象、其主数组存在时必须是数组、version 必须是数;更深的语义仍归 apply 层
-    // (live 载荷同待遇——LKG 不引入第二套 schema)。
     const eff = p.effective;
     if (typeof eff.version !== "number")
         return { reason: "bad effective.version" };
-    // codex R24(真存量 bug):teams 的真形=信封 `{ teams: CenterTeam[] }`(EffectiveConfig 声明形,
-    // applyEffective 消费 `eff.teams?.teams`)——旧判形要求裸数组,任何带 teams 的候选保存成功、下次 boot
-    // 被拒("bad effective.teams")→ env 兜底 → 慢中心下 defer 再签,正是交棒门要消的环。teams 改与其他域
-    // 同姿势:对象 + 主数组存在时必须是数组。(旧夹具 `teams: []` 曾遮住此形;裸数组从未被真实 save 产出,
-    // 拒掉无害:unusable → env 兜底 → 下个干净候选重写。)
     for (const [domain, arrayKey] of [["models", "models"], ["teams", "teams"], ["skills", "skills"], ["mcp", "servers"], ["scenarios", "scenarios"], ["runtime", null]]) {
         const v = eff[domain];
         if (v === undefined)
@@ -100,7 +59,6 @@ export async function loadLkg(path, worker) {
                 return { reason: `bad effective.${domain}.${arrayKey}` };
         }
     }
-    // prompts 面复判(候选门同函数):坏 prompts 若放行,boot 采用后每个任务 prepare 都会炸。
     const promptsRaw = p.effective.prompts;
     if (promptsRaw !== undefined && !validatePromptsDomain(promptsRaw).ok)
         return { reason: "prompts face fails re-validation" };