claude-dev-env 7.4.1 → 7.6.0

package/scripts/claude_chain_runner.py

@@ -131,6 +131,8 @@ from dev_env_scripts_constants.claude_chain_constants import (
     UTF8_ENCODING,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 def _decode_captured_stream(raw_bytes: bytes, encoding: str, errors: str) -> str:
     """Decode captured *raw_bytes* with ``text=True`` universal-newline semantics.
@@ -222,6 +224,7 @@ def _run_captured_subprocess(
                     else None
                 ),
                 input=input_bytes,
+                creationflags=hidden_window_creation_flags(),
             )
         except subprocess.TimeoutExpired as timeout_error:
             _attach_partial_timeout_streams(

package/scripts/durable_post_lint_config/config/constants.py

@@ -55,10 +55,7 @@ CONVENTIONAL_TITLE_PATTERN: re.Pattern[str] = re.compile(
     rf"^(?:{'|'.join(ALL_CONVENTIONAL_TITLE_TYPES)})(?:\([^)\r\n]+\))?!?: [^\s].*$"
 )
 ALL_REQUIRED_PR_DESCRIPTION_HEADINGS: tuple[str, ...] = (
-    "Summary",
-    "Description",
     "Why",
-    "How",
     "Verification",
 )
 ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS: tuple[str, ...] = (

package/scripts/durable_post_lint_config/config/test_constants.py

@@ -4,6 +4,7 @@ from durable_post_lint_config.config.constants import (
     ALL_CONVENTIONAL_TITLE_TYPES,
     ALL_POST_ACTIONS,
     ALL_RELEASE_BODY_MARKERS,
+    ALL_REQUIRED_PR_DESCRIPTION_HEADINGS,
     CONVENTIONAL_TITLE_PATTERN,
     RELEASE_BRANCH_PREFIX,
 )
@@ -36,3 +37,7 @@ def should_carry_both_markers_release_automation_writes() -> None:
 
 def should_name_the_branch_prefix_release_automation_pushes() -> None:
     assert RELEASE_BRANCH_PREFIX == "release-please--branches--"
+
+
+def should_require_only_the_headings_both_pull_request_rule_sets_name() -> None:
+    assert ALL_REQUIRED_PR_DESCRIPTION_HEADINGS == ("Why", "Verification")

package/scripts/gh_artifact_upload.py

@@ -41,6 +41,8 @@ from dev_env_scripts_constants.gh_artifact_upload_constants import (
     UTF8_ENCODING,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 class ArtifactUploadError(Exception):
     """Raised when creating the release or uploading the asset fails."""
@@ -53,6 +55,7 @@ def _run_gh(all_arguments: list[str]) -> subprocess.CompletedProcess[str]:
         text=True,
         encoding=UTF8_ENCODING,
         check=False,
+        creationflags=hidden_window_creation_flags(),
     )
 
 

package/scripts/grok_headless_runner.py

@@ -85,6 +85,8 @@ from process_tree_kill import (  # noqa: E402
     terminate_process_tree,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 runner_popen = subprocess.Popen
 
 
@@ -361,6 +363,7 @@ def _invoke_process(
             encoding=UTF8_ENCODING,
             errors=UTF8_DECODE_ERRORS,
             start_new_session=should_start_new_session(),
+            creationflags=hidden_window_creation_flags(),
         )
     except FileNotFoundError:
         return _missing_binary_outcome()

package/scripts/grok_patch_artifacts.py

@@ -27,6 +27,8 @@ from dev_env_scripts_constants.grok_run_ledger_constants import (
     UTF8_ENCODING,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 def compute_sha256_hex(content: bytes) -> str:
     """Return the hex SHA-256 digest of raw bytes.
@@ -58,11 +60,13 @@ def extract_worktree_diff(
         ["git", "-C", str(worktree_path), "diff", base_sha],
         text=True,
         encoding=UTF8_ENCODING,
+        creationflags=hidden_window_creation_flags(),
     )
     changed_paths_listing = subprocess.check_output(
         ["git", "-C", str(worktree_path), "diff", "--name-only", base_sha],
         text=True,
         encoding=UTF8_ENCODING,
+        creationflags=hidden_window_creation_flags(),
     )
     changed_paths = tuple(
         each_line.strip()

package/scripts/grok_worker_preflight.py

@@ -90,6 +90,8 @@ from dev_env_scripts_constants.grok_worker_constants import (
     UTF8_ENCODING,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 preflight_which = shutil.which
 preflight_subprocess_runner = subprocess.run
 preflight_time = time.time
@@ -259,6 +261,7 @@ def _run_grok_command(
             errors=UTF8_DECODE_ERRORS,
             timeout=timeout_seconds,
             check=False,
+            creationflags=hidden_window_creation_flags(),
         )
     except OSError:
         return None

package/scripts/invoke_code_review.py

@@ -104,6 +104,8 @@ from dev_env_scripts_constants.timing import (  # noqa: E402
     DEFAULT_CODE_REVIEW_TIMEOUT_SECONDS,
 )
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 @dataclass(frozen=True)
 class CodeReviewOutcome:
@@ -265,6 +267,7 @@ def is_working_tree_dirty(working_directory: Path) -> bool:
         capture_output=True,
         text=True,
         check=False,
+        creationflags=hidden_window_creation_flags(),
     )
     if completion.returncode != 0:
         return True

package/scripts/local_verification/command_runner.py

@@ -11,6 +11,8 @@ from .config import (
 )
 from .model import CommandCapture
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 def run_command(
     all_arguments: tuple[str, ...], check_directory: Path, timeout_seconds: float
@@ -73,6 +75,7 @@ def _run_subprocess(
         encoding=UTF8_ENCODING,
         errors="replace",
         timeout=timeout_seconds,
+        creationflags=hidden_window_creation_flags(),
     )
 
 

package/scripts/local_verification/git_state.py

@@ -23,6 +23,8 @@ from .config import (
 )
 from .config.timing import GIT_METADATA_TIMEOUT_SECONDS
 
+from subprocess_window_access import hidden_window_creation_flags
+
 
 @dataclass(frozen=True)
 class CandidateSnapshot:
@@ -82,6 +84,7 @@ def _run_git_bytes(
             capture_output=True,
             check=False,
             timeout=GIT_METADATA_TIMEOUT_SECONDS,
+            creationflags=hidden_window_creation_flags(),
         )
     except (OSError, subprocess.SubprocessError):
         return None

package/scripts/policy_lint/adapter_configuration.py

@@ -121,7 +121,31 @@ def _registered_nested_strings(each_entry: object) -> tuple[str, ...]:
     return tuple(all_registered_strings)
 
 
+def _names_exempt_registration_path(registered_string: str) -> bool:
+    """Return True when the registration names a chain that decides no policy.
+
+    ::
+
+        hooks/blocking/bash_pre_tool_use_dispatcher.py   -> exempt
+        hooks/blocking/some_new_blocker.py               -> flagged
+
+    The Bash PreToolUse dispatcher sits under ``blocking/`` for layout reasons
+    while its roster hosts one allow-and-rewrite hook. Its path segment reads as
+    a policy boundary that the chain never carries.
+
+    Args:
+        registered_string: One command, path, script, or entrypoint string.
+    """
+    path_shaped_string = registered_string.lower().replace("\\", "/")
+    return any(
+        each_exempt_path in path_shaped_string
+        for each_exempt_path in constants.ALL_ACTION_BOUNDARY_EXEMPT_REGISTRATION_PATHS
+    )
+
+
 def _contains_action_boundary_marker(registered_string: str) -> bool:
+    if _names_exempt_registration_path(registered_string):
+        return False
     normalized_string = registered_string.lower().replace("\\", "/")
     normalized_string = normalized_string.replace(".", "/").replace("-", "/")
     return any(

package/scripts/policy_lint/adapter_detectors.py

@@ -4,6 +4,7 @@ from collections.abc import Iterable
 from contextlib import redirect_stderr, redirect_stdout
 from io import StringIO
 from pathlib import Path, PurePosixPath
+from types import ModuleType
 
 from . import adapter_support
 from .config import constants
@@ -118,10 +119,49 @@ def validator_diagnostics(
     return adapter_support._diagnostics_for_messages(document, "validators", all_messages)
 
 
+def _is_untouched_function(
+    message: str, all_changed_lines: frozenset[int], scoping_module: ModuleType
+) -> bool:
+    span_range = scoping_module.function_length_span_range(message)
+    return span_range is not None and all_changed_lines.isdisjoint(span_range)
+
+
+def _change_scoped_messages(
+    all_messages: Iterable[str],
+    document: Document,
+    load_pr_loop_module: adapter_support.HookModuleLoader,
+) -> tuple[str, ...]:
+    """Drop function-length messages for functions the change never touched.
+
+    ::
+
+        an import added above an existing long ``main`` -> dropped
+        a statement added inside that ``main``          -> kept
+
+    Args:
+        all_messages: Every message the code-rule engine returned.
+        document: Current document and the lines this change touched.
+        load_pr_loop_module: Loader for the shared pull-request-loop scripts.
+
+    Returns:
+        The messages that remain in scope for this change.
+    """
+    all_changed_lines = document.changed_lines
+    if all_changed_lines is None:
+        return tuple(all_messages)
+    scoping_module = load_pr_loop_module(constants.VIOLATION_SCOPING_MODULE_NAME)
+    return tuple(
+        each_message
+        for each_message in all_messages
+        if not _is_untouched_function(each_message, all_changed_lines, scoping_module)
+    )
+
+
 def code_rule_diagnostics(
     document: Document,
     repository_root: Path,
     load_module: adapter_support.HookModuleLoader,
+    load_pr_loop_module: adapter_support.HookModuleLoader,
 ) -> tuple[Diagnostic, ...]:
     """Run the code-rule engine on one document.
 
@@ -129,9 +169,10 @@ def code_rule_diagnostics(
         document: Current text and optional prior text.
         repository_root: Request repository root for sibling-file resolution.
         load_module: Hook module loader.
+        load_pr_loop_module: Loader for the shared pull-request-loop scripts.
 
     Returns:
-        Diagnostics from the code-rule engine.
+        Diagnostics from the code-rule engine, scoped to the change.
     """
     absolute_path = adapter_support._document_path(repository_root, document)
     legacy_module = load_module("blocking.code_rules_enforcer")
@@ -146,7 +187,12 @@ def code_rule_diagnostics(
             sibling_directory=absolute_path.parent,
             include_comment_policy=True,
         )
-    return adapter_support._diagnostics_for_messages(document, "code-rules", all_messages)
+    all_scoped_messages = _change_scoped_messages(
+        all_messages, document, load_pr_loop_module
+    )
+    return adapter_support._diagnostics_for_messages(
+        document, "code-rules", all_scoped_messages
+    )
 
 
 def state_description_diagnostics(

package/scripts/policy_lint/adapter_pairing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import ast
+from collections import Counter
 from pathlib import PurePosixPath
 
 from . import adapter_support
@@ -52,12 +53,19 @@ def _remove_docstrings(parsed_tree: ast.AST) -> None:
         _remove_docstrings(each_child)
 
 
-def _ast_without_docstrings(source_text: str) -> str | None:
+def _parsed_without_docstrings(source_text: str) -> ast.Module | None:
     try:
         parsed_tree = ast.parse(source_text)
-    except SyntaxError:
+    except (SyntaxError, ValueError):
         return None
     _remove_docstrings(parsed_tree)
+    return parsed_tree
+
+
+def _ast_without_docstrings(source_text: str) -> str | None:
+    parsed_tree = _parsed_without_docstrings(source_text)
+    if parsed_tree is None:
+        return None
     return ast.dump(parsed_tree, include_attributes=False)
 
 
@@ -71,6 +79,144 @@ def _is_docstring_only_python_document(document: Document) -> bool:
     return current_ast is not None and current_ast == prior_ast
 
 
+def _is_import_statement(node: object) -> bool:
+    return isinstance(node, (ast.Import, ast.ImportFrom))
+
+
+def _dumped_import_tally(all_nodes: list[object]) -> Counter[str]:
+    return Counter(
+        ast.dump(each_node, include_attributes=False)
+        for each_node in all_nodes
+        if isinstance(each_node, ast.AST) and _is_import_statement(each_node)
+    )
+
+
+def _matches_positional_list(
+    all_current_nodes: list[object], all_prior_nodes: list[object]
+) -> bool:
+    if len(all_current_nodes) != len(all_prior_nodes):
+        return False
+    return all(
+        _matches_field(each_current_node, each_prior_node)
+        for each_current_node, each_prior_node in zip(
+            all_current_nodes, all_prior_nodes, strict=True
+        )
+    )
+
+
+def _matches_statement_list(
+    all_current_nodes: list[object], all_prior_nodes: list[object]
+) -> bool:
+    if _dumped_import_tally(all_prior_nodes) - _dumped_import_tally(all_current_nodes):
+        return False
+    return _matches_positional_list(
+        [
+            each_node
+            for each_node in all_current_nodes
+            if not _is_import_statement(each_node)
+        ],
+        [
+            each_node
+            for each_node in all_prior_nodes
+            if not _is_import_statement(each_node)
+        ],
+    )
+
+
+def _is_statement_list(all_nodes: list[object]) -> bool:
+    return all(isinstance(each_node, ast.stmt) for each_node in all_nodes)
+
+
+def _matches_node_list(
+    all_current_nodes: list[object], all_prior_nodes: list[object]
+) -> bool:
+    if _is_statement_list(all_current_nodes) and _is_statement_list(all_prior_nodes):
+        return _matches_statement_list(all_current_nodes, all_prior_nodes)
+    return _matches_positional_list(all_current_nodes, all_prior_nodes)
+
+
+def _matches_field(current_field: object, prior_field: object) -> bool:
+    if isinstance(current_field, ast.AST) and isinstance(prior_field, ast.AST):
+        return _matches_node(current_field, prior_field)
+    if isinstance(current_field, list) and isinstance(prior_field, list):
+        return _matches_node_list(current_field, prior_field)
+    if type(current_field) is not type(prior_field):
+        return False
+    return bool(current_field == prior_field)
+
+
+def _matches_keyword(current_keyword: ast.keyword, prior_keyword: ast.keyword) -> bool:
+    return current_keyword.arg == prior_keyword.arg and _matches_node(
+        current_keyword.value, prior_keyword.value
+    )
+
+
+def _keywords_after_match(
+    all_candidate_keywords: list[ast.keyword], prior_keyword: ast.keyword
+) -> list[ast.keyword] | None:
+    for each_index, each_candidate_keyword in enumerate(all_candidate_keywords):
+        if _matches_keyword(each_candidate_keyword, prior_keyword):
+            return all_candidate_keywords[each_index + 1 :]
+    return None
+
+
+def _prior_keywords_survive(
+    all_current_keywords: list[ast.keyword], all_prior_keywords: list[ast.keyword]
+) -> bool:
+    all_remaining_keywords: list[ast.keyword] | None = list(all_current_keywords)
+    for each_prior_keyword in all_prior_keywords:
+        if all_remaining_keywords is None:
+            return False
+        all_remaining_keywords = _keywords_after_match(
+            all_remaining_keywords, each_prior_keyword
+        )
+    return all_remaining_keywords is not None
+
+
+def _mapping_unpacking_count(all_keywords: list[ast.keyword]) -> int:
+    return sum(1 for each_keyword in all_keywords if each_keyword.arg is None)
+
+
+def _matches_call(current_call: ast.Call, prior_call: ast.Call) -> bool:
+    if not _matches_node(current_call.func, prior_call.func):
+        return False
+    if not _matches_positional_list(list(current_call.args), list(prior_call.args)):
+        return False
+    if _mapping_unpacking_count(current_call.keywords) != _mapping_unpacking_count(
+        prior_call.keywords
+    ):
+        return False
+    return _prior_keywords_survive(
+        list(current_call.keywords), list(prior_call.keywords)
+    )
+
+
+def _matches_node(current_node: ast.AST, prior_node: ast.AST) -> bool:
+    if type(current_node) is not type(prior_node):
+        return False
+    if isinstance(current_node, ast.Call) and isinstance(prior_node, ast.Call):
+        return _matches_call(current_node, prior_node)
+    return all(
+        _matches_field(
+            getattr(current_node, each_field_name, None),
+            getattr(prior_node, each_field_name, None),
+        )
+        for each_field_name in current_node._fields
+    )
+
+
+def _is_import_and_keyword_addition_python_document(document: Document) -> bool:
+    if document.path.suffix.lower() != constants.PYTHON_SUFFIX:
+        return False
+    if document.prior_text is None:
+        return False
+    current_tree = _parsed_without_docstrings(document.text)
+    prior_tree = _parsed_without_docstrings(document.prior_text)
+    if current_tree is None or prior_tree is None:
+        return False
+    return _matches_node(current_tree, prior_tree)
+
+
 def _candidate_test_names(path: PurePosixPath) -> frozenset[str]:
     stem = path.stem
     suffix = path.suffix.lower()
@@ -157,6 +303,8 @@ def _is_unpaired_production(
         return False
     if _is_docstring_only_python_document(production_document):
         return False
+    if _is_import_and_keyword_addition_python_document(production_document):
+        return False
     return not _has_changed_test(production_path, all_changed_test_paths)
 
 

package/scripts/policy_lint/adapter_retired_hook_prose.py

@@ -0,0 +1,201 @@
+"""Detect rules prose that credits a hook module which runs nowhere.
+
+A hook module runs when ``hooks/hooks.json`` registers it or a dispatcher
+roster hosts it. A module that survives on disk while appearing in neither
+one reaches no tool call, so prose that gives it a present-tense action
+describes a gate the reader never faces.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path, PurePosixPath
+
+from .config import constants
+from .model import Diagnostic, Document, Location, Severity
+
+
+def accepts_rules_markdown(document: Document) -> bool:
+    """Return whether the document is Markdown in a rules directory.
+
+    Args:
+        document: Candidate document.
+
+    Returns:
+        True for a Markdown file directly under a ``rules`` directory.
+    """
+    return (
+        document.path.suffix.lower() in constants.ALL_MARKDOWN_SUFFIXES
+        and document.path.parent.name == constants.RULES_DIRECTORY_NAME
+    )
+
+
+def _package_root(repository_root: Path, document: Document) -> Path:
+    return repository_root / document.path.parent.parent.as_posix()
+
+
+def _read_text(path: Path) -> str:
+    if not path.is_file():
+        return ""
+    return path.read_text(
+        encoding="utf-8", errors=constants.REPLACEMENT_CHARACTER_ERRORS
+    )
+
+
+def _registered_hook_stems(hooks_root: Path) -> frozenset[str]:
+    all_stems = set(
+        re.findall(
+            constants.HOOKS_JSON_PATH_PATTERN,
+            _read_text(hooks_root / constants.HOOKS_CONFIGURATION_FILE_NAME),
+        )
+    )
+    constants_root = hooks_root / constants.HOOK_CONSTANTS_DIRECTORY_NAME
+    if constants_root.is_dir():
+        for each_path in sorted(
+            constants_root.glob(constants.DISPATCHER_CONSTANTS_GLOB)
+        ):
+            all_stems.update(
+                PurePosixPath(each_relative_path).stem
+                for each_relative_path in re.findall(
+                    constants.QUOTED_HOOK_PATH_PATTERN, _read_text(each_path)
+                )
+            )
+    return frozenset(all_stems)
+
+
+def _present_hook_stems(hooks_root: Path) -> frozenset[str]:
+    if not hooks_root.is_dir():
+        return frozenset()
+    return frozenset(
+        each_path.stem for each_path in hooks_root.rglob(constants.PYTHON_GLOB)
+    )
+
+
+def _retired_roster_stems(package_root: Path) -> frozenset[str]:
+    installer_path = package_root.joinpath(*constants.ALL_INSTALLER_PATH_SEGMENTS)
+    maybe_roster = re.search(
+        constants.RETIRED_ROSTER_PATTERN, _read_text(installer_path)
+    )
+    if maybe_roster is None:
+        return frozenset()
+    return frozenset(
+        PurePosixPath(each_relative_path).stem
+        for each_relative_path in re.findall(
+            constants.QUOTED_HOOK_PATH_PATTERN, maybe_roster.group(1)
+        )
+    )
+
+
+def _hook_stem_in_span(span_text: str) -> str | None:
+    candidate_name = (
+        span_text.strip()
+        .rsplit(constants.PATH_SEPARATOR, 1)[-1]
+        .removesuffix(constants.PYTHON_SUFFIX)
+    )
+    if not re.fullmatch(constants.HOOK_MODULE_NAME_PATTERN, candidate_name):
+        return None
+    if not candidate_name.endswith(constants.ALL_HOOK_MODULE_NAME_SUFFIXES):
+        return None
+    return candidate_name
+
+
+def _names_a_live_action(segment_text: str) -> bool:
+    return any(
+        each_word in constants.ALL_LIVE_CLAIM_VERBS
+        for each_word in re.findall(
+            constants.PROSE_WORD_PATTERN, segment_text.lower()
+        )
+    )
+
+
+def _describes_a_replacement(line_text: str) -> bool:
+    normalized_line = line_text.lower()
+    return any(
+        each_phrase in normalized_line
+        for each_phrase in constants.ALL_REPLACEMENT_DELIVERY_PHRASES
+    )
+
+
+def _claim_segment_end(
+    line_text: str, all_spans: tuple[re.Match[str], ...], span_index: int
+) -> int:
+    maybe_sentence_end = re.compile(constants.SENTENCE_BOUNDARY_PATTERN).search(
+        line_text, all_spans[span_index].end()
+    )
+    segment_end = (
+        len(line_text) if maybe_sentence_end is None else maybe_sentence_end.start()
+    )
+    for each_span in all_spans[span_index + 1 :]:
+        if each_span.start() >= segment_end:
+            break
+        if _hook_stem_in_span(each_span.group(1)) is not None:
+            return each_span.start()
+    return segment_end
+
+
+def _line_diagnostics(
+    document: Document,
+    line_text: str,
+    line_number: int,
+    all_known_stems: frozenset[str],
+    all_registered_stems: frozenset[str],
+) -> tuple[Diagnostic, ...]:
+    all_spans = tuple(re.finditer(constants.INLINE_CODE_PATTERN, line_text))
+    all_diagnostics: list[Diagnostic] = []
+    for each_index, each_span in enumerate(all_spans):
+        maybe_stem = _hook_stem_in_span(each_span.group(1))
+        if maybe_stem is None or maybe_stem not in all_known_stems:
+            continue
+        if maybe_stem in all_registered_stems:
+            continue
+        claim_end = _claim_segment_end(line_text, all_spans, each_index)
+        if not _names_a_live_action(line_text[each_span.end() : claim_end]):
+            continue
+        all_diagnostics.append(
+            Diagnostic(
+                constants.RETIRED_HOOK_PROSE_RULE_ID,
+                Severity.ERROR,
+                constants.RETIRED_HOOK_PROSE_MESSAGE.format(hook_name=maybe_stem),
+                Location(document.path, line_number, each_span.start() + 1),
+            )
+        )
+    return tuple(all_diagnostics)
+
+
+def _hook_stem_sets(package_root: Path) -> tuple[frozenset[str], frozenset[str]]:
+    hooks_root = package_root / constants.HOOKS_DIRECTORY_NAME
+    all_known_stems = _present_hook_stems(hooks_root) | _retired_roster_stems(
+        package_root
+    )
+    return all_known_stems, _registered_hook_stems(hooks_root)
+
+
+def retired_hook_prose_diagnostics(
+    document: Document, repository_root: Path
+) -> tuple[Diagnostic, ...]:
+    """Report rules prose that credits an unregistered hook with a live action.
+
+    Args:
+        document: Current rules Markdown text and path.
+        repository_root: Request repository root for package resolution.
+
+    Returns:
+        One diagnostic for each live claim about a hook that runs nowhere.
+    """
+    all_known_stems, all_registered_stems = _hook_stem_sets(
+        _package_root(repository_root, document)
+    )
+    all_diagnostics: list[Diagnostic] = []
+    for each_line_number, each_line in enumerate(document.text.splitlines(), 1):
+        if _describes_a_replacement(each_line):
+            continue
+        all_diagnostics.extend(
+            _line_diagnostics(
+                document,
+                each_line,
+                each_line_number,
+                all_known_stems,
+                all_registered_stems,
+            )
+        )
+    return tuple(all_diagnostics)