@joshuaswarren/openclaw-engram 8.3.10 → 8.3.11

package/dist/index.js

@@ -10670,6 +10670,22 @@ var Orchestrator = class _Orchestrator {
     const ns = namespace && namespace.length > 0 ? namespace : this.config.defaultNamespace;
     return this.storageRouter.storageFor(ns);
   }
+  async appendMemoryActionEvent(event) {
+    const namespace = typeof event.namespace === "string" && event.namespace.length > 0 ? event.namespace : this.config.defaultNamespace;
+    try {
+      const storage = await this.getStorage(namespace);
+      const toWrite = {
+        ...event,
+        namespace,
+        timestamp: typeof event.timestamp === "string" && event.timestamp.length > 0 ? event.timestamp : (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await storage.appendMemoryActionEvents([toWrite]);
+      return true;
+    } catch (err) {
+      log.warn(`appendMemoryActionEvent failed (non-fatal): ${err}`);
+      return false;
+    }
+  }
   async getLastGraphRecallSnapshot(namespace) {
     const storage = await this.getStorage(namespace);
     const snapshotPath = path22.join(storage.dir, "state", "last_graph_recall.json");
@@ -12868,11 +12884,25 @@ ${lines.join("\n\n")}`;
 
 // src/tools.ts
 import path23 from "path";
+import { createHash as createHash5 } from "crypto";
 import { Type } from "@sinclair/typebox";
 function toolResult(text) {
   return { content: [{ type: "text", text }], details: void 0 };
 }
 function registerTools(api, orchestrator) {
+  const actionTypes = [
+    "store_episode",
+    "store_note",
+    "update_note",
+    "create_artifact",
+    "summarize_node",
+    "discard",
+    "link_graph"
+  ];
+  function promptHashForTelemetry(input) {
+    if (typeof input !== "string" || input.trim().length === 0) return void 0;
+    return createHash5("sha256").update(input).digest("hex").slice(0, 16);
+  }
   function namespaceFromPath(p) {
     const m = p.match(/[\\/]+namespaces[\\/]+([^\\/]+)[\\/]+/);
     return m && m[1] ? m[1] : orchestrator.config.defaultNamespace;
@@ -13114,6 +13144,112 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
     },
     { name: "memory_feedback_last_recall" }
   );
+  api.registerTool(
+    {
+      name: "context_checkpoint",
+      label: "Context Checkpoint",
+      description: "Record a context-compression checkpoint event for policy-learning telemetry (v8.3).",
+      parameters: Type.Object({
+        summary: Type.String({
+          description: "Short summary of what was checkpointed."
+        }),
+        sourcePrompt: Type.Optional(
+          Type.String({
+            description: "Optional source prompt text used for hashing in telemetry."
+          })
+        ),
+        namespace: Type.Optional(
+          Type.String({
+            description: "Optional namespace. Defaults to defaultNamespace."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.contextCompressionActionsEnabled) {
+          return toolResult(
+            "Context compression actions are disabled. Enable `contextCompressionActionsEnabled: true` to use this tool."
+          );
+        }
+        const { summary, sourcePrompt, namespace } = params;
+        const ns = typeof namespace === "string" && namespace.length > 0 ? namespace : orchestrator.config.defaultNamespace;
+        const wrote = await orchestrator.appendMemoryActionEvent({
+          action: "summarize_node",
+          outcome: "applied",
+          namespace: ns,
+          reason: `context_checkpoint:${summary.slice(0, 200)}`,
+          promptHash: promptHashForTelemetry(sourcePrompt)
+        });
+        if (!wrote) {
+          return toolResult("Checkpoint recorded best-effort failed (fail-open).");
+        }
+        return toolResult(`Recorded context checkpoint telemetry in namespace=${ns}.`);
+      }
+    },
+    { name: "context_checkpoint" }
+  );
+  api.registerTool(
+    {
+      name: "memory_action_apply",
+      label: "Apply Memory Action",
+      description: "Record a memory-action application event for policy-learning telemetry (v8.3).",
+      parameters: Type.Object({
+        action: Type.String({
+          enum: actionTypes,
+          description: "Memory action type."
+        }),
+        outcome: Type.Optional(
+          Type.String({
+            enum: ["applied", "skipped", "failed"],
+            description: "Outcome status (default: applied)."
+          })
+        ),
+        reason: Type.Optional(
+          Type.String({
+            description: "Optional reason/notes for this action outcome."
+          })
+        ),
+        memoryId: Type.Optional(
+          Type.String({
+            description: "Optional memory ID targeted by this action."
+          })
+        ),
+        sourcePrompt: Type.Optional(
+          Type.String({
+            description: "Optional source prompt text used for hashing in telemetry."
+          })
+        ),
+        namespace: Type.Optional(
+          Type.String({
+            description: "Optional namespace. Defaults to defaultNamespace."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        if (!orchestrator.config.contextCompressionActionsEnabled) {
+          return toolResult(
+            "Context compression actions are disabled. Enable `contextCompressionActionsEnabled: true` to use this tool."
+          );
+        }
+        const { action, outcome, reason, memoryId, sourcePrompt, namespace } = params;
+        const ns = typeof namespace === "string" && namespace.length > 0 ? namespace : orchestrator.config.defaultNamespace;
+        const wrote = await orchestrator.appendMemoryActionEvent({
+          action,
+          outcome: outcome ?? "applied",
+          namespace: ns,
+          reason,
+          memoryId,
+          promptHash: promptHashForTelemetry(sourcePrompt)
+        });
+        if (!wrote) {
+          return toolResult("Memory action telemetry write failed (fail-open).");
+        }
+        return toolResult(
+          `Recorded memory action telemetry: action=${action}, outcome=${outcome ?? "applied"}, namespace=${ns}.`
+        );
+      }
+    },
+    { name: "memory_action_apply" }
+  );
   api.registerTool(
     {
       name: "memory_store",
@@ -13648,17 +13784,17 @@ var EXPORT_FORMAT = "openclaw-engram-export";
 var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir17, readdir as readdir10, readFile as readFile17, stat as stat3, writeFile as writeFile16 } from "fs/promises";
 import path24 from "path";
 async function sha256File(filePath) {
   const buf = await readFile17(filePath);
-  const sha256 = createHash5("sha256").update(buf).digest("hex");
+  const sha256 = createHash6("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
 function sha256String(content) {
   const buf = Buffer.from(content, "utf-8");
-  const sha256 = createHash5("sha256").update(buf).digest("hex");
+  const sha256 = createHash6("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {