@joshuaswarren/openclaw-engram 8.0.3 → 8.0.4

package/dist/index.js

@@ -368,12 +368,15 @@ function parseConfig(raw) {
     traceWeaverOverlapThreshold: typeof cfg.traceWeaverOverlapThreshold === "number" ? cfg.traceWeaverOverlapThreshold : 0.4,
     boxRecallDays: typeof cfg.boxRecallDays === "number" ? cfg.boxRecallDays : 3,
     // v8.0 Phase 2B: Episode/Note dual store (HiMem)
-    episodeNoteModeEnabled: cfg.episodeNoteModeEnabled === true
+    episodeNoteModeEnabled: cfg.episodeNoteModeEnabled === true,
+    // v8.1: Temporal + Tag Indexes (SwiftMem-inspired)
+    queryAwareIndexingEnabled: cfg.queryAwareIndexingEnabled === true,
+    queryAwareIndexingMaxCandidates: typeof cfg.queryAwareIndexingMaxCandidates === "number" ? Math.max(0, cfg.queryAwareIndexingMaxCandidates) : 200
   };
 }
 
 // src/orchestrator.ts
-import path19 from "path";
+import path20 from "path";
 import { createHash as createHash4 } from "crypto";
 import { mkdir as mkdir14, readFile as readFile14, writeFile as writeFile14 } from "fs/promises";
 
@@ -1101,8 +1104,8 @@ var LocalLlmClient = class _LocalLlmClient {
       log.debug(`local LLM: request body length=${requestBodyJson.length}`);
       if (this.config.debug) {
         try {
-          const { writeFileSync: writeFileSync2 } = await import("fs");
-          writeFileSync2("/tmp/engram-last-request.json", requestBodyJson);
+          const { writeFileSync: writeFileSync3 } = await import("fs");
+          writeFileSync3("/tmp/engram-last-request.json", requestBodyJson);
         } catch {
         }
       }
@@ -4300,8 +4303,8 @@ var ContentHashIndex = class _ContentHashIndex {
   hashes = /* @__PURE__ */ new Set();
   dirty = false;
   filePath;
-  constructor(stateDir) {
-    this.filePath = path4.join(stateDir, "fact-hashes.txt");
+  constructor(stateDir2) {
+    this.filePath = path4.join(stateDir2, "fact-hashes.txt");
   }
   /** Load existing hashes from disk. Safe to call multiple times. */
   async load() {
@@ -4998,23 +5001,23 @@ ${sanitized.text}
   async cleanExpiredTTL() {
     const memories = await this.readAllMemories();
     const now = Date.now();
-    let cleaned = 0;
+    const deleted = [];
     for (const m of memories) {
       if (!m.frontmatter.expiresAt) continue;
       const expiresAt = new Date(m.frontmatter.expiresAt).getTime();
       if (expiresAt < now) {
         try {
           await unlink(m.path);
-          cleaned++;
+          deleted.push(m);
           log.debug(`cleaned expired memory ${m.frontmatter.id} (TTL expired)`);
         } catch {
         }
       }
     }
-    if (cleaned > 0) {
+    if (deleted.length > 0) {
       this.bumpMemoryStatusVersion();
     }
-    return cleaned;
+    return deleted;
   }
   async loadBuffer() {
     const bufferPath = path4.join(this.stateDir, "buffer.json");
@@ -5499,7 +5502,7 @@ ${rows.join("\n")}
   async cleanExpiredCommitments(decayDays) {
     const memories = await this.readAllMemories();
     const cutoff = Date.now() - decayDays * 24 * 60 * 60 * 1e3;
-    let cleaned = 0;
+    const deleted = [];
     for (const m of memories) {
       if (m.frontmatter.category !== "commitment") continue;
       const isResolved = m.frontmatter.tags.some(
@@ -5510,16 +5513,16 @@ ${rows.join("\n")}
       if (updatedAt < cutoff) {
         try {
           await unlink(m.path);
-          cleaned++;
+          deleted.push(m);
           log.debug(`cleaned expired commitment ${m.frontmatter.id}`);
         } catch {
         }
       }
     }
-    if (cleaned > 0) {
+    if (deleted.length > 0) {
       this.bumpMemoryStatusVersion();
     }
-    return cleaned;
+    return deleted;
   }
   // ---------------------------------------------------------------------------
   // Access Tracking (Phase 1A)
@@ -8378,6 +8381,252 @@ function classifyMemoryKind(content, tags, category) {
   return "episode";
 }
 
+// src/temporal-index.ts
+import * as fs from "fs";
+import * as path14 from "path";
+var INDEX_VERSION = 1;
+var TEMPORAL_INDEX_FILE = "index_time.json";
+var TAG_INDEX_FILE = "index_tags.json";
+function stateDir(memoryDir) {
+  return path14.join(memoryDir, "state");
+}
+function temporalIndexPath(memoryDir) {
+  return path14.join(stateDir(memoryDir), TEMPORAL_INDEX_FILE);
+}
+function tagIndexPath(memoryDir) {
+  return path14.join(stateDir(memoryDir), TAG_INDEX_FILE);
+}
+function ensureStateDir(memoryDir) {
+  const dir = stateDir(memoryDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function readJsonSafe(filePath, fallback) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function writeJsonSafe(filePath, data) {
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+  } catch {
+  }
+}
+function writeJsonAtomic(filePath, data) {
+  const tmp = `${filePath}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+    fs.renameSync(tmp, filePath);
+  } catch {
+    writeJsonSafe(filePath, data);
+    try {
+      fs.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function isoDateFromTimestamp(isoString) {
+  if (typeof isoString !== "string" || isoString.length < 10) {
+    console.warn(`[engram] temporal-index: malformed timestamp "${isoString}", falling back to today`);
+    return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  }
+  return isoString.slice(0, 10);
+}
+function addPathToSet(record, key, p) {
+  if (!record[key]) {
+    record[key] = [];
+  }
+  if (!record[key].includes(p)) {
+    record[key].push(p);
+  }
+}
+function removePathFromSet(record, key, p) {
+  if (!record[key]) return;
+  record[key] = record[key].filter((x) => x !== p);
+  if (record[key].length === 0) {
+    delete record[key];
+  }
+}
+function indexMemory(memoryDir, memoryPath, createdAt, tags) {
+  try {
+    ensureStateDir(memoryDir);
+    const tPath = temporalIndexPath(memoryDir);
+    const tIndex = readJsonSafe(tPath, { version: INDEX_VERSION, dates: {} });
+    const dateKey = isoDateFromTimestamp(createdAt);
+    addPathToSet(tIndex.dates, dateKey, memoryPath);
+    writeJsonAtomic(tPath, tIndex);
+    const gPath = tagIndexPath(memoryDir);
+    const gIndex = readJsonSafe(gPath, { version: INDEX_VERSION, tags: {} });
+    for (const tag of tags) {
+      if (tag && typeof tag === "string") {
+        addPathToSet(gIndex.tags, tag.toLowerCase(), memoryPath);
+      }
+    }
+    writeJsonAtomic(gPath, gIndex);
+  } catch {
+  }
+}
+function deindexMemory(memoryDir, memoryPath, createdAt, tags) {
+  try {
+    ensureStateDir(memoryDir);
+    const tPath = temporalIndexPath(memoryDir);
+    const tIndex = readJsonSafe(tPath, { version: INDEX_VERSION, dates: {} });
+    const dateKey = isoDateFromTimestamp(createdAt);
+    removePathFromSet(tIndex.dates, dateKey, memoryPath);
+    writeJsonAtomic(tPath, tIndex);
+    const gPath = tagIndexPath(memoryDir);
+    const gIndex = readJsonSafe(gPath, { version: INDEX_VERSION, tags: {} });
+    for (const tag of tags) {
+      if (tag && typeof tag === "string") {
+        removePathFromSet(gIndex.tags, tag.toLowerCase(), memoryPath);
+      }
+    }
+    writeJsonAtomic(gPath, gIndex);
+  } catch {
+  }
+}
+function clearIndexes(memoryDir) {
+  try {
+    ensureStateDir(memoryDir);
+    writeJsonAtomic(temporalIndexPath(memoryDir), { version: INDEX_VERSION, dates: {} });
+    writeJsonAtomic(tagIndexPath(memoryDir), { version: INDEX_VERSION, tags: {} });
+  } catch {
+  }
+}
+function indexesExist(memoryDir) {
+  try {
+    return fs.existsSync(temporalIndexPath(memoryDir)) && fs.existsSync(tagIndexPath(memoryDir));
+  } catch {
+    return false;
+  }
+}
+function indexMemoriesBatch(memoryDir, entries) {
+  if (entries.length === 0) return;
+  try {
+    ensureStateDir(memoryDir);
+    const tPath = temporalIndexPath(memoryDir);
+    const tIndex = readJsonSafe(tPath, { version: INDEX_VERSION, dates: {} });
+    const gPath = tagIndexPath(memoryDir);
+    const gIndex = readJsonSafe(gPath, { version: INDEX_VERSION, tags: {} });
+    for (const entry of entries) {
+      const dateKey = isoDateFromTimestamp(entry.createdAt);
+      addPathToSet(tIndex.dates, dateKey, entry.path);
+      for (const tag of entry.tags) {
+        if (tag && typeof tag === "string") {
+          addPathToSet(gIndex.tags, tag.toLowerCase(), entry.path);
+        }
+      }
+    }
+    writeJsonAtomic(tPath, tIndex);
+    writeJsonAtomic(gPath, gIndex);
+  } catch {
+  }
+}
+async function queryByDateRangeAsync(memoryDir, fromDate, toDate) {
+  try {
+    const tPath = temporalIndexPath(memoryDir);
+    let raw;
+    try {
+      raw = await fs.promises.readFile(tPath, "utf8");
+    } catch {
+      return null;
+    }
+    let tIndex;
+    try {
+      tIndex = JSON.parse(raw);
+    } catch {
+      tIndex = { version: INDEX_VERSION, dates: {} };
+    }
+    const end = toDate ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const results = /* @__PURE__ */ new Set();
+    for (const [date, paths] of Object.entries(tIndex.dates)) {
+      if (date >= fromDate && date <= end) {
+        for (const p of paths) {
+          results.add(p);
+        }
+      }
+    }
+    return results;
+  } catch {
+    return null;
+  }
+}
+async function queryByTagsAsync(memoryDir, tags) {
+  if (tags.length === 0) return null;
+  try {
+    const gPath = tagIndexPath(memoryDir);
+    let raw;
+    try {
+      raw = await fs.promises.readFile(gPath, "utf8");
+    } catch {
+      return null;
+    }
+    let gIndex;
+    try {
+      gIndex = JSON.parse(raw);
+    } catch {
+      gIndex = { version: INDEX_VERSION, tags: {} };
+    }
+    const results = /* @__PURE__ */ new Set();
+    for (const tag of tags) {
+      const key = tag.toLowerCase();
+      const paths = gIndex.tags[key] ?? [];
+      for (const p of paths) {
+        results.add(p);
+      }
+    }
+    return results.size > 0 ? results : null;
+  } catch {
+    return null;
+  }
+}
+function extractTagsFromPrompt(prompt) {
+  const found = /* @__PURE__ */ new Set();
+  const hashMatches = prompt.matchAll(/#([a-zA-Z][\w-]{1,30})/g);
+  for (const m of hashMatches) {
+    found.add(m[1].toLowerCase());
+  }
+  return Array.from(found);
+}
+function isTemporalQuery(prompt) {
+  return /\b(today|yesterday|this week|last week|this month|last month|recent(?:ly)?|lately|just now|earlier today|this morning|last night|\d+ days? ago|\d+ hours? ago)\b/i.test(
+    prompt
+  );
+}
+function recencyWindowFromPrompt(prompt, nowMs = Date.now()) {
+  const p = prompt.toLowerCase();
+  let daysBack = 7;
+  if (/\btoday\b/.test(p) || /\bthis morning\b/.test(p) || /\bjust now\b/.test(p) || /\bearlier today\b/.test(p)) {
+    daysBack = 0;
+  } else if (/\byesterday\b/.test(p) || /\blast night\b/.test(p)) {
+    daysBack = 1;
+  } else if (/\bthis week\b/.test(p)) {
+    daysBack = 7;
+  } else if (/\blast week\b/.test(p)) {
+    daysBack = 14;
+  } else if (/\bthis month\b/.test(p)) {
+    daysBack = 31;
+  } else if (/\blast month\b/.test(p)) {
+    daysBack = 62;
+  } else {
+    const numMatch = p.match(/(\d{1,5})\s*days?\s*ago/);
+    if (numMatch) {
+      daysBack = Math.min(365, parseInt(numMatch[1], 10));
+    } else {
+      const hrMatch = p.match(/(\d{1,5})\s*hours?\s*ago/);
+      if (hrMatch) {
+        daysBack = Math.max(1, Math.ceil(parseInt(hrMatch[1], 10) / 24));
+      }
+    }
+  }
+  const from = new Date(nowMs - daysBack * 24 * 60 * 60 * 1e3);
+  return from.toISOString().slice(0, 10);
+}
+
 // src/conversation-index/chunker.ts
 function chunkTranscriptEntries(sessionKey, entries, opts) {
   const maxChars = Math.max(500, opts.maxChars);
@@ -8412,7 +8661,7 @@ function chunkTranscriptEntries(sessionKey, entries, opts) {
 
 // src/conversation-index/indexer.ts
 import { mkdir as mkdir11, writeFile as writeFile11 } from "fs/promises";
-import path14 from "path";
+import path15 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);
@@ -8422,9 +8671,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 = path14.join(rootDir, safe, date);
+    const dir = path15.join(rootDir, safe, date);
     await mkdir11(dir, { recursive: true });
-    const fp = path14.join(dir, `${c.id}.md`);
+    const fp = path15.join(dir, `${c.id}.md`);
     const content = `---
 kind: conversation_chunk
 sessionKey: ${c.sessionKey}
@@ -8441,7 +8690,7 @@ endTs: ${c.endTs}
 
 // src/conversation-index/cleanup.ts
 import { readdir as readdir7, rm } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 async function cleanupConversationChunks(rootDir, retentionDays) {
   if (!Number.isFinite(retentionDays) || retentionDays <= 0) return;
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
@@ -8449,7 +8698,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
     const sessions = await readdir7(rootDir, { withFileTypes: true });
     for (const s of sessions) {
       if (!s.isDirectory()) continue;
-      const sessionDir = path15.join(rootDir, s.name);
+      const sessionDir = path16.join(rootDir, s.name);
       const dayDirs = await readdir7(sessionDir, { withFileTypes: true });
       for (const d of dayDirs) {
         if (!d.isDirectory()) continue;
@@ -8457,7 +8706,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 rm(path15.join(sessionDir, d.name), { recursive: true, force: true });
+          await rm(path16.join(sessionDir, d.name), { recursive: true, force: true });
         }
       }
       try {
@@ -8474,7 +8723,7 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
 }
 
 // src/namespaces/storage.ts
-import path16 from "path";
+import path17 from "path";
 import { access } from "fs/promises";
 async function exists(p) {
   try {
@@ -8496,7 +8745,7 @@ var NamespaceStorageRouter = class {
       this.defaultNsRootResolved = this.config.memoryDir;
       return this.defaultNsRootResolved;
     }
-    const nsDir = path16.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
+    const nsDir = path17.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
     this.defaultNsRootResolved = await exists(nsDir) ? nsDir : this.config.memoryDir;
     return this.defaultNsRootResolved;
   }
@@ -8505,7 +8754,7 @@ var NamespaceStorageRouter = class {
     if (namespace === this.config.defaultNamespace) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }
-    return path16.join(this.config.memoryDir, "namespaces", namespace);
+    return path17.join(this.config.memoryDir, "namespaces", namespace);
   }
   async storageFor(namespace) {
     const ns = namespace || this.config.defaultNamespace;
@@ -8582,7 +8831,7 @@ function recallNamespacesForPrincipal(principal, config) {
 
 // src/shared-context/manager.ts
 import { mkdir as mkdir12, readFile as readFile12, readdir as readdir8, appendFile as appendFile3, writeFile as writeFile12, stat as stat2 } from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
 var SharedFeedbackEntrySchema = z3.object({
@@ -8604,15 +8853,15 @@ function ymd(d) {
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path17.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path18.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
     this.dir = base;
-    this.prioritiesPath = path17.join(base, "priorities.md");
-    this.prioritiesInboxPath = path17.join(base, "priorities.inbox.md");
-    this.outputsDir = path17.join(base, "agent-outputs");
-    this.roundtableDir = path17.join(base, "roundtable");
-    this.feedbackDir = path17.join(base, "feedback");
-    this.feedbackInboxPath = path17.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path17.join(base, "cross-signals");
+    this.prioritiesPath = path18.join(base, "priorities.md");
+    this.prioritiesInboxPath = path18.join(base, "priorities.inbox.md");
+    this.outputsDir = path18.join(base, "agent-outputs");
+    this.roundtableDir = path18.join(base, "roundtable");
+    this.feedbackDir = path18.join(base, "feedback");
+    this.feedbackInboxPath = path18.join(this.feedbackDir, "inbox.jsonl");
+    this.crossSignalsDir = path18.join(base, "cross-signals");
   }
   dir;
   prioritiesPath;
@@ -8628,10 +8877,10 @@ var SharedContextManager = class {
     await mkdir12(this.roundtableDir, { recursive: true });
     await mkdir12(this.feedbackDir, { recursive: true });
     await mkdir12(this.crossSignalsDir, { recursive: true });
-    await mkdir12(path17.join(this.dir, "staging"), { recursive: true });
-    await mkdir12(path17.join(this.dir, "kpis"), { recursive: true });
-    await mkdir12(path17.join(this.dir, "calendar"), { recursive: true });
-    await mkdir12(path17.join(this.dir, "content-calendar"), { recursive: true });
+    await mkdir12(path18.join(this.dir, "staging"), { recursive: true });
+    await mkdir12(path18.join(this.dir, "kpis"), { recursive: true });
+    await mkdir12(path18.join(this.dir, "calendar"), { recursive: true });
+    await mkdir12(path18.join(this.dir, "content-calendar"), { recursive: true });
     await this.ensureFile(
       this.prioritiesPath,
       [
@@ -8675,7 +8924,7 @@ var SharedContextManager = class {
   async readLatestRoundtable() {
     try {
       const files = (await readdir8(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path17.join(this.roundtableDir, files[0]) : null;
+      const fp = files[0] ? path18.join(this.roundtableDir, files[0]) : null;
       if (!fp) return "";
       return await readFile12(fp, "utf-8");
     } catch {
@@ -8687,9 +8936,9 @@ var SharedContextManager = class {
     const date = ymd(createdAt);
     const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
     const slug = safeSlug(opts.title);
-    const dir = path17.join(this.outputsDir, opts.agentId, date);
+    const dir = path18.join(this.outputsDir, opts.agentId, date);
     await mkdir12(dir, { recursive: true });
-    const fp = path17.join(dir, `${time}-${slug}.md`);
+    const fp = path18.join(dir, `${time}-${slug}.md`);
     const body = `---
 kind: agent_output
 agent: ${opts.agentId}
@@ -8724,11 +8973,11 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
       const agents = await readdir8(this.outputsDir, { withFileTypes: true });
       for (const a of agents) {
         if (!a.isDirectory()) continue;
-        const dayDir = path17.join(this.outputsDir, a.name, date);
+        const dayDir = path18.join(this.outputsDir, a.name, date);
         try {
           const files = (await readdir8(dayDir)).filter((f) => f.endsWith(".md")).sort();
           for (const f of files) {
-            const p = path17.join(dayDir, f);
+            const p = path18.join(dayDir, f);
             const raw = await readFile12(p, "utf-8");
             const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
             outputs.push({ path: p, title });
@@ -8768,7 +9017,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
     ];
     const out = md.join("\n");
     const trimmed = out.length > maxChars ? out.slice(0, maxChars) + "\n\n...(trimmed)\n" : out;
-    const fp = path17.join(this.roundtableDir, `${date}.md`);
+    const fp = path18.join(this.roundtableDir, `${date}.md`);
     await writeFile12(fp, trimmed, "utf-8");
     log.info(`shared-context curated daily roundtable: ${fp}`);
     return fp;
@@ -8777,7 +9026,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 
 // src/compounding/engine.ts
 import { mkdir as mkdir13, readFile as readFile13, writeFile as writeFile13 } from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import os4 from "os";
 function isoWeekId(d) {
   const dt = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
@@ -8792,28 +9041,28 @@ function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
   }
-  return path18.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
+  return path19.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
 }
 var CompoundingEngine = class {
   constructor(config) {
     this.config = config;
-    this.weeklyDir = path18.join(config.memoryDir, "compounding", "weekly");
-    this.mistakesPath = path18.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path18.join(sharedContextDir(config), "feedback", "inbox.jsonl");
+    this.weeklyDir = path19.join(config.memoryDir, "compounding", "weekly");
+    this.mistakesPath = path19.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = path19.join(sharedContextDir(config), "feedback", "inbox.jsonl");
   }
   weeklyDir;
   mistakesPath;
   feedbackInboxPath;
   async ensureDirs() {
     await mkdir13(this.weeklyDir, { recursive: true });
-    await mkdir13(path18.dirname(this.mistakesPath), { recursive: true });
+    await mkdir13(path19.dirname(this.mistakesPath), { recursive: true });
   }
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
     const weekId = opts?.weekId ?? isoWeekId(/* @__PURE__ */ new Date());
     const entries = await this.readFeedbackEntriesForWeek(weekId);
     const mistakes = this.buildMistakes(entries);
-    const reportPath = path18.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path19.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns);
     await writeFile13(reportPath, md, "utf-8");
     await writeFile13(this.mistakesPath, JSON.stringify(mistakes, null, 2) + "\n", "utf-8");
@@ -9057,7 +9306,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 = path19.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path20.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -9067,7 +9316,7 @@ var Orchestrator = class _Orchestrator {
     this.localLlm = new LocalLlmClient(config, this.modelRegistry);
     this.extraction = new ExtractionEngine(config, this.localLlm, config.gatewayConfig, this.modelRegistry);
     this.threading = new ThreadingManager(
-      path19.join(config.memoryDir, "threads"),
+      path20.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.initPromise = new Promise((resolve) => {
@@ -9169,8 +9418,8 @@ var Orchestrator = class _Orchestrator {
     await this.negatives.load();
     await this.lastRecall.load();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir = path19.join(this.config.memoryDir, "state");
-      this.contentHashIndex = new ContentHashIndex(stateDir);
+      const stateDir2 = path20.join(this.config.memoryDir, "state");
+      this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
     }
@@ -9207,7 +9456,7 @@ var Orchestrator = class _Orchestrator {
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path19.join(this.config.memoryDir, "conversation-index")
+          path20.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -9243,12 +9492,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path19.isAbsolute(rel) ? rel : path19.join(this.config.workspaceDir, rel);
+        const abs = path20.isAbsolute(rel) ? rel : path20.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile14(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path19.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path19.basename(abs);
+            const archiveDir = path20.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path20.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -9273,8 +9522,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path19.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir14(path19.dirname(fp), { recursive: true });
+        const fp = path20.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir14(path20.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -9803,21 +10052,26 @@ ${boxLines.join("\n")}`);
           const activeMemories = memories.filter(
             (m) => !m.frontmatter.status || m.frontmatter.status === "active"
           );
-          const recent = activeMemories.sort(
+          const recentSorted = activeMemories.sort(
             (a, b) => new Date(b.frontmatter.updated).getTime() - new Date(a.frontmatter.updated).getTime()
-          ).slice(0, recallResultLimit);
-          const memoryIds = recent.map((m) => m.frontmatter.id);
+          );
+          const preloadedMap = new Map(
+            activeMemories.filter((m) => m.path).map((m) => [m.path, m])
+          );
+          const recentAsResults = recentSorted.map((m, i) => ({
+            docid: m.frontmatter.id,
+            path: m.path,
+            snippet: m.content,
+            score: 1 - i / Math.max(recentSorted.length, 1)
+          }));
+          const recent = (await this.boostSearchResults(recentAsResults, recallNamespaces, prompt, preloadedMap)).sort((a, b) => b.score - a.score).slice(0, recallResultLimit);
+          const memoryIds = recent.map((r) => r.docid).filter(Boolean);
           this.trackMemoryAccess(memoryIds);
           if (sessionKey) {
             const unique = Array.from(new Set(memoryIds)).slice(0, 40);
             this.lastRecall.record({ sessionKey, query: prompt, memoryIds: unique }).catch((err) => log.debug(`last recall record failed: ${err}`));
           }
-          const lines = recent.map(
-            (m) => `- [${m.frontmatter.category}] ${m.content}`
-          );
-          sections.push(`## Recent Memories
-
-${lines.join("\n")}`);
+          sections.push(this.formatQmdResults("Recent Memories", recent));
         }
       }
       if (isDisagreementPrompt(prompt)) {
@@ -10234,7 +10488,8 @@ _Context: ${topQuestion.context}_`);
             this.contentHashIndex.add(fact.content);
           }
           for (const chunk of chunkResult.chunks) {
-            await this.indexPersistedMemory(storage, `${parentId}-chunk-${chunk.index}`);
+            const chunkId = `${parentId}-chunk-${chunk.index}`;
+            await this.indexPersistedMemory(storage, chunkId);
           }
           if (this.config.verbatimArtifactsEnabled && this.config.verbatimArtifactCategories.includes(fact.category) && fact.confidence >= this.config.verbatimArtifactsMinConfidence) {
             await storage.writeArtifact(fact.content, {
@@ -10262,6 +10517,14 @@ _Context: ${topQuestion.context}_`);
             strength: contradiction.confidence,
             reason: contradiction.reason
           });
+          if (this.config.queryAwareIndexingEnabled && contradiction.supersededPath) {
+            deindexMemory(
+              this.config.memoryDir,
+              contradiction.supersededPath,
+              contradiction.supersededCreated,
+              contradiction.supersededTags
+            );
+          }
         }
       }
       if (this.config.memoryLinkingEnabled && this.qmd.isAvailable()) {
@@ -10366,6 +10629,9 @@ _Context: ${topQuestion.context}_`);
     log.info(
       `persisted: ${facts.length - dedupedCount} facts${dedupSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
     );
+    this.updateTemporalTagIndexes(storage, persistedIds).catch(
+      (err) => log.debug(`temporal-index update error (non-fatal): ${err}`)
+    );
     return persistedIds;
   }
   async indexPersistedMemory(storage, memoryId) {
@@ -10375,6 +10641,52 @@ _Context: ${topQuestion.context}_`);
     if (!memory) return;
     await this.embeddingFallback.indexFile(memoryId, memory.content, memory.path);
   }
+  /**
+   * Batch-update temporal and tag indexes after extraction (v8.1).
+   * Reads each persisted memory's path + frontmatter and adds them to
+   * state/index_time.json and state/index_tags.json.
+   * Fail-open: any error is logged but does not abort extraction.
+   */
+  async updateTemporalTagIndexes(storage, persistedIds) {
+    if (!this.config.queryAwareIndexingEnabled) return;
+    const needsFullRebuild = !indexesExist(this.config.memoryDir);
+    if (!needsFullRebuild && persistedIds.length === 0) return;
+    try {
+      const allMemories = needsFullRebuild && this.config.namespacesEnabled ? await this.readAllMemoriesForNamespaces(
+        Array.from(/* @__PURE__ */ new Set([
+          this.config.defaultNamespace,
+          this.config.sharedNamespace,
+          ...this.config.namespacePolicies.map((p) => p.name)
+        ]))
+      ) : await storage.readAllMemories();
+      const isActive = (m) => !m.frontmatter.status || m.frontmatter.status === "active";
+      const pool = needsFullRebuild ? allMemories.filter(isActive) : (() => {
+        const idSet = new Set(persistedIds);
+        return allMemories.filter((m) => idSet.has(m.frontmatter.id));
+      })();
+      const entries = [];
+      for (const mem of pool) {
+        if (mem.path && mem.frontmatter?.created) {
+          entries.push({
+            path: mem.path,
+            createdAt: mem.frontmatter.created,
+            tags: mem.frontmatter.tags ?? []
+          });
+        }
+      }
+      if (needsFullRebuild) {
+        clearIndexes(this.config.memoryDir);
+        if (entries.length > 0) {
+          indexMemoriesBatch(this.config.memoryDir, entries);
+        }
+        log.info(`temporal-index: bootstrapped from ${entries.length} active memories`);
+      } else if (entries.length > 0) {
+        indexMemoriesBatch(this.config.memoryDir, entries);
+      }
+    } catch (err) {
+      log.debug(`temporal-index update failed (non-fatal): ${err}`);
+    }
+  }
   /** IDs of facts persisted in the last extraction */
   lastPersistedIds = [];
   async runConsolidation() {
@@ -10396,14 +10708,25 @@ _Context: ${topQuestion.context}_`);
     );
     const profile = await this.storage.readProfile();
     const result = await this.extraction.consolidate(recent, older, profile);
+    const memoryLookup = this.config.queryAwareIndexingEnabled ? new Map(allMemories.map((m) => [m.frontmatter.id, m])) : null;
     for (const item of result.items) {
       switch (item.action) {
-        case "INVALIDATE":
+        case "INVALIDATE": {
+          const toInvalidate = this.config.queryAwareIndexingEnabled ? memoryLookup?.get(item.existingId) ?? null : null;
           if (await this.storage.invalidateMemory(item.existingId)) {
             invalidated += 1;
             await this.embeddingFallback.removeFromIndex(item.existingId);
+            if (toInvalidate?.path && toInvalidate.frontmatter?.created) {
+              deindexMemory(
+                this.config.memoryDir,
+                toInvalidate.path,
+                toInvalidate.frontmatter.created,
+                toInvalidate.frontmatter.tags ?? []
+              );
+            }
           }
           break;
+        }
         case "UPDATE":
           if (item.updatedContent) {
             await this.storage.updateMemory(item.existingId, item.updatedContent, {
@@ -10419,10 +10742,19 @@ _Context: ${topQuestion.context}_`);
               lineage: [item.existingId, item.mergeWith]
             });
             await this.indexPersistedMemory(this.storage, item.existingId);
+            const toMergeInvalidate = this.config.queryAwareIndexingEnabled ? memoryLookup?.get(item.mergeWith) ?? null : null;
             if (await this.storage.invalidateMemory(item.mergeWith)) {
               invalidated += 1;
               merged += 1;
               await this.embeddingFallback.removeFromIndex(item.mergeWith);
+              if (toMergeInvalidate?.path && toMergeInvalidate.frontmatter?.created) {
+                deindexMemory(
+                  this.config.memoryDir,
+                  toMergeInvalidate.path,
+                  toMergeInvalidate.frontmatter.created,
+                  toMergeInvalidate.frontmatter.tags ?? []
+                );
+              }
             }
           }
           break;
@@ -10477,13 +10809,23 @@ _Context: ${topQuestion.context}_`);
         log.debug(`entity summary pass failed: ${err}`);
       }
     }
-    const cleaned = await this.storage.cleanExpiredCommitments(this.config.commitmentDecayDays);
-    if (cleaned > 0) {
-      log.info(`cleaned ${cleaned} expired commitments`);
+    const deletedCommitments = await this.storage.cleanExpiredCommitments(this.config.commitmentDecayDays);
+    if (deletedCommitments.length > 0) {
+      log.info(`cleaned ${deletedCommitments.length} expired commitments`);
+      if (this.config.queryAwareIndexingEnabled) {
+        for (const m of deletedCommitments) {
+          deindexMemory(this.config.memoryDir, m.path, m.frontmatter.created, m.frontmatter.tags ?? []);
+        }
+      }
     }
-    const ttlCleaned = await this.storage.cleanExpiredTTL();
-    if (ttlCleaned > 0) {
-      log.info(`cleaned ${ttlCleaned} TTL-expired memories`);
+    const deletedTTL = await this.storage.cleanExpiredTTL();
+    if (deletedTTL.length > 0) {
+      log.info(`cleaned ${deletedTTL.length} TTL-expired memories`);
+      if (this.config.queryAwareIndexingEnabled) {
+        for (const m of deletedTTL) {
+          deindexMemory(this.config.memoryDir, m.path, m.frontmatter.created, m.frontmatter.tags ?? []);
+        }
+      }
     }
     if (this.config.factArchivalEnabled) {
       const archived = await this.runFactArchival(allMemories);
@@ -10544,6 +10886,14 @@ _Context: ${topQuestion.context}_`);
           this.contentHashIndex.remove(memory.content);
         }
         await this.embeddingFallback.removeFromIndex(memory.frontmatter.id);
+        if (this.config.queryAwareIndexingEnabled && memory.path && memory.frontmatter?.created) {
+          deindexMemory(
+            this.config.memoryDir,
+            memory.path,
+            memory.frontmatter.created,
+            memory.frontmatter.tags ?? []
+          );
+        }
         archivedCount++;
       }
     }
@@ -10671,7 +11021,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path19.isAbsolute(hit.path) ? hit.path : path19.join(this.config.memoryDir, hit.path);
+      const fullPath = path20.isAbsolute(hit.path) ? hit.path : path20.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -10751,18 +11101,48 @@ ${lines.join("\n\n")}`;
    * Apply recency, access count, and importance boosting to QMD search results.
    * Returns re-ranked results.
    */
-  async boostSearchResults(results, _recallNamespaces, prompt) {
+  async boostSearchResults(results, _recallNamespaces, prompt, preloadedMemoryMap) {
     if (results.length === 0) return results;
     const now = Date.now();
-    const memoryByPath = /* @__PURE__ */ new Map();
-    await Promise.all(
-      results.map(async (r) => {
-        if (!r.path || memoryByPath.has(r.path)) return;
-        const mem = await this.storage.readMemoryByPath(r.path);
-        if (mem) memoryByPath.set(r.path, mem);
-      })
-    );
+    const memoryByPath = preloadedMemoryMap ? new Map(preloadedMemoryMap) : /* @__PURE__ */ new Map();
+    const resultPaths = new Set(results.map((r) => r.path).filter(Boolean));
+    let temporalFromDate = null;
+    let promptTags = [];
+    if (this.config.queryAwareIndexingEnabled && prompt) {
+      if (isTemporalQuery(prompt)) {
+        temporalFromDate = recencyWindowFromPrompt(prompt, now);
+      }
+      promptTags = extractTagsFromPrompt(prompt);
+    }
+    const [, rawTemporal, rawTags] = await Promise.all([
+      Promise.all(
+        results.map(async (r) => {
+          if (!r.path || memoryByPath.has(r.path)) return;
+          const mem = await this.storage.readMemoryByPath(r.path);
+          if (mem) memoryByPath.set(r.path, mem);
+        })
+      ),
+      temporalFromDate !== null ? queryByDateRangeAsync(this.config.memoryDir, temporalFromDate) : Promise.resolve(null),
+      promptTags.length > 0 ? queryByTagsAsync(this.config.memoryDir, promptTags) : Promise.resolve(null)
+    ]);
     const queryIntent = this.config.intentRoutingEnabled && prompt ? inferIntentFromText(prompt) : null;
+    let temporalCandidates = null;
+    let tagCandidates = null;
+    if (this.config.queryAwareIndexingEnabled && prompt) {
+      const maxCandidates = this.config.queryAwareIndexingMaxCandidates;
+      const capSet = (s) => {
+        if (!s) return null;
+        const scoped = new Set(Array.from(s).filter((p) => resultPaths.has(p)));
+        if (maxCandidates === 0 || scoped.size <= maxCandidates) return scoped.size > 0 ? scoped : null;
+        return new Set(Array.from(scoped).slice(0, maxCandidates));
+      };
+      if (temporalFromDate !== null) {
+        temporalCandidates = capSet(rawTemporal);
+      }
+      if (promptTags.length > 0) {
+        tagCandidates = capSet(rawTags);
+      }
+    }
     const boosted = results.map((r) => {
       const memory = memoryByPath.get(r.path);
       let score = r.score;
@@ -10809,6 +11189,14 @@ ${lines.join("\n\n")}`;
           });
           score += compatibility * this.config.intentRoutingBoost;
         }
+        if (this.config.queryAwareIndexingEnabled && r.path) {
+          if (temporalCandidates?.has(r.path)) {
+            score += 0.08;
+          }
+          if (tagCandidates?.has(r.path)) {
+            score += 0.06;
+          }
+        }
       }
       return { ...r, score };
     });
@@ -10877,7 +11265,10 @@ ${lines.join("\n\n")}`;
             return {
               supersededId: existingMemory.frontmatter.id,
               confidence: verification.confidence,
-              reason: verification.reasoning
+              reason: verification.reasoning,
+              supersededPath: existingMemory.path,
+              supersededCreated: existingMemory.frontmatter.created,
+              supersededTags: existingMemory.frontmatter.tags ?? []
             };
           }
         }
@@ -10942,7 +11333,7 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path20 from "path";
+import path21 from "path";
 import { Type } from "@sinclair/typebox";
 function toolResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
@@ -11217,6 +11608,12 @@ Best for:
             source: "explicit"
           }
         );
+        if (orchestrator.config.queryAwareIndexingEnabled && indexesExist(orchestrator.config.memoryDir)) {
+          const mem = await storage.getMemoryById(id).catch(() => null);
+          if (mem?.path && mem.frontmatter?.created) {
+            indexMemory(orchestrator.config.memoryDir, mem.path, mem.frontmatter.created, mem.frontmatter.tags ?? []);
+          }
+        }
         orchestrator.requestQmdMaintenanceForTool("memory_store");
         return toolResult(`Memory stored: ${id}${namespace ? ` (namespace: ${namespace})` : ""}
 
@@ -11274,6 +11671,12 @@ Content: ${content}`);
           supersedes: mem.frontmatter.supersedes,
           links: mem.frontmatter.links
         });
+        if (orchestrator.config.queryAwareIndexingEnabled && indexesExist(orchestrator.config.memoryDir)) {
+          const promoted = await dst.getMemoryById(newId).catch(() => null);
+          if (promoted?.path && promoted.frontmatter?.created) {
+            indexMemory(orchestrator.config.memoryDir, promoted.path, promoted.frontmatter.created, promoted.frontmatter.tags ?? []);
+          }
+        }
         return toolResult(`Promoted ${srcNs}:${memoryId} \u2192 ${dstNs}:${newId}`);
       }
     },
@@ -11420,7 +11823,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path20.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path21.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.");
@@ -11669,11 +12072,11 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path30 from "path";
+import path31 from "path";
 import { access as access2, readFile as readFile20 } from "fs/promises";
 
 // src/transfer/export-json.ts
-import path22 from "path";
+import path23 from "path";
 import { mkdir as mkdir16, readFile as readFile16 } from "fs/promises";
 
 // src/transfer/constants.ts
@@ -11683,7 +12086,7 @@ var EXPORT_SCHEMA_VERSION = 1;
 // src/transfer/fs-utils.ts
 import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir15, readdir as readdir9, readFile as readFile15, stat as stat3, writeFile as writeFile15 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 async function sha256File(filePath) {
   const buf = await readFile15(filePath);
   const sha256 = createHash5("sha256").update(buf).digest("hex");
@@ -11695,7 +12098,7 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir15(path21.dirname(filePath), { recursive: true });
+  await mkdir15(path22.dirname(filePath), { recursive: true });
   await writeFile15(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile(filePath) {
@@ -11707,7 +12110,7 @@ async function listFilesRecursive(rootDir) {
   async function walk(dir) {
     const entries = await readdir9(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path21.join(dir, ent.name);
+      const fp = path22.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -11727,11 +12130,11 @@ async function fileExists(filePath) {
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path21.relative(rootDir, absPath);
-  return rel.split(path21.sep).join("/");
+  const rel = path22.relative(rootDir, absPath);
+  return rel.split(path22.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path21.sep);
+  return relPath.split("/").join(path22.sep);
 }
 
 // src/transfer/export-json.ts
@@ -11747,9 +12150,9 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path22.resolve(opts.outDir);
+  const outDirAbs = path23.resolve(opts.outDir);
   await mkdir16(outDirAbs, { recursive: true });
-  const memoryDirAbs = path22.resolve(opts.memoryDir);
+  const memoryDirAbs = path23.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memoryDirAbs);
   const records = [];
   const manifestFiles = [];
@@ -11762,7 +12165,7 @@ async function exportJsonBundle(opts) {
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
   if (opts.includeWorkspaceIdentity !== false && opts.workspaceDir) {
-    const identityPath = path22.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path23.join(opts.workspaceDir, "IDENTITY.md");
     try {
       const content = await readFile16(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
@@ -11781,12 +12184,12 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path22.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path22.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path23.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path23.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path23 from "path";
+import path24 from "path";
 import { mkdir as mkdir17, readFile as readFile17, writeFile as writeFile16 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
@@ -11795,16 +12198,16 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path23.resolve(opts.outDir);
+  const outDirAbs = path24.resolve(opts.outDir);
   await mkdir17(outDirAbs, { recursive: true });
-  const memDirAbs = path23.resolve(opts.memoryDir);
+  const memDirAbs = path24.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 = path23.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir17(path23.dirname(dstAbs), { recursive: true });
+    const dstAbs = path24.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir17(path24.dirname(dstAbs), { recursive: true });
     const content = await readFile17(abs);
     await writeFile16(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
@@ -11818,12 +12221,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path23.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path24.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path23.resolve(fromDir);
+  const dirAbs = path24.resolve(fromDir);
   try {
-    const raw = await readFile17(path23.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile17(path24.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -11832,16 +12235,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path24 from "path";
+import path25 from "path";
 import { mkdir as mkdir18, readdir as readdir10, rm as rm2 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path24.resolve(opts.outDir);
+  const outDirAbs = path25.resolve(opts.outDir);
   await mkdir18(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path24.join(outDirAbs, ts);
+  const backupDir = path25.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -11866,13 +12269,13 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm2(path24.join(outDirAbs, name), { recursive: true, force: true });
+      await rm2(path25.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path25 from "path";
+import path26 from "path";
 import Database from "better-sqlite3";
 import { readFile as readFile18 } from "fs/promises";
 
@@ -11900,8 +12303,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path25.resolve(opts.memoryDir);
-  const outAbs = path25.resolve(opts.outFile);
+  const memDirAbs = path26.resolve(opts.memoryDir);
+  const outAbs = path26.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -11933,7 +12336,7 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path26 from "path";
+import path27 from "path";
 import { mkdir as mkdir19, writeFile as writeFile17 } from "fs/promises";
 
 // src/transfer/types.ts
@@ -11967,21 +12370,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path26.resolve(opts.fromDir);
-  const bundlePath = path26.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path27.resolve(opts.fromDir);
+  const bundlePath = path27.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile(bundlePath));
-  const memDirAbs = path26.resolve(opts.targetMemoryDir);
+  const memDirAbs = path27.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 ? path26.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path27.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path26.join(targetBase, relFs);
+    const absTarget = path27.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -12005,21 +12408,21 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir19(path26.dirname(w.abs), { recursive: true });
+    await mkdir19(path27.dirname(w.abs), { recursive: true });
     await writeFile17(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path26.resolve(fromDir);
+  const dir = path27.resolve(fromDir);
   return Promise.all([
-    fileExists(path26.join(dir, "manifest.json")),
-    fileExists(path26.join(dir, "bundle.json"))
+    fileExists(path27.join(dir, "manifest.json")),
+    fileExists(path27.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path27 from "path";
+import path28 from "path";
 import Database2 from "better-sqlite3";
 import { mkdir as mkdir20, writeFile as writeFile18 } from "fs/promises";
 function normalizeForDedupe2(s) {
@@ -12027,8 +12430,8 @@ function normalizeForDedupe2(s) {
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path27.resolve(opts.targetMemoryDir);
-  const fromAbs = path27.resolve(opts.fromFile);
+  const memDirAbs = path28.resolve(opts.targetMemoryDir);
+  const fromAbs = path28.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -12041,7 +12444,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 = path27.join(memDirAbs, relFs);
+      const absTarget = path28.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -12066,29 +12469,29 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir20(path27.dirname(w.abs), { recursive: true });
+    await mkdir20(path28.dirname(w.abs), { recursive: true });
     await writeFile18(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path28 from "path";
+import path29 from "path";
 import { mkdir as mkdir21, readFile as readFile19, writeFile as writeFile19 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path28.resolve(opts.fromDir);
-  const targetAbs = path28.resolve(opts.targetMemoryDir);
+  const fromAbs = path29.resolve(opts.fromDir);
+  const targetAbs = path29.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 = path28.join(targetAbs, fromPosixRelPath(relPosix));
+    const dstAbs = path29.join(targetAbs, fromPosixRelPath(relPosix));
     const content = await readFile19(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
@@ -12111,17 +12514,17 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir21(path28.dirname(w.abs), { recursive: true });
+    await mkdir21(path29.dirname(w.abs), { recursive: true });
     await writeFile19(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path29 from "path";
+import path30 from "path";
 import { stat as stat4 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path29.resolve(fromPath);
+  const abs = path30.resolve(fromPath);
   let st;
   try {
     st = await stat4(abs);
@@ -12163,7 +12566,7 @@ 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 = path30.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path31.join(orchestrator.config.memoryDir, "namespaces", ns);
   if (ns === orchestrator.config.defaultNamespace) {
     return await exists2(candidate) ? candidate : orchestrator.config.memoryDir;
   }
@@ -12446,7 +12849,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path30.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path31.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -12586,8 +12989,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path30.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path30.join(memoryDir, "threads"));
+        const memoryDir = path31.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path31.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -12761,15 +13164,15 @@ function parseDuration(duration) {
 
 // src/index.ts
 import { readFile as readFile21, writeFile as writeFile20 } from "fs/promises";
-import { readFileSync as readFileSync3 } from "fs";
-import path31 from "path";
+import { readFileSync as readFileSync4 } from "fs";
+import path32 from "path";
 import os5 from "os";
 function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os5.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path31.join(homeDir, ".openclaw", "openclaw.json");
-    const content = readFileSync3(configPath, "utf-8");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path32.join(homeDir, ".openclaw", "openclaw.json");
+    const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
     return pluginEntry?.config;
@@ -12925,7 +13328,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 = path31.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path32.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {