@max-null/dsh-memory 0.7.1 → 0.7.3

package/dist/engine.d.ts

@@ -218,6 +218,8 @@ export declare class MemoryEngine extends Service {
     private globalTable?;
     /** project 域按工作区 cwd 懒打开 + 缓存（多会话并发各工作区独立）。 */
     private projectTables;
+    /** 进行中的工作区打开（key → promise）：并发调用复用同一次，见 {@link projectTableFor}。 */
+    private readonly projectOpenings;
     private projectFacilities;
     /** backend 只注册一次（registry 重名抛 duplicate；reload 清缓存后不得重复注册）。 */
     private registeredProjectBackends;
@@ -236,15 +238,34 @@ export declare class MemoryEngine extends Service {
     private projectRootFor;
     /** 稳定 backend 名（registry 重名抛错，按 cwd hash 唯一化；只允许 [a-z0-9_]，domain 名校验）。 */
     private projectBackendName;
+    /**
+     * 工作区表是否已经打开（同步判断）。组装路径用它决定「要不要等一次预热」——
+     * 表已打开是常态，那时这条路径不该付出任何异步代价。
+     */
+    projectOpen(projectCwd?: string): boolean;
     /**
      * 按工作区 cwd 取 project 表（懒打开 + 缓存）。无 cwd（未选工作区）
      * 返回 undefined——调用方（工具/面板）按此跳过 project 部分。
+     *
+     * **打开是异步的，调用方却会并发**：预热是 fire-and-forget，注入路径、工具路径、
+     * 面板路径各来一次。底层 unit 句柄只允许一个，两次并发打开会让后到者以
+     * `unit '…' is already open; a unit has exactly one live handle` 失败——而调用方
+     * 普遍把预热失败当无碍吞掉，于是表现为「这一轮工作区记忆缺席」。所以这里复用
+     * 进行中的那次打开。
      */
     private projectTableFor;
+    /** {@link projectTableFor} 的实际打开步骤；并发去重由调用方负责。 */
+    private openProjectTable;
     /**
      * 强制重载存储：关闭全局域与全部已开工作区域后重开（unit 释放后
      * backend 重读文件），放弃内存缓存。供外部编辑记忆文件后刷新
-     * （JsonStorageBackend 打开时加载一次，无 watch——2026-08-19 实测）。
+     * （JsonStorageBackend 打开时加载一次，无 watch——2026-08-19 实测）；
+     * 多实例写入协调（0.7.1）让它在每次「磁盘被别人改过」时自动触发。
+     *
+     * **已打开的工作区要重开，而不是一关了之**：注入 provider 是同步回调、只读
+     * 已打开的表，关掉就等同于「这个工作区没有常驻记忆」——工作区记忆会从上下文里
+     * 静默消失，直到某次工具调用把它重新打开。重开的表同样从磁盘重读，
+     * 「放弃内存缓存」这条语义不变，改变的只是「重读完别忘了装回去」。
      */
     reload(): Promise<void>;
     /**

package/dist/engine.js

@@ -166,6 +166,8 @@ export class MemoryEngine extends Service {
     globalTable;
     /** project 域按工作区 cwd 懒打开 + 缓存（多会话并发各工作区独立）。 */
     projectTables = new Map();
+    /** 进行中的工作区打开（key → promise）：并发调用复用同一次，见 {@link projectTableFor}。 */
+    projectOpenings = new Map();
     projectFacilities = new Map();
     /** backend 只注册一次（registry 重名抛 duplicate；reload 清缓存后不得重复注册）。 */
     registeredProjectBackends = new Set();
@@ -211,9 +213,24 @@ export class MemoryEngine extends Service {
             h = ((h << 5) + h + text.charCodeAt(i)) | 0;
         return `memory_project_${Math.abs(h).toString(36)}`;
     }
+    /**
+     * 工作区表是否已经打开（同步判断）。组装路径用它决定「要不要等一次预热」——
+     * 表已打开是常态，那时这条路径不该付出任何异步代价。
+     */
+    projectOpen(projectCwd) {
+        if (projectCwd === undefined || projectCwd === '')
+            return false;
+        return this.projectTables.has(join(projectCwd));
+    }
     /**
      * 按工作区 cwd 取 project 表（懒打开 + 缓存）。无 cwd（未选工作区）
      * 返回 undefined——调用方（工具/面板）按此跳过 project 部分。
+     *
+     * **打开是异步的，调用方却会并发**：预热是 fire-and-forget，注入路径、工具路径、
+     * 面板路径各来一次。底层 unit 句柄只允许一个，两次并发打开会让后到者以
+     * `unit '…' is already open; a unit has exactly one live handle` 失败——而调用方
+     * 普遍把预热失败当无碍吞掉，于是表现为「这一轮工作区记忆缺席」。所以这里复用
+     * 进行中的那次打开。
      */
     async projectTableFor(projectCwd) {
         if (projectCwd === undefined || projectCwd === '')
@@ -222,6 +239,20 @@ export class MemoryEngine extends Service {
         const cached = this.projectTables.get(key);
         if (cached !== undefined)
             return cached;
+        const inFlight = this.projectOpenings.get(key);
+        if (inFlight !== undefined)
+            return await inFlight;
+        const opening = this.openProjectTable(key);
+        this.projectOpenings.set(key, opening);
+        try {
+            return await opening;
+        }
+        finally {
+            this.projectOpenings.delete(key);
+        }
+    }
+    /** {@link projectTableFor} 的实际打开步骤；并发去重由调用方负责。 */
+    async openProjectTable(key) {
         const backendName = this.projectBackendName(key);
         // 0.5.2：旧实现 domain 名多一层 memory_project_ 前缀（文件名双重前缀，
         // 且 unit 文件头 name 同为旧名）。打开前统一迁移到规范名：
@@ -262,15 +293,30 @@ export class MemoryEngine extends Service {
     /**
      * 强制重载存储：关闭全局域与全部已开工作区域后重开（unit 释放后
      * backend 重读文件），放弃内存缓存。供外部编辑记忆文件后刷新
-     * （JsonStorageBackend 打开时加载一次，无 watch——2026-08-19 实测）。
+     * （JsonStorageBackend 打开时加载一次，无 watch——2026-08-19 实测）；
+     * 多实例写入协调（0.7.1）让它在每次「磁盘被别人改过」时自动触发。
+     *
+     * **已打开的工作区要重开，而不是一关了之**：注入 provider 是同步回调、只读
+     * 已打开的表，关掉就等同于「这个工作区没有常驻记忆」——工作区记忆会从上下文里
+     * 静默消失，直到某次工具调用把它重新打开。重开的表同样从磁盘重读，
+     * 「放弃内存缓存」这条语义不变，改变的只是「重读完别忘了装回去」。
      */
     async reload() {
+        // 进行中的打开先落地：否则它们会在下面的 clear 之后把表塞回已清空的映射，
+        // 留下「表在映射里但 facility 已关」的半死状态。
+        await Promise.allSettled([...this.projectOpenings.values()]);
+        const opened = [...this.projectTables.keys()];
         await this.facility?.closeAll();
         for (const facility of this.projectFacilities.values())
             await facility.closeAll();
         this.projectTables.clear();
         this.projectFacilities.clear();
         await this.openGlobalFacility();
+        for (const key of opened) {
+            // 重开失败 = 该工作区退回「未打开」（本轮注入缺这部分，下次访问重试），
+            // 不该让触发重载的那一整次写入跟着失败。
+            await this.projectTableFor(key).catch(() => undefined);
+        }
     }
     /**
      * Create one record. 低危内容直接 `approved`（静默生效，2026-09-15 静默记忆机制）；

package/dist/index.js

@@ -159,6 +159,8 @@ export async function apply(ctx, config) {
         order: 49,
         text: SELF_DESCRIPTION,
     });
+    const injectionBudget = config?.injectionBudget ?? DEFAULT_INJECTION_BUDGET;
+    const summaryChars = config?.summaryChars ?? DEFAULT_SUMMARY_CHARS;
     ctx.systemPrompt.context({
         name: 'memory:recall',
         order: 50,
@@ -166,11 +168,34 @@ export async function apply(ctx, config) {
             const cwd = assemblyProjectCwd(assembly);
             if (cwd !== undefined)
                 void memory.ensureProjectOpen(cwd).catch(() => { });
-            const budget = config?.injectionBudget ?? DEFAULT_INJECTION_BUDGET;
-            const summaryChars = config?.summaryChars ?? DEFAULT_SUMMARY_CHARS;
-            return recallText(memory, cwd, budget, summaryChars);
+            return recallText(memory, cwd, injectionBudget, summaryChars);
         },
     });
+    // 上面那条 provider 是**同步**的（`SystemPrompt.context` 的 `text` 类型就是
+    // `string | ((context) => string)`），而工作区表是异步打开的：重启后首次组装时
+    // 它还没打开，工作区记忆会整整缺席一轮（等预热完成，第二轮才回来）。
+    // `system-prompt/assemble` 是异步 waterfall、文档写明「返回值权威」，在这里补一次。
+    //
+    // **不能拿「此刻表是否打开」当作「provider 渲染时表是否打开」的判据**：provider 里那次
+    // 预热的 Promise 可能在 `next()` 的 await 期间就完成了，于是这里看到「已打开」而跳过，
+    // 而 provider 渲染时它还是空的。所以这里总是重渲染一遍——`renderInjection` 是纯函数、
+    // 读的是内存表，代价可忽略；文本没变就原样返回，不动 downstream 看到的对象。
+    ctx.on('system-prompt/assemble', async (assembly, context, next) => {
+        const assembled = await next();
+        const cwd = assemblyProjectCwd(context);
+        if (cwd === undefined || cwd === '')
+            return assembled;
+        if (!memory.projectOpen(cwd))
+            await memory.ensureProjectOpen(cwd).catch(() => undefined);
+        const text = recallText(memory, cwd, injectionBudget, summaryChars);
+        const current = assembled.contexts.find(entry => entry.name === 'memory:recall');
+        if (current === undefined || current.text === text)
+            return assembled;
+        return {
+            ...assembled,
+            contexts: assembled.contexts.map(entry => entry.name === 'memory:recall' ? { ...entry, text } : entry),
+        };
+    });
     // 会话创建即预热对应工作区的 project 表（0.5.1）：让首轮模型请求就
     // 能注入工作区常驻记忆（provider 同步只读已打开的表）。
     // session/created 事件由 dsh-session 提供（可选依赖：无 session 服务

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Cross-session plaintext memory plugin for the DeepSeek Harness — deterministic BM25 recall, writes take effect immediately, signal-driven injection, no embeddings",
   "license": "MIT",
   "publishConfig": {