claude-dev-env 2.9.0 → 2.11.0

package/_shared/pr-loop/audit-contract.md

@@ -1,6 +1,6 @@
 # Audit contract
 
-Shared output schema and audit-loop contract used by `/bugteam`, `/qbug`, `/findbugs`, and `/fixbugs`. Changing a shape here is a breaking change for every consuming skill.
+Shared output schema and audit-loop contract used by `/bugteam`, `clean-room audit (code-quality-agent)`, and `/pr-fix-protocol`. Changing a shape here is a breaking change for every consuming skill.
 
 ## Contents
 
@@ -11,6 +11,17 @@ Shared output schema and audit-loop contract used by `/bugteam`, `/qbug`, `/find
 - De-dup and merge
 - Persistence (loop-<L>-audit.json, loop-<L>-diagnostics.json)
 
+## Collection before severity filtering
+
+Audit collection reports every real finding. The collection record retains all
+seeded severities (`P0`, `P1`, `P2`) and every Shape A field (`file`, `line`,
+`category`, `severity`, `excerpt`, `failure_mode`, `evidence_files`). Do not drop a real finding because its severity is low.
+
+Severity or action filtering is a **separate consumer stage** after collection
+is complete. A consumer may select a subset for fix or posting; it must not
+rewrite the collection record or strip file, line, evidence, or category from
+retained entries.
+
 ## Finding schema
 
 Each finding an audit produces MUST be one of exactly two shapes.
@@ -30,7 +41,7 @@ Each finding an audit produces MUST be one of exactly two shapes.
 }
 ```
 
-`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>`.
+`id` is `loop<L>-<K>` where `L` is the loop counter (1-based) and `K` is the 1-based index within the loop. For `clean-room audit (code-quality-agent)` which runs once, use `find<K>`.
 
 ### Shape B — structured proof-of-absence
 
@@ -92,10 +103,10 @@ The audit must either produce new Shape A findings citing new file:line referenc
 
 ## Haiku secondary auditor
 
-For single-subagent skills (`/qbug`, `/findbugs`) the LEAD spawns two `Agent()` calls in one message:
+For single-subagent skills (`/bugteam`, `clean-room audit (code-quality-agent)`) the LEAD spawns two `Agent()` calls in one message:
 
-- **Primary** — `subagent_type=clean-coder`, `model=sonnet` (for qbug cycle) or `subagent_type=code-quality-agent`, `model=sonnet` (for findbugs clean-room).
-- **Secondary (Haiku)** — `subagent_type=code-quality-agent`, `model=haiku`, same self-contained clean-room prompt shape used by `/findbugs`.
+- **Primary** — `subagent_type=clean-coder`, `model=sonnet` (for `/bugteam` cycle) or `subagent_type=code-quality-agent`, `model=sonnet` (for clean-room audit).
+- **Secondary (Haiku)** — `subagent_type=code-quality-agent`, `model=haiku`, same self-contained clean-room prompt shape used by `clean-room audit (code-quality-agent)`.
 
 Both audit the same diff. The secondary returns findings to the LEAD only — never posted to the PR.
 
@@ -112,7 +123,7 @@ For `/bugteam`, the single audit agent provides per-category coverage by walking
 
 ## Post-fix self-audit
 
-Audit-and-fix skills (`/qbug`, `/bugteam`) MUST re-audit modified files between `py_compile` and `git add`. This catches fix-induced regressions in the same loop that introduced them rather than on loop N+1.
+Audit-and-fix skills (`/bugteam`) MUST re-audit modified files between `py_compile` and `git add`. This catches fix-induced regressions in the same loop that introduced them rather than on loop N+1.
 
 Sequence:
 

package/_shared/pr-loop/audit-reply-template.md

@@ -1,10 +1,10 @@
 # Audit reply template
 
-Canonical reply shape for every orchestrator-to-thread reply posted by the PR-loop suite (`pr-converge`, `bugteam`, `qbug`, and the `clean-coder` agent). Every reply Claude posts to an unresolved review thread on a draft PR uses this template.
+Canonical reply shape for every orchestrator-to-thread reply posted by the PR-loop suite (`pr-converge`, `bugteam`, and the `clean-coder` agent). Every reply Claude posts to an unresolved review thread on a draft PR uses this template.
 
-Read this doc before authoring any code that posts a reply. The template is the contract emitted by every `clean-coder` reply path; the audit-skill wiring (`bugteam`, `qbug`, `pr-converge`) reads it before authoring a reply.
+Read this doc before authoring any code that posts a reply. The template is the contract emitted by every `clean-coder` reply path; the audit-skill wiring (`bugteam`, `pr-converge`) reads it before authoring a reply.
 
-This doc has two surfaces, called out separately so consumers do not conflate them: the **reply template** (this section and below) shapes the body Claude posts back to a single review thread; the **audit body skeleton** in [Relationship to the audit review body](#relationship-to-the-audit-review-body) shapes the parent review `post_audit_thread.py` posts at audit time. The reply-template consumers are the four skills/agents listed above (read-only `findbugs` is excluded — it posts an audit review via `post_audit_thread.py` but never authors thread replies). The audit-body-skeleton consumers include `findbugs` alongside `bugteam` and `qbug` because all three skills post audit reviews via the same script.
+This doc has two surfaces, called out separately so consumers do not conflate them: the **reply template** (this section and below) shapes the body Claude posts back to a single review thread; the **audit body skeleton** in [Relationship to the audit review body](#relationship-to-the-audit-review-body) shapes the parent review `post_audit_thread.py` posts at audit time. The reply-template consumers are the skills/agents listed above (read-only `clean-room audit` is excluded — it posts an audit review via `post_audit_thread.py` but never authors thread replies). The audit-body-skeleton consumers include `clean-room audit` alongside `bugteam` because both post audit reviews via the same script.
 
 ## Provenance
 
@@ -121,7 +121,7 @@ The thread can be resolved without further action; the reviewer's underlying con
 
 ## Relationship to the audit review body
 
-The audit review body posted by `post_audit_thread.py` (consumers: `bugteam`, `findbugs`, `qbug`) shares the same header anchor pattern:
+The audit review body posted by `post_audit_thread.py` (consumers: `bugteam`, `clean-room audit`) shares the same header anchor pattern:
 
 <!-- audit-body-skeleton:start -->
 ```

package/_shared/pr-loop/code-rules-gate.md

@@ -7,7 +7,7 @@ Pre-audit validator run before each AUDIT (and pre-commit when applicable). Wrap
 Canonical: `~/.claude/_shared/pr-loop/scripts/code_rules_gate.py` after install.
 
 Workflows reference it via:
-- all skills (bugteam, qbug, pr-converge, monitor-many): `${CLAUDE_SKILL_DIR}/../../_shared/pr-loop/scripts/code_rules_gate.py`
+- all skills (bugteam, pr-converge): `${CLAUDE_SKILL_DIR}/../../_shared/pr-loop/scripts/code_rules_gate.py`
 
 Cross-skill path traversal works because every skill installs as a flat top-level dir under `~/.claude/skills/` and `_shared/` lives alongside `skills/` under `~/.claude/`.
 
@@ -37,9 +37,7 @@ python "<gate_script>" --base origin/<base_branch> --only-under <prefix> [--only
 ## Workflow integration
 
 - **bugteam:** before every AUDIT in Step 3 of the loop. Non-zero → spawn clean-coder for standards fix; loop until exit 0 or 5 consecutive gate failures → `error: code rules gate failed pre-audit`.
-- **qbug:** before every AUDIT inside the subagent's loop. Three consecutive failures → `error: code rules gate failed pre-audit`.
-- **pr-converge:** before every push in the Fix protocol. Halt on non-zero, fix violations, re-run.
-- **monitor-many:** before every commit during the fix loop. Halt on non-zero, fix violations, re-run.
+- **pr-converge:** before every push in the Fix protocol and before every commit during the fix loop. Halt on non-zero, fix violations, re-run.
 
 ## Coverage
 
@@ -61,4 +59,4 @@ When the gate exits non-zero:
 2. Group violations by file
 3. Apply fixes in the smallest change set (extract constants to `config/`, rename collection params with `all_` prefix, replace literals with named constants, etc.)
 4. Re-run the gate with the same arguments
-5. Cap at 5 consecutive failures (bugteam, monitor-many) or 3 (qbug); on cap exceeded, exit `error`
+5. Cap at 5 consecutive failures (bugteam, pr-converge); on cap exceeded, exit `error`

package/_shared/pr-loop/fix-protocol.md

@@ -42,9 +42,8 @@
 
     Transport: post the reply via [`gh-payloads.md`](gh-payloads.md), then call `pull_request_review_write(method="resolve_thread", threadId=<thread_node_id>, ...)` for the same thread before moving to the next finding (this is the PR review thread node ID — `PRRT_kwDOxxx` — distinct from the numeric comment ID; harvest it at audit time when calling `get_review_comments`, see [`skills/bugteam/reference/obstacles/fix-resolve-thread.md`](../../skills/bugteam/reference/obstacles/fix-resolve-thread.md)).
 13. **Re-trigger reviewer** when the calling workflow specifies. Workflow-specific:
-    - `pr-converge`: post `bugbot run` issue comment after every push (Cursor Bugbot)
-    - `monitor-many`: post `bugbot run` issue comment AND call `requested_reviewers` API for Copilot
-    - `bugteam` / `qbug`: skip — Claude itself is the reviewer; the next loop iteration audits
+    - `pr-converge`: post `bugbot run` issue comment after every push (Cursor Bugbot); when the multi-PR path also needs Copilot, call `requested_reviewers` for Copilot as well
+    - `bugteam`: skip — Claude itself is the reviewer; the next loop iteration audits
 
 ## Stuck detection
 

package/_shared/pr-loop/gh-payloads.md

@@ -1,6 +1,6 @@
 # MCP-based payloads
 
-Shared payload shapes for posting PR reviews and replies. Used by `bugteam`, `qbug`, `pr-converge`, `monitor-many`.
+Shared payload shapes for posting PR reviews and replies. Used by `bugteam` and `pr-converge`.
 
 ## Build payloads with MCP tools
 

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

@@ -14,7 +14,7 @@ Python scripts invoked at runtime by the PR-loop skills. Each script is a standa
 | `stale_worktree_rule_sweep.py` | Drops allow/deny rules pointing at deleted `~/.claude/worktrees/<repo>/<worktree>` directories and deduplicates the rule arrays; run by the grant and revoke flows before they write |
 | `code_rules_gate.py` | Pre-commit gate that runs `code_rules_enforcer` checks on staged Python files before a fix commit lands, and the terminology sweep over the staged diff |
 | `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 reviewer opt-out and opt-in gates; parses `CLAUDE_REVIEWS_DISABLED` tokens `bugteam`, `bugbot`, `copilot`, and `codex`, plus `CLAUDE_REVIEWS_ENABLED` for bugbot opt-in (bugbot is off by default and runs only when `CLAUDE_REVIEWS_ENABLED` lists it) |
+| `reviews_disabled.py` | Shared helper for the reviewer opt-out and opt-in gates; parses `CLAUDE_REVIEWS_DISABLED` tokens `bugteam`, `bugbot`, `copilot`, and `codex`, plus `CLAUDE_REVIEWS_ENABLED` for opt-in. `bugbot`, `bugteam`, and `codex` are off by default and each runs only when `CLAUDE_REVIEWS_ENABLED` lists it; `copilot` runs by default and stops only when `CLAUDE_REVIEWS_DISABLED` lists it |
 | `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 |

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

@@ -1,6 +1,6 @@
 # Shared PR-loop scripts
 
-Runnable helpers used by **bugteam**, **qbug**, **pr-converge**, and related skills. These files are **executed** from the repository (or a `~/.claude` install); they are not meant as primary model-reading context.
+Runnable helpers used by **bugteam**, **pr-converge**, and related skills. These files are **executed** from the repository (or a `~/.claude` install); they are not meant as primary model-reading context.
 
 ## Inventory
 

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

@@ -314,11 +314,13 @@ def _run_diff_mode(
     scoped_added_lines = (
         added_lines_by_file(repository_root, arguments.base, file_paths) if file_paths else {}
     )
+    merge_base_ref = resolve_merge_base(repository_root, arguments.base)
     return run_gate(
         validate_content,
         file_paths,
         repository_root,
         all_added_lines_by_path=scoped_added_lines,
+        prior_ref=merge_base_ref,
     )
 
 

package/_shared/pr-loop/scripts/code_rules_gate_parts/gate_running.py

@@ -96,6 +96,7 @@ def _scoped_violations_for_file(
     repository_root: Path,
     all_added_lines_for_file: set[int] | None,
     should_read_staged_content: bool = False,
+    prior_ref: str = "HEAD",
 ) -> tuple[list[str], list[str]] | None:
     """Validate one resolved file and partition its violations by diff scope."""
     resolved_root = repository_root.resolve()
@@ -106,7 +107,7 @@ def _scoped_violations_for_file(
     if content is None:
         sys.stderr.write(f"code_rules_gate: skip unreadable {resolved_path}\n")
         return None
-    prior_content = read_prior_committed_content(resolved_root, relative_posix)
+    prior_content = read_prior_committed_content(resolved_root, relative_posix, prior_ref)
     issues = validate_content(
         content,
         relative_posix,
@@ -135,6 +136,7 @@ def _partition_over_eligible_paths(
     repository_root: Path,
     all_added_lines_by_path: dict[Path, set[int]] | None,
     should_read_staged_content: bool,
+    prior_ref: str = "HEAD",
 ) -> PartitionedViolations:
     """Validate each already-resolved eligible file and partition the results."""
     blocking_by_file: dict[Path, list[str]] = {}
@@ -147,6 +149,7 @@ def _partition_over_eligible_paths(
             repository_root,
             _added_lines_for(all_added_lines_by_path, each_resolved),
             should_read_staged_content,
+            prior_ref,
         )
         if scoped_violations is None:
             skipped_unreadable_count += 1
@@ -165,6 +168,7 @@ def _collect_partitioned_violations(
     repository_root: Path,
     all_added_lines_by_path: dict[Path, set[int]] | None,
     should_read_staged_content: bool = False,
+    prior_ref: str = "HEAD",
 ) -> PartitionedViolations:
     """Validate every eligible file and partition results, counting read skips."""
     all_eligible_paths = _eligible_resolved_paths(
@@ -176,6 +180,7 @@ def _collect_partitioned_violations(
         repository_root,
         all_added_lines_by_path,
         should_read_staged_content,
+        prior_ref,
     )
 
 
@@ -266,6 +271,7 @@ def _validate_and_count(
     repository_root: Path,
     all_added_lines_by_path: dict[Path, set[int]] | None,
     should_read_staged_content: bool,
+    prior_ref: str = "HEAD",
 ) -> PartitionedViolations:
     """Validate the eligible files, report the inspected count, return partitions."""
     all_eligible_paths = _eligible_resolved_paths(
@@ -277,6 +283,7 @@ def _validate_and_count(
         repository_root,
         all_added_lines_by_path,
         should_read_staged_content,
+        prior_ref,
     )
     _report_inspected_count(len(all_eligible_paths) - skipped_count)
     return blocking_by_file, advisory_by_file, skipped_count
@@ -288,6 +295,7 @@ def run_gate(
     repository_root: Path,
     all_added_lines_by_path: dict[Path, set[int]] | None = None,
     should_read_staged_content: bool = False,
+    prior_ref: str = "HEAD",
 ) -> int:
     """Run the gate over *all_file_paths* and emit a partitioned report.
 
@@ -297,6 +305,12 @@ def run_gate(
         repository_root: Repository root for resolving relative paths.
         all_added_lines_by_path: Per-file added-line maps, or None.
         should_read_staged_content: When True, validate staged blobs.
+        prior_ref: The git ref each file's grandfathering baseline is read
+            from. Defaults to ``HEAD`` (staged and explicit-paths mode); diff
+            mode passes the merge-base with the diff's base branch so a
+            fragment-baselined finding (such as ``check_comment_changes``)
+            grandfathers against the branch's starting point, not its own
+            latest commit.
 
     Returns:
         Zero when clean; non-zero on a blocking violation or a skipped file.
@@ -307,6 +321,7 @@ def run_gate(
         repository_root,
         all_added_lines_by_path,
         should_read_staged_content,
+        prior_ref,
     )
     return _report_partitioned_violations(
         partitions, repository_root, all_added_lines_by_path is None

package/_shared/pr-loop/scripts/code_rules_gate_parts/git_blob_readers.py

@@ -12,19 +12,25 @@ from pathlib import Path
 from terminology_sweep import repository_environment
 
 
-def read_prior_committed_content(repository_root: Path, relative_path_posix: str) -> str:
-    """Return the HEAD-committed content for *relative_path_posix*.
+def read_prior_committed_content(
+    repository_root: Path, relative_path_posix: str, ref: str = "HEAD"
+) -> str:
+    """Return *ref*'s committed content for *relative_path_posix*.
 
     Args:
         repository_root: Repository root used as the ``git -C`` target.
         relative_path_posix: Repository-relative POSIX path to read.
+        ref: The git ref to read the blob from. Defaults to ``HEAD`` for
+            staged and explicit-paths mode; diff mode passes the merge-base
+            with the diff's base branch so grandfathering compares against
+            the branch's starting point rather than its own latest commit.
 
     Returns:
-        The committed content at HEAD, or an empty string when the path is not
-        tracked or ``git show`` returns non-zero.
+        The committed content at *ref*, or an empty string when the path is
+        not tracked there or ``git show`` returns non-zero.
     """
     completed = subprocess.run(
-        ["git", "show", f"HEAD:{relative_path_posix}"],
+        ["git", "show", f"{ref}:{relative_path_posix}"],
         cwd=str(repository_root),
         capture_output=True,
         text=True,

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

@@ -43,6 +43,7 @@ from preflight_self_heal import silently_clear_stale_local_hooks_path_override
 from reviews_disabled import (
     CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN,
     CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME,
+    CLAUDE_REVIEWS_ENABLED_ENV_VAR_NAME,
     EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV,
     is_bugteam_disabled_via_env,
 )
@@ -467,8 +468,10 @@ def main(all_arguments: list[str]) -> int:
 
     Returns:
         Zero on success. Non-zero exit code on the first failing check.
-        Returns :data:`EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV` when
-        ``CLAUDE_REVIEWS_DISABLED`` lists the ``bugteam`` token.
+        Returns :data:`EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV` when bugteam is off
+        for this run. Bugteam is off by default, so that happens when
+        ``CLAUDE_REVIEWS_ENABLED`` omits the ``bugteam`` token, and also when
+        ``CLAUDE_REVIEWS_DISABLED`` lists it.
     """
     arguments = parse_arguments(all_arguments)
     skip_env_var_name = BUGTEAM_PREFLIGHT_SKIP_ENV_VAR_NAME
@@ -480,13 +483,15 @@ def main(all_arguments: list[str]) -> int:
         )
         return 0
     reviews_disabled_env_var_name = CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME
+    reviews_enabled_env_var_name = CLAUDE_REVIEWS_ENABLED_ENV_VAR_NAME
     reviews_disabled_bugteam_token = CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN
     disabled_via_env_exit_code = EXIT_CODE_BUGTEAM_DISABLED_VIA_ENV
     if is_bugteam_disabled_via_env():
         print(
             f"bugteam_preflight: halted "
-            f"({reviews_disabled_env_var_name} contains "
-            f"'{reviews_disabled_bugteam_token}').",
+            f"({reviews_enabled_env_var_name} omits "
+            f"'{reviews_disabled_bugteam_token}', or "
+            f"{reviews_disabled_env_var_name} lists it).",
             file=sys.stderr,
         )
         return disabled_via_env_exit_code

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

@@ -5,13 +5,17 @@
     enabled lists bugbot, disabled empty    -> bugbot   ok:   runs
     no lists set                            -> bugbot   flag: off (default)
     enabled lists bugbot, disabled bugbot   -> bugbot   flag: off (opt-out wins)
-    disabled empty                          -> bugteam  ok:   runs
+    enabled lists bugteam, disabled empty   -> bugteam  ok:   runs
+    no lists set                            -> bugteam  flag: off (default)
+    no lists set                            -> codex    flag: off (default)
+    disabled empty                          -> copilot  ok:   runs
     disabled lists copilot                  -> copilot  flag: off
-    disabled lists codex                    -> codex    flag: off
 
-Bugbot is off by default and runs only when the enabled list names it.
-Bugteam, copilot, and codex run by default and stop only when the disabled
-list names them; both lists parse case-insensitively and tolerate whitespace.
+Bugbot, bugteam, and codex are off by default. Each runs only when the
+enabled list names it. A token in the disabled list forces one off even
+when the enabled list names it too. Copilot runs by default and stops only
+when the disabled list names it. Both lists parse case-insensitively and
+tolerate whitespace.
 """
 
 from __future__ import annotations
@@ -75,15 +79,42 @@ def _is_reviewer_listed_in_env(
     return reviewer_token in all_listed_tokens
 
 
-def is_bugteam_disabled_via_env() -> bool:
-    """Check whether CLAUDE_REVIEWS_DISABLED opts the bug-audit family out.
+def _is_off_by_default_reviewer_disabled(reviewer_token: str) -> bool:
+    """Decide whether an opt-in reviewer stays off for this run.
+
+    ::
+
+        enabled lists the token, disabled empty  -> False  (runs)
+        neither list names the token             -> True   (off by default)
+        both lists name the token                -> True   (opt-out wins)
+
+    Args:
+        reviewer_token: The lowercase reviewer token to look up in both lists.
 
     Returns:
-        True when the env var lists the ``bugteam`` token.
+        True when the reviewer stays off for this run.
     """
-    return _is_reviewer_listed_in_env(
-        CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME, CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN
+    is_opted_out = _is_reviewer_listed_in_env(
+        CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME, reviewer_token
     )
+    is_opted_in = _is_reviewer_listed_in_env(
+        CLAUDE_REVIEWS_ENABLED_ENV_VAR_NAME, reviewer_token
+    )
+    return is_opted_out or not is_opted_in
+
+
+def is_bugteam_disabled_via_env() -> bool:
+    """Check whether the bug-audit family stays off for this run.
+
+    The bug-audit family is off by default. It runs only when
+    ``CLAUDE_REVIEWS_ENABLED`` lists ``bugteam``, and a ``bugteam`` token in
+    ``CLAUDE_REVIEWS_DISABLED`` forces it off even when the opt-in lists it.
+
+    Returns:
+        True when ``CLAUDE_REVIEWS_DISABLED`` lists ``bugteam`` or when
+        ``CLAUDE_REVIEWS_ENABLED`` does not list ``bugteam``.
+    """
+    return _is_off_by_default_reviewer_disabled(CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN)
 
 
 def is_bugbot_disabled_via_env() -> bool:
@@ -97,13 +128,7 @@ def is_bugbot_disabled_via_env() -> bool:
         True when ``CLAUDE_REVIEWS_DISABLED`` lists ``bugbot`` or when
         ``CLAUDE_REVIEWS_ENABLED`` does not list ``bugbot``.
     """
-    is_opted_out = _is_reviewer_listed_in_env(
-        CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME, CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN
-    )
-    is_opted_in = _is_reviewer_listed_in_env(
-        CLAUDE_REVIEWS_ENABLED_ENV_VAR_NAME, CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN
-    )
-    return is_opted_out or not is_opted_in
+    return _is_off_by_default_reviewer_disabled(CLAUDE_REVIEWS_DISABLED_BUGBOT_TOKEN)
 
 
 def is_bugbot_opted_out_via_env() -> bool:
@@ -134,14 +159,17 @@ def is_copilot_disabled_via_env() -> bool:
 
 
 def is_codex_disabled_via_env() -> bool:
-    """Check whether CLAUDE_REVIEWS_DISABLED opts the Codex reviewer out.
+    """Check whether the Codex reviewer stays off for this run.
+
+    Codex is off by default. It runs only when ``CLAUDE_REVIEWS_ENABLED``
+    lists ``codex``, and a ``codex`` token in ``CLAUDE_REVIEWS_DISABLED``
+    forces it off even when the opt-in lists it.
 
     Returns:
-        True when the env var lists the ``codex`` token.
+        True when ``CLAUDE_REVIEWS_DISABLED`` lists ``codex`` or when
+        ``CLAUDE_REVIEWS_ENABLED`` does not list ``codex``.
     """
-    return _is_reviewer_listed_in_env(
-        CLAUDE_REVIEWS_DISABLED_ENV_VAR_NAME, CLAUDE_REVIEWS_DISABLED_CODEX_TOKEN
-    )
+    return _is_off_by_default_reviewer_disabled(CLAUDE_REVIEWS_DISABLED_CODEX_TOKEN)
 
 
 def parse_arguments(all_argv: list[str]) -> argparse.Namespace:

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

@@ -1 +1,21 @@
 """Test fixtures for _shared/pr-loop/scripts/tests/."""
+
+import pytest
+from pr_loop_shared_constants.reviews_disabled_constants import (
+    CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN,
+    CLAUDE_REVIEWS_ENABLED_ENV_VAR_NAME,
+)
+
+
+@pytest.fixture(autouse=True)
+def opt_bugteam_in(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Opt bugteam in so each case exercises its own check, not the default off.
+
+    Bugteam is off by default, so a preflight case that never mentions the
+    reviewer lists halts on the opt-in check before reaching the behavior it
+    was written for. A case that tests those lists overrides this from its own
+    body, where monkeypatch runs after the fixture.
+    """
+    monkeypatch.setenv(
+        CLAUDE_REVIEWS_ENABLED_ENV_VAR_NAME, CLAUDE_REVIEWS_DISABLED_BUGTEAM_TOKEN
+    )

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

@@ -200,9 +200,9 @@ def test_is_valid_project_root_uses_extracted_directory_marker_constants() -> No
 
 def test_permission_rule_tool_name_extracts_tool_prefix() -> None:
     assert common.permission_rule_tool_name("Edit(/repo/.claude/**)") == "Edit"
-    assert common.permission_rule_tool_name("Write(c:/Users/jon/.claude/worktrees/x/**)") == (
-        "Write"
-    )
+    assert common.permission_rule_tool_name(
+        "Write(c:/Users/example/.claude/worktrees/x/**)"
+    ) == ("Write")
     assert common.permission_rule_tool_name(None) is None
     assert common.permission_rule_tool_name("not-a-rule") is None
 
@@ -217,13 +217,13 @@ def test_is_inert_file_permission_rule_for_write_glob_notebookedit() -> None:
 
 def test_all_project_path_aliases_for_reap_adds_home_alias_when_project_is_home() -> None:
     all_aliases = common.all_project_path_aliases_for_reap(
-        "C:/Users/jon", home_directory_path="C:/Users/jon"
+        "C:/Users/example", home_directory_path="C:/Users/example"
     )
-    assert all_aliases == ("C:/Users/jon", "$HOME")
+    assert all_aliases == ("C:/Users/example", "$HOME")
 
 
 def test_all_project_path_aliases_for_reap_skips_home_alias_for_other_projects() -> None:
     all_aliases = common.all_project_path_aliases_for_reap(
-        "C:/dev/other", home_directory_path="C:/Users/jon"
+        "C:/dev/other", home_directory_path="C:/Users/example"
     )
     assert all_aliases == ("C:/dev/other",)

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

@@ -29,13 +29,30 @@ def test_is_bugteam_disabled_via_env_returns_true_when_env_lists_bugteam(
     assert reviews_disabled.is_bugteam_disabled_via_env() is True
 
 
-def test_is_bugteam_disabled_via_env_returns_false_when_env_is_empty(
+def test_is_bugteam_disabled_via_env_returns_true_when_no_env_vars_set(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.delenv("CLAUDE_REVIEWS_ENABLED", raising=False)
+    assert reviews_disabled.is_bugteam_disabled_via_env() is True
+
+
+def test_is_bugteam_disabled_via_env_returns_false_when_enabled_lists_bugteam(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.setenv("CLAUDE_REVIEWS_ENABLED", "bugteam")
     assert reviews_disabled.is_bugteam_disabled_via_env() is False
 
 
+def test_is_bugteam_disabled_via_env_true_when_disabled_overrides_enabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugteam")
+    monkeypatch.setenv("CLAUDE_REVIEWS_ENABLED", "bugteam")
+    assert reviews_disabled.is_bugteam_disabled_via_env() is True
+
+
 def test_is_bugbot_disabled_via_env_returns_true_when_env_lists_bugbot(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -150,20 +167,30 @@ def test_is_codex_disabled_via_env_returns_true_when_env_lists_codex(
     assert reviews_disabled.is_codex_disabled_via_env() is True
 
 
-def test_is_codex_disabled_via_env_returns_false_when_env_is_empty(
+def test_is_codex_disabled_via_env_returns_true_when_no_env_vars_set(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
-    assert reviews_disabled.is_codex_disabled_via_env() is False
+    monkeypatch.delenv("CLAUDE_REVIEWS_ENABLED", raising=False)
+    assert reviews_disabled.is_codex_disabled_via_env() is True
 
 
-def test_is_codex_disabled_via_env_returns_false_when_only_bugbot_listed(
+def test_is_codex_disabled_via_env_returns_false_when_enabled_lists_codex(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugbot")
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.setenv("CLAUDE_REVIEWS_ENABLED", "codex")
     assert reviews_disabled.is_codex_disabled_via_env() is False
 
 
+def test_is_codex_disabled_via_env_true_when_only_bugbot_enabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.setenv("CLAUDE_REVIEWS_ENABLED", "bugbot")
+    assert reviews_disabled.is_codex_disabled_via_env() is True
+
+
 def test_is_codex_disabled_via_env_true_when_listed_among_other_tokens(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -223,8 +250,25 @@ def test_cli_main_supports_codex_reviewer(
     assert reviews_disabled.main(["--reviewer", "codex"]) == 0
 
 
-def test_cli_main_returns_one_for_codex_when_only_bugbot_disabled(
+def test_cli_main_returns_one_for_codex_when_enabled_via_env(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     monkeypatch.setenv("CLAUDE_REVIEWS_DISABLED", "bugbot")
+    monkeypatch.setenv("CLAUDE_REVIEWS_ENABLED", "codex")
     assert reviews_disabled.main(["--reviewer", "codex"]) == 1
+
+
+def test_cli_main_returns_one_for_bugteam_when_enabled_via_env(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.setenv("CLAUDE_REVIEWS_ENABLED", "bugteam")
+    assert reviews_disabled.main(["--reviewer", "bugteam"]) == 1
+
+
+def test_cli_main_returns_zero_for_bugteam_when_no_env_vars_set(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delenv("CLAUDE_REVIEWS_DISABLED", raising=False)
+    monkeypatch.delenv("CLAUDE_REVIEWS_ENABLED", raising=False)
+    assert reviews_disabled.main(["--reviewer", "bugteam"]) == 0

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

@@ -114,7 +114,7 @@ def test_revoke_strips_inert_write_glob_notebookedit_on_foreign_worktree_paths(
     (project_directory / ".git").mkdir()
     settings_path = tmp_path / "home" / ".claude" / "settings.json"
     foreign_worktree = (
-        "c:/Users/jon/.claude/worktrees/claude-dev-env-702a0c2055d2/other-wt"
+        "c:/Users/example/.claude/worktrees/claude-dev-env-702a0c2055d2/other-wt"
     )
     live_other_project = "C:/dev/live-other-project"
     settings_path.parent.mkdir(parents=True, exist_ok=True)

package/_shared/pr-loop/state-schema.md

@@ -23,19 +23,13 @@ Adds:
 - `pre_fix_sha` — `git rev-parse HEAD` immediately before each FIX
 - `gate_round_count` — consecutive pre-audit gate failures (cap: 5 → exit `error`)
 
-State lives inline in the lead session (orchestrator). Cleared on TeamDelete.
-
-### qbug
-
-Adds nothing beyond common. Single subagent loops internally and returns a final summary; orchestrator discards intermediate state. Subagent's loop counter and findings return in the exit payload (`{exit_reason, loop_count, final_commit_sha, audit_log, unresolved}`).
+State lives inline in the lead session (orchestrator). Cleared on TeamDelete. A single-subagent cycle returns its loop counter and findings in the exit payload (`{exit_reason, loop_count, final_commit_sha, audit_log, unresolved}`); the orchestrator discards intermediate state.
 
 ### pr-converge
 
 Normative field list, phase enum, dual persistence, and reset semantics: [`../../skills/pr-converge/reference/state-schema.md`](../../skills/pr-converge/reference/state-schema.md). File-backed multi-PR `status` enum: [`../../skills/pr-converge/reference/multi-pr-orchestration.md`](../../skills/pr-converge/reference/multi-pr-orchestration.md).
 
-### monitor-many
-
-Adds per-PR JSON state file at `~/.claude/skills/monitor-many/state/<owner>-<repo>-<pr_number>.json`:
+Multi-PR runs also keep a per-PR JSON state file at `~/.claude/skills/pr-converge/state/<owner>-<repo>-<pr_number>.json`:
 
 | Field | Type | Description |
 |---|---|---|
@@ -51,12 +45,9 @@ Adds per-PR JSON state file at `~/.claude/skills/monitor-many/state/<owner>-<rep
 ## Reset semantics
 
 - bugteam: cleared on each new `/bugteam` invocation
-- qbug: cleared on each new `/qbug` invocation
-- pr-converge: see [`../../skills/pr-converge/reference/state-schema.md`](../../skills/pr-converge/reference/state-schema.md)
-- monitor-many: persists across orchestrator runs; only `last_seen_comment_id` advances monotonically
+- pr-converge: see [`../../skills/pr-converge/reference/state-schema.md`](../../skills/pr-converge/reference/state-schema.md); multi-PR file state persists across orchestrator runs and only `last_seen_comment_id` advances monotonically
 
 ## Convergence checks
 
-- bugteam, qbug: `last_action == "audited"` AND `last_findings.total == 0` → `converged`
-- pr-converge: see [`../../skills/pr-converge/reference/convergence-gates.md`](../../skills/pr-converge/reference/convergence-gates.md)
-- monitor-many: no unresolved comments requiring code changes AND required checks green AND review policy satisfied → `gh pr ready`
+- bugteam: `last_action == "audited"` AND `last_findings.total == 0` → `converged`
+- pr-converge: see [`../../skills/pr-converge/reference/convergence-gates.md`](../../skills/pr-converge/reference/convergence-gates.md); multi-PR ready when no unresolved comments require code changes, required checks are green, and review policy is satisfied → `gh pr ready`