claude-dev-env 1.84.0 → 1.85.0

package/_shared/pr-loop/scripts/pr_loop_shared_constants/CLAUDE.md

@@ -16,7 +16,7 @@ Named constants for every script in `_shared/pr-loop/scripts/`. Each module owns
 | `preflight_self_heal_constants.py` | `preflight_self_heal.py` — git config keys and local-scope detection strings |
 | `reviews_disabled_constants.py` | `reviews_disabled.py` — `CLAUDE_REVIEWS_DISABLED` token taxonomy |
 | `copilot_quota_constants.py` | `copilot_quota.py` — `COPILOT_QUOTA_ACCOUNT` env-var name, `copilot_internal/user` API path, the `premium_interactions` gating field names, the four skip/run exit codes, and the default `.env` path |
-| `terminology_sweep_constants.py` | `terminology_sweep.py` — identifier and prose-token regexes, diff-parsing prefixes, code-file extensions, and the finding-message template |
+| `terminology_sweep_constants.py` | `terminology_sweep.py` — identifier and prose-token regexes, diff-parsing prefixes, code-file extensions, test-file detection patterns, and the finding-message template |
 | `reviewer_availability_constants.py` | `reviewer_availability.py` — the available/down exit codes for the unified reviewer-availability pre-check |
 | `__init__.py` | Empty package marker |
 

package/_shared/pr-loop/scripts/pr_loop_shared_constants/terminology_sweep_constants.py

@@ -8,6 +8,8 @@ ALL_SWEEP_CODE_FILE_EXTENSIONS: frozenset[str] = frozenset(
 
 MARKDOWN_FILE_EXTENSION: str = ".md"
 
+PYTHON_FILE_EXTENSION: str = ".py"
+
 SNAKE_CASE_IDENTIFIER_PATTERN: re.Pattern[str] = re.compile(
     r"\b[a-z][a-z0-9]*(?:_[a-z0-9]+)+\b"
 )
@@ -28,6 +30,12 @@ STRING_LITERAL_CONTENT_PATTERN: re.Pattern[str] = re.compile(
     r"\"([^\"]*)\"|'([^']*)'|`([^`]*)`"
 )
 
+TEST_DIRECTORY_PATH_SEGMENT: str = "/tests/"
+
+TEST_FILE_NAME_PREFIX: str = "test_"
+
+ALL_TEST_FILE_NAME_INFIX_MARKERS: tuple[str, ...] = ("_test.", ".test.", ".spec.")
+
 DIFF_FILE_HEADER_PREFIX: str = "+++ "
 
 DIFF_HUNK_HEADER_PATTERN: re.Pattern[str] = re.compile(

package/_shared/pr-loop/scripts/terminology_sweep.py

@@ -1,40 +1,27 @@
-"""Flag prose terms that near-miss an identifier a diff introduces.
-
-Picture a change that adds an API field named ``premium_interactions``. On the
-same branch, the docs call it the ``premium-request`` budget. The code and the
-prose now name one thing two ways. A reader who searches for one term never
-finds the other.
-
-This sweep reads a unified diff and collects every multi-word identifier added
-on code lines. Then it scans each added prose line — a Markdown line, or a
-comment, docstring, or string inside a code file. It flags a hyphenated term
-that shares an identifier's leading word but diverges in the tail. Each
-near-miss prints as one ``file:line`` finding, and the run exits non-zero when
-any finding remains, so a commit gate can block on it.
-
-Only hyphenated terms are candidates. A hyphen marks a deliberate compound —
-the author bound the words into one term — so a divergent tail there is a real
-naming drift. A bare spaced word run is ordinary prose: windowing every
-sentence that starts with an identifier's first word ("each attempt", "file
-exists") floods a vocabulary-dense change with false findings and gives the
-gate nothing actionable.
-
-A shared leading token alone is too weak a signal: ordinary English compounds
-such as ``read-only`` and ``data-driven`` collide with unrelated identifiers
-(``read_config``, ``data_source``) and would block a commit falsely. To keep the
-grounding case (``premium-request`` against ``premium_interactions``) firing
-while sparing those compounds, a candidate whose final token is a common English
-compound tail word (``only``, ``driven``, ``safe``, and the rest listed in
-``ALL_COMMON_ENGLISH_COMPOUND_TAIL_WORDS``) is treated as ordinary prose, not a
-near-miss.
-
-Ordinary singular/plural prose is spared the same way. A candidate that differs
-from an identifier only by a singular/plural form of one or more tokens
-(``test files`` against ``test_file``, ``retry policies`` against
-``retry_policy``) is treated as the same term, not a near-miss.
+"""Flag a prose term that near-misses a code identifier a diff introduces.
+
+A change adds the field ``premium_interactions`` while the same branch's docs
+call it the ``premium-request`` budget: two names for one thing, and a reader
+who searches one never finds the other.
+
+::
+
+    code adds:  premium_interactions          (the identifier)
+    prose adds: "the premium-request budget"   (a hyphenated term)
+    flag: premium-request  vs  premium_interactions   -- shared first token, tail diverges
+    ok:   premium-interactions                 -- exact hyphen form, no drift
+    ok:   read-only,  test files               -- English compound or plural, not drift
+
+Only hyphenated prose is a candidate, since a hyphen marks a deliberate compound
+while a spaced word run is ordinary prose. Markdown scans in full; a JavaScript
+or TypeScript line contributes its comments and string literals; a Python file
+contributes identifiers only; a test code file is skipped whole. Each near-miss
+prints one ``file:line`` finding and the run exits non-zero, so a commit gate
+blocks on it.
 """
 
 import argparse
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -48,6 +35,7 @@ from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
     ALL_DIFF_FILE_PATH_STRIP_PREFIXES,
     ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
     ALL_SWEEP_CODE_FILE_EXTENSIONS,
+    ALL_TEST_FILE_NAME_INFIX_MARKERS,
     CAMEL_CASE_IDENTIFIER_PATTERN,
     CAMEL_CASE_WORD_PATTERN,
     DIFF_ADDED_LINE_PREFIX,
@@ -64,10 +52,13 @@ from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
     MARKDOWN_FILE_EXTENSION,
     MINIMUM_IDENTIFIER_TOKEN_COUNT,
     PYTHON_COMMENT_MARKER,
+    PYTHON_FILE_EXTENSION,
     SNAKE_CASE_IDENTIFIER_PATTERN,
     STRING_LITERAL_CONTENT_PATTERN,
     TERMINOLOGY_FINDING_TEMPLATE,
     TERMINOLOGY_SWEEP_DESCRIPTION,
+    TEST_DIRECTORY_PATH_SEGMENT,
+    TEST_FILE_NAME_PREFIX,
 )
 
 IdentifierTuple = tuple[str, ...]
@@ -124,6 +115,35 @@ def _file_extension(file_path: str) -> str:
     return Path(file_path).suffix.lower()
 
 
+def _is_test_file(file_path: str) -> bool:
+    """Return True when the diff path is a test code file the sweep should skip.
+
+    A test code file's prose is scaffolding: its docstrings and string fixtures
+    name the identifiers under test on purpose, so scanning it only adds noise. A
+    Markdown or other non-code file is prose worth scanning whatever its name, so
+    a ``test_plan.md`` design doc is scanned rather than skipped.
+
+    Args:
+        file_path: The repository-relative diff path.
+
+    Returns:
+        True for a code file under a ``tests`` directory, a ``test_`` prefixed
+        code file, or a code file whose name carries a
+        ``_test.``/``.test.``/``.spec.`` marker. False for any non-code file.
+    """
+    if _file_extension(file_path) not in ALL_SWEEP_CODE_FILE_EXTENSIONS:
+        return False
+    normalized_path = file_path.replace("\\", "/").lower()
+    if TEST_DIRECTORY_PATH_SEGMENT in f"/{normalized_path}":
+        return True
+    basename = normalized_path.rsplit("/", 1)[-1]
+    if basename.startswith(TEST_FILE_NAME_PREFIX):
+        return True
+    return any(
+        each_marker in basename for each_marker in ALL_TEST_FILE_NAME_INFIX_MARKERS
+    )
+
+
 def _identifier_token_tuple(identifier: str) -> IdentifierTuple:
     """Return the lowercase word tokens of a snake_case or camelCase identifier."""
     if "_" in identifier:
@@ -175,8 +195,11 @@ def _collect_introduced_identifiers(
 def _prose_fragments(file_path: str, line_text: str) -> list[str]:
     """Return the prose fragments of an added line worth scanning for terms.
 
-    A Markdown line is prose in full. A code line contributes its comment tail,
-    its JSDoc continuation text, and the contents of its string literals.
+    A Markdown line is prose in full. A JavaScript or TypeScript line contributes
+    its comment tail, its JSDoc continuation text, and the contents of its string
+    literals. A Python line contributes no prose: to avoid flagging a module's own
+    vocabulary as drift, the sweep ignores Python comments, docstrings, and string
+    literals and scans Python files for identifiers only.
 
     Args:
         file_path: The path the added line belongs to.
@@ -185,9 +208,12 @@ def _prose_fragments(file_path: str, line_text: str) -> list[str]:
     Returns:
         The prose fragments to scan for near-miss terms.
     """
-    if _file_extension(file_path) == MARKDOWN_FILE_EXTENSION:
+    extension = _file_extension(file_path)
+    if extension == MARKDOWN_FILE_EXTENSION:
         return [line_text]
-    if _file_extension(file_path) not in ALL_SWEEP_CODE_FILE_EXTENSIONS:
+    if extension not in ALL_SWEEP_CODE_FILE_EXTENSIONS:
+        return []
+    if extension == PYTHON_FILE_EXTENSION:
         return []
     all_fragments: list[str] = []
     stripped_line = line_text.strip()
@@ -352,7 +378,11 @@ def sweep_diff(diff_text: str) -> list[str]:
     Returns:
         One finding string per near-miss term on an added prose line.
     """
-    all_added_lines = _parse_added_lines(diff_text)
+    all_added_lines = [
+        each_added_line
+        for each_added_line in _parse_added_lines(diff_text)
+        if not _is_test_file(each_added_line[0])
+    ]
     all_identifier_tuples, identifiers_by_first_token = _collect_introduced_identifiers(
         all_added_lines
     )
@@ -372,6 +402,21 @@ def sweep_diff(diff_text: str) -> list[str]:
     return all_findings
 
 
+def _git_environment() -> dict[str, str]:
+    """Return the process environment with every GIT_ variable removed.
+
+    A git commit hook runs this sweep with GIT_INDEX_FILE pointed at the commit
+    index. Stripping every GIT_ variable makes ``git diff --cached`` read the
+    repository's own index, so the sweep sees the staged diff of the repository
+    it was handed rather than an ambient override.
+    """
+    return {
+        each_key: each_setting
+        for each_key, each_setting in os.environ.items()
+        if not each_key.startswith("GIT_")
+    }
+
+
 def staged_terminology_findings(repository_root: Path) -> list[str]:
     """Return terminology near-miss findings for a repository's staged diff.
 
@@ -391,6 +436,7 @@ def staged_terminology_findings(repository_root: Path) -> list[str]:
         errors="replace",
         timeout=GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS,
         check=False,
+        env=_git_environment(),
     )
     if diff_process.returncode != 0:
         return []

package/_shared/pr-loop/scripts/tests/test_terminology_sweep.py

@@ -23,13 +23,22 @@ main = sweep_module.main
 parse_added_lines = sweep_module._parse_added_lines
 
 
+_git_environment = sweep_module._git_environment
+
+
 def _init_git_repository(repository_path: Path) -> None:
     for each_command in (
         ["git", "init"],
         ["git", "config", "user.email", "test@example.com"],
         ["git", "config", "user.name", "Test"],
     ):
-        subprocess.run(each_command, cwd=repository_path, check=True, capture_output=True)
+        subprocess.run(
+            each_command,
+            cwd=repository_path,
+            check=True,
+            capture_output=True,
+            env=_git_environment(),
+        )
 
 
 CODE_AND_PROSE_DIFF = (
@@ -220,17 +229,86 @@ def test_does_not_flag_ordinary_sentence_sharing_loop_variable_prefix() -> None:
 
 
 def test_flags_near_miss_inside_code_comment() -> None:
+    diff = (
+        "diff --git a/api/quota.mjs b/api/quota.mjs\n"
+        "--- a/api/quota.mjs\n"
+        "+++ b/api/quota.mjs\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+const premium_interactions = 5\n"
+        "+// the premium-request path resets the counter\n"
+    )
+    findings = sweep_diff(diff)
+    assert len(findings) == 1
+    assert "premium-request" in findings[0]
+
+
+def test_flags_near_miss_inside_code_string_literal() -> None:
+    diff = (
+        "diff --git a/api/quota.mjs b/api/quota.mjs\n"
+        "--- a/api/quota.mjs\n"
+        "+++ b/api/quota.mjs\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+const premium_interactions = 5\n"
+        '+throw new Error("the premium-request budget")\n'
+    )
+    findings = sweep_diff(diff)
+    assert len(findings) == 1
+    assert "premium-request" in findings[0]
+
+
+def test_does_not_flag_prose_inside_code_string_literal() -> None:
+    diff = (
+        "diff --git a/api/quota.py b/api/quota.py\n"
+        "--- a/api/quota.py\n"
+        "+++ b/api/quota.py\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+premium_interactions = 5\n"
+        '+message = "the premium-request budget"\n'
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_does_not_flag_prose_inside_code_docstring() -> None:
     diff = (
         "diff --git a/api/quota.py b/api/quota.py\n"
         "--- a/api/quota.py\n"
         "+++ b/api/quota.py\n"
         "@@ -0,0 +1,2 @@\n"
         "+premium_interactions = 5\n"
-        "+# the premium-request path resets the counter\n"
+        '+    """Gate the run on the premium-request budget."""\n'
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_does_not_flag_prose_in_test_file() -> None:
+    diff = (
+        "diff --git a/api/quota.test.mjs b/api/quota.test.mjs\n"
+        "--- a/api/quota.test.mjs\n"
+        "+++ b/api/quota.test.mjs\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+const premium_interactions = 5\n"
+        "+// the premium-request path resets the counter\n"
+    )
+    assert sweep_diff(diff) == []
+
+
+def test_flags_prose_in_test_named_markdown_doc() -> None:
+    diff = (
+        "diff --git a/api/quota.py b/api/quota.py\n"
+        "--- a/api/quota.py\n"
+        "+++ b/api/quota.py\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+premium_interactions = 5\n"
+        "diff --git a/docs/test_plan.md b/docs/test_plan.md\n"
+        "--- a/docs/test_plan.md\n"
+        "+++ b/docs/test_plan.md\n"
+        "@@ -0,0 +1,1 @@\n"
+        "+The premium-request budget gates the run.\n"
     )
     findings = sweep_diff(diff)
     assert len(findings) == 1
     assert "premium-request" in findings[0]
+    assert "test_plan.md" in findings[0]
 
 
 def test_no_findings_when_no_multiword_identifier_introduced() -> None:
@@ -273,7 +351,13 @@ def test_staged_terminology_findings_flags_staged_prose(tmp_path: Path) -> None:
     (tmp_path / "README.md").write_text(
         "The premium-request budget gates the run.\n", encoding="utf-8"
     )
-    subprocess.run(["git", "add", "-A"], cwd=tmp_path, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "add", "-A"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+        env=_git_environment(),
+    )
     findings = staged_terminology_findings(tmp_path)
     assert any("premium-request" in each_finding for each_finding in findings)
 
@@ -281,7 +365,13 @@ def test_staged_terminology_findings_flags_staged_prose(tmp_path: Path) -> None:
 def test_staged_terminology_findings_empty_when_clean(tmp_path: Path) -> None:
     _init_git_repository(tmp_path)
     (tmp_path / "README.md").write_text("Nothing notable here.\n", encoding="utf-8")
-    subprocess.run(["git", "add", "-A"], cwd=tmp_path, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "add", "-A"],
+        cwd=tmp_path,
+        check=True,
+        capture_output=True,
+        env=_git_environment(),
+    )
     assert staged_terminology_findings(tmp_path) == []
 
 

package/hooks/blocking/claude_md_orphan_file_blocker.py

@@ -45,11 +45,11 @@ from hooks_constants.claude_md_orphan_file_blocker_constants import (  # noqa: E
     SEPARATOR_CELL_PATTERN,
     TABLE_ROW_PATTERN,
 )
+from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.multi_edit_reconstruction import (  # noqa: E402
     apply_edits,
     edits_for_tool,
 )
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.pre_tool_use_stdin import (  # noqa: E402
     read_hook_input_dictionary_from_stdin,
 )

package/hooks/blocking/code_rules_docstrings.py

@@ -93,6 +93,7 @@ from hooks_constants.blocking_check_limits import (  # noqa: E402
     MINIMUM_NAMED_MARKS_FOR_PROSE_ENUMERATION,
     MINIMUM_PUBLIC_CHECKS_FOR_MODULE_DOCSTRING_ROSTER,
     MINIMUM_PUBLIC_METHODS_FOR_CLASS_DOCSTRING_BREADTH,
+    MINIMUM_RANGE_ARGS_FOR_SPAN,
     MINIMUM_SIBLING_OCCURRENCES_FOR_SHARED_TOKEN,
     MINIMUM_TOKENS_FOR_DISPATCH_CALLEE,
     MINIMUM_TUPLE_MEMBERS_FOR_DOCSTRING_ENUMERATION,
@@ -2019,13 +2020,14 @@ def _documentable_docstrings_with_line(parsed_tree: ast.Module) -> list[tuple[in
 def check_docstring_cardinal_count_matches_constant_family(
     content: str, file_path: str
 ) -> list[str]:
-    """Flag a docstring cardinal count that under-names a referenced constant family.
+    """Flag a docstring cardinal count that differs from a referenced constant family.
 
     The drift this catches: a docstring states a cardinal count of an outcome
     family (``Covers the four outcome branches: ...``) and enumerates that
-    family's members in prose, while the module references more members of the
-    same ``UPPER_SNAKE`` constant family than the count names. The prose
-    under-describes the code — a reader trusts the count and the enumeration to
+    family's members in prose, while the module references a member set of the
+    same ``UPPER_SNAKE`` constant family whose size differs from the stated
+    count — above it and below it both trip. The prose
+    misdescribes the code — a reader trusts the count and the enumeration to
     be the full set, but the module imports and exercises an outcome the summary
     omits. The check binds only when the docstring states a cardinal beside an
     outcome noun, names two or more members of one referenced family, leaves at
@@ -2038,7 +2040,8 @@ def check_docstring_cardinal_count_matches_constant_family(
 
     Args:
         content: The source text to inspect.
-        file_path: The path the source will be written to, used for exemptions.
+        file_path: Accepted for the uniform check interface; the body does not
+            read it.
 
     Returns:
         One issue per docstring whose cardinal count and enumeration omit a
@@ -2473,12 +2476,12 @@ def _argument_prose_scopes_a_single_line(argument_prose: str) -> bool:
     )
 
 
-def _call_node_builds_two_argument_range(call_node: ast.Call) -> bool:
+def _call_node_builds_explicit_start_range(call_node: ast.Call) -> bool:
     callee = call_node.func
     return (
         isinstance(callee, ast.Name)
         and callee.id == "range"
-        and len(call_node.args) >= MINIMUM_TOKENS_FOR_DISPATCH_CALLEE
+        and len(call_node.args) >= MINIMUM_RANGE_ARGS_FOR_SPAN
     )
 
 
@@ -2490,7 +2493,7 @@ def _function_body_scopes_a_span_by_intersection(
     for each_node in ast.walk(function_node):
         if not isinstance(each_node, ast.Call):
             continue
-        if _call_node_builds_two_argument_range(each_node):
+        if _call_node_builds_explicit_start_range(each_node):
             builds_range_span = True
         if _call_callee_name(each_node) in ALL_DOCSTRING_SPAN_RANGE_BODY_CALLEE_NAMES:
             calls_span_scoper = True
@@ -2510,11 +2513,12 @@ def check_docstring_args_single_line_scope_vs_span(content: str, file_path: str)
     is the deterministic slice of Category O6 docstring-vs-implementation drift
     for an Args single-line scope claim disagreeing with a span-intersection body.
 
-    An entry is left alone when its prose says "any line of" / "any line in" its
-    span, since that wording matches the span body. The body is judged a
-    span-intersection scoper only when it both builds a two-argument ``range(...)``
-    and calls a known span scoper, so a body that scopes by a single line never
-    trips the check. Hook infrastructure is in scope here — the import-sort gate
+    An entry is left alone when its prose says "any line of" / "any line in" /
+    "any of its lines" / "any span line" about its span, since that wording
+    matches the span body. The body is judged a span-intersection scoper only
+    when it both builds an explicit-start ``range(...)`` (two or more
+    arguments) and calls a known span scoper, so a body that scopes by a
+    single line never trips the check. Hook infrastructure is in scope here — the import-sort gate
     that carries this drift class is itself a hook — and test files are exempt.
 
     Args:

package/hooks/blocking/code_rules_imports_logging.py

@@ -244,7 +244,8 @@ def check_import_block_sorted(
             give ruff the filename it needs for config discovery.
         all_changed_lines: Post-edit line numbers the current edit touched, or
             None to treat the whole file as in scope. When provided, a finding
-            blocks only when its block-anchor line is among the changed lines.
+            blocks only when any line of its block span is among the changed
+            lines.
         defer_scope_to_caller: When True, return every finding so the commit/push
             gate's ``Line N:`` partitioning scopes by added line.
 
@@ -813,9 +814,9 @@ def _naive_datetime_remediation(constructor_name: str) -> str:
     """Return the fix guidance for a specific naive datetime constructor.
 
     ``utcnow`` and ``utcfromtimestamp`` accept no ``tz`` argument, so each points
-    at its aware replacement (``datetime.now(tz=...)`` and
-    ``datetime.fromtimestamp(..., tz=...)``); ``fromtimestamp`` keeps its shape and
-    only needs a ``tz=`` argument.
+    at its aware replacement (``now(tz=...)`` and ``fromtimestamp(..., tz=...)``
+    on the same datetime class, whichever import form the call used);
+    ``fromtimestamp`` keeps its shape and only needs a ``tz=`` argument.
 
     Args:
         constructor_name: The naive constructor the call used.
@@ -824,9 +825,12 @@ def _naive_datetime_remediation(constructor_name: str) -> str:
         The remediation clause to embed in the emitted issue.
     """
     if constructor_name == NAIVE_DATETIME_UTCNOW_CONSTRUCTOR:
-        return "use datetime.now(tz=timezone.utc)"
+        return "replace utcnow() with now(tz=timezone.utc) on the same datetime class"
     if constructor_name == NAIVE_DATETIME_UTCFROMTIMESTAMP_CONSTRUCTOR:
-        return "use datetime.fromtimestamp(..., tz=timezone.utc)"
+        return (
+            "replace utcfromtimestamp(...) with fromtimestamp(..., tz=timezone.utc) "
+            "on the same datetime class"
+        )
     return "pass tz= (e.g. tz=timezone.utc)"
 
 

package/hooks/blocking/code_rules_naming_collection.py

@@ -434,7 +434,7 @@ def _contradicting_polarity_pair(target_name: str, called_name: str) -> tuple[st
 
 
 def check_polarity_name_contradiction(content: str, file_path: str) -> list[str]:
-    """Flag a boolean assignment whose target and callee assert opposite polarity.
+    """Flag an assignment whose target and callee assert opposite polarity.
 
     ::
 
@@ -445,8 +445,10 @@ def check_polarity_name_contradiction(content: str, file_path: str) -> list[str]
         flag: is_inside_allowed = _point_hits_any_forbidden(...)
 
     The target token and the callee token contradict each other, so the reader
-    cannot tell which name states the truth. Rename the callee to a neutral form
-    the two names agree on at every call site.
+    cannot tell which name states the truth. Any single-name assignment from a
+    call is inspected — collections and counts included, not only booleans.
+    Rename the callee to a neutral form the two names agree on at every call
+    site.
     """
     if is_test_file(file_path):
         return []

package/hooks/blocking/code_rules_paired_test.py

@@ -164,8 +164,9 @@ def _stem_matched_test_path(module_path: Path) -> Path | None:
 
     Returns:
         The path of the first existing ``test_<stem>.py`` or ``<stem>_test.py``
-        file — beside the module or under an ancestor ``tests`` directory — or
-        None when the module has no dedicated test file.
+        file beside the module, or ``test_<stem>.py`` under an ancestor
+        ``tests`` directory — or None when the module has no dedicated test
+        file.
     """
     module_directory = module_path.parent
     module_stem = module_path.stem

package/hooks/blocking/code_rules_string_magic.py

@@ -1,4 +1,4 @@
-"""Bare string-literal magic, inline literal-collection, inline tuple string-magic, and whitespace-indentation magic checks."""
+"""Bare string-literal magic, join-separator string magic, inline literal-collection, inline tuple string-magic, and whitespace-indentation magic checks."""
 
 import ast
 import re

package/hooks/blocking/code_rules_unused_imports.py

@@ -1,4 +1,4 @@
-"""Unused module-level import check and its import-range and type-checking-gate helpers."""
+"""Unused module-level import check and its import-range helpers."""
 
 import ast
 import sys
@@ -143,7 +143,7 @@ def check_unused_module_level_imports(
 
     When ``full_file_content`` is provided, ``content`` is treated as an Edit
     fragment containing the imports being added or replaced, while the
-    ``__all__`` / ``TYPE_CHECKING`` gate detection and reference scanning run
+    ``__all__`` gate detection and reference scanning run
     against ``full_file_content`` (the post-edit file as it will look once the
     Edit applies). This prevents false-positive flags on imports added in the
     same Edit as their consumers.

package/hooks/blocking/test_code_rules_enforcer_docstring_args_span_scope.py

@@ -75,6 +75,35 @@ def test_flags_anchor_line_scope_against_span_intersection_body() -> None:
     assert "all_changed_lines" in issues[0]
 
 
+def test_flags_single_line_scope_against_stepped_range_span_body() -> None:
+    content = (
+        "def check_import_block_sorted(\n"
+        "    content: str, file_path: str, all_changed_lines: set[int] | None\n"
+        ") -> list[str]:\n"
+        '    """Flag an unsorted import block scoped to the changed lines.\n'
+        "\n"
+        "    Args:\n"
+        "        content: The full file content the write would leave on disk.\n"
+        "        file_path: The destination path used to gate by extension.\n"
+        "        all_changed_lines: Post-edit line numbers, or None. When provided,\n"
+        "            a finding blocks only when its block-anchor line is among the\n"
+        "            changed lines.\n"
+        "\n"
+        "    Returns:\n"
+        "        One issue string per detected finding.\n"
+        '    """\n'
+        "    span_range = range(line_number, block_end_line_number + 1, 1)\n"
+        "    all_violations.append((span_range, message))\n"
+        "    return _scope_violations_to_changed_lines(\n"
+        "        all_violations, all_changed_lines, defer_scope_to_caller\n"
+        "    )\n"
+    )
+    issues = check_docstring_args_single_line_scope_vs_span(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "check_import_block_sorted" in issues[0]
+    assert "all_changed_lines" in issues[0]
+
+
 def test_flags_the_line_is_among_phrasing() -> None:
     content = (
         "def check_block(\n"

package/hooks/blocking/test_code_rules_enforcer_naive_datetime.py

@@ -181,6 +181,30 @@ def test_utcfromtimestamp_remediation_uses_generic_placeholder() -> None:
     assert "stamp, tz=" not in issues[0]
 
 
+def test_utcnow_remediation_is_import_agnostic() -> None:
+    content = (
+        "import datetime\n"
+        "def stamp() -> object:\n"
+        "    return datetime.datetime.utcnow()\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "use datetime.now(" not in issues[0]
+    assert "on the same datetime class" in issues[0]
+
+
+def test_utcfromtimestamp_remediation_is_import_agnostic() -> None:
+    content = (
+        "import datetime\n"
+        "def build(stamp: float) -> object:\n"
+        "    return datetime.datetime.utcfromtimestamp(stamp)\n"
+    )
+    issues = check_naive_datetime_construction(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "use datetime.fromtimestamp(" not in issues[0]
+    assert "on the same datetime class" in issues[0]
+
+
 def test_remediation_does_not_mandate_astimezone() -> None:
     content = (
         "from datetime import datetime\n"

package/hooks/hooks_constants/blocking_check_limits.py

@@ -99,6 +99,7 @@ ALL_PUNCTUATION_MARK_GLYPH_PROSE_NAMES: dict[str, tuple[str, ...]] = {
 MAX_DOCSTRING_STEP_DISPATCH_ISSUES: int = 5
 MINIMUM_NAMED_LINEAR_STEPS_FOR_DISPATCH_CHECK: int = 2
 MINIMUM_TOKENS_FOR_DISPATCH_CALLEE: int = 2
+MINIMUM_RANGE_ARGS_FOR_SPAN: 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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "1.84.0",
+    "version": "1.85.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {