claude-mpm 5.6.9__py3-none-any.whl → 5.6.11__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-5.6.9
+5.6.11

claude_mpm/agents/PM_INSTRUCTIONS.md

@@ -294,6 +294,8 @@ If you're about to run ANY other command, stop and delegate instead.
 - Grep (>1), Glob (investigation) → Delegate to research
 - `mcp__mcp-ticketer__*` → Delegate to ticketing
 - `mcp__chrome-devtools__*` → Delegate to web-qa
+- `mcp__claude-in-chrome__*` → Delegate to web-qa
+- `mcp__playwright__*` → Delegate to web-qa
 
 ## Agent Deployment Architecture
 
@@ -358,7 +360,7 @@ These are EXAMPLES of routing, not an exhaustive list. **Default to delegation f
 | **Research** | Understanding codebase, investigating approaches, analyzing files | Grep, Glob, Read multiple files, WebSearch | Investigation tools |
 | **Engineer** | Writing/modifying code, implementing features, refactoring | Edit, Write, codebase knowledge, testing workflows | - |
 | **Ops** (local-ops) | Deploying apps, managing infrastructure, starting servers, port/process management | Environment config, deployment procedures | Use `local-ops` for localhost/PM2/docker |
-| **QA** (web-qa, api-qa) | Testing implementations, verifying deployments, regression tests, browser testing | Playwright (web), fetch (APIs), verification protocols | For browser: use **web-qa** (never use chrome-devtools directly) |
+| **QA** (web-qa, api-qa) | Testing implementations, verifying deployments, regression tests, browser testing | Playwright (web), fetch (APIs), verification protocols | For browser: use **web-qa** (never use chrome-devtools, claude-in-chrome, or playwright directly) |
 | **Documentation** | Creating/updating docs, README, API docs, guides | Style consistency, organization standards | - |
 | **Ticketing** | ALL ticket operations (CRUD, search, hierarchy, comments) | Direct mcp-ticketer access | PM never uses `mcp__mcp-ticketer__*` directly |
 | **Version Control** | Creating PRs, managing branches, complex git ops | PR workflows, branch management | Check git user for main branch access (bobmatnyc@users.noreply.github.com only) |
@@ -728,7 +730,7 @@ Circuit breakers automatically detect and enforce delegation requirements. All c
 | 3 | Unverified Assertions | PM claiming status without agent evidence | Require verification evidence | [Details](#circuit-breaker-3-unverified-assertions) |
 | 4 | File Tracking | PM marking task complete without tracking new files | Run git tracking sequence | [Details](#circuit-breaker-4-file-tracking-enforcement) |
 | 5 | Delegation Chain | PM claiming completion without full workflow delegation | Execute missing phases | [Details](#circuit-breaker-5-delegation-chain) |
-| 6 | Forbidden Tool Usage | PM using ticketing/browser MCP tools directly | Delegate to specialist agent | [Details](#circuit-breaker-6-forbidden-tool-usage) |
+| 6 | Forbidden Tool Usage | PM using ticketing/browser MCP tools (ticketer, chrome-devtools, claude-in-chrome, playwright) directly | Delegate to specialist agent | [Details](#circuit-breaker-6-forbidden-tool-usage) |
 | 7 | Verification Commands | PM using curl/lsof/ps/wget/nc | Delegate to local-ops or QA | [Details](#circuit-breaker-7-verification-command-detection) |
 | 8 | QA Verification Gate | PM claiming work complete without QA delegation | BLOCK - Delegate to QA now | [Details](#circuit-breaker-8-qa-verification-gate) |
 | 9 | User Delegation | PM instructing user to run commands | Delegate to appropriate agent | [Details](#circuit-breaker-9-user-delegation-detection) |
@@ -747,6 +749,9 @@ Circuit breakers automatically detect and enforce delegation requirements. All c
 - "It works" / "It's deployed" → Circuit Breaker #3
 - Marks todo complete without `git status` → Circuit Breaker #4
 - Uses `mcp__mcp-ticketer__*` → Circuit Breaker #6
+- Uses `mcp__chrome-devtools__*` → Circuit Breaker #6
+- Uses `mcp__claude-in-chrome__*` → Circuit Breaker #6
+- Uses `mcp__playwright__*` → Circuit Breaker #6
 - Uses curl/lsof directly → Circuit Breaker #7
 - Claims complete without QA → Circuit Breaker #8
 - "You'll need to run..." → Circuit Breaker #9
@@ -782,7 +787,7 @@ When the user says "just do it" or "handle it", delegate to the full workflow pi
 
 When the user says "verify", "check", or "test", delegate to the QA agent with specific verification criteria.
 
-When the user mentions "browser", "screenshot", "click", "navigate", "DOM", "console errors", delegate to web-qa agent for browser testing (NEVER use chrome-devtools tools directly).
+When the user mentions "browser", "screenshot", "click", "navigate", "DOM", "console errors", "tabs", "window", delegate to web-qa agent for browser testing (NEVER use chrome-devtools, claude-in-chrome, or playwright tools directly).
 
 When the user mentions "localhost", "local server", or "PM2", delegate to **local-ops** as the primary choice for local development operations.
 

claude_mpm/commander/core/__init__.py

@@ -0,0 +1,10 @@
+"""Core coordination components for MPM Commander.
+
+This module provides core components that coordinate between different
+subsystems like events, work execution, and session management.
+"""
+
+from .block_manager import BlockManager
+from .response_manager import ResponseManager, ResponseRoute
+
+__all__ = ["BlockManager", "ResponseManager", "ResponseRoute"]

claude_mpm/commander/core/block_manager.py

@@ -0,0 +1,325 @@
+"""BlockManager for coordinating work blocking with events.
+
+This module provides BlockManager which automatically blocks/unblocks
+work items based on blocking event detection and resolution.
+"""
+
+import logging
+from typing import Dict, List, Optional, Set
+
+from ..events.manager import EventManager
+from ..models.events import Event
+from ..models.work import WorkState
+from ..work.executor import WorkExecutor
+from ..work.queue import WorkQueue
+
+logger = logging.getLogger(__name__)
+
+
+class BlockManager:
+    """Coordinates blocking events with work execution.
+
+    Monitors blocking events and automatically blocks/unblocks work items
+    based on event lifecycle. Tracks event-to-work relationships for precise
+    unblocking when events are resolved.
+
+    Attributes:
+        event_manager: EventManager for querying blocking events
+        work_queues: Dict mapping project_id -> WorkQueue
+        work_executors: Dict mapping project_id -> WorkExecutor
+
+    Example:
+        >>> manager = BlockManager(event_manager, work_queues, work_executors)
+        >>> blocked = await manager.check_and_block(event)
+        >>> unblocked = await manager.check_and_unblock(event_id)
+    """
+
+    def __init__(
+        self,
+        event_manager: EventManager,
+        work_queues: Dict[str, WorkQueue],
+        work_executors: Dict[str, WorkExecutor],
+    ):
+        """Initialize BlockManager.
+
+        Args:
+            event_manager: EventManager instance
+            work_queues: Dict mapping project_id -> WorkQueue
+            work_executors: Dict mapping project_id -> WorkExecutor
+
+        Raises:
+            ValueError: If any required parameter is None
+        """
+        if event_manager is None:
+            raise ValueError("EventManager cannot be None")
+        if work_queues is None:
+            raise ValueError("work_queues cannot be None")
+        if work_executors is None:
+            raise ValueError("work_executors cannot be None")
+
+        self.event_manager = event_manager
+        self.work_queues = work_queues
+        self.work_executors = work_executors
+
+        # Track event-to-work mapping: event_id -> set of work_ids
+        self._event_work_mapping: Dict[str, Set[str]] = {}
+
+        logger.debug("BlockManager initialized")
+
+    async def check_and_block(self, event: Event) -> List[str]:
+        """Check if event is blocking and block affected work.
+
+        When a blocking event is detected:
+        1. Determine blocking scope (project or all)
+        2. Find all in-progress work items in scope
+        3. Block each work item via WorkExecutor
+        4. Track event-to-work mapping for later unblocking
+
+        Args:
+            event: Event to check for blocking
+
+        Returns:
+            List of work item IDs that were blocked
+
+        Example:
+            >>> event = Event(type=EventType.ERROR, ...)
+            >>> blocked = await manager.check_and_block(event)
+            >>> print(f"Blocked {len(blocked)} work items")
+        """
+        if not event.is_blocking:
+            logger.debug("Event %s is not blocking, no action needed", event.id)
+            return []
+
+        logger.info(
+            "Processing blocking event %s (scope: %s): %s",
+            event.id,
+            event.blocking_scope,
+            event.title,
+        )
+
+        blocked_work_ids = []
+
+        # Determine which projects to block based on scope
+        if event.blocking_scope == "all":
+            # Block all projects
+            target_projects = list(self.work_queues.keys())
+            logger.info("Event %s blocks ALL projects", event.id)
+        elif event.blocking_scope == "project":
+            # Block only this project
+            target_projects = [event.project_id]
+            logger.info("Event %s blocks project %s only", event.id, event.project_id)
+        else:
+            logger.warning(
+                "Unknown blocking scope '%s' for event %s",
+                event.blocking_scope,
+                event.id,
+            )
+            return []
+
+        # Block in-progress work in target projects
+        for project_id in target_projects:
+            queue = self.work_queues.get(project_id)
+            if not queue:
+                logger.debug("No work queue for project %s", project_id)
+                continue
+
+            executor = self.work_executors.get(project_id)
+            if not executor:
+                logger.debug("No work executor for project %s", project_id)
+                continue
+
+            # Get in-progress work items
+            in_progress = queue.list(WorkState.IN_PROGRESS)
+
+            for work_item in in_progress:
+                # Block the work item
+                block_reason = f"Event {event.id}: {event.title}"
+                success = await executor.handle_block(work_item.id, block_reason)
+
+                if success:
+                    blocked_work_ids.append(work_item.id)
+                    logger.info(
+                        "Blocked work item %s for project %s: %s",
+                        work_item.id,
+                        project_id,
+                        block_reason,
+                    )
+                else:
+                    logger.warning(
+                        "Failed to block work item %s for project %s",
+                        work_item.id,
+                        project_id,
+                    )
+
+        # Track event-to-work mapping
+        if blocked_work_ids:
+            self._event_work_mapping[event.id] = set(blocked_work_ids)
+            logger.info(
+                "Event %s blocked %d work items: %s",
+                event.id,
+                len(blocked_work_ids),
+                blocked_work_ids,
+            )
+
+        return blocked_work_ids
+
+    async def check_and_unblock(self, event_id: str) -> List[str]:
+        """Unblock work items when event is resolved.
+
+        When a blocking event is resolved:
+        1. Look up which work items were blocked by this event
+        2. Unblock each work item via WorkExecutor
+        3. Remove event-to-work mapping
+
+        Args:
+            event_id: ID of resolved event
+
+        Returns:
+            List of work item IDs that were unblocked
+
+        Example:
+            >>> unblocked = await manager.check_and_unblock("evt_123")
+            >>> print(f"Unblocked {len(unblocked)} work items")
+        """
+        # Get work items blocked by this event
+        work_ids = self._event_work_mapping.pop(event_id, set())
+
+        if not work_ids:
+            logger.debug("No work items blocked by event %s", event_id)
+            return []
+
+        logger.info(
+            "Unblocking %d work items for resolved event %s", len(work_ids), event_id
+        )
+
+        unblocked_work_ids = []
+
+        # Unblock each work item
+        for work_id in work_ids:
+            # Find which project this work belongs to
+            project_id = self._find_work_project(work_id)
+            if not project_id:
+                logger.warning("Cannot find project for work item %s", work_id)
+                continue
+
+            executor = self.work_executors.get(project_id)
+            if not executor:
+                logger.warning("No executor for project %s", project_id)
+                continue
+
+            # Unblock the work item
+            success = await executor.handle_unblock(work_id)
+
+            if success:
+                unblocked_work_ids.append(work_id)
+                logger.info("Unblocked work item %s", work_id)
+            else:
+                logger.warning("Failed to unblock work item %s", work_id)
+
+        return unblocked_work_ids
+
+    def _find_work_project(self, work_id: str) -> Optional[str]:
+        """Find which project a work item belongs to.
+
+        Args:
+            work_id: Work item ID to search for
+
+        Returns:
+            Project ID if found, None otherwise
+        """
+        for project_id, queue in self.work_queues.items():
+            work_item = queue.get(work_id)
+            if work_item:
+                return project_id
+        return None
+
+    def get_blocked_work(self, event_id: str) -> Set[str]:
+        """Get work items blocked by a specific event.
+
+        Args:
+            event_id: Event ID to check
+
+        Returns:
+            Set of work item IDs blocked by this event
+
+        Example:
+            >>> work_ids = manager.get_blocked_work("evt_123")
+        """
+        return self._event_work_mapping.get(event_id, set()).copy()
+
+    def get_blocking_events(self, work_id: str) -> List[str]:
+        """Get events that are blocking a specific work item.
+
+        Args:
+            work_id: Work item ID to check
+
+        Returns:
+            List of event IDs blocking this work item
+
+        Example:
+            >>> events = manager.get_blocking_events("work-123")
+        """
+        blocking_events = []
+        for event_id, work_ids in self._event_work_mapping.items():
+            if work_id in work_ids:
+                blocking_events.append(event_id)
+        return blocking_events
+
+    def is_work_blocked(self, work_id: str) -> bool:
+        """Check if a work item is currently blocked.
+
+        Args:
+            work_id: Work item ID to check
+
+        Returns:
+            True if work item is blocked by any event, False otherwise
+
+        Example:
+            >>> if manager.is_work_blocked("work-123"):
+            ...     print("Work is blocked")
+        """
+        return len(self.get_blocking_events(work_id)) > 0
+
+    def clear_project_mappings(self, project_id: str) -> int:
+        """Clear all event-work mappings for a project.
+
+        Called when a project is shut down or reset.
+
+        Args:
+            project_id: Project ID to clear
+
+        Returns:
+            Number of work items that had mappings removed
+
+        Example:
+            >>> count = manager.clear_project_mappings("proj_123")
+        """
+        queue = self.work_queues.get(project_id)
+        if not queue:
+            return 0
+
+        # Get all work IDs for this project
+        all_work = queue.list()
+        project_work_ids = {w.id for w in all_work}
+
+        removed_count = 0
+
+        # Remove work items from event mappings
+        for event_id in list(self._event_work_mapping.keys()):
+            work_ids = self._event_work_mapping[event_id]
+            original_len = len(work_ids)
+
+            # Remove project work items
+            work_ids.difference_update(project_work_ids)
+
+            removed_count += original_len - len(work_ids)
+
+            # Remove empty mappings
+            if not work_ids:
+                del self._event_work_mapping[event_id]
+
+        logger.info(
+            "Cleared %d work item mappings for project %s", removed_count, project_id
+        )
+
+        return removed_count

claude_mpm/commander/core/response_manager.py

@@ -0,0 +1,323 @@
+"""ResponseManager for centralized response routing and validation.
+
+This module provides ResponseManager which handles response validation,
+routing, and delivery to runtime sessions.
+"""
+
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple
+
+from ..events.manager import EventManager
+from ..models.events import Event, EventType
+from ..runtime.executor import RuntimeExecutor
+
+logger = logging.getLogger(__name__)
+
+
+def _utc_now() -> datetime:
+    """Return current UTC time with timezone info."""
+    return datetime.now(timezone.utc)
+
+
+@dataclass
+class ResponseRoute:
+    """Encapsulates a validated response ready for delivery.
+
+    Attributes:
+        event: Event being responded to
+        response: User's response text
+        valid: Whether validation passed
+        validation_errors: List of validation error messages
+        timestamp: When the route was created
+        delivered: Whether response has been delivered
+        delivery_timestamp: When the response was delivered
+    """
+
+    event: Event
+    response: str
+    valid: bool
+    validation_errors: List[str] = field(default_factory=list)
+    timestamp: datetime = field(default_factory=_utc_now)
+    delivered: bool = False
+    delivery_timestamp: Optional[datetime] = None
+
+
+class ResponseManager:
+    """Centralizes response validation, routing, and delivery.
+
+    Provides centralized response handling with validation and routing
+    capabilities for event responses.
+
+    Attributes:
+        event_manager: EventManager for retrieving events
+        runtime_executor: Optional RuntimeExecutor for response delivery
+        _response_history: History of all response attempts per event
+
+    Example:
+        >>> manager = ResponseManager(event_manager, runtime_executor)
+        >>> valid, errors = manager.validate_response(event, "staging")
+        >>> if valid:
+        ...     route = manager.validate_and_route(event_id, "staging")
+        ...     success = await manager.deliver_response(route)
+    """
+
+    def __init__(
+        self,
+        event_manager: EventManager,
+        runtime_executor: Optional[RuntimeExecutor] = None,
+    ) -> None:
+        """Initialize ResponseManager.
+
+        Args:
+            event_manager: EventManager instance for retrieving events
+            runtime_executor: Optional RuntimeExecutor for response delivery
+
+        Raises:
+            ValueError: If event_manager is None
+        """
+        if event_manager is None:
+            raise ValueError("EventManager cannot be None")
+
+        self.event_manager = event_manager
+        self.runtime_executor = runtime_executor
+        self._response_history: Dict[str, List[ResponseRoute]] = {}
+
+        logger.debug(
+            "ResponseManager initialized (runtime_executor: %s)",
+            "enabled" if runtime_executor else "disabled",
+        )
+
+    def validate_response(self, event: Event, response: str) -> Tuple[bool, List[str]]:
+        """Validate response against event constraints.
+
+        Validation rules:
+        1. Empty responses: Not allowed for blocking events
+        2. DECISION_NEEDED options: Response must match one of the options
+        3. Response whitespace: Stripped before validation
+
+        Args:
+            event: Event being responded to
+            response: User's response
+
+        Returns:
+            Tuple of (is_valid, list_of_error_messages)
+
+        Example:
+            >>> valid, errors = manager.validate_response(event, "staging")
+            >>> if not valid:
+            ...     for error in errors:
+            ...         print(f"Validation error: {error}")
+        """
+        errors: List[str] = []
+
+        # Strip whitespace for validation
+        response_stripped = response.strip()
+
+        # Rule 1: Empty responses not allowed for blocking events
+        if event.is_blocking and not response_stripped:
+            errors.append("Response cannot be empty for blocking events")
+
+        # Rule 2: DECISION_NEEDED events must use one of the provided options
+        if event.type == EventType.DECISION_NEEDED and event.options:
+            if response_stripped not in event.options:
+                errors.append(
+                    f"Response must be one of: {', '.join(event.options)}. "
+                    f"Got: '{response_stripped}'"
+                )
+
+        # Future validation rules can be added here:
+        # - Max length check
+        # - Format validation (e.g., regex patterns)
+        # - Custom validators per event type
+        # - Conditional validation based on event context
+
+        is_valid = len(errors) == 0
+        return is_valid, errors
+
+    def validate_and_route(
+        self, event_id: str, response: str
+    ) -> Optional[ResponseRoute]:
+        """Create a validated ResponseRoute for an event.
+
+        Retrieves the event, validates the response, and creates a ResponseRoute
+        with validation results.
+
+        Args:
+            event_id: ID of event to respond to
+            response: User's response
+
+        Returns:
+            ResponseRoute with validation results, or None if event not found
+
+        Example:
+            >>> route = manager.validate_and_route("evt_123", "staging")
+            >>> if route and route.valid:
+            ...     await manager.deliver_response(route)
+            >>> elif route:
+            ...     print(f"Validation failed: {route.validation_errors}")
+        """
+        # Get the event
+        event = self.event_manager.get(event_id)
+        if not event:
+            logger.warning("Event not found: %s", event_id)
+            return None
+
+        # Validate response
+        valid, errors = self.validate_response(event, response)
+
+        # Create route
+        route = ResponseRoute(
+            event=event,
+            response=response,
+            valid=valid,
+            validation_errors=errors,
+        )
+
+        logger.debug(
+            "Created route for event %s: valid=%s, errors=%s",
+            event_id,
+            valid,
+            errors,
+        )
+
+        return route
+
+    async def deliver_response(self, route: ResponseRoute) -> bool:
+        """Deliver a validated response to the runtime.
+
+        Records the response in event history and attempts delivery to the
+        runtime executor if available.
+
+        Args:
+            route: ResponseRoute to deliver
+
+        Returns:
+            True if delivery successful, False otherwise
+
+        Raises:
+            ValueError: If route validation failed
+
+        Example:
+            >>> route = manager.validate_and_route("evt_123", "yes")
+            >>> if route and route.valid:
+            ...     success = await manager.deliver_response(route)
+            ...     if success:
+            ...         print("Response delivered successfully")
+        """
+        if not route.valid:
+            error_msg = "; ".join(route.validation_errors)
+            raise ValueError(f"Cannot deliver invalid response: {error_msg}")
+
+        # Mark route as delivered
+        route.delivered = True
+        route.delivery_timestamp = _utc_now()
+
+        # Track in history
+        self._add_to_history(route)
+
+        # For non-blocking events, no runtime delivery needed
+        if not route.event.is_blocking:
+            logger.debug(
+                "Event %s is non-blocking, no runtime delivery needed",
+                route.event.id,
+            )
+            return True
+
+        # Deliver to runtime if executor available
+        if not self.runtime_executor:
+            logger.warning(
+                "No runtime executor available, cannot deliver response for event %s",
+                route.event.id,
+            )
+            return False
+
+        # Note: Actual delivery is handled by EventHandler which has session context
+        # ResponseManager just validates and tracks responses
+        # The EventHandler will call executor.send_message() with session's active_pane
+        logger.info(
+            "Response validated and ready for delivery (event %s): %s",
+            route.event.id,
+            route.response[:50],
+        )
+        return True
+
+    def _add_to_history(self, route: ResponseRoute) -> None:
+        """Add response route to history tracking.
+
+        Args:
+            route: ResponseRoute to record
+        """
+        event_id = route.event.id
+        if event_id not in self._response_history:
+            self._response_history[event_id] = []
+
+        self._response_history[event_id].append(route)
+        logger.debug(
+            "Added response to history for event %s (total: %d)",
+            event_id,
+            len(self._response_history[event_id]),
+        )
+
+    def get_response_history(self, event_id: str) -> List[ResponseRoute]:
+        """Get all response attempts for an event (for audit trail).
+
+        Args:
+            event_id: Event ID to query
+
+        Returns:
+            List of ResponseRoute objects for this event (chronological order)
+
+        Example:
+            >>> history = manager.get_response_history("evt_123")
+            >>> for i, route in enumerate(history, 1):
+            ...     status = "valid" if route.valid else "invalid"
+            ...     print(f"Attempt {i} ({status}): {route.response}")
+        """
+        return self._response_history.get(event_id, []).copy()
+
+    def clear_history(self, event_id: str) -> int:
+        """Clear response history for an event.
+
+        Args:
+            event_id: Event ID to clear
+
+        Returns:
+            Number of history entries removed
+
+        Example:
+            >>> removed = manager.clear_history("evt_123")
+            >>> print(f"Cleared {removed} history entries")
+        """
+        history = self._response_history.pop(event_id, [])
+        count = len(history)
+        if count > 0:
+            logger.debug("Cleared %d history entries for event %s", count, event_id)
+        return count
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get statistics about response history.
+
+        Returns:
+            Dict with statistics about tracked responses
+
+        Example:
+            >>> stats = manager.get_stats()
+            >>> print(f"Total events with history: {stats['total_events']}")
+            >>> print(f"Total response attempts: {stats['total_responses']}")
+        """
+        total_events = len(self._response_history)
+        total_responses = sum(len(routes) for routes in self._response_history.values())
+        valid_responses = sum(
+            sum(1 for route in routes if route.valid)
+            for routes in self._response_history.values()
+        )
+        invalid_responses = total_responses - valid_responses
+
+        return {
+            "total_events": total_events,
+            "total_responses": total_responses,
+            "valid_responses": valid_responses,
+            "invalid_responses": invalid_responses,
+        }

claude_mpm/commander/daemon.py

@@ -15,12 +15,18 @@ from .api.app import (
     app,
 )
 from .config import DaemonConfig
+from .core.block_manager import BlockManager
 from .events.manager import EventManager
 from .inbox import Inbox
+from .parsing.output_parser import OutputParser
 from .persistence import EventStore, StateStore
 from .project_session import ProjectSession, SessionState
 from .registry import ProjectRegistry
+from .runtime.monitor import RuntimeMonitor
 from .tmux_orchestrator import TmuxOrchestrator
+from .work.executor import WorkExecutor
+from .work.queue import WorkQueue
+from .workflow.event_handler import EventHandler
 
 logger = logging.getLogger(__name__)
 
@@ -38,6 +44,11 @@ class CommanderDaemon:
         event_manager: Event manager
         inbox: Event inbox
         sessions: Active project sessions by project_id
+        work_queues: Work queues by project_id
+        work_executors: Work executors by project_id
+        block_manager: Block manager for automatic work blocking
+        runtime_monitor: Runtime monitor for output monitoring
+        event_handler: Event handler for blocking event workflow
         state_store: StateStore for project/session persistence
         event_store: EventStore for event queue persistence
         running: Whether daemon is currently running
@@ -68,6 +79,8 @@ class CommanderDaemon:
         self.event_manager = EventManager()
         self.inbox = Inbox(self.event_manager, self.registry)
         self.sessions: Dict[str, ProjectSession] = {}
+        self.work_queues: Dict[str, WorkQueue] = {}
+        self.work_executors: Dict[str, WorkExecutor] = {}
         self._running = False
         self._server_task: Optional[asyncio.Task] = None
         self._main_loop_task: Optional[asyncio.Task] = None
@@ -76,6 +89,30 @@ class CommanderDaemon:
         self.state_store = StateStore(config.state_dir)
         self.event_store = EventStore(config.state_dir)
 
+        # Initialize BlockManager with work queues and executors
+        self.block_manager = BlockManager(
+            event_manager=self.event_manager,
+            work_queues=self.work_queues,
+            work_executors=self.work_executors,
+        )
+
+        # Initialize RuntimeMonitor with BlockManager
+        parser = OutputParser(self.event_manager)
+        self.runtime_monitor = RuntimeMonitor(
+            orchestrator=self.orchestrator,
+            parser=parser,
+            event_manager=self.event_manager,
+            poll_interval=config.poll_interval,
+            block_manager=self.block_manager,
+        )
+
+        # Initialize EventHandler with BlockManager
+        self.event_handler = EventHandler(
+            inbox=self.inbox,
+            session_manager=self.sessions,
+            block_manager=self.block_manager,
+        )
+
         # Configure logging
         logging.basicConfig(
             level=getattr(logging, config.log_level.upper()),
@@ -171,6 +208,16 @@ class CommanderDaemon:
             except Exception as e:
                 logger.error(f"Error stopping session {project_id}: {e}")
 
+        # Clear BlockManager project mappings
+        for project_id in list(self.work_queues.keys()):
+            try:
+                removed = self.block_manager.clear_project_mappings(project_id)
+                logger.debug(
+                    f"Cleared {removed} work mappings for project {project_id}"
+                )
+            except Exception as e:
+                logger.error(f"Error clearing mappings for {project_id}: {e}")
+
         # Cancel main loop task
         if self._main_loop_task and not self._main_loop_task.done():
             self._main_loop_task.cancel()
@@ -282,7 +329,26 @@ class CommanderDaemon:
         if project is None:
             raise ValueError(f"Project not found: {project_id}")
 
-        session = ProjectSession(project, self.orchestrator)
+        # Create work queue for project if not exists
+        if project_id not in self.work_queues:
+            self.work_queues[project_id] = WorkQueue(project_id)
+            logger.debug(f"Created work queue for project {project_id}")
+
+        # Create work executor for project if not exists
+        if project_id not in self.work_executors:
+            from .runtime.executor import RuntimeExecutor
+
+            runtime_executor = RuntimeExecutor(self.orchestrator)
+            self.work_executors[project_id] = WorkExecutor(
+                runtime=runtime_executor, queue=self.work_queues[project_id]
+            )
+            logger.debug(f"Created work executor for project {project_id}")
+
+        session = ProjectSession(
+            project=project,
+            orchestrator=self.orchestrator,
+            monitor=self.runtime_monitor,
+        )
         self.sessions[project_id] = session
 
         logger.info(f"Created new session for project {project_id}")

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

@@ -155,7 +155,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 +164,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 +184,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-5.6.9.dist-info → claude_mpm-5.6.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.6.9
+Version: 5.6.11
 Summary: Claude Multi-Agent Project Manager - Orchestrate Claude with agent delegation and ticket tracking
 Author-email: Bob Matsuoka <bob@matsuoka.com>
 Maintainer: Claude MPM Team

{claude_mpm-5.6.9.dist-info → claude_mpm-5.6.11.dist-info}/RECORD

@@ -1,5 +1,5 @@
 claude_mpm/BUILD_NUMBER,sha256=9JfxhnDtr-8l3kCP2U5TVXSErptHoga8m7XA8zqgGOc,4
-claude_mpm/VERSION,sha256=nJST2g_21xhxfQk5QgAosXHOMTc1xwppJdB3d85to-g,6
+claude_mpm/VERSION,sha256=S81MrAwnIgULw4v1GrJed7APLxpXKTpjomdjKgbSLgo,7
 claude_mpm/__init__.py,sha256=AGfh00BHKvLYD-UVFw7qbKtl7NMRIzRXOWw7vEuZ-h4,2214
 claude_mpm/__main__.py,sha256=Ro5UBWBoQaSAIoSqWAr7zkbLyvi4sSy28WShqAhKJG0,723
 claude_mpm/constants.py,sha256=pz3lTrZZR5HhV3eZzYtIbtBwWo7iM6pkBHP_ixxmI6Y,6827
@@ -11,7 +11,7 @@ claude_mpm/agents/CLAUDE_MPM_OUTPUT_STYLE.md,sha256=C61nb8szGeeGaXQd9-VPpL1t79G2
 claude_mpm/agents/CLAUDE_MPM_RESEARCH_OUTPUT_STYLE.md,sha256=OIVDU0Ypw5qrXix9rmMDG4u0V4ePnYDlsu5AoTmfZzs,13294
 claude_mpm/agents/CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md,sha256=vneNW5vHjfKsRIukkuGbAnvnyp_-EC3qpFzHDdsMOwc,4796
 claude_mpm/agents/MEMORY.md,sha256=V1mGx5oEaLdN9AYLX3Xetslmr2Ja6vnLPATeEoR6bvw,3303
-claude_mpm/agents/PM_INSTRUCTIONS.md,sha256=S4xzeFlMSfBRbzu1zJzcpB7jC04Bh4yVs_ZRK7gBhRc,34728
+claude_mpm/agents/PM_INSTRUCTIONS.md,sha256=4rhuCHW18GsdGJbXlMS-QOxL1sZmuWyMALDKAlRlGrM,35132
 claude_mpm/agents/WORKFLOW.md,sha256=jKs3V9RUrE1Tn5_CtwZGKRDSUBgD6USaCBxAnxv3-Zc,3487
 claude_mpm/agents/__init__.py,sha256=3cCQh2Hf_-2F9XDT5In533Bw7oKuGIqZvOdBW7af6dY,3403
 claude_mpm/agents/agent-template.yaml,sha256=mRlz5Yd0SmknTeoJWgFkZXzEF5T7OmGBJGs2-KPT93k,1969
@@ -154,7 +154,7 @@ claude_mpm/cli_module/migration_example.py,sha256=DtQ59RyoBD6r8FIfrjKXCQ8-xnUiOq
 claude_mpm/commander/__init__.py,sha256=8NjmTnvUzWm_UrTunHj3Gt3PFUq0XNtNj1o1p1puiTo,2186
 claude_mpm/commander/config.py,sha256=b9HUNN7LY8tHU4XkLzpuoVdHUZcgC-3by39fRYOg32Q,1583
 claude_mpm/commander/config_loader.py,sha256=H2ASh19-Nu1Ej4_ojhuIQMU9fR4sMHTsA8fiXocoosE,3736
-claude_mpm/commander/daemon.py,sha256=xQQzcJCTNGT3XqHn_Yi8MReALzOJW09TfqI43yVPHTQ,13429
+claude_mpm/commander/daemon.py,sha256=6cD5KFx97CetYxusC-oGpdYnBaHPz7PejRv4VI4L66U,16186
 claude_mpm/commander/instance_manager.py,sha256=H37wjQkeeIQV5l-0q_ycDk1theU3eT1gg3b-Lbncirw,10790
 claude_mpm/commander/project_session.py,sha256=z_vhKcvla8WPmXS1MBl-Iki6oFxNug-YUdHMm15r6H0,9356
 claude_mpm/commander/registry.py,sha256=WcPUgZQnCWahrYvl_8GL8xvgikhlPjyJihylhWCIyvc,12878
@@ -178,6 +178,9 @@ claude_mpm/commander/chat/__init__.py,sha256=5Iiya2YPkF54OvtZgL4NNT0zp5PCsZnnE7D
 claude_mpm/commander/chat/cli.py,sha256=mHWEXjDll7OFIi2frTwfMs0wnJ71aFkFHX3vJr_iEGM,3151
 claude_mpm/commander/chat/commands.py,sha256=0Lvc4XT1k-0gpmLxhzgwVNw7IXc40kgZ9YqTVF0vxxk,2440
 claude_mpm/commander/chat/repl.py,sha256=c7Qi4qBg32b-JQyBKSNGadSWmmUrU7vBpFOkCV94QwU,10999
+claude_mpm/commander/core/__init__.py,sha256=BVtJoH9hn9LtlmtqPBybPowbPfiKNaNgtotLV82JRQk,357
+claude_mpm/commander/core/block_manager.py,sha256=UhjzH59eezWWdTLECVhiq7gFVI2LofeJx52wBoLMZV4,10725
+claude_mpm/commander/core/response_manager.py,sha256=hOciRaiOmi-MFimaOUyyH0UCKfrIqcnTA_z2iisiTGE,10921
 claude_mpm/commander/events/__init__.py,sha256=NtUCo8eQfX4D3G9I2U10SRuuU4zMEIySKZGPxyUELzw,478
 claude_mpm/commander/events/manager.py,sha256=T-gXJ6DWIodxTdfFLv3u4kuks2ilJLjtlBZnmCkRSDA,10352
 claude_mpm/commander/frameworks/__init__.py,sha256=tOdMc4XNASVDrhpIPA1e7FKtNM7GQW5AEZXXW5NJK9I,280
@@ -213,16 +216,16 @@ claude_mpm/commander/proxy/output_handler.py,sha256=eIbz6KstcxmOUM42dKDQ5LibdcXw
 claude_mpm/commander/proxy/relay.py,sha256=8ma4e8OLpCKx8rG5YgfhH4NMRWayLaRpBLgKVQ0NH9s,5029
 claude_mpm/commander/runtime/__init__.py,sha256=0n-bPme0BlApM5ElXI-Qcbt5RqB8tiYbtvUHBjcBcyo,325
 claude_mpm/commander/runtime/executor.py,sha256=7o_CVSeKEM5UZ85eL2jhKByKMB_kRxDl0YE4yhhU4cU,6654
-claude_mpm/commander/runtime/monitor.py,sha256=yX2sabcXqwr7AgHJqfBoP7xrsxkSgojiXdL6DGzzlhY,10866
+claude_mpm/commander/runtime/monitor.py,sha256=C4QROkmARkZ-gh_cELLf-pLI8U-3_gqJuTnpytnybvw,12500
 claude_mpm/commander/session/__init__.py,sha256=MfKCDPGqEZdM_MuQm3GM3OuqiigQMpgPKTL8rM7Fm68,177
 claude_mpm/commander/session/context.py,sha256=_P6VbFFjLSETxOgNDVCxhfCAdP3zeIbW7qxZk51nIwM,2405
 claude_mpm/commander/session/manager.py,sha256=RiCq2zAUFGURtmyiYP8NTb447dvBIG65GhX4uQa_KO0,1675
 claude_mpm/commander/web/__init__.py,sha256=QStUHljiyh5KUycukpjtX08O0HxA9e_6_hhVZybNBRo,39
 claude_mpm/commander/work/__init__.py,sha256=XuOjTHv0dZPQwOg3NOnmNLW4pM1PWKr03egIUWeaOH8,962
-claude_mpm/commander/work/executor.py,sha256=5FewUKBYYBRIEtS-AcaOdroRhLLPrRUFkXdTpz_5ZZM,6123
+claude_mpm/commander/work/executor.py,sha256=JVAlqWk9E6xkslQofc9gTxMxU5nBZtnhrNCaFQOxfF4,6369
 claude_mpm/commander/work/queue.py,sha256=GrfNRhY8uaxzZ6Q3I0YjjCqssQOKx-oyREdIKV2mvjQ,11895
 claude_mpm/commander/workflow/__init__.py,sha256=_eLy6z3rUj99gINqVHf0abapw8miyKRqgT3j7DAM0ZM,933
-claude_mpm/commander/workflow/event_handler.py,sha256=vWrbeQt-1GNMm9i4x5lQ2oAlw5pF8Q7NVZYi83im1pY,7448
+claude_mpm/commander/workflow/event_handler.py,sha256=BO8kKAOJRpmY5OfibHID4fkvgqL46jUnDzJknhnE3YE,8285
 claude_mpm/commander/workflow/notifier.py,sha256=-XpR9ioRQeGn2bre4i8lMk5zFEMs_a5PIiD3DEkp_-I,4330
 claude_mpm/commands/__init__.py,sha256=paX5Ub5-UmRgiQ8UgKWIKwU2-RjLu67OmNJND-fVtjg,588
 claude_mpm/commands/mpm-config.md,sha256=GMQIsXSzKUmaIpfrohBUA7d4lga4JfYDxJqgqYQV7uM,960
@@ -1109,10 +1112,10 @@ claude_mpm/utils/subprocess_utils.py,sha256=D0izRT8anjiUb_JG72zlJR_JAw1cDkb7kalN
 claude_mpm/validation/__init__.py,sha256=YZhwE3mhit-lslvRLuwfX82xJ_k4haZeKmh4IWaVwtk,156
 claude_mpm/validation/agent_validator.py,sha256=GprtAvu80VyMXcKGsK_VhYiXWA6BjKHv7O6HKx0AB9w,20917
 claude_mpm/validation/frontmatter_validator.py,sha256=YpJlYNNYcV8u6hIOi3_jaRsDnzhbcQpjCBE6eyBKaFY,7076
-claude_mpm-5.6.9.dist-info/licenses/LICENSE,sha256=ca3y_Rk4aPrbF6f62z8Ht5MJM9OAvbGlHvEDcj9vUQ4,3867
-claude_mpm-5.6.9.dist-info/licenses/LICENSE-FAQ.md,sha256=TxfEkXVCK98RzDOer09puc7JVCP_q_bN4dHtZKHCMcM,5104
-claude_mpm-5.6.9.dist-info/METADATA,sha256=zFOkKrO7QsszgLAusCpXjQiG-wsHRWCsCsxOIYntIL0,14983
-claude_mpm-5.6.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-claude_mpm-5.6.9.dist-info/entry_points.txt,sha256=n-Uk4vwHPpuvu-g_I7-GHORzTnN_m6iyOsoLveKKD0E,228
-claude_mpm-5.6.9.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
-claude_mpm-5.6.9.dist-info/RECORD,,
+claude_mpm-5.6.11.dist-info/licenses/LICENSE,sha256=ca3y_Rk4aPrbF6f62z8Ht5MJM9OAvbGlHvEDcj9vUQ4,3867
+claude_mpm-5.6.11.dist-info/licenses/LICENSE-FAQ.md,sha256=TxfEkXVCK98RzDOer09puc7JVCP_q_bN4dHtZKHCMcM,5104
+claude_mpm-5.6.11.dist-info/METADATA,sha256=sTUt9uZf2xCDms1yhicNEuEdsHI9kHzMdNnIUv_c4jg,14984
+claude_mpm-5.6.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+claude_mpm-5.6.11.dist-info/entry_points.txt,sha256=n-Uk4vwHPpuvu-g_I7-GHORzTnN_m6iyOsoLveKKD0E,228
+claude_mpm-5.6.11.dist-info/top_level.txt,sha256=1nUg3FEaBySgm8t-s54jK5zoPnu3_eY6EP6IOlekyHA,11
+claude_mpm-5.6.11.dist-info/RECORD,,