diff --git a/.agents/skills/pr-watch/SKILL.md b/.agents/skills/pr-watch/SKILL.md
index b397ce9a..18ee787a 100644
--- a/.agents/skills/pr-watch/SKILL.md
+++ b/.agents/skills/pr-watch/SKILL.md
@@ -12,12 +12,14 @@ scripts/pr-watch <pr-number> [--expect <sha>] [--timeout <sec>] [--interval <sec
 ```
 exit 0  every check COMPLETED, none failed, and MERGEABLE with a state of
         CLEAN, UNSTABLE or HAS_HOOKS
-exit 1  a check failed, or the PR is not mergeable (CONFLICTING, BLOCKED,
-        DIRTY, BEHIND, DRAFT, or a state it does not know)
+exit 1  a check failed (under any mergeability, BLOCKED included), or the
+        PR is not mergeable (CONFLICTING, DIRTY, BEHIND, DRAFT, or a state
+        it does not know)
 exit 2  the head moved during the wait, or is not --expect
 exit 3  timed out with checks still running, mergeability still UNKNOWN,
         or still BLOCKED with every registered check green
 exit 4  usage or environment error
+exit 5  the PR is MERGED or CLOSED; it ends on the first poll
 ```
 
 **Exit 0 now means mergeable, not only green.** GitHub computes mergeability
diff --git a/context/code/tooling.md b/context/code/tooling.md
index 6b09fc0f..78275a1e 100644
--- a/context/code/tooling.md
+++ b/context/code/tooling.md
@@ -278,7 +278,15 @@ The rule now:
   exit 1.
 - **A known answer ends the wait early**: a failed check (exit 1 whatever
   mergeability says, since waiting would turn a known red into a timeout), or
-  `mergeable == CONFLICTING`.
+  `mergeable == CONFLICTING`. "Whatever mergeability says" includes
+  `MERGEABLE/BLOCKED`, which is how a failed *required* check reports here, so
+  it is the commonest red this script sees (improvise-9pfs).
+- **A PR that is no longer open ends it on the first poll, with exit 5**
+  (improvise-1qaa). GitHub reports a MERGED or CLOSED PR as `UNKNOWN/UNKNOWN`
+  permanently. The UNKNOWN wait therefore slept the whole timeout there and
+  then blamed mergeability. The script now fetches `state`. Exit 5 is its own
+  code, not 1 or 0, because under merge-as-soon-as-green "someone else already
+  merged it" is a normal answer, and the caller should hear it as that.
 - **The pass condition is an allowlist**: `mergeable == MERGEABLE` *and*
   `mergeStateStatus` in `CLEAN`, `UNSTABLE` or `HAS_HOOKS`. Anything else exits
   1. That includes `null` and any state GitHub adds later, so the check fails
diff --git a/context/test-evidence/tooling.md b/context/test-evidence/tooling.md
index 8ac79c4f..dd62dca5 100644
--- a/context/test-evidence/tooling.md
+++ b/context/test-evidence/tooling.md
@@ -682,6 +682,36 @@ alone fails, exiting 0. All 44 others pass. That is the review's point: the
 older `a head that moves mid-wait is not a pass` starts from MERGEABLE, so it
 cannot see this rival.
 
+### The pr-watch red-under-BLOCKED and ended-PR cases — `scripts/pr-watch-test.sh`
+
+improvise-9pfs and improvise-1qaa. Both were found by the re-review of PR #186
+at `04230a7`.
+
+**9pfs: the commonest red had no case.** Every red fixture wore `UNSTABLE` or
+`UNKNOWN`. Here, though, a failed *required* check reports `MERGEABLE/BLOCKED`,
+and the table enumerates green rollups only. The new case is
+`a failed required check under MERGEABLE/BLOCKED fails without waiting`. It uses
+PR #189's rollup with `Test and lint (host)` rewritten to `FAILURE`, runs at
+`--timeout 0`, and expects exit 1. It passed at `202e7eac`, since the script
+already broke on any failed check, so it pins existing behaviour. **Rival:** the
+failed-check break gated on `state != BLOCKED`. That case alone fails, exiting 3
+where 1 is wanted, and the other 45 cases pass. Nothing else in the suite could
+see a refactor that turned every required-check red into a timeout.
+
+**1qaa: a merged PR slept the whole timeout.** Two case pairs, one for MERGED
+and one for CLOSED, each with green checks and `UNKNOWN/UNKNOWN`. That is the
+shape `gh pr view 189` returned live once #189 had merged. Each pair asserts
+exit 5, and also that the fixture was read **once**, from the poll counter
+`fetch` keeps on disk. At `202e7eac` all four failed: exit 3 after 108 and 109
+polls within a 5s timeout. Two rivals:
+
+- **The state checked only when the timeout expires.** It exits 5 after the full
+  wait, so both exit-code cases pass and only the two poll-count cases fail, at
+  52 and 25 polls. The poll count is what pins "does not wait". An exit code
+  alone cannot, which is why each case is a pair.
+- **Exit 1 instead of 5.** The two exit-code cases fail with exit 1. That keeps
+  "already merged" apart from "not mergeable".
+
 ## Every JSON parser reads numbers exactly (improvise-dz8c)
 
 ### `every_crate_that_can_parse_json_enables_float_roundtrip`
diff --git a/scripts/pr-watch b/scripts/pr-watch
index 0c96ddaf..c4496df6 100755
--- a/scripts/pr-watch
+++ b/scripts/pr-watch
@@ -18,6 +18,7 @@ exit 2  the head moved during the wait, or is not --expect
 exit 3  timed out with checks still running, or mergeability still UNKNOWN,
         or still BLOCKED with every registered check green
 exit 4  usage or environment error
+exit 5  the PR is MERGED or CLOSED, so there is nothing left to wait for
 EOF
   exit 4
 }
@@ -51,10 +52,10 @@ fetch() {
     return
   fi
   if command -v gh >/dev/null 2>&1 && gh --version 2>/dev/null | grep -q '^gh version'; then
-    gh pr view "$PR" --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup
+    gh pr view "$PR" --json state,headRefOid,mergeable,mergeStateStatus,statusCheckRollup
   else
     nix shell nixpkgs#gh --command gh pr view "$PR" \
-      --json headRefOid,mergeable,mergeStateStatus,statusCheckRollup
+      --json state,headRefOid,mergeable,mergeStateStatus,statusCheckRollup
   fi
 }
 
@@ -74,6 +75,11 @@ while :; do
     echo "pr-watch: head is $head, expected $EXPECT*" >&2
     exit 2
   fi
+  # A merged or closed PR reports UNKNOWN/UNKNOWN for good (improvise-1qaa).
+  pr_state="$(printf '%s' "$json" | jqf '.state')"
+  case "$pr_state" in
+    MERGED|CLOSED) echo "pr-watch: PR $PR is $pr_state, nothing to wait for" >&2; exit 5 ;;
+  esac
   if [ -z "$pinned" ]; then
     pinned="$head"
   elif [ "$head" != "$pinned" ]; then
diff --git a/scripts/pr-watch-test.sh b/scripts/pr-watch-test.sh
index 172d5717..cc2e9b25 100755
--- a/scripts/pr-watch-test.sh
+++ b/scripts/pr-watch-test.sh
@@ -153,6 +153,26 @@ run_case "the needs-gap before the required check registers is not a failure" 0
 gap_state "$work/gap-never" last.json MERGEABLE BLOCKED "$not_yet"
 run_case "a required check that never registers is a timeout" 3 "$work/gap-never"
 
+# improvise-9pfs. Here a failed REQUIRED check reports MERGEABLE/BLOCKED, not
+# UNSTABLE. The table above holds only green rollups, so this red was unpinned.
+gap_state "$work/blocked-red" last.json MERGEABLE BLOCKED \
+  'map(if .name == "Test and lint (host)" then .conclusion = "FAILURE" else . end)'
+run_case "a failed required check under MERGEABLE/BLOCKED fails without waiting" 1 \
+  "$work/blocked-red" --timeout 0
+
+# improvise-1qaa. GitHub reports a merged or closed PR as UNKNOWN/UNKNOWN, so
+# waiting on UNKNOWN slept the full timeout there. One poll, then exit 5.
+for s in MERGED CLOSED; do
+  d="$work/ended-$s"
+  mkdir -p "$d"
+  printf '{"headRefOid":"aaaaaaaaaaaa","state":"%s","mergeable":"UNKNOWN","mergeStateStatus":"UNKNOWN","statusCheckRollup":%s}\n' \
+    "$s" "$green_rollup" > "$d/last.json"
+  run_case "a $s PR ends the watch as no longer open" 5 "$d" --timeout 5
+  polls="$(cat "$d/.poll" 2>/dev/null || echo 0)"
+  [ "$polls" = 1 ] && ok "a $s PR is read once, not waited on" \
+    || bad "a $s PR is read once, not waited on (polls)" "$polls" 1
+done
+
 # improvise-h3ni. The head must stay pinned across the UNKNOWN wait, or a
 # verdict about b is reported as a verdict about a.
 state "$work/unk-moved" 1.json '"UNKNOWN"' '"UNKNOWN"' "$green_rollup"