@muggleai/works 4.12.2 → 4.12.3

package/dist/{chunk-I4VLYJ7M.js → chunk-CPF6AR2I.js}

@@ -2,15 +2,15 @@ import * as crypto from 'crypto';
 import { randomUUID } from 'crypto';
 import * as fs5 from 'fs';
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
-import * as path2 from 'path';
+import * as path9 from 'path';
 import { join, dirname } from 'path';
-import * as os3 from 'os';
+import * as os4 from 'os';
 import { platform } from 'os';
 import winston from 'winston';
 import { fileURLToPath } from 'url';
-import { spawn, exec } from 'child_process';
+import { exec, spawn } from 'child_process';
 import axios, { AxiosError } from 'axios';
-import * as fs7 from 'fs/promises';
+import * as fs8 from 'fs/promises';
 import AppInsights from 'applicationinsights';
 import { z } from 'zod';
 
@@ -98,7 +98,7 @@ __export(src_exports, {
 });
 var DATA_DIR_NAME = ".muggle-ai";
 function getDataDir() {
-  return path2.join(os3.homedir(), DATA_DIR_NAME);
+  return path9.join(os4.homedir(), DATA_DIR_NAME);
 }
 var DEV_MANIFEST = {
   release: "dev",
@@ -162,24 +162,24 @@ var configInstance = null;
 var muggleConfigCache = null;
 function getPackageRoot() {
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentDir = path2.dirname(currentFilePath);
-  if (currentDir.includes(path2.join("dist", "shared"))) {
-    return path2.resolve(currentDir, "..", "..");
+  const currentDir = path9.dirname(currentFilePath);
+  if (currentDir.includes(path9.join("dist", "shared"))) {
+    return path9.resolve(currentDir, "..", "..");
   }
   if (currentDir.endsWith("dist")) {
-    return path2.resolve(currentDir, "..");
+    return path9.resolve(currentDir, "..");
   }
-  if (currentDir.includes(path2.join("src", "shared"))) {
-    return path2.resolve(currentDir, "..", "..");
+  if (currentDir.includes(path9.join("src", "shared"))) {
+    return path9.resolve(currentDir, "..", "..");
   }
-  return path2.dirname(currentDir);
+  return path9.dirname(currentDir);
 }
 function getMuggleConfig() {
   if (muggleConfigCache) {
     return muggleConfigCache;
   }
   const packageRoot = getPackageRoot();
-  const packageJsonPath = path2.join(packageRoot, "package.json");
+  const packageJsonPath = path9.join(packageRoot, "package.json");
   let packageJson;
   try {
     const content = fs5.readFileSync(packageJsonPath, "utf-8");
@@ -240,19 +240,19 @@ function getDataDir2() {
   return getDataDir();
 }
 function getDownloadedElectronAppPath() {
-  const platformName = os3.platform();
+  const platformName = os4.platform();
   const version = getElectronAppVersion();
-  const baseDir = path2.join(getDataDir2(), ELECTRON_APP_DIR, version);
+  const baseDir = path9.join(getDataDir2(), ELECTRON_APP_DIR, version);
   let binaryPath;
   switch (platformName) {
     case "darwin":
-      binaryPath = path2.join(baseDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      binaryPath = path9.join(baseDir, "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
       break;
     case "win32":
-      binaryPath = path2.join(baseDir, "MuggleAI.exe");
+      binaryPath = path9.join(baseDir, "MuggleAI.exe");
       break;
     case "linux":
-      binaryPath = path2.join(baseDir, "MuggleAI");
+      binaryPath = path9.join(baseDir, "MuggleAI");
       break;
     default:
       return null;
@@ -263,18 +263,18 @@ function getDownloadedElectronAppPath() {
   return null;
 }
 function getSystemElectronAppPath() {
-  const platformName = os3.platform();
-  const homeDir = os3.homedir();
+  const platformName = os4.platform();
+  const homeDir = os4.homedir();
   let binaryPath;
   switch (platformName) {
     case "darwin":
-      binaryPath = path2.join(homeDir, "Applications", "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
+      binaryPath = path9.join(homeDir, "Applications", "MuggleAI.app", "Contents", "MacOS", "MuggleAI");
       break;
     case "win32":
-      binaryPath = path2.join(homeDir, "AppData", "Local", "Programs", "MuggleAI", "MuggleAI.exe");
+      binaryPath = path9.join(homeDir, "AppData", "Local", "Programs", "MuggleAI", "MuggleAI.exe");
       break;
     case "linux":
-      binaryPath = path2.join(homeDir, ".local", "share", "muggle-ai", "MuggleAI");
+      binaryPath = path9.join(homeDir, ".local", "share", "muggle-ai", "MuggleAI");
       break;
     default:
       return null;
@@ -305,7 +305,7 @@ function resolveWebServicePath() {
     return customPath;
   }
   const packageRoot = getPackageRoot();
-  const siblingPath = path2.resolve(packageRoot, "..", "web-service", "dist", "src", "index.js");
+  const siblingPath = path9.resolve(packageRoot, "..", "web-service", "dist", "src", "index.js");
   if (fs5.existsSync(siblingPath)) {
     return siblingPath;
   }
@@ -392,13 +392,13 @@ function buildLocalQaConfig() {
     webServiceUrl: process.env.WEB_SERVICE_URL ?? DEFAULT_WEB_SERVICE_URL,
     promptServiceUrl: process.env.PROMPT_SERVICE_BASE_URL ?? defaultPromptServiceUrl,
     dataDir,
-    sessionsDir: path2.join(dataDir, "sessions"),
-    projectsDir: path2.join(dataDir, "projects"),
-    tempDir: path2.join(dataDir, "temp"),
-    apiKeyFilePath: path2.join(dataDir, API_KEY_FILE),
-    oauthSessionFilePath: path2.join(dataDir, "oauth-session.json"),
+    sessionsDir: path9.join(dataDir, "sessions"),
+    projectsDir: path9.join(dataDir, "projects"),
+    tempDir: path9.join(dataDir, "temp"),
+    apiKeyFilePath: path9.join(dataDir, API_KEY_FILE),
+    oauthSessionFilePath: path9.join(dataDir, "oauth-session.json"),
     webServicePath: resolveWebServicePath(),
-    webServicePidFile: path2.join(dataDir, "web-service.pid"),
+    webServicePidFile: path9.join(dataDir, "web-service.pid"),
     auth0: {
       domain: process.env.AUTH0_DOMAIN ?? defaultAuth0Domain,
       clientId: process.env.AUTH0_CLIENT_ID ?? defaultAuth0ClientId,
@@ -433,7 +433,7 @@ function getElectronAppVersion() {
   if (envVersion && /^\d+\.\d+\.\d+$/.test(envVersion)) {
     return envVersion;
   }
-  const overridePath = path2.join(getDataDir2(), VERSION_OVERRIDE_FILE);
+  const overridePath = path9.join(getDataDir2(), VERSION_OVERRIDE_FILE);
   if (fs5.existsSync(overridePath)) {
     try {
       const content = JSON.parse(fs5.readFileSync(overridePath, "utf-8"));
@@ -450,7 +450,7 @@ function getElectronAppVersionSource() {
   if (envVersion && /^\d+\.\d+\.\d+$/.test(envVersion)) {
     return "env";
   }
-  const overridePath = path2.join(getDataDir2(), VERSION_OVERRIDE_FILE);
+  const overridePath = path9.join(getDataDir2(), VERSION_OVERRIDE_FILE);
   if (fs5.existsSync(overridePath)) {
     try {
       const content = JSON.parse(fs5.readFileSync(overridePath, "utf-8"));
@@ -485,7 +485,7 @@ function isElectronAppInstalled() {
 }
 function getElectronAppDir(version) {
   const resolvedVersion = version ?? getElectronAppVersion();
-  return path2.join(getDataDir2(), ELECTRON_APP_DIR, resolvedVersion);
+  return path9.join(getDataDir2(), ELECTRON_APP_DIR, resolvedVersion);
 }
 
 // packages/mcps/src/shared/logger.ts
@@ -528,9 +528,9 @@ function resetLogger() {
 // packages/mcps/src/shared/checksum.ts
 var logger = getLogger();
 function getPlatformKey() {
-  const os5 = platform();
+  const os6 = platform();
   const arch2 = process.arch;
-  switch (os5) {
+  switch (os6) {
     case "darwin":
       return arch2 === "arm64" ? "darwin-arm64" : "darwin-x64";
     case "win32":
@@ -538,18 +538,18 @@ function getPlatformKey() {
     case "linux":
       return "linux-x64";
     default:
-      throw new Error(`Unsupported platform: ${os5}`);
+      throw new Error(`Unsupported platform: ${os6}`);
   }
 }
 async function calculateFileChecksum(filePath) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     const hash = crypto.createHash("sha256");
     const stream = fs5.createReadStream(filePath);
     stream.on("data", (data) => {
       hash.update(data);
     });
     stream.on("end", () => {
-      resolve3(hash.digest("hex"));
+      resolve4(hash.digest("hex"));
     });
     stream.on("error", (error) => {
       reject(error);
@@ -559,7 +559,7 @@ async function calculateFileChecksum(filePath) {
 async function verifyFileChecksum(filePath, expectedChecksum) {
   if (!expectedChecksum || expectedChecksum.trim() === "") {
     logger.warn("Checksum verification skipped - no checksum provided", {
-      file: path2.basename(filePath)
+      file: path9.basename(filePath)
     });
     return {
       valid: true,
@@ -575,13 +575,13 @@ async function verifyFileChecksum(filePath, expectedChecksum) {
     const valid = normalizedExpected === normalizedActual;
     if (!valid) {
       logger.error("Checksum verification failed", {
-        file: path2.basename(filePath),
+        file: path9.basename(filePath),
         expected: normalizedExpected,
         actual: normalizedActual
       });
     } else {
       logger.info("Checksum verified successfully", {
-        file: path2.basename(filePath),
+        file: path9.basename(filePath),
         checksum: normalizedActual
       });
     }
@@ -594,7 +594,7 @@ async function verifyFileChecksum(filePath, expectedChecksum) {
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     logger.error("Checksum calculation failed", {
-      file: path2.basename(filePath),
+      file: path9.basename(filePath),
       error: errorMessage
     });
     return {
@@ -627,7 +627,7 @@ function getOpenCommand(url) {
   }
 }
 async function openBrowserUrl(options) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     try {
       const command = getOpenCommand(options.url);
       logger2.debug("[Browser] Opening URL", { url: options.url, command });
@@ -637,13 +637,13 @@ async function openBrowserUrl(options) {
             url: options.url,
             error: error.message
           });
-          resolve3({
+          resolve4({
             opened: false,
             error: error.message
           });
         } else {
           logger2.info("[Browser] URL opened successfully", { url: options.url });
-          resolve3({ opened: true });
+          resolve4({ opened: true });
         }
       });
     } catch (error) {
@@ -652,7 +652,7 @@ async function openBrowserUrl(options) {
         url: options.url,
         error: errorMessage
       });
-      resolve3({
+      resolve4({
         opened: false,
         error: errorMessage
       });
@@ -661,7 +661,7 @@ async function openBrowserUrl(options) {
 }
 var API_KEY_FILE2 = "api-key.json";
 function getApiKeyFilePath() {
-  return path2.join(getDataDir(), API_KEY_FILE2);
+  return path9.join(getDataDir(), API_KEY_FILE2);
 }
 function ensureDataDir() {
   const dataDir = getDataDir();
@@ -850,8 +850,8 @@ var AuthService = class {
   constructor() {
     const config = getConfig();
     this.oauthSessionFilePath = config.localQa.oauthSessionFilePath;
-    this.pendingDeviceCodePath = path2.join(
-      path2.dirname(config.localQa.oauthSessionFilePath),
+    this.pendingDeviceCodePath = path9.join(
+      path9.dirname(config.localQa.oauthSessionFilePath),
       "pending-device-code.json"
     );
   }
@@ -959,7 +959,7 @@ var AuthService = class {
    */
   storePendingDeviceCode(params) {
     const logger6 = getLogger();
-    const dir = path2.dirname(this.pendingDeviceCodePath);
+    const dir = path9.dirname(this.pendingDeviceCodePath);
     if (!fs5.existsSync(dir)) {
       fs5.mkdirSync(dir, { recursive: true });
     }
@@ -1172,7 +1172,7 @@ var AuthService = class {
       email,
       userId
     };
-    const dir = path2.dirname(this.oauthSessionFilePath);
+    const dir = path9.dirname(this.oauthSessionFilePath);
     if (!fs5.existsSync(dir)) {
       fs5.mkdirSync(dir, { recursive: true });
     }
@@ -1275,7 +1275,7 @@ var AuthService = class {
         email: storedAuth.email,
         userId: storedAuth.userId
       };
-      const dir = path2.dirname(this.oauthSessionFilePath);
+      const dir = path9.dirname(this.oauthSessionFilePath);
       if (!fs5.existsSync(dir)) {
         fs5.mkdirSync(dir, { recursive: true });
       }
@@ -1356,9 +1356,9 @@ function resetAuthService() {
   serviceInstance = null;
 }
 function sleep(params) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     setTimeout(() => {
-      resolve3();
+      resolve4();
     }, params.durationMs);
   });
 }
@@ -1398,11 +1398,11 @@ var StorageService = class {
   createSessionDirectory(sessionId) {
     const logger6 = getLogger();
     this.ensureDirectories();
-    const sessionDir = path2.join(this.sessionsDir, sessionId);
+    const sessionDir = path9.join(this.sessionsDir, sessionId);
     if (!fs5.existsSync(sessionDir)) {
       fs5.mkdirSync(sessionDir, { recursive: true });
-      fs5.mkdirSync(path2.join(sessionDir, "screenshots"), { recursive: true });
-      fs5.mkdirSync(path2.join(sessionDir, "logs"), { recursive: true });
+      fs5.mkdirSync(path9.join(sessionDir, "screenshots"), { recursive: true });
+      fs5.mkdirSync(path9.join(sessionDir, "logs"), { recursive: true });
       logger6.info("Created session directory", { sessionId, path: sessionDir });
     }
     return sessionDir;
@@ -1414,7 +1414,7 @@ var StorageService = class {
   saveSessionMetadata(metadata) {
     const logger6 = getLogger();
     const sessionDir = this.createSessionDirectory(metadata.sessionId);
-    const metadataPath = path2.join(sessionDir, "metadata.json");
+    const metadataPath = path9.join(sessionDir, "metadata.json");
     fs5.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
     logger6.debug("Saved session metadata", { sessionId: metadata.sessionId });
   }
@@ -1425,7 +1425,7 @@ var StorageService = class {
    */
   loadSessionMetadata(sessionId) {
     const logger6 = getLogger();
-    const metadataPath = path2.join(this.sessionsDir, sessionId, "metadata.json");
+    const metadataPath = path9.join(this.sessionsDir, sessionId, "metadata.json");
     if (!fs5.existsSync(metadataPath)) {
       return null;
     }
@@ -1449,7 +1449,7 @@ var StorageService = class {
       return [];
     }
     return fs5.readdirSync(this.sessionsDir).filter((entry) => {
-      const entryPath = path2.join(this.sessionsDir, entry);
+      const entryPath = path9.join(this.sessionsDir, entry);
       return fs5.statSync(entryPath).isDirectory();
     });
   }
@@ -1458,13 +1458,13 @@ var StorageService = class {
    * @returns Current session ID, or null.
    */
   getCurrentSessionId() {
-    const currentPath = path2.join(this.sessionsDir, "current");
+    const currentPath = path9.join(this.sessionsDir, "current");
     if (!fs5.existsSync(currentPath)) {
       return null;
     }
     try {
       const target = fs5.readlinkSync(currentPath);
-      return path2.basename(target);
+      return path9.basename(target);
     } catch {
       return null;
     }
@@ -1475,8 +1475,8 @@ var StorageService = class {
    */
   setCurrentSession(sessionId) {
     const logger6 = getLogger();
-    const currentPath = path2.join(this.sessionsDir, "current");
-    const targetPath = path2.join(this.sessionsDir, sessionId);
+    const currentPath = path9.join(this.sessionsDir, "current");
+    const targetPath = path9.join(this.sessionsDir, sessionId);
     if (fs5.existsSync(currentPath)) {
       fs5.unlinkSync(currentPath);
     }
@@ -1491,7 +1491,7 @@ var StorageService = class {
     const { sessionId, filename, data } = params;
     const logger6 = getLogger();
     const sessionDir = this.createSessionDirectory(sessionId);
-    const screenshotPath = path2.join(sessionDir, "screenshots", filename);
+    const screenshotPath = path9.join(sessionDir, "screenshots", filename);
     fs5.writeFileSync(screenshotPath, data);
     logger6.debug("Saved screenshot", { sessionId, filename });
     return screenshotPath;
@@ -1504,7 +1504,7 @@ var StorageService = class {
     const { sessionId, content } = params;
     const logger6 = getLogger();
     const sessionDir = this.createSessionDirectory(sessionId);
-    const resultsPath = path2.join(sessionDir, "results.md");
+    const resultsPath = path9.join(sessionDir, "results.md");
     fs5.appendFileSync(resultsPath, content + "\n", "utf-8");
     logger6.debug("Appended to results", { sessionId });
   }
@@ -1514,7 +1514,7 @@ var StorageService = class {
    * @returns Results content, or null if not found.
    */
   getResults(sessionId) {
-    const resultsPath = path2.join(this.sessionsDir, sessionId, "results.md");
+    const resultsPath = path9.join(this.sessionsDir, sessionId, "results.md");
     if (!fs5.existsSync(resultsPath)) {
       return null;
     }
@@ -1583,7 +1583,7 @@ var StorageService = class {
     const { sessionId, targetUrl, testInstructions } = params;
     const logger6 = getLogger();
     const sessionDir = this.createSessionDirectory(sessionId);
-    const resultsPath = path2.join(sessionDir, "results.md");
+    const resultsPath = path9.join(sessionDir, "results.md");
     const header = [
       `# Test Results: ${sessionId}`,
       "",
@@ -1607,7 +1607,7 @@ var StorageService = class {
     const { sessionId, step } = params;
     const logger6 = getLogger();
     const sessionDir = this.createSessionDirectory(sessionId);
-    const resultsPath = path2.join(sessionDir, "results.md");
+    const resultsPath = path9.join(sessionDir, "results.md");
     const statusIcon = step.success ? "\u2713" : "\u2717";
     const stepContent = [
       `### Step ${step.stepNumber}: ${step.action}`,
@@ -1632,8 +1632,8 @@ var StorageService = class {
   finalizeResults(params) {
     const { sessionId, status, summary } = params;
     const logger6 = getLogger();
-    const sessionDir = path2.join(this.sessionsDir, sessionId);
-    const resultsPath = path2.join(sessionDir, "results.md");
+    const sessionDir = path9.join(this.sessionsDir, sessionId);
+    const resultsPath = path9.join(sessionDir, "results.md");
     if (!fs5.existsSync(resultsPath)) {
       logger6.warn("Results file not found for finalization", { sessionId });
       return;
@@ -1715,7 +1715,7 @@ var StorageService = class {
       }
       const sessionDate = new Date(metadata.startTime);
       if (sessionDate < cutoffDate) {
-        const sessionDir = path2.join(this.sessionsDir, sessionId);
+        const sessionDir = path9.join(this.sessionsDir, sessionId);
         try {
           fs5.rmSync(sessionDir, { recursive: true, force: true });
           deletedCount++;
@@ -1745,7 +1745,7 @@ var StorageService = class {
    * @returns Session directory path.
    */
   getSessionPath(sessionId) {
-    return path2.join(this.sessionsDir, sessionId);
+    return path9.join(this.sessionsDir, sessionId);
   }
   /**
    * Delete a specific session.
@@ -1754,7 +1754,7 @@ var StorageService = class {
    */
   deleteSession(sessionId) {
     const logger6 = getLogger();
-    const sessionDir = path2.join(this.sessionsDir, sessionId);
+    const sessionDir = path9.join(this.sessionsDir, sessionId);
     if (!fs5.existsSync(sessionDir)) {
       logger6.warn("Session not found for deletion", { sessionId });
       return false;
@@ -1762,7 +1762,7 @@ var StorageService = class {
     try {
       const currentId = this.getCurrentSessionId();
       if (currentId === sessionId) {
-        const currentPath = path2.join(this.sessionsDir, "current");
+        const currentPath = path9.join(this.sessionsDir, "current");
         if (fs5.existsSync(currentPath)) {
           fs5.unlinkSync(currentPath);
         }
@@ -1796,8 +1796,8 @@ var RunResultStorageService = class {
   constructor() {
     const storageService = getStorageService();
     const dataDir = storageService.getDataDir();
-    this.runResultsDir = path2.join(dataDir, "run-results");
-    this.testScriptsDir = path2.join(dataDir, "test-scripts");
+    this.runResultsDir = path9.join(dataDir, "run-results");
+    this.testScriptsDir = path9.join(dataDir, "test-scripts");
     this.ensureDirectories();
   }
   /**
@@ -1823,7 +1823,7 @@ var RunResultStorageService = class {
       const results = [];
       for (const file of files) {
         try {
-          const content = fs5.readFileSync(path2.join(this.runResultsDir, file), "utf-8");
+          const content = fs5.readFileSync(path9.join(this.runResultsDir, file), "utf-8");
           results.push(JSON.parse(content));
         } catch {
           logger3.warn("Failed to read run result file", { file });
@@ -1838,7 +1838,7 @@ var RunResultStorageService = class {
    * Get a run result by ID.
    */
   getRunResult(runId) {
-    const filePath = path2.join(this.runResultsDir, `${runId}.json`);
+    const filePath = path9.join(this.runResultsDir, `${runId}.json`);
     if (!fs5.existsSync(filePath)) {
       return void 0;
     }
@@ -1853,7 +1853,7 @@ var RunResultStorageService = class {
    * Save a run result.
    */
   saveRunResult(result) {
-    const filePath = path2.join(this.runResultsDir, `${result.id}.json`);
+    const filePath = path9.join(this.runResultsDir, `${result.id}.json`);
     fs5.writeFileSync(filePath, JSON.stringify(result, null, 2));
   }
   /**
@@ -1906,7 +1906,7 @@ var RunResultStorageService = class {
       const scripts = [];
       for (const file of files) {
         try {
-          const content = fs5.readFileSync(path2.join(this.testScriptsDir, file), "utf-8");
+          const content = fs5.readFileSync(path9.join(this.testScriptsDir, file), "utf-8");
           scripts.push(JSON.parse(content));
         } catch {
           logger3.warn("Failed to read test script file", { file });
@@ -1921,7 +1921,7 @@ var RunResultStorageService = class {
    * Get a test script by ID.
    */
   getTestScript(testScriptId) {
-    const filePath = path2.join(this.testScriptsDir, `${testScriptId}.json`);
+    const filePath = path9.join(this.testScriptsDir, `${testScriptId}.json`);
     if (!fs5.existsSync(filePath)) {
       return void 0;
     }
@@ -1936,7 +1936,7 @@ var RunResultStorageService = class {
    * Save a test script.
    */
   saveTestScript(script) {
-    const filePath = path2.join(this.testScriptsDir, `${script.id}.json`);
+    const filePath = path9.join(this.testScriptsDir, `${script.id}.json`);
     fs5.writeFileSync(filePath, JSON.stringify(script, null, 2));
   }
   /**
@@ -1986,6 +1986,176 @@ function resetRunResultStorageService() {
   instance = null;
 }
 
+// packages/mcps/src/mcp/local/services/local-execution-lock-constants.ts
+var LOCK_FILE_NAME = "local-execution.lock";
+var MODIFY_LOCK_SUFFIX = ".modify";
+var POLL_INTERVAL_MS = 2e3;
+var WAIT_LOG_INTERVAL_MS = 1e4;
+var MODIFY_LOCK_RETRY_MS = 50;
+var MODIFY_LOCK_STALE_MS = 5e3;
+
+// packages/mcps/src/mcp/local/services/local-execution-lock.ts
+function lockFilePath() {
+  return path9.join(getDataDir(), LOCK_FILE_NAME);
+}
+function modifyLockPath() {
+  return lockFilePath() + MODIFY_LOCK_SUFFIX;
+}
+function normalizeCwd(cwd) {
+  const resolved = path9.resolve(cwd);
+  return os4.platform() === "win32" ? resolved.toLowerCase() : resolved;
+}
+function pidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") return false;
+    if (code === "EPERM") return true;
+    return false;
+  }
+}
+async function readState() {
+  try {
+    const raw = await fs8.readFile(lockFilePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function writeState(state2) {
+  await fs8.writeFile(lockFilePath(), JSON.stringify(state2, null, 2), "utf-8");
+}
+async function deleteStateFile() {
+  try {
+    await fs8.unlink(lockFilePath());
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function withModifyLock(fn) {
+  await fs8.mkdir(path9.dirname(modifyLockPath()), { recursive: true });
+  const modifyPath = modifyLockPath();
+  let fileHandle = null;
+  while (fileHandle === null) {
+    try {
+      fileHandle = await fs8.open(modifyPath, "wx");
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      try {
+        const stat3 = await fs8.stat(modifyPath);
+        if (Date.now() - stat3.mtimeMs > MODIFY_LOCK_STALE_MS) {
+          await fs8.unlink(modifyPath).catch(() => void 0);
+          continue;
+        }
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, MODIFY_LOCK_RETRY_MS));
+    }
+  }
+  try {
+    await fileHandle.writeFile(JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    return await fn();
+  } finally {
+    await fileHandle.close().catch(() => void 0);
+    await fs8.unlink(modifyPath).catch(() => void 0);
+  }
+}
+async function tryAcquireOnce(params) {
+  return await withModifyLock(async () => {
+    const existing = await readState();
+    if (existing === null) {
+      await writeState({
+        holderCwd: params.normalizedCwd,
+        holderPids: [params.pid],
+        acquiredAt: Date.now()
+      });
+      return { acquired: true };
+    }
+    const liveHolderPids = existing.holderPids.filter((pid) => pidIsAlive(pid));
+    if (liveHolderPids.length === 0) {
+      getLogger().warn("Breaking stale local-execution lock", {
+        staleCwd: existing.holderCwd,
+        stalePids: existing.holderPids
+      });
+      await writeState({
+        holderCwd: params.normalizedCwd,
+        holderPids: [params.pid],
+        acquiredAt: Date.now()
+      });
+      return { acquired: true };
+    }
+    if (existing.holderCwd === params.normalizedCwd) {
+      const updated = {
+        holderCwd: existing.holderCwd,
+        holderPids: [...liveHolderPids, params.pid],
+        acquiredAt: existing.acquiredAt
+      };
+      await writeState(updated);
+      return { acquired: true };
+    }
+    return {
+      acquired: false,
+      blockingState: { ...existing, holderPids: liveHolderPids }
+    };
+  });
+}
+async function decrementHolder(params) {
+  await withModifyLock(async () => {
+    const existing = await readState();
+    if (existing === null) return;
+    if (existing.holderCwd !== params.normalizedCwd) {
+      getLogger().warn("Release skipped \u2014 holder cwd no longer matches", {
+        ourCwd: params.normalizedCwd,
+        holderCwd: existing.holderCwd
+      });
+      return;
+    }
+    const removalIndex = existing.holderPids.indexOf(params.pid);
+    const remainingPids = removalIndex >= 0 ? [...existing.holderPids.slice(0, removalIndex), ...existing.holderPids.slice(removalIndex + 1)] : existing.holderPids;
+    if (remainingPids.length === 0) {
+      await deleteStateFile();
+      return;
+    }
+    await writeState({
+      holderCwd: existing.holderCwd,
+      holderPids: remainingPids,
+      acquiredAt: existing.acquiredAt
+    });
+  });
+}
+async function acquireLocalExecutionLock(params) {
+  const normalizedCwd = normalizeCwd(params.cwd);
+  const pid = process.pid;
+  const startWaitAt = Date.now();
+  let lastWaitLogAt = 0;
+  while (true) {
+    const outcome = await tryAcquireOnce({ normalizedCwd, pid });
+    if (outcome.acquired) {
+      return {
+        release: () => decrementHolder({ normalizedCwd, pid })
+      };
+    }
+    const now = Date.now();
+    if (now - lastWaitLogAt >= WAIT_LOG_INTERVAL_MS) {
+      const waitedSec = Math.round((now - startWaitAt) / 1e3);
+      getLogger().info("Waiting for local-execution lock", {
+        ourCwd: normalizedCwd,
+        heldBy: outcome.blockingState?.holderCwd,
+        heldByPids: outcome.blockingState?.holderPids,
+        waitedSec
+      });
+      lastWaitLogAt = now;
+    }
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+  }
+}
+async function readLocalExecutionLockState() {
+  return readState();
+}
+
 // packages/mcps/src/mcp/local/services/replay-url-rewrite.ts
 function rewriteActionScriptUrls(params) {
   const { actionScript, originalUrl, localUrl } = params;
@@ -2045,15 +2215,15 @@ function getAuthenticatedUserId() {
 }
 async function findPackageJsonAsync() {
   const currentFileUrl = import.meta.url;
-  const currentDir = path2.dirname(fileURLToPath(currentFileUrl));
+  const currentDir = path9.dirname(fileURLToPath(currentFileUrl));
   const candidatePaths = [
-    path2.resolve(currentDir, "../../../package.json"),
-    path2.resolve(currentDir, "../package.json"),
-    path2.resolve(currentDir, "../../package.json")
+    path9.resolve(currentDir, "../../../package.json"),
+    path9.resolve(currentDir, "../package.json"),
+    path9.resolve(currentDir, "../../package.json")
   ];
   for (const candidatePath of candidatePaths) {
     try {
-      const packageJsonRaw = await fs7.readFile(candidatePath, "utf-8");
+      const packageJsonRaw = await fs8.readFile(candidatePath, "utf-8");
       const packageJson = JSON.parse(packageJsonRaw);
       if (packageJson.name === "@muggleai/works" && packageJson.version && packageJson.muggleConfig?.electronAppVersion) {
         return {
@@ -2075,8 +2245,8 @@ async function getLocalExecutionContextBaseAsync(params) {
     originalUrl: params.originalUrl,
     productionUrl: params.productionUrl,
     runByUserId: params.runByUserId,
-    machineHostname: os3.hostname(),
-    osInfo: `${os3.platform()} ${os3.release()} ${os3.arch()}`,
+    machineHostname: os4.hostname(),
+    osInfo: `${os4.platform()} ${os4.release()} ${os4.arch()}`,
     electronAppVersion: packageJson.muggleConfig.electronAppVersion,
     mcpServerVersion: packageJson.version
   };
@@ -2099,20 +2269,20 @@ function buildStudioAuthContent() {
 }
 async function ensureTempDir() {
   const config = getConfig();
-  const tempDir = path2.join(config.localQa.dataDir, "temp");
-  await fs7.mkdir(tempDir, { recursive: true });
+  const tempDir = path9.join(config.localQa.dataDir, "temp");
+  await fs8.mkdir(tempDir, { recursive: true });
   return tempDir;
 }
 async function writeTempFile(params) {
   const tempDir = await ensureTempDir();
-  const filePath = path2.join(tempDir, params.filename);
-  await fs7.writeFile(filePath, JSON.stringify(params.data, null, 2));
+  const filePath = path9.join(tempDir, params.filename);
+  await fs8.writeFile(filePath, JSON.stringify(params.data, null, 2));
   return filePath;
 }
 async function cleanupTempFiles(params) {
   for (const filePath of params.filePaths) {
     try {
-      await fs7.unlink(filePath);
+      await fs8.unlink(filePath);
     } catch {
     }
   }
@@ -2120,12 +2290,12 @@ async function cleanupTempFiles(params) {
 async function moveResultsToArtifacts(params) {
   const storageService = getStorageService();
   const sessionsDir = storageService.getSessionsDir();
-  const artifactsDir = path2.join(sessionsDir, params.runId);
-  const actionScriptPath = path2.join(artifactsDir, "action-script.json");
-  await fs7.mkdir(artifactsDir, { recursive: true });
-  await fs7.copyFile(params.generatedScriptPath, actionScriptPath);
+  const artifactsDir = path9.join(sessionsDir, params.runId);
+  const actionScriptPath = path9.join(artifactsDir, "action-script.json");
+  await fs8.mkdir(artifactsDir, { recursive: true });
+  await fs8.copyFile(params.generatedScriptPath, actionScriptPath);
   try {
-    await fs7.unlink(params.generatedScriptPath);
+    await fs8.unlink(params.generatedScriptPath);
   } catch {
   }
   return artifactsDir;
@@ -2133,19 +2303,92 @@ async function moveResultsToArtifacts(params) {
 async function writeExecutionLogs(params) {
   const storageService = getStorageService();
   const sessionsDir = storageService.getSessionsDir();
-  const artifactsDir = path2.join(sessionsDir, params.runId);
-  await fs7.mkdir(artifactsDir, { recursive: true });
-  const stdoutPath = path2.join(artifactsDir, "stdout.log");
-  const stderrPath = path2.join(artifactsDir, "stderr.log");
+  const artifactsDir = path9.join(sessionsDir, params.runId);
+  await fs8.mkdir(artifactsDir, { recursive: true });
+  const stdoutPath = path9.join(artifactsDir, "stdout.log");
+  const stderrPath = path9.join(artifactsDir, "stderr.log");
   await Promise.all([
-    fs7.writeFile(stdoutPath, params.stdout, "utf-8"),
-    fs7.writeFile(stderrPath, params.stderr, "utf-8")
+    fs8.writeFile(stdoutPath, params.stdout, "utf-8"),
+    fs8.writeFile(stderrPath, params.stderr, "utf-8")
   ]);
   logger4.info("Wrote execution logs to artifacts directory", {
     runId: params.runId,
     artifactsDir
   });
 }
+async function preserveElectronRuntimeArtifacts(params) {
+  try {
+    const tempDir = await ensureTempDir();
+    const markerPath = path9.join(tempDir, `${params.runId}_runtime_dir.txt`);
+    let runtimeDir = null;
+    try {
+      const marker = await fs8.readFile(markerPath, "utf-8");
+      const trimmed = marker.trim();
+      if (trimmed.length > 0) runtimeDir = trimmed;
+    } catch (markerReadError) {
+      if (markerReadError.code !== "ENOENT") {
+        logger4.warn("Failed to read runtime-dir marker", {
+          runId: params.runId,
+          error: String(markerReadError)
+        });
+      }
+    }
+    if (runtimeDir === null) {
+      runtimeDir = await scanForRuntimeDirByMtime({
+        electronCwd: params.electronCwd,
+        spawnAtMs: params.spawnAtMs
+      });
+    }
+    if (runtimeDir === null) {
+      logger4.info("No Electron runtime dir found to preserve", { runId: params.runId });
+      return;
+    }
+    try {
+      await fs8.access(runtimeDir);
+    } catch {
+      logger4.warn("Electron runtime dir referenced but missing on disk", {
+        runId: params.runId,
+        runtimeDir
+      });
+      await fs8.unlink(markerPath).catch(() => void 0);
+      return;
+    }
+    const storage = getStorageService();
+    const destDir = path9.join(storage.getSessionsDir(), params.runId, "electron-runtime");
+    await fs8.mkdir(destDir, { recursive: true });
+    await fs8.cp(runtimeDir, destDir, { recursive: true });
+    logger4.info("Preserved Electron runtime artifacts", {
+      runId: params.runId,
+      sourceDir: runtimeDir,
+      destDir
+    });
+    await fs8.unlink(markerPath).catch(() => void 0);
+  } catch (preserveError) {
+    logger4.warn("Failed to preserve Electron runtime artifacts", {
+      runId: params.runId,
+      error: preserveError instanceof Error ? preserveError.message : String(preserveError)
+    });
+  }
+}
+async function scanForRuntimeDirByMtime(params) {
+  const runtimeRoot = path9.join(params.electronCwd, "user_data", "runtime");
+  try {
+    const entries = await fs8.readdir(runtimeRoot, { withFileTypes: true });
+    let bestCandidate = null;
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const fullPath = path9.join(runtimeRoot, entry.name);
+      const stat3 = await fs8.stat(fullPath);
+      if (stat3.mtimeMs < params.spawnAtMs) continue;
+      if (bestCandidate === null || stat3.mtimeMs > bestCandidate.mtimeMs) {
+        bestCandidate = { path: fullPath, mtimeMs: stat3.mtimeMs };
+      }
+    }
+    return bestCandidate?.path ?? null;
+  } catch {
+    return null;
+  }
+}
 function getElectronAppPathOrThrow() {
   const electronAppPath = resolveElectronAppPathOrNull();
   if (electronAppPath && electronAppPath.trim() !== "") {
@@ -2283,10 +2526,11 @@ async function executeElectronAppAsync(params) {
   });
   const electronEnv = { ...process.env };
   delete electronEnv.ELECTRON_RUN_AS_NODE;
+  const electronCwd = path9.dirname(electronAppPath);
   const child = spawn(electronAppPath, spawnArgs, {
     stdio: ["ignore", "pipe", "pipe"],
     env: electronEnv,
-    cwd: path2.dirname(electronAppPath)
+    cwd: electronCwd
   });
   const processInfo = {
     runId: params.runId,
@@ -2297,7 +2541,7 @@ async function executeElectronAppAsync(params) {
     capturedStderr: ""
   };
   activeProcesses.set(params.runId, processInfo);
-  return await new Promise((resolve3, reject) => {
+  return await new Promise((resolve4, reject) => {
     let settled = false;
     const finalize = (result) => {
       if (settled) {
@@ -2309,7 +2553,7 @@ async function executeElectronAppAsync(params) {
       }
       activeProcesses.delete(params.runId);
       if (result.ok) {
-        resolve3(result.payload);
+        resolve4(result.payload);
       } else {
         reject(result.payload);
       }
@@ -2363,13 +2607,22 @@ ${processInfo.capturedStderr}`
         payload: {
           exitCode,
           stdout: processInfo.capturedStdout,
-          stderr: processInfo.capturedStderr
+          stderr: processInfo.capturedStderr,
+          electronCwd
         }
       });
     });
   });
 }
 async function executeTestGeneration(params) {
+  const lockHandle = await acquireLocalExecutionLock({ cwd: params.cwd });
+  try {
+    return await runTestGenerationLocked(params);
+  } finally {
+    await lockHandle.release();
+  }
+}
+async function runTestGenerationLocked(params) {
   const { testCase, localUrl } = params;
   const timeoutMs = params.timeoutMs ?? 3e5;
   const userId = getAuthenticatedUserId();
@@ -2438,17 +2691,35 @@ async function executeTestGeneration(params) {
         stdout: executionResult.stdout,
         stderr: executionResult.stderr
       });
+      await preserveElectronRuntimeArtifacts({
+        runId,
+        electronCwd: executionResult.electronCwd,
+        spawnAtMs: startedAt
+      });
       if (executionResult.exitCode !== 0) {
         const failureMessage = `Electron exited with code ${executionResult.exitCode}.
 STDOUT:
 ${executionResult.stdout}
 STDERR:
 ${executionResult.stderr}`;
+        const sessionsDir = getStorageService().getSessionsDir();
+        const artifactsDir2 = path9.join(sessionsDir, runId);
+        const generatedScriptPath2 = path9.join(
+          path9.dirname(inputFilePath),
+          `gen_${path9.basename(inputFilePath)}`
+        );
+        try {
+          await fs8.copyFile(generatedScriptPath2, path9.join(artifactsDir2, "action-script.json"));
+          await fs8.unlink(generatedScriptPath2).catch(() => {
+          });
+        } catch {
+        }
         storage.updateRunResult(runId, {
           status: "failed",
           testScriptId: localTestScript.id,
           executionTimeMs,
           errorMessage: failureMessage,
+          artifactsDir: artifactsDir2,
           localExecutionContext: {
             ...localExecutionContextBase,
             localExecutionCompletedAt: completedAt
@@ -2465,11 +2736,11 @@ ${executionResult.stderr}`;
           errorMessage: failureMessage
         };
       }
-      const generatedScriptPath = path2.join(
-        path2.dirname(inputFilePath),
-        `gen_${path2.basename(inputFilePath)}`
+      const generatedScriptPath = path9.join(
+        path9.dirname(inputFilePath),
+        `gen_${path9.basename(inputFilePath)}`
       );
-      const generatedScriptRaw = await fs7.readFile(generatedScriptPath, "utf-8");
+      const generatedScriptRaw = await fs8.readFile(generatedScriptPath, "utf-8");
       const generatedScript = JSON.parse(generatedScriptRaw);
       const generatedSteps = generatedScript.steps;
       if (!Array.isArray(generatedSteps)) {
@@ -2528,6 +2799,14 @@ ${executionResult.stderr}`;
   }
 }
 async function executeReplay(params) {
+  const lockHandle = await acquireLocalExecutionLock({ cwd: params.cwd });
+  try {
+    return await runReplayLocked(params);
+  } finally {
+    await lockHandle.release();
+  }
+}
+async function runReplayLocked(params) {
   const { testScript, actionScript, localUrl } = params;
   const timeoutMs = params.timeoutMs ?? 18e4;
   const userId = getAuthenticatedUserId();
@@ -2590,16 +2869,23 @@ async function executeReplay(params) {
         stdout: executionResult.stdout,
         stderr: executionResult.stderr
       });
+      await preserveElectronRuntimeArtifacts({
+        runId,
+        electronCwd: executionResult.electronCwd,
+        spawnAtMs: startedAt
+      });
       if (executionResult.exitCode !== 0) {
         const failureMessage = `Electron exited with code ${executionResult.exitCode}.
 STDOUT:
 ${executionResult.stdout}
 STDERR:
 ${executionResult.stderr}`;
+        const artifactsDir2 = path9.join(getStorageService().getSessionsDir(), runId);
         storage.updateRunResult(runId, {
           status: "failed",
           executionTimeMs,
           errorMessage: failureMessage,
+          artifactsDir: artifactsDir2,
           localExecutionContext: {
             ...localExecutionContextBase,
             localExecutionCompletedAt: completedAt
@@ -2612,7 +2898,7 @@ ${executionResult.stderr}`;
           errorMessage: failureMessage
         };
       }
-      const artifactsDir = path2.join(getStorageService().getSessionsDir(), runId);
+      const artifactsDir = path9.join(getStorageService().getSessionsDir(), runId);
       storage.updateRunResult(runId, {
         status: "passed",
         executionTimeMs,
@@ -3045,7 +3331,7 @@ 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);
+  return path9.join(os4.homedir(), DATA_DIR_NAME2);
 }
 
 var cachedInstallId;
@@ -3110,9 +3396,9 @@ function isValid2(value) {
 function readReleaseManifest2() {
   if (cachedManifest2 !== void 0)
     return cachedManifest2;
-  const path15 = MANIFEST_PATH2;
+  const path16 = MANIFEST_PATH2;
   try {
-    const raw = readFileSync(path15, "utf8");
+    const raw = readFileSync(path16, "utf8");
     const parsed = JSON.parse(raw);
     cachedManifest2 = isValid2(parsed) ? parsed : DEV_MANIFEST2;
     return cachedManifest2;
@@ -3666,7 +3952,11 @@ var ProjectTestScriptsSummaryInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to get test scripts summary for")
 });
 var ProjectTestRunsSummaryInputSchema = z.object({
-  projectId: IdSchema.describe("Project ID (UUID) to get test runs summary for")
+  projectId: IdSchema.describe("Project ID (UUID) to get test runs summary for"),
+  page: z.number().int().positive().default(1).describe("Page number, 1-based. Defaults to 1."),
+  pageSize: z.number().int().positive().max(100).default(20).describe("Number of runs per page. Defaults to 20, max 100."),
+  sortBy: z.enum(["lastRunAt", "status", "testCaseTitle"]).default("lastRunAt").describe("Sort field for the runs slice. Defaults to lastRunAt."),
+  sortOrder: z.enum(["asc", "desc"]).default("desc").describe("Sort direction. Defaults to desc (most recent / Z\u2192A first).")
 });
 var ReportStatsSummaryInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to get report stats for")
@@ -3872,17 +4162,17 @@ var PromptServiceClient = class {
    * @param path - Path to validate.
    * @throws GatewayError if path is not allowed.
    */
-  validatePath(path15) {
-    const isAllowed = ALLOWED_UPSTREAM_PREFIXES.some((prefix) => path15.startsWith(prefix));
+  validatePath(path16) {
+    const isAllowed = ALLOWED_UPSTREAM_PREFIXES.some((prefix) => path16.startsWith(prefix));
     if (!isAllowed) {
       const logger6 = getLogger();
       logger6.error("Path not in allowlist", {
-        path: path15,
+        path: path16,
         allowedPrefixes: ALLOWED_UPSTREAM_PREFIXES
       });
       throw new GatewayError({
         code: "FORBIDDEN" /* FORBIDDEN */,
-        message: `Path '${path15}' is not allowed`
+        message: `Path '${path16}' is not allowed`
       });
     }
   }
@@ -4100,6 +4390,59 @@ function getPromptServiceClient() {
   return clientInstance;
 }
 
+// packages/mcps/src/mcp/tools/e2e/test-runs-summary-transform.ts
+var UNKNOWN_STATUS = "UNKNOWN";
+function slimEntry(raw) {
+  const slim = { status: raw.status ?? UNKNOWN_STATUS };
+  if (raw.testCase?.id) slim.testCaseId = raw.testCase.id;
+  if (raw.testCase?.title) slim.testCaseTitle = raw.testCase.title;
+  if (raw.useCase?.id) slim.useCaseId = raw.useCase.id;
+  if (raw.useCase?.title) slim.useCaseTitle = raw.useCase.title;
+  if (typeof raw.lastRunAt === "number") slim.lastRunAt = raw.lastRunAt;
+  if (raw.error) slim.error = raw.error;
+  if (raw.latestWorkflowRun?.id) slim.latestWorkflowRunId = raw.latestWorkflowRun.id;
+  return slim;
+}
+function aggregateByStatus(entries) {
+  const counts = {};
+  for (const entry of entries) {
+    const status = entry.status ?? UNKNOWN_STATUS;
+    counts[status] = (counts[status] ?? 0) + 1;
+  }
+  return counts;
+}
+function sortRuns(runs, sortBy, sortOrder) {
+  const sign = sortOrder === "asc" ? 1 : -1;
+  return [...runs].sort((a, b) => {
+    const av = a[sortBy];
+    const bv = b[sortBy];
+    if (av === void 0 && bv === void 0) return 0;
+    if (av === void 0) return 1;
+    if (bv === void 0) return -1;
+    if (av < bv) return -1 * sign;
+    if (av > bv) return 1 * sign;
+    return 0;
+  });
+}
+function mapTestRunsSummary(response, input) {
+  const params = input;
+  const raw = Array.isArray(response.data) ? response.data : [];
+  const byStatus = aggregateByStatus(raw);
+  const sorted = sortRuns(raw.map(slimEntry), params.sortBy, params.sortOrder);
+  const total = sorted.length;
+  const totalPages = Math.max(1, Math.ceil(total / params.pageSize));
+  const start = (params.page - 1) * params.pageSize;
+  const runs = sorted.slice(start, start + params.pageSize);
+  return {
+    totals: { total, byStatus },
+    page: params.page,
+    pageSize: params.pageSize,
+    totalPages,
+    hasMore: params.page < totalPages,
+    runs
+  };
+}
+
 // packages/mcps/src/mcp/tools/e2e/tool-registry.ts
 var MUGGLE_TEST_PREFIX = "/v1/protected/muggle-test";
 var getWorkflowTimeoutMs = () => getConfig().e2e.workflowTimeoutMs;
@@ -4896,7 +5239,7 @@ var reportTools = [
   },
   {
     name: "muggle-remote-project-test-runs-summary-get",
-    description: "Get a summary of test runs for a project.",
+    description: "Get a paginated, slimmed summary of latest test runs for a project. Response shape: { totals: { total, byStatus }, page, pageSize, totalPages, hasMore, runs: [{ status, testCaseId, testCaseTitle, useCaseId, useCaseTitle, lastRunAt, error, latestWorkflowRunId }] }. Returns 20 runs per page by default (max 100). `totals` covers the full project; `runs` is the page slice. Check `hasMore` to decide whether to fetch additional pages. Use muggle-remote-test-case-get / muggle-remote-wf-get-ts-replay-latest-run for full per-run detail.",
     inputSchema: ProjectTestRunsSummaryInputSchema,
     mapToUpstream: (input) => {
       const data = input;
@@ -4904,7 +5247,8 @@ var reportTools = [
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/test-runs/summary`
       };
-    }
+    },
+    mapFromUpstream: mapTestRunsSummary
   },
   {
     name: "muggle-remote-report-stats-summary-get",
@@ -5754,6 +6098,8 @@ var ExecuteTestGenerationInputSchema = z.object({
   testCase: TestCaseDetailsSchema.describe("Test case details obtained from muggle-remote-test-case-get"),
   /** Local URL to test against. */
   localUrl: z.string().url().describe("Local URL to test against (e.g., http://localhost:3000)"),
+  /** Absolute path identifying the caller's worktree. Drives the cross-worktree single-flight lock — same path = parallel allowed (intra-change), different path = waits its turn. Required: ambiguity here causes the lock to mis-key, splitting one logical change into two competing holders. */
+  cwd: z.string().min(1).describe("Absolute path of the caller's worktree. Required \u2014 this keys the cross-worktree single-flight lock so concurrent muggle-test runs from different branches serialize."),
   /** Optional timeout. */
   timeoutMs: z.number().int().positive().optional().describe("Timeout in milliseconds (default: 300000 = 5 min)"),
   /** Show the electron-app UI during execution. Default: visible window. Pass false to run headless. */
@@ -5770,6 +6116,8 @@ var ExecuteReplayInputSchema = z.object({
   actionScript: z.array(z.unknown()).describe("Action script steps from muggle-remote-action-script-get"),
   /** Local URL to test against. */
   localUrl: z.string().url().describe("Local URL to test against (e.g., http://localhost:3000)"),
+  /** Absolute path identifying the caller's worktree. Drives the cross-worktree single-flight lock — same path = parallel allowed (intra-change), different path = waits its turn. Required: ambiguity here causes the lock to mis-key, splitting one logical change into two competing holders. */
+  cwd: z.string().min(1).describe("Absolute path of the caller's worktree. Required \u2014 this keys the cross-worktree single-flight lock so concurrent muggle-test runs from different branches serialize."),
   /** Optional timeout. */
   timeoutMs: z.number().int().positive().optional().describe("Timeout in milliseconds (default: 180000 = 3 min)"),
   /** Show the electron-app UI during execution. Default: visible window. Pass false to run headless. */
@@ -6031,9 +6379,9 @@ 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);
+    const dir = path9.join(getDataDir(), TELEMETRY_DIR_NAME);
     fs5.mkdirSync(dir, { recursive: true });
-    const filePath = path2.join(dir, FAILURE_EVENTS_FILE_NAME);
+    const filePath = path9.join(dir, FAILURE_EVENTS_FILE_NAME);
     const full = { ts: (/* @__PURE__ */ new Date()).toISOString(), ...record };
     fs5.appendFileSync(filePath, `${JSON.stringify(full)}
 `, "utf-8");
@@ -6044,7 +6392,7 @@ function appendFailureEvent(record) {
   }
 }
 function isFirstRun(dataDirOverride2) {
-  const filePath = path2.join(dataDirOverride2 ?? getDataDir(), PREFERENCES_FILE_NAME);
+  const filePath = path9.join(dataDirOverride2 ?? getDataDir(), PREFERENCES_FILE_NAME);
   return !fs5.existsSync(filePath);
 }
 function readPreferencesFile(filePath) {
@@ -6063,12 +6411,12 @@ function readPreferencesFile(filePath) {
   }
 }
 function readGlobalPreferences(dataDirOverride2) {
-  const filePath = path2.join(dataDirOverride2 ?? getDataDir(), PREFERENCES_FILE_NAME);
+  const filePath = path9.join(dataDirOverride2 ?? getDataDir(), PREFERENCES_FILE_NAME);
   const partial = readPreferencesFile(filePath);
   return { ...DEFAULT_PREFERENCES, ...partial };
 }
 function readProjectPreferences(cwd) {
-  const filePath = path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_FILE_NAME);
+  const filePath = path9.join(cwd, PREFERENCES_PROJECT_DIR_NAME, PREFERENCES_FILE_NAME);
   return readPreferencesFile(filePath);
 }
 function resolvePreferences(dataDirOverride2, cwd) {
@@ -6080,9 +6428,9 @@ function resolvePreferences(dataDirOverride2, cwd) {
   return { ...global, ...project };
 }
 function writePreferences2(prefs, scope, dataDirOverride2, cwd) {
-  const dir = scope === "project" && cwd ? path2.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride2 ?? getDataDir();
+  const dir = scope === "project" && cwd ? path9.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride2 ?? getDataDir();
   fs5.mkdirSync(dir, { recursive: true });
-  const filePath = path2.join(dir, PREFERENCES_FILE_NAME);
+  const filePath = path9.join(dir, PREFERENCES_FILE_NAME);
   const existing = readPreferencesFile(filePath);
   const merged = { ...existing, ...prefs };
   const file = {
@@ -6093,8 +6441,8 @@ function writePreferences2(prefs, scope, dataDirOverride2, cwd) {
 `, "utf-8");
 }
 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);
+  const dir = scope === "project" && cwd ? path9.join(cwd, PREFERENCES_PROJECT_DIR_NAME) : dataDirOverride2 ?? getDataDir();
+  const filePath = path9.join(dir, PREFERENCES_FILE_NAME);
   if (!fs5.existsSync(filePath)) {
     return;
   }
@@ -6125,7 +6473,7 @@ 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);
+  const filePath = path9.join(cwd, LAST_PROJECT_DIR_NAME, LAST_PROJECT_FILE_NAME);
   try {
     if (!fs5.existsSync(filePath)) {
       return null;
@@ -6141,9 +6489,9 @@ function readLastProject(cwd) {
   }
 }
 function writeLastProject(cwd, lastProject) {
-  const dir = path2.join(cwd, LAST_PROJECT_DIR_NAME);
+  const dir = path9.join(cwd, LAST_PROJECT_DIR_NAME);
   fs5.mkdirSync(dir, { recursive: true });
-  const filePath = path2.join(dir, LAST_PROJECT_FILE_NAME);
+  const filePath = path9.join(dir, LAST_PROJECT_FILE_NAME);
   const file = {
     version: LAST_PROJECT_VERSION,
     lastProject: { ...lastProject, savedAt: (/* @__PURE__ */ new Date()).toISOString() }
@@ -6152,7 +6500,7 @@ function writeLastProject(cwd, lastProject) {
 `, "utf-8");
 }
 function clearLastProject(cwd) {
-  const filePath = path2.join(cwd, LAST_PROJECT_DIR_NAME, LAST_PROJECT_FILE_NAME);
+  const filePath = path9.join(cwd, LAST_PROJECT_DIR_NAME, LAST_PROJECT_FILE_NAME);
   if (fs5.existsSync(filePath)) {
     fs5.unlinkSync(filePath);
   }
@@ -6161,7 +6509,7 @@ 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);
+  const filePath = path9.join(cwd, LAST_HOST_DIR_NAME, LAST_HOST_FILE_NAME);
   try {
     if (!fs5.existsSync(filePath)) {
       return null;
@@ -6177,9 +6525,9 @@ function readLastHost(cwd) {
   }
 }
 function writeLastHost(cwd, host) {
-  const dir = path2.join(cwd, LAST_HOST_DIR_NAME);
+  const dir = path9.join(cwd, LAST_HOST_DIR_NAME);
   fs5.mkdirSync(dir, { recursive: true });
-  const filePath = path2.join(dir, LAST_HOST_FILE_NAME);
+  const filePath = path9.join(dir, LAST_HOST_FILE_NAME);
   const file = {
     version: LAST_HOST_VERSION,
     lastHost: { host, savedAt: (/* @__PURE__ */ new Date()).toISOString() }
@@ -6188,7 +6536,7 @@ function writeLastHost(cwd, host) {
 `, "utf-8");
 }
 function clearLastHost(cwd) {
-  const filePath = path2.join(cwd, LAST_HOST_DIR_NAME, LAST_HOST_FILE_NAME);
+  const filePath = path9.join(cwd, LAST_HOST_DIR_NAME, LAST_HOST_FILE_NAME);
   if (fs5.existsSync(filePath)) {
     fs5.unlinkSync(filePath);
   }
@@ -6317,11 +6665,11 @@ var runResultGetTool = {
         `**Location:** \`${result.artifactsDir}\``,
         ""
       );
-      const actionScriptPath = path2.join(result.artifactsDir, "action-script.json");
-      const resultsMdPath = path2.join(result.artifactsDir, "results.md");
-      const screenshotsDir = path2.join(result.artifactsDir, "screenshots");
-      const stdoutLogPath = path2.join(result.artifactsDir, "stdout.log");
-      const stderrLogPath = path2.join(result.artifactsDir, "stderr.log");
+      const actionScriptPath = path9.join(result.artifactsDir, "action-script.json");
+      const resultsMdPath = path9.join(result.artifactsDir, "results.md");
+      const screenshotsDir = path9.join(result.artifactsDir, "screenshots");
+      const stdoutLogPath = path9.join(result.artifactsDir, "stdout.log");
+      const stderrLogPath = path9.join(result.artifactsDir, "stderr.log");
       const artifactItems = [];
       if (fs5.existsSync(actionScriptPath)) {
         artifactItems.push("- `action-script.json` \u2014 generated test steps");
@@ -6416,6 +6764,7 @@ var executeTestGenerationTool = {
       const result = await executeTestGeneration({
         testCase: input.testCase,
         localUrl: input.localUrl,
+        cwd: input.cwd,
         mutations: input.mutations,
         timeoutMs: input.timeoutMs,
         showUi,
@@ -6457,6 +6806,7 @@ var executeReplayTool = {
         testScript: input.testScript,
         actionScript: input.actionScript,
         localUrl: input.localUrl,
+        cwd: input.cwd,
         mutations: input.mutations,
         timeoutMs: input.timeoutMs,
         showUi,
@@ -7057,6 +7407,7 @@ __export(local_exports2, {
   TestScriptDetailsSchema: () => TestScriptDetailsSchema,
   TestScriptGetInputSchema: () => TestScriptGetInputSchema2,
   TestScriptListInputSchema: () => TestScriptListInputSchema2,
+  acquireLocalExecutionLock: () => acquireLocalExecutionLock,
   allLocalQaTools: () => allLocalQaTools,
   cancelExecution: () => cancelExecution,
   executeReplay: () => executeReplay,
@@ -7068,6 +7419,7 @@ __export(local_exports2, {
   getStorageService: () => getStorageService,
   getTool: () => getTool,
   listActiveExecutions: () => listActiveExecutions,
+  readLocalExecutionLockState: () => readLocalExecutionLockState,
   resetAuthService: () => resetAuthService,
   resetRunResultStorageService: () => resetRunResultStorageService,
   resetStorageService: () => resetStorageService