claude-dev-env 2.11.0 → 2.13.0

package/hooks/blocking/conventional_pr_title_gate.py

@@ -36,8 +36,6 @@ _hooks_dir = str(Path(__file__).resolve().parent.parent)
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
-from verification_verdict_store import resolve_repo_root  # noqa: E402
-
 from blocking._gh_body_arg_utils import (  # noqa: E402
     all_value_flags,
     count_extra_tokens_to_skip_for_split_quoted_value,
@@ -68,6 +66,7 @@ from hooks_constants.conventional_pr_title_gate_constants import (  # noqa: E402
     YAML_LIST_ITEM_PREFIX,
 )
 from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
+from hooks_constants.project_paths_reader import find_git_root as resolve_repo_root  # noqa: E402
 
 
 def _matches_gh_pr_title_subcommand(command: str) -> bool:

package/hooks/blocking/send_user_file_open_locally_blocker.py

@@ -3,7 +3,7 @@
 
 SendUserFile attaches a file to the session. While the user is at the terminal
 (status "normal" or unset) an attach does not let them see the file — it must
-open on screen in its own viewer via Show-Asset.ps1. The one attach allowed
+open on screen in its native Windows app. The one attach allowed
 through is an away-from-desk phone push (status "proactive").
 """
 

package/hooks/blocking/stop_dispatcher.py

@@ -1,11 +1,11 @@
 #!/usr/bin/env python3
-"""Stop-hook dispatcher that hosts the six Stop-chain hooks in one process.
+"""Stop-hook dispatcher that hosts the Stop-chain blockers in one process.
 
 Reads the Stop payload from stdin once, runs each hosted hook in registration
 order via the shared hosted-hook runner, and emits the first block decision the
-chain produced. Later hooks still run so side-effect hooks (the log extractor
-wrapper) fire even when an earlier hook blocked. A single hosted hook crash
-fails open and does not suppress the remaining hooks.
+chain produced. Later hooks still run after an earlier block so every hosted
+hook gets a chance to run. A single hosted hook crash fails open and does not
+suppress the remaining hooks.
 """
 
 from __future__ import annotations

package/hooks/blocking/test_bash_pre_tool_use_dispatcher.py

@@ -221,9 +221,6 @@ def test_powershell_selects_the_shared_hooks_in_registration_order() -> None:
     assert powershell_paths == [
         "blocking/unscoped_search_blocker.py",
         "blocking/pii_prevention_blocker.py",
-        "blocking/code_review_push_gate.py",
-        "blocking/code_review_pr_create_gate.py",
-        "blocking/code_review_stamp_directory_write_blocker.py",
     ]
 
 

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -715,8 +715,8 @@ def test_dispatcher_write_applies_both_groups() -> None:
     assert "blocking/plain_language_blocker.py" in all_write_script_paths, (
         "plain_language_blocker (Group B) must be in Write applicable set"
     )
-    assert len(all_write_entries) == 21, (
-        f"Write tool must apply to all 21 hosted hooks, got {len(all_write_entries)}"
+    assert len(all_write_entries) == 19, (
+        f"Write tool must apply to all 19 hosted hooks, got {len(all_write_entries)}"
     )
 
 
@@ -732,16 +732,16 @@ def test_dispatcher_edit_applies_both_groups() -> None:
     assert "advisory/refactor_guard.py" in all_edit_script_paths, (
         "refactor_guard is Edit-scoped and hosted, so it belongs in the Edit applicable set"
     )
-    assert len(all_edit_entries) == 24, (
-        f"expected 24 Edit entries, got {len(all_edit_entries)}"
+    assert len(all_edit_entries) == 22, (
+        f"expected 22 Edit entries, got {len(all_edit_entries)}"
     )
 
 
 def test_dispatcher_multi_edit_applies_only_group_b() -> None:
     """MultiEdit tool triggers only Group B (10 hooks), not Group A."""
     all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
-    assert len(all_multi_edit_entries) == 10, (
-        f"MultiEdit tool must apply to exactly 10 Group-B hooks, got {len(all_multi_edit_entries)}"
+    assert len(all_multi_edit_entries) == 9, (
+        f"MultiEdit tool must apply to exactly 9 Group-B hooks, got {len(all_multi_edit_entries)}"
     )
 
 
@@ -969,7 +969,6 @@ def test_hosted_hook_set_covers_all_write_edit_blocking_hooks() -> None:
         "blocking/state_description_blocker.py",
         "blocking/subprocess_budget_completeness.py",
         "blocking/hook_prose_detector_consistency.py",
-        "blocking/verified_commit_message_accuracy_blocker.py",
         "blocking/workflow_substitution_slot_blocker.py",
         "blocking/claude_md_orphan_file_blocker.py",
         "blocking/pytest_testpaths_orphan_blocker.py",

package/hooks/blocking/test_send_user_file_open_locally_blocker.py

@@ -45,8 +45,9 @@ def test_allows_proactive_status() -> None:
     assert _should_block(PROACTIVE_STATUS) is False
 
 
-def test_corrective_message_points_to_show_asset() -> None:
-    assert "Show-Asset.ps1" in CORRECTIVE_MESSAGE
+def test_corrective_message_points_to_native_windows_app() -> None:
+    assert "native Windows app" in CORRECTIVE_MESSAGE
+    assert "Show-Asset.ps1" not in CORRECTIVE_MESSAGE
 
 
 def test_corrective_message_names_proactive_escape_hatch() -> None:
@@ -71,7 +72,7 @@ def test_main_blocks_normal_attach() -> None:
     output_text = _run_main_with_io(json.dumps(hook_input))
     output = json.loads(output_text)
     assert output["hookSpecificOutput"]["permissionDecision"] == "deny"
-    assert "Show-Asset.ps1" in output["hookSpecificOutput"]["permissionDecisionReason"]
+    assert "native Windows app" in output["hookSpecificOutput"]["permissionDecisionReason"]
 
 
 def test_main_allows_proactive_attach() -> None:

package/hooks/blocking/test_shared_stdin_adoption.py

@@ -30,8 +30,6 @@ _BLOCKING_DIRECTORY = Path(__file__).resolve().parent
 ALL_CONVERTED_HOOK_FILENAMES = (
     "open_questions_in_plans_blocker.py",
     "claude_md_orphan_file_blocker.py",
-    "pr_converge_bugteam_enforcer.py",
-    "verdict_directory_write_blocker.py",
     "package_inventory_stale_blocker.py",
 )
 

package/hooks/diagnostic/CLAUDE.md

@@ -14,8 +14,8 @@ Hooks and scripts that collect, store, and query hook-firing records. The pipeli
 | File | What it does |
 |---|---|
 | `hook_log_init.py` | One-time setup: creates the Neon schema (runs `schema.sql`), then verifies read-write parity with a sentinel round-trip |
-| `hook_log_extractor.py` | Stop hook — reads per-session JSONL transcripts and ingests new `hook_*` attachment records into the `hook_events` table; idempotent via a UNIQUE constraint on `(source_jsonl_path, source_line_number)` |
-| `hook_log_stop_wrapper.py` | Thin wrapper that invokes `hook_log_extractor.py` from the Stop lifecycle event |
+| `hook_log_extractor.py` | Disabled CLI: exits 0 without reading transcripts or rewriting offset state; body remains for a re-enable path that ingests `hook_*` attachments into Neon |
+| `hook_log_stop_wrapper.py` | Disabled Stop wrapper stub: exits 0; not on the Stop dispatcher roster |
 | `schema.sql` | DDL for the `hook_events` table, `blocked_commands` view, and supporting indexes |
 | `requirements-hook-logs.txt` | Runtime dependencies (`psycopg`) for the extractor |
 | `requirements-hook-logs-dev.txt` | Dev/test dependencies |
@@ -38,6 +38,6 @@ The `blocked_commands` view filters to `outcome = 'blocked'`.
 
 ## Conventions
 
-- The extractor exits 0 even when Neon is unreachable (offline-graceful); it logs to `OFFLINE_WARNING_LOG` and does not block session end.
+- Extractor and Stop wrapper mains are disabled and exit 0 with no work.
 - Constants for the extractor (table name, offset state file, timeout) live in `hooks_constants/hook_log_extractor_constants.py`.
 - Tests run with `python -m pytest diagnostic/test_hook_log_*.py`.

package/hooks/diagnostic/hook_log_extractor.py

@@ -67,15 +67,10 @@ from hooks_constants.hook_log_extractor_constants import (
     CATEGORY_PATH_MINIMUM_PARTS,
     COMMAND_EXCERPT_MAX_CHARACTERS,
     CONNECT_TIMEOUT_SECONDS,
-    DEFAULT_QUERY_FOR_SUMMARY,
     EMPTY_STRING,
     EXIT_CODE_EXTRACTOR_ENVIRONMENT_MISSING,
     EXIT_CODE_SUCCESS,
     EXIT_CODE_UNKNOWN_QUERY,
-    FLAG_FULL_REBUILD,
-    FLAG_INCREMENTAL,
-    FLAG_QUERY,
-    FLAG_SUMMARY,
     HOOK_CATEGORY_UNCATEGORIZED,
     HOOK_EVENTS_INSERT_SQL,
     HOOK_EVENTS_TRUNCATE_SQL,
@@ -94,10 +89,8 @@ from hooks_constants.hook_log_extractor_constants import (
     NEON_DATABASE_URL_ENVIRONMENT_VARIABLE,
     NEWLINE_JOINER,
     OFFLINE_WARNING_LOG,
-    OFFSET_STATE_FILE,
     OFFSETS_JSON_INDENT,
     OUTCOME_BY_ATTACHMENT_TYPE,
-    PROJECTS_TRANSCRIPT_ROOT,
     QUERIES_DIRECTORY_NAME,
     QUERY_NAME_PATTERN,
     QUERY_NO_ROWS_RETURNED_MESSAGE,
@@ -874,35 +867,8 @@ def run_query(named_query: str) -> int:
 
 
 def main() -> int:
-    """Entry point for the hook-log extractor CLI.
-
-    Supported flags:
-
-    * ``--summary`` prints the top blockers of the last twenty-four hours.
-    * ``--query <name>`` runs a pre-baked SQL file under ``queries/``.
-    * ``--full-rebuild`` truncates ``hook_events`` and re-reads every
-      JSONL from byte zero.
-    * ``--incremental`` is a documented no-op; it selects the default
-      byte-offset resumption path that the Stop hook also uses when no
-      flags are passed.
-    """
-    all_cli_arguments = list(sys.argv[1:])
-    if FLAG_SUMMARY in all_cli_arguments:
-        return run_summary()
-    if FLAG_QUERY in all_cli_arguments:
-        flag_index = all_cli_arguments.index(FLAG_QUERY)
-        if flag_index + 1 >= len(all_cli_arguments):
-            return run_query(DEFAULT_QUERY_FOR_SUMMARY)
-        return run_query(all_cli_arguments[flag_index + 1])
-    is_full_rebuild_requested = FLAG_FULL_REBUILD in all_cli_arguments
-    is_incremental_requested = FLAG_INCREMENTAL in all_cli_arguments
-    if is_incremental_requested and is_full_rebuild_requested:
-        is_full_rebuild_requested = False
-    return run_full_extraction(
-        transcripts_root=PROJECTS_TRANSCRIPT_ROOT,
-        state_file_path=OFFSET_STATE_FILE,
-        full_rebuild=is_full_rebuild_requested,
-    )
+    """Disabled extractor entry point: exit success with no work."""
+    return EXIT_CODE_SUCCESS
 
 
 if __name__ == "__main__":

package/hooks/diagnostic/hook_log_stop_wrapper.py

@@ -1,173 +1,24 @@
 #!/usr/bin/env python3
-"""Stop-hook wrapper for hook_log_extractor: debounced, fire-and-forget.
+"""Disabled Stop-hook wrapper for the hook-log extractor.
 
-Runs after every assistant turn (Stop hook), so per-turn latency must
-stay near zero. The wrapper:
-
-1. Reads the last-spawn timestamp; if it falls within the debounce
-   window, exits 0 immediately without spawning anything (typical fast
-   path: a small file read, well under 10ms).
-2. Otherwise records the current timestamp, then launches the extractor
-   as a fully detached background process (no stdio, separate process
-   group on POSIX or CREATE_NO_WINDOW|CREATE_NEW_PROCESS_GROUP on
-   Windows) and returns without waiting for it. CREATE_NO_WINDOW
-   prevents a console flash on Windows even when the wrapper goes
-   through ``bws run`` first; DETACHED_PROCESS would let the
-   grandchild python.exe allocate a fresh console.
-
-Bitwarden injection: when both ``bws`` is on PATH and
-``BWS_ACCESS_TOKEN`` is set, the extractor is launched via
-``bws run --`` so the Neon URL never hits disk; otherwise it is
-launched directly. The extractor itself exits 0 when
-``NEON_HOOK_LOGS_DATABASE_URL`` is unset, so missing dependencies
-cannot block session shutdown.
-
-This wrapper always exits 0 so the Stop hook never surfaces a failure.
+The wrapper is off the Stop dispatcher roster and exits 0 without spawning
+the extractor or writing debounce state. Git history holds the prior
+debounce-and-spawn implementation if Neon-backed extraction returns.
 """
 
 from __future__ import annotations
 
-import os
-import shutil
-import subprocess
 import sys
-import time
 from pathlib import Path
 
 if str(Path(__file__).resolve().parent.parent) not in sys.path:
     sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
-from hooks_constants.hook_log_extractor_constants import (
-    BWS_ACCESS_TOKEN_ENV_VAR,
-    BWS_EXECUTABLE_NAME,
-    BWS_RUN_SEPARATOR,
-    BWS_RUN_SUBCOMMAND,
-    EXIT_CODE_SUCCESS,
-    FLAG_INCREMENTAL,
-    STOP_WRAPPER_DEBOUNCE_SECONDS,
-    STOP_WRAPPER_EXTRACTOR_SCRIPT_NAME,
-    STOP_WRAPPER_LAST_RUN_TIMESTAMP_FILE,
-    WINDOWS_CREATE_NEW_PROCESS_GROUP_FLAG,
-    WINDOWS_CREATE_NO_WINDOW_FLAG,
-    WINDOWS_OS_NAME,
-)
-
-
-def _extractor_script_path() -> str:
-    return str(
-        Path(__file__).resolve().parent / STOP_WRAPPER_EXTRACTOR_SCRIPT_NAME
-    )
-
-
-def _last_run_timestamp_path() -> Path:
-    return Path(STOP_WRAPPER_LAST_RUN_TIMESTAMP_FILE)
-
-
-def _is_within_debounce_window() -> bool:
-    timestamp_path = _last_run_timestamp_path()
-    if not timestamp_path.exists():
-        return False
-    try:
-        previous_timestamp = float(timestamp_path.read_text().strip())
-    except (OSError, ValueError):
-        return False
-    seconds_since_previous_spawn = time.time() - previous_timestamp
-    if seconds_since_previous_spawn < 0:
-        return False
-    return seconds_since_previous_spawn < STOP_WRAPPER_DEBOUNCE_SECONDS
-
-
-def _record_current_timestamp() -> None:
-    timestamp_path = _last_run_timestamp_path()
-    timestamp_path.parent.mkdir(parents=True, exist_ok=True)
-    timestamp_path.write_text(str(time.time()))
-
-
-def _clear_recorded_timestamp() -> None:
-    """Remove the debounce timestamp regardless of which process wrote it.
-
-    The unlink is unconditional: if process A writes a timestamp, process
-    B observes it and debounces, then A's spawn fails, A's rollback here
-    deletes the timestamp B already saw. The next Stop hook then spawns
-    a fresh extractor instead of debouncing the remainder of the window.
-    Consequence is benign because the extractor's own offset-file lock
-    (LOCK_MAXIMUM_RETRY_COUNT in hook_log_extractor_constants) serializes
-    concurrent extractor runs, so at most one extra extractor briefly
-    waits on the lock. Scoping the rollback to A's own write would
-    require a per-process sentinel and tighter atomicity than the
-    benefit warrants for this Stop-hook fast path.
-    """
-    timestamp_path = _last_run_timestamp_path()
-    timestamp_path.unlink(missing_ok=True)
-
-
-def _can_use_bws() -> bool:
-    if not os.environ.get(BWS_ACCESS_TOKEN_ENV_VAR):
-        return False
-    return shutil.which(BWS_EXECUTABLE_NAME) is not None
-
-
-def _detached_spawn_keyword_arguments() -> dict[str, object]:
-    spawn_arguments: dict[str, object] = {
-        "stdin": subprocess.DEVNULL,
-        "stdout": subprocess.DEVNULL,
-        "stderr": subprocess.DEVNULL,
-        "close_fds": True,
-    }
-    if os.name == WINDOWS_OS_NAME:
-        spawn_arguments["creationflags"] = (
-            WINDOWS_CREATE_NO_WINDOW_FLAG
-            | WINDOWS_CREATE_NEW_PROCESS_GROUP_FLAG
-        )
-        startup_info = subprocess.STARTUPINFO()
-        startup_info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
-        startup_info.wShowWindow = subprocess.SW_HIDE
-        spawn_arguments["startupinfo"] = startup_info
-    else:
-        spawn_arguments["start_new_session"] = True
-    return spawn_arguments
-
-
-def _spawn_with_bws() -> None:
-    subprocess.Popen(
-        [
-            BWS_EXECUTABLE_NAME,
-            BWS_RUN_SUBCOMMAND,
-            BWS_RUN_SEPARATOR,
-            sys.executable,
-            _extractor_script_path(),
-            FLAG_INCREMENTAL,
-        ],
-        **_detached_spawn_keyword_arguments(),
-    )
-
-
-def _spawn_without_bws() -> None:
-    subprocess.Popen(
-        [
-            sys.executable,
-            _extractor_script_path(),
-            FLAG_INCREMENTAL,
-        ],
-        **_detached_spawn_keyword_arguments(),
-    )
+from hooks_constants.hook_log_extractor_constants import EXIT_CODE_SUCCESS
 
 
 def main() -> int:
-    """Debounce, then fire-and-forget the extractor; always exit 0."""
-    try:
-        if _is_within_debounce_window():
-            return EXIT_CODE_SUCCESS
-        _record_current_timestamp()
-        try:
-            if _can_use_bws():
-                _spawn_with_bws()
-            else:
-                _spawn_without_bws()
-        except Exception:
-            _clear_recorded_timestamp()
-    except Exception:
-        pass
+    """Exit success without spawning the extractor."""
     return EXIT_CODE_SUCCESS
 
 

package/hooks/diagnostic/test_hook_log_extractor.py

@@ -805,32 +805,19 @@ def test_offline_fallback_still_exits_zero_when_warning_log_write_raises(
     assert exit_code == 0
 
 
-def test_main_accepts_incremental_flag_as_noop(
-    tmp_path: Path,
+def test_main_is_disabled_and_skips_extraction(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    """C8: ``--incremental`` must be recognized and route to default extraction."""
-    captured_arguments: dict[str, object] = {}
-
-    def _fake_run_full_extraction(
-        transcripts_root: str,
-        state_file_path: str,
-        full_rebuild: bool,
-    ) -> int:
-        captured_arguments["transcripts_root"] = transcripts_root
-        captured_arguments["state_file_path"] = state_file_path
-        captured_arguments["full_rebuild"] = full_rebuild
-        return 0
-
-    monkeypatch.setattr(sys, "argv", ["hook_log_extractor.py", "--incremental"])
+    """Disabled main exits success without running extraction."""
+
+    def _fail_if_called(*_args: object, **_kwargs: object) -> int:
+        raise AssertionError("run_full_extraction must not run while disabled")
+
     monkeypatch.setattr(
-        hook_log_extractor, "run_full_extraction", _fake_run_full_extraction
+        hook_log_extractor, "run_full_extraction", _fail_if_called
     )
 
-    exit_code = hook_log_extractor.main()
-
-    assert exit_code == 0
-    assert captured_arguments["full_rebuild"] is False
+    assert hook_log_extractor.main() == 0
 
 
 def test_run_query_returns_nonzero_for_unknown_query(