@sema-agent/server 7.146.0 → 7.147.0

package/dist/memory-incident-sink.js

@@ -1,3 +1,5 @@
+import { recordFailOpen } from "./observability/fail-open.js";
+import { isStoreFormRefusalCode } from "./memory-store-refusal.js";
 import { redactIncarnations } from "./session-incarnation.js";
 import { codeFieldOf } from "./terminal.js";
 import { seatText } from "./trace/exit-seat.js";
@@ -10,6 +12,9 @@ export function createMemoryEngineIncidentSink(deps) {
             detail: redactIncarnations(String(err)),
         });
         deps.metrics?.inc("memory_engine_incident_total", { ...codeField });
+        const { code } = codeField;
+        if (isStoreFormRefusalCode(code))
+            recordFailOpen("server.memory.store-form-refused-step-skipped", `code=${code}`);
     };
 }
 export function createOperatorFaceIncidentSink(deps, event) {

package/dist/memory-scope.d.ts

@@ -57,7 +57,7 @@ export declare function memoryScopeFor(config: ServiceConfig, principal?: string
  *
  * **一条规则,与车道无关**(主会话 09-23 裁 ②):项目根 = spec 解析出的**真任务根**(`boot/resolve-spec.ts`
  * 的 `realTaskRootOf`,[ref] 属主;run-local 腿 = 它的 `workspaceDir`)。本进程读得到这个根 ⇒ 求项目身份并铸项目层键
- * (in-process 车道的真任务根是 `process.cwd()`,读得到,所以照常铸 —— 它的语义就是「项目 = 任务根指向的地方」,不需要另一个词);
+ * (无手的 `none` 车道的真任务根是 `process.cwd()`,读得到,所以照常铸 —— 它的语义就是「项目 = 任务根指向的地方」,不需要另一个词);
  * 读不到(根在沙箱/设备盘上,或 host 车道会话没登记 cwd、spec 期还不知道根)⇒ 调用方传 `undefined` ⇒ `{ absent: "unreadable" }`,
  * core 铸 operator 通知 `memory.project_scope_absent`,写照常落全局层 —— **响亮**,不是静默落 `local`。
  *
@@ -106,7 +106,7 @@ export declare function replicatesProjectLayersOf(coverage: MemoryReplicationCov
  * (`MEMORY_ENGINE_REMOTE_LANE=allow`, e.g. ssh to a host on the same NFS mount).
  *
  * Pure posture probe (memoryEngineBackendFor consumes it; main.ts logs it): `undefined` = no plane split
- * (the lane's file plane IS this worker's fs — `in-process` / `host`), `dark` = split + fail-closed, `forced` =
+ * (the lane's file plane IS this worker's fs — `none` / `host`), `dark` = split + fail-closed, `forced` =
  * split + operator override.
  * The plane question reads the execution environment block (`hostLocalPaths`, sole author `capabilitiesFor`) — it used to be the
  * hand-written synonym `lane === undefined || lane === "host"`; readings are unchanged lane by lane.

package/dist/memory-scope.js

@@ -68,7 +68,7 @@ export function replicatesProjectLayersOf(coverage, owner) {
     }
 }
 export function memoryEngineRemoteLanePosture(config) {
-    const lane = executionLaneOf(config.remoteExec?.provider);
+    const lane = config.remoteExec.provider;
     if (capabilitiesFor(config).hostLocalPaths)
         return undefined;
     return { lane, posture: config.memoryEngineRemoteLaneAllowed === true ? "forced" : "dark" };

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

@@ -1,13 +1,16 @@
 /**
- * **店形拒**(store-form refusal)在本仓的唯一读法属主(纯叶:零 http / 零 boot 依赖)—— core 一只铸点(`layout.ts` `storeFormRefusal`)的**两码一族**:
+ * **店形拒**(store-form refusal)在本仓的唯一读法属主(纯叶:零 http / 零 boot 依赖)—— core 店形拒**一族**(族表 `STORE_FORM_REFUSAL_CODES`,引擎 7.65.0 起三码;
+ * 本仓按族读,下面点名的成员只是举例与历史,不是判据):
  *  · `memory.target_outside_store`(core 7.31.1 [ref]):记忆 store 里的一个目录经软链通到了 store **外**(或 store 根在 backend 打开 / 引擎首次
  *    挂载之后被改指)⇒ 引擎对落点在外的删 / 写 / 重放 / 自身写一律**不做**;
  *  · `memory.scope_home_not_directory`(core 7.44.0 [ref]):一只 scope home(`<memoryDir>/<label>`)不是真目录 —— 被换成软链 / 普通文件 / 特殊文件
  *    (`detail.form` ∈ `symlink` | `file` | `other`,`lstat` 判、不跟链)。修前 core 对这一形抛不带码的 `ControlPlaneCorruptError`(与真控制面损坏同类同形),
- *    平铺布局(条目直接住在 home 里)于是答 500,而同一换法在嵌套布局下一层答 409 —— 现在两布局同答这一码。
- * 两码的形相同:普通 `Error` + `.code` + `.detail`(`{ path }`;home 那一码多 `form`),**句子以码领头、不含任何宿主路径**(core 7.44.0 起,
+ *    平铺布局(条目直接住在 home 里)于是答 500,而同一换法在嵌套布局下一层答 409 —— 现在两布局同答这一码;
+ *  · `memory.control_plane_links_unsupported`(core 7.65.0):记忆控制面所在的文件系统不能建硬链接 ⇒ File 记忆店在打开处被拒(构造期抛 ⇒ 起服拒;
+ *    引擎 mount 时开它自己的店被拒 ⇒ Runner 记忆相 fail-open,这一跑 memoryless,见 `memory-incident-sink.ts`)。
+ * 族里各码的形相同:普通 `Error` + `.code` + `.detail`(`{ path }`;home 那一码多 `form`),**句子以码领头、不含任何宿主路径**(core 7.44.0 起,
  * 路径只在 `detail.path`)。core 的读法:operator 要处置的盘形(去掉那只链 / 放回真目录),**不是**可重试的 IO 故障,也**不是**对调用方的裁决;
- * 盘形修好之前重发恒拒。本仓据此一条规则:两码同族、409、码原样;路径只进运维行(HTTP 映射一处,见 `http/memory-store-refusal-reply.ts`)。
+ * 盘形修好之前重发恒拒。本仓据此一条规则:族内同答、409、码原样;路径只进运维行(HTTP 映射一处,见 `http/memory-store-refusal-reply.ts`)。
  *
  * ## 两条到达车道,两个读者(本模块各给一只,别处不许再写第二份判据)
  *  ① **抛出面**(抹除 / 出处 / 外源列表 / 清标 / bundle 导出导入 —— 凡触 store 树的 backend 面):`.code` 就是码
@@ -36,6 +39,16 @@
  */
 import { type ScopeHomeForm, type StoreFormRefusalCode } from "@sema-agent/core";
 import type { Logger } from "./observability/logger.js";
+/**
+ * 词表与型全取 core 包根([ref] / core 7.45.0 [ref];此前 core 不导出,本文件自写两只码字面量与族表 —— 那份手抄随本版退役):
+ *  · 族 = `STORE_FORM_REFUSAL_CODES`,型 `StoreFormRefusalCode`;族判只读族表、不点成员(族的成员归 core,不在这里由人裁)。HTTP 映射逐码写字面量
+ *    (错误码目录门扫源码字面量,变量态的码对它隐形),两处穷举:`http/memory-store-refusal-reply.ts`(operator 面)与 `http/memory-compliance-failure-reply.ts`(会话所有者面)——
+ *    引擎加一码 ⇒ 两处编译红、各补一臂(引擎 7.65.0 的第三码 `CONTROL_PLANE_LINKS_UNSUPPORTED` 就是这样补的);记忆相上撞到它的 fail-open 臂〔mount 开店被拒 / mount 后的一步记忆活被拒〕在 `memory-incident-sink.ts` 登记;
+ *  · 抛出面的形 = `StoreFormRefusal`(普通 `Error` + `code` + `detail: StoreFormRefusalDetail`);
+ *  · `detail.form` 的闭集 = `SCOPE_HOME_FORMS`(型 `ScopeHomeForm`):闭集内原样读,闭集外不读(引擎说不出的词不进运维行)。
+ */
+/** 族判(族表 `STORE_FORM_REFUSAL_CODES` 的唯一判据):{@link storeFormRefusalOf} 用它判抛出面的 `.code`;记忆事故席用它判 `codeFieldOf` 已经读出的码(那一席码只许读一次)。 */
+export declare const isStoreFormRefusalCode: (code: unknown) => code is StoreFormRefusalCode;
 /** 一次店形拒的读数(纯数据)。`path` / `form` 取自 core 的 `detail`(读不出 ⇒ `undefined`,不猜、不从句子里抠)。 */
 export interface StoreFormRefusalReading {
     readonly code: StoreFormRefusalCode;

package/dist/memory-store-refusal.js

@@ -1,5 +1,5 @@
 import { SCOPE_HOME_FORMS, STORE_FORM_REFUSAL_CODES } from "@sema-agent/core";
-const isStoreFormRefusalCode = (code) => STORE_FORM_REFUSAL_CODES.includes(code);
+export const isStoreFormRefusalCode = (code) => STORE_FORM_REFUSAL_CODES.includes(code);
 const isScopeHomeForm = (form) => SCOPE_HOME_FORMS.includes(form);
 export function storeFormRefusalOf(err) {
     if (!(err instanceof Error))

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

@@ -40,6 +40,8 @@ export declare function createMemorySyncTransport(opts: {
 /** 一层的游标文件路径:引擎根 `memoryEngineDir`(= `RunnerDeps.memoryEngineDir` 的那一个值)下 `sync-cursors/<scope 摘要>.json`。一层一只,不随对端变、不随店变。
  *  落在子目录里:与更早的根下一层文件名 `sync-cursor-<peer>.json` 的空间不相交。 */
 export declare function memorySyncCursorPath(memoryEngineDir: string, scope: string): string;
+/** 全部游标文件的父目录 `<引擎根>/sync-cursors`(游标路径与一次性迁移 M39 的名册同读这一只;缺省 File 记忆引擎根 = 数据根 ⇒ `<数据根>/sync-cursors`)。 */
+export declare function memorySyncCursorDirFor(memoryEngineDir: string): string;
 /**
  * ⑦ 停驻层的出路(闭集;今天唯一成员)。`delete_cursor` = 删掉这一层的游标文件,下一轮从空基线重收敛。读面 `memorySync.parked[].wayOut` 与运维行同读这只词;
  * 加一个词 ⇒ {@link wayOutSentence} 的穷尽 switch 编译红(句子先写好,词才上得了 wire)。

package/dist/memory-sync-client.js

@@ -1,9 +1,10 @@
-import { createHash, randomBytes } from "node:crypto";
-import { mkdir, readFile, readdir, rename, rmdir, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { readFile, readdir, rename, rmdir, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { carriesCredential, syncMemoryScope, } from "@sema-agent/core";
+import { carriesCredential, ensureDir, syncMemoryScope, } from "@sema-agent/core";
 import { replicationCovers } from "./memory-scope.js";
 import { parseProjectLayerKey } from "./project-layer-key.js";
+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";
@@ -44,7 +45,10 @@ function scopeDigest(scope) {
     return createHash("sha256").update(scope, "utf8").digest("hex").slice(0, 32);
 }
 export function memorySyncCursorPath(memoryEngineDir, scope) {
-    return join(memoryEngineDir, SYNC_CURSOR_DIR, `${scopeDigest(scope)}.json`);
+    return join(memorySyncCursorDirFor(memoryEngineDir), `${scopeDigest(scope)}.json`);
+}
+export function memorySyncCursorDirFor(memoryEngineDir) {
+    return join(memoryEngineDir, SYNC_CURSOR_DIR);
 }
 const CURSOR_AXES = { scope: true, peer: true, store: true, incarnation: true };
 const CURSOR_FOUND = { absent: true, other: true };
@@ -142,10 +146,8 @@ async function loadLayerBaseline(path, scope) {
     return { kind: "cursor", cursor };
 }
 async function saveCursor(path, cursor) {
-    await mkdir(dirname(path), { recursive: true });
-    const tmp = `${path}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
-    await writeFile(tmp, JSON.stringify(cursor), "utf8");
-    await rename(tmp, path);
+    ensureDir(dirname(path));
+    await atomicWriteFileAsync(path, JSON.stringify(cursor), { durability: "best-effort" });
 }
 const LEGACY_PEER_SEGMENT = "central";
 const LEGACY_ROOT_CURSOR_FILE = "sync-cursor-central.json";
@@ -191,7 +193,7 @@ export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
             log.warn("memory_sync_cursor_not_relocated", { path: from, to, note: "this layer already has a cursor at its path, so the file written by an earlier version stays where it is and no round reads it; delete it" });
             return;
         }
-        await mkdir(dirname(to), { recursive: true });
+        ensureDir(dirname(to));
         try {
             await rename(from, to);
         }
@@ -203,7 +205,7 @@ export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
         moved += 1;
         log.info("memory_sync_cursor_relocated", { from, to });
     };
-    const legacyDir = join(memoryEngineDir, SYNC_CURSOR_DIR, LEGACY_PEER_SEGMENT);
+    const legacyDir = join(memorySyncCursorDirFor(memoryEngineDir), LEGACY_PEER_SEGMENT);
     let names = [];
     try {
         names = await readdir(legacyDir);
@@ -214,7 +216,7 @@ export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
     }
     for (const name of [...names].sort()) {
         if (/^[0-9a-f]{32}\.json$/.test(name))
-            await move(join(legacyDir, name), join(memoryEngineDir, SYNC_CURSOR_DIR, name));
+            await move(join(legacyDir, name), join(memorySyncCursorDirFor(memoryEngineDir), name));
     }
     if (names.length > 0) {
         try {

package/dist/memory-sync.js

@@ -219,7 +219,7 @@ export async function performMemorySync(backend, sync, scope, req, now = Date.no
     const patches = [
         ...plan.pull.map((e) => {
             const base = req.baseRevs[e.id];
-            return base !== undefined ? { op: "update", id: e.id, entry: e, baseRev: base } : { op: "add", id: e.id, entry: e };
+            return base !== undefined ? { op: "update", id: e.id, entry: e, baseRev: base } : { op: "add", id: e.id, entry: e, guard: "absent" };
         }),
         ...plan.deleteLocal.map((d) => ({ op: "delete", id: d.id, baseRev: d.baseRev })),
     ];

package/dist/model-compat.d.ts

@@ -1,6 +1,8 @@
 /**
- * `Model.compat` —— 一只模型对 **openai-completions 线路**的兼容声明(core `OpenAICompletionsCompat`;
- * 声明面 settings-schema 1.10.0 `ModelEntry.compat`)。本模块是**两条腿共用的唯一判据点 + 唯一铸点**,
+ * `Model.compat` —— 一只模型对**它那条线路**的兼容声明(声明面 settings-schema 1.10.0 `ModelEntry.compat`,契约包解析透明、形归本服务):
+ * openai-completions 条目读 core `OpenAICompletionsCompat`,anthropic-messages 条目读 core `AnthropicMessagesCompat`(**按线路读**,
+ * 线路 = 条目的 `api`:core 的 `Model.compat` 按 `TApi` 分型,契约 `ModelEntry` 强制 `provider:"anthropic"` ⟺ `api:"anthropic-messages"`)。
+ * 本模块是**两条腿共用的唯一判据点 + 唯一铸点**,
  * 与 `toolFaces` 的读法(引擎根导出的 `readToolFaces`,`task-mcp.ts` / `skills-mcp.ts` 两腿同问)同一个「判据单点、多腿一致」的形。
  *
  * ## 它治的病(1.10.0 CHANGELOG + core 型面顶注双向亲读)
@@ -11,10 +13,10 @@
  * 真需求 = vLLM / Qwen 类**缺省开思考**的网关:关思考只能靠 `chat_template_kwargs.enable_thinking=false`
  * (`thinkingFormat: "qwen-chat-template"`),否则 auto 档每一轮都白烧一段思考。
  *
- * ## 三张对表全部**从 core 的型面铸**,本仓一个词都不枚举
- * `THINKING_LEVEL_TABLE` / `THINKING_FORMAT_TABLE` / `MAX_TOKENS_FIELD_TABLE` 都是 `Record<闭集词, true>`,
- * `COMPAT_KEY_READERS` 是 `{ [K in keyof Required<OpenAICompletionsCompat>]: 读器 }` 的**映射型**:
- * core 加词/删词、加键/删键,四张表当场 tsc 红(`MODEL_DEGRADE_ON` 的 `Set<DegradeReason>` 同款纪律)。
+ * ## 对表全部**从 core 的型面铸**,本仓一个词都不枚举
+ * `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 加一键、有人把它补进白名单却忘了写读器,
  * 于是这个键被**允许但不读** = 静默丢。读器与键集是**同一张表**,那个洞在结构上不存在。
  *
@@ -27,13 +29,19 @@
  * 反方向(整只模型不进)的代价则不成比例:一个拼错的 `thinkingFormat` 会让这只模型从目录里消失,
  * 用户面直接是 `request.unknown_reference`。
  *
- * 判形**整只判**:任一键不合 ⇒ 整只声明不收(和 `toolFaces` 每只工具「applied whole or not at all」
+ * 判形**整只判**(每条线路内):任一键不合 —— 含写了另一条线路的键 —— ⇒ 整只声明不收(和 `toolFaces` 每只工具「applied whole or not at all」
  * 同律)。留下好的那几键 = 让运维以为整条声明生效了,而实际发出去的请求是半张脸。
  */
 import type { Model } from "@sema-agent/core";
-/** core `OpenAICompletionsCompat` —— core 的 index 没有按名导出它,从 `Model` 的**型面**取
- *  (`Model<TApi>` 的 `compat` 按 api 分叉;openai 那支就是它)。这不是抄一份结构,是引用同一个型。 */
-export type OpenAICompletionsCompat = NonNullable<Model<"openai-completions">["compat"]>;
+import type { ModelEntry } from "@sema-agent/settings-schema";
+/** 目录条目的线路闭集 = 契约 `ModelEntry.api`(契约加一条线路 ⇒ 读器表缺一行 ⇒ tsc 红)。 */
+export type CatalogApi = ModelEntry["api"];
+/** 一条线路的 compat 型 —— core 的 index 没有按名导出它们,从 `Model` 的**型面**取(`Model<TApi>` 的 `compat` 按 api 分叉)。这不是抄一份结构,是引用同一个型。 */
+export type CompatOf<A extends CatalogApi> = NonNullable<Model<A>["compat"]>;
+/** core `OpenAICompletionsCompat`。 */
+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 的一个键)。 */
@@ -48,34 +56,40 @@ export declare const isThinkingFormat: (w: unknown) => w is ModelThinkingFormat;
 /** `maxTokensField` 两词闭集(缺席 ⇒ core 按模型 id 推断,见 `inferMaxTokensField`)。 */
 export type ModelMaxTokensField = NonNullable<OpenAICompletionsCompat["maxTokensField"]>;
 export declare const MAX_TOKENS_FIELDS: readonly ModelMaxTokensField[];
-type CompatKey = keyof Required<OpenAICompletionsCompat>;
-/** 五键闭集(书写序取自上表),未知键拒因文案的单一真源。 */
-export declare const MODEL_COMPAT_KEYS: readonly CompatKey[];
+/** anthropic 线路 `thinkingMode` 两词闭集(core:`budget` = `thinking:{type:"enabled",budget_tokens}`;`adaptive` = `thinking:{type:"adaptive"}`、无 budget、关不掉)。 */
+export type AnthropicThinkingMode = NonNullable<AnthropicMessagesCompat["thinkingMode"]>;
+export declare const ANTHROPIC_THINKING_MODES: readonly AnthropicThinkingMode[];
+type CompatKey<A extends CatalogApi> = keyof Required<CompatOf<A>>;
+/** 每条线路的键闭集(书写序取自上表),未知键拒因文案与铸点遍历的单一真源。 */
+export declare const MODEL_COMPAT_KEYS: {
+    readonly [A in CatalogApi]: readonly CompatKey<A>[];
+};
 /**
  * 一条目录条目的 `compat` 判形结果:
  *  · `{ ok: true, compat }` —— 合形(`compat` 缺席 = 这条条目没有声明,或声明了一个**空**对象:
  *    两者对 core 同义,都不铸键);
  *  · `{ ok: false, issue }` —— 判不出形,调用方**整只丢**这条声明并留一句 warn(见模块头注)。
- *    `issue` 只带键名与哪一段不合,**不带值** —— 与 `source` / `toolFaces` 同一条留痕纪律。
+ *    `issue` 只带线路、键名与哪一段不合,**不带值** —— 与 `source` / `toolFaces` 同一条留痕纪律。
  */
-export type ModelCompatRead = {
+export type ModelCompatRead<A extends CatalogApi> = {
     ok: true;
-    compat?: OpenAICompletionsCompat;
+    compat?: CompatOf<A>;
 } | {
     ok: false;
     issue: string;
 };
-/** 从任一腿的原始条目里读出 `compat` —— **本地 config.d 腿与 center 腿共用的唯一判据点**。 */
-export declare function readModelCompat(v: unknown): ModelCompatRead;
+/** 从任一腿的原始条目里读出 `compat`(按条目的线路)—— **本地 config.d 腿与 center 腿共用的唯一判据点**。 */
+export declare function readModelCompat<A extends CatalogApi>(api: A, v: unknown): ModelCompatRead<A>;
 /**
- * `Model.compat` 的**唯一铸点**(env 腿与目录腿都经这里)。层序 = 优先级,**前层逐键赢、后层补缺席**
+ * `Model.compat` 的**唯一铸点**(env 腿与目录腿都经这里;按线路)。层序 = 优先级,**前层逐键赢、后层补缺席**
  * (BL-8:目录条目声明 ?? env 缺省 —— 不是整只替换,否则一条只写了 `thinkingFormat` 的目录条目会把
  * 部署级的 `MODEL_REASONING_EFFORT_LEVELS` 静默吃掉,正是 `contextWindow`/`maxTokens` 那一族的老病)。
+ * 层必须是同一条线路的声明(调用方只把同线路的 env 缺省叠进来 —— 见 `toModel`)。
  *
  * 归一两条(两腿因此对同一个空值给出同一个下场):值 `undefined` = 这一层没声明这一键;
- * `reasoningEffortLevels` 为**空表** = 没声明这一键(env 腿的空 CSV 与目录腿的 `[]` 同义)。
+ * 数组值为**空表** = 没声明这一键(`reasoningEffortLevels` / `effortLevels`;env 腿的空 CSV 与目录腿的 `[]` 同义)。
  * 全空 ⇒ 回 `undefined` = **不铸这个键**(缺席 = core 走自己的推断 = 今日行为)。
  */
-export declare function buildModelCompat(...layers: ReadonlyArray<OpenAICompletionsCompat | undefined>): OpenAICompletionsCompat | undefined;
+export declare function buildModelCompat<A extends CatalogApi>(api: A, ...layers: ReadonlyArray<CompatOf<A> | undefined>): CompatOf<A> | undefined;
 export {};
 //# sourceMappingURL=model-compat.d.ts.map

package/dist/model-compat.js

@@ -6,47 +6,75 @@ export const THINKING_FORMATS = Object.keys(THINKING_FORMAT_TABLE);
 export const isThinkingFormat = (w) => typeof w === "string" && THINKING_FORMATS.includes(w);
 const MAX_TOKENS_FIELD_TABLE = { max_tokens: true, max_completion_tokens: true };
 export const MAX_TOKENS_FIELDS = Object.keys(MAX_TOKENS_FIELD_TABLE);
+const THINKING_MODE_TABLE = { budget: true, adaptive: true };
+export const ANTHROPIC_THINKING_MODES = Object.keys(THINKING_MODE_TABLE);
+const readBoolean = (v) => (typeof v === "boolean" ? v : undefined);
+const readLadder = (v) => (Array.isArray(v) && v.every(isThinkingTier) ? v : undefined);
 const COMPAT_KEY_READERS = {
-    supportsReasoningEffort: (v) => (typeof v === "boolean" ? v : undefined),
-    requiresReasoningContentOnAssistantMessages: (v) => (typeof v === "boolean" ? v : undefined),
-    maxTokensField: (v) => (typeof v === "string" && MAX_TOKENS_FIELDS.includes(v) ? v : undefined),
-    thinkingFormat: (v) => (isThinkingFormat(v) ? v : undefined),
-    reasoningEffortLevels: (v) => (Array.isArray(v) && v.every(isThinkingTier) ? v : undefined),
+    "openai-completions": {
+        supportsReasoningEffort: readBoolean,
+        requiresReasoningContentOnAssistantMessages: readBoolean,
+        maxTokensField: (v) => (typeof v === "string" && MAX_TOKENS_FIELDS.includes(v) ? v : undefined),
+        thinkingFormat: (v) => (isThinkingFormat(v) ? v : undefined),
+        reasoningEffortLevels: readLadder,
+    },
+    "anthropic-messages": {
+        thinkingMode: (v) => (typeof v === "string" && ANTHROPIC_THINKING_MODES.includes(v) ? v : undefined),
+        effortLevels: readLadder,
+        supportsTemperature: readBoolean,
+        contextManagement: readBoolean,
+        interleavedThinking: readBoolean,
+    },
 };
-export const MODEL_COMPAT_KEYS = Object.keys(COMPAT_KEY_READERS);
-const isCompatKey = (k) => MODEL_COMPAT_KEYS.includes(k);
-export function readModelCompat(v) {
+export const MODEL_COMPAT_KEYS = {
+    "openai-completions": Object.keys(COMPAT_KEY_READERS["openai-completions"]),
+    "anthropic-messages": Object.keys(COMPAT_KEY_READERS["anthropic-messages"]),
+};
+const isKeyOf = (table, k) => Object.hasOwn(table, k);
+export function readModelCompat(api, v) {
     if (v === undefined)
         return { ok: true };
     if (v === null || typeof v !== "object" || Array.isArray(v))
         return { ok: false, issue: `compat is ${v === null ? "null" : Array.isArray(v) ? "an array" : typeof v}, not an object of wire-compat keys` };
+    return COMPAT_LEGS[api].read(v);
+}
+function readCompatWith(api, readers, v) {
     const out = {};
     for (const [k, raw] of Object.entries(v)) {
-        if (!isCompatKey(k))
-            return { ok: false, issue: `unknown key ${JSON.stringify(k)} (valid: ${MODEL_COMPAT_KEYS.join(" | ")})` };
-        const read = COMPAT_KEY_READERS[k](raw);
+        if (!isKeyOf(readers, k))
+            return { ok: false, issue: `unknown key ${JSON.stringify(k)} for an ${api} entry (valid: ${Object.keys(readers).join(" | ")})` };
+        const read = readers[k](raw);
         if (read === undefined)
-            return { ok: false, issue: `key ${JSON.stringify(k)} does not fit the wire-compat shape` };
+            return { ok: false, issue: `key ${JSON.stringify(k)} does not fit the ${api} wire-compat shape` };
         out[k] = read;
     }
     return Object.keys(out).length > 0 ? { ok: true, compat: out } : { ok: true };
 }
-export function buildModelCompat(...layers) {
+export function buildModelCompat(api, ...layers) {
+    return COMPAT_LEGS[api].build(layers);
+}
+const declaresKey = (v) => v !== undefined && !(Array.isArray(v) && v.length === 0);
+function buildCompatWith(keys, layers) {
     const out = {};
     for (const layer of layers) {
         if (layer === undefined)
             continue;
-        for (const k of MODEL_COMPAT_KEYS) {
-            if (k in out)
+        for (const k of keys) {
+            if (Object.hasOwn(out, k) || !declaresKey(layer[k]))
                 continue;
-            const v = layer[k];
-            if (v === undefined)
-                continue;
-            if (k === "reasoningEffortLevels" && Array.isArray(v) && v.length === 0)
-                continue;
-            out[k] = v;
+            out[k] = layer[k];
         }
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
+const COMPAT_LEGS = {
+    "openai-completions": {
+        read: (v) => readCompatWith("openai-completions", COMPAT_KEY_READERS["openai-completions"], v),
+        build: (layers) => buildCompatWith(MODEL_COMPAT_KEYS["openai-completions"], layers),
+    },
+    "anthropic-messages": {
+        read: (v) => readCompatWith("anthropic-messages", COMPAT_KEY_READERS["anthropic-messages"], v),
+        build: (layers) => buildCompatWith(MODEL_COMPAT_KEYS["anthropic-messages"], layers),
+    },
+};
 //# sourceMappingURL=model-compat.js.map

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

@@ -1,6 +1,7 @@
 import { 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";
 /**
  * 条目拒因码 → 本仓铸它的成因 —— **以码为键**([ref]):码闭集的属主是 settings-schema(`MODEL_ENTRY_REFUSAL_CODES`,6.2.0 起;此前本仓
  * 自持一份同名码表,撞名已消灭、零别名)。那边加一个条目码 ⇒ 本表缺键 ⇒ 本仓 tsc 红(只拿 `satisfies` 约束码值证明的是「子集」,
@@ -132,10 +133,17 @@ export declare function echoModelRef(ref: string): string;
  * 别名段(`(catalog entry …)`)的判断读原形:ref 与条目名逐字相同 ⇒ 不带,不因回显截短而误判成「另有条目」。
  */
 export declare function modelUnavailableMessage(field: string, requested: string, name: string, r: ModelEntryRefusal): string;
-/** 缺省模型不变量读的切面(`ServiceConfig` 与 `CrossInvariantView` 都结构满足)。 */
+/** 缺省模型不变量读的切面(`ServiceConfig` 与 `CrossInvariantView` 都结构满足;可选成员缺席 = 没有被拒的候选)。 */
 export interface DefaultModelView {
     readonly models: Readonly<Record<string, unknown>>;
     readonly modelRefusals: Readonly<Record<string, ModelEntryRefusal>>;
+    /**
+     * [ref] ① —— **为何这张 env 表上没有目录**:候选判官整拒了最近一份候选(一个域都没应用),于是回落 env。值是判官交出的拒因列(`rejected.errors`,与 `config_candidate_rejected`
+     * 行体的 `errors` 同一份事实)经 `buildCandidateRejectionNotes` 投成的纯数据 —— 每个被拒文档一格:文档名 · 拒码 · 原因类词 · 文档路径(本地读腿)。**不含 `error` 原文**:
+     * 契约 / 读腿的原句可能点名链接指向的目标路径等操作数,只留在 warn 行(那里已过产出边界脱敏);句子函数不读日志、不读原句、不自铸第二份。
+     * 缺席 / 空 = 没有被拒的候选(纯 env 部署、候选被收下、dry-run)⇒ 拒因句逐字不变。只有 `env` 腿的句子读它(`catalog` 腿说的是目录候选自己没有缺省,与候选被整拒无关)。
+     */
+    readonly candidateRejectionNotes?: readonly CandidateRejectionNote[];
 }
 /**
  * 🔴 [ref] —— **这张模型表有没有一只缺省模型**(`models.default`)。`undefined` = 有。
@@ -146,6 +154,8 @@ export interface DefaultModelView {
  *
  * 拒因一句:码 + 这条腿上**真实**的出路 + 若目录在场但每条都不可用,点名它们与各自的码。env 腿句首保留 `MODEL_ID is required`
  * 这个既有的可 grep 片段(壳与运维脚本认它);目录腿不提 `MODEL_ID`(见 {@link ModelTableLeg})。
+ * env 腿若是因「候选被判官整拒」才回落到这张表({@link DefaultModelView.candidateRejectionNotes}),同一行再追加「回落原因」:被拒的文档名 + 拒码 + 原因类词 + 文档路径 ——
+ * 不带配置值、不带链接指向的目标路径、不抄任何 `error` 原文;只追加,句首的 grep 锚不动,没有被拒候选时整句逐字不变。
  */
 export declare function defaultModelRefusal(view: DefaultModelView, leg: ModelTableLeg): string | undefined;
 /** 一个被铸出的被拒名字:`name` = 被拒条目的名字,`target` = 增广把它指向的那条条目,`via` = 它是以什么身份被铸出的。 */

package/dist/model-entry-refusal.js

@@ -152,6 +152,12 @@ 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}`;
 }
+function candidateFellBackClause(notes) {
+    if (notes === undefined || notes.length === 0)
+        return "";
+    const rows = notes.map((n) => `"${n.document}" [${n.code}] ${n.cause}${n.path !== undefined ? `: ${n.path}` : ""}`);
+    return ` (the config candidate was rejected whole and none of its domains applied, so its catalog is not in this table; fix or remove the named document(s) — the config_candidate_rejected warn line has the full diagnostics — rejected: ${rows.join(" | ")})`;
+}
 export function defaultModelRefusal(view, leg) {
     if (Object.hasOwn(view.models, DEFAULT_MODEL_REF) && view.models[DEFAULT_MODEL_REF] !== undefined)
         return undefined;
@@ -161,6 +167,7 @@ export function defaultModelRefusal(view, leg) {
         case "env":
             return (`MODEL_ID is required when no catalog default resolves [${DEFAULT_MODEL_MISSING_CODE}] — this model table has no default model` +
                 unavailable +
+                candidateFellBackClause(view.candidateRejectionNotes) +
                 ". Set MODEL_ID=<model name your gateway serves>, or enable at least one model this host can serve in the catalog " +
                 "(config.d/models.json, or the web-admin) — either one is enough (a web-admin that answers after the boot budget " +
                 "counts as absent at boot: raise CONFIG_BOOT_FETCH_BUDGET_MS to wait for it).");

package/dist/namespaced-rule-name.d.ts

@@ -7,7 +7,8 @@
  * (本文件那只判与它在会话规则写口、SQL 店写口、四张条目表上的调用)退役,零双读。
  *
  * **调它的面**(点名,不是「每个面」):运维三张名表(`APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`)与中心下发的同名表、请求
- * `settings.permissions.{ask,deny}`(经 `config.ts` 的 `unmatchableToolNamesRefusal`)。会话规则写口直接调 core 的 `assertSessionRuleNamesCurrent`
+ * `settings.permissions.{ask,deny,neverAuto}`(经 `config.ts` 的 `unmatchableToolNamesRefusal`)。这些面上退役且无后继的名字在**有通告席**的表上不拒、行原样留着(唯一读法 {@link isRetiredWithoutSuccessor};
+ * 通告席见 `UnmatchableToolNameJudgment.noticeSeat`),请求体 `neverAuto` 没有通告席、照拒。会话规则写口直接调 core 的 `assertSessionRuleNamesCurrent`
  * (同一只判官的店形);引擎 allow 层的条目表(请求 `settings.permissions.allow`、运维 `APPROVAL_GRANT`、技能两只清单)交引擎 `compileAllowList`
  * (名册 = {@link TOOL_NAME_ROSTER};判官判非现役的条目读成 `tool_name`,名册里有的只差大小写读成 `near_miss`)。
  * **不调它的面**:`/v1/rules` 的持久规则写口与 `cc-import` 导入口(`http/routes/rules.ts`、`rules-consent.ts` 与两只持久规则店零判官调用)—— 如实未接,
@@ -51,6 +52,22 @@ export declare const NAME_TABLE_BEHAVIOR: "deny";
  * (core 7.55.0 [ref]:`mcp__*` 在 deny / ask 里是这一协议的每一只工具、在 allow 里什么也不是),漏传态度的调用点是编译错,不是一条静默的「不带态度」读法。
  */
 export declare function unmatchableRuleNameOf(name: string, behavior: PermissionRule["behavior"]): UnmatchableRuleName | undefined;
+/**
+ * **限制表上跳过的那一行**,唯一一只读法:引擎判官判 `retired`,且判词**不带** 1:1 后继 `currentName`(退役表那一行写的是 `removed` / `folded into`,不是 `renamed`)。
+ * 这样一行够不着任何工具,也没有可以改写成的现名 —— 引擎准备期的名字审计用同一位(`retired` ∧ 无 `currentName`)把它排出审计、照跑,并铸一条 `config.legacy_tool_name`。
+ * 本服务**有通告席**的前门读这一只:**不拒、不改写表**(行原样留着 —— 与引擎同:引擎只把它排出审计,编出的策略里那一行照在,名册里真有同名工具时它照管);
+ * 不拒必须配恰一句话 —— 没有人说话的表(请求体 `settings.permissions.neverAuto`、选择器清单)照拒:选择器 / 技能表候引擎发退役名通告,`neverAuto` 候引擎导出通告句源后由本服务铸。
+ * 谁读这张表谁说一句:引擎读的表(请求体 `settings.permissions` 的规则桶)由引擎铸通告;只有本服务读的表(运维 `APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`、
+ * 中心下发的 `approvalRequire`)由读它的那一处按 {@link retiredWithoutSuccessorEntries} 在起服 / 落配日志里点名。本服务的名册看不到嵌入方自挂的工具,
+ * 所以「够不着」只对本服务知道的工具成立 —— 去掉这一行会让嵌入方自挂的同名工具失去这条限制(静默放宽),留着它最坏是一条死行。
+ * 有后继的改名(`Task` ⇒ `Agent`、`KillShell` ⇒ `TaskStop`)不是这一形:写的人要的那只工具换了名字,照拒并给现名。其它判词不经这里。
+ */
+export declare function isRetiredWithoutSuccessor(v: UnmatchableRuleName | undefined): boolean;
+/** 一张**只有本服务读**的限制名表(条目就是工具名:运维 `APPROVAL_REQUIRE` / `DENY` / `NEVER_AUTO`、中心下发的 `approvalRequire`)里按 {@link isRetiredWithoutSuccessor} 读出的那几行(带退役表自己那一行),供读表处点名;表本身不动。 */
+export declare function retiredWithoutSuccessorEntries(names: readonly string[], behavior: PermissionRule["behavior"]): readonly {
+    readonly entry: string;
+    readonly guidance: string;
+}[];
 /**
  * 判词 → 「为什么永远匹配不到 + 怎么写」(不复述条目本身 —— 调用方的句子已点名它)。引擎判词的 `guidance` 原样带出,是改法指引的**唯一**一句
  * (本仓不在后面追加 1:1 现名:通配名上那个现名是摘要名或更窄的写法,照写不生效;现名过境给机器读的位,如会话规则拒体顶层的 `currentName`);

package/dist/namespaced-rule-name.js

@@ -10,6 +10,18 @@ export function unmatchableRuleNameOf(name, behavior) {
     const verdict = judgeRuleToolName(name, TOOL_NAME_ROSTER, behavior);
     return verdict.kind === "current" ? undefined : verdict;
 }
+export function isRetiredWithoutSuccessor(v) {
+    return v?.kind === "retired" && v.currentName === undefined;
+}
+export function retiredWithoutSuccessorEntries(names, behavior) {
+    const out = [];
+    for (const name of names) {
+        const verdict = unmatchableRuleNameOf(name, behavior);
+        if (verdict?.kind === "retired" && isRetiredWithoutSuccessor(verdict))
+            out.push({ entry: name, guidance: verdict.guidance });
+    }
+    return out;
+}
 export function describeUnmatchableRuleName(v, name) {
     switch (v.kind) {
         case "retired":