@sema-agent/server 7.138.0 → 7.140.0

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

@@ -45,7 +45,8 @@
  * `retentionSweepRuns`):开 ⇒ `managed`,关(缺省)⇒ `none`;local 形的店恒声明 `none`。删除的执行面是扫车道(`boot/retention-lane.ts`)与 SQL 店上的
  * 执行器,不在本装配点。所以本装配点对件D 只做两件事:①把策略与执行器递给 core 的启动期校验
  * (`assertRetentionCapability` —— 配对由引擎一个判官判:店声明 `managed` 而部署不跑执行器、执行器不是执行器,锁不锁都拒;锁着 + 店不能删 ⇒ 拒启,
- * 「策略锁着、数据永存」不许发生);②策略在场而没有任何 managed 店时打一条响亮 warn。**不**假装有执行面。
+ * 「策略锁着、数据永存」不许发生);②策略在场而扫车道关着(节律缺或为 0)时打一条响亮 warn,句说这个真因。**不**假装有执行面。
+ * 车道关着而策略在场只可能在 `audit-only` 档:`enforce` 而车道不齐在 `loadConfig` 就拒了(配置不变量 `retention-lane-complete`)。
  */
 import { type LockedKey, type ManagedRetentionCapability, type RunnerDeps } from "@sema-agent/core";
 import type { ServiceConfig } from "../config.js";
@@ -61,7 +62,7 @@ export interface GovernanceSeams {
 }
 /** 依赖收窄到真实消费面(接口隔离 —— 测试用真形字面量,零铸形)。 */
 export interface GovernanceSeamsCtx {
-    config: Pick<ServiceConfig, "compliancePosture" | "lockedConfigKeys" | "retentionPolicy" | "mcpServers" | "requirePrincipal">;
+    config: Pick<ServiceConfig, "compliancePosture" | "lockedConfigKeys" | "retentionPolicy" | "retentionSweep" | "mcpServers" | "requirePrincipal">;
     logger: Pick<Logger, "info" | "warn">;
     /**
      * core 留存能力校验的对象集(名字进拒启文案)。喂的是**装配现场的真店**,不是「我以为装了什么」——

package/dist/boot/governance-seams.js

@@ -50,17 +50,15 @@ export function createGovernanceSeams(ctx) {
     const retentionPolicy = config.retentionPolicy;
     const locked = lockedKeys.has("retentionPolicy");
     assertRetentionCapability({ policy: retentionPolicy, locked, stores: retentionStores, executor: ctx.retentionExecutor });
-    if (retentionPolicy !== undefined) {
-        const managed = retentionStores.filter((s) => s.store?.retention === "managed");
-        if (managed.length === 0) {
-            logger.warn("retention_policy_not_executed", {
-                maxAgeDays: retentionPolicy.maxAgeDays,
-                note: "RETENTION_MAX_AGE_DAYS is configured but NO wired store declares retention:\"managed\" (the retention sweep lane is off — " +
-                    "RETENTION_SWEEP_INTERVAL_SEC unset or 0 — or the store medium has no sweep) — the policy is a DECLARATION only; nothing " +
-                    "deletes data on its account. It is relayed to the engine for the startup capability check; run the sweep lane on a SQL " +
-                    "backend to make it effective.",
-            });
-        }
+    if (retentionPolicy !== undefined && config.retentionSweep.intervalSec === 0) {
+        logger.warn("retention_policy_not_executed", {
+            maxAgeDays: retentionPolicy.maxAgeDays,
+            mode: config.retentionSweep.mode,
+            retentionSweepIntervalSec: config.retentionSweep.intervalSec,
+            note: "RETENTION_MAX_AGE_DAYS is set but RETENTION_SWEEP_INTERVAL_SEC is unset or 0, so the retention sweep lane is off: nothing deletes data — " +
+                "or records what it would delete — on this policy's account; the policy is a declaration relayed to the engine's startup capability check. " +
+                "To run the lane set RETENTION_SWEEP_INTERVAL_SEC above 0 on a SQL backend (RETENTION_MODE=audit-only records what would be deleted; enforce deletes it).",
+        });
     }
     return { compliancePostureResolver, lockedConfig, retentionPolicy, lockedKeys };
 }

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

@@ -56,35 +56,6 @@
  */
 import { type ExecutionLane, type RemoteExecProvider } from "../execution-lane-caps.js";
 import type { MemoryEngineBackend } from "@sema-agent/settings-schema/execution-lanes";
-/**
- * [ref] A3 源头修(黑板 [ref]/[ref]/[ref],[ref])—— `memoryPersistenceCapable` 的**装配层有效值**:
- * operator 显式 env 恒赢;env 缺席时,`REMOTE_EXEC=host` 腿自动补 `true`;其余一律缺席(现行为)。
- *
- * ## 为什么 host 腿可以自动声明(而且只有 host 腿)
- * core r13/r14 的 withhold 判据是「执行环境暴露 remote 面」——它对 host 腿是**误伤**:host 腿的文件
- * 工具就跑在**这台机器**的 fs 上(`hostSemanticsLane`,与 core 的 remote 判决是两根轴,见下方 facts 注),
- * 记忆根也在这台机器上,「执行车道与记忆根共享文件平面」这个 capable=true 所断言的**车道级事实**由
- * 构造成立。剩下的围栏维(记忆根是否落在该次任务的 fs 授权边界内)在 in-process 上**同样存在**而 core
- * 并不 withhold——它由本模块的 ② 号 warn、fs 门的 `path_not_in_root` 拒绝、以及 core 准入席自动放行写家
- * ([ref])这套既有处置管,不归 withhold 判据管。所以 host 腿自动 true 与 in-process 的默认行为**同等诚实**。
- * 沙箱腿(e2b/k8s/ssh/local-docker)文件平面在沙箱盘,withhold 是对的,恒不自动。
- *
- * ## 为什么不是「围栏覆盖记忆根」的更严合取
- * boot 期对 host 腿**算不出**围栏根(host factory 每任务另铸 `sema-host-*` 子目录、per-session cwd 可整个
- * 换掉 workspaceBase——见 boot/stores.ts 的 codex 已核注释),那个合取在恰恰需要它的腿上永不可满足;
- * 而且它断言的是 per-task 事实,不是本键的车道级语义。
- *
- * ## 位置与纪律
- * 单源:resolve-spec 的 spec 直通(引擎据它判「本会话没有持久记忆」的披露与四只记忆面臂)、boot 审计的 declared 位
- * 两处都必须读本函数,禁各自重算(operator-knob 律:显式 env 的优先权在这一个函数里执法一次)。
- * 自动补位在 boot 日志上必须可见(stores.ts 的 info 行),部署方随时可用显式 env 覆盖。
- */
-export declare function effectiveMemoryPersistenceCapable(config: {
-    remoteExec?: {
-        provider?: string;
-    };
-    memoryPersistenceCapable?: boolean;
-}): boolean | undefined;
 /** boot 期可知的全部事实。每一位都必须由调用点从真配置/真装配结果取,禁在本模块内重算(重算=第二真源)。 */
 export interface MemoryWriteBoundaryFacts {
     /** 引擎的**挂载平面**根 —— 引擎真正读写条目的那棵树,由 `memoryMountRootOf(backend, root)` 单铸点取
@@ -97,16 +68,9 @@ export interface MemoryWriteBoundaryFacts {
     memoryRoot: string | undefined;
     /** 执行车道名,只进文案(归一读口 `executionLaneOf` 的答案;[ref] 起不在调用点手写 `?? "in-process"`)。 */
     lane: ExecutionLane;
-    /** 该车道的文件工具是否跑在**本机** fs 上(in-process / `REMOTE_EXEC=host`)。false = 沙箱盘,与记忆根分平面。
-     *  ⚠️ 这一位管的是**文件平面**,与下面的 `coreRemoteExecutionEnv` 是**两根轴**,别合并(codex round2
-     *  [medium] 就是把它们当成一根轴的后果):`host` 车道的文件平面就是本机(这一位 true),但 core 眼里它
-     *  仍是 remote(那一位也 true)。 */
+    /** 该车道的路径是不是本机的文件(执行环境块 `hostLocalPaths`:in-process 的桩块 / `REMOTE_EXEC=host` 为真)。false = 沙箱 / 远端 / 设备盘,
+     *  与记忆根分平面 —— 引擎在这一形上不教 `# Memory` 写指令(除非部署声明 `memoryPersistenceCapable: true`),判的是同一键。 */
     hostSemanticsLane: boolean;
-    /** core 的 `isRemoteExecutionEnv` 对本部署执行环境的判决 —— 判别位 = `REMOTE_EXEC` 有没有设(**含
-     *  `host`**:core 的判别是鸭子类型,`remote-env-host.ts` 把那几件全实现了,亲验坐实)。
-     *  5.26.0 的 r13/r14 收窄按的是**这一位**,不是文件平面:凡 core 判 remote,`# Memory` 写指令一律撤,
-     *  除非声明 `memoryPersistenceCapable: true`。 */
-    coreRemoteExecutionEnv: boolean;
     /** 部署声明 `MEMORY_PERSISTENCE_CAPABLE`(三态)。两极都让本模块闭嘴,但理由不同 —— 见各臂注释。 */
     declaredCapable: boolean | undefined;
     /** 本部署的记忆引擎后端(`config.memoryEngineBackend`)。**只进文案**,不参与任何判决 —— 它在这里的
@@ -119,31 +83,30 @@ export interface MemoryWriteBoundaryFacts {
     containmentRoots: readonly string[];
 }
 /**
- * [ref] —— 审计的**车道那四位**由本函数从能力表派生(boot/stores.ts 的装配点只调它,不再就地手写):
- * 改前 stores 里是 `lane === undefined || lane === "host"`(同义折,门 D R3)+ `config.remoteExec !== undefined`
- * (座位上的裸缺席判,R4)+ `lane ?? "in-process"` ×3(R2)。两根轴各读表里各自那一位,不合并:
- *  · `hostSemanticsLane` ⇐ `hostFilePlane`(文件平面在不在本机);
- *  · `coreRemoteExecutionEnv` ⇐ 同名位(core 拿没拿到执行环境)。
- * 读数逐车道不变(对账:`test/execution-lane-caps.test.ts` 的真装配点联合覆盖格)。`processCwd` 由调用点传
- * (stores 传 `process.cwd()`),本函数保持纯。
+ * 审计的**车道三位**由本函数派生(boot/stores.ts 的装配点只调它,不就地手写):
+ *  · `lane` ⇐ 归一读口 `executionLaneOf`;
+ *  · `hostSemanticsLane` ⇐ 执行环境块 `hostLocalPaths`(唯一作者 `capabilitiesFor`;引擎撤不撤写指令读的是同一键);
+ *  · `containmentRoots` ⇐ 只有 in-process 给得出(见下)。
+ * `processCwd` 由调用点传(stores 传 `process.cwd()`),本函数保持纯。
  */
 export declare function buildMemoryBoundaryLaneFacts(config: {
     readonly remoteExec?: {
         readonly provider: RemoteExecProvider;
+        readonly s3Snapshot?: unknown;
     } | undefined;
-}, processCwd: string): Pick<MemoryWriteBoundaryFacts, "lane" | "hostSemanticsLane" | "coreRemoteExecutionEnv" | "containmentRoots">;
+}, processCwd: string): Pick<MemoryWriteBoundaryFacts, "lane" | "hostSemanticsLane" | "containmentRoots">;
 /** 一条启动告警:`tag` 进日志事件名(可被运维按名过滤/告警),`detail` 是给人读的整句(含恢复路径)。 */
 export interface MemoryWriteBoundaryWarning {
     tag: "memory_root_outside_write_boundary" | "memory_remote_lane_write_instruction_dropped";
     detail: string;
 }
 /**
- * 判两件事,互斥(remote 上不叠 host 的围栏话 —— 围栏根本不在这台机器上,说了是噪音):
+ * 判两件事,互斥(路径不是本机的车道上不叠围栏话 —— 围栏根本不在这台机器上,说了是噪音):
  *
- * ① **remote 车道**(只可能因为 `MEMORY_ENGINE_REMOTE_LANE=allow` 才在这里还有引擎):core 5.26.0 的
- *    r13/r14 收窄把 `# Memory` 写指令在 remote executionEnv 上撤了(沙箱手带够不着 host 记忆根),
- *    官方恢复路径是声明 `memoryPersistenceCapable: true`。未声明 ⇒ 点名 warn,把恢复旋钮写进句子里。
- * ② **host 车道**:记忆根不在任何一个已知围栏根内 ⇒ 模型被教着往一个 fs 工具够不到的路径写。
+ * ① **路径不是本机的车道**(块 `hostLocalPaths` 为假:沙箱 / 远端 / 设备;记忆引擎在这里只可能因为 `MEMORY_ENGINE_REMOTE_LANE=allow`
+ *    或 DB 记忆面才在):引擎不教 `# Memory` 写指令(手带够不着本机的记忆根),官方恢复路径是声明 `memoryPersistenceCapable: true`。
+ *    未声明 ⇒ 点名 warn,把恢复旋钮写进句子里。
+ * ② **路径是本机的车道**(in-process / host):记忆根不在任何一个已知围栏根内 ⇒ 模型被教着往一个 fs 工具够不到的路径写。
  *
  * 两极声明都让本模块闭嘴,但理由不同,别合并:
  *  · `true` = operator 自证有推断看不见的持久通道(共享挂载 / 自定义 writer),我们的结构判断本就不该

package/dist/boot/memory-boundary.js

@@ -1,17 +1,10 @@
 import { resolve } from "node:path";
-import { executionLaneCaps, executionLaneOf, laneWiresExecutionEnv } from "../execution-lane-caps.js";
-export function effectiveMemoryPersistenceCapable(config) {
-    if (config.memoryPersistenceCapable !== undefined)
-        return config.memoryPersistenceCapable;
-    return config.remoteExec?.provider === "host" ? true : undefined;
-}
+import { capabilitiesFor, executionLaneOf } from "../execution-lane-caps.js";
 export function buildMemoryBoundaryLaneFacts(config, processCwd) {
     const lane = executionLaneOf(config.remoteExec?.provider);
-    const caps = executionLaneCaps(lane);
     return {
         lane,
-        hostSemanticsLane: caps.hostFilePlane === "supported",
-        coreRemoteExecutionEnv: laneWiresExecutionEnv(lane),
+        hostSemanticsLane: capabilitiesFor(config).hostLocalPaths,
         containmentRoots: lane === "in-process" ? [processCwd] : [],
     };
 }
@@ -21,25 +14,22 @@ function isInside(child, root) {
     return c === r || c.startsWith(r === "/" ? "/" : `${r}/`);
 }
 export function buildMemoryWriteBoundaryAudit(facts) {
-    const { memoryRoot, lane, hostSemanticsLane, coreRemoteExecutionEnv, declaredCapable, containmentRoots, engineBackend } = facts;
+    const { memoryRoot, lane, hostSemanticsLane, declaredCapable, containmentRoots, engineBackend } = facts;
     if (memoryRoot === undefined)
         return { warnings: [] };
     if (declaredCapable !== undefined)
         return { warnings: [] };
-    if (coreRemoteExecutionEnv) {
-        const plane = hostSemanticsLane
-            ? `the model's file tools DO run on this worker's filesystem, but core classifies this execution environment as ` +
-                `remote (it exposes the remote-env surface), so the instruction is withheld anyway`
-            : `the model's file tools write the SANDBOX filesystem while the memory root (${memoryRoot}) lives on this worker`;
+    if (!hostSemanticsLane) {
         return {
             warnings: [
                 {
                     tag: "memory_remote_lane_write_instruction_dropped",
-                    detail: `the memory engine is wired over the "${lane}" execution lane and ${plane}. ` +
-                        `Since core 5.26.0 the "# Memory" WRITE instruction is withheld on a remote execution environment, so this ` +
-                        `deployment reads memory but no longer teaches the model how to save into it. If this lane genuinely reaches ` +
-                        `the memory root, declare it: MEMORY_PERSISTENCE_CAPABLE=true restores the write instruction. If it does not, ` +
-                        `MEMORY_PERSISTENCE_CAPABLE=false makes the read-only state explicit to the model instead of leaving it silent.`,
+                    detail: `the memory engine is wired over the "${lane}" execution lane and the model's file tools write the SANDBOX filesystem ` +
+                        `while the memory root (${memoryRoot}) lives on this worker. The engine withholds the "# Memory" WRITE instruction when ` +
+                        `the execution environment's paths are not this worker's files, so this deployment reads memory but does not teach ` +
+                        `the model how to save into it. If this lane genuinely reaches the memory root, declare it: ` +
+                        `MEMORY_PERSISTENCE_CAPABLE=true restores the write instruction. If it does not, MEMORY_PERSISTENCE_CAPABLE=false ` +
+                        `makes the read-only state explicit to the model instead of leaving it silent.`,
                 },
             ],
         };

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

@@ -1,7 +1,9 @@
 import { type LaneHomeDeployment } from "../execution-lane-caps.js";
+import { type MemoryScopeStores } from "../memory-scope-stores.js";
+import type { SessionCaptureRecordSource } from "../plugins/store-backend.js";
 import type { RestartSliceCtx } from "../web-admin-client/restart-signal.js";
 import type { MemoryConsolidationDriverConfig, ServiceConfig } from "../config-types.js";
-import { resolveMemoryConsolidationDriver, type ConsolidationWriteJudge, type ConsolidationWriteJudgeInput, type EngineNotice, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type MemoryBackend, type MemoryConsolidationDriverDeps, type PermissionRuleStoreProvider, type SessionCaptureRecordStore } from "@sema-agent/core";
+import { resolveMemoryConsolidationDriver, type ConsolidationWriteJudge, type ConsolidationWriteJudgeInput, type EngineNotice, type ConsolidationDriverRunRow, type ConsolidationRunReceipt, type MemoryConsolidationDriverDeps, type PermissionRuleStoreProvider } from "@sema-agent/core";
 /**
  * 座解析的 options 形 = core 解析器交回的那只(core 7.50.0 起它**不含** `writeJudge`:判官不是模型席的一部分,由调用方在动词上带)。
  * 取解析器的返回型而不是自己写 `Omit<…>`:形的属主是 core 的解析器,本仓不持第二份。
@@ -462,14 +464,19 @@ export interface MemoryConsolidationFaces {
     lastRun(scope: string): ConsolidationDriverRunRow | undefined;
 }
 /**
- * 在**已装配的记忆后端**上建 consolidation 操作面。命名照 CLAUDE.md 工厂律:返回带行为的活对象 ⇒ `create*`。
+ * 在**记忆作用域店**上建 consolidation 操作面。命名照 CLAUDE.md 工厂律:返回带行为的活对象 ⇒ `create*`。
+ *
+ * ## 引擎建在哪只店上:被整理的那一层住的那只
+ * 整理一层 = 读这一层的库、把产物写回这一层 —— 店只问记忆作用域店(`memoryStoreForRequest(stores, [scope])`;读不出的层键 ⇒ `request.memory_layer`)。
+ * 一只店一只引擎,`lastRun` 读那只引擎的控制面(run 账住在被整理的那只店的控制面里)。修前恒在部署的店上建:目录钉住的部署上,
+ * 类型化个人层(`user:` / `userproj:` / `org:`)的库在个人挂载上的另一只店里,整理读到的是空库、产物落在会话不读的店。
  *
  * ## 为什么这里现构一只引擎(与 `createMemoryComplianceFaces` / `createMemoryBundleFaces` 同一条理由)
  *
  * 本仓**没有**一个长命的 `MemoryEngine` 实例:`boot/stores.ts` 装配出来的 `memoryEngine` 是
- * `{ backend, root }` 二元组,真引擎由 core 的 Runner **每任务现构**。HTTP 面要一个引擎就得自己构。
- * 两只引擎不会各说各话:控制面由后端写死(`backend.controlPlaneRoot`),gate / run 账 / plan 归档
- * 全住在那里,所以操作面引擎与每任务引擎看的是**同一本**账。
+ * 记忆作用域店,真引擎由 core 的 Runner **每任务现构**。HTTP 面要一个引擎就得自己构。
+ * 两只引擎不会各说各话:控制面由店写死(`backend.controlPlaneRoot`),gate / run 账 / plan 归档
+ * 全住在那里,所以操作面引擎与每任务引擎在同一只店上看的是**同一本**账。
  *
  * ## `consolidation: {}` = 出厂缺省,**显式在场**
  *
@@ -481,10 +488,7 @@ export interface MemoryConsolidationFaces {
  * `multiNode` 也**刻意不声明**:声明它就必须注入一只全局租约,而本仓今天没有(见顶注「v1 没有周期腿」
  * 那一段的同一条理由)——不声明 = 单机 plan-seat CAS 是唯一互斥,core 的契约原话如此,不是偷偷降级。
  */
-export declare function createMemoryConsolidationFaces(store: {
-    backend: MemoryBackend;
-    root: string;
-}, input: {
+export declare function createMemoryConsolidationFaces(stores: MemoryScopeStores, input: {
     seat: ConsolidationDriverSeat;
     scopes: readonly string[];
     /** 部署的 provenance 姿态,原样交给引擎(缺席 ⇒ core 缺省 `carry`)。 */
@@ -496,13 +500,13 @@ export declare function createMemoryConsolidationFaces(store: {
     /** 停因自由文本的**运维日志**座(缺席 = 没人听,不影响任何行为)。载荷由 {@link buildStopDetailAudit}
      *  铸,调用点在单飞回调**之内** ⇒ 一轮真 run 一行,并入的等待者不各落一行。 */
     onStopDetail?: (audit: ReturnType<typeof buildStopDetailAudit>) => void;
-    /** [ref]②(383 §2.1b):capture opt-out 记录的 SQL 载体(main.ts 单实例,与 Runner 同源)。
+    /** [ref]②(383 §2.1b):capture opt-out 记录的按平面取用源(main.ts 取一次,与 Runner 同源;每只引擎按它那只店的控制面取)。
      *  🔴 这只引擎是四只 operator 面里**真读名册**的那只:`consolidationEligibility` 第四臂
      *  (engine.js `listCaptureOptOutSessions`)拿它筛掉 opt-out 会话的贡献条目 —— SQL 部署上漏喂
      *  = 驱动器读文件空名册 ⇒ 蒸馏器放大用户明说不要记的内容(S-5 真实失效形;全站同批注入律,
      *  机器钉 capture-optout-lane ②)。[ref] 起 local 车道在引擎接线时也供(core 文件三腿,同一只控制面);
      *  缺席 ⇒ 记忆面暗(引擎未接线),与 Runner 同本。 */
-    captureRecordStore?: SessionCaptureRecordStore;
+    captureRecords?: SessionCaptureRecordSource;
     /** core 7.50.0:整理跑的**写判官座**(必填 —— 缺席不是「没有规则」,core 也拒)。操作面不判任何东西,只把它原样递给驱动动词:
      *  早问库目录一次、应用时问每个产物文件,答 `no_objection` 以外一律拒写。装配层给哪一只见 {@link createOperatorValveWriteJudge}。 */
     writeJudge: ConsolidationWriteJudge;

package/dist/boot/memory-consolidation.js

@@ -4,8 +4,9 @@ import { buildOperatorRosterWayOut } from "../http/principal-gate.js";
 import { memoryMountRootOf } from "../memory-scope.js";
 import { executionLaneHomeDir } from "../execution-lane-caps.js";
 import { DEFAULT_MODEL_REF, resolveMainModel } from "../model-select.js";
-import { backendOwnsControlPlane } from "../memory-operator-faces.js";
-import { createConsolidationWriteJudge, deliverWriteRefusal, expandTiers, MemoryEngine, readConsolidationDriverRun, resolveMemoryConsolidationDriver, runMemoryConsolidationDriver, } from "@sema-agent/core";
+import { backendOwnsControlPlane, captureRecordStoreOf } from "../memory-operator-faces.js";
+import { memoryStoreForRequest } from "../memory-scope-stores.js";
+import { createConsolidationWriteJudge, deliverWriteRefusal, expandTiers, MemoryEngine, modelOriginOf, readConsolidationDriverRun, resolveMemoryConsolidationDriver, runMemoryConsolidationDriver, } from "@sema-agent/core";
 export function resolveConsolidationDriverSeat(deps) {
     let options;
     try {
@@ -151,7 +152,7 @@ export function consolidationSeatBillingOf(plane) {
     catch (err) {
         return { kind: "unresolvable", fault: `the main model (${DEFAULT_MODEL_REF}) does not resolve: ${err instanceof Error ? err.message : String(err)}` };
     }
-    return seat.entry === main ? { kind: "main-model", mainModel: main.id } : { kind: "own-model", seatModel: seat.entry.id, mainModel: main.id };
+    return modelOriginOf(seat.entry) === modelOriginOf(main) ? { kind: "main-model", mainModel: main.id } : { kind: "own-model", seatModel: seat.entry.id, mainModel: main.id };
 }
 export function resolveConsolidationValve(input) {
     const decided = decideConsolidationValve(input);
@@ -333,22 +334,32 @@ export function createOperatorValveWriteJudge(facts) {
         return judge(target);
     };
 }
-export function createMemoryConsolidationFaces(store, input) {
-    const engine = new MemoryEngine({
-        backend: store.backend,
-        memoryDir: memoryMountRootOf(store.backend, store.root),
-        consolidation: {},
-        ...(input.provenance !== undefined ? { provenance: input.provenance } : {}),
-        ...(input.onIncident !== undefined ? { onIncident: input.onIncident } : {}),
-        ...(input.captureRecordStore !== undefined ? { captureRecordStore: input.captureRecordStore } : {}),
-    });
+export function createMemoryConsolidationFaces(stores, input) {
+    const engines = new Map();
+    const engineOf = (scope) => {
+        const store = memoryStoreForRequest(stores, [scope]);
+        const known = engines.get(store);
+        if (known !== undefined)
+            return known;
+        const records = captureRecordStoreOf(input.captureRecords, store);
+        const engine = new MemoryEngine({
+            backend: store,
+            memoryDir: memoryMountRootOf(store, stores.root),
+            consolidation: {},
+            ...(input.provenance !== undefined ? { provenance: input.provenance } : {}),
+            ...(input.onIncident !== undefined ? { onIncident: input.onIncident } : {}),
+            ...(records !== undefined ? { captureRecordStore: records } : {}),
+        });
+        engines.set(store, engine);
+        return engine;
+    };
     const flight = createPerScopeSingleFlight();
     return {
         seat: input.seat.seat,
         model: input.seat.model,
         scopes: input.scopes,
         run: (scope) => flight(scope, async () => {
-            const receipt = await runMemoryConsolidationDriver(engine, scope, {
+            const receipt = await runMemoryConsolidationDriver(engineOf(scope), scope, {
                 ...input.seat.options,
                 writeJudge: input.writeJudge,
                 ...(input.onNotice !== undefined ? { onNotice: input.onNotice } : {}),
@@ -361,7 +372,7 @@ export function createMemoryConsolidationFaces(store, input) {
             }
             return receipt;
         }),
-        lastRun: (scope) => readConsolidationDriverRun(engine.controlPlaneRoot, scope),
+        lastRun: (scope) => readConsolidationDriverRun(engineOf(scope).controlPlaneRoot, scope),
     };
 }
 //# sourceMappingURL=memory-consolidation.js.map

package/dist/boot/resolve-spec.d.ts

@@ -1,4 +1,3 @@
-import { type MemoryBackend } from "@sema-agent/core";
 import { SessionEnvironmentSelection, selectEnvironmentTool } from "../capabilities/select-environment-tool.js";
 import { sendUserFileTool } from "../capabilities/send-user-file-tool.js";
 import { selectScenario } from "../capabilities/scenarios.js";
@@ -15,8 +14,9 @@ import type { Metrics } from "../observability/metrics.js";
 import { PerTaskImageRegistry } from "../per-task-image.js";
 import type { StoreBackend } from "../plugins/store-backend.js";
 import { type TaskAttachmentStore } from "../plugins/task-attachment-store.js";
-import { type createPrincipalEntitlementsClient } from "../runtime-caps-resolver.js";
+import type { createPrincipalEntitlementsClient } from "../runtime-caps-resolver.js";
 import { type OwnerAwareSessionStore } from "../security.js";
+import type { MemoryScopeStores } from "../memory-scope-stores.js";
 import type { MemorySyncRunner } from "../memory-sync-client.js";
 import type { PeerDesk } from "../peer-seat.js";
 import type { RunnerDepsOnAsk } from "./runner-deps.js";
@@ -55,10 +55,8 @@ export interface ResolveSpecCtx {
     taskTimeoutSec: number;
     selectEnvTool: ReturnType<typeof selectEnvironmentTool> | undefined;
     sendUserFileToolSpec: ReturnType<typeof sendUserFileTool> | undefined;
-    memoryEngine: {
-        backend: MemoryBackend;
-        root: string;
-    } | undefined;
+    /** 记忆引擎对象 = 记忆作用域店(`memory-scope-stores.ts`;项目层准备一步按层问它的店)。 */
+    memoryEngine: MemoryScopeStores | undefined;
     /** [ref]:记忆同步腿(开 `MEMORY_SYNC_*` 且记忆引擎接线时在场)—— 项目层准备一步把本任务的项目层交给它跟踪(`memory-project-layer.ts`)。 */
     memorySyncRunner: MemorySyncRunner | undefined;
     durableEnabled: boolean;

package/dist/boot/resolve-spec.js

@@ -25,7 +25,6 @@ import { bindAttachmentsForTask } from "../plugins/task-attachment-store.js";
 import { resourceSuspendOptIn } from "../resource-suspend.js";
 import { routeServiceTask, supPostureOverrides } from "../router/route-orchestration.js";
 import { tightenGoverned } from "../governance-overrides.js";
-import { gateExecutionLane } from "../runtime-caps-resolver.js";
 import { applyRuntimeGovernance } from "../runtime-governance.js";
 import { HttpError, createCodedHttpError, encodeCheckpointScope } from "../security.js";
 import { headReadOf, sessionFaceOfHead } from "../session-incarnation.js";
@@ -52,9 +51,12 @@ import { TENANCY_WALL_CLOCK_BASE_SEC, enableForkFromBody, normalizeRetainSubagen
 import { redactSecrets } from "../trace/redact.js";
 import { DeferredSandboxPathEnv, sandboxPathEnvSlots } from "./deferred-sandbox-path-env.js";
 import { executionLaneHomeDir, executionLaneOf, laneWiresExecutionEnv } from "../execution-lane-caps.js";
-import { effectiveMemoryPersistenceCapable } from "./memory-boundary.js";
 import { withUnattendedLeg } from "../unattended-permission-mode.js";
 import { fieldConflictFacts } from "../field-conflict.js";
+function unrooted(spec) {
+    const { sessionId: _neverWritten, ...resolved } = spec;
+    return resolved;
+}
 export function createResolveSpec(ctx) {
     const { config, logger, metrics, localRoot, scenarios, principalCaps, centerRuntimeCapsResolver, getKeyResolver, taskAttachmentStore, perSessionCwd, setSessionCwd, setSessionShellEnv, fenceSessionOwner, hookLlm, hookAgent, fleetBus, hookWakeBus, resumeAnchorStore, ownerAware, taskLimitCaps, taskTimeoutSec, selectEnvTool, sendUserFileToolSpec, memoryEngine, memorySyncRunner, durableEnabled, approvalExemptionStore, checkpointStore, imageIndex, perTaskImage, sessionEnvSelection, liveQuestionFace, approverSeat, lockedKeys, loadedSkills, peerDesk, } = ctx;
     const deploymentSkillSources = new Map(loadedSkills.map((k) => [k.spec.name, k.source]));
@@ -72,7 +74,7 @@ export function createResolveSpec(ctx) {
         const sessionCwd = auth?.sessionId ? effectiveHostWorkspace(perSessionCwd.get(auth.sessionId), {}) : undefined;
         return sessionCwd ?? (executionLaneOf(config.remoteExec?.provider) === "in-process" ? process.cwd() : undefined);
     };
-    const memoryProjectLayers = createMemoryProjectLayers({ backend: memoryEngine?.backend, syncRunner: memorySyncRunner, log: logger });
+    const memoryProjectLayers = createMemoryProjectLayers({ stores: memoryEngine, syncRunner: memorySyncRunner, log: logger });
     if (onlySensitiveBaseline)
         logger.warn(onlySensitiveBaseline.event, onlySensitiveBaseline.fields);
     const approvalGrantNotice = buildApprovalGrantNotice(config);
@@ -179,9 +181,9 @@ export function createResolveSpec(ctx) {
     };
     const gateScenarioAndAppend = async (body, auth, opts) => {
         const scenarioName = await scenarioGate(auth?.principal, body.scenario);
-        gateExecutionLane(await principalCaps?.executionRuling(auth?.principal), executionLaneOf(config.remoteExec?.provider), logger);
-        const sessionWitness = auth?.sessionId !== undefined ? { sessionId: auth.sessionId, incarnation: (sessionHeadOf === undefined ? undefined : sessionFaceOfHead(auth.sessionId, await sessionHeadOf(auth.sessionId)))?.incarnation ?? null } : undefined;
-        const cap = selectScenario(scenarios, scenarioName)(body, auth?.principal, sessionWitness !== undefined ? { sessionId: sessionWitness.sessionId, delegationRoot: sessionWitness } : {});
+        const root = opts.execution.root;
+        const sessionWitness = { sessionId: root, incarnation: (sessionHeadOf === undefined ? undefined : sessionFaceOfHead(root, await sessionHeadOf(root)))?.incarnation ?? null };
+        const cap = selectScenario(scenarios, scenarioName)(body, auth?.principal, { sessionId: sessionWitness.sessionId, delegationRoot: sessionWitness });
         const acceptedAppend = acceptAppendSystemPrompt(body.appendSystemPrompt, (detail) => logger.warn("append_system_prompt_dropped", { detail, sessionId: auth?.sessionId ?? null }));
         const objective = typeof body.objective === "string" ? body.objective : "";
         const parsedSettings = parseTaskSettings(body.settings, opts?.leg === "fresh" || !taskHooksHonored(config) ? {} : { storedHooksReread: storedHooksRereadM20(new Date().toISOString().slice(0, 10)) });
@@ -375,7 +377,6 @@ export function createResolveSpec(ctx) {
             appendSystemPrompt: acceptedAppend,
             ...(body.outputStyle !== undefined ? { outputStyle: body.outputStyle } : {}),
             ...(body.projectMemory !== undefined ? { projectMemory: body.projectMemory } : {}),
-            sessionId: auth?.sessionId,
             ...(legProjectId !== undefined ? { projectId: legProjectId } : {}),
             principal: auth?.principal,
             images: body.images,
@@ -396,7 +397,6 @@ export function createResolveSpec(ctx) {
             suggestNextPrompts: normalizeSuggestNextPrompts(body.suggestNextPrompts),
             restoreFiles: body.restoreFiles === true ? true : undefined,
             acceptPartialRestore: body.acceptPartialRestore === true ? true : undefined,
-            ...(body.rewindFiles === true ? { rewindFiles: true } : {}),
             rewindFilesTo: rewindFilesToEntryId,
             ...(body.fileHistory === "disabled" ? { fileHistory: "disabled" } : {}),
             additionalDirectories,
@@ -492,7 +492,7 @@ export function createResolveSpec(ctx) {
             memory: memoryEngine
                 ? memorySpecForRequest(auth?.memoryScope, projectKey, body.memoryWrite, s4DefaultScopes, { multiTenant: config.requirePrincipal === true }, { memory: body.memory, memoryCapture: body.memoryCapture })
                 : undefined,
-            ...((v) => (v !== undefined ? { memoryPersistenceCapable: v } : {}))(effectiveMemoryPersistenceCapable(config)),
+            ...(config.memoryPersistenceCapable !== undefined ? { memoryPersistenceCapable: config.memoryPersistenceCapable } : {}),
             tools: ((base) => {
                 const extra = [...(selectEnvTool ? [selectEnvTool] : []), ...(sendUserFileToolSpec ? [sendUserFileToolSpec] : [])];
                 const merged = extra.length > 0 ? [...(base ?? []), ...extra] : base;
@@ -523,7 +523,6 @@ export function createResolveSpec(ctx) {
                     ...((rs) => (rs ? { resourceSuspend: rs } : {}))(resourceSuspendOptIn({
                         enabled: config.resourceSuspend,
                         ttlSec: config.resourceSuspendTtlSec,
-                        isVerify: body.verify === true,
                         isCascade: body.cascade === true,
                         scope: encodeCheckpointScope(auth?.principal),
                         totalTokens: config.resourceSuspendTotalTokens,
@@ -670,9 +669,7 @@ export function createResolveSpec(ctx) {
     };
     const resolveSpecForLeg = async (body, req, auth, opts) => {
         const spec = await resolveSpec(body, req, auth, opts);
-        if (opts?.unattendedLeg !== true)
-            return spec;
-        return withUnattendedLeg(spec);
+        return unrooted(opts.unattendedLeg !== true ? spec : withUnattendedLeg(spec));
     };
     return resolveSpecForLeg;
 }

package/dist/boot/retention-lane.d.ts

@@ -158,14 +158,15 @@ export interface RetentionSweepOutcome {
  *  · core 那道判**配对**,锁不锁都判(`executor` 必给):声明 `managed` 的店 × 没有执行器(`null`)⇒ 拒;执行器四个契约方法
  *    (`listRetentionDomains` / `expireCheckpoints` / `deleteExpiredSessions` / `deleteOrphanToolResults`)缺一 ⇒ 拒;
  *    **锁着**的策略盖在声明 `none` 的店上 ⇒ 拒。它不问 lane 开没开、策略在不在,也不拦没锁时「执行器在场 × 店声明 `none`」(部署可以持有执行器而不在某只店上跑);
- *  · **本道**问的是「lane 开着的时候,它真的能删吗」——**不看 locked 状态**:策略在场、执行器在场、lane 调的**五**个方法都在
+ *  · **本道**问的是「lane 开着的时候,它接得上能删的东西吗」——**不看 locked 状态**:执行器在场、lane 调的**五**个方法都在
  *    (多出的 `previewRetention` 是 audit-only 档的读数口,不在 core 的四方法契约里,引擎的检查覆盖不到它)、每只被 lane 消费的店都声明 `managed`。
  *    「执行器在场」与「契约方法齐」两格和引擎的判官说的是同一件事(各自一句拒句),其余几格是引擎不问的。
  *
+ * 「lane 开着而没有视界(天数)」与「`RETENTION_MODE=enforce` 而车道不齐」不在本道:那是配置事实,判在 `loadConfig` 的配置不变量段
+ * (`config-invariants.ts` 的 `retentionLaneRefusal`,一条规则)—— 到得了本道的部署,lane 开着就一定有视界。本道只判**接线**(配置看不见的那几格)。
+ *
  * 为什么本道必须存在:引擎的门不拦
- *  ① `RETENTION_SWEEP_INTERVAL_SEC>0` 而 policy 缺席 = 没有有效 cutoff 的 sweep(每 tick 什么都算不出来,
- *     读数一路 0,看起来像"没有候选");
- *  ② 没锁时,执行器在场 × 一只 `"none"` 的店 —— 部署于是**广告了一个不执行的留存面**:能力位说
+ *  · 没锁时,执行器在场 × 一只 `"none"` 的店 —— 部署于是**广告了一个不执行的留存面**:能力位说
  *     `{mode,maxAgeDays}`、审计表也在长,而那只店的行谁都没在删。
  *     本仓的 SQL 后端按同一个事实(扫车道开不开,`plugins/retention-store-sql.ts` 的 `retentionSweepRuns`)给它铸的三只店声明词,所以 lane 开着时
  *     这三只店在这一格上恒是 `managed`;这一格防的是声明与 lane 脱钩的店(别的后端、替身)。
@@ -176,7 +177,6 @@ export interface RetentionSweepOutcome {
  */
 export declare function assertRetentionLaneWirable(input: {
     intervalSec: number;
-    policy: RetentionPolicy | undefined;
     executor: RetentionExecutor | undefined;
     stores: ReadonlyArray<{
         name: string;

package/dist/boot/retention-lane.js

@@ -7,12 +7,6 @@ export function assertRetentionLaneWirable(input) {
     if (input.intervalSec <= 0)
         return;
     const lockNote = input.locked === true ? " (the retentionPolicy key is LOCKED, but this gate refuses either way)" : "";
-    if (input.policy === undefined) {
-        throw new Error(`RETENTION_SWEEP_INTERVAL_SEC=${input.intervalSec} arms the managed-retention sweep lane, but RETENTION_MAX_AGE_DAYS is not ` +
-            `configured — the lane would run with NO horizon to compute a cutoff from, enumerate domains every tick and delete nothing, ` +
-            `while the capability surface advertises a retention face that does not exist${lockNote}. Set RETENTION_MAX_AGE_DAYS, or set ` +
-            `RETENTION_SWEEP_INTERVAL_SEC=0 to leave the lane off.`);
-    }
     if (input.executor === undefined) {
         throw new Error(`RETENTION_SWEEP_INTERVAL_SEC=${input.intervalSec} arms the managed-retention sweep lane, but this deployment wires NO retention ` +
             `executor — the destructive store methods live on the SQL backends only (DB_BACKEND=mysql|pg); the local/file backend honestly ` +

package/dist/boot/runner-deps.d.ts

@@ -66,7 +66,9 @@ export declare function createRunnerDepsOnAsk(toolApproval: ToolApprovalCoordina
  *  [ref]:第五词 `shell-gate-off` 随 core 7.34.0 的 off 车道一起退役(引擎侧零发射点),同批删 —— 它唯一的本仓消费者
  *  (「本 session 显式 bypass ⇒ 降级 info」那条回查腿与 `boot/session-shell-gate-registry.ts` 登记簿)一并删干净。所以这是「按实现亲读」的开集快照,不是 core 类型闭集——词表外的值原样进日志并标
  *  `classificationKnown:false`(指标标签折 `unknown`),不吞不编;与安装包的锁步由 test/boot-runner-deps-shared-base.test.ts
- *  的 dist 扫描格钉住(两种发射写法都读;读不出词的经变量发射点本身红;core 加词/收进 d.ts 那天先红)。 */
+ *  的 dist 扫描格钉住(两种发射写法都读;读不出词的经变量发射点本身红;core 加词/收进 d.ts 那天先红)。
+ *  第七词 `peer-seat-hold`(runtask 的 `holdDeclarations`,字面量):对端座的三员对象里 `hold` / `release` 抛了 ⇒ 引擎报一次、该引用
+ *  不被持有;座是本仓的 desk,所以这是部署自己的故障,与其余六词同走 warn + 计数。 */
 export declare const CONFIG_ADVISORY_CLASSIFICATIONS: ReadonlySet<string>;
 /** [ref]:core 的 [ref] 前缀缓存**断裂**探测器交给宿主的根因**闭集**,以及每个词的日志级别。
  *  闭集**不抄词**:词源直接取 core 公开导出的 `CacheBreakFinding["cause"]`(`@sema-agent/core` 根导出,
@@ -181,7 +183,7 @@ export interface RunnerDepsCtx {
      *  (`backend.sessionCaptureRecords()`,main.ts 取**一次**、与四只 operator 面引擎同一只源 —— 全站同批
      *  注入律,机器钉 = test/memory-capture-optout-lane.test.ts ②)。在场 ⇒ `capture:"off"` 声明与中途翻转
      *  verb 真持久;缺席 ⇒ core 读作「无店」,而 core 的 `captureCarrierUnsupported` 判据是**席位在不在**
-     *  (不是「文件形能不能用」),叠上 `isRemoteExecutionEnv` 的接口形鸭子判 ⇒ 两条 ingress 都拒
+     *  (不是「文件形能不能用」),叠上执行环境块 `hostLocalPaths` 为假(沙箱 / 远端 / 设备车道)⇒ 两条 ingress 都拒
      *  `config.memory_capture_unsupported`。[ref] 起三条车道都供(SQL 双方言 twin / local 的控制面文件三腿),
      *  所以缺席今天只剩一个成因:**记忆面暗**的 local 部署(那时 core 的 capture 腿本就不参与)。 */
     sessionCaptureRecords: SessionCaptureRecordSource | undefined;
@@ -245,7 +247,7 @@ export interface RunnerDepsCtx {
 }
 /** [ref] A10 留档发现②:main runner `RunnerDeps` 与 main.ts subRunner 字面量之间此前手工重复
  * 的 ~15 个键,类型标注见 {@link createSharedRunnerDeps} 头注。 */
-export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "memoryEngineDir" | "allowedTools" | "crossBoundaryPosture" | "models" | "roles" | "tiers" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "mods" | "toolResultStore" | "checkpointStore" | "hands" | "sessionPolicyStore" | "usageWindows" | "usageWindowStore" | "memoryScopeAdmission" | "deploymentMemoryScopes" | "sharedMemoryStores" | "compliancePostureResolver" | "lockedConfig" | "retentionPolicy" | "onNotice" | "mcpRevocations" | "peerSeat">;
+export type SharedRunnerDeps = Pick<RunnerDeps, "brain" | "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "readDenyFloorRequired" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "memoryEngineDir" | "allowedTools" | "crossBoundaryPosture" | "models" | "roles" | "tiers" | "pricing" | "tracer" | "promptSource" | "executionEnvFactory" | "lspManager" | "backgroundAgentStore" | "mailboxStore" | "rosterStore" | "mods" | "toolResultStore" | "checkpointStore" | "hands" | "sessionPolicyStore" | "usageWindows" | "usageWindowStore" | "memoryScopeAdmission" | "deploymentMemoryScopes" | "sharedMemoryStores" | "compliancePostureResolver" | "lockedConfig" | "retentionPolicy" | "onNotice" | "mcpRevocations" | "peerSeat">;
 /**
  * [ref] A10 留档发现②(review 2026-07-29,[ref]§三族A 同源修补的延续):main runner 的
  * `RunnerDeps` 字面量(下方 `createRunnerDeps`)与 `main.ts` 里 subRunner 的 `new Runner({...})`
@@ -320,7 +322,7 @@ export declare function createEngineNoticeSeat(logger: {
  * 「键为 undefined」与「键缺席」对引擎逐字等价)。**不复制引擎缺省**(`roots`/`static-face`/`carry`/`open`/
  * CC parity 20/200 一个都不抄):上游改缺省之日起本仓不会成为第二份真源。
  */
-export type DeploymentPostureSeats = Pick<RunnerDeps, "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "allowedTools" | "agentConfigDir" | "crossBoundaryPosture">;
+export type DeploymentPostureSeats = Pick<RunnerDeps, "readFace" | "readDenyPatterns" | "readDenyBuiltinTiers" | "readDenyBuiltinExclude" | "readDenyFloorRequired" | "memoryDelegationEvidence" | "memoryProvenance" | "memoryCapturePolicy" | "delegationEntryCaps" | "crossSessionInbound" | "crossSessionDialogExpiry" | "writeProtectedPaths" | "allowedTools" | "agentConfigDir" | "crossBoundaryPosture">;
 /** 本族读的配置切面:席名与 config 键同名的那几席 + 运维 allow 表(席 `allowedTools` ← config `approvalGrant`,env 名 `APPROVAL_GRANT` 不改)
  *  + LKG 覆写路径(`readDenyPatterns` 席并入它派生的读拒行,`lkgReadDenyRows`)+ 主体门(席 `crossBoundaryPosture` ← config `requirePrincipal`)。 */
 export type DeploymentPostureConfig = Pick<ServiceConfig, Exclude<keyof DeploymentPostureSeats, "allowedTools" | "crossBoundaryPosture"> | "approvalGrant" | "configLkgPath" | "requirePrincipal">;

package/dist/boot/runner-deps.js

@@ -32,6 +32,7 @@ export const CONFIG_ADVISORY_CLASSIFICATIONS = new Set([
     "file-history-no-store",
     "interaction-posture-refused",
     "memory-tools-not-mounted",
+    "peer-seat-hold",
     "sandbox-admission-unavailable",
     "shared-memory-not-mounted",
 ]);
@@ -78,6 +79,7 @@ export function buildDeploymentPostureSeats(config) {
         readDenyPatterns: readDenyAdditions ? readDenyAdditions : undefined,
         readDenyBuiltinTiers: config.readDenyBuiltinTiers ?? undefined,
         readDenyBuiltinExclude: config.readDenyBuiltinExclude ?? undefined,
+        readDenyFloorRequired: config.readDenyFloorRequired,
         agentConfigDir: config.agentConfigDir ?? undefined,
         memoryDelegationEvidence: config.memoryDelegationEvidence ?? undefined,
         memoryProvenance: config.memoryProvenance ?? undefined,
@@ -131,7 +133,7 @@ export function createSharedRunnerDeps(ctx) {
         lockedConfig: ctx.governanceSeams.lockedConfig,
         retentionPolicy: ctx.governanceSeams.retentionPolicy,
         mcpRevocations: ctx.mcpRevocations ? ctx.mcpRevocations : undefined,
-        peerSeat: ctx.peerDesk.seat.answer,
+        peerSeat: ctx.peerDesk.seat,
     };
     return shared;
 }

package/dist/boot/session-faces.d.ts

@@ -21,7 +21,6 @@ import type { createSessionStore } from "../plugins/session-store.js";
 import type { TaskAttachmentStore } from "../plugins/task-attachment-store.js";
 import type { FileHistoryErasureFace } from "../file-history-capture.js";
 import type { OwnerAwareSessionStore } from "../security.js";
-import type { DeviceStore } from "../device-store.js";
 import { SessionWatchRegistry } from "../session-watch.js";
 import type { TaskListLane } from "./task-list-lane.js";
 import { type RunnerDeps } from "@sema-agent/core";
@@ -48,8 +47,6 @@ export interface SessionFacesCtx {
     workflowCompletionInbox: WorkflowCompletionInbox | undefined;
     /** [ref]:会话级任务清单车道(E21 级联的一条腿)。缺席 = 装配未接本车道 ⇒ 无清单可删。 */
     taskListLane: TaskListLane | undefined;
-    /** device lane 的四表店(E21 级联的一条腿:`device_session` 绑定行随会话删)。缺席 = 非 SQL 后端。 */
-    deviceStore: DeviceStore | undefined;
     /** per-session cwd/shellEnv 登记簿的清除口(E21 级联的一条腿,codex R1-F1)。缺席 = 装配未接。 */
     dropSessionScoped: ((sid: string) => void) | undefined;
     /** [ref]:会话盒(`session.<id>`)的信箱 + 它的收件人生命周期面(E21 级联的一条腿)。**成对**在场