@muggleai/works 5.27.0-staging.246 → 5.27.0-staging.247

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "muggleai",
       "source": "./plugin",
       "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-      "version": "5.27.0-staging.246"
+      "version": "5.27.0-staging.247"
     }
   ]
 }

package/dist/{chunk-PT5EGMBA.js → chunk-B5BWBZZ5.js}

@@ -2384,7 +2384,6 @@ var WATCH_STATUS_FILE = "status.json";
 var WATCH_STATE_FILE = "state.json";
 var WATCH_EVENTS_FILE = "events.jsonl";
 var WATCH_EVENTS_ROTATE_BYTES = 5 * 1024 * 1024;
-var MONITOR_STDOUT_CAP_MS = 30 * 6e4;
 var WATCHER_REARM_GRACE_MS = 5 * 6e4;
 var CODEX_ACTIVE_WINDOW_MS = 10 * 6e4;
 var CODEX_ROLLOUT_DAY_DIRS_SCANNED = 7;
@@ -4990,8 +4989,7 @@ function resolveWatcherLiveness(loop, heartbeatAgeMs, isOwnerSessionActive, isPr
     return isHeartbeatWithin(WATCH_HEARTBEAT_STALE_MS) ? "polling" /* Polling */ : "dead" /* Dead */;
   }
   if (loop) {
-    const hasOutlivedMonitor = (loop.ageMs ?? 0) > MONITOR_STDOUT_CAP_MS;
-    return hasOutlivedMonitor || isOwnerSessionActive === false ? "deaf" /* Deaf */ : "polling" /* Polling */;
+    return isOwnerSessionActive === false ? "deaf" /* Deaf */ : "polling" /* Polling */;
   }
   return isHeartbeatWithin(WATCHER_REARM_GRACE_MS) ? "rearming" /* Rearming */ : "dead" /* Dead */;
 }
@@ -5058,12 +5056,11 @@ function watcherFinding(assessment, subject) {
     );
   }
   if (assessment.watcher === "deaf" /* Deaf */) {
-    const reason = assessment.isOwnerSessionActive === false ? `its owner session ${shortSessionId(assessment.ownerSessionId ?? "")} has ended` : `it has run ${formatDuration(assessment.loopAgeMs ?? 0)}, past the 30-minute Monitor cap`;
     return finding(
       "WATCHER_DEAF" /* WatcherDeaf */,
       [assessment.pr.url, assessment.loopPid],
       subject,
-      `watch loop pid ${assessment.loopPid} reports to no session: ${reason}`
+      `watch loop pid ${assessment.loopPid} reports to no session: its owner session ${shortSessionId(assessment.ownerSessionId ?? "")} has ended`
     );
   }
   return void 0;

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-PT5EGMBA.js';
+import { runCli } from './chunk-B5BWBZZ5.js';
 import './chunk-6BAB7IVG.js';
 
 // src/cli/main.ts

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-PT5EGMBA.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-B5BWBZZ5.js';
 export { createChildLogger, e2e_exports as e2e, getConfig, getLocalQaTools, getLogger, getQaTools, local_exports as localQa, mcp_exports as mcp, e2e_exports as qa, src_exports as shared } from './chunk-6BAB7IVG.js';

package/dist/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-  "version": "5.27.0-staging.246",
+  "version": "5.27.0-staging.247",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.codex-mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.27.0-staging.246",
+        "@muggleai/works@5.27.0-staging.247",
         "serve"
       ],
       "env": {

package/dist/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "muggle",
-  "version": "5.27.0-staging.246",
+  "version": "5.27.0-staging.247",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
   "author": {
     "name": "Muggle AI",

package/dist/plugin/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Real-browser E2E acceptance for your coding agent: test the flows you changed and open the PR with screenshots. Built for flows other tools can't reach: managed test identities with live inboxes (magic links, email OTP and 2FA, verification mail, password resets), an encrypted secret store for login and test credentials, and a test graph that runs prerequisite flows first. Plain-English tests become replayable scripts on localhost or preview URLs.",
-  "version": "5.27.0-staging.246",
+  "version": "5.27.0-staging.247",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/.mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.27.0-staging.246",
+        "@muggleai/works@5.27.0-staging.247",
         "serve"
       ]
     }

package/dist/plugin/hooks/README.md

@@ -77,9 +77,9 @@ Codex runs a plugin's hooks only once the user trusts them: it asks at startup (
 
 `SessionStart` (`scripts/reconcile-stale-watchers.sh`) — a standalone advisory, not part of the `guardrails.mjs` decision tree above.
 
-`muggle-pr-followup` watchers are session-only (a monitor or `/loop` cron); they die with their session, leaving open PRs with no live poller. This is by design — a review is addressed only inside a session that carries the context to address it. The skill's [`reconcile`](../skills/muggle-pr-followup/reconcile.md) procedure recovers them at the next session start — finalizes slots whose PR went terminal, sweeps orphan crons, re-arms silently-stopped open watchers — but re-arming needs Claude tools a shell hook can't call. So this hook nudges rather than acts.
+`muggle-pr-followup` watchers are session-only (a background watch loop or `/loop` cron); they die with their session, leaving open PRs with no live poller. This is by design — a review is addressed only inside a session that carries the context to address it. The skill's [`reconcile`](../skills/muggle-pr-followup/reconcile.md) procedure recovers them at the next session start — finalizes slots whose PR went terminal, sweeps orphan crons, re-arms silently-stopped open watchers — but re-arming needs Claude tools a shell hook can't call. So this hook nudges rather than acts.
 
-The nudge counts only slots **this session owns**, and reports the rest as orphans it will not act on — ownership and the recovery rules it gates are defined in [`reconcile`](../skills/muggle-pr-followup/reconcile.md). Nothing owned and nothing orphaned → it emits nothing. A pure directory scan (no `gh`, no writes), so it's cheap enough for every session start.
+The nudge counts only slots **this session owns** — ownership and the recovery rules it gates are defined in [`reconcile`](../skills/muggle-pr-followup/reconcile.md). A session that owns none hears nothing: the hook speaks into every session start, and slots owned elsewhere are no work of this one's — `muggle watch status` reports them. A pure directory scan (no `gh`, no writes), so it's cheap enough for every session start.
 
 ## Session-start upkeep
 

package/dist/plugin/scripts/pr-watch-arm.sh

@@ -8,9 +8,10 @@
 # and never reaching its terminal check. Every health signal said fine. Doing
 # the three steps here, in one command, is what makes that unskippable.
 #
-# The floors are taken from the drain's own read rather than from a fresh fetch
-# afterwards: anything that lands between the two would otherwise be marked seen
-# without ever being reported.
+# A first arm takes its floors from the drain's own read rather than from a fresh
+# fetch afterwards: anything that lands between the two would otherwise be marked
+# seen without ever being reported. A re-arm keeps the review, comment and thread
+# floors the session already holds, for the same reason.
 #
 # A stale branch or a red head is floored only when the slot proves a cycle ran
 # for it. Flooring whatever was outstanding at arm time let a session that never
@@ -38,7 +39,7 @@ if [ -z "$slot" ] || [ -z "$repo" ] || [ -z "$pr_number" ] || [ -z "$base_branch
     exit 2
 fi
 
-for lib in pr-watch-guards.sh pr-watch-events.sh pr-watch-fetch.sh pr-watch-due.sh; do
+for lib in pr-watch-guards.sh pr-watch-events.sh pr-watch-fetch.sh pr-watch-due.sh pr-watch-floors.sh; do
     if [ ! -f "${script_dir}/${lib}" ]; then
         echo "pr-watch-arm: missing ${lib} beside this script" >&2
         exit 2
@@ -135,9 +136,10 @@ recorded_rebase_due_key="$rebase_due_key"
 thread_count=0
 [ -n "$unresolved_threads" ] && thread_count=$(printf '%s' "$unresolved_threads" | tr ';' '\n' | grep -c .)
 
-# Printed, not swallowed: these are the things the arming session owes action on
-# before the monitor takes over. Unattempted work is left unfloored, so the
-# loop's first pass reports it again as an event.
+# A record of the PR as armed, read from the watch's output when its loop ends.
+# Printing wakes nobody: the session hears the watch only when the loop exits.
+# Unattempted work is left unfloored, so the loop's first poll reports it and
+# exits — that report is the wake.
 echo "DRAIN pr=$pr_number state=$pr_state head=${head_sha:0:8}"
 echo "DRAIN unresolved-threads=$thread_count latest-review=${latest_review:-0} latest-comment=${latest_comment:-0}"
 echo "DRAIN checks pending=${pending_checks:-0} failed=${failed_checks:-0} behind-base=${behind_count:-unknown} mergeable=${mergeable:-UNKNOWN}"
@@ -158,10 +160,25 @@ if [ -n "$rebase_due_key" ]; then
     fi
 fi
 
+# A re-arm carries the review, comment and thread floors forward. The session
+# advanced them past what it handled, so anything newer — a review landing
+# between its last tick's read and this one — is above them, and the loop's
+# first poll reports it. Seeding them from this read would floor that review
+# unseen. Only a first arm, with nothing handled yet, takes them from its read.
+review_floor="${latest_review:-0}"
+comment_floor="${latest_comment:-0}"
+threads_floor="$unresolved_threads"
+if [ -f "${slot}/watch-watermark.env" ]; then
+    review_floor="$(watch_read_slot_value "$slot" watch-watermark.env REV)"
+    comment_floor="$(watch_read_slot_value "$slot" watch-watermark.env COM)"
+    threads_floor="$(watch_threads_still_unresolved \
+        "$(watch_read_slot_value "$slot" watch-watermark.env THREADS)" "$unresolved_threads")"
+fi
+
 {
-    printf 'REV=%s\n' "${latest_review:-0}"
-    printf 'COM=%s\n' "${latest_comment:-0}"
-    printf 'THREADS="%s"\n' "$unresolved_threads"
+    printf 'REV=%s\n' "${review_floor:-0}"
+    printf 'COM=%s\n' "${comment_floor:-0}"
+    printf 'THREADS="%s"\n' "$threads_floor"
     printf 'CIRED="%s"\n' "$ci_red_floor"
     printf 'REBASED="%s"\n' "$rebase_floor"
     printf 'BLOCKED_CIDIGEST="%s"\n' "$blocked_digest_floor"

package/dist/plugin/scripts/pr-watch-floors.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+
+# The floors a watch compares each poll against, as they persist between loops.
+# Sourced by pr-watch-arm.sh and pr-watch-loop.sh.
+#
+# A loop exits on every report, because the session that owns it hears it only
+# when it exits. So no floor can live in a loop's memory: whatever stops one
+# occurrence firing twice has to be on disk for the next loop to read. Two files
+# hold them — watch-watermark.env, which the session advances past what it
+# handled, and watch-reported.env, which the loop advances past what it told
+# the session — and a poll fires only on what is above both.
+
+MUGGLE_PR_WATCH_REPORTED_FILE="watch-reported.env"
+
+# Prints the value of `key` in a slot file of `KEY="value"` lines, quotes
+# stripped, the last match winning; nothing when the file or key is absent.
+# Read with builtins, never sourced: THREADS holds bare semicolons, which a
+# sourced unquoted line would split, and a CI digest carries check names an
+# author controls.
+watch_read_slot_value() {
+    local slot="$1" file_name="$2" key="$3" line value=""
+    [ -f "${slot}/${file_name}" ] || return 0
+    while IFS= read -r line || [ -n "$line" ]; do
+        line="${line%$'\r'}"
+        case "$line" in
+            "${key}="*)
+                value="${line#"${key}"=}"
+                value="${value%\"}"
+                value="${value#\"}"
+                ;;
+        esac
+    done < "${slot}/${file_name}"
+    printf '%s' "$value"
+}
+
+# Writes <slot>/watch-reported.env: the newest review and comment ids and the
+# unresolved threads a loop's last poll saw — every one of them either reported
+# or already floored — and the red head, rebase key and blocked digest it
+# reported, with the block (`blocked_for`, that block's watermark digest) the
+# digest was reported under.
+watch_record_reported() {
+    local slot="$1" review="$2" comment="$3" threads="$4" ci_red="$5" rebase="$6" blocked_digest="$7" blocked_for="$8"
+    printf 'REV=%s\nCOM=%s\nTHREADS="%s"\nCIRED="%s"\nREBASED="%s"\nBLOCKED_CIDIGEST="%s"\nBLOCKED_FOR="%s"\n' \
+        "$review" "$comment" "$threads" "$ci_red" "$rebase" "$blocked_digest" "$blocked_for" \
+        > "${slot}/${MUGGLE_PR_WATCH_REPORTED_FILE}"
+}
+
+# Prints the threads of `known` (semicolon-joined) that are still in
+# `unresolved`, semicolon-joined. A thread resolved since it was floored drops
+# out, so its unresolving again is news.
+watch_threads_still_unresolved() {
+    local known="$1" unresolved="$2" thread_id kept=""
+    local -a thread_ids
+    IFS=';' read -ra thread_ids <<< "$known"
+    for thread_id in "${thread_ids[@]}"; do
+        [ -n "$thread_id" ] || continue
+        case ";${unresolved};" in
+            *";${thread_id};"*) kept="${kept:+${kept};}${thread_id}" ;;
+        esac
+    done
+    printf '%s' "$kept"
+}

package/dist/plugin/scripts/pr-watch-guards.sh

@@ -13,26 +13,26 @@
 #   watcher_superseded    — <slot>/watch.pid holds the PID of the watcher that
 #                           owns the slot. A loop whose PID no longer matches has
 #                           been replaced by a newer arm and must exit.
-#   watcher_window_elapsed — a loop exits once it has run for its monitor
-#                           window, before the Monitor that owns its stdout ends.
-#                           It announces the exit so the owning session re-arms.
+#   watcher_window_elapsed — a loop run under a Monitor exits once it has run for
+#                           its window, before the Monitor that owns its stdout
+#                           ends. It announces the exit so the owning session
+#                           re-arms. Off unless MUGGLE_PR_WATCH_MONITOR_WINDOW is set.
 #   watcher_lifetime_exceeded — a loop exits after MUGGLE_PR_WATCH_MAX_LIFETIME
 #                           regardless, so an orphan nothing supersedes still dies
 #                           on its own; reconcile re-arms an open PR inside a live
 #                           session.
 
 # Seconds a watch loop may live. 0 means unbounded — the `never` setting of the
-# watcherLifetime preference. Under a Monitor the window below ends a loop long
-# before this does; this bounds a loop run with the window disabled.
+# watcherLifetime preference.
 MUGGLE_PR_WATCH_MAX_LIFETIME="${MUGGLE_PR_WATCH_MAX_LIFETIME:-604800}"
 MUGGLE_PR_WATCH_POLL_INTERVAL="${MUGGLE_PR_WATCH_POLL_INTERVAL:-60}"
 # Seconds one loop process runs before handing the watch back for a fresh arm.
-# The Monitor tool ends a background task after 1800s but does not stop the
-# process it launched, so a loop that outlives its monitor polls into a closed
-# pipe: every event it prints reaches nobody while its lease and heartbeat read
-# healthy. 1740 closes the window one poll interval inside that cap. 0 means
-# unbounded, for a loop run outside a Monitor.
-MUGGLE_PR_WATCH_MONITOR_WINDOW="${MUGGLE_PR_WATCH_MONITOR_WINDOW:-1740}"
+# Only a loop run under a Monitor needs one: the Monitor tool stops reading after
+# 1800s without stopping the process, so such a loop must end itself first, and
+# every hand-back costs the session a model turn. The watch runs as a background
+# shell, which has no cap and wakes the session only when the loop exits, so the
+# default is 0, unbounded.
+MUGGLE_PR_WATCH_MONITOR_WINDOW="${MUGGLE_PR_WATCH_MONITOR_WINDOW:-0}"
 # Consecutive failed fetches before a loop gives up. A watcher must ride through
 # a GitHub / network outage — an observed drop lasted ~8 minutes — not die and
 # leave the PR unwatched until its owning session next starts. With the backoff, 60

package/dist/plugin/scripts/pr-watch-loop.sh

@@ -1,7 +1,12 @@
 #!/usr/bin/env bash
 
 # The muggle-pr-followup watch loop. One process per PR slot: polls provider
-# state, prints one line per new event, and exits when the PR goes terminal.
+# state silently, and exits as soon as a poll finds something — printing one line
+# per new event — or the PR goes terminal.
+#
+# It runs as a background shell, which wakes the owning session only when the
+# process exits. So a quiet PR costs the session nothing, and each report costs
+# one turn, after which the session handles it and arms a fresh loop.
 #
 # Ships as a file so arming runs it rather than rewrites it. A loop re-derived
 # from prose on every arm drifts — the behind-base wake went missing from half
@@ -39,7 +44,7 @@ fi
 # gone. Guards missing means the plugin moved or upgraded underneath this loop —
 # a newer version's watcher owns the slot now, so step down rather than run on
 # without the supersede check.
-for lib in pr-watch-guards.sh pr-watch-events.sh pr-watch-fetch.sh pr-watch-due.sh; do
+for lib in pr-watch-guards.sh pr-watch-events.sh pr-watch-fetch.sh pr-watch-due.sh pr-watch-floors.sh; do
     [ -f "${script_dir}/${lib}" ] || exit 0
     # shellcheck source=/dev/null
     . "${script_dir}/${lib}"
@@ -60,16 +65,6 @@ unseeded=0
 # look at the PR rather than handing back a watch that never polled.
 has_iterated=""
 
-# In-memory floors, above the on-disk watermark. The watermark is advanced by
-# the session after it handles a wave; these stop the loop re-reporting an event
-# in the window before that write lands.
-floor_review=0
-floor_comment=0
-floor_threads=";"
-floor_ci_red=""
-floor_rebase=""
-floor_blocked_digest=""
-
 # What watch-due.env last recorded, so the file is rewritten only when the due
 # work changes rather than every poll.
 due_rebase_key=""
@@ -81,19 +76,28 @@ pinned_token="$(gh auth token 2>/dev/null)"
 [ -n "$pinned_token" ] && export GH_TOKEN="$pinned_token"
 
 
-read_watermark_value() {
-    local key="$1" line value=""
-    while IFS= read -r line || [ -n "$line" ]; do
-        line="${line%$'\r'}"
-        case "$line" in
-            "${key}="*)
-                value="${line#"${key}"=}"
-                value="${value%\"}"
-                value="${value#\"}"
-                ;;
-        esac
-    done < "${slot}/watch-watermark.env"
-    printf '%s' "$value"
+# What earlier loops already reported. Without these, work the session saw and
+# chose not to act on — a HOLD WATCH, a comment needing no reply — would end
+# every fresh loop on its first poll. A blocked-resume floor holds only for the
+# block it was reported under (BLOCKED_FOR), so the same digest can resume a
+# later block.
+read_reported() {
+    watch_read_slot_value "$slot" "$MUGGLE_PR_WATCH_REPORTED_FILE" "$1"
+}
+reported_review=$(read_reported REV)
+reported_comment=$(read_reported COM)
+reported_threads=$(read_reported THREADS)
+floor_ci_red=$(read_reported CIRED)
+floor_rebase=$(read_reported REBASED)
+floor_blocked_digest=$(read_reported BLOCKED_CIDIGEST)
+floor_blocked_for=$(read_reported BLOCKED_FOR)
+
+read_watermark() {
+    watch_read_slot_value "$slot" watch-watermark.env "$1"
+}
+
+higher_id() {
+    if [ "${1:-0}" -gt "${2:-0}" ] 2>/dev/null; then printf '%s' "${1:-0}"; else printf '%s' "${2:-0}"; fi
 }
 
 # Every wait goes through here so that none, however long, can carry the loop
@@ -104,7 +108,10 @@ pause() {
 
 while :; do
     watcher_superseded "$slot" "$$" && exit 0
-    watcher_lifetime_exceeded "$started" "$(date +%s)" && exit 0
+    if watcher_lifetime_exceeded "$started" "$(date +%s)"; then
+        echo "EXPIRED pr=$pr_number watch lifetime of ${MUGGLE_PR_WATCH_MAX_LIFETIME}s reached — re-arm to keep watching"
+        exit 0
+    fi
     # Exit while the Monitor that owns this stdout is still reading, and say so:
     # the line is the owning session's cue to re-arm, and ending here is what
     # frees the lease that re-arm needs. A loop that ran on past its monitor would
@@ -136,13 +143,13 @@ while :; do
     fi
     unseeded=0
 
-    watermark_review=$(read_watermark_value REV)
-    watermark_comment=$(read_watermark_value COM)
-    watermark_threads=$(read_watermark_value THREADS)
-    watermark_ci_red=$(read_watermark_value CIRED)
-    watermark_rebase=$(read_watermark_value REBASED)
-    watermark_blocked_digest=$(read_watermark_value BLOCKED_CIDIGEST)
-    watermark_rebase_held=$(read_watermark_value REBASE_HELD)
+    watermark_review=$(read_watermark REV)
+    watermark_comment=$(read_watermark COM)
+    watermark_threads=$(read_watermark THREADS)
+    watermark_ci_red=$(read_watermark CIRED)
+    watermark_rebase=$(read_watermark REBASED)
+    watermark_blocked_digest=$(read_watermark BLOCKED_CIDIGEST)
+    watermark_rebase_held=$(read_watermark REBASE_HELD)
 
     state_line=$(watch_fetch_state "$repo" "$pr_number" "$slot" "$state_projection")
     # One quick retry before counting a strike: a single flaky call should not
@@ -187,29 +194,25 @@ while :; do
         continue
     fi
     fails=0
+    has_reported=""
 
-    if watch_wake_review "$pr_number" "$latest_review" \
-        "$(( watermark_review > floor_review ? watermark_review : floor_review ))"; then
-        floor_review="$latest_review"
-    fi
-
-    if watch_wake_comment "$pr_number" "$latest_comment" \
-        "$(( watermark_comment > floor_comment ? watermark_comment : floor_comment ))"; then
-        floor_comment="$latest_comment"
-    fi
+    watch_wake_review "$pr_number" "$latest_review" "$(higher_id "$watermark_review" "$reported_review")" && has_reported=1
+    watch_wake_comment "$pr_number" "$latest_comment" "$(higher_id "$watermark_comment" "$reported_comment")" && has_reported=1
 
     if [ -n "$unresolved_threads" ]; then
         IFS=';' read -ra thread_ids <<< "$unresolved_threads"
         for thread_id in "${thread_ids[@]}"; do
-            if watch_wake_thread "$pr_number" "$thread_id" "${watermark_threads};${floor_threads}"; then
-                floor_threads="${floor_threads}${thread_id};"
-            fi
+            watch_wake_thread "$pr_number" "$thread_id" "${watermark_threads};${reported_threads}" && has_reported=1
         done
     fi
 
-    if watch_wake_ci_red "$pr_number" "$pending_checks" "$failed_checks" "$head_sha" \
-        "${floor_ci_red:-$watermark_ci_red}"; then
+    # Either floor quiets the head: the watermark's when a fix already ran for
+    # it, the reported one when a loop already told the session it went red.
+    ci_red_floor="$watermark_ci_red"
+    [ "$floor_ci_red" = "$head_sha" ] && ci_red_floor="$floor_ci_red"
+    if watch_wake_ci_red "$pr_number" "$pending_checks" "$failed_checks" "$head_sha" "$ci_red_floor"; then
         floor_ci_red="$head_sha"
+        has_reported=1
     fi
 
     rebase_key="${head_sha}..${base_tip_sha}"
@@ -227,6 +230,7 @@ while :; do
         if watch_wake_rebase "$pr_number" "$mergeable" "$behind_count" "$rebase_key" ""; then
             floor_rebase="$rebase_key"
             due_rebase_key="$rebase_key"
+            has_reported=1
         fi
     fi
 
@@ -239,12 +243,21 @@ while :; do
     fi
 
     # The tick owns clearing the block, and it may not run for a while. Holding
-    # the emitted digest stops the loop repeating itself every iteration in the
-    # meantime — the repeat nagging the design rules out — while a further move
-    # still wakes it.
+    # the reported digest stops each fresh loop repeating it in the meantime — the
+    # repeat nagging the design rules out — while a further move still wakes it.
+    [ "$floor_blocked_for" = "$watermark_blocked_digest" ] || floor_blocked_digest=""
     if [ "$ci_digest" != "$floor_blocked_digest" ] \
         && watch_wake_blocked_resume "$pr_number" "$ci_digest" "$watermark_blocked_digest"; then
         floor_blocked_digest="$ci_digest"
+        floor_blocked_for="$watermark_blocked_digest"
+        has_reported=1
+    fi
+
+    if [ -n "$has_reported" ]; then
+        watch_record_reported "$slot" "$(higher_id "$latest_review" "$reported_review")" \
+            "$(higher_id "$latest_comment" "$reported_comment")" "$unresolved_threads" \
+            "$floor_ci_red" "$floor_rebase" "$floor_blocked_digest" "$floor_blocked_for"
+        exit 0
     fi
 
     pause "$MUGGLE_PR_WATCH_POLL_INTERVAL"

package/dist/plugin/scripts/reconcile-stale-watchers.sh

@@ -9,10 +9,11 @@ set -euo pipefail
 # The nudge is owner-scoped. Each slot records the session that armed it in
 # owner.json; only slots owned by THIS session are a recovery the agent should
 # run, because re-arming a stranger's PR would hand review work to a session with
-# no context for it. Slots owned by another session (or none) are reported as
-# orphans with the adopt command, never as work to pick up. A pure directory scan
-# — no gh, no writes, bash builtins only — so it stays cheap enough for every
-# session start however many slots have piled up.
+# no context for it. A session that owns none hears nothing: the hook speaks into
+# every session start, and slots owned elsewhere are no work of this one's —
+# `muggle watch status` reports them. A pure directory scan — no gh, no writes,
+# bash builtins only — so it stays cheap enough for every session start however
+# many slots have piled up.
 
 hook_dir="${BASH_SOURCE[0]%/*}"
 [ "$hook_dir" = "${BASH_SOURCE[0]}" ] && hook_dir=.
@@ -56,8 +57,6 @@ fi
 # stopped watchers back as work.
 sessions_dir="${HOME}/.muggle-ai/muggle-do/sessions"
 owned_count=0
-orphan_count=0
-first_orphan_slug=""
 
 if [ -d "$sessions_dir" ]; then
     for slot in "$sessions_dir"/*/; do
@@ -76,20 +75,11 @@ if [ -d "$sessions_dir" ]; then
         # (legacy slot) is likewise foreign — never adopted by default.
         if [ -n "$current_session_id" ] && [ "$slot_owner" = "$current_session_id" ]; then
             owned_count=$((owned_count + 1))
-        else
-            orphan_count=$((orphan_count + 1))
-            if [ -z "$first_orphan_slug" ]; then
-                first_orphan_slug="${slot%/}"
-                first_orphan_slug="${first_orphan_slug##*/}"
-            fi
         fi
     done
 fi
 
-# Clean state: nothing of this session's to recover and no orphans → stay silent.
-if [ "$owned_count" -eq 0 ] && [ "$orphan_count" -eq 0 ]; then
-    exit 0
-fi
+[ "$owned_count" -gt 0 ] || exit 0
 
 if [ "$owned_count" -eq 1 ]; then
     owned_word="watcher"
@@ -97,20 +87,7 @@ else
     owned_word="watchers"
 fi
 
-if [ "$owned_count" -gt 0 ]; then
-    context="muggle-pr-followup: ${owned_count} open ${owned_word} owned by this session may have lost its poller. Run \`/muggle:muggle-pr-followup reconcile\` to finalize any whose PR went terminal and re-arm the silently-stopped ones. Reconcile is idempotent and re-arms only watchers this session armed itself."
-else
-    context="muggle-pr-followup: no watchers belong to this session — nothing to re-arm."
-fi
-
-if [ "$orphan_count" -gt 0 ]; then
-    if [ "$orphan_count" -eq 1 ]; then
-        orphan_word="slot is"
-    else
-        orphan_word="slots are"
-    fi
-    context="${context} ${orphan_count} open ${orphan_word} owned by other sessions; reconcile will finalize them if their PR already merged or closed, but will never re-arm them. Adopt one deliberately with \`/muggle:muggle-pr-followup adopt <slug>\` (e.g. ${first_orphan_slug}) only if the user asks — do not offer or adopt on your own."
-fi
+context="muggle-pr-followup: ${owned_count} open ${owned_word} owned by this session may have lost its poller. Run \`/muggle:muggle-pr-followup reconcile\` to finalize any whose PR went terminal and re-arm the silently-stopped ones. Reconcile is idempotent and re-arms only watchers this session armed itself."
 
 escaped_context=$(escape_for_json "$context")
 

package/dist/plugin/skills/_shared/host-tool-equivalents.md

@@ -11,7 +11,7 @@ These skills are written against Claude Code's tools. In another agent host —
 | `$CLAUDE_CODE_SESSION_ID` | This session's id | `$CODEX_SESSION_ID` — the same id the hooks receive as `session_id`. |
 | Dispatch a plugin agent (`agents/*.md`, subagent type `muggle:<agent>`) | The Agent tool | `spawn_agent` with that agent file's instructions as the task, when multi-agent is enabled; otherwise run the agent file inline, as each skill already allows for a host with no subagents. |
 | `TodoWrite` | The session task list | `update_plan` |
-| `Monitor`, `/loop`, `CronCreate`/`CronDelete` (the PR watcher's background watch) | Wake the session when the watch reports an event | No equivalent: nothing in Codex wakes a session from a background process. Run the drain tick, seed the slot without a loop (`pr-watch-arm.sh … --no-exec`), and tell the user that following the PR up means invoking `$muggle:muggle-pr-followup` again — or scheduling it with `codex exec`. Never leave a loop polling that no session will hear. |
+| A background `Bash` command (`run_in_background`), `/loop`, `CronCreate`/`CronDelete` (the PR watcher's background watch) | Wake the session when the watch reports an event | No equivalent: nothing in Codex wakes a session from a background process. Run the drain tick, seed the slot without a loop (`pr-watch-arm.sh … --no-exec`), and tell the user that following the PR up means invoking `$muggle:muggle-pr-followup` again — or scheduling it with `codex exec`. Never leave a loop polling that no session will hear. |
 | `model:` in a skill's frontmatter | Runs the skill on that model | Ignored — the session's model runs every skill. |
 
 ## Codex's sandbox

package/dist/plugin/skills/do/next-step.md

@@ -55,4 +55,4 @@ At most four options, in this order:
 
 A new task goes through the selector's free-text answer, which starts a fresh `/muggle-do` forward run.
 
-**Text while a watch runs.** When the status block holds an `open` or `blocked` line, print the selector as text — one numbered option per line — and end the turn on the question; the user's next message is the pick. A pending `AskUserQuestion` holds the turn, and every watcher this chat runs with it: a rollover goes unanswered and the watcher stays dead until the user replies. With no such line, ask with one `AskUserQuestion`. The adopt selector under **Other chats' work** follows the same rule.
+**Text while a watch runs.** When the status block holds an `open` or `blocked` line, print the selector as text — one numbered option per line — and end the turn on the question; the user's next message is the pick. A pending `AskUserQuestion` holds the turn, and every watcher this chat runs with it: a loop that ends on a report goes unanswered and the watcher stays dead until the user replies. With no such line, ask with one `AskUserQuestion`. The adopt selector under **Other chats' work** follows the same rule.

package/dist/plugin/skills/do/open-prs/forward.md

@@ -86,7 +86,7 @@ If `prs.json` is empty, **do not arm** — record the reason in `result.md` and
 **Skipped:** repo → reason (when `autoCreatePR` short-circuited)
 **Overflow comments posted:** repo → PR #
 **Stage 7.5:** `green` | `waived — <reason>` | `iteration-cap`
-**Stage 8:** `Watching <N> PR(s) — one monitor per PR, armed per arm-watcher.md` | `No PRs to watch — stage 8 not armed`
+**Stage 8:** `Watching <N> PR(s) — one watch loop per PR, armed per arm-watcher.md` | `No PRs to watch — stage 8 not armed`
 **Errors:** repo → message
 
 ## Post-merge cleanup

package/dist/plugin/skills/muggle-pr-followup/SKILL.md

@@ -16,13 +16,13 @@ A watcher that babysits one open PR toward **merge-ready** — review threads ad
 
 **Per-PR isolation.** One watcher per PR. Multi-PR work runs N independent watchers.
 
-**Arming.** Bootstrap, auto-track, and the executor's post-cycle respawn all arm the watch the same way — one drain tick, then one persistent labeled monitor per PR — visible as a running task for as long as the PR is polled, gone at terminal ([`arm-watcher.md`](arm-watcher.md)). Crons only ever deliver a recovery tick, never the ongoing cadence: a cron-delivered tick re-arms the monitor and cancels its own cron ([`contract.md`](contract.md) Step 7.5), because every cron fire is a model turn while the monitor polls token-free.
+**Arming.** Bootstrap, auto-track, and the executor's post-cycle respawn all arm the watch the same way — one drain tick, then one background watch loop per PR — visible as a running task for as long as the PR is polled, gone at terminal ([`arm-watcher.md`](arm-watcher.md)). The loop polls token-free and reaches the session only by exiting, on the poll that finds something to act on, so a quiet PR costs no turns; the tick that answers it re-arms the loop ([`contract.md`](contract.md) Step 7.5). Crons only ever deliver a recovery tick, never the ongoing cadence: a cron-delivered tick re-arms the loop and cancels its own cron, because every cron fire is a model turn.
 
 **One reminder when blocked pending a human.** When a PR can't progress without the user — an escalated rebase/CI budget spent, or an ambiguous review awaiting direction — the tick that flags the block emits **one** one-line reminder: the pending act plus a reference back to the decision context ([`contract.md`](contract.md) Steps 2.5, 7). After that the watch stays visible and silent — no repeat nagging — and the block clears the instant a wake finds a push, review, or CI/deploy state moved.
 
-**Cron lifecycle.** Each tick records its `/loop` cron id to `cron.json` while `CronList` can still see it ([`record-cron-id.md`](record-cron-id.md)), so teardown can delete the cron by id after a session continue / compaction blinds `CronList` to it. Reconcile ([`reconcile.md`](reconcile.md)) sweeps crons whose PR is terminal or whose slot is gone, and re-arms an open slot whose watcher stopped silently — monitor-first, never with a recurring cron.
+**Cron lifecycle.** Each tick records its `/loop` cron id to `cron.json` while `CronList` can still see it ([`record-cron-id.md`](record-cron-id.md)), so teardown can delete the cron by id after a session continue / compaction blinds `CronList` to it. Reconcile ([`reconcile.md`](reconcile.md)) sweeps crons whose PR is terminal or whose slot is gone, and re-arms an open slot whose watcher stopped silently — loop-first, never with a recurring cron.
 
-**Session death.** Monitors and crons are both session-bound — a session that ends or hits its usage limit takes every watch with it. That is by design: nothing polls out of session, because a review is addressed only inside a session that carries the context to address it, never by a headless process replying context-blind.
+**Session death.** Watch loops and crons are both session-bound — a session that ends or hits its usage limit takes every watch with it. That is by design: nothing polls out of session, because a review is addressed only inside a session that carries the context to address it, never by a headless process replying context-blind.
 
 **A watcher belongs to the session that armed it.** Each slot records its owning session in `owner.json` ([`state-schemas.md`](state-schemas.md#ownerjson)), and recovery is owner-scoped: [`reconcile`](reconcile.md#triggers) re-arms a dead watcher only inside the session that armed it, and reports the rest as orphans it declined to touch. Starting a session therefore picks up nothing new — the same context argument that rules out a headless daemon rules out inheriting a stranger's PR, which would hand review work to a session that never saw the design. A PR whose owning session is gone stays unwatched until the user adopts it by name ([`adopt.md`](adopt.md)).
 
@@ -34,10 +34,10 @@ The skill recognizes its mode by inspecting `$ARGUMENTS` and falling back to on-
 | :---- | :------------ | :--- |
 | First arg matches `https?://github\.com/[^/]+/[^/]+/pull/\d+` | — | **bootstrap** → [`bootstrap.md`](bootstrap.md) |
 | `<slug> <pr-number>` | session dir for `<slug>` exists; slot's `watch.pid` is dead, or `--wake` passed | **tick** → [`contract.md`](contract.md) |
-| `<slug> <pr-number>` | session dir for `<slug>` exists; `watch.pid` names a live process and no `--wake` | **watch-status** — report the slot from on-disk state (`prs.json` state + head, newest `followup.log` tick line, monitor liveness, watermark floors). **Zero provider calls:** a live monitor owns the cadence, and the session never polls unwoken. |
+| `<slug> <pr-number>` | session dir for `<slug>` exists; `watch.pid` names a live process and no `--wake` | **watch-status** — report the slot from on-disk state (`prs.json` state + head, newest `followup.log` tick line, loop liveness, watermark floors). **Zero provider calls:** a live loop owns the cadence, and the session never polls unwoken. |
 | `<slug> <pr-number>` | session dir missing, `<slug>.stopped` exists (or the global kill file `~/.muggle-ai/muggle-do/polling.disabled`) | **absorb** — one line, nothing else ([`contract.md`](contract.md) Step 0) |
 | `<slug> <pr-number>` | session dir missing | **error:** "no session at `<path>`; pass a PR URL to start one" |
-| `stop` (optional `<slug>`) | — | **stop** → [`stop.md`](stop.md) — tear down monitor + cron, mark slot(s) `.stopped`; no slug stops everything and writes the kill file |
+| `stop` (optional `<slug>`) | — | **stop** → [`stop.md`](stop.md) — tear down loop + cron, mark slot(s) `.stopped`; no slug stops everything and writes the kill file |
 | `<pr-number>` alone | exactly one existing session contains it | **tick** or **watch-status** for that PR, by the same `watch.pid` gate |
 | `<pr-number>` alone | zero or multiple matches | **error:** ambiguous; list candidates and exit |
 | empty | — | **auto-track** → [`auto-track.md`](auto-track.md) |