@sema-agent/server 7.43.0 → 7.44.0

package/dist/config-center/apply-ledger.js

@@ -1,40 +1,9 @@
-/**
- * #322 —— **世代账**(design/322 §2 世代账,codex 设计审 F4)。
- *
- * 身份标 = 上游 `EffectiveConfig.version`,**刻意不造跨进程 epoch**(codex F4 语义不变):
- *  · 同版本幂等重放(etag 未推进的下一拍)不该伪增世代;
- *  · 双副本对账「是不是同一代」必须能跨进程判 —— 同 source version = 同一代。
- *
- * 🔴 #325(test [4809],[4810] 阻断裁定):**序轴与身份标分离**。source version 在
- * `CONFIG_PROVIDER=local` 下是 registry-core file-store 的内容哈希(u53,上游契约只承诺
- * 「同 files ⇒ 同 number」,从未承诺序)——把它当序数消费,哈希更小的合法新代会被永久
- * 静默忽略且本账双盲(target/applied 都不动)。修后:**推进判断吃收货处铸的进程内单调
- * ordinal**(config-center `generationOf`;等版本重放沿用同 ordinal=幂等语义保留),
- * `version` 只做对账身份标——configTargetVersion 语义从「max(见过)」变为「**最后**见过的
- * 源代」(remote 单调腿二者等价;local 腿这才是真相)。
- *
- * 读面两个:`/health` 的三键(target / applied / 失败持续时长;#325 起 additive 补
- * targetOrdinal/appliedOrdinal 两键=推进/停滞的机器判据)给编排器判「这个副本要不要摘」;
- * 诊断端点的 `configApply` 段给运维看**按组**的细节(哪一组停在哪一代、上一次为什么被拒)。
- *
- * 🔴 原子承诺的**域**是单进程(§2):本账记的是「本副本的收敛状态」,不是 fleet 的。fleet 级判据 = 各副本
- * /health 的 applied == target,拉齐工具归运维面。
- */
 export function createConfigApplyLedger(now = () => Date.now()) {
     let targetOrd = 0;
     let appliedOrd = 0;
     let targetVersion = 0;
     let appliedVersion = 0;
-    /**
-     * 🔴 codex R1-F3(真 finding,红先):**有组被拒的世代不算「本副本应用了这一代」**。
-     *
-     * applyEffective 对一个 limits 被整组拒的候选仍返回 true(其余面照常提交),生产腿随后无条件调
-     * `applied(...)` —— 修前于是 `/health` 报 applied==target、stale 时长消失,而限额面其实停在旧代。
-     * 世代账存在的全部理由就是让这种漂移可见,所以拒过的世代在这里被记下,`applied()` 拒绝为它收敛。
-     * #325 起按 **ordinal** 记(local 腿同 version 可能隔代重现,序数才是「这一次候选」的唯一键)。
-     */
     const rejectedOrds = new Set();
-    /** 首次分歧的时刻 —— **持续**时长的锚(每拍刷新会把「卡了一小时」写成「卡了 0 秒」)。 */
     let divergedSince;
     const groups = {};
     const reconcile = () => {
@@ -53,10 +22,9 @@ export function createConfigApplyLedger(now = () => Date.now()) {
         },
         applied(ordinal, version) {
             if (ordinal > targetOrd) {
-                targetOrd = ordinal; // 迟到 boot / LKG 腿:应用的那一代自然也是见过的
+                targetOrd = ordinal;
                 targetVersion = version;
             }
-            // 本世代有组被拒 ⇒ 只推进 target(诚实的「见过、没能完整应用」),applied 停在上一个完整世代。
             if (!rejectedOrds.has(ordinal) && ordinal > appliedOrd) {
                 appliedOrd = ordinal;
                 appliedVersion = version;
@@ -65,14 +33,14 @@ export function createConfigApplyLedger(now = () => Date.now()) {
         },
         recordApply(report) {
             const prev = groups.limitsHttp;
-            const ord = report.ordinal ?? report.version; // 兼容臂:未传 ordinal 的单元调用退回 version 键
+            const ord = report.ordinal ?? report.version;
             if (report.limits.rejected)
                 rejectedOrds.add(ord);
             else
-                rejectedOrds.delete(ord); // 同一世代重放且这次过了(拒因已修)⇒ 允许收敛
+                rejectedOrds.delete(ord);
             if (report.limits.rejected) {
                 groups.limitsHttp = {
-                    appliedVersion: prev?.appliedVersion ?? 0, // 被拒的世代不许推进组的 applied
+                    appliedVersion: prev?.appliedVersion ?? 0,
                     ...(prev?.deferredKeys ? { deferredKeys: prev.deferredKeys } : {}),
                     lastRejected: { keys: [...report.limits.rejected.keys], reason: report.limits.rejected.reason, version: report.version, at: now() },
                     ...(report.limits.rejected.restartReason
@@ -83,9 +51,8 @@ export function createConfigApplyLedger(now = () => Date.now()) {
             }
             groups.limitsHttp = {
                 appliedVersion: report.version,
-                // 逐键 defer(值合法但键不热):每代重算 —— 不再被发布的 defer 自然消失,不粘。
                 ...(report.limits.deferred && report.limits.deferred.length > 0 ? { deferredKeys: report.limits.deferred.map((d) => ({ key: d.key, reason: d.reason })) } : {}),
-                ...(prev?.lastRejected ? { lastRejected: prev.lastRejected } : {}), // 上一次拒因保留:修好之后仍要能查到发生过什么
+                ...(prev?.lastRejected ? { lastRejected: prev.lastRejected } : {}),
             };
         },
         view() {

package/dist/config-center/facade.js

@@ -1,44 +1,3 @@
-/**
- * Config-center adapter — pull the effective config from the config-center control plane and
- * apply it OVER the env-derived defaults (env = fallback, center = override). Follows the
- * "universal internal schema → translate at the boundary" pattern, with our security boundary kept:
- *
- * (name history: this module tracks the control plane's product name, which has changed over time
- * — registry → sema-web → planned sema-admin. The module itself keeps a neutral, product-name-free
- * identifier ("config-center") and does not chase the rename.)
- *
- *   - the CENTER owns the LOGICAL config: the model roster (names/capabilities/tier), the role map,
- *     and team templates;
- *   - the SERVICE env still owns the SECRETS: API keys stay in env (the center never stores a secret);
- *     keys are per-model via `apiKeyEnv` → `config.modelApiKeyEnv` → the spec's `getApiKeyAndHeaders`
- *     (core 1.45), so each model/cascade-rung authenticates with its own upstream key.
- *
- * Per-model `baseUrl` IS transported (a catalog model may live on a different gateway;
- * core brain honors model.baseUrl, absent = "" = boot-env endpoint).
- *
- * Hot-reload status (复审 2026-07-29 P1-11 — 亲读判定,取代此处旧的 "models/roles are restart-to-apply"
- * TODO, which went stale when `mutateInPlace` landed):
- *   - models/roles/roster/teams/projects/autonomy — **HOT**. `applyEffective` mutates `config.models`/
- *     `config.roles` IN PLACE, and core's Runner reads `this.deps.models/roles` per task off that very
- *     reference. Both brains re-resolve `model.baseUrl || config.baseUrl` inside `buildRequest()` on every
- *     call (core 2.1.0 `brain/openai.js` + `brain/anthropic.js`), so a moved gateway takes effect on the
- *     next task with no restart.
- *   - the same plane under a **tier-frozen** Runner — deferred, not hot: core expands a PRIVATE catalog copy
- *     at construction, so `main` defers the whole plane and the `models-tiers` restart slice signals.
- *   - **`degrade-route`** — the one genuinely boot-frozen catalog consumer left: reactive degrade
- *     (`MODEL_DEGRADE_REACTIVE`) bakes the target Model + its gateway + its key into the brain composition
- *     at boot. It cannot be hot-applied without rebuilding the brain, so it is registered on the existing
- *     restartRequired /health contract instead (see `restart-signal.ts`). Fail-loud beats serving a stale
- *     gateway silently on the rate-limit path.
- *   - skills/mcp/scenarios/runtime-gates — restart-to-apply by construction (baked into the boot wiring).
- *
- * (design/158 A13, internal-lossless) This module is now a FACADE: the implementation lives
- * alongside it in `src/config-center/` split by responsibility group (HTTP client / EffectiveConfig
- * application / restart-signal detection / skills+MCP consumption). Every symbol below is
- * re-exported UNCHANGED — existing `from ".../config-center/facade.js"` imports need zero changes
- * across a rename of this file's *contents*; a path rename (this move, 2026-07-29) does require the
- * importers to update, which was done in the same commit.
- */
 export { fetchEffective, fetchPrincipalCaps, fetchPrincipalOrgMemory, ConfigCenterHttpError, fetchSkillContent, fetchPromptArtifact, fetchPromptBlob, } from "./http-client.js";
 export { mutateInPlace, applyEffective, applyRuntimeGates, applyRuntimeHot, resolveDefaultModelName, logEffectiveDiff, runtimeHasActiveGate, } from "./apply-effective.js";
 export { restartReasons, planeHasActiveTiers, modelPlaneChanged, } from "./restart-signal.js";

package/dist/config-center/hot-keys-registry.js

@@ -1,10 +1,4 @@
 const cases = (key) => ({ effect: `HK-${key}-effect`, refuse: `HK-${key}-refuse`, rollback: `HK-${key}-rollback` });
-/**
- * 批1(cost 族)真正接线的 14 键 —— **stage 消费的单一真源**:`stage-limits.ts` 按本表遍历,
- * 所以「表里有、stage 不写」或「stage 写、表里没有」都不可能悄悄发生。
- *
- * 前 3 个是 B 簇1(限额座 setter);其余 11 个是 limitsHttp 组的 A′ 接线键。
- */
 export const BATCH1_LIMIT_KEYS = [
     "rateLimitPerMin",
     "maxPrincipalCostUsd",
@@ -22,19 +16,6 @@ export const BATCH1_LIMIT_KEYS = [
     "toolResultTtlSec",
 ];
 const B_SETTER_KEYS = ["rateLimitPerMin", "maxPrincipalCostUsd"];
-/**
- * 🔴 **stage 消费但不热**的键(codex R2-F2,验真后降档)。
- *
- * `costQuotaWindowSec` 在设计稿里归 B 簇(「加个 setter 就好」),那个判断的前提是「限额是比较参数,不是
- * 行状态」—— 对**限额**成立,对**窗长**不成立:SQL 腿的窗长是**桶键的一部分**(`floor(now/windowMs)`,
- * 进 DB 主键)。热切窗长于是有两个真后果:①A→B→A 会在原 A 窗内**复活**切换前的花费(旧桶还在,桶号又
- * 撞上);②B 期间 A 的高编号旧桶不被 `window_bucket < current` 的 reap 清理。内存腿只能靠「换窗即清」
- * 才安全,于是两腿语义必然分裂 —— 同一条发布在不同后端给出相反的成本判决(后端相关的 fail-open)。
- *
- * 处置:窗长**降为 restart-to-apply**(值仍逐次校验,变更逐次铸因、进世代账的 deferredKeys + 一条响亮
- * warn),而不是给一个「在某些后端上会复活旧账」的热能力。真做热要给桶键加**世代隔离**(把窗长世代并进
- * 持久化主键 + 跨副本一致的世代来源),那是独立的一件,归后续批。
- */
 export const DEFERRED_LIMIT_KEYS = [
     {
         key: "costQuotaWindowSec",
@@ -43,7 +24,6 @@ export const DEFERRED_LIMIT_KEYS = [
     },
 ];
 const DEFERRED_KEYS = new Set(DEFERRED_LIMIT_KEYS.map((d) => d.key));
-/** 热键表 = 批1 消费键集**减去**显式 deferred 的那些(表只登记真的热的键)。 */
 export const HOT_KEYS_REGISTRY = BATCH1_LIMIT_KEYS.filter((key) => !DEFERRED_KEYS.has(key)).map((key) => ({
     key,
     group: "limitsHttp",

package/dist/config-center/http-client.js

@@ -1,25 +1,10 @@
-/**
- * config-center HTTP client — the transport calls the service makes against the config-center
- * (`fetchEffective`/`fetchPrincipalCaps`/`fetchPrincipalOrgMemory`/`fetchSkillContent`/`fetchPromptArtifact`/
- * `fetchPromptBlob`) plus the shared HTTP-error type. 后两条 `?principal=` 腿共用 `requestPrincipalView`
- * 传输半场与 `assertPrincipalEcho` 回声核,只在**解析投影**上分家(见 `fetchPrincipalOrgMemory` 头注)。 Split out of `facade.ts` (design/158 A13, internal-lossless — the
- * facade re-exports every symbol below unchanged).
- */
 import { createHash } from "node:crypto";
 import { readEffectiveWire, PrincipalCapsWire } from "@sema-agent/registry-core";
-import { centerPromptsFromEffective } from "../prompts-domain-validate.js"; // #100 worker 腿 prompts 边界归一(中立叶)
-/** GET the effective config (Bearer + ETag). null = 304 (unchanged). Throws on transport/HTTP error, and on a
- *  payload that is not an effective config at all(非对象 / version 非有限数 / gate 域坏形——[2281] 裁B)。
- *  `domainErrors`:坏 catalog 域(schema default 已落)逐域单列——与本地腿 `FetchEffectiveResult` 同键同义,
- *  boot/refresh 的候选门直接消费。 */
+import { centerPromptsFromEffective } from "../prompts-domain-validate.js";
 export async function fetchEffective(baseUrl, token, etag, fetchImpl = fetch, worker) {
-    // Defensive scheme guard: Node's fetch supports file:// — a mis-set
-    // SEMA_REGISTRY_URL must not turn into a local-file read. Reject anything but http(s).
     const scheme = new URL(baseUrl).protocol;
     if (scheme !== "http:" && scheme !== "https:")
         throw new Error(`SEMA_REGISTRY_URL must be http(s), got "${scheme}"`);
-    // worker-scoped pull: `?worker=<name>` returns that worker's roster; omitted → the global roster
-    // (backward compatible — the center returns today's global config when no worker is given).
     const url = `${baseUrl.replace(/\/+$/, "")}/api/config/effective${worker ? `?worker=${encodeURIComponent(worker)}` : ""}`;
     const res = await fetchImpl(url, {
         headers: { authorization: `Bearer ${token}`, ...(etag ? { "if-none-match": etag } : {}) },
@@ -29,24 +14,13 @@ export async function fetchEffective(baseUrl, token, etag, fetchImpl = fetch, wo
         return null;
     if (!res.ok)
         throw new Error(`config-center HTTP ${res.status}`);
-    // [2281] 裁B(§M1):wire 载荷在**这个消费端边界**过 registry-core `readEffectiveWire`(0.12.0)真校验,
-    // 不再裸断言——「两个契约共用一个拼写不是一个被检查的契约」。判据与本地腿同源(parseDomain +
-    // DOMAIN_READ_FALLBACK):catalog 域坏形 → 该域 schema default + 下面折进 domainErrors(候选门在
-    // refresh 拒候选、boot 逐域 warn);gate 域坏形/垃圾载荷 → throw(caller 整包 catch 回落 env/LKG)。
-    // 未知顶层键 verbatim 透传(open-world:新 center 新域、legacy teams 键都不丢)。grandfather 类
-    // 警告(值已被收编接受)不算 error,不进 domainErrors——与本地店同口径。
     const warnings = [];
     const wire = readEffectiveWire(await res.json(), (w) => warnings.push(w));
-    // #100 边界单点归一(§V2-B):worker 腿 prompts 键在**这里**定形——0.13.0 起 wire 值 verbatim 到手,
-    // 存储原文(global lane 合法下发形/emptyEffective 底座)归一为「键缺席」或 catalog 投影,下游
-    // boot/adopt/refresh/deferred/LKG 存取全部只见「缺席或消费形」(裸 `.prompts` 直读有棘轮钉拦)。
     const centerPrompts = centerPromptsFromEffective(wire);
     if (centerPrompts === undefined)
         delete wire.prompts;
     else
         wire.prompts = centerPrompts;
-    // registry-core 0.19.0 响亮化三 kind 同批收编(与 local 腿 config-provider.ts 同映射,LANDING-7.38 件③):
-    // dropped/unread=写了没生效(defaulted 同级),carried=承运待键表方判——全入诊断面,禁静默丢。
     const domainErrors = warnings
         .map((w) => w.kind === "domain-defaulted"
         ? { domain: w.domain, error: (w.error instanceof Error ? w.error.message : String(w.error)).slice(0, 600) }
@@ -58,38 +32,13 @@ export async function fetchEffective(baseUrl, token, etag, fetchImpl = fetch, wo
                     ? { domain: w.domain ?? "config.d", error: `unread config file ${w.file} (${w.why})`.slice(0, 600) }
                     : undefined)
         .filter((r) => r !== undefined);
-    // 经真校验后的 wire 值到 service 拼写副本的换装:两型同一契约面(EffectiveWire 是 service 型的同源超集,
-    // service 型只声明自己消费的域且全 optional)——此断言的前提正是上面那次校验,不再是裸信任。
     const effective = wire;
     return { effective, etag: res.headers.get("etag") ?? undefined, ...(domainErrors.length > 0 ? { domainErrors } : {}) };
 }
-/**
- * design/99 §K (core 1.157 `RunnerDeps.runtimeCapsResolver`) — GET the PER-PRINCIPAL runtime
- * ENTITLEMENTS the engine enforces server-side, from center's `GET /api/config/effective?principal=&worker=`.
- * Center pre-resolves the tighten-only intersection (fleet defaults ∩ tier ⊕ roles + overrides) and returns a
- * `runtimeCaps` block — the service passes it through verbatim (no further tightening, per center's ruling).
- *
- * 🔐 TOKEN/WORKER (center ruling, sema-registry `aeb4979`): two valid postures —
- *   • FULL `SERVICE_PULL_TOKEN` + `?principal=` → full per-user body (caps + per-user config).
- *   • worker-scoped `wpt_<self>` + `?principal=&worker=<self>` → **caps-only** body (`{principal, configured,
- *     runtimeCaps, budget}`; never other tenants' config) — a worker MAY resolve its OWN worker's principals.
- *   A `wpt_` with NO `?worker=` (or a mismatched worker) still 403s. So we ALWAYS pass `?worker=` when the
- *   deployment has one (`SEMA_REGISTRY_WORKER`): it authorizes the wpt_ path AND is harmless on the full token
- *   (the caps value is worker-independent — `resolveEntitlement` resolves from the principal alone; worker only
- *   scopes the config view we ignore). This re-adds the `worker` arg dropped in 1.14.0 (L2-3) — center's ruling
- *   makes it load-bearing for AUTHORIZATION, not for the caps value.
- * `null` = 304 (caller keeps its cached value). THROWS on transport / non-304 HTTP error → the resolver
- * fail-closes (core then DENIES the optional `allowWorkflows` cap — an outage must never silently GRANT). ETag is
- * content-hashed (`p-<hash>`); an `if-none-match` poll is cheap. Mirrors `fetchEffective` (Bearer + 8s + scheme guard).
- */
 export async function fetchPrincipalCaps(baseUrl, token, principal, etag, fetchImpl = fetch, worker) {
     const raw = await requestPrincipalView(baseUrl, token, principal, etag, fetchImpl, worker);
     if (raw === null)
         return null;
-    // 边界读=schema(clay 宪法 [2704] §2,同源锚=registry-core PrincipalCapsWire):治理面
-    // runtimeCaps/budget 严格+passthrough(值漂移整体拒 ⇒ 本函数 throw ⇒ resolver fail-close,
-    // 「outage 绝不静默 GRANT」同向);[565]/[580] fail-open 面与 orgMemory(C3 失败域隔离)在
-    // schema 里保持宽读,归一/校验仍在下方与目录腿(极性不因 schema 化翻转)。
     const parsedBody = PrincipalCapsWire.safeParse(raw.json);
     if (!parsedBody.success) {
         throw new Error(`config-center principal-caps body failed schema validation: ${parsedBody.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ").slice(0, 600)}`);
@@ -99,10 +48,6 @@ export async function fetchPrincipalCaps(baseUrl, token, principal, etag, fetchI
     return {
         runtimeCaps: body.runtimeCaps ?? null,
         configured: Boolean(body.configured),
-        // The caps view carries the RESOLVED per-principal scenario ruling (two keys, shape pinned
-        // by center tests). An older center has NO such keys → undefined (no governance, legacy passthrough) —
-        // distinct from the "assigned nothing" ruling {scenario:null, allowlist:[]} a newer center returns.
-        // Defensive on shape (scenario face is fail-open — see gateScenarioRequest): non-string entries dropped.
         ...("scenario" in body || "allowlist" in body
             ? {
                 scenario: {
@@ -111,17 +56,7 @@ export async function fetchPrincipalCaps(baseUrl, token, principal, etag, fetchI
                 },
             }
             : {}),
-        // (stage7 P5, registry-core 0.8 execution 域): the caps view's per-principal execution
-        // ruling `{required, allowedLanes}` — same car, same no-cache semantics as the scenario ruling. An
-        // older center has no key → undefined (no enforcement). allowedLanes is an OPEN value domain
-        // (adding a lane is never BREAKING) — tolerate unknown names, drop non-string ELEMENTS defensively.
-        // shape DRIFT (required non-boolean / allowedLanes non-array) must NOT be
-        // coerced — the old coercion turned "allowedLanes came as a comma string" + required=true into
-        // allowedLanes=[] = fleet-wide deny-all (fail-CLOSED on a wire glitch, opposite of the fail-open posture)
-        // and a drifted `required` into silent non-enforcement. Now: drift ⇒ DROP the whole ruling (fail-open,
-        // gate passes) + `executionDrift` so the caller's audit line fires (the resolver routes it to onError).
         ...((() => {
-            // [2704] §1:unknown 面的窄化走运行时类型谓词(真检查),不走断言。
             const isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
             const exRaw = body.execution;
             if (exRaw === undefined || exRaw === null)
@@ -133,10 +68,6 @@ export async function fetchPrincipalCaps(baseUrl, token, principal, etag, fetchI
             if (!Array.isArray(exRaw.allowedLanes))
                 return { executionDrift: `execution.allowedLanes is ${typeof exRaw.allowedLanes}, expected string[] — ruling dropped (fail-open)` };
             const execution = { required: exRaw.required, allowedLanes: exRaw.allowedLanes.filter((s) => typeof s === "string") };
-            // registry-core 0.10.1-0.10.2:execution.sessionMirror 宽读。observation-only 子面
-            // (server 非执法端,见 ExecutionRuling.sessionMirror 注),所以形状漂移只丢**本子面**并走 executionDrift
-            // 审计线(resolver 路由到 onError),**绝不**连带丢 lane ruling(那是真执法面,不能被观测子面拖垮)。
-            // required 缺省 false = registry-core zod 默认(便利态);engineUrl 必须非空 string。
             if (exRaw.sessionMirror !== undefined && exRaw.sessionMirror !== null) {
                 const sm = exRaw.sessionMirror;
                 if (isRecord(sm) && typeof sm.engineUrl === "string" && sm.engineUrl.length > 0 && (sm.required === undefined || typeof sm.required === "boolean")) {
@@ -148,31 +79,19 @@ export async function fetchPrincipalCaps(baseUrl, token, principal, etag, fetchI
             }
             return { execution };
         })()),
-        // design/170 件A:org 记忆解析段**原值透传**(键在场保在场、缺席保缺席——缺席=旧 center 能力握手,
-        // org 目录腿据此判 section_absent 瞬时;形状校验是 org-memory-admission 模块用 PrincipalOrgMemoryWire
-        // 的事,本腿保持薄透传不预判)。
         ...("orgMemory" in body ? { orgMemory: body.orgMemory } : {}),
-        etag: raw.etag, // 与提取共用件之前逐字等价:键恒在场,无 ETag 头时值为 undefined(消费端只读真值)
+        etag: raw.etag,
     };
 }
-/** design/170 件A C8(响应 principal 回声核):center 两条 `?principal=` 腿的 body 都回带 principal——
- *  在场且与请求不符 = 中间层/LB 把别的 principal 的视图递了过来,弃用整响应(throw ⇒ caps 腿
- *  fail-close、org 目录腿记 unavailable)。键缺席 = 旧 center 形,按无证据容忍(回声核只拦「有回声
- *  且对不上」的确定性错递,不把旧形升级成故障)。两条腿共用同一道闸,不各写一遍。 */
 function assertPrincipalEcho(echoed, principal) {
     if (echoed !== undefined && echoed !== principal) {
         throw new Error(`config-center principal-caps response echoes principal ${JSON.stringify(echoed)} but ${JSON.stringify(principal)} was requested — discarding the whole response`);
     }
 }
-/** 两条 `?principal=` 腿共用的**传输**半场:scheme 闸 / `?principal=[&worker=]` / Bearer / 8s 超时 /
- *  304 语义。逐字来自原 {@link fetchPrincipalCaps} 函数体,提成共用件是为了第二条腿(org 段读取)
- *  不必抄一遍传输纪律——抄一遍就等于给同一条边界立两套会各自漂移的规矩。
- *  返回 `null` = 合法的 304(仅当我们真的发了条件请求);否则是**解析前**的 body 原值。 */
 async function requestPrincipalView(baseUrl, token, principal, etag, fetchImpl, worker) {
     const scheme = new URL(baseUrl).protocol;
     if (scheme !== "http:" && scheme !== "https:")
         throw new Error(`SEMA_REGISTRY_URL must be http(s), got "${scheme}"`);
-    // `?principal=<id>[&worker=<self>]` — worker authorizes the wpt_<self> caps-only path; harmless on a full token.
     const params = new URLSearchParams({ principal });
     if (worker)
         params.set("worker", worker);
@@ -182,9 +101,6 @@ async function requestPrincipalView(baseUrl, token, principal, etag, fetchImpl,
         signal: AbortSignal.timeout(8000),
     });
     if (res.status === 304) {
-        // A 304 is only valid as a reply to OUR conditional. If we sent no etag and still got 304, center is
-        // misbehaving — DON'T treat it as "unchanged" (that surfaces undefined caps = no restriction = fail OPEN).
-        // Throw so the resolver fail-closes (review B). With an etag, 304 = genuine "unchanged" → null.
         if (!etag)
             throw new Error("config-center returned 304 to a non-conditional principal-caps request");
         return null;
@@ -194,31 +110,9 @@ async function requestPrincipalView(baseUrl, token, principal, etag, fetchImpl,
     const responseEtag = res.headers.get("etag");
     return { json: await res.json(), ...(responseEtag !== null ? { etag: responseEtag } : {}) };
 }
-/** 件A C3 失败域隔离的读取投影:org 目录腿只消费两个字段——`principal`(回声核)与 `orgMemory` 段
- *  原值。用 `PrincipalCapsWire.pick()` 取子集(schema 属主仍是 registry-core,这里不复制形状定义,
- *  `.passthrough()` 随 `_def` 一并继承)。 */
 const PrincipalOrgMemoryEnvelope = PrincipalCapsWire.pick({ principal: true, orgMemory: true });
-/**
- * design/170 件A —— 读 `?principal=` 响应里的 org 记忆解析段(org 目录腿的取数口)。
- *
- * 🔬 **为什么不复用 {@link fetchPrincipalCaps}**(复审车 D-2 修):C3「两张表失败域互不干扰」是在档
- * 裁定,registry-core 的 `PrincipalCapsWire` 也正是为此把 org 段留成 `unknown`(「在本 schema 里校验
- * 会把 org 段坏形连坐进 caps 腿」)。但隔离此前只做了**单向**:org 段坏不连坐 caps,caps 段坏却整体
- * 连坐 org —— 治理面 `runtimeCaps`/`budget` 的一次值漂移会让整封 safeParse 失败、函数 throw,于是一个
- * **形状完全正确**的 org 授权段读不出来,目录记 `fetch_failed`、准入铸瞬时拒。治理面的 fail-closed
- * 极性是对的(它管的是「别静默放松治理」),但它不该决定 org 授权面的可用性。
- *
- * 所以这条腿用 {@link PrincipalOrgMemoryEnvelope} 只读它真正消费的两个字段:治理面漂移在这里是被
- * `.passthrough()` 原样放过的未知键,不构成本腿的故障。段本身的形状校验仍在目录腿
- * (`PrincipalOrgMemoryWire`),本腿保持薄透传不预判。
- *
- * 返回值三值语义:段键缺席 ⇒ `undefined`(旧 center 能力握手 ⇒ 目录判 `section_absent` 瞬时);
- * 段在场 ⇒ 原值(空表 = 取数成功的负结果,与缺席不同格)。条件请求不适用(本腿恒不带 etag),
- * 因此 304 在传输层就是 fail-loud。
- */
 export async function fetchPrincipalOrgMemory(baseUrl, token, principal, fetchImpl = fetch, worker) {
     const raw = await requestPrincipalView(baseUrl, token, principal, undefined, fetchImpl, worker);
-    // etag 恒缺席 ⇒ 304 已在传输层 throw;这一支只为类型收口(不可达)。
     if (raw === null)
         throw new Error("config-center returned 304 to a non-conditional org-directory fetch");
     const parsed = PrincipalOrgMemoryEnvelope.safeParse(raw.json);
@@ -228,8 +122,6 @@ export async function fetchPrincipalOrgMemory(baseUrl, token, principal, fetchIm
     assertPrincipalEcho(parsed.data.principal, principal);
     return parsed.data.orgMemory;
 }
-/** An HTTP error from a config-center fetch that carries the response status so callers can branch on it
- *  (e.g. translate a 404 to "unknown hash → undefined") WITHOUT parsing the message string. */
 export class ConfigCenterHttpError extends Error {
     status;
     constructor(message, status) {
@@ -238,14 +130,6 @@ export class ConfigCenterHttpError extends Error {
         this.name = "ConfigCenterHttpError";
     }
 }
-/**
- * Fetch one skill's body by content hash (`GET /api/config/skills/content/<hash>`, Bearer) and VERIFY its
- * sha256 matches the manifest hash (integrity + tamper check). The content is immutable per hash, so the
- * caller caches by hash and never re-fetches an unchanged skill. Throws a {@link ConfigCenterHttpError}
- * (carrying `.status`) on an HTTP error — INCLUDING 404 — or a plain Error on hash mismatch. Callers that
- * want "unknown hash → undefined" parity with the local backend inspect `.status === 404` and swallow it;
- * the legacy `applyCenterSkills` path keeps treating every throw as "skip this skill, keep baseline".
- */
 export async function fetchSkillContent(baseUrl, token, contentHash, fetchImpl = fetch) {
     const url = `${baseUrl.replace(/\/+$/, "")}/api/config/skills/content/${encodeURIComponent(contentHash)}`;
     const res = await fetchImpl(url, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(8000) });
@@ -258,10 +142,6 @@ export async function fetchSkillContent(baseUrl, token, contentHash, fetchImpl =
         throw new Error(`skill content hash mismatch for ${contentHash}: computed sha256:${got}`);
     return content;
 }
-/** [985]b / [1285]① — §9.4 by-digest 补拉二函(fetchSkillContent 同姿势:HTTP+Bearer+8s 超时+
- *  消费侧自证)。artifact=envelope JSON(验真=调用方过 core verifyPromptArtifact,canonical 重算——
- *  本函数只做传输与形读,不越权解释);blob=段文本 raw-byte(sha256 逐位自证,fetchSkillContent 同款)。
- *  digest 参数收带前缀/裸 hex 两形([1285] 参数口径)。 */
 export async function fetchPromptArtifact(baseUrl, token, artifactDigest, fetchImpl = fetch) {
     const url = `${baseUrl.replace(/\/+$/, "")}/api/config/prompts/epoch-artifacts/${encodeURIComponent(artifactDigest)}`;
     const res = await fetchImpl(url, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(8000) });
@@ -274,9 +154,6 @@ export async function fetchPromptBlob(baseUrl, token, contentDigest, fetchImpl =
     const res = await fetchImpl(url, { headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(8000) });
     if (!res.ok)
         throw new ConfigCenterHttpError(`prompt blob HTTP ${res.status} for ${contentDigest}`, res.status);
-    // codex F2(补拉批):哈希必须打在**响应原始字节**上(res.text() 的 UTF-8 宽容解码会剥 BOM/替换坏序列
-    // ——验的就不再是送来的字节,content-addressed 完整性破功);验过再严格解码(fatal:true,坏 UTF-8
-    // 掷错而非静默替换)。
     const bytes = new Uint8Array(await res.arrayBuffer());
     const want = contentDigest.replace(/^sha256:/, "").toLowerCase();
     const got = createHash("sha256").update(bytes).digest("hex");

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

@@ -1,45 +1,17 @@
-/**
- * #324(core 5.50 design/338 提货件)—— mid-turn MCP 撤销台账:`RunnerDeps.mcpRevocations` 席的宿主实现。
- *
- * 语义(与 core 契约对表,types.d.ts `RunnerDeps.mcpRevocations` 注):
- *  · 权威单点在宿主 —— core 每次 MCP dispatch 前**同步**探 `isRevoked(serverName)`,从不缓存答案。
- *  · 本台账记「中心**曾发布为 enabled、后从 enabled 集移除**」的服务器名。MCP mount 是 boot-baked
- *    (`resolveMcpServers` 只在启动期跑),所以**删除向**在 5.50 前只能等 restart 才生效——这正是
- *    design/338 要消的窗:治理面最要紧的动作(撤销一条对外通道)现在即时生效,restart 信号的
- *    删除向豁免见 `restart-signal.ts` 的 mcp 特判(`mcpRevocationLive` 前提,fail-closed:席没接线
- *    的部署保持旧的 restart 语义)。
- *  · **重现恢复是指纹判,不是名字判**(codex F1,confirmed):被撤的名字回到 enabled 集时,只有当
- *    它的条目指纹与 **baseline(boot mount 真身)逐字相同**才解除撤销——重加同名**不同址/不同配置**
- *    的条目,复活的会是 boot-frozen 的旧 mount(新配置要 restart 才装上),那是把已撤下的旧端点在
- *    restart 窗口内重新放行(fail-open)。指纹不匹配 ⇒ 名字保持 revoked 直到 restart 收敛。
- *  · **baseline 只由 boot bake 拍铸**(codex F2,confirmed):它必须是「实际 mount 的集合」——迟到
- *    boot 采用/refresh 拍的候选集都不是 mount 真身,不得铸 baseline。`hasBaseline()` 是 restart 豁免
- *    的第二道门(boot 超时形:mount=env 集,中心撤销语义整个不适用,豁免必须关死走旧 restart 语义)。
- *  · **域缺席(null)不动**:中心停止发布 mcp 域 ≠ 逐服务器撤销指令(fingerprint 上 null↔非 null
- *    自会签 restart);域在场但 `servers: []` 是明确的「清空」指令 ⇒ 全撤。
- *  · baseline 之后新增再删除的名字照 revoke(它从未 mount,isRevoked=true 无 mount 可拒=无害,
- *    fail-closed 向);这类名字重加时因无 baseline 指纹**不解除**——同样无害,restart 收敛。
- *
- * 纯内存、同步、无 I/O —— 每副本各自持有(mount 也是副本各自的,天然同界)。进程重启即清零:
- * 重启后按新配置 mount,台账语义自洽。
- */
 export function createMcpRevocationLedger(onChange) {
-    /** boot mount 真身(name→指纹);undefined = baseline 未铸(hasBaseline=false)。铸后不变。 */
     let baseline;
-    let seen; // 上一拍 enabled 名集;undefined = 还没见过任何一拍
+    let seen;
     const revoked = new Set();
     return {
         isRevoked: (serverName) => revoked.has(serverName),
         hasBaseline: () => baseline !== undefined,
         applyEnabledEntries: (entries, opts) => {
             if (entries === null)
-                return; // 域未发布 ≠ 撤销指令(成文见文件头)
+                return;
             if (opts?.isBaseline === true && baseline === undefined)
                 baseline = new Map(entries);
             const restored = [];
             for (const [n, fp] of entries) {
-                // codex F1:恢复=指纹判——只有回归到 baseline(mount 真身)的逐字同形才解除;
-                // 同名不同形(改址/改配置)保持 revoked,新配置候 restart 装上(fail-closed)。
                 if (revoked.has(n) && baseline?.get(n) === fp) {
                     revoked.delete(n);
                     restored.push(n);
@@ -62,10 +34,6 @@ export function createMcpRevocationLedger(onChange) {
         view: () => ({ revoked: [...revoked].sort() }),
     };
 }
-/** 一拍 EffectiveConfig 的 ENABLED MCP 服务器条目表(`resolveMcpServers` 同判据:`enabled !== false`;
- *  值=整条目的 key 排序 JSON 指纹,Map 插入序=发布序);mcp 域缺席 ⇒ `null`(台账不动)。
- *  指纹口径与 restart-signal 的 stableStringify 同精神(key 序归一),但**刻意独立实现**:两处指纹
- *  只在各自域内自比,不跨域比对,无同源约束。 */
 export function enabledMcpEntries(mcp) {
     if (!mcp)
         return null;

package/dist/config-center/read-face.js

@@ -1,33 +1,4 @@
-/**
- * #A4([4147] 窗三件批 件1;[4073]/[4083] 承诺件)—— READ 容纳面四键的 **config-center 消费腿**。
- *
- * 部署 env 的四键(`READ_FACE` / `READ_DENY_PATTERNS` / `READ_DENY_BUILTIN_TIERS` /
- * `READ_DENY_BUILTIN_EXCLUDE`,见 config.ts)此前是这条轴上的唯一入口:一个用 config-center 管理整片
- * worker 的组织,想统一收紧 READ 面只能逐机改 env。本模块把 `EffectiveConfig.readFace`(见 types.ts
- * {@link CenterReadFace})投影到同样的四个 `ServiceConfig` 键上,**restart-to-apply**(与 mcp/a2a 同线:
- * `createRunnerDeps` 在 boot 期捕获这四键;改动由 `read-face` restart 片通告)。
- *
- * ── 三条规则,每条都有失败方向的论证 ──────────────────────────────────────────────────────────
- *
- * ① **env 显式恒赢,逐键判**(operator-knob 律)。env 是**这台机器**的部署主权表达,center 是组织下发;
- *    冲突时保留 env 并留一条点名 warn。为什么不照 6 闸的「center 覆盖 env」:那六闸是**限额/治理**面
- *    (组织比单机更知道该收多紧),而 READ 容纳面描述的是**这台机器的磁盘上有什么** —— 运维在这台机器上
- *    写下 `READ_FACE=roots` 时知道的事情,组织的下发面不知道。静默盖掉它是本仓「部署级旋钮」纪律的反面。
- *    逐键而非整域:env 只写了 face 时,center 的三个 deny 键照常落(否则一个 env 键会把整片组织策略挡掉)。
- *    判据 = **键在场**(`!== undefined`):`readDenyBuiltinTiers: []` 是 env `none` 的显式空姿态,
- *    不是「没设过」—— 用真值判会把「一档内建都不要」这个显式表态判成缺席。
- *
- * ② **坏值整域拒 + 响亮**(#157 安全轴)。任何一个成员过不了引擎自己的校验器 ⇒ 整个 readFace 域不落,
- *    保留 env 前值 + warn 点名。两个方向都要:半应用一份 READ 姿态(收紧了一半)会让运维以为策略生效;
- *    而 throw 会让一次坏发布把常驻进程炸掉(env 腿 throw 是对的 —— 那是启动期、由本机运维自己写的值)。
- *    与 `stageApprovalRequire` 的域级拒绝先例同形。
- *
- * ③ **校验一律交给引擎**(`compileReadDeny` / `resolveReadDenyBuiltins`)。宿主不自造第二份判定语义,
- *    与 env 腿逐字同款;且校验跑在**合成后的最终姿态**上(env 键 + center 键混合形),否则
- *    「env 选了档位、center 删了一个不在该档里的行名」这类跨腿坏组合会漏过。
- */
 import { compileReadDeny, resolveReadDenyBuiltins } from "@sema-agent/core";
-/** center 域成员 → `ServiceConfig` 键的对照表(单一真源:warn 文案、env-wins 判定、落配三处同吃)。 */
 const KEY_MAP = [
     ["face", "readFace"],
     ["denyPatterns", "readDenyPatterns"],
@@ -36,9 +7,6 @@ const KEY_MAP = [
 ];
 class ReadFaceDomainError extends Error {
 }
-/** `denyPatterns` 的归一:裸串简写 ≡ `{pattern, caseSensitive:false}`(core `ReadDenyEntry` 同宽,
- *  与 env 腿 `parseReadDenyPatternsEnv` 逐字同词表)。形坏一律抛 ⇒ 整域拒(绝不静默丢元素:丢光会
- *  塌成空表,而空表的语义恰好是「没有追加保护」)。 */
 function normalizeDenyPatterns(raw) {
     if (!Array.isArray(raw))
         throw new ReadFaceDomainError("readFace.denyPatterns must be an array of \"pattern\" strings or {pattern, caseSensitive?} objects");
@@ -54,20 +22,17 @@ function normalizeDenyPatterns(raw) {
         return { pattern: it.pattern, caseSensitive: cs === true };
     });
 }
-/** `face` 的词表校验(闭集两词;坏词抛 ⇒ 整域拒)。 */
 function assertFace(raw) {
     if (raw !== "open" && raw !== "roots")
         throw new ReadFaceDomainError(`readFace.face must be "open" or "roots" — got ${JSON.stringify(raw)}`);
     return raw;
 }
-/** `resolveReadDenyBuiltins` 的入参拼装(两处调用同源:发布件自校验 + 合成后终校验)。 */
 function builtinsArg(tiers, exclude) {
     return {
         ...(tiers !== undefined ? { tiers } : {}),
         ...(exclude !== undefined ? { exclude } : {}),
     };
 }
-/** 名字表(档位 / 行名)的形校验:必须是非空串数组;`[]` 合法(显式空姿态)。 */
 function normalizeNameList(field, raw) {
     if (!Array.isArray(raw))
         throw new ReadFaceDomainError(`readFace.${field} must be an array of names`);
@@ -77,17 +42,7 @@ function normalizeNameList(field, raw) {
         return n.trim();
     });
 }
-/**
- * 应用 center 的 readFace 域(**boot-only**:调用点在 boot 拉取之后、`createRunnerDeps` 之前)。
- * 缺席 ⇒ 零触碰。规则见文件头注 ①②③。
- *
- * 返回值 = **本机 env 显式占住的 center 键名**(与本次发布内容无关的部署事实)。调用方把它喂给
- * `RestartSliceCtx.readFaceEnvHeld`,`read-face` restart 片于是只指纹「真会 boot-bake 的那部分」——
- * 否则 center 改一个本机永远用不上的键,整片 fleet 会为一次对自己毫无影响的发布滚动重启一遍
- * (codex 对抗复审 finding 2,验真后采纳的那一半)。
- */
 export function applyCenterReadFace(config, eff, logger) {
-    // 部署事实先算(与发布件在不在场无关):env 占住哪几个键,是这台机器的属性。
     const envHeldKeys = KEY_MAP.filter(([, cfgKey]) => config[cfgKey] !== undefined).map(([centerKey]) => centerKey);
     const domain = eff.readFace;
     if (domain === undefined || domain === null)
@@ -100,33 +55,21 @@ export function applyCenterReadFace(config, eff, logger) {
         return envHeldKeys;
     }
     const d = domain;
-    // ── ① env 恒赢(逐键):env 写过的键,center 的同名成员只留声、不落配 ────────────────────────
     const envHeld = KEY_MAP.filter(([centerKey, cfgKey]) => d[centerKey] !== undefined && config[cfgKey] !== undefined).map(([centerKey, cfgKey]) => `${cfgKey} (readFace.${centerKey})`);
-    // ── ②③ stage ────────────────────────────────────────────────────────────────────────────────
     let staged;
     try {
-        // ② **全域预校验先行,不看 env 是否覆盖**(codex 对抗复审 finding 1,验真属实后重排的次序)。
-        // 旧序把校验挂在「取 center 值」之后,而被 env 占住的键根本不取值 ⇒ 那个成员**完全不过校验**:
-        // 「env 钉死 face × center 把 face 写错一个字母 + 同域发一个放宽的 denyBuiltinTiers:[]」这一形下,
-        // 非法成员静默无声、放宽成员照落 —— 本文件承诺的「任一坏值整域拒」被证否,且偏离方向是 fail-open。
-        // 现在:域里**每一个在场成员**都先过形/词表/引擎校验(且校验的是**这份发布自己的**姿态),
-        // 任一不合法 ⇒ 抛 ⇒ 整域拒;合法之后才做 env-wins 逐键合成。
         const normalized = {
             ...(d.face !== undefined ? { readFace: assertFace(d.face) } : {}),
             ...(d.denyPatterns !== undefined ? { readDenyPatterns: normalizeDenyPatterns(d.denyPatterns) } : {}),
             ...(d.denyBuiltinTiers !== undefined ? { readDenyBuiltinTiers: normalizeNameList("denyBuiltinTiers", d.denyBuiltinTiers) } : {}),
             ...(d.denyBuiltinExclude !== undefined ? { readDenyBuiltinExclude: normalizeNameList("denyBuiltinExclude", d.denyBuiltinExclude) } : {}),
         };
-        // 发布件自身的引擎校验(与 env 覆盖无关 —— 一个坏发布就是坏发布,不因本机恰好用不上它而变合法)。
         if (normalized.readDenyPatterns !== undefined)
             compileReadDeny(normalized.readDenyPatterns);
         if (normalized.readDenyBuiltinTiers !== undefined || normalized.readDenyBuiltinExclude !== undefined) {
             resolveReadDenyBuiltins(builtinsArg(normalized.readDenyBuiltinTiers, normalized.readDenyBuiltinExclude));
         }
-        // ③ env-wins 逐键合成:只保留**没被 env 占住**的键。
         staged = Object.fromEntries(KEY_MAP.filter(([, cfgKey]) => config[cfgKey] === undefined).map(([, cfgKey]) => [cfgKey, normalized[cfgKey]]).filter(([, v]) => v !== undefined));
-        // 引擎规则再验一次,这次跑在**最终合成姿态**上(env 键 + 本次 center 键):跨腿坏组合
-        // (env 选档位 × center 删一个不在该档里的行名)只有在合成后才看得见。
         const finalPatterns = staged.readDenyPatterns ?? config.readDenyPatterns;
         const finalTiers = staged.readDenyBuiltinTiers ?? config.readDenyBuiltinTiers;
         const finalExclude = staged.readDenyBuiltinExclude ?? config.readDenyBuiltinExclude;
@@ -142,7 +85,6 @@ export function applyCenterReadFace(config, eff, logger) {
         });
         return envHeldKeys;
     }
-    // ── commit:纯赋值 ────────────────────────────────────────────────────────────────────────────
     if (staged.readFace !== undefined)
         config.readFace = staged.readFace;
     if (staged.readDenyPatterns !== undefined)
@@ -159,7 +101,6 @@ export function applyCenterReadFace(config, eff, logger) {
     }
     if (Object.keys(staged).length > 0) {
         logger?.info("sema_registry_read_face", {
-            // 落的是**哪些键**,不是 deny 表的内容(策略内容不进日志面,与能力位的最小披露同判)。
             applied: Object.keys(staged),
             ...(staged.readFace !== undefined ? { face: staged.readFace } : {}),
             note: "restart-to-apply — these keys are captured when the runner deps are assembled at boot",