@joshuaswarren/openclaw-engram 8.3.58 → 8.3.60

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 = [
@@ -15105,30 +15163,123 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
     log.info("consolidation complete");
     return { memoriesProcessed: allMemories.length, merged, invalidated };
   }
-  async runCompressionGuidelineLearningPass() {
-    if (!this.config.compressionGuidelineLearningEnabled) return;
-    try {
-      const previousState = await this.storage.readCompressionGuidelineOptimizerState();
-      const events = await this.storage.readMemoryActionEvents(500);
-      const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const candidate = computeCompressionGuidelineCandidate(events, {
-        generatedAtIso: generatedAt,
-        previousState
-      });
-      const content = renderCompressionGuidelinesMarkdown(candidate);
+  async optimizeCompressionGuidelines(options) {
+    const dryRun = options?.dryRun === true;
+    const eventLimit = typeof options?.eventLimit === "number" ? Math.max(0, Math.floor(options.eventLimit)) : 500;
+    const previousState = await this.storage.readCompressionGuidelineOptimizerState();
+    if (!this.config.compressionGuidelineLearningEnabled) {
+      return {
+        enabled: false,
+        dryRun,
+        eventCount: 0,
+        previousGuidelineVersion: previousState?.guidelineVersion ?? null,
+        nextGuidelineVersion: previousState?.guidelineVersion ?? 0,
+        changedRules: 0,
+        semanticRefinementApplied: false,
+        persisted: false
+      };
+    }
+    const events = await this.storage.readMemoryActionEvents(eventLimit);
+    const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const candidate = computeCompressionGuidelineCandidate(events, {
+      generatedAtIso: generatedAt,
+      previousState
+    });
+    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);
+    const semanticRefinementApplied = JSON.stringify(refinedCandidate.ruleUpdates) !== JSON.stringify(candidate.ruleUpdates);
+    const changedRules = refinedCandidate.ruleUpdates.filter((rule) => rule.delta !== 0).length;
+    if (!dryRun) {
       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)`);
+    }
+    return {
+      enabled: true,
+      dryRun,
+      eventCount: events.length,
+      previousGuidelineVersion: previousState?.guidelineVersion ?? null,
+      nextGuidelineVersion: refinedCandidate.guidelineVersion,
+      changedRules,
+      semanticRefinementApplied,
+      persisted: !dryRun
+    };
+  }
+  async runCompressionGuidelineLearningPass() {
+    if (!this.config.compressionGuidelineLearningEnabled) return;
+    try {
+      const result = await this.optimizeCompressionGuidelines({ dryRun: false, eventLimit: 500 });
+      log.info(`compression guideline learning updated (${result.eventCount} 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();
@@ -17447,6 +17598,49 @@ NOTE: You did not provide sessionKey; under concurrency this may not match your
     },
     { name: "memory_action_apply" }
   );
+  api.registerTool(
+    {
+      name: "compression_guidelines_optimize",
+      label: "Optimize Compression Guidelines",
+      description: "Run compression guideline optimizer and optionally persist the new guideline/state (v8.11).",
+      parameters: Type.Object({
+        dryRun: Type.Optional(
+          Type.Boolean({
+            description: "When true, compute candidate/output but do not persist changes."
+          })
+        ),
+        eventLimit: Type.Optional(
+          Type.Number({
+            description: "Max telemetry events to analyze (default: 500)."
+          })
+        )
+      }),
+      async execute(_toolCallId, params) {
+        const { dryRun, eventLimit } = params;
+        const result = await orchestrator.optimizeCompressionGuidelines({
+          dryRun: dryRun === true,
+          eventLimit
+        });
+        if (!result.enabled) {
+          return toolResult(
+            "Compression guideline learning is disabled. Enable `compressionGuidelineLearningEnabled: true` to run optimizer."
+          );
+        }
+        return toolResult(
+          [
+            "Compression guideline optimization complete.",
+            `dryRun=${result.dryRun}`,
+            `persisted=${result.persisted}`,
+            `eventCount=${result.eventCount}`,
+            `guidelineVersion: ${result.previousGuidelineVersion ?? "none"} -> ${result.nextGuidelineVersion}`,
+            `changedRules=${result.changedRules}`,
+            `semanticRefinementApplied=${result.semanticRefinementApplied}`
+          ].join("\n")
+        );
+      }
+    },
+    { name: "compression_guidelines_optimize" }
+  );
   api.registerTool(
     {
       name: "memory_store",