@joshuaswarren/openclaw-engram 8.3.53 → 8.3.55

package/dist/index.js

@@ -425,7 +425,7 @@ function parseConfig(raw) {
 }
 
 // src/orchestrator.ts
-import path24 from "path";
+import path25 from "path";
 import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir18, readFile as readFile18, writeFile as writeFile17 } from "fs/promises";
 
@@ -10927,6 +10927,18 @@ endTs: ${c.endTs}
   }
   return written;
 }
+async function upsertConversationChunksFailOpen(adapter, chunks) {
+  if (!adapter) {
+    return { upserted: 0, skipped: true, reason: "adapter-unavailable" };
+  }
+  try {
+    const upserted = await adapter.upsertChunks(chunks);
+    return { upserted, skipped: false };
+  } catch (err) {
+    log.debug(`conversation index FAISS upsert failed (fail-open): ${err}`);
+    return { upserted: 0, skipped: true, reason: "adapter-error" };
+  }
+}
 
 // src/conversation-index/cleanup.ts
 import { readdir as readdir8, rm } from "fs/promises";
@@ -10962,8 +10974,212 @@ async function cleanupConversationChunks(rootDir, retentionDays) {
   }
 }
 
-// src/namespaces/storage.ts
+// src/conversation-index/faiss-adapter.ts
+import * as childProcess from "child_process";
+import { fileURLToPath } from "url";
 import path20 from "path";
+var FaissAdapterError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FaissAdapterError";
+  }
+};
+function resolveDefaultFaissScriptPath(fromModuleUrl = import.meta.url) {
+  const currentFile = fileURLToPath(fromModuleUrl);
+  const moduleDir = path20.dirname(currentFile);
+  if (moduleDir.endsWith(`${path20.sep}conversation-index`)) {
+    return path20.resolve(moduleDir, "..", "..", "scripts", "faiss_index.py");
+  }
+  return path20.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 = path20.isAbsolute(config.indexDir) ? config.indexDir : path20.join(config.memoryDir, config.indexDir);
+    this.spawnFn = config.spawnFn ?? childProcess.spawn;
+  }
+  pythonBin;
+  scriptPath;
+  indexPath;
+  spawnFn;
+  async upsertChunks(chunks) {
+    if (this.config.maxBatchSize <= 0) return 0;
+    let totalUpserted = 0;
+    for (let offset = 0; offset < chunks.length; offset += this.config.maxBatchSize) {
+      const batch = chunks.slice(offset, offset + this.config.maxBatchSize);
+      if (batch.length === 0) continue;
+      const payload = {
+        modelId: this.config.modelId,
+        indexPath: this.indexPath,
+        chunks: batch.map((chunk) => ({
+          id: chunk.id,
+          sessionKey: chunk.sessionKey,
+          text: chunk.text,
+          startTs: chunk.startTs,
+          endTs: chunk.endTs
+        }))
+      };
+      const result = await this.runCommand("upsert", payload, this.config.upsertTimeoutMs);
+      const upserted = result.upserted;
+      if (typeof upserted !== "number" || !Number.isFinite(upserted)) {
+        throw new FaissAdapterError("FAISS sidecar produced malformed upsert response", "malformed_output");
+      }
+      totalUpserted += Math.max(0, Math.floor(upserted));
+    }
+    return totalUpserted;
+  }
+  async searchChunks(query, topK) {
+    const requestedTopK = Number.isFinite(topK) ? Math.floor(topK) : 0;
+    const boundedTopK = this.config.maxSearchK > 0 ? Math.max(0, Math.min(requestedTopK, this.config.maxSearchK)) : 0;
+    if (boundedTopK <= 0 || query.trim().length === 0) return [];
+    const payload = {
+      modelId: this.config.modelId,
+      indexPath: this.indexPath,
+      query,
+      topK: boundedTopK
+    };
+    const result = await this.runCommand("search", payload, this.config.searchTimeoutMs);
+    if (!Array.isArray(result.results)) {
+      throw new FaissAdapterError("FAISS sidecar produced malformed search response", "malformed_output");
+    }
+    const rows = result.results;
+    return rows.filter(
+      (row) => row && typeof row.path === "string" && typeof row.snippet === "string" && typeof row.score === "number"
+    ).map((row) => ({ path: row.path, snippet: row.snippet, score: row.score }));
+  }
+  async health() {
+    const payload = {
+      modelId: this.config.modelId,
+      indexPath: this.indexPath
+    };
+    const result = await this.runCommand("health", payload, this.config.healthTimeoutMs);
+    if (result.status !== "ok" && result.status !== "degraded" && result.status !== "error") {
+      throw new FaissAdapterError("FAISS sidecar produced malformed health response", "malformed_output");
+    }
+    return {
+      ok: result.ok === true,
+      status: result.status,
+      indexPath: this.indexPath,
+      message: typeof result.error === "string" && result.error.length > 0 ? result.error : void 0
+    };
+  }
+  async runCommand(command, payload, timeoutMs) {
+    const args = [this.scriptPath, command];
+    const child = this.spawnFn(this.pythonBin, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let timedOut = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, timeoutMs) : void 0;
+    child.stdout.on("data", (chunk) => {
+      stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    let code;
+    try {
+      child.stdin.write(JSON.stringify(payload));
+      child.stdin.end();
+      code = await new Promise((resolve, reject) => {
+        const rejectAsProcessError = (err) => {
+          const msg = err instanceof Error ? err.message : String(err);
+          reject(new FaissAdapterError(`FAISS sidecar stream/process error (${command}): ${msg}`, "non_zero_exit"));
+        };
+        child.once("error", rejectAsProcessError);
+        child.stdin.once("error", rejectAsProcessError);
+        child.once("close", (exitCode) => resolve(exitCode));
+      });
+    } catch (err) {
+      if (err instanceof FaissAdapterError) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new FaissAdapterError(`FAISS sidecar stream/process error (${command}): ${msg}`, "non_zero_exit");
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+    const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
+    const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+    if (timedOut) {
+      throw new FaissAdapterError(
+        `FAISS sidecar command timed out (${command}, ${timeoutMs}ms)`,
+        "timeout"
+      );
+    }
+    if (code !== 0) {
+      throw new FaissAdapterError(
+        `FAISS sidecar exited non-zero (${command}, code=${code ?? "null"})${stderr ? `: ${stderr}` : ""}`,
+        "non_zero_exit"
+      );
+    }
+    if (stdout.length === 0) {
+      throw new FaissAdapterError(
+        `FAISS sidecar produced empty output (${command})`,
+        "malformed_output"
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(stdout);
+    } catch {
+      throw new FaissAdapterError(
+        `FAISS sidecar produced malformed JSON (${command})`,
+        "malformed_output"
+      );
+    }
+    if (parsed.ok === false) {
+      const message = typeof parsed.error === "string" && parsed.error.length > 0 ? parsed.error : `FAISS sidecar command failed (${command})`;
+      throw new FaissAdapterError(message, "non_zero_exit");
+    }
+    if (parsed.ok !== true) {
+      throw new FaissAdapterError(
+        `FAISS sidecar produced malformed success envelope (${command})`,
+        "malformed_output"
+      );
+    }
+    return parsed;
+  }
+};
+async function failOpenFaissHealth(adapter) {
+  if (!adapter) {
+    return { ok: false, status: "error", indexPath: "", message: "adapter-unavailable" };
+  }
+  try {
+    return await adapter.health();
+  } catch (err) {
+    log.debug(`faiss adapter health failed (fail-open): ${err}`);
+    return { ok: false, status: "error", indexPath: "", message: "adapter-error" };
+  }
+}
+
+// src/conversation-index/search.ts
+async function searchConversationIndex(qmd, query, maxResults) {
+  try {
+    const results = await qmd.search(query, void 0, maxResults);
+    return results.map((r) => ({ path: r.path, snippet: r.snippet, score: r.score }));
+  } catch (err) {
+    log.debug(`conversation index search failed: ${err}`);
+    return [];
+  }
+}
+async function searchConversationIndexFaissFailOpen(adapter, query, maxResults) {
+  if (!adapter) return [];
+  try {
+    return await adapter.searchChunks(query, maxResults);
+  } catch (err) {
+    log.debug(`conversation index FAISS search failed (fail-open): ${err}`);
+    return [];
+  }
+}
+
+// src/namespaces/storage.ts
+import path21 from "path";
 import { access } from "fs/promises";
 async function exists(p) {
   try {
@@ -10985,7 +11201,7 @@ var NamespaceStorageRouter = class {
       this.defaultNsRootResolved = this.config.memoryDir;
       return this.defaultNsRootResolved;
     }
-    const nsDir = path20.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
+    const nsDir = path21.join(this.config.memoryDir, "namespaces", this.config.defaultNamespace);
     this.defaultNsRootResolved = await exists(nsDir) ? nsDir : this.config.memoryDir;
     return this.defaultNsRootResolved;
   }
@@ -10994,7 +11210,7 @@ var NamespaceStorageRouter = class {
     if (namespace === this.config.defaultNamespace) {
       return this.defaultNsRootResolved ?? this.config.memoryDir;
     }
-    return path20.join(this.config.memoryDir, "namespaces", namespace);
+    return path21.join(this.config.memoryDir, "namespaces", namespace);
   }
   async storageFor(namespace) {
     const ns = namespace || this.config.defaultNamespace;
@@ -11071,7 +11287,7 @@ function recallNamespacesForPrincipal(principal, config) {
 
 // src/shared-context/manager.ts
 import { mkdir as mkdir15, readFile as readFile15, readdir as readdir9, appendFile as appendFile5, writeFile as writeFile14, stat as stat4 } from "fs/promises";
-import path21 from "path";
+import path22 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
 var SharedFeedbackEntrySchema = z3.object({
@@ -11093,15 +11309,15 @@ function ymd(d) {
 var SharedContextManager = class {
   constructor(config) {
     this.config = config;
-    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path21.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
+    const base = typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0 ? config.sharedContextDir : path22.join(os3.homedir(), ".openclaw", "workspace", "shared-context");
     this.dir = base;
-    this.prioritiesPath = path21.join(base, "priorities.md");
-    this.prioritiesInboxPath = path21.join(base, "priorities.inbox.md");
-    this.outputsDir = path21.join(base, "agent-outputs");
-    this.roundtableDir = path21.join(base, "roundtable");
-    this.feedbackDir = path21.join(base, "feedback");
-    this.feedbackInboxPath = path21.join(this.feedbackDir, "inbox.jsonl");
-    this.crossSignalsDir = path21.join(base, "cross-signals");
+    this.prioritiesPath = path22.join(base, "priorities.md");
+    this.prioritiesInboxPath = path22.join(base, "priorities.inbox.md");
+    this.outputsDir = path22.join(base, "agent-outputs");
+    this.roundtableDir = path22.join(base, "roundtable");
+    this.feedbackDir = path22.join(base, "feedback");
+    this.feedbackInboxPath = path22.join(this.feedbackDir, "inbox.jsonl");
+    this.crossSignalsDir = path22.join(base, "cross-signals");
   }
   dir;
   prioritiesPath;
@@ -11117,10 +11333,10 @@ var SharedContextManager = class {
     await mkdir15(this.roundtableDir, { recursive: true });
     await mkdir15(this.feedbackDir, { recursive: true });
     await mkdir15(this.crossSignalsDir, { recursive: true });
-    await mkdir15(path21.join(this.dir, "staging"), { recursive: true });
-    await mkdir15(path21.join(this.dir, "kpis"), { recursive: true });
-    await mkdir15(path21.join(this.dir, "calendar"), { recursive: true });
-    await mkdir15(path21.join(this.dir, "content-calendar"), { recursive: true });
+    await mkdir15(path22.join(this.dir, "staging"), { recursive: true });
+    await mkdir15(path22.join(this.dir, "kpis"), { recursive: true });
+    await mkdir15(path22.join(this.dir, "calendar"), { recursive: true });
+    await mkdir15(path22.join(this.dir, "content-calendar"), { recursive: true });
     await this.ensureFile(
       this.prioritiesPath,
       [
@@ -11164,7 +11380,7 @@ var SharedContextManager = class {
   async readLatestRoundtable() {
     try {
       const files = (await readdir9(this.roundtableDir)).filter((f) => f.endsWith(".md")).sort().reverse();
-      const fp = files[0] ? path21.join(this.roundtableDir, files[0]) : null;
+      const fp = files[0] ? path22.join(this.roundtableDir, files[0]) : null;
       if (!fp) return "";
       return await readFile15(fp, "utf-8");
     } catch {
@@ -11176,9 +11392,9 @@ var SharedContextManager = class {
     const date = ymd(createdAt);
     const time = createdAt.toISOString().slice(11, 19).replace(/:/g, "");
     const slug = safeSlug(opts.title);
-    const dir = path21.join(this.outputsDir, opts.agentId, date);
+    const dir = path22.join(this.outputsDir, opts.agentId, date);
     await mkdir15(dir, { recursive: true });
-    const fp = path21.join(dir, `${time}-${slug}.md`);
+    const fp = path22.join(dir, `${time}-${slug}.md`);
     const body = `---
 kind: agent_output
 agent: ${opts.agentId}
@@ -11213,11 +11429,11 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
       const agents = await readdir9(this.outputsDir, { withFileTypes: true });
       for (const a of agents) {
         if (!a.isDirectory()) continue;
-        const dayDir = path21.join(this.outputsDir, a.name, date);
+        const dayDir = path22.join(this.outputsDir, a.name, date);
         try {
           const files = (await readdir9(dayDir)).filter((f) => f.endsWith(".md")).sort();
           for (const f of files) {
-            const p = path21.join(dayDir, f);
+            const p = path22.join(dayDir, f);
             const raw = await readFile15(p, "utf-8");
             const title = (raw.match(/^title:\s*(.+)$/m)?.[1] ?? f).trim();
             outputs.push({ path: p, title });
@@ -11257,7 +11473,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 = path21.join(this.roundtableDir, `${date}.md`);
+    const fp = path22.join(this.roundtableDir, `${date}.md`);
     await writeFile14(fp, trimmed, "utf-8");
     log.info(`shared-context curated daily roundtable: ${fp}`);
     return fp;
@@ -11266,7 +11482,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
 
 // src/compounding/engine.ts
 import { mkdir as mkdir16, readFile as readFile16, readdir as readdir10, writeFile as writeFile15 } from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import os4 from "os";
 function isoWeekId(d) {
   const dt = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
@@ -11297,7 +11513,7 @@ function sharedContextDir(config) {
   if (typeof config.sharedContextDir === "string" && config.sharedContextDir.length > 0) {
     return config.sharedContextDir;
   }
-  return path22.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
+  return path23.join(os4.homedir(), ".openclaw", "workspace", "shared-context");
 }
 function cadenceStaleWindowMs(cadence) {
   switch (cadence) {
@@ -11316,14 +11532,14 @@ function cadenceStaleWindowMs(cadence) {
 var CompoundingEngine = class {
   constructor(config) {
     this.config = config;
-    this.weeklyDir = path22.join(config.memoryDir, "compounding", "weekly");
-    this.mistakesPath = path22.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path22.join(sharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAnchorPath = path22.join(config.memoryDir, "identity", "identity-anchor.md");
-    this.identityIncidentsDir = path22.join(config.memoryDir, "identity", "incidents");
-    this.identityAuditWeeklyDir = path22.join(config.memoryDir, "identity", "audits", "weekly");
-    this.identityAuditMonthlyDir = path22.join(config.memoryDir, "identity", "audits", "monthly");
-    this.identityImprovementLoopsPath = path22.join(config.memoryDir, "identity", "improvement-loops.md");
+    this.weeklyDir = path23.join(config.memoryDir, "compounding", "weekly");
+    this.mistakesPath = path23.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = path23.join(sharedContextDir(config), "feedback", "inbox.jsonl");
+    this.identityAnchorPath = path23.join(config.memoryDir, "identity", "identity-anchor.md");
+    this.identityIncidentsDir = path23.join(config.memoryDir, "identity", "incidents");
+    this.identityAuditWeeklyDir = path23.join(config.memoryDir, "identity", "audits", "weekly");
+    this.identityAuditMonthlyDir = path23.join(config.memoryDir, "identity", "audits", "monthly");
+    this.identityImprovementLoopsPath = path23.join(config.memoryDir, "identity", "improvement-loops.md");
   }
   weeklyDir;
   mistakesPath;
@@ -11335,7 +11551,7 @@ var CompoundingEngine = class {
   identityImprovementLoopsPath;
   async ensureDirs() {
     await mkdir16(this.weeklyDir, { recursive: true });
-    await mkdir16(path22.dirname(this.mistakesPath), { recursive: true });
+    await mkdir16(path23.dirname(this.mistakesPath), { recursive: true });
   }
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
@@ -11343,7 +11559,7 @@ var CompoundingEngine = class {
     const entries = await this.readFeedbackEntriesForWeek(weekId);
     const mistakes = this.buildMistakes(entries);
     const continuity = this.config.continuityAuditEnabled ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
-    const reportPath = path22.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path23.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, continuity);
     await writeFile15(reportPath, md, "utf-8");
     await writeFile15(this.mistakesPath, JSON.stringify(mistakes, null, 2) + "\n", "utf-8");
@@ -11423,7 +11639,7 @@ var CompoundingEngine = class {
     ];
     const dir = period === "weekly" ? this.identityAuditWeeklyDir : this.identityAuditMonthlyDir;
     await mkdir16(dir, { recursive: true });
-    const reportPath = path22.join(dir, `${key}.md`);
+    const reportPath = path23.join(dir, `${key}.md`);
     await writeFile15(reportPath, lines.join("\n"), "utf-8");
     return { period, key, reportPath };
   }
@@ -11552,7 +11768,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 = path22.join(this.identityIncidentsDir, file);
+        const filePath = path23.join(this.identityIncidentsDir, file);
         try {
           const raw = await readFile16(filePath, "utf-8");
           const parsed = parseContinuityIncident(raw);
@@ -11568,8 +11784,8 @@ var CompoundingEngine = class {
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
-    const weeklyPath = path22.join(this.identityAuditWeeklyDir, `${weekId}.md`);
-    const monthlyPath = path22.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyPath = path23.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path23.join(this.identityAuditMonthlyDir, `${monthId}.md`);
     const weeklyExists = await this.readNonEmptyFile(weeklyPath);
     const monthlyExists = await this.readNonEmptyFile(monthlyPath);
     return {
@@ -11685,7 +11901,7 @@ function selectRouteRule(text, rules, options) {
 
 // src/routing/store.ts
 import { lstat, mkdir as mkdir17, readFile as readFile17, realpath, rename as rename2, rm as rm2, stat as stat5, writeFile as writeFile16 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 import { createHash as createHash4 } from "crypto";
 function defaultState() {
   return {
@@ -11704,14 +11920,14 @@ function stableRuleId(rule) {
   return `route-${createHash4("sha256").update(seed).digest("hex").slice(0, 12)}`;
 }
 function resolveStatePath(memoryDir, stateFile) {
-  const root = path23.resolve(memoryDir);
-  const defaultPath = path23.join(root, "state", "routing-rules.json");
-  if (path23.isAbsolute(stateFile)) {
-    const absolute = path23.resolve(stateFile);
-    return absolute.startsWith(root + path23.sep) ? absolute : defaultPath;
+  const root = path24.resolve(memoryDir);
+  const defaultPath = path24.join(root, "state", "routing-rules.json");
+  if (path24.isAbsolute(stateFile)) {
+    const absolute = path24.resolve(stateFile);
+    return absolute.startsWith(root + path24.sep) ? absolute : defaultPath;
   }
-  const resolved = path23.resolve(root, stateFile);
-  return resolved.startsWith(root + path23.sep) ? resolved : defaultPath;
+  const resolved = path24.resolve(root, stateFile);
+  return resolved.startsWith(root + path24.sep) ? resolved : defaultPath;
 }
 function normalizeRule(rule, options) {
   if (!rule || typeof rule !== "object") return null;
@@ -11744,7 +11960,7 @@ var RoutingRulesStore = class {
   lockPath;
   writeQueue = Promise.resolve();
   constructor(memoryDir, stateFile = "state/routing-rules.json") {
-    this.memoryRoot = path23.resolve(memoryDir);
+    this.memoryRoot = path24.resolve(memoryDir);
     this.statePath = resolveStatePath(memoryDir, stateFile);
     this.lockPath = `${this.statePath}.lock`;
   }
@@ -11850,7 +12066,7 @@ var RoutingRulesStore = class {
     const timeoutMs = 5e3;
     let unexpectedLockError = null;
     await this.assertStatePathScoped();
-    await mkdir17(path23.dirname(this.lockPath), { recursive: true });
+    await mkdir17(path24.dirname(this.lockPath), { recursive: true });
     while (Date.now() - start < timeoutMs) {
       try {
         await mkdir17(this.lockPath);
@@ -11885,12 +12101,12 @@ var RoutingRulesStore = class {
   async assertStatePathScoped() {
     await mkdir17(this.memoryRoot, { recursive: true });
     const canonicalRoot = await realpath(this.memoryRoot);
-    const canonicalParent = await this.canonicalizePathWithoutCreating(path23.dirname(this.statePath));
-    const canonicalStatePath = path23.join(canonicalParent, path23.basename(this.statePath));
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path24.dirname(this.statePath));
+    const canonicalStatePath = path24.join(canonicalParent, path24.basename(this.statePath));
     if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
       throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
     }
-    await mkdir17(path23.dirname(this.statePath), { recursive: true });
+    await mkdir17(path24.dirname(this.statePath), { recursive: true });
     try {
       const stateStats = await lstat(this.statePath);
       if (stateStats.isSymbolicLink()) {
@@ -11907,28 +12123,28 @@ var RoutingRulesStore = class {
     }
   }
   isPathInside(root, candidate) {
-    const normalizedRoot = path23.resolve(root);
-    const normalizedCandidate = path23.resolve(candidate);
+    const normalizedRoot = path24.resolve(root);
+    const normalizedCandidate = path24.resolve(candidate);
     if (normalizedCandidate === normalizedRoot) return true;
-    if (normalizedRoot === path23.parse(normalizedRoot).root) {
+    if (normalizedRoot === path24.parse(normalizedRoot).root) {
       return normalizedCandidate.startsWith(normalizedRoot);
     }
-    return normalizedCandidate.startsWith(`${normalizedRoot}${path23.sep}`);
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path24.sep}`);
   }
   async canonicalizePathWithoutCreating(targetPath) {
-    const absoluteTarget = path23.resolve(targetPath);
+    const absoluteTarget = path24.resolve(targetPath);
     let probe = absoluteTarget;
     while (true) {
       try {
         const canonicalProbe = await realpath(probe);
-        const remainder = path23.relative(probe, absoluteTarget);
-        return path23.resolve(canonicalProbe, remainder);
+        const remainder = path24.relative(probe, absoluteTarget);
+        return path24.resolve(canonicalProbe, remainder);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
           throw err;
         }
-        const parent = path23.dirname(probe);
+        const parent = path24.dirname(probe);
         if (parent === probe) {
           return absoluteTarget;
         }
@@ -12117,11 +12333,11 @@ function mergeGraphExpandedResults(primary, expanded) {
   return Array.from(mergedByPath.values());
 }
 function graphPathRelativeToStorage(storageDir, candidatePath) {
-  const absolutePath = path24.isAbsolute(candidatePath) ? candidatePath : path24.resolve(storageDir, candidatePath);
-  const rel = path24.relative(storageDir, absolutePath);
+  const absolutePath = path25.isAbsolute(candidatePath) ? candidatePath : path25.resolve(storageDir, candidatePath);
+  const rel = path25.relative(storageDir, absolutePath);
   if (!rel || rel === ".") return null;
   if (rel.startsWith("..")) return null;
-  return rel.split(path24.sep).join("/");
+  return rel.split(path25.sep).join("/");
 }
 function graphActivationScoreToRecallScore(score) {
   const bounded = Number.isFinite(score) && score > 0 ? score : 0;
@@ -12163,7 +12379,7 @@ function buildMemoryPathById(allMemsForGraph, storageDir) {
   for (const mem of allMemsForGraph ?? []) {
     const id = mem.frontmatter.id;
     if (!id) continue;
-    pathById.set(id, path24.relative(storageDir, mem.path));
+    pathById.set(id, path25.relative(storageDir, mem.path));
   }
   return pathById;
 }
@@ -12171,7 +12387,7 @@ function appendMemoryToGraphContext(options) {
   if (!Array.isArray(options.allMemsForGraph)) return;
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   options.allMemsForGraph.push({
-    path: path24.join(options.storageDir, options.memoryRelPath),
+    path: path25.join(options.storageDir, options.memoryRelPath),
     content: options.content,
     frontmatter: {
       id: options.memoryId,
@@ -12191,21 +12407,22 @@ function resolvePersistedMemoryRelativePath(options) {
   const persisted = options.pathById.get(options.memoryId);
   if (persisted) return persisted;
   if (options.category === "correction") {
-    return path24.join("corrections", `${options.memoryId}.md`);
+    return path25.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 path24.join("facts", day, `${options.memoryId}.md`);
+    return path25.join("facts", day, `${options.memoryId}.md`);
   }
-  return path24.join("facts", `${options.memoryId}.md`);
+  return path25.join("facts", `${options.memoryId}.md`);
 }
 var Orchestrator = class _Orchestrator {
   storage;
   storageRouter;
   qmd;
   conversationQmd;
+  conversationFaiss;
   sharedContext;
   compounding;
   buffer;
@@ -12287,11 +12504,23 @@ var Orchestrator = class _Orchestrator {
         daemonRecheckIntervalMs: config.qmdDaemonRecheckIntervalMs
       }
     ) : void 0;
+    this.conversationFaiss = config.conversationIndexEnabled && config.conversationIndexBackend === "faiss" ? new FaissConversationIndexAdapter({
+      memoryDir: config.memoryDir,
+      scriptPath: config.conversationIndexFaissScriptPath,
+      pythonBin: config.conversationIndexFaissPythonBin,
+      modelId: config.conversationIndexFaissModelId,
+      indexDir: config.conversationIndexFaissIndexDir,
+      upsertTimeoutMs: config.conversationIndexFaissUpsertTimeoutMs,
+      searchTimeoutMs: config.conversationIndexFaissSearchTimeoutMs,
+      healthTimeoutMs: config.conversationIndexFaissHealthTimeoutMs,
+      maxBatchSize: config.conversationIndexFaissMaxBatchSize,
+      maxSearchK: config.conversationIndexFaissMaxSearchK
+    }) : void 0;
     this.sharedContext = config.sharedContextEnabled ? new SharedContextManager(config) : void 0;
     this.compounding = config.compoundingEnabled ? new CompoundingEngine(config) : void 0;
     this.buffer = new SmartBuffer(config, this.storage);
     this.transcript = new TranscriptManager(config);
-    this.conversationIndexDir = path24.join(config.memoryDir, "conversation-index", "chunks");
+    this.conversationIndexDir = path25.join(config.memoryDir, "conversation-index", "chunks");
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -12306,7 +12535,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(
-      path24.join(config.memoryDir, "threads"),
+      path25.join(config.memoryDir, "threads"),
       config.threadingGapMinutes
     );
     this.tmtBuilder = new TmtBuilder(config.memoryDir, {
@@ -12442,7 +12671,7 @@ var Orchestrator = class _Orchestrator {
     await this.lastRecall.load();
     await this.sessionObserver.load();
     if (this.config.factDeduplicationEnabled) {
-      const stateDir2 = path24.join(this.config.memoryDir, "state");
+      const stateDir2 = path25.join(this.config.memoryDir, "state");
       this.contentHashIndex = new ContentHashIndex(stateDir2);
       await this.contentHashIndex.load();
       log.info(`content-hash dedup: loaded ${this.contentHashIndex.size} hashes`);
@@ -12475,12 +12704,12 @@ var Orchestrator = class _Orchestrator {
         log.warn(`QMD: not available ${this.qmd.debugStatus()}`);
       }
     }
-    if (this.config.conversationIndexEnabled && this.conversationQmd) {
+    if (this.config.conversationIndexEnabled && this.config.conversationIndexBackend === "qmd" && this.conversationQmd) {
       const available = await this.conversationQmd.probe();
       if (available) {
         log.info(`Conversation index QMD: available ${this.conversationQmd.debugStatus()}`);
         const collectionState = await this.conversationQmd.ensureCollection(
-          path24.join(this.config.memoryDir, "conversation-index")
+          path25.join(this.config.memoryDir, "conversation-index")
         );
         if (collectionState === "missing") {
           this.config.conversationIndexEnabled = false;
@@ -12498,6 +12727,14 @@ var Orchestrator = class _Orchestrator {
         log.warn(`Conversation index QMD: not available ${this.conversationQmd.debugStatus()}`);
       }
     }
+    if (this.config.conversationIndexEnabled && this.config.conversationIndexBackend === "faiss" && this.conversationFaiss) {
+      const health = await failOpenFaissHealth(this.conversationFaiss);
+      if (health.ok) {
+        log.info(`Conversation index FAISS: available (status=${health.status})`);
+      } else {
+        log.warn(`Conversation index FAISS: degraded (${health.message ?? health.status})`);
+      }
+    }
     await this.buffer.load();
     if (this.config.localLlmEnabled) {
       await this.validateLocalLlmModel();
@@ -12516,12 +12753,12 @@ var Orchestrator = class _Orchestrator {
     this.lastFileHygieneRunAtMs = now;
     if (hygiene.rotateEnabled) {
       for (const rel of hygiene.rotatePaths) {
-        const abs = path24.isAbsolute(rel) ? rel : path24.join(this.config.workspaceDir, rel);
+        const abs = path25.isAbsolute(rel) ? rel : path25.join(this.config.workspaceDir, rel);
         try {
           const raw = await readFile18(abs, "utf-8");
           if (raw.length > hygiene.rotateMaxBytes) {
-            const archiveDir = path24.join(this.config.workspaceDir, hygiene.archiveDir);
-            const base = path24.basename(abs);
+            const archiveDir = path25.join(this.config.workspaceDir, hygiene.archiveDir);
+            const base = path25.basename(abs);
             const prefix = base.toUpperCase().replace(/\.MD$/i, "").replace(/[^A-Z0-9]+/g, "-") || "FILE";
             const { newContent } = await rotateMarkdownFileToArchive({
               filePath: abs,
@@ -12546,8 +12783,8 @@ var Orchestrator = class _Orchestrator {
         log.warn(w.message);
       }
       if (hygiene.warningsLogEnabled && warnings.length > 0) {
-        const fp = path24.join(this.config.memoryDir, hygiene.warningsLogPath);
-        await mkdir18(path24.dirname(fp), { recursive: true });
+        const fp = path25.join(this.config.memoryDir, hygiene.warningsLogPath);
+        await mkdir18(path25.dirname(fp), { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString();
         const block = `
 
@@ -12615,7 +12852,7 @@ var Orchestrator = class _Orchestrator {
   }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
-    const snapshotPath = path24.join(storage.dir, "state", "last_graph_recall.json");
+    const snapshotPath = path25.join(storage.dir, "state", "last_graph_recall.json");
     try {
       const raw = await readFile18(snapshotPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -12655,6 +12892,32 @@ var Orchestrator = class _Orchestrator {
       ...expanded.map((e) => `- ${e.path} (score=${e.score.toFixed(3)}, ns=${e.namespace})`)
     ].join("\n");
   }
+  async searchConversationRecallResults(retrievalQuery, topK) {
+    if (this.config.conversationIndexBackend === "faiss") {
+      return searchConversationIndexFaissFailOpen(this.conversationFaiss, retrievalQuery, topK);
+    }
+    if (this.conversationQmd && this.conversationQmd.isAvailable()) {
+      return searchConversationIndex(this.conversationQmd, retrievalQuery, topK);
+    }
+    return [];
+  }
+  formatConversationRecallSection(results, maxChars) {
+    if (!Array.isArray(results) || results.length === 0) return null;
+    const lines = ["## Semantic Recall (Past Conversations)", ""];
+    let used = 0;
+    for (const r of results) {
+      if (!r?.snippet) continue;
+      const chunk = `### ${r.path}
+Score: ${r.score.toFixed(3)}
+
+${r.snippet.trim()}
+`;
+      if (used + chunk.length > maxChars) break;
+      lines.push(chunk);
+      used += chunk.length;
+    }
+    return used > 0 ? lines.join("\n") : null;
+  }
   async updateConversationIndex(sessionKey, hours = 24, opts) {
     if (!this.config.conversationIndexEnabled) {
       return { chunks: 0, skipped: true, reason: "disabled", embedded: false };
@@ -12685,15 +12948,19 @@ var Orchestrator = class _Orchestrator {
       this.conversationIndexDir,
       this.config.conversationIndexRetentionDays
     );
-    const q = this.conversationQmd ?? this.qmd;
-    const usingPrimaryQmdClient = q === this.qmd;
     const shouldEmbed = opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
     let embedded = false;
-    if ((!usingPrimaryQmdClient || this.config.qmdEnabled) && q.isAvailable()) {
-      await q.update();
-      if (shouldEmbed) {
-        await q.embed();
-        embedded = true;
+    if (this.config.conversationIndexBackend === "faiss") {
+      await upsertConversationChunksFailOpen(this.conversationFaiss, chunks);
+    } else {
+      const q = this.conversationQmd ?? this.qmd;
+      const usingPrimaryQmdClient = q === this.qmd;
+      if ((!usingPrimaryQmdClient || this.config.qmdEnabled) && q.isAvailable()) {
+        await q.update();
+        if (shouldEmbed) {
+          await q.embed();
+          embedded = true;
+        }
       }
     }
     this.conversationIndexLastUpdateAtMs.set(sessionKey, Date.now());
@@ -12917,7 +13184,7 @@ var Orchestrator = class _Orchestrator {
       const storage = await this.storageRouter.storageFor(namespace);
       const seedRelativePaths = nsResults.slice(0, perNamespaceSeedCap).map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter((value) => typeof value === "string" && value.length > 0);
       if (seedRelativePaths.length === 0) continue;
-      seedPaths.push(...seedRelativePaths.map((rel) => path24.join(storage.dir, rel)));
+      seedPaths.push(...seedRelativePaths.map((rel) => path25.join(storage.dir, rel)));
       const seedSet = new Set(seedRelativePaths);
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
@@ -12926,7 +13193,7 @@ var Orchestrator = class _Orchestrator {
       if (expanded.length === 0) continue;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
         if (seedSet.has(candidate.path)) continue;
-        const memoryPath = path24.resolve(storage.dir, candidate.path);
+        const memoryPath = path25.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
@@ -12954,8 +13221,8 @@ var Orchestrator = class _Orchestrator {
   }
   async recordLastGraphRecallSnapshot(options) {
     try {
-      const snapshotPath = path24.join(options.storage.dir, "state", "last_graph_recall.json");
-      await mkdir18(path24.dirname(snapshotPath), { recursive: true });
+      const snapshotPath = path25.join(options.storage.dir, "state", "last_graph_recall.json");
+      await mkdir18(path25.dirname(snapshotPath), { recursive: true });
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const payload = {
         recordedAt: now,
@@ -13539,36 +13806,22 @@ ${formatted}`);
     }
     timings.summaries = `${Date.now() - summariesT0}ms`;
     const convT0 = Date.now();
-    if (this.config.conversationIndexEnabled && !queryPolicy.skipConversationRecall && this.conversationQmd && this.conversationQmd.isAvailable()) {
+    if (this.config.conversationIndexEnabled && !queryPolicy.skipConversationRecall) {
       const startedAtMs = Date.now();
       const timeoutMs = Math.max(200, this.config.conversationRecallTimeoutMs);
       const topK = Math.max(1, this.config.conversationRecallTopK);
       const maxChars = Math.max(400, this.config.conversationRecallMaxChars);
       const results = await Promise.race([
-        this.conversationQmd.search(retrievalQuery, void 0, topK),
+        this.searchConversationRecallResults(retrievalQuery, topK),
         new Promise((resolve) => setTimeout(() => resolve([]), timeoutMs))
       ]).catch(() => []);
       const durationMs = Date.now() - startedAtMs;
       if (durationMs >= timeoutMs) {
         log.debug(`conversation recall: timed out after ${timeoutMs}ms`);
       }
-      if (Array.isArray(results) && results.length > 0) {
-        const lines = ["## Semantic Recall (Past Conversations)", ""];
-        let used = 0;
-        for (const r of results) {
-          if (!r?.snippet) continue;
-          const chunk = `### ${r.path}
-Score: ${r.score.toFixed(3)}
-
-${r.snippet.trim()}
-`;
-          if (used + chunk.length > maxChars) break;
-          lines.push(chunk);
-          used += chunk.length;
-        }
-        if (used > 0) {
-          sections.push(lines.join("\n"));
-        }
+      const formattedConversationRecall = this.formatConversationRecallSection(results, maxChars);
+      if (formattedConversationRecall) {
+        sections.push(formattedConversationRecall);
       }
     }
     timings.convRecall = `${Date.now() - convT0}ms`;
@@ -14370,7 +14623,7 @@ _Context: ${topQuestion.context}_`);
         const allMems = allMemsForGraph ?? [];
         for (const m of allMems) {
           if (m.frontmatter.entityRef === entityRef) {
-            const rel = path24.relative(storage.dir, m.path);
+            const rel = path25.relative(storage.dir, m.path);
             if (rel !== memoryRelPath) entitySiblings.push(rel);
           }
         }
@@ -14747,8 +15000,8 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         protectedCategories: this.config.lifecycleProtectedCategories
       }
     };
-    const metricsPath = path24.join(this.storage.dir, "state", "lifecycle-metrics.json");
-    await mkdir18(path24.dirname(metricsPath), { recursive: true });
+    const metricsPath = path25.join(this.storage.dir, "state", "lifecycle-metrics.json");
+    await mkdir18(path25.dirname(metricsPath), { recursive: true });
     await writeFile17(metricsPath, JSON.stringify(metrics, null, 2), "utf-8");
   }
   /**
@@ -15015,7 +15268,7 @@ ${lines.join("\n\n")}`;
     if (hits.length === 0) return [];
     const results = [];
     for (const hit of hits) {
-      const fullPath = path24.isAbsolute(hit.path) ? hit.path : path24.join(this.config.memoryDir, hit.path);
+      const fullPath = path25.isAbsolute(hit.path) ? hit.path : path25.join(this.config.memoryDir, hit.path);
       const memory = await this.storage.readMemoryByPath(fullPath);
       if (!memory) continue;
       results.push({
@@ -15454,8 +15707,8 @@ ${lines.join("\n\n")}`;
   }
   namespaceFromStorageDir(storageDir) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path24.resolve(storageDir);
-    const resolvedMemoryDir = path24.resolve(this.config.memoryDir);
+    const resolvedStorageDir = path25.resolve(storageDir);
+    const resolvedMemoryDir = path25.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;
@@ -15483,12 +15736,12 @@ ${lines.join("\n\n")}`;
 };
 
 // src/tools.ts
-import path26 from "path";
+import path27 from "path";
 import { createHash as createHash6 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/work/storage.ts
-import path25 from "path";
+import path26 from "path";
 import { randomUUID } from "crypto";
 import { mkdir as mkdir19, readdir as readdir11, readFile as readFile19, rm as rm3, writeFile as writeFile18 } from "fs/promises";
 var TASK_TRANSITIONS = {
@@ -15565,8 +15818,8 @@ function ensureProjectStatus(value) {
 var WorkStorage = class {
   constructor(memoryDir) {
     this.memoryDir = memoryDir;
-    this.tasksDir = path25.join(memoryDir, "work", "tasks");
-    this.projectsDir = path25.join(memoryDir, "work", "projects");
+    this.tasksDir = path26.join(memoryDir, "work", "tasks");
+    this.projectsDir = path26.join(memoryDir, "work", "projects");
   }
   tasksDir;
   projectsDir;
@@ -15576,11 +15829,11 @@ var WorkStorage = class {
   }
   taskPath(id) {
     assertValidWorkId(id, "task");
-    return path25.join(this.tasksDir, `${id}.md`);
+    return path26.join(this.tasksDir, `${id}.md`);
   }
   projectPath(id) {
     assertValidWorkId(id, "project");
-    return path25.join(this.projectsDir, `${id}.md`);
+    return path26.join(this.projectsDir, `${id}.md`);
   }
   serializeTask(task) {
     return `${serializeFrontmatter2(task)}
@@ -15672,7 +15925,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile19(path25.join(this.tasksDir, entry.name), "utf-8");
+      const raw = await readFile19(path26.join(this.tasksDir, entry.name), "utf-8");
       const task = this.parseTask(raw);
       if (!task) continue;
       if (filter?.status && task.status !== filter.status) continue;
@@ -15771,7 +16024,7 @@ ${project.description}
     const out = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = await readFile19(path25.join(this.projectsDir, entry.name), "utf-8");
+      const raw = await readFile19(path26.join(this.projectsDir, entry.name), "utf-8");
       const project = this.parseProject(raw);
       if (project) out.push(project);
     }
@@ -17272,7 +17525,7 @@ Best for:
 - Reviewing identity development over time`,
       parameters: Type.Object({}),
       async execute() {
-        const workspaceDir = path26.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path27.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.");
@@ -17781,11 +18034,11 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path42 from "path";
+import path43 from "path";
 import { access as access3, readFile as readFile30, readdir as readdir18, unlink as unlink5 } from "fs/promises";
 
 // src/transfer/export-json.ts
-import path28 from "path";
+import path29 from "path";
 import { mkdir as mkdir21, readFile as readFile21 } from "fs/promises";
 
 // src/transfer/constants.ts
@@ -17795,7 +18048,7 @@ var EXPORT_SCHEMA_VERSION = 1;
 // src/transfer/fs-utils.ts
 import { createHash as createHash7 } from "crypto";
 import { mkdir as mkdir20, readdir as readdir12, readFile as readFile20, stat as stat6, writeFile as writeFile19 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 async function sha256File(filePath) {
   const buf = await readFile20(filePath);
   const sha256 = createHash7("sha256").update(buf).digest("hex");
@@ -17807,7 +18060,7 @@ function sha256String(content) {
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {
-  await mkdir20(path27.dirname(filePath), { recursive: true });
+  await mkdir20(path28.dirname(filePath), { recursive: true });
   await writeFile19(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 }
 async function readJsonFile(filePath) {
@@ -17819,7 +18072,7 @@ async function listFilesRecursive(rootDir) {
   async function walk(dir) {
     const entries = await readdir12(dir, { withFileTypes: true });
     for (const ent of entries) {
-      const fp = path27.join(dir, ent.name);
+      const fp = path28.join(dir, ent.name);
       if (ent.isDirectory()) {
         await walk(fp);
       } else if (ent.isFile()) {
@@ -17839,11 +18092,11 @@ async function fileExists(filePath) {
   }
 }
 function toPosixRelPath(absPath, rootDir) {
-  const rel = path27.relative(rootDir, absPath);
-  return rel.split(path27.sep).join("/");
+  const rel = path28.relative(rootDir, absPath);
+  return rel.split(path28.sep).join("/");
 }
 function fromPosixRelPath(relPath) {
-  return relPath.split("/").join(path27.sep);
+  return relPath.split("/").join(path28.sep);
 }
 
 // src/transfer/export-json.ts
@@ -17859,9 +18112,9 @@ function shouldExclude(relPosix, includeTranscripts) {
 }
 async function exportJsonBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path28.resolve(opts.outDir);
+  const outDirAbs = path29.resolve(opts.outDir);
   await mkdir21(outDirAbs, { recursive: true });
-  const memoryDirAbs = path28.resolve(opts.memoryDir);
+  const memoryDirAbs = path29.resolve(opts.memoryDir);
   const filesAbs = await listFilesRecursive(memoryDirAbs);
   const records = [];
   const manifestFiles = [];
@@ -17874,7 +18127,7 @@ async function exportJsonBundle(opts) {
     manifestFiles.push({ path: relPosix, sha256, bytes });
   }
   if (opts.includeWorkspaceIdentity !== false && opts.workspaceDir) {
-    const identityPath = path28.join(opts.workspaceDir, "IDENTITY.md");
+    const identityPath = path29.join(opts.workspaceDir, "IDENTITY.md");
     try {
       const content = await readFile21(identityPath, "utf-8");
       const relPath = "workspace/IDENTITY.md";
@@ -17893,12 +18146,12 @@ async function exportJsonBundle(opts) {
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
   const bundle = { manifest, records };
-  await writeJsonFile(path28.join(outDirAbs, "manifest.json"), manifest);
-  await writeJsonFile(path28.join(outDirAbs, "bundle.json"), bundle);
+  await writeJsonFile(path29.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path29.join(outDirAbs, "bundle.json"), bundle);
 }
 
 // src/transfer/export-md.ts
-import path29 from "path";
+import path30 from "path";
 import { mkdir as mkdir22, readFile as readFile22, writeFile as writeFile20 } from "fs/promises";
 function shouldExclude2(relPosix, includeTranscripts) {
   const parts = relPosix.split("/");
@@ -17907,16 +18160,16 @@ function shouldExclude2(relPosix, includeTranscripts) {
 }
 async function exportMarkdownBundle(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const outDirAbs = path29.resolve(opts.outDir);
+  const outDirAbs = path30.resolve(opts.outDir);
   await mkdir22(outDirAbs, { recursive: true });
-  const memDirAbs = path29.resolve(opts.memoryDir);
+  const memDirAbs = path30.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 = path29.join(outDirAbs, ...relPosix.split("/"));
-    await mkdir22(path29.dirname(dstAbs), { recursive: true });
+    const dstAbs = path30.join(outDirAbs, ...relPosix.split("/"));
+    await mkdir22(path30.dirname(dstAbs), { recursive: true });
     const content = await readFile22(abs);
     await writeFile20(dstAbs, content);
     const { sha256, bytes } = await sha256File(abs);
@@ -17930,12 +18183,12 @@ async function exportMarkdownBundle(opts) {
     includesTranscripts: includeTranscripts,
     files: manifestFiles.sort((a, b) => a.path.localeCompare(b.path))
   };
-  await writeJsonFile(path29.join(outDirAbs, "manifest.json"), manifest);
+  await writeJsonFile(path30.join(outDirAbs, "manifest.json"), manifest);
 }
 async function looksLikeEngramMdExport(fromDir) {
-  const dirAbs = path29.resolve(fromDir);
+  const dirAbs = path30.resolve(fromDir);
   try {
-    const raw = await readFile22(path29.join(dirAbs, "manifest.json"), "utf-8");
+    const raw = await readFile22(path30.join(dirAbs, "manifest.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.format === EXPORT_FORMAT && parsed.schemaVersion === EXPORT_SCHEMA_VERSION;
   } catch {
@@ -17944,16 +18197,16 @@ async function looksLikeEngramMdExport(fromDir) {
 }
 
 // src/transfer/backup.ts
-import path30 from "path";
+import path31 from "path";
 import { mkdir as mkdir23, readdir as readdir13, rm as rm4 } from "fs/promises";
 function timestampDirName(now) {
   return now.toISOString().replace(/[:.]/g, "-");
 }
 async function backupMemoryDir(opts) {
-  const outDirAbs = path30.resolve(opts.outDir);
+  const outDirAbs = path31.resolve(opts.outDir);
   await mkdir23(outDirAbs, { recursive: true });
   const ts = timestampDirName(/* @__PURE__ */ new Date());
-  const backupDir = path30.join(outDirAbs, ts);
+  const backupDir = path31.join(outDirAbs, ts);
   await exportMarkdownBundle({
     memoryDir: opts.memoryDir,
     outDir: backupDir,
@@ -17978,13 +18231,13 @@ async function enforceRetention(outDirAbs, retentionDays) {
     const tsMs = iso ? Date.parse(iso) : NaN;
     if (!Number.isFinite(tsMs)) continue;
     if (tsMs < cutoffMs) {
-      await rm4(path30.join(outDirAbs, name), { recursive: true, force: true });
+      await rm4(path31.join(outDirAbs, name), { recursive: true, force: true });
     }
   }
 }
 
 // src/transfer/export-sqlite.ts
-import path31 from "path";
+import path32 from "path";
 import Database from "better-sqlite3";
 import { readFile as readFile23 } from "fs/promises";
 
@@ -18012,8 +18265,8 @@ function shouldExclude3(relPosix, includeTranscripts) {
 }
 async function exportSqlite(opts) {
   const includeTranscripts = opts.includeTranscripts === true;
-  const memDirAbs = path31.resolve(opts.memoryDir);
-  const outAbs = path31.resolve(opts.outFile);
+  const memDirAbs = path32.resolve(opts.memoryDir);
+  const outAbs = path32.resolve(opts.outFile);
   const filesAbs = await listFilesRecursive(memDirAbs);
   const db = new Database(outAbs);
   try {
@@ -18045,7 +18298,7 @@ async function exportSqlite(opts) {
 }
 
 // src/transfer/import-json.ts
-import path32 from "path";
+import path33 from "path";
 import { mkdir as mkdir24, writeFile as writeFile21 } from "fs/promises";
 
 // src/transfer/types.ts
@@ -18079,21 +18332,21 @@ function normalizeForDedupe(s) {
 }
 async function importJsonBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromDirAbs = path32.resolve(opts.fromDir);
-  const bundlePath = path32.join(fromDirAbs, "bundle.json");
+  const fromDirAbs = path33.resolve(opts.fromDir);
+  const bundlePath = path33.join(fromDirAbs, "bundle.json");
   const bundle = ExportBundleV1Schema.parse(await readJsonFile(bundlePath));
-  const memDirAbs = path32.resolve(opts.targetMemoryDir);
+  const memDirAbs = path33.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 ? path32.resolve(opts.workspaceDir) : null : memDirAbs;
+    const targetBase = isWorkspace ? opts.workspaceDir ? path33.resolve(opts.workspaceDir) : null : memDirAbs;
     if (isWorkspace && !targetBase) {
       skipped += 1;
       continue;
     }
     const relFs = fromPosixRelPath(isWorkspace ? rec.path.replace(/^workspace\//, "") : rec.path);
-    const absTarget = path32.join(targetBase, relFs);
+    const absTarget = path33.join(targetBase, relFs);
     const exists3 = await fileExists(absTarget);
     if (exists3) {
       if (conflict === "skip") {
@@ -18117,21 +18370,21 @@ async function importJsonBundle(opts) {
     return { written: 0, skipped };
   }
   for (const w of written) {
-    await mkdir24(path32.dirname(w.abs), { recursive: true });
+    await mkdir24(path33.dirname(w.abs), { recursive: true });
     await writeFile21(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 function looksLikeEngramJsonExport(fromDir) {
-  const dir = path32.resolve(fromDir);
+  const dir = path33.resolve(fromDir);
   return Promise.all([
-    fileExists(path32.join(dir, "manifest.json")),
-    fileExists(path32.join(dir, "bundle.json"))
+    fileExists(path33.join(dir, "manifest.json")),
+    fileExists(path33.join(dir, "bundle.json"))
   ]).then(([m, b]) => m && b);
 }
 
 // src/transfer/import-sqlite.ts
-import path33 from "path";
+import path34 from "path";
 import Database2 from "better-sqlite3";
 import { mkdir as mkdir25, writeFile as writeFile22 } from "fs/promises";
 function normalizeForDedupe2(s) {
@@ -18139,8 +18392,8 @@ function normalizeForDedupe2(s) {
 }
 async function importSqlite(opts) {
   const conflict = opts.conflict ?? "skip";
-  const memDirAbs = path33.resolve(opts.targetMemoryDir);
-  const fromAbs = path33.resolve(opts.fromFile);
+  const memDirAbs = path34.resolve(opts.targetMemoryDir);
+  const fromAbs = path34.resolve(opts.fromFile);
   const db = new Database2(fromAbs, { readonly: true });
   const written = [];
   let skipped = 0;
@@ -18153,7 +18406,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 = path33.join(memDirAbs, relFs);
+      const absTarget = path34.join(memDirAbs, relFs);
       const exists3 = await fileExists(absTarget);
       if (exists3) {
         if (conflict === "skip") {
@@ -18178,29 +18431,29 @@ async function importSqlite(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of written) {
-    await mkdir25(path33.dirname(w.abs), { recursive: true });
+    await mkdir25(path34.dirname(w.abs), { recursive: true });
     await writeFile22(w.abs, w.content, "utf-8");
   }
   return { written: written.length, skipped };
 }
 
 // src/transfer/import-md.ts
-import path34 from "path";
+import path35 from "path";
 import { mkdir as mkdir26, readFile as readFile24, writeFile as writeFile23 } from "fs/promises";
 function normalizeForDedupe3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function importMarkdownBundle(opts) {
   const conflict = opts.conflict ?? "skip";
-  const fromAbs = path34.resolve(opts.fromDir);
-  const targetAbs = path34.resolve(opts.targetMemoryDir);
+  const fromAbs = path35.resolve(opts.fromDir);
+  const targetAbs = path35.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 = path34.join(targetAbs, fromPosixRelPath(relPosix));
+    const dstAbs = path35.join(targetAbs, fromPosixRelPath(relPosix));
     const content = await readFile24(abs, "utf-8");
     const exists3 = await fileExists(dstAbs);
     if (exists3) {
@@ -18223,17 +18476,17 @@ async function importMarkdownBundle(opts) {
   }
   if (opts.dryRun) return { written: 0, skipped };
   for (const w of writes) {
-    await mkdir26(path34.dirname(w.abs), { recursive: true });
+    await mkdir26(path35.dirname(w.abs), { recursive: true });
     await writeFile23(w.abs, w.content, "utf-8");
   }
   return { written: writes.length, skipped };
 }
 
 // src/transfer/autodetect.ts
-import path35 from "path";
+import path36 from "path";
 import { stat as stat7 } from "fs/promises";
 async function detectImportFormat(fromPath) {
-  const abs = path35.resolve(fromPath);
+  const abs = path36.resolve(fromPath);
   let st;
   try {
     st = await stat7(abs);
@@ -18661,8 +18914,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path44 = typeof record.path === "string" ? record.path : "";
-      if (!path44.startsWith("transcripts/") && !path44.includes("/transcripts/")) continue;
+      const path45 = typeof record.path === "string" ? record.path : "";
+      if (!path45.startsWith("transcripts/") && !path45.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -18718,7 +18971,7 @@ var openclawReplayNormalizer = {
 };
 
 // src/maintenance/archive-observations.ts
-import path36 from "path";
+import path37 from "path";
 import { mkdir as mkdir27, readdir as readdir14, readFile as readFile25, unlink as unlink4, writeFile as writeFile24 } from "fs/promises";
 var DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
 function normalizeRetentionDays(value) {
@@ -18745,8 +18998,8 @@ async function listFilesRecursive2(root, relPrefix = "") {
     return out;
   }
   for (const entry of entries) {
-    const rel = relPrefix ? path36.join(relPrefix, entry.name) : entry.name;
-    const full = path36.join(root, entry.name);
+    const rel = relPrefix ? path37.join(relPrefix, entry.name) : entry.name;
+    const full = path37.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listFilesRecursive2(full, rel));
       continue;
@@ -18756,19 +19009,19 @@ async function listFilesRecursive2(root, relPrefix = "") {
   return out;
 }
 async function collectArchiveCandidates(memoryDir, cutoffTimeMs) {
-  const roots = ["transcripts", path36.join("state", "tool-usage"), path36.join("summaries", "hourly")];
+  const roots = ["transcripts", path37.join("state", "tool-usage"), path37.join("summaries", "hourly")];
   const out = [];
   for (const relRoot of roots) {
-    const absRoot = path36.join(memoryDir, relRoot);
+    const absRoot = path37.join(memoryDir, relRoot);
     const files = await listFilesRecursive2(absRoot);
     for (const fileRel of files) {
-      const filename = path36.basename(fileRel);
+      const filename = path37.basename(fileRel);
       const parsedDate = extractDateFromFilename(filename);
       if (!parsedDate) continue;
       if (parsedDate.getTime() >= cutoffTimeMs) continue;
       out.push({
-        absolutePath: path36.join(absRoot, fileRel),
-        relativePath: path36.join(relRoot, fileRel)
+        absolutePath: path37.join(absRoot, fileRel),
+        relativePath: path37.join(relRoot, fileRel)
       });
     }
   }
@@ -18783,7 +19036,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 = path36.join(options.memoryDir, "archive", "observations", stamp);
+  const archiveRoot = path37.join(options.memoryDir, "archive", "observations", stamp);
   const candidates = retentionDays === 0 ? [] : await collectArchiveCandidates(
     options.memoryDir,
     cutoffDayStartUtc
@@ -18794,8 +19047,8 @@ async function archiveObservations(options) {
   if (!dryRun && candidates.length > 0) {
     await mkdir27(archiveRoot, { recursive: true });
     for (const candidate of candidates) {
-      const archivePath = path36.join(archiveRoot, candidate.relativePath);
-      const archiveDir = path36.dirname(archivePath);
+      const archivePath = path37.join(archiveRoot, candidate.relativePath);
+      const archiveDir = path37.dirname(archivePath);
       await mkdir27(archiveDir, { recursive: true });
       const raw = await readFile25(candidate.absolutePath);
       await writeFile24(archivePath, raw);
@@ -18819,11 +19072,11 @@ async function archiveObservations(options) {
 }
 
 // src/maintenance/rebuild-observations.ts
-import path38 from "path";
+import path39 from "path";
 import { readdir as readdir15, readFile as readFile27 } from "fs/promises";
 
 // src/maintenance/observation-ledger-utils.ts
-import path37 from "path";
+import path38 from "path";
 import { mkdir as mkdir28, readFile as readFile26, writeFile as writeFile25 } from "fs/promises";
 function toHourBucketIso(timestamp) {
   const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
@@ -18835,8 +19088,8 @@ function toHourBucketIso(timestamp) {
 }
 async function backupAndWriteRebuiltObservations(options) {
   const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
-  const archiveRoot = path37.join(options.memoryDir, "archive", "observations", stamp);
-  let backupPath = path37.join(
+  const archiveRoot = path38.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path38.join(
     archiveRoot,
     "state",
     "observation-ledger",
@@ -18844,7 +19097,7 @@ async function backupAndWriteRebuiltObservations(options) {
   );
   try {
     const existing = await readFile26(options.outputPath, "utf-8");
-    await mkdir28(path37.dirname(backupPath), { recursive: true });
+    await mkdir28(path38.dirname(backupPath), { recursive: true });
     await writeFile25(backupPath, existing, "utf-8");
   } catch (err) {
     const code = err.code;
@@ -18861,7 +19114,7 @@ async function backupAndWriteRebuiltObservations(options) {
       rebuiltAt
     })
   );
-  await mkdir28(path37.dirname(options.outputPath), { recursive: true });
+  await mkdir28(path38.dirname(options.outputPath), { recursive: true });
   await writeFile25(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
 ` : "", "utf-8");
   return backupPath;
@@ -18884,7 +19137,7 @@ async function listTranscriptFiles(root) {
   for (const entry of entries) {
     if (entry.name === "." || entry.name === "..") continue;
     if (entry.isSymbolicLink()) continue;
-    const full = path38.join(root, entry.name);
+    const full = path39.join(root, entry.name);
     if (entry.isDirectory()) {
       out.push(...await listTranscriptFiles(full));
       continue;
@@ -18944,8 +19197,8 @@ function buildLedgerRows(linesByFile) {
 async function rebuildObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const transcriptsRoot = path38.join(options.memoryDir, "transcripts");
-  const outputPath = path38.join(
+  const transcriptsRoot = path39.join(options.memoryDir, "transcripts");
+  const outputPath = path39.join(
     options.memoryDir,
     "state",
     "observation-ledger",
@@ -18981,7 +19234,7 @@ async function rebuildObservations(options) {
 }
 
 // src/maintenance/migrate-observations.ts
-import path39 from "path";
+import path40 from "path";
 import { readdir as readdir16, readFile as readFile28 } from "fs/promises";
 function toNonNegativeInt(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
@@ -19045,15 +19298,15 @@ async function listLegacyObservationFiles(root) {
 async function migrateObservations(options) {
   const dryRun = options.dryRun !== false;
   const now = options.now ?? /* @__PURE__ */ new Date();
-  const ledgerRoot = path39.join(options.memoryDir, "state", "observation-ledger");
-  const outputPath = path39.join(ledgerRoot, "rebuilt-observations.jsonl");
+  const ledgerRoot = path40.join(options.memoryDir, "state", "observation-ledger");
+  const outputPath = path40.join(ledgerRoot, "rebuilt-observations.jsonl");
   const legacyFiles = await listLegacyObservationFiles(ledgerRoot);
-  const sourceRelativePaths = legacyFiles.map((name) => path39.join("state", "observation-ledger", name));
+  const sourceRelativePaths = legacyFiles.map((name) => path40.join("state", "observation-ledger", name));
   const byKey = /* @__PURE__ */ new Map();
   let parsedRows = 0;
   let malformedLines = 0;
   for (const file of legacyFiles) {
-    const full = path39.join(ledgerRoot, file);
+    const full = path40.join(ledgerRoot, file);
     const raw = await readFile28(full, "utf-8");
     for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
@@ -19132,7 +19385,7 @@ async function migrateObservations(options) {
 
 // src/network/tailscale.ts
 import { stat as stat8 } from "fs/promises";
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 var TailscaleHelper = class {
   tailscaleBinary;
   rsyncBinary;
@@ -19203,7 +19456,7 @@ async function assertReadableDirectory(dir) {
 }
 var defaultCommandRunner = (command, args, options) => {
   return new Promise((resolve) => {
-    const child = spawn2(command, args, {
+    const child = spawn3(command, args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout = "";
@@ -19246,7 +19499,7 @@ import { createReadStream } from "fs";
 import { mkdir as mkdir29, readdir as readdir17, realpath as realpath2, stat as stat9 } from "fs/promises";
 import { createServer } from "http";
 import { timingSafeEqual } from "crypto";
-import path40 from "path";
+import path41 from "path";
 import { pipeline } from "stream/promises";
 import { URL as URL2 } from "url";
 function hostToUrlAuthority(host) {
@@ -19282,10 +19535,10 @@ var WebDavServer = class _WebDavServer {
     const allowedRoots = [];
     const aliasSet = /* @__PURE__ */ new Set();
     for (const dir of options.allowlistDirs) {
-      const resolved = path40.resolve(dir);
+      const resolved = path41.resolve(dir);
       await mkdir29(resolved, { recursive: true });
       const canonical = await realpath2(resolved);
-      const alias = path40.basename(canonical) || "root";
+      const alias = path41.basename(canonical) || "root";
       if (aliasSet.has(alias)) {
         throw new Error(`duplicate webdav allowlist alias: ${alias}`);
       }
@@ -19441,7 +19694,7 @@ var WebDavServer = class _WebDavServer {
     if (decodedPath.includes("\0")) {
       return { ok: false, code: 400, message: "invalid path" };
     }
-    const normalized = path40.posix.normalize(decodedPath);
+    const normalized = path41.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" };
@@ -19455,7 +19708,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 = path40.resolve(root.absolute, ...relative);
+    const candidate = path41.resolve(root.absolute, ...relative);
     if (!this.isPathInside(root.absolute, candidate)) {
       return { ok: false, code: 403, message: "path escaped allowlist" };
     }
@@ -19533,10 +19786,10 @@ var WebDavServer = class _WebDavServer {
   }
   isPathInside(root, target) {
     if (target === root) return true;
-    if (root === path40.parse(root).root) {
+    if (root === path41.parse(root).root) {
       return target.startsWith(root);
     }
-    return target.startsWith(`${root}${path40.sep}`);
+    return target.startsWith(`${root}${path41.sep}`);
   }
 };
 function xmlEscape(value) {
@@ -19548,8 +19801,8 @@ function toEncodedHref(pathname) {
 
 // src/compat/checks.ts
 import { access as access2, readFile as readFile29 } from "fs/promises";
-import path41 from "path";
-import { spawn as spawn3 } from "child_process";
+import path42 from "path";
+import { spawn as spawn4 } from "child_process";
 var REQUIRED_HOOKS = ["before_agent_start", "agent_end"];
 function isSafeCommandToken(command) {
   return /^[a-zA-Z0-9._-]+$/.test(command);
@@ -19560,7 +19813,7 @@ var defaultRunner = {
     const binary = process.platform === "win32" ? "where" : "which";
     const args = [command];
     return new Promise((resolve) => {
-      const child = spawn3(binary, args, { stdio: "ignore" });
+      const child = spawn4(binary, args, { stdio: "ignore" });
       child.on("error", () => resolve(false));
       child.on("close", (code) => resolve(code === 0));
     });
@@ -19730,9 +19983,9 @@ function compareVersions(a, b) {
 async function runCompatChecks(options) {
   const checks = [];
   const runner = options.runner ?? defaultRunner;
-  const pluginJsonPath = path41.join(options.repoRoot, "openclaw.plugin.json");
-  const packageJsonPath = path41.join(options.repoRoot, "package.json");
-  const indexPath = path41.join(options.repoRoot, "src", "index.ts");
+  const pluginJsonPath = path42.join(options.repoRoot, "openclaw.plugin.json");
+  const packageJsonPath = path42.join(options.repoRoot, "package.json");
+  const indexPath = path42.join(options.repoRoot, "src", "index.ts");
   let pluginRaw = "";
   let pluginManifestPresent = false;
   try {
@@ -20392,14 +20645,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 = path42.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path43.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 = [path42.join(memoryDir, "facts"), path42.join(memoryDir, "corrections")];
+  const roots = [path43.join(memoryDir, "facts"), path43.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -20410,7 +20663,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 = path42.join(dir, entryName);
+      const fullPath = path43.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -21182,7 +21435,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path42.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path43.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -21405,8 +21658,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path42.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path42.join(memoryDir, "threads"));
+        const memoryDir = path43.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path43.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -21581,14 +21834,14 @@ function parseDuration(duration) {
 // src/index.ts
 import { readFile as readFile31, writeFile as writeFile26 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path43 from "path";
+import path44 from "path";
 import os5 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os5.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path43.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path44.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -21796,7 +22049,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 = path43.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path44.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {