@olegkoval/agent-skills 1.51.0 → 1.51.2

package/.windsurf/rules/qodoloop.md

@@ -22,10 +22,31 @@ Qodo runs as `qodo-code-review[bot]` and posts **two independent things** per re
 
 **Use the inline threads as the source of truth.** They carry `isResolved` state natively (fetch via GraphQL, see `references/graphql-queries.md`), so "done" is answerable directly instead of re-parsing the rollup's HTML on every iteration. Each thread's body contains a `<details><summary>Agent Prompt</summary>` (or `**Agent Prompt**`) section with a ready-made fix spec, and a severity badge image whose `alt` text is `Remediation recommended` or `Informational` (recommended ↔ "Review recommended", informational ↔ "Optional").
 
-Qodo has **no check run to poll**: there is nothing in `gh pr checks` to wait on. Completion means a new `qodo-code-review[bot]` comment/review appears after your push; poll comments, not checks.
+Qodo has **no check run to poll**: there is nothing in `gh pr checks` to wait on. Completion means a new `qodo-code-review[bot]` comment/review appears after your push; `scripts/pr-review-state.sh` detects it.
 
 **Rate limit is a real terminal state, not a bug.** A completed-looking comment reading "Qodo reviews are paused" / "you've reached your PR review limit" means Qodo will not review again this cycle: stop and report it, don't loop waiting for something that isn't coming.
 
+## Review state comes from the PR, not from memory
+
+`scripts/pr-review-state.sh` reads the PR and prints one JSON object: the current head, whether
+Qodo has acted on that head (a review of it, or any comment after it was pushed), and every
+unresolved review thread with its author. Every "is there work / are we done" decision in this
+loop comes from its exit code, never from what you remember resolving. The script lives in this
+skill's directory, `SKILL_ROOT`: the directory holding this `SKILL.md` (Claude Code prints it as the
+skill's base directory when the skill loads; in Codex, derive it from the selected `SKILL.md` path).
+
+| Exit | `verdict`  | Meaning                                                             | Do                                   |
+|------|------------|---------------------------------------------------------------------|--------------------------------------|
+| 0    | `clean`    | Qodo acted on the current head and no bot thread is unresolved    | exit check: done                     |
+| 10   | `findings` | unresolved threads from Qodo **or any other review bot**          | run an iteration                     |
+| 20   | `pending`  | Qodo has not acted on the current head yet                        | trigger if needed, then wait         |
+| 30   | `limited`  | a rate-limit or paused notice from Qodo after the current head    | stop, report `blocked: rate-limited` |
+
+Resolving the last thread does not make a PR clean: Qodo has not reviewed your push yet. Earlier
+versions of this loop exited at exactly that moment, while the next round of comments was still on
+its way. Human threads are listed in `.unresolved` (`is_bot: false`) and counted in `.counts.humans`;
+they never block `clean`, and this loop never resolves them.
+
 ## Instructions
 
 ### 1. Identify the PR
@@ -50,33 +71,48 @@ narrower.
 
 ### 2. Loop (max 5 iterations)
 
-#### A. Wait for a review of the current head
-
-On **iteration 1**, if there is nothing to push yet (you haven't fixed anything in this loop), don't wait for a brand-new review: use whatever Qodo has already posted as your starting point and go straight to step B. Otherwise:
-
-```bash
-SINCE=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-git push
-```
+#### A. Read the PR state; wait for Qodo's review of the current head
 
-Poll (every ~10s, timeout ~5min), fetching **every page** of comments, not just the first:
+One read answers both "is there work?" and "has Qodo seen my last push?". `SINCE` is the
+timestamp you took right before your last push (step E); leave it empty on iteration 1. Right
+after a push, add `--wait 600` straight away: the wait ends only once the bot has acted on the new
+head, so threads left open on purpose cannot make the push look reviewed.
 
 ```bash
-gh api --paginate "repos/{owner}/{repo}/issues/<PR_NUMBER>/comments?per_page=100" | jq -s '
-  add | map(select(.user.login == "qodo-code-review[bot]")) | sort_by(.created_at)'
+"$SKILL_ROOT/scripts/pr-review-state.sh" --repo OWNER/REPO --pr <PR> --bot qodo-code-review --since "$SINCE"
 ```
 
-From the comments created **after `$SINCE`** (ignore anything older: that's leftover from a prior push, not this one):
-- Any of them contains "review limit" or "paused" → **stop the loop now**, go to Report with `blocked: rate-limited`.
-- The latest one starts with `<h3>Code Review by Qodo</h3>` → proceed to step B.
-- Otherwise (nothing yet, or only "Qodo is busy working") → sleep 10s and poll again, up to the 5-minute timeout.
+- Exit `10` (`findings`): go to B. On iteration 1 this is whatever Qodo (or another bot)
+  already posted.
+- Exit `20` (`pending`): Qodo reviews new pushes on its own, so there is nothing to post. Then wait with the same command plus `--wait 600`. Run the
+  wait in the background where the host allows it (Claude Code: Bash `run_in_background`; you are
+  re-invoked when it exits) so ten minutes of polling never sits in the conversation. Still `20`
+  after the wait: say so out loud, check the PR for a Qodo notice explaining the silence, and wait once more. Still `20` after that: stop and
+  report the timeout honestly; never claim success.
+- Exit `0` (`clean`): go to the exit check. A `--wait` call returns `clean` only after a settle
+  re-read 60 seconds later, so a comment landing right behind the review is still caught. A bare
+  read (no `--wait`) that says `clean` is good enough only when you have not pushed since Qodo's
+  last review.
+- Exit `30` (`limited`): stop now and report `blocked: rate-limited`; nothing more is coming.
+- Exit `1`: the read itself failed (often a transient GitHub 502). Retry once; if it fails again,
+  stop and report it. An unknown state is not a clean one.
 
 #### B. Fetch unresolved findings
 
-Run the paginated GraphQL query in `references/graphql-queries.md` (`unresolvedQodoThreads`): **follow `pageInfo.hasNextPage`/`endCursor` until it's exhausted**; a PR with more than 100 Qodo threads silently loses every finding past the first page otherwise. For each unresolved thread from `qodo-code-review[bot]`: parse the finding title, severity (recommended/optional), file/line, and the **Agent Prompt** block.
+The working set is every unresolved thread in the state JSON with `is_bot: true`: Qodo's
+own (`is_target: true`) **and any other review bot's** (Greptile, for example). A
+fix for one bot often draws a comment from another, and leaving those open is how a "finished" loop
+leaves a PR that is not clean. Never act on a human's thread (`is_bot: false`); list it in the report.
+
+Qodo's threads are `.unresolved[] | select(.is_target)` in step A's state JSON (the script already follows pagination). For each, read the full comment (`gh api repos/{owner}/{repo}/pulls/comments/<comment_id>`) and parse the finding title, severity (recommended/optional), file/line, and the **Agent Prompt** block.
 
 Build the working set: all `recommended` threads, plus `optional` ones too if `--include-optional`.
 
+Threads from other bots come from the state JSON (`.unresolved[] | select(.is_bot and (.is_target | not))`).
+They carry no ready-made fix prompt: read the full comment
+(`gh api repos/{owner}/{repo}/pulls/comments/<comment_id>`), verify its claim against the real
+code, and handle it like any Qodo finding: fix it, or reply with the evidence for not fixing it.
+
 Mark each thread as seen with an 👀 reaction on its first comment (`databaseId` from the query), so
 the bot and a watching human can tell it is being worked. GitHub's reaction set is fixed; `eyes` is
 the only "looking at it" value:
@@ -87,7 +123,15 @@ gh api --method POST repos/{owner}/{repo}/pulls/comments/<DATABASE_ID>/reactions
 
 #### C. Check exit conditions
 
-Stop if the working set is empty, or max iterations reached.
+Stop when step A's read exited `0` (`clean`) after your last push (a `--wait` read, which settles),
+or exited `30` (`limited`), or the iteration cap is reached. An empty working set on its own is not
+done: with no review of the current head yet, it only means Qodo has not answered your push.
+
+Two kinds of thread stay open by design, so for Qodo `findings` can still mean done: a finding you
+**blocked** (replied, deliberately left unresolved) and, without `--include-optional`, an
+**Optional** finding outside the working set. Stop as done when Qodo has acted on the current head
+(`.bots[0].acted_on_head` is `true` in a `--wait` read) and every open bot thread is one of those
+two. Never re-work a thread already in your blocked ledger.
 
 #### D. Fix each finding
 
@@ -100,6 +144,7 @@ If **fixed** is empty, skip straight to F (nothing to commit). Otherwise, stage
 ```bash
 git add <files touched by this iteration's fixes>
 git commit -m "address Qodo review feedback (qodoloop iteration N)"
+SINCE=$(date -u +%Y-%m-%dT%H:%M:%SZ)   # step A reads bot activity after this
 git push
 ```
 
@@ -133,6 +178,18 @@ gh api --method POST repos/{owner}/{repo}/pulls/comments/<DATABASE_ID>/reactions
 
 Go back to step A.
 
+### Keep the context small; resume instead of restarting
+
+- Carry only three things between iterations: the iteration counter, the latest state JSON, and a
+  ledger of each thread you handled (fixed with its commit, rebutted, or blocked). Re-read files
+  fresh each iteration; do not re-paste earlier rounds' comment bodies.
+- All loop state lives on the PR, so the loop is resumable. If the session has grown long or slow,
+  or a bot commented after the loop ended, run this skill again in a fresh session: step A picks up
+  from the PR as it is now. Starting fresh is cheaper than dragging a long session through more
+  rounds.
+- After reporting done, if the host can schedule a follow-up (Claude Code: `/loop` or a scheduled
+  wakeup), offer one re-check about 20 minutes later for bots that comment late.
+
 ### 3. Report
 
 | Field              | Value |
@@ -141,7 +198,8 @@ Go back to step A.
 | Findings resolved  | N     |
 | Findings blocked   | N (with reasons, left unresolved) |
 | Remaining          | N (if any) |
-| Blocked            | rate-limited / human-intervention / max-iterations / none |
+| Human threads      | N (open, listed; never resolved by this loop) |
+| Blocked            | rate-limited / timeout / human-intervention / max-iterations / none |
 
 ```text
 Qodoloop complete.
@@ -153,4 +211,4 @@ Qodoloop complete.
 
 ## References
 
-- `references/graphql-queries.md`: the exact `unresolvedQodoThreads` query and the `resolveReviewThread` / `addPullRequestReviewThreadReply` mutations, with field notes.
+- `references/graphql-queries.md`: the `resolveReviewThread` / `addPullRequestReviewThreadReply` mutations, with field notes. Its `unresolvedQodoThreads` query is superseded by `scripts/pr-review-state.sh` for finding threads.

package/adapters/claude/olko-github-pr/skills/coderabbitloop/SKILL.md

@@ -9,7 +9,7 @@ description: >
   CodeRabbit" / "resolve CodeRabbit comments".
 compatibility: Requires git and gh (GitHub CLI) authenticated, with the CodeRabbit GitHub App installed on the repo.
 metadata:
-  version: "1.1"
+  version: "1.2"
 allowed-tools: Bash(gh:*) Bash(git:*)
 ---
 <!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
@@ -38,6 +38,27 @@ CodeRabbit has slash commands (official, `docs.coderabbit.ai/reference/review-co
 
 **Rate limit is a real terminal state, not a bug.** A comment reading "you've reached your PR review limit" (confirmed live wording) means CodeRabbit will not review again this cycle: stop and report it, don't loop waiting for something that isn't coming.
 
+## Review state comes from the PR, not from memory
+
+`scripts/pr-review-state.sh` reads the PR and prints one JSON object: the current head, whether
+CodeRabbit has acted on that head (a review of it, or any comment after it was pushed), and every
+unresolved review thread with its author. Every "is there work / are we done" decision in this
+loop comes from its exit code, never from what you remember resolving. The script lives in this
+skill's directory, `SKILL_ROOT`: the directory holding this `SKILL.md` (Claude Code prints it as the
+skill's base directory when the skill loads; in Codex, derive it from the selected `SKILL.md` path).
+
+| Exit | `verdict`  | Meaning                                                             | Do                                   |
+|------|------------|---------------------------------------------------------------------|--------------------------------------|
+| 0    | `clean`    | CodeRabbit acted on the current head and no bot thread is unresolved    | exit check: done                     |
+| 10   | `findings` | unresolved threads from CodeRabbit **or any other review bot**          | run an iteration                     |
+| 20   | `pending`  | CodeRabbit has not acted on the current head yet                        | trigger if needed, then wait         |
+| 30   | `limited`  | a rate-limit or paused notice from CodeRabbit after the current head    | stop, report `blocked: rate-limited` |
+
+Resolving the last thread does not make a PR clean: CodeRabbit has not reviewed your push yet. Earlier
+versions of this loop exited at exactly that moment, while the next round of comments was still on
+its way. Human threads are listed in `.unresolved` (`is_bot: false`) and counted in `.counts.humans`;
+they never block `clean`, and this loop never resolves them.
+
 ## Instructions
 
 ### 1. Identify the PR
@@ -62,38 +83,50 @@ gets those edits swept into the fix commit right along with it.
 Keep an explicit iteration counter and stop at 5: the cap is a real bound to enforce, not a figure
 of speech. Each pass through A–F is one iteration; on hitting the cap, go straight to the report.
 
-#### A. Wait for a review of the current head
+#### A. Read the PR state; wait for CodeRabbit's review of the current head
 
-On **iteration 1**, if there is nothing to push yet (you haven't fixed anything in this loop), don't
-wait for a brand-new review: use whatever CodeRabbit has already posted as your starting point and
-go straight to step B. Otherwise:
+One read answers both "is there work?" and "has CodeRabbit seen my last push?". `SINCE` is the
+timestamp you took right before your last push (step E); leave it empty on iteration 1. Right
+after a push, add `--wait 600` straight away: the wait ends only once the bot has acted on the new
+head, so threads left open on purpose cannot make the push look reviewed.
 
 ```bash
-SINCE=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-git push
+"$SKILL_ROOT/scripts/pr-review-state.sh" --repo OWNER/REPO --pr <PR> --bot coderabbitai --since "$SINCE"
 ```
 
-If this repo doesn't auto-review on push, nudge it:
-
-```bash
-gh pr comment <PR_NUMBER> --body "@coderabbitai review"
-```
-
-Poll (every ~10s, timeout ~5min) for CodeRabbit's next formal review to land: a new entry in
-`gh api --paginate repos/{owner}/{repo}/pulls/<PR_NUMBER>/reviews` from `coderabbitai[bot]`
-(REST spelling carries the `[bot]` suffix) created after `$SINCE`. Follow pagination so a review
-that lands on page two is not missed. If you instead see a rate-limit comment ("review limit"),
-**stop the loop now** and go to Report with `blocked: rate-limited`. If no review arrives within
-the timeout after one retry, stop and report the timeout honestly; do not claim success.
+- Exit `10` (`findings`): go to B. On iteration 1 this is whatever CodeRabbit (or another bot)
+  already posted.
+- Exit `20` (`pending`): post `@coderabbitai review` if this repo does not review pushes automatically (`gh pr comment <PR_NUMBER> --body "@coderabbitai review"`). Then wait with the same command plus `--wait 600`. Run the
+  wait in the background where the host allows it (Claude Code: Bash `run_in_background`; you are
+  re-invoked when it exits) so ten minutes of polling never sits in the conversation. Still `20`
+  after the wait: say so out loud, post `@coderabbitai review` once more, and wait once more. Still `20` after that: stop and
+  report the timeout honestly; never claim success.
+- Exit `0` (`clean`): go to the exit check. A `--wait` call returns `clean` only after a settle
+  re-read 60 seconds later, so a comment landing right behind the review is still caught. A bare
+  read (no `--wait`) that says `clean` is good enough only when you have not pushed since CodeRabbit's
+  last review.
+- Exit `30` (`limited`): stop now and report `blocked: rate-limited`; nothing more is coming.
+- Exit `1`: the read itself failed (often a transient GitHub 502). Retry once; if it fails again,
+  stop and report it. An unknown state is not a clean one.
 
 #### B. Fetch unresolved findings
 
-Run the `unresolvedQodoThreads`-shaped query in `references/graphql-queries.md` (filter `author.login`
-on GraphQL's bare `coderabbitai`, **not** REST's `coderabbitai[bot]`: see the reference's login-spelling
-note, and follow `pageInfo.hasNextPage`/`endCursor` until exhausted). For each unresolved thread,
-parse the finding text, its `databaseId`, and the **Prompt for AI Agents** block (heading text is
+The working set is every unresolved thread in the state JSON with `is_bot: true`: CodeRabbit's
+own (`is_target: true`) **and any other review bot's** (Greptile, for example). A
+fix for one bot often draws a comment from another, and leaving those open is how a "finished" loop
+leaves a PR that is not clean. Never act on a human's thread (`is_bot: false`); list it in the report.
+
+CodeRabbit's threads are `.unresolved[] | select(.is_target)` in step A's state JSON (the script
+already follows pagination). For each, read the full comment
+(`gh api repos/{owner}/{repo}/pulls/comments/<comment_id>`) and parse the finding text and the
+**Prompt for AI Agents** block (heading text is
 `🤖 Prompt for AI Agents`, not `Agent Prompt`: match case/emoji-insensitively).
 
+Threads from other bots come from the state JSON (`.unresolved[] | select(.is_bot and (.is_target | not))`).
+They carry no ready-made fix prompt: read the full comment
+(`gh api repos/{owner}/{repo}/pulls/comments/<comment_id>`), verify its claim against the real
+code, and handle it like any CodeRabbit finding: fix it, or reply with the evidence for not fixing it.
+
 Mark each thread as seen with an 👀 reaction on its first comment (`databaseId` from the query), so
 the bot and a watching human can tell it is being worked:
 
@@ -103,7 +136,9 @@ gh api --method POST repos/{owner}/{repo}/pulls/comments/<DATABASE_ID>/reactions
 
 #### C. Check exit conditions
 
-Stop if there are zero unresolved CodeRabbit threads, or max iterations reached.
+Stop when step A's read exited `0` (`clean`) after your last push (a `--wait` read, which settles),
+or exited `30` (`limited`), or the iteration cap is reached. An empty working set on its own is not
+done: with no review of the current head yet, it only means CodeRabbit has not answered your push.
 
 #### D. Fix each finding
 
@@ -123,6 +158,7 @@ If step D changed code:
 git status --short                     # look before you stage
 git add <path> [<path>...]             # the files named in the findings you fixed
 git commit -m "address CodeRabbit review feedback (coderabbitloop iteration N)"
+SINCE=$(date -u +%Y-%m-%dT%H:%M:%SZ)   # step A reads bot activity after this
 git push
 ```
 
@@ -171,6 +207,18 @@ the reply, and a resolved thread with no reply loses the reasoning.
 
 Go back to step A.
 
+### Keep the context small; resume instead of restarting
+
+- Carry only three things between iterations: the iteration counter, the latest state JSON, and a
+  ledger of each thread you handled (fixed with its commit, rebutted, or blocked). Re-read files
+  fresh each iteration; do not re-paste earlier rounds' comment bodies.
+- All loop state lives on the PR, so the loop is resumable. If the session has grown long or slow,
+  or a bot commented after the loop ended, run this skill again in a fresh session: step A picks up
+  from the PR as it is now. Starting fresh is cheaper than dragging a long session through more
+  rounds.
+- After reporting done, if the host can schedule a follow-up (Claude Code: `/loop` or a scheduled
+  wakeup), offer one re-check about 20 minutes later for bots that comment late.
+
 ### 3. Report
 
 | Field              | Value |
@@ -179,6 +227,7 @@ Go back to step A.
 | Findings resolved  | N     |
 | Findings skipped   | N (with reasons) |
 | Remaining          | N (if any) |
+| Human threads      | N (open, listed; never resolved by this loop) |
 | Blocked            | rate-limited / timeout / max-iterations / none |
 
 ```

package/adapters/claude/olko-github-pr/skills/coderabbitloop/scripts/pr-review-state.sh

@@ -0,0 +1,163 @@
+#!/usr/bin/env bash
+# pr-review-state.sh: read a PR's review-bot state once (or until it settles) and print it as JSON.
+#
+# Shared by every review loop in olko-github-pr (codexloop, geminiloop, copilotloop,
+# coderabbitloop, qodoloop). Each skill ships its own copy so it works on every adapter;
+# tests/test-pr-review-state.sh fails if the copies drift apart.
+#
+# The loops decide "done" from this output, never from their own memory of what they resolved:
+#   clean     every --bot has acted on the current head AND no bot thread is unresolved
+#   findings  at least one unresolved thread from any bot (target or not): work to do
+#   pending   some --bot has not acted on the current head yet
+#
+# "Acted on the head" = a review of the head commit, or after the head was pushed: a
+# comment that is not a progress notice, or a PR reaction other than 👀 (Codex signals a clean
+# review with only a 👍 on the PR, and edits a "**Running**" summary comment while it works).
+#   limited   a --bot posted a rate-limit / paused notice after the current head
+set -euo pipefail
+
+usage() {
+  cat >&2 <<'EOF'
+usage: pr-review-state.sh --repo OWNER/REPO --pr N --bot REGEX [--bot REGEX ...]
+                          [--since ISO8601] [--wait SECONDS] [--settle SECONDS] [--interval SECONDS]
+
+  --bot       case-insensitive regex matched against the bare bot login (GraphQL drops "[bot]"),
+              e.g. codex, gemini-code-assist, copilot, coderabbitai, qodo-code-review. Repeatable:
+              every --bot must have acted on the current head before the verdict can be "clean".
+  --since     when the current head was pushed (date -u +%Y-%m-%dT%H:%M:%SZ, taken before the push).
+              Bot activity counts for the head only if it happened after max(head commit date, since).
+  --wait      poll until every --bot has acted on the current head (or posted a limit notice), or
+              SECONDS pass (default 0: read once). Open threads do not end the wait early, so threads
+              left open on purpose cannot make a fresh push look reviewed.
+  --settle    once "clean", wait SECONDS and read again, so a late comment is not missed
+              (default 60 when --wait is set, else 0).
+  --interval  seconds between polls (default 20).
+
+exit: 0 clean, 10 findings, 20 pending, 30 limited, 2 usage, 1 error
+EOF
+  exit 2
+}
+
+REPO="" PR="" SINCE="" WAIT=0 SETTLE="" INTERVAL=20
+BOTS=()
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --repo) REPO="${2:-}"; shift 2 ;;
+    --pr) PR="${2:-}"; shift 2 ;;
+    --bot) BOTS+=("${2:-}"); shift 2 ;;
+    --since) SINCE="${2:-}"; shift 2 ;;
+    --wait) WAIT="${2:-}"; shift 2 ;;
+    --settle) SETTLE="${2:-}"; shift 2 ;;
+    --interval) INTERVAL="${2:-}"; shift 2 ;;
+    -h|--help) usage ;;
+    *) echo "unknown argument: $1" >&2; usage ;;
+  esac
+done
+[ -n "$REPO" ] && [ -n "$PR" ] && [ "${#BOTS[@]}" -gt 0 ] || usage
+case "$REPO" in */*) ;; *) usage ;; esac
+[ -n "$SETTLE" ] || { [ "$WAIT" -gt 0 ] && SETTLE=60 || SETTLE=0; }
+OWNER="${REPO%%/*}" NAME="${REPO#*/}"
+BOTS_JSON=$(printf '%s\n' "${BOTS[@]}" | jq -R . | jq -s .)
+
+QUERY='query($owner:String!,$name:String!,$pr:Int!,$cursor:String){
+  repository(owner:$owner,name:$name){ pullRequest(number:$pr){
+    headRefOid
+    commits(last:1){ nodes{ commit{ oid committedDate } } }
+    reviews(last:100){ nodes{ author{ login __typename } commit{ oid } submittedAt body } }
+    comments(last:100){ nodes{ author{ login __typename } createdAt updatedAt body } }
+    reactions(last:50){ nodes{ content createdAt user{ login } } }
+    reviewThreads(first:100, after:$cursor){
+      pageInfo{ hasNextPage endCursor }
+      nodes{ id isResolved isOutdated path line
+        comments(first:1){ nodes{ databaseId url author{ login __typename } body } } }
+    }
+  } }
+}'
+
+# One full read: first page carries head/reviews/comments; every page carries threads.
+read_state() {
+  local cursor=null page first="" threads="[]"
+  while :; do
+    page=$(gh api graphql -f query="$QUERY" -f owner="$OWNER" -f name="$NAME" \
+      -F pr="$PR" -F cursor="$cursor")
+    [ -n "$first" ] || first="$page"
+    threads=$(jq -c --argjson acc "$threads" \
+      '$acc + .data.repository.pullRequest.reviewThreads.nodes' <<<"$page")
+    [ "$(jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.hasNextPage' <<<"$page")" = "true" ] || break
+    cursor=$(jq -r '.data.repository.pullRequest.reviewThreads.pageInfo.endCursor' <<<"$page")
+  done
+
+  jq -c --argjson bots "$BOTS_JSON" --argjson threads "$threads" --arg since "$SINCE" '
+    .data.repository.pullRequest as $p
+    | $p.headRefOid as $head
+    | ([$p.commits.nodes[0].commit.committedDate // "", $since] | max) as $after
+    | def matches($login): any($bots[]; . as $re | ($login // "") | test($re; "i"));
+      def isbot($a): ($a.__typename // "User") != "User";
+      def progress: test("busy working|in progress|currently processing|currently reviewing|\\*\\*(running|queued)\\*\\*"; "i");
+      def limited: test("review limit reached|reached your (pr )?review limit|reviews are paused|rate limit (exceeded|reached)|been rate[- ]limited"; "i");
+    [ $bots[] as $re
+      | ($p.reviews.nodes  | map(select((.author.login // "") | test($re; "i")))) as $revs
+      | ($p.comments.nodes | map(select((.author.login // "") | test($re; "i")))) as $coms
+      | ($coms | map(select(.updatedAt >= $after))) as $fresh
+      | ($p.reactions.nodes | map(select(((.user.login // "") | test($re; "i"))
+                                         and .content != "EYES" and .createdAt >= $after))) as $reacts
+      | {
+          bot: $re,
+          reviewed_head: any($revs[]; .commit.oid == $head),
+          activity_after_head: (any($fresh[]; (.body | progress) | not)
+                                or ($reacts | length) > 0),
+          limited: any($fresh[]; .body | limited)
+        }
+      | .acted_on_head = (.reviewed_head or .activity_after_head)
+    ] as $per_bot
+    | [ $threads[] | select(.isResolved | not)
+        | .comments.nodes[0] as $c
+        | {
+            thread_id: .id, comment_id: $c.databaseId, url: $c.url,
+            author: $c.author.login, is_bot: isbot($c.author), is_target: matches($c.author.login),
+            path, line, outdated: .isOutdated,
+            excerpt: (($c.body // "") | gsub("\\s+"; " ") | .[0:160])
+          } ] as $open
+    | ($open | map(select(.is_bot))) as $open_bot
+    | {
+        head: $head,
+        head_after: $after,
+        bots: $per_bot,
+        unresolved: $open,
+        counts: {
+          target: ($open_bot | map(select(.is_target)) | length),
+          other_bots: ($open_bot | map(select(.is_target | not)) | length),
+          humans: ($open | map(select(.is_bot | not)) | length)
+        },
+        verdict: (
+          if any($per_bot[]; .limited) then "limited"
+          elif ($open_bot | length) > 0 then "findings"
+          elif any($per_bot[]; .acted_on_head | not) then "pending"
+          else "clean" end)
+      }' <<<"$first"
+}
+
+exit_for() {
+  case "$1" in clean) echo 0 ;; findings) echo 10 ;; pending) echo 20 ;; limited) echo 30 ;; *) echo 1 ;; esac
+}
+
+deadline=$(( SECONDS + WAIT ))
+state=$(read_state)
+verdict=$(jq -r .verdict <<<"$state")
+waiting() { jq -e '.verdict != "limited" and any(.bots[]; .acted_on_head | not)' >/dev/null <<<"$state"; }
+while :; do
+  if waiting && [ "$SECONDS" -lt "$deadline" ]; then
+    sleep "$INTERVAL"
+  elif [ "$verdict" = "clean" ] && [ "$SETTLE" -gt 0 ]; then
+    # Clean once is not clean: bots post a review, then a second bot or a follow-up lands.
+    sleep "$SETTLE"
+    SETTLE=0
+  else
+    break
+  fi
+  state=$(read_state)
+  verdict=$(jq -r .verdict <<<"$state")
+done
+
+printf '%s\n' "$state"
+exit "$(exit_for "$verdict")"