@remnic/core 9.3.636 → 9.3.638

package/dist/{chunk-TFICNXXU.js → chunk-TJRV4MWX.js}

@@ -29,7 +29,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-UXFOGILU.js";
+} from "./chunk-QDAWVW75.js";
 import {
   SharedContextManager
 } from "./chunk-DRD2Q7HQ.js";
@@ -64,7 +64,7 @@ import {
 } from "./chunk-VOUOLGIP.js";
 import {
   HourlySummarizer
-} from "./chunk-HZVIYZYN.js";
+} from "./chunk-7KRYJUTB.js";
 import {
   SessionObserverState
 } from "./chunk-MHQC2WU2.js";
@@ -113,7 +113,7 @@ import {
   LastRecallStore,
   TierMigrationStatusStore,
   clampGraphRecallExpandedEntries
-} from "./chunk-2IT7WFYE.js";
+} from "./chunk-FWIROLS6.js";
 import {
   buildQmdRecallCacheKey,
   getCachedQmdRecall,
@@ -231,7 +231,7 @@ import {
 } from "./chunk-ZRWB5D4H.js";
 import {
   TranscriptManager
-} from "./chunk-A6D7A2FW.js";
+} from "./chunk-IHG27THY.js";
 import {
   NamespaceStorageRouter
 } from "./chunk-LEG7XWS2.js";
@@ -308,6 +308,9 @@ import {
   listTrustZoneRecords,
   searchTrustZoneRecords
 } from "./chunk-JGSKJHF7.js";
+import {
+  isPathInsideStorageRoot
+} from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
 } from "./chunk-YQNADJCT.js";
@@ -345,7 +348,7 @@ import {
 } from "./chunk-H3PHZLMF.js";
 import {
   GraphIndex
-} from "./chunk-XL7FK7PJ.js";
+} from "./chunk-Y56J7CXW.js";
 import {
   buildChainFollowupGenerator
 } from "./chunk-CMN5AWAZ.js";
@@ -387,7 +390,7 @@ import {
 } from "./chunk-FVQJYWH7.js";
 import {
   searchCausalTrajectories
-} from "./chunk-TQOU3VAT.js";
+} from "./chunk-SSOMTUCA.js";
 import {
   canReadNamespace,
   defaultNamespaceForPrincipal,
@@ -416,6 +419,9 @@ import {
   keyring_exports,
   secureStoreDir
 } from "./chunk-BJMBJZ2Y.js";
+import {
+  SecureStoreLockedError
+} from "./chunk-ILXTATKK.js";
 import {
   parseFlexibleIsoTimestamp
 } from "./chunk-P7FMDTKL.js";
@@ -1633,6 +1639,42 @@ async function raceRecallAbort(promise, signal, message = "recall aborted") {
     }
   }
 }
+function qmdCollectionPathParts(resultPath) {
+  if (!resultPath || path2.isAbsolute(resultPath)) return null;
+  const normalized = resultPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  const slashIndex = normalized.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= normalized.length - 1) return null;
+  const collection = normalized.slice(0, slashIndex);
+  if (/^\d{4}-\d{2}-\d{2}$/.test(collection)) return null;
+  return {
+    collection,
+    relativePath: normalized.slice(slashIndex + 1)
+  };
+}
+function qmdResultPathCandidates(storageDir, resultPath) {
+  const candidates = /* @__PURE__ */ new Set();
+  const storageRoot = path2.resolve(storageDir);
+  const addCandidate = (candidate) => {
+    const resolved = path2.resolve(candidate);
+    if (isPathInsideStorageRoot(storageRoot, resolved)) {
+      candidates.add(resolved);
+    }
+  };
+  const addRelativeCandidates = (relativePath) => {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized) return;
+    addCandidate(path2.join(storageRoot, normalized));
+    if (/^\d{4}-\d{2}-\d{2}\//.test(normalized)) {
+      addCandidate(path2.join(storageRoot, "facts", normalized));
+    }
+  };
+  if (path2.isAbsolute(resultPath)) {
+    addCandidate(resultPath);
+  } else {
+    addRelativeCandidates(resultPath);
+  }
+  return [...candidates];
+}
 var COMPACTION_SIGNAL_MAX_AGE_MS = 60 * 60 * 1e3;
 var DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 1e4;
 function qmdStartupCollectionCheckTimeoutMs() {
@@ -5334,16 +5376,74 @@ ${r.snippet.trim()}
     return capped;
   }
   async expandResultsViaGraph(options) {
+    const deadlineExpired = () => typeof options.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
     const byNamespace = /* @__PURE__ */ new Map();
-    for (const result of options.memoryResults) {
-      const ns = this.namespaceFromPath(result.path);
-      if (!options.recallNamespaces.includes(ns)) continue;
-      const existing = byNamespace.get(ns);
+    const addResultForNamespace = (namespace, result) => {
+      const existing = byNamespace.get(namespace);
       if (existing) {
         existing.push(result);
       } else {
-        byNamespace.set(ns, [result]);
+        byNamespace.set(namespace, [result]);
       }
+    };
+    const resolvedAmbiguousSeeds = /* @__PURE__ */ new Map();
+    const resolveAmbiguousSeedOwner = async (result, parts) => {
+      const cached = resolvedAmbiguousSeeds.get(result.path);
+      if (cached !== void 0) return cached;
+      if (deadlineExpired()) {
+        resolvedAmbiguousSeeds.set(result.path, null);
+        return null;
+      }
+      let resolvedPath = result.path;
+      let resolvedResult = result;
+      if (parts) {
+        const resolvedCold = await this.resolveColdQmdResultForRecall(
+          result,
+          this.storage,
+          options.recallNamespaces
+        );
+        if (!resolvedCold || deadlineExpired()) {
+          resolvedAmbiguousSeeds.set(result.path, null);
+          return null;
+        }
+        resolvedPath = resolvedCold.result.path;
+        resolvedResult = resolvedCold.result;
+      }
+      if (!path2.isAbsolute(resolvedPath)) {
+        resolvedAmbiguousSeeds.set(result.path, null);
+        return null;
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resolvedPath,
+        this.storage,
+        options.recallNamespaces
+      );
+      const ownerNamespace = ownerStorage?.namespace ?? null;
+      const resolved = ownerNamespace && options.recallNamespaces.includes(ownerNamespace) ? { namespace: ownerNamespace, result: resolvedResult } : null;
+      resolvedAmbiguousSeeds.set(result.path, resolved);
+      return resolved;
+    };
+    const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
+    for (const result of options.memoryResults) {
+      if (deadlineExpired()) break;
+      const parts = qmdCollectionPathParts(result.path);
+      if (parts?.collection === coldCollection) {
+        const resolved = await resolveAmbiguousSeedOwner(result, parts);
+        if (resolved) {
+          addResultForNamespace(resolved.namespace, resolved.result);
+        }
+        continue;
+      }
+      if (path2.isAbsolute(result.path)) {
+        const resolved = await resolveAmbiguousSeedOwner(result, null);
+        if (resolved) {
+          addResultForNamespace(resolved.namespace, resolved.result);
+        }
+        continue;
+      }
+      const ns = this.namespaceFromPath(result.path);
+      if (!options.recallNamespaces.includes(ns)) continue;
+      addResultForNamespace(ns, result);
     }
     const perNamespaceSeedCap = Math.max(3, options.recallResultLimit);
     const perNamespaceExpandedCap = Math.max(8, options.recallResultLimit * 2);
@@ -5352,12 +5452,25 @@ ${r.snippet.trim()}
     const expandedPaths = [];
     const expandedResults = [];
     for (const [namespace, nsResults] of byNamespace.entries()) {
+      if (deadlineExpired()) break;
       const storage = await this.storageRouter.storageFor(namespace);
       const seedCandidates = nsResults.slice(0, perNamespaceSeedCap);
       seedResults.push(...seedCandidates);
-      const seedRelativePaths = seedCandidates.map((result) => graphPathRelativeToStorage(storage.dir, result.path)).filter(
+      const seedRelativePaths = typeof options.deadlineAtMs === "number" ? await this.graphSeedPathsWithinDeadline(
+        storage,
+        seedCandidates,
+        options.deadlineAtMs,
+        [namespace]
+      ) : (await Promise.all(
+        seedCandidates.map(
+          (result) => this.graphSeedPathRelativeToStorage(storage, result, [
+            namespace
+          ])
+        )
+      )).filter(
         (value) => typeof value === "string" && value.length > 0
       );
+      if (deadlineExpired()) break;
       if (seedRelativePaths.length === 0) continue;
       const seedRecallScore = seedCandidates.reduce(
         (max, item) => Math.max(max, item.score),
@@ -5370,13 +5483,19 @@ ${r.snippet.trim()}
       const expanded = await this.graphIndexFor(storage).spreadingActivation(
         seedRelativePaths,
         this.config.maxGraphTraversalSteps,
-        options.includeLowConfidence === true ? { includeLowConfidence: true } : void 0
+        {
+          ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {},
+          ...typeof options.deadlineAtMs === "number" ? { deadlineAtMs: options.deadlineAtMs } : {}
+        }
       );
       if (expanded.length === 0) continue;
+      if (deadlineExpired()) break;
       for (const candidate of expanded.slice(0, perNamespaceExpandedCap)) {
+        if (deadlineExpired()) break;
         if (seedSet.has(candidate.path)) continue;
         const memoryPath = path2.resolve(storage.dir, candidate.path);
         const memory = await storage.readMemoryByPath(memoryPath);
+        if (deadlineExpired()) break;
         if (!memory) continue;
         if (isArtifactMemoryPath(memory.path)) continue;
         if (memory.frontmatter.status && memory.frontmatter.status !== "active")
@@ -7505,10 +7624,12 @@ ${formatted}`;
           return section;
         })()
       );
-      const recentBoxesPromise = this.isRecallSectionEnabled(
-        "memory-boxes",
-        this.config.memoryBoxesEnabled === true
-      ) && this.config.memoryBoxesEnabled && this.config.boxRecallDays > 0 ? this.boxBuilderFor(profileStorage).readRecentBoxes(this.config.boxRecallDays).catch(() => []) : Promise.resolve([]);
+      const recentBoxesPromise = observeEnrichmentPromise(
+        this.isRecallSectionEnabled(
+          "memory-boxes",
+          this.config.memoryBoxesEnabled === true
+        ) && this.config.memoryBoxesEnabled && this.config.boxRecallDays > 0 ? this.boxBuilderFor(profileStorage).readRecentBoxes(this.config.boxRecallDays).catch(() => []) : Promise.resolve([])
+      );
       this.profiler.startSpan("phase-1-parallel", profileTraceId);
       const phase1Start = Date.now();
       log.info(
@@ -7637,6 +7758,48 @@ ${formatted}`;
         }
         return finalizeEnrichmentOutcome(outcome);
       };
+      const remainingEnrichmentAssemblyMs = () => enrichmentAssemblyDeadlineAtMs === null ? null : Math.max(0, enrichmentAssemblyDeadlineAtMs - Date.now());
+      const awaitAssemblyStep = async (name, task, fallback) => {
+        if (options.abortSignal?.aborted) {
+          log.debug(
+            `recall phase-1 assembly [${name}]: skipped after abort at +${Date.now() - phase1Start}ms`
+          );
+          return fallback;
+        }
+        const timeoutMs = remainingEnrichmentAssemblyMs();
+        if (timeoutMs === 0) {
+          log.debug(
+            `recall phase-1 assembly [${name}]: skipped after shared ${enrichmentSectionDeadlineMs}ms budget expired at +${Date.now() - phase1Start}ms`
+          );
+          return fallback;
+        }
+        let timeoutHandle;
+        try {
+          const result = await (timeoutMs !== null ? Promise.race([
+            task(),
+            new Promise((resolve) => {
+              timeoutHandle = setTimeout(
+                () => resolve({ status: "timed_out" }),
+                timeoutMs
+              );
+            })
+          ]) : task());
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+          if (typeof result === "object" && result !== null && "status" in result && result.status === "timed_out") {
+            log.debug(
+              `recall phase-1 assembly [${name}]: timed out within shared ${enrichmentSectionDeadlineMs}ms budget at +${Date.now() - phase1Start}ms`
+            );
+            return fallback;
+          }
+          return result;
+        } catch (err) {
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+          log.warn(
+            `recall phase-1 assembly [${name}] failed open: ${err instanceof Error ? err.message : String(err)}`
+          );
+          return fallback;
+        }
+      };
       this.profiler.startSpan("assembly", profileTraceId);
       if (sharedCtx)
         this.appendRecallSection(sectionBuckets, "shared-context", sharedCtx);
@@ -7855,8 +8018,11 @@ ${lines.join("\n")}`
         );
       }
       {
-        const recentBoxes = await recentBoxesPromise;
-        if (recentBoxes.length > 0) {
+        const recentBoxes = await awaitEnrichmentSection(
+          "memory-boxes",
+          recentBoxesPromise
+        );
+        if (recentBoxes && recentBoxes.length > 0) {
           const boxLines = recentBoxes.slice(0, 5).map((b) => {
             const sealedDate = b.sealedAt ? b.sealedAt.slice(0, 16).replace("T", " ") : "?";
             const traceNote = b.traceId ? ` [trace: ${b.traceId.slice(0, 12)}]` : "";
@@ -7986,6 +8152,7 @@ ${tmtNode.summary}`
           workProductsSection
         );
       }
+      const qmdWasSettledBeforeAssemblyWait = qmdPromise.getSettledOutcome() !== void 0;
       const qmdResult = await awaitEnrichmentSection("qmd", qmdPromise);
       if (qmdResult) {
         const t0 = Date.now();
@@ -8032,48 +8199,69 @@ ${tmtNode.summary}`
             graphExpandedResultPaths.clear();
           } else {
             try {
-              const {
-                merged,
-                seedPaths,
-                expandedPaths,
-                seedResults = baselineMemoryResults
-              } = await this.expandResultsViaGraph({
-                memoryResults,
-                recallNamespaces,
-                recallResultLimit,
-                ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
-              });
-              graphSnapshotStatus = "completed";
-              graphDecisionStatus = "completed";
-              graphDecisionReason = graphShadowEvalEnabled ? "graph shadow evaluation completed without altering injected context" : "graph expansion merged into recall ranking";
-              graphSnapshotReason = graphDecisionReason;
-              graphSnapshotSeedPaths = seedPaths;
-              graphSnapshotExpandedPaths = expandedPaths;
-              graphSnapshotSeedResults = this.buildGraphRecallRankedResults(
-                seedResults,
-                () => ["baseline"]
-              );
-              graphExpandedResultPaths.clear();
-              expandedPaths.forEach(
-                (entry) => graphExpandedResultPaths.add(entry.path)
+              const graphExpansion = await awaitAssemblyStep(
+                "graph-expansion",
+                () => this.expandResultsViaGraph({
+                  memoryResults,
+                  recallNamespaces,
+                  recallResultLimit,
+                  deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
+                  ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
+                }),
+                null
               );
-              memoryResults = graphShadowEvalEnabled ? baselineMemoryResults : merged;
-              if (graphShadowEvalEnabled) {
-                const comparison = summarizeGraphShadowComparison(
+              if (!graphExpansion) {
+                graphSnapshotStatus = "aborted";
+                graphDecisionStatus = "aborted";
+                graphDecisionReason = options.abortSignal?.aborted ? "graph expansion skipped because recall assembly was aborted" : "graph expansion skipped because shared post-retrieval assembly budget expired";
+                graphSnapshotReason = graphDecisionReason;
+                graphSnapshotSeedPaths = baselineMemoryResults.slice(0, Math.max(1, recallResultLimit)).map((result) => result.path);
+                graphSnapshotSeedResults = this.buildGraphRecallRankedResults(
                   baselineMemoryResults,
+                  () => ["baseline"]
+                );
+                graphSnapshotExpandedPaths = [];
+                graphExpandedResultPaths.clear();
+                memoryResults = baselineMemoryResults;
+              } else {
+                const {
                   merged,
-                  recallResultLimit
+                  seedPaths,
+                  expandedPaths,
+                  seedResults = baselineMemoryResults
+                } = graphExpansion;
+                graphSnapshotStatus = "completed";
+                graphDecisionStatus = "completed";
+                graphDecisionReason = graphShadowEvalEnabled ? "graph shadow evaluation completed without altering injected context" : "graph expansion merged into recall ranking";
+                graphSnapshotReason = graphDecisionReason;
+                graphSnapshotSeedPaths = seedPaths;
+                graphSnapshotExpandedPaths = expandedPaths;
+                graphSnapshotSeedResults = this.buildGraphRecallRankedResults(
+                  seedResults,
+                  () => ["baseline"]
                 );
-                graphSnapshotShadowComparison = comparison;
-                recordRecallSectionMetric({
-                  section: "graphShadow",
-                  priority: "enrichment",
-                  durationMs: Date.now() - t0,
-                  deadlineMs: enrichmentSectionDeadlineMs,
-                  source: "fresh",
-                  success: true,
-                  timing: `on b=${comparison.baselineCount} g=${comparison.graphCount} ov=${comparison.overlapCount} (${comparison.overlapRatio.toFixed(2)}) avgDelta=${comparison.averageOverlapDelta.toFixed(3)}`
-                });
+                graphExpandedResultPaths.clear();
+                expandedPaths.forEach(
+                  (entry) => graphExpandedResultPaths.add(entry.path)
+                );
+                memoryResults = graphShadowEvalEnabled ? baselineMemoryResults : merged;
+                if (graphShadowEvalEnabled) {
+                  const comparison = summarizeGraphShadowComparison(
+                    baselineMemoryResults,
+                    merged,
+                    recallResultLimit
+                  );
+                  graphSnapshotShadowComparison = comparison;
+                  recordRecallSectionMetric({
+                    section: "graphShadow",
+                    priority: "enrichment",
+                    durationMs: Date.now() - t0,
+                    deadlineMs: enrichmentSectionDeadlineMs,
+                    source: "fresh",
+                    success: true,
+                    timing: `on b=${comparison.baselineCount} g=${comparison.graphCount} ov=${comparison.overlapCount} (${comparison.overlapRatio.toFixed(2)}) avgDelta=${comparison.averageOverlapDelta.toFixed(3)}`
+                  });
+                }
               }
             } catch (err) {
               graphSnapshotStatus = "aborted";
@@ -8092,12 +8280,31 @@ ${tmtNode.summary}`
             }
           }
         }
-        memoryResults = await this.boostSearchResults(
+        const qmdBoostInput = await this.filterSearchResultsForRecall(
           memoryResults,
-          recallNamespaces,
-          retrievalQuery,
           void 0,
-          { asOfMs }
+          {
+            asOfMs,
+            // If QMD had already settled before the ordered assembly reached it,
+            // do not let unrelated slow enrichment turn those known results into
+            // unchecked misses. QMD that only settles during its own wait remains
+            // bounded by the shared post-retrieval assembly deadline.
+            deadlineAtMs: qmdWasSettledBeforeAssemblyWait ? null : enrichmentAssemblyDeadlineAtMs,
+            abortSignal: options.abortSignal,
+            dropUnresolved: true,
+            recallNamespaces
+          }
+        );
+        memoryResults = await awaitAssemblyStep(
+          "qmd-boost",
+          () => this.boostSearchResults(
+            qmdBoostInput.results,
+            recallNamespaces,
+            retrievalQuery,
+            qmdBoostInput.memoryByPath,
+            { asOfMs }
+          ),
+          qmdBoostInput.results
         );
         if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
           const ranked = await rerankLocalOrNoop({
@@ -8224,39 +8431,45 @@ ${tmtNode.summary}`
         } else if (!confidenceGateRejected) {
           const queryAwarePrefilter = await queryAwarePrefilterPromise;
           if (queryAwarePrefilter.candidatePaths?.size !== 0) {
-            const embeddingResults = await this.searchEmbeddingFallback(
-              retrievalQuery,
-              embeddingFetchLimit
-            );
-            const prefilteredEmbeddingResults = applyQueryAwareCandidateFilter(
-              embeddingResults,
-              queryAwarePrefilter.candidatePaths
-            );
-            const scopedCandidates = filterRecallCandidates(
-              prefilteredEmbeddingResults,
-              {
-                namespacesEnabled: this.config.namespacesEnabled,
-                recallNamespaces,
-                resolveNamespace: (p) => this.namespaceFromPath(p),
-                limit: embeddingFetchLimit
-              }
-            );
-            const boostedScoped = await this.boostSearchResults(
-              scopedCandidates,
-              recallNamespaces,
-              retrievalQuery,
-              void 0,
-              { asOfMs }
-            );
-            xrayBranchPoolSize.hot_embedding = Math.max(
-              xrayBranchPoolSize.hot_embedding,
-              boostedScoped.length
-            );
-            const scoped = this.diversifyAndLimitRecallResults(
-              "memories",
-              boostedScoped,
-              recallResultLimit,
-              retrievalQuery
+            const scoped = await awaitAssemblyStep(
+              "embedding-fallback",
+              async () => {
+                const embeddingResults = await this.searchEmbeddingFallback(
+                  retrievalQuery,
+                  embeddingFetchLimit
+                );
+                const prefilteredEmbeddingResults = applyQueryAwareCandidateFilter(
+                  embeddingResults,
+                  queryAwarePrefilter.candidatePaths
+                );
+                const scopedCandidates = filterRecallCandidates(
+                  prefilteredEmbeddingResults,
+                  {
+                    namespacesEnabled: this.config.namespacesEnabled,
+                    recallNamespaces,
+                    resolveNamespace: (p) => this.namespaceFromPath(p),
+                    limit: embeddingFetchLimit
+                  }
+                );
+                const boostedScoped = await this.boostSearchResults(
+                  scopedCandidates,
+                  recallNamespaces,
+                  retrievalQuery,
+                  void 0,
+                  { asOfMs }
+                );
+                xrayBranchPoolSize.hot_embedding = Math.max(
+                  xrayBranchPoolSize.hot_embedding,
+                  boostedScoped.length
+                );
+                return this.diversifyAndLimitRecallResults(
+                  "memories",
+                  boostedScoped,
+                  recallResultLimit,
+                  retrievalQuery
+                );
+              },
+              []
             );
             if (scoped.length > 0) {
               if (shouldPersistGraphSnapshot) {
@@ -8292,6 +8505,7 @@ ${tmtNode.summary}`
                 queryAwarePrefilter,
                 abortSignal: options.abortSignal,
                 xrayPoolSizeSink: xrayColdPoolSink,
+                deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                 asOfMs,
                 ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
@@ -8358,39 +8572,45 @@ ${tmtNode.summary}`
       } else if (recallResultLimit > 0 && !this.qmd.isAvailable()) {
         const queryAwarePrefilter = await queryAwarePrefilterPromise;
         if (queryAwarePrefilter.candidatePaths?.size !== 0) {
-          const embeddingResults = await this.searchEmbeddingFallback(
-            retrievalQuery,
-            embeddingFetchLimit
-          );
-          const prefilteredEmbeddingResults = applyQueryAwareCandidateFilter(
-            embeddingResults,
-            queryAwarePrefilter.candidatePaths
-          );
-          const scopedCandidates = filterRecallCandidates(
-            prefilteredEmbeddingResults,
-            {
-              namespacesEnabled: this.config.namespacesEnabled,
-              recallNamespaces,
-              resolveNamespace: (p) => this.namespaceFromPath(p),
-              limit: embeddingFetchLimit
-            }
-          );
-          const boostedScoped = await this.boostSearchResults(
-            scopedCandidates,
-            recallNamespaces,
-            retrievalQuery,
-            void 0,
-            { asOfMs }
-          );
-          xrayBranchPoolSize.hot_embedding = Math.max(
-            xrayBranchPoolSize.hot_embedding,
-            boostedScoped.length
-          );
-          const scoped = this.diversifyAndLimitRecallResults(
-            "memories",
-            boostedScoped,
-            recallResultLimit,
-            retrievalQuery
+          const scoped = await awaitAssemblyStep(
+            "embedding-fallback",
+            async () => {
+              const embeddingResults = await this.searchEmbeddingFallback(
+                retrievalQuery,
+                embeddingFetchLimit
+              );
+              const prefilteredEmbeddingResults = applyQueryAwareCandidateFilter(
+                embeddingResults,
+                queryAwarePrefilter.candidatePaths
+              );
+              const scopedCandidates = filterRecallCandidates(
+                prefilteredEmbeddingResults,
+                {
+                  namespacesEnabled: this.config.namespacesEnabled,
+                  recallNamespaces,
+                  resolveNamespace: (p) => this.namespaceFromPath(p),
+                  limit: embeddingFetchLimit
+                }
+              );
+              const boostedScoped = await this.boostSearchResults(
+                scopedCandidates,
+                recallNamespaces,
+                retrievalQuery,
+                void 0,
+                { asOfMs }
+              );
+              xrayBranchPoolSize.hot_embedding = Math.max(
+                xrayBranchPoolSize.hot_embedding,
+                boostedScoped.length
+              );
+              return this.diversifyAndLimitRecallResults(
+                "memories",
+                boostedScoped,
+                recallResultLimit,
+                retrievalQuery
+              );
+            },
+            []
           );
           if (scoped.length > 0) {
             if (shouldPersistGraphSnapshot) {
@@ -8418,7 +8638,11 @@ ${tmtNode.summary}`
             xrayRecalledResults = scoped;
             impressionRecorded = true;
           } else {
-            const memories = await this.readAllMemoriesForNamespaces(recallNamespaces);
+            const memories = await awaitAssemblyStep(
+              "recent-memory-read",
+              () => this.readAllMemoriesForNamespaces(recallNamespaces),
+              []
+            );
             if (memories.length > 0) {
               const supersessionOptions = {
                 enabled: this.config.temporalSupersessionEnabled,
@@ -8449,6 +8673,7 @@ ${tmtNode.summary}`
                   queryAwarePrefilter,
                   abortSignal: options.abortSignal,
                   xrayPoolSizeSink: xrayColdPoolSink,
+                  deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                   asOfMs,
                   ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
                 });
@@ -8473,36 +8698,42 @@ ${tmtNode.summary}`
                   impressionRecorded = true;
                 }
               } else {
-                const recentSorted = queryAwareScopedMemories.sort(
-                  (a, b) => new Date(b.frontmatter.updated).getTime() - new Date(a.frontmatter.updated).getTime()
-                );
-                const preloadedMap = new Map(
-                  queryAwareScopedMemories.filter((m) => m.path).map((m) => [m.path, m])
-                );
-                const recentAsResults = recentSorted.map(
-                  (m, i) => ({
-                    docid: m.frontmatter.id,
-                    path: m.path,
-                    snippet: m.content,
-                    score: 1 - i / Math.max(recentSorted.length, 1)
-                  })
-                );
-                const boostedRecent = (await this.boostSearchResults(
-                  recentAsResults,
-                  recallNamespaces,
-                  retrievalQuery,
-                  preloadedMap,
-                  { asOfMs }
-                )).sort((a, b) => b.score - a.score);
-                xrayBranchPoolSize.recent_scan = Math.max(
-                  xrayBranchPoolSize.recent_scan,
-                  boostedRecent.length
-                );
-                const recent = this.diversifyAndLimitRecallResults(
-                  "memories",
-                  boostedRecent,
-                  recallResultLimit,
-                  retrievalQuery
+                const recent = await awaitAssemblyStep(
+                  "recent-memory-scan",
+                  async () => {
+                    const recentSorted = queryAwareScopedMemories.sort(
+                      (a, b) => new Date(b.frontmatter.updated).getTime() - new Date(a.frontmatter.updated).getTime()
+                    );
+                    const preloadedMap = new Map(
+                      queryAwareScopedMemories.filter((m) => m.path).map((m) => [m.path, m])
+                    );
+                    const recentAsResults = recentSorted.map(
+                      (m, i) => ({
+                        docid: m.frontmatter.id,
+                        path: m.path,
+                        snippet: m.content,
+                        score: 1 - i / Math.max(recentSorted.length, 1)
+                      })
+                    );
+                    const boostedRecent = (await this.boostSearchResults(
+                      recentAsResults,
+                      recallNamespaces,
+                      retrievalQuery,
+                      preloadedMap,
+                      { asOfMs }
+                    )).sort((a, b) => b.score - a.score);
+                    xrayBranchPoolSize.recent_scan = Math.max(
+                      xrayBranchPoolSize.recent_scan,
+                      boostedRecent.length
+                    );
+                    return this.diversifyAndLimitRecallResults(
+                      "memories",
+                      boostedRecent,
+                      recallResultLimit,
+                      retrievalQuery
+                    );
+                  },
+                  []
                 );
                 if (recent.length > 0) {
                   if (shouldPersistGraphSnapshot) {
@@ -8538,6 +8769,7 @@ ${tmtNode.summary}`
                     queryAwarePrefilter,
                     abortSignal: options.abortSignal,
                     xrayPoolSizeSink: xrayColdPoolSink,
+                    deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                     asOfMs,
                     ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
                   });
@@ -8578,6 +8810,7 @@ ${tmtNode.summary}`
                 queryAwarePrefilter,
                 abortSignal: options.abortSignal,
                 xrayPoolSizeSink: xrayColdPoolSink,
+                deadlineAtMs: enrichmentAssemblyDeadlineAtMs,
                 asOfMs,
                 ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
@@ -8872,6 +9105,7 @@ _Context: ${topQuestion.context}_`
           query: retrievalQuery,
           memoryIds: recalledMemoryIds,
           namespace: selfNamespace,
+          recallNamespaces,
           traceId,
           plannerMode: recallMode,
           requestedMode,
@@ -12268,6 +12502,212 @@ ${lines.join("\n\n")}`;
    *
    * Callers must pass the full candidate pool (post-rerank, pre-slice).
    */
+  qmdCollectionNamespaceFromPrefix(collectionPrefix) {
+    const baseCollection = this.config.qmdCollection;
+    if (collectionPrefix === baseCollection) return this.config.defaultNamespace;
+    const namespaceSuffix = collectionPrefix.startsWith(`${baseCollection}--`) ? collectionPrefix.slice(baseCollection.length + 2) : "";
+    if (!namespaceSuffix) return null;
+    const decoded = namespaceIdentityFromToken(namespaceSuffix);
+    if (decoded !== null) return decoded || this.config.defaultNamespace;
+    if (namespaceSuffix.startsWith("ns--")) {
+      const legacyNamespace = namespaceSuffix.slice("ns--".length).trim();
+      return legacyNamespace || null;
+    }
+    return null;
+  }
+  async readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces = []) {
+    const parts = qmdCollectionPathParts(resultPath);
+    const storageDirFor = (storage) => typeof storage.dir === "string" && storage.dir ? storage.dir : null;
+    const fallbackStorageDir = storageDirFor(fallbackStorage);
+    const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
+    if (parts && parts.collection === coldCollection) {
+      const storages = [];
+      const seenStorageDirs = /* @__PURE__ */ new Set();
+      const addStorage = (storage) => {
+        const storageDir = storageDirFor(storage);
+        const storageKey = storageDir ? path2.resolve(storageDir) : `storage-without-dir-${storages.length}`;
+        if (seenStorageDirs.has(storageKey)) return;
+        seenStorageDirs.add(storageKey);
+        storages.push(storage);
+      };
+      const fallbackNamespace = fallbackStorageDir !== null ? this.namespaceFromStorageDir(fallbackStorageDir) : this.config.defaultNamespace;
+      if (recallNamespaces.length === 0 || !this.config.namespacesEnabled || recallNamespaces.includes(fallbackNamespace)) {
+        addStorage(fallbackStorage);
+      }
+      if (recallNamespaces.length > 0) {
+        for (const namespace of recallNamespaces) {
+          try {
+            addStorage(await this.storageRouter.storageFor(namespace));
+          } catch (err) {
+            log.debug("qmd cold result namespace storage lookup skipped", {
+              path: resultPath,
+              namespace,
+              error: err.message
+            });
+          }
+        }
+      }
+      for (const storage of storages) {
+        const storageDir = storageDirFor(storage);
+        if (!storageDir) {
+          const memory = await storage.readMemoryByPath(resultPath);
+          if (memory) return memory;
+          continue;
+        }
+        try {
+          const coldRoot = path2.join(storageDir, "cold");
+          for (const candidate of qmdResultPathCandidates(
+            coldRoot,
+            parts.relativePath
+          )) {
+            const memory = await storage.readMemoryByPath(candidate);
+            if (memory) return memory;
+          }
+        } catch (err) {
+          if (err instanceof SecureStoreLockedError) throw err;
+          log.debug("qmd cold result path lookup failed open", {
+            path: resultPath,
+            collection: coldCollection,
+            error: err.message
+          });
+        }
+      }
+      return null;
+    }
+    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
+    if (parts && collectionNamespace) {
+      try {
+        const collectionStorage = await this.storageRouter.storageFor(collectionNamespace);
+        for (const candidate of qmdResultPathCandidates(
+          collectionStorage.dir,
+          parts.relativePath
+        )) {
+          const memory = await collectionStorage.readMemoryByPath(candidate);
+          if (memory) return memory;
+        }
+        return null;
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) throw err;
+        log.debug("qmd result namespace path lookup failed open", {
+          path: resultPath,
+          namespace: collectionNamespace,
+          error: err.message
+        });
+        return null;
+      }
+    }
+    if (path2.isAbsolute(resultPath)) {
+      if (!fallbackStorageDir) {
+        return await fallbackStorage.readMemoryByPath(resultPath);
+      }
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        resultPath,
+        fallbackStorage,
+        recallNamespaces
+      );
+      if (!ownerStorage) return null;
+      for (const candidate of qmdResultPathCandidates(
+        ownerStorage.dir,
+        resultPath
+      )) {
+        const memory = await ownerStorage.storage.readMemoryByPath(candidate);
+        if (memory) return memory;
+      }
+      return null;
+    }
+    if (!fallbackStorageDir) {
+      return await fallbackStorage.readMemoryByPath(resultPath);
+    }
+    for (const candidate of qmdResultPathCandidates(
+      fallbackStorageDir,
+      resultPath
+    )) {
+      const memory = await fallbackStorage.readMemoryByPath(candidate);
+      if (memory) return memory;
+    }
+    return null;
+  }
+  async resolveColdQmdResultForRecall(result, fallbackStorage, recallNamespaces = []) {
+    const memory = await this.readQmdResultMemory(
+      result.path,
+      fallbackStorage,
+      recallNamespaces
+    );
+    if (!memory) return null;
+    let ownerNamespace = null;
+    if (path2.isAbsolute(memory.path)) {
+      const ownerStorage = await this.storageForAbsoluteQmdResultPath(
+        memory.path,
+        fallbackStorage,
+        recallNamespaces
+      );
+      ownerNamespace = ownerStorage?.namespace ?? null;
+      if (!ownerNamespace && this.config.namespacesEnabled) return null;
+    }
+    ownerNamespace ??= this.namespaceFromPath(memory.path);
+    if (recallNamespaces.length > 0 && !recallNamespaces.includes(ownerNamespace)) {
+      return null;
+    }
+    return {
+      namespace: ownerNamespace,
+      result: {
+        ...result,
+        docid: result.docid || memory.frontmatter.id,
+        path: memory.path,
+        snippet: result.snippet || memory.content.slice(0, 400)
+      }
+    };
+  }
+  async storageForAbsoluteQmdResultPath(resultPath, fallbackStorage, recallNamespaces = []) {
+    const resolvedPath = path2.resolve(resultPath);
+    const memoryRoot = path2.resolve(this.config.memoryDir);
+    const namespacesRoot = path2.join(memoryRoot, "namespaces");
+    const fallbackStorageDir = typeof fallbackStorage.dir === "string" && fallbackStorage.dir ? fallbackStorage.dir : null;
+    const matches = [];
+    const seenDirs = /* @__PURE__ */ new Set();
+    const maybeAddStorage = (storage, namespace) => {
+      const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
+      if (!storageDir) return;
+      const candidateRoot = path2.resolve(storageDir);
+      if (seenDirs.has(candidateRoot)) return;
+      if (!isPathInsideStorageRoot(candidateRoot, resolvedPath)) return;
+      if (candidateRoot === memoryRoot && isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+        return;
+      }
+      seenDirs.add(candidateRoot);
+      matches.push({ storage, dir: candidateRoot, namespace });
+    };
+    const fallbackNamespace = fallbackStorageDir !== null ? this.namespaceFromStorageDir(fallbackStorageDir) : this.config.defaultNamespace;
+    maybeAddStorage(fallbackStorage, fallbackNamespace);
+    const candidateNamespaces = /* @__PURE__ */ new Set();
+    candidateNamespaces.add(this.config.defaultNamespace);
+    candidateNamespaces.add(this.config.sharedNamespace);
+    for (const ns of recallNamespaces) {
+      candidateNamespaces.add(ns);
+    }
+    if (isPathInsideStorageRoot(namespacesRoot, resolvedPath)) {
+      const relativeToNamespaces = path2.relative(namespacesRoot, resolvedPath);
+      const [namespaceSegment] = relativeToNamespaces.split(/[\\/]/);
+      if (namespaceSegment) {
+        candidateNamespaces.add(
+          namespaceIdentityFromToken(namespaceSegment) ?? namespaceSegment
+        );
+      }
+    }
+    for (const policy of this.config.namespacePolicies ?? []) {
+      candidateNamespaces.add(policy.name);
+    }
+    for (const ns of candidateNamespaces) {
+      if (!ns) continue;
+      try {
+        maybeAddStorage(await this.storageRouter.storageFor(ns), ns);
+      } catch {
+        continue;
+      }
+    }
+    matches.sort((a, b) => b.dir.length - a.dir.length);
+    return matches[0] ?? null;
+  }
   async applyMemoryWorthRerank(results, namespaces) {
     const counters = /* @__PURE__ */ new Map();
     const seenNamespaces = /* @__PURE__ */ new Set();
@@ -12312,7 +12752,7 @@ ${lines.join("\n\n")}`;
       if (reader) {
         for (const r of missing) {
           try {
-            const memory = await reader.readMemoryByPath(r.path);
+            const memory = await this.readQmdResultMemory(r.path, reader, namespaces);
             if (!memory) continue;
             const fm = memory.frontmatter;
             if (fm.mw_success === void 0 && fm.mw_fail === void 0) continue;
@@ -12560,6 +13000,41 @@ ${lines.join("\n\n")}`;
       if (options.xrayPoolSizeSink) options.xrayPoolSizeSink.size = 0;
       return [];
     }
+    const deadlineRemainingMs = () => typeof options.deadlineAtMs === "number" ? Math.max(0, options.deadlineAtMs - Date.now()) : null;
+    const runColdStepWithinDeadline = async (label, fallback, task) => {
+      throwIfRecallAborted(options.abortSignal);
+      const remainingMs = deadlineRemainingMs();
+      if (remainingMs === 0) {
+        log.debug(`cold-tier recall ${label} skipped: shared assembly deadline expired`);
+        return fallback;
+      }
+      if (remainingMs === null) return task();
+      let timeoutHandle;
+      let timedOut = false;
+      const taskPromise = task().catch((err) => {
+        if (timedOut) {
+          log.debug(`cold-tier recall ${label} failed after deadline: ${err}`);
+          return fallback;
+        }
+        throw err;
+      });
+      try {
+        return await Promise.race([
+          taskPromise,
+          new Promise((resolve) => {
+            timeoutHandle = setTimeout(() => {
+              timedOut = true;
+              log.debug(
+                `cold-tier recall ${label} skipped: shared assembly deadline expired`
+              );
+              resolve(fallback);
+            }, remainingMs);
+          })
+        ]);
+      } finally {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+      }
+    };
     const coldQmdEnabled = this.config.qmdColdTierEnabled === true;
     const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
     const coldMaxResults = this.config.qmdColdMaxResults ?? this.config.qmdMaxResults;
@@ -12575,19 +13050,23 @@ ${lines.join("\n\n")}`;
           false,
           0
         );
-        longTerm = await this.fetchQmdMemoryResultsWithArtifactTopUp(
-          options.prompt,
-          coldFetchLimit,
-          coldHybridLimit,
-          {
-            namespacesEnabled: this.config.namespacesEnabled,
-            recallNamespaces: options.recallNamespaces,
-            resolveNamespace: (p) => this.namespaceFromPath(p),
-            collection: coldCollection,
-            queryAwarePrefilter: options.queryAwarePrefilter,
-            searchOptions: this.buildConfiguredQmdSearchOptions(options.prompt),
-            abortSignal: options.abortSignal
-          }
+        longTerm = await runColdStepWithinDeadline(
+          "qmd lookup",
+          [],
+          () => this.fetchQmdMemoryResultsWithArtifactTopUp(
+            options.prompt,
+            coldFetchLimit,
+            coldHybridLimit,
+            {
+              namespacesEnabled: this.config.namespacesEnabled,
+              recallNamespaces: options.recallNamespaces,
+              resolveNamespace: (p) => this.namespaceFromPath(p),
+              collection: coldCollection,
+              queryAwarePrefilter: options.queryAwarePrefilter,
+              searchOptions: this.buildConfiguredQmdSearchOptions(options.prompt),
+              abortSignal: options.abortSignal
+            }
+          )
         );
         if (longTerm.length > 0) {
           log.debug(
@@ -12597,12 +13076,16 @@ ${lines.join("\n\n")}`;
       }
     }
     if (longTerm.length === 0) {
-      longTerm = await this.searchLongTermArchiveFallback(
-        options.prompt,
-        options.recallNamespaces,
-        options.recallResultLimit,
-        options.queryAwarePrefilter,
-        options.abortSignal
+      longTerm = await runColdStepWithinDeadline(
+        "archive scan",
+        [],
+        () => this.searchLongTermArchiveFallback(
+          options.prompt,
+          options.recallNamespaces,
+          options.recallResultLimit,
+          options.queryAwarePrefilter,
+          options.abortSignal
+        )
       );
       if (longTerm.length > 0) {
         log.debug("cold-tier recall source=archive-scan");
@@ -12611,9 +13094,51 @@ ${lines.join("\n\n")}`;
     if (longTerm.length === 0) return [];
     let results = longTerm;
     if (this.config.namespacesEnabled) {
-      results = results.filter(
-        (r) => options.recallNamespaces.includes(this.namespaceFromPath(r.path))
-      );
+      const recallRoots = [];
+      const seenRecallRoots = /* @__PURE__ */ new Set();
+      for (const namespace of options.recallNamespaces) {
+        try {
+          const storage = await this.storageRouter.storageFor(namespace);
+          const storageDir = typeof storage.dir === "string" && storage.dir ? storage.dir : null;
+          if (!storageDir) continue;
+          const recallRoot = path2.resolve(storageDir);
+          if (seenRecallRoots.has(recallRoot)) continue;
+          seenRecallRoots.add(recallRoot);
+          recallRoots.push(recallRoot);
+        } catch (err) {
+          log.debug("cold-tier recall namespace root lookup skipped", {
+            namespace,
+            error: err.message
+          });
+        }
+      }
+      const scopedResults = [];
+      for (const result of results) {
+        if (options.abortSignal?.aborted || deadlineRemainingMs() === 0) break;
+        const parts = qmdCollectionPathParts(result.path);
+        if (parts?.collection === coldCollection) {
+          const resolvedCold = await this.resolveColdQmdResultForRecall(
+            result,
+            this.storage,
+            options.recallNamespaces
+          );
+          if (resolvedCold) scopedResults.push(resolvedCold.result);
+          continue;
+        }
+        if (path2.isAbsolute(result.path)) {
+          const resolvedPath = path2.resolve(result.path);
+          if (recallRoots.some(
+            (recallRoot) => isPathInsideStorageRoot(recallRoot, resolvedPath)
+          )) {
+            scopedResults.push(result);
+          }
+          continue;
+        }
+        if (options.recallNamespaces.includes(this.namespaceFromPath(result.path))) {
+          scopedResults.push(result);
+        }
+      }
+      results = scopedResults;
     }
     results = results.filter((r) => !isArtifactMemoryPath(r.path));
     if (results.length === 0) return [];
@@ -12624,17 +13149,64 @@ ${lines.join("\n\n")}`;
         memoryResults: results,
         recallNamespaces: options.recallNamespaces,
         recallResultLimit: options.recallResultLimit,
+        deadlineAtMs: options.deadlineAtMs,
         ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
       });
       results = merged;
     }
-    results = await this.boostSearchResults(
+    const boostInput = await this.filterSearchResultsForRecall(
       results,
-      options.recallNamespaces,
-      options.prompt,
       void 0,
-      { allowLifecycleFiltered: true, asOfMs: options.asOfMs }
+      {
+        allowLifecycleFiltered: true,
+        asOfMs: options.asOfMs,
+        deadlineAtMs: options.deadlineAtMs,
+        abortSignal: options.abortSignal,
+        dropUnresolved: true,
+        recallNamespaces: options.recallNamespaces
+      }
     );
+    results = boostInput.results;
+    const boostTimeoutMs = typeof options.deadlineAtMs === "number" ? Math.max(0, options.deadlineAtMs - Date.now()) : null;
+    if (boostTimeoutMs !== 0) {
+      let timeoutHandle;
+      try {
+        const boosted = await (boostTimeoutMs !== null ? Promise.race([
+          this.boostSearchResults(
+            boostInput.results,
+            options.recallNamespaces,
+            options.prompt,
+            boostInput.memoryByPath,
+            { allowLifecycleFiltered: true, asOfMs: options.asOfMs }
+          ),
+          new Promise((resolve) => {
+            timeoutHandle = setTimeout(
+              () => resolve({ status: "timed_out" }),
+              boostTimeoutMs
+            );
+          })
+        ]) : this.boostSearchResults(
+          boostInput.results,
+          options.recallNamespaces,
+          options.prompt,
+          boostInput.memoryByPath,
+          { allowLifecycleFiltered: true, asOfMs: options.asOfMs }
+        ));
+        if (typeof boosted === "object" && boosted !== null && "status" in boosted && boosted.status === "timed_out") {
+          log.debug("cold-tier recall boost skipped: shared assembly deadline expired");
+        } else if (Array.isArray(boosted)) {
+          results = boosted;
+        } else {
+          results = boostInput.results;
+        }
+      } catch (err) {
+        log.debug(`cold-tier recall boost failed open: ${err}`);
+      } finally {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+      }
+    } else {
+      log.debug("cold-tier recall boost skipped: shared assembly deadline already expired");
+    }
     if (this.config.rerankEnabled && this.config.rerankProvider === "local") {
       const ranked = await rerankLocalOrNoop({
         query: options.prompt,
@@ -12755,64 +13327,101 @@ ${lines.join("\n\n")}`;
     this.accessTrackingBuffer.clear();
     log.debug(`flushed ${entries.length} access tracking entries`);
   }
-  /**
-   * Apply recency, access count, and importance boosting to QMD search results.
-   * Returns re-ranked results.
-   */
-  async boostSearchResults(results, _recallNamespaces, prompt, preloadedMemoryMap, options) {
-    if (results.length === 0) return results;
-    const now = Date.now();
+  async loadSearchResultMemoryMap(results, preloadedMemoryMap, options) {
     const memoryByPath = preloadedMemoryMap ? new Map(preloadedMemoryMap) : /* @__PURE__ */ new Map();
-    const resultPaths = new Set(
-      results.map((r) => r.path).filter(Boolean)
-    );
-    let temporalFromDate = null;
-    let promptTags = [];
-    if (this.config.queryAwareIndexingEnabled && prompt) {
-      if (isTemporalQuery(prompt)) {
-        temporalFromDate = recencyWindowFromPrompt(prompt, now);
+    const checkedPaths = /* @__PURE__ */ new Set();
+    const unreadablePaths = /* @__PURE__ */ new Set();
+    const markChecked = (result) => {
+      if (result.path) checkedPaths.add(result.path);
+    };
+    const markUnreadable = (result, err) => {
+      if (!result.path) return;
+      checkedPaths.add(result.path);
+      unreadablePaths.add(result.path);
+      log.warn("recall safety filter dropped unreadable secure-store candidate", {
+        path: result.path,
+        error: err.message
+      });
+    };
+    const deadlineExpired = () => typeof options?.deadlineAtMs === "number" && Date.now() >= options.deadlineAtMs;
+    if (options?.deadlineAtMs == null) {
+      const batchSize = options?.abortSignal ? 16 : results.length;
+      for (let offset = 0; offset < results.length; offset += batchSize) {
+        if (options?.abortSignal?.aborted) {
+          return {
+            memoryByPath,
+            checkedPaths,
+            unreadablePaths,
+            completed: false
+          };
+        }
+        await Promise.all(
+          results.slice(offset, offset + batchSize).map(async (r) => {
+            if (!r.path) return;
+            if (memoryByPath.has(r.path)) {
+              markChecked(r);
+              return;
+            }
+            try {
+              const mem = await this.readQmdResultMemory(
+                r.path,
+                this.storage,
+                options?.recallNamespaces
+              );
+              markChecked(r);
+              if (mem) memoryByPath.set(r.path, mem);
+            } catch (err) {
+              if (err instanceof SecureStoreLockedError) {
+                markUnreadable(r, err);
+                return;
+              }
+              throw err;
+            }
+          })
+        );
       }
-      promptTags = extractTagsFromPrompt(prompt);
+      return { memoryByPath, checkedPaths, unreadablePaths, completed: true };
     }
-    const [, rawTemporal, rawTags] = await Promise.all([
-      Promise.all(
-        results.map(async (r) => {
-          if (!r.path || memoryByPath.has(r.path)) return;
-          const mem = await this.storage.readMemoryByPath(r.path);
-          if (mem) memoryByPath.set(r.path, mem);
-        })
-      ),
-      temporalFromDate !== null ? queryByDateRangeAsync(this.config.memoryDir, temporalFromDate) : Promise.resolve(null),
-      promptTags.length > 0 ? queryByTagsAsync(this.config.memoryDir, promptTags) : Promise.resolve(null)
-    ]);
-    const queryIntent = this.config.intentRoutingEnabled && prompt ? inferIntentFromText(prompt) : null;
-    let temporalCandidates = null;
-    let tagCandidates = null;
-    if (this.config.queryAwareIndexingEnabled && prompt) {
-      const maxCandidates = this.config.queryAwareIndexingMaxCandidates;
-      const capSet = (s) => {
-        if (!s) return null;
-        const scoped = new Set(Array.from(s).filter((p) => resultPaths.has(p)));
-        if (maxCandidates === 0 || scoped.size <= maxCandidates)
-          return scoped;
-        return new Set(Array.from(scoped).slice(0, maxCandidates));
-      };
-      if (temporalFromDate !== null) {
-        temporalCandidates = capSet(rawTemporal);
+    for (const result of results) {
+      if (!result.path) continue;
+      if (memoryByPath.has(result.path)) {
+        markChecked(result);
+        continue;
       }
-      if (promptTags.length > 0) {
-        tagCandidates = capSet(rawTags);
+      if (options?.abortSignal?.aborted || deadlineExpired()) {
+        return { memoryByPath, checkedPaths, unreadablePaths, completed: false };
+      }
+      try {
+        const mem = await this.readQmdResultMemory(
+          result.path,
+          this.storage,
+          options?.recallNamespaces
+        );
+        markChecked(result);
+        if (mem) memoryByPath.set(result.path, mem);
+      } catch (err) {
+        if (err instanceof SecureStoreLockedError) {
+          markUnreadable(result, err);
+          continue;
+        }
+        throw err;
       }
     }
+    return { memoryByPath, checkedPaths, unreadablePaths, completed: true };
+  }
+  filterSearchResultsByRecallSafety(results, memoryByPath, options) {
     let lifecycleFilteredCount = 0;
     let temporalSupersededFilteredCount = 0;
     let dedicatedSurfaceFilteredCount = 0;
     let forgottenFilteredCount = 0;
-    const boosted = [];
-    const recencyWeight = this.effectiveRecencyWeight();
+    let blockedPathFilteredCount = 0;
+    const filtered = [];
     for (const r of results) {
+      if (r.path && options?.blockedPaths?.has(r.path)) {
+        blockedPathFilteredCount += 1;
+        continue;
+      }
       const memory = memoryByPath.get(r.path);
-      let score = r.score;
       if (memory) {
         if (memory.frontmatter.status === "forgotten") {
           forgottenFilteredCount += 1;
@@ -12854,6 +13463,126 @@ ${lines.join("\n\n")}`;
           dedicatedSurfaceFilteredCount += 1;
           continue;
         }
+      }
+      filtered.push(r);
+    }
+    if (lifecycleFilteredCount > 0) {
+      log.debug(
+        `lifecycle retrieval filter removed ${lifecycleFilteredCount} stale/archived candidates`
+      );
+    }
+    if (temporalSupersededFilteredCount > 0) {
+      log.debug(
+        `temporal supersession filter removed ${temporalSupersededFilteredCount} superseded candidates`
+      );
+    }
+    if (dedicatedSurfaceFilteredCount > 0) {
+      log.debug(
+        `dedicated surface filter removed ${dedicatedSurfaceFilteredCount} dream/procedural candidates from generic recall`
+      );
+    }
+    if (forgottenFilteredCount > 0) {
+      log.debug(
+        `forgotten status filter removed ${forgottenFilteredCount} candidates from recall`
+      );
+    }
+    if (blockedPathFilteredCount > 0) {
+      log.debug(
+        `unreadable-path filter removed ${blockedPathFilteredCount} candidates from recall`
+      );
+    }
+    return filtered;
+  }
+  async filterSearchResultsForRecall(results, preloadedMemoryMap, options) {
+    if (results.length === 0) {
+      return {
+        results,
+        memoryByPath: preloadedMemoryMap ? new Map(preloadedMemoryMap) : /* @__PURE__ */ new Map()
+      };
+    }
+    const loaded = await this.loadSearchResultMemoryMap(
+      results,
+      preloadedMemoryMap,
+      options
+    );
+    const candidateResults = loaded.completed ? results : results.filter((result) => !result.path || loaded.checkedPaths.has(result.path));
+    if (!loaded.completed) {
+      log.debug(
+        `recall safety filter stopped before validating all candidates (${candidateResults.length}/${results.length} eligible)`
+      );
+    }
+    const blockedPaths = new Set(loaded.unreadablePaths);
+    if (options?.dropUnresolved === true) {
+      for (const resultPath of loaded.checkedPaths) {
+        if (!loaded.memoryByPath.has(resultPath)) {
+          blockedPaths.add(resultPath);
+        }
+      }
+    }
+    return {
+      results: this.filterSearchResultsByRecallSafety(
+        candidateResults,
+        loaded.memoryByPath,
+        { ...options, blockedPaths }
+      ),
+      memoryByPath: loaded.memoryByPath
+    };
+  }
+  /**
+   * Apply recency, access count, and importance boosting to QMD search results.
+   * Returns re-ranked results.
+   */
+  async boostSearchResults(results, _recallNamespaces, prompt, preloadedMemoryMap, options) {
+    if (results.length === 0) return results;
+    const safety = await this.filterSearchResultsForRecall(
+      results,
+      preloadedMemoryMap,
+      { ...options, recallNamespaces: _recallNamespaces }
+    );
+    const safeResults = safety.results;
+    const memoryByPath = safety.memoryByPath;
+    if (safeResults.length === 0) return safeResults;
+    const now = Date.now();
+    const resultPaths = new Set(
+      safeResults.map((r) => r.path).filter(Boolean)
+    );
+    let temporalFromDate = null;
+    let promptTags = [];
+    if (this.config.queryAwareIndexingEnabled && prompt) {
+      if (isTemporalQuery(prompt)) {
+        temporalFromDate = recencyWindowFromPrompt(prompt, now);
+      }
+      promptTags = extractTagsFromPrompt(prompt);
+    }
+    const [rawTemporal, rawTags] = await Promise.all([
+      temporalFromDate !== null ? queryByDateRangeAsync(this.config.memoryDir, temporalFromDate) : Promise.resolve(null),
+      promptTags.length > 0 ? queryByTagsAsync(this.config.memoryDir, promptTags) : Promise.resolve(null)
+    ]);
+    const queryIntent = this.config.intentRoutingEnabled && prompt ? inferIntentFromText(prompt) : null;
+    let temporalCandidates = null;
+    let tagCandidates = null;
+    if (this.config.queryAwareIndexingEnabled && prompt) {
+      const maxCandidates = this.config.queryAwareIndexingMaxCandidates;
+      const capSet = (s) => {
+        if (!s) return null;
+        const scoped = new Set(Array.from(s).filter((p) => resultPaths.has(p)));
+        if (maxCandidates === 0 || scoped.size <= maxCandidates)
+          return scoped;
+        return new Set(Array.from(scoped).slice(0, maxCandidates));
+      };
+      if (temporalFromDate !== null) {
+        temporalCandidates = capSet(rawTemporal);
+      }
+      if (promptTags.length > 0) {
+        tagCandidates = capSet(rawTags);
+      }
+    }
+    const boosted = [];
+    const recencyWeight = this.effectiveRecencyWeight();
+    for (const r of safeResults) {
+      const memory = memoryByPath.get(r.path);
+      let score = r.score;
+      if (memory) {
         if (recencyWeight > 0) {
           const createdAt = new Date(memory.frontmatter.created).getTime();
           const ageMs = now - createdAt;
@@ -12964,26 +13693,6 @@ ${lines.join("\n\n")}`;
       }
       boosted.push({ ...r, score });
     }
-    if (lifecycleFilteredCount > 0) {
-      log.debug(
-        `lifecycle retrieval filter removed ${lifecycleFilteredCount} stale/archived candidates`
-      );
-    }
-    if (temporalSupersededFilteredCount > 0) {
-      log.debug(
-        `temporal supersession filter removed ${temporalSupersededFilteredCount} superseded candidates`
-      );
-    }
-    if (dedicatedSurfaceFilteredCount > 0) {
-      log.debug(
-        `dedicated surface filter removed ${dedicatedSurfaceFilteredCount} dream/procedural candidates from generic recall`
-      );
-    }
-    if (forgottenFilteredCount > 0) {
-      log.debug(
-        `forgotten status filter removed ${forgottenFilteredCount} candidates from recall`
-      );
-    }
     return boosted.sort((a, b) => b.score - a.score);
   }
   /**
@@ -13121,8 +13830,37 @@ ${lines.join("\n\n")}`;
       reason: link.reason || void 0
     }));
   }
+  async graphSeedPathRelativeToStorage(storage, result, recallNamespaces = []) {
+    const parts = qmdCollectionPathParts(result.path);
+    if (parts) {
+      const memory = await this.readQmdResultMemory(
+        result.path,
+        storage,
+        recallNamespaces
+      );
+      return memory ? graphPathRelativeToStorage(storage.dir, memory.path) : null;
+    }
+    return graphPathRelativeToStorage(storage.dir, result.path);
+  }
+  async graphSeedPathsWithinDeadline(storage, results, deadlineAtMs, recallNamespaces = []) {
+    const resolved = [];
+    for (const result of results) {
+      if (Date.now() >= deadlineAtMs) break;
+      const seedPath = await this.graphSeedPathRelativeToStorage(
+        storage,
+        result,
+        recallNamespaces
+      );
+      if (Date.now() >= deadlineAtMs) break;
+      if (seedPath) resolved.push(seedPath);
+    }
+    return resolved;
+  }
   namespaceFromPath(p) {
     if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
+    const parts = qmdCollectionPathParts(p);
+    const collectionNamespace = parts ? this.qmdCollectionNamespaceFromPrefix(parts.collection) : null;
+    if (collectionNamespace) return collectionNamespace;
     const m = p.match(/[\\/]+namespaces[\\/]+([^\\/]+)(?:[\\/]|$)/);
     if (!m?.[1]) return this.config.defaultNamespace;
     return namespaceIdentityFromToken(m[1]) ?? m[1];
@@ -13206,4 +13944,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-TFICNXXU.js.map
+//# sourceMappingURL=chunk-TJRV4MWX.js.map