@sema-agent/server 7.146.0 → 7.148.0

package/dist/spec-fields.js

@@ -3,7 +3,8 @@ import { taskWallClockSec } from "./task-workflow.js";
 import { ABSOLUTE_HOST_PATH_MAX, isAbsoluteHostPath } from "@sema-agent/settings-schema";
 import { ruleEntryListShapeOk, skillToolListsOverCap } from "./rule-entry-list.js";
 import { describeLimit, limitFacts, limitRefusal } from "./limit-refusal.js";
-import { quotedCallerText } from "./caller-text-echo.js";
+import { echoCallerText, quotedCallerText } from "./caller-text-echo.js";
+import { skillCarriesRetiredManifest } from "./http/retired-skill-manifest.js";
 export function normalizeSuggestNextPrompts(v) {
     if (v === true)
         return true;
@@ -77,7 +78,6 @@ const MAX_AGENT_TEXT_CHARS = 4_096;
 const MAX_AGENT_SYSTEM_PROMPT_CHARS = 65_536;
 const MAX_AGENT_TOOLS = 64;
 const MAX_AGENT_TOOL_NAME_CHARS = 128;
-const MAX_AGENT_SKILL_CONTENT_CHARS = 1_048_576;
 const MAX_AGENT_MAX_TURNS = 1_000;
 const boundedString = (max) => (v) => typeof v === "string" && v.length <= max;
 const toolList = (v) => Array.isArray(v) &&
@@ -96,54 +96,69 @@ const toolListLimit = (v) => {
 };
 const plainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 export const skillToolListOk = ruleEntryListShapeOk;
-const skillFilesOk = (v) => Array.isArray(v) &&
-    v.every((f) => plainObject(f) && typeof f.path === "string" && f.path.length > 0 && typeof f.content === "string");
+const SKILL_TOOL_LIST_DESC = "an array of strings (permission-rule spellings: a tool name, mcp__<server> / mcp__<server>__*, Bash(<prefix>:*), Read(//<dir>/**))";
+export const MAX_SKILL_CONTENT_CHARS = 1_048_576;
+export const SKILL_NAMED_REFUSALS = {
+    manifest: "was retired in core 7.41.0 — a skill's tools are its allowedTools / disallowedTools now (an allow-rule and a deny-rule source for the run the skill is activated in, never a fence); move manifest.allowTools to allowedTools. To fence tools use deny rules (settings.permissions.deny) or a delegated agent's allowTools; to fence write paths use the session rules' allowDirs",
+    mods: "is not a request key — skill registrations are code the deployment mounts, not request data (this server does not compile skill hooks: GET /v1/capabilities answers mods.skill_seat: false)",
+};
+const skillCharLimit = (max) => (v) => typeof v === "string" && v.length > max ? { measure: "characters", count: v.length, cap: max } : undefined;
 const SKILL_FIELD_SHAPES = {
-    name: { required: true, ok: (v) => typeof v === "string" && v.length > 0 },
-    description: { required: true, ok: (v) => typeof v === "string" },
-    content: { required: true, ok: (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_AGENT_SKILL_CONTENT_CHARS },
-    allowedTools: { required: false, ok: skillToolListOk },
-    disallowedTools: { required: false, ok: skillToolListOk },
-    files: { required: false, ok: skillFilesOk },
-    baseDir: { required: false, ok: isAbsoluteHostPath },
-    mods: { required: false, ok: () => false },
+    name: { required: true, desc: "a non-empty string", ok: (v) => typeof v === "string" && v.length > 0 },
+    description: { required: true, desc: "a string", ok: (v) => typeof v === "string" },
+    content: {
+        required: true,
+        desc: `a non-empty string of at most ${MAX_SKILL_CONTENT_CHARS} characters (the engine rejects skills over this size outright at load time)`,
+        ok: (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_SKILL_CONTENT_CHARS,
+        limit: skillCharLimit(MAX_SKILL_CONTENT_CHARS),
+    },
+    allowedTools: { required: false, desc: SKILL_TOOL_LIST_DESC, ok: skillToolListOk },
+    disallowedTools: { required: false, desc: SKILL_TOOL_LIST_DESC, ok: skillToolListOk },
+    files: {
+        required: false,
+        desc: "an array of { path, content } entries (path a non-empty string, content a string)",
+        ok: (v) => Array.isArray(v) && v.every((f) => plainObject(f) && typeof f.path === "string" && f.path.length > 0 && typeof f.content === "string"),
+    },
+    baseDir: {
+        required: false,
+        desc: `an absolute path string of at most ${ABSOLUTE_HOST_PATH_MAX} characters with no ".." segment and no NUL byte (it is not resolved or read here — the engine only substitutes it into the skill's own text)`,
+        ok: isAbsoluteHostPath,
+        limit: skillCharLimit(ABSOLUTE_HOST_PATH_MAX),
+    },
 };
-const skillOk = (s) => {
-    if (!plainObject(s))
-        return false;
-    for (const k of Object.keys(s)) {
-        if (!Object.hasOwn(SKILL_FIELD_SHAPES, k))
-            return false;
+const SKILL_UNKNOWN_KEY_TAIL = `is not a skill key — a skill carries ${Object.keys(SKILL_FIELD_SHAPES)
+    .filter((k) => SKILL_FIELD_SHAPES[k].required)
+    .join(", ")} and optionally ${Object.keys(SKILL_FIELD_SHAPES)
+    .filter((k) => !SKILL_FIELD_SHAPES[k].required)
+    .join(", ")}`;
+function namedRefusalOf(skill) {
+    if (skillCarriesRetiredManifest(skill))
+        return "manifest";
+    return Object.hasOwn(skill, "mods") ? "mods" : undefined;
+}
+export function skillItemIssue(skill) {
+    if (!plainObject(skill))
+        return { words: "must be an object { name, description, content }" };
+    const named = namedRefusalOf(skill);
+    if (named !== undefined)
+        return { key: named, words: SKILL_NAMED_REFUSALS[named] };
+    for (const key of Object.keys(skill)) {
+        if (!Object.hasOwn(SKILL_FIELD_SHAPES, key))
+            return { key: echoCallerText(key), words: SKILL_UNKNOWN_KEY_TAIL };
     }
-    for (const [k, shape] of Object.entries(SKILL_FIELD_SHAPES)) {
-        const v = s[k];
-        if (v === undefined) {
-            if (shape.required)
-                return false;
+    for (const [key, shape] of Object.entries(SKILL_FIELD_SHAPES)) {
+        const v = skill[key];
+        if (v === undefined ? !shape.required : shape.ok(v))
             continue;
-        }
-        if (!shape.ok(v))
-            return false;
-    }
-    return true;
-};
-const skillsLimit = (v) => {
-    if (!Array.isArray(v))
-        return undefined;
-    const j = v.findIndex((s) => !skillOk(s));
-    const s = j < 0 ? undefined : v[j];
-    if (!plainObject(s))
-        return undefined;
-    const content = s["content"];
-    const baseDir = s["baseDir"];
-    if (typeof content === "string" && content.length > MAX_AGENT_SKILL_CONTENT_CHARS) {
-        return { sub: `[${j}].content`, measure: "characters", count: content.length, cap: MAX_AGENT_SKILL_CONTENT_CHARS, keepShapeSentence: true };
+        const limit = v === undefined ? undefined : shape.limit?.(v);
+        return { key, words: `must be ${shape.desc}`, ...(limit === undefined ? {} : { limit }) };
     }
-    if (typeof baseDir === "string" && baseDir.length > ABSOLUTE_HOST_PATH_MAX) {
-        return { sub: `[${j}].baseDir`, measure: "characters", count: baseDir.length, cap: ABSOLUTE_HOST_PATH_MAX, keepShapeSentence: true };
-    }
-    return undefined;
-};
+    return null;
+}
+export function skillRefusalAt(at, issue) {
+    const field = issue.key === undefined ? at : `${at}.${issue.key}`;
+    return { message: `${field} ${issue.words}`, facts: issue.limit === undefined ? { field } : limitFacts(field, issue.limit.measure, issue.limit.count, issue.limit.cap) };
+}
 const memoryOk = (v) => {
     if (!plainObject(v))
         return false;
@@ -171,11 +186,7 @@ const TASK_AGENT_FIELD_SHAPES = {
     whenToUseLean: { desc: `a string of at most ${MAX_AGENT_TEXT_CHARS} characters`, ok: boundedString(MAX_AGENT_TEXT_CHARS), limit: charLimit(MAX_AGENT_TEXT_CHARS) },
     allowTools: { desc: `an array of at most ${MAX_AGENT_TOOLS} non-empty strings of at most ${MAX_AGENT_TOOL_NAME_CHARS} characters each`, ok: toolList, limit: toolListLimit },
     denyTools: { desc: `an array of at most ${MAX_AGENT_TOOLS} non-empty strings of at most ${MAX_AGENT_TOOL_NAME_CHARS} characters each`, ok: toolList, limit: toolListLimit },
-    skills: {
-        desc: "an array of { name, description, content } skill objects (optional allowedTools/disallowedTools/files/baseDir; allowedTools/disallowedTools are arrays of strings; files entries need { path, content }; baseDir must be an absolute path with no \"..\" segment) — no count cap; the engine renders the listing within its own byte budget",
-        ok: (v) => Array.isArray(v) && v.every(skillOk),
-        limit: skillsLimit,
-    },
+    skills: { desc: "an array of skill objects — no count cap; the engine renders the listing within its own byte budget", ok: (v) => Array.isArray(v) },
     background: { desc: "a boolean", ok: (v) => typeof v === "boolean" },
     isolation: { desc: '"worktree"', ok: (v) => v === "worktree" },
     model: {
@@ -216,7 +227,15 @@ export function taskAgentIssue(item) {
             return { message: `agent.${k} must be ${shape.desc}` };
         const rel = `${k}${hit.sub}`;
         const limit = { rel, measure: hit.measure, count: hit.count, cap: hit.cap };
-        return hit.keepShapeSentence === true ? { message: `agent.${k} must be ${shape.desc}`, limit } : { message: describeLimit(`agent.${rel}`, hit.measure, hit.count, hit.cap), limit };
+        return { message: describeLimit(`agent.${rel}`, hit.measure, hit.count, hit.cap), limit };
+    }
+    const skills = rec.skills;
+    if (Array.isArray(skills)) {
+        for (let j = 0; j < skills.length; j++) {
+            const issue = skillItemIssue(skills[j]);
+            if (issue !== null)
+                return { message: skillRefusalAt(`agent.skills[${j}]`, issue).message, skill: { index: j, issue } };
+        }
     }
     return null;
 }
@@ -228,6 +247,8 @@ export function validateTaskAgents(v) {
     const names = new Set();
     for (let i = 0; i < v.length; i++) {
         const issue = taskAgentIssue(v[i]);
+        if (issue?.skill !== undefined)
+            return skillRefusalAt(`agents[${i}].skills[${issue.skill.index}]`, issue.skill.issue);
         if (issue) {
             const message = `agents[${i}]: ${issue.message}`;
             return issue.limit === undefined ? { message } : { message, facts: limitFacts(`agents[${i}].${issue.limit.rel}`, issue.limit.measure, issue.limit.count, issue.limit.cap) };

package/dist/store-posture.d.ts

@@ -1,25 +1,13 @@
-/**
- * [ref] ①(设计稿 v1.1 §2①)—— 「这台副本**真的在持久化吗**」的单一推导点:caps `store`、`/health.storeDegraded` / `durable:false`、
- * gauge `store_backend_degraded` 三面读**同一只装配值**({@link StorePosture},`boot/stores.ts` 铸一次)。
- *
- * ## 病
- * 7.105.0 及以前,店降级的痕迹是 gauge + `/health` 两位 + caps `sql:null` —— 而 `sql:null` 同时是「本来就没配 SQL」「local 文件店」
- * 「降级到内存」「最近一次连接初始化被拒」四件事;调用方分不清「以为在持久化,其实在内存」这最坏的一形。
- *
- * ## 形
- * `declared` = 运维的声明(`DB_BACKEND` 词,含缺省推导);`backend` = **装配出的**后端 kind(没装出后端 = `memory`);两者不等是合法的
- * 形(`DB_BACKEND=pg` + 坐标在场 + `SESSION_BACKEND=memory` = 声明 pg、刻意不持久 —— 坐标缺席的声明在配置期拒启,见 `sql-engine-coordinates.ts`;缺省推导 local 起不来)—— 两位都上 wire,
- * 由调用方自己读出落差。`degradedReason` present-iff 降级臂走过(按后端族定词,{@link storeDegradedReasonFor})。
- * 顶层 `sql` 并入 `store.sql`(硬 breaking,零别名;对象逐字同形)。
- */
 import type { StoreBackend as StoreBackendWord } from "@sema-agent/settings-schema/execution-lanes";
 import type { ServiceConfig } from "./config-types.js";
 import type { StoreBackend } from "./plugins/store-backend.js";
 import type { SqlEngineFacts } from "./plugins/sql-driver.js";
 import { type SqlEngineCapability } from "./sql-engine-posture.js";
+import { type MountRow, type MountTable } from "./mountinfo.js";
 /**
  * 降级词闭集(**按后端族**,不按失败发生在哪一步):
- *  · `local_unwritable` —— **缺省推导**的 local 文件店构造期失败(mkdir / 数据根锁 / 权限 / 只读挂载 / 磁盘满)。
+ *  · `local_unwritable` —— **缺省推导**的 local 文件店在**空 / 不存在**的数据根上构造期失败(mkdir / 权限 / 只读挂载 / 磁盘满)。
+ *    数据根上已有东西时开不了(含另一实例持锁)是拒启,不是降级(判据见 `openStoreBackendWithFallback`)。
  *
  * 🔴 SQL 族**没有**降级词:配了 DSN 的库当下打不开 ⇒ 窗内重试、到窗拒启(`plugins/store-open-wait.ts` / `openStoreBackendWithFallback`),
  * 从来不退成内存 —— 修前这里有第二个词 `db_unreachable`(`SESSION_BACKEND=auto` 下 SQL 族打不开 ⇒ 内存 + 本位置位),那是 [ref] P 类的静默 fail-open,随降级臂一并退役。
@@ -29,28 +17,137 @@ export type StoreDegradedReason = (typeof STORE_DEGRADED_REASONS)[number];
 /** 降级臂按后端族定词(穷举 switch:词表加员 ⇒ 编译红)。只有缺省推导的 `local` 走得到降级臂;`mysql` / `pg` / `memory` 走到这里 = 装配缺陷,响亮抛。 */
 export declare function storeDegradedReasonFor(declared: StoreBackendWord): StoreDegradedReason;
 /**
- * `/health.sessionBackend` 与 `listening` 日志 `session` 位的**唯一读法**:装配后的 `config.sessionBackend`(`memory` | `tidb`;`tidb` = 「后端自己的 durable 店」的泛指标签)
- * + 装配出的后端 kind ⇒ 对运维说人话的有效店 —— `durable(pg)` / `durable(mysql)` / `durable(local)` / `memory`。`sessionBackend` 缺 backend 的 `tidb`
- * 不替它编一个后端名(那是装配缺陷,`createSessionStore` 会先拒)。部署侧的 smoke(`deploy/sema-up/lib/health.sh`)按这一形读同一位。
+ * `/health.sessionBackend` 与 `listening` 日志 `session` 位的**唯一读法**:装配后的 `config.sessionBackend`(`memory` | `tidb`;`tidb` = 「后端自己的店」的泛指标签)
+ * + 装配出的后端 kind ⇒ 会话店落在哪种后端上 —— `pg` / `mysql` / `local` / `memory`。**只说种类,不说持久**:持久性是另一个读数(`/health.store.durability`,
+ * 与 caps 同一只装配值)。`sessionBackend` 缺 backend 的 `tidb` 不替它编一个后端名(那是装配缺陷,`createSessionStore` 会先拒)。
  */
 export declare function sessionStoreLabelOf(sessionBackend: ServiceConfig["sessionBackend"], backendKind: StoreBackend["kind"] | undefined): string;
-/** 装配值(纯数据;`boot/stores.ts` 铸一次,gauge / `/health` / caps 三面同读)。 */
+/** 持久性三态(闭集;wire 词)。`unknown` = 判不出(证据缺 / 读不懂 / 介质形不在规则表里),从不折成 `durable`。 */
+export declare const STORE_DURABILITIES: readonly ["durable", "ephemeral", "unknown"];
+export type StoreDurability = (typeof STORE_DURABILITIES)[number];
+/** 三根(闭集;诊断面 `storeDurability.roots[].root` 的词)。 */
+export declare const STORE_ROOTS: readonly ["data", "sealed_key", "memory"];
+export type StoreRoot = (typeof STORE_ROOTS)[number];
+/**
+ * 判定依据词(闭集;诊断面 `roots[].rule` 的词)—— 每一根的判定是哪一条规则给的。三态由 {@link durabilityOfRule} 的穷举 switch 从它派生(加词 ⇒ 编译红,
+ * 由人显式判它属于哪一态)。
+ */
+export declare const STORE_DURABILITY_RULES: readonly ["backend_memory", "backend_sql", "fs_volatile", "k8s_empty_dir", "k8s_persistent_volume", "network_fs", "block_device", "unrecognized_mount", "mount_unresolved", "mountinfo_unreadable", "mountinfo_malformed", "path_unresolvable", "not_linux"];
+export type StoreDurabilityRule = (typeof STORE_DURABILITY_RULES)[number];
+/** 规则词 → 三态(穷举 switch)。 */
+export declare function durabilityOfRule(rule: StoreDurabilityRule): StoreDurability;
+/** 规则表里的词(挂载形那一半)。 */
+type StoreMountRule = Extract<StoreDurabilityRule, "fs_volatile" | "k8s_empty_dir" | "k8s_persistent_volume" | "network_fs" | "block_device">;
+/**
+ * 挂载形的规则表(闭集常量表,先中先判;一行都不中 ⇒ `unrecognized_mount` = `unknown`)。读的是走路径看见的那一只挂载:
+ *  · `fs_volatile` —— fs 类型 `overlay` / `tmpfs` / `ramfs`(容器根的可写层、内存盘):随容器 / Pod 删;
+ *  · `k8s_empty_dir` —— 根路径含 `kubernetes.io~empty-dir`(磁盘介质的 emptyDir;内存介质的是 tmpfs,上一行已中):随 Pod 删;
+ *  · `k8s_persistent_volume` —— 根路径含 `kubernetes.io~csi` / `kubernetes.io~local-volume`(PV 经 kubelet 挂进来);
+ *  · `network_fs` —— `nfs*` / `cifs` / `ceph` / `glusterfs` / `9p`(`9p` 挂在 `/` 上是沙箱运行时的容器根,不算);
+ *  · `block_device` —— 挂载源是块设备(`/dev/…`)且**整只文件系统**挂上来(根路径 `/`):虚机 / 裸机的盘、块形 PV。
+ *    绑定挂载一只子目录(根路径不是 `/`:hostPath、docker 卷 / 绑定、btrfs 子卷)不中这一行 —— 那只目录跟着谁走看不出来,归 `unknown`。
+ */
+export declare const STORE_MOUNT_RULES: readonly {
+    readonly rule: StoreMountRule;
+    readonly holds: (m: MountRow) => boolean;
+}[];
+/** 一只挂载按规则表判出的依据词。 */
+export declare function classifyStoreMount(m: MountRow): StoreDurabilityRule;
+/** 一根的判定(逐根明细的形;诊断面 `storeDurability.roots[]` 原样出)。 */
+export interface StoreRootDurability {
+    readonly root: StoreRoot;
+    /** 判的那条物理路径(符号链接已展平);SQL / memory 后端的数据根没有路径 ⇒ `null`。 */
+    readonly path: string | null;
+    /** 走那条路径看见的那一只挂载(判不出 ⇒ 三格 `null`)。 */
+    readonly mountPoint: string | null;
+    readonly mountSource: string | null;
+    readonly fsType: string | null;
+    readonly rule: StoreDurabilityRule;
+    readonly verdict: StoreDurability;
+}
+/** 一根的判定去掉根名(取证时还不知道它排在哪一行)。 */
+export type StoreRootReading = Omit<StoreRootDurability, "root">;
+/** 挂载表这一份证据的读数。 */
+export type MountTableReading = {
+    readonly kind: "read";
+    readonly table: MountTable;
+} | {
+    readonly kind: "unreadable";
+} | {
+    readonly kind: "not_linux";
+};
+/** 一条物理路径落在什么介质上(纯函数)。挂载表里有读不懂的行 ⇒ 不判(看见的那一只可能正是被读丢的那一行)。 */
+export declare function judgeStoreRootPath(physicalPath: string, reading: MountTableReading): StoreRootReading;
+/** 最弱律:`ephemeral` < `unknown` < `durable`;空表 ⇒ `unknown`(没有证据永不答 `durable`)。 */
+export declare function weakestDurability(verdicts: readonly StoreDurability[]): StoreDurability;
+/**
+ * 数据根上**有没有东西**(开店之前读;开店本身会建根、落锁,读晚了恒答「有」)。两个调用点:起服第 2 段段首的取证(`store_fresh_start` 的判据),
+ * 与 `openStoreBackendWithFallback` 的降级判据。不存在(`ENOENT`)/ 路径上有一段不是目录(`ENOTDIR`)⇒ 没有;空目录 ⇒ 没有;有任何条目 ⇒ 有。
+ * 读不出(`EACCES` 等)⇒ 判不了 ⇒ 按「有」答(fail-closed:判不了的那一形不许把它当空根降级,也不许说「本次在空店上初始化」)。
+ */
+export declare function localDataRootHoldsData(root: string): boolean;
+/** 起服证据(纯数据;第 2 段段首铸一次,随开店带到第 3 段)。 */
+export interface StoreEvidence {
+    /** 第 2 段写任何东西之前,数据根上有没有东西({@link localDataRootHoldsData})。 */
+    readonly dataRootHeldData: boolean;
+    /** 数据根的介质(只在装配出 local 后端时进判定;别的后端按后端规则判)。 */
+    readonly dataRoot: StoreRootReading;
+    readonly sealedKey: StoreRootReading;
+    /** file 记忆根:`MEMORY_ENGINE_BACKEND=file` 时取证;进不进判定看引擎真接没接线(`buildStorePosture` 的 `memoryRootWired`)。 */
+    readonly memory?: StoreRootReading;
+}
+/** 取证要判的三条路径(按各自属主解析好的配置路径;`boot/store-evidence.ts` 递)。 */
+export interface StoreEvidencePaths {
+    readonly dataRoot: string;
+    readonly sealedKeyDir: string;
+    readonly memoryRoot: string | undefined;
+}
+/** 取证的宿主座:`canonical` 由调用方给(符号链接展平的那一只生产实现在 `memory-scope.ts`);其余缺席 = 本进程实测。 */
+export interface StoreEvidenceHost {
+    readonly canonical: (p: string) => string;
+    /** 挂载表全文;`null` = 本平台没有 procfs 挂载表。缺席 = {@link readProcessMountinfo}。 */
+    readonly mountinfo?: () => Promise<string | null>;
+    /** 缺席 = {@link localDataRootHoldsData}。 */
+    readonly holdsData?: (root: string) => boolean;
+}
+/**
+ * 起服证据:挂载表读一次,三条路径各展平成物理路径、各判一次;数据根空不空读一次。读不到 / 读不懂 / 路径展不平 / 找不到看见的那一只挂载 ⇒ 那几根判 `unknown`
+ * + 登记 F 类 fail-open(只影响自报)。
+ */
+export declare function captureStoreEvidence(paths: StoreEvidencePaths, host: StoreEvidenceHost): Promise<StoreEvidence>;
+/** 装配值(纯数据;`boot/stores.ts` 铸一次,gauge / `/health` / caps / 诊断 / 布线审计同读)。 */
 export interface StorePosture {
     readonly declared: StoreBackendWord;
     readonly backend: StoreBackendWord;
     readonly degradedReason?: StoreDegradedReason;
+    /** 三根取最弱({@link weakestDurability})。 */
+    readonly durability: StoreDurability;
+    /** 逐根明细:恒以数据根开头;有起服证据时再接封签钥匙目录与(接线时的)file 记忆根。 */
+    readonly roots: readonly StoreRootDurability[];
 }
-/** `build*`(纯数据)。`assembled` = 装配出的 `StoreBackend.kind`;缺席 = 没装出后端 ⇒ `memory`。 */
+/**
+ * `build*`(纯数据)。`assembled` = 装配出的 `StoreBackend.kind`;缺席 = 没装出后端 ⇒ `memory`。`evidence` 缺席 = 这个宿主没有起服证据(测试夹具 / 桩):
+ * 只判数据根、且只按后端规则判(local 无证据即抛)。`memoryRootWired` = file 记忆引擎在本部署上真接了线(配了才算;没接线的记忆根不进最弱律)。
+ */
 export declare function buildStorePosture(a: {
     readonly declared: StoreBackendWord;
     readonly assembled: StoreBackend["kind"] | undefined;
     readonly degradedReason: StoreDegradedReason | undefined;
+    readonly evidence: StoreEvidence | undefined;
+    readonly memoryRootWired: boolean;
 }): StorePosture;
+/** 读面桩的诚实下限(没有装配值的宿主:声明 = 配置词,后端 = memory ⇒ `ephemeral`)。caps 与 `/health` 同调这一只。 */
+export declare function unwiredStorePosture(declared: StoreBackendWord): StorePosture;
+/**
+ * 起服账本一行 `store_fresh_start` 的字段(present-iff 装配出 local 后端 ∧ 第 2 段之前数据根上什么都没有)。只断言「本次起服在空店上初始化」+ 三根判定 ——
+ * **不**声称首启:首启、丢卷、挂错卷三者只看空不空分不开(分辨要店外的记录)。
+ */
+export declare function buildStoreFreshStartLine(posture: StorePosture, evidence: StoreEvidence): Readonly<Record<string, unknown>> | undefined;
 /** caps `store` 的形。 */
 export interface StoreCapability {
     readonly declared: StoreBackendWord;
     readonly backend: StoreBackendWord;
-    readonly durable: boolean;
+    readonly durability: StoreDurability;
     readonly degradedReason?: StoreDegradedReason;
     /** 7.105.0 及以前的顶层 `sql` 对象,原样搬入(`{engine, isolation, txnMode}`)。present-iff `backend ∈ {mysql, pg}` ∧ 驱动此刻给得出
      *  回读复核过的事实 —— 最近一次连接初始化被拒([ref] ④)时驱动交 `null`,本键随之缺席(此前是顶层 `sql:null`)。 */
@@ -58,4 +155,24 @@ export interface StoreCapability {
 }
 /** 装配值 → caps 投影(纯函数)。 */
 export declare function projectStoreCapability(posture: StorePosture, sqlFacts: SqlEngineFacts | null | undefined): StoreCapability;
+/** `/health.store` 的形(恒在场):与 caps `store.durability` 同一只装配值、同一拍铸。 */
+export interface HealthStoreSection {
+    readonly durability: StoreDurability;
+}
+export declare function projectHealthStoreSection(posture: StorePosture): HealthStoreSection;
+/** `GET /v1/diagnostics/wiring` 的 `storeDurability` 段(运维面):三态 + 逐根明细。 */
+export interface StoreDurabilityWiring {
+    readonly durability: StoreDurability;
+    readonly roots: readonly StoreRootDurability[];
+}
+export declare function projectStoreDurabilityWiring(posture: StorePosture): StoreDurabilityWiring;
+/** 一根的人读形(布线审计的拒句 / warn 行逐根列):`<根> <路径> (<fs 类型> <挂载源> at <挂载点>) ⇒ <三态> [<依据>]`。 */
+export declare function describeStoreRoot(r: StoreRootDurability): string;
+/** 布线审计拒启那一句的机器码(起服 fatal 标题 `[config.store_not_durable]`)。 */
+export declare const STORE_NOT_DURABLE_CODE = "config.store_not_durable";
+/** 起服布线审计因会话店落在易失介质上拒启时的抛出物:`code` = {@link STORE_NOT_DURABLE_CODE}(`boot/fatal-exit.ts` 把带码异常写成 `Error [<码>]: …` 标题)。 */
+export declare class StoreNotDurableError extends Error {
+    readonly code = "config.store_not_durable";
+}
+export {};
 //# sourceMappingURL=store-posture.d.ts.map

package/dist/store-posture.js

@@ -1,4 +1,7 @@
+import { readdirSync } from "node:fs";
 import { projectSqlEngineCapability } from "./sql-engine-posture.js";
+import { parseMountinfo, readProcessMountinfo, visibleMountOf } from "./mountinfo.js";
+import { recordFailOpen } from "./observability/fail-open.js";
 export const STORE_DEGRADED_REASONS = ["local_unwritable"];
 export function storeDegradedReasonFor(declared) {
     switch (declared) {
@@ -16,19 +19,201 @@ export function storeDegradedReasonFor(declared) {
     }
 }
 export function sessionStoreLabelOf(sessionBackend, backendKind) {
-    return sessionBackend === "tidb" && backendKind !== undefined ? `durable(${backendKind})` : sessionBackend;
+    return sessionBackend === "tidb" && backendKind !== undefined ? backendKind : sessionBackend;
+}
+export const STORE_DURABILITIES = ["durable", "ephemeral", "unknown"];
+export const STORE_ROOTS = ["data", "sealed_key", "memory"];
+export const STORE_DURABILITY_RULES = [
+    "backend_memory",
+    "backend_sql",
+    "fs_volatile",
+    "k8s_empty_dir",
+    "k8s_persistent_volume",
+    "network_fs",
+    "block_device",
+    "unrecognized_mount",
+    "mount_unresolved",
+    "mountinfo_unreadable",
+    "mountinfo_malformed",
+    "path_unresolvable",
+    "not_linux",
+];
+export function durabilityOfRule(rule) {
+    switch (rule) {
+        case "backend_sql":
+        case "k8s_persistent_volume":
+        case "network_fs":
+        case "block_device":
+            return "durable";
+        case "backend_memory":
+        case "fs_volatile":
+        case "k8s_empty_dir":
+            return "ephemeral";
+        case "unrecognized_mount":
+        case "mount_unresolved":
+        case "mountinfo_unreadable":
+        case "mountinfo_malformed":
+        case "path_unresolvable":
+        case "not_linux":
+            return "unknown";
+        default: {
+            const unhandled = rule;
+            throw new Error(`store posture: no ruling for durability rule ${String(unhandled)}`);
+        }
+    }
+}
+const VOLATILE_FS_TYPES = new Set(["overlay", "tmpfs", "ramfs"]);
+const NETWORK_FS_TYPES = new Set(["cifs", "smb3", "ceph", "glusterfs", "fuse.glusterfs", "9p"]);
+export const STORE_MOUNT_RULES = [
+    { rule: "fs_volatile", holds: (m) => VOLATILE_FS_TYPES.has(m.fsType) },
+    { rule: "k8s_empty_dir", holds: (m) => m.root.includes("kubernetes.io~empty-dir") },
+    { rule: "k8s_persistent_volume", holds: (m) => m.root.includes("kubernetes.io~csi") || m.root.includes("kubernetes.io~local-volume") },
+    { rule: "network_fs", holds: (m) => (m.fsType.startsWith("nfs") || NETWORK_FS_TYPES.has(m.fsType)) && !(m.fsType === "9p" && m.mountPoint === "/") },
+    { rule: "block_device", holds: (m) => m.source.startsWith("/dev/") && m.root === "/" },
+];
+export function classifyStoreMount(m) {
+    return STORE_MOUNT_RULES.find((r) => r.holds(m))?.rule ?? "unrecognized_mount";
+}
+const readingWithoutMount = (path, rule) => ({ path, mountPoint: null, mountSource: null, fsType: null, rule, verdict: durabilityOfRule(rule) });
+export function judgeStoreRootPath(physicalPath, reading) {
+    switch (reading.kind) {
+        case "not_linux":
+            return readingWithoutMount(physicalPath, "not_linux");
+        case "unreadable":
+            return readingWithoutMount(physicalPath, "mountinfo_unreadable");
+        case "read": {
+            if (reading.table.malformed > 0)
+                return readingWithoutMount(physicalPath, "mountinfo_malformed");
+            const visible = visibleMountOf(reading.table.rows, physicalPath);
+            if (typeof visible !== "object")
+                return readingWithoutMount(physicalPath, "mount_unresolved");
+            const rule = classifyStoreMount(visible);
+            return { path: physicalPath, mountPoint: visible.mountPoint, mountSource: visible.source, fsType: visible.fsType, rule, verdict: durabilityOfRule(rule) };
+        }
+        default: {
+            const unhandled = reading;
+            throw new Error(`store posture: unknown mount table reading ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+const DURABILITY_RANK = { ephemeral: 0, unknown: 1, durable: 2 };
+export function weakestDurability(verdicts) {
+    return verdicts.reduce((w, v) => (w === undefined || DURABILITY_RANK[v] < DURABILITY_RANK[w] ? v : w), undefined) ?? "unknown";
+}
+export function localDataRootHoldsData(root) {
+    try {
+        return readdirSync(root).length > 0;
+    }
+    catch (e) {
+        const code = e.code;
+        return code !== "ENOENT" && code !== "ENOTDIR";
+    }
+}
+const EVIDENCE_TAG = "server.store-durability.evidence-unreadable";
+const errnoOf = (e) => (e instanceof Error && "code" in e && typeof e.code === "string" ? e.code : e instanceof Error ? e.name : "unknown");
+export async function captureStoreEvidence(paths, host) {
+    let reading;
+    try {
+        const text = await (host.mountinfo ?? readProcessMountinfo)();
+        reading = text === null ? { kind: "not_linux" } : { kind: "read", table: parseMountinfo(text) };
+    }
+    catch (err) {
+        recordFailOpen(EVIDENCE_TAG, `why=mountinfo_unreadable err=${errnoOf(err)}`);
+        reading = { kind: "unreadable" };
+    }
+    if (reading.kind === "read" && reading.table.malformed > 0)
+        recordFailOpen(EVIDENCE_TAG, `why=mountinfo_malformed lines=${reading.table.malformed}`);
+    const judge = (p) => {
+        let physical;
+        try {
+            physical = host.canonical(p);
+        }
+        catch (err) {
+            recordFailOpen(EVIDENCE_TAG, `why=path_unresolvable err=${errnoOf(err)} path=${p}`);
+            return readingWithoutMount(p, "path_unresolvable");
+        }
+        const judged = judgeStoreRootPath(physical, reading);
+        if (judged.rule === "mount_unresolved")
+            recordFailOpen(EVIDENCE_TAG, `why=mount_unresolved path=${physical}`);
+        return judged;
+    };
+    return {
+        dataRootHeldData: (host.holdsData ?? localDataRootHoldsData)(paths.dataRoot),
+        dataRoot: judge(paths.dataRoot),
+        sealedKey: judge(paths.sealedKeyDir),
+        ...(paths.memoryRoot !== undefined ? { memory: judge(paths.memoryRoot) } : {}),
+    };
+}
+function dataRootReadingOf(backend, evidence) {
+    switch (backend) {
+        case "memory":
+            return readingWithoutMount(null, "backend_memory");
+        case "mysql":
+        case "pg":
+            return readingWithoutMount(null, "backend_sql");
+        case "local":
+            if (evidence === undefined)
+                throw new Error("store posture: a local backend was assembled without boot evidence of its data root's mount — wiring defect (stage 2 captures it before the key directory is written)");
+            return evidence.dataRoot;
+        default: {
+            const unhandled = backend;
+            throw new Error(`store posture: unknown backend kind ${String(unhandled)}`);
+        }
+    }
 }
 export function buildStorePosture(a) {
-    return { declared: a.declared, backend: a.assembled ?? "memory", ...(a.degradedReason !== undefined ? { degradedReason: a.degradedReason } : {}) };
+    const backend = a.assembled ?? "memory";
+    const ev = a.evidence;
+    const memory = a.memoryRootWired ? ev?.memory : undefined;
+    const roots = [
+        { root: "data", ...dataRootReadingOf(backend, ev) },
+        ...(ev !== undefined ? [{ root: "sealed_key", ...ev.sealedKey }] : []),
+        ...(memory !== undefined ? [{ root: "memory", ...memory }] : []),
+    ];
+    return {
+        declared: a.declared,
+        backend,
+        ...(a.degradedReason !== undefined ? { degradedReason: a.degradedReason } : {}),
+        durability: weakestDurability(roots.map((r) => r.verdict)),
+        roots,
+    };
+}
+export function unwiredStorePosture(declared) {
+    return buildStorePosture({ declared, assembled: undefined, degradedReason: undefined, evidence: undefined, memoryRootWired: false });
+}
+export function buildStoreFreshStartLine(posture, evidence) {
+    if (posture.backend !== "local" || evidence.dataRootHeldData)
+        return undefined;
+    return {
+        dataRoot: evidence.dataRoot.path,
+        durability: posture.durability,
+        roots: posture.roots.map((r) => ({ root: r.root, verdict: r.verdict, rule: r.rule })),
+        note: "this boot initialized an empty local store (the data root held nothing before startup wrote to it); a first start, a lost volume and a wrong mount all look like this — if this deployment had data before, check the volume mounted at the data root",
+    };
 }
 export function projectStoreCapability(posture, sqlFacts) {
     const sql = posture.backend === "mysql" || posture.backend === "pg" ? projectSqlEngineCapability(sqlFacts) : null;
     return {
         declared: posture.declared,
         backend: posture.backend,
-        durable: posture.backend !== "memory",
+        durability: posture.durability,
         ...(posture.degradedReason !== undefined ? { degradedReason: posture.degradedReason } : {}),
         ...(sql !== null ? { sql } : {}),
     };
 }
+export function projectHealthStoreSection(posture) {
+    return { durability: posture.durability };
+}
+export function projectStoreDurabilityWiring(posture) {
+    return { durability: posture.durability, roots: posture.roots };
+}
+export function describeStoreRoot(r) {
+    const where = r.path ?? (r.rule === "backend_sql" ? "(rows held by the database)" : "(no store backend)");
+    const mount = r.fsType !== null ? ` (${r.fsType} ${r.mountSource ?? "?"} at ${r.mountPoint ?? "?"})` : "";
+    return `${r.root} ${where}${mount} ⇒ ${r.verdict} [${r.rule}]`;
+}
+export const STORE_NOT_DURABLE_CODE = "config.store_not_durable";
+export class StoreNotDurableError extends Error {
+    code = STORE_NOT_DURABLE_CODE;
+}
 //# sourceMappingURL=store-posture.js.map

package/dist/stored-request-hooks-m20.d.ts

@@ -9,10 +9,11 @@ export type StoredHooksRereadM20 = (raw: unknown) => StoredHooksRereadM20Result
 /** 读者(= `parseHooksConfig`);作形参只为让「读者交回什么拒因」可被替身喂(默认值就是生产读者)。 */
 export type HooksReader = (raw: unknown) => ParseHooksConfigResult;
 /**
- * 重读一份存体 hooks:读者拒因全部属于两形 ⇒ 剥掉被点名的块里按类型确属未知的键、再问读者,**剥到读者受理为止**,过了就交回产物 + 被剥坐标;否则 `undefined`(原臂:整份不采纳)。
+ * 重读一份存体 hooks:读者拒因全部属于两形 ⇒ 剥掉被点名的块里该剥的键(全部未知键 + 被点名的不透明列)、再问读者,**剥到读者受理为止**,过了就交回产物 + 被剥坐标;否则 `undefined`(原臂:整份不采纳)。
  * 调用方只在读者**已经拒过**这份原值之后才来问;读者一开始就受理的值不进这里(进来也返回 `undefined`:没有可迁移的东西)。
  *
- * 终止:循环体以一次读开头(最后一次剥键之后必有一次读);继续下一轮的条件是本轮真从文档里剥掉了至少一个对象键,文档只减不增 ⇒ 必停;同一块只会被点名一次 ⇒ 轮数 ≤ 被点名的块数 + `__proto__` 键数。
+ * 终止:循环体以一次读开头(最后一次剥键之后必有一次读);继续下一轮的条件是本轮真从文档里剥掉了至少一个对象键,文档只减不增 ⇒ 必停;
+ * 同一块至多被点名 1 + 它的不透明列数次 ⇒ 轮数 ≤ Σ 被点名的块(1 + 不透明列数)+ `__proto__` 键数。
  */
 export declare function rereadStoredHooksM20(raw: unknown, read?: HooksReader): StoredHooksRereadM20Result | undefined;
 /**