claude-dev-env 4.3.0 → 7.0.0

package/hooks/blocking/test_code_rules_js_returns_object_schemaless.py

@@ -34,8 +34,8 @@ check_js_returns_object_schemaless_branch = (
 
 _MJS_PATH = "skills/autoconverge/workflow/converge.mjs"
 
-_SHIPPED_CONVERGE_MJS = (
-    _HOOK_DIRECTORY.parents[1] / ".agents" / "skills" / "autoconverge" / "workflow" / "converge.mjs"
+_ARCHIVED_CONVERGE_MJS = (
+    _HOOK_DIRECTORY.parents[3] / "skill-archive" / "autoconverge" / "workflow" / "converge.mjs"
 )
 
 
@@ -161,7 +161,7 @@ def test_skips_python_files() -> None:
     assert issues == []
 
 
-def test_shipped_converge_mjs_passes_its_own_check() -> None:
-    shipped_source = _SHIPPED_CONVERGE_MJS.read_text(encoding="utf-8")
-    issues = check_js_returns_object_schemaless_branch(shipped_source, _MJS_PATH)
+def test_archived_converge_regression_fixture_passes_the_check() -> None:
+    archived_source = _ARCHIVED_CONVERGE_MJS.read_text(encoding="utf-8")
+    issues = check_js_returns_object_schemaless_branch(archived_source, _MJS_PATH)
     assert issues == []

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -428,44 +428,30 @@ def test_context_survives_alongside_deny_reason(
     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)
+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, "Dispatcher must deny when any hook denies"
-
-    applicable_entries = _applicable_entries_for_tool(WRITE_TOOL_NAME)
+    assert dispatcher_is_deny
     all_expected_deny_reasons: list[str] = []
-    for each_entry in applicable_entries:
+    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, (
-        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."
+        "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, (
-            f"Missing deny reason in dispatcher output.\n"
-            f"Expected reason: {each_reason!r}\n"
-            f"Dispatcher reason: {dispatcher_reason!r}"
-        )
+        assert each_reason in dispatcher_reason
 
 
 def test_aggregate_exit_code_two_signals_deny() -> None:
@@ -686,18 +672,12 @@ 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",
-    )
+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:
@@ -712,8 +692,8 @@ def test_dispatcher_write_applies_both_groups() -> None:
     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)}"
+    assert len(all_write_entries) == 11, (
+        f"Write tool must apply to the 11 retained write hooks, got {len(all_write_entries)}"
     )
 
 
@@ -727,8 +707,8 @@ 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) == 20, (
-        f"expected 20 Edit entries, got {len(all_edit_entries)}"
+    assert len(all_edit_entries) == 13, (
+        f"expected 13 retained Edit entries, got {len(all_edit_entries)}"
     )
 
 
@@ -751,7 +731,7 @@ def test_dispatcher_multi_edit_reaches_the_sensitive_protector() -> None:
 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
+    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)
@@ -885,45 +865,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 +961,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"]
 
@@ -1115,60 +1063,47 @@ def test_dispatcher_denies_apply_patch_add_onto_an_existing_path(tmp_path: Path)
 
 
 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 = {
+    "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 = {
+    "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",
+}
+
+def test_hosted_hook_set_retains_boundaries_and_excludes_replaced_file_checks() -> None:
+    """Keep unresolved controls and exclude the seven staged-linter replacements."""
+    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_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/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):