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

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -20,6 +20,15 @@ import os
 import sys
 from datetime import datetime, timezone
 
+# 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 is enabled by default for better visibility into hook processing
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
@@ -94,13 +103,10 @@ class ConnectionManagerService:
         try:
             self.connection_pool = get_connection_pool()
             if DEBUG:
-                print("✅ Modern SocketIO connection pool initialized", file=sys.stderr)
+                _log("✅ Modern SocketIO connection pool initialized")
         except Exception as e:
             if DEBUG:
-                print(
-                    f"⚠️ Failed to initialize SocketIO connection pool: {e}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ Failed to initialize SocketIO connection pool: {e}")
             self.connection_pool = None
 
     def emit_event(self, namespace: str, event: str, data: dict):
@@ -149,10 +155,7 @@ class ConnectionManagerService:
 
                 # Debug log when we detect invalid hook_type for troubleshooting
                 if DEBUG:
-                    print(
-                        f"⚠️ Invalid hook_type detected, using fallback: {hook_type}",
-                        file=sys.stderr,
-                    )
+                    _log(f"⚠️ Invalid hook_type detected, using fallback: {hook_type}")
 
             event_type = hook_type
         else:
@@ -177,16 +180,12 @@ class ConnectionManagerService:
         if DEBUG and event in ["subagent_stop", "pre_tool"]:
             if event == "subagent_stop":
                 agent_type = data.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
-                    file=sys.stderr,
-                )
+                _log(f"Hook handler: Publishing SubagentStop for agent '{agent_type}'")
             elif event == "pre_tool" and data.get("tool_name") == "Task":
                 delegation = data.get("delegation_details", {})
                 agent_type = delegation.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'",
-                    file=sys.stderr,
+                _log(
+                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'"
                 )
 
         # Emit through direct Socket.IO connection pool (primary path)
@@ -196,11 +195,11 @@ class ConnectionManagerService:
                 # Emit to Socket.IO server directly
                 self.connection_pool.emit("mpm_event", claude_event_data)
                 if DEBUG:
-                    print(f"✅ Emitted via connection pool: {event}", file=sys.stderr)
+                    _log(f"✅ Emitted via connection pool: {event}")
                 return  # Success - no need for fallback
             except Exception as e:
                 if DEBUG:
-                    print(f"⚠️ Failed to emit via connection pool: {e}", file=sys.stderr)
+                    _log(f"⚠️ Failed to emit via connection pool: {e}")
 
         # HTTP fallback for cross-process communication (when direct calls fail)
         # This replaces EventBus for reliability without the complexity
@@ -221,22 +220,18 @@ class ConnectionManagerService:
 
             if response.status_code in [200, 204]:
                 if DEBUG:
-                    print("✅ HTTP fallback successful", file=sys.stderr)
+                    _log("✅ HTTP fallback successful")
             elif DEBUG:
-                print(
-                    f"⚠️ HTTP fallback failed: {response.status_code}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ HTTP fallback failed: {response.status_code}")
 
         except Exception as e:
             if DEBUG:
-                print(f"⚠️ HTTP fallback error: {e}", file=sys.stderr)
+                _log(f"⚠️ HTTP fallback error: {e}")
 
         # Warn if no emission method is available
         if not self.connection_pool and DEBUG:
-            print(
-                f"⚠️ No event emission method available for: {claude_event_data.get('event', 'unknown')}",
-                file=sys.stderr,
+            _log(
+                f"⚠️ No event emission method available for: {claude_event_data.get('event', 'unknown')}"
             )
 
     def cleanup(self):
@@ -245,5 +240,5 @@ class ConnectionManagerService:
         if self.connection_pool:
             try:
                 self.connection_pool.cleanup()
-            except Exception:
+            except Exception:  # nosec B110
                 pass  # Ignore cleanup errors during destruction

claude_mpm/hooks/claude_hooks/services/connection_manager_http.py

@@ -16,10 +16,18 @@ is simpler and more reliable for ephemeral processes.
 """
 
 import os
-import sys
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
 
+# 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 is enabled by default for better visibility into hook processing
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
@@ -78,9 +86,8 @@ class ConnectionManagerService:
         )
 
         if DEBUG:
-            print(
-                f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}",
-                file=sys.stderr,
+            _log(
+                f"✅ HTTP connection manager initialized - endpoint: {self.http_endpoint}"
             )
 
     def emit_event(self, namespace: str, event: str, data: dict):
@@ -110,16 +117,12 @@ class ConnectionManagerService:
         if DEBUG and event in ["subagent_stop", "pre_tool"]:
             if event == "subagent_stop":
                 agent_type = data.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing SubagentStop for agent '{agent_type}'",
-                    file=sys.stderr,
-                )
+                _log(f"Hook handler: Publishing SubagentStop for agent '{agent_type}'")
             elif event == "pre_tool" and data.get("tool_name") == "Task":
                 delegation = data.get("delegation_details", {})
                 agent_type = delegation.get("agent_type", "unknown")
-                print(
-                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'",
-                    file=sys.stderr,
+                _log(
+                    f"Hook handler: Publishing Task delegation to agent '{agent_type}'"
                 )
 
         # Emit via HTTP POST (non-blocking, runs in thread pool)
@@ -133,10 +136,7 @@ class ConnectionManagerService:
         """
         if not REQUESTS_AVAILABLE:
             if DEBUG:
-                print(
-                    "⚠️ requests module not available - cannot emit via HTTP",
-                    file=sys.stderr,
-                )
+                _log("⚠️ requests module not available - cannot emit via HTTP")
             return
 
         # Submit to thread pool - don't wait for result (fire-and-forget)
@@ -162,25 +162,21 @@ class ConnectionManagerService:
 
             if response.status_code in [200, 204]:
                 if DEBUG:
-                    print(f"✅ HTTP POST successful: {event}", file=sys.stderr)
+                    _log(f"✅ HTTP POST successful: {event}")
             elif DEBUG:
-                print(
-                    f"⚠️ HTTP POST failed with status {response.status_code}: {event}",
-                    file=sys.stderr,
-                )
+                _log(f"⚠️ HTTP POST failed with status {response.status_code}: {event}")
 
         except requests.exceptions.Timeout:
             if DEBUG:
-                print(f"⚠️ HTTP POST timeout for: {event}", file=sys.stderr)
+                _log(f"⚠️ HTTP POST timeout for: {event}")
         except requests.exceptions.ConnectionError:
             if DEBUG:
-                print(
-                    f"⚠️ HTTP POST connection failed for: {event} (server not running?)",
-                    file=sys.stderr,
+                _log(
+                    f"⚠️ HTTP POST connection failed for: {event} (server not running?)"
                 )
         except Exception as e:
             if DEBUG:
-                print(f"⚠️ HTTP POST error for {event}: {e}", file=sys.stderr)
+                _log(f"⚠️ HTTP POST error for {event}: {e}")
 
     def cleanup(self):
         """Cleanup connections on service destruction."""
@@ -188,4 +184,4 @@ class ConnectionManagerService:
         if hasattr(self, "_http_executor"):
             self._http_executor.shutdown(wait=False)
             if DEBUG:
-                print("✅ HTTP executor shutdown", file=sys.stderr)
+                _log("✅ HTTP executor shutdown")

claude_mpm/hooks/claude_hooks/services/state_manager.py

@@ -8,13 +8,22 @@ This service manages:
 """
 
 import os
-import subprocess
+import subprocess  # nosec B404
 import time
 from collections import deque
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import 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
+
+
 # Import constants for configuration
 try:
     from claude_mpm.core.constants import TimeoutConfig
@@ -63,17 +72,11 @@ class StateManagerService:
     ):
         """Track a new agent delegation with optional request data for response correlation."""
         if DEBUG:
-            import sys
-
-            print(
-                f"  - session_id: {session_id[:16] if session_id else 'None'}...",
-                file=sys.stderr,
-            )
-            print(f"  - agent_type: {agent_type}", file=sys.stderr)
-            print(f"  - request_data provided: {bool(request_data)}", file=sys.stderr)
-            print(
-                f"  - delegation_requests size before: {len(self.delegation_requests)}",
-                file=sys.stderr,
+            _log(f"  - session_id: {session_id[:16] if session_id else 'None'}...")
+            _log(f"  - agent_type: {agent_type}")
+            _log(f"  - request_data provided: {bool(request_data)}")
+            _log(
+                f"  - delegation_requests size before: {len(self.delegation_requests)}"
             )
 
         if session_id and agent_type and agent_type != "unknown":
@@ -89,15 +92,9 @@ class StateManagerService:
                     "timestamp": datetime.now(timezone.utc).isoformat(),
                 }
                 if DEBUG:
-                    import sys
-
-                    print(
-                        f"  - ✅ Stored in delegation_requests[{session_id[:16]}...]",
-                        file=sys.stderr,
-                    )
-                    print(
-                        f"  - delegation_requests size after: {len(self.delegation_requests)}",
-                        file=sys.stderr,
+                    _log(f"  - ✅ Stored in delegation_requests[{session_id[:16]}...]")
+                    _log(
+                        f"  - delegation_requests size after: {len(self.delegation_requests)}"
                     )
 
             # Clean up old delegations (older than 5 minutes)
@@ -197,7 +194,7 @@ class StateManagerService:
             os.chdir(working_dir)
 
             # Run git command to get current branch
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["git", "branch", "--show-current"],
                 capture_output=True,
                 text=True,
@@ -233,17 +230,12 @@ class StateManagerService:
     def find_matching_request(self, session_id: str) -> Optional[dict]:
         """Find matching request data for a session, with fuzzy matching fallback."""
         # First try exact match
-        request_info = self.delegation_requests.get(session_id)
+        request_info = self.delegation_requests.get(session_id)  # nosec B113
 
         # If exact match fails, try partial matching
         if not request_info and session_id:
             if DEBUG:
-                import sys
-
-                print(
-                    f"  - Trying fuzzy match for session {session_id[:16]}...",
-                    file=sys.stderr,
-                )
+                _log(f"  - Trying fuzzy match for session {session_id[:16]}...")
             # Try to find a session that matches the first 8-16 characters
             for stored_sid in list(self.delegation_requests.keys()):
                 if (
@@ -256,13 +248,8 @@ class StateManagerService:
                     )
                 ):
                     if DEBUG:
-                        import sys
-
-                        print(
-                            f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
-                            file=sys.stderr,
-                        )
-                    request_info = self.delegation_requests.get(stored_sid)
+                        _log(f"  - ✅ Fuzzy match found: {stored_sid[:16]}...")
+                    request_info = self.delegation_requests.get(stored_sid)  # nosec B113
                     # Update the key to use the current session_id for consistency
                     if request_info:
                         self.delegation_requests[session_id] = request_info

claude_mpm/hooks/claude_hooks/services/subagent_processor.py

@@ -10,10 +10,18 @@ This service handles:
 import json
 import os
 import re
-import sys
 from datetime import datetime, timezone
 from typing import Optional, Tuple
 
+# 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 is enabled by default for better visibility into hook processing
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
@@ -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_template.py

@@ -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."""

{claude_mpm-5.6.4.dist-info → claude_mpm-5.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 5.6.4
+Version: 5.6.5
 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