claude-mpm 5.6.4__py3-none-any.whl → 5.6.30__py3-none-any.whl

claude_mpm/hooks/claude_hooks/services/subagent_processor.py

@@ -10,12 +10,20 @@ This service handles:
 import json
 import os
 import re
-import sys
 from datetime import datetime, timezone
 from typing import Optional, Tuple
 
-# Debug mode is enabled by default for better visibility into hook processing
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
+# Debug mode - disabled by default to prevent logging overhead in production
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 
 class SubagentResponseProcessor:
@@ -45,26 +53,21 @@ class SubagentResponseProcessor:
         # Enhanced debug logging for session correlation
         session_id = event.get("session_id", "")
         if DEBUG:
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - event keys: {list(event.keys())}", file=sys.stderr)
-            print(
-                f"  - delegation_requests size: {len(self.state_manager.delegation_requests)}",
-                file=sys.stderr,
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - event keys: {list(event.keys())}")
+            _log(
+                f"  - delegation_requests size: {len(self.state_manager.delegation_requests)}"
             )
             # Show all stored session IDs for comparison
             all_sessions = list(self.state_manager.delegation_requests.keys())
             if all_sessions:
-                print("  - Stored sessions (first 16 chars):", file=sys.stderr)
+                _log("  - Stored sessions (first 16 chars):")
                 for sid in all_sessions[:10]:  # Show up to 10
-                    print(
-                        f"    - {sid[:16]}... (agent: {self.state_manager.delegation_requests[sid].get('agent_type', 'unknown')})",
-                        file=sys.stderr,
+                    _log(
+                        f"    - {sid[:16]}... (agent: {self.state_manager.delegation_requests[sid].get('agent_type', 'unknown')})"
                     )
             else:
-                print("  - No stored sessions in delegation_requests!", file=sys.stderr)
+                _log("  - No stored sessions in delegation_requests!")
 
         # Get agent type and other basic info
         agent_type, agent_id, reason, agent_type_inferred = self._extract_basic_info(
@@ -73,9 +76,8 @@ class SubagentResponseProcessor:
 
         # Always log SubagentStop events for debugging
         if DEBUG or agent_type != "unknown":
-            print(
-                f"Hook handler: Processing SubagentStop - agent: '{agent_type}', session: '{session_id}', reason: '{reason}'",
-                file=sys.stderr,
+            _log(
+                f"Hook handler: Processing SubagentStop - agent: '{agent_type}', session: '{session_id}', reason: '{reason}'"
             )
 
         # Get working directory and git branch
@@ -115,9 +117,8 @@ class SubagentResponseProcessor:
 
         # Debug log the processed data
         if DEBUG:
-            print(
-                f"SubagentStop processed data: agent_type='{agent_type}', session_id='{session_id}'",
-                file=sys.stderr,
+            _log(
+                f"SubagentStop processed data: agent_type='{agent_type}', session_id='{session_id}'"
             )
 
         # Emit to default namespace (consistent with subagent_start)
@@ -163,10 +164,7 @@ class SubagentResponseProcessor:
             agent_type = "pm"
             agent_type_inferred = True
             if DEBUG:
-                print(
-                    "  - Inferred agent_type='pm' (no explicit type found)",
-                    file=sys.stderr,
-                )
+                _log("  - Inferred agent_type='pm' (no explicit type found)")
 
         return agent_type, agent_id, reason, agent_type_inferred
 
@@ -182,17 +180,15 @@ class SubagentResponseProcessor:
             if json_match:
                 structured_response = json.loads(json_match.group(1))
                 if DEBUG:
-                    print(
-                        f"Extracted structured response from {agent_type} agent in SubagentStop",
-                        file=sys.stderr,
+                    _log(
+                        f"Extracted structured response from {agent_type} agent in SubagentStop"
                     )
 
                 # Log if MEMORIES field is present
                 if structured_response.get("MEMORIES") and DEBUG:
                     memories_count = len(structured_response["MEMORIES"])
-                    print(
-                        f"Agent {agent_type} returned MEMORIES field with {memories_count} items",
-                        file=sys.stderr,
+                    _log(
+                        f"Agent {agent_type} returned MEMORIES field with {memories_count} items"
                     )
 
                 return structured_response
@@ -214,20 +210,15 @@ class SubagentResponseProcessor:
     ):
         """Track the agent response if response tracking is enabled."""
         if DEBUG:
-            print(
-                f"  - response_tracking_enabled: {self.response_tracking_manager.response_tracking_enabled}",
-                file=sys.stderr,
-            )
-            print(
-                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}",
-                file=sys.stderr,
+            _log(
+                f"  - response_tracking_enabled: {self.response_tracking_manager.response_tracking_enabled}"
             )
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
+            _log(
+                f"  - response_tracker exists: {self.response_tracking_manager.response_tracker is not None}"
             )
-            print(f"  - agent_type: {agent_type}", file=sys.stderr)
-            print(f"  - reason: {reason}", file=sys.stderr)
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - agent_type: {agent_type}")
+            _log(f"  - reason: {reason}")
 
         if (
             self.response_tracking_manager.response_tracking_enabled
@@ -238,27 +229,16 @@ class SubagentResponseProcessor:
                 request_info = self.state_manager.find_matching_request(session_id)
 
                 if DEBUG:
-                    print(
-                        f"  - request_info present: {bool(request_info)}",
-                        file=sys.stderr,
-                    )
+                    _log(f"  - request_info present: {bool(request_info)}")
                     if request_info:
-                        print(
-                            "  - ✅ Found request data for response tracking",
-                            file=sys.stderr,
-                        )
-                        print(
-                            f"  - stored agent_type: {request_info.get('agent_type')}",
-                            file=sys.stderr,
-                        )
-                        print(
-                            f"  - request keys: {list(request_info.get('request', {}).keys())}",
-                            file=sys.stderr,
+                        _log("  - ✅ Found request data for response tracking")
+                        _log(f"  - stored agent_type: {request_info.get('agent_type')}")
+                        _log(
+                            f"  - request keys: {list(request_info.get('request', {}).keys())}"
                         )
                     else:
-                        print(
-                            f"  - ❌ No request data found for session {session_id[:16]}...",
-                            file=sys.stderr,
+                        _log(
+                            f"  - ❌ No request data found for session {session_id[:16]}..."
                         )
 
                 if request_info:
@@ -310,9 +290,8 @@ class SubagentResponseProcessor:
                         # Check for MEMORIES field and process if present
                         if structured_response.get("MEMORIES") and DEBUG:
                             memories = structured_response["MEMORIES"]
-                            print(
-                                f"Found MEMORIES field in {agent_type} response with {len(memories)} items",
-                                file=sys.stderr,
+                            _log(
+                                f"Found MEMORIES field in {agent_type} response with {len(memories)} items"
                             )
                             # The memory will be processed by extract_and_update_memory
                             # which is called by the memory hook service
@@ -329,26 +308,21 @@ class SubagentResponseProcessor:
                     )
 
                     if file_path and DEBUG:
-                        print(
-                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}",
-                            file=sys.stderr,
+                        _log(
+                            f"✅ Tracked {agent_type} agent response on SubagentStop: {file_path.name}"
                         )
 
                     # Clean up the request data
                     self.state_manager.remove_request(session_id)
 
                 elif DEBUG:
-                    print(
-                        f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}",
-                        file=sys.stderr,
+                    _log(
+                        f"No request data for SubagentStop session {session_id[:8]}..., agent: {agent_type}"
                     )
 
             except Exception as e:
                 if DEBUG:
-                    print(
-                        f"❌ Failed to track response on SubagentStop: {e}",
-                        file=sys.stderr,
-                    )
+                    _log(f"❌ Failed to track response on SubagentStop: {e}")
 
     def _build_subagent_stop_data(
         self,

claude_mpm/hooks/session_resume_hook.py

@@ -12,13 +12,21 @@ DESIGN DECISIONS:
 """
 
 import json
-import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
 from claude_mpm.core.logger import get_logger
 from claude_mpm.services.cli.session_resume_helper import SessionResumeHelper
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
 logger = get_logger(__name__)
 
 
@@ -86,23 +94,19 @@ class SessionResumeStartupHook:
         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)
+        _log("=" * 60)
+        _log("⚠️  ACTIVE AUTO-PAUSE SESSION DETECTED")
+        _log("=" * 60)
+        _log(f"Session ID: {pause_info['session_id']}")
+        _log(f"Started at: {pause_info['started_at']}")
+        _log(f"Context at pause: {pause_info['context_at_start']:.1%}")
+        _log(f"Actions recorded: {pause_info['action_count']}")
+        _log("\nThis session was auto-paused due to high context usage.")
+        _log("Options:")
+        _log("  1. Continue (actions will be appended)")
+        _log("  2. Use /mpm-init pause --finalize to create snapshot")
+        _log("  3. Use /mpm-init pause --discard to abandon")
+        _log("=" * 60 + "\n")
 
     def on_pm_startup(self) -> Optional[Dict[str, Any]]:
         """Execute on PM startup to check for paused sessions.

claude_mpm/hooks/templates/pre_tool_use_simple.py

@@ -38,7 +38,7 @@ def main():
         # Read event from stdin
         event_data = sys.stdin.read()
         if not event_data.strip():
-            print(json.dumps({"action": "continue"}))
+            print(json.dumps({"continue": True}))
             return
 
         event = json.loads(event_data)
@@ -49,7 +49,7 @@ def main():
         if tool_name == "Grep" and "-n" not in tool_input:
             modified_input = tool_input.copy()
             modified_input["-n"] = True
-            print(json.dumps({"action": "continue", "tool_input": modified_input}))
+            print(json.dumps({"continue": True, "tool_input": modified_input}))
             return
 
         # Example: Block operations on .env files
@@ -59,19 +59,19 @@ def main():
                 print(
                     json.dumps(
                         {
-                            "action": "block",
-                            "message": "Access to .env file blocked for security",
+                            "continue": False,
+                            "stopReason": "Access to .env file blocked for security",
                         }
                     )
                 )
                 return
 
         # Default: continue without modification
-        print(json.dumps({"action": "continue"}))
+        print(json.dumps({"continue": True}))
 
     except Exception:
         # Always continue on error to avoid blocking Claude
-        print(json.dumps({"action": "continue"}))
+        print(json.dumps({"continue": True}))
 
 
 if __name__ == "__main__":

claude_mpm/hooks/templates/pre_tool_use_template.py

@@ -29,7 +29,7 @@ Input Format (stdin):
 
 Output Format (stdout):
 {
-  "action": "continue",
+  "continue": true,
   "tool_input": {
     "file_path": "/path/to/file.py",
     "old_string": "foo",
@@ -39,13 +39,13 @@ Output Format (stdout):
 
 Or to block execution:
 {
-  "action": "block",
-  "message": "Reason for blocking"
+  "continue": false,
+  "stopReason": "Reason for blocking"
 }
 
 Or to continue without modification:
 {
-  "action": "continue"
+  "continue": true
 }
 """
 
@@ -55,6 +55,14 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
 
 class PreToolUseHook:
     """Base class for PreToolUse hooks with input modification support."""
@@ -64,9 +72,9 @@ class PreToolUseHook:
         self.debug = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
     def log_debug(self, message: str) -> None:
-        """Log debug message to stderr."""
+        """Log debug message using _log helper."""
         if self.debug:
-            print(f"[PreToolUse Hook] {message}", file=sys.stderr)
+            _log(f"[PreToolUse Hook] {message}")
 
     def read_event(self) -> Optional[Dict[str, Any]]:
         """Read and parse the hook event from stdin."""
@@ -86,14 +94,14 @@ class PreToolUseHook:
         self, modified_input: Optional[Dict[str, Any]] = None
     ) -> None:
         """Continue execution with optional modified input."""
-        response = {"action": "continue"}
+        response = {"continue": True}
         if modified_input is not None:
             response["tool_input"] = modified_input
         print(json.dumps(response))
 
     def block_execution(self, message: str) -> None:
         """Block execution with a message."""
-        response = {"action": "block", "message": message}
+        response = {"continue": False, "stopReason": message}
         print(json.dumps(response))
 
     def modify_input(

claude_mpm/scripts/claude-hook-handler.sh

@@ -125,7 +125,7 @@ find_python_command() {
     # 1. Check for UV project first (uv.lock or pyproject.toml with uv)
     if [ -f "$CLAUDE_MPM_ROOT/uv.lock" ]; then
         if command -v uv &> /dev/null; then
-            echo "uv run python"
+            echo "uv run --directory \"$CLAUDE_MPM_ROOT\" python"
             return
         fi
     fi
@@ -219,16 +219,16 @@ log_debug() {
 
 # Test Python works and module exists
 # Handle UV's multi-word command specially
-if [[ "$PYTHON_CMD" == "uv run python" ]]; then
-    if ! uv run python -c "import claude_mpm" 2>/dev/null; then
+if [[ "$PYTHON_CMD" == "uv run"* ]]; then
+    if ! uv run --directory "$CLAUDE_MPM_ROOT" python -c "import claude_mpm" 2>/dev/null; then
         log_debug "claude_mpm module not available, continuing without hook"
-        echo '{"action": "continue"}'
+        echo '{"continue": true}'
         exit 0
     fi
 else
     if ! $PYTHON_CMD -c "import claude_mpm" 2>/dev/null; then
         log_debug "claude_mpm module not available, continuing without hook"
-        echo '{"action": "continue"}'
+        echo '{"continue": true}'
         exit 0
     fi
 fi
@@ -237,8 +237,8 @@ fi
 # Use exec to replace the shell process with Python
 # Handle UV's multi-word command specially
 # Suppress RuntimeWarning to prevent stderr output (which causes hook errors)
-if [[ "$PYTHON_CMD" == "uv run python" ]]; then
-    exec uv run python -W ignore::RuntimeWarning -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
+if [[ "$PYTHON_CMD" == "uv run"* ]]; then
+    exec uv run --directory "$CLAUDE_MPM_ROOT" python -W ignore::RuntimeWarning -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
 else
     exec "$PYTHON_CMD" -W ignore::RuntimeWarning -m claude_mpm.hooks.claude_hooks.hook_handler "$@" 2>/tmp/claude-mpm-hook-error.log
 fi
@@ -250,5 +250,5 @@ if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
     echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Error: $(cat /tmp/claude-mpm-hook-error.log 2>/dev/null | head -5)" >> /tmp/claude-mpm-hook.log
 fi
 # Return continue action to prevent blocking Claude Code
-echo '{"action": "continue"}'
+echo '{"continue": true}'
 exit 0

claude_mpm/services/agents/agent_selection_service.py

@@ -39,10 +39,10 @@ import logging
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set, Tuple
 
-from src.claude_mpm.services.agents.single_tier_deployment_service import (
+from claude_mpm.services.agents.single_tier_deployment_service import (
     SingleTierDeploymentService,
 )
-from src.claude_mpm.services.agents.toolchain_detector import ToolchainDetector
+from claude_mpm.services.agents.toolchain_detector import ToolchainDetector
 
 logger = logging.getLogger(__name__)
 

claude_mpm/services/agents/single_tier_deployment_service.py

@@ -30,12 +30,12 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
-from src.claude_mpm.config.agent_sources import AgentSourceConfiguration
-from src.claude_mpm.models.git_repository import GitRepository
-from src.claude_mpm.services.agents.deployment.remote_agent_discovery_service import (
+from claude_mpm.config.agent_sources import AgentSourceConfiguration
+from claude_mpm.models.git_repository import GitRepository
+from claude_mpm.services.agents.deployment.remote_agent_discovery_service import (
     RemoteAgentDiscoveryService,
 )
-from src.claude_mpm.services.agents.git_source_manager import GitSourceManager
+from claude_mpm.services.agents.git_source_manager import GitSourceManager
 
 logger = logging.getLogger(__name__)
 

claude_mpm/services/command_deployment_service.py

@@ -1,10 +1,14 @@
-"""Service for deploying MPM slash commands to user's Claude configuration.
+"""Service for managing MPM slash commands in user's Claude configuration.
 
-This service handles:
-1. Copying command markdown files from source to user's ~/.claude/commands directory
-2. Creating the commands directory if it doesn't exist
-3. Overwriting existing commands to ensure they're up-to-date
-4. Parsing and validating YAML frontmatter for namespace metadata (Phase 1 - 1M-400)
+DEPRECATED: User-level commands in ~/.claude/commands/ are deprecated.
+Project-level skills (.claude/skills/) are now the only source for commands.
+
+This service now only handles:
+1. Cleanup of deprecated commands from previous versions
+2. Cleanup of stale commands that no longer exist in source
+3. Parsing and validating YAML frontmatter (for internal use)
+
+New command deployment is intentionally disabled - see deploy_commands_on_startup().
 """
 
 from pathlib import Path
@@ -17,20 +21,34 @@ from claude_mpm.core.logger import get_logger
 
 
 class CommandDeploymentService(BaseService):
-    """Service for deploying MPM slash commands."""
+    """Service for managing MPM slash commands (cleanup only - deployment deprecated)."""
 
-    # Deprecated commands that have been replaced (cleanup on startup)
+    # Deprecated commands that should be removed from ~/.claude/commands/
+    # ALL user-level commands are now deprecated - project-level skills are the only source
     DEPRECATED_COMMANDS = [
+        # Legacy deprecated commands (historical)
         "mpm-agents.md",  # Replaced by mpm-agents-list.md
         "mpm-auto-configure.md",  # Replaced by mpm-agents-auto-configure.md
         "mpm-config-view.md",  # Replaced by mpm-config.md
         "mpm-resume.md",  # Replaced by mpm-session-resume.md
         "mpm-ticket.md",  # Replaced by mpm-ticket-view.md
-        # Removed - consolidated into /mpm-configure
         "mpm-agents-list.md",  # Consolidated into /mpm-configure
         "mpm-agents-detect.md",  # Consolidated into /mpm-configure
         "mpm-agents-auto-configure.md",  # Consolidated into /mpm-configure
         "mpm-agents-recommend.md",  # Consolidated into /mpm-configure
+        # ALL user-level commands are now deprecated (use project-level skills)
+        "mpm.md",
+        "mpm-config.md",
+        "mpm-doctor.md",
+        "mpm-help.md",
+        "mpm-init.md",
+        "mpm-monitor.md",
+        "mpm-organize.md",
+        "mpm-postmortem.md",
+        "mpm-session-resume.md",
+        "mpm-status.md",
+        "mpm-ticket-view.md",
+        "mpm-version.md",
     ]
 
     def __init__(self):
@@ -414,33 +432,33 @@ class CommandDeploymentService(BaseService):
 def deploy_commands_on_startup(force: bool = False) -> None:
     """Convenience function to deploy commands during startup.
 
-    This function:
-    1. Removes deprecated commands that have been replaced
-    2. Removes stale commands that no longer exist in source
-    3. Deploys current command files
+    DEPRECATED: User-level commands in ~/.claude/commands/ are deprecated.
+    Project-level skills should be the only source for commands.
+
+    This function now only cleans up any existing deprecated/stale commands
+    without deploying new ones.
 
     Args:
-        force: Force deployment even if files exist
+        force: Force deployment even if files exist (ignored - deployment disabled)
     """
-    service = CommandDeploymentService()
     logger = get_logger("startup")
+    logger.debug(
+        "User-level command deployment is deprecated - "
+        "project-level skills are the only command source"
+    )
 
-    # Clean up deprecated commands FIRST (known old commands)
+    # Still clean up any lingering deprecated/stale commands from previous versions
+    service = CommandDeploymentService()
+
+    # Clean up deprecated commands
     deprecated_count = service.remove_deprecated_commands()
     if deprecated_count > 0:
         logger.info(f"Cleaned up {deprecated_count} deprecated command(s)")
 
-    # Clean up stale commands SECOND (deployed but not in source anymore)
+    # Clean up stale commands
     stale_count = service.remove_stale_commands()
     if stale_count > 0:
         logger.info(f"Cleaned up {stale_count} stale command(s)")
 
-    # Deploy current commands LAST
-    result = service.deploy_commands(force=force)
-
-    if result["deployed"]:
-        logger.info(f"MPM commands deployed: {', '.join(result['deployed'])}")
-
-    if result["errors"]:
-        for error in result["errors"]:
-            logger.warning(f"Command deployment issue: {error}")
+    # NOTE: Deployment of new commands is intentionally disabled.
+    # Project-level skills (.claude/skills/) are the only source for commands.

claude_mpm/services/pm_skills_deployer.py

@@ -389,8 +389,9 @@ class PMSkillsDeployerService(LoggerMixin):
             if not skill_dir.is_dir() or skill_dir.name.startswith("."):
                 continue
 
-            # Only process mpm-* skills (framework management)
-            if not skill_dir.name.startswith("mpm-"):
+            # Only process mpm* skills (framework management)
+            # Note: Includes both 'mpm' (core skill) and 'mpm-*' (other PM skills)
+            if not skill_dir.name.startswith("mpm"):
                 self.logger.debug(f"Skipping non-mpm skill: {skill_dir.name}")
                 continue