@sema-agent/server 7.147.0 → 7.149.0

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` = 本部署能完整服务它。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。
- * 形分两段、同一个码(`config.model_entry_invalid`):settings-schema 的 `ModelEntry`,再是 [ref] 的 `headers`(白名单 + 线路 + 值形,
+ * **逐条判据**:`ok` = 本部署能完整服务它(连同判出它的那一份读数)。判序即语义:先形(不合形的条目谈不上走哪条腿),再腿。
+ * 形分三段、同一个码(`config.model_entry_invalid`):settings-schema 的 `ModelEntry`,再是 [ref] 的名字(凭据形的名不收,见 {@link credentialNameRefusal}),再是 [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})。 */
@@ -101,9 +114,9 @@ export interface ModelRefusalVerdict {
 /**
  * [ref] —— 判决 → `/health.modelRefusals` 与 fleet 心跳 `modelRefusals` 的 wire 形(settings-schema `ModelRefusalsSignal`,纯投影):
  * 名 → 码,**值只码**(拒因事实里的上游 id / provider 词 / 坏字段键 / 出路句都不上 wire —— `entry_invalid` 行是没人验过的行,id / provider
- * 可能就是坏行原样;句子是给本机运维的散文,不是契约)。**名筛在这里、只在这里**:键过 settings-schema `isReportableRefusalName`(唯一判据,
- * import 不复制;6.3.0 起 = 标识符白名单 ∧ 无密钥形 ∧ 无 URL userinfo)—— 秘密形 / 空串 / `__proto__` / 不是标识符的串这类出不了门的名不进键、
- * 不计数;引擎内部的判决不受影响;本机日志 / 拒因句里的写名同样先问这一只([ref],{@link disclosableRefusalName}:不可披露的名只写码)。
+ * 可能就是坏行原样;句子是给本机运维的散文,不是契约)。**名筛在这里、只在这里**:键过 {@link disclosableRefusalName}([ref] 起 wire 出口与日志 / 拒因句同一个口:
+ * settings-schema `isReportableRefusalName`〔6.3.0 起 = 标识符白名单 ∧ 无密钥形 ∧ 无 URL userinfo,import 不复制〕∧ 脱敏器的强证据臂不认它是凭据)—— 秘密形 /
+ * 空串 / `__proto__` / 不是标识符的串这类出不了门的名不进键、不计数;引擎内部的判决不受影响;本机日志 / 拒因句里的写名同样先问这一个口([ref]:不可披露的名只写码)。
  * 逐条空且无组拒 ⇒ `undefined`(键缺席:「没有」只有一种拼法)。
  */
 export declare function buildModelRefusalsSignal(v: ModelRefusalVerdict | undefined): ModelRefusalsSignal | undefined;
@@ -131,8 +144,15 @@ export declare function echoModelRef(ref: string): string;
  * hook 选模型的失败文案 —— 各处同一句)。`field` = 调用方的通道名(`model` / `compactionModel` / `agents[0].model` /
  * `@-mention`),`requested` = 调用方发来的**原形**(name 或 id;本函数回显它时过 {@link echoModelRef},调用方不预先截)。
  * 别名段(`(catalog entry …)`)的判断读原形:ref 与条目名逐字相同 ⇒ 不带,不因回显截短而误判成「另有条目」。
+ * 别名段里的条目名过 {@link nameSlot}([ref]):调用方按上游 id 点中一条名字是凭据形的条目时,名字是**配置里的字**、不是调用方写的字,不可披露的名不原样回给他。
  */
 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

@@ -4,6 +4,7 @@ import { catalogBrainLane } from "./model-provider.js";
 import { readCatalogEntryHeaders } from "./model-entry-headers.js";
 import { DroppedCatalogEntryRow, describeSchemaIssueFields, describeSchemaIssues } from "./web-admin-client/read-warnings.js";
 import { echoCallerText } from "./caller-text-echo.js";
+import { isCredentialShapedUnit } from "./trace/redact.js";
 import { DEFAULT_MODEL_REF } from "./model-select.js";
 export const ENTRY_REFUSAL_REASON_OF = {
     "config.model_no_brain": "no_brain",
@@ -26,36 +27,45 @@ 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;
+    if (isCredentialShapedUnit(e.name))
+        return { ok: false, refusal: credentialNameRefusal(e.id, e.provider) };
+    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 +77,20 @@ 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 credentialNameRefusal(id, provider) {
+    return {
+        ...refusalCause("config.model_entry_invalid"),
+        id,
+        provider,
+        fields: ["name"],
+        detail: "the catalog entry's name field is credential-shaped (the engine's secret scanner reads it as a credential) — an entry name is returned verbatim by GET /v1/models " +
+            "and serves as the @-mention handle, so the entry is not served rather than served under a name that every log line has to mask; rename the entry to a plain identifier " +
+            "to bring it back, and treat the credential as exposed if the name was pasted from a real one",
+    };
+}
+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 +99,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,24 +119,24 @@ 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)
         return undefined;
-    const entries = Object.fromEntries(Object.entries(v.entries).flatMap(([name, r]) => (isReportableRefusalName(name) ? [[name, r.code]] : [])));
+    const entries = Object.fromEntries(Object.entries(v.entries).flatMap(([name, r]) => (disclosableRefusalName(name) !== undefined ? [[name, r.code]] : [])));
     if (Object.keys(entries).length === 0 && v.plane === undefined)
         return undefined;
     return v.plane === undefined ? { entries } : { entries, plane: v.plane };
 }
 function disclosableRefusalName(name) {
-    return isReportableRefusalName(name) ? name : undefined;
+    return isReportableRefusalName(name) && !isCredentialShapedUnit(name) ? name : undefined;
 }
 export function refusedNameLogField(key, name) {
     const shown = disclosableRefusalName(name);
@@ -149,9 +173,12 @@ export function echoModelRef(ref) {
     return echoCallerText(ref, { maxChars: MODEL_REF_ECHO_CHARS });
 }
 export function modelUnavailableMessage(field, requested, name, r) {
-    const alias = requested === name ? "" : ` (catalog entry "${name}")`;
+    const alias = requested === name ? "" : ` (catalog entry ${nameSlot(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-reach-scope.d.ts

@@ -4,7 +4,8 @@
  * 两层,一只 `AsyncLocalStorage`:
  *  · **腿层**(`withModelReachScope`,三条带用户面投递口的 run 腿各包一次:流式 `POST /v1/tasks/stream`、后台 `POST /v1/runs`、续跑):
  *    带着这条腿的两枚身份 —— `sessionId`(通告归属键)与 `taskId`(这条腿的 run 资源 id,= 本腿交给引擎的 `spec.taskId`;7.121.0)——
- *    与本腿已经说过的目标集合(去重单位 = 每腿每目标一次);
+ *    与本腿已经说过的目标集合(去重单位 = 每腿每目标一次);腿层的 `sessionId` 同时是读拒字节地板通告的归属键
+ *    (`read-deny-floor-notice.ts` 的 `presentEngineNotice`:腿派出去的 run —— cascade 的级、验证器、子代 —— 的那一帧落在这条腿的流上);
  *  · **调用层**(`createModelReachBrain` 每次模型调用包一次):一只可变的 {@link ModelCallReach},出网观察者
  *    (`outbound-dispatcher.ts` 的 undici 诊断通道订阅)把这次调用发出的每一条请求的**结局**记在上面 —— 最后一条是
  *    「连上了、有了回答」还是「建连就失败了」。

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`。

package/dist/model-route-endpoint.js

@@ -31,21 +31,43 @@ export function judgeModelRouteEndpoint(view, leg) {
     }
     const routes = routeTableOf(view);
     const entries = Object.entries(view.models ?? {});
+    const laneUnmounted = [];
     const unresolved = [];
-    let laneCredentialMissing = false;
     for (const [name, m] of entries) {
         if (name === DEFAULT_MODEL_REF && entries.some(([k, other]) => k !== name && other === m))
             continue;
-        if (brainLaneFor(m.provider, routes) !== "gateway")
+        const lane = brainLaneFor(m.provider, routes);
+        if (catalogBrainLane(m.provider) !== lane) {
+            laneUnmounted.push(`"${name}"`);
+            continue;
+        }
+        if (lane !== "gateway")
             continue;
         if (openaiRouteBaseUrl(m.baseUrl, gateway) !== undefined)
             continue;
-        laneCredentialMissing ||= catalogBrainLane(m.provider) === "anthropic";
-        unresolved.push(unresolvedRouteLabel(name, m.provider));
+        unresolved.push(`"${name}"`);
+    }
+    const endpointMissing = unresolved.length > 0 ? routeEndpointMissingRefusal(unresolved, leg) : undefined;
+    if (laneUnmounted.length > 0) {
+        const reason = laneUnmountedRefusal(laneUnmounted, leg) + (endpointMissing !== undefined ? ` Also: ${endpointMissing}` : "");
+        return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: "lane_credential_missing", reason };
+    }
+    return endpointMissing === undefined ? undefined : { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: "endpoint_missing", reason: endpointMissing };
+}
+function laneUnmountedRefusal(quotedNames, leg) {
+    const one = quotedNames.length === 1;
+    const head = `${one ? `model ${quotedNames[0]} asks` : `models ${quotedNames.join(", ")} ask`} for the anthropic lane (provider "anthropic"), but no Anthropic route is mounted on this ` +
+        `deployment — ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN are both unset [${MODEL_ROUTE_ENDPOINT_MISSING_CODE}]. ${one ? "It is" : "They are"} not served rather than ` +
+        "handed to the openai-compatible gateway under an anthropic label (that lane would answer with its own key, its own wire format and its own cache accounting). ";
+    switch (leg) {
+        case "env":
+            return (head +
+                "Pick one way out: (1) set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN (plus ANTHROPIC_BASE_URL for a non-default endpoint); " +
+                "(2) set MODEL_PROVIDER=gateway (or vllm) to serve the env model on the openai-compatible gateway; " +
+                "(3) leave MODEL_ID unset and let the default entry of a catalog (config.d/models.json, or the web-admin) serve — a catalog in force replaces the env model table.");
+        case "catalog":
+            return head + `Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN in this service's env, or change ${one ? "the entry's" : "each named entry's"} provider to an OpenAI-compatible route ("gateway" / "vllm") with its own baseUrl.`;
     }
-    if (unresolved.length === 0)
-        return undefined;
-    return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: laneCredentialMissing ? "lane_credential_missing" : "endpoint_missing", reason: routeEndpointMissingRefusal(unresolved, leg) };
 }
 function routeEndpointMissingRefusal(quotedNames, leg) {
     const one = quotedNames.length === 1;

package/dist/model-select.d.ts

@@ -84,6 +84,22 @@ export declare function resolveTaskModel(bodyModel: unknown, objective: string,
     notAllowed?: ModelNotAllowed;
     unavailable?: ModelUnavailable;
 };
+/** 用户选择被判的那一份模型面(`ServiceConfig` 结构上满足):目录、档位绑定、不可用条目、本代 `atMention` —— 四件出自同一份配置。 */
+export interface UserModelPlane<M> {
+    readonly models: Record<string, M>;
+    readonly tiers: Record<string, string> | undefined;
+    readonly modelRefusals: Readonly<Record<string, ModelEntryRefusal>> | undefined;
+    readonly atMention: AtMention;
+}
+/**
+ * 🔴 **用户选择的唯一入口**(请求面 `body.model` / `settings.model`、objective 内联 `@name`,每一条提交腿同调):在**可选目录**({@link selectableCatalog})上解析、
+ * 用本代 `atMention` 判许可({@link resolveTaskModel} → {@link isAtMentionable})。可选目录随结果交回(调用方其余显式选择通道 —— `compactionModel` /
+ * `agents[].model` / 未知模型拒体的 `available` —— 判的是同一张,不另铸)。哪张目录、哪份许可只在这里取,任何一条腿都没有「取契约缺省」的第二读法。
+ */
+export declare function pickUserModel<M>(plane: UserModelPlane<M>, bodyModel: unknown, objective: string): {
+    selectable: Record<string, M>;
+    picked: ReturnType<typeof resolveTaskModel>;
+};
 /**
  * [ref] 判别式拒因:这次**用户选择**点中的是一条已发布、但本部署不可用的目录条目(`config.modelRefusals`)。
  * 与 {@link ModelNotAllowed} 同一种处置口:本函数不 throw,调用点按 leg 分流(fresh 400 `request.model_unavailable` /

package/dist/model-select.js

@@ -57,6 +57,10 @@ export function resolveTaskModel(bodyModel, objective, catalog, atMention, refus
         ...(unavailable ? { unavailable } : {}),
     };
 }
+export function pickUserModel(plane, bodyModel, objective) {
+    const selectable = selectableCatalog(plane.models, plane.tiers, plane.modelRefusals);
+    return { selectable, picked: resolveTaskModel(bodyModel, objective, selectable, plane.atMention, plane.modelRefusals) };
+}
 export function selectableCatalog(models, tiers, refusals) {
     const expanded = (expandTiers(models, tiers ?? {}) ?? models);
     const reserved = Object.keys(refusals ?? {}).filter((n) => Object.hasOwn(expanded, n) && !Object.hasOwn(models, n));