@sema-agent/server 7.37.0 → 7.38.0-rc.2

package/dist/config-center/hot-keys-registry.d.ts

@@ -0,0 +1,62 @@
+/**
+ * #322 —— **热键登记表**(design/322 §4 机器门)。
+ *
+ * 一个键「是不是热的」在本仓有三个互相独立的说法:①代码里真的接了写入面;②测试里真的有黑盒断言;
+ * ③文档里对运维的承诺。三者任一漂了,受害者都是运维(改了配置,不知道该不该重启)。本表是**闭集单源**:
+ * 键 → 组 → 换代手法 → **参数化用例 ID**(不是文件名——文件名粒度挡不住「文件在、用例没了」)。
+ *
+ * 机器门在 test/config-hot/batch1-hot-keys-registry.test.ts:登记为热却没有三断言用例 = 红;
+ * 表的键集与 stage 真正消费的键集(`BATCH1_LIMIT_KEYS`)不等 = 红。
+ *
+ * ⚠️ 本表**只登记已落地的批**。批2-4 的键在各自批次里追加(设计稿 §6),不提前写进来 —— 一个「登记为热
+ * 但没接线」的条目正是本表要消灭的那种谎。
+ */
+import type { ServiceConfigFlat, ServiceConfigGroups } from "../config-types.js";
+/** 换代手法(design/322 §2):A′=写入面接线(消费侧本就现读);B=值换代座位(对象已建、值被冻住)。 */
+export type HotKeyForm = "A-prime" | "B-setter";
+/** 三断言的用例 ID —— 与 test/config-hot 的参数化生成规则(`HK-<key>-<kind>`)逐字一致。 */
+export interface HotKeyCases {
+    /** 生效:改配置源 ⇒ ≤2 tick 行为面翻转。 */
+    readonly effect: string;
+    /** 坏值拒:响亮拒 + 旧值继续服务。 */
+    readonly refuse: string;
+    /** 回滚:改回 / center 撤键 ⇒ 行为回原状(无粘滞)。 */
+    readonly rollback: string;
+}
+export interface HotKeyEntry {
+    readonly key: keyof ServiceConfigFlat;
+    readonly group: keyof ServiceConfigGroups;
+    readonly form: HotKeyForm;
+    /** 落地批次(设计稿 §6 的批号)。 */
+    readonly batch: 1;
+    readonly cases: HotKeyCases;
+}
+/**
+ * 批1(cost 族)真正接线的 14 键 —— **stage 消费的单一真源**:`stage-limits.ts` 按本表遍历,
+ * 所以「表里有、stage 不写」或「stage 写、表里没有」都不可能悄悄发生。
+ *
+ * 前 3 个是 B 簇1(限额座 setter);其余 11 个是 limitsHttp 组的 A′ 接线键。
+ */
+export declare const BATCH1_LIMIT_KEYS: readonly ["rateLimitPerMin", "maxPrincipalCostUsd", "costQuotaWindowSec", "maxTaskCostUsd", "maxTaskTokens", "infraCostRates", "attachmentOrphanGraceMs", "workspaceFileMaxBytes", "attachmentMaxBytes", "attachmentMimeAllowlist", "attachmentUnboundTtlMs", "drainGraceMs", "runStaleSec", "toolResultTtlSec"];
+export type Batch1LimitKey = (typeof BATCH1_LIMIT_KEYS)[number];
+/**
+ * 🔴 **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 declare const DEFERRED_LIMIT_KEYS: ReadonlyArray<{
+    readonly key: Batch1LimitKey;
+    readonly restartReason: string;
+    readonly why: string;
+}>;
+/** 热键表 = 批1 消费键集**减去**显式 deferred 的那些(表只登记真的热的键)。 */
+export declare const HOT_KEYS_REGISTRY: readonly HotKeyEntry[];
+//# sourceMappingURL=hot-keys-registry.d.ts.map

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

@@ -0,0 +1,54 @@
+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",
+    "costQuotaWindowSec",
+    "maxTaskCostUsd",
+    "maxTaskTokens",
+    "infraCostRates",
+    "attachmentOrphanGraceMs",
+    "workspaceFileMaxBytes",
+    "attachmentMaxBytes",
+    "attachmentMimeAllowlist",
+    "attachmentUnboundTtlMs",
+    "drainGraceMs",
+    "runStaleSec",
+    "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",
+        restartReason: "cost-quota-window",
+        why: "the quota window length is part of the SQL bucket key (row state), not a comparison parameter — hot-swapping it can revive spend from an older window on the SQL backends while the in-memory backend clears it (a backend-dependent cost fail-open)",
+    },
+];
+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",
+    form: (B_SETTER_KEYS.includes(key) ? "B-setter" : "A-prime"),
+    batch: 1,
+    cases: cases(key),
+}));
+//# sourceMappingURL=hot-keys-registry.js.map

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

@@ -45,9 +45,19 @@ export async function fetchEffective(baseUrl, token, etag, fetchImpl = fetch, wo
         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
-        .filter((w) => w.kind === "domain-defaulted")
-        .map((w) => ({ domain: w.domain, error: (w.error instanceof Error ? w.error.message : String(w.error)).slice(0, 600) }));
+        .map((w) => w.kind === "domain-defaulted"
+        ? { domain: w.domain, error: (w.error instanceof Error ? w.error.message : String(w.error)).slice(0, 600) }
+        : w.kind === "unknown-keys-dropped"
+            ? { domain: w.domain, error: `unknown keys dropped by domain schema: ${w.keys.join(", ")}`.slice(0, 600) }
+            : w.kind === "unknown-keys-carried"
+                ? { domain: w.domain, error: `unknown keys carried to consumer (spelling?): ${w.keys.join(", ")}`.slice(0, 600) }
+                : w.kind === "unread-config-file"
+                    ? { 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;

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

@@ -6,7 +6,7 @@
  * 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, runtimeGatePresent, resolveDefaultModelName } from "./apply-effective.js";
+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. */
@@ -82,8 +82,11 @@ 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 (runtimeGatePresent(rt, k))
+                if (!HOT_RUNTIME_GATE_KEYS.has(k) && runtimeGatePresent(rt, k))
                     present[k] = rt[k];
             return Object.keys(present).length ? present : null;
         }

package/dist/config-center/stage-limits.d.ts

@@ -0,0 +1,59 @@
+/**
+ * #322 批1 —— limitsHttp 组的 **stage 半场**(design/322 手法 A′ + B 簇1)。
+ *
+ * 形与 `stageApprovalRequire` 同族:一切可抛/可判的事在 stage 做,commit 段只剩纯赋值。三条本域纪律:
+ *
+ *  1. **非粘**(applyRuntimeHot 的 NON-STICKY 同源):每次 apply 都从 **env 基线**重算 `present ? center : baseline`
+ *     ——center 撤键 ⇒ 回 env 底。「缺席=保上一个 center 值」会把一次已经撤回的限额永久冻在进程里。
+ *  2. **整批原子**(design/322 §0③ + §4 混批零变异):本域任一键坏值/任一跨键不变量不过 ⇒ **整批拒**,
+ *     合法键也不落地,旧值继续服务,拒因响亮点名键(#123 法)。半应用一个限额面 = 运营看到的数字与真门
+ *     不是同一代,比整批拒糟得多。
+ *  3. **判据单源**:跨键不变量走 `config-invariants.ts` 的同一张表(boot 与 stage 同表);数值下限走
+ *     config.ts 导出的同一组 floor 常量(env 腿夹取、center 腿拒——**判据阈值同源,处置刻意不同**:
+ *     env 是既有部署的存量值,夹取+点名不打断服务;center 发布是一次可重发的显式动作,拒绝才有意义)。
+ */
+import type { ServiceConfig } from "../config-types.js";
+import type { Logger } from "../observability/logger.js";
+import { type Batch1LimitKey } from "./hot-keys-registry.js";
+import type { EffectiveLimits } from "./types.js";
+/**
+ * stage 的入参视图。
+ *
+ * 🔴 `legacyGates` 是**已过旧位 presence 判据**的闸值(判据属主 = `runtimeGatePresent`,调用方过一遍再传)。
+ * 两位刻意判据不同,不是疏忽:旧位(`runtime`)的容忍语义(例如 `costQuotaWindowSec: 0` 判「缺席」保 env)
+ * 是既有 center 的在营契约,收紧它会把一个存量发布变成整批拒;新位(`limits`)从第一天起就是严判
+ * (坏值 = 整批响亮拒)。判据属主各只有一个,谁都没有被复刻第二份。
+ */
+export interface LimitsSource {
+    readonly version: number;
+    readonly limits?: EffectiveLimits;
+    readonly legacyGates?: Readonly<Record<string, unknown>>;
+}
+/** 逐键 defer 的铸因(codex R2-F2):值合法但这一键**不热**,变更只能重启生效。 */
+export interface DeferredLimit {
+    readonly key: Batch1LimitKey;
+    readonly reason: string;
+}
+export interface StagedLimits {
+    /** commit 段照单赋值。 */
+    readonly assignments: ReadonlyArray<readonly [Batch1LimitKey, unknown]>;
+    /** 回 env 底、而底本身是「键缺席」的那些键(presence-as-semantics 的键必须**删**,不能写 undefined)。 */
+    readonly deletions: readonly Batch1LimitKey[];
+    /** 本世代真正换了值的键(通知载荷,post-commit 发)。 */
+    readonly changed: readonly string[];
+    /** 值合法但**不热**的键:不落地,铸因进世代账 + 一条响亮 warn(逐键 defer,不是整批拒)。 */
+    readonly deferred: readonly DeferredLimit[];
+    /** 整批被拒时的成因(消毒:只带键名与判据文案,**绝不带值**)。 */
+    readonly rejected?: {
+        readonly keys: string[];
+        readonly reason: string;
+        readonly restartReason?: string;
+    };
+}
+/**
+ * STAGE:算出本世代 limitsHttp 组要 COMMIT 的全部赋值(纯计算,零变异)。
+ *
+ * 返回 `rejected` 时 `assignments`/`deletions` 恒为空 —— 整批拒的物理保证在返回值形上,不靠调用方自律。
+ */
+export declare function stageLimits(config: ServiceConfig, eff: LimitsSource, logger?: Logger): StagedLimits;
+//# sourceMappingURL=stage-limits.d.ts.map

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

@@ -0,0 +1,188 @@
+import { LIMITS_HTTP_FLOORS } from "../config.js";
+import { checkCrossInvariants } from "../config-invariants.js";
+import { BATCH1_LIMIT_KEYS, DEFERRED_LIMIT_KEYS } from "./hot-keys-registry.js";
+const INFRA_RATE_KEYS = ["toolCallMicroUsd", "sandboxSecMicroUsd", "egressGbMicroUsd"];
+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 拿它做除数
+    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" };
+        const src = v;
+        const unknown = Object.keys(src).filter((k) => !INFRA_RATE_KEYS.includes(k));
+        if (unknown.length > 0)
+            return { ok: false, reason: `infraCostRates has unknown rate(s) ${unknown.join(", ")} — a misspelled rate name means that axis is silently NOT billed; known rates: ${INFRA_RATE_KEYS.join(", ")}` };
+        const base = (baseline ?? {});
+        const out = {};
+        for (const k of INFRA_RATE_KEYS) {
+            const raw = src[k];
+            if (raw === undefined) {
+                out[k] = base[k] ?? 0; // 缺席成员 = 本域不管这一条轴 ⇒ 回 env 基线(非粘),**不是**清零
+                continue;
+            }
+            if (!okNum(raw) || raw < 0)
+                return { ok: false, reason: `infraCostRates.${k} must be a finite number >= 0 (a negative rate would credit cost back)` };
+            out[k] = raw;
+        }
+        return { ok: true, value: out };
+    },
+    attachmentOrphanGraceMs: (v) => atLeast("attachmentOrphanGraceMs", v, 0), // 0 = 关掉孤儿清扫腿
+    workspaceFileMaxBytes: (v) => positive("workspaceFileMaxBytes", v),
+    attachmentMaxBytes: (v) => atLeast("attachmentMaxBytes", v, LIMITS_HTTP_FLOORS.attachmentMaxBytes),
+    attachmentMimeAllowlist: (v) => {
+        if (!Array.isArray(v))
+            return { ok: false, reason: "attachmentMimeAllowlist must be an array of mime strings" };
+        const bad = v.some((e) => typeof e !== "string" || e.trim().length === 0);
+        if (bad)
+            return { ok: false, reason: "attachmentMimeAllowlist must contain only non-empty strings (a coerced/dropped entry would silently WIDEN or empty the policy)" };
+        return { ok: true, value: v.map((e) => String(e).trim().toLowerCase()) };
+    },
+    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 ⇒ 一拍收光所有卸载结果
+};
+/** env 派生基线(**首次** stage 时快照;boot 序 = loadConfig → applyEffective,此刻 config 尚是纯 env)。 */
+const limitsEnvBaseline = new WeakMap();
+function baselineOf(config) {
+    const known = limitsEnvBaseline.get(config);
+    if (known)
+        return known;
+    const snap = {};
+    for (const k of BATCH1_LIMIT_KEYS)
+        snap[k] = structuredClone(config[k]);
+    limitsEnvBaseline.set(config, snap);
+    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 ?? {};
+    const assignments = [];
+    const deletions = [];
+    const changed = [];
+    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}` };
+        logger?.warn("sema_registry_limits_invalid", {
+            ...rejected,
+            version: eff.version,
+            kept: "the whole limits batch is refused — a malformed container must never read as 'the center manages none of these keys' (that would silently revert every published ceiling to the env baseline)",
+        });
+        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));
+        if (unconsumed.length > 0) {
+            logger?.warn("sema_registry_limits_unconsumed_keys", {
+                keys: unconsumed,
+                version: eff.version,
+                note: "published in the limits domain but not consumed by this server build (misspelled, or a later-batch key) — the value is inert until a batch that owns it ships",
+            });
+        }
+    }
+    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 底
+        }
+        else {
+            const verdict = VALIDATORS[key](published, baseline[key]);
+            if (!verdict.ok) {
+                badKeys.push(key);
+                reason ??= verdict.reason;
+                continue;
+            }
+            next = verdict.value;
+        }
+        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 });
+            continue;
+        }
+        if (next === undefined)
+            deletions.push(key);
+        else
+            assignments.push([key, next]);
+        changed.push(key);
+    }
+    if (badKeys.length > 0) {
+        const rejected = { keys: badKeys, reason: reason };
+        logger?.warn("sema_registry_limits_invalid", {
+            ...rejected,
+            version: eff.version,
+            kept: "the whole limits batch is refused — the prior values keep serving (a half-applied limit face means the published numbers and the live gate are different generations)",
+        });
+        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();
+        const rejected = { keys: [...involved], reason: verdict.reason, restartReason: verdict.restartReason };
+        logger?.warn("sema_registry_limits_invalid", {
+            ...rejected,
+            invariant: verdict.id,
+            version: eff.version,
+            kept: "the whole limits batch is refused by a cross-key invariant — the prior values keep serving; this change needs a restart if it is intended",
+        });
+        return { assignments: [], deletions: [], changed: [], deferred: [], rejected };
+    }
+    if (deferred.length > 0) {
+        logger?.warn("sema_registry_limits_deferred", {
+            keys: deferred.map((d) => d.key),
+            version: eff.version,
+            reasons: [...new Set(DEFERRED_LIMIT_KEYS.filter((d) => deferred.some((x) => x.key === d.key)).map((d) => d.why))],
+            note: "these published keys are NOT hot — the prior values keep serving until this process restarts (the restart is what applies them)",
+        });
+    }
+    return { assignments, deletions, changed, deferred };
+}
+//# sourceMappingURL=stage-limits.js.map

package/dist/config-center/types.d.ts

@@ -172,6 +172,46 @@ export interface CenterReadFace {
     /** 按行名删内建条目,在档位选择**之后**生效。 */
     denyBuiltinExclude?: string[];
 }
+/**
+ * #322 批1 的 wire 面(`EffectiveConfig.limits`)。**全 optional**:缺席 = 本域不管这一键 ⇒ 该键回 env
+ * 基线(非粘,applyRuntimeHot 的 NON-STICKY 同族纪律 —— 「缺席=保上一个 center 值」会把撤回的治理永久冻住)。
+ *
+ * 🔴 类型是**到货 JSON 的声明**,不是运行时保证(local 腿的 eff 来自原始 JSON):每个键在 stage 侧都
+ * 逐个验型验域,坏值 ⇒ 整批拒 + 旧值继续服务(#123 响亮拒)。
+ */
+export interface EffectiveLimits {
+    /** 每 principal 每分钟请求上限;**0 = 关**(关断哨兵,不是缺席)。 */
+    rateLimitPerMin?: number;
+    /** 每 principal 滚动窗累计花费上限(USD);0 = 无配额。 */
+    maxPrincipalCostUsd?: number;
+    /** 上面那条配额的窗长(秒);必须 > 0。 */
+    costQuotaWindowSec?: number;
+    /** 单任务成本/token 天花板;0 = 无天花板。 */
+    maxTaskCostUsd?: number;
+    maxTaskTokens?: number;
+    /** 基建计价(每项 ≥ 0);缺席 = 不改。 */
+    infraCostRates?: {
+        toolCallMicroUsd?: number;
+        sandboxSecMicroUsd?: number;
+        egressGbMicroUsd?: number;
+    };
+    /** 附件孤儿对象 GC 宽限(ms);0 = 关掉该腿。 */
+    attachmentOrphanGraceMs?: number;
+    /** workspace 单文件读上限(字节,> 0)。 */
+    workspaceFileMaxBytes?: number;
+    /** 附件单文件上限(字节,≥ 下限)。 */
+    attachmentMaxBytes?: number;
+    /** 附件 mime 白名单(非空串数组);空数组 = 显式「一个都不许」,与缺席(不设限)不同。 */
+    attachmentMimeAllowlist?: string[];
+    /** 未绑定附件 TTL(ms)。 */
+    attachmentUnboundTtlMs?: number;
+    /** SIGTERM drain 窗(ms)。 */
+    drainGraceMs?: number;
+    /** run 心跳陈旧窗(秒);必须严格大于活体心跳(跨键不变量,见 config-invariants.ts)。 */
+    runStaleSec?: number;
+    /** 卸载工具结果的 TTL(秒,> 0)。 */
+    toolResultTtlSec?: number;
+}
 export interface EffectiveConfig {
     version: number;
     updatedAt: string;
@@ -239,6 +279,26 @@ export interface EffectiveConfig {
         autonomy?: Autonomy;
         commandPolicy?: CommandRule[];
     };
+    /**
+     * #322 批1 —— **limitsHttp 组的热更新发布域**(design/322 §6 批1)。
+     *
+     * 🔴 为什么是**新顶层域**而不是往 `runtime` 里加键(亲验,不是推测):registry-core 的 `RuntimeConfig`
+     * 是 zod `"strip"` 对象,`runtime` 里的未知键在**两条腿上都会被静默剥掉**(local 腿实测
+     * `{rateLimitPerMin:7, toolResultTtlSec:999}` → `{rateLimitPerMin:7}`,零 domainError;remote 腿的
+     * `readEffectiveWire` 同一 schema)。而**未知顶层域**是 open-world verbatim 透传的(同一实测:顶层
+     * `limits` 原样到手)——所以这是今天唯一能真的把这些键送到消费端的形,也与 governance 域当初从
+     * runtime 里拆出去的先例同族。
+     *
+     * 车道现状(如实):remote 腿即刻可用(center 发什么就到什么);**local 腿(config.d/)暂不可用** ——
+     * `FileConfigStore` 的域表是闭集,`config.d/limits.json` 根本不会被读进 effective。补法在 registry-core
+     * (加 `limits` 域 + PORTABLE_DOMAINS),与 `a2a`/`readFace` 当初的缺口同族;server 侧的消费半场(本键 +
+     * stage + commit)先落地,不在下游自建第二个读盘腿(源头修复纪律)。
+     *
+     * 与 `runtime` 的**优先级**:五个既有闸键(rateLimitPerMin/maxTaskCostUsd/maxTaskTokens/
+     * maxPrincipalCostUsd/costQuotaWindowSec)两处都可能出现 ⇒ `limits` 赢(新位是真值,旧位是过渡),
+     * 与 governance/runtime 的读取优先级契约同形。
+     */
+    limits?: EffectiveLimits;
     /** 142-S4(registry-core 0.10.0 第 15 域):center 项目登记簿。wire 面 verbatim JSON —
      *  registry-core `ProjectsConfig` 的形状是 `{projects: Record<projectId, ProjectRegistration>}`(skills/mcp
      *  同款域包裹)。[2373]B-8:裸 Record 联合臂随 apply-effective 的宽读一起删(0.13.0 只有包裹形,

package/dist/config-invariants.d.ts

@@ -0,0 +1,65 @@
+/**
+ * #322 —— **跨键不变量的单源表**(design/322 §2 A′,codex 设计审 F2)。
+ *
+ * 病灶:boot 期的跨域不变量(拒启 throw)散在 `config.ts` 的装配尾与 `main.ts` 的开头。把配置改热之后,
+ * 每一条都变成一个**热路径上的漏检**:一次发布可以在运行期造出 boot 期会当场拒启的姿态(无鉴权写面被
+ * 打开、bake runner 凭据被删、直连门半开、reaper 追杀活 run……),而进程照跑。逐条在 stage 里手抄一遍
+ * 是必错的形(抄漏一条没人会发现),所以本文件是**唯一**的表:
+ *
+ *  · stage 面(config-center):批1 的任一键触发**全表**校验,过不了 ⇒ 整批拒 + 旧值继续服务 + 铸
+ *    `restartReason`(运维据此知道「这个变更只能重启生效」,而不是被静默吞掉)。
+ *  · boot 面:每条 throw 点旁挂 `CROSS-INVARIANT:<id>` 锚,由 test/config-hot/batch1-cross-invariants.test.ts
+ *    双向对表 —— 新增一条拒启却不登记 = 门红。boot 的判据文本与拒启行为**逐字不变**(本批不改拒启),
+ *    表在这一侧承担的是「不许有表外不变量」的登记职责。
+ *
+ * 🔴 判据形状:每条不变量收 `{live, next}` 两个视图。有些条目判的是**状态**(next 自身是否自洽),有些
+ * 判的是**转换**(宽→窄、门姿态翻转)。boot 期没有「上一代」,调用方传 `live === next`,于是转换型条目
+ * 在 boot 天然惰性 —— 这正确:boot 不存在「热切」这回事。
+ *
+ * 依赖纪律:本文件是**叶**(只 type-import config-types + 值引 deployment-governance 的守卫集编译门),
+ * 不引 config.ts,故 config.ts / runs.ts 都可以安全引它。
+ */
+import type { ServiceConfigFlat } from "./config-types.js";
+/**
+ * 活体心跳周期(ms)——`runs.ts` 的 `HEARTBEAT_MS` 就是它(那边 re-export,单源在此)。
+ *
+ * 为什么常量住在不变量文件里:它唯一的**判据用途**是「陈旧窗必须大于心跳」这条不变量,而该不变量现在
+ * 有 boot 与 stage 两个消费面。放在这里,两面读的是同一个数,`runs.ts` 的心跳环也读同一个数。
+ */
+export declare const LIVENESS_HEARTBEAT_MS = 30000;
+/** 闭集:新增一条不变量必须在这里加词(拼错 = 编译红,而不是运行期悄悄不判)。 */
+export type CrossInvariantId = "run-stale-heartbeat" | "bind-posture" | "bake-runner-credential" | "direct-door-anchors" | "operator-principals-required" | "bake-operator-principals" | "sensitive-write-patterns" | "leader-host-lane" | "leader-durable-store";
+/** 表读的键集(取自平铺配置型 ⇒ 键名/类型永不与真配置漂)。 */
+export type CrossInvariantView = Readonly<Pick<ServiceConfigFlat, "runStaleSec" | "authToken" | "authTokens" | "allowUnauthedWrites" | "imageBakes" | "directApprovalDoor" | "durableApproval" | "approvalHmacKeys" | "principalJwtPubkeys" | "principalJwtIss" | "principalJwtAud" | "requirePrincipal" | "operatorPrincipals" | "sensitiveWritePatterns" | "leaderEnabled" | "remoteExec" | "dbBackend">>;
+export interface CrossInvariantInput {
+    /** 现役配置(boot 期 = 候选自身)。 */
+    readonly live: CrossInvariantView;
+    /** 候选(stage 期 = 现役 + 本批 staged 赋值)。 */
+    readonly next: CrossInvariantView;
+}
+export interface CrossInvariant {
+    readonly id: CrossInvariantId;
+    /** 本条读哪些键(诊断面按键回答「我这次改动会被哪条不变量看着」)。 */
+    readonly keys: readonly (keyof ServiceConfigFlat)[];
+    /** 热拒时铸给运维的重启因由(与 restart-signal 的 slice 词表同族的自由词,不是 RestartSlice 闭集)。 */
+    readonly restartReason: string;
+    /** boot 期同一条不变量的拒启锚(机械门用;缺席 = 本条只存在于 stage 面)。 */
+    readonly bootAnchor?: {
+        readonly file: string;
+        readonly marker: string;
+    };
+    /** 返回拒因;`undefined` = 通过。 */
+    check(input: CrossInvariantInput): string | undefined;
+}
+export declare const CONFIG_CROSS_INVARIANTS: readonly CrossInvariant[];
+export type CrossInvariantVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    id: CrossInvariantId;
+    reason: string;
+    restartReason: string;
+};
+/** 全表校验(**第一条不过即拒**:候选是整批的,报第一个成因足够行动,继续跑其余条目只会淹掉它)。 */
+export declare function checkCrossInvariants(input: CrossInvariantInput): CrossInvariantVerdict;
+//# sourceMappingURL=config-invariants.d.ts.map