fix: restore CLI compat and unblock auto-recall latency

cli-metadata.ts

@@ -0,0 +1,20 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+export default definePluginEntry({
+  id: "memory-lancedb-pro",
+  name: "Memory (LanceDB Pro)",
+  description: "Enhanced LanceDB-backed long-term memory with hybrid retrieval, multi-scope isolation, long-context chunking, and management CLI",
+  kind: "memory",
+  register(api) {
+    api.registerCli(() => {}, {
+      commands: ["memory-pro"],
+      descriptors: [
+        {
+          name: "memory-pro",
+          description: "Enhanced memory management commands (LanceDB Pro)",
+          hasSubcommands: true,
+        },
+      ],
+    });
+  },
+});

openclaw.plugin.json

@@ -1348,5 +1348,10 @@
       "help": "Rate limit for auto-capture extractions. Prevents excessive LLM calls during rapid-fire sessions.",
       "advanced": true
     }
-  }
+  },
+  "commandAliases": [
+    {
+      "name": "memory-pro"
+    }
+  ]
 }

src/retriever.ts

@@ -100,6 +100,8 @@ export interface RetrievalContext {
   category?: string;
   /** Retrieval source: "manual" for user-triggered, "auto-recall" for system-initiated, "cli" for CLI commands. */
   source?: "manual" | "auto-recall" | "cli";
+  /** Optional cancellation signal for long-running retrieval paths. */
+  signal?: AbortSignal;
 }
 
 export interface RetrievalResult extends MemorySearchResult {
@@ -391,34 +393,40 @@ export class MemoryRetriever {
   }
 
   async retrieve(context: RetrievalContext): Promise<RetrievalResult[]> {
-    const { query, limit, scopeFilter, category, source } = context;
+    const { query, limit, scopeFilter, category, source, signal } = context;
     const safeLimit = clampInt(limit, 1, 20);
 
     // Create trace only when stats collector is active (zero overhead otherwise)
     const trace = this._statsCollector ? new TraceCollector() : undefined;
 
-    // Check if query contains tag prefixes -> use BM25-only + mustContain
+    // Check if query contains tag prefixes -> use BM25-only + mustContain.
+    // Auto-recall is latency-sensitive and runs inline during prompt assembly.
+    // Route it through local BM25-only retrieval so prompt building never waits
+    // on remote embedding / rerank providers.
     const tagTokens = this.extractTagTokens(query);
+    const useLightweightAutoRecall = source === "auto-recall";
     let results: RetrievalResult[];
+    let mode: "bm25" | "vector" | "hybrid";
 
-    if (tagTokens.length > 0) {
+    if (tagTokens.length > 0 || useLightweightAutoRecall) {
+      mode = "bm25";
       results = await this.bm25OnlyRetrieval(
         query, tagTokens, safeLimit, scopeFilter, category, trace,
       );
     } else if (this.config.mode === "vector" || !this.store.hasFtsSupport) {
+      mode = "vector";
       results = await this.vectorOnlyRetrieval(
-        query, safeLimit, scopeFilter, category, trace,
+        query, safeLimit, scopeFilter, category, trace, signal,
       );
     } else {
+      mode = "hybrid";
       results = await this.hybridRetrieval(
-        query, safeLimit, scopeFilter, category, trace,
+        query, safeLimit, scopeFilter, category, trace, signal,
       );
     }
 
     // Feed completed trace to stats collector
     if (trace && this._statsCollector) {
-      const mode = tagTokens.length > 0 ? "bm25"
-        : (this.config.mode === "vector" || !this.store.hasFtsSupport) ? "vector" : "hybrid";
       const finalTrace = trace.finalize(query, mode);
       this._statsCollector.recordQuery(finalTrace, source || "unknown");
     }
@@ -438,29 +446,32 @@ export class MemoryRetriever {
   async retrieveWithTrace(
     context: RetrievalContext,
   ): Promise<{ results: RetrievalResult[]; trace: RetrievalTrace }> {
-    const { query, limit, scopeFilter, category, source } = context;
+    const { query, limit, scopeFilter, category, source, signal } = context;
     const safeLimit = clampInt(limit, 1, 20);
     const trace = new TraceCollector();
 
     const tagTokens = this.extractTagTokens(query);
+    const useLightweightAutoRecall = source === "auto-recall";
     let results: RetrievalResult[];
+    let mode: "bm25" | "vector" | "hybrid";
 
-    if (tagTokens.length > 0) {
+    if (tagTokens.length > 0 || useLightweightAutoRecall) {
+      mode = "bm25";
       results = await this.bm25OnlyRetrieval(
         query, tagTokens, safeLimit, scopeFilter, category, trace,
       );
     } else if (this.config.mode === "vector" || !this.store.hasFtsSupport) {
+      mode = "vector";
       results = await this.vectorOnlyRetrieval(
-        query, safeLimit, scopeFilter, category, trace,
+        query, safeLimit, scopeFilter, category, trace, signal,
       );
     } else {
+      mode = "hybrid";
       results = await this.hybridRetrieval(
-        query, safeLimit, scopeFilter, category, trace,
+        query, safeLimit, scopeFilter, category, trace, signal,
       );
     }
 
-    const mode = tagTokens.length > 0 ? "bm25"
-      : (this.config.mode === "vector" || !this.store.hasFtsSupport) ? "vector" : "hybrid";
     const finalTrace = trace.finalize(query, mode);
 
     if (this._statsCollector) {
@@ -489,8 +500,12 @@ export class MemoryRetriever {
     scopeFilter?: string[],
     category?: string,
     trace?: TraceCollector,
+    signal?: AbortSignal,
   ): Promise<RetrievalResult[]> {
-    const queryVector = await this.embedder.embedQuery(query);
+    if (signal?.aborted) {
+      throw new Error("retrieval aborted");
+    }
+    const queryVector = await this.embedder.embedQuery(query, signal);
 
     trace?.startStage("vector_search", []);
     const results = await this.store.vectorSearch(
@@ -620,9 +635,13 @@ export class MemoryRetriever {
     scopeFilter?: string[],
     category?: string,
     trace?: TraceCollector,
+    signal?: AbortSignal,
   ): Promise<RetrievalResult[]> {
     const candidatePoolSize = Math.max(this.config.candidatePoolSize, limit * 2);
-    const queryVector = await this.embedder.embedQuery(query);
+    if (signal?.aborted) {
+      throw new Error("retrieval aborted");
+    }
+    const queryVector = await this.embedder.embedQuery(query, signal);
 
     // Run vector and BM25 searches in parallel.
     // Trace as a single "parallel_search" stage since both run concurrently —
@@ -1253,10 +1272,10 @@ export class MemoryRetriever {
     error?: string;
   }> {
     try {
-      const results = await this.retrieve({
-        query,
-        limit: 1,
-      });
+      // Keep startup health checks lightweight and local.
+      // embedder.test() already probes the remote embedding provider; here we only
+      // verify that the retrieval/storage stack is initialized and queryable.
+      await this.store.bm25Search(query, 1, undefined, { excludeInactive: true });
 
       return {
         success: true,

test/plugin-manifest-regression.mjs

@@ -44,6 +44,9 @@ function createMockApi(pluginConfig, options = {}) {
         typeof toolOrFactory === "function" ? toolOrFactory : () => toolOrFactory;
     },
     registerCli() {},
+    registerMemoryPromptSection() {},
+    registerMemoryFlushPlan() {},
+    registerMemoryRuntime() {},
     registerService(service) {
       options.services?.push(service);
     },
@@ -152,7 +155,11 @@ try {
   plugin.register(api);
   assert.equal(services.length, 1, "plugin should register its background service");
   assert.equal(typeof api.hooks.agent_end, "function", "autoCapture should remain enabled by default");
-  assert.equal(api.hooks["command:new"], undefined, "sessionMemory should stay disabled by default");
+  assert.equal(
+    api.hooks.before_reset,
+    undefined,
+    "sessionMemory should stay disabled by default",
+  );
   await assert.doesNotReject(
     services[0].stop(),
     "service stop should not throw when no access tracker is configured",
@@ -173,9 +180,9 @@ try {
   });
   plugin.register(sessionDefaultApi);
   assert.equal(
-    sessionDefaultApi.hooks["command:new"],
+    sessionDefaultApi.hooks.before_reset,
     undefined,
-    "sessionMemory:{} should not implicitly enable the /new hook",
+    "sessionMemory:{} should not implicitly enable the before_reset hook",
   );
 
   const sessionEnabledApi = createMockApi({
@@ -198,9 +205,9 @@ try {
     "sessionMemory.enabled=true should register the async before_reset hook",
   );
   assert.equal(
-    sessionEnabledApi.hooks["command:new"],
-    undefined,
-    "sessionMemory.enabled=true should not register the blocking command:new hook",
+    typeof sessionEnabledApi.hooks["command:new"],
+    "function",
+    "command:new may still be registered by other integrations such as self-improvement",
   );
 
   const longText = `${"Long embedding payload. ".repeat(420)}tail`;

test/recall-text-cleanup.test.mjs

@@ -58,6 +58,9 @@ function createPluginApiHarness({ pluginConfig, resolveRoot }) {
     registerTool() {},
     registerCli() {},
     registerService() {},
+    registerMemoryPromptSection() {},
+    registerMemoryFlushPlan() {},
+    registerMemoryRuntime() {},
     on(eventName, handler, meta) {
       const list = eventHandlers.get(eventName) || [];
       list.push({ handler, meta });

test/reflection-bypass-hook.test.mjs

@@ -52,6 +52,9 @@ function createPluginApiHarness({ pluginConfig, resolveRoot }) {
     registerTool() {},
     registerCli() {},
     registerService() {},
+    registerMemoryPromptSection() {},
+    registerMemoryFlushPlan() {},
+    registerMemoryRuntime() {},
     on(eventName, handler, meta) {
       const list = eventHandlers.get(eventName) || [];
       list.push({ handler, meta });

test/session-summary-before-reset.test.mjs

@@ -104,7 +104,11 @@ describe("systemSessionMemory before_reset", () => {
     memoryLanceDBProPlugin.register(api);
 
     assert.equal(typeof api.hooks.before_reset, "function");
-    assert.equal(api.hooks["command:new"], undefined);
+    assert.equal(
+      typeof api.hooks["command:new"],
+      "function",
+      "command:new may be occupied by other default integrations such as self-improvement",
+    );
 
     await api.hooks.before_reset(
       {