@sema-agent/server 7.139.0 → 7.140.0

package/dist/memory-operator-faces.d.ts

@@ -5,9 +5,26 @@
  * ## 为什么是一个模块而不是 main.ts 里直接 new
  *
  * 同 `memory-bundle-engine.ts` 的那句话:本仓**没有**一个长命的 `MemoryEngine` 实例 —— `boot/stores.ts`
- * 装配出来的 `memoryEngine` 是 `{ backend, root }` 二元组,真引擎由 core 的 Runner **每任务现构**
- * (按任务的 scope 平面决定 `memoryDir`)。HTTP 面若要一个引擎,必须自己构;构的判断写在这里,main.ts
- * 只调用与转接。
+ * 装配出来的 `memoryEngine` 是记忆作用域店(`memory-scope-stores.ts`:部署的店 + 引擎根 + 「一层住哪只店」的唯一读者),
+ * 真引擎由 core 的 Runner **每任务现构**(按任务的 scope 平面决定店与 `memoryDir`)。HTTP 面若要一个引擎,必须自己构;构的判断写在这里,
+ * main.ts 只调用与转接。
+ *
+ * ## 引擎建在哪只店上:动词点名的层住的那只(一层的店只问记忆作用域店)
+ * 每个动词先定店,再在那只店上建(或复用)一只引擎 —— 一只店一只引擎,`memoryDir` = 那只店的挂载平面、控制面 = 那只店自带的。
+ * 店怎么定只有一条规则({@link memoryStoreForRequest}):请求点名的层(`select.scope`、`expectedScopes`、外源列表的 `scopes`、
+ * 不点名层的动词的层座 `{ layer }`)共住的那一只;不点名层 ⇒ 本部署点名的层与部署的店共处的那一只,分住两只就拒(`request.memory_layer`)。
+ * 修前三只工厂各在**部署的店**上建一只引擎 —— 目录钉住的部署上,类型化个人层(`user:` / `userproj:` / `org:`)的会话条目在个人挂载上的
+ * 另一只店里,擦的、查的、清标的都是会话不读的那只店。
+ *
+ * 会话 id 的两只动词不点名层(会话的写家在哪只店由它各条腿的任务根定,服务端没有存;一只会话可以跨两只店):
+ *  · 会话记忆状态读**本部署的每一只店**(`memoryStoresOfDeployment`,至多两只),逐店的答案按 {@link foldPlaneStatuses} 折成一份;
+ *  · 按会话抹除(`{ sessionId }` 选择子)落部署的店,见下一节的护栏。
+ *
+ * ## 抹除只在部署的店上执行({@link MemoryErasureStoreUnjudged})
+ * 抹除 `requestId` 的幂等判(重放收敛、同 id 换了选择子 ⇒ `memory.erasure_selector_mismatch`)记在**每只店自己的**证据链上,引擎今天没有
+ * 跨店的请求身份、也没有按 `requestId` 读锚的公开面;本层不另记一本请求账(第二真源)。所以本服务只在**一只**店上执行抹除 —— 部署的店,
+ * 它的证据链就是本部署唯一的判官:请求落到别的店(点名的层住在个人挂载那只店),或按会话抹除而这只会话在别的店里有贡献(或那只店的账读不出)
+ * ⇒ 409 拒,什么都不删。🚧 引擎给出部署级的抹除请求身份后,这条护栏删除、各店照常执行(钉在 `test/memory-project-scope.test.ts` ⑩)。
  *
  * ## 控制面归属:为什么 `controlPlaneRoot` 缺席就整口不挂(F-9 裁)
  *
@@ -46,6 +63,8 @@
  * 不是一回事(附录 A 两条分列)。
  */
 import { type EntryProvenanceAccount, type MemoryBackend, type MemoryEntryOrigin, type MemoryErasureAttestation, type OriginClearanceRow, type SessionCaptureRecordStore, type SessionMemoryStatus } from "@sema-agent/core";
+import { type MemoryScopeStores } from "./memory-scope-stores.js";
+import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
 /**
  * 控制面归属判据 —— 三个记忆操作面(合规两口 / 外源标记三口 / consolidation 阀门的 D1 拒启门)共用的
  * **同一只**谓词:backend 的面上带**非空** `controlPlaneRoot` 才算归属在案。空串与缺席同判「不归属」:
@@ -54,11 +73,22 @@ import { type EntryProvenanceAccount, type MemoryBackend, type MemoryEntryOrigin
  * 「逐字同源」成为结构事实而不是手抄承诺(merge-rescan 746 C-1:main.ts 手抄版漏了空串臂)。
  */
 export declare function backendOwnsControlPlane(backend: unknown): boolean;
+/**
+ * 一只店的 capture opt-out 记录店 —— 按**这只店的控制面**向记录源取(`StoreBackend.sessionCaptureRecords()` 的按平面取用;
+ * 会话装配向同一只源问的也是它那只平面的控制面,core `prepare-memory` 的 `memoryCaptureRecordStore({ controlDir })`)。
+ * 店带控制面归属 ⇒ 问那一只控制面(个人店 ⇒ 个人平面的记录,部署的店 ⇒ 部署那一只);不带(SQL 孪生)⇒ 不指名(SQL 源本就不按平面分)。
+ * 修前操作面引擎一律拿部署平面那一只:个人店上的整理会读错名册(看不见只在个人平面登记 opt-out 的会话)。
+ */
+export declare function captureRecordStoreOf(source: SessionCaptureRecordSource | undefined, store: MemoryBackend): SessionCaptureRecordStore | undefined;
+/** 不点名层的动词(条目 id / 会话 id / 店级账本)的**层座**:点名一层 ⇒ 动词答在这一层住的那只店上(这一层只用来定店)。 */
+export interface MemoryLayerSeat {
+    readonly layer: string;
+}
 /** 两口 HTTP 面消费的窄能力面(`ServiceDeps.memoryCompliance` 的实参来源)。 */
 export interface MemoryComplianceFaces {
     /** 单条出处账。core 的失败姿态原样穿过:控制面损坏 ⇒ `ControlPlaneCorruptError`(fail-closed,
      *  绝不在一个完整性未知的账上拼一个答案);能力缺席 ⇒ 三值 `capability-absent`,**不是**抛。 */
-    provenanceOf: (entryId: string) => Promise<EntryProvenanceAccount>;
+    provenanceOf: (entryId: string, at?: MemoryLayerSeat) => Promise<EntryProvenanceAccount>;
     /**
      * 抹除。入参 `unknown`:调用方递交的是未校验的对象,三选一选择子的整体判决归 core
      * (`erasureRequestInvalid` 是它的单一属主面)—— 在本层抄一遍就是第二真源。
@@ -69,14 +99,23 @@ export interface MemoryComplianceFaces {
      * 都得是集内成员,判在解析之后、店锁之内;违者整单拒 `config.memory_erasure_scope`,拒句不带数、不带 id、不带 scope(集外 id
      * 与从没存在过的 id 同句,不是存在性神谕)。本层不另设信封:一只只读得到 `{ scope }` 选择子字面量的信封判不了 `ids` /
      * `sessionId` 两腿、只能整拒,而且让「哪些 scope 能删」有两个答者。集随**入参**走(与 `requestId` / `select` 同一个对象),
-     * 本面没有第二个形参。
+     * 授权集也是定店的那一只读数之一(选择子不点名 scope 时,集里的层共住的那只店;见文件头「引擎建在哪只店上」)。
      *
      * 今天谁传集:operator 面原样递交调用方的体(调用方自己写的 `expectedScopes` = 它自己收窄自己);路由不替 operator 铸集 ——
      * 本仓没有任何授权源能对一个 operator 说「你只能动这些 scope」(`routes/memory-policy.ts` 的 `gateMemoryScope`:operator 支在查
      * 目录之前就 allow;`org-memory-admission.ts`:v1 不中央收窄 operator 声明的 scope)。拿 org 目录的 grant 集去凑一个集就是在本层
      * 发明第二套授权语义,与 `gateMemoryScope` 对同一个身份给出相反答案。会话自助面的选择子由路径铸,不带集。
      */
-    erase: (input: unknown) => Promise<MemoryErasureAttestation>;
+    erase: (input: unknown, at?: MemoryLayerSeat) => Promise<MemoryErasureAttestation>;
+}
+/**
+ * 本服务的「这次抹除不在本版受理的那只店上」拒(409 `memory.erasure_store_unjudged`):请求本身合法,是本部署此刻判不了同一个 `requestId`
+ * 跨店的幂等(见文件头「抹除只在部署的店上执行」)。什么都没删、什么都没记。句子不带层键、路径或任何值(两受众同一句;会话所有者受众另有固定句)。
+ * 🚧 引擎的部署级抹除请求身份到货后,本类连同抛它的两处删除。
+ */
+export declare class MemoryErasureStoreUnjudged extends Error {
+    readonly code: "memory.erasure_store_unjudged";
+    constructor();
 }
 /**
  * **选择子替身**的拦截谓词(codex 交叉复审 [critical],亲验复现后修 —— 复现器与结论逐条在
@@ -111,10 +150,11 @@ export interface MemoryComplianceFaces {
  */
 export declare function erasureInputSmugglesPrototypeKey(input: unknown): boolean;
 /**
- * 在**已装配的记忆后端**上建合规两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
+ * 在**记忆作用域店**上建合规两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * `memoryDir` = 引擎的**挂载平面**(`memoryMountRootOf(backend, root)` 单铸点:后端钉了 `directoryRoot`
- * 就是它 —— file 腿 = `<配置根>/memory`;两只 SQL 孪生不钉 ⇒ 回到配置根,读数逐字节不变)。
+ * 店:出处按层座定;抹除按选择子的 `scope` / `expectedScopes` 定(会话自助面由路径铸选择子,用层座)—— 见文件头。
+ * `memoryDir` = 那只店的**挂载平面**(`memoryMountRootOf(store, root)` 单铸点:店钉了 `directoryRoot`
+ * 就是它 —— file 腿 = `<配置根>/memory`,个人店 = 个人挂载;两只 SQL 孪生不钉 ⇒ 回到配置根,读数逐字节不变)。
  *
  * 🔴 **不是 `memoryEngine.root`**(2026 提货批订正,亲读 core 推翻旧注):旧注写着「这两条路径不读它」,
  * 而实装里 `erase` 的派生索引清扫(`engine.js` 的 `sweepErasedIndexLines`)与 `clearEntryOrigin` 的
@@ -123,10 +163,7 @@ export declare function erasureInputSmugglesPrototypeKey(input: unknown): boolea
  * **静默**:扫一棵不存在的树 ⇒ ENOENT ⇒ 跳过 ⇒ 零残留可报,而真正的 `MEMORY.md` 里还留着被抹条目的
  * 名字,收执却显示干净。机器钉:`test/memory-operator-faces.test.ts` 的「[ref] 提货」两格。
  */
-export declare function createMemoryComplianceFaces(store: {
-    backend: MemoryBackend;
-    root: string;
-}, 
+export declare function createMemoryComplianceFaces(stores: MemoryScopeStores, 
 /**
  * 引擎的 **advisory incident 座**(core `MemoryEngineOptions.onIncident`)。接它不是锦上添花:
  * 抹除腿上有一条**只走这个座**的码 —— `memory.erasure_index_residue`(engine.js)。它说的是
@@ -143,7 +180,7 @@ opts?: {
     onIncident?: (err: Error & {
         code?: string;
     }) => void;
-    captureRecordStore?: SessionCaptureRecordStore;
+    captureRecords?: SessionCaptureRecordSource;
 }): MemoryComplianceFaces | undefined;
 /** 件② 三口 HTTP 面消费的窄能力面(`ServiceDeps.memoryOriginFace` 的实参来源)。 */
 export interface MemoryOriginFaces {
@@ -164,12 +201,12 @@ export interface MemoryOriginFaces {
     }>>;
     /** §13-4② 读半场:清标审计账(**同步** —— core 的 `listOriginClearances` 就是一次严格 sidecar 读;
      *  账本损坏 ⇒ `ControlPlaneCorruptError`,fail-closed,绝不回半张表)。 */
-    listClearances: () => OriginClearanceRow[];
+    listClearances: (at?: MemoryLayerSeat) => OriginClearanceRow[];
     /** §13-4② 写半场:审计化的 UN-MARK 阀门。拒因族是 core 的**闭集码**,本层零翻译原样上抛。 */
     clear: (entryId: string, input: {
         requestId: string;
         reason: string;
-    }) => Promise<{
+    }, at?: MemoryLayerSeat) => Promise<{
         entryId: string;
         clearanceId: string;
         origin: MemoryEntryOrigin;
@@ -208,10 +245,7 @@ export interface MemoryOriginFaces {
  * ⚠️ **不在 seam 里翻译拒因码**:core 的 origin-clear 族是**闭集**,翻译点只有一个(路由的 switch),
  *    在这里再翻一遍就是第二真源。seam 原样抛,路由逐码字面量转发。
  */
-export declare function createMemoryOriginFaces(store: {
-    backend: MemoryBackend;
-    root: string;
-}, 
+export declare function createMemoryOriginFaces(stores: MemoryScopeStores, 
 /**
  * 引擎的 advisory incident 座(core `MemoryEngineOptions.onIncident`)。
  * 🔴 与合规面的同名座**理由不同,如实写**:亲读 core 5.59.0 的这三条动词路径(engine.js)
@@ -223,12 +257,34 @@ opts?: {
     onIncident?: (err: Error & {
         code?: string;
     }) => void;
-    captureRecordStore?: SessionCaptureRecordStore;
+    captureRecords?: SessionCaptureRecordSource;
 }): MemoryOriginFaces | undefined;
 /** [ref] seam① 的窄能力面(`ServiceDeps.sessionMemoryStatus` 的实参来源)。 */
 export interface SessionMemoryStatusFace {
+    /**
+     * 这次状态请求读的店:层座点名 ⇒ 那一层住的那一只;不带 ⇒ 本部署的每一只店(部署的店在前,至多两只;单店部署恰一只)——
+     * 路由逐店读,再按 {@link foldPlaneStatuses} 折成一份(会话 id 不点名层,一只会话可以跨两只店,见文件头)。每次请求都现定 ——
+     * 登记簿热换当场生效,路由的短窗缓存只缓存逐店的扫描,不缓存定店。唯一的拒:点名的层 / 本部署点名的层引擎读不出 ⇒ 同步抛 `request.memory_layer`。
+     */
+    storesAt: (at?: MemoryLayerSeat) => readonly SessionMemoryStatusStore[];
+}
+/** 一只店上的会话记忆状态读。 */
+export interface SessionMemoryStatusStore {
+    /** 这只店的控制面根(引擎自己的读数)—— 状态读扫的就是它;路由的短窗缓存按(会话, 它)分:落同一只店的层键别名是同一格。 */
+    readonly controlPlane: string;
     status: (sessionId: string) => Promise<SessionMemoryStatus>;
 }
+/** 状态面上 wire 的五键(引擎答案里其余的键不上 wire,也就不折)。 */
+export type FoldedSessionMemoryStatus = Pick<SessionMemoryStatus, "captureOptedOut" | "committedCount" | "foldedCount" | "optOutSource" | "lastCaptureAt">;
+/**
+ * 逐店的会话记忆状态 → 一份(**折叠律在代码里只写这一处**;契约 §9 开头同句)。每只店的答案都来自引擎,本函数只按键合,不补任何替身值:
+ *  · `committedCount` / `foldedCount`:各店相加;任一店缺席(那只店的账读不出)⇒ 缺席。
+ *  · `lastCaptureAt`:各店取最大;任一店的 `committedCount` 缺席(同一次账读失败)⇒ 缺席;都没有贡献 ⇒ 缺席(与引擎单店同义)。
+ *  · `captureOptedOut` / `optOutSource`:任一店有记录 ⇒ `true`,带那只店的 `optOutSource`(引擎恒是 `"record"`;一只店上的单向记录就是这只会话的记录);否则全部店答 `false` ⇒ `false`;
+ *    否则(有店故障)⇒ `captureOptedOut` 缺席,有店说 `"fault"` 就带 `optOutSource: "fault"`。
+ * 一只店 ⇒ 逐键与那只店的答案同(单店部署的应答字节不变)。🚧 引擎的部署级会话记忆状态到货后,本函数删除、路由直接投那一份。
+ */
+export declare function foldPlaneStatuses(statuses: readonly SessionMemoryStatus[]): FoldedSessionMemoryStatus;
 /**
  * [ref] seam①([ref] §S-7,core 7.0.2 [ref] 件1)—— `GET /v1/sessions/:id/memory-status` 的引擎面。
  * 命名照 CLAUDE.md 工厂律:返回带行为的活对象 ⇒ `create*`。
@@ -240,17 +296,16 @@ export interface SessionMemoryStatusFace {
  * 那是**说谎的 0**,比缺席更坏(S-7 的诚实键律:可读零必须是真零)。⇒ 归属缺席 ⇒ 工厂返 undefined,
  * HTTP 面诚实 501,与 erase/origin 同码同分支。
  *
- * `captureRecordStore` = [ref]② 的 SQL 载体(main.ts 单实例,与 Runner/其余引擎同源 —— 全站同批注入律,
- * 机器钉 capture-optout-lane ②):`captureOptedOut` / `optOutSource` 两键经它读,多副本部署上答的才是
- * 跨副本的真记录。[ref] 起 local 车道在引擎接线时也供(core 文件三腿,同一只控制面,单机字节不变);缺席 ⇒ 记忆面暗。
+ * `captureRecords` = [ref]② 的按平面取用源(main.ts 取一次,与 Runner/其余引擎同源 —— 全站同批注入律,
+ * 机器钉 capture-optout-lane ②;引擎按它那只店的控制面取,{@link captureRecordStoreOf}):`captureOptedOut` / `optOutSource`
+ * 两键经它读,多副本部署上答的才是跨副本的真记录。[ref] 起 local 车道在引擎接线时也供(core 文件三腿);缺席 ⇒ 记忆面暗。
  *
- * 面**不抛**(core 契约:sessionMemoryStatus never throws —— 每个事实源各自 catch 折缺席键);
+ * 引擎**不抛**(core 契约:sessionMemoryStatus never throws —— 每个事实源各自 catch 折缺席键);面唯一的拒是定店那一步的
+ * `request.memory_layer`(点名的层 / 本部署点名的层读不出)。不点名层 ⇒ 读本部署的每一只店、路由按 {@link foldPlaneStatuses} 折
+ * (只读一只店而它不装这只会话,答出来的就是一个说谎的 0)。
  * 不接 onIncident:这条只读路径上今天零 sink 站点,而且缺席键本身就是它的披露形。
  */
-export declare function createSessionMemoryStatusFace(store: {
-    backend: MemoryBackend;
-    root: string;
-}, opts?: {
-    captureRecordStore?: SessionCaptureRecordStore;
+export declare function createSessionMemoryStatusFace(stores: MemoryScopeStores, opts?: {
+    captureRecords?: SessionCaptureRecordSource;
 }): SessionMemoryStatusFace | undefined;
 //# sourceMappingURL=memory-operator-faces.d.ts.map

package/dist/memory-operator-faces.js

@@ -1,8 +1,59 @@
 import { MemoryEngine, } from "@sema-agent/core";
 import { memoryMountRootOf } from "./memory-scope.js";
+import { memoryStoreForRequest, memoryStoresOfDeployment } from "./memory-scope-stores.js";
 export function backendOwnsControlPlane(backend) {
-    const b = backend;
-    return typeof b?.controlPlaneRoot === "string" && b.controlPlaneRoot !== "";
+    return controlPlaneRootOf(backend) !== undefined;
+}
+function controlPlaneRootOf(backend) {
+    const root = backend?.controlPlaneRoot;
+    return typeof root === "string" && root !== "" ? root : undefined;
+}
+export function captureRecordStoreOf(source, store) {
+    if (source === undefined)
+        return undefined;
+    const root = controlPlaneRootOf(store);
+    return source(root !== undefined ? { controlDir: root } : undefined);
+}
+const seatLayers = (at) => (at !== undefined ? [at.layer] : []);
+function createEngineSeat(build) {
+    const engines = new Map();
+    return (store) => {
+        const known = engines.get(store);
+        if (known !== undefined)
+            return known;
+        if (!backendOwnsControlPlane(store))
+            throw new Error("the memory store that holds this layer owns no engine control plane (controlPlaneRoot) — the operator faces never answer over a store without one");
+        const engine = build(store);
+        engines.set(store, engine);
+        return engine;
+    };
+}
+function erasureLayersOf(input) {
+    if (typeof input !== "object" || input === null)
+        return [];
+    const { select, expectedScopes } = input;
+    const scope = typeof select === "object" && select !== null ? select.scope : undefined;
+    if (typeof scope === "string" && scope.length > 0)
+        return [scope];
+    if (Array.isArray(expectedScopes) && expectedScopes.length > 0 && expectedScopes.every((s) => typeof s === "string" && s.length > 0))
+        return expectedScopes;
+    return [];
+}
+function erasureSessionOf(input) {
+    if (typeof input !== "object" || input === null)
+        return undefined;
+    const { select } = input;
+    const sessionId = typeof select === "object" && select !== null ? select.sessionId : undefined;
+    return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : undefined;
+}
+export class MemoryErasureStoreUnjudged extends Error {
+    code = "memory.erasure_store_unjudged";
+    constructor() {
+        super("memory erasure refused: this erasure reaches a memory store other than the deployment's store (this deployment keeps the typed personal memory layers in a second store), " +
+            "and this build judges an erasure requestId on the deployment's store only, so it cannot tell whether the same requestId already erased under another selector there — " +
+            "erasures that reach the second store are not taken in this build, and nothing was erased; the way out is the engine's deployment-wide erasure request identity, due with the next engine update");
+        this.name = "MemoryErasureStoreUnjudged";
+    }
 }
 export function erasureInputSmugglesPrototypeKey(input) {
     const stack = [input];
@@ -24,50 +75,105 @@ export function erasureInputSmugglesPrototypeKey(input) {
     }
     return false;
 }
-export function createMemoryComplianceFaces(store, opts) {
-    if (!backendOwnsControlPlane(store.backend))
+export function createMemoryComplianceFaces(stores, opts) {
+    if (!backendOwnsControlPlane(stores.backend))
         return undefined;
-    const engine = new MemoryEngine({
-        backend: store.backend,
-        memoryDir: memoryMountRootOf(store.backend, store.root),
-        ...(opts?.onIncident !== undefined ? { onIncident: opts.onIncident } : {}),
-        ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}),
+    const engineOf = createEngineSeat((store) => {
+        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        return new MemoryEngine({
+            backend: store,
+            memoryDir: memoryMountRootOf(store, stores.root),
+            ...(opts?.onIncident !== undefined ? { onIncident: opts.onIncident } : {}),
+            ...(records !== undefined ? { captureRecordStore: records } : {}),
+        });
     });
+    const erasureStoreOf = async (input, at) => {
+        const seat = at !== undefined ? "`scope`" : "`select.scope`, or `expectedScopes` next to `select.ids` / `select.sessionId`";
+        const layers = at !== undefined ? seatLayers(at) : erasureLayersOf(input);
+        const sessionId = layers.length === 0 ? erasureSessionOf(input) : undefined;
+        if (sessionId === undefined) {
+            const store = memoryStoreForRequest(stores, layers, seat);
+            if (store !== stores.backend)
+                throw new MemoryErasureStoreUnjudged();
+            return store;
+        }
+        for (const other of memoryStoresOfDeployment(stores, seat)) {
+            if (other === stores.backend)
+                continue;
+            if ((await engineOf(other).sessionMemoryStatus(sessionId)).committedCount !== 0)
+                throw new MemoryErasureStoreUnjudged();
+        }
+        return stores.backend;
+    };
     return {
-        provenanceOf: (entryId) => engine.provenanceOf(entryId),
-        erase: (input) => {
+        provenanceOf: async (entryId, at) => engineOf(memoryStoreForRequest(stores, seatLayers(at))).provenanceOf(entryId),
+        erase: async (input, at) => {
             if (erasureInputSmugglesPrototypeKey(input)) {
                 const e = new Error("memory erasure refused: the request carries a key that rewrites an object's prototype — such a key is not a selector, and core's selector dispatch would read it in preference to the declared one");
                 e.code = "memory.erasure_selector_unsafe";
-                return Promise.reject(e);
+                throw e;
             }
-            return engine.eraseMemoryEntries(input);
+            const store = await erasureStoreOf(input, at);
+            return engineOf(store).eraseMemoryEntries(input);
         },
     };
 }
-export function createMemoryOriginFaces(store, opts) {
-    if (!backendOwnsControlPlane(store.backend))
+export function createMemoryOriginFaces(stores, opts) {
+    if (!backendOwnsControlPlane(stores.backend))
         return undefined;
-    const engine = new MemoryEngine({
-        backend: store.backend,
-        memoryDir: memoryMountRootOf(store.backend, store.root),
-        ...(opts?.onIncident !== undefined ? { onIncident: opts.onIncident } : {}),
-        ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}),
+    const engineOf = createEngineSeat((store) => {
+        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        return new MemoryEngine({
+            backend: store,
+            memoryDir: memoryMountRootOf(store, stores.root),
+            ...(opts?.onIncident !== undefined ? { onIncident: opts.onIncident } : {}),
+            ...(records !== undefined ? { captureRecordStore: records } : {}),
+        });
     });
     return {
-        listExternal: (scopes) => engine.listExternalOriginEntries(scopes),
-        listClearances: () => engine.listOriginClearances(),
-        clear: (entryId, input) => engine.clearEntryOrigin(entryId, input),
+        listExternal: async (scopes) => engineOf(memoryStoreForRequest(stores, scopes)).listExternalOriginEntries(scopes),
+        listClearances: (at) => engineOf(memoryStoreForRequest(stores, seatLayers(at))).listOriginClearances(),
+        clear: async (entryId, input, at) => engineOf(memoryStoreForRequest(stores, seatLayers(at))).clearEntryOrigin(entryId, input),
     };
 }
-export function createSessionMemoryStatusFace(store, opts) {
-    if (!backendOwnsControlPlane(store.backend))
+export function foldPlaneStatuses(statuses) {
+    const sum = (key) => statuses.every((s) => s[key] !== undefined) ? statuses.reduce((n, s) => n + s[key], 0) : undefined;
+    const committedCount = sum("committedCount");
+    const foldedCount = sum("foldedCount");
+    const captures = statuses.flatMap((s) => (s.lastCaptureAt !== undefined ? [s.lastCaptureAt] : []));
+    const lastCaptureAt = committedCount !== undefined && captures.length > 0 ? Math.max(...captures) : undefined;
+    const recorded = statuses.find((s) => s.captureOptedOut === true);
+    const capture = recorded !== undefined
+        ? { captureOptedOut: true, ...(recorded.optOutSource !== undefined ? { optOutSource: recorded.optOutSource } : {}) }
+        : statuses.every((s) => s.captureOptedOut === false)
+            ? { captureOptedOut: false }
+            : statuses.some((s) => s.optOutSource === "fault")
+                ? { optOutSource: "fault" }
+                : {};
+    return {
+        ...capture,
+        ...(committedCount !== undefined ? { committedCount } : {}),
+        ...(foldedCount !== undefined ? { foldedCount } : {}),
+        ...(lastCaptureAt !== undefined ? { lastCaptureAt } : {}),
+    };
+}
+export function createSessionMemoryStatusFace(stores, opts) {
+    if (!backendOwnsControlPlane(stores.backend))
         return undefined;
-    const engine = new MemoryEngine({
-        backend: store.backend,
-        memoryDir: memoryMountRootOf(store.backend, store.root),
-        ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}),
+    const engineOf = createEngineSeat((store) => {
+        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        return new MemoryEngine({
+            backend: store,
+            memoryDir: memoryMountRootOf(store, stores.root),
+            ...(records !== undefined ? { captureRecordStore: records } : {}),
+        });
     });
-    return { status: (sessionId) => engine.sessionMemoryStatus(sessionId) };
+    const storeOf = (store) => {
+        const engine = engineOf(store);
+        return { controlPlane: engine.controlPlaneRoot, status: (sessionId) => engine.sessionMemoryStatus(sessionId) };
+    };
+    return {
+        storesAt: (at) => (at !== undefined ? [storeOf(memoryStoreForRequest(stores, seatLayers(at)))] : memoryStoresOfDeployment(stores).map(storeOf)),
+    };
 }
 //# sourceMappingURL=memory-operator-faces.js.map

package/dist/memory-project-layer.d.ts

@@ -1,23 +1,5 @@
-/**
- * [ref]([ref] 片二)—— 一个任务的**项目层准备一步**:求键 → 把同一 checkout 的旧层折进当前层 → 交给同步腿跟踪。
- * HTTP 腿(`boot/resolve-spec.ts`)与 run-local 腿共用这一只;键的规则只在 `memory-scope.ts` `memoryProjectLayerFor`(本模块不判让位、不铸键)。
- *
- * ## 折叠(`foldFrom`,由 `project-identity.ts` `projectLayerForTaskRoot` 给出,按序)
- *  · 退役 `repo:<sha256(根)[:24]>` 层 —— **一次性迁移**(7.98.0–7.132.x 的项目键;窗、删法见 `plugins/one-time-migrations.ts` 登记表 M25);
- *  · 当前档为 `r`(origin 远端)时本 checkout 的 `p` 档 —— **常设律**(先 `git init` 后加远端的项目,加远端那一刻不丢项目记忆)。
- * 折 = core `migrateScope`(id 保留、rev 按新 scope 重算、逐条 CAS;冲突留原地,下一个任务再折)。**不记「已折」**:每个任务先读一眼旧层
- * (`listHeaders`,空就不动),旧层之后又来了条目(仍在跑的旧任务 harvest、同步把别处的改动拉回旧层)下一个任务照折。
- * 🔴 **与同步轮串行**:旧层若是被同步的层(`p` 档),在飞的那一轮的应答(拉回的改动 / 删除)按 id 落盘 —— 折在它前面,应答会把刚折走的条目改回旧层
- * 或在新层上删掉它。所以有东西要折时,折叠排进同步腿的串行链(`MemorySyncRunner.exclusive`):等在飞的那一轮落定再折,折的时候没有轮在飞。
- * 折在 spec 返回之前完成(`await`)⇒ 这一任务挂载时就看得见折进来的条目(代价如实:有东西要折又恰有一轮在飞时,任务起步等那一轮)。
- * 折叠失败不挡任务(响亮 warn,条目原地不动、下次再折):项目层记忆暂时少了旧层那几条,比任务起不来更接近用户要的东西。
- *
- * ## 跟踪
- * 当前层在复制覆盖面里(否则规则已让位、根本走不到这里)且有同步腿 ⇒ `track(scope)`:本地还没有条目也每轮拉它 —— 第二台设备第一次进这个项目
- * 就拉得到第一台写的(拉回来可能晚于本任务挂载:第一个任务看不见,下一个任务看得见,如实)。
- */
-import { type MemoryBackend } from "@sema-agent/core";
 import type { ServiceConfig } from "./config-types.js";
+import type { MemoryScopeStores } from "./memory-scope-stores.js";
 import type { MemorySyncRunner } from "./memory-sync-client.js";
 import type { MemoryProjectKey } from "./project-identity.js";
 export interface MemoryProjectLayers {
@@ -25,8 +7,8 @@ export interface MemoryProjectLayers {
     prepare(config: Pick<ServiceConfig, "requirePrincipal" | "memorySync">, scope: string | undefined, taskRoot: string | undefined): Promise<MemoryProjectKey | undefined>;
 }
 export declare function createMemoryProjectLayers(deps: {
-    /** 本部署的记忆引擎 backend(File 或 SQL 孪生);缺席 ⇒ 没有可折的盘(记忆暗时调用方根本不会问)。 */
-    backend: MemoryBackend | undefined;
+    /** 本部署的记忆作用域店(= 入口装配出的记忆引擎对象);缺席 ⇒ 没有可折的盘(记忆暗时调用方根本不会问)。 */
+    stores: MemoryScopeStores | undefined;
     /** 同步腿(开同步时在场):跟踪当前层;有东西要折时折叠排进它的串行链。 */
     syncRunner: Pick<MemorySyncRunner, "track" | "exclusive"> | undefined;
     log: {

package/dist/memory-project-layer.js

@@ -1,10 +1,13 @@
 import { migrateScope } from "@sema-agent/core";
 import { memoryProjectLayerFor } from "./memory-scope.js";
 export function createMemoryProjectLayers(deps) {
-    const fold = async (backend, from, to) => {
+    const fold = async (stores, from, to) => {
         let report;
         try {
-            report = await migrateScope(backend, from, to);
+            const store = stores.storeOf(to);
+            if (stores.storeOf(from) !== store)
+                throw new Error(`the layers ${JSON.stringify(from)} and ${JSON.stringify(to)} live in two different memory stores — a fold moves entries inside one store`);
+            report = await migrateScope(store, from, to);
         }
         catch (err) {
             deps.log.warn("memory_project_layer_fold_failed", { from, to, err: String(err), note: "entries stay where they are; the next task in this project retries" });
@@ -16,10 +19,10 @@ export function createMemoryProjectLayers(deps) {
             deps.log.warn("memory_project_layer_fold_conflicts", { from, to, conflicts: report.conflicts.length, note: "conflicting entries stay in the old layer; the next task in this project retries" });
         }
     };
-    const occupied = async (backend, sources) => {
+    const occupied = async (stores, sources) => {
         const out = [];
         for (const from of sources) {
-            if ((await backend.listHeaders([from])).some((h) => h.scope === from))
+            if ((await stores.storeOf(from).listHeaders([from])).some((h) => h.scope === from))
                 out.push(from);
         }
         return out;
@@ -30,11 +33,11 @@ export function createMemoryProjectLayers(deps) {
             const current = layer?.key.scope;
             if (layer === undefined || current === undefined)
                 return layer?.key;
-            const backend = deps.backend;
-            if (backend !== undefined && (await occupied(backend, layer.foldFrom)).length > 0) {
+            const stores = deps.stores;
+            if (stores !== undefined && (await occupied(stores, layer.foldFrom)).length > 0) {
                 const foldAll = async () => {
-                    for (const from of await occupied(backend, layer.foldFrom))
-                        await fold(backend, from, current);
+                    for (const from of await occupied(stores, layer.foldFrom))
+                        await fold(stores, from, current);
                 };
                 await (deps.syncRunner !== undefined ? deps.syncRunner.exclusive(foldAll) : foldAll());
             }

package/dist/memory-scope-stores.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 记忆作用域店 —— 「一层住在哪只店」在本宿主的**唯一读者**。
+ *
+ * ## 规则(一条)
+ * 一层(scope)的条目住哪只店,只有引擎的 `resolveMemoryScopeStore` 答;本服务在会话之外读写某一层的每一条腿(同步执行器、项目层折叠、
+ * 中心侧导出 / 同步、bundle 导出导入、合规抹除 / 出处、外源标记、会话记忆状态、整理)一律问**本对象**,不再自持「部署的店」当某一层的答案。
+ * 本对象就是起服装配出来的那只记忆引擎对象(`boot/stores.ts` 的 `memoryEngine`、`run-local.ts` 的同名量):它的 `backend` / `root`
+ * 正是交给 Runner 的两件事实(`RunnerDeps.memoryBackend` / `RunnerDeps.memoryEngineDir`),会话装配解析一层的店读的也是这两件 ——
+ * 所以宿主腿与会话对同一层答同一只店。每进程一只,所有腿共用(引擎的话:每层解析一次、留着用)。
+ *
+ * ## 喂给引擎的契约
+ * `scopeContract` = 本服务铸 spec 时给会话盖的同一只判据 {@link memoryScopeContractOf}(按层问与按会话问答同一只店,理由见该函数注)。
+ *
+ * ## 先判平面,再建店;一只平面一只实例
+ * 目录钉住的部署上,引擎对个人平面的答案是在个人挂载上**新开**的一只 File 店(契约原话:一只挂载;打开 = 建目录、收尾中断的事务、读台账)。
+ * 层键是调用方给的串,所以本对象**先**问平面、**再**按平面取店:
+ *  · 平面 = 引擎同一只读法 `resolveMemoryScopeStore` 在一只**不钉目录**的探针店上的答案。引擎契约:不钉目录的店对个人平面原样答回
+ *    入参店(「the personal plane shares a backend without a directory」)、项目平面恒答部署的店 ⇒ 这一问只得平面、零建店零读盘,
+ *    层键读不出照样抛引擎的 `config.memory_scope_key`(同一只校验)。不在本层另写分类(另写就是第二个读者)。
+ *  · 店 = 每个平面第一次用到时问引擎一次(真店入参),留下这一只;同平面的后来层复用它 —— 每个本对象至多两只店(项目 / 个人),
+ *    「两层同店」按实例判(下面的路由读它)。不按层键缓存:任意多把新层键不建店、不读盘、本对象不长。
+ * 🚧 平面的读法待引擎导出纯分类函数(`classifyScopePlanes` / `scopePlanesOf`)后改读它、删探针店;钉在 `test/memory-layer-seat-http.test.ts`。
+ *
+ * ## 请求的店({@link memoryStoreForRequest})
+ * 动词按它的请求**点名的层**取店;点名的几层不在同一只店 ⇒ 响亮拒(一次请求只落一只店)。请求不点名层的动词(条目 id、店级账本)
+ * 答在**本部署点名的层与部署的店共处的那一只店**上(`memoryLayersNamedBy`:全局层 / 同步层 / 登记簿种子 / 整理层);它们分住两只店时
+ * 不猜,响亮拒并指路「在请求里点名层」。单店部署(缺省 `local`、SQL 记忆后端、配置不点名个人平面键)上无层请求的答法与上一版逐字同。
+ *
+ * ## 本部署的店({@link memoryStoresOfDeployment})
+ * 部署的店 + 本部署点名的每一层住的店,去重、部署的店在前 —— 至多两只。会话 id 的动词读它:一只会话的记忆事实住在它各条腿写进的那只店
+ * (写家所在的平面),而单用户部署上会话的写家只会是项目层(部署的店)或全局层(点名的层),所以这张表就是「这只会话可能住的店」的全集。
+ */
+import { type MemoryBackend } from "@sema-agent/core";
+export interface MemoryScopeStores {
+    /** 部署的记忆后端 —— 交给 Runner 的那一只(`RunnerDeps.memoryBackend`)。它是「层在哪只店」那只读法的输入、项目平面的店本身,
+     *  不是任何一层的答案(层的答案只出自 {@link MemoryScopeStores.storeOf})。 */
+    readonly backend: MemoryBackend;
+    /** 引擎根 —— 交给 Runner 的那一个值(`RunnerDeps.memoryEngineDir`):读法的另一件输入(个人挂载在它下面),也是同步游标的根。 */
+    readonly root: string;
+    /** 层 `layer` 住的那只店(引擎的唯一读法;先判平面、每个平面一只实例)。引擎读不出的层键 ⇒ 抛引擎的 `config.memory_scope_key`,原样。 */
+    storeOf(layer: string): MemoryBackend;
+    /** 本部署配置点名的层(每次现读 —— 登记簿热换)。 */
+    namedLayers(): readonly string[];
+}
+/** 命名照工厂律:返回带行为的活对象 ⇒ `create*`。 */
+export declare function createMemoryScopeStores(input: {
+    backend: MemoryBackend;
+    root: string;
+    namedLayers: () => readonly string[];
+    /** 本对象为一层开出的店(个人平面的 File 店)的构造期 incident 座(与部署的店那只同一只汇点;缺席合法)。 */
+    onIncident?: (err: Error & {
+        code?: string;
+    }) => void;
+}): MemoryScopeStores;
+/** 本服务的「这次请求落不到一只记忆店」拒(400 `request.memory_layer`):点名的层读不出 / 点名的几层分住两只店 / 两店部署上没点名层。 */
+export declare class MemoryLayerRefusal extends Error {
+    readonly code: "request.memory_layer";
+    constructor(message: string, cause?: unknown);
+}
+/**
+ * 一次请求的记忆店。`layers` = 请求点名的层(空 = 没点名):
+ *  · 点名 ⇒ 它们共住的那一只店;分住两只 ⇒ 拒(一次请求只落一只店,按店拆成几次请求)。
+ *  · 没点名 ⇒ 本部署点名的层与部署的店共处的那一只(= 部署的店);它们分住两只 ⇒ 拒,指路在请求里点名层。
+ * `seat` = 这个动词点名层的那一处(拒句里指路用,如 `` `scope` ``;缺省 = 层座 `scope`)。
+ * 拒一律 {@link MemoryLayerRefusal}(读不出的层键同码,引擎原句随句)。
+ */
+export declare function memoryStoreForRequest(stores: MemoryScopeStores, layers: readonly string[], seat?: string): MemoryBackend;
+/**
+ * 本部署的店:部署的店在前,其后是本部署点名的层住的其余店(去重)—— 单店部署恰一只(部署的店本身)。点名的层读不出 ⇒ {@link MemoryLayerRefusal}(同无层那一臂)。
+ * 每次现算(登记簿热换当场生效);只问平面与每平面一只的店,不建多余的店。
+ */
+export declare function memoryStoresOfDeployment(stores: MemoryScopeStores, seat?: string): readonly MemoryBackend[];
+//# sourceMappingURL=memory-scope-stores.d.ts.map