claude-mpm 5.6.4__py3-none-any.whl → 5.6.30__py3-none-any.whl

claude_mpm/hooks/claude_hooks/auto_pause_handler.py

@@ -22,7 +22,7 @@ USAGE:
         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)
+            _log(f"\n⚠️  {warning}")
 
     # Record actions during pause mode
     if auto_pause.is_pause_active():
@@ -34,7 +34,6 @@ USAGE:
 """
 
 import os
-import sys
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -45,10 +44,19 @@ from claude_mpm.services.infrastructure.context_usage_tracker import (
     ContextUsageTracker,
 )
 
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
+
 logger = get_logger(__name__)
 
 # Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Warning messages for threshold crossings
 THRESHOLD_WARNINGS = {
@@ -100,11 +108,10 @@ class AutoPauseHandler:
             self._previous_threshold = current_state.threshold_reached
 
             if DEBUG:
-                print(
+                _log(
                     f"AutoPauseHandler initialized: "
                     f"{current_state.percentage_used:.1f}% context used, "
-                    f"threshold: {current_state.threshold_reached}",
-                    file=sys.stderr,
+                    f"threshold: {current_state.threshold_reached}"
                 )
         except Exception as e:
             logger.error(f"Failed to initialize AutoPauseHandler: {e}")
@@ -169,10 +176,9 @@ class AutoPauseHandler:
                     self._previous_threshold = current_threshold
 
                     if DEBUG:
-                        print(
+                        _log(
                             f"Context threshold crossed: {current_threshold} "
-                            f"({state.percentage_used:.1f}%)",
-                            file=sys.stderr,
+                            f"({state.percentage_used:.1f}%)"
                         )
 
                     # Trigger auto-pause if threshold reached
@@ -184,7 +190,7 @@ class AutoPauseHandler:
         except Exception as e:
             logger.error(f"Failed to update usage: {e}")
             if DEBUG:
-                print(f"❌ Usage update failed: {e}", file=sys.stderr)
+                _log(f"❌ Usage update failed: {e}")
             # Don't propagate error - auto-pause is optional
             return None
 
@@ -220,12 +226,12 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(f"Recorded tool call during pause: {tool_name}", file=sys.stderr)
+                _log(f"Recorded tool call during pause: {tool_name}")
 
         except Exception as e:
             logger.error(f"Failed to record tool call: {e}")
             if DEBUG:
-                print(f"❌ Failed to record tool call: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record tool call: {e}")
 
     def on_assistant_response(self, response_summary: str) -> None:
         """Record an assistant response if auto-pause is active.
@@ -257,15 +263,14 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
-                    f"Recorded assistant response during pause (length: {len(summary)})",
-                    file=sys.stderr,
+                _log(
+                    f"Recorded assistant response during pause (length: {len(summary)})"
                 )
 
         except Exception as e:
             logger.error(f"Failed to record assistant response: {e}")
             if DEBUG:
-                print(f"❌ Failed to record assistant response: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record assistant response: {e}")
 
     def on_user_message(self, message_summary: str) -> None:
         """Record a user message if auto-pause is active.
@@ -297,15 +302,12 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
-                    f"Recorded user message during pause (length: {len(summary)})",
-                    file=sys.stderr,
-                )
+                _log(f"Recorded user message during pause (length: {len(summary)})")
 
         except Exception as e:
             logger.error(f"Failed to record user message: {e}")
             if DEBUG:
-                print(f"❌ Failed to record user message: {e}", file=sys.stderr)
+                _log(f"❌ Failed to record user message: {e}")
 
     def on_session_end(self) -> Optional[Path]:
         """Called when session ends. Finalizes any active pause.
@@ -318,7 +320,7 @@ class AutoPauseHandler:
         """
         if not self.is_pause_active():
             if DEBUG:
-                print("No active pause to finalize", file=sys.stderr)
+                _log("No active pause to finalize")
             return None
 
         try:
@@ -326,14 +328,14 @@ class AutoPauseHandler:
             session_path = self.pause_manager.finalize_pause(create_full_snapshot=True)
 
             if session_path and DEBUG:
-                print(f"✅ Session finalized: {session_path.name}", file=sys.stderr)
+                _log(f"✅ Session finalized: {session_path.name}")
 
             return session_path
 
         except Exception as e:
             logger.error(f"Failed to finalize pause session: {e}")
             if DEBUG:
-                print(f"❌ Failed to finalize pause: {e}", file=sys.stderr)
+                _log(f"❌ Failed to finalize pause: {e}")
             raise
 
     def is_pause_active(self) -> bool:
@@ -417,9 +419,7 @@ class AutoPauseHandler:
             # Check if pause is already active
             if self.is_pause_active():
                 if DEBUG:
-                    print(
-                        "Auto-pause already active, skipping trigger", file=sys.stderr
-                    )
+                    _log("Auto-pause already active, skipping trigger")
                 return
 
             # Start incremental pause
@@ -429,16 +429,15 @@ class AutoPauseHandler:
             )
 
             if DEBUG:
-                print(
+                _log(
                     f"✅ Auto-pause triggered: {session_id} "
-                    f"({state.percentage_used:.1f}% context used)",
-                    file=sys.stderr,
+                    f"({state.percentage_used:.1f}% context used)"
                 )
 
         except Exception as e:
             logger.error(f"Failed to trigger auto-pause: {e}")
             if DEBUG:
-                print(f"❌ Failed to trigger auto-pause: {e}", file=sys.stderr)
+                _log(f"❌ Failed to trigger auto-pause: {e}")
             # Don't propagate - auto-pause is optional
 
     def _summarize_dict(

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -126,6 +126,15 @@ class EventHandlers:
             # Response tracking is optional - silently continue if it fails
             pass
 
+        # Record user message 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_user_message(prompt)
+            except Exception as e:
+                if DEBUG:
+                    _log(f"Auto-pause user message recording error: {e}")
+
         # Emit normalized event (namespace no longer needed with normalized events)
         self.hook_handler._emit_socketio_event("", "user_prompt", prompt_data)
 
@@ -603,6 +612,19 @@ class EventHandlers:
                     if DEBUG:
                         _log(f"Auto-pause error in handle_stop_fast: {e}")
 
+                # Finalize pause session if active
+                try:
+                    if auto_pause.is_pause_active():
+                        session_file = auto_pause.on_session_end()
+                        if session_file:
+                            if DEBUG:
+                                _log(
+                                    f"✅ Auto-pause session finalized: {session_file.name}"
+                                )
+                except Exception as e:
+                    if DEBUG:
+                        _log(f"❌ Failed to finalize auto-pause session: {e}")
+
         # Track response if enabled
         try:
             rtm = getattr(self.hook_handler, "response_tracking_manager", None)

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -496,11 +496,11 @@ class ClaudeHookHandler:
         if modified_input is not None:
             # Claude Code v2.0.30+ supports modifying PreToolUse tool inputs
             print(
-                json.dumps({"action": "continue", "tool_input": modified_input}),
+                json.dumps({"continue": True, "tool_input": modified_input}),
                 flush=True,
             )
         else:
-            print(json.dumps({"action": "continue"}), flush=True)
+            print(json.dumps({"continue": True}), flush=True)
 
     # Delegation methods for compatibility with event_handlers
     def _track_delegation(self, session_id: str, agent_type: str, request_data=None):
@@ -673,7 +673,7 @@ def main():
         # This prevents errors on older Claude Code versions
         if version:
             _log(f"Skipping hook processing due to version incompatibility ({version})")
-        print(json.dumps({"action": "continue"}), flush=True)
+        print(json.dumps({"continue": True}), flush=True)
         sys.exit(0)
 
     def cleanup_handler(signum=None, frame=None):
@@ -682,7 +682,7 @@ def main():
         _log(f"Hook handler cleanup (pid: {os.getpid()}, signal: {signum})")
         # Only output continue if we haven't already (i.e., if interrupted by signal)
         if signum is not None and not _continue_printed:
-            print(json.dumps({"action": "continue"}), flush=True)
+            print(json.dumps({"continue": True}), flush=True)
             _continue_printed = True
             sys.exit(0)
 
@@ -715,7 +715,7 @@ def main():
     except Exception as e:
         # Only output continue if not already printed
         if not _continue_printed:
-            print(json.dumps({"action": "continue"}), flush=True)
+            print(json.dumps({"continue": True}), flush=True)
             _continue_printed = True
         # Log error for debugging
         _log(f"Hook handler error: {e}")
@@ -727,5 +727,5 @@ if __name__ == "__main__":
         main()
     except Exception:
         # Catastrophic failure (import error, etc.) - always output valid JSON
-        print(json.dumps({"action": "continue"}), flush=True)
+        print(json.dumps({"continue": True}), flush=True)
         sys.exit(0)

claude_mpm/hooks/claude_hooks/installer.py

@@ -149,7 +149,7 @@ main() {
         if [ "${CLAUDE_MPM_HOOK_DEBUG}" = "true" ]; then
             echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Claude MPM not found, continuing..." >> /tmp/claude-mpm-hook.log
         fi
-        echo '{"action": "continue"}'
+        echo '{"continue": true}'
         exit 0
     fi
 
@@ -176,7 +176,7 @@ main() {
             echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Hook handler failed, see /tmp/claude-mpm-hook-error.log" >> /tmp/claude-mpm-hook.log
             echo "[$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ)] Error: $(cat /tmp/claude-mpm-hook-error.log 2>/dev/null | head -5)" >> /tmp/claude-mpm-hook.log
         fi
-        echo '{"action": "continue"}'
+        echo '{"continue": true}'
         exit 0
     fi
 
@@ -537,6 +537,44 @@ main "$@"
         except Exception as e:
             self.logger.warning(f"Could not clean up old settings file: {e}")
 
+    def _fix_status_line(self, settings: Dict) -> None:
+        """Fix statusLine command to handle both output style schema formats.
+
+        The statusLine command receives input in different formats:
+        - Newer format: {"activeOutputStyle": "Claude MPM", ...}
+        - Older format: {"output_style": {"name": "Claude MPM"}, ...}
+
+        This method ensures the jq expression checks both locations.
+
+        Args:
+            settings: The settings dictionary to update
+        """
+        if "statusLine" not in settings:
+            return
+
+        status_line = settings.get("statusLine", {})
+        if "command" not in status_line:
+            return
+
+        command = status_line["command"]
+
+        # Pattern to match: '.output_style.name // "default"'
+        # We need to update it to: '.output_style.name // .activeOutputStyle // "default"'
+        old_pattern = r'\.output_style\.name\s*//\s*"default"'
+        new_pattern = '.output_style.name // .activeOutputStyle // "default"'
+
+        # Check if the command needs updating
+        if re.search(old_pattern, command) and ".activeOutputStyle" not in command:
+            updated_command = re.sub(old_pattern, new_pattern, command)
+            settings["statusLine"]["command"] = updated_command
+            self.logger.info(
+                "Fixed statusLine command to handle both output style schemas"
+            )
+        else:
+            self.logger.debug(
+                "StatusLine command already supports both schemas or not present"
+            )
+
     def _update_claude_settings(self, hook_script_path: Path) -> None:
         """Update Claude settings to use the installed hook."""
         self.logger.info("Updating Claude settings...")
@@ -598,6 +636,9 @@ main "$@"
             }
         ]
 
+        # Fix statusLine command to handle both output style schemas
+        self._fix_status_line(settings)
+
         # Write settings to settings.json
         with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -7,7 +7,16 @@ including pre and post delegation hooks.
 
 import logging
 import os
-import sys
+from pathlib import Path
+
+# Try to import _log from hook_handler, fall back to no-op
+try:
+    from claude_mpm.hooks.claude_hooks.hook_handler import _log
+except ImportError:
+
+    def _log(msg: str) -> None:
+        pass  # Silent fallback
+
 
 # Install-type-aware logging configuration BEFORE kuzu-memory imports
 # This overrides kuzu-memory's WARNING-level basicConfig (fixes 1M-445)
@@ -28,11 +37,15 @@ try:
         DeploymentContext.DEVELOPMENT,
         DeploymentContext.EDITABLE_INSTALL,
     ):
+        # Write logs to file instead of stderr to avoid hook errors
+        log_dir = Path.home() / ".claude-mpm"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "hooks.log"
         logging.basicConfig(
             level=logging.INFO,
             format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
             force=True,  # Python 3.8+ - reconfigures root logger
-            stream=sys.stderr,
+            filename=str(log_file),
         )
 except ImportError:
     # Fallback: if unified_paths not available, check suppression before configuring
@@ -40,17 +53,21 @@ except ImportError:
     is_suppressed = root_logger.level > logging.CRITICAL
 
     if not is_suppressed:
+        # Write logs to file instead of stderr to avoid hook errors
+        log_dir = Path.home() / ".claude-mpm"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "hooks.log"
         logging.basicConfig(
             level=logging.INFO,
             format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
             force=True,
-            stream=sys.stderr,
+            filename=str(log_file),
         )
 from datetime import datetime, timezone
 from typing import Optional
 
 # Debug mode
-DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
+DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "false").lower() == "true"
 
 # Memory hooks integration
 MEMORY_HOOKS_AVAILABLE = False
@@ -71,7 +88,7 @@ try:
 except Exception as e:
     # Catch all exceptions to prevent any import errors from breaking the handler
     if DEBUG:
-        print(f"Memory hooks not available: {e}", file=sys.stderr)
+        _log(f"Memory hooks not available: {e}")
     MEMORY_HOOKS_AVAILABLE = False
 
 
@@ -105,10 +122,7 @@ class MemoryHookManager:
             # Only initialize if memory system is enabled
             if not config.get("memory.enabled", True):
                 if DEBUG:
-                    print(
-                        "Memory system disabled - skipping hook initialization",
-                        file=sys.stderr,
-                    )
+                    _log("Memory system disabled - skipping hook initialization")
                 return
 
             # Initialize pre-delegation hook for memory injection
@@ -126,14 +140,11 @@ class MemoryHookManager:
                     hooks_info.append("pre-delegation")
                 if self.post_delegation_hook:
                     hooks_info.append("post-delegation")
-                print(
-                    f"✅ Memory hooks initialized: {', '.join(hooks_info)}",
-                    file=sys.stderr,
-                )
+                _log(f"✅ Memory hooks initialized: {', '.join(hooks_info)}")
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Failed to initialize memory hooks: {e}", file=sys.stderr)
+                _log(f"❌ Failed to initialize memory hooks: {e}")
             # Don't fail the entire handler - memory system is optional
 
     def trigger_pre_delegation_hook(
@@ -182,14 +193,13 @@ class MemoryHookManager:
 
                     if DEBUG:
                         memory_size = len(memory_section.encode("utf-8"))
-                        print(
-                            f"✅ Injected {memory_size} bytes of memory for agent '{agent_type}'",
-                            file=sys.stderr,
+                        _log(
+                            f"✅ Injected {memory_size} bytes of memory for agent '{agent_type}'"
                         )
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Memory pre-delegation hook failed: {e}", file=sys.stderr)
+                _log(f"❌ Memory pre-delegation hook failed: {e}")
             # Don't fail the delegation - memory is optional
 
     def trigger_post_delegation_hook(
@@ -249,12 +259,11 @@ class MemoryHookManager:
             if result.success and result.metadata:
                 learnings_extracted = result.metadata.get("learnings_extracted", 0)
                 if learnings_extracted > 0 and DEBUG:
-                    print(
-                        f"✅ Extracted {learnings_extracted} learnings for agent '{agent_type}'",
-                        file=sys.stderr,
+                    _log(
+                        f"✅ Extracted {learnings_extracted} learnings for agent '{agent_type}'"
                     )
 
         except Exception as e:
             if DEBUG:
-                print(f"❌ Memory post-delegation hook failed: {e}", file=sys.stderr)
+                _log(f"❌ Memory post-delegation hook failed: {e}")
             # Don't fail the delegation result - memory is optional