@muggleai/works 4.12.4 → 4.13.1

package/plugin/skills/_shared/resolve-e2e-validation-context.md

@@ -0,0 +1,56 @@
+# Resolving the E2E Validation Context
+
+**How-to procedure.** Followed by any seeder that prepares a session for unattended Stage 6 (E2E acceptance) runs.
+
+**Goal:** resolve — once, while the user is present — everything Stage 6 needs to run without further prompts (validation strategy, local URL, backend status, Muggle Test project, test credentials, auth), and persist it to `state.md` so every later non-interactive run reads it instead of asking.
+
+The sections below are the steps in order: reuse an existing context if one is on disk, else detect what's resolvable silently, ask the rest in one question, and write the result. The final [`## Persisted fields`](#persisted-fields) section doubles as the schema the cycle reads back.
+
+## Reuse an existing context
+
+If a `## Pre-flight answers` block already exists for this working tree — the current session slot, or the most recent sibling session under `.muggle-do/sessions/*` — fire the [`autoReuseValidationContext`](../muggle-preferences/preference-gates/autoReuseValidationContext.md) gate before gathering anything:
+
+- `always` → copy the existing block into this session; skip the questionnaire.
+- `never` → ignore it; run the full gather below.
+- `ask` → prompt reuse-vs-re-gather.
+
+Run the gather only when no block exists or the user chose to re-gather.
+
+## Silent detection
+
+Resolve without prompting; use as questionnaire defaults:
+
+1. Dev server + backend health — per [`dev-server-readiness.md`](dev-server-readiness.md).
+2. Muggle Test MCP auth — `muggle-remote-auth-status`.
+3. Candidate projects — `muggle-remote-project-list`, ranked against the repo's dev URL and the PR title.
+4. Existing test-user secrets — `muggle-remote-secret-list` per candidate project (`managed_profile_email` / `managed_profile_password`).
+5. Auth0 tenant for local dev — grep the repo env file for `*AUTH0_DOMAIN*`.
+
+## Questions
+
+One `AskUserQuestion` for the validation subset, detected values as defaults. Canonical wording lives in [`../do/pre-flight.md`](../do/pre-flight.md) — reference, don't fork:
+
+- Validation strategy — pre-flight Q4
+- Local URL — pre-flight Q5 (defers to [`autoSelectLocalHost`](../muggle-preferences/preference-gates/autoSelectLocalHost.md))
+- Backend reachable — pre-flight Q6
+- Muggle Test project — pre-flight Q7 (defers to [`autoSelectProject`](../muggle-preferences/preference-gates/autoSelectProject.md))
+- Test-user credentials — pre-flight Q8
+- Re-auth Muggle Test MCP — pre-flight Q10
+
+The chosen **validation strategy is the standing decision for every cycle** — no per-tick re-prompt. It subsumes the [`autoE2ETest`](../muggle-preferences/preference-gates/autoE2ETest.md) gate (pre-flight Q13), meaningless in a loop: `local-e2e` runs Stage 6 each cycle; `unit-only` / `skip` stands down. The gate's `always` default makes `local-e2e` the default when a dev server is detected.
+
+Skip the forward-only questions (task scope, repo, branch, PR target, worktree, rebase) — the targeted repo and head branch are already checked out.
+
+## Persisted fields
+
+Write to `state.md` under a `## Pre-flight answers` block:
+
+- `Validation: <local-e2e | staging-replay | unit-only | skip>`
+- `Local URL: <url | N/A>`
+- `Backend status: <up | down | N/A>`
+- `Muggle Test project: <name> (<uuid>)`
+- `Test credentials: <existing | new | skip>`
+- `Auth status: <ok | re-authed | N/A>`
+- `Working tree: <path>` — the verified checkout the cycle runs against
+
+Missing any required field is a seeding bug: escalate with the session path and halt. Never silently skip E2E.

package/plugin/skills/_shared/telemetry-events/muggle-do-cycle.md

@@ -23,4 +23,4 @@ One per address-reviews invocation, regardless of outcome.
 - `"escalated"` — all reviews were ambiguous; no push.
 - `"mixed"` — both branches happened in the same invocation.
 - `"no-op"` — every input id was already in the escalated set; no work.
-- `"self-loop-skip"` — review was a synthetic wrapper around the agent's own reply (empty body + all line comments are replies). Cursor advanced silently; no work, no escalation.
+- `"self-loop-skip"` — review was a synthetic wrapper around the agent's own reply (every line comment is a reply carrying the loop marker `<!-- muggle-do:bot -->`). Cursor advanced silently; no work, no escalation.

package/plugin/skills/_shared/test-case-chain-readiness.md

@@ -0,0 +1,41 @@
+# Test Case Chain Readiness
+
+A test case may depend on prerequisite ("parent") test cases in the project's **test-plan graph** — e.g. "edit item" depends on "create item". Before generating or replaying the chosen test case, every ancestor in that chain must already have a ready script, or the run starts from missing state and fails for the wrong reason.
+
+This is the **graph the backend owns** — do not infer the chain from titles or `precondition` text. Read it from `muggle-remote-test-case-ancestors-get`.
+
+**Ready** = `muggle-remote-test-script-list` (with the ancestor's `testCaseId`) returns at least one replayable/succeeded script — the same bar Step 5 uses to offer replay.
+
+## Procedure
+
+Run once the target `testCaseId` is chosen and the local URL + services are confirmed (the generation calls below need `localUrl` and `cwd`).
+
+1. **Resolve the chain.** `muggle-remote-test-case-ancestors-get` with the target `testCaseId`. Response: `{ testCaseId, ancestors, orphan }`.
+   - `orphan: true` **or** empty `ancestors` → no prerequisites. Skip the rest; continue to Step 5.
+   - Otherwise `ancestors` is ordered **immediate-parent → root**. Reverse it to **root-first** so prerequisites are satisfied bottom-up.
+
+2. **For each ancestor, root-first:**
+   - Check readiness via `muggle-remote-test-script-list` (`projectId`, `testCaseId` = ancestor). Ready → skip to the next ancestor.
+   - Not ready → **generate its script only (never replay):**
+     1. `muggle-remote-test-case-get` for the ancestor.
+     2. Determine `freshSession` for that ancestor from its own content — same rules as Step 6.
+     3. `muggle-local-execute-test-generation` with the ancestor test case, `localUrl`, `cwd`, and a long `timeoutMs` (see Step 6's timeout guidance). Do **not** call `muggle-local-execute-replay`.
+     4. `muggle-local-publish-test-script` (`runId`, `cloudTestCaseId` = ancestor) so the generated script is promoted as that ancestor's canonical replay script — it now reads as ready for any case downstream.
+
+3. **All ancestors ready** → continue to Step 5 for the target test case.
+
+## When an ancestor's generation fails
+
+If an ancestor's generation does not reach `passed` (read it via `muggle-local-run-result-get`, never the execute stdout tail), the target's prerequisite state is missing. **Halt the chain** and surface which ancestor failed and why, then ask via `AskUserQuestion`:
+
+- **Stop** — don't run the target; the chain is broken.
+- **Proceed anyway** — run the target without the prerequisite (likely to fail; only if the user judges the state already exists).
+- **Give feedback** — invoke the `muggle-feedback` skill with the failed ancestor's `runId`.
+
+Do not silently skip a failed ancestor and run the target.
+
+## Notes
+
+- The target test case is **not** in its own `ancestors` list — only its prerequisites are.
+- Each ancestor is a single path to the root (one parent per node), so the reversed list has no duplicates; generate each at most once per session.
+- This walks the **full** chain to root, not just the immediate parent — a grandparent without a ready script is generated before its child.

package/plugin/skills/do/address-reviews.md

@@ -27,14 +27,18 @@ Read from `.muggle-do/sessions/<slug>/`:
 
 ## Procedure
 
-### Step 1 — Read every listed review off GitHub
+### Step 1 — Assemble the work set
 
-For each review id in the input:
+Two sources, combined into one batch (dedupe by comment id):
+
+**(a) The dispatched reviews.** For each review id in the input:
 
 - Fetch reviews per [`../_shared/github-cli-recipes/submitted-reviews.md`](../_shared/github-cli-recipes/submitted-reviews.md) (cursor 0; filter to the specific id).
 - Fetch its line comments per [`../_shared/github-cli-recipes/line-comments-for-review.md`](../_shared/github-cli-recipes/line-comments-for-review.md).
 
-Group into one combined batch.
+**(b) Unaddressed comments on every unresolved thread.** Fetch unresolved threads per [`../_shared/github-cli-recipes/unresolved-threads.md`](../_shared/github-cli-recipes/unresolved-threads.md). For each thread classified **unaddressed human comment** — newest comment lacks the loop marker `<!-- muggle-do:bot -->` ([`loop-signature.md`](../_shared/pr-followup-helpers/loop-signature.md)) and post-dates the loop's last marked reply — add it to the batch, even if its review predates the cursor. This is how a human thread follow-up (a marker-less reply) gets addressed. **Exclude** comments whose review id is in `last_seen.escalated_review_ids` — paused awaiting the user, not re-work.
+
+Group (a) and (b) into one combined batch.
 
 ### Step 2 — Classify each review
 
@@ -57,7 +61,7 @@ The user clarifies on GitHub by submitting a new review. The next watcher tick p
 
 ### Step 4 — Handle actionables (if any)
 
-If `actionable_review_ids` is empty, skip Steps 4 and 5; proceed to Step 6 (cursor + respawn). Otherwise:
+If `actionable_review_ids` is empty, skip the rest of Step 4 and Step 5; proceed to Step 5.5 (resolve-reminder) then Step 6. Otherwise:
 
 #### 4a. Flatten the work
 
@@ -75,7 +79,7 @@ Invoke [`unit-tests.md`](unit-tests.md). Cover the surface that just changed; re
 
 #### 4d. Run ONE E2E acceptance pass
 
-Invoke [`e2e-acceptance.md`](e2e-acceptance.md). One pass covering all related test cases for this PR, not one pass per comment. Use the `autoE2ETest` gate per its usual contract.
+Invoke [`e2e-acceptance.md`](e2e-acceptance.md). One pass covering all related test cases for this PR, not one per comment. The stage reads the persisted validation context (seeded by pre-flight or by bootstrap Step 6.5); a poll-only session with no context (e.g. auto-track) is reported `SKIPPED`. The persisted `Validation` strategy is the standing decision — no per-tick `autoE2ETest` prompt. See [`e2e-acceptance.md`](e2e-acceptance.md) Step 0 and [`../_shared/resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md).
 
 #### 4e. Create or update the PR
 
@@ -85,9 +89,7 @@ Invoke [`open-prs/update.md`](open-prs/update.md) (pass the PR URL + slug + exis
 
 Invoke [`per-comment-replies.md`](per-comment-replies.md) with the actionable reviews and the new SHA. One reply per comment, in its own thread, describing what was done for it.
 
-#### 4g. Run the resolve-reminder stage
-
-Invoke [`resolve-reminder.md`](resolve-reminder.md). Scans unresolved threads, classifies, and posts a top-level PR comment listing addressed-by-loop thread ids.
+(The resolve-reminder runs once per round in Step 5.5 below — not only after a push — so a round that pushed nothing still nudges addressed-but-unresolved threads.)
 
 ### Step 5 — Update session state
 
@@ -95,6 +97,10 @@ Invoke [`resolve-reminder.md`](resolve-reminder.md). Scans unresolved threads, c
 - `last_seen.last_pushed_sha` = the new head SHA (update.md already wrote this; verify)
 - `last_seen.reviewId` = max(input review ids ∪ last_seen.reviewId)
 
+### Step 5.5 — Resolve-reminder (runs every round)
+
+Invoke [`resolve-reminder.md`](resolve-reminder.md) once, regardless of whether this round pushed. It scans unresolved threads, finds those whose newest comment is loop-marked (addressed, awaiting resolve), and posts one top-level PR comment nudging the reviewer to resolve them — or stays silent if there are none. Threads with a newer human comment were already pulled into this round's work set in Step 1(b).
+
 ### Step 6 — Respawn the watcher
 
 Refresh PR state per [`../_shared/github-cli-recipes/pr-metadata.md`](../_shared/github-cli-recipes/pr-metadata.md). If the PR is now merged or closed:

package/plugin/skills/do/e2e-acceptance.md

@@ -44,11 +44,15 @@ You receive everything from `state.md` already — pre-flight resolved it:
 
 ## Your Job
 
-### Step 0: Consume pre-flight (no user questions)
+### Step 0: Consume the validation context (no user questions)
 
-Read `state.md`. Resolve [`autoE2ETest`](../muggle-preferences/preference-gates/autoE2ETest.md) first — `always` (default, including when unset) runs this stage. `ask` should already have been resolved by pre-flight Q13. Use the resolved validation mode (`local-e2e`, `staging-replay`, `unit-only`, `skip`) to pick execution vs early-exit behavior.
+Read `state.md`.
 
-Use `localUrl`, `projectId`, and `worktreePath` from `state.md`. Missing any → pre-flight bug; escalate with the session path and halt; do not ask the user.
+**No `## Pre-flight answers` block at all** → the session was seeded poll-only (e.g. by auto-track, [`../muggle-pr-followup/auto-track.md`](../muggle-pr-followup/auto-track.md)). Treat `Validation` as `skip`: emit a `SKIPPED` report with reason `no validation context seeded` and exit cleanly. The watcher owns no E2E context by design; "no context" is a clean skip, not a failure.
+
+Otherwise the block was seeded by pre-flight or bootstrap per [`../_shared/resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md) — read it the same way regardless of seeder. The persisted `Validation` field (`local-e2e`, `staging-replay`, `unit-only`, `skip`) picks execution vs early-exit below. In a forward run, [`autoE2ETest`](../muggle-preferences/preference-gates/autoE2ETest.md) `ask` was resolved by pre-flight Q13; in a watcher cycle there is no per-tick pre-flight, so `Validation` **is** the standing decision — don't re-resolve `ask`.
+
+For a `local-e2e` block, use `localUrl`, `projectId`, and the working-tree path from `state.md`. Missing any → seeding bug; escalate with the session path and halt; do not ask the user.
 
 ### Step 0.5: Pre-flight verification probes
 

package/plugin/skills/do/per-comment-replies.md

@@ -36,9 +36,12 @@ Reply body uses the template in [`../muggle-pr-followup/output-templates/inline-
 
 ```
 Addressed in <short-sha>: <one-line summary of the change made for THIS comment>.
+
+<!-- muggle-do:bot -->
+🤖 _Automated reply from muggle-do._
 ```
 
-`<short-sha>` is the first 7 chars of `new_sha`. The body must contain the literal `<short-sha>` substring — the resolve-reminder stage greps for it to classify threads as addressed-by-loop.
+`<short-sha>` is the first 7 chars of `new_sha`; the body must contain that substring so the resolve-reminder stage knows which push addressed the thread. The trailing signature block is mandatory — its `<!-- muggle-do:bot -->` marker is what identifies the reply as loop-authored (see [`../_shared/pr-followup-helpers/loop-signature.md`](../_shared/pr-followup-helpers/loop-signature.md)).
 
 ### Step 3 — Handle review-body-only comments
 
@@ -46,6 +49,9 @@ If an actionable review has a non-empty `body` and **zero** line comments, GitHu
 
 ```
 Re: review #<review_id> — addressed in <short-sha>: <one-line summary>.
+
+<!-- muggle-do:bot -->
+🤖 _Automated reply from muggle-do._
 ```
 
 Posted per [`../_shared/github-cli-recipes/top-level-comment.md`](../_shared/github-cli-recipes/top-level-comment.md). Fires at most once per actionable review-with-no-line-comments. Does not fire if the review has line comments — Step 2 covers those.
@@ -58,4 +64,4 @@ Posted per [`../_shared/github-cli-recipes/top-level-comment.md`](../_shared/git
 ## Invariants
 
 - One reply per line comment. No per-review summary reply anywhere.
-- Every reply body contains the new SHA's 7-char prefix — the resolve-reminder stage greps for it.
+- Every reply body contains the new SHA's 7-char prefix (which push addressed it) and ends with the loop signature block — the `<!-- muggle-do:bot -->` marker, not the author login, is what identifies loop-authored comments.

package/plugin/skills/do/resolve-reminder.md

@@ -1,11 +1,11 @@
 # Resolve-Reminder Stage
 
-A `/muggle-do` stage that runs in **address-reviews mode only**, after per-comment inline replies have been posted. Scans every unresolved comment thread on the PR, classifies them, and posts ONE top-level PR comment listing the threads the loop addressed in this push.
+A `/muggle-do` stage that runs in **address-reviews mode only**, near the end of each review round. Scans every unresolved comment thread on the PR, classifies them by the loop signature, and posts ONE top-level PR comment listing the threads the loop has addressed that are still unresolved with no newer human reply.
 
-Runs zero or one times per `/muggle-do` invocation:
+Runs once per `/muggle-do` address-reviews invocation (one review round):
 
-- Runs when at least one actionable review was processed (i.e. the cycle actually pushed).
-- Does not run when the entire input batch was ambiguous (no push, nothing to remind about).
+- Runs every round, whether or not this round pushed — it nudges **all** still-unresolved loop-addressed threads, not only ones touched by this push.
+- Posts a comment only when at least one such thread exists; otherwise silent.
 - Does not run in the forward pipeline (a fresh PR has no review threads to remind about).
 
 ## Turn preamble (inline within `/muggle-do` cycle)
@@ -28,33 +28,31 @@ If the API call fails, log the error to `followup.log` and skip the stage. Do no
 
 ### Step 2 — Classify each thread
 
-For each unresolved thread, walk its comments in chronological order. Classify by the **first match** that applies:
+Per [`../_shared/github-cli-recipes/unresolved-threads.md`](../_shared/github-cli-recipes/unresolved-threads.md): walk each thread's comments in `createdAt` order and classify by the loop marker `<!-- muggle-do:bot -->` ([`../_shared/pr-followup-helpers/loop-signature.md`](../_shared/pr-followup-helpers/loop-signature.md)), not by `author.login`:
 
-- **Addressed by the loop** — at least one comment authored by the loop user **and** that comment's body cites a SHA prefix in `last_seen.pushed_shas[]`. Bodies use the form *"Addressed in `<short-sha>`: ..."* per [`../muggle-pr-followup/output-templates/inline-reply.md`](../muggle-pr-followup/output-templates/inline-reply.md), so a substring match on any `pushed_shas[i][:7]` works.
-- **Addressed by a human** — at least one comment authored by a non-loop-user identity created after the original comment's timestamp, and no addressed-by-loop signal.
-- **Not addressed** — neither of the above.
+- **Addressed, awaiting resolve** — the **newest** comment carries the marker. The loop replied and nothing newer is waiting. These feed the reminder.
+- **Unaddressed human comment** — the newest comment lacks the marker and post-dates the loop's last marked reply (or there is no loop reply yet). The address-reviews round handles these as work (Step 1 sweep), not the reminder.
+- **Not addressed** — indeterminate.
 
-The classification considers only the unresolved threads' comments. Do not cross-reference timeline events from outside the threads.
+Consider only the threads' own comments. Do not cross-reference timeline events from outside the threads.
 
 ### Step 3 — Build the resolve-reminder list
 
-Collect the thread `databaseId` of every thread classified as **addressed by the loop in this push** (i.e. citing a SHA in `pushed_shas[]` where that SHA was added by the current invocation; older SHAs were already covered by prior cycles' reminders).
-
-Note: the watcher does not maintain a "addressed-this-cycle" set; this stage derives it by comparing thread comments to the most-recent appended SHA. The simplest deterministic rule: include a thread iff at least one of its bot replies cites the **most recent** `pushed_shas[-1]`. Earlier SHAs were already addressed in past reminders.
+Collect the thread `databaseId` of every thread classified **addressed, awaiting resolve** in Step 2 — every still-unresolved thread whose newest comment is loop-marked, regardless of which push addressed it. A thread stays on the list across rounds until the reviewer resolves it or replies; a human reply moves it to **unaddressed human comment** (into the round's work set, Step 1), so it drops off the reminder automatically.
 
 ### Step 4 — Post the top-level reminder comment
 
-If the resolve-reminder list is non-empty, post **one** top-level PR comment using the template in [`../muggle-pr-followup/output-templates/resolve-reminder.md`](../muggle-pr-followup/output-templates/resolve-reminder.md) per [`../_shared/github-cli-recipes/top-level-comment.md`](../_shared/github-cli-recipes/top-level-comment.md).
+If the resolve-reminder list is non-empty, post **one** top-level PR comment using the template in [`../muggle-pr-followup/output-templates/resolve-reminder.md`](../muggle-pr-followup/output-templates/resolve-reminder.md) per [`../_shared/github-cli-recipes/top-level-comment.md`](../_shared/github-cli-recipes/top-level-comment.md). The comment carries the loop signature, so a later round's scan won't read it back as a human comment.
 
-If the list is empty (the push didn't end up addressing any threads — e.g. the actionable work was on lines that had no comment threads), post **nothing**. Still emit telemetry so the stage's run is observable.
+If the list is empty, post **nothing**. Still emit telemetry so the stage's run is observable.
 
 ### Step 5 — Emit telemetry
 
 Emit one event per [`../_shared/telemetry-events/muggle-do-resolve-reminder.md`](../_shared/telemetry-events/muggle-do-resolve-reminder.md). Include:
 
-- `addressed_by_loop` — count of threads added to the reminder list in Step 3.
-- `addressed_by_human` — count from Step 2's other category.
-- `not_addressed` — count from Step 2's "not addressed" category.
+- `addressed_by_loop` — count of threads on the reminder list (Step 3; newest comment loop-marked).
+- `addressed_by_human` — count of threads with an unaddressed human comment (newest comment unmarked; handled by the round's Step 1 sweep, not the reminder).
+- `not_addressed` — count from Step 2's indeterminate category.
 - `comment_posted` — true iff Step 4 actually posted a comment.
 
 ## Failure modes
@@ -66,5 +64,5 @@ The one exception: do not silently swallow a `gh pr comment` failure if Step 4 r
 ## Invariants
 
 - Telemetry fires once per invocation, even when no comment is posted.
-- The reminder only covers threads addressed by the **most recent** push — older SHAs were covered by prior cycles' reminders.
+- The reminder covers **every** still-unresolved thread whose newest comment is loop-marked — not just the most recent push. A thread leaves the reminder only when the reviewer resolves it or replies (a reply routes it to the round's work set).
 - This stage suggests; it does not resolve threads on the reviewer's behalf.

package/plugin/skills/muggle-pr-followup/CLAUDE.md

@@ -4,8 +4,9 @@ This folder holds the watcher loop for PR review follow-ups. The watcher is a **
 
 ## Files in this folder
 
-- [`SKILL.md`](SKILL.md) — public entry. Smart-inference routing between bootstrap mode (URL input) and tick mode (slug + PR number). Read first.
-- [`bootstrap.md`](bootstrap.md) — the bootstrap procedure (one-shot non-interactive seed + watcher dispatch).
+- [`SKILL.md`](SKILL.md) — public entry. Routing between bootstrap (URL input), tick (slug + PR number), and auto-track (no args). Read first.
+- [`auto-track.md`](auto-track.md) — the no-args procedure: discovers PRs pushed this session (any repo) and seeds one poll-only watcher each. Seeds no E2E context — the watcher only watches.
+- [`bootstrap.md`](bootstrap.md) — the bootstrap procedure (asks once for the E2E validation context, seeds state, dispatches the first watcher).
 - [`contract.md`](contract.md) — the watcher per-tick procedure (poll → dispatch → exit).
 - [`state-schemas.md`](state-schemas.md) — canonical JSON shapes of session state files.
 - [`output-templates.md`](output-templates.md) — TOC of message templates; per-group files in `output-templates/`.
@@ -14,6 +15,7 @@ This folder holds the watcher loop for PR review follow-ups. The watcher is a **
 
 Shared with other skills, under `../_shared/`:
 
+- [`resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md) — the E2E validation-context contract bootstrap seeds into `state.md` (Step 6.5) and `do/e2e-acceptance.md` consumes.
 - [`pr-followup-helpers.md`](../_shared/pr-followup-helpers.md) — TOC of allow-list / reply-routing / classify; per-section files in `_shared/pr-followup-helpers/`. Called by `/muggle-do`, not by this folder.
 - [`telemetry-emit.md`](../_shared/telemetry-emit.md) — how to emit a telemetry event.
 - [`telemetry-events.md`](../_shared/telemetry-events.md) — TOC of canonical event shapes; per-event files in `_shared/telemetry-events/`.
@@ -22,4 +24,4 @@ Shared with other skills, under `../_shared/`:
 Caller-specific, under `../do/`:
 
 - [`open-prs.md`](../do/open-prs.md) — TOC for the create-or-update PR stage; per-mode files in `do/open-prs/`.
-- [`resolve-reminder.md`](../do/resolve-reminder.md) — `/muggle-do`'s post-replies stage that posts the resolve-reminder top-level comment.
+- [`resolve-reminder.md`](../do/resolve-reminder.md) — `/muggle-do`'s per-round stage that nudges the reviewer to resolve addressed-but-still-open threads.

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

@@ -1,6 +1,6 @@
 ---
 name: muggle-pr-followup
-description: Watcher loop for PR review follow-ups. Polls one PR for new submitted reviews and dispatches `/muggle-do` (address-reviews mode) when there are any. A dumb pipe — no classification, no cycle execution, no replies. Use `/loop 1m /muggle:muggle-pr-followup <slug> <pr-number>` for ongoing polling, or `/muggle:muggle-pr-followup <pr-url>` to bootstrap a fresh watcher on an existing PR.
+description: Watcher loop for PR review follow-ups. Polls one PR for new submitted reviews and dispatches `/muggle-do` (address-reviews mode) when there are any. A dumb pipe — no classification, no cycle execution, no replies. Run it with no args to auto-track every PR you pushed this session (poll-only watchers, any repo). Use `/loop 1m /muggle:muggle-pr-followup <slug> <pr-number>` for ongoing polling, or `/muggle:muggle-pr-followup <pr-url>` to bootstrap a fresh watcher on an existing PR (asks once for the E2E validation context, then runs unattended).
 disable-model-invocation: true
 ---
 
@@ -16,7 +16,7 @@ A watcher that babysits one open PR's review thread. Polls for new submitted rev
 
 ## Routing
 
-The skill recognizes two modes by inspecting `$ARGUMENTS` and falling back to on-disk state. It never runs procedure inline — it identifies the mode and routes to the appropriate procedure file.
+The skill recognizes its mode by inspecting `$ARGUMENTS` and falling back to on-disk state. It never runs procedure inline — it identifies the mode and routes to the appropriate procedure file.
 
 | Input | On-disk check | Mode |
 | :---- | :------------ | :--- |
@@ -25,7 +25,8 @@ The skill recognizes two modes by inspecting `$ARGUMENTS` and falling back to on
 | `<slug> <pr-number>` | session dir missing | **error:** "no session at `<path>`; pass a PR URL to start one" |
 | `<pr-number>` alone | exactly one existing session contains it | **tick** for that PR |
 | `<pr-number>` alone | zero or multiple matches | **error:** ambiguous; list candidates and exit |
-| empty / `help` / `?` | — | **help:** list active loops per [`output-templates/help.md`](output-templates/help.md) |
+| empty | — | **auto-track** → [`auto-track.md`](auto-track.md) |
+| `help` / `?` | — | **help:** list active loops per [`output-templates/help.md`](output-templates/help.md) |
 
 Bootstrap accepts three optional trailing flags:
 
@@ -33,6 +34,12 @@ Bootstrap accepts three optional trailing flags:
 - `--resume` — opt in to reusing an existing session slot (default is refuse on conflict)
 - `--forward-only` — pin cursor past existing reviews (skip history). Default is cursor 0, which processes prior submitted reviews on the first tick.
 
+## Preferences
+
+| Preference | Gate |
+| :--------- | :--- |
+| `autoReuseValidationContext` | Bootstrap reuses an existing validation context instead of re-asking — fired in the Step 6.5 gather per [`../_shared/resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md) |
+
 ## Folder TOC
 
 See [`CLAUDE.md`](CLAUDE.md) for the one-line index of every file in this folder.

package/plugin/skills/muggle-pr-followup/auto-track.md

@@ -0,0 +1,91 @@
+# Auto-Track Procedure
+
+The procedure for the **auto-track mode** of `muggle-pr-followup` — invoked when the skill is dispatched with **no arguments**. Routing is in [`SKILL.md`](SKILL.md#routing).
+
+Auto-track discovers the PRs you pushed or opened during this Claude Code session — across **any repo** — and starts one **poll-only watcher** per PR. The watcher only watches: it seeds nothing about E2E. Running and posting E2E is `/muggle-do`'s job; a watcher with no validation context yields a `SKIPPED` E2E verdict when `/muggle-do` runs — see [`../do/e2e-acceptance.md`](../do/e2e-acceptance.md) Step 0.
+
+## Turn preamble
+
+```
+**muggle-pr-followup auto-track** — tracking PRs from this session.
+```
+
+## Input
+
+`$ARGUMENTS` is empty.
+
+## Procedure
+
+### Step 1 — Discover candidate PRs from session context
+
+A PR counts as **pushed this session** if, earlier in this conversation, you:
+
+- opened it (`gh pr create`), or
+- pushed commits to a branch that has an open PR, or
+- acted on it as the active PR (its URL appeared and you worked it).
+
+Collect each candidate's canonical URL (`https://github.com/<owner>/<repo>/pull/<n>`); candidates may span repos.
+
+### Step 2 — Decide confident vs. uncertain
+
+- **Confident** — context clearly identifies one or more PRs pushed this session. Use that set; go to Step 4. **Do not prompt.**
+- **Uncertain** — nothing clearly attributable, or several candidates are plausible. Go to Step 3.
+
+### Step 3 — Picker (uncertain only)
+
+Build a candidate list from the Step 1 URLs, plus — if the current working directory is a git repo — `gh pr list --author @me --state open --json number,title,url,headRefName` for that repo. Present an `AskUserQuestion` **multi-select** picker of the candidates (PR number + title + repo).
+
+- Empty selection → exit with a one-line note (`No PRs selected; nothing to track.`). Write nothing.
+- One or more selected → use them as the track list and go to Step 4.
+
+### Step 4 — Seed one poll-only watcher per PR
+
+For each PR URL in the track list, run the [`bootstrap.md`](bootstrap.md) procedure with these auto-track overrides:
+
+- **Skip Step 3 (verify working tree).** The PR's checkout need not be the current tree. If you know which directory it was pushed from, record `Working tree: <path>` in `state.md`; else omit it — `/muggle-do` resolves the tree when it runs.
+- **Skip Step 6.5 (E2E validation context).** The watcher owns no E2E concern; do **not** write a `## Pre-flight answers` block.
+- **Existing slot → skip silently** (never the slot-conflict abort); add it to the *skipped* list.
+- **`caller = "auto-track"`** in the bootstrap telemetry event.
+
+Everything else is unchanged: URL parse, metadata + terminal-PR abort, slug, cursor 0 (process prior reviews on the first tick), and the `prs.json`/`last_seen.json`/`state.md` writes minus the pre-flight block.
+
+### Step 5 — Print the summary
+
+```
+muggle-pr-followup auto-track
+
+Tracked (new):
+  <slug> → <owner>/<repo>#<n>
+  ...
+  (or "none")
+Already tracking (skipped):
+  <slug> → <owner>/<repo>#<n>
+  ...
+  (or "none")
+
+Dispatching:
+  /loop 1m /muggle:muggle-pr-followup <slug> <n>
+  ...
+```
+
+Print the summary **before** the `/loop` dispatches so it stays visible.
+
+### Step 6 — Dispatch the watchers
+
+As the last action of the turn, emit one `/loop` line per **newly tracked** PR (not the skipped ones):
+
+```
+/loop 1m /muggle:muggle-pr-followup <slug> <n>
+```
+
+Each registers an independent cron — the N-independent-watchers model from [`SKILL.md`](SKILL.md).
+
+### Step 7 — Emit telemetry
+
+One bootstrap event per **newly tracked** PR per [`../_shared/telemetry-events/pr-followup-bootstrap.md`](../_shared/telemetry-events/pr-followup-bootstrap.md), with `caller = "auto-track"`. Fire-and-forget per [`../_shared/telemetry-emit.md`](../_shared/telemetry-emit.md). Skipped PRs emit nothing.
+
+## Invariants
+
+- **Tracking depends only on the PR.** No E2E context is gathered, prompted for, or required.
+- **Idempotent.** Existing slots are skipped; re-running never double-tracks.
+- **No-op is silent.** Empty discovery followed by an empty picker writes nothing and dispatches nothing.

package/plugin/skills/muggle-pr-followup/bootstrap.md

@@ -2,7 +2,7 @@
 
 The procedure for the **bootstrap mode** of `muggle-pr-followup` — invoked when a user dispatches the skill with a GitHub PR URL. Routing into this mode is documented in [`SKILL.md`](SKILL.md#routing).
 
-Bootstrap is **non-interactive**: it runs straight through, prompts the user for nothing, and ends with the first watcher dispatched. The first review the watcher sees triggers `/muggle-do`, where working-tree validation surfaces (via the existing E2E stage / muggle-test).
+Bootstrap asks **one** questionnaire — the E2E validation context the loop will reuse — then runs through to the first watcher dispatch. The user is present at launch, so this is the only place to gather it; every later tick reads it from `state.md`. Without it, a URL-bootstrapped watcher has no `localUrl`/`projectId` and Stage 6 hard-halts instead of running E2E.
 
 ## Turn preamble
 
@@ -44,13 +44,19 @@ Default: `<repo>-pr<n>` (e.g. `muggle-ai-works-pr154`). Override: `--slug=<name>
 If `.muggle-do/sessions/<slug>/` exists:
 
 - Without `--resume` → exit with the slot-conflict abort. Both remedies (delete + re-run, or pass `--resume`) are spelled out in the message.
-- With `--resume` → refresh `prs.json[0].head_sha` to the current `headRefOid` from Step 2. Leave `last_seen.json`, `state.md`, and everything else untouched. Skip to Step 8 (no need to re-seed; no need to refetch the cursor).
+- With `--resume` → refresh `prs.json[0].head_sha` to the current `headRefOid` from Step 2; leave `last_seen.json` and the cursor untouched. If `state.md` already has a `## Pre-flight answers` block, skip to Step 8; if not (older session), run Step 6.5 to backfill it, then skip to Step 8.
 
 ### Step 6 — Resolve the initial cursor
 
 - **Default (no `--forward-only`):** cursor is `0`. The watcher will pick up every existing submitted review on its first tick. This matches the common case where the user opened the PR, left review comments they want addressed, and is now running bootstrap.
 - **With `--forward-only`:** fetch reviews per [`../_shared/github-cli-recipes/submitted-reviews.md`](../_shared/github-cli-recipes/submitted-reviews.md), then take `max(id)`. The watcher only acts on later submissions. Use when bootstrapping a PR with stale/already-handled prior reviews you don't want re-processed.
 
+### Step 6.5 — Resolve E2E validation context
+
+The only step that may prompt the user. Run the gather in [`../_shared/resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md): reuse an existing context if one is found (gated by `autoReuseValidationContext`), else silent detection + one `AskUserQuestion` (strategy, local URL, backend, project, credentials, re-auth). Record Step 3's verified working tree as `Working tree`.
+
+Capture the fields for Step 7. Do **not** run E2E now — the first watcher tick that dispatches `/muggle-do` does that.
+
 ### Step 7 — Seed state files
 
 Identify the loop user once per [`../_shared/github-cli-recipes/loop-user-identity.md`](../_shared/github-cli-recipes/loop-user-identity.md); cache in `state.md`.
@@ -61,7 +67,7 @@ Write under `.muggle-do/sessions/<slug>/`:
 
 **`last_seen.json`** — see [`state-schemas.md`](state-schemas.md#last_seenjson). One key (`"<owner>/<repo>#<n>"`), `reviewId` from Step 6, `last_pushed_sha: null`, `idle_tick_count: 0`, `cycles_completed: 0`, `escalated_review_ids: []`, `pushed_shas: []`.
 
-**`state.md`** — see [`state-schemas.md`](state-schemas.md#statemd). `Bootstrapped from URL: yes`. Cache the loop-user login.
+**`state.md`** — see [`state-schemas.md`](state-schemas.md#statemd). `Bootstrapped from URL: yes`. Cache the loop-user login. Append the `## Pre-flight answers` block with the fields resolved in Step 6.5, per [`../_shared/resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md#persisted-fields).
 
 Do **not** write `cycle.json` or `requirements.md` — those files are no longer part of the session slot.
 
@@ -85,6 +91,7 @@ Emit one event per [`../_shared/telemetry-events/pr-followup-bootstrap.md`](../_
 
 ## Invariants
 
-- All state writes happen in Step 7 — earlier aborts leave nothing on disk.
+- Step 6.5 is the **only** user prompt. If the user cancels it, abort leaving nothing on disk.
+- All state writes happen in Step 7 — earlier aborts (including a cancelled Step 6.5) leave nothing on disk.
 - If Step 7 fails mid-write, surface the OS error and tell the user to `rm -rf <slot>` and re-run; do not dispatch the watcher.
 - Bootstrap never retries.

package/plugin/skills/muggle-pr-followup/output-templates/help.md

@@ -1,6 +1,6 @@
 # Help output
 
-For `/muggle:muggle-pr-followup` with no args, or with `help` / `?`:
+For `/muggle:muggle-pr-followup help` or `?` (no args runs **auto-track** instead — see [`../auto-track.md`](../auto-track.md)):
 
 ```
 muggle-pr-followup — watcher loop for PR review follow-ups
@@ -11,6 +11,7 @@ Active loops:
   (or "no active loops")
 
 Usage:
+  /muggle:muggle-pr-followup                     → auto-track every PR you pushed this session
   /muggle:muggle-pr-followup <pr-url>            → bootstrap a new loop
   /muggle:muggle-pr-followup <slug> <pr-number>  → run one tick (called by /loop)
   /muggle:muggle-pr-followup <pr-number>         → run one tick (slug inferred from on-disk state)

package/plugin/skills/muggle-pr-followup/output-templates/inline-reply.md

@@ -4,9 +4,12 @@ Posted via `gh api .../comments/<comment-id>/replies` per cycle, one per line co
 
 ```
 Addressed in <short-sha>: <one-line summary of the change made for THIS comment>.
+
+<!-- muggle-do:bot -->
+🤖 _Automated reply from muggle-do._
 ```
 
-`<short-sha>` is the first 7 chars of the new SHA. The body must contain that substring — the resolve-reminder stage greps for it to classify threads as addressed-by-loop.
+`<short-sha>` is the first 7 chars of the new SHA; the body must contain that substring so the resolve-reminder stage knows *which push* addressed the thread. The trailing signature block — defined in [`../../_shared/pr-followup-helpers/loop-signature.md`](../../_shared/pr-followup-helpers/loop-signature.md) — is mandatory; its `<!-- muggle-do:bot -->` marker is what identifies the comment as loop-authored.
 
 ## Top-level fallback (review-body-only)
 
@@ -14,4 +17,7 @@ When an actionable review has a non-empty body but zero line comments, GitHub ha
 
 ```
 Re: review #<review_id> — addressed in <short-sha>: <one-line summary>.
+
+<!-- muggle-do:bot -->
+🤖 _Automated reply from muggle-do._
 ```

package/plugin/skills/muggle-pr-followup/output-templates/resolve-reminder.md

@@ -1,12 +1,15 @@
 # Resolve-reminder top-level PR comment
 
-Posted via `gh pr comment` after the resolve-reminder stage scans threads. Only when at least one addressed-by-loop thread exists.
+Posted via `gh pr comment` once per review round, when at least one unresolved thread is addressed-by-loop with no newer human reply.
 
 ```
-I addressed these threads in <short-sha> — mark them resolved when satisfied:
+These threads are addressed and still open — mark them resolved if satisfied, or reply if more is needed:
 - #<thread-id-1>
 - #<thread-id-2>
 - ...
+
+<!-- muggle-do:bot -->
+🤖 _Automated reply from muggle-do._
 ```
 
-If `addressed_by_loop == 0`, no comment is posted (silent).
+If no such thread exists, no comment is posted (silent). The trailing signature block ([`loop-signature.md`](../../_shared/pr-followup-helpers/loop-signature.md)) keeps the loop from later mistaking its own reminder for a human comment.

package/plugin/skills/muggle-pr-followup/state-schemas.md

@@ -60,9 +60,21 @@ Free-form markdown. No required schema beyond a few well-known fields the caller
 **Created:** <ISO-8601>
 **Bootstrapped from URL:** <yes | no>
 
+## Pre-flight answers
+
+- Validation: <local-e2e | staging-replay | unit-only | skip>
+- Local URL: <url | N/A>
+- Backend status: <up | down | N/A>
+- Muggle Test project: <name> (<uuid>)
+- Test credentials: <existing | new | skip>
+- Auth status: <ok | re-authed | N/A>
+- Working tree: <path>
+
 ...free-form notes added by /muggle-do and bootstrap...
 ```
 
+The `## Pre-flight answers` block is the **E2E validation context** consumed by `do/e2e-acceptance.md` Step 0 — seeded by bootstrap (Step 6.5) or by pre-flight's output block. Fields: [`../_shared/resolve-e2e-validation-context.md`](../_shared/resolve-e2e-validation-context.md#persisted-fields).
+
 The watcher does **not** read or write `state.md`. Only bootstrap, `/muggle-do`, and the caller's stages touch it.
 
 ## `followup.log`

package/plugin/skills/muggle-preferences/ops/configure.md

@@ -26,7 +26,7 @@ you can tell me which (if any) should instead be set to `never`.
 For each option: label = key name, description = first paragraph of `preference-gates/<key>.md`. Multi-select question text = `Which of these should auto-proceed (set to "always")?`; selected = `always`.
 
 - `multiSelect: true`, `header: "Auth & session"` — `autoLogin`, `autoSelectProject`, `checkForUpdates`, `verboseOutput`
-- `multiSelect: true`, `header: "Test setup"` — `autoSelectLocalHost`, `autoDetectChanges`
+- `multiSelect: true`, `header: "Test setup"` — `autoSelectLocalHost`, `autoDetectChanges`, `autoReuseValidationContext`
 - `multiSelect: true`, `header: "Test run"` — `showElectronBrowser`, `openTestResultsAfterRun`, `autoPublishLocalResults`
 - `multiSelect: true`, `header: "Suggestions & PR"` — `suggestRelatedUseCases`, `suggestRelatedTestCases`, `postPRVisualWalkthrough`, `autoCreatePR`
 - `multiSelect: true`, `header: "Branch hygiene"` — `autoUseWorktree`, `autoRebase`, `autoCleanup`

package/plugin/skills/muggle-preferences/preference-gates/autoReuseValidationContext.md

@@ -0,0 +1,11 @@
+# `autoReuseValidationContext`
+
+Reuse an existing E2E validation context (a prior session's `## Pre-flight answers` block for this working tree) instead of asking the validation questions again. Substitute `{contextSource}` (the slug + age of the block being offered). Fires only when such a block exists; with none, the calling skill runs the full gather and never reaches this gate.
+
+**Picker 1** — header `Validation context`, question `"Reuse the validation context from {contextSource}?"`
+- `Reuse it` — `Same local URL, project, strategy, and credentials as {contextSource}.` → copy the block into this session
+- `Re-gather` — `Ask the validation questions fresh.` → run the full gather
+
+**Silent action**
+- `always` → `Reusing validation context from {contextSource}`
+- `never` → no footer; the gather is the visible step.