claude-mpm 4.5.1__py3-none-any.whl → 4.5.6__py3-none-any.whl

claude_mpm/VERSION

@@ -1 +1 @@
-4.5.1
+4.5.6

claude_mpm/agents/PM_INSTRUCTIONS.md

@@ -61,6 +61,10 @@
 ❌ "No issues found" without scan results → MUST have scan evidence
 ❌ "Performance improved" without metrics → MUST have measurement data
 ❌ "Security enhanced" without audit → MUST have security verification
+❌ "Running on localhost:XXXX" without fetch verification → MUST have HTTP response evidence
+❌ "Server started successfully" without log evidence → MUST have process/log verification
+❌ "Application available at..." without accessibility test → MUST have endpoint check
+❌ "You can now access..." without verification → MUST have browser/fetch test
 
 ## ONLY ALLOWED PM TOOLS
 ✓ Task - For delegation to agents (PRIMARY TOOL - USE THIS 90% OF TIME)
@@ -267,6 +271,30 @@ Requirements:
 5. Report: "Deployment VERIFIED" or "Deployment FAILED: [specific issues]"
 ```
 
+## LOCAL DEPLOYMENT MANDATORY VERIFICATION
+
+**CRITICAL**: PM MUST NEVER claim "running on localhost" without verification.
+
+### Required for ALL Local Deployments (PM2, Docker, npm start, etc.):
+1. PM MUST delegate to local-ops-agent (or Ops) for deployment
+2. Ops agent MUST verify with ALL of these:
+   - Process status check (ps, pm2 status, docker ps)
+   - Log examination for startup errors
+   - Fetch test to claimed URL (e.g., curl http://localhost:3000)
+   - Response validation (HTTP status code, content check)
+3. PM can ONLY report success WITH evidence:
+   - ✅ "Verified running at localhost:3000: [HTTP 200 response]"
+   - ❌ "Should be running on localhost:3000" (VIOLATION)
+   - ❌ "Application is available at..." (VIOLATION without proof)
+
+### Automatic Violation Triggers for Localhost Claims:
+These phrases without fetch evidence = IMMEDIATE VIOLATION:
+- "running on localhost"
+- "available at localhost"
+- "access at http://localhost"
+- "server started on port"
+- "deployment successful" (without verification)
+
 ## QA Requirements
 
 **Rule**: No QA = Work incomplete
@@ -375,6 +403,11 @@ When PM attempts forbidden action:
 - "I think" → VIOLATION: Need agent analysis
 - "Probably" → VIOLATION: Need verification
 
+**Localhost Assertion Red Flags:**
+- "Running on localhost" → VIOLATION: Need fetch verification
+- "Server is up" → VIOLATION: Need process + fetch proof
+- "You can access" → VIOLATION: Need endpoint test
+
 ### ✅ CORRECT PM PHRASES:
 - "I'll delegate this to..."
 - "I'll have [Agent] handle..."

claude_mpm/cli/__init__.py

@@ -222,6 +222,14 @@ def _check_mcp_auto_configuration():
         logger = get_logger("cli")
         logger.debug(f"MCP auto-configuration check failed: {e}")
 
+    # Skip MCP service fixes for the doctor command
+    # The doctor command performs its own comprehensive MCP service check
+    # Running both would cause duplicate checks and log messages (9 seconds apart)
+    import sys
+
+    if len(sys.argv) > 1 and sys.argv[1] == "doctor":
+        return
+
     # Also ensure MCP services are properly configured in ~/.claude.json
     # This fixes incorrect paths and adds missing services
     try:
@@ -289,23 +297,31 @@ def _verify_mcp_gateway_startup():
         # Quick check first - if already configured, skip detailed verification
         gateway_configured = is_mcp_gateway_configured()
 
-        # Pre-warm MCP servers regardless of gateway config
-        # This eliminates the 11.9s delay on first agent invocation
+        # DISABLED: Pre-warming MCP servers can interfere with Claude Code's MCP management
+        # This was causing issues with MCP server initialization and stderr handling
+        # def run_pre_warming():
+        #     loop = None
+        #     try:
+        #         start_time = time.time()
+        #         loop = asyncio.new_event_loop()
+        #         asyncio.set_event_loop(loop)
+        #
+        #         # Pre-warm MCP servers (especially vector search)
+        #         logger.info("Pre-warming MCP servers to eliminate startup delay...")
+        #         loop.run_until_complete(pre_warm_mcp_servers())
+        #
+        #         pre_warm_time = time.time() - start_time
+        #         if pre_warm_time > 1.0:
+        #             logger.info(f"MCP servers pre-warmed in {pre_warm_time:.2f}s")
+
+        # Dummy function to maintain structure
         def run_pre_warming():
             loop = None
             try:
-                start_time = time.time()
+                time.time()
                 loop = asyncio.new_event_loop()
                 asyncio.set_event_loop(loop)
 
-                # Pre-warm MCP servers (especially vector search)
-                logger.info("Pre-warming MCP servers to eliminate startup delay...")
-                loop.run_until_complete(pre_warm_mcp_servers())
-
-                pre_warm_time = time.time() - start_time
-                if pre_warm_time > 1.0:
-                    logger.info(f"MCP servers pre-warmed in {pre_warm_time:.2f}s")
-
                 # Also run gateway verification if needed
                 if not gateway_configured:
                     loop.run_until_complete(verify_mcp_gateway_on_startup())

claude_mpm/cli/commands/doctor.py

@@ -137,10 +137,7 @@ def doctor_command(args):
         output_format = "markdown"
     elif output_file:
         # Force markdown format when writing to file (unless json specified)
-        if str(output_file).endswith(".json"):
-            output_format = "json"
-        else:
-            output_format = "markdown"
+        output_format = "json" if str(output_file).endswith(".json") else "markdown"
     else:
         output_format = "terminal"
 

claude_mpm/core/config.py

@@ -56,7 +56,7 @@ class Config:
                 # Double-check locking pattern for thread safety
                 if cls._instance is None:
                     cls._instance = super().__new__(cls)
-                    logger.info("Creating new Config singleton instance")
+                    logger.debug("Creating new Config singleton instance")
                 else:
                     logger.debug(
                         "Reusing existing Config singleton instance (concurrent init)"
@@ -102,7 +102,7 @@ class Config:
                 return
 
             Config._initialized = True
-            logger.info("Initializing Config singleton for the first time")
+            logger.debug("Initializing Config singleton for the first time")
 
             # Initialize instance variables inside the lock to ensure thread safety
             self._config: Dict[str, Any] = {}

claude_mpm/core/framework/__init__.py

@@ -22,17 +22,17 @@ from .processors import (
 )
 
 __all__ = [
-    # Loaders
-    "FileLoader",
-    "PackagedLoader",
-    "InstructionLoader",
     "AgentLoader",
+    "CapabilityGenerator",
     # Formatters
     "ContentFormatter",
-    "CapabilityGenerator",
     "ContextGenerator",
+    # Loaders
+    "FileLoader",
+    "InstructionLoader",
+    "MemoryProcessor",
     # Processors
     "MetadataProcessor",
+    "PackagedLoader",
     "TemplateProcessor",
-    "MemoryProcessor",
 ]

claude_mpm/core/unified_paths.py

@@ -178,7 +178,7 @@ class PathContext:
         """
         # Check for environment variable override
         if os.environ.get("CLAUDE_MPM_DEV_MODE", "").lower() in ("1", "true", "yes"):
-            logger.info(
+            logger.debug(
                 "Development mode forced via CLAUDE_MPM_DEV_MODE environment variable"
             )
             return DeploymentContext.DEVELOPMENT
@@ -198,10 +198,10 @@ class PathContext:
                         'name = "claude-mpm"' in pyproject_content
                         or '"claude-mpm"' in pyproject_content
                     ):
-                        logger.info(
+                        logger.debug(
                             f"Detected claude-mpm development directory at {current}"
                         )
-                        logger.info(
+                        logger.debug(
                             "Using development mode for local source preference"
                         )
                         return DeploymentContext.DEVELOPMENT
@@ -219,7 +219,7 @@ class PathContext:
             # First check if this is an editable install, regardless of path
             # This is important for cases where pipx points to a development installation
             if PathContext._is_editable_install():
-                logger.info("Detected editable/development installation")
+                logger.debug("Detected editable/development installation")
                 # Check if we should use development paths
                 # This could be because we're in a src/ directory or running from dev directory
                 if module_path.parent.name == "src":
@@ -233,7 +233,7 @@ class PathContext:
                         if (current / "src" / "claude_mpm").exists() and (
                             current / "pyproject.toml"
                         ).exists():
-                            logger.info(
+                            logger.debug(
                                 "Running pipx from development directory, using development mode"
                             )
                             return DeploymentContext.DEVELOPMENT
@@ -249,33 +249,33 @@ class PathContext:
                 module_path.parent.name == "src"
                 and (module_path.parent.parent / "src" / "claude_mpm").exists()
             ):
-                logger.info(
+                logger.debug(
                     f"Detected development mode via directory structure at {module_path}"
                 )
                 return DeploymentContext.DEVELOPMENT
 
             # Check for pipx install
             if "pipx" in str(module_path):
-                logger.info(f"Detected pipx installation at {module_path}")
+                logger.debug(f"Detected pipx installation at {module_path}")
                 return DeploymentContext.PIPX_INSTALL
 
             # Check for system package
             if "dist-packages" in str(module_path):
-                logger.info(f"Detected system package installation at {module_path}")
+                logger.debug(f"Detected system package installation at {module_path}")
                 return DeploymentContext.SYSTEM_PACKAGE
 
             # Check for site-packages (could be pip or editable)
             if "site-packages" in str(module_path):
                 # Already checked for editable above, so this is a regular pip install
-                logger.info(f"Detected pip installation at {module_path}")
+                logger.debug(f"Detected pip installation at {module_path}")
                 return DeploymentContext.PIP_INSTALL
 
             # Default to pip install
-            logger.info(f"Defaulting to pip installation for {module_path}")
+            logger.debug(f"Defaulting to pip installation for {module_path}")
             return DeploymentContext.PIP_INSTALL
 
         except ImportError:
-            logger.info(
+            logger.debug(
                 "ImportError during context detection, defaulting to development"
             )
             return DeploymentContext.DEVELOPMENT
@@ -321,7 +321,8 @@ class UnifiedPathManager:
         ]
         self._initialized = True
 
-        logger.info(
+        # Use debug level for initialization details
+        logger.debug(
             f"UnifiedPathManager initialized with context: {self._deployment_context.value}"
         )
 

claude_mpm/hooks/kuzu_memory_hook.py

@@ -230,7 +230,7 @@ Note: Use the memories above to provide more informed and contextual responses.
             # Extract memory content and metadata
             content = memory.get("content", "")
             tags = memory.get("tags", [])
-            timestamp = memory.get("timestamp", "")
+            memory.get("timestamp", "")
             relevance = memory.get("relevance", 0.0)
 
             # Format memory entry

claude_mpm/init.py

@@ -141,6 +141,25 @@ class ProjectInitializer:
             if not gitignore.exists():
                 gitignore.write_text("logs/\n*.log\n*.pyc\n__pycache__/\n")
 
+            # Also ensure MCP directories are in main project .gitignore
+            try:
+                from claude_mpm.services.project.project_organizer import (
+                    ProjectOrganizer,
+                )
+
+                # Check if we're in a git repository
+                if (project_root / ".git").exists():
+                    organizer = ProjectOrganizer(project_root)
+                    # This will add MCP directories and other standard patterns
+                    organizer.update_gitignore()
+                    self.logger.debug(
+                        "Updated project .gitignore with MCP and standard patterns"
+                    )
+            except Exception as e:
+                self.logger.debug(
+                    f"Could not update project gitignore with MCP patterns: {e}"
+                )
+
             # Log successful creation with details
             self.logger.info(f"Initialized project directory at {self.project_dir}")
             self.logger.debug("Created directories: agents, config, responses, logs")

claude_mpm/services/async_session_logger.py

@@ -175,6 +175,11 @@ class AsyncSessionLogger:
         if self.enable_async:
             self._start_worker()
 
+        # Log initialization status
+        logger.info(
+            f"AsyncSessionLogger initialized: session_id={self.session_id}, async={self.enable_async}, format={self.log_format.value}"
+        )
+
     def _get_claude_session_id(self) -> str:
         """Get or generate a Claude session ID."""
         # Check environment variables in order of preference
@@ -471,8 +476,19 @@ class AsyncSessionLogger:
         Args:
             timeout: Maximum time to wait for shutdown
         """
+        # Only log shutdown if we're actually shutting down an active logger
+        if self._shutdown:
+            logger.debug("AsyncSessionLogger already shut down")
+            return
+
         if self.enable_async:
-            logger.info("Shutting down async logger")
+            # Only log at INFO level if we actually processed something
+            if self.stats.get("logged", 0) > 0 or self.stats.get("queued", 0) > 0:
+                logger.info(
+                    f"Shutting down async logger (logged: {self.stats.get('logged', 0)}, queued: {self.stats.get('queued', 0)})"
+                )
+            else:
+                logger.debug("Shutting down async logger (no activity)")
 
             # Signal shutdown
             self._shutdown = True
@@ -484,8 +500,18 @@ class AsyncSessionLogger:
                 if self._worker_thread.is_alive():
                     logger.warning("Worker thread did not shutdown cleanly")
 
-            # Log final statistics
-            logger.info(f"Logger stats: {self.stats}")
+            # Log final statistics only if we actually logged something
+            if self.stats.get("logged", 0) > 0:
+                logger.info(f"AsyncSessionLogger final stats: {self.stats}")
+            elif self.stats.get("queued", 0) > 0 or self.stats.get("dropped", 0) > 0:
+                logger.debug(
+                    f"AsyncSessionLogger stats (incomplete session): {self.stats}"
+                )
+            else:
+                # Use debug level when nothing was logged
+                logger.debug(
+                    f"AsyncSessionLogger stats (no sessions logged): {self.stats}"
+                )
 
     def get_stats(self) -> Dict[str, Any]:
         """Get logger statistics."""

claude_mpm/services/claude_session_logger.py

@@ -101,8 +101,16 @@ class ClaudeSessionLogger:
 
         if self.use_async:
             try:
+                # Pass our session_id to async logger to avoid duplicate generation
                 self._async_logger = get_async_logger(config=config)
-                logger.info("Using async logger for improved performance")
+                # Synchronize session IDs - use the one we already generated
+                if self.session_id and hasattr(self._async_logger, "set_session_id"):
+                    self._async_logger.set_session_id(self.session_id)
+                    logger.info(
+                        f"Using async logger with session ID: {self.session_id}"
+                    )
+                else:
+                    logger.info("Using async logger for improved performance")
             except Exception as e:
                 logger.warning(
                     f"Failed to initialize async logger, falling back to sync: {e}"
@@ -135,9 +143,9 @@ class ClaudeSessionLogger:
         if not session_id:
             # Use a timestamp-based session ID as fallback
             session_id = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
-            logger.info(f"No Claude session ID found, using generated: {session_id}")
+            logger.info(f"Session ID: {session_id} (generated)")
         else:
-            logger.info(f"Using Claude session ID: {session_id}")
+            logger.info(f"Session ID: {session_id}")
 
         return session_id
 

claude_mpm/services/diagnostics/checks/mcp_services_check.py

@@ -195,7 +195,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
 
             # Determine overall status
             errors = [r for r in sub_results if r.status == DiagnosticStatus.ERROR]
-            warnings = [r for r in sub_results if r.status == DiagnosticStatus.WARNING]
+            [r for r in sub_results if r.status == DiagnosticStatus.WARNING]
 
             if errors:
                 status = DiagnosticStatus.ERROR
@@ -508,7 +508,7 @@ class MCPServicesCheck(BaseDiagnosticCheck):
                         # Special case for kuzu-memory with args
                         mcp_command = ["pipx", "run", base_cmd[0]] + base_cmd[1:]
                     else:
-                        mcp_command = ["pipx", "run"] + base_cmd
+                        mcp_command = ["pipx", "run", *base_cmd]
             else:
                 mcp_command = config["mcp_command"]
 

claude_mpm/services/diagnostics/doctor_reporter.py

@@ -508,8 +508,6 @@ class DoctorReporter:
         recommendations = []
 
         # Analyze results for recommendations
-        has_errors = summary.error_count > 0
-        has_warnings = summary.warning_count > 0
 
         # Check specific conditions
         for result in summary.results: