@sema-agent/server 7.145.0 → 7.146.0

package/dist/json-body-limit.js

@@ -0,0 +1,2 @@
+export const MAX_JSON_BODY_BYTES = 8 * 1024 * 1024;
+//# sourceMappingURL=json-body-limit.js.map

package/dist/leader/diffout.d.ts

@@ -45,7 +45,7 @@ export type PullDiffResult = {
  * 而它**本就已经** `import { safeRev } from "./diffout.js"` —— 依赖边在,共享零成本。两份手抄的后果不是
  * 「多写一行」,是**单边改值后上行/pull 两腿对同一个 diff 的过/拒判定分家**:同一份补丁在一条腿上过、
  * 另一条腿上被截断,而两处都「按自己的常量」正确工作,没有任何一处会报错。
- * (同族先例:`checkpoint-store-sql.ts` 的 `export const TERMINAL_GRACE_MS`。)
+ * (同族先例:`checkpoint-store-face.ts` 的 `export const TERMINAL_GRACE_MS`。)
  */
 export declare const DEFAULT_MAX_DIFF_BYTES: number;
 export declare function safeRev(rev: string): boolean;

package/dist/local-data-root.d.ts

@@ -7,8 +7,8 @@
  * `scripts/drain-check-local.mjs`(经 `dist/local-data-root.js` 取同一只函数,缺省数据根不再自抄一份链:抄本只对了一半,
  * 设了 `AGENT_DATA_DIR` 的部署不带参数跑脚本会读到另一个目录并报「干净」)。纯叶、零反向依赖 ⇒ 脚本引它不会把整个服务装载起来。
  *
- * ⚠️ 与**配置根**(`configLocalRoot`:`CONFIG_LOCAL_DIR` → `AGENT_DATA_DIR` → `~/.ai-agent`,不吃 `LOCAL_DATA_ROOT`)不是同一条链 —— 两根分家的那一形由
- * boot 期的 `local_roots_split` 告警说出来,本函数不改那条解析。
+ * ⚠️ 与**配置根**(`configLocalRoot`:`CONFIG_LOCAL_DIR` → `AGENT_DATA_DIR` → `~/.ai-agent`,不吃 `LOCAL_DATA_ROOT`)不是同一条链 —— 两根一声不响分家的那一形
+ * (没给 `CONFIG_LOCAL_DIR`)由 boot 期的 `local_roots_split` 告警说出来,本函数不改那条解析。
  */
 export declare function resolveLocalDataRoot(env: Readonly<Record<string, string | undefined>>, home: string): string;
 //# sourceMappingURL=local-data-root.d.ts.map

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

@@ -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) {
@@ -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/net-address.d.ts

@@ -0,0 +1,53 @@
+export type CidrFamily = "ipv4" | "ipv6";
+/** 一条 CIDR 的平数据读数。`net` 是写下的网络地址原文(不规范化,`BlockList` 按它建块)。 */
+export interface ParsedCidr {
+    readonly net: string;
+    readonly prefix: number;
+    readonly family: CidrFamily;
+    /** 前缀之后还有为 1 的位(`10.0.0.5/8`)。宽文法照收;名单侧拒。 */
+    readonly hostBitsSet: boolean;
+}
+export type CidrParse = {
+    readonly ok: true;
+    readonly cidr: ParsedCidr;
+} | {
+    readonly ok: false;
+};
+/**
+ * 宽文法:`<IPv4|IPv6>[/<十进制前缀>]`,裸地址 = 主机前缀(/32 或 /128)。前缀只认 `^\d+$` 且不超过族上界。
+ * 地址合法性归 `isIP`(它已拒前导零的 IPv4 段)。
+ */
+export declare function parseCidr(text: string): CidrParse;
+/** 名单项的规范文本(`net/prefix`,网络地址取规范形),或拒因。 */
+export type TrustedProxyCidrParse = {
+    readonly ok: true;
+    readonly cidr: ParsedCidr;
+    readonly text: string;
+} | {
+    readonly ok: false;
+    readonly flaw: string;
+};
+/**
+ * 可信代理名单的一项(设备 WS 预鉴权帽键;运维写下、安全轴)。在宽文法之上收紧 —— 歧义 = 拒,不收下当「差不多」:
+ *  · 空项(`a,,b` / 尾逗号 / 只含空白):多半是拼接事故,收下会让人以为某条还在;
+ *  · zone id(`fe80::1%eth0`):链路本地的接口名对别的主机没有意义;
+ *  · 主机位非零(`10.0.0.5/8`):是想信整块还是信一台?两个出路都写进拒句;
+ *  · 前缀 0(`0.0.0.0/0` / `::/0`):信全网任意来源的转发头 = 每个客户端自报帽键,等于一只绕帽旋钮 —— 本旋钮不提供它。
+ */
+export declare function parseTrustedProxyCidr(text: string): TrustedProxyCidrParse;
+/** 地址集合的活对象(按 CIDR 建块,判官 = node `BlockList`)。IPv4-mapped IPv6 的两种拼法与 IPv4 规则互相命中是 `BlockList` 自己的
+ *  跨族匹配(net-address.test 钉住:换 node 后它变了那里先红)。`has` 不改写地址 —— 出网策略判照旧按原文查。 */
+export interface CidrSet {
+    has(address: string): boolean;
+    readonly size: number;
+}
+export declare function createCidrSet(cidrs: readonly ParsedCidr[]): CidrSet;
+/** 可信代理名单(已由配置层逐项校验过的文本)⇒ 集合。坏项 = 装配缝(配置层已先拒),当场抛,不跳过。 */
+export declare function createTrustedProxySet(items: readonly string[]): CidrSet;
+/**
+ * 地址的规范形(帽键的唯一拼法):IPv4 原样(`isIP` 已保证点分十进制、无前导零);IPv6 取 WHATWG 的压缩小写形;
+ * IPv4-mapped IPv6(`::ffff:1.2.3.4` / `::ffff:102:304`)⇒ 点分 IPv4 —— 同一台主机经 IPv4 栈与双栈来时是同一个键。
+ * 非地址、带 zone id、带端口、带方括号 ⇒ `undefined`(端口 / 方括号由调用方按自己的文法先剥)。
+ */
+export declare function canonicalAddress(text: string): string | undefined;
+//# sourceMappingURL=net-address.d.ts.map

package/dist/net-address.js

@@ -0,0 +1,111 @@
+import { BlockList, isIP } from "node:net";
+export function parseCidr(text) {
+    const slash = text.indexOf("/");
+    const net = slash < 0 ? text : text.slice(0, slash);
+    const fam = isIP(net);
+    const max = fam === 6 ? 128 : 32;
+    const prefixText = slash < 0 ? String(max) : text.slice(slash + 1);
+    const prefix = Number(prefixText);
+    if (fam === 0 || !/^\d+$/.test(prefixText) || prefix > max)
+        return { ok: false };
+    const family = fam === 6 ? "ipv6" : "ipv4";
+    return { ok: true, cidr: { net, prefix, family, hostBitsSet: hostBitsSet(net, prefix, family) } };
+}
+export function parseTrustedProxyCidr(text) {
+    if (text === "")
+        return { ok: false, flaw: "is empty (a stray comma, or a whitespace-only value)" };
+    if (text.includes("%"))
+        return { ok: false, flaw: "carries an interface zone id (%…), which means nothing to another host" };
+    const parsed = parseCidr(text);
+    if (!parsed.ok)
+        return { ok: false, flaw: "is not an IPv4 / IPv6 address or CIDR (address[/prefix], prefix in decimal within 32 / 128; hostnames are not accepted)" };
+    const { cidr } = parsed;
+    const net = canonicalNetwork(cidr);
+    if (cidr.prefix === 0) {
+        return { ok: false, flaw: "is a /0 prefix — it would trust the forwarded-for header from every source, so any client could pick its own cap key; list only your own reverse proxies" };
+    }
+    if (cidr.hostBitsSet) {
+        return { ok: false, flaw: `has host bits set past /${cidr.prefix} — write ${maskedNetwork(cidr)}/${cidr.prefix} to trust the whole block, or ${net}/${cidr.family === "ipv6" ? 128 : 32} to trust that one proxy` };
+    }
+    return { ok: true, cidr, text: `${net}/${cidr.prefix}` };
+}
+export function createCidrSet(cidrs) {
+    const list = new BlockList();
+    for (const c of cidrs)
+        list.addSubnet(c.net, c.prefix, c.family);
+    return {
+        size: cidrs.length,
+        has(address) {
+            const fam = isIP(address);
+            if (fam === 0)
+                return false;
+            return list.check(address, fam === 6 ? "ipv6" : "ipv4");
+        },
+    };
+}
+export function createTrustedProxySet(items) {
+    const cidrs = items.map((item, i) => {
+        const r = parseTrustedProxyCidr(item);
+        if (!r.ok)
+            throw new Error(`device lane: trusted proxy list item ${i + 1} of ${items.length} (${JSON.stringify(item)}) ${r.flaw} (assembly bug: DEVICE_TRUSTED_PROXY_CIDRS is validated at config load)`);
+        return r.cidr;
+    });
+    return createCidrSet(cidrs);
+}
+export function canonicalAddress(text) {
+    const fam = isIP(text);
+    if (fam === 4)
+        return text;
+    if (fam !== 6)
+        return undefined;
+    const inner = compressedIpv6(text);
+    if (inner === undefined)
+        return undefined;
+    const mapped = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(inner);
+    if (mapped !== null) {
+        const hi = parseInt(mapped[1], 16);
+        const lo = parseInt(mapped[2], 16);
+        return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+    }
+    return inner;
+}
+function compressedIpv6(text) {
+    const href = `http://[${text}]/`;
+    return URL.canParse(href) ? new URL(href).hostname.slice(1, -1) : undefined;
+}
+function addressBytes(net, family) {
+    if (family === "ipv4")
+        return net.split(".").map(Number);
+    const zone = net.indexOf("%");
+    const host = compressedIpv6(zone < 0 ? net : net.slice(0, zone));
+    if (host === undefined)
+        return undefined;
+    const [left = "", right] = host.split("::");
+    const l = left === "" ? [] : left.split(":");
+    const r = right === undefined || right === "" ? [] : right.split(":");
+    const groups = [...l, ...Array(8 - l.length - r.length).fill("0"), ...r].map((g) => parseInt(g, 16));
+    return groups.flatMap((g) => [g >> 8, g & 255]);
+}
+function hostBitsSet(net, prefix, family) {
+    const bytes = addressBytes(net, family);
+    if (bytes === undefined)
+        return false;
+    return bytes.some((b, i) => (b & ~maskByte(prefix, i) & 255) !== 0);
+}
+function maskByte(prefix, index) {
+    const bits = Math.max(0, Math.min(8, prefix - index * 8));
+    return (0xff << (8 - bits)) & 255;
+}
+function maskedNetwork(c) {
+    const bytes = (addressBytes(c.net, c.family) ?? []).map((b, i) => b & maskByte(c.prefix, i));
+    if (c.family === "ipv4")
+        return bytes.join(".");
+    const groups = [];
+    for (let i = 0; i < 16; i += 2)
+        groups.push(((bytes[i] << 8) | bytes[i + 1]).toString(16));
+    return compressedIpv6(groups.join(":")) ?? groups.join(":");
+}
+function canonicalNetwork(c) {
+    return c.family === "ipv4" ? c.net : (compressedIpv6(c.net) ?? c.net);
+}
+//# sourceMappingURL=net-address.js.map

package/dist/observability/fail-open.d.ts

@@ -175,17 +175,13 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "design/382 §3.5(S-44;core 7.55.0 #1468 P1 阶段二起读者是 core `readRuleOffers`,经 `approval-card.ts` 的 `readRuleOfferList`,两条腿同调):batch offer 的 `uncoveredDetail` 明细座不是「每个计数段一行良构行」(集外 reason / 非数组 / 行数与 count 座不等 —— core 读者判丢、读数带 `uncoveredDetailDropped`)或行数超本仓展示帽 MAX_UNCOVERED_DETAIL_ROWS ⇒ 只丢这一座、batch 本体照投。放行的最坏后果 = 卡上少几行「这段为什么还会问」的解释(count 座仍在,core 契约明写明细缺席不是断言);把整只 batch 判假才是错的方向(一只真可兑的合取批从卡上消失)。纯展示轴 ⇒ F 类;必须留痕,否则上游明细座漂形在遥测里零痕迹。detail = `index=<core 列表里的下标>` + 丢的缘由(不带段文本)。";
     };
-    readonly "server.approval-batch.kindless-row": {
-        readonly cls: "F";
-        readonly note: "起服普查(`approval-batch-census.ts`;SQL 两方言同一只读口 `SqlCheckpointStore.scanKindlessBatchRows`):一行审批停驻行(`checkpoint` 表,所有状态)的规则提议里,有 batch offer 带着**无 `kind` 的存量成员** —— 引擎读者(`readRuleOffers`)为这个旧形留着一条存量读臂(无 `kind`、四个命令文本键齐的成员读成 `command`,并给那只 offer 打 `kindlessForm` 记号),本仓用 `countKindlessBatchOffers` 数这个记号。载体两个:`rule_suggestions` 列、blob 里的 `pendingAction.ruleOffers`(detail 的 `carriers=` 点名是哪个)。每个带旧形成员的行记一次(逐次计数 + 探针行 + 每进程一次 warn),起服另出一行 info `approval_batch_kindless_rows { count }`。放行的最坏后果 = 无新增放行:这是读侧存量兼容臂被数的位,读法本来就是『旧形读成 command』,普查不改任何一行的读法、不翻行、不删臂;留痕的唯一目的是让『还有几行靠这条臂』可证 —— 计数为零(整个部署的每个副本起服都是零)才能由后续一版删那条存量臂;非零 = 还有行靠它,不可删,detail 的 `row=` 是行指纹(不是 token)。F 类(读侧兼容、纯展示轴:这条臂读出的是「不再询问」候选的卡面,不是门)。逐页读、不是原子快照(页间别的副本的写入可以让一行被漏数或多数一行);滚动升级窗里停在旧版本的副本之后写的旧形行,下次起服才数得到。后台跑、不挡起服就绪。";
-    };
     readonly "server.checkpoint.inbox-risk-axes-damaged": {
         readonly cls: "F";
-        readonly note: "core 7.55.0 `summarizeCheckpoint` 的第二参(`plugins/checkpoint-store-sql.ts` 的 `listByScope`:supervisor inbox / 调度视图的按 scope 待决投影):一行审批门的风险描述符读穿了一格坏轴 —— `axes` 不是普通对象,或某个标记(`egress` / `irreversible` / `shell`)在场却不是布尔(手改 / 第三方写者;引擎铸的行没有这一形)⇒ 行照投,`severity` 取有效标记给出的下界,证不出就缺席;core 交一句话给店的座,本座逐行计一次。放行的最坏后果 = 这一行在按 severity 倒排的 inbox 里排位偏低或无档(分诊材料,不是门;resume 的判据不读它)。不放行的代价是一行坏描述符打掉整个 scope 的 inbox(修前:非对象描述符抛 TypeError 出投影)。修前不传座 ⇒ 降档是静默的。detail = core 的句子(按 checkpoint id 与会话 JSON 点名、按形说成员,不带令牌、不带值);每次列 inbox 都会再说一次,直到那一行被修或被决。LOCAL 车道的同一句经 backend 的 `file_store_corrupt_read` 座(core File 店自带),不走本 tag。";
+        readonly note: "core 7.55.0 `summarizeCheckpoint` 的第二参(`stores-sql/checkpoint-store-sql.ts` 的 `listByScope`:supervisor inbox / 调度视图的按 scope 待决投影):一行审批门的风险描述符读穿了一格坏轴 —— `axes` 不是普通对象,或某个标记(`egress` / `irreversible` / `shell`)在场却不是布尔(手改 / 第三方写者;引擎铸的行没有这一形)⇒ 行照投,`severity` 取有效标记给出的下界,证不出就缺席;core 交一句话给店的座,本座逐行计一次。放行的最坏后果 = 这一行在按 severity 倒排的 inbox 里排位偏低或无档(分诊材料,不是门;resume 的判据不读它)。不放行的代价是一行坏描述符打掉整个 scope 的 inbox(修前:非对象描述符抛 TypeError 出投影)。修前不传座 ⇒ 降档是静默的。detail = core 的句子(按 checkpoint id 与会话 JSON 点名、按形说成员,不带令牌、不带值);每次列 inbox 都会再说一次,直到那一行被修或被决。LOCAL 车道的同一句经 backend 的 `file_store_corrupt_read` 座(core File 店自带),不走本 tag。";
     };
     readonly "server.rule-offers.offer-dropped": {
         readonly cls: "F";
-        readonly note: "core 7.55.0 #1468 P1 阶段二(`approval-card.ts` 的 `readRuleOfferList`,规则提议列表的唯一读者,判官 = core `readRuleOffers`;两条腿同调 —— 耐久腿 `checkpoint-store-sql.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行;同步腿 `tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`):一个元素读不出(`unknown_word`:offer / 成员的 `kind`、`match` 是本引擎不认的词 —— 更新的铸者或别的写者;`malformed`:不是对象、成员缺位或错型、空 batch、计数不是非负安全整数)⇒ 这一只整只丢(batch 不拆成员)、兄弟照投;整只值在场却不是列表(`not_an_array`)⇒ 这一行无供给。逐元素计。放行的最坏后果 = 卡上少一个「不再询问」选项(人仍可逐次批;少的是选项不是门 —— 渲出一个读不懂的选项、或少一个成员的合取批,才是错的方向)。修前耐久腿丢元素是静默的,同步腿走一行 logger warn(`rule_offer_dropped_unreadable_shape`,随之退役)。计数非零 = 有 offer 列表的形本引擎读不懂:上游版本领先(core 加了词)或库里的行被手改过。detail = `index=<下标> problem=<RULE_OFFER_SHAPE_PROBLEMS 的词>`(不带 offer 文本 —— 那是命令原文族)。";
+        readonly note: "core 7.55.0 #1468 P1 阶段二(`approval-card.ts` 的 `readRuleOfferList`,规则提议列表的唯一读者,判官 = core `readRuleOffers`;两条腿同调 —— 耐久腿 `checkpoint-store-face.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行;同步腿 `tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`):一个元素读不出(`unknown_word`:offer / 成员的 `kind`、`match` 是本引擎不认的词 —— 更新的铸者或别的写者;`malformed`:不是对象、成员缺位或错型、空 batch、计数不是非负安全整数)⇒ 这一只整只丢(batch 不拆成员)、兄弟照投;整只值在场却不是列表(`not_an_array`)⇒ 这一行无供给。逐元素计。放行的最坏后果 = 卡上少一个「不再询问」选项(人仍可逐次批;少的是选项不是门 —— 渲出一个读不懂的选项、或少一个成员的合取批,才是错的方向)。修前耐久腿丢元素是静默的,同步腿走一行 logger warn(`rule_offer_dropped_unreadable_shape`,随之退役)。计数非零 = 有 offer 列表的形本引擎读不懂:上游版本领先(core 加了词)或库里的行被手改过。detail = `index=<下标> problem=<RULE_OFFER_SHAPE_PROBLEMS 的词>`(不带 offer 文本 —— 那是命令原文族)。";
     };
     readonly "server.rules.ticket-claim-release-failed": {
         readonly cls: "F";
@@ -201,7 +197,7 @@ export declare const FAIL_OPEN_TAGS: {
     };
     readonly "server.approvals.park-row-blob-unreadable": {
         readonly cls: "F";
-        readonly note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)";
+        readonly note: "S-700(`stores-sql/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)";
     };
     readonly "server.approvals.queue-row-agent-unreadable": {
         readonly cls: "F";
@@ -219,17 +215,21 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "`session-notify-door.ts` 的 `deliver`(会话通知门的判活读;两只调用方 `POST /v1/sessions/:id/notify` 与后台子代完成 relay 同经):判活读 —— run 店的单活认领读 `getActiveTaskId` —— 抛(店瞬断 / 超时 / 连接被回收)⇒ 门当这只会话**没有在飞的 run**,落空闲臂:入收件箱,下次开流排空成 `task_notification` 帧,不把读失败抛给调用方。放行的最坏后果 = 这一条通知晚到 —— 本该在活流的下一个边界投递(`priority: next`),改成下一次开流才排空(至少一次,晚一次开流),不丢、不错投;两臂的投递动作之前紧邻的住客复核照做,所以这不是门、不是权限、不是凭证。不放行(抛)= 一次 run 店瞬断把通知路由答成 500(经全局兜底)、把后台子代的完成通知记成 `relay_failed` 交不出去,比晚一次开流更糟。读失败与「会话真的空闲」在外部同形,所以必须留痕:计数 + 探针(detail 带会话 id 与错句,经记录器统一脱敏)+ 每进程一次 warn。";
     };
+    readonly "server.session-id-tombstone.evicted": {
+        readonly cls: "P-DEBT";
+        readonly note: "`deleted-session-ids.ts` 的 `retireSessionId`(本进程删过的会话 id → 删前属主那张表的唯一铸点;执行上下文解析器 `resolveExecutionContext` 读它,拒本进程上这只 id 的执行服务删前属主之外的住客 —— 409 `conflict.session_id_retired`):表满(`DELETED_SESSION_ID_CAP` 条)⇒ 驱逐最旧的一条,那个 id 回到「本进程没删过」。保护面、方向明知是放行 ⇒ 记债:表独自守着一个窄 P 面 —— 本服务按裸会话 id 键的通告分流器(`EngineNoticeRouter`)收委派腿的用户面通告,引擎 7.64.0 的地址是树根会话 id、不带住客 ⇒ 被驱逐的那个 id 上,另一位属主在本进程重登之后,前任住客子代的被拒通告可按 id 落进新住客的流(暂存那一形不在其内:引擎 7.64.0 起按住客存取,弃掉、运维席一条 delegation.delivery_discarded)。不放行的形是表无界增长。收口条件 = core #3479(委派腿通告地址带根住客)到货 ∧ 服务侧按裸会话 id 键的座普查为零 —— 届时表、本 tag 与 409 `conflict.session_id_retired` 一并退。";
+    };
     readonly "server.approvals.queue-row-gate-kind-missing": {
         readonly cls: "F";
-        readonly note: "S-1681(`plugins/checkpoint-store-sql.ts` 的 `queueRowGateKind`,7.132.0;SQL 与 local 两只孪生的 `listPending` 同调这一只判官):运维待批队列(`GET /v1/approvals` / `/stream`)读到一行 pending 的门型(SQL 孪生:`checkpoint.gate_kind` 列;local 孪生:快照上的门)是 NULL 或不是 core 登记的门型 ⇒ 这一行**不列**。按构造不可达:每次停驻都把门型反范式进这一列,一次性迁移 M21 把没有它的存量行从门子树补齐(读不出登记门型的置 expired)。放行(不列、队列其余照常)的最坏后果 = 一行谁也决不了的行不出现在队列上 —— 它本来就不可决:每一条决断口按门型绑定取行(`gate_kind IN (…)`),证不出门型就不当它是这道门;不放行(整只拒)的代价是一行坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)。也不按缺键投出去:消费方按 `gateKind` 路由、缺键即 fail-closed,队列行的契约是 `gateKind` 恒在场。故 F 类;计数非零 = 写腿或手改出了错,`SELECT session_id FROM checkpoint WHERE status = 'pending' AND gate_kind IS NULL` 查那一行(置 expired 或删会话)。";
+        readonly note: "S-1681(`plugins/checkpoint-store-face.ts` 的 `queueRowGateKind`,7.132.0;SQL 与 local 两只孪生的 `listPending` 同调这一只判官):运维待批队列(`GET /v1/approvals` / `/stream`)读到一行 pending 的门型(SQL 孪生:`checkpoint.gate_kind` 列;local 孪生:快照上的门)是 NULL 或不是 core 登记的门型 ⇒ 这一行**不列**。按构造不可达:每次停驻都把门型反范式进这一列,一次性迁移 M21 把没有它的存量行从门子树补齐(读不出登记门型的置 expired)。放行(不列、队列其余照常)的最坏后果 = 一行谁也决不了的行不出现在队列上 —— 它本来就不可决:每一条决断口按门型绑定取行(`gate_kind IN (…)`),证不出门型就不当它是这道门;不放行(整只拒)的代价是一行坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)。也不按缺键投出去:消费方按 `gateKind` 路由、缺键即 fail-closed,队列行的契约是 `gateKind` 恒在场。故 F 类;计数非零 = 写腿或手改出了错,`SELECT session_id FROM checkpoint WHERE status = 'pending' AND gate_kind IS NULL` 查那一行(置 expired 或删会话)。";
     };
     readonly "server.sql-json.checkpoint.pending-steer-queue-lossy": {
         readonly cls: "F";
-        readonly note: "S-550(`plugins/checkpoint-store-sql.ts` 的 `get()`,core 5.14.0 #147 的耐久转向队列):一条挂起 run 的 `checkpoint.pending_steer_queue` 这一格**没能完整读出来**(不是合法 JSON 文本 / 不是数组 / 某一条目的四个必备键不合形)⇒ 读不出的那部分**丢掉**,run 照常 resume。放行的最坏后果 = 一条已经 park 的操作员转向指令**没有**在这次 resume 上注入(人以为说过的话没送到);不放行的代价是这条挂起的 run **永远不可 resume** —— resume 是它唯一的出路,为一格读不出的转向把整条 run 变成砖是错误的失败方向(写侧刻意相反:`setPendingSteer` 往一份读不全的队列上追加会把读不出的条目永久抹掉,那里 fail-loud)。故 F 类。留痕从一条 `logger.info` 升成登记 tag 的理由:日志行在**遥测轴**上是零信号,「这台机器的转向队列一直读不出来」与「这台机器本来就没人 steer」在指标上完全同形。计数非零 = 去按日志里的 token 指纹查那一行。";
+        readonly note: "S-550(`stores-sql/checkpoint-store-sql.ts` 的 `get()`,core 5.14.0 #147 的耐久转向队列):一条挂起 run 的 `checkpoint.pending_steer_queue` 这一格**没能完整读出来**(不是合法 JSON 文本 / 不是数组 / 某一条目的四个必备键不合形)⇒ 读不出的那部分**丢掉**,run 照常 resume。放行的最坏后果 = 一条已经 park 的操作员转向指令**没有**在这次 resume 上注入(人以为说过的话没送到);不放行的代价是这条挂起的 run **永远不可 resume** —— resume 是它唯一的出路,为一格读不出的转向把整条 run 变成砖是错误的失败方向(写侧刻意相反:`setPendingSteer` 往一份读不全的队列上追加会把读不出的条目永久抹掉,那里 fail-loud)。故 F 类。留痕从一条 `logger.info` 升成登记 tag 的理由:日志行在**遥测轴**上是零信号,「这台机器的转向队列一直读不出来」与「这台机器本来就没人 steer」在指标上完全同形。计数非零 = 去按日志里的 token 指纹查那一行。";
     };
     readonly "server.sql-json.checkpoint.outcome-unreadable": {
         readonly cls: "F";
-        readonly note: "S-550(`plugins/checkpoint-store-sql.ts` 的 `findDecidedApprovalsForBinding`,`/decide` 的**幂等回放**腿):一条已决 checkpoint 行的 `outcome` 这一格读不出形(手改 / 撕裂写 / 迁移脚本改过)⇒ 这一行交出 `decision: null`(= 判别不出),调用方按「整次拒绝」处置。放行的最坏后果 = 一次 decide **重试**拿不到上次的判词,退回按新请求处理(而不是回放)—— 回放是锦上添花的腿,让一条读不出的 JSON 把一次重试变成 500 比这更坏;方向上没有任何批准被放宽(判不出就是判不出,调用方拒绝)。故 F 类。**只容忍体的问题**:`not-text`(读腿漏了投影)与连接/超时一律原样上抛 —— 那是码坏或故障,不是数据坏。";
+        readonly note: "S-550(`stores-sql/checkpoint-store-sql.ts` 的 `findDecidedApprovalsForBinding`,`/decide` 的**幂等回放**腿):一条已决 checkpoint 行的 `outcome` 这一格读不出形(手改 / 撕裂写 / 迁移脚本改过)⇒ 这一行交出 `decision: null`(= 判别不出),调用方按「整次拒绝」处置。放行的最坏后果 = 一次 decide **重试**拿不到上次的判词,退回按新请求处理(而不是回放)—— 回放是锦上添花的腿,让一条读不出的 JSON 把一次重试变成 500 比这更坏;方向上没有任何批准被放宽(判不出就是判不出,调用方拒绝)。故 F 类。**只容忍体的问题**:`not-text`(读腿漏了投影)与连接/超时一律原样上抛 —— 那是码坏或故障,不是数据坏。";
     };
     readonly "server.sql-json.checkpoint.execution-outcome-unreadable": {
         readonly cls: "F";
@@ -625,6 +625,10 @@ export declare const FAIL_OPEN_TAGS: {
         readonly cls: "F";
         readonly note: "在飞 run 的切档口(`http/routes/run-permission-mode.ts`,`POST /v1/runs/:id/permission-mode`):引擎已经收下新档(本腿下一次工具调用按它仲裁),把准入的词写回这条 run 存储体(run 模式词的唯一来源,续跑腿按它重建 spec)没有落定 —— 这一刻这条 run 已不持有会话认领或已不在跑(`claim_released`:切档与停驻 / 终局同时到;认领栅栏拒写,不会拿旧 run 的体盖掉同会话新 run 的)、会话没有存储体行(`context_absent`)、店写抛(`store_failed`:库抖 / 一行装不下 / 封签失败)。每次记一次 + 一行 warn,回执 `persisted:false` + `persistMiss` 照实告诉壳。放行的最坏后果 = 下一条腿(停驻后续跑 / 重启后续跑)回到切档前的词:切松了 ⇒ 续跑回到更严的档(多问);切严了 ⇒ 续跑回到切档前更松的档 —— 那一档是这条 run 提交时受理过的,受理判官当时判过,不越过任何部署拒;不是门、不是凭据。计数非零 = 切档常与停驻相撞或 checkpoint 店在出错;壳据 `persisted` 在续跑后重切。detail = `miss=<词> mode=<词>`。";
     };
+    readonly "server.capabilities.adoption-import-unreadable": {
+        readonly cls: "F";
+        readonly note: "能力位 `adoptionImport`(`adoption/import.ts` 的 `readAdoptionImportCapability`,`GET /v1/capabilities` 每请求一读):按调用者读它作为源主体的那一条收编行时库读抛(断连 / 超时 / 池断)⇒ 这一位缺席、能力面照常 200。放行的是**藏**的方向:缺席 = 「你还没被收编」,触发臂不出导入入口,导入口本身不受影响(它自己读行、读失败照常 5xx)。最坏后果 = 这一拍用户看不到「一键收编」,下一次读能力面恢复。计数非零 = 收编日志所在的库在这台副本上读不动。";
+    };
 };
 /** 词表键推导的闭集类型——未登记的 tag 传不进 {@link recordFailOpen}(编译期拒)。 */
 export type FailOpenTag = keyof typeof FAIL_OPEN_TAGS;

package/dist/observability/fail-open.js

@@ -157,17 +157,13 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "design/382 §3.5(S-44;core 7.55.0 #1468 P1 阶段二起读者是 core `readRuleOffers`,经 `approval-card.ts` 的 `readRuleOfferList`,两条腿同调):batch offer 的 `uncoveredDetail` 明细座不是「每个计数段一行良构行」(集外 reason / 非数组 / 行数与 count 座不等 —— core 读者判丢、读数带 `uncoveredDetailDropped`)或行数超本仓展示帽 MAX_UNCOVERED_DETAIL_ROWS ⇒ 只丢这一座、batch 本体照投。放行的最坏后果 = 卡上少几行「这段为什么还会问」的解释(count 座仍在,core 契约明写明细缺席不是断言);把整只 batch 判假才是错的方向(一只真可兑的合取批从卡上消失)。纯展示轴 ⇒ F 类;必须留痕,否则上游明细座漂形在遥测里零痕迹。detail = `index=<core 列表里的下标>` + 丢的缘由(不带段文本)。",
     },
-    "server.approval-batch.kindless-row": {
-        cls: "F",
-        note: "起服普查(`approval-batch-census.ts`;SQL 两方言同一只读口 `SqlCheckpointStore.scanKindlessBatchRows`):一行审批停驻行(`checkpoint` 表,所有状态)的规则提议里,有 batch offer 带着**无 `kind` 的存量成员** —— 引擎读者(`readRuleOffers`)为这个旧形留着一条存量读臂(无 `kind`、四个命令文本键齐的成员读成 `command`,并给那只 offer 打 `kindlessForm` 记号),本仓用 `countKindlessBatchOffers` 数这个记号。载体两个:`rule_suggestions` 列、blob 里的 `pendingAction.ruleOffers`(detail 的 `carriers=` 点名是哪个)。每个带旧形成员的行记一次(逐次计数 + 探针行 + 每进程一次 warn),起服另出一行 info `approval_batch_kindless_rows { count }`。放行的最坏后果 = 无新增放行:这是读侧存量兼容臂被数的位,读法本来就是『旧形读成 command』,普查不改任何一行的读法、不翻行、不删臂;留痕的唯一目的是让『还有几行靠这条臂』可证 —— 计数为零(整个部署的每个副本起服都是零)才能由后续一版删那条存量臂;非零 = 还有行靠它,不可删,detail 的 `row=` 是行指纹(不是 token)。F 类(读侧兼容、纯展示轴:这条臂读出的是「不再询问」候选的卡面,不是门)。逐页读、不是原子快照(页间别的副本的写入可以让一行被漏数或多数一行);滚动升级窗里停在旧版本的副本之后写的旧形行,下次起服才数得到。后台跑、不挡起服就绪。",
-    },
     "server.checkpoint.inbox-risk-axes-damaged": {
         cls: "F",
-        note: "core 7.55.0 `summarizeCheckpoint` 的第二参(`plugins/checkpoint-store-sql.ts` 的 `listByScope`:supervisor inbox / 调度视图的按 scope 待决投影):一行审批门的风险描述符读穿了一格坏轴 —— `axes` 不是普通对象,或某个标记(`egress` / `irreversible` / `shell`)在场却不是布尔(手改 / 第三方写者;引擎铸的行没有这一形)⇒ 行照投,`severity` 取有效标记给出的下界,证不出就缺席;core 交一句话给店的座,本座逐行计一次。放行的最坏后果 = 这一行在按 severity 倒排的 inbox 里排位偏低或无档(分诊材料,不是门;resume 的判据不读它)。不放行的代价是一行坏描述符打掉整个 scope 的 inbox(修前:非对象描述符抛 TypeError 出投影)。修前不传座 ⇒ 降档是静默的。detail = core 的句子(按 checkpoint id 与会话 JSON 点名、按形说成员,不带令牌、不带值);每次列 inbox 都会再说一次,直到那一行被修或被决。LOCAL 车道的同一句经 backend 的 `file_store_corrupt_read` 座(core File 店自带),不走本 tag。",
+        note: "core 7.55.0 `summarizeCheckpoint` 的第二参(`stores-sql/checkpoint-store-sql.ts` 的 `listByScope`:supervisor inbox / 调度视图的按 scope 待决投影):一行审批门的风险描述符读穿了一格坏轴 —— `axes` 不是普通对象,或某个标记(`egress` / `irreversible` / `shell`)在场却不是布尔(手改 / 第三方写者;引擎铸的行没有这一形)⇒ 行照投,`severity` 取有效标记给出的下界,证不出就缺席;core 交一句话给店的座,本座逐行计一次。放行的最坏后果 = 这一行在按 severity 倒排的 inbox 里排位偏低或无档(分诊材料,不是门;resume 的判据不读它)。不放行的代价是一行坏描述符打掉整个 scope 的 inbox(修前:非对象描述符抛 TypeError 出投影)。修前不传座 ⇒ 降档是静默的。detail = core 的句子(按 checkpoint id 与会话 JSON 点名、按形说成员,不带令牌、不带值);每次列 inbox 都会再说一次,直到那一行被修或被决。LOCAL 车道的同一句经 backend 的 `file_store_corrupt_read` 座(core File 店自带),不走本 tag。",
     },
     "server.rule-offers.offer-dropped": {
         cls: "F",
-        note: "core 7.55.0 #1468 P1 阶段二(`approval-card.ts` 的 `readRuleOfferList`,规则提议列表的唯一读者,判官 = core `readRuleOffers`;两条腿同调 —— 耐久腿 `checkpoint-store-sql.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行;同步腿 `tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`):一个元素读不出(`unknown_word`:offer / 成员的 `kind`、`match` 是本引擎不认的词 —— 更新的铸者或别的写者;`malformed`:不是对象、成员缺位或错型、空 batch、计数不是非负安全整数)⇒ 这一只整只丢(batch 不拆成员)、兄弟照投;整只值在场却不是列表(`not_an_array`)⇒ 这一行无供给。逐元素计。放行的最坏后果 = 卡上少一个「不再询问」选项(人仍可逐次批;少的是选项不是门 —— 渲出一个读不懂的选项、或少一个成员的合取批,才是错的方向)。修前耐久腿丢元素是静默的,同步腿走一行 logger warn(`rule_offer_dropped_unreadable_shape`,随之退役)。计数非零 = 有 offer 列表的形本引擎读不懂:上游版本领先(core 加了词)或库里的行被手改过。detail = `index=<下标> problem=<RULE_OFFER_SHAPE_PROBLEMS 的词>`(不带 offer 文本 —— 那是命令原文族)。",
+        note: "core 7.55.0 #1468 P1 阶段二(`approval-card.ts` 的 `readRuleOfferList`,规则提议列表的唯一读者,判官 = core `readRuleOffers`;两条腿同调 —— 耐久腿 `checkpoint-store-face.ts` `boundedRuleOffers`:铸行落列、回读列、LOCAL 孪生读寄存行;同步腿 `tool-approval.ts` `boundRuleOfferTexts`:活 ask 的 `AskRequest.ruleOffers`):一个元素读不出(`unknown_word`:offer / 成员的 `kind`、`match` 是本引擎不认的词 —— 更新的铸者或别的写者;`malformed`:不是对象、成员缺位或错型、空 batch、计数不是非负安全整数)⇒ 这一只整只丢(batch 不拆成员)、兄弟照投;整只值在场却不是列表(`not_an_array`)⇒ 这一行无供给。逐元素计。放行的最坏后果 = 卡上少一个「不再询问」选项(人仍可逐次批;少的是选项不是门 —— 渲出一个读不懂的选项、或少一个成员的合取批,才是错的方向)。修前耐久腿丢元素是静默的,同步腿走一行 logger warn(`rule_offer_dropped_unreadable_shape`,随之退役)。计数非零 = 有 offer 列表的形本引擎读不懂:上游版本领先(core 加了词)或库里的行被手改过。detail = `index=<下标> problem=<RULE_OFFER_SHAPE_PROBLEMS 的词>`(不带 offer 文本 —— 那是命令原文族)。",
     },
     "server.rules.ticket-claim-release-failed": {
         cls: "F",
@@ -183,7 +179,7 @@ export const FAIL_OPEN_TAGS = {
     },
     "server.approvals.park-row-blob-unreadable": {
         cls: "F",
-        note: "S-700(`plugins/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)",
+        note: "S-700(`stores-sql/checkpoint-store-sql.ts` 的 `readParkRowActionCell`):运维待批队列(`GET /v1/approvals` / `/stream`)的某一行,`checkpoint` 列里寄存行的 **`pendingAction` 子树**(NP-3 / 7.100.0 起引擎内只取这一棵、整只快照不出库;只为 park 行事实 `requiresRealApproval` / `ruleOffersAbsence` / `mandated`(S-663 二段,core #1079)/ `mandate`(S-721)/ `origin`(S-755)而读 —— 事实位的真源是 `approval-card.ts` 的 `ParkRowFacts`)**在场却不是一只对象**(JSON `null` 字面 / 串 / 数 —— 手改 / 迁移脚本改过)。子树**缺席**(SQL NULL:成员不在,或整只文档不是对象 —— 后者 `get()` 照旧拒;MariaDB 文本承载上的非 JSON 字节同样答 SQL NULL)⇒ 事实缺席、不计数。放行的最坏后果 = **这一行**的 park 行事实(`ParkRowFacts` 各位)缺席(展示/分诊材料;core 定性 display metadata,resume 的带子读 gate 自己的位),队列其余部分照常 —— 而这一行本来就 resume 不了(`get()` 对同一格拒)。不放行的代价是整只 `rows.map` 抛出 ⇒ 一行坏 blob 打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远空),与同一 `rows.map` 里 `rule_suggestions` / `risk_descriptor` 两格同族同判。故 F 类;tag 与那两格**分开计**(哪一格在坏要读得出来)。计数非零 = 这一行的 decide 同样读不动(`get()` 对同一格拒),去按 session 查那一行。 7.144.0 起同 tag 另有一座:停驻行的**整行读**(`readStoredRow`;按快照摘要记忆,未命中才读)—— 运维队列行的判决 `rowVerdict` 与技能卡两位、7.145.0 起还有收件箱 / 任务视图 `listByScope` 的行投影,同经这一只读法、同一失败方向(行级隔离):整行解不出 ⇒ 判官对读回的原样值作答(恒 `damaged`),行照列、带判决;体是对象但 core 摘要读不动(`{}` / 缺 `state` 等手改行)⇒ 判官对这只对象作答;两形都只丢摘要派生的位(队列行的技能卡两位 / 收件箱行的摘要键,收件箱行退回列组事实),逐次计、不进记忆,一行坏体在子树与整行两读上各计一次。修前收件箱对同一行整张拒(500 / 503)。 (`member=gate` 那第二座随 core 7.55.0 #1468 P1 阶段二退役:队列行的卡与到期分法改读 `approval_card` / `gate_kind` 两列 —— 写口与 M29 回填同一只派生落下的格 —— 本读面不再读 blob 的 `gate` 子树。)(S-2076 的 `readParkedSkillCardFacts` 两座已由上面那次 `projectStoredRow` 整行读取代,树上零命中。)",
     },
     "server.approvals.queue-row-agent-unreadable": {
         cls: "F",
@@ -201,17 +197,21 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "`session-notify-door.ts` 的 `deliver`(会话通知门的判活读;两只调用方 `POST /v1/sessions/:id/notify` 与后台子代完成 relay 同经):判活读 —— run 店的单活认领读 `getActiveTaskId` —— 抛(店瞬断 / 超时 / 连接被回收)⇒ 门当这只会话**没有在飞的 run**,落空闲臂:入收件箱,下次开流排空成 `task_notification` 帧,不把读失败抛给调用方。放行的最坏后果 = 这一条通知晚到 —— 本该在活流的下一个边界投递(`priority: next`),改成下一次开流才排空(至少一次,晚一次开流),不丢、不错投;两臂的投递动作之前紧邻的住客复核照做,所以这不是门、不是权限、不是凭证。不放行(抛)= 一次 run 店瞬断把通知路由答成 500(经全局兜底)、把后台子代的完成通知记成 `relay_failed` 交不出去,比晚一次开流更糟。读失败与「会话真的空闲」在外部同形,所以必须留痕:计数 + 探针(detail 带会话 id 与错句,经记录器统一脱敏)+ 每进程一次 warn。",
     },
+    "server.session-id-tombstone.evicted": {
+        cls: "P-DEBT",
+        note: "`deleted-session-ids.ts` 的 `retireSessionId`(本进程删过的会话 id → 删前属主那张表的唯一铸点;执行上下文解析器 `resolveExecutionContext` 读它,拒本进程上这只 id 的执行服务删前属主之外的住客 —— 409 `conflict.session_id_retired`):表满(`DELETED_SESSION_ID_CAP` 条)⇒ 驱逐最旧的一条,那个 id 回到「本进程没删过」。保护面、方向明知是放行 ⇒ 记债:表独自守着一个窄 P 面 —— 本服务按裸会话 id 键的通告分流器(`EngineNoticeRouter`)收委派腿的用户面通告,引擎 7.64.0 的地址是树根会话 id、不带住客 ⇒ 被驱逐的那个 id 上,另一位属主在本进程重登之后,前任住客子代的被拒通告可按 id 落进新住客的流(暂存那一形不在其内:引擎 7.64.0 起按住客存取,弃掉、运维席一条 delegation.delivery_discarded)。不放行的形是表无界增长。收口条件 = core #3479(委派腿通告地址带根住客)到货 ∧ 服务侧按裸会话 id 键的座普查为零 —— 届时表、本 tag 与 409 `conflict.session_id_retired` 一并退。",
+    },
     "server.approvals.queue-row-gate-kind-missing": {
         cls: "F",
-        note: "S-1681(`plugins/checkpoint-store-sql.ts` 的 `queueRowGateKind`,7.132.0;SQL 与 local 两只孪生的 `listPending` 同调这一只判官):运维待批队列(`GET /v1/approvals` / `/stream`)读到一行 pending 的门型(SQL 孪生:`checkpoint.gate_kind` 列;local 孪生:快照上的门)是 NULL 或不是 core 登记的门型 ⇒ 这一行**不列**。按构造不可达:每次停驻都把门型反范式进这一列,一次性迁移 M21 把没有它的存量行从门子树补齐(读不出登记门型的置 expired)。放行(不列、队列其余照常)的最坏后果 = 一行谁也决不了的行不出现在队列上 —— 它本来就不可决:每一条决断口按门型绑定取行(`gate_kind IN (…)`),证不出门型就不当它是这道门;不放行(整只拒)的代价是一行坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)。也不按缺键投出去:消费方按 `gateKind` 路由、缺键即 fail-closed,队列行的契约是 `gateKind` 恒在场。故 F 类;计数非零 = 写腿或手改出了错,`SELECT session_id FROM checkpoint WHERE status = 'pending' AND gate_kind IS NULL` 查那一行(置 expired 或删会话)。",
+        note: "S-1681(`plugins/checkpoint-store-face.ts` 的 `queueRowGateKind`,7.132.0;SQL 与 local 两只孪生的 `listPending` 同调这一只判官):运维待批队列(`GET /v1/approvals` / `/stream`)读到一行 pending 的门型(SQL 孪生:`checkpoint.gate_kind` 列;local 孪生:快照上的门)是 NULL 或不是 core 登记的门型 ⇒ 这一行**不列**。按构造不可达:每次停驻都把门型反范式进这一列,一次性迁移 M21 把没有它的存量行从门子树补齐(读不出登记门型的置 expired)。放行(不列、队列其余照常)的最坏后果 = 一行谁也决不了的行不出现在队列上 —— 它本来就不可决:每一条决断口按门型绑定取行(`gate_kind IN (…)`),证不出门型就不当它是这道门;不放行(整只拒)的代价是一行坏行打掉整个租户的队列(列表 500、SSE 心跳照常而队列永远停在旧帧)。也不按缺键投出去:消费方按 `gateKind` 路由、缺键即 fail-closed,队列行的契约是 `gateKind` 恒在场。故 F 类;计数非零 = 写腿或手改出了错,`SELECT session_id FROM checkpoint WHERE status = 'pending' AND gate_kind IS NULL` 查那一行(置 expired 或删会话)。",
     },
     "server.sql-json.checkpoint.pending-steer-queue-lossy": {
         cls: "F",
-        note: "S-550(`plugins/checkpoint-store-sql.ts` 的 `get()`,core 5.14.0 #147 的耐久转向队列):一条挂起 run 的 `checkpoint.pending_steer_queue` 这一格**没能完整读出来**(不是合法 JSON 文本 / 不是数组 / 某一条目的四个必备键不合形)⇒ 读不出的那部分**丢掉**,run 照常 resume。放行的最坏后果 = 一条已经 park 的操作员转向指令**没有**在这次 resume 上注入(人以为说过的话没送到);不放行的代价是这条挂起的 run **永远不可 resume** —— resume 是它唯一的出路,为一格读不出的转向把整条 run 变成砖是错误的失败方向(写侧刻意相反:`setPendingSteer` 往一份读不全的队列上追加会把读不出的条目永久抹掉,那里 fail-loud)。故 F 类。留痕从一条 `logger.info` 升成登记 tag 的理由:日志行在**遥测轴**上是零信号,「这台机器的转向队列一直读不出来」与「这台机器本来就没人 steer」在指标上完全同形。计数非零 = 去按日志里的 token 指纹查那一行。",
+        note: "S-550(`stores-sql/checkpoint-store-sql.ts` 的 `get()`,core 5.14.0 #147 的耐久转向队列):一条挂起 run 的 `checkpoint.pending_steer_queue` 这一格**没能完整读出来**(不是合法 JSON 文本 / 不是数组 / 某一条目的四个必备键不合形)⇒ 读不出的那部分**丢掉**,run 照常 resume。放行的最坏后果 = 一条已经 park 的操作员转向指令**没有**在这次 resume 上注入(人以为说过的话没送到);不放行的代价是这条挂起的 run **永远不可 resume** —— resume 是它唯一的出路,为一格读不出的转向把整条 run 变成砖是错误的失败方向(写侧刻意相反:`setPendingSteer` 往一份读不全的队列上追加会把读不出的条目永久抹掉,那里 fail-loud)。故 F 类。留痕从一条 `logger.info` 升成登记 tag 的理由:日志行在**遥测轴**上是零信号,「这台机器的转向队列一直读不出来」与「这台机器本来就没人 steer」在指标上完全同形。计数非零 = 去按日志里的 token 指纹查那一行。",
     },
     "server.sql-json.checkpoint.outcome-unreadable": {
         cls: "F",
-        note: "S-550(`plugins/checkpoint-store-sql.ts` 的 `findDecidedApprovalsForBinding`,`/decide` 的**幂等回放**腿):一条已决 checkpoint 行的 `outcome` 这一格读不出形(手改 / 撕裂写 / 迁移脚本改过)⇒ 这一行交出 `decision: null`(= 判别不出),调用方按「整次拒绝」处置。放行的最坏后果 = 一次 decide **重试**拿不到上次的判词,退回按新请求处理(而不是回放)—— 回放是锦上添花的腿,让一条读不出的 JSON 把一次重试变成 500 比这更坏;方向上没有任何批准被放宽(判不出就是判不出,调用方拒绝)。故 F 类。**只容忍体的问题**:`not-text`(读腿漏了投影)与连接/超时一律原样上抛 —— 那是码坏或故障,不是数据坏。",
+        note: "S-550(`stores-sql/checkpoint-store-sql.ts` 的 `findDecidedApprovalsForBinding`,`/decide` 的**幂等回放**腿):一条已决 checkpoint 行的 `outcome` 这一格读不出形(手改 / 撕裂写 / 迁移脚本改过)⇒ 这一行交出 `decision: null`(= 判别不出),调用方按「整次拒绝」处置。放行的最坏后果 = 一次 decide **重试**拿不到上次的判词,退回按新请求处理(而不是回放)—— 回放是锦上添花的腿,让一条读不出的 JSON 把一次重试变成 500 比这更坏;方向上没有任何批准被放宽(判不出就是判不出,调用方拒绝)。故 F 类。**只容忍体的问题**:`not-text`(读腿漏了投影)与连接/超时一律原样上抛 —— 那是码坏或故障,不是数据坏。",
     },
     "server.sql-json.checkpoint.execution-outcome-unreadable": {
         cls: "F",
@@ -583,6 +583,10 @@ export const FAIL_OPEN_TAGS = {
         cls: "F",
         note: "在飞 run 的切档口(`http/routes/run-permission-mode.ts`,`POST /v1/runs/:id/permission-mode`):引擎已经收下新档(本腿下一次工具调用按它仲裁),把准入的词写回这条 run 存储体(run 模式词的唯一来源,续跑腿按它重建 spec)没有落定 —— 这一刻这条 run 已不持有会话认领或已不在跑(`claim_released`:切档与停驻 / 终局同时到;认领栅栏拒写,不会拿旧 run 的体盖掉同会话新 run 的)、会话没有存储体行(`context_absent`)、店写抛(`store_failed`:库抖 / 一行装不下 / 封签失败)。每次记一次 + 一行 warn,回执 `persisted:false` + `persistMiss` 照实告诉壳。放行的最坏后果 = 下一条腿(停驻后续跑 / 重启后续跑)回到切档前的词:切松了 ⇒ 续跑回到更严的档(多问);切严了 ⇒ 续跑回到切档前更松的档 —— 那一档是这条 run 提交时受理过的,受理判官当时判过,不越过任何部署拒;不是门、不是凭据。计数非零 = 切档常与停驻相撞或 checkpoint 店在出错;壳据 `persisted` 在续跑后重切。detail = `miss=<词> mode=<词>`。",
     },
+    "server.capabilities.adoption-import-unreadable": {
+        cls: "F",
+        note: "能力位 `adoptionImport`(`adoption/import.ts` 的 `readAdoptionImportCapability`,`GET /v1/capabilities` 每请求一读):按调用者读它作为源主体的那一条收编行时库读抛(断连 / 超时 / 池断)⇒ 这一位缺席、能力面照常 200。放行的是**藏**的方向:缺席 = 「你还没被收编」,触发臂不出导入入口,导入口本身不受影响(它自己读行、读失败照常 5xx)。最坏后果 = 这一拍用户看不到「一键收编」,下一次读能力面恢复。计数非零 = 收编日志所在的库在这台副本上读不动。",
+    },
 };
 export function failOpenTagForDroppedFrame(frameType) {
     switch (frameType) {