superlocalmemory 3.2.1 → 3.2.2

package/src/superlocalmemory/core/engine.py

@@ -2,9 +2,13 @@
 # Licensed under the MIT License - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""SuperLocalMemory V3 — Main Memory Engine.
+"""SuperLocalMemory V3 — Main Memory Engine (Facade).
+
+Thin orchestrator that delegates to extracted pipeline modules:
+  - store_pipeline   (store, store_fact_direct, close_session, enrich_fact)
+  - recall_pipeline  (recall, adaptive ranking)
+  - engine_wiring    (embedder init, encoding init, retrieval init, hooks)
 
-Orchestrates the full memory lifecycle: store, encode, retrieve.
 Single entry point for all memory operations.
 Profile-scoped. Mode-aware (A/B/C).
 
@@ -19,7 +23,7 @@ from typing import Any
 from superlocalmemory.core.config import SLMConfig
 from superlocalmemory.core.modes import get_capabilities
 from superlocalmemory.storage.models import (
-    AtomicFact, FactType, MemoryRecord, Mode, RecallResponse,
+    AtomicFact, MemoryRecord, Mode, RecallResponse,
 )
 
 logger = logging.getLogger(__name__)
@@ -67,8 +71,35 @@ class MemoryEngine:
         self._provenance = None
         self._adaptive_learner = None
         self._compliance_checker = None
+        self._vector_store = None
+        self._access_log = None
+        self._context_generator = None
+        self._temporal_validator = None
+        self._auto_invoker = None
+        self._auto_linker = None
+        self._graph_analyzer = None
+        self._consolidation_engine = None
         self._hooks = HookRegistry()
 
+    # -- Public properties (Phase 2+ access) --------------------------------
+
+    @property
+    def db(self):
+        """Database manager (read-only access for Phase 2+)."""
+        return self._db
+
+    @property
+    def trust_scorer(self):
+        """Trust scorer (read-only access for Phase 2+)."""
+        return self._trust_scorer
+
+    @property
+    def embedder(self):
+        """Embedding service (read-only access for Phase 2+)."""
+        return self._embedder
+
+    # -- Initialization -----------------------------------------------------
+
     def initialize(self) -> None:
         """Initialize all components. Call once before use."""
         if self._initialized:
@@ -76,17 +107,22 @@ class MemoryEngine:
 
         from superlocalmemory.storage import schema
         from superlocalmemory.storage.database import DatabaseManager
-        from superlocalmemory.core.embeddings import EmbeddingService
         from superlocalmemory.llm.backbone import LLMBackbone
+        from superlocalmemory.core.engine_wiring import (
+            init_embedder, init_encoding, init_retrieval, wire_hooks,
+            _init_auto_invoker, _init_consolidation,
+        )
 
         self._db = DatabaseManager(self._config.db_path)
         self._db.initialize(schema)
-        self._embedder = self._init_embedder()
+        self._embedder = init_embedder(self._config)
 
         if self._caps.llm_fact_extraction:
             self._llm = LLMBackbone(self._config.llm)
             if not self._llm.is_available():
-                logger.warning("LLM not available. Falling back to Mode A extraction.")
+                logger.warning(
+                    "LLM not available. Falling back to Mode A extraction.",
+                )
                 self._llm = None
 
         from superlocalmemory.trust.scorer import TrustScorer
@@ -96,89 +132,72 @@ class MemoryEngine:
 
         self._trust_scorer = TrustScorer(self._db)
 
-        self._init_encoding()
-        self._init_retrieval()
+        # Encoding components
+        enc = init_encoding(
+            self._config, self._db, self._embedder, self._llm,
+        )
+        self._ann_index = enc["ann_index"]
+        self._fact_extractor = enc["fact_extractor"]
+        self._entity_resolver = enc["entity_resolver"]
+        self._temporal_parser = enc["temporal_parser"]
+        self._type_router = enc["type_router"]
+        self._graph_builder = enc["graph_builder"]
+        self._consolidator = enc["consolidator"]
+        self._observation_builder = enc["observation_builder"]
+        self._scene_builder = enc["scene_builder"]
+        self._entropy_gate = enc["entropy_gate"]
+        self._sheaf_checker = enc["sheaf_checker"]
+        self._vector_store = enc.get("vector_store")
+        self._access_log = enc.get("access_log")
+        self._context_generator = enc.get("context_generator")
+        self._temporal_validator = enc.get("temporal_validator")
+        self._auto_linker = enc.get("auto_linker")
+        self._graph_analyzer = enc.get("graph_analyzer")
+
+        # Retrieval engine
+        self._retrieval_engine = init_retrieval(
+            self._config, self._db, self._embedder,
+            self._entity_resolver, self._trust_scorer,
+            vector_store=self._vector_store,
+        )
 
         self._provenance = ProvenanceTracker(self._db)
         self._adaptive_learner = AdaptiveLearner(self._db)
         self._compliance_checker = EUAIActChecker()
 
         # Wire lifecycle hooks
-        self._wire_hooks()
+        hook_result = wire_hooks(
+            self._hooks, self._config, self._db,
+            self._trust_scorer, self._profile_id,
+        )
+        self._signal_recorder = hook_result["signal_recorder"]
+        self._audit_chain = hook_result["audit_chain"]
+
+        # V3.2: AutoInvoker (Phase 2) -- multi-signal auto-recall
+        self._auto_invoker = _init_auto_invoker(
+            self._config, self._db, self._vector_store,
+            self._trust_scorer, self._embedder,
+        )
+
+        # V3.2: ConsolidationEngine (Phase 5) -- sleep-time consolidation
+        from superlocalmemory.core.summarizer import Summarizer
+        summarizer = Summarizer(self._config)
+        self._consolidation_engine = _init_consolidation(
+            self._config, self._db,
+            auto_linker=self._auto_linker,
+            graph_analyzer=self._graph_analyzer,
+            temporal_validator=self._temporal_validator,
+            summarizer=summarizer,
+            behavioral_store=None,
+        )
 
         self._initialized = True
-        logger.info("MemoryEngine initialized: mode=%s profile=%s",
-                     self._config.mode.value, self._profile_id)
-
-    def _init_embedder(self):
-        """Initialize the best available embedding provider.
-
-        Priority order:
-        1. Explicit provider in config (ollama / cloud / sentence-transformers)
-        2. Auto-detect: if LLM provider=ollama and Ollama has embedding model → use it
-        3. Fallback to sentence-transformers subprocess
-        4. If nothing works → None (BM25-only mode)
-        """
-        from superlocalmemory.core.embeddings import EmbeddingService
-
-        emb_cfg = self._config.embedding
-        provider = emb_cfg.provider
-
-        # --- Explicit ollama provider ---
-        if provider == "ollama":
-            return self._try_ollama_embedder(emb_cfg)
-
-        # --- Explicit cloud provider ---
-        if provider == "cloud" or emb_cfg.is_cloud:
-            return self._try_service_embedder(EmbeddingService, emb_cfg)
-
-        # --- Explicit sentence-transformers ---
-        if provider == "sentence-transformers":
-            return self._try_service_embedder(EmbeddingService, emb_cfg)
-
-        # --- Auto-detect: try Ollama first (fast path, <1s) ---
-        # Check regardless of LLM provider — if Ollama is running and has
-        # the embedding model, use it. This avoids the 30s cold start of
-        # sentence-transformers subprocess.
-        ollama_emb = self._try_ollama_embedder(emb_cfg)
-        if ollama_emb is not None:
-            logger.info("Auto-detected Ollama embeddings (fast path)")
-            return ollama_emb
-
-        # --- Fallback: sentence-transformers subprocess ---
-        return self._try_service_embedder(EmbeddingService, emb_cfg)
-
-    def _try_ollama_embedder(self, emb_cfg):
-        """Try to create an OllamaEmbedder. Returns it or None."""
-        try:
-            from superlocalmemory.core.ollama_embedder import OllamaEmbedder
-            emb = OllamaEmbedder(
-                model=emb_cfg.ollama_model,
-                base_url=emb_cfg.ollama_base_url,
-                dimension=emb_cfg.dimension,
-            )
-            if emb.is_available:
-                logger.info("Using Ollama embeddings (%s)", emb_cfg.ollama_model)
-                return emb
-            logger.warning(
-                "Ollama embedder not available (model=%s). Falling back.",
-                emb_cfg.ollama_model,
-            )
-        except Exception as exc:
-            logger.warning("OllamaEmbedder init failed: %s", exc)
-        return None
-
-    @staticmethod
-    def _try_service_embedder(cls, emb_cfg):
-        """Try to create an EmbeddingService. Returns it or None."""
-        try:
-            emb = cls(emb_cfg)
-            if emb.is_available:
-                return emb
-            logger.warning("EmbeddingService not available. BM25-only mode. Run 'slm doctor' to diagnose.")
-        except Exception as exc:
-            logger.warning("Embeddings unavailable (%s). BM25-only mode. Run 'slm doctor' to diagnose.", exc)
-        return None
+        logger.info(
+            "MemoryEngine initialized: mode=%s profile=%s",
+            self._config.mode.value, self._profile_id,
+        )
+
+    # -- Store operations ---------------------------------------------------
 
     def store(
         self,
@@ -192,364 +211,79 @@ class MemoryEngine:
         """Store content and extract structured facts. Returns fact_ids."""
         self._ensure_init()
 
-        # Pre-operation hooks (trust gate, ABAC, rate limiter)
-        hook_ctx = {"operation": "store", "agent_id": metadata.get("agent_id", "unknown") if metadata else "unknown",
-                     "profile_id": self._profile_id, "content_preview": content[:100]}
-        self._hooks.run_pre("store", hook_ctx)
-
-        if self._entropy_gate and not self._entropy_gate.should_pass(content):
-            return []
+        from superlocalmemory.core.store_pipeline import run_store
+        return run_store(
+            content, self._profile_id,
+            session_id=session_id, session_date=session_date,
+            speaker=speaker, role=role, metadata=metadata,
+            config=self._config, db=self._db,
+            embedder=self._embedder,
+            fact_extractor=self._fact_extractor,
+            entity_resolver=self._entity_resolver,
+            temporal_parser=self._temporal_parser,
+            type_router=self._type_router,
+            graph_builder=self._graph_builder,
+            consolidator=self._consolidator,
+            observation_builder=self._observation_builder,
+            scene_builder=self._scene_builder,
+            entropy_gate=self._entropy_gate,
+            ann_index=self._ann_index,
+            sheaf_checker=self._sheaf_checker,
+            retrieval_engine=self._retrieval_engine,
+            provenance=self._provenance,
+            hooks=self._hooks,
+            vector_store=self._vector_store,
+            context_generator=self._context_generator,
+            temporal_validator=self._temporal_validator,
+            auto_linker=self._auto_linker,
+            consolidation_engine=self._consolidation_engine,
+        )
 
-        from superlocalmemory.encoding.temporal_parser import TemporalParser
-        parser = self._temporal_parser or TemporalParser()
-        parsed_date = parser.parse_session_date(session_date) if session_date else None
+    def store_fact_direct(self, fact: AtomicFact) -> str:
+        """Store a pre-built fact with full enrichment."""
+        self._ensure_init()
 
-        record = MemoryRecord(
-            profile_id=self._profile_id, content=content,
-            session_id=session_id, speaker=speaker, role=role,
-            session_date=parsed_date, metadata=metadata or {},
+        from superlocalmemory.core.store_pipeline import run_store_fact_direct
+        return run_store_fact_direct(
+            fact, self._profile_id,
+            db=self._db, embedder=self._embedder,
+            entity_resolver=self._entity_resolver,
+            ann_index=self._ann_index,
+            graph_builder=self._graph_builder,
+            retrieval_engine=self._retrieval_engine,
+            vector_store=self._vector_store,
         )
-        self._db.store_memory(record)
 
-        facts = self._fact_extractor.extract_facts(
-            turns=[content], session_id=session_id,
-            session_date=parsed_date, speaker_a=speaker,
-        )
-        if not facts:
-            return []
-
-        if self._type_router:
-            facts = self._type_router.route_facts(facts)
-
-        stored_ids: list[str] = []
-        for fact in facts:
-            fact = self._enrich_fact(fact, record)
-
-            if self._consolidator:
-                action = self._consolidator.consolidate(fact, self._profile_id)
-                if action.action_type.value == "noop":
-                    continue
-
-                # Opinion confidence tracking: reinforce or decay
-                # When a new opinion aligns with existing, boost confidence.
-                # When contradicted (supersede), reduce old fact's confidence.
-                if fact.fact_type == FactType.OPINION and action.action_type.value == "update":
-                    try:
-                        existing = self._db.get_fact(action.new_fact_id)
-                        if existing and existing.fact_type == FactType.OPINION:
-                            new_conf = min(1.0, existing.confidence + 0.1)
-                            self._db.update_fact(action.new_fact_id, {"confidence": new_conf})
-                    except Exception:
-                        pass
-                elif fact.fact_type == FactType.OPINION and action.action_type.value == "supersede":
-                    try:
-                        old_id = getattr(action, "old_fact_id", None)
-                        if old_id:
-                            old_fact = self._db.get_fact(old_id)
-                            if old_fact:
-                                new_conf = max(0.0, old_fact.confidence - 0.2)
-                                self._db.update_fact(old_id, {"confidence": new_conf})
-                    except Exception:
-                        pass
-
-                if action.action_type.value in ("update", "supersede"):
-                    # Run post-processing on updated facts
-                    updated_fact = self._db.get_fact(action.new_fact_id)
-                    if updated_fact:
-                        if self._graph_builder:
-                            self._graph_builder.build_edges(updated_fact, self._profile_id)
-                        if self._observation_builder:
-                            for eid in updated_fact.canonical_entities:
-                                self._observation_builder.update_profile(
-                                    eid, updated_fact, self._profile_id,
-                                )
-                    stored_ids.append(action.new_fact_id)
-                    continue
-                # ADD case: consolidator already stored the fact (F8 fix)
-                # Fall through to post-processing below
-            else:
-                self._db.store_fact(fact)
-
-            stored_ids.append(fact.fact_id)
-
-            if fact.embedding and self._ann_index:
-                self._ann_index.add(fact.fact_id, fact.embedding)
-            if self._graph_builder:
-                self._graph_builder.build_edges(fact, self._profile_id)
-
-            # Sheaf consistency check (runs after edges exist)
-            # Cap edge check to prevent O(N^2) hang on large graphs
-            if (self._sheaf_checker
-                    and fact.embedding
-                    and fact.canonical_entities):
-                from superlocalmemory.storage.models import EdgeType, GraphEdge
-                try:
-                    edges_for_fact = self._db.get_edges_for_node(
-                        fact.fact_id, self._profile_id,
-                    )
-                    # Only run sheaf if edge count is manageable
-                    # At 18K+ edges, the coboundary computation becomes O(N*dim^2)
-                    if len(edges_for_fact) < self._config.math.sheaf_max_edges_per_check:
-                        contradictions = self._sheaf_checker.check_consistency(
-                            fact, self._profile_id,
-                        )
-                        for c in contradictions:
-                            if c.severity > 0.45:
-                                edge = GraphEdge(
-                                    profile_id=self._profile_id,
-                                    source_id=fact.fact_id,
-                                    target_id=c.fact_id_b,
-                                    edge_type=EdgeType.SUPERSEDES,
-                                    weight=c.severity,
-                                )
-                                self._db.store_edge(edge)
-                except Exception as exc:
-                    logger.debug("Sheaf check skipped: %s", exc)
-
-            if self._observation_builder:
-                for eid in fact.canonical_entities:
-                    self._observation_builder.update_profile(eid, fact, self._profile_id)
-
-            # Increment fact_count for each linked canonical entity
-            for eid in fact.canonical_entities:
-                try:
-                    self._db.increment_entity_fact_count(eid)
-                except Exception:
-                    pass  # Non-critical — entity may have been deleted
-            if self._scene_builder:
-                self._scene_builder.assign_to_scene(fact, self._profile_id)
-
-            # Populate temporal_events for temporal retrieval
-            has_dates = (fact.observation_date or fact.referenced_date
-                         or fact.interval_start)
-            if fact.canonical_entities and has_dates:
-                from superlocalmemory.storage.models import TemporalEvent
-                for eid in fact.canonical_entities:
-                    event = TemporalEvent(
-                        profile_id=self._profile_id, entity_id=eid,
-                        fact_id=fact.fact_id,
-                        observation_date=fact.observation_date,
-                        referenced_date=fact.referenced_date,
-                        interval_start=fact.interval_start,
-                        interval_end=fact.interval_end,
-                        description=fact.content[:200],
-                    )
-                    self._db.store_temporal_event(event)
-
-            # Foresight: extract time-bounded predictions
-            try:
-                from superlocalmemory.encoding.foresight import extract_foresight_signals
-                from superlocalmemory.storage.models import TemporalEvent as _TE
-                foresight_signals = extract_foresight_signals(fact)
-                for sig in foresight_signals:
-                    f_event = _TE(
-                        profile_id=self._profile_id,
-                        entity_id=sig.get("entity_id", ""),
-                        fact_id=fact.fact_id,
-                        interval_start=sig.get("start_time"),
-                        interval_end=sig.get("end_time"),
-                        description=sig.get("description", ""),
-                    )
-                    self._db.store_temporal_event(f_event)
-            except Exception as exc:
-                logger.debug("Foresight extraction: %s", exc)
-
-            # Persist BM25 tokens at ingestion
-            bm25 = getattr(self._retrieval_engine, '_bm25', None) if self._retrieval_engine else None
-            if bm25:
-                bm25.add(fact.fact_id, fact.content, self._profile_id)
-
-            # Record provenance for data lineage (EU AI Act Art. 10)
-            if self._provenance:
-                try:
-                    self._provenance.record(
-                        fact_id=fact.fact_id,
-                        profile_id=self._profile_id,
-                        source_type="store",
-                        source_id=session_id,
-                        created_by=speaker or "unknown",
-                    )
-                except Exception:
-                    pass
-
-        logger.info("Stored %d facts (session=%s)", len(stored_ids), session_id)
-
-        # Post-operation hooks (audit, trust signal, event bus)
-        hook_ctx["fact_ids"] = stored_ids
-        hook_ctx["fact_count"] = len(stored_ids)
-        self._hooks.run_post("store", hook_ctx)
-
-        return stored_ids
+    # -- Recall operations --------------------------------------------------
 
     def recall(
         self, query: str, profile_id: str | None = None,
         mode: Mode | None = None, limit: int = 20,
         agent_id: str = "unknown",
     ) -> RecallResponse:
-        """Recall relevant facts for a query.
-
-        Pipeline: retrieval → agentic sufficiency (if configured) → post-recall updates.
-        Agentic sufficiency (sufficiency check): triggers 2-round re-retrieval when
-        initial results are insufficient. Mode C uses LLM judgment; Mode A uses
-        heuristic alias expansion.
-        """
+        """Recall relevant facts for a query."""
         self._ensure_init()
 
-        # Pre-operation hooks
-        hook_ctx = {"operation": "recall", "agent_id": agent_id,
-                     "profile_id": profile_id or self._profile_id, "query_preview": query[:100]}
-        self._hooks.run_pre("recall", hook_ctx)
-
         pid = profile_id or self._profile_id
-        m = mode or self._config.mode
-
-        response = self._retrieval_engine.recall(query, pid, m, limit)
-
-        # Agentic sufficiency verification
-        # Only trigger when: (a) configured rounds > 0, (b) results look weak
-        agentic_rounds = self._config.retrieval.agentic_max_rounds
-        if agentic_rounds > 0 and response.results:
-            max_score = max((r.score for r in response.results), default=0.0)
-            should_trigger = (
-                max_score < self._config.retrieval.agentic_confidence_threshold
-                or response.query_type == "multi_hop"
-                or len(response.results) < 3
-            )
-            if should_trigger:
-                try:
-                    from superlocalmemory.retrieval.agentic import AgenticRetriever
-                    agentic = AgenticRetriever(
-                        confidence_threshold=self._config.retrieval.agentic_confidence_threshold,
-                        db=self._db,
-                    )
-                    enhanced_facts = agentic.retrieve(
-                        query=query, profile_id=pid,
-                        retrieval_engine=self._retrieval_engine,
-                        llm=self._llm,
-                        top_k=limit,
-                        query_type=response.query_type,
-                    )
-                    # Replace response results with enhanced facts if we got more
-                    if len(enhanced_facts) > len(response.results):
-                        from superlocalmemory.storage.models import RetrievalResult
-                        enhanced_results = []
-                        for i, f in enumerate(enhanced_facts):
-                            # Look up real trust score for agentic results
-                            fact_trust = 0.5
-                            if self._trust_scorer:
-                                try:
-                                    fact_trust = self._trust_scorer.get_fact_trust(
-                                        f.fact_id, pid,
-                                    )
-                                except Exception:
-                                    pass
-                            enhanced_results.append(RetrievalResult(
-                                fact=f, score=1.0 / (i + 1),
-                                channel_scores={"agentic": 1.0},
-                                confidence=f.confidence,
-                                evidence_chain=["agentic_round_2"],
-                                trust_score=fact_trust,
-                            ))
-                        response = RecallResponse(
-                            query=query, mode=m, results=enhanced_results[:limit],
-                            query_type=response.query_type,
-                            channel_weights=response.channel_weights,
-                            total_candidates=response.total_candidates + len(enhanced_facts),
-                            retrieval_time_ms=response.retrieval_time_ms,
-                        )
-                except Exception as exc:
-                    logger.debug("Agentic sufficiency skipped: %s", exc)
-
-        # Adaptive re-ranking (V3.1 Active Memory)
-        # Phase 1 (< 50 signals): no change (cross-encoder order preserved)
-        # Phase 2 (50+): heuristic boosts (recency, access, trust)
-        # Phase 3 (200+): LightGBM ML ranking
-        try:
-            response = self._apply_adaptive_ranking(response, query, pid)
-        except Exception as exc:
-            logger.debug("Adaptive ranking skipped: %s", exc)
-
-        # Reconsolidation: access updates trust + count (neuroscience principle)
-        if self._trust_scorer:
-            for r in response.results:
-                self._trust_scorer.update_on_access("fact", r.fact.fact_id, pid)
-
-        # Fisher Bayesian update on recall
-        q_emb = self._embedder.embed(query) if self._embedder else None
-        q_var_arr = None
-        if self._embedder and q_emb:
-            _, q_var_list = self._embedder.compute_fisher_params(q_emb)
-            import numpy as _np
-            q_var_arr = _np.array(q_var_list, dtype=_np.float64)
-
-        for r in response.results:
-            updates: dict[str, object] = {
-                "access_count": r.fact.access_count + 1,
-            }
-            # Bayesian variance narrowing after 3+ accesses
-            if (q_var_arr is not None
-                    and r.fact.fisher_variance
-                    and len(r.fact.fisher_variance) == len(q_var_arr)
-                    and r.fact.access_count >= 3):
-                import numpy as _np
-                f_var = _np.array(r.fact.fisher_variance, dtype=_np.float64)
-                # Conjugate Gaussian update: 1/new_var = 1/f_var + 1/q_var
-                new_var = 1.0 / (1.0 / _np.maximum(f_var, 0.05) + 1.0 / _np.maximum(q_var_arr, 0.05))
-                new_var = _np.clip(new_var, 0.05, 2.0)
-                updates["fisher_variance"] = new_var.tolist()
-
-            self._db.update_fact(r.fact.fact_id, updates)
-
-        # Post-operation hooks (audit, trust signal, learning)
-        hook_ctx["result_count"] = len(response.results)
-        hook_ctx["query_type"] = response.query_type
-        self._hooks.run_post("recall", hook_ctx)
-
-        return response
 
-    def store_fact_direct(self, fact: AtomicFact) -> str:
-        """Store a pre-built fact with full enrichment.
+        from superlocalmemory.core.recall_pipeline import run_recall
+        return run_recall(
+            query, pid, mode=mode, limit=limit, agent_id=agent_id,
+            config=self._config,
+            retrieval_engine=self._retrieval_engine,
+            trust_scorer=self._trust_scorer,
+            embedder=self._embedder,
+            db=self._db, llm=self._llm,
+            hooks=self._hooks,
+            access_log=self._access_log,
+            auto_linker=self._auto_linker,
+        )
 
-        Ensures embedding, Fisher params, canonical entities, BM25 tokens,
-        and graph edges are all populated — even for auxiliary data.
-        Creates a parent memory record to satisfy FK constraint.
-        """
-        self._ensure_init()
+    # -- Session operations -------------------------------------------------
 
-        # Create parent memory record (FK: atomic_facts.memory_id → memories.memory_id)
-        if not fact.memory_id:
-            from superlocalmemory.storage.models import _new_id
-            record = MemoryRecord(
-                profile_id=self._profile_id,
-                content=fact.content[:500],
-                session_id=fact.session_id,
-            )
-            self._db.store_memory(record)
-            fact.memory_id = record.memory_id
-
-        if not fact.embedding and self._embedder:
-            fact.embedding = self._embedder.embed(fact.content)
-            if fact.embedding:
-                fact.fisher_mean, fact.fisher_variance = (
-                    self._embedder.compute_fisher_params(fact.embedding)
-                )
-        if self._entity_resolver and fact.entities:
-            canonical = self._entity_resolver.resolve(
-                fact.entities, self._profile_id,
-            )
-            fact.canonical_entities = list(canonical.values())
-        self._db.store_fact(fact)
-        if fact.embedding and self._ann_index:
-            self._ann_index.add(fact.fact_id, fact.embedding)
-        if self._graph_builder:
-            self._graph_builder.build_edges(fact, self._profile_id)
-        # BM25 indexing
-        bm25 = getattr(self._retrieval_engine, '_bm25', None) if self._retrieval_engine else None
-        if bm25:
-            bm25.add(fact.fact_id, fact.content, self._profile_id)
-        return fact.fact_id
-
-    def create_speaker_entities(self, speaker_a: str, speaker_b: str) -> None:
+    def create_speaker_entities(
+        self, speaker_a: str, speaker_b: str,
+    ) -> None:
         """Pre-create canonical entities for conversation speakers."""
         self._ensure_init()
         if self._entity_resolver:
@@ -558,48 +292,15 @@ class MemoryEngine:
             )
 
     def close_session(self, session_id: str) -> int:
-        """Create session-level temporal summary for session-level retrieval.
-
-        Aggregates facts from a completed session into temporal_events
-        with session scope. Enables temporal queries like "What happened
-        in session 3?"
-
-        Returns number of session summary events created.
-        """
+        """Create session-level temporal summary."""
         self._ensure_init()
-        from superlocalmemory.storage.models import TemporalEvent
-
-        facts = self._db.get_all_facts(self._profile_id)
-        session_facts = [f for f in facts if f.session_id == session_id]
-        if not session_facts:
-            return 0
-
-        # Group by entity for session-level summaries
-        entity_facts: dict[str, list[AtomicFact]] = {}
-        for f in session_facts:
-            for eid in f.canonical_entities:
-                entity_facts.setdefault(eid, []).append(f)
-
-        count = 0
-        session_date = session_facts[0].observation_date or ""
-        for eid, efacts in entity_facts.items():
-            summary_parts = [f.content[:80] for f in efacts[:5]]
-            summary = f"Session {session_id}: " + "; ".join(summary_parts)
-            event = TemporalEvent(
-                profile_id=self._profile_id,
-                entity_id=eid,
-                fact_id=efacts[0].fact_id,
-                observation_date=session_date,
-                description=summary[:500],
-            )
-            self._db.store_temporal_event(event)
-            count += 1
 
-        logger.info(
-            "Session %s closed: %d summary events for %d facts",
-            session_id, count, len(session_facts),
+        from superlocalmemory.core.store_pipeline import run_close_session
+        return run_close_session(
+            session_id, self._profile_id, db=self._db,
         )
-        return count
+
+    # -- Lifecycle ----------------------------------------------------------
 
     def close(self) -> None:
         self._initialized = False
@@ -617,219 +318,8 @@ class MemoryEngine:
         self._ensure_init()
         return self._db.get_fact_count(self._profile_id)
 
-    # -- Internal ----------------------------------------------------------
+    # -- Internal -----------------------------------------------------------
 
     def _ensure_init(self) -> None:
         if not self._initialized:
             self.initialize()
-
-    def _apply_adaptive_ranking(self, response, query: str, pid: str):
-        """Apply adaptive re-ranking if enough learning signals exist.
-
-        Phase 1 (< 50 signals): returns response unchanged (backward compat).
-        Phase 2 (50+): heuristic boosts from recency, access count, trust.
-        Phase 3 (200+): LightGBM ML-based reranking.
-        """
-        from superlocalmemory.learning.feedback import FeedbackCollector
-        from pathlib import Path
-
-        learning_db = Path.home() / ".superlocalmemory" / "learning.db"
-        if not learning_db.exists():
-            return response
-
-        collector = FeedbackCollector(learning_db)
-        signal_count = collector.get_feedback_count(pid)
-
-        if signal_count < 50:
-            return response  # Phase 1: no change
-
-        from superlocalmemory.learning.ranker import AdaptiveRanker
-        ranker = AdaptiveRanker(signal_count=signal_count)
-
-        result_dicts = []
-        for r in response.results:
-            result_dicts.append({
-                "score": r.score,
-                "cross_encoder_score": r.score,
-                "trust_score": r.trust_score,
-                "channel_scores": r.channel_scores or {},
-                "fact": {
-                    "age_days": 0,
-                    "access_count": r.fact.access_count,
-                },
-                "_original": r,
-            })
-
-        query_context = {"query_type": response.query_type}
-        reranked = ranker.rerank(result_dicts, query_context)
-
-        # Rebuild response with new ordering
-        new_results = [d["_original"] for d in reranked]
-
-        from superlocalmemory.storage.models import RecallResponse
-        return RecallResponse(
-            query=response.query,
-            mode=response.mode,
-            results=new_results,
-            query_type=response.query_type,
-            channel_weights=response.channel_weights,
-            total_candidates=response.total_candidates,
-            retrieval_time_ms=response.retrieval_time_ms,
-        )
-
-    def _init_encoding(self) -> None:
-        from superlocalmemory.encoding.fact_extractor import FactExtractor
-        from superlocalmemory.encoding.entity_resolver import EntityResolver
-        from superlocalmemory.encoding.temporal_parser import TemporalParser
-        from superlocalmemory.encoding.type_router import TypeRouter
-        from superlocalmemory.encoding.graph_builder import GraphBuilder
-        from superlocalmemory.encoding.consolidator import MemoryConsolidator
-        from superlocalmemory.encoding.observation_builder import ObservationBuilder
-        from superlocalmemory.encoding.scene_builder import SceneBuilder
-        from superlocalmemory.encoding.entropy_gate import EntropyGate
-        from superlocalmemory.retrieval.ann_index import ANNIndex
-
-        self._ann_index = ANNIndex(dimension=self._config.embedding.dimension)
-        self._fact_extractor = FactExtractor(
-            config=self._config.encoding, llm=self._llm,
-            embedder=self._embedder, mode=self._config.mode,
-        )
-        self._entity_resolver = EntityResolver(self._db, self._llm)
-        self._temporal_parser = TemporalParser()
-        self._type_router = TypeRouter(
-            mode=self._config.mode, embedder=self._embedder, llm=self._llm,
-        )
-        self._graph_builder = GraphBuilder(self._db, self._ann_index)
-        self._consolidator = MemoryConsolidator(
-            self._db, self._embedder, self._llm, self._config.encoding,
-        )
-        self._observation_builder = ObservationBuilder(self._db)
-        self._scene_builder = SceneBuilder(self._db, self._embedder)
-        self._entropy_gate = EntropyGate(
-            self._embedder, self._config.encoding.entropy_threshold,
-        )
-
-        # Wire Sheaf consistency checker
-        if self._config.math.sheaf_at_encoding:
-            from superlocalmemory.math.sheaf import SheafConsistencyChecker
-            self._sheaf_checker = SheafConsistencyChecker(
-                self._db, self._config.math.sheaf_contradiction_threshold,
-            )
-
-    def _init_retrieval(self) -> None:
-        from superlocalmemory.retrieval.engine import RetrievalEngine
-        from superlocalmemory.retrieval.semantic_channel import SemanticChannel
-        from superlocalmemory.retrieval.bm25_channel import BM25Channel
-        from superlocalmemory.retrieval.entity_channel import EntityGraphChannel
-        from superlocalmemory.retrieval.temporal_channel import TemporalChannel
-        from superlocalmemory.retrieval.reranker import CrossEncoderReranker
-        from superlocalmemory.retrieval.profile_channel import ProfileChannel
-        from superlocalmemory.retrieval.bridge_discovery import BridgeDiscovery
-
-        channels: dict = {
-            "semantic": SemanticChannel(
-                self._db,
-                fisher_temperature=self._config.math.fisher_temperature,
-                embedder=self._embedder,
-                fisher_mode=self._config.math.fisher_mode,
-            ),
-            "bm25": BM25Channel(self._db),
-            "entity_graph": EntityGraphChannel(self._db, self._entity_resolver),
-            "temporal": TemporalChannel(self._db),
-        }
-        reranker = None
-        if self._config.retrieval.use_cross_encoder:
-            reranker = CrossEncoderReranker(self._config.retrieval.cross_encoder_model)
-
-        profile_ch = ProfileChannel(self._db)
-        bridge = BridgeDiscovery(self._db)
-
-        self._retrieval_engine = RetrievalEngine(
-            db=self._db, config=self._config.retrieval, channels=channels,
-            embedder=self._embedder, reranker=reranker,
-            base_weights=self._config.channel_weights,
-            profile_channel=profile_ch,
-            bridge_discovery=bridge,
-            trust_scorer=self._trust_scorer,
-        )
-
-    def _wire_hooks(self) -> None:
-        """Wire trust, compliance, and event bus hooks into engine lifecycle."""
-        # -- Pre-store hooks (synchronous, can reject) --
-        if self._trust_scorer:
-            from superlocalmemory.trust.gate import TrustGate
-            gate = TrustGate(self._trust_scorer)
-            self._hooks.register_pre("store", lambda ctx: gate.check_write(
-                ctx.get("agent_id", "unknown"), ctx.get("profile_id", self._profile_id)))
-            self._hooks.register_pre("delete", lambda ctx: gate.check_delete(
-                ctx.get("agent_id", "unknown"), ctx.get("profile_id", self._profile_id)))
-
-        # -- Post-store hooks (async, never block) --
-        if self._trust_scorer:
-            self._hooks.register_post("store", lambda ctx: self._trust_scorer.record_signal(
-                ctx.get("agent_id", "unknown"), ctx.get("profile_id", self._profile_id), "store_success"))
-            self._hooks.register_post("recall", lambda ctx: self._trust_scorer.record_signal(
-                ctx.get("agent_id", "unknown"), ctx.get("profile_id", self._profile_id), "recall_hit"))
-
-        # -- Burst detection via SignalRecorder --
-        try:
-            from superlocalmemory.trust.signals import SignalRecorder
-            self._signal_recorder = SignalRecorder(self._db)
-            self._hooks.register_post("store", lambda ctx: self._signal_recorder.record(
-                ctx.get("agent_id", "unknown"), ctx.get("profile_id", self._profile_id), "store_success"))
-        except Exception:
-            self._signal_recorder = None
-
-        # -- Tamper-proof audit chain (all operations logged with hash chain) --
-        try:
-            from superlocalmemory.compliance.audit import AuditChain
-            audit_path = self._config.db_path.parent / "audit_chain.db"
-            self._audit_chain = AuditChain(audit_path)
-            for op in ("store", "recall", "delete"):
-                self._hooks.register_post(op, lambda ctx, _op=op: self._audit_chain.log(
-                    operation=_op,
-                    agent_id=ctx.get("agent_id", "unknown"),
-                    profile_id=ctx.get("profile_id", self._profile_id),
-                    content_hash=ctx.get("content_hash", ""),
-                ))
-        except Exception:
-            self._audit_chain = None
-
-    def _enrich_fact(self, fact: AtomicFact, record: MemoryRecord) -> AtomicFact:
-        """Enrich fact with embeddings, entities, temporal, emotional data."""
-        from superlocalmemory.encoding.emotional import tag_emotion, emotional_importance_boost
-        from superlocalmemory.encoding.signal_inference import infer_signal
-
-        embedding = self._embedder.embed(fact.content) if self._embedder else None
-        fisher_mean, fisher_variance = (None, None)
-        if self._embedder and embedding:
-            fisher_mean, fisher_variance = self._embedder.compute_fisher_params(embedding)
-
-        canonical = {}
-        if self._entity_resolver and fact.entities:
-            canonical = self._entity_resolver.resolve(fact.entities, self._profile_id)
-
-        temporal = {}
-        if self._temporal_parser:
-            temporal = self._temporal_parser.extract_dates_from_text(fact.content)
-
-        emotion = tag_emotion(fact.content)
-        signal = infer_signal(fact.content)
-
-        return AtomicFact(
-            fact_id=fact.fact_id, memory_id=record.memory_id,
-            profile_id=self._profile_id, content=fact.content,
-            fact_type=fact.fact_type, entities=fact.entities,
-            canonical_entities=list(canonical.values()),
-            observation_date=fact.observation_date or record.session_date,
-            referenced_date=fact.referenced_date or temporal.get("referenced_date"),
-            interval_start=fact.interval_start or temporal.get("interval_start"),
-            interval_end=fact.interval_end or temporal.get("interval_end"),
-            confidence=fact.confidence,
-            importance=min(1.0, fact.importance + emotional_importance_boost(emotion)),
-            evidence_count=fact.evidence_count,
-            source_turn_ids=fact.source_turn_ids, session_id=record.session_id,
-            embedding=embedding, fisher_mean=fisher_mean, fisher_variance=fisher_variance,
-            emotional_valence=emotion.valence, emotional_arousal=emotion.arousal,
-            signal_type=signal, created_at=fact.created_at,
-        )