claude-dev-env 1.82.0 → 1.84.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/audit-contract.md

@@ -8,7 +8,8 @@ Shared output schema and audit-loop contract used by `/bugteam`, `/qbug`, `/find
 - Adversarial second pass
 - Haiku secondary auditor
 - Post-fix self-audit
-- Persistence (loop-N-audit.json, loop-N-diagnostics.json)
+- De-dup and merge
+- Persistence (loop-<L>-audit.json, loop-<L>-diagnostics.json)
 
 ## Finding schema
 
@@ -18,7 +19,7 @@ Each finding an audit produces MUST be one of exactly two shapes.
 
 ```json
 {
-  "id": "loop<N>-<K>",
+  "id": "loop<L>-<K>",
   "file": "path/relative/to/repo/root.py",
   "line": 123,
   "category": "A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P",
@@ -29,7 +30,7 @@ Each finding an audit produces MUST be one of exactly two shapes.
 }
 ```
 
-`id` is `loop<N>-<K>` where `N` is the loop counter (1-based) and `K` is the 1-based index within the loop. For `/findbugs` which runs once, use `find<K>`.
+`id` is `loop<L>-<K>` where `L` is the loop counter (1-based) and `K` is the 1-based index within the loop. For `/findbugs` which runs once, use `find<K>`.
 
 ### Shape B — structured proof-of-absence
 
@@ -98,16 +99,16 @@ For single-subagent skills (`/qbug`, `/findbugs`) the LEAD spawns two `Agent()`
 
 Both audit the same diff. The secondary returns findings to the LEAD only — never posted to the PR.
 
-Merge rules:
+Merge rules — applied whenever the LEAD combines findings from multiple sources (primary auditor, Haiku secondary auditor, adversarial pass):
 
-- **De-dup key**: `(file, line, category)`.
-- **Severity conflict**: max wins (P0 > P1 > P2).
-- **Unique-to-Haiku findings**: added to the primary set with Haiku's severity and source annotation.
+- **De-dup key**: `(file, line, category)`. Two findings sharing the same `(file, line, category)` tuple are the same finding and collapse into one entry.
+- **Severity conflict**: max wins (`P0 > P1 > P2`). When sources disagree on severity for the same de-dup key, the merged entry keeps the highest severity.
+- **Unique-to-secondary findings**: added to the merged set with the secondary's severity and source annotation.
 - **Unique-to-primary findings**: kept as-is.
-- **Zero Haiku findings**: primary set trusted; proceed.
-- **Malformed or non-parseable Haiku output**: lead trusts the primary set, logs the event in `loop-<N>-diagnostics.json` under `haiku_findings` as `[{"parse_error": "<message>"}]`.
+- **Zero secondary findings**: the primary set is trusted and the audit moves on.
+- **Malformed or non-parseable secondary output**: lead trusts the primary set and logs the event in `loop-<L>-diagnostics.json` under `haiku_findings` as `[{"parse_error": "<message>"}]`.
 
-For multi-subagent skills (`/bugteam`) the parallel-auditors pattern in [`audit-and-teammates.md`](audit-and-teammates.md) already provides cross-model coverage via the three variant teammates.
+For `/bugteam`, the single audit agent provides per-category coverage by walking all A–P rubrics in one invocation.
 
 ## Post-fix self-audit
 
@@ -128,11 +129,22 @@ Sequence:
 
 `converged` exit condition: `primary_audit_clean AND post_fix_audit_clean` for the committing loop.
 
+## De-dup and merge
+
+Findings from primary, adversarial, Haiku secondary, and post-fix passes are merged into a single deduped finding list before persistence.
+
+- **De-dup key:** `(file, line, category)`. Two findings sharing the same `(file, line, category)` tuple collapse into a single deduped entry.
+- **Severity conflict resolution:** `max wins`. When merged findings disagree on severity, the deduped entry carries the highest severity (`P0 > P1 > P2`).
+- **Excerpt and failure_mode:** the deduped entry inherits these fields from the highest-severity contributing finding. Ties keep the first observed contributor.
+- **`evidence_files`:** the deduped entry carries the union of every contributor's `evidence_files`, deduplicated and sorted.
+
+The merged list lands in `loop-<L>-diagnostics.json` under both `merged` (one entry per contributing finding) and `deduped` (one entry per unique `(file, line, category)` tuple).
+
 ## Persistence
 
 Every audit loop writes two JSON files under the skill's scoped temp directory (resolved via `tempfile.gettempdir()`):
 
-### `loop-<N>-audit.json`
+### `loop-<L>-audit.json`
 
 ```json
 {
@@ -142,7 +154,7 @@ Every audit loop writes two JSON files under the skill's scoped temp directory (
 }
 ```
 
-### `loop-<N>-diagnostics.json`
+### `loop-<L>-diagnostics.json`
 
 ```json
 {

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/_claude_permissions_common.py

@@ -299,9 +299,11 @@ def write_atomically_with_mode(
 
     Raises:
         OSError: When os.open or os.fdopen fails. The raw file descriptor
-            is closed before re-raising so the descriptor does not leak.
+            is closed and the on-disk temporary file is unlinked before
+            re-raising so neither the descriptor nor the file leaks.
         MemoryError: When os.fdopen runs out of buffer memory; the file
-            descriptor is closed before re-raising.
+            descriptor is closed and the temporary file is unlinked
+            before re-raising.
     """
     file_descriptor = os.open(
         str(temporary_path),
@@ -312,6 +314,10 @@ def write_atomically_with_mode(
         writer = os.fdopen(file_descriptor, "w", encoding=TEXT_FILE_ENCODING)
     except (OSError, MemoryError):
         os.close(file_descriptor)
+        try:
+            os.unlink(str(temporary_path))
+        except OSError:
+            pass
         raise
     with writer:
         writer.write(serialized_content)
@@ -321,7 +327,8 @@ def save_settings(settings_path: Path, all_settings: dict[str, object]) -> None:
     """Write settings to a JSON file atomically with permission preservation.
 
     Creates a temporary sibling file, writes content, then atomically
-    replaces the target. Cleans up the temporary file in a finally block.
+    replaces the target. Cleans up the temporary file in a finally block,
+    printing a warning to stderr when that cleanup unlink fails.
 
     Args:
         settings_path: Path to the target settings JSON file.
@@ -352,8 +359,12 @@ def save_settings(settings_path: Path, all_settings: dict[str, object]) -> None:
         if temporary_path.exists():
             try:
                 temporary_path.unlink()
-            except OSError:
-                pass
+            except OSError as unlink_error:
+                print(
+                    f"Warning: could not remove temp file {temporary_path}: "
+                    f"{type(unlink_error).__name__}: {unlink_error}",
+                    file=sys.stderr,
+                )
 
 
 def append_if_missing(all_target_list: list[object], new_value: str) -> bool:

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

@@ -1673,7 +1673,6 @@ def main(all_arguments: list[str]) -> int:
     if arguments.staged:
         all_terminology_findings = staged_terminology_findings(repository_root)
         _report_terminology_findings(all_terminology_findings)
-        terminology_exit_code = 1 if all_terminology_findings else 0
         staged_test_exit_code = run_staged_test_files(repository_root)
         staged_file_paths = paths_from_git_staged(repository_root)
         staged_file_paths = filter_paths_under_prefixes(
@@ -1682,7 +1681,7 @@ def main(all_arguments: list[str]) -> int:
             arguments.only_under,
         )
         if not staged_file_paths:
-            return terminology_exit_code or staged_test_exit_code
+            return staged_test_exit_code
         staged_added_lines = added_lines_by_file_staged(
             repository_root, staged_file_paths
         )
@@ -1693,7 +1692,7 @@ def main(all_arguments: list[str]) -> int:
             all_added_lines_by_path=staged_added_lines,
             read_staged_content_flag=True,
         )
-        return gate_exit_code or terminology_exit_code or staged_test_exit_code
+        return gate_exit_code or staged_test_exit_code
     file_paths = paths_from_git_diff(repository_root, arguments.base)
     file_paths = filter_paths_under_prefixes(
         file_paths,

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/reviews_disabled.py

@@ -103,6 +103,7 @@ def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
         choices=[
             CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN,
             CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN,
+            CLAUDE_REVIEWS_DISABLED_COPILOT_TOKEN,
         ],
         help="Reviewer token to test against CLAUDE_REVIEWS_DISABLED",
     )
@@ -122,6 +123,7 @@ def main(all_arguments: list[str]) -> int:
     disabled_checker_by_reviewer = {
         CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN: is_bugbot_disabled_via_env,
         CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN: is_bugteam_disabled_via_env,
+        CLAUDE_REVIEWS_DISABLED_COPILOT_TOKEN: is_copilot_disabled_via_env,
     }
     return 0 if disabled_checker_by_reviewer[arguments.reviewer]() else 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 |