claude-dev-env 7.0.0 → 7.1.0

package/bin/install.transaction.test.mjs

@@ -286,7 +286,7 @@ test('installer fault after_file_staging restores prior managed installation', (
             'utf8',
         );
 
-        const failedRun = runInstaller(homeDirectory, ['--only', 'journal'], {
+        const failedRun = runInstaller(homeDirectory, ['--only', 'core'], {
             faultPhase: FAULT_PHASES.AFTER_FILE_STAGING,
         });
         assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
@@ -333,7 +333,7 @@ test('installer fault after_manifest_write restores prior manifest', () => {
             'utf8',
         );
 
-        const failedRun = runInstaller(homeDirectory, ['--only', 'journal'], {
+        const failedRun = runInstaller(homeDirectory, ['--only', 'core'], {
             faultPhase: FAULT_PHASES.AFTER_MANIFEST_WRITE,
         });
         assert.notEqual(failedRun.status, 0, failedRun.stdout + failedRun.stderr);
@@ -387,7 +387,7 @@ test('successful install after prior install leaves one manifest and no fault',
     const homeDirectory = mkdtempSync(join(tmpdir(), 'cdev-txn-e2e-ok-'));
     try {
         seedPriorInstall(homeDirectory);
-        const okRun = runInstaller(homeDirectory, ['--only', 'journal']);
+        const okRun = runInstaller(homeDirectory, ['--only', 'core']);
         assert.equal(okRun.status, 0, okRun.stdout + okRun.stderr);
         const manifestPath = join(homeDirectory, '.claude', '.claude-dev-env-manifest.json');
         assert.equal(existsSync(manifestPath), true);

package/docs/CODE_RULES.md

@@ -43,7 +43,7 @@ Before writing ANY constant: search `config/` for the exact value → semantic m
 
 ## 5. NO ABBREVIATIONS
 
-Full words only (`context`, not `ctx`). Exceptions: `i`/`j`/`k` in loops, `e` for exception. Naming patterns: loop vars `each_*`; booleans `is_/has_/should_/can_/was_/did_`; collections `all_*`; maps `X_by_Y`; preposition params (`from_path=`, `to=`, `into=`). Banned names: `result`, `data`, `output`, `response`, `value`, `item`, `temp`. Banned prefixes: `handle`, `process`, `manage`, `do`. Name a component for what it IS — `Overlay`, `Validator`, `InvoicePreview`.
+Full words only (`context`, not `ctx`). Exceptions: `i`/`j`/`k` in loops, `e` for exception. Naming patterns: loop vars `each_*`; booleans `is_/has_/should_/can_/was_/did_`; collections `all_*`; maps `X_by_Y`; preposition params (`from_path=`, `to=`, `into=`). Banned names: `result`, `data`, `output`, `response`, `value`, `item`, `temp`. Banned prefixes: `handle`, `process`, `manage`, `do`. Name components for what they are: `Overlay`, `Validator`, `InvoicePreview`. The failure-blast-radius rule requires `ItemBlocked` or `RunFatal`. Names ending with either bypass the banned-noun word check.
 
 ### Public compatibility definitions
 

package/hooks/blocking/code_rules_banned_identifiers.py

@@ -30,6 +30,7 @@ from code_rules_shared import (  # noqa: E402
 from hooks_constants.banned_identifiers_constants import (  # noqa: E402
     ALL_BANNED_IDENTIFIERS,
     ALL_BANNED_NOUN_WORDS,
+    ALL_BLAST_RADIUS_EXCEPTION_SUFFIXES,
     BANNED_IDENTIFIER_MESSAGE_SUFFIX,
     BANNED_IDENTIFIER_SKIP_ADVISORY,
     BANNED_NOUN_COMPATIBILITY_COMMENT,
@@ -228,6 +229,8 @@ def _find_banned_noun_word(identifier: str) -> str | None:
         identifier (e.g., ``'result'`` for ``'HolidayPeakResult'``). Returns
         ``None`` when no banned noun word is present.
     """
+    if identifier.endswith(ALL_BLAST_RADIUS_EXCEPTION_SUFFIXES):
+        return None
     for each_word in _identifier_word_parts(identifier):
         if each_word in ALL_BANNED_NOUN_WORDS:
             return each_word

package/hooks/blocking/precommit_code_rules_gate.py

@@ -1,11 +1,8 @@
-"""Library helper: resolve a directory's Git repository root.
-
-``pii_prevention_blocker.py`` and ``pii_payload_scan.py`` import
-``resolve_repository_root`` to find the repository a staged-commit scan
-targets, and ``session_edit_stage_gate.py`` imports it to find the
-repository a commit's unstaged-edit check targets. This module carries no
-hook entry point of its own; the native ``git-hooks/pre_commit.py`` runs
-the real commit-time CODE_RULES enforcement.
+"""Library helper that resolves a directory to its Git repository root.
+
+``pii_payload_scan.py`` imports ``resolve_repository_root`` for staged scans.
+This module has no hook entry point. Native ``git-hooks/pre_commit.py`` shows
+the local verification advisory and does not enforce CODE_RULES.
 """
 
 import subprocess

package/hooks/blocking/test_bash_dispatcher_interpreter_starts.py

@@ -1,61 +1,16 @@
-"""Benchmark: consolidated Bash dispatcher starts one interpreter, not N.
+"""Tests for the retired Bash and PowerShell blocking roster."""
 
-Standalone registration starts one Python process per hosted hook. The
-dispatcher replaces that chain with a single process that hosts every hook
-in-process. This test pins the before/after interpreter-start counts so a
-regression that re-splits the chain fails CI.
-"""
-
-from __future__ import annotations
-
-import json
-import subprocess
 import sys
 from pathlib import Path
 
-_HOOKS_DIR = str(Path(__file__).resolve().parent.parent)
-if _HOOKS_DIR not in sys.path:
-    sys.path.insert(0, _HOOKS_DIR)
+_HOOKS_ROOT = Path(__file__).resolve().parent.parent
+if str(_HOOKS_ROOT) not in sys.path:
+    sys.path.insert(0, str(_HOOKS_ROOT))
 
-from hooks_constants.bash_pre_tool_use_dispatcher_constants import (  # noqa: E402
+from hooks_constants.bash_pre_tool_use_dispatcher_constants import (
     ALL_BASH_HOSTED_HOOK_ENTRIES,
-    BASH_TOOL_NAME,
 )
 
-_BLOCKING_DIR = Path(__file__).resolve().parent
-_HOOKS_ROOT = _BLOCKING_DIR.parent
-_DISPATCHER_SCRIPT = str(_BLOCKING_DIR / "bash_pre_tool_use_dispatcher.py")
-
-STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL = len(ALL_BASH_HOSTED_HOOK_ENTRIES)
-DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL = 1
-
-
-def test_roster_is_large_enough_that_consolidation_saves_starts() -> None:
-    """Consolidation only pays off when the chain hosts more than one hook."""
-    assert STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL >= 10
-    assert DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL == 1
-    assert STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL > DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL
-
-
-def test_dispatcher_handles_a_bash_call_in_one_process() -> None:
-    """One subprocess run of the dispatcher covers the full Bash hosted chain."""
-    payload_text = json.dumps(
-        {"tool_name": BASH_TOOL_NAME, "tool_input": {"command": "echo interpreter-start-probe"}}
-    )
-    completed = subprocess.run(
-        [sys.executable, _DISPATCHER_SCRIPT],
-        check=False,
-        input=payload_text,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-    )
-    assert completed.returncode == 0
-    assert DISPATCHER_INTERPRETER_STARTS_PER_BASH_CALL == 1
-
 
-def test_standalone_chain_would_start_one_process_per_roster_entry() -> None:
-    """Each roster path is a real script that would own its own interpreter start."""
-    for each_entry in ALL_BASH_HOSTED_HOOK_ENTRIES:
-        assert (_HOOKS_ROOT / each_entry.script_relative_path).is_file()
-    assert len(ALL_BASH_HOSTED_HOOK_ENTRIES) == STANDALONE_INTERPRETER_STARTS_PER_BASH_CALL
+def test_retired_bash_roster_has_no_effective_blocking_hooks() -> None:
+    assert ALL_BASH_HOSTED_HOOK_ENTRIES == ()

package/hooks/blocking/test_bash_pre_tool_use_dispatcher.py

@@ -100,17 +100,6 @@ def test_clean_command_yields_no_decision_matching_the_standalone_chain() -> Non
     assert dispatcher_decision == expected_decision
 
 
-def test_destructive_command_asks_matching_the_standalone_chain() -> None:
-    """A destructive command the chain asks on makes the dispatcher ask too."""
-    payload_text = _bash_payload("rm -rf /")
-    expected_decision = _expected_precedence(payload_text, BASH_TOOL_NAME)
-    dispatcher_decision, _reason = _decision_from_stdout(
-        _run_process(_DISPATCHER_SCRIPT, payload_text).stdout
-    )
-    assert dispatcher_decision == expected_decision
-    assert expected_decision == "ask"
-
-
 def test_dispatcher_exits_zero_on_a_clean_command() -> None:
     """The dispatcher exits zero for a command no hook decides on."""
     completed = _run_process(_DISPATCHER_SCRIPT, _bash_payload("echo hi"))
@@ -212,19 +201,6 @@ def test_additional_context_is_collected_from_deciding_hooks() -> None:
     assert aggregated.all_additional_context == ["see docs/runbook.md"]
 
 
-def test_powershell_selects_the_shared_hooks_in_registration_order() -> None:
-    """Selecting for PowerShell yields the shared hooks in registration order."""
-    powershell_paths = [
-        each_entry.script_relative_path
-        for each_entry in select_applicable_entries(POWERSHELL_TOOL_NAME)
-    ]
-    assert powershell_paths == [
-        "blocking/cursor_cli_python_misfire_blocker.py",
-        "blocking/unscoped_search_blocker.py",
-        "blocking/pii_prevention_blocker.py",
-    ]
-
-
 def test_dispatcher_imports_standalone_with_only_blocking_on_the_path() -> None:
     """The dispatcher's bootstrap resolves hooks_constants without hooks/ on PYTHONPATH."""
     subprocess_environment = {**os.environ, "PYTHONPATH": str(_BLOCKING_DIR)}
@@ -259,48 +235,3 @@ def test_emit_decision_re_emits_silent_deny_fields(
     assert hook_specific["additionalContext"] == "see docs/runbook.md"
     assert emitted_payload["systemMessage"] == "[gh-gate] blocked redirected gh pr create"
     assert emitted_payload["suppressOutput"] is True
-
-
-def test_dispatcher_denies_subshell_disguised_as_arithmetic_expansion() -> None:
-    """The dispatcher denies a `$((cd X) && Y)` subshell, not only the bare hook.
-
-    `echo $((cd /tmp) && pwd)` opens with a `$((` two-character lookahead
-    match, so a function-level test alone does not prove the block reaches
-    the live Bash tool path.
-    """
-    payload_text = _bash_payload("echo $((cd /tmp) && pwd)")
-    decision, _reason = _decision_from_stdout(_run_process(_DISPATCHER_SCRIPT, payload_text).stdout)
-    assert decision == "deny"
-
-
-def test_dispatch_emits_deny_immediately_and_skips_later_hooks(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    """A mid-chain deny emits at once and does not invoke later hosted hooks."""
-    all_call_paths: list[str] = []
-
-    def _fake_run_hook(script_path: str, payload_text: str) -> HostedHookRun:
-        del payload_text
-        all_call_paths.append(script_path)
-        script_name = Path(script_path).name
-        if script_name == "destructive_command_blocker.py":
-            return HostedHookRun(
-                captured_stdout=_decision_json("deny", "blocked early"),
-                did_crash=False,
-            )
-        if script_name == "precommit_code_rules_gate.py":
-            raise AssertionError("later hooks must not run after an early deny")
-        return HostedHookRun(captured_stdout="", did_crash=False)
-
-    monkeypatch.setattr(
-        "bash_pre_tool_use_dispatcher.run_hook_capturing_output",
-        _fake_run_hook,
-    )
-    dispatch(_bash_payload("rm -rf /"), BASH_TOOL_NAME)
-    captured = capsys.readouterr()
-    decision, reason = _decision_from_stdout(captured.out)
-    assert decision == "deny"
-    assert "blocked early" in reason
-    assert any(path.endswith("destructive_command_blocker.py") for path in all_call_paths)
-    assert not any(path.endswith("precommit_code_rules_gate.py") for path in all_call_paths)

package/hooks/blocking/test_code_rules_banned_identifiers.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from code_rules_banned_identifiers import (
+    _find_banned_noun_word,
+    check_banned_noun_word_boundary,
+)
+
+PRODUCTION_FILE_PATH = "packages/app/services/customer_pipeline.py"
+
+
+def test_should_return_no_banned_word_for_item_blocked_exception_suffix() -> None:
+    assert _find_banned_noun_word("AssetSizingItemBlocked") is None
+    assert _find_banned_noun_word("NinePatchGuideFrameItemBlocked") is None
+
+
+def test_should_return_no_banned_word_for_run_fatal_exception_suffix() -> None:
+    assert _find_banned_noun_word("AssetVariantRunFatal") is None
+
+
+def test_should_return_banned_word_for_item_without_blast_radius_suffix() -> None:
+    assert _find_banned_noun_word("IconGridItem") == "item"
+    assert _find_banned_noun_word("item_key") == "item"
+
+
+def test_should_allow_class_ending_with_item_blocked_suffix() -> None:
+    source = "class AssetSizingItemBlocked(Exception):\n    pass\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_long_class_ending_with_item_blocked_suffix() -> None:
+    source = "class NinePatchGuideFrameItemBlocked(Exception):\n    pass\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_allow_class_ending_with_run_fatal_suffix() -> None:
+    source = "class AssetVariantRunFatal(Exception):\n    pass\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_should_flag_class_ending_with_item_without_blast_radius_suffix() -> None:
+    source = "class IconGridItem:\n    pass\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert any("IconGridItem" in each_issue for each_issue in issues)
+
+
+def test_should_flag_item_key_assignment() -> None:
+    source = "item_key = 'slot'\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert any("item_key" in each_issue for each_issue in issues)
+
+
+def test_should_flag_output_path_assignment() -> None:
+    source = "output_path = 'slot'\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert any("output_path" in each_issue for each_issue in issues)
+
+
+def test_should_flag_each_value_assignment() -> None:
+    source = "each_value = 1\n"
+    issues = check_banned_noun_word_boundary(source, PRODUCTION_FILE_PATH)
+    assert any("each_value" in each_issue for each_issue in issues)

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -1,14 +1,8 @@
 """Golden differential and failure-mode tests for the PreToolUse dispatcher.
 
-Each golden differential test runs a payload through every applicable hosted
-hook as its own subprocess (the production path), records each hook's
-allow-or-deny and messages, computes the expected aggregate, then runs the
-dispatcher on the same payload and asserts equal decision and equal message
-union.
-
-The failure-mode tests cover one row each from spec/failure-modes.md:
-early-exit-then-later-deny, multi-deny, context-survival, blocking-hook crash,
-fail-open malformed input.
+The live roster carries only nonblocking edit advisors. These tests keep the
+aggregator contract and prove retired policy registrations fail open while
+explicit standalone checks remain callable.
 """
 
 from __future__ import annotations
@@ -31,7 +25,6 @@ if str(_HOOKS_ROOT) not in sys.path:
 
 from hooks_constants.pre_tool_use_dispatcher_constants import (  # noqa: E402, I001
     ALL_HOSTED_HOOK_ENTRIES,
-    ALL_IMMEDIATE_HARM_SCRIPT_PATHS,
     APPLY_PATCH_TOOL_NAME,
     BLOCKING_CRASH_DENY_REASON,
     BLOCKING_CRASH_EXIT_CODE,
@@ -407,53 +400,6 @@ def test_write_existing_file_blocker_allows_multi_edit_to_an_existing_path(
     _assert_dispatcher_matches_individual_hooks(payload_text, MULTI_EDIT_TOOL_NAME)
 
 
-def test_context_survives_alongside_deny_reason(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
-) -> None:
-    """A non-denying hook's additional context survives in the dispatcher output.
-
-    This tests that hooks whose output is additional-context (not a deny) still
-    have their output preserved when another hook denies.
-    """
-    monkeypatch.setenv("HOME", str(tmp_path))
-    monkeypatch.setenv("USERPROFILE", str(tmp_path))
-    sensitive_path = str(Path.home() / ".env")
-    payload_text = _write_payload(sensitive_path, "SECRET=abc")
-    dispatcher_result = _run_dispatcher(payload_text)
-    is_deny, _reason = _parse_hook_decision(dispatcher_result)
-    assert is_deny, (
-        "sensitive_file_protector should deny a write to .env — "
-        "if it did not, check whether the path is on the sensitive list"
-    )
-    assert dispatcher_result.stdout.strip(), "Dispatcher must emit output when denying"
-
-
-def test_all_deny_reasons_present_when_multiple_hooks_deny(
-    monkeypatch: pytest.MonkeyPatch, tmp_path: Path,
-) -> None:
-    """Preserve every deny reason from the retained file-boundary checks."""
-    monkeypatch.setenv("HOME", str(tmp_path))
-    monkeypatch.setenv("USERPROFILE", str(tmp_path))
-    existing_sensitive_path = tmp_path / ".env"
-    existing_sensitive_path.write_text("VALUE=fixture\n", encoding="utf-8")
-    payload_text = _write_payload(str(existing_sensitive_path), "VALUE=changed\n")
-    _assert_dispatcher_matches_individual_hooks(payload_text, WRITE_TOOL_NAME)
-    dispatcher_result = _run_dispatcher(payload_text)
-    dispatcher_is_deny, dispatcher_reason = _parse_hook_decision(dispatcher_result)
-    assert dispatcher_is_deny
-    all_expected_deny_reasons: list[str] = []
-    for each_entry in _applicable_entries_for_tool(WRITE_TOOL_NAME):
-        completed_process = _run_hook_subprocess(each_entry.script_relative_path, payload_text)
-        is_deny, reason_text = _parse_hook_decision(completed_process)
-        if is_deny and reason_text:
-            all_expected_deny_reasons.append(reason_text)
-    assert len(all_expected_deny_reasons) >= 2, (
-        "Existing-file and sensitive-file checks must both deny the fixture"
-    )
-    for each_reason in all_expected_deny_reasons:
-        assert each_reason in dispatcher_reason
-
-
 def test_aggregate_exit_code_two_signals_deny() -> None:
     """A HostedHookResult with exit_code 2 and did_crash False signals deny.
 
@@ -672,81 +618,6 @@ def test_emit_allow_preserves_system_message_and_additional_context(
     assert parsed["systemMessage"] == "system-a\nsystem-b"
 
 
-def test_later_hook_deny_survives_early_hook_exit(tmp_path: Path) -> None:
-    """A retained document-reference denial survives earlier successful checks."""
-    payload_text = _orphan_claude_md_payload(tmp_path)
-    _assert_dispatcher_matches_individual_hooks(payload_text, WRITE_TOOL_NAME)
-    is_deny, reason = _parse_hook_decision(_run_dispatcher(payload_text))
-    assert is_deny, reason
-
-
-def test_dispatcher_write_applies_both_groups() -> None:
-    """Write tool triggers both Group A and Group B hooks through the dispatcher.
-
-    Verifies that the set of applicable entries for Write includes entries from
-    both ALL_WRITE_AND_EDIT_TOOL_NAMES (Group A) and ALL_WRITE_EDIT_MULTI_EDIT_TOOL_NAMES
-    (Group B) in the constants.
-    """
-    all_write_entries = _applicable_entries_for_tool(WRITE_TOOL_NAME)
-    all_write_script_paths = {each_entry.script_relative_path for each_entry in all_write_entries}
-    assert "blocking/write_existing_file_blocker.py" in all_write_script_paths, (
-        "write_existing_file_blocker (Group A) must be in Write applicable set"
-    )
-    assert len(all_write_entries) == 11, (
-        f"Write tool must apply to the 11 retained write hooks, got {len(all_write_entries)}"
-    )
-
-
-def test_dispatcher_edit_applies_both_groups() -> None:
-    """Edit triggers Group A, Group B, and the Edit-scoped entry through the
-    dispatcher.
-    """
-    all_edit_entries = _applicable_entries_for_tool(EDIT_TOOL_NAME)
-    all_edit_script_paths = {each_entry.script_relative_path for each_entry in all_edit_entries}
-    assert "blocking/stale_comment_reference_blocker.py" not in all_edit_script_paths
-    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) == 13, (
-        f"expected 13 retained Edit entries, got {len(all_edit_entries)}"
-    )
-
-
-def test_dispatcher_multi_edit_reaches_the_sensitive_protector() -> None:
-    """A MultiEdit onto a sensitive path meets the same gate a Write does.
-
-    test_edit_and_multi_edit_applicable_sets_are_equal in the constants suite
-    holds the Edit and MultiEdit rosters equal, so this pins the one hook whose
-    absence would let a secret through a MultiEdit.
-    """
-    all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
-    all_multi_edit_script_paths = {
-        each_entry.script_relative_path for each_entry in all_multi_edit_entries
-    }
-    assert "blocking/sensitive_file_protector.py" in all_multi_edit_script_paths, (
-        "sensitive_file_protector belongs in the MultiEdit applicable set"
-    )
-
-
-def test_dispatcher_apply_patch_applies_immediate_harm_hooks() -> None:
-    """apply_patch applies to exactly the immediate-harm roster.
-
-    apply_patch reaches only the retained immediate-harm roster the constants
-    module names, not the full Write/Edit/MultiEdit lint surface.
-    """
-    all_apply_patch_entries = _applicable_entries_for_tool(APPLY_PATCH_TOOL_NAME)
-    all_apply_patch_script_paths = {
-        each_entry.script_relative_path for each_entry in all_apply_patch_entries
-    }
-    assert "blocking/sensitive_file_protector.py" in all_apply_patch_script_paths, (
-        "sensitive_file_protector belongs in the apply_patch applicable set"
-    )
-    assert all_apply_patch_script_paths == set(ALL_IMMEDIATE_HARM_SCRIPT_PATHS), (
-        "apply_patch must apply to exactly the immediate-harm roster, got: "
-        f"{sorted(all_apply_patch_script_paths)}"
-    )
-
-
 def _assert_roster_names_no_run_all_validators_entry() -> None:
     """Assert no hosted-roster ``script_relative_path`` names run_all_validators."""
     all_roster_script_paths = {
@@ -809,40 +680,6 @@ def _orphan_claude_md_payload(tmp_path: Path) -> str:
     return _write_payload(claude_md_path, orphan_table)
 
 
-def test_runpy_deny_preserves_additional_context_and_suppress_output(tmp_path: Path) -> None:
-    """A runpy-hosted deny carries its additionalContext and suppressOutput through the dispatcher.
-
-    claude_md_orphan_file_blocker emits hookSpecificOutput.additionalContext and a
-    top-level suppressOutput flag on a deny. The dispatcher must preserve both so
-    the dispatched denial matches the standalone hook's deny shape.
-
-    Args:
-        tmp_path: Pytest temp directory hosting the throwaway CLAUDE.md.
-    """
-    payload_text = _orphan_claude_md_payload(tmp_path)
-
-    standalone_result = _run_hook_subprocess(
-        "blocking/claude_md_orphan_file_blocker.py", payload_text
-    )
-    standalone_payload = json.loads(standalone_result.stdout.strip())
-    standalone_hook_specific = standalone_payload["hookSpecificOutput"]
-    expected_additional_context = standalone_hook_specific["additionalContext"]
-
-    dispatcher_result = _run_dispatcher(payload_text)
-    dispatcher_payload = json.loads(dispatcher_result.stdout.strip())
-    dispatcher_hook_specific = dispatcher_payload.get("hookSpecificOutput", {})
-    assert isinstance(dispatcher_hook_specific, dict)
-    assert dispatcher_hook_specific.get("additionalContext") == expected_additional_context, (
-        "Dispatcher must preserve the runpy hook's additionalContext.\n"
-        f"Expected: {expected_additional_context!r}\n"
-        f"Got: {dispatcher_hook_specific.get('additionalContext')!r}"
-    )
-    assert dispatcher_payload.get("suppressOutput") is True, (
-        "Dispatcher must preserve the runpy hook's suppressOutput flag.\n"
-        f"Got: {dispatcher_payload.get('suppressOutput')!r}"
-    )
-
-
 def _parse_hook_allow(completed_process: subprocess.CompletedProcess[str]) -> bool:
     """Parse one hook's subprocess result for an explicit permissionDecision allow.
 
@@ -996,72 +833,6 @@ def _codex_add_patch(relative_file_path: str, file_body: str) -> str:
     )
 
 
-def test_dispatcher_denies_apply_patch_add_with_hardcoded_secret(
-    tmp_path: Path,
-    init_bare_git_repo: Callable[[Path], None],
-    synthetic_github_token: str,
-) -> None:
-    """The dispatcher denies an apply_patch "add" that writes a hardcoded token.
-
-    Proves Done-when scenario 1 (hardcoded secret/PII denied) reaches apply_patch
-    through the real dispatcher subprocess, not only the standalone
-    pii_prevention_blocker test.
-    """
-    repository_root = tmp_path / "repo"
-    init_bare_git_repo(repository_root)
-    patch_command = _codex_add_patch("leaked.py", f"token is {synthetic_github_token}\n")
-    payload_text = _apply_patch_payload(str(repository_root), patch_command)
-
-    dispatcher_result = _run_dispatcher(payload_text)
-    is_deny, reason_text = _parse_hook_decision(dispatcher_result)
-    assert is_deny, (
-        "dispatcher must deny an apply_patch add carrying a hardcoded secret, "
-        f"got stdout {dispatcher_result.stdout.strip()!r}"
-    )
-    assert reason_text, "a deny must carry a non-empty reason"
-
-
-def test_dispatcher_denies_apply_patch_targeting_a_sensitive_path(tmp_path: Path) -> None:
-    """The dispatcher denies an apply_patch "add" that targets a sensitive file.
-
-    Proves Done-when scenario 2 (sensitive path denied) reaches apply_patch
-    through the real dispatcher subprocess.
-    """
-    patch_command = _codex_add_patch(".env", "SECRET_KEY=irrelevant\n")
-    payload_text = _apply_patch_payload(str(tmp_path), patch_command)
-
-    dispatcher_result = _run_dispatcher(payload_text)
-    is_deny, reason_text = _parse_hook_decision(dispatcher_result)
-    assert is_deny, (
-        "dispatcher must deny an apply_patch add targeting a sensitive path, "
-        f"got stdout {dispatcher_result.stdout.strip()!r}"
-    )
-    assert reason_text, "a deny must carry a non-empty reason"
-
-
-def test_dispatcher_denies_apply_patch_add_onto_an_existing_path(tmp_path: Path) -> None:
-    """The dispatcher denies an apply_patch "add" that targets a path already on disk.
-
-    Proves Done-when scenario 3 (overwrite-without-reading denied) reaches
-    apply_patch: a Codex "add" operation onto an existing path is caught by
-    code_rules_enforcer's codex-patch reading, blocking/codex_apply_patch.py's
-    _codex_read_patch_file, which raises CodexPatchError for an add already on
-    disk, reported through the dispatcher's aggregate.
-    """
-    existing_target = tmp_path / "already_here.py"
-    existing_target.write_text("value = 1\n", encoding="utf-8")
-    patch_command = _codex_add_patch("already_here.py", "value = 2\n")
-    payload_text = _apply_patch_payload(str(tmp_path), patch_command)
-
-    dispatcher_result = _run_dispatcher(payload_text)
-    is_deny, reason_text = _parse_hook_decision(dispatcher_result)
-    assert is_deny, (
-        "dispatcher must deny an apply_patch add onto an already-existing path, "
-        f"got stdout {dispatcher_result.stdout.strip()!r}"
-    )
-    assert reason_text, "a deny must carry a non-empty reason"
-
-
 def test_dispatcher_allows_clean_apply_patch_add(tmp_path: Path) -> None:
     """A clean patch can proceed before the staged linter evaluates test pairing."""
     patch_command = _codex_add_patch(
@@ -1074,21 +845,11 @@ def test_dispatcher_allows_clean_apply_patch_add(tmp_path: Path) -> None:
 
 
 ALL_RETAINED_PATHS = {
-    "blocking/write_existing_file_blocker.py",
-    "blocking/sensitive_file_protector.py",
-    "blocking/pii_prevention_blocker.py",
-    "validation/hook_format_validator.py",
-    "blocking/duplicate_rmtree_helper_blocker.py",
-    "blocking/claude_md_orphan_file_blocker.py",
-    "blocking/package_inventory_stale_blocker.py",
-    "blocking/env_var_table_code_drift_blocker.py",
-    "blocking/pytest_testpaths_orphan_blocker.py",
-    "blocking/open_questions_in_plans_blocker.py",
-    "blocking/docstring_rule_gate_count_blocker.py",
     "advisory/refactor_guard.py",
     "advisory/migration_safety_advisor.py",
 }
 ALL_RETIRED_PATHS = {
+    "validation/hook_format_validator.py",
     "blocking/code_rules_enforcer.py",
     "blocking/tdd_enforcer.py",
     "blocking/windows_rmtree_blocker.py",
@@ -1096,10 +857,15 @@ ALL_RETIRED_PATHS = {
     "blocking/subprocess_budget_completeness.py",
     "blocking/hook_prose_detector_consistency.py",
     "blocking/workflow_substitution_slot_blocker.py",
+    "blocking/open_questions_in_plans_blocker.py",
+    "blocking/docstring_rule_gate_count_blocker.py",
+    "blocking/duplicate_rmtree_helper_blocker.py",
+    "blocking/env_var_table_code_drift_blocker.py",
+    "blocking/pytest_testpaths_orphan_blocker.py",
 }
 
 def test_hosted_hook_set_retains_boundaries_and_excludes_replaced_file_checks() -> None:
-    """Keep unresolved controls and exclude the seven staged-linter replacements."""
+    """Keep boundary controls and exclude every registry-backed policy hook."""
     all_hosted_script_paths = {
         each_entry.script_relative_path for each_entry in ALL_HOSTED_HOOK_ENTRIES
     }