@sema-agent/server 7.145.0 → 7.147.0

package/dist/memory-operator-faces.d.ts

@@ -58,7 +58,7 @@
  * core 自己响亮拒(`memory.erasure_evidence_unavailable`),那是**运行期**的诚实拒,与「换部署形态才行」
  * 不是一回事(附录 A 两条分列)。
  */
-import { type EntryProvenanceAccount, type MemoryBackend, type MemoryEntryOrigin, type MemoryErasureAttestation, type OriginClearanceRow, type DeploymentSessionMemoryStatus, type SessionCaptureRecordStore } from "@sema-agent/core";
+import { type EntryProvenanceAccount, type MemoryBackend, type MemoryEntryOrigin, type MemoryErasureAttestation, type OriginClearanceRow, type DeploymentSessionMemoryStatus, type SessionCaptureRecordStore, type SessionMemoryStatus } from "@sema-agent/core";
 import { type MemoryScopeStores } from "./memory-scope-stores.js";
 import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
 /**
@@ -249,11 +249,16 @@ export interface SessionMemoryStatusFace {
 /** 一份会话记忆状态的读法(见 {@link SessionMemoryStatusFace.readingAt})。 */
 export interface SessionMemoryStatusReading {
     readonly key: string;
-    /** 引擎的答案,原样(引擎不抛:读不出的源 = 缺席的键)。路由只投 wire 的五键。 */
+    /** 引擎的答案,原样(引擎不抛:读不出的源 = 缺席的键)。路由只投 wire 的键。 */
     status: (sessionId: string) => Promise<SessionMemoryView>;
 }
-/** 状态面上 wire 的五键所在的那一份:部署对象答案去掉逐店明细 `planes`(逐店明细不上 wire,见 `core-keyset-guard.ts`)。 */
-export type SessionMemoryView = Omit<DeploymentSessionMemoryStatus, "planes">;
+/**
+ * 状态面上 wire 的键所在的那一份,**引擎的答案原样**:带层座 ⇒ 那只店的引擎答案(`SessionMemoryStatus`:五键 + `writeHome`,`writeHome` 是店绑定的键);
+ * 不带层座 ⇒ 部署对象的答案(`DeploymentSessionMemoryStatus`:引擎折好的五键 + 引擎择好的会话级 `writeHome` + 逐店明细 `planes`,每行是一只店原样的 `SessionMemoryStatus`)。
+ * 会话级 `writeHome` 由引擎在店之间择一(点名家的店里较新的那只的家,原样;任一店读不出 / 同刻 / 无店点名 ⇒ 缺席);本服务不折、不择一、不去重,
+ * 路由把顶层 `writeHome` 与每行的 `plane` / `writeHome` 原样投出(见 `core-keyset-guard.ts` ⑩e)。
+ */
+export type SessionMemoryView = SessionMemoryStatus & Partial<Pick<DeploymentSessionMemoryStatus, "planes">>;
 /**
  * [ref] seam①([ref] §S-7,core 7.0.2 [ref] 件1)—— `GET /v1/sessions/:id/memory-status` 的引擎面。
  * 命名照 CLAUDE.md 工厂律:返回带行为的活对象 ⇒ `create*`。

package/dist/memory-scope-stores.d.ts

@@ -2,10 +2,11 @@
  * 记忆作用域店 —— 本部署的记忆在本宿主的**唯一持有者**:「一层住在哪只店」与「本部署有哪些店」都只在这里答。
  *
  * ## 规则(一条)
- * 一层(scope)的平面只有引擎的纯分类函数答(`scopePlanesOf`,契约 = 本服务铸 spec 时盖在会话上的同一只判据 {@link memoryScopeContractOf});
+ * 一层(scope)的平面只有引擎答(`memoryScopePlaneOf`,契约 = 本服务铸 spec 时盖在会话上的同一只判据 {@link memoryScopeContractOf});
  * 一层的店 = 它那只平面的店(项目平面 = 部署的店;目录钉住的部署上个人平面是个人挂载上的另一只店,引擎的 `resolveMemoryScopeStore` 开它)。
- * **本部署有哪些店**只有引擎的部署对象答(`createMemoryDeployment(…).stores()`):项目店,再加上个人挂载**在盘上**的那只个人店 ——
- * 盘的集合,不是配置点名的层推出来的集合(配置只决定会话往哪写;换了 `MEMORY_SCOPE` 之后个人挂载上留下的那只店照样在集合里)。
+ * **本部署有哪些店**只有引擎的部署对象答(`createMemoryDeployment(…).stores()`,契约 `memory.deployment.store_set`):项目店,再加上个人挂载上
+ * **存有记录**的那只个人店 —— 盘的集合,不是配置点名的层推出来的集合(配置只决定会话往哪写;换了 `MEMORY_SCOPE` 之后个人挂载上写过的那只店照样在集合里),
+ * 也不是「开过」的集合(打开 / 读 / 被拒的请求只留下引擎具名的工件,不让店进集;每次从盘上读,每只部署对象答同一个集合)。
  * 本服务在会话之外读写某一层的每一条腿(同步执行器、项目层折叠、中心侧导出 / 同步、bundle 导出导入、合规抹除 / 出处、外源标记、会话记忆状态、整理)
  * 一律问**本对象**。本对象就是起服装配出来的那只记忆引擎对象(`boot/stores.ts` 的 `memoryEngine`、`run-local.ts` 的同名量):它的 `backend` / `root`
  * 正是交给 Runner 的两件事实(`RunnerDeps.memoryBackend` / `RunnerDeps.memoryEngineDir`)—— 宿主腿与会话对同一层答同一只店。每进程一只,所有腿共用。
@@ -18,7 +19,7 @@
  *
  * ## 请求的店({@link memoryStoreForRequest})
  * 点名层的动词按点名的层取店;点名的几层不在同一只店 ⇒ 响亮拒(一次请求只落一只店)。不点名层的条目 id / 店级账本动词答在**本部署唯一的那只店**上;
- * 部署有两只店(盘上有个人店)⇒ 不猜,响亮拒并指路「在请求里点名层」。没有部署对象的部署(SQL 记忆孪生,不钉目录 ⇒ 两个平面同一只店)恒是一只店。
+ * 部署有两只店(个人挂载上的店存有记录)⇒ 不猜,响亮拒并指路「在请求里点名层」。没有部署对象的部署(SQL 记忆孪生,不钉目录 ⇒ 两个平面同一只店)恒是一只店。
  */
 import { type MemoryBackend, type MemoryDeployment } from "@sema-agent/core";
 import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
@@ -29,7 +30,7 @@ export interface MemoryScopeStores {
     readonly root: string;
     /** capture opt-out 记录源(起服取一次的那一只;缺席 ⇒ 引擎各自的文件缺省)。本部署每一只记忆引擎 —— 部署对象、各操作面按店构造的引擎 —— 都只读这一格。 */
     readonly captureRecords: SessionCaptureRecordSource | undefined;
-    /** 层 `layer` 的平面(引擎的规范化 + 纯分类函数,与引擎的店解析同一读法;零建店、零读盘)。引擎读不出的层键 ⇒ 抛引擎的 `config.memory_scope_key`,原样。 */
+    /** 层 `layer` 的平面(引擎的 `memoryScopePlaneOf`,与引擎的店解析同一只;零建店、零读盘)。引擎读不出的层键 ⇒ 抛引擎的 `config.memory_scope_key`,原样。 */
     planeOf(layer: string): "project" | "personal";
     /** 层 `layer` 住的那只店(先判平面、每个平面一只实例)。读不出的层键 ⇒ 同 {@link MemoryScopeStores.planeOf}。 */
     storeOf(layer: string): MemoryBackend;
@@ -37,7 +38,8 @@ export interface MemoryScopeStores {
     deployment(): MemoryDeployment | undefined;
 }
 /**
- * 控制面归属判据 —— 记忆操作面(合规 / 外源标记 / 会话记忆状态 / consolidation 阀门的 D1 拒启门)与部署对象共用的**同一只**谓词:
+ * 控制面归属判据 —— 记忆操作面(合规 / 外源标记 / 会话记忆状态)与部署对象共用的**同一只**谓词(这些部署面问「后端发不发布控制面」;
+ * 整理阀门问的是另一件事 —— 整理状态随不随后端走 —— 只问引擎的 `memoryGovernanceDurability`,见 `boot/memory-consolidation.ts`):
  * backend 的面上带**非空** `controlPlaneRoot` 才算归属在案。空串与缺席同判「不归属」:core 对空串会 truthy-回退到本副本盘上派生控制面
  * (engine 构造里的 `backendControl ? … : derive(…)`),对无状态多副本部署这正是 D1 要拒的那台机器(折叠账随 pod 一起死)。
  */
@@ -63,7 +65,7 @@ export declare class MemoryLayerRefusal extends Error {
 /**
  * 一次请求的记忆店。`layers` = 请求点名的层(空 = 没点名):
  *  · 点名 ⇒ 它们共住的那一只店;分住两只 ⇒ 拒(一次请求只落一只店,按店拆成几次请求)。
- *  · 没点名 ⇒ 本部署唯一的那只店(= 部署的店);部署有两只店(盘上有个人店,{@link MemoryScopeStores.deployment})⇒ 拒,指路在请求里点名层。
+ *  · 没点名 ⇒ 本部署唯一的那只店(= 部署的店);部署有两只店(个人挂载上的店存有记录,{@link MemoryScopeStores.deployment})⇒ 拒,指路在请求里点名层。
  * `seat` = 这个动词点名层的那一处(拒句里指路用,如 `` `scope` ``;缺省 = 层座 `scope`)。
  * 拒一律 {@link MemoryLayerRefusal}(读不出的层键同码,引擎原句随句)。
  */

package/dist/memory-scope-stores.js

@@ -1,4 +1,4 @@
-import { createMemoryDeployment, normalizeMemorySpec, resolveMemoryScopeStore, scopePlanesOf } from "@sema-agent/core";
+import { createMemoryDeployment, memoryScopePlaneOf, resolveMemoryScopeStore } from "@sema-agent/core";
 import { memoryScopeContractOf } from "./memory-scope.js";
 export function backendOwnsControlPlane(backend) {
     return controlPlaneRootOf(backend) !== undefined;
@@ -7,6 +7,7 @@ export function controlPlaneRootOf(backend) {
     const root = backend?.controlPlaneRoot;
     return typeof root === "string" && root !== "" ? root : undefined;
 }
+const PLANE_FACE = "memoryScopeStores.planeOf";
 export function createMemoryScopeStores(input) {
     let personal;
     const resolve = (layer) => resolveMemoryScopeStore({
@@ -16,19 +17,7 @@ export function createMemoryScopeStores(input) {
         memoryEngineDir: input.root,
         ...(input.onIncident !== undefined ? { onIncident: input.onIncident } : {}),
     });
-    const planeOf = (layer) => {
-        const contract = memoryScopeContractOf([layer]);
-        let spec;
-        try {
-            spec = normalizeMemorySpec({ scopes: [layer], writeScope: layer, ...(contract !== undefined ? { scopeContract: contract } : {}) });
-        }
-        catch {
-            spec = undefined;
-        }
-        if (spec === undefined || spec.writeScope === null)
-            return resolve(layer).plane;
-        return scopePlanesOf(spec.scopes, spec.writeScope, spec.scopeContract)?.writePlane ?? "project";
-    };
+    const planeOf = (layer) => memoryScopePlaneOf(PLANE_FACE, layer, memoryScopeContractOf([layer]));
     let deployment;
     return {
         backend: input.backend,

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.
@@ -173,6 +173,42 @@ export declare function memoryEngineRootFor(config: Pick<ServiceConfig, "memoryE
  *  所以它的根必须走这条链而不是 `memoryEngineRootFor` 的分派(codex 修复验证轮 [medium]:分派会把 run-local 的
  *  记忆搬到 `<localDataRoot>/memory-work`,存量记忆与控制面升级后隐形)。 */
 export declare function fileMemoryEngineRoot(config: Pick<ServiceConfig, "memoryEngineDir">, fallbackRoot?: string): string;
+/**
+ * 一条路径的**规范形**(给 {@link judgeMemoryRootOutsideDataRoot} 的 `canonical` 座用的生产实现):
+ *  · 既存的绝对路径 ⇒ **原样**交给 `realpath`(`.native`:大小写不敏感的文件系统上返回盘上的拼写;符号链接、macOS 的 `/var` → `/private/var` 在这一步展平)。
+ *    不先在字串上折 `..`:操作系统在展开符号链接**之后**才折 `..`,`/link/..` 的真身是链接目标的父目录,字串折叠会把它读成 `/`;
+ *  · 其余(尚不存在 / 相对)⇒ 绝对化并折叠 → 取**最深既存祖先**的 `realpath` → 接回尚不存在的尾巴(尾巴只做字串规范化)。
+ *
+ * 为什么按「最深既存祖先」而不是直接 `realpath(p)`:boot 期记忆根常常还没建出来(新数据根),`realpath` 对不存在的路径抛 ENOENT,
+ * 而数据根那一侧已经存在、会被展平 —— 两侧拼写空间不一样,同一个目录会被读成「不在其下」。祖先用 `existsSync` 找(它对 ENOENT / ENOTDIR / EACCES / ELOOP
+ * 一律答 `false`,不抛),所以走到的那一级一定 stat 得动;`realpath` 仍可能在「探完到取值之间目录被挪走 / 搜索权限被收」的竞态里抛 ——
+ * 不在本函数里吞(吞了就是一条无声的降级臂),由 boot 调用点接住并响亮报一行(`memory_engine_dir_check_unavailable`),起服照常。
+ *
+ * 取舍:尾巴(不存在的那几段)只比规范化字串,**不折大小写**,`..` 也按字串折:两个只差大小写、且都还不存在的拼写在大小写不敏感的盘上会被读成两处 ——
+ * 方向是多报一条 warn(这条判据的失败方向),不会漏报。
+ */
+export declare function canonicalPathOf(p: string): string;
+/** {@link judgeMemoryRootOutsideDataRoot} 的读数:记忆引擎的根落在本机数据根**之外**。三键即 boot 日志行的字段(`hint` 是一句带两条真路径的人话)。 */
+export type MemoryRootOutsideDataRoot = {
+    readonly root: string;
+    readonly dataRoot: string;
+    readonly hint: string;
+};
+/**
+ * 【判官】file 形记忆引擎的**已解析根**是不是落在本机数据根(`config.localDataRoot`)**之外** —— 是 ⇒ 回两条真路径(boot 打一条 warn),不是 ⇒ `undefined`。
+ *
+ * 判据只有这一条**路径包含**:`path.relative(数据根, 记忆根)` 不以 `..` 段开头、也不是绝对路径(跨盘符)⇒ 在其下(相等也算在其下)。**与 env 是否显式无关**:
+ * `MEMORY_ENGINE_DIR` 缺席不是判据(此前判据是「`LOCAL_DATA_ROOT` 在 ∧ `MEMORY_ENGINE_DIR` 缺席」,于是 `AGENT_DATA_DIR` 已把两者放在同一处时,
+ * 「正在共享全机默认库」一句不真,而显式 `MEMORY_ENGINE_DIR` 指到数据根之外的真分家反而不报)。数据根缺席 ⇒ 无从比较,不报。
+ *
+ * 纯函数:不读 env、不读盘 —— 规范化走 `canonical` 座(缺省 `path.resolve`,字串规范形;boot 递 {@link canonicalPathOf} 取符号链接 / 大小写展平后的形)。
+ * 读数里的两条路径是**调用方给的原样拼写**(运维认得出来的那两条),不是规范形。
+ */
+export declare function judgeMemoryRootOutsideDataRoot(a: {
+    readonly memoryRoot: string;
+    readonly dataRoot: string | undefined;
+    readonly canonical?: (p: string) => string;
+}): MemoryRootOutsideDataRoot | undefined;
 /** 本部署 file 记忆引擎的**平面三坐标**(根 / 记忆目录 / 控制面目录)—— {@link fileMemoryPlaneFor} 一次算齐。 */
 export interface FileMemoryPlane {
     readonly root: string;

package/dist/memory-scope.js

@@ -1,4 +1,5 @@
-import { join } from "node:path";
+import { existsSync, realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { FileMemoryEngineBackend, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope, normalizeMemorySpec } from "@sema-agent/core";
 import { capabilitiesFor, executionLaneOf } from "./execution-lane-caps.js";
 import { assertMemoryScopeWidth } from "./plugins/memory-key-guards.js";
@@ -9,6 +10,7 @@ const V2_SCOPE_PREFIX_BY_KIND = {
     org: "org:",
     proj: "proj:",
     userproj: "userproj:",
+    userlocal: "userlocal:",
 };
 export const V2_SCOPE_PREFIXES = Object.freeze(Object.values(V2_SCOPE_PREFIX_BY_KIND));
 export function isV2ScopeKey(key) {
@@ -66,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" };
@@ -108,6 +110,35 @@ export function memoryEngineRootFor(config, localRoot) {
 export function fileMemoryEngineRoot(config, fallbackRoot) {
     return resolveMemoryEngineRoot(config.memoryEngineDir ?? fallbackRoot);
 }
+export function canonicalPathOf(p) {
+    if (isAbsolute(p) && existsSync(p))
+        return realpathSync.native(p);
+    const abs = resolve(p);
+    let existing = abs;
+    const tail = [];
+    while (!existsSync(existing)) {
+        const parent = dirname(existing);
+        if (parent === existing)
+            return abs;
+        tail.unshift(basename(existing));
+        existing = parent;
+    }
+    return join(realpathSync.native(existing), ...tail);
+}
+export function judgeMemoryRootOutsideDataRoot(a) {
+    if (!a.dataRoot)
+        return undefined;
+    const canonical = a.canonical ?? resolve;
+    const rel = relative(canonical(a.dataRoot), canonical(a.memoryRoot));
+    const inside = rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+    if (inside)
+        return undefined;
+    return {
+        root: a.memoryRoot,
+        dataRoot: a.dataRoot,
+        hint: `memory engine root ${a.memoryRoot} is outside the local data root ${a.dataRoot}; set MEMORY_ENGINE_DIR under ${a.dataRoot} to isolate it`,
+    };
+}
 export function fileMemoryPlaneFor(config, fallbackRoot) {
     if (config.requirePrincipal === true || !config.memoryEngineEnabled)
         return undefined;

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` = 它是以什么身份被铸出的。 */