@remnic/core 9.3.602 → 9.3.604

package/dist/{chunk-MTGOAU7A.js → chunk-OEIRQ7DB.js}

@@ -70,7 +70,7 @@ import {
   runDirectAgent,
   runTemporalAgent,
   shouldRunAgent
-} from "./chunk-5SQ5CQJP.js";
+} from "./chunk-HSVJGWYS.js";
 import {
   clearIndexes,
   deindexMemory,
@@ -82,7 +82,7 @@ import {
   queryByTagsAsync,
   recencyWindowFromPrompt,
   resolvePromptTagPrefilterAsync
-} from "./chunk-75O6YQ63.js";
+} from "./chunk-G6R5UD3Q.js";
 import {
   applyRuntimeRetrievalPolicy
 } from "./chunk-5IZL4DCV.js";
@@ -1214,7 +1214,8 @@ function filterRecallCandidates(candidates, options) {
   return scopedByNamespace.filter((r) => !isArtifactMemoryPath(r.path)).slice(0, Math.max(0, options.limit));
 }
 function applyQueryAwareCandidateFilter(candidates, candidatePaths) {
-  if (!candidatePaths || candidatePaths.size === 0) return candidates;
+  if (!candidatePaths) return candidates;
+  if (candidatePaths.size === 0) return [];
   const filtered = candidates.filter(
     (candidate) => candidatePaths.has(candidate.path)
   );
@@ -4341,7 +4342,7 @@ ${r.snippet.trim()}
     return mergeArtifactRecallCandidates(filteredByNamespace, targetCount);
   }
   scopeQueryAwarePaths(paths, recallNamespaces) {
-    if (!paths || paths.size === 0) return null;
+    if (!paths) return null;
     const scoped = /* @__PURE__ */ new Set();
     for (const memoryPath of paths) {
       if (!memoryPath || isArtifactMemoryPath(memoryPath)) continue;
@@ -4350,7 +4351,7 @@ ${r.snippet.trim()}
       }
       scoped.add(memoryPath);
     }
-    return scoped.size > 0 ? scoped : null;
+    return scoped;
   }
   async buildQueryAwarePrefilter(prompt, recallNamespaces) {
     if (!this.config.queryAwareIndexingEnabled || !prompt.trim()) {
@@ -4386,7 +4387,10 @@ ${r.snippet.trim()}
     let candidatePaths = null;
     let combination = "none";
     let filteredToFullSearch = false;
-    if (temporalCandidates && tagCandidates) {
+    if (tagSignals.matchedTags.length > 0 && tagCandidates !== null && tagCandidates.size === 0) {
+      candidatePaths = tagCandidates;
+      combination = "tag";
+    } else if (temporalCandidates !== null && tagCandidates !== null) {
       const intersection = new Set(
         Array.from(temporalCandidates).filter(
           (memoryPath) => tagCandidates.has(memoryPath)
@@ -4399,10 +4403,10 @@ ${r.snippet.trim()}
         candidatePaths = /* @__PURE__ */ new Set([...temporalCandidates, ...tagCandidates]);
         combination = "union";
       }
-    } else if (temporalCandidates) {
+    } else if (temporalCandidates !== null) {
       candidatePaths = temporalCandidates;
       combination = "temporal";
-    } else if (tagCandidates) {
+    } else if (tagCandidates !== null) {
       candidatePaths = tagCandidates;
       combination = "tag";
     }
@@ -4516,6 +4520,10 @@ ${r.snippet.trim()}
         }))
       });
     };
+    if (queryAwarePrefilter.candidatePaths?.size === 0) {
+      await emitDebugSnapshot([], fetchLimit);
+      return [];
+    }
     for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
       throwIfRecallAborted(options.abortSignal);
       if (qmdRecallBudgetEnabled && Date.now() - startedAtMs >= qmdRecallBudgetMs) {
@@ -6215,6 +6223,14 @@ ${lines.join("\n\n")}`;
             }
           );
           const staleQmdFallback = cachedQmd?.source === "stale" ? cachedQmd : null;
+          const queryAwarePrefilter = await queryAwarePrefilterPromise;
+          const queryAwarePrefilterIsEmpty = queryAwarePrefilter.candidatePaths?.size === 0;
+          const emptyQueryAwareQmdResult = {
+            memoryResultsLists: [[]],
+            globalResults: [],
+            preAugmentTopScore: 0,
+            maxSpecializedScore: 0
+          };
           if (cachedQmd?.source === "fresh") {
             recordRecallSectionMetric({
               section: "qmd",
@@ -6225,6 +6241,9 @@ ${lines.join("\n\n")}`;
               success: true,
               timing: `${Math.max(0, Math.round(cachedQmd.ageMs))}ms-cache`
             });
+            if (queryAwarePrefilterIsEmpty) {
+              return emptyQueryAwareQmdResult;
+            }
             return cachedQmd.value;
           }
           if (!this.qmd.isAvailable()) {
@@ -6241,6 +6260,9 @@ ${lines.join("\n\n")}`;
                   success: true,
                   timing: `stale-cache(reprobe-cooldown:${Math.max(0, Math.round(staleQmdFallback.ageMs))}ms)`
                 });
+                if (queryAwarePrefilterIsEmpty) {
+                  return emptyQueryAwareQmdResult;
+                }
                 return staleQmdFallback.value;
               }
               recordRecallSectionMetric({
@@ -6267,6 +6289,9 @@ ${lines.join("\n\n")}`;
                   success: true,
                   timing: `stale-cache(reprobe-failed:${Math.max(0, Math.round(staleQmdFallback.ageMs))}ms)`
                 });
+                if (queryAwarePrefilterIsEmpty) {
+                  return emptyQueryAwareQmdResult;
+                }
                 return staleQmdFallback.value;
               }
               recordRecallSectionMetric({
@@ -6285,9 +6310,8 @@ ${lines.join("\n\n")}`;
             }
             log.info(`QMD re-probe succeeded: ${this.qmd.debugStatus()}`);
           }
-          const queryAwarePrefilter = await queryAwarePrefilterPromise;
           const maxPerAgent = this.config.parallelMaxResultsPerAgent;
-          const specializedAgentPromise = this.config.parallelRetrievalEnabled && maxPerAgent > 0 ? Promise.all([
+          const specializedAgentPromise = !queryAwarePrefilterIsEmpty && this.config.parallelRetrievalEnabled && maxPerAgent > 0 ? Promise.all([
             shouldRunAgent("direct", retrievalQuery, 0) ? runDirectAgent(
               retrievalQuery,
               profileStorage.dir,
@@ -6388,6 +6412,9 @@ ${lines.join("\n\n")}`;
                 success: true,
                 timing: `stale-cache(${err instanceof Error ? err.message : String(err)})`
               });
+              if (queryAwarePrefilterIsEmpty) {
+                return emptyQueryAwareQmdResult;
+              }
               return staleQmdFallback.value;
             }
             throw err;
@@ -7489,89 +7516,53 @@ ${tmtNode.summary}`
           impressionRecorded = true;
         } else if (!confidenceGateRejected) {
           const queryAwarePrefilter = await queryAwarePrefilterPromise;
-          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
-          );
-          if (scoped.length > 0) {
-            if (shouldPersistGraphSnapshot) {
-              graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
-                scoped,
-                graphSourceLabelsForPath
-              );
-            }
-            recallSource = "hot_embedding";
-            recalledMemoryCount = scoped.length;
-            this.publishRecallResults({
-              title: "Relevant Memories",
-              results: scoped,
-              sectionBuckets,
+          if (queryAwarePrefilter.candidatePaths?.size !== 0) {
+            const embeddingResults = await this.searchEmbeddingFallback(
               retrievalQuery,
-              sessionKey,
-              identityInjection: {
-                mode: identityInjectionModeUsed,
-                injectedChars: identityInjectedChars,
-                truncated: identityInjectionTruncated
+              embeddingFetchLimit
+            );
+            const prefilteredEmbeddingResults = applyQueryAwareCandidateFilter(
+              embeddingResults,
+              queryAwarePrefilter.candidatePaths
+            );
+            const scopedCandidates = filterRecallCandidates(
+              prefilteredEmbeddingResults,
+              {
+                namespacesEnabled: this.config.namespacesEnabled,
+                recallNamespaces,
+                resolveNamespace: (p) => this.namespaceFromPath(p),
+                limit: embeddingFetchLimit
               }
-            });
-            recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
-            recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
-            xrayRecalledResults = scoped;
-            impressionRecorded = true;
-          } else {
-            const longTerm = await this.applyColdFallbackPipeline({
-              prompt: retrievalQuery,
+            );
+            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,
-              recallMode,
-              queryAwarePrefilter,
-              abortSignal: options.abortSignal,
-              xrayPoolSizeSink: xrayColdPoolSink,
-              asOfMs,
-              ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
-            });
-            if (longTerm.length > 0) {
+              retrievalQuery
+            );
+            if (scoped.length > 0) {
               if (shouldPersistGraphSnapshot) {
                 graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
-                  longTerm,
+                  scoped,
                   graphSourceLabelsForPath
                 );
               }
-              recallSource = "cold_fallback";
-              recalledMemoryCount = longTerm.length;
+              recallSource = "hot_embedding";
+              recalledMemoryCount = scoped.length;
               this.publishRecallResults({
-                title: "Long-Term Memories (Fallback)",
-                results: longTerm,
+                title: "Relevant Memories",
+                results: scoped,
                 sectionBuckets,
                 retrievalQuery,
                 sessionKey,
@@ -7581,10 +7572,48 @@ ${tmtNode.summary}`
                   truncated: identityInjectionTruncated
                 }
               });
-              recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
-              recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
-              xrayRecalledResults = longTerm;
+              recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
+              recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
+              xrayRecalledResults = scoped;
               impressionRecorded = true;
+            } else {
+              const longTerm = await this.applyColdFallbackPipeline({
+                prompt: retrievalQuery,
+                recallNamespaces,
+                recallResultLimit,
+                recallMode,
+                queryAwarePrefilter,
+                abortSignal: options.abortSignal,
+                xrayPoolSizeSink: xrayColdPoolSink,
+                asOfMs,
+                ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
+              });
+              if (longTerm.length > 0) {
+                if (shouldPersistGraphSnapshot) {
+                  graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
+                    longTerm,
+                    graphSourceLabelsForPath
+                  );
+                }
+                recallSource = "cold_fallback";
+                recalledMemoryCount = longTerm.length;
+                this.publishRecallResults({
+                  title: "Long-Term Memories (Fallback)",
+                  results: longTerm,
+                  sectionBuckets,
+                  retrievalQuery,
+                  sessionKey,
+                  identityInjection: {
+                    mode: identityInjectionModeUsed,
+                    injectedChars: identityInjectedChars,
+                    truncated: identityInjectionTruncated
+                  }
+                });
+                recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
+                recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+                xrayRecalledResults = longTerm;
+                impressionRecorded = true;
+              }
             }
           }
         }
@@ -7621,178 +7650,90 @@ ${tmtNode.summary}`
         }
       } else if (recallResultLimit > 0 && !this.qmd.isAvailable()) {
         const queryAwarePrefilter = await queryAwarePrefilterPromise;
-        const embeddingResults = await this.searchEmbeddingFallback(
-          retrievalQuery,
-          embeddingFetchLimit
-        );
-        const prefilteredEmbeddingResults = applyQueryAwareCandidateFilter(
-          embeddingResults,
-          queryAwarePrefilter.candidatePaths
-        );
-        const scopedCandidates = filterRecallCandidates(
-          prefilteredEmbeddingResults,
-          {
-            namespacesEnabled: this.config.namespacesEnabled,
+        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,
-            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
-        );
-        if (scoped.length > 0) {
-          if (shouldPersistGraphSnapshot) {
-            graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
-              scoped,
-              graphSourceLabelsForPath
-            );
-          }
-          recallSource = "hot_embedding";
-          recalledMemoryCount = scoped.length;
-          this.publishRecallResults({
-            title: "Relevant Memories",
-            results: scoped,
-            sectionBuckets,
             retrievalQuery,
-            sessionKey,
-            identityInjection: {
-              mode: identityInjectionModeUsed,
-              injectedChars: identityInjectedChars,
-              truncated: identityInjectionTruncated
+            void 0,
+            { asOfMs }
+          );
+          xrayBranchPoolSize.hot_embedding = Math.max(
+            xrayBranchPoolSize.hot_embedding,
+            boostedScoped.length
+          );
+          const scoped = this.diversifyAndLimitRecallResults(
+            "memories",
+            boostedScoped,
+            recallResultLimit,
+            retrievalQuery
+          );
+          if (scoped.length > 0) {
+            if (shouldPersistGraphSnapshot) {
+              graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
+                scoped,
+                graphSourceLabelsForPath
+              );
             }
-          });
-          recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
-          recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
-          xrayRecalledResults = scoped;
-          impressionRecorded = true;
-        } else {
-          const memories = await this.readAllMemoriesForNamespaces(recallNamespaces);
-          if (memories.length > 0) {
-            const supersessionOptions = {
-              enabled: this.config.temporalSupersessionEnabled,
-              includeInRecall: this.config.temporalSupersessionIncludeInRecall
-            };
-            const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
-            const activeMemories = memories.filter(
-              (m) => {
-                if (isArtifactMemoryPath(m.path)) return false;
-                const status = m.frontmatter.status;
-                if (!status || status === "active") return true;
-                if (status === "superseded") {
-                  if (asOfActive) return true;
-                  return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
-                }
-                return false;
+            recallSource = "hot_embedding";
+            recalledMemoryCount = scoped.length;
+            this.publishRecallResults({
+              title: "Relevant Memories",
+              results: scoped,
+              sectionBuckets,
+              retrievalQuery,
+              sessionKey,
+              identityInjection: {
+                mode: identityInjectionModeUsed,
+                injectedChars: identityInjectedChars,
+                truncated: identityInjectionTruncated
               }
-            );
-            const queryAwareScopedMemories = queryAwarePrefilter.candidatePaths ? activeMemories.filter(
-              (memory) => queryAwarePrefilter.candidatePaths?.has(memory.path)
-            ) : activeMemories;
-            if (queryAwarePrefilter.candidatePaths && queryAwareScopedMemories.length === 0) {
-              const longTerm = await this.applyColdFallbackPipeline({
-                prompt: retrievalQuery,
-                recallNamespaces,
-                recallResultLimit,
-                recallMode,
-                queryAwarePrefilter,
-                abortSignal: options.abortSignal,
-                xrayPoolSizeSink: xrayColdPoolSink,
-                asOfMs,
-                ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
-              });
-              if (longTerm.length > 0) {
-                recallSource = "cold_fallback";
-                recalledMemoryCount = longTerm.length;
-                this.publishRecallResults({
-                  title: "Long-Term Memories (Fallback)",
-                  results: longTerm,
-                  sectionBuckets,
-                  retrievalQuery,
-                  sessionKey,
-                  identityInjection: {
-                    mode: identityInjectionModeUsed,
-                    injectedChars: identityInjectedChars,
-                    truncated: identityInjectionTruncated
+            });
+            recalledMemoryIds = this.extractMemoryIdsFromResults(scoped);
+            recalledMemoryPaths = scoped.map((result) => result.path).filter(Boolean);
+            xrayRecalledResults = scoped;
+            impressionRecorded = true;
+          } else {
+            const memories = await this.readAllMemoriesForNamespaces(recallNamespaces);
+            if (memories.length > 0) {
+              const supersessionOptions = {
+                enabled: this.config.temporalSupersessionEnabled,
+                includeInRecall: this.config.temporalSupersessionIncludeInRecall
+              };
+              const asOfActive = typeof asOfMs === "number" && Number.isFinite(asOfMs);
+              const activeMemories = memories.filter(
+                (m) => {
+                  if (isArtifactMemoryPath(m.path)) return false;
+                  const status = m.frontmatter.status;
+                  if (!status || status === "active") return true;
+                  if (status === "superseded") {
+                    if (asOfActive) return true;
+                    return !shouldFilterSupersededFromRecall(m.frontmatter, supersessionOptions);
                   }
-                });
-                recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
-                recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
-                xrayRecalledResults = longTerm;
-                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
-              );
-              if (recent.length > 0) {
-                if (shouldPersistGraphSnapshot) {
-                  graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
-                    recent,
-                    graphSourceLabelsForPath
-                  );
+                  return false;
                 }
-                recallSource = "recent_scan";
-                recalledMemoryCount = recent.length;
-                this.publishRecallResults({
-                  title: "Recent Memories",
-                  results: recent,
-                  sectionBuckets,
-                  retrievalQuery,
-                  sessionKey,
-                  identityInjection: {
-                    mode: identityInjectionModeUsed,
-                    injectedChars: identityInjectedChars,
-                    truncated: identityInjectionTruncated
-                  }
-                });
-                recalledMemoryIds = this.extractMemoryIdsFromResults(recent);
-                recalledMemoryPaths = recent.map((result) => result.path).filter(Boolean);
-                xrayRecalledResults = recent;
-                impressionRecorded = true;
-              } else {
+              );
+              const queryAwareScopedMemories = queryAwarePrefilter.candidatePaths ? activeMemories.filter(
+                (memory) => queryAwarePrefilter.candidatePaths?.has(memory.path)
+              ) : activeMemories;
+              if (queryAwarePrefilter.candidatePaths && queryAwareScopedMemories.length === 0) {
                 const longTerm = await this.applyColdFallbackPipeline({
                   prompt: retrievalQuery,
                   recallNamespaces,
@@ -7805,12 +7746,6 @@ ${tmtNode.summary}`
                   ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
                 });
                 if (longTerm.length > 0) {
-                  if (shouldPersistGraphSnapshot) {
-                    graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
-                      longTerm,
-                      graphSourceLabelsForPath
-                    );
-                  }
                   recallSource = "cold_fallback";
                   recalledMemoryCount = longTerm.length;
                   this.publishRecallResults({
@@ -7830,45 +7765,141 @@ ${tmtNode.summary}`
                   xrayRecalledResults = longTerm;
                   impressionRecorded = true;
                 }
-              }
-            }
-          } else {
-            const longTerm = await this.applyColdFallbackPipeline({
-              prompt: retrievalQuery,
-              recallNamespaces,
-              recallResultLimit,
-              recallMode,
-              queryAwarePrefilter,
-              abortSignal: options.abortSignal,
-              xrayPoolSizeSink: xrayColdPoolSink,
-              asOfMs,
-              ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
-            });
-            if (longTerm.length > 0) {
-              if (shouldPersistGraphSnapshot) {
-                graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
-                  longTerm,
-                  graphSourceLabelsForPath
+              } else {
+                const recentSorted = queryAwareScopedMemories.sort(
+                  (a, b) => new Date(b.frontmatter.updated).getTime() - new Date(a.frontmatter.updated).getTime()
                 );
-              }
-              recallSource = "cold_fallback";
-              recalledMemoryCount = longTerm.length;
-              this.publishRecallResults({
-                title: "Long-Term Memories (Fallback)",
-                results: longTerm,
-                sectionBuckets,
-                retrievalQuery,
-                sessionKey,
-                identityInjection: {
-                  mode: identityInjectionModeUsed,
-                  injectedChars: identityInjectedChars,
-                  truncated: identityInjectionTruncated
+                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
+                );
+                if (recent.length > 0) {
+                  if (shouldPersistGraphSnapshot) {
+                    graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
+                      recent,
+                      graphSourceLabelsForPath
+                    );
+                  }
+                  recallSource = "recent_scan";
+                  recalledMemoryCount = recent.length;
+                  this.publishRecallResults({
+                    title: "Recent Memories",
+                    results: recent,
+                    sectionBuckets,
+                    retrievalQuery,
+                    sessionKey,
+                    identityInjection: {
+                      mode: identityInjectionModeUsed,
+                      injectedChars: identityInjectedChars,
+                      truncated: identityInjectionTruncated
+                    }
+                  });
+                  recalledMemoryIds = this.extractMemoryIdsFromResults(recent);
+                  recalledMemoryPaths = recent.map((result) => result.path).filter(Boolean);
+                  xrayRecalledResults = recent;
+                  impressionRecorded = true;
+                } else {
+                  const longTerm = await this.applyColdFallbackPipeline({
+                    prompt: retrievalQuery,
+                    recallNamespaces,
+                    recallResultLimit,
+                    recallMode,
+                    queryAwarePrefilter,
+                    abortSignal: options.abortSignal,
+                    xrayPoolSizeSink: xrayColdPoolSink,
+                    asOfMs,
+                    ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
+                  });
+                  if (longTerm.length > 0) {
+                    if (shouldPersistGraphSnapshot) {
+                      graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
+                        longTerm,
+                        graphSourceLabelsForPath
+                      );
+                    }
+                    recallSource = "cold_fallback";
+                    recalledMemoryCount = longTerm.length;
+                    this.publishRecallResults({
+                      title: "Long-Term Memories (Fallback)",
+                      results: longTerm,
+                      sectionBuckets,
+                      retrievalQuery,
+                      sessionKey,
+                      identityInjection: {
+                        mode: identityInjectionModeUsed,
+                        injectedChars: identityInjectedChars,
+                        truncated: identityInjectionTruncated
+                      }
+                    });
+                    recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
+                    recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+                    xrayRecalledResults = longTerm;
+                    impressionRecorded = true;
+                  }
                 }
+              }
+            } else {
+              const longTerm = await this.applyColdFallbackPipeline({
+                prompt: retrievalQuery,
+                recallNamespaces,
+                recallResultLimit,
+                recallMode,
+                queryAwarePrefilter,
+                abortSignal: options.abortSignal,
+                xrayPoolSizeSink: xrayColdPoolSink,
+                asOfMs,
+                ...options.includeLowConfidence === true ? { includeLowConfidence: true } : {}
               });
-              recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
-              recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
-              xrayRecalledResults = longTerm;
-              impressionRecorded = true;
+              if (longTerm.length > 0) {
+                if (shouldPersistGraphSnapshot) {
+                  graphSnapshotFinalResults = this.buildGraphRecallRankedResults(
+                    longTerm,
+                    graphSourceLabelsForPath
+                  );
+                }
+                recallSource = "cold_fallback";
+                recalledMemoryCount = longTerm.length;
+                this.publishRecallResults({
+                  title: "Long-Term Memories (Fallback)",
+                  results: longTerm,
+                  sectionBuckets,
+                  retrievalQuery,
+                  sessionKey,
+                  identityInjection: {
+                    mode: identityInjectionModeUsed,
+                    injectedChars: identityInjectedChars,
+                    truncated: identityInjectionTruncated
+                  }
+                });
+                recalledMemoryIds = this.extractMemoryIdsFromResults(longTerm);
+                recalledMemoryPaths = longTerm.map((result) => result.path).filter(Boolean);
+                xrayRecalledResults = longTerm;
+                impressionRecorded = true;
+              }
             }
           }
         }
@@ -11718,6 +11749,7 @@ ${lines.join("\n\n")}`;
     throwIfRecallAborted(abortSignal);
     const cappedLimit = Math.max(0, limit);
     if (cappedLimit === 0) return [];
+    if (queryAwarePrefilter?.candidatePaths?.size === 0) return [];
     const scopedSeedResults = queryAwarePrefilter?.candidatePaths?.size ? await this.searchScopedMemoryCandidates(
       queryAwarePrefilter.candidatePaths,
       prompt,
@@ -11767,6 +11799,10 @@ ${lines.join("\n\n")}`;
     return [...mergedByPath.values()].filter((result) => !isArtifactMemoryPath(result.path)).sort((a, b) => b.score - a.score).slice(0, cappedLimit);
   }
   async applyColdFallbackPipeline(options) {
+    if (options.queryAwarePrefilter?.candidatePaths?.size === 0) {
+      if (options.xrayPoolSizeSink) options.xrayPoolSizeSink.size = 0;
+      return [];
+    }
     const coldQmdEnabled = this.config.qmdColdTierEnabled === true;
     const coldCollection = this.config.qmdColdCollection ?? "openclaw-engram-cold";
     const coldMaxResults = this.config.qmdColdMaxResults ?? this.config.qmdMaxResults;
@@ -12001,7 +12037,7 @@ ${lines.join("\n\n")}`;
         if (!s) return null;
         const scoped = new Set(Array.from(s).filter((p) => resultPaths.has(p)));
         if (maxCandidates === 0 || scoped.size <= maxCandidates)
-          return scoped.size > 0 ? scoped : null;
+          return scoped;
         return new Set(Array.from(scoped).slice(0, maxCandidates));
       };
       if (temporalFromDate !== null) {
@@ -12405,4 +12441,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-MTGOAU7A.js.map
+//# sourceMappingURL=chunk-OEIRQ7DB.js.map