claude-dev-env 2.36.0 → 4.0.0

package/_shared/advisor/scripts/tests/test_tier_model_ids.py

@@ -105,10 +105,19 @@ def test_sendmessage_reply_wait_is_positive_bound() -> None:
     assert ADVISOR_SENDMESSAGE_REPLY_WAIT_SECONDS == 120
 
 
-def test_resolve_codex_model_id_maps_sol() -> None:
-    assert resolve_codex_model_id(f" {ADVISOR_MODEL_TIER.lower()} ") == (
-        ADVISOR_CODEX_MODEL_ID
-    )
+@pytest.mark.parametrize("tier_name", ["Astra", "astra", "ASTRA", " Astra "])
+def test_resolve_codex_model_id_maps_astra(tier_name: str) -> None:
+    assert resolve_codex_model_id(tier_name) == "gpt-6-astra"
+
+
+def test_resolve_codex_model_id_rejects_old_sol_tier() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_codex_model_id("Sol")
+
+
+def test_resolve_cli_model_id_rejects_astra_as_a_claude_alias() -> None:
+    with pytest.raises(ValueError, match="not a known model tier"):
+        resolve_cli_model_id("Astra")
 
 
 def test_resolve_codex_model_id_rejects_claude_tier() -> None:
@@ -132,6 +141,7 @@ def test_cli_model_alias_map_keys_match_known_tiers() -> None:
 def test_canonical_tier_name_strips_and_normalizes() -> None:
     assert canonical_tier_name(" opus ") == "Opus"
     assert canonical_tier_name("thirdparty") == "ThirdParty"
+    assert canonical_tier_name(" astra ") == "Astra"
     assert canonical_tier_name("") is None
     assert canonical_tier_name("Titan") is None
 

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

@@ -109,6 +109,20 @@ ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND: tuple[str, ...] = (
 
 GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS: int = 30
 
+GIT_NO_MATCH_EXIT_CODE: int = 1
+
+GIT_OPERATION_FAILURE_TEMPLATE: str = "{operation} failed: {details}"
+
+GIT_DIFF_OPERATION: str = "git diff --cached"
+
+GIT_GREP_OPERATION_TEMPLATE: str = "git grep for {identifier}"
+
+GIT_FAILURE_WITHOUT_DETAILS: str = "no diagnostic text"
+
+GIT_TEXT_ENCODING: str = "utf-8"
+
+GIT_DECODE_ERRORS: str = "replace"
+
 TERMINOLOGY_SWEEP_GATE_HEADER: str = (
     "terminology_sweep: {finding_count} cross-surface terminology near-miss(es) "
     "on staged prose:"

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

@@ -1,7 +1,7 @@
 """Flag a prose term that names a code identifier a hair differently.
 
 A change adds the field ``premium_request_interactions`` while the same
-branch's docs call it the ``premium-request-budget`` field: one thing, two
+branch's docs call it the ``premium-request-budget`` field. One thing, two
 names, and a reader who searches one never finds the other.
 
 ::
@@ -14,38 +14,29 @@ names, and a reader who searches one never finds the other.
 
 The sweep reads a unified diff, collects the multi-word identifiers added on
 code lines, and scans each added prose line for a hyphen or space variant that
-renames only the final word of an identifier: it agrees on every earlier word
-and differs on the last. A term that diverges in any earlier word, or shares
-only one leading word, is ordinary prose. It also spares English compound
-tails, singular/plural forms, stopword windows, and words that are themselves
-tokens of another introduced identifier.
+renames only the final word of an identifier. The variant agrees on every
+earlier word and differs on the last. A term that diverges in any earlier
+word, or shares only one leading word, is ordinary prose. It also spares
+English compound tails, singular/plural forms, stopword windows, and words
+that are themselves tokens of another introduced identifier.
 """
 
 import argparse
 import os
 import subprocess
 import sys
+from collections.abc import Sequence
 from pathlib import Path
 
-parent_directory = str(Path(__file__).resolve().parent)
-if parent_directory not in sys.path:
-    sys.path.insert(0, parent_directory)
-
-from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
+from pr_loop_shared_constants.terminology_sweep_constants import (
     ALL_COMMON_ENGLISH_COMPOUND_TAIL_WORDS,
+    ALL_DIFF_FILE_PATH_STRIP_PREFIXES,
+    ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND,
     ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
     ALL_PROSE_STOPWORD_TOKENS,
     ALL_STRING_ESCAPE_SEQUENCES,
-    ALL_TEST_FILE_NAME_INFIX_MARKERS,
-    GIT_BASE_TREE_REVISION,
-    IDENTIFIER_TOKEN_SEPARATOR,
-    PROSE_WINDOW_WORD_SEPARATOR,
-    TEST_DIRECTORY_PATH_SEGMENT,
-    TEST_FILE_PREFIX,
-    TEST_FILE_SUFFIX,
-    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,
@@ -55,19 +46,32 @@ from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
     DIFF_NEW_FILE_HEADER_PREFIX,
     DIFF_OLD_FILE_HEADER_PREFIX,
     DIFF_REMOVED_LINE_PREFIX,
+    GIT_BASE_TREE_REVISION,
+    GIT_DECODE_ERRORS,
+    GIT_DIFF_OPERATION,
     GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS,
+    GIT_FAILURE_WITHOUT_DETAILS,
+    GIT_GREP_OPERATION_TEMPLATE,
+    GIT_NO_MATCH_EXIT_CODE,
+    GIT_OPERATION_FAILURE_TEMPLATE,
+    GIT_TEXT_ENCODING,
     HYPHENATED_PROSE_TOKEN_PATTERN,
+    IDENTIFIER_TOKEN_SEPARATOR,
     INLINE_CODE_SPAN_PATTERN,
     JAVASCRIPT_LINE_COMMENT_MARKER,
     JSDOC_CONTINUATION_MARKER,
     MARKDOWN_FILE_EXTENSION,
     MINIMUM_IDENTIFIER_TOKEN_COUNT,
+    PROSE_WINDOW_WORD_SEPARATOR,
     PROSE_WORD_PATTERN,
     PYTHON_COMMENT_MARKER,
     SNAKE_CASE_IDENTIFIER_PATTERN,
     STRING_LITERAL_CONTENT_PATTERN,
     TERMINOLOGY_FINDING_TEMPLATE,
     TERMINOLOGY_SWEEP_DESCRIPTION,
+    TEST_DIRECTORY_PATH_SEGMENT,
+    TEST_FILE_PREFIX,
+    TEST_FILE_SUFFIX,
 )
 
 IdentifierTuple = tuple[str, ...]
@@ -173,8 +177,8 @@ def _prose_fragments(file_path: str, line_text: str) -> list[str]:
     A Markdown line is prose with its inline-code spans removed, since a
     backticked span names code verbatim. A code line contributes its comment
     tail, its JSDoc continuation text, and the contents of its string
-    literals. A test module contributes its comment tail and JSDoc text only
-    — its string literals hold fixture data, not prose.
+    literals. A test module contributes its comment tail and JSDoc text only.
+    Its string literals hold fixture data, not prose.
 
     Args:
         file_path: The path the added line belongs to.
@@ -201,9 +205,9 @@ def _prose_fragments(file_path: str, line_text: str) -> list[str]:
 def _is_test_file(file_path: str) -> bool:
     """Return whether a diff path names a test code module.
 
-    A test module's string literals hold fixture data — embedded diffs,
-    generated source, file trees — not documentation prose, so the sweep
-    reads only its comments and JSDoc lines. A ``quota.test.mjs``, a
+    A test module's string literals hold fixture data: embedded diffs,
+    generated source, and file trees. That is not documentation prose, so the
+    sweep reads only its comments and JSDoc lines. A ``quota.test.mjs``, a
     ``layout.spec.ts``, and a ``fixtures.py`` under a tests directory are all
     test modules, so every one of these paths counts::
 
@@ -260,8 +264,8 @@ def _string_literal_fragments(line_text: str) -> list[str]:
     Escape sequences inside a literal (``\\n``, ``\\t``) are replaced with
     spaces before the words are read, so an escape letter never glues onto a
     neighbouring word as a phantom prose term. A literal left with no
-    whitespace after that replacement is an identifier-shaped value — a UID,
-    a key, a path — not prose, and contributes nothing.
+    whitespace after that replacement is an identifier-shaped value: a UID,
+    a key, or a path. It is not prose, and contributes nothing.
     """
     all_fragments: list[str] = []
     for each_match in STRING_LITERAL_CONTENT_PATTERN.finditer(line_text):
@@ -413,9 +417,7 @@ def _word_is_identifier_vocabulary(
         return True
     if prose_word.endswith("es") and prose_word[:-2] in all_identifier_tokens:
         return True
-    if prose_word.endswith("ies") and prose_word[:-3] + "y" in all_identifier_tokens:
-        return True
-    return False
+    return prose_word.endswith("ies") and prose_word[:-3] + "y" in all_identifier_tokens
 
 
 def _near_miss_identifier(
@@ -525,22 +527,8 @@ def _findings_for_line(
     return all_findings
 
 
-def sweep_diff(
-    diff_text: str,
-    all_preexisting_identifier_tuples: frozenset[IdentifierTuple] = frozenset(),
-) -> list[str]:
-    """Return every terminology near-miss finding for a unified diff.
-
-    Args:
-        diff_text: The unified-diff text to sweep.
-        all_preexisting_identifier_tuples: Token tuples of added-line identifiers
-            the base tree already names. A pre-existing identifier is not one
-            the diff introduces, so no prose is flagged against it. Its
-            tokens still count as code vocabulary.
-
-    Returns:
-        One finding string per near-miss term on an added prose line.
-    """
+def _find_terminology_near_misses(
+    diff_text: str, all_preexisting_identifier_tuples: frozenset[IdentifierTuple]) -> list[str]:
     all_added_lines = _parse_added_lines(diff_text)
     all_identifier_tuples = _collect_introduced_identifiers(all_added_lines)
     all_identifier_tokens = frozenset(
@@ -571,6 +559,27 @@ def sweep_diff(
     return all_findings
 
 
+def sweep_diff(
+    diff_text: str,
+    all_preexisting_identifier_tuples: frozenset[IdentifierTuple] = frozenset(),
+) -> list[str]:
+    """Return every terminology near-miss finding for a unified diff.
+
+    Args:
+        diff_text: The unified-diff text to sweep.
+        all_preexisting_identifier_tuples: Token tuples of added-line identifiers
+            the base tree already names. A pre-existing identifier is not one
+            the diff introduces, so no prose is flagged against it. Its
+            tokens still count as code vocabulary.
+
+    Returns:
+        One finding string per near-miss term on an added prose line.
+    """
+    return _find_terminology_near_misses(
+        diff_text, all_preexisting_identifier_tuples
+    )
+
+
 def repository_environment() -> dict[str, str]:
     """Return the process environment with every GIT_ variable removed.
 
@@ -619,8 +628,8 @@ def _base_tree_names(
 
     Each name is looked up as a whole word in the base revision's tree. A
     repository with no commits yet, or a lookup that git cannot run, reports
-    the name as absent, so the sweep then treats it as newly introduced —
-    the behaviour the sweep has with no base-tree check at all.
+    the name as absent, so the sweep then treats it as newly introduced.
+    That is the behaviour the sweep has with no base-tree check at all.
 
     Args:
         repository_root: The repository root the lookups run in.
@@ -652,11 +661,90 @@ def _base_tree_names(
     return frozenset(all_present_names)
 
 
+def _run_strict_git(
+    repository_root: Path, all_arguments: Sequence[str]
+) -> subprocess.CompletedProcess[str]:
+    try:
+        return subprocess.run(
+            list(all_arguments),
+            cwd=str(repository_root),
+            capture_output=True,
+            text=True,
+            encoding=GIT_TEXT_ENCODING,
+            errors=GIT_DECODE_ERRORS,
+            timeout=GIT_DIFF_SUBPROCESS_TIMEOUT_SECONDS,
+            check=False,
+            env=repository_environment(),
+        )
+    except (subprocess.TimeoutExpired, OSError) as e:
+        raise RuntimeError(str(e)) from e
+
+
+def _raise_for_git_failure(
+    git_process: subprocess.CompletedProcess[str], operation: str
+) -> None:
+    if git_process.returncode == 0:
+        return
+    details = git_process.stderr.strip() or git_process.stdout.strip()
+    raise RuntimeError(
+        GIT_OPERATION_FAILURE_TEMPLATE.format(
+            operation=operation,
+            details=details or GIT_FAILURE_WITHOUT_DETAILS,
+        )
+    )
+
+
+def _strict_base_tree_names(
+    repository_root: Path, all_names: frozenset[str]
+) -> frozenset[str]:
+    all_present_names: set[str] = set()
+    for each_name in sorted(all_names):
+        all_arguments = (
+            *ALL_GIT_GREP_BASE_TREE_COMMAND_PREFIX,
+            each_name,
+            GIT_BASE_TREE_REVISION,
+        )
+        grep_process = _run_strict_git(repository_root, all_arguments)
+        if grep_process.returncode == 0:
+            all_present_names.add(each_name)
+            continue
+        if grep_process.returncode == GIT_NO_MATCH_EXIT_CODE:
+            continue
+        operation = GIT_GREP_OPERATION_TEMPLATE.format(identifier=each_name)
+        _raise_for_git_failure(grep_process, operation)
+    return frozenset(all_present_names)
+
+
+def strict_staged_terminology_findings(repository_root: Path) -> list[str]:
+    """Return near-miss findings for the staged diff.
+
+    Args:
+        repository_root: The repository root the staged diff is read from.
+
+    Returns:
+        One finding string per near-miss term on a staged prose line.
+
+    Raises:
+        RuntimeError: Git could not read the staged diff or look up an
+            identifier in HEAD.
+    """
+    diff_process = _run_strict_git(
+        repository_root, ALL_GIT_DIFF_CACHED_UNIFIED_ZERO_COMMAND
+    )
+    _raise_for_git_failure(diff_process, GIT_DIFF_OPERATION)
+    all_added_names = _identifier_names_on_added_code_lines(diff_process.stdout)
+    preexisting_tuples = frozenset(
+        _identifier_token_tuple(each_name)
+        for each_name in _strict_base_tree_names(repository_root, all_added_names)
+    )
+    return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
+
+
 def staged_terminology_findings(repository_root: Path) -> list[str]:
     """Return terminology near-miss findings for a repository's staged diff.
 
     An identifier the base tree already names is not one the staged diff
-    introduces, so no prose is flagged against it — only genuinely new
+    introduces, so no prose is flagged against it. Only genuinely new
     identifiers are swept.
 
     Args:
@@ -684,7 +772,7 @@ def staged_terminology_findings(repository_root: Path) -> list[str]:
         _identifier_token_tuple(each_name)
         for each_name in _base_tree_names(repository_root, all_added_names)
     )
-    return sweep_diff(diff_process.stdout, preexisting_tuples)
+    return _find_terminology_near_misses(diff_process.stdout, preexisting_tuples)
 
 
 def _read_diff_text(diff_file_path: str | None) -> str:

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

@@ -2,6 +2,7 @@
 
 import importlib.util
 import subprocess
+import sys
 from pathlib import Path
 from types import ModuleType
 
@@ -10,17 +11,26 @@ import pytest
 
 def _load_sweep_module() -> ModuleType:
     module_path = Path(__file__).parent.parent / "terminology_sweep.py"
+    module_directory = str(module_path.parent)
+    should_remove_module_directory = module_directory not in sys.path
+    if should_remove_module_directory:
+        sys.path.insert(0, module_directory)
     spec = importlib.util.spec_from_file_location("terminology_sweep", 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)
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        if should_remove_module_directory:
+            sys.path.remove(module_directory)
     return module
 
 
 sweep_module = _load_sweep_module()
 sweep_diff = sweep_module.sweep_diff
 staged_terminology_findings = sweep_module.staged_terminology_findings
+strict_staged_terminology_findings = sweep_module.strict_staged_terminology_findings
 main = sweep_module.main
 parse_added_lines = sweep_module._parse_added_lines
 
@@ -282,6 +292,8 @@ def test_staged_terminology_findings_flags_staged_prose(tmp_path: Path) -> None:
         env=_hermetic_git_environment(),
     )
     findings = staged_terminology_findings(tmp_path)
+    with pytest.raises(RuntimeError, match="git grep"):
+        strict_staged_terminology_findings(tmp_path)
     assert any("premium-request" in each_finding for each_finding in findings)
 
 

package/docs/references/team-advisor-skill.md

@@ -1,6 +1,6 @@
-# Team-Advisor Skill
+# Team-advisor skill
 
-`/team-advisor` binds one standing warm advisor for this session at the strongest reachable tier. This skill is the selected custom reproduction path for advisor behavior: it forwards explicit packets to a warm Agent/SendMessage advisor or the read-only `codex_sol_advisor.py` path across many decision points.
+`/team-advisor` binds one standing warm advisor for this session at the strongest reachable tier. It sends explicit packets to a warm Agent/SendMessage advisor or the read-only `codex_astra_advisor.py` helper.
 
 ## Refs
 
@@ -17,4 +17,4 @@ Follow the call rules in `advisor-tool.md` (orientation first, then consult befo
 
 ## Selected path
 
-`/team-advisor` is the repository's advisor implementation. It provides explicit first-consult packets, delta consults, a standing warm reviewer, an in-session Sol spawn on Codex, and a read-only Sol CLI option.
+`/team-advisor` is the repository's advisor implementation. It provides explicit first-consult packets, delta consults, a standing warm reviewer, an in-session Astra spawn on Codex, and a read-only Astra CLI option.

package/hooks/validators/README.md

@@ -2,7 +2,41 @@
 
 AST-based Python style checks for code quality enforcement.
 
-The checks live in `python_style_checks.py`; the shared source-line splitting, function-discovery, and statement-classification helpers they build on live in `python_style_helpers.py`. `python_style_import_bootstrap.py` recognizes the repo's sys.path bootstrap-guard idiom so the imports-at-top check does not penalize a file for following it. `hook_timing_harness.py` measures real wall-clock time for the Write/Edit hooks `hooks.json` registers, reporting p50 and p95 over a configurable run count. `fast_save_validators.py` runs the twelve non-Mypy, non-Ruff checks in-process for the Write/Edit save-path gate, with no per-check subprocess.
+The checks live in `python_style_checks.py`. Shared source-line splitting, function discovery, and statement classification live in `python_style_helpers.py`. `python_style_import_bootstrap.py` recognizes the repo's sys.path bootstrap-guard idiom so the imports-at-top check does not penalize a file for following it. `fast_save_validators.py` runs the twelve non-Mypy, non-Ruff checks in-process for the Write/Edit save-path gate, with no per-check subprocess.
+
+## Production modules
+
+| File | Role |
+|---|---|
+| `abbreviation_checks.py` | Abbreviation and single-letter name checks |
+| `code_quality_checks.py` | Function, nesting, and file length checks |
+| `comment_checks.py` | Comment detection for the opt-in diff-aware linter |
+| `exempt_paths.py` | Shared config, test, and hook-infrastructure path exemptions |
+| `fast_save_validators.py` | In-process Write/Edit save-path validator roster |
+| `file_structure_checks.py` | File structure checks for pre-PR validation |
+| `git_checks.py` | Git and GitHub checks for pre-push review |
+| `health_check.py` | Validator availability, dependency, and version checks |
+| `hook_timing_harness.py` | Hook runtime measurement and threshold report |
+| `magic_value_checks.py` | Hardcoded magic-number checks |
+| `mypy_integration.py` | Mypy static type checking integration |
+| `output_formatter.py` | Colored, diff, progress, and JSON validator output |
+| `pr_reference_checks.py` | PR and commit reference checks in comments |
+| `project_roots.py` | Project-root resolution from a path |
+| `pyproject_config_discovery.py` | Walk-up discovery of tool pyproject tables |
+| `python_antipattern_checks.py` | Mutable defaults, bare except, and print checks |
+| `python_style_checks.py` | Import placement, decorator spacing, blank lines, and view naming |
+| `python_style_helpers.py` | Source-line splitting and function-discovery helpers |
+| `python_style_import_bootstrap.py` | sys.path bootstrap-guard recognizer |
+| `react_checks.py` | React class-component and error-boundary checks |
+| `ruff_integration.py` | Ruff lint integration |
+| `run_all_validators.py` | Pre-push validator orchestration and report |
+| `security_checks.py` | Hardcoded-secret, SQL injection, and XSS checks |
+| `system_temporary_roots.py` | System temp-root membership for staged copies |
+| `todo_checks.py` | TODO/FIXME tracking with issue-reference requirement |
+| `type_safety_checks.py` | Missing type hints and Any usage checks |
+| `useless_test_checks.py` | Useless-test detection |
+| `validator_base.py` | Shared validator dataclasses, source read, and parse |
+| `validator_defaults.py` | Shared constants for the validators package |
 
 ## Checks Implemented
 

package/package.json

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

package/scripts/check.ps1

@@ -1,8 +1,9 @@
 #!/usr/bin/env pwsh
 <#
 .SYNOPSIS
-    One-shot quality gate — runs ruff, hooks mypy, pr-loop mypy,
-    process-tree mypy, and the blocking pytest suite from a single entry point.
+    One-shot quality gate. Runs ruff, hooks mypy, pr-loop mypy,
+    process-tree mypy, repository-policy, and the blocking pytest suite from a
+    single entry point.
 
 .DESCRIPTION
     Resolves paths relative to $PSScriptRoot so the script works from any CWD
@@ -11,9 +12,10 @@
     propagates this file). Tools: ruff over hooks/, mypy over hooks blocking
     and validators, mypy-pr-loop over _shared/pr-loop/scripts production
     modules, mypy-process-tree over the shared process-tree kill helper and
-    its constants, and optional pytest over the blocking enforcer suite. Each tool
-    runs sequentially; the first non-zero exit code is preserved as the
-    script's exit code so CI/pre-commit can short-circuit on the first failure.
+    its constants, repository-policy over the committed tree, and optional
+    pytest over the blocking enforcer suite. Each tool runs in sequence. The
+    first non-zero exit code is preserved as the script's exit code so CI and
+    pre-commit can stop on the first failure.
 
 .PARAMETER SkipTests
     Skip the pytest run. Useful during local iteration when you want only the
@@ -25,19 +27,23 @@
 .PARAMETER SkipRuff
     Skip the ruff run.
 
+.PARAMETER SkipRepositoryPolicy
+    Skip the committed-tree repository_policy.py run.
+
 .PARAMETER CommentPolicyBase
     Optional git reference used as the comment-policy baseline.
 
 .OUTPUTS
     Per-tool status lines on stdout. Final summary line:
         CHECK: OK
-        CHECK: FAILED tools=ruff,mypy,mypy-pr-loop,mypy-process-tree,pytest
+        CHECK: FAILED tools=ruff,repository-policy,mypy,mypy-pr-loop,mypy-process-tree,pytest
 #>
 [CmdletBinding()]
 param(
     [switch]$SkipTests,
     [switch]$SkipMypy,
     [switch]$SkipRuff,
+    [switch]$SkipRepositoryPolicy,
     [string]$CommentPolicyBase
 )
 
@@ -121,6 +127,12 @@ Invoke-Tool -Label 'comment-policy' -Action {
     }
 }
 
+if (-not $SkipRepositoryPolicy) {
+    Invoke-Tool -Label 'repository-policy' -Action {
+        python (Join-Path $PSScriptRoot 'repository_policy.py') --repository-root $repositoryRoot
+    }
+}
+
 if (-not $SkipMypy) {
     Invoke-Tool -Label 'mypy' -Action {
         Push-Location $hooksRoot

package/scripts/policy_lint/adapter_detectors.py

@@ -3,11 +3,51 @@ from __future__ import annotations
 from collections.abc import Iterable
 from contextlib import redirect_stderr, redirect_stdout
 from io import StringIO
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 
 from . import adapter_support
 from .config import constants
-from .model import Diagnostic, Document
+from .model import Diagnostic, Document, DocumentSet, Location, SelectionKind, Severity
+
+
+def _terminology_diagnostic(finding: str) -> Diagnostic:
+    finding_match = constants.TERMINOLOGY_FINDING_PATTERN.fullmatch(finding)
+    if finding_match is None:
+        raise ValueError(finding)
+    return Diagnostic(
+        constants.TERMINOLOGY_SWEEP_RULE_ID,
+        Severity.ERROR,
+        finding_match.group(constants.TERMINOLOGY_MESSAGE_GROUP),
+        Location(
+            PurePosixPath(finding_match.group(constants.TERMINOLOGY_PATH_GROUP)),
+            int(finding_match.group(constants.TERMINOLOGY_LINE_NUMBER_GROUP)),
+        ),
+    )
+
+
+def terminology_diagnostics(
+    document_set: DocumentSet,
+    load_module: adapter_support.HookModuleLoader,
+) -> tuple[Diagnostic, ...]:
+    """Report staged prose that near-misses a newly introduced identifier.
+
+    Args:
+        document_set: Candidate staged documents and repository root.
+        load_module: Shared script module loader.
+
+    Returns:
+        Diagnostics that name the prose file and line.
+    """
+    if document_set.selection is not SelectionKind.STAGED:
+        return ()
+    terminology_module = load_module(constants.TERMINOLOGY_SWEEP_MODULE_NAME)
+    helper_stdout = StringIO()
+    helper_stderr = StringIO()
+    with redirect_stdout(helper_stdout), redirect_stderr(helper_stderr):
+        all_findings = terminology_module.strict_staged_terminology_findings(
+            document_set.repository_root
+        )
+    return tuple(_terminology_diagnostic(each_finding) for each_finding in all_findings)
 
 
 def _stable_validator_message(document: Document, raw_message: str) -> str:

package/scripts/policy_lint/adapters.py

@@ -23,6 +23,16 @@ def _hooks_module(module_name: str) -> ModuleType:
     return importlib.import_module(module_name)
 
 
+def _pr_loop_script_module(module_name: str) -> ModuleType:
+    package_directory = Path(__file__).resolve().parent.parent.parent
+    scripts_directory = str(
+        package_directory.joinpath(*constants.ALL_PR_LOOP_SCRIPTS_PATH_SEGMENTS)
+    )
+    if scripts_directory not in sys.path:
+        sys.path.insert(0, scripts_directory)
+    return importlib.import_module(module_name)
+
+
 def validator_diagnostics(
     document: Document, repository_root: Path
 ) -> tuple[Diagnostic, ...]:
@@ -222,6 +232,20 @@ def test_pairing_diagnostics(document_set: DocumentSet) -> tuple[Diagnostic, ...
     return adapter_pairing.test_pairing_diagnostics(document_set, _hooks_module)
 
 
+def terminology_diagnostics(document_set: DocumentSet) -> tuple[Diagnostic, ...]:
+    """Report staged prose that near-misses a newly introduced identifier.
+
+    Args:
+        document_set: Candidate staged documents and repository root.
+
+    Returns:
+        Diagnostics that name the prose file and line.
+    """
+    return adapter_detectors.terminology_diagnostics(
+        document_set, _pr_loop_script_module
+    )
+
+
 def hook_format_diagnostics(
     document: Document, repository_root: Path
 ) -> tuple[Diagnostic, ...]:

package/scripts/policy_lint/config/constants.py

@@ -1,3 +1,5 @@
+import re
+
 INCOMPLETE_EXIT_CODE = 3
 INVALID_INPUT_EXIT_CODE = 2
 GIT_EXECUTABLE = "git"
@@ -64,3 +66,12 @@ FAST_SAVE_VALIDATORS_STEM = "fast_save_validators"
 ALL_OVERLAPPING_VALIDATOR_NAMES = frozenset(
     {"Python Style", "Magic Values", "Type Safety", "Test Safety", "React"}
 )
+ALL_PR_LOOP_SCRIPTS_PATH_SEGMENTS = ("_shared", "pr-loop", "scripts")
+TERMINOLOGY_SWEEP_MODULE_NAME = "terminology_sweep"
+TERMINOLOGY_SWEEP_RULE_ID = "terminology-sweep"
+TERMINOLOGY_FINDING_PATTERN = re.compile(
+    r"^(?P<path>.+):(?P<line_number>\d+): (?P<message>.+)$"
+)
+TERMINOLOGY_PATH_GROUP = "path"
+TERMINOLOGY_LINE_NUMBER_GROUP = "line_number"
+TERMINOLOGY_MESSAGE_GROUP = "message"

package/scripts/policy_lint/engine.py

@@ -180,7 +180,7 @@ def _run_changeset_rule(
     all_diagnostics: list[Diagnostic],
     all_skipped_rules: list[str],
 ) -> None:
-    if document_set.selection not in {SelectionKind.STAGED, SelectionKind.BASE}:
+    if document_set.selection not in rule.selections:
         all_skipped_rules.append(rule.rule_id)
         return
     all_diagnostics.extend(rule.check(document_set))

package/scripts/policy_lint/model.py

@@ -284,6 +284,7 @@ class DocumentRule:
 class ChangeSetRule:
     rule_id: str
     rule_sets: frozenset[str]
+    selections: frozenset[SelectionKind]
     check: DocumentSetChecker