claude-mpm 4.18.0__py3-none-any.whl → 4.20.0__py3-none-any.whl

claude_mpm/core/config.py

@@ -578,6 +578,11 @@ class Config:
                     "[PM-REMINDER] Your role is coordination and management",
                 ],
             },
+            # Session management configuration
+            "session": {
+                "auto_save": True,  # Enable automatic session saving
+                "save_interval": 300,  # Auto-save interval in seconds (5 minutes)
+            },
         }
 
         # Apply defaults for missing keys
@@ -588,6 +593,9 @@ class Config:
         # Validate health and recovery configuration
         self._validate_health_recovery_config()
 
+        # Validate session configuration
+        self._validate_session_config()
+
     def get(self, key: str, default: Any = None) -> Any:
         """Get configuration value."""
         # Support nested keys with dot notation
@@ -764,6 +772,40 @@ class Config:
         except Exception as e:
             logger.error(f"Error validating health/recovery configuration: {e}")
 
+    def _validate_session_config(self) -> None:
+        """Validate session management configuration."""
+        try:
+            session_config = self.get("session", {})
+
+            # Validate save_interval range (60-1800 seconds)
+            save_interval = session_config.get("save_interval", 300)
+            if not isinstance(save_interval, int):
+                logger.warning(
+                    f"Session save_interval must be integer, got {type(save_interval).__name__}, using default 300"
+                )
+                self.set("session.save_interval", 300)
+            elif save_interval < 60:
+                logger.warning(
+                    f"Session save_interval must be at least 60 seconds, got {save_interval}, using 60"
+                )
+                self.set("session.save_interval", 60)
+            elif save_interval > 1800:
+                logger.warning(
+                    f"Session save_interval must be at most 1800 seconds (30 min), got {save_interval}, using 1800"
+                )
+                self.set("session.save_interval", 1800)
+
+            # Validate auto_save is boolean
+            auto_save = session_config.get("auto_save", True)
+            if not isinstance(auto_save, bool):
+                logger.warning(
+                    f"Session auto_save must be boolean, got {type(auto_save).__name__}, using True"
+                )
+                self.set("session.auto_save", True)
+
+        except Exception as e:
+            logger.error(f"Error validating session configuration: {e}")
+
     def get_health_monitoring_config(self) -> Dict[str, Any]:
         """Get health monitoring configuration with defaults."""
         base_config = {

claude_mpm/hooks/__init__.py

@@ -12,6 +12,11 @@ from .failure_learning import (
 from .kuzu_enrichment_hook import KuzuEnrichmentHook, get_kuzu_enrichment_hook
 from .kuzu_memory_hook import KuzuMemoryHook, get_kuzu_memory_hook
 from .kuzu_response_hook import KuzuResponseHook, get_kuzu_response_hook
+from .session_resume_hook import (
+    SessionResumeStartupHook,
+    get_session_resume_hook,
+    trigger_session_resume_check,
+)
 
 __all__ = [
     "BaseHook",
@@ -24,10 +29,13 @@ __all__ = [
     "KuzuMemoryHook",
     "KuzuResponseHook",
     "LearningExtractionHook",
+    "SessionResumeStartupHook",
     "get_failure_detection_hook",
     "get_fix_detection_hook",
     "get_kuzu_enrichment_hook",
     "get_kuzu_memory_hook",
     "get_kuzu_response_hook",
     "get_learning_extraction_hook",
+    "get_session_resume_hook",
+    "trigger_session_resume_check",
 ]

claude_mpm/hooks/session_resume_hook.py

@@ -0,0 +1,121 @@
+"""Session Resume Startup Hook.
+
+WHY: This hook automatically checks for paused sessions on PM startup and displays
+resume context to help users continue their work seamlessly.
+
+DESIGN DECISIONS:
+- Runs automatically on PM startup
+- Non-blocking: doesn't prevent PM from starting if check fails
+- Displays context to stdout for user visibility
+- Integrates with existing session pause/resume infrastructure
+"""
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from claude_mpm.core.logger import get_logger
+from claude_mpm.services.cli.session_resume_helper import SessionResumeHelper
+
+logger = get_logger(__name__)
+
+
+class SessionResumeStartupHook:
+    """Hook for automatic session resume detection on PM startup."""
+
+    def __init__(self, project_path: Optional[Path] = None):
+        """Initialize the session resume hook.
+
+        Args:
+            project_path: Project root path (default: current directory)
+        """
+        self.project_path = project_path or Path.cwd()
+        self.resume_helper = SessionResumeHelper(self.project_path)
+        self._session_displayed = False
+
+    def on_pm_startup(self) -> Optional[Dict[str, Any]]:
+        """Execute on PM startup to check for paused sessions.
+
+        Returns:
+            Session data if paused session found, None otherwise
+        """
+        try:
+            # Check if we already displayed a session in this process
+            if self._session_displayed:
+                logger.debug("Session already displayed, skipping")
+                return None
+
+            # Check for paused sessions
+            session_data = self.resume_helper.check_and_display_resume_prompt()
+
+            if session_data:
+                self._session_displayed = True
+                logger.info("Paused session context displayed to user")
+
+            return session_data
+
+        except Exception as e:
+            logger.error(f"Failed to check for paused sessions: {e}", exc_info=True)
+            return None
+
+    def get_session_count(self) -> int:
+        """Get count of paused sessions.
+
+        Returns:
+            Number of paused sessions
+        """
+        try:
+            return self.resume_helper.get_session_count()
+        except Exception as e:
+            logger.error(f"Failed to get session count: {e}")
+            return 0
+
+    def clear_displayed_session(self, session_data: Dict[str, Any]) -> bool:
+        """Clear a session after it has been displayed and user has acknowledged.
+
+        Args:
+            session_data: Session data to clear
+
+        Returns:
+            True if successfully cleared, False otherwise
+        """
+        try:
+            return self.resume_helper.clear_session(session_data)
+        except Exception as e:
+            logger.error(f"Failed to clear session: {e}")
+            return False
+
+
+# Global hook instance
+_session_resume_hook: Optional[SessionResumeStartupHook] = None
+
+
+def get_session_resume_hook(
+    project_path: Optional[Path] = None,
+) -> SessionResumeStartupHook:
+    """Get or create the global session resume hook instance.
+
+    Args:
+        project_path: Project root path (default: current directory)
+
+    Returns:
+        SessionResumeStartupHook instance
+    """
+    global _session_resume_hook
+
+    if _session_resume_hook is None:
+        _session_resume_hook = SessionResumeStartupHook(project_path)
+        logger.debug("Created session resume hook instance")
+
+    return _session_resume_hook
+
+
+def trigger_session_resume_check() -> Optional[Dict[str, Any]]:
+    """Trigger a session resume check (convenience function).
+
+    This is the main entry point for PM startup integration.
+
+    Returns:
+        Session data if found, None otherwise
+    """
+    hook = get_session_resume_hook()
+    return hook.on_pm_startup()

claude_mpm/services/agents/deployment/agent_validator.py

@@ -329,10 +329,26 @@ class AgentValidator:
             "type": "agent",  # Default type
         }
 
-        # Extract from YAML frontmatter
+        # Extract ONLY from YAML frontmatter (between --- markers)
         lines = content.split("\n")
+        in_frontmatter = False
+        frontmatter_ended = False
+
         for line in lines:
             stripped_line = line.strip()
+
+            # Track frontmatter boundaries
+            if stripped_line == "---":
+                if not in_frontmatter:
+                    in_frontmatter = True
+                    continue
+                frontmatter_ended = True
+                break  # Stop parsing after frontmatter ends
+
+            # Only parse within frontmatter
+            if not in_frontmatter or frontmatter_ended:
+                continue
+
             if stripped_line.startswith("name:"):
                 agent_info["name"] = stripped_line.split(":", 1)[1].strip().strip("\"'")
             elif stripped_line.startswith("description:"):