@sema-agent/server 7.139.0 → 7.141.0

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

@@ -40,7 +40,7 @@
  * `memory_harvest_rejections_total{code}` + 一条 warn,见 `boot/runner-deps.ts` 的 harvest 报告站点),
  * 等下一次非受限会话走正常门收编。
  * ⚠️ **这一层只在 file 记忆引擎上**(受限视图 = `FileMemoryEngineBackend` 的实装,`materialize` 取它是
- * `?? this.backend` 的可选 seam):`MEMORY_ENGINE_BACKEND=pg|tidb` 的两条腿读侧走库、盘上只是每任务投影,
+ * `?? this.backend` 的可选 seam):`MEMORY_ENGINE_BACKEND=pg|mysql` 的两条腿读侧走库、盘上只是每任务投影,
  * 没有「读磁盘即收编」的通道,`false` 在它们上仍买到披露/写门/零收编 harvest 三件。
  * ⚠️ **口径别混**:受限 = **会话级 verdict 单键**(declared-false 那一个键);`writeScope:null` 的只读
  * **平面**(请求键 `memoryWrite:false` 的 per-run 暂停 / org 层默认只读 / 双根非写面)**保持 adopt-on-read
@@ -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,21 +68,14 @@ 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`)。**只进文案**,不参与任何判决 —— 它在这里的
      *  唯一作用是把「怎么把根挪进围栏」这句话指向**在该腿上真的有效**的那个旋钮:`MEMORY_ENGINE_DIR` 只被
-     *  file 腿读(memory-scope 的 `resolveMemoryEngineRoot`),pg/tidb 腿的根是
+     *  file 腿读(memory-scope 的 `resolveMemoryEngineRoot`),pg/mysql 腿的根是
      *  `<LOCAL_DATA_ROOT|数据根>/memory-work`(boot/stores.ts 两支),那条腿上指 MEMORY_ENGINE_DIR 是让
      *  operator 去拧一个不接线的旋钮 —— 修不好还以为自己修了。 */
     engineBackend: 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 的解析器,本仓不持第二份。
@@ -208,7 +210,7 @@ export declare function consolidationSeatBillingOf(plane: ConsolidationSeatPlane
  *    (结构上跑不起来由下游 D1 三条拒启臂照拒,本判决不吞);开而座落主模型 ⇒ 开 + 一行
  *    `memory_consolidation_on_main_model`(部署方显式承担,但必须知道账按主模型记)。
  *  · **未设 = 出厂缺省派生**([ref] 取代 [ref] ① 的「出厂 off」实况):
- *      结构上跑不起来(判官 {@link consolidationDriverUnwirable} 有成因:多租户 / `MEMORY_ENGINE=off` / pg·tidb
+ *      结构上跑不起来(判官 {@link consolidationDriverUnwirable} 有成因:多租户 / `MEMORY_ENGINE=off` / pg·mysql
  *      记忆后端 / `MEMORY_PROVENANCE=off`)⇒ **恒关、零提示、零探针** —— 派生开撞上 D1 拒启臂 = 每台配了便宜模型的
  *      多租户 worker 升级即起不来;而配不配便宜模型它都开不了,一句指向 `MODEL_CHEAP_ID` 的提示是误导;
  *      座不落主模型({@link consolidationSeatBillingOf} = `own-model`)⇒ **开**;
@@ -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,7 +4,8 @@ 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 { 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;
@@ -113,7 +114,7 @@ function unwirableRefusal(code, facts) {
                 `(MEMORY_ENGINE_BACKEND=${facts.memoryEngineBackend}) does NOT own an engine control plane (controlPlaneRoot) — ` +
                 `core would derive one on THIS replica's local disk, and a consolidation run's resumable account would die with ` +
                 `the pod (a lost run re-mints the whole library at full model cost on the next attempt). The file memory backend ` +
-                `owns a control plane; the pg/tidb memory backends do not. Set MEMORY_ENGINE_BACKEND=file, or set ` +
+                `owns a control plane; the pg/mysql memory backends do not. Set MEMORY_ENGINE_BACKEND=file, or set ` +
                 `MEMORY_CONSOLIDATION_DRIVER=off.`);
         case "provenance-off":
             return (`MEMORY_CONSOLIDATION_DRIVER=on is incompatible with MEMORY_PROVENANCE=off — core refuses to enable consolidation ` +
@@ -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/reapers.d.ts

@@ -167,8 +167,8 @@ interface ReapSessionsInputs {
  * 的那条臂**结构上看不见**它(它从行出发枚举),只有从会话侧枚举才找得到。
  *
  * 两只面必须落在**host durable 店**上,而 release 这一格是承重的:
- *  · `listPlaced` = host 店的分区枚举(SQL 孪生实装;local/File 后端无此面 ⇒ 键**不设**,core 那条腿
- *    如实不可用 —— 绝不给一个恒返回 `[]` 的假面,那会把「枚不了」读成「没有孤儿」);
+ *  · `listPlaced` = host 店的分区枚举(三只持久会话店都实装:SQL 两孪生读 `session_meta`,local 读会话存档行头;
+ *    店上没有这只面 ⇒ 键**不设**,core 那条腿如实不可用 —— 绝不给一个恒返回 `[]` 的假面,那会把「枚不了」读成「没有孤儿」);
  *  · `release` 对 **placed id** 必须走 host 店:路由店(`ForkRoutingSessionStore`)对一个重启后不认识
  *    的 id 会回落 transient(进程内 no-op),那会让 core 数出一次**从未发生**的 release
  *    (`orphanPlacedReleased` 当场变成谎)而字节还在库里。故先按**持久化元组**判(一次 PK 探针),

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";
@@ -17,6 +16,7 @@ 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 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

@@ -1,6 +1,6 @@
 import { realpathSync } from "node:fs";
 import { join } from "node:path";
-import { NodeExecutionEnv, QUESTION_AWAITS_RESUME, deriveAskEffective, expandTiers, modePolicyOf, resolveAskSeamForm } from "@sema-agent/core";
+import { NodeExecutionEnv, QUESTION_AWAITS_RESUME, deriveAskEffective, expandTiers, resolveAskSeamForm } from "@sema-agent/core";
 import { cappedCeiling } from "../budget.js";
 import { recordFailOpen } from "../observability/fail-open.js";
 import { SessionEnvironmentSelection, selectEnvironmentTool } from "../capabilities/select-environment-tool.js";
@@ -14,7 +14,7 @@ import { createDeploymentListExemption, gateIntentUnserviceableReason, singleUse
 import { acceptShellScratchpadDir, buildEnvFacts, egressForRemoteExec, ensureScratchpadDir, resumeFactsForLane, scratchpadCoveringTaskRoot } from "../env-facts.js";
 import { FleetEventBus } from "../fleet/fleet-bus.js";
 import { createSettingsHooksRegistration, settingsHooksBudgetMs } from "../hooks/hook-runner.js";
-import { HOST_POSTURE_REFUSED_CODE, taskInheritEnvRefusal, taskWriteFaceRefusal } from "../hosted-posture.js";
+import { HOST_POSTURE_REFUSED_CODE, permissionModeWriteFaceRefusal, taskInheritEnvRefusal } from "../hosted-posture.js";
 import { headerStr } from "../http/principal-gate.js";
 import { explicitOperatorOk } from "../http/server.js";
 import { isAtMentionable, matchCatalogModel, refusedCatalogEntry, resolveTaskModel, selectableCatalog, terminalCatalogName } from "../model-select.js";
@@ -51,7 +51,7 @@ 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 { executionConfigRootOf } from "../execution-config-root.js";
 import { withUnattendedLeg } from "../unattended-permission-mode.js";
 import { fieldConflictFacts } from "../field-conflict.js";
 function unrooted(spec) {
@@ -75,7 +75,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);
@@ -161,8 +161,8 @@ export function createResolveSpec(ctx) {
             assertRequestImageUrls(body.images);
         const gated = await gateScenarioAndAppend(body, auth, opts);
         const effMode = effectivePermissionMode(body, gated.parsedSettings.settings);
-        if (effMode !== undefined && modePolicyOf(effMode).writeFace === "open") {
-            const why = taskWriteFaceRefusal(config);
+        {
+            const why = permissionModeWriteFaceRefusal(effMode, config);
             if (why !== undefined)
                 throw new HttpError(422, why, { code: HOST_POSTURE_REFUSED_CODE });
         }
@@ -493,7 +493,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;
@@ -524,7 +524,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,
@@ -581,9 +580,11 @@ export function createResolveSpec(ctx) {
                 ? await ensureScratchpadDir(config.localDataRoot ?? localRoot, auth.sessionId, (msg, meta) => logger.warn(msg, { ...(meta ?? {}), sessionId: auth.sessionId }))
                 : undefined);
         if (effectiveSettings) {
+            const configRoot = executionConfigRootOf(config);
             const ruleBases = {
                 ...(pathAdjudication.taskRoot !== undefined ? { taskRoot: pathAdjudication.taskRoot } : {}),
                 ...(pathAdjudication.taskHome !== undefined ? { taskHome: pathAdjudication.taskHome } : {}),
+                ...(configRoot !== undefined ? { configRoot } : {}),
             };
             try {
                 governed = applyTaskSettings(governedBase, effectiveSettings, ruleBases);

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

@@ -183,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;
@@ -247,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({...})`
@@ -322,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

@@ -79,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,

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

@@ -16,7 +16,7 @@ import type { Logger } from "../observability/logger.js";
 import type { Metrics } from "../observability/metrics.js";
 import type { WorkflowCompletionInbox } from "../orchestration/workflow-completion-inbox.js";
 import { PlanCacheProbe } from "../plan-cache-probe.js";
-import type { CheckpointStoreFull, StoreBackend, ToolResultStoreFull } from "../plugins/store-backend.js";
+import { type CheckpointStoreFull, type StoreBackend, type ToolResultStoreFull } from "../plugins/store-backend.js";
 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";

package/dist/boot/session-faces.js

@@ -2,6 +2,7 @@ import { buildRewindHandles, buildSessionAudit, buildSessionAuditLocal, buildSes
 import { makeDegenerateInstrument } from "../degenerate-instrument.js";
 import { PlanCacheProbe } from "../plan-cache-probe.js";
 import { purgeScratchpadDir } from "../env-facts.js";
+import { localSessionRowsOf } from "../plugins/store-backend.js";
 import { setLeafAdvanceListener } from "../session-leaf-bus.js";
 import { SessionWatchRegistry, posIntEnv } from "../session-watch.js";
 import { defaultTaskRegistry, peerSessionBoxHandle } from "@sema-agent/core";
@@ -14,17 +15,17 @@ export function createSessionFaces(ctx) {
     const { config, logger, metrics, localRoot, backend, sessionStore, runStore, checkpointStore, toolResultStore, resumeAnchorStore, approvalExemptionStore, sessionPolicyStore, taskAttachmentStore, fileHistoryErasure, workflowCompletionInbox, taskListLane, dropSessionScoped, mailboxStore, mailboxRecipientLifecycle, backgroundAgentStore, userInputLedgerStore, spaceReclaimer, } = ctx;
     const mysqlPool = backend?.mysqlPool();
     const auditPgPool = backend?.pgPool();
-    const auditLocalRoot = backend?.kind === "local" ? (config.localDataRoot ?? localRoot) : undefined;
+    const auditLocalRows = localSessionRowsOf(backend);
     const ownerAware = sessionStore;
     const headOf = headReadOf(sessionStore);
-    const sessionAudit = mysqlPool || auditPgPool || auditLocalRoot
+    const sessionAudit = mysqlPool || auditPgPool || auditLocalRows
         ? async (sessionId, opts) => {
             const handles = opts !== undefined && resumeAnchorStore !== undefined ? buildRewindHandles(await resumeAnchorStore.listBySession(sessionId), opts.reader) : undefined;
             const audit = mysqlPool
                 ? await buildSessionAudit(mysqlPool, sessionId, handles)
                 : auditPgPool
                     ? await buildSessionAuditPg(auditPgPool, sessionId, handles)
-                    : await buildSessionAuditLocal(auditLocalRoot, sessionId, handles);
+                    : await buildSessionAuditLocal(auditLocalRows, sessionId, handles);
             if (!audit)
                 return undefined;
             const [head, placement] = await Promise.all([headOf?.(sessionId), opts !== undefined ? ownerAware.placementOf?.(sessionId) : undefined]);

package/dist/boot/shutdown.js

@@ -74,6 +74,7 @@ export function installShutdownHandlers(ctx) {
     let closingAt = 0;
     let parentWatch;
     let engineLease;
+    let leaseFactsReader;
     const hardShutdown = () => {
         if (closing)
             return;
@@ -280,6 +281,8 @@ export function installShutdownHandlers(ctx) {
                 : {}),
             log: (event, fields) => logger.info(event, fields),
         });
+        leaseFactsReader = () => engineLease?.facts;
+        drainState.engineLease = leaseFactsReader;
     }
     let disposed = false;
     return {
@@ -302,6 +305,8 @@ export function installShutdownHandlers(ctx) {
             engineLease?.stop();
             if (drainState.enter === enterByRequest)
                 drainState.enter = undefined;
+            if (leaseFactsReader !== undefined && drainState.engineLease === leaseFactsReader)
+                drainState.engineLease = undefined;
         },
     };
 }

package/dist/boot/stage-03-store-backend.d.ts

@@ -7,16 +7,12 @@ export declare function runStage03(ctx: Awaited<ReturnType<typeof runStage02>>):
     instanceId: string;
     mailboxRecipientLifecycle: import("../plugins/mailbox-recipient-lifecycle.js").MailboxRecipientLifecycle | undefined;
     mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
-    memoryEngine: {
-        backend: import("@sema-agent/core").MemoryBackend;
-        root: string;
-    } | undefined;
-    memoryExportBackend: import("@sema-agent/core").MemoryBackend | undefined;
+    memoryEngine: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
+    memoryExportStores: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
     memoryPosture: import("../memory-posture.js").MemoryPosture;
     memorySyncCursors: import("../plugins/memory-sync-store-pg.js").MemorySyncStore | undefined;
     memorySyncRunner: import("../memory-sync-client.js").MemorySyncRunner | undefined;
     rosterStore: import("@sema-agent/core").RosterStore | undefined;
-    sessionCaptureRecordStore: import("@sema-agent/core").SessionCaptureRecordStore | undefined;
     sessionCaptureRecords: import("../index.js").SessionCaptureRecordSource | undefined;
     sessionStore: import("@sema-agent/core").SessionStore<import("@sema-agent/core").SessionStoreSummary, import("@sema-agent/core").SessionListQuery>;
     sqlEngine: import("../plugins/sql-driver.js").SqlEngineReading | undefined;

package/dist/boot/stage-03-store-backend.js

@@ -2,10 +2,9 @@ import { uuidv7 } from "@sema-agent/core";
 import { openStores } from "./stores.js";
 export async function runStage03(ctx) {
     const { config, localRoot, logger, metrics } = ctx;
-    const { backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, mailboxRecipientLifecycle, memoryExportBackend, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngine, } = await openStores({ config, logger, metrics, localRoot });
+    const { backend, storePosture, memoryEngine, engineDataRoot, memorySyncCursors, rosterStore, backgroundAgentStore, taskAttachmentStore, mailboxStore, mailboxRecipientLifecycle, memoryExportStores, memorySyncRunner, sessionStore, breakerState, usageWindowStore, memoryPosture, taskListLane, sqlEngine, } = await openStores({ config, logger, metrics, localRoot });
     const instanceId = uuidv7();
     const sessionCaptureRecords = backend?.sessionCaptureRecords();
-    const sessionCaptureRecordStore = sessionCaptureRecords?.();
-    return { ...ctx, backend, backgroundAgentStore, breakerState, engineDataRoot, instanceId, mailboxRecipientLifecycle, mailboxStore, memoryEngine, memoryExportBackend, memoryPosture, memorySyncCursors, memorySyncRunner, rosterStore, sessionCaptureRecordStore, sessionCaptureRecords, sessionStore, sqlEngine, storePosture, taskAttachmentStore, taskListLane, usageWindowStore };
+    return { ...ctx, backend, backgroundAgentStore, breakerState, engineDataRoot, instanceId, mailboxRecipientLifecycle, mailboxStore, memoryEngine, memoryExportStores, memoryPosture, memorySyncCursors, memorySyncRunner, rosterStore, sessionCaptureRecords, sessionStore, sqlEngine, storePosture, taskAttachmentStore, taskListLane, usageWindowStore };
 }
 //# sourceMappingURL=stage-03-store-backend.js.map

package/dist/boot/stage-04-stores.d.ts

@@ -37,16 +37,12 @@ export declare function runStage04(ctx: Awaited<ReturnType<typeof runStage03>>):
     instanceId: string;
     mailboxRecipientLifecycle: import("../plugins/mailbox-recipient-lifecycle.js").MailboxRecipientLifecycle | undefined;
     mailboxStore: import("@sema-agent/core").MailboxStore | undefined;
-    memoryEngine: {
-        backend: import("@sema-agent/core").MemoryBackend;
-        root: string;
-    } | undefined;
-    memoryExportBackend: import("@sema-agent/core").MemoryBackend | undefined;
+    memoryEngine: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
+    memoryExportStores: import("../memory-scope-stores.js").MemoryScopeStores | undefined;
     memoryPosture: import("../memory-posture.js").MemoryPosture;
     memorySyncCursors: import("../plugins/memory-sync-store-pg.js").MemorySyncStore | undefined;
     memorySyncRunner: import("../memory-sync-client.js").MemorySyncRunner | undefined;
     rosterStore: import("@sema-agent/core").RosterStore | undefined;
-    sessionCaptureRecordStore: import("@sema-agent/core").SessionCaptureRecordStore | undefined;
     sessionCaptureRecords: import("../index.js").SessionCaptureRecordSource | undefined;
     sessionStore: import("@sema-agent/core").SessionStore<import("@sema-agent/core").SessionStoreSummary, import("@sema-agent/core").SessionListQuery>;
     sqlEngine: import("../plugins/sql-driver.js").SqlEngineReading | undefined;