@sema-agent/server 7.133.0 → 7.135.0

package/dist/auto-mode-face.d.ts

@@ -27,9 +27,9 @@
  *                              capabilities 查询串不带 settings ⇒ 本面不产);
  *  · `resolver_fault`       —— resolver 抛错(core 同形全拒:autoMode:false + onError phase config)。
  *
- * 🔴 S-877(core 7.34.0 提货):「这台机器上装的 core 用哪套武装极性」的**安装包探针**(按文本扫
+ * 🔴 [ref](core 7.34.0 提货):「这台机器上装的 core 用哪套武装极性」的**安装包探针**(按文本扫
  * `dist/core/runner/prepare-task.js` 找 `autoModeRequested`)整只退役 —— 7.34.0 起那个键被引擎按名拒,探针的主判
- * 恒假、佐证恒真 ⇒ 矛盾臂 fatal,整台 server 起服即拒(S-878 探针 7.34.0 读数的 13 只红文件同一根因)。
+ * 恒假、佐证恒真 ⇒ 矛盾臂 fatal,整台 server 起服即拒([ref] 探针 7.34.0 读数的 13 只红文件同一根因)。
  * 极性不再是运行期要猜的事实:本仓把 core **精确钉版**(`package.json`,`test/core-dependency-floor.test.ts` 承重),
  * 钉住的那一版的武装谓词就是上面那一行,由类型面(`TaskSpec.permissionMode` / `RunnerDeps.autoMode` /
  * `RuntimeCaps.autoMode`)与 core CHANGELOG 同时陈述。⇒ 旧式臂(「org 授予」极性)与 `engineArmsOnIntent` 座一并删,
@@ -51,7 +51,7 @@ import { type PermissionMode, type RunnerDeps, type RuntimeCaps } from "@sema-ag
  * 本仓 [ref] 的跨仓诉求兑现;契约句 `classifier.seat.one_resolver` 逐字:引擎的武装点与**显示这个席**
  * 的宿主读面调同一只导出函数,而不是各自从目录/角色/档位表再推一遍 —— 第二份推导就是第二个答案)。
  *
- * 🔴 **S-350:本仓的自算分支已删**。修前这里调的是 `resolveTaskModel({modelRole:"classifier"})`,那只
+ * 🔴 **[ref]:本仓的自算分支已删**。修前这里调的是 `resolveTaskModel({modelRole:"classifier"})`,那只
  * 回答的是「classifier **角色**解到谁」;引擎真正挑席时在角色没点名模型的情况下还要走 **tierBelowMain**
  * (主模型档位**严格之下**、路由不同的最近一档)。两者在「档位表在场 + 没有 classifier 角色」这一形上
  * 给出**不同的模型**(车FL U-3 坐实),读面于是对着 `sema doctor permissions` 报另一只模型。规则变少的
@@ -92,7 +92,7 @@ export declare const AUTO_MODE_UNARMED_REASON_SEMANTICS: {
     readonly resolver_fault: "per-principal caps resolver 抛错/答非记录(core 同形全拒:autoMode:false + onError phase config)";
 };
 /** 装配面交给读面的三件事实(`main.ts` 从 runnerDeps / 合成后的 caps resolver 取,读面不自算)。
- *  S-877:第四件「引擎半场到货位」(`engineArmsOnIntent`,安装包探针)随极性探针一起退役。 */
+ *  [ref]:第四件「引擎半场到货位」(`engineArmsOnIntent`,安装包探针)随极性探针一起退役。 */
 export interface AutoModeFaceDeps {
     /** `RunnerDeps.autoMode !== undefined`——**读**装配点那一位,不写字面 true(与 parked-revive 的
      *  `autoModeSeatMounted` 同一纪律:席位哪天改成有条件挂载,这里不能静默错供)。 */

package/dist/background-session-reap.d.ts

@@ -39,7 +39,7 @@ export interface SessionHardReap {
  *     + run 的 task id 就是会话 id 的 run 行;同一个 id 在别的 scope 是别的会话;别的会话的行永远不碰)—— 宽限里跑完处理器的进程答
  *     `already_gone`,屏蔽 / 没跑完的在这一枪组 SIGKILL(与 host 梯子自己到点的那一枪同拍,两枪都是组 SIGKILL,幂等)。同拍是设计内的:
  *     两枪谁先是同一毫秒的定时器次序。硬面先打 ⇒ `killed`;梯子先打、引擎还没收割组长 ⇒ 硬面那一枪落在只剩僵尸的组上:darwin EPERM ⇒
- *     `no_pgid`(未确认)、linux ⇒ `killed`;已收割 ⇒ `already_gone`。受据按观察答(S-769 车PA 删了「已硬收过」闩:组信号任一成员收到即
+ *     `no_pgid`(未确认)、linux ⇒ `killed`;已收割 ⇒ `already_gone`。受据按观察答([ref] 车PA 删了「已硬收过」闩:组信号任一成员收到即
  *     成功,闩在部分送达时把活着读成没了),本函数也不为「让硬面先打」挪任何一拍。
  *
  * `scope` = 会话行属主 `owner ?? "default"`(与 core 注册铸值 `spec.principal ?? "default"` 同源 —— 缺席 scope 在 core 的
@@ -48,7 +48,7 @@ export interface SessionHardReap {
  * 两处调用(见文件头 ①),都 `await`:E21 删除级联 `includeRetained:false`(显式活服务照留);停止口照传请求体。应答在硬面之后发,
  * 代价 = 有 shell 行刚被软停的会话,DELETE / 停止口的应答慢到最后一行的「软停 + 宽限」(通常一次宽限;操作员旋钮 `HOST_BG_KILL_GRACE_MS`,缺省 1000;要几乎不等写 `1` ——
  * `numEnvOr` 把 `0` 读作缺席、回落缺省,与它供的其余执行车道旋钮同一条语义)。
- * 受委托帮手的 shell 挂在帮手自己的会话上,本函数碰不到(core KL-1107a / #1109,候 core)。
+ * 受委托帮手的 shell 挂在帮手自己的会话上,本函数碰不到(core KL-1107a / [ref],候 core)。
  * 注册表是**进程内**的:只收本副本上的行(多副本部署里别的副本上的行由那个副本自己的出口收)。
  */
 export declare function reapSessionBackgroundHard(sessionId: string, scope: string, opts: {

package/dist/bake-runner/main.d.ts

@@ -21,7 +21,7 @@ interface RunnerEnv {
  *    `BUILD_SH_PATH`(缺省 `e2b-template/dev-sandbox/build.sh`)、`BAKE_DATA_DIR`(缺省 `/data`)、`LOG_LEVEL`(缺省 info)。
  *  · 数值四键(`parseNumOrFailNonNegative`,非数 / 负数拒启):`BAKE_HEARTBEAT_MS`(30000)、`BAKE_IDLE_POLL_MS`(5000)、
  *    `IMAGE_BAKE_MIN_FREE_GB`(20)、`BAKE_SHUTDOWN_GRACE_MS`(5000)。
- *  · `BAKE_ENV_ALLOW=NAME,NAME`(7.103.0,S-684 残余):本进程 spawn 的每一只子进程组(build.sh 与 git fetch / docker push /
+ *  · `BAKE_ENV_ALLOW=NAME,NAME`(7.103.0,[ref] 残余):本进程 spawn 的每一只子进程组(build.sh 与 git fetch / docker push /
  *    docker image inspect / df)的 env 缺省 = 本进程 env 剥密(runner 自己的 `BAKE_RUNNER_TOKEN` 在内);名单点到的键从本进程 env **原样**
  *    放回(部署方显式承担 —— 例如配方脚本真要一枚 `*_PASSWORD` 做 registry 登录)。与服务侧 `LSP_ENV_ALLOW` **同一只**解析器
  *    (`config.ts` `parseEnvNameAllowlist`)与同一只放行谓词:形错(空段 / 尾逗号 / 非变量名形 / 点名任一只名单型旋钮)⇒ **拒启**,拒句点名
@@ -34,7 +34,7 @@ declare function loadEnv(): RunnerEnv;
  *  carries the per-bake ingest secret header (so image-api can reject a stale/rogue runner — §P2.4e). */
 declare function makeApiClient(env: RunnerEnv, log: BakeRunnerLogger): ImageApiClient;
 /**
- * S-567 —— **bake-runner 自己的在飞进程组簿**。
+ * [ref] —— **bake-runner 自己的在飞进程组簿**。
  *
  * 为什么不复用 host 前台簿(`src/plugins/host-platform.ts` 的 `adoptHostForegroundChild`)—— **属主语义不同**
  * (车LD §3(a) 判定)：那本簿的契约逐字是「被一个**在飞 turn** 拥有的 host lane 前台 exec」，收割姿势是

package/dist/bake-runner/runner.d.ts

@@ -33,7 +33,7 @@ export interface ChildHandle {
     }>;
     /** Send a signal to the process GROUP (SIGTERM then SIGKILL on the cancel/deadline path). */
     killGroup(signal: NodeJS.Signals): void;
-    /** Does the process GROUP still have ANY member? (`kill(-pgid, 0)`.) 🔴 S-567 codex ①: this — not {@link exited} — is
+    /** Does the process GROUP still have ANY member? (`kill(-pgid, 0)`.) 🔴 [ref] codex ①: this — not {@link exited} — is
      *  the group's lifetime. `exited` resolves when the LEADER exits; a leader that dies on SIGTERM can leave a
      *  TERM-immune descendant in the same group, and treating leader-exit as "the group is gone" lets it escape. */
     groupAlive(): boolean;
@@ -103,7 +103,7 @@ export interface BakeRunnerOpts {
     /** Minimum free GiB on /data at claim; below this the bake fails fast (507-class) rather than dying mid-build and
      *  leaving a half-layer (k3s + docker containerd both on /data — a fill triggers kubelet GC eviction — §P2.7). */
     minFreeGb?: number;
-    /** S-567 —— **一只注定要死的 build 进程组的「体面赴死窗」**(ms,`BAKE_SHUTDOWN_GRACE_MS`,默认 5000)。
+    /** [ref] —— **一只注定要死的 build 进程组的「体面赴死窗」**(ms,`BAKE_SHUTDOWN_GRACE_MS`,默认 5000)。
      *
      *  两条路读同一个数,因为它们问的是**同一个问题**:
      *   · cancel / deadline 击杀({@link BakeRunner.runOne} 的 supervisor):SIGTERM → 本窗 → SIGKILL;
@@ -139,7 +139,7 @@ export declare class BakeRunner {
     private readonly liveKills;
     constructor(opts: BakeRunnerOpts);
     /**
-     * S-567 —— **关机梯子**：幂等、可 await、四步，一处承重。
+     * [ref] —— **关机梯子**：幂等、可 await、四步，一处承重。
      *
      * ── 病（车LD §2.3，28 次真进程×两套运行时、零反例）───────────────────────────────
      * 旧 `stop()` 只置一个 flag，而 `loop()` 此刻正 `await this.runOne(...)`、`runOne` 正 `await child.exited`
@@ -198,7 +198,7 @@ export declare class BakeRunner {
      * 不受本进程信号支配（既有射程，非本批新开）。一次 SIGKILL 死在 docker build 中间会留悬挂层；
      * dup-check + lockhash 保证重烤不被毒化，悬挂层本身由 docker 自己的 prune / 运维回收。
      * （旧注声称“一条启动期的工作目录清扫会把它们收回去”—— **假补偿**：全 `src/` 无此实现，build.sh 侧也只有
-     * per-job workdir + `mktemp -d` 回退，没有任何启动期清扫 —— 车LD §3(3) 亲核，S-567 删句：过期的“已被兜住”
+     * per-job workdir + `mktemp -d` 回退，没有任何启动期清扫 —— 车LD §3(3) 亲核，[ref] 删句：过期的“已被兜住”
      * 声明比欠账更危险。真要做清扫，那是带自己设计的另一台车。）
      */
     private killGroupLadder;

package/dist/bench/s1/live-deps.d.ts

@@ -89,7 +89,7 @@ export declare function benchBaseSpec(rt: LiveRuntimeConfig, cellId: string): (o
 /**
  * Project a `SoloImplSpec` (budget already stamped by the harness, all keys in `limits`) onto the bench base TaskSpec.
  * 🔴 7.106.0 合并复审 X3:SOLO 是**无人值守腿**(verify→fix 跑在一只不接 `onAsk` 的 Runner 上,没有审批席)⇒ 经 `withUnattendedLeg` 接
- * 无人值守腿的合并口(S-934 ①:`default` + 按类作答的 onAsk,无席)。修前裸 spec ⇒ core 7.34.0「缺席 =
+ * 无人值守腿的合并口([ref] ①:`default` + 按类作答的 onAsk,无席)。修前裸 spec ⇒ core 7.34.0「缺席 =
  * default」且无席 ⇒ 写与非只读命令 headless 拒、终态照旧 completed。SUP 不走这里:它有耐久审批席
  * (checkpoint suspend),它的问要人答。
  */

package/dist/bench/s1/run-firm.d.ts

@@ -16,7 +16,7 @@
  * 🔴 ENV GATING: the live path requires E2B_API_KEY + DEEPSEEK_API_KEY; absent → the driver refuses the live path
  *    with a clear message (never a silent fake run). The deterministic --dry-run never needs keys.
  *
- * 🔴 LEDGER I/O (S-977): the WRITE side is the repo's shared append port — core `AppendLog` (lazy open, one `writeSync` loop per
+ * 🔴 LEDGER I/O ([ref]): the WRITE side is the repo's shared append port — core `AppendLog` (lazy open, one `writeSync` loop per
  *    row, a failed write rolled back, a torn tail repaired on open AND before every append) — so a crash that tore the last
  *    row no longer glues the resume's first row onto the broken suffix (which lost that cell's row ⇒ one cell re-run at real
  *    E2B / DeepSeek cost). No fsync (a crash loses at most the tail row ⇒ that cell stays re-runnable — the same posture as before).

package/dist/boot/coordinators.d.ts

@@ -14,6 +14,7 @@ import { QuestionCoordinator } from "../question.js";
 import { ToolApprovalCoordinator, type ParkedAskRedeem } from "../tool-approval.js";
 import { FileApprovalAskAuditStore } from "../approval-ask-audit-store.js";
 import type { ParkCommitWatch } from "../plugins/park-commit-watch.js";
+import { type GateCurrencyStore } from "../approval-gate-currency.js";
 import { SendUserFileEmitter } from "../capabilities/send-user-file-tool.js";
 import { TaskEnvRegistry } from "../capabilities/sandbox-file-send.js";
 import type { StoreBackend } from "../plugins/store-backend.js";
@@ -33,16 +34,20 @@ export interface LiveCoordinatorsCtx {
      *  必须排在它之前;同款 holder 先例 = reaper 的 `getRunDenySweep`)。取到 undefined ⇒ 那条臂逐字回落
      *  修前 404(partial 部署安全)。缺席(不传本键)⇒ 协调器整条迟到腿的 PARKED 臂恒 404。 */
     getParkedRedeem?: () => ParkedAskRedeem | undefined;
-    /** S-929 F1:checkpoint 店的 park 提交观察层(stage-06 与店同一处铸;在场 ⇔ 有 checkpoint 店)。协调器据它判「有序关停下的 park 路由
+    /** [ref] F1:checkpoint 店的 park 提交观察层(stage-06 与店同一处铸;在场 ⇔ 有 checkpoint 店)。协调器据它判「有序关停下的 park 路由
      *  提交了没有」—— 审计 settle 行等 park 提交落定才写。缺席 = 没有 park 设施(core 在 ask 回调处就收场,没有提交这一步)。 */
     parkCommits?: ParkCommitWatch;
+    /** [ref]:checkpoint 店(stage-06 的**同一只**,与 `parkCommits` 同源;在场 ⇔ 有 park 设施)。协调器的按问读口据它判一张 `PARKED` 卡的门此刻还是不是该会话当前待决的审批门
+     *  (判官 = `approval-gate-currency.ts`,应答口判 `approval_stale` 读的同一只)。缺席 ⇒ 读口只能说行说的话(`parked`)。
+     *  也是流内审批协议上场门的 park 设施位:在场性与实例是一个事实 —— 门的 `active` 臂交出去的就是这一只,缺席 ⇒ 协议不上场(`no_park_facility`)。 */
+    checkpointStore?: GateCurrencyStore;
 }
 export declare function createLiveCoordinators(ctx: LiveCoordinatorsCtx): {
     elicitation: ElicitationCoordinator | undefined;
     question: QuestionCoordinator | undefined;
     toolApproval: ToolApprovalCoordinator | undefined;
     durableEnabled: boolean;
-    streamApprovalGate: import("../tool-approval.js").StreamApprovalGate;
+    streamApprovalGate: import("../tool-approval.js").StreamApprovalGate<GateCurrencyStore>;
     approvalAskAudit: FileApprovalAskAuditStore | undefined;
     approvalExemptionStore: import("../plugins/approval-exemption-store.js").ApprovalExemptionStore | undefined;
     sendUserFileEmitter: SendUserFileEmitter | undefined;

package/dist/boot/coordinators.js

@@ -3,23 +3,25 @@ import { QuestionCoordinator } from "../question.js";
 import { ToolApprovalCoordinator, resolveStreamApprovalGate } from "../tool-approval.js";
 import { deploymentListAsks } from "../approval.js";
 import { FileApprovalAskAuditStore } from "../approval-ask-audit-store.js";
+import { createParkedGateRead } from "../approval-gate-currency.js";
 import { SendUserFileEmitter, SEND_USER_FILE_MAX_BYTES, sendUserFileTool } from "../capabilities/send-user-file-tool.js";
 import { createSandboxFileSend, TaskEnvRegistry } from "../capabilities/sandbox-file-send.js";
 import { createSendUserFileIssuer } from "../plugins/send-user-file.js";
 import { withLedgerRecording } from "../plugins/send-file-ledger.js";
 import { basename, resolve } from "node:path";
-import { toolsRunOnThisHost } from "../task-cwd.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import { stat as fsStat, readFile as fsReadFile } from "node:fs/promises";
 export function createLiveCoordinators(ctx) {
-    const { config, logger, backend, sendUserFileTaskEnvs, ruleConsent, ruleScopeRootFor, getParkedRedeem, parkCommits } = ctx;
+    const { config, logger, backend, sendUserFileTaskEnvs, ruleConsent, ruleScopeRootFor, getParkedRedeem, parkCommits, checkpointStore } = ctx;
     const elicitation = config.mcpElicitation.enabled ? new ElicitationCoordinator(config.mcpElicitation.throttle) : undefined;
     const question = config.askQuestionEnabled ? new QuestionCoordinator(config.questionThrottle) : undefined;
-    const durableEnabled = backend?.checkpoint !== undefined && config.durableApproval === true;
+    const parkStore = checkpointStore;
+    const durableEnabled = parkStore !== undefined;
     const streamApprovalGate = resolveStreamApprovalGate({
         toolApprovalEnabled: config.toolApprovalEnabled === true,
         streamApprovalEnabled: config.streamApproval.enabled,
         backend,
-        parkFacility: durableEnabled,
+        checkpointStore: parkStore,
     });
     if (config.streamApproval.enabled && !streamApprovalGate.active) {
         logger.info("stream_approval_disabled", {
@@ -58,6 +60,7 @@ export function createLiveCoordinators(ctx) {
             ...(ruleScopeRootFor !== undefined ? { ruleScopeRootFor } : {}),
             unattendedPolicy: config.unattendedApprovalPolicy,
             ...(getParkedRedeem !== undefined ? { parkedRedeem: getParkedRedeem } : {}),
+            ...(checkpointStore !== undefined ? { parkedGate: createParkedGateRead(checkpointStore) } : {}),
             ...(approvalAskAudit !== undefined ? { askAudit: approvalAskAudit } : {}),
             ...(approvalExemptionStore !== undefined
                 ? { sessionGrants: approvalExemptionStore, deploymentListAsks: (call) => deploymentListAsks(config, call) }
@@ -70,7 +73,7 @@ export function createLiveCoordinators(ctx) {
             return undefined;
         if (sendUserFileTaskEnvs)
             return new SendUserFileEmitter();
-        if (toolsRunOnThisHost(config) && config.requirePrincipal !== true)
+        if (DEPLOYMENT_SHAPE_PREDICATES.callerOwnsWorkerDisk.holds(config))
             return new SendUserFileEmitter();
         return undefined;
     })();

package/dist/boot/deferred-sandbox-path-env.d.ts

@@ -46,12 +46,6 @@
  * 该面由 test/task-settings.test.ts 的「真身胜过名字」特征化钉机器可见。
  */
 import { FileError, StubExecutionEnv, type ExecutionEnv, type ExecutionEnvFactory, type FileInfo, type Result } from "@sema-agent/core";
-/** 哪些 lane 用本模块的代理裁决写门 —— 文件平面**不在** worker 本机的全部(= 能力表 `hostFilePlane` 答否)。
- *  与 resolve-spec 的 `hostSemanticsLane` 是同一判别式的两面,取值处**只此一个**(两处各写一份正是漂移的成因)。
- *  🔴 S-602:改前写的是 `provider !== undefined && provider !== "host"` —— 把缺席并进 host 的同义折(门 D R3),
- *  今天改读表那一位(`in-process` / `host` 答 YES,其余答 NO;读数逐格不变)。认不出的词 ⇒ 走代理裁决:
- *  代理 slot 空 ⇒ 写门 fail-closed(本模块头注裁定 2),与改前同向。 */
-export declare function isSandboxPathAdjudicationLane(provider: string | undefined): boolean;
 /** slot 取值的三态。`ok:false` 的两支都是 fail-closed,分开只为让留痕说得出**哪一种**缺席。 */
 export type SandboxPathEnvLookup = {
     readonly ok: true;

package/dist/boot/deferred-sandbox-path-env.js

@@ -1,10 +1,5 @@
 import { FileError, StubExecutionEnv, err, ok } from "@sema-agent/core";
 import { normalizeAbsolutePathLexically } from "../task-cwd.js";
-import { executionLaneCaps, executionLaneOf } from "../execution-lane-caps.js";
-export function isSandboxPathAdjudicationLane(provider) {
-    const lane = executionLaneOf(provider);
-    return lane === undefined || executionLaneCaps(lane).hostFilePlane !== "supported";
-}
 const MAX_BOUND_SESSIONS = 4096;
 export class SandboxPathEnvSlots {
     bySession = new Map();

package/dist/boot/engine-lease.d.ts

@@ -8,16 +8,16 @@
  * **多壳共享一只引擎**时它结构性地问错了问题 —— 首壳退了 peer 还在用,监视父 pid 要么误杀要么永不触发。
  * 本件问的是那个真正的问题:**还有没有人附着**。
  *
- * ## S-306:自退律只剩这一条(硬 breaking)
+ * ## [ref]:自退律只剩这一条(硬 breaking)
  *
  * `SEMA_PARENT_PID` 看门狗的 drain 臂**整条删**了:父死只是把引擎标成**孤儿**(`parent_watch_orphaned`),
  * 孤儿走的是**本腿这一条**判据,只有一处不同 —— 窗长从 {@link EngineLeaseDeps.lingerMs} 换成
  * {@link EngineLeaseOrphanLane.lingerMs}(`ENGINE_ORPHAN_LINGER_MS`,默认 2s)。于是:
  *  · 规则集 **−1**(「父死即退」那条判据没了),参数 +1(孤儿窗);
- *  · 「有人附着 / 有 run 在飞就不退」这条结构性保护**对孤儿同样成立** —— cli 拒绝 S-292 的那一形
+ *  · 「有人附着 / 有 run 在飞就不退」这条结构性保护**对孤儿同样成立** —— cli 拒绝 [ref] 的那一形
  *    (A 起引擎、B 按 engine.port 复用、A 正常退)不会再在 B 的 turn 中间把引擎拆掉;
  *  · 装配判据随之变成 `parentPid 在场 ∨ engineAutoExit`;`ENGINE_AUTO_EXIT` 关着的 owned 引擎窗长
- *    是 **`Infinity`** —— 父还活着就**永不自退**(与 S-306 前逐字同),父一死才由孤儿窗接手。
+ *    是 **`Infinity`** —— 父还活着就**永不自退**(与 [ref] 前逐字同),父一死才由孤儿窗接手。
  *
  * ## 机制(逐条都是契约)
  *
@@ -47,7 +47,7 @@
  *  6. **interval 必须 unref**:自退检查腿不得成为「进程本该退出却退不掉」的理由(与 drain tick 刻意
  *     不 unref 的取向相反 —— 那一只 tick 就是停机驱动,这一只只是观察者)。**恒一只 interval**:
  *     孤儿态不另起第二只定时器(两只定时器 = 两条自退律,正是本件要消灭的那件事)。
- *  9. **拍频由窗推导,不是第二个旋钮**(S-306):`tickMs = min(`{@link ENGINE_LEASE_TICK_MS}`, 本腿可能
+ *  9. **拍频由窗推导,不是第二个旋钮**([ref]):`tickMs = min(`{@link ENGINE_LEASE_TICK_MS}`, 本腿可能
  *     执行的每一个窗)`。理由是顶注 8 那句话的逆命题 —— 实际窗 `[linger, linger+tickMs)` 里,采样滞后
  *     不得压过窗本身:15s 一拍去执行一个 2s 的孤儿窗,「2s」这句承诺就只是个装饰。所以装了孤儿车道
  *     (= 壳 spawn 形)的引擎按 2s 采样,没装的(纯服务器形)仍是 15s —— 存量部署一拍都没多跳。
@@ -67,7 +67,7 @@
  *    已由 `inflight()` 结构性守住;parked 行是 durable 的,引擎退掉不丢:下次起来仍可赎回(spawn 形里
  *    「下次」就是壳的下一次 spawn)。伤害面 = 一条 parked run 的赎回被推迟到下次启动,不是丢失。
  *    这是**允许的收窄,不是静默**:有了廉价 parked 计数口(或本腿改成事件驱动)之后应当补上。
- *  · **活过父 run 的后台子代理不入判据**(codex R1 [high] 验真后**如实登记**,不是本件引入:S-306 之前
+ *  · **活过父 run 的后台子代理不入判据**(codex R1 [high] 验真后**如实登记**,不是本件引入:[ref] 之前
  *    父死走的是**当场** drain,而 `drainThenShutdown` 读的是同一只 `inflight()` ⇒ 同一个缺口,只是那时
  *    连这 2s 都没有)。`inflight()` 的口径是**本副本的 HTTP 腿 ∪ leader 腿**(`http/server.ts` 的
  *    `inflightRuns`/`steerableRuns`/两只计数器),而 core 侧 `backgroundScope:"session"` 的子代理可以

package/dist/boot/execution-env.d.ts

@@ -12,14 +12,14 @@ import { type SpaceCommitRows } from "../workspace-space-commit.js";
 import * as facts from "../capability-facts.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { TaskInheritEnv } from "../request-value-closure.js";
-import type { IncarnationRead } from "../session-incarnation.js";
+import { type HeadRead } from "../session-incarnation.js";
 import type { SpaceReclaimer } from "../workspace-space.js";
 /**
  * per-session 的 **cwd / shellEnv 登记簿**(TOC cwd seam + R-survey shellEnv seam)+ 它们的**租户围栏**。
  *
  * ── 为什么围栏不是可选的(codex R1-F1,判真)────────────────────────────────────────────────────
- * 这两张表只按 `sessionId` 键控。在 host lane 上那是安全的:那条车道的闸带 `requirePrincipal !== true`,
- * 整台机器就一个用户。**device lane 把这个前提撤掉了** —— 它的闸(`deviceCwdHonored`)刻意不要求单用户
+ * 这两张表只按 `sessionId` 键控。在 host lane 上那是安全的:那条车道的闸(部署形表行 `callerCwd` 的 host 臂)
+ * 要求单主,整台机器就一个用户。**device lane 把这个前提撤掉了** —— 同一行的 device 臂刻意不要求单用户
  * (员工各连各的设备)。于是一条真实的超范围路径出现了:
  *   ① sessionId 由**调用方自选**,而且 `DELETE /v1/sessions/:id` 之后可以被**别人** `register` 重新登记
  *      (`boot/session-faces.ts` 的化身围栏注逐字写着这件事);
@@ -38,12 +38,12 @@ import type { SpaceReclaimer } from "../workspace-space.js";
 export interface SessionScopedRegistries {
     readonly perSessionCwd: Map<string, string>;
     readonly perSessionShellEnv: Map<string, Record<string, string>>;
-    /** S-895:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装;写只经 {@link setSessionInheritEnv}。 */
+    /** [ref]:host shell 的继承策略(`inheritEnv` 请求键)。只读面给 host 工厂包装;写只经 {@link setSessionInheritEnv}。 */
     readonly perSessionInheritEnv: ReadonlyMap<string, TaskInheritEnv>;
     setSessionCwd(sid: string, cwd: string): void;
     setSessionShellEnv(sid: string, env: Record<string, string>): void;
     /**
-     * S-895 —— 第三只 per-session 绑定(与 cwd / shellEnv 同一只 LRU 权威、同一条围栏、同一条删除)。
+     * [ref] —— 第三只 per-session 绑定(与 cwd / shellEnv 同一只 LRU 权威、同一条围栏、同一条删除)。
      * `undefined` = **清掉**这一格(不是「不动」):`inheritEnv` 是「本条请求要什么」,缺席的请求要的是缺省清洗 ——
      * 与 cwd / shellEnv 的「缺席 = 留着上一条的值」刻意不同(那两位由壳每条请求重发,粘住无害;这一位粘住 = 替一个没说话的
      * 请求放宽凭据面)。
@@ -59,10 +59,10 @@ export declare function createSessionScopedRegistries(maxEntries?: number): Sess
 /**
  * k8s 车道的**每 run 绑定**:部署级适配器配置 × 三只 run 作用域的座(都按本 run 的 `ctx.sessionId` 取)——
  *  · 镜像:§7 P0.5 per-task 镜像(resolveSpec 按调用方 principal 解出、按会话登记;缺席 ⇒ 部署缺省镜像);
- *  · **工作区空间的分区 = 会话化身**(`spaceOccupant.incarnation`):建这只 env 时按 id 读一次会话店的 `incarnationOf`(会话行上的那一格,
- *    `session-incarnation.ts`;本工厂不取会话,正是 core 给「没取会话的读者」的那只读)。读数是闭集三臂(`SpaceOccupant`,适配器那边逐臂处置):
+ *  · **工作区空间的分区 = 会话化身**(`spaceOccupant.incarnation`):建这只 env 时按 id 读一次会话店的头(`headOf`,会话行上的那一格,
+ *    `session-incarnation.ts`;本工厂不取会话,正是 core 给「没取会话的读者」的那只读),经 `sessionFaceOfHead` 投成一位活住客。读数是闭集三臂(`SpaceOccupant`,适配器那边逐臂处置):
  *    答令牌 ⇒ 已知;答 `undefined`(没有这只会话)⇒ `{ unread: "incarnation_unknown" }` —— 没有空间:空间车道不开、缓存卷不挂,各一行;
- *    读抛 / 超时(`rpcTimeoutMs`,同一次 connect 里读围栏行与 `latest` 的那一只墙)/ 答出的不是非空串 ⇒ `{ fault: <code> }` —— 读不到空间 ≠ 没有空间:开着的空间车道 / 缓存卷让这只 env 一只 pod 都不建,
+ *    读抛 / 超时(`rpcTimeoutMs`,同一次 connect 里读围栏行与 `latest` 的那一只墙)/ 行在而没有令牌(`session.incarnation_missing`)/ 答出的不是非空串 ⇒ `{ fault: <code> }` —— 读不到空间 ≠ 没有空间:开着的空间车道 / 缓存卷让这只 env 一只 pod 都不建,
  *    connect 与 resumeVM 都答 `connect_failed`(与 `latest` 读失败同一铸点),一行 `workspace_space_unreadable_occupant`;`code` 是店的错误码,
  *    从不带正文、从不带令牌。**绝不**以会话 id 代替;
  *    同时开这只 env 在空间提交围栏上的座(`spaceOccupant.fence`,run 店的 `workspace_space_commit` 行;法见 `workspace-space-commit.ts`);
@@ -76,9 +76,10 @@ export declare function createSessionScopedRegistries(maxEntries?: number): Sess
  */
 export declare function createK8sRunEnvFactory(k8sCfg: K8sEnvConfig, seats: {
     imageOf(sessionId: string): string | undefined;
-    /** The session store's by-id occupant read (`SessionStore.incarnationOf`, picked once by `incarnationReadOf`); absent ⇔ the store
-     *  has none, which `assertWorkspaceSpaceReadable` refuses together with `space` (embeddings that wire another lane pass none). */
-    incarnationOf: IncarnationRead | undefined;
+    /** The session store's by-id head read (`SessionStore.headOf`, picked once by `headReadOf`); the occupant is its live-occupant projection
+     *  (`sessionFaceOfHead`). Absent ⇔ the store has none, which `assertWorkspaceSpaceReadable` refuses together with `space` (embeddings that
+     *  wire another lane pass none). */
+    headOf: HeadRead | undefined;
     /** The run store's commit-fence rows (`workspace_space_commit`); answers `undefined` only before stage 7 binds the run store
      *  or without a store backend — the latter `assertWorkspaceSpaceReadable` refuses together with `space`. */
     spaceCommits(): SpaceCommitRows | undefined;
@@ -87,7 +88,7 @@ export declare function createK8sRunEnvFactory(k8sCfg: K8sEnvConfig, seats: {
  * k8s 工作区空间的**起服前提**(装配后的真门;同段先例 = `assertDeviceLaneWired`)。法只有一条:
  * **生效策略 `space`(事实 `workspaceSpace`)∧ {@link createK8sRunEnvFactory} 的两只座缺一 ⇒ 拒启。**
  *
- * 空间车道每条 run 开不开,只看工厂的两只座:住客的按 id 读(会话店的 `incarnationOf`,`incarnationReadOf` 在第 5 段判一次,本门与工厂
+ * 空间车道每条 run 开不开,只看工厂的两只座:住客的按 id 读(会话店的 `headOf`,`headReadOf` 在第 5 段判一次,本门与工厂
  * 读同一只返回值)与提交围栏的行(run 店 —— 住在存储后端里;没有存储后端 ⇒ 没有这只座)。缺一 ⇒ 每条 run 都不存,而能力位
  * `workspaceSync.persist` 只读配置、照报 `"space"`。事实**保持只读配置**;让它恒真的办法是拒掉这一组合,不是给事实加运行期依赖。
  * 生效策略缺席(非 k8s 车道 / 没配快照存储:能力位本就不在场,后者有起服一行 `workspace_persist_unavailable`)或 `off` ⇒ 不判。
@@ -96,7 +97,7 @@ export declare function createK8sRunEnvFactory(k8sCfg: K8sEnvConfig, seats: {
  * 拒句一行,点名:旋钮词、缺的是哪一只座、会话店种类(`sessionStoreLabelOf` —— `/health.sessionBackend` 同一读法)、出路。
  */
 export declare function assertWorkspaceSpaceReadable(space: ReturnType<typeof facts.workspaceSpace>, seats: {
-    readonly incarnationOf: IncarnationRead | undefined;
+    readonly headOf: HeadRead | undefined;
     readonly spaceCommits: (() => SpaceCommitRows | undefined) | undefined;
 }, cache: ReturnType<typeof facts.workspaceCache>, sessionStoreLabel: string): void;
 /** device lane 的三件活对象(店 / 汇聚端 / 准入链)。缺席 = 本部署没有 device 车道。 */
@@ -116,8 +117,8 @@ export interface ExecutionEnvCtx {
      *  (`late-binds.ts`),工厂在 run 期才求值。装配(第 5 段)在有存储后端时传、没有时不传(起服门据此判);不传(含只装别的车道的嵌入 /
      *  测试)⇒ 读不到行 ⇒ k8s 空间车道按「住客读不到」不开,每 env 一行 `workspace_space_unavailable`(响亮,不静默)。 */
     spaceCommits?: () => SpaceCommitRows | undefined;
-    /** k8s 工作区空间的住客读:会话店的按 id 读(`incarnationReadOf(sessionStore)`,第 5 段判一次、与起服门同一只)。不传 ⇒ 同上,不开、响亮。 */
-    incarnationOf?: IncarnationRead;
+    /** k8s 工作区空间的住客读:会话店的按 id 读(`headReadOf(sessionStore)`,第 5 段判一次、与起服门同一只)。不传 ⇒ 同上,不开、响亮。 */
+    headOf?: HeadRead;
 }
 export declare function createExecutionEnv(ctx: ExecutionEnvCtx): {
     perTaskImage: PerTaskImageRegistry;

package/dist/boot/execution-env.js

@@ -1,7 +1,8 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { createHostLspManager } from "../host-lsp-manager.js";
-import { sandboxSendLaneEnabled, TaskEnvRegistry } from "../capabilities/sandbox-file-send.js";
+import { TaskEnvRegistry } from "../capabilities/sandbox-file-send.js";
+import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import { SessionEnvironmentSelection } from "../capabilities/select-environment-tool.js";
 import { createE2bLspManager } from "../lsp/e2b-manager.js";
 import { evictLspOnDestroy } from "../lsp-evict.js";
@@ -15,7 +16,7 @@ import { createRunWorkspaceSnapshotSeat } from "../fleet/workspace-snapshot-resi
 import { createSpaceCommitFence } from "../workspace-space-commit.js";
 import { localDockerExecutionEnvFactory } from "../plugins/remote-env-local-docker.js";
 import { sshExecutionEnvFactory } from "../plugins/remote-env-ssh.js";
-import { isRemoteScratchpadLane, withRemoteScratchpad } from "../plugins/remote-scratchpad.js";
+import { withRemoteScratchpad } from "../plugins/remote-scratchpad.js";
 import { FileSchedulerBackend, defaultSchedulerStorePath } from "../plugins/scheduler-support.js";
 import * as facts from "../capability-facts.js";
 import { materializeAttachmentsInto } from "../plugins/task-attachment-store.js";
@@ -23,12 +24,13 @@ import { reapOrphanWorktrees, withWorktreeIsolation } from "../plugins/worktree-
 import { derivePkgSourceEnv } from "../sandbox-pkg-source.js";
 import { effectiveHostWorkspace } from "../task-cwd.js";
 import { taskInheritEnvRefusal } from "../hosted-posture.js";
+import { sessionFaceOfHead } from "../session-incarnation.js";
 import { createCacheMissMemory } from "../workspace-cache.js";
 import { workspaceSnapshotTimeoutOf } from "../workspace-space.js";
 import { sayEgressPolicyReading } from "../sandbox-egress-policy.js";
-import { isSandboxPathAdjudicationLane, sandboxPathEnvSlots, withSandboxPathEnvSlot } from "./deferred-sandbox-path-env.js";
+import { sandboxPathEnvSlots, withSandboxPathEnvSlot } from "./deferred-sandbox-path-env.js";
 import { LANE_HOME_UNDECLARED_EVENT, createLaneHomeAbsenceReporter } from "../lane-home-probe.js";
-import { REMOTE_EXEC_PROVIDER_WORDS, buildUndeclaredHomeNote, executionLaneHomeDir, executionLaneOf, isSingleMachineDefaultLane, laneBindsReads, laneIsolated } from "../execution-lane-caps.js";
+import { REMOTE_EXEC_PROVIDER_WORDS, buildUndeclaredHomeNote, executionLaneHomeDir, executionLaneOf, laneBindsReads, laneIsolated } from "../execution-lane-caps.js";
 function boundedSessionSetter(map, maxEntries) {
     return (sid, value) => {
         map.delete(sid);
@@ -132,14 +134,14 @@ const INCARNATION_READ_TIMEOUT = "incarnation_read_timeout";
 async function occupantOf(seats, sessionId, taskId, boundMs) {
     let answer;
     try {
-        const read = seats.incarnationOf;
+        const read = seats.headOf;
         answer =
             read === undefined
                 ? undefined
-                : await boundedStoreCall(() => read(sessionId), {
+                : sessionFaceOfHead(sessionId, await boundedStoreCall(() => read(sessionId), {
                     ms: boundMs,
                     onTimeout: () => Object.assign(new Error(`session occupant read did not answer within ${boundMs}ms`), { code: INCARNATION_READ_TIMEOUT }),
-                });
+                }))?.incarnation;
     }
     catch (e) {
         const code = e?.code;
@@ -147,8 +149,6 @@ async function occupantOf(seats, sessionId, taskId, boundMs) {
     }
     if (answer === undefined)
         return { unread: "incarnation_unknown" };
-    if (typeof answer !== "string" || answer === "")
-        return { fault: "incarnation_read_failed" };
     const rows = seats.spaceCommits();
     return rows !== undefined ? { incarnation: answer, fence: createSpaceCommitFence(rows, answer, taskId) } : { unread: "incarnation_unknown" };
 }
@@ -158,7 +158,7 @@ function spaceOff(store) {
 }
 export function assertWorkspaceSpaceReadable(space, seats, cache, sessionStoreLabel) {
     if (space.available && persistNeedsOccupant(space.policy.persist)) {
-        const missing = seats.incarnationOf === undefined ? `the session store (${sessionStoreLabel}) has no by-id occupant read (incarnationOf)`
+        const missing = seats.headOf === undefined ? `the session store (${sessionStoreLabel}) has no by-id occupant read (headOf)`
             : seats.spaceCommits === undefined ? `this deployment has no store backend to hold the space's commit rows (the session store is ${sessionStoreLabel})`
                 : undefined;
         if (missing === undefined)
@@ -169,9 +169,9 @@ export function assertWorkspaceSpaceReadable(space, seats, cache, sessionStoreLa
             "DB_BACKEND=memory has none), or set WORKSPACE_PERSIST=off (the default is space), and restart");
         return;
     }
-    if (cache.available && (seats.incarnationOf === undefined || seats.spaceCommits === undefined)) {
-        const missing = seats.incarnationOf === undefined
-            ? `the session store (${sessionStoreLabel}) has no by-id occupant read (incarnationOf)`
+    if (cache.available && (seats.headOf === undefined || seats.spaceCommits === undefined)) {
+        const missing = seats.headOf === undefined
+            ? `the session store (${sessionStoreLabel}) has no by-id occupant read (headOf)`
             : `this deployment has no store backend to hold the space durably (the session store is ${sessionStoreLabel})`;
         throw new Error(`WORKSPACE_CACHE=volume but ${missing} [workspace-space-unreadable]: ` +
             "the k8s build-cache volume belongs to the workspace space, which is keyed by the session occupant, so here no run would get its volume while " +
@@ -187,7 +187,7 @@ function persistNeedsOccupant(persist) {
     }
 }
 function buildRealSystemNote(remoteExec) {
-    if (!isSingleMachineDefaultLane(remoteExec))
+    if (!DEPLOYMENT_SHAPE_PREDICATES.singleMachineDefaultLane.holds({ remoteExec }))
         return "non-isolated target — actions are permanent; rely on the policy gate + HITL (design/61 §5)";
     const sandboxLanes = REMOTE_EXEC_PROVIDER_WORDS.filter((lane) => laneIsolated(lane)).join("|");
     return ("hands run on this machine with no OS sandbox (single-machine default: REMOTE_EXEC unset, CONFIG_PROVIDER=local) — actions are permanent, " +
@@ -245,7 +245,7 @@ export function createExecutionEnv(ctx) {
             logger,
             ...((env) => (env !== undefined ? { podEnv: env } : {}))(buildSandboxLaneEnv(config, config.remoteExec.sandboxEnv)),
         };
-        executionEnvFactory = createK8sRunEnvFactory(k8sCfg, { imageOf: (sid) => perTaskImage.get(sid), incarnationOf: ctx.incarnationOf, spaceCommits: ctx.spaceCommits ?? (() => undefined) });
+        executionEnvFactory = createK8sRunEnvFactory(k8sCfg, { imageOf: (sid) => perTaskImage.get(sid), headOf: ctx.headOf, spaceCommits: ctx.spaceCommits ?? (() => undefined) });
         if (k8sCfg.cache !== undefined || k8sCfg.s3Snapshot !== undefined)
             spaceReclaimer = createSpaceReclaimer(k8sCfg);
         void checkSandboxEgressPolicy(k8sCfg)
@@ -341,7 +341,7 @@ export function createExecutionEnv(ctx) {
             ...(config.remoteExec.env ? { env: config.remoteExec.env } : {}),
         });
     }
-    if (executionEnvFactory && isRemoteScratchpadLane(config.remoteExec?.provider)) {
+    if (executionEnvFactory && DEPLOYMENT_SHAPE_PREDICATES.remoteScratchpad.holds(config)) {
         executionEnvFactory = withRemoteScratchpad(executionEnvFactory, logger);
     }
     if (config.worktreeIsolation && executionEnvFactory) {
@@ -387,8 +387,7 @@ export function createExecutionEnv(ctx) {
         }
     }
     const sendUserFileTaskEnvs = (() => {
-        const provider = config.remoteExec?.provider;
-        if (!config.sendUserFile || !executionEnvFactory || !sandboxSendLaneEnabled(provider, config.requirePrincipal))
+        if (!config.sendUserFile || !executionEnvFactory || !DEPLOYMENT_SHAPE_PREDICATES.sandboxSendUserFile.holds(config))
             return undefined;
         const registry = new TaskEnvRegistry();
         executionEnvFactory = registry.wrapFactory(executionEnvFactory);
@@ -405,13 +404,12 @@ export function createExecutionEnv(ctx) {
             return env;
         };
     }
-    if (executionEnvFactory && isSandboxPathAdjudicationLane(config.remoteExec?.provider)) {
+    if (executionEnvFactory && DEPLOYMENT_SHAPE_PREDICATES.sandboxPathAdjudication.holds(config)) {
         executionEnvFactory = withSandboxPathEnvSlot(executionEnvFactory, sandboxPathEnvSlots, logger);
     }
     if (executionEnvFactory) {
         const isolated = laneIsolated(executionLaneOf(config.remoteExec.provider));
-        const suspendable = config.remoteExec.provider === "e2b" ||
-            (config.remoteExec.provider === "k8s" && !!config.remoteExec.s3Snapshot);
+        const suspendable = DEPLOYMENT_SHAPE_PREDICATES.suspendableHands.holds(config);
         const sandboxEnvKeys = forwardedSandboxEnvKeys(config.remoteExec);
         logger.info("remote_exec_enabled", { provider: config.remoteExec.provider, isolated, suspendable, ...(sandboxEnvKeys.length > 0 ? { sandboxEnvKeys } : {}) });
         if (!isolated)

package/dist/boot/fatal-exit.d.ts

@@ -9,8 +9,8 @@ export declare function buildFatalErrorText(err: unknown): string;
 /**
  * 进程级 fatal 出口的**唯一一只腿**:同一只 {@link buildFatalErrorText} 产物写两个面,然后按崩溃码退。
  *
- * ── 病(S-555,test [ref] P2)────────────────────────────────────────────────────────────────────
- * 出口过去只有那条 JSON 行。而拒启文案是**多行**的 —— S-547 的列集对账会生成
+ * ── 病([ref],test [ref] P2)────────────────────────────────────────────────────────────────────
+ * 出口过去只有那条 JSON 行。而拒启文案是**多行**的 —— [ref] 的列集对账会生成
  * `ALTER TABLE <表> ADD COLUMN <列定义>;`,它存在的全部理由就是「运维直接粘进 psql」;塞进 JSON 字符串后
  * 整段变成一串 `\n` 转义,**粘不走**。dist 里也没有 pretty / `isTTY` 分支去把它摊开(有也不该有:出口的
  * 可读性不该取决于终端是谁)。

package/dist/boot/late-binds.d.ts

@@ -1,5 +1,5 @@
 /**
- * 晚绑席(S-151 十段切分的**唯一**跨段可变面)—— 四只 cell,读点在前段、写点在后段。
+ * 晚绑席([ref] 十段切分的**唯一**跨段可变面)—— 四只 cell,读点在前段、写点在后段。
  *
  * 为什么是模块级 live binding 而不是 ctx 字段:读点的原文是**裸标识符**(`() => runStore`、
  * `() => parkedAskRedeem`),而 ctx 字段是**快照** —— 把读点改成 `ctx.runStore` 就是正文改写,

package/dist/boot/leader.d.ts

@@ -23,6 +23,8 @@ export interface LeaderCtx {
     toolResultStore: ToolResultStoreFull | undefined;
     sessionStore: ReturnType<typeof createSessionStore>;
     checkpointStore: CheckpointStoreFull | undefined;
+    /** [ref]:停驻行凭据的封签器(与 HTTP 面 `ServiceDeps.checkpointCtxSealing` 同一只;起服第 6 段已对「店在、它不在」拒启)。必填键,值可为 undefined。 */
+    checkpointCtxSealing: import("../http/checkpoint-ctx.js").CheckpointCtxSealing | undefined;
     /** [ref] 件B/C/D([ref],codex R2-F1):部署治理三座席 —— leader 车道的每一只 Runner 都要带上它,
      *  否则开了 leader 端点的部署就有一条在部署治理**之外**的执行面(合规否决/锁都够不着)。 */
     governanceSeams: import("./governance-seams.js").GovernanceSeams;

package/dist/boot/leader.js

@@ -22,7 +22,7 @@ export function assertLeaderDurableStore(leaderEnabled, hasLeaderRunStore) {
         "(#193 车4 件2 capability gate; the DB_BACKEND literal check in config.ts is the intent half of the same rule)");
 }
 export function createLeaderFace(ctx) {
-    const { config, logger, brain, pricing, executionEnvFactory, toolResultStore, sessionStore, checkpointStore, governanceSeams } = ctx;
+    const { config, logger, brain, pricing, executionEnvFactory, toolResultStore, sessionStore, checkpointStore, checkpointCtxSealing, governanceSeams } = ctx;
     const leaderMinio = process.env.MINIO_ENDPOINT && process.env.MINIO_ACCESS_KEY && process.env.MINIO_SECRET_KEY
         ? {
             s3: {
@@ -74,6 +74,7 @@ export function createLeaderFace(ctx) {
                     durable: () => hasApprovalListIntent(config)
                         ? {
                             checkpointStore,
+                            ctxSealer: checkpointCtxSealing,
                             requireApproval: config.approvalRequire,
                             deny: config.approvalDeny,
                             autoBudget: config.approvalAutoBudget,

package/dist/boot/memory-boundary.d.ts

@@ -95,7 +95,7 @@ export interface MemoryWriteBoundaryFacts {
      *  core 7.16.0([ref])之后写家还要再深一层(`<平面>/<label>`),但 label 归引擎注册簿,boot 期说不出口;
      *  平面是**包含关系上等价**的那一只(家恒为平面的直接子目录),所以判据停在平面,不猜 label。 */
     memoryRoot: string | undefined;
-    /** 执行车道名,只进文案(归一读口 `executionLaneOf` 的答案;S-602 起不在调用点手写 `?? "in-process"`)。 */
+    /** 执行车道名,只进文案(归一读口 `executionLaneOf` 的答案;[ref] 起不在调用点手写 `?? "in-process"`)。 */
     lane: ExecutionLane;
     /** 该车道的文件工具是否跑在**本机** fs 上(in-process / `REMOTE_EXEC=host`)。false = 沙箱盘,与记忆根分平面。
      *  ⚠️ 这一位管的是**文件平面**,与下面的 `coreRemoteExecutionEnv` 是**两根轴**,别合并(codex round2
@@ -119,7 +119,7 @@ export interface MemoryWriteBoundaryFacts {
     containmentRoots: readonly string[];
 }
 /**
- * S-602 —— 审计的**车道那四位**由本函数从能力表派生(boot/stores.ts 的装配点只调它,不再就地手写):
+ * [ref] —— 审计的**车道那四位**由本函数从能力表派生(boot/stores.ts 的装配点只调它,不再就地手写):
  * 改前 stores 里是 `lane === undefined || lane === "host"`(同义折,门 D R3)+ `config.remoteExec !== undefined`
  * (座位上的裸缺席判,R4)+ `lane ?? "in-process"` ×3(R2)。两根轴各读表里各自那一位,不合并:
  *  · `hostSemanticsLane` ⇐ `hostFilePlane`(文件平面在不在本机);