superlocalmemory 3.0.37 → 3.1.1

package/src/superlocalmemory/mcp/resources.py

@@ -20,7 +20,32 @@ logger = logging.getLogger(__name__)
 
 
 def register_resources(server, get_engine: Callable) -> None:
-    """Register 6 MCP resources on *server*."""
+    """Register 7 MCP resources on *server*."""
+
+    # ------------------------------------------------------------------
+    # 0. slm://context — Active Memory auto-injection
+    # ------------------------------------------------------------------
+    @server.resource("slm://context")
+    async def session_context() -> str:
+        """Active session context — auto-injected on MCP connect.
+
+        Returns the most relevant memories for the current session:
+        recent decisions, active patterns, and project context.
+        AI tools read this automatically on connection to get instant context.
+        """
+        try:
+            from superlocalmemory.hooks.auto_recall import AutoRecall
+            engine = get_engine()
+            auto = AutoRecall(
+                engine=engine,
+                config={"enabled": True, "max_memories_injected": 10, "relevance_threshold": 0.3},
+            )
+            context = auto.get_session_context(query="recent decisions and important context")
+            if not context:
+                return "No session context available yet. Use 'remember' to store memories."
+            return context
+        except Exception as exc:
+            return f"Context unavailable: {exc}"
 
     # ------------------------------------------------------------------
     # 1. slm://recent

package/src/superlocalmemory/mcp/server.py

@@ -58,11 +58,13 @@ def reset_engine():
 from superlocalmemory.mcp.tools_core import register_core_tools
 from superlocalmemory.mcp.tools_v28 import register_v28_tools
 from superlocalmemory.mcp.tools_v3 import register_v3_tools
+from superlocalmemory.mcp.tools_active import register_active_tools
 from superlocalmemory.mcp.resources import register_resources
 
 register_core_tools(server, get_engine)
 register_v28_tools(server, get_engine)
 register_v3_tools(server, get_engine)
+register_active_tools(server, get_engine)
 register_resources(server, get_engine)
 
 

package/src/superlocalmemory/mcp/tools_active.py

@@ -0,0 +1,255 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under the MIT License - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SuperLocalMemory V3.1 — Active Memory MCP Tools.
+
+session_init    — Auto-recall project context at session start.
+observe         — Monitor conversation for auto-capture (decisions/bugs/prefs).
+report_feedback — Record explicit feedback on recall results for learning.
+
+These tools transform SLM from a passive database into an active
+intelligence layer that learns and improves over time.
+
+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*."""
+
+    # ------------------------------------------------------------------
+    # 1. session_init — Auto-recall project context at session start
+    # ------------------------------------------------------------------
+    @server.tool()
+    async def session_init(
+        project_path: str = "",
+        query: str = "",
+        max_results: int = 10,
+    ) -> dict:
+        """Initialize session with relevant memory context.
+
+        Call this ONCE at the start of every session. Returns:
+        - Recent decisions and patterns for this project
+        - Top relevant memories based on project path or query
+        - Learning status (signal count, ranking phase)
+
+        The AI should call this automatically before any other work.
+        """
+        try:
+            from superlocalmemory.hooks.auto_recall import AutoRecall
+            from superlocalmemory.hooks.rules_engine import RulesEngine
+
+            engine = get_engine()
+            rules = RulesEngine()
+
+            if not rules.should_recall("session_start"):
+                return {"success": True, "context": "", "memories": [], "message": "Auto-recall disabled"}
+
+            recall_config = rules.get_recall_config()
+            auto = AutoRecall(
+                engine=engine,
+                config={
+                    "enabled": True,
+                    "max_memories_injected": max_results,
+                    "relevance_threshold": recall_config.get("relevance_threshold", 0.3),
+                },
+            )
+
+            # Get formatted context for system prompt injection
+            context = auto.get_session_context(project_path=project_path, query=query)
+
+            # Get structured results for tool response
+            search_query = query or f"project context {project_path}" if project_path else "recent important decisions"
+            memories = auto.get_query_context(search_query)
+
+            # Get learning status
+            pid = engine.profile_id
+            feedback_count = 0
+            try:
+                feedback_count = engine._adaptive_learner.get_feedback_count(pid)
+            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,
+                "memories": memories[:max_results],
+                "memory_count": len(memories),
+                "learning": {
+                    "feedback_signals": feedback_count,
+                    "phase": 1 if feedback_count < 50 else (2 if feedback_count < 200 else 3),
+                    "status": "collecting" if feedback_count < 50 else ("learning" if feedback_count < 200 else "trained"),
+                },
+            }
+        except Exception as exc:
+            logger.exception("session_init failed")
+            return {"success": False, "error": str(exc)}
+
+    # ------------------------------------------------------------------
+    # 2. observe — Auto-capture decisions/bugs/preferences
+    # ------------------------------------------------------------------
+    @server.tool()
+    async def observe(
+        content: str,
+        agent_id: str = "mcp_client",
+    ) -> dict:
+        """Observe conversation content for automatic memory capture.
+
+        Send conversation snippets here. The system evaluates whether
+        the content contains decisions, bug fixes, or preferences worth
+        storing. If so, it auto-captures them with classification metadata.
+
+        Call this after making decisions, fixing bugs, or expressing preferences.
+        The system will NOT store low-confidence or irrelevant content.
+        """
+        try:
+            from superlocalmemory.hooks.auto_capture import AutoCapture
+            from superlocalmemory.hooks.rules_engine import RulesEngine
+
+            engine = get_engine()
+            rules = RulesEngine()
+
+            auto = AutoCapture(
+                engine=engine,
+                config=rules.get_capture_config(),
+            )
+
+            decision = auto.evaluate(content)
+
+            if not decision.capture:
+                return {
+                    "captured": False,
+                    "reason": decision.reason,
+                    "category": decision.category,
+                    "confidence": round(decision.confidence, 3),
+                }
+
+            # Check rules engine for category-level permission
+            if not rules.should_capture(decision.category, decision.confidence):
+                return {
+                    "captured": False,
+                    "reason": f"Category '{decision.category}' disabled in rules",
+                    "category": decision.category,
+                    "confidence": round(decision.confidence, 3),
+                }
+
+            # Auto-store via engine
+            stored = auto.capture(
+                content,
+                category=decision.category,
+                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,
+                "confidence": round(decision.confidence, 3),
+                "reason": decision.reason,
+            }
+        except Exception as exc:
+            logger.exception("observe failed")
+            return {"captured": False, "error": str(exc)}
+
+    # ------------------------------------------------------------------
+    # 3. report_feedback — Explicit feedback for learning
+    # ------------------------------------------------------------------
+    @server.tool()
+    async def report_feedback(
+        fact_id: str,
+        feedback: str = "relevant",
+        query: str = "",
+    ) -> dict:
+        """Report whether a recalled memory was useful.
+
+        feedback: "relevant" (memory was helpful), "irrelevant" (not useful),
+                  "partial" (somewhat relevant).
+
+        This feedback trains the adaptive ranker to return better results
+        over time. The more feedback, the smarter the system gets.
+        """
+        try:
+            engine = get_engine()
+            pid = engine.profile_id
+
+            if feedback not in ("relevant", "irrelevant", "partial"):
+                return {"success": False, "error": f"Invalid feedback: {feedback}. Use relevant/irrelevant/partial"}
+
+            record = engine._adaptive_learner.record_feedback(
+                query=query,
+                fact_id=fact_id,
+                feedback_type=feedback,
+                profile_id=pid,
+            )
+
+            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,
+                "total_signals": count,
+                "phase": 1 if count < 50 else (2 if count < 200 else 3),
+                "message": f"Feedback recorded. {count} total signals."
+                + (" Phase 2 unlocked!" if count == 50 else "")
+                + (" Phase 3 (ML) unlocked!" if count == 200 else ""),
+            }
+        except Exception as exc:
+            logger.exception("report_feedback failed")
+            return {"success": False, "error": str(exc)}

package/src/superlocalmemory/mcp/tools_core.py

@@ -15,10 +15,71 @@ 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.
+
+    Non-blocking, non-critical — failures silently ignored.
+    Feeds: FeedbackCollector + Co-Retrieval + Confidence Boost.
+    """
+    try:
+        from pathlib import Path
+        engine = get_engine()
+        pid = engine.profile_id
+        slm_dir = Path.home() / ".superlocalmemory"
+        fact_ids = [r.get("fact_id", "") for r in results[:10] if r.get("fact_id")]
+        if not fact_ids:
+            return
+
+        # 1. Implicit feedback (recall_hit signals for adaptive learner)
+        try:
+            from superlocalmemory.learning.feedback import FeedbackCollector
+            collector = FeedbackCollector(slm_dir / "learning.db")
+            collector.record_implicit(
+                profile_id=pid, query=query,
+                fact_ids_returned=fact_ids, fact_ids_available=fact_ids,
+            )
+        except Exception:
+            pass
+
+        # 2. Co-retrieval signals (strengthen implicit graph edges)
+        try:
+            from superlocalmemory.learning.signals import LearningSignals
+            signals = LearningSignals(slm_dir / "learning.db")
+            signals.record_co_retrieval(pid, fact_ids)
+        except Exception:
+            pass
+
+        # 3. Confidence boost (accessed facts get +0.02, cap 1.0)
+        try:
+            from superlocalmemory.learning.signals import LearningSignals
+            mem_db = str(slm_dir / "memory.db")
+            for fid in fact_ids[:5]:
+                LearningSignals.boost_confidence(mem_db, fid)
+        except Exception:
+            pass
+    except Exception:
+        pass
+
 
 def register_core_tools(server, get_engine: Callable) -> None:
     """Register the 13 core MCP tools on *server*."""
@@ -43,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:
@@ -57,6 +123,17 @@ def register_core_tools(server, get_engine: Callable) -> None:
             pool = WorkerPool.shared()
             result = pool.recall(query, limit=limit)
             if result.get("ok"):
+                # Record implicit feedback: every returned result is a recall_hit
+                try:
+                    _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", []),
@@ -311,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/behavioral.py

@@ -45,9 +45,18 @@ async def behavioral_status():
         recent_outcomes = []
         try:
             tracker = OutcomeTracker(db_path)
-            total_outcomes = tracker.get_outcome_count(profile=profile)
-            outcome_breakdown = tracker.get_outcome_breakdown(profile=profile)
-            recent_outcomes = tracker.get_recent_outcomes(profile=profile, limit=20)
+            all_outcomes = tracker.get_outcomes(profile_id=profile, limit=50)
+            total_outcomes = len(all_outcomes)
+            for o in all_outcomes:
+                key = o.outcome if hasattr(o, 'outcome') else str(o)
+                if key in outcome_breakdown:
+                    outcome_breakdown[key] += 1
+            recent_outcomes = [
+                {"outcome": o.outcome, "action_type": o.action_type,
+                 "timestamp": o.timestamp}
+                for o in all_outcomes[:20]
+                if hasattr(o, 'outcome')
+            ]
         except Exception as exc:
             logger.debug("outcome tracker: %s", exc)
 
@@ -56,8 +65,8 @@ async def behavioral_status():
         cross_project_transfers = 0
         try:
             store = BehavioralPatternStore(db_path)
-            patterns = store.get_patterns(profile=profile)
-            cross_project_transfers = store.get_cross_project_count(profile=profile)
+            patterns = store.get_patterns(profile_id=profile)
+            cross_project_transfers = 0
         except Exception as exc:
             logger.debug("pattern store: %s", exc)
 
@@ -69,6 +78,12 @@ async def behavioral_status():
             "patterns": patterns,
             "cross_project_transfers": cross_project_transfers,
             "recent_outcomes": recent_outcomes,
+            "stats": {
+                "success_count": outcome_breakdown.get("success", 0),
+                "failure_count": outcome_breakdown.get("failure", 0),
+                "partial_count": outcome_breakdown.get("partial", 0),
+                "patterns_count": len(patterns),
+            },
         }
     except Exception as e:
         logger.error("behavioral_status error: %s", e)

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

@@ -79,22 +79,45 @@ async def learning_status():
         active_profile = get_active_profile()
         result["active_profile"] = active_profile
 
-        # Ranking phase
-        result["ranking_phase"] = "baseline"
+        # Real signal count from V3.1 learning_feedback table
+        signal_count = 0
+        try:
+            from superlocalmemory.learning.feedback import FeedbackCollector
+            from pathlib import Path
+            learning_db = Path.home() / ".superlocalmemory" / "learning.db"
+            if learning_db.exists():
+                collector = FeedbackCollector(learning_db)
+                signal_count = collector.get_feedback_count(active_profile)
+        except Exception:
+            pass
+
+        # Ranking phase based on real signal count
+        if signal_count >= 200:
+            result["ranking_phase"] = "ml_model"
+        elif signal_count >= 20:
+            result["ranking_phase"] = "rule_based"
+        else:
+            result["ranking_phase"] = "baseline"
 
-        # Feedback stats
+        # Feedback stats — merge old system + new V3.1 signals
+        stats_dict = {"feedback_count": signal_count, "active_profile": active_profile}
         feedback = _get_feedback()
         if feedback:
             try:
-                summary = feedback.get_feedback_summary()
-                result["stats"] = summary
-                result["profile_feedback"] = {
-                    "profile": active_profile,
-                    "signals": summary.get("total_signals", 0),
-                }
+                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
+                    stats_dict = old_stats
             except Exception as exc:
                 logger.debug("feedback summary: %s", exc)
 
+        result["stats"] = stats_dict
+        result["profile_feedback"] = {
+            "profile": active_profile,
+            "signals": signal_count,
+        }
+
         # Engagement
         engagement = _get_engagement()
         if engagement:
@@ -105,9 +128,43 @@ async def learning_status():
         else:
             result["engagement"] = None
 
-        # Tech preferences (stub until learning DB populated)
-        result["tech_preferences"] = []
-        result["workflow_patterns"] = []
+        # Tech preferences + workflow patterns from V3.1 behavioral store
+        try:
+            from superlocalmemory.learning.behavioral import BehavioralPatternStore
+            from pathlib import Path
+            learning_db = Path.home() / ".superlocalmemory" / "learning.db"
+            if learning_db.exists():
+                store = BehavioralPatternStore(str(learning_db))
+                all_patterns = store.get_patterns(profile_id=active_profile)
+                tech = [
+                    {"key": "tech", "value": p.get("metadata", {}).get("value", p.get("pattern_key", "")),
+                     "confidence": p.get("confidence", 0), "evidence": p.get("evidence_count", 0)}
+                    for p in all_patterns if p.get("pattern_type") == "tech_preference"
+                ]
+                workflows = [
+                    {"type": p.get("pattern_type"), "key": p.get("pattern_key", ""),
+                     "value": p.get("metadata", {}).get("value", ""),
+                     "confidence": p.get("confidence", 0)}
+                    for p in all_patterns if p.get("pattern_type") in ("temporal", "interest")
+                ]
+                result["tech_preferences"] = tech
+                result["workflow_patterns"] = workflows
+
+                # Privacy stats
+                import os
+                db_size = os.path.getsize(str(learning_db)) // 1024 if learning_db.exists() else 0
+                stats_dict["db_size_kb"] = db_size
+                stats_dict["transferable_patterns"] = len(all_patterns)
+                stats_dict["models_trained"] = 1 if signal_count >= 200 else 0
+                stats_dict["tracked_sources"] = len(set(
+                    p.get("pattern_type") for p in all_patterns
+                ))
+            else:
+                result["tech_preferences"] = []
+                result["workflow_patterns"] = []
+        except Exception:
+            result["tech_preferences"] = []
+            result["workflow_patterns"] = []
         result["source_scores"] = {}
 
     except Exception as e:
@@ -217,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: