claude-dev-env 4.3.0 → 7.1.0

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,67 +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() -> None:
-    """When two or more hooks deny, all their reasons appear in the dispatcher output.
-
-    Uses a Write to an existing markdown path with a historical phrase
-    ("previously") so write_existing_file_blocker and state_description_blocker
-    both deny.
-    """
-    existing_markdown_path = str(Path(__file__).resolve().parent / "CLAUDE.md")
-    multi_deny_content = (
-        "# Guide\n\n"
-        "Previously the system used a different mechanism.\n"
-    )
-    payload_text = _write_payload(existing_markdown_path, multi_deny_content)
-    _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, "Dispatcher must deny when any hook denies"
-
-    applicable_entries = _applicable_entries_for_tool(WRITE_TOOL_NAME)
-    all_expected_deny_reasons: list[str] = []
-    for each_entry in applicable_entries:
-        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, (
-        f"Test payload must trip at least two hooks — got {len(all_expected_deny_reasons)}. "
-        "Check that an existing path triggers write_existing_file_blocker and "
-        "'previously' triggers state_description_blocker on a Write."
-    )
-    for each_reason in all_expected_deny_reasons:
-        assert each_reason in dispatcher_reason, (
-            f"Missing deny reason in dispatcher output.\n"
-            f"Expected reason: {each_reason!r}\n"
-            f"Dispatcher reason: {dispatcher_reason!r}"
-        )
-
-
 def test_aggregate_exit_code_two_signals_deny() -> None:
     """A HostedHookResult with exit_code 2 and did_crash False signals deny.
 
@@ -686,87 +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() -> None:
-    """Dispatcher denies even when an earlier hook exits cleanly before a later hook denies.
-
-    state_description_blocker denies a markdown write with a historical phrase.
-    Earlier hooks exit 0 (allow). The dispatcher must catch each hook's
-    SystemExit and continue, so the later denial reaches the aggregator.
-    """
-    payload_text = _write_payload(
-        _MARKDOWN_FILE_PATH,
-        "# Doc\n\nPreviously this section used a different mechanism.\n",
-    )
-    _assert_dispatcher_matches_individual_hooks(payload_text, WRITE_TOOL_NAME)
-
-
-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) == 18, (
-        f"Write tool must apply to all 18 hosted 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) == 20, (
-        f"expected 20 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 immediate-harm-plus-TDD 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 = {
@@ -829,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.
 
@@ -885,45 +702,19 @@ def _parse_hook_allow(completed_process: subprocess.CompletedProcess[str]) -> bo
     return hook_specific.get("permissionDecision") == "allow"
 
 
-def test_dispatcher_reemits_explicit_allow_from_tdd_enforcer(tmp_path: Path) -> None:
-    """The dispatcher re-emits an explicit allow when tdd_enforcer's allow branch fires.
-
-    tdd_enforcer writes an explicit allow payload for a constants-only Python
-    Write, which auto-approves the write standalone. Run against the dispatcher,
-    the same payload must produce an explicit allow decision identical to the
-    standalone tdd_enforcer output, rather than a silent fall-back to the default
-    permission flow.
-
-    Args:
-        tmp_path: Pytest temp directory hosting the fresh config target path.
-    """
+def test_retired_tdd_hook_cannot_auto_approve_the_write(tmp_path: Path) -> None:
+    """Pairing belongs to staged lint; its edit-time auto-approval is absent."""
     config_target_path = str(tmp_path / "config" / "timing.py")
     constants_only_content = (
         '"""Timing constants."""\n\nMAXIMUM_RETRIES = 3\nRETRY_DELAY_SECONDS = 5\n'
     )
     payload_text = _write_payload(config_target_path, constants_only_content)
-
     standalone_result = _run_hook_subprocess("blocking/tdd_enforcer.py", payload_text)
-    assert _parse_hook_allow(standalone_result), (
-        "tdd_enforcer must emit an explicit allow for a constants-only Python Write — "
-        "if it does not, this fixture no longer exercises the allow branch"
-    )
-
+    assert _parse_hook_allow(standalone_result)
     dispatcher_result = _run_dispatcher(payload_text)
-    dispatcher_is_deny, _reason = _parse_hook_decision(dispatcher_result)
-    assert not dispatcher_is_deny, "dispatcher must not deny a payload tdd_enforcer allows"
-    assert _parse_hook_allow(dispatcher_result), (
-        "dispatcher must re-emit an explicit allow when a hosted hook allows explicitly "
-        "and no hook denies, matching the standalone tdd_enforcer behavior — "
-        f"got stdout {dispatcher_result.stdout.strip()!r}"
-    )
-    dispatcher_payload = json.loads(dispatcher_result.stdout.strip())
-    standalone_payload = json.loads(standalone_result.stdout.strip())
-    assert dispatcher_payload == standalone_payload, (
-        "dispatcher allow payload must match the standalone tdd_enforcer allow payload.\n"
-        f"Standalone: {standalone_payload!r}\n"
-        f"Dispatcher: {dispatcher_payload!r}"
-    )
+    dispatcher_is_deny, reason = _parse_hook_decision(dispatcher_result)
+    assert not dispatcher_is_deny, reason
+    assert not _parse_hook_allow(dispatcher_result)
 
 
 def test_runpy_hosted_hook_sees_its_own_argv_not_the_dispatchers(tmp_path: Path) -> None:
@@ -1007,13 +798,7 @@ def _dispatcher_matchers(all_pre_tool_use_groups: list[dict]) -> list[str]:
 
 
 def test_apply_patch_has_no_standalone_code_rules_enforcer_hooks_json_entry() -> None:
-    """apply_patch's code_rules_enforcer coverage comes only from the dispatcher.
-
-    hooks.json once registered a standalone apply_patch to code_rules_enforcer.py
-    PreToolUse command. That entry is now folded into the dispatcher's own
-    Write|Edit|MultiEdit|apply_patch matcher, so no separate command may still
-    spawn code_rules_enforcer.py for apply_patch on its own.
-    """
+    """The retired code-rules hook has no direct apply_patch registration."""
     hooks_json_text = (_HOOKS_ROOT / "hooks.json").read_text(encoding="utf-8")
     all_pre_tool_use_groups = json.loads(hooks_json_text)["hooks"]["PreToolUse"]
 
@@ -1048,127 +833,43 @@ 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:
-    """The dispatcher allows an apply_patch "add" whose paired test already exists.
-
-    tdd_enforcer now reaches apply_patch the same way it reaches Write: an
-    untested production file is exactly the immediate-harm case the apply_patch
-    boundary rule names, so "clean" here means test-first was honored before
-    the tool call, not that TDD is skipped for this tool. The paired test file
-    is written to disk first, matching how test_dispatcher_surfaces_migration_
-    warning_for_edit proves a fresh Edit passes tdd_enforcer.
-    """
-    (tmp_path / "test_services.py").write_text(
-        "def test_add_one():\n    assert True\n", encoding="utf-8"
-    )
+    """A clean patch can proceed before the staged linter evaluates test pairing."""
     patch_command = _codex_add_patch(
-        "services.py",
-        "def add_one(value: int) -> int:\n    return value + 1\n",
+        "services.py", "def add_one(value: int) -> int:\n    return value + 1\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 not is_deny, (
-        f"dispatcher must allow an apply_patch add with a fresh paired test, "
-        f"got deny reason {reason_text!r}"
-    )
-
-
-def test_hosted_hook_set_covers_all_write_edit_blocking_hooks() -> None:
-    """The hosted hook set covers all previously-registered Write/Edit blocking hooks.
-
-    Verifies that removing the standalone gate entries from hooks.json did not
-    silently drop coverage: every script path that was registered as a blocking
-    PreToolUse hook for Write/Edit is present in the dispatcher's hosted set.
-    """
-    all_hosted_script_paths = frozenset(
+    assert not is_deny, reason_text
+
+
+ALL_RETAINED_PATHS = {
+    "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",
+    "blocking/state_description_blocker.py",
+    "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 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
-    )
-    previously_registered_blocking_hooks: frozenset[str] = frozenset({
-        "blocking/write_existing_file_blocker.py",
-        "blocking/sensitive_file_protector.py",
-        "validation/hook_format_validator.py",
-        "blocking/code_rules_enforcer.py",
-        "blocking/tdd_enforcer.py",
-        "blocking/windows_rmtree_blocker.py",
-        "blocking/state_description_blocker.py",
-        "blocking/subprocess_budget_completeness.py",
-        "blocking/hook_prose_detector_consistency.py",
-        "blocking/workflow_substitution_slot_blocker.py",
-        "blocking/claude_md_orphan_file_blocker.py",
-        "blocking/pytest_testpaths_orphan_blocker.py",
-        "blocking/open_questions_in_plans_blocker.py",
-    })
-    for each_script_path in previously_registered_blocking_hooks:
-        assert each_script_path in all_hosted_script_paths, (
-            f"Previously-registered blocking hook {each_script_path!r} is missing "
-            "from the dispatcher's hosted hook set — coverage was lost when the "
-            "standalone entry was removed from hooks.json"
-        )
+    }
+    assert all_hosted_script_paths == ALL_RETAINED_PATHS
+    assert not all_hosted_script_paths.intersection(ALL_RETIRED_PATHS)
+    for each_relative_path in ALL_RETIRED_PATHS:
+        assert (_HOOKS_ROOT / each_relative_path).is_file()

package/hooks/blocking/test_pre_tool_use_dispatcher_native.py

@@ -1,16 +1,8 @@
-"""Native-equivalence tests for the nativized PreToolUse hosted hooks.
-
-For the state_description_blocker hook the dispatcher runs natively. This suite
-asserts the native evaluate() call and the hook's standalone __main__ subprocess
-path decide identically on the same payload: same allow-or-deny, same deny-reason
-text. It also asserts the dispatcher reaches the same decision through its native
-path.
-
-The corpus pairs allowing payloads with denying payloads for each hook so the
-equivalence holds across both outcomes. Each payload names an absolute file
-under this repository and carries the repository root as its ``cwd``, so the
-decision belongs to this checkout rather than to the directory pytest runs
-from.
+"""Preserve detector equivalence while retiring its dispatcher registration.
+
+The standalone state-description detector remains callable by the policy linter.
+Its function and script agree on valid and invalid inputs; the write dispatcher
+allows these policy findings to reach the staged linter.
 """
 
 from __future__ import annotations
@@ -195,28 +187,6 @@ def _deny_reason_from_dispatcher(payload_dictionary: dict[str, object]) -> str |
     )
     return _deny_reason_from_script_stdout(completed_process.stdout.strip())
 
-def _deny_payload_from_dispatcher(payload_dictionary: dict[str, object]) -> dict[str, object]:
-    """Run the dispatcher as a subprocess and return its parsed deny payload.
-
-    Args:
-        payload_dictionary: The payload dict to send as JSON on stdin.
-
-    Returns:
-        The dispatcher's emitted deny JSON parsed into a dict.
-    """
-    completed_process = subprocess.run(
-        [sys.executable, _DISPATCHER_SCRIPT],
-        check=False,
-        input=json.dumps(payload_dictionary),
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        env=_subprocess_environment(),
-    )
-    parsed_payload = json.loads(completed_process.stdout.strip())
-    assert isinstance(parsed_payload, dict)
-    return parsed_payload
-
 def test_state_description_native_allows_match_script() -> None:
     """state_description_blocker native allow matches the script's allow."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_ALLOW_CONTENT)
@@ -262,18 +232,17 @@ def test_state_description_native_multi_edit_deny_matches_script() -> None:
     assert native_reason == script_reason
 
 
-def test_dispatcher_native_path_denies_state_description() -> None:
-    """The dispatcher's native path denies a state_description_blocker violation."""
+def test_dispatcher_allows_the_retired_state_description_rule() -> None:
+    """The detector still finds the violation, but the write dispatcher allows it."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
     native_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     dispatcher_reason = _deny_reason_from_dispatcher(payload_dictionary)
     assert native_reason is not None
-    assert dispatcher_reason is not None
-    assert native_reason in dispatcher_reason
+    assert dispatcher_reason is None
 
 
-def test_dispatcher_native_state_description_carries_additional_context() -> None:
-    """The dispatcher's state-description deny carries the standalone additionalContext."""
+def test_standalone_state_description_retains_additional_context() -> None:
+    """The retained standalone interface still supplies its corrective context."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
     deny_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     assert deny_reason is not None
@@ -281,20 +250,20 @@ def test_dispatcher_native_state_description_carries_additional_context() -> Non
     standalone_hook_specific = standalone_payload["hookSpecificOutput"]
     assert isinstance(standalone_hook_specific, dict)
     expected_additional_context = standalone_hook_specific["additionalContext"]
-    dispatcher_payload = _deny_payload_from_dispatcher(payload_dictionary)
-    dispatcher_hook_specific = dispatcher_payload.get("hookSpecificOutput", {})
-    assert isinstance(dispatcher_hook_specific, dict)
-    assert dispatcher_hook_specific.get("additionalContext") == expected_additional_context
+    script_payload = json.loads(_run_script_subprocess(_STATE_DESCRIPTION_SCRIPT, payload_dictionary))
+    script_hook_specific = script_payload.get("hookSpecificOutput", {})
+    assert isinstance(script_hook_specific, dict)
+    assert script_hook_specific.get("additionalContext") == expected_additional_context
 
-def test_dispatcher_native_state_description_carries_system_message() -> None:
-    """The dispatcher's state-description deny carries the standalone systemMessage."""
+def test_standalone_state_description_retains_system_message() -> None:
+    """The retained standalone interface still supplies its system message."""
     payload_dictionary = _write_payload_dictionary(_MARKDOWN_PATH, _STATE_DESCRIPTION_DENY_CONTENT)
     deny_reason = _evaluate_with_prose_style_opt_in(state_description_blocker.evaluate, payload_dictionary)
     assert deny_reason is not None
     standalone_payload = state_description_blocker.build_deny_payload(deny_reason)
     expected_system_message = standalone_payload["systemMessage"]
     assert isinstance(expected_system_message, str)
-    dispatcher_payload = _deny_payload_from_dispatcher(payload_dictionary)
-    dispatcher_system_message = dispatcher_payload.get("systemMessage")
-    assert isinstance(dispatcher_system_message, str)
-    assert expected_system_message in dispatcher_system_message
+    script_payload = json.loads(_run_script_subprocess(_STATE_DESCRIPTION_SCRIPT, payload_dictionary))
+    script_system_message = script_payload.get("systemMessage")
+    assert isinstance(script_system_message, str)
+    assert expected_system_message in script_system_message

package/hooks/blocking/test_shared_stdin_adoption.py

@@ -34,11 +34,7 @@ from test_hook_subprocess_support import (  # noqa: E402
     run_hook_as_subprocess,
 )
 
-ALL_CONVERTED_HOOK_FILENAMES = (
-    "open_questions_in_plans_blocker.py",
-    "claude_md_orphan_file_blocker.py",
-    "package_inventory_stale_blocker.py",
-)
+ALL_CONVERTED_HOOK_FILENAMES = ("open_questions_in_plans_blocker.py",)
 
 EMPTY_STDIN_PAYLOAD = ""
 WHITESPACE_STDIN_PAYLOAD = "   \n\t  "
@@ -126,48 +122,6 @@ def test_open_questions_blocker_still_allows_plan_without_open_questions(
     assert _decision_from_stdout(completed) is None
 
 
-def test_package_inventory_blocker_still_denies_uninventoried_new_file(
-    tmp_path: Path,
-) -> None:
-    inventory_body = "# package\n\n| File | Role |\n|---|---|\n| `alpha.py` | A |\n| `beta.py` | B |\n"
-    (tmp_path / "README.md").write_text(inventory_body, encoding="utf-8")
-    (tmp_path / "alpha.py").write_text("x = 1\n", encoding="utf-8")
-    (tmp_path / "beta.py").write_text("x = 1\n", encoding="utf-8")
-    new_file_path = tmp_path / "gamma.py"
-    payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": str(new_file_path), "content": "x = 1\n"},
-        }
-    )
-    completed = _run_hook_script("package_inventory_stale_blocker.py", payload, tmp_path)
-    assert completed.returncode == 0, completed.stderr
-    assert _decision_from_stdout(completed) == "deny"
-    assert_hook_deny_log_contains(tmp_path, "package_inventory_stale_blocker.py")
-
-
-def test_package_inventory_blocker_still_allows_inventoried_new_file(
-    tmp_path: Path,
-) -> None:
-    inventory_body = (
-        "# package\n\n| File | Role |\n|---|---|\n"
-        "| `alpha.py` | A |\n| `beta.py` | B |\n| `gamma.py` | G |\n"
-    )
-    (tmp_path / "README.md").write_text(inventory_body, encoding="utf-8")
-    (tmp_path / "alpha.py").write_text("x = 1\n", encoding="utf-8")
-    (tmp_path / "beta.py").write_text("x = 1\n", encoding="utf-8")
-    new_file_path = tmp_path / "gamma.py"
-    payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": str(new_file_path), "content": "x = 1\n"},
-        }
-    )
-    completed = _run_hook_script("package_inventory_stale_blocker.py", payload, tmp_path)
-    assert completed.returncode == 0, completed.stderr
-    assert _decision_from_stdout(completed) is None
-
-
 def test_converted_hooks_allow_unrelated_tool_name(tmp_path: Path) -> None:
     payload = json.dumps({"tool_name": "Bash", "tool_input": {"command": "ls"}})
     for each_hook_filename in ALL_CONVERTED_HOOK_FILENAMES:

package/hooks/git-hooks/git_hooks_constants/staged_policy_lint.py

@@ -0,0 +1,12 @@
+"""Constants for the native pre-commit policy-lint step."""
+
+POLICY_LINT_PACKAGE_PARENT_INDEX = 2
+POLICY_LINT_SCRIPT_RELATIVE_PATH = "scripts/cde_lint.py"
+POLICY_LINT_STAGED_ARGUMENT = "--staged"
+POLICY_LINT_TIMEOUT_SECONDS = 240
+POLICY_LINT_INFRASTRUCTURE_EXIT_CODE = 2
+POLICY_LINT_UNAVAILABLE_MESSAGE = (
+    "cde lint is missing from this hook installation; reinstall claude-dev-env "
+    "before committing"
+)
+POLICY_LINT_FAILED_MESSAGE = "cde lint could not complete: {error}"