claude-dev-env 2.12.0 → 2.13.0

package/hooks/blocking/CLAUDE.md

@@ -6,10 +6,7 @@ PreToolUse hooks that deny (block) tool calls when a rule is violated. The main
 
 | Directory | Role |
 |---|---|
-| `config/` | Shared constants for the verified-commit gate family (`verified_commit_constants.py`) |
 | `tdd_enforcer_parts/` | Concern modules the `tdd_enforcer.py` entry hook wires together: path classification, content analysis, candidate-path resolution, freshness, git-tracking restore detection, decisions, and constants |
-| `verified_commit_gate_parts/` | Concern modules the `verified_commit_gate.py` entry hook wires together: command tokenization, directory-change resolution, gated git-invocation resolution, deny-reason resolution, and deny-payload assembly |
-| `code_review_stamp_write_blocker_parts/` | Concern modules the `code_review_stamp_directory_write_blocker.py` entry hook wires together: the split directory-change-into-stamp matcher and the obfuscated-stamp-path-write matcher |
 | `claude_md_orphan_file_blocker_parts/` | Concern modules the `claude_md_orphan_file_blocker.py` entry hook wires together: reference extraction, subtree scan, scan plan, decision, and constants |
 | `package_inventory_stale_blocker_parts/` | Concern modules the `package_inventory_stale_blocker.py` entry hook wires together: inventory detection, decision, and constants |
 | `inventory_intent_records/` | The shared per-session pending-intent store both inventory blockers read to break the file/row add-order deadlock |
@@ -73,11 +70,6 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `block_main_commit.py` | PreToolUse (Bash) | `git commit`/`git push` directly to `main` |
 | `bot_mention_comment_blocker.py` | PreToolUse (Write/Edit) | PR review comments that @-mention a bot |
 | `claude_md_orphan_file_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | Per-directory `CLAUDE.md` table cells naming a bare filename absent from the directory subtree |
-| `code_review_pr_create_gate.py` | PreToolUse (Bash/MCP GitHub) | `gh pr create` or the MCP `create_pull_request` tool without a clean `xhigh` code-review stamp covering the branch surface |
-| `code_review_push_gate.py` | PreToolUse (Bash/PowerShell) | `git push` without a clean `low` code-review stamp covering the branch surface |
-| `code_review_stamp_directory_write_blocker.py` | PreToolUse (Bash/PowerShell/Write/Edit/MultiEdit) | Shell or file-tool writes into `~/.claude/code-review-stamps/`, and shell references to the stamp store module or its mint call, outside the sanctioned invoker |
-| `code_verifier_spawn_preflight_gate.py` | PreToolUse (Agent) | Spawning the `code-verifier` subagent when the branch has a merge conflict vs its base or a CODE_RULES violation on a working-tree-added line, or the CODE_RULES engine fails to load |
-| `convergence_gate_blocker.py` | PreToolUse (Bash) | Convergence workflow actions on a conflicting PR |
 | `conventional_pr_title_gate.py` | PreToolUse (Bash) | `gh pr create`/`gh pr edit` with a `--title` that is not a Conventional Commit, in a repo whose CI runs a semantic-pull-request title check |
 | `destructive_command_blocker.py` | PreToolUse (Bash/PowerShell) | Shell commands with destructive literals (`rm -rf`, `git reset --hard`, etc.) |
 | `docstring_rule_gate_count_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | A stale spelled-out gate-validator count in `docstring-prose-matches-implementation.md` — the "N more gate validators" / "M gated slices" count drifting from the `check_docstring_*` validators the prose names |
@@ -101,13 +93,10 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `pii_scanner.py` | library | Pure text scanners shared by `pii_prevention_blocker.py` |
 | `piped_pytest_blocker.py` | PreToolUse (Bash) | A pytest run whose output feeds a pipe, where the pipeline reports the exit code of the command on the right |
 | `plain_language_blocker.py` | PreToolUse (Write/Edit/AskUserQuestion) | Heavy or jargon words in user-facing prose when `CLAUDE_PROSE_STYLE_ENFORCEMENT` is on (default off); AskUserQuestion lean-block structure stays always on |
-| `pr_converge_bugteam_enforcer.py` | PreToolUse | Enforces that bugteam runs in parallel with bugbot in pr-converge loops |
-| `pr_description_enforcer.py` | PreToolUse (Bash) | `gh pr create`/`edit`/`comment` bodies that fail the Anthropic claude-code style audit, proof-shaped `gh pr comment` bodies missing proof-of-work parts, and `gh pr ready` while the PR carries no passing proof comment |
 | `precommit_code_rules_gate.py` | PreToolUse (Bash) | Staged changes that fail the CODE_RULES gate at commit time |
 | `pytest_testpaths_orphan_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | New `test_*.py` files created under a directory absent from a package's explicit pytest `testpaths` allowlist |
 | `question_to_user_enforcer.py` | Stop | User-directed questions not routed through `AskUserQuestion` |
-| `reviewer_spawn_gate.py` | PreToolUse (Bash) | A sentinel-marked autoconverge reviewer-spawn command (Copilot review request, Bugbot rerun comment) run while `reviewer_availability.py` reports that reviewer down or out of quota |
-| `send_user_file_open_locally_blocker.py` | PreToolUse (SendUserFile) | A desk-side file attach (`SendUserFile` with `status` not `proactive`); points to opening the file locally via `Show-Asset.ps1` |
+| `send_user_file_open_locally_blocker.py` | PreToolUse (SendUserFile) | A desk-side file attach (`SendUserFile` with `status` not `proactive`); points to opening the file with its native Windows app |
 | `sensitive_file_protector.py` | PreToolUse (Write/Edit) | Writes to sensitive credential or config files |
 | `session_edit_stage_gate.py` | PreToolUse (Bash) | A `git commit` that would drop files edited this session because they are tracked but left unstaged |
 | `session_handoff_blocker.py` | Stop | Responses suggesting a new session mid-task |
@@ -117,10 +106,6 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `subprocess_budget_completeness.py` | PreToolUse | Subprocess calls missing required budget arguments |
 | `tdd_enforcer.py` | PreToolUse (Write/Edit) | Production code written without a matching failing test |
 | `unscoped_search_blocker.py` | PreToolUse (Bash/PowerShell) | A `find` or recursive listing that walks from the filesystem root, a drive root, bare home, or a network share root |
-| `verdict_directory_write_blocker.py` | PreToolUse (Bash/PowerShell) | Shell writes into `~/.claude/verification/` |
-| `verified_commit_gate.py` | PreToolUse (Bash/PowerShell) | `git commit`/`git push` without a passing verifier verdict |
-| `verified_commit_message_accuracy_blocker.py` | PreToolUse | Commit messages that misstate what the diff has |
-| `verifier_verdict_minter.py` | SubagentStop | Mints a passing verdict file when a `code-verifier` agent finishes cleanly |
 | `volatile_path_in_post_blocker.py` | PreToolUse (Bash/MCP GitHub) | `gh` post commands and GitHub MCP post tools whose body references a volatile path (job scratch dir, worktree, or system temp) that outlives the durable post |
 | `windows_rmtree_blocker.py` | PreToolUse (Write/Edit) | `shutil.rmtree` with `ignore_errors=True` on Windows |
 | `workflow_substitution_slot_blocker.py` | PreToolUse (Write/Edit) | Workflow templates with bare per-iteration tokens missing angle-bracket slots |
@@ -131,18 +116,8 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | File | Role |
 |---|---|
 | `_gh_body_arg_utils.py` | Parsing helpers for `gh_body_arg_blocker.py` |
-| `code_review_enforcement_config_bootstrap.py` | Binds `config.code_review_enforcement_constants` to the sibling `config/` file by explicit location, so the code-review gate family resolves its constants regardless of a foreign `config` package's `sys.path` order |
-| `code_review_gate_deny.py` | Shared deny scaffold for the push and PR-create code-review gates: the `hookSpecificOutput` deny-payload builder and the log-and-emit helper, so both gates share one deny shape |
-| `code_review_stamp_store.py` | Reads and writes the per-work-tree code-review stamp files under `~/.claude/code-review-stamps/`, and decides whether a clean stamp at the needed effort covers the live branch surface |
-| `pr_description_body_audit.py` | Body audit logic for `pr_description_enforcer.py` |
-| `pr_description_command_parser.py` | `gh` command parsing for `pr_description_enforcer.py` |
-| `pr_description_pr_number.py` | PR number extraction logic |
-| `pr_description_proof_of_work.py` | Proof-of-work comment audit and `gh pr ready` gate logic for `pr_description_enforcer.py` |
-| `pr_description_readability.py` | Readability checks on PR description bodies |
-| `verification_verdict_store.py` | Reads and writes verdict files under `~/.claude/verification/` |
-| `verified_commit_config_bootstrap.py` | Binds `config.verified_commit_constants` to the sibling `config/` file by explicit location, so the gate family resolves its constants regardless of a foreign `config` package's `sys.path` order |
 
 ## Conventions
 
 - Tests live beside each hook as `test_<hookname>.py` or `test_<hookname>_<suffix>.py`. Run with `python -m pytest <test_file>`.
-- Tunable constants live in `hooks_constants/<hook_name>_constants.py`; the verified-commit family uses `blocking/config/verified_commit_constants.py`.
+- Tunable constants live in `hooks_constants/<hook_name>_constants.py`.

package/hooks/blocking/config/CLAUDE.md

@@ -1,22 +1,10 @@
 # hooks/blocking/config
 
-A Python package that holds shared constants for blocking hooks. Verified-commit gate modules and opinionated prose-style gates import from here.
+A Python package that holds shared constants for blocking hooks. Opinionated prose-style gates import from here.
 
 ## Key files
 
 | File | Contents |
 |---|---|
 | `__init__.py` | Declares this as a regular package (not a namespace package) so it resolves first on `sys.path` |
-| `code_review_enforcement_constants.py` | Stamp and effort tunables for the code-review enforcement gates |
 | `prose_style_enforcement_constants.py` | `CLAUDE_PROSE_STYLE_ENFORCEMENT` opt-in (default off) for opinionated prose gates |
-| `verified_commit_constants.py` | All tunables for the gate: directory names, regex patterns for detecting verdict paths and obfuscation attempts, timeout values, git subcommand sets, bypass marker, and corrective messages |
-| `verified_commit_context_constants.py` | `VERIFY_SKIP_ADDITIONAL_CONTEXT`, the ``# verify-skip`` usage rule the gate attaches to a deny payload's `additionalContext` |
-| `verified_commit_gate_output_constants.py` | `PRE_TOOL_USE_HOOK_EVENT_NAME` and `DENY_PERMISSION_DECISION` (the deny payload's event name and decision string), `GATE_HOOK_MODULE_NAME` (the gate's own module name for block logging), and `REGEX_ALTERNATION_SEPARATOR` (the `\|` join for the directory-change verb alternation in `gated_invocations.py`) |
-
-## Key constants in `verified_commit_constants.py`
-
-- `VERIFICATION_BYPASS_MARKER` — the `# verify-skip` comment that exempts a single commit/push from the gate
-- `MINTING_AGENT_TYPE` — `"code-verifier"`, the agent type whose SubagentStop hook mints verdicts
-- `VERDICT_DIRECTORY_NAME` — `"verification"`, the directory under `~/.claude/` that holds verdict JSON files
-- `DOCS_ONLY_EXTENSIONS` — extensions (`.md`, `.txt`, images) whose changes are mechanically exempt from the gate
-- `CORRECTIVE_MESSAGE` / `VERDICT_DIRECTORY_GUARD_MESSAGE` — user-facing block messages

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(