Fix #1514: Auto-recall hardcodes maxResults: 10, ignoring recall.maxResultsDefault config

apps/memos-local-openclaw/README.md

@@ -514,6 +514,7 @@ All optional — shown with defaults:
     "recall": {
       "maxResultsDefault": 6,     // Default search results
       "maxResultsMax": 20,        // Max search results
+      "autoRecallMaxResults": 6,  // Optional: override max results for the auto-recall hook only. Defaults to `maxResultsDefault`. Set lower (e.g. 3 or 5) to reduce auto-injected tokens while keeping `memory_search` results richer.
       "minScoreDefault": 0.45,    // Default min score threshold
       "minScoreFloor": 0.35,      // Lowest allowed min score
       "rrfK": 60,                 // RRF fusion constant

apps/memos-local-openclaw/index.ts

@@ -1889,9 +1889,20 @@ Groups: ${groupNames.length > 0 ? groupNames.join(", ") : "(none)"}`,
         ctx.log.debug(`auto-recall: query="${query.slice(0, 80)}"`);
 
         // ── Phase 1: Local search ∥ Hub search (parallel) ──
-        const arLocalP = engine.search({ query, maxResults: 10, minScore: 0.45, ownerFilter: recallOwnerFilter });
+        // Issue #1514: previously hardcoded maxResults: 10 here, which made
+        // `recall.maxResultsDefault` and the new `recall.autoRecallMaxResults`
+        // ineffective for the auto-recall path. Resolution order:
+        //   1. `recall.autoRecallMaxResults` (explicit auto-recall cap)
+        //   2. `recall.maxResultsDefault`    (shared default with memory_search)
+        //   3. literal 10                    (defensive — `resolveConfig`
+        //      always fills `maxResultsDefault`, so this fires only if a
+        //      caller built a context without going through `resolveConfig`).
+        const recallCfg = ctx.config.recall ?? {};
+        const autoRecallMax = recallCfg.autoRecallMaxResults ?? recallCfg.maxResultsDefault ?? 10;
+
+        const arLocalP = engine.search({ query, maxResults: autoRecallMax, minScore: 0.45, ownerFilter: recallOwnerFilter });
         const arHubP = ctx.config?.sharing?.enabled
-          ? hubSearchMemories(store, ctx, { query, maxResults: 10, scope: "all" })
+          ? hubSearchMemories(store, ctx, { query, maxResults: autoRecallMax, scope: "all" })
               .catch((err: any) => { ctx.log.debug(`auto-recall: hub search failed (${err})`); return { hits: [] as any[], meta: {} }; })
           : Promise.resolve({ hits: [] as any[], meta: {} });
 

apps/memos-local-openclaw/src/config.ts

@@ -60,6 +60,10 @@ export function resolveConfig(raw: Partial<MemosLocalConfig> | undefined, stateD
     recall: {
       maxResultsDefault: cfg.recall?.maxResultsDefault ?? DEFAULTS.maxResultsDefault,
       maxResultsMax: cfg.recall?.maxResultsMax ?? DEFAULTS.maxResultsMax,
+      // Optional override for the `before_prompt_build` auto-recall hook.
+      // Left undefined when the user does not configure it so the hook can
+      // fall through to `maxResultsDefault` at call time (issue #1514).
+      autoRecallMaxResults: cfg.recall?.autoRecallMaxResults,
       minScoreDefault: cfg.recall?.minScoreDefault ?? DEFAULTS.minScoreDefault,
       minScoreFloor: cfg.recall?.minScoreFloor ?? DEFAULTS.minScoreFloor,
       rrfK: cfg.recall?.rrfK ?? DEFAULTS.rrfK,

apps/memos-local-openclaw/src/types.ts

@@ -305,6 +305,14 @@ export interface MemosLocalConfig {
   recall?: {
     maxResultsDefault?: number;
     maxResultsMax?: number;
+    /**
+     * Override the maximum number of candidates the `before_prompt_build`
+     * auto-recall hook fetches per source (local + Hub). When undefined the
+     * hook falls back to `maxResultsDefault`. Use this to make auto-recall
+     * leaner (e.g. 3 or 5) without shrinking the result set of explicit
+     * `memory_search` tool calls. See issue #1514.
+     */
+    autoRecallMaxResults?: number;
     minScoreDefault?: number;
     minScoreFloor?: number;
     rrfK?: number;

apps/memos-local-openclaw/tests/config.test.ts

@@ -48,6 +48,46 @@ describe("resolveConfig", () => {
     });
   });
 
+  describe("recall.autoRecallMaxResults", () => {
+    it("leaves autoRecallMaxResults undefined when no recall config is provided (fall-through to maxResultsDefault)", () => {
+      const resolved = resolveConfig(undefined, "/tmp/memos-config-recall-default");
+
+      // Default policy: auto-recall path inherits maxResultsDefault when not overridden.
+      expect(resolved.recall?.maxResultsDefault).toBe(6);
+      expect(resolved.recall?.autoRecallMaxResults).toBeUndefined();
+    });
+
+    it("preserves an explicit autoRecallMaxResults value when set", () => {
+      const resolved = resolveConfig(
+        {
+          recall: {
+            maxResultsDefault: 6,
+            autoRecallMaxResults: 3,
+          },
+        } as any,
+        "/tmp/memos-config-recall-override",
+      );
+
+      expect(resolved.recall?.maxResultsDefault).toBe(6);
+      expect(resolved.recall?.autoRecallMaxResults).toBe(3);
+    });
+
+    it("allows independent control: maxResultsDefault for memory_search, autoRecallMaxResults for auto-recall", () => {
+      const resolved = resolveConfig(
+        {
+          recall: {
+            maxResultsDefault: 10,
+            autoRecallMaxResults: 5,
+          },
+        } as any,
+        "/tmp/memos-config-recall-split",
+      );
+
+      expect(resolved.recall?.maxResultsDefault).toBe(10);
+      expect(resolved.recall?.autoRecallMaxResults).toBe(5);
+    });
+  });
+
   it("preserves explicit user providers when host capabilities are enabled", () => {
     const resolved = resolveConfig(
       {