@sema-agent/server 7.142.0 → 7.144.0

package/dist/memory-bundle-engine.js

@@ -2,7 +2,7 @@ import { MemoryEngine } from "@sema-agent/core";
 import { memoryMountRootOf } from "./memory-scope.js";
 import { memoryStoreForRequest } from "./memory-scope-stores.js";
 import { captureRecordStoreOf } from "./memory-operator-faces.js";
-export function createMemoryBundleFaces(stores, opts) {
+export function createMemoryBundleFaces(stores) {
     if (!carriesBundleComposite(stores.backend))
         return undefined;
     const engines = new Map();
@@ -12,7 +12,7 @@ export function createMemoryBundleFaces(stores, opts) {
             return known;
         if (!carriesBundleComposite(store))
             throw new Error("the memory store that holds these layers implements no v2-c bundle composite (exportSnapshotOf / importBundleCommit) — a bundle is never assembled outside one");
-        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        const records = captureRecordStoreOf(stores.captureRecords, store);
         const engine = new MemoryEngine({ backend: store, memoryDir: memoryMountRootOf(store, stores.root), ...(records !== undefined ? { captureRecordStore: records } : {}) });
         engines.set(store, engine);
         return engine;

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

@@ -16,15 +16,11 @@
  * 修前三只工厂各在**部署的店**上建一只引擎 —— 目录钉住的部署上,类型化个人层(`user:` / `userproj:` / `org:`)的会话条目在个人挂载上的
  * 另一只店里,擦的、查的、清标的都是会话不读的那只店。
  *
- * 会话 id 的两只动词不点名层(会话的写家在哪只店由它各条腿的任务根定,服务端没有存;一只会话可以跨两只店):
- *  · 会话记忆状态读**本部署的每一只店**(`memoryStoresOfDeployment`,至多两只),逐店的答案按 {@link foldPlaneStatuses} 折成一份;
- *  · 按会话抹除(`{ sessionId }` 选择子)落部署的店,见下一节的护栏。
- *
- * ## 抹除只在部署的店上执行({@link MemoryErasureStoreUnjudged})
- * 抹除 `requestId` 的幂等判(重放收敛、同 id 换了选择子 ⇒ `memory.erasure_selector_mismatch`)记在**每只店自己的**证据链上,引擎今天没有
- * 跨店的请求身份、也没有按 `requestId` 读锚的公开面;本层不另记一本请求账(第二真源)。所以本服务只在**一只**店上执行抹除 —— 部署的店,
- * 它的证据链就是本部署唯一的判官:请求落到别的店(点名的层住在个人挂载那只店),或按会话抹除而这只会话在别的店里有贡献(或那只店的账读不出)
- * ⇒ 409 拒,什么都不删。🚧 引擎给出部署级的抹除请求身份后,这条护栏删除、各店照常执行(钉在 `test/memory-project-scope.test.ts` ⑩)。
+ * 抹除与会话记忆状态答的是**整个部署**(记忆作用域店的部署对象,引擎的 `createMemoryDeployment`):
+ *  · 抹除 —— operator 面与会话自助面同一只部署对象的 `eraseMemoryEntries`:一个 `requestId` 在整个部署里只名一次请求,引擎在任何一只店执行之前
+ *    读遍每只店的锚(同一个 id 换了选择子、或落到另一只店 ⇒ `memory.erasure_selector_mismatch`,什么都没删);`{ scope }` / `expectedScopes`
+ *    落那几层住的店,`{ ids }` / `{ sessionId }` 不带授权集 ⇒ 每只店各擦各的那一份,收执合成一份。本层不定店、不另记请求账;
+ *  · 会话记忆状态 —— 不带层座 ⇒ 部署对象的答案(引擎在每只店上折成一份;折叠律只在引擎里);带层座 ⇒ 那一层住的那只店上的引擎答案。
  *
  * ## 控制面归属:为什么 `controlPlaneRoot` 缺席就整口不挂(F-9 裁)
  *
@@ -62,17 +58,9 @@
  * core 自己响亮拒(`memory.erasure_evidence_unavailable`),那是**运行期**的诚实拒,与「换部署形态才行」
  * 不是一回事(附录 A 两条分列)。
  */
-import { type EntryProvenanceAccount, type MemoryBackend, type MemoryEntryOrigin, type MemoryErasureAttestation, type OriginClearanceRow, type SessionCaptureRecordStore, type SessionMemoryStatus } from "@sema-agent/core";
+import { type EntryProvenanceAccount, type MemoryBackend, type MemoryEntryOrigin, type MemoryErasureAttestation, type OriginClearanceRow, type DeploymentSessionMemoryStatus, type SessionCaptureRecordStore } from "@sema-agent/core";
 import { type MemoryScopeStores } from "./memory-scope-stores.js";
 import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
-/**
- * 控制面归属判据 —— 三个记忆操作面(合规两口 / 外源标记三口 / consolidation 阀门的 D1 拒启门)共用的
- * **同一只**谓词:backend 的面上带**非空** `controlPlaneRoot` 才算归属在案。空串与缺席同判「不归属」:
- * core 对空串会 truthy-回退到本副本盘上派生控制面(engine 构造里的 `backendControl ? … : derive(…)`),
- * 对无状态多副本部署这正是 D1 要拒的那台机器(折叠账随 pod 一起死)。抽成单点导出是为了让三处
- * 「逐字同源」成为结构事实而不是手抄承诺(merge-rescan 746 C-1:main.ts 手抄版漏了空串臂)。
- */
-export declare function backendOwnsControlPlane(backend: unknown): boolean;
 /**
  * 一只店的 capture opt-out 记录店 —— 按**这只店的控制面**向记录源取(`StoreBackend.sessionCaptureRecords()` 的按平面取用;
  * 会话装配向同一只源问的也是它那只平面的控制面,core `prepare-memory` 的 `memoryCaptureRecordStore({ controlDir })`)。
@@ -99,23 +87,14 @@ export interface MemoryComplianceFaces {
      * 都得是集内成员,判在解析之后、店锁之内;违者整单拒 `config.memory_erasure_scope`,拒句不带数、不带 id、不带 scope(集外 id
      * 与从没存在过的 id 同句,不是存在性神谕)。本层不另设信封:一只只读得到 `{ scope }` 选择子字面量的信封判不了 `ids` /
      * `sessionId` 两腿、只能整拒,而且让「哪些 scope 能删」有两个答者。集随**入参**走(与 `requestId` / `select` 同一个对象),
-     * 授权集也是定店的那一只读数之一(选择子不点名 scope 时,集里的层共住的那只店;见文件头「引擎建在哪只店上」)。
+     * 授权集也是部署对象定店的那一只读数之一(选择子不点名 scope 时,集里的层共住的那只店;两只店 ⇒ 引擎拒 `config.memory_erasure_scope`)。
      *
      * 今天谁传集:operator 面原样递交调用方的体(调用方自己写的 `expectedScopes` = 它自己收窄自己);路由不替 operator 铸集 ——
      * 本仓没有任何授权源能对一个 operator 说「你只能动这些 scope」(`routes/memory-policy.ts` 的 `gateMemoryScope`:operator 支在查
      * 目录之前就 allow;`org-memory-admission.ts`:v1 不中央收窄 operator 声明的 scope)。拿 org 目录的 grant 集去凑一个集就是在本层
-     * 发明第二套授权语义,与 `gateMemoryScope` 对同一个身份给出相反答案。会话自助面的选择子由路径铸,不带集。
+     * 发明第二套授权语义,与 `gateMemoryScope` 对同一个身份给出相反答案。会话自助面的选择子由路径铸(`{ sessionId }`),不带集 ⇒ 每只店各擦这只会话的那一份。
      */
-    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();
+    erase: (input: unknown) => Promise<MemoryErasureAttestation>;
 }
 /**
  * **选择子替身**的拦截谓词(codex 交叉复审 [critical],亲验复现后修 —— 复现器与结论逐条在
@@ -152,8 +131,8 @@ export declare function erasureInputSmugglesPrototypeKey(input: unknown): boolea
 /**
  * 在**记忆作用域店**上建合规两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * 店:出处按层座定;抹除按选择子的 `scope` / `expectedScopes` 定(会话自助面由路径铸选择子,用层座)—— 见文件头。
- * `memoryDir` = 那只店的**挂载平面**(`memoryMountRootOf(store, root)` 单铸点:店钉了 `directoryRoot`
+ * 店:出处按层座定;抹除交部署对象(整个部署一只判官,店由它按选择子 / 授权集定)—— 见文件头。
+ * 出处引擎的 `memoryDir` = 那只店的**挂载平面**(`memoryMountRootOf(store, root)` 单铸点:店钉了 `directoryRoot`
  * 就是它 —— file 腿 = `<配置根>/memory`,个人店 = 个人挂载;两只 SQL 孪生不钉 ⇒ 回到配置根,读数逐字节不变)。
  *
  * 🔴 **不是 `memoryEngine.root`**(2026 提货批订正,亲读 core 推翻旧注):旧注写着「这两条路径不读它」,
@@ -165,7 +144,8 @@ export declare function erasureInputSmugglesPrototypeKey(input: unknown): boolea
  */
 export declare function createMemoryComplianceFaces(stores: MemoryScopeStores, 
 /**
- * 引擎的 **advisory incident 座**(core `MemoryEngineOptions.onIncident`)。接它不是锦上添花:
+ * 出处引擎的 **advisory incident 座**(core `MemoryEngineOptions.onIncident`)。抹除腿不走这只座:抹除交部署对象,它的座是记忆作用域店起服时接的
+ * 引擎事故汇点(`memory_engine_incident`,带码位与计数)—— 下面这段说的那条码今天从那里出来,理由同样成立。接它不是锦上添花:
  * 抹除腿上有一条**只走这个座**的码 —— `memory.erasure_index_residue`(engine.js)。它说的是
  * 「这次抹除的**索引残留披露**没能写进收执」:于是 operator 归档的那份凭据里少了一句「MEMORY.md
  * 里可能还留着被删条目的名字」,而收执**看上去是干净的**。座不接 ⇒ 这句话在本部署上无声消失,正是
@@ -180,7 +160,6 @@ opts?: {
     onIncident?: (err: Error & {
         code?: string;
     }) => void;
-    captureRecords?: SessionCaptureRecordSource;
 }): MemoryComplianceFaces | undefined;
 /** 件② 三口 HTTP 面消费的窄能力面(`ServiceDeps.memoryOriginFace` 的实参来源)。 */
 export interface MemoryOriginFaces {
@@ -257,55 +236,40 @@ opts?: {
     onIncident?: (err: Error & {
         code?: string;
     }) => void;
-    captureRecords?: SessionCaptureRecordSource;
 }): MemoryOriginFaces | undefined;
 /** [ref] seam① 的窄能力面(`ServiceDeps.sessionMemoryStatus` 的实参来源)。 */
 export interface SessionMemoryStatusFace {
     /**
-     * 这次状态请求读的店:层座点名 ⇒ 那一层住的那一只;不带 ⇒ 本部署的每一只店(部署的店在前,至多两只;单店部署恰一只)——
-     * 路由逐店读,再按 {@link foldPlaneStatuses} 折成一份(会话 id 不点名层,一只会话可以跨两只店,见文件头)。每次请求都现定 ——
-     * 登记簿热换当场生效,路由的短窗缓存只缓存逐店的扫描,不缓存定店。唯一的拒:点名的层 / 本部署点名的层引擎读不出 ⇒ 同步抛 `request.memory_layer`。
+     * 这次状态请求读的那一份(每次请求现定):不带层座 ⇒ 部署对象的答案(引擎在本部署每一只店上折成一份 —— 店集是盘上的,折叠律只在引擎里);
+     * 带层座 ⇒ 那一层住的那只店上的引擎答案。`key` = 这一份在路由短窗缓存里的格(部署那一份一格;每只店一格,落同一只店的层座别名同一格)。
+     * 唯一的拒:层座读不出 ⇒ 同步抛 `request.memory_layer`。
      */
-    storesAt: (at?: MemoryLayerSeat) => readonly SessionMemoryStatusStore[];
+    readingAt: (at?: MemoryLayerSeat) => SessionMemoryStatusReading;
 }
-/** 一只店上的会话记忆状态读。 */
-export interface SessionMemoryStatusStore {
-    /** 这只店的控制面根(引擎自己的读数)—— 状态读扫的就是它;路由的短窗缓存按(会话, 它)分:落同一只店的层键别名是同一格。 */
-    readonly controlPlane: string;
-    status: (sessionId: string) => Promise<SessionMemoryStatus>;
+/** 一份会话记忆状态的读法(见 {@link SessionMemoryStatusFace.readingAt})。 */
+export interface SessionMemoryStatusReading {
+    readonly key: string;
+    /** 引擎的答案,原样(引擎不抛:读不出的源 = 缺席的键)。路由只投 wire 的五键。 */
+    status: (sessionId: string) => Promise<SessionMemoryView>;
 }
-/** 状态面上 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;
+/** 状态面上 wire 的五键所在的那一份:部署对象答案去掉逐店明细 `planes`(逐店明细不上 wire,见 `core-keyset-guard.ts`)。 */
+export type SessionMemoryView = Omit<DeploymentSessionMemoryStatus, "planes">;
 /**
  * [ref] seam①([ref] §S-7,core 7.0.2 [ref] 件1)—— `GET /v1/sessions/:id/memory-status` 的引擎面。
  * 命名照 CLAUDE.md 工厂律:返回带行为的活对象 ⇒ `create*`。
  *
- * 挂载判据与合规/清标两族**同一条 F-9 裁**(`backendOwnsControlPlane`,理由见文件头):
+ * 挂载判据与合规/清标两族**同一条 F-9 裁**(`backendOwnsControlPlane`,理由见文件头;部署对象读同一只谓词):
  * `committedCount` / `foldedCount` / `lastCaptureAt` 读的是引擎控制面的 lineage 台账 ——
  * 控制面归属缺席的部署上(两只 SQL 记忆孪生),core 会把控制面落到**副本本地盘**,一个「可读的空目录」
  * 让 core 面答出 `committedCount: 0`(readLineageRecord 对空目录**不抛**,亲读 engine.js)——
  * 那是**说谎的 0**,比缺席更坏(S-7 的诚实键律:可读零必须是真零)。⇒ 归属缺席 ⇒ 工厂返 undefined,
  * HTTP 面诚实 501,与 erase/origin 同码同分支。
  *
- * `captureRecords` = [ref]② 的按平面取用源(main.ts 取一次,与 Runner/其余引擎同源 —— 全站同批注入律,
- * 机器钉 capture-optout-lane ②;引擎按它那只店的控制面取,{@link captureRecordStoreOf}):`captureOptedOut` / `optOutSource`
- * 两键经它读,多副本部署上答的才是跨副本的真记录。[ref] 起 local 车道在引擎接线时也供(core 文件三腿);缺席 ⇒ 记忆面暗。
+ * capture opt-out 记录源 = 记忆作用域店的那一格(`stores.captureRecords`,[ref]② 的按平面取用源):带层座那一读的引擎按它那只店的控制面取
+ * ({@link captureRecordStoreOf}),部署对象在构造时拿的是同一格 —— 两读一个源。`captureOptedOut` / `optOutSource` 两键经它读,多副本部署上答的才是跨副本的真记录。
  *
- * 引擎**不抛**(core 契约:sessionMemoryStatus never throws —— 每个事实源各自 catch 折缺席键);面唯一的拒是定店那一步的
- * `request.memory_layer`(点名的层 / 本部署点名的层读不出)。不点名层 ⇒ 读本部署的每一只店、路由按 {@link foldPlaneStatuses} 折
- * (只读一只店而它不装这只会话,答出来的就是一个说谎的 0)。
- * 不接 onIncident:这条只读路径上今天零 sink 站点,而且缺席键本身就是它的披露形。
+ * 引擎**不抛**(core 契约:sessionMemoryStatus / 部署对象的 sessionMemoryStatus never throw —— 每个事实源各自 catch 折缺席键);
+ * 面唯一的拒是带层座那一读定店时的 `request.memory_layer`。不接 onIncident:这条只读路径上今天零 sink 站点,而且缺席键本身就是它的披露形。
  */
-export declare function createSessionMemoryStatusFace(stores: MemoryScopeStores, opts?: {
-    captureRecords?: SessionCaptureRecordSource;
-}): SessionMemoryStatusFace | undefined;
+export declare function createSessionMemoryStatusFace(stores: MemoryScopeStores): SessionMemoryStatusFace | undefined;
 //# sourceMappingURL=memory-operator-faces.d.ts.map

package/dist/memory-operator-faces.js

@@ -1,13 +1,6 @@
 import { MemoryEngine, } from "@sema-agent/core";
 import { memoryMountRootOf } from "./memory-scope.js";
-import { memoryStoreForRequest, memoryStoresOfDeployment } from "./memory-scope-stores.js";
-export function backendOwnsControlPlane(backend) {
-    return controlPlaneRootOf(backend) !== undefined;
-}
-function controlPlaneRootOf(backend) {
-    const root = backend?.controlPlaneRoot;
-    return typeof root === "string" && root !== "" ? root : undefined;
-}
+import { backendOwnsControlPlane, controlPlaneRootOf, memoryStoreForRequest } from "./memory-scope-stores.js";
 export function captureRecordStoreOf(source, store) {
     if (source === undefined)
         return undefined;
@@ -28,33 +21,6 @@ function createEngineSeat(build) {
         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];
     while (stack.length > 0) {
@@ -76,10 +42,11 @@ export function erasureInputSmugglesPrototypeKey(input) {
     return false;
 }
 export function createMemoryComplianceFaces(stores, opts) {
-    if (!backendOwnsControlPlane(stores.backend))
+    const deployment = stores.deployment();
+    if (deployment === undefined)
         return undefined;
     const engineOf = createEngineSeat((store) => {
-        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        const records = captureRecordStoreOf(stores.captureRecords, store);
         return new MemoryEngine({
             backend: store,
             memoryDir: memoryMountRootOf(store, stores.root),
@@ -87,34 +54,15 @@ export function createMemoryComplianceFaces(stores, opts) {
             ...(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: async (entryId, at) => engineOf(memoryStoreForRequest(stores, seatLayers(at))).provenanceOf(entryId),
-        erase: async (input, at) => {
+        erase: async (input) => {
             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";
                 throw e;
             }
-            const store = await erasureStoreOf(input, at);
-            return engineOf(store).eraseMemoryEntries(input);
+            return deployment.eraseMemoryEntries(input);
         },
     };
 }
@@ -122,7 +70,7 @@ export function createMemoryOriginFaces(stores, opts) {
     if (!backendOwnsControlPlane(stores.backend))
         return undefined;
     const engineOf = createEngineSeat((store) => {
-        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        const records = captureRecordStoreOf(stores.captureRecords, store);
         return new MemoryEngine({
             backend: store,
             memoryDir: memoryMountRootOf(store, stores.root),
@@ -136,44 +84,25 @@ export function createMemoryOriginFaces(stores, opts) {
         clear: async (entryId, input, at) => engineOf(memoryStoreForRequest(stores, seatLayers(at))).clearEntryOrigin(entryId, input),
     };
 }
-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))
+export function createSessionMemoryStatusFace(stores) {
+    const deployment = stores.deployment();
+    if (deployment === undefined)
         return undefined;
     const engineOf = createEngineSeat((store) => {
-        const records = captureRecordStoreOf(opts?.captureRecords, store);
+        const records = captureRecordStoreOf(stores.captureRecords, store);
         return new MemoryEngine({
             backend: store,
             memoryDir: memoryMountRootOf(store, stores.root),
             ...(records !== undefined ? { captureRecordStore: records } : {}),
         });
     });
-    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)),
+        readingAt: (at) => {
+            if (at === undefined)
+                return { key: "deployment", status: (sessionId) => deployment.sessionMemoryStatus(sessionId) };
+            const engine = engineOf(memoryStoreForRequest(stores, seatLayers(at)));
+            return { key: engine.controlPlaneRoot, status: (sessionId) => engine.sessionMemoryStatus(sessionId) };
+        },
     };
 }
 //# sourceMappingURL=memory-operator-faces.js.map

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

@@ -1,56 +1,59 @@
 /**
- * 记忆作用域店 —— 「一层住在哪只店」在本宿主的**唯一读者**。
+ * 记忆作用域店 —— 本部署的记忆在本宿主的**唯一持有者**:「一层住在哪只店」与「本部署有哪些店」都只在这里答。
  *
  * ## 规则(一条)
- * 一层(scope)的条目住哪只店,只有引擎的 `resolveMemoryScopeStore` 答;本服务在会话之外读写某一层的每一条腿(同步执行器、项目层折叠、
- * 中心侧导出 / 同步、bundle 导出导入、合规抹除 / 出处、外源标记、会话记忆状态、整理)一律问**本对象**,不再自持「部署的店」当某一层的答案。
- * 本对象就是起服装配出来的那只记忆引擎对象(`boot/stores.ts` 的 `memoryEngine`、`run-local.ts` 的同名量):它的 `backend` / `root`
- * 正是交给 Runner 的两件事实(`RunnerDeps.memoryBackend` / `RunnerDeps.memoryEngineDir`),会话装配解析一层的店读的也是这两件 ——
- * 所以宿主腿与会话对同一层答同一只店。每进程一只,所有腿共用(引擎的话:每层解析一次、留着用)。
+ * 一层(scope)的平面只有引擎的纯分类函数答(`scopePlanesOf`,契约 = 本服务铸 spec 时盖在会话上的同一只判据 {@link memoryScopeContractOf});
+ * 一层的店 = 它那只平面的店(项目平面 = 部署的店;目录钉住的部署上个人平面是个人挂载上的另一只店,引擎的 `resolveMemoryScopeStore` 开它)。
+ * **本部署有哪些店**只有引擎的部署对象答(`createMemoryDeployment(…).stores()`):项目店,再加上个人挂载**在盘上**的那只个人店 ——
+ * 盘的集合,不是配置点名的层推出来的集合(配置只决定会话往哪写;换了 `MEMORY_SCOPE` 之后个人挂载上留下的那只店照样在集合里)。
+ * 本服务在会话之外读写某一层的每一条腿(同步执行器、项目层折叠、中心侧导出 / 同步、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 MemoryScopeStores.deployment})
+ * 会话 id 的两只动词(会话记忆状态、按会话 / 按请求身份的抹除)答的是**整个部署**:一个抹除 `requestId` 在整个部署里只名一次请求
+ * (引擎在执行任何一只店之前读遍每只店的锚,同一个 id 换了选择子或落到别的店 ⇒ `memory.erasure_selector_mismatch`),会话记忆状态由引擎在每只店上
+ * 折成一份(折叠律只在引擎里)。所以这两只动词不再由本服务定店:直接交部署对象。部署对象只在部署的店自带控制面归属(`controlPlaneRoot`)时存在
+ * (引擎拒没有控制面的店;两只 SQL 记忆孪生没有 ⇒ 缺席,读它的操作面在那些部署上本就不挂),第一次用到时建、留着用(它自己按需开个人店并留着)。
  *
  * ## 请求的店({@link memoryStoreForRequest})
- * 动词按它的请求**点名的层**取店;点名的几层不在同一只店 ⇒ 响亮拒(一次请求只落一只店)。请求不点名层的动词(条目 id、店级账本)
- * 答在**本部署点名的层与部署的店共处的那一只店**上(`memoryLayersNamedBy`:全局层 / 同步层 / 登记簿种子 / 整理层);它们分住两只店时
- * 不猜,响亮拒并指路「在请求里点名层」。单店部署(缺省 `local`、SQL 记忆后端、配置不点名个人平面键)上无层请求的答法与上一版逐字同。
- *
- * ## 本部署的店({@link memoryStoresOfDeployment})
- * 部署的店 + 本部署点名的每一层住的店,去重、部署的店在前 —— 至多两只。会话 id 的动词读它:一只会话的记忆事实住在它各条腿写进的那只店
- * (写家所在的平面),而单用户部署上会话的写家只会是项目层(部署的店)或全局层(点名的层),所以这张表就是「这只会话可能住的店」的全集。
+ * 点名层的动词按点名的层取店;点名的几层不在同一只店 ⇒ 响亮拒(一次请求只落一只店)。不点名层的条目 id / 店级账本动词答在**本部署唯一的那只店**上;
+ * 部署有两只店(盘上有个人店)⇒ 不猜,响亮拒并指路「在请求里点名层」。没有部署对象的部署(SQL 记忆孪生,不钉目录 ⇒ 两个平面同一只店)恒是一只店。
  */
-import { type MemoryBackend } from "@sema-agent/core";
+import { type MemoryBackend, type MemoryDeployment } from "@sema-agent/core";
+import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
 export interface MemoryScopeStores {
-    /** 部署的记忆后端 —— 交给 Runner 的那一只(`RunnerDeps.memoryBackend`)。它是「层在哪只店」那只读法的输入、项目平面的店本身,
-     *  不是任何一层的答案(层的答案只出自 {@link MemoryScopeStores.storeOf})。 */
+    /** 部署的记忆后端 —— 交给 Runner 的那一只(`RunnerDeps.memoryBackend`):项目平面的店本身,也是部署对象的输入。 */
     readonly backend: MemoryBackend;
-    /** 引擎根 —— 交给 Runner 的那一个值(`RunnerDeps.memoryEngineDir`):读法的另一件输入(个人挂载在它下面),也是同步游标的根。 */
+    /** 引擎根 —— 交给 Runner 的那一个值(`RunnerDeps.memoryEngineDir`):个人挂载在它下面,也是同步游标的根。 */
     readonly root: string;
-    /** 层 `layer` 住的那只店(引擎的唯一读法;先判平面、每个平面一只实例)。引擎读不出的层键 ⇒ 抛引擎的 `config.memory_scope_key`,原样。 */
+    /** capture opt-out 记录源(起服取一次的那一只;缺席 ⇒ 引擎各自的文件缺省)。本部署每一只记忆引擎 —— 部署对象、各操作面按店构造的引擎 —— 都只读这一格。 */
+    readonly captureRecords: SessionCaptureRecordSource | undefined;
+    /** 层 `layer` 的平面(引擎的规范化 + 纯分类函数,与引擎的店解析同一读法;零建店、零读盘)。引擎读不出的层键 ⇒ 抛引擎的 `config.memory_scope_key`,原样。 */
+    planeOf(layer: string): "project" | "personal";
+    /** 层 `layer` 住的那只店(先判平面、每个平面一只实例)。读不出的层键 ⇒ 同 {@link MemoryScopeStores.planeOf}。 */
     storeOf(layer: string): MemoryBackend;
-    /** 本部署配置点名的层(每次现读 —— 登记簿热换)。 */
-    namedLayers(): readonly string[];
+    /** 本部署的记忆(引擎的部署对象,见文件头)。部署的店不带控制面归属 ⇒ `undefined`。 */
+    deployment(): MemoryDeployment | undefined;
 }
+/**
+ * 控制面归属判据 —— 记忆操作面(合规 / 外源标记 / 会话记忆状态 / consolidation 阀门的 D1 拒启门)与部署对象共用的**同一只**谓词:
+ * backend 的面上带**非空** `controlPlaneRoot` 才算归属在案。空串与缺席同判「不归属」:core 对空串会 truthy-回退到本副本盘上派生控制面
+ * (engine 构造里的 `backendControl ? … : derive(…)`),对无状态多副本部署这正是 D1 要拒的那台机器(折叠账随 pod 一起死)。
+ */
+export declare function backendOwnsControlPlane(backend: unknown): boolean;
+/** 店自己发布的控制面根(`controlPlaneRoot`,非空串);不带 ⇒ `undefined`。读这一位只走这里。 */
+export declare function controlPlaneRootOf(backend: unknown): string | undefined;
 /** 命名照工厂律:返回带行为的活对象 ⇒ `create*`。 */
 export declare function createMemoryScopeStores(input: {
     backend: MemoryBackend;
     root: string;
-    namedLayers: () => readonly string[];
-    /** 本对象为一层开出的店(个人平面的 File 店)的构造期 incident 座(与部署的店那只同一只汇点;缺席合法)。 */
+    /** 本对象(与部署对象)为一层开出的店与引擎的 incident 座(与部署的店那只同一只汇点;缺席合法)。 */
     onIncident?: (err: Error & {
         code?: string;
     }) => void;
+    /** capture opt-out 记录源(`StoreBackend.sessionCaptureRecords()`,起服取一次的那一只):部署对象按每只店的控制面问它。缺席 ⇒ 引擎各自的文件缺省。 */
+    captureRecords?: SessionCaptureRecordSource;
 }): MemoryScopeStores;
 /** 本服务的「这次请求落不到一只记忆店」拒(400 `request.memory_layer`):点名的层读不出 / 点名的几层分住两只店 / 两店部署上没点名层。 */
 export declare class MemoryLayerRefusal extends Error {
@@ -60,14 +63,9 @@ export declare class MemoryLayerRefusal extends Error {
 /**
  * 一次请求的记忆店。`layers` = 请求点名的层(空 = 没点名):
  *  · 点名 ⇒ 它们共住的那一只店;分住两只 ⇒ 拒(一次请求只落一只店,按店拆成几次请求)。
- *  · 没点名 ⇒ 本部署点名的层与部署的店共处的那一只(= 部署的店);它们分住两只 ⇒ 拒,指路在请求里点名层。
+ *  · 没点名 ⇒ 本部署唯一的那只店(= 部署的店);部署有两只店(盘上有个人店,{@link MemoryScopeStores.deployment})⇒ 拒,指路在请求里点名层。
  * `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

package/dist/memory-scope-stores.js

@@ -1,30 +1,63 @@
-import { resolveMemoryScopeStore } from "@sema-agent/core";
+import { createMemoryDeployment, normalizeMemorySpec, resolveMemoryScopeStore, scopePlanesOf } from "@sema-agent/core";
 import { memoryScopeContractOf } from "./memory-scope.js";
+export function backendOwnsControlPlane(backend) {
+    return controlPlaneRootOf(backend) !== undefined;
+}
+export function controlPlaneRootOf(backend) {
+    const root = backend?.controlPlaneRoot;
+    return typeof root === "string" && root !== "" ? root : undefined;
+}
 export function createMemoryScopeStores(input) {
-    const byPlane = new Map();
-    const resolve = (layer, backend) => resolveMemoryScopeStore({
+    let personal;
+    const resolve = (layer) => resolveMemoryScopeStore({
         scope: layer,
         scopeContract: memoryScopeContractOf([layer]),
-        backend,
+        backend: input.backend,
         memoryEngineDir: input.root,
         ...(input.onIncident !== undefined ? { onIncident: input.onIncident } : {}),
     });
+    const planeOf = (layer) => {
+        const contract = memoryScopeContractOf([layer]);
+        let spec;
+        try {
+            spec = normalizeMemorySpec({ scopes: [layer], writeScope: layer, ...(contract !== undefined ? { scopeContract: contract } : {}) });
+        }
+        catch {
+            spec = undefined;
+        }
+        if (spec === undefined || spec.writeScope === null)
+            return resolve(layer).plane;
+        return scopePlanesOf(spec.scopes, spec.writeScope, spec.scopeContract)?.writePlane ?? "project";
+    };
+    let deployment;
     return {
         backend: input.backend,
         root: input.root,
-        namedLayers: input.namedLayers,
+        captureRecords: input.captureRecords,
+        planeOf,
         storeOf(layer) {
-            const { plane } = resolve(layer, PLANE_PROBE);
-            const known = byPlane.get(plane);
-            if (known !== undefined)
-                return known;
-            const store = resolve(layer, input.backend).backend;
-            byPlane.set(plane, store);
+            const plane = planeOf(layer);
+            if (plane === "personal" && personal !== undefined)
+                return personal;
+            const store = resolve(layer).backend;
+            if (plane === "personal")
+                personal = store;
             return store;
         },
+        deployment() {
+            if (deployment !== undefined || !backendOwnsControlPlane(input.backend))
+                return deployment;
+            deployment = createMemoryDeployment({
+                backend: input.backend,
+                memoryEngineDir: input.root,
+                scopeContract: "v2",
+                ...(input.onIncident !== undefined ? { onIncident: input.onIncident } : {}),
+                ...(input.captureRecords !== undefined ? { memoryCaptureRecordStore: input.captureRecords } : {}),
+            });
+            return deployment;
+        },
     };
 }
-const PLANE_PROBE = Object.freeze({});
 export class MemoryLayerRefusal extends Error {
     code = "request.memory_layer";
     constructor(message, cause) {
@@ -33,7 +66,7 @@ export class MemoryLayerRefusal extends Error {
     }
 }
 const quoted = (layers) => layers.map((l) => JSON.stringify(l)).join(", ");
-function storeOfNamed(stores, layer, whose, seat) {
+function storeOfNamed(stores, layer) {
     try {
         return stores.storeOf(layer);
     }
@@ -41,16 +74,14 @@ function storeOfNamed(stores, layer, whose, seat) {
         if (err?.code !== "config.memory_scope_key")
             throw err;
         const why = err instanceof Error ? err.message : String(err);
-        throw new MemoryLayerRefusal(whose === "request"
-            ? `the memory layer ${JSON.stringify(layer)} cannot be read: ${why}`
-            : `this deployment's configured memory layer ${JSON.stringify(layer)} cannot be read (${why}), so the store a request that names no layer belongs to cannot be told — name the layer in the request (${seat})`, err);
+        throw new MemoryLayerRefusal(`the memory layer ${JSON.stringify(layer)} cannot be read: ${why}`, err);
     }
 }
 export function memoryStoreForRequest(stores, layers, seat = "`scope`") {
     if (layers.length > 0) {
         const groups = new Map();
         for (const layer of layers) {
-            const store = storeOfNamed(stores, layer, "request", seat);
+            const store = storeOfNamed(stores, layer);
             const group = groups.get(store);
             if (group === undefined)
                 groups.set(store, [layer]);
@@ -62,25 +93,9 @@ export function memoryStoreForRequest(stores, layers, seat = "`scope`") {
         const split = [...groups.values()].map((g) => `[${quoted(g)}]`).join(" / ");
         throw new MemoryLayerRefusal(`the memory layers ${quoted(layers)} live in ${groups.size} different memory stores on this deployment and one request reaches one store — send one request per store: ${split}`);
     }
-    const groups = deploymentStoreGroups(stores, seat);
-    if (groups.size === 1)
+    const census = stores.deployment()?.stores() ?? [];
+    if (census.length <= 1)
         return stores.backend;
-    const elsewhere = [...groups.entries()].filter(([store]) => store !== stores.backend).flatMap(([, g]) => g);
-    throw new MemoryLayerRefusal(`this deployment keeps memory layers in ${groups.size} stores — the project layers${groups.get(stores.backend).length > 0 ? ` and ${quoted(groups.get(stores.backend))}` : ""} in the deployment's store, ${quoted(elsewhere)} in another — so a request that names no layer cannot be told which store it means; name the layer in the request (${seat})`);
-}
-export function memoryStoresOfDeployment(stores, seat = "`scope`") {
-    return [...deploymentStoreGroups(stores, seat).keys()];
-}
-function deploymentStoreGroups(stores, seat) {
-    const groups = new Map([[stores.backend, []]]);
-    for (const layer of stores.namedLayers()) {
-        const store = storeOfNamed(stores, layer, "deployment", seat);
-        const group = groups.get(store);
-        if (group === undefined)
-            groups.set(store, [layer]);
-        else
-            group.push(layer);
-    }
-    return groups;
+    throw new MemoryLayerRefusal(`this deployment keeps memory in ${census.length} stores (the project store and the personal store under the memory engine root), so a request that names no layer cannot be told which store it means; name the layer in the request (${seat})`);
 }
 //# sourceMappingURL=memory-scope-stores.js.map

package/dist/memory-scope.d.ts

@@ -28,15 +28,6 @@ export declare function isV2ScopeKey(key: string): boolean;
  * 同步执行器无从同时对上两者),收口点在配置边界(拒或规范化这一形,后者会挪存量记忆的平面),不在本谓词;未闭环。
  */
 export declare function memoryScopeContractOf(scopes: readonly string[]): "v2" | undefined;
-/**
- * 本部署**自己点名**的记忆层 —— 配置里写着的每一层(去重、去空串、保序):单用户的全局层(`MEMORY_SCOPE`,{@link memoryScopeFor} 单用户臂的答案)、
- * 同步层(`MEMORY_SYNC_SCOPE`,缺省即全局层)、项目登记簿的种子层(`config.projects[*].defaultScopes`,{@link memorySpecForRequest} 盖进会话的读列表)、
- * 整理层(`MEMORY_CONSOLIDATION_SCOPES`)。项目层(`userrepo:…`)按任务根铸、不在配置里,也就不在这里 —— 它们住部署的店。
- *
- * 唯一读者:记忆作用域店的「不点名层的动词答在哪只店」(`memory-scope-stores.ts` 的 {@link memoryStoreForRequest} 无层那一臂)。
- * 登记簿随中心配置热换(`applyEffective` 在同一只 `config.projects` 对象上原地整表换内容),所以读者每次现调本函数,不在起服时冻一份。
- */
-export declare function memoryLayersNamedBy(config: Pick<ServiceConfig, "requirePrincipal" | "memoryScope" | "memorySync" | "projects" | "memoryConsolidationDriver">): string[];
 /** Resolve the memory scope for a request —— {@link memoryScopeFor} 的三形(按实现逐臂写;[ref] 合并前主会话点名:
  *  旧版这里写「多租户恒 `undefined` ⇒ 记忆暗」,与下面 DB 后端那一臂正好相反,test [ref] 就是被这句带偏的)。
  *