claude-dev-env 1.82.0 → 1.83.0

package/CLAUDE.md

@@ -115,30 +115,33 @@ Before any coding task, call the `initial_instructions` tool to load the Serena
 
 ### Tool hierarchy for code navigation
 1. **Serena** — symbol-level navigation (declarations, references, implementations, rename)
-2. **Everything** (`everything_search`) — file-system search by name/path/extension
+2. **es.exe** — file-system search by name/path/extension/size/date (Everything CLI)
 3. **Grep/Glob** — content and pattern matching
 
-## Everything Search (MCP Tool)
+## Everything Search (es.exe CLI)
 
-This machine has **Everything (voidtools)** running with an HTTP server on port 54321.
-The `everything_search` MCP tool is available in every session.
+Search files by name, path, extension, size, or date with the Everything command-line tool `es.exe`. It reads the same live index the desktop app keeps, so results return instantly.
 
-### Use Everything for file-system searches
-Use `everything_search` for finding files by name, path, extension, size, or date. For content searches, use Grep — Everything's `content:` search is a fallback when Grep returns nothing.
+### Invocation and scope tokens
+Run `es.exe` with a scoped query — a project path, an `ext:`/`dm:`/`size:` filter, or a name pattern. The `es_exe_path_rewriter` hook resolves a `{project-name}` placeholder or a bare registry key from `~/.claude/project-paths.json` into its quoted absolute path before the command runs (it allows and rewrites, never blocks).
+
+### Hard limits
+- Scope every search. A bare whole-drive scan or a network-share sweep is out of bounds.
 
 ### Fallback order
-1. **Everything** (`everything_search`) — file-system search by name/path/extension/size/date, and content search
-2. **Grep** — complex regex content searches if Everything's `content:` returns nothing
-3. **Glob** — precise relative-path pattern matching within the current project
+1. **es.exe** — file-system search by name/path/extension/size/date
+2. **Debug** — try to find out why es.exe isn't working, and then prompt user for next-steps if you can't self-heal.
+3. **Grep** — file-content search (Grep owns content)
+4. **Glob** — relative-path pattern matching within the current project
 
 ### Search syntax quick reference
-- `ext:py` — find by extension (multiple: `ext:ts;js`)
+- `ext:py` — find by extension (multiple: `ext:ts | ext:js`)
 - `path:src\components` — match against full path
-- `count:10` — limit number of results to 10
 - `*.config.*` — wildcards
 - `size:>10mb` — size filter
 - `dm:today` / `dm:thisweek` — date modified filter
-- `content:keyword` — search inside file contents
-- `parent:node_modules package.json` — match parent folder
+- `-n 50` — limit results; `-sort dm` — sort by date modified
 - `foo bar` — AND, `foo | bar` — OR, `!foo` — NOT
 - `"exact phrase"` — literal match
+
+Full operator reference: `skills/everything-search/SKILL.md`.

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

@@ -15,6 +15,7 @@ Python scripts invoked at runtime by the PR-loop skills. Each script is a standa
 | `terminology_sweep.py` | Flags a prose term that near-misses an identifier introduced on added code lines of a unified diff (shared leading word, divergent tail) |
 | `reviews_disabled.py` | Shared helper for the `CLAUDE_REVIEWS_DISABLED` opt-out gate; parses the env-var token to find which reviewer types are suppressed |
 | `copilot_quota.py` | Copilot premium-request quota pre-check: resolves a configured GitHub account, reads its remaining `premium_interactions` quota via `gh api copilot_internal/user`, and exits 0 (run Copilot) or non-zero (skip: out of quota, API down, or no account configured) |
+| `reviewer_availability.py` | Unified reviewer-availability entry point for Copilot and Bugbot: reuses `copilot_quota.py` and `reviews_disabled.py` and exits 0 when the named `--reviewer` may be spawned, non-zero when it is opted out or (for Copilot) out of quota |
 | `fix_hookspath.py` | Repairs a malformed `core.hooksPath` global git config entry |
 | `_claude_permissions_common.py` | Internal helpers shared by the grant/revoke scripts: atomic settings.json writes, list mutation, path helpers |
 

package/_shared/pr-loop/scripts/README.md

@@ -7,6 +7,7 @@ Runnable helpers used by **bugteam**, **qbug**, **pr-converge**, and related ski
 | File | Purpose |
 | --- | --- |
 | `preflight.py` | Local checks before a PR-loop run (pytest discovery, optional pre-commit, hooksPath sanity). |
+| `reviewer_availability.py` | Unified availability check for Copilot and Bugbot; reuses `copilot_quota.py` and `reviews_disabled.py` and exits 0 when the named `--reviewer` may be spawned. |
 | `code_rules_gate.py` | CODE_RULES gate over PR-scoped diffs (`--base`, staged-only, path filters). |
 | `fix_hookspath.py` | Repair `core.hooksPath` when it does not point at the packaged git-hooks tree. |
 | `grant_project_claude_permissions.py` / `revoke_project_claude_permissions.py` | Claude Code permission JSON helpers used during publish-style flows. |

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

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

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

@@ -0,0 +1,12 @@
+"""Configuration constants for the unified reviewer-availability pre-check.
+
+The down code is 3 so a deliberate reviewer-down report stays distinguishable
+from a generic interpreter crash (exit 1) and an argparse usage error
+(exit 2). A caller that gates on the down code treats any other non-zero exit
+as a broken check, not a down reviewer, and fails open.
+"""
+
+from __future__ import annotations
+
+EXIT_CODE_REVIEWER_AVAILABLE: int = 0
+EXIT_CODE_REVIEWER_DOWN: int = 3

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

@@ -24,8 +24,6 @@ HYPHENATED_PROSE_TOKEN_PATTERN: re.Pattern[str] = re.compile(
     r"\b[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z][A-Za-z0-9]*)+\b"
 )
 
-PROSE_WORD_PATTERN: re.Pattern[str] = re.compile(r"[A-Za-z][A-Za-z0-9]*")
-
 STRING_LITERAL_CONTENT_PATTERN: re.Pattern[str] = re.compile(
     r"\"([^\"]*)\"|'([^']*)'|`([^`]*)`"
 )

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

@@ -0,0 +1,182 @@
+"""Unified reviewer-availability pre-check for GitHub Copilot and Cursor Bugbot.
+
+Run this before either reviewer step spawns. It answers one question: is the
+named reviewer available to run right now. It reuses two existing checks
+instead of re-implementing their rules. The ``CLAUDE_REVIEWS_DISABLED``
+opt-out gate lives in ``reviews_disabled.py``. The Copilot premium-interaction
+quota pre-check lives in ``copilot_quota.py``.
+
+Copilot counts as down in two cases: it is opted out via
+``CLAUDE_REVIEWS_DISABLED``, or its quota pre-check returns anything other
+than quota available (out of quota, the quota API or account down, or no
+account configured).
+
+Bugbot carries no quota or availability API. It counts as down only when it
+is opted out via ``CLAUDE_REVIEWS_DISABLED``. A genuine runtime outage shows
+up later as a poll timeout, not here.
+
+The exit code tells the caller what to do. Exit 0 means the reviewer is
+available and may be spawned. The documented down code (3) means skip it. Any
+other non-zero exit is a broken check — an interpreter crash or a usage
+error — not a down report, so a gating caller fails open on it. Every path
+prints one line: available lines go to stdout, down lines go to stderr.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from copilot_quota import (
+    COPILOT_QUOTA_DEFAULT_ENV_FILE_PATH,
+    EXIT_CODE_QUOTA_AVAILABLE,
+    evaluate_copilot_quota,
+)
+from pr_loop_shared_constants.reviewer_availability_constants import (
+    EXIT_CODE_REVIEWER_AVAILABLE,
+    EXIT_CODE_REVIEWER_DOWN,
+)
+from pr_loop_shared_constants.reviews_disabled_constants import (
+    CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN,
+    CLAUDE_REVIEWS_DISABLED_COPILOT_TOKEN,
+    CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME,
+)
+from reviews_disabled import is_bugbot_disabled_via_env, is_copilot_disabled_via_env
+
+
+@dataclass(frozen=True)
+class ReviewerAvailability:
+    """One reviewer-availability outcome: the exit code and the single log line.
+
+    The exit code tells the caller what to do, where 0 means the reviewer may
+    be spawned and the documented down code (3) means skip it. The CLI prints
+    the message on one line, to stdout when available and to stderr when down.
+    """
+
+    exit_code: int
+    message: str
+
+
+def _evaluate_copilot_availability(env_file_path: Path) -> ReviewerAvailability:
+    """Decide whether GitHub Copilot is available to spawn.
+
+    Args:
+        env_file_path: The ``.env`` file the quota pre-check consults for the
+            configured account when neither the flag nor the environment
+            variable names one.
+
+    Returns:
+        A ReviewerAvailability that is down when Copilot is opted out via
+        ``CLAUDE_REVIEWS_DISABLED`` or the quota pre-check reports anything
+        other than quota available, and available otherwise.
+    """
+    if is_copilot_disabled_via_env():
+        return ReviewerAvailability(
+            EXIT_CODE_REVIEWER_DOWN,
+            f"reviewer-availability: copilot is disabled via "
+            f"{CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME} — skipping.",
+        )
+    quota_decision = evaluate_copilot_quota(cli_account=None, env_file_path=env_file_path)
+    if quota_decision.exit_code != EXIT_CODE_QUOTA_AVAILABLE:
+        return ReviewerAvailability(EXIT_CODE_REVIEWER_DOWN, quota_decision.message)
+    return ReviewerAvailability(EXIT_CODE_REVIEWER_AVAILABLE, quota_decision.message)
+
+
+def _evaluate_bugbot_availability() -> ReviewerAvailability:
+    """Decide whether Cursor Bugbot is available to spawn.
+
+    Bugbot carries no quota or availability API, so this checks only the
+    deterministic ``CLAUDE_REVIEWS_DISABLED`` opt-out.
+
+    Returns:
+        A ReviewerAvailability that is down when Bugbot is opted out via
+        ``CLAUDE_REVIEWS_DISABLED``, and available otherwise.
+    """
+    if is_bugbot_disabled_via_env():
+        return ReviewerAvailability(
+            EXIT_CODE_REVIEWER_DOWN,
+            f"reviewer-availability: bugbot is disabled via "
+            f"{CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME} — skipping.",
+        )
+    return ReviewerAvailability(
+        EXIT_CODE_REVIEWER_AVAILABLE,
+        "reviewer-availability: bugbot is available.",
+    )
+
+
+def evaluate_reviewer_availability(
+    reviewer_token: str, env_file_path: Path
+) -> ReviewerAvailability:
+    """Decide whether the named reviewer is available to spawn.
+
+    Args:
+        reviewer_token: Either the Copilot or the Bugbot reviewer token.
+        env_file_path: The ``.env`` file the Copilot quota pre-check consults
+            for the configured account.
+
+    Returns:
+        The ReviewerAvailability for the named reviewer.
+
+    Raises:
+        ValueError: When reviewer_token names neither the Copilot nor the
+            Bugbot reviewer token.
+    """
+    if reviewer_token == CLAUDE_REVIEWS_DISABLED_COPILOT_TOKEN:
+        return _evaluate_copilot_availability(env_file_path)
+    if reviewer_token == CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN:
+        return _evaluate_bugbot_availability()
+    raise ValueError(f"unknown reviewer token: {reviewer_token}")
+
+
+def _parse_arguments(all_argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments for the reviewer-availability check.
+
+    Args:
+        all_argv: Argument list excluding the program name, typically
+            ``sys.argv[1:]``.
+
+    Returns:
+        Namespace exposing a ``reviewer`` attribute constrained to the
+        Copilot and Bugbot reviewer tokens.
+    """
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--reviewer",
+        required=True,
+        choices=[
+            CLAUDE_REVIEWS_DISABLED_COPILOT_TOKEN,
+            CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN,
+        ],
+        help="Reviewer to check availability for",
+    )
+    return parser.parse_args(all_argv)
+
+
+def main(all_arguments: list[str]) -> int:
+    """Run the reviewer-availability check end-to-end and print its decision.
+
+    Args:
+        all_arguments: Argument list excluding the program name.
+
+    Returns:
+        0 when the named reviewer is available to spawn, the documented
+        reviewer-down exit code when it is down.
+    """
+    arguments = _parse_arguments(all_arguments)
+    availability = evaluate_reviewer_availability(
+        reviewer_token=arguments.reviewer,
+        env_file_path=COPILOT_QUOTA_DEFAULT_ENV_FILE_PATH,
+    )
+    message_stream = (
+        sys.stdout
+        if availability.exit_code == EXIT_CODE_REVIEWER_AVAILABLE
+        else sys.stderr
+    )
+    print(availability.message, file=message_stream)
+    return availability.exit_code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

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

@@ -7,11 +7,18 @@ finds the other.
 
 This sweep reads a unified diff and collects every multi-word identifier added
 on code lines. Then it scans each added prose line — a Markdown line, or a
-comment, docstring, or string inside a code file. It flags a hyphen or space
-variant that shares an identifier's leading word but diverges in the tail. Each
+comment, docstring, or string inside a code file. It flags a hyphenated term
+that shares an identifier's leading word but diverges in the tail. Each
 near-miss prints as one ``file:line`` finding, and the run exits non-zero when
 any finding remains, so a commit gate can block on it.
 
+Only hyphenated terms are candidates. A hyphen marks a deliberate compound —
+the author bound the words into one term — so a divergent tail there is a real
+naming drift. A bare spaced word run is ordinary prose: windowing every
+sentence that starts with an identifier's first word ("each attempt", "file
+exists") floods a vocabulary-dense change with false findings and gives the
+gate nothing actionable.
+
 A shared leading token alone is too weak a signal: ordinary English compounds
 such as ``read-only`` and ``data-driven`` collide with unrelated identifiers
 (``read_config``, ``data_source``) and would block a commit falsely. To keep the
@@ -56,7 +63,6 @@ from pr_loop_shared_constants.terminology_sweep_constants import (  # noqa: E402
     JSDOC_CONTINUATION_MARKER,
     MARKDOWN_FILE_EXTENSION,
     MINIMUM_IDENTIFIER_TOKEN_COUNT,
-    PROSE_WORD_PATTERN,
     PYTHON_COMMENT_MARKER,
     SNAKE_CASE_IDENTIFIER_PATTERN,
     STRING_LITERAL_CONTENT_PATTERN,
@@ -234,35 +240,6 @@ def _hyphenated_candidates(fragment: str) -> list[tuple[str, IdentifierTuple]]:
     return all_candidates
 
 
-def _spaced_candidates(
-    fragment: str,
-    identifiers_by_first_token: dict[str, list[IdentifierTuple]],
-) -> list[tuple[str, IdentifierTuple]]:
-    """Return spaced word windows whose first word matches an identifier prefix.
-
-    Only a window anchored at a known identifier prefix and sized to one of that
-    prefix's identifiers is returned, which bounds the windows to the shapes the
-    near-miss check can act on.
-
-    Args:
-        fragment: The prose fragment to scan.
-        identifiers_by_first_token: Identifier tuples grouped by leading token.
-
-    Returns:
-        ``(display, token_tuple)`` pairs for each candidate window.
-    """
-    all_words = [
-        each_word.lower() for each_word in PROSE_WORD_PATTERN.findall(fragment)
-    ]
-    all_candidates: list[tuple[str, IdentifierTuple]] = []
-    for each_index, each_word in enumerate(all_words):
-        for each_identifier in identifiers_by_first_token.get(each_word, []):
-            window = tuple(all_words[each_index : each_index + len(each_identifier)])
-            if len(window) == len(each_identifier):
-                all_candidates.append((" ".join(window), window))
-    return all_candidates
-
-
 def _tokens_are_plural_variants(first_word: str, second_word: str) -> bool:
     """Return whether two words are singular/plural forms of one word.
 
@@ -348,7 +325,6 @@ def _findings_for_line(
     reported_tuples: set[IdentifierTuple] = set()
     for each_fragment in _prose_fragments(file_path, line_text):
         all_candidates = _hyphenated_candidates(each_fragment)
-        all_candidates += _spaced_candidates(each_fragment, identifiers_by_first_token)
         for each_display, each_tuple in all_candidates:
             matched_identifier = _near_miss_identifier(
                 each_tuple, all_identifier_tuples, identifiers_by_first_token

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

@@ -24,6 +24,8 @@ pytest suite for the scripts and constants in `_shared/pr-loop/scripts/`. Each t
 | `test_reviews_disabled.py` | `reviews_disabled.py` opt-out gate parsing |
 | `test_copilot_quota.py` | `copilot_quota.py` end-to-end: account resolution, premium-quota classification, exit codes, and skip logging |
 | `test_copilot_quota_constants.py` | `pr_loop_shared_constants/copilot_quota_constants.py` |
+| `test_reviewer_availability.py` | `reviewer_availability.py` end-to-end: Copilot and Bugbot availability, opt-out via `CLAUDE_REVIEWS_DISABLED`, and every Copilot quota outcome |
+| `test_reviewer_availability_constants.py` | `pr_loop_shared_constants/reviewer_availability_constants.py` |
 | `test_revoke_project_claude_permissions.py` | `revoke_project_claude_permissions.py` end-to-end |
 | `test_agent_config_carveout.py` | Agent-config deny-rule carve-out logic |
 | `conftest.py` | Shared pytest fixtures |

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

@@ -0,0 +1,159 @@
+"""Direct unit tests for the unified reviewer_availability pre-check.
+
+Every case drives the production ``main`` path through
+``evaluate_reviewer_availability``. Copilot cases stub only the ``gh``
+subprocess boundary inside ``copilot_quota`` (``_run_gh``), reusing the same
+captured fixture ``test_copilot_quota.py`` drives. Opt-out cases set or clear
+``CLAUDE_REVIEWS_DISABLED`` directly.
+"""
+
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+import pytest
+
+
+def _load_module(module_name: str) -> ModuleType:
+    scripts_directory = Path(__file__).parent.parent
+    if str(scripts_directory) not in sys.path:
+        sys.path.insert(0, str(scripts_directory))
+    module_path = scripts_directory / f"{module_name}.py"
+    specification = importlib.util.spec_from_file_location(module_name, module_path)
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    sys.modules[specification.name] = module
+    specification.loader.exec_module(module)
+    return module
+
+
+copilot_quota = _load_module("copilot_quota")
+reviewer_availability = _load_module("reviewer_availability")
+
+FIXTURE_PATH = Path(__file__).parent / "fixtures" / "copilot_internal_user_jonecho.json"
+AVAILABLE_USER_JSON = FIXTURE_PATH.read_text(encoding="utf-8")
+FAKE_TOKEN_RESULT = (0, "ghp_faketoken_value\n")
+
+
+def _exhausted_user_json() -> str:
+    user = json.loads(AVAILABLE_USER_JSON)
+    premium = user["quota_snapshots"]["premium_interactions"]
+    premium["remaining"] = 0
+    premium["quota_remaining"] = 0.0
+    premium["percent_remaining"] = 0.0
+    return json.dumps(user)
+
+
+def _gh_stub(token_result: tuple[int, str], api_result: tuple[int, str]):
+    def _fake_run_gh(
+        command_arguments: list[str],
+        extra_environment: dict[str, str] | None = None,
+    ) -> tuple[int, str]:
+        if command_arguments and command_arguments[0] == "auth":
+            return token_result
+        if command_arguments and command_arguments[0] == "api":
+            return api_result
+        raise AssertionError(f"unexpected gh command {command_arguments}")
+
+    return _fake_run_gh
+
+
+@pytest.fixture(autouse=True)
+def _isolate_reviewer_environment(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    monkeypatch.delenv("COPILOT_QUOTA_ACCOUNT", raising=False)
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.setattr(
+        reviewer_availability, "COPILOT_QUOTA_DEFAULT_ENV_FILE_PATH", tmp_path / ".env"
+    )
+
+
+def test_main_reports_copilot_available_when_quota_confirmed_available(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota, "_run_gh", _gh_stub(FAKE_TOKEN_RESULT, (0, AVAILABLE_USER_JSON))
+    )
+    exit_code = reviewer_availability.main(["--reviewer", "copilot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_AVAILABLE
+    assert "running Copilot" in captured.out
+
+
+def test_main_reports_copilot_down_when_opted_out_via_env(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "copilot")
+
+    def _fail_if_called(
+        command_arguments: list[str],
+        extra_environment: dict[str, str] | None = None,
+    ) -> tuple[int, str]:
+        raise AssertionError("gh must not run once copilot is opted out")
+
+    monkeypatch.setattr(copilot_quota, "_run_gh", _fail_if_called)
+    exit_code = reviewer_availability.main(["--reviewer", "copilot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_DOWN
+    assert "CLAUDE_REVIEWS_DISABLED" in captured.err
+
+
+def test_main_reports_copilot_down_when_out_of_quota(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota,
+        "_run_gh",
+        _gh_stub(FAKE_TOKEN_RESULT, (0, _exhausted_user_json())),
+    )
+    exit_code = reviewer_availability.main(["--reviewer", "copilot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_DOWN
+    assert "scenario A" in captured.err
+
+
+def test_main_reports_copilot_down_when_quota_api_is_down(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("COPILOT_QUOTA_ACCOUNT", "jonecho")
+    monkeypatch.setattr(
+        copilot_quota, "_run_gh", _gh_stub(FAKE_TOKEN_RESULT, (0, "not json at all"))
+    )
+    exit_code = reviewer_availability.main(["--reviewer", "copilot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_DOWN
+    assert "scenario B" in captured.err
+
+
+def test_main_reports_copilot_down_when_no_account_configured(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code = reviewer_availability.main(["--reviewer", "copilot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_DOWN
+    assert "scenario C" in captured.err
+
+
+def test_main_reports_bugbot_available_when_not_opted_out(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    exit_code = reviewer_availability.main(["--reviewer", "bugbot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_AVAILABLE
+    assert "bugbot" in captured.out
+
+
+def test_main_reports_bugbot_down_when_opted_out_via_env(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugbot")
+    exit_code = reviewer_availability.main(["--reviewer", "bugbot"])
+    captured = capsys.readouterr()
+    assert exit_code == reviewer_availability.EXIT_CODE_REVIEWER_DOWN
+    assert "CLAUDE_REVIEWS_DISABLED" in captured.err

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

@@ -0,0 +1,36 @@
+"""Tests for reviewer_availability_constants.py extracted constant set."""
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_constants_module() -> ModuleType:
+    module_path = (
+        Path(__file__).parent.parent
+        / "pr_loop_shared_constants"
+        / "reviewer_availability_constants.py"
+    )
+    specification = importlib.util.spec_from_file_location(
+        "pr_loop_shared_constants.reviewer_availability_constants", module_path
+    )
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+    return module
+
+
+constants_module = _load_constants_module()
+
+
+def test_available_exit_code_matches_the_posix_success_convention() -> None:
+    assert constants_module.EXIT_CODE_REVIEWER_AVAILABLE == 0
+
+
+def test_down_exit_code_is_distinct_from_the_available_exit_code() -> None:
+    assert (
+        constants_module.EXIT_CODE_REVIEWER_DOWN
+        != constants_module.EXIT_CODE_REVIEWER_AVAILABLE
+    )
+    assert constants_module.EXIT_CODE_REVIEWER_DOWN != 0

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

@@ -191,7 +191,7 @@ def test_does_not_flag_y_to_ies_plural_variant() -> None:
     assert sweep_diff(diff) == []
 
 
-def test_still_flags_non_plural_divergent_tail() -> None:
+def test_does_not_flag_spaced_prose_sharing_identifier_prefix() -> None:
     diff = (
         "diff --git a/api/quota.py b/api/quota.py\n"
         "--- a/api/quota.py\n"
@@ -204,9 +204,19 @@ def test_still_flags_non_plural_divergent_tail() -> None:
         "@@ -0,0 +1,1 @@\n"
         "+The premium request budget gates the run.\n"
     )
-    findings = sweep_diff(diff)
-    assert len(findings) == 1
-    assert "premium request" in findings[0]
+    assert sweep_diff(diff) == []
+
+
+def test_does_not_flag_ordinary_sentence_sharing_loop_variable_prefix() -> None:
+    diff = (
+        "diff --git a/api/scan.py b/api/scan.py\n"
+        "--- a/api/scan.py\n"
+        "+++ b/api/scan.py\n"
+        "@@ -0,0 +1,2 @@\n"
+        "+each_node = walk(tree)\n"
+        '+DESCRIPTION = "Each attempt polls the review endpoint once."\n'
+    )
+    assert sweep_diff(diff) == []
 
 
 def test_flags_near_miss_inside_code_comment() -> None:

package/hooks/blocking/CLAUDE.md

@@ -86,9 +86,11 @@ The check modules it calls are the `code_rules_<concern>.py` files below.
 | `precommit_code_rules_gate.py` | PreToolUse (Bash) | Staged changes that fail the CODE_RULES gate at commit time |
 | `pytest_testpaths_orphan_blocker.py` | PreToolUse (Write/Edit/MultiEdit) | New `test_*.py` files created under a directory absent from a package's explicit pytest `testpaths` allowlist |
 | `question_to_user_enforcer.py` | Stop | User-directed questions not routed through `AskUserQuestion` |
+| `reviewer_spawn_gate.py` | PreToolUse (Bash) | A sentinel-marked autoconverge reviewer-spawn command (Copilot review request, Bugbot rerun comment) run while `reviewer_availability.py` reports that reviewer down or out of quota |
 | `send_user_file_open_locally_blocker.py` | PreToolUse (SendUserFile) | A desk-side file attach (`SendUserFile` with `status` not `proactive`); points to opening the file locally via `Show-Asset.ps1` |
 | `sensitive_file_protector.py` | PreToolUse (Write/Edit) | Writes to sensitive credential or config files |
 | `session_handoff_blocker.py` | Stop | Responses suggesting a new session mid-task |
+| `stale_comment_reference_blocker.py` | PreToolUse (Edit) | An Edit that rewrites a Python code line while keeping the standalone comment directly above it, when that comment names an identifier the rewrite removes from the line |
 | `state_description_blocker.py` | PreToolUse (Write/Edit) | Historical/comparative language in documentation |
 | `subprocess_budget_completeness.py` | PreToolUse | Subprocess calls missing required budget arguments |
 | `tdd_enforcer.py` | PreToolUse (Write/Edit) | Production code written without a matching failing test |