@joshuaswarren/openclaw-engram 8.3.71 → 8.3.73

package/dist/index.js

@@ -3650,7 +3650,11 @@ function getGlobalQmdState() {
       lastGlobalUpdateFailAtMs: null,
       lastGlobalEmbedRunAtMs: null,
       lastGlobalEmbedFailAtMs: null,
-      lastCliWarnAtMs: null
+      lastCliWarnAtMs: null,
+      lastUpdateByCollectionMs: {},
+      lastUpdateFailByCollectionMs: {},
+      lastEmbedByCollectionMs: {},
+      lastEmbedFailByCollectionMs: {}
     };
   }
   return g[QMD_GLOBAL_STATE_KEY];
@@ -4259,23 +4263,49 @@ ${stderr}`.trim();
     }
   }
   async update() {
+    await this.runUpdateForCollection(this.collection, { perCollectionThrottle: false });
+  }
+  async updateCollection(collection) {
+    await this.runUpdateForCollection(collection, { perCollectionThrottle: true });
+  }
+  async runUpdateForCollection(collection, options) {
     if (this.available === false) return;
+    const name = collection.trim();
+    if (!name) return;
     const globalState = getGlobalQmdState();
-    if (this.lastUpdateRunAtMs && Date.now() - this.lastUpdateRunAtMs < this.updateMinIntervalMs) {
-      log.debug("QMD update: suppressed due to min-interval gate");
-      return;
-    }
-    if (this.lastUpdateFailAtMs && Date.now() - this.lastUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
-      log.debug("QMD update: suppressed due to recent failures (backoff)");
-      return;
-    }
-    if (globalState.lastGlobalUpdateRunAtMs && Date.now() - globalState.lastGlobalUpdateRunAtMs < this.updateMinIntervalMs) {
-      log.debug("QMD update: suppressed by global min-interval gate");
-      return;
-    }
-    if (globalState.lastGlobalUpdateFailAtMs && Date.now() - globalState.lastGlobalUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
-      log.debug("QMD update: suppressed by global failure backoff");
-      return;
+    const now = Date.now();
+    if (options.perCollectionThrottle) {
+      if (globalState.lastGlobalUpdateFailAtMs && now - globalState.lastGlobalUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
+        log.debug("QMD update: suppressed by global failure backoff");
+        return;
+      }
+      const lastCollectionRun = globalState.lastUpdateByCollectionMs[name];
+      if (Number.isFinite(lastCollectionRun) && now - lastCollectionRun < this.updateMinIntervalMs) {
+        log.debug(`QMD update: suppressed by per-collection min-interval gate (${name})`);
+        return;
+      }
+      const lastCollectionFail = globalState.lastUpdateFailByCollectionMs[name];
+      if (Number.isFinite(lastCollectionFail) && now - lastCollectionFail < QMD_UPDATE_BACKOFF_MS) {
+        log.debug(`QMD update: suppressed by per-collection failure backoff (${name})`);
+        return;
+      }
+    } else {
+      if (this.lastUpdateRunAtMs && now - this.lastUpdateRunAtMs < this.updateMinIntervalMs) {
+        log.debug("QMD update: suppressed due to min-interval gate");
+        return;
+      }
+      if (this.lastUpdateFailAtMs && now - this.lastUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
+        log.debug("QMD update: suppressed due to recent failures (backoff)");
+        return;
+      }
+      if (globalState.lastGlobalUpdateRunAtMs && now - globalState.lastGlobalUpdateRunAtMs < this.updateMinIntervalMs) {
+        log.debug("QMD update: suppressed by global min-interval gate");
+        return;
+      }
+      if (globalState.lastGlobalUpdateFailAtMs && now - globalState.lastGlobalUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
+        log.debug("QMD update: suppressed by global failure backoff");
+        return;
+      }
     }
     try {
       if (!globalState.warnedGlobalUpdateBehavior) {
@@ -4285,21 +4315,31 @@ ${stderr}`.trim();
         );
       }
       const startedAtMs = Date.now();
-      await runQmd(["update", "-c", this.collection], this.updateTimeoutMs, this.qmdPath);
+      await runQmd(["update", "-c", name], this.updateTimeoutMs, this.qmdPath);
       const durationMs = Date.now() - startedAtMs;
       if (this.slowLog?.enabled && durationMs >= this.slowLog.thresholdMs) {
         log.warn(`SLOW QMD update: durationMs=${durationMs}`);
       }
-      const now = Date.now();
-      this.lastUpdateRunAtMs = now;
-      globalState.lastGlobalUpdateRunAtMs = now;
-      log.debug("QMD update completed");
+      const at = Date.now();
+      if (options.perCollectionThrottle) {
+        globalState.lastUpdateByCollectionMs[name] = at;
+        globalState.lastGlobalUpdateRunAtMs = at;
+      } else {
+        this.lastUpdateRunAtMs = at;
+        globalState.lastGlobalUpdateRunAtMs = at;
+      }
+      log.debug(`QMD update completed for collection=${name}`);
     } catch (err) {
-      const now = Date.now();
-      this.lastUpdateFailAtMs = now;
-      globalState.lastGlobalUpdateFailAtMs = now;
+      const at = Date.now();
+      if (options.perCollectionThrottle) {
+        globalState.lastUpdateFailByCollectionMs[name] = at;
+        globalState.lastGlobalUpdateFailAtMs = at;
+      } else {
+        this.lastUpdateFailAtMs = at;
+        globalState.lastGlobalUpdateFailAtMs = at;
+      }
       const msg = err instanceof Error ? err.message : String(err);
-      log.warn(`QMD update failed: ${msg}`);
+      log.warn(`QMD update failed for collection ${name}: ${msg}`);
     }
   }
   async embed() {
@@ -4334,6 +4374,39 @@ ${stderr}`.trim();
       log.warn(`QMD embed failed: ${msg}`);
     }
   }
+  async embedCollection(collection) {
+    if (this.available === false) return;
+    const name = collection.trim();
+    if (!name) return;
+    const globalState = getGlobalQmdState();
+    const now = Date.now();
+    if (globalState.lastGlobalEmbedFailAtMs && now - globalState.lastGlobalEmbedFailAtMs < QMD_EMBED_BACKOFF_MS) {
+      log.debug(`QMD embed: suppressed by global failure backoff (${name})`);
+      return;
+    }
+    const lastCollectionRun = globalState.lastEmbedByCollectionMs[name];
+    if (Number.isFinite(lastCollectionRun) && now - lastCollectionRun < this.updateMinIntervalMs) {
+      log.debug(`QMD embed: suppressed by per-collection min-interval gate (${name})`);
+      return;
+    }
+    const lastCollectionFail = globalState.lastEmbedFailByCollectionMs[name];
+    if (Number.isFinite(lastCollectionFail) && now - lastCollectionFail < QMD_EMBED_BACKOFF_MS) {
+      log.debug(`QMD embed: suppressed by per-collection failure backoff (${name})`);
+      return;
+    }
+    try {
+      await runQmd(["embed", "-c", name], 3e5, this.qmdPath);
+      const at = Date.now();
+      globalState.lastEmbedByCollectionMs[name] = at;
+      globalState.lastGlobalEmbedRunAtMs = at;
+    } catch (err) {
+      const at = Date.now();
+      globalState.lastEmbedFailByCollectionMs[name] = at;
+      globalState.lastGlobalEmbedFailAtMs = at;
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn(`QMD embed failed for collection ${name}: ${msg}`);
+    }
+  }
   async ensureCollection(memoryDir) {
     if (this.available === false && !this.daemonAvailable) return "unknown";
     if (this.available === false) return "skipped";
@@ -4364,7 +4437,7 @@ ${stderr}`.trim();
 };
 
 // src/storage.ts
-import { readdir, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, unlink, appendFile } from "fs/promises";
+import { readdir, readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, unlink, rename, appendFile } from "fs/promises";
 import { appendFileSync, mkdirSync as mkdirSync2, statSync } from "fs";
 import { createHash } from "crypto";
 import path4 from "path";
@@ -5579,6 +5652,86 @@ ${sanitized.text}
       return null;
     }
   }
+  resolveTierRootDir(tier) {
+    return tier === "cold" ? path4.join(this.baseDir, "cold") : this.baseDir;
+  }
+  resolveMemoryDateDir(memory) {
+    const preferred = memory.frontmatter.created || memory.frontmatter.updated;
+    const dateToken = (preferred ?? "").slice(0, 10);
+    return /^\d{4}-\d{2}-\d{2}$/.test(dateToken) ? dateToken : (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  }
+  isArtifactMemory(memory) {
+    if (memory.frontmatter.source === "artifact") return true;
+    if (memory.frontmatter.artifactType !== void 0) return true;
+    return /[\\/]artifacts[\\/]/.test(memory.path);
+  }
+  buildTierMemoryPath(memory, tier) {
+    const root = this.resolveTierRootDir(tier);
+    if (this.isArtifactMemory(memory)) {
+      return path4.join(root, "artifacts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+    }
+    if (memory.frontmatter.category === "correction") {
+      return path4.join(root, "corrections", `${memory.frontmatter.id}.md`);
+    }
+    return path4.join(root, "facts", this.resolveMemoryDateDir(memory), `${memory.frontmatter.id}.md`);
+  }
+  async writeMemoryFileAtomic(targetPath, memory) {
+    const fileContent = `${serializeFrontmatter(memory.frontmatter)}
+
+${memory.content}
+`;
+    await mkdir2(path4.dirname(targetPath), { recursive: true });
+    const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+      await writeFile2(tempPath, fileContent, "utf-8");
+      await rename(tempPath, targetPath);
+    } catch (err) {
+      try {
+        await unlink(tempPath);
+      } catch {
+      }
+      throw err;
+    }
+  }
+  async moveMemoryToPath(memory, targetPath) {
+    await this.writeMemoryFileAtomic(targetPath, memory);
+    const sourcePath = path4.resolve(memory.path);
+    const destPath = path4.resolve(targetPath);
+    if (sourcePath !== destPath) {
+      try {
+        await unlink(memory.path);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (!message.includes("ENOENT")) {
+          throw err;
+        }
+      }
+    }
+  }
+  async migrateMemoryToTier(memory, targetTier) {
+    const targetPath = this.buildTierMemoryPath(memory, targetTier);
+    const sourcePath = path4.resolve(memory.path);
+    const destPath = path4.resolve(targetPath);
+    if (sourcePath === destPath) {
+      return { changed: false, targetPath };
+    }
+    const existing = await this.readMemoryByPath(targetPath);
+    if (existing?.frontmatter.id === memory.frontmatter.id) {
+      try {
+        await unlink(memory.path);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (!message.includes("ENOENT")) {
+          throw err;
+        }
+      }
+      this.bumpMemoryStatusVersion();
+      return { changed: false, targetPath };
+    }
+    await this.moveMemoryToPath(memory, targetPath);
+    this.bumpMemoryStatusVersion();
+    return { changed: true, targetPath };
+  }
   get archiveDir() {
     return path4.join(this.baseDir, "archive");
   }
@@ -10614,16 +10767,22 @@ function resolveLifecycleState(frontmatter) {
 function computeHeat(memory, now, signals) {
   const frontmatter = memory.frontmatter;
   if (frontmatter.status === "archived") return 0;
-  const nowMs = now.getTime();
-  const confidence = confidenceTierWeight(frontmatter);
-  const access4 = accessWeight(frontmatter.accessCount);
-  const recency = recencyWeight(frontmatter, nowMs);
-  const importance = clamp01(frontmatter.importance?.score ?? 0.5);
-  const feedback = feedbackWeight(signals);
-  const disputedPenalty = frontmatter.verificationState === "disputed" ? 0.2 : 0;
-  const score = confidence * 0.25 + access4 * 0.3 + recency * 0.2 + importance * 0.15 + feedback * 0.1 - disputedPenalty;
+  const inputs = computeLifecycleValueInputs(memory, now, signals);
+  const score = inputs.confidence * 0.25 + inputs.access * 0.3 + inputs.recency * 0.2 + inputs.importance * 0.15 + inputs.feedback * 0.1 - inputs.disputedPenalty;
   return clamp01(score);
 }
+function computeLifecycleValueInputs(memory, now, signals) {
+  const frontmatter = memory.frontmatter;
+  const nowMs = now.getTime();
+  return {
+    confidence: confidenceTierWeight(frontmatter),
+    access: accessWeight(frontmatter.accessCount),
+    recency: recencyWeight(frontmatter, nowMs),
+    importance: clamp01(frontmatter.importance?.score ?? 0.5),
+    feedback: feedbackWeight(signals),
+    disputedPenalty: frontmatter.verificationState === "disputed" ? 0.2 : 0
+  };
+}
 function computeDecay(memory, now, signals) {
   const frontmatter = memory.frontmatter;
   if (frontmatter.status === "archived") return 1;