claude-dev-env 1.39.0 → 1.40.0

package/skills/findbugs/SKILL.md

@@ -18,6 +18,16 @@ User types `/findbugs` or asks for a bug audit on the current branch's PR. Typic
 
 If the current branch has no associated PR and no diff against the default branch, say so and stop. Do not invent scope.
 
+## Refusals
+
+First match wins; respond with the quoted line exactly and stop:
+
+- **Disabled via environment.** When `CLAUDE_REVIEWS_DISABLED` contains the
+  token `bugteam` (comma-separated, case-insensitive, whitespace-tolerant):
+  `/findbugs is disabled via CLAUDE_REVIEWS_DISABLED.` `/findbugs` is a PR
+  bug-audit skill in the same family as `/bugteam` and `/qbug`, so the
+  shared `bugteam` token disables all three.
+
 ## The Process
 
 ### Step 1: Resolve PR scope
@@ -120,13 +130,31 @@ returns findings without posting them as inline comments is invisible
 to the gate. Findbugs remains read-only on code — the review post is
 the only side effect.
 
-**Self-PR precondition.** GitHub rejects both `APPROVE` and
-`REQUEST_CHANGES` reviews when the authenticated identity matches the
-PR author with HTTP 422; `post_audit_thread.py` retries and then exits 2.
-To run findbugs on a PR you authored, switch `gh auth` to an alternate
-reviewer identity (a separate GitHub account) BEFORE invoking the skill.
-Without this switch, exit 2 is a hard halt — there is no automated
-fallback path. The script does not auto-downgrade on the self-PR case.
+**Self-PR auto-toggle.** GitHub rejects both `APPROVE` and
+`REQUEST_CHANGES` reviews with HTTP 422 when the authenticated identity
+matches the PR author ("Cannot approve/request changes on your own pull
+request"). `post_audit_thread.py` detects this case via `gh api user` +
+`gh api repos/<o>/<r>/pulls/<n>` and auto-resolves an alternate gh
+account's token for the reviews POST — the active `gh auth` account is
+not mutated; only the bearer token sent on the request changes. After
+the POST the active account is still whoever it was before, so no
+"swap back" step is needed.
+
+Configuration:
+
+- `GH_TOKEN` / `GITHUB_TOKEN` env vars take precedence over the toggle.
+  Set them when you need to pin a specific reviewer identity by token
+  rather than by account login.
+- `BUGTEAM_REVIEWER_ACCOUNT` env var names which authenticated alternate
+  to prefer when a toggle is needed (for example,
+  `BUGTEAM_REVIEWER_ACCOUNT=jl-cmd`). The env var name is shared across
+  every skill that invokes `post_audit_thread.py`. When unset, the
+  script falls back to the first alternate account `gh auth status`
+  reports.
+- The named alternate must be logged in (`gh auth login -h github.com -u
+  <login>`) before the audit skill runs. The script exits 1 with a
+  pointing-at-`gh auth login` message when self-PR is detected and no
+  usable alternate is authenticated.
 
 After the agent (and Haiku secondary) return and the merge is complete,
 serialize the merged findings to a JSON file and call

package/skills/monitor-open-prs/SKILL.md

@@ -27,6 +27,7 @@ description: >-
 
 Refusals — first match wins; respond with the quoted line exactly and stop:
 
+- **Disabled via environment.** When `CLAUDE_REVIEWS_DISABLED` (comma-separated, case-insensitive, whitespace-tolerant) contains the token `bugteam`: `/monitor-open-prs is a /bugteam dispatcher and /bugteam is disabled via CLAUDE_REVIEWS_DISABLED.`
 - **GitHub API not accessible.** `get_me failed. /monitor-open-prs needs active GitHub MCP credentials.`
 - **Dirty tree on the caller's repo.** `Uncommitted changes detected. Stash, commit, or revert before /monitor-open-prs.`
 - **Required subagents missing.** Confirm `code-quality-agent` and `clean-coder` exist. Else: `Required subagent type <name> not installed.`
@@ -40,7 +41,7 @@ Call `scripts/discover_open_prs.discover_open_prs(all_owners=["jl-cmd", "JonEcho
 For each discovered PR:
 
 1. Resolve the PR's repo checkout (existing worktree or fresh `git clone`).
-2. From that checkout, invoke `/bugteam --bugbot-retrigger <pr_number>`.
+2. From that checkout, invoke `/bugteam --bugbot-retrigger <pr_number>`. When `CLAUDE_REVIEWS_DISABLED` (comma-separated, case-insensitive, whitespace-tolerant) contains the token `bugbot`, omit `--bugbot-retrigger` from the dispatched command so the bugbot leg sits out the run.
 3. The `--bugbot-retrigger` flag tells bugteam to post `bugbot run` as an issue comment after every successful FIX push so Cursor's bugbot re-evaluates the new commit.
 4. Bugteam runs its own 20-loop audit/fix cycle per PR; this skill waits for each bugteam invocation to return before dispatching the next (or fanning out — see below).
 

package/skills/pr-converge/SKILL.md

@@ -136,7 +136,9 @@ no longer applies.
             - [ ] `bugbot_clean_at = current_head`
             - [ ] Advance to Step 5
       - [ ] **no review yet / commit_id mismatch** →
-            - [ ] Run `python ~/.claude/skills/pr-converge/scripts/check_bugbot_ci.py --owner <O> --repo <R> --check-active --sha <current_head>`
+            - [ ] Run `python ~/.claude/skills/pr-converge/scripts/check_bugbot_ci.py --owner <O> --repo <R> --check-clean --sha <current_head>`
+            - [ ] Exit 0 (bugbot CI completed with success/neutral conclusion and no review = silent pass) → `bugbot_clean_at = current_head` → advance to Step 5
+            - [ ] Exit 1 (not a silent pass) or Exit 2 (gh CLI error — silent pass not confirmable) → Run `python ~/.claude/skills/pr-converge/scripts/check_bugbot_ci.py --owner <O> --repo <R> --check-active --sha <current_head>`
             - [ ] Exit 0 (already queued) → schedule 360s wakeup → return to Step 4 next tick
             - [ ] Exit 1 → post exactly `bugbot run` via `add_issue_comment` (no `@cursor[bot]` mention, no other text), wait 8s
             - [ ] Run `python ~/.claude/skills/pr-converge/scripts/check_bugbot_ci.py --owner <O> --repo <R> --sha <current_head>`

package/skills/pr-converge/config/constants.py

@@ -27,6 +27,7 @@ BUGBOT_DIRTY_BODY_REGEX = (
 )
 BUGBOT_CHECK_RUN_NAME_SUBSTRING = "bugbot"
 ALL_BUGBOT_CHECK_RUN_ACTIVE_STATUSES = ("queued", "in_progress")
+BUGBOT_CHECK_RUN_COMPLETED_STATUS = "completed"
 ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS = ("success", "neutral")
 BUGBOT_RUN_TRIGGER_PHRASE = "bugbot run\n"
 BUGBOT_RUN_TRIGGER_WAIT_SECONDS = 8

package/skills/pr-converge/reference/per-tick.md

@@ -207,6 +207,14 @@ BUGBOT.
 
 ## Step 3: Re-trigger bugbot
 
+- [ ] **Opt-out gate.** When `CLAUDE_REVIEWS_DISABLED` (comma-separated,
+  case-insensitive, whitespace-tolerant) contains `bugbot`, set
+  `bugbot_down = true`, skip every check below, set `phase = BUGTEAM`,
+  and continue BUGTEAM in the same tick. The downstream loop branches on
+  `bugbot_down` exactly the way it does when bugbot CI is unavailable.
+- [ ] **Silent-pass pre-check.** Run `python ~/.claude/skills/pr-converge/scripts/check_bugbot_ci.py --check-clean --owner <O> --repo <R> --sha <current_head>`
+- [ ] Exit 0 → bugbot CI completed clean with no review (silent pass); set `bugbot_clean_at = current_head`, `phase = BUGTEAM`, continue BUGTEAM same tick
+- [ ] Exit 1 (not a silent pass) or Exit 2 (gh CLI error — silent pass not confirmable) → continue with the trigger flow below
 - [ ] Run `python ~/.claude/skills/pr-converge/scripts/check_bugbot_ci.py --check-active --owner <O> --repo <R> --sha <current_head>`
 - [ ] Exit 0 → bugbot already queued on this commit; skip posting, wait for completion
 - [ ] Exit 1 → post trigger via `add_issue_comment(owner="OWNER", repo="REPO", issueNumber=NUMBER, body="bugbot run")`
@@ -215,6 +223,15 @@ BUGBOT.
 - [ ] Exit non-zero → bugbot is down; set `bugbot_down = true`, `phase = BUGTEAM`, continue BUGTEAM same tick
 - [ ] Exit 0 (check run present) → record `bugbot_acknowledged_at = <now ISO 8601>`, proceed to Step 4
 
+The silent-pass pre-check fires FIRST so we never re-trigger a bot that
+already finished cleanly. Cursor Bugbot communicates "no findings" by
+completing the CI check with `conclusion: success` (or `neutral`) and
+posting no review. The pre-check treats that outcome as
+`bugbot_clean_at = current_head`, equivalent to an explicit clean
+review. Without it, the trigger flow would re-prompt a bot that has
+already evaluated this commit and refuses to re-run, and the bypass
+branch would falsely mark `bugbot_down = true`.
+
 `bugbot run` is empirically the only re-trigger Cursor Bugbot recognizes;
 alternative phrasings silently no-op.
 

package/skills/pr-converge/scripts/check_bugbot_ci.py

@@ -2,11 +2,23 @@
 
 Usage:
   python scripts/check_bugbot_ci.py --owner <O> --repo <R> --sha <SHA>
+  python scripts/check_bugbot_ci.py --owner <O> --repo <R> --sha <SHA> --check-active
+  python scripts/check_bugbot_ci.py --owner <O> --repo <R> --sha <SHA> --check-clean
 
-Exit codes:
+Default mode (no flag):
   0 — bugbot check run found (printed to stdout as JSON)
   1 — no bugbot check run found
   EXIT_CODE_GH_ERROR — gh CLI error
+
+``--check-active`` mode:
+  0 — bugbot check run is queued or in_progress
+  1 — bugbot check run is absent or no longer active
+
+``--check-clean`` mode (silent-pass detection):
+  0 — bugbot check run is completed with success/neutral conclusion
+  1 — bugbot check run is absent, still active, or completed with a
+      non-clean conclusion (failure, action_required, etc.)
+  EXIT_CODE_GH_ERROR — gh CLI error
 """
 
 from __future__ import annotations
@@ -23,6 +35,8 @@ if str(_pr_converge_dir) not in sys.path:
 
 from config.constants import (
     ALL_BUGBOT_CHECK_RUN_ACTIVE_STATUSES,
+    ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS,
+    BUGBOT_CHECK_RUN_COMPLETED_STATUS,
     BUGBOT_CHECK_RUN_NAME_SUBSTRING,
     CHECK_RUNS_PER_PAGE,
     EXIT_CODE_GH_ERROR,
@@ -121,6 +135,74 @@ def is_bugbot_run_active(*, owner: str, repo: str, sha: str) -> bool:
     return False
 
 
+def _classify_bugbot_check_run(
+    completed_process: subprocess.CompletedProcess[str],
+) -> bool | None:
+    """Classify the bugbot check run state from a gh API process result.
+
+    Args:
+        completed_process: Result of calling ``_run_check_runs_api``.
+
+    Returns:
+        True when the captured stdout contains a bugbot check run with a
+        ``completed`` status and a conclusion in
+        ``ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS``. False when no such
+        check run is present (absent, still active, or completed with a
+        non-clean conclusion). None when ``completed_process.returncode``
+        is non-zero, signalling a gh CLI failure that the caller must
+        surface separately from "not clean".
+    """
+    if completed_process.returncode != 0:
+        return None
+    for each_line in completed_process.stdout.splitlines():
+        stripped_line = each_line.strip()
+        if not stripped_line:
+            continue
+        try:
+            check_entry: dict[str, object] = json.loads(stripped_line)
+        except json.JSONDecodeError:
+            continue
+        each_name: object = check_entry.get("name")
+        if not isinstance(each_name, str):
+            continue
+        if BUGBOT_CHECK_RUN_NAME_SUBSTRING.lower() not in each_name.lower():
+            continue
+        each_status: object = check_entry.get("status")
+        if each_status != BUGBOT_CHECK_RUN_COMPLETED_STATUS:
+            return False
+        each_conclusion: object = check_entry.get("conclusion")
+        return (
+            isinstance(each_conclusion, str)
+            and each_conclusion in ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS
+        )
+    return False
+
+
+def is_bugbot_run_clean(*, owner: str, repo: str, sha: str) -> bool | None:
+    """Check whether bugbot has a completed check run with a clean conclusion.
+
+    A "silent pass" is bugbot's signal that it found no issues: the CI
+    check run completes with a ``success`` or ``neutral`` conclusion and
+    no review comment is posted. This function detects that signal so
+    callers can treat it as equivalent to an explicit clean review.
+
+    Args:
+        owner: GitHub repository owner.
+        repo: GitHub repository name.
+        sha: Commit SHA to check.
+
+    Returns:
+        True when a bugbot check run is completed with a conclusion in
+        ``ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS``. False when the
+        check run is absent, still active, or completed with a non-clean
+        conclusion. None when the gh CLI returns an error so the caller
+        can distinguish a transient API failure from a "not clean"
+        result.
+    """
+    completed_process = _run_check_runs_api(owner=owner, repo=repo, sha=sha)
+    return _classify_bugbot_check_run(completed_process)
+
+
 def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
     """Parse command-line arguments.
 
@@ -128,18 +210,28 @@ def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
         all_argv: Command-line argument list.
 
     Returns:
-        Parsed namespace with owner, repo, and sha.
+        Parsed namespace with owner, repo, sha, and mode flags.
     """
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--owner", required=True, help="GitHub repository owner")
     parser.add_argument("--repo", required=True, help="GitHub repository name")
     parser.add_argument("--sha", required=True, help="Commit SHA to check")
-    parser.add_argument(
+    mode_group = parser.add_mutually_exclusive_group()
+    mode_group.add_argument(
         "--check-active",
         action="store_true",
         default=False,
         help="Check for active (queued/in-progress) check runs only",
     )
+    mode_group.add_argument(
+        "--check-clean",
+        action="store_true",
+        default=False,
+        help=(
+            "Check for a completed bugbot check run with a "
+            "success/neutral conclusion (silent-pass detection)"
+        ),
+    )
     return parser.parse_args(all_argv)
 
 
@@ -150,19 +242,32 @@ def main(all_arguments: list[str]) -> int:
         all_arguments: Command-line arguments.
 
     Returns:
-        0 when a bugbot check run is found, 1 when absent,
-        EXIT_CODE_GH_ERROR on error.
+        Exit code per the mode-specific contract documented in the
+        module docstring.
     """
     arguments = parse_arguments(all_arguments)
+    if arguments.check_clean:
+        completed_process = _run_check_runs_api(
+            owner=arguments.owner,
+            repo=arguments.repo,
+            sha=arguments.sha,
+        )
+        if completed_process.returncode != 0:
+            print(f"gh api error: {completed_process.stderr}", file=sys.stderr)
+            return EXIT_CODE_GH_ERROR
+        is_clean = _classify_bugbot_check_run(completed_process)
+        if is_clean is not True:
+            print("bugbot: not clean")
+        return 0 if is_clean is True else 1
     if arguments.check_active:
-        found = is_bugbot_run_active(
+        is_active = is_bugbot_run_active(
             owner=arguments.owner,
             repo=arguments.repo,
             sha=arguments.sha,
         )
-        if not found:
+        if not is_active:
             print("bugbot: not found")
-        return 0 if found else 1
+        return 0 if is_active else 1
     return check_bugbot_ci(
         owner=arguments.owner,
         repo=arguments.repo,

package/skills/pr-converge/scripts/test_check_bugbot_ci.py

@@ -0,0 +1,312 @@
+"""Tests for check_bugbot_ci silent-pass detection.
+
+Covers:
+- is_bugbot_run_clean returns True for completed success / completed neutral
+- is_bugbot_run_clean returns False for completed failure, in_progress, missing
+- is_bugbot_run_clean returns None when the gh CLI fails
+- main(--check-clean) returns 0 on clean, 1 on not-clean, and
+  EXIT_CODE_GH_ERROR on gh CLI failure (with stderr diagnostics)
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import subprocess
+import sys
+from collections.abc import Iterator
+from pathlib import Path
+from types import ModuleType
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+_SCRIPTS_DIRECTORY = Path(__file__).resolve().parent
+
+
+@pytest.fixture(scope="session")
+def check_bugbot_ci_module() -> Iterator[ModuleType]:
+    """Load check_bugbot_ci with full sys.path and sys.modules isolation.
+
+    Snapshots sys.path and sys.modules at session start; restores both
+    unconditionally at session teardown so sibling tests inherit a clean
+    loading environment. The production script performs its own
+    membership-guarded sys.path.insert during exec_module so its config
+    dependency resolves; that insert and any config.* modules it loads
+    are reverted on teardown.
+    """
+    module_path = _SCRIPTS_DIRECTORY / "check_bugbot_ci.py"
+    spec = importlib.util.spec_from_file_location("check_bugbot_ci", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    sys_path_snapshot = list(sys.path)
+    sys_modules_snapshot = dict(sys.modules)
+    evicted_config_modules = {
+        each_module_name: sys.modules.pop(each_module_name)
+        for each_module_name in list(sys.modules)
+        if each_module_name == "config" or each_module_name.startswith("config.")
+    }
+    sys_modules_snapshot.update(evicted_config_modules)
+    spec.loader.exec_module(module)
+    try:
+        yield module
+    finally:
+        sys.path[:] = sys_path_snapshot
+        for each_new_module_name in list(sys.modules):
+            if each_new_module_name not in sys_modules_snapshot:
+                del sys.modules[each_new_module_name]
+        for each_module_name, each_module_value in sys_modules_snapshot.items():
+            sys.modules[each_module_name] = each_module_value
+
+
+def _make_completed_process(
+    stdout: str, returncode: int = 0
+) -> subprocess.CompletedProcess[str]:
+    process = MagicMock(spec=subprocess.CompletedProcess)
+    process.stdout = stdout
+    process.stderr = ""
+    process.returncode = returncode
+    return process
+
+
+def _build_stdout(*all_check_entries: dict[str, object]) -> str:
+    return "\n".join(json.dumps(each_entry) for each_entry in all_check_entries) + "\n"
+
+
+def test_should_return_true_when_bugbot_completed_with_success_conclusion(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "success"}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is True
+
+
+def test_should_return_true_when_bugbot_completed_with_neutral_conclusion(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "bugbot", "status": "completed", "conclusion": "neutral"}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is True
+
+
+def test_should_return_false_when_bugbot_completed_with_failure_conclusion(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "failure"}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is False
+
+
+def test_should_return_false_when_bugbot_still_in_progress(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "in_progress", "conclusion": None}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is False
+
+
+def test_should_return_false_when_no_bugbot_check_run_present(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "ci-other", "status": "completed", "conclusion": "success"}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is False
+
+
+def test_should_return_false_when_first_bugbot_run_is_in_progress_even_if_later_one_clean(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "in_progress", "conclusion": None},
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "success"},
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is False
+
+
+def test_should_return_false_when_first_bugbot_run_failed_even_if_later_one_clean(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "failure"},
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "success"},
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is False
+
+
+def test_should_return_none_when_gh_cli_fails(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    failing_process = MagicMock(spec=subprocess.CompletedProcess)
+    failing_process.stdout = ""
+    failing_process.stderr = "boom"
+    failing_process.returncode = 1
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=failing_process,
+    ):
+        is_clean = check_bugbot_ci_module.is_bugbot_run_clean(
+            owner="acme", repo="repo", sha="abc"
+        )
+    assert is_clean is None
+
+
+def test_main_check_clean_should_return_gh_error_code_when_gh_cli_fails(
+    check_bugbot_ci_module: ModuleType,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    failing_process = MagicMock(spec=subprocess.CompletedProcess)
+    failing_process.stdout = ""
+    failing_process.stderr = "boom"
+    failing_process.returncode = 1
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=failing_process,
+    ):
+        exit_code = check_bugbot_ci_module.main(
+            ["--check-clean", "--owner", "acme", "--repo", "repo", "--sha", "abc"]
+        )
+    assert exit_code == check_bugbot_ci_module.EXIT_CODE_GH_ERROR
+    captured = capsys.readouterr()
+    assert "gh api error: boom" in captured.err
+
+
+def test_main_check_clean_should_return_zero_when_bugbot_clean(
+    check_bugbot_ci_module: ModuleType,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "success"}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        exit_code = check_bugbot_ci_module.main(
+            ["--check-clean", "--owner", "acme", "--repo", "repo", "--sha", "abc"]
+        )
+    assert exit_code == 0
+    captured = capsys.readouterr()
+    assert "not clean" not in captured.out
+
+
+def test_main_check_clean_should_return_one_when_bugbot_not_clean(
+    check_bugbot_ci_module: ModuleType,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "completed", "conclusion": "failure"}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        exit_code = check_bugbot_ci_module.main(
+            ["--check-clean", "--owner", "acme", "--repo", "repo", "--sha", "abc"]
+        )
+    assert exit_code == 1
+    captured = capsys.readouterr()
+    assert "not clean" in captured.out
+
+
+def test_main_check_active_should_return_zero_when_bugbot_in_progress(
+    check_bugbot_ci_module: ModuleType,
+) -> None:
+    stdout = _build_stdout(
+        {"name": "Cursor Bugbot", "status": "in_progress", "conclusion": None}
+    )
+    with patch.object(
+        check_bugbot_ci_module,
+        "_run_check_runs_api",
+        return_value=_make_completed_process(stdout),
+    ):
+        exit_code = check_bugbot_ci_module.main(
+            ["--check-active", "--owner", "acme", "--repo", "repo", "--sha", "abc"]
+        )
+    assert exit_code == 0
+
+
+def test_main_should_reject_check_clean_and_check_active_together(
+    check_bugbot_ci_module: ModuleType,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    with pytest.raises(SystemExit):
+        check_bugbot_ci_module.main(
+            [
+                "--check-clean",
+                "--check-active",
+                "--owner",
+                "acme",
+                "--repo",
+                "repo",
+                "--sha",
+                "abc",
+            ]
+        )
+    captured = capsys.readouterr()
+    assert "not allowed with" in captured.err or "mutually exclusive" in captured.err

package/skills/qbug/SKILL.md

@@ -31,6 +31,12 @@ Shared artifacts with /bugteam are referenced below by path, using the `${CLAUDE
 
 Refusals — first match wins; respond with the quoted line exactly and stop:
 
+- **Disabled via environment.** When `CLAUDE_REVIEWS_DISABLED` contains the
+  token `bugteam` (comma-separated, case-insensitive, whitespace-tolerant):
+  `/qbug is disabled via CLAUDE_REVIEWS_DISABLED.` `/qbug` is the bugteam
+  baseline review and shares the `bugteam` token with `/bugteam`; the shared
+  pre-flight script also exits 7 in this case so any caller invoking it
+  directly halts on the same signal.
 - **No PR or upstream diff.** `No PR or upstream diff. /qbug needs a target.`
 - **Dirty tree.** `Uncommitted changes detected. Stash, commit, or revert before /qbug.`
 - **Missing subagent.** Before Step 2, confirm `clean-coder` exists. Else: `Required subagent type clean-coder not installed. /qbug needs clean-coder available.`
@@ -222,14 +228,33 @@ The subagent receives this prompt and loops internally — the lead does not re-
        `[]` and pass `--state CLEAN`; one or more anchored findings →
        pass `--state DIRTY` with the full list.
 
-       **Self-PR precondition.** GitHub rejects both `APPROVE` and
-       `REQUEST_CHANGES` reviews when the authenticated identity matches
-       the PR author with HTTP 422; `post_audit_thread.py` retries and
-       then exits 2. To run qbug on a PR you authored, switch `gh auth`
-       to an alternate reviewer identity (a separate GitHub account)
-       BEFORE invoking the skill. Without this switch, exit 2 is a hard
-       halt — there is no automated fallback path. The script does not
-       auto-downgrade on the self-PR case.
+       **Self-PR auto-toggle.** GitHub rejects both `APPROVE` and
+       `REQUEST_CHANGES` reviews with HTTP 422 when the authenticated
+       identity matches the PR author ("Cannot approve/request changes
+       on your own pull request"). `post_audit_thread.py` detects this
+       case via `gh api user` + `gh api repos/<o>/<r>/pulls/<n>` and
+       auto-resolves an alternate gh account's token for the reviews
+       POST — the active `gh auth` account is not mutated; only the
+       bearer token sent on the request changes. After the POST the
+       active account is still whoever it was before, so no "swap back"
+       step is needed.
+
+       Configuration:
+
+       - `GH_TOKEN` / `GITHUB_TOKEN` env vars take precedence over the
+         toggle. Set them when you need to pin a specific reviewer
+         identity by token rather than by account login.
+       - `BUGTEAM_REVIEWER_ACCOUNT` env var names which authenticated
+         alternate to prefer when a toggle is needed (for example,
+         `BUGTEAM_REVIEWER_ACCOUNT=jl-cmd`). The env var name is shared
+         across every skill that invokes `post_audit_thread.py`. When
+         unset, the script falls back to the first alternate account
+         `gh auth status` reports.
+       - The named alternate must be logged in (`gh auth login -h
+         github.com -u <login>`) before the audit skill runs. The
+         script exits 1 with a pointing-at-`gh auth login` message
+         when self-PR is detected and no usable alternate is
+         authenticated.
 
        ```
        python "${CLAUDE_SKILL_DIR}/../../_shared/pr-loop/scripts/post_audit_thread.py" \