Memory: fix async sync close race

src/memory/manager.async-search.test.ts

@@ -3,7 +3,7 @@ import os from "node:os";
 import path from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { OpenClawConfig } from "../config/config.js";
-import type { MemoryIndexManager } from "./index.js";
+import { getMemorySearchManager, type MemoryIndexManager } from "./index.js";
 import { createOpenAIEmbeddingProviderMock } from "./test-embeddings-mock.js";
 import { createMemoryManagerOrThrow } from "./test-manager.js";
 
@@ -23,7 +23,27 @@ describe("memory search async sync", () => {
   let indexPath: string;
   let manager: MemoryIndexManager | null = null;
 
+  const buildConfig = (): OpenClawConfig =>
+    ({
+      agents: {
+        defaults: {
+          workspace: workspaceDir,
+          memorySearch: {
+            provider: "openai",
+            model: "text-embedding-3-small",
+            store: { path: indexPath },
+            sync: { watch: false, onSessionStart: false, onSearch: true },
+            query: { minScore: 0 },
+            remote: { batch: { enabled: true, wait: true } },
+          },
+        },
+        list: [{ id: "main", default: true }],
+      },
+    }) as OpenClawConfig;
+
   beforeEach(async () => {
+    embedBatch.mockReset();
+    embedBatch.mockImplementation(async (input: string[]) => input.map(() => [0.2, 0.2, 0.2]));
     workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-mem-async-"));
     indexPath = path.join(workspaceDir, "index.sqlite");
     await fs.mkdir(path.join(workspaceDir, "memory"));
@@ -40,22 +60,7 @@ describe("memory search async sync", () => {
   });
 
   it("does not await sync when searching", async () => {
-    const cfg = {
-      agents: {
-        defaults: {
-          workspace: workspaceDir,
-          memorySearch: {
-            provider: "openai",
-            model: "text-embedding-3-small",
-            store: { path: indexPath },
-            sync: { watch: false, onSessionStart: false, onSearch: true },
-            query: { minScore: 0 },
-            remote: { batch: { enabled: true, wait: true } },
-          },
-        },
-        list: [{ id: "main", default: true }],
-      },
-    } as OpenClawConfig;
+    const cfg = buildConfig();
 
     manager = await createMemoryManagerOrThrow(cfg);
 
@@ -70,4 +75,41 @@ describe("memory search async sync", () => {
     await activeManager.search("hello");
     expect(syncMock).toHaveBeenCalledTimes(1);
   });
+
+  it("waits for in-flight search sync during close", async () => {
+    const cfg = buildConfig();
+    let releaseSync: (() => void) | null = null;
+    const syncGate = new Promise<void>((resolve) => {
+      releaseSync = resolve;
+    });
+    embedBatch.mockImplementation(async (input: string[]) => {
+      await syncGate;
+      return input.map(() => [0.3, 0.2, 0.1]);
+    });
+
+    manager = await createMemoryManagerOrThrow(cfg);
+    await manager.search("hello");
+
+    let closed = false;
+    const closePromise = manager.close().then(() => {
+      closed = true;
+    });
+
+    await Promise.resolve();
+    expect(closed).toBe(false);
+
+    releaseSync?.();
+    await closePromise;
+    manager = null;
+
+    const reopened = await getMemorySearchManager({ cfg, agentId: "main", purpose: "status" });
+    expect(reopened.manager).not.toBeNull();
+    if (!reopened.manager) {
+      throw new Error("reopened manager missing");
+    }
+    const status = reopened.manager.status();
+    expect(status.files).toBeGreaterThan(0);
+    expect(status.dirty).toBe(false);
+    await reopened.manager.close?.();
+  });
 });

src/memory/manager.ts

@@ -379,6 +379,9 @@ export class MemoryIndexManager extends MemoryManagerEmbeddingOps implements Mem
     force?: boolean;
     progress?: (update: MemorySyncProgressUpdate) => void;
   }): Promise<void> {
+    if (this.closed) {
+      return;
+    }
     if (this.syncing) {
       return this.syncing;
     }
@@ -602,6 +605,7 @@ export class MemoryIndexManager extends MemoryManagerEmbeddingOps implements Mem
       return;
     }
     this.closed = true;
+    const pendingSync = this.syncing;
     if (this.watchTimer) {
       clearTimeout(this.watchTimer);
       this.watchTimer = null;
@@ -622,6 +626,11 @@ export class MemoryIndexManager extends MemoryManagerEmbeddingOps implements Mem
       this.sessionUnsubscribe();
       this.sessionUnsubscribe = null;
     }
+    if (pendingSync) {
+      try {
+        await pendingSync;
+      } catch {}
+    }
     this.db.close();
     INDEX_CACHE.delete(this.cacheKey);
   }