@muggleai/works 4.7.0 → 4.8.1

package/dist/plugin/skills/muggle-upgrade/SKILL.md

@@ -10,7 +10,7 @@ Update all Muggle AI components to the latest published version.
 ## Steps
 
 1. Run `/muggle:muggle-status` checks to capture current versions.
-2. Run `muggle setup --force` to download the latest Electron browser test runner.
+2. Run `muggle upgrade` to check GitHub releases for the latest electron-app version and download it.
 3. Report the upgrade results:
    - Previous version vs new version for each component.
    - Whether the upgrade succeeded or failed.

package/dist/plugin/skills/muggle-works-npm-release/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: muggle-works-npm-release
+description: >-
+  Cut @muggleai/works release: AskQuestion (major/minor/patch), sync master, stop if
+  nothing ships, semver baseline + Electron from GitHub, confirm plan, bump
+  package.json + sync:versions, full local verify, chore(release) PR, merge via gh,
+  dispatch publish-works-to-npm.yml—no local npm publish.
+---
+
+# Muggle Works — npm release (single playbook)
+
+Repo: **`multiplex-ai/muggle-ai-works`**. Workflow: **`.github/workflows/publish-works-to-npm.yml`** (“Publish Works to npm”). **Never** run local **`npm publish`** (OIDC trusted publishing in CI).
+
+---
+
+## Phase 1 — Ask bump type (do this first)
+
+**Stop until the user answers.**
+
+**Prefer `AskQuestion`** with exactly these three options: **major**, **minor**, **patch** (fix). If the environment has no structured question tool, ask the same in plain text:
+
+> Is this release a **major**, **minor**, or **patch** (fix)?
+
+You may **recommend** a bump from commit subjects (e.g. `feat!` / breaking → major, `feat` → minor, `fix` / `chore` → patch) but **do not** choose for them. **Do not** edit files yet.
+
+---
+
+## Phase 2 — Sync, surface state, empty-release gate
+
+Run from **`muggle-ai-works`**:
+
+```bash
+git checkout master && git pull --ff-only && git fetch --tags
+```
+
+Show what is shipping:
+
+```bash
+node -e 'console.log("master package.json:", require("./package.json").version)'
+npm view @muggleai/works version 2>&1 | sed 's/^/npm latest: /'
+```
+
+**Commits since the last release commit** (stop if there is nothing to ship):
+
+```bash
+LAST_RELEASE_SHA=$(git log --grep='chore(release)' --format='%H' -1)
+git log --oneline "$LAST_RELEASE_SHA..HEAD"
+```
+
+- If the log is **empty**, tell the user there is **nothing to ship** and **stop** (no branch, no bump, no PR).
+- If non-empty, present commits as a short table (subject; PR number from title/body if present).
+
+---
+
+## Phase 3 — Version baseline, Electron, print summary, confirm
+
+### npm version (`nextNpmVersion`)
+
+1. **`npm view @muggleai/works version`** — last published on npm.
+2. Root **`package.json` → `version`** on current **`master`** checkout.
+3. **Baseline** = **semver-higher** of those two (never target below repo or npm).
+4. Apply the user’s **major / minor / patch** to that baseline → **`nextNpmVersion`** (semver-correct).
+
+### Electron (`muggleConfig`)
+
+1. Read **`package.json` → `muggleConfig.electronAppVersion`**.
+2. **Latest desktop on GitHub:**  
+   `https://api.github.com/repos/multiplex-ai/muggle-ai-works/releases?per_page=30`  
+   → newest **`tag_name`** matching **`electron-app-v*`** → strip prefix → **`latestElectronVersion`** (semver only).
+
+### Print (always)
+
+| Item | Value |
+| :--- | :---- |
+| Last **@muggleai/works** on npm | … |
+| **Baseline** for bump | … |
+| **`nextNpmVersion`** (to publish) | … |
+| Current **`electronAppVersion`** | … |
+| Latest **`electron-app-v…`** on GitHub | … |
+
+### Electron bump decision
+
+If **`latestElectronVersion`** ≠ current **`electronAppVersion`**, ask: **bump** Electron + all four **`muggleConfig.checksums`** to **`latestElectronVersion`**, or **keep** current.
+
+If bumping, checksums from:
+
+`https://github.com/multiplex-ai/muggle-ai-works/releases/download/electron-app-vVERSION/checksums.txt`
+
+Map zip artifacts → **`darwin-arm64`**, **`darwin-x64`**, **`win32-x64`**, **`linux-x64`** (same mapping rules as today).
+
+**Stop again:** user must **confirm** the full plan (**`nextNpmVersion`** + Electron choice). If they cancel, **do not** branch, merge, or dispatch CI.
+
+---
+
+## Phase 4 — After explicit confirmation only
+
+### 1. Branch and bump
+
+```bash
+git checkout -b "chore/release-<VERSION>"
+npm version "<VERSION>" --no-git-tag-version
+```
+
+Replace **`<VERSION>`** with **`nextNpmVersion`** (dots in the branch name are fine, e.g. `chore/release-4.8.0`).
+
+- If Electron bump agreed: set **`muggleConfig.electronAppVersion`** and all four **`muggleConfig.checksums`** in **`package.json`**.
+
+### 2. Propagate versions (do not hand-edit manifests)
+
+```bash
+pnpm run sync:versions
+```
+
+Never hand-edit **`.claude-plugin/marketplace.json`**, **`.cursor-plugin/marketplace.json`**, **`plugin/.claude-plugin/plugin.json`**, **`plugin/.cursor-plugin/plugin.json`**, or **`server.json`** — **`sync-versions`** (and **`build`**) owns them.
+
+If you changed Electron after the first sync, run **`pnpm run sync:versions`** again.
+
+### 3. Full local verify (before push)
+
+```bash
+pnpm run lint:check && pnpm run typecheck && pnpm test && pnpm run build && pnpm run verify:plugin && pnpm run verify:contracts && pnpm run verify:electron-release-checksums
+```
+
+- **`pnpm run build`** is required before **`verify:plugin`** — the verifier reads the **built** plugin under **`dist/plugin/`**, not source under **`plugin/`**.
+- If **anything** fails, **stop** and surface the error; **do not** push a broken release.
+
+### 4. Commit (**`chore(release)`**)
+
+Stage version-touched files (at minimum **`package.json`** plus whatever **`sync:versions`** changed — typically the marketplace/plugin **`server.json`** paths above).
+
+**Subject:** `chore(release): @muggleai/works <VERSION>`
+
+**Body:** one bullet per shipping PR / theme, note **Electron** bump or unchanged, and any coordinated follow-ups in sibling repos (e.g. teaching-service, UI). Use a **heredoc** for `git commit` so newlines are preserved.
+
+### 5. PR, merge, update local **`master`**
+
+```bash
+git push -u origin HEAD
+gh pr create --repo multiplex-ai/muggle-ai-works --base master --head <branch> \
+  --title "chore(release): @muggleai/works <VERSION>" \
+  --body "<PR body: version delta, bump rationale, shipping list, Electron status, manifests touched by sync:versions, short test plan checklist>"
+```
+
+**Merge:** when the human has approved the release in this session, run **`gh pr merge`** (squash is fine unless the repo prefers merge commits), then:
+
+```bash
+git checkout master && git pull --ff-only
+node -e 'console.log("master now:", require("./package.json").version)'
+```
+
+Confirm **`package.json`** on **`master`** matches **`nextNpmVersion`** before publishing.
+
+---
+
+## Phase 5 — Trigger publish (CI only)
+
+Prefer **explicit version** (not “auto bump”):
+
+```bash
+gh workflow run publish-works-to-npm.yml --repo multiplex-ai/muggle-ai-works --ref master \
+  --field "version=<VERSION>" --field "bump=patch"
+```
+
+The `bump=patch` field is a harmless placeholder when `version` is set; the workflow prefers the explicit `version` input.
+
+**Or** **`git tag "v<VERSION>"`** && **`git push origin "v<VERSION>"`** only if that tag **does not** already exist on the remote; if the tag exists, use **`workflow_dispatch`** with **`version`**.
+
+Watch the run and confirm jobs succeed:
+
+```bash
+gh run list --repo multiplex-ai/muggle-ai-works --workflow=publish-works-to-npm.yml --limit 1
+gh run watch <RUN_ID> --repo multiplex-ai/muggle-ai-works --exit-status
+```
+
+Verify the registry:
+
+```bash
+npm view @muggleai/works version
+```
+
+Give the user the **Actions run URL**. If npm lags, wait ~60s and retry.
+
+---
+
+## Rules
+
+- **No local `npm publish`.**
+- **Phase 1:** use **`AskQuestion`** for major / minor / patch when available (see Phase 1).
+- Phases 1–3: keep chat concise; Phase 4–5 can be terse status lines.
+- If the user cancels after Phase 3, **do not** merge or dispatch CI.
+- **Tag vs npm:** **`v*`** tags are for the **npm** package; **`electron-app-v*`** is separate — **`electronAppVersion`** can move independently of **`version`**.
+
+---
+
+## Notes (troubleshooting)
+
+- Workflow **`name:`** / filename is tied to npm **Trusted Publishing** — see the comment block at the top of **`publish-works-to-npm.yml`** if auth fails.
+- If commits land on **`master`** between opening the PR and merging, re-check **`git log`** vs the last **`chore(release)`** before merging; rebasing the release branch may be needed so **`master`** still matches what you intend to ship.

package/dist/release-manifest.json

@@ -1,7 +1,7 @@
 {
-  "release": "4.7.0",
-  "buildId": "run-18-1",
-  "commitSha": "2497ce3c3bd536d511c5f1a8d6621e691fd8f5e3",
-  "buildTime": "2026-04-11T06:11:05Z",
+  "release": "4.8.1",
+  "buildId": "run-20-1",
+  "commitSha": "8cd42b4b70c049e44510010003084227b04229a8",
+  "buildTime": "2026-04-14T21:44:51Z",
   "serviceName": "muggle-ai-works-mcp"
 }

package/dist/{src-TX2KXI26.js → src-ZRUONWKV.js}

@@ -1 +1 @@
-export { buildElectronAppChecksumsUrl, buildElectronAppReleaseAssetUrl, buildElectronAppReleaseTag, calculateFileChecksum, createApiKeyWithToken, createChildLogger, deleteApiKeyData, deleteCredentials, e2e_exports as e2e, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppVersion, getElectronAppVersionSource, getLocalQaTools, getLogger, getPlatformKey, getQaTools, getValidApiKeyData, getValidCredentials, hasApiKey, isElectronAppInstalled, loadApiKeyData, loadCredentials, local_exports as localQa, mcp_exports as mcp, openBrowserUrl, performLogin, performLogout, pollDeviceCode, e2e_exports as qa, resetConfig, resetLogger, saveApiKey, saveApiKeyData, saveCredentials, startDeviceCodeFlow, toolRequiresAuth, verifyFileChecksum } from './chunk-HDEZDEM6.js';
+export { buildElectronAppChecksumsUrl, buildElectronAppReleaseAssetUrl, buildElectronAppReleaseTag, calculateFileChecksum, createApiKeyWithToken, createChildLogger, deleteApiKeyData, deleteCredentials, e2e_exports as e2e, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppVersion, getElectronAppVersionSource, getLocalQaTools, getLogger, getPlatformKey, getQaTools, getValidApiKeyData, getValidCredentials, hasApiKey, isElectronAppInstalled, loadApiKeyData, loadCredentials, local_exports as localQa, mcp_exports as mcp, openBrowserUrl, performLogin, performLogout, pollDeviceCode, e2e_exports as qa, resetConfig, resetLogger, saveApiKey, saveApiKeyData, saveCredentials, startDeviceCodeFlow, toolRequiresAuth, verifyFileChecksum } from './chunk-44I5ROCB.js';

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@muggleai/works",
     "mcpName": "io.github.multiplex-ai/muggle",
-    "version": "4.7.0",
+    "version": "4.8.1",
     "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",
@@ -41,14 +41,14 @@
         "test:watch": "vitest"
     },
     "muggleConfig": {
-        "electronAppVersion": "1.0.51",
+        "electronAppVersion": "1.0.59",
         "downloadBaseUrl": "https://github.com/multiplex-ai/muggle-ai-works/releases/download",
         "runtimeTargetDefault": "production",
         "checksums": {
-            "darwin-arm64": "6be5d2ff37541d9933e065f94f04348d7e4be63f01896b334a108a755a79f770",
-            "darwin-x64": "5c381e68829a330eecb8bd6edb9e5fba820e995acafe7fe78474fd7c43174f40",
-            "win32-x64": "2c101c467f75e8d60482aad16ad3c1a1e8edecac9ae58cdf7f1ad74cdf1141f7",
-            "linux-x64": "efeed3f2caf1cd301e8cc503a8ebae1f604ce73f7325c43202dee1c8a858a8a8"
+            "darwin-arm64": "c6da3f7f6b6875174a70a6c065554ed051ff99f731470e161ab71d9a9e568a87",
+            "darwin-x64": "ff93b24724fd415b99c40bcce2cc90a31e453a6408aad45a63480ff92606e7b0",
+            "win32-x64": "59bc67ea0a067fb4a204b87c73bf8cc387e705307f77ec96202822ff14b587fa",
+            "linux-x64": "714c93f586ac423377d9061924d2f703c175e3b541ef6ad22c96f6c20d3f4ea0"
         }
     },
     "dependencies": {

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": "4.7.0",
+  "version": "4.8.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": "4.7.0",
+  "version": "4.8.1",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"

package/plugin/README.md

@@ -15,7 +15,7 @@ For npm installs:
 npm install -g @muggleai/works
 ```
 
-This updates the CLI and syncs `muggle-*` skills into `~/.cursor/skills/` for Cursor. Claude slash commands remain plugin-managed, so use `/plugin update muggleai@muggle-works` to refresh them.
+This updates the CLI, configures Cursor MCP (`~/.cursor/mcp.json`), and syncs `muggle-*` skills into `~/.cursor/skills/`. Claude slash commands remain plugin-managed, so use `/plugin update muggleai@muggle-works` to refresh them.
 
 ## Skills
 

package/plugin/skills/muggle-test/SKILL.md

@@ -200,6 +200,17 @@ If nothing detected, ask as free text: "Your local app should be running. What's
 
 Before execution, fetch full test case details for all selected test cases by issuing **all** `muggle-remote-test-case-get` calls in parallel (single message, multiple tool calls).
 
+### Determine `freshSession` per test case
+
+Before executing each test case, inspect its content (title, goal, instructions, preconditions) for signals that it requires a **clean browser state** — no prior cookies, localStorage, or logged-in session. Set `freshSession: true` when the test case involves any of:
+
+- **Registration / sign-up** — creating a new account
+- **Login / authentication** — verifying the login flow itself (not a test that merely *uses* login as a prerequisite)
+- **Cookie consent / GDPR banners** — verifying first-visit consent prompts
+- **Onboarding flows** — first-time user experiences that only appear on a fresh session
+
+If none of the above apply, omit `freshSession` (defaults to `false`, preserving any existing session state). Evaluate this per test case — in a batch, some may need it and others may not.
+
 ### Run sequentially (Electron constraint)
 
 Execution itself **must** be sequential because there is only one local Electron browser. For each test case, in order:
@@ -208,6 +219,7 @@ Execution itself **must** be sequential because there is only one local Electron
    - `testCase`: Full test case object from the parallel fetch above
    - `localUrl`: User's local URL from the pre-flight question
    - `showUi`: omit (default visible) unless the user explicitly asked for headless, then pass `false`
+   - `freshSession`: `true` if the test case requires a clean browser state (see above), omit otherwise
 2. Store the returned `runId`
 
 If a generation fails, log it and continue to the next. Do not abort the batch.
@@ -231,7 +243,7 @@ Store every `viewUrl` — these are used in the next steps.
 ### Report summary
 
 ```
-Test Case                  Status    Duration   Steps   View on Muggle
+Test Case                  Status    Duration   Steps   View Steps on Muggle AI
 ─────────────────────────────────────────────────────────────────────────
 Login with valid creds     PASSED    12.3s      8       https://www.muggle-ai.com/...
 Login with invalid creds   PASSED    9.1s       6       https://www.muggle-ai.com/...

package/plugin/skills/muggle-test-feature-local/SKILL.md

@@ -86,17 +86,28 @@ Remind them: local URL is only the execution target, not tied to cloud project c
 
 ### 5. Load data for the chosen path
 
+**Determine `freshSession`**
+
+Before calling either execution tool, inspect the test case content (title, goal, instructions, preconditions) for signals that the test requires a **clean browser state** — no prior cookies, localStorage, or logged-in session. Pass `freshSession: true` when the test case involves any of:
+
+- **Registration / sign-up** — creating a new account
+- **Login / authentication** — verifying the login flow itself (not a test that merely *uses* login as a prerequisite)
+- **Cookie consent / GDPR banners** — verifying first-visit consent prompts
+- **Onboarding flows** — first-time user experiences that only appear on a fresh session
+
+If none of the above apply, omit `freshSession` (defaults to `false`, preserving any existing session state).
+
 **Generate**
 
 1. `muggle-remote-test-case-get`
-2. `muggle-local-execute-test-generation` with that test case + `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`timeoutMs`** — see below)
+2. `muggle-local-execute-test-generation` with that test case + `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`freshSession`** — see above; **`timeoutMs`** — see below)
 
 **Replay**
 
 1. `muggle-remote-test-script-get` — note `actionScriptId`
 2. `muggle-remote-action-script-get` with that id — full `actionScript`
    **Use the API response as-is.** Do not edit, shorten, or rebuild `actionScript`; replay needs full `label` paths for element lookup.
-3. `muggle-local-execute-replay` with `testScript`, `actionScript`, `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`timeoutMs`** — see below)
+3. `muggle-local-execute-replay` with `testScript`, `actionScript`, `localUrl` (optional: `showUi: false` for headless — defaults to visible; **`freshSession`** — see above; **`timeoutMs`** — see below)
 
 ### Local execution timeout (`timeoutMs`)
 

package/plugin/skills/muggle-test-regenerate-missing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: muggle-test-regenerate-missing
-description: "Bulk-regenerate test scripts for every test case in a Muggle AI project that doesn't currently have an active script. Scans the project, finds test cases stuck in DRAFT or GENERATION_PENDING (no usable script attached), shows the user the list, and on approval kicks off remote test script generation for each one in parallel via the Muggle cloud. Use this skill whenever the user asks to 'regenerate missing scripts', 'fill in missing test scripts', 'generate scripts for test cases without one', 'regen all the test cases that don't have scripts', 'rebuild scripts for stale test cases', 'fix test cases with no script', 'bulk regenerate', or any phrasing that means 'kick off script generation across a project for the cases that need it'. Triggers on: 'regenerate missing test scripts', 'generate scripts for all empty test cases', 'fill the gaps in my test scripts', 'bulk test script regen', 'all my test cases without active scripts'. This is the go-to skill for project-wide script catch-up — it handles discovery, filtering, confirmation, and remote workflow dispatch end-to-end."
+description: "Bulk-regenerate test scripts for every test case in a Muggle AI project that doesn't currently have an active script. Scans the project, finds test cases stuck in DRAFT or GENERATION_PENDING (no usable script attached), shows the user the list, and on approval kicks off bulk remote test script generation via the Muggle cloud. Use this skill whenever the user asks to 'regenerate missing scripts', 'fill in missing test scripts', 'generate scripts for test cases without one', 'regen all the test cases that don't have scripts', 'rebuild scripts for stale test cases', 'fix test cases with no script', 'bulk regenerate', or any phrasing that means 'kick off script generation across a project for the cases that need it'. Triggers on: 'regenerate missing test scripts', 'generate scripts for all empty test cases', 'fill the gaps in my test scripts', 'bulk test script regen', 'all my test cases without active scripts'. This is the go-to skill for project-wide script catch-up — it handles discovery, filtering, confirmation, and remote workflow dispatch end-to-end."
 ---
 
 # Muggle Test — Regenerate Missing Test Scripts
@@ -116,27 +116,22 @@ After selection, call `AskQuestion` once more for a final confirmation:
 
 Only proceed after the user picks "Yes".
 
-### Step 6 — Dispatch Remote Generations
+### Step 6 — Dispatch Remote Generations (Bulk)
 
-For each selected test case, in order:
+Send a single bulk request instead of dispatching one workflow per test case:
 
-1. Call `muggle-remote-test-case-get` with `testCaseId` to fetch the full record (the list endpoint returns a slim shape; generation needs `goal`, `precondition`, `instructions`, `expectedResult`, `url`).
-2. Call `muggle-remote-workflow-start-test-script-generation` with:
+1. Call `muggle-remote-workflow-start-test-script-generation-bulk` with:
    - `projectId` — from Step 2
-   - `useCaseId` — from the test case
-   - `testCaseId` — the test case being regenerated
-   - `name` — `"muggle-test-regenerate-missing: {test case title}"` (so it's easy to find this batch later in the dashboard)
-   - `url` — prefer the test case's own `url` if set, else the project URL from Step 2
-   - `goal`, `precondition`, `instructions`, `expectedResult` — straight from the test case. If `precondition` is empty, pass `"None"` (the schema requires a non-empty string).
-3. Capture the returned workflow runtime ID and store it alongside the test case.
+   - `name` — `"muggle-test-regenerate-missing: bulk ({count} test cases)"` where `{count}` is the number of selected test cases
+   - `testCaseIds` — array of all selected test case IDs from Step 5
+2. The backend handles looking up full test case details (goal, precondition, instructions, expectedResult, url), so there is no need to call `muggle-remote-test-case-get` per test case.
+3. Parse the response to get the `items` array with per-test-case status. Each item contains the test case ID, dispatch status, and (when successful) the workflow runtime ID.
 
-**Failure handling:** if a single dispatch fails (validation error, server error, missing field), log it inline, mark the test case as `dispatch_failed`, and continue to the next one. Do not abort the whole batch — partial progress is more useful than nothing.
-
-**Pacing:** Muggle's cloud handles parallelism on its side, so you don't need to throttle. Just dispatch sequentially as fast as the API will accept them.
+**Failure handling:** the bulk API returns per-item status in the response `items` array. Individual test cases may fail (validation error, missing field, etc.) while others succeed. Surface failures in the Step 7 report — partial progress beats no progress.
 
 ### Step 7 — Report
 
-After all dispatches are done, print a summary table:
+After the bulk dispatch returns, build a summary table from the response `items` array. Each item contains a test case ID, dispatch status, and (when successful) a workflow runtime ID. Cross-reference with the test case list from Step 3 to fill in titles and use case names:
 
 ```
 Test Case                          Use Case             Prev Status       Dispatch       Runtime
@@ -149,7 +144,7 @@ Apply expired coupon               Checkout Flow        GENERATION_PEND.  ❌ fa
 Total: 17 dispatched | 16 started | 1 failed
 ```
 
-For failures: include a one-line error excerpt and (where possible) a hint at the cause (e.g., "missing instructions field — edit the test case in the dashboard, then re-run this skill").
+For failures: include a one-line error excerpt from the item's error field and (where possible) a hint at the cause (e.g., "missing instructions field — edit the test case in the dashboard, then re-run this skill").
 
 ### Step 8 — Open the Dashboard
 
@@ -183,8 +178,7 @@ Add item to cart         rt-ghi789   COMPLETED   12
 | Auth | `muggle-remote-auth-status`, `muggle-remote-auth-login`, `muggle-remote-auth-poll` |
 | Project | `muggle-remote-project-list`, `muggle-remote-project-create` |
 | Scan | `muggle-remote-test-case-list` (paginated) |
-| Detail | `muggle-remote-test-case-get` |
-| Dispatch | `muggle-remote-workflow-start-test-script-generation` |
+| Dispatch | `muggle-remote-workflow-start-test-script-generation-bulk` |
 | Status (optional) | `muggle-remote-wf-get-ts-gen-latest-run`, `muggle-remote-wf-get-latest-ts-gen-by-tc` |
 | Browser | `open` (shell command) |
 
@@ -193,9 +187,8 @@ Add item to cart         rt-ghi789   COMPLETED   12
 - **The user MUST select the project** — present projects via `AskQuestion`, never infer from cwd, repo name, or URL guesses.
 - **The user MUST approve which test cases to regenerate** — show the candidates via `AskQuestion`, let them deselect, then confirm again before any dispatch. Bulk-regenerating without approval can waste meaningful workflow budget.
 - **Default filter is `DRAFT` + `GENERATION_PENDING`** — never include `GENERATING`, `ACTIVE`, `DEPRECATED`, `ARCHIVED`, `REPLAYING`, or `REPLAY_PENDING` unless the user explicitly says so. `GENERATING` already has a workflow in flight and dispatching another races against it. `ACTIVE` test cases already have working scripts. The rest reflect deliberate user decisions or in-flight replays the skill should not interfere with.
-- **Use `muggle-remote-test-case-get` before each dispatch** — the list endpoint returns a slim shape and generation needs the full payload.
-- **Failures don't abort the batch** — log and continue, then surface them at the end. Partial progress beats no progress.
-- **Never throttle artificially** — dispatch sequentially as fast as the API accepts. Muggle's cloud handles parallelism.
+- **Use the bulk endpoint for dispatch** — call `muggle-remote-workflow-start-test-script-generation-bulk` once with all selected test case IDs rather than dispatching one-by-one. The backend resolves full test case details internally.
+- **Failures don't abort the batch** — the bulk API returns per-item status. Surface failures in the report. Partial progress beats no progress.
 - **Open the dashboard, don't poll by default** — the runs page is the canonical view of progress. Only poll if the user explicitly asks.
 - **Use `AskQuestion` for every selection** — never ask the user to type a number.
 - **Can be invoked at any state** — if the user already has a project chosen in conversation context, skip Step 2 and go straight to scanning.

package/plugin/skills/muggle-upgrade/SKILL.md

@@ -10,7 +10,7 @@ Update all Muggle AI components to the latest published version.
 ## Steps
 
 1. Run `/muggle:muggle-status` checks to capture current versions.
-2. Run `muggle setup --force` to download the latest Electron browser test runner.
+2. Run `muggle upgrade` to check GitHub releases for the latest electron-app version and download it.
 3. Report the upgrade results:
    - Previous version vs new version for each component.
    - Whether the upgrade succeeded or failed.

package/plugin/skills/muggle-works-npm-release/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: muggle-works-npm-release
+description: >-
+  Cut @muggleai/works release: AskQuestion (major/minor/patch), sync master, stop if
+  nothing ships, semver baseline + Electron from GitHub, confirm plan, bump
+  package.json + sync:versions, full local verify, chore(release) PR, merge via gh,
+  dispatch publish-works-to-npm.yml—no local npm publish.
+---
+
+# Muggle Works — npm release (single playbook)
+
+Repo: **`multiplex-ai/muggle-ai-works`**. Workflow: **`.github/workflows/publish-works-to-npm.yml`** (“Publish Works to npm”). **Never** run local **`npm publish`** (OIDC trusted publishing in CI).
+
+---
+
+## Phase 1 — Ask bump type (do this first)
+
+**Stop until the user answers.**
+
+**Prefer `AskQuestion`** with exactly these three options: **major**, **minor**, **patch** (fix). If the environment has no structured question tool, ask the same in plain text:
+
+> Is this release a **major**, **minor**, or **patch** (fix)?
+
+You may **recommend** a bump from commit subjects (e.g. `feat!` / breaking → major, `feat` → minor, `fix` / `chore` → patch) but **do not** choose for them. **Do not** edit files yet.
+
+---
+
+## Phase 2 — Sync, surface state, empty-release gate
+
+Run from **`muggle-ai-works`**:
+
+```bash
+git checkout master && git pull --ff-only && git fetch --tags
+```
+
+Show what is shipping:
+
+```bash
+node -e 'console.log("master package.json:", require("./package.json").version)'
+npm view @muggleai/works version 2>&1 | sed 's/^/npm latest: /'
+```
+
+**Commits since the last release commit** (stop if there is nothing to ship):
+
+```bash
+LAST_RELEASE_SHA=$(git log --grep='chore(release)' --format='%H' -1)
+git log --oneline "$LAST_RELEASE_SHA..HEAD"
+```
+
+- If the log is **empty**, tell the user there is **nothing to ship** and **stop** (no branch, no bump, no PR).
+- If non-empty, present commits as a short table (subject; PR number from title/body if present).
+
+---
+
+## Phase 3 — Version baseline, Electron, print summary, confirm
+
+### npm version (`nextNpmVersion`)
+
+1. **`npm view @muggleai/works version`** — last published on npm.
+2. Root **`package.json` → `version`** on current **`master`** checkout.
+3. **Baseline** = **semver-higher** of those two (never target below repo or npm).
+4. Apply the user’s **major / minor / patch** to that baseline → **`nextNpmVersion`** (semver-correct).
+
+### Electron (`muggleConfig`)
+
+1. Read **`package.json` → `muggleConfig.electronAppVersion`**.
+2. **Latest desktop on GitHub:**  
+   `https://api.github.com/repos/multiplex-ai/muggle-ai-works/releases?per_page=30`  
+   → newest **`tag_name`** matching **`electron-app-v*`** → strip prefix → **`latestElectronVersion`** (semver only).
+
+### Print (always)
+
+| Item | Value |
+| :--- | :---- |
+| Last **@muggleai/works** on npm | … |
+| **Baseline** for bump | … |
+| **`nextNpmVersion`** (to publish) | … |
+| Current **`electronAppVersion`** | … |
+| Latest **`electron-app-v…`** on GitHub | … |
+
+### Electron bump decision
+
+If **`latestElectronVersion`** ≠ current **`electronAppVersion`**, ask: **bump** Electron + all four **`muggleConfig.checksums`** to **`latestElectronVersion`**, or **keep** current.
+
+If bumping, checksums from:
+
+`https://github.com/multiplex-ai/muggle-ai-works/releases/download/electron-app-vVERSION/checksums.txt`
+
+Map zip artifacts → **`darwin-arm64`**, **`darwin-x64`**, **`win32-x64`**, **`linux-x64`** (same mapping rules as today).
+
+**Stop again:** user must **confirm** the full plan (**`nextNpmVersion`** + Electron choice). If they cancel, **do not** branch, merge, or dispatch CI.
+
+---
+
+## Phase 4 — After explicit confirmation only
+
+### 1. Branch and bump
+
+```bash
+git checkout -b "chore/release-<VERSION>"
+npm version "<VERSION>" --no-git-tag-version
+```
+
+Replace **`<VERSION>`** with **`nextNpmVersion`** (dots in the branch name are fine, e.g. `chore/release-4.8.0`).
+
+- If Electron bump agreed: set **`muggleConfig.electronAppVersion`** and all four **`muggleConfig.checksums`** in **`package.json`**.
+
+### 2. Propagate versions (do not hand-edit manifests)
+
+```bash
+pnpm run sync:versions
+```
+
+Never hand-edit **`.claude-plugin/marketplace.json`**, **`.cursor-plugin/marketplace.json`**, **`plugin/.claude-plugin/plugin.json`**, **`plugin/.cursor-plugin/plugin.json`**, or **`server.json`** — **`sync-versions`** (and **`build`**) owns them.
+
+If you changed Electron after the first sync, run **`pnpm run sync:versions`** again.
+
+### 3. Full local verify (before push)
+
+```bash
+pnpm run lint:check && pnpm run typecheck && pnpm test && pnpm run build && pnpm run verify:plugin && pnpm run verify:contracts && pnpm run verify:electron-release-checksums
+```
+
+- **`pnpm run build`** is required before **`verify:plugin`** — the verifier reads the **built** plugin under **`dist/plugin/`**, not source under **`plugin/`**.
+- If **anything** fails, **stop** and surface the error; **do not** push a broken release.
+
+### 4. Commit (**`chore(release)`**)
+
+Stage version-touched files (at minimum **`package.json`** plus whatever **`sync:versions`** changed — typically the marketplace/plugin **`server.json`** paths above).
+
+**Subject:** `chore(release): @muggleai/works <VERSION>`
+
+**Body:** one bullet per shipping PR / theme, note **Electron** bump or unchanged, and any coordinated follow-ups in sibling repos (e.g. teaching-service, UI). Use a **heredoc** for `git commit` so newlines are preserved.
+
+### 5. PR, merge, update local **`master`**
+
+```bash
+git push -u origin HEAD
+gh pr create --repo multiplex-ai/muggle-ai-works --base master --head <branch> \
+  --title "chore(release): @muggleai/works <VERSION>" \
+  --body "<PR body: version delta, bump rationale, shipping list, Electron status, manifests touched by sync:versions, short test plan checklist>"
+```
+
+**Merge:** when the human has approved the release in this session, run **`gh pr merge`** (squash is fine unless the repo prefers merge commits), then:
+
+```bash
+git checkout master && git pull --ff-only
+node -e 'console.log("master now:", require("./package.json").version)'
+```
+
+Confirm **`package.json`** on **`master`** matches **`nextNpmVersion`** before publishing.
+
+---
+
+## Phase 5 — Trigger publish (CI only)
+
+Prefer **explicit version** (not “auto bump”):
+
+```bash
+gh workflow run publish-works-to-npm.yml --repo multiplex-ai/muggle-ai-works --ref master \
+  --field "version=<VERSION>" --field "bump=patch"
+```
+
+The `bump=patch` field is a harmless placeholder when `version` is set; the workflow prefers the explicit `version` input.
+
+**Or** **`git tag "v<VERSION>"`** && **`git push origin "v<VERSION>"`** only if that tag **does not** already exist on the remote; if the tag exists, use **`workflow_dispatch`** with **`version`**.
+
+Watch the run and confirm jobs succeed:
+
+```bash
+gh run list --repo multiplex-ai/muggle-ai-works --workflow=publish-works-to-npm.yml --limit 1
+gh run watch <RUN_ID> --repo multiplex-ai/muggle-ai-works --exit-status
+```
+
+Verify the registry:
+
+```bash
+npm view @muggleai/works version
+```
+
+Give the user the **Actions run URL**. If npm lags, wait ~60s and retry.
+
+---
+
+## Rules
+
+- **No local `npm publish`.**
+- **Phase 1:** use **`AskQuestion`** for major / minor / patch when available (see Phase 1).
+- Phases 1–3: keep chat concise; Phase 4–5 can be terse status lines.
+- If the user cancels after Phase 3, **do not** merge or dispatch CI.
+- **Tag vs npm:** **`v*`** tags are for the **npm** package; **`electron-app-v*`** is separate — **`electronAppVersion`** can move independently of **`version`**.
+
+---
+
+## Notes (troubleshooting)
+
+- Workflow **`name:`** / filename is tied to npm **Trusted Publishing** — see the comment block at the top of **`publish-works-to-npm.yml`** if auth fails.
+- If commits land on **`master`** between opening the PR and merging, re-check **`git log`** vs the last **`chore(release)`** before merging; rebasing the release branch may be needed so **`master`** still matches what you intend to ship.