@sema-agent/server 7.146.0 → 7.148.0

package/dist/user-input-ledger.d.ts

@@ -13,9 +13,8 @@
  * 「本服务以回执向调用方承诺已交给引擎、而消费只发生在进程内存里的用户输入」,**且承载它的那只 `TaskStream` 活在本服务的一条 run 腿里**([ref])——
  * 后半句是收敛判词成立的前提:证据面是那条 run 行(下文「收敛判据」)。行的 `taskId` = 回执上的 run、`sessionId` = 那条 run 的会话(人看的那一只),
  * run 里是哪一只流(run 自己的 / 同步子代的)**不是**账本的事实:告知按 run 并帧(`steer` = 条数),读面行同形。今天只有 steer 一族(`kind:"steer"` =
- * 受理它的引擎动词 `TaskStream.steer`,三档 `now` / `next` / `later` 同一个动词同一族),三个入口同一个引擎动词:
- *  · `POST /v1/runs/:id/steer` 的 live 腿(200 applied);
- *  · `POST /v1/runs/:id/interrupt` 的带 text 形(202 queued-immediate,档位 now;设计稿把它划在病面外,车 SW 亲核它进的是同一只进程内队列 ⇒ 同类同修);
+ * 受理它的引擎动词 `TaskStream.steer`,三档 `now` / `next` / `later` 同一个动词同一族),两个入口同一个引擎动词:
+ *  · `POST /v1/runs/:id/steer` 的 live 腿(200 applied;档位只来自它的体 —— 「切断并说话」= `priority:"now"`,同一扇门);
  *  · `POST /v1/runs/:id/subagents/:target/steer`(200 applied,[ref])—— 投进**同步子代**自己的流(core `createSteerHandle` → `stream.steer`)。子代由父腿
  *    await,父腿收场时 core 撤掉在飞的复活(`subagentRetain.disposeAll`),所以它活在父 run 的腿里;腿 = 子代句柄,`handle.settled` 兑现 ⇒ 结清。
  * 规则的反面(不是例外表):workflow agent steer(`POST /v1/workflows/:id/agents/:label/steer`,200 applied)不在本账 —— workflow 是会话锚定的后台件
@@ -45,8 +44,8 @@
  *                   —— run 事件账与本账是两只店、没有共同事务,两害取「多说一遍」,不取「声称说过」。
  * 转移只有四条(open → settled | converged;converged → announced),两只孪生都按 CAS 守它们(File 单进程 = 内存判;SQL = `WHERE state=…`)。
  *  · `erased`    —— ([ref])**会话树删除**:该会话此前的每一次受理(不论状态)离开账本。行随会话走 —— 账本行的唯一归属键就是 `sessionId`,
- *                   所以两条删会话树的级联(在线删除协调器 `boot/session-faces.ts` 的 `purgeSession`、托管留存的事务化孪生
- *                   `retention-store-sql.ts` 的 `purgeSessionTrees`)各有一臂删它,谓词同一只(`session_id` 单键,店动词 `deleteBySession`)。
+ *                   所以删净一只会话的唯一执行体(`session-erase.ts`)删它,谓词同一只(`session_id` 单键):local 执行体调店动词 `deleteBySession`,
+ *                   SQL 上在线删除与托管留存同一段会话树事务经 `plugins/retention-deployment.ts` 的 `deleteDeploymentSessionRows` 发同一只谓词。
  *                   File 孪生的盘上形 = 一行会话级墓碑 `{ kind:"erased", sessionId, at }`(与 workflow 完成信箱 `drain{sessionId}` 同形),
  *                   只擦它**之前**的同会话行 —— 会话 id 删后可被重新登记,之后的受理属于下一位住客;SQL 孪生 = 真删行。被删受理上迟到的转移全输
  *                   (行不在了,与「未知 acceptId」同一条守卫)。
@@ -105,7 +104,7 @@ export type UserInputKind = (typeof LEDGER_KIND_OF_LANE)[UserInputLane];
 /** 读盘词表(判定走 `Object.hasOwn`;派生自 {@link LEDGER_KIND_OF_LANE})。≤7.117.x 的读腿不认 `follow_up`(回滚须知在 MIGRATION)。 */
 export declare const USER_INPUT_KIND_WORDS: Readonly<Record<UserInputKind, true>>;
 /**
- * 一次受理的族词 —— 三个受理口(run steer 的 live 腿 / interrupt 带 text 形 / 子代 steer)同调这一只。车道是引擎的那一只读法
+ * 一次受理的族词 —— 两个受理口(run steer 的 live 腿 / 子代 steer)同调这一只。车道是引擎的那一只读法
  * `injectionLaneOf(steerPriorityOf(…))`(core 7.45.0 [ref]:缺席档 = `next`;`later` 走 follow-up 车道,`now` / `next` 走 steer 车道;
  * 档外值抛 `steering.invalid_content` —— 受理口在这之前已按 `isSystemInjectionPriority` 400 掉档外值,这一抛在本仓不可达)。
  */
@@ -263,8 +262,8 @@ export interface UserInputLedgerStore {
     listUnannounced(sessionId: string, limit: number): Promise<UserInputAcceptance[]>;
     /** [ref] —— **会话树删除**:删掉该会话**每一种状态**的受理,回删除条数(没有可删的 ⇒ 0、零写;幂等)。按 `session_id` 单键:行上没有属主列,
      *  会话所有权由调用方证过(在线删除 = 路由的 DELETE 门;留存 = 候选集本身出自本域加锁读的 `session_meta`),与 anchors / exemptions /
-     *  attachments 同律。调用方 = 在线删除协调器(`boot/session-faces.ts` `purgeSession` 的一腿);托管留存的事务化孪生不调店、在自己的事务里
-     *  发**同一只谓词**(`retention-store-sql.ts` `purgeSessionTrees` ④)。写不进 ⇒ 抛(协调器据此不删会话本体,幂等重试收敛)。 */
+     *  attachments 同律。调用方 = local 删净执行体(`session-erase.ts` `createLocalSessionEraser` 的一腿);SQL 上的删净(在线与留存同一段事务体)不调店、
+     *  在自己的事务里发**同一只谓词**(`retention-deployment.ts` `deleteDeploymentSessionRows` ④)。写不进 ⇒ 抛(执行体据此不删会话本体,幂等重试收敛)。 */
     deleteBySession(sessionId: string): Promise<number>;
 }
 /** 收敛判词读的 run 店面(只读一只动词)。 */

package/dist/user-input-ledger.js

@@ -138,7 +138,7 @@ export function buildCrashedUndrainedNotice(input) {
     const face = USER_INPUT_UNDRAINED_FAMILIES[lane];
     return {
         code: face.code,
-        message: `Check the earlier run's transcript and results before re-sending any of these steers to a live run. The server accepted ${input.count} ${UNDRAINED_WHAT_OF_LANE[lane]} for run ${input.taskId} (each answered 200 applied or 202 queued-immediate), but the process running that run ended before the engine confirmed consuming them. They are NOT redelivered.`,
+        message: `Check the earlier run's transcript and results before re-sending any of these steers to a live run. The server accepted ${input.count} ${UNDRAINED_WHAT_OF_LANE[lane]} for run ${input.taskId}, but the process running that run ended before the engine confirmed consuming them. They are NOT redelivered.`,
         detail: { [face.countKey]: input.count, cause: CRASHED_CAUSE, taskId: input.taskId, sessionId: input.sessionId },
         sessionId: input.sessionId,
     };

package/dist/web-admin-client/apply-effective.d.ts

@@ -16,9 +16,12 @@ import { type ConfigCandidateRead } from "./candidate-gate.js";
 import type { CatalogSource } from "../env-model-table-gate.js";
 /** Apply center config OVER the env-derived config (mutates `config`). Empty domains keep env defaults. */
 /** Replace a record's contents IN PLACE (clear keys, copy source) so holders of the SAME reference see the
- *  change. This is what makes models/roles/pricing HOT-apply: core's Runner reads
- *  `this.deps.models/roles/pricing` LIVE per-task and `/v1/models` reads `config.models` — both share the
- *  reference captured at boot, so mutating it (vs reassigning) updates both with no split, no Runner rebuild. */
+ *  change. Who holds it: this service's own readers (`/v1/models`, resolveSpec, the quota / key maps) read
+ *  `config.models` / `config.roles` / `pricing` per request off the reference captured at boot; the engine reads
+ *  `deps.roles` (the role map stays the caller's object between operations) and `deps.pricing` live off the same
+ *  reference. NOT `models` / `tiers`: since core 7.60.0 the catalog door receives a whole generation at
+ *  `new Runner` / `swapDeps` and keeps a frozen snapshot, so a model-plane change reaches the Runner only through
+ *  `swapPlane` (applyEffective, before this commit) — the in-place write here is for this service's readers. */
 export declare function mutateInPlace<V>(target: Record<string, V>, source: Record<string, V>): void;
 /** 返回值=是否 COMMIT(false 两臂:[ref]③ 世代序 CAS 拒绝 / 7.10.0 swapPlane 换装拒绝——两臂都在
  *  commit 之前,活配置零触碰)。caller 收到 false 必须把**同一世代的旁路消费**(prompts 采用/pricing/

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

@@ -1,10 +1,11 @@
 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, retiredLeftOutEntries } from "../namespaced-rule-name.js";
 import { buildModelCompat, readModelCompat } from "../model-compat.js";
+import { ASSUMED_CONTEXT_WINDOW } from "../model-context-window.js";
 import { buildModelHeadersKey } from "../model-entry-headers.js";
 import { validateCommandRules } from "../runtime-governance.js";
 import { stageLimits } from "./stage-limits.js";
@@ -14,11 +15,10 @@ import { crossInvariant } from "../config-invariants.js";
 import { DEFAULT_MODEL_MISSING_CODE, REFUSED_NAME_MINTED_CODE, judgeCatalogEntries, mintedRefusedNames, refusalEventOf, refusalWarnFields, refusedNameLogField, refusedNamesLogFields, malformedDroppedCarrierRefusal } from "../model-entry-refusal.js";
 import { judgeModelRouteEndpoint } from "../model-route-endpoint.js";
 import { gateIntentUnserviceableReason } from "../approval.js";
-import { refusedGroups } from "./apply-ledger.js";
+import { modelPlaneOutcomeOf, refusedGroups } from "./apply-ledger.js";
 import { judgeConfigCandidate } from "./candidate-gate.js";
 import { declareServerWithheldEnv, withdrawServerWithheldEnv } from "../server-secret-env.js";
 import { MODEL_ROUTE_ENV_KEYS } from "../model-route-gap.js";
-const charsPerTokenOf = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : undefined);
 function envDerivedModel(config) {
     const m = config.envModel;
     if (m === undefined) {
@@ -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,
@@ -43,20 +41,18 @@ function toModel(m, envDefaults = {}, logger) {
         api: m.api,
         baseUrl: m.baseUrl ?? "",
         ...mintCapabilityKeys({ reasoning: m.reasoning, vision: m.vision }),
-        contextWindow: m.contextWindow ?? envDefaults.contextWindow ?? 262144,
+        contextWindow: m.contextWindow ?? envDefaults.contextWindow ?? ASSUMED_CONTEXT_WINDOW,
         maxTokens: m.maxTokens ?? envDefaults.maxTokens ?? 4096,
-        ...(charsPerTokenOf(m.charsPerToken) !== undefined || envDefaults.charsPerToken !== undefined
-            ? { charsPerToken: charsPerTokenOf(m.charsPerToken) ?? envDefaults.charsPerToken }
-            : {}),
-        ...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" },
+        ...(m.charsPerToken !== undefined || envDefaults.charsPerToken !== undefined ? { charsPerToken: m.charsPerToken ?? envDefaults.charsPerToken } : {}),
+        ...buildModelCostKey(m.cost),
+        params: { 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),
     };
-    const explicitAct = m.autoCompactTokens;
-    applyAutoCompactWindow(model, typeof explicitAct === "number" ? explicitAct : undefined);
+    applyAutoCompactWindow(model, m.autoCompactTokens);
     return model;
 }
 export function mutateInPlace(target, source) {
@@ -369,7 +365,7 @@ function stageModelPlane(config, eff, source, logger, sealedKeys) {
         return stageEnvModelPlane(config);
     const enabled = (eff.models?.models ?? []).filter((m) => m.enabled !== false);
     const verdict = judgeCatalogEntries(enabled, { anthropicRouteMounted: config.anthropic !== undefined }, eff.models?.droppedCatalogEntries);
-    if (enabled.length === 0 && verdict.malformed.length === 0 && verdict.dropped.every((row) => row.identity?.enabled === false))
+    if (!verdict.manages)
         return { stages: {} };
     {
         for (const [name, r] of Object.entries(verdict.refused))
@@ -399,7 +395,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" });
@@ -450,7 +446,7 @@ function stageModelPlane(config, eff, source, logger, sealedKeys) {
         const roles = { ...envPlane.roles, ...centerRoles };
         const activeTiers = {};
         for (const [tier, target] of Object.entries(resolveActiveTiers(eff.models) ?? {})) {
-            if (models[target] !== undefined) {
+            if (Object.hasOwn(models, target)) {
                 activeTiers[tier] = target;
                 continue;
             }
@@ -459,7 +455,7 @@ function stageModelPlane(config, eff, source, logger, sealedKeys) {
         }
         let picked;
         if (usable.length > 0) {
-            const decided = resolveCatalogDefaultModel(eff.models, (n) => models[n] !== undefined, usable[0].name);
+            const decided = resolveCatalogDefaultModel(eff.models, (n) => Object.hasOwn(models, n), usable[0].name);
             switch (decided.kind) {
                 case "named":
                     for (const d of decided.dangling) {
@@ -543,22 +539,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 +619,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 +629,7 @@ function stageApprovalRequire(raw) {
             kept: KEPT_WOULD_MATCH_NOTHING,
         };
     }
-    return { ok: true, value: names };
+    return { ok: true, value: names, skipped: retiredLeftOutEntries("published governance.approvalRequire", names) };
 }
 function unserviceableOnLeg(leg, candidate) {
     switch (leg.leg) {
@@ -672,6 +656,7 @@ function stageApprovalGate(config, gov, leg, logger) {
     };
     const raw = gov?.approvalRequire;
     let next;
+    let skipped = [];
     if (raw === undefined) {
         next = [...approvalEnvBaseline.get(config)];
     }
@@ -680,10 +665,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 };
 }
@@ -759,7 +752,7 @@ export function logEffectiveDiff(config, eff, catalogSource, logger) {
     logger?.warn("web_admin_dry_run", {
         note: `DRY RUN — web-admin config NOT applied; unset ${WEB_ADMIN_ENV.dryRun} to go live`,
         version: eff.version,
-        wouldOverrideModels: enabled.length > 0,
+        wouldOverrideModels: modelPlaneOutcomeOf(modelPlaneGroupReport(plane)) !== "unmanaged",
         wouldDefaultModel: plane.defaultName ?? null,
         ...(Object.keys(refused).length > 0 ? { wouldRefuse: Object.fromEntries(Object.entries(refused).map(([n, r]) => [n, r.code])) } : {}),
         ...(plane.rejected !== undefined ? { wouldRefuseModelPlane: { invariant: plane.rejected.invariant, code: plane.rejected.code, reason: plane.rejected.reason } } : {}),

package/dist/web-admin-client/apply-ledger.d.ts

@@ -70,11 +70,12 @@ export interface ConfigApplyGroupState {
 export interface ConfigApplyLedgerView {
     /** 本副本**最后**见到的源版本(身份标;拉到即算,哪怕候选被整拒)。 */
     readonly configTargetVersion: number;
-    /** 最后一次成功 commit 的源版本(身份标)。 */
+    /** 最后一次**收口**的完整应用版本(身份标):这一代已提交、且应用它的那一拍的重启判定已发布(写口在 web-admin 的拍收口,
+     *  与 `/health.restart` 同一段同步写 ⇒ 读到它到版时 `restart` 已是这一拍的判定)。按组的落地另记在 `groups[*].appliedVersion`(提交即记)。 */
     readonly configAppliedVersion: number;
     /** [ref]:target 的收货序数(进程内单调)——「见过多少代」的推进判据,哈希方向免疫。 */
     readonly configTargetOrdinal: number;
-    /** [ref]:applied 的收货序数。targetOrdinal 推进而这里停滞 = 「改了没生效」的机器判据。 */
+    /** [ref]:applied 的收货序数(与 `configAppliedVersion` 同一次写)。targetOrdinal 推进而这里停滞 = 「改了没生效」的机器判据。 */
     readonly configAppliedOrdinal: number;
     /** target≠applied 的**持续**时长(ms);收敛时键缺席(健康面不制造噪音)。 */
     readonly configApplyStaleMs?: number;
@@ -110,15 +111,23 @@ export declare function refusedGroups(report: ConfigApplyReport): Array<{
     readonly reason: string;
 }>;
 /**
- * O3:这一次 apply 的**模型面组**(组内各域 = `MODEL_PLANE_DOMAINS`)落地了没有(整组被拒 ⇒
- * false;报告缺席 = 没走到 commit ⇒ false,如实)。调用方据此决定「Runner 现在跑的是哪一代模型面」(`appliedPlaneEff`,swap 判据的
- * 基准)、名册门开不开、以及 boot 要不要按组回落 LKG —— 都只许从真落地的模型面推进。
+ * 一次 apply 里**模型面组**(组内各域 = `MODEL_PLANE_DOMAINS`)的结局 —— 闭集三词,调用方穷举:
+ *  · `landed` —— 组内的域真落地了(Runner 换到这一代模型面);
+ *  · `unmanaged` —— 候选**不管**模型面(目录条目批判据的判决位 `manages` 为假:零启用条目,含只有停用的被丢行;降档时服务的已是 env 表也是这一形)——
+ *    上一代 / env 继续服务,**不是拒,也不是落地**;
+ *  · `refused` —— 整组拒(上一代继续服务)。
+ * 调用方据此决定「Runner 现在跑的是哪一代模型面」(`appliedPlaneEff`,swap 判据的基准)、名册门开不开、boot 要不要按组回落 LKG、
+ * 要不要说「在服 LKG 的模型面」—— 只有 `landed` 推进这些;`refused` 才走按组回落;`unmanaged` 两件都不做。
  */
-export declare function modelPlaneCommitted(report: ConfigApplyReport | undefined): boolean;
+export type ModelPlaneOutcome = "landed" | "unmanaged" | "refused";
+/** 模型面组报告 → 结局(组报告的唯一写者是 apply-effective 的 `modelPlaneGroupReport`:`applied` 非空 ⇔ 组内的域被 stage 出来并提交)。dry-run 读同一只。 */
+export declare function modelPlaneOutcomeOf(group: ConfigApplyGroupReport): ModelPlaneOutcome;
+/** 一次 apply 的模型面结局;报告缺席(没走到 commit:CAS 拒 / swap 席拒 / apply 抛)⇒ `undefined`,如实。 */
+export declare function modelPlaneOutcome(report: ConfigApplyReport | undefined): ModelPlaneOutcome | undefined;
 export interface ConfigApplyLedger {
     /** 拉到一个候选(无论后续是否应用)。ordinal=收货序数,version=身份标。 */
     seenTarget(ordinal: number, version: number): void;
-    /** 一个候选整体 commit 成功。 */
+    /** 应用这一代的那一拍收口(已提交 + 重启判定已发布;有组被拒的那一代只推进 target)。 */
     applied(ordinal: number, version: number): void;
     /** 消费 applyEffective 的报告(按组记账)。 */
     recordApply(report: ConfigApplyReport): void;

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

@@ -10,8 +10,11 @@ export function refusedGroups(report) {
         return r ? [{ group, keys: r.keys, reason: r.reason }] : [];
     });
 }
-export function modelPlaneCommitted(report) {
-    return report !== undefined && report.groups.modelPlane.rejected === undefined;
+export function modelPlaneOutcomeOf(group) {
+    return group.rejected !== undefined ? "refused" : group.applied.length > 0 ? "landed" : "unmanaged";
+}
+export function modelPlaneOutcome(report) {
+    return report === undefined ? undefined : modelPlaneOutcomeOf(report.groups.modelPlane);
 }
 export function createConfigApplyLedger(now = () => Date.now()) {
     let targetOrd = 0;

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` 结构上满足)。 */
@@ -64,8 +67,8 @@ export declare function pullViewQuery(view: {
     readonly principal?: string | undefined;
 }): string;
 /**
- * 中心回了重定向(`egress-redirect.ts` 的判据:`opaqueredirect` 或任何 3xx;304 除外,见 {@link NOT_MODIFIED}):不跟、不重试,类型化拒。拒句是 `egress-redirect.ts` 既有 helper 的那一句(与 hook 直连腿 /
- * 记忆 embedder 同一条律),前面冠上这条请求打的那一席;不回显 `Location`。`status` 是中心回的码(续签器据此落「被拒」终态)。
+ * 中心回了重定向(`egress-redirect.ts` 的判据:`opaqueredirect` 或除 304 外的任何 3xx):不跟、不重试,类型化拒。拒句是 `egress-redirect.ts` 那一只出口的那一句(与本仓其余每个出站面同一条律),
+ * 前面冠上这条请求打的那一席;不回显 `Location`。`status` 是中心回的码(续签器据此落「被拒」终态)。
  */
 export declare class CenterRedirectRefusedError extends Error {
     readonly status: number;

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

@@ -4,11 +4,12 @@ import { FLEET_LIVE_PATHS, FLEET_PATHS } from "@sema-agent/settings-schema/fleet
 import { CenterCredentialUnavailableError } from "../center-credential.js";
 import { WEB_ADMIN_ENV, httpUrlFlaws, pathBaseUrlFlaws } from "@sema-agent/settings-schema";
 import { buildHttpUrlRefusal } from "../url-refusal.js";
-import { egressRedirectRefusal } from "../egress-redirect.js";
+import { EgressRedirectRefusedError, createEgressFetch } 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)}`);
@@ -66,21 +67,21 @@ export class CenterRedirectRefusedError extends Error {
         this.name = "CenterRedirectRefusedError";
     }
 }
-const NOT_MODIFIED = 304;
 async function sendToCenter(fix, url, wire) {
-    const res = await (wire.fetchImpl ?? fetch)(url, {
-        method: wire.method,
-        headers: wire.headers,
-        ...(wire.body !== undefined ? { body: wire.body } : {}),
-        redirect: "manual",
-        signal: AbortSignal.timeout(wire.timeoutMs),
-    });
-    if (res.status === NOT_MODIFIED)
-        return res;
-    const refusal = egressRedirectRefusal(res, fix);
-    if (refusal !== undefined)
-        throw new CenterRedirectRefusedError(res.status, `web-admin center request: ${refusal}`);
-    return res;
+    const egress = createEgressFetch(fix, wire.fetchImpl);
+    try {
+        return await egress(url, {
+            method: wire.method,
+            headers: wire.headers,
+            ...(wire.body !== undefined ? { body: wire.body } : {}),
+            signal: AbortSignal.timeout(wire.timeoutMs),
+        });
+    }
+    catch (err) {
+        if (err instanceof EgressRedirectRefusedError)
+            throw new CenterRedirectRefusedError(err.status, `web-admin center request: ${err.message}`);
+        throw err;
+    }
 }
 export function pathBaseUrlRefusal(subject, raw) {
     const flaws = pathBaseUrlFlaws(raw);

package/dist/web-admin-client/effective-keys.d.ts

@@ -18,7 +18,7 @@ export declare const EFFECTIVE_ENVELOPE_KEYS: readonly ["version", "updatedAt"];
 /** `governance` 域(治理三件)的键集——对账门与 schema `GovernanceConfig.shape` 钉集合等式。 */
 export declare const GOVERNANCE_DOMAIN_KEYS: readonly string[];
 /** EffectiveConfig 上**不是** settings-schema 域的顶层键(键 → 成文理由)。⚠️ 墓碑语义:任一键将来出现在 schema
- *  `DOMAINS` 里 ⇒ 对账门红 ⇒ 清本行 + 接本地腿投影(mapToServiceEffective)+ 复核 restart 片归属。 */
+ *  `DOMAINS` 里 ⇒ 对账门红 ⇒ 清本行 + 核本地腿线上视图(`publishLocalEffective`,契约投影整域承运)+ 复核 restart 片归属。 */
 export declare const NON_DOMAIN_EFFECTIVE_KEYS: Readonly<Record<string, string>>;
 /** schema `DOMAINS` 里 server **不消费**的域(域 → 成文理由)。⚠️ 新域(如 presets)到货而不入本表也不入
  *  EffectiveConfig ⇒ 对账门红 ⇒ 逼一行显式决定(「加了域没人接」从此机器可见,[ref]③)。 */

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`)。",
 };
@@ -37,6 +36,6 @@ export const DOMAINS_NOT_CONSUMED_BY_SERVER = {
     execution: "per-principal 执法面同 entitlement:ruling 骑 caps view(ExecutionRuling),/effective 域面 server 不读。",
 };
 export const LOCAL_LANE_REMOTE_ONLY_DOMAINS = {
-    projects: "身份台账(design/142 §1.4,与租户身份同风险模型):settings-schema 便携表刻意排除(file-store.ts 成文)——本地腿无此域文件,mapToServiceEffective 不投影;远端腿 verbatim 消费(applyEffective → config.projects)。",
+    projects: "身份台账(design/142 §1.4,与租户身份同风险模型):settings-schema 便携表刻意排除(file-store.ts 成文)——本地腿无此域文件(线上视图里只有契约缺省的空登记簿,解出 `{}` 与缺席同);远端腿 verbatim 消费(applyEffective → config.projects)。",
 };
 //# sourceMappingURL=effective-keys.js.map

package/dist/web-admin-client/entry-metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const ENTRY_METADATA_KEYS: readonly ["notes", "rosters"];
+type EntryMetadataKey = (typeof ENTRY_METADATA_KEYS)[number];
+/** 条目去掉顶层元数据键之后的副本(浅拷;入参不动)。 */
+export declare function withoutEntryMetadata<T extends object>(entry: T): Omit<T, EntryMetadataKey>;
+/** MCP 条目的指纹面:减顶层元数据键 + 分组标签按挂载口的判据读(坏形 ≡ 缺席)。restart 的 mcp 片与撤销台账的恢复指纹同读这一只。 */
+export declare function mcpEntryFingerprintFace(entry: object): Record<string, unknown>;
+export {};
+//# sourceMappingURL=entry-metadata.d.ts.map

package/dist/web-admin-client/entry-metadata.js

@@ -0,0 +1,13 @@
+import { isMcpSourceLabel } from "../mcp-source-label.js";
+export const ENTRY_METADATA_KEYS = ["notes", "rosters"];
+const METADATA = new Set(ENTRY_METADATA_KEYS);
+export function withoutEntryMetadata(entry) {
+    return Object.fromEntries(Object.entries(entry).filter(([key]) => !METADATA.has(key)));
+}
+export function mcpEntryFingerprintFace(entry) {
+    const face = withoutEntryMetadata(entry);
+    if (!isMcpSourceLabel(face.source))
+        delete face.source;
+    return face;
+}
+//# sourceMappingURL=entry-metadata.js.map

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