claude-dev-env 2.12.0 → 2.14.0

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/AGENTS.md

@@ -0,0 +1,43 @@
+# hooks/diagnostic
+
+Hooks and scripts that collect, store, and query hook-firing records. The pipeline reads session JSONL transcripts, extracts hook attachment records, and writes them as rows into a Neon (Postgres) `hook_events` table.
+
+## Subdirectories
+
+| Directory | Role |
+|---|---|
+| `migrations/` | SQL migration files for the `hook_events` schema |
+| `queries/` | Parameterized SQL queries for inspecting blocked commands |
+
+## Key files
+
+| 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` | 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 |
+| `test_hook_log_extractor.py` | Tests for the extractor |
+| `test_hook_log_init.py` | Tests for the schema-init script |
+| `test_hook_log_stop_wrapper.py` | Tests for the Stop wrapper |
+
+## Schema overview (`schema.sql`)
+
+The `hook_events` table captures one row per hook firing:
+
+- `hook_event`, `hook_name`, `hook_category` — what fired
+- `outcome` — `allowed`, `blocked`, or `ask`
+- `tool_name`, `command_excerpt` — what tool was called
+- `session_id`, `git_branch`, `cwd` — context
+- `duration_ms`, `exit_code` — timing and result
+- `source_jsonl_path`, `source_line_number` — idempotency key
+
+The `blocked_commands` view filters to `outcome = 'blocked'`.
+
+## Conventions
+
+- 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/CLAUDE.md

@@ -1,43 +1 @@
-# hooks/diagnostic
-
-Hooks and scripts that collect, store, and query hook-firing records. The pipeline reads session JSONL transcripts, extracts hook attachment records, and writes them as rows into a Neon (Postgres) `hook_events` table.
-
-## Subdirectories
-
-| Directory | Role |
-|---|---|
-| `migrations/` | SQL migration files for the `hook_events` schema |
-| `queries/` | Parameterized SQL queries for inspecting blocked commands |
-
-## Key files
-
-| 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 |
-| `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 |
-| `test_hook_log_extractor.py` | Tests for the extractor |
-| `test_hook_log_init.py` | Tests for the schema-init script |
-| `test_hook_log_stop_wrapper.py` | Tests for the Stop wrapper |
-
-## Schema overview (`schema.sql`)
-
-The `hook_events` table captures one row per hook firing:
-
-- `hook_event`, `hook_name`, `hook_category` — what fired
-- `outcome` — `allowed`, `blocked`, or `ask`
-- `tool_name`, `command_excerpt` — what tool was called
-- `session_id`, `git_branch`, `cwd` — context
-- `duration_ms`, `exit_code` — timing and result
-- `source_jsonl_path`, `source_line_number` — idempotency key
-
-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.
-- 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`.
+@AGENTS.md

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,
@@ -106,7 +99,7 @@ from hooks_constants.hook_log_extractor_constants import (
     STDERR_EXCERPT_MAX_CHARACTERS,
     STDOUT_EXCERPT_MAX_CHARACTERS,
     SUMMARY_COLUMN_HEADINGS,
-    SUMMARY_NO_NEW_BLOCKS_MESSAGE,
+    SUMMARY_ZERO_BLOCKED_EVENTS_MESSAGE,
     SUMMARY_TABLE_COLUMN_GAP,
     TOP_BLOCKED_COMMAND_PREVIEW_MAX_CHARACTERS,
     TOP_BLOCKERS_LAST_24_HOURS_SQL,
@@ -787,7 +780,7 @@ def run_summary() -> int:
         except Exception:
             pass
     if not all_result_rows:
-        print(SUMMARY_NO_NEW_BLOCKS_MESSAGE)
+        print(SUMMARY_ZERO_BLOCKED_EVENTS_MESSAGE)
         return EXIT_CODE_SUCCESS
     _print_summary_table(all_result_rows)
     return EXIT_CODE_SUCCESS
@@ -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/migrations/AGENTS.md

@@ -0,0 +1,16 @@
+# hooks/diagnostic/migrations
+
+SQL migration files for the `hook_events` Neon schema. Each file applies a schema change to the `hook_events` table or its indexes.
+
+## Files
+
+| File | What it does |
+|---|---|
+| `2026-04-25-drop-themes-hook-events.sql` | Drops the `themes` hook-events table variant |
+| `README.md` | Notes on the migration approach |
+
+## Conventions
+
+- Run migrations manually against the Neon database using `psql` or the Neon console.
+- The baseline schema lives in `diagnostic/schema.sql`.
+- File names follow `YYYY-MM-DD-<description>.sql` for chronological ordering.

package/hooks/diagnostic/migrations/CLAUDE.md

@@ -1,16 +1 @@
-# hooks/diagnostic/migrations
-
-SQL migration files for the `hook_events` Neon schema. Each file applies a schema change to the `hook_events` table or its indexes.
-
-## Files
-
-| File | What it does |
-|---|---|
-| `2026-04-25-drop-themes-hook-events.sql` | Drops the `themes` hook-events table variant |
-| `README.md` | Notes on the migration approach |
-
-## Conventions
-
-- Run migrations manually against the Neon database using `psql` or the Neon console.
-- The baseline schema lives in `diagnostic/schema.sql`.
-- File names follow `YYYY-MM-DD-<description>.sql` for chronological ordering.
+@AGENTS.md

package/hooks/diagnostic/queries/AGENTS.md

@@ -0,0 +1,19 @@
+# hooks/diagnostic/queries
+
+Parameterized SQL queries for inspecting the `hook_events` Neon table. Run these directly against the Neon database to analyze hook-firing patterns.
+
+## Files
+
+| File | What it returns |
+|---|---|
+| `block_details_for_hook.sql` | Full details for all blocked events matching a given hook name |
+| `blocks_by_category.sql` | Count of blocks grouped by hook category |
+| `blocks_by_tool.sql` | Count of blocks grouped by tool name |
+| `blocks_last_7_days.sql` | All blocked events from the last 7 days |
+| `top_blockers_last_24_hours.sql` | Hook names with the most blocks in the last 24 hours |
+| `top_blockers_overall.sql` | Hook names with the most blocks across all time |
+
+## Conventions
+
+- Queries target the `hook_events` table and `blocked_commands` view defined in `diagnostic/schema.sql`.
+- Run with `psql $DATABASE_URL -f <query>.sql` or paste into the Neon console.

package/hooks/diagnostic/queries/CLAUDE.md

@@ -1,19 +1 @@
-# hooks/diagnostic/queries
-
-Parameterized SQL queries for inspecting the `hook_events` Neon table. Run these directly against the Neon database to analyze hook-firing patterns.
-
-## Files
-
-| File | What it returns |
-|---|---|
-| `block_details_for_hook.sql` | Full details for all blocked events matching a given hook name |
-| `blocks_by_category.sql` | Count of blocks grouped by hook category |
-| `blocks_by_tool.sql` | Count of blocks grouped by tool name |
-| `blocks_last_7_days.sql` | All blocked events from the last 7 days |
-| `top_blockers_last_24_hours.sql` | Hook names with the most blocks in the last 24 hours |
-| `top_blockers_overall.sql` | Hook names with the most blocks across all time |
-
-## Conventions
-
-- Queries target the `hook_events` table and `blocked_commands` view defined in `diagnostic/schema.sql`.
-- Run with `psql $DATABASE_URL -f <query>.sql` or paste into the Neon console.
+@AGENTS.md

package/hooks/diagnostic/test_hook_log_extractor.py

@@ -617,7 +617,7 @@ def test_tool_name_extracted_from_hook_name_prefix() -> None:
     assert hook_log_extractor.extract_tool_name("UserPromptSubmit") is None
 
 
-def test_run_summary_prints_no_new_blocks_when_cursor_empty(
+def test_run_summary_prints_zero_blocked_events_when_cursor_empty(
     capsys: pytest.CaptureFixture[str],
 ) -> None:
     fake_cursor = MagicMock()
@@ -632,7 +632,7 @@ def test_run_summary_prints_no_new_blocks_when_cursor_empty(
 
     captured = capsys.readouterr()
     assert exit_code == 0
-    assert "No new blocks since last run." in captured.out
+    assert "Blocked events recorded in the last 24 hours: 0." in captured.out
 
 
 def test_run_summary_prints_table_when_rows_returned(
@@ -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(