claude-dev-env 1.76.0 → 1.78.0

package/hooks/blocking/test_code_rules_enforcer_docstring_runon_sentence.py

@@ -0,0 +1,267 @@
+"""Tests for check_docstring_runon_sentence — the plain-illustrative-docstrings backstop.
+
+A readable docstring breaks its narrative into short sentences a general developer
+follows on first read. The one mechanical mark of a dense wall is a single run-on
+sentence: many words strung together with an em-dash or a semicolon. This check
+flags that mark in module, class, and public-function docstring narrative prose,
+and leaves the "is it illustrative" judgment to the audit lane.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+_HOOKS_DIRECTORY = str(Path(__file__).resolve().parent.parent)
+if _HOOKS_DIRECTORY not in sys.path:
+    sys.path.insert(0, _HOOKS_DIRECTORY)
+
+from hooks_constants.code_rules_enforcer_constants import (  # noqa: E402
+    ALL_DOCSTRING_ARGS_SECTION_HEADERS,
+    ALL_DOCSTRING_TERMINATING_SECTION_HEADERS,
+)
+
+
+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()
+
+
+def check_docstring_runon_sentence(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_docstring_runon_sentence(content, file_path)
+
+
+def validate_content(content: str, file_path: str, old_content: str) -> list[str]:
+    return code_rules_enforcer.validate_content(content, file_path, old_content)
+
+
+PRODUCTION_FILE_PATH = "/project/src/run_lifecycle.py"
+TEST_FILE_PATH = "/project/src/test_run_lifecycle.py"
+HOOK_INFRASTRUCTURE_PATH = "/home/user/.claude/hooks/blocking/example.py"
+
+
+def _run_lifecycle_module() -> str:
+    return (
+        '"""Generic run-lifecycle plumbing for the STP version promoter run.\n'
+        "\n"
+        "Owns the SIGINT install/restore/installability check, the atexit terminal-record\n"
+        "registration, and the interrupted-run finalizer — the non-promoter-specific\n"
+        "machinery that brackets a run so the JSONL artifact always carries a terminal\n"
+        "record and an in-flight theme record on interrupt.\n"
+        '"""\n'
+        "\n"
+        "def install_signal_handler() -> None:\n"
+        "    return None\n"
+    )
+
+
+def _approved_bar_module() -> str:
+    return (
+        '"""Make sure a run\'s log always records how it ended.\n'
+        "\n"
+        "So when you reopen the report, the last line tells you the truth: the run\n"
+        "finished cleanly, or you hit Ctrl-C while theme 42 was processing, or it died\n"
+        "on an unexpected error. Without this, a killed run looks identical to a clean\n"
+        "one — and you're debugging blind.\n"
+        '"""\n'
+        "\n"
+        "def describe_outcome() -> None:\n"
+        "    return None\n"
+    )
+
+
+def _class_docstring_runon() -> str:
+    return (
+        "class RunRecorder:\n"
+        '    """Owns the SIGINT install and restore step, the atexit record hook, and the\n'
+        "    interrupted-run finalizer — the plumbing that brackets a run so the artifact\n"
+        "    always carries a terminal record and an in-flight theme record on interrupt.\n"
+        '    """\n'
+        "\n"
+        "    def record(self) -> None:\n"
+        "        return None\n"
+    )
+
+
+def _normal_short_docstring() -> str:
+    return (
+        "def summarize_run() -> str:\n"
+        '    """Write the run summary.\n'
+        "\n"
+        "    Each line names one theme and its final outcome.\n"
+        '    """\n'
+        '    return ""\n'
+    )
+
+
+def _long_args_line_outside_narrative() -> str:
+    return (
+        "def configure_run(option_name: str) -> None:\n"
+        '    """Set one option for the run.\n'
+        "\n"
+        "    Args:\n"
+        "        option_name: the name of the option to set, described here in a needlessly\n"
+        "            long sentence that runs far past thirty words and even carries an\n"
+        "            em-dash — yet the check stays silent because every word here sits after\n"
+        "            the Args header and therefore outside the inspected narrative entirely.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def _private_function_runon() -> str:
+    return (
+        "def _install_handlers() -> None:\n"
+        '    """Owns the SIGINT install and restore step, the atexit record hook, and the\n'
+        "    interrupted-run finalizer — the plumbing that brackets a run so the artifact\n"
+        "    always carries a terminal record and an in-flight theme record on interrupt.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def _property_method_runon() -> str:
+    return (
+        "class Widget:\n"
+        "    @property\n"
+        "    def label(self) -> str:\n"
+        '        """Owns the SIGINT install and restore step, the atexit record hook, and the\n'
+        "        interrupted-run finalizer — the plumbing that brackets a run so the artifact\n"
+        "        always carries a terminal record and an in-flight theme record on interrupt.\n"
+        '        """\n'
+        '        return "label"\n'
+    )
+
+
+def test_should_flag_run_lifecycle_module_docstring_wall() -> None:
+    issues = check_docstring_runon_sentence(_run_lifecycle_module(), PRODUCTION_FILE_PATH)
+    assert any("run-on" in each for each in issues), (
+        f"Expected the module-docstring wall to flag, got: {issues!r}"
+    )
+    assert any("module" in each for each in issues)
+    assert len(issues) == 1
+
+
+def test_should_not_flag_approved_bar_module_docstring() -> None:
+    issues = check_docstring_runon_sentence(_approved_bar_module(), PRODUCTION_FILE_PATH)
+    assert issues == [], f"The approved bar must pass clean, got: {issues!r}"
+
+
+def test_should_flag_class_docstring_wall() -> None:
+    issues = check_docstring_runon_sentence(_class_docstring_runon(), PRODUCTION_FILE_PATH)
+    assert any("RunRecorder" in each for each in issues), (
+        f"Expected the class-docstring wall to flag, got: {issues!r}"
+    )
+    assert len(issues) == 1
+
+
+def test_should_not_flag_normal_short_docstring() -> None:
+    issues = check_docstring_runon_sentence(_normal_short_docstring(), PRODUCTION_FILE_PATH)
+    assert issues == [], f"A short multi-sentence docstring must not flag, got: {issues!r}"
+
+
+def test_should_not_flag_long_args_line_outside_narrative() -> None:
+    issues = check_docstring_runon_sentence(
+        _long_args_line_outside_narrative(), PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"The Args section is outside the narrative, got: {issues!r}"
+
+
+def test_should_skip_private_function() -> None:
+    issues = check_docstring_runon_sentence(_private_function_runon(), PRODUCTION_FILE_PATH)
+    assert issues == [], f"Private functions are out of scope, got: {issues!r}"
+
+
+def test_should_skip_property_method() -> None:
+    issues = check_docstring_runon_sentence(_property_method_runon(), PRODUCTION_FILE_PATH)
+    assert issues == [], f"@property methods are exempt, got: {issues!r}"
+
+
+def test_should_skip_test_file() -> None:
+    issues = check_docstring_runon_sentence(_run_lifecycle_module(), TEST_FILE_PATH)
+    assert issues == [], f"Test files exempt, got: {issues!r}"
+
+
+def test_should_skip_hook_infrastructure() -> None:
+    issues = check_docstring_runon_sentence(_run_lifecycle_module(), HOOK_INFRASTRUCTURE_PATH)
+    assert issues == [], f"Hook infrastructure exempt, got: {issues!r}"
+
+
+def test_should_handle_syntax_error_gracefully() -> None:
+    issues = check_docstring_runon_sentence("def broken(\n", PRODUCTION_FILE_PATH)
+    assert issues == [], f"Syntax error must yield no issues, got: {issues!r}"
+
+
+def test_validate_content_surfaces_docstring_runon_wall() -> None:
+    issues = validate_content(_run_lifecycle_module(), PRODUCTION_FILE_PATH, old_content="")
+    matching_issues = [each for each in issues if "run-on" in each]
+    assert matching_issues, f"Expected validate_content to surface the run-on wall, got: {issues!r}"
+
+
+def _attached_cli_flag_double_hyphen() -> str:
+    return (
+        "def gather_remote_reviews() -> None:\n"
+        '    """Read every review the bot left across all the pages it produced and\n'
+        "    gather them into one ordered list by paging through the endpoint with the\n"
+        "    --paginate --slurp flags so the newest review across the whole set rises to\n"
+        "    the top of the report for the reader.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def _spaced_double_hyphen_joiner() -> str:
+    return (
+        "def gather_remote_reviews() -> None:\n"
+        '    """Read every review the bot left across all the pages it produced and\n'
+        "    gather them into one ordered list so the newest review rises to the top of\n"
+        "    the report -- the single line a tired reader scans first to learn how the\n"
+        "    whole run actually ended today.\n"
+        '    """\n'
+        "    return None\n"
+    )
+
+
+def test_should_not_flag_attached_cli_flag_double_hyphen() -> None:
+    issues = check_docstring_runon_sentence(
+        _attached_cli_flag_double_hyphen(), PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        "An attached --flag token is not a clause joiner and must not flag, "
+        f"got: {issues!r}"
+    )
+
+
+def test_should_flag_spaced_double_hyphen_joiner() -> None:
+    issues = check_docstring_runon_sentence(
+        _spaced_double_hyphen_joiner(), PRODUCTION_FILE_PATH
+    )
+    assert any("run-on" in each for each in issues), (
+        f"A spaced double-hyphen joiner past the word limit must flag, got: {issues!r}"
+    )
+    assert len(issues) == 1
+
+
+def test_docstring_names_every_inspected_section_header() -> None:
+    docstring = code_rules_enforcer.check_docstring_runon_sentence.__doc__
+    assert docstring is not None
+    inspected_headers = set(ALL_DOCSTRING_ARGS_SECTION_HEADERS) | set(
+        ALL_DOCSTRING_TERMINATING_SECTION_HEADERS
+    )
+    missing_headers = sorted(
+        each_header for each_header in inspected_headers if each_header not in docstring
+    )
+    assert missing_headers == [], (
+        "The docstring must name every section header the body cuts the narrative on; "
+        f"missing: {missing_headers!r}"
+    )

package/hooks/blocking/test_code_rules_enforcer_paired_test.py

@@ -0,0 +1,149 @@
+"""Behavioral tests for the public-function paired-test coverage check.
+
+Drives ``check_public_function_missing_paired_test`` over a real temporary
+filesystem whose path carries no ``test``/``hooks``/``config`` segment, so the
+module under test is classified as ordinary production code while its on-disk
+paired test files are read exactly as they would be in a real package.
+"""
+
+from __future__ import annotations
+
+import sys
+import tempfile
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+_BLOCKING_DIRECTORY = Path(__file__).resolve().parent
+if str(_BLOCKING_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_BLOCKING_DIRECTORY))
+
+from code_rules_paired_test import (  # noqa: E402
+    check_public_function_missing_paired_test,
+)
+
+_TWO_PUBLIC_FUNCTIONS = "def alpha():\n    return 1\n\n\ndef beta():\n    return 2\n"
+
+
+@pytest.fixture
+def neutral_package_directory() -> Iterator[Path]:
+    """Yield a ``pkg`` directory under a neutral temp root with a ``tests`` child.
+
+    The root prefix carries no ``test`` segment, so the module path the check
+    receives is classified as production code rather than a test file.
+    """
+    with tempfile.TemporaryDirectory(prefix="paircov_") as root_name:
+        package_directory = Path(root_name) / "pkg"
+        (package_directory / "tests").mkdir(parents=True)
+        yield package_directory
+
+
+def _write_test_file(package_directory: Path, filename: str, body: str) -> None:
+    (package_directory / "tests" / filename).write_text(body, encoding="utf-8")
+
+
+def test_flags_public_function_absent_from_established_suite(
+    neutral_package_directory: Path,
+) -> None:
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import alpha\n\ndef test_alpha():\n    assert alpha() == 1\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        _TWO_PUBLIC_FUNCTIONS, str(neutral_package_directory / "mod.py")
+    )
+    assert len(all_issues) == 1
+    assert "beta" in all_issues[0]
+    assert "paired test suite" in all_issues[0]
+    assert "alpha" not in all_issues[0]
+
+
+def test_clean_when_suite_covers_every_public_function(
+    neutral_package_directory: Path,
+) -> None:
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import alpha, beta\n\ndef test_both():\n    assert alpha() and beta()\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        _TWO_PUBLIC_FUNCTIONS, str(neutral_package_directory / "mod.py")
+    )
+    assert all_issues == []
+
+
+def test_skips_module_without_dedicated_test_file(
+    neutral_package_directory: Path,
+) -> None:
+    all_issues = check_public_function_missing_paired_test(
+        _TWO_PUBLIC_FUNCTIONS, str(neutral_package_directory / "mod.py")
+    )
+    assert all_issues == []
+
+
+def test_skips_when_suite_covers_no_public_function(
+    neutral_package_directory: Path,
+) -> None:
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "def test_unrelated():\n    assert 1 + 1 == 2\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        _TWO_PUBLIC_FUNCTIONS, str(neutral_package_directory / "mod.py")
+    )
+    assert all_issues == []
+
+
+def test_counts_coverage_across_sibling_test_files(
+    neutral_package_directory: Path,
+) -> None:
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import alpha\n\ndef test_alpha():\n    assert alpha() == 1\n",
+    )
+    _write_test_file(
+        neutral_package_directory,
+        "test_extra.py",
+        "from pkg.mod import beta\n\ndef test_beta():\n    assert beta() == 2\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        _TWO_PUBLIC_FUNCTIONS, str(neutral_package_directory / "mod.py")
+    )
+    assert all_issues == []
+
+
+def test_main_and_private_functions_are_never_required(
+    neutral_package_directory: Path,
+) -> None:
+    module_source = (
+        "def alpha():\n    return 1\n\n\n"
+        "def main():\n    return 0\n\n\n"
+        "def _helper():\n    return 2\n"
+    )
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import alpha\n\ndef test_alpha():\n    assert alpha() == 1\n",
+    )
+    all_issues = check_public_function_missing_paired_test(
+        module_source, str(neutral_package_directory / "mod.py")
+    )
+    assert all_issues == []
+
+
+def test_exempts_hook_infrastructure_and_test_paths(
+    neutral_package_directory: Path,
+) -> None:
+    _write_test_file(
+        neutral_package_directory,
+        "test_mod.py",
+        "from pkg.mod import alpha\n\ndef test_alpha():\n    assert alpha() == 1\n",
+    )
+    hook_path = "/repo/hooks/blocking/code_rules_paired_test.py"
+    test_path = str(neutral_package_directory / "tests" / "test_mod.py")
+    assert check_public_function_missing_paired_test(_TWO_PUBLIC_FUNCTIONS, hook_path) == []
+    assert check_public_function_missing_paired_test(_TWO_PUBLIC_FUNCTIONS, test_path) == []

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/hooks_constants/CLAUDE.md

@@ -39,6 +39,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

@@ -7,6 +7,8 @@ under the file-global-constants use-count rule (CODE_RULES §file-global-constan
 
 from __future__ import annotations
 
+import re
+
 MAX_BANNED_PREFIX_ISSUES: int = 3
 MAX_STUB_IMPLEMENTATION_ISSUES: int = 3
 MAX_TYPED_DICT_PAIR_ISSUES: int = 3
@@ -55,12 +57,57 @@ 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_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",
+    "anchor line is among the edited lines",
+    "anchor line is among the changed",
+    "first line is among the changed lines",
+    "start line is among the changed lines",
+)
+ALL_DOCSTRING_SPAN_SCOPE_OVERRIDE_PHRASES: tuple[str, ...] = (
+    "any line of",
+    "any line in",
+    "any of its lines",
+    "any span line",
+)
+ALL_DOCSTRING_SPAN_RANGE_BODY_CALLEE_NAMES: tuple[str, ...] = (
+    "_scope_violations_to_changed_lines",
+    "_scope_violations",
+)
+MAX_DOCSTRING_CARDINAL_FAMILY_ISSUES: int = 5
+MINIMUM_CONSTANT_FAMILY_MEMBERS_FOR_CARDINAL_CHECK: int = 2
+MINIMUM_DOCSTRING_FAMILY_OVERLAP_FOR_CARDINAL_CHECK: int = 2
 ALL_NAMING_CONVENTION_DESCRIPTOR_TOKENS: frozenset[str] = frozenset(
     {
         "UPPER_SNAKE_CASE",
@@ -114,6 +161,10 @@ ALL_FORMAT_LOGGER_FUNCTION_NAMES: frozenset[str] = frozenset(
         "log_background",
     }
 )
+DOCSTRING_RUNON_SENTENCE_WORD_LIMIT: int = 30
+MAX_DOCSTRING_RUNON_SENTENCE_ISSUES: int = 5
+ALL_DOCSTRING_RUNON_JOINER_MARKERS: tuple[str, ...] = ("—", " -- ", ";")
+DOCSTRING_RUNON_SENTENCE_BOUNDARY_PATTERN: re.Pattern[str] = re.compile(r"(?<=[.!?])\s+")
 
 ALL_DOCSTRING_NO_CONSUMER_CLAIM_PHRASES: tuple[str, ...] = (
     "no consumer reads",