@sema-agent/server 7.71.0 → 7.73.0

package/dist/config-catalog.js

@@ -1,6 +1,6 @@
 import { CROSS_SESSION_INBOUND_SETTINGS, CROSS_SESSION_DIALOG_EXPIRY_VALUES } from "@sema-agent/core";
 import { THINKING_FORMATS } from "./model-compat.js";
-import { MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT } from "./config-types.js";
+import { RESILIENCE_DEFAULTS } from "./config-types.js";
 import { webSearchConfigFromEnv } from "./plugins/web-search.js";
 import { CENTER_READ_FACE_LIVE_KEYS } from "./config-center/read-face.js";
 export const CATALOG_VALUE_TYPES = ["boolean", "number", "string", "enum", "csv", "json", "path", "url", "secret", "opaque"];
@@ -246,8 +246,8 @@ export const CONFIG_CATALOG = [
     r("MODEL_API_KEY", "modelPlane", "secret", "网关腿共享 API key(per-model 覆写在 center 侧)", { danger: [...SEC, ...BILL] }),
     r("MODEL_AUTO_COMPACT_TOKENS", "modelPlane", "number", "主槽 dual-window 触发阈(1M 窗不再隐式 967000,缺席则用普通触发几何)", { derivedDefaultNote: "缺席 ⇒ 不铸键(core W-33000 几何)" }),
     r("MODEL_CASCADE_LADDER", "modelPlane", "csv", "质量门级联梯(目录名 cheapest→strongest;opt-in per-task cascade:true)", { danger: BILL, configKey: "cascadeLadder" }),
-    r("MODEL_CB_COOLDOWN_MS", "modelPlane", "number", "熔断冷却窗(ms)", { staticDefault: "30000" }),
-    r("MODEL_CB_FAILURE_THRESHOLD", "modelPlane", "number", "熔断失败阈", { staticDefault: "5" }),
+    r("MODEL_CB_COOLDOWN_MS", "modelPlane", "number", "熔断冷却窗(ms)", { staticDefault: String(RESILIENCE_DEFAULTS.cooldownMs.value) }),
+    r("MODEL_CB_FAILURE_THRESHOLD", "modelPlane", "number", "熔断失败阈", { staticDefault: String(RESILIENCE_DEFAULTS.failureThreshold.value) }),
     r("MODEL_CHARS_PER_TOKEN", "modelPlane", "number", "结构估 token 系数(CJK 密集模型建议 2-3;坏值回 core 默认)", { derivedDefaultNote: "缺席 ⇒ core 默认 4" }),
     r("MODEL_CHEAP_AUTO_COMPACT_TOKENS", "modelPlane", "number", "cheap 槽 dual-window 触发阈(主槽值刻意不外溢)", { derivedDefaultNote: "缺席 ⇒ 不铸键" }),
     r("MODEL_CHEAP_CHARS_PER_TOKEN", "modelPlane", "number", "cheap 槽结构估 token 系数", { derivedDefaultNote: "缺席 ⇒ 继承主模型" }),
@@ -260,14 +260,14 @@ export const CONFIG_CATALOG = [
     r("MODEL_CHEAP_MAX_TOKENS", "modelPlane", "number", "cheap 槽输出上限", { derivedDefaultNote: "缺席 ⇒ 继承主模型", center: cModels("models[].maxTokens") }),
     r("MODEL_CHEAP_REASONING", "modelPlane", "boolean", "cheap 槽 reasoning 声明(三态:缺席继承主模型)", { derivedDefaultNote: "缺席 ⇒ 继承主模型" }),
     r("MODEL_CHEAP_VISION", "modelPlane", "boolean", "cheap 槽 vision 声明(三态:缺席继承主模型;text-only cheap 必设 false 让预检真拦)", { derivedDefaultNote: "缺席 ⇒ 继承主模型" }),
-    r("MODEL_CIRCUIT_BREAKER", "modelPlane", "boolean", "模型腿熔断开关", { staticDefault: "false" }),
+    r("MODEL_CIRCUIT_BREAKER", "modelPlane", "boolean", "模型腿熔断开关", { staticDefault: String(RESILIENCE_DEFAULTS.circuitBreaker.value) }),
     r("MODEL_CODE_ROLES", "modelPlane", "csv", "给点名 role 附编码 persona(role 表内名字才生效)"),
-    r("MODEL_CONNECT_TIMEOUT_MS", "modelPlane", "number", "连接超时(ms;0=关)", { staticDefault: "30000" }),
+    r("MODEL_CONNECT_TIMEOUT_MS", "modelPlane", "number", "连接超时(ms;0=关)", { staticDefault: String(RESILIENCE_DEFAULTS.connectTimeoutMs.value) }),
     r("MODEL_CONTEXT_WINDOW", "modelPlane", "number", "主模型上下文窗声明", { staticDefault: "262144", configKey: "model", resolve: (c) => c.model.contextWindow ?? null, center: cModels("models[].contextWindow") }),
-    r("MODEL_COST_CACHE_READ", "modelPlane", "number", "主模型 cache-read 单价(per-1M USD;0=不计价)", { staticDefault: "0", danger: BILL, resolve: (c) => c.model.cost?.cacheRead ?? null, center: cModels("models[].cost.cacheRead") }),
-    r("MODEL_COST_CACHE_WRITE", "modelPlane", "number", "主模型 cache-write 单价", { staticDefault: "0", danger: BILL, resolve: (c) => c.model.cost?.cacheWrite ?? null, center: cModels("models[].cost.cacheWrite") }),
-    r("MODEL_COST_INPUT", "modelPlane", "number", "主模型 input 单价(NaN 会让成本天花板整条消失 ⇒ 坏值拒启)", { staticDefault: "0", danger: BILL, resolve: (c) => c.model.cost?.input ?? null, center: cModels("models[].cost.input") }),
-    r("MODEL_COST_OUTPUT", "modelPlane", "number", "主模型 output 单价", { staticDefault: "0", danger: BILL, resolve: (c) => c.model.cost?.output ?? null, center: cModels("models[].cost.output") }),
+    r("MODEL_COST_CACHE_READ", "modelPlane", "number", "主模型 cache-read 单价(per-1M USD;显式 0=声明免费,不是「没配」)", { derivedDefaultNote: "四键全缺席 ⇒ 未定价(不铸 cost 键,成本读面缺席);任一设 ⇒ 四键在场,未设的按 0 显式", danger: BILL, resolve: (c) => c.model.cost?.cacheRead ?? null, center: cModels("models[].cost.cacheRead") }),
+    r("MODEL_COST_CACHE_WRITE", "modelPlane", "number", "主模型 cache-write 单价", { derivedDefaultNote: "四键全缺席 ⇒ 未定价(不铸 cost 键,成本读面缺席);任一设 ⇒ 四键在场,未设的按 0 显式", danger: BILL, resolve: (c) => c.model.cost?.cacheWrite ?? null, center: cModels("models[].cost.cacheWrite") }),
+    r("MODEL_COST_INPUT", "modelPlane", "number", "主模型 input 单价(NaN 会让成本天花板整条消失 ⇒ 坏值拒启)", { derivedDefaultNote: "四键全缺席 ⇒ 未定价(不铸 cost 键,成本读面缺席);任一设 ⇒ 四键在场,未设的按 0 显式", danger: BILL, resolve: (c) => c.model.cost?.input ?? null, center: cModels("models[].cost.input") }),
+    r("MODEL_COST_OUTPUT", "modelPlane", "number", "主模型 output 单价", { derivedDefaultNote: "四键全缺席 ⇒ 未定价(不铸 cost 键,成本读面缺席);任一设 ⇒ 四键在场,未设的按 0 显式", danger: BILL, resolve: (c) => c.model.cost?.output ?? null, center: cModels("models[].cost.output") }),
     r("MODEL_DEFAULT_THINKING", "modelPlane", "enum", "主模型默认思考档(llm-core ThinkingLevel;off=不设模型级默认;未知词拒启)", { enumValues: ["minimal", "low", "medium", "high", "xhigh", "max", "off"], derivedDefaultNote: "缺席/off ⇒ 不铸 defaultThinking(逐任务档由 spec>role 决定)", resolve: (c) => c.model.defaultThinking ?? null }),
     r("MODEL_DEGRADE_AT_COST_FRACTION", "modelPlane", "number", "预算降级触发比(spent/budget;>1=实际别降级)", { staticDefault: "0.7", danger: BILL }),
     r("MODEL_DEGRADE_ON", "modelPlane", "csv", "反应式降级触发词表(core DegradeReason 全集;拼错拒启)", { center: { domain: "models", path: "degrade", centerKey: "models", precedence: "center-wins", timing: "restart", restartSlice: "degrade-route" } }),
@@ -275,12 +275,12 @@ export const CONFIG_CATALOG = [
     r("MODEL_DEGRADE_TO", "modelPlane", "string", "降级目标模型(设了=开降级;外部网关名不必在目录)", { danger: BILL }),
     r("MODEL_DEGRADE_TO_VISION", "modelPlane", "boolean", "降级目标的 vision 声明(false ⇒ 带图任务丢降级不丢图)", { staticDefault: "false" }),
     r("MODEL_EXTRA_BODY", "modelPlane", "opaque", "生成参数直通 JSON(top_k/logit_bias 等;必须静态 —— 前缀缓存键序)", { danger: SEC }),
-    r("MODEL_FIRST_TOKEN_TIMEOUT_MS", "modelPlane", "number", "首 token 超时(ms;0=关 —— 开流不吐字的唯一看门狗;自托管长 prefill 后端按此档留足)", { staticDefault: String(MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT) }),
+    r("MODEL_FIRST_TOKEN_TIMEOUT_MS", "modelPlane", "number", "首 token 超时(ms;0=关 —— 开流不吐字的唯一看门狗;自托管长 prefill 后端按此档留足)", { staticDefault: String(RESILIENCE_DEFAULTS.firstTokenTimeoutMs.value) }),
     r("MODEL_FREQUENCY_PENALTY", "modelPlane", "number", "frequency_penalty 直通(压过 EXTRA_BODY 同键)"),
     r("MODEL_GATEWAY_BASEURL", "modelPlane", "url", "openai 兼容网关 base URL(默认 localhost 占位 —— 公开分发不烤内网坐标)", { staticDefault: "http://127.0.0.1:8000/v1", configKey: "gatewayBaseUrl", center: cModels("models[].baseUrl") }),
     r("MODEL_GATEWAY_FALLBACK_URLS", "modelPlane", "url", "网关故障转移地址表(CSV)", { configKey: "gatewayFallbackUrls" }),
     r("MODEL_ID", "modelPlane", "string", "主模型 id(3.0.0 起无出厂缺省,缺 ⇒ 拒启指路)", { configKey: "model", resolve: (c) => c.model.id, center: cModels("models[].id") }),
-    r("MODEL_IDLE_TIMEOUT_MS", "modelPlane", "number", "流中静默看门狗(ms;0=关)", { staticDefault: "300000" }),
+    r("MODEL_IDLE_TIMEOUT_MS", "modelPlane", "number", "流中静默看门狗(ms;0=关)", { staticDefault: String(RESILIENCE_DEFAULTS.idleTimeoutMs.value) }),
     r("MODEL_MAX_TOKENS", "modelPlane", "number", "主模型输出上限", { derivedDefaultNote: "缺席 ⇒ min(32000, contextWindow)", resolve: (c) => c.model.maxTokens ?? null, center: cModels("models[].maxTokens") }),
     r("MODEL_PRESENCE_PENALTY", "modelPlane", "number", "presence_penalty 直通"),
     r("MODEL_PROVIDER", "modelPlane", "string", "主模型 provider(路由选 brain)", { derivedDefaultNote: "缺席:ANTHROPIC base+cred 同在 ⇒ anthropic,否则 gateway", resolve: (c) => c.model.provider, center: cModels("models[].provider") }),
@@ -340,7 +340,7 @@ export const CONFIG_CATALOG = [
     r("QUESTION_TTL_MS", "approval", "number", "AskUserQuestion 无人应答释放窗(ms)", { derivedDefaultNote: "缺席 ⇒ 出厂窗 300000" }),
     r("RATE_LIMIT_RPM", "limitsHttp", "number", "计费提交每分钟限流(0=关)", { staticDefault: "0", danger: BILL, configKey: "rateLimitPerMin", center: cLimits("rateLimitPerMin") }),
     r("READ_DENY_BUILTIN_EXCLUDE", "orchestration", "csv", "按行名删内建 deny 条目(档位之后生效;绝不削任务显式 deny)", { danger: SEC, configKey: "readDenyBuiltinExclude", center: cRead("denyBuiltinExclude", "readDenyBuiltinExclude") }),
-    r("READ_DENY_BUILTIN_TIERS", "orchestration", "csv", "内建 deny 表档位选择(闭集四档;none=显式空姿态)", { danger: SEC, configKey: "readDenyBuiltinTiers", center: cRead("denyBuiltinTiers", "readDenyBuiltinTiers") }),
+    r("READ_DENY_BUILTIN_TIERS", "orchestration", "csv", "内建 deny 表档位选择(闭集五档 credentials/shell-history/browser/wallet/agent-config;none=显式空姿态)", { danger: SEC, configKey: "readDenyBuiltinTiers", center: cRead("denyBuiltinTiers", "readDenyBuiltinTiers") }),
     r("READ_DENY_PATTERNS", "orchestration", "csv", "READ 面额外 deny pattern 表", { danger: SEC, configKey: "readDenyPatterns", center: cRead("denyPatterns", "readDenyPatterns") }),
     r("READ_FACE", "orchestration", "enum", "READ 容纳面档位(env 逐键恒赢 center —— 部署主权表达)", { enumValues: ["open", "roots"], danger: SEC, derivedDefaultNote: "缺席 ⇒ 按 posture 派生(S-167):单用户 turnkey(REQUIRE_PRINCIPAL 未设)铸 open;多租户不铸键、core 默认 roots。生效来源见 GET /v1/diagnostics/wiring 的 readFace.source 四词", configKey: "readFace", center: cRead("face", "readFace") }),
     r("REAP_INTERVAL_SEC", "limitsHttp", "number", "reaper 周期(秒)", { staticDefault: "60", configKey: "reapIntervalSec" }),

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

@@ -1,6 +1,6 @@
 import { resolveActiveTiers, SEALED_BOX_ALG } from "@sema-agent/settings-schema";
 import { sealedKeyPoison } from "../sealed-key.js";
-import { applyAutoCompactWindow, findUnmatchableToolNames, formatUnmatchableToolNames, parseAutonomy } from "../config.js";
+import { applyAutoCompactWindow, buildModelCostKey, findUnmatchableToolNames, formatUnmatchableToolNames, parseAutonomy } from "../config.js";
 import { buildModelCompat, readModelCompat } from "../model-compat.js";
 import { validateCommandRules } from "../runtime-governance.js";
 import { projectCollabToWorkflows, registerCollabWorkflows } from "../capabilities/collab-workflows.js";
@@ -37,9 +37,7 @@ function toModel(m, envDefaults = {}, logger) {
         ...(charsPerTokenOf(m.charsPerToken) !== undefined || envDefaults.charsPerToken !== undefined
             ? { charsPerToken: charsPerTokenOf(m.charsPerToken) ?? envDefaults.charsPerToken }
             : {}),
-        cost: m.cost
-            ? { input: m.cost.input, output: m.cost.output, cacheRead: m.cost.cacheRead ?? 0, cacheWrite: m.cost.cacheWrite ?? 0 }
-            : { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        ...buildModelCostKey(m.cost ? { input: m.cost.input, output: m.cost.output, cacheRead: m.cost.cacheRead ?? 0, cacheWrite: m.cost.cacheWrite ?? 0 } : undefined),
         params: { ...(m.tier ? { tier: m.tier } : {}), promptCacheFamily: m.provider === "anthropic" ? "input-excludes-cached" : "input-includes-cached" },
         ...(thinkingDefault ? { defaultThinking: thinkingDefault } : {}),
         ...(compat ? { compat } : {}),

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

@@ -45,5 +45,5 @@ export { mutateInPlace, applyEffective, type ApplyReport, applyRuntimeGates, app
 export { restartReasons, planeHasActiveTiers, modelPlaneChanged, type RestartSlice, type RestartSliceCtx, type RestartSignal, } from "./restart-signal.js";
 export { applyCenterSkills, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./skills-mcp.js";
 export { applyCenterReadFace, CENTER_READ_FACE_LIVE_KEYS, type CenterReadFaceApply, type CenterReadFaceReport, type ReadFaceBaseline } from "./read-face.js";
-export type { CenterSkillManifest, CenterMcpServer, CenterA2aPeer, CenterReadFace, EffectiveConfig, ExecutionRuling, SessionMirrorRuling, } from "./types.js";
+export type { CenterSkillManifest, CenterMcpServer, CenterA2aPeer, CenterModel, CenterReadFace, EffectiveConfig, ExecutionRuling, SessionMirrorRuling, } from "./types.js";
 //# sourceMappingURL=facade.d.ts.map

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

@@ -19,8 +19,8 @@ function enabledOnly(rows) {
     return rows.filter((r) => r.enabled !== false);
 }
 function catalogEntryFingerprint(entry) {
-    const { cost: _cost, quotaWeight: _quotaWeight, enabled: _enabled, ...route } = entry;
-    return route;
+    const { cost, quotaWeight: _quotaWeight, enabled: _enabled, ...route } = entry;
+    return { ...route, costDeclared: cost !== undefined };
 }
 function planeEntriesFingerprint(rows) {
     const enabled = enabledOnly(rows);

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

@@ -4,6 +4,7 @@ import { skillContentHash } from "@sema-agent/settings-schema";
 import { CONTENT_ORIGIN_WORDS, describeBadContentOrigin, isContentOriginWord } from "../mcp-content-origin.js";
 import { fetchSkillContent } from "./http-client.js";
 import { SHA256_HEX_RE } from "../digest-form.js";
+import { describeBadWireName, isUsableWireName } from "../wire-name-bound.js";
 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");
@@ -84,6 +85,13 @@ export function resolveMcpServers(mcp, logger) {
     for (const s of mcp.servers ?? []) {
         if (s.enabled === false)
             continue;
+        if (!isUsableWireName(s.name)) {
+            logger?.warn("sema_registry_mcp_name_unusable", {
+                server: describeBadWireName(s.name),
+                note: "server SKIPPED — an MCP server name is its identity (it becomes the tool namespace prefix) and core REFUSES an out-of-bound name at prepare, which would fail every task in this scenario. Shorten the name and republish; sibling servers are unaffected.",
+            });
+            continue;
+        }
         const allow = s.allowTools && s.allowTools.length > 0 ? { allowTools: s.allowTools } : {};
         const elicit = s.elicitation === true ? { elicitation: true } : {};
         let contentOrigin = {};
@@ -144,6 +152,13 @@ export function resolveA2aPeers(a2a, logger) {
     for (const p of a2a.peers ?? []) {
         if (p.enabled === false)
             continue;
+        if (!isUsableWireName(p.name)) {
+            logger?.warn("sema_registry_a2a_name_unusable", {
+                peer: describeBadWireName(p.name),
+                note: "peer SKIPPED — an A2A peer name is its identity (it lands as the roster's `origin.peer`) and core REFUSES an out-of-bound name at prepare, which would fail every task in this scenario. Shorten the name and republish; sibling peers are unaffected.",
+            });
+            continue;
+        }
         const headers = resolveRefs(p.headerRefs, p.name, "header", logger, "sema_registry_a2a_env_missing", "skipping this A2A peer — referenced env var is unset in this service");
         if (headers === null)
             continue;

package/dist/config-types.d.ts

@@ -56,23 +56,67 @@ export interface RetentionSweepConfig {
  */
 export declare const MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC = 300;
 /**
- * S-202 —— **首 token 看门狗的缺省上限(ms)**,全仓单一属主。
+ * S-220 —— **`resilience` 块缺省的唯一属主**(S-202 的单源从一根扩到整族)。
  *
- * 「SSE 已开但迟迟不吐第一个 delta」是唯一一条 core 的 idle 计时器够不着的挂死路(它只在首 token
- * 之后才武装),所以这条看门狗是那条路上唯一的守卫。600s 而不是原来的 120s:自托管后端在长 prefill
- * (大上下文 / 冷缓存 / 排队)下,首字合理地就是要等几分钟——120s 会把一次**正常**的慢启动判成
- * `[network]` 失败去重试,而重试再交同一份 prompt 给同一个排队中的后端,只会更慢更贵。
+ * 这是一张**表**,不是六个常量:缺省长在三条腿上(解析器腿 `config.ts` 的 `numEnv`/`boolEnv` 缺省、
+ * 目录腿 `config-catalog.ts` 的 `staticDefault`、`brain.ts` 的 `DEFAULT_RESILIENCE` —— config 对象
+ * 没带 resilience 块时的同姿态兜底),而三条腿此前**各写一份字面量**。S-202 只把 `firstTokenTimeoutMs`
+ * 一根收成单源,于是剩下五根还在「改一处漏一处 = 目录对外宣告的缺省与真跑的不是同一代」这条病里 ——
+ * 按类修的形是把**整族**收进一张表,让三条腿都只许引用它,而不是再加五个同形常量(六个常量 = 六份
+ * 要各自记得引用的纪律;一张表 = 一条)。
  *
- * ⚠️ **`0 = 关`语义不变**,提高缺省不碰它;依赖 120s 快失败的部署把
- * `MODEL_FIRST_TOKEN_TIMEOUT_MS=120000` 显式写回即可(env 恒赢)。
+ * 每行带自己的 **env 键名** —— 它是这一行的**身份**,给消费门当锚(目录行查名、三腿对账)。
+ * ⚠️ 但 `config.ts` / `config-catalog.ts` 的读点仍写**字面** env 名,不写 `RESILIENCE_DEFAULTS.x.env`:
+ * D1 双向对账门(`test/config-catalog.test.ts` ⑦)是 AST 扫 `numEnv("NAME", …)` 的字面名来数「src/ 在读
+ * 哪些键」,改成间接引用会让这六个键在那道门眼里整体消失(实测:6 个幽灵键 + 动态读棘轮 27→33)——
+ * 拿一条真在岗的对账门去换一处写法上的统一是亏的。键名的同源由那道门自己咬:src/ 字面名 ⟺ 目录行名
+ * ⟺ 本表的 `env`(S-220 那一格按 `env` 查目录行,查不到当场红),三方互钉,没有静默漂移的空间。
+ * `satisfies Readonly<Record<keyof ServiceConfigFlat["resilience"], …>>` 双向咬:块上加字段而表里没行
+ * ⇒ tsc 红(加字段的人被迫当场回答「它的出厂缺省是多少、归哪个 env」);表里多一行块上没有的键同样红。
  *
- * 🔴 **常量在此、别处只许引用**:解析器腿(`config.ts` 的 `numEnv` 缺省)、目录腿
- * (`config-catalog.ts` 的 `staticDefault`)与 `brain.ts` 的 `DEFAULT_RESILIENCE`(config 对象没带
- * resilience 块时的同姿态兜底)此前各写一份 `120000` 字面量,改一处漏一处 = 对外宣告的缺省与真跑的
- * 不是同一代。`test/config-catalog.test.ts` 的 S-202 两格咬:一格钉三腿同值,一格扫全 `src/` 判
- * 「字面量」这一类写法为红(下一份镜像出生即红)。
+ * ⚠️ 语义面**一个数字都没动**:`0 = 关`(三个看门狗)与「熔断默认关」照旧,env 恒赢。
+ * 首 token 那一行的 600_000 由来(S-202 clay 裁 A):自托管后端在长 prefill(大上下文 / 冷缓存 /
+ * 排队)下首字合理地要等几分钟,120s 会把一次**正常**的慢启动判成 `[network]` 失败去重试,而重试
+ * 再交同一份 prompt 给同一个排队中的后端只会更慢更贵;依赖旧姿态的部署显式写回
+ * `MODEL_FIRST_TOKEN_TIMEOUT_MS=120000` 即可。
+ *
+ * 🔴 **常量在此、别处只许引用**:`test/config-catalog.test.ts` 的 S-220 两格咬 —— 一格按表逐行钉
+ * 三腿同值(目录 staticDefault / 解析器实算值 / {@link buildDefaultResilience}),一格扫全 `src/`
+ * 判「字面量」这一类写法为红(下一份镜像出生即红)。
+ */
+export declare const RESILIENCE_DEFAULTS: {
+    readonly connectTimeoutMs: {
+        readonly env: "MODEL_CONNECT_TIMEOUT_MS";
+        readonly value: 30000;
+    };
+    readonly firstTokenTimeoutMs: {
+        readonly env: "MODEL_FIRST_TOKEN_TIMEOUT_MS";
+        readonly value: 600000;
+    };
+    readonly idleTimeoutMs: {
+        readonly env: "MODEL_IDLE_TIMEOUT_MS";
+        readonly value: 300000;
+    };
+    readonly circuitBreaker: {
+        readonly env: "MODEL_CIRCUIT_BREAKER";
+        readonly value: false;
+    };
+    readonly failureThreshold: {
+        readonly env: "MODEL_CB_FAILURE_THRESHOLD";
+        readonly value: 5;
+    };
+    readonly cooldownMs: {
+        readonly env: "MODEL_CB_COOLDOWN_MS";
+        readonly value: 30000;
+    };
+};
+/**
+ * S-220 —— 「config 对象没带 resilience 块」时的整块兜底,**逐字段派生自 {@link RESILIENCE_DEFAULTS}**。
+ *
+ * 返回类型把键集钉死(缺键 / 多键都是 tsc 红),所以这里剩下的唯一手写物是键名本身,值一个字面量都没有。
+ * 每次调用铸一只新对象(共享一只导出常量会被消费方就地改掉,那是另一条病)。
  */
-export declare const MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT = 600000;
+export declare function buildDefaultResilience(): ServiceConfigFlat["resilience"];
 /**
  * [ref] D1/D2 —— consolidation driver 阀门的三根旋钮(语义与三问见
  * {@link ServiceConfigFlat.memoryConsolidationDriver})。纯数据。
@@ -1375,12 +1419,15 @@ export interface ServiceConfigFlat {
      *  settings ⇒ 整块跳过;bypassPermissions 臂不回 shellGate;非 host lane wiring 不建 ⇒ 沙箱 lane 全失效)。
      *  rank 合成:与 autonomy 派生值取大(`ask`→`"always"` 压过 `"classify"`),对 base 只升不降。
      *  客户端 settings 折叠在其后、tighten-only,拿不掉这个值;SUP 路由姿态只会把它抬到 `"always"`。
-     *  🔴 **语义随 core 版本演进(2026-07-31 核)**:`"classify"` 下「纯读自动放行」这句自 core 2.7.0 起
-     *  **不再无条件成立** —— [ref] 给 classifier 加了 root 边界扫描,core 内部自铸 boundary
+     *  🔴 **语义随 core 版本演进(2026-07-31 核;core 7.15.0 再核)**:`"classify"` 下「纯读自动放行」这句
+     *  自 core 2.7.0 起**不再无条件成立** —— [ref] 给 classifier 加了 root 边界扫描,core 内部自铸 boundary
      *  (`prepare-task.ts` 的 `shellReadBoundary`:roots=任务 root+additionalRoots+additionalReadRoots,
-     *  cwd=活 handsCwd),
-     *  **读到 roots 之外的路径同样会 ask**(server 侧零接线即得:我们只传 shellGate,边界是 core 自算的)。
-     *  旧 core(<2.7.0)下仍是名字级判定=越界读放行,两者都能工作、后者更严 ⇒ floor 不因此抬。
+     *  cwd=活 handsCwd),**读到 roots 之外的路径同样会 ask**(server 侧零接线即得:我们只传 shellGate,
+     *  边界是 core 自算的)。
+     *  🔴 **而自 core 7.15.0([ref])起,那道读边界不再是本旋钮买来的** —— 它**每一档都判**(`off` 含在内),
+     *  本旋钮买的只剩**剩余**风险那一半:`"classify"` = 可证只读且在界内的命令自动放行、其余发问;
+     *  `"always"` = 每条命令都发问。⇒ 别再把「越界读会问」写成开这根旋钮的理由(它在不开的部署上同样成立);
+     *  这根旋钮仍然是 tighten-only、仍然无条件施加,语义一字未改。
      *  Absent/unset = `undefined` = **zero behavior change** (this is a tighten-ONLY opt-in, never a
      *  default — a deployment must explicitly choose it); `"always"` = CC-strict parity (every Bash asks). Any
      *  other value (incl. `"off"`) is treated as unset — this knob has no "off" value to opt BACK OUT with once a
@@ -1408,8 +1455,13 @@ export interface ServiceConfigFlat {
      *  ToolSearch-loads the schema). Assessment says the win is marginal for us (spec.tools total ≈4.2k tokens, of
      *  which Agent + the Task quartet ≈3.2k are CC-core posture = must stay inline; the deferrable tail is
      *  ≈200-500 tokens/turn) and SendUserFile is deliberately NOT in the defer set (proactive-delivery tool —
-     *  hiding it behind ToolSearch suppresses exactly the spontaneous use it exists for). MCP tools are ALWAYS
-     *  auto-deferred by core regardless of this flag. `TOOL_DEFER_LONGTAIL=true` opts in. */
+     *  hiding it behind ToolSearch suppresses exactly the spontaneous use it exists for). `TOOL_DEFER_LONGTAIL=true`
+     *  opts in.
+     *  🔴 **core 7.15.0([ref])起 `defer:true` 只是「进候选集」的声明,不是「一定占位」的保证**:候选集
+     *  (caller spec 的 `defer:true` + 远端协议铸名 + 内置自声明 defer)整体受**一道**阈值门,全或无 ——
+     *  内联字节 ≥ 上下文窗的 **10%** 才延迟,否则全内联且不挂 `ToolSearch`。同一条收窄也让「MCP 工具恒被
+     *  core 自动延迟」这句(本行旧文案)作废:缺省窗下一个中小 MCP 名册够不着阈值,首请求带全 schema。
+     *  唯一不受门的是调用方的 `TaskSpec.deferTools` 字面名单。口径全文见 src/capabilities/tool-defer.ts 头注。 */
     toolDeferLongtail: boolean;
     /** LSP code-intelligence tool ([ref] §13.1): mount core's `lsp` tool, routed to an E2B LSP sidecar. Requires
      *  REMOTE_EXEC=e2b. Default OFF (the on-the-fly language-server install is heavy until an E2B template bakes it).
@@ -1625,9 +1677,17 @@ export interface ServiceConfigFlat {
         pattern: string;
         caseSensitive: boolean;
     }[];
-    /** [ref] 件 G5(core 5.33.0 [ref],clay 裁定件):**内建** deny 表的档位选择(闭集四档:credentials /
-     *  shell-history / browser / wallet)。`READ_DENY_BUILTIN_TIERS`=逗号分隔;`none`=显式空姿态(core 的
-     *  `[]`:一档内建都不要);坏档名 / 空串**启动期响亮拒**(校验用 core 自己的 `resolveReadDenyBuiltins`)。
+    /** [ref] 件 G5(core 5.33.0 [ref],clay 裁定件):**内建** deny 表的档位选择(闭集**五档**:credentials /
+     *  shell-history / browser / wallet / **agent-config**)。`READ_DENY_BUILTIN_TIERS`=逗号分隔;`none`=显式
+     *  空姿态(core 的 `[]`:一档内建都不要);坏档名 / 空串**启动期响亮拒**(校验用 core 自己的
+     *  `resolveReadDenyBuiltins` —— 词表**单一属主在 core**,本仓零镜像:加档这天校验自动认,这段散文是
+     *  唯一要跟手的东西)。
+     *  🔴 **`agent-config`(core 7.14.0 [ref] C-e 新加的第五档)**:agent **自己的配置文件** —— 它们的 `env` /
+     *  server 段里明文放着 API key(壳的 `settings.json` env 块、项目 `.mcp.json` 的 server env、引擎宿主
+     *  data-root 下的 `.env`)。此前对这类文件的一次结构化读会把密钥**逐字**落进工具结果、从而落进会话记录。
+     *  行名的是**文件**不是配置**目录**(`.sema`/`.claude` 底下还住着 agents/skills/hooks 与记忆库 —— 模型
+     *  当作日常材料读写的东西);同族工具的 token **存储**(`.credentials.json`/`.codex/auth.json` …)归
+     *  `credentials` 档,不归本档 ⇒ 为排查 agent 配置而关掉本档的部署,凭证行照样拦着。
      *  缺席=不铸 ⇒ core 自默认(除 shell-history 外全开)。**仅 deployment 席**:TaskSpec 上没有同名键,
      *  任务/受治脚本无法据此放宽自己的部署(core 侧的设计,与本仓「部署级旋钮无条件施加」同向)。 */
     readDenyBuiltinTiers?: readonly string[];

package/dist/config-types.js

@@ -1,4 +1,22 @@
 export const RETENTION_MODES = ["audit-only", "enforce"];
 export const MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC = 300;
-export const MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT = 600_000;
+export const RESILIENCE_DEFAULTS = {
+    connectTimeoutMs: { env: "MODEL_CONNECT_TIMEOUT_MS", value: 30_000 },
+    firstTokenTimeoutMs: { env: "MODEL_FIRST_TOKEN_TIMEOUT_MS", value: 600_000 },
+    idleTimeoutMs: { env: "MODEL_IDLE_TIMEOUT_MS", value: 300_000 },
+    circuitBreaker: { env: "MODEL_CIRCUIT_BREAKER", value: false },
+    failureThreshold: { env: "MODEL_CB_FAILURE_THRESHOLD", value: 5 },
+    cooldownMs: { env: "MODEL_CB_COOLDOWN_MS", value: 30_000 },
+};
+export function buildDefaultResilience() {
+    const d = RESILIENCE_DEFAULTS;
+    return {
+        connectTimeoutMs: d.connectTimeoutMs.value,
+        firstTokenTimeoutMs: d.firstTokenTimeoutMs.value,
+        idleTimeoutMs: d.idleTimeoutMs.value,
+        circuitBreaker: d.circuitBreaker.value,
+        failureThreshold: d.failureThreshold.value,
+        cooldownMs: d.cooldownMs.value,
+    };
+}
 //# sourceMappingURL=config-types.js.map

package/dist/config.d.ts

@@ -99,6 +99,64 @@ export declare function logConfigDiagnostics(logger: {
     info?: (event: string, fields?: Record<string, unknown>) => void;
     debug?: (event: string, fields?: Record<string, unknown>) => void;
 }): void;
+/** B-089:`Model.cost` 的四项(per-1M USD)。类型从 core 的 `Model` 取,不在本仓重列一份。 */
+type ModelCost = NonNullable<Model["cost"]>;
+/**
+ * 🔴 B-089 —— `Model.cost` 这**一个键**的唯一铸点(可展开片段):有价目表 ⇒ 键在;没配 ⇒ **键不出**。
+ * 三个铸点(env 主槽 / env cheap 槽 / config-center 车道)共用它,所以「缺席怎么表达」在本仓只有一处答案。
+ *
+ * `Model.cost` 自 core 7.16.0([ref])起在**类型面**上也是可选的(`dist/engine/llm/types.d.ts` 的
+ * `cost?:`),与它一直以来的运行期读法([ref] 的 `isModelPriced`:这个键在不在)对齐 ——
+ * 于是本函数不再需要任何类型让步,返回 `{}` 就是「不写这个键」的字面表达。
+ *
+ * ⚠️ 连带纪律仍在:**读** `Model.cost` 一律先判在场(catalog 行的 `c.model.cost?.input`),
+ * 别写 `model.cost.input`;而「这只模型定价了吗」这一问不许在本仓重写一遍,调 `isModelPriced`。
+ */
+export declare function buildModelCostKey(cost: ModelCost | undefined): Pick<Model, "cost">;
+/**
+ * 🔴 B-089 —— 「配了 $ 成本天花板,但目录里一只带价模型都没有」的判据 + 文案(纯函数,零副作用)。
+ *
+ * 两道天花板(`MAX_TASK_COST_USD` / `MAX_PRINCIPAL_COST_USD`)量的是 `costUsd`,而一只**未定价**的模型
+ * 算不出成本([ref] 之后它连 `costMicroUsd` 这个键都不发)—— 于是这两根旋钮在这台机器上**永不可能
+ * 触发**:运营方以为配了 $ 护栏,实际一道都没有,且没有任何一处会响。不拒启([ref] 只要求 loud ——
+ * 这是一台**本来就在服务**的机器的既有形,而且「先配上限、稍后配单价」是正当的上线顺序)。
+ *
+ * ⚠️ 位置即判据(codex r1 [medium] 真复现):**必须拿生效后的目录与限额来判,不能在 `loadConfig` 里判**。
+ * `loadConfig` 只见 env 车道,而 `main.ts` 在第一次 effective 拉取**之前**就把 boot 诊断排空了 ——
+ * 在那里判会同时犯两个方向的错:center 名册已配价、env 未配 ⇒ **假警**;env 已配价、center 名册撤了价
+ * (或天花板只由 center 的 limits 下发)⇒ **漏警**。故本函数只给判据,席位在两只入口各自的
+ * **采纳之后**(`main.ts` 的 `createConfigCenterRuntime` 之后 / `run-local.ts` 的 `applyEffective` 之后)。
+ *
+ * 判据 = **目录里没有任何一只带价模型**,问法与 `budget.buildPricing` 的填表判据是**同一只函数**
+ * (S-231:core 7.16.0 导出的 `isModelPriced`;第二参传 `undefined` = 这一问发生在注入表建起来之前,
+ * 谓词落在「模型自报价了吗」那一半)。本模块刻意不 import `budget.ts`(那边挂着 metrics/fleet 一串
+ * 运行期依赖,config 是纯解析层)—— 单源因此不是「谁 import 谁」,而是两边都问引擎那一只。
+ */
+/** 「$ 天花板 × 价目表」的三位事实 —— 告警判据与清警原因的**同一只**读数(S-232 合并复审:清警要说得出为什么清)。 */
+export interface CostCeilingPricingPosture {
+    /** 配了的天花板旋钮名(空 = 一根都没配)。 */
+    ceilings: string[];
+    /** 生效目录里的模型 id(空 = 目录还空着)。 */
+    modelIds: string[];
+    /** 目录里至少一只模型自报了价(`isModelPriced(m, undefined)`,S-231 单源)。 */
+    anyPriced: boolean;
+}
+export declare function costCeilingPricingPosture(models: Record<string, Model>, limits: {
+    maxTaskCostUsd: number;
+    maxPrincipalCostUsd: number;
+}): CostCeilingPricingPosture;
+/** 「天花板告警此刻**不**成立」的原因(闭集三词);`undefined` = 告警成立。序 = 先判护栏在不在(`no_ceiling`),
+ *  再判有没有东西可计价(`empty_catalog`),最后才是「真配回了价」(`priced`)—— 只有最后一词可以说
+ *  「护栏能再触发」,前两词下这句话是假的。 */
+export type UnpricedCeilingClearReason = "no_ceiling" | "empty_catalog" | "priced";
+export declare function unpricedCeilingClearReasonOf(p: CostCeilingPricingPosture): UnpricedCeilingClearReason | undefined;
+export declare function buildUnpricedCeilingNotice(models: Record<string, Model>, limits: {
+    maxTaskCostUsd: number;
+    maxPrincipalCostUsd: number;
+}): {
+    event: string;
+    fields: Record<string, string>;
+} | undefined;
 /** [ref] N8/N9 — the BOOLEAN member of this module's env-parser family (`env`/`env2`/`numEnv`/
  *  `numEnvBounded`/`optFinitePositiveEnv`/`enumEnv`/`headerNameEnv`/`firstSetEnv`). Until now booleans were the
  *  one type parsed by a hand-written literal comparison at every single site, and that is exactly why the same

package/dist/config.js

@@ -2,14 +2,14 @@ import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { BUILTIN_COMPLIANCE_DENIES, COMPLIANCE_CAPABILITIES, CROSS_SESSION_INBOUND_SETTINGS, CROSS_SESSION_DIALOG_EXPIRY_VALUES, compileReadDeny, resolveReadDenyBuiltins, CODE_AGENT_PROMPT, formatUserScope, PROTOCOL_TABLE, protocolOf, RECOMMENDED_SENSITIVE_PATTERNS, RETIRED_TOOL_NAMES, resolveFileHistoryRetention, resolveLockedKeys, validatePermissionRules, WRITE_PROTECTED_DEFAULT_TABLE, resolveWriteProtectedTable, parseRuleText } from "@sema-agent/core";
+import { BUILTIN_COMPLIANCE_DENIES, COMPLIANCE_CAPABILITIES, CROSS_SESSION_INBOUND_SETTINGS, CROSS_SESSION_DIALOG_EXPIRY_VALUES, compileReadDeny, resolveReadDenyBuiltins, CODE_AGENT_PROMPT, formatUserScope, isModelPriced, PROTOCOL_TABLE, protocolOf, RECOMMENDED_SENSITIVE_PATTERNS, RETIRED_TOOL_NAMES, resolveFileHistoryRetention, resolveLockedKeys, validatePermissionRules, WRITE_PROTECTED_DEFAULT_TABLE, resolveWriteProtectedTable, parseRuleText } from "@sema-agent/core";
 import { ROSTER_PRIMARY_ROLES, ROSTER_CHEAP_ROLES } from "@sema-agent/settings-schema";
 import { parseApprovalHmacKeys, parsePrincipalJwks } from "./auth-keys.js";
 import { DEFAULT_ELICITATION_THROTTLE } from "./elicitation.js";
 import { isV2ScopeKey } from "./memory-scope.js";
 import { DEFAULT_QUESTION_THROTTLE } from "./question.js";
 import { GIT_API_KINDS, isGitApiKind } from "./git-api-kind.js";
-import { RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC, MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT } from "./config-types.js";
+import { RETENTION_MODES, MEMORY_CONSOLIDATION_MIN_INTERVAL_SEC, RESILIENCE_DEFAULTS } from "./config-types.js";
 import { buildWriteProtectionPosture } from "./write-protection.js";
 import { normalizeSshFingerprint } from "./ssh-host-key.js";
 import { readFaceForPosture } from "./read-face-posture.js";
@@ -260,16 +260,70 @@ function numEnvOr(name, fallback) {
         return fallback;
     return parseNumOrFail(name, raw);
 }
-function cheapCostEnv(name, mainPrice) {
+function costEnv(name, emptyString) {
     const raw = process.env[name];
     if (raw === undefined)
-        return mainPrice;
+        return undefined;
     if (raw === "") {
+        if (emptyString === "unset")
+            return undefined;
         CONFIG_WARNINGS.push({ env: name, raw: "", used: "0", kind: "empty-preserved" });
         return 0;
     }
     return parseNumOrFail(name, raw);
 }
+function buildCostOrAbsent(read, inherited) {
+    const declared = read.input !== undefined || read.output !== undefined || read.cacheRead !== undefined || read.cacheWrite !== undefined;
+    if (!declared && inherited === undefined)
+        return undefined;
+    return {
+        input: read.input ?? inherited?.input ?? 0,
+        output: read.output ?? inherited?.output ?? 0,
+        cacheRead: read.cacheRead ?? inherited?.cacheRead ?? 0,
+        cacheWrite: read.cacheWrite ?? inherited?.cacheWrite ?? 0,
+    };
+}
+export function buildModelCostKey(cost) {
+    return cost === undefined ? {} : { cost };
+}
+export function costCeilingPricingPosture(models, limits) {
+    const entries = Object.values(models);
+    return {
+        ceilings: [
+            ...(limits.maxTaskCostUsd > 0 ? ["MAX_TASK_COST_USD"] : []),
+            ...(limits.maxPrincipalCostUsd > 0 ? ["MAX_PRINCIPAL_COST_USD"] : []),
+        ],
+        modelIds: [...new Set(entries.map((m) => m.id))],
+        anyPriced: entries.some((m) => isModelPriced(m, undefined)),
+    };
+}
+export function unpricedCeilingClearReasonOf(p) {
+    if (p.ceilings.length === 0)
+        return "no_ceiling";
+    if (p.modelIds.length === 0)
+        return "empty_catalog";
+    if (p.anyPriced)
+        return "priced";
+    return undefined;
+}
+export function buildUnpricedCeilingNotice(models, limits) {
+    const posture = costCeilingPricingPosture(models, limits);
+    if (unpricedCeilingClearReasonOf(posture) !== undefined)
+        return undefined;
+    const { ceilings, modelIds } = posture;
+    return {
+        event: "cost_ceiling_without_pricing",
+        fields: {
+            ceilings: ceilings.join(","),
+            models: modelIds.join(","),
+            note: `${ceilings.join(" / ")} is configured but NO model in the effective catalog declares a price table — an ` +
+                "unpriced model reports NO cost at all (core RB-368), so these $ ceilings can never fire and this deployment " +
+                "has no cost guardrail despite looking like it does. Set MODEL_COST_INPUT / MODEL_COST_OUTPUT / " +
+                "MODEL_COST_CACHE_READ / MODEL_COST_CACHE_WRITE (env lane), or a per-model `cost` on the center roster row. " +
+                "The token ceiling (MAX_TASK_TOKENS) is unaffected and still fires.",
+        },
+    };
+}
 function optNumEnvStrict(name) {
     const raw = process.env[name];
     if (!raw)
@@ -753,12 +807,12 @@ function parseModelDomain() {
         baseUrl: "",
         reasoning: boolEnv("MODEL_REASONING", true),
         input: boolEnv("MODEL_VISION", true) ? ["text", "image"] : ["text"],
-        cost: {
-            input: numEnv("MODEL_COST_INPUT", "0"),
-            output: numEnv("MODEL_COST_OUTPUT", "0"),
-            cacheRead: numEnv("MODEL_COST_CACHE_READ", "0"),
-            cacheWrite: numEnv("MODEL_COST_CACHE_WRITE", "0"),
-        },
+        ...buildModelCostKey(buildCostOrAbsent({
+            input: costEnv("MODEL_COST_INPUT", "unset"),
+            output: costEnv("MODEL_COST_OUTPUT", "unset"),
+            cacheRead: costEnv("MODEL_COST_CACHE_READ", "unset"),
+            cacheWrite: costEnv("MODEL_COST_CACHE_WRITE", "unset"),
+        }, undefined)),
         contextWindow: numEnv("MODEL_CONTEXT_WINDOW", "262144"),
         maxTokens: process.env.MODEL_MAX_TOKENS !== undefined && process.env.MODEL_MAX_TOKENS !== ""
             ? parseNumOrFail("MODEL_MAX_TOKENS", process.env.MODEL_MAX_TOKENS)
@@ -776,12 +830,12 @@ function parseModelDomain() {
             id: cheapId,
             name: cheapId,
             input: ((v) => (v === undefined ? model.input : v ? ["text", "image"] : ["text"]))(parseBoolWord("MODEL_CHEAP_VISION", process.env.MODEL_CHEAP_VISION)),
-            cost: {
-                input: cheapCostEnv("MODEL_CHEAP_COST_INPUT", model.cost.input),
-                output: cheapCostEnv("MODEL_CHEAP_COST_OUTPUT", model.cost.output),
-                cacheRead: cheapCostEnv("MODEL_CHEAP_COST_CACHE_READ", model.cost.cacheRead),
-                cacheWrite: cheapCostEnv("MODEL_CHEAP_COST_CACHE_WRITE", model.cost.cacheWrite),
-            },
+            ...buildModelCostKey(buildCostOrAbsent({
+                input: costEnv("MODEL_CHEAP_COST_INPUT", "declares-zero"),
+                output: costEnv("MODEL_CHEAP_COST_OUTPUT", "declares-zero"),
+                cacheRead: costEnv("MODEL_CHEAP_COST_CACHE_READ", "declares-zero"),
+                cacheWrite: costEnv("MODEL_CHEAP_COST_CACHE_WRITE", "declares-zero"),
+            }, model.cost)),
             contextWindow: numEnvOr("MODEL_CHEAP_CONTEXT_WINDOW", model.contextWindow),
             maxTokens: numEnvOr("MODEL_CHEAP_MAX_TOKENS", model.maxTokens),
             ...(optFinitePositiveEnv("MODEL_CHEAP_CHARS_PER_TOKEN") !== undefined ? { charsPerToken: optFinitePositiveEnv("MODEL_CHEAP_CHARS_PER_TOKEN") } : {}),
@@ -855,12 +909,12 @@ function parseModelDomain() {
             }
             : undefined,
         resilience: {
-            connectTimeoutMs: numEnv("MODEL_CONNECT_TIMEOUT_MS", "30000"),
-            firstTokenTimeoutMs: numEnv("MODEL_FIRST_TOKEN_TIMEOUT_MS", String(MODEL_FIRST_TOKEN_TIMEOUT_MS_DEFAULT)),
-            idleTimeoutMs: numEnv("MODEL_IDLE_TIMEOUT_MS", "300000"),
-            circuitBreaker: boolEnv("MODEL_CIRCUIT_BREAKER", false),
-            failureThreshold: numEnv("MODEL_CB_FAILURE_THRESHOLD", "5"),
-            cooldownMs: numEnv("MODEL_CB_COOLDOWN_MS", "30000"),
+            connectTimeoutMs: numEnv("MODEL_CONNECT_TIMEOUT_MS", String(RESILIENCE_DEFAULTS.connectTimeoutMs.value)),
+            firstTokenTimeoutMs: numEnv("MODEL_FIRST_TOKEN_TIMEOUT_MS", String(RESILIENCE_DEFAULTS.firstTokenTimeoutMs.value)),
+            idleTimeoutMs: numEnv("MODEL_IDLE_TIMEOUT_MS", String(RESILIENCE_DEFAULTS.idleTimeoutMs.value)),
+            circuitBreaker: boolEnv("MODEL_CIRCUIT_BREAKER", RESILIENCE_DEFAULTS.circuitBreaker.value),
+            failureThreshold: numEnv("MODEL_CB_FAILURE_THRESHOLD", String(RESILIENCE_DEFAULTS.failureThreshold.value)),
+            cooldownMs: numEnv("MODEL_CB_COOLDOWN_MS", String(RESILIENCE_DEFAULTS.cooldownMs.value)),
         },
         model,
         envModel: model,

package/dist/http/active-run-conflict.d.ts

@@ -14,6 +14,7 @@
  *    test/session-active-conflict-materials.test.ts 的分门用例会红。认不出的 kind ⇒ null(诚实缺席,不铸假门)。
  */
 import { type Autonomy } from "../runtime-governance.js";
+import type { ShellGateDoctrine } from "@sema-agent/core";
 import { type RunRecord } from "../plugins/store-contracts.js";
 import { type PendingRowBinding } from "../plugins/checkpoint-store-sql.js";
 /** [ref] 归因的部署侧入参(两个治理旋钮;判据属主见 `governanceMandatesShellGateAlways`)。 */
@@ -124,7 +125,7 @@ export declare function resumeEntryForGate(kind: string, ids: {
 }): string | null;
 export declare function governanceOriginOf(gate: {
     riskDescriptor?: {
-        shellGateDoctrine?: "classify" | "always";
+        shellGateDoctrine?: ShellGateDoctrine;
     };
 } | undefined, governance: GovernancePosture | undefined): true | undefined;
 /** token 泛型:真身是 branded CheckpointToken(秘密能力,只在本函数内部流转,绝不进响应体)。 */
@@ -183,7 +184,7 @@ interface ConflictProbeDeps<TToken> {
             gate?: {
                 kind?: string;
                 riskDescriptor?: {
-                    shellGateDoctrine?: "classify" | "always";
+                    shellGateDoctrine?: ShellGateDoctrine;
                 };
             };
         } | null | undefined>;