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

claude_mpm/hooks/claude_hooks/event_handlers.py

@@ -9,7 +9,8 @@ import os
 import re
 import subprocess
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
+from pathlib import Path
 from typing import Optional
 
 # Import tool analysis with fallback for direct execution
@@ -77,7 +78,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "is_command": prompt.startswith("/"),
             "contains_code": "```" in prompt
             or "python" in prompt.lower()
@@ -101,7 +102,7 @@ class EventHandlers:
             if session_id:
                 self.hook_handler.pending_prompts[session_id] = {
                     "prompt": prompt,
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "working_directory": working_dir,
                 }
                 if DEBUG:
@@ -150,7 +151,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "parameter_count": len(tool_input) if isinstance(tool_input, dict) else 0,
             "is_file_operation": tool_name
             in ["Write", "Edit", "MultiEdit", "Read", "LS", "Glob"],
@@ -249,7 +250,7 @@ class EventHandlers:
             "session_id": session_id,
             "prompt": tool_input.get("prompt", ""),
             "description": tool_input.get("description", ""),
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "hook_event_name": "SubagentStart",  # For dashboard compatibility
         }
         self.hook_handler._emit_socketio_event(
@@ -277,18 +278,18 @@ class EventHandlers:
                     "session_id": session_id,
                     "delegation_context": {
                         "description": tool_input.get("description", ""),
-                        "timestamp": datetime.now().isoformat(),
+                        "timestamp": datetime.now(timezone.utc).isoformat(),
                     },
                 }
 
                 # Log the agent prompt asynchronously
                 try:
                     loop = asyncio.get_running_loop()
-                    asyncio.create_task(
+                    _task = asyncio.create_task(
                         log_manager.log_prompt(
                             f"agent_{agent_type}", prompt_content, metadata
                         )
-                    )
+                    )  # Fire-and-forget logging (ephemeral hook process)
                 except RuntimeError:
                     # No running loop, create one
                     loop = asyncio.new_event_loop()
@@ -309,23 +310,25 @@ class EventHandlers:
         """Get git branch for the given directory with caching."""
         # Use current working directory if not specified
         if not working_dir:
-            working_dir = os.getcwd()
+            working_dir = Path.cwd()
 
-        # Check cache first (cache for 30 seconds)
-        current_time = datetime.now().timestamp()
+        # Check cache first (cache for 300 seconds = 5 minutes)
+        # WHY 5 minutes: Git branches rarely change during development sessions,
+        # reducing subprocess overhead significantly without staleness issues
+        current_time = datetime.now(timezone.utc).timestamp()
         cache_key = working_dir
 
         if (
             cache_key in self.hook_handler._git_branch_cache
             and cache_key in self.hook_handler._git_branch_cache_time
-            and current_time - self.hook_handler._git_branch_cache_time[cache_key] < 30
+            and current_time - self.hook_handler._git_branch_cache_time[cache_key] < 300
         ):
             return self.hook_handler._git_branch_cache[cache_key]
 
         # Try to get git branch
         try:
             # Change to the working directory temporarily
-            original_cwd = os.getcwd()
+            original_cwd = Path.cwd()
             os.chdir(working_dir)
 
             # Run git command to get current branch
@@ -397,7 +400,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "has_output": bool(result_data.get("output")),
             "has_error": bool(result_data.get("error")),
             "output_size": (
@@ -448,7 +451,7 @@ class EventHandlers:
             "session_id": event.get("session_id", ""),
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "is_user_input_request": "input" in message.lower()
             or "waiting" in message.lower(),
             "is_error_notification": "error" in message.lower()
@@ -492,7 +495,7 @@ class EventHandlers:
         """Extract metadata from stop event."""
         working_dir = event.get("cwd", "")
         return {
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "working_directory": working_dir,
             "git_branch": (
                 self._get_git_branch(working_dir) if working_dir else "Unknown"
@@ -639,7 +642,7 @@ class EventHandlers:
                     "has_error": reason in ["error", "timeout", "failed", "blocked"],
                     "working_directory": working_dir,
                     "git_branch": git_branch,
-                    "timestamp": datetime.now().isoformat(),
+                    "timestamp": datetime.now(timezone.utc).isoformat(),
                     "event_type": "subagent_stop",
                     "reason": reason,
                     "original_request_timestamp": request_info.get("timestamp"),
@@ -715,7 +718,7 @@ class EventHandlers:
             "session_id": session_id,
             "working_directory": working_dir,
             "git_branch": git_branch,
-            "timestamp": datetime.now().isoformat(),
+            "timestamp": datetime.now(timezone.utc).isoformat(),
             "contains_code": "```" in response_text,
             "contains_json": "```json" in response_text,
             "hook_event_name": "AssistantResponse",  # Explicitly set for dashboard

claude_mpm/hooks/claude_hooks/hook_handler.py

@@ -3,7 +3,7 @@
 
 This handler uses a service-oriented architecture with:
 - StateManagerService: Manages state and delegation tracking
-- ConnectionManagerService: Handles SocketIO and EventBus connections
+- ConnectionManagerService: Handles SocketIO connections with HTTP fallback
 - SubagentResponseProcessor: Processes complex subagent responses
 - DuplicateEventDetector: Detects and filters duplicate events
 
@@ -25,7 +25,7 @@ import signal
 import subprocess
 import sys
 import threading
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional, Tuple
 
 # Import extracted modules with fallback for direct execution
@@ -73,19 +73,10 @@ DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 Conditional imports with graceful fallbacks for testing and modularity.
 
 WHY conditional imports:
-- EventBus is optional for basic hook functionality
 - Tests may not have full environment setup
 - Allows hooks to work in minimal configurations
 - Graceful degradation when dependencies unavailable
 """
-# Import EventBus availability flag for backward compatibility with tests
-try:
-    from claude_mpm.services.event_bus import EventBus
-
-    EVENTBUS_AVAILABLE = True
-except ImportError:
-    EVENTBUS_AVAILABLE = False
-    EventBus = None
 
 # Import get_connection_pool for backward compatibility with tests
 try:
@@ -241,7 +232,6 @@ class ClaudeHookHandler:
 
         # Backward compatibility properties for tests
         self.connection_pool = self.connection_manager.connection_pool
-        self.event_bus = self.connection_manager.event_bus
 
         # Expose state manager properties for backward compatibility
         self.active_delegations = self.state_manager.active_delegations
@@ -294,7 +284,7 @@ class ClaudeHookHandler:
             if self.duplicate_detector.is_duplicate(event):
                 if DEBUG:
                     print(
-                        f"[{datetime.now().isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
+                        f"[{datetime.now(timezone.utc).isoformat()}] Skipping duplicate event: {event.get('hook_event_name', 'unknown')} (PID: {os.getpid()})",
                         file=sys.stderr,
                     )
                 # Still need to output continue for this invocation
@@ -307,7 +297,7 @@ class ClaudeHookHandler:
             if DEBUG:
                 hook_type = event.get("hook_event_name", "unknown")
                 print(
-                    f"\n[{datetime.now().isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})",
+                    f"\n[{datetime.now(timezone.utc).isoformat()}] Processing hook event: {hook_type} (PID: {os.getpid()})",
                     file=sys.stderr,
                 )
 
@@ -321,11 +311,12 @@ class ClaudeHookHandler:
                     )
 
             # Route event to appropriate handler
-            self._route_event(event)
+            # Handlers can optionally return modified input for PreToolUse events
+            modified_input = self._route_event(event)
 
             # Always continue execution (only if not already sent)
             if not _continue_sent:
-                self._continue_execution()
+                self._continue_execution(modified_input)
                 _continue_sent = True
 
         except Exception:
@@ -386,7 +377,7 @@ class ClaudeHookHandler:
                 print(f"Error reading hook event: {e}", file=sys.stderr)
             return None
 
-    def _route_event(self, event: dict) -> None:
+    def _route_event(self, event: dict) -> Optional[dict]:
         """
         Route event to appropriate handler based on type.
 
@@ -395,6 +386,9 @@ class ClaudeHookHandler:
 
         Args:
             event: Hook event dictionary
+
+        Returns:
+            Modified input for PreToolUse events (v2.0.30+), None otherwise
         """
         # Try multiple field names for compatibility
         hook_type = (
@@ -426,23 +420,36 @@ class ClaudeHookHandler:
         handler = event_handlers.get(hook_type)
         if handler:
             try:
-                handler(event)
+                # Handlers can optionally return modified input
+                result = handler(event)
+                # Only PreToolUse handlers should return modified input
+                if hook_type == "PreToolUse" and result is not None:
+                    return result
             except Exception as e:
                 if DEBUG:
                     print(f"Error handling {hook_type}: {e}", file=sys.stderr)
 
+        return None
+
     def handle_subagent_stop(self, event: dict):
         """Delegate subagent stop processing to the specialized processor."""
         self.subagent_processor.process_subagent_stop(event)
 
-    def _continue_execution(self) -> None:
+    def _continue_execution(self, modified_input: Optional[dict] = None) -> None:
         """
-        Send continue action to Claude.
+        Send continue action to Claude with optional input modification.
 
         WHY: Centralized response ensures consistent format
         and makes it easier to add response modifications.
+
+        Args:
+            modified_input: Modified tool parameters for PreToolUse hooks (v2.0.30+)
         """
-        print(json.dumps({"action": "continue"}))
+        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}))
+        else:
+            print(json.dumps({"action": "continue"}))
 
     # Delegation methods for compatibility with event_handlers
     def _track_delegation(self, session_id: str, agent_type: str, request_data=None):
@@ -471,7 +478,7 @@ class ClaudeHookHandler:
         if hasattr(self, "connection_manager") and self.connection_manager:
             try:
                 self.connection_manager.cleanup()
-            except:
+            except Exception:
                 pass  # Ignore cleanup errors during destruction
 
 

claude_mpm/hooks/claude_hooks/installer.py

@@ -37,7 +37,7 @@ find_claude_mpm() {
             cmd_path=$(readlink -f "$cmd_path")
         fi
         # Extract the base directory (usually site-packages or venv)
-        local base_dir=$(python3 -c "import claude_mpm; import os; print(os.path.dirname(os.path.dirname(claude_mpm.__file__)))" 2>/dev/null)
+        local base_dir=$(python3 -c "import claude_mpm; import os; print(Path(os.path.dirname(claude_mpm.__file__).parent))" 2>/dev/null)
         if [ -n "$base_dir" ]; then
             echo "$base_dir"
             return 0
@@ -71,7 +71,7 @@ try:
     import claude_mpm
     import os
     # Get the package directory
-    pkg_dir = os.path.dirname(claude_mpm.__file__)
+    pkg_dir = Path(claude_mpm.__file__).parent
     # Check if we're in a development install (src directory)
     if 'src' in pkg_dir:
         # Go up to find the project root
@@ -81,11 +81,11 @@ try:
             project_root = os.sep.join(parts[:src_idx])
             print(project_root)
         else:
-            print(os.path.dirname(os.path.dirname(pkg_dir)))
+            print(Path(os.path.dirname(pkg_dir).parent))
     else:
         # Installed package - just return the package location
-        print(os.path.dirname(pkg_dir))
-except:
+        print(Path(pkg_dir).parent)
+except Exception:
     pass
 " 2>/dev/null)
 
@@ -99,7 +99,7 @@ except:
     for path_dir in $PATH; do
         if [ -f "$path_dir/claude-mpm" ]; then
             # Found claude-mpm executable, try to find its package
-            local pkg_dir=$(cd "$path_dir" && python3 -c "import claude_mpm; import os; print(os.path.dirname(os.path.dirname(claude_mpm.__file__)))" 2>/dev/null)
+            local pkg_dir=$(cd "$path_dir" && python3 -c "import claude_mpm; import os; print(Path(os.path.dirname(claude_mpm.__file__).parent))" 2>/dev/null)
             if [ -n "$pkg_dir" ]; then
                 echo "$pkg_dir"
                 return 0
@@ -192,6 +192,8 @@ main "$@"
 
     # Minimum Claude Code version required for hook monitoring
     MIN_CLAUDE_VERSION = "1.0.92"
+    # Minimum version for PreToolUse input modification support
+    MIN_PRETOOL_MODIFY_VERSION = "2.0.30"
 
     def __init__(self):
         """Initialize the hook installer."""
@@ -292,6 +294,42 @@ main "$@"
 
         return (True, f"Claude Code {version} is compatible with hook monitoring.")
 
+    def supports_pretool_modify(self) -> bool:
+        """
+        Check if the installed Claude Code version supports PreToolUse input modification.
+
+        PreToolUse input modification was added in Claude Code v2.0.30.
+
+        Returns:
+            True if version supports input modification, False otherwise
+        """
+        version = self.get_claude_version()
+
+        if version is None:
+            return False
+
+        def parse_version(v: str) -> List[int]:
+            """Parse semantic version string to list of integers."""
+            try:
+                return [int(x) for x in v.split(".")]
+            except (ValueError, AttributeError):
+                return [0]
+
+        current = parse_version(version)
+        required = parse_version(self.MIN_PRETOOL_MODIFY_VERSION)
+
+        # Compare versions
+        for i in range(max(len(current), len(required))):
+            curr_part = current[i] if i < len(current) else 0
+            req_part = required[i] if i < len(required) else 0
+
+            if curr_part < req_part:
+                return False
+            if curr_part > req_part:
+                return True
+
+        return True
+
     def get_hook_script_path(self) -> Path:
         """Get the path to the hook handler script based on installation method.
 
@@ -339,8 +377,8 @@ main "$@"
 
         # Make sure it's executable
         if script_path.exists():
-            st = os.stat(script_path)
-            os.chmod(script_path, st.st_mode | stat.S_IEXEC)
+            st = Path(script_path).stat()
+            Path(script_path).chmod(st.st_mode | stat.S_IEXEC)
             self._hook_script_path = script_path
             return script_path
 
@@ -428,7 +466,7 @@ main "$@"
             return
 
         try:
-            with open(self.old_settings_file) as f:
+            with self.old_settings_file.open() as f:
                 old_settings = json.load(f)
 
             # Remove hooks section if present
@@ -437,7 +475,7 @@ main "$@"
                 self.logger.info(f"Removing hooks from {self.old_settings_file}")
 
                 # Write back the cleaned settings
-                with open(self.old_settings_file, "w") as f:
+                with self.old_settings_file.open("w") as f:
                     json.dump(old_settings, f, indent=2)
 
                 self.logger.info(f"Cleaned up hooks from {self.old_settings_file}")
@@ -450,7 +488,7 @@ main "$@"
 
         # Load existing settings.json or create new
         if self.settings_file.exists():
-            with open(self.settings_file) as f:
+            with self.settings_file.open() as f:
                 settings = json.load(f)
             self.logger.info(f"Found existing Claude settings at {self.settings_file}")
         else:
@@ -490,7 +528,7 @@ main "$@"
             ]
 
         # Write settings to settings.json
-        with open(self.settings_file, "w") as f:
+        with self.settings_file.open("w") as f:
             json.dump(settings, f, indent=2)
 
         self.logger.info(f"Updated Claude settings at {self.settings_file}")
@@ -564,7 +602,7 @@ main "$@"
             issues.append(f"Claude settings file not found at {self.settings_file}")
         else:
             try:
-                with open(self.settings_file) as f:
+                with self.settings_file.open() as f:
                     settings = json.load(f)
 
                 if "hooks" not in settings:
@@ -588,9 +626,9 @@ main "$@"
                 issues.append(f"Invalid Claude settings JSON: {e}")
 
         # Check if claude-mpm is accessible
-        try:
-            import claude_mpm
-        except ImportError:
+        import importlib.util
+
+        if importlib.util.find_spec("claude_mpm") is None:
             issues.append("claude-mpm package not found in Python environment")
 
         is_valid = len(issues) == 0
@@ -615,7 +653,7 @@ main "$@"
             # Remove from Claude settings (both old and new locations)
             for settings_path in [self.settings_file, self.old_settings_file]:
                 if settings_path.exists():
-                    with open(settings_path) as f:
+                    with settings_path.open() as f:
                         settings = json.load(f)
 
                     if "hooks" in settings:
@@ -655,7 +693,7 @@ main "$@"
                             del settings["hooks"]
 
                         # Write back settings
-                        with open(settings_path, "w") as f:
+                        with settings_path.open("w") as f:
                             json.dump(settings, f, indent=2)
 
                         self.logger.info(f"Removed hooks from {settings_path}")
@@ -677,6 +715,7 @@ main "$@"
         # Check version compatibility
         claude_version = self.get_claude_version()
         is_compatible, version_message = self.is_version_compatible()
+        pretool_modify_supported = self.supports_pretool_modify()
 
         is_valid, issues = self.verify_hooks()
 
@@ -701,6 +740,12 @@ main "$@"
             "version_compatible": is_compatible,
             "version_message": version_message,
             "deployment_type": "deployment-root",  # New field to indicate new architecture
+            "pretool_modify_supported": pretool_modify_supported,  # v2.0.30+ feature
+            "pretool_modify_message": (
+                f"PreToolUse input modification supported (v{claude_version})"
+                if pretool_modify_supported
+                else f"PreToolUse input modification requires Claude Code {self.MIN_PRETOOL_MODIFY_VERSION}+ (current: {claude_version or 'unknown'})"
+            ),
         }
 
         # Check Claude settings for hook configuration
@@ -709,18 +754,18 @@ main "$@"
 
         if self.settings_file.exists():
             try:
-                with open(self.settings_file) as f:
+                with self.settings_file.open() as f:
                     settings = json.load(f)
                     if "hooks" in settings:
                         status["configured_events"] = list(settings["hooks"].keys())
                         configured_in_local = True
-            except:
+            except Exception:
                 pass
 
         # Also check old settings file
         if self.old_settings_file.exists():
             try:
-                with open(self.old_settings_file) as f:
+                with self.old_settings_file.open() as f:
                     old_settings = json.load(f)
                     if "hooks" in old_settings:
                         status["old_file_has_hooks"] = True
@@ -728,7 +773,7 @@ main "$@"
                             status["warning"] = (
                                 "Hooks found in settings.local.json but Claude Code reads from settings.json"
                             )
-            except:
+            except Exception:
                 pass
 
         status["settings_location"] = (

claude_mpm/hooks/claude_hooks/memory_integration.py

@@ -7,7 +7,7 @@ including pre and post delegation hooks.
 
 import os
 import sys
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Optional
 
 # Debug mode
@@ -122,7 +122,7 @@ class MemoryHookManager:
                     "session_id": session_id,
                 },
                 metadata={"source": "claude_hook_handler", "tool_name": "Task"},
-                timestamp=datetime.now().isoformat(),
+                timestamp=datetime.now(timezone.utc).isoformat(),
                 session_id=session_id,
             )
 
@@ -200,7 +200,7 @@ class MemoryHookManager:
                     "tool_name": "Task",
                     "duration_ms": event.get("duration_ms", 0),
                 },
-                timestamp=datetime.now().isoformat(),
+                timestamp=datetime.now(timezone.utc).isoformat(),
                 session_id=session_id,
             )
 

claude_mpm/hooks/claude_hooks/response_tracking.py

@@ -9,29 +9,29 @@ import json
 import os
 import re
 import sys
-from datetime import datetime
-from typing import Optional
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
 
 # Debug mode
 DEBUG = os.environ.get("CLAUDE_MPM_HOOK_DEBUG", "true").lower() != "false"
 
 # Response tracking integration
-RESPONSE_TRACKING_AVAILABLE = False
-try:
-    from claude_mpm.services.response_tracker import ResponseTracker
-
-    RESPONSE_TRACKING_AVAILABLE = True
-except Exception as e:
-    if DEBUG:
-        print(f"Response tracking not available: {e}", file=sys.stderr)
-    RESPONSE_TRACKING_AVAILABLE = False
+# NOTE: ResponseTracker import moved to _initialize_response_tracking() for lazy loading
+# This prevents unnecessary import of base_agent_loader and other heavy dependencies
+# when hooks don't need response tracking
+RESPONSE_TRACKING_AVAILABLE = (
+    True  # Assume available, will check on actual initialization
+)
 
 
 class ResponseTrackingManager:
     """Manager for response tracking functionality."""
 
     def __init__(self):
-        self.response_tracker: Optional[ResponseTracker] = None
+        self.response_tracker: Optional[Any] = (
+            None  # Type hint changed to Any for lazy import
+        )
         self.response_tracking_enabled = False
         self.track_all_interactions = (
             False  # Track all Claude interactions, not just delegations
@@ -49,8 +49,14 @@ class ResponseTrackingManager:
 
         DESIGN DECISION: Check configuration to allow enabling/disabling
         response tracking without code changes.
+
+        NOTE: ResponseTracker is imported lazily here to avoid loading
+        base_agent_loader and other heavy dependencies unless actually needed.
         """
         try:
+            # Lazy import of ResponseTracker to avoid unnecessary dependency loading
+            from claude_mpm.services.response_tracker import ResponseTracker
+
             # Create configuration with optional config file using ConfigLoader
             config_file = os.environ.get("CLAUDE_PM_CONFIG_FILE")
             from claude_mpm.core.shared.config_loader import ConfigLoader, ConfigPattern
@@ -59,8 +65,8 @@ class ResponseTrackingManager:
             if config_file:
                 # Use specific config file with ConfigLoader
                 pattern = ConfigPattern(
-                    filenames=[os.path.basename(config_file)],
-                    search_paths=[os.path.dirname(config_file)],
+                    filenames=[Path(config_file).name],
+                    search_paths=[Path(config_file).parent],
                     env_prefix="CLAUDE_MPM_",
                 )
                 config = config_loader.load_config(
@@ -192,7 +198,7 @@ class ResponseTrackingManager:
                 "has_error": bool(event.get("error")),
                 "duration_ms": event.get("duration_ms"),
                 "working_directory": event.get("cwd", ""),
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "tool_name": "Task",
                 "original_request_timestamp": request_info.get("timestamp"),
             }
@@ -262,7 +268,10 @@ class ResponseTrackingManager:
     def track_stop_response(
         self, event: dict, session_id: str, metadata: dict, pending_prompts: dict
     ):
-        """Track response for stop events."""
+        """Track response for stop events.
+
+        Captures Claude API stop_reason and usage data for context management.
+        """
         if not (self.response_tracking_enabled and self.response_tracker):
             return
 
@@ -288,6 +297,37 @@ class ResponseTrackingManager:
                 # Add prompt timestamp to metadata
                 metadata["prompt_timestamp"] = prompt_data.get("timestamp")
 
+                # Capture Claude API stop_reason if available
+                if "stop_reason" in event:
+                    metadata["stop_reason"] = event["stop_reason"]
+                    if DEBUG:
+                        print(
+                            f"  - Captured stop_reason: {event['stop_reason']}",
+                            file=sys.stderr,
+                        )
+
+                # Capture Claude API usage data if available
+                if "usage" in event:
+                    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
+                        ),
+                    }
+                    if DEBUG:
+                        total_tokens = usage_data.get(
+                            "input_tokens", 0
+                        ) + usage_data.get("output_tokens", 0)
+                        print(
+                            f"  - Captured usage: {total_tokens} total tokens",
+                            file=sys.stderr,
+                        )
+
                 # Track the main Claude response
                 file_path = self.response_tracker.track_response(
                     agent_name="claude_main",
@@ -344,7 +384,7 @@ class ResponseTrackingManager:
 
             # Track the response
             metadata = {
-                "timestamp": datetime.now().isoformat(),
+                "timestamp": datetime.now(timezone.utc).isoformat(),
                 "prompt_timestamp": prompt_data.get("timestamp"),
                 "working_directory": prompt_data.get("working_directory", ""),
                 "event_type": "assistant_response",