claude-mpm 4.1.6__py3-none-any.whl → 4.24.0__py3-none-any.whl

claude_mpm/core/hook_manager.py

@@ -19,7 +19,7 @@ import queue
 import subprocess
 import threading
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from ..core.logger import get_logger
@@ -106,7 +106,9 @@ class HookManager:
             hook_event = {
                 "hook_event_name": hook_type,
                 "session_id": self.session_id,
-                "timestamp": hook_data.get("timestamp", datetime.utcnow().isoformat()),
+                "timestamp": hook_data.get(
+                    "timestamp", datetime.now(timezone.utc).isoformat()
+                ),
                 **event_data,
             }
 
@@ -182,7 +184,7 @@ class HookManager:
             {
                 "tool_name": tool_name,
                 "tool_args": tool_args or {},
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             },
         )
 
@@ -205,7 +207,7 @@ class HookManager:
                 "tool_name": tool_name,
                 "exit_code": exit_code,
                 "result": str(result) if result is not None else None,
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             },
         )
 
@@ -220,7 +222,7 @@ class HookManager:
         """
         return self._trigger_hook_event(
             "UserPromptSubmit",
-            {"prompt": prompt, "timestamp": datetime.utcnow().isoformat()},
+            {"prompt": prompt, "timestamp": datetime.now(timezone.utc).isoformat()},
         )
 
     def _trigger_hook_event(self, hook_type: str, event_data: Dict[str, Any]) -> bool:
@@ -250,7 +252,7 @@ class HookManager:
             hook_data = {
                 "hook_type": hook_type,
                 "event_data": event_data,
-                "timestamp": datetime.utcnow().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
             }
 
             # Try to queue without blocking

claude_mpm/core/injectable_service.py

@@ -182,14 +182,17 @@ class InjectableService(BaseService, ABC):
                 continue
 
             attr = getattr(self, attr_name, None)
-            if attr and hasattr(attr, "start") and hasattr(attr, "running"):
-                # It's a service that needs to be started
-                if not attr.running:
-                    try:
-                        await attr.start()
-                        logger.debug(f"Started dependency {attr_name}")
-                    except Exception as e:
-                        logger.warning(f"Failed to start dependency {attr_name}: {e}")
+            if (
+                attr
+                and hasattr(attr, "start")
+                and hasattr(attr, "running")
+                and not attr.running
+            ):
+                try:
+                    await attr.start()
+                    logger.debug(f"Started dependency {attr_name}")
+                except Exception as e:
+                    logger.warning(f"Failed to start dependency {attr_name}: {e}")
 
     def __repr__(self) -> str:
         """Enhanced string representation showing dependencies."""

claude_mpm/core/instruction_reinforcement_hook.py

@@ -0,0 +1,267 @@
+"""Instruction Reinforcement Hook for PM instruction drift prevention.
+
+This module implements a hook that intercepts TodoWrite calls and injects
+reminder messages at configurable intervals to combat PM instruction drift
+during long conversations.
+
+WHY this is needed:
+- PM agents can drift from their original instructions during long sessions
+- Direct tool usage (Edit, Write, Bash) is a common drift pattern
+- Reminder injection via TodoWrite is a non-intrusive way to reinforce instructions
+- Configurable intervals and message rotation provide flexibility
+
+The hook works by:
+1. Tracking TodoWrite call count
+2. Injecting reminders at configured intervals (default: every 5 calls)
+3. Rotating through multiple reminder messages
+4. Providing metrics for monitoring effectiveness
+"""
+
+import threading
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+from ..core.enums import OperationResult
+from ..core.logger import get_logger
+
+
+class InstructionReinforcementHook:
+    """Hook for injecting instruction reminders into TodoWrite calls.
+
+    This class intercepts TodoWrite operations and periodically injects
+    reminder messages to help prevent PM instruction drift.
+
+    Key features:
+    - Configurable injection intervals
+    - Message rotation for variety
+    - Thread-safe operation
+    - Metrics tracking
+    - Test mode support
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """Initialize the instruction reinforcement hook.
+
+        Args:
+            config: Configuration dictionary with optional keys:
+                - enabled: Whether the hook is enabled (default: True)
+                - test_mode: Whether to use test messages (default: True)
+                - injection_interval: Calls between injections (default: 5)
+                - test_messages: List of test messages to rotate through
+        """
+        self.logger = get_logger("instruction_reinforcement_hook")
+
+        # Initialize configuration
+        config = config or {}
+        self.enabled = config.get("enabled", True)
+        self.test_mode = config.get("test_mode", True)
+        self.injection_interval = config.get("injection_interval", 5)
+
+        # Thread-safe counters
+        self._lock = threading.Lock()
+        self.call_count = 0
+        self.injection_count = 0
+        self.message_index = 0
+
+        # Default test messages (will be used in test_mode)
+        self.test_messages = config.get(
+            "test_messages",
+            [
+                "[TEST-REMINDER] This is an injected instruction reminder",
+                "[PM-INSTRUCTION] Remember to delegate all work to agents",
+                "[PM-INSTRUCTION] Do not use Edit, Write, or Bash tools directly",
+                "[PM-INSTRUCTION] Your role is orchestration and coordination",
+            ],
+        )
+
+        # Production messages (used when test_mode=False)
+        self.production_messages = [
+            "[STOP] Are you about to use Edit/Write/Bash? Delegate to Engineer instead!",
+            "[DELEGATE] Your job is coordination, not implementation - pass this to an agent",
+            "[REMINDER] PM = Project Manager, not Project Implementer - delegate this work",
+            "[CHECK] If you're reading code files, stop and delegate to Research Agent",
+            "[WARNING] Direct implementation detected - use 'do this yourself' to override",
+        ]
+
+        self.logger.info(
+            f"InstructionReinforcementHook initialized: "
+            f"enabled={self.enabled}, test_mode={self.test_mode}, "
+            f"interval={self.injection_interval}"
+        )
+
+    def intercept_todowrite(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Intercept TodoWrite parameters and potentially inject reminders.
+
+        Args:
+            params: TodoWrite parameters dictionary containing 'todos' list
+
+        Returns:
+            Modified parameters with potentially injected reminders
+        """
+        if not self.enabled:
+            return params
+
+        try:
+            # Extract todos safely
+            todos = params.get("todos", [])
+            if not isinstance(todos, list):
+                self.logger.warning("Invalid todos format - skipping injection")
+                return params
+
+            with self._lock:
+                self.call_count += 1
+
+                # Check if we should inject
+                if self.should_inject():
+                    modified_todos = self.inject_reminders(todos)
+                    params = params.copy()  # Don't modify original
+                    params["todos"] = modified_todos
+                    self.injection_count += 1
+
+                    self.logger.info(
+                        f"Injected reminder #{self.injection_count} at call #{self.call_count}"
+                    )
+
+            return params
+
+        except Exception as e:
+            self.logger.error(f"Error in TodoWrite interception: {e}")
+            # Return original params on error to avoid breaking functionality
+            return params
+
+    def should_inject(self) -> bool:
+        """Determine if a reminder should be injected.
+
+        Returns:
+            True if injection should occur
+        """
+        if not self.enabled:
+            return False
+
+        return self.call_count % self.injection_interval == 0
+
+    def inject_reminders(self, todos: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Inject reminder message into todos list.
+
+        Args:
+            todos: Original todos list
+
+        Returns:
+            Modified todos list with reminder injected at the beginning
+        """
+        # Choose message set based on mode
+        messages = self.test_messages if self.test_mode else self.production_messages
+
+        # Get next message (rotate through available messages)
+        message = messages[self.message_index % len(messages)]
+        self.message_index += 1
+
+        # Create reminder todo
+        reminder_todo = {
+            "content": message,
+            "status": OperationResult.PENDING,
+            "activeForm": "Processing instruction reminder",
+        }
+
+        # Insert at beginning of todos list
+        modified_todos = todos.copy()
+        modified_todos.insert(0, reminder_todo)
+
+        self.logger.debug(f"Injected reminder: {message}")
+
+        return modified_todos
+
+    def get_metrics(self) -> Dict[str, Any]:
+        """Get current hook metrics.
+
+        Returns:
+            Dictionary containing metrics:
+            - call_count: Total TodoWrite calls processed
+            - injection_count: Total reminders injected
+            - injection_rate: Ratio of injections to calls
+            - next_injection_in: Calls until next injection
+            - enabled: Whether hook is enabled
+            - test_mode: Whether using test messages
+        """
+        with self._lock:
+            next_injection = self.injection_interval - (
+                self.call_count % self.injection_interval
+            )
+            if next_injection == self.injection_interval:
+                next_injection = 0  # Next call will trigger injection
+
+            return {
+                "call_count": self.call_count,
+                "injection_count": self.injection_count,
+                "injection_rate": self.injection_count / max(self.call_count, 1),
+                "next_injection_in": next_injection,
+                "enabled": self.enabled,
+                "test_mode": self.test_mode,
+                "injection_interval": self.injection_interval,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+            }
+
+    def reset_counters(self):
+        """Reset all counters to zero.
+
+        Useful for testing or starting fresh tracking.
+        """
+        with self._lock:
+            self.call_count = 0
+            self.injection_count = 0
+            self.message_index = 0
+
+        self.logger.info("Reset instruction reinforcement counters")
+
+    def update_config(self, config: Dict[str, Any]):
+        """Update hook configuration.
+
+        Args:
+            config: New configuration values
+        """
+        if "enabled" in config:
+            self.enabled = config["enabled"]
+        if "test_mode" in config:
+            self.test_mode = config["test_mode"]
+        if "injection_interval" in config:
+            self.injection_interval = max(1, config["injection_interval"])  # Minimum 1
+        if "test_messages" in config:
+            self.test_messages = config["test_messages"]
+
+        self.logger.info(f"Updated configuration: {config}")
+
+
+# Global instance for singleton pattern
+_instruction_reinforcement_hook: Optional[InstructionReinforcementHook] = None
+_hook_lock = threading.Lock()
+
+
+def get_instruction_reinforcement_hook(
+    config: Optional[Dict[str, Any]] = None,
+) -> InstructionReinforcementHook:
+    """Get the global instruction reinforcement hook instance.
+
+    Args:
+        config: Configuration for first-time initialization
+
+    Returns:
+        InstructionReinforcementHook instance
+    """
+    global _instruction_reinforcement_hook
+
+    with _hook_lock:
+        if _instruction_reinforcement_hook is None:
+            _instruction_reinforcement_hook = InstructionReinforcementHook(config)
+
+    return _instruction_reinforcement_hook
+
+
+def reset_instruction_reinforcement_hook():
+    """Reset the global hook instance.
+
+    Primarily used for testing to ensure clean state.
+    """
+    global _instruction_reinforcement_hook
+
+    with _hook_lock:
+        _instruction_reinforcement_hook = None

claude_mpm/core/interactive_session.py

@@ -8,8 +8,10 @@ import contextlib
 import os
 import subprocess
 import uuid
+from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
+from claude_mpm.core.enums import ServiceState
 from claude_mpm.core.logger import get_logger
 
 
@@ -35,7 +37,7 @@ class InteractiveSession:
         self.runner = runner
         self.logger = get_logger("interactive_session")
         self.session_id = None
-        self.original_cwd = os.getcwd()
+        self.original_cwd = Path.cwd()
 
         # Initialize response tracking for interactive sessions
         # WHY: Interactive sessions need response logging just like oneshot sessions.
@@ -178,7 +180,8 @@ class InteractiveSession:
             # Notify WebSocket if connected
             if self.runner.websocket_server:
                 self.runner.websocket_server.claude_status_changed(
-                    status="starting", message="Launching Claude interactive session"
+                    status=ServiceState.STARTING,
+                    message="Launching Claude interactive session",
                 )
 
             # Launch using selected method
@@ -225,7 +228,7 @@ class InteractiveSession:
         """
         try:
             # Restore original directory
-            if self.original_cwd and os.path.exists(self.original_cwd):
+            if self.original_cwd and Path(self.original_cwd).exists():
                 with contextlib.suppress(OSError):
                     os.chdir(self.original_cwd)
 
@@ -278,7 +281,7 @@ class InteractiveSession:
             self.runner.websocket_server.session_started(
                 session_id=self.session_id,
                 launch_method=self.runner.launch_method,
-                working_dir=os.getcwd(),
+                working_dir=Path.cwd(),
             )
             return True, None
 
@@ -310,6 +313,9 @@ class InteractiveSession:
         print(
             "\033[32m│\033[0m     /mpm        - MPM overview and help           \033[32m│\033[0m"
         )
+        print(
+            "\033[32m│\033[0m     /mpm-init   - Initialize or update project    \033[32m│\033[0m"
+        )
         print(
             "\033[32m│\033[0m     /mpm-agents - Show available agents           \033[32m│\033[0m"
         )
@@ -369,7 +375,7 @@ class InteractiveSession:
 
             return cmd
         # Normal mode - full command with all claude-mpm enhancements
-        cmd = ["claude", "--model", "opus", "--dangerously-skip-permissions"]
+        cmd = ["claude", "--dangerously-skip-permissions"]
 
         # Add custom arguments
         if self.runner.claude_args:
@@ -377,6 +383,14 @@ class InteractiveSession:
             self.logger.debug(f"Raw claude_args received: {self.runner.claude_args}")
             cmd.extend(self.runner.claude_args)
 
+        # Add --agents flag if native agents mode is enabled
+        if getattr(self.runner, "use_native_agents", False):
+            agents_flag = self._build_agents_flag()
+            if agents_flag:
+                # Add --agents JSON directly (already properly formatted)
+                cmd.extend(agents_flag)
+                self.logger.info("✓ Native agents mode: Using --agents CLI flag")
+
         # Add system instructions
         from claude_mpm.core.claude_runner import create_simple_context
 
@@ -392,10 +406,42 @@ class InteractiveSession:
             self.logger.info("✅ VERIFIED: --resume flag IS included in final command")
             self.logger.debug(f"--resume position in command: {cmd.index('--resume')}")
         else:
-            self.logger.debug("ℹ️ --resume flag NOT included in final command")
+            self.logger.debug("[INFO]️ --resume flag NOT included in final command")
 
         return cmd
 
+    def _build_agents_flag(self) -> Optional[list]:
+        """Build --agents flag with all MPM agents.
+
+        Returns:
+            List with ["--agents", "<json>"] or None if conversion fails
+        """
+        try:
+            from claude_mpm.services.native_agent_converter import NativeAgentConverter
+
+            converter = NativeAgentConverter()
+            agents = converter.load_agents_from_templates()
+
+            if not agents:
+                self.logger.warning("No agents loaded for native mode")
+                return None
+
+            # Generate JSON for --agents flag
+            agents_json = converter.generate_agents_json(agents)
+            summary = converter.get_conversion_summary(agents)
+
+            self.logger.info(
+                f"Native agents: {summary['total_agents']} agents, "
+                f"{summary['json_size_kb']} KB JSON"
+            )
+
+            # Return as list: ["--agents", "<json>"]
+            return ["--agents", agents_json]
+
+        except Exception as e:
+            self.logger.error(f"Failed to build --agents flag: {e}", exc_info=True)
+            return None
+
     def _prepare_environment(self) -> dict:
         """Prepare clean environment variables for Claude."""
         clean_env = os.environ.copy()
@@ -450,7 +496,8 @@ class InteractiveSession:
         # Notify WebSocket before exec
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_status_changed(
-                status="running", message="Claude process started (exec mode)"
+                status=ServiceState.RUNNING,
+                message="Claude process started (exec mode)",
             )
 
         # This will not return if successful
@@ -490,7 +537,7 @@ class InteractiveSession:
         # Notify WebSocket of error
         if self.runner.websocket_server:
             self.runner.websocket_server.claude_status_changed(
-                status="error", message=f"Failed to launch Claude: {error}"
+                status=ServiceState.ERROR, message=f"Failed to launch Claude: {error}"
             )
 
     def _handle_keyboard_interrupt(self) -> None:

claude_mpm/core/interfaces.py

@@ -33,7 +33,62 @@ from pathlib import Path
 from typing import Any, Dict, Generic, List, Optional, Tuple, TypeVar
 
 # Re-export everything from the new location for backward compatibility
-from claude_mpm.services.core.interfaces import *
+from claude_mpm.services.core.interfaces import (  # noqa: F401
+    AgentCapabilitiesInterface,
+    AgentDeploymentInterface,
+    AgentMetadata,
+    CacheEntry,
+    CommandHandlerInterface,
+    HealthStatus,
+    HookServiceInterface,
+    IAgentRecommender,
+    IAgentRegistry,
+    IAutoConfigManager,
+    ICacheService,
+    IConfigurationManager,
+    IConfigurationService,
+    ICrashDetector,
+    IDeploymentStateManager,
+    IErrorHandler,
+    IEventBus,
+    IHealthCheck,
+    IHealthCheckManager,
+    IHealthMonitor,
+    ILocalProcessManager,
+    ILogMonitor,
+    IMemoryLeakDetector,
+    IModelProvider,
+    IModelRouter,
+    InterfaceRegistry,
+    IPerformanceMonitor,
+    IPromptCache,
+    IResourceMonitor,
+    IRestartManager,
+    IRestartPolicy,
+    IServiceContainer,
+    IServiceFactory,
+    IServiceLifecycle,
+    IStructuredLogger,
+    ITemplateManager,
+    IToolchainAnalyzer,
+    MemoryHookInterface,
+    MemoryServiceInterface,
+    ModelCapability,
+    ModelProvider,
+    ModelResponse,
+    ProjectAnalyzerInterface,
+    RunnerConfigurationInterface,
+    ServiceType,
+    SessionManagementInterface,
+    SocketIOServiceInterface,
+    SubprocessLauncherInterface,
+    SystemInstructionsInterface,
+    T,
+    TemplateRenderContext,
+    TicketManagerInterface,
+    UtilityServiceInterface,
+    VersionServiceInterface,
+)
 
 # Type variables for generic interfaces
 T = TypeVar("T")

claude_mpm/core/lazy.py

@@ -16,7 +16,7 @@ import functools
 import threading
 import time
 from dataclasses import dataclass, field
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, Generic, Optional, Type, TypeVar
 
 from ..core.logger import get_logger
@@ -121,7 +121,7 @@ class LazyService(Generic[T]):
             # Track initialization
             start_time = time.time()
             if self._metrics.first_access is None:
-                self._metrics.first_access = datetime.now()
+                self._metrics.first_access = datetime.now(timezone.utc)
 
             try:
                 self._logger.debug(f"Initializing lazy service: {self._name}")
@@ -417,7 +417,7 @@ class AsyncLazyService(Generic[T]):
 
             start_time = time.time()
             if self._metrics.first_access is None:
-                self._metrics.first_access = datetime.now()
+                self._metrics.first_access = datetime.now(timezone.utc)
 
             try:
                 self._logger.debug(f"Async initializing: {self._name}")