@remnic/core 9.3.737 → 9.3.739

package/src/orchestrator.ts

@@ -102,6 +102,8 @@ import { SemanticConsolidationCoordinator } from "./orchestration/semantic-conso
 import { LifecyclePolicyCoordinator } from "./orchestration/lifecycle-policy-coordinator.js";
 import { EntitySynthesisCoordinator } from "./orchestration/entity-synthesis-coordinator.js";
 import { RecallResultFormatter } from "./orchestration/recall-result-formatter.js";
+import { ConversationIndexCoordinator } from "./orchestration/conversation-index-coordinator.js";
+import { RecallRerankCoordinator } from "./orchestration/recall-rerank-coordinator.js";
 export { hasIdentityRecoveryIntent, resolveEffectiveIdentityInjectionMode } from "./orchestration/recall-result-formatter.js";
 import {
   runLiveConnectorsOnce,
@@ -121,16 +123,8 @@ import {
   type ParallelSearchResult,
 } from "./retrieval-agents.js";
 import { RerankCache, rerankLocalOrNoop } from "./rerank.js";
-import {
-  applyMemoryWorthFilter,
-  buildMemoryWorthCounterMap,
-  type MemoryWorthCounters,
-} from "./memory-worth-filter.js";
-import { applyTrustScoreStage, buildTrustSignalsForRerank, projectTrustForXray } from "./trust-score-stage.js";
+import { projectTrustForXray } from "./trust-score-stage.js";
 import type { TrustStageResultItem } from "./trust-score-stage.js";
-import { renderEpistemicHedge, type TrustSignals } from "./trust-score.js";
-import { reorderRecallResultsWithMmr } from "./recall-mmr.js";
-import { applyReasoningTraceBoost } from "./reasoning-trace-recall.js";
 import { buildRetrievedMemoryProvenance } from "./memory-provenance.js";
 import {
   applyTemporalSupersession,
@@ -267,8 +261,7 @@ import {
   type TrustZoneSearchResult,
 } from "./trust-zones.js";
 import { tryDirectAnswer, type DirectAnswerSources } from "./direct-answer-wiring.js";
-import {
-  resolveNamespaceCapabilities,
+import { resolveNamespaceCapabilities,
   resolveCapabilities,
   resolveGraphConstructionCapabilities,
   resolveMemoryLifecycleCapabilities,
@@ -282,7 +275,7 @@ import {
   resolveQmdCapabilities,
   resolveIdentityContinuityCapabilities,
   resolveLocalLlmCapabilities,
-  resolveSecurityCapabilities, resolveEvalCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities} from "./capabilities.js";
+  resolveSecurityCapabilities, resolveEvalCapabilities, resolveUtilityLearningCapabilities, resolveObjectiveStateCapabilities, resolveCompressionCapabilities, resolvePresentationCapabilities, resolveConsolidationCapabilities, resolveRecallAuxiliaryCapabilities } from "./capabilities.js";
 import { DEFAULT_TAXONOMY } from "./taxonomy/index.js";
 import {
   searchHarmonicRetrieval,
@@ -331,9 +324,6 @@ import {
   type SemanticConsolidationLlmOperator,
   type SemanticConsolidationResult,
 } from "./semantic-consolidation.js";
-import { chunkTranscriptEntries } from "./conversation-index/chunker.js";
-import { writeConversationChunks } from "./conversation-index/indexer.js";
-import { cleanupConversationChunks } from "./conversation-index/cleanup.js";
 import {
   type ConversationIndexBackend,
   type ConversationIndexBackendInspection,
@@ -1818,31 +1808,6 @@ export class Orchestrator {
   readonly lcmEngine: LcmEngine | null = null;
   private readonly rerankCache = new RerankCache();
 
-  /**
-   * Short-TTL cache for Memory Worth counter lookups so interactive recall
-   * doesn't trigger a full `readAllMemories` scan per query. Keyed by
-   * namespace; the filter unions across namespaces at query time. The TTL
-   * is intentionally short (seconds, not minutes) because counters are
-   * mutated by `recordMemoryOutcome` asynchronously and we'd rather serve
-   * a 30-second-stale worth score than a stable-but-wrong one.
-   */
-  private readonly memoryWorthCounterCache = new Map<
-    string,
-    { at: number; counters: ReadonlyMap<string, MemoryWorthCounters> }
-  >();
-  private static readonly MEMORY_WORTH_CACHE_TTL_MS = 30_000;
-  /**
-   * Issue #1577 — per-namespace TrustScore signal map cache. Same TTL/shape
-   * discipline as {@link memoryWorthCounterCache}: seconds-scale, evicted on
-   * every call, keyed by namespace. Holds the frontmatter-derived signals
-   * (worth, provenance, faithfulness, corroboration, recency) so the trust
-   * stage doesn't trigger a fresh `readAllMemories` scan per query.
-   */
-  private readonly trustSignalCache = new Map<
-    string,
-    { at: number; signals: ReadonlyMap<string, TrustSignals> }
-  >();
-  private static readonly TRUST_SIGNAL_CACHE_TTL_MS = 30_000;
   /**
    * Per-session workspace selections keyed by sessionKey.
    * Set by the before_agent_start hook so recall() uses the correct
@@ -1910,6 +1875,12 @@ export class Orchestrator {
    * to RecallResultFormatter.
    */
   readonly recallResultFormatter: RecallResultFormatter;
+  /**
+   * Issue #1526: conversation-index subsystem moved to
+   * ConversationIndexCoordinator.
+   */
+  readonly conversationIndexCoordinator: ConversationIndexCoordinator;
+  readonly recallRerankCoordinator: RecallRerankCoordinator;
   private heartbeatObserverChains = new Map<string, Promise<void>>();
   private recentExtractionFingerprints = new Map<string, number>();
   private readonly consolidationObservers = new Set<
@@ -1918,7 +1889,6 @@ export class Orchestrator {
   private wearablesServiceInstance: WearablesService | null = null;
   private wearablesAutoSyncHandle: { stop(): Promise<void> } | null = null;
   private lastQmdReprobeAtMs = 0;
-  private readonly conversationIndexLastUpdateAtMs = new Map<string, number>();
   private lastFileHygieneRunAtMs = 0;
   // Pattern-reinforcement cadence gate (issue #687 PR 2/4).  Tracks the
   // last successful run so `runPatternReinforcement` can short-circuit
@@ -2565,7 +2535,7 @@ export class Orchestrator {
   private async contentHashIndexForStorage(
     targetStorage: StorageManager,
   ): Promise<ContentHashIndex | null> {
-    if (!this.config.factDeduplicationEnabled) return null;
+    if (!resolveRecallAuxiliaryCapabilities(this.config).factDeduplication) return null;
 
     if (targetStorage.dir === this.storage.dir) {
       if (!this.contentHashIndex) {
@@ -2828,7 +2798,7 @@ export class Orchestrator {
     if (config.defaultNamespace) this.storageRouter.bindCatalogWriteHook(this.storage, config.defaultNamespace);
     // Wire page-level versioning (issue #371)
     this.storage.setVersioningConfig({
-      enabled: config.versioningEnabled,
+      enabled: resolveRecallAuxiliaryCapabilities(config).versioning,
       maxVersionsPerPage: config.versioningMaxPerPage,
       sidecarDir: config.versioningSidecarDir,
     });
@@ -2851,7 +2821,7 @@ export class Orchestrator {
     // Wire at-rest encryption (issue #690 PR 3/4).
     // If secureStoreEnabled, check whether the keyring already holds a key
     // for this memory dir (e.g. operator unlocked before daemon restart).
-    if (config.secureStoreEnabled) {
+    if (resolveRecallAuxiliaryCapabilities(config).secureStore) {
       // Mark the store as required so writes throw SecureStoreLockedError
       // instead of silently falling back to plaintext when locked (P1 finding
       // from Cursor review of PR #767).
@@ -2889,7 +2859,7 @@ export class Orchestrator {
     this.sharedContext = config.sharedContextEnabled
       ? new SharedContextManager(config)
       : undefined;
-    this.compounding = config.compoundingEnabled
+    this.compounding = resolveConsolidationCapabilities(config).compounding
       ? new CompoundingEngine(config, this.storage)
       : undefined;
     this.buffer = new SmartBuffer(config, this.storage);
@@ -2899,6 +2869,18 @@ export class Orchestrator {
       "conversation-index",
       "chunks",
     );
+    this.conversationIndexCoordinator = new ConversationIndexCoordinator({
+      config,
+      getTranscript: () => this.transcript,
+      getBackend: () => this.conversationIndexBackend,
+      indexDir: this.conversationIndexDir,
+    });
+    this.recallRerankCoordinator = new RecallRerankCoordinator({
+      getConfig: () => this.config,
+      getStorage: (namespace) => this.getStorage(namespace),
+      readQmdResultMemory: (resultPath, fallbackStorage, recallNamespaces) =>
+        this.readQmdResultMemory(resultPath, fallbackStorage, recallNamespaces),
+    });
     this.modelRegistry = new ModelRegistry(config.memoryDir);
     this.relevance = new RelevanceStore(config.memoryDir);
     this.negatives = new NegativeExampleStore(config.memoryDir);
@@ -3081,7 +3063,7 @@ export class Orchestrator {
       this.boxBuilders.set(
         dir,
         new BoxBuilder(dir, {
-          memoryBoxesEnabled: this.config.memoryBoxesEnabled,
+          memoryBoxesEnabled: resolvePresentationCapabilities(this.config).memoryBoxes,
           traceWeaverEnabled: this.config.traceWeaverEnabled,
           boxTopicShiftThreshold: this.config.boxTopicShiftThreshold,
           boxTimeGapMs: this.config.boxTimeGapMs,
@@ -3427,7 +3409,7 @@ export class Orchestrator {
       });
 
       // Initialize content-hash dedup index
-      if (this.config.factDeduplicationEnabled) {
+      if (resolveRecallAuxiliaryCapabilities(this.config).factDeduplication) {
         this.contentHashIndex = this.storage.createContentHashIndex();
         await this.contentHashIndex.load();
         log.info(
@@ -3453,7 +3435,7 @@ export class Orchestrator {
         );
         this.buffer.resetToEmpty();
       }
-      if (this.config.compactionResetEnabled) {
+      if (resolveRecallAuxiliaryCapabilities(this.config).compactionReset) {
         try {
           const wsDir = this.config.workspaceDir || defaultWorkspaceDir();
           const files = await readdir(wsDir).catch(() => [] as string[]);
@@ -3677,7 +3659,7 @@ export class Orchestrator {
     // Awaited so callers of `deferredReady` can rely on warmups being complete
     // and shutdown sequencing does not race with in-flight cache builds.
     const cacheWarmups: Promise<void>[] = [];
-    if (this.config.knowledgeIndexEnabled) {
+    if (resolveRecallAuxiliaryCapabilities(this.config).knowledgeIndex) {
       cacheWarmups.push(
         (async () => {
           try {
@@ -3996,7 +3978,7 @@ export class Orchestrator {
     const cadenceKey = options.namespace ?? "";
     // Master switch: a disabled feature is never bypassed, even with
     // force=true.  `force` only relaxes the cadence floor below.
-    if (!this.config.patternReinforcementEnabled) {
+    if (!resolveConsolidationCapabilities(this.config).patternReinforcement) {
       return { ran: false, skippedReason: "disabled", namespace: cadenceKey };
     }
     const cadence = this.config.patternReinforcementCadenceMs;
@@ -4055,7 +4037,7 @@ export class Orchestrator {
           ? { itemCount: result.result.clustersFound }
           : { itemCount: 0 };
       },
-      { enabled: this.config.patternReinforcementEnabled },
+      { enabled: resolveConsolidationCapabilities(this.config).patternReinforcement },
     );
   }
 
@@ -4099,7 +4081,7 @@ export class Orchestrator {
         });
         return { itemCount: result.clustersFound };
       },
-      { enabled: this.config.semanticConsolidationEnabled },
+      { enabled: resolveConsolidationCapabilities(this.config).semanticConsolidation },
     );
   }
 
@@ -5007,63 +4989,21 @@ export class Orchestrator {
     retrievalQuery: string,
     topK: number,
   ): Promise<Array<{ path: string; snippet: string; score: number }>> {
-    if (this.conversationIndexBackend) {
-      return this.conversationIndexBackend.search(retrievalQuery, topK);
-    }
-    return [];
+    return this.conversationIndexCoordinator.search(retrievalQuery, topK);
   }
 
   private formatConversationRecallSection(
     results: Array<{ path: string; snippet: string; score: number }>,
     maxChars: number,
   ): string | null {
-    if (!Array.isArray(results) || results.length === 0) return null;
-    const lines: string[] = ["## Semantic Recall (Past Conversations)", ""];
-    let used = 0;
-    for (const r of results) {
-      if (!r?.snippet) continue;
-      const chunk =
-        `### ${r.path}\n` +
-        `Score: ${r.score.toFixed(3)}\n\n` +
-        `${r.snippet.trim()}\n`;
-      if (used + chunk.length > maxChars) break;
-      lines.push(chunk);
-      used += chunk.length;
-    }
-    return used > 0 ? lines.join("\n") : null;
-  }
-
-  private async countConversationChunkDocs(dir: string): Promise<number> {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-      let total = 0;
-      for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-          total += await this.countConversationChunkDocs(fullPath);
-          continue;
-        }
-        if (entry.isFile() && entry.name.endsWith(".md")) {
-          total += 1;
-        }
-      }
-      return total;
-    } catch {
-      return 0;
-    }
+    return this.conversationIndexCoordinator.formatRecallSection(
+      results,
+      maxChars,
+    );
   }
 
-  private async buildConversationIndexChunks(
-    sessionKey?: string,
-    hours: number = 24,
-  ): Promise<ReturnType<typeof chunkTranscriptEntries>> {
-    const entries = await this.transcript.readRecent(hours, sessionKey);
-    const effectiveSessionKey = sessionKey ?? "all-sessions";
-    return chunkTranscriptEntries(effectiveSessionKey, entries, {
-      maxChars: this.config.conversationRecallMaxChars * 2,
-      maxTurns: Math.max(10, this.config.hourlySummariesMaxTurnsPerRun),
-    });
-  }
+  // Issue #1526: countConversationChunkDocs / buildConversationIndexChunks moved
+  // to ConversationIndexCoordinator (internal helpers, no orchestrator callers).
 
   async getConversationIndexHealth(): Promise<{
     enabled: boolean;
@@ -5088,37 +5028,7 @@ export class Orchestrator {
       };
     };
   }> {
-    const chunkDocCount = await this.countConversationChunkDocs(
-      this.conversationIndexDir,
-    );
-    const lastUpdateAtMs = Math.max(
-      0,
-      ...this.conversationIndexLastUpdateAtMs.values(),
-    );
-    const lastUpdateAt =
-      lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
-
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return {
-        enabled: false,
-        backend: this.config.conversationIndexBackend,
-        status: "disabled",
-        chunkDocCount,
-        lastUpdateAt,
-      };
-    }
-    const backendHealth = this.conversationIndexBackend
-      ? await this.conversationIndexBackend.health()
-      : {
-          backend: this.config.conversationIndexBackend,
-          status: "degraded" as const,
-        };
-    return {
-      enabled: true,
-      chunkDocCount,
-      lastUpdateAt,
-      ...backendHealth,
-    };
+    return this.conversationIndexCoordinator.getHealth();
   }
 
   async inspectConversationIndex(): Promise<
@@ -5128,53 +5038,7 @@ export class Orchestrator {
       lastUpdateAt: string | null;
     }
   > {
-    const chunkDocCount = await this.countConversationChunkDocs(
-      this.conversationIndexDir,
-    );
-    const lastUpdateAtMs = Math.max(
-      0,
-      ...this.conversationIndexLastUpdateAtMs.values(),
-    );
-    const lastUpdateAt =
-      lastUpdateAtMs > 0 ? new Date(lastUpdateAtMs).toISOString() : null;
-
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return {
-        enabled: false,
-        backend: this.config.conversationIndexBackend,
-        status: "disabled",
-        available: false,
-        indexPath: this.conversationIndexDir,
-        supportsIncrementalUpdate: true,
-        message: "Conversation index disabled by config",
-        metadata: {
-          chunkCount: chunkDocCount,
-        },
-        chunkDocCount,
-        lastUpdateAt,
-      };
-    }
-
-    const inspection = this.conversationIndexBackend
-      ? await this.conversationIndexBackend.inspect()
-      : {
-          backend: this.config.conversationIndexBackend,
-          status: "degraded" as const,
-          available: false,
-          indexPath: this.conversationIndexDir,
-          supportsIncrementalUpdate: true,
-          message: "Conversation index backend unavailable",
-          metadata: {
-            chunkCount: chunkDocCount,
-          },
-        };
-
-    return {
-      enabled: true,
-      chunkDocCount,
-      lastUpdateAt,
-      ...inspection,
-    };
+    return this.conversationIndexCoordinator.inspect();
   }
 
   async getRecoverySummary(sessionKey?: string): Promise<{
@@ -5200,54 +5064,7 @@ export class Orchestrator {
     retryAfterMs?: number;
     embedded?: boolean;
   }> {
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return { chunks: 0, skipped: true, reason: "disabled", embedded: false };
-    }
-    const enforceMinInterval = opts?.enforceMinInterval !== false;
-    if (enforceMinInterval) {
-      const minIntervalMs = Math.max(
-        0,
-        this.config.conversationIndexMinUpdateIntervalMs,
-      );
-      const now = Date.now();
-      const last = this.conversationIndexLastUpdateAtMs.get(sessionKey) ?? 0;
-      const elapsed = now - last;
-      if (minIntervalMs > 0 && elapsed < minIntervalMs) {
-        return {
-          chunks: 0,
-          skipped: true,
-          reason: "min_interval",
-          retryAfterMs: minIntervalMs - elapsed,
-          embedded: false,
-        };
-      }
-    }
-    const chunks = await this.buildConversationIndexChunks(sessionKey, hours);
-    await writeConversationChunks(this.conversationIndexDir, chunks);
-    const retentionCutoffMs =
-      Number.isFinite(this.config.conversationIndexRetentionDays) &&
-      this.config.conversationIndexRetentionDays > 0
-        ? Date.now() -
-          this.config.conversationIndexRetentionDays * 24 * 60 * 60 * 1000
-        : undefined;
-    await cleanupConversationChunks(
-      this.conversationIndexDir,
-      this.config.conversationIndexRetentionDays,
-    );
-    const shouldEmbed =
-      opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
-    let embedded = false;
-
-    if (this.conversationIndexBackend) {
-      const result = await this.conversationIndexBackend.update(chunks, {
-        embed: shouldEmbed,
-        ...(retentionCutoffMs !== undefined ? { retentionCutoffMs } : {}),
-      });
-      embedded = result.embedded;
-    }
-
-    this.conversationIndexLastUpdateAtMs.set(sessionKey, Date.now());
-    return { chunks: chunks.length, skipped: false, embedded };
+    return this.conversationIndexCoordinator.update(sessionKey, hours, opts);
   }
 
   async rebuildConversationIndex(
@@ -5261,42 +5078,7 @@ export class Orchestrator {
     embedded?: boolean;
     rebuilt?: boolean;
   }> {
-    if (!resolveIndexingCapabilities(this.config).conversationIndex) {
-      return {
-        chunks: 0,
-        skipped: true,
-        reason: "disabled",
-        embedded: false,
-        rebuilt: false,
-      };
-    }
-
-    const chunks = await this.buildConversationIndexChunks(sessionKey, hours);
-    await writeConversationChunks(this.conversationIndexDir, chunks);
-    await cleanupConversationChunks(
-      this.conversationIndexDir,
-      this.config.conversationIndexRetentionDays,
-    );
-
-    const shouldEmbed =
-      opts?.embed ?? this.config.conversationIndexEmbedOnUpdate;
-    let embedded = false;
-    let rebuilt = false;
-    if (this.conversationIndexBackend) {
-      const result = await this.conversationIndexBackend.rebuild(chunks, {
-        embed: shouldEmbed,
-      });
-      embedded = result.embedded;
-      rebuilt = result.rebuilt;
-    }
-
-    const stamp = Date.now();
-    if (sessionKey) {
-      this.conversationIndexLastUpdateAtMs.set(sessionKey, stamp);
-    } else {
-      this.conversationIndexLastUpdateAtMs.set("__rebuild__", stamp);
-    }
-    return { chunks: chunks.length, skipped: false, embedded, rebuilt };
+    return this.conversationIndexCoordinator.rebuild(sessionKey, hours, opts);
   }
 
   /**
@@ -5430,7 +5212,7 @@ export class Orchestrator {
     // memory directory, reject recall with a clear human-readable error
     // rather than surfacing a cryptic SecureStoreLockedError from deep
     // inside the storage layer.
-    if (this.config.secureStoreEnabled && !this.storage.isSecureStoreUnlocked()) {
+    if (resolveRecallAuxiliaryCapabilities(this.config).secureStore && !this.storage.isSecureStoreUnlocked()) {
       const lockedMsg =
         "[secure-store locked] Memory store is encrypted and locked. " +
         "Unlock the secure-store inside this daemon process, or restart the daemon through a secure-store aware launcher that installs the key.";
@@ -5568,7 +5350,7 @@ export class Orchestrator {
     });
     const observationNamespaces = observationScopePlan.readNamespaces;
     const observationQueryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
-      cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
+      cronRecallPolicyEnabled: resolveRecallAuxiliaryCapabilities(this.config).cronRecallPolicy,
       cronRecallNormalizedQueryMaxChars:
         this.config.cronRecallNormalizedQueryMaxChars,
       cronRecallInstructionHeavyTokenCap:
@@ -6994,7 +6776,7 @@ export class Orchestrator {
     // recall searches, incl. coding `readFallbacks`). See the
     // `lcmReadSessionIds` derivation after `recallNamespaces` is built.
     const queryPolicy = buildRecallQueryPolicy(prompt, sessionKey, {
-      cronRecallPolicyEnabled: this.config.cronRecallPolicyEnabled,
+      cronRecallPolicyEnabled: resolveRecallAuxiliaryCapabilities(this.config).cronRecallPolicy,
       cronRecallNormalizedQueryMaxChars:
         this.config.cronRecallNormalizedQueryMaxChars,
       cronRecallInstructionHeavyTokenCap:
@@ -7157,7 +6939,7 @@ export class Orchestrator {
           return limit;
         })()
       : 0;
-    const recallHeadroom = this.config.verbatimArtifactsEnabled
+    const recallHeadroom = resolvePresentationCapabilities(this.config).verbatimArtifacts
       ? Math.max(12, this.config.verbatimArtifactsMaxRecall * 4)
       : 12;
     const computedFetchLimit =
@@ -7170,7 +6952,7 @@ export class Orchestrator {
     const qmdFetchLimit = computedFetchLimit;
     const qmdHybridFetchLimit = computeQmdHybridFetchLimit(
       qmdFetchLimit,
-      this.config.verbatimArtifactsEnabled,
+      resolvePresentationCapabilities(this.config).verbatimArtifacts,
       this.config.verbatimArtifactsMaxRecall,
     );
     const embeddingFetchLimit = computedFetchLimit;
@@ -7862,11 +7644,11 @@ export class Orchestrator {
       if (
         !this.isRecallSectionEnabled(
           "entity-retrieval",
-          this.config.entityRetrievalEnabled,
+          resolveRecallAuxiliaryCapabilities(this.config).entityRetrieval,
         )
       )
         return null;
-      if (!this.config.entityRetrievalEnabled) return null;
+      if (!resolveRecallAuxiliaryCapabilities(this.config).entityRetrieval) return null;
       const maxChars =
         this.getRecallSectionMaxChars("entity-retrieval") ??
         this.config.entityRetrievalMaxChars;
@@ -7939,11 +7721,11 @@ export class Orchestrator {
       if (
         !this.isRecallSectionEnabled(
           "knowledge-index",
-          this.config.knowledgeIndexEnabled,
+          resolveRecallAuxiliaryCapabilities(this.config).knowledgeIndex,
         )
       )
         return null;
-      if (!this.config.knowledgeIndexEnabled) return null;
+      if (!resolveRecallAuxiliaryCapabilities(this.config).knowledgeIndex) return null;
       const t0 = Date.now();
       try {
         const knowledgeIndexMaxChars =
@@ -8034,11 +7816,11 @@ export class Orchestrator {
       if (
         !this.isRecallSectionEnabled(
           "verbatim-artifacts",
-          this.config.verbatimArtifactsEnabled === true,
+          resolvePresentationCapabilities(this.config).verbatimArtifacts === true,
         )
       )
         return [];
-      if (!this.config.verbatimArtifactsEnabled) return [];
+      if (!resolvePresentationCapabilities(this.config).verbatimArtifacts) return [];
       const t0 = Date.now();
       const targetCount = computeArtifactRecallLimit(
         recallMode,
@@ -8269,10 +8051,10 @@ export class Orchestrator {
     const calibrationPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.calibrationEnabled ||
+        !resolveConsolidationCapabilities(this.config).calibration ||
         !this.isRecallSectionEnabled(
           "calibration-rules",
-          this.config.calibrationEnabled === true,
+          resolveConsolidationCapabilities(this.config).calibration === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -8434,7 +8216,7 @@ export class Orchestrator {
               query: retrievalQuery,
               maxResults,
               sessionKey,
-              anchorsEnabled: this.config.abstractionAnchorsEnabled,
+              anchorsEnabled: resolveConsolidationCapabilities(this.config).abstractionAnchors,
               abortSignal: harmonicRetrievalAbort.signal,
             }),
           ),
@@ -8481,10 +8263,10 @@ export class Orchestrator {
     const verifiedRecallPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.verifiedRecallEnabled ||
+        !resolveRecallAuxiliaryCapabilities(this.config).verifiedRecall ||
         !this.isRecallSectionEnabled(
           "verified-episodes",
-          this.config.verifiedRecallEnabled === true,
+          resolveRecallAuxiliaryCapabilities(this.config).verifiedRecall === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -8570,10 +8352,10 @@ export class Orchestrator {
     const verifiedRulesPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.semanticRuleVerificationEnabled ||
+        !resolveRecallAuxiliaryCapabilities(this.config).semanticRuleVerification ||
         !this.isRecallSectionEnabled(
           "verified-rules",
-          this.config.semanticRuleVerificationEnabled === true,
+          resolveRecallAuxiliaryCapabilities(this.config).semanticRuleVerification === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -8659,10 +8441,10 @@ export class Orchestrator {
       const t0 = Date.now();
       if (
         !resolveCreationMemoryCapabilities(this.config).creationMemory ||
-        !this.config.workProductRecallEnabled ||
+        !resolveRecallAuxiliaryCapabilities(this.config).workProductRecall ||
         !this.isRecallSectionEnabled(
           "work-products",
-          this.config.workProductRecallEnabled === true,
+          resolveRecallAuxiliaryCapabilities(this.config).workProductRecall === true,
         )
       ) {
         recordRecallSectionMetric({
@@ -9170,7 +8952,7 @@ export class Orchestrator {
     const transcriptPromise = (async (): Promise<string | null> => {
       const t0 = Date.now();
       if (
-        !this.config.transcriptEnabled ||
+        !resolvePresentationCapabilities(this.config).transcript ||
         !this.isRecallSectionEnabled("transcript", true)
       ) {
         recordRecallSectionMetric({
@@ -9276,7 +9058,7 @@ export class Orchestrator {
         this._recallWorkspaceOverrides.get(effectiveSessionKey);
       this._recallWorkspaceOverrides.delete(effectiveSessionKey);
 
-      if (!this.config.compactionResetEnabled) return null;
+      if (!resolveRecallAuxiliaryCapabilities(this.config).compactionReset) return null;
 
       const workspaceDir =
         compactionWorkspaceDir ||
@@ -9629,9 +9411,9 @@ export class Orchestrator {
     const recentBoxesPromise = observeEnrichmentPromise(
       this.isRecallSectionEnabled(
         "memory-boxes",
-        this.config.memoryBoxesEnabled === true,
+        resolvePresentationCapabilities(this.config).memoryBoxes === true,
       ) &&
-        this.config.memoryBoxesEnabled &&
+        resolvePresentationCapabilities(this.config).memoryBoxes &&
         this.config.boxRecallDays > 0
         ? Promise.all(
             profileStorages.map((storage) =>
@@ -12734,7 +12516,7 @@ export class Orchestrator {
   ): Promise<void> {
     const mode = this.config.correctionCaptureMode;
     if (mode === "off") return;
-    if (!this.config.correctionEnabled) return;
+    if (!resolveRecallAuxiliaryCapabilities(this.config).correction) return;
 
     try {
       const corrections = detectPassiveCorrections(
@@ -12754,7 +12536,7 @@ export class Orchestrator {
       const result = await capturePassiveCorrections(
         corrections,
         {
-          correctionEnabled: this.config.correctionEnabled,
+          correctionEnabled: resolveRecallAuxiliaryCapabilities(this.config).correction,
           isLiveSession: opts.isLiveSession,
           bufferKey: opts.bufferKey,
           sessionKey: opts.sessionKey,
@@ -13188,7 +12970,7 @@ export class Orchestrator {
     }
 
     let threadIdForExtraction: string | null = null;
-    if (this.config.threadingEnabled && turns.length > 0) {
+    if (resolvePresentationCapabilities(this.config).threading && turns.length > 0) {
       const lastTurn = turns[turns.length - 1];
       try {
         threadIdForExtraction = await this.threading.processTurn(lastTurn, []);
@@ -13318,7 +13100,7 @@ export class Orchestrator {
     // Topics are derived from the current extraction's facts and entities only —
     // not from readAllMemories() — so box topics accurately reflect the current
     // session window and the call is free of expensive full-corpus I/O.
-    if (this.config.memoryBoxesEnabled && persistedIds.length > 0) {
+    if (resolvePresentationCapabilities(this.config).memoryBoxes && persistedIds.length > 0) {
       const extractionTopics = deriveTopicsFromExtraction(result);
       // Derive episodic metadata from buffer turns (REMem-inspired)
       const firstUserTurn = turns.find((t) => t.role === "user");
@@ -13339,7 +13121,7 @@ export class Orchestrator {
     // Batch-append persisted IDs so non-fact memories (entities/questions) are
     // always attached to the thread. The helper excludes pending_review ids (#1635).
     if (
-      this.config.threadingEnabled &&
+      resolvePresentationCapabilities(this.config).threading &&
       threadIdForExtraction &&
       persistedIds.length > 0
     ) {
@@ -13350,7 +13132,7 @@ export class Orchestrator {
     }
 
     // Thread title update for the already-established thread context.
-    if (this.config.threadingEnabled && threadIdForExtraction) {
+    if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction) {
       const conversationContent = turns.map((t) => t.content).join(" ");
       try {
         await this.threading.updateThreadTitle(
@@ -15251,7 +15033,7 @@ export class Orchestrator {
 
         if (chunkResult.chunked && chunkResult.chunks.length > 1) {
           // Classify memory kind (v8.0 Phase 2B: HiMem episode/note dual store)
-          const memoryKind = this.config.episodeNoteModeEnabled
+          const memoryKind = resolvePresentationCapabilities(this.config).episodeNoteMode
             ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory)
             : undefined;
 
@@ -15508,7 +15290,7 @@ export class Orchestrator {
           }
           try {
             if (
-              this.config.verbatimArtifactsEnabled &&
+              resolvePresentationCapabilities(this.config).verbatimArtifacts &&
               this.config.verbatimArtifactCategories.includes(writeCategory) &&
               fact.confidence >= this.config.verbatimArtifactsMinConfidence &&
               !postWriteGuard
@@ -15605,7 +15387,7 @@ export class Orchestrator {
       const memoryKind =
         writeCategory === "procedure"
           ? undefined
-          : this.config.episodeNoteModeEnabled
+          : resolvePresentationCapabilities(this.config).episodeNoteMode
             ? classifyMemoryKind(fact.content, fact.tags ?? [], writeCategory)
             : undefined;
 
@@ -15805,7 +15587,7 @@ export class Orchestrator {
           }
         }
         if (
-          this.config.verbatimArtifactsEnabled &&
+          resolvePresentationCapabilities(this.config).verbatimArtifacts &&
           this.config.verbatimArtifactCategories.includes(writeCategory) &&
           fact.confidence >= this.config.verbatimArtifactsMinConfidence &&
           !postWriteGuard
@@ -16421,7 +16203,7 @@ export class Orchestrator {
       log.info(`merged ${entitiesMerged} fragmented entity files`);
     }
 
-    if (this.config.entitySummaryEnabled) {
+    if (resolvePresentationCapabilities(this.config).entitySummary) {
       try {
         const synthesized = await this.processEntitySynthesisQueue(
           this.config.defaultNamespace,
@@ -16565,7 +16347,7 @@ export class Orchestrator {
     }
 
     // Semantic consolidation pass — find similar memories, synthesize canonical versions
-    if (this.config.semanticConsolidationEnabled) {
+    if (resolveConsolidationCapabilities(this.config).semanticConsolidation) {
       try {
         const stateFilePath = path.join(
           this.config.memoryDir,
@@ -17366,156 +17148,15 @@ export class Orchestrator {
     return matches[0] ?? null;
   }
 
+  // Issue #1526: recall-rerank methods moved to RecallRerankCoordinator.
+  // Thin delegation keeps the private API stable for callers + tests.
   private async applyMemoryWorthRerank(
     results: QmdSearchResult[],
     namespaces: string[],
   ): Promise<QmdSearchResult[]> {
-    // Build the counter lookup. We union frontmatter counters across every
-    // namespace the recall spans — the recall path itself already
-    // aggregates candidates from multiple namespaces, so we must do the
-    // same when looking up counters. Per-namespace results are cached with
-    // a short TTL so interactive recall doesn't trigger a full
-    // `readAllMemories` scan per query (addresses codex P2 on PR 4).
-    const counters = new Map<string, MemoryWorthCounters>();
-    const seenNamespaces = new Set<string>();
-    const nowMs = Date.now();
-
-    // Evict all expired entries on every call so long-running processes
-    // touching a high-cardinality namespace set (coding/project overlays,
-    // per-branch) don't grow the cache unboundedly. Without this, an entry
-    // for a namespace that's never looked up again would pin its full
-    // counter map forever.
-    for (const [key, entry] of this.memoryWorthCounterCache) {
-      if (nowMs - entry.at >= Orchestrator.MEMORY_WORTH_CACHE_TTL_MS) {
-        this.memoryWorthCounterCache.delete(key);
-      }
-    }
-
-    for (const ns of namespaces) {
-      if (seenNamespaces.has(ns)) continue;
-      seenNamespaces.add(ns);
-      try {
-        const cached = this.memoryWorthCounterCache.get(ns);
-        let nsMap: ReadonlyMap<string, MemoryWorthCounters> | undefined;
-        if (
-          cached &&
-          nowMs - cached.at < Orchestrator.MEMORY_WORTH_CACHE_TTL_MS
-        ) {
-          nsMap = cached.counters;
-        } else {
-          const storage = await this.getStorage(ns);
-          const memories = await storage.readAllMemories();
-          nsMap = buildMemoryWorthCounterMap(memories);
-          this.memoryWorthCounterCache.set(ns, { at: nowMs, counters: nsMap });
-        }
-        for (const [path, c] of nsMap) counters.set(path, c);
-      } catch (err) {
-        log.debug("memory-worth: failed to read namespace, skipping", {
-          namespace: ns,
-          error: (err as Error).message,
-        });
-      }
-    }
-
-    // For candidates whose path didn't show up in any hot-tier namespace
-    // scan (typical of cold-tier / archive fallback), try a direct
-    // per-path read. Without this, cold-tier candidates always stay at
-    // multiplier 1.0 even when they have outcome history. Errors are
-    // swallowed so a single unreadable archive entry can't break the
-    // whole recall.
-    const missing = results.filter((r) => !counters.has(r.path));
-    if (missing.length > 0) {
-      // Use the first-seen namespace's storage as the reader — all
-      // StorageManagers share the same on-disk format, and
-      // `readMemoryByPath` takes an absolute path so the baseDir doesn't
-      // have to match.
-      let reader: StorageManager | null = null;
-      for (const ns of namespaces) {
-        try {
-          reader = await this.getStorage(ns);
-          break;
-        } catch {
-          // try next namespace
-        }
-      }
-      if (reader) {
-        for (const r of missing) {
-          try {
-            const memory = await this.readQmdResultMemory(r.path, reader, namespaces);
-            if (!memory) continue;
-            const fm = memory.frontmatter;
-            if (fm.mw_success === undefined && fm.mw_fail === undefined) continue;
-            counters.set(r.path, {
-              mw_success: fm.mw_success,
-              mw_fail: fm.mw_fail,
-              lastAccessed: fm.lastAccessed,
-            });
-          } catch (err) {
-            log.debug("memory-worth: direct path lookup failed", {
-              path: r.path,
-              error: (err as Error).message,
-            });
-          }
-        }
-      }
-    }
-
-    // If no memory in the candidate set has any counter data, the filter
-    // would be a no-op — skip the reorder to avoid spurious log spam.
-    if (counters.size === 0) return results;
-
-    // Preserve upstream ordering (reranker, specialized tiers, etc.) for
-    // neutral candidates. The upstream stages set `memoryResults` in their
-    // intended order but often leave `r.score` as the raw QMD score. If we
-    // sorted by `r.score * multiplier` directly, neutral candidates
-    // (multiplier 1.0) would snap back to raw-QMD order and silently undo
-    // the reranker. Feed the filter a synthetic monotone-decreasing rank
-    // score so it uses input position as the baseline, then applies the
-    // multiplier on top. Ties fall back to the stable secondary key in
-    // `applyMemoryWorthFilter`.
-    const rankedInputs = results.map((r, i) => ({
-      path: r.path,
-      // Large positive rank score so multiplier math stays well-scaled and
-      // we never hit zero; descending so earlier items rank higher.
-      score: results.length - i,
-    }));
-    const filtered = applyMemoryWorthFilter(rankedInputs, {
-      counters,
-      now: new Date(),
-      halfLifeMs:
-        this.config.recallMemoryWorthHalfLifeMs > 0
-          ? this.config.recallMemoryWorthHalfLifeMs
-          : undefined,
-    });
-
-    // Reconstruct the QmdSearchResult list in the new order. `.score` is
-    // preserved from the upstream pipeline (rerank, tier scoring, etc.) —
-    // we only reorder. Writing the synthetic rank-weighted score back
-    // would contaminate downstream logic (telemetry, confidence gates)
-    // that expects the original QMD/rerank score semantics.
-    const byPath = new Map(results.map((r) => [r.path, r]));
-    const reordered: QmdSearchResult[] = [];
-    for (const item of filtered) {
-      const original = byPath.get(item.path);
-      if (original) reordered.push(original);
-    }
-    return reordered;
+    return this.recallRerankCoordinator.applyMemoryWorthRerank(results, namespaces);
   }
 
-  /**
-   * Issue #1577 — unified TrustScore recall stage. Thin wiring over the pure
-   * {@link applyTrustScoreStage} scorer + the {@link buildTrustSignalsForRerank}
-   * signal builder. The stage subsumes the Memory Worth multiplier — the
-   * orchestrator runs exactly one of the two (mutual exclusion, rule 39; the
-   * double-multiplier test in trust-score-stage.test.ts pins it structurally).
-   *
-   * Returns the admitted results AND the per-path trust map (including
-   * quarantined items) so the caller can: (a) render epistemic hedges, (b)
-   * surface quarantined items in X-ray with a reason (rule 34), and (c) filter
-   * quarantined paths from fallback recall branches. The trust map is a
-   * per-recall local — never instance state — so concurrent recalls cannot
-   * race on it (review: shared-trust-map concurrency).
-   */
   private async applyTrustScoreRerank(
     results: QmdSearchResult[],
     namespaces: string[],
@@ -17523,74 +17164,9 @@ export class Orchestrator {
     results: QmdSearchResult[];
     trustByPath: Map<string, TrustStageResultItem> | null;
   }> {
-    if (results.length === 0) return { results, trustByPath: null };
-    const now = new Date();
-    const halfLifeDays =
-      this.config.recallMemoryWorthHalfLifeMs > 0
-        ? this.config.recallMemoryWorthHalfLifeMs / (24 * 60 * 60 * 1000)
-        : undefined;
-    // Cold-tier direct-fallback reader: resolve once, reuse for every missing
-    // candidate (mirrors the memory-worth filter's reader selection).
-    let fallbackReader: StorageManager | null = null;
-    const signals = await buildTrustSignalsForRerank(
-      results.map((r) => r.path),
-      namespaces,
-      {
-        readNamespaceMemories: async (ns) => (await this.getStorage(ns)).readAllMemories(),
-        readMemoryFrontmatter: async (path) => {
-          if (!fallbackReader) {
-            for (const ns of namespaces) {
-              try {
-                fallbackReader = await this.getStorage(ns);
-                break;
-              } catch {
-                // try next namespace
-              }
-            }
-          }
-          if (!fallbackReader) return null;
-          const memory = await this.readQmdResultMemory(path, fallbackReader, namespaces);
-          return memory ? memory.frontmatter : null;
-        },
-      },
-      { cache: this.trustSignalCache, ttlMs: Orchestrator.TRUST_SIGNAL_CACHE_TTL_MS },
-      now,
-      {
-        recencyHalfLifeDays: halfLifeDays,
-        logDebug: (message, context) => log.debug(message, context),
-      },
-    );
-    if (signals.size === 0) {
-      return { results, trustByPath: null };
-    }
-    // Synthetic monotone-decreasing rank so the multiplier rebias is applied
-    // on top of upstream ordering, not raw QMD scores (see applyMemoryWorthRerank).
-    const rankedInputs = results.map((r, i) => ({ path: r.path, score: results.length - i }));
-    const stage = applyTrustScoreStage(rankedInputs, {
-      signals,
-      weights: this.config.trustScoreWeights,
-      minMultiplier: this.config.trustScoreMinMultiplier,
-      maxMultiplier: this.config.trustScoreMaxMultiplier,
-      quarantine: this.config.trustScoreQuarantine,
-    });
-    const trustByPath = new Map(stage.all.map((item) => [item.path, item]));
-    const byPath = new Map(results.map((r) => [r.path, r]));
-    const admitted = stage.admitted
-      .map((item) => byPath.get(item.path))
-      .filter((r): r is QmdSearchResult => r !== undefined);
-    return { results: admitted, trustByPath };
+    return this.recallRerankCoordinator.applyTrustScoreRerank(results, namespaces);
   }
 
-  /**
-   * Issue #1577 — apply the TrustScore stage (or, when trust is off, the Memory
-   * Worth multiplier fallback) to ONE recall branch's results, returning the
-   * scored results + the per-path trust map. Thin wiring over
-   * {@link applyTrustScoreRerank} so every recall path — hot QMD, embedding
-   * fallback, recent scan — applies the SAME multiplier gate (rule 41: a
-   * feature gate must apply across ALL parallel recall paths). TrustScore
-   * subsumes Memory Worth; exactly one runs (rule 39). Fail-open on lookup
-   * errors so a storage hiccup never breaks a fallback path.
-   */
   private async applyTrustScoreToBranch(
     results: QmdSearchResult[],
     namespaces: string[],
@@ -17600,25 +17176,7 @@ export class Orchestrator {
     results: QmdSearchResult[];
     trustByPath: Map<string, TrustStageResultItem> | null;
   }> {
-    if (caps.recallTrustScore && results.length > 0) {
-      try {
-        return await this.applyTrustScoreRerank(results, namespaces);
-      } catch (err) {
-        log.debug(`trust-score stage (${label}) failed open`, {
-          error: (err as Error).message,
-        });
-      }
-    } else if (caps.recallMemoryWorthFilter && results.length > 0) {
-      try {
-        const filtered = await this.applyMemoryWorthRerank(results, namespaces);
-        return { results: filtered, trustByPath: null };
-      } catch (err) {
-        log.debug(`memory-worth filter (${label}) failed open`, {
-          error: (err as Error).message,
-        });
-      }
-    }
-    return { results, trustByPath: null };
+    return this.recallRerankCoordinator.applyTrustScoreToBranch(results, namespaces, caps, label);
   }
 
   private diversifyAndLimitRecallResults(
@@ -17626,89 +17184,17 @@ export class Orchestrator {
     results: QmdSearchResult[],
     limit: number,
     retrievalQuery?: string,
-    // `caps` is additive AND last (issue #1523) so the positional call shape
-    // stays backward-compatible: the recall pipeline threads a resolved set,
-    // but callers that omit it (e.g. direct unit-test invocations) get an
-    // equivalent set derived from the same config — behavior-preserving.
     caps: CapabilitySet = resolveCapabilities(this.config),
   ): QmdSearchResult[] {
-    const safeLimit =
-      typeof limit === "number" && Number.isFinite(limit)
-        ? Math.max(0, Math.floor(limit))
-        : 0;
-    if (!Array.isArray(results) || results.length === 0) return [];
-    // `recallResultLimit === 0` is a true zero limit (e.g. when
-    // `memoriesSectionEnabled` is false) and must return an empty array so
-    // the memories section is genuinely skipped. This mirrors the
-    // `slice(0, 0)` semantics of every call site this helper replaced.
-    if (safeLimit === 0) return [];
-    // Issue #564 PR 3: when the feature flag is on, boost reasoning_trace
-    // memories for problem-solving asks so they bubble up ahead of ordinary
-    // facts/decisions before MMR picks the final section. No-op when the
-    // flag is off or the query is not a problem-solving ask.
-    const boosted =
-      caps.recallReasoningTraceBoost && typeof retrievalQuery === "string"
-        ? applyReasoningTraceBoost(results, {
-            enabled: true,
-            query: retrievalQuery,
-          })
-        : results;
-    const diversified = this.applyMmrToQmdResults(sectionId, boosted, caps);
-    return diversified.slice(0, safeLimit);
+    return this.recallRerankCoordinator.diversifyAndLimitRecallResults(sectionId, results, limit, retrievalQuery, caps);
   }
 
-  /**
-   * Apply Maximal Marginal Relevance to a section's ordered candidate list.
-   *
-   * Operates per-section so one redundant cluster cannot dominate a section,
-   * and so one section's MMR pass cannot starve other sections. Returns the
-   * input unchanged when disabled, when there are fewer than 2 candidates, or
-   * when no budget information is available.
-   */
   private applyMmrToQmdResults(
     sectionId: string,
     results: QmdSearchResult[],
-    // Additive `caps` (issue #1523); defaults to a config-derived set so direct
-    // callers that omit it behave identically to the threaded recall path.
     caps: CapabilitySet = resolveCapabilities(this.config),
   ): QmdSearchResult[] {
-    if (!caps.recallMmr) return results;
-    if (!Array.isArray(results) || results.length < 2) return results;
-
-    // Config is runtime API (see AGENTS.md §4): preserve `0` as a true zero
-    // limit rather than coercing it to a non-zero value. A configured topN of
-    // 0 means "apply MMR over an empty window" — i.e. skip the reorder and
-    // return the upstream candidates unchanged. This keeps read-time
-    // behavior symmetric with the write-time semantics parseConfig exposes.
-    const configuredTopN = this.config.recallMmrTopN;
-    const topN =
-      typeof configuredTopN === "number" && Number.isFinite(configuredTopN)
-        ? Math.max(0, Math.floor(configuredTopN))
-        : 40;
-    if (topN === 0) return results;
-    const lambda = this.config.recallMmrLambda ?? 0.7;
-
-    // Delegate to the pure helper so candidate keying (path-first, index
-    // suffixed for uniqueness) and the head-of-list diversity metric are
-    // exercised by the same code path that the unit tests cover.
-    const { reordered, diversity } = reorderRecallResultsWithMmr(results, {
-      lambda,
-      topN,
-    });
-
-    try {
-      log.info(
-        `recall_mmr: section=${sectionId} kept=${diversity.kept}/${diversity.considered} ` +
-          `headReorderCount=${diversity.headReorderCount} ` +
-          `avgSimBefore=${diversity.avgPairwiseSimBefore.toFixed(3)} ` +
-          `avgSimAfter=${diversity.avgPairwiseSimAfter.toFixed(3)} ` +
-          `lambda=${lambda.toFixed(2)}`,
-      );
-    } catch {
-      // Metrics must never break recall.
-    }
-
-    return reordered;
+    return this.recallRerankCoordinator.applyMmrToQmdResults(sectionId, results, caps);
   }
 
   private buildLastRecallBudgetSummary(options: {