clawmem 0.8.3 → 0.8.4

package/CLAUDE.md

@@ -206,18 +206,17 @@ systemctl --user status clawmem-watcher.service clawmem-embed.timer
 
 When using ClawMem with OpenClaw, choose one of two deployment options:
 
-### Option 1: ClawMem Exclusive (Recommended)
+**Active Memory coexistence:** ClawMem is fully compatible with OpenClaw's Active Memory plugin (v2026.4.10+). They search different backends (ClawMem vault vs dreaming/wiki) and inject into different prompt regions (user prompt vs system prompt). Both can run simultaneously — no configuration needed.
+
+**OpenClaw v2026.4.10+ recommended:** Fixes a config normalization bug where `plugins.slots.contextEngine` was silently dropped (#64192).
 
-ClawMem handles 100% of memory operations via hooks + MCP tools. Zero redundancy.
+### Option 1: ClawMem Exclusive (Recommended)
 
-**Benefits:**
-- No context window waste (avoids 10-15% duplicate injection)
-- Prevents OpenClaw native memory auto-initialization on updates
-- All memory in ClawMem's hybrid search + graph traversal system
+ClawMem handles 100% of structured memory. Disable native memory search (not Active Memory — that's separate and compatible):
 
 **Configuration:**
 ```bash
-# Disable OpenClaw's native memory
+# Disable OpenClaw's native memory search
 openclaw config set agents.defaults.memorySearch.extraPaths "[]"
 
 # Verify
@@ -235,7 +234,7 @@ ls ~/.openclaw/agents/main/memory/
 
 ### Option 2: Hybrid (ClawMem + Native)
 
-Run both ClawMem and OpenClaw's native memory for redundancy.
+Run both ClawMem and OpenClaw's native memory search for redundancy.
 
 **Configuration:**
 ```bash
@@ -243,9 +242,9 @@ openclaw config set agents.defaults.memorySearch.extraPaths '["~/documents", "~/
 ```
 
 **Tradeoffs:**
-- ✅ Redundant recall from two independent systems
-- ❌ 10-15% context window waste from duplicate facts
-- ❌ Two memory indices to maintain
+- Redundant recall from two independent systems
+- 10-15% context window waste from duplicate facts
+- Two memory indices to maintain
 
 **Recommendation:** Use Option 1 unless you have a specific need for redundant memory systems.
 

package/README.md

@@ -186,7 +186,7 @@ clawmem setup mcp      # Register MCP server in ~/.claude.json (31 tools)
 ClawMem registers as a native ContextEngine plugin - OpenClaw's pluggable interface for context management. Same 90/10 automatic retrieval, delivered through OpenClaw's lifecycle system instead of Claude Code hooks.
 
 ```bash
-clawmem setup openclaw   # Shows installation steps
+clawmem setup openclaw   # Auto-installs plugin, prints remaining steps
 ```
 
 **What the plugin provides:**
@@ -196,11 +196,15 @@ clawmem setup openclaw   # Shows installation steps
 - **5 agent tools** - `clawmem_search`, `clawmem_get`, `clawmem_session_log`, `clawmem_timeline`, `clawmem_similar`
 - **Session lifecycle hooks** - `session_start`, `session_end`, `before_reset` safety net
 
-Disable OpenClaw's native memory and `memory-lancedb` auto-recall/capture to avoid duplicate injection:
+Disable OpenClaw's native memory search to avoid duplicate injection:
 ```bash
 openclaw config set agents.defaults.memorySearch.extraPaths "[]"
 ```
 
+ClawMem coexists cleanly with OpenClaw's [Active Memory](https://docs.openclaw.ai/concepts/active-memory) plugin (v2026.4.10+) — they search different backends and inject into different prompt regions, so both can run simultaneously without conflict. See the [OpenClaw plugin guide](docs/guides/openclaw-plugin.md#coexistence-with-openclaw-active-memory) for details.
+
+> **OpenClaw v2026.4.10+** recommended — fixes a config normalization bug where `plugins.slots.contextEngine` was silently dropped (#64192).
+
 **Alternative:** OpenClaw agents can also use ClawMem's MCP server directly (`clawmem setup mcp`), with or without hooks. This gives full access to all 31 MCP tools but bypasses OpenClaw's ContextEngine lifecycle, so you lose token budget awareness, native compaction orchestration, and the `afterTurn()` message pipeline. The ContextEngine plugin is recommended for new OpenClaw setups; MCP is available as an additional or standalone integration.
 
 #### Hermes Agent

package/SKILL.md

@@ -605,12 +605,15 @@ Phase 3 deductive synthesis applies the same `contradicts` link for any draft th
 
 ## OpenClaw Integration
 
+**Active Memory coexistence:** ClawMem is fully compatible with OpenClaw's Active Memory plugin (v2026.4.10+). They search different backends and inject into different prompt regions — both can run simultaneously. The deployment options below control native memory search (`memorySearch.extraPaths`), not Active Memory.
+
+**OpenClaw v2026.4.10+ recommended** — fixes contextEngine slot being silently dropped during config normalization (#64192).
+
 ### Option 1: ClawMem Exclusive (Recommended)
 
-ClawMem handles 100% of memory. No redundancy.
+ClawMem handles 100% of structured memory. Disable native memory search:
 
 ```bash
-# Disable OpenClaw's native memory
 openclaw config set agents.defaults.memorySearch.extraPaths "[]"
 ```
 
@@ -618,7 +621,7 @@ openclaw config set agents.defaults.memorySearch.extraPaths "[]"
 
 ### Option 2: Hybrid
 
-Run both ClawMem and OpenClaw native memory.
+Run both ClawMem and OpenClaw native memory search.
 
 ```bash
 openclaw config set agents.defaults.memorySearch.extraPaths '["~/documents", "~/notes"]'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmem",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "On-device context engine and memory for AI agents. Claude Code and OpenClaw. Hooks + MCP server + hybrid RAG search.",
   "type": "module",
   "bin": {

package/src/clawmem.ts

@@ -1300,43 +1300,115 @@ function cmdPath() {
 
 async function cmdSetupOpenClaw(args: string[]) {
   const remove = args.includes("--remove");
-  const binPath = findClawmemBinary();
   const pluginDir = pathResolve(import.meta.dir, "openclaw");
+  const extensionsDir = pathResolve(process.env.HOME || "~", ".openclaw", "extensions");
+  const linkPath = pathResolve(extensionsDir, "clawmem");
+
+  // Check if openclaw CLI is available
+  const hasOpenClawCli = (() => {
+    try {
+      const r = Bun.spawnSync(["openclaw", "--version"], { stdout: "pipe", stderr: "pipe" });
+      return r.exitCode === 0;
+    } catch { return false; }
+  })();
 
   if (remove) {
-    console.log(`${c.green}To remove ClawMem from OpenClaw:${c.reset}`);
-    console.log(`  1. Remove the symlink: rm ~/.openclaw/extensions/clawmem`);
-    console.log(`  2. Remove from config: openclaw config set plugins.slots.contextEngine legacy`);
+    // Actually uninstall — mirror of install behavior
+    let removed = false;
+    try {
+      const stat = await import("fs").then(m => m.lstatSync(linkPath));
+      if (stat.isSymbolicLink() || stat.isDirectory()) {
+        const { unlinkSync, rmSync } = await import("fs");
+        if (stat.isSymbolicLink()) {
+          unlinkSync(linkPath);
+        } else {
+          rmSync(linkPath, { recursive: true });
+        }
+        console.log(`${c.green}Removed plugin from ${linkPath}${c.reset}`);
+        removed = true;
+      }
+    } catch (e: any) {
+      if (e.code !== "ENOENT") throw e;
+      console.log(`${c.dim}Plugin not installed at ${linkPath}${c.reset}`);
+    }
+
+    if (hasOpenClawCli) {
+      Bun.spawnSync(["openclaw", "config", "set", "plugins.slots.contextEngine", "legacy"], { stdout: "inherit", stderr: "inherit" });
+      console.log(`${c.green}Reset context engine slot to legacy${c.reset}`);
+    } else if (removed) {
+      console.log(`${c.dim}openclaw CLI not found — manually run: openclaw config set plugins.slots.contextEngine legacy${c.reset}`);
+    }
     return;
   }
 
-  // Check that the OpenClaw plugin files exist
+  // Verify plugin source files exist
   if (!existsSync(pathResolve(pluginDir, "index.ts"))) {
     die(`OpenClaw plugin files not found at ${pluginDir}`);
   }
+  if (!existsSync(pathResolve(pluginDir, "openclaw.plugin.json"))) {
+    die(`Plugin manifest not found at ${pluginDir}/openclaw.plugin.json`);
+  }
 
-  console.log(`${c.green}ClawMem OpenClaw Plugin Setup${c.reset}`);
-  console.log();
-  console.log(`Plugin source: ${pluginDir}`);
-  console.log(`ClawMem binary: ${binPath}`);
+  // Create extensions directory
+  if (!existsSync(extensionsDir)) {
+    mkdirSync(extensionsDir, { recursive: true });
+  }
+
+  // Remove stale symlink/directory if present
+  try {
+    const { lstatSync, unlinkSync, rmSync } = await import("fs");
+    const stat = lstatSync(linkPath);
+    if (stat.isSymbolicLink()) {
+      const { readlinkSync } = await import("fs");
+      const target = readlinkSync(linkPath);
+      if (target === pluginDir) {
+        console.log(`${c.dim}Symlink already correct at ${linkPath}${c.reset}`);
+      } else {
+        unlinkSync(linkPath);
+        console.log(`${c.dim}Replaced stale symlink (was → ${target})${c.reset}`);
+      }
+    } else if (stat.isDirectory()) {
+      rmSync(linkPath, { recursive: true });
+      console.log(`${c.dim}Replaced existing directory at ${linkPath}${c.reset}`);
+    } else {
+      // Regular file or other non-symlink, non-directory — conflict
+      die(`${linkPath} exists but is not a symlink or directory. Remove it manually and re-run setup.`);
+    }
+  } catch (e: any) {
+    if (e.code !== "ENOENT") throw e;
+  }
+
+  // Create symlink
+  if (!existsSync(linkPath)) {
+    const { symlinkSync } = await import("fs");
+    symlinkSync(pluginDir, linkPath);
+  }
+  console.log(`${c.green}Installed plugin: ${linkPath} → ${pluginDir}${c.reset}`);
+
+  // Version warning
   console.log();
-  console.log(`${c.bold}Installation steps:${c.reset}`);
+  console.log(`${c.bold}Note:${c.reset} OpenClaw v2026.4.10+ recommended — earlier versions`);
+  console.log(`have a bug where plugins.slots.contextEngine is silently dropped`);
+  console.log(`during config normalization (openclaw/openclaw#64192).`);
+
+  // Remaining steps — gateway must restart BEFORE setting the context engine slot,
+  // otherwise OpenClaw hasn't discovered the plugin yet and the slot assignment
+  // fails or is ignored (the exact bug reported in issue #5).
   console.log();
-  console.log(`  1. Symlink the plugin into OpenClaw extensions:`);
-  console.log(`     ${c.cyan}ln -s ${pluginDir} ~/.openclaw/extensions/clawmem${c.reset}`);
+  console.log(`${c.bold}Next steps:${c.reset}`);
   console.log();
-  console.log(`  2. Copy the plugin manifest:`);
-  console.log(`     ${c.cyan}cp ${pluginDir}/plugin.json ~/.openclaw/extensions/clawmem/openclaw.plugin.json${c.reset}`);
+  console.log(`  1. Restart OpenClaw gateway to discover the plugin:`);
+  console.log(`     ${c.cyan}openclaw gateway restart${c.reset}`);
   console.log();
-  console.log(`  3. Set ClawMem as the active context engine:`);
+  console.log(`  2. Set ClawMem as the active context engine (after restart):`);
   console.log(`     ${c.cyan}openclaw config set plugins.slots.contextEngine clawmem${c.reset}`);
   console.log();
-  console.log(`  4. Configure GPU endpoints (if not using defaults):`);
+  console.log(`  3. Configure GPU endpoints (if not using defaults):`);
   console.log(`     ${c.cyan}openclaw config set plugins.entries.clawmem.config.gpuEmbed http://YOUR_GPU:8088${c.reset}`);
   console.log(`     ${c.cyan}openclaw config set plugins.entries.clawmem.config.gpuLlm http://YOUR_GPU:8089${c.reset}`);
   console.log(`     ${c.cyan}openclaw config set plugins.entries.clawmem.config.gpuRerank http://YOUR_GPU:8090${c.reset}`);
   console.log();
-  console.log(`  5. Start the REST API (for tool calls):`);
+  console.log(`  4. Start the REST API (for agent tools):`);
   console.log(`     ${c.cyan}clawmem serve &${c.reset}`);
   console.log();
   console.log(`${c.dim}ClawMem will work alongside Claude Code hooks — both modes share the same vault.${c.reset}`);