claude-dev-env 2.28.0 → 2.28.1

package/hooks/blocking/test_hedging_language_blocker.py

@@ -1,261 +0,0 @@
-"""Tests for hedging_language_blocker hook response shape."""
-
-import importlib.util
-import io
-import json
-import os
-import subprocess
-import sys
-import tempfile
-
-import pytest
-
-HOOK_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "hedging_language_blocker.py")
-_HOOKS_DIR = os.path.dirname(HOOK_SCRIPT_PATH)
-_HOOKS_ROOT = os.path.join(_HOOKS_DIR, "..")
-_HOOK_CONFIG_DIR = os.path.join(_HOOKS_ROOT, "hooks_constants")
-if _HOOKS_DIR not in sys.path:
-    sys.path.insert(0, _HOOKS_DIR)
-if _HOOKS_ROOT not in sys.path:
-    sys.path.insert(0, _HOOKS_ROOT)
-import hedging_language_blocker
-from hooks_constants.messages import USER_FACING_NOTICE
-from hooks_constants.text_stripping import strip_code_and_quotes
-
-
-def test_blocker_uses_shared_strip_code_and_quotes() -> None:
-    assert hedging_language_blocker.strip_code_and_quotes is strip_code_and_quotes
-
-
-RESEARCH_MODE_SKILL_BODY_MARKER = "Three anti-hallucination constraints are ALWAYS active."
-HEDGING_MESSAGE = "This is likely correct."
-CLEAN_MESSAGE = "This is verified by the source document."
-EMPTY_MESSAGE = ""
-
-
-def run_hook_with_message(
-    assistant_message: str, *, is_prose_style_enabled: bool = True
-) -> subprocess.CompletedProcess:
-    hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
-    environment_by_key = os.environ.copy()
-    if is_prose_style_enabled:
-        environment_by_key["CLAUDE_PROSE_STYLE_ENFORCEMENT"] = "1"
-    else:
-        environment_by_key.pop("CLAUDE_PROSE_STYLE_ENFORCEMENT", None)
-    return subprocess.run(
-        [sys.executable, HOOK_SCRIPT_PATH],
-        input=hook_input_payload,
-        capture_output=True,
-        text=True,
-        check=False,
-        env=environment_by_key,
-    )
-
-
-def run_hook_with_patched_search_paths(
-    assistant_message: str,
-    search_paths: list[str],
-) -> subprocess.CompletedProcess:
-    """Run the hook with RESEARCH_MODE_SKILL_SEARCH_PATHS overridden via a wrapper script."""
-    wrapper_script = (
-        "import sys, json, os\n"
-        f"sys.path.insert(0, {repr(os.path.dirname(HOOK_SCRIPT_PATH))})\n"
-        "import hedging_language_blocker as blocker\n"
-        f"blocker.RESEARCH_MODE_SKILL_SEARCH_PATHS = {repr(search_paths)}\n"
-        "blocker.main()\n"
-    )
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as wrapper_file:
-        wrapper_file.write(wrapper_script)
-        wrapper_file_path = wrapper_file.name
-
-    hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
-    environment_by_key = os.environ.copy()
-    environment_by_key["CLAUDE_PROSE_STYLE_ENFORCEMENT"] = "1"
-    try:
-        completed_process = subprocess.run(
-            [sys.executable, wrapper_file_path],
-            input=hook_input_payload,
-            capture_output=True,
-            text=True,
-            check=False,
-            env=environment_by_key,
-        )
-    finally:
-        os.unlink(wrapper_file_path)
-    return completed_process
-
-
-def test_user_facing_notice_matches_config_messages_module():
-    config_messages_path = os.path.join(_HOOK_CONFIG_DIR, "messages.py")
-    specification = importlib.util.spec_from_file_location("messages", config_messages_path)
-    module = importlib.util.module_from_spec(specification)
-    specification.loader.exec_module(module)
-
-    assert module.USER_FACING_NOTICE == USER_FACING_NOTICE
-
-
-def test_hedging_scan_is_default_off() -> None:
-    completed_process = run_hook_with_message(
-        HEDGING_MESSAGE, is_prose_style_enabled=False
-    )
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_default_off_emits_privacy_safe_advisory_candidates(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    all_emitted: list[tuple[str, str, str]] = []
-
-    def _record_advisory(
-        matcher_id: str, surface: str, context_text: str, **_kwargs: object
-    ) -> dict[str, object]:
-        all_emitted.append((matcher_id, surface, context_text))
-        return {}
-
-    monkeypatch.setattr(
-        hedging_language_blocker, "emit_advisory_candidate", _record_advisory
-    )
-    monkeypatch.setattr(
-        hedging_language_blocker,
-        "prose_style_enforcement_enabled_in_environment",
-        lambda: False,
-    )
-    monkeypatch.setattr(
-        hedging_language_blocker.sys,
-        "stdin",
-        io.StringIO(json.dumps({"last_assistant_message": HEDGING_MESSAGE})),
-    )
-    with pytest.raises(SystemExit) as exit_info:
-        hedging_language_blocker.main()
-    assert exit_info.value.code == 0
-    assert all_emitted
-    matcher_id, surface, context_text = all_emitted[0]
-    assert matcher_id == "hedging_word"
-    assert surface == "Stop"
-    assert "likely" in context_text
-
-
-def test_hedging_message_emits_block_with_short_user_notice():
-    completed_process = run_hook_with_message(HEDGING_MESSAGE)
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-
-    assert parsed_response["decision"] == "block"
-    assert parsed_response["systemMessage"] == USER_FACING_NOTICE
-    assert parsed_response["suppressOutput"] is True
-    assert "likely" in parsed_response["reason"]
-
-
-def test_hedging_reason_contains_not_installed_notice_when_skill_absent():
-    completed_process = run_hook_with_patched_search_paths(
-        HEDGING_MESSAGE,
-        ["/nonexistent/path/one/SKILL.md", "/nonexistent/path/two/SKILL.md"],
-    )
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-
-    assert parsed_response["decision"] == "block"
-    assert "no research-mode skill installed" in parsed_response["reason"]
-    assert "verify with sources or prompt the user via AskUserQuestion" in parsed_response["reason"]
-    assert "SKILL.md" not in parsed_response["reason"]
-    assert RESEARCH_MODE_SKILL_BODY_MARKER not in parsed_response["reason"]
-
-
-def test_hedging_reason_contains_skill_path_when_skill_present():
-    with tempfile.TemporaryDirectory() as skill_dir:
-        skill_file_path = os.path.join(skill_dir, "SKILL.md")
-        with open(skill_file_path, "w") as skill_file:
-            skill_file.write("# Research Mode Skill\n")
-
-        completed_process = run_hook_with_patched_search_paths(
-            HEDGING_MESSAGE,
-            ["/nonexistent/path/SKILL.md", skill_file_path],
-        )
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-
-    assert parsed_response["decision"] == "block"
-    assert "SKILL.md" in parsed_response["reason"]
-    assert "no research-mode skill installed" not in parsed_response["reason"]
-    assert RESEARCH_MODE_SKILL_BODY_MARKER not in parsed_response["reason"]
-
-
-def test_clean_message_passes_through_with_no_output():
-    completed_process = run_hook_with_message(CLEAN_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_empty_message_passes_through_with_no_output():
-    completed_process = run_hook_with_message(EMPTY_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_explicit_unverified_label_in_same_sentence_passes() -> None:
-    completed_process = run_hook_with_message(
-        "This claim is unverified; the deploy is probably blocked."
-    )
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_i_dont_know_label_in_same_sentence_passes() -> None:
-    completed_process = run_hook_with_message(
-        "I don't know whether the port is probably open."
-    )
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_supported_probability_without_hedge_word_passes() -> None:
-    completed_process = run_hook_with_message(
-        "The suite reports 0.92 precision on the labeled fixture set in "
-        "test_prose_matcher_advisory.py."
-    )
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_label_in_one_sentence_does_not_exempt_bare_hedge_in_another() -> None:
-    completed_process = run_hook_with_message(
-        "This claim is unverified. The deploy is probably blocked."
-    )
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-    assert "probably" in parsed_response["reason"]
-    assert "explicit uncertainty label" in parsed_response["reason"]
-
-
-def test_bare_probably_still_blocks_with_positive_corrective() -> None:
-    completed_process = run_hook_with_message("The deploy is probably blocked.")
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-    assert parsed_response["decision"] == "block"
-    assert "probably" in parsed_response["reason"]
-    assert "label that claim unverified" in parsed_response["reason"]
-    assert "AskUserQuestion" in parsed_response["reason"]
-
-
-def test_find_blocking_hedging_terms_is_sentence_scoped() -> None:
-    bare = hedging_language_blocker.find_blocking_hedging_terms(
-        "This claim is unverified. The deploy is probably blocked."
-    )
-    labeled = hedging_language_blocker.find_blocking_hedging_terms(
-        "This claim is unverified; the deploy is probably blocked."
-    )
-    assert bare == ["probably"]
-    assert labeled == []

package/hooks/blocking/test_intent_only_ending_blocker.py

@@ -1,209 +0,0 @@
-"""Tests for intent_only_ending_blocker hook response shape."""
-
-import importlib.util
-import json
-import os
-import subprocess
-import sys
-
-HOOK_SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "intent_only_ending_blocker.py")
-_HOOKS_DIR = os.path.dirname(HOOK_SCRIPT_PATH)
-_HOOKS_ROOT = os.path.join(_HOOKS_DIR, "..")
-_HOOK_CONFIG_DIR = os.path.join(_HOOKS_ROOT, "hooks_constants")
-if _HOOKS_DIR not in sys.path:
-    sys.path.insert(0, _HOOKS_DIR)
-if _HOOKS_ROOT not in sys.path:
-    sys.path.insert(0, _HOOKS_ROOT)
-import intent_only_ending_blocker
-from hooks_constants.messages import USER_FACING_INTENT_ENDING_NOTICE
-from hooks_constants.text_stripping import strip_code_and_quotes
-
-def test_blocker_uses_shared_strip_code_and_quotes() -> None:
-    assert intent_only_ending_blocker.strip_code_and_quotes is strip_code_and_quotes
-
-
-INTENT_ENDING_MESSAGE = "I'll now run the test suite and fix any failures that come up."
-NEXT_STEPS_MESSAGE = "Next steps:"
-COMPLETED_WORK_MESSAGE = "Done - all tests pass. The fix is in place."
-BENIGN_PAST_TENSE_MESSAGE = "I implemented the parser and verified it against the fixtures."
-CLEAN_MESSAGE = "The function returns the parsed payload to its caller."
-COMMITMENT_PHRASING_MESSAGE = "I'll commit to keeping the API stable across the next release."
-NAMING_COMMITMENT_MESSAGE = "Let me commit to a clear naming convention for these helpers."
-GIT_COMMIT_INTENT_MESSAGE = "I'll commit the changes once the tests pass."
-DEFERRED_TO_USER_CI_RUNS_MESSAGE = (
-    "Let me know if this looks right. The CI will run automatically on push."
-)
-DEFERRED_TO_USER_EITHER_WAY_MESSAGE = (
-    "Let me know which option you want. I can check either way."
-)
-USER_DIRECTED_NEXT_STEPS_MESSAGE = (
-    "All done. The PR is merged.\n\nNext steps: you should deploy when ready."
-)
-EMPTY_MESSAGE = ""
-
-
-def run_hook_with_message(
-    assistant_message: str, *, is_prose_style_enabled: bool = True
-) -> subprocess.CompletedProcess:
-    hook_input_payload = json.dumps({"last_assistant_message": assistant_message})
-    environment_by_key = os.environ.copy()
-    if is_prose_style_enabled:
-        environment_by_key["CLAUDE_PROSE_STYLE_ENFORCEMENT"] = "1"
-    else:
-        environment_by_key.pop("CLAUDE_PROSE_STYLE_ENFORCEMENT", None)
-    return subprocess.run(
-        [sys.executable, HOOK_SCRIPT_PATH],
-        input=hook_input_payload,
-        capture_output=True,
-        text=True,
-        check=False,
-        env=environment_by_key,
-    )
-
-
-def run_hook_with_payload(
-    hook_input_payload: dict, *, is_prose_style_enabled: bool = True
-) -> subprocess.CompletedProcess:
-    environment_by_key = os.environ.copy()
-    if is_prose_style_enabled:
-        environment_by_key["CLAUDE_PROSE_STYLE_ENFORCEMENT"] = "1"
-    else:
-        environment_by_key.pop("CLAUDE_PROSE_STYLE_ENFORCEMENT", None)
-    return subprocess.run(
-        [sys.executable, HOOK_SCRIPT_PATH],
-        input=json.dumps(hook_input_payload),
-        capture_output=True,
-        text=True,
-        check=False,
-        env=environment_by_key,
-    )
-
-
-def test_user_facing_notice_matches_config_messages_module():
-    config_messages_path = os.path.join(_HOOK_CONFIG_DIR, "messages.py")
-    specification = importlib.util.spec_from_file_location("messages", config_messages_path)
-    module = importlib.util.module_from_spec(specification)
-    specification.loader.exec_module(module)
-
-    assert module.USER_FACING_INTENT_ENDING_NOTICE == USER_FACING_INTENT_ENDING_NOTICE
-    assert (
-        intent_only_ending_blocker.USER_FACING_INTENT_ENDING_NOTICE
-        == module.USER_FACING_INTENT_ENDING_NOTICE
-    )
-
-
-def test_intent_scan_is_default_off() -> None:
-    completed_process = run_hook_with_message(
-        INTENT_ENDING_MESSAGE, is_prose_style_enabled=False
-    )
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_intent_ending_message_emits_block_with_short_user_notice():
-    completed_process = run_hook_with_message(INTENT_ENDING_MESSAGE)
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-
-    assert parsed_response["decision"] == "block"
-    assert parsed_response["systemMessage"] == USER_FACING_INTENT_ENDING_NOTICE
-    assert parsed_response["suppressOutput"] is True
-    assert "long-horizon-autonomy" in parsed_response["reason"]
-    assert "This turn ends with a promise of future work." in parsed_response["reason"]
-    assert "Complete that work with tool calls during this turn." in parsed_response[
-        "reason"
-    ]
-
-
-def test_next_steps_lead_in_emits_block():
-    completed_process = run_hook_with_message(NEXT_STEPS_MESSAGE)
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-
-    assert parsed_response["decision"] == "block"
-    assert parsed_response["systemMessage"] == USER_FACING_INTENT_ENDING_NOTICE
-
-
-def test_completed_work_summary_passes_through_with_no_output():
-    completed_process = run_hook_with_message(COMPLETED_WORK_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_past_tense_summary_passes_through_with_no_output():
-    completed_process = run_hook_with_message(BENIGN_PAST_TENSE_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_commitment_phrasing_passes_through_with_no_output():
-    completed_process = run_hook_with_message(COMMITMENT_PHRASING_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_naming_commitment_passes_through_with_no_output():
-    completed_process = run_hook_with_message(NAMING_COMMITMENT_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_git_commit_intent_emits_block():
-    completed_process = run_hook_with_message(GIT_COMMIT_INTENT_MESSAGE)
-
-    assert completed_process.returncode == 0
-    parsed_response = json.loads(completed_process.stdout)
-
-    assert parsed_response["decision"] == "block"
-    assert parsed_response["systemMessage"] == USER_FACING_INTENT_ENDING_NOTICE
-
-
-def test_benign_opener_with_unrelated_work_verb_passes_through_with_no_output():
-    completed_process = run_hook_with_message(DEFERRED_TO_USER_CI_RUNS_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_deferral_to_user_with_later_verb_passes_through_with_no_output():
-    completed_process = run_hook_with_message(DEFERRED_TO_USER_EITHER_WAY_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_user_directed_next_steps_passes_through_with_no_output():
-    completed_process = run_hook_with_message(USER_DIRECTED_NEXT_STEPS_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_clean_message_passes_through_with_no_output():
-    completed_process = run_hook_with_message(CLEAN_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_empty_message_passes_through_with_no_output():
-    completed_process = run_hook_with_message(EMPTY_MESSAGE)
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""
-
-
-def test_stop_hook_active_short_circuits_with_no_output():
-    completed_process = run_hook_with_payload(
-        {"last_assistant_message": INTENT_ENDING_MESSAGE, "stop_hook_active": True}
-    )
-
-    assert completed_process.returncode == 0
-    assert completed_process.stdout == ""

package/hooks/hooks_constants/dead_argparse_argument_constants.py

@@ -1,28 +0,0 @@
-"""Constants for the dead argparse-argument detector in ``code_rules_enforcer``.
-
-Lives under the hooks-tree ``hooks_constants`` package so module-level
-UPPER_SNAKE constants satisfy the CODE_RULES "constants live in config"
-requirement and share a home with the other hook-tree configuration.
-"""
-
-ADD_ARGUMENT_METHOD_NAME: str = "add_argument"
-ALL_PARSE_METHOD_NAMES: frozenset[str] = frozenset({"parse_args", "parse_known_args"})
-DEST_KEYWORD_NAME: str = "dest"
-NAMESPACE_KEYWORD_NAME: str = "namespace"
-ACTION_KEYWORD_NAME: str = "action"
-ALL_SUPPRESSED_ACTION_NAMES: frozenset[str] = frozenset({"help", "version"})
-GETATTR_FUNCTION_NAME: str = "getattr"
-GETATTR_NAME_ARGUMENT_MINIMUM: int = 2
-ATTRGETTER_FUNCTION_NAME: str = "attrgetter"
-NAMESPACE_DICT_ATTRIBUTE_NAME: str = "__dict__"
-OPTION_PREFIX: str = "-"
-LONG_OPTION_PREFIX: str = "--"
-DEST_WORD_SEPARATOR: str = "-"
-DEST_WORD_JOINER: str = "_"
-EXPORTED_NAMES_ATTRIBUTE: str = "__all__"
-MAX_DEAD_ARGPARSE_ARGUMENT_ISSUES: int = 25
-DEAD_ARGPARSE_ARGUMENT_GUIDANCE: str = (
-    "optional CLI flag whose parsed value is never read in this file - remove the"
-    " add_argument call (argparse silently accepts an unused flag), or read the"
-    " parsed value where it is needed (CODE_RULES §9.8)"
-)

package/hooks/hooks_constants/dead_config_field_constants.py

@@ -1,39 +0,0 @@
-"""Constants for the dead config-dataclass field detector in ``code_rules_enforcer``.
-
-Lives under the hooks-tree ``hooks_constants`` package so module-level
-UPPER_SNAKE constants satisfy the CODE_RULES "constants live in config"
-requirement and share a home with the other hook-tree configuration.
-"""
-
-from hooks_constants.dead_dataclass_field_constants import (
-    ALL_REFLECTIVE_FIELD_CONSUMER_NAMES,
-    WHOLE_INSTANCE_DICT_ATTRIBUTE_NAME,
-)
-from hooks_constants.dead_module_constant_constants import (
-    CONFIG_DIRECTORY_SEGMENT,
-    DUNDER_INIT_FILENAME,
-    MAX_SCAN_ROOT_FILE_COUNT,
-    PYTHON_SOURCE_SUFFIX,
-)
-
-ALL_CONFIG_CLASS_NAME_SUFFIXES: tuple[str, ...] = ("Config", "Selectors")
-DATACLASSES_MODULE_NAME: str = "dataclasses"
-MAX_DEAD_CONFIG_FIELD_ISSUES: int = 25
-DEAD_CONFIG_FIELD_GUIDANCE: str = (
-    "config or selectors dataclass field is defined but read by no production"
-    " module in the enclosing package tree - remove the dead field, or read it"
-    " where the value is needed (CODE_RULES §9.8)"
-)
-
-__all__ = [
-    "ALL_CONFIG_CLASS_NAME_SUFFIXES",
-    "ALL_REFLECTIVE_FIELD_CONSUMER_NAMES",
-    "CONFIG_DIRECTORY_SEGMENT",
-    "DATACLASSES_MODULE_NAME",
-    "DEAD_CONFIG_FIELD_GUIDANCE",
-    "DUNDER_INIT_FILENAME",
-    "MAX_DEAD_CONFIG_FIELD_ISSUES",
-    "MAX_SCAN_ROOT_FILE_COUNT",
-    "PYTHON_SOURCE_SUFFIX",
-    "WHOLE_INSTANCE_DICT_ATTRIBUTE_NAME",
-]

package/hooks/hooks_constants/dead_dataclass_field_constants.py

@@ -1,25 +0,0 @@
-"""Constants for the dead dataclass-field detector in ``code_rules_enforcer``.
-
-Lives under the hooks-tree ``hooks_constants`` package so module-level
-UPPER_SNAKE constants satisfy the CODE_RULES "constants live in config"
-requirement and share a home with the other hook-tree configuration.
-"""
-
-ALL_DATACLASS_DECORATOR_NAMES: frozenset[str] = frozenset({"dataclass", "dataclasses"})
-ATTRGETTER_FUNCTION_NAME: str = "attrgetter"
-CLASSVAR_ANNOTATION_NAME: str = "ClassVar"
-GETATTR_FUNCTION_NAME: str = "getattr"
-GETATTR_NAME_ARGUMENT_MINIMUM: int = 2
-ALL_REFLECTIVE_FIELD_CONSUMER_NAMES: frozenset[str] = frozenset(
-    {"asdict", "astuple", "fields", "replace", "vars"}
-)
-WHOLE_INSTANCE_DICT_ATTRIBUTE_NAME: str = "__dict__"
-ALL_WHOLE_INSTANCE_STRINGIFY_NAMES: frozenset[str] = frozenset(
-    {"str", "repr", "format"}
-)
-MAX_DEAD_DATACLASS_FIELD_ISSUES: int = 25
-DEAD_DATACLASS_FIELD_GUIDANCE: str = (
-    "field is assigned but never read in this file - remove the field and the code"
-    " that only exists to populate it, or read it where the value is needed"
-    " (CODE_RULES §9.8)"
-)

package/hooks/hooks_constants/dead_module_constant_constants.py

@@ -1,30 +0,0 @@
-"""Constants for the dead module-level constant detector in ``code_rules_enforcer``.
-
-Lives under the hooks-tree ``hooks_constants`` package so module-level
-UPPER_SNAKE constants satisfy the CODE_RULES "constants live in config"
-requirement and share a home with the other hook-tree configuration.
-"""
-
-PYTHON_SOURCE_SUFFIX: str = ".py"
-DUNDER_INIT_FILENAME: str = "__init__.py"
-CONSTANTS_MODULE_SUFFIX: str = "_constants.py"
-CONFIG_DIRECTORY_SEGMENT: str = "config"
-DUNDER_ALL_NAME: str = "__all__"
-GIT_DIRECTORY_NAME: str = ".git"
-MINIMUM_UPPER_SNAKE_LENGTH: int = 2
-MAX_DEAD_MODULE_CONSTANT_ISSUES: int = 25
-MAX_SCAN_ROOT_FILE_COUNT: int = 2000
-MAX_SCAN_ROOT_READ_COUNT: int = 20000
-DEAD_MODULE_CONSTANT_GUIDANCE: str = (
-    "module-level constant is defined here but never imported or read by any"
-    " module in the enclosing package tree - remove the constant, or reference it"
-    " where its value is needed (CODE_RULES §9.8)"
-)
-DEAD_MODULE_CONSTANT_RETRY_GUIDANCE: str = (
-    "To land a constant a consumer will read, break the write-order deadlock by"
-    " writing the consumer that reads it first: that write completes even though a"
-    " transient mypy attr-defined advisory flags the not-yet-defined name (a"
-    " non-blocking post-write check), then re-issue this write, which passes once"
-    " the consumer is on disk. A constant no module ever reads stays flagged on"
-    " every attempt."
-)

package/hooks/hooks_constants/hedging_uncertainty_constants.py

@@ -1,42 +0,0 @@
-"""Explicit uncertainty labels that co-occur with hedge words in one sentence.
-
-::
-
-    ok:   This claim is unverified; the port is probably down.
-    flag: The port is probably down. (no label in that sentence)
-
-A response-wide "unverified" label does not exempt a bare hedge in another
-sentence. Classification of matcher precision (OP-07B) uses the same blocking
-surface: only hedges that survive this filter count toward hard-block evidence.
-"""
-
-from __future__ import annotations
-
-import re
-
-# Sentence ends at . ! ? when followed by space or end; keep the terminator
-# attached to the sentence so labels next to periods still match.
-SENTENCE_BOUNDARY_PATTERN = re.compile(r"(?<=[.!?])\s+")
-
-ALL_EXPLICIT_UNCERTAINTY_LABEL_PATTERNS = (
-    re.compile(r"\bunverified\b", re.IGNORECASE),
-    re.compile(r"\bi don't know\b", re.IGNORECASE),
-    re.compile(r"\bi do not know\b", re.IGNORECASE),
-    re.compile(r"\bno source for this claim\b", re.IGNORECASE),
-    re.compile(r"\bwithout a (credible )?source\b", re.IGNORECASE),
-    re.compile(r"\bnamed (as )?unverified\b", re.IGNORECASE),
-)
-
-HEDGING_TERM_LIST_SEPARATOR = ", "
-
-POSITIVE_CORRECTIVE_GUIDANCE = (
-    "State the claim with evidence that backs it, or label that claim unverified "
-    "in the same sentence as the uncertainty word. "
-    "Gather a source, run a live probe, or ask the user through AskUserQuestion — "
-    "then re-output the complete revised response."
-)
-
-BLOCK_REASON_PREFIX = (
-    "ANTI-HALLUCINATION GUARDRAIL: Your response contains hedging language without "
-    "an explicit uncertainty label in the same sentence: "
-)

package/hooks/hooks_constants/test_dispatcher_constants_docstrings.py

@@ -1,44 +0,0 @@
-"""Regression tests proving the dispatcher constants docstrings clear the O6 gate.
-
-The PreToolUse and PostToolUse dispatcher constants modules each carry a module
-docstring stating what the module centralizes. Neither docstring may assert that
-no literals appear inline in its companion dispatcher script — that completeness
-claim about a sibling file is the deterministic Category O6 drift the enforcer's
-check_docstring_no_inline_literal_claim blocks. These tests load the real
-modules' source and assert the check returns no issues for either.
-"""
-
-from __future__ import annotations
-
-import importlib.util
-from pathlib import Path
-from types import ModuleType
-
-
-def _load_enforcer_module() -> ModuleType:
-    enforcer_path = Path(__file__).resolve().parent.parent / "blocking" / "code_rules_enforcer.py"
-    enforcer_spec = importlib.util.spec_from_file_location("code_rules_enforcer", enforcer_path)
-    assert enforcer_spec is not None
-    assert enforcer_spec.loader is not None
-    enforcer_module = importlib.util.module_from_spec(enforcer_spec)
-    enforcer_spec.loader.exec_module(enforcer_module)
-    return enforcer_module
-
-
-code_rules_enforcer = _load_enforcer_module()
-
-
-def _check_issues_for(module_filename: str) -> list[str]:
-    module_path = Path(__file__).resolve().parent / module_filename
-    module_source = module_path.read_text(encoding="utf-8")
-    return code_rules_enforcer.check_docstring_no_inline_literal_claim(
-        module_source, str(module_path)
-    )
-
-
-def test_pre_tool_use_dispatcher_constants_docstring_clears_o6_gate() -> None:
-    assert _check_issues_for("pre_tool_use_dispatcher_constants.py") == []
-
-
-def test_post_tool_use_dispatcher_constants_docstring_clears_o6_gate() -> None:
-    assert _check_issues_for("post_tool_use_dispatcher_constants.py") == []