@joshuaswarren/openclaw-engram 9.0.37 → 9.0.39

package/dist/index.js

@@ -304,6 +304,8 @@ function parseConfig(raw) {
     memoryRedTeamBenchEnabled: cfg.memoryRedTeamBenchEnabled === true,
     harmonicRetrievalEnabled: cfg.harmonicRetrievalEnabled === true,
     abstractionAnchorsEnabled: cfg.abstractionAnchorsEnabled === true,
+    verifiedRecallEnabled: cfg.verifiedRecallEnabled === true,
+    semanticRulePromotionEnabled: cfg.semanticRulePromotionEnabled === true,
     abstractionNodeStoreDir: typeof cfg.abstractionNodeStoreDir === "string" && cfg.abstractionNodeStoreDir.trim().length > 0 ? cfg.abstractionNodeStoreDir.trim() : path.join(memoryDir, "state", "abstraction-nodes"),
     // Local LLM Provider (v2.1)
     localLlmEnabled: cfg.localLlmEnabled === true || cfg.localLlmEnabled === "true",
@@ -581,6 +583,18 @@ function buildDefaultRecallPipeline(cfg) {
       maxResults: 3,
       maxChars: 1800
     },
+    {
+      id: "harmonic-retrieval",
+      enabled: cfg.harmonicRetrievalEnabled === true,
+      maxResults: 3,
+      maxChars: 2200
+    },
+    {
+      id: "verified-episodes",
+      enabled: cfg.verifiedRecallEnabled === true,
+      maxResults: 3,
+      maxChars: 1800
+    },
     {
       id: "memories",
       enabled: true,
@@ -628,10 +642,10 @@ function buildRecallPipelineConfig(cfg) {
 }
 
 // src/orchestrator.ts
-import path34 from "path";
+import path37 from "path";
 import os5 from "os";
 import { createHash as createHash6 } from "crypto";
-import { mkdir as mkdir24, readdir as readdir16, readFile as readFile23, stat as stat7, unlink as unlink5, writeFile as writeFile24 } from "fs/promises";
+import { mkdir as mkdir26, readdir as readdir16, readFile as readFile23, stat as stat7, unlink as unlink5, writeFile as writeFile26 } from "fs/promises";
 
 // src/signal.ts
 var BUILTIN_HIGH_PATTERNS = [
@@ -15021,6 +15035,401 @@ async function getTrustZoneStoreStatus(options) {
   };
 }
 
+// src/harmonic-retrieval.ts
+import path27 from "path";
+
+// src/abstraction-nodes.ts
+import path25 from "path";
+import { mkdir as mkdir18, writeFile as writeFile19 } from "fs/promises";
+function validateKind2(raw) {
+  const value = assertString2(raw, "kind");
+  if (!["episode", "topic", "project", "workflow", "constraint"].includes(value)) {
+    throw new Error("kind must be one of episode|topic|project|workflow|constraint");
+  }
+  return value;
+}
+function validateLevel(raw) {
+  const value = assertString2(raw, "abstractionLevel");
+  if (!["micro", "meso", "macro"].includes(value)) {
+    throw new Error("abstractionLevel must be one of micro|meso|macro");
+  }
+  return value;
+}
+function resolveAbstractionNodeStoreDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path25.join(memoryDir, "state", "abstraction-nodes");
+}
+function validateAbstractionNode(raw) {
+  if (!isRecord2(raw)) throw new Error("abstraction node must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  return {
+    schemaVersion: 1,
+    nodeId: assertSafePathSegment(assertString2(raw.nodeId, "nodeId"), "nodeId"),
+    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
+    kind: validateKind2(raw.kind),
+    abstractionLevel: validateLevel(raw.abstractionLevel),
+    title: assertString2(raw.title, "title"),
+    summary: assertString2(raw.summary, "summary"),
+    sourceMemoryIds: optionalStringArray2(raw.sourceMemoryIds, "sourceMemoryIds"),
+    entityRefs: optionalStringArray2(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray2(raw.tags, "tags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function getAbstractionNodeStoreStatus(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const nodesDir = path25.join(rootDir, "nodes");
+  const files = await listJsonFiles(nodesDir);
+  const nodes = [];
+  const invalidNodes = [];
+  for (const filePath of files) {
+    try {
+      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidNodes.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  nodes.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byKind = {};
+  const byLevel = {};
+  for (const node of nodes) {
+    byKind[node.kind] = (byKind[node.kind] ?? 0) + 1;
+    byLevel[node.abstractionLevel] = (byLevel[node.abstractionLevel] ?? 0) + 1;
+  }
+  return {
+    enabled: options.enabled,
+    anchorsEnabled: options.anchorsEnabled,
+    rootDir,
+    nodesDir,
+    nodes: {
+      total: files.length,
+      valid: nodes.length,
+      invalid: invalidNodes.length,
+      byKind,
+      byLevel,
+      latestNodeId: nodes[0]?.nodeId,
+      latestRecordedAt: nodes[0]?.recordedAt,
+      latestSessionKey: nodes[0]?.sessionKey
+    },
+    latestNode: nodes[0],
+    invalidNodes
+  };
+}
+
+// src/cue-anchors.ts
+import path26 from "path";
+import { mkdir as mkdir19, writeFile as writeFile20 } from "fs/promises";
+function validateAnchorType(raw) {
+  const value = assertString2(raw, "anchorType");
+  if (!["entity", "file", "tool", "outcome", "constraint", "date"].includes(value)) {
+    throw new Error("anchorType must be one of entity|file|tool|outcome|constraint|date");
+  }
+  return value;
+}
+function validateNodeRefs(raw) {
+  const nodeRefs = optionalStringArray2(raw, "nodeRefs");
+  if (!nodeRefs || nodeRefs.length === 0) {
+    throw new Error("nodeRefs must contain at least one node reference");
+  }
+  return nodeRefs.map((nodeRef, index) => assertSafePathSegment(nodeRef, `nodeRefs[${index}]`));
+}
+function resolveCueAnchorStoreDir(abstractionNodeStoreDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path26.join(abstractionNodeStoreDir, "anchors");
+}
+function validateCueAnchor(raw) {
+  if (!isRecord2(raw)) throw new Error("cue anchor must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  return {
+    schemaVersion: 1,
+    anchorId: assertSafePathSegment(assertString2(raw.anchorId, "anchorId"), "anchorId"),
+    anchorType: validateAnchorType(raw.anchorType),
+    anchorValue: assertString2(raw.anchorValue, "anchorValue"),
+    normalizedCue: assertString2(raw.normalizedCue, "normalizedCue"),
+    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
+    nodeRefs: validateNodeRefs(raw.nodeRefs),
+    tags: optionalStringArray2(raw.tags, "tags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function getCueAnchorStoreStatus(options) {
+  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length ? options.abstractionNodeStoreDir.trim() : path26.join(options.memoryDir, "state", "abstraction-nodes");
+  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
+  const files = await listJsonFiles(rootDir);
+  const anchors = [];
+  const invalidAnchors = [];
+  for (const filePath of files) {
+    try {
+      anchors.push(validateCueAnchor(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidAnchors.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  anchors.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byType = {};
+  let totalNodeRefs = 0;
+  for (const anchor of anchors) {
+    byType[anchor.anchorType] = (byType[anchor.anchorType] ?? 0) + 1;
+    totalNodeRefs += anchor.nodeRefs.length;
+  }
+  return {
+    enabled: options.enabled,
+    anchorsEnabled: options.anchorsEnabled,
+    rootDir,
+    anchors: {
+      total: files.length,
+      valid: anchors.length,
+      invalid: invalidAnchors.length,
+      byType,
+      totalNodeRefs,
+      latestAnchorId: anchors[0]?.anchorId,
+      latestRecordedAt: anchors[0]?.recordedAt,
+      latestSessionKey: anchors[0]?.sessionKey
+    },
+    latestAnchor: anchors[0],
+    invalidAnchors
+  };
+}
+
+// src/harmonic-retrieval.ts
+function scoreNode(node, queryTokens) {
+  const matchedFields = [];
+  let score = 0;
+  const titleMatches = countRecallTokenOverlap(queryTokens, node.title);
+  if (titleMatches > 0) {
+    score += titleMatches * 3;
+    matchedFields.push("title");
+  }
+  const summaryMatches = countRecallTokenOverlap(queryTokens, node.summary);
+  if (summaryMatches > 0) {
+    score += summaryMatches * 3;
+    matchedFields.push("summary");
+  }
+  const tagMatches = countRecallTokenOverlap(queryTokens, node.tags?.join(" "));
+  if (tagMatches > 0) {
+    score += tagMatches * 2;
+    matchedFields.push("tags");
+  }
+  const entityMatches = countRecallTokenOverlap(queryTokens, node.entityRefs?.join(" "));
+  if (entityMatches > 0) {
+    score += entityMatches * 2;
+    matchedFields.push("entityRefs");
+  }
+  const kindMatches = countRecallTokenOverlap(queryTokens, `${node.kind} ${node.abstractionLevel}`);
+  if (kindMatches > 0) {
+    score += kindMatches;
+    matchedFields.push("kind");
+  }
+  return { score, matchedFields };
+}
+function scoreAnchor(anchor, queryTokens) {
+  const matchedFields = [];
+  let score = 0;
+  const valueMatches = countRecallTokenOverlap(queryTokens, anchor.anchorValue);
+  const normalizedMatches = countRecallTokenOverlap(queryTokens, anchor.normalizedCue);
+  const cueMatches = Math.max(valueMatches, normalizedMatches);
+  if (cueMatches > 0) {
+    score += cueMatches * 4;
+    if (valueMatches > 0) matchedFields.push("anchorValue");
+    if (normalizedMatches > 0) matchedFields.push("anchor");
+  }
+  const typeMatches = countRecallTokenOverlap(queryTokens, anchor.anchorType);
+  if (typeMatches > 0) {
+    score += typeMatches;
+    matchedFields.push("anchorType");
+  }
+  const tagMatches = countRecallTokenOverlap(queryTokens, anchor.tags?.join(" "));
+  if (tagMatches > 0) {
+    score += tagMatches * 2;
+    matchedFields.push("anchorTags");
+  }
+  return { score, matchedFields };
+}
+async function readAbstractionNodes(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const files = await listJsonFiles(path27.join(rootDir, "nodes"));
+  const nodes = [];
+  for (const filePath of files) {
+    try {
+      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));
+    } catch {
+    }
+  }
+  return nodes;
+}
+async function readCueAnchors(options) {
+  const abstractionRoot = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const rootDir = resolveCueAnchorStoreDir(abstractionRoot);
+  const files = await listJsonFiles(rootDir);
+  const anchors = [];
+  for (const filePath of files) {
+    try {
+      anchors.push(validateCueAnchor(await readJsonFile(filePath)));
+    } catch {
+    }
+  }
+  return anchors;
+}
+async function searchHarmonicRetrieval(options) {
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["what", "which"]));
+  if (queryTokens.size === 0 || options.maxResults <= 0) return [];
+  const nodes = await readAbstractionNodes(options);
+  const candidates = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const { score, matchedFields } = scoreNode(node, queryTokens);
+    if (score <= 0) continue;
+    candidates.set(node.nodeId, {
+      node,
+      nodeScore: score,
+      anchorScore: 0,
+      matchedFields: new Set(matchedFields),
+      matchedAnchors: /* @__PURE__ */ new Map()
+    });
+  }
+  if (options.anchorsEnabled) {
+    const anchors = await readCueAnchors(options);
+    const nodeIndex = new Map(nodes.map((node) => [node.nodeId, node]));
+    for (const anchor of anchors) {
+      const { score, matchedFields } = scoreAnchor(anchor, queryTokens);
+      if (score <= 0) continue;
+      for (const nodeRef of anchor.nodeRefs) {
+        const node = nodeIndex.get(nodeRef);
+        if (!node) continue;
+        const existing = candidates.get(nodeRef) ?? {
+          node,
+          nodeScore: 0,
+          anchorScore: 0,
+          matchedFields: /* @__PURE__ */ new Set(),
+          matchedAnchors: /* @__PURE__ */ new Map()
+        };
+        existing.anchorScore += score;
+        existing.matchedFields.add("anchor");
+        for (const field of matchedFields) existing.matchedFields.add(field);
+        existing.matchedAnchors.set(anchor.anchorId, {
+          anchorId: anchor.anchorId,
+          anchorType: anchor.anchorType,
+          anchorValue: anchor.anchorValue
+        });
+        candidates.set(nodeRef, existing);
+      }
+    }
+  }
+  return [...candidates.values()].map((candidate) => {
+    let score = candidate.nodeScore + candidate.anchorScore;
+    if (options.sessionKey && candidate.node.sessionKey === options.sessionKey) score += 0.5;
+    return {
+      node: candidate.node,
+      score,
+      nodeScore: candidate.nodeScore,
+      anchorScore: candidate.anchorScore,
+      matchedFields: [...candidate.matchedFields].sort(),
+      matchedAnchors: [...candidate.matchedAnchors.values()].sort(
+        (left, right) => left.anchorType.localeCompare(right.anchorType) || left.anchorValue.localeCompare(right.anchorValue)
+      )
+    };
+  }).filter((result) => result.nodeScore > 0 || result.anchorScore > 0).sort(
+    (left, right) => right.score - left.score || right.anchorScore - left.anchorScore || right.node.recordedAt.localeCompare(left.node.recordedAt)
+  ).slice(0, options.maxResults);
+}
+
+// src/verified-recall.ts
+function createReadOnlyBoxBuilder(memoryDir) {
+  return new BoxBuilder(memoryDir, {
+    memoryBoxesEnabled: true,
+    traceWeaverEnabled: false,
+    boxTopicShiftThreshold: 0.35,
+    boxTimeGapMs: 30 * 60 * 1e3,
+    boxMaxMemories: 50,
+    traceWeaverLookbackDays: 7,
+    traceWeaverOverlapThreshold: 0.4
+  });
+}
+function scoreVerifiedEpisodeCandidate(box, verifiedMemories, queryTokens) {
+  const matchedFields = /* @__PURE__ */ new Set();
+  let score = 0;
+  const topicMatches = countRecallTokenOverlap(queryTokens, box.topics.join(" "));
+  if (topicMatches > 0) {
+    score += topicMatches * 3;
+    matchedFields.add("topics");
+  }
+  const goalMatches = countRecallTokenOverlap(queryTokens, box.goal);
+  if (goalMatches > 0) {
+    score += goalMatches * 4;
+    matchedFields.add("goal");
+  }
+  const toolMatches = countRecallTokenOverlap(queryTokens, box.toolsUsed?.join(" "));
+  if (toolMatches > 0) {
+    score += toolMatches * 2;
+    matchedFields.add("toolsUsed");
+  }
+  let episodeContentMatches = 0;
+  for (const memory of verifiedMemories) {
+    episodeContentMatches += countRecallTokenOverlap(queryTokens, memory.content);
+  }
+  if (episodeContentMatches > 0) {
+    score += episodeContentMatches * 4;
+    matchedFields.add("episodeContent");
+  }
+  return { score, matchedFields };
+}
+function resolveVerifiedEpisodeMemoriesFromMap(memoryById, memoryIds) {
+  const verified = [];
+  for (const memoryId of memoryIds) {
+    try {
+      const memory = memoryById.get(memoryId);
+      if (!memory) continue;
+      if (memory.frontmatter.status === "archived") continue;
+      if (memory.frontmatter.memoryKind !== "episode") continue;
+      verified.push(memory);
+    } catch {
+    }
+  }
+  return verified;
+}
+async function searchVerifiedEpisodes(options) {
+  const queryTokens = new Set(normalizeRecallTokens(options.query, ["what", "which"]));
+  if (queryTokens.size === 0 || options.maxResults <= 0) return [];
+  const storage = new StorageManager(options.memoryDir);
+  const verifiedMemoryById = new Map(
+    (await storage.readAllMemories()).filter((memory) => memory.frontmatter.status !== "archived").filter((memory) => memory.frontmatter.memoryKind === "episode").map((memory) => [memory.frontmatter.id, memory])
+  );
+  const boxes = await createReadOnlyBoxBuilder(options.memoryDir).readRecentBoxes(Math.max(1, Math.floor(options.boxRecallDays ?? 3))).catch(() => []);
+  const candidates = [];
+  for (const box of boxes) {
+    const verifiedMemories = resolveVerifiedEpisodeMemoriesFromMap(verifiedMemoryById, box.memoryIds);
+    if (verifiedMemories.length === 0) continue;
+    const { score, matchedFields } = scoreVerifiedEpisodeCandidate(box, verifiedMemories, queryTokens);
+    if (score <= 0) continue;
+    candidates.push({
+      box,
+      score,
+      matchedFields,
+      verifiedMemories
+    });
+  }
+  return candidates.map((candidate) => ({
+    box: candidate.box,
+    score: candidate.score,
+    verifiedEpisodeCount: candidate.verifiedMemories.length,
+    verifiedMemoryIds: candidate.verifiedMemories.map((memory) => memory.frontmatter.id),
+    matchedFields: [...candidate.matchedFields].sort()
+  })).sort(
+    (left, right) => right.score - left.score || right.verifiedEpisodeCount - left.verifiedEpisodeCount || right.box.sealedAt.localeCompare(left.box.sealedAt)
+  ).slice(0, options.maxResults);
+}
+
 // src/replay/types.ts
 var VALID_SOURCES = /* @__PURE__ */ new Set(["openclaw", "claude", "chatgpt"]);
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
@@ -15129,8 +15538,8 @@ function chunkTranscriptEntries(sessionKey, entries, opts) {
 }
 
 // src/conversation-index/indexer.ts
-import { mkdir as mkdir18, writeFile as writeFile19 } from "fs/promises";
-import path25 from "path";
+import { mkdir as mkdir20, writeFile as writeFile21 } from "fs/promises";
+import path28 from "path";
 function sanitizeSessionKey(sessionKey) {
   const raw = typeof sessionKey === "string" && sessionKey.trim().length > 0 ? sessionKey : "unknown-session";
   return raw.toLowerCase().replace(/[^a-z0-9._-]+/g, "_").slice(0, 200);
@@ -15140,9 +15549,9 @@ async function writeConversationChunks(rootDir, chunks) {
   for (const c of chunks) {
     const safe = sanitizeSessionKey(c.sessionKey);
     const date = c.startTs.slice(0, 10);
-    const dir = path25.join(rootDir, safe, date);
-    await mkdir18(dir, { recursive: true });
-    const fp = path25.join(dir, `${c.id}.md`);
+    const dir = path28.join(rootDir, safe, date);
+    await mkdir20(dir, { recursive: true });
+    const fp = path28.join(dir, `${c.id}.md`);
     const content = `---
 kind: conversation_chunk
 sessionKey: ${c.sessionKey}
@@ -15151,7 +15560,7 @@ endTs: ${c.endTs}
 ---
 
 ` + c.text + "\n";
-    await writeFile19(fp, content, "utf-8");
+    await writeFile21(fp, content, "utf-8");
     written.push(fp);
   }
   return written;
@@ -15171,7 +15580,7 @@ async function upsertConversationChunksFailOpen(adapter, chunks) {
 
 // src/conversation-index/cleanup.ts
 import { readdir as readdir13, rm as rm2 } from "fs/promises";
-import path26 from "path";
+import path29 from "path";
 async function cleanupConversationChunks(rootDir, retentionDays) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
@@ -15179,7 +15588,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
     const sessions = await readdir13(rootDir, { withFileTypes: true });
     for (const s of sessions) {
       if (!s.isDirectory()) continue;
-      const sessionDir = path26.join(rootDir, s.name);
+      const sessionDir = path29.join(rootDir, s.name);
       const dayDirs = await readdir13(sessionDir, { withFileTypes: true });
       for (const d of dayDirs) {
         if (!d.isDirectory()) continue;
@@ -15187,7 +15596,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
         const dayMs = (/* @__PURE__ */ new Date(d.name + "T00:00:00.000Z")).getTime();
         if (!Number.isFinite(dayMs)) continue;
         if (dayMs < cutoffMs) {
-          await rm2(path26.join(sessionDir, d.name), { recursive: true, force: true });
+          await rm2(path29.join(sessionDir, d.name), { recursive: true, force: true });
         }
       }
       try {
@@ -15206,7 +15615,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
 // src/conversation-index/faiss-adapter.ts
 import * as childProcess from "child_process";
 import { fileURLToPath } from "url";
-import path27 from "path";
+import path30 from "path";
 var FaissAdapterError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -15216,18 +15625,18 @@ var FaissAdapterError = class extends Error {
 };
 function resolveDefaultFaissScriptPath(fromModuleUrl = import.meta.url) {
   const currentFile = fileURLToPath(fromModuleUrl);
-  const moduleDir = path27.dirname(currentFile);
-  if (moduleDir.endsWith(`${path27.sep}conversation-index`)) {
-    return path27.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
+  const moduleDir = path30.dirname(currentFile);
+  if (moduleDir.endsWith(`${path30.sep}conversation-index`)) {
+    return path30.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
   }
-  return path27.resolve(moduleDir, "..", "scripts", "faiss_index.py");
+  return path30.resolve(moduleDir, "..", "scripts", "faiss_index.py");
 }
 var FaissConversationIndexAdapter = class {
   constructor(config) {
     this.config = config;
     this.pythonBin = config.pythonBin && config.pythonBin.trim().length > 0 ? config.pythonBin.trim() : "python3";
     this.scriptPath = config.scriptPath && config.scriptPath.trim().length > 0 ? config.scriptPath.trim() : resolveDefaultFaissScriptPath();
-    this.indexPath = path27.isAbsolute(config.indexDir) ? config.indexDir : path27.join(config.memoryDir, config.indexDir);
+    this.indexPath = path30.isAbsolute(config.indexDir) ? config.indexDir : path30.join(config.memoryDir, config.indexDir);
     this.spawnFn = config.spawnFn ?? childProcess.spawn;
   }
   pythonBin;
@@ -15408,7 +15817,7 @@ async function searchConversationIndexFaissFailOpen(adapter, query, maxResults)
 }
 
 // src/namespaces/storage.ts
-import path28 from "path";
+import path31 from "path";
 import { access } from "fs/promises";
 async function exists(p) {
   try {
@@ -15430,7 +15839,7 @@ var NamespaceStorageRouter = class {
       this.defaultNsRootResolved = this.config.memoryDir;
       return this.defaultNsRootResolved;
     }
-    const nsDir = path28.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
+    const nsDir = path31.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
     this.defaultNsRootResolved = await exists(nsDir) ? nsDir : this.config.memoryDir;
     return this.defaultNsRootResolved;
   }
@@ -15439,7 +15848,7 @@ var NamespaceStorageRouter = class {
     if (namespace === this.config.defaultNamespace) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }
-    return path28.join(this.config.memoryDir, "namespaces", namespace);
+    return path31.join(this.config.memoryDir, "namespaces", namespace);
   }
   async storageFor(namespace) {
     const ns = namespace || this.config.defaultNamespace;
@@ -15515,8 +15924,8 @@ function recallNamespacesForPrincipal(principal, config) {
 }
 
 // src/shared-context/manager.ts
-import { mkdir as mkdir19, readFile as readFile19, readdir as readdir14, appendFile as appendFile4, writeFile as writeFile20, stat as stat5 } from "fs/promises";
-import path29 from "path";
+import { mkdir as mkdir21, readFile as readFile19, readdir as readdir14, appendFile as appendFile4, writeFile as writeFile22, stat as stat5 } from "fs/promises";
+import path32 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
 var SharedFeedbackEntrySchema = z3.object({
@@ -15712,15 +16121,15 @@ async function computeSemanticOverlapsWithTimeout(sources, timeoutMs, maxCandida
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path29.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path32.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
     this.dir = base;
-    this.prioritiesPath = path29.join(base, "priorities.md");
-    this.prioritiesInboxPath = path29.join(base, "priorities.inbox.md");
-    this.outputsDir = path29.join(base, "agent-outputs");
-    this.roundtableDir = path29.join(base, "roundtable");
-    this.feedbackDir = path29.join(base, "feedback");
-    this.feedbackInboxPath = path29.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path29.join(base, "cross-signals");
+    this.prioritiesPath = path32.join(base, "priorities.md");
+    this.prioritiesInboxPath = path32.join(base, "priorities.inbox.md");
+    this.outputsDir = path32.join(base, "agent-outputs");
+    this.roundtableDir = path32.join(base, "roundtable");
+    this.feedbackDir = path32.join(base, "feedback");
+    this.feedbackInboxPath = path32.join(this.feedbackDir, "inbox.jsonl");
+    this.crossSignalsDir = path32.join(base, "cross-signals");
   }
   dir;
   prioritiesPath;
@@ -15731,15 +16140,15 @@ var SharedContextManager = class {
   feedbackInboxPath;
   crossSignalsDir;
   async ensureStructure() {
-    await mkdir19(this.dir, { recursive: true });
-    await mkdir19(this.outputsDir, { recursive: true });
-    await mkdir19(this.roundtableDir, { recursive: true });
-    await mkdir19(this.feedbackDir, { recursive: true });
-    await mkdir19(this.crossSignalsDir, { recursive: true });
-    await mkdir19(path29.join(this.dir, "staging"), { recursive: true });
-    await mkdir19(path29.join(this.dir, "kpis"), { recursive: true });
-    await mkdir19(path29.join(this.dir, "calendar"), { recursive: true });
-    await mkdir19(path29.join(this.dir, "content-calendar"), { recursive: true });
+    await mkdir21(this.dir, { recursive: true });
+    await mkdir21(this.outputsDir, { recursive: true });
+    await mkdir21(this.roundtableDir, { recursive: true });
+    await mkdir21(this.feedbackDir, { recursive: true });
+    await mkdir21(this.crossSignalsDir, { recursive: true });
+    await mkdir21(path32.join(this.dir, "staging"), { recursive: true });
+    await mkdir21(path32.join(this.dir, "kpis"), { recursive: true });
+    await mkdir21(path32.join(this.dir, "calendar"), { recursive: true });
+    await mkdir21(path32.join(this.dir, "content-calendar"), { recursive: true });
     await this.ensureFile(
       this.prioritiesPath,
       [
@@ -15770,7 +16179,7 @@ var SharedContextManager = class {
     try {
       await stat5(fp);
     } catch {
-      await writeFile20(fp, content, "utf-8");
+      await writeFile22(fp, content, "utf-8");
     }
   }
   async readPriorities() {
@@ -15783,7 +16192,7 @@ var SharedContextManager = class {
   async readLatestRoundtable() {
     try {
       const files = (await readdir14(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path29.join(this.roundtableDir, files[0]) : null;
+      const fp = files[0] ? path32.join(this.roundtableDir, files[0]) : null;
       if (!fp) return "";
       return await readFile19(fp, "utf-8");
     } catch {
@@ -15795,9 +16204,9 @@ var SharedContextManager = class {
     const date = ymd(createdAt);
     const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
     const slug = safeSlug(opts.title);
-    const dir = path29.join(this.outputsDir, opts.agentId, date);
-    await mkdir19(dir, { recursive: true });
-    const fp = path29.join(dir, `${time}-${slug}.md`);
+    const dir = path32.join(this.outputsDir, opts.agentId, date);
+    await mkdir21(dir, { recursive: true });
+    const fp = path32.join(dir, `${time}-${slug}.md`);
     const body = `---
 kind: agent_output
 agent: ${opts.agentId}
@@ -15806,7 +16215,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 ---
 
 ` + opts.content.trimEnd() + "\n";
-    await writeFile20(fp, body, "utf-8");
+    await writeFile22(fp, body, "utf-8");
     return fp;
   }
   async appendFeedback(entry) {
@@ -15832,11 +16241,11 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
       const agents = await readdir14(this.outputsDir, { withFileTypes: true });
       for (const a of agents) {
         if (!a.isDirectory()) continue;
-        const dayDir = path29.join(this.outputsDir, a.name, date);
+        const dayDir = path32.join(this.outputsDir, a.name, date);
         try {
           const files = (await readdir14(dayDir)).filter((f) => f.endsWith(".md")).sort();
           for (const f of files) {
-            const p = path29.join(dayDir, f);
+            const p = path32.join(dayDir, f);
             const raw = await readFile19(p, "utf-8");
             const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
             outputs.push({ agent: a.name, path: p, title, raw });
@@ -15943,8 +16352,8 @@ ${body}`)
         addedOverlapCount: semanticAddedOverlapCount
       }
     };
-    const crossSignalsPath = path29.join(this.crossSignalsDir, `${date}.json`);
-    await writeFile20(crossSignalsPath, `${JSON.stringify(crossSignalReport, null, 2)}
+    const crossSignalsPath = path32.join(this.crossSignalsDir, `${date}.json`);
+    await writeFile22(crossSignalsPath, `${JSON.stringify(crossSignalReport, null, 2)}
 `, "utf-8");
     const overlapBullets = mergedOverlaps.length === 0 ? ["- No multi-agent topic overlap detected."] : mergedOverlaps.slice(0, 8).map((entry) => `- \`${entry.token}\` (${entry.agentCount} agents: ${entry.agents.join(", ")})`);
     const md = [
@@ -15967,8 +16376,8 @@ ${body}`)
     ];
     const out = md.join("\n");
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
-    const roundtablePath = path29.join(this.roundtableDir, `${date}.md`);
-    await writeFile20(roundtablePath, trimmed, "utf-8");
+    const roundtablePath = path32.join(this.roundtableDir, `${date}.md`);
+    await writeFile22(roundtablePath, trimmed, "utf-8");
     log.info(`shared-context curated daily roundtable: ${roundtablePath}`);
     return {
       date,
@@ -15980,8 +16389,8 @@ ${body}`)
 };
 
 // src/compounding/engine.ts
-import { mkdir as mkdir20, readFile as readFile20, readdir as readdir15, writeFile as writeFile21 } from "fs/promises";
-import path30 from "path";
+import { mkdir as mkdir22, readFile as readFile20, readdir as readdir15, writeFile as writeFile23 } from "fs/promises";
+import path33 from "path";
 import os4 from "os";
 function defaultTierMigrationCycleBudget(config, trigger) {
   if (trigger === "extraction") {
@@ -16028,7 +16437,7 @@ function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
   }
-  return path30.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
+  return path33.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
 }
 function cadenceStaleWindowMs(cadence) {
   switch (cadence) {
@@ -16047,16 +16456,16 @@ function cadenceStaleWindowMs(cadence) {
 var CompoundingEngine = class {
   constructor(config) {
     this.config = config;
-    this.weeklyDir = path30.join(config.memoryDir, "compounding", "weekly");
-    this.rubricsPath = path30.join(config.memoryDir, "compounding", "rubrics.md");
-    this.mistakesPath = path30.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path30.join(sharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAnchorPath = path30.join(config.memoryDir, "identity", "identity-anchor.md");
-    this.identityIncidentsDir = path30.join(config.memoryDir, "identity", "incidents");
-    this.identityAuditWeeklyDir = path30.join(config.memoryDir, "identity", "audits", "weekly");
-    this.identityAuditMonthlyDir = path30.join(config.memoryDir, "identity", "audits", "monthly");
-    this.identityImprovementLoopsPath = path30.join(config.memoryDir, "identity", "improvement-loops.md");
-    this.memoryActionEventsPath = path30.join(config.memoryDir, "state", "memory-actions.jsonl");
+    this.weeklyDir = path33.join(config.memoryDir, "compounding", "weekly");
+    this.rubricsPath = path33.join(config.memoryDir, "compounding", "rubrics.md");
+    this.mistakesPath = path33.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = path33.join(sharedContextDir(config), "feedback", "inbox.jsonl");
+    this.identityAnchorPath = path33.join(config.memoryDir, "identity", "identity-anchor.md");
+    this.identityIncidentsDir = path33.join(config.memoryDir, "identity", "incidents");
+    this.identityAuditWeeklyDir = path33.join(config.memoryDir, "identity", "audits", "weekly");
+    this.identityAuditMonthlyDir = path33.join(config.memoryDir, "identity", "audits", "monthly");
+    this.identityImprovementLoopsPath = path33.join(config.memoryDir, "identity", "improvement-loops.md");
+    this.memoryActionEventsPath = path33.join(config.memoryDir, "state", "memory-actions.jsonl");
   }
   weeklyDir;
   rubricsPath;
@@ -16069,9 +16478,9 @@ var CompoundingEngine = class {
   identityImprovementLoopsPath;
   memoryActionEventsPath;
   async ensureDirs() {
-    await mkdir20(this.weeklyDir, { recursive: true });
-    await mkdir20(path30.dirname(this.mistakesPath), { recursive: true });
-    await mkdir20(path30.dirname(this.rubricsPath), { recursive: true });
+    await mkdir22(this.weeklyDir, { recursive: true });
+    await mkdir22(path33.dirname(this.mistakesPath), { recursive: true });
+    await mkdir22(path33.dirname(this.rubricsPath), { recursive: true });
   }
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
@@ -16082,12 +16491,12 @@ var CompoundingEngine = class {
     const promotionCandidates = this.config.compoundingSemanticEnabled ? this.derivePromotionCandidates(outcomeSummary) : [];
     const mistakes = this.buildMistakes(entries, actionPatterns);
     const continuity = this.config.continuityAuditEnabled ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
-    const reportPath = path30.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path33.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, mistakes.details, continuity, outcomeSummary, promotionCandidates);
-    await writeFile21(reportPath, md, "utf-8");
+    await writeFile23(reportPath, md, "utf-8");
     const rubrics = this.formatRubrics(entries, outcomeSummary);
-    await writeFile21(this.rubricsPath, rubrics, "utf-8");
-    await writeFile21(
+    await writeFile23(this.rubricsPath, rubrics, "utf-8");
+    await writeFile23(
       this.mistakesPath,
       JSON.stringify({ updatedAt: mistakes.updatedAt, patterns: mistakes.patterns }, null, 2) + "\n",
       "utf-8"
@@ -16167,9 +16576,9 @@ var CompoundingEngine = class {
       ""
     ];
     const dir = period === "weekly" ? this.identityAuditWeeklyDir : this.identityAuditMonthlyDir;
-    await mkdir20(dir, { recursive: true });
-    const reportPath = path30.join(dir, `${key}.md`);
-    await writeFile21(reportPath, lines.join("\n"), "utf-8");
+    await mkdir22(dir, { recursive: true });
+    const reportPath = path33.join(dir, `${key}.md`);
+    await writeFile23(reportPath, lines.join("\n"), "utf-8");
     return { period, key, reportPath };
   }
   async readMistakes() {
@@ -16268,7 +16677,7 @@ var CompoundingEngine = class {
       else if (event.outcome === "skipped") acc.counts.skipped += 1;
       else if (event.outcome === "failed") acc.counts.failed += 1;
       else acc.counts.unknown += 1;
-      acc.provenance.add(`${path30.basename(this.memoryActionEventsPath)}:L${event.line}`);
+      acc.provenance.add(`${path33.basename(this.memoryActionEventsPath)}:L${event.line}`);
       byAction.set(key, acc);
     }
     const out = [];
@@ -16306,7 +16715,7 @@ var CompoundingEngine = class {
     const patterns = [];
     for (const wrapped of entries) {
       const e = wrapped.entry;
-      const provenance = [`${path30.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
+      const provenance = [`${path33.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
       if (e.learning && e.learning.trim().length > 0) {
         patterns.push({ pattern: `${e.agent}: ${e.learning.trim()}`, provenance });
         continue;
@@ -16316,7 +16725,7 @@ var CompoundingEngine = class {
       }
     }
     for (const p of actionPatterns) {
-      patterns.push({ pattern: p, provenance: [`${path30.basename(this.memoryActionEventsPath)}:*`] });
+      patterns.push({ pattern: p, provenance: [`${path33.basename(this.memoryActionEventsPath)}:*`] });
     }
     const byPattern = /* @__PURE__ */ new Map();
     for (const p of patterns) {
@@ -16356,7 +16765,7 @@ var CompoundingEngine = class {
         lines.push(`- approved: ${approved}`);
         lines.push(`- approved_with_feedback: ${awf}`);
         lines.push(`- rejected: ${rejected}`);
-        const provenance = list.slice(0, 3).map((e) => `${path30.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
+        const provenance = list.slice(0, 3).map((e) => `${path33.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
         if (provenance.length > 0) {
           lines.push(`- provenance: ${provenance.join(", ")}`);
         }
@@ -16447,7 +16856,7 @@ var CompoundingEngine = class {
         } else {
           for (const item of learnings) {
             const note = (item.entry.learning && item.entry.learning.trim().length > 0 ? item.entry.learning : item.entry.reason).trim();
-            lines.push(`- ${note} _(source: ${path30.basename(item.sourcePath)}:L${item.sourceLine}#${item.entryId})_`);
+            lines.push(`- ${note} _(source: ${path33.basename(item.sourcePath)}:L${item.sourceLine}#${item.entryId})_`);
           }
         }
         lines.push("");
@@ -16492,7 +16901,7 @@ var CompoundingEngine = class {
       const files = names.filter((n) => n.endsWith(".md")).sort().reverse();
       for (const file of files) {
         if (incidents.length >= cappedLimit) break;
-        const filePath = path30.join(this.identityIncidentsDir, file);
+        const filePath = path33.join(this.identityIncidentsDir, file);
         try {
           const raw = await readFile20(filePath, "utf-8");
           const parsed = parseContinuityIncident(raw);
@@ -16508,8 +16917,8 @@ var CompoundingEngine = class {
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
-    const weeklyPath = path30.join(this.identityAuditWeeklyDir, `${weekId}.md`);
-    const monthlyPath = path30.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyPath = path33.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path33.join(this.identityAuditMonthlyDir, `${monthId}.md`);
     const weeklyExists = await this.readNonEmptyFile(weeklyPath);
     const monthlyExists = await this.readNonEmptyFile(monthlyPath);
     return {
@@ -16522,8 +16931,8 @@ var CompoundingEngine = class {
 };
 
 // src/tier-migration.ts
-import { appendFile as appendFile5, mkdir as mkdir21 } from "fs/promises";
-import path31 from "path";
+import { appendFile as appendFile5, mkdir as mkdir23 } from "fs/promises";
+import path34 from "path";
 var TierMigrationExecutor = class {
   storage;
   qmd;
@@ -16537,7 +16946,7 @@ var TierMigrationExecutor = class {
     this.hotCollection = options.hotCollection;
     this.coldCollection = options.coldCollection;
     this.autoEmbed = options.autoEmbed === true;
-    this.journalPath = options.journalPath ?? path31.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
+    this.journalPath = options.journalPath ?? path34.join(this.storage.dir, "state", "tier-migration-journal.jsonl");
   }
   async migrateMemory(request) {
     const { memory, fromTier, toTier, reason } = request;
@@ -16590,7 +16999,7 @@ var TierMigrationExecutor = class {
       reason: result.reason,
       targetPath: result.targetPath
     };
-    await mkdir21(path31.dirname(this.journalPath), { recursive: true });
+    await mkdir23(path34.dirname(this.journalPath), { recursive: true });
     await appendFile5(this.journalPath, `${JSON.stringify(entry)}
 `, "utf-8");
   }
@@ -16757,8 +17166,8 @@ function selectRouteRule(text, rules, options) {
 }
 
 // src/routing/store.ts
-import { lstat, mkdir as mkdir22, readFile as readFile21, realpath, rename as rename2, rm as rm3, stat as stat6, writeFile as writeFile22 } from "fs/promises";
-import path32 from "path";
+import { lstat, mkdir as mkdir24, readFile as readFile21, realpath, rename as rename2, rm as rm3, stat as stat6, writeFile as writeFile24 } from "fs/promises";
+import path35 from "path";
 import { createHash as createHash4 } from "crypto";
 function defaultState() {
   return {
@@ -16777,14 +17186,14 @@ function stableRuleId(rule) {
   return `route-${createHash4("sha256").update(seed).digest("hex").slice(0, 12)}`;
 }
 function resolveStatePath(memoryDir, stateFile) {
-  const root = path32.resolve(memoryDir);
-  const defaultPath = path32.join(root, "state", "routing-rules.json");
-  if (path32.isAbsolute(stateFile)) {
-    const absolute = path32.resolve(stateFile);
-    return absolute.startsWith(root + path32.sep) ? absolute : defaultPath;
+  const root = path35.resolve(memoryDir);
+  const defaultPath = path35.join(root, "state", "routing-rules.json");
+  if (path35.isAbsolute(stateFile)) {
+    const absolute = path35.resolve(stateFile);
+    return absolute.startsWith(root + path35.sep) ? absolute : defaultPath;
   }
-  const resolved = path32.resolve(root, stateFile);
-  return resolved.startsWith(root + path32.sep) ? resolved : defaultPath;
+  const resolved = path35.resolve(root, stateFile);
+  return resolved.startsWith(root + path35.sep) ? resolved : defaultPath;
 }
 function normalizeRule(rule, options) {
   if (!rule || typeof rule !== "object") return null;
@@ -16817,7 +17226,7 @@ var RoutingRulesStore = class {
   lockPath;
   writeQueue = Promise.resolve();
   constructor(memoryDir, stateFile = "state/routing-rules.json") {
-    this.memoryRoot = path32.resolve(memoryDir);
+    this.memoryRoot = path35.resolve(memoryDir);
     this.statePath = resolveStatePath(memoryDir, stateFile);
     this.lockPath = `${this.statePath}.lock`;
   }
@@ -16855,7 +17264,7 @@ var RoutingRulesStore = class {
     await this.withWriteLock(async () => {
       const payload = defaultState();
       await this.assertStatePathScoped();
-      await writeFile22(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile24(this.statePath, JSON.stringify(payload, null, 2), "utf-8");
     });
   }
   dedupeById(rules) {
@@ -16889,7 +17298,7 @@ var RoutingRulesStore = class {
     const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;
     try {
       await this.assertStatePathScoped();
-      await writeFile22(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile24(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
       await rename2(tmpPath, this.statePath);
     } catch (err) {
       log.debug(`routing rules write failed: ${err}`);
@@ -16923,10 +17332,10 @@ var RoutingRulesStore = class {
     const timeoutMs = 5e3;
     let unexpectedLockError = null;
     await this.assertStatePathScoped();
-    await mkdir22(path32.dirname(this.lockPath), { recursive: true });
+    await mkdir24(path35.dirname(this.lockPath), { recursive: true });
     while (Date.now() - start < timeoutMs) {
       try {
-        await mkdir22(this.lockPath);
+        await mkdir24(this.lockPath);
         return async () => {
           try {
             await rm3(this.lockPath, { recursive: true, force: true });
@@ -16956,14 +17365,14 @@ var RoutingRulesStore = class {
     throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);
   }
   async assertStatePathScoped() {
-    await mkdir22(this.memoryRoot, { recursive: true });
+    await mkdir24(this.memoryRoot, { recursive: true });
     const canonicalRoot = await realpath(this.memoryRoot);
-    const canonicalParent = await this.canonicalizePathWithoutCreating(path32.dirname(this.statePath));
-    const canonicalStatePath = path32.join(canonicalParent, path32.basename(this.statePath));
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path35.dirname(this.statePath));
+    const canonicalStatePath = path35.join(canonicalParent, path35.basename(this.statePath));
     if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
       throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
     }
-    await mkdir22(path32.dirname(this.statePath), { recursive: true });
+    await mkdir24(path35.dirname(this.statePath), { recursive: true });
     try {
       const stateStats = await lstat(this.statePath);
       if (stateStats.isSymbolicLink()) {
@@ -16980,28 +17389,28 @@ var RoutingRulesStore = class {
     }
   }
   isPathInside(root, candidate) {
-    const normalizedRoot = path32.resolve(root);
-    const normalizedCandidate = path32.resolve(candidate);
+    const normalizedRoot = path35.resolve(root);
+    const normalizedCandidate = path35.resolve(candidate);
     if (normalizedCandidate === normalizedRoot) return true;
-    if (normalizedRoot === path32.parse(normalizedRoot).root) {
+    if (normalizedRoot === path35.parse(normalizedRoot).root) {
       return normalizedCandidate.startsWith(normalizedRoot);
     }
-    return normalizedCandidate.startsWith(`${normalizedRoot}${path32.sep}`);
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path35.sep}`);
   }
   async canonicalizePathWithoutCreating(targetPath) {
-    const absoluteTarget = path32.resolve(targetPath);
+    const absoluteTarget = path35.resolve(targetPath);
     let probe = absoluteTarget;
     while (true) {
       try {
         const canonicalProbe = await realpath(probe);
-        const remainder = path32.relative(probe, absoluteTarget);
-        return path32.resolve(canonicalProbe, remainder);
+        const remainder = path35.relative(probe, absoluteTarget);
+        return path35.resolve(canonicalProbe, remainder);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
           throw err;
         }
-        const parent = path32.dirname(probe);
+        const parent = path35.dirname(probe);
         if (parent === probe) {
           return absoluteTarget;
         }
@@ -17012,8 +17421,8 @@ var RoutingRulesStore = class {
 };
 
 // src/policy-runtime.ts
-import path33 from "path";
-import { mkdir as mkdir23, readFile as readFile22, rename as rename3, writeFile as writeFile23 } from "fs/promises";
+import path36 from "path";
+import { mkdir as mkdir25, readFile as readFile22, rename as rename3, writeFile as writeFile25 } from "fs/promises";
 var RUNTIME_POLICY_VERSION = 1;
 var RUNTIME_POLICY_FILE = "policy-runtime.json";
 var RUNTIME_POLICY_PREV_FILE = "policy-runtime.prev.json";
@@ -17061,8 +17470,8 @@ async function readRuntimePolicySnapshot(filePath, options) {
 }
 async function writeSnapshotAtomic(filePath, snapshot) {
   const tempPath = `${filePath}.tmp`;
-  await mkdir23(path33.dirname(filePath), { recursive: true });
-  await writeFile23(tempPath, `${JSON.stringify(snapshot, null, 2)}
+  await mkdir25(path36.dirname(filePath), { recursive: true });
+  await writeFile25(tempPath, `${JSON.stringify(snapshot, null, 2)}
 `, "utf-8");
   await rename3(tempPath, filePath);
 }
@@ -17070,9 +17479,9 @@ var PolicyRuntimeManager = class {
   constructor(memoryDir, config) {
     this.memoryDir = memoryDir;
     this.config = config;
-    const stateDir2 = path33.join(memoryDir, "state");
-    this.runtimePath = path33.join(stateDir2, RUNTIME_POLICY_FILE);
-    this.runtimePrevPath = path33.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
+    const stateDir2 = path36.join(memoryDir, "state");
+    this.runtimePath = path36.join(stateDir2, RUNTIME_POLICY_FILE);
+    this.runtimePrevPath = path36.join(stateDir2, RUNTIME_POLICY_PREV_FILE);
   }
   runtimePath;
   runtimePrevPath;
@@ -17225,7 +17634,7 @@ function dedupeBehaviorSignalsByMemoryAndHash(signals) {
 // src/orchestrator.ts
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 function defaultWorkspaceDir() {
-  return path34.join(os5.homedir(), ".openclaw", "workspace");
+  return path37.join(os5.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -17365,11 +17774,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path34.isAbsolute(candidatePath) ? candidatePath : path34.resolve(storageDir, candidatePath);
-  const rel = path34.relative(storageDir, absolutePath);
+  const absolutePath = path37.isAbsolute(candidatePath) ? candidatePath : path37.resolve(storageDir, candidatePath);
+  const rel = path37.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path34.sep).join("/");
+  return rel.split(path37.sep).join("/");
 }
 function normalizeGraphActivationScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -17444,7 +17853,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path34.relative(storageDir, mem.path));
+    pathById.set(id, path37.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -17452,7 +17861,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path34.join(options.storageDir, options.memoryRelPath),
+    path: path37.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -17472,15 +17881,15 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path34.join("corrections", `${options.memoryId}.md`);
+    return path37.join("corrections", `${options.memoryId}.md`);
   }
   const idParts = options.memoryId.split("-");
   const maybeTimestamp = Number(idParts[1]);
   if (Number.isFinite(maybeTimestamp) && maybeTimestamp > 0) {
     const day = new Date(maybeTimestamp).toISOString().slice(0, 10);
-    return path34.join("facts", day, `${options.memoryId}.md`);
+    return path37.join("facts", day, `${options.memoryId}.md`);
   }
-  return path34.join("facts", `${options.memoryId}.md`);
+  return path37.join("facts", `${options.memoryId}.md`);
 }
 function shouldRejectLowConfidenceRecall(results, threshold) {
   if (results.length === 0) return false;
@@ -17588,7 +17997,7 @@ var Orchestrator = class _Orchestrator {
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path34.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path37.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -17613,7 +18022,7 @@ var Orchestrator = class _Orchestrator {
     })() : this.localLlm;
     this.extraction = new ExtractionEngine(config, this.localLlm, config.gatewayConfig, this.modelRegistry);
     this.threading = new ThreadingManager(
-      path34.join(config.memoryDir, "threads"),
+      path37.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -17782,7 +18191,7 @@ var Orchestrator = class _Orchestrator {
     await this.sessionObserver.load();
     this.runtimePolicyValues = await this.policyRuntime.loadRuntimeValues();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path34.join(this.config.memoryDir, "state");
+      const stateDir2 = path37.join(this.config.memoryDir, "state");
       this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
@@ -17821,7 +18230,7 @@ var Orchestrator = class _Orchestrator {
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path34.join(this.config.memoryDir, "conversation-index")
+          path37.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -17857,7 +18266,7 @@ var Orchestrator = class _Orchestrator {
         const files = await readdir16(wsDir).catch(() => []);
         for (const f of files) {
           if (!f.startsWith(".compaction-reset-signal-")) continue;
-          const fp = path34.join(wsDir, f);
+          const fp = path37.join(wsDir, f);
           const s = await stat7(fp).catch(() => null);
           if (s && Date.now() - s.mtimeMs >= COMPACTION_SIGNAL_MAX_AGE_MS) {
             await unlink5(fp).catch(() => {
@@ -17893,12 +18302,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path34.isAbsolute(rel) ? rel : path34.join(this.config.workspaceDir, rel);
+        const abs = path37.isAbsolute(rel) ? rel : path37.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile23(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path34.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path34.basename(abs);
+            const archiveDir = path37.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path37.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -17906,7 +18315,7 @@ var Orchestrator = class _Orchestrator {
               archivePrefix: prefix,
               keepTailChars: hygiene.rotateKeepTailChars
             });
-            await writeFile24(abs, newContent, "utf-8");
+            await writeFile26(abs, newContent, "utf-8");
           }
         } catch {
         }
@@ -17923,8 +18332,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path34.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir24(path34.dirname(fp), { recursive: true });
+        const fp = path37.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir26(path37.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -17937,7 +18346,7 @@ var Orchestrator = class _Orchestrator {
         } catch {
           existing = "# Engram File Hygiene Warnings\n";
         }
-        await writeFile24(fp, existing + block, "utf-8");
+        await writeFile26(fp, existing + block, "utf-8");
       }
     }
   }
@@ -18013,7 +18422,7 @@ var Orchestrator = class _Orchestrator {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path34.join(storage.dir, "state", "last_graph_recall.json");
+    const snapshotPath = path37.join(storage.dir, "state", "last_graph_recall.json");
     try {
       const raw = await readFile23(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -18084,7 +18493,7 @@ ${r.snippet.trim()}
       const entries = await readdir16(dir, { withFileTypes: true });
       let total = 0;
       for (const entry of entries) {
-        const fullPath = path34.join(dir, entry.name);
+        const fullPath = path37.join(dir, entry.name);
         if (entry.isDirectory()) {
           total += await this.countConversationChunkDocs(fullPath);
           continue;
@@ -18409,7 +18818,7 @@ ${r.snippet.trim()}
       const seedRelativePaths = seedCandidates.map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
       if (seedRelativePaths.length === 0) continue;
       const seedRecallScore = seedCandidates.reduce((max, item) => Math.max(max, item.score), 0);
-      seedPaths.push(...seedRelativePaths.map((rel) => path34.join(storage.dir, rel)));
+      seedPaths.push(...seedRelativePaths.map((rel) => path37.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
@@ -18418,7 +18827,7 @@ ${r.snippet.trim()}
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path34.resolve(storage.dir, candidate.path);
+        const memoryPath = path37.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -18441,7 +18850,7 @@ ${r.snippet.trim()}
           path: memory.path,
           score,
           namespace,
-          seed: path34.resolve(storage.dir, candidate.seed),
+          seed: path37.resolve(storage.dir, candidate.seed),
           hopDepth: candidate.hopDepth,
           decayedWeight: candidate.decayedWeight,
           graphType: candidate.graphType
@@ -18456,8 +18865,8 @@ ${r.snippet.trim()}
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path34.join(options.storage.dir, "state", "last_graph_recall.json");
-      await mkdir24(path34.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path37.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir26(path37.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const totalSeedCount = options.seedPaths.length;
       const totalExpandedCount = options.expandedPaths.length;
@@ -18474,7 +18883,7 @@ ${r.snippet.trim()}
         seeds,
         expanded
       };
-      await writeFile24(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile26(snapshotPath, JSON.stringify(payload, null, 2), "utf-8");
     } catch (err) {
       log.debug(`last graph recall write failed: ${err}`);
     }
@@ -18783,7 +19192,49 @@ ${r.snippet.trim()}
       timings.trustZones = `${Date.now() - t0}ms`;
       return results.length > 0 ? this.formatTrustZoneResults(results) : null;
     })();
-    const qmdPromise = (async () => {
+    const harmonicRetrievalPromise = (async () => {
+      const t0 = Date.now();
+      if (!this.config.harmonicRetrievalEnabled || !this.isRecallSectionEnabled("harmonic-retrieval", this.config.harmonicRetrievalEnabled === true)) {
+        timings.harmonicRetrieval = "skip";
+        return null;
+      }
+      const maxResults = this.getRecallSectionNumber("harmonic-retrieval", "maxResults") ?? 3;
+      if (maxResults <= 0) {
+        timings.harmonicRetrieval = "skip(limit=0)";
+        return null;
+      }
+      const results = await searchHarmonicRetrieval({
+        memoryDir: this.config.memoryDir,
+        abstractionNodeStoreDir: this.config.abstractionNodeStoreDir,
+        query: retrievalQuery,
+        maxResults,
+        sessionKey,
+        anchorsEnabled: this.config.abstractionAnchorsEnabled
+      });
+      timings.harmonicRetrieval = `${Date.now() - t0}ms`;
+      return results.length > 0 ? this.formatHarmonicRetrievalResults(results) : null;
+    })();
+    const verifiedRecallPromise = (async () => {
+      const t0 = Date.now();
+      if (!this.config.verifiedRecallEnabled || !this.isRecallSectionEnabled("verified-episodes", this.config.verifiedRecallEnabled === true)) {
+        timings.verifiedRecall = "skip";
+        return null;
+      }
+      const maxResults = this.getRecallSectionNumber("verified-episodes", "maxResults") ?? 3;
+      if (maxResults <= 0) {
+        timings.verifiedRecall = "skip(limit=0)";
+        return null;
+      }
+      const results = await searchVerifiedEpisodes({
+        memoryDir: this.config.memoryDir,
+        query: retrievalQuery,
+        maxResults,
+        boxRecallDays: this.config.boxRecallDays
+      });
+      timings.verifiedRecall = `${Date.now() - t0}ms`;
+      return results.length > 0 ? this.formatVerifiedEpisodeResults(results) : null;
+    })();
+    const qmdPromise = (async () => {
       if (recallResultLimit <= 0) {
         timings.qmd = "skip(limit=0)";
         return null;
@@ -18856,8 +19307,8 @@ ${formatted}`;
       if (!this.config.compactionResetEnabled) return null;
       const workspaceDir = compactionWorkspaceDir || this.config.workspaceDir || defaultWorkspaceDir();
       const safeSessionKey = sanitizeSessionKeyForFilename(effectiveSessionKey);
-      const signalPath = path34.join(workspaceDir, `.compaction-reset-signal-${safeSessionKey}`);
-      const bootPath = path34.join(workspaceDir, "BOOT.md");
+      const signalPath = path37.join(workspaceDir, `.compaction-reset-signal-${safeSessionKey}`);
+      const bootPath = path37.join(workspaceDir, "BOOT.md");
       try {
         const signalStat = await stat7(signalPath).catch(() => null);
         if (!signalStat) return null;
@@ -18989,6 +19440,8 @@ ${formatted}`;
       objectiveStateSection,
       causalTrajectorySection,
       trustZoneSection,
+      harmonicRetrievalSection,
+      verifiedRecallSection,
       qmdResult,
       transcriptSection,
       compactionSection,
@@ -19004,6 +19457,8 @@ ${formatted}`;
       objectiveStatePromise,
       causalTrajectoryPromise,
       trustZonePromise,
+      harmonicRetrievalPromise,
+      verifiedRecallPromise,
       qmdPromise,
       transcriptPromise,
       compactionPromise,
@@ -19067,6 +19522,12 @@ ${tmtNode.summary}`);
     if (trustZoneSection) {
       this.appendRecallSection(sectionBuckets, "trust-zones", trustZoneSection);
     }
+    if (harmonicRetrievalSection) {
+      this.appendRecallSection(sectionBuckets, "harmonic-retrieval", harmonicRetrievalSection);
+    }
+    if (verifiedRecallSection) {
+      this.appendRecallSection(sectionBuckets, "verified-episodes", verifiedRecallSection);
+    }
     if (qmdResult) {
       const t0 = Date.now();
       const { memoryResultsLists, globalResults } = qmdResult;
@@ -19860,7 +20321,7 @@ _Context: ${topQuestion.context}_`
     };
     this.tierMigrationInFlight = true;
     try {
-      const coldStorage = new StorageManager(path34.join(storage.dir, "cold"));
+      const coldStorage = new StorageManager(path37.join(storage.dir, "cold"));
       const [hotMemories, coldMemories] = await Promise.all([
         storage.readAllMemories(),
         coldStorage.readAllMemories()
@@ -20454,7 +20915,7 @@ _Context: ${topQuestion.context}_`
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path34.relative(storage.dir, m.path);
+            const rel = path37.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -21018,9 +21479,9 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path34.join(this.storage.dir, "state", "lifecycle-metrics.json");
-    await mkdir24(path34.dirname(metricsPath), { recursive: true });
-    await writeFile24(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
+    const metricsPath = path37.join(this.storage.dir, "state", "lifecycle-metrics.json");
+    await mkdir26(path37.dirname(metricsPath), { recursive: true });
+    await writeFile26(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
    * Archive old, low-importance, rarely-accessed facts (v6.0).
@@ -21242,6 +21703,54 @@ ${details.join("\n")}`;
     });
     return `## Trust Zones
 
+${lines.join("\n\n")}`;
+  }
+  formatHarmonicRetrievalResults(results) {
+    const lines = results.map(({ node, matchedAnchors, matchedFields, nodeScore, anchorScore }, index) => {
+      const header = [
+        `[${index + 1}] ${node.recordedAt.replace("T", " ").slice(0, 16)}`,
+        `${node.kind}/${node.abstractionLevel}`,
+        node.sessionKey
+      ].join(" | ");
+      const details = [
+        node.title,
+        node.summary,
+        `scores: node=${nodeScore.toFixed(1)} anchor=${anchorScore.toFixed(1)}`
+      ];
+      if (matchedAnchors.length > 0) {
+        details.push(`anchors: ${matchedAnchors.map((anchor) => `${anchor.anchorType}:${anchor.anchorValue}`).join("; ")}`);
+      }
+      if (matchedFields.length > 0) {
+        details.push(`matched: ${matchedFields.join(", ")}`);
+      }
+      return `${header}
+${details.join("\n")}`;
+    });
+    return `## Harmonic Retrieval
+
+${lines.join("\n\n")}`;
+  }
+  formatVerifiedEpisodeResults(results) {
+    const lines = results.map(({ box, verifiedEpisodeCount, matchedFields }, index) => {
+      const header = [
+        `[${index + 1}] ${box.sealedAt.replace("T", " ").slice(0, 16)}`,
+        box.traceId ? `trace:${box.traceId.slice(0, 12)}` : "trace:none"
+      ].join(" | ");
+      const details = [
+        box.goal ?? `topics: ${box.topics.join(", ")}`,
+        `verified episodes: ${verifiedEpisodeCount}`
+      ];
+      if (box.toolsUsed && box.toolsUsed.length > 0) {
+        details.push(`tools: ${box.toolsUsed.join(", ")}`);
+      }
+      if (matchedFields.length > 0) {
+        details.push(`matched: ${matchedFields.join(", ")}`);
+      }
+      return `${header}
+${details.join("\n")}`;
+    });
+    return `## Verified Episodes
+
 ${lines.join("\n\n")}`;
   }
   summarizeIdentityText(raw, maxLines, maxChars) {
@@ -21375,7 +21884,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path34.isAbsolute(hit.path) ? hit.path : path34.join(this.config.memoryDir, hit.path);
+      const fullPath = path37.isAbsolute(hit.path) ? hit.path : path37.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -21833,8 +22342,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path34.resolve(storageDir);
-    const resolvedMemoryDir = path34.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path37.resolve(storageDir);
+    const resolvedMemoryDir = path37.resolve(this.config.memoryDir);
     if (resolvedStorageDir === resolvedMemoryDir) return this.config.defaultNamespace;
     const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
     return m && m[1] ? m[1] : this.config.defaultNamespace;
@@ -21862,14 +22371,14 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path36 from "path";
+import path39 from "path";
 import { createHash as createHash7 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/work/storage.ts
-import path35 from "path";
+import path38 from "path";
 import { randomUUID } from "crypto";
-import { mkdir as mkdir25, readdir as readdir17, readFile as readFile24, rm as rm4, writeFile as writeFile25 } from "fs/promises";
+import { mkdir as mkdir27, readdir as readdir17, readFile as readFile24, rm as rm4, writeFile as writeFile27 } from "fs/promises";
 var TASK_TRANSITIONS = {
   todo: /* @__PURE__ */ new Set(["in_progress", "blocked", "cancelled"]),
   in_progress: /* @__PURE__ */ new Set(["todo", "blocked", "done", "cancelled"]),
@@ -21944,22 +22453,22 @@ function ensureProjectStatus(value) {
 var WorkStorage = class {
   constructor(memoryDir) {
     this.memoryDir = memoryDir;
-    this.tasksDir = path35.join(memoryDir, "work", "tasks");
-    this.projectsDir = path35.join(memoryDir, "work", "projects");
+    this.tasksDir = path38.join(memoryDir, "work", "tasks");
+    this.projectsDir = path38.join(memoryDir, "work", "projects");
   }
   tasksDir;
   projectsDir;
   async ensureDirectories() {
-    await mkdir25(this.tasksDir, { recursive: true });
-    await mkdir25(this.projectsDir, { recursive: true });
+    await mkdir27(this.tasksDir, { recursive: true });
+    await mkdir27(this.projectsDir, { recursive: true });
   }
   taskPath(id) {
     assertValidWorkId(id, "task");
-    return path35.join(this.tasksDir, `${id}.md`);
+    return path38.join(this.tasksDir, `${id}.md`);
   }
   projectPath(id) {
     assertValidWorkId(id, "project");
-    return path35.join(this.projectsDir, `${id}.md`);
+    return path38.join(this.projectsDir, `${id}.md`);
   }
   serializeTask(task) {
     return `${serializeFrontmatter2(task)}
@@ -22031,7 +22540,7 @@ ${project.description}
         throw new Error(`project not found: ${task.projectId}`);
       }
     }
-    await writeFile25(this.taskPath(task.id), this.serializeTask(task), "utf-8");
+    await writeFile27(this.taskPath(task.id), this.serializeTask(task), "utf-8");
     if (task.projectId) {
       await this.addTaskIdToProject(task.projectId, task.id, now);
     }
@@ -22051,7 +22560,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile24(path35.join(this.tasksDir, entry.name), "utf-8");
+      const raw = await readFile24(path38.join(this.tasksDir, entry.name), "utf-8");
       const task = this.parseTask(raw);
       if (!task) continue;
       if (filter?.status && task.status !== filter.status) continue;
@@ -22093,7 +22602,7 @@ ${project.description}
       tags: patch.tags ?? existing.tags,
       updatedAt: now.toISOString()
     };
-    await writeFile25(this.taskPath(id), this.serializeTask(next), "utf-8");
+    await writeFile27(this.taskPath(id), this.serializeTask(next), "utf-8");
     return next;
   }
   async transitionTask(id, nextStatus, now = /* @__PURE__ */ new Date()) {
@@ -22133,7 +22642,7 @@ ${project.description}
       createdAt: timestamp,
       updatedAt: timestamp
     };
-    await writeFile25(this.projectPath(project.id), this.serializeProject(project), "utf-8");
+    await writeFile27(this.projectPath(project.id), this.serializeProject(project), "utf-8");
     return project;
   }
   async getProject(id) {
@@ -22150,7 +22659,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile24(path35.join(this.projectsDir, entry.name), "utf-8");
+      const raw = await readFile24(path38.join(this.projectsDir, entry.name), "utf-8");
       const project = this.parseProject(raw);
       if (project) out.push(project);
     }
@@ -22167,7 +22676,7 @@ ${project.description}
       taskIds: patch.taskIds ? [...patch.taskIds].sort() : existing.taskIds,
       updatedAt: now.toISOString()
     };
-    await writeFile25(this.projectPath(id), this.serializeProject(next), "utf-8");
+    await writeFile27(this.projectPath(id), this.serializeProject(next), "utf-8");
     return next;
   }
   async deleteProject(id) {
@@ -23706,7 +24215,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path36.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path39.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           return toolResult("No identity file found. Identity reflections build automatically through conversations when identityEnabled is true.");
@@ -24223,13 +24732,13 @@ promotionCandidates: ${res.promotionCandidateCount}`
 }
 
 // src/cli.ts
-import path56 from "path";
+import path57 from "path";
 import { access as access3, readFile as readFile37, readdir as readdir24, unlink as unlink7 } from "fs/promises";
 import { createHash as createHash10 } from "crypto";
 
 // src/transfer/export-json.ts
-import path38 from "path";
-import { mkdir as mkdir27, readFile as readFile26 } from "fs/promises";
+import path41 from "path";
+import { mkdir as mkdir29, readFile as readFile26 } from "fs/promises";
 
 // src/transfer/constants.ts
 var EXPORT_FORMAT = "openclaw-engram-export";
@@ -24237,8 +24746,8 @@ var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdir as mkdir26, readdir as readdir18, readFile as readFile25, stat as stat8, writeFile as writeFile26 } from "fs/promises";
-import path37 from "path";
+import { mkdir as mkdir28, readdir as readdir18, readFile as readFile25, stat as stat8, writeFile as writeFile28 } from "fs/promises";
+import path40 from "path";
 async function sha256File(filePath) {
   const buf = await readFile25(filePath);
   const sha256 = createHash8("sha256").update(buf).digest("hex");
@@ -24250,8 +24759,8 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir26(path37.dirname(filePath), { recursive: true });
-  await writeFile26(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  await mkdir28(path40.dirname(filePath), { recursive: true });
+  await writeFile28(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile2(filePath) {
   const raw = await readFile25(filePath, "utf-8");
@@ -24262,7 +24771,7 @@ async function listFilesRecursive(rootDir) {
   async function walk(dir) {
     const entries = await readdir18(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path37.join(dir, ent.name);
+      const fp = path40.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -24282,11 +24791,11 @@ async function fileExists(filePath) {
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path37.relative(rootDir, absPath);
-  return rel.split(path37.sep).join("/");
+  const rel = path40.relative(rootDir, absPath);
+  return rel.split(path40.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path37.sep);
+  return relPath.split("/").join(path40.sep);
 }
 
 // src/transfer/export-json.ts
@@ -24302,9 +24811,9 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path38.resolve(opts.outDir);
-  await mkdir27(outDirAbs, { recursive: true });
-  const memoryDirAbs = path38.resolve(opts.memoryDir);
+  const outDirAbs = path41.resolve(opts.outDir);
+  await mkdir29(outDirAbs, { recursive: true });
+  const memoryDirAbs = path41.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memoryDirAbs);
   const records = [];
   const manifestFiles = [];
@@ -24317,7 +24826,7 @@ async function exportJsonBundle(opts) {
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
   if (opts.includeWorkspaceIdentity !== false && opts.workspaceDir) {
-    const identityPath = path38.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path41.join(opts.workspaceDir, "IDENTITY.md");
     try {
       const content = await readFile26(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
@@ -24336,13 +24845,13 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path38.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path38.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path41.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path41.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path39 from "path";
-import { mkdir as mkdir28, readFile as readFile27, writeFile as writeFile27 } from "fs/promises";
+import path42 from "path";
+import { mkdir as mkdir30, readFile as readFile27, writeFile as writeFile29 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
   if (!includeTranscripts && parts[0] === "transcripts") return true;
@@ -24350,18 +24859,18 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path39.resolve(opts.outDir);
-  await mkdir28(outDirAbs, { recursive: true });
-  const memDirAbs = path39.resolve(opts.memoryDir);
+  const outDirAbs = path42.resolve(opts.outDir);
+  await mkdir30(outDirAbs, { recursive: true });
+  const memDirAbs = path42.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const manifestFiles = [];
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, memDirAbs);
     if (shouldExclude2(relPosix, includeTranscripts)) continue;
-    const dstAbs = path39.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir28(path39.dirname(dstAbs), { recursive: true });
+    const dstAbs = path42.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir30(path42.dirname(dstAbs), { recursive: true });
     const content = await readFile27(abs);
-    await writeFile27(dstAbs, content);
+    await writeFile29(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
@@ -24373,12 +24882,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path39.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path42.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path39.resolve(fromDir);
+  const dirAbs = path42.resolve(fromDir);
   try {
-    const raw = await readFile27(path39.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile27(path42.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -24387,16 +24896,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path40 from "path";
-import { mkdir as mkdir29, readdir as readdir19, rm as rm5 } from "fs/promises";
+import path43 from "path";
+import { mkdir as mkdir31, readdir as readdir19, rm as rm5 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path40.resolve(opts.outDir);
-  await mkdir29(outDirAbs, { recursive: true });
+  const outDirAbs = path43.resolve(opts.outDir);
+  await mkdir31(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path40.join(outDirAbs, ts);
+  const backupDir = path43.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -24421,13 +24930,13 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm5(path40.join(outDirAbs, name), { recursive: true, force: true });
+      await rm5(path43.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path41 from "path";
+import path44 from "path";
 import Database from "better-sqlite3";
 import { readFile as readFile28 } from "fs/promises";
 
@@ -24455,8 +24964,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path41.resolve(opts.memoryDir);
-  const outAbs = path41.resolve(opts.outFile);
+  const memDirAbs = path44.resolve(opts.memoryDir);
+  const outAbs = path44.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -24488,8 +24997,8 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path42 from "path";
-import { mkdir as mkdir30, writeFile as writeFile28 } from "fs/promises";
+import path45 from "path";
+import { mkdir as mkdir32, writeFile as writeFile30 } from "fs/promises";
 
 // src/transfer/types.ts
 import { z as z4 } from "zod";
@@ -24522,21 +25031,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path42.resolve(opts.fromDir);
-  const bundlePath = path42.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path45.resolve(opts.fromDir);
+  const bundlePath = path45.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile2(bundlePath));
-  const memDirAbs = path42.resolve(opts.targetMemoryDir);
+  const memDirAbs = path45.resolve(opts.targetMemoryDir);
   const written = [];
   let skipped = 0;
   for (const rec of bundle.records) {
     const isWorkspace = rec.path.startsWith("workspace/");
-    const targetBase = isWorkspace ? opts.workspaceDir ? path42.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path45.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path42.join(targetBase, relFs);
+    const absTarget = path45.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -24560,30 +25069,30 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir30(path42.dirname(w.abs), { recursive: true });
-    await writeFile28(w.abs, w.content, "utf-8");
+    await mkdir32(path45.dirname(w.abs), { recursive: true });
+    await writeFile30(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path42.resolve(fromDir);
+  const dir = path45.resolve(fromDir);
   return Promise.all([
-    fileExists(path42.join(dir, "manifest.json")),
-    fileExists(path42.join(dir, "bundle.json"))
+    fileExists(path45.join(dir, "manifest.json")),
+    fileExists(path45.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path43 from "path";
+import path46 from "path";
 import Database2 from "better-sqlite3";
-import { mkdir as mkdir31, writeFile as writeFile29 } from "fs/promises";
+import { mkdir as mkdir33, writeFile as writeFile31 } from "fs/promises";
 function normalizeForDedupe2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path43.resolve(opts.targetMemoryDir);
-  const fromAbs = path43.resolve(opts.fromFile);
+  const memDirAbs = path46.resolve(opts.targetMemoryDir);
+  const fromAbs = path46.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -24596,7 +25105,7 @@ async function importSqlite(opts) {
     const rows = db.prepare("SELECT path_rel, content FROM files").all();
     for (const r of rows) {
       const relFs = fromPosixRelPath(r.path_rel);
-      const absTarget = path43.join(memDirAbs, relFs);
+      const absTarget = path46.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -24621,29 +25130,29 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir31(path43.dirname(w.abs), { recursive: true });
-    await writeFile29(w.abs, w.content, "utf-8");
+    await mkdir33(path46.dirname(w.abs), { recursive: true });
+    await writeFile31(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path44 from "path";
-import { mkdir as mkdir32, readFile as readFile29, writeFile as writeFile30 } from "fs/promises";
+import path47 from "path";
+import { mkdir as mkdir34, readFile as readFile29, writeFile as writeFile32 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path44.resolve(opts.fromDir);
-  const targetAbs = path44.resolve(opts.targetMemoryDir);
+  const fromAbs = path47.resolve(opts.fromDir);
+  const targetAbs = path47.resolve(opts.targetMemoryDir);
   const filesAbs = await listFilesRecursive(fromAbs);
   const writes = [];
   let skipped = 0;
   for (const abs of filesAbs) {
     const relPosix = toPosixRelPath(abs, fromAbs);
     if (relPosix === "manifest.json") continue;
-    const dstAbs = path44.join(targetAbs, fromPosixRelPath(relPosix));
+    const dstAbs = path47.join(targetAbs, fromPosixRelPath(relPosix));
     const content = await readFile29(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
@@ -24666,17 +25175,17 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir32(path44.dirname(w.abs), { recursive: true });
-    await writeFile30(w.abs, w.content, "utf-8");
+    await mkdir34(path47.dirname(w.abs), { recursive: true });
+    await writeFile32(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path45 from "path";
+import path48 from "path";
 import { stat as stat9 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path45.resolve(fromPath);
+  const abs = path48.resolve(fromPath);
   let st;
   try {
     st = await stat9(abs);
@@ -25104,8 +25613,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path58 = typeof record.path === "string" ? record.path : "";
-      if (!path58.startsWith("transcripts/") && !path58.includes("/transcripts/")) continue;
+      const path59 = typeof record.path === "string" ? record.path : "";
+      if (!path59.startsWith("transcripts/") && !path59.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -25161,8 +25670,8 @@ var openclawReplayNormalizer = {
 };
 
 // src/maintenance/archive-observations.ts
-import path46 from "path";
-import { mkdir as mkdir33, readdir as readdir20, readFile as readFile30, unlink as unlink6, writeFile as writeFile31 } from "fs/promises";
+import path49 from "path";
+import { mkdir as mkdir35, readdir as readdir20, readFile as readFile30, unlink as unlink6, writeFile as writeFile33 } from "fs/promises";
 var DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
 function normalizeRetentionDays(value) {
   if (!Number.isFinite(value)) return 30;
@@ -25188,8 +25697,8 @@ async function listFilesRecursive2(root, relPrefix = "") {
     return out;
   }
   for (const entry of entries) {
-    const rel = relPrefix ? path46.join(relPrefix, entry.name) : entry.name;
-    const full = path46.join(root, entry.name);
+    const rel = relPrefix ? path49.join(relPrefix, entry.name) : entry.name;
+    const full = path49.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFilesRecursive2(full, rel));
       continue;
@@ -25199,19 +25708,19 @@ async function listFilesRecursive2(root, relPrefix = "") {
   return out;
 }
 async function collectArchiveCandidates(memoryDir, cutoffTimeMs) {
-  const roots = ["transcripts", path46.join("state", "tool-usage"), path46.join("summaries", "hourly")];
+  const roots = ["transcripts", path49.join("state", "tool-usage"), path49.join("summaries", "hourly")];
   const out = [];
   for (const relRoot of roots) {
-    const absRoot = path46.join(memoryDir, relRoot);
+    const absRoot = path49.join(memoryDir, relRoot);
     const files = await listFilesRecursive2(absRoot);
     for (const fileRel of files) {
-      const filename = path46.basename(fileRel);
+      const filename = path49.basename(fileRel);
       const parsedDate = extractDateFromFilename(filename);
       if (!parsedDate) continue;
       if (parsedDate.getTime() >= cutoffTimeMs) continue;
       out.push({
-        absolutePath: path46.join(absRoot, fileRel),
-        relativePath: path46.join(relRoot, fileRel)
+        absolutePath: path49.join(absRoot, fileRel),
+        relativePath: path49.join(relRoot, fileRel)
       });
     }
   }
@@ -25226,7 +25735,7 @@ async function archiveObservations(options) {
     new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1e3)
   );
   const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path46.join(options.memoryDir, "archive", "observations", stamp);
+  const archiveRoot = path49.join(options.memoryDir, "archive", "observations", stamp);
   const candidates = retentionDays === 0 ? [] : await collectArchiveCandidates(
     options.memoryDir,
     cutoffDayStartUtc
@@ -25235,13 +25744,13 @@ async function archiveObservations(options) {
   let archivedBytes = 0;
   const archivedRelativePaths = [];
   if (!dryRun && candidates.length > 0) {
-    await mkdir33(archiveRoot, { recursive: true });
+    await mkdir35(archiveRoot, { recursive: true });
     for (const candidate of candidates) {
-      const archivePath = path46.join(archiveRoot, candidate.relativePath);
-      const archiveDir = path46.dirname(archivePath);
-      await mkdir33(archiveDir, { recursive: true });
+      const archivePath = path49.join(archiveRoot, candidate.relativePath);
+      const archiveDir = path49.dirname(archivePath);
+      await mkdir35(archiveDir, { recursive: true });
       const raw = await readFile30(candidate.absolutePath);
-      await writeFile31(archivePath, raw);
+      await writeFile33(archivePath, raw);
       await unlink6(candidate.absolutePath);
       archivedFiles += 1;
       archivedBytes += raw.byteLength;
@@ -25262,12 +25771,12 @@ async function archiveObservations(options) {
 }
 
 // src/maintenance/rebuild-observations.ts
-import path48 from "path";
+import path51 from "path";
 import { readdir as readdir21, readFile as readFile32 } from "fs/promises";
 
 // src/maintenance/observation-ledger-utils.ts
-import path47 from "path";
-import { mkdir as mkdir34, readFile as readFile31, writeFile as writeFile32 } from "fs/promises";
+import path50 from "path";
+import { mkdir as mkdir36, readFile as readFile31, writeFile as writeFile34 } from "fs/promises";
 function toHourBucketIso(timestamp) {
   const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
   const ms = Date.parse(normalized);
@@ -25278,8 +25787,8 @@ function toHourBucketIso(timestamp) {
 }
 async function backupAndWriteRebuiltObservations(options) {
   const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path47.join(options.memoryDir, "archive", "observations", stamp);
-  let backupPath = path47.join(
+  const archiveRoot = path50.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path50.join(
     archiveRoot,
     "state",
     "observation-ledger",
@@ -25287,8 +25796,8 @@ async function backupAndWriteRebuiltObservations(options) {
   );
   try {
     const existing = await readFile31(options.outputPath, "utf-8");
-    await mkdir34(path47.dirname(backupPath), { recursive: true });
-    await writeFile32(backupPath, existing, "utf-8");
+    await mkdir36(path50.dirname(backupPath), { recursive: true });
+    await writeFile34(backupPath, existing, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code && code === "ENOENT") {
@@ -25304,8 +25813,8 @@ async function backupAndWriteRebuiltObservations(options) {
       rebuiltAt
     })
   );
-  await mkdir34(path47.dirname(options.outputPath), { recursive: true });
-  await writeFile32(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
+  await mkdir36(path50.dirname(options.outputPath), { recursive: true });
+  await writeFile34(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf-8");
   return backupPath;
 }
@@ -25327,7 +25836,7 @@ async function listTranscriptFiles2(root) {
   for (const entry of entries) {
     if (entry.name === "." || entry.name === "..") continue;
     if (entry.isSymbolicLink()) continue;
-    const full = path48.join(root, entry.name);
+    const full = path51.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listTranscriptFiles2(full));
       continue;
@@ -25387,8 +25896,8 @@ function buildLedgerRows(linesByFile) {
 async function rebuildObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const transcriptsRoot = path48.join(options.memoryDir, "transcripts");
-  const outputPath = path48.join(
+  const transcriptsRoot = path51.join(options.memoryDir, "transcripts");
+  const outputPath = path51.join(
     options.memoryDir,
     "state",
     "observation-ledger",
@@ -25424,7 +25933,7 @@ async function rebuildObservations(options) {
 }
 
 // src/maintenance/migrate-observations.ts
-import path49 from "path";
+import path52 from "path";
 import { readdir as readdir22, readFile as readFile33 } from "fs/promises";
 function toNonNegativeInt(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
@@ -25488,15 +25997,15 @@ async function listLegacyObservationFiles(root) {
 async function migrateObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const ledgerRoot = path49.join(options.memoryDir, "state", "observation-ledger");
-  const outputPath = path49.join(ledgerRoot, "rebuilt-observations.jsonl");
+  const ledgerRoot = path52.join(options.memoryDir, "state", "observation-ledger");
+  const outputPath = path52.join(ledgerRoot, "rebuilt-observations.jsonl");
   const legacyFiles = await listLegacyObservationFiles(ledgerRoot);
-  const sourceRelativePaths = legacyFiles.map((name) => path49.join("state", "observation-ledger", name));
+  const sourceRelativePaths = legacyFiles.map((name) => path52.join("state", "observation-ledger", name));
   const byKey = /* @__PURE__ */ new Map();
   let parsedRows = 0;
   let malformedLines = 0;
   for (const file of legacyFiles) {
-    const full = path49.join(ledgerRoot, file);
+    const full = path52.join(ledgerRoot, file);
     const raw = await readFile33(full, "utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
@@ -25686,10 +26195,10 @@ var defaultCommandRunner = (command, args, options) => {
 
 // src/network/webdav.ts
 import { createReadStream } from "fs";
-import { mkdir as mkdir35, readdir as readdir23, realpath as realpath2, stat as stat11 } from "fs/promises";
+import { mkdir as mkdir37, readdir as readdir23, realpath as realpath2, stat as stat11 } from "fs/promises";
 import { createServer } from "http";
 import { timingSafeEqual } from "crypto";
-import path50 from "path";
+import path53 from "path";
 import { pipeline } from "stream/promises";
 import { URL as URL2 } from "url";
 function hostToUrlAuthority(host) {
@@ -25725,10 +26234,10 @@ var WebDavServer = class _WebDavServer {
     const allowedRoots = [];
     const aliasSet = /* @__PURE__ */ new Set();
     for (const dir of options.allowlistDirs) {
-      const resolved = path50.resolve(dir);
-      await mkdir35(resolved, { recursive: true });
+      const resolved = path53.resolve(dir);
+      await mkdir37(resolved, { recursive: true });
       const canonical = await realpath2(resolved);
-      const alias = path50.basename(canonical) || "root";
+      const alias = path53.basename(canonical) || "root";
       if (aliasSet.has(alias)) {
         throw new Error(`duplicate webdav allowlist alias: ${alias}`);
       }
@@ -25884,7 +26393,7 @@ var WebDavServer = class _WebDavServer {
     if (decodedPath.includes("\0")) {
       return { ok: false, code: 400, message: "invalid path" };
     }
-    const normalized = path50.posix.normalize(decodedPath);
+    const normalized = path53.posix.normalize(decodedPath);
     const segments = normalized.split("/").filter((segment) => segment.length > 0);
     if (segments.length === 0) {
       return { ok: false, code: 403, message: "root listing is not allowed" };
@@ -25898,7 +26407,7 @@ var WebDavServer = class _WebDavServer {
     if (relative.some((segment) => segment === ".." || segment.includes("\\"))) {
       return { ok: false, code: 403, message: "path traversal is not allowed" };
     }
-    const candidate = path50.resolve(root.absolute, ...relative);
+    const candidate = path53.resolve(root.absolute, ...relative);
     if (!this.isPathInside(root.absolute, candidate)) {
       return { ok: false, code: 403, message: "path escaped allowlist" };
     }
@@ -25976,10 +26485,10 @@ var WebDavServer = class _WebDavServer {
   }
   isPathInside(root, target) {
     if (target === root) return true;
-    if (root === path50.parse(root).root) {
+    if (root === path53.parse(root).root) {
       return target.startsWith(root);
     }
-    return target.startsWith(`${root}${path50.sep}`);
+    return target.startsWith(`${root}${path53.sep}`);
   }
 };
 function xmlEscape(value) {
@@ -25994,10 +26503,10 @@ import { createHash as createHash9 } from "crypto";
 import { createServer as createServer2 } from "http";
 import { watch } from "fs";
 import { readFile as readFile35 } from "fs/promises";
-import path52 from "path";
+import path55 from "path";
 
 // src/graph-dashboard-parser.ts
-import path51 from "path";
+import path54 from "path";
 import { readFile as readFile34 } from "fs/promises";
 
 // src/graph-dashboard-key.ts
@@ -26008,7 +26517,7 @@ function graphEdgeKey(edge) {
 // src/graph-dashboard-parser.ts
 var GRAPH_TYPES = ["entity", "time", "causal"];
 function graphFile(memoryDir, type) {
-  return path51.join(memoryDir, "state", "graphs", `${type}.jsonl`);
+  return path54.join(memoryDir, "state", "graphs", `${type}.jsonl`);
 }
 function isGraphEdge(raw, expectedType) {
   if (!raw || typeof raw !== "object") return false;
@@ -26135,7 +26644,7 @@ var GraphDashboardServer = class {
     this.memoryDir = options.memoryDir;
     this.host = options.host?.trim() || "127.0.0.1";
     this.requestedPort = Number.isFinite(options.port) ? Math.max(0, Math.floor(options.port ?? 0)) : 0;
-    this.publicDir = options.publicDir ?? path52.join(process.cwd(), "dashboard", "public");
+    this.publicDir = options.publicDir ?? path55.join(process.cwd(), "dashboard", "public");
     this.watchDebounceMs = Math.max(50, Math.floor(options.watchDebounceMs ?? 300));
   }
   async start() {
@@ -26234,11 +26743,11 @@ var GraphDashboardServer = class {
       return;
     }
     if (req.method === "GET" && url === "/app.js") {
-      await this.respondStatic(res, path52.join(this.publicDir, "app.js"), "application/javascript; charset=utf-8");
+      await this.respondStatic(res, path55.join(this.publicDir, "app.js"), "application/javascript; charset=utf-8");
       return;
     }
     if (req.method === "GET" && (url === "/" || url === "/index.html")) {
-      await this.respondStatic(res, path52.join(this.publicDir, "index.html"), "text/html; charset=utf-8");
+      await this.respondStatic(res, path55.join(this.publicDir, "index.html"), "text/html; charset=utf-8");
       return;
     }
     this.respondJson(res, 404, { error: "Not found" });
@@ -26324,7 +26833,7 @@ var GraphDashboardServer = class {
     }
   }
   startWatcher() {
-    const graphDir = path52.join(this.memoryDir, "state", "graphs");
+    const graphDir = path55.join(this.memoryDir, "state", "graphs");
     try {
       this.watcher = watch(graphDir, { persistent: false }, () => {
         this.scheduleRebuild();
@@ -26370,7 +26879,7 @@ var GraphDashboardServer = class {
 
 // src/compat/checks.ts
 import { access as access2, readFile as readFile36 } from "fs/promises";
-import path53 from "path";
+import path56 from "path";
 import { spawn as spawn4 } from "child_process";
 var REQUIRED_HOOKS = ["before_agent_start", "agent_end"];
 function isSafeCommandToken(command) {
@@ -26552,9 +27061,9 @@ function compareVersions(a, b) {
 async function runCompatChecks(options) {
   const checks = [];
   const runner = options.runner ?? defaultRunner;
-  const pluginJsonPath = path53.join(options.repoRoot, "openclaw.plugin.json");
-  const packageJsonPath = path53.join(options.repoRoot, "package.json");
-  const indexPath = path53.join(options.repoRoot, "src", "index.ts");
+  const pluginJsonPath = path56.join(options.repoRoot, "openclaw.plugin.json");
+  const packageJsonPath = path56.join(options.repoRoot, "package.json");
+  const indexPath = path56.join(options.repoRoot, "src", "index.ts");
   let pluginRaw = "";
   let pluginManifestPresent = false;
   try {
@@ -26739,171 +27248,6 @@ async function runCompatChecks(options) {
   };
 }
 
-// src/abstraction-nodes.ts
-import path54 from "path";
-import { mkdir as mkdir36, writeFile as writeFile33 } from "fs/promises";
-function validateKind2(raw) {
-  const value = assertString2(raw, "kind");
-  if (!["episode", "topic", "project", "workflow", "constraint"].includes(value)) {
-    throw new Error("kind must be one of episode|topic|project|workflow|constraint");
-  }
-  return value;
-}
-function validateLevel(raw) {
-  const value = assertString2(raw, "abstractionLevel");
-  if (!["micro", "meso", "macro"].includes(value)) {
-    throw new Error("abstractionLevel must be one of micro|meso|macro");
-  }
-  return value;
-}
-function resolveAbstractionNodeStoreDir(memoryDir, overrideDir) {
-  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
-    return overrideDir.trim();
-  }
-  return path54.join(memoryDir, "state", "abstraction-nodes");
-}
-function validateAbstractionNode(raw) {
-  if (!isRecord2(raw)) throw new Error("abstraction node must be an object");
-  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
-  return {
-    schemaVersion: 1,
-    nodeId: assertSafePathSegment(assertString2(raw.nodeId, "nodeId"), "nodeId"),
-    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
-    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
-    kind: validateKind2(raw.kind),
-    abstractionLevel: validateLevel(raw.abstractionLevel),
-    title: assertString2(raw.title, "title"),
-    summary: assertString2(raw.summary, "summary"),
-    sourceMemoryIds: optionalStringArray2(raw.sourceMemoryIds, "sourceMemoryIds"),
-    entityRefs: optionalStringArray2(raw.entityRefs, "entityRefs"),
-    tags: optionalStringArray2(raw.tags, "tags"),
-    metadata: validateStringRecord(raw.metadata, "metadata")
-  };
-}
-async function getAbstractionNodeStoreStatus(options) {
-  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
-  const nodesDir = path54.join(rootDir, "nodes");
-  const files = await listJsonFiles(nodesDir);
-  const nodes = [];
-  const invalidNodes = [];
-  for (const filePath of files) {
-    try {
-      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));
-    } catch (error) {
-      invalidNodes.push({
-        path: filePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  nodes.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
-  const byKind = {};
-  const byLevel = {};
-  for (const node of nodes) {
-    byKind[node.kind] = (byKind[node.kind] ?? 0) + 1;
-    byLevel[node.abstractionLevel] = (byLevel[node.abstractionLevel] ?? 0) + 1;
-  }
-  return {
-    enabled: options.enabled,
-    anchorsEnabled: options.anchorsEnabled,
-    rootDir,
-    nodesDir,
-    nodes: {
-      total: files.length,
-      valid: nodes.length,
-      invalid: invalidNodes.length,
-      byKind,
-      byLevel,
-      latestNodeId: nodes[0]?.nodeId,
-      latestRecordedAt: nodes[0]?.recordedAt,
-      latestSessionKey: nodes[0]?.sessionKey
-    },
-    latestNode: nodes[0],
-    invalidNodes
-  };
-}
-
-// src/cue-anchors.ts
-import path55 from "path";
-import { mkdir as mkdir37, writeFile as writeFile34 } from "fs/promises";
-function validateAnchorType(raw) {
-  const value = assertString2(raw, "anchorType");
-  if (!["entity", "file", "tool", "outcome", "constraint", "date"].includes(value)) {
-    throw new Error("anchorType must be one of entity|file|tool|outcome|constraint|date");
-  }
-  return value;
-}
-function validateNodeRefs(raw) {
-  const nodeRefs = optionalStringArray2(raw, "nodeRefs");
-  if (!nodeRefs || nodeRefs.length === 0) {
-    throw new Error("nodeRefs must contain at least one node reference");
-  }
-  return nodeRefs.map((nodeRef, index) => assertSafePathSegment(nodeRef, `nodeRefs[${index}]`));
-}
-function resolveCueAnchorStoreDir(abstractionNodeStoreDir, overrideDir) {
-  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
-    return overrideDir.trim();
-  }
-  return path55.join(abstractionNodeStoreDir, "anchors");
-}
-function validateCueAnchor(raw) {
-  if (!isRecord2(raw)) throw new Error("cue anchor must be an object");
-  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
-  return {
-    schemaVersion: 1,
-    anchorId: assertSafePathSegment(assertString2(raw.anchorId, "anchorId"), "anchorId"),
-    anchorType: validateAnchorType(raw.anchorType),
-    anchorValue: assertString2(raw.anchorValue, "anchorValue"),
-    normalizedCue: assertString2(raw.normalizedCue, "normalizedCue"),
-    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
-    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
-    nodeRefs: validateNodeRefs(raw.nodeRefs),
-    tags: optionalStringArray2(raw.tags, "tags"),
-    metadata: validateStringRecord(raw.metadata, "metadata")
-  };
-}
-async function getCueAnchorStoreStatus(options) {
-  const abstractionNodeStoreDir = options.abstractionNodeStoreDir?.trim().length ? options.abstractionNodeStoreDir.trim() : path55.join(options.memoryDir, "state", "abstraction-nodes");
-  const rootDir = resolveCueAnchorStoreDir(abstractionNodeStoreDir, options.cueAnchorStoreDir);
-  const files = await listJsonFiles(rootDir);
-  const anchors = [];
-  const invalidAnchors = [];
-  for (const filePath of files) {
-    try {
-      anchors.push(validateCueAnchor(await readJsonFile(filePath)));
-    } catch (error) {
-      invalidAnchors.push({
-        path: filePath,
-        error: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  anchors.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
-  const byType = {};
-  let totalNodeRefs = 0;
-  for (const anchor of anchors) {
-    byType[anchor.anchorType] = (byType[anchor.anchorType] ?? 0) + 1;
-    totalNodeRefs += anchor.nodeRefs.length;
-  }
-  return {
-    enabled: options.enabled,
-    anchorsEnabled: options.anchorsEnabled,
-    rootDir,
-    anchors: {
-      total: files.length,
-      valid: anchors.length,
-      invalid: invalidAnchors.length,
-      byType,
-      totalNodeRefs,
-      latestAnchorId: anchors[0]?.anchorId,
-      latestRecordedAt: anchors[0]?.recordedAt,
-      latestSessionKey: anchors[0]?.sessionKey
-    },
-    latestAnchor: anchors[0],
-    invalidAnchors
-  };
-}
-
 // src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -27129,6 +27473,26 @@ async function runCueAnchorStatusCliCommand(options) {
     anchorsEnabled: options.abstractionAnchorsEnabled
   });
 }
+async function runHarmonicSearchCliCommand(options) {
+  if (!options.harmonicRetrievalEnabled) return [];
+  return searchHarmonicRetrieval({
+    memoryDir: options.memoryDir,
+    abstractionNodeStoreDir: options.abstractionNodeStoreDir,
+    query: options.query,
+    maxResults: Math.max(1, Math.floor(options.maxResults ?? 3)),
+    sessionKey: options.sessionKey,
+    anchorsEnabled: options.abstractionAnchorsEnabled
+  });
+}
+async function runVerifiedRecallSearchCliCommand(options) {
+  if (!options.verifiedRecallEnabled) return [];
+  return searchVerifiedEpisodes({
+    memoryDir: options.memoryDir,
+    query: options.query,
+    maxResults: Math.max(1, Math.floor(options.maxResults ?? 3)),
+    boxRecallDays: options.boxRecallDays
+  });
+}
 async function runTrustZonePromoteCliCommand(options) {
   const result = await promoteTrustZoneRecord({
     memoryDir: options.memoryDir,
@@ -27375,7 +27739,7 @@ function policyVersionForValues(values, config) {
   return createHash10("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path56.join(config.memoryDir, "state", fileName);
+  const filePath = path57.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -27959,14 +28323,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 = path56.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path57.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 = [path56.join(memoryDir, "facts"), path56.join(memoryDir, "corrections")];
+  const roots = [path57.join(memoryDir, "facts"), path57.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -27977,7 +28341,7 @@ async function readAllMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path56.join(dir, entryName);
+      const fullPath = path57.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -28340,6 +28704,22 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(status, null, 2));
         console.log("OK");
       });
+      cmd.command("harmonic-search").description("Preview harmonic retrieval blending over abstraction nodes and cue anchors").argument("<query>", "Prompt-like query to evaluate against harmonic retrieval storage").option("--max-results <count>", "Maximum number of blended results to return", "3").option("--session-key <sessionKey>", "Optional session key for same-session tie-breaking").action(async (...args) => {
+        const query = typeof args[0] === "string" ? args[0] : "";
+        const options = args[1] ?? {};
+        const maxResults = typeof options.maxResults === "string" ? Number.parseInt(options.maxResults, 10) : 3;
+        const results = await runHarmonicSearchCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          abstractionNodeStoreDir: orchestrator.config.abstractionNodeStoreDir,
+          harmonicRetrievalEnabled: orchestrator.config.harmonicRetrievalEnabled,
+          abstractionAnchorsEnabled: orchestrator.config.abstractionAnchorsEnabled,
+          query,
+          maxResults: Number.isFinite(maxResults) ? maxResults : 3,
+          sessionKey: typeof options.sessionKey === "string" ? options.sessionKey : void 0
+        });
+        console.log(JSON.stringify(results, null, 2));
+        console.log("OK");
+      });
       cmd.command("trust-zone-promote").description("Dry-run or apply a trust-zone promotion with provenance enforcement").requiredOption("--record-id <recordId>", "Source trust-zone record id").requiredOption("--target-zone <targetZone>", "Promotion target zone (working|trusted)").requiredOption("--reason <reason>", "Human-readable promotion reason").option("--recorded-at <isoTimestamp>", "Promotion timestamp (defaults to now)").option("--summary <summary>", "Optional replacement summary for the promoted record").option("--dry-run", "Show the promotion plan without writing the promoted record").action(async (...args) => {
         const options = args[0] ?? {};
         const result = await runTrustZonePromoteCliCommand({
@@ -28358,6 +28738,20 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(result, null, 2));
         console.log("OK");
       });
+      cmd.command("verified-recall-search").description("Preview verified episodic recall over recent memory boxes").argument("<query>", "Prompt-like query to evaluate against verified episodic recall").option("--max-results <count>", "Maximum number of verified episodic results to return", "3").action(async (...args) => {
+        const query = typeof args[0] === "string" ? args[0] : "";
+        const options = args[1] ?? {};
+        const maxResults = typeof options.maxResults === "string" ? Number.parseInt(options.maxResults, 10) : 3;
+        const results = await runVerifiedRecallSearchCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          verifiedRecallEnabled: orchestrator.config.verifiedRecallEnabled,
+          query,
+          maxResults: Number.isFinite(maxResults) ? maxResults : 3,
+          boxRecallDays: orchestrator.config.boxRecallDays
+        });
+        console.log(JSON.stringify(results, null, 2));
+        console.log("OK");
+      });
       cmd.command("conversation-index-health").description("Show conversation index backend health and index stats").action(async () => {
         const health = await runConversationIndexHealthCliCommand(orchestrator);
         console.log(JSON.stringify(health, null, 2));
@@ -29007,7 +29401,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path56.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path57.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -29230,8 +29624,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path56.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path56.join(memoryDir, "threads"));
+        const memoryDir = path57.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path57.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -29709,7 +30103,7 @@ async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
 // src/index.ts
 import { readFile as readFile38, writeFile as writeFile35 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path57 from "path";
+import path58 from "path";
 import os6 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 var ENGRAM_HOOK_APIS = "__openclawEngramHookApis";
@@ -29717,7 +30111,7 @@ function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os6.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path57.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path58.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -29967,7 +30361,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
                 `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
               );
               const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-              const signalPath = path57.join(
+              const signalPath = path58.join(
                 workspaceDir,
                 `.compaction-reset-signal-${safeSessionKey}`
               );
@@ -29998,7 +30392,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path57.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path58.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {