claude-mpm 5.1.9__py3-none-any.whl → 5.4.3__py3-none-any.whl

claude_mpm/cli/executor.py

@@ -141,6 +141,14 @@ def execute_command(command: str, args) -> int:
         result = agent_source_command(args)
         return result if result is not None else 0
 
+    # Handle summarize command with lazy import
+    if command == "summarize":
+        # Lazy import to avoid loading unless needed
+        from .commands.summarize import summarize_command
+
+        result = summarize_command(args)
+        return result if result is not None else 0
+
     # Handle auto-configure command with lazy import
     if command == "auto-configure":
         # Lazy import to avoid loading unless needed

claude_mpm/cli/parsers/base_parser.py

@@ -594,6 +594,11 @@ def create_parser(
             action="store_true",
             help="Skip confirmation prompts",
         )
+
+        # Add summarize command
+        from ..commands.summarize import add_summarize_parser
+
+        add_summarize_parser(subparsers)
     except ImportError:
         # Commands module may not be available during testing or refactoring
         pass

claude_mpm/cli/startup.py

@@ -221,75 +221,76 @@ def discover_and_link_runtime_skills():
 
 def deploy_output_style_on_startup():
     """
-    Deploy claude-mpm output style to Claude Code on CLI startup.
+    Deploy claude-mpm output styles to PROJECT-LEVEL directory on CLI startup.
 
-    WHY: Automatically deploy and activate the output style to ensure consistent,
-    professional communication without emojis and exclamation points. This ensures
-    the style is available even when using Claude Code directly (not via chat command).
+    WHY: Automatically deploy output styles to ensure consistent, professional
+    communication without emojis and exclamation points. Styles are project-specific
+    to allow different projects to have different communication styles.
 
-    DESIGN DECISION: This is non-blocking and idempotent. It uses OutputStyleManager
-    which handles version detection, file deployment, and settings activation.
-    Only works for Claude Code >= 1.0.83.
+    DESIGN DECISION: This is non-blocking and idempotent. Deploys to project-level
+    directory (.claude/settings/output-styles/) instead of user-level to maintain
+    project isolation.
+
+    Deploys two styles:
+    - claude-mpm-style.md (professional mode)
+    - claude-mpm-teacher.md (teaching mode)
     """
     try:
+        import shutil
         from pathlib import Path
 
-        from ..core.output_style_manager import OutputStyleManager
-
-        # Create OutputStyleManager instance
-        output_style_manager = OutputStyleManager()
-
-        # Check if Claude Code supports output styles
-        if not output_style_manager.supports_output_styles():
-            # Silently skip - version too old or Claude not installed
-            return
-
-        # Check if already deployed and active
-        settings_file = Path.home() / ".claude" / "settings.json"
-        output_style_file = Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
-
-        already_configured = False
-        if settings_file.exists() and output_style_file.exists():
-            try:
-                import json
-
-                # Check if file has content (bug fix: was skipping empty files)
-                if output_style_file.stat().st_size == 0:
-                    # File is empty, need to redeploy with content
-                    pass  # Fall through to deployment below
-                else:
-                    # File has content, check if already active
-                    settings = json.loads(settings_file.read_text())
-                    if settings.get("activeOutputStyle") == "claude-mpm":
-                        # Already deployed and active with content
-                        already_configured = True
-            except Exception:
-                pass  # Continue with deployment if we can't read settings
+        # Source files (in framework package)
+        package_dir = Path(__file__).parent.parent / "agents"
+        professional_source = package_dir / "CLAUDE_MPM_OUTPUT_STYLE.md"
+        teacher_source = package_dir / "CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md"
+
+        # Target directory (PROJECT-LEVEL, not user-level)
+        project_dir = Path.cwd()
+        output_styles_dir = project_dir / ".claude" / "settings" / "output-styles"
+        professional_target = output_styles_dir / "claude-mpm-style.md"
+        teacher_target = output_styles_dir / "claude-mpm-teacher.md"
+
+        # Create directory if it doesn't exist
+        output_styles_dir.mkdir(parents=True, exist_ok=True)
+
+        # Check if already deployed (both files exist and have content)
+        already_deployed = (
+            professional_target.exists()
+            and teacher_target.exists()
+            and professional_target.stat().st_size > 0
+            and teacher_target.stat().st_size > 0
+        )
 
-        if already_configured:
-            # Show feedback that output style is ready
-            print("✓ Output style configured", flush=True)
+        if already_deployed:
+            # Show feedback that output styles are ready
+            print("✓ Output styles ready", flush=True)
             return
 
-        # Read OUTPUT_STYLE.md content
-        output_style_path = Path(__file__).parent.parent / "agents" / "OUTPUT_STYLE.md"
+        # Deploy both styles
+        deployed_count = 0
+        if professional_source.exists():
+            shutil.copy2(professional_source, professional_target)
+            deployed_count += 1
 
-        if not output_style_path.exists():
-            # No output style file to deploy
-            return
+        if teacher_source.exists():
+            shutil.copy2(teacher_source, teacher_target)
+            deployed_count += 1
 
-        output_style_content = output_style_path.read_text()
+        if deployed_count > 0:
+            print(f"✓ Output styles deployed ({deployed_count} styles)", flush=True)
+        else:
+            # Source files missing - log but don't fail
+            from ..core.logger import get_logger
 
-        # Deploy the output style (deploys file and activates it)
-        output_style_manager.deploy_output_style(output_style_content)
-        print("✓ Output style configured", flush=True)
+            logger = get_logger("cli")
+            logger.debug("Output style source files not found")
 
     except Exception as e:
         # Non-critical - log but don't fail startup
         from ..core.logger import get_logger
 
         logger = get_logger("cli")
-        logger.debug(f"Failed to deploy output style: {e}")
+        logger.debug(f"Failed to deploy output styles: {e}")
         # Continue execution - output style deployment shouldn't block startup
 
 
@@ -386,6 +387,7 @@ def sync_remote_agents_on_startup():
                     # 1. Must have "/agents/" in path (from git repos)
                     # 2. Must not be in PM templates or doc files
                     # 3. Exclude BASE-AGENT.md which is not a deployable agent
+                    # 4. Exclude build artifacts (dist/, build/, .cache/) to prevent double-counting
                     agent_files = [
                         f
                         for f in all_md_files
@@ -396,6 +398,11 @@ def sync_remote_agents_on_startup():
                             and f.name.lower() not in pm_templates
                             and f.name.lower() not in doc_files
                             and f.name.lower() != "base-agent.md"
+                            # Exclude build artifacts (prevents double-counting source + built files)
+                            and not any(
+                                part in str(f).split("/")
+                                for part in ["dist", "build", ".cache"]
+                            )
                         )
                     ]
                     agent_count = len(agent_files)
@@ -409,8 +416,8 @@ def sync_remote_agents_on_startup():
                         show_counter=True,
                     )
 
-                    # Deploy agents with progress callback
-                    deploy_target = Path.home() / ".claude" / "agents"
+                    # Deploy agents to project-level directory where Claude Code expects them
+                    deploy_target = Path.cwd() / ".claude" / "agents"
                     deployment_result = deployment_service.deploy_agents(
                         target_dir=deploy_target,
                         force_rebuild=False,  # Only deploy if versions differ

claude_mpm/commands/{mpm-ticket-organize.md → mpm-organize.md}

@@ -1,10 +1,9 @@
 ---
-namespace: mpm/ticket
+namespace: mpm/system
 command: organize
-aliases: [mpm-ticket-organize]
-migration_target: /mpm/ticket:organize
-category: tickets
-deprecated_aliases: [mpm-organize]
+aliases: [mpm-organize]
+migration_target: /mpm/system:organize
+category: system
 description: Organize project files into proper directories with intelligent pattern detection
 ---
 # /mpm-organize

claude_mpm/config/agent_sources.py

@@ -316,6 +316,33 @@ class AgentSourceConfiguration:
 
         return errors
 
+    def list_sources(self) -> list[dict]:
+        """Return list of source configurations as dictionaries.
+
+        This method converts GitRepository objects to dictionaries for CLI
+        and API compatibility. Called by GitSourceManager and CLI commands.
+
+        Returns:
+            List of dicts with keys: identifier, url, subdirectory, enabled, priority
+
+        Example:
+            >>> config = AgentSourceConfiguration()
+            >>> sources = config.list_sources()
+            >>> for source in sources:
+            ...     print(f"{source['identifier']} (priority: {source['priority']})")
+        """
+        repos = self.get_enabled_repositories()
+        return [
+            {
+                "identifier": repo.identifier,
+                "url": repo.url,
+                "subdirectory": repo.subdirectory,
+                "enabled": repo.enabled,
+                "priority": repo.priority,
+            }
+            for repo in repos
+        ]
+
     def __repr__(self) -> str:
         """Return string representation of configuration."""
         return (

claude_mpm/core/framework/loaders/agent_loader.py

@@ -115,7 +115,11 @@ class AgentLoader:
         return agents
 
     def discover_local_json_templates(self) -> Dict[str, Dict[str, Any]]:
-        """Discover local JSON agent templates from .claude-mpm/agents/ directories.
+        """Discover local JSON agent templates.
+
+        NOTE: This method is kept for backward compatibility but is deprecated.
+        The new architecture uses SOURCE (~/.claude-mpm/cache/remote-agents/)
+        and DEPLOYMENT (.claude/agents/) locations only.
 
         Returns:
             Dictionary mapping agent IDs to agent metadata
@@ -125,11 +129,10 @@ class AgentLoader:
         local_agents = {}
 
         # Check for local JSON templates in priority order
+        # NOTE: These directories are deprecated in the simplified architecture
         template_dirs = [
-            Path.cwd()
-            / ".claude-mpm"
-            / "agents",  # Project local agents (highest priority)
-            Path.home() / ".claude-mpm" / "agents",  # User local agents
+            Path.cwd() / ".claude-mpm" / "agents",  # Deprecated: Project local agents
+            Path.home() / ".claude-mpm" / "agents",  # Deprecated: User local agents
         ]
 
         for priority, template_dir in enumerate(template_dirs):

claude_mpm/core/socketio_pool.py

@@ -55,8 +55,8 @@ class CircuitState(Enum):
 class ConnectionStats:
     """Connection statistics for monitoring."""
 
-    created_at: datetime = field(default_factory=datetime.now)
-    last_used: datetime = field(default_factory=datetime.now)
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+    last_used: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
     events_sent: int = 0
     errors: int = 0
     consecutive_errors: int = 0
@@ -70,7 +70,7 @@ class BatchEvent:
     namespace: str
     event: str
     data: Dict[str, Any]
-    timestamp: datetime = field(default_factory=datetime.now)
+    timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
 
 
 class CircuitBreaker:

claude_mpm/core/unified_agent_registry.py

@@ -174,26 +174,16 @@ class UnifiedAgentRegistry:
         if project_path.exists():
             self.discovery_paths.append(project_path)
 
-        # Also check for local JSON templates in .claude-mpm/agents/
-        local_project_path = self.path_manager.project_root / ".claude-mpm" / "agents"
-        if (
-            local_project_path.exists()
-            and local_project_path not in self.discovery_paths
-        ):
-            self.discovery_paths.append(local_project_path)
-            logger.debug(f"Added local project templates path: {local_project_path}")
+        # NOTE: .claude-mpm/agents/ is deprecated in the simplified architecture
+        # Source agents come from ~/.claude-mpm/cache/remote-agents/
+        # Deployed agents go to .claude/agents/
 
-        # User-level agents
+        # User-level agents (deprecated in simplified architecture)
+        # Keeping for backward compatibility but not actively used
         user_path = self.path_manager.get_user_agents_dir()
         if user_path.exists():
             self.discovery_paths.append(user_path)
 
-        # Also check for user JSON templates in ~/.claude-mpm/agents/
-        local_user_path = Path.home() / ".claude-mpm" / "agents"
-        if local_user_path.exists() and local_user_path not in self.discovery_paths:
-            self.discovery_paths.append(local_user_path)
-            logger.debug(f"Added local user templates path: {local_user_path}")
-
         # System-level agents (includes templates as a subdirectory)
         system_path = self.path_manager.get_system_agents_dir()
         if system_path.exists():

claude_mpm/hooks/claude_hooks/correlation_manager.py

@@ -0,0 +1,60 @@
+"""Cross-process correlation storage using .claude-mpm directory."""
+
+import json
+import time
+from pathlib import Path
+
+
+def get_correlation_dir() -> Path:
+    """Get correlation directory in project's .claude-mpm folder."""
+    # Use CWD's .claude-mpm directory (where hooks run from)
+    cwd = Path.cwd()
+    return cwd / ".claude-mpm" / "correlations"
+
+
+TTL_SECONDS = 3600  # 1 hour
+
+
+class CorrelationManager:
+    """Manages correlation IDs across separate hook processes."""
+
+    @staticmethod
+    def store(session_id: str, tool_call_id: str, tool_name: str) -> None:
+        """Store correlation data for later retrieval by post_tool."""
+        correlation_dir = get_correlation_dir()
+        correlation_dir.mkdir(parents=True, exist_ok=True)
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        data = {
+            "tool_call_id": tool_call_id,
+            "tool_name": tool_name,
+            "timestamp": time.time(),
+        }
+        filepath.write_text(json.dumps(data))
+
+    @staticmethod
+    def retrieve(session_id: str) -> str | None:
+        """Retrieve and delete correlation data from temp file."""
+        correlation_dir = get_correlation_dir()
+        filepath = correlation_dir / f"correlation_{session_id}.json"
+        if not filepath.exists():
+            return None
+        try:
+            data = json.loads(filepath.read_text())
+            filepath.unlink()  # Delete after reading
+            return data.get("tool_call_id")
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    @staticmethod
+    def cleanup_old() -> None:
+        """Remove correlation files older than TTL."""
+        correlation_dir = get_correlation_dir()
+        if not correlation_dir.exists():
+            return
+        now = time.time()
+        for filepath in correlation_dir.glob("correlation_*.json"):
+            try:
+                if now - filepath.stat().st_mtime > TTL_SECONDS:
+                    filepath.unlink()
+            except OSError:
+                pass

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -9,6 +9,7 @@ import os
 import re
 import subprocess
 import sys
+import uuid
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Optional
@@ -134,6 +135,9 @@ class EventHandlers:
         tool_name = event.get("tool_name", "")
         tool_input = event.get("tool_input", {})
 
+        # Generate unique tool call ID for correlation with post_tool event
+        tool_call_id = str(uuid.uuid4())
+
         # Extract key parameters based on tool type
         tool_params = extract_tool_parameters(tool_name, tool_input)
 
@@ -144,6 +148,8 @@ class EventHandlers:
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
 
+        timestamp = datetime.now(timezone.utc).isoformat()
+
         pre_tool_data = {
             "tool_name": tool_name,
             "operation_type": operation_type,
@@ -151,15 +157,27 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "timestamp": timestamp,
             "parameter_count": len(tool_input) if isinstance(tool_input, dict) else 0,
             "is_file_operation": tool_name
             in ["Write", "Edit", "MultiEdit", "Read", "LS", "Glob"],
             "is_execution": tool_name in ["Bash", "NotebookEdit"],
             "is_delegation": tool_name == "Task",
             "security_risk": assess_security_risk(tool_name, tool_input),
+            "correlation_id": tool_call_id,  # Add correlation_id for pre/post correlation
         }
 
+        # Store tool_call_id using CorrelationManager for cross-process retrieval
+        if session_id:
+            from .correlation_manager import CorrelationManager
+
+            CorrelationManager.store(session_id, tool_call_id, tool_name)
+            if DEBUG:
+                print(
+                    f"  - Generated tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
+                    file=sys.stderr,
+                )
+
         # Add delegation-specific data if this is a Task tool
         if tool_name == "Task" and isinstance(tool_input, dict):
             self._handle_task_delegation(tool_input, pre_tool_data, session_id)
@@ -375,6 +393,7 @@ class EventHandlers:
         """
         tool_name = event.get("tool_name", "")
         exit_code = event.get("exit_code", 0)
+        session_id = event.get("session_id", "")
 
         # Extract result data
         result_data = extract_tool_results(event)
@@ -386,6 +405,16 @@ class EventHandlers:
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
 
+        # Retrieve tool_call_id using CorrelationManager for cross-process correlation
+        from .correlation_manager import CorrelationManager
+
+        tool_call_id = CorrelationManager.retrieve(session_id) if session_id else None
+        if DEBUG and tool_call_id:
+            print(
+                f"  - Retrieved tool_call_id: {tool_call_id[:8]}... for session {session_id[:8]}...",
+                file=sys.stderr,
+            )
+
         post_tool_data = {
             "tool_name": tool_name,
             "exit_code": exit_code,
@@ -399,7 +428,7 @@ class EventHandlers:
             ),
             "duration_ms": duration,
             "result_summary": result_data,
-            "session_id": event.get("session_id", ""),
+            "session_id": session_id,
             "working_directory": working_dir,
             "git_branch": git_branch,
             "timestamp": datetime.now(timezone.utc).isoformat(),
@@ -412,6 +441,10 @@ class EventHandlers:
             ),
         }
 
+        # Add correlation_id if available for correlation with pre_tool
+        if tool_call_id:
+            post_tool_data["correlation_id"] = tool_call_id
+
         # Handle Task delegation completion for memory hooks and response tracking
         if tool_name == "Task":
             session_id = event.get("session_id", "")

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -304,6 +304,10 @@ class ClaudeHookHandler:
             # Perform periodic cleanup if needed
             if self.state_manager.increment_events_processed():
                 self.state_manager.cleanup_old_entries()
+                # Also cleanup old correlation files
+                from .correlation_manager import CorrelationManager
+
+                CorrelationManager.cleanup_old()
                 if DEBUG:
                     print(
                         f"🧹 Performed cleanup after {self.state_manager.events_processed} events",

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -115,6 +115,9 @@ class ConnectionManagerService:
         - Fallback: HTTP POST for reliability when direct connection fails
         - Eliminates duplicate events from multiple emission paths
         """
+        # Extract tool_call_id from data if present for correlation
+        tool_call_id = data.get("tool_call_id")
+
         # Create event data for normalization
         raw_event = {
             "type": "hook",
@@ -123,6 +126,7 @@ class ConnectionManagerService:
             "data": data,
             "source": "claude_hooks",  # Identify the source
             "session_id": data.get("sessionId"),  # Include session if available
+            "correlation_id": tool_call_id,  # Set from tool_call_id for event correlation
         }
 
         # Normalize the event using EventNormalizer for consistent schema