fix(memory): complete recursive search follow-up

leafbird · leafbird · commit b871c4a7f869 · 2026-05-10T14:44:38.000Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1545,6 +1545,7 @@ Docs: https://docs.openclaw.ai
 - Replies: strip legacy `[TOOL_CALL]{tool => ..., args => ...}[/TOOL_CALL]` pseudo-call text from user-facing replies and flag it in tool-call diagnostics instead of showing raw tool syntax in channels. Fixes #63610. Thanks @canh0chua.
 - WhatsApp: close long-lived web sockets through Baileys `end(error)` before falling back to raw websocket close, so listener teardown runs Baileys cleanup instead of leaving zombie sockets. Fixes #52442. Thanks @essendigitalgroup-cyber.
 - Twitch/plugins: emit a flat JSON Schema for Twitch channel config so single-account and multi-account configs validate before runtime load, and add source-checkout diagnostics for missing pnpm workspace dependencies. Thanks @vincentkoc.
+- Memory/memory_search: await dirty builtin memory index sync before agent-facing search, recognize nested dated memory paths, and watch memory roots directly so first-search results stay fresh for recursive `memory/**/*.md` changes. Fixes #52115 and #34400. Thanks @leafbird.
 - Gateway/sessions: move hot transcript reads and mirror appends onto async bounded IO with serialized parent-linked writes, keeping large session histories from stalling Gateway requests and channel replies. Fixes #75656. Thanks @DerFlash.
 - macOS/Talk Mode: downmix multi-channel microphone buffers before handing them to Apple Speech across Push-to-Talk, Talk Mode, Voice Wake, and the wake-word tester, so pro audio interfaces no longer produce empty transcripts. Fixes #42533. Thanks @jbuecker.
 - macOS/Talk Mode: subscribe native WebChat to active-session transcript updates and render external spoken user turns in the chat thread instead of only showing assistant replies. Fixes #75155. Thanks @SledderBling.
diff --git a/docs/.generated/config-baseline.sha256 b/docs/.generated/config-baseline.sha256
@@ -1,4 +1,4 @@
-c9e88800854b697cb3c9721d0087eb2bc7bcf6ae7239cb51d9849c49ef3d48e3  config-baseline.json
-67c58457ed2b525975cdb053489f92a5f840c8cf982666393e111fd327dd132e  config-baseline.core.json
+f23d3f2eb622977a46509fd3fc9a66639af574f17da3fdeae0d40a071a849860  config-baseline.json
+e19c928031beed6691e694ad77e1fd86615bfdc741f2f20f982809ac16271c88  config-baseline.core.json
 f90c9d96ccc4c0c703d6c489f86d89fde208cd7f697b396aeee96ff3ee087956  config-baseline.channel.json
 18f71e9d4a62fe68fbd5bf18d5833a4e380fc705ad641769e1cf05794286344c  config-baseline.plugin.json
diff --git a/extensions/memory-core/package.json b/extensions/memory-core/package.json
@@ -7,6 +7,7 @@
   "dependencies": {
     "chokidar": "^5.0.0",
     "json5": "^2.2.3",
+    "minimatch": "10.2.5",
     "typebox": "1.1.38"
   },
   "devDependencies": {
diff --git a/extensions/memory-core/src/memory/manager-async-state.ts b/extensions/memory-core/src/memory/manager-async-state.ts
@@ -1,16 +1,18 @@
-export function startAsyncSearchSync(params: {
+export async function awaitSearchSyncIfNeeded(params: {
   enabled: boolean;
   dirty: boolean;
   sessionsDirty: boolean;
   sync: (params: { reason: string }) => Promise<void>;
   onError: (err: unknown) => void;
-}): void {
+}): Promise<void> {
   if (!params.enabled || (!params.dirty && !params.sessionsDirty)) {
     return;
   }
-  void params.sync({ reason: "search" }).catch((err) => {
+  try {
+    await params.sync({ reason: "search" });
+  } catch (err) {
     params.onError(err);
-  });
+  }
 }
 
 export async function awaitPendingManagerWork(params: {
diff --git a/extensions/memory-core/src/memory/manager.async-search.test.ts b/extensions/memory-core/src/memory/manager.async-search.test.ts
@@ -1,18 +1,20 @@
 import { describe, expect, it, vi } from "vitest";
-import { awaitPendingManagerWork, startAsyncSearchSync } from "./manager-async-state.js";
+import { awaitPendingManagerWork, awaitSearchSyncIfNeeded } from "./manager-async-state.js";
 
 describe("memory search async sync", () => {
-  it("does not await sync when searching", async () => {
+  it("awaits sync when searching dirty indexes", async () => {
     let releaseSync = () => {};
+    let settled = false;
     const pending = new Promise<void>((resolve) => {
-      releaseSync = () => resolve();
-    });
-    const syncMock = vi.fn(async () => {
-      return pending;
+      releaseSync = () => {
+        settled = true;
+        resolve();
+      };
     });
+    const syncMock = vi.fn(async () => pending);
     const onError = vi.fn();
 
-    startAsyncSearchSync({
+    const searchSyncPromise = awaitSearchSyncIfNeeded({
       enabled: true,
       dirty: true,
       sessionsDirty: false,
@@ -21,8 +23,17 @@ describe("memory search async sync", () => {
     });
 
     expect(syncMock).toHaveBeenCalledTimes(1);
+    let finished = false;
+    void searchSyncPromise.then(() => {
+      finished = true;
+    });
+    await Promise.resolve();
+    expect(finished).toBe(false);
+    expect(settled).toBe(false);
+
     releaseSync();
-    await pending;
+    await searchSyncPromise;
+    expect(finished).toBe(true);
     expect(onError).not.toHaveBeenCalled();
   });
 
@@ -44,9 +55,9 @@ describe("memory search async sync", () => {
     await closePromise;
   });
 
-  it("skips background search sync when search-triggered sync is disabled", () => {
+  it("skips search sync when search-triggered sync is disabled", async () => {
     const syncMock = vi.fn(async () => {});
-    startAsyncSearchSync({
+    await awaitSearchSyncIfNeeded({
       enabled: false,
       dirty: true,
       sessionsDirty: false,
diff --git a/extensions/memory-core/src/memory/manager.ts b/extensions/memory-core/src/memory/manager.ts
@@ -29,7 +29,7 @@ import {
   type EmbeddingProviderRuntime,
 } from "./embeddings.js";
 import { bm25RankToScore, buildFtsQuery, mergeHybridResults } from "./hybrid.js";
-import { awaitPendingManagerWork, startAsyncSearchSync } from "./manager-async-state.js";
+import { awaitPendingManagerWork, awaitSearchSyncIfNeeded } from "./manager-async-state.js";
 import { MEMORY_BATCH_FAILURE_LIMIT } from "./manager-batch-state.js";
 import {
   closeManagedCacheEntries,
@@ -335,7 +335,7 @@ export class MemoryIndexManager extends MemoryManagerEmbeddingOps implements Mem
     }
     const cleaned = preflight.normalizedQuery;
     void this.warmSession(opts?.sessionKey);
-    startAsyncSearchSync({
+    await awaitSearchSyncIfNeeded({
       enabled: this.settings.sync.onSearch,
       dirty: this.dirty,
       sessionsDirty: this.sessionsDirty,
@@ -344,6 +344,9 @@ export class MemoryIndexManager extends MemoryManagerEmbeddingOps implements Mem
         log.warn(`memory sync failed (search): ${String(err)}`);
       },
     });
+    if (this.closed) {
+      return [];
+    }
     if (preflight.shouldInitializeProvider) {
       await this.ensureProviderInitialized();
     }
diff --git a/extensions/memory-core/src/memory/qmd-manager.test.ts b/extensions/memory-core/src/memory/qmd-manager.test.ts
@@ -434,23 +434,51 @@ describe("QmdMemoryManager", () => {
 
     const { manager } = await createManager({ mode: "full" });
     expect(watchMock).toHaveBeenCalledTimes(1);
+    const firstWatchCall = watchMock.mock.calls[0];
+    expect(firstWatchCall).toBeDefined();
+    const [watchArgs, watchOptions] = firstWatchCall as unknown as [
+      string[],
+      {
+        ignored?: (
+          watchPath: string,
+          stats: { isFile(): boolean; isDirectory(): boolean } | undefined,
+        ) => boolean;
+      },
+    ];
+    expect(watchArgs).toEqual([workspaceDir]);
+    expect(typeof watchOptions.ignored).toBe("function");
+    expect(watchOptions.ignored?.(workspaceDir, undefined)).toBe(false);
+    expect(
+      watchOptions.ignored?.(path.join(workspaceDir, ".git", "index"), {
+        isFile: () => true,
+        isDirectory: () => false,
+      }),
+    ).toBe(true);
     const watcher = watchMock.mock.results[0]?.value as {
       emit: (event: string, ...args: unknown[]) => boolean;
     };
     const initialUpdateCalls = spawnMock.mock.calls.filter((call) => call[1]?.[0] === "update");
     expect(initialUpdateCalls).toHaveLength(0);
-    const [, watchOptions] = watchMock.mock.calls[0] as unknown as [
-      string[],
-      { ignored?: (watchPath: string) => boolean },
-    ];
-    expect(watchOptions.ignored?.(path.join(workspaceDir, "node_modules", "pkg", "note.md"))).toBe(
+    expect(
+      watchOptions.ignored?.(path.join(workspaceDir, "node_modules", "pkg", "note.md"), undefined),
+    ).toBe(true);
+    expect(
+      watchOptions.ignored?.(path.join(workspaceDir, ".cache", "qmd", "note.md"), undefined),
+    ).toBe(true);
+    expect(
+      watchOptions.ignored?.(path.join(workspaceDir, "vendor", "pkg", "note.md"), undefined),
+    ).toBe(true);
+    expect(watchOptions.ignored?.(path.join(workspaceDir, "dist", "note.md"), undefined)).toBe(
       true,
     );
-    expect(watchOptions.ignored?.(path.join(workspaceDir, ".cache", "qmd", "note.md"))).toBe(true);
-    expect(watchOptions.ignored?.(path.join(workspaceDir, "vendor", "pkg", "note.md"))).toBe(true);
-    expect(watchOptions.ignored?.(path.join(workspaceDir, "dist", "note.md"))).toBe(true);
-    expect(watchOptions.ignored?.(path.join(workspaceDir, "build", "note.md"))).toBe(true);
-    expect(watchOptions.ignored?.(path.join(workspaceDir, "notes.md"))).toBe(false);
+    expect(watchOptions.ignored?.(path.join(workspaceDir, "build", "note.md"), undefined)).toBe(
+      true,
+    );
+    expect(watchOptions.ignored?.(path.join(workspaceDir, "notes.md"), undefined)).toBe(false);
+
+    watcher.emit("change", path.join(workspaceDir, "notes.txt"));
+    await vi.advanceTimersByTimeAsync(25);
+    expect(spawnMock.mock.calls.filter((call) => call[1]?.[0] === "update")).toHaveLength(0);
 
     watcher.emit("change", path.join(workspaceDir, "notes.md"));
     expect(manager.status().dirty).toBe(true);
diff --git a/extensions/memory-core/src/memory/qmd-manager.ts b/extensions/memory-core/src/memory/qmd-manager.ts
@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import chokidar, { type FSWatcher } from "chokidar";
+import { minimatch } from "minimatch";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { withFileLock } from "openclaw/plugin-sdk/file-lock";
 import {
@@ -192,14 +193,34 @@ function resolveQmdEmbedLockOptions(embedTimeoutMs: number) {
   };
 }
 
-function shouldIgnoreMemoryWatchPath(watchPath: string): boolean {
+function shouldIgnoreMemoryWatchPath(
+  watchPath: string,
+  _stats: { isFile(): boolean; isDirectory(): boolean } | undefined,
+): boolean {
   const normalized = path.normalize(watchPath);
   const parts = normalized
     .split(path.sep)
     .map((segment) => normalizeLowercaseStringOrEmpty(segment));
   return parts.some((segment) => IGNORED_MEMORY_WATCH_DIR_NAMES.has(segment));
 }
 
+function shouldHandleMemoryWatchEvent(
+  watchPath: string,
+  collections: ManagedCollection[],
+): boolean {
+  const normalized = path.normalize(watchPath);
+  return collections.some((collection) => {
+    if (collection.kind === "sessions") {
+      return false;
+    }
+    const relativePath = path.relative(path.normalize(collection.path), normalized);
+    if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+      return false;
+    }
+    return minimatch(relativePath.replaceAll("\\", "/"), collection.pattern, { dot: true });
+  });
+}
+
 type CollectionRoot = {
   path: string;
   kind: MemorySource;
@@ -1550,10 +1571,10 @@ export class QmdMemoryManager implements MemorySearchManager {
       return;
     }
     const watchPaths = new Set<string>();
-    for (const collection of this.qmd.collections) {
-      if (collection.kind === "sessions") {
-        continue;
-      }
+    const watchedCollections = this.qmd.collections.filter(
+      (collection) => collection.kind !== "sessions",
+    );
+    for (const collection of watchedCollections) {
       watchPaths.add(this.resolveCollectionWatchPath(collection));
     }
     if (watchPaths.size === 0) {
@@ -1564,13 +1585,16 @@ export class QmdMemoryManager implements MemorySearchManager {
     log.info(`qmd watcher starting for agent "${this.agentId}" paths=${watchPathList.length}`);
     this.watcher = chokidar.watch(watchPathList, {
       ignoreInitial: true,
-      ignored: (watchPath) => shouldIgnoreMemoryWatchPath(watchPath),
+      ignored: (watchPath, stats) => shouldIgnoreMemoryWatchPath(watchPath, stats),
       awaitWriteFinish: {
         stabilityThreshold: QMD_WATCH_STABILITY_MS,
         pollInterval: 100,
       },
     });
-    const markDirty = () => {
+    const markDirty = (watchPath: string) => {
+      if (!shouldHandleMemoryWatchEvent(watchPath, watchedCollections)) {
+        return;
+      }
       this.dirty = true;
       this.scheduleWatchSync();
     };
@@ -1585,7 +1609,7 @@ export class QmdMemoryManager implements MemorySearchManager {
   }
 
   private resolveCollectionWatchPath(collection: ManagedCollection): string {
-    return path.join(path.normalize(collection.path), collection.pattern);
+    return path.normalize(collection.path);
   }
 
   private scheduleWatchSync(): void {
diff --git a/extensions/memory-core/src/memory/temporal-decay.test.ts b/extensions/memory-core/src/memory/temporal-decay.test.ts
@@ -90,6 +90,64 @@ describe("temporal decay", () => {
     expect(decayed[1]?.score).toBeCloseTo(0.75);
   });
 
+  it("uses dated path decay for nested memory files", async () => {
+    const merged = await mergeVectorResultsWithTemporalDecay([
+      createVectorMemoryEntry({
+        id: "nested-old",
+        path: "memory/2025-01/2025-01-01.md",
+        snippet: "old nested",
+        vectorScore: 0.95,
+      }),
+      createVectorMemoryEntry({
+        id: "nested-new",
+        path: "memory/2026-02/2026-02-10.md",
+        snippet: "new nested",
+        vectorScore: 0.8,
+      }),
+    ]);
+
+    expect(merged[0]?.path).toBe("memory/2026-02/2026-02-10.md");
+    expect(merged[0]?.score ?? 0).toBeGreaterThan(merged[1]?.score ?? 0);
+  });
+
+  it("does not misclassify nested dated memory files as evergreen", async () => {
+    const dir = await createTempWorkspace("openclaw-temporal-decay-");
+    const nestedPath = path.join(dir, "memory", "2026-02", "2026-02-10.md");
+    await fs.mkdir(path.dirname(nestedPath), { recursive: true });
+    await fs.writeFile(nestedPath, "dated nested memory");
+
+    const veryOld = new Date(Date.UTC(2010, 0, 1));
+    await fs.utimes(nestedPath, veryOld, veryOld);
+
+    const decayed = await applyTemporalDecayToHybridResults({
+      results: [{ path: "memory/2026-02/2026-02-10.md", score: 1, source: "memory" }],
+      workspaceDir: dir,
+      temporalDecay: { enabled: true, halfLifeDays: 30 },
+      nowMs: NOW_MS,
+    });
+
+    expect(decayed[0]?.score).toBeCloseTo(1);
+  });
+
+  it("supports nested dated memory files under non-ascii or dotted directories", async () => {
+    const merged = await mergeVectorResultsWithTemporalDecay([
+      createVectorMemoryEntry({
+        id: "old-nonascii",
+        path: "memory/프로젝트.v1/2025-01-01.md",
+        snippet: "old nonascii",
+        vectorScore: 0.95,
+      }),
+      createVectorMemoryEntry({
+        id: "new-nonascii",
+        path: "memory/프로젝트.v1/2026-02-10.md",
+        snippet: "new nonascii",
+        vectorScore: 0.8,
+      }),
+    ]);
+
+    expect(merged[0]?.path).toBe("memory/프로젝트.v1/2026-02-10.md");
+  });
+
   it("applies decay in hybrid merging before ranking", async () => {
     const merged = await mergeVectorResultsWithTemporalDecay([
       createVectorMemoryEntry({
diff --git a/extensions/memory-core/src/memory/temporal-decay.ts b/extensions/memory-core/src/memory/temporal-decay.ts
@@ -12,7 +12,7 @@ export const DEFAULT_TEMPORAL_DECAY_CONFIG: TemporalDecayConfig = {
 };
 
 const DAY_MS = 24 * 60 * 60 * 1000;
-const DATED_MEMORY_PATH_RE = /(?:^|\/)memory\/(\d{4})-(\d{2})-(\d{2})\.md$/;
+const DATED_MEMORY_PATH_RE = /(?:^|\/)memory\/(?:[^/]+\/)*(\d{4})-(\d{2})-(\d{2})\.md$/;
 
 function toDecayLambda(halfLifeDays: number): number {
   if (!Number.isFinite(halfLifeDays) || halfLifeDays <= 0) {
diff --git a/extensions/memory-core/src/prompt-section.ts b/extensions/memory-core/src/prompt-section.ts
@@ -14,10 +14,10 @@ export const buildPromptSection: MemoryPromptSectionBuilder = ({
   let toolGuidance: string;
   if (hasMemorySearch && hasMemoryGet) {
     toolGuidance =
-      "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/*.md + indexed session transcripts; then use memory_get to pull only the needed lines. If low confidence after search, say you checked.";
+      "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/**/*.md + indexed session transcripts; then use memory_get to pull only the needed lines. If low confidence after search, say you checked.";
   } else if (hasMemorySearch) {
     toolGuidance =
-      "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/*.md + indexed session transcripts and answer from the matching results. If low confidence after search, say you checked.";
+      "Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/**/*.md + indexed session transcripts and answer from the matching results. If low confidence after search, say you checked.";
   } else {
     toolGuidance =
       "Before answering anything about prior work, decisions, dates, people, preferences, or todos that already point to a specific memory file or note: run memory_get to pull only the needed lines. If low confidence after reading them, say you checked.";
diff --git a/extensions/memory-core/src/tools.ts b/extensions/memory-core/src/tools.ts
@@ -237,7 +237,7 @@ export function createMemorySearchTool(options: {
     label: "Memory Search",
     name: "memory_search",
     description:
-      "Mandatory recall step: semantically search MEMORY.md + memory/*.md (and optional session transcripts) before answering questions about prior work, decisions, dates, people, preferences, or todos. Optional `corpus=wiki` or `corpus=all` also searches registered compiled-wiki supplements. `corpus=memory` restricts hits to indexed memory files (excludes session transcript chunks from ranking). `corpus=sessions` restricts hits to indexed session transcripts (same visibility rules as session history tools). If response has disabled=true, memory retrieval is unavailable and should be surfaced to the user.",
+      "Mandatory recall step: semantically search MEMORY.md + memory/**/*.md (and optional session transcripts) before answering questions about prior work, decisions, dates, people, preferences, or todos. Optional `corpus=wiki` or `corpus=all` also searches registered compiled-wiki supplements. `corpus=memory` restricts hits to indexed memory files (excludes session transcript chunks from ranking). `corpus=sessions` restricts hits to indexed session transcripts (same visibility rules as session history tools). If response has disabled=true, memory retrieval is unavailable and should be surfaced to the user.",
     parameters: MemorySearchSchema,
     execute:
       ({ cfg, agentId }) =>
@@ -401,7 +401,7 @@ export function createMemoryGetTool(options: {
     label: "Memory Get",
     name: "memory_get",
     description:
-      "Safe exact excerpt read from MEMORY.md or memory/*.md. Defaults to a bounded excerpt when lines are omitted, includes truncation/continuation info when more content exists, and `corpus=wiki` reads from registered compiled-wiki supplements.",
+      "Safe exact excerpt read from MEMORY.md or memory/**/*.md. Defaults to a bounded excerpt when lines are omitted, includes truncation/continuation info when more content exists, and `corpus=wiki` reads from registered compiled-wiki supplements.",
     parameters: MemoryGetSchema,
     execute:
       ({ cfg, agentId }) =>
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
diff --git a/src/config/schema.help.ts b/src/config/schema.help.ts
