superlocalmemory 3.4.11 → 3.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.11",
+  "version": "3.4.12",
   "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.4.11"
+version = "3.4.12"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/retrieval/engine.py

@@ -187,6 +187,37 @@ 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]
@@ -448,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/server/unified_daemon.py

@@ -587,6 +587,9 @@ def _register_daemon_routes(application: FastAPI) -> None:
                     "score": round(r.score, 4),
                     "fact_type": getattr(r.fact.fact_type, 'value', str(r.fact.fact_type)),
                     "fact_id": r.fact.fact_id,
+                    "channel_scores": {
+                        k: round(v, 4) for k, v in r.channel_scores.items()
+                    } if r.channel_scores else {},
                 }
                 for r in response.results
             ]

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.11
+Version: 3.4.12
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -83,7 +83,7 @@ Dynamic: license-file
 
 <h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf & 17+ AI tools.</em></p>
-<p align="center"><code>v3.4.4 "Neural Glass"</code> — Install once. Every session remembers the last. Automatically.</p>
+<p align="center"><code>v3.4.11</code> — Install once. Every session remembers the last. Automatically.</p>
 <p align="center"><strong>Backed by 3 peer-reviewed research papers</strong> · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -457,15 +457,20 @@ Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`.
 - Auto-learned soft prompts injected into agent context
 - Behavioral pattern detection and outcome tracking
 
-### Skill Evolution (NEW in v3.4.10)
-- **Per-skill performance tracking** — automatically tracks which skills succeed and which fail, across sessions (zero-LLM, always on)
-- **Execution trace analysis** — mines tool usage patterns around skill invocations to determine effectiveness
-- **Skill entities in Entity Explorer** — each skill becomes a browsable entity with performance facts and evolution history
-- **Dedicated Skill Evolution dashboard tab** — overview cards, performance assertions, skill correlations
-- **Behavioral assertions for skill routing** — soft prompts recommend high-performing skills in future sessions
-- **LLM-powered skill evolution** — 3-trigger system (post-session + degradation + health check) with blind verification. **Off by default** — opt-in via `slm config set evolution.enabled true`. Supports Ollama (free, local), Anthropic API, and OpenAI API backends.
-- **ECC integration** — enhanced observation support with [Everything Claude Code](https://github.com/affaan-m/everything-claude-code) via `slm ingest --source ecc`
-- **IDE compatibility:** Skill tracking currently works with Claude Code. The `/api/v3/tool-event` endpoint accepts events from any IDE client — adapters for other IDEs in future releases.
+### Skill Evolution
+- **Per-skill performance tracking** — tracks which skills succeed and fail across sessions (zero-LLM, always on)
+- **Evolution engine** — 3-trigger system with blind verification. Off by default — enable via `slm config set evolution.enabled true`
+- **MCP tools** — `evolve_skill`, `skill_health`, `skill_lineage` for programmatic access
+- **Lineage DAG** — visual evolution history in the dashboard
+- **CLI config** — `slm config get/set` for all evolution settings
+- **Post-session triggers** — automatic analysis on session end via Stop hook
+- **[ECC](https://github.com/affaan-m/everything-claude-code) integration** — optional enhanced observations via `slm ingest --source ecc`
+
+### Tiered Storage & Scaling
+- **4-tier lifecycle** — active, warm, cold, archived with automatic promotion/demotion
+- **Deep recall** — archived facts searchable at reduced weight
+- **Graph pruning** — automatic cleanup of orphan edges, self-loops, duplicates
+- **Fact consolidation** — clusters related facts into consolidated summaries
 
 ### Trust & Security
 - Bayesian Beta-distribution trust scoring (per-agent, per-fact)
@@ -476,9 +481,9 @@ Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`.
 ### Infrastructure
 - 23-tab web dashboard with real-time visualization
 - 17+ IDE integrations (Claude, Cursor, Windsurf, VS Code, JetBrains, Zed, etc.)
-- 35 MCP tools + 7 MCP resources
+- 38 MCP tools + 7 MCP resources
 - Profile isolation (independent memory spaces)
-- 1400+ tests, AGPL v3, cross-platform (Mac/Linux/Windows)
+- 2,900+ tests, AGPL v3, cross-platform (Mac/Linux/Windows)
 - CPU-only — no GPU required
 - Automatic orphaned process cleanup