superlocalmemory 3.3.25 → 3.3.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.3.25",
+  "version": "3.3.26",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.3.25"
+version = "3.3.26"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "Elastic-2.0"}

package/src/superlocalmemory/core/config.py

@@ -259,6 +259,8 @@ class ForgettingConfig:
     learning_rate: float = 1.0      # eta in spaced repetition update
     # Coupling
     forgetting_drift_scale: float = 0.5  # How strongly forgetting affects Langevin drift
+    # Trust-weighted forgetting (Paper 3, Section 5.5)
+    trust_kappa: float = 2.0  # Sensitivity: lambda_eff = lambda * (1 + trust_kappa * (1 - tau))
     # Scheduler
     scheduler_interval_minutes: int = 30  # How often to recompute retentions
     # Immunity

package/src/superlocalmemory/learning/forgetting_scheduler.py

@@ -202,31 +202,69 @@ class ForgettingScheduler:
         - confirmation_count mapped from atomic_facts.evidence_count
         - emotional_salience from atomic_facts.emotional_valence
         """
-        rows = self._db.execute(
-            "SELECT f.fact_id, "
-            "  COALESCE(al.access_count, 0) as access_count, "
-            "  COALESCE(fi.pagerank_score, 0.0) as importance, "
-            "  COALESCE(f.evidence_count, 0) as confirmation_count, "
-            "  f.created_at, "
-            "  COALESCE(r.last_accessed_at, f.created_at) as last_accessed_at, "
-            "  COALESCE(f.emotional_valence, 0.0) as emotional_salience "
-            "FROM atomic_facts f "
-            "LEFT JOIN ("
-            "  SELECT fact_id, COUNT(*) as access_count "
-            "  FROM fact_access_log WHERE profile_id = ? GROUP BY fact_id"
-            ") al ON f.fact_id = al.fact_id "
-            "LEFT JOIN fact_importance fi "
-            "  ON f.fact_id = fi.fact_id AND fi.profile_id = ? "
-            "LEFT JOIN fact_retention r "
-            "  ON f.fact_id = r.fact_id AND r.profile_id = ? "
-            "WHERE f.profile_id = ? "
-            "AND f.fact_id NOT IN ("
-            "  SELECT json_each.value "
-            "  FROM core_memory_blocks, json_each(core_memory_blocks.source_fact_ids) "
-            "  WHERE core_memory_blocks.profile_id = ?"
-            ")",
-            (profile_id, profile_id, profile_id, profile_id, profile_id),
-        )
+        # V3.3.26: Trust-weighted forgetting — look up trust score for
+        # the agent that created each fact. Falls back to 1.0 if trust_scores
+        # table or created_by column is unavailable.
+        trust_available = self._has_trust_tables()
+        if trust_available:
+            sql = (
+                "SELECT f.fact_id, "
+                "  COALESCE(al.access_count, 0) as access_count, "
+                "  COALESCE(fi.pagerank_score, 0.0) as importance, "
+                "  COALESCE(f.evidence_count, 0) as confirmation_count, "
+                "  f.created_at, "
+                "  COALESCE(r.last_accessed_at, f.created_at) as last_accessed_at, "
+                "  COALESCE(f.emotional_valence, 0.0) as emotional_salience, "
+                "  COALESCE(ts.trust_score, 1.0) as trust_score "
+                "FROM atomic_facts f "
+                "LEFT JOIN ("
+                "  SELECT fact_id, COUNT(*) as access_count "
+                "  FROM fact_access_log WHERE profile_id = ? GROUP BY fact_id"
+                ") al ON f.fact_id = al.fact_id "
+                "LEFT JOIN fact_importance fi "
+                "  ON f.fact_id = fi.fact_id AND fi.profile_id = ? "
+                "LEFT JOIN fact_retention r "
+                "  ON f.fact_id = r.fact_id AND r.profile_id = ? "
+                "LEFT JOIN trust_scores ts "
+                "  ON ts.target_id = f.created_by "
+                "  AND ts.target_type = 'agent' "
+                "  AND ts.profile_id = ? "
+                "WHERE f.profile_id = ? "
+                "AND f.fact_id NOT IN ("
+                "  SELECT json_each.value "
+                "  FROM core_memory_blocks, json_each(core_memory_blocks.source_fact_ids) "
+                "  WHERE core_memory_blocks.profile_id = ?"
+                ")"
+            )
+            params = (profile_id,) * 6
+        else:
+            sql = (
+                "SELECT f.fact_id, "
+                "  COALESCE(al.access_count, 0) as access_count, "
+                "  COALESCE(fi.pagerank_score, 0.0) as importance, "
+                "  COALESCE(f.evidence_count, 0) as confirmation_count, "
+                "  f.created_at, "
+                "  COALESCE(r.last_accessed_at, f.created_at) as last_accessed_at, "
+                "  COALESCE(f.emotional_valence, 0.0) as emotional_salience "
+                "FROM atomic_facts f "
+                "LEFT JOIN ("
+                "  SELECT fact_id, COUNT(*) as access_count "
+                "  FROM fact_access_log WHERE profile_id = ? GROUP BY fact_id"
+                ") al ON f.fact_id = al.fact_id "
+                "LEFT JOIN fact_importance fi "
+                "  ON f.fact_id = fi.fact_id AND fi.profile_id = ? "
+                "LEFT JOIN fact_retention r "
+                "  ON f.fact_id = r.fact_id AND r.profile_id = ? "
+                "WHERE f.profile_id = ? "
+                "AND f.fact_id NOT IN ("
+                "  SELECT json_each.value "
+                "  FROM core_memory_blocks, json_each(core_memory_blocks.source_fact_ids) "
+                "  WHERE core_memory_blocks.profile_id = ?"
+                ")"
+            )
+            params = (profile_id,) * 5
+
+        rows = self._db.execute(sql, params)
 
         facts: list[dict] = []
         for row in rows:
@@ -238,6 +276,7 @@ class ForgettingScheduler:
                 "confirmation_count": int(d["confirmation_count"]),
                 "emotional_salience": float(d["emotional_salience"]),
                 "last_accessed_at": str(d["last_accessed_at"]),
+                "trust_score": float(d.get("trust_score", 1.0)),
             })
         return facts
 
@@ -251,6 +290,19 @@ class ForgettingScheduler:
         retention_rows = self._db.batch_get_retention(fact_ids, profile_id)
         return {r["fact_id"]: r["lifecycle_zone"] for r in retention_rows}
 
+    def _has_trust_tables(self) -> bool:
+        """Check if trust_scores table and created_by column exist."""
+        try:
+            self._db.execute(
+                "SELECT 1 FROM trust_scores LIMIT 0", (),
+            )
+            self._db.execute(
+                "SELECT created_by FROM atomic_facts LIMIT 0", (),
+            )
+            return True
+        except Exception:
+            return False
+
     def _soft_delete_with_audit(self, fact_id: str, profile_id: str) -> None:
         """Soft-delete a forgotten fact with compliance audit trail.
 

package/src/superlocalmemory/math/ebbinghaus.py

@@ -78,6 +78,7 @@ class FactRetentionInput(TypedDict):
     confirmation_count: int        # Mapped from atomic_facts.evidence_count
     emotional_salience: float      # Mapped from atomic_facts.emotional_valence
     last_accessed_at: str          # ISO 8601 datetime string
+    trust_score: float             # Source trust in [0, 1]. Default 1.0.
 
 
 # ---------------------------------------------------------------------------
@@ -142,6 +143,47 @@ class EbbinghausCurve:
         # HR-02: Clamp to [0.0, 1.0]
         return max(0.0, min(1.0, r))
 
+    def trust_modulated_retention(
+        self,
+        hours_since_access: float,
+        strength: float,
+        trust_score: float = 1.0,
+    ) -> float:
+        """Compute trust-weighted Ebbinghaus retention.
+
+        lambda_eff = lambda * (1 + kappa * (1 - trust))
+
+        Low-trust memories decay faster. When trust=1.0, identical to
+        standard retention. When trust=0.0, decay rate is (1+kappa)x faster.
+
+        Paper 3, Section 5.5: Trust-Weighted Forgetting.
+
+        Args:
+            hours_since_access: Hours since last access.
+            strength: Memory strength S.
+            trust_score: Source trust in [0, 1]. Default 1.0 (fully trusted).
+
+        Returns:
+            Retention score in [0.0, 1.0].
+        """
+        if hours_since_access < 0:
+            return 1.0
+
+        s = max(self._config.min_strength, strength)
+        tau = max(0.0, min(1.0, trust_score))
+        kappa = self._config.trust_kappa
+
+        # Trust-modulated decay rate
+        lambda_base = 1.0 / s
+        lambda_eff = lambda_base * (1.0 + kappa * (1.0 - tau))
+
+        r = math.exp(-lambda_eff * hours_since_access)
+
+        if math.isnan(r) or math.isinf(r):
+            return 0.0
+
+        return max(0.0, min(1.0, r))
+
     def memory_strength(
         self,
         access_count: int,
@@ -294,7 +336,8 @@ class EbbinghausCurve:
             strength = self.memory_strength(
                 access_count, importance, confirmation_count, emotional_salience,
             )
-            ret = self.retention(hours_since, strength)
+            trust = fact.get("trust_score", 1.0)
+            ret = self.trust_modulated_retention(hours_since, strength, trust)
             zone = self.lifecycle_zone(ret)
 
             results.append({

package/src/superlocalmemory/math/fisher_quantized.py

@@ -145,14 +145,14 @@ class FRQADMetric:
         if bit_width >= 32:
             return np.array(base_variance, dtype=np.float64)
 
-        # V3.3.12: Paper-correct ADDITIVE variance combination (was multiplicative).
-        # sigma²_total = sigma²_obs + sigma²_quant
-        # sigma²_quant = Delta²/12 where Delta = 2/2^b (uniform quantization step)
-        delta = 2.0 / (2 ** bit_width)  # Quantization step size
-        sigma_q_sq = (delta ** 2) / 12.0  # Uniform quantization noise variance
-        sigma_total = np.asarray(base_variance, dtype=np.float64) + sigma_q_sq
-
-        return np.clip(sigma_total, self._config.variance_floor, self._config.variance_ceiling)
+        # V3.3.26: MULTIPLICATIVE variance inflation (Paper 3, Equation 2).
+        # sigma²_eff = sigma²_obs * (32 / bit_width) ^ kappa
+        # When bw=32: scale=1.0 (no change). When bw=4: scale=2.83x (kappa=0.5).
+        # This is MORE novel and MORE aggressive than additive Delta²/12.
+        scale = (32.0 / bit_width) ** self._config.kappa
+        sigma_inflated = np.asarray(base_variance, dtype=np.float64) * scale
+
+        return np.clip(sigma_inflated, self._config.variance_floor, self._config.variance_ceiling)
 
     # ------------------------------------------------------------------
     # Core distance (THE novel contribution)

package/src/superlocalmemory/retrieval/semantic_channel.py

@@ -92,6 +92,8 @@ class SemanticChannel:
         self._fisher_mode = fisher_mode if fisher_mode in ("simplified", "full") else "simplified"
         # Lazily instantiated full metric (avoids import cost when not needed)
         self._full_metric: object | None = None
+        # V3.3.26: Lazily instantiated FRQAD metric for mixed-precision scoring
+        self._frqad_metric: object | None = None
         self._vector_store = vector_store
         # V3.3.19: TurboQuant 3-tier search (stateless, optional)
         self._qas = quantization_aware_search
@@ -276,21 +278,68 @@ class SemanticChannel:
         q_mean: np.ndarray | None,
         q_var: np.ndarray | None,
     ) -> float:
-        """Compute Fisher-Rao similarity using simplified or full metric.
+        """Compute Fisher-Rao similarity using simplified, full, or FRQAD metric.
 
         Simplified (default): Mahalanobis-like distance using only fact variance.
-        Full: Atkinson-Mitchell geodesic via FisherRaoMetric.similarity(),
-              requires both query and fact (mean, variance) pairs.
+        Full: Atkinson-Mitchell geodesic via FisherRaoMetric.similarity().
+        FRQAD: V3.3.26 — quantization-aware distance via FRQADMetric when
+               the fact has a non-32-bit embedding (mixed precision).
 
-        Falls back to simplified if full metric cannot be applied (e.g.
-        missing fisher_mean on the fact, or missing query variance).
+        Falls back to simplified if full/FRQAD cannot be applied.
         """
+        # V3.3.26: FRQAD for mixed-precision facts
+        fact_bw = getattr(fact, "bit_width", 32) or 32
+        if fact_bw < 32 and q_mean is not None and q_var is not None:
+            return self._compute_frqad_sim(
+                q_mean, q_var, 32, f_vec, var_vec, fact_bw, fact,
+            )
+
         if self._fisher_mode == "full":
             return self._compute_full_fisher_sim(
                 q_vec, f_vec, var_vec, fact, q_mean, q_var,
             )
         return _fisher_rao_similarity(q_vec, f_vec, var_vec, self._temperature)
 
+    def _compute_frqad_sim(
+        self,
+        q_mean: np.ndarray,
+        q_var: np.ndarray,
+        q_bw: int,
+        f_mean: np.ndarray,
+        f_var: np.ndarray,
+        f_bw: int,
+        fact: AtomicFact,
+    ) -> float:
+        """FRQAD: quantization-aware Fisher-Rao similarity (Paper 3, C1).
+
+        Uses variance inflation: sigma_eff = sigma * (32/bw)^kappa
+        to penalize lower-precision embeddings on the statistical manifold.
+        """
+        frqad = self._get_frqad_metric()
+        if frqad is None:
+            return _fisher_rao_similarity(q_mean, f_mean, f_var, self._temperature)
+        try:
+            return frqad.similarity(
+                q_mean, q_var, q_bw,
+                f_mean, f_var, f_bw,
+            )
+        except (ValueError, FloatingPointError):
+            logger.debug("FRQAD raised; falling back to simplified Fisher-Rao")
+            return _fisher_rao_similarity(q_mean, f_mean, f_var, self._temperature)
+
+    def _get_frqad_metric(self) -> object | None:
+        """Lazy-load FRQADMetric to avoid import-time cost."""
+        if self._frqad_metric is None:
+            try:
+                from superlocalmemory.math.fisher import FisherRaoMetric
+                from superlocalmemory.math.fisher_quantized import FRQADConfig, FRQADMetric
+                base = FisherRaoMetric(temperature=self._temperature)
+                self._frqad_metric = FRQADMetric(base, FRQADConfig())
+            except Exception:
+                logger.debug("FRQAD metric unavailable; mixed-precision scoring disabled")
+                return None
+        return self._frqad_metric
+
     def _compute_full_fisher_sim(
         self,
         q_vec: np.ndarray,