@sema-agent/server 7.148.0 → 7.150.0

package/dist/server-secret-env.d.ts

@@ -13,7 +13,7 @@
  * 剥掉的键经一个登记过的 `SecretEnvScrubSite` 留痕(现场按**腿**命名);git 腿再叠 git 自己的两件({@link gitSubprocessEnv})。射程 = **每一条**宿主腿:
  * src 里每一只值引 `node:child_process` 的文件都是登记腿、其中每一次起子进程都显式交组合出的 env(普查门在 `test/secret-env-scrub-host-legs.test.ts`)。
  * 腿的继承词是调用点的事实,按「子进程里跑的是谁选的代码」定:模型命令(host shell,交任务自己的词)/ 仓里的钩子与凭据助手(三条 git 腿)/ 执行仓代码的
- * 语言服务器 / 配方脚本 ⇒ 形状剥 `"scrub"`;请求带来的 settings hooks 命令 ⇒ 严格名单(十二名基础名单,`[names]` 臂;请求的继承词只给工具 shell、对 hook 不作用)、请求的有效环境层作授予叠在继承结果之上(引擎的 `hostChildEnv`);部署方装在宿主上的 CLI(`docker` / `adb`,命令本身
+ * 语言服务器 / 配方脚本 ⇒ 形状剥 `"scrub"`;请求带来的 settings hooks 命令 ⇒ 严格名单(十二名基础名单,`[names]` 臂;请求的继承词只给工具 shell、对 hook 不作用)∪ 部署方 `HOOK_ENV_ALLOW` 点名放回、请求的有效环境层作授予叠在继承结果之上(引擎的 `hostChildEnv`);部署方装在宿主上的 CLI(`docker` / `adb`,命令本身
  * 在容器 / 设备里跑、那边的 env 由 `-e` 显式给)⇒ `"all"` —— 只扣本服务自有凭据,CLI 与它的凭据助手 / 插件要读的生态变量照交(形状剥会剥
  * `ADB_VENDOR_KEYS` / `AWS_SECRET_ACCESS_KEY` 一类,实测)。三个继承词只在引擎一处判:
  *  · `"all"` = 整份环境 **减** 本进程声明的自有凭据名;`"scrub"`(缺省)= 形状剥 ∪ 该名单;`[names]` = 严格白名单,点到名单中的名 ⇒ 引擎响亮拒
@@ -29,24 +29,27 @@
  *    `loadConfig()` 的**声明前提**({@link ownCredentialDeclarationRefusal}:起服表的名没全扣 ⇒ `loadConfig` 抛,拒句点名 {@link declareServerWithheldEnv} —— 「先声明」不再只是入口里的位置契约,
  *    不经入口直接调 `loadConfig` 的进程〔包根嵌入方 / bench / 探针脚本〕得先声明,声明对它们才不是空的)与能力词 `inherit_env.own_credentials_withheld` 在本进程的事实
  *    {@link ownCredentialsWithheld}(当前生效配置应声明的名全被扣;活配置经 {@link bindOwnCredentialsConfig} 在 `loadConfig()` 之后绑一次;未绑 / 没扣 ⇒ false)。
- *  · **值臂**(core 7.52.0 [ref]):声明是一张表 `{ names, values }`。`values` = 本进程持有凭据的变量此刻的值(目录 secret 名 ∪ 模型条目 `apiKeyEnv`,{@link serverCredentialValueSources}),
- *    逐个交给引擎的同一只判;引擎判「不是凭据值」的那一个不扣、名照扣、不拒启、点名一次。能力词 `inherit_env.own_credential_values_withheld` 的事实 = {@link ownCredentialValuesWithheld}(位真 ⇔ 值臂真扣)。
+ *  · **值臂**(core 7.52.0 [ref]):声明是一张表 `{ names, values }`。`values` = 本进程持有凭据的变量(目录 secret 名 ∪ 模型条目 `apiKeyEnv`,{@link serverCredentialValueSources})
+ *    此刻装着的**每一枚**本服务凭据 —— 颗粒按本服务读这只变量的那一只解析器定(目录行的 `credentialForm`:整值总在内,`SERVICE_AUTH_TOKENS` 另加每一枚令牌、
+ *    `APPROVAL_HMAC_KEYS` 另加每一把钥;{@link credentialsHeldBy})—— 引擎按整串比,所以一枚令牌换了个变量名放着与原变量同扣,部分重叠 / 前后缀不同的值不扣。
+ *    逐枚交给引擎的同一只判;引擎判「不是凭据值」的那一枚不扣、名照扣、不拒启、点名那个变量一次。能力词 `inherit_env.own_credential_values_withheld` 的事实 = {@link ownCredentialValuesWithheld}(位真 ⇔ 值臂每一枚都真扣)。
+ *    「这个变量是不是本服务的凭据」(名是,或值是)只有一只读法 {@link ownCredentialVariable}(判官 = 引擎此刻的声明):名单型旋钮的解析器与声明增长时的重判都问它。
  *  · 调用方显式传入的 env(`cfg.env` / 单次命令的 `env` / 沙箱的点名放回)不是继承,照旧原样叠在组合结果之上 —— 那是适配器自己的凭据通道。
  * 各腿只调 {@link hostSubprocessEnv} / {@link gitSubprocessEnv} —— 不许再有内联拼装、不许再有 `{ ...process.env }`、不许本仓再判任何一个继承词、不许起子进程不交 env
  * (类级门与普查门在 `test/secret-env-scrub-host-legs.test.ts`)。
  *
  * ## 点名放行([ref] / [ref],一只谓词各处用)
  * {@link allowlistedEnv} 是本仓「一张名单点到哪些 env 键,就把它们从源 env **原样**交给沙箱」的唯一实现。调用:沙箱带外 env 的 `E2B_SANDBOX_ENV` / `DOCKER_SANDBOX_ENV` /
- * `K8S_SANDBOX_ENV`(`config.ts`)与名单解析器的「在不在」判。宿主子进程的剥后放回(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)不经它 —— 那是引擎的严格名单臂(上一段)。
+ * `K8S_SANDBOX_ENV`(`config.ts`)与名单解析器的「在不在」判。宿主子进程的剥后放回(`LSP_ENV_ALLOW` / `HOOK_ENV_ALLOW` / `BAKE_ENV_ALLOW`)不经它 —— 那是引擎的严格名单臂(上一段)。
  * host shell 的 `inheritEnv:[names]`(hermetic 形)7.129.0 起由引擎读(与 core `NodeExecutionEnv` 同名选项同义,点到自有凭据名即拒),不经本谓词。
  * 名单型旋钮的**名单**另由 `config.ts` 的同一只解析器 `parseEnvNameAllowlist` 判形(形错 / 点名名单型旋钮 / 点名本服务自有凭据名 ⇒ 拒启;源里没有的名按序号 warn),本函数只管取值。
  * 「点名」在各处同义:点到的键原样带值(空串值照带),密钥形也照过(点名 = 部署方显式承担);源里没有的名不产生条目。
- * 剥后放回形(`LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`)的放回本身也经引擎:{@link composeHostSubprocessEnv} 把名单交引擎的严格名单臂(`inheritedHostEnv([names])`)叠在
+ * 剥后放回形(`LSP_ENV_ALLOW` / `HOOK_ENV_ALLOW` / `BAKE_ENV_ALLOW`)的放回本身也经引擎:{@link composeHostSubprocessEnv} 把名单交引擎的严格名单臂(`inheritedHostEnv([names])`)叠在
  * 继承结果之上 ⇒ 点到本服务自有凭据名 = 引擎在**组合这一刻**抛(语言服务器在构造时组合一次、之后 spawn 用那份静态记录;bake-runner 每次 spawn 组合;
  * 起服时解析器 `parseEnvNameAllowlist` 已用同一只判 `inheritEnvPolicyProblem` 拒过 —— 解析器对五只名单一律拒,点到**解析时已声明**的自有凭据名的沙箱名单因此
  * 到不了 {@link allowlistedEnv} 取值这一步;声明之后增长(中心 / config.d 模型条目的 `apiKeyEnv` 换代并进)时,换代声明对活配置里每只名单此刻交出去的名用同一只判
- * 重判一次 —— 命中 ⇒ 撤回这次增长、候选整拒,已装好的沙箱 env / 语言服务器 env 不变成本服务的凭据,`config.ts` `ownCredentialHitsInForce`),
- * 点到的变量值是本服务凭据的副本 = 引擎扣下。本仓不另判。
+ * 重判一次 —— 命中 ⇒ 撤回这次增长、候选整拒,已装好的沙箱 env / 语言服务器 env 不变成本服务的凭据,`config.ts` `ownCredentialHitsInForce`)。
+ * 解析器与重判问的是「点到的变量是不是本服务的凭据」—— 名是,**或值是**(另一个名下的副本,{@link ownCredentialVariable})—— 都拒;组合这一刻引擎照样扣下值副本(不变量)。本仓不另判、不比值。
  */
 import { type InheritEnvPolicy, type SecretEnvFinding } from "@sema-agent/core";
 import type { ServiceConfig } from "./config-types.js";
@@ -61,8 +64,9 @@ export type ModelApiKeyEnvTable = Readonly<Record<string, string>>;
  */
 export declare function serverWithheldEnvNames(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
 /**
- * 本进程**持有凭据值**的变量名(值臂的来源;core 7.52.0 [ref]):目录 secret 名 ∪ 模型条目 `apiKeyEnv` 的值 —— 名单与值臂两臂同一张表派生,只少名单型旋钮名(它们的值是
- * 一张变量名单,不是凭据)。纯函数,排序只为读数稳定。
+ * 本进程**持有凭据值**的变量名(值臂的来源;core 7.52.0 [ref]):目录 secret 名 ∪ 模型条目 `apiKeyEnv` 的值 —— 名单与值臂两臂同一张表派生,只少不在目录里的名单型旋钮名
+ * (今天 = bake-runner 进程的 `BAKE_ENV_ALLOW`);目录里的名单型旋钮行是 secret 行,原文按凭据类整值对待(行上 `credentialForm: "whole"`)。每个来源装着几枚凭据
+ * 由目录行的颗粒定({@link credentialsHeldBy})。纯函数,排序只为读数稳定。
  */
 export declare function serverCredentialValueSources(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
 /**
@@ -72,15 +76,14 @@ export declare function serverCredentialValueSources(modelApiKeyEnv?: ModelApiKe
  *  · **名臂**:此前声明过的 ∪ 这张表的 {@link serverWithheldEnvNames}。引擎对坏形名 / 运行时回填名(`PATH` / `HOME` …)响亮抛且声明保持原状 —— 本函数不接住:
  *    起服那次抛 = 拒启;换代那次抛 = 候选整拒(`applyEffective` 抛,与 stage 抛同路)。第一次交表带着名臂与**此前已收下的值**(引擎收过、env 不变 ⇒ 同值照收),
  *    所以这一次抛只可能是名的问题。
- *  · **值臂**:{@link serverCredentialValueSources} 的每一个变量此刻在 env 里的值,逐个交给引擎**同一只**判(不另写「什么算凭据值」的第二份判据):引擎收下 ⇒ 记进值臂;
- *    引擎拒(不是凭据值:空白 / 占位词 / 一个字符重复 / 不足 8 字符;或它是每个子进程都会拿到的变量的值)⇒ 这一个值不扣、名照扣、**不拒启**(与引擎自己的收值口
- *    `holdOwnCredentialValues` 同一姿势:不收 + 说一次),经留痕座结构化点名那个变量一次 —— `warn` 行 `own_credential_value_not_withheld { name, reason }`
+ *  · **值臂**:{@link serverCredentialValueSources} 的每一个变量此刻装着的每一枚凭据({@link credentialsHeldBy}:整值,列表形另加每一枚),逐枚交给引擎**同一只**判
+ *    (不另写「什么算凭据值」的第二份判据):引擎收下 ⇒ 记进值臂;
+ *    引擎拒(不是凭据值:空白 / 占位词 / 一个字符重复 / 不足 8 字符;或它是每个子进程都会拿到的变量的值)⇒ 这一枚不扣(同一变量的其余几枚照收)、名照扣、**不拒启**(与引擎自己的收值口
+ *    `holdOwnCredentialValues` 同一姿势:不收 + 说一次),经留痕座结构化点名那个变量一次(它装着几枚被拒都是一行)—— `warn` 行 `own_credential_value_not_withheld { name, reason }`
  *    ({@link recordOwnCredentialValueNotWithheld};`reason` 是引擎拒句原文,从不回显值;起服第一步还没有 logger 时当拍经进程默认的 JSON 行日志器写 stderr,不缓冲),能力位 `inherit_env.own_credential_values_withheld`
  *    因此答 false(位真 ⇔ 值臂真扣)。引擎拒一个值时声明保持上一份,所以逐个交表的中间态都是上一份的超集。
- *    🔴 **这一行是本服务唯一的写者**:值是网关密钥(`MODEL_API_KEY` / `ANTHROPIC_API_KEY`)时,进程输出里另有一行**引擎**的裸 `console.warn`(`a credential the engine was handed is …`)——
- *    它写在 `createOpenAIBrain` / `createAnthropicBrain` 的收值口,那个口没有通告席(适配器配置没有 `onNotice`;`holdOwnCredentialValues` 不在 core 根导出),core 把这一形记为已知限制。
- *    本仓不在引擎外面吞 console、也不拿声明口去抢引擎的「每进程每值说一次」账(下游不改上游座的语义);等 core 给席或让声明口的拒收记作已说。读数与翻面条件:
- *    `test/own-credential-value-boot-lines.test.ts`(真主进程;零裸行的期望以 `it.fails` 立着,core 改形那天转红再翻成常规钉)。
+ *    🔴 **这一行是唯一的一行**:值是网关密钥(`MODEL_API_KEY` / `ANTHROPIC_API_KEY`)时,引擎在适配器构造口收下同一个值,声明口拒过的值它记作已说、不再说第二遍
+ *    (core 7.62.0 起;此前那里另有一行引擎的裸 `console.warn`)。读数:`test/own-credential-value-boot-lines.test.ts`(真主进程,零裸文本行)。
  * 返回声明的名单(只名、不值)。
  */
 export declare function declareServerWithheldEnv(modelApiKeyEnv?: ModelApiKeyEnvTable): readonly string[];
@@ -113,10 +116,20 @@ export declare function ownCredentialDeclarationRefusal(): string | undefined;
  */
 export declare function ownCredentialsWithheld(): boolean;
 /**
- * 能力词 `inherit_env.own_credential_values_withheld`(core 7.52.0)在本进程的事实:当前生效配置的每一个凭据值来源({@link serverCredentialValueSources}),只要它此刻在 env 里
- * 有值,那个值都已交进值臂、被引擎收下。位真 ⇔ 值臂真扣:一个值被引擎判「扣不了」⇒ false;env 里没有值的来源没有东西可扣,不影响事实。没绑活配置 / 没声明过 ⇒ false。
+ * 能力词 `inherit_env.own_credential_values_withheld`(core 7.52.0)在本进程的事实:当前生效配置的每一个凭据值来源({@link serverCredentialValueSources})此刻装着的
+ * **每一枚**凭据({@link credentialsHeldBy})都已交进值臂、被引擎收下。位真 ⇔ 值臂真扣:有一枚被引擎判「扣不了」⇒ false;env 里没有值的来源没有东西可扣,不影响事实。
+ * 没绑活配置 / 没声明过 ⇒ false。
  */
 export declare function ownCredentialValuesWithheld(): boolean;
+/** {@link ownCredentialVariable} 的答案:这个变量是本服务的凭据,因为它的**名**是声明过的自有凭据名,还是它此刻的**值**是本服务的某一枚凭据(另一个名下的副本)。 */
+export type OwnCredentialHold = "name" | "value";
+/**
+ * 「本进程环境里这个变量是不是本服务的自有凭据」的**唯一读法**(判官 = 引擎此刻的声明;本仓不比值、不持值):名是声明过的自有凭据名 ⇒ `"name"`;
+ * 名不是,而它此刻的值等于引擎扣着的某一枚凭据(值臂按颗粒逐枚声明的,或引擎自己收下的)⇒ `"value"`;都不是 / 变量不在本进程环境里 ⇒ `undefined`。
+ * 值的那一半读引擎严格名单臂对这一名的扣留(`inheritedHostEnv([name])` 的 `own-credential` 发现 —— 严格名单不做形状剥,那里扣下的只有自有凭据一类)。
+ * 调用方先判过名形(引擎对坏形名同样答「有问题」,会被读成 `"name"`)。读者:名单型旋钮的解析器 ② 与声明增长时的重判(`config.ts` `ownCredentialHitsInForce`)。
+ */
+export declare function ownCredentialVariable(name: string): OwnCredentialHold | undefined;
 /** 测试缝:撤回声明(引擎侧重声明为空表)、忘掉两份声明镜像、点名记账与活配置;生产代码从不调它。 */
 export declare function __resetServerWithheldEnvForTest(): void;
 /** 一条宿主腿要什么:现场(留痕)、继承策略(缺省 `"scrub"`;按头注「腿的继承词」一条由调用点定)、部署方点名放回的键、调用方显式交的授予(按序叠在继承之上,后者赢)。 */
@@ -133,8 +146,9 @@ export interface HostSubprocessEnvRequest {
  * 不是剥除,不计数、不披露。源 env 恒为本进程 env(引擎只读 `process.env`,本仓没有第二个源)。
  *
  * 九条宿主腿都只经它(直接或经 {@link gitSubprocessEnv}):host shell(三个继承词原样交给 `policy`)、project-memory / center-plugins / leader 三条 git 腿、
- * 本地语言服务器、bake-runner 的每一只子进程组、local-docker 与 adb 两条 CLI 腿(`"all"`)、settings hooks 的命令腿(十二名严格名单 + 有效环境层作授予)。`allow` 只在**有部署级出路**的现场非空(今天 = `LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`,
- * 它们的现场在 `SECRET_ENV_SCRUB_SITES` 里登记了 `remedy`,披露行因此是 warn + 放行名单 + 出路句);其余现场传 `[]`。
+ * 本地语言服务器、bake-runner 的每一只子进程组、local-docker 与 adb 两条 CLI 腿(`"all"`)、settings hooks 的命令腿(十二名严格名单 ∪ `HOOK_ENV_ALLOW` 放回 + 有效环境层作授予)。`allow` 只在**有部署级出路**的现场非空(今天 = `LSP_ENV_ALLOW` / `BAKE_ENV_ALLOW`,
+ * 它们的现场在 `SECRET_ENV_SCRUB_SITES` 里登记了 `remedy`,披露行因此是 warn + 放行名单 + 出路句;settings hooks 的 `HOOK_ENV_ALLOW` 也走这只槽,但那条腿是严格名单,
+ * finding 只有自有凭据的扣留、任何名单都放不回,现场登记 `remedy: null`,理由在登记处);其余现场传 `[]`。
  * 「扣了哪些名字」一腿一个读者:host shell 腿由引擎读 `withheldEnv` 说(`inherit_env.names_withheld`,现场登记 `told:"engine-notice"` ⇒ 本函数对它只计数、不写披露行);
  * 其余各条腿(含 host 适配器类里不交给引擎的 git worktree 基环境,`HostEnvConfig.gitBase`)引擎没有读者,披露行是唯一的读法(`told:"log"`)。
  * 返回 `NodeJS.ProcessEnv` 形(值可能是 `undefined` 的键本来就不会进子进程);调用方显式要交的键(`LC_ALL`、`cfg.env` …)叠在它之上。

package/dist/server-secret-env.js

@@ -1,5 +1,6 @@
 import { declareWithheldEnv, hostChildEnv, inheritEnvPolicyProblem, inheritedHostEnv } from "@sema-agent/core";
 import { CONFIG_CATALOG } from "./config-catalog.js";
+import { parseApprovalHmacKeys, parseServiceAuthTokens } from "./auth-keys.js";
 import { ENV_NAME_ALLOWLIST_KNOB_NAMES } from "./env-name-allowlist-knobs.js";
 import { recordOwnCredentialValueNotWithheld, recordSecretEnvScrub } from "./observability/secret-env-scrub.js";
 export const CATALOG_SECRET_ENV_NAMES = new Set(CONFIG_CATALOG.filter((spec) => spec.type === "secret").map((spec) => spec.name));
@@ -10,37 +11,72 @@ export function serverWithheldEnvNames(modelApiKeyEnv = NO_MODEL_ENTRIES) {
 export function serverCredentialValueSources(modelApiKeyEnv = NO_MODEL_ENTRIES) {
     return [...new Set([...CATALOG_SECRET_ENV_NAMES, ...Object.values(modelApiKeyEnv)])].sort();
 }
+const CREDENTIAL_FORM_OF = new Map(CONFIG_CATALOG.flatMap((spec) => (spec.credentialForm === undefined ? [] : [[spec.name, spec.credentialForm]])));
+const DROPPED_KEYS_TOLD_BY_LOAD_CONFIG = () => { };
+function credentialsIn(form, raw) {
+    switch (form) {
+        case "whole":
+            return [raw];
+        case "token-table":
+            return [raw, ...Object.keys(parseServiceAuthTokens(raw))];
+        case "key-set":
+            return [raw, ...parseApprovalHmacKeys(raw, DROPPED_KEYS_TOLD_BY_LOAD_CONFIG).map((k) => k.key)];
+        default: {
+            const unreachable = form;
+            throw new Error(`unhandled secret credential form: ${String(unreachable)}`);
+        }
+    }
+}
 let declared;
 let beforeLast;
 const valueRefusalAnnounced = new Set();
 let liveConfig;
 const envValueOf = (name) => process.env[name];
-const valuesOf = (sources) => [...sources].map(envValueOf).filter((v) => typeof v === "string" && v !== "");
+function credentialsHeldBy(source) {
+    const raw = envValueOf(source);
+    if (raw === undefined || raw === "")
+        return [];
+    return [...new Set(credentialsIn(CREDENTIAL_FORM_OF.get(source) ?? "whole", raw))].filter((v) => v !== "");
+}
+function heldValues(held) {
+    return [...held].flatMap(([source, at]) => {
+        const all = credentialsHeldBy(source);
+        return [...at].flatMap((i) => {
+            const value = all[i];
+            return value === undefined ? [] : [value];
+        });
+    });
+}
 export function declareServerWithheldEnv(modelApiKeyEnv = NO_MODEL_ENTRIES) {
     const names = [...new Set([...(declared?.names ?? []), ...serverWithheldEnvNames(modelApiKeyEnv)])].sort();
-    const kept = [...(declared?.valueSources ?? [])];
-    declareWithheldEnv({ names, values: valuesOf(kept) });
-    const valueSources = new Set(kept);
+    const held = new Map(declared?.held ?? []);
+    declareWithheldEnv({ names, values: heldValues(held) });
     for (const source of serverCredentialValueSources(modelApiKeyEnv)) {
-        if (valueSources.has(source) || valuesOf([source]).length === 0)
-            continue;
-        try {
-            declareWithheldEnv({ names, values: valuesOf([...valueSources, source]) });
-            valueSources.add(source);
-        }
-        catch (e) {
-            if (!valueRefusalAnnounced.has(source)) {
-                valueRefusalAnnounced.add(source);
-                recordOwnCredentialValueNotWithheld({ name: source, reason: e instanceof Error ? e.message : String(e) });
+        const at = new Set(held.get(source) ?? []);
+        let refusal;
+        credentialsHeldBy(source).forEach((_, i) => {
+            if (at.has(i))
+                return;
+            try {
+                declareWithheldEnv({ names, values: heldValues(new Map(held).set(source, new Set([...at, i]))) });
+                at.add(i);
+                held.set(source, new Set(at));
+            }
+            catch (e) {
+                refusal ??= e instanceof Error ? e.message : String(e);
             }
+        });
+        if (refusal !== undefined && !valueRefusalAnnounced.has(source)) {
+            valueRefusalAnnounced.add(source);
+            recordOwnCredentialValueNotWithheld({ name: source, reason: refusal });
         }
     }
     beforeLast = declared;
-    declared = { names: new Set(names), valueSources };
+    declared = { names: new Set(names), held };
     return names;
 }
 export function withdrawServerWithheldEnv() {
-    declareWithheldEnv({ names: [...(beforeLast?.names ?? [])], values: valuesOf(beforeLast?.valueSources ?? []) });
+    declareWithheldEnv({ names: [...(beforeLast?.names ?? [])], values: heldValues(beforeLast?.held ?? new Map()) });
     declared = beforeLast;
 }
 export function bindOwnCredentialsConfig(config) {
@@ -65,8 +101,15 @@ export function ownCredentialsWithheld() {
 export function ownCredentialValuesWithheld() {
     if (declared === undefined || liveConfig === undefined)
         return false;
-    const own = declared.valueSources;
-    return serverCredentialValueSources(liveConfig.modelApiKeyEnv).every((source) => own.has(source) || valuesOf([source]).length === 0);
+    const held = declared.held;
+    return serverCredentialValueSources(liveConfig.modelApiKeyEnv).every((source) => (held.get(source)?.size ?? 0) === credentialsHeldBy(source).length);
+}
+export function ownCredentialVariable(name) {
+    if (inheritEnvPolicyProblem([name]) !== undefined)
+        return "name";
+    const findings = [];
+    inheritedHostEnv([name], findings);
+    return findings.some((f) => f.kind === "own-credential") ? "value" : undefined;
 }
 export function __resetServerWithheldEnvForTest() {
     declareWithheldEnv({ names: [], values: [] });

package/dist/session-agent.d.ts

@@ -5,7 +5,7 @@
  * 店原样记下,首写不可变。三只持久会话店都存:SQL 两孪生在 `session_meta` 的 `placement_*` 列(`plugins/session-placement.ts` 的 `placementFromRow`),
  * local 后端(7.141.0 起)在会话存档行头(core 文件 repo)。读口是店的 `placementOf`(一行 PK 探针;店不交它 = 不存元组)。
  *
- * 读者(同一只读口 {@link readSessionAgent}、同一只投影 {@link sessionAgentOf},逐值同答):
+ * 读者(同一只读口 —— 属主存取器的 `readSessionAgent`(`http/owner-access.ts`:店的行读只在存取器里)—— 同一只投影 {@link sessionAgentOf},逐值同答):
  *  · 会话视图 `GET /v1/sessions/:id` 体顶层的 `agent`(视图读才付探针;探针抛 ⇒ 视图读响亮失败,`boot/session-faces.ts`);
  *  · 运维审批队列 `GET /v1/approvals` 的停驻行(`pending[]` 的 `checkpoint` 族)与 `/v1/approvals/stream` 的 `pending` 帧:行的身份就是它那只会话
  *    (决断口 `/v1/approvals/:sessionId/decide`),行上的 `agent` = 同一只会话在视图上的 `agent`;一行读不出 ⇒ 只这一行缺键、F 类兜底计数
@@ -14,8 +14,9 @@
  *
  * 投影律(不另铸):`id` = 元组的 `handle`(耐久 agent 行的 `a…` 键,与 fleet 行的 `id`、`GET /v1/agents/roster` 的 `handle` 同一个串);`parentSessionId` /
  * `rootSessionId` = 元组的同名格(派它的会话 / 委派树的根会话);元组缺哪一格这里就缺哪一格;元组的 `scope`(租户键)/ `placedAt` / `kind` 不上 wire。
- * 键在场 = 这是一只委派子代的会话(元组只存了 `kind` 时是 `{}`);键缺席 = 不是 placed 行(宿主会话、同步委派的子代、`subagent_type: "fork"` 的后台子代 ——
- * 它的会话是父会话的一只普通分叉;`DB_BACKEND=local` 到 7.140.x 停驻时拷进宿主店的子代转录,那一份是普通会话行)、这台部署的店不存元组(无 repo 的内存店
+ * 键在场 = 这是一只后台委派子代的会话(普通后台子代与 `subagent_type: "fork"` 的后台子代同样落元组 —— 引擎 7.63.0 起后台 fork 建会话那一笔也交委派元组;
+ * 元组只存了 `kind` 时是 `{}`);键缺席 = 不是 placed 行(宿主会话、同步委派的子代 —— 含同步 fork,它的会话是父会话的一只普通分叉;`DB_BACKEND=local` 到 7.140.x
+ * 停驻时拷进宿主店的子代转录,那一份是普通会话行)、这台部署的店不存元组(无 repo 的内存店
  * 〔`DB_BACKEND=memory`〕、嵌入方自建且不声明委派分区的店),或那一读没读成 —— 消费方一律读作「这台 server 没有说」,不读作「不是子代」。
  */
 import type { SessionPlacementRecord } from "@sema-agent/core";
@@ -25,15 +26,6 @@ export interface SessionAgent {
     parentSessionId?: string;
     rootSessionId?: string;
 }
-/** 交委派元组读口的会话店面(本仓三只持久会话店与缓存包装层都交;内存店不交)。 */
-export interface PlacementReadingSessionStore {
-    readonly placementOf?: (sessionId: string) => Promise<SessionPlacementRecord | undefined>;
-}
 /** {@link SessionAgent} 的唯一投影:店答出的委派元组 → `agent` 的值;`undefined`(普通会话 / 店没有这一面)⇒ 调用方不铸键。 */
 export declare function sessionAgentOf(placement: SessionPlacementRecord | undefined): SessionAgent | undefined;
-/**
- * `agent` 的**唯一读口**:店的 `placementOf` 一读 → {@link sessionAgentOf}。店不交 `placementOf` ⇒ `undefined`(这台部署不存元组,不探)。
- * 探针抛 ⇒ 原样上抛 —— 读不出怎么说归读者(视图读响亮失败;队列只缺那一行的键并计数),本函数不替任何一面把故障说成「不是子代」。
- */
-export declare function readSessionAgent(store: PlacementReadingSessionStore | undefined, sessionId: string): Promise<SessionAgent | undefined>;
 //# sourceMappingURL=session-agent.d.ts.map

package/dist/session-agent.js

@@ -7,10 +7,4 @@ export function sessionAgentOf(placement) {
         ...(placement.rootSessionId !== undefined ? { rootSessionId: placement.rootSessionId } : {}),
     };
 }
-export async function readSessionAgent(store, sessionId) {
-    const placementOf = store?.placementOf;
-    if (placementOf === undefined)
-        return undefined;
-    return sessionAgentOf(await placementOf.call(store, sessionId));
-}
 //# sourceMappingURL=session-agent.js.map

package/dist/session-children-retire.d.ts

@@ -15,7 +15,7 @@
  * ## 动词(core 板 [ref] ⑧⑨ 给定;本车第零步探针 `test/core-probe-parked-stop-root-access.test.ts` 真跑证实)
  *  · 枚举 = `agentStore.listBySession(scope, 根会话)`(耐久行,锚 = 行的 session / parent / root 任一),并上本进程登记表里的
  *    `activeDelegationHandles(scope, 根会话)`(没接耐久店的部署只有这一半)。scope 轴由调用方给(唯一派生 {@link sessionTenantScope})。
- *  · **parked** 行 ⇒ `checkpointStore.expire(token, 卡自己的 scope)`(与 core 自己的本进程仲裁器同一只 CAS)+
+ *  · **parked** 行 ⇒ 按店里该卡的属主格 `expire`(`expireCardUnderStoredScope`:属主格读店的列、不读行体;与 core 自己的本进程仲裁器同一只 CAS)+
  *    `registry.reconcileParkedAgents(stores, scope)` ⇒ 行 `failed`(stoppedBy `system`)、卡离开待决面。任何副本上都做得到 ⇒ 预检把它
  *    算作可达(前提是本部署有 checkpoint 店)。
  *    ⚠️ **不对 parked 行调 `stopTask`**:只在耐久店里的行(park 它的进程不在 / 别的副本 / 重启后 —— parked 行活过重启是常态)
@@ -40,6 +40,7 @@
  * 两轮之间留一小段退避让它落盘。
  */
 import type { BackgroundAgentStore, CheckpointStore, TaskRegistry } from "@sema-agent/core";
+import { type CardSettlePort } from "./card-settle-stored-scope.js";
 /** 重新枚举的轮数上界。 */
 export declare const RETIRE_MAX_ROUNDS = 6;
 /** 两步共用的枚举口。 */
@@ -47,14 +48,16 @@ interface ChildrenSource {
     agentStore: BackgroundAgentStore | undefined;
     registry: Pick<TaskRegistry, "activeDelegationHandles">;
 }
+/** 预检与结清共用的 checkpoint 店口:作废卡({@link CardSettlePort})+ 引擎对账读卡(`get`)—— 预检说「可达」的前提就是结清做得了这两件,所以两步同一个型。 */
+export type ChildrenCheckpointStore = Pick<CheckpointStore, "get"> & CardSettlePort;
 export interface ProbeSessionChildrenDeps extends ChildrenSource {
     /** 缺席 = 本部署没有耐久审批;撞见 parked 行却没有它 ⇒ 那只作废不了 ⇒ 不可达(拒在删之前)。 */
-    checkpointStore: Pick<CheckpointStore, "get" | "expire"> | undefined;
+    checkpointStore: ChildrenCheckpointStore | undefined;
     registry: Pick<TaskRegistry, "activeDelegationHandles" | "getAccessibleTask" | "writerId">;
 }
 export interface RetireSessionChildrenDeps extends ChildrenSource {
     /** 缺席 = 本部署没有耐久审批(不可能有 parked 行);撞见 parked 行却没有它 ⇒ 那只作废不了,留到剩余(预检本该已经拒掉它)。 */
-    checkpointStore: Pick<CheckpointStore, "get" | "expire"> | undefined;
+    checkpointStore: ChildrenCheckpointStore | undefined;
     registry: Pick<TaskRegistry, "stopTask" | "reconcileParkedAgents" | "activeDelegationHandles">;
     sleep?: (ms: number) => Promise<void>;
 }

package/dist/session-children-retire.js

@@ -1,6 +1,7 @@
 import { partsOf } from "./owner-brands.js";
 import { recoveredSubject } from "./owner-faces.js";
 import { taskSpecIdentityOf } from "./engine-identity.js";
+import { expireCardUnderStoredScope } from "./card-settle-stored-scope.js";
 export const RETIRE_MAX_ROUNDS = 6;
 const RETIRE_BACKOFF_MS = [0, 25, 50, 100, 200, 400];
 export function sessionTenantScope(owner) {
@@ -74,11 +75,7 @@ async function expireParkedCard(deps, handle, scope) {
     const row = await deps.agentStore.get(handle, scope);
     if (row === null || row.status !== "parked" || row.parkedCheckpointToken === undefined)
         return;
-    const token = row.parkedCheckpointToken;
-    const cp = await deps.checkpointStore.get(token);
-    if (cp === null || cp.status !== "pending")
-        return;
-    await deps.checkpointStore.expire(token, cp.scope);
+    await expireCardUnderStoredScope(deps.checkpointStore, row.parkedCheckpointToken);
 }
 export class SessionChildrenStopIncompleteError extends Error {
     sessionId;

package/dist/session-incarnation.d.ts

@@ -129,14 +129,28 @@ export declare function sessionFaceOfHead(sessionId: string, head: SessionHead):
 export declare function sessionFaceOfHead(sessionId: string, head: SessionHead | undefined): SessionFace | undefined;
 /**
  * 「这只会话店有没有按 id 读(`headOf`)」—— 全仓**只判这一处**:授权口、各路由的属主门、能力位、起服门、k8s 工作区空间的每 run 读与
- * 一次性迁移 M23(窗内)的回填读的都是这一只返回值。缺席 = 店没有实装 `headOf`(读不出属主 / 住客 / 叶子,调用方各按自己的 fail-closed 臂处置)。
+ * 一次性迁移 M23(窗内)的回填读的都是这一只判({@link headReadOf} 的在不在 = 它)。缺席 = 店没有实装 `headOf`(读不出属主 / 住客 / 叶子,调用方各按自己的 fail-closed 臂处置)。
+ * 收的是任意店形(路由层的封住视图也行:在不在照判,读口在型上调不了 —— 带属主的行只经属主存取器读,`http/owner-access.ts`)。
  */
-export declare function headReadOf(store: object | undefined): HeadRead | undefined;
+export declare function headReadPresent(store: {
+    readonly headOf?: unknown;
+} | undefined): boolean;
+/** 会话店的按 id 读(绑好宿主的那一只;店没有 ⇒ `undefined`)。路由层的封住视图在这里读不出读口(封住的那一格型是 `undefined`,类型墙,`route-ctx.ts` 的 `RouteDeps`)。 */
+export declare function headReadOf(store: {
+    readonly headOf?: HeadRead;
+} | undefined): HeadRead | undefined;
 /**
  * 删除门(`DELETE /v1/sessions/:id` 的属主门 + 协调器的化身围栏)的头读 —— **只判这一处**:店交了 `deletionHeadOf`(删除已开始、还没收完的那一行也答得出属主与住客;local)⇒ 它;
- * 否则 ⇒ {@link headReadOf}(删除是一个事务的店,没有删到一半的行)。缺席 = 店没有按 id 读。
+ * 否则 ⇒ {@link headReadOf}(删除是一个事务的店,没有删到一半的行)。缺席 = 店没有按 id 读。同 {@link headReadOf}:只收值上交读口的店形。
  */
-export declare function deletionHeadReadOf(store: object | undefined): HeadRead | undefined;
+export declare function deletionHeadReadOf(store: {
+    readonly deletionHeadOf?: HeadRead;
+    readonly headOf: HeadRead;
+}): HeadRead;
+export declare function deletionHeadReadOf(store: {
+    readonly deletionHeadOf?: HeadRead;
+    readonly headOf?: HeadRead;
+} | undefined): HeadRead | undefined;
 /** 换装沿用的行格(化身 + fork 键):{@link carriedRowCells} 的答案。`forkKey: null` = 没有可沿用的键(新建行 / 行上本来没有)。 */
 export interface CarriedRowCells {
     readonly incarnation: string;

package/dist/session-incarnation.js

@@ -66,9 +66,12 @@ export function leafOfAdmittedHead(head) {
 export function sessionFaceOfHead(sessionId, head) {
     return head === undefined ? undefined : sessionFaceFromRow(sessionId, head.owner, head.incarnation);
 }
+export function headReadPresent(store) {
+    return typeof store?.headOf === "function";
+}
 export function headReadOf(store) {
     const read = store?.headOf;
-    return typeof read === "function" ? read.bind(store) : undefined;
+    return headReadPresent(store) ? read.bind(store) : undefined;
 }
 export function deletionHeadReadOf(store) {
     const read = store?.deletionHeadOf;

package/dist/session-notify-door.d.ts

@@ -9,7 +9,7 @@
  *    别的抛 = 活流刚收尾的竞态 ⇒ 落空闲臂。
  *  · **空闲**:这只会话的完成收件箱(`externalNotificationInboxEntry`,external 键域;脱敏 / 限长在入箱口内)⇒ 下次开流排空成 `task_notification` 帧。
  *    部署没有收件箱 ⇒ 如实交回 `no_inbox`(调用方各自答:HTTP 门 501,引擎完成告警)。
- *  · **复核住客**:两臂的投递动作(注入 / 入箱)之前**紧邻**一次头读,与目标的住客比 —— 判官是仓里那一只 `sameOccupant`(`execution-placement.ts`:属主 ∧ 化身,
+ *  · **复核住客**:两臂的投递动作(注入 / 入箱)之前**紧邻**一次头读,与目标的住客比(读与判在属主存取器的 `occupantRecheckOf`)—— 判官是仓里那一只 `sameOccupant`(`execution-placement.ts`:属主 ∧ 化身,
  *    写口与执行上下文解析器判的也是它):不在 ⇒ `withdrawn: gone`;两样里任一样变了 ⇒ `withdrawn: replaced`。会话店不铸化身(嵌入方自建的店)时两侧都没有令牌,
  *    判官只剩属主那一半:属主没变 ⇒ 投,变了 ⇒ 撤回。这一读是动作之前的最后一次让出:判活读(及活臂刚收尾时的那次注入)都在它前面 ——
  *    令牌永不复用,此刻还是那一位 ⇒ 判活读那一刻也是那一位 ⇒ 判出的 run 是它的 run。
@@ -33,7 +33,7 @@
 import type { ExternalNotificationInput, SessionHead, SubagentToolOptions, TaskStream } from "@sema-agent/core";
 import { type WorkflowCompletionInbox } from "./orchestration/workflow-completion-inbox.js";
 import type { DelegationRootWitness } from "./delegated-session-owner.js";
-import type { HeadRead } from "./session-incarnation.js";
+import type { OwnerAwareSessionStore } from "./security.js";
 import type { Logger } from "./observability/logger.js";
 /** 门的一次投递结局(闭集;调用方 `switch` 穷尽)。 */
 export type SessionNotifyOutcome = {
@@ -74,8 +74,8 @@ export interface SessionNotifyDoorIo {
     /** 本副本持活 core 流的腿(taskId → 流)。 */
     readonly liveRuns: ReadonlyMap<string, Pick<TaskStream, "notify">>;
     readonly inbox: WorkflowCompletionInbox | undefined;
-    /** 会话店的按 id 头读(复核住客的那一读)。店没有 ⇒ `undefined`:调用方先判(路由 501;后台完成 relay 照交,门响亮抛 ⇒ relay 告警)。 */
-    readonly headOf: HeadRead | undefined;
+    /** 会话店(复核住客的那一读只经属主存取器)。店没有按 id 头读 ⇒ 调用方先判(路由 501;后台完成 relay 照交,门响亮抛 ⇒ relay 告警)。 */
+    readonly sessionStorage: Pick<OwnerAwareSessionStore, "headOf"> | undefined;
 }
 export declare function createSessionNotifyDoor(io: SessionNotifyDoorIo): SessionNotifyDoor;
 /** 委派工具挂载期的完成 sink 的型(取自 core 的选项型,不手抄)。 */

package/dist/session-notify-door.js

@@ -1,14 +1,13 @@
 import { externalNotificationInboxEntry } from "./orchestration/workflow-completion-inbox.js";
-import { sameOccupant } from "./execution-placement.js";
+import { occupantRecheckOf } from "./http/owner-access.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 export function createSessionNotifyDoor(io) {
+    const occupantNow = occupantRecheckOf(io.sessionStorage);
     async function recheck(target) {
-        if (io.headOf === undefined)
+        if (occupantNow === undefined)
             throw new Error("session notify door: the session store has no head read (headOf); the occupant cannot be re-checked before delivery");
-        const head = await io.headOf(target.sessionId);
-        if (head === undefined)
-            return { delivery: "withdrawn", reason: "gone" };
-        return sameOccupant(target.occupant, head) ? undefined : { delivery: "withdrawn", reason: "replaced" };
+        const verdict = await occupantNow(target.sessionId, target.occupant);
+        return verdict === "same" ? undefined : { delivery: "withdrawn", reason: verdict };
     }
     return {
         async deliver(target, event) {

package/dist/session-rules-seat.d.ts

@@ -4,9 +4,10 @@
  * (引擎交界的身份格,`engine-identity.ts`):带场景的会话,人 ≠ 属主,原样查 = 落到另一只桶(运维在 health 会话上 PUT 的 deny 对引擎不存在 = 安全轴放宽)。
  *
  * 律(一句):引擎交来的人恰是这只会话属主背后的人 ⇒ 键换成会话属主;否则原样(与今天逐字节同 —— 没带场景的会话属主与人字节相同,两种读法同一个键)。
- * 属主只经会话店的头读一处(`headOf(id)?.owner`,会话行是属主的唯一事实);读不到头(会话不在 / 店不交头读)⇒ 原样。读写两腿与祖先会话的规则读同经这一只席。
+ * 属主只经会话店的头读一处(会话行是属主的唯一事实;读与判在属主存取器 `http/owner-access.ts` 的 `engineRulesKeyOf`);读不到头(会话不在 / 店不交头读)⇒ 原样。
+ * 读写两腿与祖先会话的规则读同经这一只席。
  */
 import type { SessionPolicyStore } from "@sema-agent/core";
-import type { HeadRead } from "./session-incarnation.js";
-export declare function createEngineSessionRulesSeat(store: SessionPolicyStore, headOf: HeadRead | undefined): SessionPolicyStore;
+import type { OwnerAwareSessionStore } from "./security.js";
+export declare function createEngineSessionRulesSeat(store: SessionPolicyStore, sessions: Pick<OwnerAwareSessionStore, "headOf"> | undefined): SessionPolicyStore;
 //# sourceMappingURL=session-rules-seat.d.ts.map

package/dist/session-rules-seat.js

@@ -1,14 +1,6 @@
-import { personOf } from "./owner-brands.js";
-import { recoveredSubject } from "./owner-faces.js";
-export function createEngineSessionRulesSeat(store, headOf) {
-    const keyFor = async (sessionId, principal) => {
-        if (principal === undefined || headOf === undefined)
-            return principal;
-        const owner = (await headOf(sessionId))?.owner;
-        if (owner === undefined || owner === null)
-            return principal;
-        return personOf(recoveredSubject(owner)) === principal ? owner : principal;
-    };
+import { engineRulesKeyOf } from "./http/owner-access.js";
+export function createEngineSessionRulesSeat(store, sessions) {
+    const keyFor = (sessionId, principal) => engineRulesKeyOf(sessions, sessionId, principal);
     return {
         getRules: async (sessionId, principal) => store.getRules(sessionId, await keyFor(sessionId, principal)),
         putRules: async (sessionId, principal, rules, opts) => store.putRules(sessionId, await keyFor(sessionId, principal), rules, opts),

package/dist/session-sync.js

@@ -1,7 +1,7 @@
 import { anchorEntryDeclared, classifySyncRelationship } from "./session-sync-kernel.js";
 import { recordFailOpen } from "./observability/fail-open.js";
 import { loosenReasons, normalizeRules } from "@sema-agent/core";
-import { headReadOf } from "./session-incarnation.js";
+import { sessionFactsReadOf } from "./http/owner-access.js";
 import { fileHistoryBlobExchangeOf, judgeSessionRulesWrite } from "@sema-agent/core";
 export class FileHistoryUnreadableError extends Error {
     sessionId;
@@ -75,8 +75,8 @@ export async function exportSessionManifest(sessionId, srcBackend, historyStore)
     const entryIds = await listEntryIds(sessionId);
     if (entryIds === null)
         return null;
-    const headOf = headReadOf(session);
-    const leafId = headOf ? ((await headOf(sessionId))?.leafId ?? null) : null;
+    const sessionFactsOf = sessionFactsReadOf(session);
+    const leafId = sessionFactsOf ? ((await sessionFactsOf(sessionId))?.leafId ?? null) : null;
     const fs = historyStore;
     const fileHistory = await exportedFileHistory(fs, sessionId);
     const policyStore = srcBackend.sessionPolicy();

package/dist/session-workspace.d.ts

@@ -23,9 +23,9 @@
  * 会话在没有记号的检出里续跑时,项目随每一次不带 `projectId` 的提交丢掉。现在:一个值进引擎、一格存引擎的答案、下一条腿读那一格。
  *
  * ## 不在这里的(如实)
- *  · **记忆项目层**(单用户 `userrepo:` 键,`project-identity.ts` 的 git 检出身份)不是这个事实:它在装配期(任何帧之前)交给
- *    `TaskSpec.memory.projectKey`,按 git 仓库(origin 远端 / 本机路径)键控,与 `.sema/project` 记号无关;引擎 7.58.0 自己也写明
- *    「只声明的身份不改记忆的键」。两者是否该合成一个身份,是另一张设计票。
+ *  · **记忆项目层**(单用户 `userrepo:` 键,`project-identity.ts`)不读这一格:它在装配期(任何帧之前)交给 `TaskSpec.memory.projectKey`,
+ *    身份是**检出**的函数 —— 检出带 `.sema/project` 记号 ⇒ 按记号键控,读法就是引擎判官读的同一只(core `resolveProjectId`,同一任务根);
+ *    没有记号 ⇒ git 根回落。行上 `source: "declared"` 的项目不改项目层的键(引擎 7.58.0 记忆自己的读法同:「只声明的身份不改记忆的键」)。
  *  · 多租户记忆分区(`proj:<租户>/<projectId>`)与登记簿种子读的是**这次提交**的 `projectId`(按提交挑盘,修前即如此),不读行。
  *  · 行上的项目还有一位读者:会话视图 `GET /v1/sessions/:id` 体顶层的 `projectId`(唯一读口 {@link readSessionProjectId},与视图的 `agent` 同一次视图读)。
  *    `root` / `cwd` / `entered` / `remote` 今天只存不读;fork 出的新会话从「没有记录」起(项目声明按引擎契约每腿都带,fork 的首腿由调用方带上)。

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