From ffebeb3e24c76489d259540e2ae8ea315649e94c Mon Sep 17 00:00:00 2001
From: Arjun Mehta <arjun.mehta@tata-consulting.co.uk>
Date: Wed, 5 Aug 2026 23:02:43 -0500
Subject: [PATCH] [skills] iterate-pr 2.4.0: never report an unfetched PR as a
 clean one

The feedback fetcher could report `needs_attention: 0` and exit 0 while the PR
held real, unaddressed review feedback. A run that trusted that output merged
unreviewed code, and nothing in the output said so.

Root cause: an empty response and an undelivered one were treated the same.
`get_review_threads` did `if not isinstance(result, dict): break`, so any
non-dict payload - including `gh` exiting 0 with empty stdout - silently yielded
zero threads and a clean-looking summary. The REST channels had the identical
inversion via `flatten_pages`, which returned `[]` for any non-list.

Fixed at the transport layer rather than the call sites: each of the three
feedback channels (inline review threads, PR conversation comments, review
bodies) must now *deliver*. A non-zero exit, an exit-0-with-no-output, or an
unexpected shape is an error, never an absence. On error the script exits
non-zero and emits `status: "error"` with `summary` and `feedback` explicitly
null, so a caller reading only stdout cannot mistake a failed lookup for a clean
PR.

Because a future silent-empty path would look exactly like a clean PR again, a
count probe backstops it: when a channel comes back empty, the script asks
GitHub how many records that channel holds and fails with the channel named and
both numbers shown if the server disagrees. It runs only when something is
already empty, so a genuinely quiet PR costs nothing extra and still reports
`status: "ok"`.

Also converged the two skill lineages into one copy at 2.4.0:
- Script paths corrected from `.claude/skills/...` to `.agents/skills/...`
  (11 references). `.claude/skills` is a symlink in some repos but is absent on
  a Windows checkout with `core.symlinks=false`, so `.agents/` is canonical.
- Release steps are repo-neutral - the repo is resolved from the checkout, and
  a repository's own release skill takes precedence when it ships one.
- `full` / `full-release` are documented and honored as synonyms for `--merge` /
  `--merge --release`. `full` previously matched no rule in the mode-hint
  precedence and silently fell through to non-merging default mode.

Validated against six meshery/meshery PRs holding 20 review threads
(#21146=10, #21145=3, #21168=2, #21144=2, #21140=2, #21147=1): 20/20 found,
per-PR counts exact. Both silent-empty paths now exit non-zero, and eight
genuinely quiet PRs still report `status: "ok"` with no false alarm.


Also removes committed __pycache__ bytecode from this repo's copy of the
skill. It is compiled from the very scripts replaced here, so it is stale on
arrival, and it left the skill directory differing between repos:
  .agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc
  .agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc

Signed-off-by: Arjun Mehta <arjun.mehta@tata-consulting.co.uk>
---
 .agents/skills/iterate-pr/SKILL.md            | 167 +++++-
 .../fetch_pr_checks.cpython-314.pyc           | Bin 10826 -> 0 bytes
 .../fetch_pr_feedback.cpython-314.pyc         | Bin 20211 -> 0 bytes
 .../iterate-pr/scripts/fetch_pr_checks.py     |  66 ++-
 .../iterate-pr/scripts/fetch_pr_feedback.py   | 492 ++++++++++++++----
 5 files changed, 591 insertions(+), 134 deletions(-)
 delete mode 100644 .agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc
 delete mode 100644 .agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc

diff --git a/.agents/skills/iterate-pr/SKILL.md b/.agents/skills/iterate-pr/SKILL.md
index 1c7151f11..55183aafb 100644
--- a/.agents/skills/iterate-pr/SKILL.md
+++ b/.agents/skills/iterate-pr/SKILL.md
@@ -4,11 +4,16 @@ description: Iterate on a PR until CI passes. Optionally merge or merge and publ
 argument-hint: "[--merge] [--release]"
 metadata:
   author: leecalcote
-  version: "2.3.0"
+  version: "2.4.0"
 ---
 
 # Iterate on PR Until CI Passes
 
+> **2.4.0** - `fetch_pr_feedback.py` no longer reports an empty result as a successful
+> fetch. Every path where a feedback channel could come back empty because the request
+> did not actually deliver now fails loudly, and a server-side count probe backstops any
+> path not yet known. See [Fetch Integrity](#fetch-integrity).
+
 Continuously iterate on the current branch until all CI checks pass and review feedback is addressed.
 
 **Requires**: GitHub CLI (`gh`) authenticated.
@@ -19,6 +24,11 @@ Continuously iterate on the current branch until all CI checks pass and review f
 
 ### Running the Bundled Scripts
 
+Skills live in `.agents/skills/` - that is the canonical path, and the only one used in
+this document. Some repos also expose `.claude/skills` as a symlink to it, but that
+symlink is not guaranteed: it does not survive a Windows checkout with
+`core.symlinks=false`, and not every repo carries it. Always invoke via `.agents/`.
+
 Every script below accepts either runner - they only use the standard library, so no
 dependency installation is needed either way:
 
@@ -39,23 +49,66 @@ fi
 The rest of this document shows invocations in the shorter `python3 <script>` form for
 readability - substitute `uv run` per the rule above whenever `uv` is available.
 
+### Reading Script Output - Mandatory Gate
+
+`fetch_pr_feedback.py` and `fetch_pr_checks.py` both emit a single JSON object with a
+top-level `status` field, and both exit non-zero on failure.
+
+| `status` | Meaning | What you must do |
+|---|---|---|
+| `"ok"` | The fetch completed. `summary` and `feedback`/`checks` are trustworthy. | Proceed. |
+| `"error"` | The fetch did **not** complete. `summary` and `feedback`/`checks` are `null`. | **Stop.** Surface `error` to the user. Never merge. |
+
+**Check `status` before reading any other field.** A failed lookup is not a clean PR.
+Do not pipe these scripts through anything that discards the exit status, and never infer
+"no feedback" or "checks passed" from an absent count - on failure the counts are `null`,
+not `0`, precisely so that the two cases cannot be confused.
+
+### Fetch Integrity
+
+The failure this skill guards against hardest is the *silent* one: reporting a clean PR
+because the feedback never arrived, rather than because there was none. A run that merges
+on that basis merges unreviewed code, and nothing in the output says so.
+
+`fetch_pr_feedback.py` reads three independent channels - inline review threads (GraphQL),
+PR conversation comments (REST), and review bodies (REST). Each is treated as a channel
+that must *deliver*, not merely return:
+
+- `gh` exiting non-zero is an error, never an empty channel.
+- `gh` exiting 0 while writing nothing is an error too. An undelivered response and an
+  empty one are indistinguishable downstream, so they are not allowed to look alike here.
+- A payload of unexpected shape is an error, not an absence.
+- **Count probe backstop:** if any channel does come back empty, the script asks GitHub how
+  many records that channel actually holds. If the server says there are records and the
+  fetch produced none, the script fails with the channel named and both numbers shown.
+
+The probe costs one small extra query and only runs when a channel is already empty, so a
+genuinely quiet PR reports `status: "ok"` with zero counts and no extra cost on the common
+path. A PR with real feedback can no longer report zero.
+
 ## Invocation and Modes
 
 Invoke as:
 
 - `/iterate-pr`
-- `/iterate-pr --merge`
+- `/iterate-pr --merge` (alias: `full`)
 - `/iterate-pr --release`
-- `/iterate-pr --merge --release`
+- `/iterate-pr --merge --release` (alias: `full-release`)
 
 In Claude Desktop, arguments are **hints**, not strict CLI parsing. Treat whatever follows `/iterate-pr` as a mode hint string.
 
+`full` and `full-release` are the positional spellings this skill used before 2.3.0 and are
+still what several callers' standing instructions say. They are exact synonyms for `--merge`
+and `--merge --release`. Both spellings are supported and must stay supported: a caller who
+types `full` is asking for an autonomous merge run, and silently giving them default mode
+means the PR they expected to be merged just sits there.
+
 ### Argument Hint Interpretation (Claude Desktop)
 
 Use this deterministic precedence:
 
-1. If hints include `--release` or terms like `release`, `publish`, `ship` → run **release mode**.
-2. Else if hints include `--merge` or terms like `autonomous`, `merge` → run **merge mode**.
+1. If hints include `--release`, `full-release`, or terms like `release`, `publish`, `ship` → run **release mode**.
+2. Else if hints include `--merge`, `full`, or terms like `autonomous`, `merge` → run **merge mode**.
 3. Else run **default mode**.
 
 Do not fail because hints are missing or unrecognized; default safely.
@@ -63,8 +116,8 @@ Do not fail because hints are missing or unrecognized; default safely.
 | Mode | Behavior |
 |---|---|
 | Default (`/iterate-pr`) | Iterates on CI + high/medium feedback, asks user about low-priority items, then exits without merging. |
-| `--merge` | Fully autonomous: handles every non-resolved feedback item, replies to every item, re-requests review (Gemini or Copilot) after each push, iterates until no new feedback and CI is green, then administratively merges the PR without waiting for a required-approval status. |
-| `--release` | Does everything in `--merge`, then cuts/publishes a release for the repository. |
+| `--merge` / `full` | Fully autonomous: handles every new feedback item and replies to each one once, re-requests review (Gemini or Copilot) after each push, iterates until no new feedback and CI is green, then administratively merges the PR without waiting for a required-approval status. |
+| `--release` / `full-release` | Does everything in `--merge`, then cuts/publishes a release for the repository. |
 
 ## Bundled Scripts
 
@@ -79,6 +132,7 @@ python3 .agents/skills/iterate-pr/scripts/fetch_pr_checks.py [--pr NUMBER]
 Returns JSON:
 ```json
 {
+  "status": "ok",
   "pr": {"number": 123, "branch": "feat/foo"},
   "summary": {"total": 5, "passed": 3, "failed": 2, "pending": 0},
   "checks": [
@@ -96,6 +150,11 @@ Fetches and categorizes PR review feedback using the [LOGAF scale](https://devel
 python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py [--pr NUMBER]
 ```
 
+Sources covered, all paginated: review bodies (**every** review state, not only
+`CHANGES_REQUESTED`), inline review threads, and PR conversation comments. Each is a
+channel that must deliver - see [Fetch Integrity](#fetch-integrity) - so a zero here means
+the PR really has nothing, never that a request quietly returned nothing.
+
 Returns JSON with feedback categorized as:
 - `high` - Must address before merge (`h:`, blocker, changes requested)
 - `medium` - Should address (`m:`, standard feedback)
@@ -103,10 +162,42 @@ Returns JSON with feedback categorized as:
 - `bot` - Informational automated comments (Codecov, Dependabot, etc.)
 - `resolved` - Already resolved threads
 
-Review bot feedback (from Sentry, Warden, Cursor, Bugbot, CodeQL, etc.) appears in `high`/`medium`/`low` with `review_bot: true` — it is NOT placed in the `bot` bucket.
+Review bot feedback (CodeRabbit, Gemini Code Assist, Copilot, Sentry, Warden, Cursor,
+Bugbot, CodeQL, etc.) appears in `high`/`medium`/`low` with `review_bot: true` — it is NOT
+placed in the `bot` bucket. `REVIEW_BOT_PATTERNS` in `scripts/fetch_pr_feedback.py` owns
+the full roster; do not maintain a second copy of it here. Logins are matched with any
+trailing `[bot]` stripped, because REST reports `coderabbitai[bot]` where GraphQL reports
+`coderabbitai` for the same account; without that normalization the generic `[bot]` suffix
+rule files the fleet's main reviewer under `bot` and it gets skipped silently.
 
 Each feedback item may also include:
 - `thread_id` - GraphQL node ID for inline review comments (used for replies via `reply_to_thread.py`)
+- `replied` - the newest comment in that thread is yours, so you have already answered it
+
+Top-level fields:
+- `status` - see the mandatory gate above
+- `viewer` - the login `gh` is authenticated as
+- `summary.needs_attention` - open `high` + `medium` items, **excluding** those flagged `replied`
+- `summary.already_replied` - how many priority items were excluded on that basis
+
+**Self-authored feedback is never reported.** Comments and reviews written by the PR author
+or by `viewer` are dropped, and a thread whose newest comment is yours is flagged `replied`
+and leaves `needs_attention`. Without both rules a `--merge` run answers an item, sees its
+own answer as new feedback, and never converges.
+
+`replied` is decided per source, by the strongest evidence each one offers:
+
+| Source | `replied` when |
+|---|---|
+| Inline review thread | the newest comment in that thread is yours - exact |
+| Review body | never - a review body has no thread and no resolve button, so track in-session which you have answered |
+| PR conversation comment | never - GitHub gives these no resolution state, so track in-session which you have answered |
+
+Only the inline-thread signal is exact evidence, so it is the only one used. Anything
+weaker - "the review predates something else we said" - cannot tell answering a review
+apart from merely typing after it, and would silently dismiss a review that arrives
+mid-round. Re-reporting a review you already answered is visible to you; dropping one you
+never read is not.
 
 ### `scripts/reply_to_thread.py`
 
@@ -137,6 +228,9 @@ Stop if no PR exists for the current branch.
 
 Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py` to get categorized feedback already posted on the PR.
 
+Check `status` first. If it is not `"ok"`, stop and report the `error` — do not continue as
+though the PR had no feedback.
+
 ### 3. Handle Feedback by Priority and Mode
 
 Determine mode from invocation (`/iterate-pr`, `/iterate-pr --merge`, `/iterate-pr --release`).
@@ -161,11 +255,18 @@ Which would you like to address? (e.g., "1,3" or "all" or "none")
 
 **Skip silently:**
 - `resolved` threads
+- items flagged `replied` (you already answered them; act only when a reviewer follows up)
 - `bot` comments (informational only — Codecov, Dependabot, etc.)
 
 #### Merge modes (`/iterate-pr --merge`, `/iterate-pr --merge --release`)
 
-Operate autonomously. Process every non-resolved feedback item returned by `fetch_pr_feedback.py` (`high`, `medium`, `low`, and `bot`).
+Operate autonomously. Process every **new** feedback item returned by `fetch_pr_feedback.py` (`high`, `medium`, `low`, and `bot`).
+
+An item is **new** when it is not `resolved`, not flagged `replied`, and not one you already
+answered in an earlier round of this same session. Only inline review threads carry `replied`;
+review bodies and PR conversation comments have no resolution state, so the fetcher re-returns
+them verbatim on every poll and cannot make that last distinction for you. Keep your own
+in-session record of which ones you have replied to and do not answer them twice.
 
 For each item:
 - Decide whether the feedback is justified
@@ -189,12 +290,12 @@ After processing feedback, reply to PR comments/threads to acknowledge the actio
 
 **Scope by mode:**
 - Default mode: reply to `high`/`medium`; reply to `low` only when fixed or declined by the user
-- Merge modes: reply to every non-resolved feedback item, including informational bot feedback
+- Merge modes: reply to every new feedback item, including informational bot feedback - one reply per item per session, not one per poll
 
 **How to reply:**
 - If `thread_id` exists (inline review thread), use `python3 .agents/skills/iterate-pr/scripts/reply_to_thread.py`
 - If no `thread_id` exists, post a PR comment with `gh pr comment <PR_NUMBER> --body "..."`
-- In merge modes, a feedback round is incomplete until every item has a corresponding reply
+- In merge modes, a round is incomplete until every **new** item has a corresponding reply; an item you answered in an earlier round of this session already has one, so leave it alone rather than replying again
 
 Batch inline replies for a round into a single call:
 
@@ -213,8 +314,10 @@ python3 .agents/skills/iterate-pr/scripts/reply_to_thread.py \
 ### 4. Check CI Status
 
 Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_checks.py` to get structured failure data.
+Check `status` first; if it is not `"ok"`, stop and report the `error` rather than treating
+the PR as green.
 
-**Wait if pending:** If review bot checks (sentry, warden, cursor, bugbot, seer, codeql) are still running, wait before proceeding—they post actionable feedback that must be evaluated. Informational bots (codecov) are not worth waiting for.
+**Wait if pending:** If review bot checks (sentry, warden, cursor, bugbot, seer, codeql, coderabbit, gemini) are still running, wait before proceeding—they post actionable feedback that must be evaluated. Informational bots (codecov) are not worth waiting for.
 
 ### 5. Fix CI Failures
 
@@ -255,7 +358,7 @@ Poll CI status and review feedback in a loop instead of blocking:
    a. Run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py` for new review feedback
    b. Address feedback based on mode:
       - Default mode: new `high`/`medium`
-      - Merge modes: every new non-resolved item (`high`/`medium`/`low`/`bot`) and reply to each item
+      - Merge modes: every new item (`high`/`medium`/`low`/`bot`) and reply to each item - "new" as defined in step 3, so a review body or PR comment you already answered this session is skipped, not re-answered
    c. If changes were needed, commit and push (this restarts CI)
    d. In merge modes, after each push, explicitly re-request review:
       - Prefer Gemini review command (`/gemini review`) when available
@@ -263,7 +366,7 @@ Poll CI status and review feedback in a loop instead of blocking:
    e. Sleep 30 seconds (don't increase on subsequent iterations), then repeat from sub-step 1
 5. After all checks pass, do a final feedback check: `sleep 10`, then run `python3 .agents/skills/iterate-pr/scripts/fetch_pr_feedback.py`.
    - Default mode: address any new `high`/`medium` feedback; if changes are needed, return to step 6
-   - Merge modes: address any new non-resolved item; if changes are needed, return to step 6 and re-request review
+   - Merge modes: address any new item; if changes are needed, return to step 6 and re-request review
 
 ### 8. Repeat
 
@@ -271,12 +374,15 @@ If step 7 required code changes (from new feedback after CI passed), return to s
 
 In merge modes, continue looping until both conditions are true:
 - CI checks are green
-- No new non-resolved feedback is returned after the latest review request
+- No new feedback remains after the latest review request - that is, every item the fetcher
+  returned is `resolved`, flagged `replied`, or one you already answered this session. Do not
+  wait for the fetcher to return an empty list; it never will while an unresolved review body
+  or PR conversation comment exists.
 
 ### 9. Finish by Mode
 
 - Default mode: stop after success conditions are met (do not merge automatically)
-- `merge`: once CI is green and no new feedback remains, merge administratively - do not wait for a required-approval status to clear:
+- `--merge`: once CI is green and no new feedback remains, merge administratively - do not wait for a required-approval status to clear:
 
 ```bash
 gh pr merge <PR_NUMBER> --admin --delete-branch
@@ -290,31 +396,47 @@ authenticated account lacks admin/maintainer rights on the repo, or a check can'
 bypassed), stop and surface the `gh` error to the user - do not retry under a different
 identity and do not fall back silently.
 
-- `--release`: complete `--merge` mode merge, then cut a release:
+- `--release`: complete `--merge` mode merge, then cut a release.
+
+  **First check whether this repository ships its own release skill** (look for
+  `cut-release` or similar under `.agents/skills/`). If it does, use it instead of the
+  generic steps below - it knows this repo's drafter, tag and post-publish workflow
+  conventions, and the generic path does not.
+
+  Otherwise, resolve the repo from the checkout rather than hardcoding it:
+
+  ```bash
+  REPO=$(gh repo view --json nameWithOwner --jq .nameWithOwner)
+  ```
+
   1. Find the draft release tag:
      ```bash
-     gh release list --repo layer5io/meshery-cloud --json tagName,isDraft --jq '.[] | select(.isDraft) | .tagName'
+     gh release list --repo "$REPO" --json tagName,isDraft --jq '.[] | select(.isDraft) | .tagName'
      ```
   2. Review draft notes:
      ```bash
-     gh release view vX.Y.Z --repo layer5io/meshery-cloud
+     gh release view vX.Y.Z --repo "$REPO"
      ```
   3. Publish the release:
      ```bash
-     gh release edit vX.Y.Z --repo layer5io/meshery-cloud --draft=false --latest
+     gh release edit vX.Y.Z --repo "$REPO" --draft=false --latest
      ```
 
+  Publishing a GitHub release does not prove the artifact reached its registry. Verify at
+  the real surface - the package registry, the version endpoint - not the release page.
+
 ## Exit Conditions
 
 **Success (default):** All checks pass, post-CI feedback re-check is clean (no new unaddressed high/medium feedback including review bot findings), user has decided on low-priority items.
 
-**Success (`merge`):** All checks pass, no new non-resolved feedback remains after the latest review request, every feedback item has a reply, and the PR is administratively merged (no wait on a required-approval status).
+**Success (`--merge`):** All checks pass, no new feedback remains after the latest review request (step 8's definition - not an empty fetcher result), every new feedback item has a reply (one per item per session, not one per poll), and the PR is administratively merged (no wait on a required-approval status).
 
 **Success (`--release`):** `--merge` success criteria are met and the draft GitHub release has been published.
 
 **Ask for help:** Same failure after 2 attempts, feedback needs clarification, infrastructure issues, or `gh pr merge --admin` fails (insufficient permissions or an unbypassable check) - surface the error rather than retrying under a different identity or falling back silently.
 
-**Stop:** No PR exists, branch needs rebase.
+**Stop:** No PR exists, branch needs rebase, or either fetch script returned `status: "error"`.
+A `status: "error"` is never a success condition and never a reason to merge.
 
 ## Fallback
 
@@ -322,3 +444,4 @@ If scripts fail, use `gh` CLI directly:
 - `gh pr checks --json name,state,bucket,link`
 - `gh run view <run-id> --log-failed`
 - `gh api repos/{owner}/{repo}/pulls/{number}/comments`
+- `gh api repos/{owner}/{repo}/pulls/{number}/reviews`
diff --git a/.agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc b/.agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_checks.cpython-314.pyc
deleted file mode 100644
index dab126de76baaf615a3e42db3aaec93d9acd350c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10826
zcmcgSYj7LKd3(SCIN$&RB*CXB@%Ru$P<%+XWJweynUY9}kw`H|8BT0U2nZZWSRer3
z9rQq)25~zb+Hoo<@l<fqRP-cM%V}q#w4RAF(@d>6o#rQKNG5V-#%|M>|51@$#cqG}
z`}S}kNK=v9%w#dx+ui$a_uIYi{oVEomxDk#`h_n(^FK|5{2Dt(G3yQH-p`?tCL&SE
zSt2qc%yE-yYR0x{#H^a>l~q}KwWt<)wW?NnwW&6^nn$?fcGccYM7EBImO2vks1C78
zv_j8@y(pvd(C46UFZP|H1A07#b&1uY6MC-Vy$Z1cdTx5pEqdyR>N!&>R_^@*Az|20
z6FK8)A-jtEfK^Rx^zZYg{>?Egsi9e6TojIs2%%XibWRb1v9KUrROMhu6=W$Yoe#!T
zVLBLzCS^%bVv$5bQk7nZ;|V1=BlSB3D2YqzY&<4R<79z^9MEU#O<WS5?&(R$Fn?g|
ziP6JD;u(iyWLltO5k-i_RY6Hep~!SZ3U>=hMN$NHRzh^9<1%fAlCmtp`crZ+7Mg`s
zPbJkvQtcN$H*soAP~(E4hT}<9xDZiip)DsvDxewG_acOYYOvSgV>CV(gT;bsBpy@7
zpl=?GT?#R9B>2a|!XMr+b5DRqn)u0C)80RU^MkP_@_A;K5gE}Wnnkt`PS0ogzyx3#
z8<c01lsy_z)Td$XGn!SFVEI_8B^(LSp>6>dIwL$MP?%zSEFP0yCxC?&b~zVR6-1&{
z+tnM229sf_PdOKfMwPyZD#<}rg7fQBLUJUbDt(_mV9gl_6!#_t0x}OXHNaol1XY^c
zCl!qME>@X_6};q{AE(`WaGTHrzy=l@{9&_}dv5?XX|jn-(qXK|akJ}63y^*<<0su^
z<8VOuGw)&b!35)H#*6JTFfxv7tt$q3ZYz$5Tkzl~IRk8*GN#efuPtQb`F9mxDv&wb
zMuhU6IM>dAJu3+h<5~&Rq}#YFT14x3rO{ixo+ifJPGHs3rtzxPdq&Gi9$_cFMsFhs
zk=s)|(Ppw4a7>sEnGjRG6=BMDU2Dv<dIfwfh_C)^8;Owp=FKF+`0S}i#bitf3Ny39
zk(0pA@wqwVW&G=ODI|ij0?a{q2e<|psaG@2%%1j{wTe(MfvgkI$2C?38K7AxCy%8n
zhh!NzQclKVk=P8bpfN(q)Gq)Pv(u5N<a25cB{`Ll;~_~=G&4YIR-HFB3-CrHp|Q^>
z@t9_b#)Dx+t2z>lMy2q$4o_#-ED1RhQvog>(I1v%Su-n_6wQqoAC*G!utY(9X4wiS
zg8Zf=qpHS83eYa;5Cj?N1jduGz|5@N3LVN0e+7*+Sz(<P?{ej)t6RRgrQoWZAI_Zq
z#%N(vbD^@PP*wY(-BRV4x2`xz&!ayaeSLJP`_N+dp{4G@x4Q>lQZJ`oOl3Q+^}N!P
zcX#Hv6K|?e{dSqJS>ihv`OXiC38v;;IZw+%+iRV#c3$80z202Q&Kp%X27i3~N5^mU
z=PC~VeBz&;y7kl@Zv0p7>i=Hm-AjD)BH#QWVJu$FUA<z4>nF+%K=t`SX0U_YVw<sU
zr|piKBX#Cm`}+^?H~(yZEwtaNVz92o`u7oKGEfuI>>#yc$+;;>{=@+<0VEbmDH%C6
zRr4unM(-hS`WV>`7hQtUv!^16R$X|*kV6)x{w{$k+rNUB+|FUzm60LW$RT{MR1Qr;
zBTafi&YWUEl8};Q0L9#doL}T}04tTVrb(m&TKpwm-BseYN!+V`moYdQ#JMT8_n4%j
z+KI%b<K03$fr<hM^pY@jNzji)0P;trv`!)USk07>HTHZ&y6}m$rw3^~)v7<zos^^9
zvr;fDO4DP(IjMUps7S>&aGW&~QzTgh3Rh)HsXmk34#-i`RuJcoB02Ljl8R~-v6E5a
z(xdHwMw<K!KaxKBp3PI>oR|3*_{`wTN_OA3{^&N>vCLOy+P^-KW9wE=**G&6o`sY8
ztm=-^h>qM=c#@LECtj-4*3!lq`C(M?2s~e+icL(_T>@3MYXvX49Y<+*6<+|R1@#)G
ziob+&p;X~mM-@P552A_<X`*-%&8X?{G-w$|>RVS(%YgC+^}nY`TM3ijG+xq7tKj2^
z<+`$7ug$<5O+eLc@K2ck@AHhi)-3>C(QMGNhYVjQB*FUG&yLFpI5~jdXkONsH(^=T
zjed(U3MSIu6Qb|v#6dz%n>XS~(c%XqxVv!`@85-+Xa#8IGeg@p#LK+*WiZ|9DMeV$
znm_Aoqm0Ojc9H8V?Yo(r_yHkyvW57~)ROQRy8tZ=w1Qf=mn2P_;eD3$FrV6w(gehZ
zVNs*p2%>laX@V*kRj3-A>QN-<fr%GJg<90dr$Gv!9U|jW8spFyyT-;qdT7?EWayj(
z`Y{@bozsZMU5Lx)rlau-pbabV36zkURkyu;cFh_DOFb5rx8prDNaPx<(4>&-paQ*|
zh(<vEM5UN!AG#QlsMzyaSEZ0FAn+ap##JRy(Lq^N6l4=nwor6^>p%geFDwHg5X$5{
zuo%jxmU8*@@{z3lTVuDmwiQ#YrOMF7PLHmIKeVw_1v`kR_VQO=_{x&Ib<y3r<Zgf4
z-Cn4!nI9=sR?k}t-o~q=S4Nk-+ZMgs@?PJPw{OwgcY}S$yL<j<p}OvB|CRo$1K%9@
zrKi5&t-t!YE1%1%d2jpt(6YNKv-|6*?C1aNs|8Q(Ro4|4OqCs4X!-8(Yh$mB<(s+-
z-lnXyF!<fsYq3{i`7OP0{|)nvp}%w7{QMggtB|*wy5Brp@NQW!t=KKiRsTgSmDP87
zQuEkKEnq(H0=vMAYQ3u9u6)ssioNO+1tsV8y+;SgtriCBw!wC|yyYD1gUincTtiOt
zKk^LJzrQxO>h6;M>QRTwy;wa=Hje|4(hL=P4m@*&xl8NpkrjH)weQsjJ}sZo>Z0=b
z4f^z?p=UsQqetKe+ZJtV(bmfu(j&o?$z^6$1{>Pi(D$nn)6aOw6Q-mIIc^xNfM;7b
z@+8F43Zfld;G%p2`QtZ@nNDoc`8jDyfFqX##~oV{;&Y^WkZWZrgzhG~yTFzPhoRxC
zQ1u@)JW<L_$Q6p3;(B`Y15ep{dZLjzU@Ftj9kLJ3BIQFL6cztSxEtBHTLCvTsdR_p
zu~0OrfSo~2go)Xp=2#umY(<CL$5PWkb3{ODz@xE{Bp-%(H8ZdrF#hAvrd+Bq@>(0%
zjXbIEBY^13BLGU@@Dw!C<X>IY1<o~pzQ9#wh6`L}W><mp<f;w;Mb}vG5le+FJ^Z1Q
zIBPT0e-U2d+ur8efSTv+|6I2@&mX>WKGX7A&8syF&*fWo-Lx;Z3|=0bAG~sYkw2Vc
z4}bhNe^^0nc%yExhP~yqLcNBnQGfuwF!$OiE)RCMfoe>BAbUY7Q9G53#%BWPno!!-
z>~q130hCPOa)8-N4U>nG`B_*~X`u_>C;d$OU91*DD|oq~U*3F_4(f!CrkGKRh+FPW
zQbWW~HdJ{f<1zunDq6u*F^i^g*zo$|FRAVX3kHFu%s@36i~>si2q70>J$Ysl*QaG8
z1EhsKd8`ZqnQ~p(Rm5Q}bDaQr?YC@X0{E>47N81;imK33dKwf;6R`M3JA1Ol2Zjk#
zGQ!(ng|%itf?HMIXNjLXYw0e-*boB=`(()xpR6{v<1d}glV2+jK|Ej%$CEz4gCPmt
zZvhcvEs78@d7hp2JIah0AX&c^gajyHRQd^L!s>S#yA6Y61QV0r=$u5h3^%87W)LK>
zJW_hY5P941r2M=AUlK@G5J<L^I`ohzoG>lN=LFyg0XYJKV<+Qr2;fmS1)P73$Q8qO
zb3yr>B(I6>DS`sAwRkcXMsoy2k3NUI1I}1uo*PS99lgE1LT9R0n2ST?51jG1+^P6r
z`Y0M5zS@+7jy>H!shmmix~S1R&f>bXr`a)<C`|=J=QO)ym>DT=P(k;n6C|MTP;Zz1
zxMm$596333G-XW$W06pQ$~q0=GuofxVu?9nNEBOAj!Qu~remX3kH*8vs5BN=hjAk`
zHlXn%bBVaD7CRG{VruZB-m#y)l+XhRn!_KACW~$Egmg&<s2EfsR56uQi+Akkw&}M#
zBe5`O1{y-7BdMwb2M+XhA-+$DLleDS&`oiHK%ln^DxX8%2L~yGngZuq0*8<W^E8tT
zhMXb=<<P9=7&$g}N*p>eI58yeML07^GpHglxgWYdmwW=JIEl9`x{&h}4>phpst_KG
zDVhhuJX0V5!^V*2Hee#~Y9Sh<F%fwH=WtC&WJT8r5a_|M3>b5o8Eiz&RgCKvWoeZx
z%>^SE>Y*A0pcMrjgbv;4qn2OM^s7Tz454BJFi@OHjsiTDw6)X@TyYRr&E>Hd#<IKe
zP9Z(?8*5#?HOG2a9wGIcu3o%yF(>TE*X_g+E2(QppIWYN%0BT<b=wQJd1je+UEcTN
zzFf`LzY%|U=Jhj6{Qleg{(^JUlCyQu*}Aav9p~1&7UFHc&k^UQ_ubW(FTHRnTa!&?
zznp8>o_BZWxb78>)U+=Q-tl&%N0*)M43jyqu=7rJd)~P<J+$m_y%fr9{rWT6o;!_?
z-U!}l+>>|gO&@vR+pu8HdE3*YcdevjcfMip)xZLCbK)o5wU%tltAQL_n`;<+&(=`j
zYL>XBMXo7(;rmK%`+@wngSn1FxkFFnHv4aLPrlE)FYkL{U*=4nZ_BZ5AOFTq8V@sy
z6VB+Z&D>ER`&O3~>NPr&g_~4I3eZSDG$gI-M;iHxgym6qMvvY&AiQ9Na~@^@eg~dX
zz*2(c?h_Y=j-kp{ui#~&k@h}q`{AU3r{!J+ebJvKa*Q@%nW`%(36br!fX26+9T2T+
zqR1t+2Wu5eNh||lQqO+_7*IOQMvAhHtcePjsU2hXHBnYu+rwkXV4W0WvH)H31-Vok
zT9vwRLrHB|k>!?UukOB4@2nFLNIAiZjL-DwPeE|D%ptU?kvR!m#WA0)%%`I+9(C+C
z!}D6jX&q?jVj=>`5E<VnxRo)uP+M_LaLI{wBF0M*J6Q%8N(JYkfe}-_JYt&Jo$dI3
z+rsqswqO6FobzBYbm}b&owjUy&GnjV0qjcj-*VjJHy-=(fgc@!h8`<zU*y}3fM;3o
zbWH@b9hQE6&@$*Hw>TbaZ_Q!We5<<(>q89GKQm(;0=QD~K#OwA-?D@RUFq^SR&Kx*
zAAtM?sN+3Au~-toUE^q9t}CKx)ttiQj}ZZCMtBT-t}8~g2Yef}erW*;L^fYn43&?u
zB!iM?KnXz3qm+f1#68inQ5FGq03KCe$<#DvY$j#dhYj)vE#z$J8Q6zOw3Ww4FeW8(
zYev{f458CfX0BSmT(ye!gbhuq;rnogoapd#;}A_+Uqpw<8|Iwod;pB=0pk^`&z9zJ
zKL8ezpCy>e2f$RW!t}8TyWcK4%XceQ(X{DvRHoRb;myGtL8hX`Uy2ODzU^XV`IGyZ
z(t8AXg0cW09OV#k*CaaE`b@4z8L=8tww&MQDJ5q`yMceg;ddDGg?CddT1wA4L~r@L
z#+wK8mM=X6?*TAxD?L*(G6Aca4jA^Yn+3*e>9}=#tMSz8)o(Xe0Y~6t-8>fSM4R6%
z)<YC?qqknadeUNppA{P)0Jmusu8$R)#Lbh&CcqdsRu#8QqB~8C*jxv9R!^-2Bb33k
zJOHM(45sY?Fzsb9TQ`R3vxpsjYo9sc{OtVdcb+wg+l<_wfi<`VcJOaIQ=J>+;%QpD
zXwQ{$@0iaHOL|TitmhPq`Sg?z;)}&pMQ2!=4nkfGvgz@42@8lq`g|tH?tvw&v9nS%
zp;;uf>{DCD;(Fp83~AkkSd)6!toq~{UzX7rlQGh#*^;qyvG@g=w8P+r{3wp1eF-)y
z%0w9`n8=UeD2uzHb`JDtLA?zRF!!E<#sJd_oRcP}$*=%2g_$sIoasU7ZSV>j+Qldj
znA?8lB1v0-N?VIm3UQv@X2_44DY6t5_yj;c22Vj2#?-q*J`PRIWvJu;hG~kil(Zh-
zv=7WkG3jDLKB(29Vca_qjfa9!<zR2=Mh@nnA->;!0O;pDW3QaZJbV4X&B1>d`pM9n
z9lvPJ4~#BuAH7=n&C2hb_*g-s>5m(>Gp{<fGn!*HMx^nehD$ay)!4`lni+CQ^5fWI
zF_@(BWw|8HrX(TND__zqDtzP+)xdcI-zvQ3ltDM@r+gF|r85To@NA{HCOR)NWl^&#
zu;GpKgm^kS#rXM1@jSmw@xjH$Xwc<#ll)a2VnXE>hWs@clb?s`-{F4`g(*FvhEt1M
zcY`s#_othFVO`uecCF>xE%~jxKfZ@&^SoPN{@fwpHxe`y_XpXF{1sSP--`SVXl}fV
z|A0I4Wvnt#X*LY9gQxU|!SGwK<U=w1PXJO%=iE54*zwpx<;~+i-TsS)#eVVH&TsF`
zcRcoS5q<dD1o8y`Ut%$pG2ceS!mJ^dF%Uf*T@VfoQWY4^j8fA19q0W4?gqlPI@L6O
zskEEiNMNx)ux2|nSAk#FfbR?5y01p#;2RzK*@IRwD9?Z!9#hBhD+pP02E*Y1+@)jG
zVbUBF5(gEUXQe3>8I_w1)DI#poSaK2G9sg~(#42MvmI2F(C{i`YS0}<BbxfZ)UBt^
zJY;#3bG`~>O<Y|6e8FbqbldTP$FZWh7Ekdr3UKQ6q>5IIuIPbWjE7;uo_=Z}g*7L9
zLll}tXC2IV2uXt-uUYkUlAH!u1+zoC&t9w_*Tou(vP}K~-2H0=L(TNtG+B1lEV<g>
zcD3hrK7HFYnI0~%jwQBkk*&*Gzdw=ddkQkjx7nu)eB~0~w8%H*`7P<AA6kjKG24D^
z+bi4h6|L!G@9|aeHN;Ed%g?;{Om<tY?MSZSXue|THaEP?@t3(5xlH9t{QI7|EO*D#
zk{&6zyqPn1Tx}3?wvvkatUd2)O%FpPpuQ0z0`PH0`oym*>*g)*JF7B7S4XalWTzJ*
zdGC&b)0>g5My^B_xa(Vg=zHCF<JiqF=DUvNYmXPoK&K!}RB+a2E!XU?*cZC4Pvz@(
zVw~GCZ(s2cXHDh{cla#}9k=<;g1hl;ckA+&p6k>3ExR*3ps=}P;h8&4JC~Y<b4|lH
zzIgNeo!!IpqsyC`mr=;)J!1ur_nyVvR55?@J|wQ1mh0LUPTpv`(|#~tcPPWYS6#Q<
zH~glW?>m_p$<8f$y9-^9-FWU!*HP%sLI&%7u6~JYUgVk=?C)@0cXyMj`jr7<cj4Y5
z1!rYu&(-}`_Ggm|Q~7Gxg*P*eTRV33#FY~ZuIqB%`v`2s?SSuA>{SJ4^~)2v24B9W
z3m{((Em9$yZ#b2&J+;9=&CALn6%YBwiG1Be!AS>@!}5(^%GZ5qg|~VgD;30EnX77D
z+3c>c!V7987RO8Nm%Co<%J>%sZ#z2PVYkt!fCkYoq$r4fF`!{TK-<7qrP%_3a6A+U
zXpTT&I!V7V3drb^$=}8b8B0Ec70ppn-m-#u0`x4S(xUkfof{8gcLXa8F6nHB)QbzF
z(uNP<P<K#dbPDGN=4gcQp!_4af!>}n2^D1I80N0S&afYO3Dfp#;(nL#?-KjFr1D+j
z_!X)B$O<3J-EW02RqlJ>!-S6pFdKHi2@(V!r5Ff?{6;v!Fr6zWO@wvMr*4}Ye#vrw
NI(*km*haeg{{o9{!K(lO

diff --git a/.agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc b/.agents/skills/iterate-pr/scripts/__pycache__/fetch_pr_feedback.cpython-314.pyc
deleted file mode 100644
index c17400972421576acf44a5633e4d1fdc88952e8e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 20211
zcmd^nYj9iFnb^H}zaIp^_XB(r7GHYUk||LZ#fPXDNncX1Em7it1V|zR0pwml5)nD!
zI%xtq-iq3|6};<>>0R%Hnlv3|x^46$)A7bhn`t{8kf03sT2px^o@O$g=|HhmKQf*6
z`_9F^04dN+((U#~&k*N+=bp#?&N<)t&i8%iJKSS3>L>`cC(nQ7-|VBPUtvNF76G6?
z`L{BPTA~;#LS3R5`XoIpi^%E_mYtMG<m9P{D9BS8QIe-Bq9RXqL=8{*NzJe}q8-*n
zbahlG#dM9*5j{M+;c2+29IF&RnSa((i~@41^KV4x0APcGQSO)RSXZ@6UG<mL)$CGN
zyI<BRkC>Ug7U~=om36{zsE(q-6x6E{a4U@6`2I`!F(Nx%Pf=Q`7TO6@5eu{L|4O@7
zMps5L`Z6kDiIgw~fQ<yUF(!b`1hzB#84IMWm<rGl2U7wm8_6qW>;O9mT*j0FTt?t>
zrX1i30#`7V09O&XlBou`hQL)!Ex>gIu4bG}J=4I*m`3<D!LONVVOrtW20s@g>(Ve!
zLFqkMIv|VGFzt})Aa!dm)-j!jUZf~5P;E7Jv9_K%kQ?ecpvFe>ivn%pNctfbA=iP}
zrf$d=nVENbf?ns0C*qq6vHqCPImS3y-xa^_s&m%o^G<taE_dp5=Qz)tuSe&E5WV7L
zqd~}ox>I3xN-7mzbYAG_2(!?_)X2HB#|N2<q(XQxG9L==|2=EyPR=?>D}K%y3`Lw=
z*f-;!_4~Z-&M4>OoRN8g;%tZ|;7pWdeZh!xn)L){<~wyRn%8@RP|*|dhl1RQOUBFl
zf{VOnB*ge4Q8pN>zBI`_)%IM^e9!fHfFSnI0X%tOe)6J=S70hun=7->bA5r7S@3!N
zQAkZ*Sin*$AswsAl?(J-50G+!&{ZrHz(R6J%+N3!_`{%ppB$2(I00Cq+|(u6p>M&|
z!Mkeed3v5^XqbFCqv(Q(b18p=%bHg&_&6MVUd}~WUd575u-Mcc3OcKTfmrZFIQ&Kf
z|4iphz!UZQy12{!K!EG=M|>>IEKEulH^chF5w5G)yzz#qsobFXrlweAb1%V<LoT#L
zeM-q_%R`Ko8?*RGw2{;&kV}ycB7i{!KhnVn087-Q*l}ty$Dt@{3^CspfV071bkPTL
z<;7<mHHj^fFs2cq{Ij0AB-H_Gr(w`!ywb<AA$G*2<dtF8AB^yduW+Ftuk=P2!W<0Z
zBF8Iy*ZdI|%_5^G1J}Zu0pu049)EzX0Fd;)5r8G?zC!z2)6J(|eQJ3waW&~^P3hV;
z6|VaV^>>C}8IC{y?bECk%Ke|rGpi*Z_pozZOdIfXkqa=>7g+<mWnnZa)(8=xYl4R`
z&jejEO(eR68MP4MT-oV!^g|La`?KV^(l4a*h(b{k)DV;TI!5-hDrz#90rMoynDmOm
zdFrIy)F=`vkm^Ci4nmlopo`7VCF;;sAa5AVY6?n_eO0I-#)s+F95@G^tfuO)9CmzL
z7{mG57DPT*&<5axZ7|BPd=mRc0;6KoV>n0K!UQGKnSo+76LJH!Pa(dU#~%HGc!U)b
z3aK{)6GqWU!I+kaA0D%dQ2tp@O-NsDq@2{Gv_4dn*Ma>B%L@7;pO68bG7--S*}RNV
zgk{gk{Is7sEU%&bG_;ZbVrl+MA_VO=Khf^*Ge+8d@-O?YOUKLR<|kkYnr1v<V70!f
zP&5*b!U~M|u0>*{xVn5^XCy@SkGXkg|Cy6L&XJfU8oV3~T@5<n6<NG7IY2z^jA@-h
zogQbb0yZUN-_SrX6zn)PK04wQns*s^9T%Mrv!NN_l)M}^Ctf`|K8S39H!#s)#J}JZ
zQaYiHnUL4VtGI|4zDAzV5U+$q=MMw72>F973_Qgv10j!><IVW30UuT(t+<pd$~4G|
zxo9B5%YD~o*cN!h;_P!uh+1%;6nKgr(3zT>pF$?Yc0wLmtVZB;OH@{-Ru0hjtyQ;c
z|ExA+w8qaa55&)As_HUU$0N0(L>E_OO_auzR+q1<%M*Q@>Y7YR`R$Hd9qE$pWJ&kR
zGe78kyEkn;xNbd|vOb%(jwa!+cQmfLZ>mg;uh@Q2{&x9l(_hyno!x8NyDfLilU2u4
zrv9X+|0ARA=EWNq(?;jI(U~$fEDb%-TR$+{vI@EK9DUzxyBT{mmS{<t>yw)L&mNUg
z2HPWwMr=)$$(sFZ{cBGrtDa4ndft^oYro6NG4FSe$|-{-t*=|x*I{XB=m|WM-6xY(
zr&6ZV$>%4Mnh8?#9Q_5?1w->nb-#@IS-YdZiF!|_@2{7?XEgU$%ipV3BHZK{sFA<-
zY~4V){O9FLfVc2mWLJchp<KDs-r9v*gq-kO!d_$MNHiSqA-`>R5~jNwtBpeIoQ-_q
zQ%XbEKg4MH8{{GISICnBu4RH$6PfS)eh8AjYE;_0!qg;`5`w#c1Bi0H#8rSJRZ|7r
zKx$zgxbhfoBijPVj+EF+(R^t|hj(g0;!a_iTjJJU_*OOLmhFg{Qsfl#^rT)y$}Qnr
z@J`}o`%&mo^9t4%4#l3H2}J|A)FV!>4}_Qnf6xaUAROZSkr2D+oMl4`PEq#r`dQx$
zzUGy{Mtm%;+&O=cR|Gu^zL;y5rbv}8Eb3CQdjVHofzt06s*Vm^v@sni&`t`d$P(st
ze$F4{A|P@4c!k$L6JeXMo_x+1VX?PBW9{%@L4Tx3lN`>k#1o8AZVEdy<qv}R)&qHj
zt~dZd;4qeNRP?2c$Crlg>mAFpZ+g@E#tnTVuDmKHWg1Uv#xsVJo2PD^TE4m>OBou|
zhSqgM>#90s=w2Gk=&d(<ZuBhArt~#S0}u3;w-lu2P|9>7sX1|9Z;D61+w(e?IPks2
zq~4iSIP-ErPX3}Kx^)tab`w+u0Y(eDKrp&6?PI^tf!yW1?i>lhWZ*9Pg$V~qSY{xM
zU))uqS%ONE^r@yx9#Rk`db0Rft0k#C)=-uNN&0*Tl1r#n%SLIWYaj3gpjLWJ>|d?|
zJ}$`$*PckV;+g>o6!|#`dFn0Pk=?RMNir2{ZCe!*{WB8%!+J$(m-DhP8*@d2p6P%O
zH^w}zgBFG=j!5EydIJP{3~*te#^@P{Vh4l~Z;!Hp_IaPj%lKwTfRfuiQP8>Ac0rNj
za!=UAfN(=Wmx@;b{rXseS_w_F2eHjV7&Soz6nq3>-027{6AFfXEw`&71;cz3`aKS1
zmf**oAONqwur!cSTQ=0y8I9ql{)T?J56JD=?|pq!(*neuu&0c*#b`T6p+LY(XY;cw
z&Y1!lC%n{2zVhWXc}FSGqy|(*7FRA=mV_30#dIhX*p&ibg|A35HBAqIOpS4(KTDn~
z1425FCzK~a!ZQv@4-8CRranwRuQ)|{8<868K;zj@GZbj?n!I*ok+k<AST_<KLBFf1
z(?CbHM9V?T2<rCryR;!vGg2DaEORJQNYndK5oG{4LN@?5OVk841nVSB=kYDB1GwpN
znMmo^s3m0`bsBUJf)mw9JuUascj%EjGG4}_kmd8RGxK+V&^x<%I?N8j2XmyfB#@H!
z$eb_eyB21T@=iYoY!R97)O0A)c_a{;@dUV|ol=SKV(of}KKl(IoHX^XcO74?e~rDl
z`08T9nix)-o0I0|RM+v(Kf!7EW>YIYF@zQX4_E+f%%J<^;0sg7M<=Gn`X(j@nUV23
zw15#3*{pz%aSIZx8*&IOpzQY967@iD`tJTsQ~$j#l%#I%e{FwK(f=w&@%-zQz8_xX
zY2%NgVRit%xGSChQz%qGr^gAM9;XwasnhgvdZh{J^f;Zz1<I3v14P!-|G#v~o`f-A
zPhoTxqAhgEj=>wg7Kj0P+z#}36KfUFW8Zq$v10Ui>~j`Z8qy*=j_q1cjtq@%p+xo^
zwpBof`hrihxF*R=Z>7S%dtJv;raplR`;ZFzkP36JQ~Ex5k)L^y3UR+8Gv5ZlPNFiH
zp+K`_l&C#-fgXEDBZ$pJq`@7H$Teh>;N`I03-Yv`m@l?&_Pg))e+JEQE`rRbl!dlG
z#3(V7#mB0RJnjmQWZyZGDRc@tAq6xpkWO_&Hw#Tq46sZ$1u8y>uMo@Kpg=Q<eQNAl
zXI{9K7l;A!yb>-lx~;6Z6Bu156;`<A7HSCQCaf%|t=ze`7q(LnL=<Cc32zBt)Mb=g
znco0J<_+u>SoN0naRNywj@{|g6n+CIX<KkhVmY)5iYPK|H%zWe11vJ^kAX@H5_T6)
zcf~YaevXU!xUQJCYbLa?05(=GrUS#Q2PA7SDaO<t9b6#FhKp}3$Tp>I1&;#gyz=9w
z^Bdj{J%Dj?)49zB)>q-?LKZEoBS~HXcm%!%hCiUfMGh6g7C}rA)^Ib*Dx@=0Vn>Q>
zEpI_J4y7Hkvs8`ViLChkHui4wf3l|!j=VMa=Yv0te9qy(zf$g^-vTqUOV9-f9=rnS
zo>zgH!x!`tDT-Hl!eK~2F|uS(u@FQm)C_oyhzhTO5%qB>ySB8T-9XrdN}fcTy$of@
zQh6N!q9<fD#*EIg>{wPWe>GuGs1oxliz}DcDw3MR8I3)ov1YZ(O4TQn(xhG*dSsvs
zrFnHCW46Y%A2qiw4S#4UjVn;q@V+^a*4J<7>oW%X&Cwg9>o^Rls?qliqxX$v2?b~(
z#>P!!V=g-}@V=q`p_a0iWp$LnzBKv|#A;YHk?gwh{S6f2&}x82&mo$&JtQ%*4NM{5
zz$Y>ed=k!qz>};47Ybn=!$3QDsuz~y;%4ZuvI^J+8sr(J8|{NK<c7#h2&6%VLLe<N
zm3^{KU0CH-`pU>6R~6GXpuWznBxNPN7jz7Xk-1gkvJa~ZG!J#&4*tY~QQ+6A$TD`T
zi|Y9LU2Fh`UGj~)<eT#OVU1f;6bEysWQPcA3woxVM8-|R_MUl5a?DcPx5R?*bZf<N
z0y(<)7cB)?>D;=aSXsqZB=%l7n#Jpsh;_nBw^FR<CG`gB({N%U%!SM5`By+r<N)le
zQ6Ib5)<o<GJ<f5kGY04C+nr6wZ41+3w#Rug7{M&hEEqk+JeTupq#a-mk_DtK*P763
zyAze19-+y6ai=pJ4Fnh;Aizc11XU3Vh1tR)*ec506Z0%6kX+lWpXDMw&b{5;?amw;
z0y<kOLEFH%PJ(bGVF%ocgn17)0<3Th@^g5LIlvJ6qbwI<x4eIOODYJ4R_=*5{oXBw
zoS-W(J}wlv;(Ib<G#c^37PUPi?1{{8Ya{?>rERZ7#w?A)_HJWeisOhm(;@HTwifaA
z42&&c)E6m|C+O-=^cbr-oy3w=q|(+g!;;(IY)u!Y@~{XAPaz&*J+Q)f^&IO7&wn)#
zlXc9-RD^_k0UnB}2<7$0lt_%dF?pEnjj0Hs^nx+W6Y=n1W)}^0yuN?}dE*vJ<CSC>
zd5uU&yuN^Pc&$V%u!qh8O55!e&*HmTh+O(@dn~Uc`10zAK-0Vm>?lBWd2<GD$|;(;
z5-i%@cr9W=1bz-T1z|(Ru`S${w^h6j1<77?f(V{jS&dP%G?+a?!Pa^rQ&F=tl+l?!
zGFUSPN5){unC#2vmQN%N)lVjD%LB{L#79Vmb=kFCl{D039eRr{uE>I6y<|gQ19>-3
z-#DGHuavH;R<0%Mx|8L5Hx2tfwpJ%5Qq~5r{F^HhE$=j?&8-{e){McLZ2{B$(nz+R
z0*gPI46h{El%e5)(Q;#axf)<&4z2-HqOnnUU$@ebGB#(ml(sBupsaOiOT)UQVddcJ
z@sy=2u0&bE_vS=e->{)?$QW!lM{bNHp58Rne`Ie++gsM{Ei19LeJT4hac#z2e)HuU
zFDEXh&3iV?dk`Uz6%ZjURZ?}k=2lJOYbooVxaxt~@#+=G{zzZ4H1eb%0sK|iqn!YJ
ziO!NcIv1=zVCnHL<}E*8=)lA;nk9EL^#6DGj%0yU;Q2R1%Ul*8i5N-cv4pZDNLZeS
zWTE8;)C4C*U4;#SEde{EwBHNWFm_9)k>Z{*2c^L31GW{n4E;75B{7&qy%o>d&WxVu
z8<LC}>=}G5XTJ^)UJcw1wh%b@4*0J40$a^@2DCHIM5chbcxKseL3z?${4!WLD%)<D
z;_8gP<mS;EM-xqOp0la1%h<|aJ@ZgWRk<Fj;E*TZcX4-?tglU^l^yMKs8!0k<e+rq
zY;-Dt{|WPixD!=!SNZQTlq9-0%6|q_8X-!+1i@n!tRL`LYa}lPTv0C&g8~2|@%<HG
z@1YCT#V6;%3#Ybl>LShAlO=?iVqk{ylFhhe>xFX@>6}Dx^+4NiUZUG(6{Nu`NE54|
zq~_(7!X2%Gva{txNs^zngH`ZL+Ysd!k<J91@T~evaZ(bTBx&uB!fD4gcECvm{!3~>
zJq3f{7EKeUkeDzB04OkFIw<O^)?%VJ7%g+8n$s&mOn*YJ1bZMZqC0Y;QnIfAOqNp-
z(@=BXWlGd5i>Q_V6Ivi@rC_nt_1<}T<%G1ZlKQ$IzMQjF);Pgd$tt1zKSDp*SFvZ`
zMdXmKTbxTo?Ia2_`x?CYUzmmJa1QSycdl>4`}*hXpF%#X#t0Wb?9ynaA{JA^Qv_3&
zaroqkVTniahBKotNGV`e-^MD0W9bPunkrydv*Nb<<WRGy2on~t2*78c4XaC*pGm7L
zH`JBy^sber8xL(X9{Rv+|G1<!5lNLaEuDU#F3FfHlbXt3t99SxHg&x}dO4-*{SNmX
z?iDGOR`+hGdp|Hc9tdTQ{OEd0cSI~Bq|)jm8|ov_^auK!GKq90vO$TpIN{~*y-|Um
z)&hGJY6!d!g^yhspaMQA?NBt`iiY0SgbD4wt*iS<D$k{%K@ueNS|Ew&6<aE3G845i
zSbZ{HKb4bTr#um!f<=O&7kDJ0A)?TM%831#0zoS>b=kMbz5&?;OB?xEMsL1(=*FSt
zvn%^j`j(`kg`mgl@@=!Xp&(jBBJ*fc34+rb9BlDu3I%5iBJ2;56gX@U2_HpG@w|Z7
z3bNdk-%D1II3wr+Lzw*l!Q#s|Cc)szXc#T3>WrQ-z|ROj6Qs?IrArS3ViioGWUnGq
zMTq#%p?UT%F!}~YZ(`Jo(O+WpeT;@MLQ507g3;R;889MKzne&+!3n<t#c{`LL6HQa
zjLw*q!}BA9Ije+cRzq3sSuH|3O7F<(5i%fTM94(x>{&BH7OJE)YelF8Asa$=%Ie5E
z5GtiCmDw_c$|;roVFf^2w^7`j@F$EcU{-t+z4XgNKqOvpzXH1_kX1V<$YNk*?IH-z
zv-AWNMnzrPX!Dt9f)NRF3|Zv1a3Gfs>%dS$Gb*<Z%`}Y0E$dQ*^=`Se)j{2A>V?CM
z7RleO@CoVDjE<!9>b&s&0;4DIRZ@Kw)@KZEpb3(rE|Oy+IhrClW|E_oa)ht^1!E!a
z31$7}mw;H$2>T8^Mq={L&Q6}zu}(-8a7yhgX!UR;0mAJ+#~ea*gx-+UCU}jwSa^-N
zQ1S!^htBeV4_u@`Neg&pd~6%kaTy2?7QT@uWT{Poe790AujZl)3m$e+U;{|UEiFyC
zAZknwumi9j5H&?F;VHuE{sj~!<oquISfU<PQq66vioZU&CVyu%?p;3cr(a1t{l3Y0
z*A6O_$#FAuBb4y2^ruX1X;bIAsWWBjUOJIgQCjPAOGaZ_R%bM}<%x{Ou^a=7XSHf+
z;8XCMGGxlC;_e%Uj9R~;F3Tl=v1dvv;^%JYaX+Z4i!0*i*EQwa64p#jJ>*QTYbqb8
zEt%@(_=R;%#YcMcQW1Aglq|_Is3x5$&S18?9`Op|9kJV*--~M=IT)__Q!*MnZ!wO0
zg{QD4AzKO{{|LxbLerkgLM5d5aV|3ZgYXp$VcZaaDz^tlmKP0iEsBnxc!*uhuqLfX
z8r&a|Ly{oAC2COPBzBzyP>4(-oPUbaT3GR-f>9On4KT7Q#z1=89^jx#GBOs;2d*x1
zk+6D)HgpALGz?zJFu>0UKNI}GjM=3ORqjyNvc<?*A>!xOPD)%){Jz8k{sZBRT2K(*
zgYnl*=4<IDk)BA{UMr^>f_w)2ve-yShE1k~xZnbLf+`8}@($(ykdf2x(1xvG<bXp;
zJp|WX;Qa<Et;X~VKOvVE1iWCsoU9Z3>V~?LNW~=V@GX1(TOyq>4v{LuMyAwlWXh1M
zj#o1JLfRRt&ox}|a2v%o;8g4vf>r=@+b9-!QTC!74D*01hOlX}S%4_&g~o#S=KS2f
zXxe$k2WjtrBO_w6P=oZ)ub@RszNXu<>#PG+xGhCzy?ht?uPC5TtJ^Bg2v86xxOvL6
z?u>no@-6`m`TEe%*7}#I!ZF{uN5Z8Qw{>gzvvd~~E^(I>?c*Otsm0saiBdbryyPhr
z=2@iFIiOGIqc~(h&trICy)B3wPNb(x@<VWlAt>0VKLaY?BUad91}m8=ajlDOgl#*N
zt(HpI-8K=ioHB1dtDA)02;qgFifx7+`E@p7m?&Il#Yd{<$#u2^Hnk!)JLK1i`4hHX
zN5T2zC=^hqebO%WOzhXz-cQ)i(jW&qm}j1ag8AzKUJy~x@oExJ4M}k8MXZ?mgIeKT
z*f?J4b`;X@Zaf2yeg3P!HS$=#Xx@1ZdBG?E9MKFs|9`;hFU{9-m+rh)3V42L(UsA#
z%jz%O{q*kQZT!Dk8UF-U#vewl#j$TJLaoJ1Hi`582U1D%LFFGyCAj|4-ZWl0hQ0vX
zg2*|5CIAeVxy#02x85Em#bOlGBFbzagOx!o*fGOKw{h&?_BwDaw3ShcD+P8q;P!~e
z>1T2@i;IK=cO{q}+tAF%9L$^d#E}Y@!&O9;Tg5!JgY@%Me)K{6QZswpnl1&?&gk=8
zbNg;Aw#^u}lra>pKB<gxOBrL)G96pWn2MG$Zz*FgTBg%o&U9@lw?&E&aoSR%DAt7<
zZkL+r9<S_@hby*^gT%ko$QhWu?h0lfN-t--pyZZzx0T#4m8^u4TgGHt$pcbJCGf^v
z`;&)rQ%_AE5uq`(MQjUTQm(ipW1c>kGop+A$E#M2l#`mwU5v&XfL<r|0X(A6=tDwY
znwyaPkMb?l;B_tKbIL*Gna2XO<to!ZM9YdZ|9N}Mu0t{BPPbo0RTZz2!cjE2Hwj+T
zF$G>rjk&-xTR2H~wt0QC9=HMomr_I9JhkBttP2chipXLZt_aNg0^t!}B~%lXY+T)f
zxhr=PDLQ8p6EHET3Z~UK7W@H3sIjB1i^Ho*aG1<n`-l5RP7IDuF@w*a8yue)9LO0`
z;WpHQA5MSZxH)$mlvnI|>&(0-2p&gZQ6p{vJ}>)Y{DdDP4!;Ap8^ojaAztS9@>=Qi
zI&W&gQsOzgOS`l6;QQDtF&w;&&<cJ)fnM1xni+V_d}JXo1x7wN4f;A3_%=qw0zu4X
zE0BbFkfS*fZ5>-|<H(C)9O+MD02G`7bOSG>$K~!V)+XSQPIwQ8F~v=uB1MYpCb!>$
zw0%kRL~F=#&V9lYFPx&gGdQ5F00JXy0%CB{AAtw2nvTv~hU*}&V?ra66sLeBczG3=
z+xfBuk3U%C=pX?~Ifo0BnBcRNvP$*$rCsr%jJ-PHPTQN3_NMrNXj44{j$5CqDXs2R
z`tR*ca89SyeOTHhc&vT1`7r$>(_xxD28|JGByY}{O})7r0qhSUi#Na_i+Gm7@wU8a
zRkGgj<{;b&=fDgMj&69tntcx{#`g4iy<l_VoOpQ}7KtBjl1Jc@PVWA=bJ_=Y8GKG~
z!-sp!W-tdqO+tTgamO2TinWDH)lb%s9cBpSgEPd{d@dKA12QJJyqz6R4|f^whqKPB
z^ZuE6T#z0CC%hx=4|)OJqo~0NiwY@6IJA&&TW>BWuYsGmVGqmscvBxc7e&{{F-*d3
zLTGaea>+Y(3dc-GO5#h7T;ySoW7EelYQhM$D&c4o_gTSfaTXzR)dKBc>^w%-F}jS=
z9gNT@Czy-zpo5&L@Tx1G066mS3N)}2<2o-7hr)2DIl92wu^6h&ELw|PRlJHImUDRk
ziWMAo;aoU(YXjM{;J%9&cXDU2zrdIO8X~;ih|ES<k7Q*cC9~Hs&$QK>l2-|acfvw=
zBk>;+$w)99;?f6~M_^j;KL!?gb<W3z{TaTu6wn!5)q)$_DzI9@y-`A2<PeIuU=)px
z3GR{#Ttn=Cf#!(8>}{Ce&(K5Ckv2AM7@LxN$2W}=;EAEor4?oCin4_2o$+MX`J|$3
zQ*i+<oTT;D>-y@HzIJIKt57H_?w2-xFLXl>t_~$N3GZ8TZ_K4iTH<Onu9qh?_bl~G
zCo`6^+xlDj#PG^=%Hm2}I@T>6t8;5?%F+Xwr8T!N-@2S^*td2(ReEq~6pfYUWm!gJ
zS#AKY%{ZHjN|ujj^{Tz9rC~70n@ewAzHvF>T7g?$ZA&NatF6neZyrdiof~TBhov>~
zq5HO)#OyoXv~ACZZO;dm@{HMWGj=1EXib?Lk}c0}nxDm&j;h<|Z=GM!tTv<^9cjnj
zb;sVd*1P*sj-$XlY!$bAZuKN)0c)EpKJdU+@dNv6>89%l)VyzN%Qz}BWi|J!Y7<x9
zioFqA?YLW#symXZ>V^BLc2j%+4i&1q;seX2H_m_;=(78sp*n47TsJhXfHSD;VI5Ug
zn{B`WENNOfw>q%qN|hXmtM6CrSslDvk*esAn;vN>O-Zg_DYf%{(SDWH+>YIftvt0l
zohsX#E_-^t?CG_+yKJiLczpPQt?Heg)%l+)(v7_vjlF>PulMZ#sqWoFzwG<P;mxs$
z^r3Sbht9#gJpcXE$qN_ZLan1A?Pytdw5(iPD@i#Hq#cLW9f$6gy$j<rh(qE`+nUyG
zO)KtICS~g`9F(8S-yQh(r~dBLduLL|o=;Ak+dOs-zV~sZI6Uolm8rU;smkZ#r!(cX
zZ|UC9tsF>|x5ZCBXzsoh+k9sDm!+v^-0|U$3rF_lbY1s)UH4km-RV?aU#jZ3IAf}m
zqjd{h-Fm;;xl;Or%C{?5&)jWJ)gMb$_uX&ZyXN}oc)GQ3qqXl1*SnESRb#UC*m~8m
zbk+G})%l-aOpd>l8a)5VrXw>}N*Nu?FWxiMrVY*OhUOJ-+OX&0voKMQj^Ipmg0qmi
zbwl0yVOewh1X9@CJCU@leZ$sHh^hMag<BWE-3UgmJ?-dTcXY3n-G!0s#gVJLefZYl
z#FZ5`Wqa!P7`HOlYD=o@V0?HBrCojNYj1pQ^@vDm8GF_3)3;8q=u-AQJ9SO3B3(0W
z@7nv&wR)<&CEG;Vs&04P>UzJVF|L9m0=$OyrZKLED`+3uD`DRRN2=i)!^;;5-F_mc
z996Js+L|8esPd{uxxMxiCG5H2JzcI!D(tX6wML|QKX@rEA0!=*l2w#@S(Eq%96p$J
zaN4FVfeV_i_a`(frT5C)Qg#;<d3`3)wsPoRWqYc$16p`}|MImJ<v;sI$_8Fqm2dXL
za&`QTIaS@AF_gY32kJe4uev)`zBgm2Pd4t)7;4_+Rt~KW-D}*Rsypzv+}%U(4&OU`
zHg$01UfoF6tg-9h7*A_k9?sTVO{%3KaQgyQqe`pGHsR=_>G`-SX?AXC>N9X;(w5d%
zZECABO+$rmn{U>=R+nk=i0?jXY9rvfrv78;UtqXb`Zjef?<-nAdo-w^4CQ#syW+ma
z@Y?vY<Gbh6n(_@zIl0nZ@w-Q-=r1ks1qWgp^>?!R7xz>DuD0SOCzaW+f2l^EIck5Y
zT>e4165tP<`tv&Z2Yc-2m2zIG1en)MO(CzJnsRAl`nKo%u1g&8`_Cn=dRW-%a|yxe
zFPE5(&VhIn)8^{<*qDKUGoi3Q02#Vm%Imu(Rww^TMNEKK>Q@6Uom2}%r_hy{nbh+7
z(AD3A?HkDp_?I-HE3n<gY$Q47kIYA>I|RXp%Qb=0kbibD<{(8l-+~7us+kVf7w~yF
zU#?}ifD9Mt0->l^#5}loIi|rX@U<qPsmTifPhM<tsbUQaQ7$sc?E&xAYu5!y|9Uix
zXXV#Lc_`KqnfG&8hQzMt+OD#p;M{e8a0Wai!7c3iG#k3?3top2n_G0n+BhE!B*=3@
z6}S{~{Yo?dH+wzP{s6qbJ`;j_&}`5ZtGEjPbOuXJgSYGD>oXn@$gbmmaB#&8lhdF_
zLH|5~$?2GWa(Wsr_g(g}lhZC!OcV4+F7!-t7kM>6VgJnKm^m-qk(`(wzQXz8KQ=)7
zu@Z8n8@~ki14Hn1Jr}E60NImt{VEJ3yo-dcPy66G?L$X6SIig+qp;`+2o37sN_mLQ
z!CYh!{tW=45Cdt*H!FOm?CQJ+Tk_&37DG{NblxAl95Y742<KkMN+X`j_$5CU4k3mx
zg;#tr&E)j#RsYq=X~AL7$*ZTPyrG$?DPA`<H5(=WB4dh0otpiR7!mR9G(z<lfuRQE
zFwh{uU0nD_FsMDS6Bu2<Jd~q=czwL?<cX0{X0X2x{_Dk`U^ZS%W0x@^@@FSPJs1(`
z)Q!+2MnvEwqUX0TNo3785F&yp%2T-D(6<~G98LV8h`&d-Aa-evEQGw#fbS^#YbXl(
z3dMaNV)$<mH2qMgp%stq6y5kM%KRav|B%vtNLfFmbPp)!Z&kW7S(38-wp{Okr!`wm
zsWjg?|H}EKrE9I^CpAB=NhzOuw=}63&M4Kw`@L)Xe$xBn-juTM-9t&m8R>oJn(QaW
z9~)E3qwgw{ilHq0+YH%~>7hk!SAC+?S!E9u0L9f=IR!19`jb=fs|nd##y5=bD_S1P
zAnPF(S~5PYHe-bn3seATrwWku5DP6C9zO;D2<fp7|J%;vPWT@XpO(Va^v8C*Bm7u{
zH!dG*EVTV`3tl;S%*eoN^sxzC5+B!scTQG=jujfJtU`3uD6bYBH2}&vYLr!pjv5uU
zqN4^tIY*6ha1F**N~xOqPtj51F+=0YaQ3`{QW)Z~O?kx!3eC5N9?B_2<>$XWYk+Qk
a{@ZfEodYvC^)qAhphNMqXPXBr75^JGd$1D#

diff --git a/.agents/skills/iterate-pr/scripts/fetch_pr_checks.py b/.agents/skills/iterate-pr/scripts/fetch_pr_checks.py
index ba7f4e1ab..a78dfbc3a 100755
--- a/.agents/skills/iterate-pr/scripts/fetch_pr_checks.py
+++ b/.agents/skills/iterate-pr/scripts/fetch_pr_checks.py
@@ -6,9 +6,15 @@
 Fetch PR CI checks and optional failure snippets.
 
 Usage:
-    python fetch_pr_checks.py [--pr PR_NUMBER]
+    uv run fetch_pr_checks.py [--pr PR_NUMBER]
+    python3 fetch_pr_checks.py [--pr PR_NUMBER]
 
 If --pr is not specified, uses the PR for the current branch.
+
+Output contract: a single JSON object on stdout carrying a top-level ``status``
+field, ``"ok"`` or ``"error"``. On error ``summary`` and ``checks`` are ``null``
+- never empty - so a caller reading only stdout cannot mistake a failed lookup
+for a green PR. Errors also exit non-zero.
 """
 
 from __future__ import annotations
@@ -18,7 +24,7 @@
 import re
 import subprocess
 import sys
-from typing import Any
+from typing import Any, NoReturn
 
 RUN_ID_PATTERN = re.compile(r"/actions/runs/(\d+)")
 FAILURE_PATTERNS = [
@@ -41,17 +47,37 @@
 ]
 
 
-def fail(message: str) -> None:
-    print(json.dumps({"error": message}))
+def fail(message: str) -> NoReturn:
+    """Emit a machine-readable failure and exit non-zero."""
+    print(
+        json.dumps(
+            {
+                "status": "error",
+                "error": message,
+                "pr": None,
+                "summary": None,
+                "checks": None,
+                "action_required": (
+                    "STOP: CI status could not be fetched, so this PR's check state "
+                    "is unknown. Do not treat this as 'checks passed' and do not "
+                    f"merge. Cause: {message}"
+                ),
+            },
+            indent=2,
+        )
+    )
     sys.exit(1)
 
 
 def run_gh_json(args: list[str], allowed_exit_codes: tuple[int, ...] = (0,)) -> Any:
-    result = subprocess.run(
-        ["gh", *args],
-        capture_output=True,
-        text=True,
-    )
+    try:
+        result = subprocess.run(
+            ["gh", *args],
+            capture_output=True,
+            text=True,
+        )
+    except OSError as exc:
+        raise RuntimeError(f"failed to run gh CLI: {exc}") from exc
 
     if result.returncode not in allowed_exit_codes:
         stderr = (result.stderr or result.stdout).strip() or "unknown gh error"
@@ -130,12 +156,21 @@ def extract_failure_snippet(log_text: str, max_lines: int = 50) -> str:
 
 
 def get_run_logs(run_id: int) -> str | None:
-    result = subprocess.run(
-        ["gh", "run", "view", str(run_id), "--log-failed"],
-        capture_output=True,
-        text=True,
-        timeout=60,
-    )
+    """Failure logs for a run, or ``None`` when they cannot be read.
+
+    A log snippet is an enrichment, so every failure here degrades to no
+    snippet. Raising instead would abort an otherwise-complete checks fetch and
+    leave stdout empty, which is the one thing this script's contract forbids.
+    """
+    try:
+        result = subprocess.run(
+            ["gh", "run", "view", str(run_id), "--log-failed"],
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+    except (subprocess.TimeoutExpired, OSError):
+        return None
     if result.returncode != 0:
         return None
     return result.stdout if result.stdout.strip() else None
@@ -186,6 +221,7 @@ def main() -> None:
         processed_checks.append(processed)
 
     output = {
+        "status": "ok",
         "pr": {
             "number": pr_number,
             "url": pr_info.get("url", ""),
diff --git a/.agents/skills/iterate-pr/scripts/fetch_pr_feedback.py b/.agents/skills/iterate-pr/scripts/fetch_pr_feedback.py
index 8ebc33f24..d96f65131 100755
--- a/.agents/skills/iterate-pr/scripts/fetch_pr_feedback.py
+++ b/.agents/skills/iterate-pr/scripts/fetch_pr_feedback.py
@@ -10,6 +10,12 @@
     python3 fetch_pr_feedback.py [--pr PR_NUMBER]
 
 If --pr is not specified, uses the PR for the current branch.
+
+Output contract: a single JSON object on stdout carrying a top-level ``status``
+field. ``status`` is ``"ok"`` when the fetch completed and ``"error"`` when it
+did not. On error the ``summary`` and ``feedback`` keys are ``null`` - never
+empty - so that "there is no feedback" and "the feedback was never fetched"
+cannot be confused by a caller reading only stdout. Errors also exit non-zero.
 """
 
 from __future__ import annotations
@@ -22,6 +28,9 @@
 from typing import Any, NoReturn
 
 
+# Bots whose comments are actionable code review. Matched against the login with
+# any trailing "[bot]" stripped, because the REST API reports "coderabbitai[bot]"
+# while GraphQL reports "coderabbitai" for the same account.
 REVIEW_BOT_PATTERNS = [
     r"(?i)^sentry",
     r"(?i)^warden",
@@ -32,8 +41,16 @@
     r"(?i)^codex",
     r"(?i)^claude",
     r"(?i)^codeql",
+    r"(?i)^coderabbit",
+    r"(?i)^gemini-code-assist",
+    r"(?i)^greptile",
+    r"(?i)^sourcery",
+    r"(?i)^qodo",
+    r"(?i)^codium",
+    r"(?i)^ellipsis",
 ]
 
+# Bots that post informational status reports rather than review findings.
 INFO_BOT_PATTERNS = [
     r"(?i)^codecov",
     r"(?i)^dependabot",
@@ -43,6 +60,8 @@
     r"(?i)^semantic-release",
     r"(?i)^sonarcloud",
     r"(?i)^snyk",
+    r"(?i)^netlify",
+    r"(?i)^vercel",
     r"(?i)bot$",
     r"(?i)\[bot\]$",
 ]
@@ -85,9 +104,32 @@
     )
 ]
 
+BOT_SUFFIX = re.compile(r"\[bot\]$", re.IGNORECASE)
+
 
 def fail(message: str) -> NoReturn:
-    print(json.dumps({"error": message}))
+    """Emit a machine-readable failure and exit non-zero.
+
+    ``summary`` and ``feedback`` are explicitly null so a caller that reads only
+    stdout cannot mistake a failed lookup for a clean PR.
+    """
+    print(
+        json.dumps(
+            {
+                "status": "error",
+                "error": message,
+                "pr": None,
+                "summary": None,
+                "feedback": None,
+                "action_required": (
+                    "STOP: PR feedback could not be fetched, so this PR's review "
+                    "state is unknown. Do not treat this as 'no feedback' and do "
+                    f"not merge. Cause: {message}"
+                ),
+            },
+            indent=2,
+        )
+    )
     sys.exit(1)
 
 
@@ -114,6 +156,29 @@ def run_gh_json(args: list[str]) -> Any:
         raise RuntimeError(f"gh {' '.join(args)} returned non-JSON output") from exc
 
 
+def run_gh_json_list(args: list[str]) -> list[dict[str, Any]]:
+    """Fetch a paginated REST list and flatten it, or raise.
+
+    Every caller of this needs a list. ``gh`` can exit 0 while writing nothing -
+    a truncated response, a proxy, a degraded endpoint - and the shape that
+    reaches us is then ``None``, not ``[]``. Returning ``[]`` for it is the
+    silent-empty inversion this whole script exists to prevent: a whole feedback
+    channel disappears and the run reports a clean PR. So anything that is not a
+    list is an error, not an absence.
+    """
+    result = run_gh_json(args)
+    if result is None:
+        raise RuntimeError(
+            f"gh {' '.join(args)} exited 0 but returned no output; "
+            "the response was not delivered, so the feedback it carries is unknown"
+        )
+    if not isinstance(result, list):
+        raise RuntimeError(
+            f"gh {' '.join(args)} returned {type(result).__name__}, expected a list of pages"
+        )
+    return flatten_pages(result)
+
+
 def get_repo_info() -> tuple[str, str]:
     result = run_gh_json(["repo", "view", "--json", "owner,name"])
     if not isinstance(result, dict):
@@ -125,8 +190,23 @@ def get_repo_info() -> tuple[str, str]:
     return str(owner), str(repo)
 
 
+def get_current_user() -> str:
+    """Login of the account ``gh`` is authenticated as.
+
+    Required, not optional: without it the fetcher cannot tell the caller's own
+    replies apart from reviewer feedback, and reports them back as new work.
+    """
+    result = run_gh_json(["api", "user"])
+    if not isinstance(result, dict):
+        raise RuntimeError("could not determine the authenticated gh user")
+    login = result.get("login")
+    if not login:
+        raise RuntimeError("authenticated gh user has no login")
+    return str(login)
+
+
 def get_pr_info(pr_number: int | None = None) -> dict[str, Any]:
-    args = ["pr", "view", "--json", "number,url,headRefName,author,reviews,reviewDecision"]
+    args = ["pr", "view", "--json", "number,url,headRefName,author,reviewDecision"]
     if pr_number is not None:
         args.insert(2, str(pr_number))
     result = run_gh_json(args)
@@ -135,31 +215,57 @@ def get_pr_info(pr_number: int | None = None) -> dict[str, Any]:
     return result
 
 
+def normalize_login(username: str) -> str:
+    """Strip the REST-only ``[bot]`` suffix so both APIs classify identically."""
+    return BOT_SUFFIX.sub("", username or "").strip()
+
+
 def is_review_bot(username: str) -> bool:
-    return any(re.search(p, username) for p in REVIEW_BOT_PATTERNS)
+    login = normalize_login(username)
+    return any(re.search(p, login) for p in REVIEW_BOT_PATTERNS)
 
 
 def is_info_bot(username: str) -> bool:
-    return any(re.search(p, username) for p in INFO_BOT_PATTERNS)
+    return any(re.search(p, username or "") for p in INFO_BOT_PATTERNS)
+
+
+def flatten_pages(result: list[Any]) -> list[dict[str, Any]]:
+    """Flatten the list of pages ``gh api --paginate --slurp`` returns.
+
+    Shape validation belongs to ``run_gh_json_list``; by the time we get here the
+    payload is known to be a list of pages.
+    """
+    entries: list[dict[str, Any]] = []
+    for page in result:
+        if isinstance(page, list):
+            entries.extend(entry for entry in page if isinstance(entry, dict))
+        elif isinstance(page, dict):
+            entries.append(page)
+    return entries
 
 
 def get_issue_comments(owner: str, repo: str, pr_number: int) -> list[dict[str, Any]]:
-    result = run_gh_json([
+    return run_gh_json_list([
         "api",
         f"repos/{owner}/{repo}/issues/{pr_number}/comments",
         "--paginate",
         "--slurp",
     ])
-    if not isinstance(result, list):
-        return []
 
-    comments: list[dict[str, Any]] = []
-    for page in result:
-        if isinstance(page, list):
-            comments.extend(entry for entry in page if isinstance(entry, dict))
-        elif isinstance(page, dict):
-            comments.append(page)
-    return comments
+
+def get_reviews(owner: str, repo: str, pr_number: int) -> list[dict[str, Any]]:
+    """Submitted reviews, read from REST because only REST carries ``html_url``.
+
+    ``gh pr view --json reviews`` exposes the review's GraphQL node id, while the
+    page anchor is keyed on the numeric database id, so a review body sourced
+    that way reaches the caller with no link back to the review it came from.
+    """
+    return run_gh_json_list([
+        "api",
+        f"repos/{owner}/{repo}/pulls/{pr_number}/reviews",
+        "--paginate",
+        "--slurp",
+    ])
 
 
 def get_review_threads(owner: str, repo: str, pr_number: int) -> list[dict[str, Any]]:
@@ -178,7 +284,7 @@ def get_review_threads(owner: str, repo: str, pr_number: int) -> list[dict[str,
               isOutdated
               path
               line
-              comments(first: 1) {
+              firstComment: comments(first: 1) {
                 nodes {
                   body
                   createdAt
@@ -187,6 +293,14 @@ def get_review_threads(owner: str, repo: str, pr_number: int) -> list[dict[str,
                   }
                 }
               }
+              lastComment: comments(last: 1) {
+                nodes {
+                  createdAt
+                  author {
+                    login
+                  }
+                }
+              }
             }
           }
         }
@@ -213,19 +327,20 @@ def get_review_threads(owner: str, repo: str, pr_number: int) -> list[dict[str,
 
         result = run_gh_json(args)
         if not isinstance(result, dict):
-            break
+            raise RuntimeError("gh api graphql returned no review-thread payload")
 
-        review_threads = (
-            result.get("data", {})
-            .get("repository", {})
-            .get("pullRequest", {})
-            .get("reviewThreads", {})
-        )
+        pull_request = ((result.get("data") or {}).get("repository") or {}).get("pullRequest")
+        if not isinstance(pull_request, dict):
+            raise RuntimeError(
+                f"GraphQL returned no pull request {pr_number} for {owner}/{repo}"
+            )
+
+        review_threads = pull_request.get("reviewThreads") or {}
         nodes = review_threads.get("nodes", [])
         if isinstance(nodes, list):
             threads.extend(nodes)
 
-        page_info = review_threads.get("pageInfo", {})
+        page_info = review_threads.get("pageInfo") or {}
         if not page_info.get("hasNextPage"):
             break
         cursor = page_info.get("endCursor")
@@ -235,6 +350,105 @@ def get_review_threads(owner: str, repo: str, pr_number: int) -> list[dict[str,
     return threads
 
 
+# Channel name -> the GraphQL connection on PullRequest that counts the same records.
+PROBE_CONNECTIONS = {
+    "review threads": "reviewThreads",
+    "PR conversation comments": "comments",
+    "reviews": "reviews",
+}
+
+
+def probe_counts(owner: str, repo: str, pr_number: int) -> dict[str, int]:
+    """Server-side record counts per feedback channel.
+
+    One small query, used only to sanity-check an empty channel. It asks GitHub
+    how many records it holds rather than trusting that an empty response means
+    an empty PR.
+    """
+    selections = "\n".join(
+        f"{alias}: {connection}(first: 1) {{ totalCount }}"
+        for alias, connection in enumerate_probe_aliases()
+    )
+    query = f"""
+    query($owner: String!, $repo: String!, $pr: Int!) {{
+      repository(owner: $owner, name: $repo) {{
+        pullRequest(number: $pr) {{
+          {selections}
+        }}
+      }}
+    }}
+    """
+    result = run_gh_json([
+        "api",
+        "graphql",
+        "-f",
+        f"query={query}",
+        "-F",
+        f"owner={owner}",
+        "-F",
+        f"repo={repo}",
+        "-F",
+        f"pr={pr_number}",
+    ])
+    if not isinstance(result, dict):
+        raise RuntimeError("gh api graphql returned no count-probe payload")
+
+    pull_request = ((result.get("data") or {}).get("repository") or {}).get("pullRequest")
+    if not isinstance(pull_request, dict):
+        raise RuntimeError(
+            f"count probe found no pull request {pr_number} for {owner}/{repo}"
+        )
+
+    counts: dict[str, int] = {}
+    for channel, (alias, _connection) in zip(PROBE_CONNECTIONS, enumerate_probe_aliases()):
+        node = pull_request.get(alias)
+        total = node.get("totalCount") if isinstance(node, dict) else None
+        if not isinstance(total, int):
+            raise RuntimeError(f"count probe returned no total for {channel}")
+        counts[channel] = total
+    return counts
+
+
+def enumerate_probe_aliases() -> list[tuple[str, str]]:
+    """Stable ``(alias, connection)`` pairs for the probe query.
+
+    Aliases are positional (``c0``, ``c1``, ...) so the query never repeats a
+    field name, which GraphQL rejects when the same connection is selected twice.
+    """
+    return [(f"c{index}", connection) for index, connection in enumerate(PROBE_CONNECTIONS.values())]
+
+
+def assert_empty_channels_are_really_empty(
+    owner: str,
+    repo: str,
+    pr_number: int,
+    fetched: dict[str, list[Any]],
+) -> None:
+    """Fail loudly when a channel came back empty but GitHub says it has records.
+
+    This is the backstop for the defect class this script is built around: every
+    known silent-empty path is closed above, but a *new* one would again look
+    exactly like a clean PR. Probing only when something is already empty keeps
+    this to one extra query on the rare path and none on the common one.
+    """
+    empty = [channel for channel, records in fetched.items() if not records]
+    if not empty:
+        return
+
+    counts = probe_counts(owner, repo, pr_number)
+    missing = [
+        f"{channel} (fetched 0, GitHub reports {counts[channel]})"
+        for channel in empty
+        if counts.get(channel, 0) > 0
+    ]
+    if missing:
+        raise RuntimeError(
+            "feedback channels came back empty while GitHub reports records in them: "
+            + "; ".join(missing)
+            + ". The fetch was incomplete, so this PR's review state is unknown"
+        )
+
+
 def detect_logaf(body: str) -> str | None:
     for pattern, level in LOGAF_PATTERNS:
         if pattern.search(body):
@@ -261,6 +475,38 @@ def item_sort_key(item: dict[str, Any]) -> str:
     return item.get("_created_at", "")
 
 
+def first_node(container: Any) -> dict[str, Any]:
+    """Return the first node of a GraphQL connection, or an empty dict."""
+    nodes = container.get("nodes") if isinstance(container, dict) else None
+    if isinstance(nodes, list) and nodes and isinstance(nodes[0], dict):
+        return nodes[0]
+    return {}
+
+
+def author_login(node: Any) -> str:
+    """``author.login`` of a GraphQL node, tolerating a null ``author``.
+
+    A deleted account serializes as ``"author": null``, which an unguarded
+    ``.get("author", {}).get("login")`` turns into an AttributeError.
+    """
+    if not isinstance(node, dict):
+        return ""
+    author = node.get("author")
+    if not isinstance(author, dict):
+        return ""
+    return str(author.get("login") or "")
+
+
+def user_login(node: Any) -> str:
+    """``user.login`` of a REST node, tolerating a null ``user``."""
+    if not isinstance(node, dict):
+        return ""
+    user = node.get("user")
+    if not isinstance(user, dict):
+        return ""
+    return str(user.get("login") or "")
+
+
 def extract_feedback_item(
     body: str,
     author: str,
@@ -273,6 +519,7 @@ def extract_feedback_item(
     is_outdated: bool = False,
     review_bot: bool = False,
     thread_id: str | None = None,
+    replied: bool = False,
 ) -> dict[str, Any]:
     summary = body[:200] + "..." if len(body) > 200 else body
     summary = summary.replace("\n", " ").strip()
@@ -298,6 +545,8 @@ def extract_feedback_item(
         item["review_bot"] = True
     if thread_id:
         item["thread_id"] = thread_id
+    if replied:
+        item["replied"] = True
 
     return item
 
@@ -309,14 +558,24 @@ def main() -> None:
 
     try:
         owner, repo = get_repo_info()
+        viewer = get_current_user()
         pr_info = get_pr_info(args.pr)
     except RuntimeError as error:
         fail(str(error))
 
     pr_number = pr_info["number"]
-    pr_author = pr_info.get("author", {}).get("login", "")
+    pr_author = author_login(pr_info)
     review_decision = pr_info.get("reviewDecision", "")
 
+    self_logins = {
+        normalize_login(viewer).casefold(),
+        normalize_login(pr_author).casefold(),
+    } - {""}
+
+    def is_self(author: str) -> bool:
+        """What the caller wrote is not feedback for the caller."""
+        return normalize_login(author).casefold() in self_logins
+
     feedback: dict[str, list[dict[str, Any]]] = {
         "high": [],
         "medium": [],
@@ -325,94 +584,132 @@ def main() -> None:
         "resolved": [],
     }
 
-    reviews = pr_info.get("reviews", [])
-    if isinstance(reviews, list):
-        for review in reviews:
-            if not isinstance(review, dict):
-                continue
-            if review.get("state") != "CHANGES_REQUESTED":
-                continue
-            author = review.get("author", {}).get("login", "")
-            body = review.get("body", "")
-            if not author or not body or author == pr_author:
-                continue
-            item = extract_feedback_item(
-                body=body,
-                author=author,
-                created_at=str(review.get("submittedAt", "")),
-            )
-            item["type"] = "changes_requested"
-            feedback["high"].append(item)
-
     try:
         threads = get_review_threads(owner, repo, pr_number)
         issue_comments = get_issue_comments(owner, repo, pr_number)
+        reviews = get_reviews(owner, repo, pr_number)
+        assert_empty_channels_are_really_empty(
+            owner,
+            repo,
+            pr_number,
+            {
+                "review threads": threads,
+                "PR conversation comments": issue_comments,
+                "reviews": reviews,
+            },
+        )
     except RuntimeError as error:
         fail(str(error))
 
-    if isinstance(threads, list):
-        for thread in threads:
-            if not isinstance(thread, dict):
-                continue
-            comments = thread.get("comments", {}).get("nodes", [])
-            if not comments or not isinstance(comments, list):
-                continue
-
-            first_comment = comments[0] if comments and isinstance(comments[0], dict) else {}
-            author = first_comment.get("author", {}).get("login", "")
-            body = first_comment.get("body", "")
-            if not author or not body or author == pr_author or len(body.strip()) < 3:
-                continue
-
-            is_resolved = bool(thread.get("isResolved", False))
-            thread_id = thread.get("id")
-            category = "resolved" if is_resolved else categorize_comment(author, body)
-
-            item = extract_feedback_item(
-                body=body,
-                author=author,
-                created_at=str(first_comment.get("createdAt", "")),
-                path=thread.get("path"),
-                line=thread.get("line"),
-                is_resolved=is_resolved,
-                is_outdated=bool(thread.get("isOutdated", False)),
-                thread_id=thread_id if isinstance(thread_id, str) else None,
-                review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
-            )
-            feedback[category].append(item)
-
-    if isinstance(issue_comments, list):
-        for comment in issue_comments:
-            if not isinstance(comment, dict):
-                continue
-            author = comment.get("user", {}).get("login", "")
-            body = comment.get("body", "")
-            if not author or not body or author == pr_author or len(body.strip()) < 3:
-                continue
-
-            category = categorize_comment(author, body)
-            item = extract_feedback_item(
-                body=body,
-                author=author,
-                created_at=str(comment.get("created_at", "")),
-                url=comment.get("html_url"),
-                review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
-            )
-            feedback[category].append(item)
+    for thread in threads:
+        if not isinstance(thread, dict):
+            continue
+
+        first_comment = first_node(thread.get("firstComment"))
+        author = author_login(first_comment)
+        body = first_comment.get("body", "")
+        if not author or not body or is_self(author) or len(body.strip()) < 3:
+            continue
+
+        is_resolved = bool(thread.get("isResolved", False))
+        thread_id = thread.get("id")
+
+        # A thread whose newest comment is ours has already been answered. Without
+        # this the caller replies, sees the same thread on the next poll, and
+        # replies again forever.
+        last_author = author_login(first_node(thread.get("lastComment")))
+        replied = bool(last_author) and is_self(last_author)
+
+        category = "resolved" if is_resolved else categorize_comment(author, body)
+
+        item = extract_feedback_item(
+            body=body,
+            author=author,
+            created_at=str(first_comment.get("createdAt", "")),
+            path=thread.get("path"),
+            line=thread.get("line"),
+            is_resolved=is_resolved,
+            is_outdated=bool(thread.get("isOutdated", False)),
+            thread_id=thread_id if isinstance(thread_id, str) else None,
+            review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
+            replied=replied and not is_resolved,
+        )
+        feedback[category].append(item)
+
+    for comment in issue_comments:
+        if not isinstance(comment, dict):
+            continue
+        author = user_login(comment)
+        body = comment.get("body", "")
+        if not author or not body or is_self(author) or len(body.strip()) < 3:
+            continue
+
+        category = categorize_comment(author, body)
+        item = extract_feedback_item(
+            body=body,
+            author=author,
+            created_at=str(comment.get("created_at", "")),
+            url=comment.get("html_url"),
+            review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
+        )
+        feedback[category].append(item)
+
+    # Review bodies. Bots that post their findings as one review (CodeRabbit,
+    # Copilot, Gemini) submit with state COMMENTED, so filtering on
+    # CHANGES_REQUESTED alone discards the entire finding list.
+    #
+    # A review body is never flagged `replied`. It carries no thread and no
+    # resolve button, so the only stateless signal available is "we said
+    # something later", which cannot tell answering a review apart from
+    # happening to type after it - and a review that lands mid-round would then
+    # be dismissed unread. Re-reporting an answered review is visible; dropping
+    # an unread one is not.
+    for review in reviews:
+        if not isinstance(review, dict):
+            continue
+        author = user_login(review)
+        body = review.get("body", "") or ""
+        if not author or not body.strip() or is_self(author):
+            continue
+        state = review.get("state", "")
+        changes_requested = state == "CHANGES_REQUESTED"
+        category = "high" if changes_requested else categorize_comment(author, body)
+        item = extract_feedback_item(
+            body=body,
+            author=author,
+            created_at=str(review.get("submitted_at", "")),
+            url=review.get("html_url"),
+            review_bot=category in {"high", "medium", "low"} and is_review_bot(author),
+        )
+        item["type"] = "changes_requested" if changes_requested else "review"
+        feedback[category].append(item)
 
     for bucket in feedback.values():
         bucket.sort(key=item_sort_key)
         for item in bucket:
             item.pop("_created_at", None)
 
+    priority_buckets = ("high", "medium", "low")
     review_bot_count = sum(
         1
-        for bucket in ("high", "medium", "low")
+        for bucket in priority_buckets
         for item in feedback[bucket]
         if item.get("review_bot")
     )
+    already_replied = sum(
+        1
+        for bucket in priority_buckets
+        for item in feedback[bucket]
+        if item.get("replied")
+    )
+
+    open_high = [item for item in feedback["high"] if not item.get("replied")]
+    open_medium = [item for item in feedback["medium"] if not item.get("replied")]
+    open_low = [item for item in feedback["low"] if not item.get("replied")]
 
     output = {
+        "status": "ok",
+        "viewer": viewer,
         "pr": {
             "number": pr_number,
             "url": pr_info.get("url", ""),
@@ -426,16 +723,17 @@ def main() -> None:
             "bot_comments": len(feedback["bot"]),
             "resolved": len(feedback["resolved"]),
             "review_bot_feedback": review_bot_count,
-            "needs_attention": len(feedback["high"]) + len(feedback["medium"]),
+            "already_replied": already_replied,
+            "needs_attention": len(open_high) + len(open_medium),
         },
         "feedback": feedback,
     }
 
-    if feedback["high"]:
+    if open_high:
         output["action_required"] = "Address high-priority feedback before merge"
-    elif feedback["medium"]:
+    elif open_medium:
         output["action_required"] = "Address medium-priority feedback"
-    elif feedback["low"]:
+    elif open_low:
         output["action_required"] = "Review low-priority suggestions - ask user which to address"
     else:
         output["action_required"] = None