claude-mpm 5.4.96__py3-none-any.whl → 5.6.17__py3-none-any.whl

claude_mpm/core/config.py

@@ -12,11 +12,10 @@ import threading
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-import yaml
-
 from claude_mpm.core.logging_utils import get_logger
 
-from ..utils.config_manager import ConfigurationManager
+# Lazy import ConfigurationManager to avoid importing yaml at module level
+# This prevents hook errors when yaml isn't available in the execution environment
 from .exceptions import ConfigurationError, FileOperationError
 from .unified_paths import get_path_manager
 
@@ -104,6 +103,9 @@ class Config:
             Config._initialized = True
             logger.debug("Initializing Config singleton for the first time")
 
+            # Lazy import ConfigurationManager at runtime to avoid yaml import at module level
+            from ..utils.config_manager import ConfigurationManager
+
             # Initialize instance variables inside the lock to ensure thread safety
             self._config: Dict[str, Any] = {}
             self._env_prefix = env_prefix
@@ -224,21 +226,6 @@ class Config:
                             f"Response logging format: {response_logging.get('format', 'json')}"
                         )
 
-        except yaml.YAMLError as e:
-            logger.error(f"YAML syntax error in {file_path}: {e}")
-            if hasattr(e, "problem_mark"):
-                mark = e.problem_mark
-                logger.error(f"Error at line {mark.line + 1}, column {mark.column + 1}")
-            logger.info(
-                "TIP: Validate your YAML at https://www.yamllint.com/ or run: python scripts/validate_configuration.py"
-            )
-            logger.info(
-                "TIP: Common issue - YAML requires spaces, not tabs. Fix with: sed -i '' 's/\t/    /g' "
-                + str(file_path)
-            )
-            # Store error for later retrieval
-            self._config["_load_error"] = str(e)
-
         except json.JSONDecodeError as e:
             logger.error(f"JSON syntax error in {file_path}: {e}")
             logger.error(f"Error at line {e.lineno}, column {e.colno}")
@@ -255,7 +242,28 @@ class Config:
                 },
             ) from e
         except Exception as e:
-            # Catch any remaining unexpected errors and wrap them as configuration errors
+            # Handle YAML errors without importing yaml at module level
+            # ConfigurationManager.load_yaml raises yaml.YAMLError, but we don't want to import yaml
+            # Check if it's a YAML error by class name to avoid import
+            if e.__class__.__name__ == "YAMLError":
+                logger.error(f"YAML syntax error in {file_path}: {e}")
+                if hasattr(e, "problem_mark"):
+                    mark = e.problem_mark
+                    logger.error(
+                        f"Error at line {mark.line + 1}, column {mark.column + 1}"
+                    )
+                logger.info(
+                    "TIP: Validate your YAML at https://www.yamllint.com/ or run: python scripts/validate_configuration.py"
+                )
+                logger.info(
+                    "TIP: Common issue - YAML requires spaces, not tabs. Fix with: sed -i '' 's/\t/    /g' "
+                    + str(file_path)
+                )
+                # Store error for later retrieval
+                self._config["_load_error"] = str(e)
+                return  # Don't re-raise, we handled it
+
+            # Not a YAML error, wrap as configuration error
             raise ConfigurationError(
                 f"Unexpected error loading configuration from {file_path}: {e}",
                 context={
@@ -605,6 +613,11 @@ class Config:
                 "sync_interval": "startup",  # Options: "startup", "hourly", "daily", "manual"
                 "cache_dir": str(Path.home() / ".claude-mpm" / "cache" / "agents"),
             },
+            # Autotodos configuration
+            "autotodos": {
+                "auto_inject_on_startup": True,  # Auto-inject pending todos on PM session start
+                "max_todos_per_session": 10,  # Max todos to inject per session
+            },
         }
 
         # Apply defaults for missing keys

claude_mpm/core/logger.py

@@ -214,19 +214,22 @@ def setup_logging(
 
     # Console handler
     if console_output:
+        # MUST use stderr to avoid corrupting hook JSON output
+        # WHY stderr: Hook handlers output JSON to stdout. Logging to stdout
+        # corrupts this JSON and causes "hook error" messages from Claude Code.
         if use_streaming:
             # Use streaming handler for single-line INFO messages
-            console_handler = StreamingHandler(sys.stdout)
+            console_handler = StreamingHandler(sys.stderr)
             console_handler.setFormatter(simple_formatter)
         elif use_rich and not json_format:
             # Rich support has been removed, use standard handler
-            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler = logging.StreamHandler(sys.stderr)
             console_handler.setFormatter(simple_formatter)
         else:
-            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler = logging.StreamHandler(sys.stderr)
             console_handler.setFormatter(formatter if json_format else simple_formatter)
 
-        console_handler.setLevel(logging.INFO)
+        console_handler.setLevel(log_level)  # Respect the requested log level
         logger.addHandler(console_handler)
 
     # File handler
@@ -263,7 +266,7 @@ def setup_logging(
                 if deleted_count > 0:
                     # Log to the new file handler that we're about to add
                     pass  # Deletion count will be logged when logger is ready
-            except Exception:
+            except Exception:  # nosec B110 - intentional: logging should not break app
                 pass  # Ignore cleanup errors
 
             # Also create a symlink to latest log (with thread safety)
@@ -305,7 +308,7 @@ def setup_logging(
                     # Fallback: try to create a regular file with reference to actual log
                     try:
                         latest_link.write_text(f"Latest log: {log_file.name}\n")
-                    except Exception:
+                    except Exception:  # nosec B110 - intentional: logging should not break app
                         pass  # Silently fail - logging should not break the application
                 except Exception as e:
                     # Catch any other unexpected errors to ensure logging doesn't break
@@ -381,15 +384,29 @@ def cleanup_old_mpm_logs(
             try:
                 log_file.unlink()
                 deleted_count += 1
-            except Exception:
+            except Exception:  # nosec B110 - intentional: log cleanup is best-effort
                 pass  # Ignore deletion errors
 
         return deleted_count
 
 
 def get_logger(name: str) -> logging.Logger:
-    """Get a logger instance."""
-    return logging.getLogger(f"claude_mpm.{name}")
+    """Get a logger instance.
+
+    CRITICAL: Respects startup suppression mode (CRITICAL+1) to prevent
+    early INFO logs before setup_logging() is called.
+    """
+    logger = logging.getLogger(f"claude_mpm.{name}")
+
+    # Check if root logger is suppressed (startup.py sets CRITICAL+1)
+    root_logger = logging.getLogger()
+    if root_logger.level > logging.CRITICAL:
+        # Suppression active - ensure this logger is also suppressed
+        logger.setLevel(logging.CRITICAL + 1)
+        logger.handlers = []
+        logger.propagate = False
+
+    return logger
 
 
 def setup_streaming_logger(name: str, level: str = "INFO") -> logging.Logger:

claude_mpm/core/logging_utils.py

@@ -103,21 +103,45 @@ class LoggerFactory:
 
         # Set up root logger
         root_logger = logging.getLogger()
-        root_logger.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
+
+        # CRITICAL FIX: Respect existing root logger suppression
+        # If root logger is already set to CRITICAL+1 (suppressed by startup.py),
+        # don't override it. This prevents logging from appearing during startup
+        # before the CLI's setup_logging() runs.
+        current_level = root_logger.level
+        desired_level = LoggingConfig.LEVELS.get(cls._log_level, logging.INFO)
+
+        # Only set level if current is unset (0) or lower than desired
+        # CRITICAL+1 is 51, so this check preserves suppression
+        should_configure_logging = current_level == 0 or (
+            current_level < desired_level and current_level <= logging.CRITICAL
+        )
+
+        if should_configure_logging:
+            root_logger.setLevel(desired_level)
+        # else: root logger is suppressed (CRITICAL+1), keep it suppressed
 
         # Remove existing handlers
         root_logger.handlers = []
 
-        # Console handler
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setLevel(LoggingConfig.LEVELS.get(cls._log_level, logging.INFO))
-        console_formatter = logging.Formatter(
-            log_format or LoggingConfig.DEFAULT_FORMAT,
-            date_format or LoggingConfig.DATE_FORMAT,
-        )
-        console_handler.setFormatter(console_formatter)
-        root_logger.addHandler(console_handler)
-        cls._handlers["console"] = console_handler
+        # CRITICAL FIX: Don't add handlers if logging is suppressed
+        # If root logger is at CRITICAL+1 (startup suppression), don't add any handlers
+        # This prevents early imports from logging before CLI setup_logging() runs
+        if should_configure_logging:
+            # Console handler - MUST use stderr to avoid corrupting hook JSON output
+            # WHY stderr: Hook handlers output JSON to stdout. Logging to stdout
+            # corrupts this JSON and causes "hook error" messages from Claude Code.
+            console_handler = logging.StreamHandler(sys.stderr)
+            console_handler.setLevel(
+                LoggingConfig.LEVELS.get(cls._log_level, logging.INFO)
+            )
+            console_formatter = logging.Formatter(
+                log_format or LoggingConfig.DEFAULT_FORMAT,
+                date_format or LoggingConfig.DATE_FORMAT,
+            )
+            console_handler.setFormatter(console_formatter)
+            root_logger.addHandler(console_handler)
+            cls._handlers["console"] = console_handler
 
         # File handler (optional)
         if log_to_file and cls._log_dir:

claude_mpm/core/output_style_manager.py

@@ -27,7 +27,9 @@ _CACHED_CLAUDE_VERSION: Optional[str] = None
 _VERSION_DETECTED: bool = False
 
 # Output style types
-OutputStyleType = Literal["professional", "teaching", "founders"]
+OutputStyleType = Literal[
+    "professional", "teaching", "research", "founders"
+]  # "founders" is deprecated, use "research"
 
 
 class StyleConfig(TypedDict):
@@ -44,7 +46,7 @@ class OutputStyleManager:
     Supports three output styles:
     - professional: Default Claude MPM style (claude-mpm.md)
     - teaching: Adaptive teaching mode (claude-mpm-teacher.md)
-    - founders: Non-technical mode for startup founders (claude-mpm-founders.md)
+    - research: Codebase research mode for founders, PMs, and developers (claude-mpm-research.md)
     """
 
     def __init__(self) -> None:
@@ -72,12 +74,20 @@ class OutputStyleManager:
                 target=self.output_style_dir / "claude-mpm-teacher.md",
                 name="Claude MPM Teacher",
             ),
+            "research": StyleConfig(
+                source=Path(__file__).parent.parent
+                / "agents"
+                / "CLAUDE_MPM_RESEARCH_OUTPUT_STYLE.md",
+                target=self.output_style_dir / "claude-mpm-research.md",
+                name="Claude MPM Research",
+            ),
+            # Backward compatibility alias (deprecated)
             "founders": StyleConfig(
                 source=Path(__file__).parent.parent
                 / "agents"
-                / "CLAUDE_MPM_FOUNDERS_OUTPUT_STYLE.md",
-                target=self.output_style_dir / "claude-mpm-founders.md",
-                name="Claude MPM Founders",
+                / "CLAUDE_MPM_RESEARCH_OUTPUT_STYLE.md",
+                target=self.output_style_dir / "claude-mpm-research.md",
+                name="Claude MPM Research",
             ),
         }
 
@@ -287,6 +297,9 @@ class OutputStyleManager:
             target_path = style_config["target"]
             style_name = style_config["name"]
 
+            # Check if this is a fresh install (file doesn't exist yet)
+            is_fresh_install = not target_path.exists()
+
             # If content not provided, read from source
             if content is None:
                 content = self.extract_output_style_content(style=style)
@@ -300,7 +313,9 @@ class OutputStyleManager:
 
             # Activate the style if requested
             if activate:
-                self._activate_output_style(style_name)
+                self._activate_output_style(
+                    style_name, is_fresh_install=is_fresh_install
+                )
 
             return True
 
@@ -308,12 +323,21 @@ class OutputStyleManager:
             self.logger.error(f"Failed to deploy {style} style: {e}")
             return False
 
-    def _activate_output_style(self, style_name: str = "Claude MPM") -> bool:
+    def _activate_output_style(
+        self, style_name: str = "Claude MPM", is_fresh_install: bool = False
+    ) -> bool:
         """
         Update Claude Code settings to activate a specific output style.
 
+        Only activates the style if:
+        1. No active style is currently set (first deployment), OR
+        2. This is a fresh install (style file didn't exist before deployment)
+
+        This preserves user preferences if they've manually changed their active style.
+
         Args:
             style_name: Name of the style to activate (e.g., "Claude MPM", "Claude MPM Teacher")
+            is_fresh_install: Whether this is a fresh install (style file didn't exist before)
 
         Returns:
             True if activated successfully, False otherwise
@@ -332,8 +356,12 @@ class OutputStyleManager:
             # Check current active style
             current_style = settings.get("activeOutputStyle")
 
-            # Update active output style if different
-            if current_style != style_name:
+            # Only set activeOutputStyle if:
+            # 1. No active style is set (first deployment), OR
+            # 2. This is a fresh install (file didn't exist before deployment)
+            should_activate = current_style is None or is_fresh_install
+
+            if should_activate and current_style != style_name:
                 settings["activeOutputStyle"] = style_name
 
                 # Ensure settings directory exists
@@ -348,7 +376,10 @@ class OutputStyleManager:
                     f"✅ Activated {style_name} output style (was: {current_style or 'none'})"
                 )
             else:
-                self.logger.debug(f"{style_name} output style already active")
+                self.logger.debug(
+                    f"Preserving user preference: {current_style or 'none'} "
+                    f"(skipping activation of {style_name})"
+                )
 
             return True
 
@@ -442,6 +473,10 @@ class OutputStyleManager:
         """
         results: Dict[str, bool] = {}
 
+        # Check if professional style exists BEFORE deployment
+        # This determines if this is a fresh install
+        professional_style_existed = self.styles["professional"]["target"].exists()
+
         for style_type_key in self.styles:
             # Deploy without activation
             # Cast is safe because we know self.styles keys are OutputStyleType
@@ -449,9 +484,11 @@ class OutputStyleManager:
             success = self.deploy_output_style(style=style_type, activate=False)
             results[style_type] = success
 
-        # Activate the default style if requested
+        # Activate the default style if requested AND this is first deployment
         if activate_default and results.get("professional", False):
-            self._activate_output_style("Claude MPM")
+            self._activate_output_style(
+                "Claude MPM", is_fresh_install=not professional_style_existed
+            )
 
         return results
 

claude_mpm/core/unified_config.py

@@ -73,15 +73,19 @@ class AgentConfig(BaseModel):
     )
 
     # Required agents that are always deployed
+    # Standard 7 core agents for essential PM workflow functionality
+    # These are auto-deployed when no agents are specified in configuration
     required: List[str] = Field(
         default_factory=lambda: [
-            "research",
-            "mpm-skills-manager",
-            "mpm-agent-manager",
-            "memory-manager-agent",  # Specific agent ID (not generic "memory-manager")
-            "ticketing",
+            "engineer",  # General-purpose implementation
+            "research",  # Codebase exploration and analysis
+            "qa",  # Testing and quality assurance
+            "web-qa",  # Browser-based testing specialist
+            "documentation",  # Documentation generation
+            "ops",  # Basic deployment operations
+            "ticketing",  # Ticket tracking (essential for PM workflow)
         ],
-        description="Agents that are always deployed (core system agents)",
+        description="Agents that are always deployed (standard 7 core agents)",
     )
 
     include_universal: bool = Field(

claude_mpm/core/unified_paths.py

@@ -76,6 +76,7 @@ class DeploymentContext(Enum):
     EDITABLE_INSTALL = "editable_install"
     PIP_INSTALL = "pip_install"
     PIPX_INSTALL = "pipx_install"
+    UV_TOOLS = "uv_tools"
     SYSTEM_PACKAGE = "system_package"
 
 
@@ -190,113 +191,100 @@ class PathContext:
 
         Priority order:
         1. Environment variable override (CLAUDE_MPM_DEV_MODE)
-        2. Current working directory is a claude-mpm development project
-        3. Editable installation detection
-        4. Path-based detection (development, pipx, system, pip)
+        2. Package installation path (uv tools, pipx, site-packages, editable)
+        3. Current working directory (opt-in with CLAUDE_MPM_PREFER_LOCAL_SOURCE)
+
+        This ensures installed packages use their installation paths rather than
+        accidentally picking up development paths from CWD.
         """
-        # Check for environment variable override
+        # 1. Explicit environment variable override
         if os.environ.get("CLAUDE_MPM_DEV_MODE", "").lower() in ("1", "true", "yes"):
             logger.debug(
                 "Development mode forced via CLAUDE_MPM_DEV_MODE environment variable"
             )
             return DeploymentContext.DEVELOPMENT
 
-        # Check if current working directory is a claude-mpm development project
-        # This handles the case where pipx claude-mpm is run from within the dev directory
-        cwd = _safe_cwd()
-        current = cwd
-        for _ in range(5):  # Check up to 5 levels up from current directory
-            if (current / "pyproject.toml").exists() and (
-                current / "src" / "claude_mpm"
-            ).exists():
-                # Check if this is the claude-mpm project
-                try:
-                    pyproject_content = (current / "pyproject.toml").read_text()
-                    if (
-                        'name = "claude-mpm"' in pyproject_content
-                        or '"claude-mpm"' in pyproject_content
-                    ):
-                        logger.debug(
-                            f"Detected claude-mpm development directory at {current}"
-                        )
-                        logger.debug(
-                            "Using development mode for local source preference"
-                        )
-                        return DeploymentContext.DEVELOPMENT
-                except Exception:  # nosec B110
-                    pass
-            if current == current.parent:
-                break
-            current = current.parent
-
+        # 2. Check where the actual package is installed
         try:
             import claude_mpm
 
             module_path = Path(claude_mpm.__file__).parent
+            package_str = str(module_path)
 
-            # 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.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":
-                    return DeploymentContext.DEVELOPMENT
-                if "pipx" in str(module_path):
-                    # Running via pipx but from within a development directory
-                    # Use development mode to prefer local source over pipx installation
-                    cwd = _safe_cwd()
-                    current = cwd
-                    for _ in range(5):
-                        if (current / "src" / "claude_mpm").exists() and (
-                            current / "pyproject.toml"
-                        ).exists():
-                            logger.debug(
-                                "Running pipx from development directory, using development mode"
-                            )
-                            return DeploymentContext.DEVELOPMENT
-                        if current == current.parent:
-                            break
-                        current = current.parent
-                    return DeploymentContext.EDITABLE_INSTALL
-                return DeploymentContext.EDITABLE_INSTALL
+            # UV tools installation (~/.local/share/uv/tools/)
+            if "/.local/share/uv/tools/" in package_str:
+                logger.debug(f"Detected uv tools installation at {module_path}")
+                return DeploymentContext.UV_TOOLS
 
-            # Check for development mode based on directory structure
-            # module_path is typically /path/to/project/src/claude_mpm
-            if (
-                module_path.parent.name == "src"
-                and (module_path.parent.parent / "src" / "claude_mpm").exists()
-            ):
+            # pipx installation (~/.local/pipx/venvs/)
+            if "/.local/pipx/venvs/" in package_str or "/pipx/" in package_str:
+                logger.debug(f"Detected pipx installation at {module_path}")
+                return DeploymentContext.PIPX_INSTALL
+
+            # site-packages (pip install) - but not editable
+            if "/site-packages/" in package_str and "/src/" not in package_str:
+                logger.debug(f"Detected pip installation at {module_path}")
+                return DeploymentContext.PIP_INSTALL
+
+            # Editable install (pip install -e) - module in src/
+            if module_path.parent.name == "src":
+                # Check if this is truly an editable install
+                if PathContext._is_editable_install():
+                    logger.debug(f"Detected editable installation at {module_path}")
+                    return DeploymentContext.EDITABLE_INSTALL
+                # Module in src/ but not editable - development mode
                 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.debug(f"Detected pipx installation at {module_path}")
-                return DeploymentContext.PIPX_INSTALL
-
-            # Check for system package
-            if "dist-packages" in str(module_path):
+            # dist-packages (system package manager)
+            if "dist-packages" in package_str:
                 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.debug(f"Detected pip installation at {module_path}")
-                return DeploymentContext.PIP_INSTALL
-
-            # Default to pip install
+            # Default to pip install for any other installation
             logger.debug(f"Defaulting to pip installation for {module_path}")
             return DeploymentContext.PIP_INSTALL
 
         except ImportError:
             logger.debug(
-                "ImportError during context detection, defaulting to development"
+                "ImportError during module path detection, checking CWD as fallback"
             )
-            return DeploymentContext.DEVELOPMENT
+
+        # 3. CWD-based detection (OPT-IN ONLY for explicit development work)
+        # Only use CWD if explicitly requested or no package installation found
+        if os.environ.get("CLAUDE_MPM_PREFER_LOCAL_SOURCE", "").lower() in (
+            "1",
+            "true",
+            "yes",
+        ):
+            cwd = _safe_cwd()
+            current = cwd
+            for _ in range(5):  # Check up to 5 levels up from current directory
+                if (current / "pyproject.toml").exists() and (
+                    current / "src" / "claude_mpm"
+                ).exists():
+                    # Check if this is the claude-mpm project
+                    try:
+                        pyproject_content = (current / "pyproject.toml").read_text()
+                        if (
+                            'name = "claude-mpm"' in pyproject_content
+                            or '"claude-mpm"' in pyproject_content
+                        ):
+                            logger.debug(
+                                f"CLAUDE_MPM_PREFER_LOCAL_SOURCE: Using development directory at {current}"
+                            )
+                            return DeploymentContext.DEVELOPMENT
+                    except Exception:  # nosec B110
+                        pass
+                if current == current.parent:
+                    break
+                current = current.parent
+
+        # Final fallback: assume development mode
+        logger.debug("No installation detected, defaulting to development mode")
+        return DeploymentContext.DEVELOPMENT
 
 
 class UnifiedPathManager:

claude_mpm/experimental/cli_enhancements.py

@@ -58,8 +58,9 @@ class CLIContext:
             else "%(message)s"
         )
 
+        # MUST use stderr to avoid corrupting hook JSON output
         logging.basicConfig(
-            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stdout)]
+            level=level, format=format_str, handlers=[logging.StreamHandler(sys.stderr)]
         )
         self.debug = debug