claude-dev-env 1.95.0 → 2.0.1

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

@@ -1,235 +1,279 @@
-"""Review and Bugbot IO leaves for the convergence gate checks.
-
-Each function issues one ``gh`` REST call and returns a ``(passed, detail)``
-pair the convergence checker turns into a PASS/FAIL line, or a raw
-``(returncode, stdout)`` pair for the low-level callers. The checker re-imports
-these names, so a test patches them on the checker module.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import subprocess
-import sys
-
-import _pr_converge_path_setup  # noqa: F401
-from pr_converge_skill_constants.constants import (
-    ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS,
-    BUGBOT_CHECK_RUN_NAME_SUBSTRING,
-    BUGBOT_DIRTY_BODY_REGEX,
-    CHECK_RUNS_PER_PAGE,
-    CURSOR_LOGIN_FILTER_SUBSTRING,
-    EXIT_CODE_GH_ERROR,
-    GH_CHECK_RUNS_PATH_TEMPLATE,
-    GH_PR_OBJECT_PATH_TEMPLATE,
-    GH_REVIEWS_PATH_TEMPLATE,
-    REVIEWS_PER_PAGE,
-)
-from pr_converge_scripts_constants.convergence_gate_constants import SHORT_SHA_LENGTH
-
-JsonObject = dict[str, object]
-ReviewStateGroup = tuple[str, ...]
-
-
-def _run_gh_command(all_arguments: list[str]) -> tuple[int, str]:
-    completed_process = subprocess.run(
-        all_arguments,
-        capture_output=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-        check=False,
-    )
-    return completed_process.returncode, completed_process.stdout
-
-
-def _gh_api(endpoint_path: str) -> tuple[int, str]:
-    return _run_gh_command(["gh", "api", endpoint_path])
-
-
-def _gh_api_paginated(endpoint_path: str) -> tuple[int, str]:
-    return _run_gh_command(["gh", "api", endpoint_path, "--paginate", "--slurp"])
-
-
-def _short_sha(commit_id: str) -> str:
-    return commit_id[:SHORT_SHA_LENGTH]
-
-
-def _get_pr_head_sha(*, owner: str, repo: str, number: int) -> str:
-    """Return the PR HEAD SHA, exiting with the gh-error code when the call fails."""
-    endpoint = GH_PR_OBJECT_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
-    returncode, stdout = _gh_api(endpoint)
-    if returncode != 0:
-        sys.stderr.write(f"gh api error fetching PR object: {stdout}\n")
-        raise SystemExit(EXIT_CODE_GH_ERROR)
-    pr_object = json.loads(stdout)
-    head_sha: object = pr_object.get("head", {}).get("sha")
-    if not isinstance(head_sha, str):
-        raise SystemExit(EXIT_CODE_GH_ERROR)
-    return head_sha
-
-
-def _get_mergeable(*, owner: str, repo: str, number: int) -> tuple[bool, str]:
-    """Return whether the PR is cleanly mergeable, with the mergeable-state detail."""
-    endpoint = GH_PR_OBJECT_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
-    returncode, stdout = _gh_api(endpoint)
-    if returncode != 0:
-        return False, f"gh api error: {stdout}"
-    pr_object = json.loads(stdout)
-    mergeable: object = pr_object.get("mergeable")
-    mergeable_state: object = pr_object.get("mergeable_state", "unknown")
-    state_text = str(mergeable_state)
-    if mergeable is True and state_text == "clean":
-        return True, "clean"
-    return False, state_text
-
-
-def _bugbot_check_runs(
-    *, owner: str, repo: str, sha: str
-) -> tuple[int, list[JsonObject]]:
-    """Fetch the check runs for a SHA and return the returncode and run dicts."""
-    endpoint = GH_CHECK_RUNS_PATH_TEMPLATE.format(owner=owner, repo=repo, sha=sha)
-    returncode, stdout = _gh_api(f"{endpoint}?per_page={CHECK_RUNS_PER_PAGE}")
-    if returncode != 0:
-        return returncode, []
-    try:
-        payload = json.loads(stdout)
-    except json.JSONDecodeError:
-        return returncode, []
-    raw_runs = payload.get("check_runs") if isinstance(payload, dict) else None
-    if not isinstance(raw_runs, list):
-        return returncode, []
-    return returncode, [each_run for each_run in raw_runs if isinstance(each_run, dict)]
-
-
-def _bugbot_run_conclusion_detail(check_run: JsonObject) -> tuple[bool, str]:
-    """Return the pass flag and detail for one bugbot check run."""
-    conclusion = check_run.get("conclusion", "")
-    if conclusion in ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS:
-        check_id = check_run.get("id", "?")
-        detail_url = check_run.get("html_url", "")
-        details_suffix = f" ({detail_url})" if detail_url else ""
-        return True, f"check run {check_id}, conclusion: {conclusion}{details_suffix}"
-    return (
-        False,
-        f"check run conclusion is '{conclusion}', expected {ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS}",
-    )
-
-
-def _check_bugbot(*, owner: str, repo: str, sha: str) -> tuple[bool, str]:
-    """Return whether the Cursor Bugbot check run on a SHA completed successfully."""
-    returncode, check_runs = _bugbot_check_runs(owner=owner, repo=repo, sha=sha)
-    if returncode != 0:
-        return False, "gh api error fetching check runs"
-    for each_check_run in check_runs:
-        each_name = each_check_run.get("name", "")
-        if not isinstance(each_name, str):
-            continue
-        if BUGBOT_CHECK_RUN_NAME_SUBSTRING.lower() not in each_name.lower():
-            continue
-        return _bugbot_run_conclusion_detail(each_check_run)
-    return False, "no bugbot check run found"
-
-
-def _flatten_paginated_reviews(stdout: str) -> list[JsonObject] | None:
-    """Flatten a slurped, paginated reviews payload into a newest-first list."""
-    try:
-        reviews_payload = json.loads(stdout)
-    except json.JSONDecodeError:
-        return None
-    if not isinstance(reviews_payload, list):
-        return None
-    all_flat: list[JsonObject] = [
-        each_entry
-        for each_page in reviews_payload
-        if isinstance(each_page, list)
-        for each_entry in each_page
-        if isinstance(each_entry, dict)
-    ]
-    all_flat.sort(
-        key=lambda each_review: str(each_review.get("submitted_at", "")), reverse=True
-    )
-    return all_flat
-
-
-def _review_matches_login(review: JsonObject, login_substring: str) -> bool:
-    user_object = review.get("user")
-    if not isinstance(user_object, dict):
-        return False
-    login = user_object.get("login", "")
-    return isinstance(login, str) and login_substring in login.lower()
-
-
-def _review_commit_starts_with(review: JsonObject, head_sha: str) -> bool:
-    commit_id = review.get("commit_id", "")
-    return isinstance(commit_id, str) and commit_id.startswith(head_sha)
-
-
-def _check_bugbot_not_dirty(
-    *, owner: str, repo: str, number: int, head_sha: str
-) -> tuple[bool, str]:
-    """Return whether the newest Cursor Bugbot review on HEAD reports no findings."""
-    endpoint = GH_REVIEWS_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
-    returncode, stdout = _gh_api_paginated(f"{endpoint}?per_page={REVIEWS_PER_PAGE}")
-    if returncode != 0:
-        return True, "bugbot reviews unavailable (non-fatal)"
-    all_flat = _flatten_paginated_reviews(stdout)
-    if all_flat is None:
-        return True, "bugbot reviews not valid JSON (non-fatal)"
-    dirty_pattern = re.compile(BUGBOT_DIRTY_BODY_REGEX, re.IGNORECASE)
-    for each_review in all_flat:
-        if not _review_matches_login(each_review, CURSOR_LOGIN_FILTER_SUBSTRING):
-            continue
-        if not _review_commit_starts_with(each_review, head_sha):
-            continue
-        body = each_review.get("body", "")
-        if isinstance(body, str) and dirty_pattern.search(body):
-            return False, "bugbot review body reports findings"
-        return True, "clean"
-    return True, "no bugbot review at HEAD"
-
-
-def _bot_review_state_detail(
-    review: JsonObject,
-    clean_states: ReviewStateGroup,
-    dirty_states: ReviewStateGroup,
-) -> tuple[bool, str]:
-    """Return the pass flag and detail for one bot review's state."""
-    review_state = review.get("state", "")
-    commit_id = review.get("commit_id", "")
-    short_commit = _short_sha(commit_id) if isinstance(commit_id, str) else "?"
-    if review_state in clean_states:
-        review_id = review.get("id", "?")
-        return True, f"review {review_id}, state: {review_state}, commit {short_commit}"
-    if review_state in dirty_states:
-        return False, f"review state is '{review_state}' (dirty), commit {short_commit}"
-    return False, f"review state is '{review_state}', commit {short_commit}"
-
-
-def _check_bot_review(
-    *,
-    owner: str,
-    repo: str,
-    number: int,
-    head_sha: str,
-    login_substring: str,
-    clean_states: ReviewStateGroup,
-    dirty_states: ReviewStateGroup,
-    label: str,
-) -> tuple[bool, str]:
-    """Return whether the newest matching bot review on HEAD is in a clean state."""
-    endpoint = GH_REVIEWS_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
-    returncode, stdout = _gh_api_paginated(f"{endpoint}?per_page={REVIEWS_PER_PAGE}")
-    if returncode != 0:
-        return False, f"gh api error: {stdout}"
-    all_flat = _flatten_paginated_reviews(stdout)
-    if all_flat is None:
-        return False, f"no {label} review found"
-    for each_review in all_flat:
-        if not _review_matches_login(each_review, login_substring):
-            continue
-        if not _review_commit_starts_with(each_review, head_sha):
-            continue
-        return _bot_review_state_detail(each_review, clean_states, dirty_states)
-    return False, f"no {label} review found on {_short_sha(head_sha)}"
+"""Review and Bugbot IO leaves for the convergence gate checks.
+
+Each function issues one ``gh`` REST call and returns a ``(passed, detail)``
+pair the convergence checker turns into a PASS/FAIL line, or a raw
+``(returncode, stdout)`` pair for the low-level callers. The checker re-imports
+these names, so a test patches them on the checker module.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import subprocess
+import sys
+
+import _pr_converge_path_setup  # noqa: F401
+from pr_converge_skill_constants.constants import (
+    ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS,
+    BUGBOT_CHECK_RUN_NAME_SUBSTRING,
+    BUGBOT_DIRTY_BODY_REGEX,
+    CHECK_RUNS_PER_PAGE,
+    CURSOR_LOGIN_FILTER_SUBSTRING,
+    EXIT_CODE_GH_ERROR,
+    GH_CHECK_RUNS_PATH_TEMPLATE,
+    GH_PR_OBJECT_PATH_TEMPLATE,
+    GH_REVIEWS_PATH_TEMPLATE,
+    REVIEWS_PER_PAGE,
+)
+from pr_converge_scripts_constants.convergence_gate_constants import (
+    MERGEABLE_STATE_CLEAN,
+    REVIEW_SUBMITTED_AT_KEY,
+    SHORT_SHA_LENGTH,
+)
+
+JsonObject = dict[str, object]
+ReviewStateGroup = tuple[str, ...]
+
+
+def _run_gh_command(all_arguments: list[str]) -> tuple[int, str]:
+    completed_process = subprocess.run(
+        all_arguments,
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    return completed_process.returncode, completed_process.stdout
+
+
+def _gh_api(endpoint_path: str) -> tuple[int, str]:
+    return _run_gh_command(["gh", "api", endpoint_path])
+
+
+def _gh_api_paginated(endpoint_path: str) -> tuple[int, str]:
+    return _run_gh_command(["gh", "api", endpoint_path, "--paginate", "--slurp"])
+
+
+def _short_sha(commit_id: str) -> str:
+    return commit_id[:SHORT_SHA_LENGTH]
+
+
+def _get_pr_head_sha(*, owner: str, repo: str, number: int) -> str:
+    """Return the PR HEAD SHA, exiting with the gh-error code when the call fails."""
+    endpoint = GH_PR_OBJECT_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
+    returncode, stdout = _gh_api(endpoint)
+    if returncode != 0:
+        sys.stderr.write(f"gh api error fetching PR object: {stdout}\n")
+        raise SystemExit(EXIT_CODE_GH_ERROR)
+    try:
+        pr_object = json.loads(stdout)
+    except json.JSONDecodeError as decode_error:
+        sys.stderr.write(f"gh api PR object not valid JSON: {stdout}\n")
+        raise SystemExit(EXIT_CODE_GH_ERROR) from decode_error
+    head_object = pr_object.get("head") if isinstance(pr_object, dict) else None
+    head_sha: object = head_object.get("sha") if isinstance(head_object, dict) else None
+    if not isinstance(head_sha, str):
+        raise SystemExit(EXIT_CODE_GH_ERROR)
+    return head_sha
+
+
+def _evaluate_mergeable_from_pr_object(pr_object: JsonObject) -> tuple[bool, str]:
+    """Return whether a PR object dict is cleanly mergeable.
+
+    Pure evaluator: no network IO. Live and fixture paths share this contract.
+
+    Args:
+        pr_object: Pull request JSON object with mergeable and mergeable_state fields.
+
+    Returns:
+        (True, clean) when mergeable is true and state is clean; otherwise (False, state).
+    """
+    mergeable: object = pr_object.get("mergeable")
+    mergeable_state: object = pr_object.get("mergeable_state", "unknown")
+    state_text = str(mergeable_state)
+    if mergeable is True and state_text == MERGEABLE_STATE_CLEAN:
+        return True, MERGEABLE_STATE_CLEAN
+    return False, state_text
+
+
+def _get_mergeable(*, owner: str, repo: str, number: int) -> tuple[bool, str]:
+    """Return whether the PR is cleanly mergeable, with the mergeable-state detail."""
+    endpoint = GH_PR_OBJECT_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
+    returncode, stdout = _gh_api(endpoint)
+    if returncode != 0:
+        return False, f"gh api error: {stdout}"
+    try:
+        pr_object = json.loads(stdout)
+    except json.JSONDecodeError:
+        return False, "gh api PR object not valid JSON"
+    if not isinstance(pr_object, dict):
+        return False, "unknown"
+    return _evaluate_mergeable_from_pr_object(pr_object)
+
+
+def _bugbot_check_runs(
+    *, owner: str, repo: str, sha: str
+) -> tuple[int, list[JsonObject]]:
+    """Fetch the check runs for a SHA and return the returncode and run dicts."""
+    endpoint = GH_CHECK_RUNS_PATH_TEMPLATE.format(owner=owner, repo=repo, sha=sha)
+    returncode, stdout = _gh_api(f"{endpoint}?per_page={CHECK_RUNS_PER_PAGE}")
+    if returncode != 0:
+        return returncode, []
+    try:
+        payload = json.loads(stdout)
+    except json.JSONDecodeError:
+        return returncode, []
+    raw_runs = payload.get("check_runs") if isinstance(payload, dict) else None
+    if not isinstance(raw_runs, list):
+        return returncode, []
+    return returncode, [each_run for each_run in raw_runs if isinstance(each_run, dict)]
+
+
+def _bugbot_run_conclusion_detail(check_run: JsonObject) -> tuple[bool, str]:
+    """Return the pass flag and detail for one bugbot check run."""
+    conclusion = check_run.get("conclusion", "")
+    if conclusion in ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS:
+        check_id = check_run.get("id", "?")
+        detail_url = check_run.get("html_url", "")
+        details_suffix = f" ({detail_url})" if detail_url else ""
+        return True, f"check run {check_id}, conclusion: {conclusion}{details_suffix}"
+    return (
+        False,
+        f"check run conclusion is '{conclusion}', expected {ALL_BUGBOT_CHECK_RUN_COMPLETE_CONCLUSIONS}",
+    )
+
+
+def _check_bugbot(*, owner: str, repo: str, sha: str) -> tuple[bool, str]:
+    """Return whether the Cursor Bugbot check run on a SHA completed successfully."""
+    returncode, check_runs = _bugbot_check_runs(owner=owner, repo=repo, sha=sha)
+    if returncode != 0:
+        return False, "gh api error fetching check runs"
+    for each_check_run in check_runs:
+        each_name = each_check_run.get("name", "")
+        if not isinstance(each_name, str):
+            continue
+        if BUGBOT_CHECK_RUN_NAME_SUBSTRING.lower() not in each_name.lower():
+            continue
+        return _bugbot_run_conclusion_detail(each_check_run)
+    return False, "no bugbot check run found"
+
+
+def _sort_reviews_newest_first(all_reviews: list[JsonObject]) -> list[JsonObject]:
+    """Return the reviews ordered newest-first by submission time.
+
+    The live gh path and the offline fixture path both feed the same
+    newest-first evaluators, so both order their reviews through here.
+
+    Args:
+        all_reviews: Review objects in any order.
+
+    Returns:
+        A new list ordered newest-first; a review with no submitted_at sorts last.
+    """
+    return sorted(
+        all_reviews,
+        key=lambda each_review: str(each_review.get(REVIEW_SUBMITTED_AT_KEY, "")),
+        reverse=True,
+    )
+
+
+def _flatten_paginated_reviews(stdout: str) -> list[JsonObject] | None:
+    """Flatten a slurped, paginated reviews payload into a newest-first list."""
+    try:
+        reviews_payload = json.loads(stdout)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(reviews_payload, list):
+        return None
+    all_flat: list[JsonObject] = [
+        each_entry
+        for each_page in reviews_payload
+        if isinstance(each_page, list)
+        for each_entry in each_page
+        if isinstance(each_entry, dict)
+    ]
+    return _sort_reviews_newest_first(all_flat)
+
+
+def _review_matches_login(review: JsonObject, login_substring: str) -> bool:
+    user_object = review.get("user")
+    if not isinstance(user_object, dict):
+        return False
+    login = user_object.get("login", "")
+    return isinstance(login, str) and login_substring in login.lower()
+
+
+def _review_commit_starts_with(review: JsonObject, head_sha: str) -> bool:
+    commit_id = review.get("commit_id", "")
+    return isinstance(commit_id, str) and commit_id.startswith(head_sha)
+
+
+def _check_bugbot_not_dirty(
+    *, owner: str, repo: str, number: int, head_sha: str
+) -> tuple[bool, str]:
+    """Return whether the newest Cursor Bugbot review on HEAD reports no findings."""
+    endpoint = GH_REVIEWS_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
+    returncode, stdout = _gh_api_paginated(f"{endpoint}?per_page={REVIEWS_PER_PAGE}")
+    if returncode != 0:
+        return True, "bugbot reviews unavailable (non-fatal)"
+    all_flat = _flatten_paginated_reviews(stdout)
+    if all_flat is None:
+        return True, "bugbot reviews not valid JSON (non-fatal)"
+    dirty_pattern = re.compile(BUGBOT_DIRTY_BODY_REGEX, re.IGNORECASE)
+    for each_review in all_flat:
+        if not _review_matches_login(each_review, CURSOR_LOGIN_FILTER_SUBSTRING):
+            continue
+        if not _review_commit_starts_with(each_review, head_sha):
+            continue
+        body = each_review.get("body", "")
+        if isinstance(body, str) and dirty_pattern.search(body):
+            return False, "bugbot review body reports findings"
+        return True, "clean"
+    return True, "no bugbot review at HEAD"
+
+
+def _bot_review_state_detail(
+    review: JsonObject,
+    clean_states: ReviewStateGroup,
+    dirty_states: ReviewStateGroup,
+) -> tuple[bool, str]:
+    """Return the pass flag and detail for one bot review's state."""
+    review_state = review.get("state", "")
+    commit_id = review.get("commit_id", "")
+    short_commit = _short_sha(commit_id) if isinstance(commit_id, str) else "?"
+    if review_state in clean_states:
+        review_id = review.get("id", "?")
+        return True, f"review {review_id}, state: {review_state}, commit {short_commit}"
+    if review_state in dirty_states:
+        return False, f"review state is '{review_state}' (dirty), commit {short_commit}"
+    return False, f"review state is '{review_state}', commit {short_commit}"
+
+
+def _check_bot_review(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    head_sha: str,
+    login_substring: str,
+    clean_states: ReviewStateGroup,
+    dirty_states: ReviewStateGroup,
+    label: str,
+) -> tuple[bool, str]:
+    """Return whether the newest matching bot review on HEAD is in a clean state."""
+    endpoint = GH_REVIEWS_PATH_TEMPLATE.format(owner=owner, repo=repo, number=number)
+    returncode, stdout = _gh_api_paginated(f"{endpoint}?per_page={REVIEWS_PER_PAGE}")
+    if returncode != 0:
+        return False, f"gh api error: {stdout}"
+    all_flat = _flatten_paginated_reviews(stdout)
+    if all_flat is None:
+        return False, f"no {label} review found"
+    for each_review in all_flat:
+        if not _review_matches_login(each_review, login_substring):
+            continue
+        if not _review_commit_starts_with(each_review, head_sha):
+            continue
+        return _bot_review_state_detail(each_review, clean_states, dirty_states)
+    return False, f"no {label} review found on {_short_sha(head_sha)}"

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

@@ -207,7 +207,7 @@ def _check_no_pending_reviews(
     try:
         pending_payload = json.loads(stdout)
     except json.JSONDecodeError:
-        return True, "no pending (empty response)"
+        return False, "pending-reviewers response not valid JSON"
     copilot_pending = _pending_copilot_logins(
         _requested_reviewer_users(pending_payload)
     )

package/skills/pr-converge/scripts/pr_converge_scripts_constants/convergence_gate_constants.py

@@ -1,11 +1,14 @@
 """Named constants for the convergence gate IO leaves.
 
-Holds the short-SHA length, the join separators for gate detail strings, and
-the GraphQL query that lists a PR's review threads.
+Holds the short-SHA length, the review field key the newest-first sort reads,
+the join separators for gate detail strings, the fixture payload keys, and the
+GraphQL query that lists a PR's review threads.
 """
 
 SHORT_SHA_LENGTH: int = 7
 
+REVIEW_SUBMITTED_AT_KEY: str = "submitted_at"
+
 THREAD_PATH_JOIN_SEPARATOR: str = "; "
 
 PENDING_REVIEWER_JOIN_SEPARATOR: str = ", "
@@ -34,3 +37,34 @@ query($owner: String!, $repo: String!, $number: Int!, $first: Int!, $cursor: Str
   }
 }
 """
+
+FIXTURE_KEY_HEAD_SHA: str = "head_sha"
+FIXTURE_KEY_PR_OBJECT: str = "pr_object"
+FIXTURE_KEY_REVIEWS: str = "reviews"
+FIXTURE_KEY_UNRESOLVED_BOT_THREADS_PASSED: str = "unresolved_bot_threads_passed"
+FIXTURE_KEY_UNRESOLVED_BOT_THREADS_DETAIL: str = "unresolved_bot_threads_detail"
+FIXTURE_KEY_PENDING_REVIEWS_PASSED: str = "pending_reviews_passed"
+FIXTURE_KEY_PENDING_REVIEWS_DETAIL: str = "pending_reviews_detail"
+FIXTURE_KEY_CODEX_PERCENT_LEFT: str = "codex_percent_left"
+FIXTURE_KEY_CODEX_CLEAN_AT: str = "codex_clean_at"
+FIXTURE_DEFAULT_THREADS_DETAIL: str = "0 unresolved"
+FIXTURE_DEFAULT_PENDING_DETAIL: str = "none pending"
+MERGEABLE_STATE_CLEAN: str = "clean"
+
+COPILOT_DOWN_BYPASS_NOTE: str = "copilot_down"
+BUGBOT_DOWN_BYPASS_NOTE: str = "bugbot_down"
+REVIEWER_UNAVAILABLE_NOTE_TEMPLATE: str = "{token} unavailable: {message}"
+SETTINGS_DISK_FALLBACK_LOG_TEMPLATE: str = (
+    "reviewer-availability: settings.json unreadable; using process env for %s and %s"
+)
+
+CODEX_GATE_LABEL: str = "codex_clean_at == current_head"
+CODEX_BYPASS_DETAIL: str = "bypassed (codex_down)"
+CODEX_SKIPPED_USAGE_DETAIL: str = "skipped (codex review not required)"
+CODEX_CLEAN_DETAIL_TEMPLATE: str = "clean at %s"
+CODEX_MISSING_CLEAN_DETAIL_TEMPLATE: str = "no codex clean on %s"
+CLAUDE_JOB_DIR_ENV_VAR_NAME: str = "CLAUDE_JOB_DIR"
+PR_CONVERGE_STATE_FILENAME: str = "pr-converge-state.json"
+CODEX_CLEAN_AT_STATE_KEY: str = "codex_clean_at"
+CODEX_DOWN_STATE_KEY: str = "codex_down"
+MINIMUM_ABBREVIATED_SHA_LENGTH: int = 7

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

@@ -22,5 +22,9 @@ def test_path_setup_registers_skill_and_shared_directories() -> None:
     shared_directory = (
         _SCRIPTS_DIRECTORY.parent.parent.parent / "_shared" / "pr-loop" / "scripts"
     )
+    codex_scripts_directory = (
+        _SCRIPTS_DIRECTORY.parent.parent / "codex-review" / "scripts"
+    )
     assert str(skill_directory) in sys.path
     assert str(shared_directory) in sys.path
+    assert str(codex_scripts_directory) in sys.path