@sema-agent/server 7.146.0 → 7.147.0

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

@@ -1,9 +1,9 @@
 import { expandTiers, modelOriginOf, resolveTaskModel as coreResolveTaskModel } from "@sema-agent/core";
-import { CATALOG_REPLACES_ENV_MODELS_CODE, SandboxGitConfig, WEB_ADMIN_ENV, envModelsDecisionTag, formatConfigPath, narrowAtMention, resolveActiveTiers, resolveCatalogDefaultModel, sanitizeZodError } from "@sema-agent/settings-schema";
+import { CATALOG_REPLACES_ENV_MODELS_CODE, SandboxGitConfig, WEB_ADMIN_ENV, envModelsDecisionTag, formatConfigPath, narrowAtMention, parseDomainSalvaged, resolveActiveTiers, resolveCatalogDefaultModel, sanitizeZodError } from "@sema-agent/settings-schema";
 import { modelKeyPoison } from "../key-resolver.js";
 import { DEFAULT_MODEL_REF, buildEnvModelIdNotServedNotice, mintCapabilityKeys, readAtMention, servedModelTableLeg } from "../model-select.js";
 import { applyAutoCompactWindow, buildModelCostKey, isRosterGateArmed, ownCredentialHitsInForce, parseAutonomy, unmatchableToolNamesRefusal } from "../config.js";
-import { NAME_TABLE_BEHAVIOR } from "../namespaced-rule-name.js";
+import { NAME_TABLE_BEHAVIOR, retiredWithoutSuccessorEntries } from "../namespaced-rule-name.js";
 import { buildModelCompat, readModelCompat } from "../model-compat.js";
 import { buildModelHeadersKey } from "../model-entry-headers.js";
 import { validateCommandRules } from "../runtime-governance.js";
@@ -29,13 +29,11 @@ function envDerivedModel(config) {
 }
 function toModel(m, envDefaults = {}, logger) {
     const thinkingDefault = envDefaults.defaultThinking;
-    const declared = readModelCompat(m.compat);
+    const declared = readModelCompat(m.api, m.compat);
     if (!declared.ok)
         logger?.warn("model_compat_dropped", { model: m.name, issue: declared.issue, hint: "the per-model wire-compat declaration was dropped whole — the engine falls back to its own inference (today's behaviour); fix the entry to make it live" });
-    else if (declared.compat !== undefined && m.provider === "anthropic") {
-        logger?.warn("model_compat_dropped", { model: m.name, issue: "declared on an anthropic model", hint: "`compat` mirrors OpenAICompletionsCompat — the Anthropic brain reads AnthropicMessagesCompat and never sees these keys; the declaration is dropped" });
-    }
-    const compat = m.provider === "anthropic" ? undefined : buildModelCompat(declared.ok ? declared.compat : undefined, envDefaults.compat);
+    const envCompat = envDefaults.api === m.api ? envDefaults.compat : undefined;
+    const compat = buildModelCompat(m.api, declared.ok ? declared.compat : undefined, envCompat);
     const model = {
         id: m.id,
         name: m.name,
@@ -52,6 +50,7 @@ function toModel(m, envDefaults = {}, logger) {
         params: { ...(m.tier ? { tier: m.tier } : {}), promptCacheFamily: m.provider === "anthropic" ? "input-excludes-cached" : "input-includes-cached" },
         ...(thinkingDefault ? { defaultThinking: thinkingDefault } : {}),
         ...(compat ? { compat } : {}),
+        ...(m.thinkingLevelMap !== undefined ? { thinkingLevelMap: m.thinkingLevelMap } : {}),
         ...(m.extraBody ? { extraBody: m.extraBody } : {}),
         ...buildModelHeadersKey(m.name, m.headers, m.api),
     };
@@ -399,7 +398,7 @@ function stageModelPlane(config, eff, source, logger, sealedKeys) {
         const modelApiKeyEnv = {};
         const modelApiKeys = {};
         const envModel = envDerivedModel(config);
-        const envDefaults = { maxTokens: envModel.maxTokens, contextWindow: envModel.contextWindow, charsPerToken: envModel.charsPerToken, defaultThinking: envModel.defaultThinking, compat: envModel.compat };
+        const envDefaults = { maxTokens: envModel.maxTokens, contextWindow: envModel.contextWindow, charsPerToken: envModel.charsPerToken, defaultThinking: envModel.defaultThinking, api: envModel.api, compat: envModel.compat };
         for (const m of usable) {
             if (m.baseUrl)
                 logger?.warn("web_admin_model_base_url", { model: m.name, baseUrl: buildDisplaySafeUrl(m.baseUrl), hint: "registry-directed gateway override — this model's key authenticates AGAINST THIS URL" });
@@ -543,22 +542,10 @@ function stageEffective(config, eff, logger, opts) {
     const approvalGate = stageApprovalGate(config, eff.governance, opts, logger);
     const limits = stageLimits(config, { version: typeof eff.version === "number" ? eff.version : 0, ...("limits" in eff ? { limits: eff.limits } : {}) }, logger);
     const hot = stageRuntimeHot(config, eff.governance, logger);
-    const projDomain = eff.projects;
-    const rawProjects = (projDomain && typeof projDomain === "object" && !Array.isArray(projDomain) &&
-        "projects" in projDomain && typeof projDomain.projects === "object"
-        ? (projDomain.projects ?? {})
-        : {}) ?? {};
-    const projects = {};
-    for (const [pid, reg] of Object.entries(rawProjects)) {
-        if (!reg || typeof reg !== "object" || Array.isArray(reg))
-            continue;
-        const r = reg;
-        projects[pid] = {
-            ...(typeof r.displayName === "string" ? { displayName: r.displayName } : {}),
-            ...(Array.isArray(r.gitRemotes) ? { gitRemotes: r.gitRemotes.filter((x) => typeof x === "string") } : {}),
-            ...(Array.isArray(r.defaultScopes) ? { defaultScopes: r.defaultScopes.filter((x) => typeof x === "string") } : {}),
-        };
-    }
+    const projectWarnings = [];
+    const projects = eff.projects === undefined ? {} : { ...parseDomainSalvaged("projects", eff.projects, (w) => projectWarnings.push(w)).projects };
+    for (const w of projectWarnings)
+        logger?.warn("web_admin_projects_read_warning", { kind: w.kind, ...(w.kind === "entry-dropped" ? { entry: formatConfigPath(w.path), ...(w.reasonCode !== undefined ? { reasonCode: w.reasonCode } : {}) } : {}) });
     const sandboxGit = stageSandboxGit(eff, logger);
     return {
         version: typeof eff.version === "number" && Number.isFinite(eff.version) ? eff.version : 0,
@@ -635,7 +622,7 @@ function stageApprovalRequire(raw) {
         return { ok: false, detail, reason: detail, names: nonString.map((e) => `[${e.i}]`), kept: KEPT_WOULD_REMOVE_GATE };
     }
     const names = raw.filter((n) => typeof n === "string").map((n) => n.trim()).filter((n) => n.length > 0);
-    const unmatchable = unmatchableToolNamesRefusal("published governance.approvalRequire", names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR });
+    const unmatchable = unmatchableToolNamesRefusal("published governance.approvalRequire", names, { consumer: "tool-name-table", behavior: NAME_TABLE_BEHAVIOR, noticeSeat: "server" });
     if (unmatchable !== undefined) {
         return {
             ok: false,
@@ -645,7 +632,7 @@ function stageApprovalRequire(raw) {
             kept: KEPT_WOULD_MATCH_NOTHING,
         };
     }
-    return { ok: true, value: names };
+    return { ok: true, value: names, skipped: retiredWithoutSuccessorEntries(names, NAME_TABLE_BEHAVIOR) };
 }
 function unserviceableOnLeg(leg, candidate) {
     switch (leg.leg) {
@@ -672,6 +659,7 @@ function stageApprovalGate(config, gov, leg, logger) {
     };
     const raw = gov?.approvalRequire;
     let next;
+    let skipped = [];
     if (raw === undefined) {
         next = [...approvalEnvBaseline.get(config)];
     }
@@ -680,10 +668,18 @@ function stageApprovalGate(config, gov, leg, logger) {
         if (!verdict.ok)
             return refuse(verdict);
         next = verdict.value;
+        skipped = verdict.skipped;
     }
     const unserviceable = unserviceableOnLeg(leg, { ...config, approvalRequire: next });
     if (unserviceable !== undefined)
         return refuse({ detail: unserviceable, reason: unserviceable, names: next, kept: KEPT_WOULD_NEVER_PARK });
+    if (skipped.length > 0) {
+        logger?.warn("web_admin_approval_require_legacy_tool_name", {
+            names: skipped.map((s) => s.entry),
+            guidance: skipped.map((s) => s.guidance),
+            note: "published governance.approvalRequire names tools the engine retired with no successor — they reach no tool this server knows, so those entries guard nothing (kept as written: a tool of that exact name mounted by an embedder is still matched); the list is applied; remove them from the published list if written for the retired tool",
+        });
+    }
     const same = next.length === config.approvalRequire.length && next.every((n, i) => n === config.approvalRequire[i]);
     return same ? {} : { next };
 }

package/dist/web-admin-client/candidate-gate.d.ts

@@ -39,9 +39,21 @@ export interface CandidateDomainError {
 /** 判官拒一份候选的成因(闭集):某个域判形失败(含 prompts 面)`domain_invalid` ∪ 被拒文档自带的词(契约闭集 `CONFIG_DOCUMENT_REFUSAL_REASONS`:
  *  `empty` / `invalid_json` / `not_object` / `io` / `too_deep` 文件层,`retired_domain` 墓碑)—— 被拒文档的词表只在契约一处定义,这里派生(契约加词 ⇒ 按词穷举的读者编译红)。 */
 export type CandidateRejectReason = "domain_invalid" | ConfigDocumentRefusalReason;
-/** 拒判里的一条:哪一域、为什么(读腿 / 契约包的原句)、成因词。`config_candidate_rejected` 行的 `errors` 就是这一列。 */
+/**
+ * 拒因的**类词**(闭集,机读,不含任何自由文本):这一条拒是哪一类事 —— 拒启句(`defaultModelRefusal` 的回落原因)只许据它说「为什么」,**不许**抄 `error` 原文(见 {@link CandidateDomainRejection.kind})。
+ * 成因词 {@link CandidateRejectReason} 已是闭集,但 `io` 一个词盖了三件事(悬空符号链接 / 权限 / I/O 故障),类词把悬空链接拆出来:
+ * `schema_invalid`(域判形失败 / 引用悬空 / prompts 坏形)· `empty` · `parse_error`(JSON 解析不过)· `not_object` · `too_deep` · `retired_domain`(退役域墓碑)· `dangling_symlink` · `unreadable`(在场却读不出的其余形)。
+ */
+export declare const CANDIDATE_REJECTION_KINDS: readonly ["schema_invalid", "empty", "parse_error", "not_object", "too_deep", "retired_domain", "dangling_symlink", "unreadable"];
+export type CandidateRejectionKind = (typeof CANDIDATE_REJECTION_KINDS)[number];
+/**
+ * 拒判里的一条:哪一域、为什么(读腿 / 契约包的原句)、成因词、类词。`config_candidate_rejected` 行的 `errors` 就是这一列。
+ * `error` 是读腿 / 契约的原句(可能点名链接指向的目标路径等操作数),**只走 warn 行**;`kind` 是机读的类词(只在 {@link judgeConfigCandidate} 铸一次),
+ * 拒启句读 `kind` 不读 `error`。
+ */
 export interface CandidateDomainRejection extends CandidateDomainError {
     readonly reason: CandidateRejectReason;
+    readonly kind: CandidateRejectionKind;
 }
 /** 判官的输入:一份读出来的候选。`refusedDocuments` = 读腿交出的被拒文档(两条读腿同形,契约的类型 `ConfigDocumentRefusal`;判官只读文档名、拒句与成因词)。 */
 export interface ConfigCandidateRead {
@@ -82,19 +94,39 @@ export declare function buildCandidateRejectedFields(r: {
  * 最近一次被判官整拒的候选的**结论**(纯数据)—— 判官判决的持有形:`domains` 就是 {@link judgeConfigCandidate} 交出的 `rejected.domains`(排序去重的域名集),
  * 一个字没改写;`source` = 这份候选是哪种配置源读出来的(`"local"` 本地 `config.d` / `"remote"` 中心);`at` = 判官判下这份候选的时刻(毫秒)。
  * 持有者(`boot/web-admin.ts` 的 `candidateRejection`)是它的**唯一**座:`config_candidate_rejected` 日志行的去重键与 `GET /v1/models.candidateRejected`
- * 的投影({@link buildCandidateRejectedWire})读的是同一份 —— 拒因文案(`errors`)与文件路径(`dir`)只走日志,不进这份结论,也就不上 wire。
+ * 的投影({@link buildCandidateRejectedWire})读的是同一份。`errors` 是判官交出的 `rejected.errors` 那一列的**同一个数组**(`config_candidate_rejected` 行体的 `errors` 也是它,
+ * {@link buildCandidateRejectedFields}):进程内的读者 —— 起服期「回落 env 之后没有缺省模型」的拒启句(`defaultModelRefusal` 的回落原因)—— 读它点名被拒的文档与拒码,
+ * 不读日志、不自铸第二份。拒因文案(`errors`)与文件路径(`dir`)只走日志与这条进程内的读,**不上 wire**:wire 投影 {@link buildCandidateRejectedWire} 只挑 `domains` / `at` / `source` 三键。
  */
 export interface CandidateRejection {
     readonly version: number;
     readonly domains: readonly string[];
     readonly source: "local" | "remote";
     readonly at: number;
+    readonly errors: readonly CandidateDomainRejection[];
+    /** 本地读腿的配置根(`config_candidate_rejected` 行的 `dir` 同一个值;远程读腿缺席)—— 拒启句据它 + 域名点得出被拒文档的路径。 */
+    readonly dir?: string;
 }
 export declare function candidateRejectionOf(r: {
     readonly effective: EffectiveConfig;
 }, verdict: Extract<ConfigCandidateVerdict, {
     verdict: "rejected";
-}>, source: CandidateRejection["source"], at: number): CandidateRejection;
+}>, source: CandidateRejection["source"], at: number, dir?: string): CandidateRejection;
+/**
+ * 拒启句里「回落原因」的一格(纯数据):被拒的文档名 · 成因词(拒码)· 原因类词 · 被拒文档的路径(本地读腿才有)。
+ * **不含** `error` 原文:契约句 / 读腿句里的链接目标路径等操作数只留在 `config_candidate_rejected` 行(那里已过产出边界脱敏)。
+ */
+export interface CandidateRejectionNote {
+    readonly document: string;
+    readonly code: CandidateRejectReason;
+    readonly cause: string;
+    readonly path?: string;
+}
+/**
+ * {@link CandidateRejection} 的拒因列 → 拒启句的「回落原因」格(`defaultModelRefusal` 的视图成员读它)。来源就是判官交出的那一列 `errors`(与 `config_candidate_rejected` 行同一份),
+ * 路径 = `<dir>/config.d/<域>.json`(拒行「据 dir + 域点得出文件」的同一读法,`localConfigDirOf` 是本仓 `config.d` 路径的唯一写法)。
+ */
+export declare function buildCandidateRejectionNotes(rejection: Pick<CandidateRejection, "errors" | "dir">): CandidateRejectionNote[];
 /** `GET /v1/models` 顶层 `candidateRejected` 的 wire 形(契约 §A.1d「`GET /v1/models` 的 `candidateRejected`」):域名闭集词 + ISO 时刻 + 源形态,零自由文本。 */
 export interface CandidateRejectedWire {
     readonly domains: string[];

package/dist/web-admin-client/candidate-gate.js

@@ -1,11 +1,40 @@
+import { join } from "node:path";
+import { localConfigDirOf } from "../config-dir-trust.js";
 import { judgePromptsWire } from "../prompts-domain-validate.js";
+export const CANDIDATE_REJECTION_KINDS = ["schema_invalid", "empty", "parse_error", "not_object", "too_deep", "retired_domain", "dangling_symlink", "unreadable"];
+const DANGLING_LINK_MARK = " is a dangling symbolic link (";
+function rejectionKindOf(reason, error) {
+    switch (reason) {
+        case "domain_invalid":
+            return "schema_invalid";
+        case "empty":
+            return "empty";
+        case "invalid_json":
+            return "parse_error";
+        case "not_object":
+            return "not_object";
+        case "too_deep":
+            return "too_deep";
+        case "retired_domain":
+            return "retired_domain";
+        case "io":
+            return error.includes(DANGLING_LINK_MARK) ? "dangling_symlink" : "unreadable";
+        default: {
+            const unhandled = reason;
+            throw new Error(`unhandled candidate reject reason: ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+function rejectionOf(domain, error, reason) {
+    return { domain, error, reason, kind: rejectionKindOf(reason, error) };
+}
 export function judgeConfigCandidate(r) {
     const prompts = r.effective.prompts;
     const promptsGate = prompts === undefined ? undefined : judgePromptsWire(prompts);
     const errors = [
-        ...(r.domainErrors ?? []).map((de) => ({ domain: de.domain, error: de.error, reason: "domain_invalid" })),
-        ...(promptsGate !== undefined && !promptsGate.ok ? [{ domain: "prompts", error: promptsGate.error, reason: "domain_invalid" }] : []),
-        ...(r.refusedDocuments ?? []).map((d) => ({ domain: d.document, error: d.error, reason: d.reason })),
+        ...(r.domainErrors ?? []).map((de) => rejectionOf(de.domain, de.error, "domain_invalid")),
+        ...(promptsGate !== undefined && !promptsGate.ok ? [rejectionOf("prompts", promptsGate.error, "domain_invalid")] : []),
+        ...(r.refusedDocuments ?? []).map((d) => rejectionOf(d.document, d.error, d.reason)),
     ];
     if (errors.length === 0)
         return { verdict: "clean", prompts: promptsGate?.ok ? promptsGate.artifact : undefined };
@@ -24,8 +53,27 @@ export function buildCandidateRejectedFields(r, verdict, leg, ctx) {
         note: "candidate rejected whole (§9.5-5) — live config keeps the last-known-good; fix the named files to unblock",
     };
 }
-export function candidateRejectionOf(r, verdict, source, at) {
-    return { version: r.effective.version, domains: verdict.domains, source, at };
+export function candidateRejectionOf(r, verdict, source, at, dir) {
+    return { version: r.effective.version, domains: verdict.domains, source, at, errors: verdict.errors, ...(dir !== undefined ? { dir } : {}) };
+}
+const KIND_CAUSE = {
+    schema_invalid: "the domain failed its schema",
+    empty: "empty file",
+    parse_error: "parse error",
+    not_object: "not a JSON object",
+    too_deep: "nested too deep",
+    retired_domain: "retired domain file",
+    dangling_symlink: "dangling symbolic link",
+    unreadable: "unreadable",
+};
+export function buildCandidateRejectionNotes(rejection) {
+    const configDir = rejection.dir === undefined ? undefined : localConfigDirOf(rejection.dir);
+    return rejection.errors.map((e) => ({
+        document: e.domain,
+        code: e.reason,
+        cause: KIND_CAUSE[e.kind],
+        ...(configDir !== undefined ? { path: join(configDir, `${e.domain}.json`) } : {}),
+    }));
 }
 export function buildCandidateRejectedWire(rejection) {
     return { domains: [...rejection.domains], at: new Date(rejection.at).toISOString(), source: rejection.source };

package/dist/web-admin-client/center-request.d.ts

@@ -2,7 +2,10 @@ import { type CenterCredentialSource } from "../center-credential.js";
 export declare const SCHEMA_MAJOR_HEADER = "x-sema-schema-major";
 /** 8s:对中心请求 / 响应式调用的传输上界(拉配置 / 两条 principal 视图 / 内容拉取 / 凭证续签同一值)。 */
 export declare const CENTER_PULL_TIMEOUT_MS = 8000;
-/** 已装 settings-schema 的 major(机器派生)。版本号不成形 ⇒ 模块装载即抛(装坏了的包不该带着一个猜出来的
+/** 已装 settings-schema 的版本号 —— 本仓**唯一**的读口(包自己的 `./package.json` 出口,JSON 模块导入见上):对中心协商用的 major(下)与能力位
+ *  `settingsContract.version`(`capabilities/settings-contract.ts`)同读这一只。 */
+export declare const SETTINGS_SCHEMA_VERSION: string;
+/** 已装 settings-schema 的 major(由 {@link SETTINGS_SCHEMA_VERSION} 机器派生)。版本号不成形 ⇒ 模块装载即抛(装坏了的包不该带着一个猜出来的
  *  major 去跟中心协商 wire 形)。 */
 export declare const SETTINGS_SCHEMA_MAJOR: string;
 /** 一个中心端点 = 基址 + 凭证来源(`ServiceConfig.webAdmin` 结构上满足)。 */

package/dist/web-admin-client/center-request.js

@@ -7,8 +7,9 @@ import { buildHttpUrlRefusal } from "../url-refusal.js";
 import { egressRedirectRefusal } from "../egress-redirect.js";
 export const SCHEMA_MAJOR_HEADER = "x-sema-schema-major";
 export const CENTER_PULL_TIMEOUT_MS = 8000;
+export const SETTINGS_SCHEMA_VERSION = settingsSchemaPackage.version;
 export const SETTINGS_SCHEMA_MAJOR = (() => {
-    const version = settingsSchemaPackage.version;
+    const version = SETTINGS_SCHEMA_VERSION;
     const m = /^(\d+)\.\d+\.\d+/.exec(version);
     if (m === null)
         throw new Error(`cannot derive ${SCHEMA_MAJOR_HEADER}: @sema-agent/settings-schema package.json has version ${JSON.stringify(version)}`);

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

@@ -24,7 +24,6 @@ const GOVERNANCE_DOMAIN_KEY_TABLE = {
 };
 export const GOVERNANCE_DOMAIN_KEYS = Object.keys(GOVERNANCE_DOMAIN_KEY_TABLE);
 export const NON_DOMAIN_EFFECTIVE_KEYS = {
-    a2a: "R-15 裁开域([4384]),但 settings-schema 至 1.3.0 未开(DOMAINS 无 a2a)——S-31 件2 BLOCKED on schema:远端腿靠 readEffectiveWire 的 open-world verbatim 透传(DESIGN-269),本地腿不可达(FileConfigStore 只读 PORTABLE_DOMAINS)。schema 开域之日按墓碑流程收线。",
     readFace: "R-15 裁**暂不开域**([4384]:env 逐键恒赢语义下收益薄,⚪ 呈现制过渡)——#A4 的远端腿同靠 open-world 透传;本地腿四键由 env / 引擎默认独占。若来日改裁开域,同上墓碑机制。",
     sandboxGit: "契约的 wire-only 键(settings-schema 14.7.0 `EffectiveWire.sandboxGit`):web-admin 按部署登记册投影,不是存储域 —— `buildEffective` 从不产它、`readEffectiveWire` 逐字承运;判它的唯一座位 `SandboxGitConfig` 在 stageEffective 调一次。本地腿不可达(`config.d` 只读便携域)⇒ 本地配置源恒缺席(沙箱 git 平面读 `no_origins`)。",
 };

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

@@ -52,5 +52,5 @@ export { mutateInPlace, applyEffective, NO_CENTER_EFFECTIVE, isNoCenterEffective
 export { restartReasons, modelPlaneChanged, type RestartSlice, type RestartSliceCtx, type EngineRestartSignal, } from "./restart-signal.js";
 export { applySkillsManifest, installedSkillMatchesManifest, skillManifestEntriesNotInstalled, skillToolListsOf, resolveMcpServers, mcpForScenario, resolveA2aPeers, a2aForScenario } from "./skills-mcp.js";
 export { applyCenterReadFace, buildReadFaceBaseline, buildReadFaceSwapCandidate, restoreReadFaceBaseline, CENTER_READ_FACE_LIVE_KEYS, type CenterReadFaceApply, type CenterReadFaceReport, type ReadFaceBaseline, type ReadFaceSeat } from "./read-face.js";
-export type { CenterSkillManifest, CenterMcpServer, CenterA2aPeer, CenterModel, CenterReadFace, EffectiveConfig, ExecutionRuling, SessionMirrorRuling, } from "./types.js";
+export type { CenterSkillManifest, CenterMcpServer, CenterModel, CenterReadFace, EffectiveConfig, ExecutionRuling, SessionMirrorRuling, } from "./types.js";
 //# sourceMappingURL=facade.d.ts.map

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

@@ -53,6 +53,7 @@ export declare function fetchPrincipalCaps(center: CenterEndpoint, principal: st
     runtimeCaps: EntitlementRuntimeCaps | null;
     configured: boolean;
     scenario?: ScenarioRuling;
+    scenarioDrift?: string;
     execution?: ExecutionRuling;
     executionDrift?: string;
     orgMemory?: unknown;

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readEffectiveWire, PrincipalCapsWire } from "@sema-agent/settings-schema";
+import { isStringArray, readEffectiveWire, PrincipalCapsWire } from "@sema-agent/settings-schema";
 import { separateRetiredDomains, splitFoldedReadWarnings, withDroppedCatalogEntries } from "./read-warnings.js";
 import { CENTER_PULL_TIMEOUT_MS, centerFetch } from "./center-request.js";
 import { answerStillCurrent } from "../center-credential.js";
@@ -38,14 +38,7 @@ export async function fetchPrincipalCaps(center, principal, etag, fetchImpl, wor
     return {
         runtimeCaps: body.runtimeCaps ?? null,
         configured: Boolean(body.configured),
-        ...("scenario" in body || "allowlist" in body
-            ? {
-                scenario: {
-                    scenario: typeof body.scenario === "string" ? body.scenario : null,
-                    allowlist: Array.isArray(body.allowlist) ? body.allowlist.filter((s) => typeof s === "string") : [],
-                },
-            }
-            : {}),
+        ...scenarioRulingOf(body),
         ...((() => {
             const isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
             const exRaw = body.execution;
@@ -73,6 +66,21 @@ export async function fetchPrincipalCaps(center, principal, etag, fetchImpl, wor
         etag: raw.etag,
     };
 }
+function scenarioRulingOf(body) {
+    const hasScenario = "scenario" in body;
+    const hasAllowlist = "allowlist" in body;
+    if (!hasScenario && !hasAllowlist)
+        return {};
+    if (!hasScenario || !hasAllowlist)
+        return { scenarioDrift: `${hasScenario ? "allowlist" : "scenario"} is missing while ${hasScenario ? "scenario" : "allowlist"} is present` };
+    const { scenario, allowlist } = body;
+    if (scenario !== null && typeof scenario !== "string")
+        return { scenarioDrift: `scenario is ${Array.isArray(scenario) ? "array" : typeof scenario}, expected string or null` };
+    if (!isStringArray(allowlist)) {
+        return { scenarioDrift: Array.isArray(allowlist) ? "allowlist has a non-string element, expected string[]" : `allowlist is ${allowlist === null ? "null" : typeof allowlist}, expected string[]` };
+    }
+    return { scenario: { scenario: typeof scenario === "string" ? scenario : null, allowlist: [...allowlist] } };
+}
 function assertPrincipalEcho(echoed, principal) {
     if (echoed !== undefined && echoed !== principal) {
         throw new Error(`web-admin principal-caps response echoes principal ${JSON.stringify(echoed)} but ${JSON.stringify(principal)} was requested — discarding the whole response`);

package/dist/web-admin-client/restart-signal.js

@@ -2,6 +2,7 @@ import { resolveActiveTiers, resolveCatalogDefaultModel } from "@sema-agent/sett
 import { stableStringify } from "@sema-agent/settings-schema/hash";
 import { DEFAULT_PLUGIN_ALLOW_HOSTS, materializablePlugins } from "../capabilities/center-plugins.js";
 import { CENTER_READ_FACE_LIVE_KEYS } from "./read-face.js";
+import { enabledA2aPeerView } from "./skills-mcp.js";
 const RESTART_SLICES = ["skills", "mcp", "a2a", "scenarios", "degrade-route", "read-face", "memory-consolidation"];
 function enabledOnly(rows) {
     if (!rows)
@@ -41,8 +42,10 @@ function restartSliceValue(eff, slice, ctx) {
         }
         case "mcp":
             return enabledOnly(eff.mcp?.servers);
-        case "a2a":
-            return enabledOnly(eff.a2a?.peers);
+        case "a2a": {
+            const views = (eff.a2a?.peers ?? []).flatMap((peer) => enabledA2aPeerView(peer) ?? []);
+            return views.length > 0 ? views : null;
+        }
         case "scenarios":
             return enabledOnly(eff.scenarios?.scenarios);
         case "read-face": {

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

@@ -4,7 +4,8 @@ import type { Logger } from "../observability/logger.js";
 import { type PeerDesk, type PeerLease } from "../peer-seat.js";
 import type { LoadedSkill } from "../capabilities/skills.js";
 import type { ConfigProvider } from "../config-provider.js";
-import type { CenterA2aPeer, CenterMcpServer, CenterSkillManifest } from "./types.js";
+import type { CenterMcpServer, CenterSkillManifest } from "./types.js";
+import type { A2aConfig, A2aPeerSpec } from "@sema-agent/settings-schema";
 /**
  * 技能正文的来源 = **拉到这份清单的配置源自己**([ref]):`fetchSkillContent(contentHash)` 按 hash 答正文 —— 远程 = 中心内容端点
  * (传输自验 hash;未知 hash ⇒ `undefined`),本地 = config.d 里内联的正文(与清单同一种容错读);`skillBodyCacheDir` = 这只配置源
@@ -68,8 +69,8 @@ export declare function resolveMcpServers(mcp: {
  *  [ref]:alias 窗撤销,单键命中(同 `skillsForScenario`)。 */
 export declare function mcpForScenario(center: CenterMcp | undefined, scenario: string): McpServerSpec[] | undefined;
 /**
- * DESIGN-269 §2.1 —— resolve center A2A peers (`/effective.a2a`) into core `A2aServerSpec`s + the scenarios
- * each applies to. Exact sibling of {@link resolveMcpServers}, same three rules:
+ * DESIGN-269 §2.1 —— resolve the deployment's A2A peers (the `a2a` domain: `config.d/a2a.json` on the local leg, `/effective.a2a` on the
+ * center leg — one declaration seat, both legs read through the contract) into core `A2aServerSpec`s + the scenarios each applies to. Exact sibling of {@link resolveMcpServers}, same three rules:
  *   · header-NAME refs → real values from THIS service's env (the secret boundary is unchanged — the center
  *     never holds the bearer), registered on `desk` under `rosterLease` (`mintDeclaration`, only for a peer that mounts); the spec carries the minted
  *     reference, never the values. A peer with ANY missing ref is SKIPPED wholesale (`resolveRefs` → null):
@@ -85,9 +86,22 @@ export declare function mcpForScenario(center: CenterMcp | undefined, scenario:
  * the caller. Absent face > a face that quietly launders trust. (`allowSkills` is the operator's real
  * knob here: narrow WHAT mounts, never re-label what it does.)
  */
-export declare function resolveA2aPeers(a2a: {
-    peers: CenterA2aPeer[];
-}, desk: Pick<PeerDesk, "declare">, rosterLease: PeerLease, logger?: Logger): ScopedA2aPeer[];
+export declare function resolveA2aPeers(a2a: A2aConfig, desk: Pick<PeerDesk, "declare">, rosterLease: PeerLease, logger?: Logger): ScopedA2aPeer[];
+/** 解析器从一条 a2a 对端上真读的七键,读成同一件事的写法归一成一形:`cardUrl` / `principalHeader` 空串 ≡ 缺席、`allowSkills` 空表 ≡ 缺席
+ *  (不收窄)、`headerRefs` 空记录 ≡ 缺席(没有件)、`scenarios` 缺席 ≡ `[]`(全场景)。禁用的对端 ⇒ undefined(解析器跳过,零运行期效果)。
+ *  两个读者:{@link resolveA2aPeers}(拨号的输入就是它)与 restart 片 `a2a`(指纹的就是它 —— 只指纹真重启的字段,与模型条目同律)。
+ *  七键名单只在这里成文:解析器多读一个键而这里没投 ⇒ 解析器读不到(编译红);片不会漏签。
+ *  `enabled` / `scenarios` 按可缺席读:型上它们恒在(契约读口补缺省),但 LKG 回放不经读口(删除条件同解析器的名字臂)。 */
+export interface A2aPeerView {
+    name: string;
+    url: string;
+    cardUrl?: string;
+    headerRefs?: Record<string, string>;
+    principalHeader?: string;
+    allowSkills?: string[];
+    scenarios: string[];
+}
+export declare function enabledA2aPeerView(peer: A2aPeerSpec): A2aPeerView | undefined;
 /** The A2A peers applicable to a scenario: tagged with it, or untagged (global). undefined when none.
  *  Twin of {@link mcpForScenario} — `undefined` (not `[]`) is load-bearing: an empty array would put an
  *  `a2a: []` key on the spec, i.e. "this deployment declares an empty peer set", where absence means

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

@@ -1,10 +1,11 @@
 import { readMcpSourceLabel } from "../mcp-source-label.js";
 import { skillContentHash } from "@sema-agent/settings-schema";
-import { judgeSessionMetaKey, readMcpToolAxes, readToolFaces } from "@sema-agent/core";
+import { ensureDir, judgeSessionMetaKey, readMcpToolAxes, readToolFaces } from "@sema-agent/core";
 import { MCP_CONTENT_ORIGINS, describeBadContentOrigin, describeBadWireName, isContentOriginWord, isUsableWireName } from "@sema-agent/settings-schema";
 import { noteMcpAssertionHeaderNotSent, withholdsMcpAssertionHeader } from "../mcp-assertion-header.js";
 import { mintDeclaration, peerSentence } from "../peer-seat.js";
 import { SHA256_HEX_RE } from "../digest-form.js";
+import { atomicWriteFileAsync } from "../plugins/owner-only-file-mode.js";
 export function skillToolListsOf(source) {
     return {
         ...(source.allowedTools !== undefined ? { allowedTools: [...source.allowedTools] } : {}),
@@ -62,10 +63,8 @@ export async function applySkillsManifest(baseline, manifest, bodies, logger) {
             return;
         const hex = hash.replace(/^sha256:/, "");
         pendingWrites.push((async () => {
-            await fsp.mkdir(diskCacheDir, { recursive: true });
-            const tmp = joinPath(diskCacheDir, `${hex}.${Math.random().toString(36).slice(2, 8)}.tmp`);
-            await fsp.writeFile(tmp, content, { mode: 0o600 });
-            await fsp.rename(tmp, joinPath(diskCacheDir, hex));
+            ensureDir(diskCacheDir);
+            await atomicWriteFileAsync(joinPath(diskCacheDir, hex), content, { durability: "best-effort" });
         })().catch((err) => logger?.warn("web_admin_skill_cache_write_failed", { hash, err: String(err) })));
     };
     const byName = new Map(baseline.map((s) => [s.spec.name, s]));
@@ -211,35 +210,41 @@ export function mcpForScenario(center, scenario) {
 }
 export function resolveA2aPeers(a2a, desk, rosterLease, logger) {
     const out = [];
-    for (const p of a2a.peers ?? []) {
-        if (p.enabled === false)
+    for (const declared of a2a.peers ?? []) {
+        const view = enabledA2aPeerView(declared);
+        if (view === undefined)
             continue;
-        if (!isUsableWireName(p.name)) {
+        if (!isUsableWireName(view.name)) {
             logger?.warn("web_admin_a2a_name_unusable", {
-                peer: describeBadWireName(p.name),
+                peer: describeBadWireName(view.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, "web_admin_a2a_env_missing", "skipping this A2A peer — referenced env var is unset in this service");
+        const { headerRefs, scenarios, ...spec } = view;
+        const headers = resolveRefs(headerRefs, spec.name, "header", logger, "web_admin_a2a_env_missing", "skipping this A2A peer — referenced env var is unset in this service");
         if (headers === null)
             continue;
-        const draft = {
-            spec: {
-                name: p.name,
-                url: p.url,
-                ...(p.cardUrl ? { cardUrl: p.cardUrl } : {}),
-                ...(p.principalHeader ? { principalHeader: p.principalHeader } : {}),
-                ...(p.allowSkills && p.allowSkills.length > 0 ? { allowSkills: p.allowSkills } : {}),
-            },
-            pieces: headers,
-        };
-        out.push({ scenarios: p.scenarios ?? [], spec: mintDeclaration(desk, draft, rosterLease) });
+        const draft = { spec, pieces: headers };
+        out.push({ scenarios, spec: mintDeclaration(desk, draft, rosterLease) });
     }
     if (out.length > 0)
         logger?.info("web_admin_a2a", { peers: out.map((p) => p.spec.name) });
     return out;
 }
+export function enabledA2aPeerView(peer) {
+    if (peer.enabled === false)
+        return undefined;
+    return {
+        name: peer.name,
+        url: peer.url,
+        ...(peer.cardUrl ? { cardUrl: peer.cardUrl } : {}),
+        ...(peer.headerRefs && Object.keys(peer.headerRefs).length > 0 ? { headerRefs: peer.headerRefs } : {}),
+        ...(peer.principalHeader ? { principalHeader: peer.principalHeader } : {}),
+        ...(peer.allowSkills && peer.allowSkills.length > 0 ? { allowSkills: peer.allowSkills } : {}),
+        scenarios: peer.scenarios ?? [],
+    };
+}
 export function a2aForScenario(peers, scenario) {
     if (!peers || peers.length === 0)
         return undefined;