feat: add optional reranker stage to CognitiveMemoryManager.retrieve()

Author: jddunn

src/memory/CognitiveMemoryManager.ts

@@ -207,6 +207,9 @@ export class CognitiveMemoryManager implements ICognitiveMemoryManager {
   // Cognitive Mechanisms (optional)
   private mechanismsEngine: import('./mechanisms/CognitiveMechanismsEngine.js').CognitiveMechanismsEngine | null = null;
 
+  // Optional neural reranker for post-retrieval quality improvement
+  private rerankerService: import('../rag/reranking/RerankerService.js').RerankerService | null = null;
+
   /**
    * Optional HyDE retriever for hypothesis-driven memory recall.
    *
@@ -244,6 +247,11 @@ export class CognitiveMemoryManager implements ICognitiveMemoryManager {
       this.store.setBrain(config.brain);
     }
 
+    // Optional neural reranker for post-retrieval quality improvement
+    if (config.rerankerService) {
+      this.rerankerService = config.rerankerService;
+    }
+
     // Cognitive working memory (wraps the existing IWorkingMemory)
     this.workingMemory = new CognitiveWorkingMemory(config.workingMemory, {
       baseCapacity: config.workingMemoryCapacity ?? 7,
@@ -548,6 +556,39 @@ export class CognitiveMemoryManager implements ICognitiveMemoryManager {
       }
     }
 
+    // --- Optional neural reranking ---
+    // Blends Cohere/LLM-Judge cross-encoder scores with the existing
+    // cognitive composite. Weight: 0.7 cognitive + 0.3 neural reranker.
+    // This preserves decay, mood congruence, and graph activation signals
+    // while boosting semantically relevant results the bi-encoder missed.
+    if (this.rerankerService && scored.length > 0) {
+      try {
+        const rerankerOutput = await this.rerankerService.rerank({
+          query,
+          documents: scored.map((t) => ({
+            id: t.id,
+            content: t.content,
+            originalScore: t.retrievalScore,
+          })),
+        }, { topN: options.topK ?? 10 });
+
+        const rerankedScores = new Map(
+          rerankerOutput.results.map((r) => [r.id, r.relevanceScore])
+        );
+
+        for (const trace of scored) {
+          const neuralScore = rerankedScores.get(trace.id);
+          if (neuralScore !== undefined) {
+            trace.retrievalScore = 0.7 * trace.retrievalScore + 0.3 * neuralScore;
+          }
+        }
+
+        scored.sort((a, b) => b.retrievalScore - a.retrievalScore);
+      } catch {
+        // Reranking is non-critical — use cognitive scores as-is
+      }
+    }
+
     // Record access for retrieved memories (spaced repetition)
     for (const trace of scored.slice(0, 5)) {
       await this.store.recordAccess(trace.id);

src/memory/core/config.ts

@@ -271,6 +271,22 @@ export interface CognitiveMemoryConfig {
    * @see {@link SqliteBrain} — the cross-platform persistence layer
    */
   brain?: import('../retrieval/store/SqliteBrain.js').SqliteBrain;
+
+  /**
+   * Optional reranker service for post-retrieval quality improvement.
+   *
+   * When provided, retrieved memory traces are reranked after the
+   * cognitive scoring pipeline (vector similarity + strength + recency +
+   * emotional congruence + graph activation + importance). The reranker
+   * score is blended with the existing composite score at a 0.7/0.3
+   * weighting to preserve cognitive signals while boosting semantically
+   * relevant results.
+   *
+   * Recommended: Cohere rerank-v3.5 primary, LLM-Judge fallback.
+   *
+   * @default undefined (no reranking)
+   */
+  rerankerService?: import('../../rag/reranking/RerankerService.js').RerankerService;
 }
 
 // ---------------------------------------------------------------------------