@muggleai/works 5.28.0-staging.250 → 5.28.0-staging.252

package/.claude-plugin/marketplace.json

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

package/dist/{chunk-HBCASFGN.js → chunk-JRYEMMKU.js}

@@ -991,6 +991,16 @@ var HealthStatus = /* @__PURE__ */ ((HealthStatus2) => {
   HealthStatus2["Unhealthy"] = "unhealthy";
   return HealthStatus2;
 })(HealthStatus || {});
+var StudioVerdict = /* @__PURE__ */ ((StudioVerdict2) => {
+  StudioVerdict2["Success"] = "success";
+  StudioVerdict2["Active"] = "active";
+  StudioVerdict2["BugDetected"] = "bug_detected";
+  StudioVerdict2["GoalNotAchievable"] = "goal_not_achievable";
+  StudioVerdict2["Failure"] = "failure";
+  StudioVerdict2["Failed"] = "failed";
+  StudioVerdict2["Timeout"] = "timeout";
+  return StudioVerdict2;
+})(StudioVerdict || {});
 var TestResultStatus = /* @__PURE__ */ ((TestResultStatus2) => {
   TestResultStatus2["Passed"] = "passed";
   TestResultStatus2["Failed"] = "failed";
@@ -9883,6 +9893,33 @@ function formatElectronBrowserVisibilityLine(visibility) {
   return `**UI:** ${label} \u2014 showElectronBrowser is "${visibility.showElectronBrowserPreference}", so showUi: ${ignoredShowUi} was ignored`;
 }
 
+// packages/mcps/src/mcp/tools/local/studio-verdict-line-constants.ts
+var STUDIO_VERDICT_LABELS = {
+  ["success" /* Success */]: "Passed",
+  ["active" /* Active */]: "Passed",
+  ["bug_detected" /* BugDetected */]: "Bug Detected",
+  ["goal_not_achievable" /* GoalNotAchievable */]: "Goal Not Achievable",
+  ["failure" /* Failure */]: "Failed",
+  ["failed" /* Failed */]: "Failed",
+  ["timeout" /* Timeout */]: "Timed Out"
+};
+
+// packages/mcps/src/mcp/tools/local/studio-verdict-line.ts
+function isStudioVerdict(rawStatus) {
+  return Object.values(StudioVerdict).includes(rawStatus);
+}
+function formatStudioVerdictLine(studioReturnedResult) {
+  if (typeof studioReturnedResult !== "object" || studioReturnedResult === null) {
+    return "";
+  }
+  const rawStatus = studioReturnedResult.status;
+  if (typeof rawStatus !== "string" || rawStatus.length === 0) {
+    return "";
+  }
+  const verdictText = isStudioVerdict(rawStatus) ? `${STUDIO_VERDICT_LABELS[rawStatus]} (${rawStatus})` : rawStatus;
+  return `**Studio Verdict:** ${verdictText}`;
+}
+
 // packages/mcps/src/mcp/tools/local/run-checkout-refusal.ts
 function formatRunCheckoutRefusal(report, cwd) {
   const baseName = report.baseRef ? toDisplayRef(report.baseRef) : "";
@@ -10067,6 +10104,7 @@ var runResultGetTool = {
       `**ID:** ${storedRunResult.id}`,
       `**Type:** ${storedRunResult.runType}`,
       `**Status:** ${storedRunResult.status}`,
+      formatStudioVerdictLine(storedRunResult.studioReturnedResult),
       `**Cloud Test Case:** ${storedRunResult.cloudTestCaseId}`,
       `**Duration:** ${storedRunResult.executionTimeMs ?? 0}ms`,
       storedRunResult.errorMessage ? `**Error:** ${storedRunResult.errorMessage}` : "",
@@ -10756,6 +10794,7 @@ __export(local_exports2, {
   SessionStatus: () => SessionStatus,
   SkillTelemetryEmitInputSchema: () => SkillTelemetryEmitInputSchema,
   StorageService: () => StorageService,
+  StudioVerdict: () => StudioVerdict,
   TestCaseDetailsSchema: () => TestCaseDetailsSchema,
   TestResultStatus: () => TestResultStatus,
   TestScriptDetailsSchema: () => TestScriptDetailsSchema,

package/dist/{chunk-KGNRBL52.js → chunk-XEFALLR5.js}

@@ -1,4 +1,4 @@
-import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getActiveRuntimeTarget, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, reconcileProjectPreferences, getDataDir2, PREFERENCES_FILE_NAME, isFirstRun, writePreferences, DEFAULT_PREFERENCES, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, getElectronAppSignedFromVersion, getReleaseSignerIdentityUri, verifyFileChecksum, resolveElectronAppExecutablePath, calculateFileChecksum, initTelemetry, Surface, ServiceName, track, EventName, getQaTools, getLocalQaTools, performLogout, assertDeviceCodeClientProvisioned, performLogin, getActiveElectronAppReleaseStream, buildToolInputJsonSchema, toolRequiresAuth, getCallerCredentials, parseElectronAppDirName, getElectronAppReleaseTagPrefix, hasShownDisclosure, markDisclosureShown, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, ElectronAppReleaseStream, buildElectronAppChecksumsUrl, __require, getDisclosureCopy, buildOnboardingPlan, applyOnboardingAnswers, needsOnboarding, buildLlmSourcePlan, describeLlmSourceStatus, resolveLlmSourceStatus, readRunView, RunViewError, renderRunViewText, writeRunViewHtml, openBrowserUrl, evaluateCheckoutFreshness, runGitCommand, BLOCKING_FRESHNESS_VERDICTS, claimServiceStack, BUSY_EXIT_CODE, checkServiceStack, releaseServiceStack, readServiceStackStatus, resolvePreferences, OnboardingBlanketChoice, PreferenceKey, LlmSource, applyLlmSourceSelection, describeStackMismatch, getDataDir, DEFAULT_LOCAL_LLM_BASE_URL, isValidLocalBaseUrl, local_exports } from './chunk-HBCASFGN.js';
+import { __export, getLogger, getConfig, createChildLogger, buildElectronAppReleaseAssetUrl, getActiveRuntimeTarget, getAuthService, hasApiKey, getElectronAppVersion, getElectronAppDir, getPlatformKey, reconcileProjectPreferences, getDataDir2, PREFERENCES_FILE_NAME, isFirstRun, writePreferences, DEFAULT_PREFERENCES, isElectronAppInstalled, getElectronAppChecksums, getChecksumForPlatform, getElectronAppSignedFromVersion, getReleaseSignerIdentityUri, verifyFileChecksum, resolveElectronAppExecutablePath, calculateFileChecksum, initTelemetry, Surface, ServiceName, track, EventName, getQaTools, getLocalQaTools, performLogout, assertDeviceCodeClientProvisioned, performLogin, getActiveElectronAppReleaseStream, buildToolInputJsonSchema, toolRequiresAuth, getCallerCredentials, parseElectronAppDirName, getElectronAppReleaseTagPrefix, hasShownDisclosure, markDisclosureShown, getBundledElectronAppVersion, getElectronAppVersionSource, getCredentialsFilePath, ElectronAppReleaseStream, buildElectronAppChecksumsUrl, __require, getDisclosureCopy, buildOnboardingPlan, applyOnboardingAnswers, needsOnboarding, buildLlmSourcePlan, describeLlmSourceStatus, resolveLlmSourceStatus, readRunView, RunViewError, renderRunViewText, writeRunViewHtml, openBrowserUrl, evaluateCheckoutFreshness, runGitCommand, BLOCKING_FRESHNESS_VERDICTS, claimServiceStack, BUSY_EXIT_CODE, checkServiceStack, releaseServiceStack, readServiceStackStatus, resolvePreferences, OnboardingBlanketChoice, PreferenceKey, LlmSource, applyLlmSourceSelection, describeStackMismatch, getDataDir, DEFAULT_LOCAL_LLM_BASE_URL, isValidLocalBaseUrl, local_exports } from './chunk-JRYEMMKU.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { v4 } from 'uuid';
@@ -1151,7 +1151,7 @@ async function resolveGsScreenshotUrls(report, opts) {
     if (gsUrls.length === 0) {
       return report;
     }
-    const mcps = await import('./src-ZOCXV6PT.js');
+    const mcps = await import('./src-7OY7RXTE.js');
     const credentials = await mcps.getCallerCredentialsAsync();
     if (!credentials.bearerToken && !credentials.apiKey) {
       stderrWrite(

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { runCli } from './chunk-KGNRBL52.js';
-import './chunk-HBCASFGN.js';
+import { runCli } from './chunk-XEFALLR5.js';
+import './chunk-JRYEMMKU.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-KGNRBL52.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-HBCASFGN.js';
+export { src_exports as commands, createUnifiedMcpServer, server_exports as server } from './chunk-XEFALLR5.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-JRYEMMKU.js';

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

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

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

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.28.0-staging.250",
+        "@muggleai/works@5.28.0-staging.252",
         "serve"
       ],
       "env": {

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

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

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

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

package/dist/plugin/.mcp.json

@@ -4,7 +4,7 @@
       "command": "npx",
       "args": [
         "-y",
-        "@muggleai/works@5.28.0-staging.250",
+        "@muggleai/works@5.28.0-staging.252",
         "serve"
       ]
     }

package/dist/plugin/agents/acceptance-tester.md

@@ -22,6 +22,8 @@ You operate through skills — never call raw MCP tools directly.
 
 Select the skill based on what the orchestrator asks you to do. If the task doesn't clearly map to one skill, ask for clarification.
 
+A criterion about a video, image, audio, data, or research artifact is verified by a deliverable check rather than a browser run, per [`../skills/_shared/deliverable-categories.md`](../skills/_shared/deliverable-categories.md). Its results are reported in the **Deliverables** block and never as a Muggle run.
+
 The run loop these skills execute (replay/regen, timeouts, publish, screenshots) lives in [`../skills/_shared/dev-loop/run.md`](../skills/_shared/dev-loop/run.md) — you reach it through `muggle-test`, never by calling MCP tools yourself.
 
 ## Input Contract
@@ -58,6 +60,8 @@ Verdict policy (matches the CLI's `computeVerdict`):
 
 A test is **inconclusive** when the run could not yield a pass/fail signal for reasons outside the product itself: no replayable script, environment precondition unmet, infra error blocked execution, agent stalled before reaching the assertion (auth/cookie banner, missing secret). The product is not implicated. If you are tempted to call a run "passed except for one that didn't really run," that one is inconclusive.
 
+A run whose studio verdict is `bug_detected` (`**Studio Verdict:** Bug Detected (bug_detected)` on `muggle-local-run-result-get`) is **failed**: it is a product bug the run proved. Report it as a FAIL whose blocking issue is that bug in the user's app; do not retry, regenerate, or debug the test.
+
 **Section 2 — Per-Test Highlights**
 
 Order failures first, then inconclusives, then passes.

package/dist/plugin/skills/_shared/deliverable-categories/audio.md

@@ -0,0 +1,29 @@
+# Audio deliverable check
+
+The flow for an `[audio]` criterion. Shared rules — obtaining the artifact, verdicts, the report entry — live in the `deliverable-categories.md` index beside this folder, which opens this file.
+
+**Verified by:** deliverable check.
+
+## Artifact
+
+An audio file: committed at head, or produced by the repo's render or text-to-speech command.
+
+## Probes
+
+Read with `ffprobe` unless a step names another tool.
+
+- Codec.
+- Duration, against the stated length or range.
+- Sample rate and channel count.
+- Integrated loudness and true peak (`ffmpeg` `ebur128`), against any stated target.
+- Silence stretches (`silencedetect`) longer than two seconds, unless the criterion calls for them.
+
+## Review
+
+Transcribe spoken content with a speech-to-text tool available on the machine, and compare the transcript with the script or the criterion.
+
+## Inconclusive when
+
+- `ffprobe` or `ffmpeg` is missing.
+- No transcription is available. Only the spoken-content review is `INCONCLUSIVE`, with reason `no transcription available`; the probes still run and report.
+- The audio cannot be produced for an environment reason.

package/dist/plugin/skills/_shared/deliverable-categories/data.md

@@ -0,0 +1,31 @@
+# Data deliverable check
+
+The flow for a `[data]` criterion. Shared rules — obtaining the artifact, verdicts, the report entry — live in the `deliverable-categories.md` index beside this folder, which opens this file.
+
+**Verified by:** deliverable check.
+
+## Artifact
+
+A dataset or export — CSV, JSON, JSONL, Parquet, seed data: committed at head, or produced by the repo's export command.
+
+## Probes
+
+Run as a script written outside the worktree, so the check leaves the change untouched.
+
+- The file parses in its format.
+- Schema fields and types.
+- Row count, against the expected count or range.
+- Required fields filled.
+- Key uniqueness.
+- Values inside stated ranges or enumerations.
+- References to other files or tables resolve.
+
+A changed dataset is also diffed against its base-branch version: fields added or removed, type changes, row-count delta.
+
+## Review
+
+Read the first rows and a random sample of rows against the criterion.
+
+## Inconclusive when
+
+- The dataset cannot be produced for an environment reason.

package/dist/plugin/skills/_shared/deliverable-categories/image.md

@@ -0,0 +1,34 @@
+# Image deliverable check
+
+The flow for an `[image]` criterion. Shared rules — obtaining the artifact, verdicts, the report entry — live in the `deliverable-categories.md` index beside this folder, which opens this file.
+
+**Verified by:** deliverable check.
+
+## Artifact
+
+A raster or vector image: committed at head, or produced by the repo's build or export command.
+
+## Probes
+
+Read with `ffprobe` for raster images; read an SVG's markup directly.
+
+- Format.
+- Pixel dimensions, or the `viewBox` for SVG.
+- Aspect ratio.
+- File size, against any stated budget.
+- Alpha channel, when the criterion requires transparency.
+
+## Review
+
+View the image against the criterion:
+
+- Text legible and spelled as specified.
+- Required elements present.
+- Nothing cropped or clipped.
+
+A changed image is also viewed beside its base-branch version; every difference the criterion does not ask for is a finding.
+
+## Inconclusive when
+
+- `ffprobe` is missing for a raster image.
+- The image cannot be produced for an environment reason.

package/dist/plugin/skills/_shared/deliverable-categories/research.md

@@ -0,0 +1,28 @@
+# Research deliverable check
+
+The flow for a `[research]` criterion. Shared rules — obtaining the artifact, verdicts, the report entry — live in the `deliverable-categories.md` index beside this folder, which opens this file.
+
+**Verified by:** deliverable check.
+
+## Artifact
+
+A report or brief: committed at head, or produced by the repo's generation command.
+
+## Probes
+
+- Every question the criterion poses has an answer, cited by section.
+- Every claim a criterion depends on cites a source.
+- Every cited source resolves.
+- No placeholders remain: `TODO`, `TBD`, `[citation needed]`, an empty section.
+- A figure quoted in two places agrees.
+- Every source falls inside any stated recency bound.
+
+## Review
+
+Read each cited source and confirm it says what the claim says.
+
+A source that answers gone or not found is a `FAIL`: a dead citation is a defect in the deliverable.
+
+## Inconclusive when
+
+- A source is unreachable for a network reason.

package/dist/plugin/skills/_shared/deliverable-categories/video.md

@@ -0,0 +1,32 @@
+# Video deliverable check
+
+The flow for a `[video]` criterion. Shared rules — obtaining the artifact, verdicts, the report entry — live in the `deliverable-categories.md` index beside this folder, which opens this file.
+
+**Verified by:** deliverable check.
+
+## Artifact
+
+A rendered video file: committed at head, or produced by the repo's render command.
+
+## Probes
+
+Read with `ffprobe` unless a step names another tool.
+
+- Container and codec.
+- Duration, against the stated length or range.
+- Resolution and frame rate.
+- Audio-track presence, when the criterion implies sound.
+- Black stretches (`ffmpeg` `blackdetect`) and frozen stretches (`freezedetect`) longer than one second, unless the criterion calls for them.
+
+## Review
+
+Extract a frame with `ffmpeg` at every timestamp a criterion names, plus the first frame, the last, and one every 5 seconds — at most 24 in all. View each one against the criterion:
+
+- On-screen text present and spelled as specified.
+- Scenes in the stated order.
+- Captions on screen when they should be.
+
+## Inconclusive when
+
+- `ffprobe` or `ffmpeg` is missing.
+- The render fails for an environment reason.

package/dist/plugin/skills/_shared/deliverable-categories/web.md

@@ -0,0 +1,25 @@
+# Web deliverable check
+
+The flow for a `[web]` criterion. Shared rules — tagging, verdicts, the report entry — live in the `deliverable-categories.md` index beside this folder, which opens this file.
+
+**Verified by:** test cases.
+
+## Artifact
+
+The running app at the cycle's validation target: the dev server the readiness check brings up from the PR's worktree, or the preview URL a staging replay names.
+
+## Test cases
+
+Each criterion maps to the impacted or new Muggle test cases that exercise it, recorded as `coveredBy` in the scope. A new test case names one atomic behavior to verify, with prerequisites resolved from the project's test-plan graph rather than written into the case.
+
+## Review
+
+The run's step screenshots, read against the criterion: the element the criterion names is on screen, in the stated state, at the step that asserts it.
+
+## Inconclusive when
+
+- No replayable script exists and generation fails.
+- The test case's prerequisites cannot be satisfied.
+- The runner fails before reaching the assertion for a reason outside the product: an infrastructure error, a missing secret, an auth or cookie banner it could not clear.
+
+An app that never answers is not inconclusive: the cycle halts for readiness and owes the run.

package/dist/plugin/skills/_shared/deliverable-categories.md

@@ -0,0 +1,69 @@
+# Deliverable categories
+
+A **deliverable** is the artifact an acceptance criterion is about. Its **deliverable category** is one of `web`, `video`, `image`, `audio`, `data`, `research` — the one list of categories, which other files reference rather than restate. No category is special-cased: each criterion is verified the way its category's flow file declares under **Verified by** — **test cases** (Muggle browser test cases, run against the app) or a **deliverable check** (obtain the artifact, probe it, review it, return a verdict). Scoping and the acceptance stage read that declaration from the criterion's category and never branch on a category's name.
+
+## Tagging a criterion
+
+Every criterion carries exactly one category, written as a leading tag: `- [video] The promo renders at 1080×1920 and runs 28–32 s`. A criterion spanning two categories (a page that embeds a new video) is split into one criterion per category. A criterion about something a user does in a browser is `[web]`. A criterion no category can observe — a log line, a config value, a unit-test requirement — is still tagged with the category of the artifact it concerns, and impact analysis scopes it `unobservable`.
+
+## Obtaining the artifact
+
+- **Committed** — a file at the branch head is checked as committed, read from the PR's worktree.
+- **Built** — an artifact the change produces (a render, an export, a generated report) is built with the repo's own command, run from the PR's worktree at head, writing into a scratch directory outside the worktree.
+
+A check never commits, moves, or edits what it obtains. A build that fails because the change is broken is a `FAIL`; a build that fails because the environment lacks something (a missing binary, no network) is `INCONCLUSIVE`, naming it.
+
+## Probes and review
+
+A **probe** measures one property and compares it with the expected value the criterion states, or the value the scope planned when the criterion implies one. A rerun on the same artifact measures the same value. A **review** is the agent's inspection of the content against the criterion; the report labels every review finding as agent judgment.
+
+Media probes use `ffprobe`, and frame extraction and media filters use `ffmpeg`. A probe whose tool is missing makes the check `INCONCLUSIVE` with reason `probe tool missing: <tool>` — never a silent pass, never a skipped probe.
+
+## Category flows
+
+Every category's flow lives in its own file, so it can be customized without touching the others. Each file declares **Verified by**, then names the artifact, how it is verified, and when the verification is `INCONCLUSIVE`; the rules on this page apply to all of them. Changing a category's **Verified by** changes how its criteria are scoped and run, with no edit anywhere else.
+
+| Category | Verified by | Flow |
+| :-- | :-- | :-- |
+| web | test cases | [`deliverable-categories/web.md`](deliverable-categories/web.md) |
+| video | deliverable check | [`deliverable-categories/video.md`](deliverable-categories/video.md) |
+| image | deliverable check | [`deliverable-categories/image.md`](deliverable-categories/image.md) |
+| audio | deliverable check | [`deliverable-categories/audio.md`](deliverable-categories/audio.md) |
+| data | deliverable check | [`deliverable-categories/data.md`](deliverable-categories/data.md) |
+| research | deliverable check | [`deliverable-categories/research.md`](deliverable-categories/research.md) |
+
+Scoping and the acceptance stage open the flow file of every category the cycle's criteria carry before planning or running anything.
+
+## Verdict
+
+- **PASS** — every probe and review passed.
+- **FAIL** — a probe or review failed on an artifact that was obtained. The entry names the probe or review, the expected value, and the observed one.
+- **INCONCLUSIVE** — the artifact could not be obtained for an environment reason, a required tool is missing, or a source could not be reached. The product is not implicated.
+
+## Report entry
+
+```
+- (deliverable name):
+  - key: <DC key from the scope>
+  - category: <video | image | audio | data | research>
+  - artifact: <repo-relative path, or the build command and its scratch output>
+  - criteria: <the criteria it verifies>
+  - checks: [{ check, kind: probe | review, expected, observed, passed }, ...]
+  - verdict: PASS | FAIL | INCONCLUSIVE
+  - reason: <one short sentence; FAIL and INCONCLUSIVE only>
+  - evidenceDir: <scratch directory holding extracted frames, transcripts, probe output>
+```
+
+## Evidence on the PR
+
+Deliverable checks are run by the agent and are not recorded on the Muggle dashboard, so they never go under the walkthrough heading or its slot marker — that heading is Muggle vouching for a recorded run. They go in the PR body's `## Validation` section as one table per check:
+
+```
+**[video] Promo render** — PASS
+| Check | Kind | Expected | Observed |
+| :-- | :-- | :-- | :-- |
+| duration | probe | 28–32 s | 30.04 s |
+| end-card text | review (agent judgment) | "Try Muggle" | "Try Muggle" |
+```
+
+The table is followed by one line: `Deliverable checks ran in this PR's worktree at <short sha>; they are not recorded on the Muggle dashboard.` An image committed at head is embedded under its table by its blob URL at that commit, with `?raw=true`.

package/dist/plugin/skills/_shared/dev-loop/failures.md

@@ -1,6 +1,6 @@
 # Dev Loop — Reading the Result
 
-For each `runId`, call `muggle-local-run-result-get` and read **structured fields**, never `execute`'s stdout tail (a truncated display excerpt). Order: `Status` → `Error` → `Artifacts`. Retain per run: `testCaseId`, `testScriptId` (if any), `runId`, `status`, `artifactsDir`, plus the record it ran: `runSettingsId` from the `cloudRunSettingsId` the result prints as `**Cloud Run Settings ID:**` (absent on a run filed under no record), and the `resolutionLabel` of the plan record it ran.
+For each `runId`, call `muggle-local-run-result-get` and read **structured fields**, never `execute`'s stdout tail (a truncated display excerpt). Order: `Status` → `Studio Verdict` → `Error` → `Artifacts`. Retain per run: `testCaseId`, `testScriptId` (if any), `runId`, `status`, `artifactsDir`, plus the record it ran: `runSettingsId` from the `cloudRunSettingsId` the result prints as `**Cloud Run Settings ID:**` (absent on a run filed under no record), and the `resolutionLabel` of the plan record it ran.
 
 ## Artifacts
 
@@ -11,6 +11,7 @@ Per-step frames are **not** absent on the failure path — the `Artifacts` secti
 ## Common failures
 
 - `Electron execution timed out after 300000ms` → orchestration wait too short; see [`timeouts.md`](timeouts.md).
+- **`Studio Verdict: Bug Detected (bug_detected)`** → status `failed`: it is a product bug the run proved. Surface it to the user as a bug in their app; do not retry, regenerate, or debug the test.
 - **Exit code 26** (with "LLM failed to generate / replay action script") is usually a completed exploration whose outcome was **goal not achievable** (`goal_not_achievable`, summary with `halt`) — e.g. asserting "view a completed run" on an account that has none. Read the summary; don't assume a crash. Fix the precondition: pick a project/account that already has the needed state, or narrow the goal so generation isn't forced to create resources from scratch.
 
 Then route via [`../failure-mode-handling.md`](../failure-mode-handling.md).

package/dist/plugin/skills/_shared/failure-mode-handling.md

@@ -41,10 +41,13 @@ When the subagent aggregates per-script results from sections B and C into one v
 | `infra` (replay or regen) | B / C | **BLOCKED** |
 | `stale-script` (replay) | B | **INCONCLUSIVE** |
 | `product-defect` (replay) | B | **FAIL** |
+| studio verdict `bug_detected` (replay or regen) | B / C | **FAIL** |
 | `product-uxux` (regen) | C | **FAIL** |
 | `agent-course` (regen) | C | **INCONCLUSIVE** (agent couldn't complete, not a PR defect) |
 | `transient` (regen) | C | retry once; if still transient → **INCONCLUSIVE** |
 
+A deliverable check ([`deliverable-categories.md`](deliverable-categories.md)) carries no bucket; its own `FAIL` or `INCONCLUSIVE` verdict counts as a test case's **FAIL** or **INCONCLUSIVE** here.
+
 When a run mixes buckets across multiple test cases, take the most-significant verdict in this priority order: **FAIL > PARTIAL > BLOCKED > INCONCLUSIVE > SKIPPED > PASS**. If any one test case maps to FAIL, the run is FAIL. If some passed and some were INCONCLUSIVE, the run is PARTIAL.
 
 ### How orchestrators consume the verdict
@@ -123,6 +126,7 @@ Call `muggle-local-run-result-get` (local) or the remote equivalent and read **s
 - **infra** signals: `electron-crash`, `chromium-error`, `click-no-effect-on-clickable-element`, `timeout-on-trivial-wait`, `internal-error-in-mcp-output`.
 - **stale-script** signals: `element-not-found`, `selector-timeout`, `label-path-mismatch`, `nav-target-404`, `aria-label-changed`.
 - **product-defect** signals: `assertion-failed-on-passing-step`, `unexpected-error-toast`, `wrong-page-after-action`, `network-500-from-app`, `form-validation-rejected-valid-input`.
+- Studio verdict `bug_detected` (`**Studio Verdict:** Bug Detected (bug_detected)` on `muggle-local-run-result-get`) settles the bucket as **product-defect**, status `failed`: it is a product bug the run proved. Surface it to the user as a bug in their app; do not retry, regenerate, or debug the test.
 
 If signals span multiple buckets, pick the most specific one and list all signals in telemetry — the user can override.
 
@@ -213,6 +217,7 @@ Order:
 - **infra**: `electron-mcp-handler-crash`, `internal-validation-error`, `pipeline-stuck`, identical failure repeated more than twice.
 - **agent-course**: `goal_not_achievable` with summary mentioning the agent picked a different element, looped on a modal, kept trying the same wrong action; many steps but no real progress.
 - **product-uxux**: server 5xx in step screenshots, "page not found" reached repeatedly, expected element provably absent (visible in screenshot), product clearly broken in the artifact log.
+- Studio verdict `bug_detected` (`**Studio Verdict:** Bug Detected (bug_detected)` on `muggle-local-run-result-get`) settles the bucket as **product-uxux**, status `failed`: it is a product bug the run proved. Surface it to the user as a bug in their app; do not retry, regenerate, or debug the test.
 
 ### Suggestions per bucket
 

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

@@ -73,7 +73,7 @@ When other work is in front of the session as this change reaches Stage 6, the m
 
 ### Step 0.5: Readiness check
 
-A `local-e2e` cycle runs these before any `muggle-local-execute-*` call, every cycle — even when pre-flight already reported the app ready, since a server can die while stages 2–5 run and a healthy one fast-exits:
+A scope with deliverable checks and no browser case runs none of these and goes to Step 5. Otherwise a `local-e2e` cycle runs these before any `muggle-local-execute-*` call, every cycle — even when pre-flight already reported the app ready, since a server can die while stages 2–5 run and a healthy one fast-exits:
 
 1. **Dev-server + backend readiness** — invoke [`muggle-test-prepare`](../muggle-test-prepare/SKILL.md) from the cycle's worktree, passing the PR target as `base` — the readiness/service-start owner (idempotent fast-exit when healthy; probes via `dev-server-readiness.md` and starts what is down). It syncs the worktree onto the latest base before starting anything, and serves every other repo from its latest default branch. Its readiness table must show the cycle's worktree as the `Source` of the changed repo's services, at the worktree's current HEAD; any other source is not ready. Still not ready after its start attempts → the readiness halt below.
 2. **Auth** — `muggle-remote-auth-status` must be `authenticated`; else escalate.
@@ -87,7 +87,7 @@ Only the app not answering is this halt. A run the runner itself lost while read
 
 Pre-flight handled auth. If `muggle-remote-auth-status` somehow shows expired here (session clock skew, etc.), re-auth silently via `muggle-remote-auth-login` + `muggle-remote-auth-poll` — but do not ask the user "continue with this account?" again.
 
-If validation is `unit-only` or `skip`, emit a `SKIPPED` report citing the code that holds — `NO_WEB_SURFACE` when the repo has nothing to drive, `DEV_SERVER_UNREACHABLE` when it does but nothing answers — and exit cleanly. This is the only exit `DEV_SERVER_UNREACHABLE` belongs to, because pre-flight never planned a browser run; on a `local-e2e` cycle an unreachable server is the Step 0.5 readiness halt.
+If validation is `unit-only` or `skip`, the scope's test cases — the criteria whose category flow is **Verified by** test cases ([`../_shared/deliverable-categories.md`](../_shared/deliverable-categories.md#category-flows)) — get no run: emit a `SKIPPED` report citing the code that holds — `NO_WEB_SURFACE` when the repo has nothing to drive, `DEV_SERVER_UNREACHABLE` when it does but nothing answers — and exit cleanly. Every other criterion follows its own flow: under `unit-only`, a scope that also holds deliverable checks records that code as the report's `**Browser skip:**` line instead and goes straight to Step 5 rather than exiting. This is the only exit `DEV_SERVER_UNREACHABLE` belongs to, because pre-flight never planned a browser run; on a `local-e2e` cycle an unreachable server is the Step 0.5 readiness halt.
 
 If validation is `staging-replay`, emit `INCONCLUSIVE` with reason `staging replay not handled in Stage 6 local runner path` and exit cleanly.
 
@@ -141,11 +141,18 @@ Inputs to the loop: `mode` from the script-exists check, `localUrl`/project from
 
 Each record's run is its own report entry carrying its `runSettingsId` and `resolutionLabel`. A record skipped because its primary failed is an Inconclusive entry with reason `primary failed`, not a skipped test case.
 
+### Step 5: Run the deliverable checks
+
+Run every `deliverableChecks` entry of the scope per [`../_shared/deliverable-categories.md`](../_shared/deliverable-categories.md): obtain the artifact from the working tree recorded in `state.md`, run each planned probe plus the category's review, and record one report entry per check in the **Deliverables** block. Probe output, extracted frames, and transcripts go in a scratch directory outside the worktree, recorded as the entry's `evidenceDir`. A check that could not run is an `INCONCLUSIVE` entry with its reason, never absent.
+
+Deliverable checks do not satisfy the session's browser E2E gate. A cycle that ran no browser case still declares its browser skip with `echo "MUGGLE_E2E_SKIP: <CODE>: <detail>"`: `NO_WEB_SURFACE` when that holds, else `NOT_APPLICABLE` with a detail naming the categories checked instead, e.g. `NOT_APPLICABLE: change ships only video and image deliverables, verified by deliverable checks DC1-DC2`.
+
 ### Step 7: Collect Results
 
 For each test case:
 - Record pass or fail from the run result
 - If failed, capture the error message, failure step index, and `artifactsDir` for local debugging
+- A studio verdict of `bug_detected` (`**Studio Verdict:** Bug Detected (bug_detected)` on `muggle-local-run-result-get`) is failed: it is a product bug the run proved. Surface it to the user as a bug in their app; do not retry, regenerate, or debug the test
 - In `local-e2e` mode, every scoped test case must be executed — generate a new script if none exists (no skips)
 
 ## Output
@@ -185,6 +192,10 @@ For each test case:
   - reason: `<one short sentence>`
   - steps: `[{ stepIndex, action, description, screenshotUrl }, ...]` (empty only when the run produced no steps)
 
+**Deliverables:** (count) — one entry per deliverable check from Step 5, in the report-entry shape of [`../_shared/deliverable-categories.md`](../_shared/deliverable-categories.md#report-entry). Omitted when the scope planned none.
+
+**Browser skip:** `<CODE>: <detail>` — only when Step 1 skipped the browser part of a cycle that still ran deliverable checks.
+
 **Scope:** (from `e2eScope`, after Step 3)
 - impacted: `<testCaseId>`, ...
 - new: `<key>` → `<testCaseId>`, ...
@@ -194,7 +205,7 @@ For each test case:
 **Metadata:**
 - projectId: `<projectId>`
 
-**Overall:** PASS | FAIL | PARTIAL | INCONCLUSIVE | BLOCKED | SKIPPED — see [`../_shared/failure-mode-handling.md`](../_shared/failure-mode-handling.md) section F for the canonical taxonomy.
+**Overall:** PASS | FAIL | PARTIAL | INCONCLUSIVE | BLOCKED | SKIPPED — see [`../_shared/failure-mode-handling.md`](../_shared/failure-mode-handling.md) section F for the canonical taxonomy. Deliverable entries count toward it like test cases: a `FAIL` entry fails the run, an `INCONCLUSIVE` one is a gap. A browser skip beside deliverable entries is not `SKIPPED` — the run's verdict comes from the entries that ran.
 
 A non-passing verdict does not end the cycle. [`e2e-repair.md`](e2e-repair.md) consumes this report at Stage 7.5 and root-causes every Failed and Inconclusive entry before a watcher is armed, so write those blocks in full — the bucket, failing step, and `artifactsDir` recorded here are that stage's entire input.
 

package/dist/plugin/skills/do/e2e-repair.md

@@ -26,7 +26,7 @@ Read the Stage 6 run-level verdict, defined in [`../_shared/failure-mode-handlin
 - `PASS` or `SKIPPED` → nothing to repair. Append `e2e-repair: clear (<verdict>)` to the iteration log and hand to Stage 8.
 - A verdict the user waived earlier in this session → clear on the recorded waiver; never re-ask.
 - An entry whose run failed because the app did not answer — connection refused, page never loaded — is the readiness halt of [`e2e-acceptance.md`](e2e-acceptance.md) Step 0.5 arriving late. Nothing ran, so there is nothing to repair and nothing to waive, attended or not: re-check readiness there, and if the app is still down, stop as Step 4's **Stop here** and report the halt. A run the runner lost while the app answers — an Electron, MCP or Studio crash, even before the first step — is not this: it is an `infra` failure and takes the loop below.
-- `FAIL`, `PARTIAL`, `INCONCLUSIVE`, or `BLOCKED` → the loop runs over every entry in the Failed and Inconclusive blocks.
+- `FAIL`, `PARTIAL`, `INCONCLUSIVE`, or `BLOCKED` → the loop runs over every entry in the Failed and Inconclusive blocks, and every non-`PASS` entry in the Deliverables block.
 
 ## Step 1: Root-cause each failure
 
@@ -56,6 +56,8 @@ A `repair` disposition requires a named defect: the failing step, expected-versu
 
 **A failure the diff cannot explain may predate it.** When a `product-defect` or `product-uxux` failure names no code path the diff touched, replay the same test case against a checkout of the base before repairing anything: a worktree at the base tip's full SHA, with its own stack claim and services, under the same runSettings record. If that run fails the same way, its disposition is `baseline` — the defect is on the base, not this change's to fix — and the entry carries that run's id as `baselineRunId` into the walkthrough report ([`../muggle-pr-visual-walkthrough/e2e-report-assembly.md`](../muggle-pr-visual-walkthrough/e2e-report-assembly.md)). If it passes, the change caused the failure and the original disposition stands. A `baseline` entry is never re-run or waived; when every remaining failure is `baseline`, the loop clears.
 
+A Deliverables entry carries no bucket. A `FAIL` entry is already a named defect — the failed probe or review with its expected and observed values — so its disposition is `repair`. An `INCONCLUSIVE` entry is `ask`, naming its reason: a missing tool or unreachable source is the machine's to fix, not the diff's. A Step 5 re-run re-checks only the deliverable entries the repair touched.
+
 An Inconclusive entry Stage 6 recorded as `prerequisites unmet` never executed. It carries no bucket and none may be derived from it — there is no run to read. Its disposition is `ask`, and the question names the missing prerequisite: what failed is the project's test-plan chain, not the diff.
 
 An Inconclusive entry Stage 6 recorded as `primary failed` never executed either: it is a record held back by its test case's failed primary. It takes no disposition of its own; the primary's entry is the one repaired, and re-running the test case runs it again.

package/dist/plugin/skills/do/impact-analysis.md

@@ -101,6 +101,8 @@ The case selection [`e2e-acceptance.md`](e2e-acceptance.md) runs. Stage 6 execut
 
 Scope only when this cycle runs E2E: `Validation` is `local-e2e`, `pathClassification` is not `none`, and in a watcher cycle `cycleSize` is `full`. Otherwise emit `e2eScope: not-scoped — <the condition that failed>`.
 
+Deliverable checks ([`../_shared/deliverable-categories.md`](../_shared/deliverable-categories.md)) need no browser, dev server, or Muggle session, so they are scoped on their own rule: whenever `Validation` is not `skip`, `pathClassification` is not `none`, and in a watcher cycle `cycleSize` is `full`. A cycle that scopes deliverable checks but no browser cases emits only `projectId: none`, `deliverableChecks`, and `criteria`; the browser lists are written empty.
+
 The criteria are the acceptance criteria in the session's `requirements.md`, plus each review-derived change item that alters behavior in an address-reviews cycle. A session with no `requirements.md` (an adopted PR) scopes from the diff alone and writes `criteria: []`.
 
 ### Procedure
@@ -113,9 +115,11 @@ The criteria are the acceptance criteria in the session's `requirements.md`, plu
    - **Removed** — the change removes the feature it verifies. `replacedBy: none`.
 
    A use case is retired only when the change removes its whole flow **and** every test case under it is retired: deleting a use case cascades to all its test cases and scripts, so one surviving test case keeps the use case. Retired cases are deleted after the PR merges ([`cleanup.md`](cleanup.md)), never during the cycle — an unmerged change must leave the project's suite intact for the default branch.
-5. **Map every criterion.** Each criterion carries `coveredBy` (impacted or new test cases that verify it) or `unobservable` (why no browser can observe it: a log line, a unit-test requirement, a config value). A criterion with neither is a scoping failure.
+5. **Map every criterion.** A criterion's mapping follows its category's flow file ([`../_shared/deliverable-categories.md`](../_shared/deliverable-categories.md#category-flows)), never the category's name. A flow **Verified by** test cases gives the criterion `coveredBy` (impacted or new test cases that verify it); a flow **Verified by** a deliverable check gives it `verifiedBy` (the deliverable checks that verify it). Either may instead carry `unobservable` (why no check can observe it: a log line, a unit-test requirement, a config value). A criterion with none of the three is a scoping failure.
 6. **Plan the new cases.** Each uncovered criterion gets a new test case under the impacted use case its behavior belongs to, or under a new use case when none fits. A test case instruction names one atomic behavior to verify, with no signup, login, navigation, or seed-data steps, per [`../_shared/test-case-design.md`](../_shared/test-case-design.md); prerequisites come from the test-plan graph at run time ([`../_shared/test-case-chain-readiness.md`](../_shared/test-case-chain-readiness.md)).
 
+7. **Plan the deliverable checks.** One check per artifact that the criteria mapped to `verifiedBy` are about, keyed `DC1`, `DC2`, …: its category, the artifact and how it is obtained (committed path, or the build command), the probes with their expected values, and the criteria it verifies. A changed artifact that no criterion names is still checked when the diff touches it — the probes alone, with expected values from its base-branch version.
+
 This stage plans new cases and creates nothing. Stage 6 creates them, so a cycle that never reaches E2E leaves no cases behind in the project.
 
 ### Shape
@@ -148,11 +152,21 @@ e2eScope:
       - key: NTC1
         useCase: <useCaseId | new use case key>
         instruction: <one atomic behavior to verify>
+    deliverableChecks:
+      - key: DC1
+        category: <video | image | audio | data | research>
+        artifact: <repo-relative path | build: <command> → <output>>
+        probes:
+          - probe: <property>
+            expected: <value or range>
+        criteria: [<criterion>, ...]
     criteria:
-      - criterion: <acceptance criterion>
+      - criterion: <[<category verified by test cases>] acceptance criterion>
         coveredBy: [<testCaseId | new test case key>, ...]
+      - criterion: <[<category verified by a deliverable check>] acceptance criterion>
+        verifiedBy: [<DC key>, ...]
       - criterion: <acceptance criterion>
-        unobservable: <why no browser can observe it>
+        unobservable: <why no check can observe it>
 ```
 
 An empty list is written empty, never omitted; an absent list reads as "not scoped". Record the scope in this stage's marker in `iterations/<NNN>.md`, so Stage 6, a Stage 7.5 re-run, and a resumed session read the same one.