claude-dev-env 1.77.0 → 1.79.0

package/hooks/blocking/test_code_rules_enforcer_vacuous_cleanup_assertion.py

@@ -0,0 +1,132 @@
+"""Tests for vacuous cleanup-on-failure assertion detection.
+
+A cleanup-on-failure test that asserts no leftover temp file is left behind,
+yet never proves the temp file was created, passes vacuously: the assertion
+holds even when the on-failure cleanup is entirely broken. The gate flags that
+shape so the author arranges a post-creation failure and asserts real removal.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code_rules_enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+TEST_FILE_PATH = "packages/app/tests/test_archive_rewrite.py"
+PRODUCTION_FILE_PATH = "packages/app/services/archive_rewrite.py"
+
+
+def test_should_flag_glob_emptiness_cleanup_test_without_temp_creation() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_failure(tmp_path: Path) -> None:\n"
+        "    stp_path = build_corrupt_stp(stp_path=tmp_path / 'corrupt.stp')\n"
+        "    rewrite_properties_xml_atomically(stp_path=stp_path, patched='<x/>')\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert any("vacuous" in issue.lower() for issue in issues), (
+        f"Expected a vacuous-cleanup issue, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_post_creation_failure_is_arranged() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_replace_failure(tmp_path, monkeypatch)"
+        " -> None:\n"
+        "    stp_path = build_valid_stp(stp_path=tmp_path / 'theme.stp')\n"
+        "    monkeypatch.setattr(os, 'replace', _raise_oserror)\n"
+        "    rewrite_properties_xml_atomically(stp_path=stp_path, patched='<x/>')\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue when failure is arranged, got: {issues}"
+
+
+def test_should_not_flag_when_temp_existence_is_proven_first() -> None:
+    source = (
+        "def test_cleanup_removes_temp_on_failure(tmp_path: Path) -> None:\n"
+        "    temporary_path = tmp_path / 'theme.stp.tmp'\n"
+        "    temporary_path.write_bytes(b'partial')\n"
+        "    assert temporary_path.exists()\n"
+        "    run_cleanup_after_failure(temporary_path)\n"
+        "    assert not list(tmp_path.glob('*.tmp'))\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue when temp existence proven, got: {issues}"
+
+
+def test_should_not_flag_success_named_cleanup_assertion() -> None:
+    source = (
+        "def test_rewrite_leaves_no_tmp_sibling_on_success(tmp_path: Path) -> None:\n"
+        "    stp_path = build_valid_stp(stp_path=tmp_path / 'theme.stp')\n"
+        "    rewrite_properties_xml_atomically(stp_path=stp_path, patched='<x/>')\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue for a success-named test, got: {issues}"
+
+
+def test_should_not_flag_failure_test_asserting_real_behavior() -> None:
+    source = (
+        "def test_rewrite_reports_cleanup_failure_on_directory_tmp("
+        "tmp_path: Path) -> None:\n"
+        "    temporary_path = tmp_path / 'theme.stp.tmp'\n"
+        "    temporary_path.mkdir()\n"
+        "    write_outcome = rewrite_properties_xml_atomically("
+        "stp_path=tmp_path / 't.stp', patched='<x/>')\n"
+        "    assert write_outcome.temporary_cleanup_error_message is not None\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue for a behavior assertion, got: {issues}"
+
+
+def test_should_not_flag_mixed_assertion_cleanup_test() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_and_reports_failure(tmp_path: Path) -> None:\n"
+        "    stp_path = build_corrupt_stp(stp_path=tmp_path / 'corrupt.stp')\n"
+        "    write_outcome = rewrite_properties_xml_atomically("
+        "stp_path=stp_path, patched='<x/>')\n"
+        "    assert write_outcome.is_write_successful is False\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issue for a mixed-assertion test, got: {issues}"
+
+
+def test_should_not_flag_in_production_files() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_failure(tmp_path: Path) -> None:\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert len(all_tmp_siblings) == 0\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Expected no issue in a production file, got: {issues}"
+
+
+def test_should_include_line_number_in_issue() -> None:
+    source = (
+        "def test_rewrite_removes_tmp_file_on_failure(tmp_path: Path) -> None:\n"
+        "    all_tmp_siblings = list(tmp_path.glob('*.tmp'))\n"
+        "    assert all_tmp_siblings == []\n"
+    )
+    issues = code_rules_enforcer.check_vacuous_cleanup_assertion_tests(source, TEST_FILE_PATH)
+    assert any("Line 1" in issue for issue in issues), (
+        f"Expected a line number in the issue, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_whitespace_indentation_magic.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location("code_rules_enforcer", ENFORCER_PATH)
+assert specification is not None and specification.loader is not None
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+PRODUCTION_PATH = "C:/project/pkg/menu_info_colors.py"
+
+
+def _check(source: str) -> list[str]:
+    return code_rules_enforcer.check_whitespace_indentation_magic(source, PRODUCTION_PATH)
+
+
+def test_flags_twelve_space_indent_constant() -> None:
+    source = 'def fallback_indent() -> str:\n    return "            "\n'
+    issues = _check(source)
+    assert len(issues) == 1
+    assert "Line 2" in issues[0]
+
+
+def test_flags_indent_fragment_inside_fstring() -> None:
+    source = 'def build(value: str) -> str:\n    return value + f"\\n            {value}"\n'
+    issues = _check(source)
+    assert len(issues) == 1
+    assert "Line 2" in issues[0]
+
+
+def test_flags_tab_indent_constant() -> None:
+    source = 'def tabbed() -> str:\n    return "\\t\\t"\n'
+    assert len(_check(source)) == 1
+
+
+def test_does_not_flag_single_tab_delimiter() -> None:
+    source = 'def split_columns(text: str) -> list[str]:\n    return text.split("\\t")\n'
+    assert _check(source) == []
+
+
+def test_does_not_flag_single_tab_join_delimiter() -> None:
+    source = 'def join_rows(rows: list[str]) -> str:\n    return "\\t".join(rows)\n'
+    assert _check(source) == []
+
+
+def test_does_not_flag_single_space() -> None:
+    source = 'def join_words(left: str, right: str) -> str:\n    return left + " " + right\n'
+    assert _check(source) == []
+
+
+def test_does_not_flag_newline_only_fragment() -> None:
+    source = 'def build(value: str) -> str:\n    return f"\\n{value}"\n'
+    assert _check(source) == []
+
+
+def test_does_not_flag_docstring_with_spaced_words() -> None:
+    source = (
+        "def documented() -> str:\n"
+        '    """A docstring with    spaced    words."""\n'
+        '    return documented.__doc__ or ""\n'
+    )
+    assert _check(source) == []
+
+
+def test_does_not_flag_in_config_file() -> None:
+    source = 'def fallback_indent() -> str:\n    return "            "\n'
+    assert (
+        code_rules_enforcer.check_whitespace_indentation_magic(
+            source, "C:/project/pkg/config/indents.py"
+        )
+        == []
+    )

package/hooks/blocking/test_convergence_gate_blocker.py

@@ -1,9 +1,14 @@
 """Unit tests for convergence-gate-blocker PreToolUse hook."""
 
 import importlib.util
+import io
+import json
 import pathlib
+import subprocess
 import sys
 
+import pytest
+
 _HOOK_DIR = pathlib.Path(__file__).parent
 if str(_HOOK_DIR) not in sys.path:
     sys.path.insert(0, str(_HOOK_DIR))
@@ -61,3 +66,69 @@ def test_returns_none_when_no_number_and_no_repo() -> None:
 
 def test_matches_gh_pr_ready_in_compound_command() -> None:
     assert not _GH_PR_READY_PATTERN.search("gh pr ready --undo && gh pr create")
+
+
+def test_run_convergence_check_forwards_cwd_to_subprocess(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured_cwd: list[object] = []
+
+    def fake_run(*_run_args: object, **run_keywords: object) -> subprocess.CompletedProcess[str]:
+        captured_cwd.append(run_keywords.get("cwd"))
+        return subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(hook_module.subprocess, "run", fake_run)
+    hook_module._run_convergence_check(
+        "check_convergence.py", "owner", "repo", 783, "C:/worktrees/pr-783"
+    )
+    assert captured_cwd == ["C:/worktrees/pr-783"]
+
+
+def test_run_convergence_check_forwards_none_cwd_as_none(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured_cwd: list[object] = []
+
+    def fake_run(*_run_args: object, **run_keywords: object) -> subprocess.CompletedProcess[str]:
+        captured_cwd.append(run_keywords.get("cwd"))
+        return subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(hook_module.subprocess, "run", fake_run)
+    hook_module._run_convergence_check("check_convergence.py", "owner", "repo", 783, None)
+    assert captured_cwd == [None]
+
+
+def test_main_reads_cwd_from_top_level_payload(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: pathlib.Path
+) -> None:
+    convergence_script = (
+        tmp_path / ".claude" / "skills" / "pr-converge" / "scripts" / "check_convergence.py"
+    )
+    convergence_script.parent.mkdir(parents=True)
+    convergence_script.write_text("")
+    monkeypatch.setattr(hook_module.Path, "home", classmethod(lambda _cls: tmp_path))
+
+    worktree_path = str(tmp_path / "worktrees" / "pr-783")
+    monkeypatch.setattr(hook_module, "_resolve_owner_repo", lambda _cwd: ("jl-cmd", "repo"))
+
+    captured_cwd: list[object] = []
+
+    def fake_check(
+        _script: str, _owner: str, _repo: str, _pr_number: int, cwd: str | None
+    ) -> subprocess.CompletedProcess[str]:
+        captured_cwd.append(cwd)
+        return subprocess.CompletedProcess(args=[], returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(hook_module, "_run_convergence_check", fake_check)
+
+    payload = {
+        "tool_name": "Bash",
+        "cwd": worktree_path,
+        "tool_input": {"command": "gh pr ready 783", "cwd": "C:/wrong/session/dir"},
+    }
+    monkeypatch.setattr(sys, "stdin", io.StringIO(json.dumps(payload)))
+
+    with pytest.raises(SystemExit):
+        hook_module.main()
+
+    assert captured_cwd == [worktree_path]

package/hooks/blocking/test_env_var_table_code_drift_blocker.py

@@ -0,0 +1,94 @@
+"""Tests for the env-var-table code-drift blocker.
+
+Each test builds a real on-disk directory holding a code file and a markdown
+doc, then drives the blocker's detection function against that tree. The drift
+the blocker catches: a markdown env-var summary table row attributes an
+environment variable to a code file whose source never references that variable.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+_blocking_dir = str(Path(__file__).resolve().parent)
+if _blocking_dir not in sys.path:
+    sys.path.insert(0, _blocking_dir)
+
+from env_var_table_code_drift_blocker import (  # noqa: E402
+    find_drift_rows,
+    is_markdown_file,
+)
+
+
+def _write(file_path: Path, content: str) -> None:
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    file_path.write_text(content, encoding="utf-8")
+
+
+def _anchor_repo_root(repo_root: Path) -> None:
+    (repo_root / ".git").mkdir(parents=True, exist_ok=True)
+
+
+def test_is_markdown_file_accepts_md_and_rejects_python() -> None:
+    assert is_markdown_file("docs/configuration.md") is True
+    assert is_markdown_file("auth/google_auth.py") is False
+
+
+def test_flags_variable_absent_from_named_code_file(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    _write(tmp_path / "auth" / "google_auth.py", "def load():\n    return read_bws_secret()\n")
+    doc_path = tmp_path / "docs" / "configuration.md"
+    content = (
+        "## Summary: Environment Variables\n\n"
+        "| Variable | Used By | Purpose |\n"
+        "|----------|---------|---------|\n"
+        "| `GOOGLE_APPLICATION_CREDENTIALS` | `auth/google_auth.py` | Path to JSON |\n"
+    )
+    drift_rows = find_drift_rows(content, doc_path.parent)
+    assert drift_rows == ["GOOGLE_APPLICATION_CREDENTIALS -> auth/google_auth.py"]
+
+
+def test_passes_when_variable_present_in_code_file(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    _write(
+        tmp_path / "automation_logging" / "__init__.py",
+        'topic = os.environ["NTFY_TOPIC"]\n',
+    )
+    doc_path = tmp_path / "docs" / "configuration.md"
+    content = (
+        "| Variable | Used By | Purpose |\n"
+        "|----------|---------|---------|\n"
+        "| `NTFY_TOPIC` | `automation_logging/__init__.py` | ntfy topic |\n"
+    )
+    assert find_drift_rows(content, doc_path.parent) == []
+
+
+def test_skips_row_whose_code_file_is_absent(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    doc_path = tmp_path / "docs" / "configuration.md"
+    content = (
+        "| Variable | Used By | Purpose |\n"
+        "|----------|---------|---------|\n"
+        "| `MISSING_VAR` | `nowhere/ghost.py` | unresolved |\n"
+    )
+    assert find_drift_rows(content, doc_path.parent) == []
+
+
+def test_ignores_rows_inside_a_fenced_code_block(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    _write(tmp_path / "auth" / "google_auth.py", "no variable here\n")
+    doc_path = tmp_path / "docs" / "configuration.md"
+    content = "```\n| `GOOGLE_APPLICATION_CREDENTIALS` | `auth/google_auth.py` | sample |\n```\n"
+    assert find_drift_rows(content, doc_path.parent) == []
+
+
+def test_ignores_row_whose_second_cell_is_not_a_code_file(tmp_path: Path) -> None:
+    _anchor_repo_root(tmp_path)
+    doc_path = tmp_path / "docs" / "configuration.md"
+    content = (
+        "| Variable | Purpose | Default |\n"
+        "|----------|---------|---------|\n"
+        "| `SOME_FLAG` | `enables the thing` | off |\n"
+    )
+    assert find_drift_rows(content, doc_path.parent) == []

package/hooks/blocking/test_package_inventory_stale_blocker.py

@@ -311,6 +311,52 @@ def test_is_inventoried_production_file_accepts_production_file(tmp_path: Path):
     assert is_inventoried_production_file(str(production_file_path)) is True
 
 
+SKILL_MD_SCRIPTS_LAYOUT = (
+    "# base-theme-match\n\n"
+    "## Layout\n\n"
+    "| Path | Role |\n"
+    "|---|---|\n"
+    "| `scripts/discover_candidates.py` | Discovers candidates. |\n"
+    "| `scripts/resolve_stp.py` | Resolves the STP filename. |\n"
+    "| `scripts/select_stp.py` | Selects the STP filename. |\n"
+)
+
+
+def _skill_scripts_directory(tmp_path: Path) -> Path:
+    """Return a skill package's scripts/ directory under a SKILL.md Layout table."""
+    skill_directory = tmp_path / "base-theme-match"
+    skill_directory.mkdir()
+    (skill_directory / "SKILL.md").write_text(SKILL_MD_SCRIPTS_LAYOUT, encoding="utf-8")
+    scripts_directory = skill_directory / "scripts"
+    scripts_directory.mkdir()
+    _write_sibling_files(scripts_directory, ["discover_candidates.py", "resolve_stp.py"])
+    return scripts_directory
+
+
+def test_blocks_new_script_absent_from_parent_skill_layout(tmp_path: Path):
+    scripts_directory = _skill_scripts_directory(tmp_path)
+    new_file_path = scripts_directory / "stp_selection.py"
+    result = _run_hook(
+        "Write",
+        {"file_path": str(new_file_path), "content": "x = 1\n"},
+    )
+    assert result.returncode == 0
+    payload = json.loads(result.stdout)
+    assert payload["hookSpecificOutput"]["permissionDecision"] == "deny"
+    assert "stp_selection.py" in payload["hookSpecificOutput"]["permissionDecisionReason"]
+
+
+def test_allows_new_script_named_in_parent_skill_layout(tmp_path: Path):
+    scripts_directory = _skill_scripts_directory(tmp_path)
+    new_file_path = scripts_directory / "select_stp.py"
+    result = _run_hook(
+        "Write",
+        {"file_path": str(new_file_path), "content": "x = 1\n"},
+    )
+    assert result.returncode == 0
+    assert result.stdout.strip() == ""
+
+
 def test_find_stale_inventory_returns_survey_for_omission(tmp_path: Path):
     package_directory = _package_directory_with_readme(tmp_path, README_LISTING_TWO_FILES)
     _write_sibling_files(package_directory, ["dialer_compose.py", "compose_dialer_cli.py"])

package/hooks/blocking/test_pre_tool_use_dispatcher.py

@@ -632,24 +632,24 @@ def test_dispatcher_write_applies_both_groups() -> None:
     assert "blocking/plain_language_blocker.py" in all_write_script_paths, (
         "plain_language_blocker (Group B) 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) == 19, (
+        f"Write tool must apply to all 19 hosted hooks, got {len(all_write_entries)}"
     )
 
 
 def test_dispatcher_edit_applies_both_groups() -> None:
     """Edit tool triggers both Group A and Group B hooks through the dispatcher."""
     all_edit_entries = _applicable_entries_for_tool(EDIT_TOOL_NAME)
-    assert len(all_edit_entries) == 18, (
-        f"Edit tool must apply to all 18 hosted hooks, got {len(all_edit_entries)}"
+    assert len(all_edit_entries) == 19, (
+        f"Edit tool must apply to all 19 hosted hooks, got {len(all_edit_entries)}"
     )
 
 
 def test_dispatcher_multi_edit_applies_only_group_b() -> None:
-    """MultiEdit tool triggers only Group B (7 hooks), not Group A."""
+    """MultiEdit tool triggers only Group B (8 hooks), not Group A."""
     all_multi_edit_entries = _applicable_entries_for_tool(MULTI_EDIT_TOOL_NAME)
-    assert len(all_multi_edit_entries) == 7, (
-        f"MultiEdit tool must apply to exactly 7 Group-B hooks, got {len(all_multi_edit_entries)}"
+    assert len(all_multi_edit_entries) == 8, (
+        f"MultiEdit tool must apply to exactly 8 Group-B hooks, got {len(all_multi_edit_entries)}"
     )
 
 

package/hooks/hooks_constants/CLAUDE.md

@@ -13,6 +13,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `bot_mention_comment_blocker_constants.py` | Patterns for detecting bot @-mentions in PR comments |
 | `claude_md_orphan_file_blocker_constants.py` | Table patterns, file extensions, scan budget, and block-message text for the CLAUDE.md orphan-file blocker |
 | `code_rules_enforcer_constants.py` | File-extension sets, test-path patterns, advisory line thresholds, boolean-name prefixes |
+| `env_var_table_code_drift_constants.py` | Table patterns, env-var-name and code-file recognizers, scan budget, and block-message text for the env-var-table code-drift blocker |
 | `code_rules_path_utils_constants.py` | Path-matching helpers used by the code-rules check modules |
 | `code_verifier_spawn_preflight_gate_constants.py` | Subagent type, merge-tree command flags, timeouts, and deny-message text for the code-verifier spawn pre-flight gate |
 | `convergence_branch_constants.py` | Branch and worktree naming patterns for the convergence gate |
@@ -39,6 +40,7 @@ Shared constant modules imported by hooks throughout the `hooks/` tree. Each fil
 | `open_questions_in_plans_blocker_constants.py` | Patterns for detecting unresolved open questions in plan documents |
 | `orphan_css_class_constants.py` | Scan radius and selector patterns for the orphan-CSS-class check |
 | `package_inventory_stale_blocker_constants.py` | Inventory document names, production code extensions, backtick token pattern, smallest inventory size, exempt names, scan budget, and block-message text for the package-inventory stale-entry blocker |
+| `paired_test_coverage_constants.py` | Test-directory name, stem-test filename affixes, test-file globs, exempt public-function names, scan budget, coverage threshold, and guidance text for the public-function paired-test coverage check |
 | `path_rewriter_constants.py` | Path rewriting patterns for the Everything-search path rewriter |
 | `plain_language_blocker_constants.py` | The list of heavy words and their everyday replacements |
 | `pr_converge_bugteam_enforcer_constants.py` | State keys and timing config for the bugteam-parallel enforcer |

package/hooks/hooks_constants/blocking_check_limits.py

@@ -51,18 +51,73 @@ MAX_DOCSTRING_FALLBACK_BRANCH_ISSUES: int = 3
 DOCSTRING_FALLBACK_BRANCH_MINIMUM_ROUTE_COUNT: int = 2
 MAX_DOCSTRING_NO_CONSUMER_CLAIM_ISSUES: int = 3
 MAX_DOCSTRING_UNGUARDED_PAYLOAD_CLAIM_ISSUES: int = 3
+MAX_DOCSTRING_NO_NETWORK_CLAIM_ISSUES: int = 3
 MAX_STALE_TEST_NAME_TARGET_ISSUES: int = 3
 STALE_TEST_NAME_MINIMUM_SHARED_TOKEN_COUNT: int = 2
 MAX_MODULE_DOCSTRING_CHECK_ROSTER_ISSUES: int = 5
 MINIMUM_PUBLIC_CHECKS_FOR_MODULE_DOCSTRING_ROSTER: int = 2
 MAX_DOCSTRING_TUPLE_ENUMERATION_ISSUES: int = 5
 MINIMUM_TUPLE_MEMBERS_FOR_DOCSTRING_ENUMERATION: int = 2
+MAX_DOCSTRING_MARK_GLYPH_ENUMERATION_ISSUES: int = 5
+MINIMUM_NAMED_MARKS_FOR_PROSE_ENUMERATION: int = 2
+MAX_COMPANION_MODULE_RESOLUTION_DEPTH: int = 6
+PYTHON_MODULE_FILE_SUFFIX: str = ".py"
+WORD_BOUNDARY_REGEX: str = r"\b"
+ALL_PUNCTUATION_MARK_GLYPH_PROSE_NAMES: dict[str, tuple[str, ...]] = {
+    "—": ("em-dash", "em dash"),
+    "–": ("en-dash", "en dash"),
+    "--": ("double-hyphen", "double hyphen", "spaced double-hyphen"),
+    ";": ("semicolon",),
+    ":": ("colon",),
+    ",": ("comma",),
+    "/": ("slash", "forward slash"),
+    "|": ("pipe", "vertical bar"),
+    "&": ("ampersand",),
+}
 MAX_DOCSTRING_STEP_DISPATCH_ISSUES: int = 5
 MINIMUM_NAMED_LINEAR_STEPS_FOR_DISPATCH_CHECK: int = 2
 MINIMUM_TOKENS_FOR_DISPATCH_CALLEE: int = 2
 MAX_DOCSTRING_UNDEFINED_CONSTANT_ISSUES: int = 3
 MAX_DOCSTRING_RETURNS_PLURAL_CARDINALITY_ISSUES: int = 5
 SINGLE_DICT_KEY_COUNT_FOR_PLURAL_CARDINALITY_DRIFT: int = 1
+MAX_LENGTH_CONSTANT_SUPERLATIVE_ISSUES: int = 3
+LENGTH_GATE_PACKAGE_SCAN_FILE_LIMIT: int = 400
+LENGTH_CONFIG_SUBDIRECTORY_NAME: str = "config"
+ALL_LENGTH_CONSTANT_NAME_SUFFIXES: tuple[str, ...] = ("_LENGTH", "_LEN")
+ALL_LENGTH_SUPERLATIVE_RANGE_PHRASES: tuple[str, ...] = (
+    "longest",
+    "maximum length",
+    "no longer than",
+)
+MAX_DOCSTRING_FIELD_RUNMODE_OUTCOME_ISSUES: int = 5
+ALL_DOCSTRING_RUNMODE_FLAG_FIELD_NAME_TOKENS: tuple[str, ...] = ("dry_run",)
+ALL_DOCSTRING_PER_RECORD_WRITE_OUTCOME_PHRASES: tuple[str, ...] = (
+    "was written",
+    "is written",
+    "were written",
+    "nothing was written",
+    "no file was written",
+    "wrote",
+    "written to disk",
+    "written to the file",
+)
+ALL_DOCSTRING_RUN_MODE_PHRASES: tuple[str, ...] = (
+    "dry run",
+    "dry-run",
+    "execute run",
+    "--execute",
+    "run mode",
+    "live run",
+    "not an execute",
+)
+MAX_DOCSTRING_RAISES_LARGEZIPFILE_ISSUES: int = 5
+DOCSTRING_LARGE_ZIP_FILE_EXCEPTION_NAME: str = "LargeZipFile"
+ZIPFILE_WRITER_CLASS_NAME: str = "ZipFile"
+ZIPFILE_MODE_KEYWORD: str = "mode"
+ZIPFILE_MODE_POSITIONAL_INDEX: int = 1
+ZIPFILE_ALLOW_ZIP64_KEYWORD: str = "allowZip64"
+ZIPFILE_ALLOW_ZIP64_POSITIONAL_INDEX: int = 3
+ALL_ZIPFILE_WRITE_MODE_VALUES: frozenset[str] = frozenset({"w", "a", "x"})
 MAX_DOCSTRING_ARGS_SPAN_SCOPE_ISSUES: int = 3
 ALL_DOCSTRING_SINGLE_LINE_SCOPE_PHRASES: tuple[str, ...] = (
     "anchor line is among the changed lines",
@@ -163,6 +218,26 @@ ALL_DOCSTRING_GUARDED_FAILURE_CLAIM_PHRASES: tuple[str, ...] = (
     "malformed payload yields none",
 )
 
+ALL_DOCSTRING_NO_NETWORK_CLAIM_PHRASES: tuple[str, ...] = (
+    "without touching the network",
+    "without touching the share",
+    "without touching the network share",
+    "without hitting the network",
+    "without hitting the share",
+    "without a network call",
+    "without any network call",
+    "without network access",
+    "without a network round-trip",
+    "without a network round trip",
+    "no network access",
+    "no network round-trip",
+    "no network round trip",
+)
+
+ALL_PATH_METADATA_ACCESS_METHOD_NAMES: frozenset[str] = frozenset(
+    {"is_file", "is_dir", "exists", "stat", "lstat"}
+)
+
 MAX_DOCSTRING_INLINE_LITERAL_CLAIM_ISSUES: int = 3
 ALL_DOCSTRING_NO_INLINE_LITERAL_CLAIM_PHRASES: tuple[str, ...] = (
     "no literals appear inline",
@@ -204,3 +279,30 @@ ALL_TEST_INDICATING_ENVIRONMENT_VARIABLE_NAMES: frozenset[str] = frozenset(
         "UNIT_TEST",
     }
 )
+
+MAX_MODULE_DOCSTRING_DATA_SCHEMA_SCOPE_ISSUES: int = 1
+MODULE_DOCSTRING_DATA_SCHEMA_CONSTANT_SAMPLE_LIMIT: int = 6
+ALL_USER_FACING_TEXT_SCOPE_DOCSTRING_PHRASES: tuple[str, ...] = (
+    "user-facing",
+    "user facing",
+)
+ALL_DATA_SCHEMA_CONSTANT_NAME_MARKERS: tuple[str, ...] = (
+    "_FIELD_",
+    "_KEY_",
+    "_SCHEMA_",
+    "_ENCODING",
+    "_FORMAT_STRING",
+)
+ALL_DATA_SCHEMA_DOCSTRING_ACKNOWLEDGEMENT_PHRASES: tuple[str, ...] = (
+    "field key",
+    "schema key",
+    "schema",
+    "metadata",
+    "encoding",
+    "format string",
+    "runtime config",
+    "runtime-config",
+    "data schema",
+    "data-schema",
+    "config constant",
+)

package/hooks/hooks_constants/code_rules_enforcer_constants.py

@@ -39,6 +39,20 @@ DENY_REASON_ISSUE_PREVIEW_COUNT = 10
 ALL_BOOLEAN_NAME_PREFIXES: tuple[str, ...] = ("is_", "has_", "should_", "can_", "was_", "did_")
 UPPER_SNAKE_CONSTANT_PATTERN = re.compile(r"^[A-Z][A-Z0-9_]*$")
 
+ALL_POLARITY_ANTONYM_TOKEN_PAIRS: tuple[tuple[str, str], ...] = (
+    ("allowed", "forbidden"),
+    ("allowed", "denied"),
+    ("allowed", "blocked"),
+    ("permitted", "forbidden"),
+    ("permitted", "denied"),
+    ("included", "excluded"),
+    ("valid", "invalid"),
+    ("enabled", "disabled"),
+    ("visible", "hidden"),
+    ("present", "missing"),
+)
+POLARITY_TOKEN_BOUNDARY_PATTERN: str = r"(?:^|_)%s(?:_|$)"
+
 ALL_MUST_CHECK_RETURN_FUNCTION_NAMES: frozenset[str] = frozenset({"find_and_click", "write_outcome"})
 
 DOCSTRING_ARG_ENTRY_PATTERN: re.Pattern[str] = re.compile(r"^([A-Za-z_][A-Za-z0-9_]*)\s*[:(]")
@@ -137,6 +151,20 @@ MINIMUM_FSTRING_LITERAL_LENGTH = 2
 MAX_FSTRING_STRUCTURAL_LITERAL_ISSUES = 100
 ALL_ALLOWED_MAGIC_NUMBER_LITERALS: frozenset[str] = frozenset({"0", "1", "-1", "0.0", "1.0"})
 ALL_NON_MAGIC_FSTRING_STRIPPED_VALUES: frozenset[str] = frozenset({"", "True", "False"})
+INDENTATION_MAGIC_MINIMUM_SPACE_RUN = 4
+INDENTATION_MAGIC_MINIMUM_TAB_RUN = 2
+MAX_WHITESPACE_INDENTATION_MAGIC_ISSUES = 100
+WHITESPACE_INDENTATION_MAGIC_MESSAGE_SUFFIX: str = (
+    "whitespace indentation literal in a function body - extract to a named "
+    "indent constant in config/"
+)
+ALL_ALWAYS_NONEMPTY_SPLIT_METHOD_NAMES: frozenset[str] = frozenset({"split", "rsplit"})
+MAX_DEAD_SPLIT_BRANCH_ISSUES = 100
+DEAD_SPLIT_BRANCH_MESSAGE_SUFFIX: str = (
+    "is bound from a str.split() call with a separator, which never returns an "
+    "empty list, so this truthiness test's falsy branch is unreachable dead "
+    "code - remove the dead branch"
+)
 DUPLICATED_FORMAT_MINIMUM_REPETITION_COUNT = 3
 DUPLICATED_FORMAT_MINIMUM_LITERAL_CHARACTER_COUNT = 5
 FILE_GLOBAL_UPPER_SNAKE_PATTERN = re.compile(r"^_?[A-Z][A-Z0-9_]*$")