superlocalmemory 3.1.0 → 3.1.1

package/README.md

@@ -84,7 +84,7 @@ slm status
 }
 ```
 
-24 MCP tools available. Works with Claude Code, Cursor, Windsurf, VS Code Copilot, Continue, Cody, ChatGPT Desktop, Gemini CLI, JetBrains, Zed, and 17+ AI tools.
+27 MCP tools + 7 resources available. Works with Claude Code, Cursor, Windsurf, VS Code Copilot, Continue, Cody, ChatGPT Desktop, Gemini CLI, JetBrains, Zed, and 17+ AI tools. **V3.1: Active Memory tools auto-learn your patterns.**
 
 ### Dual Interface: MCP + CLI
 
@@ -247,6 +247,42 @@ slm dashboard    # Opens at http://localhost:8765
 
 ---
 
+## Active Memory (V3.1) — Memory That Learns
+
+Most AI memory systems are passive databases — you store, you search, you get results. **SuperLocalMemory learns.**
+
+Every recall you make generates learning signals. Over time, the system adapts to your patterns:
+
+| Phase | Signals | What Happens |
+|-------|---------|-------------|
+| **Baseline** | 0-19 | Cross-encoder ranking (default behavior) |
+| **Rule-Based** | 20+ | Heuristic boosts: recency, access count, trust score |
+| **ML Model** | 200+ | LightGBM model trained on YOUR usage patterns |
+
+### Zero-Cost Learning Signals
+No LLM tokens spent. Four mathematical signals computed locally:
+- **Co-Retrieval** — memories retrieved together strengthen their connections
+- **Confidence Lifecycle** — accessed facts get boosted, unused facts decay
+- **Channel Performance** — tracks which retrieval channel works best for your queries
+- **Entropy Gap** — surprising content gets prioritized for deeper indexing
+
+### Auto-Capture & Auto-Recall
+```bash
+slm hooks install     # Install Claude Code hooks for invisible injection
+slm observe "We decided to use PostgreSQL"  # Auto-detects decisions, bugs, preferences
+slm session-context   # Get relevant context at session start
+```
+
+### MCP Active Memory Tools
+Three new tools for AI assistants:
+- `session_init` — call at session start, get relevant project context automatically
+- `observe` — send conversation content, auto-captures decisions/bugs/preferences
+- `report_feedback` — explicit feedback for faster learning
+
+**No competitor learns at zero token cost.** Mem0, Zep, and Letta all require cloud LLM calls for their learning loops. SLM learns through mathematics.
+
+---
+
 ## Features
 
 ### Retrieval

package/docs/getting-started.md

@@ -2,7 +2,7 @@
 > SuperLocalMemory V3 Documentation
 > https://superlocalmemory.com | Part of Qualixar
 
-Get your AI's memory system running in under 5 minutes.
+Get your AI's memory system running in under 5 minutes. **V3.1: Now with Active Memory — your memory learns from your usage and gets smarter over time, at zero token cost.**
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "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.1.0"
+version = "3.1.1"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "MIT"}

package/src/superlocalmemory/cli/commands.py

@@ -291,6 +291,12 @@ def cmd_recall(args: Namespace) -> None:
         ])
         return
 
+    # Record learning signals (CLI path — works without MCP)
+    try:
+        _cli_record_signals(config, args.query, response.results)
+    except Exception:
+        pass
+
     if not response.results:
         print("No memories found.")
         return
@@ -298,6 +304,26 @@ def cmd_recall(args: Namespace) -> None:
         print(f"  {i}. [{r.score:.2f}] {r.fact.content[:120]}")
 
 
+def _cli_record_signals(config, query, results):
+    """Record learning signals from CLI recall (no MCP dependency)."""
+    from pathlib import Path
+    from superlocalmemory.learning.feedback import FeedbackCollector
+    from superlocalmemory.learning.signals import LearningSignals
+    slm_dir = Path.home() / ".superlocalmemory"
+    pid = config.active_profile
+    fact_ids = [r.fact.fact_id for r in results[:10]]
+    if not fact_ids:
+        return
+    FeedbackCollector(slm_dir / "learning.db").record_implicit(
+        profile_id=pid, query=query,
+        fact_ids_returned=fact_ids, fact_ids_available=fact_ids,
+    )
+    signals = LearningSignals(slm_dir / "learning.db")
+    signals.record_co_retrieval(pid, fact_ids)
+    for fid in fact_ids[:5]:
+        LearningSignals.boost_confidence(str(slm_dir / "memory.db"), fid)
+
+
 def cmd_forget(args: Namespace) -> None:
     """Delete memories matching a query."""
     from superlocalmemory.core.engine import MemoryEngine

package/src/superlocalmemory/learning/feedback.py

@@ -314,3 +314,6 @@ class FeedbackCollector:
             }
         finally:
             conn.close()
+
+    # Alias used by dashboard routes
+    get_feedback_summary = get_summary

package/src/superlocalmemory/mcp/tools_active.py

@@ -17,10 +17,37 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 from __future__ import annotations
 
 import logging
+from pathlib import Path
 from typing import Callable
 
 logger = logging.getLogger(__name__)
 
+MEMORY_DIR = Path.home() / ".superlocalmemory"
+DB_PATH = MEMORY_DIR / "memory.db"
+
+
+def _emit_event(event_type: str, payload: dict | None = None,
+                source_agent: str = "mcp_client") -> None:
+    """Emit an event to the EventBus (best-effort, never raises)."""
+    try:
+        from superlocalmemory.infra.event_bus import EventBus
+        bus = EventBus.get_instance(str(DB_PATH))
+        bus.emit(event_type, payload=payload, source_agent=source_agent,
+                 source_protocol="mcp")
+    except Exception:
+        pass
+
+
+def _register_agent(agent_id: str, profile_id: str) -> None:
+    """Register an agent in the AgentRegistry (best-effort)."""
+    try:
+        from superlocalmemory.core.registry import AgentRegistry
+        registry_path = MEMORY_DIR / "agents.json"
+        registry = AgentRegistry(persist_path=registry_path)
+        registry.register_agent(agent_id, profile_id)
+    except Exception:
+        pass
+
 
 def register_active_tools(server, get_engine: Callable) -> None:
     """Register 3 active memory tools on *server*."""
@@ -78,6 +105,14 @@ def register_active_tools(server, get_engine: Callable) -> None:
             except Exception:
                 pass
 
+            # Register agent + emit event
+            _register_agent("mcp_client", pid)
+            _emit_event("agent.connected", {
+                "agent_id": "mcp_client",
+                "project_path": project_path,
+                "memory_count": len(memories),
+            })
+
             return {
                 "success": True,
                 "context": context,
@@ -148,6 +183,14 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 metadata={"agent_id": agent_id, "source": "auto-observe"},
             )
 
+            if stored:
+                _emit_event("memory.created", {
+                    "agent_id": agent_id,
+                    "category": decision.category,
+                    "content_preview": content[:80],
+                    "source": "auto-observe",
+                }, source_agent=agent_id)
+
             return {
                 "captured": stored,
                 "category": decision.category,
@@ -191,6 +234,13 @@ def register_active_tools(server, get_engine: Callable) -> None:
 
             count = engine._adaptive_learner.get_feedback_count(pid)
 
+            _emit_event("pattern.learned", {
+                "fact_id": fact_id,
+                "feedback": feedback,
+                "total_signals": count,
+                "phase": 1 if count < 50 else (2 if count < 200 else 3),
+            })
+
             return {
                 "success": True,
                 "feedback_id": record.feedback_id,

package/src/superlocalmemory/mcp/tools_core.py

@@ -15,10 +15,25 @@ from __future__ import annotations
 
 import json
 import logging
+from pathlib import Path
 from typing import Any, Callable
 
 logger = logging.getLogger(__name__)
 
+_DB_PATH = str(Path.home() / ".superlocalmemory" / "memory.db")
+
+
+def _emit_event(event_type: str, payload: dict | None = None,
+                source_agent: str = "mcp_client") -> None:
+    """Emit an event to the EventBus (best-effort, never raises)."""
+    try:
+        from superlocalmemory.infra.event_bus import EventBus
+        bus = EventBus.get_instance(_DB_PATH)
+        bus.emit(event_type, payload=payload, source_agent=source_agent,
+                 source_protocol="mcp")
+    except Exception:
+        pass
+
 
 def _record_recall_hits(get_engine: Callable, query: str, results: list[dict]) -> None:
     """Record implicit feedback + learning signals for each recall.
@@ -89,6 +104,11 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 "session_id": session_id,
             })
             if result.get("ok"):
+                _emit_event("memory.created", {
+                    "content_preview": content[:80],
+                    "agent_id": agent_id,
+                    "fact_count": result.get("count", 0),
+                }, source_agent=agent_id)
                 return {"success": True, "fact_ids": result.get("fact_ids", []), "count": result.get("count", 0)}
             return {"success": False, "error": result.get("error", "Store failed")}
         except Exception as exc:
@@ -108,6 +128,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     _record_recall_hits(get_engine, query, result.get("results", []))
                 except Exception:
                     pass  # Feedback is non-critical, never block recall
+                _emit_event("memory.recalled", {
+                    "query": query[:80],
+                    "result_count": result.get("result_count", 0),
+                    "query_type": result.get("query_type", "unknown"),
+                    "agent_id": agent_id,
+                }, source_agent=agent_id)
                 return {
                     "success": True,
                     "results": result.get("results", []),
@@ -362,6 +388,10 @@ def register_core_tools(server, get_engine: Callable) -> None:
             })
             if result.get("ok"):
                 logger.info("Memory deleted: %s by agent: %s", fact_id[:16], agent_id)
+                _emit_event("memory.deleted", {
+                    "fact_id": fact_id,
+                    "agent_id": agent_id,
+                }, source_agent=agent_id)
                 return {"success": True, "deleted": fact_id, "agent_id": agent_id}
             return {"success": False, "error": result.get("error", "Delete failed")}
         except Exception as exc:

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

@@ -43,13 +43,15 @@ async def get_agents(
     if not REGISTRY_AVAILABLE:
         return {"agents": [], "count": 0, "message": "Agent registry not available"}
     try:
-        engine = getattr(request.app.state, "engine", None)
-        if engine and hasattr(engine, '_db'):
-            registry = AgentRegistry(engine._db)
-            agents = registry.list_agents(protocol=protocol, limit=limit)
-            stats = registry.get_stats()
-            return {"agents": agents, "count": len(agents), "stats": stats}
-        return {"agents": [], "count": 0, "message": "Engine not initialized"}
+        from pathlib import Path
+        registry_path = Path.home() / ".superlocalmemory" / "agents.json"
+        registry = AgentRegistry(persist_path=registry_path)
+        agents = registry.list_agents()
+        return {
+            "agents": agents,
+            "count": len(agents),
+            "stats": {"total_agents": len(agents)},
+        }
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Agent registry error: {str(e)}")
 
@@ -60,11 +62,11 @@ async def get_agent_stats(request: Request):
     if not REGISTRY_AVAILABLE:
         return {"total_agents": 0, "message": "Agent registry not available"}
     try:
-        engine = getattr(request.app.state, "engine", None)
-        if engine and hasattr(engine, '_db'):
-            registry = AgentRegistry(engine._db)
-            return registry.get_stats()
-        return {"total_agents": 0, "message": "Engine not initialized"}
+        from pathlib import Path
+        registry_path = Path.home() / ".superlocalmemory" / "agents.json"
+        registry = AgentRegistry(persist_path=registry_path)
+        agents = registry.list_agents()
+        return {"total_agents": len(agents)}
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Agent stats error: {str(e)}")
 

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

@@ -104,7 +104,7 @@ async def learning_status():
         feedback = _get_feedback()
         if feedback:
             try:
-                old_stats = feedback.get_feedback_summary()
+                old_stats = feedback.get_feedback_summary(active_profile)
                 if isinstance(old_stats, dict):
                     old_stats["feedback_count"] = signal_count
                     old_stats["active_profile"] = active_profile
@@ -274,8 +274,9 @@ async def feedback_stats():
         by_type = {}
 
         if feedback:
-            summary = feedback.get_feedback_summary()
-            total = summary.get("total_signals", 0)
+            profile = get_active_profile()
+            summary = feedback.get_feedback_summary(profile)
+            total = summary.get("total", summary.get("total_signals", 0))
             by_channel = summary.get("by_channel", {})
             by_type = summary.get("by_type", {})
 

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

@@ -38,32 +38,32 @@ async def lifecycle_status():
         conn = sqlite3.connect(str(DB_PATH))
         conn.row_factory = sqlite3.Row
 
-        # Try V3 schema first (atomic_facts with lifecycle_state)
+        # Try V3 schema first (atomic_facts with lifecycle column)
         states = {}
         try:
             rows = conn.execute(
-                "SELECT lifecycle_state, COUNT(*) as cnt "
-                "FROM atomic_facts WHERE profile_id = ? GROUP BY lifecycle_state",
+                "SELECT lifecycle, COUNT(*) as cnt "
+                "FROM atomic_facts WHERE profile_id = ? GROUP BY lifecycle",
                 (profile,),
             ).fetchall()
             states = {
-                (row['lifecycle_state'] or 'active'): row['cnt']
+                (row['lifecycle'] or 'active'): row['cnt']
                 for row in rows
             }
         except sqlite3.OperationalError:
             # V2 fallback: memories table
             try:
                 rows = conn.execute(
-                    "SELECT lifecycle_state, COUNT(*) as cnt "
-                    "FROM memories WHERE profile = ? GROUP BY lifecycle_state",
+                    "SELECT lifecycle, COUNT(*) as cnt "
+                    "FROM memories WHERE profile = ? GROUP BY lifecycle",
                     (profile,),
                 ).fetchall()
                 states = {
-                    (row['lifecycle_state'] or 'active'): row['cnt']
+                    (row['lifecycle'] or 'active'): row['cnt']
                     for row in rows
                 }
             except sqlite3.OperationalError:
-                # No lifecycle_state column at all
+                # No lifecycle column at all — count everything as active
                 total = conn.execute(
                     "SELECT COUNT(*) FROM atomic_facts WHERE profile_id = ?",
                     (profile,),
@@ -80,7 +80,7 @@ async def lifecycle_status():
                     "SELECT AVG(julianday('now') - julianday(created_at)) as avg_age, "
                     "MIN(julianday('now') - julianday(created_at)) as min_age, "
                     "MAX(julianday('now') - julianday(created_at)) as max_age "
-                    "FROM atomic_facts WHERE profile_id = ? AND lifecycle_state = ?",
+                    "FROM atomic_facts WHERE profile_id = ? AND lifecycle = ?",
                     (profile, state),
                 ).fetchone()
                 if row and row['avg_age'] is not None:

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

@@ -46,53 +46,37 @@ def _fetch_graph_data(
 ) -> tuple[list, list, list]:
     """Fetch graph nodes, links, clusters from V3 or V2 schema."""
     if use_v3:
-        # Graph-first: fetch edges, then get connected nodes, then fill slots
+        # Recency-first: get the most recent nodes, then find their edges
         cursor.execute("""
-            SELECT source_id as source, target_id as target,
-                   weight, edge_type as relationship_type
-            FROM graph_edges WHERE profile_id = ?
-            ORDER BY weight DESC
-        """, (profile,))
-        all_links = cursor.fetchall()
+            SELECT fact_id as id, content, fact_type as category,
+                   confidence as importance, session_id as project_name,
+                   created_at
+            FROM atomic_facts
+            WHERE profile_id = ? AND confidence >= ?
+            ORDER BY created_at DESC
+            LIMIT ?
+        """, (profile, min_importance / 10.0, max_nodes))
+        nodes = cursor.fetchall()
 
-        connected_ids = set()
-        for lk in all_links:
-            connected_ids.add(lk['source'])
-            connected_ids.add(lk['target'])
+        node_ids = {n['id'] for n in nodes}
 
-        # Fetch connected nodes first (these have edges to display)
-        connected_nodes: list = []
-        if connected_ids:
-            ph = ','.join('?' * len(connected_ids))
+        # Fetch edges between these nodes
+        if node_ids:
+            ph = ','.join('?' * len(node_ids))
+            id_list = list(node_ids)
             cursor.execute(f"""
-                SELECT fact_id as id, content, fact_type as category,
-                       confidence as importance, session_id as project_name,
-                       created_at
-                FROM atomic_facts
-                WHERE profile_id = ? AND fact_id IN ({ph})
-            """, [profile] + list(connected_ids))
-            connected_nodes = cursor.fetchall()
-
-        # Fill remaining slots with top-confidence unconnected nodes
-        remaining = max_nodes - len(connected_nodes)
-        if remaining > 0:
-            existing = {n['id'] for n in connected_nodes}
-            cursor.execute("""
-                SELECT fact_id as id, content, fact_type as category,
-                       confidence as importance, session_id as project_name,
-                       created_at
-                FROM atomic_facts
-                WHERE profile_id = ? AND confidence >= ?
-                ORDER BY confidence DESC, created_at DESC
-                LIMIT ?
-            """, (profile, min_importance / 10.0, remaining + len(existing)))
-            for n in cursor.fetchall():
-                if n['id'] not in existing:
-                    connected_nodes.append(n)
-                    if len(connected_nodes) >= max_nodes:
-                        break
-
-        nodes = connected_nodes[:max_nodes]
+                SELECT source_id as source, target_id as target,
+                       weight, edge_type as relationship_type
+                FROM graph_edges
+                WHERE profile_id = ?
+                  AND source_id IN ({ph}) AND target_id IN ({ph})
+                ORDER BY weight DESC
+            """, [profile] + id_list + id_list)
+            all_links = cursor.fetchall()
+        else:
+            all_links = []
+
+        links = all_links
         for n in nodes:
             n['entities'] = []
             n['content_preview'] = _preview(n.get('content'))
@@ -101,7 +85,33 @@ def _fetch_graph_data(
         node_ids = {n['id'] for n in nodes}
         links = [lk for lk in all_links
                  if lk['source'] in node_ids and lk['target'] in node_ids]
-        return nodes, links, []
+
+        # Compute clusters from memory_scenes
+        clusters = []
+        try:
+            cursor.execute("""
+                SELECT scene_id, theme, fact_ids_json
+                FROM memory_scenes WHERE profile_id = ?
+            """, (profile,))
+            for row in cursor.fetchall():
+                fact_ids = []
+                try:
+                    fact_ids = json.loads(row.get('fact_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                # Only include clusters that overlap with displayed nodes
+                overlap = [fid for fid in fact_ids if fid in node_ids]
+                if overlap:
+                    clusters.append({
+                        'cluster_id': row['scene_id'],
+                        'size': len(fact_ids),
+                        'visible_size': len(overlap),
+                        'theme': row.get('theme', ''),
+                    })
+        except Exception:
+            pass
+
+        return nodes, links, clusters
 
     # V2 fallback
     try:
@@ -362,15 +372,54 @@ async def get_clusters(request: Request):
         profile = get_active_profile()
         unclustered = 0
 
-        if _has_table(cursor, 'scene_facts'):
+        # V3 schema: memory_scenes stores fact_ids_json (JSON array)
+        if _has_table(cursor, 'memory_scenes'):
             cursor.execute("""
-                SELECT s.scene_id as cluster_id, COUNT(sf.fact_id) as member_count,
-                       s.summary, s.created_at as first_memory
-                FROM scenes s JOIN scene_facts sf ON s.scene_id = sf.scene_id
-                WHERE s.profile_id = ? GROUP BY s.scene_id ORDER BY member_count DESC
+                SELECT scene_id as cluster_id, theme, fact_ids_json,
+                       entity_ids_json, created_at as first_memory
+                FROM memory_scenes WHERE profile_id = ?
+                ORDER BY created_at DESC
             """, (profile,))
-            clusters = [dict(r, top_entities=[]) for r in cursor.fetchall()]
+            raw_scenes = cursor.fetchall()
+            clusters = []
+            for scene in raw_scenes:
+                fact_ids = []
+                try:
+                    fact_ids = json.loads(scene.get('fact_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                entity_ids = []
+                try:
+                    entity_ids = json.loads(scene.get('entity_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                clusters.append({
+                    'cluster_id': scene['cluster_id'],
+                    'member_count': len(fact_ids),
+                    'categories': scene.get('theme', ''),
+                    'summary': scene.get('theme', ''),
+                    'first_memory': scene.get('first_memory', ''),
+                    'top_entities': entity_ids[:5],
+                })
+            # Filter out empty clusters
+            clusters = [c for c in clusters if c['member_count'] > 0]
+            clusters.sort(key=lambda c: c['member_count'], reverse=True)
+
+            # Count facts not in any scene
+            all_scene_fact_ids = set()
+            for scene in raw_scenes:
+                try:
+                    ids = json.loads(scene.get('fact_ids_json', '[]') or '[]')
+                    all_scene_fact_ids.update(ids)
+                except (json.JSONDecodeError, TypeError):
+                    pass
+            total_facts = cursor.execute(
+                "SELECT COUNT(*) as c FROM atomic_facts WHERE profile_id = ?",
+                (profile,),
+            ).fetchone()['c']
+            unclustered = total_facts - len(all_scene_fact_ids)
         else:
+            # V2 fallback
             try:
                 cursor.execute("""
                     SELECT cluster_id, COUNT(*) as member_count,
@@ -382,8 +431,14 @@ async def get_clusters(request: Request):
                 clusters = [dict(r, top_entities=[]) for r in cursor.fetchall()]
             except Exception:
                 clusters = []
-            cursor.execute("SELECT COUNT(*) as c FROM memories WHERE cluster_id IS NULL AND profile = ?", (profile,))
-            unclustered = cursor.fetchone()['c']
+            try:
+                cursor.execute(
+                    "SELECT COUNT(*) as c FROM memories WHERE cluster_id IS NULL AND profile = ?",
+                    (profile,),
+                )
+                unclustered = cursor.fetchone()['c']
+            except Exception:
+                unclustered = 0
 
         conn.close()
         return {"clusters": clusters, "total_clusters": len(clusters), "unclustered_count": unclustered}
@@ -392,21 +447,41 @@ async def get_clusters(request: Request):
 
 
 @router.get("/api/clusters/{cluster_id}")
-async def get_cluster_detail(request: Request, cluster_id: int, limit: int = Query(50, ge=1, le=200)):
-    """Get detailed view of a specific cluster."""
+async def get_cluster_detail(request: Request, cluster_id: str, limit: int = Query(50, ge=1, le=200)):
+    """Get detailed view of a specific cluster (scene)."""
     try:
         conn = get_db_connection()
         conn.row_factory = dict_factory
         cursor = conn.cursor()
         profile = get_active_profile()
 
-        if _has_table(cursor, 'scene_facts'):
-            cursor.execute("""
-                SELECT f.fact_id as id, f.content, f.fact_type as category,
-                       f.confidence as importance, f.created_at
-                FROM atomic_facts f JOIN scene_facts sf ON f.fact_id = sf.fact_id
-                WHERE sf.scene_id = ? AND f.profile_id = ? ORDER BY f.confidence DESC LIMIT ?
-            """, (str(cluster_id), profile, limit))
+        if _has_table(cursor, 'memory_scenes'):
+            # Get fact IDs from the scene's JSON array
+            cursor.execute(
+                "SELECT fact_ids_json, theme FROM memory_scenes "
+                "WHERE scene_id = ? AND profile_id = ?",
+                (cluster_id, profile),
+            )
+            scene_row = cursor.fetchone()
+            if scene_row:
+                fact_ids = []
+                try:
+                    fact_ids = json.loads(scene_row.get('fact_ids_json', '[]') or '[]')
+                except (json.JSONDecodeError, TypeError):
+                    pass
+                if fact_ids:
+                    ph = ','.join('?' * min(len(fact_ids), limit))
+                    cursor.execute(f"""
+                        SELECT fact_id as id, content, fact_type as category,
+                               confidence as importance, created_at
+                        FROM atomic_facts
+                        WHERE profile_id = ? AND fact_id IN ({ph})
+                        ORDER BY confidence DESC
+                    """, [profile] + fact_ids[:limit])
+                else:
+                    cursor.execute("SELECT 1 WHERE 0")  # empty result
+            else:
+                cursor.execute("SELECT 1 WHERE 0")  # empty result
         else:
             cursor.execute("""
                 SELECT id, content, summary, category, project_name, importance, created_at, tags