claude-dev-env 8.9.0 → 8.11.0

package/scripts/cde_lint.py

@@ -11,11 +11,24 @@ from typing import Never, TextIO
 
 from policy_lint.config.constants import INVALID_INPUT_EXIT_CODE
 from policy_lint.engine import lint
-from policy_lint.model import LintReport, LintRequest, SelectionKind, TextDocument
+from policy_lint.model import (
+    LintReport,
+    LintRequest,
+    SelectionKind,
+    Severity,
+    TextDocument,
+)
 from policy_lint.render import ReportFormat, render
 from policy_lint.selection import SelectionRunFatal
 from policy_lint.selection_git import GitSelectionError, git_bytes_for
 
+_hooks_directory = str(Path(__file__).resolve().parents[1] / "hooks")
+if _hooks_directory not in sys.path:
+    sys.path.insert(0, _hooks_directory)
+
+from followup_ledger import FollowupFinding, head_commit, record_followup_finding
+from hooks_constants.followup_ledger_constants import SEVERITY_SMELL
+
 
 class _LintUsageError(ValueError):
     """Raised when command arguments cannot form a source selection."""
@@ -201,6 +214,38 @@ def _write_invalid_input(error: Exception, stderr: TextIO) -> int:
     return INVALID_INPUT_EXIT_CODE
 
 
+def _record_warning_followups(report: LintReport, repository_root: Path) -> None:
+    """Append each warning in the report to the repository's follow-up ledger.
+
+    Args:
+        report: The findings this run produced.
+        repository_root: The repository whose ledger receives the warnings.
+    """
+    all_warnings = [
+        each_diagnostic
+        for each_diagnostic in report.diagnostics
+        if each_diagnostic.severity is Severity.WARNING
+    ]
+    if not all_warnings:
+        return
+    origin_commit = head_commit(repository_root)
+    for each_warning in all_warnings:
+        file_path = (
+            "" if each_warning.location is None else each_warning.location.path.as_posix()
+        )
+        record_followup_finding(
+            repository_root,
+            FollowupFinding(
+                each_warning.rule_id,
+                file_path,
+                each_warning.message,
+                each_warning.check_id or each_warning.rule_id,
+                SEVERITY_SMELL,
+                origin_commit,
+            ),
+        )
+
+
 def _render_lint(
     all_arguments: Sequence[str],
     repository_root: Path,
@@ -212,6 +257,7 @@ def _render_lint(
         all_arguments, stdin, repository_root, lint_runner
     )
     stdout.write(render(report, report_format))
+    _record_warning_followups(report, repository_root)
     return report.exit_code
 
 

package/scripts/policy_lint/adapter_callers.py

@@ -0,0 +1,124 @@
+"""Report a new code file that nothing outside its own tests calls.
+
+A script, hook or skill script earns its place when something runs it: a
+``hooks.json`` entry, a workflow step, a skill or command, or an import from
+live code. A file whose only mention is its own test ships work nobody uses.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path, PurePosixPath
+
+from .config import constants
+from .model import Diagnostic, Document, DocumentSet, Location, SelectionKind, Severity
+
+
+def _is_test_path(path: PurePosixPath) -> bool:
+    return (
+        path.name.startswith("test_")
+        or path.stem.endswith("_test")
+        or ".test." in path.name
+        or "tests" in path.parts
+        or "test" in path.parts
+    )
+
+
+def _is_new_code_file(document: Document) -> bool:
+    if document.prior_text is not None or document.prior_path is not None:
+        return False
+    path = document.path
+    if path.suffix.lower() not in constants.ALL_CALLED_CODE_SUFFIXES:
+        return False
+    if path.name in constants.ALL_UNCALLED_EXEMPT_FILE_NAMES or _is_test_path(path):
+        return False
+    normalized_path = f"/{path.as_posix()}"
+    return any(
+        each_segment in normalized_path
+        for each_segment in constants.ALL_CALLED_CODE_SEGMENTS
+    )
+
+
+def _is_caller_source(
+    relative_path: PurePosixPath, all_candidate_paths: frozenset[PurePosixPath]
+) -> bool:
+    if constants.ALL_CALLER_SEARCH_SKIPPED_DIRECTORIES.intersection(
+        relative_path.parts
+    ):
+        return False
+    if relative_path.name in constants.ALL_INVENTORY_FILE_NAMES:
+        return False
+    return relative_path not in all_candidate_paths and not _is_test_path(
+        relative_path
+    )
+
+
+def _read_caller_text(file_path: Path) -> str:
+    try:
+        return file_path.read_text("utf-8")
+    except (OSError, UnicodeDecodeError):
+        return ""
+
+
+def _caller_texts(
+    repository_root: Path, all_candidate_paths: frozenset[PurePosixPath]
+) -> tuple[str, ...]:
+    return tuple(
+        _read_caller_text(each_path)
+        for each_path in repository_root.rglob("*")
+        if each_path.is_file()
+        and _is_caller_source(
+            PurePosixPath(each_path.relative_to(repository_root).as_posix()),
+            all_candidate_paths,
+        )
+    )
+
+
+def _has_caller(document: Document, all_caller_texts: tuple[str, ...]) -> bool:
+    name_pattern = re.compile(
+        constants.CALLER_NAME_PATTERN_TEMPLATE.format(
+            name=re.escape(document.path.stem)
+        )
+    )
+    return any(name_pattern.search(each_text) for each_text in all_caller_texts)
+
+
+def _uncalled_diagnostic(document: Document) -> Diagnostic:
+    return Diagnostic(
+        constants.UNCALLED_NEW_FILE_RULE_ID,
+        Severity.ERROR,
+        constants.UNCALLED_NEW_FILE_MESSAGE.format(file_name=document.path.name),
+        Location(document.path, 1, 1),
+    )
+
+
+def uncalled_new_file_diagnostics(
+    document_set: DocumentSet,
+) -> tuple[Diagnostic, ...]:
+    """Report each new code file with no caller outside its tests.
+
+    Args:
+        document_set: Staged or base change selection.
+
+    Returns:
+        One diagnostic for each added script, hook or skill script whose name
+        appears only in tests and inventory files.
+    """
+    if document_set.selection not in {SelectionKind.STAGED, SelectionKind.BASE}:
+        return ()
+    all_new_documents = tuple(
+        each_document
+        for each_document in document_set.documents
+        if _is_new_code_file(each_document)
+    )
+    if not all_new_documents:
+        return ()
+    all_caller_texts = _caller_texts(
+        document_set.repository_root,
+        frozenset(each_document.path for each_document in all_new_documents),
+    )
+    return tuple(
+        _uncalled_diagnostic(each_document)
+        for each_document in all_new_documents
+        if not _has_caller(each_document, all_caller_texts)
+    )

package/scripts/policy_lint/adapter_pairing.py

@@ -5,9 +5,10 @@ from collections import Counter
 from pathlib import PurePosixPath
 
 from . import adapter_support
+from .check_catalog import severity_for_check_id
 from .config import constants
 from .config.approved_test_pairs import APPROVED_TEST_PATHS_BY_PRODUCTION_PATH
-from .model import Diagnostic, Document, DocumentSet, Location, SelectionKind, Severity
+from .model import Diagnostic, Document, DocumentSet, Location, SelectionKind
 
 
 def _is_test_path(path: PurePosixPath) -> bool:
@@ -319,9 +320,10 @@ def _changed_test_paths(document_set: DocumentSet) -> frozenset[PurePosixPath]:
 def _pairing_diagnostic(document: Document) -> Diagnostic:
     return Diagnostic(
         "test-pairing",
-        Severity.ERROR,
+        severity_for_check_id("test-pairing"),
         "Changed production file has no changed matching test",
         Location(document.path, 1, 1),
+        "test-pairing",
     )
 
 

package/scripts/policy_lint/adapter_support.py

@@ -4,7 +4,7 @@ from collections.abc import Callable, Iterable
 from pathlib import Path
 from types import ModuleType
 
-from .check_catalog import check_id_for_message
+from .check_catalog import check_id_for_message, severity_for_check_id
 from .model import Diagnostic, Document, Location, Severity
 
 HookModuleLoader = Callable[[str], ModuleType]
@@ -69,13 +69,14 @@ def _diagnostics_for_messages(
         location = (
             None if maybe_line is None else Location(document.path, maybe_line, 1)
         )
+        check_id = check_id_for_message(rule_id, each_message)
         all_diagnostics.append(
             Diagnostic(
                 rule_id,
-                Severity.ERROR,
+                severity_for_check_id(check_id),
                 each_message,
                 location,
-                check_id_for_message(rule_id, each_message),
+                check_id,
             )
         )
     return tuple(all_diagnostics)

package/scripts/policy_lint/adapters.py

@@ -9,6 +9,7 @@ from types import ModuleType
 from shared_tree_paths import resolve_shared_scripts_directory
 
 from . import (
+    adapter_callers,
     adapter_configuration,
     adapter_contrast_framing,
     adapter_detectors,
@@ -245,6 +246,20 @@ def test_pairing_diagnostics(document_set: DocumentSet) -> tuple[Diagnostic, ...
     return adapter_pairing.test_pairing_diagnostics(document_set, _hooks_module)
 
 
+def uncalled_new_file_diagnostics(
+    document_set: DocumentSet,
+) -> tuple[Diagnostic, ...]:
+    """Report new code files that nothing outside their tests calls.
+
+    Args:
+        document_set: Staged or base change selection.
+
+    Returns:
+        One diagnostic for each uncalled new file.
+    """
+    return adapter_callers.uncalled_new_file_diagnostics(document_set)
+
+
 def terminology_diagnostics(document_set: DocumentSet) -> tuple[Diagnostic, ...]:
     """Report staged prose that near-misses a newly introduced identifier.
 

package/scripts/policy_lint/check_catalog.py

@@ -21,8 +21,12 @@ from .config.check_catalog_constants import (
     ALL_BUNDLING_RULE_IDS,
     ALL_CHECK_CATALOG_ENTRIES,
     CHECK_ID_SEPARATOR,
+    SEVERITY_BREAKING,
+    SEVERITY_BY_CHECK_ID,
+    SEVERITY_SMELL,
     UNCLASSIFIED_CHECK_NAME,
 )
+from .model import Severity
 
 
 def check_id_for_message(rule_id: str, message: str) -> str:
@@ -42,3 +46,23 @@ def check_id_for_message(rule_id: str, message: str) -> str:
         if each_entry.message_marker in message:
             return rule_id + CHECK_ID_SEPARATOR + each_entry.check_name
     return rule_id + CHECK_ID_SEPARATOR + UNCLASSIFIED_CHECK_NAME
+
+
+def severity_for_check_id(check_id: str) -> Severity:
+    """Return the severity ``SEVERITY_BY_CHECK_ID`` declares for one check.
+
+    ::
+
+        "code-rules/paired-test-missing-function" -> Severity.WARNING
+        "code-rules/unclassified"                 -> Severity.ERROR
+
+    Args:
+        check_id: The identifier ``check_id_for_message`` returned.
+
+    Returns:
+        ``Severity.WARNING`` for a smell, which the lint records and passes,
+        and ``Severity.ERROR`` for every other check.
+    """
+    if SEVERITY_BY_CHECK_ID.get(check_id, SEVERITY_BREAKING) == SEVERITY_SMELL:
+        return Severity.WARNING
+    return Severity.ERROR

package/scripts/policy_lint/config/approved_test_pairs.py

@@ -6,11 +6,11 @@ APPROVED_TEST_PATHS_BY_PRODUCTION_PATH: dict[
     PurePosixPath, frozenset[PurePosixPath]
 ] = {
     PurePosixPath(
-        ".cursor/skills/verify-claude-dev-env/scripts/verify_installer_constants/constants.mjs"
+        ".agents/skills/verify/scripts/verify_installer_constants/constants.mjs"
     ): frozenset(
         {
             PurePosixPath(
-                ".cursor/skills/verify-claude-dev-env/scripts/verify-installer.test.mjs"
+                ".agents/skills/verify/scripts/verify-installer.test.mjs"
             ),
         }
     ),
@@ -21,6 +21,7 @@ APPROVED_TEST_PATHS_BY_PRODUCTION_PATH: dict[
     ),
     PurePosixPath("packages/claude-dev-env/bin/install.mjs"): frozenset(
         {
+            PurePosixPath("packages/claude-dev-env/bin/install.agents-home.test.mjs"),
             PurePosixPath("packages/claude-dev-env/bin/install.cursor-rules.test.mjs"),
         }
     ),

package/scripts/policy_lint/config/check_catalog_constants.py

@@ -56,4 +56,17 @@ ALL_CHECK_CATALOG_ENTRIES: tuple[CheckCatalogEntry, ...] = (
         "missing type annotation (CODE_RULES §6)", "missing-type-annotation"
     ),
     CheckCatalogEntry("Single-letter variable", "single-letter-variable"),
+    CheckCatalogEntry(
+        "is exercised by no test in the module's paired test suite",
+        "paired-test-missing-function",
+    ),
+    CheckCatalogEntry("but exercises nowhere", "paired-test-omitted-function"),
 )
+
+SEVERITY_BREAKING: str = "breaking"
+SEVERITY_SMELL: str = "smell"
+SEVERITY_BY_CHECK_ID: dict[str, str] = {
+    "code-rules/paired-test-missing-function": SEVERITY_SMELL,
+    "code-rules/paired-test-omitted-function": SEVERITY_SMELL,
+    "test-pairing": SEVERITY_SMELL,
+}

package/scripts/policy_lint/config/constants.py

@@ -6,6 +6,7 @@ GIT_EXECUTABLE = "git"
 UTF8_ENCODING = "utf-8"
 PATH_SEPARATOR = "/"
 ARCHIVED_SKILLS_DIRECTORY_NAME = "skill-archive"
+ARCHIVED_HOOKS_DIRECTORY_NAME = "hooks-archived"
 NUL_BYTE = b"\0"
 ALL_GIT_ROOT_ARGUMENTS = ("rev-parse", "--show-toplevel")
 ALL_GIT_HEAD_ARGUMENTS = ("rev-parse", "--verify", "HEAD")
@@ -20,6 +21,7 @@ ALL_MISSING_BLOB_ERROR_FRAGMENTS = (
     "does not exist in",
     "does not exist (at stage",
     "exists on disk, but not in",
+    ": bad file",
 )
 GIT_DIFF_ARGUMENT = "diff"
 GIT_CACHED_FLAG = "--cached"
@@ -170,3 +172,19 @@ RETIRED_HOOK_PROSE_MESSAGE = (
 )
 
 CONTRAST_FRAMING_RULE_ID = "contrast-framing"
+
+UNCALLED_NEW_FILE_RULE_ID = "uncalled-new-file"
+UNCALLED_NEW_FILE_MESSAGE = (
+    "New file {file_name} has no caller outside its tests. Wire it into a hook,"
+    " workflow, skill, command or import in this change, or drop it."
+)
+ALL_CALLED_CODE_SUFFIXES = frozenset({".py", ".mjs", ".js", ".sh", ".ps1"})
+ALL_CALLED_CODE_SEGMENTS = ("/scripts/", "/hooks/", "/bin/")
+ALL_CALLER_SEARCH_SKIPPED_DIRECTORIES = frozenset(
+    {".git", "node_modules", "__pycache__", ".venv"}
+)
+ALL_INVENTORY_FILE_NAMES = frozenset(
+    {"CHANGELOG.md", "README.md", "ever-shipped-skills.mjs"}
+)
+ALL_UNCALLED_EXEMPT_FILE_NAMES = frozenset({"__init__.py", "conftest.py"})
+CALLER_NAME_PATTERN_TEMPLATE = r"(?<![\w-]){name}(?![\w-])"

package/scripts/policy_lint/engine.py

@@ -3,7 +3,10 @@ from __future__ import annotations
 from collections.abc import Iterable, Sequence
 from pathlib import Path, PurePosixPath
 
-from .config.constants import ARCHIVED_SKILLS_DIRECTORY_NAME
+from .config.constants import (
+    ARCHIVED_HOOKS_DIRECTORY_NAME,
+    ARCHIVED_SKILLS_DIRECTORY_NAME,
+)
 from .model import (
     ChangeSetRule,
     Diagnostic,
@@ -27,7 +30,7 @@ def lint(
     """Run the selected rules on one source selection.
 
     Repository and diff selections check active code. File and editor
-    selections include archived skills.
+    selections include archived skills and archived hooks.
 
     Args:
         request: Repository root, source, and rule sets.
@@ -55,7 +58,10 @@ def lint(
 
 
 def _is_runtime_path(path: PurePosixPath) -> bool:
-    return path.parts[0] != ARCHIVED_SKILLS_DIRECTORY_NAME
+    return (
+        path.parts[0] != ARCHIVED_SKILLS_DIRECTORY_NAME
+        and ARCHIVED_HOOKS_DIRECTORY_NAME not in path.parts
+    )
 
 
 def _runtime_document_set(document_set: DocumentSet) -> DocumentSet:

package/scripts/policy_lint/model.py

@@ -341,11 +341,15 @@ class LintReport:
         """Return the process exit code for this report.
 
         Returns:
-            Zero for clean output, one for findings, or three for rule failure.
+            Zero for clean output or warnings only, one for an error finding,
+            or three for rule failure.
         """
         if self.failed_rules:
             return INCOMPLETE_EXIT_CODE
-        if self.diagnostics:
+        if any(
+            each_diagnostic.severity is Severity.ERROR
+            for each_diagnostic in self.diagnostics
+        ):
             return 1
         return 0
 

package/scripts/policy_lint/registry.py

@@ -154,6 +154,12 @@ def default_registry() -> tuple[model.Rule, ...]:
             frozenset({model.SelectionKind.STAGED, model.SelectionKind.BASE}),
             adapters.terminology_diagnostics,
         ),
+        model.ChangeSetRule(
+            "uncalled-new-file",
+            frozenset({"changed"}),
+            frozenset({model.SelectionKind.STAGED, model.SelectionKind.BASE}),
+            adapters.uncalled_new_file_diagnostics,
+        ),
         model.RepositoryRule(
             "repository-path-collision",
             frozenset({"repository"}),

package/scripts/policy_lint/selection.py

@@ -205,6 +205,8 @@ def _append_change(
     all_renamed_paths: list[tuple[PurePosixPath, PurePosixPath]],
 ) -> None:
     old_path, new_path = all_paths if status[:1] in {"R", "C"} else (all_paths[0], all_paths[0])
+    if status != "D" and (repository_root / new_path).is_symlink():
+        return
     normalized_old_path = _normalize_path(repository_root, old_path)
     normalized_new_path = _normalize_path(repository_root, new_path)
     if status == "D":

package/scripts/tests/test_cde_lint.py

@@ -396,3 +396,53 @@ def test_should_emit_only_located_diagnostics_in_editor_format(
     assert exit_code == 1
     assert "src/app.py:4:2:" in stdout_text
     assert "unlocated finding" not in stdout_text
+
+
+def test_should_exit_zero_and_record_a_followup_when_only_warnings_exist(
+    tmp_path: Path,
+) -> None:
+    warning_report = LintReport(
+        1,
+        (
+            Diagnostic(
+                "code-rules",
+                Severity.WARNING,
+                "Line 4: paired test gap",
+                Location(PurePosixPath("src/app.py"), 4, 1),
+                "code-rules/paired-test-missing-function",
+            ),
+        ),
+        (PurePosixPath("src/app.py"),),
+        ("code-rules",),
+        (),
+        (),
+    )
+    exit_code, stdout_text, _stderr_text = _run_cli(
+        ["--files", "src/app.py"],
+        lint_runner=lambda _request: warning_report,
+        repository_root=tmp_path,
+    )
+    ledger_path = tmp_path / ".claude" / "followups" / "smells.jsonl"
+    all_ledger_records = [
+        json.loads(each_line)
+        for each_line in ledger_path.read_text(encoding="utf-8").splitlines()
+    ]
+    assert exit_code == 0
+    assert "paired test gap" in stdout_text
+    assert [each_record["check_id"] for each_record in all_ledger_records] == [
+        "code-rules/paired-test-missing-function"
+    ]
+    assert all_ledger_records[0]["file_path"] == "src/app.py"
+
+
+def test_should_leave_the_ledger_absent_when_every_finding_is_an_error(
+    tmp_path: Path,
+) -> None:
+    _run_cli(
+        ["--files", "src/app.py"],
+        lint_runner=lambda _request: LintReport(
+            1, (_located_diagnostic(),), (), ("rule-a",), (), ()
+        ),
+        repository_root=tmp_path,
+    )
+    assert not (tmp_path / ".claude" / "followups" / "smells.jsonl").exists()

package/scripts/tests/test_policy_lint_rules_archive.py

@@ -118,3 +118,19 @@ def test_retirement_and_restoration_preserve_live_change_metadata(tmp_path: Path
     assert tuple(document.path for document in runtime_set.documents) == (restored_path,)
     assert runtime_set.deleted_paths == (deleted_path, retired_path)
     assert runtime_set.renamed_paths == ((restored_source, restored_path),)
+
+
+def test_archived_hook_moves_leave_the_automatic_checks(tmp_path: Path) -> None:
+    live_hook_path = PurePosixPath("packages/tool/hooks/blocking/retired_gate.py")
+    archived_hook_path = PurePosixPath("packages/tool/hooks-archived/blocking/retired_gate.py")
+    document_set = DocumentSet(
+        (Document.from_text(archived_hook_path, "archived"),),
+        SelectionKind.BASE,
+        tmp_path,
+        (),
+        ((live_hook_path, archived_hook_path),),
+    )
+    runtime_set = _runtime_document_set(document_set)
+    assert runtime_set.documents == ()
+    assert runtime_set.deleted_paths == (live_hook_path,)
+    assert runtime_set.renamed_paths == ()

package/scripts/tests/test_policy_lint_rules_callers.py

@@ -0,0 +1,126 @@
+"""Tests for the uncalled-new-file rule over a change set."""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+from policy_lint import adapter_callers, registry
+from policy_lint.model import (
+    ChangeSetRule,
+    ContentOrigin,
+    Document,
+    DocumentSet,
+    SelectionKind,
+)
+
+_PACKAGE = "packages/claude-dev-env"
+_NEW_SCRIPT = f"{_PACKAGE}/scripts/lonely_watcher.py"
+
+
+def _write(repository_root: Path, relative_path: str, text: str) -> None:
+    target = repository_root / relative_path
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(text, "utf-8")
+
+
+def _added(relative_path: str, prior_text: str | None = None) -> Document:
+    return Document(
+        PurePosixPath(relative_path),
+        "print('hi')\n",
+        prior_text,
+        None,
+        ContentOrigin.REVISION_DIFF,
+    )
+
+
+def _messages(
+    repository_root: Path,
+    all_documents: tuple[Document, ...],
+    selection: SelectionKind = SelectionKind.BASE,
+) -> tuple[str, ...]:
+    document_set = DocumentSet(all_documents, selection, repository_root)
+    return tuple(
+        each_diagnostic.message
+        for each_diagnostic in adapter_callers.uncalled_new_file_diagnostics(
+            document_set
+        )
+    )
+
+
+def test_should_report_a_new_script_only_its_own_test_names(tmp_path: Path) -> None:
+    _write(tmp_path, _NEW_SCRIPT, "print('hi')\n")
+    _write(
+        tmp_path,
+        f"{_PACKAGE}/scripts/tests/test_lonely_watcher.py",
+        "import lonely_watcher\n",
+    )
+    _write(tmp_path, f"{_PACKAGE}/CHANGELOG.md", "added lonely_watcher\n")
+    _write(tmp_path, f"{_PACKAGE}/README.md", "| lonely_watcher | x |\n")
+    _write(tmp_path, f"{_PACKAGE}/bin/ever-shipped-skills.mjs", "'lonely_watcher'\n")
+
+    all_messages = _messages(tmp_path, (_added(_NEW_SCRIPT),))
+
+    assert len(all_messages) == 1
+    assert "lonely_watcher" in all_messages[0]
+
+
+def test_should_pass_a_new_script_a_workflow_runs(tmp_path: Path) -> None:
+    _write(tmp_path, _NEW_SCRIPT, "print('hi')\n")
+    _write(
+        tmp_path,
+        ".github/workflows/ci.yml",
+        f"run: python {_NEW_SCRIPT}\n",
+    )
+
+    assert _messages(tmp_path, (_added(_NEW_SCRIPT),)) == ()
+
+
+def test_should_pass_a_new_hook_that_hooks_json_registers(tmp_path: Path) -> None:
+    hook_path = f"{_PACKAGE}/hooks/advisory/quiet_guard.py"
+    _write(tmp_path, hook_path, "")
+    _write(
+        tmp_path,
+        f"{_PACKAGE}/hooks/hooks.json",
+        '{"command": "python hooks/advisory/quiet_guard.py"}',
+    )
+
+    assert _messages(tmp_path, (_added(hook_path),)) == ()
+
+
+def test_should_ignore_a_file_that_existed_before_the_change(tmp_path: Path) -> None:
+    _write(tmp_path, _NEW_SCRIPT, "print('hi')\n")
+
+    assert _messages(tmp_path, (_added(_NEW_SCRIPT, "old\n"),)) == ()
+
+
+def test_should_ignore_new_tests_and_files_outside_code_folders(
+    tmp_path: Path,
+) -> None:
+    test_path = f"{_PACKAGE}/scripts/tests/test_orphan.py"
+    rule_path = f"{_PACKAGE}/rules/orphan.md"
+    _write(tmp_path, test_path, "")
+    _write(tmp_path, rule_path, "")
+
+    assert _messages(tmp_path, (_added(test_path), _added(rule_path))) == ()
+
+
+def test_should_not_count_a_longer_name_that_contains_the_stem(
+    tmp_path: Path,
+) -> None:
+    _write(tmp_path, _NEW_SCRIPT, "print('hi')\n")
+    _write(tmp_path, f"{_PACKAGE}/scripts/runner.py", "import lonely_watcher_v2\n")
+
+    assert len(_messages(tmp_path, (_added(_NEW_SCRIPT),))) == 1
+
+
+def test_should_run_on_staged_and_base_selections() -> None:
+    uncalled_rule = next(
+        each_rule
+        for each_rule in registry.default_registry()
+        if each_rule.rule_id == "uncalled-new-file"
+    )
+
+    assert isinstance(uncalled_rule, ChangeSetRule)
+    assert uncalled_rule.selections == frozenset(
+        {SelectionKind.STAGED, SelectionKind.BASE}
+    )