@sema-agent/server 7.147.0 → 7.149.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-admission.d.ts

@@ -0,0 +1,33 @@
+/**
+ * **店的持久性准入**(起服第 2 段;只读,拒 = 抛 {@link StoreNotDurableError},机器码 `config.store_not_durable`)—— 店的拒启判都在这一只函数里,判两根:
+ *
+ * ## 规则(一句)
+ * 引擎被告知「活过一次替换」的东西,它落的那只根就必须活过替换:
+ *  · **数据根**(local 后端:会话店 + 检查点店落在它上面)—— local 店的声明 `durable`(`localStoreDeclarationOf`)∧ 数据根介质判 `ephemeral` ⇒ 拒;
+ *  · **显式的封签钥匙目录**(`SEALED_KEY_DIR`,数据根之外单设的那一只)—— 停驻审批在场(`DURABLE_APPROVAL`)∧ 检查点店声明 `durable`(SQL 后端恒是;local 后端随它的声明)
+ *    ∧ 钥匙目录介质判 `ephemeral` ⇒ 拒:停驻任务的请求凭据封在那只目录里的钥匙上,钥匙随下一次替换而去,之前停驻的每一条续跑都答 `key_not_held` —— 行活着、钥匙没了。
+ *    缺省的钥匙目录(`<数据根>/sealed-key`)跟数据根同判:local 后端由数据根那一臂判;SQL 后端的缺省目录只进读数与起服 warn(无卷的无状态副本是 SQL 部署的常形,
+ *    没写 `SEALED_KEY_DIR` 的部署没有对钥匙目录作过承诺 —— 与「声明了的目录建不了店 ⇒ 拒,缺省 ⇒ warn」同一条律)。
+ * file 记忆根不进判据(只进读数):记忆丢了是召回变差,不让任何一笔已承诺的停驻悬空;单卷部署(只给数据根挂卷)也不因它被拒。
+ * 判不出的介质(`unknown`:非 Linux、读不懂的挂载)不拒 —— 缺证据不放宽声明,也不凭空拒。
+ *
+ * ⚠️ 位置即契约:起服第 2 段**车道合成之后**(数据根那一臂读车道:`callerOwnsWorkerDisk`)、**本进程的第一笔写之前** —— 配置根的一次性迁移(配置根缺省就是数据根)、
+ * 配置根供给(`SEMA_CONFIG_DIR`)、保管店铸钥匙与第 3 段开店都在它之后:拒的时候数据根 / 配置根 / 钥匙目录上没有本服务写下的任何东西。介质 = 第 2 段段首的取证
+ * (`captureBootStoreEvidence`)那一份,不重读挂载表。放行时交回 local 店的那一份声明(非 local 后端 ⇒ `undefined`);第 3 段开店按同一组输入经 `localStoreDeclarationOf` 交给两半店。
+ * 第 9 段布线审计的同码一臂是「引擎读到的会话店声明 × 数据根介质」的通用对表(也管没有后端的 env-only 形);local 部署走到那里时,同一组输入已在这里判过、判得一样。
+ * run-local 没有起服取证(介质 unknown ⇒ 不拒),不调。
+ */
+import type { StoreBackend as StoreBackendWord } from "@sema-agent/settings-schema/execution-lanes";
+import { type LocalStoreDeclaration, type LocalStoreDeclarationDeployment } from "./local-store-declaration.js";
+import { type StoreEvidence } from "./store-posture.js";
+/** 准入读的部署事实(`ServiceConfig` 结构上满足):local 店声明的那几键 + 后端词 + 停驻审批在场 + 显式钥匙目录。 */
+export type StoreAdmissionDeployment = LocalStoreDeclarationDeployment & {
+    readonly dbBackend: StoreBackendWord;
+    readonly durableApproval: boolean;
+    readonly sealedKeyDir?: string;
+};
+/**
+ * 🔴 店的持久性准入(规则与位置见文件头)。两臂各判、一次说完:任一臂不过 ⇒ 抛一只 {@link StoreNotDurableError},拒句逐条列出不过的那几臂与各自的出路。
+ */
+export declare function admitStoreDurability(deployment: StoreAdmissionDeployment, evidence: Pick<StoreEvidence, "dataRoot" | "sealedKey">): LocalStoreDeclaration | undefined;
+//# sourceMappingURL=store-admission.d.ts.map

package/dist/store-admission.js

@@ -0,0 +1,49 @@
+import { describeLocalStoreDeclaration, localStoreDeclarationOf } from "./local-store-declaration.js";
+import { STORE_NOT_DURABLE_CODE, StoreNotDurableError, describeStoreRoot } from "./store-posture.js";
+function checkpointDeclarationOf(backend, local) {
+    switch (backend) {
+        case "mysql":
+        case "pg":
+            return "durable";
+        case "local":
+            if (local === undefined)
+                throw new Error("store admission: a local backend without its declaration — wiring defect");
+            return local.durability === "durable" ? "durable" : "process-local";
+        case "memory":
+            return "none";
+        default: {
+            const unhandled = backend;
+            throw new Error(`store admission: unknown DB_BACKEND word ${String(unhandled)}`);
+        }
+    }
+}
+function keyRootWaysOut(backend, path) {
+    const volume = `mount a persistent volume at ${path} (every replica must see the same directory)`;
+    const noParks = "or turn parked approvals off (DURABLE_APPROVAL=false — a task that needs an approval then waits on a live connection only)";
+    return backend === "local"
+        ? `Three ways out: ${volume}; or declare the local store ephemeral (LOCAL_STORE_DURABILITY=ephemeral — sessions and parked approvals then do not survive a replacement); ${noParks}.`
+        : `Two ways out: ${volume}; ${noParks}.`;
+}
+export function admitStoreDurability(deployment, evidence) {
+    const local = deployment.dbBackend === "local" ? localStoreDeclarationOf(deployment, evidence.dataRoot.verdict) : undefined;
+    const findings = [];
+    if (local !== undefined && local.durability === "durable" && evidence.dataRoot.verdict === "ephemeral") {
+        const dataRoot = evidence.dataRoot;
+        findings.push(`${STORE_NOT_DURABLE_CODE}: the local store declares itself durable (${describeLocalStoreDeclaration(local)}) while its data root does not survive a container / Pod replacement ` +
+            `(${describeStoreRoot({ root: "data", ...dataRoot })}). A durable declaration on an ephemeral medium is a claim nothing can honor — sessions and parked approvals would vanish with the next replacement while the engine was told they survive. ` +
+            `Three ways out: mount a persistent volume at ${dataRoot.path ?? "the data root"} (or point LOCAL_DATA_ROOT at one); or declare the local store ephemeral ` +
+            `(LOCAL_STORE_DURABILITY=ephemeral — sessions, parked approvals and memory then do not survive a container / Pod replacement); or keep nothing on disk (DB_BACKEND=memory).`);
+    }
+    const parks = checkpointDeclarationOf(deployment.dbBackend, local);
+    if (deployment.sealedKeyDir !== undefined && deployment.durableApproval && parks === "durable" && evidence.sealedKey.verdict === "ephemeral") {
+        const keyRoot = evidence.sealedKey;
+        findings.push(`${STORE_NOT_DURABLE_CODE}: parked approvals are declared durable (${deployment.dbBackend === "local" ? "the local checkpoint store's declaration" : "the checkpoint store is the SQL database"}, DURABLE_APPROVAL on) ` +
+            `while the declared sealing-key directory SEALED_KEY_DIR does not survive a container / Pod replacement (${describeStoreRoot({ root: "sealed_key", ...keyRoot })}). ` +
+            "A parked task's request credentials are sealed to a key kept in that directory — after the next replacement the parked rows are still there and the key is not: every task parked before it answers key_not_held on resume. " +
+            keyRootWaysOut(deployment.dbBackend, keyRoot.path ?? deployment.sealedKeyDir));
+    }
+    if (findings.length === 0)
+        return local;
+    throw new StoreNotDurableError(`store durability admission failed — refusing to start before any store or sealed key is written:\n${findings.map((f) => `  · ${f}`).join("\n")}`);
+}
+//# sourceMappingURL=store-admission.js.map

package/dist/store-posture.d.ts

@@ -1,22 +1,10 @@
-/**
- * [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";
+import type { LocalStoreDeclaration } from "./local-store-declaration.js";
 /**
  * 降级词闭集(**按后端族**,不按失败发生在哪一步):
  *  · `local_unwritable` —— **缺省推导**的 local 文件店在**空 / 不存在**的数据根上构造期失败(mkdir / 权限 / 只读挂载 / 磁盘满)。
@@ -30,28 +18,141 @@ 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[];
+    /** local 店交给两半店的声明(present-iff 装配出 local 后端;值 = 后端构造时 `localStoreDeclarationOf` 的那一份,装配方从后端读回,不重算)。 */
+    readonly localDeclaration?: LocalStoreDeclaration;
 }
-/** `build*`(纯数据)。`assembled` = 装配出的 `StoreBackend.kind`;缺席 = 没装出后端 ⇒ `memory`。 */
+/**
+ * `build*`(纯数据)。`assembled` = 装配出的 `StoreBackend.kind`;缺席 = 没装出后端 ⇒ `memory`。`evidence` 缺席 = 这个宿主没有起服证据(测试夹具 / 桩):
+ * 只判数据根、且只按后端规则判(local 无证据即抛)。`memoryRootWired` = file 记忆引擎在本部署上真接了线(配了才算;没接线的记忆根不进最弱律)。
+ * `localDeclaration` = 装配出的 local 后端交给两半店的那一份声明(装配出 local 而缺席 = 装配缺陷,响亮抛;别的后端递了也不收)。
+ */
 export declare function buildStorePosture(a: {
     readonly declared: StoreBackendWord;
     readonly assembled: StoreBackend["kind"] | undefined;
     readonly degradedReason: StoreDegradedReason | undefined;
+    readonly evidence: StoreEvidence | undefined;
+    readonly memoryRootWired: boolean;
+    readonly localDeclaration: LocalStoreDeclaration | undefined;
 }): 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`)。 */
@@ -59,4 +160,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