fix(memory): harden qmd status manager lifecycle

neeravmakwana · neeravmakwana · commit c7d8699d95ed · 2026-03-24T09:12:49.000-04:00
diff --git a/src/memory/search-manager.test.ts b/src/memory/search-manager.test.ts
@@ -225,9 +225,30 @@ describe("getMemorySearchManager caching", () => {
 
     requireManager(full);
     requireManager(status);
-    expect(status.manager).toBe(full.manager);
+    expect(status.manager).not.toBe(full.manager);
     // eslint-disable-next-line @typescript-eslint/unbound-method
     expect(createQmdManagerMock).toHaveBeenCalledTimes(1);
+    await status.manager?.close?.();
+    expect(mockPrimary.close).not.toHaveBeenCalled();
+
+    const fullAgain = await getMemorySearchManager({ cfg, agentId });
+    expect(fullAgain.manager).toBe(full.manager);
+  });
+
+  it("evicts closed cached status managers so later status requests get a fresh manager", async () => {
+    const agentId = "status-eviction-agent";
+    const cfg = createQmdCfg(agentId);
+
+    const first = await getMemorySearchManager({ cfg, agentId, purpose: "status" });
+    const firstManager = requireManager(first);
+    await firstManager.close?.();
+
+    const second = await getMemorySearchManager({ cfg, agentId, purpose: "status" });
+    requireManager(second);
+
+    expect(second.manager).not.toBe(firstManager);
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    expect(createQmdManagerMock).toHaveBeenCalledTimes(2);
   });
 
   it("does not evict a newer cached wrapper when closing an older failed wrapper", async () => {
diff --git a/src/memory/search-manager.ts b/src/memory/search-manager.ts
@@ -53,12 +53,12 @@ export async function getMemorySearchManager(params: {
       return { manager: cached };
     }
     if (statusOnly) {
-      // Reuse an existing full manager for status requests to avoid duplicate
-      // QMD managers and extra sqlite handles for the same agent/config.
       const fullCached = QMD_MANAGER_CACHE.get(`${baseCacheKey}:full`);
       if (fullCached) {
-        QMD_MANAGER_CACHE.set(cacheKey, fullCached);
-        return { manager: fullCached };
+        // Status callers often close the manager they receive. Wrap the live
+        // full manager with a no-op close so health/status probes do not tear
+        // down the active QMD manager for the process.
+        return { manager: new BorrowedMemoryManager(fullCached) };
       }
     }
     try {
@@ -71,8 +71,11 @@ export async function getMemorySearchManager(params: {
       });
       if (primary) {
         if (statusOnly) {
-          QMD_MANAGER_CACHE.set(cacheKey, primary);
-          return { manager: primary };
+          const wrapper = new CachedStatusMemoryManager(primary, () => {
+            QMD_MANAGER_CACHE.delete(cacheKey);
+          });
+          QMD_MANAGER_CACHE.set(cacheKey, wrapper);
+          return { manager: wrapper };
         }
         const wrapper = new FallbackMemoryManager(
           {
@@ -105,6 +108,97 @@ export async function getMemorySearchManager(params: {
   }
 }
 
+class BorrowedMemoryManager implements MemorySearchManager {
+  constructor(private readonly inner: MemorySearchManager) {}
+
+  async search(
+    query: string,
+    opts?: { maxResults?: number; minScore?: number; sessionKey?: string },
+  ) {
+    return await this.inner.search(query, opts);
+  }
+
+  async readFile(params: { relPath: string; from?: number; lines?: number }) {
+    return await this.inner.readFile(params);
+  }
+
+  status() {
+    return this.inner.status();
+  }
+
+  async sync(params?: {
+    reason?: string;
+    force?: boolean;
+    sessionFiles?: string[];
+    progress?: (update: MemorySyncProgressUpdate) => void;
+  }) {
+    await this.inner.sync?.(params);
+  }
+
+  async probeEmbeddingAvailability(): Promise<MemoryEmbeddingProbeResult> {
+    return await this.inner.probeEmbeddingAvailability();
+  }
+
+  async probeVectorAvailability() {
+    return await this.inner.probeVectorAvailability();
+  }
+
+  async close() {}
+}
+
+class CachedStatusMemoryManager implements MemorySearchManager {
+  private closed = false;
+
+  constructor(
+    private readonly inner: MemorySearchManager,
+    private readonly onClose: () => void,
+  ) {}
+
+  async search(
+    query: string,
+    opts?: { maxResults?: number; minScore?: number; sessionKey?: string },
+  ) {
+    return await this.inner.search(query, opts);
+  }
+
+  async readFile(params: { relPath: string; from?: number; lines?: number }) {
+    return await this.inner.readFile(params);
+  }
+
+  status() {
+    return this.inner.status();
+  }
+
+  async sync(params?: {
+    reason?: string;
+    force?: boolean;
+    sessionFiles?: string[];
+    progress?: (update: MemorySyncProgressUpdate) => void;
+  }) {
+    await this.inner.sync?.(params);
+  }
+
+  async probeEmbeddingAvailability(): Promise<MemoryEmbeddingProbeResult> {
+    return await this.inner.probeEmbeddingAvailability();
+  }
+
+  async probeVectorAvailability() {
+    return await this.inner.probeVectorAvailability();
+  }
+
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    try {
+      await this.inner.close?.();
+    } finally {
+      this.onClose();
+    }
+  }
+}
+
 export async function closeAllMemorySearchManagers(): Promise<void> {
   const managers = Array.from(QMD_MANAGER_CACHE.values());
   QMD_MANAGER_CACHE.clear();
