@sema-agent/server 7.122.0 → 7.123.0

package/dist/config-center/read-warnings.d.ts

@@ -25,7 +25,8 @@
  * 候选门整拒,而它在 1.10.0 上零告警零 domainErrors(亲验读数)。兼容臂的关窗观测归属主(settings-schema 的
  * `onWarning` 流),不借候选门这条带副作用的通道传信息。
  */
-import { type EffectiveReadWarning } from "@sema-agent/settings-schema";
+import { z } from "zod";
+import { type DroppedEntryIdentity, type DroppedEntryReasonCode, type EffectiveReadWarning } from "@sema-agent/settings-schema";
 /** 折叠产物:`scope` 决定消费方做什么 —— `"domain"` 进候选门(`domainErrors`),`"entry"` 进逐条丢弃面(`droppedEntries`)。 */
 export type FoldedReadWarning = {
     readonly scope: "domain";
@@ -36,12 +37,16 @@ export type FoldedReadWarning = {
     readonly domain: string;
     readonly entry: string;
     readonly error: string;
+    readonly reasonCode: DroppedEntryReasonCode;
 };
-/** 逐条丢弃面的一行(两条读腿的 `droppedEntries` 同形):`entry` = 被丢那条的出门形坐标(`models.1`),`error` = 哪些字段、为什么。 */
+/** 逐条丢弃面的一行(两条读腿的 `droppedEntries` 同形,`config_entry_dropped` 日志行读它):`entry` = 被丢那条的出门形坐标(`models.1`),
+ *  `error` = 哪些字段、为什么(人读),`reasonCode` = 为什么丢的**闭集词**(S-1295:settings-schema 铸、原样过境 —— 目录行的
+ *  `GET /v1/models.droppedEntries[].reasonCode` 就是这同一个词,取自同一次折叠的同一行)。 */
 export type DroppedConfigEntry = {
     readonly domain: string;
     readonly entry: string;
     readonly error: string;
+    readonly reasonCode: DroppedEntryReasonCode;
 };
 /**
  * zod 形的错误 → 一行可读的字段诊断(`contextWindow: expected number, received string; api: custom`)。
@@ -58,41 +63,42 @@ export declare function describeSchemaIssueFields(error: unknown): string[];
 /** null = 不入诊断面(`hosts-grandfathered` / `legacy-governance-lifted`:值已被收编接受,与本地店同口径)。 */
 export declare function foldEffectiveReadWarning(w: EffectiveReadWarning): FoldedReadWarning | null;
 /**
- * 🔴 S-712 —— 一条被 schema 逐条丢掉的**启用**、**有名**目录条目的身份(模型面墓碑的来源;载体 = `EffectiveConfig.models.droppedIdentities`,
- * 随 effective 走 —— 盘上 LKG 从同一个对象落盘,重启从 LKG 起服墓碑不丢)。
+ * 🔴 S-712 / S-1295 —— **被丢目录条目的载体行**(载体 = `EffectiveConfig.models.droppedCatalogEntries`,读腿铸,随 effective 走 —— 盘上 LKG
+ * 从同一个对象落盘,重启从 LKG 起服时它还在)。形的**唯一定义**(型由它推出;判据按它判盘上来的行)。
  *
- * 为什么要交出身份:条目被丢之后它的名字从目录里消失,而档位增广(core `expandTiers`)会把一个**空出来的**档位词 / CC 别名
- * (条目恰好叫 `sonnet` / `pro` …)重新铸到另一条条目上 —— 显式点它的请求与点名它的角色绑定就这样被静默换了目的地
- * (gpt-6 腿 F2 / F3,真复现)。身份进 `modelRefusals` 之后,不变量 `refused-names-not-minted` 才判得到它。
+ * **规则一条:读腿把 schema 逐条丢掉的每一条目录条目(`models` 域的 `["models", <下标>]`)记一行,写入时不挑;每个读者读自己要的那一部分。**
+ *  · 墓碑判据(`model-entry-refusal.ts` `judgeCatalogEntries`)—— 有名(`identity.name`)且未停用(`identity.enabled !== false`)的行;
+ *  · `GET /v1/models` 的 `droppedEntries`({@link buildDroppedEntriesWire})—— 每一行的下标、闭集词与可披露身份;
+ *  · `config_entry_dropped` 日志行读的是这一行由之而来的那条折叠行({@link DroppedConfigEntry},同一次折叠、同一个词)。
+ * (修前 S-712 的载体 `droppedIdentities` 在写入时只收「有名且启用」的行 —— 那是墓碑读者的筛子,装在了写入处;同一件事于是没有
+ * 第二个读者可用。筛子回到读者那里,载体就只剩「记下发生了什么」这一条律。)
  *
- * 🔐 纯身份,不含值:`name` / `id` 取自告警的 `identity`(settings-schema 6.1.0:只取被丢条目原文里的字符串形,脱敏器会改动的串
- * 整键扣下),`fields` 是坏字段的**键路径**,`issues` 是 {@link describeSchemaIssues} 的一行(键名 + 类型词)—— 被丢条目的原值
- * (可能是一段贴错位置的凭据)绝不进载体、日志、LKG 与 400 拒因句。
+ * 🔐 不含值:`identity` 取告警自带的身份(settings-schema 只铸可披露的标识符 —— 秘密形 / 非标识符的串 ⇒ 该键缺席,三键都没有 ⇒ 整个缺席);
+ * `index` 是条目在**这次读到的那份目录文档** `models` 数组里的原下标(数,不是串);`fields` 是坏字段的键路径、`issues` 是
+ * {@link describeSchemaIssues} 的一行(键名 + 类型词)—— 后两者只供本机拒因句,不上 wire。
  */
-export interface DroppedModelIdentity {
-    /** 出门形坐标(`models.1`),与同一次读的 `droppedEntries[].entry` 同一串。 */
-    readonly entry: string;
-    /** 条目写的 `name`(读腿只为有名的行铸载体)。载体上缺了它 = 载体形不对(LKG 载体被改 / 手写 effective)⇒ 模型面整组拒,
-     *  判在 `model-entry-refusal.ts` `judgeCatalogEntries`。 */
-    readonly name: string;
-    readonly id?: string;
-    readonly fields: readonly string[];
-    readonly issues: string;
-}
+export declare const DroppedCatalogEntryRow: z.ZodObject<{
+    index: z.ZodNumber;
+    reasonCode: z.ZodEnum<{
+        "entry-schema-invalid": "entry-schema-invalid";
+        "entry-key-invalid": "entry-key-invalid";
+        "entry-unreadable": "entry-unreadable";
+    }>;
+    identity: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    fields: z.ZodArray<z.ZodString>;
+    issues: z.ZodString;
+}, z.core.$strict>;
+export type DroppedCatalogEntry = z.infer<typeof DroppedCatalogEntryRow>;
 /**
  * 两条读腿(远端 `http-client.ts` / 本地 `config-provider.ts`)共用的**分面单点**:折叠产物按 `scope` 分进候选门
- * (`domainErrors`)与逐条丢弃面(`droppedEntries`)。`switch` 穷举 —— 加一种 scope 不补臂 = 编译红,两腿不会各分各的。
+ * (`domainErrors`)与逐条丢弃面(`droppedEntries`);逐条丢弃里的**目录条目**同一拍铸进目录载体(`droppedCatalogEntries`,
+ * 一次遍历、一行折叠、一个词 —— 日志行与载体行不各算一次)。`switch` 穷举 —— 加一种 scope 不补臂 = 编译红,两腿不会各分各的。
  * 文案**未脱敏**:进日志流之前各腿在自己的产出边界上过 `redactConfigError`(与 `domainErrors` 同一道)。
- *
- * 🔴 S-712 身份规则(一条,数据源 = 告警自带的 `identity`,settings-schema 6.1.0 在**同一次解析**里从被丢条目原文取 —— 本仓不再回读原文档):
- * **`identity.name` 是字符串 ⇒ 有名;有名且 `identity.enabled !== false` ⇒ 墓碑(进载体);其余一律不进载体。**
- *  · 有名而停用 ⇒ 停用 = 不在目录(与 7.100.0 同义);
- *  · 没有字符串名 —— `identity` 在场而无 `name`,或 `identity` 整个缺席 ⇒ **无名可留**,与停用同处置。按 settings-schema 6.1.0 的铸点
- *    (`config-fns.ts` `readEntryIdentity`),「没有名」有两个成因、刻意不分:原文 `name` 不是字符串(`null` / 数 / 整行不是对象),
- *    或是字符串但脱敏器会改动它(秘密形 —— 扣下不出门)。后者对本判据同样安全:档位增广只铸闭集词(`ultra` / `max` / `pro` /
- *    `flash` / `lite`、CC 别名、`best`),没有一个是秘密形,一个被扣下的名字无从被铸出;它的代价只是显式点它的请求拿到「未知模型」
- *    而不是 `request.model_unavailable`(那个名字本来也不许进日志与拒因句)。
- * 坏行本身照样走 `droppedEntries`(坐标 + 字段,不带值)。
+ * 坏行本身照样走 `droppedEntries`(坐标 + 字段 + 词,不带值)。
  */
 export declare function splitFoldedReadWarnings(warnings: readonly EffectiveReadWarning[]): {
     domainErrors: Array<{
@@ -100,10 +106,25 @@ export declare function splitFoldedReadWarnings(warnings: readonly EffectiveRead
         error: string;
     }>;
     droppedEntries: DroppedConfigEntry[];
-    droppedIdentities: DroppedModelIdentity[];
+    droppedCatalogEntries: DroppedCatalogEntry[];
 };
-/** S-712:把本次读交出的被丢身份挂上 effective 的模型域(两腿同一只;空 ⇒ 不挂键)。 */
-export declare function withDroppedIdentities<E extends {
+/** 把本次读交出的目录载体挂上 effective 的模型域(两腿同一只;空 ⇒ 不挂键)。 */
+export declare function withDroppedCatalogEntries<E extends {
     models?: object;
-}>(effective: E, droppedIdentities: readonly DroppedModelIdentity[]): E;
+}>(effective: E, rows: readonly DroppedCatalogEntry[]): E;
+/** `GET /v1/models` 顶层 `droppedEntries` 的一行(wire 形;契约 §A.1d「`GET /v1/models` 的 `droppedEntries`」)。 */
+export interface DroppedEntryWireRow {
+    readonly index: number;
+    readonly reasonCode: DroppedEntryReasonCode;
+    readonly identity?: DroppedEntryIdentity;
+}
+/**
+ * S-1295 —— 本代目录的被丢条目(`config.droppedCatalogEntries`)→ `GET /v1/models` 的 `droppedEntries`。纯投影,**唯一**出口。
+ *  · 词:settings-schema 的闭集原样过境({@link reasonCodeForWire} 穷举:包加词 / 删词 ⇒ 本仓编译红,逼一次「这个词能不能上 wire」的显式决定);
+ *  · 身份:`name` / `id` 在出口再问一次包的 `isDisclosableIdentity`(唯一判据,import 不复制)—— 载体可能来自被手改的盘上 LKG,读腿铸的身份
+ *    本来就过了同一只判据;不可披露 ⇒ 该键不出门(不打码:打过码的串不再是身份);`enabled` 是布尔照带;三键都不剩 ⇒ `identity` 缺席;
+ *  · 不投 `fields` / `issues`(人读的诊断句,不是契约),不投坐标串(下标是数)。
+ * 恒返回数组(零条 = `[]`):键恒在场,缺席只意味着更早的 server。
+ */
+export declare function buildDroppedEntriesWire(rows: readonly DroppedCatalogEntry[]): DroppedEntryWireRow[];
 //# sourceMappingURL=read-warnings.d.ts.map

package/dist/config-center/read-warnings.js

@@ -1,4 +1,5 @@
-import { formatConfigPath } from "@sema-agent/settings-schema";
+import { z } from "zod";
+import { DROPPED_ENTRY_REASON_CODES, formatConfigPath, isDisclosableIdentity, } from "@sema-agent/settings-schema";
 export function describeSchemaIssues(error) {
     const issues = schemaIssuesOf(error);
     if (issues === undefined)
@@ -55,7 +56,7 @@ export function foldEffectiveReadWarning(w) {
         case "domain-defaulted":
             return { scope: "domain", domain: w.domain, error: cap(errorText(w.error)) };
         case "entry-dropped":
-            return { scope: "entry", domain: w.domain, entry: formatConfigPath(w.path), error: cap(`entry dropped by domain schema: ${describeSchemaIssues(w.error) ?? errorText(w.error)}`) };
+            return { scope: "entry", domain: w.domain, entry: formatConfigPath(w.path), error: cap(`entry dropped by domain schema: ${describeSchemaIssues(w.error) ?? errorText(w.error)}`), reasonCode: droppedReasonCodeOf(w) };
         case "unknown-keys-dropped":
             return { scope: "domain", domain: w.domain, error: keyList("unknown keys dropped by domain schema: ", w.keys, w.truncatedFrom) };
         case "unknown-keys-carried":
@@ -68,12 +69,34 @@ export function foldEffectiveReadWarning(w) {
         }
     }
 }
-function isModelEntryDrop(w) {
-    return w.kind === "entry-dropped" && w.domain === "models" && w.path.length === 2 && w.path[0] === "models" && typeof w.path[1] === "number";
+function droppedReasonCodeOf(w) {
+    if (w.reasonCode === undefined) {
+        throw new Error(`entry-dropped warning at ${formatConfigPath(w.path)} carries no reasonCode — settings-schema mints one on every dropped entry, so this warning did not come from the pinned package`);
+    }
+    return w.reasonCode;
+}
+export const DroppedCatalogEntryRow = z
+    .object({
+    index: z.number().int().nonnegative(),
+    reasonCode: z.enum(DROPPED_ENTRY_REASON_CODES),
+    identity: z.object({ name: z.string().optional(), id: z.string().optional(), enabled: z.boolean().optional() }).strict().optional(),
+    fields: z.array(z.string()),
+    issues: z.string(),
+})
+    .strict();
+function catalogIndexOf(w) {
+    return w.kind === "entry-dropped" && w.domain === "models" && w.path.length === 2 && w.path[0] === "models" && typeof w.path[1] === "number" ? w.path[1] : undefined;
+}
+function identityOf(i) {
+    if (i === undefined)
+        return undefined;
+    const out = { ...(i.name !== undefined ? { name: i.name } : {}), ...(i.id !== undefined ? { id: i.id } : {}), ...(i.enabled !== undefined ? { enabled: i.enabled } : {}) };
+    return Object.keys(out).length > 0 ? out : undefined;
 }
 export function splitFoldedReadWarnings(warnings) {
     const domainErrors = [];
     const droppedEntries = [];
+    const droppedCatalogEntries = [];
     for (const w of warnings) {
         const f = foldEffectiveReadWarning(w);
         if (f === null)
@@ -82,29 +105,54 @@ export function splitFoldedReadWarnings(warnings) {
             case "domain":
                 domainErrors.push({ domain: f.domain, error: f.error });
                 break;
-            case "entry":
-                droppedEntries.push({ domain: f.domain, entry: f.entry, error: f.error });
+            case "entry": {
+                droppedEntries.push({ domain: f.domain, entry: f.entry, error: f.error, reasonCode: f.reasonCode });
+                const index = catalogIndexOf(w);
+                if (index !== undefined && w.kind === "entry-dropped") {
+                    const identity = identityOf(w.identity);
+                    droppedCatalogEntries.push({ index, reasonCode: f.reasonCode, ...(identity !== undefined ? { identity } : {}), fields: describeSchemaIssueFields(w.error), issues: describeSchemaIssues(w.error) ?? "(schema issues unreadable)" });
+                }
                 break;
+            }
             default: {
                 const never = f;
                 throw new Error(`unhandled folded read-warning scope: ${JSON.stringify(never)}`);
             }
         }
     }
-    const droppedIdentities = [];
-    for (const w of warnings) {
-        if (!isModelEntryDrop(w))
-            continue;
-        const identity = w.identity;
-        if (identity?.name === undefined || identity.enabled === false)
-            continue;
-        droppedIdentities.push({ entry: formatConfigPath(w.path), name: identity.name, ...(identity.id !== undefined ? { id: identity.id } : {}), fields: describeSchemaIssueFields(w.error), issues: describeSchemaIssues(w.error) ?? "(schema issues unreadable)" });
-    }
-    return { domainErrors, droppedEntries, droppedIdentities };
+    return { domainErrors, droppedEntries, droppedCatalogEntries };
 }
-export function withDroppedIdentities(effective, droppedIdentities) {
-    if (droppedIdentities.length === 0 || effective.models === undefined)
+export function withDroppedCatalogEntries(effective, rows) {
+    if (rows.length === 0 || effective.models === undefined)
         return effective;
-    return { ...effective, models: { ...effective.models, droppedIdentities: [...droppedIdentities] } };
+    return { ...effective, models: { ...effective.models, droppedCatalogEntries: [...rows] } };
+}
+export function buildDroppedEntriesWire(rows) {
+    return rows.map((r) => {
+        const identity = disclosableIdentityOf(r.identity);
+        return { index: r.index, reasonCode: reasonCodeForWire(r.reasonCode), ...(identity !== undefined ? { identity } : {}) };
+    });
+}
+function reasonCodeForWire(code) {
+    switch (code) {
+        case "entry-schema-invalid":
+        case "entry-key-invalid":
+        case "entry-unreadable":
+            return code;
+        default: {
+            const never = code;
+            throw new Error(`unhandled DroppedEntryReasonCode: ${JSON.stringify(never)}`);
+        }
+    }
+}
+function disclosableIdentityOf(i) {
+    if (i === undefined)
+        return undefined;
+    const out = {
+        ...(i.name !== undefined && isDisclosableIdentity(i.name) ? { name: i.name } : {}),
+        ...(i.id !== undefined && isDisclosableIdentity(i.id) ? { id: i.id } : {}),
+        ...(i.enabled !== undefined ? { enabled: i.enabled } : {}),
+    };
+    return Object.keys(out).length > 0 ? out : undefined;
 }
 //# sourceMappingURL=read-warnings.js.map

package/dist/config-center/types.d.ts

@@ -8,7 +8,7 @@
 import type { ToolContentOrigin } from "@sema-agent/core";
 import type { CollabTemplateWire } from "../capabilities/collab-wire.js";
 import type { Autonomy, CommandRule } from "../runtime-governance.js";
-import type { DroppedModelIdentity } from "./read-warnings.js";
+import type { DroppedCatalogEntry } from "./read-warnings.js";
 export interface CenterModel {
     name: string;
     id: string;
@@ -271,13 +271,12 @@ export interface EffectiveConfig {
         default?: string;
         tierGroups?: unknown;
         activeTierGroup?: string;
-        /** 🔴 S-712 —— **本仓读腿铸的**载体(不是 wire 键:中心在模型域里写同名键会被 schema 当未知键剥掉并进候选门):这次读
-         *  被 schema 逐条丢掉的**启用**、**有名**目录条目的身份(取 settings-schema 6.1.0 告警自带的 `identity`,见
-         *  `read-warnings.ts` `splitFoldedReadWarnings`)。模型面 stage 把它们铸成 `config.model_entry_invalid` 墓碑进 `modelRefusals`,
-         *  不变量 `refused-names-not-minted` 据此判增广有没有把它们的名字铸到别的条目上。挂在 effective 上(而不是读结果旁边)是为了
-         *  **随 effective 落 LKG**:重启从 LKG 起服时墓碑还在。形见 {@link DroppedModelIdentity}(纯身份,不含值);盘上形不对
-         *  (不是列表 / 行缺字符串 `name`)⇒ 模型面整组拒。 */
-        droppedIdentities?: DroppedModelIdentity[];
+        /** 🔴 S-712 / S-1295 —— **本仓读腿铸的**载体(不是 wire 键:中心在模型域里写同名键会被 schema 当未知键剥掉并进候选门):这次读
+         *  被 schema 逐条丢掉的**每一条**目录条目一行(下标 + settings-schema 闭集词 `reasonCode` + 告警自带的 `identity` + 字段诊断;形与律见
+         *  `read-warnings.ts` {@link DroppedCatalogEntry})。读者各取所需:模型面 stage 把有名且启用的行铸成 `config.model_entry_invalid` 墓碑
+         *  (不变量 `refused-names-not-minted` 据此判增广),每一行与 `models` 同 commit 进 `config.droppedCatalogEntries`(`GET /v1/models.droppedEntries` 的源)。
+         *  挂在 effective 上(而不是读结果旁边)是为了**随 effective 落 LKG**:重启从 LKG 起服时它还在。盘上形不对 ⇒ 模型面整组拒。 */
+        droppedCatalogEntries?: DroppedCatalogEntry[];
     };
     /** registry-core 0.7 collab domain (teams' successor) — consumed by the slice-1.5 projection
      *  (projectCollabToWorkflows → registerCollabWorkflows). Both lanes carry it: the remote worker /effective view

package/dist/config-lkg.d.ts

@@ -1,6 +1,6 @@
-/** 落盘信封。`effective`/`etag` 逐字=当时的 fetchEffective 返回(JSON verbatim 面)。 */
+/** 落盘信封。`effective`/`etag` 逐字=当时的 fetchEffective 返回(JSON verbatim 面)。`formatVersion` 的语义见头注(3 = 载荷的被丢目录条目记录是全的)。 */
 export interface PersistedLkg {
-    formatVersion: 2;
+    formatVersion: 3;
     savedAt: string;
     worker: string;
     /** 拉到这份候选时所用凭证的身份(`center-credential.ts`;摘要形,不含凭证原文)。 */
@@ -30,13 +30,14 @@ export declare function lkgPathOverrideOf(raw: string | undefined): string | und
  * LKG(含凭据)实际所在位置的**读拒行** —— 一条规则:读拒从 LKG 落在哪派生,不写死位置。
  *  · 没覆写 ⇒ LKG 落在配置根下(`config-lkg-<箱>.json`):引擎内建表的 `~/.sema/config-lkg-*.json` 行在家目录与声明的根(`agentConfigDir`,
  *    根经链接时引擎连目标一起守)两处守它 ⇒ 不另加行(加了就是同一个文件两只判据,`READ_DENY_BUILTIN_EXCLUDE` 删那一行也删不掉它);
- *  · 覆写 ⇒ LKG 在配置根外,引擎那一行够不着 ⇒ 这里派生行:它的**两种拼法**各一行 —— 覆写写下的绝对路径,与文件真正落的地方(路径经符号链接的
- *    目录时,写进去的文件在链接目标下;只守拼写的话读真实路径就绕过了 —— 车内复审 [high])。两者相同 ⇒ 一行。大小写不敏感(与内建行同读法)。
- *    拒句与内建行同一句(`sensitive-path read deny list (pattern …)`)。
- *    **行的射程**(引擎读拒表的读法,不是本函数选的):行是路径段串 —— 引擎去掉开头的 `/`、不锚到根,这串段在任意深度出现即拒(大小写不敏感),
- *    所以挡的不止 LKG 那一个文件:用户仓里同段串的路径(`/app/config-lkg.json` ⇒ `…/app/config-lkg.json`)一并读不到、Grep 结果里也不出现。
- *    挡多了优于不挡;引擎提供锚定单文件的行之前如此(随包文案 MIGRATION / 目录行同句)。
- * 读者:部署姿态座席族(`boot/runner-deps.ts` `buildDeploymentPostureSeats` 的 `readDenyPatterns` 席 = 运维的行 ∪ 本函数的行)—— 每次铸席现解一次链接。
+ *  · 覆写 ⇒ LKG 在配置根外,引擎那一行够不着 ⇒ 这里派生**一行** = 覆写的绝对路径(`/` 开头;`lkgPathOverrideOf` 已把相对值解成绝对)。大小写不敏感
+ *    (与内建行同读法)。拒句与内建行同一句(`sensitive-path read deny list (pattern …)`)。
+ *    **行的射程**(引擎读拒表的读法,core 7.48.0 #1442):`/` 开头的行**根锚定** —— 只守那一个绝对位置,用户仓里同尾的路径
+ *    (`/app/config-lkg.json` 之于 `…/repo/app/config-lkg.json`)读得到、Grep 结果里也在;路径经符号链接的目录时,引擎在每次准备时把这一行
+ *    **沿链放置**到它的字面头真正通向的地方(写进去的文件落在链接目标下,目标路径同样被拒)。
+ *    7.120.0–7.122.x 的两处旧读法随之退役:行是尾段任意深度匹配(挡掉用户仓里同尾的路径);本仓另派生一条 realpath 落点行(座席铸一次、
+ *    解不开计 P-DEBT)—— 那是「这条路径通向哪」的第二个读者,引擎沿链放置之后它是双读。
+ * 读者:部署姿态座席族(`boot/runner-deps.ts` `buildDeploymentPostureSeats` 的 `readDenyPatterns` 席 = 运维的行 ∪ 本函数的行)。
  */
 export declare function lkgReadDenyRows(configLkgPath: string | undefined): {
     pattern: string;
@@ -49,9 +50,11 @@ export declare function saveLkg(path: string, worker: string | undefined, identi
  * 读盘上 LKG。返回 undefined 的所有情形都「安静地回 env 兜底」(调用方 warn 点名 reason):
  * 文件缺席/JSON 坏/信封形不对/worker 或凭证身份不匹配(防同名文件跨 worker / 跨账号串包;`CONFIG_LKG_PATH`
  * 单一路径时这是唯一的一道)/prompts 面复判失败。
+ * `migrated`:读回时做过一次性迁移({@link migrateV2Lkg})—— 调用方响亮打一行。
  */
 export declare function loadLkg(path: string, worker: string | undefined, identity: string): Promise<{
     lkg: PersistedLkg;
+    migrated?: string;
 } | {
     lkg?: undefined;
     reason: string;

package/dist/config-lkg.js

@@ -1,10 +1,9 @@
-import { promises as fs, lstatSync, realpathSync } from "node:fs";
-import { basename, join, dirname, resolve } from "node:path";
+import { promises as fs } from "node:fs";
+import { join, dirname, resolve } from "node:path";
 import { randomBytes } from "node:crypto";
 import { validatePromptsDomain } from "./prompts-domain-validate.js";
 import { centerStateBin, pullTokenIdentity } from "./center-credential.js";
 import { configRootOf } from "./sema-config-dir.js";
-import { recordFailOpen } from "./observability/fail-open.js";
 export function defaultSkillCacheDir(config) {
     return join(configRootOf(config), "skill-cache");
 }
@@ -23,41 +22,10 @@ export function lkgPathOverrideOf(raw) {
 export function lkgReadDenyRows(configLkgPath) {
     if (configLkgPath === undefined)
         return [];
-    return [...new Set([configLkgPath, landedPathOf(configLkgPath)])].map((pattern) => ({ pattern, caseSensitive: false }));
-}
-function landedPathOf(p) {
-    const rest = [];
-    let landed = p;
-    let unresolved;
-    for (let head = p;; head = dirname(head)) {
-        try {
-            landed = join(realpathSync(head), ...rest);
-            break;
-        }
-        catch {
-            if (unresolved === undefined && head !== p && segmentPresent(head))
-                unresolved = head;
-            if (dirname(head) === head)
-                break;
-            rest.unshift(basename(head));
-        }
-    }
-    if (unresolved !== undefined)
-        recordFailOpen("server.config-lkg.landed-path-unresolved", `segment=${unresolved}`);
-    return landed;
-}
-function segmentPresent(p) {
-    try {
-        lstatSync(p);
-        return true;
-    }
-    catch (e) {
-        const code = e.code;
-        return code !== "ENOENT" && code !== "ENOTDIR";
-    }
+    return [{ pattern: configLkgPath, caseSensitive: false }];
 }
 export async function saveLkg(path, worker, identity, effective, etag) {
-    const body = { formatVersion: 2, savedAt: new Date().toISOString(), worker: worker ?? "global", identity, ...(etag !== undefined ? { etag } : {}), effective };
+    const body = { formatVersion: 3, savedAt: new Date().toISOString(), worker: worker ?? "global", identity, ...(etag !== undefined ? { etag } : {}), effective };
     const tmp = `${path}.${randomBytes(6).toString("hex")}.tmp`;
     await fs.mkdir(dirname(path), { recursive: true });
     await fs.writeFile(tmp, JSON.stringify(body), { mode: 0o600 });
@@ -84,14 +52,45 @@ export async function loadLkg(path, worker, identity) {
     const formatVersion = p.formatVersion;
     if (formatVersion === 1)
         return { reason: "pre-identity LKG (formatVersion 1) — not read back: it cannot prove whose credential fetched it (S-651); the next clean candidate rewrites it" };
-    if (formatVersion !== 2)
+    if (formatVersion !== 2 && formatVersion !== 3)
         return { reason: `unknown formatVersion ${String(formatVersion)}` };
     if (typeof p.worker !== "string" || p.worker !== (worker ?? "global"))
         return { reason: `worker mismatch (file=${String(p.worker)})` };
     if (typeof p.identity !== "string" || p.identity !== identity)
         return { reason: "credential identity mismatch (the LKG was fetched under another credential identity — not read back)" };
     const problem = lkgPayloadProblem(p.effective, p.etag);
-    return problem === undefined ? { lkg: p } : { reason: problem };
+    if (problem !== undefined)
+        return { reason: problem };
+    return formatVersion === 2 ? migrateV2Lkg(p) : { lkg: p };
+}
+const RETIRED_CATALOG_COORDINATE = /^models\.(0|[1-9][0-9]*)$/;
+function migrateDroppedIdentityRow(row) {
+    if (row === null || typeof row !== "object")
+        return row;
+    const r = row;
+    const at = typeof r.entry === "string" ? RETIRED_CATALOG_COORDINATE.exec(r.entry) : null;
+    const fields = r.fields;
+    if (at === null || typeof r.name !== "string" || (r.id !== undefined && typeof r.id !== "string") || !Array.isArray(fields) || !fields.every((f) => typeof f === "string") || typeof r.issues !== "string")
+        return row;
+    return { index: Number(at[1]), reasonCode: "entry-schema-invalid", identity: { name: r.name, ...(typeof r.id === "string" ? { id: r.id } : {}) }, fields: [...fields], issues: r.issues };
+}
+function migrateV2Lkg(lkg) {
+    const { etag: _incompleteCarrierValidator, ...envelope } = lkg;
+    const models = lkg.effective.models;
+    const hasRetired = models !== undefined && models !== null && typeof models === "object" && Object.hasOwn(models, "droppedIdentities");
+    let effective = lkg.effective;
+    if (hasRetired) {
+        const { droppedIdentities: retired, ...rest } = models;
+        if (Object.hasOwn(rest, "droppedCatalogEntries")) {
+            return { reason: "both the retired dropped-entry carrier (models.droppedIdentities) and its successor (models.droppedCatalogEntries) are present — no writer produces that shape; not read back" };
+        }
+        effective = { ...lkg.effective, models: { ...rest, droppedCatalogEntries: Array.isArray(retired) ? retired.map(migrateDroppedIdentityRow) : retired } };
+    }
+    return {
+        lkg: { ...envelope, formatVersion: 3, effective },
+        migrated: "formatVersion 2 → 3 (one-time): this LKG was written before every dropped catalog entry was recorded, so its etag is not reused — the next pull re-reads the whole candidate and re-mints the full record" +
+            (hasRetired ? "; the retired carrier models.droppedIdentities was moved to models.droppedCatalogEntries" : ""),
+    };
 }
 function lkgPayloadProblem(effective, etag) {
     if (effective === null || typeof effective !== "object")
@@ -183,7 +182,7 @@ export async function migrateV1Lkg(o) {
         }
     }
     try {
-        await saveLkg(o.binPath, o.worker, o.identity, v1.effective, typeof v1.etag === "string" ? v1.etag : undefined);
+        await saveLkg(o.binPath, o.worker, o.identity, v1.effective, undefined);
     }
     catch (err) {
         return refuse(`writing it into this credential identity's bin failed (${String(err)}) — the old file is left in place and the migration retries on the next LKG read`);

package/dist/config-provider.d.ts

@@ -22,8 +22,9 @@ import type { ConfigProviderWord } from "./config-types.js";
  *  路由进日志/审计流的消费者必须自己先脱敏。 */
 /** `credentialIdentity`(S-651 / [ref] E-15):远程腿恒在场 = 这次拉取所用凭证的身份(分箱键来源);本地腿
  *  缺席(没有凭证 —— config.d 就在本机盘上)。 */
-/** `droppedEntries`(S-704 ②):schema 逐条丢掉的条目(坐标 + 字段诊断,已脱敏)—— **不**进候选门,调用方逐条响亮
- *  点名、其余照用;缺席 = 这次读零逐条丢弃(与 `domainErrors` 同一种缺席即无的形)。 */
+/** `droppedEntries`(S-704 ②):schema 逐条丢掉的条目(坐标 + 字段诊断,已脱敏;S-1295 起每行带闭集词 `reasonCode`)—— **不**进候选门,
+ *  调用方逐条响亮点名、其余照用;缺席 = 这次读零逐条丢弃(与 `domainErrors` 同一种缺席即无的形)。其中的目录条目同一次折叠另记进
+ *  `effective.models.droppedCatalogEntries`(`GET /v1/models.droppedEntries` 的源,与 `models` 同世代)。 */
 export type FetchEffectiveResult = {
     effective: EffectiveConfig;
     etag?: string;

package/dist/config-provider.js

@@ -1,6 +1,6 @@
 import { readMcpSourceLabel } from "./mcp-source-label.js";
 import { createHmac, randomBytes } from "node:crypto";
-import { splitFoldedReadWarnings, withDroppedIdentities } from "./config-center/read-warnings.js";
+import { splitFoldedReadWarnings, withDroppedCatalogEntries } from "./config-center/read-warnings.js";
 import { FileConfigStore } from "@sema-agent/settings-schema/node";
 import { findSkillContent, skillContentHash, refIntegrityIssues, createSiblingResolver, formatConfigPath, REF_CHECKED_DOMAINS, } from "@sema-agent/settings-schema";
 import { redactSecrets } from "./trace/redact.js";
@@ -96,7 +96,7 @@ export class LocalConfigProvider {
         const droppedEntries = folded.droppedEntries.map((d) => ({ ...d, error: redactConfigError(d.error) }));
         const errors = [...domainErrors.map((de) => ({ domain: de.domain, error: redactConfigError(de.error) })), ...parseErrors, ...refErrors];
         return {
-            effective: withDroppedIdentities(mapToServiceEffective(eff, eff.version), folded.droppedIdentities),
+            effective: withDroppedCatalogEntries(mapToServiceEffective(eff, eff.version), folded.droppedCatalogEntries),
             etag: tag,
             readWarnings,
             ...(errors.length > 0 ? { domainErrors: errors } : {}),

package/dist/config-types.d.ts

@@ -9,6 +9,7 @@ import type { ReadFaceSource } from "./read-face-posture.js";
 import type { PostureSource } from "./posture-source.js";
 import type { SealedCustodyPoison } from "./key-resolver.js";
 import type { ModelEntryRefusal } from "./model-entry-refusal.js";
+import type { DroppedCatalogEntry } from "./config-center/read-warnings.js";
 import type { A2aServerSpec, CompliancePosture, CrossSessionDialogExpiry, CrossSessionInboundSetting, FileHistoryRetentionPolicy, LockedKey, McpServerSpec, Model, ModelRoles, RetentionPolicy, ShellGateDoctrine, WriteProtectedEntry } from "@sema-agent/core";
 import type { ApprovalHmacKey, PrincipalJwtKey } from "./auth-keys.js";
 import type { ElicitationThrottle } from "./elicitation.js";
@@ -572,6 +573,13 @@ export interface ServiceConfigFlat {
      * 「没这模型」。env 腿恒空;只由 applyEffective 与 `models` **同世代同 commit** 整表重赋值(非粘)。
      */
     modelRefusals: Readonly<Record<string, ModelEntryRefusal>>;
+    /**
+     * S-1295 —— **本世代目录里被读腿逐条丢掉的条目**(载体 `EffectiveConfig.models.droppedCatalogEntries` 经模型面判据判过形的行,保序;
+     * 下标 + settings-schema 闭集词 + 身份 + 字段诊断)。`GET /v1/models` 的 `droppedEntries` 唯一的源(出口投影 `buildDroppedEntriesWire`:
+     * 只投词与可披露身份)。env 腿恒空(没有目录读);只由 applyEffective 与 `models` **同世代同 commit** 整表重赋值(非粘)—— 模型面这一组
+     * 被拒时它与目录一起停在上一代。墓碑(`modelRefusals` 里的 `entry_invalid` 行)是同一份载体的另一种读法,不是第二份记录。
+     */
+    droppedCatalogEntries: readonly DroppedCatalogEntry[];
     /** 配额倍率表(name+id 双键→ModelEntry.quotaWeight):weight-at-burn 的运行时源——tracer 在
      *  brain.call 记账点读它算 weightedTokens(lease 双轴+usage 批报)。registry apply IN-PLACE hot-apply;
      *  env lane 恒空(无倍率概念,weight=1 兜底)。 */
@@ -2159,7 +2167,7 @@ export interface ServiceConfigFlat {
 /** 组:store(持久化)—— DB 引擎三态、session 后端、SQL coords、快照 BLOB / SendUserFile 对象存储。 */
 export type ServiceStoreConfig = Pick<ServiceConfigFlat, "sessionBackend" | "sessionCacheTtlSec" | "storeProbeIntervalMs" | "storeLockWaitMs" | "dbBackend" | "dbBackendExplicit" | "localDataRoot" | "runStoreStrictHydrate" | "tidb" | "pg" | "dbQueryTimeoutMs" | "snapshotBlobStore" | "snapshotBlobSqlMaxBytes" | "snapshotBlobAllowSql" | "fileHistory" | "fileHistoryCapture" | "sendUserFile">;
 /** 组:modelPlane(模型面)—— 网关坐标、Anthropic 路线、韧性旋钮、主/廉价 model entry、role 表、降级梯。 */
-export type ServiceModelPlaneConfig = Pick<ServiceConfigFlat, "gatewayBaseUrl" | "gatewayApiKey" | "gatewayFallbackUrls" | "gatewayMaxRetries" | "anthropic" | "resilience" | "model" | "envModel" | "models" | "modelApiKeyEnv" | "modelApiKeys" | "modelRefusals" | "modelQuotaWeights" | "tiers" | "projects" | "roles" | "atModelAllowlist" | "cascadeLadder" | "degrade">;
+export type ServiceModelPlaneConfig = Pick<ServiceConfigFlat, "gatewayBaseUrl" | "gatewayApiKey" | "gatewayFallbackUrls" | "gatewayMaxRetries" | "anthropic" | "resilience" | "model" | "envModel" | "models" | "modelApiKeyEnv" | "modelApiKeys" | "modelRefusals" | "droppedCatalogEntries" | "modelQuotaWeights" | "tiers" | "projects" | "roles" | "atModelAllowlist" | "cascadeLadder" | "degrade">;
 /** 组:approval(审批 / HITL 门)。`directDoorActive` 无 env 解析腿(装配层三域合取的产物),但语义上
  *  就是本组的门状态,故进组;`parseApprovalDomain` 的返回类型相应是 `Omit<…, "directDoorActive">`。 */
 export type ServiceApprovalConfig = Pick<ServiceConfigFlat, "approvalRequire" | "approvalDeny" | "approvalTimeoutSec" | "approvalAutoBudget" | "approvalNeverAuto" | "approvalGrant" | "approvalHmacKeys" | "durableApproval" | "durableApprovalSource" | "streamAskWindowMsSource" | "directApprovalDoor" | "directDoorActive" | "resourceSuspend" | "resourceSuspendTtlSec" | "resourceSuspendTotalTokens" | "resourceSuspendTotalBudgetUsd" | "resourceSuspendMaxSlices" | "askQuestionEnabled" | "questionThrottle" | "toolApprovalEnabled" | "permissionRulesEnabled" | "permissionRulesEnabledExplicit" | "streamAskWindowMarginMs" | "streamApproval" | "unattendedApprovalPolicy" | "mcpElicitation" | "sensitiveWritePatterns" | "writeProtectedPaths" | "manualModeShellGate" | "permissionsDisableAutoMode" | "autoModeClassifierFallback" | "autoModeClassifierTimeoutMs" | "crossSessionInbound" | "crossSessionDialogExpiry">;

package/dist/config.d.ts

@@ -211,7 +211,7 @@ export declare function buildUnpricedCeilingNotice(models: Record<string, Model>
     fields: Record<string, string>;
 } | undefined;
 /** [ref] N8/N9 — the BOOLEAN member of this module's env-parser family (`env`/`env2`/`numEnv`/
- *  `numEnvBounded`/`optFinitePositiveEnv`/`enumEnv`/`headerNameEnv`/`firstSetEnv`). Until now booleans were the
+ *  `numEnvBounded`/`optFinitePositiveEnv`/`enumEnv`/`headerNameEnv`). Until now booleans were the
  *  one type parsed by a hand-written literal comparison at every single site, and that is exactly why the same
  *  `*_ENABLED` suffix grew FOUR incompatible polarities (opt-in `=== "true"`, opt-out `!== "false"`, the posture
  *  tri-state, and negative `*_DISABLED` names): with no shared helper there was nowhere for the default to be
@@ -298,7 +298,7 @@ export declare function isRosterGateArmed(configCenter: ServiceConfig["configCen
  *   - 够不着挂载工具的协议名:**对端段铸不出**(`mcp__github.com`、`mcp__github.com__*`、`mcp__*`、超长 / 归一后带连串下划线的服务器段、对端段为空的
  *     `mcp__` / `mcp____x`)—— 前缀对,但引擎铸注册名时归一对端段,而规则对对端段逐字比,永不匹配。判官是引擎的 `judgeRuleToolName`(core 7.43.0 #1355 (b)
  *     的判词 `unmintable_segment`,句子带它的 guidance 与 1:1 现名);本仓 7.116.0–7.117.x 那只自比 `mintNamespacePrefix` 的对照随之退役。
- *     引擎判官放行、却一只工具都够不着的一形 —— **工具段为空**(`mcp__srv__`)—— 由本仓判(`namespaced-rule-name.ts`,会话规则写口两腿与 SQL 店写口同调)。
+ *     **工具段为空**(`mcp__srv__`)core 7.48.0 #1400 起也是这一判词(7.116.0–7.122.x 由本仓自答,随之退役)。
  *     ⚠️ 两段覆盖形 `mcp__<server>`(服务器段是自铸形)够得着(S-1047 收掉的分叉,见下)。
  *   - **core 的文法编不出来的串**:判词取自 core 自己的 `validatePermissionRules`,射程与指引见 {@link uncompilableRuleGuidance}
  *     (名表消费者只递得来名字里带反斜杠、单条 >512 字符、空串三种;规则编译器消费者递来的每一条内容形都走这里)。[ref]①([ref])补齐 ——
@@ -337,8 +337,8 @@ export interface UnmatchableToolName {
  *    (S-177 / core 7.9.0 起)。引擎**真的按内容匹配** deny / ask 的内容形(`Bash(rm -r:*)` / `Edit(~/.sema/**)`),所以本仓不许再替它拒 ——
  *    判据整条交回 core 的 `validatePermissionRules`,按这张表自己的 behavior 问。core 7.42.0 起策略只说 deny / ask(allow 表不再是本消费者)。
  * (7.117.0 有过第三种 `"allow-layer"` —— 请求的 `settings.permissions.allow` 只判名字。7.118.0 / core 7.43.0 #1358 起引擎的 allow 层自己按名册读条目名并通告
- *  (`permission.allowed_tool_not_granted`,`reason: "tool_name"` / `near_miss`)⇒ 本仓的名字判退役,allow 侧整只交引擎,只剩引擎读不到的那一形在
- *  `task-settings.ts` 经 `rule-entry-list.ts` 拒。)
+ *  (`permission.allowed_tool_not_granted`,`reason: "tool_name"` / `near_miss`)⇒ 本仓的名字判退役,allow 侧整只交引擎;7.116.0–7.122.x 另拒的「工具段为空」
+ *  一形随 core 7.48.0 #1400 也交引擎。)
  */
 export type RuleEntryConsumer = "tool-name-table" | "rule-policy";
 /**
@@ -369,10 +369,10 @@ export declare function unmatchableToolNamesRefusal(source: string, names: reado
  * 7.117.0(core 7.42.0)起这张表整份投 `RunnerDeps.allowedTools`(引擎 allow 层的部署成员,构造时读一次),判据是**引擎的读法**,与请求的两张
  * allow 表同一份(`rule-entry-list.ts`):
  *  ① 值不是字符串表 ⇒ 拒(env 的 CSV 恒给字符串表;判在这里是为了「值一旦换了来源,第一道判仍在」);
- *  ② 引擎读不到的那一形(工具段为空的协议名)⇒ 拒(与技能清单、请求 allow 桶同一只函数);
- *  ③ 引擎读成空的条目(`compileAllowList(names, "allow", 名册 = 空集).inert` 非空 —— `*`、`mcp__*`、写路径 / 域名形、带空白或畸形的名字,以及
- *     core 7.43.0 起条目名过引擎判官读成 `tool_name` 的退役名 / 无前缀短名 / 对端段铸不出)⇒ 拒,句子点名条目、引擎给的原因词(名字层带判词与现名)、
- *     该怎么写。请求的 allow 侧对 ③ 只收通告;运维这一侧拒启:这是运维自己的配置,写错了当场改,而引擎对读成空的部署条目只在每一跑发一条通告。
+ *  ② 引擎读成空的条目(`compileAllowList(names, "allow", 名册 = 空集).inert` 非空 —— `*`、`mcp__*`、写路径 / 域名形、带空白或畸形的名字,以及
+ *     core 7.43.0 起条目名过引擎判官读成 `tool_name` 的退役名 / 无前缀短名 / 对端段铸不出,core 7.48.0 #1400 起含工具段为空的 `mcp__<srv>__`;
+ *     7.116.0–7.122.x 那一形由本仓先拒,随之退役)⇒ 拒,句子点名条目、引擎给的原因词(名字层带判词与现名)、
+ *     该怎么写。请求的 allow 侧对 ② 只收通告;运维这一侧拒启:这是运维自己的配置,写错了当场改,而引擎对读成空的部署条目只在每一跑发一条通告。
  * 文法随引擎:工具名、协议名覆盖形、`Bash(...)` 命令规则、`Read(//dir/**)` 读目录都收(内容形里带逗号的写不进 CSV —— 这张表的分隔符就是逗号)。
  */
 export declare function approvalGrantRefusal(names: unknown): string | undefined;