claude-mpm 4.0.19__tar.gz → 4.0.20__tar.gz

claude_mpm-4.0.20/BUILD_NUMBER

@@ -0,0 +1 @@
+289

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-mpm
-Version: 4.0.19
+Version: 4.0.20
 Summary: Claude Multi-agent Project Manager - Clean orchestration with ticket management
 Home-page: https://github.com/bobmatnyc/claude-mpm
 Author: Claude MPM Team

claude_mpm-4.0.20/VERSION

@@ -0,0 +1 @@
+4.0.20

claude_mpm-4.0.20/src/claude_mpm/VERSION

@@ -0,0 +1 @@
+4.0.20

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/__main__.py

@@ -10,8 +10,12 @@ DESIGN DECISION: We only import and call the main function from the CLI module,
 keeping this file minimal and focused on its single responsibility.
 """
 
+import os
 import sys
 
+# Disable telemetry by default
+os.environ['DISABLE_TELEMETRY'] = '1'
+
 # Add parent directory to path to ensure proper imports
 sys.path.insert(0, str(Path(__file__).parent.parent))
 

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/agents/BASE_AGENT_TEMPLATE.md

@@ -70,10 +70,30 @@ End every response with this structured data:
     {"file": "path/file.py", "action": "created|modified|deleted", "description": "What changed"}
   ],
   "tools_used": ["Read", "Edit", "etc"],
-  "remember": ["Key learnings"] or null
+  "remember": ["Key project-specific learnings"] or null
 }
 ```
 
+**Memory Guidelines:**
+- The `remember` field should contain a list of strings or `null`
+- Only include memories when you learn something NEW about THIS project
+- Memories are automatically extracted and added to your agent memory file
+- Each memory item should be a concise, specific fact (under 100 characters)
+- Memories accumulate over time - you don't need to repeat previous learnings
+
+**Good memory examples:**
+- "Memory system uses .claude-mpm/memories/ for storage"
+- "Service layer has 5 domains: core, agent, communication, project, infra"
+- "All services implement explicit interfaces for DI"
+- "Agent templates stored as JSON in src/claude_mpm/agents/templates/"
+- "Project uses lazy loading for performance optimization"
+
+**Bad memory examples (too generic or obvious):**
+- "Python uses indentation" (generic programming knowledge)
+- "Always test code" (general best practice)
+- "Files should have docstrings" (not project-specific)
+- "This is a Python project" (too obvious)
+
 ## Quick Reference
 
 **When blocked:** Stop and ask for help  
@@ -81,5 +101,21 @@ End every response with this structured data:
 **When delegating:** Use `[Agent] Task` format  
 **Always include:** JSON response block at end  
 
+## Memory System Integration
+
+**How Memory Works:**
+1. Before each task, your accumulated project knowledge is loaded
+2. During tasks, you discover new project-specific facts
+3. Add these discoveries to the `remember` field in your JSON response
+4. Your memories are automatically saved and will be available next time
+
+**What to Remember:**
+- Project architecture and structure patterns
+- Coding conventions specific to this codebase
+- Integration points and dependencies
+- Performance considerations discovered
+- Common mistakes to avoid in this project
+- Domain-specific knowledge unique to this system
+
 ## Remember
-You're a specialist in your domain. Focus on your expertise, communicate clearly with the PM who coordinates multi-agent workflows, and always think about what other agents need next.
+You're a specialist in your domain. Focus on your expertise, communicate clearly with the PM who coordinates multi-agent workflows, and always think about what other agents need next. Your accumulated memories help you become more effective over time.

claude_mpm-4.0.20/src/claude_mpm/agents/OUTPUT_STYLE.md

@@ -0,0 +1,84 @@
+---
+name: Claude MPM
+description: Multi-Agent Project Manager orchestration mode for delegation and coordination
+---
+
+You are Claude Multi-Agent PM, a PROJECT MANAGER whose SOLE PURPOSE is to delegate work to specialized agents.
+
+## 🔴 PRIMARY DIRECTIVE - MANDATORY DELEGATION 🔴
+
+**YOU ARE STRICTLY FORBIDDEN FROM DOING ANY WORK DIRECTLY.**
+
+Direct implementation is ABSOLUTELY PROHIBITED unless the user EXPLICITLY overrides with phrases like:
+- "do this yourself"
+- "don't delegate"
+- "implement directly"
+- "you do it"
+- "no delegation"
+
+## Core Operating Rules
+
+**DEFAULT BEHAVIOR - ALWAYS DELEGATE**:
+- 🔴 You MUST delegate 100% of ALL work to specialized agents by default
+- 🔴 Direct action is STRICTLY FORBIDDEN without explicit user override
+- 🔴 Even the simplest tasks MUST be delegated - NO EXCEPTIONS
+- 🔴 When in doubt, ALWAYS DELEGATE - never act directly
+
+**Allowed Tools**:
+- **Task** for delegation (YOUR PRIMARY FUNCTION)
+- **TodoWrite** for tracking delegation progress ONLY
+- **WebSearch/WebFetch** for gathering context BEFORE delegation
+- **Direct answers** ONLY for questions about PM capabilities
+
+## Communication Standards
+
+- **Tone**: Professional, neutral by default
+- **Use**: "Understood", "Confirmed", "Noted"
+- **No simplification** without explicit user request
+- **No mocks** outside test environments
+- **Complete implementations** only - no placeholders
+- **FORBIDDEN**: Overeager enthusiasm ("Excellent!", "Perfect!", "Amazing!")
+
+## Error Handling Protocol
+
+**3-Attempt Process**:
+1. **First Failure**: Re-delegate with enhanced context
+2. **Second Failure**: Mark "ERROR - Attempt 2/3", escalate if needed
+3. **Third Failure**: TodoWrite escalation with user decision required
+
+## Standard Operating Procedure
+
+1. **Analysis**: Parse request, assess context (NO TOOLS)
+2. **Planning**: Agent selection, task breakdown, priority assignment
+3. **Delegation**: Task Tool with enhanced format
+4. **Monitoring**: Track progress via TodoWrite
+5. **Integration**: Synthesize results, validate, report
+
+## TodoWrite Requirements
+
+### Mandatory [Agent] Prefix Rules
+
+**ALWAYS use [Agent] prefix for delegated tasks**:
+- ✅ `[Research] Analyze authentication patterns`
+- ✅ `[Engineer] Implement user registration`
+- ✅ `[QA] Test payment flow`
+- ✅ `[Documentation] Update API docs`
+
+**NEVER use [PM] prefix for implementation tasks**
+
+### Task Status Management
+
+- `pending` - Task not yet started
+- `in_progress` - Currently being worked on (ONE at a time)
+- `completed` - Task finished successfully
+
+## Response Format
+
+When completing delegations, provide structured summaries including:
+- Request summary
+- Agents used and task counts
+- Tasks completed with [Agent] prefixes
+- Files affected across all agents
+- Blockers encountered and resolutions
+- Next steps for user
+- Key information to remember

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/agents/templates/qa.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "1.2.0",
   "agent_id": "qa-agent",
-  "agent_version": "3.1.0",
+  "agent_version": "3.2.0",
   "agent_type": "qa",
   "metadata": {
     "name": "Qa Agent",

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/__init__.py

@@ -71,6 +71,10 @@ def main(argv: Optional[list] = None):
     Returns:
         Exit code (0 for success, non-zero for errors)
     """
+    # Disable telemetry by default (set early in case any imported modules check it)
+    import os
+    os.environ.setdefault('DISABLE_TELEMETRY', '1')
+    
     # Ensure directories are initialized on first run
     ensure_directories()
 
@@ -247,10 +251,28 @@ def _ensure_run_attributes(args):
     args.input = getattr(args, "input", None)
     args.non_interactive = getattr(args, "non_interactive", False)
     args.no_native_agents = getattr(args, "no_native_agents", False)
-    args.claude_args = getattr(args, "claude_args", [])
+    
+    # Handle claude_args - if --resume flag is set, add it to claude_args
+    claude_args = getattr(args, "claude_args", [])
+    if getattr(args, "resume", False):
+        # Add --resume to claude_args if not already present
+        if "--resume" not in claude_args:
+            claude_args = ["--resume"] + claude_args
+    args.claude_args = claude_args
+    
     args.launch_method = getattr(args, "launch_method", "exec")
     args.websocket = getattr(args, "websocket", False)
     args.websocket_port = getattr(args, "websocket_port", 8765)
+    # CRITICAL: Include mpm_resume attribute for session resumption
+    args.mpm_resume = getattr(args, "mpm_resume", None)
+    # Also include monitor and force attributes
+    args.monitor = getattr(args, "monitor", False)
+    args.force = getattr(args, "force", False)
+    # Include dependency checking attributes
+    args.check_dependencies = getattr(args, "check_dependencies", True)
+    args.force_check_dependencies = getattr(args, "force_check_dependencies", False)
+    args.no_prompt = getattr(args, "no_prompt", False)
+    args.force_prompt = getattr(args, "force_prompt", False)
 
 
 def _execute_command(command: str, args) -> int:

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/__main__.py

@@ -16,8 +16,12 @@ This is equivalent to calling the claude-mpm script directly but ensures
 proper Python module context and import resolution.
 """
 
+import os
 import sys
 
+# Disable telemetry by default
+os.environ['DISABLE_TELEMETRY'] = '1'
+
 from . import main
 
 if __name__ == "__main__":

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/commands/memory.py

@@ -280,7 +280,12 @@ def _show_basic_status(memory_manager):
         print(f"   Expected location: {memory_dir}")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
 
     if not memory_files:
         print("📭 No memory files found")
@@ -296,7 +301,13 @@ def _show_basic_status(memory_manager):
         size_kb = stat.st_size / 1024
         total_size += stat.st_size
 
-        agent_id = file_path.stem.replace("_agent", "")
+        # Extract agent name from various formats
+        if file_path.name.endswith("_memories.md"):
+            agent_id = file_path.stem[:-9]  # Remove "_memories"
+        elif file_path.name.endswith("_agent.md"):
+            agent_id = file_path.stem[:-6]  # Remove "_agent"
+        else:
+            agent_id = file_path.stem
         print(f"   {agent_id}: {size_kb:.1f} KB")
 
     print(f"💾 Total size: {total_size / 1024:.1f} KB")
@@ -395,7 +406,12 @@ def _clean_memory(args, memory_manager):
         print("📁 No memory directory found - nothing to clean")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
     if not memory_files:
         print("📭 No memory files found - nothing to clean")
         return
@@ -651,7 +667,12 @@ def _show_all_agent_memories(format_type, memory_manager):
         print("📁 No memory directory found")
         return
 
-    memory_files = list(memory_dir.glob("*_agent.md"))
+    # Support both old and new formats
+    memory_files = list(memory_dir.glob("*_memories.md"))
+    # Also check for old formats for backward compatibility
+    memory_files.extend(memory_dir.glob("*_agent.md"))
+    memory_files.extend([f for f in memory_dir.glob("*.md") 
+                        if f.name != "README.md" and not f.name.endswith("_memories.md") and not f.name.endswith("_agent.md")])
     if not memory_files:
         print("📭 No agent memories found")
         return
@@ -664,7 +685,13 @@ def _show_all_agent_memories(format_type, memory_manager):
 
     # Load all agent memories
     for file_path in sorted(memory_files):
-        agent_id = file_path.stem.replace("_agent", "")
+        # Extract agent name from various formats
+        if file_path.name.endswith("_memories.md"):
+            agent_id = file_path.stem[:-9]  # Remove "_memories"
+        elif file_path.name.endswith("_agent.md"):
+            agent_id = file_path.stem[:-6]  # Remove "_agent"
+        else:
+            agent_id = file_path.stem
         try:
             memory_content = memory_manager.load_agent_memory(agent_id)
             if memory_content:

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/commands/run.py

@@ -33,7 +33,8 @@ def filter_claude_mpm_args(claude_args):
     flags and will error if they're passed through.
 
     DESIGN DECISION: We maintain a list of known claude-mpm flags to filter out,
-    ensuring only genuine Claude CLI arguments are passed through.
+    ensuring only genuine Claude CLI arguments are passed through. We also remove
+    the '--' separator that argparse uses, as it's not needed by Claude CLI.
 
     Args:
         claude_args: List of arguments captured by argparse.REMAINDER
@@ -83,6 +84,11 @@ def filter_claude_mpm_args(claude_args):
     while i < len(claude_args):
         arg = claude_args[i]
 
+        # Skip the '--' separator used by argparse - Claude doesn't need it
+        if arg == "--":
+            i += 1
+            continue
+
         # Check if this is a claude-mpm flag
         if arg in mpm_flags:
             # Skip this flag
@@ -379,16 +385,37 @@ def run_session(args):
     # Create simple runner
     enable_tickets = not args.no_tickets
     raw_claude_args = getattr(args, "claude_args", []) or []
+    
+    # Add --resume to claude_args if the flag is set
+    resume_flag_present = getattr(args, "resume", False)
+    if resume_flag_present:
+        logger.info("📌 --resume flag detected in args")
+        if "--resume" not in raw_claude_args:
+            raw_claude_args = ["--resume"] + raw_claude_args
+            logger.info("✅ Added --resume to claude_args")
+        else:
+            logger.info("ℹ️ --resume already in claude_args")
+    
     # Filter out claude-mpm specific flags before passing to Claude CLI
+    logger.debug(f"Pre-filter claude_args: {raw_claude_args}")
     claude_args = filter_claude_mpm_args(raw_claude_args)
     monitor_mode = getattr(args, "monitor", False)
 
-    # Debug logging for argument filtering
+    # Enhanced debug logging for argument filtering
     if raw_claude_args != claude_args:
-        logger.debug(
-            f"Filtered claude-mpm args: {set(raw_claude_args) - set(claude_args)}"
-        )
-        logger.debug(f"Passing to Claude CLI: {claude_args}")
+        filtered_out = list(set(raw_claude_args) - set(claude_args))
+        logger.debug(f"Filtered out MPM-specific args: {filtered_out}")
+    
+    logger.info(f"Final claude_args being passed: {claude_args}")
+    
+    # Explicit verification of --resume flag
+    if resume_flag_present:
+        if "--resume" in claude_args:
+            logger.info("✅ CONFIRMED: --resume flag will be passed to Claude CLI")
+        else:
+            logger.error("❌ WARNING: --resume flag was filtered out! This is a bug!")
+            logger.error(f"   Original args: {raw_claude_args}")
+            logger.error(f"   Filtered args: {claude_args}")
 
     # Use the specified launch method (default: exec)
     launch_method = getattr(args, "launch_method", "exec")

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/parsers/base_parser.py

@@ -187,6 +187,11 @@ def add_top_level_run_arguments(parser: argparse.ArgumentParser) -> None:
         const="last",
         help="Resume an MPM session (last session if no ID specified, or specific session ID)",
     )
+    run_group.add_argument(
+        "--resume",
+        action="store_true",
+        help="Pass --resume flag to Claude Desktop to resume the last conversation",
+    )
     run_group.add_argument(
         "--force",
         action="store_true",

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/parsers/run_parser.py

@@ -75,6 +75,11 @@ def add_run_arguments(parser: argparse.ArgumentParser) -> None:
         const="last",
         help="Resume an MPM session (last session if no ID specified, or specific session ID)",
     )
+    run_group.add_argument(
+        "--resume",
+        action="store_true",
+        help="Pass --resume flag to Claude Desktop to resume the last conversation",
+    )
 
     # Dependency checking options
     dep_group = parser.add_argument_group("dependency options")

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/cli/utils.py

@@ -132,11 +132,24 @@ def list_agent_versions_at_startup() -> None:
 
     WHY: Users want to see what agents are available when they start a session.
     This provides immediate feedback about the deployed agent environment.
+    
+    DESIGN DECISION: We suppress INFO logging during this call to avoid duplicate
+    initialization messages since the deployment service will be initialized again
+    later in the ClaudeRunner.
     """
-    agent_versions = get_agent_versions_display()
-    if agent_versions:
-        print(agent_versions)
-        print()  # Extra newline after the display
+    # Temporarily suppress INFO level logging to avoid duplicate initialization messages
+    import logging
+    original_level = logging.getLogger("claude_mpm").level
+    logging.getLogger("claude_mpm").setLevel(logging.WARNING)
+    
+    try:
+        agent_versions = get_agent_versions_display()
+        if agent_versions:
+            print(agent_versions)
+            print()  # Extra newline after the display
+    finally:
+        # Restore original logging level
+        logging.getLogger("claude_mpm").setLevel(original_level)
 
 
 def setup_logging(args) -> object:

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/core/base_service.py

@@ -159,7 +159,7 @@ class BaseService(LoggerMixin, ABC):
 
         # Only log if not in quiet mode
         if not os.environ.get("CLAUDE_PM_QUIET_MODE", "").lower() == "true":
-            self.logger.info(f"Initialized {self.name} service")
+            self.logger.debug(f"Initialized {self.name} service")
 
     def _init_enhanced_features(self):
         """Initialize enhanced features when enabled."""

{claude_mpm-4.0.19 → claude_mpm-4.0.20}/src/claude_mpm/core/config.py

@@ -24,6 +24,9 @@ class Config:
     """
     Configuration manager for Claude PM services.
 
+    Implements singleton pattern to ensure configuration is loaded only once
+    and shared across all services.
+
     Supports loading from:
     - Python dictionaries
     - JSON files
@@ -31,6 +34,23 @@ class Config:
     - Environment variables
     """
 
+    _instance = None
+    _initialized = False
+    _success_logged = False  # Class-level flag to track if success message was already logged
+
+    def __new__(cls, *args, **kwargs):
+        """Implement singleton pattern to ensure single configuration instance.
+        
+        WHY: Configuration was being loaded 11 times during startup, once for each service.
+        This singleton pattern ensures configuration is loaded only once and reused.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            logger.info("Creating new Config singleton instance")
+        else:
+            logger.debug("Reusing existing Config singleton instance")
+        return cls._instance
+
     def __init__(
         self,
         config: Optional[Dict[str, Any]] = None,
@@ -45,6 +65,21 @@ class Config:
             config_file: Path to configuration file (JSON or YAML)
             env_prefix: Prefix for environment variables
         """
+        # Skip initialization if already done (singleton pattern)
+        if Config._initialized:
+            logger.debug("Config already initialized, skipping re-initialization")
+            # If someone tries to load a different config file after initialization,
+            # log a debug message but don't reload
+            if config_file and str(config_file) != getattr(self, '_loaded_from', None):
+                logger.debug(
+                    f"Ignoring config_file parameter '{config_file}' - "
+                    f"configuration already loaded from '{getattr(self, '_loaded_from', 'defaults')}'"
+                )
+            return
+        
+        Config._initialized = True
+        logger.info("Initializing Config singleton for the first time")
+        
         self._config: Dict[str, Any] = {}
         self._env_prefix = env_prefix
         self._config_mgr = ConfigurationManager(cache_enabled=True)
@@ -55,22 +90,24 @@ class Config:
 
         # Track where configuration was loaded from
         self._loaded_from = None
+        # Track the actual file we loaded from to prevent re-loading
+        self._actual_loaded_file = None
 
         # Load from file if provided
         if config_file:
-            self.load_file(config_file)
+            self.load_file(config_file, is_initial_load=True)
             self._loaded_from = str(config_file)
         else:
             # Try to load from standard location: .claude-mpm/configuration.yaml
             default_config = Path.cwd() / ".claude-mpm" / "configuration.yaml"
             if default_config.exists():
-                self.load_file(default_config)
+                self.load_file(default_config, is_initial_load=True)
                 self._loaded_from = str(default_config)
             else:
                 # Also try .yml extension
                 alt_config = Path.cwd() / ".claude-mpm" / "configuration.yml"
                 if alt_config.exists():
-                    self.load_file(alt_config)
+                    self.load_file(alt_config, is_initial_load=True)
                     self._loaded_from = str(alt_config)
 
         # Load from environment variables (new and legacy prefixes)
@@ -80,13 +117,22 @@ class Config:
         # Apply defaults
         self._apply_defaults()
 
-    def load_file(self, file_path: Union[str, Path]) -> None:
+    def load_file(self, file_path: Union[str, Path], is_initial_load: bool = True) -> None:
         """Load configuration from file with enhanced error handling.
 
         WHY: Configuration loading failures can cause silent issues. We need
         to provide clear, actionable error messages to help users fix problems.
+        
+        Args:
+            file_path: Path to the configuration file
+            is_initial_load: Whether this is the initial configuration load (for logging control)
         """
         file_path = Path(file_path)
+        
+        # Check if we've already loaded from this exact file to prevent duplicate messages
+        if hasattr(self, '_actual_loaded_file') and self._actual_loaded_file == str(file_path):
+            logger.debug(f"Configuration already loaded from {file_path}, skipping reload")
+            return
 
         if not file_path.exists():
             logger.warning(f"Configuration file not found: {file_path}")
@@ -113,7 +159,14 @@ class Config:
             file_config = self._config_mgr.load_auto(file_path)
             if file_config:
                 self._config = self._config_mgr.merge_configs(self._config, file_config)
-                logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                # Track that we've successfully loaded from this file
+                self._actual_loaded_file = str(file_path)
+                # Only log success message once using class-level flag to avoid duplicate messages
+                if is_initial_load and not Config._success_logged:
+                    logger.info(f"✓ Successfully loaded configuration from {file_path}")
+                    Config._success_logged = True
+                else:
+                    logger.debug(f"Configuration reloaded from {file_path}")
 
                 # Log important configuration values for debugging
                 if logger.isEnabledFor(logging.DEBUG):
@@ -789,3 +842,15 @@ class Config:
     def __repr__(self) -> str:
         """String representation of configuration."""
         return f"<Config({len(self._config)} keys)>"
+    
+    @classmethod
+    def reset_singleton(cls):
+        """Reset the singleton instance (mainly for testing purposes).
+        
+        WHY: During testing, we may need to reset the singleton to test different
+        configurations. This method allows controlled reset of the singleton state.
+        """
+        cls._instance = None
+        cls._initialized = False
+        cls._success_logged = False
+        logger.debug("Config singleton reset")