claude-mpm 5.6.10__py3-none-any.whl → 5.6.17__py3-none-any.whl

claude_mpm/commander/runtime/monitor.py

@@ -6,13 +6,16 @@ and detects events using OutputParser.
 
 import asyncio
 import logging
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..events.manager import EventManager
 from ..models.events import Event
 from ..parsing.output_parser import OutputParser
 from ..tmux_orchestrator import TmuxOrchestrator
 
+if TYPE_CHECKING:
+    from ..core.block_manager import BlockManager
+
 logger = logging.getLogger(__name__)
 
 
@@ -44,6 +47,7 @@ class RuntimeMonitor:
         event_manager: EventManager,
         poll_interval: float = 2.0,
         capture_lines: int = 1000,
+        block_manager: Optional["BlockManager"] = None,
     ):
         """Initialize runtime monitor.
 
@@ -53,6 +57,7 @@ class RuntimeMonitor:
             event_manager: EventManager for emitting events
             poll_interval: Seconds between polls (default: 2.0)
             capture_lines: Number of lines to capture (default: 1000)
+            block_manager: Optional BlockManager for automatic work blocking
 
         Raises:
             ValueError: If any required parameter is None
@@ -69,15 +74,17 @@ class RuntimeMonitor:
         self.event_manager = event_manager
         self.poll_interval = poll_interval
         self.capture_lines = capture_lines
+        self.block_manager = block_manager
 
         # Track active monitors: pane_target -> (project_id, task, last_output_hash)
         self._monitors: Dict[str, tuple[str, Optional[asyncio.Task], int]] = {}
         self._running = False
 
         logger.debug(
-            "RuntimeMonitor initialized (interval: %.2fs, lines: %d)",
+            "RuntimeMonitor initialized (interval: %.2fs, lines: %d, block_manager: %s)",
             poll_interval,
             capture_lines,
+            "enabled" if block_manager else "disabled",
         )
 
     async def start_monitoring(self, pane_target: str, project_id: str) -> None:
@@ -284,6 +291,29 @@ class RuntimeMonitor:
                         pane_target,
                     )
 
+                    # Automatically block work for blocking events
+                    if self.block_manager:
+                        for parse_result in parse_results:
+                            # Get the created event from EventManager
+                            # Events are created with matching titles, so find by title
+                            pending_events = self.event_manager.get_pending(project_id)
+                            for event in pending_events:
+                                if (
+                                    event.title == parse_result.title
+                                    and event.is_blocking
+                                ):
+                                    blocked_work = (
+                                        await self.block_manager.check_and_block(event)
+                                    )
+                                    if blocked_work:
+                                        logger.info(
+                                            "Event %s blocked %d work items: %s",
+                                            event.id,
+                                            len(blocked_work),
+                                            blocked_work,
+                                        )
+                                    break
+
             except Exception as e:
                 logger.error(
                     "Error in monitor loop for pane %s: %s",

claude_mpm/commander/work/executor.py

@@ -51,16 +51,19 @@ class WorkExecutor:
 
         logger.debug(f"Initialized WorkExecutor for project {queue.project_id}")
 
-    async def execute_next(self) -> bool:
+    async def execute_next(self, pane_target: Optional[str] = None) -> bool:
         """Execute next available work item.
 
         Gets next work from queue, starts it, and executes via RuntimeExecutor.
 
+        Args:
+            pane_target: Optional tmux pane target for execution
+
         Returns:
             True if work was executed, False if queue empty/blocked
 
         Example:
-            >>> executed = await executor.execute_next()
+            >>> executed = await executor.execute_next("%5")
             >>> if not executed:
             ...     print("No work available")
         """
@@ -71,10 +74,12 @@ class WorkExecutor:
             return False
 
         # Execute the work item
-        await self.execute(work_item)
+        await self.execute(work_item, pane_target)
         return True
 
-    async def execute(self, work_item: WorkItem) -> None:
+    async def execute(
+        self, work_item: WorkItem, pane_target: Optional[str] = None
+    ) -> None:
         """Execute a specific work item.
 
         Marks work as IN_PROGRESS and sends to RuntimeExecutor.
@@ -83,12 +88,13 @@ class WorkExecutor:
 
         Args:
             work_item: WorkItem to execute
+            pane_target: Optional tmux pane target for execution
 
         Raises:
             RuntimeError: If execution fails
 
         Example:
-            >>> await executor.execute(work_item)
+            >>> await executor.execute(work_item, "%5")
         """
         # Mark as in progress
         if not self.queue.start(work_item.id):
@@ -103,17 +109,21 @@ class WorkExecutor:
         )
 
         try:
-            # Send work content to runtime
-            # Note: In actual implementation, this would integrate with
-            # ProjectSession which manages the pane_target
-            # For now, we assume runtime has active session
-            # This will be properly integrated when wiring with ProjectSession
+            # Send work content to runtime if pane target provided
+            if pane_target:
+                await self.runtime.send_message(pane_target, work_item.content)
+                logger.info(
+                    f"Work item {work_item.id} sent to pane {pane_target} for execution"
+                )
+            else:
+                logger.warning(
+                    f"No pane target provided for work item {work_item.id}, "
+                    f"work marked as in-progress but not sent to runtime"
+                )
 
             # Store work item ID in metadata for callback tracking
             work_item.metadata["execution_started"] = True
 
-            logger.info(f"Work item {work_item.id} sent to runtime for execution")
-
         except Exception as e:
             logger.error(f"Failed to execute work item {work_item.id}: {e}")
             await self.handle_failure(work_item.id, str(e))
@@ -155,7 +165,7 @@ class WorkExecutor:
         else:
             logger.warning(f"Failed to mark work item {work_id} as failed")
 
-    async def handle_block(self, work_id: str, reason: str) -> None:
+    async def handle_block(self, work_id: str, reason: str) -> bool:
         """Handle work being blocked by an event.
 
         Called when RuntimeMonitor detects a blocking event.
@@ -164,15 +174,19 @@ class WorkExecutor:
             work_id: Work item ID that is blocked
             reason: Reason for blocking (e.g., "Waiting for approval")
 
+        Returns:
+            True if work was successfully blocked, False otherwise
+
         Example:
-            >>> await executor.handle_block("work-123", "Decision needed")
+            >>> success = await executor.handle_block("work-123", "Decision needed")
         """
         if self.queue.block(work_id, reason):
             logger.info(f"Work item {work_id} blocked: {reason}")
-        else:
-            logger.warning(f"Failed to mark work item {work_id} as blocked")
+            return True
+        logger.warning(f"Failed to mark work item {work_id} as blocked")
+        return False
 
-    async def handle_unblock(self, work_id: str) -> None:
+    async def handle_unblock(self, work_id: str) -> bool:
         """Handle work being unblocked after event resolution.
 
         Called when EventHandler resolves a blocking event.
@@ -180,10 +194,14 @@ class WorkExecutor:
         Args:
             work_id: Work item ID to unblock
 
+        Returns:
+            True if work was successfully unblocked, False otherwise
+
         Example:
-            >>> await executor.handle_unblock("work-123")
+            >>> success = await executor.handle_unblock("work-123")
         """
         if self.queue.unblock(work_id):
             logger.info(f"Work item {work_id} unblocked, resuming execution")
-        else:
-            logger.warning(f"Failed to unblock work item {work_id}")
+            return True
+        logger.warning(f"Failed to unblock work item {work_id}")
+        return False

claude_mpm/commander/workflow/event_handler.py

@@ -5,12 +5,15 @@ user input and coordinates session pause/resume.
 """
 
 import logging
-from typing import Dict, List, Optional
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 from ..inbox import Inbox
 from ..models.events import BLOCKING_EVENTS, Event, EventStatus
 from ..project_session import ProjectSession
 
+if TYPE_CHECKING:
+    from ..core.block_manager import BlockManager
+
 logger = logging.getLogger(__name__)
 
 
@@ -32,13 +35,17 @@ class EventHandler:
     """
 
     def __init__(
-        self, inbox: Inbox, session_manager: Dict[str, ProjectSession]
+        self,
+        inbox: Inbox,
+        session_manager: Dict[str, ProjectSession],
+        block_manager: Optional["BlockManager"] = None,
     ) -> None:
         """Initialize event handler.
 
         Args:
             inbox: Inbox instance for event access
             session_manager: Dict mapping project_id -> ProjectSession
+            block_manager: Optional BlockManager for automatic work unblocking
 
         Raises:
             ValueError: If inbox or session_manager is None
@@ -51,8 +58,12 @@ class EventHandler:
         self.inbox = inbox
         self.session_manager = session_manager
         self._event_manager = inbox.events
+        self.block_manager = block_manager
 
-        logger.debug("EventHandler initialized")
+        logger.debug(
+            "EventHandler initialized (block_manager: %s)",
+            "enabled" if block_manager else "disabled",
+        )
 
     async def process_event(self, event: Event) -> None:
         """Process an event - pause session if blocking.
@@ -137,6 +148,17 @@ class EventHandler:
         # Mark event as resolved
         self._event_manager.respond(event_id, response)
 
+        # Automatically unblock work items if BlockManager is available
+        if self.block_manager and was_blocking:
+            unblocked_work = await self.block_manager.check_and_unblock(event_id)
+            if unblocked_work:
+                logger.info(
+                    "Event %s resolution unblocked %d work items: %s",
+                    event_id,
+                    len(unblocked_work),
+                    unblocked_work,
+                )
+
         # If event was NOT blocking, no need to resume
         if not was_blocking:
             logger.debug("Event %s was non-blocking, no resume needed", event_id)

claude_mpm/core/claude_runner.py

@@ -1,5 +1,7 @@
 """Claude runner with both exec and subprocess launch methods."""
 
+import hashlib
+import json
 import os
 from pathlib import Path
 from typing import Optional
@@ -211,9 +213,137 @@ class ClaudeRunner:
                 }
             )
 
+    def _get_deployment_state_path(self) -> Path:
+        """Get path to deployment state file."""
+        return Path.cwd() / ".claude-mpm" / "deployment-state.json"
+
+    def _calculate_deployment_hash(self, agents_dir: Path) -> str:
+        """Calculate hash of all agent files for change detection.
+
+        Args:
+            agents_dir: Directory containing agent .md files
+
+        Returns:
+            SHA256 hash of agent file contents
+        """
+        if not agents_dir.exists():
+            return ""
+
+        # Get all .md files sorted for consistent hashing
+        agent_files = sorted(agents_dir.glob("*.md"))
+
+        hash_obj = hashlib.sha256()
+        for agent_file in agent_files:
+            # Include filename and content in hash
+            hash_obj.update(agent_file.name.encode())
+            try:
+                hash_obj.update(agent_file.read_bytes())
+            except Exception as e:
+                self.logger.debug(f"Error reading {agent_file} for hash: {e}")
+
+        return hash_obj.hexdigest()
+
+    def _check_deployment_state(self) -> bool:
+        """Check if agents are already deployed and up-to-date.
+
+        Returns:
+            True if agents are already deployed and match current version, False otherwise
+        """
+        state_file = self._get_deployment_state_path()
+        agents_dir = Path.cwd() / ".claude" / "agents"
+
+        # If state file doesn't exist, need to deploy
+        if not state_file.exists():
+            return False
+
+        # If agents directory doesn't exist, need to deploy
+        if not agents_dir.exists():
+            return False
+
+        try:
+            # Load deployment state
+            state_data = json.loads(state_file.read_text())
+
+            # Get current version from package
+            from claude_mpm import __version__
+
+            # Check if version matches
+            if state_data.get("version") != __version__:
+                self.logger.debug(
+                    f"Version mismatch: {state_data.get('version')} != {__version__}"
+                )
+                return False
+
+            # Check if agent count and hash match
+            current_hash = self._calculate_deployment_hash(agents_dir)
+            stored_hash = state_data.get("deployment_hash", "")
+
+            if current_hash != stored_hash:
+                self.logger.debug("Agent deployment hash mismatch")
+                return False
+
+            # All checks passed - agents are already deployed
+            agent_count = state_data.get("agent_count", 0)
+            self.logger.debug(
+                f"Agents already deployed: {agent_count} agents (v{__version__})"
+            )
+            return True
+
+        except Exception as e:
+            self.logger.debug(f"Error checking deployment state: {e}")
+            return False
+
+    def _save_deployment_state(self, agent_count: int) -> None:
+        """Save current deployment state.
+
+        Args:
+            agent_count: Number of agents deployed
+        """
+        state_file = self._get_deployment_state_path()
+        agents_dir = Path.cwd() / ".claude" / "agents"
+
+        try:
+            import time
+
+            from claude_mpm import __version__
+
+            # Calculate deployment hash
+            deployment_hash = self._calculate_deployment_hash(agents_dir)
+
+            # Create state data
+            state_data = {
+                "version": __version__,
+                "agent_count": agent_count,
+                "deployment_hash": deployment_hash,
+                "deployed_at": time.time(),
+            }
+
+            # Ensure directory exists
+            state_file.parent.mkdir(parents=True, exist_ok=True)
+
+            # Write state file
+            state_file.write_text(json.dumps(state_data, indent=2))
+            self.logger.debug(f"Saved deployment state: {agent_count} agents")
+
+        except Exception as e:
+            self.logger.debug(f"Error saving deployment state: {e}")
+
     def setup_agents(self) -> bool:
         """Deploy native agents to .claude/agents/."""
         try:
+            # Check if agents are already deployed and up-to-date
+            if self._check_deployment_state():
+                agents_dir = Path.cwd() / ".claude" / "agents"
+                agent_count = len(list(agents_dir.glob("*.md")))
+                print(f"✓ Agents: {agent_count} cached")
+                if self.project_logger:
+                    self.project_logger.log_system(
+                        f"Agents already deployed: {agent_count} cached",
+                        level="INFO",
+                        component="deployment",
+                    )
+                return True
+
             if self.project_logger:
                 self.project_logger.log_system(
                     "Starting agent deployment", level="INFO", component="deployment"
@@ -239,6 +369,12 @@ class ClaudeRunner:
 
                 # Set Claude environment
                 self.deployment_service.set_claude_environment()
+
+                # Save deployment state for future runs
+                agents_dir = Path.cwd() / ".claude" / "agents"
+                total_agents = len(list(agents_dir.glob("*.md")))
+                self._save_deployment_state(total_agents)
+
                 return True
             self.logger.info("All agents already up to date")
             if self.project_logger:
@@ -247,6 +383,13 @@ class ClaudeRunner:
                     level="INFO",
                     component="deployment",
                 )
+
+            # Save deployment state even if no changes
+            agents_dir = Path.cwd() / ".claude" / "agents"
+            if agents_dir.exists():
+                total_agents = len(list(agents_dir.glob("*.md")))
+                self._save_deployment_state(total_agents)
+
             return True
 
         except PermissionError as e:

claude_mpm/core/output_style_manager.py

@@ -297,6 +297,9 @@ class OutputStyleManager:
             target_path = style_config["target"]
             style_name = style_config["name"]
 
+            # Check if this is a fresh install (file doesn't exist yet)
+            is_fresh_install = not target_path.exists()
+
             # If content not provided, read from source
             if content is None:
                 content = self.extract_output_style_content(style=style)
@@ -310,7 +313,9 @@ class OutputStyleManager:
 
             # Activate the style if requested
             if activate:
-                self._activate_output_style(style_name)
+                self._activate_output_style(
+                    style_name, is_fresh_install=is_fresh_install
+                )
 
             return True
 
@@ -318,12 +323,21 @@ class OutputStyleManager:
             self.logger.error(f"Failed to deploy {style} style: {e}")
             return False
 
-    def _activate_output_style(self, style_name: str = "Claude MPM") -> bool:
+    def _activate_output_style(
+        self, style_name: str = "Claude MPM", is_fresh_install: bool = False
+    ) -> bool:
         """
         Update Claude Code settings to activate a specific output style.
 
+        Only activates the style if:
+        1. No active style is currently set (first deployment), OR
+        2. This is a fresh install (style file didn't exist before deployment)
+
+        This preserves user preferences if they've manually changed their active style.
+
         Args:
             style_name: Name of the style to activate (e.g., "Claude MPM", "Claude MPM Teacher")
+            is_fresh_install: Whether this is a fresh install (style file didn't exist before)
 
         Returns:
             True if activated successfully, False otherwise
@@ -342,8 +356,12 @@ class OutputStyleManager:
             # Check current active style
             current_style = settings.get("activeOutputStyle")
 
-            # Update active output style if different
-            if current_style != style_name:
+            # Only set activeOutputStyle if:
+            # 1. No active style is set (first deployment), OR
+            # 2. This is a fresh install (file didn't exist before deployment)
+            should_activate = current_style is None or is_fresh_install
+
+            if should_activate and current_style != style_name:
                 settings["activeOutputStyle"] = style_name
 
                 # Ensure settings directory exists
@@ -358,7 +376,10 @@ class OutputStyleManager:
                     f"✅ Activated {style_name} output style (was: {current_style or 'none'})"
                 )
             else:
-                self.logger.debug(f"{style_name} output style already active")
+                self.logger.debug(
+                    f"Preserving user preference: {current_style or 'none'} "
+                    f"(skipping activation of {style_name})"
+                )
 
             return True
 
@@ -452,6 +473,10 @@ class OutputStyleManager:
         """
         results: Dict[str, bool] = {}
 
+        # Check if professional style exists BEFORE deployment
+        # This determines if this is a fresh install
+        professional_style_existed = self.styles["professional"]["target"].exists()
+
         for style_type_key in self.styles:
             # Deploy without activation
             # Cast is safe because we know self.styles keys are OutputStyleType
@@ -459,9 +484,11 @@ class OutputStyleManager:
             success = self.deploy_output_style(style=style_type, activate=False)
             results[style_type] = success
 
-        # Activate the default style if requested
+        # Activate the default style if requested AND this is first deployment
         if activate_default and results.get("professional", False):
-            self._activate_output_style("Claude MPM")
+            self._activate_output_style(
+                "Claude MPM", is_fresh_install=not professional_style_existed
+            )
 
         return results
 

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -126,6 +126,15 @@ class EventHandlers:
             # Response tracking is optional - silently continue if it fails
             pass
 
+        # Record user message for auto-pause if active
+        auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+        if auto_pause and auto_pause.is_pause_active():
+            try:
+                auto_pause.on_user_message(prompt)
+            except Exception as e:
+                if DEBUG:
+                    _log(f"Auto-pause user message recording error: {e}")
+
         # Emit normalized event (namespace no longer needed with normalized events)
         self.hook_handler._emit_socketio_event("", "user_prompt", prompt_data)
 
@@ -603,6 +612,19 @@ class EventHandlers:
                     if DEBUG:
                         _log(f"Auto-pause error in handle_stop_fast: {e}")
 
+                # Finalize pause session if active
+                try:
+                    if auto_pause.is_pause_active():
+                        session_file = auto_pause.on_session_end()
+                        if session_file:
+                            if DEBUG:
+                                _log(
+                                    f"✅ Auto-pause session finalized: {session_file.name}"
+                                )
+                except Exception as e:
+                    if DEBUG:
+                        _log(f"❌ Failed to finalize auto-pause session: {e}")
+
         # Track response if enabled
         try:
             rtm = getattr(self.hook_handler, "response_tracking_manager", None)

claude_mpm/skills/__init__.py

@@ -24,7 +24,7 @@ Legacy System (maintained for compatibility):
 from .agent_skills_injector import AgentSkillsInjector
 
 # Legacy System (maintained for compatibility)
-from .registry import Skill, SkillsRegistry, get_registry
+from .registry import Skill, SkillsRegistry, get_registry, validate_agentskills_spec
 from .skill_manager import SkillManager
 from .skills_registry import SkillsRegistry as SkillsRegistryHelper
 from .skills_service import SkillsService
@@ -39,4 +39,5 @@ __all__ = [
     # New Skills Integration System
     "SkillsService",
     "get_registry",
+    "validate_agentskills_spec",
 ]