@remnic/core 9.25.5 → 9.25.7

package/src/orchestration/recall-internal.ts

@@ -100,7 +100,7 @@ import {
   type QueryAwarePrefilter,
   type RecallInvocationOptions,
 } from "../orchestrator.js";
-import { isGenericRecallExcludedPath } from "./orchestrator-helpers.js";
+import { isGenericRecallExcludedPath } from "./generic-recall-paths.js";
 
 import type {
   RecallSectionAppendOptions,
@@ -4165,8 +4165,7 @@ export class RecallInternalCoordinator {
         memoryResults = memoryResults.filter((r) =>
           recallNamespaces.includes(r.namespace ?? this.deps.namespaceFromPath(r.path)));
       }
-      // Artifacts + activity digests are dedicated surfaces, never generic recall.
-      memoryResults = memoryResults.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config.memoryDir));
+      memoryResults = memoryResults.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config, "qmd"));
 
       const isFullModeGraphAssist =
         graphCaps.multiGraphMemory &&
@@ -4297,6 +4296,7 @@ export class RecallInternalCoordinator {
           }
         }
       }
+      memoryResults = memoryResults.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config, "qmd"));
 
       // Apply mandatory recall safety filters before deadline-bound scoring
       // enrichment. If scoring times out, we must fall back to this filtered
@@ -4550,7 +4550,7 @@ export class RecallInternalCoordinator {
                 recallNamespaces,
                 resolveNamespace: (p) => this.deps.namespaceFromPath(p),
                 limit: embeddingFetchLimit,
-                memoryRoot: this.deps.config.memoryDir,
+                pathPolicy: this.deps.config,
               },
             );
             const boostedScoped = await this.deps.boostSearchResults(
@@ -4745,7 +4745,7 @@ export class RecallInternalCoordinator {
                 recallNamespaces,
                 resolveNamespace: (p) => this.deps.namespaceFromPath(p),
                 limit: embeddingFetchLimit,
-                memoryRoot: this.deps.config.memoryDir,
+                pathPolicy: this.deps.config,
               },
             );
             const boostedScoped = await this.deps.boostSearchResults(
@@ -4868,7 +4868,7 @@ export class RecallInternalCoordinator {
             typeof asOfMs === "number" && Number.isFinite(asOfMs);
           const activeMemories = memories.filter(
             (m) => {
-              if (isGenericRecallExcludedPath(m.path, this.deps.config.memoryDir)) return false;
+              if (isGenericRecallExcludedPath(m.path, this.deps.config)) return false;
               const status = m.frontmatter.status;
               if (!status || status === "active") return true;
               if (status === "superseded") {

package/src/orchestration/recall-search-pipeline.test.ts

@@ -78,13 +78,12 @@ function scopedCandidatesStub(
     seed.filter((r) => candidatePaths.has(r.path)).slice(0, Math.max(0, limit));
 }
 
-function fallbackCoordinator(seed: QmdSearchResult[], archived: MemoryFile[]): RecallSearchPipelineCoordinator {
-  const readArchivedMemoriesForNamespaces: RecallSearchPipelineDeps["readArchivedMemoriesForNamespaces"] =
-    async () => archived;
+function queryAwareFallbackCoordinator(
+  seed: QmdSearchResult[],
+): RecallSearchPipelineCoordinator {
   const namespaceFromPath: RecallSearchPipelineDeps["namespaceFromPath"] = () => "default";
   const deps = {
     searchScopedMemoryCandidates: scopedCandidatesStub(seed),
-    readArchivedMemoriesForNamespaces,
     namespaceFromPath,
     config: { memoryDir: "/mem" },
   } as unknown as RecallSearchPipelineDeps;
@@ -107,48 +106,85 @@ const SEED_PATHS = [MEETING_RECORD, "facts/a.md", "artifacts/y.md"];
 const SEED_WITH_NON_RECALLABLE = SEED_PATHS.map((p) => result("default", p));
 const PREFILTER = prefilter(SEED_PATHS);
 
-test("archive fallback excludes non-recallable seeds on the archived-empty early return", async () => {
-  const coordinator = fallbackCoordinator(SEED_WITH_NON_RECALLABLE, []);
-  // limit 10 > filtered seed count, tokens non-empty, archived empty → the
-  // `return scopedSeedResults` early path at the archived-empty guard.
-  const out = await coordinator.searchLongTermArchiveFallback("quarterly report", ["default"], 10, PREFILTER);
+test("query-aware fallback filters non-recallable scoped candidates", async () => {
+  const coordinator = queryAwareFallbackCoordinator(SEED_WITH_NON_RECALLABLE);
+  const out = await coordinator.searchQueryAwareFallback("quarterly report", 10, PREFILTER);
   assert.deepEqual(
     out.map((r) => r.path),
     ["facts/a.md"],
-    "meeting record + artifact must not leak through the direct-caller early return",
+    "meeting records and artifacts must not leak through query-aware fallback",
   );
 });
 
-test("archive fallback excludes non-recallable seeds on the empty-tokens early return", async () => {
-  const coordinator = fallbackCoordinator(SEED_WITH_NON_RECALLABLE, [memory("facts/z.md", "archived")]);
-  // Empty prompt → zero tokens → the `return scopedSeedResults` early path
-  // before archive scoring is even attempted.
-  const out = await coordinator.searchLongTermArchiveFallback("", ["default"], 10, PREFILTER);
+test("query-aware fallback filters non-recallable scoped candidates for an empty query", async () => {
+  const coordinator = queryAwareFallbackCoordinator(SEED_WITH_NON_RECALLABLE);
+  const out = await coordinator.searchQueryAwareFallback("", 10, PREFILTER);
   assert.deepEqual(out.map((r) => r.path), ["facts/a.md"]);
 });
 
-test("archive fallback applies the cap to FILTERED seeds, not raw non-recallable hits", async () => {
-  // The scoped search returns a single non-recallable hit that would fill a cap
-  // of 1 if counted raw; the method must count only recallable seeds, so it does
-  // not early-return that hit and (archive empty) yields nothing.
-  const coordinator = fallbackCoordinator([result("default", MEETING_RECORD)], []);
-  const out = await coordinator.searchLongTermArchiveFallback("quarterly", ["default"], 1, prefilter([MEETING_RECORD]));
+test("query-aware fallback applies the cap after filtering", async () => {
+  const coordinator = queryAwareFallbackCoordinator([result("default", MEETING_RECORD)]);
+  const out = await coordinator.searchQueryAwareFallback("quarterly", 1, prefilter([MEETING_RECORD]));
   assert.deepEqual(out.map((r) => r.path), []);
 });
 
-test("finding 1 — overfetches scoped seeds before exclusion so a capped fetch still yields recallable hits", async () => {
+test("query-aware fallback excludes root archive candidates before its cap", async () => {
+  const archivePath = "archive/2026-02-23/fact-archived.md";
+  const coordinator = queryAwareFallbackCoordinator([
+    result("default", archivePath),
+    result("default", "facts/a.md"),
+  ]);
+
+  const out = await coordinator.searchQueryAwareFallback(
+    "quarterly",
+    1,
+    prefilter([archivePath, "facts/a.md"]),
+  );
+
+  assert.deepEqual(out.map((r) => r.path), ["facts/a.md"]);
+});
+
+test("query-aware fallback retains non-active candidates for historical filtering", async () => {
+  let optionsSeen: { allowArchived?: boolean } | undefined;
+  const searchScopedMemoryCandidates: RecallSearchPipelineDeps["searchScopedMemoryCandidates"] = async (
+    candidatePaths,
+    _query,
+    limit,
+    options,
+  ) => {
+    optionsSeen = options;
+    return [result("default", "facts/superseded.md")]
+      .filter((candidate) => candidatePaths.has(candidate.path))
+      .slice(0, limit);
+  };
+  const coordinator = new RecallSearchPipelineCoordinator({
+    config: { memoryDir: "/mem" },
+    namespaceFromPath: () => "default",
+    searchScopedMemoryCandidates,
+  } as unknown as RecallSearchPipelineDeps);
+
+  const out = await coordinator.searchQueryAwareFallback(
+    "historical incident",
+    1,
+    prefilter(["facts/superseded.md"]),
+  );
+
+  assert.deepEqual(out.map((candidate) => candidate.path), ["facts/superseded.md"]);
+  assert.deepEqual(optionsSeen, { allowArchived: true });
+});
+
+test("query-aware fallback overfetches scoped candidates before exclusion", async () => {
   // The scoped candidate order puts the NON-recallable meeting record FIRST;
   // capping the scoped fetch to the caller's limit (1) BEFORE the generic-recall
   // exclusion would return only the meeting record, which is then filtered out —
   // dropping facts/a.md with no refill. Overfetching the full candidate set first
   // and excluding afterward must still surface the recallable hit at the cap.
-  const coordinator = fallbackCoordinator(
-    [result("default", MEETING_RECORD), result("default", "facts/a.md")],
-    [],
-  );
-  const out = await coordinator.searchLongTermArchiveFallback(
+  const coordinator = queryAwareFallbackCoordinator([
+    result("default", MEETING_RECORD),
+    result("default", "facts/a.md"),
+  ]);
+  const out = await coordinator.searchQueryAwareFallback(
     "quarterly",
-    ["default"],
     1,
     prefilter([MEETING_RECORD, "facts/a.md"]),
   );
@@ -159,6 +195,7 @@ test("finding 1 — overfetches scoped seeds before exclusion so a capped fetch
   );
 });
 
+
 function hotSeedCoordinator(seed: QmdSearchResult[]): RecallSearchPipelineCoordinator {
   const deps = {
     config: { memoryDir: "/mem", qmdSearchStrategy: "lex", searchBackend: "qmd" },
@@ -250,3 +287,132 @@ test("finding 1 (round-5) — excluded seeds must not fill the merge cap and sta
     "excluded seeds ranked ahead must not fill the fetchLimit cap and starve the recallable primary hit",
   );
 });
+
+test("QMD widening continues past archive-only pages", async () => {
+  const archived = Array.from({ length: 45 }, (_, index) =>
+    resultScored("default", `archive/2026-07-25/archive-${index}.md`, 2),
+  );
+  const live = resultScored("default", "facts/live.md", 1);
+  const ranked = [...archived, live];
+  const coordinator = new RecallSearchPipelineCoordinator({
+    config: { memoryDir: "/mem", qmdSearchStrategy: "lex", searchBackend: "qmd" },
+    qmd: {},
+    namespaceFromPath: () => "default",
+    searchAcrossNamespaces: async ({ maxResults }: { maxResults: number }) =>
+      ranked.slice(0, maxResults),
+  } as unknown as RecallSearchPipelineDeps);
+
+  const out = await coordinator.fetchQmdMemoryResultsWithArtifactTopUp(
+    "archive-starved",
+    20,
+    20,
+    {
+      namespacesEnabled: false,
+      recallNamespaces: ["default"],
+      resolveNamespace: () => "default",
+      queryAwarePrefilter: {
+        candidatePaths: null,
+        temporalFromDate: null,
+        matchedTags: [],
+        expandedTags: [],
+        combination: "none",
+        filteredToFullSearch: false,
+      },
+    },
+  );
+
+  assert.deepEqual(out.map((candidate) => candidate.path), ["facts/live.md"]);
+});
+
+test("QMD hybrid top-up runs when primary results are archive-only", async () => {
+  const archived = Array.from({ length: 20 }, (_, index) =>
+    resultScored("default", `archive/2026-07-25/archive-${index}.md`, 2),
+  );
+  const live = resultScored("default", "facts/hybrid-live.md", 1);
+  let hybridCalls = 0;
+  const coordinator = new RecallSearchPipelineCoordinator({
+    config: {
+      memoryDir: "/mem",
+      qmdSearchStrategy: "hybrid",
+      searchBackend: "qmd",
+    },
+    qmd: {
+      search: async (
+        _query: string,
+        _collection: string,
+        maxResults: number,
+      ) => archived.slice(0, maxResults),
+      hybridSearch: async () => {
+        hybridCalls += 1;
+        return [live];
+      },
+    },
+    namespaceFromPath: () => "default",
+  } as unknown as RecallSearchPipelineDeps);
+
+  const out = await coordinator.fetchQmdMemoryResultsWithArtifactTopUp(
+    "archive-starved-hybrid",
+    2,
+    2,
+    {
+      namespacesEnabled: false,
+      recallNamespaces: ["default"],
+      resolveNamespace: () => "default",
+      collection: "openclaw-engram",
+      queryAwarePrefilter: {
+        candidatePaths: null,
+        temporalFromDate: null,
+        matchedTags: [],
+        expandedTags: [],
+        combination: "none",
+        filteredToFullSearch: false,
+      },
+    },
+  );
+
+  assert.ok(hybridCalls > 0, "archive-only primary pages must trigger hybrid top-up");
+  assert.deepEqual(out.map((candidate) => candidate.path), ["facts/hybrid-live.md"]);
+});
+
+test("QMD stops after an underfilled archive-only page", async () => {
+  const archived = [resultScored("default", "archive/2026-07-25/only.md", 2)];
+  let searchCalls = 0;
+  const coordinator = new RecallSearchPipelineCoordinator({
+    config: {
+      memoryDir: "/mem",
+      qmdSearchStrategy: "hybrid",
+      searchBackend: "qmd",
+    },
+    qmd: {
+      search: async () => {
+        searchCalls += 1;
+        return archived;
+      },
+      hybridSearch: async () => [],
+    },
+    namespaceFromPath: () => "default",
+  } as unknown as RecallSearchPipelineDeps);
+
+  const out = await coordinator.fetchQmdMemoryResultsWithArtifactTopUp(
+    "archive-underfilled",
+    20,
+    20,
+    {
+      namespacesEnabled: false,
+      recallNamespaces: ["default"],
+      resolveNamespace: () => "default",
+      collection: "openclaw-engram",
+      queryAwarePrefilter: {
+        candidatePaths: null,
+        temporalFromDate: null,
+        matchedTags: [],
+        expandedTags: [],
+        combination: "none",
+        filteredToFullSearch: false,
+      },
+    },
+  );
+
+  assert.deepEqual(out, []);
+  assert.equal(searchCalls, 1, "an underfilled raw page must not trigger widening");
+});

package/src/orchestration/recall-search-pipeline.ts

@@ -28,7 +28,6 @@ import { NamespaceStorageRouter } from "../namespaces/storage.js";
 import { NegativeExampleStore } from "../negative.js";
 import { qmdCollectionPathParts } from "./qmd-result-resolver.js";
 import type { GraphRecallExpandedEntry } from "../recall-state.js";
-import { getDefaultArchiveScoring, memoryFileToScoreItem } from "../recall/archive-scoring.js";
 import { RelevanceStore } from "../relevance.js";
 import { RerankCache, rerankLocalOrNoop, reorderByRankedKeys } from "../rerank.js";
 import type { SearchBackend, SearchDegradation, SearchExecutionOptions, SearchQueryOptions } from "../search/port.js";
@@ -55,11 +54,11 @@ import {
   computeQmdHybridFetchLimit,
   filterRecallCandidates,
   throwIfRecallAborted,
-  tokenizeRecallQuery,
   type QmdRecallSnapshot,
   type QueryAwarePrefilter,
 } from "../orchestrator.js";
-import { isActivityDigestPath, isGenericRecallExcludedPath } from "./orchestrator-helpers.js";
+import { isActivityDigestPath } from "./orchestrator-helpers.js";
+import { isGenericRecallExcludedPath, isTopLevelArchivePath } from "./generic-recall-paths.js";
 
 export interface RecallSearchPipelineDeps {
   applyMemoryWorthRerank(
@@ -185,7 +184,6 @@ export interface RecallSearchPipelineDeps {
   namespaceFromPath(p: string): string;
   readonly negatives: NegativeExampleStore;
   readonly qmd: SearchBackend;
-  readArchivedMemoriesForNamespaces(namespaces: string[]): Promise<MemoryFile[]>;
   readQmdResultMemory(
     resultPath: string,
     fallbackStorage: StorageManager,
@@ -215,9 +213,8 @@ export interface RecallSearchPipelineDeps {
     searchOptions?: SearchQueryOptions;
     execution?: SearchExecutionOptions;
   }): Promise<QmdSearchResult[]>;
-  searchLongTermArchiveFallback(
+  searchQueryAwareFallback(
     prompt: string,
-    recallNamespaces: string[],
     limit: number,
     queryAwarePrefilter?: QueryAwarePrefilter,
     abortSignal?: AbortSignal,
@@ -422,26 +419,19 @@ export class RecallSearchPipelineCoordinator {
       ? await this.deps.searchScopedMemoryCandidates(
           queryAwarePrefilter.candidatePaths,
           prompt,
-          // Overfetch the FULL scoped candidate set BEFORE the generic-recall
-          // exclusion `filterRecallCandidates` applies below (L464). Capping to
-          // `qmdFetchLimit` here lets excluded paths (artifacts, activity digests,
-          // meeting records) consume the caller's budget and drop legitimate hits
-          // with no refill — the hot-path mirror of the archive-fallback fix. The
-          // candidate set is an already-bounded prefilter, so its size is the
-          // natural ceiling; the post-exclusion cap is applied by filterRecallCandidates.
+          // Exclude dedicated surfaces before capping the bounded prefilter set.
           queryAwarePrefilter.candidatePaths.size,
           { allowArchived: options.collection !== undefined },
         )
       : [];
     // Drop generic-recall-excluded records before the fetchLimit cap so they can't starve valid memories (#1995).
-    const recallable = (r: QmdSearchResult) => !isGenericRecallExcludedPath(r.path, this.deps.config.memoryDir);
+    const recallable = (r: QmdSearchResult) => !isGenericRecallExcludedPath(r.path, this.deps.config, "qmd");
 
     let fetchLimit = Math.max(qmdFetchLimit, qmdHybridFetchLimit);
     const maxFetchLimit = Math.min(
       320,
       Math.max(fetchLimit, qmdFetchLimit * 5),
     );
-    const MAX_ATTEMPTS = 2;
     const qmdRecallBudgetMs = this.deps.config.recallEnrichmentDeadlineMs ?? 25_000;
     const qmdRecallBudgetEnabled = qmdRecallBudgetMs > 0;
     const startedAtMs = Date.now();
@@ -475,7 +465,7 @@ export class RecallSearchPipelineCoordinator {
       recallNamespaces: options.recallNamespaces,
       resolveNamespace: options.resolveNamespace,
       limit: qmdFetchLimit,
-      memoryRoot: this.deps.config.memoryDir,
+      pathPolicy: this.deps.config,
     });
     const emitDebugSnapshot = async (
       results: QmdSearchResult[],
@@ -508,7 +498,7 @@ export class RecallSearchPipelineCoordinator {
       return [];
     }
 
-    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    for (;;) {
       throwIfRecallAborted(options.abortSignal);
       if (
         qmdRecallBudgetEnabled &&
@@ -554,10 +544,15 @@ export class RecallSearchPipelineCoordinator {
       lastHybridTopUpUsed = false;
       lastHybridTopUpSkippedReason = undefined;
       let mergedResults = primaryResults;
+      const primaryRecallableCount = primaryResults.filter(recallable).length;
+      const primaryIncludesArchivePath = primaryResults.some((result) =>
+        isTopLevelArchivePath(result.path, this.deps.config, "qmd"),
+      );
 
-      // Backfill with hybrid results only when primary retrieval underfills.
+      // Backfill with hybrid results when the recallable primary page underfills.
       if (
-        primaryResults.length < qmdFetchLimit &&
+        primaryRecallableCount < qmdFetchLimit &&
+        (primaryResults.length < qmdFetchLimit || primaryIncludesArchivePath) &&
         (!qmdRecallBudgetEnabled ||
           Date.now() - startedAtMs < qmdRecallBudgetMs)
       ) {
@@ -620,7 +615,7 @@ export class RecallSearchPipelineCoordinator {
         recallNamespaces: options.recallNamespaces,
         resolveNamespace: options.resolveNamespace,
         limit: fetchLimit,
-        memoryRoot: this.deps.config.memoryDir,
+        pathPolicy: this.deps.config,
       });
 
       if (filteredResults.length >= qmdFetchLimit) {
@@ -631,11 +626,9 @@ export class RecallSearchPipelineCoordinator {
       if (filteredResults.length > bestFiltered.length) {
         bestFiltered = filteredResults;
       }
-      if (mergedResults.length === 0) {
-        await emitDebugSnapshot(filteredResults, fetchLimit);
-        return filteredResults;
-      }
-      if (mergedResults.length < fetchLimit && filteredResults.length > 0) {
+      // A full raw page may filter down to nothing (for example, archive-only
+      // hits). Keep widening until the backend itself underfills the page.
+      if (primaryResults.length < fetchLimit) {
         await emitDebugSnapshot(filteredResults, fetchLimit);
         return filteredResults;
       }
@@ -679,20 +672,18 @@ export class RecallSearchPipelineCoordinator {
   }
 
   /**
-   * Long-term fallback retrieval.
-   * Searches archived memories only, and is invoked only when hot recall returns zero hits.
+   * Cold fallback retains qualifying query-aware candidates. Archive records
+   * belong to dedicated surfaces and never re-enter generic recall.
    */
-  async searchLongTermArchiveFallback(
+  async searchQueryAwareFallback(
     prompt: string,
-    recallNamespaces: string[],
     limit: number,
     queryAwarePrefilter?: QueryAwarePrefilter,
     abortSignal?: AbortSignal,
   ): Promise<QmdSearchResult[]> {
     throwIfRecallAborted(abortSignal);
     const cappedLimit = Math.max(0, limit);
-    if (cappedLimit === 0) return [];
-    if (queryAwarePrefilter?.candidatePaths?.size === 0) return [];
+    if (cappedLimit === 0 || queryAwarePrefilter?.candidatePaths?.size === 0) return [];
 
     const candidatePaths = queryAwarePrefilter?.candidatePaths;
     const scopedSeedResults = (
@@ -700,57 +691,12 @@ export class RecallSearchPipelineCoordinator {
         ? await this.deps.searchScopedMemoryCandidates(
             candidatePaths,
             prompt,
-            // Overfetch the FULL scoped candidate set BEFORE the generic-recall
-            // exclusion below. Capping to `cappedLimit` first lets excluded paths
-            // (artifacts, activity digests, meeting records) consume the caller's
-            // budget and drop legitimate hits with no refill — e.g. a prefilter of
-            // [meetingRecord, facts/a.md] at limit 1 would return nothing. The
-            // candidate set is an already-bounded prefilter, so its size is the
-            // natural ceiling; the post-exclusion cap is applied below.
             candidatePaths.size,
             { allowArchived: true },
           )
         : []
-    ).filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config.memoryDir));
-    // Non-recallable seed paths (artifacts, activity digests, meeting records) are
-    // excluded above AFTER an unconstrained candidate fetch, so the cap here counts
-    // only recallable seeds — and EVERY early-return / direct-caller path below
-    // returns already-filtered, budget-honoring seeds.
-    if (scopedSeedResults.length >= cappedLimit) {
-      return scopedSeedResults.slice(0, cappedLimit);
-    }
-
-    const tokens = Array.from(new Set(tokenizeRecallQuery(prompt)));
-    if (tokens.length === 0) return scopedSeedResults;
-
-    throwIfRecallAborted(abortSignal);
-    const archivedMemories =
-      await this.deps.readArchivedMemoriesForNamespaces(recallNamespaces);
-    if (archivedMemories.length === 0) return scopedSeedResults;
-
-    // Issue #1674: off-load the CPU-bound archive-scoring loop to a
-    // worker_threads pool so concurrent recall requests run on separate
-    // cores instead of serializing on the main JS thread. The pure scoring
-    // function is identical to the old inline loop — only the execution
-    // context changed. Aborts are checked at the boundaries (before submit
-    // and after result); the worker's work is bounded by the file count.
-    throwIfRecallAborted(abortSignal);
-    const scoring = getDefaultArchiveScoring();
-    const scoredResults = await scoring.score(archivedMemories.map(memoryFileToScoreItem), tokens, abortSignal);
-    throwIfRecallAborted(abortSignal);
-    const scored: QmdSearchResult[] = scoredResults.map((r) => ({
-      docid: r.docid,
-      path: r.path,
-      score: r.score,
-      snippet: r.snippet,
-    }));
-
-    return dedupeResultsByNamespace(
-      [...scopedSeedResults, ...scored],
-      this.deps.namespaceFromPath,
-      cappedLimit,
-      { filter: (result) => !isGenericRecallExcludedPath(result.path, this.deps.config.memoryDir) },
-    );
+    ).filter((result) => !isGenericRecallExcludedPath(result.path, this.deps.config, "qmd"));
+    return scopedSeedResults.slice(0, cappedLimit);
   }
 
   async applyColdFallbackPipeline(options: {
@@ -935,17 +881,19 @@ export class RecallSearchPipelineCoordinator {
       }
     }
     if (longTerm.length === 0) {
-      // The archive-scan scoring worker terminates when EITHER the caller
-      // aborts or this step's own deadline wins — both flow through the
-      // step signal injected by runColdStepWithinDeadline (#1674, #1907).
       longTerm = await runColdStepWithinDeadline(
-        "archive scan", [],
-        (stepSignal) => this.deps.searchLongTermArchiveFallback(
-          options.prompt, options.recallNamespaces, options.recallResultLimit,
-          options.queryAwarePrefilter, stepSignal),
+        "query-aware fallback",
+        [],
+        (stepSignal) =>
+          this.deps.searchQueryAwareFallback(
+            options.prompt,
+            options.recallResultLimit,
+            options.queryAwarePrefilter,
+            stepSignal,
+          ),
       );
       if (longTerm.length > 0) {
-        log.debug("cold-tier recall source=archive-scan");
+        log.debug("cold-tier recall source=query-aware-fallback");
       }
     }
     if (longTerm.length === 0) return [];
@@ -997,9 +945,8 @@ export class RecallSearchPipelineCoordinator {
       }
       results = scopedResults;
     }
-    // Dedicated-surface isolation: generic recall must exclude artifacts and
-    // activity digests (both remain readable via explicit search).
-    results = results.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config.memoryDir));
+    // Dedicated-surface isolation keeps generic recall out of artifacts, activity digests, and archives.
+    results = results.filter((r) => !isGenericRecallExcludedPath(r.path, this.deps.config, "qmd"));
     if (results.length === 0) return [];
 
     const isFullModeGraphAssist =
@@ -1022,6 +969,9 @@ export class RecallSearchPipelineCoordinator {
       });
       results = merged;
     }
+    results = results.filter(
+      (result) => !isGenericRecallExcludedPath(result.path, this.deps.config, "qmd"),
+    );
 
     const boostInput = await this.deps.filterSearchResultsForRecall(
       results,

package/src/orchestrator.ts

@@ -134,11 +134,11 @@ import {
   computeSemanticDedupScope,
   qmdCollectionNamespaceFromPrefix as computeQmdCollectionNamespaceFromPrefix,
 } from "./orchestration/orchestrator-namespace-scope.js";
+import { isGenericRecallExcludedPath } from "./orchestration/generic-recall-paths.js";
 import {
   abortRecallError,
   buildCompressionGuidelinesMarkdown,
   buildQmdIntentHint,
-  isGenericRecallExcludedPath,
   mergeArtifactRecallCandidates,
   tokenizeRecallQuery,
   type BulkImportBatchIngestResult,
@@ -163,7 +163,6 @@ export {
   computeQmdHybridFetchLimit,
   defaultWorkspaceDir,
   filterHourlySummaryMarkdownForLocalDay,
-  filterRecallCandidates,
   formatDateInTimeZone,
   isArtifactMemoryPath,
   lifecycleRecallScoreAdjustment,
@@ -198,6 +197,7 @@ export {
   type RecallInvocationOptions,
   type RecallModeDecision,
 } from "./orchestration/orchestrator-helpers.js";
+export { filterRecallCandidates } from "./orchestration/generic-recall-paths.js";
 
 export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
 import {
@@ -541,7 +541,6 @@ import type {
   RecallSectionConfig,
   RecallTierExplain,
 } from "./types.js";
-import { disposeDefaultArchiveScoring, getDefaultArchiveScoring, memoryFileToScoreItem } from "./recall/archive-scoring.js";
 
 // Issue #1526 seam 15: ExtractionRunResult moved to orchestration/extraction-run.ts.
 export type { ExtractionRunResult } from "./orchestration/extraction-run.js";
@@ -997,8 +996,6 @@ export class Orchestrator {
       if (this.conversationQmd && this.conversationQmd !== this.qmd) {
         await (this.conversationQmd as { dispose?: () => void | Promise<void> }).dispose?.();
       }
-      // Issue #1674: terminate archive-scoring worker threads on destroy.
-      await disposeDefaultArchiveScoring();
     } finally {
       if (bufferFlushError !== undefined) {
         log.warn(
@@ -2483,7 +2480,7 @@ export class Orchestrator {
     if (!paths) return null;
     const scoped = new Set<string>();
     for (const memoryPath of paths) {
-      if (!memoryPath || isGenericRecallExcludedPath(memoryPath, this.config.memoryDir)) continue;
+      if (!memoryPath || isGenericRecallExcludedPath(memoryPath, this.config, "qmd")) continue;
       if (
         resolveNamespaceCapabilities(this.config).namespaces &&
         !recallNamespaces.includes(this.namespaceFromPath(memoryPath))
@@ -3600,16 +3597,14 @@ export class Orchestrator {
     );
   }
 
-  private async searchLongTermArchiveFallback(
+  private async searchQueryAwareFallback(
     prompt: string,
-    recallNamespaces: string[],
     limit: number,
     queryAwarePrefilter?: QueryAwarePrefilter,
     abortSignal?: AbortSignal,
   ): Promise<QmdSearchResult[]> {
-    return this.recallSearchPipelineCoordinator.searchLongTermArchiveFallback(
+    return this.recallSearchPipelineCoordinator.searchQueryAwareFallback(
       prompt,
-      recallNamespaces,
       limit,
       queryAwarePrefilter,
       abortSignal,
@@ -3968,11 +3963,4 @@ export class Orchestrator {
       namespaces,
     );
   }
-  private async readArchivedMemoriesForNamespaces(
-    namespaces: string[],
-  ): Promise<MemoryFile[]> {
-    return this.namespaceReadFanoutCoordinator.readArchivedMemoriesForNamespaces(
-      namespaces,
-    );
-  }
 }