@sema-agent/server 7.139.0 → 7.140.0

package/dist/memory-scope-stores.js

@@ -0,0 +1,86 @@
+import { resolveMemoryScopeStore } from "@sema-agent/core";
+import { memoryScopeContractOf } from "./memory-scope.js";
+export function createMemoryScopeStores(input) {
+    const byPlane = new Map();
+    const resolve = (layer, backend) => resolveMemoryScopeStore({
+        scope: layer,
+        scopeContract: memoryScopeContractOf([layer]),
+        backend,
+        memoryEngineDir: input.root,
+        ...(input.onIncident !== undefined ? { onIncident: input.onIncident } : {}),
+    });
+    return {
+        backend: input.backend,
+        root: input.root,
+        namedLayers: input.namedLayers,
+        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);
+            return store;
+        },
+    };
+}
+const PLANE_PROBE = Object.freeze({});
+export class MemoryLayerRefusal extends Error {
+    code = "request.memory_layer";
+    constructor(message, cause) {
+        super(message, cause !== undefined ? { cause } : undefined);
+        this.name = "MemoryLayerRefusal";
+    }
+}
+const quoted = (layers) => layers.map((l) => JSON.stringify(l)).join(", ");
+function storeOfNamed(stores, layer, whose, seat) {
+    try {
+        return stores.storeOf(layer);
+    }
+    catch (err) {
+        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);
+    }
+}
+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 group = groups.get(store);
+            if (group === undefined)
+                groups.set(store, [layer]);
+            else
+                group.push(layer);
+        }
+        if (groups.size === 1)
+            return [...groups.keys()][0];
+        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)
+        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;
+}
+//# sourceMappingURL=memory-scope-stores.js.map

package/dist/memory-scope.d.ts

@@ -8,11 +8,35 @@ export declare const V2_SCOPE_PREFIXES: readonly string[];
  * 一个 scope 键是否带 v2 typed 前缀。
  *
  * ⚠️ 判据刻意停在**前缀**层,不升级成 core 的 `parseScopeKey`:后者对「带可识别前缀但结构坏」的键
- * 是 fail-loud 抛错,而本谓词的两个调用点都只是在决定「要不要挂 v2 标 / 要不要再包一层」——把抛点
- * 挪到这里会把 core 的校验时机整体前移(行为面改动,不在本条案的射程内)。坏键仍由 core 在它自己的
- * 校验点 fail-loud。
+ * 是 fail-loud 抛错,而本谓词的两个读者都只是在决定「要不要挂 v2 标({@link memoryScopeContractOf})/
+ * 同步层要不要另给(`config.ts`)」——把抛点挪到这里会把 core 的校验时机整体前移(行为面改动,不在本条案的射程内)。
+ * 坏键仍由 core 在它自己的校验点 fail-loud。
  */
 export declare function isV2ScopeKey(key: string): boolean;
+/**
+ * 本服务给一组记忆层盖的**作用域契约**(core `TaskSpec.memory.scopeContract`)—— 一个判据、两个读者:
+ *  · {@link memorySpecForRequest} 铸 spec 时盖在会话上的那一个(读列表 = 全局层 + 登记簿种子);
+ *  · 同步执行器替一层问「这一层在哪只店」时报给引擎的那一个(`resolveMemoryScopeStore` 的 `scopeContract`,`memory-sync-client.ts`)。
+ * 契约决定**类型化键落哪个平面**(v2 下 `user:` / `userproj:` / `org:` 在个人平面,不透明键在项目平面;不声明则一律项目平面),
+ * 所以两个读者必须读同一只:会话把一层放在哪只店,同步就同步哪只店。
+ *
+ * 判据:列表里有类型化键(前缀表 {@link V2_SCOPE_PREFIXES})⇒ `"v2"`;没有 ⇒ `undefined`(不声明;显式 opt-in,不嗅探调用方数据 ——
+ * 这些键只来自本服务自己的铸点与运维的登记簿,见 {@link memorySpecForRequest} 的 142-S1.5 注)。
+ * 按层问与按会话问答同一只店:平面按**每把键自己的种类**分,契约只挪类型化键,而本判据下带类型化键的会话恒盖 `"v2"`。
+ * 🚧 前提是键为规范形:引擎读键前去掉首尾空白,本判据看原串 —— 带首尾空白的类型化键(`" user:alice"`,配置边界今天放行)本判据不认、引擎在 v2 下读得出,
+ * 于是同一把键在带类型化种子的会话里落个人平面、在不带种子的会话与同步执行器里落项目平面。这是会话面先有的不一致(不同项目的会话对同一层就答两只店,
+ * 同步执行器无从同时对上两者),收口点在配置边界(拒或规范化这一形,后者会挪存量记忆的平面),不在本谓词;未闭环。
+ */
+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] 就是被这句带偏的)。
  *
@@ -93,8 +117,8 @@ export declare function replicatesProjectLayersOf(coverage: MemoryReplicationCov
  * Pure posture probe (memoryEngineBackendFor consumes it; main.ts logs it): `undefined` = no plane split
  * (the lane's file plane IS this worker's fs — `in-process` / `host`), `dark` = split + fail-closed, `forced` =
  * split + operator override.
- * [ref]: the plane question reads the lane-caps table (`hostFilePlane`) — it used to be the hand-written synonym
- * `lane === undefined || lane === "host"` (fold-ban gate D, R3); readings are unchanged lane by lane.
+ * The plane question reads the execution environment block (`hostLocalPaths`, sole author `capabilitiesFor`) — it used to be the
+ * hand-written synonym `lane === undefined || lane === "host"`; readings are unchanged lane by lane.
  */
 export declare function memoryEngineRemoteLanePosture(config: ServiceConfig): {
     lane: ExecutionLane;

package/dist/memory-scope.js

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import { FileMemoryEngineBackend, resolveMemoryEngineRoot, deriveControlPlaneDir, formatUserScope, formatProjScope, normalizeMemorySpec } from "@sema-agent/core";
-import { executionLaneCaps, executionLaneOf } from "./execution-lane-caps.js";
+import { capabilitiesFor, executionLaneOf } from "./execution-lane-caps.js";
 import { assertMemoryScopeWidth } from "./plugins/memory-key-guards.js";
 import { projectLayerForTaskRoot } from "./project-identity.js";
 import { parseProjectLayerKey, projectLayerOwnerOf } from "./project-layer-key.js";
@@ -14,6 +14,18 @@ export const V2_SCOPE_PREFIXES = Object.freeze(Object.values(V2_SCOPE_PREFIX_BY_
 export function isV2ScopeKey(key) {
     return V2_SCOPE_PREFIXES.some((prefix) => key.startsWith(prefix));
 }
+export function memoryScopeContractOf(scopes) {
+    return scopes.some(isV2ScopeKey) ? "v2" : undefined;
+}
+export function memoryLayersNamedBy(config) {
+    const named = [
+        ...(config.requirePrincipal === true ? [] : [config.memoryScope]),
+        ...(config.memorySync !== undefined ? [config.memorySync.scope] : []),
+        ...Object.values(config.projects ?? {}).flatMap((p) => p.defaultScopes ?? []),
+        ...config.memoryConsolidationDriver.scopes,
+    ];
+    return named.filter((s, i) => typeof s === "string" && s.length > 0 && named.indexOf(s) === i);
+}
 export { MEMORY_SCOPE_COLUMN_CHARS, assertMemoryScopeWidth } from "./plugins/memory-key-guards.js";
 export function memoryScopeFor(config, principal, projectId) {
     if (config.requirePrincipal === true) {
@@ -64,7 +76,7 @@ export function replicatesProjectLayersOf(coverage, owner) {
 }
 export function memoryEngineRemoteLanePosture(config) {
     const lane = executionLaneOf(config.remoteExec?.provider);
-    if (executionLaneCaps(lane).hostFilePlane === "supported")
+    if (capabilitiesFor(config).hostLocalPaths)
         return undefined;
     return { lane, posture: config.memoryEngineRemoteLaneAllowed === true ? "forced" : "dark" };
 }
@@ -158,14 +170,14 @@ export function memorySpecForRequest(scope, projectKey, memoryWrite, defaultScop
         throw new Error(`memory project scope ${JSON.stringify(projectScope)} equals the global memory scope (MEMORY_SCOPE) — the project layer and the global layer would be one directory. ` +
             "Set MEMORY_SCOPE to a name outside the server-minted project-key families (see src/project-layer-key.ts).");
     }
-    const isV2 = isV2ScopeKey;
     const extras = (defaultScopes ?? []).filter((s, i, arr) => typeof s === "string" && s.length > 0 && s !== scope && s !== projectScope && arr.indexOf(s) === i);
     const layered = projectKey !== undefined
         ? { scopes: projectScope !== undefined ? [projectScope, scope, ...extras] : [scope, ...extras], writeScope: projectScope ?? scope, projectKey }
         : extras.length > 0
             ? { scopes: [scope, ...extras], writeScope: scope }
             : { scopes: [scope] };
-    const v2 = isV2(scope) || extras.some(isV2) ? { scopeContract: "v2" } : {};
+    const contract = memoryScopeContractOf([scope, ...extras]);
+    const v2 = contract !== undefined ? { scopeContract: contract } : {};
     const stamped = {};
     if (originPolicy !== undefined) {
         if (scope.startsWith("org:"))

package/dist/memory-sync-client.d.ts

@@ -1,4 +1,6 @@
-import { type MemoryBackend, type MemorySyncClientResult, type MemorySyncTransport } from "@sema-agent/core";
+import { type MemorySyncClientResult, type MemorySyncTransport } from "@sema-agent/core";
+import type { ServiceConfig } from "./config-types.js";
+import type { MemoryScopeStores } from "./memory-scope-stores.js";
 import { type OneTimeMigrationWindow } from "./plugins/one-time-migrations.js";
 /** 结构化日志面(src/observability/logger.ts Logger 的结构子集——测试可注入捕获器)。 */
 export interface MemorySyncLog {
@@ -41,9 +43,9 @@ export declare function createMemorySyncTransport(opts: {
     /** The one call shape this transport makes (`fetch` itself fits it). */
     fetchImpl?: (url: string, init: RequestInit) => Promise<Response>;
 }): MemorySyncTransport;
-/** 一层的游标文件路径:`memoryRoot`(= RunnerDeps.memoryEngineDir 的 resolved config root)下 `sync-cursors/<scope 摘要>.json`。一层一只,不随对端变。
+/** 一层的游标文件路径:引擎根 `memoryEngineDir`(= `RunnerDeps.memoryEngineDir` 的那一个值)下 `sync-cursors/<scope 摘要>.json`。一层一只,不随对端变、不随店变。
  *  落在子目录里:与更早的根下一层文件名 `sync-cursor-<peer>.json` 的空间不相交。 */
-export declare function memorySyncCursorPath(memoryRoot: string, scope: string): string;
+export declare function memorySyncCursorPath(memoryEngineDir: string, scope: string): string;
 /** M31 一次的读数(测试按它断言)。`window: "closed"` ⇒ 一行都没读。 */
 export interface SyncCursorRelocationM31Report {
     readonly window: "open" | "closed";
@@ -59,7 +61,7 @@ export interface SyncCursorRelocationM31Report {
  * 与同一数据根上并跑的另一个进程(server + run-local)同搬:源已被对方搬走(`ENOENT`)⇒ 跳过。残余(如实):先查目标再 `rename` 之间若有写者在目标路径上
  * 落下游标,会被盖掉 —— 写者只有本模块的 runner,而 runner 写任何游标之前先跑完本步。别的读写错 ⇒ 抛(这一轮整轮失败、下一轮再搬)。
  */
-export declare function relocateSyncCursorsM31(memoryRoot: string, log: MemorySyncLog, opts: {
+export declare function relocateSyncCursorsM31(memoryEngineDir: string, log: MemorySyncLog, opts: {
     readonly today: string;
     readonly window?: Pick<OneTimeMigrationWindow, "removableAfter">;
 }): Promise<SyncCursorRelocationM31Report>;
@@ -91,13 +93,13 @@ export interface MemorySyncRunner {
 export declare const MAX_SYNC_ROUNDS = 32;
 /**
  * 组装同步执行器:同步层 `scope` + 同属主的项目层,逐层一轮(cursor 持久化 + core `syncMemoryScope` + conflicts 上报),串行化/节流。
- * `backend` = 本地 File authority plane(memoryEngineBackendFor 的产物);`memoryRoot` = resolved config root(cursor sidecar 落在 memory/ 目录旁)。
+ * 每一层同步的店由记忆作用域店答(⑥);同步层建时就问(坏的层键 ⇒ 这里抛引擎的 `config.memory_scope_key`,原样)。
  */
 export declare function createMemorySyncRunner(opts: {
-    backend: MemoryBackend;
+    /** 记忆作用域店(本进程那一只):每一层的店问它的 `storeOf`;项目层的发现列它的 `backend`(部署的店本身);游标的根 = 它的 `root`。 */
+    stores: MemoryScopeStores;
     /** 同步层(`config.memorySync.scope`);它同属主的项目层随它一起同步。 */
     scope: string;
-    memoryRoot: string;
     /** 对端 = 它的 `peer`(这一轮的对端只有这一个来源;游标绑的对端由引擎对它判)。 */
     transport: MemorySyncTransport;
     log: MemorySyncLog;
@@ -106,4 +108,15 @@ export declare function createMemorySyncRunner(opts: {
     maxPushEntries?: number;
     maxPullEntries?: number;
 }): MemorySyncRunner;
+/**
+ * 两个入口(HTTP 服务 `boot/stores.ts` 与 `run-local.ts`)起同步执行器的**唯一一处**:建 transport(对端身份在这里铸一次)、建执行器、
+ * 起服日志一行 `memory_sync_enabled`、fire-and-forget 起服那一轮。两处此前各手抄一份同样的装配(上限两键漏过一次);
+ * 店只经入口装配出的那只记忆作用域店取 —— 它的两件事实就是交给 Runner 的那两只,会话把一层放在哪只店由同样的两件事实决定。
+ */
+export declare function startMemorySyncRunner(deps: {
+    sync: NonNullable<ServiceConfig["memorySync"]>;
+    /** 入口装配出的记忆作用域店(= 本入口的记忆引擎对象)。 */
+    stores: MemoryScopeStores;
+    log: MemorySyncLog;
+}): MemorySyncRunner;
 //# sourceMappingURL=memory-sync-client.d.ts.map

package/dist/memory-sync-client.js

@@ -50,8 +50,8 @@ const SYNC_CURSOR_DIR = "sync-cursors";
 function scopeDigest(scope) {
     return createHash("sha256").update(scope, "utf8").digest("hex").slice(0, 32);
 }
-export function memorySyncCursorPath(memoryRoot, scope) {
-    return join(memoryRoot, SYNC_CURSOR_DIR, `${scopeDigest(scope)}.json`);
+export function memorySyncCursorPath(memoryEngineDir, scope) {
+    return join(memoryEngineDir, SYNC_CURSOR_DIR, `${scopeDigest(scope)}.json`);
 }
 function unusableCursor(scope, path, why) {
     return new Error(`memory sync: layer ${JSON.stringify(scope)} not synced — the cursor file ${path} cannot be read as a sync cursor (${why}); the layer stays unsynced until the operator picks one of two ways out: ` +
@@ -120,7 +120,7 @@ function scopeOfLegacyCursor(raw) {
     const scope = parsed["scope"];
     return typeof scope === "string" && scope.length > 0 ? scope : undefined;
 }
-export async function relocateSyncCursorsM31(memoryRoot, log, opts) {
+export async function relocateSyncCursorsM31(memoryEngineDir, log, opts) {
     if (!migrationWindowOpen(opts.window ?? m31Window(), opts.today))
         return { window: "closed", moved: 0, left: 0 };
     let moved = 0;
@@ -155,7 +155,7 @@ export async function relocateSyncCursorsM31(memoryRoot, log, opts) {
         moved += 1;
         log.info("memory_sync_cursor_relocated", { from, to });
     };
-    const legacyDir = join(memoryRoot, SYNC_CURSOR_DIR, LEGACY_PEER_SEGMENT);
+    const legacyDir = join(memoryEngineDir, SYNC_CURSOR_DIR, LEGACY_PEER_SEGMENT);
     let names = [];
     try {
         names = await readdir(legacyDir);
@@ -166,7 +166,7 @@ export async function relocateSyncCursorsM31(memoryRoot, log, opts) {
     }
     for (const name of [...names].sort()) {
         if (/^[0-9a-f]{32}\.json$/.test(name))
-            await move(join(legacyDir, name), join(memoryRoot, SYNC_CURSOR_DIR, name));
+            await move(join(legacyDir, name), join(memoryEngineDir, SYNC_CURSOR_DIR, name));
     }
     if (names.length > 0) {
         try {
@@ -177,7 +177,7 @@ export async function relocateSyncCursorsM31(memoryRoot, log, opts) {
                 throw err;
         }
     }
-    const legacyFile = join(memoryRoot, LEGACY_ROOT_CURSOR_FILE);
+    const legacyFile = join(memoryEngineDir, LEGACY_ROOT_CURSOR_FILE);
     let raw;
     try {
         raw = await readFile(legacyFile, "utf8");
@@ -193,7 +193,7 @@ export async function relocateSyncCursorsM31(memoryRoot, log, opts) {
             log.warn("memory_sync_cursor_not_relocated", { path: legacyFile, note: "a cursor file written by an earlier version that is not a JSON object naming its scope, so no layer can take it as its baseline; restore it from a backup and restart, or delete it" });
         }
         else {
-            await move(legacyFile, memorySyncCursorPath(memoryRoot, scope));
+            await move(legacyFile, memorySyncCursorPath(memoryEngineDir, scope));
         }
     }
     return { window: "open", moved, left };
@@ -209,8 +209,11 @@ export function createMemorySyncRunner(opts) {
     const tracked = new Set();
     let enumerationWarned = false;
     const isCoveredProjectLayer = (scope) => scope !== opts.scope && parseProjectLayerKey(scope) !== undefined && replicationCovers(coverage, scope);
+    const storeOf = (scope) => opts.stores.storeOf(scope);
+    const memoryEngineDir = opts.stores.root;
+    storeOf(opts.scope);
     const layersOfRound = () => {
-        const local = enumerateScopes(opts.backend);
+        const local = enumerateScopes(opts.stores.backend);
         if (!local.supported && !enumerationWarned) {
             enumerationWarned = true;
             opts.log.warn("memory_sync_layer_enumeration_unsupported", { scope: opts.scope, reason: local.reason, note: "only the sync layer and tracked project layers are synced" });
@@ -219,7 +222,7 @@ export function createMemorySyncRunner(opts) {
         return [opts.scope, ...[...projectLayers].sort()];
     };
     const syncLayer = async (scope, reason) => {
-        const cursorPath = memorySyncCursorPath(opts.memoryRoot, scope);
+        const cursorPath = memorySyncCursorPath(memoryEngineDir, scope);
         const baseline = await loadLayerBaseline(cursorPath, scope);
         let cursor = baseline.kind === "cursor" ? baseline.cursor : undefined;
         let result;
@@ -227,7 +230,7 @@ export function createMemorySyncRunner(opts) {
         for (;;) {
             subRound += 1;
             result = await syncMemoryScope({
-                backend: opts.backend,
+                backend: storeOf(scope),
                 scope,
                 transport: opts.transport,
                 ...(cursor !== undefined ? { cursor } : {}),
@@ -288,7 +291,7 @@ export function createMemorySyncRunner(opts) {
     let relocated = false;
     const round = async (reason) => {
         if (!relocated) {
-            await relocateSyncCursorsM31(opts.memoryRoot, opts.log, { today: new Date(now()).toISOString().slice(0, 10) });
+            await relocateSyncCursorsM31(memoryEngineDir, opts.log, { today: new Date(now()).toISOString().slice(0, 10) });
             relocated = true;
         }
         const layers = [];
@@ -299,7 +302,7 @@ export function createMemorySyncRunner(opts) {
             }
             catch (err) {
                 failures.push({ scope, err });
-                opts.log.warn("memory_sync_layer_failed", { reason, scope, cursorPath: memorySyncCursorPath(opts.memoryRoot, scope), err: String(err) });
+                opts.log.warn("memory_sync_layer_failed", { reason, scope, cursorPath: memorySyncCursorPath(memoryEngineDir, scope), err: String(err) });
             }
         }
         if (failures.length > 0) {
@@ -339,6 +342,21 @@ export function createMemorySyncRunner(opts) {
         tracked.add(scope);
         queueRound("track");
     };
-    return { syncOnce, trigger, track, exclusive, cursorPathFor: (scope) => memorySyncCursorPath(opts.memoryRoot, scope), pending: () => pending };
+    return { syncOnce, trigger, track, exclusive, cursorPathFor: (scope) => memorySyncCursorPath(memoryEngineDir, scope), pending: () => pending };
+}
+export function startMemorySyncRunner(deps) {
+    const { sync } = deps;
+    const transport = createMemorySyncTransport({ url: sync.url, token: sync.token });
+    const runner = createMemorySyncRunner({
+        stores: deps.stores,
+        scope: sync.scope,
+        transport,
+        log: deps.log,
+        ...(sync.maxPushEntries !== undefined ? { maxPushEntries: sync.maxPushEntries } : {}),
+        ...(sync.maxPullEntries !== undefined ? { maxPullEntries: sync.maxPullEntries } : {}),
+    });
+    deps.log.info("memory_sync_enabled", buildMemorySyncEnabledFields(transport.peer, sync.scope, runner.cursorPathFor(sync.scope)));
+    runner.trigger("boot");
+    return runner;
 }
 //# sourceMappingURL=memory-sync-client.js.map

package/dist/plugins/adoption-log-sql.js

@@ -86,8 +86,8 @@ export class SqlAdoptionLogStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     get reader() {
         return this.db;
@@ -191,7 +191,7 @@ export class SqlAdoptionLogStore {
         try {
             lockName = qualifyAdoptionLockName(await this.resolveLockKeyspace(conn), name);
             for (let i = 0; i < attempts && !held; i += 1) {
-                const res = await conn.query(this.q("SELECT GET_LOCK(?, 0) AS got", "SELECT pg_try_advisory_lock($1, $2) AS got"), this.db.dialect === "tidb" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
+                const res = await conn.query(this.q("SELECT GET_LOCK(?, 0) AS got", "SELECT pg_try_advisory_lock($1, $2) AS got"), this.db.dialect === "mysql" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
                 const got = res.rows[0]?.got;
                 held = got === 1 || got === true || got === "1";
                 if (!held)
@@ -204,7 +204,7 @@ export class SqlAdoptionLogStore {
         finally {
             if (held) {
                 try {
-                    await conn.query(this.q("SELECT RELEASE_LOCK(?) AS released", "SELECT pg_advisory_unlock($1, $2) AS released"), this.db.dialect === "tidb" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
+                    await conn.query(this.q("SELECT RELEASE_LOCK(?) AS released", "SELECT pg_advisory_unlock($1, $2) AS released"), this.db.dialect === "mysql" ? [lockName] : [PG_ADOPTION_LOCK_CLASS, pgLockObjectKey(lockName)]);
                 }
                 catch (releaseErr) {
                     console.warn("[adoption-log] releasing the adoption arc lock failed (it auto-frees when the connection closes):", releaseErr);

package/dist/plugins/approval-ask-store-sql.js

@@ -386,7 +386,7 @@ function patchColumns(patch, json) {
     return out;
 }
 function ph(dialect, n) {
-    return dialect === "tidb" ? "?" : `$${n}`;
+    return dialect === "mysql" ? "?" : `$${n}`;
 }
 function pendingClaimWhere(dialect, firstParam) {
     return `ask_id = ${ph(dialect, firstParam)} AND batch_id = ${ph(dialect, firstParam + 1)} AND state = 'STREAM_PENDING'`;
@@ -394,15 +394,15 @@ function pendingClaimWhere(dialect, firstParam) {
 function decideOwnerWhere(dialect, owner, param) {
     if (owner === null)
         return { sql: "owner IS NULL", params: [] };
-    return dialect === "tidb" ? { sql: "CAST(owner AS BINARY) = CAST(? AS BINARY)", params: [owner] } : { sql: `owner = ${ph(dialect, param)}`, params: [owner] };
+    return dialect === "mysql" ? { sql: "CAST(owner AS BINARY) = CAST(? AS BINARY)", params: [owner] } : { sql: `owner = ${ph(dialect, param)}`, params: [owner] };
 }
 export class SqlApprovalAskStore {
     db;
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     json(value) {
         return dialectJsonEncoder(this.db.dialect)(value);
@@ -411,7 +411,7 @@ export class SqlApprovalAskStore {
         return isDupKeyError(this.db.dialect, e);
     }
     async getAskOn(conn, askId) {
-        const { rows } = await conn.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [askId]);
+        const { rows } = await conn.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [askId]);
         return rows[0] ? mapAskRow(rows[0]) : null;
     }
     async getBatchOn(conn, batchId) {
@@ -704,40 +704,40 @@ export class SqlApprovalAskStore {
         }
     }
     async listByState(state, limit) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE state = ? ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE state = $1 ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT $2`), [state, limit]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE state = ? ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE state = $1 ORDER BY updated_at_ms ASC, created_at_ms ASC LIMIT $2`), [state, limit]);
         return rows.map(mapAskRow);
     }
     async listPendingByTask(taskId, signal) {
         if (signal?.aborted === true)
             throw abortedReadError("listPendingByTask");
-        const { rows } = await withReadSignal(this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`), [taskId]), signal, "listPendingByTask");
+        const { rows } = await withReadSignal(this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND state = 'STREAM_PENDING' ORDER BY created_at_ms ASC`), [taskId]), signal, "listPendingByTask");
         return rows.map(mapAskRow);
     }
     async listPendingBySession(sessionId, owner, signal) {
         if (signal?.aborted === true)
             throw abortedReadError("listPendingBySession");
         const { rows } = await withReadSignal(this.db.query(owner === null
-            ? this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`)
-            : this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner = ? ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner = $2 ORDER BY created_at_ms ASC`), owner === null ? [sessionId] : [sessionId, owner]), signal, "listPendingBySession");
+            ? this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner IS NULL ORDER BY created_at_ms ASC`)
+            : this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'STREAM_PENDING' AND owner = ? ORDER BY created_at_ms ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'STREAM_PENDING' AND owner = $2 ORDER BY created_at_ms ASC`), owner === null ? [sessionId] : [sessionId, owner]), signal, "listPendingBySession");
         return rows.map(mapAskRow);
     }
     async listByCall(call) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND leg_key = ? AND tool_call_id = ? AND source_task_id = ? ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND leg_key = $2 AND tool_call_id = $3 AND source_task_id = $4 ORDER BY created_at_ms ASC, ask_id ASC`), [call.taskId, call.legKey, call.toolCallId, call.sourceTaskId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND leg_key = ? AND tool_call_id = ? AND source_task_id = ? ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND leg_key = $2 AND tool_call_id = $3 AND source_task_id = $4 ORDER BY created_at_ms ASC, ask_id ASC`), [call.taskId, call.legKey, call.toolCallId, call.sourceTaskId]);
         return rows.map(mapAskRow).filter((r) => askRowOnCall(r, call));
     }
     async listParkingBySession(sessionId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`), [sessionId]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = ? AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE session_id = $1 AND state = 'PARKING' ORDER BY created_at_ms ASC, ask_id ASC`), [sessionId]);
         return rows.map(mapAskRow).filter((r) => r.sessionId === sessionId);
     }
     async getAsk(askId) {
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE ask_id = $1`), [
             askId,
         ]);
         return rows[0] ? mapAskRow(rows[0]) : null;
     }
     async getByIdempotencyKey(taskId, key) {
         assertIdempotencyKeyShape(key);
-        const { rows } = await this.db.query(this.q(`SELECT ${askCols("tidb")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND idempotency_key = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND idempotency_key = $2`), [taskId, key]);
+        const { rows } = await this.db.query(this.q(`SELECT ${askCols("mysql")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = ? AND idempotency_key = ?`, `SELECT ${askCols("pg")} FROM ${APPROVAL_ASK_TABLE} WHERE task_id = $1 AND idempotency_key = $2`), [taskId, key]);
         return rows[0] ? mapAskRow(rows[0]) : null;
     }
     async deferReconcile(askId, expectedState, expectedRev, nowMs) {
@@ -772,7 +772,7 @@ export class SqlApprovalAskStore {
         const ANCHOR_COLUMNS = ["task_id", "session_id", "source_task_id"];
         let keepSql = "";
         let keepParams = [];
-        if (keep.length > 0 && dialect === "tidb") {
+        if (keep.length > 0 && dialect === "mysql") {
             const list = keep.map(() => "?").join(", ");
             keepSql = ANCHOR_COLUMNS.map((c) => ` AND ${c} NOT IN (${list})`).join("");
             keepParams = ANCHOR_COLUMNS.flatMap(() => keep);

package/dist/plugins/approval-nonce-store.js

@@ -10,15 +10,15 @@ export class SqlApprovalNonceStore {
     constructor(db) {
         this.db = db;
     }
-    q(tidb, pg) {
-        return this.db.dialect === "tidb" ? tidb : pg;
+    q(mysql, pg) {
+        return this.db.dialect === "mysql" ? mysql : pg;
     }
     async nowMs() {
         return sqlDbNowMs(this.db, APPROVAL_NONCE_TABLE);
     }
     async consume(sessionId, nonce, expiresAtMs) {
         try {
-            await this.db.query(this.q(`INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES (?,?,${SQL_DB_NOW_MS.tidb},?)`, `INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES ($1,$2,${SQL_DB_NOW_MS.pg},$3)`), [sessionId, nonce, expiresAtMs]);
+            await this.db.query(this.q(`INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES (?,?,${SQL_DB_NOW_MS.mysql},?)`, `INSERT INTO ${APPROVAL_NONCE_TABLE} (session_id, nonce, consumed_at_ms, expires_at_ms) VALUES ($1,$2,${SQL_DB_NOW_MS.pg},$3)`), [sessionId, nonce, expiresAtMs]);
             return true;
         }
         catch (err) {
@@ -28,7 +28,7 @@ export class SqlApprovalNonceStore {
         }
     }
     async reapExpired() {
-        const res = await this.db.query(this.q(`DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.tidb}`, `DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.pg}`), []);
+        const res = await this.db.query(this.q(`DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.mysql}`, `DELETE FROM ${APPROVAL_NONCE_TABLE} WHERE expires_at_ms <= ${SQL_DB_NOW_MS.pg}`), []);
         return res.affected;
     }
 }

package/dist/plugins/blob-backend.d.ts

@@ -1,6 +1,6 @@
 import type { Pool as MysqlPool } from "mysql2/promise";
 import type { Pool as PgPool } from "pg";
-import { type SqlEngineFacts, type SqlEngineReading, type SqlWallSource, type SqlWallsReading } from "./sql-driver.js";
+import { type SqlEngineFacts, type SqlEngineReading, type SqlWallSource, type SqlWallsReading, type SqlDialect } from "./sql-driver.js";
 import { type Logger } from "../observability/logger.js";
 /**
  * 文本协议的 blob 膨胀律 —— mysql2 `query()` 把 Buffer 参数写成 `X'<hex>'`,一字节两个字符,所以承载一个 blob 的语句至少是它的 2 倍。
@@ -115,7 +115,7 @@ export declare class SqlBlobBackend implements BlobBackend {
     private readonly db;
     /** Where a stale connection's replacement is logged ({@link connectJudged}); the boot assembly passes the service logger. */
     private readonly log;
-    constructor(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, maxBytes?: number, table?: string, log?: Pick<Logger, "warn">);
+    constructor(dialect: SqlDialect, pool: MysqlPool | PgPool, maxBytes?: number, table?: string, log?: Pick<Logger, "warn">);
     /** The created_at-refreshing content-addressed upsert — VERBATIM the tidb/pg stores' `putBlobRow`. Refreshes
      *  created_at even on a dedup hit so a re-used/just-written blob is "touched=now" and GC-grace-protected.
      *  (a): an over-cap blob is REJECTED (typed {@link BlobTooLargeError}) BEFORE the driver ever sees the bytes —
@@ -140,7 +140,7 @@ export declare class SqlBlobBackend implements BlobBackend {
 /** SHARED index op(workspace 浏览面 #3,[ref]②)—— per-blob 字节数,读 SQL INDEX 的 `byte_len`
  *  列(sqlHasBlobs 同款单 IN 查询;MinIO 后端的 bytes-NULL 索引行同样带 byte_len,两后端同源)。
  *  tree/file 面的 size 投影与「超限先拒后拉」都靠它——绝不为拿大小去 getBlob 整块字节。 */
-export declare function sqlBlobSizes(dialect: "tidb" | "pg", pool: MysqlPool | PgPool, hashes: string[]): Promise<Map<string, number>>;
+export declare function sqlBlobSizes(dialect: SqlDialect, pool: MysqlPool | PgPool, hashes: string[]): Promise<Map<string, number>>;
 export interface MinioBlobBackendConfig {
     endpoint: string;
     bucket: string;
@@ -198,7 +198,7 @@ export declare class MinioBlobBackend implements BlobBackend {
     /** Blob-domain index table ([ref] 域隔离,SqlBlobBackend.table 同款;默认 = E19 纪元的 snapshot_blob)。 */
     private readonly indexTable;
     constructor(cfg: MinioBlobBackendConfig, index?: {
-        dialect: "tidb" | "pg";
+        dialect: SqlDialect;
         pool: MysqlPool | PgPool;
         table?: string;
     });

package/dist/plugins/blob-backend.js

@@ -76,7 +76,7 @@ export class SqlBlobBackend {
         this.pool = pool;
         this.explicitCapBytes = maxBytes;
         this.table = table;
-        this.db = dialect === "tidb" ? mysqlDriver(pool) : pgDriver(pool);
+        this.db = dialect === "mysql" ? mysqlDriver(pool) : pgDriver(pool);
         this.log = log ?? createLogger();
     }
     async putBlob(hash, bytes) {
@@ -90,7 +90,7 @@ export class SqlBlobBackend {
         if (judged.refusal !== undefined)
             throw new BlobTooLargeError(bytes.byteLength, judged.refusal.cap);
         try {
-            await judged.conn.query(this.dialect === "tidb"
+            await judged.conn.query(this.dialect === "mysql"
                 ? `INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES (?,?,?,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)`
                 : `INSERT INTO ${this.table} (blob_hash, byte_len, bytes, created_at) VALUES ($1,$2,$3,$4) ON CONFLICT (blob_hash) DO UPDATE SET created_at = EXCLUDED.created_at`, [hash, bytes.byteLength, Buffer.from(bytes), new Date()]);
         }
@@ -99,7 +99,7 @@ export class SqlBlobBackend {
         }
     }
     async getBlob(hash) {
-        if (this.dialect === "tidb") {
+        if (this.dialect === "mysql") {
             const [rows] = await this.pool.query(`SELECT bytes FROM ${this.table} WHERE blob_hash = ?`, [hash]);
             return rows[0]?.bytes != null ? new Uint8Array(rows[0].bytes) : undefined;
         }
@@ -118,7 +118,7 @@ async function sqlHasBlobs(dialect, pool, hashes, table = "snapshot_blob") {
     if (hashes.length === 0)
         return new Set();
     const distinct = [...new Set(hashes)];
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const ph = distinct.map(() => "?").join(",");
         const [rows] = await pool.query(`SELECT blob_hash FROM ${table} WHERE blob_hash IN (${ph})`, distinct);
         return new Set(rows.map((r) => String(r.blob_hash)));
@@ -135,7 +135,7 @@ export async function sqlBlobSizes(dialect, pool, hashes) {
     const out = new Map();
     for (let i = 0; i < distinct.length; i += CHUNK) {
         const part = distinct.slice(i, i + CHUNK);
-        if (dialect === "tidb") {
+        if (dialect === "mysql") {
             const ph = part.map(() => "?").join(",");
             const [rows] = await pool.query(`SELECT blob_hash, byte_len FROM snapshot_blob WHERE blob_hash IN (${ph})`, part);
             for (const r of rows)
@@ -155,7 +155,7 @@ async function sqlDeleteIndexRowsPastGrace(dialect, pool, hashes, table = "snaps
         return [];
     const distinct = [...new Set(hashes)];
     const cutoff = new Date(Date.now() - BLOB_GC_GRACE_MS);
-    if (dialect === "tidb") {
+    if (dialect === "mysql") {
         const ph = distinct.map(() => "?").join(",");
         const grace = await pool
             .query(`SELECT blob_hash FROM ${table} WHERE created_at < ? AND blob_hash IN (${ph})`, [cutoff, ...distinct])
@@ -216,7 +216,7 @@ export class MinioBlobBackend {
             throw new Error(`MinioBlobBackend.putBlob ${hash}: HTTP ${res.status} ${detail.slice(0, 200)}`);
         }
         if (this.indexPool && this.indexDialect) {
-            if (this.indexDialect === "tidb") {
+            if (this.indexDialect === "mysql") {
                 await this.indexPool.query(`INSERT INTO ${this.indexTable} (blob_hash, byte_len, bytes, created_at) VALUES (?,?,NULL,?) ON DUPLICATE KEY UPDATE created_at = VALUES(created_at)`, [hash, bytes.byteLength, new Date()]);
             }
             else {