claude-dev-env 1.36.2 → 1.37.0

package/skills/pr-converge/reference/state-schema.md

@@ -0,0 +1,19 @@
+# State across ticks
+
+**Dual persistence:** `<TMPDIR>/pr-converge-<session_id>/state.json`
+exists (multi-PR) → that file is source of truth for `phase`, heads,
+counters, status, not conversation transcript. No `state.json` (typical
+single-PR `/pr-converge`) → track in each assistant turn as
+plain text so next tick re-reads from context:
+
+- `phase`: `BUGBOT` or `BUGTEAM`. Start `BUGBOT` on first tick.
+- `bugbot_clean_at`: HEAD SHA where bugbot last reported clean, or `null`.
+  Reset to `null` on every push.
+- `inline_lag_streak`: integer, init `0`. Consecutive ticks where review
+  body shows findings against `current_head` but inline API returns zero
+  matching. Reset to `0` on any other branch outcome.
+- `tick_count`: integer, init `0`. Increment every tick.
+
+Tick begins reading prior state line from most recent assistant message
+(no `state.json`) and ends by emitting updated state line; with
+`state.json`, follow `multi-pr-orchestration.md` §What orchestrator does per tick.

package/skills/pr-converge/reference/stop-conditions.md

@@ -0,0 +1,26 @@
+# Stop conditions
+
+- **Convergence** (back-to-back clean ∧ no outstanding Copilot findings
+  on `current_head` ∧ `mergeStateStatus == "CLEAN"` with `mergeable ==
+  "MERGEABLE"` ∧ post-convergence Copilot request returned `clean` at
+  `current_head`): prefer `mark_pr_ready.py`; else `gh pr ready`. With
+  `state.json`, append convergence row to
+  `<TMPDIR>/pr-converge-<session_id>/converged.log` per `multi-pr-orchestration.md` §Memory; else
+  skip. Report [convergence-gates.md](convergence-gates.md) (d) summary, then **omit loop pacing**
+  per **Convergence** in `../workflows/schedule-wakeup-loop.md`. End all loops
+  once all PRs terminal (converged or blocked).
+- **Hard blocker:** API auth failure across two ticks, CI regression
+  whose root cause falls outside this PR, hook rejection unresolved
+  across three commits, `inline_lag_streak >= 3`, **bugteam** reports
+  stuck, or post-convergence Copilot request fails to surface review on
+  `current_head` after three consecutive wakeups. Report specific
+  blocker and diagnosis, **omit loop pacing** per
+  `../workflows/schedule-wakeup-loop.md`.
+- **Hard blocker (`mergeStateStatus` non-CLEAN non-DIRTY):**
+  `mergeStateStatus` is `BLOCKED`, `UNKNOWN`, or `BEHIND` (required
+  checks pending, branch behind base without textual conflicts, or
+  GitHub indeterminate). Investigate before retrying; `rebase` skill
+  handles `DIRTY` (textual conflicts) only. Report specific
+  `mergeStateStatus`, **omit loop pacing**.
+- **User stops loop:** "stop the converge loop" → **omit loop pacing**
+  per `../workflows/schedule-wakeup-loop.md`.

package/skills/pr-converge/scripts/README.md

@@ -25,7 +25,7 @@ python "${CLAUDE_SKILL_DIR}/scripts/fetch_bugbot_reviews.py" \
   --owner <OWNER> --repo <REPO> --number <NUMBER>
 ```
 
-Output: JSON array of `{review_id, commit_id, submitted_at, body, classification}` where `classification` is `"dirty"` (body matches `Cursor Bugbot has reviewed your changes and found <N> potential issue`) or `"clean"`. Uses `--paginate --slurp` and flattens pages in Python — required by `../../../rules/gh-paginate.md` because `gh --paginate --jq` runs the filter per-page (gh CLI #10459).
+Output: JSON array of `{review_id, commit_id, submitted_at, state, body, classification}` where `classification` is `"dirty"` (body matches `Cursor Bugbot has reviewed your changes and found <N> potential issue`) or `"clean"`. Uses `--paginate --slurp` and flattens pages in Python — required by `../../../rules/gh-paginate.md` because `gh --paginate --jq` runs the filter per-page (gh CLI issue 10459). Login filter is a case-insensitive substring match on `cursor` (handles login-shape divergence between review-level and inline-comment endpoints).
 
 ### `fetch_bugbot_inline_comments.py`
 
@@ -86,7 +86,8 @@ Output: the new reply id from gh's JSON response, on stdout.
 Returns the mergeability state of the current PR as JSON. Wraps `gh pr view --json mergeable,mergeStateStatus,headRefOid` (single-object endpoint — no pagination needed). Used by the convergence gate to detect base-branch conflicts (`mergeStateStatus == "DIRTY"` / `mergeable == "CONFLICTING"`) before flipping the PR ready.
 
 ```bash
-python "${CLAUDE_SKILL_DIR}/scripts/check_pr_mergeability.py"
+python "${CLAUDE_SKILL_DIR}/scripts/check_pr_mergeability.py" \
+--owner <OWNER> --repo <REPO> --number <NUMBER>
 ```
 
 Output: `{"mergeable", "mergeStateStatus", "headRefOid"}`.
@@ -100,7 +101,7 @@ python "${CLAUDE_SKILL_DIR}/scripts/fetch_copilot_reviews.py" \
   --owner <OWNER> --repo <REPO> --number <NUMBER>
 ```
 
-Output: JSON array of `{review_id, commit_id, submitted_at, state, body, classification}` where `classification` is `"clean"` for `state == "APPROVED"`, `"dirty"` for `state == "CHANGES_REQUESTED"`, and `"dirty"` for `state == "COMMENTED"` with a non-empty body. Uses `--paginate --slurp` and flattens pages in Python — required by `../../../rules/gh-paginate.md`.
+Output: JSON array of `{review_id, commit_id, submitted_at, state, body, classification}` where `classification` is `"clean"` for `state == "APPROVED"`, `"dirty"` for `state == "CHANGES_REQUESTED"`, and `"dirty"` for `state == "COMMENTED"` with a non-empty body. Uses `--paginate --slurp` and flattens pages in Python — required by `../../../rules/gh-paginate.md`. Login filter is a case-insensitive substring match on `copilot` (handles the divergence where Copilot reviews come from `copilot-pull-request-reviewer[bot]` but its inline comments are authored by `Copilot`).
 
 ### `fetch_copilot_inline_comments.py`
 
@@ -124,17 +125,43 @@ python "${CLAUDE_SKILL_DIR}/scripts/request_copilot_review.py" \
 
 Output: none on success (gh's stdout is suppressed); `subprocess.CalledProcessError` on failure.
 
-### `open_followup_copilot_pr.py`
+### `fetch_claude_reviews.py`
 
-Opens a follow-up draft PR addressing Copilot findings from the parent PR. Subprocess sequence: resolve parent's `baseRefName` → `git fetch origin <head_sha>` → `git switch -c <new_branch> <head_sha>` → `git push -u origin <new_branch>` → `gh pr create --draft --base <base_ref> --head <new_branch> --title <...> --body-file <findings_file>` (per `../../../rules/gh-body-file.md`). Branch name format: `chore/copilot-followup-{parent_number}-{short_sha}`.
+Fetches every Claude reviewer-bot review on the PR newest-first, classified per the review's `state` field. Mirror of `fetch_copilot_reviews.py` for an Anthropic Claude PR review bot (e.g. `claude[bot]`, `claude-code[bot]`, or any login containing `claude`).
 
 ```bash
-python "${CLAUDE_SKILL_DIR}/scripts/open_followup_copilot_pr.py" \
-  --owner <OWNER> --repo <REPO> --parent-number <PARENT_NUMBER> \
-  --head <HEAD_SHA> --findings-file <PATH_TO_FINDINGS_MD>
+python "${CLAUDE_SKILL_DIR}/scripts/fetch_claude_reviews.py" \
+  --owner <OWNER> --repo <REPO> --number <NUMBER>
+```
+
+Output: JSON array of `{review_id, commit_id, submitted_at, state, body, classification}` — same shape and same state-based classification rules as `fetch_copilot_reviews.py`. Login filter is a case-insensitive substring match on `claude`.
+
+### `fetch_claude_inline_comments.py`
+
+Fetches unaddressed Claude inline comments for the **newest submitted Claude review** on the requested `--commit` SHA (matches `pull_request_review_id` to the review returned by `fetch_claude_reviews.py` so stale inline threads from an older Claude review on the same SHA are ignored).
+
+```bash
+python "${CLAUDE_SKILL_DIR}/scripts/fetch_claude_inline_comments.py" \
+  --owner <OWNER> --repo <REPO> --number <NUMBER> --commit <CURRENT_HEAD>
 ```
 
-Output: the new PR URL on stdout, trimmed.
+Output: JSON array of `{comment_id, commit_id, path, line, body}`. Same `--paginate --slurp` pattern.
+
+## Shared modules
+
+The reviewer fetch scripts share their fetch and classification logic via two internal modules. Entry-point scripts (`fetch_bugbot_reviews.py`, `fetch_copilot_reviews.py`, `fetch_claude_reviews.py` and their inline-comment counterparts) are thin wrappers — they import a per-reviewer spec, call the shared core, and shape argparse / JSON output.
+
+### `reviewer_specs.py`
+
+Defines the `ReviewerSpec` frozen dataclass (two fields: `login_filter_substring` and `classify_review`) plus three module-level instances: `bugbot_spec`, `copilot_spec`, `claude_spec`. The state-based classifier used by Copilot and Claude is built via the shared `_make_state_based_classifier` factory; Bugbot has its own body-regex classifier because Bugbot uses `state == "COMMENTED"` for both clean and dirty reviews and only the body distinguishes them.
+
+Spec instances use lowercase names because they are frozen dataclass values rather than scalar configuration constants — keeps them out of the `UPPER_SNAKE` constants-location rule that requires module-level constants outside `config/` to be hoisted there.
+
+### `reviewer_fetch_core.py`
+
+Exports `fetch_reviewer_reviews(spec, ...)` and `fetch_reviewer_inline_comments(spec, ..., all_reviews=...)`. The inline-comments function takes pre-fetched reviews as an argument rather than fetching them internally, so each entry-point script keeps its own patchable `fetch_X_reviews` function for tests that mock the reviews fetch on the entry-point module.
+
+The core enforces the gh-paginate contract (`--paginate --slurp` + Python JSON flattening, never `gh --jq` for cross-page operations) and the case-insensitive substring login filter in one place.
 
 ## Tests
 

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

@@ -5,8 +5,7 @@ so the skill body emits one script invocation. Single-object endpoint - no
 pagination. Explicit ``--owner``/``--repo``/``--number`` targeting matches every
 sibling convergence-gate script (``fetch_*_reviews.py``,
 ``fetch_*_inline_comments.py``, ``request_copilot_review.py``,
-``mark_pr_ready.py``); under multi-PR orchestration or after
-``open_followup_copilot_pr.py`` switches the checkout, the gate is guaranteed
+``mark_pr_ready.py``); under multi-PR orchestration the gate is guaranteed
 to query the intended PR rather than whichever PR the current git context
 points at.
 

package/skills/pr-converge/scripts/config/pr_converge_constants.py

@@ -4,18 +4,37 @@ Path templates accept ``str.format(**kwargs)`` substitution; bugbot strings
 match the literal phrasing the Cursor Bugbot reviewer emits.
 """
 
+import re
+from pathlib import Path
+
 CURSOR_BOT_LOGIN: str = "cursor[bot]"
 
+CURSOR_LOGIN_FILTER_SUBSTRING: str = "cursor"
+
 COPILOT_REVIEWER_LOGIN: str = "copilot-pull-request-reviewer[bot]"
 
 COPILOT_REVIEWER_REQUEST_ID: str = COPILOT_REVIEWER_LOGIN
 
+COPILOT_LOGIN_FILTER_SUBSTRING: str = "copilot"
+
 COPILOT_CLEAN_REVIEW_STATE: str = "APPROVED"
 
 ALL_COPILOT_DIRTY_REVIEW_STATES: tuple[str, ...] = ("CHANGES_REQUESTED", "COMMENTED")
 
 COPILOT_SOFT_DIRTY_REVIEW_STATE: str = "COMMENTED"
 
+CLAUDE_REVIEWER_LOGIN: str = "claude[bot]"
+
+CLAUDE_REVIEWER_REQUEST_ID: str = CLAUDE_REVIEWER_LOGIN
+
+CLAUDE_LOGIN_FILTER_SUBSTRING: str = "claude"
+
+CLAUDE_CLEAN_REVIEW_STATE: str = "APPROVED"
+
+ALL_CLAUDE_DIRTY_REVIEW_STATES: tuple[str, ...] = ("CHANGES_REQUESTED", "COMMENTED")
+
+CLAUDE_SOFT_DIRTY_REVIEW_STATE: str = "COMMENTED"
+
 BUGBOT_DIRTY_BODY_REGEX: str = (
     r"Cursor Bugbot has reviewed your changes and found \d+ potential issue"
 )
@@ -54,12 +73,46 @@ GH_FIELD_BODY_AT_PREFIX: str = "body=@"
 
 GH_REPO_ARG_TEMPLATE: str = "{owner}/{repo}"
 
-PR_BASE_REF_FIELDS: str = "baseRefName"
+SKILL_REFLOW_MAXIMUM_WIDTH: int = 80
+
+PR_CONVERGE_SKILL_PATH: Path = Path(__file__).resolve().parent.parent.parent / "SKILL.md"
+
+MARKDOWN_CODE_FENCE_MARKER: str = "```"
+
+YAML_FRONT_MATTER_DELIMITER: str = "---"
+
+YAML_DESCRIPTION_PREFIX: str = "description: >-"
 
-COPILOT_FOLLOWUP_BRANCH_TEMPLATE: str = "chore/copilot-followup-{parent_number}-{short_sha}"
+EXAMPLE_OPEN_TAG: str = "<example>"
 
-COPILOT_FOLLOWUP_PR_TITLE_TEMPLATE: str = (
-    "chore: address Copilot findings from PR #{parent_number}"
+EXAMPLE_CLOSE_TAG: str = "</example>"
+
+BASH_FENCE_LANGUAGE: str = "bash"
+
+BASH_LINE_CONTINUATION_SUFFIX: str = " \\"
+
+BASH_CONTINUATION_INDENT: str = "  "
+
+REFLOW_FRONT_MATTER_ERROR: str = "expected YAML front matter starting with ---"
+
+ORDERED_MARKDOWN_LIST_PATTERN: re.Pattern[str] = re.compile(
+    r"^(?P<leading_whitespace>\s*)(?P<marker>\d+\.\s)(?P<body>.*)$"
+)
+
+BULLET_MARKDOWN_LIST_PATTERN: re.Pattern[str] = re.compile(
+    r"^(?P<leading_whitespace>\s*)(?P<marker>[-*]\s)(?P<body>.*)$"
 )
 
-COPILOT_FOLLOWUP_SHORT_SHA_LENGTH: int = 8
+UNFINISHED_MARKDOWN_LINK_TARGET_PATTERN: re.Pattern[str] = re.compile(r"\]\([^)]*$")
+
+MARKDOWN_HEADING_PATTERN: re.Pattern[str] = re.compile(r"^#{1,6}\s+.+$")
+
+MARKDOWN_REFERENCE_DEFINITION_PATTERN: re.Pattern[str] = re.compile(r"^\[[^\]]+\]:\s+\S+")
+
+BASH_LINE_CONTINUATION_MARKER_WIDTH: int = 2
+
+CODE_FENCE_MARKER_LENGTH: int = 3
+
+BASH_MINIMUM_SEGMENT_WIDTH: int = 1
+
+LONG_ROW_PREVIEW_LIMIT: int = 20

package/skills/pr-converge/scripts/config/reflow_skill_md_constants.py

@@ -0,0 +1,13 @@
+"""Configuration for the pr-converge skill Markdown reflow script."""
+
+import re
+from pathlib import Path
+
+MAXIMUM_LINE_WIDTH: int = 80
+BASH_CONTINUATION_MARKER_WIDTH: int = 2
+TARGET_SKILL_PATH: Path = Path(__file__).resolve().parent.parent.parent / "SKILL.md"
+
+ORDERED_LIST_ITEM_PATTERN: re.Pattern[str] = re.compile(r"^(\s*)(\d+\.\s)(.*)$")
+BULLET_LIST_ITEM_PATTERN: re.Pattern[str] = re.compile(r"^(\s*)([-*]\s)(.*)$")
+UNFINISHED_MARKDOWN_LINK_TARGET_PATTERN: re.Pattern[str] = re.compile(r"\]\([^)]*$")
+MARKDOWN_REFERENCE_DEFINITION_PATTERN: re.Pattern[str] = re.compile(r"^\s*\[[^\]]+\]:\s*\S")

package/skills/pr-converge/scripts/config/test_pr_converge_constants.py

@@ -150,27 +150,3 @@ def test_requested_reviewers_field_template_accepts_reviewer_id() -> None:
     assert rendered == "reviewers[]=copilot-pull-request-reviewer[bot]"
 
 
-def test_pr_base_ref_fields_lists_base_ref_name() -> None:
-    assert "baseRefName" in pr_converge_constants_module.PR_BASE_REF_FIELDS
-
-
-def test_copilot_followup_branch_template_renders_parent_number_and_sha() -> None:
-    rendered = (
-        pr_converge_constants_module.COPILOT_FOLLOWUP_BRANCH_TEMPLATE.format(
-            parent_number=312, short_sha="abc12345"
-        )
-    )
-    assert rendered == "chore/copilot-followup-312-abc12345"
-
-
-def test_copilot_followup_pr_title_template_renders_parent_number() -> None:
-    rendered = (
-        pr_converge_constants_module.COPILOT_FOLLOWUP_PR_TITLE_TEMPLATE.format(
-            parent_number=312
-        )
-    )
-    assert rendered == "chore: address Copilot findings from PR #312"
-
-
-def test_copilot_followup_short_sha_length_is_eight() -> None:
-    assert pr_converge_constants_module.COPILOT_FOLLOWUP_SHORT_SHA_LENGTH == 8

package/skills/pr-converge/scripts/cursor-agents-continue.ahk

@@ -34,14 +34,34 @@ LABEL_ON             := "AGENTS: ON  (Ctrl+Alt+A)"
 DPI_REFERENCE := 96
 
 AUTO_START_FLAG := "--start-on"
+STOP_SCRIPT_FILE_NAME := "cursor-agents-continue-stop-others.ps1"
+POWERSHELL_CORE_SHELL_NAME := "pwsh"
+WINDOWS_POWERSHELL_SHELL_NAME := "powershell.exe"
+STOP_SCRIPT_ARGUMENTS_FORMAT := ' -NoProfile -NoLogo -ExecutionPolicy Bypass -File "{1}" -KeepProcessId {2}'
+STOP_SCRIPT_FAILURE_MESSAGE_FORMAT := 'Could not run duplicate cleanup script "{1}" with {2} or {3}.'
+RUN_WAIT_WINDOW_OPTION := "Hide"
 
 INT32_MINIMUM_VALUE := -2147483648
 
 terminate_other_script_instances() {
-    stop_script := A_ScriptDir "\cursor-agents-continue-stop-others.ps1"
+    stop_script := A_ScriptDir "\" STOP_SCRIPT_FILE_NAME
     if !FileExist(stop_script)
         return
-    RunWait('pwsh -NoProfile -NoLogo -ExecutionPolicy Bypass -File "' stop_script '" -KeepProcessId ' ProcessExist(), , "Hide")
+    if run_stop_script_with_shell(POWERSHELL_CORE_SHELL_NAME, stop_script)
+        return
+    if run_stop_script_with_shell(WINDOWS_POWERSHELL_SHELL_NAME, stop_script)
+        return
+    throw Error(Format(STOP_SCRIPT_FAILURE_MESSAGE_FORMAT, stop_script, POWERSHELL_CORE_SHELL_NAME, WINDOWS_POWERSHELL_SHELL_NAME))
+}
+
+run_stop_script_with_shell(shell_name, stop_script) {
+    stop_command_arguments := Format(STOP_SCRIPT_ARGUMENTS_FORMAT, stop_script, ProcessExist())
+    try {
+        RunWait(shell_name stop_command_arguments, , RUN_WAIT_WINDOW_OPTION)
+        return true
+    } catch {
+        return false
+    }
 }
 
 terminate_other_script_instances()

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

@@ -1,17 +1,19 @@
 """Fetch unaddressed Cursor Bugbot inline comments for the latest Bugbot review on a commit.
 
-Uses ``fetch_bugbot_reviews`` to find the newest submitted Bugbot review whose ``commit_id`` matches the caller
-``current_head``, then returns only ``cursor[bot]`` inline comments whose ``pull_request_review_id`` matches that
-review. This avoids misclassifying a PR when Bugbot posts more than one review on the same SHA: older inline threads
-stay anchored to the earlier review id even when they share the same commit id.
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_inline_comments``
+parameterised by ``bugbot_spec``. The ``fetch_bugbot_reviews`` call lives here
+(rather than inside the core) so tests can patch it on this module to exercise
+the inline-comments fetch in isolation.
 
-Wraps the gh CLI invocation required by the gh-paginate rule for the comments list:
-``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with ``--paginate --slurp`` and external JSON handling.
+Wraps the gh CLI invocation required by the gh-paginate rule for the comments
+list: ``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with
+``--paginate --slurp`` and external JSON handling.
 """
 
+from __future__ import annotations
+
 import argparse
 import json
-import subprocess
 import sys
 from pathlib import Path
 
@@ -22,12 +24,9 @@ from evict_cached_config_modules import evict_cached_config_modules
 
 evict_cached_config_modules()
 
-from config.pr_converge_constants import (
-    CURSOR_BOT_LOGIN,
-    GH_INLINE_COMMENTS_PATH_TEMPLATE,
-)
 from fetch_bugbot_reviews import fetch_bugbot_reviews
-from review_field_helpers import body_of, login_of
+from reviewer_fetch_core import fetch_reviewer_inline_comments
+from reviewer_specs import bugbot_spec
 
 
 def fetch_bugbot_inline_comments(
@@ -37,55 +36,16 @@ def fetch_bugbot_inline_comments(
     number: int,
     current_head: str,
 ) -> list[dict[str, object]]:
-    """Return cursor[bot] inline comments for the latest Bugbot review on ``current_head``.
-
-    Each entry contains comment_id, commit_id, path, line, and body.
-    """
+    """Return Bugbot inline comments for the latest Bugbot review on ``current_head``."""
     all_bugbot_reviews = fetch_bugbot_reviews(owner=owner, repo=repo, number=number)
-    latest_bugbot_review_for_head = next(
-        (
-            each_review
-            for each_review in all_bugbot_reviews
-            if each_review.get("commit_id") == current_head
-        ),
-        None,
-    )
-    if latest_bugbot_review_for_head is None:
-        return []
-    target_pull_request_review_id = latest_bugbot_review_for_head["review_id"]
-    comments_endpoint = GH_INLINE_COMMENTS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        comments_endpoint,
-        "--paginate",
-        "--slurp",
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
+    return fetch_reviewer_inline_comments(
+        bugbot_spec,
+        owner=owner,
+        repo=repo,
+        number=number,
+        current_head=current_head,
+        all_reviews=all_bugbot_reviews,
     )
-    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
-    all_flat_comments = [each_comment for each_page in pages for each_comment in each_page]
-    return [
-        {
-            "comment_id": each_comment["id"],
-            "commit_id": each_comment.get("commit_id"),
-            "path": each_comment.get("path"),
-            "line": each_comment.get("line"),
-            "body": body_of(each_comment),
-        }
-        for each_comment in all_flat_comments
-        if login_of(each_comment) == CURSOR_BOT_LOGIN
-        and each_comment.get("commit_id") == current_head
-        and each_comment.get("pull_request_review_id") == target_pull_request_review_id
-    ]
 
 
 def main() -> int:

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

@@ -1,15 +1,16 @@
 """Fetch Cursor Bugbot reviews newest-first, classified as dirty or clean.
 
-Wraps the gh CLI invocation required by the gh-paginate rule:
-`gh api '...?per_page=100' --paginate --slurp` piped through external Python
-JSON handling (instead of `gh --jq`, which runs per-page and breaks cross-page
-operations like sort/reverse — see GitHub CLI #10459).
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_reviews`` parameterised
+by ``bugbot_spec``. Wraps the gh CLI invocation required by the gh-paginate
+rule: ``gh api '...?per_page=100' --paginate --slurp`` piped through external
+Python JSON handling (instead of ``gh --jq``, which runs per-page and breaks
+cross-page operations like sort/reverse - see GitHub CLI issue 10459).
 """
 
+from __future__ import annotations
+
 import argparse
 import json
-import re
-import subprocess
 import sys
 from pathlib import Path
 
@@ -20,12 +21,8 @@ from evict_cached_config_modules import evict_cached_config_modules
 
 evict_cached_config_modules()
 
-from config.pr_converge_constants import (
-    BUGBOT_DIRTY_BODY_REGEX,
-    CURSOR_BOT_LOGIN,
-    GH_REVIEWS_PATH_TEMPLATE,
-)
-from review_field_helpers import body_of, login_of, submitted_at_of
+from reviewer_fetch_core import fetch_reviewer_reviews
+from reviewer_specs import bugbot_spec
 
 
 def fetch_bugbot_reviews(
@@ -34,55 +31,10 @@ def fetch_bugbot_reviews(
     repo: str,
     number: int,
 ) -> list[dict[str, object]]:
-    """Return Cursor Bugbot reviews newest-first, each with a clean/dirty classification.
-
-    Each entry contains review_id, commit_id, submitted_at, body, and classification.
-    """
-    reviews_endpoint = GH_REVIEWS_PATH_TEMPLATE.format(
-        owner=owner, repo=repo, number=number
-    )
-    gh_command: list[str] = [
-        "gh",
-        "api",
-        reviews_endpoint,
-        "--paginate",
-        "--slurp",
-    ]
-    completed = subprocess.run(
-        gh_command,
-        capture_output=True,
-        check=True,
-        text=True,
-        encoding="utf-8",
-        errors="replace",
-    )
-    pages: list[list[dict[str, object]]] = json.loads(completed.stdout)
-    all_flat_reviews = [each_review for each_page in pages for each_review in each_page]
-    all_bugbot_reviews = [
-        each_review
-        for each_review in all_flat_reviews
-        if login_of(each_review) == CURSOR_BOT_LOGIN
-        and each_review.get("submitted_at") is not None
-        and each_review.get("id") is not None
-    ]
-    all_bugbot_reviews.sort(
-        key=lambda each_review: submitted_at_of(each_review), reverse=True
+    """Return Cursor Bugbot reviews newest-first, each with a classification."""
+    return fetch_reviewer_reviews(
+        bugbot_spec, owner=owner, repo=repo, number=number
     )
-    dirty_pattern = re.compile(BUGBOT_DIRTY_BODY_REGEX)
-    return [
-        {
-            "review_id": each_review["id"],
-            "commit_id": each_review.get("commit_id"),
-            "submitted_at": each_review["submitted_at"],
-            "body": body_of(each_review),
-            "classification": (
-                "dirty"
-                if dirty_pattern.search(body_of(each_review))
-                else "clean"
-            ),
-        }
-        for each_review in all_bugbot_reviews
-    ]
 
 
 def main() -> int:
@@ -92,7 +44,9 @@ def main() -> int:
     parser.add_argument("--number", required=True, type=int)
     parsed_arguments = parser.parse_args()
     all_reviews = fetch_bugbot_reviews(
-        owner=parsed_arguments.owner, repo=parsed_arguments.repo, number=parsed_arguments.number
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
     )
     json.dump(all_reviews, sys.stdout)
     sys.stdout.write("\n")

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

@@ -0,0 +1,70 @@
+"""Fetch unaddressed Claude inline comments for the latest Claude review on a commit.
+
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_inline_comments``
+parameterised by ``claude_spec``. The ``fetch_claude_reviews`` call lives here
+(rather than inside the core) so tests can patch it on this module to exercise
+the inline-comments fetch in isolation.
+
+Wraps the gh CLI invocation required by the gh-paginate rule for the comments
+list: ``gh api`` on ``repos/{owner}/{repo}/pulls/{number}/comments`` with
+``--paginate --slurp`` and external JSON handling.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from fetch_claude_reviews import fetch_claude_reviews
+from reviewer_fetch_core import fetch_reviewer_inline_comments
+from reviewer_specs import claude_spec
+
+
+def fetch_claude_inline_comments(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    current_head: str,
+) -> list[dict[str, object]]:
+    """Return Claude inline comments for the latest Claude review on ``current_head``."""
+    all_claude_reviews = fetch_claude_reviews(owner=owner, repo=repo, number=number)
+    return fetch_reviewer_inline_comments(
+        claude_spec,
+        owner=owner,
+        repo=repo,
+        number=number,
+        current_head=current_head,
+        all_reviews=all_claude_reviews,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parser.add_argument("--commit", required=True, dest="current_head")
+    parsed_arguments = parser.parse_args()
+    all_comments = fetch_claude_inline_comments(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
+        current_head=parsed_arguments.current_head,
+    )
+    json.dump(all_comments, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,61 @@
+"""Fetch Claude reviewer-bot reviews newest-first, classified as dirty or clean.
+
+Thin wrapper around ``reviewer_fetch_core.fetch_reviewer_reviews`` parameterised
+by ``claude_spec``. Classification follows the review's ``state`` field
+(``APPROVED`` -> clean; ``CHANGES_REQUESTED`` -> dirty; ``COMMENTED`` with
+non-empty body -> dirty; everything else -> clean) - see ``reviewer_specs``.
+
+Wraps the gh CLI invocation required by the gh-paginate rule:
+``gh api '...?per_page=100' --paginate --slurp`` piped through external Python
+JSON handling (instead of ``gh --jq``, which runs per-page and breaks
+cross-page operations like sort/reverse - see GitHub CLI issue 10459).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+if str(Path(__file__).resolve().parent) not in sys.path:
+    sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from evict_cached_config_modules import evict_cached_config_modules
+
+evict_cached_config_modules()
+
+from reviewer_fetch_core import fetch_reviewer_reviews
+from reviewer_specs import claude_spec
+
+
+def fetch_claude_reviews(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+) -> list[dict[str, object]]:
+    """Return Claude reviews newest-first, each with a classification."""
+    return fetch_reviewer_reviews(
+        claude_spec, owner=owner, repo=repo, number=number
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True)
+    parser.add_argument("--repo", required=True)
+    parser.add_argument("--number", required=True, type=int)
+    parsed_arguments = parser.parse_args()
+    all_reviews = fetch_claude_reviews(
+        owner=parsed_arguments.owner,
+        repo=parsed_arguments.repo,
+        number=parsed_arguments.number,
+    )
+    json.dump(all_reviews, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())