superlocalmemory 3.2.2 → 3.3.0

package/src/superlocalmemory/retrieval/hopfield_channel.py

@@ -0,0 +1,335 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3
+
+"""SuperLocalMemory V3.3 -- Hopfield Associative Memory (6th Retrieval Channel).
+
+Modern Continuous Hopfield Network retrieval channel based on
+Ramsauer et al. (2020): "Hopfield Networks is All You Need".
+
+The Hopfield channel excels at pattern completion for vague/noisy queries.
+It operates on the same embedding space as the semantic channel but uses
+an energy-based attention mechanism instead of cosine similarity.
+
+Key features:
+  - Full memory matrix path for stores < 10K facts
+  - ANN pre-filter path for stores 10K-100K (VectorStore KNN -> Hopfield refinement)
+  - Skip path for stores > 100K (other 5 channels are sufficient)
+  - TTL-based matrix cache to avoid rebuilding every query
+  - Returns [] on any error (HR-06)
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+License: MIT
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from superlocalmemory.math.hopfield import HopfieldConfig, ModernHopfieldNetwork
+
+if TYPE_CHECKING:
+    from superlocalmemory.retrieval.vector_store import VectorStore
+    from superlocalmemory.storage.database import DatabaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class HopfieldChannel:
+    """6th retrieval channel: Modern Hopfield associative memory.
+
+    Implements the RetrievalChannel protocol::
+
+        def search(query, profile_id, top_k=50) -> list[tuple[str, float]]
+
+    The channel builds an in-memory matrix from all fact embeddings,
+    computes Hopfield attention scores (softmax of scaled dot products),
+    then ranks facts by similarity to the completed pattern.
+
+    Routing logic (per LLD Section 2.2):
+      - n > skip_threshold (100K): return [] immediately
+      - n > prefilter_threshold (10K): ANN pre-filter + Hopfield on subset
+      - n <= prefilter_threshold: full matrix Hopfield
+    """
+
+    def __init__(
+        self,
+        db: Any,
+        vector_store: Any,
+        config: HopfieldConfig | None = None,
+    ) -> None:
+        """Initialize HopfieldChannel.
+
+        Args:
+            db: DatabaseManager with get_all_facts() and get_facts_by_ids().
+            vector_store: VectorStore with search() and count().
+            config: Hopfield configuration. Uses defaults if None.
+        """
+        self._db = db
+        self._vector_store = vector_store
+        self._config = config or HopfieldConfig()
+        self._hopfield = ModernHopfieldNetwork(self._config)
+
+        # Memory matrix cache (per LLD Section 2.2, HR-09)
+        self._cached_matrix: np.ndarray | None = None
+        self._cached_fact_ids: list[str] = []
+        self._cached_profile: str = ""
+        self._cached_count: int = 0
+        self._cache_timestamp: float = 0.0
+
+    # -- Public API (RetrievalChannel protocol) --------------------------------
+
+    def search(
+        self,
+        query: Any,
+        profile_id: str,
+        top_k: int = 50,
+    ) -> list[tuple[str, float]]:
+        """Search for facts using Hopfield associative retrieval.
+
+        Args:
+            query: Query embedding (list[float] or np.ndarray).
+            profile_id: Scope search to this profile.
+            top_k: Maximum results to return.
+
+        Returns:
+            List of (fact_id, score) sorted by score descending.
+            Returns [] on any error (HR-06).
+        """
+        # Step 1: Check enabled
+        if not self._config.enabled:
+            return []
+
+        try:
+            return self._search_inner(query, profile_id, top_k)
+        except Exception as exc:
+            # HR-06: Return [] on any error
+            logger.warning("Hopfield channel error: %s", exc)
+            return []
+
+    # -- Private implementation ------------------------------------------------
+
+    def _search_inner(
+        self,
+        query: Any,
+        profile_id: str,
+        top_k: int,
+    ) -> list[tuple[str, float]]:
+        """Core search logic, separated for clean error handling."""
+        # Step 2: Convert query to numpy
+        q_vec = np.array(query, dtype=np.float32)
+
+        # Step 3: Validate dimension
+        if q_vec.shape != (self._config.dimension,):
+            logger.debug(
+                "Hopfield dimension mismatch: query %s, expected (%d,)",
+                q_vec.shape, self._config.dimension,
+            )
+            return []
+
+        # Step 3b (AUDIT FIX G-MEDIUM-02): Check skip_threshold BEFORE loading matrix
+        total_count = (
+            self._vector_store.count(profile_id)
+            if self._vector_store and getattr(self._vector_store, "available", False)
+            else 0
+        )
+        # Step 3c: Skip for very large stores
+        if total_count > self._config.skip_threshold:
+            logger.debug(
+                "Hopfield skipped: %d facts exceeds skip_threshold %d",
+                total_count, self._config.skip_threshold,
+            )
+            return []
+
+        # Step 4: Get memory matrix
+        memory_matrix, fact_ids = self._get_memory_matrix(profile_id)
+
+        # Step 5: Empty check
+        if memory_matrix is None or len(fact_ids) == 0:
+            return []
+
+        # Step 6/7: Route by size
+        if len(fact_ids) > self._config.prefilter_threshold:
+            return self._search_with_prefilter(
+                q_vec, profile_id, fact_ids, top_k,
+            )
+        return self._search_full_matrix(
+            q_vec, memory_matrix, fact_ids, top_k,
+        )
+
+    def _search_full_matrix(
+        self,
+        query: np.ndarray,
+        memory_matrix: np.ndarray,
+        fact_ids: list[str],
+        top_k: int,
+    ) -> list[tuple[str, float]]:
+        """Full matrix Hopfield retrieval for stores <= prefilter_threshold.
+
+        Algorithm (LLD Section 2.2):
+        1. Compute Hopfield attention weights
+        2. Compute retrieved (completed) pattern via weighted sum
+        3. Normalize retrieved pattern
+        4. Score all stored patterns against the completed pattern
+        5. Return top-K by similarity
+        """
+        # Step 1: Hopfield attention
+        attention = self._hopfield.attention_scores(query, memory_matrix)
+
+        # Step 2: Pattern completion
+        retrieved = memory_matrix.T @ attention  # shape (d,)
+
+        # Step 3: Normalize
+        norm = float(np.linalg.norm(retrieved))
+        if norm > 1e-8:
+            retrieved = retrieved / norm
+
+        # Step 4: Similarity to all patterns
+        similarities = memory_matrix @ retrieved  # shape (n,)
+
+        # Step 5: Top-K selection
+        top_indices = np.argsort(-similarities)[:top_k]
+        results: list[tuple[str, float]] = [
+            (fact_ids[int(i)], float(similarities[i]))
+            for i in top_indices
+            if similarities[i] > 0.0
+        ]
+
+        return results
+
+    def _search_with_prefilter(
+        self,
+        query: np.ndarray,
+        profile_id: str,
+        all_fact_ids: list[str],
+        top_k: int,
+    ) -> list[tuple[str, float]]:
+        """Two-stage retrieval for large stores (>prefilter_threshold facts).
+
+        Stage 1: VectorStore KNN pre-filter to get candidate subset
+        Stage 2: Hopfield refinement on the small candidate set
+
+        Algorithm (LLD Section 2.2):
+        1. Get KNN candidates from VectorStore
+        2. Load candidate facts from DB
+        3. Build sub-matrix from candidate embeddings
+        4. Run full-matrix Hopfield on the sub-matrix
+        """
+        # Stage 1: KNN pre-filter
+        if not self._vector_store or not getattr(self._vector_store, "available", False):
+            # No vector store available; fall back to full matrix
+            # (only reached if matrix was somehow loaded despite no VS)
+            return []
+
+        knn_results = self._vector_store.search(
+            query.tolist(),
+            top_k=self._config.prefilter_candidates,
+            profile_id=profile_id,
+        )
+        if not knn_results:
+            return []
+
+        # Stage 2: Load candidate facts
+        candidate_ids = [fid for fid, _ in knn_results]
+        candidates = self._db.get_facts_by_ids(candidate_ids, profile_id)
+        if not candidates:
+            return []
+
+        # Stage 3: Build sub-matrix
+        sub_embeddings: list[np.ndarray] = []
+        sub_ids: list[str] = []
+        for fact in candidates:
+            emb = getattr(fact, "embedding", None)
+            if emb is not None and len(emb) == self._config.dimension:
+                sub_embeddings.append(np.array(emb, dtype=np.float32))
+                sub_ids.append(fact.fact_id)
+
+        if not sub_embeddings:
+            return []
+
+        sub_matrix = np.array(sub_embeddings, dtype=np.float32)
+
+        # HR-03: L2-normalize sub-matrix rows
+        norms = np.linalg.norm(sub_matrix, axis=1, keepdims=True)
+        norms = np.maximum(norms, 1e-8)
+        sub_matrix = sub_matrix / norms
+
+        # Stage 4: Hopfield on subset
+        return self._search_full_matrix(query, sub_matrix, sub_ids, top_k)
+
+    def _get_memory_matrix(
+        self, profile_id: str,
+    ) -> tuple[np.ndarray | None, list[str]]:
+        """Build or retrieve cached memory matrix X (n x d).
+
+        The matrix is L2-normalized per row (HR-03) and cached
+        with a TTL (HR-09, default 60s).
+
+        Returns:
+            (memory_matrix, fact_ids) or (None, []) if no valid facts.
+        """
+        # Step 1: Check cache validity
+        current_count = (
+            self._vector_store.count(profile_id)
+            if self._vector_store and getattr(self._vector_store, "available", False)
+            else 0
+        )
+
+        if (
+            self._cached_profile == profile_id
+            and self._cached_count == current_count
+            and self._cached_matrix is not None
+            and (time.monotonic() - self._cache_timestamp)
+            < self._config.cache_ttl_seconds
+        ):
+            return (self._cached_matrix, self._cached_fact_ids)
+
+        # Step 2: Load all facts
+        facts = self._db.get_all_facts(profile_id)
+        if not facts:
+            return (None, [])
+
+        # Step 4: Filter facts with valid embeddings
+        valid: list[tuple[str, list[float]]] = []
+        for f in facts:
+            emb = getattr(f, "embedding", None)
+            if emb is not None and len(emb) == self._config.dimension:
+                valid.append((f.fact_id, emb))
+
+        if not valid:
+            return (None, [])
+
+        # Step 6: Build matrix
+        fact_ids = [fid for fid, _ in valid]
+        matrix = np.array(
+            [emb for _, emb in valid], dtype=np.float32,
+        )  # shape (n, d)
+
+        # Step 7: HR-03 — L2 normalize each row
+        norms = np.linalg.norm(matrix, axis=1, keepdims=True)
+        norms = np.maximum(norms, 1e-8)
+        matrix = matrix / norms
+
+        # Step 8: Update cache
+        self._cached_matrix = matrix
+        self._cached_fact_ids = fact_ids
+        self._cached_profile = profile_id
+        self._cached_count = current_count
+        self._cache_timestamp = time.monotonic()
+
+        return (matrix, fact_ids)
+
+    def invalidate_cache(self) -> None:
+        """Clear the memory matrix cache.
+
+        Called after fact insertion/deletion to ensure
+        next search rebuilds with fresh data.
+        """
+        self._cached_matrix = None
+        self._cached_fact_ids = []
+        self._cached_count = 0
+        self._cache_timestamp = 0.0

package/src/superlocalmemory/retrieval/quantization_aware_search.py

@@ -0,0 +1,133 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3
+
+"""Three-tier mixed-precision search.
+
+Merges results from:
+  Tier 1: float32 (VectorStore.search -- exact cosine)
+  Tier 2: int8    (VectorStore.search_int8 -- sqlite-vec native)
+  Tier 3: polar   (QuantizedEmbeddingStore.search -- PolarQuant)
+
+Deduplicates by keeping the highest score per fact_id.
+Applies precision-dependent score penalties:
+  - float32: no penalty (1.0x)
+  - int8:    0.98x
+  - polar:   config.polar_search_penalty (default 0.95x)
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+License: MIT
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from numpy.typing import NDArray
+
+from superlocalmemory.core.config import QuantizationConfig
+
+if TYPE_CHECKING:
+    from superlocalmemory.storage.quantized_store import QuantizedEmbeddingStore
+
+logger = logging.getLogger(__name__)
+
+# Penalty factor for int8 tier (fixed, not configurable)
+_INT8_PENALTY: float = 0.98
+
+
+class QuantizationAwareSearch:
+    """Three-tier mixed-precision embedding search.
+
+    Combines float32 + int8 + polar results, deduplicates,
+    and returns top_k by score descending.
+    """
+
+    __slots__ = ("_vector_store", "_quantized_store", "_config")
+
+    def __init__(
+        self,
+        vector_store,
+        quantized_store: QuantizedEmbeddingStore,
+        config: QuantizationConfig,
+    ) -> None:
+        self._vector_store = vector_store
+        self._quantized_store = quantized_store
+        self._config = config
+
+    def search(
+        self,
+        query_embedding: NDArray,
+        profile_id: str,
+        top_k: int = 50,
+    ) -> list[tuple[str, float]]:
+        """Execute three-tier mixed-precision search.
+
+        Args:
+            query_embedding: Query vector (float32/64).
+            profile_id:      Scope to this profile.
+            top_k:           Max results to return.
+
+        Returns:
+            [(fact_id, score)] sorted by score descending.
+        """
+        # Tier 1: float32 exact search
+        results_f32 = self._search_float32(query_embedding, profile_id, top_k)
+
+        # Tier 2: int8 approximate search
+        results_int8 = self._search_int8(query_embedding, profile_id, top_k)
+
+        # Tier 3: polar quantized search
+        results_polar = self._search_polar(query_embedding, profile_id, top_k)
+
+        # Merge + dedup (keep highest score per fact_id)
+        seen: dict[str, float] = {}
+        for fid, score in results_f32 + results_int8 + results_polar:
+            if fid not in seen or score > seen[fid]:
+                seen[fid] = score
+
+        # Sort by score descending
+        merged = sorted(seen.items(), key=lambda x: x[1], reverse=True)
+        return merged[:top_k]
+
+    # -- Tier helpers (encapsulate error handling) -------------------------
+
+    def _search_float32(
+        self, query: NDArray, profile_id: str, top_k: int,
+    ) -> list[tuple[str, float]]:
+        """Tier 1: float32 exact cosine via VectorStore."""
+        try:
+            return self._vector_store.search(query, profile_id, top_k)
+        except Exception as exc:
+            logger.debug("float32 search failed: %s", exc)
+            return []
+
+    def _search_int8(
+        self, query: NDArray, profile_id: str, top_k: int,
+    ) -> list[tuple[str, float]]:
+        """Tier 2: int8 approximate via VectorStore.search_int8.
+
+        Applies 0.98x penalty to account for int8 quantization error.
+        """
+        try:
+            raw = self._vector_store.search_int8(query, profile_id, top_k)
+            return [(fid, score * _INT8_PENALTY) for fid, score in raw]
+        except Exception as exc:
+            logger.debug("int8 search failed: %s", exc)
+            return []
+
+    def _search_polar(
+        self, query: NDArray, profile_id: str, top_k: int,
+    ) -> list[tuple[str, float]]:
+        """Tier 3: polar quantized via QuantizedEmbeddingStore.
+
+        Applies polar_search_penalty from config.
+        """
+        try:
+            raw = self._quantized_store.search(query, profile_id, top_k)
+            penalty = self._config.polar_search_penalty
+            return [(fid, score * penalty) for fid, score in raw]
+        except Exception as exc:
+            logger.debug("polar search failed: %s", exc)
+            return []

package/src/superlocalmemory/retrieval/spreading_activation.py

@@ -50,7 +50,7 @@ class SpreadingActivationConfig:
     top_m: int = 7               # Lateral inhibition: max active nodes
     max_iterations: int = 3      # T: propagation depth
     tau_gate: float = 0.12       # FOK confidence gate
-    enabled: bool = False        # Feature flag (Rule 12)
+    enabled: bool = True         # Ships enabled by default
 
 
 # ---------------------------------------------------------------------------

package/src/superlocalmemory/retrieval/strategy.py

@@ -16,13 +16,14 @@ import re
 from dataclasses import dataclass, field
 
 STRATEGY_PRESETS: dict[str, dict[str, float]] = {
-    "temporal": {"semantic": 0.8, "bm25": 1.5, "entity_graph": 0.8, "temporal": 2.0, "spreading_activation": 0.5},
-    "multi_hop": {"semantic": 1.0, "bm25": 0.8, "entity_graph": 2.0, "temporal": 0.5, "spreading_activation": 2.0},
-    "aggregation": {"semantic": 1.2, "bm25": 1.5, "entity_graph": 1.0, "temporal": 0.5, "spreading_activation": 0.8},
-    "opinion": {"semantic": 1.8, "bm25": 0.6, "entity_graph": 0.8, "temporal": 0.3, "spreading_activation": 0.5},
-    "factual": {"semantic": 1.2, "bm25": 1.4, "entity_graph": 1.0, "temporal": 0.6, "spreading_activation": 0.8},
-    "entity": {"semantic": 1.0, "bm25": 1.5, "entity_graph": 1.2, "temporal": 0.5, "spreading_activation": 1.0},
+    "temporal": {"semantic": 0.8, "bm25": 1.5, "entity_graph": 0.8, "temporal": 2.0, "spreading_activation": 0.5, "hopfield": 0.5},
+    "multi_hop": {"semantic": 1.0, "bm25": 0.8, "entity_graph": 2.0, "temporal": 0.5, "spreading_activation": 2.0, "hopfield": 0.7},
+    "aggregation": {"semantic": 1.2, "bm25": 1.5, "entity_graph": 1.0, "temporal": 0.5, "spreading_activation": 0.8, "hopfield": 0.6},
+    "opinion": {"semantic": 1.8, "bm25": 0.6, "entity_graph": 0.8, "temporal": 0.3, "spreading_activation": 0.5, "hopfield": 0.5},
+    "factual": {"semantic": 1.2, "bm25": 1.4, "entity_graph": 1.0, "temporal": 0.6, "spreading_activation": 0.8, "hopfield": 0.8},
+    "entity": {"semantic": 1.0, "bm25": 1.5, "entity_graph": 1.2, "temporal": 0.5, "spreading_activation": 1.0, "hopfield": 0.9},
     "general": {},
+    "vague": {"semantic": 0.8, "bm25": 0.5, "entity_graph": 0.6, "temporal": 0.3, "spreading_activation": 1.5, "hopfield": 1.1},
 }
 
 _TEMPORAL_WORDS: frozenset[str] = frozenset({
@@ -48,6 +49,12 @@ _OPINION_WORDS: tuple[str, ...] = (
     "believe", "like about", "dislike", "enjoy", "hate", "love",
 )
 
+_VAGUE_PHRASES: tuple[str, ...] = (
+    "something about", "i think", "maybe", "not sure",
+    "vaguely remember", "partially recall", "sort of",
+    "kind of", "i forgot", "what was that",
+)
+
 
 @dataclass
 class QueryStrategy:
@@ -93,4 +100,7 @@ class QueryStrategyClassifier:
             return "entity"
         if q.startswith(("what ", "where ", "who ", "which ", "how ")):
             return "factual"
+        # Vague/fuzzy recall — Hopfield pattern completion excels here
+        if any(p in q for p in _VAGUE_PHRASES):
+            return "vague"
         return "general"

package/src/superlocalmemory/retrieval/vector_store.py

@@ -32,7 +32,7 @@ class VectorStoreConfig:
     dimension: int = 768
     binary_quantization_threshold: int = 100_000  # L4 fix
     model_name: str = "nomic-embed-text-v1.5"
-    enabled: bool = False  # Rule 12: feature flag, default off
+    enabled: bool = True  # Ships enabled by default
 
 
 class VectorStore:

package/src/superlocalmemory/server/routes/agents.py

@@ -73,15 +73,75 @@ async def get_agent_stats(request: Request):
 
 @router.get("/api/trust/stats")
 async def get_trust_stats(request: Request):
-    """Get trust scoring statistics."""
-    if not TRUST_AVAILABLE:
-        return {"total_signals": 0, "message": "Trust scorer not available"}
+    """Get trust scoring statistics.
+
+    Queries trust_scores and trust_signals tables directly (no engine needed).
+    Falls back to engine._trust_scorer if available.
+    """
     try:
-        engine = getattr(request.app.state, "engine", None)
-        if engine and engine._trust_scorer:
-            scorer = engine._trust_scorer
-            return scorer.get_trust_stats()
-        return {"total_signals": 0, "message": "Trust scorer not initialized"}
+        # Try engine-based scorer first
+        try:
+            engine = getattr(request.app.state, "engine", None)
+            if engine and getattr(engine, "_trust_scorer", None):
+                return engine._trust_scorer.get_trust_stats()
+        except (AttributeError, Exception):
+            pass  # Fall through to direct DB query
+
+        # Direct DB query (dashboard runs without engine subprocess)
+        import sqlite3
+        from .helpers import get_active_profile
+        pid = get_active_profile()
+
+        total_signals = 0
+        avg_trust_score = 0.667
+        by_signal_type = {}
+
+        if DB_PATH.exists():
+            conn = sqlite3.connect(str(DB_PATH))
+            conn.row_factory = sqlite3.Row
+            try:
+                # Count trust signals
+                row = conn.execute(
+                    "SELECT COUNT(*) AS cnt FROM trust_signals "
+                    "WHERE profile_id = ?", (pid,),
+                ).fetchone()
+                total_signals = row["cnt"] if row else 0
+            except sqlite3.OperationalError:
+                pass
+
+            try:
+                # Average trust score
+                row = conn.execute(
+                    "SELECT AVG(trust_score) AS avg_ts FROM trust_scores "
+                    "WHERE profile_id = ?", (pid,),
+                ).fetchone()
+                if row and row["avg_ts"] is not None:
+                    avg_trust_score = round(float(row["avg_ts"]), 3)
+            except sqlite3.OperationalError:
+                pass
+
+            try:
+                # Signal breakdown by type
+                rows = conn.execute(
+                    "SELECT signal_type, COUNT(*) AS cnt "
+                    "FROM trust_signals WHERE profile_id = ? "
+                    "GROUP BY signal_type", (pid,),
+                ).fetchall()
+                by_signal_type = {r["signal_type"]: r["cnt"] for r in rows}
+            except sqlite3.OperationalError:
+                pass
+
+            conn.close()
+
+        # Enforcement status: SLM uses "Silent Collection" by default
+        enforcement = "Silent Collection"
+
+        return {
+            "total_signals": total_signals,
+            "avg_trust_score": avg_trust_score,
+            "enforcement": enforcement,
+            "by_signal_type": by_signal_type,
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Trust stats error: {str(e)}")
 

package/src/superlocalmemory/server/routes/learning.py

@@ -81,13 +81,29 @@ async def learning_status():
 
         # Real signal count from V3.1 learning_feedback table
         signal_count = 0
+        unique_queries = 0
         try:
             from superlocalmemory.learning.feedback import FeedbackCollector
             from pathlib import Path
+            import sqlite3 as _sqlite3
             learning_db = Path.home() / ".superlocalmemory" / "learning.db"
             if learning_db.exists():
                 collector = FeedbackCollector(learning_db)
                 signal_count = collector.get_feedback_count(active_profile)
+                # Count unique queries for the dashboard
+                _conn = _sqlite3.connect(str(learning_db))
+                _conn.row_factory = _sqlite3.Row
+                try:
+                    _row = _conn.execute(
+                        "SELECT COUNT(DISTINCT query_hash) AS cnt "
+                        "FROM learning_feedback WHERE profile_id = ?",
+                        (active_profile,),
+                    ).fetchone()
+                    unique_queries = _row["cnt"] if _row else 0
+                except Exception:
+                    pass
+                finally:
+                    _conn.close()
         except Exception:
             pass
 
@@ -100,13 +116,14 @@ async def learning_status():
             result["ranking_phase"] = "baseline"
 
         # Feedback stats — merge old system + new V3.1 signals
-        stats_dict = {"feedback_count": signal_count, "active_profile": active_profile}
+        stats_dict = {"feedback_count": signal_count, "unique_queries": unique_queries, "active_profile": active_profile}
         feedback = _get_feedback()
         if feedback:
             try:
                 old_stats = feedback.get_feedback_summary(active_profile)
                 if isinstance(old_stats, dict):
                     old_stats["feedback_count"] = signal_count
+                    old_stats["unique_queries"] = unique_queries
                     old_stats["active_profile"] = active_profile
                     stats_dict = old_stats
             except Exception as exc: