@remnic/core 9.3.738 → 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,
@@ -330,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,
@@ -1817,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
@@ -1909,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<
@@ -1917,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
@@ -2898,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);
@@ -5006,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;
@@ -5087,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<
@@ -5127,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<{
@@ -5199,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(
@@ -5260,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);
   }
 
   /**
@@ -17365,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[],
@@ -17522,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[],
@@ -17599,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(
@@ -17625,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: {