superlocalmemory 3.4.0 → 3.4.3

package/src/superlocalmemory/mesh/broker.py

@@ -0,0 +1,344 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the Elastic License 2.0 - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SLM Mesh Broker — core orchestration for P2P agent communication.
+
+Manages peer lifecycle, scheduled cleanup, and event logging.
+All operations use the shared memory.db via SQLite tables with mesh_ prefix.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+import threading
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger("superlocalmemory.mesh")
+
+
+class MeshBroker:
+    """Lightweight mesh broker for SLM's unified daemon.
+
+    Provides peer management, messaging, state, locks, and events.
+    All methods are synchronous (called from FastAPI via run_in_executor
+    or directly for quick operations).
+    """
+
+    def __init__(self, db_path: str | Path):
+        self._db_path = str(db_path)
+        self._started_at = time.monotonic()
+        self._cleanup_thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+
+    def start_cleanup(self) -> None:
+        """Start background cleanup thread for stale peers/messages."""
+        self._cleanup_thread = threading.Thread(
+            target=self._cleanup_loop, daemon=True, name="mesh-cleanup",
+        )
+        self._cleanup_thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+    # -- Connection helper --
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path)
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA busy_timeout=5000")
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    # -- Peers --
+
+    def register_peer(self, session_id: str, summary: str = "",
+                      host: str = "127.0.0.1", port: int = 0) -> dict:
+        conn = self._conn()
+        try:
+            now = datetime.now(timezone.utc).isoformat()
+            # Idempotent: update if same session_id exists
+            existing = conn.execute(
+                "SELECT peer_id FROM mesh_peers WHERE session_id = ?",
+                (session_id,),
+            ).fetchone()
+            if existing:
+                peer_id = existing["peer_id"]
+                conn.execute(
+                    "UPDATE mesh_peers SET summary=?, host=?, port=?, last_heartbeat=?, status='active' "
+                    "WHERE peer_id=?",
+                    (summary, host, port, now, peer_id),
+                )
+            else:
+                peer_id = str(uuid.uuid4())[:12]
+                conn.execute(
+                    "INSERT INTO mesh_peers (peer_id, session_id, summary, status, host, port, registered_at, last_heartbeat) "
+                    "VALUES (?, ?, ?, 'active', ?, ?, ?, ?)",
+                    (peer_id, session_id, summary, host, port, now, now),
+                )
+            self._log_event(conn, "peer_registered", peer_id, {"session_id": session_id})
+            conn.commit()
+            return {"peer_id": peer_id, "ok": True}
+        finally:
+            conn.close()
+
+    def deregister_peer(self, peer_id: str) -> dict:
+        conn = self._conn()
+        try:
+            row = conn.execute("SELECT 1 FROM mesh_peers WHERE peer_id=?", (peer_id,)).fetchone()
+            if not row:
+                return {"ok": False, "error": "peer not found"}
+            conn.execute("DELETE FROM mesh_peers WHERE peer_id=?", (peer_id,))
+            self._log_event(conn, "peer_deregistered", peer_id)
+            conn.commit()
+            return {"ok": True}
+        finally:
+            conn.close()
+
+    def heartbeat(self, peer_id: str) -> dict:
+        conn = self._conn()
+        try:
+            now = datetime.now(timezone.utc).isoformat()
+            cursor = conn.execute(
+                "UPDATE mesh_peers SET last_heartbeat=?, status='active' WHERE peer_id=?",
+                (now, peer_id),
+            )
+            if cursor.rowcount == 0:
+                return {"ok": False, "error": "peer not found"}
+            conn.commit()
+            return {"ok": True}
+        finally:
+            conn.close()
+
+    def update_summary(self, peer_id: str, summary: str) -> dict:
+        conn = self._conn()
+        try:
+            cursor = conn.execute(
+                "UPDATE mesh_peers SET summary=? WHERE peer_id=?",
+                (summary, peer_id),
+            )
+            if cursor.rowcount == 0:
+                return {"ok": False, "error": "peer not found"}
+            conn.commit()
+            return {"ok": True}
+        finally:
+            conn.close()
+
+    def list_peers(self) -> list[dict]:
+        conn = self._conn()
+        try:
+            rows = conn.execute(
+                "SELECT peer_id, session_id, summary, status, host, port, registered_at, last_heartbeat "
+                "FROM mesh_peers ORDER BY last_heartbeat DESC",
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
+    # -- Messages --
+
+    def send_message(self, from_peer: str, to_peer: str, content: str,
+                     msg_type: str = "text") -> dict:
+        conn = self._conn()
+        try:
+            # Verify recipient exists
+            if not conn.execute("SELECT 1 FROM mesh_peers WHERE peer_id=?", (to_peer,)).fetchone():
+                return {"ok": False, "error": "recipient peer not found"}
+            now = datetime.now(timezone.utc).isoformat()
+            cursor = conn.execute(
+                "INSERT INTO mesh_messages (from_peer, to_peer, msg_type, content, read, created_at) "
+                "VALUES (?, ?, ?, ?, 0, ?)",
+                (from_peer, to_peer, msg_type, content, now),
+            )
+            self._log_event(conn, "message_sent", from_peer, {"to": to_peer})
+            conn.commit()
+            return {"ok": True, "id": cursor.lastrowid}
+        finally:
+            conn.close()
+
+    def get_inbox(self, peer_id: str) -> list[dict]:
+        conn = self._conn()
+        try:
+            rows = conn.execute(
+                "SELECT id, from_peer, to_peer, msg_type, content, read, created_at "
+                "FROM mesh_messages WHERE to_peer=? ORDER BY created_at DESC LIMIT 100",
+                (peer_id,),
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
+    def mark_read(self, peer_id: str, message_ids: list[int]) -> dict:
+        conn = self._conn()
+        try:
+            placeholders = ",".join("?" * len(message_ids))
+            conn.execute(
+                f"UPDATE mesh_messages SET read=1 WHERE to_peer=? AND id IN ({placeholders})",
+                [peer_id, *message_ids],
+            )
+            conn.commit()
+            return {"ok": True}
+        finally:
+            conn.close()
+
+    # -- State --
+
+    def get_state(self) -> dict:
+        conn = self._conn()
+        try:
+            rows = conn.execute("SELECT key, value, set_by, updated_at FROM mesh_state").fetchall()
+            return {r["key"]: {"value": r["value"], "set_by": r["set_by"], "updated_at": r["updated_at"]} for r in rows}
+        finally:
+            conn.close()
+
+    def set_state(self, key: str, value: str, set_by: str) -> dict:
+        conn = self._conn()
+        try:
+            now = datetime.now(timezone.utc).isoformat()
+            conn.execute(
+                "INSERT INTO mesh_state (key, value, set_by, updated_at) VALUES (?, ?, ?, ?) "
+                "ON CONFLICT(key) DO UPDATE SET value=excluded.value, set_by=excluded.set_by, updated_at=excluded.updated_at",
+                (key, value, set_by, now),
+            )
+            conn.commit()
+            return {"ok": True}
+        finally:
+            conn.close()
+
+    def get_state_key(self, key: str) -> dict | None:
+        conn = self._conn()
+        try:
+            row = conn.execute(
+                "SELECT key, value, set_by, updated_at FROM mesh_state WHERE key=?", (key,),
+            ).fetchone()
+            return dict(row) if row else None
+        finally:
+            conn.close()
+
+    # -- Locks --
+
+    def lock_action(self, file_path: str, locked_by: str, action: str) -> dict:
+        conn = self._conn()
+        try:
+            now = datetime.now(timezone.utc).isoformat()
+
+            if action == "acquire":
+                existing = conn.execute(
+                    "SELECT locked_by, locked_at FROM mesh_locks WHERE file_path=?",
+                    (file_path,),
+                ).fetchone()
+                if existing and existing["locked_by"] != locked_by:
+                    return {"locked": True, "by": existing["locked_by"], "since": existing["locked_at"]}
+                conn.execute(
+                    "INSERT INTO mesh_locks (file_path, locked_by, locked_at) VALUES (?, ?, ?) "
+                    "ON CONFLICT(file_path) DO UPDATE SET locked_by=excluded.locked_by, locked_at=excluded.locked_at",
+                    (file_path, locked_by, now),
+                )
+                conn.commit()
+                return {"ok": True, "action": "acquired"}
+
+            elif action == "release":
+                conn.execute("DELETE FROM mesh_locks WHERE file_path=? AND locked_by=?",
+                             (file_path, locked_by))
+                conn.commit()
+                return {"ok": True, "action": "released"}
+
+            elif action == "query":
+                row = conn.execute(
+                    "SELECT locked_by, locked_at FROM mesh_locks WHERE file_path=?",
+                    (file_path,),
+                ).fetchone()
+                if row:
+                    return {"locked": True, "by": row["locked_by"], "since": row["locked_at"]}
+                return {"locked": False}
+
+            return {"ok": False, "error": f"unknown action: {action}"}
+        finally:
+            conn.close()
+
+    # -- Events --
+
+    def get_events(self, limit: int = 100) -> list[dict]:
+        conn = self._conn()
+        try:
+            rows = conn.execute(
+                "SELECT id, event_type, payload, emitted_by, created_at "
+                "FROM mesh_events ORDER BY id DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+            return [dict(r) for r in rows]
+        finally:
+            conn.close()
+
+    def _log_event(self, conn: sqlite3.Connection, event_type: str,
+                   emitted_by: str, payload: dict | None = None) -> None:
+        import json as _json
+        now = datetime.now(timezone.utc).isoformat()
+        conn.execute(
+            "INSERT INTO mesh_events (event_type, payload, emitted_by, created_at) VALUES (?, ?, ?, ?)",
+            (event_type, _json.dumps(payload or {}), emitted_by, now),
+        )
+
+    # -- Status --
+
+    def get_status(self) -> dict:
+        conn = self._conn()
+        try:
+            peer_count = conn.execute("SELECT COUNT(*) FROM mesh_peers WHERE status='active'").fetchone()[0]
+            return {
+                "broker_up": True,
+                "peer_count": peer_count,
+                "uptime_s": round(time.monotonic() - self._started_at),
+            }
+        finally:
+            conn.close()
+
+    # -- Cleanup --
+
+    def _cleanup_loop(self) -> None:
+        """Background cleanup: mark stale peers, delete old messages."""
+        while not self._stop_event.is_set():
+            self._stop_event.wait(300)  # Every 5 min
+            if self._stop_event.is_set():
+                break
+            try:
+                self._run_cleanup()
+            except Exception as exc:
+                logger.debug("Mesh cleanup error: %s", exc)
+
+    def _run_cleanup(self) -> None:
+        conn = self._conn()
+        try:
+            now = datetime.now(timezone.utc)
+            # Mark stale peers (no heartbeat for 5 min)
+            conn.execute(
+                "UPDATE mesh_peers SET status='stale' "
+                "WHERE status='active' AND datetime(last_heartbeat) < datetime(?, '-5 minutes')",
+                (now.isoformat(),),
+            )
+            # Delete dead peers (stale > 30 min)
+            conn.execute(
+                "UPDATE mesh_peers SET status='dead' "
+                "WHERE status='stale' AND datetime(last_heartbeat) < datetime(?, '-30 minutes')",
+                (now.isoformat(),),
+            )
+            conn.execute("DELETE FROM mesh_peers WHERE status='dead'")
+            # Delete read messages > 24hr old
+            conn.execute(
+                "DELETE FROM mesh_messages WHERE read=1 AND datetime(created_at) < datetime(?, '-24 hours')",
+                (now.isoformat(),),
+            )
+            # Delete expired locks
+            conn.execute(
+                "DELETE FROM mesh_locks WHERE datetime(expires_at) < datetime(?)",
+                (now.isoformat(),),
+            )
+            conn.commit()
+        finally:
+            conn.close()

package/src/superlocalmemory/retrieval/entity_channel.py

@@ -91,6 +91,7 @@ class EntityGraphChannel:
         entity_resolver: EntityResolver | None = None,
         decay: float = 0.7, activation_threshold: float = 0.05,
         max_hops: int = 4,
+        graph_metrics: dict[str, dict] | None = None,
     ) -> None:
         self._db = db
         self._resolver = entity_resolver
@@ -101,6 +102,9 @@ class EntityGraphChannel:
         self._adj: dict[str, list[tuple[str, float]]] = {}
         self._adj_profile: str = ""  # Track which profile is loaded
         self._adj_edge_count: int = 0  # Track edge count for staleness detection
+        # v3.4.1: Graph intelligence metrics (loaded from fact_importance)
+        self._graph_metrics: dict[str, dict] = graph_metrics or {}
+        self._graph_metrics_profile: str = ""
 
     def _ensure_adjacency(self, profile_id: str) -> None:
         """Load graph adjacency into memory for fast spreading activation.
@@ -133,6 +137,8 @@ class EntityGraphChannel:
         self._adj_edge_count = current_count
         # Also load entity maps (same staleness lifecycle)
         self._load_entity_maps(profile_id)
+        # v3.4.1: Load graph intelligence metrics (P0)
+        self._load_graph_metrics(profile_id)
 
         logger.info(
             "Loaded adjacency cache: %d nodes, %d edges, %d entity mappings for profile %s",
@@ -192,6 +198,37 @@ class EntityGraphChannel:
             len(self._entity_to_facts), len(self._fact_to_entities),
         )
 
+    def _load_graph_metrics(self, profile_id: str) -> None:
+        """Load PageRank, community_id, degree_centrality from fact_importance.
+
+        v3.4.1: Enables graph-enhanced retrieval (P0).
+        Called alongside adjacency loading. Same staleness lifecycle.
+        """
+        if self._graph_metrics_profile == profile_id and self._graph_metrics:
+            return
+        self._graph_metrics = {}
+        self._graph_metrics_profile = profile_id
+        try:
+            rows = self._db.execute(
+                "SELECT fact_id, pagerank_score, community_id, degree_centrality "
+                "FROM fact_importance WHERE profile_id = ?",
+                (profile_id,),
+            )
+            for r in rows:
+                d = dict(r)
+                self._graph_metrics[d["fact_id"]] = {
+                    "pagerank_score": float(d.get("pagerank_score", 0) or 0),
+                    "community_id": d.get("community_id"),
+                    "degree_centrality": float(d.get("degree_centrality", 0) or 0),
+                }
+            logger.info(
+                "Loaded graph metrics: %d facts for profile %s",
+                len(self._graph_metrics), profile_id,
+            )
+        except Exception as exc:
+            logger.debug("Graph metrics load failed (graceful degradation): %s", exc)
+            self._graph_metrics = {}
+
     def invalidate_cache(self) -> None:
         """Clear all caches. Call after adding/removing edges or facts."""
         self._adj.clear()
@@ -199,6 +236,8 @@ class EntityGraphChannel:
         self._adj_edge_count = 0
         self._entity_to_facts = defaultdict(list)
         self._fact_to_entities = defaultdict(list)
+        self._graph_metrics.clear()
+        self._graph_metrics_profile = ""
 
     def search(self, query: str, profile_id: str, top_k: int = 50) -> list[tuple[str, float]]:
         """Search via entity graph with spreading activation.
@@ -242,12 +281,26 @@ class EntityGraphChannel:
             for fid in frontier:
                 if use_cache:
                     neighbors = self._adj.get(fid, ())
-                    for neighbor, _weight in neighbors:
-                        propagated = activation[fid] * self._decay
-                        if propagated >= self._threshold and propagated > activation.get(neighbor, 0.0):
-                            activation[neighbor] = propagated
+                    for neighbor, edge_weight in neighbors:
+                        # v3.4.2: Only apply edge_weight and PageRank bias when
+                        # graph metrics are available. Without metrics, edge_weight
+                        # dampens propagation by ~14% with no compensating boost,
+                        # causing retrieval regression (68.4% vs 70.4% on LoCoMo).
+                        if self._graph_metrics:
+                            weighted = activation[fid] * self._decay * edge_weight
+                            if neighbor in self._graph_metrics:
+                                target_pr = self._graph_metrics[neighbor].get("pagerank_score", 0.0)
+                                pr_boost = min(1.0 + target_pr * 2.0, 2.0)
+                                weighted *= pr_boost
+                        else:
+                            weighted = activation[fid] * self._decay
+                        if weighted >= self._threshold and weighted > activation.get(neighbor, 0.0):
+                            activation[neighbor] = weighted
                             next_frontier.add(neighbor)
                 else:
+                    # NOTE: SQL fallback path does NOT use graph intelligence (P1/P2/P3).
+                    # Graph intelligence is only available on the in-memory cache path.
+                    # This fallback exists for mock/test DBs. See Phase 7 LLD H-01.
                     for edge in self._db.get_edges_for_node(fid, profile_id):
                         neighbor = edge.target_id if edge.source_id == fid else edge.source_id
                         propagated = activation[fid] * self._decay
@@ -282,10 +335,94 @@ class EntityGraphChannel:
             if not frontier:
                 break
 
+        # v3.4.1 P2: Community-aware boosting
+        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
+                    elif fact_comm is not None and fact_comm not in seed_communities:
+                        activation[fid] *= 0.9  # Mild penalty for unrelated communities
+
+        # v3.4.1 P3: Contradiction suppression via graph_edges
+        if use_cache and activation:
+            self._suppress_contradictions(activation, profile_id)
+
+        # v3.4.1: Score normalization to [0, 1]
         results = [(fid, sc) for fid, sc in activation.items() if sc >= self._threshold]
+        if not results:
+            return []
+        max_score = max(sc for _, sc in results)
+        if max_score > 0:
+            results = [(fid, sc / max_score) for fid, sc in results]
         results.sort(key=lambda x: x[1], reverse=True)
         return results[:top_k]
 
+    def _suppress_contradictions(
+        self, activation: dict[str, float], profile_id: str,
+    ) -> None:
+        """P3: Penalize older fact in contradiction pairs, heavy-penalize superseded.
+
+        Uses graph_edges (edge_type CHECK includes 'contradiction', 'supersedes').
+        """
+        candidate_ids = list(activation.keys())
+        if not candidate_ids:
+            return
+        try:
+            placeholders = ",".join("?" * len(candidate_ids))
+            sql = (
+                "SELECT source_id, target_id, edge_type FROM graph_edges "
+                "WHERE profile_id = ? AND edge_type IN ('contradiction', 'supersedes') "
+                "AND (source_id IN (" + placeholders + ") "
+                "OR target_id IN (" + placeholders + "))"
+            )
+            rows = self._db.execute(sql, (profile_id, *candidate_ids, *candidate_ids))
+            edges = [dict(r) for r in rows]
+            if not edges:
+                return
+
+            # Batch load created_at for involved facts
+            involved = set()
+            for e in edges:
+                involved.add(e["source_id"])
+                involved.add(e["target_id"])
+            involved = involved & set(candidate_ids)
+            if not involved:
+                return
+            ph2 = ",".join("?" * len(involved))
+            ts_rows = self._db.execute(
+                "SELECT fact_id, created_at FROM atomic_facts "
+                "WHERE fact_id IN (" + ph2 + ") AND profile_id = ?",
+                (*involved, profile_id),
+            )
+            ts_map = {dict(r)["fact_id"]: dict(r).get("created_at", "") for r in ts_rows}
+
+            for e in edges:
+                src, tgt, etype = e["source_id"], e["target_id"], e["edge_type"]
+                if etype == "supersedes" and src in activation:
+                    activation[src] *= 0.3  # Heavy penalty: this fact was replaced
+                elif etype == "contradiction":
+                    src_ts = ts_map.get(src, "")
+                    tgt_ts = ts_map.get(tgt, "")
+                    if src_ts and tgt_ts:
+                        older = src if src_ts < tgt_ts else tgt
+                        if older in activation:
+                            activation[older] *= 0.5
+        except Exception as exc:
+            logger.debug("Contradiction suppression failed: %s", exc)
+
     def _resolve_entities(self, raw: list[str], profile_id: str) -> list[str]:
         """Resolve raw names to canonical entity IDs."""
         ids: list[str] = []

package/src/superlocalmemory/retrieval/spreading_activation.py

@@ -53,6 +53,9 @@ class SpreadingActivationConfig:
     max_iterations: int = 3      # T: propagation depth
     tau_gate: float = 0.05       # FOK confidence gate (was 0.12)
     enabled: bool = True         # Ships enabled by default
+    # v3.4.1: Graph intelligence integration
+    use_pagerank_bias: bool = False    # Multiply propagation by target PageRank
+    community_boost: float = 0.0       # Boost same-community nodes (0.0 = disabled)
 
 
 # ---------------------------------------------------------------------------
@@ -82,6 +85,11 @@ class SpreadingActivation:
         self._db = db
         self._vector_store = vector_store
         self._config = config or SpreadingActivationConfig()
+        # v3.4.1: Graph intelligence caches (loaded lazily per profile)
+        self._pr_cache: dict[str, float] = {}
+        self._pr_profile: str = ""
+        self._comm_cache: dict[str, int | None] = {}
+        self._comm_profile: str = ""
 
     def search(
         self,
@@ -311,3 +319,40 @@ class SpreadingActivation:
             return len(result) if result else 0
         except Exception:
             return 0
+
+    # ── v3.4.1: Graph Intelligence Helpers ────────────────────────
+
+    def _load_graph_metrics_cache(self, profile_id: str) -> None:
+        """Load PageRank + community data in a single SQL query.
+
+        Called lazily on first _get_pagerank() or _get_community() call.
+        Populates both _pr_cache and _comm_cache.
+        """
+        if self._pr_profile == profile_id and self._pr_cache:
+            return  # Already loaded for this profile
+        self._pr_cache = {}
+        self._pr_profile = profile_id
+        self._comm_cache = {}
+        self._comm_profile = profile_id
+        try:
+            rows = self._db.execute(
+                "SELECT fact_id, pagerank_score, community_id "
+                "FROM fact_importance WHERE profile_id = ?",
+                (profile_id,),
+            )
+            for r in rows:
+                d = dict(r)
+                self._pr_cache[d["fact_id"]] = float(d.get("pagerank_score", 0) or 0)
+                self._comm_cache[d["fact_id"]] = d.get("community_id")
+        except Exception:
+            pass
+
+    def _get_pagerank(self, fact_id: str, profile_id: str) -> float:
+        """Look up PageRank score from fact_importance. Cached per profile."""
+        self._load_graph_metrics_cache(profile_id)
+        return self._pr_cache.get(fact_id, 0.0)
+
+    def _get_community(self, fact_id: str, profile_id: str) -> int | None:
+        """Look up community_id from fact_importance. Shares unified cache."""
+        self._load_graph_metrics_cache(profile_id)
+        return self._comm_cache.get(fact_id)

package/src/superlocalmemory/server/api.py

@@ -176,8 +176,16 @@ def create_app() -> FastAPI:
     application.include_router(ws_router)
     application.include_router(v3_router)
 
+    # v3.4.1: Chat SSE endpoint
+    for _module_name_v341 in ("chat",):
+        try:
+            _mod_v341 = __import__(f"superlocalmemory.server.routes.{_module_name_v341}", fromlist=["router"])
+            application.include_router(_mod_v341.router)
+        except (ImportError, Exception):
+            pass
+
     # Graceful optional routers
-    for _module_name in ("learning", "lifecycle", "behavioral", "compliance"):
+    for _module_name in ("learning", "lifecycle", "behavioral", "compliance", "insights", "timeline"):
         try:
             _mod = __import__(f"superlocalmemory.server.routes.{_module_name}", fromlist=["router"])
             application.include_router(_mod.router)
@@ -228,16 +236,15 @@ def create_app() -> FastAPI:
     return application
 
 
-app = create_app()
-
-
-# ============================================================================
-# Server Startup
-# ============================================================================
+# v3.4.3: Module-level app removed to prevent duplicate MemoryEngine.
+# The unified daemon (server/unified_daemon.py) imports routes from this
+# module via _register_dashboard_routes(). Do NOT create app here.
+# For standalone use: python -m superlocalmemory.server.api
 
 if __name__ == "__main__":
+    app = create_app()
     print("=" * 60)
-    print("SuperLocalMemory V3 - API Server")
+    print("SuperLocalMemory V3 - API Server (standalone mode)")
     print("=" * 60)
     print(f"Database: {DB_PATH}")
     print(f"UI Directory: {UI_DIR}")

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

@@ -25,8 +25,8 @@ try:
     from superlocalmemory.learning.behavioral import BehavioralPatternStore
     from superlocalmemory.learning.outcomes import OutcomeTracker
     BEHAVIORAL_AVAILABLE = True
-except ImportError:
-    logger.info("V3 behavioral engine not available")
+except ImportError as e:
+    logger.warning("V3 behavioral engine import failed: %s", e)
 
 
 @router.get("/api/behavioral/status")
@@ -66,9 +66,13 @@ async def behavioral_status():
         try:
             store = BehavioralPatternStore(db_path)
             patterns = store.get_patterns(profile_id=profile)
-            cross_project_transfers = 0
+            # Count patterns spanning multiple projects
+            cross_project_transfers = len([
+                p for p in patterns
+                if isinstance(p, dict) and p.get("project_count", 1) > 1
+            ])
         except Exception as exc:
-            logger.debug("pattern store: %s", exc)
+            logger.warning("pattern store error: %s", exc)
 
         return {
             "available": True,