@sema-agent/server 7.146.0 → 7.148.0

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

@@ -18,12 +18,10 @@ export declare function buildFatalErrorText(err: unknown): string;
  * ── 修 ─────────────────────────────────────────────────────────────────────────────────────────
  * **同一只产物**再原样多行写一份到 stderr。刻意不做的三件:不铸第二份文案(两份措辞必然分叉)、不加
  * pretty 旋钮(一个只有出错时才走的出口不该有配置面)、JSON 行**照旧**(机读面零回退,scraper 不动)。
- * 两个面都在 stderr,次序=先机器行后人读段。**这个次序还承重**:`createLogger()` 的构造会装上 stdio 的
- * EPIPE 无害化监听(见 `observability/logger.ts` 那段注 —— 宿主把 stderr 接管道又先退时,下一次写会发一个
- * 异步 `'error'`,无监听即致命),所以那条裸 `process.stderr.write` **必须**排在它之后;同步抛由下面的
- * `try/finally` 兜住。
+ * 两个面都在 stderr,次序=先机器行后人读段;两个面都经日志出口接缝(`observability/logger.ts`:同一只秘密形筛、同一只
+ * 物理写,EPIPE 无害化监听由接缝在每次写之前装好),同步抛由下面的 `try/finally` 兜住。
  *
- * 全仓两个 fatal 出口(`main.ts` 的 `main().catch` 与 `run-local.ts` 的同名尾巴)都经这里 —— 后者此前
+ * 全仓三个 fatal 出口(`main.ts` 的 `main().catch`、起服前探针 `model-plane-probe.ts` 的同名尾巴与 `run-local.ts` 的那一只)都经这里 —— run-local 此前
  * 连形状律都没过(裸 `String(err)`),两处各写一遍正是「同类不同命」的土壤。
  */
 export declare function fatalExit(err: unknown): never;

package/dist/boot/fatal-exit.js

@@ -1,5 +1,5 @@
 import { redactSecrets } from "../trace/redact.js";
-import { createLogger } from "../observability/logger.js";
+import { createLogger, writeLogText } from "../observability/logger.js";
 export function buildFatalErrorText(err) {
     const code = err instanceof Error ? err.code : undefined;
     return redactSecrets(typeof code === "string" && err instanceof Error ? `${err.name} [${code}]: ${err.message}` : String(err));
@@ -8,7 +8,7 @@ export function fatalExit(err) {
     const text = buildFatalErrorText(err);
     try {
         createLogger().error("fatal", { err: text });
-        process.stderr.write(text + "\n");
+        writeLogText("stderr", text);
     }
     finally {
         process.exit(1);

package/dist/boot/governance-seams.d.ts

@@ -48,7 +48,7 @@
  *
  * ## 件D 的边界(成文,别读成「数据会被删」)
  *
- * 三只被托管的 SQL 店(session / checkpoint / tool-result)的 `retention` 声明读一个事实 —— 留存扫车道开不开(`plugins/retention-store-sql.ts` 的
+ * 三只被托管的 SQL 店(session / checkpoint / tool-result)的 `retention` 声明读一个事实 —— 留存扫车道开不开(`plugins/retention-declaration.ts` 的
  * `retentionSweepRuns`):开 ⇒ `managed`,关(缺省)⇒ `none`;local 形的店恒声明 `none`。删除的执行面是扫车道(`boot/retention-lane.ts`)与 SQL 店上的
  * 执行器,不在本装配点。所以本装配点对件D 只做两件事:①把策略与执行器递给 core 的启动期校验
  * (`assertRetentionCapability` —— 配对由引擎一个判官判:店声明 `managed` 而部署不跑执行器、执行器不是执行器,锁不锁都拒;锁着 + 店不能删 ⇒ 拒启,
@@ -83,7 +83,7 @@ export interface GovernanceSeamsCtx {
     /**
      * 交给引擎启动检查的留存执行器 —— 本部署跑扫车道 ⇒ 那只执行器(`backend.retention`),不跑 ⇒ `null`(必填:漏递即编译红,
      * 引擎对 `undefined` 也拒启)。「店说 managed」与「有执行器」的配对由引擎一个判官判(引擎 7.58.0:锁不锁都判);
-     * 店的词与这一格读同一个事实(`retention-store-sql.ts` 的 `retentionSweepRuns`),本仓不再另判一遍。
+     * 店的词与这一格读同一个事实(`retention-declaration.ts` 的 `retentionSweepRuns`),本仓不再另判一遍。
      */
     retentionExecutor: ManagedRetentionCapability | null;
 }

package/dist/boot/leader.d.ts

@@ -81,5 +81,20 @@ export declare function leaderK8sMinioGap(leaderEnabled: boolean, leaderProvider
  * 而承担的方式是重复的真实推送。
  */
 export declare function assertLeaderDurableStore(leaderEnabled: boolean, hasLeaderRunStore: boolean): void;
+/**
+ * leader 的对象存储座(F2(a) 工厂模式的 diff-out:worker 自传补丁到 `<桶>/leader-diff/…`,leader 用同桶的 presigned GET 取回)。纯数据:三键齐(`MINIO_ENDPOINT` /
+ * `MINIO_ACCESS_KEY` / `MINIO_SECRET_KEY`)⇒ `{ s3 }`,否则 `{}`(静态兼容模式;k8s 车道要它)。
+ * 桶 = `MINIO_BUCKET`,缺席 = 工作区快照桶的**缺省名**(`WORKSPACE_SNAPSHOT_BUCKET_DEFAULT`,同一只常量)。两根旋钮各自独立:改了 `WORKSPACE_SNAPSHOT_BUCKET` 的部署,
+ * leader 的补丁仍落 `MINIO_BUCKET` 那一只 —— 要同桶就两根同设(目录两行写明)。
+ */
+export declare function buildLeaderObjectStore(env?: NodeJS.ProcessEnv): {
+    readonly s3?: {
+        endpoint: string;
+        bucket: string;
+        accessKey: string;
+        secretKey: string;
+        region?: string;
+    };
+};
 export declare function createLeaderFace(ctx: LeaderCtx): ReturnType<typeof createLeaderEndpoint> | undefined;
 //# sourceMappingURL=leader.d.ts.map

package/dist/boot/leader.js

@@ -1,8 +1,10 @@
 import { createLeaderEndpoint } from "../leader/endpoint.js";
-import { createLeaderRunVisibility } from "../http/owner-access.js";
-import { createLeaderRunner } from "../leader/wire.js";
-import { buildDeploymentPostureSeats } from "./runner-deps.js";
+import { seesRunAs } from "../http/owner-access.js";
+import { claimCallerOf } from "../security.js";
+import { createLeaderParkExpirer, createLeaderRunner } from "../leader/wire.js";
+import { buildDeploymentPostureSeats, buildHandsBand } from "./runner-deps.js";
 import { hasApprovalListIntent } from "../approval.js";
+import { WORKSPACE_SNAPSHOT_BUCKET_DEFAULT } from "../object-store-buckets.js";
 export function leaderK8sMinioGap(leaderEnabled, leaderProvider, hasS3) {
     if (!(leaderEnabled && leaderProvider === "k8s" && !hasS3))
         return null;
@@ -21,20 +23,18 @@ export function assertLeaderDurableStore(leaderEnabled, hasLeaderRunStore) {
         "without it a retry starts a SECOND real git push. Fix the database (or unset LEADER_ENABLED) and restart " +
         "(#193 车4 件2 capability gate; the DB_BACKEND literal check in config.ts is the intent half of the same rule)");
 }
+export function buildLeaderObjectStore(env = process.env) {
+    const endpoint = env.MINIO_ENDPOINT;
+    const accessKey = env.MINIO_ACCESS_KEY;
+    const secretKey = env.MINIO_SECRET_KEY;
+    if (!endpoint || !accessKey || !secretKey)
+        return {};
+    return { s3: { endpoint, bucket: env.MINIO_BUCKET ?? WORKSPACE_SNAPSHOT_BUCKET_DEFAULT, accessKey, secretKey, ...(env.MINIO_REGION ? { region: env.MINIO_REGION } : {}) } };
+}
 export function createLeaderFace(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: {
-                endpoint: process.env.MINIO_ENDPOINT,
-                bucket: process.env.MINIO_BUCKET ?? "workspaces",
-                accessKey: process.env.MINIO_ACCESS_KEY,
-                secretKey: process.env.MINIO_SECRET_KEY,
-                ...(process.env.MINIO_REGION ? { region: process.env.MINIO_REGION } : {}),
-            },
-        }
-        : {};
-    const leaderProvider = config.remoteExec?.provider;
+    const leaderMinio = buildLeaderObjectStore();
+    const leaderProvider = config.remoteExec.provider;
     const leaderRunStore = ctx.backend?.leaderRun?.();
     assertLeaderDurableStore(config.leaderEnabled, leaderRunStore !== undefined);
     const minioGap = leaderK8sMinioGap(config.leaderEnabled, leaderProvider, "s3" in leaderMinio);
@@ -60,6 +60,7 @@ export function createLeaderFace(ctx) {
             ...(ctx.promptSource ? { promptSource: ctx.promptSource } : {}),
             ...(ctx.onError ? { onError: ctx.onError } : {}),
             mods: ctx.deploymentMods,
+            hands: buildHandsBand(config, undefined),
             fanoutEnabled: config.leaderFanoutEnabled,
             ...(process.env.MODEL_ROUTER_ID ? { routerModel: process.env.MODEL_ROUTER_ID } : {}),
             ...(leaderProvider === "e2b" ? { e2bApiKey: config.remoteExec.apiKey } : {}),
@@ -87,7 +88,8 @@ export function createLeaderFace(ctx) {
             logger,
             requiredFields: ["objective", "durableRemote", "testCmd", "seedCmd", "baseSha"],
             ...(leaderRunStore ? { store: leaderRunStore } : {}),
-            ownerVisible: createLeaderRunVisibility(config),
+            ownerVisible: (subject, owner) => seesRunAs("run.leader", claimCallerOf(subject ?? undefined, config), owner ?? null),
+            ...(checkpointStore ? { expireWorkerParks: createLeaderParkExpirer(checkpointStore) } : {}),
         })
         : undefined;
     if (leaderEndpoint)

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

@@ -14,9 +14,9 @@
  * 这条链**结构上**走不通」——那句必须说出来。围栏根算不出来时**不说话**(判不了就闭嘴,别把猜测当告警)。
  *
  * 🔴 **已登记的判据限度(不在本批射程,别把它读成「判据已闭合」)**:② 号 warn 今天唯一算得出围栏根的
- * 腿是 `REMOTE_EXEC` 未设的 in-process 形(`boot/stores.ts` 的 `containmentRoots`),而**恰恰是这条腿
+ * 腿是无手的 `none` 形(`boot/stores.ts` 的 `containmentRoots`),而**恰恰是这条腿
  * 没有文件工具** —— 亲读装的这台 core:`prepare-execution-env.js` 的
- * `handsEnabled = ownedEnv !== undefined || deps.executionEnv !== undefined`,本仓不设 `REMOTE_EXEC` 时
+ * `handsEnabled = ownedEnv !== undefined || deps.executionEnv !== undefined`,`REMOTE_EXEC=none` 时
  * `executionEnvFactory` 恒 `undefined` ⇒ `handsEnabled=false` ⇒ `prepareHandsMount` 整个不跑。所以这条
  * warn 描述的失败形(「模型照提示词去 Write,拿回 `path_not_in_root`」)在该腿上并不成立:真相是**一只
  * 文件工具都没有**,而按它给的第一条恢复路径(把根挪进 workspace)会让 warn 闭嘴却仍然写不成。
@@ -54,7 +54,7 @@
  * `TaskSpec.memoryPersistenceCapable` 一条路进去(`boot/resolve-spec.ts` 直通),我方显式**不铸**受限会话、
  * 也**不投**这个读面(硬造一个消费点 = 造给自己看的 wire 键)。哪天真要在诊断面露它,先有消费方需求。
  */
-import { type ExecutionLane, type RemoteExecProvider } from "../execution-lane-caps.js";
+import { type ExecutionLane } from "../execution-lane-caps.js";
 import type { MemoryEngineBackend } from "@sema-agent/settings-schema/execution-lanes";
 /** boot 期可知的全部事实。每一位都必须由调用点从真配置/真装配结果取,禁在本模块内重算(重算=第二真源)。 */
 export interface MemoryWriteBoundaryFacts {
@@ -66,9 +66,9 @@ export interface MemoryWriteBoundaryFacts {
      *  core 7.16.0([ref])之后写家还要再深一层(`<平面>/<label>`),但 label 归引擎注册簿,boot 期说不出口;
      *  平面是**包含关系上等价**的那一只(家恒为平面的直接子目录),所以判据停在平面,不猜 label。 */
     memoryRoot: string | undefined;
-    /** 执行车道名,只进文案(归一读口 `executionLaneOf` 的答案;[ref] 起不在调用点手写 `?? "in-process"`)。 */
+    /** 执行车道名,只进文案(已合成配置上的车道词,直读)。 */
     lane: ExecutionLane;
-    /** 该车道的路径是不是本机的文件(执行环境块 `hostLocalPaths`:in-process 的桩块 / `REMOTE_EXEC=host` 为真)。false = 沙箱 / 远端 / 设备盘,
+    /** 该车道的路径是不是本机的文件(执行环境块 `hostLocalPaths`:`none` 的桩块 / `REMOTE_EXEC=host` 为真)。false = 沙箱 / 远端 / 设备盘,
      *  与记忆根分平面 —— 引擎在这一形上不教 `# Memory` 写指令(除非部署声明 `memoryPersistenceCapable: true`),判的是同一键。 */
     hostSemanticsLane: boolean;
     /** 部署声明 `MEMORY_PERSISTENCE_CAPABLE`(三态)。两极都让本模块闭嘴,但理由不同 —— 见各臂注释。 */
@@ -84,16 +84,16 @@ export interface MemoryWriteBoundaryFacts {
 }
 /**
  * 审计的**车道三位**由本函数派生(boot/stores.ts 的装配点只调它,不就地手写):
- *  · `lane` ⇐ 归一读口 `executionLaneOf`;
+ *  · `lane` ⇐ 已合成配置上的车道词;
  *  · `hostSemanticsLane` ⇐ 执行环境块 `hostLocalPaths`(唯一作者 `capabilitiesFor`;引擎撤不撤写指令读的是同一键);
- *  · `containmentRoots` ⇐ 只有 in-process 给得出(见下)。
+ *  · `containmentRoots` ⇐ 只有无手车道(`none`)给得出(见下)。
  * `processCwd` 由调用点传(stores 传 `process.cwd()`),本函数保持纯。
  */
 export declare function buildMemoryBoundaryLaneFacts(config: {
-    readonly remoteExec?: {
-        readonly provider: RemoteExecProvider;
+    readonly remoteExec: {
+        readonly provider: ExecutionLane;
         readonly s3Snapshot?: unknown;
-    } | undefined;
+    };
 }, processCwd: string): Pick<MemoryWriteBoundaryFacts, "lane" | "hostSemanticsLane" | "containmentRoots">;
 /** 一条启动告警:`tag` 进日志事件名(可被运维按名过滤/告警),`detail` 是给人读的整句(含恢复路径)。 */
 export interface MemoryWriteBoundaryWarning {
@@ -106,7 +106,7 @@ export interface MemoryWriteBoundaryWarning {
  * ① **路径不是本机的车道**(块 `hostLocalPaths` 为假:沙箱 / 远端 / 设备;记忆引擎在这里只可能因为 `MEMORY_ENGINE_REMOTE_LANE=allow`
  *    或 DB 记忆面才在):引擎不教 `# Memory` 写指令(手带够不着本机的记忆根),官方恢复路径是声明 `memoryPersistenceCapable: true`。
  *    未声明 ⇒ 点名 warn,把恢复旋钮写进句子里。
- * ② **路径是本机的车道**(in-process / host):记忆根不在任何一个已知围栏根内 ⇒ 模型被教着往一个 fs 工具够不到的路径写。
+ * ② **路径是本机的车道**(none / host):记忆根不在任何一个已知围栏根内 ⇒ 模型被教着往一个 fs 工具够不到的路径写。
  *
  * 两极声明都让本模块闭嘴,但理由不同,别合并:
  *  · `true` = operator 自证有推断看不见的持久通道(共享挂载 / 自定义 writer),我们的结构判断本就不该

package/dist/boot/memory-boundary.js

@@ -1,11 +1,11 @@
 import { resolve } from "node:path";
-import { capabilitiesFor, executionLaneOf } from "../execution-lane-caps.js";
+import { capabilitiesFor } from "../execution-lane-caps.js";
 export function buildMemoryBoundaryLaneFacts(config, processCwd) {
-    const lane = executionLaneOf(config.remoteExec?.provider);
+    const lane = config.remoteExec.provider;
     return {
         lane,
         hostSemanticsLane: capabilitiesFor(config).hostLocalPaths,
-        containmentRoots: lane === "in-process" ? [processCwd] : [],
+        containmentRoots: capabilitiesFor(config).io ? [] : [processCwd],
     };
 }
 function isInside(child, root) {

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

@@ -13,7 +13,7 @@ type ConsolidationSeatOptions = ReturnType<typeof resolveMemoryConsolidationDriv
 /** D3 投影的座标签闭集。`role:<name>` 里的 name 只可能是 core 的 role 链两跳之一。 */
 export type ConsolidationSeatLabel = "explicit" | "role:consolidate" | "role:summarize";
 /** {@link buildConsolidationValveAudit} 的告警名闭集(事件名进日志 ⇒ 运维可按名过滤/告警)。 */
-export type ConsolidationValveWarningTag = "memory_consolidation_valve_unreachable" | "memory_consolidation_run_credential_gated";
+export type ConsolidationValveWarningTag = "memory_consolidation_run_credential_gated";
 /** {@link resolveConsolidationValve} 的起服提示名闭集([ref] / [ref];事件名进日志 ⇒ 运维可按名过滤/告警)。 */
 export type ConsolidationValveNoticeTag = "memory_consolidation_default_off_no_cheap_model" | "memory_consolidation_on_main_model";
 /**
@@ -55,6 +55,8 @@ export type ConsolidationSeatBilling = {
     readonly kind: "unresolvable";
     readonly fault: string;
 };
+/** 整理席解座的输入 = core 解析器的输入(凭据席除外 —— 由本函数按冻结的钥匙表铸)+ 部署的两张 per-model 钥匙表(与 `models` 同一代,同一刻读)。 */
+export type ConsolidationSeatDeps = Omit<MemoryConsolidationDriverDeps, "getApiKeyAndHeaders"> & Pick<ServiceConfig, "modelApiKeyEnv" | "modelApiKeys">;
 /** 座解析的产物:core 的 options 原样 + 给投影用的两位自证。 */
 export interface ConsolidationDriverSeat {
     /** `runMemoryConsolidationDriver` 第三参的**模型席那一半**,core 的 `resolveMemoryConsolidationDriver` 原样产出(写判官另由操作面的座给)。 */
@@ -81,7 +83,7 @@ export interface ConsolidationDriverSeat {
  * 体内的注 —— 那里才是它真正生效的地方,写在这里会随实现漂。
  * (探针只构造闭包、不发任何请求、无副作用。)
  */
-export declare function resolveConsolidationDriverSeat(deps: MemoryConsolidationDriverDeps): ConsolidationDriverSeat;
+export declare function resolveConsolidationDriverSeat(input: ConsolidationSeatDeps): ConsolidationDriverSeat;
 /**
  * [ref] 波 0([ref] §3)—— 整理驱动席的 **restart 读数**。过渡件:**波 1 转热后删**(那时每轮 run 起手
  * 现取当前代的席,不再有 boot 烤死的席,这只表也就没有要比的东西了)。
@@ -117,6 +119,8 @@ export interface ConsolidationSeatWatch {
 }
 /** 解席的输入面 = boot 期真席用的同三件(活引用:refresh 就地换代,`read()` 每次现取)。 */
 export type ConsolidationSeatPlane = Pick<MemoryConsolidationDriverDeps, "models" | "tiers" | "roles">;
+/** 重启读数的输入面 = 解席三件 + 座随之冻结的两张钥匙表(座位指纹带凭据身份)。 */
+export type ConsolidationSeatWeldPlane = ConsolidationSeatPlane & Pick<ServiceConfig, "modelApiKeyEnv" | "modelApiKeys">;
 /**
  * **每 scope 单飞**(codex 交叉复审 [high],验真后修)—— 同一 scope 上在飞的那一轮被后来者**并入**,
  * 而不是各起一轮。`create*`:返回带状态的活对象。
@@ -258,7 +262,7 @@ export declare function resolveConsolidationValve(input: {
 export declare function createConsolidationValveWatch(input: {
     driver: MemoryConsolidationDriverConfig;
     unwirable: Parameters<typeof resolveConsolidationValve>[0]["unwirable"];
-    plane: () => ConsolidationSeatPlane;
+    plane: () => ConsolidationSeatWeldPlane;
 }): ConsolidationSeatWatch | undefined;
 /**
  * 阀门的**装配点**(车PI 修复轮 ⑦(a)(e):boot 第 4 段调它,测试调同一只 —— 不在测试里手抄接线)。`create*`:产出带行为的 watch。
@@ -279,7 +283,7 @@ export declare function createConsolidationValve(input: ConsolidationValveInput
 };
 /** 阀门判决的两件输入(装配点与纯判共用一只形 —— 两个入口递的是同一组事实)。 */
 export interface ConsolidationValveInput {
-    readonly config: Pick<ServiceConfig, "memoryConsolidationDriver" | "memoryEngineBackend" | "memoryProvenance" | "compliancePosture" | "models" | "tiers" | "roles">;
+    readonly config: Pick<ServiceConfig, "memoryConsolidationDriver" | "memoryEngineBackend" | "memoryProvenance" | "compliancePosture" | "models" | "tiers" | "roles" | "modelApiKeyEnv" | "modelApiKeys">;
     /** 只读两件:在不在(记忆引擎接没接线)、整理状态随不随后端走(引擎的 `memoryGovernanceDurability` 答)。 */
     readonly memoryEngine: {
         readonly backend: MemoryBackend;
@@ -301,38 +305,27 @@ export declare function judgeConsolidationValve(input: ConsolidationValveInput):
     unwirable: Parameters<typeof resolveConsolidationValve>[0]["unwirable"];
 };
 /**
- * 阀门上了场之后的**可达性**告警两条(自查 + codex 交叉复审;姿态=warn 不拒启)。
+ * 阀门上了场之后的**可达性**告警(自查 + codex 交叉复审;姿态=warn 不拒启)。
  *
- * ## 病(结构性,而且**只在**这条阀门够得着的那种部署上成立)
+ * ## 「没有运维」那一条为什么不在这里了
  *
- * consolidation 要后端自带引擎控制面归属 ⇒ 今天只有 file 记忆后端满足 ⇒ 本仓只在**单用户**形
- * (`REQUIRE_PRINCIPAL !== true`)上装配记忆引擎 —— 而那种部署的 `OPERATOR_PRINCIPALS` 通常是**空的**。
- * 没有运维名册(名单空且没有单用户声明 `OPERATOR_SINGLE_USER`)时 `explicitOperatorOk` 对任何身份恒假(「谁是 operator」的唯一读法:空名单绝不等于
- * 「人人都是 operator」),于是:阀门开着、启动成功、两口挂着、**每一次调用 501 `capability.operator_principals_required`**(运维面同一只拒发口;403 只留给名单非空而你不在名单上),
- * 能力位诚实地报 `false` —— 唯独运维不知道为什么,而他刚刚显式拧了一根写着 "on" 的旋钮。
- *
- * ## 为什么是 warn 而不是拒启(与 D1 的三条拒启臂**刻意不同档**)
- *
- * `OPERATOR_PRINCIPALS` 是**跨面共用**的部署级旋钮(adoption / retention-ops / memory-bundle /
- * memory-compliance / admin-drain 全在同一张名单上)。为一条阀门拒掉整台机器,比这条阀门本身的价值重;
- * 而那三条拒启臂拒的是「这台机器**结构上**跑不了这件事」(没有库 / 账会丢 / 折叠法铸不出标记),
- * 本条拒的是「配齐了但没人够得着」——后者是一次**配置遗漏**,补一行 env 即可,不该要一次重启失败来教。
- * 同族先例逐字:`permission_rules_lane_unavailable`(旋钮开着却上不了场 ⇒ 打一行,不拒启)。
- * 反过来说,**沉默**同样不行:那正是「设了但没生效」病族,而这一形连能力位都是诚实的假,唯一缺的
- * 就是一句把因果说清楚的话。
+ * 曾经还有一条「阀门够不着」告警(事件名已删,不再出现在日志里):阀门开着、两口挂着,而这台部署没有运维名册 ⇒ 两口对谁都 501。
+ * 它的在场条件今天在服务腿上不可达,前提链三环:① 显式开得起来的阀门要 file 记忆后端(SQL 两只孪生不发布控制面 ⇒ 第 4 段的
+ * {@link assertConsolidationDriverWirable} 拒启),而 file 记忆引擎只在单用户形上装配(`fileMemoryPlaneFor`);② 单用户形过了起服第 1 段就一定有运维
+ * (不变量 `operator-declaration-required`:`OPERATOR_SINGLE_USER=true` 或具名名单,都没有 ⇒ 第 1 段早拒;装运维面的兜底座 `createHttpServer` 同判);
+ * ③ 本函数的唯一调用点在服务腿第 6 段。读一个不可能状态的告警是死臂,随那条不变量一起退役(钉:`test/operator-declaration-required.test.ts` ⑥,
+ * 前提链每环一格,任何一环将来不成立 ⇒ 那一格红)。
  *
  * ## 只审**显式**开的阀门([ref] / [ref] 起)
  *
- * 两条告警的前提都是「运维**显式**拧了 on」(上面那句原话)——它们是一次**表态**够不着的诊断。出厂缺省**派生**开的
- * 那台(配了便宜模型的单用户部署)没有表态可审:引擎面的自动整理照跑(不走这两个口),手动口是一件它没要过的东西。
- * 照审的后果是每一台这样的部署升级后每次起服多两行 warn,点名一根它从没设过的 `MEMORY_CONSOLIDATION_DRIVER=on`,
- * 教它去配一个它不需要的操作面。判据读阀门判决的 `source`,不读表态原词(判决是阀门开关的唯一属主)。
+ * 告警的前提是「运维**显式**拧了 on」——它是一次**表态**够不着的诊断。出厂缺省**派生**开的那台(配了便宜模型的单用户部署)
+ * 没有表态可审:引擎面的自动整理照跑(不走手动口),手动口是一件它没要过的东西。照审的后果是每一台这样的部署升级后每次起服
+ * 多一行 warn,点名一根它从没设过的 `MEMORY_CONSOLIDATION_DRIVER=on`,教它去配一个它不需要的操作面。判据读阀门判决的 `source`,
+ * 不读表态原词(判决是阀门开关的唯一属主)。
  */
 export declare function buildConsolidationValveAudit(input: {
     /** 阀门判决({@link resolveConsolidationValve} 的 `enabled` + `source`)。 */
     valve: Pick<ConsolidationValve, "enabled" | "source">;
-    /** 这台部署有没有运维名册(`operatorRosterPresent`:名单非空 ∨ 单用户声明)—— 判据不在本函数里另写一份。 */
-    operatorRosterPresent: boolean;
     /** 这台部署配了任何一把 service 凭证吗(`config.authToken` 或 `config.authTokens` 非空)。 */
     hasServiceAuth: boolean;
     /** 本地开发的显式逃生口(`ALLOW_UNAUTHED_WRITES=true`)。 */
@@ -414,35 +407,37 @@ export declare function assertAutoConsolidationWirable(input: {
  * 「这条路径能不能写」在引擎里只有**一只**判官(合成写判官:技能拒行 / 收窄折叠 / 调用方与继承策略 / 人的持久规则车道 / 组织车道,一条走法一个优先序)。
  * 引擎的自动整理腿(有腿:名册上的 `Write` 脸、引擎盖的豁免根、人的持久规则读者)与本腿(运维手动阀门:没有腿)用的是**同一个构造器** ——
  * 同样的行给同样的答案,本仓不手搭第二只({@link createOperatorValveWriteJudge} 恰一处调用它,见 `test/memory-consolidation-write-judge.test.ts` ⑥)。
+ * 判官**按次铸**:每一次真跑(单飞里起跑的那一次,并入的等待者不另铸)现铸一只,所以人读的是发起这一轮的那位。
  *
- * ## 本仓供的两个部署事实(其余键一律缺席,缺席的语义见引擎:那一层不存在)
+ * ## 本仓供的部署事实(其余键一律缺席,缺席的语义见引擎:那一层不存在)
  *
  *  · `ruleStoreProvider` = 部署唯一的那只合成规则店(`RunnerDeps.permissionRuleStore` 的同一个变量,装配第 4 段铸一次)。规则店没装配 ⇒ 缺席 ⇒ 没有规则层。
+ *  · 人(`principal` / `localOwnerDeclared`)= **发起这一轮的调用方**:带主体 ⇒ 读那个主体的桶;不带主体 ⇒ 读本机属主的桶,当且仅当部署声明了它
+ *    (`localOwnerDeclared` = Runner 下发的 `localOwnerRules` 同一只判据 `localOwnerRulesDeclared` 的答案;多租形不声明 ⇒ 匿名地板,而多租形的阀门口本来就要主体)。
+ *    整理 run 按 scope 单飞、可续跑:并入正在跑的那一轮的调用方用起跑者的判官(它们拿到的是同一份收执);续跑一条 pending run 的那一次,发起者就是这一次的调用方。
  *  · `anchors.home` = `executionLaneHomeDir(config)` —— `~/` 行的基,与引擎执行环境的 `homeDir` 座、下单 422 门、规则基 `taskHome` 是**同一只函数**
  *    (车道没有自己的 home 时诚实缺席;缺席 ⇒ 引擎读到人持有的 `~/` 收紧行时无处锚定 = 按异议处置,拒闭)。**刻意不另调 `os.homedir()`**:
- *    那会在非 host 车道上造出第二个读法 —— 阀门答「可解析」而腿内答「读不出」。⚠️ 今天这一键在生产座上**空转**:阀门不带主体(下面的 `principal`),
- *    引擎读匿名地板、不读任何人的持久行,「`~/` 行无锚 ⇒ 拒闭」走不到;留着它是为了主体有了来源之后不必再回来改这里。
- *
- * ## 刻意缺席的键(披露,不是遗漏)—— 三层没喂,所以这条腿仍是**响亮的放行座**(P-DEBT,见 {@link createOperatorValveWriteJudge})
- *
- *  · `principal` / `localOwnerDeclared`(人的持久规则层):阀门是 operator 面的一次调用,本仓没有一个能回答「这个库属于谁」的来源 ——
- *    单用户 + file 后端(阀门结构上能起的唯一形,见 {@link assertConsolidationDriverWirable})里记忆是部署级全局层 / 任务根散列的项目层,principal 标签从不分盘,
- *    本仓也从不声明 `localOwnerRules`;整理 run 又是按 scope 单飞、可续跑的持久作业,「谁的规则」对并入 / 续跑的调用方没有定义。
- *  · `callerPolicy`(部署的调用方策略层):`APPROVAL_REQUIRE` / `APPROVAL_DENY` / `AUTONOMY` / 敏感路径守卫集是**每任务现合成**的(`deployment-governance.ts`,
- *    读热可改的活配置,「禁 memoize」),没有部署级单例;boot 期铸一份喂进来就是冻结一份会过期的策略(收紧不生效 = 静默放行)。喂它需要一份设计:取哪几层、
- *    活配置怎么读、审批席取什么形;其中敏感路径层还要引擎的豁免根(`RunnerDeps.memoryEngineDir` 盖在每个请求上),而宿主构造器的输入没有这一位 —— 要向 core 请托,
- *    不在本层造第二条豁免根的读法。
- *  · `anchors.root`:阀门按 scope 跑,手里没有项目根 —— 项目层 scope 键是任务根的单向散列(`project-identity.ts` 的 `repo:<sha256[:24]>`),反推不出根;
- *    全局层根本没有根。⇒ 人持有的相对 deny / ask 行无处锚定 = 异议,拒闭(引擎契约:判官不猜一行原本指向哪里)。
+ *    那会在非 host 车道上造出第二个读法 —— 阀门答「可解析」而腿内答「读不出」。
  *
- *  所以今天这条腿的放行范围与 7.128.x 相同(人的规则、部署的审批名单 / 敏感路径守卫都拦不住手动阀门这一轮折叠);变的只是「判官不再是代答」—— 往后每喂一层,
- *  只在本函数加键,钉 = `test/memory-consolidation-write-judge.test.ts` ⑦。
+ * ## 刻意缺席的键(披露,不是遗漏)—— 这两样没喂,所以这条腿仍记一笔债(P-DEBT,见 {@link createOperatorValveWriteJudge})
+ *
+ *  · `callerPolicy`(部署的调用方策略层):腿上它是任务的整条部署治理链(审批名单 + 敏感路径守卫与誊本门 + 命令策略,经 `createDeploymentGovernanceInputs` /
+ *    `createApprovalBaselinePolicy` / `applyRuntimeGovernance` 同一组构造口铸)。只喂其中一层(例如只喂审批名单)= 这条腿上半条治理链 —— 构造口的每个消费者都要挂
+ *    部署旋钮矩阵的一条腿、背齐全部旋钮(`test/operator-knob-client-posture-matrix.test.ts` 的消费腿对账),半条链背不齐。整条链喂进来又卡在敏感路径守卫:
+ *    腿上的守卫靠引擎盖在每个请求上的豁免根(`RunnerDeps.memoryEngineDir`)放过记忆库自己的写,宿主构造器的输入没有这一位 —— 不带豁免根喂进去会把库里的写当守卫目标拒掉
+ *    (与腿不同答);在本层另造一条豁免根的读法是第二个写者。⇒ 等引擎的宿主输入收这一位,再整条喂、挂矩阵腿。
+ *  · `anchors.root`:阀门按 scope 跑,手里没有项目根 —— 项目层 scope 键是任务根的单向散列(`project-identity.ts` 的 `repo:<sha256[:24]>`),反推不出根;
+ *    全局层根本没有根。⇒ 人持有的相对 deny / ask 行无处锚定 = 异议,拒闭(引擎契约:判官不猜一行原本指向哪里)。这一格没有来源,永久缺席。
  *
  * 自动整理腿不受影响:它走引擎腿自己的判官,人的持久规则与部署策略照判。
  */
 export declare function createOperatorValveJudgeInput(facts: {
     /** 部署唯一的合成规则店(装配第 4 段铸一次,`RunnerDeps.permissionRuleStore` 与本座读同一只)。缺席 = 规则店没装配。 */
     readonly ruleStoreProvider: PermissionRuleStoreProvider | undefined;
+    /** 部署是否声明本机属主的规则桶(`boot/runner-deps.ts` 的 `localOwnerRulesDeclared` —— Runner 下发 `localOwnerRules` 的同一只判据)。 */
+    readonly localOwnerDeclared: boolean;
+    /** 发起这一轮的调用方(阀门口的已验主体;不带主体 = `undefined`)。 */
+    readonly initiator: string | undefined;
     /** 只读 `executionLaneHomeDir` 读的两位(`ServiceConfig` 结构满足)。 */
     readonly config: LaneHomeDeployment;
 }): ConsolidationWriteJudgeInput;
@@ -450,10 +445,10 @@ export declare function createOperatorValveJudgeInput(facts: {
  * 运维阀门腿的写判官座:引擎的判官构造器喂 {@link createOperatorValveJudgeInput},**外加一个响亮的债计数**(P-DEBT)。
  *
  * 构造器只有引擎那一只,本函数不判任何东西:`judge(target)` 的答案原样返回。它只在每次被问时记一次
- * `server.memory-consolidation.operator-valve-layers-unfed`(计数 + 探针行 + 一次性告警)—— 因为人的规则层、部署策略层、项目根三样都没喂
- * ({@link createOperatorValveJudgeInput} 头注),放行的最坏后果没变:运维手动整理时,一条点名记忆库路径的人的持久规则或部署写策略拦不住这一轮折叠
- * (与 7.128.x 逐字同)。债在遥测里显形,而不是随着「判官已换成引擎的」这句话消失。自动整理腿不受影响,走引擎腿自己的判官。
- * 收口 = 三层各自有了来源(人:「读谁的桶」裁定;策略:设计 + 引擎的豁免根入参;根:无来源则永久缺席并改写本债)那一版,本 tag 删。
+ * `server.memory-consolidation.operator-valve-layers-unfed`(计数 + 探针行 + 一次性告警)—— 人已喂;没喂的是部署的调用方策略层
+ * (整条治理链等引擎的宿主输入收豁免根)与项目根(没有来源)({@link createOperatorValveJudgeInput} 头注)。放行的最坏后果:运维手动整理时,
+ * 部署的写策略(例如 `APPROVAL_DENY=Write`、点名记忆库路径的敏感路径守卫)拦不住这一轮折叠;人的 deny 行拦得住,人持有的相对行照旧拒闭。
+ * 自动整理腿不受影响,走引擎腿自己的判官。收口 = 引擎的宿主输入收豁免根、整条部署治理链喂上并挂矩阵腿那一版,本 tag 删(项目根改写成永久缺席的披露)。
  */
 export declare function createOperatorValveWriteJudge(facts: Parameters<typeof createOperatorValveJudgeInput>[0]): ConsolidationWriteJudge;
 /** 两个 admin 口消费的窄能力面(`ServiceDeps.memoryConsolidation` 的实参来源)。 */
@@ -465,8 +460,9 @@ export interface MemoryConsolidationFaces {
     /** 配置表的 scope(`MEMORY_CONSOLIDATION_SCOPES`)。恰好一条时是两个口的**唯一**缺省。 */
     readonly scopes: readonly string[];
     /** 跑(或**续跑**)一轮。core 的 run 行是持久的:同一 scope 上有 pending run 时本调用 CONTINUE 它
-     *  (同一 plan 缓存、同一 force requestId、零新 mint)—— 所以这一口对**重试安全**。 */
-    run(scope: string): Promise<ConsolidationRunReceipt>;
+     *  (同一 plan 缓存、同一 force requestId、零新 mint)—— 所以这一口对**重试安全**。
+     *  `initiator` = 发起这一次的调用方(已验主体;不带主体 = `undefined`):写判官按它读人的规则桶;并入正在跑的那一轮的调用方用起跑者的判官。 */
+    run(scope: string, initiator: string | undefined): Promise<ConsolidationRunReceipt>;
     /** 该 scope 最近一次 driver run 的账(`undefined` = 从没跑过 —— 诚实缺席,不编一个空壳)。core 7.63.0([ref])起经引擎的治理店座读、异步。 */
     lastRun(scope: string): Promise<ConsolidationDriverRunRow | undefined>;
 }
@@ -507,9 +503,10 @@ export declare function createMemoryConsolidationFaces(stores: MemoryScopeStores
     /** 停因自由文本的**运维日志**座(缺席 = 没人听,不影响任何行为)。载荷由 {@link buildStopDetailAudit}
      *  铸,调用点在单飞回调**之内** ⇒ 一轮真 run 一行,并入的等待者不各落一行。 */
     onStopDetail?: (audit: ReturnType<typeof buildStopDetailAudit>) => void;
-    /** core 7.50.0:整理跑的**写判官座**(必填 —— 缺席不是「没有规则」,core 也拒)。操作面不判任何东西,只把它原样递给驱动动词:
-     *  早问库目录一次、应用时问每个产物文件,答 `no_objection` 以外一律拒写。装配层给哪一只见 {@link createOperatorValveWriteJudge}。 */
-    writeJudge: ConsolidationWriteJudge;
+    /** core 7.50.0:整理跑的**写判官座**(必填 —— 缺席不是「没有规则」,core 也拒),按发起者铸:每一次真跑(单飞里起跑的那一次)调一次,
+     *  拿到的判官原样递给驱动动词 —— 早问库目录一次、应用时问每个产物文件,答 `no_objection` 以外一律拒写。操作面不判任何东西。
+     *  装配层给哪一只见 {@link createOperatorValveWriteJudge}。 */
+    writeJudgeFor: (initiator: string | undefined) => ConsolidationWriteJudge;
     /** 引擎通告的**运维行**座(与 Runner 的 `onNotice` 同一只转发器)。缺席 ⇒ 通告只在回执上。判官拒的两种时机都经它走一次:
      *  应用时拒 = 引擎在驱动里铸的 `memory.consolidation_incomplete`;早问拒 = 驱动抛出的拒绝经引擎导出的投递口(`deliverWriteRefusal`)转成的
      *  `memory.consolidation_refused`(本仓不读通告名、不自铸通告形)。 */

package/dist/boot/memory-consolidation.js

@@ -1,6 +1,5 @@
 import { redactSecrets } from "../trace/redact.js";
 import { recordFailOpen } from "../observability/fail-open.js";
-import { buildOperatorRosterWayOut } from "../http/principal-gate.js";
 import { memoryMountRootOf, memoryScopeContractOf } from "../memory-scope.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { DEFAULT_MODEL_REF, resolveMainModel } from "../model-select.js";
@@ -8,7 +7,11 @@ import { captureRecordStoreOf } from "../memory-operator-faces.js";
 import { memoryStoreForRequest } from "../memory-scope-stores.js";
 import { createConsolidationWriteJudge, deliverWriteRefusal, expandTiers, MemoryEngine, memoryGovernanceDurability, modelOriginOf, resolveComplianceDenies, resolveMemoryConsolidationDriver, runMemoryConsolidationDriver, } from "@sema-agent/core";
 import { seatText } from "../trace/exit-seat.js";
-export function resolveConsolidationDriverSeat(deps) {
+import { createKeyResolver, credentialIdentityFingerprint, credentialIdentityOf } from "../key-resolver.js";
+export function resolveConsolidationDriverSeat(input) {
+    const { modelApiKeyEnv, modelApiKeys, ...seatDeps } = input;
+    const frozenKeys = createKeyResolver({ ...modelApiKeyEnv }, process.env, { ...modelApiKeys });
+    const deps = { ...seatDeps, ...(frozenKeys !== undefined ? { getApiKeyAndHeaders: frozenKeys } : {}) };
     let options;
     try {
         options = resolveMemoryConsolidationDriver(deps);
@@ -58,7 +61,7 @@ function consolidationSeatFingerprint(plane) {
     if ("unresolvable" in seat)
         return seat;
     const { cost: _cost, ...route } = seat.entry;
-    return route;
+    return { ...route, credential: credentialIdentityFingerprint(credentialIdentityOf(plane, seat.entry.name)) };
 }
 function seatLabel(deps) {
     if (deps.memoryConsolidationDriver?.chat !== undefined)
@@ -196,7 +199,7 @@ export function createConsolidationValve(input) {
     if (valve.notice !== undefined)
         logger.warn(valve.notice.tag, { detail: valve.notice.detail });
     assertConsolidationDriverWirable({ ...wiring, enabled: valve.enabled });
-    const plane = () => ({ models: config.models, tiers: config.tiers, roles: config.roles });
+    const plane = () => ({ models: config.models, tiers: config.tiers, roles: config.roles, modelApiKeyEnv: config.modelApiKeyEnv, modelApiKeys: config.modelApiKeys });
     return { valve, watch: createConsolidationValveWatch({ driver: config.memoryConsolidationDriver, unwirable, plane }) };
 }
 export function judgeConsolidationValve(input) {
@@ -279,18 +282,6 @@ export function buildConsolidationValveAudit(input) {
     if (!input.valve.enabled || input.valve.source !== "explicit")
         return { warnings: [] };
     const warnings = [];
-    if (!input.operatorRosterPresent) {
-        warnings.push({
-            tag: "memory_consolidation_valve_unreachable",
-            detail: "MEMORY_CONSOLIDATION_DRIVER=on armed the consolidation valve and both admin endpoints are mounted, but " +
-                "this worker has no operator: OPERATOR_PRINCIPALS is EMPTY and OPERATOR_SINGLE_USER is not set — an empty operator list means NO ONE " +
-                "is an operator (it deliberately does not mean 'everyone'), so POST /v1/admin/memory/consolidation/run and GET /v1/admin/memory/consolidation " +
-                "answer 501 capability.operator_principals_required to every caller and capabilities.memoryConsolidationDriver reports false. " +
-                `To fix: ${buildOperatorRosterWayOut()}. With OPERATOR_PRINCIPALS, callers must send a listed principal in the configured principal header; a single-user declaration needs no principal. ` +
-                "(Not a startup refusal: the operator roster is shared by every operator " +
-                "endpoint on this worker, so one valve must not decide whether the whole worker starts.)",
-        });
-    }
     if (!input.hasServiceAuth && !input.allowUnauthedWrites) {
         warnings.push({
             tag: "memory_consolidation_run_credential_gated",
@@ -335,6 +326,8 @@ export function createOperatorValveJudgeInput(facts) {
     const home = executionLaneHomeDir(facts.config);
     return {
         ...(facts.ruleStoreProvider !== undefined ? { ruleStoreProvider: facts.ruleStoreProvider } : {}),
+        ...(facts.initiator !== undefined && facts.initiator !== "" ? { principal: facts.initiator } : {}),
+        ...(facts.localOwnerDeclared ? { localOwnerDeclared: true } : {}),
         anchors: home !== undefined ? { home } : {},
     };
 }
@@ -369,10 +362,10 @@ export function createMemoryConsolidationFaces(stores, input) {
         seat: input.seat.seat,
         model: input.seat.model,
         scopes: input.scopes,
-        run: (scope) => flight(scope, async () => {
+        run: (scope, initiator) => flight(scope, async () => {
             const receipt = await runMemoryConsolidationDriver(engineOf(scope), scope, {
                 ...input.seat.options,
-                writeJudge: input.writeJudge,
+                writeJudge: input.writeJudgeFor(initiator),
                 compliance: { ...(input.postureOf !== undefined ? { postureOf: input.postureOf } : {}), scopeContract: memoryScopeContractOf([scope]) },
                 ...(input.onNotice !== undefined ? { onNotice: input.onNotice } : {}),
             }).catch((err) => {

package/dist/boot/org-memory.js

@@ -8,7 +8,7 @@ function collectDeploymentOrgScopes(config) {
         scopes.add(config.memoryScope);
     if (config.requirePrincipal !== true) {
         for (const project of Object.values(config.projects)) {
-            for (const s of project.defaultScopes ?? [])
+            for (const s of project.defaultScopes)
                 if (s.startsWith(ORG_PREFIX))
                     scopes.add(s);
         }
@@ -28,9 +28,10 @@ export function createOrgMemoryAdmissionWiring(opts) {
     const directory = centerLeg !== undefined
         ? (() => {
             const directoryNow = createIdentityBins(centerLeg.credential, (credential) => createOrgMemoryDirectory({
-                fetchSection: (principal) => fetchPrincipalOrgMemory({ baseUrl: centerLeg.baseUrl, credential }, principal, fetch, centerLeg.worker),
+                fetchSection: (principal) => fetchPrincipalOrgMemory({ baseUrl: centerLeg.baseUrl, credential }, principal, undefined, centerLeg.worker),
                 grantTtlMs: config.memoryOrgGrantTtlMs,
                 unavailableBackoffMs: config.memoryOrgUnavailableBackoffMs,
+                logger,
             })).now;
             return { lookup: (principal) => directoryNow().lookup(principal) };
         })()
@@ -44,7 +45,7 @@ export function createOrgMemoryAdmissionWiring(opts) {
     const memoryPlaneLive = config.memoryEngineEnabled && config.memoryEngineBackend !== "file";
     if (directory === undefined && config.requirePrincipal === true && memoryPlaneLive) {
         const orgProjects = Object.entries(config.projects)
-            .filter(([, p]) => (p.defaultScopes ?? []).some((s) => s.startsWith(ORG_PREFIX)))
+            .filter(([, p]) => p.defaultScopes.some((s) => s.startsWith(ORG_PREFIX)))
             .map(([id]) => id);
         if (orgProjects.length > 0) {
             throw new Error(`multi-tenant deployment has org: keys in projects[${orgProjects.join(", ")}].defaultScopes but NO org-memory directory source ` +

package/dist/boot/parked-revive-gate.d.ts

@@ -6,7 +6,7 @@ import { type SandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
 import type { ApprovalExemptionStore } from "../plugins/approval-exemption-store.js";
 /** 本腿读的配置切面(`ServiceConfig` 结构满足)。两个构造口各自的切面 + lane 判别式读的 `remoteExec`。 */
 export interface ParkedReviveGateConfigView extends DeploymentGovernanceConfigView, ApprovalBaselineConfigView {
-    readonly remoteExec?: ServiceConfig["remoteExec"];
+    readonly remoteExec: ServiceConfig["remoteExec"];
     /** [ref]④:`executionLaneHomeDir` 读的运维声明(切面必须点名本腿消费的每一个字段,否则窄视图字面量会静默丢掉旋钮)。 */
     readonly remoteExecHomeDir?: ServiceConfig["remoteExecHomeDir"];
     /** host 腿裁决 env 的 cwd 占位根(见下方 `hostGateCwd`)。 */

package/dist/boot/parked-revive-gate.js

@@ -7,7 +7,7 @@ import { applyRuntimeGovernance } from "../runtime-governance.js";
 import { DeferredSandboxPathEnv, sandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
 import { DEPLOYMENT_SHAPE_PREDICATES } from "../deployment-shape.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
-import { createDeploymentListExemption } from "../approval.js";
+import { createSessionExemptionRead } from "../approval.js";
 import { seatText } from "../trace/exit-seat.js";
 function hostGateCwd(config, localRoot) {
     return join(config.localDataRoot ?? localRoot, "parked-revive-unrooted");
@@ -24,7 +24,7 @@ export function createParkedReviveInheritedGate(deps) {
                 env: new DeferredSandboxPathEnv({
                     sessionId: row.sessionId,
                     slots,
-                    logger: { warn: (event, fields) => logger.warn(event, { ...(fields ?? {}), lane: config.remoteExec?.provider, leg: "parked_revive" }) },
+                    logger: { warn: (event, fields) => logger.warn(event, { ...(fields ?? {}), lane: config.remoteExec.provider, leg: "parked_revive" }) },
                 }),
                 ...homeBase,
             }
@@ -33,7 +33,7 @@ export function createParkedReviveInheritedGate(deps) {
         const baseline = createApprovalBaselinePolicy(config, {
             kind: "durable",
             question,
-            ...(approvalExemptionStore !== undefined && rootSessionId ? { exemption: createDeploymentListExemption(approvalExemptionStore, rootSessionId, logger, "parked_revive") } : {}),
+            ...(approvalExemptionStore !== undefined && rootSessionId ? { exemption: createSessionExemptionRead(approvalExemptionStore, rootSessionId, logger, "deployment_list", "parked_revive") } : {}),
         });
         const governed = applyRuntimeGovernance({ objective: "", toolPolicy: baseline }, createDeploymentGovernanceInputs(config, pathAdjudication));
         return {

package/dist/boot/reapers.d.ts

@@ -26,7 +26,7 @@ import type { ApprovalNonceStore, CheckpointStoreFull, CostQuotaStore, ImageBake
 import { type StoreSweep, type StoreSweepLeg } from "../plugins/store-sweep.js";
 import type { ToolApprovalCoordinator } from "../tool-approval.js";
 import type { ParkCommitWatch } from "../plugins/park-commit-watch.js";
-import { type SandboxPodReaper } from "../plugins/k8s-pod-reaper.js";
+import { type SandboxReaper } from "../plugins/sandbox-reaper.js";
 import { type AuditRotationPort } from "../approval-ask-retention.js";
 /** [ref] / [ref]§五(sema-comms `audits/failopen-governance-176.md` §7 "Z 类 1 条"):default consecutive-failure
  *  count before a reaper leg's swallowed error gets a `warn` line. The ~15 `.catch(() => undefined)` sites
@@ -122,8 +122,9 @@ export interface ReapersCtx {
     approvalAskAudit: AuditRotationPort | undefined;
     /** 晚绑(server 造出来才有)——见文件头「位置即契约」①。 */
     getRunDenySweep: () => ((now: number) => Promise<void>) | undefined;
-    /** k8s 车道的沙箱 Pod reaper(`plugins/k8s-pod-reaper.ts`;第 5 段与 run 工厂同一份 k8s 配置铸)。缺席 = 非 k8s 车道 ⇒ 本腿零调用。 */
-    sandboxPodReaper?: SandboxPodReaper;
+    /** 本车道的沙箱回收座(`plugins/sandbox-reaper.ts`;第 5 段与 run 工厂同一份车道配置铸):k8s 车道 = 沙箱 Pod reaper(`plugins/k8s-pod-reaper.ts`),local-docker 车道 = 无主容器 reaper
+     *  (`plugins/local-docker-reaper.ts`)。缺席 = 别的车道 ⇒ 本腿零调用。一次部署一条执行车道 ⇒ 一只座、一个节拍。 */
+    sandboxReaper?: SandboxReaper;
 }
 /** core 5.48 `reapDurableAgents` 的 `deps.sessions` 面(结构形,只列本仓要填的三格)。 */
 export interface ReapSessionsFacade {