@sema-agent/server 7.122.0 → 7.123.0

package/dist/http/routes/sessions.js

@@ -794,15 +794,12 @@ export async function handleSessions(req, res, match, ctx) {
                     case "not-an-object":
                         sendError(res, 400, "request.body_shape", describeSessionPermissionRulesProblem(read.problem));
                         return;
-                    case "field-not-string-array":
+                    case "field-not-rule-list":
                         sendError(res, 400, "request.field_invalid", describeSessionPermissionRulesProblem(read.problem));
                         return;
                     case "legacy-tool-name":
                         sendError(res, 400, "rules.legacy_tool_name", describeSessionPermissionRulesProblem(read.problem), { ...read.problem.refusal });
                         return;
-                    case "unreachable-tool-name":
-                        sendError(res, 400, "request.field_invalid", describeSessionPermissionRulesProblem(read.problem));
-                        return;
                     default: {
                         const unhandled = read.problem;
                         throw new Error(`unhandled SessionPermissionRules problem: ${JSON.stringify(unhandled)}`);

package/dist/http/stored-body-replay.d.ts

@@ -7,13 +7,14 @@
  * **入口地板**(`runtime-governance.ts` `autonomyModeFloor`)—— 这两只属主带着配置层的包外依赖;`checkpoint-ctx.ts` 被随包的本地排空脚本经编译产物 import,
  * 它的闭包只许 node 内建 / 引擎包根(`test/drain-check-local.test.ts` 的闭包门)。判据只有这一只,前两问的谓词照旧住在各自属主里。
  */
-import { type PermissionMode } from "@sema-agent/core";
+import type { PermissionMode } from "@sema-agent/core";
 import { type Autonomy } from "../runtime-governance.js";
 import { type StoredBodyReplayRefusal } from "./checkpoint-ctx.js";
 import type { CheckpointCtx } from "./route-ctx.js";
 /**
- * 第三问:本行体里的模式词能否按当前读法重放。不能 ⇔ 本部署此刻有入口地板 ∧ 行上没有当前的模式词读法记号 ∧ 体的生效词被地板钳会变
- * (core `clampPermissionMode`,与提交入口的盖章同一只钳)⇒ 返回拒因的两个事实(体的词、地板);能 ⇒ `undefined`。
+ * 第三问:本行体里的模式词能否按当前读法重放。不能 ⇔ 本部署此刻有入口地板 ∧ 行上没有当前的模式词读法记号 ∧ 体的生效词进这块地板会变
+ * (`runtime-governance.ts` `entryPermissionMode`,与提交入口的盖章同一只函数;判的是「词变不变」而不是 `clamped` —— 体无词的旧行进地板取地板本身,
+ * 那也是变)⇒ 返回拒因的两个事实(体的词、地板);能 ⇒ `undefined`。
  */
 export declare function permissionModeReadingUnstated(ctx: CheckpointCtx, floor: PermissionMode | undefined): {
     stored: PermissionMode | undefined;

package/dist/http/stored-body-replay.js

@@ -1,13 +1,12 @@
-import { clampPermissionMode } from "@sema-agent/core";
 import { storedBodyPermissionMode } from "../task-settings.js";
-import { autonomyModeFloor } from "../runtime-governance.js";
+import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
 import { skillDenyInertEntryOf } from "../rule-entry-list.js";
 import { allowListReadingEraOf, allowListReadingUnstated, permissionModeReadingStated } from "./checkpoint-ctx.js";
 export function permissionModeReadingUnstated(ctx, floor) {
     if (floor === undefined || permissionModeReadingStated(ctx))
         return undefined;
     const stored = storedBodyPermissionMode(ctx.body);
-    return clampPermissionMode(stored, floor).effective === stored ? undefined : { stored, floor };
+    return entryPermissionMode(stored, floor).effective === stored ? undefined : { stored, floor };
 }
 export function storedBodyReplayRefusal(ctx, autonomy) {
     if (allowListReadingUnstated(ctx))

package/dist/index.d.ts

@@ -29,5 +29,7 @@ export { createKeyResolver, resolveModelApiKey, type ModelKeyRef } from "./key-r
 export { isModelKeyPoison, ModelKeyPoisonedError, type ModelKeyPoison, type ModelKeyPoisonReason } from "./key-resolver.js";
 export { RETIRED_ENVS, type RetiredEnv, type RetiredEnvKind, type RetiredEnvWire } from "./config.js";
 export { CATALOG_ENTRY_HEADER_LANES, CATALOG_ENTRY_HEADER_NAMES, type CatalogEntryHeaderName } from "./model-entry-headers.js";
+export { judgeModelRouteGap, type ModelRouteGapReading, type ModelRouteGapOptions } from "./model-route-gap.js";
+export type { ModelRouteGap } from "./model-route-endpoint.js";
 export type { UserInputLedgerStore, UserInputAcceptance, NewUserInputAcceptance, OpenScanCursor, OpenScanPage, SettleHow, WriterGoneEvidence } from "./user-input-ledger.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -26,4 +26,5 @@ export { createKeyResolver, resolveModelApiKey } from "./key-resolver.js";
 export { isModelKeyPoison, ModelKeyPoisonedError } from "./key-resolver.js";
 export { RETIRED_ENVS } from "./config.js";
 export { CATALOG_ENTRY_HEADER_LANES, CATALOG_ENTRY_HEADER_NAMES } from "./model-entry-headers.js";
+export { judgeModelRouteGap } from "./model-route-gap.js";
 //# sourceMappingURL=index.js.map

package/dist/leader/leader.d.ts

@@ -66,8 +66,8 @@ export interface ProvisionedWorker {
     verifierTools?: ToolSpec[];
 }
 /**
- * 一条 leader run 的**入口体**(提交体去掉 objective 的那一半)—— 运维 `AUTONOMY` 的模式词地板在这条 run 出生的那一拍读一次、经受理门同一只盖章
- * 盖出来的结果(`run-entry.ts` `leaderRunEntry`);地板缺席 ⇒ `{}`。leader 请求不带调用方的模式词,所以入口词就是地板本身(与 run-local 同)。
+ * 一条 leader run 的**入口体**(提交体去掉 objective 的那一半)—— 运维 `AUTONOMY` 的模式词地板在这条 run 出生的那一拍读一次、经受理门同一只函数
+ * (`runtime-governance.ts` `entryPermissionMode`)得出的入口词(`run-entry.ts` `leaderRunEntry`);地板缺席 ⇒ `{}`。leader 请求不带调用方的模式词,所以入口词就是地板本身(与 run-local 同)。
  * 本 run 铸的每一条 spec 经 {@link withLeaderLeg} 从这一份取词;worker 的续跑体由它展开(`{ ...entry, objective }`)⇒ 首跑、续跑、修复腿同一个词。
  * 入口词是 `plan` 的 run 进不了这条车道(`run-entry.ts` `leaderEntryRefusal`:worker 会话没有计划审阅通道)—— 受理口与出生处同判,到不了 worker。
  * 热改 `AUTONOMY` 只影响之后起的 leader run:在飞的 run 保持它出生时盖下的这一份。
@@ -76,10 +76,11 @@ export interface LeaderRunEntry {
     readonly permissionMode?: PermissionMode;
 }
 /**
- * leader 车道铸 spec 的**唯一**合并口:入口体的词写进 spec,再交给无人值守腿的合并口(`withUnattendedLeg` 的 `default` 钳在入口词之下)。
- * 入口体无词 ⇒ spec 原物交给 `withUnattendedLeg`,与不经本口逐字同。本车道的 spec 自己不带模式词(子任务体只有 objective,其余并进的键是预算 / 审批 / 身份),
- * 所以这里是「写」而不是「钳」。五个出生点(worker 首跑的工厂 / 静态两条车道、集成修复、模块门修复、单代理修复环)都调它、不直调 `withUnattendedLeg`
- * (`test/leader-entry-floor.test.ts` 按语法树数调用点):「这条腿的词从哪来」只有入口体一个答案。
+ * leader 车道铸 spec 的**唯一**合并口:spec 的词钳在入口体的词之下(`runtime-governance.ts` `entryPermissionMode(spec 的词, 入口词)` —— 与受理门同一只函数;
+ * 写进 spec 的值就是它的 `effective`),再交给无人值守腿的合并口(`withUnattendedLeg` 的 `default` 钳在那个词之下)。入口体无词 ⇒ spec 原物交给
+ * `withUnattendedLeg`,与不经本口逐字同。本车道的 spec 今天自己不带模式词(子任务体只有 objective,其余并进的键是预算 / 审批 / 身份)⇒ 入口词在场时写下的就是它;
+ * 将来带了词,比入口词松的折回入口词、比它紧的留着 —— 与一条提交体过受理门同一个答案,不另写「写」的规则。五个出生点(worker 首跑的工厂 / 静态两条车道、
+ * 集成修复、模块门修复、单代理修复环)都调它、不直调 `withUnattendedLeg`(`test/leader-entry-floor.test.ts` 按语法树数调用点):「这条腿的词从哪来」只有入口体一个答案。
  */
 export declare function withLeaderLeg<S extends Partial<TaskSpec>>(spec: S, entry: LeaderRunEntry): S & UnattendedLegSpec;
 export interface LeaderDeps {

package/dist/leader/leader.js

@@ -4,6 +4,7 @@ import { pullDiff } from "./diffout.js";
 import { mergeBranches } from "./merge.js";
 import { Runner, runWithVerification, resumeWithVerification } from "@sema-agent/core";
 import { pausedCauseOf, outwardPlane } from "../terminal.js";
+import { entryPermissionMode } from "../runtime-governance.js";
 import { withUnattendedLeg } from "../unattended-permission-mode.js";
 const MAX_RESUME_SLICES = 200;
 export async function autoResumeOnResource(initial, signal, resume, maxSlices = MAX_RESUME_SLICES) {
@@ -17,7 +18,8 @@ export async function autoResumeOnResource(initial, signal, resume, maxSlices =
     return vr;
 }
 export function withLeaderLeg(spec, entry) {
-    return withUnattendedLeg(entry.permissionMode === undefined ? spec : { ...spec, permissionMode: entry.permissionMode });
+    const word = entryPermissionMode(spec.permissionMode, entry.permissionMode).effective;
+    return withUnattendedLeg(word === undefined ? spec : { ...spec, permissionMode: word });
 }
 export async function runLeaderTask(task, durableBaseSha, deps) {
     let subs;

package/dist/leader/run-entry.d.ts

@@ -2,7 +2,7 @@
  * 一条 leader run 的**入口体**与「它进不进得了 leader 车道」的唯一判据。
  *
  * 规则(与受理门、run-local 同一条):运维 `AUTONOMY=plan` 是提交入口的模式词地板,盖在每一个 spec 出生点。leader 请求不带调用方的模式词,
- * 所以入口体是一份空体盖上地板(受理门同一只盖章 `task-settings.ts` `stampEntryPermissionMode`;地板的唯一属主 `runtime-governance.ts`
+ * 所以入口词 = `runtime-governance.ts` `entryPermissionMode(undefined, 地板).effective`(与受理门、run-local 同一只函数;地板的唯一属主
  * `autonomyModeFloor`)。
  *
  * `plan` 是**生命周期词**:它靠人审通道(`plan_review`)出口 —— 一个人批准计划,run 才离开 plan。leader 的 worker 会话**没有**那条通道
@@ -14,7 +14,7 @@
  */
 import { type Autonomy } from "../runtime-governance.js";
 import type { LeaderRunEntry } from "./leader.js";
-/** 一条 leader run 的入口体:地板读一次、受理门同一只盖章(地板缺席 ⇒ `{}`)。调用方读**活** config(热改只影响之后起的 run)。 */
+/** 一条 leader run 的入口体:地板读一次、入口词经受理门同一只函数(地板缺席 ⇒ `{}`)。调用方读**活** config(热改只影响之后起的 run)。 */
 export declare function leaderRunEntry(autonomy: Autonomy | undefined): LeaderRunEntry;
 /** 拒句:原因(运维的 plan 地板 × 这条车道没有计划审阅通道)+ 两条出路(改走有计划审阅的 run 车道 / 运维换档)。不含任何配置值之外的回显。
  *  受理口(HTTP 422 的 `error`)与 run 出生处(run 的 `error`)读的是这一份;字节由 `test/api-error-text-freeze.test.ts` 的常量锚格冻。 */

package/dist/leader/run-entry.js

@@ -1,7 +1,7 @@
-import { autonomyModeFloor } from "../runtime-governance.js";
-import { stampEntryPermissionMode } from "../task-settings.js";
+import { autonomyModeFloor, entryPermissionMode } from "../runtime-governance.js";
 export function leaderRunEntry(autonomy) {
-    return stampEntryPermissionMode({}, autonomyModeFloor(autonomy));
+    const word = entryPermissionMode(undefined, autonomyModeFloor(autonomy)).effective;
+    return word === undefined ? {} : { permissionMode: word };
 }
 export const LEADER_PLAN_ENTRY_REFUSAL = "this deployment runs with AUTONOMY=plan, which starts every task in plan mode and lets it out of plan mode only when a person approves its plan through plan review; " +
     "a leader task's workers have no plan review channel, so they could neither write nor hand their plan to anyone who can approve it. Nothing was started. " +

package/dist/leader/wire.d.ts

@@ -65,8 +65,8 @@ export interface LeaderWireConfig {
      * 保留它准备时的那一份(core 的自然快照语义,两条腿同律)。 */
     deploymentPosture?: () => DeploymentPostureSeats;
     /**
-     * 运维 `AUTONOMY`(活 config 的那一位)—— 本车道每条 leader run **出生那一拍**读一次,经 `run-entry.ts` 的 `leaderRunEntry`(入口地板 + 受理门同一只盖章)
-     * 盖成这条 run 的入口体(`LeaderDeps.entry`);本 run 铸的每一条 spec 与 worker 的续跑体都从它取词。入口词是 `plan` 的 run 进不了这条车道
+     * 运维 `AUTONOMY`(活 config 的那一位)—— 本车道每条 leader run **出生那一拍**读一次,经 `run-entry.ts` 的 `leaderRunEntry`(入口地板 + 受理门同一只入口函数 `entryPermissionMode`)
+     * 得出这条 run 的入口体(`LeaderDeps.entry`);本 run 铸的每一条 spec 与 worker 的续跑体都从它取词。入口词是 `plan` 的 run 进不了这条车道
      * (`leaderEntryRefusal`:worker 会话没有计划审阅通道)⇒ 出生处即以拒句收场;HTTP 受理口用同一只判据先答 422。
      *
      * 🔴 **函数席**(与 `deploymentPosture` / `durable` 同一条先例):`config.autonomy` 被 config-center 原地热改,boot 期取一次值会把这条腿钉在起服那一刻。

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

@@ -1,4 +1,5 @@
 import { type ModelEntryRefusalCode, type ModelPlaneRefusalCode, type ModelRefusalsSignal } from "@sema-agent/settings-schema";
+import { type DroppedCatalogEntry } from "./config-center/read-warnings.js";
 /**
  * 条目拒因码 → 本仓铸它的成因 —— **以码为键**(S-768):码闭集的属主是 settings-schema(`MODEL_ENTRY_REFUSAL_CODES`,6.2.0 起;此前本仓
  * 自持一份同名码表,撞名已消灭、零别名)。那边加一个条目码 ⇒ 本表缺键 ⇒ 本仓 tsc 红(只拿 `satisfies` 约束码值证明的是「子集」,
@@ -58,23 +59,31 @@ export interface CatalogEntryLike {
  * 坐标,不取它的输出(输出会补缺省、剥扩展键,那是读腿的事)。
  */
 export declare function judgeCatalogEntry(m: CatalogEntryLike, ctx: CatalogEntryVerdictCtx): ModelEntryRefusal | undefined;
-/** 一批已启用条目的判决:可用的(保序)、不可用的(按 catalog name)、以及形不对的被丢身份载体行(坐标)。 */
+/** 一批已启用条目的判决:可用的(保序)、不可用的(按 catalog name)、被丢目录条目的载体行(形对的,保序),以及形不对的载体行(坐标)。 */
 export interface CatalogEntriesVerdict<M extends CatalogEntryLike> {
     readonly usable: readonly M[];
     /** 键 = catalog name(**每一个**名,含秘密形 / 空串 / `__proto__`:引擎自己的判决保持完整 —— S-712 不变量与选择面的「让出」都读它;
      *  名筛只在出口,见 {@link buildModelRefusalsSignal})。键以自有数据属性写入(`__proto__` 不走原型 setter)。 */
     readonly refused: Readonly<Record<string, ModelEntryRefusal>>;
-    /** S-712:被丢身份**载体形不对**的行坐标(`models.3`;载体不是列表时是一个固定标记)。读腿只为有名的被丢条目铸载体行
-     *  (`read-warnings.ts` `DroppedModelIdentity`,`name` 必在),所以这一形只来自绕过读腿的输入被改过(盘上 LKG 被手改 / 手写
-     *  effective)。非空 ⇒ 读不出的名字无从证明它不被增广铸出 ⇒ 不变量 `refused-names-not-minted` 不成立 ⇒ 模型面组拒(fail-closed)。 */
+    /** S-712:被丢目录条目**载体形不对**的行坐标(`models.3`;读不出下标时是 `(unknown coordinate)`;载体不是列表时是一个固定标记)。读腿铸的每一行
+     *  都合 `read-warnings.ts` {@link DroppedCatalogEntryRow} 的形,所以这一形只来自绕过读腿的输入被改过(盘上 LKG 被手改 / 手写 effective)。
+     *  非空 ⇒ 改过的行原本代表谁说不清,无从证明它的名字不被增广铸出 ⇒ 不变量 `refused-names-not-minted` 不成立 ⇒ 模型面组拒(fail-closed)。 */
     readonly malformed: readonly string[];
+    /** S-1295:载体里形对的行(保序)—— 模型面 stage 把它与 `models` 同 commit 进 `config.droppedCatalogEntries`(`GET /v1/models.droppedEntries`
+     *  的源):载体只在这里被判形、被读一次,墓碑与 wire 读的是同一批行。 */
+    readonly dropped: readonly DroppedCatalogEntry[];
 }
 /**
  * 批量形(模型面 stage 与 dry-run 共用这一只 —— 报数与真 apply 永不撕裂)。
- * S-712:`dropped` = 读腿交出的被丢条目身份(`EffectiveConfig.models.droppedIdentities`)—— 它们与逐条判据判出的 `entry_invalid`
- * 是**同一件事**(条目不合 `ModelEntry` 形),只是在第一道边界就被丢了;每一行铸一块墓碑(拒因 provider 词空:告警身份不带它)。
- * 入参按 `unknown` 判形:载体可能来自盘上 LKG(本仓写的,但文件可被改)。**规则一条**:载体要么缺席,要么是一列带字符串 `name`
- * 的行;其余一律「载体形不对」进 `malformed`(fail-closed)—— 读腿自己从不铸这种形。
+ * S-712:`dropped` = 读腿交出的被丢目录条目载体(`EffectiveConfig.models.droppedCatalogEntries`,每一条被丢的目录条目一行)。入参按 `unknown`
+ * 判形:载体可能来自盘上 LKG(本仓写的,但文件可被改)。载体要么缺席,要么是一列合 {@link DroppedCatalogEntryRow} 形的行;其余一律「载体形不对」
+ * 进 `malformed`(fail-closed)—— 读腿自己从不铸这种形。
+ * **墓碑判据(一条,S-712 原样)**:行的 `identity.name` 在 ∧ `identity.enabled !== false` ⇒ 铸一块墓碑(它与逐条判据判出的 `entry_invalid`
+ * 是同一件事 —— 条目不合 `ModelEntry` 形,只是在第一道边界就被丢了;拒因 provider 词空:告警身份不带它)。其余行不是墓碑:
+ *  · 停用 ⇒ 不在目录(与 7.100.0 同义);
+ *  · 没有名 —— 原文 `name` 不是字符串,或是字符串但不能原样出门(settings-schema `isDisclosableIdentity` 说不,身份里不带)⇒ **无名可留**,
+ *    与停用同处置。后者对本判据同样安全:档位增广只铸闭集词(`ultra` / `max` / `pro` / `flash` / `lite`、CC 别名、`best`),没有一个是
+ *    秘密形或非标识符,被扣下的名字无从被铸出;代价只是显式点它的请求拿到「未知模型」而不是 `request.model_unavailable`。
  * 与一条可用 / 已判不可用条目同名时不覆盖(可用条目仍可用;同名撞车由不变量 `refused-names-not-minted` 响亮拒)。
  */
 export declare function judgeCatalogEntries<M extends CatalogEntryLike>(enabled: readonly M[], ctx: CatalogEntryVerdictCtx, dropped?: unknown): CatalogEntriesVerdict<M>;
@@ -163,6 +172,6 @@ export interface RefusedNameView {
 export declare function mintedRefusedNames(view: RefusedNameView): MintedRefusedName[];
 /** 不变量 `refused-names-not-minted` 的拒因句(`undefined` = 成立)。warn 与世代账 / 拒因同一句;逐对明细另走 {@link mintedRefusedNames}。 */
 export declare function refusedNameMintedRefusal(view: RefusedNameView): string | undefined;
-/** 被丢身份载体形不对的拒因句(同一不变量同一个码:读不出的名字无从证明它不被增广铸出)。 */
+/** 被丢目录条目载体形不对的拒因句(同一不变量同一个码:改过的行原本代表谁说不清,无从证明它的名字不被增广铸出)。 */
 export declare function malformedDroppedCarrierRefusal(entries: readonly string[]): string;
 //# sourceMappingURL=model-entry-refusal.d.ts.map

package/dist/model-entry-refusal.js

@@ -1,8 +1,8 @@
 import { CC_MODEL_TIER_ALIASES, DEFAULT_TIER_ORDER, expandTiers } from "@sema-agent/core";
-import { ModelEntry, isReportableRefusalName } from "@sema-agent/settings-schema";
+import { ModelEntry, formatConfigPath, isReportableRefusalName } from "@sema-agent/settings-schema";
 import { catalogBrainLane } from "./model-provider.js";
 import { readCatalogEntryHeaders } from "./model-entry-headers.js";
-import { describeSchemaIssueFields, describeSchemaIssues } from "./config-center/read-warnings.js";
+import { DroppedCatalogEntryRow, describeSchemaIssueFields, describeSchemaIssues } from "./config-center/read-warnings.js";
 import { DEFAULT_MODEL_REF } from "./model-select.js";
 export const ENTRY_REFUSAL_REASON_OF = {
     "config.model_no_brain": "no_brain",
@@ -55,7 +55,7 @@ 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",
     };
 }
-const MALFORMED_CARRIER_NOT_A_LIST = "(droppedIdentities is not a list)";
+const MALFORMED_CARRIER_NOT_A_LIST = "(droppedCatalogEntries is not a list)";
 export function judgeCatalogEntries(enabled, ctx, dropped) {
     const usable = [];
     const refused = {};
@@ -71,20 +71,25 @@ export function judgeCatalogEntries(enabled, ctx, dropped) {
     }
     const rows = dropped === undefined ? [] : Array.isArray(dropped) ? dropped : undefined;
     if (rows === undefined)
-        return { usable, refused, malformed: [MALFORMED_CARRIER_NOT_A_LIST] };
+        return { usable, refused, malformed: [MALFORMED_CARRIER_NOT_A_LIST], dropped: [] };
     const malformed = [];
+    const carried = [];
     for (const d of rows) {
-        const e = (typeof d === "object" && d !== null ? d : {});
-        if (typeof e.name !== "string") {
-            malformed.push(typeof e.entry === "string" ? e.entry : "(unknown coordinate)");
+        const row = DroppedCatalogEntryRow.safeParse(d);
+        if (!row.success) {
+            const index = typeof d === "object" && d !== null ? d.index : undefined;
+            malformed.push(typeof index === "number" && Number.isSafeInteger(index) && index >= 0 ? formatConfigPath(["models", index]) : "(unknown coordinate)");
             continue;
         }
-        if (Object.hasOwn(refused, e.name))
+        carried.push(row.data);
+        const { identity } = row.data;
+        if (identity?.name === undefined || identity.enabled === false)
             continue;
-        const fields = Array.isArray(e.fields) ? e.fields.filter((f) => typeof f === "string") : [];
-        mint(e.name, entryInvalidRefusal(typeof e.id === "string" ? e.id : "", "", fields, typeof e.issues === "string" ? e.issues : fields.join(", ")));
+        if (Object.hasOwn(refused, identity.name))
+            continue;
+        mint(identity.name, entryInvalidRefusal(identity.id ?? "", "", row.data.fields, row.data.issues));
     }
-    return { usable, refused, malformed };
+    return { usable, refused, malformed, dropped: carried };
 }
 export function buildModelRefusalsSignal(v) {
     if (v === undefined)
@@ -185,8 +190,8 @@ export function refusedNameMintedRefusal(view) {
         "rename the unavailable entry, fix it (see its own warn), or rebind / drop the tier binding that mints the name.");
 }
 export function malformedDroppedCarrierRefusal(entries) {
-    return (`the dropped-entry identity carrier of this candidate is malformed [${REFUSED_NAME_MINTED_CODE}]: ${entries.join(", ")} — ` +
-        "every row the settings-schema read writes there carries a string name, so this carrier was edited outside the read legs (e.g. a hand-edited last-known-good file); " +
-        "the candidate cannot prove the tier/alias expansion does not re-mint the unnamed entries, so its model plane is refused — restore or delete that carrier (a fresh read of the source re-mints it).");
+    return (`the dropped catalog entry carrier of this candidate is malformed [${REFUSED_NAME_MINTED_CODE}]: ${entries.join(", ")} — ` +
+        "every row the settings-schema read writes there has the carrier row shape (index, reasonCode, optional identity, fields, issues), so this carrier was edited outside the read legs (e.g. a hand-edited last-known-good file); " +
+        "the candidate cannot prove the tier/alias expansion does not re-mint the entries those rows stood for, so its model plane is refused — restore or delete that carrier (a fresh read of the source re-mints it).");
 }
 //# sourceMappingURL=model-entry-refusal.js.map

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

@@ -15,7 +15,8 @@
  * (`MODEL_GATEWAY_FALLBACK_URLS`)是主网关的镜像,没有主就没有镜像 ⇒ 拒。
  *
  * ## 执法点(判据只在这里,执法点在调用处 —— 与 S-475 `gateway-url-userinfo` 同形)
- *  · boot:`config.ts` 九域解析之后的跨域不变量区(锚 `CROSS-INVARIANT:model-route-endpoint`)⇒ 拒启;严格名册
+ *  · boot:`config.ts` 九域解析之后的跨域不变量区(锚 `CROSS-INVARIANT:model-route-endpoint`)⇒ 拒启;经 `model-route-gap.ts`
+ *    的 {@link judgeModelRouteGap}(env 读成本文件判据要的切面,与包根导出的纯判官是**同一只**);严格名册
  *    布防(`isRosterGateArmed`)时 env 腿是占位、从不被派发 ⇒ 不判它(备用网关那一条照判);
  *  · 热路径:`config-center/apply-effective.ts` 的模型面 stage ⇒ 模型面组拒(opus 腿 O3:同候选其余组照落)、上一代模型面继续服务;
  *  · run-local:配置源解析完之后按真要派发的表再判一次(`run-local.ts`,7.98.0 合并复审 F2)—— 本入口没有名册门,
@@ -37,6 +38,23 @@ import type { Model } from "@sema-agent/core";
 export declare const MODEL_ROUTE_ENDPOINT_MISSING_CODE = "config.model_route_endpoint_missing";
 /** 同族第二码:备用网关设了、主网关没设。与上一码分开是因为出路不同(补主网关 / 撤备用 vs 补主网关 / 给条目 baseUrl)。 */
 export declare const GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE = "config.gateway_fallback_without_primary";
+/**
+ * **路由缺口的出路轴**(闭集;{@link judgeModelRouteGap} 的 `gap` 词,包根导出 —— 壳 / 包在引擎起来之前问同一句)。
+ *
+ * 与上面的**码**是两根轴:码是组拒的机读词(`ModelPlaneRefusalCode`,settings-schema 属主),这里是**出路**:
+ *  · `endpoint_missing` —— 缺的是网关端点:openai 兼容腿上的条目解析不到 base URL(或备用网关设了、主网关没设);
+ *    出路 = 设 `MODEL_GATEWAY_BASEURL`,或给条目自己的 `baseUrl`;
+ *  · `lane_credential_missing` —— 缺的是**车道凭据**:条目的 provider 词是 `anthropic`(用户选的是 anthropic 车道),
+ *    却因 `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` 都没有而没装上 anthropic 路由、落进了 openai 腿,那条腿又没有端点;
+ *    出路 = 补那两把钥匙之一(设网关是另一条出路,拒因句一并给);
+ *  · `none` —— 这份配置能派发到的每一条 openai 兼容路由都解析得到端点。
+ *
+ * **声明序 = 语义序**(缺口两词在前,`none` 最后);加一词 ⇒ 所有穷举 switch 当场编译红。
+ */
+export declare const MODEL_ROUTE_GAP_WORDS: readonly ["endpoint_missing", "lane_credential_missing", "none"];
+export type ModelRouteGap = (typeof MODEL_ROUTE_GAP_WORDS)[number];
+/** 有缺口的那两词(判决的结构化形只在有缺口时存在,`none` = 判决为 `undefined`)。 */
+export type ModelRouteGapBreach = Exclude<ModelRouteGap, "none">;
 /**
  * 拒因给出的**本机网关显式写法**。`src/` 里本机 8000 那个字面的**唯一**住处 —— 源码门钉在
  * `test/config-gateway-endpoint-required.test.ts` ⑧(出现在别处 = 有人又在铸缺省)。
@@ -82,6 +100,8 @@ export declare function modelRouteEndpointRefusal(view: ModelRouteEndpointView):
 /** S-768:部署级判决的结构化形 —— 码与拒因句由**同一次**判决给出(一个不变量 id 两个码,组拒码在判决那刻当数据带出,不从句子里抠)。 */
 export interface ModelRouteEndpointVerdict {
     readonly code: typeof GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE | typeof MODEL_ROUTE_ENDPOINT_MISSING_CODE;
+    /** 出路轴({@link MODEL_ROUTE_GAP_WORDS} 的缺口两词):同一次判决给出,不从句子或码里反推(`lane_credential_missing` 与 `endpoint_missing` 共用一个码)。 */
+    readonly gap: ModelRouteGapBreach;
     readonly reason: string;
 }
 /**

package/dist/model-route-endpoint.js

@@ -2,6 +2,7 @@ import { dispatchBrainLane } from "./model-provider.js";
 import { DEFAULT_MODEL_REF } from "./model-select.js";
 export const MODEL_ROUTE_ENDPOINT_MISSING_CODE = "config.model_route_endpoint_missing";
 export const GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE = "config.gateway_fallback_without_primary";
+export const MODEL_ROUTE_GAP_WORDS = ["endpoint_missing", "lane_credential_missing", "none"];
 export const LOCAL_GATEWAY_HINT = "MODEL_GATEWAY_BASEURL=http://127.0.0.1:8000/v1";
 function declared(url) {
     return url !== undefined && url.trim() !== "" ? url : undefined;
@@ -24,11 +25,12 @@ export function judgeModelRouteEndpoint(view) {
             "after the primary fails; with no primary there is nothing to fail over from, and MODEL_GATEWAY_BASEURL has no " +
             `factory default. Set MODEL_GATEWAY_BASEURL to the primary gateway (for one on this machine: ${LOCAL_GATEWAY_HINT}), ` +
             "or unset MODEL_GATEWAY_FALLBACK_URLS.");
-        return { code: GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE, reason };
+        return { code: GATEWAY_FALLBACK_WITHOUT_PRIMARY_CODE, gap: "endpoint_missing", reason };
     }
     const anthropicMounted = view.anthropic !== undefined;
     const entries = Object.entries(view.models ?? {});
     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;
@@ -36,11 +38,15 @@ export function judgeModelRouteEndpoint(view) {
             continue;
         if (openaiRouteBaseUrl(m.baseUrl, gateway) !== undefined)
             continue;
-        unresolved.push(m.provider === "anthropic"
+        const anthropicWordWithoutRoute = m.provider === "anthropic";
+        laneCredentialMissing ||= anthropicWordWithoutRoute;
+        unresolved.push(anthropicWordWithoutRoute
             ? `"${name}" (provider "anthropic", but no Anthropic route is mounted — ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN are unset — so it falls to the openai-compatible lane)`
             : `"${name}"`);
     }
-    return unresolved.length > 0 ? { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, reason: routeEndpointMissingRefusal(unresolved) } : undefined;
+    if (unresolved.length === 0)
+        return undefined;
+    return { code: MODEL_ROUTE_ENDPOINT_MISSING_CODE, gap: laneCredentialMissing ? "lane_credential_missing" : "endpoint_missing", reason: routeEndpointMissingRefusal(unresolved) };
 }
 function routeEndpointMissingRefusal(quotedNames) {
     const one = quotedNames.length === 1;

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

@@ -0,0 +1,103 @@
+import { type ModelRouteEndpointVerdict, type ModelRouteGapBreach } from "./model-route-endpoint.js";
+/**
+ * 路由读数读的八把 env 键(**闭表**;`judgeModelRouteGap` 只碰这几把,测试用代理钉「读集 ⊆ 本表」)。
+ * 配置目录的 D1 对账门把 {@link readModelRouteEnv} 的调用当作这八把键的读点(`test/config-catalog.test.ts` 的 `DELEGATED_ENV_READERS`,键集取本表,不手抄)。
+ */
+export declare const MODEL_ROUTE_ENV_KEYS: {
+    readonly gatewayBaseUrl: "MODEL_GATEWAY_BASEURL";
+    readonly gatewayFallbackUrls: "MODEL_GATEWAY_FALLBACK_URLS";
+    readonly provider: "MODEL_PROVIDER";
+    readonly mainId: "MODEL_ID";
+    readonly cheapId: "MODEL_CHEAP_ID";
+    readonly anthropicApiKey: "ANTHROPIC_API_KEY";
+    readonly anthropicAuthToken: "ANTHROPIC_AUTH_TOKEN";
+    readonly anthropicBaseUrl: "ANTHROPIC_BASE_URL";
+};
+/** 一份 env 快照(`process.env` 也满足这个形)。 */
+export type ModelRouteEnv = Readonly<Record<string, string | undefined>>;
+/**
+ * env 腿的 **cheap 槽**(`MODEL_CHEAP_ID`)铸不铸 —— 闭集四态,消费方用穷举 switch({@link mintedCheapId};`config.ts` 的启动通知):
+ *  · `absent` —— 没设;
+ *  · `without_main` —— 设了而主槽(`MODEL_ID`)没设:cheap 槽是主模型「同网关换个 id」的形,没有主槽就没有它要派生的东西 ⇒ 不铸(启动时说一句);
+ *  · `same_as_main` —— 与主 id 相同:同一个 id 说的就是主模型本身 ⇒ 不铸(启动时说一句);
+ *  · `minted` —— 铸(`id` = `MODEL_CHEAP_ID`)。
+ */
+export type EnvCheapSlot = {
+    readonly kind: "absent";
+} | {
+    readonly kind: "without_main" | "same_as_main" | "minted";
+    readonly id: string;
+};
+/** cheap 槽铸出来的那个 id(不铸 ⇒ `undefined`)。**穷举 switch**:{@link EnvCheapSlot} 加一态不补臂 ⇒ 编译红。 */
+export declare function mintedCheapId(slot: EnvCheapSlot): string | undefined;
+/** {@link readModelRouteEnv} 的读数。 */
+export interface ModelRouteEnvReading {
+    /** `MODEL_GATEWAY_BASEURL`;**空串 = 未设**(compose `${X:-}` 常态),缺席不铸。 */
+    readonly gatewayBaseUrl: string | undefined;
+    /** `MODEL_GATEWAY_FALLBACK_URLS` 逐项 trim、丢空项。 */
+    readonly gatewayFallbackUrls: string[];
+    /** `ANTHROPIC_API_KEY` / `ANTHROPIC_AUTH_TOKEN` / `ANTHROPIC_BASE_URL`:空串 = 未设,别名各自独立(一个空别名不遮蔽另一个)。 */
+    readonly anthropicApiKey: string | undefined;
+    readonly anthropicAuthToken: string | undefined;
+    readonly anthropicBaseUrl: string | undefined;
+    /** anthropic 路由装不装 = 两把凭据任一在场(`createBrain` 同判);只读在场性。 */
+    readonly anthropicRouteMounted: boolean;
+    /**
+     * env 腿模型的 provider 词:显式 `MODEL_PROVIDER` 胜(原样,**不在此过闭集** —— 域外拒启是 `model-provider-word` 那条不变量的事);
+     * 缺席时「`ANTHROPIC_BASE_URL` + anthropic 凭据两样齐」⇒ `anthropic`(provider 推断),否则 `gateway`。
+     */
+    readonly provider: string;
+    /** `provider` 的来路(推断那一臂启动时要说一句)。 */
+    readonly providerSource: "explicit" | "inferred" | "default";
+    /** `MODEL_ID`;空串 = 没有 env 主槽(env 腿不铸任何可派发条目)。 */
+    readonly mainId: string;
+    /** cheap 槽铸不铸(见 {@link EnvCheapSlot})。 */
+    readonly cheapSlot: EnvCheapSlot;
+}
+/** 逗号串读法的归一点:逐项 trim、丢空项(缺席 = 空串 = `[]`)。本文件的 CSV 路由键与 `config.ts` 的逗号串旋钮(按名薄壳 `csv(name)`)同读这一只;
+ *  目录模块的回显分词与 `SERVICE_AUTH_TOKENS` 的 `k=v` 对分词是同形的另两处,尚未改调(清账版收,本函数届时挪到中性模块)。 */
+export declare const csvOf: (raw: string | undefined) => string[];
+/**
+ * **env 模型路由读数的唯一读口**(纯:按 {@link MODEL_ROUTE_ENV_KEYS} 点名取值,不读 `process.env`,不枚举入参)。
+ * `parseModelDomain`(起服铸 `ServiceConfig`)与 {@link judgeModelRouteGap}(判官)吃同一份读数。
+ */
+export declare function readModelRouteEnv(env: ModelRouteEnv): ModelRouteEnvReading;
+/**
+ * **env 腿的条目表** —— 主槽别名 `default` + 主槽 id(+ 铸出的 cheap 槽);没有 `MODEL_ID` ⇒ 空表(不铸占位条目:一个不存在的模型名
+ * 进可选目录 / 当缺省,正是 3.0.0 删掉的那种病)。`parseModelDomain` 铸真 `Model` 表与判官铸路由切面都经这一只,条目名与键序不会各写一份。
+ */
+export declare function envLaneTable<M extends {
+    readonly id: string;
+}>(mainId: string, main: M, cheap: M | undefined): Record<string, M>;
+/** {@link judgeModelRouteGap} 的旁路入参。 */
+export interface ModelRouteGapOptions {
+    /**
+     * env 腿的模型会不会被派发(缺省 `true`)。起服期严格名册布防(`CONFIG_REQUIRE_ROSTER=true` 且接了远程中心、非 dryRun)= 运维声明 env
+     * `MODEL_ID` 是**占位**:名册落地前计费提交 503、落地后整表换装 ⇒ env 腿从不被派发,不在「配置能派发到的」射程里(备用网关那一条与派发
+     * 无关,照判)。布防与否是中心接入的事实(不是路由键),快照读不出 ⇒ 由调用方给;壳问「本机引擎、配置在本机」那一形不用传。
+     */
+    readonly envLaneDispatchable?: boolean;
+}
+/**
+ * 判官的读数(闭集三词,穷举 switch 消费):
+ *  · `none` —— 无缺口,仅此一键;
+ *  · 缺口两词 —— `code` = 起服拒启的机读码(与 `reason` 里的方括号码同一个词;`lane_credential_missing` 也带 `config.model_route_endpoint_missing`),
+ *    `reason` = 起服拒启句原文(点名条目与出路)。
+ */
+export type ModelRouteGapReading = {
+    readonly gap: "none";
+} | {
+    [G in ModelRouteGapBreach]: {
+        readonly gap: G;
+        readonly code: ModelRouteEndpointVerdict["code"];
+        readonly reason: string;
+    };
+}[ModelRouteGapBreach];
+/**
+ * **起服前可调的模型路由缺口纯判官**(与起服判官同一实现;包根导出)。
+ *
+ * @param env 一份 env 快照(只读 {@link MODEL_ROUTE_ENV_KEYS} 那八把键;`process.env` 也行 —— 起服段就是这样调的)。
+ * @returns 三词之一;有缺口时带 `code` 与 `reason`(见 {@link ModelRouteGapReading})。
+ */
+export declare function judgeModelRouteGap(env: ModelRouteEnv, opts?: ModelRouteGapOptions): ModelRouteGapReading;
+//# sourceMappingURL=model-route-gap.d.ts.map

package/dist/model-route-gap.js

@@ -0,0 +1,80 @@
+import { DEFAULT_MODEL_REF } from "./model-select.js";
+import { judgeModelRouteEndpoint } from "./model-route-endpoint.js";
+export const MODEL_ROUTE_ENV_KEYS = {
+    gatewayBaseUrl: "MODEL_GATEWAY_BASEURL",
+    gatewayFallbackUrls: "MODEL_GATEWAY_FALLBACK_URLS",
+    provider: "MODEL_PROVIDER",
+    mainId: "MODEL_ID",
+    cheapId: "MODEL_CHEAP_ID",
+    anthropicApiKey: "ANTHROPIC_API_KEY",
+    anthropicAuthToken: "ANTHROPIC_AUTH_TOKEN",
+    anthropicBaseUrl: "ANTHROPIC_BASE_URL",
+};
+export function mintedCheapId(slot) {
+    switch (slot.kind) {
+        case "minted":
+            return slot.id;
+        case "absent":
+        case "without_main":
+        case "same_as_main":
+            return undefined;
+    }
+}
+const declaredValue = (v) => (v !== undefined && v !== "" ? v : undefined);
+export const csvOf = (raw) => (raw ?? "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+export function readModelRouteEnv(env) {
+    const K = MODEL_ROUTE_ENV_KEYS;
+    const anthropicApiKey = declaredValue(env[K.anthropicApiKey]);
+    const anthropicAuthToken = declaredValue(env[K.anthropicAuthToken]);
+    const anthropicBaseUrl = declaredValue(env[K.anthropicBaseUrl]);
+    const anthropicRouteMounted = anthropicApiKey !== undefined || anthropicAuthToken !== undefined;
+    const explicitProvider = declaredValue(env[K.provider]);
+    const inferAnthropic = anthropicBaseUrl !== undefined && anthropicRouteMounted;
+    const mainId = env[K.mainId] ?? "";
+    const rawCheapId = env[K.cheapId];
+    return {
+        gatewayBaseUrl: declaredValue(env[K.gatewayBaseUrl]),
+        gatewayFallbackUrls: csvOf(env[K.gatewayFallbackUrls]),
+        anthropicApiKey,
+        anthropicAuthToken,
+        anthropicBaseUrl,
+        anthropicRouteMounted,
+        provider: explicitProvider ?? (inferAnthropic ? "anthropic" : "gateway"),
+        providerSource: explicitProvider !== undefined ? "explicit" : inferAnthropic ? "inferred" : "default",
+        mainId,
+        cheapSlot: !rawCheapId
+            ? { kind: "absent" }
+            : mainId === ""
+                ? { kind: "without_main", id: rawCheapId }
+                : rawCheapId === mainId
+                    ? { kind: "same_as_main", id: rawCheapId }
+                    : { kind: "minted", id: rawCheapId },
+    };
+}
+export function envLaneTable(mainId, main, cheap) {
+    if (mainId === "")
+        return {};
+    const table = { [DEFAULT_MODEL_REF]: main, [main.id]: main };
+    if (cheap !== undefined)
+        table[cheap.id] = cheap;
+    return table;
+}
+export function judgeModelRouteGap(env, opts = {}) {
+    const r = readModelRouteEnv(env);
+    const slot = (id) => ({ id, baseUrl: "", provider: r.provider });
+    const cheapId = mintedCheapId(r.cheapSlot);
+    const models = opts.envLaneDispatchable === false ? {} : envLaneTable(r.mainId, slot(r.mainId), cheapId !== undefined ? slot(cheapId) : undefined);
+    const verdict = judgeModelRouteEndpoint({
+        gatewayBaseUrl: r.gatewayBaseUrl,
+        gatewayFallbackUrls: r.gatewayFallbackUrls,
+        anthropic: r.anthropicRouteMounted ? {} : undefined,
+        models,
+    });
+    if (verdict === undefined)
+        return { gap: "none" };
+    return { gap: verdict.gap, code: verdict.code, reason: verdict.reason };
+}
+//# sourceMappingURL=model-route-gap.js.map