@muggleai/works 4.12.4 → 4.13.1

package/dist/{chunk-JNI7INIO.js → chunk-5G7WI7IY.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-YKR2TQ24.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-ECRJW2LY.js');
     const credentials = await mcps.getCallerCredentialsAsync();
     if (!credentials.bearerToken && !credentials.apiKey) {
       stderrWrite(

package/dist/{chunk-CPF6AR2I.js → chunk-YKR2TQ24.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"),
@@ -3828,6 +3838,9 @@ var TestCaseListInputSchema = z.object({
 var TestCaseGetInputSchema = z.object({
   testCaseId: IdSchema.describe("Test case ID (UUID) to retrieve")
 });
+var TestCaseAncestorsGetInputSchema = z.object({
+  testCaseId: IdSchema.describe("Test case ID (UUID) to resolve the test-plan-graph ancestor chain for")
+});
 var TestCaseListByUseCaseInputSchema = z.object({
   useCaseId: IdSchema.describe("Use case ID (UUID) to list test cases for")
 });
@@ -3906,6 +3919,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 +4417,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
   };
 }
@@ -4716,6 +4704,18 @@ var testCaseTools = [
       };
     }
   },
+  {
+    name: "muggle-remote-test-case-ancestors-get",
+    description: "Resolve a test case's prerequisite chain from the project's test-plan graph. Returns { testCaseId, ancestors, orphan } where `ancestors` is an array of test case IDs ordered immediate-parent \u2192 root (empty when the case is a graph root). `orphan: true` means the case has no graph node, so it has no prerequisites. Call this before generating or replaying a script to ensure every prerequisite test case already has a ready script.",
+    inputSchema: TestCaseAncestorsGetInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-plan-graph/test-cases/${data.testCaseId}/ancestors`
+      };
+    }
+  },
   {
     name: "muggle-remote-test-case-list-by-use-case",
     description: "List test cases for a specific use case.",
@@ -5010,6 +5010,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 +5192,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 +5241,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 +6933,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,12 +7311,16 @@ __export(e2e_exports2, {
   ReportPreferencesUpsertInputSchema: () => ReportPreferencesUpsertInputSchema,
   ReportStatsSummaryInputSchema: () => ReportStatsSummaryInputSchema,
   RunBatchIdSchema: () => RunBatchIdSchema,
+  RunEnvironment: () => RunEnvironment,
+  RunEnvironmentInputSchema: () => RunEnvironmentInputSchema,
+  RunEnvironmentSchema: () => RunEnvironmentSchema,
   SecretCreateInputSchema: () => SecretCreateInputSchema,
   SecretDeleteInputSchema: () => SecretDeleteInputSchema,
   SecretGetInputSchema: () => SecretGetInputSchema,
   SecretListInputSchema: () => SecretListInputSchema,
   SecretUpdateInputSchema: () => SecretUpdateInputSchema,
   StripePaymentMethodIdSchema: () => StripePaymentMethodIdSchema,
+  TestCaseAncestorsGetInputSchema: () => TestCaseAncestorsGetInputSchema,
   TestCaseCreateInputSchema: () => TestCaseCreateInputSchema,
   TestCaseGenerateFromPromptInputSchema: () => TestCaseGenerateFromPromptInputSchema,
   TestCaseGetInputSchema: () => TestCaseGetInputSchema,

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-5G7WI7IY.js';
+import './chunk-YKR2TQ24.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-5G7WI7IY.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-YKR2TQ24.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.1",
   "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.1",
   "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/_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/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.