@joshuaswarren/openclaw-engram 9.0.48 → 9.0.49

package/README.md

@@ -47,7 +47,7 @@ AI agents forget everything between conversations. Engram fixes that.
 - **Artifact recovery recall** — Engram can now, when both `creationMemoryEnabled` and `workProductRecallEnabled` are enabled, surface prompt-relevant work-product ledger entries back into recall as a dedicated `Work Products` section and inspect reuse candidates with `openclaw engram work-product-recall-search`.
 - **Commitment lifecycle foundation** — Engram can now, when `creationMemoryEnabled`, `commitmentLedgerEnabled`, and `commitmentLifecycleEnabled` are enabled, transition existing commitments to `fulfilled` / `cancelled` / `expired`, inspect overdue and stale obligations in `openclaw engram commitment-status`, and run deterministic lifecycle cleanup with `openclaw engram commitment-lifecycle-run`.
 - **Resume-bundle builder** — Engram can now, when `creationMemoryEnabled` and `resumeBundlesEnabled` are enabled, persist typed crash-recovery resume bundles, inspect them with `openclaw engram resume-bundle-status`, write explicit handoff shells through `openclaw engram resume-bundle-record`, and build bounded resume bundles from transcript recovery, recent objective-state snapshots, work products, and open commitments through `openclaw engram resume-bundle-build`.
-- **Utility-learning telemetry foundation** — Engram can now, when `memoryUtilityLearningEnabled` is enabled, persist typed downstream utility events for promotion and ranking decisions, inspect them with `openclaw engram utility-status`, and write deterministic benchmark/operator telemetry through `openclaw engram utility-record` before learned weighting lands.
+- **Utility-learning offline learner** — Engram can now, when `memoryUtilityLearningEnabled` is enabled, persist typed downstream utility events for promotion and ranking decisions, inspect the raw event ledger with `openclaw engram utility-status`, record deterministic benchmark/operator telemetry through `openclaw engram utility-record`, and learn bounded offline promotion/ranking weights through `openclaw engram utility-learn` and `openclaw engram utility-learning-status` before runtime weighting lands.
 - **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
@@ -186,6 +186,8 @@ openclaw engram work-product-record         # Record a typed work-product ledger
 openclaw engram work-product-recall-search <query> # Preview reusable work products from the creation-memory ledger
 openclaw engram utility-status              # Utility-learning telemetry counts and latest observed outcome event
 openclaw engram utility-record              # Record a typed utility-learning telemetry event
+openclaw engram utility-learning-status     # Latest offline utility-learning snapshot and learned weight counts
+openclaw engram utility-learn               # Learn bounded offline promotion/ranking weights from recorded utility events
 openclaw engram conversation-index-health    # Conversation index status
 openclaw engram graph-health                 # Entity graph status
 openclaw engram tier-status                  # Hot/cold tier metrics

package/dist/index.js

@@ -25311,8 +25311,8 @@ promotionCandidates: ${res.promotionCandidateCount}`
 }
 
 // src/cli.ts
-import path61 from "path";
-import { access as access3, readFile as readFile37, readdir as readdir24, unlink as unlink8 } from "fs/promises";
+import path62 from "path";
+import { access as access3, readFile as readFile38, readdir as readdir24, unlink as unlink8 } from "fs/promises";
 import { createHash as createHash10 } from "crypto";
 
 // src/transfer/export-json.ts
@@ -26192,8 +26192,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path63 = typeof record.path === "string" ? record.path : "";
-      if (!path63.startsWith("transcripts/") && !path63.includes("/transcripts/")) continue;
+      const path64 = typeof record.path === "string" ? record.path : "";
+      if (!path64.startsWith("transcripts/") && !path64.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -27959,15 +27959,268 @@ async function getUtilityTelemetryStatus(options) {
   };
 }
 
-// src/resume-bundles.ts
+// src/utility-learner.ts
 import path60 from "path";
-import { mkdir as mkdir41, writeFile as writeFile38 } from "fs/promises";
+import { mkdir as mkdir41, readFile as readFile37, rename as rename4, writeFile as writeFile38 } from "fs/promises";
+var UTILITY_LEARNING_SNAPSHOT_VERSION = 1;
+var UTILITY_LEARNING_STATE_FILE = "learning-state.json";
+function clampWeight(value, maxWeightMagnitude) {
+  const limit = Number.isFinite(maxWeightMagnitude) && maxWeightMagnitude > 0 ? maxWeightMagnitude : 0;
+  return Math.max(-limit, Math.min(limit, value));
+}
+function coerceLearningWindowDays(value) {
+  if (!Number.isFinite(value)) return 14;
+  return Math.max(1, Math.floor(value));
+}
+function coerceMinEventCount(value) {
+  if (!Number.isFinite(value)) return 3;
+  return Math.max(1, Math.floor(value));
+}
+function coerceMaxWeightMagnitude(value) {
+  if (!Number.isFinite(value)) return 0.35;
+  return Math.max(0, Math.min(1, value));
+}
+function roundWeight(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function outcomeCountsFor(events) {
+  const counts = {};
+  for (const event of events) {
+    counts[event.outcome] = (counts[event.outcome] ?? 0) + 1;
+  }
+  return counts;
+}
+function selectRecentEvents(events, now, windowDays) {
+  if (!Number.isFinite(windowDays) || windowDays <= 0) return [...events];
+  const minTimestamp = now.getTime() - windowDays * 864e5;
+  return events.filter((event) => {
+    const ts = Date.parse(event.recordedAt);
+    return Number.isFinite(ts) && ts >= minTimestamp;
+  });
+}
+function confidenceFromEvents(eventCount, averageUtilityScore) {
+  if (eventCount <= 0) return 0;
+  return roundWeight(clamp01(Math.abs(averageUtilityScore) * Math.min(1, eventCount / 10)));
+}
+function validateUtilityLearningSnapshot(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("utility learning snapshot must be an object");
+  }
+  const record = raw;
+  if (record.version !== UTILITY_LEARNING_SNAPSHOT_VERSION) {
+    throw new Error("utility learning snapshot version must be 1");
+  }
+  if (typeof record.updatedAt !== "string" || record.updatedAt.length === 0) {
+    throw new Error("utility learning snapshot updatedAt must be a string");
+  }
+  if (typeof record.windowDays !== "number" || !Number.isFinite(record.windowDays) || record.windowDays < 0) {
+    throw new Error("utility learning snapshot windowDays must be a non-negative number");
+  }
+  if (typeof record.minEventCount !== "number" || !Number.isFinite(record.minEventCount) || record.minEventCount < 1) {
+    throw new Error("utility learning snapshot minEventCount must be >= 1");
+  }
+  if (typeof record.maxWeightMagnitude !== "number" || !Number.isFinite(record.maxWeightMagnitude) || record.maxWeightMagnitude < 0) {
+    throw new Error("utility learning snapshot maxWeightMagnitude must be >= 0");
+  }
+  if (!Array.isArray(record.weights)) {
+    throw new Error("utility learning snapshot weights must be an array");
+  }
+  const weights = record.weights.map((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error("utility learning weight must be an object");
+    }
+    const weight = entry;
+    const target = weight.target;
+    const decision = weight.decision;
+    if (target !== "promotion" && target !== "ranking") {
+      throw new Error("utility learning weight target must be promotion|ranking");
+    }
+    if (!["promote", "demote", "hold", "boost", "suppress"].includes(String(decision))) {
+      throw new Error("utility learning weight decision is invalid");
+    }
+    if (typeof weight.eventCount !== "number" || !Number.isFinite(weight.eventCount) || weight.eventCount < 0) {
+      throw new Error("utility learning weight eventCount must be >= 0");
+    }
+    if (typeof weight.learnedWeight !== "number" || !Number.isFinite(weight.learnedWeight)) {
+      throw new Error("utility learning weight learnedWeight must be finite");
+    }
+    if (typeof weight.averageUtilityScore !== "number" || !Number.isFinite(weight.averageUtilityScore)) {
+      throw new Error("utility learning weight averageUtilityScore must be finite");
+    }
+    if (typeof weight.confidence !== "number" || !Number.isFinite(weight.confidence)) {
+      throw new Error("utility learning weight confidence must be finite");
+    }
+    if (typeof weight.updatedAt !== "string" || weight.updatedAt.length === 0) {
+      throw new Error("utility learning weight updatedAt must be a string");
+    }
+    const outcomeCounts = weight.outcomeCounts ?? {};
+    return {
+      target,
+      decision,
+      eventCount: weight.eventCount,
+      learnedWeight: roundWeight(weight.learnedWeight),
+      averageUtilityScore: roundWeight(weight.averageUtilityScore),
+      confidence: roundWeight(clamp01(weight.confidence)),
+      outcomeCounts,
+      updatedAt: weight.updatedAt
+    };
+  });
+  return {
+    version: 1,
+    updatedAt: record.updatedAt,
+    windowDays: record.windowDays,
+    minEventCount: record.minEventCount,
+    maxWeightMagnitude: record.maxWeightMagnitude,
+    weights
+  };
+}
+function resolveUtilityLearningStatePath(memoryDir, utilityTelemetryDir) {
+  return path60.join(resolveUtilityTelemetryDir(memoryDir, utilityTelemetryDir), UTILITY_LEARNING_STATE_FILE);
+}
+async function readUtilityLearningSnapshot(memoryDir, utilityTelemetryDir) {
+  const statePath = resolveUtilityLearningStatePath(memoryDir, utilityTelemetryDir);
+  try {
+    const raw = JSON.parse(await readFile37(statePath, "utf8"));
+    return validateUtilityLearningSnapshot(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeUtilityLearningSnapshot(statePath, snapshot) {
+  const tempPath = `${statePath}.tmp`;
+  await mkdir41(path60.dirname(statePath), { recursive: true });
+  await writeFile38(tempPath, `${JSON.stringify(snapshot, null, 2)}
+`, "utf8");
+  await rename4(tempPath, statePath);
+}
+async function learnUtilityPromotionWeights(options) {
+  const statePath = resolveUtilityLearningStatePath(options.memoryDir, options.utilityTelemetryDir);
+  if (!options.enabled) {
+    return {
+      applied: false,
+      reason: "disabled",
+      statePath,
+      snapshot: null
+    };
+  }
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const updatedAt = now.toISOString();
+  const windowDays = coerceLearningWindowDays(options.learningWindowDays);
+  const minEventCount = coerceMinEventCount(options.minEventCount);
+  const maxWeightMagnitude = coerceMaxWeightMagnitude(options.maxWeightMagnitude);
+  const recentEvents = selectRecentEvents(
+    (await readUtilityTelemetryEvents({
+      memoryDir: options.memoryDir,
+      utilityTelemetryDir: options.utilityTelemetryDir
+    })).events,
+    now,
+    windowDays
+  );
+  const grouped = /* @__PURE__ */ new Map();
+  for (const event of recentEvents) {
+    const key = `${event.target}:${event.decision}`;
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.push(event);
+    } else {
+      grouped.set(key, [event]);
+    }
+  }
+  const weights = [];
+  for (const events of grouped.values()) {
+    if (events.length < minEventCount) continue;
+    const target = events[0].target;
+    const decision = events[0].decision;
+    const averageUtilityScore = events.reduce((sum, event) => sum + event.utilityScore, 0) / events.length;
+    const confidence = confidenceFromEvents(events.length, averageUtilityScore);
+    const learnedWeight = roundWeight(
+      clampWeight(averageUtilityScore * confidence, maxWeightMagnitude)
+    );
+    weights.push({
+      target,
+      decision,
+      eventCount: events.length,
+      learnedWeight,
+      averageUtilityScore: roundWeight(averageUtilityScore),
+      confidence,
+      outcomeCounts: outcomeCountsFor(events),
+      updatedAt
+    });
+  }
+  weights.sort((left, right) => {
+    const targetCompare = left.target.localeCompare(right.target);
+    if (targetCompare !== 0) return targetCompare;
+    return left.decision.localeCompare(right.decision);
+  });
+  const snapshot = {
+    version: 1,
+    updatedAt,
+    windowDays,
+    minEventCount,
+    maxWeightMagnitude,
+    weights
+  };
+  if (weights.length === 0) {
+    return {
+      applied: false,
+      reason: "insufficient_events",
+      statePath,
+      snapshot
+    };
+  }
+  await writeUtilityLearningSnapshot(statePath, snapshot);
+  return {
+    applied: true,
+    reason: "learned",
+    statePath,
+    snapshot
+  };
+}
+async function getUtilityLearningStatus(options) {
+  const rootDir = resolveUtilityTelemetryDir(options.memoryDir, options.utilityTelemetryDir);
+  const statePath = resolveUtilityLearningStatePath(options.memoryDir, options.utilityTelemetryDir);
+  if (!options.enabled) {
+    return {
+      enabled: false,
+      promotionByOutcomeEnabled: options.promotionByOutcomeEnabled === true,
+      rootDir,
+      statePath,
+      snapshot: null,
+      weights: {
+        total: 0,
+        positive: 0,
+        negative: 0,
+        zero: 0
+      }
+    };
+  }
+  const snapshot = await readUtilityLearningSnapshot(options.memoryDir, options.utilityTelemetryDir);
+  const weights = snapshot?.weights ?? [];
+  return {
+    enabled: true,
+    promotionByOutcomeEnabled: options.promotionByOutcomeEnabled === true,
+    rootDir,
+    statePath,
+    snapshot,
+    weights: {
+      total: weights.length,
+      positive: weights.filter((entry) => entry.learnedWeight > 0).length,
+      negative: weights.filter((entry) => entry.learnedWeight < 0).length,
+      zero: weights.filter((entry) => entry.learnedWeight === 0).length,
+      latestUpdatedAt: snapshot?.updatedAt
+    }
+  };
+}
+
+// src/resume-bundles.ts
+import path61 from "path";
+import { mkdir as mkdir42, writeFile as writeFile39 } from "fs/promises";
 var DEFAULT_RESUME_BUNDLE_REF_LIMIT = 5;
 function resolveResumeBundleDir(memoryDir, overrideDir) {
   if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
     return overrideDir.trim();
   }
-  return path60.join(memoryDir, "state", "resume-bundles");
+  return path61.join(memoryDir, "state", "resume-bundles");
 }
 function validateResumeBundle(raw) {
   if (!isRecord2(raw)) throw new Error("resume bundle must be an object");
@@ -28011,7 +28264,7 @@ async function readValidatedItems(options) {
 async function readObjectiveStateSnapshotsForSession(options) {
   const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);
   const items = await readValidatedItems({
-    rootDir: path60.join(rootDir, "snapshots"),
+    rootDir: path61.join(rootDir, "snapshots"),
     validate: validateObjectiveStateSnapshot
   });
   return items.filter((item) => item.sessionKey === options.sessionKey).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
@@ -28019,7 +28272,7 @@ async function readObjectiveStateSnapshotsForSession(options) {
 async function readWorkProductEntriesForSession(options) {
   const rootDir = resolveWorkProductLedgerDir(options.memoryDir, options.workProductLedgerDir);
   const items = await readValidatedItems({
-    rootDir: path60.join(rootDir, "entries"),
+    rootDir: path61.join(rootDir, "entries"),
     validate: validateWorkProductLedgerEntry
   });
   return items.filter((item) => item.sessionKey === options.sessionKey).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
@@ -28027,7 +28280,7 @@ async function readWorkProductEntriesForSession(options) {
 async function readCommitmentEntriesForSession(options) {
   const rootDir = resolveCommitmentLedgerDir(options.memoryDir, options.commitmentLedgerDir);
   const items = await readValidatedItems({
-    rootDir: path60.join(rootDir, "entries"),
+    rootDir: path61.join(rootDir, "entries"),
     validate: validateCommitmentLedgerEntry
   });
   return items.filter((item) => item.sessionKey === options.sessionKey).filter((item) => options.state ? item.state === options.state : true).sort((left, right) => right.recordedAt.localeCompare(left.recordedAt)).slice(0, options.maxResults ?? DEFAULT_RESUME_BUNDLE_REF_LIMIT);
@@ -28123,15 +28376,15 @@ async function recordResumeBundle(options) {
   const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
   const validated = validateResumeBundle(options.bundle);
   const day = recordStoreDay(validated.recordedAt);
-  const bundlesDir = path60.join(rootDir, "bundles", day);
-  const filePath = path60.join(bundlesDir, `${validated.bundleId}.json`);
-  await mkdir41(bundlesDir, { recursive: true });
-  await writeFile38(filePath, JSON.stringify(validated, null, 2), "utf8");
+  const bundlesDir = path61.join(rootDir, "bundles", day);
+  const filePath = path61.join(bundlesDir, `${validated.bundleId}.json`);
+  await mkdir42(bundlesDir, { recursive: true });
+  await writeFile39(filePath, JSON.stringify(validated, null, 2), "utf8");
   return filePath;
 }
 async function readResumeBundles(options) {
   const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
-  const files = await listJsonFiles(path60.join(rootDir, "bundles"));
+  const files = await listJsonFiles(path61.join(rootDir, "bundles"));
   const bundles = [];
   const invalidBundles = [];
   for (const filePath of files) {
@@ -28148,7 +28401,7 @@ async function readResumeBundles(options) {
 }
 async function getResumeBundleStatus(options) {
   const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
-  const bundlesDir = path60.join(rootDir, "bundles");
+  const bundlesDir = path61.join(rootDir, "bundles");
   if (!options.enabled) {
     return {
       enabled: false,
@@ -28592,6 +28845,22 @@ async function runUtilityTelemetryRecordCliCommand(options) {
     event: options.event
   });
 }
+async function runUtilityLearningStatusCliCommand(options) {
+  return getUtilityLearningStatus({
+    memoryDir: options.memoryDir,
+    enabled: options.memoryUtilityLearningEnabled,
+    promotionByOutcomeEnabled: options.promotionByOutcomeEnabled
+  });
+}
+async function runUtilityLearningCliCommand(options) {
+  return learnUtilityPromotionWeights({
+    memoryDir: options.memoryDir,
+    enabled: options.memoryUtilityLearningEnabled,
+    learningWindowDays: options.learningWindowDays ?? 14,
+    minEventCount: options.minEventCount ?? 3,
+    maxWeightMagnitude: options.maxWeightMagnitude ?? 0.35
+  });
+}
 async function runWorkProductRecordCliCommand(options) {
   if (!options.creationMemoryEnabled) return null;
   return recordWorkProductLedgerEntry({
@@ -28939,7 +29208,7 @@ function policyVersionForValues(values, config) {
   return createHash10("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path61.join(config.memoryDir, "state", fileName);
+  const filePath = path62.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -29439,7 +29708,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 readFile37(options.inputPath, "utf-8");
+  const inputRaw = await readFile38(options.inputPath, "utf-8");
   const registry = buildReplayNormalizerRegistry([
     openclawReplayNormalizer,
     claudeReplayNormalizer,
@@ -29504,7 +29773,7 @@ async function runReplayCliCommand(orchestrator, options) {
 async function getPluginVersion() {
   try {
     const pkgPath = new URL("../package.json", import.meta.url);
-    const raw = await readFile37(pkgPath, "utf-8");
+    const raw = await readFile38(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version ?? "unknown";
   } catch {
@@ -29523,14 +29792,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 = path61.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path62.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 = [path61.join(memoryDir, "facts"), path61.join(memoryDir, "corrections")];
+  const roots = [path62.join(memoryDir, "facts"), path62.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -29541,14 +29810,14 @@ async function readAllMemoryFiles(memoryDir) {
     }
     for (const entry of entries) {
       const entryName = typeof entry.name === "string" ? entry.name : entry.name.toString("utf-8");
-      const fullPath = path61.join(dir, entryName);
+      const fullPath = path62.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
       }
       if (!entry.isFile() || !entryName.endsWith(".md")) continue;
       try {
-        const raw = await readFile37(fullPath, "utf-8");
+        const raw = await readFile38(fullPath, "utf-8");
         const parsed = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
         if (!parsed) continue;
         const fmRaw = parsed[1];
@@ -29954,6 +30223,30 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify({ wrote: filePath !== null, filePath }, null, 2));
         console.log("OK");
       });
+      cmd.command("utility-learning-status").description("Show offline utility-learning snapshot status and learned weight counts").action(async () => {
+        const status = await runUtilityLearningStatusCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          memoryUtilityLearningEnabled: orchestrator.config.memoryUtilityLearningEnabled,
+          promotionByOutcomeEnabled: orchestrator.config.promotionByOutcomeEnabled
+        });
+        console.log(JSON.stringify(status, null, 2));
+        console.log("OK");
+      });
+      cmd.command("utility-learn").description("Learn bounded offline promotion/ranking weights from recorded utility telemetry").option("--window-days <days>", "Telemetry lookback window in days", "14").option("--min-event-count <count>", "Minimum event count required per target/decision group", "3").option("--max-weight-magnitude <value>", "Maximum absolute learned weight magnitude", "0.35").action(async (...args) => {
+        const options = args[0] ?? {};
+        const learningWindowDays = typeof options.windowDays === "string" ? Number.parseInt(options.windowDays, 10) : 14;
+        const minEventCount = typeof options.minEventCount === "string" ? Number.parseInt(options.minEventCount, 10) : 3;
+        const maxWeightMagnitude = typeof options.maxWeightMagnitude === "string" ? Number.parseFloat(options.maxWeightMagnitude) : 0.35;
+        const result = await runUtilityLearningCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          memoryUtilityLearningEnabled: orchestrator.config.memoryUtilityLearningEnabled,
+          learningWindowDays,
+          minEventCount,
+          maxWeightMagnitude
+        });
+        console.log(JSON.stringify(result, null, 2));
+        console.log("OK");
+      });
       cmd.command("resume-bundle-status").description("Show resume bundle status, bundle counts, and the latest recorded handoff bundle").action(async () => {
         const status = await runResumeBundleStatusCliCommand({
           memoryDir: orchestrator.config.memoryDir,
@@ -30860,7 +31153,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path61.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path62.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -31083,8 +31376,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path61.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path61.join(memoryDir, "threads"));
+        const memoryDir = path62.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path62.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -31560,9 +31853,9 @@ async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
 }
 
 // src/index.ts
-import { readFile as readFile38, writeFile as writeFile39 } from "fs/promises";
+import { readFile as readFile39, writeFile as writeFile40 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path62 from "path";
+import path63 from "path";
 import os6 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 var ENGRAM_HOOK_APIS = "__openclawEngramHookApis";
@@ -31570,7 +31863,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 : path62.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path63.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -31820,11 +32113,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 = path62.join(
+              const signalPath = path63.join(
                 workspaceDir,
                 `.compaction-reset-signal-${safeSessionKey}`
               );
-              await writeFile39(
+              await writeFile40(
                 signalPath,
                 JSON.stringify({
                   sessionKey,
@@ -31851,11 +32144,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 = path62.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path63.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
-          const content = await readFile38(cronFilePath, "utf-8");
+          const content = await readFile39(cronFilePath, "utf-8");
           jobsData = JSON.parse(content);
         } catch {
         }
@@ -31892,7 +32185,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile39(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile40(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);