@joshuaswarren/openclaw-engram 8.3.68 → 8.3.69

package/dist/index.js

@@ -10587,9 +10587,16 @@ function recencyWeight(frontmatter, nowMs) {
   return clamp01(1 - ageDays / 90);
 }
 function feedbackWeight(signals) {
-  const raw = signals?.feedbackScore ?? 0;
+  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
   return clamp01((raw + 1) / 2);
 }
+function boundedFeedbackScore(signals) {
+  const raw = (signals?.feedbackScore ?? 0) + (signals?.actionPriorScore ?? 0);
+  if (!Number.isFinite(raw)) return 0;
+  if (raw < -1) return -1;
+  if (raw > 1) return 1;
+  return raw;
+}
 function isProtectedMemory(frontmatter, policy) {
   return frontmatter.policyClass === "protected" || policy.protectedCategories.includes(frontmatter.category);
 }
@@ -10619,7 +10626,7 @@ function computeDecay(memory, now, signals) {
   const ageRisk = clamp01(ageDays / 180);
   const staleAccessRisk = clamp01(staleAccessDays / 120);
   const confidenceRisk = 1 - confidenceTierWeight(frontmatter);
-  const feedbackRisk = clamp01(((signals?.feedbackScore ?? 0) * -1 + 1) / 2);
+  const feedbackRisk = clamp01((boundedFeedbackScore(signals) * -1 + 1) / 2);
   const heat = computeHeat(memory, now, signals);
   const score = ageRisk * 0.3 + staleAccessRisk * 0.25 + confidenceRisk * 0.2 + feedbackRisk * 0.1 + (1 - heat) * 0.15;
   return clamp01(score);
@@ -11981,6 +11988,7 @@ var CompoundingEngine = class {
     this.identityAuditWeeklyDir = path23.join(config.memoryDir, "identity", "audits", "weekly");
     this.identityAuditMonthlyDir = path23.join(config.memoryDir, "identity", "audits", "monthly");
     this.identityImprovementLoopsPath = path23.join(config.memoryDir, "identity", "improvement-loops.md");
+    this.memoryActionEventsPath = path23.join(config.memoryDir, "state", "memory-actions.jsonl");
   }
   weeklyDir;
   mistakesPath;
@@ -11990,6 +11998,7 @@ var CompoundingEngine = class {
   identityAuditWeeklyDir;
   identityAuditMonthlyDir;
   identityImprovementLoopsPath;
+  memoryActionEventsPath;
   async ensureDirs() {
     await mkdir16(this.weeklyDir, { recursive: true });
     await mkdir16(path23.dirname(this.mistakesPath), { recursive: true });
@@ -11998,7 +12007,8 @@ var CompoundingEngine = class {
     await this.ensureDirs();
     const weekId = opts?.weekId ?? isoWeekId(/* @__PURE__ */ new Date());
     const entries = await this.readFeedbackEntriesForWeek(weekId);
-    const mistakes = this.buildMistakes(entries);
+    const actionPatterns = await this.readActionFailurePatternsForWeek(weekId);
+    const mistakes = this.buildMistakes(entries, actionPatterns);
     const continuity = this.config.continuityAuditEnabled ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
     const reportPath = path23.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, continuity);
@@ -12114,7 +12124,34 @@ var CompoundingEngine = class {
     }
     return out;
   }
-  buildMistakes(entries) {
+  async readActionFailurePatternsForWeek(weekId) {
+    const out = [];
+    try {
+      const raw = await readFile16(this.memoryActionEventsPath, "utf-8");
+      const lines = raw.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (typeof parsed.timestamp !== "string" || typeof parsed.action !== "string") continue;
+          const ts = new Date(parsed.timestamp);
+          if (!Number.isFinite(ts.getTime()) || isoWeekId(ts) !== weekId) continue;
+          const policy = parsed.policyDecision === "deny" || parsed.policyDecision === "defer" ? parsed.policyDecision : null;
+          const failed = parsed.outcome === "failed" || parsed.outcome === "skipped";
+          if (!failed && policy === null) continue;
+          const ns = typeof parsed.namespace === "string" && parsed.namespace.length > 0 ? parsed.namespace : "default";
+          const suffix = typeof parsed.reason === "string" && parsed.reason.trim().length > 0 ? ` - ${parsed.reason.trim().slice(0, 140)}` : "";
+          out.push(
+            `memory-action/${ns}: ${parsed.action} ${parsed.outcome ?? "unknown"}${policy ? `/${policy}` : ""}${suffix}`
+          );
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return out;
+  }
+  buildMistakes(entries, actionPatterns = []) {
     const patterns = [];
     for (const e of entries) {
       if (e.learning && e.learning.trim().length > 0) {
@@ -12125,6 +12162,7 @@ var CompoundingEngine = class {
         patterns.push(`${e.agent}: ${e.reason.trim()}`.slice(0, 240));
       }
     }
+    patterns.push(...actionPatterns);
     const uniq = Array.from(new Set(patterns)).slice(0, 500);
     return { updatedAt: (/* @__PURE__ */ new Date()).toISOString(), patterns: uniq };
   }
@@ -15591,6 +15629,58 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       return null;
     }
   }
+  actionOutcomePriorDelta(event) {
+    if (event.outcome === "failed") return -0.3;
+    if (event.policyDecision === "deny") return -0.22;
+    if (event.policyDecision === "defer") return -0.14;
+    if (event.outcome === "skipped") return -0.1;
+    if (event.outcome !== "applied") return 0;
+    switch (event.action) {
+      case "store_episode":
+      case "store_note":
+      case "update_note":
+        return 0.08;
+      case "create_artifact":
+      case "summarize_node":
+      case "link_graph":
+        return 0.04;
+      case "discard":
+        return -0.03;
+      default:
+        return 0;
+    }
+  }
+  async buildLifecycleActionPriors() {
+    const events = await this.storage.readMemoryActionEvents(1200);
+    if (events.length === 0) return /* @__PURE__ */ new Map();
+    const nowMs = Date.now();
+    const windowMs = 14 * 24 * 60 * 60 * 1e3;
+    const byMemory = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      if (typeof event.memoryId !== "string" || event.memoryId.trim().length === 0) continue;
+      const ts = Date.parse(event.timestamp);
+      if (!Number.isFinite(ts)) continue;
+      const ageMs = nowMs - ts;
+      if (ageMs < 0 || ageMs > windowMs) continue;
+      const delta = this.actionOutcomePriorDelta(event);
+      if (delta === 0) continue;
+      const recencyWeight2 = Math.max(0.2, 1 - ageMs / windowMs);
+      const list = byMemory.get(event.memoryId) ?? [];
+      if (list.length >= 8) list.shift();
+      list.push({ weightedDelta: delta * recencyWeight2, weight: recencyWeight2 });
+      byMemory.set(event.memoryId, list);
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (const [memoryId, deltas] of byMemory.entries()) {
+      if (deltas.length === 0) continue;
+      const weightedSum = deltas.reduce((sum, item) => sum + item.weightedDelta, 0);
+      const weightTotal = deltas.reduce((sum, item) => sum + item.weight, 0);
+      if (weightTotal <= 0) continue;
+      const score = weightedSum / weightTotal;
+      out.set(memoryId, Math.max(-0.25, Math.min(0.15, score)));
+    }
+    return out;
+  }
   async runLifecyclePolicyPass(allMemories) {
     const now = /* @__PURE__ */ new Date();
     const nowIso = now.toISOString();
@@ -15611,13 +15701,16 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
       archiveDecayThreshold: this.config.lifecycleArchiveDecayThreshold,
       protectedCategories: this.config.lifecycleProtectedCategories
     };
+    const actionPriors = await this.buildLifecycleActionPriors();
     for (const memory of allMemories) {
       if (memory.frontmatter.status === "superseded") {
         continue;
       }
       evaluatedCount += 1;
       const currentState = resolveLifecycleState(memory.frontmatter);
-      const decision = decideLifecycleTransition(memory, policy, now);
+      const actionPriorScore = actionPriors.get(memory.frontmatter.id);
+      const signals = typeof actionPriorScore === "number" && Number.isFinite(actionPriorScore) ? { actionPriorScore } : void 0;
+      const decision = decideLifecycleTransition(memory, policy, now, signals);
       const nextState = memory.frontmatter.status === "archived" ? "archived" : decision.nextState;
       countsByState[nextState] += 1;
       if (memory.frontmatter.verificationState === "disputed") {