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

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -7,7 +7,7 @@ Claude Code hook events.
 
 import os
 import re
-import subprocess
+import subprocess  # nosec B404 - subprocess used for safe claude CLI version checking only
 import sys
 import uuid
 from datetime import datetime, timezone
@@ -115,7 +115,7 @@ class EventHandlers:
                             f"Stored prompt for comprehensive tracking: session {session_id[:8]}...",
                             file=sys.stderr,
                         )
-        except Exception:
+        except Exception:  # nosec B110
             # Response tracking is optional - silently continue if it fails
             pass
 
@@ -189,8 +189,34 @@ class EventHandlers:
         if tool_name == "Task" and isinstance(tool_input, dict):
             self._handle_task_delegation(tool_input, pre_tool_data, session_id)
 
+        # Record tool call for auto-pause if active
+        auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+        if auto_pause and auto_pause.is_pause_active():
+            try:
+                auto_pause.on_tool_call(tool_name, tool_input)
+            except Exception as e:
+                if DEBUG:
+                    print(f"Auto-pause tool recording error: {e}", file=sys.stderr)
+
         self.hook_handler._emit_socketio_event("", "pre_tool", pre_tool_data)
 
+        # Handle TodoWrite specially - emit dedicated todo_updated event
+        # WHY: Frontend expects todo_updated events for dashboard display
+        # The broadcaster.todo_updated() method exists but was never called
+        if tool_name == "TodoWrite" and tool_params.get("todos"):
+            todo_data = {
+                "todos": tool_params["todos"],
+                "total_count": len(tool_params["todos"]),
+                "session_id": session_id,
+                "timestamp": timestamp,
+            }
+            self.hook_handler._emit_socketio_event("", "todo_updated", todo_data)
+            if DEBUG:
+                print(
+                    f"  - Emitted todo_updated event with {len(tool_params['todos'])} todos for session {session_id[:8]}...",
+                    file=sys.stderr,
+                )
+
     def _handle_task_delegation(
         self, tool_input: dict, pre_tool_data: dict, session_id: str
     ):
@@ -271,7 +297,7 @@ class EventHandlers:
             mhm = getattr(self.hook_handler, "memory_hook_manager", None)
             if mhm and hasattr(mhm, "trigger_pre_delegation_hook"):
                 mhm.trigger_pre_delegation_hook(agent_type, tool_input, session_id)
-        except Exception:
+        except Exception:  # nosec B110
             # Memory hooks are optional
             pass
 
@@ -364,7 +390,7 @@ class EventHandlers:
             os.chdir(working_dir)
 
             # Run git command to get current branch
-            result = subprocess.run(
+            result = subprocess.run(  # nosec B603 B607
                 ["git", "branch", "--show-current"],
                 capture_output=True,
                 text=True,
@@ -474,7 +500,7 @@ class EventHandlers:
                 mhm = getattr(self.hook_handler, "memory_hook_manager", None)
                 if mhm and hasattr(mhm, "trigger_post_delegation_hook"):
                     mhm.trigger_post_delegation_hook(agent_type, event, session_id)
-            except Exception:
+            except Exception:  # nosec B110
                 # Memory hooks are optional
                 pass
 
@@ -488,7 +514,7 @@ class EventHandlers:
                     rtm.track_agent_response(
                         session_id, agent_type, event, delegation_requests
                     )
-            except Exception:
+            except Exception:  # nosec B110
                 # Response tracking is optional
                 pass
 
@@ -550,13 +576,49 @@ class EventHandlers:
         if DEBUG:
             self._log_stop_event_debug(event, session_id, metadata)
 
+        # Auto-pause integration (independent of response tracking)
+        # WHY HERE: Auto-pause must work even when response_tracking is disabled
+        # Extract usage data directly from event and trigger auto-pause if thresholds crossed
+        if "usage" in event:
+            auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+            if auto_pause:
+                try:
+                    usage_data = event["usage"]
+                    metadata["usage"] = {
+                        "input_tokens": usage_data.get("input_tokens", 0),
+                        "output_tokens": usage_data.get("output_tokens", 0),
+                        "cache_creation_input_tokens": usage_data.get(
+                            "cache_creation_input_tokens", 0
+                        ),
+                        "cache_read_input_tokens": usage_data.get(
+                            "cache_read_input_tokens", 0
+                        ),
+                    }
+
+                    threshold_crossed = auto_pause.on_usage_update(metadata["usage"])
+                    if threshold_crossed:
+                        warning = auto_pause.emit_threshold_warning(threshold_crossed)
+                        print(f"\n⚠️  {warning}", file=sys.stderr)
+
+                        if DEBUG:
+                            print(
+                                f"  - Auto-pause threshold crossed: {threshold_crossed}",
+                                file=sys.stderr,
+                            )
+                except Exception as e:
+                    if DEBUG:
+                        print(
+                            f"Auto-pause error in handle_stop_fast: {e}",
+                            file=sys.stderr,
+                        )
+
         # Track response if enabled
         try:
             rtm = getattr(self.hook_handler, "response_tracking_manager", None)
             if rtm and hasattr(rtm, "track_stop_response"):
                 pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
                 rtm.track_stop_response(event, session_id, metadata, pending_prompts)
-        except Exception:
+        except Exception:  # nosec B110
             # Response tracking is optional
             pass
 
@@ -598,7 +660,7 @@ class EventHandlers:
                 f"  - response_tracker exists: {tracker_exists}",
                 file=sys.stderr,
             )
-        except Exception:
+        except Exception:  # nosec B110
             # If debug logging fails, just skip it
             pass
 
@@ -664,7 +726,7 @@ class EventHandlers:
         try:
             # Get the original request data (with fuzzy matching fallback)
             delegation_requests = getattr(self.hook_handler, "delegation_requests", {})
-            request_info = delegation_requests.get(session_id)
+            request_info = delegation_requests.get(session_id)  # nosec B113
 
             # If exact match fails, try partial matching
             if not request_info and session_id:
@@ -689,7 +751,7 @@ class EventHandlers:
                                 f"  - ✅ Fuzzy match found: {stored_sid[:16]}...",
                                 file=sys.stderr,
                             )
-                        request_info = delegation_requests.get(stored_sid)
+                        request_info = delegation_requests.get(stored_sid)  # nosec B113
                         # Update the key to use the current session_id for consistency
                         if request_info:
                             delegation_requests[session_id] = request_info
@@ -789,6 +851,7 @@ class EventHandlers:
         - Captures response content and metadata for analysis
         - Enables tracking of conversation flow and response patterns
         - Essential for comprehensive monitoring of Claude interactions
+        - Scans for delegation anti-patterns and creates autotodos
         """
         # Track the response for logging
         try:
@@ -796,10 +859,17 @@ class EventHandlers:
             if rtm and hasattr(rtm, "track_assistant_response"):
                 pending_prompts = getattr(self.hook_handler, "pending_prompts", {})
                 rtm.track_assistant_response(event, pending_prompts)
-        except Exception:
+        except Exception:  # nosec B110
             # Response tracking is optional
             pass
 
+        # Scan response for delegation anti-patterns and create autotodos
+        try:
+            self._scan_for_delegation_patterns(event)
+        except Exception as e:  # nosec B110
+            if DEBUG:
+                print(f"Delegation scanning error: {e}", file=sys.stderr)
+
         # Get working directory and git branch
         working_dir = event.get("cwd", "")
         git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
@@ -852,6 +922,21 @@ class EventHandlers:
                 file=sys.stderr,
             )
 
+        # Record assistant response for auto-pause if active
+        auto_pause = getattr(self.hook_handler, "auto_pause_handler", None)
+        if auto_pause and auto_pause.is_pause_active():
+            try:
+                # Summarize response to first 200 chars
+                summary = (
+                    response_text[:200] + "..."
+                    if len(response_text) > 200
+                    else response_text
+                )
+                auto_pause.on_assistant_response(summary)
+            except Exception as e:
+                if DEBUG:
+                    print(f"Auto-pause response recording error: {e}", file=sys.stderr)
+
         # Emit normalized event
         self.hook_handler._emit_socketio_event(
             "", "assistant_response", assistant_response_data
@@ -886,3 +971,123 @@ class EventHandlers:
 
         # Emit normalized event
         self.hook_handler._emit_socketio_event("", "session_start", session_start_data)
+
+    def handle_subagent_start_fast(self, event):
+        """Handle SubagentStart events with proper agent type extraction.
+
+        WHY separate from SessionStart:
+        - SubagentStart contains agent-specific information
+        - Frontend needs agent_type to create distinct agent nodes
+        - Multiple engineers should show as separate nodes in hierarchy
+        - Research agents must appear in the agent hierarchy
+
+        Unlike SessionStart, SubagentStart events contain agent-specific
+        information that must be preserved and emitted to the dashboard.
+        """
+        session_id = event.get("session_id", "")
+
+        # Extract agent type from event - Claude provides this in SubagentStart
+        # Try multiple possible field names for compatibility
+        agent_type = event.get("agent_type") or event.get("subagent_type") or "unknown"
+
+        # Generate unique agent ID combining type and session
+        agent_id = event.get("agent_id", f"{agent_type}_{session_id[:8]}")
+
+        # Get working directory and git branch
+        working_dir = event.get("cwd", "")
+        git_branch = self._get_git_branch(working_dir) if working_dir else "Unknown"
+
+        # Build subagent start data with all required fields
+        subagent_start_data = {
+            "session_id": session_id,
+            "agent_type": agent_type,
+            "agent_id": agent_id,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "hook_event_name": "SubagentStart",  # Preserve correct hook name
+            "working_directory": working_dir,
+            "git_branch": git_branch,
+        }
+
+        # Debug logging
+        if DEBUG:
+            print(
+                f"Hook handler: SubagentStart - agent_type='{agent_type}', "
+                f"agent_id='{agent_id}', session_id='{session_id[:16]}...'",
+                file=sys.stderr,
+            )
+
+        # Emit to /hook namespace as subagent_start (NOT session_start!)
+        self.hook_handler._emit_socketio_event(
+            "", "subagent_start", subagent_start_data
+        )
+
+    def _scan_for_delegation_patterns(self, event):
+        """Scan assistant response for delegation anti-patterns.
+
+        WHY this is needed:
+        - Detect when PM asks user to do something manually instead of delegating
+        - Flag PM behavior violations for immediate correction
+        - Enforce delegation principle in PM workflow
+        - Help PM recognize delegation opportunities
+
+        This method scans the assistant's response text for patterns like:
+        - "Make sure .env.local is in your .gitignore"
+        - "You'll need to run npm install"
+        - "Please run the tests manually"
+
+        When patterns are detected, PM violations are logged as errors/warnings
+        that should be corrected immediately, NOT as todos to delegate.
+
+        DESIGN DECISION: pm.violation vs autotodo.delegation
+        - Delegation patterns = PM doing something WRONG → pm.violation (error)
+        - Script failures = Something BROKEN → autotodo.error (todo)
+        """
+        # Only scan if delegation detector is available
+        try:
+            from claude_mpm.services.delegation_detector import get_delegation_detector
+            from claude_mpm.services.event_log import get_event_log
+        except ImportError:
+            if DEBUG:
+                print("Delegation detector or event log not available", file=sys.stderr)
+            return
+
+        response_text = event.get("response", "")
+        if not response_text:
+            return
+
+        # Get the delegation detector
+        detector = get_delegation_detector()
+
+        # Detect delegation patterns
+        detections = detector.detect_user_delegation(response_text)
+
+        if not detections:
+            return  # No patterns detected
+
+        # Get event log for violation recording
+        event_log = get_event_log()
+
+        # Create PM violation events (NOT autotodos)
+        for detection in detections:
+            # Create event log entry as pm.violation
+            event_log.append_event(
+                event_type="pm.violation",
+                payload={
+                    "violation_type": "delegation_anti_pattern",
+                    "pattern_type": detection["pattern_type"],
+                    "original_text": detection["original_text"],
+                    "suggested_action": detection["suggested_todo"],
+                    "action": detection["action"],
+                    "session_id": event.get("session_id", ""),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
+                    "severity": "warning",  # Not critical, but should be fixed
+                    "message": f"PM asked user to do something manually: {detection['original_text'][:80]}...",
+                },
+                status="pending",
+            )
+
+            if DEBUG:
+                print(
+                    f"⚠️  PM violation detected: {detection['original_text'][:60]}...",
+                    file=sys.stderr,
+                )

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -31,6 +31,7 @@ from typing import Optional, Tuple
 # Import extracted modules with fallback for direct execution
 try:
     # Try relative imports first (when imported as module)
+    from .auto_pause_handler import AutoPauseHandler
     from .event_handlers import EventHandlers
     from .memory_integration import MemoryHookManager
     from .response_tracking import ResponseTrackingManager
@@ -47,6 +48,7 @@ except ImportError:
     # Add parent directory to path
     sys.path.insert(0, str(Path(__file__).parent))
 
+    from auto_pause_handler import AutoPauseHandler
     from event_handlers import EventHandlers
     from memory_integration import MemoryHookManager
     from response_tracking import ResponseTrackingManager
@@ -153,7 +155,7 @@ def check_claude_version() -> Tuple[bool, Optional[str]]:
     """
     try:
         # Try to detect Claude Code version
-        result = subprocess.run(
+        result = subprocess.run(  # nosec B603 - Safe: hardcoded claude CLI with --version flag, no user input
             ["claude", "--version"],
             capture_output=True,
             text=True,
@@ -230,6 +232,19 @@ class ClaudeHookHandler:
             self.state_manager, self.response_tracking_manager, self.connection_manager
         )
 
+        # Initialize auto-pause handler
+        try:
+            self.auto_pause_handler = AutoPauseHandler()
+            # Pass reference to ResponseTrackingManager so it can call auto_pause
+            if hasattr(self, "response_tracking_manager"):
+                self.response_tracking_manager.auto_pause_handler = (
+                    self.auto_pause_handler
+                )
+        except Exception as e:
+            self.auto_pause_handler = None
+            if DEBUG:
+                print(f"Auto-pause initialization failed: {e}", file=sys.stderr)
+
         # Backward compatibility properties for tests
         self.connection_pool = self.connection_manager.connection_pool
 
@@ -419,7 +434,7 @@ class ClaudeHookHandler:
             "Notification": self.event_handlers.handle_notification_fast,
             "Stop": self.event_handlers.handle_stop_fast,
             "SubagentStop": self.event_handlers.handle_subagent_stop_fast,
-            "SubagentStart": self.event_handlers.handle_session_start_fast,
+            "SubagentStart": self.event_handlers.handle_subagent_start_fast,
             "SessionStart": self.event_handlers.handle_session_start_fast,
             "AssistantResponse": self.event_handlers.handle_assistant_response,
         }
@@ -535,13 +550,15 @@ class ClaudeHookHandler:
         # Build hook execution data
         hook_data = {
             "hook_name": hook_type,
-            "hook_type": hook_type,
+            "hook_type": hook_type,  # Actual hook type (PreToolUse, UserPromptSubmit, etc.)
+            "hook_event_type": hook_type,  # Additional field for clarity
             "session_id": session_id,
             "working_directory": working_dir,
             "success": success,
             "duration_ms": duration_ms,
             "result_summary": summary,
             "timestamp": datetime.now(timezone.utc).isoformat(),
+            "source": "claude_hook_handler",  # Explicit source identification
         }
 
         # Add error information if present
@@ -628,12 +645,19 @@ class ClaudeHookHandler:
 
     def __del__(self):
         """Cleanup on handler destruction."""
+        # Finalize any active auto-pause session
+        if hasattr(self, "auto_pause_handler") and self.auto_pause_handler:
+            try:
+                self.auto_pause_handler.on_session_end()
+            except Exception:
+                pass  # nosec B110 - Intentionally ignore cleanup errors during handler destruction
+
         # Clean up connection manager if it exists
         if hasattr(self, "connection_manager") and self.connection_manager:
             try:
                 self.connection_manager.cleanup()
             except Exception:
-                pass  # Ignore cleanup errors during destruction
+                pass  # nosec B110 - Intentionally ignore cleanup errors during handler destruction
 
 
 def main():

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -130,7 +130,7 @@ class ResponseTrackingManager:
 
         try:
             # Get the original request data stored during pre-tool
-            request_info = delegation_requests.get(session_id)
+            request_info = delegation_requests.get(session_id)  # nosec B113 - False positive: dict.get(), not requests library
             if not request_info:
                 if DEBUG:
                     print(
@@ -306,6 +306,8 @@ class ResponseTrackingManager:
                         )
 
                 # Capture Claude API usage data if available
+                # NOTE: Usage data is already captured in metadata by handle_stop_fast()
+                # which also handles auto-pause triggering (even when response tracking disabled)
                 if "usage" in event:
                     usage_data = event["usage"]
                     metadata["usage"] = {

claude_mpm/hooks/claude_hooks/services/connection_manager.py

@@ -134,6 +134,26 @@ class ConnectionManagerService:
         # Otherwise use "hook" as the type
         if event == "hook_execution":
             hook_type = data.get("hook_type", "unknown")
+
+            # BUGFIX: Validate hook_type is meaningful (not generic/invalid values)
+            # Problem: Dashboard shows "hook hook" instead of "PreToolUse", "UserPromptSubmit", etc.
+            # Root cause: hook_type defaults to "hook" or "unknown", providing no useful information
+            # Solution: Fallback to hook_name, then to descriptive "hook_execution_untyped"
+            if hook_type in ("hook", "unknown", "", None):
+                # Try fallback to hook_name field (set by _emit_hook_execution_event)
+                hook_type = data.get("hook_name", "unknown_hook")
+
+                # Final fallback if still generic - use descriptive name
+                if hook_type in ("hook", "unknown", "", None):
+                    hook_type = "hook_execution_untyped"
+
+                # Debug log when we detect invalid hook_type for troubleshooting
+                if DEBUG:
+                    print(
+                        f"⚠️ Invalid hook_type detected, using fallback: {hook_type}",
+                        file=sys.stderr,
+                    )
+
             event_type = hook_type
         else:
             event_type = "hook"

claude_mpm/hooks/claude_hooks/services/subagent_processor.py

@@ -67,7 +67,9 @@ class SubagentResponseProcessor:
                 print("  - No stored sessions in delegation_requests!", file=sys.stderr)
 
         # Get agent type and other basic info
-        agent_type, agent_id, reason = self._extract_basic_info(event, session_id)
+        agent_type, agent_id, reason, agent_type_inferred = self._extract_basic_info(
+            event, session_id
+        )
 
         # Always log SubagentStop events for debugging
         if DEBUG or agent_type != "unknown":
@@ -108,6 +110,7 @@ class SubagentResponseProcessor:
             working_dir,
             git_branch,
             structured_response,
+            agent_type_inferred,
         )
 
         # Debug log the processed data
@@ -117,11 +120,20 @@ class SubagentResponseProcessor:
                 file=sys.stderr,
             )
 
-        # Emit to /hook namespace with high priority
-        self.connection_manager.emit_event("/hook", "subagent_stop", subagent_stop_data)
+        # Emit to default namespace (consistent with subagent_start)
+        self.connection_manager.emit_event("", "subagent_stop", subagent_stop_data)
+
+    def _extract_basic_info(
+        self, event: dict, session_id: str
+    ) -> Tuple[str, str, str, bool]:
+        """Extract basic info from the event.
+
+        Returns:
+            Tuple of (agent_type, agent_id, reason, agent_type_inferred)
+            - agent_type_inferred is True when defaulted to "pm"
+        """
+        agent_type_inferred = False
 
-    def _extract_basic_info(self, event: dict, session_id: str) -> Tuple[str, str, str]:
-        """Extract basic info from the event."""
         # First try to get agent type from our tracking
         agent_type = (
             self.state_manager.get_delegation_agent_type(session_id)
@@ -146,7 +158,17 @@ class SubagentResponseProcessor:
             elif "pm" in task_desc or "project" in task_desc:
                 agent_type = "pm"
 
-        return agent_type, agent_id, reason
+        # Default to "pm" if still unknown (main conversation doesn't use Task tool)
+        if agent_type == "unknown":
+            agent_type = "pm"
+            agent_type_inferred = True
+            if DEBUG:
+                print(
+                    "  - Inferred agent_type='pm' (no explicit type found)",
+                    file=sys.stderr,
+                )
+
+        return agent_type, agent_id, reason, agent_type_inferred
 
     def _extract_structured_response(
         self, output: str, agent_type: str
@@ -338,10 +360,12 @@ class SubagentResponseProcessor:
         working_dir: str,
         git_branch: str,
         structured_response: Optional[dict],
+        agent_type_inferred: bool,
     ) -> dict:
         """Build the subagent stop data for event emission."""
         subagent_stop_data = {
             "agent_type": agent_type,
+            "agent_type_inferred": agent_type_inferred,
             "agent_id": agent_id,
             "reason": reason,
             "session_id": session_id,

claude_mpm/hooks/session_resume_hook.py

@@ -8,8 +8,11 @@ DESIGN DECISIONS:
 - Non-blocking: doesn't prevent PM from starting if check fails
 - Displays context to stdout for user visibility
 - Integrates with existing session pause/resume infrastructure
+- Checks for ACTIVE-PAUSE.jsonl (incremental auto-pause) before regular paused sessions
 """
 
+import json
+import sys
 from pathlib import Path
 from typing import Any, Dict, Optional
 
@@ -31,10 +34,83 @@ class SessionResumeStartupHook:
         self.project_path = project_path or Path.cwd()
         self.resume_helper = SessionResumeHelper(self.project_path)
         self._session_displayed = False
+        self.sessions_dir = self.project_path / ".claude-mpm" / "sessions"
+
+    def check_for_active_pause(self) -> Optional[Dict[str, Any]]:
+        """Check for an active incremental pause session.
+
+        Returns:
+            Pause session metadata if ACTIVE-PAUSE.jsonl exists, None otherwise
+        """
+        active_pause_path = self.sessions_dir / "ACTIVE-PAUSE.jsonl"
+
+        if not active_pause_path.exists():
+            logger.debug("No ACTIVE-PAUSE.jsonl found")
+            return None
+
+        try:
+            # Read JSONL file to get first and last actions
+            with active_pause_path.open("r") as f:
+                lines = f.readlines()
+
+            if not lines:
+                logger.warning("ACTIVE-PAUSE.jsonl is empty")
+                return None
+
+            # Parse first action (session start)
+            first_action = json.loads(lines[0])
+
+            # Parse last action (most recent)
+            last_action = json.loads(lines[-1]) if len(lines) > 1 else first_action
+
+            # Extract metadata
+            return {
+                "is_incremental": True,
+                "session_id": first_action.get("session_id"),
+                "started_at": first_action.get("timestamp"),
+                "context_at_start": first_action.get("data", {}).get(
+                    "context_percentage", 0
+                ),
+                "current_context": last_action.get("context_percentage", 0),
+                "action_count": len(lines),
+                "file_path": str(active_pause_path),
+            }
+
+        except (json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"Failed to parse ACTIVE-PAUSE.jsonl: {e}", exc_info=True)
+            return None
+
+    def display_active_pause_warning(self, pause_info: Dict[str, Any]) -> None:
+        """Display warning about active incremental pause session.
+
+        Args:
+            pause_info: Pause session metadata from check_for_active_pause()
+        """
+        print("\n" + "=" * 60, file=sys.stderr)
+        print("⚠️  ACTIVE AUTO-PAUSE SESSION DETECTED", file=sys.stderr)
+        print("=" * 60, file=sys.stderr)
+        print(f"Session ID: {pause_info['session_id']}", file=sys.stderr)
+        print(f"Started at: {pause_info['started_at']}", file=sys.stderr)
+        print(
+            f"Context at pause: {pause_info['context_at_start']:.1%}", file=sys.stderr
+        )
+        print(f"Actions recorded: {pause_info['action_count']}", file=sys.stderr)
+        print(
+            "\nThis session was auto-paused due to high context usage.", file=sys.stderr
+        )
+        print("Options:", file=sys.stderr)
+        print("  1. Continue (actions will be appended)", file=sys.stderr)
+        print("  2. Use /mpm-init pause --finalize to create snapshot", file=sys.stderr)
+        print("  3. Use /mpm-init pause --discard to abandon", file=sys.stderr)
+        print("=" * 60 + "\n", file=sys.stderr)
 
     def on_pm_startup(self) -> Optional[Dict[str, Any]]:
         """Execute on PM startup to check for paused sessions.
 
+        Checks in priority order:
+        1. ACTIVE-PAUSE.jsonl (incremental auto-pause)
+        2. Regular paused sessions (session-*.json)
+
         Returns:
             Session data if paused session found, None otherwise
         """
@@ -44,7 +120,15 @@ class SessionResumeStartupHook:
                 logger.debug("Session already displayed, skipping")
                 return None
 
-            # Check for paused sessions
+            # PRIORITY 1: Check for active incremental pause FIRST
+            active_pause_info = self.check_for_active_pause()
+            if active_pause_info:
+                self.display_active_pause_warning(active_pause_info)
+                self._session_displayed = True
+                logger.info("Active pause session detected and displayed")
+                return active_pause_info
+
+            # PRIORITY 2: Fall back to regular paused sessions
             session_data = self.resume_helper.check_and_display_resume_prompt()
 
             if session_data:

claude_mpm/init.py

@@ -216,7 +216,7 @@ class ProjectInitializer:
                         if deploy_result.deployed:
                             print(
                                 f"✓ Deployed {len(deploy_result.deployed)} PM skill(s) "
-                                f"to .claude-mpm/skills/pm/"
+                                f"to .claude/skills/"
                             )
                 else:
                     self.logger.warning(