@joshuaswarren/openclaw-engram 9.0.59 → 9.0.61

package/dist/{chunk-CWVXHH36.js → chunk-QKD7TZY2.js}

@@ -1670,9 +1670,15 @@ var StorageManager = class _StorageManager {
   get compressionGuidelinesPath() {
     return path4.join(this.stateDir, "compression-guidelines.md");
   }
+  get compressionGuidelineDraftPath() {
+    return path4.join(this.stateDir, "compression-guidelines.draft.md");
+  }
   get compressionGuidelineStatePath() {
     return path4.join(this.stateDir, "compression-guideline-state.json");
   }
+  get compressionGuidelineDraftStatePath() {
+    return path4.join(this.stateDir, "compression-guideline-draft-state.json");
+  }
   get behaviorSignalsPath() {
     return path4.join(this.stateDir, "behavior-signals.jsonl");
   }
@@ -1764,7 +1770,7 @@ ${sanitized.text}
       memoryId: id,
       eventType: "created",
       timestamp: fm.created,
-      actor: "storage.writeMemory",
+      actor: options.actor ?? "storage.writeMemory",
       after: this.summarizeLifecycleState(fm, filePath),
       relatedMemoryIds: [
         ...options.supersedes ? [options.supersedes] : [],
@@ -1826,11 +1832,12 @@ ${sanitized.text}
 
 ${sanitized.text}
 `, "utf-8");
+    const actor = typeof options.actor === "string" && options.actor.length > 0 ? options.actor : "storage.writeArtifact";
     await this.appendGeneratedMemoryLifecycleEventFailOpen("storage.writeArtifact", {
       memoryId: id,
       eventType: "created",
       timestamp: fm.created,
-      actor: "storage.writeArtifact",
+      actor,
       after: this.summarizeLifecycleState(fm, filePath),
       relatedMemoryIds: options.sourceMemoryId ? [options.sourceMemoryId] : []
     });
@@ -2329,7 +2336,7 @@ ${sanitized.text}
       memoryId: id,
       eventType: "updated",
       timestamp: updated.updated,
-      actor: "storage.updateMemory",
+      actor: options?.actor ?? "storage.updateMemory",
       before: this.summarizeLifecycleState(memory.frontmatter, memory.path),
       after: this.summarizeLifecycleState(updated, memory.path),
       relatedMemoryIds: [
@@ -2638,18 +2645,81 @@ ${memory.content}
       return null;
     }
   }
+  async writeCompressionGuidelineDraft(content) {
+    await this.ensureDirectories();
+    await writeFile2(this.compressionGuidelineDraftPath, content, "utf-8");
+  }
+  async readCompressionGuidelineDraft() {
+    try {
+      return await readFile2(this.compressionGuidelineDraftPath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
   async writeCompressionGuidelineOptimizerState(state) {
     await this.ensureDirectories();
     await writeFile2(this.compressionGuidelineStatePath, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+  }
+  async writeCompressionGuidelineDraftState(state) {
+    await this.ensureDirectories();
+    await writeFile2(this.compressionGuidelineDraftStatePath, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
   }
   async readCompressionGuidelineOptimizerState() {
+    return this.readCompressionGuidelineStateFile(this.compressionGuidelineStatePath);
+  }
+  async readCompressionGuidelineDraftState() {
+    return this.readCompressionGuidelineStateFile(this.compressionGuidelineDraftStatePath);
+  }
+  async activateCompressionGuidelineDraft(options) {
+    const [draftContent, draftState] = await Promise.all([
+      this.readCompressionGuidelineDraft(),
+      this.readCompressionGuidelineDraftState()
+    ]);
+    if (!draftContent || !draftState) return false;
+    if (typeof options?.expectedContentHash === "string" && options.expectedContentHash.length > 0 && draftState.contentHash !== options.expectedContentHash) {
+      return false;
+    }
+    if (typeof options?.expectedGuidelineVersion === "number" && Number.isFinite(options.expectedGuidelineVersion) && draftState.guidelineVersion !== options.expectedGuidelineVersion) {
+      return false;
+    }
+    if (draftState.contentHash) {
+      const contentHash = createHash("sha256").update(draftContent).digest("hex");
+      if (contentHash !== draftState.contentHash) return false;
+    }
+    await this.writeCompressionGuidelines(draftContent);
+    await this.writeCompressionGuidelineOptimizerState({
+      ...draftState,
+      activationState: "active"
+    });
+    await Promise.all([
+      unlink(this.compressionGuidelineDraftPath).catch(() => void 0),
+      unlink(this.compressionGuidelineDraftStatePath).catch(() => void 0)
+    ]);
+    return true;
+  }
+  async readCompressionGuidelineStateFile(filePath) {
     const isFiniteNonNegativeInteger = (value) => typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+    const isValidActionSummary = (value) => {
+      if (!value || typeof value !== "object") return false;
+      const summary = value;
+      return typeof summary.action === "string" && isFiniteNonNegativeInteger(summary.total) && summary.outcomes !== null && typeof summary.outcomes === "object" && isFiniteNonNegativeInteger(summary.outcomes.applied) && isFiniteNonNegativeInteger(summary.outcomes.skipped) && isFiniteNonNegativeInteger(summary.outcomes.failed) && summary.quality !== null && typeof summary.quality === "object" && isFiniteNonNegativeInteger(summary.quality.good) && isFiniteNonNegativeInteger(summary.quality.poor) && isFiniteNonNegativeInteger(summary.quality.unknown);
+    };
+    const isValidRuleUpdate = (value) => {
+      if (!value || typeof value !== "object") return false;
+      const rule = value;
+      return typeof rule.action === "string" && typeof rule.delta === "number" && Number.isFinite(rule.delta) && (rule.direction === "increase" || rule.direction === "decrease" || rule.direction === "hold") && (rule.confidence === "low" || rule.confidence === "medium" || rule.confidence === "high") && Array.isArray(rule.notes) && rule.notes.every((note) => typeof note === "string");
+    };
     try {
-      const raw = await readFile2(this.compressionGuidelineStatePath, "utf-8");
+      const raw = await readFile2(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       const sourceWindow = parsed?.sourceWindow;
       const eventCounts = parsed?.eventCounts;
+      const activationState = parsed?.activationState === "draft" || parsed?.activationState === "active" ? parsed.activationState : void 0;
+      const contentHash = typeof parsed?.contentHash === "string" && parsed.contentHash.length > 0 ? parsed.contentHash : void 0;
+      const actionSummaries = Array.isArray(parsed?.actionSummaries) ? parsed.actionSummaries.filter(isValidActionSummary) : void 0;
+      const ruleUpdates = Array.isArray(parsed?.ruleUpdates) ? parsed.ruleUpdates.filter(isValidRuleUpdate) : void 0;
       if (!isFiniteNonNegativeInteger(parsed?.version) || typeof parsed?.updatedAt !== "string" || parsed.updatedAt.length === 0 || !sourceWindow || typeof sourceWindow.from !== "string" || sourceWindow.from.length === 0 || typeof sourceWindow.to !== "string" || sourceWindow.to.length === 0 || !eventCounts || !isFiniteNonNegativeInteger(eventCounts.total) || !isFiniteNonNegativeInteger(eventCounts.applied) || !isFiniteNonNegativeInteger(eventCounts.skipped) || !isFiniteNonNegativeInteger(eventCounts.failed) || !isFiniteNonNegativeInteger(parsed?.guidelineVersion)) {
         return null;
       }
@@ -2666,7 +2736,11 @@ ${memory.content}
           skipped: eventCounts.skipped,
           failed: eventCounts.failed
         },
-        guidelineVersion: parsed.guidelineVersion
+        guidelineVersion: parsed.guidelineVersion,
+        ...contentHash ? { contentHash } : {},
+        ...activationState ? { activationState } : {},
+        ...actionSummaries ? { actionSummaries } : {},
+        ...ruleUpdates ? { ruleUpdates } : {}
       };
     } catch {
       return null;
@@ -3629,7 +3703,7 @@ ${memory.content}
   /**
    * Add links to an existing memory.
    */
-  async addLinksToMemory(memoryId, links) {
+  async addLinksToMemory(memoryId, links, lifecycle) {
     const memories = await this.readAllMemories();
     const memory = memories.find((m) => m.frontmatter.id === memoryId);
     if (!memory) return false;
@@ -3640,17 +3714,15 @@ ${memory.content}
         mergedLinks.push(link);
       }
     }
-    const updatedFm = {
-      ...memory.frontmatter,
-      links: mergedLinks,
-      updated: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const fileContent = `${serializeFrontmatter(updatedFm)}
-
-${memory.content}
-`;
     try {
-      await writeFile2(memory.path, fileContent, "utf-8");
+      await this.writeMemoryFrontmatter(
+        memory,
+        {
+          links: mergedLinks,
+          updated: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        lifecycle
+      );
       log.debug(`added ${links.length} links to memory ${memoryId}`);
       return true;
     } catch (err) {
@@ -3723,4 +3795,4 @@ export {
   serializeEntityFile,
   StorageManager
 };
-//# sourceMappingURL=chunk-CWVXHH36.js.map
+//# sourceMappingURL=chunk-QKD7TZY2.js.map