release: v2026.4.8.0449 — MemPalace Enhanced Memory

- MemPalace memory backend (ChromaDB + temporal KG via Python bridge)
- Shared bridge-call.mjs utility (eliminates code duplication)
- Memory backend abstraction (MemPalaceBackend + FileBackend + factory)
- Migration script (idempotent, dry-run, wing isolation)
- Obsidian vault export (frontmatter, wikilinks, MOCs, timeline)
- Search hook (unified MemPalace + OpenClaw search, graceful degradation)
- CLI bridge with backend selection
- setup.mjs Stage 6 (MemPalace detection)
- diagnose.sh A12 (MemPalace health check)
- 28/28 automated tests, 0 PII findings
- SKILL.md Section 23, CHANGELOG, README updated

Author: profbernardoj

CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to EverClaw are documented here.
 
+## [2026.4.8] - 2026-04-08 — MemPalace Enhanced Memory
+
+### Added
+- **MemPalace memory backend** — Optional upgrade layering ChromaDB vector search + temporal knowledge graph on top of OpenClaw's built-in `memory_search`. Dual embedding models (embeddinggemma-300m-qat 300M + all-MiniLM-L6-v2 22M) catch different semantic matches.
+- **Python bridge** (`scripts/python/mempalace_bridge.py`) — JSON contract between Node.js and MemPalace SDK v3.0.0 via spawn(). Supports search, mine, wake-up, status, init, as-of, and export commands. Full stdout suppression preserves JSON contract.
+- **Shared bridge utility** (`scripts/lib/bridge-call.mjs`) — Single source of truth for Python bridge communication. Configurable `rejectOnError` for strict vs graceful degradation modes.
+- **Memory backend abstraction** (`scripts/lib/memory-backend.mjs`) — Factory pattern with `MemPalaceBackend` and `FileBackend`. Async dynamic imports, graceful fallback.
+- **FileBackend** (`scripts/lib/file-backend.mjs`) — Grep-based search over memory/*.md files. Read-only fallback when MemPalace is not installed.
+- **MemPalaceBackend** (`scripts/lib/mempalace-backend.mjs`) — Full ChromaDB + temporal KG access via Python bridge.
+- **Migration script** (`scripts/memory/migrate-to-mempalace.mjs`) — One-time ingestion of existing memory files. Idempotent (content-hash IDs), supports dry-run, wing selection, category stats.
+- **Search hook** (`scripts/memory/mempalace-search-hook.mjs`) — Unified search API combining MemPalace results with OpenClaw built-in search. Graceful degradation when MemPalace unavailable.
+- **Obsidian vault export** (`scripts/memory/export-obsidian-vault.mjs`) — Exports palace as Obsidian-compatible vault with YAML frontmatter, wikilinks, MOCs, timeline pages. 3,245 drawers → 3,302 files in ~3s.
+- **CLI bridge** (`scripts/memory/mempalace-bridge.mjs`) — Full CLI for all memory operations with backend selection.
+- **Config template** (`templates/everclaw-config-memory.json`) — Memory backend configuration with MemPalace and FileBackend options.
+- **Setup Stage 6** — `setup.mjs` now detects MemPalace SDK, checks palace existence, and verifies bridge health.
+- **Diagnose A12** — `diagnose.sh` checks MemPalace installation and palace status.
+- **Test suite** — 28 automated tests across `tests/memory-backend.mjs` (19) and `tests/mempalace-bridge.mjs` (9). Covers FileBackend, MemPalaceBackend, factory, error handling, edge cases.
+- **SKILL.md Section 23** — Full documentation of MemPalace integration, architecture, CLI usage, and configuration.
+
+### Changed
+- **`package.json`** — Added `test:memory` script.
+
+### Security
+- All new files pass PII scan (0 findings). MemPalace vaults stored locally in `~/.mempalace/`. Export includes privacy warning.
+
+### Technical Notes
+- Requires: `pip install mempalace` (optional — EverClaw works without it)
+- First mine downloads 79MB embedding model (all-MiniLM-L6-v2)
+- Bridge timeout: 300s default (mining can be slow on first run)
+- Idempotent migration: ChromaDB content-hash IDs prevent duplicates on re-run
+- Wings provide data isolation (tested: 0 cross-contamination)
+
 ## [2026.4.7.1833] - 2026-04-07 — Ollama Input Modalities Fix
 
 ### Fixed

Dockerfile

@@ -170,7 +170,7 @@ RUN FDIR="/home/node/.openclaw/workspace/skills/everclaw/templates/flavors/${FLA
 
 # ─── Environment ──────────────────────────────────────────────────────────────
 
-ARG EVERCLAW_VERSION=2026.4.7.1918
+ARG EVERCLAW_VERSION=2026.4.8.0449
 ENV EVERCLAW_VERSION=${EVERCLAW_VERSION}
 ENV NODE_ENV=production
 ENV EVERCLAW_PROXY_PORT=8083

README.md

@@ -235,6 +235,17 @@ The proxy handles all the blockchain complexity: opening sessions, renewing befo
 
 **Benefit:** Your agent handles MOR tokens and private keys safely. The same security patterns used by professional custody solutions, adapted for AI agents.
 
+### 🧠 MemPalace — Enhanced Memory (Optional)
+| Component | What It Does |
+|-----------|-------------|
+| **ChromaDB Vector Search** | Semantic search across all memory files using all-MiniLM-L6-v2 embeddings |
+| **Temporal Knowledge Graph** | Query entity relationships at specific points in time ("What did we know about X on date Y?") |
+| **Obsidian Vault Export** | Export palace as browsable vault with frontmatter, wikilinks, MOCs, and timeline pages |
+| **Dual Embedding Models** | Complements OpenClaw's built-in embeddinggemma-300m-qat — different models catch different semantic matches |
+| **Migration Tool** | Idempotent one-time import of existing memory/*.md files into MemPalace |
+
+**Benefit:** Your agent gets deeper memory recall across thousands of files. Two embedding models (300M + 22M params) searching independently means better coverage. The Obsidian export lets you browse and graph-visualize your agent's entire knowledge base. Requires `pip install mempalace` — EverClaw works without it.
+
 ---
 
 ## Available Models
@@ -316,6 +327,7 @@ When a session ends, your MOR comes back. Open a new session with the same token
 - **macOS or Linux** — macOS Keychain or libsecret for native key storage; encrypted file fallback works everywhere
 - **age, zstd, jq** — for backup/restore features (auto-installed by `install.sh`)
 - **node-llama-cpp** — for local memory search embeddings (auto-installed by `setup.mjs` and `install.sh`)
+- **mempalace** (optional) — `pip install mempalace` for enhanced ChromaDB + temporal KG memory. Not required — EverClaw works without it.
 
 That's it. No external accounts. No API keys. No subscriptions.
 

SKILL.md

@@ -2634,8 +2634,127 @@ When the restored agent boots and detects a migration note in today's daily memo
 
 ---
 
+## 23. Enhanced Memory with MemPalace (v2026.4.8)
+
+Optional upgrade to EverClaw's memory backend using [MemPalace](https://github.com/AiEnigma-Labs/MemPalace) — a local-first memory system with ChromaDB vector search, temporal knowledge graph, and hierarchical organization (wings/rooms/drawers).
+
+### Why MemPalace?
+
+- **Dual embedding models**: OpenClaw's built-in `memory_search` uses embeddinggemma-300m-qat (300M); MemPalace uses all-MiniLM-L6-v2 (22M). Different models catch different semantic matches.
+- **Temporal awareness**: Query what was known about an entity at a specific date (`as-of` queries).
+- **Wing/room hierarchy**: Organize memories by project, topic, or time period.
+- **Obsidian export**: Browse your agent's memory as a full Obsidian vault with wikilinks and frontmatter.
+- **Zero external APIs**: Everything runs locally. No data leaves the machine.
+
+### Install
+
+```bash
+pip install mempalace
+```
+
+### Migration (one-time import of existing memory files)
+
+```bash
+# Preview what will be imported
+node scripts/memory/migrate-to-mempalace.mjs --dry-run
+
+# Run the migration
+node scripts/memory/migrate-to-mempalace.mjs --wing agent
+```
+
+### Search (CLI)
+
+```bash
+# Search memories
+node scripts/memory/mempalace-search-hook.mjs search "wallet encryption" --wing everclaw
+
+# Get status
+node scripts/memory/mempalace-search-hook.mjs status
+
+# Wake-up context (identity + essential story)
+node scripts/memory/mempalace-search-hook.mjs wake-up
+```
+
+### Search (Module API)
+
+```javascript
+import { enhancedSearch, getStatus, getWakeUpContext, queryAsOf } from './scripts/memory/mempalace-search-hook.mjs';
+
+const results = await enhancedSearch('wallet encryption', { wing: 'everclaw', maxResults: 10 });
+const status = await getStatus();
+const context = await getWakeUpContext({ wing: 'agent' });
+const history = await queryAsOf('EverClaw', '2026-04-01');
+```
+
+### Obsidian Vault Export
+
+```bash
+# Preview
+node scripts/memory/export-obsidian-vault.mjs --wing everclaw --dry-run
+
+# Export
+node scripts/memory/export-obsidian-vault.mjs --wing everclaw --clean
+```
+
+Output: `~/Documents/EverClaw-Vault/` — open directly in Obsidian.
+
+Vault structure:
+```
+EverClaw-Vault/
+├── index.md           # Global Map of Content
+├── wings/<wing>/      # Wing MOC + rooms
+│   └── rooms/<room>/  # Room MOC + drawer files
+├── concepts/          # Entity pages (KG, Phase 2)
+└── timeline/          # Dated memory pages
+```
+
+### Architecture
+
+```
+OpenClaw memory_search ──→ MEMORY.md + memory/*.md (embeddinggemma-300m-qat)
+                          ↕ complementary
+MemPalace bridge ────────→ ChromaDB + temporal KG (all-MiniLM-L6-v2)
+                          ↕
+     mempalace_bridge.py ← Python subprocess, JSON contract on stdout
+     mempalace-bridge.mjs ← Node.js wrapper, spawns Python
+```
+
+### Tests
+
+```bash
+npm run test:memory   # 28 tests: backend, factory, bridge, regression
+```
+
+### Privacy
+
+MemPalace stores data locally in `~/.mempalace/`. Exported vaults may contain PII — consider encrypting the folder or using Obsidian's encryption plugin.
+
+### Files
+
+| File | Purpose |
+|------|---------|
+| `scripts/python/mempalace_bridge.py` | Python bridge (MemPalace SDK ↔ JSON) |
+| `scripts/memory/mempalace-bridge.mjs` | Node.js bridge wrapper |
+| `scripts/memory/mempalace-search-hook.mjs` | Unified search API |
+| `scripts/memory/migrate-to-mempalace.mjs` | One-time migration script |
+| `scripts/memory/export-obsidian-vault.mjs` | Obsidian vault exporter |
+| `scripts/lib/memory-backend.mjs` | Backend abstraction + factory |
+| `scripts/lib/file-backend.mjs` | FileBackend (legacy fallback) |
+| `scripts/lib/mempalace-backend.mjs` | MemPalaceBackend |
+| `templates/everclaw-config-memory.json` | Memory config template |
+| `tests/memory-backend.mjs` | Backend tests (19 tests) |
+| `tests/mempalace-bridge.mjs` | Bridge tests (9 tests) |
+
+---
+
 ## Changelog
 
+### 2026.4.8
+- **MemPalace Enhanced Memory** — ChromaDB vector search + temporal KG + Obsidian export
+- 10 new files, 28 new tests
+- setup.mjs Stage 6: MemPalace detection + bridge health check
+- diagnose.sh A12: MemPalace SDK + palace status check
+
 ### 2026.4.2
 - **Agent Download** — Say "download my agent" in chat to get a one-click encrypted backup with a temporary download link
   - `agent-download-server.mjs` — Single-use token HTTP server with 15-minute auto-shutdown, CORS, secure shred

docker-compose.yml

@@ -13,7 +13,7 @@
 
 services:
   everclaw:
-    image: ghcr.io/everclaw/everclaw:2026.4.7.1918
+    image: ghcr.io/everclaw/everclaw:2026.4.8.0449
     build:
       context: .
       dockerfile: Dockerfile

package.json

@@ -1,6 +1,6 @@
 {
   "name": "everclaw",
-  "version": "2026.4.7.1918",
+  "version": "2026.4.8.0449",
   "type": "module",
   "description": "Open-source first AI inference via Morpheus decentralized network",
   "scripts": {
@@ -10,6 +10,7 @@
     "test:docker": "node --test tests/lib-docker.mjs",
     "test:keychain": "node --test tests/lib-keychain.mjs",
     "test:manifest": "node --test tests/lib-manifest.mjs",
+    "test:memory": "node --test tests/memory-backend.mjs tests/mempalace-bridge.mjs",
     "bootstrap": "node scripts/bootstrap-gateway.mjs"
   },
   "keywords": [

scripts/diagnose.sh

@@ -328,6 +328,23 @@ print(count)
       pass "All model input modalities valid (text/image only)"
     fi
   fi
+
+  # A12: Is MemPalace installed for enhanced memory (optional)?
+  if command -v python3 &>/dev/null; then
+    if python3 -c "import mempalace" 2>/dev/null; then
+      pass "MemPalace SDK installed (enhanced memory available)"
+      local palace_path="$HOME/.mempalace/palace"
+      if [[ -d "$palace_path" ]]; then
+        pass "MemPalace palace exists at $palace_path"
+      else
+        warn "MemPalace palace not found — run migration to initialize"
+        fix "node scripts/memory/migrate-to-mempalace.mjs --dry-run"
+      fi
+    else
+      info "MemPalace not installed (optional enhancement for memory search)"
+      fix "Install: pip install mempalace"
+    fi
+  fi
 }
 
 # ═════════════════════════════════════════════════════════════════════════════

scripts/lib/bridge-call.mjs

@@ -0,0 +1,80 @@
+/**
+ * bridge-call.mjs — Shared Python bridge communication utility
+ *
+ * Single source of truth for calling mempalace_bridge.py via spawn().
+ * Used by both MemPalaceBackend and mempalace-search-hook.
+ *
+ * @module bridge-call
+ */
+
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_BRIDGE_PATH = join(__dirname, '..', 'python', 'mempalace_bridge.py');
+
+/**
+ * Call the Python bridge and return parsed JSON.
+ *
+ * @param {string[]} args - Arguments for mempalace_bridge.py
+ * @param {Object} [options]
+ * @param {number} [options.timeout=60000] - Timeout in ms
+ * @param {string} [options.bridgePath] - Override bridge script path
+ * @param {string} [options.pythonPath='python3'] - Python binary
+ * @param {boolean} [options.rejectOnError=true] - If false, resolve with error object instead of rejecting
+ * @returns {Promise<Object>} Parsed JSON result
+ */
+export function callPythonBridge(args, options = {}) {
+  const {
+    timeout = 60_000,
+    bridgePath = DEFAULT_BRIDGE_PATH,
+    pythonPath = 'python3',
+    rejectOnError = true,
+  } = options;
+
+  return new Promise((resolve, reject) => {
+    const proc = spawn(pythonPath, [bridgePath, ...args], {
+      env: { ...process.env, PYTHONIOENCODING: 'utf-8' },
+      timeout,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+
+    proc.on('close', (code) => {
+      try {
+        const result = JSON.parse(stdout.trim());
+
+        if (!result.success && rejectOnError) {
+          const err = new Error(result.error || 'MemPalace bridge error');
+          err.hint = result.hint;
+          reject(err);
+          return;
+        }
+
+        resolve(result);
+      } catch {
+        const errorMsg = `MemPalace bridge failed (exit ${code}): ${stderr || stdout || 'no output'}`;
+        if (rejectOnError) {
+          reject(new Error(errorMsg));
+        } else {
+          resolve({ success: false, error: errorMsg });
+        }
+      }
+    });
+
+    proc.on('error', (err) => {
+      const errorMsg = `Failed to spawn Python bridge: ${err.message}`;
+      if (rejectOnError) {
+        reject(new Error(errorMsg));
+      } else {
+        resolve({ success: false, error: errorMsg });
+      }
+    });
+  });
+}