claude-mpm 5.6.1__py3-none-any.whl → 5.6.76__py3-none-any.whl

claude_mpm/commander/daemon.py

@@ -15,12 +15,23 @@ from .api.app import (
     app,
 )
 from .config import DaemonConfig
+from .core.block_manager import BlockManager
+from .env_loader import load_env
 from .events.manager import EventManager
 from .inbox import Inbox
+from .models.events import EventStatus
+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
+
+# Load environment variables at module import
+load_env()
 
 logger = logging.getLogger(__name__)
 
@@ -38,6 +49,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 +84,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 +94,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()),
@@ -122,12 +164,16 @@ class CommanderDaemon:
         # Set up signal handlers
         self._setup_signal_handlers()
 
-        # Inject global instances into API app
-        global api_registry, api_tmux, api_event_manager, api_inbox
-        api_registry = self.registry
-        api_tmux = self.orchestrator
-        api_event_manager = self.event_manager
-        api_inbox = self.inbox
+        # Inject daemon instances into API app.state (BEFORE lifespan runs)
+        app.state.registry = self.registry
+        app.state.tmux = self.orchestrator
+        app.state.event_manager = self.event_manager
+        app.state.inbox = self.inbox
+        app.state.work_queues = self.work_queues
+        app.state.daemon_instance = self
+        app.state.session_manager = self.sessions
+        app.state.event_handler = self.event_handler
+        logger.info(f"Injected work_queues dict id: {id(self.work_queues)}")
 
         # Start API server in background
         logger.info(f"Starting API server on {self.config.host}:{self.config.port}")
@@ -171,6 +217,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()
@@ -210,9 +266,19 @@ class CommanderDaemon:
 
         while self._running:
             try:
-                # TODO: Check for resolved events and resume sessions (Phase 2 Sprint 3)
-                # TODO: Check each ProjectSession for runnable work (Phase 2 Sprint 2)
-                # TODO: Spawn RuntimeExecutors for new work items (Phase 2 Sprint 1)
+                logger.info(f"🔄 Main loop iteration (running={self._running})")
+                logger.info(
+                    f"work_queues dict id: {id(self.work_queues)}, keys: {list(self.work_queues.keys())}"
+                )
+
+                # Check for resolved events and resume sessions
+                await self._check_and_resume_sessions()
+
+                # Check each ProjectSession for runnable work
+                logger.info(
+                    f"Checking for pending work across {len(self.work_queues)} queues"
+                )
+                await self._execute_pending_work()
 
                 # Periodic state persistence
                 current_time = asyncio.get_event_loop().time()
@@ -241,7 +307,16 @@ class CommanderDaemon:
 
         Registers handlers for SIGINT and SIGTERM that trigger
         daemon shutdown via asyncio event loop.
+
+        Note: Signal handlers can only be registered from the main thread.
+        If called from a background thread, registration is skipped.
         """
+        import threading
+
+        # Signal handlers can only be registered from the main thread
+        if threading.current_thread() is not threading.main_thread():
+            logger.info("Running in background thread - signal handlers skipped")
+            return
 
         def handle_signal(signum: int, frame) -> None:
             """Handle shutdown signal.
@@ -282,7 +357,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}")
@@ -363,6 +457,117 @@ class CommanderDaemon:
         except Exception as e:
             logger.error(f"Failed to save state: {e}", exc_info=True)
 
+    async def _check_and_resume_sessions(self) -> None:
+        """Check for resolved events and resume paused sessions.
+
+        Iterates through all paused sessions, checks if their blocking events
+        have been resolved, and resumes execution if ready.
+        """
+        for project_id, session in list(self.sessions.items()):
+            # Skip non-paused sessions
+            if session.state != SessionState.PAUSED:
+                continue
+
+            # Check if pause reason (event ID) is resolved
+            if not session.pause_reason:
+                logger.warning(f"Session {project_id} paused with no reason, resuming")
+                await session.resume()
+                continue
+
+            # Check if event is resolved
+            event = self.event_manager.get(session.pause_reason)
+            if event and event.status == EventStatus.RESOLVED:
+                logger.info(
+                    f"Event {event.id} resolved, resuming session for {project_id}"
+                )
+                await session.resume()
+
+                # Unblock any work items that were blocked by this event
+                if project_id in self.work_executors:
+                    executor = self.work_executors[project_id]
+                    queue = self.work_queues[project_id]
+
+                    # Find work items blocked by this event
+                    blocked_items = [
+                        item
+                        for item in queue.list()
+                        if item.state.value == "blocked"
+                        and item.metadata.get("block_reason") == event.id
+                    ]
+
+                    for item in blocked_items:
+                        await executor.handle_unblock(item.id)
+                        logger.info(f"Unblocked work item {item.id}")
+
+    async def _execute_pending_work(self) -> None:
+        """Execute pending work for all ready sessions.
+
+        Scans all work queues for pending work. For projects with work but no session,
+        auto-creates a session. Then executes the next available work item via WorkExecutor.
+        """
+        # First pass: Auto-create and start sessions for projects with pending work
+        for project_id, queue in list(self.work_queues.items()):
+            logger.info(
+                f"Checking queue for {project_id}: pending={queue.pending_count}"
+            )
+            # Skip if no pending work
+            if queue.pending_count == 0:
+                continue
+
+            # Auto-create session if needed
+            if project_id not in self.sessions:
+                try:
+                    logger.info(
+                        f"Auto-creating session for project {project_id} with pending work"
+                    )
+                    session = self.get_or_create_session(project_id)
+
+                    # Start the session so it's ready for work
+                    if session.state.value == "idle":
+                        logger.info(f"Auto-starting session for {project_id}")
+                        await session.start()
+                except Exception as e:
+                    logger.error(
+                        f"Failed to auto-create/start session for {project_id}: {e}",
+                        exc_info=True,
+                    )
+                    continue
+
+        # Second pass: Execute work for ready sessions
+        for project_id, session in list(self.sessions.items()):
+            # Skip sessions that aren't ready for work
+            if not session.is_ready():
+                continue
+
+            # Skip if no work queue exists
+            if project_id not in self.work_queues:
+                continue
+
+            # Get work executor for project
+            executor = self.work_executors.get(project_id)
+            if not executor:
+                logger.warning(
+                    f"No work executor found for project {project_id}, skipping"
+                )
+                continue
+
+            # Check if there's work available
+            queue = self.work_queues[project_id]
+            if queue.pending_count == 0:
+                continue
+
+            # Try to execute next work item
+            try:
+                # Pass the session's active pane for execution
+                executed = await executor.execute_next(pane_target=session.active_pane)
+                if executed:
+                    logger.info(f"Started work execution for project {project_id}")
+            except Exception as e:
+                logger.error(
+                    f"Error executing work for project {project_id}: {e}",
+                    exc_info=True,
+                )
+
 
 async def main(config: Optional[DaemonConfig] = None) -> None:
     """Main entry point for running the daemon.

claude_mpm/commander/env_loader.py

@@ -0,0 +1,59 @@
+"""Environment variable loader for Commander.
+
+This module handles automatic loading of .env and .env.local files
+at Commander startup. Environment files are loaded with the following precedence:
+1. Existing environment variables (not overridden)
+2. .env.local (local overrides)
+3. .env (defaults)
+
+Example:
+    >>> from claude_mpm.commander.env_loader import load_env
+    >>> load_env()
+    # Automatically loads .env.local and .env from project root
+"""
+
+import logging
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+logger = logging.getLogger(__name__)
+
+
+def load_env() -> None:
+    """Load environment variables from .env and .env.local files.
+
+    Searches for .env and .env.local in the project root directory
+    (parent of src/claude_mpm). Files are loaded with override=False,
+    meaning existing environment variables take precedence.
+
+    Precedence (highest to lowest):
+    1. Existing environment variables
+    2. .env.local
+    3. .env
+
+    Example:
+        >>> load_env()
+        # Loads .env.local and .env if they exist
+    """
+    # Find project root (parent of src/claude_mpm)
+    # Current file: src/claude_mpm/commander/env_loader.py
+    # Project root: ../../../ (3 levels up)
+    current_file = Path(__file__)
+    project_root = current_file.parent.parent.parent.parent
+
+    # Try loading .env.local first (higher priority)
+    env_local = project_root / ".env.local"
+    if env_local.exists():
+        load_dotenv(env_local, override=False)
+        logger.debug(f"Loaded environment from {env_local}")
+
+    # Then load .env (lower priority)
+    env_file = project_root / ".env"
+    if env_file.exists():
+        load_dotenv(env_file, override=False)
+        logger.debug(f"Loaded environment from {env_file}")
+
+    # Log if neither file exists
+    if not env_local.exists() and not env_file.exists():
+        logger.debug("No .env or .env.local files found in project root")

claude_mpm/commander/events/manager.py

@@ -3,11 +3,13 @@
 Manages event lifecycle, inbox queries, and project event tracking.
 """
 
+import asyncio
 import logging
 import threading
 import uuid
+from asyncio import Queue
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 from ..models.events import (
     DEFAULT_PRIORITIES,
@@ -48,6 +50,8 @@ class EventManager:
         self._events: Dict[str, Event] = {}
         self._project_index: Dict[str, List[str]] = {}  # project_id -> event_ids
         self._lock = threading.RLock()
+        self._subscribers: Dict[EventType, List[Callable]] = {}
+        self._event_queue: Queue = Queue()
 
     def create(
         self,
@@ -330,3 +334,59 @@ class EventManager:
             for eid in event_ids:
                 self._events.pop(eid, None)
             return len(event_ids)
+
+    def subscribe(self, event_type: EventType, callback: Callable) -> None:
+        """Subscribe callback to event type.
+
+        Args:
+            event_type: Type of event to subscribe to
+            callback: Function to call when event occurs (sync or async)
+
+        Example:
+            def on_error(event):
+                print(f"Error: {event.title}")
+
+            manager.subscribe(EventType.ERROR, on_error)
+        """
+        if event_type not in self._subscribers:
+            self._subscribers[event_type] = []
+        self._subscribers[event_type].append(callback)
+
+    def unsubscribe(self, event_type: EventType, callback: Callable) -> None:
+        """Unsubscribe callback from event type.
+
+        Args:
+            event_type: Type of event to unsubscribe from
+            callback: Function to remove from subscribers
+
+        Example:
+            manager.unsubscribe(EventType.ERROR, on_error)
+        """
+        if (
+            event_type in self._subscribers
+            and callback in self._subscribers[event_type]
+        ):
+            self._subscribers[event_type].remove(callback)
+
+    async def emit(self, event: Event) -> None:
+        """Emit event to all subscribers.
+
+        Queues the event and notifies all subscribed callbacks.
+        Supports both sync and async callbacks.
+
+        Args:
+            event: Event to emit
+
+        Example:
+            await manager.emit(event)
+        """
+        await self._event_queue.put(event)
+        if event.type in self._subscribers:
+            for callback in self._subscribers[event.type]:
+                try:
+                    if asyncio.iscoroutinefunction(callback):
+                        await callback(event)
+                    else:
+                        callback(event)
+                except Exception as e:
+                    logger.error(f"Subscriber callback error: {e}")

claude_mpm/commander/frameworks/base.py

@@ -19,6 +19,7 @@ class InstanceInfo:
         pane_target: Tmux pane target (e.g., "%1")
         git_branch: Current git branch if project is a git repo
         git_status: Git status summary if project is a git repo
+        connected: Whether instance has an active adapter connection
 
     Example:
         >>> info = InstanceInfo(
@@ -28,7 +29,8 @@ class InstanceInfo:
         ...     tmux_session="mpm-commander",
         ...     pane_target="%1",
         ...     git_branch="main",
-        ...     git_status="clean"
+        ...     git_status="clean",
+        ...     connected=True
         ... )
     """
 
@@ -39,6 +41,94 @@ class InstanceInfo:
     pane_target: str
     git_branch: Optional[str] = None
     git_status: Optional[str] = None
+    connected: bool = False
+    ready: bool = False
+
+
+@dataclass
+class RegisteredInstance:
+    """Persistent instance configuration (survives daemon restart).
+
+    Attributes:
+        name: Instance identifier
+        path: Original project directory path (stored as string for JSON)
+        framework: Framework identifier ("cc" or "mpm")
+        registered_at: ISO timestamp when instance was registered
+        worktree_path: Path to git worktree (if using worktree isolation)
+        worktree_branch: Branch name in the worktree
+        use_worktree: Whether worktree isolation is enabled
+
+    Example:
+        >>> instance = RegisteredInstance(
+        ...     name="myapp",
+        ...     path="/Users/user/myapp",
+        ...     framework="cc",
+        ...     registered_at="2024-01-15T10:30:00"
+        ... )
+        >>> instance.to_dict()
+        {'name': 'myapp', 'path': '/Users/user/myapp', 'framework': 'cc', ...}
+        >>> instance.working_path
+        '/Users/user/myapp'
+
+        >>> # With worktree enabled
+        >>> instance = RegisteredInstance(
+        ...     name="myapp",
+        ...     path="/Users/user/myapp",
+        ...     framework="cc",
+        ...     registered_at="2024-01-15T10:30:00",
+        ...     worktree_path="/Users/user/.mpm/worktrees/myapp",
+        ...     worktree_branch="feature/new-feature",
+        ...     use_worktree=True
+        ... )
+        >>> instance.working_path
+        '/Users/user/.mpm/worktrees/myapp'
+    """
+
+    name: str
+    path: str  # Original project path
+    framework: str
+    registered_at: str
+    # Worktree fields
+    worktree_path: Optional[str] = None  # Path to worktree (if using)
+    worktree_branch: Optional[str] = None  # Branch in worktree
+    use_worktree: bool = False  # Whether worktree is enabled
+
+    def to_dict(self) -> dict:
+        """Serialize for JSON storage."""
+        return {
+            "name": self.name,
+            "path": self.path,
+            "framework": self.framework,
+            "registered_at": self.registered_at,
+            "worktree_path": self.worktree_path,
+            "worktree_branch": self.worktree_branch,
+            "use_worktree": self.use_worktree,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "RegisteredInstance":
+        """Deserialize from JSON."""
+        return cls(
+            name=data["name"],
+            path=data["path"],
+            framework=data["framework"],
+            registered_at=data.get("registered_at", ""),
+            worktree_path=data.get("worktree_path"),
+            worktree_branch=data.get("worktree_branch"),
+            use_worktree=data.get("use_worktree", False),
+        )
+
+    @property
+    def working_path(self) -> str:
+        """Get the actual working path (worktree or original).
+
+        Returns:
+            The worktree path if worktree is enabled and configured,
+            otherwise the original project path.
+        """
+        if self.use_worktree and self.worktree_path:
+            return self.worktree_path
+        return self.path
 
 
 class BaseFramework(ABC):

claude_mpm/commander/frameworks/mpm.py

@@ -10,9 +10,7 @@ from .base import BaseFramework
 class MPMFramework(BaseFramework):
     """Claude MPM framework.
 
-    This framework launches Claude with MPM agent loading via CLAUDE.md.
-    It uses the same 'claude' command as Claude Code, but relies on CLAUDE.md
-    in the project to load the MPM agent system.
+    This framework launches Claude MPM with full agent orchestration.
 
     Example:
         >>> framework = MPMFramework()
@@ -21,42 +19,39 @@ class MPMFramework(BaseFramework):
         >>> framework.is_available()
         True
         >>> framework.get_startup_command(Path("/Users/user/myapp"))
-        "cd '/Users/user/myapp' && claude --dangerously-skip-permissions"
+        "cd '/Users/user/myapp' && claude-mpm"
     """
 
     name = "mpm"
     display_name = "Claude MPM"
-    command = "claude"  # Uses claude with MPM agent loading
+    command = "claude-mpm"
 
     def get_startup_command(self, project_path: Path) -> str:
         """Get the command to start Claude MPM in a project.
 
-        The MPM framework uses the standard 'claude' command, but expects
-        a CLAUDE.md file in the project to load the MPM agent system.
-
         Args:
             project_path: Path to the project directory
 
         Returns:
-            Shell command string to start Claude with MPM
+            Shell command string to start Claude MPM
 
         Example:
             >>> framework = MPMFramework()
             >>> framework.get_startup_command(Path("/Users/user/myapp"))
-            "cd '/Users/user/myapp' && claude --dangerously-skip-permissions"
+            "cd '/Users/user/myapp' && claude-mpm"
         """
         quoted_path = shlex.quote(str(project_path))
-        return f"cd {quoted_path} && claude --dangerously-skip-permissions"
+        return f"cd {quoted_path} && claude-mpm"
 
     def is_available(self) -> bool:
-        """Check if 'claude' command is available.
+        """Check if 'claude-mpm' command is available.
 
         Returns:
-            True if 'claude' command exists in PATH
+            True if 'claude-mpm' command exists in PATH
 
         Example:
             >>> framework = MPMFramework()
             >>> framework.is_available()
             True
         """
-        return shutil.which("claude") is not None
+        return shutil.which("claude-mpm") is not None

claude_mpm/commander/git/__init__.py

@@ -0,0 +1,5 @@
+"""Git operations for Commander."""
+
+from .worktree_manager import WorktreeInfo, WorktreeManager
+
+__all__ = ["WorktreeInfo", "WorktreeManager"]