fix(hooks): wire hook timing recording + delete dead HookTimer (#1494)

- Add hooks/lib/hook_runtime.py with time_hook() context manager that
  records hook elapsed time via SessionStats.record_hook_timing()
- Wire time_hook into all 5 hook scripts: PreToolUse, PostToolUse,
  SessionStart, Stop, UserPromptSubmit
- Delete hooks/lib/hook_timer.py (dead code — per-process in-memory
  model does not work for short-lived hook processes)
- Delete tests/test_hook_timer.py (tests for removed dead code)
- Add TestHookTimingWiring regression tests (3 cases):
  recording, exception resilience, accumulation

The Stop hook summary now surfaces ⏱ timing data:
  [CB] 3m | 12 tools | 0 errors | Bash:5 | ⏱ PostToolUse:42ms

Author: JeremyDev87

packages/claude-code-plugin/hooks/lib/hook_runtime.py

@@ -0,0 +1,52 @@
+"""Hook execution timing context manager (#1494).
+
+Records hook elapsed time via SessionStats.record_hook_timing(), flushing
+to disk so the Stop hook summary can surface the ⏱ timing report.
+"""
+import time
+from contextlib import contextmanager
+from typing import Optional
+
+
+@contextmanager
+def time_hook(
+    hook_name: str,
+    *,
+    session_id: Optional[str] = None,
+    data_dir: Optional[str] = None,
+):
+    """Context manager that records hook execution time.
+
+    Wraps hook logic with monotonic clock measurements and persists the
+    elapsed milliseconds to disk via SessionStats.  Recording failures
+    are silently swallowed so hook execution is never blocked.
+
+    Args:
+        hook_name: Claude Code event name (e.g. 'PostToolUse').
+        session_id: Explicit session ID.  If None, resolved via
+                    session_utils.get_session_id().
+        data_dir: Stats directory override (mainly for tests).
+
+    Usage::
+
+        with time_hook("PostToolUse"):
+            # ... hook logic ...
+    """
+    start = time.monotonic()
+    try:
+        yield
+    finally:
+        try:
+            elapsed_ms = (time.monotonic() - start) * 1000
+            if session_id is None:
+                from session_utils import get_session_id
+                session_id = get_session_id()
+            from stats import SessionStats
+            kwargs = {"session_id": session_id}
+            if data_dir is not None:
+                kwargs["data_dir"] = data_dir
+            stats = SessionStats(**kwargs)
+            stats.record_hook_timing(hook_name, elapsed_ms)
+            stats.flush()
+        except Exception:
+            pass  # Never block tool execution

packages/claude-code-plugin/hooks/lib/hook_timer.py

@@ -26,6 +26,13 @@ def handle_post_tool_use(data: dict):
     Records tool call stats (#825).
     Future: history tracking (#827).
     """
+    from hook_runtime import time_hook
+    with time_hook("PostToolUse"):
+        return _handle_post_tool_use(data)
+
+
+def _handle_post_tool_use(data: dict):
+    """Core PostToolUse logic, wrapped by time_hook."""
     try:
         from stats import SessionStats
 

packages/claude-code-plugin/hooks/post-tool-use.py

@@ -289,7 +289,9 @@ def _handle(data: dict) -> Optional[dict]:
 @safe_main
 def handle_pre_tool_use(data: dict) -> Optional[dict]:
     """Entry point for PreToolUse hook."""
-    return _handle(data)
+    from hook_runtime import time_hook
+    with time_hook("PreToolUse"):
+        return _handle(data)
 
 
 if __name__ == "__main__":

packages/claude-code-plugin/hooks/pre-tool-use.py

@@ -887,6 +887,14 @@ def _check_briefing_recovery() -> None:
 
 def main():
     """Main entry point for the session start hook."""
+    _ensure_lib_path()
+    from hook_runtime import time_hook
+    with time_hook("SessionStart"):
+        return _main_inner()
+
+
+def _main_inner():
+    """Core session-start logic, wrapped by time_hook."""
     try:
         home = Path.home()
         hooks_dir = home / ".claude" / "hooks"

packages/claude-code-plugin/hooks/session-start.py

@@ -23,6 +23,13 @@ def handle_stop(data: dict):
 
     Finalizes session stats and returns a systemMessage summary.
     """
+    from hook_runtime import time_hook
+    with time_hook("Stop"):
+        return _handle_stop(data)
+
+
+def _handle_stop(data: dict):
+    """Core Stop logic, wrapped by time_hook."""
     try:
         from stats import SessionStats
 

packages/claude-code-plugin/hooks/stop.py

@@ -51,6 +51,18 @@ def detect_mode(prompt: str) -> Optional[str]:
 
 def main():
     """Main entry point for the hook."""
+    # Ensure hooks/lib is importable for time_hook
+    _hooks_dir = os.path.dirname(os.path.abspath(__file__))
+    _lib_dir = os.path.join(_hooks_dir, "lib")
+    if _lib_dir not in sys.path:
+        sys.path.insert(0, _lib_dir)
+    from hook_runtime import time_hook
+    with time_hook("UserPromptSubmit"):
+        return _main_inner()
+
+
+def _main_inner():
+    """Core UserPromptSubmit logic, wrapped by time_hook."""
     try:
         # Read input from stdin
         input_data = json.load(sys.stdin)

packages/claude-code-plugin/hooks/user-prompt-submit.py

@@ -299,6 +299,57 @@ def test_concurrent_flush_no_lost_updates(self, data_dir):
         assert on_disk["tool_names"]["Bash"] == expected
 
 
+class TestHookTimingWiring:
+    """Regression test: hook scripts record timing via time_hook context manager (#1494)."""
+
+    def test_time_hook_records_timing(self, data_dir):
+        """time_hook should record elapsed_ms to disk hook_timings."""
+        from hook_runtime import time_hook
+
+        session_id = "timing-test"
+        SessionStats(session_id=session_id, data_dir=data_dir)
+
+        with time_hook("PostToolUse", session_id=session_id, data_dir=data_dir):
+            time.sleep(0.01)
+
+        s = SessionStats(session_id=session_id, data_dir=data_dir)
+        data = s._locked_read()
+        assert "PostToolUse" in data["hook_timings"]
+        assert len(data["hook_timings"]["PostToolUse"]) >= 1
+        assert data["hook_timings"]["PostToolUse"][0] >= 5  # at least ~5ms
+
+    def test_time_hook_records_even_on_inner_exception(self, data_dir):
+        """Timing is recorded even when inner code raises."""
+        from hook_runtime import time_hook
+
+        session_id = "exc-test"
+        SessionStats(session_id=session_id, data_dir=data_dir)
+
+        with pytest.raises(ValueError):
+            with time_hook("PostToolUse", session_id=session_id, data_dir=data_dir):
+                raise ValueError("intentional error inside hook")
+
+        s = SessionStats(session_id=session_id, data_dir=data_dir)
+        data = s._locked_read()
+        assert "PostToolUse" in data["hook_timings"]
+        assert len(data["hook_timings"]["PostToolUse"]) >= 1
+
+    def test_time_hook_records_multiple(self, data_dir):
+        """Multiple time_hook invocations accumulate timings."""
+        from hook_runtime import time_hook
+
+        session_id = "multi-timing"
+        SessionStats(session_id=session_id, data_dir=data_dir)
+
+        for _ in range(3):
+            with time_hook("PreToolUse", session_id=session_id, data_dir=data_dir):
+                pass
+
+        s = SessionStats(session_id=session_id, data_dir=data_dir)
+        data = s._locked_read()
+        assert len(data["hook_timings"]["PreToolUse"]) == 3
+
+
 class TestCleanup:
     def test_cleanup_stale_removes_old_files(self, data_dir):
         # Create a stale file