@remnic/core 9.3.723 → 9.3.725

package/dist/{chunk-LA3HZKES.js → chunk-KLFYKC3K.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-4T3BMHKD.js";
 import {
   MaintenanceScheduler
-} from "./chunk-Z4RU5VPM.js";
+} from "./chunk-J334N6QV.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
@@ -23,7 +23,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-WQYSDPMA.js";
+} from "./chunk-YQMPUYHE.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -166,8 +166,9 @@ import {
   shouldRecallEventOrderEvidence
 } from "./chunk-FIOYURII.js";
 import {
+  pickFactEventTimeAnchor,
   resolveFactEventTime
-} from "./chunk-M7R5R6OJ.js";
+} from "./chunk-IAIPNEHD.js";
 import {
   buildExplicitCueRecallSection
 } from "./chunk-4463LUIE.js";
@@ -184,7 +185,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-5O42UKXI.js";
+} from "./chunk-YUYPWJD3.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-EO5QWINU.js";
@@ -197,14 +198,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-EBDA5TYA.js";
+} from "./chunk-FXCIOLRB.js";
 import {
   ThreadingManager
 } from "./chunk-QRDOSYOR.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-YEE5KJQQ.js";
+} from "./chunk-T55EGZSJ.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -217,14 +218,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-PD42EYQN.js";
+} from "./chunk-5OPYYPJN.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-EXUCUPV2.js";
+} from "./chunk-WM7DNKBD.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-OHTOPFRF.js";
+} from "./chunk-SC2YAWRF.js";
 import {
   isAboveImportanceThreshold,
   scoreImportance
@@ -262,7 +263,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-NXRUUDUF.js";
+} from "./chunk-JJJCVCCQ.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -303,7 +304,7 @@ import {
   clusterByKey,
   createCorrectionService,
   detectPassiveCorrections
-} from "./chunk-VCLGUIFM.js";
+} from "./chunk-Z3FGC3QE.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -313,7 +314,7 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-GJSL4WG2.js";
+} from "./chunk-F3XZN24Z.js";
 import {
   NamespaceSearchRouter
 } from "./chunk-QR67FU5G.js";
@@ -372,7 +373,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-UO5ZHIIH.js";
+} from "./chunk-4WZ3J7M6.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -380,7 +381,7 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   parseEntityFile
-} from "./chunk-EVPNWN7Z.js";
+} from "./chunk-4R3CGCI5.js";
 import {
   buildRetiredFactTombstoneInputs
 } from "./chunk-L2B3EE7B.js";
@@ -414,7 +415,7 @@ import {
 } from "./chunk-SVOZFLIQ.js";
 import {
   confidenceTier
-} from "./chunk-ILFSEIRT.js";
+} from "./chunk-7AG54AF3.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -487,7 +488,7 @@ import {
 
 // src/orchestrator.ts
 import path3 from "path";
-import os from "os";
+import os2 from "os";
 import { createHash, randomBytes } from "crypto";
 import { existsSync, readFileSync } from "fs";
 import {
@@ -1800,6 +1801,291 @@ function extractSnippet(body, index, matchLength) {
   return `${prefix}${body.slice(start, end).replace(/\s+/g, " ").trim()}${suffix}`;
 }
 
+// src/recall/archive-scoring.ts
+import os from "os";
+import { Worker } from "worker_threads";
+function scoreArchiveMemories(items, tokens) {
+  if (items.length === 0 || tokens.length === 0) return [];
+  const scored = [];
+  for (const item of items) {
+    const haystack = [item.content, item.category, ...item.tags].join(" ").toLowerCase();
+    let hits = 0;
+    for (const token of tokens) {
+      if (haystack.includes(token)) hits += 1;
+    }
+    if (hits === 0) continue;
+    scored.push({
+      docid: item.id,
+      path: item.path,
+      score: hits / tokens.length,
+      snippet: item.content.slice(0, 400).replace(/\n/g, " ")
+    });
+  }
+  return scored;
+}
+function memoryFileToScoreItem(memory) {
+  return {
+    id: memory.frontmatter.id,
+    path: memory.path,
+    content: memory.content,
+    category: memory.frontmatter.category,
+    tags: memory.frontmatter.tags ?? []
+  };
+}
+var SyncArchiveScoring = class {
+  async score(items, tokens, abortSignal) {
+    if (items.length === 0 || tokens.length === 0) return [];
+    if (abortSignal?.aborted) return [];
+    const CHUNK = 500;
+    if (items.length <= CHUNK) return scoreArchiveMemories(items, tokens);
+    const results = [];
+    for (let i = 0; i < items.length; i += CHUNK) {
+      if (abortSignal?.aborted) return [];
+      const scored = scoreArchiveMemories(items.slice(i, i + CHUNK), tokens);
+      for (const r of scored) results.push(r);
+    }
+    return results;
+  }
+};
+var WORKER_SOURCE = String.raw`
+const { parentPort } = require('node:worker_threads');
+
+function scoreArchiveMemories(items, tokens) {
+  if (items.length === 0 || tokens.length === 0) return [];
+  var scored = [];
+  for (var i = 0; i < items.length; i++) {
+    var item = items[i];
+    var haystack = [item.content, item.category].concat(item.tags || []).join(' ').toLowerCase();
+    var hits = 0;
+    for (var j = 0; j < tokens.length; j++) {
+      if (haystack.indexOf(tokens[j]) !== -1) hits++;
+    }
+    if (hits === 0) continue;
+    scored.push({
+      docid: item.id,
+      path: item.path,
+      score: hits / tokens.length,
+      snippet: item.content.slice(0, 400).replace(/\n/g, ' '),
+    });
+  }
+  return scored;
+}
+
+if (parentPort) {
+  parentPort.on('message', function(task) {
+    try {
+      var results = scoreArchiveMemories(task.items, task.tokens);
+      parentPort.postMessage({ ok: true, results: results });
+    } catch (err) {
+      parentPort.postMessage({ ok: false, error: err && err.message ? err.message : String(err) });
+    }
+  });
+}
+`;
+function defaultPoolSize() {
+  const cpus = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
+  return Math.max(1, Math.min(Math.max(1, cpus - 1), 8));
+}
+var DISPATCH_TIMEOUT_MS = 12e4;
+var ArchiveScoringWorkerPool = class {
+  targetSize;
+  workers = [];
+  idle = [];
+  waiters = [];
+  terminated = false;
+  constructor(size = defaultPoolSize()) {
+    this.targetSize = Math.max(1, size);
+  }
+  async run(task, abortSignal) {
+    if (this.terminated) throw new Error("archive-scoring pool terminated");
+    const worker = await this.acquire(abortSignal);
+    if (abortSignal?.aborted) {
+      this.release(worker);
+      return [];
+    }
+    let abandoned = false;
+    try {
+      return await this.dispatch(worker, task, abortSignal, () => {
+        abandoned = true;
+      });
+    } finally {
+      if (abandoned) this.retireWorker(worker);
+      else this.release(worker);
+    }
+  }
+  async terminate() {
+    if (this.terminated) return;
+    this.terminated = true;
+    const queued = this.waiters;
+    this.waiters = [];
+    for (const w of queued) w.reject(new Error("archive-scoring pool terminated"));
+    const all = [...this.workers];
+    this.workers = [];
+    this.idle = [];
+    await Promise.allSettled(all.map((w) => w.terminate()));
+  }
+  async acquire(abortSignal) {
+    const idle = this.idle.pop();
+    if (idle) return idle;
+    if (this.workers.length < this.targetSize) return this.spawn();
+    return new Promise((resolve, reject) => {
+      const entry = { resolve, reject };
+      this.waiters.push(entry);
+      if (!abortSignal) return;
+      const onAbort = () => {
+        const idx = this.waiters.indexOf(entry);
+        if (idx !== -1) this.waiters.splice(idx, 1);
+        reject(new Error("archive-scoring acquire aborted"));
+      };
+      if (abortSignal.aborted) {
+        onAbort();
+        return;
+      }
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  release(worker) {
+    const next = this.waiters.shift();
+    if (next) {
+      next.resolve(worker);
+    } else if (!this.terminated) {
+      this.idle.push(worker);
+    } else {
+      void worker.terminate();
+    }
+  }
+  /** Terminate a worker that may still be busy, then spawn a replacement
+   *  if a waiter is queued. */
+  retireWorker(worker) {
+    const idx = this.workers.indexOf(worker);
+    if (idx !== -1) this.workers.splice(idx, 1);
+    void worker.terminate();
+    const next = this.waiters.shift();
+    if (next) next.resolve(this.spawn());
+  }
+  spawn() {
+    const worker = new Worker(WORKER_SOURCE, { eval: true });
+    worker.unref();
+    this.workers.push(worker);
+    return worker;
+  }
+  dispatch(worker, task, abortSignal, onAbandon) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        onAbandon();
+        log.debug(`archive-scoring dispatch timed out after ${DISPATCH_TIMEOUT_MS}ms \u2014 falling back to sync`);
+        reject(new Error(`archive-scoring dispatch timed out after ${DISPATCH_TIMEOUT_MS}ms`));
+      }, DISPATCH_TIMEOUT_MS);
+      const onMessage = (reply) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (reply.ok) resolve(reply.results);
+        else reject(new Error(reply.error));
+      };
+      const onError = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        onAbandon();
+        reject(err);
+      };
+      const onExit = (code) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        onAbandon();
+        reject(new Error(`archive-scoring worker exited with code ${code}`));
+      };
+      const onAbort = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        onAbandon();
+        resolve([]);
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        worker.off("message", onMessage);
+        worker.off("error", onError);
+        worker.off("exit", onExit);
+        abortSignal?.removeEventListener("abort", onAbort);
+      };
+      worker.on("message", onMessage);
+      worker.on("error", onError);
+      worker.on("exit", onExit);
+      abortSignal?.addEventListener("abort", onAbort, { once: true });
+      worker.postMessage(task);
+    });
+  }
+};
+var OffThreadArchiveScoring = class {
+  pool = null;
+  poolFailed = false;
+  syncFallback = new SyncArchiveScoring();
+  constructor(poolSize) {
+    if (poolSize !== void 0) {
+      this.pool = new ArchiveScoringWorkerPool(poolSize);
+    }
+  }
+  async score(items, tokens, abortSignal) {
+    if (items.length === 0 || tokens.length === 0) return [];
+    if (abortSignal?.aborted) return [];
+    if (this.pool === null && !this.poolFailed) {
+      try {
+        this.pool = new ArchiveScoringWorkerPool();
+      } catch (err) {
+        this.poolFailed = true;
+        log.debug(`archive-scoring: worker pool unavailable, using sync fallback \u2014 ${err.message}`);
+      }
+    }
+    if (this.pool !== null) {
+      const dispatchStart = Date.now();
+      try {
+        const task = {
+          items,
+          tokens
+        };
+        const results = await this.pool.run(task, abortSignal);
+        if (abortSignal?.aborted) return [];
+        return results;
+      } catch (err) {
+        if (abortSignal?.aborted) return [];
+        if (Date.now() - dispatchStart > DISPATCH_TIMEOUT_MS * 0.5) return [];
+        log.debug(`archive-scoring: worker dispatch failed, using sync fallback \u2014 ${err.message}`);
+      }
+    }
+    return this.syncFallback.score(items, tokens, abortSignal);
+  }
+  /** @internal — terminate the underlying pool (tests / shutdown). */
+  async terminate() {
+    if (this.pool !== null) {
+      await this.pool.terminate();
+      this.pool = null;
+    }
+  }
+};
+var defaultStrategy = null;
+function getDefaultArchiveScoring() {
+  if (defaultStrategy === null) {
+    defaultStrategy = new OffThreadArchiveScoring();
+  }
+  return defaultStrategy;
+}
+async function disposeDefaultArchiveScoring() {
+  if (defaultStrategy !== null) {
+    const strategy = defaultStrategy;
+    defaultStrategy = null;
+    if (strategy instanceof OffThreadArchiveScoring) {
+      await strategy.terminate();
+    }
+  }
+}
+
 // src/orchestrator.ts
 var BulkImportBatchPartialFailureError = class extends Error {
   partialResult;
@@ -2056,7 +2342,7 @@ async function qmdStartupCollectionCheckWithTimeout(promise, controller, label)
   return await Promise.race([checkedPromise, timeoutPromise]);
 }
 function defaultWorkspaceDir() {
-  return path3.join(os.homedir(), ".openclaw", "workspace");
+  return path3.join(os2.homedir(), ".openclaw", "workspace");
 }
 function sanitizeSessionKeyForFilename(sessionKey) {
   const readable = sessionKey.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -2795,6 +3081,7 @@ var Orchestrator = class _Orchestrator {
     if (this.conversationQmd && this.conversationQmd !== this.qmd) {
       await this.conversationQmd.dispose?.();
     }
+    await disposeDefaultArchiveScoring();
   }
   /** Set per-session workspace for the next recall() call (compaction reset). @internal */
   setRecallWorkspaceOverride(sessionKey, dir) {
@@ -3261,6 +3548,81 @@ var Orchestrator = class _Orchestrator {
     );
     index.remove(memory.content);
   }
+  /**
+   * Issue #1671 — backfill bi-temporal bounds onto an existing promoted/deduped
+   * copy that was written BEFORE the source fact carried a resolved
+   * `invalid_at`/`observedAt`/`eventTimeSource`.
+   *
+   * On re-extraction/backfill, a fact may now carry a resolved end bound (e.g.
+   * "until June 2025") that the existing copy lacks because it was promoted
+   * before bi-temporal wiring existed. Without this backfill, recall keeps
+   * surfacing an expired fact even though the source copy now expires correctly.
+   *
+   * Finds the active fact in `targetStorage` matching `dedupContent`, then
+   * patches the temporal frontmatter the existing copy is missing. Best-effort
+   * / fail-open — any I/O error is logged and swallowed so the dedup
+   * short-circuit is never blocked by a backfill failure.
+   *
+   * Matching: the stored `frontmatter.contentHash` is compared against
+   * `ContentHashIndex.computeHash(dedupContent)` first (the exact hash the
+   * content-hash index uses), then falls back to stripping citations and
+   * comparing normalized bodies. This handles inline-attribution deployments
+   * where the persisted body carries a citation marker the dedup key does not.
+   *
+   * I/O gate: only triggers when `invalidAt` is present (the end bound that
+   * actually changes recall behavior by expiring the fact). `observedAt` and
+   * `eventTimeSource` alone don'\''t expire a fact, so backfilling them without
+   * an end bound would cause a full readAllMemories scan on every dedup hit
+   * under biTemporal for no recall benefit.
+   *
+   * Only patches fields the existing copy LACKS — never overwrites a bound the
+   * copy already carries.
+   */
+  async backfillTemporalBoundsOnDedupHit(targetStorage, dedupContent, bounds, entityRef) {
+    if (!bounds.invalidAt) return;
+    try {
+      const incomingHash = ContentHashIndex.computeHash(dedupContent);
+      const normalizedIncoming = ContentHashIndex.normalizeContent(dedupContent);
+      const incomingEntityNorm = entityRef ? normalizeSupersessionKey(entityRef) : void 0;
+      const all = await targetStorage.readAllMemories();
+      const existing = all.find((m) => {
+        if (m.frontmatter.category !== "fact") return false;
+        if ((m.frontmatter.status ?? "active") !== "active") return false;
+        if (incomingEntityNorm && m.frontmatter.entityRef && normalizeSupersessionKey(m.frontmatter.entityRef) !== incomingEntityNorm) {
+          return false;
+        }
+        if (m.frontmatter.contentHash) {
+          return m.frontmatter.contentHash === incomingHash;
+        }
+        return ContentHashIndex.normalizeContent(
+          stripCitationForTemplate(m.content ?? "", this.config.inlineSourceAttributionFormat)
+        ) === normalizedIncoming;
+      });
+      if (!existing) return;
+      const patch = {};
+      const fm = existing.frontmatter;
+      if (bounds.invalidAt && (!fm.invalid_at || fm.invalid_at.length === 0)) {
+        patch.invalid_at = bounds.invalidAt;
+      }
+      if (bounds.observedAt && (!fm.observedAt || fm.observedAt.length === 0)) {
+        patch.observedAt = bounds.observedAt;
+      }
+      if (bounds.eventTimeSource && (!fm.eventTimeSource || fm.eventTimeSource.length === 0)) {
+        patch.eventTimeSource = bounds.eventTimeSource;
+      }
+      if (Object.keys(patch).length === 0) return;
+      const ok = await targetStorage.writeMemoryFrontmatter(existing, patch);
+      if (ok) {
+        log.debug(
+          `bitemporal-backfill: patched ${Object.keys(patch).join(",")} onto existing fact ${fm.id ?? "(unknown)"} in ${targetStorage.dir}`
+        );
+      }
+    } catch (err) {
+      log.warn(
+        `bitemporal-backfill: failed open for ${targetStorage.dir}: ${err}`
+      );
+    }
+  }
   async saveContentHashIndexes() {
     const indexes = /* @__PURE__ */ new Set();
     if (this.contentHashIndex) indexes.add(this.contentHashIndex);
@@ -4295,7 +4657,7 @@ ${doc.content}` : doc.content,
   async runDeepSleepGovernanceNow(options) {
     const targetStorage = options?.storage ?? this.storage;
     const { runMemoryGovernance } = await import("./maintenance/memory-governance.js");
-    const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-3WSCI5V4.js");
+    const { summarizeGovernanceResultForDreams } = await import("./dreams-ledger-6UODQOX6.js");
     const govResult = await runMemoryGovernance({
       memoryDir: targetStorage.dir,
       mode: options?.dryRun === true ? "shadow" : "apply"
@@ -11555,6 +11917,18 @@ ${normalized}`).digest("hex");
           const targetStorage = await this.storageRouter.storageFor(target.namespace);
           if (targetStorage.dir === options.sourceStorage.dir) continue;
           if (options.category === "fact" && await targetStorage.hasFactContentHash(dedupContent)) {
+            if (options.invalidAt) {
+              await this.backfillTemporalBoundsOnDedupHit(
+                targetStorage,
+                dedupContent,
+                {
+                  invalidAt: options.invalidAt,
+                  ...options.observedAt ? { observedAt: options.observedAt } : {},
+                  ...options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}
+                },
+                options.entityRef
+              );
+            }
             continue;
           }
           const promotedId = await targetStorage.writeMemory(
@@ -11637,6 +12011,18 @@ ${normalized}`).digest("hex");
         const dedupContent = options.category === "fact" && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0 ? `${sanitizedBase.text}
 [Attributes: ${normalizeAttributePairs(options.structuredAttributes)}]` : sanitizedBase.text;
         if (options.category === "fact" && await sharedStorage.hasFactContentHash(dedupContent)) {
+          if (options.invalidAt) {
+            await this.backfillTemporalBoundsOnDedupHit(
+              sharedStorage,
+              dedupContent,
+              {
+                invalidAt: options.invalidAt,
+                ...options.observedAt ? { observedAt: options.observedAt } : {},
+                ...options.eventTimeSource ? { eventTimeSource: options.eventTimeSource } : {}
+              },
+              options.entityRef
+            );
+          }
           if (this.config.temporalSupersessionEnabled && options.entityRef && options.structuredAttributes && Object.keys(options.structuredAttributes).length > 0) {
             let hashDedupMatchingFact;
             let hashDedupLookupComplete = false;
@@ -11969,7 +12355,8 @@ ${normalized}`).digest("hex");
       }
       fact.tags = Array.isArray(fact.tags) ? fact.tags.filter((t) => typeof t === "string") : [];
       fact.confidence = typeof fact.confidence === "number" ? fact.confidence : 0.7;
-      const biTemporal = this.config.temporalBiTemporal && sourceContext?.validAt ? resolveFactEventTime(fact.eventTime, sourceContext.validAt) : void 0;
+      const factAnchor = pickFactEventTimeAnchor(fact, sourceContext?.validAt);
+      const biTemporal = this.config.temporalBiTemporal && factAnchor ? resolveFactEventTime(fact.eventTime, factAnchor) : void 0;
       let writeCategory = fact.category;
       let targetStorage = storage;
       let targetNamespaceName = baseNamespace && baseNamespace.length > 0 ? baseNamespace : this.storageDirNamespace(targetStorage.dir);
@@ -12022,6 +12409,11 @@ ${normalized}`).digest("hex");
       }
       const canonicalContentForHash = citationEnabled && hasCitationForTemplate(fact.content, citationTemplate) ? stripCitationForTemplate(fact.content, citationTemplate) : fact.content;
       const contentHashDedupKey = writeCategory === "procedure" ? buildProcedurePersistBody(fact.content, fact.procedureSteps) : canonicalContentForHash;
+      const importance = scoreImportance(
+        fact.content,
+        writeCategory,
+        fact.tags
+      );
       let exactDuplicate = false;
       try {
         exactDuplicate = await this.hasContentHashDedup(
@@ -12034,17 +12426,31 @@ ${normalized}`).digest("hex");
         );
       }
       if (exactDuplicate) {
+        if (biTemporal && biTemporal.validUntil) {
+          const fr = faithfulnessResultsByFactIndex?.get(factLoopIndex);
+          const faithfulnessWouldPending = faithfulnessMode === "enforce" && fr?.ok === true && (fr.verdict === "unsupported" || fr.verdict === "contradicted");
+          const requireSpansWouldPending = this.config.provenance?.requireSpans === true && fact.requireSpansPending === true;
+          const judgeVerdict = judgeVerdictsByFactIndex?.get(factLoopIndex);
+          const judgeWouldGate = !this.config.extractionJudgeShadow && judgeVerdict !== void 0 && !judgeVerdict.durable;
+          if (isAboveImportanceThreshold(importance.level, this.config.extractionMinImportanceLevel) && !faithfulnessWouldPending && !requireSpansWouldPending && !judgeWouldGate) {
+            await this.backfillTemporalBoundsOnDedupHit(
+              targetStorage,
+              contentHashDedupKey,
+              {
+                invalidAt: biTemporal.validUntil,
+                observedAt: biTemporal.observedAt,
+                eventTimeSource: biTemporal.eventTimeSource
+              },
+              fact.entityRef
+            );
+          }
+        }
         log.debug(
           `dedup: skipping duplicate fact "${fact.content.slice(0, 60)}\u2026" in storage ${targetStorage.dir}`
         );
         dedupedCount++;
         continue;
       }
-      const importance = scoreImportance(
-        fact.content,
-        writeCategory,
-        fact.tags
-      );
       if (writeCategory === "procedure" && this.config.procedural?.enabled !== true) {
         log.debug("persistExtraction: skip procedure memory (procedural.enabled is false)");
         continue;
@@ -13534,7 +13940,7 @@ ${texts.map((t, i) => `[${i + 1}] ${t}`).join("\n\n")}`;
   }
   async recordScheduledDreamsPhaseRun(phase, itemsProcessed, notes, timing = {}) {
     try {
-      const { recordDreamsPhaseRun } = await import("./dreams-ledger-3WSCI5V4.js");
+      const { recordDreamsPhaseRun } = await import("./dreams-ledger-6UODQOX6.js");
       await recordDreamsPhaseRun({
         memoryDir: this.storage.dir,
         phase,
@@ -14701,27 +15107,16 @@ ${lines.join("\n\n")}`;
     throwIfRecallAborted(abortSignal);
     const archivedMemories = await this.readArchivedMemoriesForNamespaces(recallNamespaces);
     if (archivedMemories.length === 0) return scopedSeedResults;
-    const scored = [];
-    for (const memory of archivedMemories) {
-      throwIfRecallAborted(abortSignal);
-      const haystack = [
-        memory.content,
-        memory.frontmatter.category,
-        ...memory.frontmatter.tags ?? []
-      ].join(" ").toLowerCase();
-      let hits = 0;
-      for (const token of tokens) {
-        if (haystack.includes(token)) hits += 1;
-      }
-      if (hits === 0) continue;
-      const normalized = hits / tokens.length;
-      scored.push({
-        docid: memory.frontmatter.id,
-        path: memory.path,
-        score: normalized,
-        snippet: memory.content.slice(0, 400).replace(/\n/g, " ")
-      });
-    }
+    throwIfRecallAborted(abortSignal);
+    const scoring = getDefaultArchiveScoring();
+    const scoredResults = await scoring.score(archivedMemories.map(memoryFileToScoreItem), tokens, abortSignal);
+    throwIfRecallAborted(abortSignal);
+    const scored = scoredResults.map((r) => ({
+      docid: r.docid,
+      path: r.path,
+      score: r.score,
+      snippet: r.snippet
+    }));
     const mergedByPath = /* @__PURE__ */ new Map();
     for (const result of [...scopedSeedResults, ...scored]) {
       const key = result.path || result.docid;
@@ -14845,6 +15240,9 @@ ${lines.join("\n\n")}`;
       }
     }
     if (longTerm.length === 0) {
+      const da = new AbortController();
+      if (options.abortSignal?.aborted) da.abort();
+      else options.abortSignal?.addEventListener("abort", () => da.abort(), { once: true });
       longTerm = await runColdStepWithinDeadline(
         "archive scan",
         [],
@@ -14853,8 +15251,9 @@ ${lines.join("\n\n")}`;
           options.recallNamespaces,
           options.recallResultLimit,
           options.queryAwarePrefilter,
-          options.abortSignal
-        )
+          da.signal
+        ),
+        () => da.abort()
       );
       if (longTerm.length > 0) {
         log.debug("cold-tier recall source=archive-scan");
@@ -15793,4 +16192,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-LA3HZKES.js.map
+//# sourceMappingURL=chunk-KLFYKC3K.js.map