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

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -7,9 +7,14 @@ This service manages:
 DESIGN DECISION: Use stateless HTTP POST instead of persistent SocketIO
 connections because hook handlers are ephemeral processes (< 1 second lifetime).
 This eliminates disconnection issues and matches the process lifecycle.
+
+DESIGN DECISION: Synchronous HTTP POST only (no async)
+Hook handlers are too short-lived (~25ms lifecycle) to benefit from async.
+Using asyncio.run() creates event loops that close before HTTP operations complete,
+causing "Event loop is closed" errors. Synchronous HTTP POST in a thread pool
+is simpler and more reliable for ephemeral processes.
 """
 
-import asyncio
 import os
 import sys
 from concurrent.futures import ThreadPoolExecutor
@@ -27,9 +32,6 @@ except ImportError:
     REQUESTS_AVAILABLE = False
     requests = None
 
-# Import high-performance event emitter - lazy loaded in _async_emit()
-# to reduce hook handler initialization time by ~85% (792ms -> minimal)
-
 # Import EventNormalizer for consistent event formatting
 try:
     from claude_mpm.services.socketio.event_normalizer import EventNormalizer
@@ -55,10 +57,6 @@ except ImportError:
             )
 
 
-# EventBus removed - using direct HTTP POST only
-# This eliminates duplicate events and simplifies the architecture
-
-
 class ConnectionManagerService:
     """Manages connections for the Claude hook handler using HTTP POST."""
 
@@ -72,17 +70,9 @@ class ConnectionManagerService:
         self.server_port = int(os.environ.get("CLAUDE_MPM_SERVER_PORT", "8765"))
         self.http_endpoint = f"http://{self.server_host}:{self.server_port}/api/events"
 
-        # EventBus removed - using direct HTTP POST only
-
-        # For backward compatibility with tests
-        self.connection_pool = None  # No longer used
-
-        # Track async emit tasks to prevent garbage collection
-        self._emit_tasks: set = set()
-
         # Thread pool for non-blocking HTTP requests
         # WHY: Prevents HTTP POST from blocking hook processing (2s timeout → 0ms blocking)
-        # max_workers=2: Sufficient for low-frequency HTTP fallback events
+        # max_workers=2: Sufficient for low-frequency hook events
         self._http_executor = ThreadPoolExecutor(
             max_workers=2, thread_name_prefix="http-emit"
         )
@@ -94,13 +84,13 @@ class ConnectionManagerService:
             )
 
     def emit_event(self, namespace: str, event: str, data: dict):
-        """Emit event using high-performance async emitter with HTTP fallback.
+        """Emit event using HTTP POST.
 
-        WHY Hybrid approach:
-        - Direct async calls for ultra-low latency in-process events
-        - HTTP POST fallback for cross-process communication
-        - Connection pooling for memory protection
-        - Automatic routing based on availability
+        WHY HTTP POST only:
+        - Hook handlers are ephemeral (~25ms lifecycle)
+        - Async emission causes "Event loop is closed" errors
+        - HTTP POST in thread pool is simpler and more reliable
+        - Completes in 20-50ms, which is acceptable for hook handlers
         """
         # Create event data for normalization
         raw_event = {
@@ -132,62 +122,9 @@ class ConnectionManagerService:
                     file=sys.stderr,
                 )
 
-        # Try high-performance async emitter first (direct calls)
-        success = self._try_async_emit(namespace, event, claude_event_data)
-        if success:
-            return
-
-        # Fallback to HTTP POST for cross-process communication
+        # Emit via HTTP POST (non-blocking, runs in thread pool)
         self._try_http_emit(namespace, event, claude_event_data)
 
-    def _try_async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Try to emit event using high-performance async emitter."""
-        try:
-            # Run async emission in the current event loop or create one
-            loop = None
-            try:
-                loop = asyncio.get_running_loop()
-            except RuntimeError:
-                # No running loop, create a new one
-                pass
-
-            if loop:
-                # We're in an async context, create a task with tracking
-                task = loop.create_task(self._async_emit(namespace, event, data))
-                self._emit_tasks.add(task)
-                task.add_done_callback(self._emit_tasks.discard)
-                # Don't wait for completion to maintain low latency
-                if DEBUG:
-                    print(f"✅ Async emit scheduled: {event}", file=sys.stderr)
-                return True
-            # No event loop, run synchronously
-            success = asyncio.run(self._async_emit(namespace, event, data))
-            if DEBUG and success:
-                print(f"✅ Async emit successful: {event}", file=sys.stderr)
-            return success
-
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emit failed: {e}", file=sys.stderr)
-            return False
-
-    async def _async_emit(self, namespace: str, event: str, data: dict) -> bool:
-        """Async helper for event emission."""
-        try:
-            # Lazy load event emitter to reduce initialization overhead
-            from claude_mpm.services.monitor.event_emitter import get_event_emitter
-
-            emitter = await get_event_emitter()
-            return await emitter.emit_event(namespace, "claude_event", data)
-        except ImportError:
-            if DEBUG:
-                print("⚠️ Event emitter not available", file=sys.stderr)
-            return False
-        except Exception as e:
-            if DEBUG:
-                print(f"⚠️ Async emitter error: {e}", file=sys.stderr)
-            return False
-
     def _try_http_emit(self, namespace: str, event: str, data: dict):
         """Try to emit event using HTTP POST fallback (non-blocking).
 

claude_mpm/hooks/claude_hooks/services/subagent_processor.py

@@ -67,7 +67,9 @@ class SubagentResponseProcessor:
                 print("  - No stored sessions in delegation_requests!", file=sys.stderr)
 
         # Get agent type and other basic info
-        agent_type, agent_id, reason = self._extract_basic_info(event, session_id)
+        agent_type, agent_id, reason, agent_type_inferred = self._extract_basic_info(
+            event, session_id
+        )
 
         # Always log SubagentStop events for debugging
         if DEBUG or agent_type != "unknown":
@@ -108,6 +110,7 @@ class SubagentResponseProcessor:
             working_dir,
             git_branch,
             structured_response,
+            agent_type_inferred,
         )
 
         # Debug log the processed data
@@ -117,11 +120,20 @@ class SubagentResponseProcessor:
                 file=sys.stderr,
             )
 
-        # Emit to /hook namespace with high priority
-        self.connection_manager.emit_event("/hook", "subagent_stop", subagent_stop_data)
+        # Emit to default namespace (consistent with subagent_start)
+        self.connection_manager.emit_event("", "subagent_stop", subagent_stop_data)
+
+    def _extract_basic_info(
+        self, event: dict, session_id: str
+    ) -> Tuple[str, str, str, bool]:
+        """Extract basic info from the event.
+
+        Returns:
+            Tuple of (agent_type, agent_id, reason, agent_type_inferred)
+            - agent_type_inferred is True when defaulted to "pm"
+        """
+        agent_type_inferred = False
 
-    def _extract_basic_info(self, event: dict, session_id: str) -> Tuple[str, str, str]:
-        """Extract basic info from the event."""
         # First try to get agent type from our tracking
         agent_type = (
             self.state_manager.get_delegation_agent_type(session_id)
@@ -146,7 +158,17 @@ class SubagentResponseProcessor:
             elif "pm" in task_desc or "project" in task_desc:
                 agent_type = "pm"
 
-        return agent_type, agent_id, reason
+        # Default to "pm" if still unknown (main conversation doesn't use Task tool)
+        if agent_type == "unknown":
+            agent_type = "pm"
+            agent_type_inferred = True
+            if DEBUG:
+                print(
+                    "  - Inferred agent_type='pm' (no explicit type found)",
+                    file=sys.stderr,
+                )
+
+        return agent_type, agent_id, reason, agent_type_inferred
 
     def _extract_structured_response(
         self, output: str, agent_type: str
@@ -338,10 +360,12 @@ class SubagentResponseProcessor:
         working_dir: str,
         git_branch: str,
         structured_response: Optional[dict],
+        agent_type_inferred: bool,
     ) -> dict:
         """Build the subagent stop data for event emission."""
         subagent_stop_data = {
             "agent_type": agent_type,
+            "agent_type_inferred": agent_type_inferred,
             "agent_id": agent_id,
             "reason": reason,
             "session_id": session_id,

claude_mpm/hooks/session_resume_hook.py

@@ -8,8 +8,11 @@ DESIGN DECISIONS:
 - Non-blocking: doesn't prevent PM from starting if check fails
 - Displays context to stdout for user visibility
 - Integrates with existing session pause/resume infrastructure
+- Checks for ACTIVE-PAUSE.jsonl (incremental auto-pause) before regular paused sessions
 """
 
+import json
+import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -31,10 +34,83 @@ class SessionResumeStartupHook:
         self.project_path = project_path or Path.cwd()
         self.resume_helper = SessionResumeHelper(self.project_path)
         self._session_displayed = False
+        self.sessions_dir = self.project_path / ".claude-mpm" / "sessions"
+
+    def check_for_active_pause(self) -> Optional[Dict[str, Any]]:
+        """Check for an active incremental pause session.
+
+        Returns:
+            Pause session metadata if ACTIVE-PAUSE.jsonl exists, None otherwise
+        """
+        active_pause_path = self.sessions_dir / "ACTIVE-PAUSE.jsonl"
+
+        if not active_pause_path.exists():
+            logger.debug("No ACTIVE-PAUSE.jsonl found")
+            return None
+
+        try:
+            # Read JSONL file to get first and last actions
+            with active_pause_path.open("r") as f:
+                lines = f.readlines()
+
+            if not lines:
+                logger.warning("ACTIVE-PAUSE.jsonl is empty")
+                return None
+
+            # Parse first action (session start)
+            first_action = json.loads(lines[0])
+
+            # Parse last action (most recent)
+            last_action = json.loads(lines[-1]) if len(lines) > 1 else first_action
+
+            # Extract metadata
+            return {
+                "is_incremental": True,
+                "session_id": first_action.get("session_id"),
+                "started_at": first_action.get("timestamp"),
+                "context_at_start": first_action.get("data", {}).get(
+                    "context_percentage", 0
+                ),
+                "current_context": last_action.get("context_percentage", 0),
+                "action_count": len(lines),
+                "file_path": str(active_pause_path),
+            }
+
+        except (json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"Failed to parse ACTIVE-PAUSE.jsonl: {e}", exc_info=True)
+            return None
+
+    def display_active_pause_warning(self, pause_info: Dict[str, Any]) -> None:
+        """Display warning about active incremental pause session.
+
+        Args:
+            pause_info: Pause session metadata from check_for_active_pause()
+        """
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("⚠️  ACTIVE AUTO-PAUSE SESSION DETECTED", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+        print(f"Session ID: {pause_info['session_id']}", file=sys.stderr)
+        print(f"Started at: {pause_info['started_at']}", file=sys.stderr)
+        print(
+            f"Context at pause: {pause_info['context_at_start']:.1%}", file=sys.stderr
+        )
+        print(f"Actions recorded: {pause_info['action_count']}", file=sys.stderr)
+        print(
+            "\nThis session was auto-paused due to high context usage.", file=sys.stderr
+        )
+        print("Options:", file=sys.stderr)
+        print("  1. Continue (actions will be appended)", file=sys.stderr)
+        print("  2. Use /mpm-init pause --finalize to create snapshot", file=sys.stderr)
+        print("  3. Use /mpm-init pause --discard to abandon", file=sys.stderr)
+        print("=" * 60 + "\n", file=sys.stderr)
 
     def on_pm_startup(self) -> Optional[Dict[str, Any]]:
         """Execute on PM startup to check for paused sessions.
 
+        Checks in priority order:
+        1. ACTIVE-PAUSE.jsonl (incremental auto-pause)
+        2. Regular paused sessions (session-*.json)
+
         Returns:
             Session data if paused session found, None otherwise
         """
@@ -44,7 +120,15 @@ class SessionResumeStartupHook:
                 logger.debug("Session already displayed, skipping")
                 return None
 
-            # Check for paused sessions
+            # PRIORITY 1: Check for active incremental pause FIRST
+            active_pause_info = self.check_for_active_pause()
+            if active_pause_info:
+                self.display_active_pause_warning(active_pause_info)
+                self._session_displayed = True
+                logger.info("Active pause session detected and displayed")
+                return active_pause_info
+
+            # PRIORITY 2: Fall back to regular paused sessions
             session_data = self.resume_helper.check_and_display_resume_prompt()
 
             if session_data:

claude_mpm/init.py

@@ -216,7 +216,7 @@ class ProjectInitializer:
                         if deploy_result.deployed:
                             print(
                                 f"✓ Deployed {len(deploy_result.deployed)} PM skill(s) "
-                                f"to .claude-mpm/skills/pm/"
+                                f"to .claude/skills/"
                             )
                 else:
                     self.logger.warning(

claude_mpm/scripts/claude-hook-handler.sh

@@ -62,8 +62,13 @@ set -e
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 
 # Determine the claude-mpm root based on installation type
+# Check if we're in a UV tools installation
+if [[ "$SCRIPT_DIR" == *"/.local/share/uv/tools/"* ]]; then
+    # UV tools installation - script is at lib/python*/site-packages/claude_mpm/scripts/
+    # The tool root is what we need for Python detection
+    CLAUDE_MPM_ROOT="$(echo "$SCRIPT_DIR" | sed 's|/lib/python.*/site-packages.*||')"
 # Check if we're in a pipx installation
-if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
+elif [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
     # pipx installation - script is at lib/python*/site-packages/claude_mpm/scripts/
     # The venv root is what we need for Python detection
     CLAUDE_MPM_ROOT="$(echo "$SCRIPT_DIR" | sed 's|/lib/python.*/site-packages/.*||')"
@@ -89,11 +94,12 @@ fi
 # STRATEGY:
 # This function implements a fallback chain to find Python with claude-mpm dependencies:
 # 1. UV-managed projects (uv.lock detected) - uses "uv run python"
-# 2. pipx installations - uses pipx venv Python
-# 3. Project-specific virtual environments (venv, .venv)
-# 4. Currently active virtual environment ($VIRTUAL_ENV)
-# 5. System python3 (may lack dependencies)
-# 6. System python (last resort)
+# 2. UV tools installations (~/.local/share/uv/tools/) - uses tool's venv Python
+# 3. pipx installations - uses pipx venv Python
+# 4. Project-specific virtual environments (venv, .venv)
+# 5. Currently active virtual environment ($VIRTUAL_ENV)
+# 6. System python3 (may lack dependencies)
+# 7. System python (last resort)
 #
 # WHY THIS APPROACH:
 # - Claude MPM requires specific packages (socketio, eventlet) not in system Python
@@ -124,7 +130,21 @@ find_python_command() {
         fi
     fi
 
-    # 2. Check if we're in a pipx installation
+    # 2. Check if we're in a UV tools installation
+    if [[ "$SCRIPT_DIR" == *"/.local/share/uv/tools/"* ]]; then
+        # UV tools installation - extract the tool root directory
+        CLAUDE_MPM_ROOT="$(echo "$SCRIPT_DIR" | sed 's|/lib/python.*/site-packages.*||')"
+        local uv_python="$CLAUDE_MPM_ROOT/bin/python"
+        if [ -x "$uv_python" ]; then
+            if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
+                echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] UV tools Python found: $uv_python" >> /tmp/claude-mpm-hook.log
+            fi
+            echo "$uv_python"
+            return
+        fi
+    fi
+
+    # 3. Check if we're in a pipx installation
     if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
         # pipx installation - use the pipx venv's Python directly
         if [ -f "$CLAUDE_MPM_ROOT/bin/python" ]; then
@@ -133,7 +153,7 @@ find_python_command() {
         fi
     fi
 
-    # 3. Check for project-local virtual environment (common in development)
+    # 4. Check for project-local virtual environment (common in development)
     if [ -f "$CLAUDE_MPM_ROOT/venv/bin/activate" ]; then
         source "$CLAUDE_MPM_ROOT/venv/bin/activate"
         echo "$CLAUDE_MPM_ROOT/venv/bin/python"
@@ -154,7 +174,13 @@ find_python_command() {
 PYTHON_CMD=$(find_python_command)
 
 # Check installation type and set PYTHONPATH accordingly
-if [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
+if [[ "$SCRIPT_DIR" == *"/.local/share/uv/tools/"* ]]; then
+    # UV tools installation - claude_mpm is already in the tool's site-packages
+    # No need to modify PYTHONPATH
+    if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
+        echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] UV tools installation detected" >> /tmp/claude-mpm-hook.log
+    fi
+elif [[ "$SCRIPT_DIR" == *"/.local/pipx/venvs/claude-mpm/"* ]]; then
     # pipx installation - claude_mpm is already in the venv's site-packages
     # No need to modify PYTHONPATH
     if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
@@ -224,4 +250,4 @@ if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
 fi
 # Return continue action to prevent blocking Claude Code
 echo '{"action": "continue"}'
-exit 0
+exit 0

claude_mpm/services/agents/agent_recommendation_service.py

@@ -30,16 +30,16 @@ class AgentRecommendationService:
     Can be used by CLI, API, or future auto-configuration features.
     """
 
-    # Core agents always included - matches ToolchainDetector.CORE_AGENTS
+    # Core agents always included - Standard 6 core agents for essential PM workflow
+    # These agents are auto-deployed when no configuration exists
     # Uses exact agent IDs from repository for consistency
     CORE_AGENTS = {
-        "engineer",
-        "qa-agent",
-        "memory-manager-agent",
-        "local-ops-agent",
-        "research-agent",
-        "documentation-agent",
-        "security-agent",
+        "engineer",  # General-purpose implementation
+        "research",  # Codebase exploration and analysis
+        "qa",  # Testing and quality assurance
+        "documentation",  # Documentation generation
+        "ops",  # Basic deployment operations
+        "ticketing",  # Ticket tracking (essential for PM workflow)
     }
 
     # Map detected languages to recommended engineer agents

claude_mpm/services/agents/cache_git_manager.py

@@ -88,7 +88,7 @@ class CacheGitManager:
         if self.repo_path:
             logger.debug(f"Initialized CacheGitManager for repo: {self.repo_path}")
         else:
-            logger.warning(f"Cache path is not a git repository: {cache_path}")
+            logger.debug(f"Cache path is not a git repository: {cache_path}")
 
     def _find_git_root(self) -> Optional[Path]:
         """

claude_mpm/services/agents/deployment/remote_agent_discovery_service.py

@@ -491,6 +491,9 @@ class RemoteAgentDiscoveryService:
             "SKILL.md",
             "SKILLS.md",
             "skill-template.md",
+            # Legacy agents superseded by newer versions
+            # TODO: Remove after bobmatnyc/claude-mpm-agents#XXX is merged
+            "memory-manager.md",  # Superseded by memory-manager-agent.md (v1.2.0)
         }
         md_files = [f for f in md_files if f.name not in excluded_files]
 

claude_mpm/services/agents/loading/framework_agent_loader.py

@@ -10,10 +10,19 @@ Loading precedence: Project → User → System
 
 This service integrates with the main agent_loader.py to provide
 markdown-based agent profiles alongside JSON-based templates.
+
+Auto-Deployment: When no agents are configured, the standard 6 core agents
+are automatically deployed:
+- engineer: General-purpose implementation
+- research: Codebase exploration and analysis
+- qa: Testing and quality assurance
+- documentation: Documentation generation
+- ops: Basic deployment operations
+- ticketing: Ticket tracking (essential for PM workflow)
 """
 
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 from claude_mpm.agents.agent_loader import AgentTier, list_agents_by_tier
 from claude_mpm.core.logging_utils import get_logger
@@ -21,6 +30,17 @@ from claude_mpm.core.unified_paths import get_path_manager
 
 logger = get_logger(__name__)
 
+# Standard 6 core agents that are auto-deployed when no agents are specified
+# This list is the canonical source - other modules should import from here
+CORE_AGENTS: List[str] = [
+    "engineer",  # General-purpose implementation
+    "research",  # Codebase exploration and analysis
+    "qa",  # Testing and quality assurance
+    "documentation",  # Documentation generation
+    "ops",  # Basic deployment operations
+    "ticketing",  # Ticket tracking (essential for PM workflow)
+]
+
 
 class FrameworkAgentLoader:
     """Loads agent profiles from project, user, and system directories with proper precedence"""
@@ -86,7 +106,7 @@ class FrameworkAgentLoader:
                 data_claude = package_path / "data" / "agents" / "CLAUDE.md"
                 if data_instructions.exists() or data_claude.exists():
                     return package_path / "data"
-        except Exception:
+        except Exception:  # nosec B110 - intentional fallthrough to next location
             pass
 
         current = Path.cwd()
@@ -431,3 +451,56 @@ Please operate according to your profile specifications and maintain quality sta
 """
 
         return instruction.strip()
+
+    def get_core_agents(self) -> List[str]:
+        """
+        Get the standard 6 core agents for auto-deployment.
+
+        These agents are automatically deployed when no agents are specified
+        in the configuration. They provide essential PM workflow functionality.
+
+        Returns:
+            List of core agent IDs
+
+        Example:
+            >>> loader = FrameworkAgentLoader()
+            >>> core = loader.get_core_agents()
+            >>> 'engineer' in core
+            True
+            >>> len(core)
+            6
+        """
+        return CORE_AGENTS.copy()
+
+    def get_agents_with_fallback(self) -> Dict[str, list]:
+        """
+        Get available agents, falling back to core agents if none found.
+
+        This method implements the auto-deployment logic: when no agents
+        are found in any tier (project, user, system), it returns the
+        standard 6 core agents as a fallback.
+
+        Returns:
+            Dictionary with agent lists by tier. If no agents found in any tier,
+            returns core agents under 'fallback' key.
+
+        Example:
+            >>> loader = FrameworkAgentLoader()
+            >>> loader.initialize()
+            >>> agents = loader.get_agents_with_fallback()
+            >>> if 'fallback' in agents:
+            ...     print("Using core agents as fallback")
+        """
+        available = self.get_available_agents()
+
+        # Check if any agents are found
+        total_agents = sum(len(agents) for agents in available.values())
+
+        if total_agents == 0:
+            logger.info(
+                "No agents found in configuration. "
+                "Auto-deploying standard 6 core agents."
+            )
+            return {"fallback": CORE_AGENTS.copy()}
+
+        return available

claude_mpm/services/cli/__init__.py

@@ -5,6 +5,7 @@ Services specifically for CLI command support and utilities.
 
 from .agent_dependency_service import AgentDependencyService, IAgentDependencyService
 from .agent_validation_service import AgentValidationService, IAgentValidationService
+from .incremental_pause_manager import IncrementalPauseManager, PauseAction
 from .startup_checker import IStartupChecker, StartupCheckerService, StartupWarning
 
 __all__ = [
@@ -13,6 +14,8 @@ __all__ = [
     "IAgentDependencyService",
     "IAgentValidationService",
     "IStartupChecker",
+    "IncrementalPauseManager",
+    "PauseAction",
     "StartupCheckerService",
     "StartupWarning",
 ]