@muggleai/works 5.14.0-staging.97 → 5.14.0

package/config/runtime-targets.json

@@ -10,6 +10,7 @@
   "targets": {
     "production": {
       "promptServiceBaseUrl": "https://promptservice.muggle-ai.com",
+      "uiBaseUrl": "https://www.muggle-ai.com/muggleTestV0",
       "auth0Domain": "login.muggle-ai.com",
       "auth0ClientId": "UgG5UjoyLksxMciWWKqVpwfWrJ4rFvtT",
       "auth0Audience": "https://muggleai.us.auth0.com/api/v2/",
@@ -17,6 +18,7 @@
     },
     "staging": {
       "promptServiceBaseUrl": "https://staging.promptservice.muggle-ai.com",
+      "uiBaseUrl": "https://staging.muggle-ai.com/muggleTestV0",
       "auth0Domain": "login.staging.muggle-ai.com",
       "auth0ClientId": "C6rmJN3FeX3EuGZdY8qbHpbJVRadxsly",
       "auth0Audience": "https://staging-muggleai.us.auth0.com/api/v2/",
@@ -24,6 +26,7 @@
     },
     "dev": {
       "promptServiceBaseUrl": "http://localhost:5050",
+      "uiBaseUrl": "http://localhost:3999/muggleTestV0",
       "auth0Domain": "dev-po4mxmz0rd8a0w8w.us.auth0.com",
       "auth0ClientId": "GBvkMdTbCI80XJXnJ90MmbEvXwcWGUtw",
       "auth0Audience": "https://dev-po4mxmz0rd8a0w8w.us.auth0.com/api/v2/",

package/dist/{chunk-7WL6LFIU.js → chunk-2YXBHSCP.js}

@@ -490,10 +490,10 @@ function renderOverview(report) {
   }
   return lines.join("\n");
 }
-function renderTestDetails(test, projectId, testNumber) {
+function renderTestDetails(test, projectId, testNumber, dashboardBaseUrl = DASHBOARD_URL_BASE) {
   const summary = renderSummaryLine(test, testNumber);
   const frameBlock = renderEndingFrame(test);
-  const resultLines = renderResultSummary(test, projectId);
+  const resultLines = renderResultSummary(test, projectId, dashboardBaseUrl);
   const body = ["", "<br>", ""];
   if (frameBlock) {
     body.push(...frameBlock, "");
@@ -524,8 +524,8 @@ function renderEndingFrame(test) {
     fullSizeImage(frame.url, test.name)
   ];
 }
-function renderResultSummary(test, projectId) {
-  const dashboardUrl = `${DASHBOARD_URL_BASE}/${projectId}/scripts?modal=script-details&testCaseId=${encodeURIComponent(test.testCaseId)}`;
+function renderResultSummary(test, projectId, dashboardBaseUrl) {
+  const dashboardUrl = `${dashboardBaseUrl}/${projectId}/scripts?modal=script-details&testCaseId=${encodeURIComponent(test.testCaseId)}`;
   const lines = [];
   if (test.status === "passed") {
     lines.push(`**Result:** \u2705 PASSED`);
@@ -554,7 +554,7 @@ function renderBody(report, opts) {
       "_Full per-test details in the comment below \u2014 the PR description was too large to inline them._"
     ].join("\n");
   }
-  const detailBlocks = report.tests.map((t, i) => renderTestDetails(t, report.projectId, i + 1));
+  const detailBlocks = report.tests.map((t, i) => renderTestDetails(t, report.projectId, i + 1, opts.dashboardBaseUrl ?? DASHBOARD_URL_BASE));
   return [
     overview,
     "",
@@ -563,11 +563,11 @@ function renderBody(report, opts) {
     detailBlocks.join("\n\n")
   ].join("\n");
 }
-function renderComment(report) {
+function renderComment(report, opts = {}) {
   if (report.tests.length === 0) {
     return "";
   }
-  const detailBlocks = report.tests.map((t, i) => renderTestDetails(t, report.projectId, i + 1));
+  const detailBlocks = report.tests.map((t, i) => renderTestDetails(t, report.projectId, i + 1, opts.dashboardBaseUrl ?? DASHBOARD_URL_BASE));
   return [
     "## E2E acceptance evidence (overflow)",
     "",
@@ -579,7 +579,7 @@ function renderComment(report) {
 
 // src/cli/pr-section/overflow.ts
 function splitWithOverflow(report, opts) {
-  const inlineBody = renderBody(report, { inlineDetails: true });
+  const inlineBody = renderBody(report, { inlineDetails: true, dashboardBaseUrl: opts.dashboardBaseUrl });
   const inlineBytes = Buffer.byteLength(inlineBody, "utf-8");
   if (inlineBytes <= opts.maxBodyBytes) {
     return { body: inlineBody, comment: null };
@@ -587,8 +587,8 @@ function splitWithOverflow(report, opts) {
   if (report.tests.length === 0) {
     return { body: inlineBody, comment: null };
   }
-  const spilledBody = renderBody(report, { inlineDetails: false });
-  const comment = renderComment(report);
+  const spilledBody = renderBody(report, { inlineDetails: false, dashboardBaseUrl: opts.dashboardBaseUrl });
+  const comment = renderComment(report, { dashboardBaseUrl: opts.dashboardBaseUrl });
   return {
     body: spilledBody,
     comment: comment.length > 0 ? comment : null
@@ -804,6 +804,18 @@ var DEFAULT_MAX_BODY_BYTES = 6e4;
 var REPORT_SECTION_SENTINEL = "<!-- muggle-pr-section:v1 -->";
 var withSentinel = (s) => s ? `${REPORT_SECTION_SENTINEL}
 ${s}` : s;
+async function resolveDashboardBaseUrl(stderrWrite) {
+  try {
+    const mcps = await import('./src-KNYT7EHP.js');
+    return `${mcps.resolveActiveProfile().uiBaseUrl}/dashboard/projects`;
+  } catch (err) {
+    stderrWrite(
+      `build-pr-section: could not resolve the runtime target, linking to production: ${errMsg2(err)}
+`
+    );
+    return DASHBOARD_URL_BASE;
+  }
+}
 async function readAll(stream) {
   const chunks = [];
   for await (const chunk of stream) {
@@ -851,7 +863,8 @@ ${err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
   const sentinelCost = Buffer.byteLength(`${REPORT_SECTION_SENTINEL}
 `, "utf-8");
   const renderedSection = buildPrSection(resolvedReport, {
-    maxBodyBytes: opts.maxBodyBytes - sentinelCost
+    maxBodyBytes: opts.maxBodyBytes - sentinelCost,
+    dashboardBaseUrl: await resolveDashboardBaseUrl(opts.stderrWrite)
   });
   opts.stdoutWrite(
     JSON.stringify({

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-7WL6LFIU.js';
+import { runCli } from './chunk-2YXBHSCP.js';
 import './chunk-H5UDFKG3.js';
 
 // src/cli/main.ts

package/dist/index.js

@@ -1,2 +1,2 @@
-export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-7WL6LFIU.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-2YXBHSCP.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-H5UDFKG3.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": "5.13.0",
+  "version": "5.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": "5.13.0",
+  "version": "5.13.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

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

@@ -85,3 +85,33 @@ watcher_pid_alive() {
     [ -n "$pid" ] || return 1
     kill -0 "$pid" 2>/dev/null
 }
+
+# True when the slot's lease is held by a live loop that no longer belongs to the
+# session arming now — the deaf-orphan case.
+#
+# A live PID proves the loop is running; it never proves anything is listening.
+# On Windows a detached loop outlives the session that launched it, keeps
+# polling, and keeps touching its heartbeat, while its stdout is the dead
+# session's monitor pipe. Every liveness signal reads healthy and the events
+# reach nobody. Because arming skipped on a live PID alone, that corpse blocked
+# a live session from arming the PR for the whole lifetime cap — seven days
+# since the default moved off six hours.
+#
+# Deliberately narrow. It answers only "is this lease held on behalf of some
+# other session", which is decidable from state already on disk. It says nothing
+# about a loop orphaned by its own session's monitor dying, where the owner still
+# matches; that one needs a signal from the reader, which no file here carries.
+#
+# Conservative on every unknown — no watch.pid, a dead PID, no owner.json, or no
+# current session id all answer false, so a slot is never reclaimed on a guess.
+watcher_lease_is_foreign() {
+    local slot="$1" current_session="$2" owner_pid owner_session
+    [ -n "$current_session" ] || return 1
+    [ -f "${slot}/watch.pid" ] || return 1
+    owner_pid=$(tr -d ' \r\n' < "${slot}/watch.pid" 2>/dev/null)
+    watcher_pid_alive "$owner_pid" || return 1
+    [ -f "${slot}/owner.json" ] || return 1
+    owner_session=$(sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "${slot}/owner.json" | head -1)
+    [ -n "$owner_session" ] || return 1
+    [ "$owner_session" != "$current_session" ]
+}

package/dist/plugin/skills/muggle-pr-followup/arm-watcher.md

@@ -14,7 +14,11 @@ Read the `DRAIN` lines it prints: they are the outstanding work the monitor will
 
 1. **Drain.** Run one tick per [`contract.md`](contract.md). It acts on everything already outstanding — actionable threads (`gitlab`: discussions), body-only reviews past the watermark (GitHub-only — GitLab has no review envelope), a stale branch, red CI — and finalizes a terminal PR. If the tick dispatched a cycle, stop here: the cycle's exit path settles the watch when it finishes.
 2. **Seed the watermark.** *(`pr-watch-arm.sh` does this; the reasoning is kept because the floors are subtle and wrong ones are quiet.)* Resolve the provider once per [`../_shared/vcs/detect-vcs.md`](../_shared/vcs/detect-vcs.md) — every fetch in this sequence uses that provider's recipes. Write the slot's watch watermark ([`state-schemas.md`](state-schemas.md#watch-watermarkenv)) to the ids the **drain itself read** — the max review-id and comment-id observed at the drain's own fetch (Step 1), snapshotted at that read. Never let the loop capture its own baseline — the arming session writes it; and **never** from a fresh fetch taken after the drain, which would include a comment that arrived after the drain read the wave and mark it seen unread. Seeded to the drain's floor, anything landing after that read stays above the watermark and the monitor's first iteration surfaces it. Seed the CI floor (`CIRED`) from the same drain read: set it to the head SHA when the checks have **already settled red** at that read (no check pending, one or more in the `fail` bucket per [`../_shared/vcs/common/ci-rollup.md`](../_shared/vcs/common/ci-rollup.md)) — that red is what the drain just handled — and empty otherwise, so an escalated red head the drain already saw does not re-fire on the loop's first iteration. Seed the rebase floor (`REBASED`) the same way, from the drain's branch-standing read per [`../_shared/vcs/common/branch-standing.md`](../_shared/vcs/common/branch-standing.md): set it to the current `rebase_key` (`<head_sha>..<base_tip_sha>`) when the drain found the branch already behind or conflicting — that staleness is what the drain just handled — and empty otherwise, so a branch the drain already rebased or escalated does not re-fire on the loop's first iteration. Seed the blocked-CI floor (`BLOCKED_CIDIGEST`) to the blocked fingerprint's `ci_digest` when arming while `last_seen.blocked` is already set, and empty otherwise — empty is the not-blocked state, in which the loop's blocked-resume probe stays dormant.
-3. **Dedup, then watch.** First read `<slot>/watch.pid` ([`state-schemas.md`](state-schemas.md#watchpid)): if it names a live process (`kill -0 "$pid"` succeeds), a watcher already owns this slot — **skip arming, do not start a second**. This is what stops orphaned watchers from accumulating: the in-session monitor dying does not stop the OS loop it launched (on Windows a detached Git Bash loop keeps running and polling `gh` forever after the session ends), so checking a live task list is not enough — the PID lease is.
+3. **Dedup, then watch.** First read `<slot>/watch.pid` ([`state-schemas.md`](state-schemas.md#watchpid)): if it names a live process (`kill -0 "$pid"` succeeds) **and `owner.json` records this session**, a watcher already owns this slot — **skip arming, do not start a second**. This is what stops orphaned watchers from accumulating: the in-session monitor dying does not stop the OS loop it launched (on Windows a detached Git Bash loop keeps running and polling `gh` forever after the session ends), so checking a live task list is not enough — the PID lease is.
+
+   **A live lease owned by a different session does not count as owned** — check it with `watcher_lease_is_foreign` from [`../../scripts/pr-watch-guards.sh`](../../scripts/pr-watch-guards.sh). A live PID proves the loop is running, never that anything is listening: an orphan left by a dead session keeps polling and keeps touching its heartbeat while its stdout is that session's closed monitor pipe, so every liveness signal reads healthy and the events reach nobody. Skipping on the PID alone let such a corpse block this session from arming the PR for the whole lifetime cap — seven days, since the default moved off six hours. When the guard reports a foreign lease, kill that PID, delete `watch.pid`, and arm fresh; note it in the slot's `followup.log` so the reclaim is visible.
+
+   This is narrow on purpose. It reclaims only a lease held on behalf of *another* session, which is decidable from `owner.json` alone. A loop orphaned by its **own** session's monitor dying still reads as owned, and nothing on disk distinguishes it — that needs a signal from the reader, which no slot file carries. Treat an armed watcher as evidence a poller exists, never as proof a review will be seen.
 
    Otherwise **claim the slot for this session** before starting anything: write `owner.json` ([`state-schemas.md`](state-schemas.md#ownerjson)) with `session_id` from `$CLAUDE_CODE_SESSION_ID` and `claimed_at` now. Arming is what establishes ownership, so every arming point records it here rather than each caller remembering to. If `$CLAUDE_CODE_SESSION_ID` is unset, write no `owner.json` — an unidentifiable owner is worse than none, since [`reconcile.md`](reconcile.md) would read a bogus id as some other session's claim and could never recover the slot.
 

package/dist/release-manifest.json

@@ -1,7 +1,7 @@
 {
-  "release": "5.13.0",
-  "buildId": "run-97-1",
-  "commitSha": "d59f28752c70cf7a5997accb6aabda88235570b7",
-  "buildTime": "2026-09-05T00:56:07Z",
+  "release": "5.13.1",
+  "buildId": "run-103-1",
+  "commitSha": "0ca6cf7623407bc11836f39529640129081de7d0",
+  "buildTime": "2026-09-05T06:15:43Z",
   "serviceName": "muggle-ai-works-mcp"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@muggleai/works",
   "mcpName": "io.github.multiplex-ai/muggle",
-  "version": "5.14.0-staging.97",
+  "version": "5.14.0",
   "description": "Ship quality products with AI-powered E2E acceptance testing that validates your web app like a real user — from Claude Code and Cursor to PR.",
   "type": "module",
   "main": "dist/index.js",
@@ -53,7 +53,7 @@
   "muggleConfig": {
     "electronAppVersion": "1.10.3",
     "downloadBaseUrl": "https://github.com/multiplex-ai/muggle-ai-works/releases/download",
-    "runtimeTargetDefault": "staging",
+    "runtimeTargetDefault": "production",
     "checksumsByStream": {
       "production": {
         "win32-x64": "58e2238b1609ceff65b836b4b724b1c4c341d737a15debaa8a71af21b70bc436",

package/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": "5.13.0",
+  "version": "5.13.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/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": "5.13.0",
+  "version": "5.13.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

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

@@ -85,3 +85,33 @@ watcher_pid_alive() {
     [ -n "$pid" ] || return 1
     kill -0 "$pid" 2>/dev/null
 }
+
+# True when the slot's lease is held by a live loop that no longer belongs to the
+# session arming now — the deaf-orphan case.
+#
+# A live PID proves the loop is running; it never proves anything is listening.
+# On Windows a detached loop outlives the session that launched it, keeps
+# polling, and keeps touching its heartbeat, while its stdout is the dead
+# session's monitor pipe. Every liveness signal reads healthy and the events
+# reach nobody. Because arming skipped on a live PID alone, that corpse blocked
+# a live session from arming the PR for the whole lifetime cap — seven days
+# since the default moved off six hours.
+#
+# Deliberately narrow. It answers only "is this lease held on behalf of some
+# other session", which is decidable from state already on disk. It says nothing
+# about a loop orphaned by its own session's monitor dying, where the owner still
+# matches; that one needs a signal from the reader, which no file here carries.
+#
+# Conservative on every unknown — no watch.pid, a dead PID, no owner.json, or no
+# current session id all answer false, so a slot is never reclaimed on a guess.
+watcher_lease_is_foreign() {
+    local slot="$1" current_session="$2" owner_pid owner_session
+    [ -n "$current_session" ] || return 1
+    [ -f "${slot}/watch.pid" ] || return 1
+    owner_pid=$(tr -d ' \r\n' < "${slot}/watch.pid" 2>/dev/null)
+    watcher_pid_alive "$owner_pid" || return 1
+    [ -f "${slot}/owner.json" ] || return 1
+    owner_session=$(sed -n 's/.*"session_id"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' "${slot}/owner.json" | head -1)
+    [ -n "$owner_session" ] || return 1
+    [ "$owner_session" != "$current_session" ]
+}

package/plugin/skills/muggle-pr-followup/arm-watcher.md

@@ -14,7 +14,11 @@ Read the `DRAIN` lines it prints: they are the outstanding work the monitor will
 
 1. **Drain.** Run one tick per [`contract.md`](contract.md). It acts on everything already outstanding — actionable threads (`gitlab`: discussions), body-only reviews past the watermark (GitHub-only — GitLab has no review envelope), a stale branch, red CI — and finalizes a terminal PR. If the tick dispatched a cycle, stop here: the cycle's exit path settles the watch when it finishes.
 2. **Seed the watermark.** *(`pr-watch-arm.sh` does this; the reasoning is kept because the floors are subtle and wrong ones are quiet.)* Resolve the provider once per [`../_shared/vcs/detect-vcs.md`](../_shared/vcs/detect-vcs.md) — every fetch in this sequence uses that provider's recipes. Write the slot's watch watermark ([`state-schemas.md`](state-schemas.md#watch-watermarkenv)) to the ids the **drain itself read** — the max review-id and comment-id observed at the drain's own fetch (Step 1), snapshotted at that read. Never let the loop capture its own baseline — the arming session writes it; and **never** from a fresh fetch taken after the drain, which would include a comment that arrived after the drain read the wave and mark it seen unread. Seeded to the drain's floor, anything landing after that read stays above the watermark and the monitor's first iteration surfaces it. Seed the CI floor (`CIRED`) from the same drain read: set it to the head SHA when the checks have **already settled red** at that read (no check pending, one or more in the `fail` bucket per [`../_shared/vcs/common/ci-rollup.md`](../_shared/vcs/common/ci-rollup.md)) — that red is what the drain just handled — and empty otherwise, so an escalated red head the drain already saw does not re-fire on the loop's first iteration. Seed the rebase floor (`REBASED`) the same way, from the drain's branch-standing read per [`../_shared/vcs/common/branch-standing.md`](../_shared/vcs/common/branch-standing.md): set it to the current `rebase_key` (`<head_sha>..<base_tip_sha>`) when the drain found the branch already behind or conflicting — that staleness is what the drain just handled — and empty otherwise, so a branch the drain already rebased or escalated does not re-fire on the loop's first iteration. Seed the blocked-CI floor (`BLOCKED_CIDIGEST`) to the blocked fingerprint's `ci_digest` when arming while `last_seen.blocked` is already set, and empty otherwise — empty is the not-blocked state, in which the loop's blocked-resume probe stays dormant.
-3. **Dedup, then watch.** First read `<slot>/watch.pid` ([`state-schemas.md`](state-schemas.md#watchpid)): if it names a live process (`kill -0 "$pid"` succeeds), a watcher already owns this slot — **skip arming, do not start a second**. This is what stops orphaned watchers from accumulating: the in-session monitor dying does not stop the OS loop it launched (on Windows a detached Git Bash loop keeps running and polling `gh` forever after the session ends), so checking a live task list is not enough — the PID lease is.
+3. **Dedup, then watch.** First read `<slot>/watch.pid` ([`state-schemas.md`](state-schemas.md#watchpid)): if it names a live process (`kill -0 "$pid"` succeeds) **and `owner.json` records this session**, a watcher already owns this slot — **skip arming, do not start a second**. This is what stops orphaned watchers from accumulating: the in-session monitor dying does not stop the OS loop it launched (on Windows a detached Git Bash loop keeps running and polling `gh` forever after the session ends), so checking a live task list is not enough — the PID lease is.
+
+   **A live lease owned by a different session does not count as owned** — check it with `watcher_lease_is_foreign` from [`../../scripts/pr-watch-guards.sh`](../../scripts/pr-watch-guards.sh). A live PID proves the loop is running, never that anything is listening: an orphan left by a dead session keeps polling and keeps touching its heartbeat while its stdout is that session's closed monitor pipe, so every liveness signal reads healthy and the events reach nobody. Skipping on the PID alone let such a corpse block this session from arming the PR for the whole lifetime cap — seven days, since the default moved off six hours. When the guard reports a foreign lease, kill that PID, delete `watch.pid`, and arm fresh; note it in the slot's `followup.log` so the reclaim is visible.
+
+   This is narrow on purpose. It reclaims only a lease held on behalf of *another* session, which is decidable from `owner.json` alone. A loop orphaned by its **own** session's monitor dying still reads as owned, and nothing on disk distinguishes it — that needs a signal from the reader, which no slot file carries. Treat an armed watcher as evidence a poller exists, never as proof a review will be seen.
 
    Otherwise **claim the slot for this session** before starting anything: write `owner.json` ([`state-schemas.md`](state-schemas.md#ownerjson)) with `session_id` from `$CLAUDE_CODE_SESSION_ID` and `claimed_at` now. Arming is what establishes ownership, so every arming point records it here rather than each caller remembering to. If `$CLAUDE_CODE_SESSION_ID` is unset, write no `owner.json` — an unidentifiable owner is worse than none, since [`reconcile.md`](reconcile.md) would read a bogus id as some other session's claim and could never recover the slot.