@joshuaswarren/openclaw-engram 8.3.58 → 8.3.59

package/dist/index.js

@@ -377,6 +377,8 @@ function parseConfig(raw) {
     proactiveExtractionEnabled: cfg.proactiveExtractionEnabled === true,
     contextCompressionActionsEnabled: cfg.contextCompressionActionsEnabled === true,
     compressionGuidelineLearningEnabled: cfg.compressionGuidelineLearningEnabled === true,
+    compressionGuidelineSemanticRefinementEnabled: cfg.compressionGuidelineSemanticRefinementEnabled === true,
+    compressionGuidelineSemanticTimeoutMs: typeof cfg.compressionGuidelineSemanticTimeoutMs === "number" ? Math.max(1, Math.floor(cfg.compressionGuidelineSemanticTimeoutMs)) : 2500,
     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
@@ -9498,6 +9500,13 @@ function nextOptimizerVersion(previousState) {
 function roundDelta(value) {
   return Math.round(value * 1e3) / 1e3;
 }
+function confidenceForDelta(delta) {
+  const magnitude = Math.abs(delta);
+  return magnitude >= 0.09 ? "high" : magnitude >= 0.04 ? "medium" : "low";
+}
+function directionForDelta(delta) {
+  return delta > 0 ? "increase" : delta < 0 ? "decrease" : "hold";
+}
 function computeCompressionGuidelineCandidate(events, options = {}) {
   const generatedAt = options.generatedAtIso ?? (/* @__PURE__ */ new Date()).toISOString();
   const previousState = options.previousState ?? null;
@@ -9551,7 +9560,7 @@ function computeCompressionGuidelineCandidate(events, options = {}) {
     const qualitySignal = qualitySeen > 0 ? (summary.quality.good - summary.quality.poor) / qualitySeen : 0;
     const rawDelta = clamp((successRate - failureRate) * 0.12 + qualitySignal * 0.06, -MAX_DELTA, MAX_DELTA);
     const delta = roundDelta(rawDelta);
-    const direction = delta > 0 ? "increase" : delta < 0 ? "decrease" : "hold";
+    const direction = directionForDelta(delta);
     if (direction === "decrease" && summary.outcomes.failed > summary.outcomes.applied) {
       notes.push("Failures exceed applied outcomes; conservative down-adjustment.");
     } else if (direction === "increase" && summary.quality.good > summary.quality.poor) {
@@ -9561,8 +9570,7 @@ function computeCompressionGuidelineCandidate(events, options = {}) {
     } else {
       notes.push("Outcomes are stable; keep bounded adjustments.");
     }
-    const magnitude = Math.abs(delta);
-    const confidence = magnitude >= 0.09 ? "high" : magnitude >= 0.04 ? "medium" : "low";
+    const confidence = confidenceForDelta(delta);
     return {
       action: summary.action,
       delta,
@@ -9584,6 +9592,56 @@ function computeCompressionGuidelineCandidate(events, options = {}) {
     optimizerVersion: nextOptimizerVersion(previousState)
   };
 }
+async function refineCompressionGuidelineCandidateSemantically(baseline, options) {
+  if (!options.enabled) return baseline;
+  if (typeof options.runRefinement !== "function") return baseline;
+  const timeoutMs = Math.max(1, Math.floor(options.timeoutMs));
+  let timeoutId = null;
+  const timeout = new Promise((resolve) => {
+    timeoutId = setTimeout(() => resolve(null), timeoutMs);
+  });
+  const refinementPromise = options.runRefinement(baseline).catch(() => null);
+  let refinement = null;
+  try {
+    refinement = await Promise.race([refinementPromise, timeout]);
+  } catch {
+    if (timeoutId) clearTimeout(timeoutId);
+    return baseline;
+  }
+  if (timeoutId) clearTimeout(timeoutId);
+  if (!refinement || !Array.isArray(refinement.updates) || refinement.updates.length === 0) {
+    return baseline;
+  }
+  const updatesByAction = /* @__PURE__ */ new Map();
+  for (const update of refinement.updates) {
+    if (!update || typeof update.action !== "string") continue;
+    updatesByAction.set(update.action, update);
+  }
+  let changed = false;
+  const ruleUpdates = baseline.ruleUpdates.map((rule) => {
+    const patch = updatesByAction.get(rule.action);
+    if (!patch) return rule;
+    const nextDelta = typeof patch.delta === "number" && Number.isFinite(patch.delta) ? roundDelta(clamp(patch.delta, -MAX_DELTA, MAX_DELTA)) : rule.delta;
+    const nextConfidence = patch.confidence ?? confidenceForDelta(nextDelta);
+    const nextDirection = directionForDelta(nextDelta);
+    const nextNotes = typeof patch.note === "string" && patch.note.trim().length > 0 ? [patch.note.trim()] : rule.notes;
+    if (nextDelta !== rule.delta || nextDirection !== rule.direction || nextConfidence !== rule.confidence || nextNotes.join("\n") !== rule.notes.join("\n")) {
+      changed = true;
+    }
+    return {
+      ...rule,
+      delta: nextDelta,
+      direction: nextDirection,
+      confidence: nextConfidence,
+      notes: nextNotes
+    };
+  });
+  if (!changed) return baseline;
+  return {
+    ...baseline,
+    ruleUpdates
+  };
+}
 function renderCompressionGuidelinesMarkdown(candidate) {
   const actionLines = candidate.actionSummaries.length === 0 ? ["- (none)"] : candidate.actionSummaries.map((item) => `- ${item.action}: ${item.total}`);
   const outcomeLines = [
@@ -15115,20 +15173,82 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
         generatedAtIso: generatedAt,
         previousState
       });
-      const content = renderCompressionGuidelinesMarkdown(candidate);
+      const refinedCandidate = await refineCompressionGuidelineCandidateSemantically(candidate, {
+        enabled: this.config.compressionGuidelineSemanticRefinementEnabled,
+        timeoutMs: this.config.compressionGuidelineSemanticTimeoutMs,
+        runRefinement: async (baseline) => {
+          const prompt = [
+            "You refine compression policy suggestions conservatively.",
+            "Return JSON only in this shape:",
+            '{"updates":[{"action":"summarize_node","delta":0.02,"confidence":"medium","note":"..."}]}',
+            "Constraints:",
+            "- Keep updates sparse and conservative.",
+            "- delta must stay between -0.15 and 0.15.",
+            "- Only include actions present in the input.",
+            "Input candidate:",
+            JSON.stringify(baseline)
+          ].join("\n");
+          const response = await this.localLlm.chatCompletion(
+            [
+              { role: "system", content: "Respond with strict JSON only. No markdown." },
+              { role: "user", content: prompt }
+            ],
+            {
+              temperature: 0.1,
+              maxTokens: 400,
+              timeoutMs: this.config.compressionGuidelineSemanticTimeoutMs,
+              operation: "compression_guideline_semantic_refinement"
+            }
+          );
+          return this.parseCompressionSemanticRefinement(response?.content ?? "");
+        }
+      });
+      const content = renderCompressionGuidelinesMarkdown(refinedCandidate);
       await this.storage.writeCompressionGuidelines(content);
       await this.storage.writeCompressionGuidelineOptimizerState({
-        version: candidate.optimizerVersion,
-        updatedAt: candidate.generatedAt,
-        sourceWindow: candidate.sourceWindow,
-        eventCounts: candidate.eventCounts,
-        guidelineVersion: candidate.guidelineVersion
+        version: refinedCandidate.optimizerVersion,
+        updatedAt: refinedCandidate.generatedAt,
+        sourceWindow: refinedCandidate.sourceWindow,
+        eventCounts: refinedCandidate.eventCounts,
+        guidelineVersion: refinedCandidate.guidelineVersion
       });
       log.info(`compression guideline learning updated (${events.length} events)`);
     } catch (err) {
       log.warn(`compression guideline learning failed (ignored): ${err}`);
     }
   }
+  parseCompressionSemanticRefinement(raw) {
+    if (typeof raw !== "string" || raw.trim().length === 0) return null;
+    const trimmed = raw.trim();
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) return null;
+    try {
+      const parsed = JSON.parse(trimmed.slice(start, end + 1));
+      if (!Array.isArray(parsed?.updates)) return null;
+      const validActions = /* @__PURE__ */ new Set([
+        "store_episode",
+        "store_note",
+        "update_note",
+        "create_artifact",
+        "summarize_node",
+        "discard",
+        "link_graph"
+      ]);
+      const updates = parsed.updates.filter((item) => item && typeof item.action === "string" && validActions.has(item.action)).map((item) => {
+        const confidence = item.confidence === "low" || item.confidence === "medium" || item.confidence === "high" ? item.confidence : void 0;
+        return {
+          action: item.action,
+          delta: typeof item.delta === "number" && Number.isFinite(item.delta) ? item.delta : void 0,
+          confidence,
+          note: typeof item.note === "string" ? item.note : void 0
+        };
+      });
+      return { updates };
+    } catch {
+      return null;
+    }
+  }
   async runLifecyclePolicyPass(allMemories) {
     const now = /* @__PURE__ */ new Date();
     const nowIso = now.toISOString();