@sema-agent/server 7.148.0 → 7.149.0

package/dist/runs.js

@@ -2,6 +2,7 @@ import { runWithVerification, runCascade, defaultTaskRegistry, taskNotificationD
 import { atHostBoundary, failureCodeOf, sealResultForExit, outwardPlane, outwardThrownMessage } from "./terminal.js";
 import { voidVerifierPauseCard } from "./verifier-pause-card.js";
 import { voidPendingCard } from "./card-void.js";
+import { commitParkRow } from "./park-row-commit.js";
 import { NOT_IN_ROSTER, entryProblemsFacts } from "./entry-problems.js";
 import { GOVERNANCE_HTTP_STATUS } from "./governance-http-status.js";
 import { TOOL_DECLARATION_HTTP_STATUS } from "./tool-declaration-http-status.js";
@@ -29,6 +30,7 @@ import { recordFailOpen } from "./observability/fail-open.js";
 import { BASELINE_IO_DEADLINE_MS, IoDeadlineExceeded, withinIoDeadline } from "./instruction-source-notice.js";
 import { errorText as errText } from "./observability/err-text.js";
 import { LIVENESS_HEARTBEAT_MS } from "./config-invariants.js";
+import { compositionLegRoot } from "./task-cwd.js";
 export async function backgroundAgentOutput(registry, handle, access, agentStore) {
     const row = registry.getAccessibleTask(handle, access);
     if (!row || row.type !== "background_agent") {
@@ -302,12 +304,18 @@ export async function graftParkToolCallId(result, cs) {
     const id = await parkToolCallId(result, cs);
     return id === undefined ? result : { ...result, toolCallId: id };
 }
+export function heldParkOf(result) {
+    if (result.terminal.kind !== "paused")
+        return undefined;
+    const word = outwardPlane(result.terminal).status;
+    return isParkLedgerEventType(word) ? { word, token: result.terminal.token } : undefined;
+}
 export async function voidHeldParkCard(held, hostSessionId, cards, leg) {
     if (held?.terminal.kind !== "paused")
         return;
     await voidPendingCard({ token: held.terminal.token, sessionId: hostSessionId }, cards, "server.park.held-card-void-failed", `leg=${leg}`);
 }
-export async function runInBackground(runner, spec, runStore, taskId, metrics, principal, verify, cascade, instrumentDegenerate, planCacheProbe, persistThinking = false, inflight, preemptable, steerable, modelUsage, elicitation, elicitOwner, captureTurnAnchor, fleetPublisher, captureUserMessageAnchor, question, workflowCompletionInbox, subagentSteer, completionDiagLog, sendUserFile, promptManifests, approval, checkpointCards, pendingEngineNotices, trustedInternals, userInputLedger, acceptance, workspaceRecorder, runSkills) {
+export async function runInBackground(runner, spec, runStore, taskId, parkCommit, metrics, principal, verify, cascade, instrumentDegenerate, planCacheProbe, persistThinking = false, inflight, preemptable, steerable, modelUsage, elicitation, elicitOwner, captureTurnAnchor, fleetPublisher, captureUserMessageAnchor, question, workflowCompletionInbox, subagentSteer, completionDiagLog, sendUserFile, promptManifests, approval, checkpointCards, pendingEngineNotices, trustedInternals, userInputLedger, acceptance, workspaceRecorder, runSkills, registeredCwd) {
     const startedAt = Date.now();
     metrics?.addGauge("runs_active", 1);
     fleetPublisher?.onStart();
@@ -345,12 +353,12 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     if (approval) {
         const coordinator = approval.coordinator;
         spec.onAsk = approvalLeg.unattended
-            ? coordinator.boundUnattendedAsk({ owner: elicitOwner ?? owner, taskId, ...(spec.sessionId ? { sessionId: spec.sessionId } : {}), executionLane: approval.executionLane }, approvalLeg.unattended)
+            ? coordinator.boundUnattendedAsk({ owner: elicitOwner ?? owner, taskId, ...(spec.sessionId ? { sessionId: spec.sessionId } : {}), ...approval.origin }, approvalLeg.unattended)
             : coordinator.boundAsk({
                 owner: elicitOwner ?? owner,
                 taskId,
                 ...(spec.sessionId ? { sessionId: spec.sessionId } : {}),
-                executionLane: approval.executionLane,
+                ...approval.origin,
                 ...(approvalLeg.active ? { legKey: "", ...(legDeadlineMonotonic !== undefined ? { legDeadlineMonotonic } : {}) } : {}),
             });
     }
@@ -375,23 +383,26 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     let legLive = true;
     const notifiedKeys = new NotifiedKeys();
     const subagentHandleEvictions = [];
-    const parkRowWrite = {
-        suspended: (sealed) => runStore.setSuspended(taskId, sealed),
-        needs_review: (sealed) => runStore.setNeedsReview(taskId, sealed),
-    };
-    const parkLeg = async (word, res) => {
+    const parkLeg = async ({ word, token }, res) => {
         const grafted = await graftParkToolCallId(res, checkpointCards);
         await sink.appendParked(word, grafted);
         const sealed = sealResultForExit(grafted);
         reached = { kind: word, result: sealed };
-        await parkRowWrite[word](sealed);
+        const committed = await commitParkRow({
+            runStore, taskId, word, result: sealed, card: { token, sessionId: spec.sessionId }, cards: checkpointCards, leg: "bg",
+            legId: parkCommit.legId, staleWindowMs: parkCommit.runStaleSec === undefined ? undefined : parkCommit.runStaleSec * 1000,
+        });
+        if (committed.kind === "ended") {
+            reached = undefined;
+            settledAsCancel = committed.row?.errorCode === CANCELLED_CODE;
+        }
         acceptance?.settle(sealed);
     };
     const settleLegResult = async (engineResult) => {
         const result = atHostBoundary(engineResult);
-        const parkWord = result.terminal.kind === "paused" ? outwardPlane(result.terminal).status : undefined;
-        if (parkWord !== undefined && isParkLedgerEventType(parkWord)) {
-            await parkLeg(parkWord, result);
+        const held = heldParkOf(result);
+        if (held !== undefined) {
+            await parkLeg(held, result);
             return;
         }
         const settled = causeAtDone !== undefined ? cancelledResult(causeAtDone, result) : result;
@@ -416,10 +427,13 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
     const hitlTransport = createHitlTransport({ ledger: append });
     const unregisterEngineNotice = registerEngineNoticeLeg({
         sessionId: spec.sessionId,
+        taskId,
         ...(pendingEngineNotices !== undefined ? { pending: pendingEngineNotices } : {}),
         durable: (row) => append("engine_notice", row).then(() => true, () => (recordFailOpen("server.engine-notice.durable-append-failed", `leg=bg code=${row.code} task=${taskId}`), false)),
     });
     try {
+        if (typeof parkCommit?.legId !== "string" || parkCommit.legId === "")
+            throw new TypeError(`runInBackground: run ${taskId} was started without the holding leg its claim handed back (parkCommit.legId) — refusing to start a run whose park could never be committed`);
         if (userInputLedger && spec.sessionId)
             await userInputLedger.announceUndrained({ sessionId: spec.sessionId, taskId });
         await emitPendingWorkflowCompletions(workflowCompletionInbox, spec.sessionId, elicitOwner ?? owner, (frame) => {
@@ -476,10 +490,11 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     void sink.appendStatus(e).catch((err) => completionDiagLog?.("status_event_append_failed", { route: "bg-run-composite", taskId, err: err instanceof Error ? err.message : String(err) }));
                 },
             };
+            const compositeInternals = { ...fwdInternals, ...statusSeat, ...compositionLegRoot(registeredCwd) };
             const compositeLeg = verify !== undefined
-                ? () => runWithVerification(runner, { ...spec, taskId, signal: cancelCtrl.signal }, verify, { ...fwdInternals, ...statusSeat })
+                ? () => runWithVerification(runner, { ...spec, taskId, signal: cancelCtrl.signal }, verify, compositeInternals)
                 : cascade !== undefined
-                    ? () => runCascade(runner, { ...spec, taskId, signal: cancelCtrl.signal }, cascade, { ...fwdInternals, ...statusSeat })
+                    ? () => runCascade(runner, { ...spec, taskId, signal: cancelCtrl.signal }, cascade, compositeInternals)
                     : undefined;
             if (compositeLeg !== undefined) {
                 const result = await compositeLeg();
@@ -550,7 +565,7 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                     owner: elicitOwner ?? owner,
                     abortSignal: cancelCtrl.signal,
                     ...(spec.sessionId ? { sessionId: spec.sessionId } : {}),
-                    executionLane: approval.executionLane,
+                    ...approval.origin,
                     family: "approval_request",
                     transport: hitlTransport,
                     legKey: "",
@@ -599,9 +614,12 @@ export async function runInBackground(runner, spec, runStore, taskId, metrics, p
                 acceptance?.settle(reached.result);
             }
             else if (reached !== undefined) {
-                await parkRowWrite[reached.kind](reached.result);
                 acceptance?.settle(reached.result);
             }
+            else if (thrownCancelCause === undefined && observedDone !== undefined && heldParkOf(atHostBoundary(observedDone)) !== undefined) {
+                recordFailOpen("server.runs.terminal-ledger-write-failed", `arm=park-held ${message}`);
+                await settleLegResult(observedDone);
+            }
             else if (thrownCancelCause !== undefined && observedDone === undefined) {
                 const c = cancelledResult(thrownCancelCause);
                 settledAsCancel = failureCodeOf(c.terminal) === CANCELLED_CODE;

package/dist/security.d.ts

@@ -75,7 +75,7 @@ export interface SessionRowCellsWriter {
  * 而 `DELETE /v1/sessions/:id`(删整条会话)不在其中 —— 同一风险形、爆炸半径**更大**,却没门。
  *
  * 风险形逐字同源(守卫自己的注释):「无 service token + 未开 `ALLOW_UNAUTHED_WRITES`」这一形下
- * fleet 写档(面表 fleet 列的 `dev_open` 格,`owner-faces.ts` 的 `listFilterOf`)判 fleet-wide ⇒ 集群内**任意**调用方可对**任意** session 动手。
+ * fleet 写档(面表 fleet 列的 `dev_open` 格,`owner-faces.ts` 的 `listFilterOf`)判 fleet-wide ⇒ 集群内**任意**不报主体的调用方可对**任意** session 动手(报了主体的调用方只动得到那位主体的,`principal-gate.ts` 的 `actsForDeployment`)。
  * policy 腿担心的是「forged principal 能 tighten/DoS 一个会话的工具」;DELETE 直接把会话删掉。
  *
  * ⇒ 枚举改**族判定**:新增一条破坏性会话路由时自动落进门内,不必记得回来加白名单。
@@ -190,7 +190,7 @@ export type OwnerAwareSessionStore = SessionStore & {
     /** 执行席(规则在 `execution-placement.ts`):根会话行上这一位住客的那一格的唯一读口(`read`)与 place / markMirror 两只写口。三店都有;两只包装原样转发。
      *  缺席 = 会话店没有执行放置(只有不带它的测试走廊 / 嵌入形),调用方各按自己的缺席臂处置。 */
     executionPlacement?: ExecutionPlacementSeat;
-    /** **删除门的头读**(读者只有删除门:`DELETE /v1/sessions/:id` 的属主门,经 `session-incarnation.ts` 的 `deletionHeadReadOf` 一只取法):
+    /** **「被占着」的头读**(读者:`DELETE /v1/sessions/:id` 的属主门 · 认领面 · 同步推送三口的门 —— 都问「这个 id 被占着吗」,经 `session-incarnation.ts` 的 `deletionHeadReadOf` 一只取法):
      *  活行 = {@link headOf} 同答;外加在删的行(会话三态 活 → 在删 → 没了 的中间一态,律在 `session-deletion.ts`;local 另有删序停在第一步之后的标记格)的属主与住客 ——
      *  开始删它的那位属主重发删除(= 接管)就收得完,别的属主得到与「不在」同一句(不可探测)。三只店都交。 */
     deletionHeadOf?: (sessionId: string) => Promise<SessionHead | undefined>;

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

@@ -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";

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-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

package/dist/store-posture.d.ts

@@ -4,6 +4,7 @@ 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 / 权限 / 只读挂载 / 磁盘满)。
@@ -124,10 +125,13 @@ export interface StorePosture {
     readonly durability: StoreDurability;
     /** 逐根明细:恒以数据根开头;有起服证据时再接封签钥匙目录与(接线时的)file 记忆根。 */
     readonly roots: readonly StoreRootDurability[];
+    /** local 店交给两半店的声明(present-iff 装配出 local 后端;值 = 后端构造时 `localStoreDeclarationOf` 的那一份,装配方从后端读回,不重算)。 */
+    readonly localDeclaration?: LocalStoreDeclaration;
 }
 /**
  * `build*`(纯数据)。`assembled` = 装配出的 `StoreBackend.kind`;缺席 = 没装出后端 ⇒ `memory`。`evidence` 缺席 = 这个宿主没有起服证据(测试夹具 / 桩):
  * 只判数据根、且只按后端规则判(local 无证据即抛)。`memoryRootWired` = file 记忆引擎在本部署上真接了线(配了才算;没接线的记忆根不进最弱律)。
+ * `localDeclaration` = 装配出的 local 后端交给两半店的那一份声明(装配出 local 而缺席 = 装配缺陷,响亮抛;别的后端递了也不收)。
  */
 export declare function buildStorePosture(a: {
     readonly declared: StoreBackendWord;
@@ -135,6 +139,7 @@ export declare function buildStorePosture(a: {
     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;