autonomy phase 2

cortex/autonomy/proactive/monitor.py

@@ -0,0 +1,321 @@
+"""
+Proactive Context Monitor - detects opportunities for autonomous suggestions.
+"""
+
+import logging
+import time
+from typing import Dict, List, Any, Optional
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+
+class ProactiveMonitor:
+    """
+    Monitors conversation context and detects opportunities for proactive suggestions.
+
+    Triggers:
+    - Long silence → Check-in
+    - Learning queue + high curiosity → Suggest exploration
+    - Active goals → Progress reminders
+    - Conversation milestones → Offer summary
+    - Pattern detection → Helpful suggestions
+    """
+
+    def __init__(self, min_priority: float = 0.6):
+        """
+        Initialize proactive monitor.
+
+        Args:
+            min_priority: Minimum priority for suggestions (0.0-1.0)
+        """
+        self.min_priority = min_priority
+        self.last_suggestion_time = {}  # session_id -> timestamp
+        self.cooldown_seconds = 300  # 5 minutes between proactive suggestions
+
+    async def analyze_session(
+        self,
+        session_id: str,
+        context_state: Dict[str, Any],
+        self_state: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Analyze session for proactive suggestion opportunities.
+
+        Args:
+            session_id: Current session ID
+            context_state: Full context including message history
+            self_state: Lyra's current self-state
+
+        Returns:
+            {
+                "suggestion": "text to append to response",
+                "priority": 0.0-1.0,
+                "reason": "why this suggestion",
+                "type": "check_in | learning | goal_reminder | summary | pattern"
+            }
+            or None if no suggestion
+        """
+        # Check cooldown
+        if not self._check_cooldown(session_id):
+            logger.debug(f"[PROACTIVE] Session {session_id} in cooldown, skipping")
+            return None
+
+        suggestions = []
+
+        # Check 1: Long silence detection
+        silence_suggestion = self._check_long_silence(context_state)
+        if silence_suggestion:
+            suggestions.append(silence_suggestion)
+
+        # Check 2: Learning queue + high curiosity
+        learning_suggestion = self._check_learning_opportunity(self_state)
+        if learning_suggestion:
+            suggestions.append(learning_suggestion)
+
+        # Check 3: Active goals reminder
+        goal_suggestion = self._check_active_goals(self_state, context_state)
+        if goal_suggestion:
+            suggestions.append(goal_suggestion)
+
+        # Check 4: Conversation milestones
+        milestone_suggestion = self._check_conversation_milestone(context_state)
+        if milestone_suggestion:
+            suggestions.append(milestone_suggestion)
+
+        # Check 5: Pattern-based suggestions
+        pattern_suggestion = self._check_patterns(context_state, self_state)
+        if pattern_suggestion:
+            suggestions.append(pattern_suggestion)
+
+        # Filter by priority and return highest
+        valid_suggestions = [s for s in suggestions if s["priority"] >= self.min_priority]
+
+        if not valid_suggestions:
+            return None
+
+        # Return highest priority suggestion
+        best_suggestion = max(valid_suggestions, key=lambda x: x["priority"])
+
+        # Update cooldown timer
+        self._update_cooldown(session_id)
+
+        logger.info(f"[PROACTIVE] Suggestion generated: {best_suggestion['type']} (priority: {best_suggestion['priority']:.2f})")
+
+        return best_suggestion
+
+    def _check_cooldown(self, session_id: str) -> bool:
+        """Check if session is past cooldown period."""
+        if session_id not in self.last_suggestion_time:
+            return True
+
+        elapsed = time.time() - self.last_suggestion_time[session_id]
+        return elapsed >= self.cooldown_seconds
+
+    def _update_cooldown(self, session_id: str) -> None:
+        """Update cooldown timer for session."""
+        self.last_suggestion_time[session_id] = time.time()
+
+    def _check_long_silence(self, context_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Check if user has been silent for a long time.
+        """
+        minutes_since_last = context_state.get("minutes_since_last_msg", 0)
+
+        # If > 30 minutes, suggest check-in
+        if minutes_since_last > 30:
+            return {
+                "suggestion": "\n\n[Aside: I'm still here if you need anything!]",
+                "priority": 0.7,
+                "reason": f"User silent for {minutes_since_last:.0f} minutes",
+                "type": "check_in"
+            }
+
+        return None
+
+    def _check_learning_opportunity(self, self_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Check if Lyra has learning queue items and high curiosity.
+        """
+        learning_queue = self_state.get("learning_queue", [])
+        curiosity = self_state.get("curiosity", 0.5)
+
+        # If curiosity > 0.7 and learning queue exists
+        if curiosity > 0.7 and learning_queue:
+            topic = learning_queue[0] if learning_queue else "new topics"
+            return {
+                "suggestion": f"\n\n[Aside: I've been curious about {topic} lately. Would you like to explore it together?]",
+                "priority": 0.65,
+                "reason": f"High curiosity ({curiosity:.2f}) and learning queue present",
+                "type": "learning"
+            }
+
+        return None
+
+    def _check_active_goals(
+        self,
+        self_state: Dict[str, Any],
+        context_state: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Check if there are active goals worth reminding about.
+        """
+        active_goals = self_state.get("active_goals", [])
+
+        if not active_goals:
+            return None
+
+        # Check if we've had multiple messages without goal progress
+        message_count = context_state.get("message_count", 0)
+
+        # Every 10 messages, consider goal reminder
+        if message_count % 10 == 0 and message_count > 0:
+            goal = active_goals[0]  # First active goal
+            goal_name = goal if isinstance(goal, str) else goal.get("name", "your goal")
+
+            return {
+                "suggestion": f"\n\n[Aside: Still thinking about {goal_name}. Let me know if you want to work on it.]",
+                "priority": 0.6,
+                "reason": f"Active goal present, {message_count} messages since start",
+                "type": "goal_reminder"
+            }
+
+        return None
+
+    def _check_conversation_milestone(self, context_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """
+        Check for conversation milestones (e.g., every 50 messages).
+        """
+        message_count = context_state.get("message_count", 0)
+
+        # Every 50 messages, offer summary
+        if message_count > 0 and message_count % 50 == 0:
+            return {
+                "suggestion": f"\n\n[Aside: We've exchanged {message_count} messages! Would you like a summary of our conversation?]",
+                "priority": 0.65,
+                "reason": f"Milestone: {message_count} messages",
+                "type": "summary"
+            }
+
+        return None
+
+    def _check_patterns(
+        self,
+        context_state: Dict[str, Any],
+        self_state: Dict[str, Any]
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Check for behavioral patterns that merit suggestions.
+        """
+        # Get current focus
+        focus = self_state.get("focus", "")
+
+        # Check if user keeps asking similar questions (detected via focus)
+        if focus and "repeated" in focus.lower():
+            return {
+                "suggestion": "\n\n[Aside: I notice we keep coming back to this topic. Would it help to create a summary or action plan?]",
+                "priority": 0.7,
+                "reason": "Repeated topic detected",
+                "type": "pattern"
+            }
+
+        # Check energy levels - if Lyra is low energy, maybe suggest break
+        energy = self_state.get("energy", 0.8)
+        if energy < 0.3:
+            return {
+                "suggestion": "\n\n[Aside: We've been at this for a while. Need a break or want to keep going?]",
+                "priority": 0.65,
+                "reason": f"Low energy ({energy:.2f})",
+                "type": "pattern"
+            }
+
+        return None
+
+    def format_suggestion(self, suggestion: Dict[str, Any]) -> str:
+        """
+        Format suggestion for appending to response.
+
+        Args:
+            suggestion: Suggestion dict from analyze_session()
+
+        Returns:
+            Formatted string to append to response
+        """
+        return suggestion.get("suggestion", "")
+
+    def set_cooldown_duration(self, seconds: int) -> None:
+        """
+        Update cooldown duration.
+
+        Args:
+            seconds: New cooldown duration
+        """
+        self.cooldown_seconds = seconds
+        logger.info(f"[PROACTIVE] Cooldown updated to {seconds}s")
+
+    def reset_cooldown(self, session_id: str) -> None:
+        """
+        Reset cooldown for a specific session.
+
+        Args:
+            session_id: Session to reset
+        """
+        if session_id in self.last_suggestion_time:
+            del self.last_suggestion_time[session_id]
+            logger.info(f"[PROACTIVE] Cooldown reset for session {session_id}")
+
+    def get_session_stats(self, session_id: str) -> Dict[str, Any]:
+        """
+        Get stats for a session's proactive monitoring.
+
+        Args:
+            session_id: Session to check
+
+        Returns:
+            {
+                "last_suggestion_time": timestamp or None,
+                "seconds_since_last": int,
+                "cooldown_active": bool,
+                "cooldown_remaining": int
+            }
+        """
+        last_time = self.last_suggestion_time.get(session_id)
+
+        if not last_time:
+            return {
+                "last_suggestion_time": None,
+                "seconds_since_last": 0,
+                "cooldown_active": False,
+                "cooldown_remaining": 0
+            }
+
+        seconds_since = int(time.time() - last_time)
+        cooldown_active = seconds_since < self.cooldown_seconds
+        cooldown_remaining = max(0, self.cooldown_seconds - seconds_since)
+
+        return {
+            "last_suggestion_time": last_time,
+            "seconds_since_last": seconds_since,
+            "cooldown_active": cooldown_active,
+            "cooldown_remaining": cooldown_remaining
+        }
+
+
+# Singleton instance
+_monitor_instance = None
+
+
+def get_proactive_monitor(min_priority: float = 0.6) -> ProactiveMonitor:
+    """
+    Get singleton proactive monitor instance.
+
+    Args:
+        min_priority: Minimum priority threshold (only used on first call)
+
+    Returns:
+        ProactiveMonitor instance
+    """
+    global _monitor_instance
+    if _monitor_instance is None:
+        _monitor_instance = ProactiveMonitor(min_priority=min_priority)
+    return _monitor_instance