@sema-agent/server 7.147.0 → 7.148.0

package/dist/memory-store-refusal.d.ts

@@ -1,5 +1,5 @@
 /**
- * **店形拒**(store-form refusal)在本仓的唯一读法属主(纯叶:零 http / 零 boot 依赖)—— core 店形拒**一族**(族表 `STORE_FORM_REFUSAL_CODES`,引擎 7.65.0 起三码;
+ * **店形拒**(store-form refusal)在本仓的唯一读法属主(纯叶:零 http / 零 boot 依赖)—— core 店形拒**一族**(族表 `STORE_FORM_REFUSAL_CODES`,引擎 7.66.0 起四码;
  * 本仓按族读,下面点名的成员只是举例与历史,不是判据):
  *  · `memory.target_outside_store`(core 7.31.1 [ref]):记忆 store 里的一个目录经软链通到了 store **外**(或 store 根在 backend 打开 / 引擎首次
  *    挂载之后被改指)⇒ 引擎对落点在外的删 / 写 / 重放 / 自身写一律**不做**;
@@ -7,7 +7,10 @@
  *    (`detail.form` ∈ `symlink` | `file` | `other`,`lstat` 判、不跟链)。修前 core 对这一形抛不带码的 `ControlPlaneCorruptError`(与真控制面损坏同类同形),
  *    平铺布局(条目直接住在 home 里)于是答 500,而同一换法在嵌套布局下一层答 409 —— 现在两布局同答这一码;
  *  · `memory.control_plane_links_unsupported`(core 7.65.0):记忆控制面所在的文件系统不能建硬链接 ⇒ File 记忆店在打开处被拒(构造期抛 ⇒ 起服拒;
- *    引擎 mount 时开它自己的店被拒 ⇒ Runner 记忆相 fail-open,这一跑 memoryless,见 `memory-incident-sink.ts`)。
+ *    引擎 mount 时开它自己的店被拒 ⇒ Runner 记忆相 fail-open,这一跑 memoryless,见 `memory-incident-sink.ts`);
+ *  · `memory.control_plane_strays`(core 7.66.0 [ref] HB-5):后端自带治理店(不是引擎控制面上那只 File 店),而控制面里还留着旧的治理文档 /
+ *    控制对象 ⇒ 引擎构造期拒、一个字节不写(句子点名 `adoptReplicaControlPlane`)。本服务三种后端都构造不出这一形(File 后端钉住自己的控制面、
+ *    治理店就是那只;SQL 两只不带治理店 ⇒ 引擎用控制面上的 File 店)—— 按族入族,零专门臂。
  * 族里各码的形相同:普通 `Error` + `.code` + `.detail`(`{ path }`;home 那一码多 `form`),**句子以码领头、不含任何宿主路径**(core 7.44.0 起,
  * 路径只在 `detail.path`)。core 的读法:operator 要处置的盘形(去掉那只链 / 放回真目录),**不是**可重试的 IO 故障,也**不是**对调用方的裁决;
  * 盘形修好之前重发恒拒。本仓据此一条规则:族内同答、409、码原样;路径只进运维行(HTTP 映射一处,见 `http/memory-store-refusal-reply.ts`)。

package/dist/memory-sync-client.d.ts

@@ -25,8 +25,9 @@ export declare function buildMemorySyncEnabledFields(peer: string, scope: string
 };
 /**
  * fetch transport(core `MemorySyncTransport` 的部署实现)。`peer` = {@link memorySyncPeerOf}(`url`)(建时铸一次;拒的地址在这里抛,一个请求都不发),
- * `post` 打 `${peer}${path}`(core 传来的 path 以 `/` 开头);`token` 走 Authorization: Bearer(与中心侧 gatedPrincipal 的 verified-principal 门对齐)。
- * 非 2xx throw(status + body 前 200 字节——中心 4xx/5xx 的 typed error body 就是最好的诊断线索);2xx 返回解码后的 JSON(形状校验在 core
+ * `post` 打 `${peer}${path}`(core 传来的 path 以 `/` 开头);`token` 走 Authorization: Bearer(与中心侧 gatedSubject 的 verified-principal 门对齐)。
+ * 非 2xx throw(status + 体长 —— 体的字节不进报错句,与配置中心拉取同一条律:摘录在座前切会把跨界的令牌切成脱敏器认不出的前缀,座后切又会因前面的凭据被压短而
+ * 越过原来的源界、带出词表不认的形;对端是本服务的 `MEMORY_SYNC_SERVE`,拒因在对端自己的运维行);2xx 返回解码后的 JSON(解码经上游读口,不是 JSON ⇒ 句子只带体长;形状校验在 core
  * parseMemorySyncResponse,职责不重复)。`timeoutMs`(缺省 60s,AbortSignal.timeout)是活性保护:fire-and-forget 轮挂死会把 inflight 节流永久卡住
  * (undici 默认 headers 超时 300s 太钝)。
  */

package/dist/memory-sync-client.js

@@ -8,7 +8,9 @@ import { atomicWriteFileAsync } from "./plugins/owner-only-file-mode.js";
 import { ONE_TIME_MIGRATIONS, migrationWindowOpen } from "./plugins/one-time-migrations.js";
 import { buildMemorySyncIdentityBootRefusal, readMemorySyncIdentity } from "./memory-sync-identity.js";
 import { buildDisplaySafeUrl } from "./trace/redact.js";
+import { createEgressFetch } from "./egress-redirect.js";
 import { errorText } from "./observability/err-text.js";
+import { buildBodyWithheldNote, parseUpstreamJson } from "./upstream-body.js";
 export function memorySyncPeerOf(url) {
     const r = readMemorySyncIdentity(url);
     if ("flaw" in r) {
@@ -22,7 +24,8 @@ export function buildMemorySyncEnabledFields(peer, scope, cursorPath) {
 }
 export function createMemorySyncTransport(opts) {
     const peer = memorySyncPeerOf(opts.url);
-    const fetchImpl = opts.fetchImpl ?? fetch;
+    const injected = opts.fetchImpl;
+    const fetchImpl = createEgressFetch("declare the final address as MEMORY_SYNC_URL", injected === undefined ? undefined : (input, init) => injected(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, init ?? {}));
     const timeoutMs = opts.timeoutMs ?? 60_000;
     return Object.freeze({
         peer,
@@ -35,8 +38,8 @@ export function createMemorySyncTransport(opts) {
             });
             const text = await res.text();
             if (!res.ok)
-                throw new Error(`memory sync POST ${path}: HTTP ${res.status} ${text.slice(0, 200)}`);
-            return JSON.parse(text);
+                throw new Error(`memory sync POST ${path}: HTTP ${res.status} ${buildBodyWithheldNote(text)}`);
+            return parseUpstreamJson(text);
         },
     });
 }

package/dist/model-compat.d.ts

@@ -14,7 +14,7 @@
  * (`thinkingFormat: "qwen-chat-template"`),否则 auto 档每一轮都白烧一段思考。
  *
  * ## 对表全部**从 core 的型面铸**,本仓一个词都不枚举
- * `THINKING_LEVEL_TABLE` / `THINKING_FORMAT_TABLE` / `MAX_TOKENS_FIELD_TABLE` / `THINKING_MODE_TABLE` 都是 `Record<闭集词, true>`,
+ * `THINKING_TIER_TABLE` / `MODEL_THINKING_LEVEL_TABLE` / `THINKING_FORMAT_TABLE` / `MAX_TOKENS_FIELD_TABLE` / `THINKING_MODE_TABLE` 都是 `Record<闭集词, true>`,
  * `COMPAT_KEY_READERS` 是 `{ [A in 线路]: { [K in keyof Required<Model<A>["compat"]>]: 读器 } }` 的**映射型**(线路 = 契约 `ModelEntry.api` 的闭集):
  * core 加词/删词、加键/删键,或契约加一条线路,表当场 tsc 红(`MODEL_DEGRADE_ON` 的 `Set<DegradeReason>` 同款纪律)。
  * 映射型这一步是刻意的 —— 只钉「键集相等」会留下一个洞:core 加一键、有人把它补进白名单却忘了写读器,
@@ -32,7 +32,7 @@
  * 判形**整只判**(每条线路内):任一键不合 —— 含写了另一条线路的键 —— ⇒ 整只声明不收(和 `toolFaces` 每只工具「applied whole or not at all」
  * 同律)。留下好的那几键 = 让运维以为整条声明生效了,而实际发出去的请求是半张脸。
  */
-import type { Model } from "@sema-agent/core";
+import { type Model } from "@sema-agent/core";
 import type { ModelEntry } from "@sema-agent/settings-schema";
 /** 目录条目的线路闭集 = 契约 `ModelEntry.api`(契约加一条线路 ⇒ 读器表缺一行 ⇒ tsc 红)。 */
 export type CatalogApi = ModelEntry["api"];
@@ -42,13 +42,22 @@ export type CompatOf<A extends CatalogApi> = NonNullable<Model<A>["compat"]>;
 export type OpenAICompletionsCompat = CompatOf<"openai-completions">;
 /** core `AnthropicMessagesCompat`。 */
 export type AnthropicMessagesCompat = CompatOf<"anthropic-messages">;
-/** 六档思考梯(core `ThinkingLevel`)。`MODEL_DEFAULT_THINKING` / `MODEL_REASONING_EFFORT_LEVELS` /
- *  `compat.reasoningEffortLevels` 三处共用**这一张**表 —— [ref] 件⑤ 起就是「上游加一档而这里不补 ⇒
- *  编译红」的锁步姿势,本模块只是把它挪到了它真正的家(compat 的一个键)。 */
+/** 六档思考**梯**(core `ThinkingLevel`:一个端点吃得下哪几档的 effort 梯子)。型取自梯子座本身 —— `compat.reasoningEffortLevels`
+ *  (anthropic 线路的 `effortLevels` 同型)—— 而不是模型缺省档座:core 7.66.0 [ref] HB-1 起两座分家,缺省档多一档 `off`,梯子仍是六档
+ *  (`off` 永远不是梯子上的一级)。`MODEL_REASONING_EFFORT_LEVELS` / `compat.reasoningEffortLevels` / `compat.effortLevels` 共用**这一张**表;
+ *  上游加一档而这里不补 ⇒ 编译红([ref] 件⑤ 起的锁步姿势)。 */
+export type ThinkingTier = NonNullable<OpenAICompletionsCompat["reasoningEffortLevels"]>[number];
+/** 六档梯闭集(有序:低→高,取自上表的书写序),梯子两根旋钮的拒因文案与读器的单一真源。 */
+export declare const THINKING_LEVELS: readonly ThinkingTier[];
+export declare const isThinkingTier: (w: unknown) => w is ThinkingTier;
+/** 模型**缺省档**(core `ModelThinkingLevel` = `off` + 六档;`Model.defaultThinking` 的型):请求与角色都没点档时这只模型的请求走哪一档,
+ *  `off` = 缺省关(引擎发线路上的显式关),**不是**「没有缺省」—— 没有缺省 = 不铸键(core 7.66.0 [ref])。表 = 梯子六档 + `off`(展开同一张梯表,不写第二份);
+ *  core 给缺省档座加 / 删一词而这里不跟 ⇒ 编译红。 */
 export type ModelThinkingLevel = NonNullable<Model["defaultThinking"]>;
-/** 六档闭集(有序:低→高,取自上表的书写序),目录行 `enumValues` 与拒因文案的单一真源。 */
-export declare const THINKING_LEVELS: readonly ModelThinkingLevel[];
-export declare const isThinkingTier: (w: unknown) => w is ModelThinkingLevel;
+/** 七档缺省闭集(六档梯在前、`off` 在末,取自上表的书写序):`MODEL_DEFAULT_THINKING` 的目录 `enumValues` 与拒因文案的单一真源。 */
+export declare const MODEL_THINKING_LEVELS: readonly ModelThinkingLevel[];
+/** 七档判词 = core 包根的 `isThinkingLevel`(引擎自己判这七档的那一只;上表只留作有序列表与编译期锁步,不另写第二只判词)。 */
+export declare const isModelThinkingLevel: (w: unknown) => w is ModelThinkingLevel;
 /** `thinkingFormat` 七词闭集(core:openai / openrouter / deepseek / together / zai / qwen / qwen-chat-template)。 */
 export type ModelThinkingFormat = NonNullable<OpenAICompletionsCompat["thinkingFormat"]>;
 export declare const THINKING_FORMATS: readonly ModelThinkingFormat[];

package/dist/model-compat.js

@@ -1,6 +1,10 @@
-const THINKING_LEVEL_TABLE = { minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
-export const THINKING_LEVELS = Object.keys(THINKING_LEVEL_TABLE);
+import { isThinkingLevel } from "@sema-agent/core";
+const THINKING_TIER_TABLE = { minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
+export const THINKING_LEVELS = Object.keys(THINKING_TIER_TABLE);
 export const isThinkingTier = (w) => typeof w === "string" && THINKING_LEVELS.includes(w);
+const MODEL_THINKING_LEVEL_TABLE = { ...THINKING_TIER_TABLE, off: true };
+export const MODEL_THINKING_LEVELS = Object.keys(MODEL_THINKING_LEVEL_TABLE);
+export const isModelThinkingLevel = (w) => isThinkingLevel(w);
 const THINKING_FORMAT_TABLE = { openai: true, openrouter: true, deepseek: true, together: true, zai: true, qwen: true, "qwen-chat-template": true };
 export const THINKING_FORMATS = Object.keys(THINKING_FORMAT_TABLE);
 export const isThinkingFormat = (w) => typeof w === "string" && THINKING_FORMATS.includes(w);

package/dist/model-context-window.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The window this server ASSUMES for a model whose context window nobody declared — ONE spelling of the number.
+ *
+ * Three readers fall back to it and nothing else may carry a copy: the env leg (`config.ts`: `MODEL_CONTEXT_WINDOW` unset ⇒ this value,
+ * and the `MODEL_MAX_TOKENS` default `min(32000, window)` reads the SAME resolved window), the center leg (`web-admin-client/apply-effective.ts`:
+ * `entry.contextWindow ?? env model's window ?? this value`) and the config catalog's default note (`config-catalog.ts`). A literal copied
+ * into any of them is a second source that drifts the day the assumption changes — a center roster would then assume one window while
+ * the env model assumes another, and the operator-facing default note would name a third.
+ *
+ * This is a conservative CEILING GUESS, not a measurement: the engine needs a window to size its compaction trigger and the tool-schema
+ * defer threshold, and an undeclared window must never be read optimistically — so every model that reaches the engine carries SOME window,
+ * declared or this one (a catalog entry may omit `contextWindow`; the readers above fill it). Whether the value is conservative for a
+ * given model is a per-model question this constant does not answer.
+ *
+ * Pure leaf: no imports.
+ */
+export declare const ASSUMED_CONTEXT_WINDOW = 262144;
+//# sourceMappingURL=model-context-window.d.ts.map

package/dist/model-context-window.js

@@ -0,0 +1,2 @@
+export const ASSUMED_CONTEXT_WINDOW = 262144;
+//# sourceMappingURL=model-context-window.js.map

package/dist/model-entry-headers.d.ts

@@ -1,3 +1,44 @@
+/**
+ * [ref](7.108.0;cli [ref] [ref],server [ref] ② 认领)—— 模型目录条目 `headers`:**部署 ↔ 供应商**的附加请求头。
+ * 本模块是它的**唯一判据点**(白名单 + 形)与**唯一铸点**(铸进 core `Model.headers` 的那张袋)。
+ *
+ * ## 病
+ * core 的三只一方 brain 早有附加头的座(构造项 `headers` 与 per-model 的 `Model.headers`,三只 adapter 都按
+ * `mergeHeaders(model.headers, config.headers, options.headers)` 合并;anthropic 腿再把 `anthropic-beta` 与它自己的 beta
+ * 按 core [ref] 的读并合并律并成一个头),本仓零读点 ⇒ 壳的 `--betas` / `ANTHROPIC_BETAS`(开 1M 上下文等 beta)进不了引擎发出的请求。
+ *
+ * ## 座位:per-model(`Model.headers`),不是 per-route(brain 构造项 `headers`)
+ * 目录条目是**一只模型**的声明;brain 构造项的那个袋是**整条路由**共享的(一台部署一只 anthropic brain,所有 anthropic 条目都走它)——
+ * 放在那里会把一条条目的 beta 发给同路由的每一只模型。core 的 per-model 座就是为这件事开的(`Model.headers`,core 型面注:
+ * 「Cannot override auth / content-type / version」—— 鉴权头与结构头在合并之后由 brain 硬锁)。
+ *
+ * ## 白名单:闭集,每个名字带「读它的线路」({@link CATALOG_ENTRY_HEADER_LANES})
+ *  · 名字闭集 —— 表外一律拒。这不是洁癖,是**凭据轴**:`Model.headers` 上的 `authorization` / `x-api-key` 会被 core 的配对法读成
+ *    per-model 凭据(「构造即配对」,off-root 也放行),等于在托管钥匙(`sealedApiKey` / `apiKeyEnv`)之外开一条明文凭据的路;
+ *    路由 / 追踪类头同理是部署的事,要一条一条想清楚再进表。
+ *  · 只认**规范拼写**(小写):HTTP 头名大小写不敏感,两种拼法并存 = 同一只袋里两个写者;`Anthropic-Beta` 按表外拒(拒句给出规范拼写)。
+ *  · 名字带线路:`anthropic-beta` 只有 Anthropic Messages 线路读(`api: "anthropic-messages"`)。声明在不读它的条目上 ⇒ 拒 ——
+ *    否则运维以为开了 1M 上下文、请求发出去什么都没变(一个只声明不生效的旋钮,正是本仓 `model_compat_dropped` 那一族立案的病)。
+ *  · 值:可见 ASCII(首尾非空白,中间可有空格),≤ {@link MAX_HEADER_VALUE_CHARS} —— CR / LF / NUL 这类会让传输层在每次请求时才抛的值
+ *    在配置期就拒;值**逐字**透传(不改大小写、不去重 —— 合并是 core 的事)。
+ *
+ * ## 坏声明的方向:条目整条不可用(`config.model_entry_invalid`),不是「丢头、条目照常」
+ * 与 `compat` 的降级通道刻意分歧:本座一半是凭据轴(表外名字里有鉴权头),另一半是「运维以为生效了」—— 丢头照常服务正是修前的病形。
+ * 执法点 = [ref] 的逐条判据 `judgeCatalogEntry`(同一个码、同一条 warn、同一条「显式选中它 ⇒ `request.model_unavailable`」的路),
+ * 其余条目照常服务。拒因与 warn **只回显名字**(过 {@link displayHeaderName}),从不回显值。
+ *
+ * ## 两条读腿今天到不了这里(候裁「settings-schema `ModelEntry` 加 `headers`」,[ref] 字段归 server 自持)
+ * settings-schema 6.3.0 的 `ModelEntry` 没有这个键 ⇒ 远端 `readEffectiveWire` 与本地 `FileConfigStore` 都 strip 它(并报未知键)。
+ * 本模块服务的输入今天只有绕过读腿的那几条(盘上 LKG / 手写 effective);字段进 schema 之日,`config-provider.ts` 的本地投影加一行即通,
+ * `test/catalog-entry-headers.test.ts` 的 🚧 [ref]-schema 两格翻红逼销账。**词表不在 schema 里另抄一份**:schema 的那个键应当是
+ * 承载形(与 `compat` 同一种 parse-transparent + 自由形安全判),判据仍是本模块这一处 —— 或者整张表搬进 schema、本仓 import;
+ * 二选一候裁,不许两处各有一份。
+ *
+ * 依赖纪律:叶(只 type-import core、值引 `trace/redact.ts` 的名字回显尺)。
+ */
+import type { Model } from "@sema-agent/core";
+/** 条目的线路词(core `Model["api"]`,不手抄)。 */
+type ModelApi = Model["api"];
 /**
  * 白名单 = 名字 → 读它的线路(闭集;**加一个名字 = 加一行并写明哪条线路读它、为什么是部署的事**)。
  * `anthropic-beta`:Anthropic Messages 的 beta 开关(逗号分隔的 beta 名;core anthropic 腿会把自己的 beta 并进同一个头)。
@@ -28,17 +69,18 @@ export type CatalogEntryHeadersVerdict = {
     readonly issue: string;
 };
 /**
- * **唯一判据**:条目的 `headers` 原值(`unknown`:承载形,不信类型)+ 条目的线路词原值(`api`;两条读腿恒补齐它,
- * 绕过读腿的输入缺它 ⇒ 按「没有线路读它」拒 —— 判据与铸点读同一个原值,不另补一份 schema 缺省)。
+ * **唯一判据**:条目的 `headers`(`unknown`:承载形,不信类型)+ 条目的线路词(`api`)—— 两者都取判官那一次 settings-schema 解析的读数
+ * (缺席的 `api` 即 schema 的缺省),判据与铸点读同一只值,见 `judgeCatalogEntry`。
  * 整只判:任一名字 / 值不合 ⇒ 整只不收(留下好的那几个 = 让运维以为整袋生效了)。坏字段逐个列出(`headers.<名>`)。
  */
-export declare function readCatalogEntryHeaders(raw: unknown, api: unknown): CatalogEntryHeadersVerdict;
+export declare function readCatalogEntryHeaders(raw: unknown, api: ModelApi): CatalogEntryHeadersVerdict;
 /**
  * **唯一铸点**(`toModel` 调):判过的袋 → `Model.headers` 的键。缺席 ⇒ 不铸键(一个 `undefined` 值的键也不铸:
  * 缺席只有一种拼法)。判不过 ⇒ **抛**:到这里的条目已经过 [ref] 逐条判据(判不过的进 `modelRefusals`、到不了 `toModel`),
  * 抛 = 两处判据分叉了,stage 整候选拒、响亮,不静默丢头。
  */
-export declare function buildModelHeadersKey(entryName: string, raw: unknown, api: unknown): {
+export declare function buildModelHeadersKey(entryName: string, raw: unknown, api: ModelApi): {
     headers?: Record<string, string>;
 };
+export {};
 //# sourceMappingURL=model-entry-headers.d.ts.map

package/dist/model-entry-headers.js

@@ -35,9 +35,9 @@ export function readCatalogEntryHeaders(raw, api) {
             continue;
         }
         const lanes = CATALOG_ENTRY_HEADER_LANES[name];
-        if (typeof api !== "string" || !lanes.includes(api)) {
+        if (!lanes.includes(api)) {
             fields.push(field);
-            issues.push(`${field}: only read on the ${lanes.join(" / ")} lane — this entry ${typeof api === "string" ? `is api "${api}"` : "declares no api"}, where the header would be sent and do nothing`);
+            issues.push(`${field}: only read on the ${lanes.join(" / ")} lane — this entry is api "${api}", where the header would be sent and do nothing`);
             continue;
         }
         if (typeof value !== "string" || value.length > MAX_HEADER_VALUE_CHARS || !HEADER_VALUE_SHAPE.test(value)) {

package/dist/model-entry-refusal.d.ts

@@ -1,4 +1,4 @@
-import { type ModelEntryRefusalCode, type ModelPlaneRefusalCode, type ModelRefusalsSignal } from "@sema-agent/settings-schema";
+import { ModelEntry, type ModelEntryRefusalCode, type ModelPlaneRefusalCode, type ModelRefusalsSignal } from "@sema-agent/settings-schema";
 import { type DroppedCatalogEntry } from "./web-admin-client/read-warnings.js";
 import { type ModelTableLeg } from "./model-select.js";
 import type { CandidateRejectionNote } from "./web-admin-client/candidate-gate.js";
@@ -41,31 +41,38 @@ export interface CatalogEntryVerdictCtx {
     /** anthropic 路由装上了没有(= `config.anthropic` 在场,`createBrain` 同判)。 */
     readonly anthropicRouteMounted: boolean;
 }
-/** 条目最小读面(`CenterModel` 与本地投影都结构满足;形判走 settings-schema,不信这张型)。 */
+/** 条目的承载形最小读面(`CenterModel` 与本地投影都结构满足)。判据只从 settings-schema 的那一次解析读条目;承载形上只读拒因的键
+ *  (`name`)与形判不过时拒因句要的身份(`id` / `provider`,按 `typeof` 读,不信这张型)。 */
 export interface CatalogEntryLike {
     readonly name: string;
     readonly id: string;
     readonly provider: string;
-    /** [ref]:线路词(`headers` 的线路判据读它;原值,不信这张型)。 */
-    readonly api?: unknown;
-    /** [ref]:供应商附加头的承载形(`unknown`:判据在 `model-entry-headers.ts`,不信这张型)。 */
-    readonly headers?: unknown;
-    /** 引擎已退役的每模型引导句(core 7.56.0 [ref];settings-schema 的 `ModelEntry` 仍收它)—— 只读在场与否,见 {@link judgeCatalogEntry}。 */
-    readonly promptGuidance?: unknown;
 }
+/** 一条条目的判决:可用 ⇒ 判官那一次 settings-schema 解析读出的条目(**铸点只从它铸 Model** —— 判与铸读同一只值);不可用 ⇒ 拒因。 */
+export type CatalogEntryVerdict = {
+    readonly ok: true;
+    readonly entry: ModelEntry;
+} | {
+    readonly ok: false;
+    readonly refusal: ModelEntryRefusal;
+};
 /**
- * **逐条判据**:`undefined` = 本部署能完整服务它。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。
+ * **逐条判据**:`ok` = 本部署能完整服务它(连同判出它的那一份读数)。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。
  * 形分两段、同一个码(`config.model_entry_invalid`):settings-schema 的 `ModelEntry`,再是 [ref] 的 `headers`(白名单 + 线路 + 值形,
  * 判据单属主 `model-entry-headers.ts`;settings-schema 6.3.0 的 `ModelEntry` 还没有这个键 —— 候裁加字段,届时词表不另抄)。
  *
- * 形判的属主是 settings-schema 的 `ModelEntry`(两条读腿用的就是它)—— 本仓不手抄任何一条字段规则;这里只是
- * 在第二道边界(绕过读腿的输入)上**再问一次同一个属主**,并把答案变成一条带码的拒因。只取 `success` 与 issue
- * 坐标,不取它的输出(输出会补缺省、剥扩展键,那是读腿的事)。
+ * 形判的属主是 settings-schema 的 `ModelEntry`(两条读腿用的就是它)—— 本仓不手抄任何一条字段规则;这里在第二道边界(绕过读腿的
+ * 输入)上**再问一次同一个属主**:不过 ⇒ 一条带码的拒因;过 ⇒ 它的输出就是这条条目**唯一的读数**,其后的每一判与铸点都读它。
+ *
+ * **一种读法**:两条读腿交来的条目本就是这份输出;绕过读腿的输入(盘上被手改的 LKG、手写 effective、夹具)在这里得到同一份 ——
+ * schema 补的缺省(`api` / `tier` / `provider` / `quotaWeight` …)随这一次读法进 Model,不存在「判按缺省、铸按原值」的第二读法
+ * (修前:缺 `api` 的条目形判放行、铸点按原值读 ⇒ 整只候选 stage 抛;缺 `tier` 的条目铸出无 `params.tier` 的 Model,按档位选的缺省选不中 ⇒ 模型面整组拒)。
  */
-export declare function judgeCatalogEntry(m: CatalogEntryLike, ctx: CatalogEntryVerdictCtx): ModelEntryRefusal | undefined;
+export declare function judgeCatalogEntry(m: CatalogEntryLike, ctx: CatalogEntryVerdictCtx): CatalogEntryVerdict;
 /** 一批已启用条目的判决:可用的(保序)、不可用的(按 catalog name)、被丢目录条目的载体行(形对的,保序),以及形不对的载体行(坐标)。 */
-export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
-    readonly usable: readonly M[];
+export interface CatalogEntriesVerdict {
+    /** 可用条目判官那一次 schema 解析的读数(保序)—— 模型面 stage 只从这里铸 Model(承载形不再被读)。 */
+    readonly usable: readonly ModelEntry[];
     /** 键 = catalog name(**每一个**名,含秘密形 / 空串 / `__proto__`:引擎自己的判决保持完整 —— [ref] 不变量与选择面的「让出」都读它;
      *  名筛只在出口,见 {@link buildModelRefusalsSignal})。键以自有数据属性写入(`__proto__` 不走原型 setter)。 */
     readonly refused: Readonly<Record<string, ModelEntryRefusal>>;
@@ -76,6 +83,12 @@ export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
     /** [ref]:载体里形对的行(保序)—— 模型面 stage 把它与 `models` 同 commit 进 `config.droppedCatalogEntries`(`GET /v1/models.droppedEntries`
      *  的源):载体只在这里被判形、被读一次,墓碑与 wire 读的是同一批行。 */
     readonly dropped: readonly DroppedCatalogEntry[];
+    /**
+     * **这份候选管不管模型面** —— 唯一判决位(铸在这里一次;模型面 stage 的捷径、dry-run 的 `wouldOverrideModels`、世代账的模型面结局都读它,
+     * 墓碑判据与它读同一个行谓词 {@link droppedRowEnabled})。管 ⇔ 有一条启用条目(幸存的,或被读腿丢掉的 —— 有名无名都算),或载体形不对
+     * (改过的行原本代表谁说不清,按「管」判、随后组拒,fail-closed)。不管 ⇒ 上一代 / env 继续服务,不是拒。
+     */
+    readonly manages: boolean;
 }
 /**
  * 批量形(模型面 stage 与 dry-run 共用这一只 —— 报数与真 apply 永不撕裂)。
@@ -90,7 +103,7 @@ export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
  *    秘密形或非标识符,被扣下的名字无从被铸出;代价只是显式点它的请求拿到「未知模型」而不是 `request.model_unavailable`。
  * 与一条可用 / 已判不可用条目同名时不覆盖(可用条目仍可用;同名撞车由不变量 `refused-names-not-minted` 响亮拒)。
  */
-export declare function judgeCatalogEntries<M extends CatalogEntryLike>(enabled: readonly M[], ctx: CatalogEntryVerdictCtx, dropped?: unknown): CatalogEntriesVerdict<M>;
+export declare function judgeCatalogEntries(enabled: readonly CatalogEntryLike[], ctx: CatalogEntryVerdictCtx, dropped?: unknown): CatalogEntriesVerdict;
 /** [ref]:一次 apply 对「最新交到手的那份候选目录」的模型拒因判决(纯数据;`ApplyReport.modelRefusals`)。 */
 export interface ModelRefusalVerdict {
     /** 那份候选的逐条判决(键 = catalog name,**完整**,未过名筛 —— 名筛在出口 {@link buildModelRefusalsSignal})。 */
@@ -133,6 +146,12 @@ export declare function echoModelRef(ref: string): string;
  * 别名段(`(catalog entry …)`)的判断读原形:ref 与条目名逐字相同 ⇒ 不带,不因回显截短而误判成「另有条目」。
  */
 export declare function modelUnavailableMessage(field: string, requested: string, name: string, r: ModelEntryRefusal): string;
+/**
+ * 一次**用户选择**(显式 ref / `@name` / `compactionModel`)落在 `models.atMention` 许可之外时的拒因句 —— HTTP `request.model_not_allowed` 的 `error`
+ * 与 run-local 的 stderr 同一句(与 {@link modelUnavailableMessage} 同一种铸法:`field` = 调用方的通道名,`requested` = 原形,本函数回显时过 {@link echoModelRef};
+ * `resolved` = 选择归一到的目录名,即这次真会跑的那只)。
+ */
+export declare function modelNotAllowedMessage(field: string, requested: string, resolved: string): string;
 /** 缺省模型不变量读的切面(`ServiceConfig` 与 `CrossInvariantView` 都结构满足;可选成员缺席 = 没有被拒的候选)。 */
 export interface DefaultModelView {
     readonly models: Readonly<Record<string, unknown>>;

package/dist/model-entry-refusal.js

@@ -26,36 +26,43 @@ export function judgeCatalogEntry(m, ctx) {
     const shape = ModelEntry.safeParse(m);
     if (!shape.success) {
         const fields = describeSchemaIssueFields(shape.error);
-        return entryInvalidRefusal(typeof m.id === "string" ? m.id : "", typeof m.provider === "string" ? m.provider : "", fields, describeSchemaIssues(shape.error) ?? fields.join(", "));
+        return { ok: false, refusal: entryInvalidRefusal(typeof m.id === "string" ? m.id : "", typeof m.provider === "string" ? m.provider : "", fields, describeSchemaIssues(shape.error) ?? fields.join(", ")) };
     }
-    const headers = readCatalogEntryHeaders(m.headers, m.api);
+    const e = shape.data;
+    const headers = readCatalogEntryHeaders(e.headers, e.api);
     if (!headers.ok)
-        return entryInvalidRefusal(m.id, m.provider, headers.fields, headers.issue);
-    if (Array.isArray(m.promptGuidance) && m.promptGuidance.length > 0) {
+        return { ok: false, refusal: entryInvalidRefusal(e.id, e.provider, headers.fields, headers.issue) };
+    if (e.promptGuidance !== undefined && e.promptGuidance.length > 0) {
         return {
-            ...refusalCause("config.model_entry_invalid"),
-            id: m.id,
-            provider: m.provider,
-            fields: ["promptGuidance"],
-            detail: "the catalog entry carries per-model guidance sentences (promptGuidance), which the engine no longer delivers — the entry is not served here " +
-                "rather than served with its sentences silently dropped; move each sentence into a center or deployment prompt overlay on the behavior band " +
-                "and remove promptGuidance from the entry to bring it back",
+            ok: false,
+            refusal: {
+                ...refusalCause("config.model_entry_invalid"),
+                id: e.id,
+                provider: e.provider,
+                fields: ["promptGuidance"],
+                detail: "the catalog entry carries per-model guidance sentences (promptGuidance), which the engine no longer delivers — the entry is not served here " +
+                    "rather than served with its sentences silently dropped; move each sentence into a center or deployment prompt overlay on the behavior band " +
+                    "and remove promptGuidance from the entry to bring it back",
+            },
         };
     }
-    const lane = catalogBrainLane(m.provider);
+    const lane = catalogBrainLane(e.provider);
     const mount = laneMount(lane, ctx);
     if (!mount.mounted) {
         return {
-            ...refusalCause("config.model_no_brain"),
-            id: m.id,
-            provider: m.provider,
-            fields: [],
-            detail: `provider "${m.provider}" rides the ${lane} brain, which is not mounted on this deployment — the entry is not served here ` +
-                `(it is never routed to another brain with its own key); set ${mount.how}, ` +
-                'or change the entry\'s provider to an OpenAI-compatible route ("gateway" / "vllm") with its own baseUrl',
+            ok: false,
+            refusal: {
+                ...refusalCause("config.model_no_brain"),
+                id: e.id,
+                provider: e.provider,
+                fields: [],
+                detail: `provider "${e.provider}" rides the ${lane} brain, which is not mounted on this deployment — the entry is not served here ` +
+                    `(it is never routed to another brain with its own key); set ${mount.how}, ` +
+                    'or change the entry\'s provider to an OpenAI-compatible route ("gateway" / "vllm") with its own baseUrl',
+            },
         };
     }
-    return undefined;
+    return { ok: true, entry: e };
 }
 function entryInvalidRefusal(id, provider, fields, issues) {
     return {
@@ -67,6 +74,9 @@ function entryInvalidRefusal(id, provider, fields, issues) {
             "deployment's catalog on its own (the other entries keep serving) instead of being served with a value nothing validated; fix the entry to bring it back",
     };
 }
+function droppedRowEnabled(row) {
+    return row.identity?.enabled !== false;
+}
 const MALFORMED_CARRIER_NOT_A_LIST = "(droppedCatalogEntries is not a list)";
 export function judgeCatalogEntries(enabled, ctx, dropped) {
     const usable = [];
@@ -75,15 +85,15 @@ export function judgeCatalogEntries(enabled, ctx, dropped) {
         Object.defineProperty(refused, name, { value: r, enumerable: true, writable: true, configurable: true });
     };
     for (const m of enabled) {
-        const r = judgeCatalogEntry(m, ctx);
-        if (r === undefined)
-            usable.push(m);
+        const v = judgeCatalogEntry(m, ctx);
+        if (v.ok)
+            usable.push(v.entry);
         else
-            mint(String(m.name), r);
+            mint(String(m.name), v.refusal);
     }
     const rows = dropped === undefined ? [] : Array.isArray(dropped) ? dropped : undefined;
     if (rows === undefined)
-        return { usable, refused, malformed: [MALFORMED_CARRIER_NOT_A_LIST], dropped: [] };
+        return { usable, refused, malformed: [MALFORMED_CARRIER_NOT_A_LIST], dropped: [], manages: true };
     const malformed = [];
     const carried = [];
     for (const d of rows) {
@@ -95,13 +105,13 @@ export function judgeCatalogEntries(enabled, ctx, dropped) {
         }
         carried.push(row.data);
         const { identity } = row.data;
-        if (identity?.name === undefined || identity.enabled === false)
+        if (!droppedRowEnabled(row.data) || identity?.name === undefined)
             continue;
         if (Object.hasOwn(refused, identity.name))
             continue;
         mint(identity.name, entryInvalidRefusal(identity.id ?? "", "", row.data.fields, row.data.issues));
     }
-    return { usable, refused, malformed, dropped: carried };
+    return { usable, refused, malformed, dropped: carried, manages: enabled.length > 0 || malformed.length > 0 || carried.some(droppedRowEnabled) };
 }
 export function buildModelRefusalsSignal(v) {
     if (v === undefined)
@@ -152,6 +162,9 @@ export function modelUnavailableMessage(field, requested, name, r) {
     const alias = requested === name ? "" : ` (catalog entry "${name}")`;
     return `${field} "${echoModelRef(requested)}"${alias} is published in the catalog but unavailable on this deployment [${r.code}] — ${r.detail}`;
 }
+export function modelNotAllowedMessage(field, requested, resolved) {
+    return `${field} "${echoModelRef(requested)}" is not @-mentionable on this deployment (it resolves to catalog model "${resolved}") — which models can be @-mentioned is configured by the operator (models.atMention)`;
+}
 function candidateFellBackClause(notes) {
     if (notes === undefined || notes.length === 0)
         return "";

package/dist/model-plane-face.d.ts

@@ -23,13 +23,18 @@
  *  · `refusalCode` / `gap` —— **起服路由判官对当前 config 的判决**:`judgeServedModelRoute` 同一只函数(装配第 2 段与 `run-local` 调的就是它),通过 ⇒ 两键缺席。
  *    进程既然起来了,正常是缺席;测试夹具 / 自建装配 / 不拒启的入口可能在场 —— 如实投,不替它们编造通过。**不带句子**(拒因句只走日志与起服错误)。
  *
- * ## 只在起服后可答
- * 读面挂在运行中的进程上;判官必须在目录应用之后调(`judgeServedModelRoute` 头注),起服前没有「将要服务的表」,所以没有起服前的预判口。
+ * ## 两条读路,一只读口
+ * 判官必须在目录应用之后调(`judgeServedModelRoute` 头注):「将要服务的表」在装配第 2 段末才定形。读这一格的只有 {@link readModelPlaneFace} 一只,两条读路各调一次:
+ *  · 起服后 —— `GET /v1/models` 的 `modelPlane`(`http/routes/capabilities.ts`;座经 `ServiceDeps` 的两只取值口转到 web-admin 运行时);
+ *  · 起服前 —— 无监听探针 `model-plane-probe.ts`:跑**同一对**装配段(`runStage01` → `runStage02`)到模型表定形即停,同一只读口读同一个运行时的座,stdout 一行。
+ * 两路读同一批事实、同一只铸点 ⇒ 同一份部署配置、同一时点(第 2 段末;起服拉取超窗时那一份迟到的候选两路都还没采纳)两路的 JSON 字节同;
+ * 壳不再需要起服前的第二份判官。
  */
 import type { ModelPlaneRefusalCode } from "@sema-agent/settings-schema";
 import { type ModelRouteEndpointVerdict, type ModelRouteGap, type ServedModelRouteView } from "./model-route-endpoint.js";
 import { type ModelTableLeg } from "./model-select.js";
 import type { CandidateRejection } from "./web-admin-client/candidate-gate.js";
+import { type ServiceConfig } from "./config.js";
 /** `modelPlane.catalog` 的闭集(消费方用穷举 switch —— 加一词不补臂 ⇒ 编译红)。 */
 export declare const CATALOG_STANCES: readonly ["absent", "adopted", "refused"];
 export type CatalogStance = (typeof CATALOG_STANCES)[number];
@@ -44,14 +49,17 @@ export interface ModelPlaneFace {
     /** 最新到达的目录候选被模型面组拒的码(见文件头;缺席 ⇔ 最新到达的候选没有被模型面组拒)。 */
     readonly planeRefusalCode?: ModelPlaneRefusalCode;
 }
-/** {@link buildModelPlaneFace} 读的进程事实(都由调用方从各自的座取,本函数不碰任何全局)。 */
-export interface ModelPlaneFacts {
-    /** 严格名册布防(`isRosterGateArmed`):env 表是占位、不被判(装配第 2 段传的是同一只谓词)。 */
-    readonly envTableIsPlaceholder: boolean;
-    /** 候选判官最近一次整拒的结论座(`WebAdminRuntime.candidateRejectionState()`);座空 / 没有配置管道 ⇒ `undefined`。 */
-    readonly candidateRejection: CandidateRejection | undefined;
-    /** 最新到达的目录候选被模型面组拒的码(`WebAdminRuntime.latestPlaneRefusalState()`);没有 / 没有配置管道 ⇒ `undefined`。 */
-    readonly latestPlaneRefusal: ModelPlaneRefusalCode | undefined;
+/**
+ * 模型面读数取事实的两只座 —— 结构上就是 web-admin 运行时(`WebAdminRuntime`)的同名两只取值口:起服前探针递运行时本身,`GET /v1/models` 递 `ServiceDeps`
+ * (装配第 10 段把这两只接成 `() => webAdmin.<同名>()`)。没有配置管道的装配(纯 env 夹具 / 自建装配)两只都缺席 ⇒ 读作「没有整拒」。
+ */
+export interface ModelPlaneSeats {
+    readonly candidateRejectionState?: () => CandidateRejection | undefined;
+    readonly latestPlaneRefusalState?: () => ModelPlaneRefusalCode | undefined;
 }
-export declare function buildModelPlaneFace(config: ServedModelRouteView, facts: ModelPlaneFacts): ModelPlaneFace;
+/**
+ * `modelPlane` 的**唯一读口**(起服后的 HTTP 路由与起服前的探针各调一次,见文件头「两条读路,一只读口」):进程事实只在这里取齐 ——
+ * 名册布防读 `isRosterGateArmed(config.webAdmin)`(装配第 2 段的路由判官传的同一只谓词),两只座读调用方递来的运行时取值口 —— 再交铸点。
+ */
+export declare function readModelPlaneFace(config: ServedModelRouteView & Pick<ServiceConfig, "webAdmin">, seats: ModelPlaneSeats): ModelPlaneFace;
 //# sourceMappingURL=model-plane-face.d.ts.map

package/dist/model-plane-face.js

@@ -1,5 +1,6 @@
 import { judgeServedModelRoute } from "./model-route-endpoint.js";
 import { servedModelTableLeg } from "./model-select.js";
+import { isRosterGateArmed } from "./config.js";
 export const CATALOG_STANCES = ["absent", "adopted", "refused"];
 function catalogStanceOf(served, wholeRefused) {
     if (wholeRefused)
@@ -11,7 +12,14 @@ function catalogStanceOf(served, wholeRefused) {
             return "absent";
     }
 }
-export function buildModelPlaneFace(config, facts) {
+export function readModelPlaneFace(config, seats) {
+    return buildModelPlaneFace(config, {
+        envTableIsPlaceholder: isRosterGateArmed(config.webAdmin),
+        candidateRejection: seats.candidateRejectionState?.(),
+        latestPlaneRefusal: seats.latestPlaneRefusalState?.(),
+    });
+}
+function buildModelPlaneFace(config, facts) {
     const servedTable = servedModelTableLeg(config);
     const wholeRefused = facts.candidateRejection !== undefined || facts.latestPlaneRefusal !== undefined;
     const verdict = judgeServedModelRoute(config, { envTableIsPlaceholder: facts.envTableIsPlaceholder });

package/dist/model-plane-probe.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-plane-probe.d.ts.map

package/dist/model-plane-probe.js

@@ -0,0 +1,17 @@
+import { fatalExit } from "./boot/fatal-exit.js";
+import { runStage01 } from "./boot/stage-01-config.js";
+import { runStage02 } from "./boot/stage-02-web-admin-pull.js";
+import { readModelPlaneFace } from "./model-plane-face.js";
+import { reserveStdoutForAnswer, writeCliResult } from "./observability/logger.js";
+async function probe() {
+    reserveStdoutForAnswer();
+    const s02 = await runStage02(runStage01());
+    const answer = JSON.stringify(readModelPlaneFace(s02.config, s02.webAdmin));
+    await s02.webAdmin.stopRefreshLoop();
+    await writeCliResult(answer);
+    process.exit(0);
+}
+void probe().catch((err) => {
+    fatalExit(err);
+});
+//# sourceMappingURL=model-plane-probe.js.map

package/dist/model-provider.d.ts

@@ -120,9 +120,9 @@ export declare function routeTableOf<R extends object>(view: {
  * 所以答案映到本仓两词闭集:`"anthropic"` ⇒ anthropic 腿,`undefined` ⇒ 网关腿;别的名字结构上不可能(表里没有那个键),真撞上 ⇒ **响亮抛**([ref]:运行期
  * miss 臂必须说出来,不静默折网关)。
  *
- * [ref](7.101.0):**目录条目**到不了「anthropic 词、路由没装」这一格 —— 模型面 stage 的逐条判据把它判成不可用(`config.model_no_brain`,那一判问的是
- * 「词想要的腿装没装」,{@link catalogBrainLane},与本判词是两个问题)。这一格今天只剩 **env 腿**:`MODEL_PROVIDER=anthropic` 而没配 anthropic 凭据的部署,
- * env 模型落网关腿、用的是网关自己的 `MODEL_API_KEY`(凭据与端点同属网关,不越界)。
+ * 「词想要的腿」({@link catalogBrainLane})与本判词的答案不是同一条的那一格(anthropic 词、路由没装)**不被服务**:目录条目在模型面 stage 的逐条判据里判成
+ * 不可用(`config.model_no_brain`);env 表在起服路由判官那里整表拒(`model-route-endpoint.ts`,缺口 `lane_credential_missing`,网关在不在都拒)。
+ * 所以到得了派发面的条目,词与本判词恒同一条;这里把 `undefined` 读成网关腿,是引擎路由器 fallback 的逐字转写,不是对那一格的放行。
  */
 export declare function brainLaneFor(provider: string | undefined, routes: Readonly<Record<string, unknown>>): ModelBrainLane;
 //# sourceMappingURL=model-provider.d.ts.map

package/dist/model-route-endpoint.d.ts

@@ -13,6 +13,9 @@
  * **`MODEL_GATEWAY_BASEURL` 没有出厂缺省;配置能派发到的每一条 openai 兼容路由,都必须解析到一个显式配置的
  * base URL(路由自己的 `baseUrl`,或显式设了的网关),否则拒。** 附带一条同类:备用网关
  * (`MODEL_GATEWAY_FALLBACK_URLS`)是主网关的镜像,没有主就没有镜像 ⇒ 拒。
+ * 同一只判官的第二条:**一条条目的 provider 词想要的腿(`catalogBrainLane`)与引擎路由器对本部署路由表的答案(`brainLaneFor`)不是同一条 ⇒ 拒**
+ * (今天只有一形:`anthropic` 词而 anthropic 路由没装)—— 词与实际线路只许一种说法:不把它交给网关腿冒名服务(网关拿自己的钥匙、自己的线路格式与
+ * 缓存口径答它,而条目行上的 `api` / 缓存族仍按词写),网关在不在都一样。
  *
  * ## 执法点(判据只在这里,执法点在调用处 —— 与 [ref] `gateway-url-userinfo` 同形)
  * **判官只判「将要服务的那张表」,拒因句按视图说真话**(视图词 = {@link ModelTableLeg} 两词,进判据入参,不靠调用方拼句):
@@ -21,7 +24,7 @@
  *    严格名册布防(`isRosterGateArmed`)时 env 表是占位、从不被派发 ⇒ 不判它(备用网关那一条与表无关,照判)。
  *    不在 `loadConfig()`:那是目录应用**之前**,env 表还不知道会不会服务(目录一旦采纳就整张换掉它);
  *  · 壳 / 包问「这台引擎服务哪张表、起服判官怎么说」读 `GET /v1/models` 的 `modelPlane`(`model-plane-face.ts`,同一只 {@link judgeServedModelRoute});
- *    起服前没有「将要服务的表」可判,所以没有起服前的预判口;
+ *    引擎起来之前读无监听探针(`model-plane-probe.ts`:跑同一对装配段到模型表定形即停,同一只读口)—— 不另设起服前的第二判官;
  *  · 热路径:`web-admin-client/apply-effective.ts` 的模型面 stage ⇒ 模型面组拒(opus 腿 O3:同候选其余组照落)、上一代模型面继续服务(目录视图);
  *  · run-local:配置源解析完之后按真要派发的表判(`run-local.ts`)—— 本入口没有名册门,不豁免占位;
  *  · 登记:`config-invariants.ts` 的 `model-route-endpoint` 条(表的「不许有表外不变量」职责);
@@ -49,8 +52,8 @@ export declare const GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE = "config.gateway_fal
  *  · `endpoint_missing` —— 缺的是网关端点:openai 兼容腿上的条目解析不到 base URL(或备用网关设了、主网关没设);
  *    出路 = 设 `MODEL_GATEWAY_BASEURL`,或(目录视图)给条目自己的 `baseUrl` / (env 视图)挂 anthropic 路由、或不设 `MODEL_ID` 让目录缺省服务;
  *  · `lane_credential_missing` —— 缺的是**车道凭据**:条目的 provider 词是 `anthropic`(用户选的是 anthropic 车道),
- *    却因 `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` 都没有而没装上 anthropic 路由、落进了 openai 腿,那条腿又没有端点;
- *    出路 = 补那两把钥匙之一(设网关是另一条出路,拒因句一并给)。
+ *    却因 `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` 都没有而没装上 anthropic 路由 —— 词想要的腿与路由器会给的腿不是同一条,网关在不在都拒;
+ *    出路 = 补那两把钥匙之一,或把词改成 openai 兼容腿的词(env 视图:`MODEL_PROVIDER=gateway`;目录视图:条目的 provider),拒因句一并给。
  *
  * **声明序 = 语义序**;加一词 ⇒ 所有穷举 switch 当场编译红。
  */
@@ -94,8 +97,9 @@ export interface ModelRouteEndpointView {
  *
  * 判序即语义:
  *  ① 备用网关设了、主网关没设 ⇒ `config.gateway_fallback_without_primary`(备用是主的镜像,这一条与条目无关,先说);
- *  ② 逐条目:按 {@link brainLaneFor}(引擎路由器对本部署路由表的答案)落 openai 腿、且 {@link openaiRouteBaseUrl} 解析不到 ⇒ 收集名字,
- *     一句话**全部点名**(运维一次改完,而不是改一个撞下一个)。
+ *  ② 逐条目:词想要的腿({@link catalogBrainLane})≠ 引擎路由器对本部署路由表的答案({@link brainLaneFor})⇒ 收进「车道没装」一组;
+ *     其余落 openai 腿、且 {@link openaiRouteBaseUrl} 解析不到 ⇒ 收进「端点缺」一组。两组一句话**全部点名**(运维一次改完,而不是改一个撞下一个),
+ *     车道没装的一组在前(缺口词 `lane_credential_missing`)。
  *
  * `default` 键是目录里另一条的别名(env 腿 `{default: m, [m.id]: m}`、center 腿 `models.default = models[picked]`),
  * 与别的键指同一只对象时不重复点名;只有它一个键时(手搓夹具)照样点名 `default`。