@joshuaswarren/openclaw-engram 8.3.32 → 8.3.34

package/dist/index.js

@@ -16350,8 +16350,8 @@ mistakes: ${res.mistakesCount} patterns`
 }
 
 // src/cli.ts
-import path34 from "path";
-import { access as access2, readFile as readFile23, readdir as readdir13, unlink as unlink4 } from "fs/promises";
+import path38 from "path";
+import { access as access2, readFile as readFile27, readdir as readdir16, unlink as unlink5 } from "fs/promises";
 
 // src/transfer/export-json.ts
 import path26 from "path";
@@ -17230,8 +17230,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path36 = typeof record.path === "string" ? record.path : "";
-      if (!path36.startsWith("transcripts/") && !path36.includes("/transcripts/")) continue;
+      const path40 = typeof record.path === "string" ? record.path : "";
+      if (!path40.startsWith("transcripts/") && !path40.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -17286,6 +17286,419 @@ var openclawReplayNormalizer = {
   }
 };
 
+// src/maintenance/archive-observations.ts
+import path34 from "path";
+import { mkdir as mkdir25, readdir as readdir13, readFile as readFile23, unlink as unlink4, writeFile as writeFile22 } from "fs/promises";
+var DATE_FILE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})\.(jsonl|md)$/;
+function normalizeRetentionDays(value) {
+  if (!Number.isFinite(value)) return 30;
+  return Math.max(0, Math.floor(value));
+}
+function extractDateFromFilename(name) {
+  const match = DATE_FILE_PATTERN.exec(name);
+  if (!match) return null;
+  const iso = `${match[1]}-${match[2]}-${match[3]}T00:00:00.000Z`;
+  const parsed = new Date(iso);
+  if (Number.isNaN(parsed.getTime())) return null;
+  return parsed;
+}
+function startOfUtcDay(value) {
+  return Date.UTC(value.getUTCFullYear(), value.getUTCMonth(), value.getUTCDate());
+}
+async function listFilesRecursive2(root, relPrefix = "") {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir13(root, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const rel = relPrefix ? path34.join(relPrefix, entry.name) : entry.name;
+    const full = path34.join(root, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listFilesRecursive2(full, rel));
+      continue;
+    }
+    if (entry.isFile()) out.push(rel);
+  }
+  return out;
+}
+async function collectArchiveCandidates(memoryDir, cutoffTimeMs) {
+  const roots = ["transcripts", path34.join("state", "tool-usage"), path34.join("summaries", "hourly")];
+  const out = [];
+  for (const relRoot of roots) {
+    const absRoot = path34.join(memoryDir, relRoot);
+    const files = await listFilesRecursive2(absRoot);
+    for (const fileRel of files) {
+      const filename = path34.basename(fileRel);
+      const parsedDate = extractDateFromFilename(filename);
+      if (!parsedDate) continue;
+      if (parsedDate.getTime() >= cutoffTimeMs) continue;
+      out.push({
+        absolutePath: path34.join(absRoot, fileRel),
+        relativePath: path34.join(relRoot, fileRel)
+      });
+    }
+  }
+  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return out;
+}
+async function archiveObservations(options) {
+  const retentionDays = normalizeRetentionDays(options.retentionDays);
+  const dryRun = options.dryRun !== false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const cutoffDayStartUtc = startOfUtcDay(
+    new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1e3)
+  );
+  const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  const archiveRoot = path34.join(options.memoryDir, "archive", "observations", stamp);
+  const candidates = retentionDays === 0 ? [] : await collectArchiveCandidates(
+    options.memoryDir,
+    cutoffDayStartUtc
+  );
+  let archivedFiles = 0;
+  let archivedBytes = 0;
+  const archivedRelativePaths = [];
+  if (!dryRun && candidates.length > 0) {
+    await mkdir25(archiveRoot, { recursive: true });
+    for (const candidate of candidates) {
+      const archivePath = path34.join(archiveRoot, candidate.relativePath);
+      const archiveDir = path34.dirname(archivePath);
+      await mkdir25(archiveDir, { recursive: true });
+      const raw = await readFile23(candidate.absolutePath);
+      await writeFile22(archivePath, raw);
+      await unlink4(candidate.absolutePath);
+      archivedFiles += 1;
+      archivedBytes += raw.byteLength;
+      archivedRelativePaths.push(candidate.relativePath);
+    }
+  } else {
+    archivedRelativePaths.push(...candidates.map((c) => c.relativePath));
+  }
+  return {
+    dryRun,
+    retentionDays,
+    scannedFiles: candidates.length,
+    archivedFiles,
+    archivedBytes,
+    archiveRoot,
+    archivedRelativePaths
+  };
+}
+
+// src/maintenance/rebuild-observations.ts
+import path36 from "path";
+import { readdir as readdir14, readFile as readFile25 } from "fs/promises";
+
+// src/maintenance/observation-ledger-utils.ts
+import path35 from "path";
+import { mkdir as mkdir26, readFile as readFile24, writeFile as writeFile23 } from "fs/promises";
+function toHourBucketIso(timestamp) {
+  const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
+  const ms = Date.parse(normalized);
+  if (!Number.isFinite(ms)) return null;
+  const d = new Date(ms);
+  d.setUTCMinutes(0, 0, 0);
+  return d.toISOString();
+}
+async function backupAndWriteRebuiltObservations(options) {
+  const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  const archiveRoot = path35.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path35.join(
+    archiveRoot,
+    "state",
+    "observation-ledger",
+    "rebuilt-observations.jsonl"
+  );
+  try {
+    const existing = await readFile24(options.outputPath, "utf-8");
+    await mkdir26(path35.dirname(backupPath), { recursive: true });
+    await writeFile23(backupPath, existing, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code && code === "ENOENT") {
+      backupPath = void 0;
+    } else {
+      throw err;
+    }
+  }
+  const rebuiltAt = options.now.toISOString();
+  const lines = options.rows.map(
+    (row) => JSON.stringify({
+      ...row,
+      rebuiltAt
+    })
+  );
+  await mkdir26(path35.dirname(options.outputPath), { recursive: true });
+  await writeFile23(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf-8");
+  return backupPath;
+}
+
+// src/maintenance/rebuild-observations.ts
+function toSortableKey(sessionKey, hour) {
+  return `${sessionKey}\0${hour}`;
+}
+async function listTranscriptFiles(root) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir14(root, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code && code === "ENOENT") return out;
+    throw err;
+  }
+  for (const entry of entries) {
+    if (entry.name === "." || entry.name === "..") continue;
+    if (entry.isSymbolicLink()) continue;
+    const full = path36.join(root, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await listTranscriptFiles(full));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      out.push(full);
+    }
+  }
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+function buildLedgerRows(linesByFile) {
+  const byKey = /* @__PURE__ */ new Map();
+  let parsedTurns = 0;
+  let malformedLines = 0;
+  for (const rawFile of linesByFile) {
+    for (const line of rawFile.split("\n")) {
+      if (!line.trim()) continue;
+      let parsed;
+      try {
+        const candidate = JSON.parse(line);
+        if (candidate == null || typeof candidate !== "object" || Array.isArray(candidate)) {
+          malformedLines += 1;
+          continue;
+        }
+        parsed = candidate;
+      } catch {
+        malformedLines += 1;
+        continue;
+      }
+      if (typeof parsed.sessionKey !== "string" || parsed.sessionKey.length === 0) continue;
+      if (parsed.role !== "user" && parsed.role !== "assistant") continue;
+      if (typeof parsed.timestamp !== "string") continue;
+      const hour = toHourBucketIso(parsed.timestamp);
+      if (!hour) continue;
+      const key = toSortableKey(parsed.sessionKey, hour);
+      const existing = byKey.get(key) ?? {
+        sessionKey: parsed.sessionKey,
+        hour,
+        turnCount: 0,
+        userTurns: 0,
+        assistantTurns: 0
+      };
+      existing.turnCount += 1;
+      if (parsed.role === "user") existing.userTurns += 1;
+      if (parsed.role === "assistant") existing.assistantTurns += 1;
+      byKey.set(key, existing);
+      parsedTurns += 1;
+    }
+  }
+  const aggregates = Array.from(byKey.values()).sort((a, b) => {
+    if (a.sessionKey !== b.sessionKey) return a.sessionKey.localeCompare(b.sessionKey);
+    return a.hour.localeCompare(b.hour);
+  });
+  return { aggregates, parsedTurns, malformedLines };
+}
+async function rebuildObservations(options) {
+  const dryRun = options.dryRun !== false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const transcriptsRoot = path36.join(options.memoryDir, "transcripts");
+  const outputPath = path36.join(
+    options.memoryDir,
+    "state",
+    "observation-ledger",
+    "rebuilt-observations.jsonl"
+  );
+  const transcriptFiles = await listTranscriptFiles(transcriptsRoot);
+  const contents = [];
+  for (const file of transcriptFiles) {
+    try {
+      contents.push(await readFile25(file, "utf-8"));
+    } catch {
+    }
+  }
+  const { aggregates, parsedTurns, malformedLines } = buildLedgerRows(contents);
+  let backupPath;
+  if (!dryRun) {
+    backupPath = await backupAndWriteRebuiltObservations({
+      memoryDir: options.memoryDir,
+      outputPath,
+      rows: aggregates,
+      now
+    });
+  }
+  return {
+    dryRun,
+    scannedFiles: transcriptFiles.length,
+    parsedTurns,
+    malformedLines,
+    rebuiltRows: aggregates.length,
+    outputPath,
+    backupPath
+  };
+}
+
+// src/maintenance/migrate-observations.ts
+import path37 from "path";
+import { readdir as readdir15, readFile as readFile26 } from "fs/promises";
+function toNonNegativeInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  const normalized = Math.floor(value);
+  if (normalized < 0) return null;
+  return normalized;
+}
+function toHourIso(value) {
+  if (typeof value !== "string" || value.length === 0) return null;
+  return toHourBucketIso(value);
+}
+function toSessionKey(row) {
+  const candidates = [row.sessionKey, row.session, row.session_id, row.sessionId];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return null;
+}
+function toLegacyHour(row) {
+  const candidates = [row.hour, row.hourStart, row.timestamp, row.time];
+  for (const candidate of candidates) {
+    const hour = toHourIso(candidate);
+    if (hour) return hour;
+  }
+  return null;
+}
+function toCounts(row) {
+  const role = row.role === "user" || row.role === "assistant" ? row.role : null;
+  const explicitTurnCount = toNonNegativeInt(row.turnCount) ?? toNonNegativeInt(row.turns) ?? toNonNegativeInt(row.totalTurns);
+  const explicitUserTurns = toNonNegativeInt(row.userTurns) ?? toNonNegativeInt(row.user) ?? toNonNegativeInt(row.userCount);
+  const explicitAssistantTurns = toNonNegativeInt(row.assistantTurns) ?? toNonNegativeInt(row.assistant) ?? toNonNegativeInt(row.assistantCount);
+  let turnCount = explicitTurnCount ?? 0;
+  let userTurns = explicitUserTurns ?? 0;
+  let assistantTurns = explicitAssistantTurns ?? 0;
+  if (turnCount === 0 && userTurns === 0 && assistantTurns === 0 && role) {
+    turnCount = 1;
+    if (role === "user") userTurns = 1;
+    if (role === "assistant") assistantTurns = 1;
+  }
+  if (turnCount === 0 && (userTurns > 0 || assistantTurns > 0)) {
+    turnCount = userTurns + assistantTurns;
+  }
+  if (turnCount < userTurns + assistantTurns) {
+    turnCount = userTurns + assistantTurns;
+  }
+  if (turnCount === 0) return null;
+  return { turnCount, userTurns, assistantTurns };
+}
+async function listLegacyObservationFiles(root) {
+  let entries;
+  try {
+    entries = await readdir15(root, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code && code === "ENOENT") return [];
+    throw err;
+  }
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).filter((name) => name !== "rebuilt-observations.jsonl").sort((a, b) => a.localeCompare(b));
+  return files;
+}
+async function migrateObservations(options) {
+  const dryRun = options.dryRun !== false;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const ledgerRoot = path37.join(options.memoryDir, "state", "observation-ledger");
+  const outputPath = path37.join(ledgerRoot, "rebuilt-observations.jsonl");
+  const legacyFiles = await listLegacyObservationFiles(ledgerRoot);
+  const sourceRelativePaths = legacyFiles.map((name) => path37.join("state", "observation-ledger", name));
+  const byKey = /* @__PURE__ */ new Map();
+  let parsedRows = 0;
+  let malformedLines = 0;
+  for (const file of legacyFiles) {
+    const full = path37.join(ledgerRoot, file);
+    const raw = await readFile26(full, "utf-8");
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      let parsed;
+      try {
+        const candidate = JSON.parse(line);
+        if (candidate == null || typeof candidate !== "object" || Array.isArray(candidate)) {
+          malformedLines += 1;
+          continue;
+        }
+        parsed = candidate;
+      } catch {
+        malformedLines += 1;
+        continue;
+      }
+      const sessionKey = toSessionKey(parsed);
+      const hour = toLegacyHour(parsed);
+      const counts = toCounts(parsed);
+      if (!sessionKey || !hour || !counts) {
+        malformedLines += 1;
+        continue;
+      }
+      const key = `${sessionKey}\0${hour}`;
+      const existing = byKey.get(key) ?? {
+        sessionKey,
+        hour,
+        turnCount: 0,
+        userTurns: 0,
+        assistantTurns: 0
+      };
+      existing.turnCount += counts.turnCount;
+      existing.userTurns += counts.userTurns;
+      existing.assistantTurns += counts.assistantTurns;
+      if (existing.turnCount < existing.userTurns + existing.assistantTurns) {
+        existing.turnCount = existing.userTurns + existing.assistantTurns;
+      }
+      byKey.set(key, existing);
+      parsedRows += 1;
+    }
+  }
+  const aggregates = Array.from(byKey.values()).sort((a, b) => {
+    if (a.sessionKey !== b.sessionKey) return a.sessionKey.localeCompare(b.sessionKey);
+    return a.hour.localeCompare(b.hour);
+  });
+  if (!dryRun && legacyFiles.length === 0) {
+    return {
+      dryRun,
+      scannedFiles: legacyFiles.length,
+      parsedRows,
+      malformedLines,
+      migratedRows: aggregates.length,
+      outputPath,
+      sourceRelativePaths
+    };
+  }
+  let backupPath;
+  if (!dryRun) {
+    backupPath = await backupAndWriteRebuiltObservations({
+      memoryDir: options.memoryDir,
+      outputPath,
+      rows: aggregates,
+      now
+    });
+  }
+  return {
+    dryRun,
+    scannedFiles: legacyFiles.length,
+    parsedRows,
+    malformedLines,
+    migratedRows: aggregates.length,
+    outputPath,
+    backupPath,
+    sourceRelativePaths
+  };
+}
+
 // src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -17335,6 +17748,28 @@ function planExactDuplicateDeletions(memories) {
 function planAggressiveDuplicateDeletions(memories) {
   return buildDedupePlan(memories, (memory) => normalizeAggressiveBody(memory.content));
 }
+async function runArchiveObservationsCliCommand(options) {
+  return archiveObservations({
+    memoryDir: options.memoryDir,
+    retentionDays: options.retentionDays,
+    dryRun: options.write !== true,
+    now: options.now
+  });
+}
+async function runRebuildObservationsCliCommand(options) {
+  return rebuildObservations({
+    memoryDir: options.memoryDir,
+    dryRun: options.write !== true,
+    now: options.now
+  });
+}
+async function runMigrateObservationsCliCommand(options) {
+  return migrateObservations({
+    memoryDir: options.memoryDir,
+    dryRun: options.write !== true,
+    now: options.now
+  });
+}
 async function withTimeout(promise, timeoutMs, timeoutMessage) {
   let timer;
   try {
@@ -17350,7 +17785,7 @@ async function withTimeout(promise, timeoutMs, timeoutMessage) {
 }
 async function runReplayCliCommand(orchestrator, options) {
   const extractionIdleTimeoutMs = Number.isFinite(options.extractionIdleTimeoutMs) ? Math.max(1e3, Math.floor(options.extractionIdleTimeoutMs)) : 15 * 6e4;
-  const inputRaw = await readFile23(options.inputPath, "utf-8");
+  const inputRaw = await readFile27(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -17415,7 +17850,7 @@ async function runReplayCliCommand(orchestrator, options) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile23(pkgPath, "utf-8");
+    const raw = await readFile27(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -17434,32 +17869,32 @@ 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 = path34.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path38.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 = [path34.join(memoryDir, "facts"), path34.join(memoryDir, "corrections")];
+  const roots = [path38.join(memoryDir, "facts"), path38.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await readdir13(dir, { withFileTypes: true });
+      entries = await readdir16(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path34.join(dir, entryName);
+      const fullPath = path38.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile23(fullPath, "utf-8");
+        const raw = await readFile27(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -17696,6 +18131,66 @@ function registerCli(api, orchestrator) {
         }
         console.log("OK");
       });
+      cmd.command("archive-observations").description("Archive aged observation artifacts (dry-run by default)").option("--retention-days <n>", "Archive files older than N days", "30").option("--write", "Apply archive mutations (default: dry-run)").action(async (...args) => {
+        const options = args[0] ?? {};
+        const retentionDays = parseInt(String(options.retentionDays ?? "30"), 10);
+        const result = await runArchiveObservationsCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          retentionDays: Number.isFinite(retentionDays) ? retentionDays : 30,
+          write: options.write === true
+        });
+        console.log(`Dry run: ${result.dryRun ? "yes" : "no"}`);
+        console.log(`Retention days: ${result.retentionDays}`);
+        console.log(`Scanned files: ${result.scannedFiles}`);
+        console.log(`Archived files: ${result.archivedFiles}`);
+        console.log(`Archived bytes: ${result.archivedBytes}`);
+        if (result.archivedRelativePaths.length > 0) {
+          console.log("Archived paths:");
+          for (const relPath of result.archivedRelativePaths.slice(0, 20)) {
+            console.log(`  - ${relPath}`);
+          }
+          if (result.archivedRelativePaths.length > 20) {
+            console.log(`  ... and ${result.archivedRelativePaths.length - 20} more`);
+          }
+        }
+        console.log("OK");
+      });
+      cmd.command("rebuild-observations").description("Rebuild observation ledger from transcript history (dry-run by default)").option("--write", "Write rebuilt ledger (default: dry-run)").action(async (...args) => {
+        const options = args[0] ?? {};
+        const result = await runRebuildObservationsCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          write: options.write === true
+        });
+        console.log(`Dry run: ${result.dryRun ? "yes" : "no"}`);
+        console.log(`Scanned transcript files: ${result.scannedFiles}`);
+        console.log(`Parsed turns: ${result.parsedTurns}`);
+        console.log(`Malformed lines: ${result.malformedLines}`);
+        console.log(`Rebuilt rows: ${result.rebuiltRows}`);
+        console.log(`Output path: ${result.outputPath}`);
+        if (result.backupPath) console.log(`Backup path: ${result.backupPath}`);
+        console.log("OK");
+      });
+      cmd.command("migrate-observations").description("Migrate legacy observation ledgers into rebuilt format (dry-run by default)").option("--write", "Write migrated ledger (default: dry-run)").action(async (...args) => {
+        const options = args[0] ?? {};
+        const result = await runMigrateObservationsCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          write: options.write === true
+        });
+        console.log(`Dry run: ${result.dryRun ? "yes" : "no"}`);
+        console.log(`Scanned legacy files: ${result.scannedFiles}`);
+        console.log(`Parsed rows: ${result.parsedRows}`);
+        console.log(`Malformed lines: ${result.malformedLines}`);
+        console.log(`Migrated rows: ${result.migratedRows}`);
+        if (result.sourceRelativePaths.length > 0) {
+          console.log("Source files:");
+          for (const relPath of result.sourceRelativePaths) {
+            console.log(`  - ${relPath}`);
+          }
+        }
+        console.log(`Output path: ${result.outputPath}`);
+        if (result.backupPath) console.log(`Backup path: ${result.backupPath}`);
+        console.log("OK");
+      });
       cmd.command("dedupe-exact").description("Delete exact duplicate memory entries (same body text), keeping highest-confidence/newest copy").option("--dry-run", "Show what would be deleted without deleting files").option("--namespace <ns>", "Namespace to dedupe (v3.0+, default: config defaultNamespace)", "").option("--qmd-sync", "Run QMD update/embed after deletions (default: off)").action(async (...args) => {
         const options = args[0] ?? {};
         const dryRun = options.dryRun === true;
@@ -17724,7 +18219,7 @@ function registerCli(api, orchestrator) {
         let deleted = 0;
         for (const filePath of plan.deletePaths) {
           try {
-            await unlink4(filePath);
+            await unlink5(filePath);
             deleted += 1;
           } catch (err) {
             console.log(`  failed to delete ${filePath}: ${String(err)}`);
@@ -17772,7 +18267,7 @@ function registerCli(api, orchestrator) {
         let deleted = 0;
         for (const filePath of plan.deletePaths) {
           try {
-            await unlink4(filePath);
+            await unlink5(filePath);
             deleted += 1;
           } catch (err) {
             console.log(`  failed to delete ${filePath}: ${String(err)}`);
@@ -17936,7 +18431,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path34.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path38.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -18159,8 +18654,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path34.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path34.join(memoryDir, "threads"));
+        const memoryDir = path38.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path38.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -18333,16 +18828,16 @@ function parseDuration(duration) {
 }
 
 // src/index.ts
-import { readFile as readFile24, writeFile as writeFile22 } from "fs/promises";
+import { readFile as readFile28, writeFile as writeFile24 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path35 from "path";
+import path39 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 : path35.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path39.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -18550,11 +19045,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
     );
     async function ensureHourlySummaryCron(api2) {
       const jobId = "engram-hourly-summary";
-      const cronFilePath = path35.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path39.join(os5.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile24(cronFilePath, "utf-8");
+          const content = await readFile28(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -18591,7 +19086,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile22(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile24(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
         log.info("auto-registered hourly summary cron job");
       } catch (err) {
         log.error("failed to auto-register hourly summary cron job:", err);