@muggleai/works 4.9.1 → 4.10.0

package/dist/{chunk-6N7OIBAS.js → chunk-RK6XKSZK.js}

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

package/dist/{chunk-4KQZLF56.js → chunk-UVXOHXY2.js}

@@ -33,6 +33,7 @@ __export(src_exports, {
   PREFERENCES_PROJECT_DIR_NAME: () => PREFERENCES_PROJECT_DIR_NAME,
   PREFERENCES_SCHEMA: () => PREFERENCES_SCHEMA,
   PREFERENCES_VERSION: () => PREFERENCES_VERSION,
+  PREFERENCE_ALLOWED_VALUES: () => PREFERENCE_ALLOWED_VALUES,
   PreferenceKey: () => PreferenceKey,
   PreferenceValue: () => PreferenceValue,
   buildElectronAppChecksumsUrl: () => buildElectronAppChecksumsUrl,
@@ -1998,7 +1999,7 @@ function getAuthenticatedUserId() {
 }
 async function findPackageJsonAsync() {
   const currentFileUrl = import.meta.url;
-  const currentDir = path2.dirname(new URL(currentFileUrl).pathname);
+  const currentDir = path2.dirname(fileURLToPath(currentFileUrl));
   const candidatePaths = [
     path2.resolve(currentDir, "../../../package.json"),
     path2.resolve(currentDir, "../package.json"),
@@ -3481,17 +3482,17 @@ var PromptServiceClient = class {
    * @param path - Path to validate.
    * @throws GatewayError if path is not allowed.
    */
-  validatePath(path11) {
-    const isAllowed = ALLOWED_UPSTREAM_PREFIXES.some((prefix) => path11.startsWith(prefix));
+  validatePath(path12) {
+    const isAllowed = ALLOWED_UPSTREAM_PREFIXES.some((prefix) => path12.startsWith(prefix));
     if (!isAllowed) {
       const logger6 = getLogger();
       logger6.error("Path not in allowlist", {
-        path: path11,
+        path: path12,
         allowedPrefixes: ALLOWED_UPSTREAM_PREFIXES
       });
       throw new GatewayError({
         code: "FORBIDDEN" /* FORBIDDEN */,
-        message: `Path '${path11}' is not allowed`
+        message: `Path '${path12}' is not allowed`
       });
     }
   }
@@ -5303,19 +5304,11 @@ var PreferenceValue = /* @__PURE__ */ ((PreferenceValue2) => {
   PreferenceValue2["Always"] = "always";
   PreferenceValue2["Ask"] = "ask";
   PreferenceValue2["Never"] = "never";
+  PreferenceValue2["Local"] = "local";
+  PreferenceValue2["Remote"] = "remote";
   return PreferenceValue2;
 })(PreferenceValue || {});
 
-// packages/mcps/src/mcp/local/contracts/preferences-schemas.ts
-var preferenceKeyValues = Object.values(PreferenceKey);
-var preferenceValueValues = Object.values(PreferenceValue);
-var PreferencesSetInputSchema = z.object({
-  key: z.enum(preferenceKeyValues).describe("The preference key to set."),
-  value: z.enum(preferenceValueValues).describe("The value: always, ask, or never."),
-  scope: z.enum(["global", "project"]).default("global").describe("Write to global (~/.muggle-ai/) or project (.muggle-ai/) preferences."),
-  cwd: z.string().optional().describe("Project root directory. Required when scope is 'project'.")
-});
-
 // packages/mcps/src/shared/preferences-constants.ts
 var PREFERENCES_FILE_NAME = "preferences.json";
 var PREFERENCES_PROJECT_DIR_NAME = ".muggle-ai";
@@ -5334,6 +5327,30 @@ var DEFAULT_PREFERENCES = {
   ["checkForUpdates" /* CheckForUpdates */]: "ask" /* Ask */,
   ["verboseOutput" /* VerboseOutput */]: "ask" /* Ask */
 };
+var ALWAYS_ASK_NEVER = [
+  "always" /* Always */,
+  "ask" /* Ask */,
+  "never" /* Never */
+];
+var LOCAL_REMOTE_ASK = [
+  "local" /* Local */,
+  "remote" /* Remote */,
+  "ask" /* Ask */
+];
+var PREFERENCE_ALLOWED_VALUES = {
+  ["autoLogin" /* AutoLogin */]: ALWAYS_ASK_NEVER,
+  ["autoSelectProject" /* AutoSelectProject */]: ALWAYS_ASK_NEVER,
+  ["showElectronBrowser" /* ShowElectronBrowser */]: ALWAYS_ASK_NEVER,
+  ["openTestResultsAfterRun" /* OpenTestResultsAfterRun */]: ALWAYS_ASK_NEVER,
+  ["defaultExecutionMode" /* DefaultExecutionMode */]: LOCAL_REMOTE_ASK,
+  ["autoPublishLocalResults" /* AutoPublishLocalResults */]: ALWAYS_ASK_NEVER,
+  ["suggestRelatedUseCases" /* SuggestRelatedUseCases */]: ALWAYS_ASK_NEVER,
+  ["suggestRelatedTestCases" /* SuggestRelatedTestCases */]: ALWAYS_ASK_NEVER,
+  ["autoDetectChanges" /* AutoDetectChanges */]: ALWAYS_ASK_NEVER,
+  ["postPRVisualWalkthrough" /* PostPRVisualWalkthrough */]: ALWAYS_ASK_NEVER,
+  ["checkForUpdates" /* CheckForUpdates */]: ALWAYS_ASK_NEVER,
+  ["verboseOutput" /* VerboseOutput */]: ALWAYS_ASK_NEVER
+};
 var PREFERENCES_SCHEMA = {
   ["autoLogin" /* AutoLogin */]: {
     description: "When a tool requires auth and saved credentials exist, reuse them without prompting"
@@ -5373,7 +5390,36 @@ var PREFERENCES_SCHEMA = {
   }
 };
 
-// packages/mcps/src/shared/preferences.ts
+// packages/mcps/src/mcp/local/contracts/preferences-schemas.ts
+var preferenceKeyValues = Object.values(PreferenceKey);
+var preferenceValueValues = Object.values(PreferenceValue);
+var PreferencesSetInputSchema = z.object({
+  key: z.enum(preferenceKeyValues).describe("The preference key to set."),
+  value: z.enum(preferenceValueValues).describe("The value. Most keys accept always/ask/never; defaultExecutionMode accepts local/remote/ask."),
+  scope: z.enum(["global", "project"]).default("global").describe("Write to global (~/.muggle-ai/) or project (.muggle-ai/) preferences."),
+  cwd: z.string().optional().describe("Project root directory. Required when scope is 'project'.")
+}).superRefine((data, ctx) => {
+  const allowed = PREFERENCE_ALLOWED_VALUES[data.key];
+  if (!allowed.includes(data.value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Value "${data.value}" is not allowed for preference "${data.key}". Allowed: ${allowed.join(", ")}`,
+      path: ["value"]
+    });
+  }
+});
+var LastProjectGetInputSchema = z.object({
+  cwd: z.string().describe("Project root directory whose last-used project to return.")
+});
+var LastProjectSetInputSchema = z.object({
+  cwd: z.string().describe("Project root directory to save the cached project to."),
+  projectId: z.string().min(1).describe("Muggle project ID."),
+  projectUrl: z.string().min(1).describe("Muggle project URL."),
+  projectName: z.string().min(1).describe("Muggle project name.")
+});
+var LastProjectClearInputSchema = z.object({
+  cwd: z.string().describe("Project root directory whose last-used project cache to remove.")
+});
 function isFirstRun(dataDirOverride) {
   const filePath = path2.join(dataDirOverride ?? getDataDir(), PREFERENCES_FILE_NAME);
   return !fs5.existsSync(filePath);
@@ -5443,12 +5489,51 @@ function resetPreference(key, scope, dataDirOverride, cwd) {
 }
 function validatePreference(key, value) {
   const validKeys = Object.values(PreferenceKey);
-  const validValues = Object.values(PreferenceValue);
-  return validKeys.includes(key) && validValues.includes(value);
+  if (!validKeys.includes(key)) {
+    return false;
+  }
+  const allowed = PREFERENCE_ALLOWED_VALUES[key];
+  return allowed.includes(value);
 }
 function formatPreferencesOneLiner(prefs) {
   return Object.entries(prefs).map(([key, value]) => `${key}=${value}`).join(" ");
 }
+var LAST_PROJECT_FILE_NAME = "last-project.json";
+var LAST_PROJECT_DIR_NAME = ".muggle-ai";
+var LAST_PROJECT_VERSION = 1;
+function readLastProject(cwd) {
+  const filePath = path2.join(cwd, LAST_PROJECT_DIR_NAME, LAST_PROJECT_FILE_NAME);
+  try {
+    if (!fs5.existsSync(filePath)) {
+      return null;
+    }
+    const raw = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+    return raw.lastProject ?? null;
+  } catch (error) {
+    getLogger().warn("Failed to read last-project file", {
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function writeLastProject(cwd, lastProject) {
+  const dir = path2.join(cwd, LAST_PROJECT_DIR_NAME);
+  fs5.mkdirSync(dir, { recursive: true });
+  const filePath = path2.join(dir, LAST_PROJECT_FILE_NAME);
+  const file = {
+    version: LAST_PROJECT_VERSION,
+    lastProject: { ...lastProject, savedAt: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+  fs5.writeFileSync(filePath, `${JSON.stringify(file, null, 2)}
+`, "utf-8");
+}
+function clearLastProject(cwd) {
+  const filePath = path2.join(cwd, LAST_PROJECT_DIR_NAME, LAST_PROJECT_FILE_NAME);
+  if (fs5.existsSync(filePath)) {
+    fs5.unlinkSync(filePath);
+  }
+}
 
 // packages/mcps/src/mcp/tools/local/tool-registry.ts
 function createChildLogger2(correlationId) {
@@ -5918,6 +6003,76 @@ var preferencesSetTool = {
     return { content, isError: false };
   }
 };
+var lastProjectGetTool = {
+  name: "muggle-local-last-project-get",
+  description: "Get the cached last-used Muggle project for a repo (read from <cwd>/.muggle-ai/last-project.json). Returns the project ID, URL, name, and saved-at timestamp, or null if no cache exists. Skills consult this when 'autoSelectProject = always' to silently reuse the project the user picked previously, instead of presenting the project picker every time.",
+  inputSchema: LastProjectGetInputSchema,
+  execute: async (ctx) => {
+    const logger6 = createChildLogger2(ctx.correlationId);
+    logger6.info("Executing muggle-local-last-project-get");
+    const input = LastProjectGetInputSchema.parse(ctx.input);
+    const cached = readLastProject(input.cwd);
+    if (!cached) {
+      const content2 = [
+        "No cached last-used project for this repo.",
+        "",
+        `Looked at: \`${input.cwd}/.muggle-ai/${LAST_PROJECT_FILE_NAME}\``,
+        "",
+        "The cache is populated when a user picks an existing project AND chooses 'Yes, save it' on the memory picker (the autoSelectProject preference)."
+      ].join("\n");
+      return { content: content2, isError: false };
+    }
+    const content = [
+      "**Cached last-used project:**",
+      "",
+      `- ID: \`${cached.projectId}\``,
+      `- URL: ${cached.projectUrl}`,
+      `- Name: ${cached.projectName}`,
+      `- Saved at: ${cached.savedAt}`
+    ].join("\n");
+    return { content, isError: false };
+  }
+};
+var lastProjectSetTool = {
+  name: "muggle-local-last-project-set",
+  description: "Save the user's selected Muggle project as the cached last-used project for this repo. Writes to <cwd>/.muggle-ai/last-project.json. Subsequent skill invocations honor 'autoSelectProject = always' by silently reusing this entry \u2014 no project picker shown. Always pair this call with 'muggle-local-preferences-set autoSelectProject=always' when the user chose 'Yes, save it'.",
+  inputSchema: LastProjectSetInputSchema,
+  execute: async (ctx) => {
+    const logger6 = createChildLogger2(ctx.correlationId);
+    logger6.info("Executing muggle-local-last-project-set");
+    const input = LastProjectSetInputSchema.parse(ctx.input);
+    writeLastProject(input.cwd, {
+      projectId: input.projectId,
+      projectUrl: input.projectUrl,
+      projectName: input.projectName
+    });
+    const content = [
+      `Cached **${input.projectName}** as the last-used project for this repo.`,
+      "",
+      `Written to: \`${input.cwd}/.muggle-ai/${LAST_PROJECT_FILE_NAME}\``,
+      "",
+      "Skills will silently reuse this project on future runs when `autoSelectProject = always`."
+    ].join("\n");
+    return { content, isError: false };
+  }
+};
+var lastProjectClearTool = {
+  name: "muggle-local-last-project-clear",
+  description: "Remove the cached last-used project for this repo. After this, `autoSelectProject = always` will fall through to ask until the user picks a new project. No-op if no cache exists.",
+  inputSchema: LastProjectClearInputSchema,
+  execute: async (ctx) => {
+    const logger6 = createChildLogger2(ctx.correlationId);
+    logger6.info("Executing muggle-local-last-project-clear");
+    const input = LastProjectClearInputSchema.parse(ctx.input);
+    clearLastProject(input.cwd);
+    const content = [
+      "Cleared the cached last-used project for this repo.",
+      "",
+      `Path: \`${input.cwd}/.muggle-ai/${LAST_PROJECT_FILE_NAME}\``
+    ].join("\n");
+    return { content, isError: false };
+  }
+};
 var allLocalQaTools = [
   // Status tools
   checkStatusTool,
@@ -5935,7 +6090,11 @@ var allLocalQaTools = [
   // Publishing tools
   publishTestScriptTool,
   // Preferences tools
-  preferencesSetTool
+  preferencesSetTool,
+  // Last-project cache tools (per-repo "last used Muggle project")
+  lastProjectGetTool,
+  lastProjectSetTool,
+  lastProjectClearTool
 ];
 var toolMap = new Map(
   allLocalQaTools.map((tool) => [tool.name, tool])
@@ -6075,6 +6234,9 @@ __export(local_exports2, {
   ExecuteTestGenerationInputSchema: () => ExecuteTestGenerationInputSchema,
   ExecutionStatus: () => ExecutionStatus,
   HealthStatus: () => HealthStatus,
+  LastProjectClearInputSchema: () => LastProjectClearInputSchema,
+  LastProjectGetInputSchema: () => LastProjectGetInputSchema,
+  LastProjectSetInputSchema: () => LastProjectSetInputSchema,
   ListSessionsInputSchema: () => ListSessionsInputSchema,
   LocalRunStatus: () => LocalRunStatus,
   LocalRunType: () => LocalRunType,
@@ -6151,4 +6313,4 @@ var plugins_exports = {};
 // packages/mcps/src/mcp/agents/index.ts
 var agents_exports = {};
 
-export { DEFAULT_PREFERENCES, PREFERENCES_FILE_NAME, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_SCHEMA, PREFERENCES_VERSION, PreferenceKey, PreferenceValue, __export, __require, buildElectronAppChecksumsUrl, buildElectronAppReleaseAssetUrl, buildElectronAppReleaseTag, calculateFileChecksum, createApiKeyWithToken, createChildLogger, deleteApiKeyData, deleteCredentials, e2e_exports2 as e2e_exports, formatPreferencesOneLiner, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDataDir2 as getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppVersion, getElectronAppVersionSource, getLocalQaTools, getLogger, getPlatformKey, getQaTools, getValidApiKeyData, getValidCredentials, hasApiKey, isElectronAppInstalled, isFirstRun, loadApiKeyData, loadCredentials, local_exports2 as local_exports, mcp_exports, openBrowserUrl, performLogin, performLogout, pollDeviceCode, readGlobalPreferences, readProjectPreferences, resetConfig, resetLogger, resetPreference, resolvePreferences, saveApiKey, saveApiKeyData, saveCredentials, src_exports, startDeviceCodeFlow, toolRequiresAuth, validatePreference, verifyFileChecksum, writePreferences };
+export { DEFAULT_PREFERENCES, PREFERENCES_FILE_NAME, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_SCHEMA, PREFERENCES_VERSION, PREFERENCE_ALLOWED_VALUES, PreferenceKey, PreferenceValue, __export, __require, buildElectronAppChecksumsUrl, buildElectronAppReleaseAssetUrl, buildElectronAppReleaseTag, calculateFileChecksum, createApiKeyWithToken, createChildLogger, deleteApiKeyData, deleteCredentials, e2e_exports2 as e2e_exports, formatPreferencesOneLiner, getApiKey, getApiKeyFilePath, getAuthService, getBundledElectronAppVersion, getCallerCredentials, getCallerCredentialsAsync, getChecksumForPlatform, getConfig, getCredentialsFilePath, getDataDir2 as getDataDir, getDownloadBaseUrl, getElectronAppChecksums, getElectronAppDir, getElectronAppVersion, getElectronAppVersionSource, getLocalQaTools, getLogger, getPlatformKey, getQaTools, getValidApiKeyData, getValidCredentials, hasApiKey, isElectronAppInstalled, isFirstRun, loadApiKeyData, loadCredentials, local_exports2 as local_exports, mcp_exports, openBrowserUrl, performLogin, performLogout, pollDeviceCode, readGlobalPreferences, readProjectPreferences, resetConfig, resetLogger, resetPreference, resolvePreferences, saveApiKey, saveApiKeyData, saveCredentials, src_exports, startDeviceCodeFlow, toolRequiresAuth, validatePreference, verifyFileChecksum, writePreferences };

package/dist/cli.js

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

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

@@ -1,7 +1,7 @@
 {
   "name": "muggle",
   "description": "Run real-browser end-to-end (E2E) acceptance tests on your web app from any AI coding agent. Generate test scripts from plain English, replay them on localhost, capture screenshots, and validate user flows like signup, checkout, and dashboards. Works across Claude Code, Cursor, Codex, and Windsurf.",
-  "version": "4.9.1",
+  "version": "4.10.0",
   "author": {
     "name": "Muggle AI",
     "email": "support@muggle-ai.com"
@@ -9,13 +9,6 @@
   "homepage": "https://www.muggletest.com",
   "repository": "https://github.com/multiplex-ai/muggle-ai-works",
   "license": "MIT",
-  "agents": [
-    {
-      "name": "acceptance-tester",
-      "path": "agents/acceptance-tester.md",
-      "description": "E2E acceptance testing agent — runs real-browser tests, reports structured results with blocking issues and suggested fixes, imports test artifacts, manages preferences, and operates the Muggle AI suite."
-    }
-  ],
   "keywords": [
     "acceptance-testing",
     "testing",

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

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

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

@@ -1,14 +1,7 @@
 ---
 name: acceptance-tester
-description: >-
-  E2E acceptance testing agent — runs real-browser tests against web apps and
-  reports structured results with blocking issues and suggested fixes. Also
-  imports existing test artifacts, manages Muggle preferences, and operates
-  the Muggle AI suite (status checks, repairs). Dispatch this agent when the
-  team needs acceptance test feedback, test coverage for a feature, or Muggle
-  suite operations.
+description: "E2E acceptance testing agent — runs real-browser tests against web apps and reports structured results with blocking issues and suggested fixes. Also imports existing test artifacts, manages Muggle preferences, and operates the Muggle AI suite (status checks, repairs). Dispatch this agent when the team needs acceptance test feedback, test coverage for a feature, or Muggle suite operations."
 model: sonnet
-tools: ["Read", "Write", "Edit", "Bash", "Grep", "Glob"]
 ---
 
 # Acceptance Tester

package/dist/plugin/scripts/ensure-electron-app.sh

@@ -100,7 +100,30 @@ else
   prefs_file_note="\\n\\nMuggle Preferences: not configured. Run \\\`muggle setup\\\` or tell the agent to set preferences."
 fi
 
-context="<EXTREMELY_IMPORTANT>\nYou have access to Muggle AI — a real-browser E2E acceptance testing tool.\n\nWhenever the user asks you to test, validate, verify, or check if their web app works — use the muggle MCP tools. This includes:\n- Testing user flows (signup, login, checkout, forms, dashboards)\n- Verifying UI changes didn't break anything\n- Running regression tests after code changes\n- Validating frontend behavior on localhost or a dev server\n- Checking if a feature works before merging a PR\n\nMuggle launches a real Electron browser that clicks buttons, fills forms, navigates pages, and captures screenshots. It generates replayable test scripts that persist across sessions.\n\nDo NOT write test code (Playwright, Cypress, Selenium) or try to test UI manually when muggle tools are available. Use the muggle skill or muggle MCP tools instead — they are faster, capture visual evidence, and produce reusable test scripts.\n\nTrigger phrases: 'test my app', 'check if it works', 'run E2E acceptance tests', 'validate the UI', 'verify the flow', 'regression test', 'make sure it still works', 'test before merging'.\n</EXTREMELY_IMPORTANT>${upgrade_notice}${prefs_file_note}"
+# --- Last-project cache injection ---
+# Per-repo "last used Muggle project" cache. Lives at <cwd>/.muggle-ai/last-project.json
+# and is honored by skills when autoSelectProject = always.
+last_project_line=""
+last_project_note=""
+last_project_line=$(node -e "
+  const fs = require('fs');
+  const path = require('path');
+  try {
+    const cwd = process.env.CLAUDE_CWD || process.env.CURSOR_CWD || process.cwd();
+    const lpPath = path.join(cwd, '.muggle-ai', 'last-project.json');
+    if (!fs.existsSync(lpPath)) { console.log(''); return; }
+    const raw = JSON.parse(fs.readFileSync(lpPath, 'utf-8'));
+    const lp = raw && raw.lastProject;
+    if (!lp || !lp.projectId) { console.log(''); return; }
+    const safeName = String(lp.projectName || '').replace(/\"/g, '\\\\\"');
+    console.log('Muggle Last Project: id=' + lp.projectId + ' url=' + lp.projectUrl + ' name=\"' + safeName + '\"');
+  } catch { console.log(''); }
+" 2>/dev/null || true)
+if [ -n "$last_project_line" ]; then
+  last_project_note="\\n\\n${last_project_line}"
+fi
+
+context="<EXTREMELY_IMPORTANT>\nYou have access to Muggle AI — a real-browser E2E acceptance testing tool.\n\nWhenever the user asks you to test, validate, verify, or check if their web app works — use the muggle MCP tools. This includes:\n- Testing user flows (signup, login, checkout, forms, dashboards)\n- Verifying UI changes didn't break anything\n- Running regression tests after code changes\n- Validating frontend behavior on localhost or a dev server\n- Checking if a feature works before merging a PR\n\nMuggle launches a real Electron browser that clicks buttons, fills forms, navigates pages, and captures screenshots. It generates replayable test scripts that persist across sessions.\n\nDo NOT write test code (Playwright, Cypress, Selenium) or try to test UI manually when muggle tools are available. Use the muggle skill or muggle MCP tools instead — they are faster, capture visual evidence, and produce reusable test scripts.\n\nTrigger phrases: 'test my app', 'check if it works', 'run E2E acceptance tests', 'validate the UI', 'verify the flow', 'regression test', 'make sure it still works', 'test before merging'.\n</EXTREMELY_IMPORTANT>${upgrade_notice}${prefs_file_note}${last_project_note}"
 
 escaped_context=$(escape_for_json "$context")
 

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

@@ -9,20 +9,11 @@ Use this as the top-level Muggle command router.
 
 ## Preferences
 
-User preferences are available in the session context (injected at session start). Look for the line starting with `Muggle Preferences` — it contains key=value pairs like `autoLogin=ask showElectronBrowser=always ...`.
+User preferences are injected by the SessionStart hook into a `Muggle Preferences` line in session context (key=value pairs). Resolution: defaults → `~/.muggle-ai/preferences.json` (global) → `<repo>/.muggle-ai/preferences.json` (project). Treat absent prefs as `ask`.
 
-If no preferences line is present, treat all preferences as `"ask"`.
+This router skill itself does not gate any decision on a preference — it just routes user intent to a downstream skill. Each downstream skill consults its own preferences. For example, `checkForUpdates` is consulted by `muggle-status` (Check 4), not here.
 
-When you reach a decision gated by a preference:
-- **`always`** → proceed without asking the user
-- **`never`** → skip without asking the user  
-- **`ask`** → ask the user, then offer: "Want me to remember this choice for future sessions?" If yes, call `muggle-local-preferences-set` with the key, their chosen value, and scope `global`.
-
-This skill uses these preferences:
-
-| Preference | Decision it gates |
-|------------|------------------|
-| `checkForUpdates` | Check for newer Muggle version |
+If the user types "muggle" with no subcommand and you want to surface a contextual hint about the update-check pref, defer to `muggle-status` rather than reimplementing the gate in this router.
 
 ## Menu
 

package/dist/plugin/skills/muggle-pr-visual-walkthrough/SKILL.md

@@ -19,20 +19,13 @@ Rendering is always done by `muggle build-pr-section`, a battle-tested CLI that
 
 ## Preferences
 
-User preferences are available in the session context (injected at session start). Look for the line starting with `Muggle Preferences` — it contains key=value pairs like `autoLogin=ask showElectronBrowser=always ...`.
+This skill is invoked by callers (`muggle-test`, `muggle-test-feature-local`, `muggle-do`) **after** the caller has already consulted the `postPRVisualWalkthrough` gate and decided to post. Therefore **the gating happens upstream, not in this skill** — by the time this skill runs, the user has already approved posting (either via the saved gate value or by explicit pick).
 
-If no preferences line is present, treat all preferences as `"ask"`.
+| Preference | Where it's gated | Decision it gates |
+|------------|------------------|-------------------|
+| `postPRVisualWalkthrough` | Caller skill (e.g. `muggle-test` Step 9, `muggle-test-feature-local` Step 10) | Post visual walkthrough to PR |
 
-When you reach a decision gated by a preference:
-- **`always`** → proceed without asking the user
-- **`never`** → skip without asking the user  
-- **`ask`** → ask the user, then offer: "Want me to remember this choice for future sessions?" If yes, call `muggle-local-preferences-set` with the key, their chosen value, and scope `global`.
-
-This skill uses these preferences:
-
-| Preference | Decision it gates |
-|------------|------------------|
-| `postPRVisualWalkthrough` | Post visual walkthrough to PR |
+Per-key gate definitions live in `plugin/skills/muggle-preferences/preference-gates/`. This skill only renders and posts.
 
 ## Input contract: the `E2eReport` JSON
 

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

@@ -6,7 +6,7 @@ description: >-
   defaults, or manage muggle config. Triggers on: 'muggle preferences',
   'show muggle settings', 'change muggle preference', 'set autoLogin to
   always', 'muggle config', 'reset muggle preferences', 'show my muggle
-  settings', 'configure muggle'.
+  settings', 'configure muggle', 'muggle setup'.
 ---
 
 # Muggle Preferences
@@ -15,68 +15,109 @@ View, set, or reset the preference knobs that control Muggle AI behavior.
 
 ## Operations
 
-Parse the user's request to determine which operation to perform:
+Parse the user's request to decide which operation to run:
 
-- **List** — user wants to see current values (default when no specific change requested)
-- **Set** — user wants to change a specific preference
-- **Reset** — user wants to restore a preference (or all preferences) to defaults
+- **List** — show current values. Default when no change is requested.
+- **Change one** — re-run the gate's picker for a single key. Use this when the user invokes `/muggle-preferences <key>` or says "change my <key> preference".
+- **Configure** — interactive picker covering all keys at once. Default when the user wants to change preferences but hasn't named a specific one (e.g. "muggle setup", "configure muggle", "change my preferences").
+- **Set** — direct set when the user names a key+value (e.g. "set autoLogin to always").
+- **Reset** — restore preferences to default (`ask`).
 
-## List
+Per-key files live in `preference-gates/` — one `<key>.md` per key, plus `README.md` for the contract (`always`/`never`/`ask`, Picker 2 template, silent footer, re-prompt rule). The full key list = `ls preference-gates/*.md` minus `README.md`.
+
+## Reading current values
+
+Read preferences from session context. Look for the line starting with `Muggle Preferences` — it contains key=value pairs like `autoLogin=ask showElectronBrowser=always ...`.
 
-1. Read preferences from session context. Look for the line starting with `Muggle Preferences` — it contains key=value pairs like `autoLogin=ask showElectronBrowser=always ...`.
+If no preferences line is present, treat all preferences as `"ask"` (the default).
 
-   If no preferences line is present, treat all preferences as `"ask"` (the default).
+## List
 
-2. Present all 12 preferences in a table:
+Render a `Preference | Value | Description` table titled `Muggle AI — Preferences`.
+- Keys: every `preference-gates/<key>.md` (excluding `README.md`).
+- Values: from session context (default `ask`).
+- Description: each gate file's first paragraph.
 
+Footer:
 ```
-Muggle AI — Preferences
-
-| Preference               | Value  | Description                                              |
-|--------------------------|--------|----------------------------------------------------------|
-| autoLogin                | ask    | Reuse saved credentials without prompting                |
-| autoSelectProject        | ask    | Reuse last-used project for this repo                    |
-| showElectronBrowser      | ask    | Show browser window during local tests                   |
-| openTestResultsAfterRun  | ask    | Open results page on dashboard after local test          |
-| defaultExecutionMode     | ask    | Default to local or remote test execution                |
-| autoPublishLocalResults  | ask    | Upload local results to Muggle cloud                     |
-| suggestRelatedUseCases   | ask    | Suggest related use cases after creating/running one     |
-| suggestRelatedTestCases  | ask    | Suggest related test cases after creating/running one    |
-| autoDetectChanges        | ask    | Scan local git changes and map to affected test cases    |
-| postPRVisualWalkthrough  | ask    | Post visual walkthrough with screenshots to PR           |
-| checkForUpdates          | ask    | Check for newer Muggle version at session start          |
-| verboseOutput            | ask    | Show detailed progress logs during execution             |
-
-Values: always (proceed without asking) · ask (prompt each time) · never (skip without asking)
+Values: always · ask · never (defaultExecutionMode: local/remote/ask)
 Scope:  global (~/.muggle-ai/) or project (.muggle-ai/ in repo root)
 ```
 
-## Set
+## Change one (single-key picker)
+
+Use this when the user invokes `/muggle-preferences <key>` or says "change my <key> preference" / "show me the <key> options". Behavior:
+
+1. Check that `preference-gates/<key>.md` exists. If not, list `preference-gates/*.md` and ask.
+2. Open it, run **Picker 1 only**.
+3. Call `muggle-local-preferences-set` with the mapped value, `scope: "global"`. **Skip Picker 2** (user explicitly asked to change).
+4. Confirm: `Set <key> to <value>.`
+
+This is the entry point that silent-mode footers point at, so its UX must mirror the per-key gate exactly — same question, same options, same mappings.
+
+## Configure (interactive picker)
+
+Use this whenever the user wants to change preferences without naming a specific key. The flow runs in a single `AskUserQuestion` call so the user can toggle preferences with the keyboard instead of typing key names.
+
+### Step 1 — show current state
+
+Print the preference table from the **List** section so the user sees what's set today.
+
+### Step 2 — tell the user how to drive the picker
+
+Print this instruction block verbatim before calling `AskUserQuestion`:
+
+```
+How to use this picker:
+  ↑/↓        move between options
+  space      toggle a preference (selected = set to `always`)
+  tab        move to the next question
+  enter      confirm
+
+Anything you don't toggle keeps its current value. After this picker
+you can tell me which (if any) should instead be set to `never`.
+```
+
+### Step 3 — call AskUserQuestion
+
+Group keys into categories below (only place this UX grouping lives — not in the gate dir). For each option: label = key name, description = first paragraph of `preference-gates/<key>.md`.
 
-1. Parse the requested key and value from the user's message.
+- `multiSelect: true`, `header: "Auth & session"` — `autoLogin`, `autoSelectProject`, `checkForUpdates`, `verboseOutput`
+- `multiSelect: true`, `header: "Test run"` — `showElectronBrowser`, `openTestResultsAfterRun`, `autoPublishLocalResults`, `autoDetectChanges`
+- `multiSelect: true`, `header: "Suggestions & PR"` — `suggestRelatedUseCases`, `suggestRelatedTestCases`, `postPRVisualWalkthrough`
+- `multiSelect: false`, `header: "Default mode"` — `defaultExecutionMode`. Options: `Local — run on my computer` (`local`), `Remote — run in the Muggle cloud` (`remote`), `Ask each time` (don't change).
+- `multiSelect: false`, `header: "Scope"` — final scope question. Options: `Global (all repos)` (~/.muggle-ai/), `This project only` (.muggle-ai/ in repo).
 
-2. Validate the key is one of: `autoLogin`, `autoSelectProject`, `showElectronBrowser`, `openTestResultsAfterRun`, `defaultExecutionMode`, `autoPublishLocalResults`, `suggestRelatedUseCases`, `suggestRelatedTestCases`, `autoDetectChanges`, `postPRVisualWalkthrough`, `checkForUpdates`, `verboseOutput`.
+For the multi-select questions: text = `Which of these should auto-proceed (set to "always")?`; selected = `always`.
 
-   If the key is ambiguous or not recognized, show the full list and ask the user to clarify.
+`AskUserQuestion` accepts up to 4 questions per call — split into two calls if needed (categories first, scope second).
 
-3. Validate the value is one of: `always`, `ask`, `never`.
+### Step 4 — apply selections
 
-4. Determine scope:
-   - Default to `global`.
-   - If the user says "for this project", "project-level", or "just this repo", use `project` scope and pass `cwd` as the current working directory.
+For each toggled key (multi-select questions): `muggle-local-preferences-set` with `value: "always"`. For `defaultExecutionMode`: only set if user picked Local/Remote (skip "Ask each time"). Pass `scope` from the scope question; pass `cwd` when scope is `project`.
 
-5. Call `muggle-local-preferences-set` with:
-   - `key`: The preference key
-   - `value`: The chosen value
-   - `scope`: `"global"` or `"project"`
-   - `cwd`: Current working directory (required when scope is `"project"`)
+### Step 5 — offer the `never` follow-up
 
+Ask: `Want any of these set to "never" (auto-skip without asking)? Name them, e.g. "never on autoPublishLocalResults", or say "no".`. For named keys, call `muggle-local-preferences-set` with `value: "never"`, same scope.
+
+### Step 6 — confirm
+
+Print a one-liner summary: `Set autoLogin=always, openTestResultsAfterRun=always (global).`
+
+## Set (direct)
+
+When the user names both key and value (e.g. "set autoLogin to always", "make showElectronBrowser never for this project"):
+
+1. Parse `key` and `value` from the user's message.
+2. Validate `key`: `preference-gates/<key>.md` must exist. If not, list `preference-gates/*.md` and ask.
+3. Validate `value`: must be `always`/`never`/`ask` for all keys; `defaultExecutionMode` accepts `local`/`remote`/`ask` instead.
+4. Scope defaults to `global`. If user says "for this project" / "just this repo", use `project` and pass `cwd`.
+5. Call `muggle-local-preferences-set`.
 6. Confirm: `Set {key} to {value} ({scope}).`
 
 ## Reset
 
-1. If the user asks to reset a **specific key**: call `muggle-local-preferences-set` with `value: "ask"` for that key.
-
-2. If the user asks to reset **all preferences**: call `muggle-local-preferences-set` for each of the 12 keys with `value: "ask"`.
+- Specific key: `muggle-local-preferences-set` with `value: "ask"` for that key.
+- All preferences: same call for every `preference-gates/<key>.md`.
 
-3. Confirm what was reset.
+Confirm what was reset.