@joshuaswarren/openclaw-engram 8.3.65 → 8.3.67

package/dist/index.js

@@ -1604,6 +1604,31 @@ var FallbackLlmClient = class {
 
 // src/schemas.ts
 import { z } from "zod";
+var MemoryActionTypeSchema = z.enum([
+  "store_episode",
+  "store_note",
+  "update_note",
+  "create_artifact",
+  "summarize_node",
+  "discard",
+  "link_graph"
+]);
+var MemoryActionEligibilityContextSchema = z.object({
+  confidence: z.number().min(0).max(1),
+  lifecycleState: z.enum(["active", "validated", "candidate", "stale", "archived"]),
+  importance: z.number().min(0).max(1),
+  source: z.enum(["extraction", "consolidation", "replay", "manual", "unknown"])
+}).strict();
+function parseMemoryActionEligibilityContext(value) {
+  const parsed = MemoryActionEligibilityContextSchema.safeParse(value);
+  if (parsed.success) return parsed.data;
+  return {
+    confidence: 0,
+    lifecycleState: "candidate",
+    importance: 0,
+    source: "unknown"
+  };
+}
 var ExtractedFactSchema = z.object({
   category: z.enum(["fact", "preference", "correction", "entity", "decision", "relationship", "principle", "commitment", "moment", "skill"]),
   content: z.string().describe("The memory content \u2014 a clear, standalone statement"),
@@ -9492,6 +9517,59 @@ function buildRecallQueryPolicy(prompt, sessionKey, cfg) {
   };
 }
 
+// src/memory-action-policy.ts
+var HIGH_IMPORTANCE_DISCARD_THRESHOLD = 0.8;
+var LOW_CONFIDENCE_DEFER_THRESHOLD = 0.35;
+function evaluateMemoryActionPolicy(input) {
+  const { action, eligibility, options } = input;
+  if (!options.actionsEnabled) {
+    return {
+      action,
+      decision: "deny",
+      rationale: "contextCompressionActionsEnabled=false",
+      eligibility
+    };
+  }
+  if (options.maxCompressionTokensPerHour === 0 && action === "summarize_node") {
+    return {
+      action,
+      decision: "defer",
+      rationale: "maxCompressionTokensPerHour=0",
+      eligibility
+    };
+  }
+  if (action === "discard" && eligibility.importance >= HIGH_IMPORTANCE_DISCARD_THRESHOLD) {
+    return {
+      action,
+      decision: "deny",
+      rationale: "importance_too_high_for_discard",
+      eligibility
+    };
+  }
+  if ((eligibility.lifecycleState === "archived" || eligibility.lifecycleState === "stale") && (action === "update_note" || action === "create_artifact" || action === "link_graph")) {
+    return {
+      action,
+      decision: "deny",
+      rationale: `lifecycle_state_${eligibility.lifecycleState}_restricted`,
+      eligibility
+    };
+  }
+  if (eligibility.source !== "unknown" && eligibility.confidence < LOW_CONFIDENCE_DEFER_THRESHOLD && action !== "discard") {
+    return {
+      action,
+      decision: "defer",
+      rationale: "confidence_below_threshold",
+      eligibility
+    };
+  }
+  return {
+    action,
+    decision: "allow",
+    rationale: "eligible",
+    eligibility
+  };
+}
+
 // src/compression-optimizer.ts
 var MAX_DELTA = 0.15;
 var SPARSE_SAMPLE = 5;
@@ -13189,10 +13267,28 @@ var Orchestrator = class _Orchestrator {
     const namespace = typeof event.namespace === "string" && event.namespace.length > 0 ? event.namespace : this.config.defaultNamespace;
     try {
       const storage = await this.getStorage(namespace);
+      const eligibility = parseMemoryActionEligibilityContext(event.policyEligibility);
+      const policy = evaluateMemoryActionPolicy({
+        action: event.action,
+        eligibility,
+        options: {
+          actionsEnabled: this.config.contextCompressionActionsEnabled,
+          maxCompressionTokensPerHour: this.config.maxCompressionTokensPerHour
+        }
+      });
+      const normalizedOutcome = policy.decision === "allow" ? event.outcome : event.outcome === "failed" ? "failed" : "skipped";
+      const reasonParts = [event.reason, `policy:${policy.decision}`, policy.rationale].filter(
+        (part) => typeof part === "string" && part.length > 0
+      );
       const toWrite = {
         ...event,
+        outcome: normalizedOutcome,
+        reason: reasonParts.join(" | "),
         namespace,
-        timestamp: typeof event.timestamp === "string" && event.timestamp.length > 0 ? event.timestamp : (/* @__PURE__ */ new Date()).toISOString()
+        timestamp: typeof event.timestamp === "string" && event.timestamp.length > 0 ? event.timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+        policyDecision: policy.decision,
+        policyRationale: policy.rationale,
+        policyEligibility: eligibility
       };
       await storage.appendMemoryActionEvents([toWrite]);
       return true;