@muggleai/works 4.9.2 → 4.10.1

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

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'url';
 import { spawn, exec } from 'child_process';
 import axios, { AxiosError } from 'axios';
 import * as fs7 from 'fs/promises';
+import AppInsights from 'applicationinsights';
 import { z } from 'zod';
 
 var __defProp = Object.defineProperty;
@@ -33,6 +34,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,
@@ -83,6 +85,7 @@ __export(src_exports, {
   resetConfig: () => resetConfig,
   resetLogger: () => resetLogger,
   resetPreference: () => resetPreference,
+  resolveElectronAppPathOrNull: () => resolveElectronAppPathOrNull,
   resolvePreferences: () => resolvePreferences,
   saveApiKey: () => saveApiKey,
   saveApiKeyData: () => saveApiKeyData,
@@ -394,7 +397,6 @@ function buildLocalQaConfig() {
     tempDir: path2.join(dataDir, "temp"),
     apiKeyFilePath: path2.join(dataDir, API_KEY_FILE),
     oauthSessionFilePath: path2.join(dataDir, "oauth-session.json"),
-    electronAppPath: resolveElectronAppPathOrNull(),
     webServicePath: resolveWebServicePath(),
     webServicePidFile: path2.join(dataDir, "web-service.pid"),
     auth0: {
@@ -526,9 +528,9 @@ function resetLogger() {
 // packages/mcps/src/shared/checksum.ts
 var logger = getLogger();
 function getPlatformKey() {
-  const os4 = platform();
+  const os5 = platform();
   const arch2 = process.arch;
-  switch (os4) {
+  switch (os5) {
     case "darwin":
       return arch2 === "arm64" ? "darwin-arm64" : "darwin-x64";
     case "win32":
@@ -536,7 +538,7 @@ function getPlatformKey() {
     case "linux":
       return "linux-x64";
     default:
-      throw new Error(`Unsupported platform: ${os4}`);
+      throw new Error(`Unsupported platform: ${os5}`);
   }
 }
 async function calculateFileChecksum(filePath) {
@@ -1998,7 +2000,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"),
@@ -2100,29 +2102,28 @@ async function writeExecutionLogs(params) {
   });
 }
 function getElectronAppPathOrThrow() {
-  const config = getConfig();
-  const electronAppPath = config.localQa.electronAppPath;
-  if (!electronAppPath || electronAppPath.trim() === "") {
-    const version = getElectronAppVersion();
-    const versionDir = getElectronAppDir(version);
-    const envPath = process.env.ELECTRON_APP_PATH;
-    const errorLines = [
-      "Electron app binary not found.",
-      "",
-      `  Expected version: ${version}`,
-      `  Checked directory: ${versionDir}`
-    ];
-    if (envPath) {
-      errorLines.push(`  ELECTRON_APP_PATH: ${envPath} (not found or invalid)`);
-    } else {
-      errorLines.push("  ELECTRON_APP_PATH: (not set)");
-    }
-    errorLines.push("");
-    errorLines.push("To fix this, run: muggle setup");
-    errorLines.push("Or set ELECTRON_APP_PATH to the path of the MuggleAI executable.");
-    throw new Error(errorLines.join("\n"));
+  const electronAppPath = resolveElectronAppPathOrNull();
+  if (electronAppPath && electronAppPath.trim() !== "") {
+    return electronAppPath;
   }
-  return electronAppPath;
+  const version = getElectronAppVersion();
+  const versionDir = getElectronAppDir(version);
+  const envPath = process.env.ELECTRON_APP_PATH;
+  const errorLines = [
+    "Electron app binary not found.",
+    "",
+    `  Expected version: ${version}`,
+    `  Checked directory: ${versionDir}`
+  ];
+  if (envPath) {
+    errorLines.push(`  ELECTRON_APP_PATH: ${envPath} (not found or invalid)`);
+  } else {
+    errorLines.push("  ELECTRON_APP_PATH: (not set)");
+  }
+  errorLines.push("");
+  errorLines.push("To fix this, run: muggle setup");
+  errorLines.push("Or set ELECTRON_APP_PATH to the path of the MuggleAI executable.");
+  throw new Error(errorLines.join("\n"));
 }
 function getRequiredStringField(params) {
   const value = params.source[params.fieldName];
@@ -2222,7 +2223,7 @@ function buildReplayActionScript(params) {
 async function executeElectronAppAsync(params) {
   const mode = params.runType === "generation" ? "explore" : "engine";
   const electronAppPath = getElectronAppPathOrThrow();
-  const spawnArgs = [mode, params.scriptFilePath, "", params.authFilePath];
+  const spawnArgs = [mode, params.scriptFilePath, params.mutationsFilePath ?? "", params.authFilePath];
   if (params.showUi) {
     spawnArgs.push("--show-ui");
   }
@@ -2370,11 +2371,16 @@ async function executeTestGeneration(params) {
       filename: `${runId}_auth.json`,
       data: authContent
     });
+    const mutationsFilePath = params.mutations && params.mutations.length > 0 ? await writeTempFile({
+      filename: `${runId}_mutations.json`,
+      data: params.mutations
+    }) : void 0;
     try {
       const executionResult = await executeElectronAppAsync({
         runId,
         runType: "generation",
         scriptFilePath: inputFilePath,
+        mutationsFilePath,
         authFilePath,
         timeoutMs,
         showUi: params.showUi,
@@ -2517,11 +2523,16 @@ async function executeReplay(params) {
       filename: `${runId}_auth.json`,
       data: authContent
     });
+    const mutationsFilePath = params.mutations && params.mutations.length > 0 ? await writeTempFile({
+      filename: `${runId}_mutations.json`,
+      data: params.mutations
+    }) : void 0;
     try {
       const executionResult = await executeElectronAppAsync({
         runId,
         runType: "replay",
         scriptFilePath: inputFilePath,
+        mutationsFilePath,
         authFilePath,
         timeoutMs,
         showUi: params.showUi,
@@ -2990,6 +3001,268 @@ __export(e2e_exports, {
   executeQaTool: () => executeQaTool,
   getQaToolByName: () => getQaToolByName
 });
+
+var ENV_CONNECTION_STRING = "APPLICATIONINSIGHTS_CONNECTION_STRING";
+var ENV_VITE_CONNECTION_STRING = "VITE_APPLICATIONINSIGHTS_CONNECTION_STRING";
+var ENV_TELEMETRY_DISABLED = "MUGGLE_TELEMETRY_DISABLED";
+
+var DATA_DIR_NAME2 = ".muggle-ai";
+var INSTALL_ID_FILENAME = "install-id.json";
+var PREFS_FILENAME = "preferences.json";
+var OAUTH_SESSION_FILENAME = "oauth-session.json";
+var RELEASE_MANIFEST_FILENAME = "release-manifest.json";
+function getDataDir3() {
+  return path2.join(os3.homedir(), DATA_DIR_NAME2);
+}
+
+var cachedInstallId;
+function installIdFilePath() {
+  return join(getDataDir3(), INSTALL_ID_FILENAME);
+}
+function generateAndPersist(filePath) {
+  const installId = randomUUID();
+  const contents = { installId };
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(contents, null, 2) + "\n", "utf8");
+  return installId;
+}
+function isValid(value) {
+  return typeof value === "object" && value !== null && typeof value.installId === "string" && value.installId.length > 0;
+}
+function getInstallId() {
+  if (cachedInstallId !== void 0)
+    return cachedInstallId;
+  const filePath = installIdFilePath();
+  if (!existsSync(filePath)) {
+    cachedInstallId = generateAndPersist(filePath);
+    return cachedInstallId;
+  }
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (isValid(parsed)) {
+      cachedInstallId = parsed.installId;
+      return cachedInstallId;
+    }
+    cachedInstallId = generateAndPersist(filePath);
+    return cachedInstallId;
+  } catch {
+    cachedInstallId = generateAndPersist(filePath);
+    return cachedInstallId;
+  }
+}
+
+var DEV_MANIFEST2 = {
+  release: "dev",
+  buildId: "dev",
+  commitSha: "dev",
+  buildTime: "1970-01-01T00:00:00Z",
+  serviceName: "muggle-ai-telemetry"
+};
+
+var MANIFEST_PATH2 = (() => {
+  try {
+    return join(dirname(fileURLToPath(import.meta.url)), RELEASE_MANIFEST_FILENAME);
+  } catch {
+    return RELEASE_MANIFEST_FILENAME;
+  }
+})();
+var cachedManifest2;
+function isValid2(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const m = value;
+  return typeof m.release === "string" && typeof m.buildId === "string" && typeof m.commitSha === "string" && typeof m.buildTime === "string" && typeof m.serviceName === "string";
+}
+function readReleaseManifest2() {
+  if (cachedManifest2 !== void 0)
+    return cachedManifest2;
+  const path15 = MANIFEST_PATH2;
+  try {
+    const raw = readFileSync(path15, "utf8");
+    const parsed = JSON.parse(raw);
+    cachedManifest2 = isValid2(parsed) ? parsed : DEV_MANIFEST2;
+    return cachedManifest2;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.warn("release-manifest: unexpected read error, using DEV fallback", {
+        error: err.message
+      });
+    }
+    cachedManifest2 = DEV_MANIFEST2;
+    return cachedManifest2;
+  }
+}
+function readUserId() {
+  const filePath = join(getDataDir3(), OAUTH_SESSION_FILENAME);
+  if (!existsSync(filePath))
+    return void 0;
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.userId === "string" && parsed.userId.length > 0) {
+      return parsed.userId;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+var state = null;
+function resolveConnectionString(explicit) {
+  if (explicit && explicit.length > 0)
+    return explicit;
+  return process.env[ENV_CONNECTION_STRING] ?? process.env[ENV_VITE_CONNECTION_STRING] ?? void 0;
+}
+function buildCommonProperties(serviceName, surface) {
+  const manifest = readReleaseManifest2();
+  const props = {
+    source: "client",
+    serviceName,
+    surface,
+    release: manifest.release,
+    buildId: manifest.buildId,
+    commitSha: manifest.commitSha,
+    buildTime: manifest.buildTime,
+    installId: getInstallId(),
+    nodeVersion: process.version,
+    platform: process.platform
+  };
+  const userId = readUserId();
+  if (userId !== void 0)
+    props.userId = userId;
+  return props;
+}
+function initTelemetry(options) {
+  if (state !== null && state.initialized)
+    return;
+  const connectionString = resolveConnectionString(options.connectionString);
+  if (!connectionString) {
+    state = {
+      client: null,
+      serviceName: options.serviceName,
+      surface: options.surface,
+      initialized: true
+    };
+    return;
+  }
+  try {
+    AppInsights.setup(connectionString).setUseDiskRetryCaching(true).setDistributedTracingMode(AppInsights.DistributedTracingModes.AI_AND_W3C).setAutoCollectRequests(false).setAutoCollectPerformance(false, false).setAutoCollectExceptions(true).setAutoCollectDependencies(false).setAutoCollectConsole(false).setSendLiveMetrics(false);
+    const client = AppInsights.defaultClient;
+    const manifest = readReleaseManifest2();
+    client.context.tags[client.context.keys.cloudRole] = options.serviceName;
+    client.context.tags[client.context.keys.applicationVersion] = manifest.release;
+    client.commonProperties = {
+      ...client.commonProperties,
+      ...buildCommonProperties(options.serviceName, options.surface)
+    };
+    AppInsights.start();
+    state = {
+      client,
+      serviceName: options.serviceName,
+      surface: options.surface,
+      initialized: true
+    };
+  } catch (err) {
+    console.warn("[muggle-telemetry] init failed; events will be dropped", {
+      error: err.message
+    });
+    state = {
+      client: null,
+      serviceName: options.serviceName,
+      surface: options.surface,
+      initialized: true
+    };
+  }
+}
+function getClient() {
+  return state?.client ?? null;
+}
+function prefsFilePath() {
+  return join(getDataDir3(), PREFS_FILENAME);
+}
+function readPreferences() {
+  const filePath = prefsFilePath();
+  if (!existsSync(filePath))
+    return {};
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+function isTelemetryEnabled() {
+  if (process.env[ENV_TELEMETRY_DISABLED] === "1")
+    return false;
+  const prefs = readPreferences();
+  if (prefs.telemetryEnabled === false)
+    return false;
+  return true;
+}
+
+function track(event) {
+  if (!isTelemetryEnabled())
+    return;
+  const client = getClient();
+  if (!client)
+    return;
+  try {
+    client.trackEvent({
+      name: event.name,
+      properties: event.props
+    });
+  } catch {
+  }
+}
+
+var Trigger;
+(function(Trigger2) {
+  Trigger2["UserSlash"] = "user-slash";
+  Trigger2["ClaudeProactive"] = "claude-proactive";
+  Trigger2["NestedSkill"] = "nested-skill";
+})(Trigger || (Trigger = {}));
+var Outcome;
+(function(Outcome2) {
+  Outcome2["Success"] = "success";
+  Outcome2["Error"] = "error";
+  Outcome2["Cancelled"] = "cancelled";
+})(Outcome || (Outcome = {}));
+var ToolSurface;
+(function(ToolSurface2) {
+  ToolSurface2["Local"] = "local";
+  ToolSurface2["Remote"] = "remote";
+})(ToolSurface || (ToolSurface = {}));
+var Surface;
+(function(Surface2) {
+  Surface2["McpLocal"] = "mcp-local";
+  Surface2["McpRemote"] = "mcp-remote";
+  Surface2["Skill"] = "skill";
+  Surface2["Electron"] = "electron";
+})(Surface || (Surface = {}));
+var ServiceName;
+(function(ServiceName2) {
+  ServiceName2["MuggleMcp"] = "muggle-mcp";
+  ServiceName2["MuggleElectron"] = "muggle-electron";
+  ServiceName2["MuggleSkill"] = "muggle-skill";
+})(ServiceName || (ServiceName = {}));
+var EventName;
+(function(EventName2) {
+  EventName2["SkillInvoked"] = "skill.invoked";
+  EventName2["SkillCompleted"] = "skill.completed";
+  EventName2["McpToolInvoked"] = "mcp.tool.invoked";
+  EventName2["McpToolCompleted"] = "mcp.tool.completed";
+  EventName2["SystemStartup"] = "system.startup";
+  EventName2["SystemOptOutChanged"] = "system.opt_out_changed";
+  EventName2["SystemDisclosureShown"] = "system.disclosure_shown";
+})(EventName || (EventName = {}));
 var MuggleEntityIdSchema = z.string().uuid();
 var LocalExecutionContextInputSchema = z.object({
   originalUrl: z.string().url().describe("Original local URL used during local execution (typically localhost)"),
@@ -3133,6 +3406,21 @@ var UseCaseUpdateFromPromptInputSchema = z.object({
   useCaseId: IdSchema.describe("Use case ID (UUID) to update"),
   instruction: z.string().min(1).describe("Natural language instruction to regenerate the use case from")
 });
+var UseCaseUpdateInputSchema = z.object({
+  useCaseId: IdSchema.describe("Use case ID (UUID) to update"),
+  title: z.string().min(1).optional().describe("Updated use case title"),
+  description: z.string().min(1).optional().describe("Updated description"),
+  userStory: z.string().min(1).optional().describe("Updated one-line user story"),
+  url: z.string().url().optional().describe("Updated target URL"),
+  useCaseBreakdown: z.array(z.object({
+    requirement: z.string().min(1).describe("One requirement of the use case"),
+    acceptanceCriteria: z.string().min(1).describe("Concrete, measurable acceptance criteria for the requirement")
+  })).optional().describe("Updated main/alternative/error flows as requirement + acceptance criteria pairs"),
+  status: z.enum(["DRAFT", "IN_REVIEW", "APPROVED", "IMPLEMENTED", "ARCHIVED"]).optional().describe("Updated status"),
+  priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]).optional().describe("Updated priority"),
+  source: z.enum(["PRD_FILE", "SITEMAP", "CRAWLER", "PROMPT", "MANUAL"]).optional().describe("Updated source"),
+  category: z.string().optional().describe("Updated category")
+});
 var UseCaseCreateInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) the use case belongs to"),
   title: z.string().min(1).describe("Use case title"),
@@ -3216,6 +3504,20 @@ var TestCaseCreateInputSchema = z.object({
   category: z.string().optional().describe("Test case category"),
   automated: z.boolean().optional().describe("Whether this test case is automated (default: true)")
 });
+var TestCaseUpdateInputSchema = z.object({
+  testCaseId: IdSchema.describe("Test case ID (UUID) to update"),
+  title: z.string().min(1).optional().describe("Updated test case title"),
+  description: z.string().min(1).optional().describe("Updated description"),
+  goal: z.string().min(1).optional().describe("Updated goal"),
+  precondition: z.string().optional().describe("Updated precondition"),
+  expectedResult: z.string().min(1).optional().describe("Updated expected result"),
+  url: z.string().url().optional().describe("Updated target URL"),
+  status: z.enum(["DRAFT", "ACTIVE", "DEPRECATED", "ARCHIVED"]).optional().describe("Updated status"),
+  priority: z.enum(["HIGH", "MEDIUM", "LOW"]).optional().describe("Updated priority"),
+  tags: z.array(z.string()).optional().describe("Updated tags"),
+  category: z.string().optional().describe("Updated category"),
+  automated: z.boolean().optional().describe("Whether this test case is automated")
+});
 var TestScriptListInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to list test scripts for"),
   testCaseId: IdSchema.optional().describe("Optional test case ID (UUID) to filter scripts by")
@@ -3366,6 +3668,34 @@ var ApiKeyGetInputSchema = z.object({
 var ApiKeyRevokeInputSchema = z.object({
   apiKeyId: ApiKeyRecordIdSchema.describe("ID of the API key record to revoke")
 });
+var UserFeedbackTargetTypeSchema = z.enum(["actionScript", "step"]);
+var UserFeedbackTargetSchema = z.object({
+  targetType: UserFeedbackTargetTypeSchema.describe("Target entity kind: 'actionScript' for whole-script feedback, 'step' for a specific step"),
+  targetId: z.string().min(1).describe("Target identifier. For 'actionScript' use the actionScriptId; for 'step' use `${actionScriptId}:${stepIndex}` (0-based stepIndex)")
+});
+var UserFeedbackCreateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) the feedback belongs to"),
+  target: UserFeedbackTargetSchema.describe("What entity this feedback is about (action script or a specific step)"),
+  feedbackText: z.string().min(1).describe("Free-form paragraph describing what went wrong and what the expected behavior should be")
+});
+var UserFeedbackListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) to list feedback for. Always required \u2014 defines the auth boundary."),
+  actionScriptId: IdSchema.optional().describe("Narrow to feedback whose target resolves to this action script. Mutually exclusive with the other narrowing filters."),
+  testScriptId: IdSchema.optional().describe("Narrow to feedback on the action script of this test script. Mutually exclusive with the other narrowing filters."),
+  testCaseId: IdSchema.optional().describe("Narrow to feedback on any action script ever generated for this test case. Mutually exclusive with the other narrowing filters."),
+  useCaseId: IdSchema.optional().describe("Narrow to feedback on any action script ever generated under this use case. Mutually exclusive with the other narrowing filters."),
+  limit: z.number().int().positive().max(1e3).optional().describe("Max entries to return (default 100)"),
+  offset: z.number().int().min(0).optional().describe("Offset for pagination (default 0)")
+}).refine(
+  (data) => {
+    const set = [data.actionScriptId, data.testScriptId, data.testCaseId, data.useCaseId].filter(Boolean);
+    return set.length <= 1;
+  },
+  { message: "At most one of actionScriptId / testScriptId / testCaseId / useCaseId may be set" }
+);
+var UserFeedbackDeleteInputSchema = z.object({
+  feedbackId: IdSchema.describe("User feedback ID (UUID) to soft-delete")
+});
 var AuthLoginInputSchema = z.object({
   waitForCompletion: z.boolean().optional().describe("Whether to wait for browser login completion before returning. Default: true"),
   timeoutMs: z.number().int().positive().min(1e3).max(9e5).optional().describe("Maximum time to wait for login completion in milliseconds. Default: 120000"),
@@ -3418,40 +3748,40 @@ function detectMcpHost(env = process.env) {
   }
   return "unknown";
 }
-var INSTALL_ID_FILENAME = "install-id.json";
-var cachedInstallId;
-function installIdFilePath() {
-  return join(getDataDir(), INSTALL_ID_FILENAME);
+var INSTALL_ID_FILENAME2 = "install-id.json";
+var cachedInstallId2;
+function installIdFilePath2() {
+  return join(getDataDir(), INSTALL_ID_FILENAME2);
 }
-function generateAndPersist(filePath) {
+function generateAndPersist2(filePath) {
   const installId = randomUUID();
   const contents = { installId };
   mkdirSync(dirname(filePath), { recursive: true });
   writeFileSync(filePath, JSON.stringify(contents, null, 2) + "\n", "utf8");
   return installId;
 }
-function isValid(value) {
+function isValid3(value) {
   return typeof value === "object" && value !== null && typeof value.installId === "string" && value.installId.length > 0;
 }
-function getInstallId() {
-  if (cachedInstallId !== void 0) return cachedInstallId;
-  const filePath = installIdFilePath();
+function getInstallId2() {
+  if (cachedInstallId2 !== void 0) return cachedInstallId2;
+  const filePath = installIdFilePath2();
   if (!existsSync(filePath)) {
-    cachedInstallId = generateAndPersist(filePath);
-    return cachedInstallId;
+    cachedInstallId2 = generateAndPersist2(filePath);
+    return cachedInstallId2;
   }
   try {
     const raw = readFileSync(filePath, "utf8");
     const parsed = JSON.parse(raw);
-    if (isValid(parsed)) {
-      cachedInstallId = parsed.installId;
-      return cachedInstallId;
+    if (isValid3(parsed)) {
+      cachedInstallId2 = parsed.installId;
+      return cachedInstallId2;
     }
-    cachedInstallId = generateAndPersist(filePath);
-    return cachedInstallId;
+    cachedInstallId2 = generateAndPersist2(filePath);
+    return cachedInstallId2;
   } catch {
-    cachedInstallId = generateAndPersist(filePath);
-    return cachedInstallId;
+    cachedInstallId2 = generateAndPersist2(filePath);
+    return cachedInstallId2;
   }
 }
 
@@ -3481,17 +3811,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(path15) {
+    const isAllowed = ALLOWED_UPSTREAM_PREFIXES.some((prefix) => path15.startsWith(prefix));
     if (!isAllowed) {
       const logger6 = getLogger();
       logger6.error("Path not in allowlist", {
-        path: path11,
+        path: path15,
         allowedPrefixes: ALLOWED_UPSTREAM_PREFIXES
       });
       throw new GatewayError({
         code: "FORBIDDEN" /* FORBIDDEN */,
-        message: `Path '${path11}' is not allowed`
+        message: `Path '${path15}' is not allowed`
       });
     }
   }
@@ -3503,7 +3833,7 @@ var PromptServiceClient = class {
    */
   buildHeaders(credentials, correlationId) {
     const manifest = readReleaseManifest();
-    const installId = getInstallId();
+    const installId = getInstallId2();
     const host = detectMcpHost();
     const headers = {
       "X-Correlation-Id": correlationId,
@@ -3889,6 +4219,29 @@ var useCaseTools = [
       };
     }
   },
+  {
+    name: "muggle-remote-use-case-update",
+    description: "Directly update an existing use case's fields without invoking the LLM. Pass only the fields you want to change \u2014 others are left untouched. Use this for cheap, deterministic edits (rename, flip status DRAFT\u2192APPROVED, change priority, edit acceptance criteria). For LLM regeneration from a new instruction, use muggle-remote-use-case-update-from-prompt instead. Note: changing title, description, or url triggers background regeneration of dependent test cases on the server.",
+    inputSchema: UseCaseUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      const body = { id: data.useCaseId };
+      if (data.title !== void 0) body.title = data.title;
+      if (data.description !== void 0) body.description = data.description;
+      if (data.userStory !== void 0) body.userStory = data.userStory;
+      if (data.url !== void 0) body.url = data.url;
+      if (data.useCaseBreakdown !== void 0) body.useCaseBreakdown = data.useCaseBreakdown;
+      if (data.status !== void 0) body.status = data.status;
+      if (data.priority !== void 0) body.priority = data.priority;
+      if (data.source !== void 0) body.source = data.source;
+      if (data.category !== void 0) body.category = data.category;
+      return {
+        method: "PUT",
+        path: `${MUGGLE_TEST_PREFIX}/use-cases/${data.useCaseId}`,
+        body
+      };
+    }
+  },
   {
     name: "muggle-remote-use-case-create",
     description: "Create a single use case from a fully-specified payload. Use this to persist use cases returned by muggle-remote-use-case-bulk-preview-submit \u2014 no LLM is invoked.",
@@ -4011,6 +4364,31 @@ var testCaseTools = [
       };
     }
   },
+  {
+    name: "muggle-remote-test-case-update",
+    description: "Directly update an existing test case's fields. Pass only the fields you want to change \u2014 others are left untouched. Use this for cheap, deterministic edits (rename, change status/priority, fix expected result, add tags). Does not touch the associated test script \u2014 script regeneration is a separate workflow (muggle-remote-workflow-start-test-script-generation).",
+    inputSchema: TestCaseUpdateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      const body = { id: data.testCaseId };
+      if (data.title !== void 0) body.title = data.title;
+      if (data.description !== void 0) body.description = data.description;
+      if (data.goal !== void 0) body.goal = data.goal;
+      if (data.precondition !== void 0) body.precondition = data.precondition;
+      if (data.expectedResult !== void 0) body.expectedResult = data.expectedResult;
+      if (data.url !== void 0) body.url = data.url;
+      if (data.status !== void 0) body.status = data.status;
+      if (data.priority !== void 0) body.priority = data.priority;
+      if (data.tags !== void 0) body.tags = data.tags;
+      if (data.category !== void 0) body.category = data.category;
+      if (data.automated !== void 0) body.automated = data.automated;
+      return {
+        method: "PUT",
+        path: `${MUGGLE_TEST_PREFIX}/test-cases/${data.testCaseId}`,
+        body
+      };
+    }
+  },
   {
     name: "muggle-remote-test-case-bulk-preview-submit",
     description: "Submit an async bulk-preview job that uses the OpenAI Batch API to generate test cases for a single use case from many prompts at ~50% of normal LLM cost. Returns a job ID immediately; poll with muggle-remote-bulk-preview-job-get until the job reaches a terminal status, then persist each successful result via muggle-remote-test-case-create. Note: one input prompt may fan out to 1\u20135 test cases.",
@@ -4979,6 +5357,58 @@ var apiKeyTools = [
     }
   }
 ];
+var userFeedbackTools = [
+  {
+    name: "muggle-remote-user-feedback-create",
+    description: "Submit user feedback on a generated action script \u2014 either the whole script (targetType='actionScript', targetId=actionScriptId) or a specific step (targetType='step', targetId=`${actionScriptId}:${stepIndex}` with 0-based stepIndex). Persists the feedback and triggers an async feedback-analysis workflow that may regenerate the script. The response includes the saved feedback and, when the analysis workflow was started, a feedbackAnalysisWorkflowRuntimeId for polling.",
+    inputSchema: UserFeedbackCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/user-feedback`,
+        body: {
+          projectId: data.projectId,
+          target: data.target,
+          feedbackText: data.feedbackText
+        }
+      };
+    }
+  },
+  {
+    name: "muggle-remote-user-feedback-list",
+    description: "List active user feedback entries for a project. Optionally narrow by exactly one of actionScriptId / testScriptId / testCaseId / useCaseId \u2014 the typical query is 'show me feedback on this test case (or test script, or use case).' Supports limit/offset pagination. Response: { feedback: IUserFeedback[], total: number, hasMore: boolean }.",
+    inputSchema: UserFeedbackListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/user-feedback`,
+        queryParams: {
+          projectId: data.projectId,
+          actionScriptId: data.actionScriptId,
+          testScriptId: data.testScriptId,
+          testCaseId: data.testCaseId,
+          useCaseId: data.useCaseId,
+          limit: data.limit,
+          offset: data.offset
+        }
+      };
+    }
+  },
+  {
+    name: "muggle-remote-user-feedback-delete",
+    description: "Soft-delete a user feedback entry by ID. Returns 204 on success.",
+    inputSchema: UserFeedbackDeleteInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${MUGGLE_TEST_PREFIX}/user-feedback/${data.feedbackId}`
+      };
+    }
+  }
+];
 var authTools = [
   {
     name: "muggle-remote-auth-status",
@@ -5115,6 +5545,7 @@ var allQaToolDefinitions = [
   ...walletTools,
   ...recommendationTools,
   ...apiKeyTools,
+  ...userFeedbackTools,
   ...authTools
 ];
 function getQaToolByName(name) {
@@ -5132,6 +5563,13 @@ async function executeQaTool(toolName, input, correlationId) {
       isError: true
     };
   }
+  const startTime = Date.now();
+  safeTrack({
+    name: EventName.McpToolInvoked,
+    props: { toolName, toolSurface: ToolSurface.Remote, correlationId }
+  });
+  let outcome = Outcome.Success;
+  let errorCode;
   try {
     const validatedInput = tool.inputSchema.parse(input);
     if (tool.localHandler) {
@@ -5164,7 +5602,9 @@ async function executeQaTool(toolName, input, correlationId) {
       throw error;
     }
   } catch (error) {
+    outcome = Outcome.Error;
     if (error instanceof GatewayError) {
+      errorCode = error.code;
       logger6.warn("Tool call failed with gateway error", {
         tool: toolName,
         code: error.code,
@@ -5175,12 +5615,31 @@ async function executeQaTool(toolName, input, correlationId) {
         isError: true
       };
     }
+    errorCode = error instanceof Error ? error.name : "UnknownError";
     const errorMessage = error instanceof Error ? error.message : String(error);
     logger6.error("Tool call failed", { tool: toolName, error: errorMessage });
     return {
       content: JSON.stringify({ error: "INTERNAL_ERROR", message: errorMessage }),
       isError: true
     };
+  } finally {
+    safeTrack({
+      name: EventName.McpToolCompleted,
+      props: {
+        toolName,
+        toolSurface: ToolSurface.Remote,
+        correlationId,
+        durationMs: Date.now() - startTime,
+        outcome,
+        ...errorCode !== void 0 ? { errorCode } : {}
+      }
+    });
+  }
+}
+function safeTrack(event) {
+  try {
+    track(event);
+  } catch {
   }
 }
 
@@ -5239,7 +5698,9 @@ var ExecuteTestGenerationInputSchema = z.object({
   /** Show the electron-app UI during execution. Default: visible window. Pass false to run headless. */
   showUi: z.boolean().optional().describe("Show the electron-app UI during generation. Defaults to visible; pass false to run headless."),
   /** Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state, such as registration, login, or cookie consent flows. */
-  freshSession: z.boolean().optional().describe("Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state \u2014 e.g. registration, login, or cookie consent flows. Default: false.")
+  freshSession: z.boolean().optional().describe("Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state \u2014 e.g. registration, login, or cookie consent flows. Default: false."),
+  /** Mutation parameters providing variable context for this generation run — a string[] where each element is a plain-English instruction or a local file path for uploads (e.g. "Attach the image at C:\\Users\\user\\photo.jpg"). Matches the electron-app's string[] mutation file format. */
+  mutations: z.array(z.string()).optional().describe(`Mutation parameters: string[] where each element is a plain-English instruction or a local file path (e.g. ["The post content should be 'Hello'", "Attach the image at C:\\\\Users\\\\user\\\\photo.jpg"]).`)
 });
 var ExecuteReplayInputSchema = z.object({
   /** Test script metadata from muggle-remote-test-script-get. */
@@ -5253,7 +5714,9 @@ var ExecuteReplayInputSchema = z.object({
   /** Show the electron-app UI during execution. Default: visible window. Pass false to run headless. */
   showUi: z.boolean().optional().describe("Show the electron-app UI during replay. Defaults to visible; pass false to run headless."),
   /** Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state, such as registration, login, or cookie consent flows. */
-  freshSession: z.boolean().optional().describe("Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state \u2014 e.g. registration, login, or cookie consent flows. Default: false.")
+  freshSession: z.boolean().optional().describe("Clear all session storage (cookies, localStorage, etc.) before execution. Use for test cases that require a clean browser state \u2014 e.g. registration, login, or cookie consent flows. Default: false."),
+  /** Mutation parameters passed to the LLM step predictor — a string[] where each element is an instruction describing what varies this run. Supports plain-English instructions (e.g. "The post content should be 'Hello world'") and local file paths for uploads (e.g. "Attach the image at C:\\Users\\user\\photo.jpg"). Matches the electron-app's string[] mutation file format. When provided, the electron app uses LLM-driven step prediction instead of deterministic replay. */
+  mutations: z.array(z.string()).optional().describe(`Mutation parameters: string[] where each element is a plain-English instruction or a local file path (e.g. ["The post content should be 'Hello'", "Attach the image at C:\\\\Users\\\\user\\\\photo.jpg"]).`)
 });
 var CancelExecutionInputSchema = z.object({
   runId: MuggleEntityIdSchema.describe("Run ID (UUID) to cancel")
@@ -5287,6 +5750,7 @@ var EmptyInputSchema2 = z.object({});
 var PreferenceKey = /* @__PURE__ */ ((PreferenceKey2) => {
   PreferenceKey2["AutoLogin"] = "autoLogin";
   PreferenceKey2["AutoSelectProject"] = "autoSelectProject";
+  PreferenceKey2["AutoSelectLocalHost"] = "autoSelectLocalHost";
   PreferenceKey2["ShowElectronBrowser"] = "showElectronBrowser";
   PreferenceKey2["OpenTestResultsAfterRun"] = "openTestResultsAfterRun";
   PreferenceKey2["DefaultExecutionMode"] = "defaultExecutionMode";
@@ -5295,27 +5759,24 @@ var PreferenceKey = /* @__PURE__ */ ((PreferenceKey2) => {
   PreferenceKey2["SuggestRelatedTestCases"] = "suggestRelatedTestCases";
   PreferenceKey2["AutoDetectChanges"] = "autoDetectChanges";
   PreferenceKey2["PostPRVisualWalkthrough"] = "postPRVisualWalkthrough";
+  PreferenceKey2["AutoCreatePR"] = "autoCreatePR";
   PreferenceKey2["CheckForUpdates"] = "checkForUpdates";
   PreferenceKey2["VerboseOutput"] = "verboseOutput";
+  PreferenceKey2["AutoUseWorktree"] = "autoUseWorktree";
+  PreferenceKey2["AutoRebase"] = "autoRebase";
+  PreferenceKey2["AutoCleanup"] = "autoCleanup";
+  PreferenceKey2["AutoE2ETest"] = "autoE2ETest";
   return PreferenceKey2;
 })(PreferenceKey || {});
 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";
@@ -5323,6 +5784,7 @@ var PREFERENCES_VERSION = 1;
 var DEFAULT_PREFERENCES = {
   ["autoLogin" /* AutoLogin */]: "ask" /* Ask */,
   ["autoSelectProject" /* AutoSelectProject */]: "ask" /* Ask */,
+  ["autoSelectLocalHost" /* AutoSelectLocalHost */]: "ask" /* Ask */,
   ["showElectronBrowser" /* ShowElectronBrowser */]: "ask" /* Ask */,
   ["openTestResultsAfterRun" /* OpenTestResultsAfterRun */]: "ask" /* Ask */,
   ["defaultExecutionMode" /* DefaultExecutionMode */]: "ask" /* Ask */,
@@ -5331,27 +5793,69 @@ var DEFAULT_PREFERENCES = {
   ["suggestRelatedTestCases" /* SuggestRelatedTestCases */]: "ask" /* Ask */,
   ["autoDetectChanges" /* AutoDetectChanges */]: "ask" /* Ask */,
   ["postPRVisualWalkthrough" /* PostPRVisualWalkthrough */]: "ask" /* Ask */,
+  ["autoCreatePR" /* AutoCreatePR */]: "ask" /* Ask */,
   ["checkForUpdates" /* CheckForUpdates */]: "ask" /* Ask */,
-  ["verboseOutput" /* VerboseOutput */]: "ask" /* Ask */
+  ["verboseOutput" /* VerboseOutput */]: "ask" /* Ask */,
+  ["autoUseWorktree" /* AutoUseWorktree */]: "ask" /* Ask */,
+  ["autoRebase" /* AutoRebase */]: "ask" /* Ask */,
+  ["autoCleanup" /* AutoCleanup */]: "ask" /* Ask */,
+  ["autoE2ETest" /* AutoE2ETest */]: "always" /* Always */
+};
+var ALWAYS_ASK_NEVER = [
+  "always" /* Always */,
+  "ask" /* Ask */,
+  "never" /* Never */
+];
+var ALWAYS_ASK = [
+  "always" /* Always */,
+  "ask" /* Ask */
+];
+var LOCAL_REMOTE_ASK = [
+  "local" /* Local */,
+  "remote" /* Remote */,
+  "ask" /* Ask */
+];
+var PREFERENCE_ALLOWED_VALUES = {
+  ["autoLogin" /* AutoLogin */]: ALWAYS_ASK_NEVER,
+  ["autoSelectProject" /* AutoSelectProject */]: ALWAYS_ASK_NEVER,
+  ["autoSelectLocalHost" /* AutoSelectLocalHost */]: 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,
+  ["autoCreatePR" /* AutoCreatePR */]: ALWAYS_ASK_NEVER,
+  ["checkForUpdates" /* CheckForUpdates */]: ALWAYS_ASK_NEVER,
+  ["verboseOutput" /* VerboseOutput */]: ALWAYS_ASK_NEVER,
+  ["autoUseWorktree" /* AutoUseWorktree */]: ALWAYS_ASK_NEVER,
+  ["autoRebase" /* AutoRebase */]: ALWAYS_ASK_NEVER,
+  ["autoCleanup" /* AutoCleanup */]: ALWAYS_ASK_NEVER,
+  ["autoE2ETest" /* AutoE2ETest */]: ALWAYS_ASK
 };
 var PREFERENCES_SCHEMA = {
   ["autoLogin" /* AutoLogin */]: {
     description: "When a tool requires auth and saved credentials exist, reuse them without prompting"
   },
   ["autoSelectProject" /* AutoSelectProject */]: {
-    description: "When a skill needs a Muggle project and one was used previously in this repo, reuse it without prompting"
+    description: "When a skill needs a Muggle Test project and one was used previously in this repo, reuse it without prompting"
+  },
+  ["autoSelectLocalHost" /* AutoSelectLocalHost */]: {
+    description: "When running local tests, reuse the dev server URL from the previous run in this repo without prompting"
   },
   ["showElectronBrowser" /* ShowElectronBrowser */]: {
     description: "When running local E2E tests, show the Electron browser window"
   },
   ["openTestResultsAfterRun" /* OpenTestResultsAfterRun */]: {
-    description: "After a local E2E test run completes, open the per-run results page on Muggle dashboard"
+    description: "After a local E2E test run completes, open the per-run results page on Muggle Test dashboard"
   },
   ["defaultExecutionMode" /* DefaultExecutionMode */]: {
     description: "When a skill supports both local and remote test execution, which to default to"
   },
   ["autoPublishLocalResults" /* AutoPublishLocalResults */]: {
-    description: "After a local E2E test run completes, upload results to Muggle cloud for team visibility"
+    description: "After a local E2E test run completes, upload results to Muggle Test cloud for team visibility"
   },
   ["suggestRelatedUseCases" /* SuggestRelatedUseCases */]: {
     description: "After creating or running a use case, suggest related use cases to add"
@@ -5365,17 +5869,121 @@ var PREFERENCES_SCHEMA = {
   ["postPRVisualWalkthrough" /* PostPRVisualWalkthrough */]: {
     description: "After test results are available, post visual walkthrough comment with screenshots to the PR"
   },
+  ["autoCreatePR" /* AutoCreatePR */]: {
+    description: "At the end of the muggle-do dev cycle (or when a test needs an open PR to post results to), push the branch and open a PR without prompting"
+  },
   ["checkForUpdates" /* CheckForUpdates */]: {
-    description: "At session start, check if a newer Muggle version is available and notify"
+    description: "At session start, check if a newer Muggle Test version is available and notify"
   },
   ["verboseOutput" /* VerboseOutput */]: {
     description: "Show detailed progress logs during skill and tool execution"
+  },
+  ["autoUseWorktree" /* AutoUseWorktree */]: {
+    description: "When starting non-trivial development work, create a git worktree to isolate the change from the current checkout"
+  },
+  ["autoRebase" /* AutoRebase */]: {
+    description: "Before running dev servers or E2E tests on a branch behind origin, rebase onto the default branch first"
+  },
+  ["autoCleanup" /* AutoCleanup */]: {
+    description: "After a PR is merged, automatically run the cleanup sequence: remove worktree, delete branches, clear local artifacts, prune [gone] branches"
+  },
+  ["autoE2ETest" /* AutoE2ETest */]: {
+    description: "Run Stage 6 (E2E acceptance) at the end of every /muggle-do cycle (default always \u2014 running E2E is the point of muggle-do; never is not an option)"
   }
 };
 
-// packages/mcps/src/shared/preferences.ts
-function isFirstRun(dataDirOverride) {
-  const filePath = path2.join(dataDirOverride ?? getDataDir(), PREFERENCES_FILE_NAME);
+// 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 Test project ID."),
+  projectUrl: z.string().min(1).describe("Muggle Test project URL."),
+  projectName: z.string().min(1).describe("Muggle Test project name.")
+});
+var LastProjectClearInputSchema = z.object({
+  cwd: z.string().describe("Project root directory whose last-used project cache to remove.")
+});
+var LastHostGetInputSchema = z.object({
+  cwd: z.string().describe("Project root directory whose last-used host to return.")
+});
+var LastHostSetInputSchema = z.object({
+  cwd: z.string().describe("Project root directory to save the cached host to."),
+  host: z.string().min(1).describe("Local dev server URL (e.g. http://localhost:3000).")
+});
+var LastHostClearInputSchema = z.object({
+  cwd: z.string().describe("Project root directory whose last-used host cache to remove.")
+});
+var SkillTelemetryEmitInputSchema = z.object({
+  skillName: z.string().min(1).describe("Name of the skill being invoked, e.g. 'muggle-test'."),
+  trigger: z.nativeEnum(Trigger).default(Trigger.UserSlash).describe("Why this skill ran. Defaults to 'user-slash' (user typed /skill-name).")
+});
+var FailureEventType = /* @__PURE__ */ ((FailureEventType2) => {
+  FailureEventType2["PreExecutionClassification"] = "pre-execution-classification";
+  FailureEventType2["ReplayFailureClassified"] = "replay-failure-classified";
+  FailureEventType2["ReplayFailureResolved"] = "replay-failure-resolved";
+  FailureEventType2["RegenFailureClassified"] = "regen-failure-classified";
+  FailureEventType2["RegenFailureResolved"] = "regen-failure-resolved";
+  return FailureEventType2;
+})(FailureEventType || {});
+var EventTelemetryEmitInputSchema = z.object({
+  eventType: z.nativeEnum(FailureEventType).describe(
+    "Which decision point this event records. Five values cover the AI's pre-execution replay-vs-regen choice and the four post-failure classify\u2192resolve pairs."
+  ),
+  skillName: z.string().min(1).describe("Skill that emitted this event (e.g. 'muggle-test', 'muggle-test-feature-local')."),
+  aiClassification: z.string().optional().describe(
+    "What the AI classified the situation as. pre-execution: 'replay' or 'regen'. replay-failure: 'infra' | 'stale-script' | 'product-defect'. regen-failure: 'transient' | 'infra' | 'agent-course' | 'product-uxux'."
+  ),
+  aiSuggestion: z.string().optional().describe(
+    "What the AI suggested the user do. Examples: 'regenerate', 'report-bug', 'muggle-feedback', 'retry', 'wait-and-share'."
+  ),
+  userAction: z.string().optional().describe(
+    "What the user actually picked (only set on *-resolved events). Compare against aiSuggestion to measure classification accuracy."
+  ),
+  runId: z.string().optional().describe("Anchor: local run ID for the affected execution."),
+  testCaseId: z.string().optional().describe("Anchor: cloud test case ID."),
+  projectId: z.string().optional().describe("Anchor: cloud project ID."),
+  signals: z.array(z.string()).optional().describe(
+    "Signals that drove the classification, e.g. ['element-not-found', 'selector-timeout', 'electron-exit-26', 'goal-not-achievable']. Used to refine the rules later."
+  ),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Free-form additional context (e.g. error excerpt, last step name).")
+});
+var TELEMETRY_DIR_NAME = "telemetry";
+var FAILURE_EVENTS_FILE_NAME = "failure-events.jsonl";
+function appendFailureEvent(record) {
+  try {
+    const dir = path2.join(getDataDir(), TELEMETRY_DIR_NAME);
+    fs5.mkdirSync(dir, { recursive: true });
+    const filePath = path2.join(dir, FAILURE_EVENTS_FILE_NAME);
+    const full = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...record };
+    fs5.appendFileSync(filePath, `${JSON.stringify(full)}
+`, "utf-8");
+  } catch (error) {
+    getLogger().warn("Failed to append failure event", {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function isFirstRun(dataDirOverride2) {
+  const filePath = path2.join(dataDirOverride2 ?? getDataDir(), PREFERENCES_FILE_NAME);
   return !fs5.existsSync(filePath);
 }
 function readPreferencesFile(filePath) {
@@ -5393,8 +6001,8 @@ function readPreferencesFile(filePath) {
     return {};
   }
 }
-function readGlobalPreferences(dataDirOverride) {
-  const filePath = path2.join(dataDirOverride ?? getDataDir(), PREFERENCES_FILE_NAME);
+function readGlobalPreferences(dataDirOverride2) {
+  const filePath = path2.join(dataDirOverride2 ?? getDataDir(), PREFERENCES_FILE_NAME);
   const partial = readPreferencesFile(filePath);
   return { ...DEFAULT_PREFERENCES, ...partial };
 }
@@ -5402,16 +6010,16 @@ function readProjectPreferences(cwd) {
   const filePath = path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_FILE_NAME);
   return readPreferencesFile(filePath);
 }
-function resolvePreferences(dataDirOverride, cwd) {
-  const global = readGlobalPreferences(dataDirOverride);
+function resolvePreferences(dataDirOverride2, cwd) {
+  const global = readGlobalPreferences(dataDirOverride2);
   if (!cwd) {
     return global;
   }
   const project = readProjectPreferences(cwd);
   return { ...global, ...project };
 }
-function writePreferences(prefs, scope, dataDirOverride, cwd) {
-  const dir = scope === "project" && cwd ? path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride ?? getDataDir();
+function writePreferences(prefs, scope, dataDirOverride2, cwd) {
+  const dir = scope === "project" && cwd ? path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride2 ?? getDataDir();
   fs5.mkdirSync(dir, { recursive: true });
   const filePath = path2.join(dir, PREFERENCES_FILE_NAME);
   const existing = readPreferencesFile(filePath);
@@ -5423,8 +6031,8 @@ function writePreferences(prefs, scope, dataDirOverride, cwd) {
   fs5.writeFileSync(filePath, `${JSON.stringify(file, null, 2)}
 `, "utf-8");
 }
-function resetPreference(key, scope, dataDirOverride, cwd) {
-  const dir = scope === "project" && cwd ? path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride ?? getDataDir();
+function resetPreference(key, scope, dataDirOverride2, cwd) {
+  const dir = scope === "project" && cwd ? path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride2 ?? getDataDir();
   const filePath = path2.join(dir, PREFERENCES_FILE_NAME);
   if (!fs5.existsSync(filePath)) {
     return;
@@ -5443,12 +6051,87 @@ 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);
+  }
+}
+var LAST_HOST_FILE_NAME = "last-host.json";
+var LAST_HOST_DIR_NAME = ".muggle-ai";
+var LAST_HOST_VERSION = 1;
+function readLastHost(cwd) {
+  const filePath = path2.join(cwd, LAST_HOST_DIR_NAME, LAST_HOST_FILE_NAME);
+  try {
+    if (!fs5.existsSync(filePath)) {
+      return null;
+    }
+    const raw = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+    return raw.lastHost ?? null;
+  } catch (error) {
+    getLogger().warn("Failed to read last-host file", {
+      path: filePath,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+function writeLastHost(cwd, host) {
+  const dir = path2.join(cwd, LAST_HOST_DIR_NAME);
+  fs5.mkdirSync(dir, { recursive: true });
+  const filePath = path2.join(dir, LAST_HOST_FILE_NAME);
+  const file = {
+    version: LAST_HOST_VERSION,
+    lastHost: { host, savedAt: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+  fs5.writeFileSync(filePath, `${JSON.stringify(file, null, 2)}
+`, "utf-8");
+}
+function clearLastHost(cwd) {
+  const filePath = path2.join(cwd, LAST_HOST_DIR_NAME, LAST_HOST_FILE_NAME);
+  if (fs5.existsSync(filePath)) {
+    fs5.unlinkSync(filePath);
+  }
+}
 
 // packages/mcps/src/mcp/tools/local/tool-registry.ts
 function createChildLogger2(correlationId) {
@@ -5672,6 +6355,7 @@ var executeTestGenerationTool = {
       const result = await executeTestGeneration({
         testCase: input.testCase,
         localUrl: input.localUrl,
+        mutations: input.mutations,
         timeoutMs: input.timeoutMs,
         showUi,
         freshSession: input.freshSession
@@ -5712,6 +6396,7 @@ var executeReplayTool = {
         testScript: input.testScript,
         actionScript: input.actionScript,
         localUrl: input.localUrl,
+        mutations: input.mutations,
         timeoutMs: input.timeoutMs,
         showUi,
         freshSession: input.freshSession
@@ -5905,19 +6590,172 @@ var preferencesSetTool = {
       void 0,
       input.cwd
     );
-    const resolved = resolvePreferences(void 0, input.cwd);
-    const oneLiner = formatPreferencesOneLiner(resolved);
+    return {
+      content: `**${input.key}** set to **${input.value}** (${input.scope}).`,
+      isError: false
+    };
+  }
+};
+var lastProjectGetTool = {
+  name: "muggle-local-last-project-get",
+  description: "Get the cached last-used Muggle Test 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 = [
-      `**${input.key}** set to **${input.value}** (${input.scope}).`,
+      "**Cached last-used project:**",
       "",
-      `Preferences file: ~/.muggle-ai/${PREFERENCES_FILE_NAME}`,
+      `- 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 Test 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.`,
       "",
-      "Current resolved preferences:",
-      `\`${oneLiner}\``
+      `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 lastHostGetTool = {
+  name: "muggle-local-last-host-get",
+  description: "Get the cached last-used local dev server URL for a repo (read from <cwd>/.muggle-ai/last-host.json). Returns the URL and saved-at timestamp, or null if no cache exists. Skills consult this when 'autoSelectLocalHost = always' to silently reuse the URL the user used previously.",
+  inputSchema: LastHostGetInputSchema,
+  execute: async (ctx) => {
+    const logger6 = createChildLogger2(ctx.correlationId);
+    logger6.info("Executing muggle-local-last-host-get");
+    const input = LastHostGetInputSchema.parse(ctx.input);
+    const cached = readLastHost(input.cwd);
+    if (!cached) {
+      const content2 = [
+        "No cached last-used host for this repo.",
+        "",
+        `Looked at: \`${input.cwd}/.muggle-ai/${LAST_HOST_FILE_NAME}\``
+      ].join("\n");
+      return { content: content2, isError: false };
+    }
+    const content = [
+      "**Cached last-used host:**",
+      "",
+      `- URL: ${cached.host}`,
+      `- Saved at: ${cached.savedAt}`
+    ].join("\n");
+    return { content, isError: false };
+  }
+};
+var lastHostSetTool = {
+  name: "muggle-local-last-host-set",
+  description: "Save the user's chosen local dev server URL as the cached last-used host for this repo. Writes to <cwd>/.muggle-ai/last-host.json. Call this on every host pick (independent of 'Remember this URL?' Picker 2) so future runs can offer 'Use {lastHost}' regardless of whether the user opted to set autoSelectLocalHost=always.",
+  inputSchema: LastHostSetInputSchema,
+  execute: async (ctx) => {
+    const logger6 = createChildLogger2(ctx.correlationId);
+    logger6.info("Executing muggle-local-last-host-set");
+    const input = LastHostSetInputSchema.parse(ctx.input);
+    writeLastHost(input.cwd, input.host);
+    return {
+      content: `Cached **${input.host}** as the last-used host for this repo.`,
+      isError: false
+    };
+  }
+};
+var lastHostClearTool = {
+  name: "muggle-local-last-host-clear",
+  description: "Remove the cached last-used host for this repo. After this, `autoSelectLocalHost = always` will fall through to ask until the user picks a new URL. No-op if no cache exists.",
+  inputSchema: LastHostClearInputSchema,
+  execute: async (ctx) => {
+    const logger6 = createChildLogger2(ctx.correlationId);
+    logger6.info("Executing muggle-local-last-host-clear");
+    const input = LastHostClearInputSchema.parse(ctx.input);
+    clearLastHost(input.cwd);
+    return {
+      content: `Cleared the cached last-used host for this repo.`,
+      isError: false
+    };
+  }
+};
+var telemetrySkillEmitTool = {
+  name: "muggle-local-telemetry-skill-emit",
+  description: "Emit a client telemetry event recording that a Muggle Test skill was invoked. Each muggle-* skill calls this in its first step so we can measure skill usage. Never fails the skill on telemetry errors.",
+  inputSchema: SkillTelemetryEmitInputSchema,
+  execute: async (ctx) => {
+    const input = SkillTelemetryEmitInputSchema.parse(ctx.input);
+    safeTrack2({
+      name: EventName.SkillInvoked,
+      props: { skillName: input.skillName, trigger: input.trigger }
+    });
+    return { content: "ok", isError: false, data: { recorded: true } };
+  }
+};
+var telemetryEventEmitTool = {
+  name: "muggle-local-telemetry-event-emit",
+  description: "Emit a structured failure-mode telemetry event recording how a Muggle Test skill classified a situation and what action the user took. Used at five decision points: 'pre-execution-classification' (replay vs regen), 'replay-failure-classified', 'replay-failure-resolved', 'regen-failure-classified', 'regen-failure-resolved'. Records to ~/.muggle-ai/telemetry/failure-events.jsonl. Never fails the skill on telemetry errors.",
+  inputSchema: EventTelemetryEmitInputSchema,
+  execute: async (ctx) => {
+    const input = EventTelemetryEmitInputSchema.parse(ctx.input);
+    appendFailureEvent({
+      eventType: input.eventType,
+      skillName: input.skillName,
+      aiClassification: input.aiClassification,
+      aiSuggestion: input.aiSuggestion,
+      userAction: input.userAction,
+      runId: input.runId,
+      testCaseId: input.testCaseId,
+      projectId: input.projectId,
+      signals: input.signals,
+      metadata: input.metadata
+    });
+    return { content: "ok", isError: false, data: { recorded: true } };
+  }
+};
 var allLocalQaTools = [
   // Status tools
   checkStatusTool,
@@ -5935,7 +6773,18 @@ var allLocalQaTools = [
   // Publishing tools
   publishTestScriptTool,
   // Preferences tools
-  preferencesSetTool
+  preferencesSetTool,
+  // Last-project cache tools (per-repo "last used Muggle Test project")
+  lastProjectGetTool,
+  lastProjectSetTool,
+  lastProjectClearTool,
+  // Last-host cache tools (per-repo "last used local dev server URL")
+  lastHostGetTool,
+  lastHostSetTool,
+  lastHostClearTool,
+  // Client telemetry: skills emit invocation events through this tool
+  telemetrySkillEmitTool,
+  telemetryEventEmitTool
 ];
 var toolMap = new Map(
   allLocalQaTools.map((tool) => [tool.name, tool])
@@ -5951,7 +6800,44 @@ async function executeTool(name, input, correlationId) {
       isError: true
     };
   }
-  return tool.execute({ input, correlationId });
+  const startTime = Date.now();
+  safeTrack2({
+    name: EventName.McpToolInvoked,
+    props: { toolName: name, toolSurface: ToolSurface.Local, correlationId }
+  });
+  try {
+    const result = await tool.execute({ input, correlationId });
+    safeTrack2({
+      name: EventName.McpToolCompleted,
+      props: {
+        toolName: name,
+        toolSurface: ToolSurface.Local,
+        correlationId,
+        durationMs: Date.now() - startTime,
+        outcome: result.isError ? Outcome.Error : Outcome.Success
+      }
+    });
+    return result;
+  } catch (err) {
+    safeTrack2({
+      name: EventName.McpToolCompleted,
+      props: {
+        toolName: name,
+        toolSurface: ToolSurface.Local,
+        correlationId,
+        durationMs: Date.now() - startTime,
+        outcome: Outcome.Error,
+        errorCode: err instanceof Error ? err.name : "UnknownError"
+      }
+    });
+    throw err;
+  }
+}
+function safeTrack2(event) {
+  try {
+    track(event);
+  } catch {
+  }
 }
 
 // packages/mcps/src/mcp/e2e/index.ts
@@ -6013,6 +6899,7 @@ __export(e2e_exports2, {
   TestCaseGetInputSchema: () => TestCaseGetInputSchema,
   TestCaseListByUseCaseInputSchema: () => TestCaseListByUseCaseInputSchema,
   TestCaseListInputSchema: () => TestCaseListInputSchema,
+  TestCaseUpdateInputSchema: () => TestCaseUpdateInputSchema,
   TestScriptGetInputSchema: () => TestScriptGetInputSchema,
   TestScriptListInputSchema: () => TestScriptListInputSchema,
   TokenPackageIdSchema: () => TokenPackageIdSchema,
@@ -6025,6 +6912,12 @@ __export(e2e_exports2, {
   UseCaseListInputSchema: () => UseCaseListInputSchema,
   UseCasePromptPreviewInputSchema: () => UseCasePromptPreviewInputSchema,
   UseCaseUpdateFromPromptInputSchema: () => UseCaseUpdateFromPromptInputSchema,
+  UseCaseUpdateInputSchema: () => UseCaseUpdateInputSchema,
+  UserFeedbackCreateInputSchema: () => UserFeedbackCreateInputSchema,
+  UserFeedbackDeleteInputSchema: () => UserFeedbackDeleteInputSchema,
+  UserFeedbackListInputSchema: () => UserFeedbackListInputSchema,
+  UserFeedbackTargetSchema: () => UserFeedbackTargetSchema,
+  UserFeedbackTargetTypeSchema: () => UserFeedbackTargetTypeSchema,
   WalletAutoTopUpSetPaymentMethodInputSchema: () => WalletAutoTopUpSetPaymentMethodInputSchema,
   WalletAutoTopUpUpdateInputSchema: () => WalletAutoTopUpUpdateInputSchema,
   WalletPaymentMethodCreateSetupSessionInputSchema: () => WalletPaymentMethodCreateSetupSessionInputSchema,
@@ -6071,10 +6964,18 @@ __export(local_exports2, {
   CloudMappingEntityType: () => CloudMappingEntityType,
   DeviceCodePollStatus: () => DeviceCodePollStatus,
   EmptyInputSchema: () => EmptyInputSchema2,
+  EventTelemetryEmitInputSchema: () => EventTelemetryEmitInputSchema,
   ExecuteReplayInputSchema: () => ExecuteReplayInputSchema,
   ExecuteTestGenerationInputSchema: () => ExecuteTestGenerationInputSchema,
   ExecutionStatus: () => ExecutionStatus,
+  FailureEventType: () => FailureEventType,
   HealthStatus: () => HealthStatus,
+  LastHostClearInputSchema: () => LastHostClearInputSchema,
+  LastHostGetInputSchema: () => LastHostGetInputSchema,
+  LastHostSetInputSchema: () => LastHostSetInputSchema,
+  LastProjectClearInputSchema: () => LastProjectClearInputSchema,
+  LastProjectGetInputSchema: () => LastProjectGetInputSchema,
+  LastProjectSetInputSchema: () => LastProjectSetInputSchema,
   ListSessionsInputSchema: () => ListSessionsInputSchema,
   LocalRunStatus: () => LocalRunStatus,
   LocalRunType: () => LocalRunType,
@@ -6088,6 +6989,7 @@ __export(local_exports2, {
   RunResultListInputSchema: () => RunResultListInputSchema,
   RunResultStorageService: () => RunResultStorageService,
   SessionStatus: () => SessionStatus,
+  SkillTelemetryEmitInputSchema: () => SkillTelemetryEmitInputSchema,
   StorageService: () => StorageService,
   TestCaseDetailsSchema: () => TestCaseDetailsSchema,
   TestResultStatus: () => TestResultStatus,
@@ -6137,7 +7039,10 @@ function isLocalOnlyTool(toolName) {
     "muggle_run_result_list",
     "muggle_run_result_get",
     "muggle_test_script_list",
-    "muggle_test_script_get"
+    "muggle_test_script_get",
+    // Client telemetry — purely local, no backend call
+    "muggle-local-telemetry-skill-emit",
+    "muggle-local-telemetry-event-emit"
   ];
   return localOnlyTools.includes(toolName);
 }
@@ -6151,4 +7056,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, EventName, PREFERENCES_FILE_NAME, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_SCHEMA, PREFERENCES_VERSION, PREFERENCE_ALLOWED_VALUES, PreferenceKey, PreferenceValue, ServiceName, Surface, __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, initTelemetry, isElectronAppInstalled, isFirstRun, loadApiKeyData, loadCredentials, local_exports2 as local_exports, mcp_exports, openBrowserUrl, performLogin, performLogout, pollDeviceCode, readGlobalPreferences, readProjectPreferences, resetConfig, resetLogger, resetPreference, resolveElectronAppPathOrNull, resolvePreferences, saveApiKey, saveApiKeyData, saveCredentials, src_exports, startDeviceCodeFlow, toolRequiresAuth, track, validatePreference, verifyFileChecksum, writePreferences };