@digitalforgestudios/openclaw-sulcus 1.5.3 → 3.0.0

package/index.ts

@@ -1,6 +1,5 @@
-import { spawn, ChildProcess } from "node:child_process";
-import { createInterface } from "node:readline";
 import { resolve } from "node:path";
+import { existsSync } from "node:fs";
 import { Type } from "@sinclair/typebox";
 
 // ─── STATIC AWARENESS ───────────────────────────────────────────────────────
@@ -8,295 +7,171 @@ import { Type } from "@sinclair/typebox";
 // This is the absolute minimum the LLM needs to know Sulcus exists.
 // It fires even if build_context crashes, times out, or returns empty.
 // Build static awareness with runtime backend info
-function buildStaticAwareness(backendMode: string, namespace: string, serverUrl: string) {
+function buildStaticAwareness(backendMode: string, namespace: string) {
   return `## Persistent Memory (Sulcus)
 You have Sulcus — a persistent, reactive, thermodynamic memory system with reactive triggers.
 Memories survive across sessions. They have heat (0.0–1.0) that decays over time.
 
-**Connection:** Backend: ${backendMode} | Namespace: ${namespace} | Server: ${serverUrl}
+**Connection:** Backend: ${backendMode} | Namespace: ${namespace}
 
 **Your memory tools:**
 - \`memory_store\` — Save important information (preferences, facts, procedures, decisions, lessons)
-  Parameters: content, memory_type (episodic|semantic|preference|procedural|fact), decay_class (volatile|normal|stable|permanent), is_pinned, min_heat, key_points
+  Parameters: content, memory_type (episodic|semantic|preference|procedural|fact)
 - \`memory_recall\` — Search memories semantically. Use before answering about past work, decisions, or people.
   Parameters: query, limit
 
 **When to store:** User states a preference, important decision made, correction given, lesson learned, anything worth surviving this session.
 **When to search:** Questions about prior work/decisions, context seems incomplete, user references past conversations.
 
-**Memory types:** episodic (events, fast decay) · semantic (knowledge, slow) · preference (opinions, slower) · procedural (how-tos, slowest) · fact (data, slow)
-**Decay classes:** volatile (hours) · normal (days) · stable (weeks) · permanent (never)
-**Pinning:** is_pinned=true prevents decay. Use for critical knowledge.
-**Triggers:** Reactive rules on memory events. Active triggers and recent fires appear in your context below.`;
+**Memory types:** episodic (events, fast decay) · semantic (knowledge, slow) · preference (opinions, slower) · procedural (how-tos, slowest) · fact (data, slow)`;
 }
 
 // Legacy static string for backward compat (overwritten at register time)
-let STATIC_AWARENESS = buildStaticAwareness("unknown", "default", "unknown");
+let STATIC_AWARENESS = buildStaticAwareness("local", "default");
 
 // Fallback context when build_context fails — includes the cheatsheet
 // but warns that dynamic context is unavailable.
 const FALLBACK_AWARENESS = `<sulcus_context token_budget="500">
   <cheatsheet>
     You have Sulcus — persistent memory with reactive triggers.
-    STORE:    memory_store (content, memory_type, decay_class, is_pinned, key_points)
+    STORE:    memory_store (content, memory_type)
     FIND:     memory_recall (query, limit)
-    MANAGE:   memory_boost / memory_deprecate / memory_relate / memory_reclassify
-    PIN:      Set is_pinned=true to make a memory permanent (immune to decay).
-    TRIGGERS: create_trigger to set reactive rules on your memory graph
     TYPES:    episodic (fast fade), semantic (slow), preference, procedural (slowest), fact
     ⚠️ Context build failed this turn — use memory_recall to search manually.
     Below is your active context. Search for deeper recall. Unlimited storage.
   </cheatsheet>
 </sulcus_context>`;
 
-// Simple MCP Client for sulcus-local
-class SulcusClient {
-  private child: ChildProcess | null = null;
-  private nextId = 1;
-  private pending = new Map<string | number, (res: any) => void>();
-  private configPath: string | undefined;
+// ─── NATIVE LIB LOADER ──────────────────────────────────────────────────────
+// Loads libsulcus_store.dylib (embedded PG) and libsulcus_embed.dylib (embeddings)
+// via koffi FFI. Provides queryFn and embedFn callbacks for SulcusMem.create().
 
-  constructor(private binaryPath: string, configPath?: string) {
-    this.configPath = configPath;
-  }
-
-  // SECURITY NOTE: spawn() launches the sulcus-local binary (a Rust MCP server)
-  // as a child process for local-only operation. No user data is passed via argv
-  // or env vars — only RUST_LOG for log verbosity. This is the standard MCP sidecar
-  // pattern used by Claude Desktop, Cursor, etc. Only used when serverUrl is empty
-  // (local mode). When serverUrl is set, REST API is used instead (no spawn).
-  async start(configPath?: string) {
-    const cfgPath = configPath || this.configPath;
-    const args = cfgPath ? ["--config", cfgPath, "stdio"] : ["stdio"];
-    this.child = spawn(this.binaryPath, args, {
-      stdio: ["pipe", "pipe", "inherit"],
-      env: { ...process.env, RUST_LOG: "info" }  // Only passes log-level config, not secrets
-    });
-
-    this.child.on("error", (err) => {
-      // Reject all pending calls if the process dies
-      for (const [id, resolve] of this.pending) {
-        resolve({ error: { code: -1, message: `Sulcus process error: ${err.message}` } });
-      }
-      this.pending.clear();
-      this.child = null;
-    });
+class NativeLibLoader {
+  private koffi: any = null;
+  private storeLib: any = null;
+  private embedLib: any = null;
+  private embedHandle: any = null;
 
-    this.child.on("exit", (code) => {
-      for (const [id, resolve] of this.pending) {
-        resolve({ error: { code: -1, message: `Sulcus process exited with code ${code}` } });
-      }
-      this.pending.clear();
-      this.child = null;
-    });
+  // koffi function handles
+  private fn_store_init: any = null;
+  private fn_store_query: any = null;
+  private fn_store_free: any = null;
+  private fn_embed_create: any = null;
+  private fn_embed_text: any = null;
+  private fn_embed_free: any = null;
 
-    const rl = createInterface({ input: this.child.stdout! });
-    rl.on("line", (line) => {
-      try {
-        const msg = JSON.parse(line);
-        if (msg.id && this.pending.has(msg.id)) {
-          const resolve = this.pending.get(msg.id)!;
-          this.pending.delete(msg.id);
-          resolve(msg);
-        }
-      } catch (e) {}
-    });
-  }
+  public loaded = false;
+  public error: string | null = null;
 
-  async call(method: string, params: any = {}): Promise<any> {
-    if (!this.child) await this.start();
-    const id = this.nextId++;
-    const request = { jsonrpc: "2.0", id, method: "tools/call", params: { name: method, arguments: params } };
-    
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error(`Sulcus timeout: ${method}`)), 30000);
-      this.pending.set(id, (res) => {
-        clearTimeout(timeout);
-        if (res.error) reject(new Error(res.error.message));
-        else {
-            // MCP result format
-            try {
-                const content = JSON.parse(res.result.content[0].text);
-                resolve(content);
-            } catch(e) {
-                resolve(res.result);
-            }
-        }
-      });
-      this.child!.stdin!.write(JSON.stringify(request) + "\n");
-    });
-  }
-
-  stop() {
-    if (this.child) this.child.kill();
-  }
-}
-
-// REST API client — fallback when sulcus-local binary isn't available
-class SulcusRestClient {
   constructor(
-    private serverUrl: string,
-    private apiKey: string,
-    private namespace: string,
-    private logger: any
+    private storeLibPath: string,
+    private embedLibPath: string
   ) {}
 
-  private async fetch(path: string, options: RequestInit = {}): Promise<any> {
-    const url = `${this.serverUrl}${path}`;
-    const headers: Record<string, string> = {
-      "Authorization": `Bearer ${this.apiKey}`,
-      "Content-Type": "application/json",
-      ...(options.headers as Record<string, string> || {}),
-    };
-    const res = await globalThis.fetch(url, { ...options, headers });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      throw new Error(`Sulcus API ${res.status}: ${text}`);
+  init(logger: any): void {
+    try {
+      // koffi is a pure-JS FFI library — no native compilation needed
+      this.koffi = require("koffi");
+    } catch (e: any) {
+      this.error = `koffi not available: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
     }
-    return res.json();
-  }
-
-  async searchMemory(query: string, limit: number = 5): Promise<any> {
-    const raw = await this.fetch("/api/v1/agent/search", {
-      method: "POST",
-      body: JSON.stringify({ query, namespace: this.namespace, limit }),
-    });
-    // Normalize: server returns {results, provenance} — ensure .results is always accessible
-    // Also handle flat array (backward compat) and .items/.nodes variants
-    const results = raw?.results ?? raw?.items ?? raw?.nodes ?? (Array.isArray(raw) ? raw : []);
-    return { results, provenance: raw?.provenance || { backend: "cloud", namespace: this.namespace } };
-  }
-
-  async recordMemory(params: any): Promise<any> {
-    const raw = await this.fetch("/api/v1/agent/nodes", {
-      method: "POST",
-      body: JSON.stringify({
-        label: params.content,
-        memory_type: params.memory_type || "episodic",
-        namespace: params.fold_name || this.namespace,
-        heat: 0.8,
-      }),
-    });
-    // Normalize: ensure node_id is accessible (server returns "id")
-    return { ...raw, node_id: raw?.id || raw?.node_id };
-  }
-
-  async getMemory(id: string): Promise<any> {
-    return this.fetch(`/api/v1/agent/nodes/${id}`);
-  }
-
-  async deleteMemory(id: string): Promise<any> {
-    return this.fetch(`/api/v1/agent/nodes/${id}`, { method: "DELETE" });
-  }
-
-  async buildContext(prompt: string, tokenBudget: number = 2000): Promise<any> {
-    // REST doesn't have a build_context endpoint — search for relevant memories instead
-    const res = await this.searchMemory(prompt, 10);
-    const results = res?.results || res || [];
-    if (!results.length) return null;
-
-    // Build a simple context string from results
-    const items = results.slice(0, 5).map((r: any) =>
-      `[${r.memory_type || "memory"}] ${r.pointer_summary || r.label || ""}`
-    ).join("\n");
-    return `<sulcus_context source="cloud" namespace="${this.namespace}">\n${items}\n</sulcus_context>`;
-  }
 
-  async getStatus(): Promise<any> {
-    return this.fetch("/api/v1/agent/memory/status");
-  }
-}
-
-// ─── CLIENT-SIDE SIU (Semantic Inference Unit) ───────────────────────────────
-// JSON weights classifier: scale → dot → sigmoid. Zero native deps.
-// Downloads model from server on first use, caches locally.
-
-interface SiuModel {
-  classes: string[];
-  scaler_mean: number[];
-  scaler_scale: number[];
-  coefficients: number[][];
-  intercepts: number[];
-  n_features: number;
-  default_threshold: number;
-}
-
-class ClientSiu {
-  private model: SiuModel | null = null;
-  private modelPath: string;
-  private serverUrl: string;
-  private apiKey: string;
+    // ── Load libsulcus_store.dylib ──
+    if (!existsSync(this.storeLibPath)) {
+      this.error = `libsulcus_store not found at ${this.storeLibPath}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
+    if (!existsSync(this.embedLibPath)) {
+      this.error = `libsulcus_embed not found at ${this.embedLibPath}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-  constructor(cacheDir: string, serverUrl: string, apiKey: string) {
-    this.modelPath = resolve(cacheDir, "memory_classifier_multilabel.json");
-    this.serverUrl = serverUrl;
-    this.apiKey = apiKey;
-  }
+    try {
+      this.storeLib = this.koffi.load(this.storeLibPath);
+      this.fn_store_init  = this.storeLib.func("sulcus_store_init", "int",    ["str", "uint16"]);
+      this.fn_store_query = this.storeLib.func("sulcus_store_query", "char*", ["str"]);
+      this.fn_store_free  = this.storeLib.func("sulcus_store_free_string", "void", ["char*"]);
+    } catch (e: any) {
+      this.error = `Failed to load libsulcus_store: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-  // SECURITY NOTE: SIU (Semantic Intelligence Unit) model is a JSON classifier
-  // for memory type detection. Downloaded once from the configured Sulcus server,
-  // then cached locally at ~/.sulcus/cache/. File read is local cache check only —
-  // no user data is sent. The download sends only the API key for auth, not file
-  // contents. This is a standard model-caching pattern (like downloading an ONNX model).
-  async ensureModel(): Promise<SiuModel | null> {
-    if (this.model) return this.model;
-    const { existsSync, readFileSync, writeFileSync, mkdirSync } = require("node:fs");
-    const { dirname } = require("node:path");
-
-    // Try loading cached model — local file read, no network
-    if (existsSync(this.modelPath)) {
-      try {
-        this.model = JSON.parse(readFileSync(this.modelPath, "utf8"));
-        return this.model;
-      } catch { }
+    try {
+      this.embedLib = this.koffi.load(this.embedLibPath);
+      this.fn_embed_create = this.embedLib.func("sulcus_embed_create", "void*",  []);
+      this.fn_embed_text   = this.embedLib.func("sulcus_embed_text",   "char*",  ["void*", "str"]);
+      this.fn_embed_free   = this.embedLib.func("sulcus_embed_free_string", "void", ["char*"]);
+    } catch (e: any) {
+      this.error = `Failed to load libsulcus_embed: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
     }
 
-    // Download from server
-    if (!this.serverUrl || !this.apiKey) return null;
+    // ── Initialise embedded PG store ──
     try {
-      const res = await globalThis.fetch(
-        `${this.serverUrl}/api/v1/agent/siu-model`,
-        { headers: { "Authorization": `Bearer ${this.apiKey}` } }
-      );
-      if (res.ok) {
-        const data = await res.json();
-        mkdirSync(dirname(this.modelPath), { recursive: true });
-        writeFileSync(this.modelPath, JSON.stringify(data));
-        this.model = data;
-        return this.model;
+      const dataDir = resolve(process.env.HOME || "~", ".sulcus/data");
+      const port = 15432;
+      const rc = this.fn_store_init(dataDir, port);
+      if (rc !== 0) {
+        this.error = `sulcus_store_init returned ${rc}`;
+        logger.warn(`memory-sulcus: ${this.error}`);
+        return;
       }
-    } catch { }
-    return null;
-  }
-
-  // Classify using pre-computed embedding (384-dim)
-  classifyEmbedding(embedding: number[]): { type: string; confidence: number; all: Record<string, number> } | null {
-    if (!this.model) return null;
-    const m = this.model;
-    if (embedding.length !== m.n_features) return null;
+    } catch (e: any) {
+      this.error = `sulcus_store_init failed: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-    // Scale: (x - mean) / scale
-    const scaled = embedding.map((x, i) => (x - m.scaler_mean[i]) / m.scaler_scale[i]);
+    // ── Create embed handle ──
+    try {
+      this.embedHandle = this.fn_embed_create();
+    } catch (e: any) {
+      this.error = `sulcus_embed_create failed: ${e.message}`;
+      logger.warn(`memory-sulcus: ${this.error}`);
+      return;
+    }
 
-    // Dot product + sigmoid for each class
-    const scores: Record<string, number> = {};
-    let bestType = "episodic";
-    let bestScore = 0;
+    this.loaded = true;
+    logger.info(`memory-sulcus: native libs loaded (store: ${this.storeLibPath}, embed: ${this.embedLibPath})`);
+  }
 
-    for (let c = 0; c < m.classes.length; c++) {
-      let dot = m.intercepts[c];
-      for (let f = 0; f < m.n_features; f++) {
-        dot += scaled[f] * m.coefficients[c][f];
-      }
-      const sigmoid = 1 / (1 + Math.exp(-dot));
-      scores[m.classes[c]] = sigmoid;
-      if (sigmoid > bestScore) {
-        bestScore = sigmoid;
-        bestType = m.classes[c];
+  // queryFn: async (sql: string, params: any[]) => any[]
+  // Calls sulcus_store_query which accepts plain SQL (params inlined by caller or
+  // passed as a JSON payload — the store lib handles parameterisation internally).
+  makeQueryFn(): (sql: string, params: any[]) => Promise<any[]> {
+    return async (sql: string, _params: any[]): Promise<any[]> => {
+      if (!this.loaded) throw new Error("Sulcus store not available");
+      // The store lib's query function takes a single JSON-encoded request
+      const payload = JSON.stringify({ sql, params: _params });
+      const raw: string = this.fn_store_query(payload);
+      if (!raw) return [];
+      try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : (parsed?.rows ?? [parsed]);
+      } finally {
+        // NOTE: koffi manages string memory automatically for char* returns;
+        // no manual free needed with koffi's default charset handling.
+        // If the ABI requires explicit free, call fn_store_free here.
       }
-    }
+    };
+  }
 
-    return { type: bestType, confidence: bestScore, all: scores };
+  // embedFn: async (text: string) => Float32Array
+  // Calls sulcus_embed_text which returns a JSON float array string.
+  makeEmbedFn(): (text: string) => Promise<Float32Array> {
+    return async (text: string): Promise<Float32Array> => {
+      if (!this.loaded) throw new Error("Sulcus embed not available");
+      const raw: string = this.fn_embed_text(this.embedHandle, text);
+      if (!raw) throw new Error("sulcus_embed_text returned null");
+      const arr: number[] = JSON.parse(raw);
+      return new Float32Array(arr);
+    };
   }
 }
 
@@ -320,86 +195,83 @@ const JUNK_PATTERNS = [
 
 function isJunkMemory(text: string): boolean {
   if (!text || text.length < 10) return true;
-  if (text.length > 10000) return true; // probably a raw dump
+  if (text.length > 10000) return true;
   for (const pattern of JUNK_PATTERNS) {
     if (pattern.test(text.trim())) return true;
   }
   return false;
 }
 
+// ─── PLUGIN ──────────────────────────────────────────────────────────────────
+
 const sulcusPlugin = {
   id: "memory-sulcus",
   name: "Sulcus vMMU",
-  description: "Sulcus-backed vMMU memory for OpenClaw — thermodynamic decay, reactive triggers, local-first with cloud sync",
+  description: "Sulcus-backed vMMU memory for OpenClaw — thermodynamic decay, reactive triggers, local-first",
   kind: "memory" as const,
 
   register(api: any) {
-    const binaryPath = api.config?.binaryPath || "/Users/dv00003-00/dev/sulcus/target/release/sulcus-local";
-    const iniPath = api.config?.iniPath || resolve(process.env.HOME || "~", ".config/sulcus/sulcus.ini");
+    // ── Configuration ──
+    const libDir = api.config?.libDir
+      ? resolve(api.config.libDir)
+      : resolve(process.env.HOME || "~", ".sulcus/lib");
+
+    const storeLibPath = api.config?.storeLibPath
+      ? resolve(api.config.storeLibPath)
+      : resolve(libDir, process.platform === "darwin" ? "libsulcus_store.dylib" : "libsulcus_store.so");
+
+    const embedLibPath = api.config?.embedLibPath
+      ? resolve(api.config.embedLibPath)
+      : resolve(libDir, process.platform === "darwin" ? "libsulcus_embed.dylib" : "libsulcus_embed.so");
+
+    const wasmDir = api.config?.wasmDir
+      ? resolve(api.config.wasmDir)
+      : resolve(__dirname, "wasm");
+
     // Default namespace = agent name (prevents everything landing in "default")
-    // Priority: explicit namespace config > agentId config > pluginConfig.agentId > "default"
     const agentId = api.config?.agentId || api.pluginConfig?.agentId;
     const namespace = api.config?.namespace === "default" && agentId
       ? agentId
       : (api.config?.namespace || agentId || "default");
-    const serverUrl = api.config?.serverUrl || "";
-    const apiKey = api.config?.apiKey || "";
-    const client = new SulcusClient(binaryPath, iniPath);
 
-    // Detect backend mode: if serverUrl is set and binaryPath doesn't exist, it's cloud-only
-    let backendMode = "local"; // default assumption
-    let hasBinary = false;
-    try {
-      const { existsSync } = require("node:fs");
-      hasBinary = existsSync(binaryPath);
-      if (!hasBinary) {
-        backendMode = serverUrl ? "cloud" : "unavailable";
-      } else {
-        backendMode = serverUrl ? "hybrid" : "local";
-      }
-    } catch { }
+    // ── Load native dylibs ──
+    const nativeLoader = new NativeLibLoader(storeLibPath, embedLibPath);
+    nativeLoader.init(api.logger);
 
-    // REST client for cloud fallback (or cloud-only mode)
-    const restClient = serverUrl && apiKey
-      ? new SulcusRestClient(serverUrl, apiKey, namespace, api.logger)
-      : null;
+    // ── Load WASM module ──
+    let sulcusMem: any = null;
+    let backendMode = "unavailable";
 
-    // Unified call helper: try local binary first, fall back to REST
-    async function memoryCall(method: string, params: any): Promise<any> {
-      if (hasBinary) {
+    if (nativeLoader.loaded) {
+      const wasmJsPath = resolve(wasmDir, "sulcus_wasm.js");
+      if (existsSync(wasmJsPath)) {
         try {
-          return await client.call(method, params);
+          const { SulcusMem, on_init } = require(wasmJsPath);
+          // on_init sets up WASM internals (panic hooks etc.)
+          if (typeof on_init === "function") on_init();
+
+          const queryFn = nativeLoader.makeQueryFn();
+          const embedFn = nativeLoader.makeEmbedFn();
+          sulcusMem = SulcusMem.create(queryFn, embedFn);
+          backendMode = "wasm";
+          api.logger.info(`memory-sulcus: SulcusMem created via WASM (wasm: ${wasmJsPath})`);
         } catch (e: any) {
-          api.logger.warn(`memory-sulcus: local binary failed (${method}): ${e.message}, falling back to REST`);
-          if (!restClient) throw e;
+          api.logger.warn(`memory-sulcus: WASM load failed: ${e.message}`);
+          backendMode = "unavailable";
         }
+      } else {
+        api.logger.warn(`memory-sulcus: WASM module not found at ${wasmJsPath}`);
       }
-      if (!restClient) throw new Error("Sulcus unavailable: no binary and no server configured");
-      // Route to appropriate REST method
-      switch (method) {
-        case "search_memory": return restClient.searchMemory(params.query, params.limit);
-        case "record_memory": return restClient.recordMemory(params);
-        case "build_context": return restClient.buildContext(params.prompt, params.token_budget);
-        default: throw new Error(`Unknown method: ${method}`);
-      }
+    } else {
+      api.logger.warn(`memory-sulcus: native libs unavailable — ${nativeLoader.error}`);
     }
 
+    const isAvailable = sulcusMem !== null;
+
     // Update static awareness with runtime info
-    STATIC_AWARENESS = buildStaticAwareness(backendMode, namespace, serverUrl || "local");
-
-    // Initialize client-side SIU
-    const siuCacheDir = resolve(process.env.HOME || "~", ".cache/sulcus/model");
-    const clientSiu = serverUrl && apiKey ? new ClientSiu(siuCacheDir, serverUrl, apiKey) : null;
-
-    // Pre-load SIU model (non-blocking)
-    if (clientSiu) {
-      clientSiu.ensureModel().then(m => {
-        if (m) api.logger.info(`memory-sulcus: client SIU loaded (${m.classes.length} classes, ${m.n_features} features)`);
-        else api.logger.warn("memory-sulcus: client SIU model not available");
-      }).catch(() => {});
-    }
+    STATIC_AWARENESS = buildStaticAwareness(backendMode, namespace);
 
-    api.logger.info(`memory-sulcus: registered (binary: ${binaryPath}, hasBinary: ${hasBinary}, namespace: ${namespace}, backend: ${backendMode})`);
+    api.logger.info(`memory-sulcus: registered (backend: ${backendMode}, namespace: ${namespace}, available: ${isAvailable})`);
 
     // ── Core memory tools ──
 
@@ -412,12 +284,14 @@ const sulcusPlugin = {
         limit: Type.Optional(Type.Number({ default: 5, description: "Maximum number of results to return (1-10)." }))
       }),
       async execute(_id: string, params: any) {
-        const res = await memoryCall("search_memory", { query: params.query, limit: params.limit });
-        const results = res?.results || res;
-        const provenance = res?.provenance || { backend: backendMode, namespace };
+        if (!isAvailable) {
+          throw new Error(`Sulcus unavailable: ${nativeLoader.error || "WASM not loaded"}`);
+        }
+        const res = await sulcusMem.search_memory(params.query, params.limit ?? 5);
+        const results = res?.results ?? res;
         return {
           content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
-          details: { ...res, provenance }
+          details: { results, backend: backendMode, namespace }
         };
       }
     }, { name: "memory_recall" });
@@ -425,10 +299,9 @@ const sulcusPlugin = {
     api.registerTool({
       name: "memory_store",
       label: "Memory Store",
-      description: "Record information in Sulcus memory. Supports Markdown formatting. You control the memory type, decay rate, importance, and key details at creation time.",
+      description: "Record information in Sulcus memory. Supports Markdown formatting. You control the memory type at creation time.",
       parameters: Type.Object({
         content: Type.String({ description: "Memory content. Supports Markdown formatting for structured content." }),
-        fold_name: Type.Optional(Type.String({ description: `Memory namespace/fold. Defaults to "${namespace}" (agent namespace).` })),
         memory_type: Type.Optional(Type.Union([
           Type.Literal("episodic"),
           Type.Literal("semantic"),
@@ -436,15 +309,6 @@ const sulcusPlugin = {
           Type.Literal("procedural"),
           Type.Literal("fact")
         ], { description: "Memory type. preference=user preferences, procedural=how-to/processes, fact=stable knowledge, semantic=concepts/relationships, episodic=events/experiences. Default: episodic" })),
-        decay_class: Type.Optional(Type.Union([
-          Type.Literal("volatile"),
-          Type.Literal("normal"),
-          Type.Literal("stable"),
-          Type.Literal("permanent")
-        ], { description: "Decay rate. volatile=fast decay, normal=default, stable=slow decay, permanent=never decays" })),
-        is_pinned: Type.Optional(Type.Boolean({ description: "Pin memory to freeze heat at current value, preventing ALL decay. Pinned memories never lose heat." })),
-        min_heat: Type.Optional(Type.Number({ description: "Minimum heat floor (0.0-1.0). Memory will never decay below this value." })),
-        key_points: Type.Optional(Type.Array(Type.String(), { description: "Key points to index for search. Extracted highlights." }))
       }),
       async execute(_id: string, params: any) {
         // Pre-send junk filter
@@ -456,25 +320,14 @@ const sulcusPlugin = {
           };
         }
 
-        const res = await memoryCall("record_memory", { ...params, namespace, fold_name: params.fold_name || namespace });
-        // Check for storage limit error
-        if (res?.error === "storage_limit_reached") {
-          return {
-            content: [{ type: "text", text: `⚠️ Storage limit reached: ${res.message}` }],
-            details: res
-          };
+        if (!isAvailable) {
+          throw new Error(`Sulcus unavailable: ${nativeLoader.error || "WASM not loaded"}`);
         }
-        const provenance = res?.provenance || {
-          backend: backendMode,
-          namespace,
-          server: serverUrl,
-          sync_available: backendMode === "hybrid",
-          siu_classified: false,
-        };
-        const provenanceStr = `[${provenance.backend}] namespace: ${provenance.namespace || namespace}, server: ${provenance.server || serverUrl}`;
+
+        const res = await sulcusMem.add_memory(params.content, params.memory_type ?? null);
         return {
-          content: [{ type: "text", text: `Stored [${params.memory_type || "episodic"}] memory: "${(params.content || "").substring(0, 80)}..." → ${provenanceStr}` }],
-          details: { ...res, provenance }
+          content: [{ type: "text", text: `Stored [${params.memory_type || "episodic"}] memory: "${(params.content || "").substring(0, 80)}..." → [${backendMode}] namespace: ${namespace}` }],
+          details: { ...res, backend: backendMode, namespace }
         };
       }
     }, { name: "memory_store" });
@@ -482,31 +335,46 @@ const sulcusPlugin = {
     api.registerTool({
       name: "memory_status",
       label: "Memory Status",
-      description: "Check Sulcus memory backend status: connection, namespace, capabilities, and memory count.",
+      description: "Check Sulcus memory backend status: connection, namespace, capabilities, and hot nodes.",
       parameters: Type.Object({}),
       async execute(_id: string, _params: any) {
-        if (restClient) {
-          try {
-            const status = await restClient.getStatus();
-            return {
-              content: [{ type: "text", text: JSON.stringify(status, null, 2) }],
-              details: status
-            };
-          } catch (e: any) {
-            return {
-              content: [{ type: "text", text: `Memory status unavailable: ${e.message}` }],
-            };
-          }
+        if (!isAvailable) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              status: "unavailable",
+              backend: backendMode,
+              namespace,
+              error: nativeLoader.error || "WASM not loaded",
+              storeLib: storeLibPath,
+              embedLib: embedLibPath,
+              wasmDir,
+            }, null, 2) }],
+          };
+        }
+        try {
+          const hotNodes = await sulcusMem.list_hot_nodes(20);
+          const nodeList = hotNodes?.nodes ?? hotNodes ?? [];
+          const count = Array.isArray(nodeList) ? nodeList.length : 0;
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              status: "ok",
+              backend: backendMode,
+              namespace,
+              hot_node_count: count,
+              hot_nodes: nodeList,
+            }, null, 2) }],
+            details: { status: "ok", backend: backendMode, namespace, count }
+          };
+        } catch (e: any) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({
+              status: "error",
+              backend: backendMode,
+              namespace,
+              error: e.message,
+            }, null, 2) }],
+          };
         }
-        // Fallback: return local config info
-        return {
-          content: [{ type: "text", text: JSON.stringify({
-            status: hasBinary ? "local" : "unavailable",
-            backend: backendMode,
-            namespace,
-            server: serverUrl || "none",
-          }, null, 2) }],
-        };
       }
     }, { name: "memory_status" });
 
@@ -529,32 +397,23 @@ const sulcusPlugin = {
         api.logger.debug(`memory-sulcus: autoRecall is disabled, skipping context build`);
         return;
       }
+      if (!isAvailable) return;
       api.logger.info(`memory-sulcus: before_agent_start hook triggered for agent ${event.agentId}`);
       if (!event.prompt) return;
       try {
-        api.logger.debug(`memory-sulcus: building context for prompt: ${event.prompt.substring(0, 50)}...`);
-        // include_recent: false — OpenClaw already has conversation context.
-        // Only inject curated preferences, facts, and procedures from Sulcus.
-        const res = await memoryCall("build_context", { prompt: event.prompt, token_budget: 2000, include_recent: false });
-        // build_context returns either:
-        //   - plain XML string (new format, post-4dca467)
-        //   - { context: "...", token_estimate: N } (old format)
-        // The MCP client resolves to the parsed JSON if valid, or the raw MCP result object.
-        let context: string | undefined;
-        if (typeof res === "string") {
-          context = res;
-        } else if (res?.context) {
-          context = res.context;
-        } else if (res?.content?.[0]?.text) {
-          context = res.content[0].text;
-        }
-        if (context) {
-          api.logger.info(`memory-sulcus: context build successful, injecting ${context.length} chars`);
-          return { prependSystemContext: context };
+        api.logger.debug(`memory-sulcus: searching context for prompt: ${event.prompt.substring(0, 50)}...`);
+        const res = await sulcusMem.search_memory(event.prompt, 5);
+        const results = res?.results ?? [];
+        if (!results || results.length === 0) {
+          return { prependSystemContext: FALLBACK_AWARENESS };
         }
-        // Context was empty — inject fallback so LLM still knows about Sulcus
-        api.logger.warn(`memory-sulcus: build_context returned empty, injecting fallback awareness`);
-        return { prependSystemContext: FALLBACK_AWARENESS };
+        // Format results as a concise XML context block
+        const items = results.map((r: any) =>
+          `    <memory id="${r.id}" heat="${(r.current_heat ?? r.score ?? 0).toFixed(2)}" type="${r.memory_type ?? "unknown"}">${r.label ?? r.pointer_summary ?? ""}</memory>`
+        ).join("\n");
+        const context = `<sulcus_context token_budget="500" namespace="${namespace}">\n${items}\n</sulcus_context>`;
+        api.logger.info(`memory-sulcus: injecting ${results.length} recalled memories (${context.length} chars)`);
+        return { prependSystemContext: context };
       } catch (e) {
         // build_context failed — inject fallback so the LLM isn't flying blind
         api.logger.warn(`memory-sulcus: context build failed: ${e} — injecting fallback awareness`);
@@ -563,18 +422,12 @@ const sulcusPlugin = {
     });
 
     // agent_end: Do NOT auto-record raw conversation turns.
-    // The LLM has record_memory as an MCP tool — it decides what's worth remembering.
-    // Auto-recording every turn flooded the store with 2000+ junk episodic nodes
-    // containing placeholder vectors and raw JSON conversation payloads.
+    // The LLM has memory_store as a tool — it decides what's worth remembering.
     api.on("agent_end", async (event: any) => {
       api.logger.debug(`memory-sulcus: agent_end hook triggered for agent ${event.agentId} (no auto-record)`);
     });
 
-    api.registerService({
-      id: "memory-sulcus",
-      start: () => client.start(),
-      stop: () => client.stop()
-    });
+    // No service registration needed — no background process to manage
   }
 };