@rlabs-inc/memory 0.3.5 → 0.3.6

package/src/core/retrieval.ts

@@ -1,7 +1,7 @@
 // ============================================================================
-// RETRIEVAL ENGINE - 10-Dimensional Scoring Algorithm
-// EXACT PORT from Python retrieval_strategies.py
-// Preserving the working formula for consciousness continuity
+// RETRIEVAL ENGINE - Activation Signal Algorithm
+// Philosophy: Quality over quantity. Silence over noise.
+// Return ONLY memories that are truly relevant to the current context.
 // ============================================================================
 
 import type { StoredMemory, RetrievalResult } from '../types/memory.ts'
@@ -19,51 +19,339 @@ export interface SessionContext {
 }
 
 /**
- * Scoring components breakdown
+ * Activation signals - binary indicators of relevance
  */
-interface ScoringComponents {
-  trigger: number
-  vector: number
-  importance: number
-  temporal: number
-  context: number
-  tags: number
-  question: number
-  emotion: number
-  problem: number
-  action: number
+interface ActivationSignals {
+  trigger: boolean      // Trigger phrase matched
+  tags: boolean         // 2+ semantic tags found in message
+  domain: boolean       // Domain word found in message
+  feature: boolean      // Feature word found in message
+  content: boolean      // Key content words found in message
+  count: number         // Total signals activated
+  triggerStrength: number  // How strong the trigger match was (0-1)
+  tagCount: number      // How many tags matched
+  vectorSimilarity: number // Semantic similarity (0-1)
 }
 
 /**
- * Internal scored memory during retrieval
+ * Scored memory with activation signals
  */
-interface ScoredMemory {
+interface ActivatedMemory {
   memory: StoredMemory
-  score: number
-  relevance_score: number
-  value_score: number
-  reasoning: string
-  components: ScoringComponents
+  signals: ActivationSignals
+  importanceScore: number  // For ranking among relevant memories
+  isGlobal: boolean
 }
 
 /**
- * Extended result with components for logging
+ * Global memory type priority (lower = higher priority)
  */
-interface ExtendedRetrievalResult extends RetrievalResult {
-  reasoning: string
-  components: ScoringComponents
+const GLOBAL_TYPE_PRIORITY: Record<string, number> = {
+  technical: 1,
+  preference: 2,
+  architectural: 3,
+  workflow: 4,
+  decision: 5,
+  breakthrough: 6,
+  philosophy: 7,
+  personal: 8,
 }
 
+// Minimum signals required for a memory to be considered relevant
+const MIN_ACTIVATION_SIGNALS = 2
+
 /**
- * Smart Vector Retrieval - The 10-Dimensional Algorithm
+ * Stopwords for word extraction
+ */
+const STOPWORDS = new Set([
+  'the', 'is', 'are', 'was', 'were', 'to', 'a', 'an', 'and', 'or',
+  'but', 'in', 'on', 'at', 'for', 'with', 'about', 'when', 'how',
+  'what', 'why', 'where', 'this', 'that', 'it', 'of', 'be', 'have',
+  'do', 'does', 'did', 'will', 'would', 'could', 'should', 'can',
+  'may', 'might', 'must', 'shall', 'has', 'had', 'been', 'being',
+  'i', 'you', 'we', 'they', 'he', 'she', 'my', 'your', 'our',
+  'its', 'his', 'her', 'their', 'if', 'then', 'else', 'so', 'as',
+  'from', 'by', 'into', 'through', 'during', 'before', 'after',
+  'also', 'now', 'back', 'get', 'go', 'come', 'let', 'like', 'just',
+  'know', 'think', 'see', 'look', 'make', 'take', 'want', 'need',
+])
+
+
+/**
+ * Activation Signal Retrieval
+ *
+ * Phase 1: Count activation signals (binary relevance indicators)
+ * Phase 2: Among relevant memories, rank by importance
  *
- * This is the innovation: combining vector similarity with rich
- * semantic metadata from the curator to make smart decisions WITHOUT
- * needing to call Claude for every message.
+ * Philosophy: A memory is relevant if multiple signals agree it should activate.
+ * Not coincidence - intentionally crafted metadata matching intentional queries.
  */
 export class SmartVectorRetrieval {
+
+  /**
+   * Extract significant words from text
+   */
+  private _extractSignificantWords(text: string): Set<string> {
+    const words = text.toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, ' ')
+      .split(/\s+/)
+      .filter(w => w.length > 2 && !STOPWORDS.has(w))
+    return new Set(words)
+  }
+
+  /**
+   * Pre-filter: Binary exclusions based on v2 lifecycle fields
+   */
+  private _preFilter(
+    memories: StoredMemory[],
+    currentProjectId: string,
+    messageLower: string
+  ): StoredMemory[] {
+    return memories.filter(memory => {
+      if (memory.status && memory.status !== 'active') return false
+      if (memory.exclude_from_retrieval === true) return false
+      if (memory.superseded_by) return false
+      const isGlobal = memory.scope === 'global' || memory.project_id === 'global'
+      if (!isGlobal && memory.project_id !== currentProjectId) return false
+      if (memory.anti_triggers?.length) {
+        for (const antiTrigger of memory.anti_triggers) {
+          if (messageLower.includes(antiTrigger.toLowerCase())) return false
+        }
+      }
+      return true
+    })
+  }
+
+  /**
+   * Check if trigger phrases activate for this message
+   */
+  private _checkTriggerActivation(
+    messageLower: string,
+    messageWords: Set<string>,
+    triggerPhrases: string[]
+  ): { activated: boolean; strength: number } {
+    if (!triggerPhrases.length) return { activated: false, strength: 0 }
+
+    let maxStrength = 0
+
+    for (const phrase of triggerPhrases) {
+      const phraseLower = phrase.trim().toLowerCase()
+      const phraseWords = phraseLower
+        .split(/\s+/)
+        .filter(w => !STOPWORDS.has(w) && w.length > 2)
+
+      if (!phraseWords.length) continue
+
+      let matches = 0
+      for (const word of phraseWords) {
+        if (messageWords.has(word) || messageLower.includes(word)) {
+          matches++
+        } else if (messageWords.has(word.replace(/s$/, '')) ||
+                   messageWords.has(word + 's') ||
+                   messageLower.includes(word.replace(/s$/, '')) ||
+                   messageLower.includes(word + 's')) {
+          matches += 0.8
+        }
+      }
+
+      const strength = phraseWords.length > 0 ? matches / phraseWords.length : 0
+      maxStrength = Math.max(maxStrength, strength)
+    }
+
+    return { activated: maxStrength >= 0.5, strength: maxStrength }
+  }
+
+  /**
+   * Check if semantic tags activate for this message
+   */
+  private _checkTagActivation(
+    messageLower: string,
+    messageWords: Set<string>,
+    tags: string[]
+  ): { activated: boolean; count: number } {
+    if (!tags.length) return { activated: false, count: 0 }
+
+    let matchCount = 0
+    for (const tag of tags) {
+      const tagLower = tag.trim().toLowerCase()
+      if (messageWords.has(tagLower) || messageLower.includes(tagLower)) {
+        matchCount++
+      }
+    }
+
+    const threshold = tags.length <= 2 ? 1 : 2
+    return { activated: matchCount >= threshold, count: matchCount }
+  }
+
+  /**
+   * Check if domain activates for this message
+   */
+  private _checkDomainActivation(
+    messageLower: string,
+    messageWords: Set<string>,
+    domain: string | undefined
+  ): boolean {
+    if (!domain) return false
+    const domainLower = domain.trim().toLowerCase()
+    return messageWords.has(domainLower) || messageLower.includes(domainLower)
+  }
+
+  /**
+   * Check if feature activates for this message
+   */
+  private _checkFeatureActivation(
+    messageLower: string,
+    messageWords: Set<string>,
+    feature: string | undefined
+  ): boolean {
+    if (!feature) return false
+    const featureLower = feature.trim().toLowerCase()
+    return messageWords.has(featureLower) || messageLower.includes(featureLower)
+  }
+
+  /**
+   * Check if content keywords activate for this message
+   */
+  private _checkContentActivation(
+    messageWords: Set<string>,
+    memory: StoredMemory
+  ): boolean {
+    const contentPreview = memory.content.slice(0, 200)
+    const contentWords = this._extractSignificantWords(contentPreview)
+
+    let overlap = 0
+    for (const word of messageWords) {
+      if (contentWords.has(word)) overlap++
+    }
+
+    return overlap >= 3
+  }
+
+  /**
+   * Calculate vector similarity
+   */
+  private _vectorDebugSamples: number[] = []
+
+  private _calculateVectorSimilarity(
+    vec1: Float32Array | number[] | undefined,
+    vec2: Float32Array | number[] | undefined
+  ): number {
+    if (!vec1 || !vec2) {
+      return 0.0
+    }
+    const v1 = vec1 instanceof Float32Array ? vec1 : new Float32Array(vec1)
+    const v2 = vec2 instanceof Float32Array ? vec2 : new Float32Array(vec2)
+    const similarity = cosineSimilarity(v1, v2)
+
+    // Collect samples to understand similarity range
+    if (this._vectorDebugSamples.length < 20) {
+      this._vectorDebugSamples.push(similarity)
+    }
+
+    return similarity
+  }
+
+  /**
+   * Log vector similarity stats after retrieval
+   */
+  private _logVectorStats(): void {
+    if (this._vectorDebugSamples.length === 0) return
+    const samples = this._vectorDebugSamples
+    const min = Math.min(...samples)
+    const max = Math.max(...samples)
+    const avg = samples.reduce((a, b) => a + b, 0) / samples.length
+    console.log(`[DEBUG] Vector similarities: min=${(min*100).toFixed(1)}% max=${(max*100).toFixed(1)}% avg=${(avg*100).toFixed(1)}% (${samples.length} samples)`)
+    this._vectorDebugSamples = []  // Reset for next retrieval
+  }
+
+  /**
+   * Calculate importance score using ALL rich metadata
+   * Additive discrete bonuses - no averaging, no compression
+   */
+  private _calculateImportanceScore(
+    memory: StoredMemory,
+    signalCount: number,
+    messageLower: string,
+    messageWords: Set<string>
+  ): number {
+    let score = 0
+
+    // BASE: importance weight (0-1)
+    score += memory.importance_weight ?? 0.5
+
+    // SIGNAL BOOST: reward strong relevance match
+    if (signalCount >= 4) score += 0.2
+    else if (signalCount >= 3) score += 0.1
+
+    // AWAITING: unfinished work needs attention
+    if (memory.awaiting_implementation) score += 0.15
+    if (memory.awaiting_decision) score += 0.1
+
+    // CONTEXT TYPE MATCH: does user's intent match memory type?
+    const contextType = memory.context_type?.toLowerCase() ?? ''
+    const contextKeywords: Record<string, string[]> = {
+      debugging: ['debug', 'bug', 'error', 'fix', 'issue', 'problem', 'broken'],
+      decision: ['decide', 'decision', 'choose', 'choice', 'option', 'should'],
+      architectural: ['architect', 'design', 'structure', 'pattern', 'how'],
+      breakthrough: ['insight', 'realize', 'understand', 'discover', 'why'],
+      technical: ['implement', 'code', 'function', 'method', 'api'],
+      workflow: ['process', 'workflow', 'step', 'flow', 'pipeline'],
+      philosophy: ['philosophy', 'principle', 'belief', 'approach', 'think'],
+    }
+    const keywords = contextKeywords[contextType] ?? []
+    for (const kw of keywords) {
+      if (messageWords.has(kw) || messageLower.includes(kw)) {
+        score += 0.1
+        break // Only one boost per context match
+      }
+    }
+
+    // PROBLEM/SOLUTION: boost if user seems to have a problem
+    if (memory.problem_solution_pair) {
+      const problemWords = ['error', 'bug', 'issue', 'problem', 'wrong', 'fail', 'broken', 'help', 'stuck']
+      for (const pw of problemWords) {
+        if (messageWords.has(pw) || messageLower.includes(pw)) {
+          score += 0.1
+          break
+        }
+      }
+    }
+
+    // TEMPORAL CLASS: eternal truths matter more
+    const temporalClass = memory.temporal_class ?? 'medium_term'
+    if (temporalClass === 'eternal') score += 0.1
+    else if (temporalClass === 'long_term') score += 0.05
+    else if (temporalClass === 'ephemeral') {
+      // Ephemeral only gets boost if from recent session (sessions_since_surfaced <= 1)
+      if ((memory.sessions_since_surfaced ?? 0) <= 1) score += 0.1
+    }
+
+    // CONFIDENCE PENALTY: low confidence memories are less reliable
+    const confidence = memory.confidence_score ?? 0.7
+    if (confidence < 0.5) score -= 0.1
+
+    // EMOTIONAL RESONANCE: match emotional context
+    const emotionalKeywords: Record<string, string[]> = {
+      frustration: ['frustrated', 'annoying', 'stuck', 'ugh', 'damn', 'hate'],
+      excitement: ['excited', 'awesome', 'amazing', 'love', 'great', 'wow'],
+      curiosity: ['wonder', 'curious', 'interesting', 'how', 'why', 'what if'],
+      satisfaction: ['done', 'finished', 'complete', 'works', 'solved', 'finally'],
+      discovery: ['found', 'realized', 'understand', 'insight', 'breakthrough'],
+    }
+    const emotion = memory.emotional_resonance?.toLowerCase() ?? ''
+    const emotionKws = emotionalKeywords[emotion] ?? []
+    for (const ew of emotionKws) {
+      if (messageWords.has(ew) || messageLower.includes(ew)) {
+        score += 0.05
+        break
+      }
+    }
+
+    return score
+  }
+
   /**
-   * Retrieve relevant memories using 10-dimensional scoring
+   * Main retrieval - Activation Signal Algorithm
    */
   retrieveRelevantMemories(
     allMemories: StoredMemory[],
@@ -71,475 +359,314 @@ export class SmartVectorRetrieval {
     queryEmbedding: Float32Array | number[],
     sessionContext: SessionContext,
     maxMemories: number = 5,
-    alreadyInjectedCount: number = 0
+    alreadyInjectedCount: number = 0,
+    maxGlobalMemories: number = 2
   ): RetrievalResult[] {
+    const startTime = performance.now()
+
     if (!allMemories.length) {
       return []
     }
 
-    const scoredMemories: ScoredMemory[] = []
-
-    for (const memory of allMemories) {
-      // ================================================================
-      // THE 10 DIMENSIONS
-      // ================================================================
+    const messageLower = currentMessage.toLowerCase()
+    const messageWords = this._extractSignificantWords(currentMessage)
 
-      // 1. Vector similarity score (0-1)
-      const vectorScore = this._calculateVectorSimilarity(
-        queryEmbedding,
-        memory.embedding
-      )
+    // ================================================================
+    // PHASE 0: PRE-FILTER (Binary exclusions)
+    // ================================================================
+    const candidates = this._preFilter(allMemories, sessionContext.project_id, messageLower)
+    if (!candidates.length) {
+      return []
+    }
 
-      // 2. Importance weight from curator (0-1)
-      const importance = memory.importance_weight ?? 0.5
+    // ================================================================
+    // PHASE 1: ACTIVATION SIGNALS
+    // Count how many signals agree this memory should activate
+    // A memory is relevant if >= MIN_ACTIVATION_SIGNALS fire
+    // ================================================================
+    const activatedMemories: ActivatedMemory[] = []
+    let rejectedCount = 0
 
-      // 3. Temporal relevance scoring
-      const temporalScore = this._scoreTemporalRelevance(
-        memory.temporal_relevance ?? 'persistent',
-        sessionContext
-      )
+    for (const memory of candidates) {
+      const isGlobal = memory.scope === 'global' || memory.project_id === 'global'
 
-      // 4. Context type alignment
-      const contextScore = this._scoreContextAlignment(
-        currentMessage,
-        memory.context_type ?? 'general'
+      // Check each activation signal
+      const triggerResult = this._checkTriggerActivation(
+        messageLower, messageWords, memory.trigger_phrases ?? []
       )
-
-      // 5. Action required boost
-      const actionBoost = memory.action_required ? 0.3 : 0.0
-
-      // 6. Semantic tag matching
-      const tagScore = this._scoreSemanticTags(
-        currentMessage,
-        memory.semantic_tags ?? []
+      const tagResult = this._checkTagActivation(
+        messageLower, messageWords, memory.semantic_tags ?? []
       )
-
-      // 7. Trigger phrase matching (highest priority)
-      const triggerScore = this._scoreTriggerPhrases(
-        currentMessage,
-        memory.trigger_phrases ?? []
+      const domainActivated = this._checkDomainActivation(
+        messageLower, messageWords, memory.domain
       )
-
-      // 8. Question type matching
-      const questionScore = this._scoreQuestionTypes(
-        currentMessage,
-        memory.question_types ?? []
+      const featureActivated = this._checkFeatureActivation(
+        messageLower, messageWords, memory.feature
       )
-
-      // 9. Emotional resonance
-      const emotionScore = this._scoreEmotionalContext(
-        currentMessage,
-        memory.emotional_resonance ?? ''
-      )
-
-      // 10. Problem-solution patterns
-      const problemScore = this._scoreProblemSolution(
-        currentMessage,
-        memory.problem_solution_pair ?? false
-      )
-
-      // Get confidence score
-      const confidenceScore = memory.confidence_score ?? 0.8
-
-      // ================================================================
-      // THE RELEVANCE GATEKEEPER SYSTEM
-      // ================================================================
-
-      // Calculate relevance score (gatekeeper - max 0.3)
-      const relevanceScore = (
-        triggerScore * 0.10 +      // Trigger match
-        vectorScore * 0.10 +       // Semantic similarity
-        tagScore * 0.05 +          // Tag matching
-        questionScore * 0.05       // Question match
-      )  // Max = 0.30
-
-      // Calculate importance/value score (max 0.7)
-      const valueScore = (
-        importance * 0.20 +         // Curator's importance
-        temporalScore * 0.10 +      // Time relevance
-        contextScore * 0.10 +       // Context alignment
-        confidenceScore * 0.10 +    // Confidence
-        emotionScore * 0.10 +       // Emotional resonance
-        problemScore * 0.05 +       // Problem-solution
-        actionBoost * 0.05          // Action priority
-      )  // Max = 0.70
-
-      // Relevance unlocks the full score!
-      const finalScore = valueScore + relevanceScore  // Max = 1.0
-
-      // GATEKEEPER CHECK: Must have minimum relevance AND total score
-      if (relevanceScore < 0.05 || finalScore < 0.3) {
-        // Skip this memory - not relevant enough
-        continue
+      const contentActivated = this._checkContentActivation(messageWords, memory)
+      const vectorSimilarity = this._calculateVectorSimilarity(queryEmbedding, memory.embedding)
+
+      // Count activated signals
+      let signalCount = 0
+      if (triggerResult.activated) signalCount++
+      if (tagResult.activated) signalCount++
+      if (domainActivated) signalCount++
+      if (featureActivated) signalCount++
+      if (contentActivated) signalCount++
+      // Vector similarity as bonus signal only if very high
+      if (vectorSimilarity >= 0.40) signalCount++
+
+      const signals: ActivationSignals = {
+        trigger: triggerResult.activated,
+        tags: tagResult.activated,
+        domain: domainActivated,
+        feature: featureActivated,
+        content: contentActivated,
+        count: signalCount,
+        triggerStrength: triggerResult.strength,
+        tagCount: tagResult.count,
+        vectorSimilarity,
       }
 
-      // Add reasoning for why this was selected
-      const components: ScoringComponents = {
-        trigger: triggerScore,
-        vector: vectorScore,
-        importance,
-        temporal: temporalScore,
-        context: contextScore,
-        tags: tagScore,
-        question: questionScore,
-        emotion: emotionScore,
-        problem: problemScore,
-        action: actionBoost
+      // RELEVANCE GATE: Must have at least MIN_ACTIVATION_SIGNALS
+      if (signalCount < MIN_ACTIVATION_SIGNALS) {
+        rejectedCount++
+        continue
       }
 
-      const reasoning = this._generateSelectionReasoning(components)
+      // Calculate importance for ranking (Phase 2) - uses ALL rich metadata
+      const importanceScore = this._calculateImportanceScore(memory, signalCount, messageLower, messageWords)
 
-      scoredMemories.push({
+      activatedMemories.push({
         memory,
-        score: finalScore,
-        relevance_score: relevanceScore,
-        value_score: valueScore,
-        reasoning,
-        components
+        signals,
+        importanceScore,
+        isGlobal,
       })
     }
 
-    // Sort by score
-    scoredMemories.sort((a, b) => b.score - a.score)
+    // Log diagnostics
+    this._logActivationDistribution(activatedMemories, candidates.length, rejectedCount)
+    this._logVectorStats()
+
+    // If nothing activated, return empty - silence over noise
+    if (!activatedMemories.length) {
+      const durationMs = performance.now() - startTime
+      logger.logRetrievalScoring({
+        totalMemories: allMemories.length,
+        currentMessage,
+        alreadyInjected: alreadyInjectedCount,
+        preFiltered: allMemories.length - candidates.length,
+        globalCount: 0,
+        projectCount: 0,
+        finalCount: 0,
+        durationMs,
+        selectedMemories: [],
+      })
+      return []
+    }
 
     // ================================================================
-    // MULTI-TIER SELECTION STRATEGY
-    // Like how human memory floods in
+    // PHASE 2: IMPORTANCE RANKING (Among Relevant)
+    // Sort by: signal count (primary), then importance (secondary)
     // ================================================================
+    activatedMemories.sort((a, b) => {
+      // First by signal count (more signals = more certainly relevant)
+      if (b.signals.count !== a.signals.count) {
+        return b.signals.count - a.signals.count
+      }
+      // Then by importance score
+      return b.importanceScore - a.importanceScore
+    })
 
-    const selected: ScoredMemory[] = []
+    // ================================================================
+    // PHASE 3: SELECTION
+    // Separate global/project, respect limits
+    // ================================================================
+    const selected: ActivatedMemory[] = []
     const selectedIds = new Set<string>()
 
-    // Tier 1: MUST include (trigger phrases, high importance, action required)
-    const mustInclude = scoredMemories.filter(m =>
-      m.score > 0.8 ||                    // Very high combined score
-      m.components.importance > 0.9 ||    // Critical importance
-      m.components.action > 0 ||          // Action required
-      Object.values(m.components).some(v => v > 0.9)  // Any perfect match
-    )
+    const globalMemories = activatedMemories.filter(m => m.isGlobal)
+    const projectMemories = activatedMemories.filter(m => !m.isGlobal)
+
+    // --- GLOBAL MEMORIES (max 2) ---
+    const globalsSorted = globalMemories.sort((a, b) => {
+      const aPriority = GLOBAL_TYPE_PRIORITY[a.memory.context_type ?? 'personal'] ?? 8
+      const bPriority = GLOBAL_TYPE_PRIORITY[b.memory.context_type ?? 'personal'] ?? 8
+      if (aPriority !== bPriority) return aPriority - bPriority
+      if (b.signals.count !== a.signals.count) return b.signals.count - a.signals.count
+      return b.importanceScore - a.importanceScore
+    })
 
-    for (const item of mustInclude.slice(0, maxMemories)) {
+    for (const item of globalsSorted.slice(0, maxGlobalMemories)) {
       if (!selectedIds.has(item.memory.id)) {
         selected.push(item)
         selectedIds.add(item.memory.id)
       }
     }
 
-    // Tier 2: SHOULD include (high scores, diverse perspectives)
-    const remainingSlots = Math.max(maxMemories - selected.length, 0)
-    if (remainingSlots > 0 && selected.length < maxMemories * 1.5) {
-      const typesIncluded = new Set<string>()
-
-      for (const item of scoredMemories) {
-        if (selected.length >= maxMemories * 1.5) break
-        if (selectedIds.has(item.memory.id)) continue
-
-        const memoryType = item.memory.context_type ?? 'general'
+    // --- PROJECT MEMORIES ---
+    // Prioritize: action_required, high signal count, high importance
+    const projectsSorted = [...projectMemories].sort((a, b) => {
+      const aAction = a.memory.action_required ? 1 : 0
+      const bAction = b.memory.action_required ? 1 : 0
+      if (bAction !== aAction) return bAction - aAction
+      if (b.signals.count !== a.signals.count) return b.signals.count - a.signals.count
+      return b.importanceScore - a.importanceScore
+    })
 
-        // Include if: high score OR new perspective OR emotional resonance
-        if (item.score > 0.5 ||
-            !typesIncluded.has(memoryType) ||
-            item.memory.emotional_resonance) {
-          selected.push(item)
-          selectedIds.add(item.memory.id)
-          typesIncluded.add(memoryType)
-        }
-      }
+    // Debug: show top 15 candidates with calculated scores
+    console.log(`[DEBUG] Top 15 candidates (sorted):`)
+    for (let i = 0; i < Math.min(15, projectsSorted.length); i++) {
+      const m = projectsSorted[i]
+      const action = m.memory.action_required ? '⚡' : ''
+      console.log(`  ${i+1}. [${m.signals.count}sig] score=${m.importanceScore.toFixed(2)} ${action} ${m.memory.content.slice(0, 45)}...`)
     }
 
-    // Tier 3: CONTEXT enrichment (related but not directly relevant)
-    // These provide ambient context like peripheral vision
-    if (selected.length < maxMemories * 2) {
-      const currentTags = new Set<string>()
-      const currentDomains = new Set<string>()
+    for (const item of projectsSorted) {
+      if (selected.length >= maxMemories) break
+      if (selectedIds.has(item.memory.id)) continue
+      selected.push(item)
+      selectedIds.add(item.memory.id)
+    }
 
+    // PHASE 4: RELATED MEMORIES (if space remains)
+    if (selected.length < maxMemories) {
+      const relatedIds = new Set<string>()
       for (const item of selected) {
-        for (const tag of item.memory.semantic_tags ?? []) {
-          if (tag.trim()) currentTags.add(tag.trim().toLowerCase())
-        }
-        if (item.memory.knowledge_domain) {
-          currentDomains.add(item.memory.knowledge_domain)
+        for (const relatedId of item.memory.related_to ?? []) {
+          if (!selectedIds.has(relatedId)) {
+            relatedIds.add(relatedId)
+          }
         }
       }
 
-      for (const item of scoredMemories) {
-        if (selected.length >= maxMemories * 2) break
+      for (const item of activatedMemories) {
+        if (selected.length >= maxMemories) break
         if (selectedIds.has(item.memory.id)) continue
-
-        const memoryTags = new Set(
-          (item.memory.semantic_tags ?? []).map(t => t.trim().toLowerCase())
-        )
-        const memoryDomain = item.memory.knowledge_domain ?? ''
-
-        // Include if shares context with already selected memories
-        const hasSharedTags = [...memoryTags].some(t => currentTags.has(t))
-        const hasSharedDomain = currentDomains.has(memoryDomain)
-
-        if (hasSharedTags || hasSharedDomain) {
+        if (relatedIds.has(item.memory.id)) {
           selected.push(item)
           selectedIds.add(item.memory.id)
         }
       }
     }
 
-    // Respect the max_memories limit strictly
-    const finalSelected = selected.slice(0, maxMemories)
+    const durationMs = performance.now() - startTime
 
-    // Log the retrieval scoring details
+    // Log the final selection
     logger.logRetrievalScoring({
       totalMemories: allMemories.length,
       currentMessage,
       alreadyInjected: alreadyInjectedCount,
-      mustIncludeCount: mustInclude.length,
-      remainingSlots: remainingSlots,
-      finalCount: finalSelected.length,
-      selectedMemories: finalSelected.map(item => ({
+      preFiltered: allMemories.length - candidates.length,
+      globalCount: globalMemories.length,
+      projectCount: projectMemories.length,
+      finalCount: selected.length,
+      durationMs,
+      selectedMemories: selected.map(item => ({
         content: item.memory.content,
-        reasoning: item.reasoning,
-        score: item.score,
-        relevance_score: item.relevance_score,
+        reasoning: this._generateActivationReasoning(item.signals),
+        signalCount: item.signals.count,
         importance_weight: item.memory.importance_weight ?? 0.5,
         context_type: item.memory.context_type ?? 'general',
         semantic_tags: item.memory.semantic_tags ?? [],
-        components: item.components,
+        isGlobal: item.isGlobal,
+        signals: {
+          trigger: item.signals.trigger,
+          triggerStrength: item.signals.triggerStrength,
+          tags: item.signals.tags,
+          tagCount: item.signals.tagCount,
+          domain: item.signals.domain,
+          feature: item.signals.feature,
+          content: item.signals.content,
+          vector: item.signals.vectorSimilarity >= 0.40,
+          vectorSimilarity: item.signals.vectorSimilarity,
+        },
       })),
     })
 
     // Convert to RetrievalResult format
-    return finalSelected.map(item => ({
+    return selected.map(item => ({
       ...item.memory,
-      score: item.score,
-      relevance_score: item.relevance_score,
-      value_score: item.value_score,
+      score: item.signals.count / 6,
+      relevance_score: item.signals.count / 6,
+      value_score: item.importanceScore,
     }))
   }
 
-  // ================================================================
-  // SCORING FUNCTIONS - Exact match to Python
-  // ================================================================
-
-  private _calculateVectorSimilarity(
-    vec1: Float32Array | number[] | undefined,
-    vec2: Float32Array | undefined
-  ): number {
-    if (!vec1 || !vec2) return 0.0
-
-    // Use FatherStateDB's optimized cosine similarity
-    const v1 = vec1 instanceof Float32Array ? vec1 : new Float32Array(vec1)
-    return cosineSimilarity(v1, vec2)
-  }
-
-  private _scoreTemporalRelevance(
-    temporalType: string,
-    _sessionContext: SessionContext
-  ): number {
-    const scores: Record<string, number> = {
-      'persistent': 0.8,    // Always relevant
-      'session': 0.6,       // Session-specific
-      'temporary': 0.3,     // Short-term
-      'archived': 0.1       // Historical
-    }
-    return scores[temporalType] ?? 0.5
-  }
-
-  private _scoreContextAlignment(message: string, contextType: string): number {
-    const messageLower = message.toLowerCase()
-
-    // Keywords that suggest different contexts
-    const contextIndicators: Record<string, string[]> = {
-      'technical_state': ['bug', 'error', 'fix', 'implement', 'code', 'function'],
-      'breakthrough': ['idea', 'realized', 'discovered', 'insight', 'solution'],
-      'project_context': ['project', 'building', 'architecture', 'system'],
-      'personal': ['dear friend', 'thank', 'appreciate', 'feel'],
-      'unresolved': ['todo', 'need to', 'should', 'must', 'problem'],
-      'decision': ['decided', 'chose', 'will use', 'approach', 'strategy']
-    }
-
-    const indicators = contextIndicators[contextType] ?? []
-    const matches = indicators.filter(word => messageLower.includes(word)).length
-
-    if (matches > 0) {
-      return Math.min(0.3 + (matches * 0.2), 1.0)
-    }
-    return 0.1
-  }
-
-  private _scoreSemanticTags(message: string, tags: string[]): number {
-    if (!tags.length) return 0.0
-
-    const messageLower = message.toLowerCase()
-    const matches = tags.filter(tag =>
-      messageLower.includes(tag.trim().toLowerCase())
-    ).length
-
-    if (matches > 0) {
-      return Math.min(0.3 + (matches * 0.3), 1.0)
-    }
-    return 0.0
-  }
-
-  private _scoreTriggerPhrases(message: string, triggerPhrases: string[]): number {
-    if (!triggerPhrases.length) return 0.0
-
-    const messageLower = message.toLowerCase()
-    const stopWords = new Set([
-      'the', 'is', 'are', 'was', 'were', 'to', 'a', 'an', 'and', 'or',
-      'but', 'in', 'on', 'at', 'for', 'with', 'about', 'when', 'how',
-      'what', 'why'
-    ])
-
-    let maxScore = 0.0
-
-    for (const pattern of triggerPhrases) {
-      const patternLower = pattern.trim().toLowerCase()
-
-      // Strategy 1: Key concept matching (individual important words)
-      const patternWords = patternLower
-        .split(/\s+/)
-        .filter(w => !stopWords.has(w) && w.length > 2)
-
-      if (patternWords.length) {
-        let matches = 0
-        for (const word of patternWords) {
-          // Direct match
-          if (messageLower.includes(word)) {
-            matches += 1
-          }
-          // Plural/singular variations
-          else if (messageLower.includes(word.replace(/s$/, '')) ||
-                   messageLower.includes(word + 's')) {
-            matches += 0.9
-          }
-          // Substring match for compound words
-          else if (messageLower.split(/\s+/).some(msgWord => msgWord.includes(word))) {
-            matches += 0.7
-          }
-        }
-
-        // Score based on percentage of concepts found
-        let conceptScore = patternWords.length ? matches / patternWords.length : 0
-
-        // Strategy 2: Contextual pattern matching
-        const situationalIndicators = [
-          'when', 'during', 'while', 'asking about', 'working on', 'debugging', 'trying to'
-        ]
-        if (situationalIndicators.some(ind => patternLower.includes(ind))) {
-          // This is a situational pattern - be more flexible
-          if (patternWords.some(keyWord => messageLower.includes(keyWord))) {
-            conceptScore = Math.max(conceptScore, 0.7)  // Boost for situational match
-          }
-        }
-
-        maxScore = Math.max(maxScore, conceptScore)
-      }
-    }
-
-    return Math.min(maxScore, 1.0)
-  }
-
-  private _scoreQuestionTypes(message: string, questionTypes: string[]): number {
-    if (!questionTypes.length) return 0.0
-
-    const messageLower = message.toLowerCase()
-    const questionWords = ['how', 'why', 'what', 'when', 'where']
-
-    for (const qtype of questionTypes) {
-      const qtypeLower = qtype.trim().toLowerCase()
-
-      if (messageLower.includes(qtypeLower)) {
-        return 0.8
-      }
-
-      // Partial matching for question words
-      const messageHasQuestion = questionWords.some(qw => messageLower.includes(qw))
-      const typeHasQuestion = questionWords.some(qw => qtypeLower.includes(qw))
+  /**
+   * Generate reasoning string from activation signals
+   */
+  private _generateActivationReasoning(signals: ActivationSignals): string {
+    const reasons: string[] = []
 
-      if (messageHasQuestion && typeHasQuestion) {
-        return 0.5
-      }
-    }
+    if (signals.trigger) reasons.push(`trigger:${(signals.triggerStrength * 100).toFixed(0)}%`)
+    if (signals.tags) reasons.push(`tags:${signals.tagCount}`)
+    if (signals.domain) reasons.push('domain')
+    if (signals.feature) reasons.push('feature')
+    if (signals.content) reasons.push('content')
+    if (signals.vectorSimilarity >= 0.40) reasons.push(`vector:${(signals.vectorSimilarity * 100).toFixed(0)}%`)
 
-    return 0.0
+    return reasons.length
+      ? `Activated: ${reasons.join(', ')} (${signals.count} signals)`
+      : 'No signals'
   }
 
-  private _scoreEmotionalContext(message: string, emotion: string): number {
-    if (!emotion) return 0.0
-
-    const messageLower = message.toLowerCase()
-
-    // Emotion indicators
-    const emotionPatterns: Record<string, string[]> = {
-      'joy': ['happy', 'excited', 'love', 'wonderful', 'great', 'awesome'],
-      'frustration': ['stuck', 'confused', 'help', 'issue', 'problem', 'why'],
-      'discovery': ['realized', 'found', 'discovered', 'aha', 'insight'],
-      'gratitude': ['thank', 'appreciate', 'grateful', 'dear friend']
+  /**
+   * Log activation distribution for diagnostics
+   */
+  private _logActivationDistribution(
+    activated: ActivatedMemory[],
+    totalCandidates: number,
+    rejectedCount: number
+  ): void {
+    const signalBuckets: Record<string, number> = {
+      '2 signals': 0, '3 signals': 0, '4 signals': 0, '5 signals': 0, '6 signals': 0
     }
-
-    const patterns = emotionPatterns[emotion.toLowerCase()] ?? []
-    if (patterns.some(pattern => messageLower.includes(pattern))) {
-      return 0.7
+    for (const mem of activated) {
+      const key = `${Math.min(mem.signals.count, 6)} signals`
+      signalBuckets[key] = (signalBuckets[key] ?? 0) + 1
     }
 
-    return 0.0
-  }
-
-  private _scoreProblemSolution(message: string, isProblemSolution: boolean): number {
-    if (!isProblemSolution) return 0.0
-
-    const messageLower = message.toLowerCase()
-
-    // Problem indicators
-    const problemWords = [
-      'error', 'issue', 'problem', 'stuck', 'help', 'fix', 'solve', 'debug'
-    ]
-
-    if (problemWords.some(word => messageLower.includes(word))) {
-      return 0.8
+    let triggerCount = 0, tagCount = 0, domainCount = 0, featureCount = 0, contentCount = 0, vectorCount = 0
+    for (const mem of activated) {
+      if (mem.signals.trigger) triggerCount++
+      if (mem.signals.tags) tagCount++
+      if (mem.signals.domain) domainCount++
+      if (mem.signals.feature) featureCount++
+      if (mem.signals.content) contentCount++
+      if (mem.signals.vectorSimilarity >= 0.40) vectorCount++
     }
 
-    return 0.0
+    logger.logScoreDistribution({
+      totalCandidates,
+      passedGatekeeper: activated.length,
+      rejectedByGatekeeper: rejectedCount,
+      buckets: signalBuckets,
+      stats: {
+        min: activated.length ? Math.min(...activated.map(m => m.signals.count)) : 0,
+        max: activated.length ? Math.max(...activated.map(m => m.signals.count)) : 0,
+        mean: activated.length ? Math.round(activated.reduce((s, m) => s + m.signals.count, 0) / activated.length * 10) / 10 : 0,
+        stdev: 0,
+        spread: activated.length ? Math.max(...activated.map(m => m.signals.count)) - Math.min(...activated.map(m => m.signals.count)) : 0,
+      },
+      percentiles: {},
+      compressionWarning: false,
+      signalBreakdown: {
+        trigger: triggerCount,
+        tags: tagCount,
+        domain: domainCount,
+        feature: featureCount,
+        content: contentCount,
+        vector: vectorCount,
+        total: activated.length,
+      },
+    })
   }
 
-  private _generateSelectionReasoning(components: ScoringComponents): string {
-    const scores: [string, number][] = [
-      ['trigger phrase match', components.trigger],
-      ['semantic similarity', components.vector],
-      ['high importance', components.importance],
-      ['question type match', components.question],
-      ['context alignment', components.context],
-      ['temporal relevance', components.temporal],
-      ['tag match', components.tags],
-      ['emotional resonance', components.emotion],
-      ['problem-solution', components.problem],
-      ['action required', components.action]
-    ]
-
-    // Sort by score
-    scores.sort((a, b) => b[1] - a[1])
-
-    const reasons: string[] = []
-
-    // Build reasoning
-    const primary = scores[0]!
-    if (primary[1] > 0.5) {
-      reasons.push(`Strong ${primary[0]} (${primary[1].toFixed(2)})`)
-    } else if (primary[1] > 0.3) {
-      reasons.push(`${primary[0]} (${primary[1].toFixed(2)})`)
-    }
-
-    // Add secondary reasons
-    for (const [reason, score] of scores.slice(1, 3)) {
-      if (score > 0.3) {
-        reasons.push(`${reason} (${score.toFixed(2)})`)
-      }
-    }
-
-    return reasons.length
-      ? 'Selected due to: ' + reasons.join(', ')
-      : 'Selected based on combined factors'
-  }
 }
 
+
 /**
  * Create a new SmartVectorRetrieval instance
  */