@muggleai/works 4.12.4 → 4.13.0

package/dist/{chunk-JNI7INIO.js → chunk-QUWM3JQY.js}

@@ -1,4 +1,4 @@
-import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, isFirstRun, writePreferences, DEFAULT_PREFERENCES, getDataDir, PREFERENCES_FILE_NAME, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, verifyFileChecksum, calculateFileChecksum, initTelemetry, Surface, ServiceName, track, EventName, getQaTools, getLocalQaTools, performLogout, performLogin, toolRequiresAuth, getCallerCredentials, hasShownDisclosure, getDisclosureCopy, markDisclosureShown, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, buildElectronAppChecksumsUrl, __require } from './chunk-CPF6AR2I.js';
+import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, isFirstRun, writePreferences, DEFAULT_PREFERENCES, getDataDir, PREFERENCES_FILE_NAME, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, verifyFileChecksum, calculateFileChecksum, initTelemetry, Surface, ServiceName, track, EventName, getQaTools, getLocalQaTools, performLogout, performLogin, toolRequiresAuth, getCallerCredentials, hasShownDisclosure, getDisclosureCopy, markDisclosureShown, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, buildElectronAppChecksumsUrl, __require } from './chunk-TWILR37J.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { v4 } from 'uuid';
@@ -736,7 +736,7 @@ async function resolveGsScreenshotUrls(report, opts) {
     if (gsUrls.length === 0) {
       return report;
     }
-    const mcps = await import('./src-YR5UKLPC.js');
+    const mcps = await import('./src-BD5AM6OH.js');
     const credentials = await mcps.getCallerCredentialsAsync();
     if (!credentials.bearerToken && !credentials.apiKey) {
       stderrWrite(

package/dist/{chunk-CPF6AR2I.js → chunk-TWILR37J.js}

@@ -3611,6 +3611,15 @@ var EventName;
   EventName2["SystemDisclosureShown"] = "system.disclosure_shown";
 })(EventName || (EventName = {}));
 var MuggleEntityIdSchema = z.string().uuid();
+var RunEnvironment = /* @__PURE__ */ ((RunEnvironment2) => {
+  RunEnvironment2["Local"] = "local";
+  RunEnvironment2["Remote"] = "remote";
+  return RunEnvironment2;
+})(RunEnvironment || {});
+var RunEnvironmentSchema = z.enum(["local" /* Local */, "remote" /* Remote */]);
+var RunEnvironmentInputSchema = RunEnvironmentSchema.optional().describe(
+  "Environment lane for the run: 'local' (developer localhost) or 'remote' (deployed). Selects which versioned runSettings/credentials lane the cloud resolves. Omit for remote (default)."
+);
 var LocalExecutionContextInputSchema = z.object({
   originalUrl: z.string().url().describe("Original local URL used during local execution (typically localhost)"),
   productionUrl: z.string().url().describe("Cloud production URL for the test case"),
@@ -3627,6 +3636,7 @@ var LocalRunUploadInputSchema = z.object({
   useCaseId: MuggleEntityIdSchema.describe("Use case ID (UUID) for the local run"),
   testCaseId: MuggleEntityIdSchema.describe("Test case ID (UUID) for the local run"),
   runType: z.enum(["generation", "replay"]).describe("Type of local run to upload"),
+  runEnvironmentType: RunEnvironmentInputSchema,
   productionUrl: z.string().url().describe("Cloud production URL associated with the run"),
   localExecutionContext: LocalExecutionContextInputSchema.describe("Local execution metadata"),
   actionScript: z.array(z.unknown()).min(1).describe("Generated action script steps from local execution"),
@@ -3906,6 +3916,7 @@ var WorkflowStartTestScriptGenerationInputSchema = z.object({
   precondition: z.string().min(1).describe("Preconditions"),
   instructions: z.string().min(1).describe("Step-by-step instructions"),
   expectedResult: z.string().min(1).describe("Expected result"),
+  runEnvironmentType: RunEnvironmentInputSchema,
   workflowParams: WorkflowParamsSchema
 });
 var WorkflowStartTestScriptGenerationBulkInputSchema = z.object({
@@ -4403,42 +4414,16 @@ function slimEntry(raw) {
   if (raw.latestWorkflowRun?.id) slim.latestWorkflowRunId = raw.latestWorkflowRun.id;
   return slim;
 }
-function aggregateByStatus(entries) {
-  const counts = {};
-  for (const entry of entries) {
-    const status = entry.status ?? UNKNOWN_STATUS;
-    counts[status] = (counts[status] ?? 0) + 1;
-  }
-  return counts;
-}
-function sortRuns(runs, sortBy, sortOrder) {
-  const sign = sortOrder === "asc" ? 1 : -1;
-  return [...runs].sort((a, b) => {
-    const av = a[sortBy];
-    const bv = b[sortBy];
-    if (av === void 0 && bv === void 0) return 0;
-    if (av === void 0) return 1;
-    if (bv === void 0) return -1;
-    if (av < bv) return -1 * sign;
-    if (av > bv) return 1 * sign;
-    return 0;
-  });
-}
-function mapTestRunsSummary(response, input) {
-  const params = input;
-  const raw = Array.isArray(response.data) ? response.data : [];
-  const byStatus = aggregateByStatus(raw);
-  const sorted = sortRuns(raw.map(slimEntry), params.sortBy, params.sortOrder);
-  const total = sorted.length;
-  const totalPages = Math.max(1, Math.ceil(total / params.pageSize));
-  const start = (params.page - 1) * params.pageSize;
-  const runs = sorted.slice(start, start + params.pageSize);
+function mapTestRunsSummary(response) {
+  const envelope = response.data ?? {};
+  const rawRuns = Array.isArray(envelope.data) ? envelope.data : [];
+  const runs = rawRuns.map(slimEntry);
   return {
-    totals: { total, byStatus },
-    page: params.page,
-    pageSize: params.pageSize,
-    totalPages,
-    hasMore: params.page < totalPages,
+    page: envelope.page ?? 1,
+    pageSize: envelope.pageSize ?? runs.length,
+    totalCount: envelope.totalCount ?? runs.length,
+    totalPages: envelope.totalPages ?? (runs.length === 0 ? 0 : 1),
+    hasMore: envelope.hasMore ?? false,
     runs
   };
 }
@@ -5010,6 +4995,7 @@ var workflowTools = [
           precondition: data.precondition,
           instructions: data.instructions,
           expectedResult: data.expectedResult,
+          ...data.runEnvironmentType && { runEnvironmentType: data.runEnvironmentType },
           ...data.workflowParams && { workflowParams: data.workflowParams }
         },
         timeoutMs: getWorkflowTimeoutMs()
@@ -5191,6 +5177,7 @@ var workflowTools = [
           useCaseId: data.useCaseId,
           testCaseId: data.testCaseId,
           runType: data.runType,
+          ...data.runEnvironmentType && { runEnvironmentType: data.runEnvironmentType },
           productionUrl: data.productionUrl,
           localExecutionContext: {
             originalUrl: data.localExecutionContext.originalUrl,
@@ -5239,13 +5226,19 @@ var reportTools = [
   },
   {
     name: "muggle-remote-project-test-runs-summary-get",
-    description: "Get a paginated, slimmed summary of latest test runs for a project. Response shape: { totals: { total, byStatus }, page, pageSize, totalPages, hasMore, runs: [{ status, testCaseId, testCaseTitle, useCaseId, useCaseTitle, lastRunAt, error, latestWorkflowRunId }] }. Returns 20 runs per page by default (max 100). `totals` covers the full project; `runs` is the page slice. Check `hasMore` to decide whether to fetch additional pages. Use muggle-remote-test-case-get / muggle-remote-wf-get-ts-replay-latest-run for full per-run detail.",
+    description: "Get a paginated, slimmed summary of latest test runs for a project. Response shape: { page, pageSize, totalCount, totalPages, hasMore, runs: [{ status, testCaseId, testCaseTitle, useCaseId, useCaseTitle, lastRunAt, error, latestWorkflowRunId }] }. Returns 20 runs per page by default (max 100). `totalCount` is the project-wide total after the replay-status filter; `runs` is the page slice. Check `hasMore` to decide whether to fetch additional pages. Use muggle-remote-test-case-get / muggle-remote-wf-get-ts-replay-latest-run for full per-run detail.",
     inputSchema: ProjectTestRunsSummaryInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/test-runs/summary`
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/test-runs/summary/paginated`,
+        queryParams: {
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     },
     mapFromUpstream: mapTestRunsSummary
@@ -6925,6 +6918,10 @@ var publishTestScriptTool = {
             useCaseId: runResult.useCaseId,
             testCaseId: input.cloudTestCaseId,
             runType: runResult.runType,
+            // A published run always originates from local Electron execution, so it
+            // belongs to the local lane — the cloud must resolve the developer's
+            // localhost credentials, not the remote managed-profile pool.
+            runEnvironmentType: "local" /* Local */,
             productionUrl: runResult.productionUrl,
             localExecutionContext: {
               originalUrl: runResult.localExecutionContext.originalUrl,
@@ -7299,6 +7296,9 @@ __export(e2e_exports2, {
   ReportPreferencesUpsertInputSchema: () => ReportPreferencesUpsertInputSchema,
   ReportStatsSummaryInputSchema: () => ReportStatsSummaryInputSchema,
   RunBatchIdSchema: () => RunBatchIdSchema,
+  RunEnvironment: () => RunEnvironment,
+  RunEnvironmentInputSchema: () => RunEnvironmentInputSchema,
+  RunEnvironmentSchema: () => RunEnvironmentSchema,
   SecretCreateInputSchema: () => SecretCreateInputSchema,
   SecretDeleteInputSchema: () => SecretDeleteInputSchema,
   SecretGetInputSchema: () => SecretGetInputSchema,

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-JNI7INIO.js';
-import './chunk-CPF6AR2I.js';
+import { runCli } from './chunk-QUWM3JQY.js';
+import './chunk-TWILR37J.js';
 
 // src/cli/main.ts
 runCli().catch((error) => {

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-JNI7INIO.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-CPF6AR2I.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-QUWM3JQY.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-TWILR37J.js';

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

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Run real-browser end-to-end (E2E) acceptance tests on your web app from any AI coding agent. Generate test scripts from plain English, replay them on localhost, capture screenshots, and validate user flows like signup, checkout, and dashboards. Works across Claude Code, Cursor, Codex, and Windsurf.",
-  "version": "4.12.4",
+  "version": "4.13.0",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

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

@@ -2,7 +2,7 @@
   "name": "muggle",
   "displayName": "Muggle AI",
   "description": "Ship quality products with AI-powered end-to-end (E2E) acceptance testing that validates your web app like a real user — from Claude Code and Cursor to PR.",
-  "version": "4.12.4",
+  "version": "4.13.0",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/dist/plugin/skills/_shared/github-cli-recipes/submitted-reviews.md

@@ -13,4 +13,4 @@ Filter client-side:
 - `id` not in `last_seen.escalated_review_ids`
 - `user.login` in the resolved allow-list
 - `state` in `{CHANGES_REQUESTED, COMMENTED}`, OR `APPROVED` with a non-empty body or at least one line comment
-- **Not a reply-wrapper.** `POST /pulls/<n>/comments/<id>/replies` creates an implicit review whose comments all have `in_reply_to_id` set. Fetch each candidate review's comments via `gh api repos/<owner>/<repo>/pulls/<n>/reviews/<id>/comments` and drop the review if every comment has a non-null `in_reply_to_id` (no new top-level critique). Without this clause, the loop's own threaded replies — submitted under the PR author's identity in single-account workflows — pass the allow-list and re-dispatch `/muggle-do` on a no-op cycle.
+- **Not a loop echo.** `POST /pulls/<n>/comments/<id>/replies` creates an implicit review whose comments all have `in_reply_to_id` set. Fetch each candidate review's comments via `gh api repos/<owner>/<repo>/pulls/<n>/reviews/<id>/comments` and drop the review **only if every comment is a reply (`in_reply_to_id != null`) and carries the loop marker `<!-- muggle-do:bot -->`** (see [`../pr-followup-helpers/loop-signature.md`](../pr-followup-helpers/loop-signature.md)). A reply-only wrapper with any comment **lacking** the marker is a human follow-up — keep it; the round addresses it. Matching the marker, not structure, is what skips the loop's own replies (posted under the author's identity in single-account workflows) without dropping genuine follow-ups.

package/dist/plugin/skills/_shared/github-cli-recipes/unresolved-threads.md

@@ -26,8 +26,10 @@ query($owner: String!, $name: String!, $number: Int!) {
 }'
 ```
 
-Filter client-side to `isResolved == false`. Classify each thread by inspecting its comments:
+Filter client-side to `isResolved == false`. Walk each thread's comments in `createdAt` order and classify by the loop marker (see [`../pr-followup-helpers/loop-signature.md`](../pr-followup-helpers/loop-signature.md)), not by `author.login` — the login is ambiguous under a shared account:
 
-- **Addressed by loop** — at least one comment authored by the loop user citing a SHA in `last_seen.pushed_shas[]`.
-- **Addressed by human** — at least one comment authored by a non-loop user after the original, and no addressed-by-loop signal.
-- **Not addressed** — otherwise.
+- **Addressed, awaiting resolve** — the **newest** comment carries the loop marker `<!-- muggle-do:bot -->`. The loop has replied and nothing newer is waiting. → resolve-reminder.
+- **Unaddressed human comment** — the newest comment lacks the marker and is newer than the thread's newest loop-marked comment (or the thread has no loop comment yet). → actionable: the round should address it.
+- **Not addressed** — indeterminate (e.g. no comments).
+
+A loop comment also cites a `<short-sha>` from `last_seen.pushed_shas[]` in its body, which tells *which* push addressed the thread.

package/dist/plugin/skills/_shared/pr-followup-helpers/allow-list.md

@@ -2,7 +2,7 @@
 
 The address-reviews flow only acts on reviews submitted by users in the **allow-list** = (requested reviewers ∪ CODEOWNERS ∪ {PR author}) − bots. Re-resolve every invocation — never cache across cycles.
 
-The PR author is implicitly a valid reviewer: in single-account workflows, the human running the agent and the PR's author are the same identity, and the agent must honor their reviews. Self-loop is prevented at the watcher's filter layer rather than here: `POST /pulls/<n>/comments/<id>/replies` does create an implicit review under the loop user's identity, and the watcher drops it via the reply-wrapper clause in [`../github-cli-recipes/submitted-reviews.md`](../github-cli-recipes/submitted-reviews.md). Including the PR author in this allow-list is therefore safe.
+The PR author is implicitly a valid reviewer: in single-account workflows, the human running the agent and the PR's author are the same identity, and the agent must honor their reviews. Self-loop is prevented at the watcher's filter layer rather than here: `POST /pulls/<n>/comments/<id>/replies` does create an implicit review under the loop user's identity, and the watcher drops it via the loop-echo clause in [`../github-cli-recipes/submitted-reviews.md`](../github-cli-recipes/submitted-reviews.md) — matched by the loop signature ([`loop-signature.md`](loop-signature.md)), so the author's *genuine* reviews and thread replies still get through. Including the PR author in this allow-list is therefore safe.
 
 ## Step 1: requested reviewers
 

package/dist/plugin/skills/_shared/pr-followup-helpers/classify.md

@@ -4,12 +4,11 @@ Classify the **review as a unit** — but reply per line comment (threaded), not
 
 ## Pre-check: self-loop filter
 
-GitHub auto-creates a synthetic review every time the agent posts `POST /comments/<id>/replies`. That review has the loop user as author, an empty body, and contains only the agent's own reply comments (`in_reply_to_id != null`). It carries no reviewer intent and must not trigger another cycle.
+GitHub auto-creates a synthetic review every time the agent posts `POST /comments/<id>/replies`. In single-account workflows the loop posts under the PR author's own identity, so that synthetic review is indistinguishable from a human's thread reply by author or structure alone — both are reply-only wrappers. The **loop signature** is what separates them (see [`loop-signature.md`](loop-signature.md)).
 
-A review is a **self-loop** iff:
+A review is a **self-loop** iff **every** line comment under it is a reply (`in_reply_to_id != null`) **and** carries the loop marker `<!-- muggle-do:bot -->`.
 
-- `body` is empty, AND
-- every line comment under it has `in_reply_to_id != null`
+If any comment in a reply-only wrapper **lacks** the marker, it is a **human follow-up** on an existing thread — not a self-loop. It carries reviewer intent; treat it as actionable and address it in this round (the caller's unresolved-thread sweep picks up the thread context).
 
 Self-loops bypass the actionable/ambiguous decision entirely. Action: advance the cursor silently. No push, no reply, no resolve-reminder, no escalation, no entry in `escalated_review_ids`. Telemetry: emit one `cycle` event with `outcome: "self-loop-skip"`.
 

package/dist/plugin/skills/_shared/pr-followup-helpers/loop-signature.md

@@ -0,0 +1,22 @@
+# Loop comment signature
+
+Every GitHub comment `/muggle-do` posts — inline thread replies, top-level reference comments, resolve-reminders — **must** end with the signature block below. It is the only reliable way to tell loop-authored comments from human comments: in single-account workflows the loop posts under the PR author's own identity, so `author.login` cannot distinguish them. Echo-protection and addressed-by-loop classification both depend on this marker.
+
+## The signature
+
+Append these two lines as the end of every loop-posted comment body:
+
+```
+<!-- muggle-do:bot -->
+🤖 _Automated reply from muggle-do._
+```
+
+- `<!-- muggle-do:bot -->` — hidden HTML marker; GitHub renders it invisibly and humans never type it. This is the **detection token**.
+- The visible line makes the automation clear to a reader.
+
+## Detection
+
+- **Loop-authored** — the comment body contains the literal `<!-- muggle-do:bot -->`.
+- **Human** — the body does not contain the marker.
+
+Classify by the marker, never by `author.login` alone — the login is ambiguous under a shared account. A comment that carries the marker is the loop's own and must never re-trigger a cycle; a comment without it is human intent to act on.

package/dist/plugin/skills/_shared/pr-followup-helpers.md

@@ -11,3 +11,4 @@ Each section is its own file — load only what the current step needs.
 | [`allow-list`](pr-followup-helpers/allow-list.md) | Resolve who counts as a reviewer (requested reviewers ∪ CODEOWNERS − bots − author). |
 | [`reply-routing`](pr-followup-helpers/reply-routing.md) | Pick the right reply endpoint per comment type (line, body-only, CI failure). |
 | [`classify`](pr-followup-helpers/classify.md) | Per-review binary label: actionable vs ambiguous, with worked examples + borderline rule. |
+| [`loop-signature`](pr-followup-helpers/loop-signature.md) | The signature every loop-posted comment carries, and how to detect loop vs human comments by it. |

package/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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/dist/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.