@sema-agent/server 7.138.0 → 7.140.0

package/dist/lane-home-probe.js

@@ -2,7 +2,13 @@ export const LANE_HOME_PROBE_MARKER = "sema-lane-home=";
 export const LANE_HOME_PROBE_COMMAND = `printf '\\n${LANE_HOME_PROBE_MARKER}%s\\n' "$HOME"`;
 const SHOWN_MAX = 256;
 const shown = (raw) => JSON.stringify(raw.length > SHOWN_MAX ? `${raw.slice(0, SHOWN_MAX)}…` : raw);
-const comparable = (p) => (p.length > 1 ? p.replace(/\/+$/, "") : p);
+const isAbsoluteHome = (p, paths) => (paths === "win32" ? /^[A-Za-z]:[\\/]/.test(p) || /^[\\/]{2}[^\\/]/.test(p) : p.startsWith("/"));
+const comparable = (p, paths) => {
+    if (paths === "posix")
+        return p.length > 1 ? p.replace(/\/+$/, "") : p;
+    const q = p.replace(/\//g, "\\").toLowerCase();
+    return /^[a-z]:\\$/.test(q) ? q : q.replace(/\\+$/, "");
+};
 function markedHome(stdout) {
     const lines = stdout.split("\n").map((l) => l.replace(/\r$/, ""));
     const marked = lines.flatMap((l, i) => (l.startsWith(LANE_HOME_PROBE_MARKER) ? [i] : []));
@@ -13,34 +19,45 @@ function markedHome(stdout) {
         return { why: "the probe output holds more than one home line or text after it, so it cannot be read as one path" };
     return { home: lines[at].slice(LANE_HOME_PROBE_MARKER.length) };
 }
-function readLaneHome(probe) {
+function readLaneHome(probe, paths) {
     if (!probe.ok)
         return { kind: "unread", reason: probe.reason };
-    const marked = markedHome(probe.stdout);
-    if ("why" in marked)
-        return { kind: "unread", reason: marked.why };
-    return marked.home.startsWith("/") ? { kind: "home", home: marked.home } : { kind: "not_absolute", value: marked.home };
+    let home;
+    if ("value" in probe)
+        home = probe.value;
+    else {
+        const marked = markedHome(probe.stdout);
+        if ("why" in marked)
+            return { kind: "unread", reason: marked.why };
+        home = marked.home;
+    }
+    return isAbsoluteHome(home, paths) ? { kind: "home", home } : { kind: "not_absolute", value: home };
 }
-export function judgeLaneHome(lane, declared, probe) {
-    const head = `REMOTE_EXEC_HOME_DIR=${shown(declared)} is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under on the ${lane} execution lane`;
-    const reading = readLaneHome(probe);
+export function judgeLaneHome(lane, claim, probe, paths = "posix") {
+    const declared = claim.source === "declared";
+    const head = declared
+        ? `REMOTE_EXEC_HOME_DIR=${shown(claim.home)} is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under on the ${lane} execution lane`
+        : `${shown(claim.home)} — the ${lane} execution lane's own home, used because REMOTE_EXEC_HOME_DIR is unset — is the home "~/" permission rules and the engine's home-anchored read-deny rows are placed under`;
+    const unconfirmed = declared ? "the declaration cannot be confirmed" : "that home cannot be confirmed";
+    const reading = readLaneHome(probe, paths);
     if (reading.kind === "unread") {
         return {
-            refusal: `${head}, but the home of this execution environment could not be read (${reading.reason}) — the declaration cannot be confirmed, so this environment is not started. Fix the lane, or unset REMOTE_EXEC_HOME_DIR (home-relative rules are then refused at submission instead).`,
+            refusal: `${head}, but the home of this execution environment could not be read (${reading.reason}) — ${unconfirmed}, so this environment is not started. ${declared ? "Fix the lane, or unset REMOTE_EXEC_HOME_DIR." : "Fix the lane so the environment answers its $HOME."}`,
             answered: false,
         };
     }
     if (reading.kind === "not_absolute") {
         return {
-            refusal: `${head}, but this execution environment reports HOME=${shown(reading.value)}, not an absolute path — the declaration cannot be confirmed, so this environment is not started. Give the environment's user a home (HOME), or unset REMOTE_EXEC_HOME_DIR.`,
+            refusal: `${head}, but this execution environment reports HOME=${shown(reading.value)}, not an absolute path — ${unconfirmed}, so this environment is not started. ${declared ? "Give the environment's user a home (HOME), or unset REMOTE_EXEC_HOME_DIR." : "Give the environment's user a home (HOME)."}`,
             answered: true,
         };
     }
-    if (comparable(reading.home) === comparable(declared))
+    if (comparable(reading.home, paths) === comparable(claim.home, paths))
         return undefined;
+    const measured = shown(reading.home);
     return {
-        refusal: `${head}, but its commands run with HOME=${shown(reading.home)} — rules would guard ${shown(declared)} while ${shown(reading.home)} stays readable and writable, ` +
-            `so this environment is not started. Set REMOTE_EXEC_HOME_DIR to ${shown(reading.home)}, or run the environment as the user whose home is ${shown(declared)}.`,
+        refusal: `${head}, but its commands run with HOME=${measured} — rules would guard ${shown(claim.home)} while ${measured} stays readable and writable, ` +
+            `so this environment is not started. Set REMOTE_EXEC_HOME_DIR to ${measured}${declared ? " or remove it" : ""}, or make the environment's HOME read ${shown(claim.home)}.`,
         answered: true,
     };
 }
@@ -52,37 +69,43 @@ export function buildHomeAbsentNote(lane, cause, remedy) {
 }
 const DECLARE_ARG = "REMOTE_EXEC_HOME_DIR=<the absolute path the environment's $HOME reads>";
 export const DECLARE_HOME_REMEDY = `Declare the home: ${DECLARE_ARG}`;
+export const LANE_HOME_UNMEASURED_EVENT = "execution_lane_home_unmeasured";
+export function buildHomeUnmeasuredNote(lane, declared) {
+    return (`the ${lane} lane cannot read its execution environment's home, so REMOTE_EXEC_HOME_DIR=${shown(declared)} is taken as declared, not measured: ` +
+        `"~/" permission rules and the engine's home-anchored read-deny rows are placed under it. If the environment's $HOME is another directory, those rules guard ${shown(declared)} ` +
+        `while the real home stays readable and writable — keep REMOTE_EXEC_HOME_DIR equal to the $HOME the environment's commands see.`);
+}
 export class LaneHomeSeat {
     measured;
     lane;
-    declared;
-    verifiesDeclared;
+    claim;
     onAbsent;
-    constructor(options) {
-        this.lane = options.lane;
-        this.declared = options.declared;
-        this.verifiesDeclared = options.verifiesDeclared;
-        this.onAbsent = options.onAbsent;
+    paths;
+    constructor(lane, config, paths = "posix") {
+        this.lane = lane;
+        this.paths = paths;
+        this.claim = config.homeDir === undefined ? undefined : { home: config.homeDir, source: config.homeDirSource ?? "declared" };
+        this.onAbsent = config.onHomeAbsent;
     }
     get home() {
-        return this.declared ?? this.measured;
+        return this.claim?.home ?? this.measured;
     }
     get asks() {
-        return this.declared === undefined ? this.measured === undefined : this.verifiesDeclared;
+        return this.claim !== undefined || this.measured === undefined;
     }
     settle(probe) {
-        if (this.declared !== undefined)
-            return this.verifiesDeclared ? judgeLaneHome(this.lane, this.declared, probe) : undefined;
-        const reading = readLaneHome(probe);
+        if (this.claim !== undefined)
+            return judgeLaneHome(this.lane, this.claim, probe, this.paths);
+        const reading = readLaneHome(probe, this.paths);
         if (reading.kind === "home") {
             this.measured = reading.home;
             return undefined;
         }
         const because = reading.kind === "unread" ? `could not be read (${reading.reason})` : `reads ${shown(reading.value)}, not an absolute path`;
-        const remedy = this.verifiesDeclared
-            ? "Give the environment's user an absolute HOME (a declared REMOTE_EXEC_HOME_DIR is checked against it, so declaring cannot stand in for it)."
-            : `Give the environment's user an absolute HOME, or declare it: ${DECLARE_ARG}.`;
-        this.onAbsent?.({ provider: this.lane, note: buildHomeAbsentNote(this.lane, `REMOTE_EXEC_HOME_DIR is unset and the environment's own $HOME ${because}`, remedy) });
+        this.onAbsent?.({
+            provider: this.lane,
+            note: buildHomeAbsentNote(this.lane, `REMOTE_EXEC_HOME_DIR is unset and the environment's own $HOME ${because}`, "Give the environment's user an absolute HOME (a declared REMOTE_EXEC_HOME_DIR is checked against it, so declaring cannot stand in for it)."),
+        });
         return undefined;
     }
 }

package/dist/leader/wire.js

@@ -9,7 +9,8 @@ import { leaderEntryRefusal, leaderRunEntry } from "./run-entry.js";
 import { buildCheckpointCtx } from "../http/checkpoint-ctx.js";
 import { serviceVersion } from "../service-version.js";
 import { RemoteContainerExecutionEnv } from "../plugins/remote-env-e2b.js";
-import { E2B_SANDBOX_HOME } from "../execution-lane-caps.js";
+import { buildLaneHomeClaim } from "../execution-lane-caps.js";
+const e2bBaseTemplateHomeSeat = buildLaneHomeClaim({ remoteExec: { provider: "e2b" } });
 import { createDurableAskPolicy } from "../approval.js";
 import { gitSubprocessEnv } from "../server-secret-env.js";
 import { presignS3Url } from "../plugins/s3-presign.js";
@@ -366,7 +367,7 @@ export function createLeaderRunner(cfg) {
             }
             if (!cfg.e2bApiKey)
                 throw new Error("leader wire: no envFactory+s3 (factory mode) and no e2bApiKey (static mode)");
-            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, ...e2bBaseTemplateHomeSeat });
             if (!(await env.connect()).ok)
                 throw new Error(`connect failed for ${sub.workerId}`);
             await sh(env)(`${body.seedCmd}; cd ${repo}; git checkout -q -b ${sub.branch}`);
@@ -399,7 +400,7 @@ export function createLeaderRunner(cfg) {
             }
             if (!cfg.e2bApiKey)
                 throw new Error("leader wire: no envFactory and no e2bApiKey");
-            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
+            const env = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, ...e2bBaseTemplateHomeSeat });
             if (!(await env.connect()).ok) {
                 await env.destroy().catch(() => { });
                 throw new Error("integ connect failed");
@@ -439,7 +440,7 @@ export function createLeaderRunner(cfg) {
             else {
                 if (!cfg.e2bApiKey)
                     throw new Error("leader wire: repair-loop grader needs an envFactory or e2bApiKey");
-                const e2b = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, homeDir: E2B_SANDBOX_HOME });
+                const e2b = new RemoteContainerExecutionEnv({ apiKey: cfg.e2bApiKey, timeoutMs: leaderTimeoutMs, ...e2bBaseTemplateHomeSeat });
                 if (!(await e2b.connect()).ok) {
                     await e2b.destroy().catch(() => { });
                     throw new Error("repair-loop grader connect failed");

package/dist/memory-bundle-engine.d.ts

@@ -4,11 +4,18 @@
  * ## 为什么需要这个模块(而不是在 main.ts 里直接 new)
  *
  * 本仓**没有**一个长命的 `MemoryEngine` 实例:`boot/stores.ts` 装配出来的 `memoryEngine` 是
- * `{ backend, root }` 二元组,真正的引擎由 **core 的 Runner 每任务现构**
+ * 记忆作用域店(`memory-scope-stores.ts`:部署的店 + 引擎根 + 「一层住哪只店」的唯一读者),真正的引擎由 **core 的 Runner 每任务现构**
  * (`core/runner/prepare-memory.js`),而且构出来的 `memoryDir` 是**按任务的 scope 平面**决定的
  * (personal / project / dual-root 三形,还要看仓根、项目标记、pinned 目录)。
  * 也就是说「这个部署的那一个记忆引擎」这个东西**在本仓不存在** —— HTTP 面若要一个引擎,必须自己构。
  *
+ * ## 引擎建在哪只店上:包点名的层住的那只
+ * 导出按请求的 `scopes` 定店,导入按包自己的 `bundle.scopes` 定店(core 的整包判决保证包里每一条的层都在 `bundle.scopes` 里 —— 自洽是它的校验项);
+ * 几层分住两只店 ⇒ 拒(`request.memory_layer`):一只包是**一只店**单锁复合面里的一个 epoch,两只店封不出一只包。规则唯一属主
+ * `memory-scope-stores.ts` 的 {@link memoryStoreForRequest}。`bundle.scopes` 读不成「非空的非空串数组」的包,本来就过不了 core 的整包判决
+ * (结构项第一条),交部署的店那只引擎去判 —— 拒是包本身的函数,哪只引擎判都一样,什么都不落。
+ * 修前两面都在部署的店上建引擎:目录钉住的部署上,类型化个人层的条目在个人挂载上的另一只店里 —— 导出的包里没有会话写的条目,导入的落在会话不读的店。
+ *
  * ## 为什么自己构是安全的:这两个面是 **backend-scoped**,不碰 `memoryDir`
  *
  * 亲读 core 5.40.0 的 `memory-engine/engine.js`(不信 JSDoc,读实现):
@@ -41,7 +48,9 @@
  * `memory.export_incomplete` —— 那是诚实的运行期拒,附录 A 单列一条。绝不在这里回落到「用通用读面拼
  * 一个包」:core 明写那正是它拒绝生产的形(a governance-less export is the laundering shape)。
  */
-import { type MemoryBackend, type MemoryExportBundle, type MemoryImportReport, type SessionCaptureRecordStore } from "@sema-agent/core";
+import { type MemoryExportBundle, type MemoryImportReport } from "@sema-agent/core";
+import { type MemoryScopeStores } from "./memory-scope-stores.js";
+import type { SessionCaptureRecordSource } from "./plugins/store-backend.js";
 /** 两口 HTTP 面消费的窄能力面(`ServiceDeps.memoryBundle{Export,Import}` 的实参来源)。 */
 export interface MemoryBundleFaces {
     exportScopes: (scopes: readonly string[]) => Promise<MemoryExportBundle>;
@@ -51,17 +60,15 @@ export interface MemoryBundleFaces {
     }) => Promise<MemoryImportReport>;
 }
 /**
- * 在**已装配的记忆后端**上建 bundle 两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
+ * 在**记忆作用域店**上建 bundle 两面。命名照 CLAUDE.md 工厂律:返回的是带行为的活对象 ⇒ `create*`。
  *
- * `memoryDir` = 引擎的**挂载平面**(`memoryMountRootOf(backend, root)` 单铸点;全仓自构引擎同一条规则,
+ * 店:见文件头「引擎建在哪只店上」;一只店一只引擎。
+ * `memoryDir` = 那只店的**挂载平面**(`memoryMountRootOf(store, root)` 单铸点;全仓自构引擎同一条规则,
  * 由 `test/memory-layout-plane.test.ts` 的归一门咬住)。见文件头:这两条路径**不读它**(机器钉在
  * `test/memory-bundle-engine.test.ts`:给一个不存在的 `memoryDir` 也照样工作),传对的那一只是为了
  * 万一 core 日后真用上时,它拿到的是本部署真正的挂载平面,而不是高一层的配置根。
  */
-export declare function createMemoryBundleFaces(store: {
-    backend: MemoryBackend;
-    root: string;
-}, opts?: {
-    captureRecordStore?: SessionCaptureRecordStore;
+export declare function createMemoryBundleFaces(stores: MemoryScopeStores, opts?: {
+    captureRecords?: SessionCaptureRecordSource;
 }): MemoryBundleFaces | undefined;
 //# sourceMappingURL=memory-bundle-engine.d.ts.map

package/dist/memory-bundle-engine.js

@@ -1,13 +1,36 @@
 import { MemoryEngine } from "@sema-agent/core";
 import { memoryMountRootOf } from "./memory-scope.js";
-export function createMemoryBundleFaces(store, opts) {
-    const b = store.backend;
-    if (typeof b.exportSnapshotOf !== "function" || typeof b.importBundleCommit !== "function")
+import { memoryStoreForRequest } from "./memory-scope-stores.js";
+import { captureRecordStoreOf } from "./memory-operator-faces.js";
+export function createMemoryBundleFaces(stores, opts) {
+    if (!carriesBundleComposite(stores.backend))
         return undefined;
-    const engine = new MemoryEngine({ backend: store.backend, memoryDir: memoryMountRootOf(store.backend, store.root), ...(opts?.captureRecordStore !== undefined ? { captureRecordStore: opts.captureRecordStore } : {}) });
+    const engines = new Map();
+    const engineOf = (store) => {
+        const known = engines.get(store);
+        if (known !== undefined)
+            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 engine = new MemoryEngine({ backend: store, memoryDir: memoryMountRootOf(store, stores.root), ...(records !== undefined ? { captureRecordStore: records } : {}) });
+        engines.set(store, engine);
+        return engine;
+    };
     return {
-        exportScopes: (scopes) => engine.exportMemoryScopes(scopes),
-        importBundle: (bundle, opts) => engine.importMemoryBundle(bundle, opts),
+        exportScopes: async (scopes) => engineOf(memoryStoreForRequest(stores, scopes)).exportMemoryScopes(scopes),
+        importBundle: async (bundle, opts) => {
+            const layers = bundleLayersOf(bundle);
+            return engineOf(layers.length > 0 ? memoryStoreForRequest(stores, layers) : stores.backend).importMemoryBundle(bundle, opts);
+        },
     };
 }
+function carriesBundleComposite(store) {
+    const b = store;
+    return typeof b.exportSnapshotOf === "function" && typeof b.importBundleCommit === "function";
+}
+function bundleLayersOf(bundle) {
+    const scopes = typeof bundle === "object" && bundle !== null ? bundle.scopes : undefined;
+    return Array.isArray(scopes) && scopes.length > 0 && scopes.every((s) => typeof s === "string" && s.length > 0) ? scopes : [];
+}
 //# sourceMappingURL=memory-bundle-engine.js.map

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