@joshuaswarren/openclaw-engram 9.0.47 → 9.0.48

package/README.md

@@ -47,6 +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.
 - **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
@@ -183,6 +184,8 @@ openclaw engram commitment-lifecycle-run  # Expire overdue commitments and clean
 openclaw engram work-product-status         # Work-product ledger counts and latest recorded output
 openclaw engram work-product-record         # Record a typed work-product ledger entry
 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 conversation-index-health    # Conversation index status
 openclaw engram graph-health                 # Entity graph status
 openclaw engram tier-status                  # Hot/cold tier metrics
@@ -225,6 +228,8 @@ Key settings:
 | `semanticRulePromotionEnabled` | `false` | Enable deterministic promotion of explicit `IF ... THEN ...` rules from verified episodic memories via `openclaw engram semantic-rule-promote` |
 | `semanticRuleVerificationEnabled` | `false` | Verify promoted semantic rules against their cited source episodes at recall time and inject a dedicated `Verified Rules` section via `openclaw engram semantic-rule-verify` |
 | `creationMemoryEnabled` | `false` | Enable the creation-memory foundation, including the work-product ledger and operator-facing write/status commands |
+| `memoryUtilityLearningEnabled` | `false` | Enable typed utility-learning telemetry storage for future promotion/ranking learners |
+| `promotionByOutcomeEnabled` | `false` | Reserve outcome-aware promotion controls that later slices will drive from learned utility signals |
 | `commitmentLedgerEnabled` | `false` | Enable the explicit commitment ledger for promises, follow-ups, deadlines, and unfinished obligations |
 | `commitmentLifecycleEnabled` | `false` | Enable commitment lifecycle transitions, stale tracking, and resolved-entry cleanup for the commitment ledger |
 | `commitmentStaleDays` | `14` | Days before an open commitment without a due date is considered stale in lifecycle status |

package/dist/index.js

@@ -308,6 +308,8 @@ function parseConfig(raw) {
     semanticRulePromotionEnabled: cfg.semanticRulePromotionEnabled === true,
     semanticRuleVerificationEnabled: cfg.semanticRuleVerificationEnabled === true,
     creationMemoryEnabled: cfg.creationMemoryEnabled === true,
+    memoryUtilityLearningEnabled: cfg.memoryUtilityLearningEnabled === true,
+    promotionByOutcomeEnabled: cfg.promotionByOutcomeEnabled === true,
     commitmentLedgerEnabled: cfg.commitmentLedgerEnabled === true,
     commitmentLifecycleEnabled: cfg.commitmentLifecycleEnabled === true,
     commitmentStaleDays: typeof cfg.commitmentStaleDays === "number" ? cfg.commitmentStaleDays : 14,
@@ -25309,7 +25311,7 @@ promotionCandidates: ${res.promotionCandidateCount}`
 }
 
 // src/cli.ts
-import path60 from "path";
+import path61 from "path";
 import { access as access3, readFile as readFile37, readdir as readdir24, unlink as unlink8 } from "fs/promises";
 import { createHash as createHash10 } from "crypto";
 
@@ -26190,8 +26192,8 @@ function gatherCandidates(input, warnings) {
       const record = rec;
       const content = typeof record.content === "string" ? record.content : null;
       if (!content) continue;
-      const path62 = typeof record.path === "string" ? record.path : "";
-      if (!path62.startsWith("transcripts/") && !path62.includes("/transcripts/")) continue;
+      const path63 = typeof record.path === "string" ? record.path : "";
+      if (!path63.startsWith("transcripts/") && !path63.includes("/transcripts/")) continue;
       rows.push(...parseJsonl(content, warnings));
     }
     return rows;
@@ -27825,15 +27827,147 @@ async function runCompatChecks(options) {
   };
 }
 
-// src/resume-bundles.ts
+// src/utility-telemetry.ts
 import path59 from "path";
 import { mkdir as mkdir40, writeFile as writeFile37 } from "fs/promises";
+function resolveUtilityTelemetryDir(memoryDir, overrideDir) {
+  if (typeof overrideDir === "string" && overrideDir.trim().length > 0) {
+    return overrideDir.trim();
+  }
+  return path59.join(memoryDir, "state", "utility-telemetry");
+}
+function assertUtilityScore(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error("utilityScore must be a finite number");
+  }
+  if (value < -1 || value > 1) {
+    throw new Error("utilityScore must be between -1 and 1");
+  }
+  return value;
+}
+function validateUtilityTelemetryEvent(raw) {
+  if (!isRecord2(raw)) throw new Error("utility telemetry event must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("schemaVersion must be 1");
+  const source = assertString2(raw.source, "source");
+  if (!["cli", "system", "benchmark", "tool_result"].includes(source)) {
+    throw new Error("source must be one of cli|system|benchmark|tool_result");
+  }
+  const target = assertString2(raw.target, "target");
+  if (!["promotion", "ranking"].includes(target)) {
+    throw new Error("target must be one of promotion|ranking");
+  }
+  const decision = assertString2(raw.decision, "decision");
+  if (!["promote", "demote", "hold", "boost", "suppress"].includes(decision)) {
+    throw new Error("decision must be one of promote|demote|hold|boost|suppress");
+  }
+  const outcome = assertString2(raw.outcome, "outcome");
+  if (!["helpful", "neutral", "harmful"].includes(outcome)) {
+    throw new Error("outcome must be one of helpful|neutral|harmful");
+  }
+  return {
+    schemaVersion: 1,
+    eventId: assertSafePathSegment(assertString2(raw.eventId, "eventId"), "eventId"),
+    recordedAt: assertIsoRecordedAt(assertString2(raw.recordedAt, "recordedAt")),
+    sessionKey: assertString2(raw.sessionKey, "sessionKey"),
+    source,
+    target,
+    decision,
+    outcome,
+    utilityScore: assertUtilityScore(raw.utilityScore),
+    summary: assertString2(raw.summary, "summary"),
+    memoryIds: optionalStringArray2(raw.memoryIds, "memoryIds"),
+    entityRefs: optionalStringArray2(raw.entityRefs, "entityRefs"),
+    tags: optionalStringArray2(raw.tags, "tags"),
+    metadata: validateStringRecord(raw.metadata, "metadata")
+  };
+}
+async function recordUtilityTelemetryEvent(options) {
+  const rootDir = resolveUtilityTelemetryDir(options.memoryDir, options.utilityTelemetryDir);
+  const validated = validateUtilityTelemetryEvent(options.event);
+  const day = recordStoreDay(validated.recordedAt);
+  const eventsDir = path59.join(rootDir, "events", day);
+  const filePath = path59.join(eventsDir, `${validated.eventId}.json`);
+  await mkdir40(eventsDir, { recursive: true });
+  await writeFile37(filePath, JSON.stringify(validated, null, 2), "utf8");
+  return filePath;
+}
+async function readUtilityTelemetryEvents(options) {
+  const rootDir = resolveUtilityTelemetryDir(options.memoryDir, options.utilityTelemetryDir);
+  const files = await listJsonFiles(path59.join(rootDir, "events"));
+  const events = [];
+  const invalidEvents = [];
+  for (const filePath of files) {
+    try {
+      events.push(validateUtilityTelemetryEvent(await readJsonFile(filePath)));
+    } catch (error) {
+      invalidEvents.push({
+        path: filePath,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return { files, events, invalidEvents };
+}
+async function getUtilityTelemetryStatus(options) {
+  const rootDir = resolveUtilityTelemetryDir(options.memoryDir, options.utilityTelemetryDir);
+  const eventsDir = path59.join(rootDir, "events");
+  if (!options.enabled) {
+    return {
+      enabled: false,
+      promotionByOutcomeEnabled: options.promotionByOutcomeEnabled === true,
+      rootDir,
+      eventsDir,
+      events: {
+        total: 0,
+        valid: 0,
+        invalid: 0,
+        byTarget: {},
+        byDecision: {},
+        byOutcome: {}
+      },
+      invalidEvents: []
+    };
+  }
+  const { files, events, invalidEvents } = await readUtilityTelemetryEvents(options);
+  events.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));
+  const byTarget = {};
+  const byDecision = {};
+  const byOutcome = {};
+  for (const event of events) {
+    byTarget[event.target] = (byTarget[event.target] ?? 0) + 1;
+    byDecision[event.decision] = (byDecision[event.decision] ?? 0) + 1;
+    byOutcome[event.outcome] = (byOutcome[event.outcome] ?? 0) + 1;
+  }
+  return {
+    enabled: true,
+    promotionByOutcomeEnabled: options.promotionByOutcomeEnabled === true,
+    rootDir,
+    eventsDir,
+    events: {
+      total: files.length,
+      valid: events.length,
+      invalid: invalidEvents.length,
+      byTarget,
+      byDecision,
+      byOutcome,
+      latestEventId: events[0]?.eventId,
+      latestRecordedAt: events[0]?.recordedAt,
+      latestSessionKey: events[0]?.sessionKey
+    },
+    latestEvent: events[0],
+    invalidEvents
+  };
+}
+
+// src/resume-bundles.ts
+import path60 from "path";
+import { mkdir as mkdir41, writeFile as writeFile38 } 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 path59.join(memoryDir, "state", "resume-bundles");
+  return path60.join(memoryDir, "state", "resume-bundles");
 }
 function validateResumeBundle(raw) {
   if (!isRecord2(raw)) throw new Error("resume bundle must be an object");
@@ -27877,7 +28011,7 @@ async function readValidatedItems(options) {
 async function readObjectiveStateSnapshotsForSession(options) {
   const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);
   const items = await readValidatedItems({
-    rootDir: path59.join(rootDir, "snapshots"),
+    rootDir: path60.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);
@@ -27885,7 +28019,7 @@ async function readObjectiveStateSnapshotsForSession(options) {
 async function readWorkProductEntriesForSession(options) {
   const rootDir = resolveWorkProductLedgerDir(options.memoryDir, options.workProductLedgerDir);
   const items = await readValidatedItems({
-    rootDir: path59.join(rootDir, "entries"),
+    rootDir: path60.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);
@@ -27893,7 +28027,7 @@ async function readWorkProductEntriesForSession(options) {
 async function readCommitmentEntriesForSession(options) {
   const rootDir = resolveCommitmentLedgerDir(options.memoryDir, options.commitmentLedgerDir);
   const items = await readValidatedItems({
-    rootDir: path59.join(rootDir, "entries"),
+    rootDir: path60.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);
@@ -27989,15 +28123,15 @@ async function recordResumeBundle(options) {
   const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
   const validated = validateResumeBundle(options.bundle);
   const day = recordStoreDay(validated.recordedAt);
-  const bundlesDir = path59.join(rootDir, "bundles", day);
-  const filePath = path59.join(bundlesDir, `${validated.bundleId}.json`);
-  await mkdir40(bundlesDir, { recursive: true });
-  await writeFile37(filePath, JSON.stringify(validated, null, 2), "utf8");
+  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");
   return filePath;
 }
 async function readResumeBundles(options) {
   const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
-  const files = await listJsonFiles(path59.join(rootDir, "bundles"));
+  const files = await listJsonFiles(path60.join(rootDir, "bundles"));
   const bundles = [];
   const invalidBundles = [];
   for (const filePath of files) {
@@ -28014,7 +28148,7 @@ async function readResumeBundles(options) {
 }
 async function getResumeBundleStatus(options) {
   const rootDir = resolveResumeBundleDir(options.memoryDir, options.resumeBundleDir);
-  const bundlesDir = path59.join(rootDir, "bundles");
+  const bundlesDir = path60.join(rootDir, "bundles");
   if (!options.enabled) {
     return {
       enabled: false,
@@ -28444,6 +28578,20 @@ async function runWorkProductStatusCliCommand(options) {
     enabled: options.creationMemoryEnabled
   });
 }
+async function runUtilityTelemetryStatusCliCommand(options) {
+  return getUtilityTelemetryStatus({
+    memoryDir: options.memoryDir,
+    enabled: options.memoryUtilityLearningEnabled,
+    promotionByOutcomeEnabled: options.promotionByOutcomeEnabled
+  });
+}
+async function runUtilityTelemetryRecordCliCommand(options) {
+  if (!options.memoryUtilityLearningEnabled) return null;
+  return recordUtilityTelemetryEvent({
+    memoryDir: options.memoryDir,
+    event: options.event
+  });
+}
 async function runWorkProductRecordCliCommand(options) {
   if (!options.creationMemoryEnabled) return null;
   return recordWorkProductLedgerEntry({
@@ -28791,7 +28939,7 @@ function policyVersionForValues(values, config) {
   return createHash10("sha256").update(JSON.stringify(normalized)).digest("hex").slice(0, 12);
 }
 async function readRuntimePolicySnapshot2(config, fileName) {
-  const filePath = path60.join(config.memoryDir, "state", fileName);
+  const filePath = path61.join(config.memoryDir, "state", fileName);
   const snapshot = await readRuntimePolicySnapshot(filePath, {
     maxStaleDecayThreshold: config.lifecycleArchiveDecayThreshold
   });
@@ -29375,14 +29523,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 = path60.join(orchestrator.config.memoryDir, "namespaces", ns);
+  const candidate = path61.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 = [path60.join(memoryDir, "facts"), path60.join(memoryDir, "corrections")];
+  const roots = [path61.join(memoryDir, "facts"), path61.join(memoryDir, "corrections")];
   const out = [];
   const walk = async (dir) => {
     let entries;
@@ -29393,7 +29541,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 = path60.join(dir, entryName);
+      const fullPath = path61.join(dir, entryName);
       if (entry.isDirectory()) {
         await walk(fullPath);
         continue;
@@ -29772,6 +29920,40 @@ function registerCli(api, orchestrator) {
         console.log(JSON.stringify(results, null, 2));
         console.log("OK");
       });
+      cmd.command("utility-status").description("Show utility-learning telemetry status, event counts, and the latest utility event").action(async () => {
+        const status = await runUtilityTelemetryStatusCliCommand({
+          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-record").description("Record a utility-learning telemetry event when utility learning is enabled").requiredOption("--event-id <eventId>", "Utility telemetry event id").requiredOption("--recorded-at <recordedAt>", "ISO timestamp for the event").requiredOption("--session-key <sessionKey>", "Session key associated with the event").requiredOption("--source <source>", "Event source (cli|system|benchmark|tool_result)").requiredOption("--target <target>", "Telemetry target (promotion|ranking)").requiredOption("--decision <decision>", "Decision taken (promote|demote|hold|boost|suppress)").requiredOption("--outcome <outcome>", "Observed outcome (helpful|neutral|harmful)").requiredOption("--utility-score <utilityScore>", "Bounded utility score between -1 and 1").requiredOption("--summary <summary>", "Human-readable summary of the measured utility event").option("--memory-id <memoryId...>", "Memory ids linked to the utility event").option("--entity-ref <entityRef...>", "Entity refs linked to the utility event").option("--tag <tag...>", "Tags to attach to the utility event").action(async (...args) => {
+        const options = args[0] ?? {};
+        const utilityScore = typeof options.utilityScore === "string" ? Number.parseFloat(options.utilityScore) : Number.NaN;
+        const filePath = await runUtilityTelemetryRecordCliCommand({
+          memoryDir: orchestrator.config.memoryDir,
+          memoryUtilityLearningEnabled: orchestrator.config.memoryUtilityLearningEnabled,
+          event: {
+            schemaVersion: 1,
+            eventId: String(options.eventId ?? ""),
+            recordedAt: String(options.recordedAt ?? ""),
+            sessionKey: String(options.sessionKey ?? ""),
+            source: String(options.source ?? ""),
+            target: String(options.target ?? ""),
+            decision: String(options.decision ?? ""),
+            outcome: String(options.outcome ?? ""),
+            utilityScore,
+            summary: String(options.summary ?? ""),
+            memoryIds: Array.isArray(options.memoryId) ? options.memoryId.map(String) : void 0,
+            entityRefs: Array.isArray(options.entityRef) ? options.entityRef.map(String) : void 0,
+            tags: Array.isArray(options.tag) ? options.tag.map(String) : void 0
+          }
+        });
+        console.log(JSON.stringify({ wrote: filePath !== null, filePath }, 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,
@@ -30678,7 +30860,7 @@ function registerCli(api, orchestrator) {
         }
       });
       cmd.command("identity").description("Show agent identity reflections").action(async () => {
-        const workspaceDir = path60.join(process.env.HOME ?? "~", ".openclaw", "workspace");
+        const workspaceDir = path61.join(process.env.HOME ?? "~", ".openclaw", "workspace");
         const identity = await orchestrator.storage.readIdentity(workspaceDir);
         if (!identity) {
           console.log("No identity file found.");
@@ -30901,8 +31083,8 @@ function registerCli(api, orchestrator) {
         const options = args[0] ?? {};
         const threadId = options.thread;
         const top = parseInt(options.top ?? "10", 10);
-        const memoryDir = path60.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
-        const threading = new ThreadingManager(path60.join(memoryDir, "threads"));
+        const memoryDir = path61.join(process.env.HOME ?? "~", ".openclaw", "workspace", "memory", "local");
+        const threading = new ThreadingManager(path61.join(memoryDir, "threads"));
         if (threadId) {
           const thread = await threading.loadThread(threadId);
           if (!thread) {
@@ -31378,9 +31560,9 @@ async function recordObjectiveStateSnapshotsFromAgentMessages(options) {
 }
 
 // src/index.ts
-import { readFile as readFile38, writeFile as writeFile38 } from "fs/promises";
+import { readFile as readFile38, writeFile as writeFile39 } from "fs/promises";
 import { readFileSync as readFileSync4 } from "fs";
-import path61 from "path";
+import path62 from "path";
 import os6 from "os";
 var ENGRAM_REGISTERED_GUARD = "__openclawEngramRegistered";
 var ENGRAM_HOOK_APIS = "__openclawEngramHookApis";
@@ -31388,7 +31570,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 : path61.join(homeDir, ".openclaw", "openclaw.json");
+    const configPath = explicitConfigPath && explicitConfigPath.length > 0 ? explicitConfigPath : path62.join(homeDir, ".openclaw", "openclaw.json");
     const content = readFileSync4(configPath, "utf-8");
     const config = JSON.parse(content);
     const pluginEntry = config?.plugins?.entries?.["openclaw-engram"];
@@ -31638,11 +31820,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 = path61.join(
+              const signalPath = path62.join(
                 workspaceDir,
                 `.compaction-reset-signal-${safeSessionKey}`
               );
-              await writeFile38(
+              await writeFile39(
                 signalPath,
                 JSON.stringify({
                   sessionKey,
@@ -31669,7 +31851,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 = path61.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
+      const cronFilePath = path62.join(os6.homedir(), ".openclaw", "cron", "jobs.json");
       try {
         let jobsData = { version: 1, jobs: [] };
         try {
@@ -31710,7 +31892,7 @@ Use this context naturally when relevant. Never quote or expose this memory cont
           state: {}
         };
         jobsData.jobs.push(newJob);
-        await writeFile38(cronFilePath, JSON.stringify(jobsData, null, 2), "utf-8");
+        await writeFile39(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);