@toolu/opencode 6.8.0

package/plugins/pr-babysit/scripts/reply-thread.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+# reply-thread.sh — post one reply (review thread, conversation, or review-
+# level) and record it in slot state so it is never posted twice.
+#
+# Usage: reply-thread.sh --state-file <path> --kind thread|conversation|review
+#          (--thread <graphqlId> --root-comment <databaseId> --in-reply-to <databaseId>
+#           | --comment-id <id> | --review-id <id>)
+#          --body-file <path> [--timeout SECONDS]
+#
+# Idempotency key = the reviewer comment being answered:
+#   thread:<threadId>@<inReplyTo> · conversation:<id> · review:<id>
+# A key already present in actions.replied → exit 4 duplicate_reply, nothing
+# posted. A later reviewer follow-up carries a new inReplyTo, so it is
+# answerable. The body comes from a file so untrusted text never enters argv.
+# The agent writes the words; this script makes the call land or says why not.
+# Exit: 0 posted (stdout {ok,key,commentId,url}) · 2 usage · 3 api_error |
+#       state_malformed · 4 duplicate_reply · 75 locked.
+set -euo pipefail
+
+PB_SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)
+# shellcheck source=lib/common.sh
+. "$PB_SCRIPT_DIR/lib/common.sh"
+# shellcheck source=lib/lock.sh
+. "$PB_SCRIPT_DIR/lib/lock.sh"
+# shellcheck source=lib/gh.sh
+. "$PB_SCRIPT_DIR/lib/gh.sh"
+# shellcheck source=lib/state.sh
+. "$PB_SCRIPT_DIR/lib/state.sh"
+
+state_file=""; kind=""; thread=""; root=""; in_reply_to=""; comment_id=""; review_id=""; body_file=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --state-file)   state_file="${2:-}"; shift 2 ;;
+    --kind)         kind="${2:-}"; shift 2 ;;
+    --thread)       thread="${2:-}"; shift 2 ;;
+    --root-comment) root="${2:-}"; shift 2 ;;
+    --in-reply-to)  in_reply_to="${2:-}"; shift 2 ;;
+    --comment-id)   comment_id="${2:-}"; shift 2 ;;
+    --review-id)    review_id="${2:-}"; shift 2 ;;
+    --body-file)    body_file="${2:-}"; shift 2 ;;
+    --timeout)      PB_GH_TIMEOUT="${2:-}"; shift 2 ;;
+    *) pb_fail usage "reply-thread.sh: unknown argument: $1" ;;
+  esac
+done
+[ -n "$state_file" ] || pb_fail usage "reply-thread.sh: --state-file required"
+[ -n "$body_file" ] && [ -f "$body_file" ] || pb_fail usage "reply-thread.sh: --body-file <existing file> required"
+[ -s "$body_file" ] || pb_fail usage "reply-thread.sh: reply body is empty"
+# GitHub caps comment bodies at 65536 characters; refuse before the request.
+[ "$(wc -c <"$body_file" | tr -d ' ')" -le 65536 ] || pb_fail usage "reply-thread.sh: reply body exceeds GitHub's 65536-character limit"
+case "$kind" in
+  thread)
+    [[ "$thread" =~ ^[A-Za-z0-9_=-]+$ ]] || pb_fail usage "reply-thread.sh: --thread <graphqlId> required for --kind thread"
+    [[ "$root" =~ ^[0-9]+$ ]] || pb_fail usage "reply-thread.sh: --root-comment <databaseId> required for --kind thread"
+    [[ "$in_reply_to" =~ ^[0-9]+$ ]] || pb_fail usage "reply-thread.sh: --in-reply-to <databaseId> required for --kind thread"
+    key="thread:${thread}@${in_reply_to}" ;;
+  conversation)
+    [[ "$comment_id" =~ ^[0-9]+$ ]] || pb_fail usage "reply-thread.sh: --comment-id <id> required for --kind conversation"
+    key="conversation:${comment_id}" ;;
+  review)
+    [[ "$review_id" =~ ^[0-9]+$ ]] || pb_fail usage "reply-thread.sh: --review-id <id> required for --kind review"
+    key="review:${review_id}" ;;
+  *) pb_fail usage "reply-thread.sh: --kind must be thread, conversation or review" ;;
+esac
+
+pb_require jq gh
+pb_init
+pb_mktmpdir
+pb_lock_acquire "$state_file" || pb_lock_fail "$state_file"
+pb_state_load "$state_file"
+
+# Idempotency: refuse before any request.
+if jq -e --arg k "$key" '.actions.replied[$k] != null' "$state_file" >/dev/null 2>&1; then
+  pb_fail duplicate_reply "reply-thread.sh: a reply to $key is already recorded; not posting again" \
+    "$(jq -c --arg k "$key" '{key:$k, recorded:.actions.replied[$k]}' "$state_file")"
+fi
+
+case "$kind" in
+  thread)       endpoint="repos/$PB_STATE_REPO/pulls/$PB_STATE_NUMBER/comments/$root/replies" ;;
+  conversation|review) endpoint="repos/$PB_STATE_REPO/issues/$PB_STATE_NUMBER/comments" ;;
+esac
+jq -n --rawfile body "$body_file" '{body:$body}' >"$PB_TMPDIR/payload.json"
+pb_gh "$PB_TMPDIR/reply.json" api --method POST "$endpoint" --input "$PB_TMPDIR/payload.json" || pb_gh_fail reply
+jq -e '.id | type == "number"' "$PB_TMPDIR/reply.json" >/dev/null 2>&1 \
+  || pb_fail invalid_json "reply-thread.sh: reply response carried no comment id" '{"source":"reply"}'
+
+pb_state_update "$state_file" \
+  '.actions.replied[$k] = {commentId: $r.id, url: $r.html_url, at: $now, headSha: $head, kind: $kind}' \
+  --arg k "$key" --arg now "$(pb_now)" --arg head "$PB_STATE_HEAD" --arg kind "$kind" \
+  --argjson r "$(jq -c '{id, html_url}' "$PB_TMPDIR/reply.json")"
+jq -c --arg k "$key" '{ok:true, key:$k, commentId:.id, url:.html_url}' "$PB_TMPDIR/reply.json"

package/plugins/pr-babysit/scripts/resolve-thread.sh

@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+# resolve-thread.sh — resolve one review thread and CONFIRM it from the
+# mutation response before recording it. A reply is never a resolve.
+#
+# Usage: resolve-thread.sh --state-file <path> --thread <graphqlId> [--timeout SECONDS]
+#
+# The mutation runs up to 3 times until the response shows
+# thread.isResolved == true. Still false → exit 5 resolve_unconfirmed and the
+# thread stays out of actions.resolved, so the next tick's resolution audit
+# picks it up again. A thread already recorded as confirmed → exit 0 without
+# any request. Transport failure after lib/gh.sh's bounded retry → exit 3.
+# Exit: 0 confirmed (stdout {ok,thread,confirmed,attempts}) · 2 usage ·
+#       3 api_error | state_malformed · 5 resolve_unconfirmed · 75 locked.
+set -euo pipefail
+
+PB_SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd -P)
+# shellcheck source=lib/common.sh
+. "$PB_SCRIPT_DIR/lib/common.sh"
+# shellcheck source=lib/lock.sh
+. "$PB_SCRIPT_DIR/lib/lock.sh"
+# shellcheck source=lib/gh.sh
+. "$PB_SCRIPT_DIR/lib/gh.sh"
+# shellcheck source=lib/state.sh
+. "$PB_SCRIPT_DIR/lib/state.sh"
+
+state_file=""; thread=""
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --state-file) state_file="${2:-}"; shift 2 ;;
+    --thread)     thread="${2:-}"; shift 2 ;;
+    --timeout)    PB_GH_TIMEOUT="${2:-}"; shift 2 ;;
+    *) pb_fail usage "resolve-thread.sh: unknown argument: $1" ;;
+  esac
+done
+[ -n "$state_file" ] || pb_fail usage "resolve-thread.sh: --state-file required"
+# GraphQL node ids are base64url-ish; anything else is a caller bug, not a request.
+[[ "$thread" =~ ^[A-Za-z0-9_=-]+$ ]] || pb_fail usage "resolve-thread.sh: --thread <graphqlId> required (got '${thread:-}')"
+
+pb_require jq gh
+pb_init
+pb_mktmpdir
+pb_lock_acquire "$state_file" || pb_lock_fail "$state_file"
+pb_state_load "$state_file"
+
+if jq -e --arg t "$thread" '.actions.resolved[$t].confirmed == true' "$state_file" >/dev/null 2>&1; then
+  jq -c --arg t "$thread" '{ok:true, thread:$t, confirmed:true, attempts:0, alreadyResolved:true, at:.actions.resolved[$t].at}' "$state_file"
+  exit 0
+fi
+
+mutation='mutation($threadId:ID!){ resolveReviewThread(input:{threadId:$threadId}){ thread{ id isResolved } } }'
+attempt=0; confirmed=false; last=""
+while [ "$attempt" -lt 3 ]; do
+  attempt=$((attempt + 1))
+  pb_gh "$PB_TMPDIR/resolve.json" api graphql -f threadId="$thread" -f query="$mutation" || pb_gh_fail resolve
+  pb_gh_json_ok "$PB_TMPDIR/resolve.json" || pb_fail invalid_json "resolve-thread.sh: mutation response carried errors[]" \
+    "$(jq -c '{source:"resolve", errors:(.errors // [])}' "$PB_TMPDIR/resolve.json")"
+  last=$(jq -c '.data.resolveReviewThread.thread // null' "$PB_TMPDIR/resolve.json")
+  if [ "$(jq -r '.isResolved // false' <<<"$last")" = true ]; then confirmed=true; break; fi
+  echo "resolve-thread.sh: attempt $attempt returned isResolved=false for $thread; retrying" >&2
+  sleep 1
+done
+
+if [ "$confirmed" != true ]; then
+  pb_fail resolve_unconfirmed "resolve-thread.sh: $thread still unresolved after $attempt attempt(s)" \
+    "$(jq -nc --arg t "$thread" --argjson attempts "$attempt" --argjson last "${last:-null}" '{thread:$t, attempts:$attempts, lastResponse:$last}')"
+fi
+
+pb_state_update "$state_file" \
+  '.actions.resolved[$t] = {confirmed: true, at: $now, attempts: $attempts, headSha: $head}' \
+  --arg t "$thread" --arg now "$(pb_now)" --argjson attempts "$attempt" --arg head "$PB_STATE_HEAD"
+jq -nc --arg t "$thread" --argjson attempts "$attempt" '{ok:true, thread:$t, confirmed:true, attempts:$attempts}'

package/plugins/pr-babysit/skills/babysit/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: babysit
+description: Use when the user explicitly asks Codex, or an authorized verified execution handoff invokes it, to monitor and autonomously clear the current branch's pull request until CI, review threads, and the review-bot verdict are all green.
+---
+
+# Babysit a PR
+
+This no-argument invocation explicitly authorizes one durable babysitting goal
+for the current repository and PR. A verified execution handoff is sufficient authorization
+when execution already confirmed delivery authorization, GitHub
+auth, a non-default branch, and this installed plugin; do not ask again or
+introduce handoff arguments. Read [the canonical workflow](../../workflows/babysit.md)
+completely and follow only its Codex controller branches plus every shared
+strict-clearance step. Each tick is one command — the shipped
+`scripts/babysit-tick.sh` under this plugin's root (`../../scripts/babysit-tick.sh`
+relative to this file), with `--state-file` set to the Codex slot path; its output contract is [references/helper.md](references/helper.md).
+Trust that result: never write a polling script or controller of your own,
+never re-fetch with ad-hoc `gh` calls what the result already reports, and act
+through `reply-thread.sh`, `resolve-thread.sh` and `record.sh`.
+
+Use `get_goal` before `create_goal`; keep one active goal for the resolved
+repository/PR. Continue with bounded cycles: use the native `wait` mechanism for
+at most 60 seconds, persist the exact slot state, and allow later goal
+continuations to resume. Pending checks are not completion or blockage.
+
+Call `update_goal` with `complete` only after the same-cycle success audit proves
+CI green, zero unresolved threads, and an approved zero-finding bot verdict.
+Call it with `blocked` only for a genuine human-only escalation after the same
+blocker has met Codex's consecutive-goal-turn threshold. For `stop` or `cancel`,
+perform the canonical local cleanup and tell the user to cancel through Codex's
+goal control; cancellation is not a completion status.

package/plugins/pr-babysit/skills/babysit/references/helper.md

@@ -0,0 +1,209 @@
+# pr-babysit helper contract
+
+The tick helper is the deterministic half of babysitting. It lives under the
+plugin's `scripts/` directory, is plain bash (`gh` and `jq` only; bash 3.2 — `git`
+is used by the workflow's worktree steps, not by these scripts), and
+is the same on Claude Code and Codex — only `--state-file` differs by host.
+Read this file instead of the script sources: every field the agent may act
+on is listed here. Fields not listed are not part of the contract.
+
+## Scripts
+
+| Script | Role | Exit codes |
+|---|---|---|
+| `babysit-tick.sh` | **The tick.** Lock the slot → collect → reduce → persist → print the result. The only read-side command the workflow runs. | `0` result · `2` usage · `3` structured error (state preserved, `pr.lastError` stamped) · `75` slot locked |
+| `collect-pr.sh` | Read side: PR metadata, review threads (paginated, nested comment pages), issue comments, reviews; head re-checked after the fan-out; bot verdict via `parse-verdict.sh`. Writes one snapshot. | `0` · `2` · `3` |
+| `reduce-state.sh` | Pure decision layer: snapshot + prior state + `--now` → next state + result. No network, no clock. | `0` · `2` · `3` |
+| `reply-thread.sh` | Write side: post one reply (thread / conversation / review-level), idempotent per reviewer comment. | `0` · `2` · `3` · `4` duplicate_reply · `75` |
+| `resolve-thread.sh` | Write side: `resolveReviewThread`, confirmed from the response, retried, recorded. | `0` · `2` · `3` · `5` resolve_unconfirmed · `75` |
+| `record.sh` | Hand agent decisions to the reducer: `round`, `flag-injection`, `status`. | `0` · `2` · `3` · `75` |
+| `parse-verdict.sh` | Existing verdict parser; unchanged. | — |
+
+Structured errors are one JSON document on stdout:
+`{"version":1,"errors":[{"code":"…","message":"…", …}]}`. `code` is a closed set:
+`usage`, `gh_unavailable`, `jq_required`, `api_error`, `invalid_json`,
+`head_moved`, `state_malformed`, `slot_mismatch`, `locked`, `duplicate_reply`,
+`resolve_unconfirmed`.
+
+## `babysit-tick.sh`
+
+```
+babysit-tick.sh --repo <owner/repo> --pr <n> --state-file <path>
+                [--snapshot-out <path>] [--snapshot-in <path>]
+                [--page-size N] [--timeout SECONDS] [--now <iso8601>]
+```
+
+- `--state-file` — the host's slot path, verbatim: `/tmp/pr-babysit-<slot>.json`
+  (Claude) or `<repo>/.codex/tmp/pr-babysit/<slot>.json` (Codex). Created on the
+  first tick, resumed after.
+- `--snapshot-out` — full snapshot (default `<state-file minus .json>.snapshot.json`).
+- `--snapshot-in` — replay a captured snapshot instead of collecting (tests,
+  debugging). The workflow never passes it.
+- `--timeout` — per `gh` call (default 60 s); every call retries 3× with 2 s /
+  4 s waits on timeouts, 5xx, 429, rate-limit 403 and connection errors, and
+  never on other 4xx.
+- `--page-size` — GraphQL/REST page size (default 100). Exists so pagination is
+  testable on small real PRs.
+
+The PR head is read before and after the fan-out; if it moved the collection
+runs once more, then fails with `head_moved`. A tick never writes a partial
+state: state and snapshot are written atomically (temp file + rename) and a
+crash leaves the previous state and no temp file.
+
+## Result (`version: 1`)
+
+What the agent acts on. Printed on stdout by `babysit-tick.sh`.
+
+| Field | Meaning |
+|---|---|
+| `slot` | `<owner>-<repo>-<number>`, lowercase. |
+| `changed` | Any of `ciStatus, reviewDecision, mergeable, unresolvedThreads, headSha, botVerdict, botState, botFindingKeys` differs from the previous tick. `false` → silent tick. |
+| `decision` | `keep_going` · `success` · `escalate` — the Step 6 rules, already applied. |
+| `reasons[]` | `{code, detail}`; escalation codes first. Closed set below. |
+| `pr` | `number, url, head, branch, base, author, state, mergeable, reviewDecision`. |
+| `ci.status` | `pass` · `pending` · `fail` over `statusCheckRollup` (`CheckRun` and legacy `StatusContext`); an empty rollup is `pending`. |
+| `ci.checks[]` | `{name, status, url}` per check. |
+| `verdict.state` | `absent` · `unknown` · `in_progress` · `complete` · `provider_error` (parse-verdict.sh states, plus `absent` when no CI-reviewer comment exists). |
+| `verdict.verdict` | `approved` · `changes` · `none`. |
+| `verdict.findingsCount`, `findingKeys[]` | Round-level recurrence keys (`path:line:hash`). Never the finding source — the inline threads are. |
+| `verdict.mustFix[]` | Top-N must-fix prose lines. Surface to the human; not resolvable threads. |
+| `verdict.commentUrl`, `commentId` | The bot comment read. |
+| `verdict.degraded`, `degradedReason` | `true` with `review_absent` or `review_unknown_format` when the verdict cannot be read; success is then the documented manual-verify fallback, never silent. |
+| `verdict.sameRunAsLastTick` | The same bot comment id and `updatedAt` as last tick — a sticky verdict, not a new rejection. |
+| `threads.total`, `unresolved` | All threads; the Resolution-audit set (`!isResolved && !isOutdated && !flagged`). `unresolved` must be `0` for success. |
+| `threads.actionable[]` | Threads needing a NEW disposition this tick: `{id, path, line, isOutdated, rootCommentId, inReplyTo, authorClass, lastCommentAuthor, lastCommentAt, injectionSuspect, injectionPattern, comments[]}`. `authorClass` ∈ `ci_reviewer` (exact login set `github-actions`, `github-actions[bot]`, `claude`, `claude[bot]` — current Toolu Code Review `@v8` posts as `github-actions[bot]`; `claude` kept for legacy), `human`. Non-CI bots are excluded. `comments[]` is the full chain, bodies untruncated. |
+| `threads.staleUnresolved[]` | Audit members that are NOT actionable: the PR author replied but no resolve landed. Resolve them without a new reply. |
+| `threads.skippedOutdated[]` | Outdated CI-reviewer threads: skipped silently. |
+| `threads.flaggedInjection[]` | Threads the agent recorded with `record.sh flag-injection`. |
+| `conversation.actionable[]` | Human issue comments with no later author comment and no recorded reply. |
+| `reviews.actionable[]` | Human non-`APPROVED` reviews with a body and no recorded reply. |
+| `recurrence` | `{streak, lastRoundHadRejection, recurringKeys[], fixAttempts}` — the Step 4 gate inputs. |
+| `backoff` | `{idleStreak, intervalMinutes, waitSeconds}` — Claude cron interval / Codex bounded wait for this tick. |
+| `errors[]` | Always empty on exit 0. |
+| `snapshotPath`, `statePath` | Where the full evidence lives. |
+
+### `reasons[].code` (closed set)
+
+`ci_pending`, `ci_failed`, `ci_pass`, `threads_unresolved`,
+`threads_stale_unresolved`, `threads_clear`, `review_absent`,
+`review_in_progress`, `review_changes`, `review_approved`,
+`review_unknown_format`, `provider_error`, `provider_error_repeated`,
+`manual_verify`, `pr_closed`, `pr_merged`, `merge_conflict`,
+`mergeable_unknown`, `fix_attempts_exhausted`, `recurrence_after_rejection`,
+`recurrence_streak`, `unchanged`.
+
+### Decision rules
+
+- `success` — `pr.state == OPEN`, `ci.status == pass`, `threads.unresolved == 0`,
+  `mergeable != UNKNOWN`, and the verdict is `complete`/`approved`/zero findings
+  — or `degraded` (reasons then include `manual_verify`).
+- `escalate` — PR merged/closed, `mergeable == CONFLICTING`, `fixAttempts ≥ 5`,
+  finding keys recurring after a Won't-fix round, a recurrence streak of 2, or
+  `provider_error` twice on the same head.
+- `keep_going` — everything else, including pending CI, an in-progress review,
+  an unchanged tick, and `mergeable == UNKNOWN`.
+
+Recurrence only advances on a NEW verdict run (`sameRunAsLastTick: false`) and
+only against the keys the agent rotated with `record.sh round`.
+
+## State (`version: 2`)
+
+Persisted at `--state-file`; owned by the helper. The agent reads it only
+through the result, and writes it only through `record.sh`, `reply-thread.sh`
+and `resolve-thread.sh`.
+
+| Field | Meaning |
+|---|---|
+| `slot`, `repo`, `number`, `cronName` | Slot identity; a state for another PR is refused (`slot_mismatch`). |
+| `lastUpdate`, `totalTicks`, `idleStreak`, `currentInterval`, `waitSeconds` | Tick bookkeeping and backoff. |
+| `status` | `active` · `complete` · `escalated` · `cancelled` — set only by `record.sh status`. |
+| `worktree` | Codex's exact worktree path for this slot, or `null`. |
+| `pr.key`, `ciStatus`, `reviewDecision`, `mergeable`, `unresolvedThreads`, `headSha` | Last observed values (change detection). |
+| `pr.fixAttempts` | Bumped by `record.sh round --fix-pushed`, cap 5. |
+| `pr.botVerdict`, `botState`, `botCommentId`, `botCommentUpdatedAt`, `botFindingKeys` | Last verdict and its run identity. |
+| `pr.lastRoundFindingKeys`, `lastRoundHadRejection`, `recurrenceStreak` | Step 4 gate memory; rotated by `record.sh round`. |
+| `pr.unresolvedAfterClearance` | Audit count at the last tick; non-zero on a completed tick is a bug. |
+| `pr.lastError` | `{code, message, at}` of the last failed tick, or `null`. |
+| `actions.replied` | `key → {commentId, url, at, headSha, kind}`; keys `thread:<id>@<inReplyTo>`, `conversation:<id>`, `review:<id>`. |
+| `actions.resolved` | `threadId → {confirmed, at, attempts, headSha}`. |
+| `actions.flagged` | `threadId → {reason, at}`. |
+| `lastGoodSnapshot` | Path of the last snapshot that produced a result. |
+
+## Write side
+
+```
+reply-thread.sh --state-file <path> --kind thread --thread <id> --root-comment <databaseId> --in-reply-to <databaseId> --body-file <file>
+reply-thread.sh --state-file <path> --kind conversation --comment-id <id> --body-file <file>
+reply-thread.sh --state-file <path> --kind review --review-id <id> --body-file <file>
+resolve-thread.sh --state-file <path> --thread <id>
+record.sh round --state-file <path> --had-rejection true|false [--fix-pushed]
+record.sh flag-injection --state-file <path> --thread <id>
+record.sh status --state-file <path> --status complete|escalated|cancelled
+```
+
+- `--thread`, `--root-comment`, `--in-reply-to` come straight from
+  `threads.actionable[]` (`id`, `rootCommentId`, `inReplyTo`).
+- The body comes from a file so untrusted text never enters argv.
+- A reply is idempotent per reviewer comment: the same `--in-reply-to` twice is
+  exit `4` and nothing is posted; a reviewer follow-up has a new `inReplyTo`.
+- `resolve-thread.sh` returns `0` only after the mutation response shows
+  `isResolved: true`; three false responses → exit `5`, nothing recorded, and
+  the thread stays in `staleUnresolved` next tick. A confirmed thread is not
+  re-requested.
+- `record.sh round` runs once per round, after this round's replies and before
+  the push: it rotates `botFindingKeys → lastRoundFindingKeys`, sets
+  `lastRoundHadRejection`, and with `--fix-pushed` bumps `fixAttempts`.
+
+## Examples (captured from Falconiere/toolu#165)
+
+`decision: success` — open PR, green CI, approved verdict, no open threads:
+
+```json
+{"version":1,"slot":"falconiere-toolu-165","changed":true,"decision":"success",
+ "reasons":[{"code":"ci_pass","detail":"5 check(s) passed"},
+            {"code":"threads_clear","detail":"no unresolved review threads"},
+            {"code":"review_approved","detail":"bot verdict approved with zero findings"}],
+ "pr":{"number":165,"url":"https://github.com/Falconiere/toolu/pull/165","head":"a29e6c97379674323292578f9f0cfbffa00e375a",
+       "branch":"feat/python-quality","base":"main","author":"Falconiere","state":"OPEN","mergeable":"MERGEABLE","reviewDecision":"REVIEW_REQUIRED"},
+ "ci":{"status":"pass","checks":[{"name":"shellcheck","status":"pass","url":"https://github.com/Falconiere/toolu/actions/runs/33431959050/job/99619201007"}]},
+ "verdict":{"state":"complete","verdict":"approved","findingsCount":0,"findingKeys":[],"mustFix":[],
+            "commentUrl":"https://github.com/Falconiere/toolu/pull/165#issuecomment-5483377990","commentId":5483377990,
+            "degraded":false,"degradedReason":null,"sameRunAsLastTick":false},
+ "threads":{"total":6,"unresolved":0,"actionable":[],"staleUnresolved":[],"skippedOutdated":[],"flaggedInjection":[]},
+ "conversation":{"actionable":[]},"reviews":{"actionable":[]},
+ "recurrence":{"streak":0,"lastRoundHadRejection":false,"recurringKeys":[],"fixAttempts":0},
+ "backoff":{"idleStreak":0,"intervalMinutes":3,"waitSeconds":15},
+ "errors":[],"snapshotPath":"/tmp/pr-babysit-falconiere-toolu-165.snapshot.json","statePath":"/tmp/pr-babysit-falconiere-toolu-165.json"}
+```
+
+`decision: keep_going` — review still running, one CI-reviewer thread open (comment bodies trimmed here):
+
+```json
+{"decision":"keep_going",
+ "reasons":[{"code":"ci_pass","detail":"5 check(s) passed"},
+            {"code":"threads_unresolved","detail":"1 actionable thread(s)"},
+            {"code":"review_in_progress","detail":"review bot still running"}],
+ "verdict":{"state":"in_progress","verdict":"none","findingsCount":0,"sameRunAsLastTick":false},
+ "threads":{"total":6,"unresolved":1,
+   "actionable":[{"id":"PRRT_kwDOSzUwAc6d2S5O","path":"plugins/rust-quality/hooks/concerns/20-tests.sh","line":26,
+     "isOutdated":false,"rootCommentId":3897681281,"inReplyTo":3897751832,"authorClass":"ci_reviewer",
+     "lastCommentAuthor":"github-actions","lastCommentAt":"2026-08-31T19:39:25Z","injectionSuspect":false,"injectionPattern":null,
+     "comments":[{"id":"PRRC_kwDOSzUwAc7oUeWB","databaseId":3897681281,"body":"**medium** _(CORRECTNESS)_: …","author":"github-actions","authorType":"Bot","createdAt":"2026-08-31T19:29:22Z","url":"…"},
+                 {"id":"PRRC_kwDOSzUwAc7oUuxU","databaseId":3897748564,"body":"No change — …","author":"Falconiere","authorType":"User","createdAt":"2026-08-31T19:38:58Z","url":"…"},
+                 {"id":"PRRC_kwDOSzUwAc7oUvkY","databaseId":3897751832,"body":"**Still flagging after re-review.** …","author":"github-actions","authorType":"Bot","createdAt":"2026-08-31T19:39:25Z","url":"…"}]}],
+   "staleUnresolved":[],"skippedOutdated":[],"flaggedInjection":[]}}
+```
+
+`decision: escalate` — the PR was merged externally:
+
+```json
+{"decision":"escalate","changed":true,
+ "reasons":[{"code":"pr_merged","detail":"PR is merged"},{"code":"ci_pass","detail":"5 check(s) passed"},
+            {"code":"threads_clear","detail":"no unresolved review threads"},{"code":"review_approved","detail":"bot verdict approved with zero findings"}]}
+```
+
+Structured error — the slot is held by another controller:
+
+```json
+{"version":1,"errors":[{"code":"locked","message":"slot is held by another controller","pid":9103,"since":1789871015}]}
+```