claude-dev-env 4.2.0 → 7.0.0

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_precommit_code_rules_gate_native_owner.py

@@ -10,7 +10,6 @@ from __future__ import annotations
 from collections.abc import Iterator
 from contextlib import contextmanager
 import json
-import shutil
 import stat
 import subprocess
 import sys
@@ -21,12 +20,20 @@ import pytest
 HOOKS_ROOT = Path(__file__).resolve().parent.parent
 BLOCKING_ROOT = HOOKS_ROOT / "blocking"
 GIT_HOOKS_ROOT = HOOKS_ROOT / "git-hooks"
-PRE_COMMIT_SOURCE_PATH = GIT_HOOKS_ROOT / "pre_commit.py"
-GATE_UTILS_SOURCE_PATH = GIT_HOOKS_ROOT / "gate_utils.py"
-GIT_HOOKS_CONSTANTS_SOURCE_PATH = GIT_HOOKS_ROOT / "git_hooks_constants"
 DISPATCHER_SOURCE_PATH = BLOCKING_ROOT / "bash_pre_tool_use_dispatcher.py"
 GIT_COMMAND_TIMEOUT_SECONDS = 60
-CLEAN_MODULE_SOURCE = "def add_one(number: int) -> int:\n    return number + 1\n"
+CLEAN_MODULE_SOURCE = (
+    "def add_one(number: int) -> int:\n"
+    '    """Increase the number.\n\n'
+    "    Args:\n        number: The input number.\n\n"
+    "    Returns:\n        The next number.\n"
+    '    """\n'
+    "    return number + 1\n"
+)
+PAIRED_TEST_SOURCE = (
+    "from widget import add_one\n\n"
+    "def test_add_one() -> None:\n    assert add_one(1) == 2\n"
+)
 
 
 def run_git(
@@ -69,21 +76,13 @@ def write_gate_script(gate_path: Path, marker_path: Path, exit_code: int) -> Non
 
 
 def install_native_pre_commit(hooks_path: Path) -> None:
-    """Install the native pre-commit module and its self-contained imports."""
+    """Register the actual package owner with its complete linter dependency tree."""
     hooks_path.mkdir()
-    shutil.copyfile(PRE_COMMIT_SOURCE_PATH, hooks_path / "pre_commit.py")
-    shutil.copyfile(GATE_UTILS_SOURCE_PATH, hooks_path / "gate_utils.py")
-    shutil.copytree(
-        GIT_HOOKS_CONSTANTS_SOURCE_PATH,
-        hooks_path / "git_hooks_constants",
-    )
     pre_commit_path = hooks_path / "pre-commit"
     pre_commit_path.write_text(
         "#!/usr/bin/env python3\n"
         "import sys\n"
-        "from pathlib import Path\n"
-        "shim_directory = Path(__file__).resolve().parent\n"
-        "sys.path.insert(0, str(shim_directory))\n"
+        f"sys.path.insert(0, {str(GIT_HOOKS_ROOT)!r})\n"
         "import pre_commit\n"
         "sys.exit(pre_commit.main())\n",
         encoding="utf-8",
@@ -133,9 +132,10 @@ def temporary_hooks_path(repository_root: Path, benchmark_hooks_path: Path) -> I
 
 
 def stage_module(repository_root: Path) -> None:
-    """Write and stage one Python module for the commit fixture."""
+    """Stage a valid module and matching test before exercising the legacy gate."""
     (repository_root / "widget.py").write_text(CLEAN_MODULE_SOURCE, encoding="utf-8")
-    run_git(repository_root, "add", "widget.py")
+    (repository_root / "test_widget.py").write_text(PAIRED_TEST_SOURCE, encoding="utf-8")
+    run_git(repository_root, "add", "widget.py", "test_widget.py")
 
 
 def build_bash_payload(repository_root: Path) -> str:
@@ -216,7 +216,7 @@ def test_temporary_hooks_path_restores_shared_worktree_config_on_timeout(
     initialize_repository(tmp_path)
     supported_hooks_path = tmp_path / "supported_hooks"
     supported_hooks_path.mkdir()
-    run_git(tmp_path, "config", "--local", "core.hooksPath", str(supported_hooks_path))
+    run_git(tmp_path, "config", "core.hooksPath", str(supported_hooks_path))
     unrelated_worktree = tmp_path.parent / "unrelated_worktree"
     run_git(tmp_path, "worktree", "add", "--detach", str(unrelated_worktree))
     benchmark_hooks_path = tmp_path / "benchmark_hooks"

package/hooks/gh_post_body_texts.py

@@ -0,0 +1,195 @@
+"""Extract durable GitHub post body text for privacy checks."""
+
+from __future__ import annotations
+
+import shlex
+from pathlib import Path
+
+from blocking._gh_body_arg_utils import (
+    all_body_flags,
+    body_file_flag,
+    body_file_short_flag,
+    count_extra_tokens_to_skip_for_split_quoted_value,
+    get_logical_first_line,
+    is_unresolvable_shell_value,
+    match_body_file_equals_prefix,
+    match_body_flag_equals_prefix,
+    strip_surrounding_quotes,
+)
+from hooks_constants.gh_post_body_texts_constants import (
+    ALL_GH_POST_SUBCOMMANDS,
+    ALL_MCP_BODY_PARAM_NAMES,
+    BODY_FILE_ENCODING,
+    BODY_FLAG_WITH_VALUE_STEP,
+    GH_COMMAND_NAME,
+    MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT,
+    TOKEN_JOIN_SEPARATOR,
+)
+
+
+def _is_environment_assignment(token: str) -> bool:
+    equals_index = token.find("=")
+    if equals_index <= 0:
+        return False
+    name_part = token[:equals_index]
+    if not (name_part[0].isalpha() or name_part[0] == "_"):
+        return False
+    return all(each_character.isalnum() or each_character == "_" for each_character in name_part)
+
+
+def _tokens_name_gh_post_command(all_command_tokens: list[str]) -> bool:
+    command_index = 0
+    while command_index < len(all_command_tokens) and _is_environment_assignment(
+        all_command_tokens[command_index]
+    ):
+        command_index += 1
+    if command_index >= len(all_command_tokens):
+        return False
+    if all_command_tokens[command_index] != GH_COMMAND_NAME:
+        return False
+    remaining_tokens = all_command_tokens[command_index + 1 :]
+    if len(remaining_tokens) < MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT:
+        return False
+    post_noun, post_verb = remaining_tokens[:MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT]
+    return post_verb in ALL_GH_POST_SUBCOMMANDS.get(post_noun, frozenset())
+
+
+def _reassemble_split_quoted_value(
+    value_token: str,
+    all_following_tokens: list[str],
+) -> tuple[str, int]:
+    extra_token_count = count_extra_tokens_to_skip_for_split_quoted_value(
+        all_following_tokens, value_token
+    )
+    if not extra_token_count:
+        return strip_surrounding_quotes(value_token), 0
+    joined_value = (
+        value_token
+        + TOKEN_JOIN_SEPARATOR
+        + TOKEN_JOIN_SEPARATOR.join(all_following_tokens[:extra_token_count])
+    )
+    return strip_surrounding_quotes(joined_value), extra_token_count
+
+
+def _extract_flag_value_at(
+    all_command_tokens: list[str],
+    token_index: int,
+) -> tuple[bool, str, int] | None:
+    current_token = all_command_tokens[token_index]
+    following_tokens = all_command_tokens[token_index + 1 :]
+    body_prefix = match_body_flag_equals_prefix(current_token)
+    if body_prefix is not None:
+        value, extra_count = _reassemble_split_quoted_value(
+            current_token[len(body_prefix) :], following_tokens
+        )
+        return False, value, token_index + 1 + extra_count
+    body_file_prefix = match_body_file_equals_prefix(current_token)
+    if body_file_prefix is not None:
+        value, extra_count = _reassemble_split_quoted_value(
+            current_token[len(body_file_prefix) :], following_tokens
+        )
+        return True, value, token_index + 1 + extra_count
+    if current_token in all_body_flags and following_tokens:
+        value, extra_count = _reassemble_split_quoted_value(
+            following_tokens[0], following_tokens[1:]
+        )
+        return False, value, token_index + BODY_FLAG_WITH_VALUE_STEP + extra_count
+    if current_token in (body_file_flag, body_file_short_flag) and following_tokens:
+        value, extra_count = _reassemble_split_quoted_value(
+            following_tokens[0], following_tokens[1:]
+        )
+        return True, value, token_index + BODY_FLAG_WITH_VALUE_STEP + extra_count
+    return None
+
+
+def _collect_body_flag_values(
+    all_command_tokens: list[str],
+) -> tuple[list[str], list[str]]:
+    all_inline_bodies: list[str] = []
+    all_body_file_paths: list[str] = []
+    token_index = 0
+    while token_index < len(all_command_tokens):
+        extraction = _extract_flag_value_at(all_command_tokens, token_index)
+        if extraction is None:
+            token_index += 1
+            continue
+        is_body_file, value, token_index = extraction
+        if is_body_file:
+            all_body_file_paths.append(value)
+        else:
+            all_inline_bodies.append(value)
+    return all_inline_bodies, all_body_file_paths
+
+
+def _read_body_file(
+    body_file_path: str,
+    working_directory: str | None,
+) -> str | None:
+    if is_unresolvable_shell_value(body_file_path):
+        return None
+    resolved_path = Path(body_file_path)
+    if not resolved_path.is_absolute() and working_directory:
+        resolved_path = Path(working_directory) / body_file_path
+    try:
+        return resolved_path.read_text(encoding=BODY_FILE_ENCODING)
+    except (OSError, UnicodeError):
+        return None
+
+
+def _body_texts_from_tokens(
+    all_command_tokens: list[str],
+    working_directory: str | None,
+) -> tuple[list[str], str | None]:
+    if not _tokens_name_gh_post_command(all_command_tokens):
+        return [], None
+    all_body_texts, all_body_file_paths = _collect_body_flag_values(all_command_tokens)
+    for each_path in all_body_file_paths:
+        file_text = _read_body_file(each_path, working_directory)
+        if file_text is None:
+            return [], (
+                "BLOCKED [pii_prevention_blocker]: durable post uses --body-file "
+                f"but '{each_path}' could not be read for PII scanning. Use an "
+                "absolute path, ensure the file exists, or pass --body text."
+            )
+        all_body_texts.append(file_text)
+    return all_body_texts, None
+
+
+def extract_gh_post_body_texts_for_privacy_gate(
+    command: str,
+    working_directory: str | None = None,
+) -> tuple[list[str], str | None]:
+    """Extract GitHub post text and reject unreadable declared body files.
+
+    Args:
+        command: Raw GitHub CLI command.
+        working_directory: Base directory for relative body-file paths.
+
+    Returns:
+        Body texts and no error, or no texts and a rejection message without body text.
+    """
+    logical_line = get_logical_first_line(command)
+    if not logical_line:
+        return [], None
+    try:
+        all_command_tokens = shlex.split(logical_line, posix=False)
+    except ValueError:
+        return [], None
+    return _body_texts_from_tokens(all_command_tokens, working_directory)
+
+
+def extract_mcp_body_texts(all_tool_input: dict[str, object]) -> list[str]:
+    """Extract body and comment strings from a GitHub tool request.
+
+    Args:
+        all_tool_input: GitHub tool input mapping.
+
+    Returns:
+        Nonempty body and comment values.
+    """
+    all_body_texts: list[str] = []
+    for each_name in ALL_MCP_BODY_PARAM_NAMES:
+        candidate_text = all_tool_input.get(each_name)
+        if isinstance(candidate_text, str) and candidate_text:
+            all_body_texts.append(candidate_text)
+    return all_body_texts

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}"

package/hooks/git-hooks/pre_commit.py

@@ -1,17 +1,13 @@
 #!/usr/bin/env python3
-"""Native Git pre-commit owner for staged CODE_RULES validation.
+"""Run staged policy lint, then the existing staged CODE_RULES gate.
 
-Installed to the user's shared git-hooks directory via the claude-dev-env
-installer; git invokes this file as `pre-commit` (the installer strips the
-`_` and `.py` suffix when copying into the live hooks path).
+Git invokes this module through the installed native pre-commit shim. Policy
+lint reads the Git index, including GIT_INDEX_FILE when Git supplies an
+alternate index. The existing gate still covers checks whose replacement
+coverage is unproven.
 
-The Agent Bash commit surface records passive staged-surface evidence. This
-native hook invokes the shared gate and owns the staged commit decision.
-
-Exit codes:
-  0 - staged changes pass the gate (or the gate is not installed locally).
-  1 - staged changes introduce one or more blocking violations.
-  2 - unexpected invocation failure (e.g., subprocess could not launch).
+A missing linter, launch failure, or timeout is an infrastructure failure.
+Linter diagnostics and failed-rule statuses reach Git.
 """
 
 from __future__ import annotations
@@ -27,6 +23,43 @@ from git_hooks_constants import (
     IMMEDIATE_SCOPE_ARGUMENT,
     INVOKE_GATE_FAILURE_MESSAGE,
 )
+from git_hooks_constants.staged_policy_lint import (
+    POLICY_LINT_FAILED_MESSAGE,
+    POLICY_LINT_INFRASTRUCTURE_EXIT_CODE,
+    POLICY_LINT_PACKAGE_PARENT_INDEX,
+    POLICY_LINT_SCRIPT_RELATIVE_PATH,
+    POLICY_LINT_STAGED_ARGUMENT,
+    POLICY_LINT_TIMEOUT_SECONDS,
+    POLICY_LINT_UNAVAILABLE_MESSAGE,
+)
+
+
+def resolve_policy_lint_script_path() -> Path:
+    """Return the policy-linter entry point in this package or managed home."""
+    package_root = Path(__file__).resolve().parents[POLICY_LINT_PACKAGE_PARENT_INDEX]
+    return package_root / POLICY_LINT_SCRIPT_RELATIVE_PATH
+
+
+def run_staged_policy_lint() -> int:
+    """Run the staged linter with Git's environment and working directory.
+
+    Returns:
+        The linter status, or the infrastructure status when it cannot run.
+    """
+    try:
+        script_path = resolve_policy_lint_script_path()
+        if not script_path.is_file():
+            sys.stderr.write(POLICY_LINT_UNAVAILABLE_MESSAGE + "\n")
+            return POLICY_LINT_INFRASTRUCTURE_EXIT_CODE
+        completion = subprocess.run(
+            [sys.executable, str(script_path.resolve(strict=True)), POLICY_LINT_STAGED_ARGUMENT],
+            check=False,
+            timeout=POLICY_LINT_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.TimeoutExpired) as launch_error:
+        sys.stderr.write(POLICY_LINT_FAILED_MESSAGE.format(error=launch_error) + "\n")
+        return POLICY_LINT_INFRASTRUCTURE_EXIT_CODE
+    return completion.returncode
 
 
 def invoke_gate(gate_script_path: Path) -> int:
@@ -50,6 +83,14 @@ def invoke_gate(gate_script_path: Path) -> int:
 
 
 def main() -> int:
+    """Run local staged policy lint before the existing native commit checks.
+
+    Returns:
+        The first failing check's status, or zero when the checks pass.
+    """
+    lint_exit_code = run_staged_policy_lint()
+    if lint_exit_code != 0:
+        return lint_exit_code
     gate_script_not_found_message = GATE_SCRIPT_NOT_FOUND_MESSAGE
     gate_script_path, exact_allowed_path = resolve_gate_script_path()
     if not is_safe_regular_file(gate_script_path, exact_allowed_path):

package/hooks/git-hooks/test_installed_policy_lint.py

@@ -0,0 +1,159 @@
+"""Prove retirement and local enforcement through an actual disposable install."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from test_pre_commit import ALL_RULE_FIXTURES, _git, _stage
+from test_pre_commit import repository_root as repository_root
+
+ALL_RETIRED_HOOK_PATHS = (
+    "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",
+)
+PACKAGE_ROOT = Path(__file__).resolve().parents[2]
+
+
+def _legacy_settings_bytes(managed_root: Path, foreign_command: str) -> bytes:
+    original_settings = {
+        "permissions": {"allow": ["Read"]},
+        "hooks": {"PreToolUse": [{
+            "matcher": "Write|Edit|MultiEdit|apply_patch",
+            "hooks": [
+                {"type": "command", "command": foreign_command, "timeout": 17},
+                *({
+                    "type": "command",
+                    "command": f"python {managed_root.as_posix()}/hooks/{each_path}",
+                    "timeout": 10,
+                } for each_path in ALL_RETIRED_HOOK_PATHS),
+            ],
+        }]},
+    }
+    return json.dumps(original_settings, indent=2).encode("utf-8")
+
+
+def _install_environment(home: Path) -> dict[str, str]:
+    environment = {
+        each_name: each_value for each_name, each_value in os.environ.items()
+        if not each_name.startswith("GIT_")
+    }
+    environment.update({
+        "HOME": str(home),
+        "USERPROFILE": str(home),
+        "CLAUDE_CONFIG_DIR": str(home / ".claude"),
+        "CODEX_HOME": str(home / ".codex"),
+        "GIT_CONFIG_GLOBAL": str(home / "gitconfig"),
+        "GIT_CONFIG_NOSYSTEM": "1",
+    })
+    return environment
+
+
+def _install_twice(home: Path, settings_path: Path) -> bytes:
+    all_settings_bytes: list[bytes] = []
+    for each_run in range(2):
+        completed = subprocess.run(
+            ["node", str(PACKAGE_ROOT / "bin/install.mjs"), "--only", "core"],
+            cwd=PACKAGE_ROOT, env=_install_environment(home),
+            capture_output=True, text=True, check=False, timeout=180,
+        )
+        (home / f"install-{each_run}.log").write_text(
+            completed.stdout + completed.stderr, encoding="utf-8"
+        )
+        assert completed.returncode == 0, completed.stdout + completed.stderr
+        all_settings_bytes.append(settings_path.read_bytes())
+    assert all_settings_bytes[0] == all_settings_bytes[1]
+    return all_settings_bytes[-1]
+
+
+def _assert_retired_registrations(managed_root: Path, settings_bytes: bytes, foreign_command: str) -> None:
+    settings = json.loads(settings_bytes)
+    all_commands = [
+        each_hook["command"]
+        for each_groups in settings["hooks"].values()
+        for each_group in each_groups
+        for each_hook in each_group["hooks"]
+    ]
+    assert all_commands.count(foreign_command) == 1
+    assert "Read" in settings["permissions"]["allow"]
+    for each_relative_path in ALL_RETIRED_HOOK_PATHS:
+        assert not any(each_relative_path in each_command for each_command in all_commands)
+        source = PACKAGE_ROOT / "hooks" / each_relative_path
+        installed = managed_root / "hooks" / each_relative_path
+        assert hashlib.sha256(installed.read_bytes()).digest() == hashlib.sha256(source.read_bytes()).digest()
+
+
+@pytest.fixture(scope="module")
+def managed_installation(tmp_path_factory: pytest.TempPathFactory) -> Path:
+    """Install twice into a private home while retaining exact prior settings."""
+    home = tmp_path_factory.mktemp("installed-policy")
+    managed_root = home / ".claude"
+    managed_root.mkdir()
+    foreign_command = "python /unmanaged/fixture_notice.py"
+    original_bytes = _legacy_settings_bytes(managed_root, foreign_command)
+    settings_path = managed_root / "settings.json"
+    settings_path.write_bytes(original_bytes)
+    backup_directory = home / "before-cutover"
+    backup_directory.mkdir()
+    (backup_directory / "settings.json").write_bytes(original_bytes)
+    installed_settings = _install_twice(home, settings_path)
+    _assert_retired_registrations(managed_root, installed_settings, foreign_command)
+    assert (backup_directory / "settings.json").read_bytes() == original_bytes
+    hook_path = _git(home, "config", "--file", str(home / "gitconfig"), "--get", "core.hooksPath")
+    assert Path(hook_path).resolve() == (managed_root / "hooks/git-hooks").resolve()
+    return managed_root
+
+
+@pytest.mark.parametrize(("rule_id", "relative_path", "content"), ALL_RULE_FIXTURES)
+def test_installed_native_commit_catches_each_retired_file_rule(
+    managed_installation: Path,
+    repository_root: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    rule_id: str,
+    relative_path: str,
+    content: str,
+) -> None:
+    _git(repository_root, "config", "core.hooksPath", str(managed_installation / "hooks/git-hooks"))
+    monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
+    monkeypatch.setenv("CODE_RULES_GATE_PATH", str(repository_root / "missing-old-gate.py"))
+    before = _git(repository_root, "rev-parse", "HEAD")
+    _stage(repository_root, relative_path, content)
+    completed = subprocess.run(
+        ["git", "commit", "-m", "invalid fixture"],
+        cwd=repository_root, capture_output=True, text=True, check=False, timeout=240,
+    )
+    assert completed.returncode != 0
+    assert rule_id in completed.stdout + completed.stderr
+    assert _git(repository_root, "rev-parse", "HEAD") == before
+
+
+def test_installed_linter_and_native_commit_allow_valid_changes(
+    managed_installation: Path,
+    repository_root: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _git(repository_root, "config", "core.hooksPath", str(managed_installation / "hooks/git-hooks"))
+    monkeypatch.delenv("CLAUDE_CONFIG_DIR", raising=False)
+    monkeypatch.setenv("CODE_RULES_GATE_PATH", str(repository_root / "missing-old-gate.py"))
+    _stage(repository_root, "docs/guide.md", "# Guide\n\nThe API uses port 8080.\n")
+    completed = subprocess.run(
+        [sys.executable, str(managed_installation / "scripts/cde_lint.py"), "--staged", "--format", "json"],
+        cwd=repository_root, capture_output=True, text=True, check=False, timeout=240,
+    )
+    assert completed.returncode == 0, completed.stdout + completed.stderr
+    report = json.loads(completed.stdout)
+    assert report["failed_rules"] == []
+    assert "terminology-sweep" in report["executed_rules"]
+    before = _git(repository_root, "rev-parse", "HEAD")
+    _git(repository_root, "commit", "-m", "valid installed fixture")
+    assert _git(repository_root, "rev-parse", "HEAD") != before