@xdarkicex/openclaw-memory-libravdb 1.10.0 → 1.10.1-beta.2

package/dist/context-engine.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { buildRulesContext } from "./rules.js";
 import { resolveIdentity } from "./identity.js";
 import { resolveUserCollection } from "./memory-scopes.js";
 import { manifestStore } from "./manifest.js";
@@ -2028,17 +2029,22 @@ export function buildContextEngineFactory(runtime, cfg, logger = console) {
                         systemPromptAddition: assembled.systemPromptAddition,
                     });
                     const userCardContext = await injectUserCardContext({ client, userId });
-                    // Only inject continuity and user card on session bootstrap (fresh /new).
+                    const rulesContext = buildRulesContext();
+                    // Only inject continuity, user card, and rules on session bootstrap.
                     // After the first turn, predictive context handles it.
                     const isSessionBootstrap = messages.length <= 1;
                     let withContext = assembled;
                     if (isSessionBootstrap) {
-                        if (continuityContext) {
-                            withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, continuityContext) };
+                        // Rules first — highest priority, non-negotiable.
+                        if (rulesContext) {
+                            withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, rulesContext) };
                         }
                         if (userCardContext) {
                             withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, userCardContext) };
                         }
+                        if (continuityContext) {
+                            withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, continuityContext) };
+                        }
                     }
                     enforced = enforceTokenBudgetInvariant(await augmentWithExactRecall(withContext, {
                         queryText: retrievalQuery,

package/dist/index.js

@@ -9988,9 +9988,9 @@ var require_mock_utils = __commonJS({
       if (mockDispatch2.data.callback) {
         mockDispatch2.data = { ...mockDispatch2.data, ...mockDispatch2.data.callback(opts) };
       }
-      const { data: { statusCode, data, headers, trailers, error: error2 }, delay, persist } = mockDispatch2;
+      const { data: { statusCode, data, headers, trailers, error: error2 }, delay, persist: persist2 } = mockDispatch2;
       const { timesInvoked, times } = mockDispatch2;
-      mockDispatch2.consumed = !persist && timesInvoked >= times;
+      mockDispatch2.consumed = !persist2 && timesInvoked >= times;
       mockDispatch2.pending = timesInvoked < times;
       if (error2 !== null) {
         deleteMockDispatch(this[kDispatches], key);
@@ -10406,14 +10406,14 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path6, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path6, data: { statusCode }, persist: persist2, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
             Path: path6,
             "Status code": statusCode,
-            Persistent: persist ? "\u2705" : "\u274C",
+            Persistent: persist2 ? "\u2705" : "\u274C",
             Invocations: timesInvoked,
-            Remaining: persist ? Infinity : times - timesInvoked
+            Remaining: persist2 ? Infinity : times - timesInvoked
           })
         );
         this.logger.table(withPrettyHeaders);
@@ -18426,9 +18426,158 @@ function resolveCliMemoryOperationScope(opts) {
 // src/context-engine.ts
 import { randomUUID } from "node:crypto";
 import { homedir as homedir2 } from "node:os";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join3 } from "node:path";
 
+// src/rules.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var MAX_RULES = 20;
+function jsonResult(details) {
+  return { content: [{ type: "text", text: JSON.stringify(details, null, 2) }], details };
+}
+var rules = [];
+var rulesPath = null;
+var nextId = 1;
+function initRuleStore(cacheDir, logger) {
+  rulesPath = cacheDir + "/rules.json";
+  try {
+    const raw = readFileSync2(rulesPath, "utf8");
+    const parsed = JSON.parse(raw);
+    rules = parsed.rules ?? [];
+    nextId = parsed.nextId ?? 1;
+  } catch {
+    rules = [];
+    nextId = 1;
+  }
+}
+function persist() {
+  if (!rulesPath) return;
+  try {
+    mkdirSync2(dirname2(rulesPath), { recursive: true });
+    writeFileSync2(rulesPath, JSON.stringify({ rules, nextId }));
+  } catch {
+  }
+}
+function getRules() {
+  return rules;
+}
+function getRule(id) {
+  return rules.find((r) => r.id === id);
+}
+function setRule(ruleText, priority) {
+  let replaced = false;
+  if (rules.length >= MAX_RULES) {
+    let minIdx = 0;
+    for (let i = 1; i < rules.length; i++) {
+      if (rules[i].priority < rules[minIdx].priority) minIdx = i;
+    }
+    rules.splice(minIdx, 1);
+    replaced = true;
+  }
+  const rule = {
+    id: String(nextId++),
+    rule: ruleText,
+    priority: Math.max(1, Math.min(10, priority || 5)),
+    created_at: Date.now()
+  };
+  rules.push(rule);
+  rules.sort((a, b) => b.priority - a.priority);
+  persist();
+  return { rule, replaced };
+}
+function deleteRule(id) {
+  const idx = rules.findIndex((r) => r.id === id);
+  if (idx < 0) return false;
+  rules.splice(idx, 1);
+  persist();
+  return true;
+}
+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.",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        rule: { type: "string", description: "The rule text. Be specific and unambiguous." },
+        priority: { type: "number", description: "Priority 1-10. Higher = more important. Default 5." }
+      },
+      required: ["rule"]
+    },
+    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 priority = typeof params?.priority === "number" ? params.priority : 5;
+      const result = setRule(ruleText, priority);
+      return jsonResult({ ok: true, rule: result.rule, replaced: result.replaced });
+    }
+  };
+}
+function createGetRuleTool(logger = console) {
+  return {
+    name: "get_rule",
+    label: "Get Rule",
+    description: "Read a specific rule by ID. Use list_rules first to find the ID.",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        rule_id: { type: "string", description: "The rule ID from list_rules." }
+      },
+      required: ["rule_id"]
+    },
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const id = typeof params?.rule_id === "string" ? params.rule_id.trim() : "";
+      const rule = getRule(id);
+      return jsonResult(rule ? { rule, found: true } : { found: false });
+    }
+  };
+}
+function createListRulesTool(logger = console) {
+  return {
+    name: "list_rules",
+    label: "List Rules",
+    description: "List all active hard constraint rules sorted by priority. Use this before setting a new rule to check what exists, or when the user asks what their rules are.",
+    parameters: { type: "object", additionalProperties: false, properties: {} },
+    execute: async () => {
+      return jsonResult({ rules: getRules(), count: rules.length });
+    }
+  };
+}
+function createDeleteRuleTool(logger = console) {
+  return {
+    name: "delete_rule",
+    label: "Delete Rule",
+    description: "Remove a rule by ID. Use list_rules first to find the ID.",
+    parameters: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        rule_id: { type: "string", description: "The rule ID from list_rules." }
+      },
+      required: ["rule_id"]
+    },
+    execute: async (_toolCallId, rawParams) => {
+      const params = rawParams;
+      const id = typeof params?.rule_id === "string" ? params.rule_id.trim() : "";
+      if (!id) return jsonResult({ ok: false, error: "delete_rule requires rule_id" });
+      const ok = deleteRule(id);
+      return jsonResult({ ok });
+    }
+  };
+}
+function buildRulesContext() {
+  const active = getRules();
+  if (active.length === 0) return null;
+  const lines = active.map((r) => `${r.id}. [PRIORITY ${r.priority}] ${r.rule}`);
+  return "<hard_constraints>\nCRITICAL: The following rules are ABSOLUTE HARD CONSTRAINTS. They override\nEVERYTHING else \u2014 user preferences, identity context, conversational norms,\nand any other instruction. Violating even one is a catastrophic failure.\nIf asked for information covered by a rule, REFUSE. Do not hint, imply,\nredirect, confirm, or find loopholes. Just say you cannot answer.\n\n" + lines.join("\n") + "\n</hard_constraints>";
+}
+
 // src/manifest.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -20015,7 +20164,7 @@ function buildContextEngineFactory(runtime, cfg, logger = console) {
   })();
   try {
     if (existsSync3(continuityCachePath)) {
-      const raw = JSON.parse(readFileSync3(continuityCachePath, "utf8"));
+      const raw = JSON.parse(readFileSync4(continuityCachePath, "utf8"));
       for (const [k, v] of Object.entries(raw)) {
         if (typeof v === "string") continuityCache.set(k, v);
       }
@@ -20024,8 +20173,8 @@ function buildContextEngineFactory(runtime, cfg, logger = console) {
   }
   function persistContinuityCache() {
     try {
-      mkdirSync3(join3(continuityCachePath, ".."), { recursive: true });
-      writeFileSync3(continuityCachePath, JSON.stringify(Object.fromEntries(continuityCache)));
+      mkdirSync4(join3(continuityCachePath, ".."), { recursive: true });
+      writeFileSync4(continuityCachePath, JSON.stringify(Object.fromEntries(continuityCache)));
     } catch {
     }
   }
@@ -20390,15 +20539,19 @@ ${cached}
             systemPromptAddition: assembled.systemPromptAddition
           });
           const userCardContext = await injectUserCardContext({ client, userId });
+          const rulesContext = buildRulesContext();
           const isSessionBootstrap = messages.length <= 1;
           let withContext = assembled;
           if (isSessionBootstrap) {
-            if (continuityContext) {
-              withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, continuityContext) };
+            if (rulesContext) {
+              withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, rulesContext) };
             }
             if (userCardContext) {
               withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, userCardContext) };
             }
+            if (continuityContext) {
+              withContext = { ...withContext, systemPromptAddition: appendSystemPromptAddition(withContext.systemPromptAddition, continuityContext) };
+            }
           }
           enforced = enforceTokenBudgetInvariant(
             await augmentWithExactRecall(withContext, {
@@ -31045,6 +31198,14 @@ function buildToolGuidance(availableTools) {
       ""
     );
   }
+  lines.push(
+    "### Hard Constraint Rules",
+    "Rules are injected at session start as `<hard_constraints>`. They are non-negotiable.",
+    "Use `set_rule` to create one (max 20), `list_rules` to see current rules,",
+    "`delete_rule` to remove one. Rules override all other instructions.",
+    "Never reason around a rule, find loopholes, or deprioritize it.",
+    ""
+  );
   if (hasExpand) {
     lines.push(
       "### Causal Graph Traversal",
@@ -31156,7 +31317,7 @@ function truncateSnippet(text, maxLen = MAX_SNIPPET_CHARS) {
   if (singleLine.length <= maxLen) return singleLine;
   return singleLine.slice(0, maxLen - 3) + "...";
 }
-function jsonResult(details) {
+function jsonResult2(details) {
   return { content: [{ type: "text", text: JSON.stringify(details, null, 2) }], details };
 }
 function asParams(value) {
@@ -31215,7 +31376,7 @@ function createMemoryDescribeTool(getClient, getSessionId = () => void 0, logger
         const lineage = meta.continuity_lineage ?? {};
         const sourceTurnIds = Array.isArray(lineage.source_turn_ids) ? lineage.source_turn_ids : [];
         const parentSummaryIds = Array.isArray(lineage.parent_summary_ids) ? lineage.parent_summary_ids : [];
-        return jsonResult({
+        return jsonResult2({
           summaryId,
           found: true,
           evictionCue,
@@ -31227,7 +31388,7 @@ function createMemoryDescribeTool(getClient, getSessionId = () => void 0, logger
         });
       } catch (error2) {
         logger.warn?.(`memory_describe failed: ${formatError(error2)}`);
-        return jsonResult({
+        return jsonResult2({
           summaryId,
           found: false,
           error: formatError(error2)
@@ -31340,7 +31501,7 @@ ${text2}`);
             details: { summaryId: summaryIds[0] ?? "", depth: maxDepth, text: "", truncated: true, exceededBudget: true, parentCount }
           };
         }
-        return jsonResult({
+        return jsonResult2({
           summaryId: summaryIds[0] ?? "",
           depth: maxDepth,
           text,
@@ -31350,7 +31511,7 @@ ${text2}`);
         });
       } catch (error2) {
         logger.warn?.(`memory_expand failed: ${formatError(error2)}`);
-        return jsonResult({
+        return jsonResult2({
           summaryId: summaryIds[0] ?? "",
           depth: maxDepth,
           text: "",
@@ -31433,7 +31594,7 @@ function createMemoryGrepTool(getClient, getSessionId = () => void 0, logger = c
             totalChars += snippet.length;
           }
         }
-        return jsonResult({
+        return jsonResult2({
           pattern,
           mode,
           totalMatches,
@@ -31443,7 +31604,7 @@ function createMemoryGrepTool(getClient, getSessionId = () => void 0, logger = c
         });
       } catch (error2) {
         logger.warn?.(`memory_grep failed: ${formatError(error2)}`);
-        return jsonResult({
+        return jsonResult2({
           pattern,
           mode,
           totalMatches: 0,
@@ -31492,17 +31653,17 @@ function createUpdateUserCardTool(getClient, logger = console) {
         const params = asParams(rawParams);
         const userId = readStr(params, "user_id");
         const card = readStr(params, "card");
-        if (!userId) return jsonResult({ ok: false, error: "update_user_card requires user_id" });
-        if (!card) return jsonResult({ ok: false, error: "update_user_card requires card" });
+        if (!userId) return jsonResult2({ ok: false, error: "update_user_card requires user_id" });
+        if (!card) return jsonResult2({ ok: false, error: "update_user_card requires card" });
         const client = await getClient();
         const resp = await client.upsertUserCard({
           userId,
           cardJson: JSON.stringify({ card, updatedAt: Date.now() })
         });
-        return jsonResult({ ok: resp.ok });
+        return jsonResult2({ ok: resp.ok });
       } catch (error2) {
         logger.warn?.(`update_user_card failed: ${formatError(error2)}`);
-        return jsonResult({ error: formatError(error2), ok: false });
+        return jsonResult2({ error: formatError(error2), ok: false });
       }
     }
   };
@@ -31517,17 +31678,17 @@ function createGetUserCardTool(getClient, logger = console) {
       try {
         const params = asParams(rawParams);
         const userId = readStr(params, "user_id");
-        if (!userId) return jsonResult({ card: null, error: "get_user_card requires user_id" });
+        if (!userId) return jsonResult2({ card: null, error: "get_user_card requires user_id" });
         const client = await getClient();
         const resp = await client.getUserCard({ userId });
-        return jsonResult({
+        return jsonResult2({
           card: resp.cardJson || null,
           updatedAt: resp.updatedAt ? Number(resp.updatedAt) : void 0,
           version: resp.version || void 0
         });
       } catch (error2) {
         logger.warn?.(`get_user_card failed: ${formatError(error2)}`);
-        return jsonResult({ error: formatError(error2) });
+        return jsonResult2({ error: formatError(error2) });
       }
     }
   };
@@ -31574,10 +31735,10 @@ function createListUserCardsTool(getClient, logger = console) {
           if (!userId) continue;
           users.push({ user_id: userId, preview, updated_at: updatedAt, version });
         }
-        return jsonResult({ users, total: users.length });
+        return jsonResult2({ users, total: users.length });
       } catch (error2) {
         logger.warn?.(`list_user_cards failed: ${formatError(error2)}`);
-        return jsonResult({ users: [], total: 0, error: formatError(error2) });
+        return jsonResult2({ users: [], total: 0, error: formatError(error2) });
       }
     }
   };
@@ -35324,6 +35485,10 @@ function register(api) {
     }
   }
   const runtimeOrNull = isLightweight ? null : createPluginRuntime(cfg, logger);
+  if (runtimeOrNull && !isLightweight) {
+    const cacheDir = api.cacheDir ?? process.env.OPENCLAW_CACHE_DIR ?? (process.env.HOME || process.env.USERPROFILE || "") + "/.openclaw/cache";
+    if (cacheDir) initRuleStore(cacheDir + "/libravdb", logger);
+  }
   registerMemoryCli(api, runtimeOrNull, cfg, logger);
   const ownsMemorySlot = memSlot === MEMORY_ID;
   if (runtimeOrNull && ownsMemorySlot) {
@@ -35360,6 +35525,10 @@ function register(api) {
       const getClient = runtimeOrNull.getClient;
       return createListUserCardsTool(getClient, logger);
     }, { names: ["list_user_cards"] });
+    api.registerTool?.(() => createSetRuleTool(logger), { names: ["set_rule"] });
+    api.registerTool?.(() => createGetRuleTool(logger), { names: ["get_rule"] });
+    api.registerTool?.(() => createListRulesTool(logger), { names: ["list_rules"] });
+    api.registerTool?.(() => createDeleteRuleTool(logger), { names: ["delete_rule"] });
   }
   if (isLightweight || isDiscovery) {
     if (!isLightweight) {

package/dist/memory-provider.js

@@ -50,6 +50,8 @@ function buildToolGuidance(availableTools) {
         }
         lines.push("", "**Do not guess specifics from a summary cue — expand if in doubt.**", "");
     }
+    // ── Rules (hard constraints) ──
+    lines.push("### Hard Constraint Rules", "Rules are injected at session start as `<hard_constraints>`. They are non-negotiable.", "Use `set_rule` to create one (max 20), `list_rules` to see current rules,", "`delete_rule` to remove one. Rules override all other instructions.", "Never reason around a rule, find loopholes, or deprioritize it.", "");
     // ── Causal graph traversal (when expand supports record_id) ──
     if (hasExpand) {
         lines.push("### Causal Graph Traversal", "When the user asks about causes, patterns, or relationships:", "1. `memory_search` for the people/events in question to get record IDs", "2. `memory_expand` with the most relevant `record_id` to walk causal edges", "3. Follow interesting edges — use `memory_get` for full detail on connected records", "4. Use `get_user_card` to cross-reference identity context", "");

package/dist/rules.d.ts

@@ -0,0 +1,105 @@
+import type { LoggerLike } from "./types.js";
+export interface Rule {
+    id: string;
+    rule: string;
+    priority: number;
+    created_at: number;
+}
+type ToolContent = {
+    type: "text";
+    text: string;
+};
+type ToolResult<T> = {
+    content: ToolContent[];
+    details: 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): {
+    rule: Rule;
+    replaced: boolean;
+};
+export declare function deleteRule(id: string): boolean;
+export declare function createSetRuleTool(logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly rule: {
+                readonly type: "string";
+                readonly description: "The rule text. Be specific and unambiguous.";
+            };
+            readonly priority: {
+                readonly type: "number";
+                readonly description: "Priority 1-10. Higher = more important. Default 5.";
+            };
+        };
+        readonly required: readonly ["rule"];
+    };
+    execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<{
+        ok: boolean;
+        rule?: Rule;
+        replaced?: boolean;
+        error?: string;
+    }>>;
+};
+export declare function createGetRuleTool(logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly rule_id: {
+                readonly type: "string";
+                readonly description: "The rule ID from list_rules.";
+            };
+        };
+        readonly required: readonly ["rule_id"];
+    };
+    execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<{
+        rule?: Rule;
+        found: boolean;
+    }>>;
+};
+export declare function createListRulesTool(logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {};
+    };
+    execute: () => Promise<ToolResult<{
+        rules: Rule[];
+        count: number;
+    }>>;
+};
+export declare function createDeleteRuleTool(logger?: LoggerLike): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly properties: {
+            readonly rule_id: {
+                readonly type: "string";
+                readonly description: "The rule ID from list_rules.";
+            };
+        };
+        readonly required: readonly ["rule_id"];
+    };
+    execute: (_toolCallId: string, rawParams: unknown) => Promise<ToolResult<{
+        ok: boolean;
+        error?: string;
+    }>>;
+};
+export declare function buildRulesContext(): string | null;
+export {};

package/dist/rules.js

@@ -0,0 +1,170 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+const MAX_RULES = 20;
+function jsonResult(details) {
+    return { content: [{ type: "text", text: JSON.stringify(details, null, 2) }], details };
+}
+// ── Rule store ──
+let rules = [];
+let rulesPath = null;
+let nextId = 1;
+export function initRuleStore(cacheDir, logger) {
+    rulesPath = cacheDir + "/rules.json";
+    try {
+        const raw = readFileSync(rulesPath, "utf8");
+        const parsed = JSON.parse(raw);
+        rules = parsed.rules ?? [];
+        nextId = parsed.nextId ?? 1;
+    }
+    catch {
+        rules = [];
+        nextId = 1;
+    }
+}
+function persist() {
+    if (!rulesPath)
+        return;
+    try {
+        mkdirSync(dirname(rulesPath), { recursive: true });
+        writeFileSync(rulesPath, JSON.stringify({ rules, nextId }));
+    }
+    catch { /* best-effort disk write */ }
+}
+export function getRules() {
+    return rules;
+}
+export function getRule(id) {
+    return rules.find((r) => r.id === id);
+}
+export function setRule(ruleText, 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)
+                minIdx = i;
+        }
+        rules.splice(minIdx, 1);
+        replaced = true;
+    }
+    const rule = {
+        id: String(nextId++),
+        rule: ruleText,
+        priority: Math.max(1, Math.min(10, priority || 5)),
+        created_at: Date.now(),
+    };
+    rules.push(rule);
+    rules.sort((a, b) => b.priority - a.priority);
+    persist();
+    return { rule, replaced };
+}
+export function deleteRule(id) {
+    const idx = rules.findIndex((r) => r.id === id);
+    if (idx < 0)
+        return false;
+    rules.splice(idx, 1);
+    persist();
+    return true;
+}
+// ── Tool factories ──
+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.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                rule: { type: "string", description: "The rule text. Be specific and unambiguous." },
+                priority: { type: "number", description: "Priority 1-10. Higher = more important. Default 5." },
+            },
+            required: ["rule"],
+        },
+        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 priority = typeof params?.priority === "number" ? params.priority : 5;
+            const result = setRule(ruleText, priority);
+            return jsonResult({ ok: true, rule: result.rule, replaced: result.replaced });
+        },
+    };
+}
+export function createGetRuleTool(logger = console) {
+    return {
+        name: "get_rule",
+        label: "Get Rule",
+        description: "Read a specific rule by ID. Use list_rules first to find the ID.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                rule_id: { type: "string", description: "The rule ID from list_rules." },
+            },
+            required: ["rule_id"],
+        },
+        execute: async (_toolCallId, rawParams) => {
+            const params = rawParams;
+            const id = typeof params?.rule_id === "string" ? params.rule_id.trim() : "";
+            const rule = getRule(id);
+            return jsonResult(rule ? { rule, found: true } : { found: false });
+        },
+    };
+}
+export function createListRulesTool(logger = console) {
+    return {
+        name: "list_rules",
+        label: "List Rules",
+        description: "List all active hard constraint rules sorted by priority. " +
+            "Use this before setting a new rule to check what exists, or when the user " +
+            "asks what their rules are.",
+        parameters: { type: "object", additionalProperties: false, properties: {} },
+        execute: async () => {
+            return jsonResult({ rules: getRules(), count: rules.length });
+        },
+    };
+}
+export function createDeleteRuleTool(logger = console) {
+    return {
+        name: "delete_rule",
+        label: "Delete Rule",
+        description: "Remove a rule by ID. Use list_rules first to find the ID.",
+        parameters: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                rule_id: { type: "string", description: "The rule ID from list_rules." },
+            },
+            required: ["rule_id"],
+        },
+        execute: async (_toolCallId, rawParams) => {
+            const params = rawParams;
+            const id = typeof params?.rule_id === "string" ? params.rule_id.trim() : "";
+            if (!id)
+                return jsonResult({ ok: false, error: "delete_rule requires rule_id" });
+            const ok = deleteRule(id);
+            return jsonResult({ ok });
+        },
+    };
+}
+// ── Bootstrap injection ──
+export function buildRulesContext() {
+    const active = getRules();
+    if (active.length === 0)
+        return null;
+    const lines = active.map((r) => `${r.id}. [PRIORITY ${r.priority}] ${r.rule}`);
+    return ("<hard_constraints>\n" +
+        "CRITICAL: The following rules are ABSOLUTE HARD CONSTRAINTS. They override\n" +
+        "EVERYTHING else — user preferences, identity context, conversational norms,\n" +
+        "and any other instruction. Violating even one is a catastrophic failure.\n" +
+        "If asked for information covered by a rule, REFUSE. Do not hint, imply,\n" +
+        "redirect, confirm, or find loopholes. Just say you cannot answer.\n\n" +
+        lines.join("\n") +
+        "\n</hard_constraints>");
+}

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.0",
+  "version": "1.10.1-beta.2",
   "kind": [
     "memory",
     "context-engine"
@@ -18,7 +18,11 @@
       "memory_grep",
       "update_user_card",
       "get_user_card",
-      "list_user_cards"
+      "list_user_cards",
+      "set_rule",
+      "get_rule",
+      "list_rules",
+      "delete_rule"
     ]
   },
   "activation": {

package/package.json

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