claude-mpm 5.6.4__py3-none-any.whl → 5.6.30__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/config/skill_sources.py

@@ -54,6 +54,7 @@ class SkillSource:
         branch: Git branch to use (default: "main")
         priority: Priority for skill resolution (lower = higher precedence)
         enabled: Whether this source should be synced
+        token: Optional GitHub token or env var reference (e.g., "$MY_TOKEN")
 
     Priority System:
         - 0: Reserved for system repository (highest precedence)
@@ -61,6 +62,12 @@ class SkillSource:
         - 100-999: Normal priority custom sources
         - 1000+: Low priority custom sources
 
+    Token Authentication:
+        - Direct token: "ghp_xxxxx" (stored in config, not recommended)
+        - Env var reference: "$PRIVATE_REPO_TOKEN" (resolved at runtime)
+        - If None, falls back to GITHUB_TOKEN or GH_TOKEN env vars
+        - Priority: source.token > GITHUB_TOKEN > GH_TOKEN
+
     Example:
         >>> source = SkillSource(
         ...     id="system",
@@ -70,6 +77,12 @@ class SkillSource:
         ... )
         >>> source.validate()
         []
+        >>> private_source = SkillSource(
+        ...     id="private",
+        ...     type="git",
+        ...     url="https://github.com/myorg/private-skills",
+        ...     token="$PRIVATE_REPO_TOKEN"
+        ... )
     """
 
     id: str
@@ -78,6 +91,7 @@ class SkillSource:
     branch: str = "main"
     priority: int = 100
     enabled: bool = True
+    token: Optional[str] = None
 
     def __post_init__(self):
         """Validate skill source configuration after initialization.
@@ -262,6 +276,7 @@ class SkillSourceConfiguration:
                         branch=source_data.get("branch", "main"),
                         priority=source_data.get("priority", 100),
                         enabled=source_data.get("enabled", True),
+                        token=source_data.get("token"),
                     )
                     sources.append(source)
                 except (KeyError, ValueError) as e:
@@ -326,6 +341,7 @@ class SkillSourceConfiguration:
                     "branch": source.branch,
                     "priority": source.priority,
                     "enabled": source.enabled,
+                    **({"token": source.token} if source.token else {}),
                 }
                 for source in sources
             ]

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,146 @@ class ClaudeRunner:
                 }
             )
 
+    def _get_deployment_state_path(self) -> Path:
+        """Get path to deployment state file.
+
+        CRITICAL: Must match path used by startup.py::_save_deployment_state_after_reconciliation()
+        Located at: .claude-mpm/cache/deployment_state.json
+        """
+        return Path.cwd() / ".claude-mpm" / "cache" / "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:
+            # SIMPLE CHECK: If agents already exist from reconciliation, skip deployment
+            # This ensures reconciliation's user-configured agents are never overwritten
+            agents_dir = Path.cwd() / ".claude" / "agents"
+            if agents_dir.exists():
+                existing_agents = list(agents_dir.glob("*.md"))
+                if len(existing_agents) > 0:
+                    # Reconciliation already deployed agents - skip
+                    self.logger.debug(
+                        f"Skipping setup_agents: {len(existing_agents)} agents already deployed by reconciliation"
+                    )
+                    if self.project_logger:
+                        self.project_logger.log_system(
+                            f"Agents already deployed via reconciliation: {len(existing_agents)} agents",
+                            level="DEBUG",
+                            component="deployment",
+                        )
+                    return True
+
             if self.project_logger:
                 self.project_logger.log_system(
                     "Starting agent deployment", level="INFO", component="deployment"
@@ -239,6 +378,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 +392,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/config.py

@@ -12,11 +12,10 @@ import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-import yaml
-
 from claude_mpm.core.logging_utils import get_logger
 
-from ..utils.config_manager import ConfigurationManager
+# Lazy import ConfigurationManager to avoid importing yaml at module level
+# This prevents hook errors when yaml isn't available in the execution environment
 from .exceptions import ConfigurationError, FileOperationError
 from .unified_paths import get_path_manager
 
@@ -104,6 +103,9 @@ class Config:
             Config._initialized = True
             logger.debug("Initializing Config singleton for the first time")
 
+            # Lazy import ConfigurationManager at runtime to avoid yaml import at module level
+            from ..utils.config_manager import ConfigurationManager
+
             # Initialize instance variables inside the lock to ensure thread safety
             self._config: Dict[str, Any] = {}
             self._env_prefix = env_prefix
@@ -224,21 +226,6 @@ class Config:
                             f"Response logging format: {response_logging.get('format', 'json')}"
                         )
 
-        except yaml.YAMLError as e:
-            logger.error(f"YAML syntax error in {file_path}: {e}")
-            if hasattr(e, "problem_mark"):
-                mark = e.problem_mark
-                logger.error(f"Error at line {mark.line + 1}, column {mark.column + 1}")
-            logger.info(
-                "TIP: Validate your YAML at https://www.yamllint.com/ or run: python scripts/validate_configuration.py"
-            )
-            logger.info(
-                "TIP: Common issue - YAML requires spaces, not tabs. Fix with: sed -i '' 's/\t/    /g' "
-                + str(file_path)
-            )
-            # Store error for later retrieval
-            self._config["_load_error"] = str(e)
-
         except json.JSONDecodeError as e:
             logger.error(f"JSON syntax error in {file_path}: {e}")
             logger.error(f"Error at line {e.lineno}, column {e.colno}")
@@ -255,7 +242,28 @@ class Config:
                 },
             ) from e
         except Exception as e:
-            # Catch any remaining unexpected errors and wrap them as configuration errors
+            # Handle YAML errors without importing yaml at module level
+            # ConfigurationManager.load_yaml raises yaml.YAMLError, but we don't want to import yaml
+            # Check if it's a YAML error by class name to avoid import
+            if e.__class__.__name__ == "YAMLError":
+                logger.error(f"YAML syntax error in {file_path}: {e}")
+                if hasattr(e, "problem_mark"):
+                    mark = e.problem_mark
+                    logger.error(
+                        f"Error at line {mark.line + 1}, column {mark.column + 1}"
+                    )
+                logger.info(
+                    "TIP: Validate your YAML at https://www.yamllint.com/ or run: python scripts/validate_configuration.py"
+                )
+                logger.info(
+                    "TIP: Common issue - YAML requires spaces, not tabs. Fix with: sed -i '' 's/\t/    /g' "
+                    + str(file_path)
+                )
+                # Store error for later retrieval
+                self._config["_load_error"] = str(e)
+                return  # Don't re-raise, we handled it
+
+            # Not a YAML error, wrap as configuration error
             raise ConfigurationError(
                 f"Unexpected error loading configuration from {file_path}: {e}",
                 context={
@@ -491,7 +499,7 @@ class Config:
             # Socket.IO server health and recovery configuration
             "socketio_server": {
                 "host": "localhost",
-                "port": 8765,
+                "port": 8768,  # Default SocketIO port (from network_config.NetworkPorts)
                 "enable_health_monitoring": True,
                 "enable_recovery": True,
                 "health_monitoring": {
@@ -532,7 +540,7 @@ class Config:
             # Monitor server configuration (decoupled from dashboard)
             "monitor_server": {
                 "host": "localhost",
-                "port": 8765,  # Default monitor port (shared with dashboard)
+                "port": 8765,  # Default monitor port (from network_config.NetworkPorts.MONITOR_DEFAULT)
                 "enable_health_monitoring": True,
                 "auto_start": False,  # Don't auto-start with dashboard by default
                 "event_buffer_size": 2000,  # Larger buffer for monitor server
@@ -541,7 +549,7 @@ class Config:
             # Dashboard server configuration (connects to monitor)
             "dashboard_server": {
                 "host": "localhost",
-                "port": 8765,  # Dashboard UI port
+                "port": 8767,  # Dashboard UI port (from network_config.NetworkPorts.DASHBOARD_DEFAULT)
                 "monitor_host": "localhost",  # Monitor server host to connect to
                 "monitor_port": 8765,  # Monitor server port to connect to
                 "auto_connect_monitor": True,  # Automatically connect to monitor