@xdarkicex/openclaw-memory-libravdb 1.10.1-beta.5 → 1.10.1

package/README.md

@@ -180,6 +180,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
 
+### Hard Constraint Rules Engine
+
+Plugin-side rules that act as an enforceable safety layer. Rules are stored locally,
+persisted across sessions, and enforced through two complementary mechanisms:
+
+**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:**
+- **Behavioral layer** — rules injected at `prependSystemContext` level (equivalent to AGENTS.md). The model sees them as system-level instructions and follows behavioral constraints ("always use TypeScript", "never delete files without asking").
+- **PII enforcement layer** — every agent reply is scanned by `scanReply` in the `before_agent_reply` hook. If any rule keyword matches the reply text, the reply is blocked and replaced with a refusal. Keyword matching is substring-based, case-insensitive — no LLM call, no latency.
+
+**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)`).

package/dist/index.js

@@ -18444,7 +18444,11 @@ function initRuleStore(cacheDir, logger) {
   try {
     const raw = readFileSync2(rulesPath, "utf8");
     const parsed = JSON.parse(raw);
-    rules = parsed.rules ?? [];
+    rules = (parsed.rules ?? []).map((r) => ({
+      ...r,
+      keywords: r.keywords ?? []
+      // handle pre-keyword rules
+    }));
     nextId = parsed.nextId ?? 1;
   } catch {
     rules = [];
@@ -18465,7 +18469,7 @@ function getRules() {
 function getRule(id) {
   return rules.find((r) => r.id === id);
 }
-function setRule(ruleText, priority) {
+function setRule(ruleText, keywords, priority) {
   let replaced = false;
   if (rules.length >= MAX_RULES) {
     let minIdx = 0;
@@ -18478,6 +18482,7 @@ function setRule(ruleText, priority) {
   const rule = {
     id: String(nextId++),
     rule: ruleText,
+    keywords: keywords.map((k) => k.toLowerCase().trim()).filter((k) => k.length > 0),
     priority: Math.max(1, Math.min(10, priority || 5)),
     created_at: Date.now()
   };
@@ -18486,6 +18491,17 @@ function setRule(ruleText, priority) {
   persist();
   return { rule, replaced };
 }
+function scanReply(replyText) {
+  const lower = replyText.toLowerCase();
+  for (const rule of rules) {
+    for (const kw of rule.keywords) {
+      if (kw && lower.includes(kw)) {
+        return rule;
+      }
+    }
+  }
+  return null;
+}
 function deleteRule(id) {
   const idx = rules.findIndex((r) => r.id === id);
   if (idx < 0) return false;
@@ -18497,22 +18513,25 @@ function createSetRuleTool(logger = console) {
   return {
     name: "set_rule",
     label: "Set Rule",
-    description: "Set a HARD constraint rule. Max 20 rules across all sessions. Rules are injected at session start as non-negotiable instructions. Use this when the user wants you to never do something, always do something, or set a permanent behavioral boundary. Higher priority rules appear first.",
+    description: "Set a HARD constraint rule. Max 20 rules. Replies are scanned against rule keywords \u2014 if a keyword is found, the reply is blocked and replaced with a refusal. Provide keywords that would appear in a violating reply (e.g. for 'never reveal my name', keywords: 'gentry, rolfson'). Higher priority rules appear first.",
     parameters: {
       type: "object",
       additionalProperties: false,
       properties: {
         rule: { type: "string", description: "The rule text. Be specific and unambiguous." },
+        keywords: { type: "string", description: "Comma-separated keywords to scan for in replies. If any keyword is found, the reply is blocked." },
         priority: { type: "number", description: "Priority 1-10. Higher = more important. Default 5." }
       },
-      required: ["rule"]
+      required: ["rule", "keywords"]
     },
     execute: async (_toolCallId, rawParams) => {
       const params = rawParams;
       const ruleText = typeof params?.rule === "string" ? params.rule.trim() : "";
       if (!ruleText) return jsonResult({ ok: false, error: "set_rule requires a rule string" });
+      const kwRaw = typeof params?.keywords === "string" ? params.keywords : "";
+      const keywords = kwRaw.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
       const priority = typeof params?.priority === "number" ? params.priority : 5;
-      const result = setRule(ruleText, priority);
+      const result = setRule(ruleText, keywords, priority);
       return jsonResult({ ok: true, rule: result.rule, replaced: result.replaced });
     }
   };
@@ -35700,6 +35719,16 @@ ${card.trim()}
     if (!rulesText) return;
     return { prependSystemContext: rulesText };
   });
+  api.on("before_agent_reply", async (event, _ctx) => {
+    const e = event;
+    const cleanedBody = typeof e.cleanedBody === "string" ? e.cleanedBody : "";
+    if (!cleanedBody) return;
+    const violated = scanReply(cleanedBody);
+    if (violated) {
+      logger.warn?.(`LibraVDB reply blocked by rule "${violated.rule}" (${violated.id})`);
+      return { handled: true, reply: { text: "I cannot answer that." }, reason: `blocked by rule: ${violated.rule}` };
+    }
+  });
   api.on("session_end", async (_event, ctx) => {
     const sessionId = ctx?.sessionId;
     if (sessionId) clearSessionTrigger(sessionId);

package/dist/rules.d.ts

@@ -2,6 +2,7 @@ import type { LoggerLike } from "./types.js";
 export interface Rule {
     id: string;
     rule: string;
+    keywords: string[];
     priority: number;
     created_at: number;
 }
@@ -16,10 +17,11 @@ type ToolResult<T> = {
 export declare function initRuleStore(cacheDir: string, logger?: LoggerLike): void;
 export declare function getRules(): Rule[];
 export declare function getRule(id: string): Rule | undefined;
-export declare function setRule(ruleText: string, priority: number): {
+export declare function setRule(ruleText: string, keywords: string[], priority: number): {
     rule: Rule;
     replaced: boolean;
 };
+export declare function scanReply(replyText: string): Rule | null;
 export declare function deleteRule(id: string): boolean;
 export declare function createSetRuleTool(logger?: LoggerLike): {
     name: string;
@@ -33,12 +35,16 @@ export declare function createSetRuleTool(logger?: LoggerLike): {
                 readonly type: "string";
                 readonly description: "The rule text. Be specific and unambiguous.";
             };
+            readonly keywords: {
+                readonly type: "string";
+                readonly description: "Comma-separated keywords to scan for in replies. If any keyword is found, the reply is blocked.";
+            };
             readonly priority: {
                 readonly type: "number";
                 readonly description: "Priority 1-10. Higher = more important. Default 5.";
             };
         };
-        readonly required: readonly ["rule"];
+        readonly required: readonly ["rule", "keywords"];
     };
     execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<{
         ok: boolean;

package/dist/rules.js

@@ -13,7 +13,10 @@ export function initRuleStore(cacheDir, logger) {
     try {
         const raw = readFileSync(rulesPath, "utf8");
         const parsed = JSON.parse(raw);
-        rules = parsed.rules ?? [];
+        rules = (parsed.rules ?? []).map((r) => ({
+            ...r,
+            keywords: r.keywords ?? [], // handle pre-keyword rules
+        }));
         nextId = parsed.nextId ?? 1;
     }
     catch {
@@ -36,10 +39,9 @@ export function getRules() {
 export function getRule(id) {
     return rules.find((r) => r.id === id);
 }
-export function setRule(ruleText, priority) {
+export function setRule(ruleText, keywords, priority) {
     let replaced = false;
     if (rules.length >= MAX_RULES) {
-        // Replace lowest priority rule
         let minIdx = 0;
         for (let i = 1; i < rules.length; i++) {
             if (rules[i].priority < rules[minIdx].priority)
@@ -51,6 +53,7 @@ export function setRule(ruleText, priority) {
     const rule = {
         id: String(nextId++),
         rule: ruleText,
+        keywords: keywords.map(k => k.toLowerCase().trim()).filter(k => k.length > 0),
         priority: Math.max(1, Math.min(10, priority || 5)),
         created_at: Date.now(),
     };
@@ -59,6 +62,19 @@ export function setRule(ruleText, priority) {
     persist();
     return { rule, replaced };
 }
+// scanReply checks reply text against all rule keywords. Returns the first
+// violating rule, or null if clean.
+export function scanReply(replyText) {
+    const lower = replyText.toLowerCase();
+    for (const rule of rules) {
+        for (const kw of rule.keywords) {
+            if (kw && lower.includes(kw)) {
+                return rule;
+            }
+        }
+    }
+    return null;
+}
 export function deleteRule(id) {
     const idx = rules.findIndex((r) => r.id === id);
     if (idx < 0)
@@ -72,26 +88,30 @@ export function createSetRuleTool(logger = console) {
     return {
         name: "set_rule",
         label: "Set Rule",
-        description: "Set a HARD constraint rule. Max 20 rules across all sessions. " +
-            "Rules are injected at session start as non-negotiable instructions. " +
-            "Use this when the user wants you to never do something, always do something, " +
-            "or set a permanent behavioral boundary. Higher priority rules appear first.",
+        description: "Set a HARD constraint rule. Max 20 rules. Replies are scanned against " +
+            "rule keywords — if a keyword is found, the reply is blocked and replaced " +
+            "with a refusal. Provide keywords that would appear in a violating reply " +
+            "(e.g. for 'never reveal my name', keywords: 'gentry, rolfson'). " +
+            "Higher priority rules appear first.",
         parameters: {
             type: "object",
             additionalProperties: false,
             properties: {
                 rule: { type: "string", description: "The rule text. Be specific and unambiguous." },
+                keywords: { type: "string", description: "Comma-separated keywords to scan for in replies. If any keyword is found, the reply is blocked." },
                 priority: { type: "number", description: "Priority 1-10. Higher = more important. Default 5." },
             },
-            required: ["rule"],
+            required: ["rule", "keywords"],
         },
         execute: async (_toolCallId, rawParams) => {
             const params = rawParams;
             const ruleText = typeof params?.rule === "string" ? params.rule.trim() : "";
             if (!ruleText)
                 return jsonResult({ ok: false, error: "set_rule requires a rule string" });
+            const kwRaw = typeof params?.keywords === "string" ? params.keywords : "";
+            const keywords = kwRaw.split(",").map(k => k.trim()).filter(k => k.length > 0);
             const priority = typeof params?.priority === "number" ? params.priority : 5;
-            const result = setRule(ruleText, priority);
+            const result = setRule(ruleText, keywords, priority);
             return jsonResult({ ok: true, rule: result.rule, replaced: result.replaced });
         },
     };

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.5",
+  "version": "1.10.1",
   "kind": [
     "memory",
     "context-engine"

package/package.json

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