fix(memory): search memory and wiki concurrently for corpus=all (#92633)

openperf · claude · openperf · commit bed7b4ec660b · 2026-06-14T09:52:18.000+08:00
corpus=all awaited the memory/sessions branch fully before starting the
wiki/supplement branch, so two searches that each fit the 15s tool
deadline summed past it and the tool returned empty with disabled=true.
Start the supplement search concurrently with the memory branch within
the same deadline; combined wall time drops to ~max(branch).

Co-Authored-By: Claude Opus 4.8 &lt;noreply@anthropic.com&gt;
diff --git a/extensions/memory-core/src/tools.citations.test.ts b/extensions/memory-core/src/tools.citations.test.ts
@@ -495,6 +495,104 @@ describe("memory tools", () => {
     expect(getMemorySearchManagerMockCalls()).toBe(1);
   });
 
+  it("runs the memory and wiki branches concurrently for corpus=all (#92633)", async () => {
+    // Regression: corpus=all awaited the memory/sessions branch fully before
+    // starting the wiki/supplement branch, so two searches that each finished
+    // well under the 15s tool deadline summed past it and the tool returned
+    // nothing. Running them concurrently keeps the combined wall time near
+    // max(branch), so the same two 9s searches now resolve at ~9s.
+    vi.useFakeTimers();
+    try {
+      const delay = (ms: number) =>
+        new Promise<void>((resolve) => {
+          setTimeout(resolve, ms);
+        });
+      setMemorySearchImpl(async () => {
+        await delay(9_000);
+        return [
+          {
+            path: "MEMORY.md",
+            startLine: 5,
+            endLine: 7,
+            score: 0.9,
+            snippet: "@@ -5,3 @@\nAssistant: noted",
+            source: "memory" as const,
+          },
+        ];
+      });
+      registerMemoryCorpusSupplement("memory-wiki", {
+        search: async () => {
+          await delay(9_000);
+          return [
+            {
+              corpus: "wiki",
+              path: "entities/alpha.md",
+              title: "Alpha",
+              kind: "entity",
+              score: 1.1,
+              snippet: "Alpha wiki entry",
+            },
+          ];
+        },
+        get: async () => null,
+      });
+
+      const tool = createMemorySearchToolOrThrow();
+      const resultPromise = tool.execute("call_all_concurrent", {
+        query: "alpha",
+        corpus: "all",
+      });
+      // Sequentially the two branches take 18s and trip the 15s deadline;
+      // concurrently the tool resolves once the shared 9s elapses.
+      await vi.advanceTimersByTimeAsync(9_000);
+      const result = await resultPromise;
+      const details = result.details as {
+        disabled?: boolean;
+        results: Array<{ corpus: string; path: string }>;
+      };
+      expect(details.disabled).toBeUndefined();
+      expect(details.results.map((entry) => [entry.corpus, entry.path])).toEqual([
+        ["wiki", "entities/alpha.md"],
+        ["memory", "MEMORY.md"],
+      ]);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("records the memory cooldown when corpus=all memory and wiki both fail (#92633)", async () => {
+    // Concurrency must not let a wiki failure mask a real memory backend failure:
+    // when both branches throw, the memory cooldown still has to be recorded so a
+    // broken embedding provider is suppressed rather than re-hit on the next turn.
+    let searchCalls = 0;
+    setMemorySearchImpl(async () => {
+      searchCalls += 1;
+      throw new Error("openai embeddings failed: 500 server_error");
+    });
+    registerMemoryCorpusSupplement("memory-wiki", {
+      search: async () => {
+        throw new Error("wiki supplement unavailable");
+      },
+      get: async () => null,
+    });
+
+    const tool = createMemorySearchToolOrThrow();
+    const bothFail = await tool.execute("call_all_both_fail", {
+      query: "alpha",
+      corpus: "all",
+    });
+    expectUnavailableMemorySearchDetails(bothFail.details, {
+      error: "openai embeddings failed: 500 server_error",
+      warning: "Memory search is unavailable due to an embedding/provider error.",
+      action: "Check embedding provider configuration and retry memory_search.",
+    });
+
+    // The next memory search is suppressed by the cooldown (no second backend hit).
+    const followup = await tool.execute("call_memory_after_both_fail", { query: "alpha" });
+    expect((followup.details as { disabled?: boolean }).disabled).toBe(true);
+    expect(searchCalls).toBe(1);
+  });
+
   it("does not cooldown primary memory when a corpus=all wiki supplement stalls", async () => {
     vi.useFakeTimers();
     try {
diff --git a/extensions/memory-core/src/tools.ts b/extensions/memory-core/src/tools.ts
@@ -393,10 +393,13 @@ export function createMemorySearchTool(options: {
         });
         const cooldown =
           requestedCorpus === "wiki" ? undefined : readMemorySearchToolCooldown(cooldownKey);
-        let activeUnavailablePhase: "memory" | "supplement" | undefined;
-        let failedUnavailablePhase: "memory" | "supplement" | undefined;
+        // Only the memory/sessions branch feeds this tracker; the wiki branch
+        // runs concurrently (see below) and a second writer would make the
+        // corpus=all cooldown attribution race on last-writer-wins.
+        let activeUnavailablePhase: "memory" | undefined;
+        let failedUnavailablePhase: "memory" | undefined;
         const runUnavailablePhase = async <T>(
-          phase: "memory" | "supplement",
+          phase: "memory",
           task: () => Promise<T>,
         ): Promise<T> => {
           activeUnavailablePhase = phase;
@@ -430,6 +433,23 @@ export function createMemorySearchTool(options: {
               return context;
             };
             try {
+              // Run the wiki/supplement branch concurrently with memory/sessions:
+              // corpus=all previously awaited them sequentially under one 15s
+              // deadline, so two individually-fast searches summed past it and
+              // returned nothing (#92633). It stays outside runUnavailablePhase so
+              // the cooldown's memory-failure attribution is unaffected by the
+              // wiki branch; .catch absorbs the rejection on the rare paused-index
+              // early return that skips the await below.
+              const supplementResultsPromise: Promise<MemoryCorpusSearchResult[]> =
+                shouldQuerySupplements
+                  ? searchMemoryCorpusSupplements({
+                      query,
+                      maxResults,
+                      agentSessionKey: options.agentSessionKey,
+                      corpus: requestedCorpus,
+                    })
+                  : Promise.resolve([]);
+              supplementResultsPromise.catch(() => undefined);
               const memory = shouldQueryMemory
                 ? await runUnavailablePhase("memory", async () =>
                     trackMemoryManager(
@@ -599,18 +619,7 @@ export function createMemorySearchTool(options: {
                   );
                 }
               }
-              const supplementResults = shouldQuerySupplements
-                ? await runUnavailablePhase(
-                    "supplement",
-                    async () =>
-                      await searchMemoryCorpusSupplements({
-                        query,
-                        maxResults,
-                        agentSessionKey: options.agentSessionKey,
-                        corpus: requestedCorpus,
-                      }),
-                  )
-                : [];
+              const supplementResults = await supplementResultsPromise;
               // Wiki and memory scores use incomparable scales, so corpus=all first
               // balances candidate selection and then backfills any unused slots.
               const effectiveMax = Math.max(1, maxResults ?? 10);
