claude-dev-env 1.30.1 → 1.32.0

package/hooks/diagnostic/test_hook_log_init.py

@@ -0,0 +1,227 @@
+"""Failing-first tests for hook_log_init.
+
+Covers: environment variable verification, idempotent DDL apply, sentinel
+insert/select/delete round-trip, and success report format.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+_HOOKS_ROOT = Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
+
+from diagnostic import hook_log_init
+from config import hook_log_extractor_constants
+from config.hook_log_extractor_constants import (
+    EXIT_CODE_ENVIRONMENT_MISSING,
+    NEON_DATABASE_URL_ENVIRONMENT_VARIABLE,
+    OUTCOME_INIT_PROBE,
+)
+
+
+def test_main_exits_1_when_neon_database_url_missing(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.delenv(NEON_DATABASE_URL_ENVIRONMENT_VARIABLE, raising=False)
+
+    exit_code = hook_log_init.main()
+
+    assert exit_code == EXIT_CODE_ENVIRONMENT_MISSING
+    captured = capsys.readouterr()
+    assert NEON_DATABASE_URL_ENVIRONMENT_VARIABLE in captured.err
+
+
+def test_main_exits_1_when_neon_database_url_is_empty_string(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Empty NEON_HOOK_LOGS_DATABASE_URL must fire missing-env branch."""
+    monkeypatch.setenv(NEON_DATABASE_URL_ENVIRONMENT_VARIABLE, "")
+
+    exit_code = hook_log_init.main()
+
+    assert exit_code == EXIT_CODE_ENVIRONMENT_MISSING
+    captured = capsys.readouterr()
+    assert NEON_DATABASE_URL_ENVIRONMENT_VARIABLE in captured.err
+
+
+def test_main_exits_1_when_neon_database_url_is_whitespace_only(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    """Whitespace-only NEON_HOOK_LOGS_DATABASE_URL must fire missing-env branch."""
+    monkeypatch.setenv(NEON_DATABASE_URL_ENVIRONMENT_VARIABLE, "   ")
+
+    exit_code = hook_log_init.main()
+
+    assert exit_code == EXIT_CODE_ENVIRONMENT_MISSING
+    captured = capsys.readouterr()
+    assert NEON_DATABASE_URL_ENVIRONMENT_VARIABLE in captured.err
+
+
+def test_apply_schema_executes_ddl_from_schema_sql() -> None:
+    fake_cursor = MagicMock()
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    hook_log_init.apply_schema(fake_connection)
+
+    all_executed_statements = [
+        each_call.args[0] for each_call in fake_cursor.execute.call_args_list
+    ]
+    joined_schema_text = "\n".join(all_executed_statements)
+    assert "hook_events" in joined_schema_text
+    assert "CREATE TABLE IF NOT EXISTS" in joined_schema_text
+    assert "blocked_commands" in joined_schema_text
+
+
+def test_run_sentinel_round_trip_inserts_selects_and_deletes() -> None:
+    fake_cursor = MagicMock()
+    fake_cursor.fetchone.side_effect = [(1,), (1,)]
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    hook_log_init.run_sentinel_round_trip(fake_connection)
+
+    all_executed_statements = [
+        each_call.args[0].upper() for each_call in fake_cursor.execute.call_args_list
+    ]
+    assert any("INSERT" in each_statement for each_statement in all_executed_statements)
+    assert any("SELECT" in each_statement for each_statement in all_executed_statements)
+    assert any("DELETE" in each_statement for each_statement in all_executed_statements)
+
+
+def test_run_sentinel_round_trip_uses_init_probe_outcome() -> None:
+    fake_cursor = MagicMock()
+    fake_cursor.fetchone.side_effect = [(1,), (1,)]
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    hook_log_init.run_sentinel_round_trip(fake_connection)
+
+    all_call_parameters = [
+        each_call.args for each_call in fake_cursor.execute.call_args_list
+    ]
+    joined_parameter_text = " ".join(
+        str(each_parameter_tuple) for each_parameter_tuple in all_call_parameters
+    )
+    assert OUTCOME_INIT_PROBE in joined_parameter_text
+
+
+def test_print_success_report_includes_host_table_and_rowcount(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    hook_log_init.print_success_report(
+        neon_host="ep-fake-neon.aws.neon.tech",
+        table_name="hook_events",
+        row_count=42,
+    )
+
+    captured = capsys.readouterr()
+    assert "ep-fake-neon.aws.neon.tech" in captured.out
+    assert "hook_events" in captured.out
+    assert "42" in captured.out
+
+
+def test_main_happy_path_returns_zero(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv(
+        NEON_DATABASE_URL_ENVIRONMENT_VARIABLE,
+        "postgres://u:p@ep-fake-host.aws.neon.tech/db",
+    )
+
+    fake_cursor = MagicMock()
+    fake_cursor.fetchone.side_effect = [(1,), (1,), (5,)]
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    with patch.object(hook_log_init, "connect_to_neon", return_value=fake_connection):
+        exit_code = hook_log_init.main()
+
+    assert exit_code == 0
+
+
+def test_connect_to_neon_raises_when_psycopg_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv(
+        NEON_DATABASE_URL_ENVIRONMENT_VARIABLE,
+        "postgres://u:p@ep-fake-host.aws.neon.tech/db",
+    )
+
+    with patch.object(hook_log_init, "psycopg", None):
+        with pytest.raises(hook_log_init.MissingPsycopgDependencyError):
+            hook_log_init.connect_to_neon()
+
+
+def test_run_sentinel_round_trip_raises_when_select_returns_nothing() -> None:
+    fake_cursor = MagicMock()
+    fake_cursor.fetchone.side_effect = [(1,), None]
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    with pytest.raises(RuntimeError):
+        hook_log_init.run_sentinel_round_trip(fake_connection)
+
+
+def test_run_sentinel_round_trip_raises_when_select_returns_wrong_id() -> None:
+    fake_cursor = MagicMock()
+    fake_cursor.fetchone.side_effect = [(1,), (999,)]
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    with pytest.raises(RuntimeError):
+        hook_log_init.run_sentinel_round_trip(fake_connection)
+
+
+def test_run_sentinel_round_trip_raises_when_insert_returns_no_row() -> None:
+    fake_cursor = MagicMock()
+    fake_cursor.fetchone.return_value = None
+    fake_connection = MagicMock()
+    fake_connection.cursor.return_value.__enter__.return_value = fake_cursor
+
+    with pytest.raises(RuntimeError):
+        hook_log_init.run_sentinel_round_trip(fake_connection)
+
+
+def test_claude_home_resolver_falls_back_to_home_when_env_var_is_empty(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Empty CLAUDE_HOME must fall back to ~/.claude (not process CWD)."""
+    monkeypatch.setenv("CLAUDE_HOME", "")
+
+    resolved_home = hook_log_extractor_constants._resolve_claude_home_directory()
+
+    expected_home = Path.home() / ".claude"
+    assert resolved_home == expected_home
+
+
+def test_claude_home_resolver_falls_back_to_home_when_env_var_is_whitespace(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Whitespace-only CLAUDE_HOME must fall back to ~/.claude."""
+    monkeypatch.setenv("CLAUDE_HOME", "   ")
+
+    resolved_home = hook_log_extractor_constants._resolve_claude_home_directory()
+
+    expected_home = Path.home() / ".claude"
+    assert resolved_home == expected_home
+
+
+def test_claude_home_resolver_honors_explicit_path(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """Explicit CLAUDE_HOME path must win over the home fallback."""
+    explicit_claude_home = tmp_path / "explicit-claude-home"
+    monkeypatch.setenv("CLAUDE_HOME", str(explicit_claude_home))
+
+    resolved_home = hook_log_extractor_constants._resolve_claude_home_directory()
+
+    assert resolved_home == explicit_claude_home

package/hooks/diagnostic/test_hook_log_stop_wrapper.py

@@ -0,0 +1,345 @@
+"""Tests for hook_log_stop_wrapper -- debounced, fire-and-forget Stop hook."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+_HOOKS_ROOT = Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
+
+from diagnostic import hook_log_stop_wrapper
+from config.hook_log_extractor_constants import (
+    BWS_ACCESS_TOKEN_ENV_VAR,
+    BWS_EXECUTABLE_NAME,
+    FLAG_INCREMENTAL,
+    STOP_WRAPPER_DEBOUNCE_SECONDS,
+)
+
+
+def _redirect_timestamp_path(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> Path:
+    timestamp_file = tmp_path / "stop_wrapper_last_run.txt"
+    monkeypatch.setattr(
+        hook_log_stop_wrapper,
+        "_last_run_timestamp_path",
+        lambda: timestamp_file,
+    )
+    return timestamp_file
+
+
+def test_main_returns_zero_when_extractor_spawn_raises(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    def _raise(*_args: object, **_kwargs: object) -> None:
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _raise)
+
+    assert hook_log_stop_wrapper.main() == 0
+    assert not timestamp_file.exists()
+
+
+def test_main_writes_timestamp_before_spawn_to_narrow_toctou_window(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    timestamp_file_existed_at_spawn_time: list[bool] = []
+
+    def _capture_timestamp_state(*_args: object, **_kwargs: object) -> object:
+        timestamp_file_existed_at_spawn_time.append(timestamp_file.exists())
+        return object()
+
+    monkeypatch.setattr(
+        hook_log_stop_wrapper.subprocess, "Popen", _capture_timestamp_state
+    )
+
+    hook_log_stop_wrapper.main()
+
+    assert timestamp_file_existed_at_spawn_time == [True]
+
+
+def test_main_removes_timestamp_when_spawn_fails_to_allow_retry(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    timestamp_file.parent.mkdir(parents=True, exist_ok=True)
+    stale_timestamp = time.time() - STOP_WRAPPER_DEBOUNCE_SECONDS - 1
+    timestamp_file.write_text(str(stale_timestamp))
+
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    def _raise(*_args: object, **_kwargs: object) -> None:
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _raise)
+
+    assert hook_log_stop_wrapper.main() == 0
+    assert not timestamp_file.exists()
+
+
+def test_main_uses_bws_when_token_and_binary_present(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.setenv(BWS_ACCESS_TOKEN_ENV_VAR, "secret-value")
+    monkeypatch.setattr(
+        hook_log_stop_wrapper.shutil,
+        "which",
+        lambda _name: "/usr/local/bin/bws",
+    )
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 1
+    assert captured_commands[0][0] == BWS_EXECUTABLE_NAME
+    assert FLAG_INCREMENTAL in captured_commands[0]
+
+
+def test_main_skips_bws_when_token_missing(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(
+        hook_log_stop_wrapper.shutil,
+        "which",
+        lambda _name: "/usr/local/bin/bws",
+    )
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 1
+    assert BWS_EXECUTABLE_NAME not in captured_commands[0]
+
+
+def test_main_skips_bws_when_binary_missing(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.setenv(BWS_ACCESS_TOKEN_ENV_VAR, "secret-value")
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 1
+    assert BWS_EXECUTABLE_NAME not in captured_commands[0]
+
+
+def test_main_skips_spawn_when_recent_timestamp_within_debounce_window(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    timestamp_file.parent.mkdir(parents=True, exist_ok=True)
+    timestamp_file.write_text(str(time.time()))
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 0
+
+
+def test_main_spawns_when_timestamp_older_than_debounce_window(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    timestamp_file.parent.mkdir(parents=True, exist_ok=True)
+    stale_timestamp = time.time() - STOP_WRAPPER_DEBOUNCE_SECONDS - 1
+    timestamp_file.write_text(str(stale_timestamp))
+
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 1
+
+
+def test_main_writes_current_timestamp_to_file(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+    monkeypatch.setattr(
+        hook_log_stop_wrapper.subprocess,
+        "Popen",
+        lambda *_args, **_kwargs: object(),
+    )
+
+    timestamp_before_call = time.time()
+    hook_log_stop_wrapper.main()
+    timestamp_after_call = time.time()
+
+    assert timestamp_file.exists()
+    written_timestamp = float(timestamp_file.read_text().strip())
+    assert timestamp_before_call <= written_timestamp <= timestamp_after_call
+
+
+def test_main_passes_devnull_streams_to_detached_spawn(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    captured_kwargs: dict[str, object] = {}
+
+    def _fake_popen(command_list: list[str], **kwargs: object) -> object:
+        captured_kwargs.update(kwargs)
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    hook_log_stop_wrapper.main()
+
+    assert captured_kwargs.get("stdin") is hook_log_stop_wrapper.subprocess.DEVNULL
+    assert captured_kwargs.get("stdout") is hook_log_stop_wrapper.subprocess.DEVNULL
+    assert captured_kwargs.get("stderr") is hook_log_stop_wrapper.subprocess.DEVNULL
+
+
+def test_main_recovers_when_timestamp_file_is_corrupted(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    timestamp_file.parent.mkdir(parents=True, exist_ok=True)
+    timestamp_file.write_text("not-a-float")
+
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 1
+
+
+def test_main_treats_future_timestamp_as_not_debounced(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    timestamp_file = _redirect_timestamp_path(monkeypatch, tmp_path)
+    timestamp_file.parent.mkdir(parents=True, exist_ok=True)
+    far_future_timestamp = time.time() + 3600
+    timestamp_file.write_text(str(far_future_timestamp))
+
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    captured_commands: list[list[str]] = []
+
+    def _fake_popen(command_list: list[str], **_kwargs: object) -> object:
+        captured_commands.append(list(command_list))
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    exit_code = hook_log_stop_wrapper.main()
+
+    assert exit_code == 0
+    assert len(captured_commands) == 1
+
+
+def test_main_passes_hidden_startupinfo_on_windows(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    _redirect_timestamp_path(monkeypatch, tmp_path)
+    monkeypatch.delenv(BWS_ACCESS_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(hook_log_stop_wrapper.shutil, "which", lambda _name: None)
+
+    captured_kwargs: dict[str, object] = {}
+
+    def _fake_popen(command_list: list[str], **kwargs: object) -> object:
+        captured_kwargs.update(kwargs)
+        return object()
+
+    monkeypatch.setattr(hook_log_stop_wrapper.subprocess, "Popen", _fake_popen)
+
+    hook_log_stop_wrapper.main()
+
+    if os.name == "nt":
+        startup_info = captured_kwargs.get("startupinfo")
+        assert startup_info is not None
+        assert startup_info.dwFlags & subprocess.STARTF_USESHOWWINDOW
+        assert startup_info.wShowWindow == subprocess.SW_HIDE
+    else:
+        assert captured_kwargs.get("start_new_session") is True

package/hooks/hooks.json

@@ -39,6 +39,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/tdd_enforcer.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/windows_rmtree_blocker.py",
+            "timeout": 10
           }
         ]
       },
@@ -89,6 +94,11 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/content_search_to_zoekt_redirector.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/windows_rmtree_blocker.py",
+            "timeout": 10
           }
         ]
       },
@@ -112,6 +122,11 @@
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/plugin_data_dir_cleanup.py",
             "timeout": 10
           },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/session_env_cleanup.py",
+            "timeout": 10
+          },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/session/untracked_repo_detector.py",
@@ -133,6 +148,16 @@
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/hedging_language_blocker.py",
             "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/blocking/question_to_user_enforcer.py",
+            "timeout": 10
+          },
+          {
+            "type": "command",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/diagnostic/hook_log_stop_wrapper.py",
+            "timeout": 30
           }
         ]
       }