@joshuaswarren/openclaw-engram 8.3.77 → 8.3.79

package/dist/index.js

@@ -451,7 +451,7 @@ function parseConfig(raw) {
 
 // src/orchestrator.ts
 import path26 from "path";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { mkdir as mkdir19, readdir as readdir11, readFile as readFile18, writeFile as writeFile17 } from "fs/promises";
 
 // src/signal.ts
@@ -5313,6 +5313,9 @@ var StorageManager = class _StorageManager {
   get compressionGuidelineStatePath() {
     return path4.join(this.stateDir, "compression-guideline-state.json");
   }
+  get behaviorSignalsPath() {
+    return path4.join(this.stateDir, "behavior-signals.jsonl");
+  }
   /**
    * Load user-defined entity aliases from config/aliases.json in the memory store.
    * File format: { "variant": "canonical", "variant2": "canonical", ... }
@@ -5998,6 +6001,67 @@ ${memory.content}
     await appendFile(this.memoryActionsPath, payload, "utf-8");
     return events.length;
   }
+  async appendBehaviorSignals(events) {
+    if (events.length === 0) return 0;
+    await this.ensureDirectories();
+    let existingKeys = /* @__PURE__ */ new Set();
+    try {
+      const raw = await readFile2(this.behaviorSignalsPath, "utf-8");
+      const lines = raw.split("\n");
+      for (const line of lines) {
+        const row = line.trim();
+        if (!row) continue;
+        try {
+          const parsed = JSON.parse(row);
+          if (typeof parsed.memoryId === "string" && typeof parsed.signalHash === "string") {
+            existingKeys.add(`${parsed.memoryId}:${parsed.signalHash}`);
+          }
+        } catch {
+        }
+      }
+    } catch {
+      existingKeys = /* @__PURE__ */ new Set();
+    }
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    const deduped = [];
+    for (const event of events) {
+      const key = `${event.memoryId}:${event.signalHash}`;
+      if (existingKeys.has(key)) continue;
+      existingKeys.add(key);
+      deduped.push({
+        ...event,
+        timestamp: event.timestamp && event.timestamp.length > 0 ? event.timestamp : nowIso
+      });
+    }
+    if (deduped.length === 0) return 0;
+    const payload = deduped.map((event) => `${JSON.stringify(event)}
+`).join("");
+    await appendFile(this.behaviorSignalsPath, payload, "utf-8");
+    return deduped.length;
+  }
+  async readBehaviorSignals(limit = 200) {
+    const cappedLimit = Math.max(0, Math.floor(limit));
+    if (cappedLimit === 0) return [];
+    try {
+      const raw = await readFile2(this.behaviorSignalsPath, "utf-8");
+      const out = [];
+      const lines = raw.split("\n");
+      for (let i = lines.length - 1; i >= 0 && out.length < cappedLimit; i -= 1) {
+        const row = lines[i]?.trim();
+        if (!row) continue;
+        try {
+          const parsed = JSON.parse(row);
+          if (typeof parsed.timestamp === "string" && typeof parsed.namespace === "string" && typeof parsed.memoryId === "string" && typeof parsed.category === "string" && typeof parsed.signalType === "string" && typeof parsed.direction === "string" && typeof parsed.confidence === "number" && typeof parsed.signalHash === "string" && typeof parsed.source === "string") {
+            out.push(parsed);
+          }
+        } catch {
+        }
+      }
+      return out.reverse();
+    } catch {
+      return [];
+    }
+  }
   async readMemoryActionEvents(limit = 200) {
     const cappedLimit = Math.max(0, Math.floor(limit));
     if (cappedLimit === 0) return [];
@@ -9754,6 +9818,10 @@ function buildInstructionHeavyQuery(prompt, tokenCap, maxChars) {
   if (compact.length <= maxChars) return compact;
   return compact.slice(0, maxChars).trim();
 }
+function clampInstructionHeavyTokenCap(value) {
+  if (!Number.isFinite(value)) return 8;
+  return Math.max(8, Math.round(value));
+}
 function buildStandardQuery(prompt, maxChars) {
   const trimmed = collapseWhitespace(prompt);
   if (trimmed.length <= maxChars) return trimmed;
@@ -9772,7 +9840,7 @@ function buildRecallQueryPolicy(prompt, sessionKey, cfg) {
   }
   const promptShape = classifyRecallPromptShape(prompt);
   const maxChars = Math.max(120, cfg.cronRecallNormalizedQueryMaxChars);
-  const tokenCap = Math.max(8, cfg.cronRecallInstructionHeavyTokenCap);
+  const tokenCap = clampInstructionHeavyTokenCap(cfg.cronRecallInstructionHeavyTokenCap);
   const retrievalQuery = promptShape === "instruction_heavy" ? buildInstructionHeavyQuery(prompt, tokenCap, maxChars) : buildStandardQuery(prompt, maxChars);
   const skipConversationRecall = cfg.cronConversationRecallMode === "never" ? true : cfg.cronConversationRecallMode === "always" ? false : promptShape === "instruction_heavy";
   const retrievalBudgetMode = promptShape === "instruction_heavy" ? "minimal" : "full";
@@ -13057,6 +13125,63 @@ var RoutingRulesStore = class {
   }
 };
 
+// src/behavior-signals.ts
+import { createHash as createHash5 } from "crypto";
+function normalizeSignalText(input) {
+  return input.replace(/\s+/g, " ").trim().toLowerCase();
+}
+function buildBehaviorSignalHash(category, content) {
+  const normalized = `${category}:${normalizeSignalText(content)}`;
+  return createHash5("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function buildBehaviorSignalsForMemory(input) {
+  const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const signalHash = buildBehaviorSignalHash(input.category, input.content);
+  const source = input.source ?? "extraction";
+  if (input.category === "correction") {
+    return [
+      {
+        timestamp,
+        namespace: input.namespace,
+        memoryId: input.memoryId,
+        category: "correction",
+        signalType: "correction_override",
+        direction: "negative",
+        confidence: input.confidence,
+        signalHash,
+        source
+      }
+    ];
+  }
+  if (input.category === "preference") {
+    return [
+      {
+        timestamp,
+        namespace: input.namespace,
+        memoryId: input.memoryId,
+        category: "preference",
+        signalType: "preference_affinity",
+        direction: "positive",
+        confidence: input.confidence,
+        signalHash,
+        source
+      }
+    ];
+  }
+  return [];
+}
+function dedupeBehaviorSignalsByMemoryAndHash(signals) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const signal of signals) {
+    const key = `${signal.memoryId}:${signal.signalHash}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(signal);
+  }
+  return out;
+}
+
 // src/orchestrator.ts
 function isArtifactMemoryPath(filePath) {
   return /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(filePath);
@@ -14213,7 +14338,7 @@ ${r.snippet.trim()}
       const payload = {
         recordedAt: now,
         mode: options.recallMode,
-        queryHash: createHash5("sha256").update(options.prompt).digest("hex"),
+        queryHash: createHash6("sha256").update(options.prompt).digest("hex"),
         queryLength: options.prompt.length,
         namespaces: options.recallNamespaces,
         seedCount: totalSeedCount,
@@ -14229,7 +14354,7 @@ ${r.snippet.trim()}
   async recallInternal(prompt, sessionKey) {
     const recallStart = Date.now();
     const timings = {};
-    const promptHash = createHash5("sha256").update(prompt).digest("hex");
+    const promptHash = createHash6("sha256").update(prompt).digest("hex");
     const sections = [];
     const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
       cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
@@ -14238,7 +14363,7 @@ ${r.snippet.trim()}
       cronConversationRecallMode: this.config.cronConversationRecallMode
     });
     const retrievalQuery = queryPolicy.retrievalQuery || prompt;
-    const retrievalQueryHash = createHash5("sha256").update(retrievalQuery).digest("hex");
+    const retrievalQueryHash = createHash6("sha256").update(retrievalQuery).digest("hex");
     let impressionRecorded = false;
     let recallSource = "none";
     let recalledMemoryCount = 0;
@@ -14273,7 +14398,7 @@ ${r.snippet.trim()}
       timings.total = `${Date.now() - recallStart}ms`;
       this.emitTrace({
         kind: "recall_summary",
-        traceId: createHash5("sha256").update(`${sessionKey ?? "default"}:${Date.now()}:${promptHash}`).digest("hex").slice(0, 16),
+        traceId: createHash6("sha256").update(`${sessionKey ?? "default"}:${Date.now()}:${promptHash}`).digest("hex").slice(0, 16),
         operation: "recall",
         sessionKey,
         promptHash,
@@ -14870,7 +14995,7 @@ _Context: ${topQuestion.context}_`);
     const context = sections.length === 0 ? "" : sections.join("\n\n---\n\n");
     this.emitTrace({
       kind: "recall_summary",
-      traceId: createHash5("sha256").update(`${sessionKey ?? "default"}:${Date.now()}:${promptHash}`).digest("hex").slice(0, 16),
+      traceId: createHash6("sha256").update(`${sessionKey ?? "default"}:${Date.now()}:${promptHash}`).digest("hex").slice(0, 16),
       operation: "recall",
       sessionKey,
       promptHash,
@@ -15019,7 +15144,7 @@ _Context: ${topQuestion.context}_`);
     if (!Array.isArray(turns) || turns.length === 0) return false;
     const normalized = turns.filter((t) => t.role === "user" || t.role === "assistant").map((t) => `${t.role}:${(t.content ?? "").trim().slice(0, this.config.extractionMaxTurnChars)}`).join("\n");
     if (!normalized) return false;
-    const fingerprint = createHash5("sha256").update(normalized).digest("hex");
+    const fingerprint = createHash6("sha256").update(normalized).digest("hex");
     const now = Date.now();
     const seenAt = this.recentExtractionFingerprints.get(fingerprint);
     if (seenAt && now - seenAt < this.config.extractionDedupeWindowMs) {
@@ -15383,6 +15508,17 @@ _Context: ${topQuestion.context}_`);
       persistedIdsByStorage.set(key, { storage: targetStorage, ids: [id] });
     };
     let dedupedCount = 0;
+    const behaviorSignalsByStorage = /* @__PURE__ */ new Map();
+    const trackBehaviorSignals = (targetStorage, events) => {
+      if (events.length === 0) return;
+      const key = targetStorage.dir;
+      const existing = behaviorSignalsByStorage.get(key);
+      if (existing) {
+        existing.events.push(...events);
+        return;
+      }
+      behaviorSignalsByStorage.set(key, { storage: targetStorage, events: [...events] });
+    };
     if (!result || !Array.isArray(result.facts)) {
       log.warn("persistExtraction: result or result.facts is invalid, skipping", { resultType: typeof result, factsType: typeof result?.facts });
       return persistedIds;
@@ -15573,6 +15709,17 @@ _Context: ${topQuestion.context}_`);
             } catch {
             }
           }
+          trackBehaviorSignals(
+            targetStorage,
+            buildBehaviorSignalsForMemory({
+              memoryId: parentId,
+              category: writeCategory,
+              content: fact.content,
+              namespace: this.namespaceFromStorageDir(targetStorage.dir),
+              confidence: fact.confidence,
+              source: "extraction"
+            })
+          );
           continue;
         }
       }
@@ -15633,6 +15780,17 @@ _Context: ${topQuestion.context}_`);
           `routing applied for memory ${memoryId}: rule=${routedRuleId} category=${writeCategory} storage=${targetStorage.dir}`
         );
       }
+      trackBehaviorSignals(
+        targetStorage,
+        buildBehaviorSignalsForMemory({
+          memoryId,
+          category: writeCategory,
+          content: fact.content,
+          namespace: this.namespaceFromStorageDir(targetStorage.dir),
+          confidence: fact.confidence,
+          source: "extraction"
+        })
+      );
       trackPersistedId(targetStorage, memoryId);
       if (threadEpisodeIdsForGraph && !threadEpisodeIdsForGraph.includes(memoryId)) {
         threadEpisodeIdsForGraph.push(memoryId);
@@ -15750,6 +15908,11 @@ _Context: ${topQuestion.context}_`);
         (err) => log.warn(`content-hash index save failed: ${err}`)
       );
     }
+    for (const { storage: targetStorage, events } of behaviorSignalsByStorage.values()) {
+      const dedupedSignals = dedupeBehaviorSignalsByMemoryAndHash(events);
+      if (dedupedSignals.length === 0) continue;
+      await targetStorage.appendBehaviorSignals(dedupedSignals).catch((err) => log.warn(`appendBehaviorSignals failed (non-fatal): ${err}`));
+    }
     const dedupSuffix = dedupedCount > 0 ? ` (${dedupedCount} deduped)` : "";
     log.info(
       `persisted: ${facts.length - dedupedCount} facts${dedupSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
@@ -17096,7 +17259,7 @@ ${lines.join("\n\n")}`;
 
 // src/tools.ts
 import path28 from "path";
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 import { Type } from "@sinclair/typebox";
 
 // src/work/storage.ts
@@ -17867,7 +18030,7 @@ function registerTools(api, orchestrator) {
   ];
   function promptHashForTelemetry(input) {
     if (typeof input !== "string" || input.trim().length === 0) return void 0;
-    return createHash6("sha256").update(input).digest("hex").slice(0, 16);
+    return createHash7("sha256").update(input).digest("hex").slice(0, 16);
   }
   function namespaceFromPath(p) {
     const m = p.match(/[\\/]+namespaces[\\/]+([^\\/]+)[\\/]+/);
@@ -19460,17 +19623,17 @@ var EXPORT_FORMAT = "openclaw-engram-export";
 var EXPORT_SCHEMA_VERSION = 1;
 
 // src/transfer/fs-utils.ts
-import { createHash as createHash7 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 import { mkdir as mkdir21, readdir as readdir13, readFile as readFile20, stat as stat6, writeFile as writeFile19 } from "fs/promises";
 import path29 from "path";
 async function sha256File(filePath) {
   const buf = await readFile20(filePath);
-  const sha256 = createHash7("sha256").update(buf).digest("hex");
+  const sha256 = createHash8("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
 function sha256String(content) {
   const buf = Buffer.from(content, "utf-8");
-  const sha256 = createHash7("sha256").update(buf).digest("hex");
+  const sha256 = createHash8("sha256").update(buf).digest("hex");
   return { sha256, bytes: buf.byteLength };
 }
 async function writeJsonFile(filePath, value) {