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

claude_mpm/cli/startup_display.py

@@ -7,7 +7,7 @@ Shows welcome message, version info, ASCII art, and what's new section.
 import os
 import re
 import shutil
-import subprocess
+import subprocess  # nosec B404 - required for git operations
 from pathlib import Path
 from typing import List
 
@@ -65,8 +65,8 @@ def _get_recent_commits(max_commits: int = 3) -> List[str]:
         if not is_git_repository("."):
             return []
 
-        # Run git log with custom format
-        result = subprocess.run(
+        # Run git log with custom format (safe - no user input)
+        result = subprocess.run(  # nosec B603 B607
             ["git", "log", "--format=%h • %ar • %s", f"-{max_commits}"],
             capture_output=True,
             text=True,
@@ -216,6 +216,59 @@ def _get_cwd_display(max_width: int = 40) -> str:
     return "..." + cwd[-(max_width - 3) :]
 
 
+def _count_mpm_skills() -> int:
+    """
+    Count user-level MPM skills from ~/.claude/skills/.
+
+    Returns:
+        Number of skill directories with SKILL.md files
+    """
+    try:
+        user_skills_dir = Path.home() / ".claude" / "skills"
+        if not user_skills_dir.exists():
+            return 0
+
+        # Count directories with SKILL.md (skill directories)
+        skill_count = 0
+        for item in user_skills_dir.iterdir():
+            if item.is_dir():
+                skill_file = item / "SKILL.md"
+                if skill_file.exists():
+                    skill_count += 1
+            # Also count standalone .md files (legacy format)
+            elif item.is_file() and item.suffix == ".md" and item.name != "README.md":
+                skill_count += 1
+
+        return skill_count
+    except Exception:
+        # Silent failure - return 0 if any error
+        return 0
+
+
+def _count_deployed_agents() -> int:
+    """
+    Count deployed agents from .claude/agents/.
+
+    Returns:
+        Number of deployed agent files
+    """
+    try:
+        deploy_target = Path.cwd() / ".claude" / "agents"
+        if not deploy_target.exists():
+            return 0
+
+        # Count .md files, excluding README and other docs
+        agent_files = [
+            f
+            for f in deploy_target.glob("*.md")
+            if not f.name.startswith(("README", "INSTRUCTIONS", "."))
+        ]
+        return len(agent_files)
+    except Exception:
+        # Silent failure - return 0 if any error
+        return 0
+
+
 def _format_two_column_line(
     left: str, right: str, left_panel_width: int, right_panel_width: int
 ) -> str:
@@ -402,11 +455,25 @@ def display_startup_banner(version: str, logging_level: str) -> None:
             )
         )
 
-    # Line 10: Model info | separator
+    # Line 10: Model info with counts | separator
     separator = "─" * right_panel_width
+    agent_count = _count_deployed_agents()
+    skill_count = _count_mpm_skills()
+
+    # Format: "Sonnet 4.5 · 44 agents, 19 skills"
+    if agent_count > 0 or skill_count > 0:
+        counts_text = []
+        if agent_count > 0:
+            counts_text.append(f"{agent_count} agent{'s' if agent_count != 1 else ''}")
+        if skill_count > 0:
+            counts_text.append(f"{skill_count} skill{'s' if skill_count != 1 else ''}")
+        model_info = f"Sonnet 4.5 · {', '.join(counts_text)}"
+    else:
+        model_info = "Sonnet 4.5 · Claude MPM"
+
     lines.append(
         _format_two_column_line(
-            "Sonnet 4.5 · Claude MPM", separator, left_panel_width, right_panel_width
+            model_info, separator, left_panel_width, right_panel_width
         )
     )
 

claude_mpm/cli/startup_logging.py

@@ -672,7 +672,7 @@ async def trigger_vector_search_indexing(project_root: Optional[Path] = None) ->
             # Using installed binary
             cmd = [vector_search_path, "index", str(project_root)]
 
-        logger.info(
+        logger.debug(
             "MCP Vector Search: Starting background indexing for improved code search"
         )
 
@@ -761,7 +761,7 @@ def _start_vector_search_subprocess(project_root: Optional[Path] = None) -> None
         else:
             cmd = [vector_search_path, "index", str(project_root)]
 
-        logger.info(
+        logger.debug(
             "MCP Vector Search: Starting background indexing for improved code search"
         )
 

claude_mpm/commands/mpm-session-resume.md

@@ -21,7 +21,7 @@ Load and display context from most recent paused session.
 - Git context and recent commits
 - Next recommended actions
 
-**Session location:** `.claude-mpm/sessions/session-*.json`
+**Session location:** `.claude-mpm/sessions/session-*.md`
 
 **Token usage:** ~20-40k tokens (10-20% of context budget)
 

claude_mpm/constants.py

@@ -169,6 +169,7 @@ class SkillsCommands(str, Enum):
     INFO = "info"
     CONFIG = "config"
     CONFIGURE = "configure"  # Interactive skills selection (like agents configure)
+    SELECT = "select"  # Interactive topic-grouped skill selector
     # GitHub deployment commands
     DEPLOY_FROM_GITHUB = "deploy-github"
     LIST_AVAILABLE = "list-available"

claude_mpm/core/claude_runner.py

@@ -730,7 +730,7 @@ Use these agents to delegate specialized work via the Task tool.
                     import json
 
                     settings = json.loads(settings_file.read_text())
-                    if settings.get("activeOutputStyle") == "claude-mpm":
+                    if settings.get("activeOutputStyle") == "Claude MPM":
                         # Already active, check if file exists
                         output_style_file = (
                             Path.home() / ".claude" / "output-styles" / "claude-mpm.md"
@@ -740,7 +740,7 @@ Use these agents to delegate specialized work via the Task tool.
                                 "Output style 'Claude MPM' already deployed and active"
                             )
                             return
-                except Exception:
+                except Exception:  # nosec B110
                     pass  # Continue with deployment if we can't read settings
 
             # Read the OUTPUT_STYLE.md content if it exists

claude_mpm/core/hook_manager.py

@@ -16,13 +16,15 @@ import contextlib
 import json
 import os
 import queue
-import subprocess
+import subprocess  # nosec B404
 import threading
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
+from ..services.event_bus.event_bus import EventBus
+from ..services.event_log import get_event_log
 from .hook_error_memory import get_hook_error_memory
 from .hook_performance_config import get_hook_performance_config
 from .unified_paths import get_package_root
@@ -46,6 +48,10 @@ class HookManager:
         # Initialize error memory for tracking and preventing repeated errors
         self.error_memory = get_hook_error_memory()
 
+        # Initialize event log and event bus for event-driven architecture
+        self.event_log = get_event_log()
+        self.event_bus = EventBus.get_instance()
+
         # Initialize background hook processing for async execution
         self.performance_config = get_hook_performance_config()
         queue_config = self.performance_config.get_queue_config()
@@ -100,6 +106,45 @@ class HookManager:
         self.background_thread.start()
         self.logger.debug("Started background hook processor thread")
 
+    def _publish_error_event(
+        self, hook_type: str, error_info: Dict[str, str], suggestion: str
+    ):
+        """Publish hook error event to event log and event bus.
+
+        WHY publish events:
+        - Decouple error detection from error handling
+        - Enable autotodos CLI to read from persistent event log
+        - Support real-time notifications via event bus
+        - Maintain audit trail of all hook errors
+
+        Args:
+            hook_type: Type of hook that failed
+            error_info: Error information from error detection
+            suggestion: Fix suggestion from error memory
+        """
+        try:
+            # Prepare event payload
+            payload = {
+                "error_type": error_info["type"],
+                "hook_type": hook_type,
+                "details": error_info.get("details", ""),
+                "full_message": error_info.get("match", ""),
+                "suggested_fix": suggestion,
+                "source": "hook_manager",
+            }
+
+            # Publish to event log (persistent storage)
+            self.event_log.append_event(
+                event_type="autotodo.error", payload=payload, status="pending"
+            )
+
+            # Publish to event bus (real-time listeners)
+            self.event_bus.publish("autotodo.error", payload)
+
+        except Exception as e:
+            # Don't let event publishing break hook processing
+            self.logger.debug(f"Failed to publish error event: {e}")
+
     def _execute_hook_sync(self, hook_data: Dict[str, Any]):
         """Execute a single hook synchronously in the background thread with error detection.
 
@@ -141,7 +186,7 @@ class HookManager:
             env["CLAUDE_MPM_HOOK_DEBUG"] = "true"
 
             # Execute with timeout in background thread
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["python", str(self.hook_handler_path)],
                 input=event_json,
                 text=True,
@@ -157,7 +202,7 @@ class HookManager:
             )
 
             if error_info:
-                # Record the error
+                # Record the error in memory (for skipping repeated failures)
                 self.error_memory.record_error(error_info, hook_type)
 
                 # Get fix suggestion
@@ -165,6 +210,9 @@ class HookManager:
 
                 # Log error with suggestion
                 self.logger.warning(f"Hook {hook_type} error detected:\n{suggestion}")
+
+                # Publish event to event log for autotodos processing
+                self._publish_error_event(hook_type, error_info, suggestion)
             elif result.returncode != 0:
                 # Non-zero return without detected pattern
                 self.logger.debug(f"Hook {hook_type} returned code {result.returncode}")

claude_mpm/core/interactive_session.py

@@ -12,7 +12,7 @@ of InteractiveSession without circular dependency issues.
 
 import contextlib
 import os
-import subprocess
+import subprocess  # nosec B404
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
@@ -359,19 +359,19 @@ class InteractiveSession:
                 osm = self.runner.framework_loader.output_style_manager
                 if osm:
                     if osm.claude_version and osm.supports_output_styles():
-                        # Check if claude-mpm style is active
+                        # Check if Claude MPM style is active
                         settings_file = osm.settings_file
                         if settings_file.exists():
                             import json
 
                             settings = json.loads(settings_file.read_text())
                             active_style = settings.get("activeOutputStyle")
-                            if active_style == "claude-mpm":
-                                return "Output Style: claude-mpm ✅"
+                            if active_style in ("Claude MPM", "Claude MPM Teacher"):
+                                return f"Output Style: {active_style} ✅"
                             return f"Output Style: {active_style or 'none'}"
                         return "Output Style: Available"
                     return "Output Style: Injected (legacy)"
-        except Exception:
+        except Exception:  # nosec B110
             pass
         return None
 
@@ -582,7 +582,7 @@ class InteractiveSession:
             )
 
         # This will not return if successful
-        os.execvpe(cmd[0], cmd, env)
+        os.execvpe(cmd[0], cmd, env)  # nosec B606
         return False  # Only reached on failure
 
     def _launch_subprocess_mode(self, cmd: list, env: dict) -> bool:
@@ -641,7 +641,7 @@ class InteractiveSession:
             cmd = environment["command"]
             env = environment["environment"]
 
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603
                 cmd, stdin=None, stdout=None, stderr=None, env=env, check=False
             )
 

claude_mpm/core/output_style_manager.py

@@ -13,7 +13,7 @@ Users can change it if they want, and the system will respect their choice.
 
 import json
 import re
-import subprocess
+import subprocess  # nosec B404
 from pathlib import Path
 from typing import Any, Dict, Literal, Optional, TypedDict, cast
 
@@ -27,7 +27,7 @@ _CACHED_CLAUDE_VERSION: Optional[str] = None
 _VERSION_DETECTED: bool = False
 
 # Output style types
-OutputStyleType = Literal["professional", "teaching"]
+OutputStyleType = Literal["professional", "teaching", "founders"]
 
 
 class StyleConfig(TypedDict):
@@ -41,9 +41,10 @@ class StyleConfig(TypedDict):
 class OutputStyleManager:
     """Manages output style deployment and version-based handling.
 
-    Supports two output styles:
+    Supports three output styles:
     - professional: Default Claude MPM style (claude-mpm.md)
-    - teaching: Adaptive teaching mode (claude-mpm-teach.md)
+    - teaching: Adaptive teaching mode (claude-mpm-teacher.md)
+    - founders: Non-technical mode for startup founders (claude-mpm-founders.md)
     """
 
     def __init__(self) -> None:
@@ -51,8 +52,8 @@ class OutputStyleManager:
         self.logger = get_logger("output_style_manager")  # type: ignore[misc]
         self.claude_version = self._detect_claude_version()
 
-        # Deploy to ~/.claude/styles/ directory (NOT output-styles/)
-        self.output_style_dir = Path.home() / ".claude" / "styles"
+        # Deploy to ~/.claude/output-styles/ directory (official Claude Code location)
+        self.output_style_dir = Path.home() / ".claude" / "output-styles"
         self.settings_file = Path.home() / ".claude" / "settings.json"
 
         # Style definitions
@@ -62,14 +63,21 @@ class OutputStyleManager:
                 / "agents"
                 / "CLAUDE_MPM_OUTPUT_STYLE.md",
                 target=self.output_style_dir / "claude-mpm.md",
-                name="claude-mpm",
+                name="Claude MPM",
             ),
             "teaching": StyleConfig(
                 source=Path(__file__).parent.parent
                 / "agents"
                 / "CLAUDE_MPM_TEACHER_OUTPUT_STYLE.md",
-                target=self.output_style_dir / "claude-mpm-teach.md",
-                name="claude-mpm-teach",
+                target=self.output_style_dir / "claude-mpm-teacher.md",
+                name="Claude MPM Teacher",
+            ),
+            "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",
             ),
         }
 
@@ -93,7 +101,7 @@ class OutputStyleManager:
 
         try:
             # Run claude --version command
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["claude", "--version"],
                 capture_output=True,
                 text=True,
@@ -300,12 +308,12 @@ 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") -> bool:
         """
         Update Claude Code settings to activate a specific output style.
 
         Args:
-            style_name: Name of the style to activate (e.g., "claude-mpm", "claude-mpm-teach")
+            style_name: Name of the style to activate (e.g., "Claude MPM", "Claude MPM Teacher")
 
         Returns:
             True if activated successfully, False otherwise
@@ -443,7 +451,7 @@ class OutputStyleManager:
 
         # Activate the default style if requested
         if activate_default and results.get("professional", False):
-            self._activate_output_style("claude-mpm")
+            self._activate_output_style("Claude MPM")
 
         return results
 

claude_mpm/core/unified_config.py

@@ -16,7 +16,7 @@ Design Principles:
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, field_validator
 from pydantic_settings import BaseSettings
 
 from .exceptions import ConfigurationError
@@ -54,8 +54,9 @@ class LoggingConfig(BaseModel):
         default=True, description="Enable console logging"
     )
 
-    @validator("level")
-    def validate_log_level(self, v):
+    @field_validator("level")
+    @classmethod
+    def validate_log_level(cls, v):
         valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
         if v.upper() not in valid_levels:
             raise ValueError(f"Invalid log level. Must be one of: {valid_levels}")
@@ -65,8 +66,32 @@ class LoggingConfig(BaseModel):
 class AgentConfig(BaseModel):
     """Agent system configuration."""
 
+    # Explicit deployment lists (simplified model)
+    enabled: List[str] = Field(
+        default_factory=list,
+        description="Explicit list of agent IDs to deploy (empty = use auto_discover)",
+    )
+
+    # Required agents that are always deployed
+    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",
+        ],
+        description="Agents that are always deployed (core system agents)",
+    )
+
+    include_universal: bool = Field(
+        default=True,
+        description="Auto-include all agents with 'universal' toolchain/category",
+    )
+
     auto_discover: bool = Field(
-        default=True, description="Enable automatic agent discovery"
+        default=False,
+        description="Enable automatic agent discovery (deprecated, use enabled list)",
     )
     precedence: List[str] = Field(
         default=["project", "user", "system"], description="Agent precedence order"
@@ -239,6 +264,21 @@ class DocumentationConfig(BaseModel):
     )
 
 
+class SkillConfig(BaseModel):
+    """Skill system configuration."""
+
+    # Explicit deployment lists (simplified model)
+    enabled: List[str] = Field(
+        default_factory=list,
+        description="Explicit list of skill IDs to deploy (includes agent dependencies)",
+    )
+
+    auto_detect_dependencies: bool = Field(
+        default=True,
+        description="Automatically include skills required by enabled agents",
+    )
+
+
 class UnifiedConfig(BaseSettings):
     """
     Unified configuration model for Claude MPM.
@@ -258,6 +298,7 @@ class UnifiedConfig(BaseSettings):
     network: NetworkConfig = Field(default_factory=NetworkConfig)
     logging: LoggingConfig = Field(default_factory=LoggingConfig)
     agents: AgentConfig = Field(default_factory=AgentConfig)
+    skills: SkillConfig = Field(default_factory=SkillConfig)
     memory: MemoryConfig = Field(default_factory=MemoryConfig)
     security: SecurityConfig = Field(default_factory=SecurityConfig)
     performance: PerformanceConfig = Field(default_factory=PerformanceConfig)
@@ -287,8 +328,9 @@ class UnifiedConfig(BaseSettings):
         validate_assignment = True
         extra = "allow"  # Allow extra fields for backward compatibility
 
-    @validator("environment")
-    def validate_environment(self, v):
+    @field_validator("environment")
+    @classmethod
+    def validate_environment(cls, v):
         valid_envs = ["development", "testing", "production"]
         if v not in valid_envs:
             raise ValueError(f"Invalid environment. Must be one of: {valid_envs}")
@@ -554,12 +596,12 @@ class ConfigurationService:
                 import yaml
 
                 with file_path.open("w") as f:
-                    yaml.dump(self._config.dict(), f, default_flow_style=False)
+                    yaml.dump(self._config.model_dump(), f, default_flow_style=False)
             elif format.lower() == "json":
                 import json
 
                 with file_path.open("w") as f:
-                    json.dump(self._config.dict(), f, indent=2)
+                    json.dump(self._config.model_dump(), f, indent=2)
             else:
                 raise ConfigurationError(f"Unsupported export format: {format}")
 

claude_mpm/core/unified_paths.py

@@ -1,4 +1,3 @@
-#!/usr/bin/env python3
 """
 Unified Path Management System for Claude MPM
 ==============================================
@@ -36,6 +35,24 @@ from claude_mpm.core.logging_utils import get_logger
 logger = get_logger(__name__)
 
 
+def _safe_cwd() -> Path:
+    """Safely get the current working directory.
+
+    If the current directory no longer exists (deleted/moved), fall back to home directory.
+    This prevents FileNotFoundError when Path.cwd() is called from a deleted directory.
+
+    Returns:
+        Path: Current working directory, or home directory if cwd doesn't exist
+    """
+    try:
+        return Path.cwd()
+    except (FileNotFoundError, OSError) as e:
+        logger.debug(
+            f"Current directory doesn't exist ({e}), falling back to home directory"
+        )
+        return Path.home()
+
+
 class PathType(Enum):
     """Enumeration of different path types for categorization."""
 
@@ -95,7 +112,7 @@ class PathContext:
 
             # Additional check: If we're running from within a claude-mpm development directory
             # This handles the case where pipx claude-mpm is invoked from within the dev directory
-            cwd = Path.cwd()
+            cwd = _safe_cwd()
             current = cwd
             for _ in range(5):  # Check up to 5 levels up from current directory
                 if (current / "pyproject.toml").exists() and (
@@ -114,7 +131,7 @@ class PathContext:
                             # Verify this is a development setup by checking for key files
                             if (current / "scripts" / "claude-mpm").exists():
                                 return True
-                    except Exception:
+                    except Exception:  # nosec B110
                         pass
                 if current == current.parent:
                     break
@@ -140,7 +157,7 @@ class PathContext:
                                         f"Found editable install via .pth file: {pth_file}"
                                     )
                                     return True
-                            except Exception:
+                            except Exception:  # nosec B112
                                 continue
 
                         # Check for egg-link files
@@ -156,7 +173,7 @@ class PathContext:
                                             f"Found editable install via egg-link: {egg_link}"
                                         )
                                         return True
-                                except Exception:
+                                except Exception:  # nosec B112
                                     continue
             except ImportError:
                 pass
@@ -186,7 +203,7 @@ class PathContext:
 
         # 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 = Path.cwd()
+        cwd = _safe_cwd()
         current = cwd
         for _ in range(5):  # Check up to 5 levels up from current directory
             if (current / "pyproject.toml").exists() and (
@@ -206,7 +223,7 @@ class PathContext:
                             "Using development mode for local source preference"
                         )
                         return DeploymentContext.DEVELOPMENT
-                except Exception:
+                except Exception:  # nosec B110
                     pass
             if current == current.parent:
                 break
@@ -228,7 +245,7 @@ class PathContext:
                 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 = Path.cwd()
+                    cwd = _safe_cwd()
                     current = cwd
                     for _ in range(5):
                         if (current / "src" / "claude_mpm").exists() and (
@@ -346,7 +363,7 @@ class UnifiedPathManager:
             ):
                 # For development mode, first check if we're running from within a dev directory
                 # This handles the case where pipx is invoked from a development directory
-                cwd = Path.cwd()
+                cwd = _safe_cwd()
                 current = cwd
                 for _ in range(5):
                     if (current / "src" / "claude_mpm").exists() and (
@@ -360,7 +377,7 @@ class UnifiedPathManager:
                                     f"Found framework root via cwd at {current}"
                                 )
                                 return current
-                        except Exception:
+                        except Exception:  # nosec B110
                             pass
                     if current == current.parent:
                         break
@@ -403,7 +420,7 @@ class UnifiedPathManager:
     @lru_cache(maxsize=1)
     def project_root(self) -> Path:
         """Get the current project root directory."""
-        current = Path.cwd()
+        current = _safe_cwd()
         while current != current.parent:
             for marker in self._project_markers:
                 if (current / marker).exists():
@@ -413,7 +430,7 @@ class UnifiedPathManager:
 
         # Fallback to current directory
         logger.warning("Could not find project root, using current directory")
-        return Path.cwd()
+        return _safe_cwd()
 
     @property
     def package_root(self) -> Path:
@@ -562,7 +579,7 @@ class UnifiedPathManager:
         self, filename: str, start_path: Optional[Path] = None
     ) -> Optional[Path]:
         """Search for a file by traversing up the directory tree."""
-        current = start_path or Path.cwd()
+        current = start_path or _safe_cwd()
 
         while current != current.parent:
             candidate = current / filename