@joshuaswarren/openclaw-engram 9.0.7 → 9.0.8

package/dist/index.js

@@ -469,6 +469,7 @@ function parseConfig(raw) {
     graphExpansionBlendMin: typeof cfg.graphExpansionBlendMin === "number" ? Math.min(1, Math.max(0, cfg.graphExpansionBlendMin)) : 0.05,
     graphExpansionBlendMax: typeof cfg.graphExpansionBlendMax === "number" ? Math.min(1, Math.max(0, cfg.graphExpansionBlendMax)) : 0.95,
     maxEntityGraphEdgesPerMemory: typeof cfg.maxEntityGraphEdgesPerMemory === "number" ? Math.max(0, cfg.maxEntityGraphEdgesPerMemory) : 10,
+    delinearizeEnabled: cfg.delinearizeEnabled !== false,
     recallConfidenceGateEnabled: cfg.recallConfidenceGateEnabled === true,
     recallConfidenceGateThreshold: typeof cfg.recallConfidenceGateThreshold === "number" ? Math.max(0, Math.min(1, cfg.recallConfidenceGateThreshold)) : 0.12,
     graphLateralInhibitionEnabled: cfg.graphLateralInhibitionEnabled !== false,
@@ -803,6 +804,133 @@ function chunkContent(content, config = DEFAULT_CHUNKING_CONFIG) {
 // src/extraction.ts
 import OpenAI from "openai";
 
+// src/delinearize.ts
+var PRONOUN_MAP = {
+  "he": { types: ["person"], possessive: false, group: "masc" },
+  "him": { types: ["person"], possessive: false, group: "masc" },
+  "his": { types: ["person"], possessive: true, group: "masc" },
+  "she": { types: ["person"], possessive: false, group: "fem" },
+  // "her" omitted — ambiguous between object ("saw her") and possessive ("her stack")
+  "they": { types: ["company", "project", "other"], possessive: false, group: "they" },
+  "them": { types: ["company", "project", "other"], possessive: false, group: "they" },
+  "their": { types: ["company", "project", "other"], possessive: true, group: "they" },
+  "it": { types: ["project", "tool", "company"], possessive: false, group: "it" },
+  "its": { types: ["project", "tool", "company"], possessive: true, group: "it" }
+};
+function resolveCoReferences(fact, entities) {
+  if (entities.length === 0) return fact;
+  const matchingEntries = [];
+  const typeToGroups = /* @__PURE__ */ new Map();
+  for (const [pronoun, info] of Object.entries(PRONOUN_MAP)) {
+    const regex = new RegExp(`\\b${pronoun}\\b(?![''\u2019])`, "gi");
+    if (!regex.test(fact)) continue;
+    const candidates = entities.filter((e) => info.types.includes(e.type));
+    if (candidates.length !== 1) continue;
+    matchingEntries.push({ pronoun, info, entity: candidates[0] });
+    const matchedType = candidates[0].type;
+    if (!typeToGroups.has(matchedType)) typeToGroups.set(matchedType, /* @__PURE__ */ new Set());
+    typeToGroups.get(matchedType).add(info.group);
+  }
+  const ambiguousTypes = /* @__PURE__ */ new Set();
+  for (const [type, groups] of typeToGroups) {
+    const matchedEntities = entities.filter((e) => e.type === type);
+    if (matchedEntities.length === 1 && groups.size > 1) {
+      ambiguousTypes.add(type);
+    }
+  }
+  const safeEntries = matchingEntries.filter(
+    (e) => !e.info.types.some((t) => ambiguousTypes.has(t))
+  );
+  if (safeEntries.length === 0) return fact;
+  let result = fact;
+  const placeholders = [];
+  for (const { pronoun, info, entity } of safeEntries) {
+    const placeholder = `\0ENTITY_${placeholders.length}\0`;
+    const safeEntityName = entity.name.replace(/\$/g, "$$$$");
+    const replacement = info.possessive ? `${safeEntityName}'s` : safeEntityName;
+    placeholders.push(replacement);
+    result = result.replace(
+      new RegExp(`\\b${pronoun}\\b(?![''\u2019])`, "gi"),
+      placeholder
+    );
+  }
+  for (let i = 0; i < placeholders.length; i++) {
+    result = result.replaceAll(`\0ENTITY_${i}\0`, placeholders[i]);
+  }
+  return result;
+}
+function formatDate(d) {
+  return d.toISOString().slice(0, 10);
+}
+var TEMPORAL_PATTERNS = [
+  {
+    pattern: /\bearlier today\b/gi,
+    replace: (now) => `earlier on ${formatDate(now)}`
+  },
+  {
+    pattern: /\bthis morning\b/gi,
+    replace: (now) => `on the morning of ${formatDate(now)}`
+  },
+  {
+    pattern: /\bthis afternoon\b/gi,
+    replace: (now) => `on the afternoon of ${formatDate(now)}`
+  },
+  {
+    pattern: /\bthis evening\b/gi,
+    replace: (now) => `on the evening of ${formatDate(now)}`
+  },
+  {
+    pattern: /\blast week\b/gi,
+    replace: (now) => {
+      const d = new Date(now);
+      d.setUTCDate(d.getUTCDate() - 7);
+      return `around ${formatDate(d)}`;
+    }
+  },
+  {
+    pattern: /\blast month\b/gi,
+    replace: (now) => {
+      const d = new Date(now);
+      d.setUTCDate(1);
+      d.setUTCMonth(d.getUTCMonth() - 1);
+      return `around ${formatDate(d)}`;
+    }
+  },
+  // Simple patterns last
+  {
+    pattern: /\byesterday\b/gi,
+    replace: (now) => {
+      const d = new Date(now);
+      d.setUTCDate(d.getUTCDate() - 1);
+      return `on ${formatDate(d)}`;
+    }
+  },
+  {
+    pattern: /\btoday\b/gi,
+    replace: (now) => `on ${formatDate(now)}`
+  },
+  {
+    pattern: /\btomorrow\b/gi,
+    replace: (now) => {
+      const d = new Date(now);
+      d.setUTCDate(d.getUTCDate() + 1);
+      return `on ${formatDate(d)}`;
+    }
+  }
+];
+function anchorTemporalExpressions(fact, now) {
+  let result = fact;
+  for (const { pattern, replace } of TEMPORAL_PATTERNS) {
+    result = result.replace(pattern, replace(now));
+  }
+  return result;
+}
+function delinearize(factContent, entities, timestamp) {
+  let result = anchorTemporalExpressions(factContent, timestamp);
+  result = resolveCoReferences(result, entities);
+  return result;
+}
+
 // src/local-llm.ts
 import { spawnSync } from "child_process";
 import { existsSync, readFileSync } from "fs";
@@ -2286,13 +2414,18 @@ var ExtractionEngine = class {
     } catch {
     }
   }
-  sanitizeExtractionResult(result) {
+  sanitizeExtractionResult(result, messageTimestamp) {
+    const ts = messageTimestamp ?? /* @__PURE__ */ new Date();
     const facts = result.facts.map((fact) => {
       const sanitized = sanitizeMemoryContent(fact.content);
       if (!sanitized.clean) {
         log.warn(`extraction fact sanitized; violations=${sanitized.violations.join(", ")}`);
       }
-      return { ...fact, content: sanitized.text };
+      let content = sanitized.text;
+      if (this.config.delinearizeEnabled) {
+        content = delinearize(content, result.entities, ts);
+      }
+      return { ...fact, content };
     });
     return { ...result, facts };
   }
@@ -2467,6 +2600,8 @@ var ExtractionEngine = class {
       log.debug("extraction skipped \u2014 conversation only contained non-memory work-layer context");
       return { facts: [], profileUpdates: [], entities: [], questions: [] };
     }
+    const lastTurnTs = boundedTurns.length > 0 ? new Date(boundedTurns[boundedTurns.length - 1].timestamp) : void 0;
+    const messageTimestamp = lastTurnTs && !isNaN(lastTurnTs.getTime()) ? lastTurnTs : void 0;
     const traceId = crypto.randomUUID();
     this.emit({ kind: "llm_start", traceId, model: this.config.model, operation: "extraction", input: conversation });
     const startTime = Date.now();
@@ -2477,7 +2612,7 @@ var ExtractionEngine = class {
           const durationMs = Date.now() - startTime;
           this.emit({ kind: "llm_end", traceId, model: this.config.localLlmModel, operation: "extraction", durationMs });
           log.debug(`extraction: used local LLM \u2014 ${localResult.facts.length} facts, ${localResult.entities.length} entities`);
-          const sanitized = this.sanitizeExtractionResult(localResult);
+          const sanitized = this.sanitizeExtractionResult(localResult, messageTimestamp);
           return await this.applyProactiveQuestionPass(conversation, sanitized);
         }
         if (!this.config.localLlmFallback) {
@@ -2500,7 +2635,7 @@ var ExtractionEngine = class {
           const durationMs = Date.now() - startTime;
           this.emit({ kind: "llm_end", traceId, model: this.config.model, operation: "extraction", durationMs });
           log.debug(`extraction: used direct client (${this.config.model}) \u2014 ${directResult.facts.length} facts, ${directResult.entities.length} entities`);
-          const sanitized = this.sanitizeExtractionResult(directResult);
+          const sanitized = this.sanitizeExtractionResult(directResult, messageTimestamp);
           return await this.applyProactiveQuestionPass(conversation, sanitized);
         }
         log.info("extraction: direct client returned no result, falling back to gateway AI");
@@ -2536,7 +2671,7 @@ var ExtractionEngine = class {
           ...result,
           questions: result.questions ?? [],
           identityReflection: result.identityReflection ?? void 0
-        });
+        }, messageTimestamp);
         return await this.applyProactiveQuestionPass(conversation, sanitized);
       }
       log.warn("extraction fallback returned no parsed output");