feat: Implement Memory & Self-Reflection System

PHASE 1 - Session Memory:
- SessionMemory class with buffer, summary, persistence
- Sliding window + recursive summarization
- Integrated into noesis CLI via noesis_chat.py

PHASE 2 - Entity Index (Associative Memory):
- EntityExtractor with regex-based extraction
- EntityIndex inverted index for memory connections
- Integrated into MemoryStore (auto-extract on store)
- ContextBuilder now finds connected memories via entities

PHASE 3 - Self-Reflection Loop:
- SelfReflector with auto-assessment
- Authenticity scoring (0-10)
- Insight extraction for learning
- Async/non-blocking integration in chat
- Stores insights in SEMANTIC memory

Based on:
- Reflexion (Shinn et al., 2023)
- Stanford Generative Agents memory
- Anthropic context patterns
- Mem0 graph memory

Author: JuanCS-Dev

.noesis.pid

@@ -0,0 +1,3 @@
+79945
+80261
+80661

backend/services/episodic_memory/src/episodic_memory/core/__init__.py

@@ -2,6 +2,38 @@
 Episodic Memory - Core Module.
 
 Core business logic for memory storage and retrieval.
+
+Components:
+- MemoryStore: MIRIX-compatible storage with entity extraction
+- ContextBuilder: Multi-type context with associative retrieval
+- EntityIndex: Inverted index for connecting memories
+- EntityExtractor: Regex-based entity extraction
 """
 
 from __future__ import annotations
+
+from .memory_store import MemoryStore
+from .context_builder import ContextBuilder, MemoryContext
+from .entity_index import (
+    EntityExtractor,
+    EntityIndex,
+    EntityMatch,
+    get_entity_extractor,
+    get_entity_index,
+    extract_and_index,
+)
+
+__all__ = [
+    # Memory storage
+    "MemoryStore",
+    # Context building
+    "ContextBuilder",
+    "MemoryContext",
+    # Entity system
+    "EntityExtractor",
+    "EntityIndex",
+    "EntityMatch",
+    "get_entity_extractor",
+    "get_entity_index",
+    "extract_and_index",
+]

backend/services/episodic_memory/src/episodic_memory/core/context_builder.py

@@ -3,25 +3,49 @@
 ==========================================
 
 Builds context combining all 6 MIRIX memory types for task execution.
+Now with entity-based associative retrieval for connected reasoning.
 
 Based on: MIRIX Active Retrieval Mechanism (arXiv:2507.07957)
 Retrieval scoring: Stanford Generative Agents (recency + importance + relevance)
+Entity connections: Anthropic context patterns + Mem0 graph memory
 """
 
 from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, TYPE_CHECKING
+from typing import Dict, List, Optional, Set, TYPE_CHECKING
 
 from episodic_memory.models.memory import Memory, MemoryType
 
 if TYPE_CHECKING:
-    from core.memory_store import MemoryStore
+    from episodic_memory.core.memory_store import MemoryStore
 
 
 logger = logging.getLogger(__name__)
 
+# Lazy import entity index to avoid circular imports
+_entity_extractor = None
+_entity_index = None
+
+
+def _get_entity_extractor():
+    """Lazy load entity extractor."""
+    global _entity_extractor
+    if _entity_extractor is None:
+        from episodic_memory.core.entity_index import EntityExtractor
+        _entity_extractor = EntityExtractor()
+    return _entity_extractor
+
+
+def _get_entity_index():
+    """Lazy load entity index."""
+    global _entity_index
+    if _entity_index is None:
+        from episodic_memory.core.entity_index import EntityIndex
+        _entity_index = EntityIndex.load_from_disk() or EntityIndex()
+    return _entity_index
+
 
 # Default top-K per memory type
 DEFAULT_TOP_K: Dict[MemoryType, int] = {
@@ -37,7 +61,7 @@
 @dataclass
 class MemoryContext:  # pylint: disable=too-many-instance-attributes
     """
-    Context combining all 6 MIRIX memory types.
+    Context combining all 6 MIRIX memory types + connected memories.
 
     Attributes:
         core: Identity + user facts (always included)
@@ -46,7 +70,9 @@ class MemoryContext:  # pylint: disable=too-many-instance-attributes
         procedural: Applicable workflows/skills
         resource: Referenced documents
         vault: High-confidence consolidated memories
+        connected: Memories connected via shared entities (associative)
         retrieval_scores: Score per retrieved memory
+        entity_connections: Mapping of memory_id -> shared entities
         task: Original task query
     """
 
@@ -56,7 +82,9 @@ class MemoryContext:  # pylint: disable=too-many-instance-attributes
     procedural: List[Memory] = field(default_factory=list)
     resource: List[Memory] = field(default_factory=list)
     vault: List[Memory] = field(default_factory=list)
+    connected: List[Memory] = field(default_factory=list)
     retrieval_scores: Dict[str, float] = field(default_factory=dict)
+    entity_connections: Dict[str, List[str]] = field(default_factory=dict)
     task: str = ""
 
     def to_prompt_context(self) -> str:
@@ -92,6 +120,17 @@ def to_prompt_context(self) -> str:
             vault_content = "\n".join(f"- {m.content}" for m in self.vault)
             sections.append(f"[VAULT (HIGH CONFIDENCE)]\n{vault_content}")
 
+        if self.connected:
+            # Format connected memories with their shared entities
+            connected_lines = []
+            for m in self.connected:
+                shared = self.entity_connections.get(m.memory_id, [])
+                if shared:
+                    connected_lines.append(f"- {m.content} (via: {', '.join(shared)})")
+                else:
+                    connected_lines.append(f"- {m.content}")
+            sections.append(f"[CONNECTED (ASSOCIATED MEMORIES)]\n" + "\n".join(connected_lines))
+
         return "\n\n".join(sections)
 
     def total_memories(self) -> int:
@@ -102,7 +141,8 @@ def total_memories(self) -> int:
             len(self.semantic) +
             len(self.procedural) +
             len(self.resource) +
-            len(self.vault)
+            len(self.vault) +
+            len(self.connected)
         )
 
     def to_dict(self) -> Dict:
@@ -115,7 +155,9 @@ def to_dict(self) -> Dict:
             "procedural": [m.model_dump() for m in self.procedural],
             "resource": [m.model_dump() for m in self.resource],
             "vault": [m.model_dump() for m in self.vault],
+            "connected": [m.model_dump() for m in self.connected],
             "retrieval_scores": self.retrieval_scores,
+            "entity_connections": self.entity_connections,
             "total_memories": self.total_memories(),
         }
 
@@ -125,48 +167,57 @@ class ContextBuilder:  # pylint: disable=too-few-public-methods
     Builds multi-type memory context for tasks.
 
     Based on: MIRIX Active Retrieval Mechanism.
-    Uses keyword matching for now, extensible to vector search.
+    Uses keyword matching + entity-based associative retrieval.
     """
 
     def __init__(
         self,
         memory_store: "MemoryStore",
-        top_k: Optional[Dict[MemoryType, int]] = None
+        top_k: Optional[Dict[MemoryType, int]] = None,
+        max_connected: int = 5
     ) -> None:
         """
         Initialize context builder.
 
         Args:
             memory_store: Memory store instance
             top_k: Optional custom top-K per type (defaults to DEFAULT_TOP_K)
+            max_connected: Maximum connected memories to retrieve
         """
         self.store = memory_store
         self.top_k = top_k or DEFAULT_TOP_K.copy()
+        self.max_connected = max_connected
 
     async def get_context_for_task(self, task: str) -> MemoryContext:
         """
-        Build context combining all 6 MIRIX memory types.
+        Build context combining all 6 MIRIX memory types + connected memories.
 
         Pipeline:
         1. Extract keywords from task
-        2. Search each memory type (keyword match + importance sort)
-        3. Compute retrieval scores
-        4. Return combined MemoryContext
+        2. Extract entities from task (for associative retrieval)
+        3. Search each memory type (keyword match + importance sort)
+        4. Find connected memories via entity index
+        5. Compute retrieval scores
+        6. Return combined MemoryContext
 
         Args:
             task: Task description
 
         Returns:
-            MemoryContext with memories from all 6 types
+            MemoryContext with memories from all 6 types + connections
 
         Example:
-            >>> context = await builder.get_context_for_task("write unit tests")
-            >>> len(context.procedural)
-            5
+            >>> context = await builder.get_context_for_task("what did Juan say about memory?")
+            >>> len(context.connected)  # Memories connected via "Juan" entity
+            3
         """
         keywords = self._extract_keywords(task)
         results: Dict[MemoryType, List[Memory]] = {}
         scores: Dict[str, float] = {}
+        
+        # Extract entities from task for associative retrieval
+        extractor = _get_entity_extractor()
+        task_entities = extractor.extract(task)
 
         # Search each memory type
         for memory_type in MemoryType:
@@ -189,6 +240,13 @@ async def get_context_for_task(self, task: str) -> MemoryContext:
                 scores[mem.memory_id] = self._compute_retrieval_score(mem, keywords)
                 mem.record_access()  # Track access for decay boosting
 
+        # Find connected memories via entity index
+        connected_memories, entity_connections = await self._find_connected_memories(
+            task_entities,
+            results,
+            scores
+        )
+
         # Build context
         context = MemoryContext(
             core=results.get(MemoryType.CORE, []),
@@ -197,15 +255,70 @@ async def get_context_for_task(self, task: str) -> MemoryContext:
             procedural=results.get(MemoryType.PROCEDURAL, []),
             resource=results.get(MemoryType.RESOURCE, []),
             vault=results.get(MemoryType.VAULT, []),
+            connected=connected_memories,
             retrieval_scores=scores,
+            entity_connections=entity_connections,
             task=task,
         )
 
         logger.info(
-            "Built context for task '%s': %d memories",
-            task[:50], context.total_memories()
+            "Built context for task '%s': %d memories (%d connected via entities)",
+            task[:50], context.total_memories(), len(connected_memories)
         )
         return context
+    
+    async def _find_connected_memories(
+        self,
+        task_entities: List[str],
+        direct_results: Dict[MemoryType, List[Memory]],
+        scores: Dict[str, float]
+    ) -> tuple[List[Memory], Dict[str, List[str]]]:
+        """
+        Find memories connected via shared entities.
+
+        Args:
+            task_entities: Entities extracted from task
+            direct_results: Already retrieved memories (to exclude)
+            scores: Scores dict to update
+
+        Returns:
+            Tuple of (connected_memories, entity_connections)
+        """
+        if not task_entities:
+            return [], {}
+        
+        index = _get_entity_index()
+        
+        # Get IDs of already retrieved memories
+        already_retrieved: Set[str] = set()
+        for memories in direct_results.values():
+            already_retrieved.update(m.memory_id for m in memories)
+        
+        # Find related memories via entity index
+        related = index.get_related_memories(
+            task_entities,
+            exclude_ids=already_retrieved,
+            min_overlap=1
+        )
+        
+        connected_memories: List[Memory] = []
+        entity_connections: Dict[str, List[str]] = {}
+        
+        for memory_id, overlap_count in related[:self.max_connected]:
+            memory = self.store._storage.get(memory_id)  # pylint: disable=protected-access
+            if memory:
+                connected_memories.append(memory)
+                # Find which entities connect this memory
+                memory_entities = set(memory.context.get("entities", []))
+                shared = list(memory_entities & set(task_entities))
+                entity_connections[memory_id] = shared
+                
+                # Compute and store score
+                base_score = 0.5 + (overlap_count * 0.1)  # Boost for entity overlap
+                scores[memory_id] = min(1.0, base_score)
+                memory.record_access()
+        
+        return connected_memories, entity_connections
 
     async def _search_type(
         self,