fix(openclaw-agent-memory): wire memory-host hooks for auto-recall (#279)

Closes #279. The plugin registered seven OB1 tools but did not
participate in the OpenClaw memory-host lifecycle, so agents only
hit OB1 if they remembered to. As a result, recall-before / writeback-
after happened only when the prompt or skill explicitly nudged it.

Adds two additive memory hooks inside register(api):

  * registerMemoryPromptSupplement — auto-injects an OB1 discipline
    block into the system prompt every turn (recall-before /
    writeback-after, instruction-vs-evidence semantics, and the list
    of tools currently exposed to the agent).
  * registerMemoryCorpusSupplement — exposes OB1 as a searchable
    corpus so OpenClaw's native recall flow queries OB1 alongside
    whatever other corpora are active. Maps recall responses onto
    MemoryCorpusSearchResult and inspects single memories via
    MemoryCorpusGetResult, with provenanceLabel reflecting OB1's
    use_policy (instruction vs evidence).

Both supplements are additive (per the SDK contract) so they coexist
with the active exclusive memory plugin. Both no-op cleanly when OB1
is not configured (missing endpoint or workspaceId, missing access
key, network failure) — never throws into the host.

The hooks are called via (api as any).registerMemory* so the plugin
stays compatible with older OpenClaw releases that may not have the
methods on the typed surface yet; the typeof checks gate registration
on availability.

No new tooling, dependencies, or breaking changes. The seven existing
tools are unchanged. dist/ is intentionally not committed — maintainers
should run `npm run build` to regenerate it.

Author: MicScalise

integrations/openclaw-agent-memory/plugin/src/index.ts

@@ -158,5 +158,148 @@ export default definePluginEntry({
       parameters: Type.Object({ request_id: Type.String() }),
       run: (client, input) => client.getRecallTrace(input.request_id),
     });
+
+    // ------------------------------------------------------------------
+    // Memory-host hooks (fix for #279).
+    //
+    // The plugin registers tools above, but without participating in the
+    // OpenClaw memory-host lifecycle, agents only invoke OB1 if they
+    // remember to. We register two additive memory hooks so OB1 lands
+    // in every turn automatically:
+    //
+    //   1. registerMemoryPromptSupplement — auto-injects an OB1 discipline
+    //      block into the system prompt (recall-before / writeback-after
+    //      reminder, instruction-vs-evidence semantics, tool list).
+    //   2. registerMemoryCorpusSupplement — exposes OB1 as a searchable
+    //      corpus so OpenClaw's native recall flow queries OB1 alongside
+    //      whatever other corpora are active.
+    //
+    // Both are additive (per the SDK contract), coexist with the active
+    // exclusive memory plugin, and no-op cleanly when OB1 isn't configured.
+    // ------------------------------------------------------------------
+
+    const OB1_TOOL_NAMES = [
+      "openbrain_recall",
+      "openbrain_writeback",
+      "openbrain_report_usage",
+      "openbrain_inspect_memory",
+      "openbrain_list_review_queue",
+      "openbrain_review_memory",
+      "openbrain_get_recall_trace",
+    ] as const;
+
+    function isConfigured(): boolean {
+      const raw = ((api as any).pluginConfig || {}) as Record<string, unknown>;
+      return typeof raw.endpoint === "string"
+        && raw.endpoint.length > 0
+        && typeof raw.workspaceId === "string"
+        && raw.workspaceId.length > 0;
+    }
+
+    if (typeof (api as any).registerMemoryPromptSupplement === "function") {
+      (api as any).registerMemoryPromptSupplement((params: { availableTools: Set<string> }) => {
+        if (!isConfigured()) return [];
+        const present = OB1_TOOL_NAMES.filter((t) => params.availableTools.has(t));
+        if (present.length === 0) return [];
+        return [
+          "## OB1 Agent Memory",
+          "Long-term governed memory is available via OB1. Use it as a discipline, not a fallback.",
+          "",
+          "Workflow:",
+          "- Before meaningful work, call `openbrain_recall` with a task-scoped query.",
+          "- Treat returned memories tagged `instruction` as binding rules; `evidence`-tagged ones as supporting context only.",
+          "- After meaningful work, call `openbrain_writeback` with compact, provenance-labeled findings (decisions, lessons, constraints, outputs, failures).",
+          "- After acting on recalled memories, call `openbrain_report_usage` with `request_id` and the IDs you used vs. ignored — closes the recall-quality loop.",
+          "",
+          `Available tools: ${present.map((t) => "`" + t + "`").join(", ")}.`,
+        ];
+      });
+    }
+
+    if (typeof (api as any).registerMemoryCorpusSupplement === "function") {
+      (api as any).registerMemoryCorpusSupplement({
+        async search(input: { query: string; maxResults?: number; agentSessionKey?: string }) {
+          if (!isConfigured()) return [];
+          let client: AgentMemoryClient;
+          try {
+            client = await clientFromApi(api);
+          } catch {
+            return [];
+          }
+          const limit = Math.min(Math.max(input.maxResults ?? 10, 1), 50);
+          let response: any;
+          try {
+            response = await client.recall({
+              query: input.query.slice(0, 2000),
+              task_type: "general",
+              limits: { max_items: limit, max_tokens: 4000 },
+              scope: { project_only: false, include_unconfirmed: false, include_stale: false },
+            });
+          } catch {
+            return [];
+          }
+          const memories: any[] = Array.isArray(response?.memories) ? response.memories : [];
+          return memories.map((m, i) => {
+            const policy = m?.use_policy ?? {};
+            const provenance = policy?.can_use_as_instruction
+              ? "instruction"
+              : policy?.can_use_as_evidence
+                ? "evidence"
+                : undefined;
+            return {
+              corpus: "openbrain",
+              path: `openbrain://memory/${m?.id ?? i}`,
+              title: typeof m?.summary === "string" ? m.summary.slice(0, 80) : undefined,
+              kind: "memory",
+              score: typeof m?.score === "number" ? m.score : Math.max(0, 1 - i / Math.max(memories.length, 1)),
+              snippet: String(m?.summary ?? m?.content ?? "").slice(0, 600),
+              id: typeof m?.id === "string" ? m.id : undefined,
+              provenanceLabel: provenance,
+              source: "openbrain.agent_memory",
+              sourceType: "openbrain.agent_memory",
+              updatedAt: typeof m?.updated_at === "string" ? m.updated_at : undefined,
+            };
+          });
+        },
+        async get(input: { lookup: string }) {
+          if (!isConfigured()) return null;
+          const id = input.lookup.replace(/^openbrain:\/\/memory\//, "");
+          if (!id) return null;
+          let client: AgentMemoryClient;
+          try {
+            client = await clientFromApi(api);
+          } catch {
+            return null;
+          }
+          let memory: any;
+          try {
+            memory = await client.inspectMemory(id);
+          } catch {
+            return null;
+          }
+          if (!memory || typeof memory !== "object") return null;
+          const policy = (memory as any)?.use_policy ?? {};
+          const provenance = policy?.can_use_as_instruction
+            ? "instruction"
+            : policy?.can_use_as_evidence
+              ? "evidence"
+              : undefined;
+          const content = String((memory as any)?.content ?? (memory as any)?.summary ?? "");
+          return {
+            corpus: "openbrain",
+            path: input.lookup,
+            title: typeof (memory as any)?.summary === "string" ? (memory as any).summary.slice(0, 80) : undefined,
+            kind: "memory",
+            content,
+            fromLine: 1,
+            lineCount: content.split("\n").length,
+            id: typeof (memory as any)?.id === "string" ? (memory as any).id : id,
+            provenanceLabel: provenance,
+            sourceType: "openbrain.agent_memory",
+            updatedAt: typeof (memory as any)?.updated_at === "string" ? (memory as any).updated_at : undefined,
+          };
+        },
+      });
+    }
   },
 });