claude-dev-env 1.78.0 → 1.79.0

package/hooks/blocking/package_inventory_stale_blocker.py

@@ -2,7 +2,8 @@
 """PreToolUse hook: blocks a new production file absent from its package inventory.
 
 A package directory documents its own files in a sibling inventory document — a
-``README.md`` Layout table or a ``CLAUDE.md`` "Key files" list — whose entries
+``README.md`` Layout table, a ``CLAUDE.md`` "Key files" list, or a skill
+``SKILL.md`` Layout table that maps the ``scripts/`` subdirectory — whose entries
 name each file in backticks. When a Write creates a new production code file in a
 directory whose inventory already names two or more sibling files but carries no
 entry naming the new file, the inventory and the directory disagree on the
@@ -24,6 +25,7 @@ _hooks_dir = str(Path(__file__).resolve().parent.parent)
 if _hooks_dir not in sys.path:
     sys.path.insert(0, _hooks_dir)
 
+from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
 from hooks_constants.package_inventory_stale_blocker_constants import (  # noqa: E402
     ALL_EXEMPT_BASENAMES,
     ALL_EXEMPT_DIRECTORY_NAMES,
@@ -37,11 +39,12 @@ from hooks_constants.package_inventory_stale_blocker_constants import (  # noqa:
     MINIMUM_INVENTORY_ENTRY_COUNT,
     NON_FILENAME_TOKEN_PATTERN,
     PYTHON_FILE_EXTENSION,
+    SCRIPTS_SUBDIRECTORY_NAME,
+    SKILL_INVENTORY_DOCUMENT_NAME,
     STALE_INVENTORY_ADDITIONAL_CONTEXT,
     STALE_INVENTORY_MESSAGE_TEMPLATE,
     STALE_INVENTORY_SYSTEM_MESSAGE,
 )
-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,
 )
@@ -159,7 +162,7 @@ class _InventorySurvey:
 
     Attributes:
         present_inventory_names: The inventory document basenames present in the
-            directory (``README.md`` and/or ``CLAUDE.md``).
+            directory (``README.md``, ``CLAUDE.md``, and/or ``SKILL.md``).
         named_basenames: Every bare filename the present inventories name.
     """
 
@@ -279,18 +282,48 @@ def _sibling_named_basenames(
     return sibling_basenames
 
 
+def _parent_skill_inventory(package_directory: Path) -> _InventorySurvey | None:
+    """Return the parent skill ``SKILL.md`` survey for a ``scripts/`` directory.
+
+    A skill package keeps its ``SKILL.md`` at the skill root and maps the
+    ``scripts/`` subdirectory in a Layout table whose rows name files by their
+    ``scripts/<name>`` path. A production file landing in that ``scripts/``
+    directory is governed by the parent ``SKILL.md``, which sits one level up
+    rather than beside the file. This reads that parent ``SKILL.md`` and reports
+    the basenames it names. Any directory not named ``scripts/`` and any missing
+    or unreadable parent ``SKILL.md`` yield None.
+
+    Args:
+        package_directory: The directory that holds the file being written.
+
+    Returns:
+        The parent ``SKILL.md`` survey, or None when there is none to read.
+    """
+    if package_directory.name != SCRIPTS_SUBDIRECTORY_NAME:
+        return None
+    skill_inventory_path = package_directory.parent / SKILL_INVENTORY_DOCUMENT_NAME
+    inventory_content = _read_inventory_content(skill_inventory_path)
+    if inventory_content is None:
+        return None
+    return _InventorySurvey(
+        [SKILL_INVENTORY_DOCUMENT_NAME], inventory_named_basenames(inventory_content)
+    )
+
+
 def find_stale_inventory(file_path: str) -> _InventorySurvey | None:
     """Return the maintained inventory survey a new file is absent from, or None.
 
-    The file's directory inventories are surveyed, then the named basenames are
-    filtered to those that exist as files in the directory — the inventory's own
+    The file's own directory inventories are surveyed and, when the file sits in
+    a ``scripts/`` subdirectory, the parent skill ``SKILL.md`` Layout table is
+    surveyed too; the named basenames union across both. They are then filtered
+    to those that exist as files in the file's directory — the inventory's own
     sibling files. The survey reports a stale inventory only when every condition
-    holds: the directory carries at least one inventory document, those documents
-    together name at least the minimum entry count of on-disk sibling files
-    (marking them a maintained inventory rather than incidental prose that
-    mentions files living elsewhere), and the inventory does not already name this
-    file's basename. When any condition fails the file is in step with its
-    inventory (or there is no inventory to be out of step with), so None results.
+    holds: at least one inventory document is present, those documents together
+    name at least the minimum entry count of on-disk sibling files (marking them
+    a maintained inventory rather than incidental prose that mentions files living
+    elsewhere), and no inventory already names this file's basename. When any
+    condition fails the file is in step with its inventory (or there is no
+    inventory to be out of step with), so None results.
 
     Args:
         file_path: The destination path of the write.
@@ -302,14 +335,20 @@ def find_stale_inventory(file_path: str) -> _InventorySurvey | None:
     if not package_directory.is_dir():
         return None
     survey = survey_directory_inventories(package_directory)
-    if not survey.present_inventory_names:
+    present_inventory_names = list(survey.present_inventory_names)
+    named_basenames = set(survey.named_basenames)
+    parent_skill_survey = _parent_skill_inventory(package_directory)
+    if parent_skill_survey is not None:
+        present_inventory_names += parent_skill_survey.present_inventory_names
+        named_basenames |= parent_skill_survey.named_basenames
+    if not present_inventory_names:
         return None
-    sibling_basenames = _sibling_named_basenames(package_directory, survey.named_basenames)
+    sibling_basenames = _sibling_named_basenames(package_directory, named_basenames)
     if len(sibling_basenames) < MINIMUM_INVENTORY_ENTRY_COUNT:
         return None
-    if os.path.basename(file_path) in survey.named_basenames:
+    if os.path.basename(file_path) in named_basenames:
         return None
-    return _InventorySurvey(survey.present_inventory_names, sibling_basenames)
+    return _InventorySurvey(present_inventory_names, sibling_basenames)
 
 
 def _build_block_payload(file_path: str, survey: _InventorySurvey) -> dict:

package/hooks/blocking/test_code_rules_enforcer_docstring_field_runmode_outcome.py

@@ -0,0 +1,129 @@
+"""Tests for check_docstring_field_runmode_outcome — O6 run-mode-vs-per-record drift.
+
+A dataclass field whose name marks a run-mode flag (``is_dry_run``) is documented
+in the class Attributes block with per-record write-outcome prose ("True when no
+STP was written"), while the value is set the same way for every record from the
+run mode (``is_dry_run=not is_execute``). An already-OK record in an execute run
+writes no file yet still stores ``False``, so the per-record prose misleads every
+reader. This is the deterministic single-file slice of Category O6 drift.
+"""
+
+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()
+
+
+def check_docstring_field_runmode_outcome(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_docstring_field_runmode_outcome(content, file_path)
+
+
+PRODUCTION_FILE_PATH = "/project/src/jsonl_writer.py"
+TEST_FILE_PATH = "/project/src/test_jsonl_writer.py"
+HOOK_INFRASTRUCTURE_PATH = "/home/user/.claude/hooks/blocking/example.py"
+
+
+def _drifted_record() -> str:
+    return (
+        "@dataclass(frozen=True)\n"
+        "class PerThemeJsonlRecord:\n"
+        '    """Exact schema for the per-theme JSONL line.\n'
+        "\n"
+        "    Attributes:\n"
+        "        theme_name: Theme directory basename.\n"
+        "        is_dry_run: True when no STP was written.\n"
+        '    """\n'
+        "\n"
+        "    theme_name: str\n"
+        "    is_dry_run: bool\n"
+    )
+
+
+def _run_mode_record() -> str:
+    return (
+        "@dataclass(frozen=True)\n"
+        "class PerThemeJsonlRecord:\n"
+        '    """Exact schema for the per-theme JSONL line.\n'
+        "\n"
+        "    Attributes:\n"
+        "        theme_name: Theme directory basename.\n"
+        "        is_dry_run: True for a dry run; False for an execute run.\n"
+        '    """\n'
+        "\n"
+        "    theme_name: str\n"
+        "    is_dry_run: bool\n"
+    )
+
+
+def test_flags_run_mode_field_documented_as_per_record_write_outcome() -> None:
+    issues = check_docstring_field_runmode_outcome(_drifted_record(), PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "is_dry_run" in issues[0]
+    assert "run-mode" in issues[0]
+
+
+def test_run_mode_phrasing_is_left_alone() -> None:
+    issues = check_docstring_field_runmode_outcome(_run_mode_record(), PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_multiline_description_continuation_still_flags() -> None:
+    source = (
+        "@dataclass\n"
+        "class Record:\n"
+        '    """Schema.\n'
+        "\n"
+        "    Attributes:\n"
+        "        is_dry_run: True for the record when\n"
+        "            no STP was written.\n"
+        '    """\n'
+        "\n"
+        "    is_dry_run: bool\n"
+    )
+    issues = check_docstring_field_runmode_outcome(source, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+
+
+def test_non_run_mode_field_with_write_outcome_is_left_alone() -> None:
+    source = (
+        "@dataclass\n"
+        "class Record:\n"
+        '    """Schema.\n'
+        "\n"
+        "    Attributes:\n"
+        "        stp_path: Path the STP was written to disk.\n"
+        '    """\n'
+        "\n"
+        "    stp_path: str\n"
+    )
+    issues = check_docstring_field_runmode_outcome(source, PRODUCTION_FILE_PATH)
+    assert issues == []
+
+
+def test_test_file_is_exempt() -> None:
+    issues = check_docstring_field_runmode_outcome(_drifted_record(), TEST_FILE_PATH)
+    assert issues == []
+
+
+def test_hook_infrastructure_is_exempt() -> None:
+    issues = check_docstring_field_runmode_outcome(_drifted_record(), HOOK_INFRASTRUCTURE_PATH)
+    assert issues == []
+
+
+def test_syntax_error_returns_no_issues() -> None:
+    issues = check_docstring_field_runmode_outcome("class Record(\n", PRODUCTION_FILE_PATH)
+    assert issues == []

package/hooks/blocking/test_code_rules_enforcer_docstring_length_constant_superlative.py

@@ -0,0 +1,198 @@
+"""Tests for check_docstring_length_constant_superlative_vs_exact_gate.
+
+A config module defines an integer ``*_LENGTH`` constant and its docstring
+describes it with a superlative word ("the longest color string the swatch
+accepts"), while the only consumer treats the constant as an exact-length
+equality gate ("len(hex_color) != COLOR_AARRGGBB_LENGTH") in a sibling module.
+A shorter valid string is rejected, not accepted at a shorter length, so the
+"longest" prose claims a range of accepted lengths the code never allows. This
+is the deterministic exact-gate slice of Category O6/O8
+docstring-vs-implementation drift.
+
+The package trees these tests build live under a neutral OS temp directory
+rather than the pytest ``tmp_path`` fixture: the production check exempts any
+path containing "test", and the pytest fixture root carries that substring, so a
+fixture-rooted package would be skipped as test code and prove nothing.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import tempfile
+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()
+
+
+def check_length_gate(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_docstring_length_constant_superlative_vs_exact_gate(
+        content, file_path
+    )
+
+
+SUPERLATIVE_SWATCH_MODULE = '''"""Color-swatch rendering constants for the HTML run report.
+
+These constants name the longest color string the swatch accepts and the
+channel maximum the alpha byte is divided by.
+"""
+
+from typing import Final
+
+COLOR_AARRGGBB_LENGTH: Final[int] = 9
+'''
+
+
+def _run_gate_over_package(
+    swatch_content: str, consumer_body: str, swatch_basename: str = "color_swatch.py"
+) -> list[str]:
+    with tempfile.TemporaryDirectory() as temp_root:
+        config_directory = Path(temp_root) / "stp_contrast_fix" / "config"
+        config_directory.mkdir(parents=True)
+        swatch_path = config_directory / swatch_basename
+        swatch_path.write_text(swatch_content, encoding="utf-8")
+        consumer_path = config_directory.parent / "html_report_fragments.py"
+        consumer_path.write_text(consumer_body, encoding="utf-8")
+        return check_length_gate(swatch_content, str(swatch_path))
+
+
+def test_superlative_describing_exact_length_gate_is_flagged() -> None:
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH\n\n\n"
+        "def to_css(hex_color: str) -> str | None:\n"
+        '    if not hex_color.startswith("#") or len(hex_color) != '
+        "COLOR_AARRGGBB_LENGTH:\n"
+        "        return None\n"
+        "    return hex_color\n"
+    )
+    issues = _run_gate_over_package(SUPERLATIVE_SWATCH_MODULE, consumer_body)
+    assert len(issues) == 1
+    assert "COLOR_AARRGGBB_LENGTH" in issues[0]
+
+
+def test_ordered_comparison_treated_as_maximum_is_not_flagged() -> None:
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH\n\n\n"
+        "def truncated(hex_color: str) -> bool:\n"
+        "    return len(hex_color) <= COLOR_AARRGGBB_LENGTH\n"
+    )
+    assert _run_gate_over_package(SUPERLATIVE_SWATCH_MODULE, consumer_body) == []
+
+
+def test_no_superlative_phrase_is_not_flagged() -> None:
+    plain_module = (
+        '"""The exact required #AARRGGBB length the swatch renders."""\n\n'
+        "from typing import Final\n\n"
+        "COLOR_AARRGGBB_LENGTH: Final[int] = 9\n"
+    )
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH\n\n\n"
+        "def to_css(hex_color: str) -> bool:\n"
+        "    return len(hex_color) == COLOR_AARRGGBB_LENGTH\n"
+    )
+    assert _run_gate_over_package(plain_module, consumer_body) == []
+
+
+def test_constant_without_length_suffix_is_not_flagged() -> None:
+    non_length_module = (
+        '"""The longest swatch threshold value used by the renderer."""\n\n'
+        "from typing import Final\n\n"
+        "COLOR_CHANNEL_MAXIMUM: Final[int] = 255\n"
+    )
+    consumer_body = (
+        "from config.color_swatch import COLOR_CHANNEL_MAXIMUM\n\n\n"
+        "def saturated(channel: str) -> bool:\n"
+        "    return len(channel) == COLOR_CHANNEL_MAXIMUM\n"
+    )
+    assert _run_gate_over_package(non_length_module, consumer_body) == []
+
+
+def test_constant_with_no_length_comparison_is_not_flagged() -> None:
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH\n\n\n"
+        "def pad(hex_color: str) -> str:\n"
+        "    return hex_color.ljust(COLOR_AARRGGBB_LENGTH)\n"
+    )
+    assert _run_gate_over_package(SUPERLATIVE_SWATCH_MODULE, consumer_body) == []
+
+
+def test_superlative_in_function_docstring_is_not_flagged() -> None:
+    function_docstring_module = (
+        '"""The exact #AARRGGBB length the swatch renders."""\n\n'
+        "from typing import Final\n\n"
+        "COLOR_AARRGGBB_LENGTH: Final[int] = 9\n\n\n"
+        "def describe() -> str:\n"
+        '    """Return the longest color string the swatch accepts."""\n'
+        '    return "swatch"\n'
+    )
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH\n\n\n"
+        "def to_css(hex_color: str) -> bool:\n"
+        "    return len(hex_color) == COLOR_AARRGGBB_LENGTH\n"
+    )
+    assert _run_gate_over_package(function_docstring_module, consumer_body) == []
+
+
+def test_superlative_bound_to_other_constant_is_not_flagged() -> None:
+    two_constant_module = (
+        '"""Color-swatch rendering constants for the HTML run report.\n\n'
+        "COLOR_AARRGGBB_LENGTH is the exact #AARRGGBB length the swatch renders.\n"
+        "MAX_NAME_LENGTH is the longest swatch label the legend lays out.\n"
+        '"""\n\n'
+        "from typing import Final\n\n"
+        "COLOR_AARRGGBB_LENGTH: Final[int] = 9\n"
+        "MAX_NAME_LENGTH: Final[int] = 32\n"
+    )
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH, MAX_NAME_LENGTH\n\n\n"
+        "def to_css(hex_color: str) -> str | None:\n"
+        "    if len(hex_color) != COLOR_AARRGGBB_LENGTH:\n"
+        "        return None\n"
+        "    return hex_color\n\n\n"
+        "def fits(label: str) -> bool:\n"
+        "    return len(label) <= MAX_NAME_LENGTH\n"
+    )
+    assert _run_gate_over_package(two_constant_module, consumer_body) == []
+
+
+def test_superlative_bound_to_exact_gated_constant_is_flagged() -> None:
+    two_constant_module = (
+        '"""Color-swatch rendering constants for the HTML run report.\n\n'
+        "COLOR_AARRGGBB_LENGTH is the longest #AARRGGBB string the swatch accepts.\n"
+        "MAX_NAME_LENGTH is the exact swatch label width the legend lays out.\n"
+        '"""\n\n'
+        "from typing import Final\n\n"
+        "COLOR_AARRGGBB_LENGTH: Final[int] = 9\n"
+        "MAX_NAME_LENGTH: Final[int] = 32\n"
+    )
+    consumer_body = (
+        "from config.color_swatch import COLOR_AARRGGBB_LENGTH, MAX_NAME_LENGTH\n\n\n"
+        "def to_css(hex_color: str) -> str | None:\n"
+        "    if len(hex_color) != COLOR_AARRGGBB_LENGTH:\n"
+        "        return None\n"
+        "    return hex_color\n\n\n"
+        "def fits(label: str) -> bool:\n"
+        "    return len(label) <= MAX_NAME_LENGTH\n"
+    )
+    issues = _run_gate_over_package(two_constant_module, consumer_body)
+    assert len(issues) == 1
+    assert "COLOR_AARRGGBB_LENGTH" in issues[0]
+    assert "MAX_NAME_LENGTH" not in issues[0]
+
+
+def test_syntax_error_returns_empty() -> None:
+    issues = check_length_gate(
+        "def broken(\n", "/stp_contrast_fix/config/color_swatch.py"
+    )
+    assert issues == []

package/hooks/blocking/test_code_rules_enforcer_docstring_no_network.py

@@ -0,0 +1,115 @@
+"""Tests for check_docstring_no_network_claim_with_metadata_access — Category O6.
+
+A docstring promising a code path returns "without touching the network" drifts
+when the body calls a path-metadata method (``is_file``, ``stat``, ...): on a
+network share each metadata call is a round-trip over the wire, so the no-network
+claim is false. This is the deterministic slice of Category O6 (docstring prose
+versus implementation drift) for a no-network claim.
+"""
+
+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()
+
+
+def check_docstring_no_network_claim(content: str, file_path: str) -> list[str]:
+    return code_rules_enforcer.check_docstring_no_network_claim_with_metadata_access(
+        content, file_path
+    )
+
+
+PRODUCTION_FILE_PATH = "/project/shared_utils/bws/secret_fetch.py"
+TEST_FILE_PATH = "/project/shared_utils/bws/tests/test_secret_fetch.py"
+HOOK_INFRASTRUCTURE_PATH = "/home/user/.claude/hooks/blocking/example.py"
+
+
+def test_flags_no_network_claim_with_is_file_and_stat() -> None:
+    content = (
+        "def _ensure_local_bws_cache() -> str:\n"
+        '    """Return the local cache path, repopulating when stale.\n'
+        "\n"
+        "    An existing cache is returned without touching the network; a\n"
+        "    missing or size-mismatched cache is repopulated from the bundled\n"
+        "    executable.\n"
+        '    """\n'
+        "    if BUNDLED_BWS_EXECUTABLE_PATH.is_file():\n"
+        "        bundled_size = BUNDLED_BWS_EXECUTABLE_PATH.stat().st_size\n"
+        "        return str(LOCAL_BWS_CACHE_PATH)\n"
+        "    return str(LOCAL_BWS_CACHE_PATH)\n"
+    )
+    issues = check_docstring_no_network_claim(content, PRODUCTION_FILE_PATH)
+    assert len(issues) == 1
+    assert "_ensure_local_bws_cache" in issues[0]
+    assert "without touching the network" in issues[0]
+
+
+def test_flags_no_network_access_phrase_with_exists() -> None:
+    content = (
+        "def read_warm_cache(cache_path) -> str:\n"
+        '    """Serve the warm cache with no network access."""\n'
+        "    if cache_path.exists():\n"
+        "        return cache_path.read_text()\n"
+        "    return ''\n"
+    )
+    assert len(check_docstring_no_network_claim(content, PRODUCTION_FILE_PATH)) == 1
+
+
+def test_passes_when_claim_present_but_no_metadata_access() -> None:
+    content = (
+        "def read_warm_cache(cache_path) -> str:\n"
+        '    """Serve the warm cache without touching the network."""\n'
+        "    return cache_path.read_text()\n"
+    )
+    assert check_docstring_no_network_claim(content, PRODUCTION_FILE_PATH) == []
+
+
+def test_passes_when_metadata_access_but_no_network_claim() -> None:
+    content = (
+        "def _ensure_local_bws_cache(share_path) -> str:\n"
+        '    """Return the local cache path, repopulating when stale.\n'
+        "\n"
+        "    The bundled share is stat-checked on every call to validate the\n"
+        "    cache against the bundled executable size.\n"
+        '    """\n'
+        "    if share_path.is_file():\n"
+        "        return str(share_path)\n"
+        "    return ''\n"
+    )
+    assert check_docstring_no_network_claim(content, PRODUCTION_FILE_PATH) == []
+
+
+def test_test_files_are_exempt() -> None:
+    content = (
+        "def _ensure_local_bws_cache(share_path) -> str:\n"
+        '    """Return the cache without touching the network."""\n'
+        "    if share_path.is_file():\n"
+        "        return str(share_path)\n"
+        "    return ''\n"
+    )
+    assert check_docstring_no_network_claim(content, TEST_FILE_PATH) == []
+
+
+def test_hook_infrastructure_is_exempt() -> None:
+    content = (
+        "def _ensure_local_bws_cache(share_path) -> str:\n"
+        '    """Return the cache without touching the network."""\n'
+        "    if share_path.is_file():\n"
+        "        return str(share_path)\n"
+        "    return ''\n"
+    )
+    assert check_docstring_no_network_claim(content, HOOK_INFRASTRUCTURE_PATH) == []