@joshuaswarren/openclaw-engram 8.3.7 → 8.3.9

package/dist/index.js

@@ -322,6 +322,12 @@ function parseConfig(raw) {
       (c) => typeof c === "string" && VALID_MEMORY_CATEGORIES.has(c)
     ) : ["decision", "principle", "commitment", "preference"],
     lifecycleMetricsEnabled: typeof cfg.lifecycleMetricsEnabled === "boolean" ? cfg.lifecycleMetricsEnabled : cfg.lifecyclePolicyEnabled === true,
+    // v8.3 proactive + policy learning (default off)
+    proactiveExtractionEnabled: cfg.proactiveExtractionEnabled === true,
+    contextCompressionActionsEnabled: cfg.contextCompressionActionsEnabled === true,
+    compressionGuidelineLearningEnabled: cfg.compressionGuidelineLearningEnabled === true,
+    maxProactiveQuestionsPerExtraction: typeof cfg.maxProactiveQuestionsPerExtraction === "number" ? Math.max(0, Math.floor(cfg.maxProactiveQuestionsPerExtraction)) : 2,
+    maxCompressionTokensPerHour: typeof cfg.maxCompressionTokensPerHour === "number" ? Math.max(0, Math.floor(cfg.maxCompressionTokensPerHour)) : 1500,
     // v8.0 phase 1
     recallPlannerEnabled: cfg.recallPlannerEnabled !== false,
     recallPlannerMaxQmdResultsMinimal: typeof cfg.recallPlannerMaxQmdResultsMinimal === "number" ? cfg.recallPlannerMaxQmdResultsMinimal : 4,
@@ -3975,7 +3981,7 @@ ${stderr}`.trim();
 };
 
 // src/storage.ts
-import { readdir, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, unlink } from "fs/promises";
+import { readdir, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, unlink, appendFile } from "fs/promises";
 import { appendFileSync, mkdirSync as mkdirSync2, statSync } from "fs";
 import { createHash } from "crypto";
 import path4 from "path";
@@ -4535,6 +4541,12 @@ var StorageManager = class _StorageManager {
   get profilePath() {
     return path4.join(this.baseDir, "profile.md");
   }
+  get memoryActionsPath() {
+    return path4.join(this.stateDir, "memory-actions.jsonl");
+  }
+  get compressionGuidelinesPath() {
+    return path4.join(this.stateDir, "compression-guidelines.md");
+  }
   /**
    * Load user-defined entity aliases from config/aliases.json in the memory store.
    * File format: { "variant": "canonical", "variant2": "canonical", ... }
@@ -5086,6 +5098,55 @@ ${memory.content}
     const metaPath = path4.join(this.stateDir, "meta.json");
     await writeFile2(metaPath, JSON.stringify(state, null, 2), "utf-8");
   }
+  async appendMemoryActionEvents(events) {
+    if (events.length === 0) return 0;
+    await this.ensureDirectories();
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const payload = events.map((event) => {
+      const normalized = {
+        ...event,
+        timestamp: event.timestamp && event.timestamp.length > 0 ? event.timestamp : nowIso
+      };
+      return `${JSON.stringify(normalized)}
+`;
+    }).join("");
+    await appendFile(this.memoryActionsPath, payload, "utf-8");
+    return events.length;
+  }
+  async readMemoryActionEvents(limit = 200) {
+    const cappedLimit = Math.max(0, Math.floor(limit));
+    if (cappedLimit === 0) return [];
+    try {
+      const raw = await readFile2(this.memoryActionsPath, "utf-8");
+      const out = [];
+      const lines = raw.split("\n");
+      for (let i = lines.length - 1; i >= 0 && out.length < cappedLimit; i -= 1) {
+        const line = lines[i]?.trim();
+        if (!line) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (typeof parsed.timestamp === "string" && typeof parsed.action === "string" && typeof parsed.outcome === "string") {
+            out.push(parsed);
+          }
+        } catch {
+        }
+      }
+      return out.reverse();
+    } catch {
+      return [];
+    }
+  }
+  async writeCompressionGuidelines(content) {
+    await this.ensureDirectories();
+    await writeFile2(this.compressionGuidelinesPath, content, "utf-8");
+  }
+  async readCompressionGuidelines() {
+    try {
+      return await readFile2(this.compressionGuidelinesPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
   // ---------------------------------------------------------------------------
   // Question storage
   // ---------------------------------------------------------------------------
@@ -6275,7 +6336,7 @@ function extractTopics(memories, topN = 50) {
 }
 
 // src/transcript.ts
-import { appendFile, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir4, readdir as readdir3, readFile as readFile4, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
 import path6 from "path";
 var TranscriptManager = class _TranscriptManager {
   transcriptsDir;
@@ -6384,7 +6445,7 @@ var TranscriptManager = class _TranscriptManager {
     const channelDir = path6.join(this.toolUsageDir, dir);
     await mkdir4(channelDir, { recursive: true });
     const filePath = path6.join(channelDir, file);
-    await appendFile(filePath, JSON.stringify(entry) + "\n", "utf-8");
+    await appendFile2(filePath, JSON.stringify(entry) + "\n", "utf-8");
   }
   async readToolUse(sessionKey, startTime, endTime) {
     const { dir } = this.getToolUsagePath(sessionKey);
@@ -6439,7 +6500,7 @@ var TranscriptManager = class _TranscriptManager {
       const filePath = path6.join(channelDir, file);
       await mkdir4(channelDir, { recursive: true });
       const line = JSON.stringify(entry) + "\n";
-      await appendFile(filePath, line, "utf-8");
+      await appendFile2(filePath, line, "utf-8");
       log.debug(`appended transcript entry for ${entry.sessionKey}: ${entry.turnId}`);
     } catch (err) {
       log.error("failed to append transcript entry:", err);
@@ -7604,7 +7665,7 @@ var NegativeExampleStore = class {
 };
 
 // src/recall-state.ts
-import { appendFile as appendFile2, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir8, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
 import path10 from "path";
 import { createHash as createHash2 } from "crypto";
 var LastRecallStore = class {
@@ -7663,7 +7724,7 @@ var LastRecallStore = class {
     }
     try {
       await mkdir8(path10.dirname(this.impressionsPath), { recursive: true });
-      await appendFile2(this.impressionsPath, JSON.stringify(snapshot) + "\n", "utf-8");
+      await appendFile3(this.impressionsPath, JSON.stringify(snapshot) + "\n", "utf-8");
     } catch (err) {
       log.debug(`recall impressions append failed: ${err}`);
     }
@@ -9201,7 +9262,7 @@ function recencyWindowFromPrompt(prompt, nowMs = Date.now()) {
 }
 
 // src/graph.ts
-import { mkdir as mkdir12, appendFile as appendFile3, readFile as readFile13 } from "fs/promises";
+import { mkdir as mkdir12, appendFile as appendFile4, readFile as readFile13 } from "fs/promises";
 import * as path16 from "path";
 var CAUSAL_PHRASES = [
   "as a result",
@@ -9223,7 +9284,7 @@ async function ensureGraphsDir(memoryDir) {
 async function appendEdge(memoryDir, edge) {
   await ensureGraphsDir(memoryDir);
   const line = JSON.stringify(edge) + "\n";
-  await appendFile3(graphFilePath(memoryDir, edge.type), line, "utf8");
+  await appendFile4(graphFilePath(memoryDir, edge.type), line, "utf8");
 }
 async function readEdges(memoryDir, type) {
   const filePath = graphFilePath(memoryDir, type);
@@ -9587,7 +9648,7 @@ function recallNamespacesForPrincipal(principal, config) {
 }
 
 // src/shared-context/manager.ts
-import { mkdir as mkdir14, readFile as readFile14, readdir as readdir9, appendFile as appendFile4, writeFile as writeFile13, stat as stat2 } from "fs/promises";
+import { mkdir as mkdir14, readFile as readFile14, readdir as readdir9, appendFile as appendFile5, writeFile as writeFile13, stat as stat2 } from "fs/promises";
 import path20 from "path";
 import os3 from "os";
 import { z as z3 } from "zod";
@@ -9709,7 +9770,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
   }
   async appendFeedback(entry) {
     const parsed = SharedFeedbackEntrySchema.parse(entry);
-    await appendFile4(this.feedbackInboxPath, JSON.stringify(parsed) + "\n", "utf-8");
+    await appendFile5(this.feedbackInboxPath, JSON.stringify(parsed) + "\n", "utf-8");
   }
   async appendPrioritiesInbox(opts) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -9720,7 +9781,7 @@ title: ${opts.title.replace(/\n/g, " ").slice(0, 200)}
       opts.text.trimEnd(),
       ""
     ].join("\n");
-    await appendFile4(this.prioritiesInboxPath, lines, "utf-8");
+    await appendFile5(this.prioritiesInboxPath, lines, "utf-8");
   }
   async curateDaily(opts) {
     const date = opts.date ?? ymd(/* @__PURE__ */ new Date());
@@ -9937,6 +9998,42 @@ function filterRecallCandidates(candidates, options) {
   const scopedByNamespace = options.namespacesEnabled ? candidates.filter((r) => options.recallNamespaces.includes(options.resolveNamespace(r.path))) : candidates;
   return scopedByNamespace.filter((r) => !isArtifactMemoryPath(r.path)).slice(0, Math.max(0, options.limit));
 }
+function hasLifecycleMetadata(frontmatter) {
+  return frontmatter.lifecycleState !== void 0 || frontmatter.verificationState !== void 0 || frontmatter.policyClass !== void 0 || frontmatter.lastValidatedAt !== void 0 || frontmatter.decayScore !== void 0 || frontmatter.heatScore !== void 0;
+}
+function shouldFilterLifecycleRecallCandidate(frontmatter, options) {
+  if (!options.lifecyclePolicyEnabled || !options.lifecycleFilterStaleEnabled) return false;
+  if (!hasLifecycleMetadata(frontmatter)) return false;
+  const lifecycleState = resolveLifecycleState(frontmatter);
+  return lifecycleState === "stale" || lifecycleState === "archived";
+}
+function lifecycleRecallScoreAdjustment(frontmatter, options) {
+  if (!options.lifecyclePolicyEnabled) return 0;
+  if (!hasLifecycleMetadata(frontmatter)) return 0;
+  let delta = 0;
+  const lifecycleState = resolveLifecycleState(frontmatter);
+  switch (lifecycleState) {
+    case "active":
+      delta += 0.05;
+      break;
+    case "validated":
+      delta += 0.03;
+      break;
+    case "candidate":
+      delta -= 0.01;
+      break;
+    case "stale":
+      delta -= 0.06;
+      break;
+    case "archived":
+      delta -= 0.08;
+      break;
+  }
+  if (frontmatter.verificationState === "disputed") {
+    delta -= 0.12;
+  }
+  return delta;
+}
 function computeArtifactRecallLimit(recallMode, recallResultLimit, verbatimArtifactsMaxRecall) {
   if (recallMode === "no_recall") return 0;
   if (Math.max(0, recallResultLimit) === 0) return 0;
@@ -12402,10 +12499,19 @@ ${lines.join("\n\n")}`;
         tagCandidates = capSet(rawTags);
       }
     }
-    const boosted = results.map((r) => {
+    let lifecycleFilteredCount = 0;
+    const boosted = [];
+    for (const r of results) {
       const memory = memoryByPath.get(r.path);
       let score = r.score;
       if (memory) {
+        if (shouldFilterLifecycleRecallCandidate(memory.frontmatter, {
+          lifecyclePolicyEnabled: this.config.lifecyclePolicyEnabled,
+          lifecycleFilterStaleEnabled: this.config.lifecycleFilterStaleEnabled
+        })) {
+          lifecycleFilteredCount += 1;
+          continue;
+        }
         if (this.config.recencyWeight > 0) {
           const createdAt = new Date(memory.frontmatter.created).getTime();
           const ageMs = now - createdAt;
@@ -12456,9 +12562,15 @@ ${lines.join("\n\n")}`;
             score += 0.06;
           }
         }
+        score += lifecycleRecallScoreAdjustment(memory.frontmatter, {
+          lifecyclePolicyEnabled: this.config.lifecyclePolicyEnabled
+        });
       }
-      return { ...r, score };
-    });
+      boosted.push({ ...r, score });
+    }
+    if (lifecycleFilteredCount > 0) {
+      log.debug(`lifecycle retrieval filter removed ${lifecycleFilteredCount} stale/archived candidates`);
+    }
     return boosted.sort((a, b) => b.score - a.score);
   }
   /**