@joshuaswarren/openclaw-engram 9.0.34 → 9.0.36

package/README.md

@@ -37,6 +37,8 @@ AI agents forget everything between conversations. Engram fixes that.
 - **Trust-zone promotion path** — Engram can now, when `trustZonesEnabled` and `quarantinePromotionEnabled` are enabled, persist typed quarantine, working, and trusted records, plan explicit promotions, block direct `quarantine -> trusted` jumps, and require anchored provenance before promoting risky working records into `trusted`.
 - **Trust-zone recall** — Engram can now, when `trustZoneRecallEnabled` is enabled, inject prompt-relevant `working` and `trusted` trust-zone records into recall context as a separate `Trust Zones` section while keeping `quarantine` material out of recall by default.
 - **Poisoning-defense corroboration** — Engram can now, when `memoryPoisoningDefenseEnabled` is enabled, score trust-zone provenance deterministically and require independent non-quarantine corroboration before risky `working -> trusted` promotions succeed.
+- **Red-team benchmark packs** — Engram's eval harness can now validate and count typed `memory-red-team` benchmark packs so poisoning-defense regression suites stay explicit and reviewable instead of hiding inside generic benchmark metadata.
+- **Abstraction-node foundation** — Engram can now, when `harmonicRetrievalEnabled` is enabled, persist typed abstraction nodes for later harmonic retrieval slices, with `abstractionAnchorsEnabled` reserved for the future cue-anchor layer.
 - **Zero-config start** — Install, add an API key, restart. Engram works out of the box with sensible defaults and progressively unlocks advanced features as you enable them.
 
 ## Quick Start
@@ -199,6 +201,7 @@ Key settings:
 | `trustZoneStoreDir` | `{memoryDir}/state/trust-zones` | Root directory for trust-zone records |
 | `trustZoneRecallEnabled` | `false` | Inject prompt-relevant working and trusted trust-zone records into recall context |
 | `memoryPoisoningDefenseEnabled` | `false` | Enable deterministic provenance trust scoring and corroboration requirements for risky trusted promotions |
+| `memoryRedTeamBenchEnabled` | `false` | Enable typed memory red-team benchmark pack support and status accounting for poisoning-defense suites |
 
 Full reference: [Config Reference](docs/config-reference.md)
 

package/dist/index.js

@@ -301,6 +301,10 @@ function parseConfig(raw) {
     trustZoneStoreDir: typeof cfg.trustZoneStoreDir === "string" && cfg.trustZoneStoreDir.trim().length > 0 ? cfg.trustZoneStoreDir.trim() : path.join(memoryDir, "state", "trust-zones"),
     trustZoneRecallEnabled: cfg.trustZoneRecallEnabled === true,
     memoryPoisoningDefenseEnabled: cfg.memoryPoisoningDefenseEnabled === true,
+    memoryRedTeamBenchEnabled: cfg.memoryRedTeamBenchEnabled === true,
+    harmonicRetrievalEnabled: cfg.harmonicRetrievalEnabled === true,
+    abstractionAnchorsEnabled: cfg.abstractionAnchorsEnabled === true,
+    abstractionNodeStoreDir: typeof cfg.abstractionNodeStoreDir === "string" && cfg.abstractionNodeStoreDir.trim().length > 0 ? cfg.abstractionNodeStoreDir.trim() : path.join(memoryDir, "state", "abstraction-nodes"),
     // Local LLM Provider (v2.1)
     localLlmEnabled: cfg.localLlmEnabled === true || cfg.localLlmEnabled === "true",
     // default: false
@@ -11630,10 +11634,14 @@ function assertSafeBenchmarkId(benchmarkId) {
   }
   return benchmarkId;
 }
-function validateEvalBenchmarkManifest(raw) {
+function validateEvalBenchmarkManifest(raw, options) {
   if (!isRecord(raw)) throw new Error("benchmark manifest must be an object");
   if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
   if (!Array.isArray(raw.cases)) throw new Error("cases must be an array");
+  const benchmarkTypeRaw = typeof raw.benchmarkType === "string" && raw.benchmarkType.trim().length > 0 ? raw.benchmarkType.trim() : "standard";
+  if (!["standard", "memory-red-team"].includes(benchmarkTypeRaw)) {
+    throw new Error("benchmarkType must be one of standard|memory-red-team");
+  }
   const cases = raw.cases.map((item, index) => {
     if (!isRecord(item)) throw new Error(`cases[${index}] must be an object`);
     return {
@@ -11643,13 +11651,28 @@ function validateEvalBenchmarkManifest(raw) {
       notes: typeof item.notes === "string" && item.notes.trim().length > 0 ? item.notes.trim() : void 0
     };
   });
+  const benchmarkType = benchmarkTypeRaw;
+  if (benchmarkType === "memory-red-team" && options?.memoryRedTeamBenchEnabled !== true) {
+    throw new Error("memory-red-team benchmark packs require memoryRedTeamBenchEnabled");
+  }
+  const attackClass = typeof raw.attackClass === "string" && raw.attackClass.trim().length > 0 ? raw.attackClass.trim() : void 0;
+  const targetSurface = typeof raw.targetSurface === "string" && raw.targetSurface.trim().length > 0 ? raw.targetSurface.trim() : void 0;
+  if (benchmarkType === "memory-red-team" && attackClass === void 0) {
+    throw new Error("attackClass must be a non-empty string");
+  }
+  if (benchmarkType === "memory-red-team" && targetSurface === void 0) {
+    throw new Error("targetSurface must be a non-empty string");
+  }
   return {
     schemaVersion: 1,
     benchmarkId: assertString(raw.benchmarkId, "benchmarkId"),
+    benchmarkType,
     title: assertString(raw.title, "title"),
     description: typeof raw.description === "string" && raw.description.trim().length > 0 ? raw.description.trim() : void 0,
     tags: optionalStringArray(raw.tags, "tags"),
     sourceLinks: optionalStringArray(raw.sourceLinks, "sourceLinks"),
+    attackClass,
+    targetSurface,
     cases
   };
 }
@@ -11815,7 +11838,11 @@ async function collectEvalStoreSnapshot(options) {
   const manifests = [];
   for (const filePath of benchmarkFiles) {
     try {
-      manifests.push(validateEvalBenchmarkManifest(await readJsonFile(filePath)));
+      manifests.push(
+        validateEvalBenchmarkManifest(await readJsonFile(filePath), {
+          memoryRedTeamBenchEnabled: options.memoryRedTeamBenchEnabled
+        })
+      );
     } catch (error) {
       invalidBenchmarks.push({
         path: filePath,
@@ -11852,10 +11879,18 @@ async function collectEvalStoreSnapshot(options) {
   });
   shadows.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
   const tags = /* @__PURE__ */ new Set();
+  const attackClasses = /* @__PURE__ */ new Set();
   const sourceLinks = /* @__PURE__ */ new Set();
+  const targetSurfaces = /* @__PURE__ */ new Set();
   let totalCases = 0;
+  let redTeam = 0;
   for (const manifest of manifests) {
     totalCases += manifest.cases.length;
+    if (manifest.benchmarkType === "memory-red-team") {
+      redTeam += 1;
+      if (manifest.attackClass) attackClasses.add(manifest.attackClass);
+      if (manifest.targetSurface) targetSurfaces.add(manifest.targetSurface);
+    }
     for (const tag of manifest.tags ?? []) tags.add(tag);
     for (const link of manifest.sourceLinks ?? []) sourceLinks.add(link);
   }
@@ -11870,8 +11905,11 @@ async function collectEvalStoreSnapshot(options) {
         total: benchmarkFiles.length,
         valid: manifests.length,
         invalid: invalidBenchmarks.length,
+        redTeam,
         totalCases,
+        attackClasses: [...attackClasses].sort(),
         tags: [...tags].sort(),
+        targetSurfaces: [...targetSurfaces].sort(),
         sourceLinks: [...sourceLinks].sort()
       },
       runs: {
@@ -11919,25 +11957,32 @@ async function resolveBenchmarkManifestPath(sourcePath) {
   }
   throw new Error("benchmark pack source must be a file or directory");
 }
-async function validateEvalBenchmarkPack(sourcePath) {
+async function validateEvalBenchmarkPack(sourcePath, options) {
   const trimmedSourcePath = sourcePath.trim();
   if (trimmedSourcePath.length === 0) {
     throw new Error("benchmark pack path must be a non-empty string");
   }
   const { manifestPath } = await resolveBenchmarkManifestPath(trimmedSourcePath);
-  const manifest = validateEvalBenchmarkManifest(await readJsonFile(manifestPath));
+  const manifest = validateEvalBenchmarkManifest(await readJsonFile(manifestPath), {
+    memoryRedTeamBenchEnabled: options?.memoryRedTeamBenchEnabled
+  });
   return {
     sourcePath: trimmedSourcePath,
     manifestPath,
     benchmarkId: assertSafeBenchmarkId(manifest.benchmarkId),
+    benchmarkType: manifest.benchmarkType ?? "standard",
     title: manifest.title,
+    attackClass: manifest.attackClass,
+    targetSurface: manifest.targetSurface,
     totalCases: manifest.cases.length,
     tags: [...manifest.tags ?? []],
     sourceLinks: [...manifest.sourceLinks ?? []]
   };
 }
 async function importEvalBenchmarkPack(options) {
-  const summary = await validateEvalBenchmarkPack(options.sourcePath);
+  const summary = await validateEvalBenchmarkPack(options.sourcePath, {
+    memoryRedTeamBenchEnabled: options.memoryRedTeamBenchEnabled
+  });
   const rootDir = resolveEvalStoreDir(options.memoryDir, options.evalStoreDir);
   const benchmarkDir = path15.join(rootDir, "benchmarks");
   const targetDir = path15.join(benchmarkDir, summary.benchmarkId);
@@ -11982,7 +12027,8 @@ async function getEvalHarnessStatus(options) {
   return (await collectEvalStoreSnapshot({
     rootDir: resolveEvalStoreDir(options.memoryDir, options.evalStoreDir),
     enabled: options.enabled,
-    shadowModeEnabled: options.shadowModeEnabled
+    shadowModeEnabled: options.shadowModeEnabled,
+    memoryRedTeamBenchEnabled: options.memoryRedTeamBenchEnabled
   })).status;
 }
 function resolveRequiredEvalStoreRoot(options, label) {
@@ -12006,12 +12052,14 @@ async function runEvalBenchmarkCiGate(options) {
   const baseSnapshot = await collectEvalStoreSnapshot({
     rootDir: baseRootDir,
     enabled: true,
-    shadowModeEnabled: true
+    shadowModeEnabled: true,
+    memoryRedTeamBenchEnabled: true
   });
   const candidateSnapshot = await collectEvalStoreSnapshot({
     rootDir: candidateRootDir,
     enabled: true,
-    shadowModeEnabled: true
+    shadowModeEnabled: true,
+    memoryRedTeamBenchEnabled: true
   });
   const regressions = [];
   const improvements = [];
@@ -24175,7 +24223,7 @@ promotionCandidates: ${res.promotionCandidateCount}`
 }
 
 // src/cli.ts
-import path54 from "path";
+import path55 from "path";
 import { access as access3, readFile as readFile37, readdir as readdir24, unlink as unlink7 } from "fs/promises";
 import { createHash as createHash10 } from "crypto";
 
@@ -25056,8 +25104,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path56 = typeof record.path === "string" ? record.path : "";
-      if (!path56.startsWith("transcripts/") && !path56.includes("/transcripts/")) continue;
+      const path57 = typeof record.path === "string" ? record.path : "";
+      if (!path57.startsWith("transcripts/") && !path57.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -26691,6 +26739,90 @@ async function runCompatChecks(options) {
   };
 }
 
+// src/abstraction-nodes.ts
+import path54 from "path";
+import { mkdir as mkdir36, writeFile as writeFile33 } from "fs/promises";
+function validateKind2(raw) {
+  const value = assertString2(raw, "kind");
+  if (!["episode", "topic", "project", "workflow", "constraint"].includes(value)) {
+    throw new Error("kind must be one of episode|topic|project|workflow|constraint");
+  }
+  return value;
+}
+function validateLevel(raw) {
+  const value = assertString2(raw, "abstractionLevel");
+  if (!["micro", "meso", "macro"].includes(value)) {
+    throw new Error("abstractionLevel must be one of micro|meso|macro");
+  }
+  return value;
+}
+function resolveAbstractionNodeStoreDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path54.join(memoryDir, "state", "abstraction-nodes");
+}
+function validateAbstractionNode(raw) {
+  if (!isRecord2(raw)) throw new Error("abstraction node must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  return {
+    schemaVersion: 1,
+    nodeId: assertSafePathSegment(assertString2(raw.nodeId, "nodeId"), "nodeId"),
+    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
+    kind: validateKind2(raw.kind),
+    abstractionLevel: validateLevel(raw.abstractionLevel),
+    title: assertString2(raw.title, "title"),
+    summary: assertString2(raw.summary, "summary"),
+    sourceMemoryIds: optionalStringArray2(raw.sourceMemoryIds, "sourceMemoryIds"),
+    entityRefs: optionalStringArray2(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray2(raw.tags, "tags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function getAbstractionNodeStoreStatus(options) {
+  const rootDir = resolveAbstractionNodeStoreDir(options.memoryDir, options.abstractionNodeStoreDir);
+  const nodesDir = path54.join(rootDir, "nodes");
+  const files = await listJsonFiles(nodesDir);
+  const nodes = [];
+  const invalidNodes = [];
+  for (const filePath of files) {
+    try {
+      nodes.push(validateAbstractionNode(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidNodes.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  nodes.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byKind = {};
+  const byLevel = {};
+  for (const node of nodes) {
+    byKind[node.kind] = (byKind[node.kind] ?? 0) + 1;
+    byLevel[node.abstractionLevel] = (byLevel[node.abstractionLevel] ?? 0) + 1;
+  }
+  return {
+    enabled: options.enabled,
+    anchorsEnabled: options.anchorsEnabled,
+    rootDir,
+    nodesDir,
+    nodes: {
+      total: files.length,
+      valid: nodes.length,
+      invalid: invalidNodes.length,
+      byKind,
+      byLevel,
+      latestNodeId: nodes[0]?.nodeId,
+      latestRecordedAt: nodes[0]?.recordedAt,
+      latestSessionKey: nodes[0]?.sessionKey
+    },
+    latestNode: nodes[0],
+    invalidNodes
+  };
+}
+
 // src/cli.ts
 function rankCandidateForKeep(a, b) {
   const aConfidence = typeof a.frontmatter.confidence === "number" ? a.frontmatter.confidence : 0;
@@ -26852,18 +26984,22 @@ async function runBenchmarkStatusCliCommand(options) {
     memoryDir: options.memoryDir,
     evalStoreDir: options.evalStoreDir,
     enabled: options.evalHarnessEnabled,
-    shadowModeEnabled: options.evalShadowModeEnabled
+    shadowModeEnabled: options.evalShadowModeEnabled,
+    memoryRedTeamBenchEnabled: options.memoryRedTeamBenchEnabled
   });
 }
 async function runBenchmarkValidateCliCommand(options) {
-  return validateEvalBenchmarkPack(options.path);
+  return validateEvalBenchmarkPack(options.path, {
+    memoryRedTeamBenchEnabled: options.memoryRedTeamBenchEnabled
+  });
 }
 async function runBenchmarkImportCliCommand(options) {
   return importEvalBenchmarkPack({
     sourcePath: options.path,
     memoryDir: options.memoryDir,
     evalStoreDir: options.evalStoreDir,
-    force: options.force === true
+    force: options.force === true,
+    memoryRedTeamBenchEnabled: options.memoryRedTeamBenchEnabled
   });
 }
 async function runBenchmarkCiGateCliCommand(options) {
@@ -26896,6 +27032,14 @@ async function runTrustZoneStatusCliCommand(options) {
     poisoningDefenseEnabled: options.memoryPoisoningDefenseEnabled
   });
 }
+async function runAbstractionNodeStatusCliCommand(options) {
+  return getAbstractionNodeStoreStatus({
+    memoryDir: options.memoryDir,
+    abstractionNodeStoreDir: options.abstractionNodeStoreDir,
+    enabled: options.harmonicRetrievalEnabled,
+    anchorsEnabled: options.abstractionAnchorsEnabled
+  });
+}
 async function runTrustZonePromoteCliCommand(options) {
   const result = await promoteTrustZoneRecord({
     memoryDir: options.memoryDir,
@@ -27142,7 +27286,7 @@ function policyVersionForValues(values, config) {
   return createHash10("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path54.join(config.memoryDir, "state", fileName);
+  const filePath = path55.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -27726,14 +27870,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 = path54.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path55.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 = [path54.join(memoryDir, "facts"), path54.join(memoryDir, "corrections")];
+  const roots = [path55.join(memoryDir, "facts"), path55.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -27744,7 +27888,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 = path54.join(dir, entryName);
+      const fullPath = path55.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -28017,7 +28161,8 @@ function registerCli(api, orchestrator) {
           memoryDir: orchestrator.config.memoryDir,
           evalStoreDir: orchestrator.config.evalStoreDir,
           evalHarnessEnabled: orchestrator.config.evalHarnessEnabled,
-          evalShadowModeEnabled: orchestrator.config.evalShadowModeEnabled
+          evalShadowModeEnabled: orchestrator.config.evalShadowModeEnabled,
+          memoryRedTeamBenchEnabled: orchestrator.config.memoryRedTeamBenchEnabled
         });
         console.log(JSON.stringify(status, null, 2));
         console.log("OK");
@@ -28025,7 +28170,8 @@ function registerCli(api, orchestrator) {
       cmd.command("benchmark-validate").description("Validate a benchmark manifest file or pack directory without importing it").argument("<path>", "Path to a benchmark manifest JSON file or a directory with manifest.json").action(async (...args) => {
         const inputPath = args[0];
         const summary = await runBenchmarkValidateCliCommand({
-          path: typeof inputPath === "string" ? inputPath : ""
+          path: typeof inputPath === "string" ? inputPath : "",
+          memoryRedTeamBenchEnabled: orchestrator.config.memoryRedTeamBenchEnabled
         });
         console.log(JSON.stringify(summary, null, 2));
         console.log("OK");
@@ -28037,7 +28183,8 @@ function registerCli(api, orchestrator) {
           path: typeof inputPath === "string" ? inputPath : "",
           memoryDir: orchestrator.config.memoryDir,
           evalStoreDir: orchestrator.config.evalStoreDir,
-          force: options.force === true
+          force: options.force === true,
+          memoryRedTeamBenchEnabled: orchestrator.config.memoryRedTeamBenchEnabled
         });
         console.log(JSON.stringify(summary, null, 2));
         console.log("OK");
@@ -28084,6 +28231,16 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(status, null, 2));
         console.log("OK");
       });
+      cmd.command("abstraction-node-status").description("Show abstraction-node store status, abstraction counts, and latest stored node").action(async () => {
+        const status = await runAbstractionNodeStatusCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          abstractionNodeStoreDir: orchestrator.config.abstractionNodeStoreDir,
+          harmonicRetrievalEnabled: orchestrator.config.harmonicRetrievalEnabled,
+          abstractionAnchorsEnabled: orchestrator.config.abstractionAnchorsEnabled
+        });
+        console.log(JSON.stringify(status, null, 2));
+        console.log("OK");
+      });
       cmd.command("trust-zone-promote").description("Dry-run or apply a trust-zone promotion with provenance enforcement").requiredOption("--record-id <recordId>", "Source trust-zone record id").requiredOption("--target-zone <targetZone>", "Promotion target zone (working|trusted)").requiredOption("--reason <reason>", "Human-readable promotion reason").option("--recorded-at <isoTimestamp>", "Promotion timestamp (defaults to now)").option("--summary <summary>", "Optional replacement summary for the promoted record").option("--dry-run", "Show the promotion plan without writing the promoted record").action(async (...args) => {
         const options = args[0] ?? {};
         const result = await runTrustZonePromoteCliCommand({
@@ -28751,7 +28908,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path54.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path55.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -28974,8 +29131,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path54.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path54.join(memoryDir, "threads"));
+        const memoryDir = path55.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path55.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -29451,9 +29608,9 @@ async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
 }
 
 // src/index.ts
-import { readFile as readFile38, writeFile as writeFile33 } from "fs/promises";
+import { readFile as readFile38, writeFile as writeFile34 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path55 from "path";
+import path56 from "path";
 import os6 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 var ENGRAM_HOOK_APIS = "__openclawEngramHookApis";
@@ -29461,7 +29618,7 @@ function loadPluginConfigFromFile() {
   try {
     const explicitConfigPath = process.env.OPENCLAW_ENGRAM_CONFIG_PATH || process.env.OPENCLAW_CONFIG_PATH;
     const homeDir = process.env.HOME ?? os6.homedir();
-    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path55.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path56.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -29711,11 +29868,11 @@ Use this context naturally when relevant. Never quote or expose this memory cont
                 `session reset via API for ${sessionKey}, new sessionId=${result.sessionId}`
               );
               const safeSessionKey = sanitizeSessionKeyForFilename(sessionKey);
-              const signalPath = path55.join(
+              const signalPath = path56.join(
                 workspaceDir,
                 `.compaction-reset-signal-${safeSessionKey}`
               );
-              await writeFile33(
+              await writeFile34(
                 signalPath,
                 JSON.stringify({
                   sessionKey,
@@ -29742,7 +29899,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 = path55.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path56.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
@@ -29783,7 +29940,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile33(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile34(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);