@joshuaswarren/openclaw-engram 8.3.39 → 8.3.41

package/dist/index.js

@@ -320,6 +320,8 @@ function parseConfig(raw) {
     autoPromoteToSharedEnabled: cfg.autoPromoteToSharedEnabled === true,
     autoPromoteToSharedCategories: Array.isArray(cfg.autoPromoteToSharedCategories) ? cfg.autoPromoteToSharedCategories.filter((c) => c === "correction" || c === "decision" || c === "preference") : ["correction", "decision", "preference"],
     autoPromoteMinConfidenceTier: cfg.autoPromoteMinConfidenceTier === "explicit" ? "explicit" : cfg.autoPromoteMinConfidenceTier === "implied" ? "implied" : "explicit",
+    routingRulesEnabled: cfg.routingRulesEnabled === true,
+    routingRulesStateFile: typeof cfg.routingRulesStateFile === "string" && cfg.routingRulesStateFile.trim().length > 0 ? cfg.routingRulesStateFile.trim() : "state/routing-rules.json",
     // v4.0 shared-context (default off)
     sharedContextEnabled: cfg.sharedContextEnabled === true,
     sharedContextDir: typeof cfg.sharedContextDir === "string" && cfg.sharedContextDir.length > 0 ? cfg.sharedContextDir : void 0,
@@ -17301,8 +17303,8 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path39 from "path";
-import { access as access2, readFile as readFile28, readdir as readdir17, unlink as unlink5 } from "fs/promises";
+import path40 from "path";
+import { access as access2, readFile as readFile29, readdir as readdir17, unlink as unlink5 } from "fs/promises";
 
 // src/transfer/export-json.ts
 import path27 from "path";
@@ -18181,8 +18183,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path41 = typeof record.path === "string" ? record.path : "";
-      if (!path41.startsWith("transcripts/") && !path41.includes("/transcripts/")) continue;
+      const path42 = typeof record.path === "string" ? record.path : "";
+      if (!path42.startsWith("transcripts/") && !path42.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -18650,6 +18652,359 @@ async function migrateObservations(options) {
   };
 }
 
+// src/routing/engine.ts
+var DEFAULT_CATEGORIES = [
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill"
+];
+function normalizeNamespace(namespace) {
+  return namespace.trim();
+}
+function isLikelyUnsafeRegex(pattern) {
+  const value = pattern.trim();
+  if (value.length === 0) return true;
+  if (value.length > 120) return true;
+  if (/\\[1-9]/.test(value)) return true;
+  if (/\(\?<?[=!]/.test(value)) return true;
+  if (/\((?:[^()\\]|\\.)*[+*](?:[^()\\]|\\.)*\)[+*{]/.test(value)) return true;
+  if (/(^|[^\\])[()|]/.test(value)) return true;
+  const quantifierCount = (value.match(/(^|[^\\])[*+?]/g)?.length ?? 0) + (value.match(/(^|[^\\])\{/g)?.length ?? 0);
+  if (quantifierCount > 1) return true;
+  return false;
+}
+function isSafeRouteNamespace(namespace) {
+  const value = normalizeNamespace(namespace);
+  if (value.length === 0) return false;
+  if (value === ".") return false;
+  if (value.includes("/") || value.includes("\\")) return false;
+  if (value.includes("..")) return false;
+  return /^[A-Za-z0-9._-]{1,64}$/.test(value);
+}
+function validateRouteTarget(target, options) {
+  if (!target || typeof target !== "object") {
+    return { ok: false, error: "target must be an object" };
+  }
+  const allowedCategories = new Set(options?.allowedCategories ?? DEFAULT_CATEGORIES);
+  const allowedNamespaces = options?.allowedNamespaces ? new Set(options.allowedNamespaces.map((v) => v.trim()).filter((v) => v.length > 0)) : null;
+  const normalized = {};
+  if (typeof target.category === "string") {
+    if (!allowedCategories.has(target.category)) {
+      return { ok: false, error: `invalid category: ${target.category}` };
+    }
+    normalized.category = target.category;
+  }
+  if (typeof target.namespace === "string") {
+    const namespace = normalizeNamespace(target.namespace);
+    if (!isSafeRouteNamespace(namespace)) {
+      return { ok: false, error: `invalid namespace: ${target.namespace}` };
+    }
+    if (allowedNamespaces && !allowedNamespaces.has(namespace)) {
+      return { ok: false, error: `namespace not allowed: ${namespace}` };
+    }
+    normalized.namespace = namespace;
+  }
+  if (!normalized.category && !normalized.namespace) {
+    return { ok: false, error: "target must include category or namespace" };
+  }
+  return { ok: true, target: normalized };
+}
+function doesRuleMatch(rule, text) {
+  if (!rule || typeof rule !== "object") return false;
+  if (rule.enabled === false) return false;
+  if (typeof rule.pattern !== "string") return false;
+  const pattern = rule.pattern.trim();
+  if (pattern.length === 0) return false;
+  if (rule.patternType === "keyword") {
+    return text.toLowerCase().includes(pattern.toLowerCase());
+  }
+  if (rule.patternType !== "regex") {
+    return false;
+  }
+  if (isLikelyUnsafeRegex(pattern)) {
+    return false;
+  }
+  try {
+    return new RegExp(pattern, "i").test(text);
+  } catch {
+    return false;
+  }
+}
+function selectRouteRule(text, rules, options) {
+  const ranked = rules.map((rule, index) => ({ rule, index })).sort((a, b) => {
+    if (b.rule.priority !== a.rule.priority) return b.rule.priority - a.rule.priority;
+    return a.index - b.index;
+  });
+  for (const entry of ranked) {
+    if (!doesRuleMatch(entry.rule, text)) continue;
+    const validation = validateRouteTarget(entry.rule.target, options);
+    if (!validation.ok || !validation.target) continue;
+    return {
+      rule: entry.rule,
+      target: validation.target
+    };
+  }
+  return null;
+}
+
+// src/routing/store.ts
+import { lstat, mkdir as mkdir28, readFile as readFile28, realpath, rename as rename2, rm as rm4, stat as stat7, writeFile as writeFile25 } from "fs/promises";
+import path39 from "path";
+import { createHash as createHash7 } from "crypto";
+function defaultState() {
+  return {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    rules: []
+  };
+}
+function stableRuleId(rule) {
+  const seed = JSON.stringify({
+    patternType: rule.patternType,
+    pattern: rule.pattern.trim(),
+    priority: rule.priority,
+    target: rule.target
+  });
+  return `route-${createHash7("sha256").update(seed).digest("hex").slice(0, 12)}`;
+}
+function resolveStatePath(memoryDir, stateFile) {
+  const root = path39.resolve(memoryDir);
+  const defaultPath = path39.join(root, "state", "routing-rules.json");
+  if (path39.isAbsolute(stateFile)) {
+    const absolute = path39.resolve(stateFile);
+    return absolute.startsWith(root + path39.sep) ? absolute : defaultPath;
+  }
+  const resolved = path39.resolve(root, stateFile);
+  return resolved.startsWith(root + path39.sep) ? resolved : defaultPath;
+}
+function normalizeRule(rule, options) {
+  if (!rule || typeof rule !== "object") return null;
+  if (rule.enabled === false) return null;
+  if (rule.patternType !== "keyword" && rule.patternType !== "regex") return null;
+  if (typeof rule.pattern !== "string" || rule.pattern.trim().length === 0) return null;
+  if (typeof rule.priority !== "number" || !Number.isFinite(rule.priority)) return null;
+  const targetValidation = validateRouteTarget(rule.target, options);
+  if (!targetValidation.ok || !targetValidation.target) return null;
+  const normalizedPriority = Math.trunc(rule.priority);
+  const normalizedTarget = targetValidation.target;
+  const id = typeof rule.id === "string" && rule.id.trim().length > 0 ? rule.id.trim() : stableRuleId({
+    patternType: rule.patternType,
+    pattern: rule.pattern.trim(),
+    priority: normalizedPriority,
+    target: normalizedTarget
+  });
+  return {
+    id,
+    patternType: rule.patternType,
+    pattern: rule.pattern.trim(),
+    priority: normalizedPriority,
+    target: normalizedTarget,
+    enabled: true
+  };
+}
+var RoutingRulesStore = class {
+  memoryRoot;
+  statePath;
+  lockPath;
+  writeQueue = Promise.resolve();
+  constructor(memoryDir, stateFile = "state/routing-rules.json") {
+    this.memoryRoot = path39.resolve(memoryDir);
+    this.statePath = resolveStatePath(memoryDir, stateFile);
+    this.lockPath = `${this.statePath}.lock`;
+  }
+  async read(options) {
+    try {
+      const persisted = await this.readPersistedRules();
+      return persisted.map((rule) => normalizeRule(rule, options)).filter((rule) => rule !== null);
+    } catch {
+      return [];
+    }
+  }
+  async write(rules, options) {
+    return this.withWriteLock(async () => this.writeNormalized(rules, options));
+  }
+  async upsert(rule, options) {
+    return this.withWriteLock(async () => {
+      const existing = await this.readPersistedRules();
+      const normalized = normalizeRule(rule, options);
+      if (!normalized) return existing;
+      const next = existing.filter((entry) => entry.id !== normalized.id);
+      next.push(normalized);
+      return this.writeNormalized(next);
+    });
+  }
+  async removeByPattern(pattern) {
+    return this.withWriteLock(async () => {
+      const trimmed = pattern.trim();
+      const existing = await this.readPersistedRules();
+      const next = existing.filter((entry) => entry.pattern !== trimmed);
+      if (next.length === existing.length) return existing;
+      return this.writeNormalized(next);
+    });
+  }
+  async reset() {
+    await this.withWriteLock(async () => {
+      const payload = defaultState();
+      await this.assertStatePathScoped();
+      await writeFile25(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+    });
+  }
+  dedupeById(rules) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const rule of rules) {
+      byId.set(rule.id, rule);
+    }
+    return Array.from(byId.values());
+  }
+  async readPersistedRules() {
+    try {
+      await this.assertStatePathScoped();
+      const raw = await readFile28(this.statePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.rules)) return [];
+      const normalized = parsed.rules.map((rule) => normalizeRule(rule)).filter((rule) => rule !== null);
+      return this.dedupeById(normalized);
+    } catch {
+      return [];
+    }
+  }
+  async writeNormalized(rules, options) {
+    const normalized = this.dedupeById(
+      rules.map((rule) => normalizeRule(rule, options)).filter((rule) => rule !== null)
+    );
+    const payload = {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      rules: normalized
+    };
+    const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+      await this.assertStatePathScoped();
+      await writeFile25(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+      await rename2(tmpPath, this.statePath);
+    } catch (err) {
+      log.debug(`routing rules write failed: ${err}`);
+      throw err;
+    } finally {
+      await rm4(tmpPath, { force: true }).catch(() => {
+      });
+    }
+    return normalized;
+  }
+  async withWriteLock(op) {
+    const previous = this.writeQueue;
+    let release = () => {
+    };
+    this.writeQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    let unlock = null;
+    try {
+      unlock = await this.acquireFileLock();
+      return await op();
+    } finally {
+      if (unlock) await unlock();
+      release();
+    }
+  }
+  async acquireFileLock() {
+    const start = Date.now();
+    const staleMs = 3e4;
+    const timeoutMs = 5e3;
+    let unexpectedLockError = null;
+    await this.assertStatePathScoped();
+    await mkdir28(path39.dirname(this.lockPath), { recursive: true });
+    while (Date.now() - start < timeoutMs) {
+      try {
+        await mkdir28(this.lockPath);
+        return async () => {
+          try {
+            await rm4(this.lockPath, { recursive: true, force: true });
+          } catch {
+          }
+        };
+      } catch (err) {
+        const code = err.code;
+        if (code !== "EEXIST") {
+          unexpectedLockError = err;
+          break;
+        }
+        try {
+          const lockStat = await stat7(this.lockPath);
+          if (Date.now() - lockStat.mtimeMs > staleMs) {
+            await rm4(this.lockPath, { recursive: true, force: true });
+            continue;
+          }
+        } catch {
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    if (unexpectedLockError) {
+      throw unexpectedLockError;
+    }
+    throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);
+  }
+  async assertStatePathScoped() {
+    await mkdir28(this.memoryRoot, { recursive: true });
+    const canonicalRoot = await realpath(this.memoryRoot);
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path39.dirname(this.statePath));
+    const canonicalStatePath = path39.join(canonicalParent, path39.basename(this.statePath));
+    if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
+      throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
+    }
+    await mkdir28(path39.dirname(this.statePath), { recursive: true });
+    try {
+      const stateStats = await lstat(this.statePath);
+      if (stateStats.isSymbolicLink()) {
+        const canonicalFile = await realpath(this.statePath);
+        if (!this.isPathInside(canonicalRoot, canonicalFile)) {
+          throw new Error(`routing rules state symlink escaped memoryDir: ${canonicalFile}`);
+        }
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  isPathInside(root, candidate) {
+    const normalizedRoot = path39.resolve(root);
+    const normalizedCandidate = path39.resolve(candidate);
+    return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(`${normalizedRoot}${path39.sep}`);
+  }
+  async canonicalizePathWithoutCreating(targetPath) {
+    const absoluteTarget = path39.resolve(targetPath);
+    let probe = absoluteTarget;
+    while (true) {
+      try {
+        const canonicalProbe = await realpath(probe);
+        const remainder = path39.relative(probe, absoluteTarget);
+        return path39.resolve(canonicalProbe, remainder);
+      } catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+          throw err;
+        }
+        const parent = path39.dirname(probe);
+        if (parent === probe) {
+          return absoluteTarget;
+        }
+        probe = parent;
+      }
+    }
+  }
+};
+
 // src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -18699,6 +19054,37 @@ function planExactDuplicateDeletions(memories) {
 function planAggressiveDuplicateDeletions(memories) {
   return buildDedupePlan(memories, (memory) => normalizeAggressiveBody(memory.content));
 }
+function isRoutePatternType(value) {
+  return value === "keyword" || value === "regex";
+}
+function parseRouteTargetCliArg(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) throw new Error("missing target");
+  if (trimmed.startsWith("{")) {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object") throw new Error("invalid target JSON");
+    return parsed;
+  }
+  const target = {};
+  for (const token of trimmed.split(",")) {
+    const part = token.trim();
+    if (part.length === 0) continue;
+    const normalized = part.replace(":", "=");
+    const [rawKey, ...rawValueParts] = normalized.split("=");
+    if (!rawKey || rawValueParts.length === 0) continue;
+    const key = rawKey.trim().toLowerCase();
+    const value = rawValueParts.join("=").trim();
+    if (value.length === 0) continue;
+    if (key === "category") {
+      target.category = value;
+      continue;
+    }
+    if (key === "namespace") {
+      target.namespace = value;
+    }
+  }
+  return target;
+}
 function normalizeNullableCliValue(value) {
   if (value === void 0) return void 0;
   const trimmed = value.trim();
@@ -18744,6 +19130,49 @@ async function runMigrateObservationsCliCommand(options) {
     now: options.now
   });
 }
+async function runRouteCliCommand(options) {
+  const store = new RoutingRulesStore(options.memoryDir, options.stateFile);
+  if (options.action === "list") {
+    const rules = await store.read();
+    return [...rules].sort((a, b) => {
+      if (b.priority !== a.priority) return b.priority - a.priority;
+      return a.pattern.localeCompare(b.pattern);
+    });
+  }
+  if (options.action === "add") {
+    const pattern = options.pattern?.trim();
+    if (!pattern) throw new Error("missing pattern");
+    if (!options.targetRaw || options.targetRaw.trim().length === 0) throw new Error("missing target");
+    const patternType = options.patternType ?? "keyword";
+    if (!isRoutePatternType(patternType)) throw new Error(`invalid route pattern type: ${patternType}`);
+    const priority = options.priority ?? 0;
+    if (!Number.isFinite(priority)) throw new Error("invalid priority");
+    const target = parseRouteTargetCliArg(options.targetRaw);
+    const validation = validateRouteTarget(target);
+    if (!validation.ok || !validation.target) throw new Error(validation.error ?? "invalid target");
+    const rule = {
+      id: options.id?.trim() || "",
+      patternType,
+      pattern,
+      priority: Math.trunc(priority),
+      target: validation.target,
+      enabled: true
+    };
+    return store.upsert(rule);
+  }
+  if (options.action === "remove") {
+    const pattern = options.pattern?.trim();
+    if (!pattern) throw new Error("missing pattern");
+    return store.removeByPattern(pattern);
+  }
+  if (options.action === "test") {
+    const text = options.text?.trim();
+    if (!text) throw new Error("missing text");
+    const rules = await store.read();
+    return selectRouteRule(text, rules);
+  }
+  throw new Error(`unsupported route action: ${options.action}`);
+}
 async function runWorkTaskCliCommand(options) {
   const storage = new WorkStorage(options.memoryDir);
   if (options.action === "create") {
@@ -18881,7 +19310,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile28(options.inputPath, "utf-8");
+  const inputRaw = await readFile29(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -18946,7 +19375,7 @@ async function runReplayCliCommand(orchestrator, options) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile28(pkgPath, "utf-8");
+    const raw = await readFile29(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -18965,14 +19394,14 @@ async function resolveMemoryDirForNamespace(orchestrator, namespace) {
   const ns = (namespace ?? "").trim();
   if (!ns) return orchestrator.config.memoryDir;
   if (!orchestrator.config.namespacesEnabled) return orchestrator.config.memoryDir;
-  const candidate = path39.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path40.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists2(candidate) ? candidate : orchestrator.config.memoryDir;
   }
   return candidate;
 }
 async function readAllMemoryFiles(memoryDir) {
-  const roots = [path39.join(memoryDir, "facts"), path39.join(memoryDir, "corrections")];
+  const roots = [path40.join(memoryDir, "facts"), path40.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -18983,14 +19412,14 @@ async function readAllMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path39.join(dir, entryName);
+      const fullPath = path40.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile28(fullPath, "utf-8");
+        const raw = await readFile29(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -19227,6 +19656,82 @@ function registerCli(api, orchestrator) {
         }
         console.log("OK");
       });
+      const routeCmd = cmd.command("route").description("Manage custom memory routing rules");
+      routeCmd.command("list").description("List configured routing rules").action(async () => {
+        const rules = await runRouteCliCommand({
+          action: "list",
+          memoryDir: orchestrator.config.memoryDir,
+          stateFile: orchestrator.config.routingRulesStateFile
+        });
+        if (rules.length === 0) {
+          console.log("No routing rules configured.");
+          return;
+        }
+        for (const rule of rules) {
+          const targetParts = [
+            rule.target.category ? `category=${rule.target.category}` : "",
+            rule.target.namespace ? `namespace=${rule.target.namespace}` : ""
+          ].filter((value) => value.length > 0);
+          console.log(
+            `${rule.id} type=${rule.patternType} priority=${rule.priority} pattern="${rule.pattern}" target=${targetParts.join(",")}`
+          );
+        }
+      });
+      routeCmd.command("add").description("Add or update a routing rule").argument("<pattern>", "Keyword or regex pattern").argument("<target>", "Target (JSON or category=<cat>,namespace=<ns>)").option("--type <type>", "Pattern type: keyword|regex", "keyword").option("--priority <n>", "Rule priority", "0").option("--id <id>", "Optional stable rule id").action(async (...args) => {
+        const pattern = typeof args[0] === "string" ? args[0] : "";
+        const targetRaw = typeof args[1] === "string" ? args[1] : "";
+        const options = args[2] ?? {};
+        const patternTypeRaw = typeof options.type === "string" ? options.type.trim().toLowerCase() : "keyword";
+        if (!isRoutePatternType(patternTypeRaw)) {
+          throw new Error(`invalid route pattern type: ${patternTypeRaw}`);
+        }
+        const priorityInput = String(options.priority ?? "0").trim();
+        if (!/^-?\d+$/.test(priorityInput)) {
+          throw new Error(`invalid route priority: ${priorityInput}`);
+        }
+        const priorityRaw = Number(priorityInput);
+        const updated = await runRouteCliCommand({
+          action: "add",
+          memoryDir: orchestrator.config.memoryDir,
+          stateFile: orchestrator.config.routingRulesStateFile,
+          pattern,
+          patternType: patternTypeRaw,
+          priority: priorityRaw,
+          targetRaw,
+          id: typeof options.id === "string" ? options.id : void 0
+        });
+        console.log(`OK (${updated.length} rules)`);
+      });
+      routeCmd.command("remove").description("Remove routing rules by exact pattern").argument("<pattern>", "Pattern to remove").action(async (...args) => {
+        const pattern = typeof args[0] === "string" ? args[0] : "";
+        const next = await runRouteCliCommand({
+          action: "remove",
+          memoryDir: orchestrator.config.memoryDir,
+          stateFile: orchestrator.config.routingRulesStateFile,
+          pattern
+        });
+        console.log(`OK (${next.length} rules remain)`);
+      });
+      routeCmd.command("test").description("Test routing rule match for input text").argument("<text>", "Text to evaluate").action(async (...args) => {
+        const text = typeof args[0] === "string" ? args[0] : "";
+        const selection = await runRouteCliCommand({
+          action: "test",
+          memoryDir: orchestrator.config.memoryDir,
+          stateFile: orchestrator.config.routingRulesStateFile,
+          text
+        });
+        if (!selection) {
+          console.log("No route match.");
+          return;
+        }
+        const targetParts = [
+          selection.target.category ? `category=${selection.target.category}` : "",
+          selection.target.namespace ? `namespace=${selection.target.namespace}` : ""
+        ].filter((value) => value.length > 0);
+        console.log(
+          `Matched ${selection.rule.id} type=${selection.rule.patternType} priority=${selection.rule.priority} target=${targetParts.join(",")}`
+        );
+      });
       cmd.command("archive-observations").description("Archive aged observation artifacts (dry-run by default)").option("--retention-days <n>", "Archive files older than N days", "30").option("--write", "Apply archive mutations (default: dry-run)").action(async (...args) => {
         const options = args[0] ?? {};
         const retentionDays = parseInt(String(options.retentionDays ?? "30"), 10);
@@ -19603,7 +20108,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path39.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path40.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -19826,8 +20331,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path39.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path39.join(memoryDir, "threads"));
+        const memoryDir = path40.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path40.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -20000,16 +20505,16 @@ function parseDuration(duration) {
 }
 
 // src/index.ts
-import { readFile as readFile29, writeFile as writeFile25 } from "fs/promises";
+import { readFile as readFile30, writeFile as writeFile26 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path40 from "path";
+import path41 from "path";
 import os5 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os5.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path40.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path41.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -20217,11 +20722,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path40.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path41.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile29(cronFilePath, "utf-8");
+          const content = await readFile30(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -20258,7 +20763,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile25(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile26(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
         log.info("auto-registered hourly summary cron job");
       } catch (err) {
         log.error("failed to auto-register hourly summary cron job:", err);