@sema-agent/server 7.146.0 → 7.148.0

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

@@ -4,7 +4,7 @@ import type { EffectiveConfig, ExecutionRuling } from "./types.js";
 import { type DroppedConfigEntry, type UnreadConfigFile } from "./read-warnings.js";
 import { type CenterEndpoint } from "./center-request.js";
 /** GET the effective config (Bearer + ETag). null = 304 (unchanged). Throws on transport/HTTP error, and on a
- *  payload that is not an effective config at all(非对象 / version 非有限数 / gate 域坏形——[ref] 裁B)。
+ *  payload that is not an effective config at all(非对象 / version 非有限数 / gate 域坏形——[ref] 裁B;这一类抛是 `ConfigCandidateRefusedError`,成因 `rejected`)。
  *  `refusedDocuments`:被拒文档(契约类型 `ConfigDocumentRefusal`,与本地腿同键同义;wire 上只有一种 —— 带事实的退役域,墓碑,成因词 `retired_domain`)不抛 —— 交成发现、那一键不进 effective,
  *  候选判官整拒这份候选。
  *  `domainErrors`:坏 catalog 域(schema default 已落)逐域单列——与本地腿 `FetchEffectiveResult` 同键同义,
@@ -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,17 +1,36 @@
 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";
+import { candidateRefusedBy } from "../config-pull-failure.js";
+import { readUpstreamJson } from "../upstream-body.js";
 export async function fetchEffective(center, etag, fetchImpl, worker) {
     const { res, identity } = await centerFetch(center, { kind: "effective", worker }, { etag, timeoutMs: CENTER_PULL_TIMEOUT_MS, fetchImpl });
     if (res.status === 304)
         return null;
     if (!res.ok)
         throw new Error(`web-admin HTTP ${res.status}`);
+    let raw;
+    try {
+        raw = await readUpstreamJson(res);
+    }
+    catch (bodyError) {
+        if (bodyError instanceof SyntaxError)
+            throw candidateRefusedBy(bodyError);
+        throw bodyError;
+    }
     const warnings = [];
-    const { body, refusedDocuments } = separateRetiredDomains(await res.json());
-    const wire = readEffectiveWire(body, (w) => warnings.push(w));
+    let body;
+    let refusedDocuments;
+    let wire;
+    try {
+        ({ body, refusedDocuments } = separateRetiredDomains(raw));
+        wire = readEffectiveWire(body, (w) => warnings.push(w));
+    }
+    catch (readerError) {
+        throw candidateRefusedBy(readerError);
+    }
     const { domainErrors, droppedEntries, droppedCatalogEntries, unreadFiles } = splitFoldedReadWarnings(warnings, "center");
     const effective = withDroppedCatalogEntries(wire, droppedCatalogEntries);
     return {
@@ -38,14 +57,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 +85,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`);
@@ -94,7 +121,7 @@ async function requestPrincipalView(center, principal, etag, fetchImpl, worker)
     if (!res.ok)
         throw new Error(`web-admin principal-caps HTTP ${res.status}`);
     const responseEtag = res.headers.get("etag");
-    const json = await res.json();
+    const json = await readUpstreamJson(res);
     stillCurrent();
     return { json, ...(responseEtag !== null ? { etag: responseEtag } : {}) };
 }
@@ -133,7 +160,7 @@ export async function fetchPromptArtifact(center, artifactDigest, fetchImpl) {
     const { res } = await centerFetch(center, { kind: "prompt-artifact", digest: artifactDigest }, { timeoutMs: CENTER_PULL_TIMEOUT_MS, fetchImpl });
     if (!res.ok)
         throw new WebAdminHttpError(`prompt artifact HTTP ${res.status} for ${artifactDigest}`, res.status);
-    return await res.json();
+    return await readUpstreamJson(res);
 }
 export async function fetchPromptBlob(center, contentDigest, fetchImpl) {
     const { res } = await centerFetch(center, { kind: "prompt-blob", digest: contentDigest }, { timeoutMs: CENTER_PULL_TIMEOUT_MS, fetchImpl });

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

@@ -45,7 +45,7 @@ export declare function createMcpRevocationLedger(onChange?: (ev: {
     restored: string[];
 }) => void): McpRevocationLedger;
 /** 一拍 EffectiveConfig 的 ENABLED MCP 服务器条目表(`resolveMcpServers` 同判据:`enabled !== false`;
- *  值=整条目的 key 排序 JSON 指纹,Map 插入序=发布序);mcp 域缺席 ⇒ `null`(台账不动)。
+ *  值=条目的指纹面(`entry-metadata.ts` `mcpEntryFingerprintFace`:减备注 / 名册标签,分组标签按挂载口判据读)的 key 排序 JSON 指纹,Map 插入序=发布序);mcp 域缺席 ⇒ `null`(台账不动)。
  *  指纹序列化器 = `@sema-agent/settings-schema/hash` 的 `stableStringify`([ref] 起;[ref] 2026-08-31 起与 restart-signal 同源:此前本文件
  *  持一份**逐字相同**的私有复刻 `fingerprintOf`;JSON 形输入上字节恒等,golden 钉 test/canonical-json-golden.test.ts)。
  *  两处指纹仍只在各自域内自比、不跨域比对——同源只是去掉一份多余的复刻,不引入跨域约束;也**不**改用

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

@@ -1,4 +1,5 @@
 import { stableStringify } from "@sema-agent/settings-schema/hash";
+import { mcpEntryFingerprintFace } from "./entry-metadata.js";
 export function createMcpRevocationLedger(onChange) {
     let baseline;
     let seen;
@@ -41,7 +42,7 @@ export function enabledMcpEntries(mcp) {
     const out = new Map();
     for (const s of mcp.servers) {
         if (s.enabled !== false)
-            out.set(s.name, stableStringify(s));
+            out.set(s.name, stableStringify(mcpEntryFingerprintFace(s)));
     }
     return out;
 }

package/dist/web-admin-client/read-warnings.d.ts

@@ -143,6 +143,7 @@ export declare const DroppedCatalogEntryRow: z.ZodObject<{
         "entry-schema-invalid": "entry-schema-invalid";
         "entry-key-invalid": "entry-key-invalid";
         "entry-unreadable": "entry-unreadable";
+        "entry-unknown-key": "entry-unknown-key";
     }>;
     identity: z.ZodOptional<z.ZodObject<{
         name: z.ZodOptional<z.ZodString>;

package/dist/web-admin-client/read-warnings.js

@@ -209,6 +209,7 @@ function reasonCodeForWire(code) {
         case "entry-schema-invalid":
         case "entry-key-invalid":
         case "entry-unreadable":
+        case "entry-unknown-key":
             return code;
         default: {
             const never = code;

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

@@ -2,14 +2,19 @@ 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";
+import { mcpEntryFingerprintFace, withoutEntryMetadata } from "./entry-metadata.js";
 const RESTART_SLICES = ["skills", "mcp", "a2a", "scenarios", "degrade-route", "read-face", "memory-consolidation"];
 function enabledOnly(rows) {
     if (!rows)
         return null;
     return rows.filter((r) => r.enabled !== false);
 }
+function enabledEntriesFingerprint(rows, face = withoutEntryMetadata) {
+    return enabledOnly(rows)?.map((r) => face(r)) ?? null;
+}
 export function catalogEntryFingerprint(entry) {
-    const { cost, quotaWeight: _quotaWeight, enabled: _enabled, ...route } = entry;
+    const { cost, quotaWeight: _quotaWeight, enabled: _enabled, ...route } = withoutEntryMetadata(entry);
     return { ...route, costDeclared: cost !== undefined };
 }
 function planeEntriesFingerprint(rows) {
@@ -34,17 +39,19 @@ function restartSliceValue(eff, slice, ctx) {
         return null;
     switch (slice) {
         case "skills": {
-            const skills = enabledOnly(eff.skills?.skills);
+            const skills = enabledEntriesFingerprint(eff.skills?.skills);
             const materialized = materializablePlugins(eff, ctx?.pluginsAllowHosts ?? DEFAULT_PLUGIN_ALLOW_HOSTS);
             const plugins = materialized.length > 0 ? materialized : null;
             return skills === null && plugins === null ? null : { skills, plugins };
         }
         case "mcp":
-            return enabledOnly(eff.mcp?.servers);
-        case "a2a":
-            return enabledOnly(eff.a2a?.peers);
+            return enabledEntriesFingerprint(eff.mcp?.servers, mcpEntryFingerprintFace);
+        case "a2a": {
+            const views = (eff.a2a?.peers ?? []).flatMap((peer) => enabledA2aPeerView(peer) ?? []);
+            return views.length > 0 ? views : null;
+        }
         case "scenarios":
-            return enabledOnly(eff.scenarios?.scenarios);
+            return enabledEntriesFingerprint(eff.scenarios?.scenarios);
         case "read-face": {
             const d = eff.readFace;
             if (!d)

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` = 这只配置源
@@ -16,8 +17,8 @@ export type SkillBodySource = Pick<ConfigProvider, "fetchSkillContent" | "skillB
  * **在场 ⇒ 整只数组原样**(含 `[]`;不去重、不排序、不判拼写 —— settings-schema 14.4.0 的读法一句话,判官在引擎:`allowedTools` 是 allow 规则来源、`disallowedTools` 拒侧读成空的条目让
  * 那次激活 fail-closed)。数组复制一份:规格上的数组是引擎规格自己的,不与配置源手里的 manifest / 本地店对象共享。
  *
- * 本函数住在技能域的读口旁,三个读者共用 —— 本地腿 CLOSED 投影(`config-provider.ts` 的 `mapToServiceEffective`)、manifest → 规格的铸点({@link applySkillsManifest})、
- * 已装技能 ↔ manifest 的投影一致判据({@link installedSkillMatchesManifest}):三处各写一份键表就是下一次同形丢位([ref] 族)。契约再加一个技能键时的看守不在这里,
+ * 本函数住在技能域的读口旁,两个读者共用 —— manifest → 规格的铸点({@link applySkillsManifest})、
+ * 已装技能 ↔ manifest 的投影一致判据({@link installedSkillMatchesManifest}):两处各写一份键表就是下一次同形丢位(本地腿的 manifest 由契约 `toSkillsManifest` 铸,条目整只过境,不再有第三份键表)。契约再加一个技能键时的看守不在这里,
  * 在 `test/skill-tool-lists-carry.test.ts` 的键处置表(按 `keyof SkillSpec` 铸型)与 `test/settings-schema-consumption-gates.test.ts` 门 4(叶路径由契约形状派生)。
  */
 export declare function skillToolListsOf(source: {
@@ -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;

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

@@ -1,11 +1,12 @@
 /**
  * web-admin wire types — the web-admin `/api/config/effective` payload shapes (`CenterModel`,
- * `CenterSkillManifest`, `CenterMcpServer`, `CenterA2aPeer`, `EffectiveConfig`) plus the per-principal
+ * `CenterSkillManifest`, `CenterMcpServer`, `EffectiveConfig`; the `a2a` domain is the contract's own `A2aConfig`) plus the per-principal
  * execution/session-mirror ruling shapes riding the caps view (`ExecutionRuling`/`SessionMirrorRuling`).
  * Pure type/interface declarations — no runtime logic. Split out of `facade.ts` ([ref] A13,
  * internal-lossless: the facade re-exports every symbol below unchanged).
  */
 import type { ToolContentOrigin } from "@sema-agent/core";
+import type { A2aConfig, ModelThinkingLevelMap } from "@sema-agent/settings-schema";
 import type { Autonomy, CommandRule } from "../runtime-governance.js";
 import type { DroppedCatalogEntry } from "./read-warnings.js";
 export interface CenterModel {
@@ -28,6 +29,13 @@ export interface CenterModel {
     tier?: string;
     reasoning?: boolean;
     vision?: boolean;
+    /**
+     * [ref](settings-schema 20.0.0 `ModelEntry.thinkingLevelMap`)—— 这条条目的逐档思考拼写,上引擎 `Model.thinkingLevelMap`(键 off / minimal / low / medium / high / xhigh / max;
+     * 串 = 供应商对这一档的值,`null` = 这一档不支持,没写的档 = 供应商缺省)。类型就是契约型(不是 `unknown`):与 {@link CenterModel.compat} 不同,这一席的**形归契约包判**
+     * (闭集键,坏形整条被读腿丢 —— 中心腿 `readEffectiveWire`、本地腿契约文件店同一只 zod),到得了这里的都是判过的;本服务不二判,`toModel` 原样交引擎。
+     * 缺席 = 未声明(不补 `{}`);`{}` = 声明了、无覆盖。env 腿没有这一席(声明座只有目录条目)。
+     */
+    thinkingLevelMap?: ModelThinkingLevelMap;
     contextWindow?: number;
     maxTokens?: number;
     /** [ref]① 1M dual-window (core 1.289 `Model.autoCompactTokens`): an EXPLICIT roster value wins the
@@ -48,10 +56,10 @@ export interface CenterModel {
      *  此后记账,不回算窗口内历史(registry types.d.ts 同句契约)。 */
     quotaWeight?: number;
     /**
-     * [ref](settings-schema 1.10.0 `ModelEntry.compat`)—— 这条目录条目对 **openai-completions 线路**的
-     * 兼容声明,上 core `Model.compat`(`OpenAICompletionsCompat` 五键)。真需求 = vLLM / Qwen 类**缺省开
-     * 思考**的网关:关思考只能靠 `thinkingFormat: "qwen-chat-template"`(`chat_template_kwargs.
-     * enable_thinking=false`),而 `extraBody` 穿不过引擎的 OpenAI 保留键表。
+     * [ref](settings-schema 1.10.0 `ModelEntry.compat`)—— 这条目录条目对**它那条线路**的兼容声明,上 core `Model.compat`:
+     * openai-completions 条目 = `OpenAICompletionsCompat` 五键,anthropic-messages 条目 = `AnthropicMessagesCompat`([ref] (b) 起按线路读;此前 anthropic 条目一律整只丢)。
+     * 真需求 = vLLM / Qwen 类**缺省开思考**的网关:关思考只能靠 `thinkingFormat: "qwen-chat-template"`(`chat_template_kwargs.
+     * enable_thinking=false`),而 `extraBody` 穿不过引擎的 OpenAI 保留键表;adaptive 族 anthropic 端点(无 budget、关不掉)靠 `thinkingMode: "adaptive"`。
      *
      * 🔴 类型是 `unknown` 而不是那个结构,**刻意的**(与 {@link CenterMcpServer.toolFaces} 逐字同姿):本类型
      * 是两条腿的**承载形**(本地 config.d 经 settings-schema 的 `z.unknown()` 解析透明地过来、远端 /effective
@@ -63,8 +71,7 @@ export interface CenterModel {
      * `readEffectiveWire`)都把它们当未知键剥掉(1.10.0 夹具实测:`unknown-keys-dropped
      * {keys:["models.0.defaultThinking","models.0.reasoningEffortLevels"]}`;settings-schema 3.0.0 起同一条
      * 告警的坐标是**段数组** `{keys:[["models",0,"defaultThinking"],…]}`,出门形走 `formatConfigPath`),
-     * `mapToServiceEffective` 的
-     * CLOSED 投影也从未列过它们。留着 = 一份读不到任何东西的类型承诺 + `compat.reasoningEffortLevels`
+     * 当年本地腿的 CLOSED 投影(已删)也从未列过它们。留着 = 一份读不到任何东西的类型承诺 + `compat.reasoningEffortLevels`
      * 之外的第二个写者([ref]:同一语义面禁两个写者)。roster 级 `defaultThinking` 若要真做,归 schema 补键
      * 另立单据(见 CHANGELOG 未闭环)。
      */
@@ -160,8 +167,9 @@ export interface CenterMcpServer {
     toolFaces?: unknown;
     /**
      * [ref](settings-schema 12.2.x `McpServerSpec.toolAxes`,解析透明 `z.unknown()`)—— 部署侧为这台 server 的**每只工具**声明的
-     * 风险轴(`effect` / `egress` / `irreversibility`),键 = server 的**原始(未加命名空间)**工具名,上 core
-     * `McpServerSpec.toolAxes`。
+     * 风险轴(引擎的成员集:`effect` / `egress` / `irreversibility` / `boundaryFlow`),键 = server 的**原始(未加命名空间)**工具名,上 core
+     * `McpServerSpec.toolAxes`。其中 `boundaryFlow: "engine"`(须同条 `egress: false`)声明一只引擎专用工具(设备车道的发射闸对它的调用不欠任何东西),
+     * 只有部署声明(本地 config.d / 中心)能写,请求侧写它被拒;两条部署腿都原样交给引擎判。
      *
      * 🔴 类型是 `unknown` 而不是那个结构,**刻意的**(与 {@link CenterMcpServer.toolFaces} 逐字同姿):本类型是两条部署腿的**承载形**
      * (本地 config.d 经 `z.unknown()` 解析透明地过来、远端 /effective 是直读 JSON),形判与投影的单一属主是**引擎**根导出的
@@ -204,31 +212,8 @@ export interface CenterMcpServer {
     };
 }
 /**
- * DESIGN-269 §2.1 —— A2A peer registry entry (the `CenterMcpServer` sibling). `headerRefs` are env-NAME
- * refs (header-name → ENV_NAME), **never** literal secrets: the bearer for a peer lives in THIS service's
- * env, the center only ever stores the NAME. (A2A has a single transport — every peer is an https(s)
- * endpoint — so unlike MCP there is no transport discriminant; the two ref-carrying shapes collapse to one.)
- */
-export interface CenterA2aPeer {
-    name: string;
-    scenarios: string[];
-    enabled?: boolean;
-    /** The peer's service URL (also the origin the well-known agent-card path resolves against). */
-    url: string;
-    /** Explicit agent-card location when the peer does not publish at a well-known path. Set ⇒ used ALONE. */
-    cardUrl?: string;
-    /** env-NAME refs (header-name → ENV_NAME) resolved from THIS service's env at boot. A peer with ANY
-     *  unset ref is SKIPPED wholesale (fail-safe — never dial a peer half-credentialed). */
-    headerRefs?: Record<string, string>;
-    /** [ref], same contract as the MCP side: the header name the runner injects the task's authenticated
-     *  end-user principal into. Not a ref — a literal header NAME (the runner fills the value, never the model). */
-    principalHeader?: string;
-    /** Optional allowlist of the peer's skill ids to mount (others are not mounted). */
-    allowSkills?: string[];
-}
-/**
- * #A4([ref] 窗三件批 件1;[ref]/[ref] 承诺件)—— READ 容纳面的 center 下发形(`CenterA2aPeer` 的
- * 同族:一个 additive 顶层域,server 声明它才不会被静默丢弃)。四个成员逐一对应部署 env 的四键
+ * #A4([ref] 窗三件批 件1;[ref]/[ref] 承诺件)—— READ 容纳面的 center 下发形(一个 additive 顶层键,
+ * 不是契约域:server 声明它才不会被静默丢弃)。四个成员逐一对应部署 env 的四键
  * (`READ_FACE` / `READ_DENY_PATTERNS` / `READ_DENY_BUILTIN_TIERS` / `READ_DENY_BUILTIN_EXCLUDE`),
  * 消费半场 = `web-admin-client/read-face.ts` `applyCenterReadFace`。
  *
@@ -334,11 +319,14 @@ export interface EffectiveConfig {
     mcp?: {
         servers: CenterMcpServer[];
     };
-    /** DESIGN-269 §2.1: center-declared A2A peers. Absent (the shape every center ships today) ⇒ the leg
-     *  does not exist for this deployment — `config.a2aPeers` stays undefined, no peer is ever dialed. */
-    a2a?: {
-        peers: CenterA2aPeer[];
-    };
+    /** The deployment's resident outbound A2A peers — the contract's `a2a` domain (settings-schema 18.0.0, portable): `config.d/a2a.json`
+     *  on the local leg, `/effective.a2a` on the center leg, both read through the contract. The local leg materializes the domain (no file ⇒
+     *  `{ peers: [] }` — the reader is the contract itself, it always knows the domain); the center leg does NOT invent a domain the producer did not
+     *  send (settings-schema 20.0.0 `WIRE_CARRIED_DOMAINS`: an `/effective` body without `a2a` — an older center that does not know the domain —
+     *  reads ABSENT; `{ peers: [] }` = the center says "empty roster"). Absent and an empty `peers` ⇒ no peer is dialed (one state: `resolveA2aPeers`
+     *  yields nothing / is not called, `a2aForScenario` yields undefined, the restart slice reads null). Optional because of that center leg and because
+     *  the LKG replay (raw file, not read through the contract) may predate the domain. */
+    a2a?: A2aConfig;
     /** Center-declared scenarios (composition-as-config; capability stays code-pinned): each entry names a
      *  deploy-registered TOOLSET (`none` / `repo-readonly`) + an optional static prompt (≤4KB, audited at
      *  publish). Restart-to-apply like skills/mcp (baked into the scenario table at boot). Center entries
@@ -360,14 +348,10 @@ export interface EffectiveConfig {
      * `limits` 在 PORTABLE_DOMAINS 里)。
      */
     limits?: EffectiveLimits;
-    /** 142-S4(registry-core 0.10.0 第 15 域):center 项目登记簿。wire 面 verbatim JSON —
-     *  registry-core `ProjectsConfig` 的形状是 `{projects: Record<projectId, ProjectRegistration>}`(skills/mcp
-     *  同款域包裹)。[ref]B-8:裸 Record 联合臂随 apply-effective 的宽读一起删(0.13.0 只有包裹形,
-     *  裸形无 producer)。消费=applyEffective → config.projects(displayName/gitRemotes/defaultScopes
-     *  三个 runtime 字段;审计字段不进 ServiceConfig)。 */
-    projects?: {
-        projects?: Record<string, unknown>;
-    };
+    /** 项目登记簿(settings-schema `projects` 域)。wire 面 verbatim JSON —— settings-schema `ProjectsConfig` 的形状是
+     *  `{projects: Record<projectId, ProjectRegistration>}`(skills / mcp 同款域包裹)。这里不声明更窄的型:判官是 settings-schema 的视图面读函数,
+     *  唯一调用点 applyEffective(→ config.projects,`ProjectRegistration` 原样)。 */
+    projects?: unknown;
     /** settings-schema 0.6 起治理三件(autonomy/commandPolicy/approvalRequire)的**唯一**承运域(0.7.1 撤
      *  runtime 位双写镜像;顺序契约当年已走完:消费端先切、center 再撤)。键集与 schema `GovernanceConfig.shape`
      *  逐字相等([ref] 件3 对账门钉)。消费:autonomy/commandPolicy 逐请求热(`stageRuntimeHot`,boot+refresh);
@@ -400,10 +384,10 @@ export interface EffectiveConfig {
 /** (stage7 P5,registry-core 0.8 `execution` 域): the center-resolved per-principal execution
  *  ruling riding the caps view. `required=false` / ruling absent = no enforcement (legacy). `allowedLanes` is
  *  an OPEN value domain (adding one is never BREAKING; consumers tolerate unknown names). Known lane names:
- *  `host`/`e2b`/`k8s`/`ssh`/`adb`/`local-docker`/`device` (the REMOTE_EXEC providers) **plus `in-process`**
- *  — the REMOTE_EXEC-unset fleet posture ([ref]: previously "OA/review-style workers", a scenario family retired in 5.0.0; named distinctly from the explicit
- *  `host` lane on purpose). ⚠️ Admins writing `required=true` policies must include `in-process` when such
- *  workers should stay admittable — center UI/doc 词表待补齐。
+ *  `host`/`e2b`/`k8s`/`ssh`/`adb`/`local-docker`/`device`/`none` (the REMOTE_EXEC lanes; `none` = a declared
+ *  no-execution-environment lane). Since 7.147.0 every deployment declares its lane; the name earlier versions gave an
+ *  unset lane (`in-process`) is retired and renamed `none` ⇒ admins writing `required=true` policies list `none` for workers
+ *  without an execution environment (during the switch, list both names, then drop the old one — data, not a code double-read).
  *
  *  🔴 **`device` 是 per-principal 执行面上最需要写清的一条**(device-executor-lane-v2 §4.1 的 web-admin
  *  行,车A-4 补):它是「在**员工自己的机器**上执行」的那条车道 —— 允许它 ≠ 允许一台云沙箱,而是允许

package/dist/workspace-space.d.ts

@@ -139,8 +139,9 @@ export interface EndedSpace {
  *  no second read to fail — a head read that throws fails the delete itself (retried to convergence). */
 export type CacheReclaimReason = "delete_failed" | "budget";
 /**
- * The ONE reclaim seat for an ended space — called where a space ENDS: the session-delete coordinator (`boot/session-faces.ts` `purgeSession`)
- * and the managed-retention sweep after it deletes session trees (`boot/retention-lane.ts`); neither writes a reclaim of its own. It reclaims
+ * The ONE reclaim seat for an ended space — called where a space ENDS, through the one session-erase settler (`session-erase.ts`
+ * `createSessionEraseSettler`) both deciders run after a session tree is erased: the session-delete coordinator (`boot/session-faces.ts` `purgeSession`)
+ * and the managed-retention sweep (`boot/retention-lane.ts`); neither writes a reclaim of its own. It reclaims
  * everything the space left behind: the cache volume (when configured), the `space/` snapshot partition and the session's park snapshots whose names carry the ended occupant's ownership mark (when a
  * snapshot store is configured; old-form / `none` park objects are left to the bucket's lifecycle rule). ONE call runs under ONE
  * absolute deadline (`dataTimeoutMs`) built at its entry — the cache volume and the objects of every space in the call; a space the deadline passed

package/docs/DEVICE-EXECUTOR-PROTOCOL.md

@@ -13,7 +13,7 @@ dials the device, so the device needs no inbound port, no public address and no
 
 | Plane | Transport | Who calls whom | Where it is specified |
 |---|---|---|---|
-| Management / enrollment / binding | HTTPS, JSON | the user's client calls the server | `docs/ASSISTANT-WIRE-CONTRACT.md` §14 |
+| Management / enrollment / binding | HTTPS, JSON | the user's client calls the server | the server's wire contract, device-management section (internal record, not shipped) |
 | Executor | WebSocket (upgrade on the WS path below), text frames, JSON | the device connects out to the server | **this document** |
 
 **Discovery before you connect**: `GET /v1/capabilities` carries a `deviceExecutor` key — either `false`
@@ -1103,6 +1103,6 @@ The short version for an executor implementer:
   *different* device is refused — changing devices is an explicit rebind action, never an implicit one;
 - a non-device deployment refuses the key outright rather than ignoring it.
 
-The full contract — request shapes, every refusal code, the rebind verb, and the disclosed races — is in
-`docs/ASSISTANT-WIRE-CONTRACT.md` §14.6 (and §14.1–14.5 for the management verbs). It is not repeated
-here.
+The full contract — request shapes, every refusal code, the rebind verb, and the disclosed races — is part of
+the server's wire contract, in its device-lane section (the first-bind write protocol and the management verbs;
+internal record, not shipped). It is not repeated here.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/server",
-  "version": "7.146.0",
+  "version": "7.148.0",
   "description": "Sema Server — the server/API implementation layer for Sema, wiring core, registry, model providers, and cloud agent execution. Built on @sema-agent/core.",
   "type": "module",
   "license": "BUSL-1.1",
@@ -14,6 +14,9 @@
     "./main": {
       "default": "./dist/main.js"
     },
+    "./model-plane-probe": {
+      "default": "./dist/model-plane-probe.js"
+    },
     "./device-protocol": {
       "types": "./dist/device-protocol.d.ts",
       "default": "./dist/device-protocol.js"
@@ -78,23 +81,23 @@
   },
   "dependencies": {
     "@modelcontextprotocol/server": "2.4.0",
-    "@sema-agent/core": "7.64.0",
-    "@sema-agent/settings-schema": "17.1.0",
-    "e2b": "^2.28.0",
-    "libsodium-wrappers": "^0.8.4",
-    "mysql2": "^3.22.4",
-    "pg": "^8.22.0",
-    "ssh2": "^1.17.0",
+    "@sema-agent/core": "7.66.0",
+    "@sema-agent/settings-schema": "24.0.0",
+    "e2b": "2.36.0",
+    "libsodium-wrappers": "0.8.4",
+    "mysql2": "3.22.6",
+    "pg": "8.22.0",
+    "ssh2": "1.17.0",
     "typebox": "1.1.39",
     "undici": "7.30.0",
-    "ws": "^8.21.0",
-    "zod": "^4.4.3"
+    "ws": "8.21.0",
+    "zod": "4.4.3"
   },
   "optionalDependencies": {
-    "sharp": "^0.35.3"
+    "sharp": "0.35.3"
   },
   "devDependencies": {
-    "@sema-agent/sdk": "24.0.0",
+    "@sema-agent/sdk": "36.0.0",
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/node": "22.10.2",
     "@types/pg": "^8.20.0",
@@ -103,6 +106,7 @@
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",
     "core-mixed-version-reader": "npm:@sema-agent/core@7.54.1",
+    "semver": "7.8.5",
     "tsx": "4.19.2",
     "typescript": "5.7.2",
     "vitest": "^4.1.8",