superlocalmemory 3.4.10 → 3.4.12

package/src/superlocalmemory/mcp/tools_evolution.py

@@ -0,0 +1,338 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SLM v3.4.11 "Skill Evolution" — Evolution MCP Tools.
+
+Three evolution tools:
+  - evolve_skill: Manually trigger evolution for a specific skill
+  - skill_health: Get health metrics for a skill or all skills
+  - skill_lineage: Get evolution lineage for a skill
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Callable
+
+logger = logging.getLogger(__name__)
+
+MEMORY_DB = Path.home() / ".superlocalmemory" / "memory.db"
+
+
+def register_evolution_tools(server, get_engine: Callable) -> None:
+    """Register evolution MCP tools for skill evolution intelligence."""
+
+    @server.tool()
+    async def evolve_skill(
+        skill_name: str,
+        evolution_type: str = "fix",
+        reason: str = "",
+    ) -> dict:
+        """Manually trigger evolution for a specific skill.
+
+        Runs the full evolution pipeline: screen -> confirm -> mutate ->
+        blind verify -> persist. Requires evolution to be enabled in config.
+
+        Args:
+            skill_name: Name of the skill to evolve (e.g. "brainstorming")
+            evolution_type: One of 'fix', 'derived', 'captured'
+            reason: Optional reason / evidence for the evolution
+        """
+        try:
+            # Check if evolution is enabled in config
+            config_path = Path.home() / ".superlocalmemory" / "config.json"
+            evo_cfg = {}
+            if config_path.exists():
+                with open(config_path) as f:
+                    cfg = json.load(f)
+                evo_cfg = cfg.get("evolution", {})
+
+            if not evo_cfg.get("enabled", False):
+                return {
+                    "success": False,
+                    "error": "Evolution is disabled. Enable via: slm config set evolution.enabled true",
+                }
+
+            from superlocalmemory.evolution.skill_evolver import SkillEvolver
+            from superlocalmemory.evolution.types import (
+                EvolutionCandidate,
+                EvolutionType,
+                TriggerType,
+            )
+
+            # Map string to enum
+            type_map = {"fix": EvolutionType.FIX, "derived": EvolutionType.DERIVED, "captured": EvolutionType.CAPTURED}
+            evo_type = type_map.get(evolution_type, EvolutionType.FIX)
+
+            # Build a minimal config for the evolver
+            class _EvoCfg:
+                enabled = True
+                backend = evo_cfg.get("backend", "auto")
+                max_evolutions_per_cycle = evo_cfg.get("max_evolutions_per_cycle", 3)
+
+            class _Cfg:
+                evolution = _EvoCfg()
+
+            db_path = str(MEMORY_DB)
+            evolver = SkillEvolver(db_path, _Cfg())
+
+            # Build candidate from manual trigger
+            evidence = (reason,) if reason else ("Manual evolution trigger via MCP",)
+            candidate = EvolutionCandidate(
+                skill_name=skill_name,
+                evolution_type=evo_type,
+                trigger=TriggerType.HEALTH_CHECK,
+                evidence=evidence,
+                effective_score=0.0,
+                invocation_count=0,
+            )
+
+            # Process through the pipeline
+            engine = get_engine()
+            profile_id = engine.profile_id if engine else "default"
+
+            evolver._store.reset_cycle()
+            outcome = evolver._process_candidate(candidate, profile_id)
+
+            # Fetch the latest record for this skill to return details
+            recent = evolver._store.get_skill_history(skill_name, limit=1)
+            record_info = {}
+            if recent:
+                r = recent[0]
+                record_info = {
+                    "id": r.id,
+                    "status": r.status.value,
+                    "mutation_summary": r.mutation_summary,
+                    "blind_verified": r.blind_verified,
+                    "rejection_reason": r.rejection_reason,
+                }
+
+            return {
+                "success": outcome == "evolved",
+                "outcome": outcome,
+                "skill_name": skill_name,
+                "evolution_type": evolution_type,
+                **record_info,
+            }
+        except Exception as exc:
+            logger.debug("evolve_skill failed: %s", exc)
+            return {"success": False, "error": str(exc)}
+
+    @server.tool()
+    async def skill_health(
+        skill_name: str = "",
+        include_history: bool = False,
+    ) -> dict:
+        """Get health metrics for a skill or all skills.
+
+        Queries behavioral assertions (skill_performance category) and
+        tool_events to compute per-skill invocation counts, effective
+        rates, and status.
+
+        Args:
+            skill_name: Specific skill name (empty = all skills)
+            include_history: Include recent tool event history per skill
+        """
+        try:
+            engine = get_engine()
+            profile_id = engine.profile_id if engine else "default"
+            db_path = str(MEMORY_DB)
+
+            conn = sqlite3.connect(db_path, timeout=10)
+            conn.row_factory = sqlite3.Row
+
+            # Gather per-skill invocation stats from tool_events
+            # Skills are logged as tool_name='Skill' with actual skill name in input_summary
+            if skill_name:
+                # M-LIKE: Escape LIKE wildcards in user-provided skill_name
+                safe_name = skill_name.replace('\\', '\\\\').replace('%', r'\%').replace('_', r'\_')
+                event_query = (
+                    "SELECT input_summary, event_type, created_at, duration_ms "
+                    "FROM tool_events "
+                    "WHERE profile_id = ? AND tool_name = 'Skill' "
+                    "AND input_summary LIKE ? ESCAPE '\\' "
+                    "ORDER BY created_at DESC"
+                )
+                event_rows = conn.execute(event_query, (profile_id, f"%{safe_name}%")).fetchall()
+                # Aggregate
+                invocations = len(event_rows)
+                errors = sum(1 for r in event_rows if dict(r).get("event_type") == "error")
+                last_invoked = dict(event_rows[0]).get("created_at", "") if event_rows else ""
+                effective_rate = ((invocations - errors) / invocations) if invocations > 0 else 0.0
+                skill_entries = [{
+                    "name": skill_name,
+                    "invocations": invocations,
+                    "errors": errors,
+                    "effective_rate": round(effective_rate, 4),
+                    "last_invoked": last_invoked,
+                    "status": "healthy" if effective_rate >= 0.7 else ("degraded" if effective_rate >= 0.4 else "critical"),
+                }]
+                if include_history:
+                    skill_entries[0]["recent_events"] = [
+                        dict(r) for r in event_rows[:10]
+                    ]
+            else:
+                # Get all Skill tool events and extract skill names from input_summary
+                event_query = (
+                    "SELECT input_summary, event_type, created_at "
+                    "FROM tool_events "
+                    "WHERE profile_id = ? AND tool_name = 'Skill' "
+                    "ORDER BY created_at DESC LIMIT 500"
+                )
+                event_rows = conn.execute(event_query, (profile_id,)).fetchall()
+
+                # Parse skill names from input_summary and aggregate
+                from collections import defaultdict
+                skill_stats: dict = defaultdict(lambda: {"invocations": 0, "errors": 0, "last_invoked": ""})
+                for row in event_rows:
+                    r = dict(row)
+                    summary = r.get("input_summary", "")
+                    # Extract skill name from JSON or plain text
+                    sname = ""
+                    try:
+                        parsed = json.loads(summary)
+                        sname = parsed.get("skill", "") or parsed.get("name", "")
+                    except (json.JSONDecodeError, TypeError):
+                        if ":" in summary:
+                            sname = summary.split('"')[1] if '"' in summary else summary.strip()
+                    if not sname:
+                        continue
+                    stats = skill_stats[sname]
+                    stats["invocations"] += 1
+                    if r.get("event_type") == "error":
+                        stats["errors"] += 1
+                    if not stats["last_invoked"]:
+                        stats["last_invoked"] = r.get("created_at", "")
+
+                skill_entries = []
+                for sname, stats in sorted(skill_stats.items(), key=lambda x: x[1]["invocations"], reverse=True)[:50]:
+                    inv = stats["invocations"]
+                    errs = stats["errors"]
+                    eff = ((inv - errs) / inv) if inv > 0 else 0.0
+                    skill_entries.append({
+                        "name": sname,
+                        "invocations": inv,
+                        "errors": errs,
+                        "effective_rate": round(eff, 4),
+                        "last_invoked": stats["last_invoked"],
+                        "status": "healthy" if eff >= 0.7 else ("degraded" if eff >= 0.4 else "critical"),
+                    })
+
+            # Gather skill_performance assertions
+            assertion_query = (
+                "SELECT trigger_condition, action, confidence "
+                "FROM behavioral_assertions "
+                "WHERE profile_id = ? AND category = 'skill_performance'"
+            )
+            assertion_params = [profile_id]
+            if skill_name:
+                safe_assert_name = skill_name.replace('\\', '\\\\').replace('%', r'\%').replace('_', r'\_')
+                assertion_query += " AND trigger_condition LIKE ? ESCAPE '\\'"
+                assertion_params.append(f"%{safe_assert_name}%")
+            assertion_rows = conn.execute(assertion_query, tuple(assertion_params)).fetchall()
+
+            skills = skill_entries
+
+            # Add assertion insights
+            assertion_insights = [
+                {"trigger": dict(a)["trigger_condition"], "action": dict(a)["action"], "confidence": dict(a)["confidence"]}
+                for a in assertion_rows
+            ]
+
+            conn.close()
+
+            return {
+                "skills": skills,
+                "skill_count": len(skills),
+                "assertion_insights": assertion_insights,
+                "profile_id": profile_id,
+            }
+        except Exception as exc:
+            logger.debug("skill_health failed: %s", exc)
+            return {"skills": [], "skill_count": 0, "error": str(exc)}
+
+    @server.tool()
+    async def skill_lineage(
+        skill_name: str = "",
+    ) -> dict:
+        """Get evolution lineage for a skill.
+
+        Queries the skill_evolution_log table and builds a version tree
+        showing how skills evolved from their parents.
+
+        Args:
+            skill_name: Specific skill name (empty = all skills)
+        """
+        try:
+            db_path = str(MEMORY_DB)
+            conn = sqlite3.connect(db_path, timeout=10)
+            conn.row_factory = sqlite3.Row
+
+            if skill_name:
+                rows = conn.execute(
+                    "SELECT id, skill_name, parent_skill_id, evolution_type, "
+                    "trigger_type, generation, status, mutation_summary, "
+                    "blind_verified, created_at, completed_at "
+                    "FROM skill_evolution_log "
+                    "WHERE skill_name = ? OR parent_skill_id = ? "
+                    "ORDER BY created_at ASC",
+                    (skill_name, skill_name),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT id, skill_name, parent_skill_id, evolution_type, "
+                    "trigger_type, generation, status, mutation_summary, "
+                    "blind_verified, created_at, completed_at "
+                    "FROM skill_evolution_log "
+                    "ORDER BY created_at DESC LIMIT 100",
+                ).fetchall()
+
+            conn.close()
+
+            lineage = [
+                {
+                    "id": dict(r)["id"],
+                    "skill_name": dict(r)["skill_name"],
+                    "parent_skill_id": dict(r).get("parent_skill_id", ""),
+                    "evolution_type": dict(r)["evolution_type"],
+                    "trigger": dict(r)["trigger_type"],
+                    "generation": dict(r).get("generation", 0),
+                    "status": dict(r)["status"],
+                    "mutation_summary": dict(r).get("mutation_summary", ""),
+                    "blind_verified": bool(dict(r).get("blind_verified", 0)),
+                    "created_at": dict(r).get("created_at", ""),
+                    "completed_at": dict(r).get("completed_at", ""),
+                }
+                for r in rows
+            ]
+
+            # Build tree structure: group by root skill
+            tree: dict = {}
+            for entry in lineage:
+                root = entry.get("parent_skill_id") or entry["skill_name"]
+                if root not in tree:
+                    tree[root] = {"root": root, "evolutions": []}
+                tree[root]["evolutions"].append({
+                    "id": entry["id"],
+                    "skill_name": entry["skill_name"],
+                    "evolution_type": entry["evolution_type"],
+                    "status": entry["status"],
+                    "generation": entry["generation"],
+                    "created_at": entry["created_at"],
+                })
+
+            return {
+                "lineage": lineage,
+                "lineage_count": len(lineage),
+                "tree": tree,
+            }
+        except Exception as exc:
+            logger.debug("skill_lineage failed: %s", exc)
+            return {"lineage": [], "lineage_count": 0, "tree": {}, "error": str(exc)}

package/src/superlocalmemory/retrieval/engine.py

@@ -187,15 +187,43 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Scene expansion: %s", exc)
 
+        # V3.4.11: Entity graph signal enhancement (post-RRF boost)
+        # Instead of competing as independent channel, entity_graph SCORES
+        # the candidates from other channels by graph proximity to query entities.
+        # Research: Microsoft GraphRAG DRIFT, Pistis-RAG cascaded architecture.
+        if (self._entity is not None
+                and "entity_graph" not in set(self._config.disabled_channels)
+                and fused):
+            try:
+                candidate_ids = [fr.fact_id for fr in fused[:100]]
+                eg_scores = self._entity.score_candidates(
+                    query, candidate_ids, profile_id,
+                )
+                if eg_scores:
+                    boosted = []
+                    for fr in fused:
+                        eg_sc = eg_scores.get(fr.fact_id, 0.0)
+                        if eg_sc > 0:
+                            eg_weight = strat.weights.get("entity_graph", 1.0)
+                            boost = 1.0 + eg_sc * eg_weight * 0.3
+                            boosted.append(FusionResult(
+                                fact_id=fr.fact_id,
+                                fused_score=fr.fused_score * boost,
+                                channel_ranks=fr.channel_ranks,
+                                channel_scores={**fr.channel_scores, "entity_graph": eg_sc},
+                            ))
+                        else:
+                            boosted.append(fr)
+                    fused = sorted(boosted, key=lambda r: r.fused_score, reverse=True)
+            except Exception as exc:
+                logger.warning("Entity graph signal enhancement: %s", exc)
+
         # 4. Load facts for rerank pool
         pool = min(len(fused), max(effective_limit * 3, 30))
         top = fused[:pool]
         facts = self._load_facts(top, profile_id)
 
         # V3.3.21: Session diversity for aggregation queries.
-        # Cat 1 (single-hop/aggregation) needs facts from MULTIPLE sessions.
-        # Without diversity enforcement, top-20 may all come from 1-2 sessions,
-        # missing scattered mentions across 19+ sessions.
         if strat.query_type == "aggregation" and facts:
             top = self._enforce_session_diversity(top, facts, min_sessions=3, top_k=20)
 
@@ -212,8 +240,18 @@ class RetrievalEngine:
             ce_alpha = 0.5 if strat.query_type in ("multi_hop", "temporal") else 0.75
             top = self._apply_reranker(query, top, facts, alpha=ce_alpha)
 
+        # V3.4.11: Channel diversity — guarantee entity_graph results appear in
+        # the final output. Applied AFTER reranker so results can't be pushed out.
+        final_top = top[:effective_limit]
+        final_top = self._enforce_channel_diversity(
+            final_top, fused, ch_results, effective_limit,
+        )
+        # Reload facts for any newly injected results
+        if len(final_top) > len(top[:effective_limit]):
+            facts = self._load_facts(final_top, profile_id)
+
         # 6. Build response
-        results = self._build_results(top[:effective_limit], facts, strat)
+        results = self._build_results(final_top, facts, strat)
         ms = (time.monotonic() - t0) * 1000.0
         return RecallResponse(
             query=query, mode=mode, results=results,
@@ -334,6 +372,54 @@ class RetrievalEngine:
         remaining = [fr for fr in rest if fr.fact_id not in promoted_ids]
         return top + promoted + remaining
 
+    # -- Channel diversity enforcement ----------------------------------------
+
+    @staticmethod
+    def _enforce_channel_diversity(
+        top: list,
+        fused: list,
+        ch_results: dict[str, list[tuple[str, float]]],
+        effective_limit: int,
+        min_per_channel: int = 2,
+    ) -> list:
+        """Ensure structure channels (entity_graph) get representation.
+
+        V3.4.11: entity_graph finds valid results but RRF scores them low
+        because they don't overlap with semantic/bm25 results. This interleaves
+        top entity_graph facts into positions 3-4 of the final output instead
+        of appending at the end where they'd never be seen.
+        """
+        structure_channels = ["entity_graph"]
+        top_ids = {fr.fact_id for fr in top}
+
+        promoted = []
+        for ch_name in structure_channels:
+            ch_items = ch_results.get(ch_name, [])
+            if not ch_items:
+                continue
+
+            present = sum(1 for fid, _ in ch_items if fid in top_ids)
+            if present >= min_per_channel:
+                continue
+
+            needed = min_per_channel - present
+            ch_fids = {fid for fid, _ in ch_items}
+            for fr in fused:
+                if fr.fact_id in ch_fids and fr.fact_id not in top_ids:
+                    promoted.append(fr)
+                    top_ids.add(fr.fact_id)
+                    needed -= 1
+                    if needed <= 0:
+                        break
+
+        if not promoted:
+            return top
+
+        # Append as safety net — with proper RRF weights (strategy.py),
+        # entity_graph facts should already rank naturally in the top-k.
+        # This only fires when they're still missing despite weight boost.
+        return list(top) + promoted
+
     # -- Channel execution --------------------------------------------------
 
     def _embed_query(self, query: str) -> list[float] | None:
@@ -369,6 +455,11 @@ class RetrievalEngine:
         if needs_embedding:
             try:
                 q_emb = self._embed_query(query)
+                if q_emb is None:
+                    logger.warning(
+                        "Query embedding returned None — semantic, hopfield, "
+                        "spreading_activation channels will be skipped this recall"
+                    )
             except Exception as exc:
                 logger.warning("Query embedding failed: %s", exc)
 
@@ -388,13 +479,9 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("BM25 channel: %s", exc)
 
-        if self._entity is not None and "entity_graph" not in disabled:
-            try:
-                r = self._entity.search(query, profile_id, top_k=self._config.bm25_top_k)
-                if r:
-                    out["entity_graph"] = r
-            except Exception as exc:
-                logger.warning("Entity channel: %s", exc)
+        # V3.4.12: entity_graph is now a signal enhancer (post-RRF boost),
+        # not an independent channel. Removed from channel execution to avoid
+        # running spreading activation twice. See score_candidates() in engine.recall().
 
         if self._temporal is not None and "temporal" not in disabled:
             try:

package/src/superlocalmemory/retrieval/entity_channel.py

@@ -370,6 +370,124 @@ class EntityGraphChannel:
         results.sort(key=lambda x: x[1], reverse=True)
         return results[:top_k]
 
+    def score_candidates(
+        self,
+        query: str,
+        candidate_fact_ids: list[str],
+        profile_id: str,
+    ) -> dict[str, float]:
+        """Score candidate facts by their entity-graph proximity to query entities.
+
+        V3.4.11 "Signal Enhancer" architecture: instead of returning its own
+        independent set of fact_ids (which get outranked by multi-channel facts
+        in RRF), this method scores EXISTING candidates from semantic/BM25
+        by their graph connectivity to query entities.
+
+        Research basis: Microsoft GraphRAG DRIFT Search, HippoRAG, Pistis-RAG
+        cascaded architecture. Graph signals act as post-retrieval boosters,
+        not independent retrievers. Avoids the "weakest link" phenomenon where
+        non-overlapping result sets cause rank collapse in RRF fusion.
+
+        Args:
+            query: The user's query string.
+            candidate_fact_ids: Fact IDs from semantic/BM25/other channels.
+            profile_id: User profile.
+
+        Returns:
+            Dict mapping fact_id → entity_graph score [0, 1].
+            Facts with no entity connection return 0.
+            Facts directly linked to query entities score ~1.0.
+            Facts 1-hop away score ~0.7 (decay factor).
+        """
+        if not candidate_fact_ids:
+            return {}
+
+        raw_entities = extract_query_entities(query)
+        if not raw_entities:
+            return {}
+
+        canonical_ids = self._resolve_entities(raw_entities, profile_id)
+        if not canonical_ids:
+            return {}
+
+        self._ensure_adjacency(profile_id)
+
+        # Run full spreading activation (same as search())
+        activation: dict[str, float] = defaultdict(float)
+        visited_entities: set[str] = set(canonical_ids)
+        use_cache = bool(self._entity_to_facts)
+
+        for eid in canonical_ids:
+            if use_cache:
+                for fid in self._entity_to_facts.get(eid, ()):
+                    activation[fid] = max(activation[fid], 1.0)
+            else:
+                for fact in self._db.get_facts_by_entity(eid, profile_id):
+                    activation[fact.fact_id] = max(activation[fact.fact_id], 1.0)
+
+        frontier = set(activation.keys())
+        for hop in range(1, self._max_hops):
+            hop_decay = self._decay ** hop
+            if hop_decay < self._threshold:
+                break
+            next_frontier: set[str] = set()
+            for fid in frontier:
+                if use_cache:
+                    for neighbor, edge_weight in self._adj.get(fid, ()):
+                        if self._graph_metrics:
+                            weighted = activation[fid] * self._decay * edge_weight
+                            if neighbor in self._graph_metrics:
+                                pr = self._graph_metrics[neighbor].get("pagerank_score", 0.0)
+                                weighted *= min(1.0 + pr * 2.0, 2.0)
+                        else:
+                            weighted = activation[fid] * self._decay
+                        if weighted >= self._threshold and weighted > activation.get(neighbor, 0.0):
+                            activation[neighbor] = weighted
+                            next_frontier.add(neighbor)
+
+            if use_cache:
+                for fid in frontier:
+                    for eid in self._fact_to_entities.get(fid, ()):
+                        if eid not in visited_entities:
+                            visited_entities.add(eid)
+                            for linked_fid in self._entity_to_facts.get(eid, ()):
+                                if hop_decay > activation.get(linked_fid, 0.0):
+                                    activation[linked_fid] = hop_decay
+                                    next_frontier.add(linked_fid)
+
+            frontier = next_frontier
+            if not frontier:
+                break
+
+        # Community-aware boosting (same as search)
+        if self._graph_metrics and use_cache:
+            from collections import Counter as _Counter
+            seed_communities: _Counter = _Counter()
+            for eid in canonical_ids:
+                for fid in self._entity_to_facts.get(eid, ()):
+                    m = self._graph_metrics.get(fid, {})
+                    comm = m.get("community_id")
+                    if comm is not None:
+                        seed_communities[comm] += 1
+            if seed_communities:
+                total_seeds = sum(seed_communities.values())
+                for fid in list(activation.keys()):
+                    m = self._graph_metrics.get(fid, {})
+                    fact_comm = m.get("community_id")
+                    if fact_comm is not None and fact_comm in seed_communities:
+                        boost = min(1.0 + 0.15 * (seed_communities[fact_comm] / total_seeds), 1.3)
+                        activation[fid] *= boost
+
+        # Extract scores ONLY for the candidate set, normalize to [0, 1]
+        candidate_set = set(candidate_fact_ids)
+        scored = {fid: activation.get(fid, 0.0) for fid in candidate_set}
+
+        max_score = max(scored.values()) if scored else 0
+        if max_score > 0:
+            scored = {fid: sc / max_score for fid, sc in scored.items()}
+
+        return scored
+
     def _suppress_contradictions(
         self, activation: dict[str, float], profile_id: str,
     ) -> None:

package/src/superlocalmemory/retrieval/forgetting_filter.py

@@ -41,9 +41,21 @@ _ZONE_WEIGHTS: dict[str, float] = {
     "forgotten": 0.0,
 }
 
-# Zones where facts are excluded from results
+# V3.4.11: Deep recall weights — includes cold/archive with reduced scores
+_DEEP_ZONE_WEIGHTS: dict[str, float] = {
+    "active": 1.0,
+    "warm": 0.7,
+    "cold": 0.3,
+    "archive": 0.15,
+    "forgotten": 0.05,
+}
+
+# Zones where facts are excluded from results (default recall)
 _EXCLUDED_ZONES: frozenset[str] = frozenset({"archive", "forgotten"})
 
+# Deep recall excludes nothing — every fact is searchable
+_DEEP_EXCLUDED_ZONES: frozenset[str] = frozenset()
+
 
 class ForgettingFilter:
     """Post-retrieval filter that applies Ebbinghaus retention weighting.
@@ -51,11 +63,12 @@ class ForgettingFilter:
     Removes archived/forgotten facts and adjusts scores for other zones.
     """
 
-    __slots__ = ("_db", "_config")
+    __slots__ = ("_db", "_config", "_deep_recall")
 
-    def __init__(self, db: DatabaseManager, config: ForgettingConfig) -> None:
+    def __init__(self, db: DatabaseManager, config: ForgettingConfig, deep_recall: bool = False) -> None:
         self._db = db
         self._config = config
+        self._deep_recall = deep_recall
 
     def filter(
         self,
@@ -112,12 +125,14 @@ class ForgettingFilter:
 
                 zone = ret_data.get("lifecycle_zone", "active")
 
-                if zone in _EXCLUDED_ZONES:
-                    # Archive/forgotten: remove from results
+                # V3.4.11: Deep recall mode includes all tiers
+                excluded = _DEEP_EXCLUDED_ZONES if self._deep_recall else _EXCLUDED_ZONES
+                weights = _DEEP_ZONE_WEIGHTS if self._deep_recall else _ZONE_WEIGHTS
+
+                if zone in excluded:
                     continue
 
-                # Apply weight
-                weight = _ZONE_WEIGHTS.get(zone, 1.0)
+                weight = weights.get(zone, 1.0)
                 new_results.append((fact_id, score * weight))
 
             filtered[channel_name] = new_results