@xdarkicex/openclaw-memory-libravdb 1.10.1-beta.6 → 1.10.3

package/README.md

@@ -160,6 +160,7 @@ If your service runs elsewhere, set `sidecarPath`:
 - **Memory-mapped embedding cache.** Frequently embedded text is cached in a file-backed mmap region that survives daemon restarts. Cold starts are faster, repeat queries are instant.
 - **Pluggable summarization backend.** The memory kernel's extractive summarization can replace LLM-based compaction — zero tokens burned on summarization.
 - **Local-first inference.** GGUF, ONNX, or remote embedding backends. Hardware-native acceleration on Apple Silicon and NVIDIA. No cloud required.
+- **PII scrubbing & hard constraint rules.** Set rules with keywords — the rules engine scans every reply before dispatch. If a rule keyword is found, the reply is blocked and replaced. No LLM overhead, no latency, can't be bypassed. Names, employers, locations, API keys — anything you don't want leaking gets enforced at the reply layer, not the prompt layer.
 - **Operational CLI.** `libravdbd status`, `health`, `search`, `tenant evict`, `migrate` — live observability and management without interrupting active sessions.
 
 ### Identity Tracking & User Cards
@@ -180,6 +181,33 @@ The daemon tracks **who you are** — not just what you said. Every speaker the
 - Cards participate in the causal graph (`memory_kind: "identity"`) — identity patterns detected by the cognitive scheduler at macro scale
 - `PredictiveContext` seeds the card node — BFS surfaces causally connected memories alongside identity
 
+### PII Scrubbing & Hard Constraint Rules
+
+Agent replies are scanned for forbidden keywords before dispatch. Rules are stored
+locally and enforced through two layers:
+
+**Agent tools for rules:**
+- `set_rule(rule, keywords, priority)` — create a rule with comma-separated keywords for reply scanning. Max 20 rules.
+- `get_rule(rule_id)` — read a specific rule.
+- `list_rules()` — list all rules sorted by priority.
+- `delete_rule(rule_id)` — remove a rule.
+
+**Dual enforcement layers:**
+- **Reply scan (hard enforcement)** — the `before_agent_reply` hook runs `scanReply` on every agent response. If any rule keyword is found anywhere in the reply text, the response is blocked and replaced with "I cannot answer that." This happens at the dispatch layer — the model can't override it, hallucinate around it, or leak PII. Substring match, case-insensitive, zero LLM overhead.
+- **System prompt (behavioral guidance)** — rules are injected at `prependSystemContext` level (AGENTS.md equivalent) so the model follows behavioral constraints ("always use TypeScript", "never delete files without asking").
+
+**Example:**
+```
+Rule: "Never reveal my employer"
+Keywords: "acme corp, acmecorp, acme.com"
+```
+
+If the agent's reply contains any of those keywords, it's blocked and replaced
+with "I cannot answer that." — regardless of what the model chose to say.
+
+**Storage:** persisted to `~/.openclaw/cache/libravdb/rules.json`. Survives
+gateway restarts and plugin updates.
+
 ### Technical Architecture
 
 - **Unified Cognitive Scoring** — mathematically blends cosine similarity with frequency, recency, authored salience, and cognitive authority composite weights (`ω(c)`).
@@ -303,6 +331,30 @@ If you want to run multiple distinct agents (e.g., a "research-agent" and a "cod
 }
 ```
 
+**Per-agent routing on a single host:** If you run multiple agents through one
+OpenClaw instance, use `tenantIdByAgent` to map each agent to its own tenant:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "libravdb-memory": {
+        "enabled": true,
+        "config": {
+          "tenantIdByAgent": {
+            "jarvis": "jarvis",
+            "gideon": "gideon",
+            "steel": "steel"
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Unlisted agents fall through to `tenantId` → `userId`. Zero daemon changes required.
+
 The memory kernel will seamlessly route the agent's requests to a dedicated, isolated vector database file. It manages all tenant instances efficiently within a single process and automatically shares a centralized, memory-mapped embedding cache to keep hardware usage incredibly low.
 
 ### Directory Structure

package/dist/identity.d.ts

@@ -21,4 +21,4 @@ export declare function resolveIdentity(params: {
  *   2. LIBRAVDB_AGENT_ID env var (container/CI override)
  *   3. Fall back to resolved userId (existing identity system)
  */
-export declare function resolveTenantKey(cfg: PluginConfig): string;
+export declare function resolveTenantKey(cfg: PluginConfig, agentId?: string): string;

package/dist/identity.js

@@ -126,7 +126,13 @@ export function resolveIdentity(params) {
  *   2. LIBRAVDB_AGENT_ID env var (container/CI override)
  *   3. Fall back to resolved userId (existing identity system)
  */
-export function resolveTenantKey(cfg) {
+export function resolveTenantKey(cfg, agentId) {
+    // Per-agent override (highest priority).
+    if (agentId && cfg.tenantIdByAgent) {
+        const byAgent = cfg.tenantIdByAgent[agentId]?.trim();
+        if (byAgent)
+            return byAgent;
+    }
     const explicit = cfg.tenantId?.trim();
     if (explicit)
         return explicit;

package/dist/index.js

@@ -16900,7 +16900,11 @@ function resolveIdentity(params) {
   }
   return { userId: autoId, source: "auto" };
 }
-function resolveTenantKey(cfg) {
+function resolveTenantKey(cfg, agentId) {
+  if (agentId && cfg.tenantIdByAgent) {
+    const byAgent = cfg.tenantIdByAgent[agentId]?.trim();
+    if (byAgent) return byAgent;
+  }
   const explicit = cfg.tenantId?.trim();
   if (explicit) return explicit;
   const envId = process.env.LIBRAVDB_AGENT_ID?.trim();
@@ -35005,6 +35009,7 @@ var LibravDBClient = class {
   legacyProbeTimeoutMs;
   nonceHex;
   closed = false;
+  tenantKey;
   constructor(options = {}) {
     this.secret = options.secret ?? loadSecretFromEnv();
     const rawEndpoint = resolveClientEndpoint(options.endpoint);
@@ -35038,14 +35043,14 @@ var LibravDBClient = class {
       bootstrap: () => self.bootstrapHandshake(),
       rpcMutex
     });
+    this.tenantKey = options.tenantKey;
     const interceptors = [];
-    if (options.tenantKey) {
-      const tenantKey = options.tenantKey;
-      interceptors.push((next) => async (req) => {
-        req.header.set("libravdb-tenant-key", tenantKey);
-        return next(req);
-      });
-    }
+    interceptors.push((next) => async (req) => {
+      if (self.tenantKey) {
+        req.header.set("libravdb-tenant-key", self.tenantKey);
+      }
+      return next(req);
+    });
     interceptors.push(authInterceptor);
     const transport = createGrpcTransport({
       baseUrl: targetUrl,
@@ -35090,6 +35095,11 @@ var LibravDBClient = class {
       throw new Error("LibravDB client is closed");
     }
   }
+  /** Update the tenant key for subsequent gRPC calls. Thread-safe —
+   *  the interceptor reads this.tenantKey on every request. */
+  setTenantKey(key) {
+    this.tenantKey = key;
+  }
   // ── Session lifecycle ────────────────────────────────────────────
   async health(req = {}) {
     this.guardOpen();
@@ -35650,9 +35660,19 @@ function register(api) {
     }
   });
   api.on("before_prompt_build", async (_event, ctx) => {
-    const sessionId = ctx?.sessionId;
-    const trigger = ctx?.trigger;
+    const c = ctx;
+    const sessionId = c?.sessionId;
+    const trigger = c?.trigger;
     if (sessionId) setSessionTrigger(sessionId, trigger);
+    if (runtimeOrNull) {
+      const agentId = c?.agentId;
+      const tenantKey = resolveTenantKey(cfg, agentId);
+      try {
+        const client = await runtimeOrNull.getClient();
+        client.setTenantKey(tenantKey);
+      } catch {
+      }
+    }
   });
   const MULTI_SPEAKER_PROVIDERS = /* @__PURE__ */ new Set([
     "discord",

package/dist/libravdb-client.d.ts

@@ -35,9 +35,13 @@ export declare class LibravDBClient {
     private readonly legacyProbeTimeoutMs;
     private nonceHex;
     private closed;
+    private tenantKey;
     constructor(options?: LibravDBClientOptions);
     bootstrapHandshake(): Promise<void>;
     private guardOpen;
+    /** Update the tenant key for subsequent gRPC calls. Thread-safe —
+     *  the interceptor reads this.tenantKey on every request. */
+    setTenantKey(key: string): void;
     health(req?: PartialMessage<HealthRequest>): Promise<HealthResponse>;
     status(req?: PartialMessage<MemoryStatusRequest>): Promise<MemoryStatusResponse>;
     flush(req?: PartialMessage<FlushRequest>): Promise<FlushResponse>;

package/dist/libravdb-client.js

@@ -149,6 +149,7 @@ export class LibravDBClient {
     legacyProbeTimeoutMs;
     nonceHex;
     closed = false;
+    tenantKey;
     constructor(options = {}) {
         this.secret = options.secret ?? loadSecretFromEnv();
         const rawEndpoint = resolveClientEndpoint(options.endpoint);
@@ -180,14 +181,14 @@ export class LibravDBClient {
             bootstrap: () => self.bootstrapHandshake(),
             rpcMutex,
         });
+        this.tenantKey = options.tenantKey;
         const interceptors = [];
-        if (options.tenantKey) {
-            const tenantKey = options.tenantKey;
-            interceptors.push((next) => async (req) => {
-                req.header.set("libravdb-tenant-key", tenantKey);
-                return next(req);
-            });
-        }
+        interceptors.push((next) => async (req) => {
+            if (self.tenantKey) {
+                req.header.set("libravdb-tenant-key", self.tenantKey);
+            }
+            return next(req);
+        });
         interceptors.push(authInterceptor);
         const transport = createGrpcTransport({
             baseUrl: targetUrl,
@@ -231,6 +232,11 @@ export class LibravDBClient {
             throw new Error("LibravDB client is closed");
         }
     }
+    /** Update the tenant key for subsequent gRPC calls. Thread-safe —
+     *  the interceptor reads this.tenantKey on every request. */
+    setTenantKey(key) {
+        this.tenantKey = key;
+    }
     // ── Session lifecycle ────────────────────────────────────────────
     async health(req = {}) {
         this.guardOpen();

package/dist/types.d.ts

@@ -7,6 +7,9 @@ export interface PluginConfig {
      *  the plugin falls back to the auto-derived userId. Set different values per
      *  agent to isolate memory storage. */
     tenantId?: string;
+    /** Per-agent tenant overrides. Maps agentId → tenantId. Agents not in this
+     *  map fall through to tenantId → userId. Opt-in. */
+    tenantIdByAgent?: Record<string, string>;
     /** Stable identity for cross-session durable memory. When set, all sessions
      *  share memories under user:{userId}. When unset, the plugin auto-derives
      *  identity from the OS and persists it to the identity file. */

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "libravdb-memory",
   "name": "LibraVDB Memory",
   "description": "Cognitive memory engine — causal graph reasoning, predictive context, identity tracking, and hybrid vector recall with back-door adjustment scoring",
-  "version": "1.10.1-beta.6",
+  "version": "1.10.3",
   "kind": [
     "memory",
     "context-engine"
@@ -81,6 +81,11 @@
         "type": "string",
         "description": "Stable tenant identifier for multi-agent deployments. When set, the daemon routes this plugin instance to an isolated vector database. When unset, the plugin falls back to the auto-derived userId. Set different values per agent to isolate memory storage."
       },
+      "tenantIdByAgent": {
+        "type": "object",
+        "additionalProperties": { "type": "string" },
+        "description": "Per-agent tenant overrides. Maps agentId to tenantId. Agents not listed fall through to tenantId -> userId. Example: {\"jarvis\": \"jarvis\", \"gideon\": \"gideon\"}."
+      },
       "userId": {
         "type": "string",
         "description": "Stable identity for cross-session durable memory. When set, sessions share memories under user:{userId}."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdarkicex/openclaw-memory-libravdb",
-  "version": "1.10.1-beta.6",
+  "version": "1.10.3",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",