superlocalmemory 3.4.0 → 3.4.3

package/src/superlocalmemory/cli/setup_wizard.py

@@ -259,7 +259,7 @@ def run_wizard(auto: bool = False) -> None:
 
     print()
     print("╔══════════════════════════════════════════════════════════╗")
-    print("║  SuperLocalMemory V3 — Setup Wizard                    ║")
+    print("║  SuperLocalMemory V3 — The Unified Brain               ║")
     print("║  by Varun Pratap Bhardwaj / Qualixar                   ║")
     print("╚══════════════════════════════════════════════════════════╝")
     print()
@@ -373,9 +373,9 @@ def run_wizard(auto: bool = False) -> None:
     else:
         print(f"\n  ✓ CodeGraph disabled (enable later in {cg_config_path})")
 
-    # -- Step 4: Download embedding model --
+    # -- Step 4: Download models --
     print()
-    print("─── Step 4/6: Download Embedding Model ───")
+    print("─── Step 4/9: Download Embedding Model ───")
 
     if not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
@@ -385,18 +385,129 @@ def run_wizard(auto: bool = False) -> None:
         if not embed_ok:
             print("  ⚠ Model will download on first use (may take a few minutes)")
 
-    # -- Step 4: Download reranker model --
     print()
-    print("─── Step 5/6: Download Reranker Model ───")
+    print("─── Step 4b/9: Download Reranker Model ───")
 
     if not st_ok:
         print("  ⚠ Skipped (sentence-transformers not installed)")
     else:
         _download_reranker(_RERANKER_MODEL)
 
-    # -- Step 5: Verification --
+    # -- Step 5: Daemon Configuration (v3.4.3) --
+    print()
+    print("─── Step 5/9: Daemon Configuration ───")
+    print()
+    print("  The SLM daemon runs in the background for instant memory access.")
+    print()
+    print("  [1] 24/7 Always-On (recommended — brain never sleeps)")
+    print("  [2] Auto-shutdown after idle (saves RAM when not coding)")
+    print()
+
+    if interactive:
+        daemon_choice = _prompt("  Select daemon mode [1/2] (default: 1): ", "1")
+    else:
+        daemon_choice = "1"
+        print("  Auto-selecting 24/7 mode (non-interactive)")
+
+    if daemon_choice == "2":
+        if interactive:
+            timeout_choice = _prompt("  Idle timeout [30m/1h/2h] (default: 30m): ", "30m")
+        else:
+            timeout_choice = "30m"
+        timeout_map = {"30m": 1800, "1h": 3600, "2h": 7200}
+        config.daemon_idle_timeout = timeout_map.get(timeout_choice, 1800)
+        print(f"\n  ✓ Auto-shutdown after {timeout_choice} idle")
+    else:
+        config.daemon_idle_timeout = 0
+        print("\n  ✓ 24/7 Always-On mode")
+
+    config.save()
+
+    # -- Step 6: Mesh Communication (v3.4.3) --
+    print()
+    print("─── Step 6/9: Mesh Communication ───")
+    print()
+    print("  SLM Mesh enables agent-to-agent P2P communication.")
+    print("  Multiple AI sessions can share knowledge in real-time.")
+    print()
+    print("  [Y] Enable Mesh (recommended)")
+    print("  [N] Disable Mesh")
+    print()
+
+    if interactive:
+        mesh_choice = _prompt("  Enable Mesh? [Y/n] (default: Y): ", "y").lower()
+    else:
+        mesh_choice = "y"
+        print("  Auto-enabling Mesh (non-interactive)")
+
+    config.mesh_enabled = mesh_choice in ("", "y", "yes")
+    config.save()
+    print(f"\n  ✓ Mesh {'enabled' if config.mesh_enabled else 'disabled'}")
+
+    # -- Step 7: Ingestion Adapters (v3.4.3) --
+    print()
+    print("─── Step 7/9: Ingestion Adapters ───")
+    print()
+    print("  These let SLM learn from your email, calendar, and meetings.")
+    print("  All adapters are OFF by default. You can enable them later.")
+    print()
+    print("  Available adapters:")
+    print("    • Gmail Ingestion     — requires Google OAuth setup")
+    print("    • Google Calendar     — shares Gmail credentials")
+    print("    • Meeting Transcripts — watches a folder for .srt/.vtt files")
+    print()
+
+    if interactive:
+        adapter_input = _prompt("  Enable any now? [Enter to skip, or type: gmail,calendar,transcript]: ", "")
+    else:
+        adapter_input = ""
+
+    # Save adapter preferences (actual setup happens via `slm adapters enable X`)
+    adapters_config = {"gmail": False, "calendar": False, "transcript": False}
+    if adapter_input:
+        for name in adapter_input.split(","):
+            name = name.strip().lower()
+            if name in adapters_config:
+                adapters_config[name] = True
+
+    adapters_path = _SLM_HOME / "adapters.json"
+    import json as _json
+    adapters_path.write_text(_json.dumps(
+        {k: {"enabled": v, "tier": "polling"} for k, v in adapters_config.items()},
+        indent=2,
+    ))
+
+    enabled_adapters = [k for k, v in adapters_config.items() if v]
+    if enabled_adapters:
+        print(f"\n  ✓ Enabled: {', '.join(enabled_adapters)}")
+        print("    Run `slm adapters start <name>` to begin ingestion")
+    else:
+        print("\n  ✓ All adapters disabled (enable later: slm adapters enable gmail)")
+
+    # -- Step 8: Entity Compilation (v3.4.3) --
+    print()
+    print("─── Step 8/9: Entity Compilation ───")
+    print()
+    print("  Entity compilation builds knowledge summaries per person,")
+    print("  project, and concept. Runs automatically during consolidation.")
+    print()
+    print("  [Y] Enable entity compilation (recommended)")
+    print("  [N] Disable")
     print()
-    print("─── Step 6/6: Verification ───")
+
+    if interactive:
+        ec_choice = _prompt("  Enable entity compilation? [Y/n] (default: Y): ", "y").lower()
+    else:
+        ec_choice = "y"
+        print("  Auto-enabling entity compilation (non-interactive)")
+
+    config.entity_compilation_enabled = ec_choice in ("", "y", "yes")
+    config.save()
+    print(f"\n  ✓ Entity compilation {'enabled' if config.entity_compilation_enabled else 'disabled'}")
+
+    # -- Step 9: Verification --
+    print()
+    print("─── Step 9/9: Verification ───")
 
     if st_ok:
         verified = _verify_installation()
@@ -410,16 +521,33 @@ def run_wizard(auto: bool = False) -> None:
     print()
     print("╔══════════════════════════════════════════════════════════╗")
     if verified:
-        print("║  ✓ Setup Complete — SuperLocalMemory is ready!         ║")
+        print("║  ✓ Setup Complete — The Unified Brain is ready!        ║")
     else:
         print("║  ✓ Setup Complete — basic config saved                 ║")
         print("║    Models will auto-download on first use              ║")
     print("╚══════════════════════════════════════════════════════════╝")
     print()
+
+    # Summary of choices
+    daemon_mode = "24/7" if config.daemon_idle_timeout == 0 else f"auto-shutdown ({config.daemon_idle_timeout}s)"
+    print(f"  Enabled: Mode {choice.upper()}, Daemon ({daemon_mode})", end="")
+    if config.mesh_enabled:
+        print(", Mesh", end="")
+    if config.entity_compilation_enabled:
+        print(", Entity Compilation", end="")
+    if code_graph_enabled:
+        print(", CodeGraph", end="")
+    print()
+    if enabled_adapters:
+        print(f"  Adapters: {', '.join(enabled_adapters)}")
+    else:
+        print("  Adapters: none (enable via: slm adapters enable gmail)")
+    print()
     print("  Quick start:")
     print('    slm remember "your first memory"')
     print('    slm recall "search query"')
-    print("    slm dashboard")
+    print("    slm dashboard              → http://localhost:8765")
+    print("    slm adapters enable gmail  → start Gmail ingestion")
     print()
     print("  Need help?")
     print("    slm doctor     — diagnose issues")

package/src/superlocalmemory/core/config.py

@@ -153,6 +153,10 @@ class RetrievalConfig:
     temporal_proximity_days: int = 30
 
     # Reranking (V3.3.2: ONNX backend enabled for all modes)
+    # V3.4.2: Tested gte-reranker-modernbert-base (8K context) — REGRESSED
+    # LoCoMo from 68.4% to 64.1%. Reverted to MiniLM-L-12-v2. The 512-token
+    # limit is acceptable because SLM's 6-channel retrieval pre-filters
+    # relevant facts before reranking. See bench-v342-locomo.md.
     use_cross_encoder: bool = True
     cross_encoder_model: str = "cross-encoder/ms-marco-MiniLM-L-12-v2"
     cross_encoder_backend: str = ""  # "" = PyTorch (~500MB stable), "onnx" = ONNX (leaks on ARM64 CoreML)
@@ -577,6 +581,19 @@ class SLMConfig:
         default_factory=ParameterizationConfig,
     )
 
+    # v3.4.3: Daemon configuration
+    daemon_idle_timeout: int = 0       # 0 = 24/7 (no auto-kill). >0 = seconds before auto-kill.
+    daemon_port: int = 8765            # Primary daemon port
+    daemon_legacy_port: int = 8767     # Backward-compat redirect port
+    daemon_enable_legacy_port: bool = True  # Set False to disable 8767 redirect
+
+    # v3.4.3: Entity compilation
+    entity_compilation_enabled: bool = True
+    entity_compilation_retrieval_boost: float = 1.0  # 1.0 = disabled. >1.0 = boost score.
+
+    # v3.4.3: Mesh
+    mesh_enabled: bool = True
+
     def __post_init__(self) -> None:
         if self.db_path is None:
             self.db_path = self.base_dir / DEFAULT_DB_NAME
@@ -629,6 +646,17 @@ class SLMConfig:
                 if k in RetrievalConfig.__dataclass_fields__
             })
 
+        # V3.4.3 config fields (additive — missing keys get dataclass defaults)
+        config.daemon_idle_timeout = data.get("daemon_idle_timeout", 0)
+        config.daemon_port = data.get("daemon_port", 8765)
+        config.daemon_legacy_port = data.get("daemon_legacy_port", 8767)
+        config.daemon_enable_legacy_port = data.get("daemon_enable_legacy_port", True)
+        config.entity_compilation_enabled = data.get("entity_compilation_enabled", True)
+        config.entity_compilation_retrieval_boost = data.get(
+            "entity_compilation_retrieval_boost", 1.0,
+        )
+        config.mesh_enabled = data.get("mesh_enabled", True)
+
         return config
 
     def save(self, config_path: Path | None = None) -> None:

package/src/superlocalmemory/core/consolidation_engine.py

@@ -27,6 +27,7 @@ from __future__ import annotations
 
 import json
 import logging
+import threading
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any
 
@@ -141,7 +142,13 @@ class ConsolidationEngine:
         """Called after each store() in store_pipeline.py.
 
         Increments internal counter.  When counter hits step_count_trigger
-        (default 50), runs lightweight consolidation.
+        (default 50), runs lightweight consolidation AND queues async
+        graph analysis.
+
+        V3.4.2: Graph analysis runs in background thread after every
+        lightweight consolidation trigger. This populates fact_importance
+        (PageRank, communities, bridge scores) so retrieval channels can
+        use graph intelligence without blocking store/recall latency.
 
         Returns True if lightweight consolidation was triggered.
         """
@@ -152,9 +159,39 @@ class ConsolidationEngine:
         if self._store_count >= self._config.step_count_trigger:
             self._store_count = 0
             self.consolidate(profile_id, lightweight=True)
+            # V3.4.2: Queue graph analysis in background (non-blocking)
+            self._queue_graph_analysis(profile_id)
             return True
         return False
 
+    def _queue_graph_analysis(self, profile_id: str) -> None:
+        """Run graph_analyzer.compute_and_store() in a background thread.
+
+        V3.4.2: Populates fact_importance table with PageRank, community_id,
+        degree_centrality, and bridge_score. Next recall() automatically
+        uses updated graph intelligence for entity channel and spreading
+        activation. Takes ~200-800ms, runs on daemon thread, zero impact
+        on store/recall latency.
+        """
+        if self._graph_analyzer is None:
+            return
+        analyzer = self._graph_analyzer
+        pid = profile_id
+
+        def _run() -> None:
+            try:
+                result = analyzer.compute_and_store(pid)
+                logger.info(
+                    "Background graph analysis complete: %d nodes, %d communities",
+                    result.get("node_count", 0),
+                    result.get("community_count", 0),
+                )
+            except Exception as exc:
+                logger.debug("Background graph analysis failed (non-fatal): %s", exc)
+
+        t = threading.Thread(target=_run, daemon=True, name="graph-analysis-bg")
+        t.start()
+
     def get_core_memory(self, profile_id: str) -> dict[str, str]:
         """Load all Core Memory blocks for a profile.
 

package/src/superlocalmemory/core/engine.py

@@ -116,6 +116,15 @@ class MemoryEngine:
 
         self._db = DatabaseManager(self._config.db_path)
         self._db.initialize(schema)
+
+        # V3.4.3: Apply "Unified Brain" schema extensions (mesh, entity compilation, ingestion)
+        # Idempotent — safe to call on every init. Skips if already applied.
+        try:
+            from superlocalmemory.storage.schema_v343 import apply_v343_schema
+            apply_v343_schema(str(self._db.db_path))
+        except Exception as exc:
+            logger.debug("V3.4.3 schema migration: %s", exc)
+
         self._embedder = init_embedder(self._config)
 
         if self._caps.llm_fact_extraction:

package/src/superlocalmemory/core/engine_wiring.py

@@ -364,7 +364,11 @@ def _init_spreading_activation(
             SpreadingActivation,
             SpreadingActivationConfig,
         )
-        sa_config = SpreadingActivationConfig(enabled=True)
+        sa_config = SpreadingActivationConfig(
+            enabled=True,
+            use_pagerank_bias=True,      # v3.4.1: PageRank-weighted propagation
+            community_boost=0.15,        # v3.4.1: 15% boost for same-community nodes
+        )
         return SpreadingActivation(
             db=db, vector_store=vector_store, config=sa_config,
         )

package/src/superlocalmemory/core/graph_analyzer.py

@@ -8,13 +8,19 @@ Reads BOTH graph_edges and association_edges for the full graph picture.
 Stores results in fact_importance table.
 Called during consolidation (Phase 5), not at query time.
 
+v3.4.1: Added Leiden community detection (optional), TF-IDF community labels,
+bridge score detection. Frontend uses Louvain; backend uses Leiden/LP.
+
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 
 from __future__ import annotations
 
+import json
 import logging
+from collections import Counter, defaultdict
+from math import log
 from typing import Any
 
 logger = logging.getLogger(__name__)
@@ -37,7 +43,11 @@ class GraphAnalyzer:
     def compute_and_store(self, profile_id: str) -> dict[str, Any]:
         """Run all analyses and persist to fact_importance.
 
-        Returns summary dict with node_count, community_count, top_5_nodes.
+        v3.4.1: Now uses Leiden (falls back to Label Propagation),
+        generates TF-IDF community labels, computes bridge scores.
+
+        Returns summary dict with node_count, community_count, top_5_nodes,
+        bridge_count, top_bridge_nodes, community_labels.
         """
         try:
             graph = self._build_networkx_graph(profile_id)
@@ -50,22 +60,64 @@ class GraphAnalyzer:
                 }
 
             pagerank = self.compute_pagerank(graph)
-            communities = self.detect_communities(graph)
+            communities = self.detect_communities_leiden(graph, profile_id)
             centrality = self._compute_degree_centrality(graph)
+            bridge_scores = self.compute_bridge_scores(graph)
+            labels = self.compute_community_labels(profile_id, communities)
 
-            # Persist to fact_importance
+            # v3.4.1: Ensure bridge_score column exists (idempotent migration)
+            try:
+                columns = self._db.execute(
+                    "PRAGMA table_info(fact_importance)", (),
+                )
+                has_bridge = any(
+                    dict(c).get("name") == "bridge_score" for c in columns
+                )
+                if not has_bridge:
+                    self._db.execute(
+                        "ALTER TABLE fact_importance "
+                        "ADD COLUMN bridge_score REAL DEFAULT 0.0",
+                        (),
+                    )
+            except Exception:
+                pass
+
+            # Persist to fact_importance (with bridge_score)
             for node_id in graph.nodes():
                 pr_score = pagerank.get(node_id, 0.0)
                 comm_id = communities.get(node_id)
                 deg_cent = centrality.get(node_id, 0.0)
-                self._db.execute(
-                    "INSERT OR REPLACE INTO fact_importance "
-                    "(fact_id, profile_id, pagerank_score, community_id, "
-                    " degree_centrality, computed_at) "
-                    "VALUES (?, ?, ?, ?, ?, datetime('now'))",
-                    (node_id, profile_id, round(pr_score, 6),
-                     comm_id, round(deg_cent, 4)),
-                )
+                br_score = bridge_scores.get(node_id, 0.0)
+                try:
+                    self._db.execute(
+                        "INSERT OR REPLACE INTO fact_importance "
+                        "(fact_id, profile_id, pagerank_score, community_id, "
+                        " degree_centrality, bridge_score, computed_at) "
+                        "VALUES (?, ?, ?, ?, ?, ?, datetime('now'))",
+                        (node_id, profile_id, round(pr_score, 6),
+                         comm_id, round(deg_cent, 4),
+                         round(br_score, 6)),
+                    )
+                except Exception:
+                    # Fallback without bridge_score if column doesn't exist
+                    self._db.execute(
+                        "INSERT OR REPLACE INTO fact_importance "
+                        "(fact_id, profile_id, pagerank_score, community_id, "
+                        " degree_centrality, computed_at) "
+                        "VALUES (?, ?, ?, ?, ?, datetime('now'))",
+                        (node_id, profile_id, round(pr_score, 6),
+                         comm_id, round(deg_cent, 4)),
+                    )
+
+            # v3.4.1: Persist community labels to JSON sidecar
+            try:
+                from pathlib import Path as _Path
+                labels_dir = _Path.home() / ".superlocalmemory"
+                labels_dir.mkdir(parents=True, exist_ok=True)
+                labels_path = labels_dir / f"{profile_id}_community_labels.json"
+                labels_path.write_text(json.dumps(labels, indent=2))
+            except Exception:
+                pass
 
             top_5 = sorted(
                 pagerank.items(), key=lambda x: x[1], reverse=True,
@@ -74,6 +126,20 @@ class GraphAnalyzer:
                 set(c for c in communities.values() if c is not None),
             )
 
+            bridge_count = len(
+                [s for s in bridge_scores.values() if s > 0.1],
+            )
+            top_bridges = sorted(
+                bridge_scores.items(), key=lambda x: -x[1],
+            )[:5]
+
+            logger.info(
+                "GraphAnalyzer: %d nodes, %d communities, %d bridges, "
+                "labels=%s",
+                graph.number_of_nodes(), unique_communities,
+                bridge_count, labels,
+            )
+
             return {
                 "node_count": graph.number_of_nodes(),
                 "edge_count": graph.number_of_edges(),
@@ -81,6 +147,11 @@ class GraphAnalyzer:
                 "top_5_nodes": [
                     (nid, round(score, 4)) for nid, score in top_5
                 ],
+                "bridge_count": bridge_count,
+                "top_bridge_nodes": [
+                    (nid, round(s, 4)) for nid, s in top_bridges
+                ],
+                "community_labels": labels,
             }
         except Exception as exc:
             logger.debug("GraphAnalyzer.compute_and_store failed: %s", exc)
@@ -140,6 +211,177 @@ class GraphAnalyzer:
                 result[node] = comm_id
         return result
 
+    # ── v3.4.1: Leiden Community Detection ────────────────────────
+
+    def detect_communities_leiden(
+        self,
+        graph: Any = None,
+        profile_id: str = "",
+        resolution: float = 1.0,
+    ) -> dict[str, int]:
+        """Leiden community detection (higher quality than Label Propagation).
+
+        Falls back to detect_communities() (Label Propagation) if
+        leidenalg or igraph are not installed.
+        """
+        if graph is None:
+            graph = self._build_networkx_graph(profile_id)
+        if graph.number_of_nodes() == 0:
+            return {}
+
+        try:
+            import leidenalg
+            import igraph
+        except ImportError:
+            logger.info(
+                "leidenalg not installed, using Label Propagation fallback",
+            )
+            return self.detect_communities(graph, profile_id)
+
+        # Convert DiGraph -> undirected -> igraph
+        undirected = graph.to_undirected()
+        node_list = list(undirected.nodes())
+        node_index = {n: i for i, n in enumerate(node_list)}
+
+        ig = igraph.Graph(n=len(node_list), directed=False)
+        edges = []
+        weights = []
+        for u, v in undirected.edges():
+            if u in node_index and v in node_index:
+                edges.append((node_index[u], node_index[v]))
+                weights.append(undirected[u][v].get("weight", 1.0))
+
+        ig.add_edges(edges)
+        ig.es["weight"] = weights
+        ig.simplify(combine_edges={"weight": "max"})
+
+        partition = leidenalg.find_partition(
+            ig,
+            leidenalg.RBConfigurationVertexPartition,
+            resolution_parameter=resolution,
+            weights="weight",
+        )
+
+        result: dict[str, int] = {}
+        for idx, comm_id in enumerate(partition.membership):
+            result[node_list[idx]] = comm_id
+
+        logger.info(
+            "Leiden detected %d communities (resolution=%.1f)",
+            len(set(result.values())), resolution,
+        )
+        return result
+
+    # ── v3.4.1: TF-IDF Community Labels ─────────────────────────
+
+    def compute_community_labels(
+        self,
+        profile_id: str,
+        communities: dict[str, int],
+    ) -> dict[int, str]:
+        """Generate human-readable labels via TF-IDF on fact content.
+
+        Returns dict mapping community_id to label string.
+        Labels stored in config table for API access.
+        """
+        if not communities:
+            return {}
+
+        # Group fact_ids by community
+        comm_facts: dict[int, list[str]] = defaultdict(list)
+        for fact_id, comm_id in communities.items():
+            comm_facts[comm_id].append(fact_id)
+
+        stopwords = frozenset({
+            "the", "a", "an", "is", "was", "were", "are", "be", "been",
+            "being", "have", "has", "had", "do", "does", "did", "will",
+            "would", "could", "should", "may", "might", "shall", "can",
+            "to", "of", "in", "for", "on", "with", "at", "by", "from",
+            "as", "into", "through", "during", "before", "after", "above",
+            "below", "between", "and", "but", "or", "not", "no", "nor",
+            "so", "yet", "both", "either", "neither", "this", "that",
+            "these", "those", "it", "its", "they", "them", "their",
+            "he", "she", "his", "her", "we", "our", "you", "your",
+            "i", "my", "me",
+        })
+
+        # Fetch content for each community
+        tf_per_comm: dict[int, Counter] = {}
+        for comm_id, fact_ids in comm_facts.items():
+            placeholders = ",".join("?" * len(fact_ids))
+            sql = (
+                "SELECT content FROM atomic_facts WHERE fact_id IN ("
+                + placeholders
+                + ") AND profile_id = ?"
+            )
+            try:
+                rows = self._db.execute(sql, (*fact_ids, profile_id))
+                texts = [dict(r).get("content", "") for r in rows]
+            except Exception:
+                texts = []
+
+            tokens: list[str] = []
+            for text in texts:
+                for word in text.lower().split():
+                    w = word.strip(".,;:!?\"'()[]{}")
+                    if len(w) > 2 and w not in stopwords:
+                        tokens.append(w)
+            tf_per_comm[comm_id] = Counter(tokens)
+
+        num_communities = len(comm_facts)
+        labels: dict[int, str] = {}
+
+        if num_communities == 1:
+            # Single community: use raw term frequency
+            for comm_id, tf in tf_per_comm.items():
+                top = [w for w, _ in tf.most_common(3)]
+                labels[comm_id] = ", ".join(top) if top else f"Community {comm_id}"
+        else:
+            # Compute IDF across communities
+            doc_freq: Counter = Counter()
+            for tf in tf_per_comm.values():
+                for term in tf:
+                    doc_freq[term] += 1
+
+            for comm_id, tf in tf_per_comm.items():
+                scored = []
+                for term, count in tf.items():
+                    idf = log(1 + num_communities / (1 + doc_freq[term]))
+                    scored.append((term, count * idf))
+                scored.sort(key=lambda x: x[1], reverse=True)
+                top = [w for w, _ in scored[:3]]
+                labels[comm_id] = ", ".join(top) if top else f"Community {comm_id}"
+
+        # Store in config table
+        try:
+            key = "community_labels_" + profile_id
+            value = json.dumps(labels)
+            self._db.execute(
+                "INSERT OR REPLACE INTO config (key, value, updated_at) "
+                "VALUES (?, ?, datetime('now'))",
+                (key, value),
+            )
+        except Exception as exc:
+            logger.warning("Failed to store community labels: %s", exc)
+
+        return labels
+
+    # ── v3.4.1: Bridge Score Detection ───────────────────────────
+
+    def compute_bridge_scores(self, graph: Any) -> dict[str, float]:
+        """Identify bridge nodes via betweenness centrality.
+
+        Returns dict mapping node_id to bridge_score (0.0 to 1.0).
+        NOT persisted to DB (no column exists) -- used in summary only.
+        """
+        import networkx as nx
+
+        if graph.number_of_nodes() <= 2:
+            return {}
+        return nx.betweenness_centrality(
+            graph, weight="weight", normalized=True,
+        )
+
     def _compute_degree_centrality(
         self, graph: Any,
     ) -> dict[str, float]: