@muggleai/works 5.0.4 → 5.2.0

package/dist/{chunk-KDRSEHK5.js → chunk-3HSV6EXR.js}

@@ -1987,6 +1987,162 @@ function resetRunResultStorageService() {
   instance = null;
 }
 
+// packages/mcps/src/mcp/local/services/replay-url-rewrite.ts
+function rewriteActionScriptUrls(params) {
+  const { actionScript, originalUrl, localUrl } = params;
+  if (!originalUrl) {
+    return actionScript;
+  }
+  let originalHost;
+  let localOrigin;
+  try {
+    originalHost = new URL(originalUrl).hostname;
+    localOrigin = new URL(localUrl).origin;
+  } catch {
+    const serialized2 = JSON.stringify(actionScript);
+    const rewritten2 = serialized2.replace(new RegExp(escapeRegex(originalUrl), "g"), localUrl);
+    return JSON.parse(rewritten2);
+  }
+  const hostPattern = new RegExp(
+    `https?://(?:[a-z0-9-]+\\.)*${escapeRegex(originalHost)}(?=[/?#:"'\\\\]|$)`,
+    "gi"
+  );
+  const serialized = JSON.stringify(actionScript);
+  const rewritten = serialized.replace(hostPattern, localOrigin);
+  const result = JSON.parse(rewritten);
+  forceFirstNavigateUrl({ steps: result, localUrl });
+  return result;
+}
+function forceFirstNavigateUrl(params) {
+  for (const step of params.steps) {
+    if (!isPlainObject(step)) continue;
+    const operation = step["operation"];
+    if (!isPlainObject(operation)) continue;
+    if (operation["action"] !== "navigate") continue;
+    operation["url"] = params.localUrl;
+    return;
+  }
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// packages/mcps/src/mcp/local/services/action-script-builders.ts
+function getRequiredStringField(params) {
+  const value = params.source[params.fieldName];
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(
+      `Missing required field '${params.fieldName}' in ${params.sourceLabel}. Please pass the full object from the corresponding muggle-remote-* get tool.`
+    );
+  }
+  return value;
+}
+function buildGenerationActionScript(params) {
+  const testCaseRecord = params.testCase;
+  const projectId = getRequiredStringField({
+    source: testCaseRecord,
+    fieldName: "projectId",
+    sourceLabel: "testCase"
+  });
+  const useCaseId = getRequiredStringField({
+    source: testCaseRecord,
+    fieldName: "useCaseId",
+    sourceLabel: "testCase"
+  });
+  return {
+    actionScriptId: params.localTestScriptId,
+    actionScriptName: `Local Generation ${params.testCase.title}`,
+    actionType: "UserDefined",
+    actionParams: {
+      type: "Test Script Generation Workflow",
+      name: `Local Generation ${params.testCase.title}`,
+      ownerId: params.ownerUserId,
+      projectId,
+      useCaseId,
+      testCaseId: params.testCase.id,
+      testScriptId: params.localTestScriptId,
+      actionScriptId: params.localTestScriptId,
+      workflowRunId: params.runId,
+      url: params.localUrl,
+      // Tags the run as locally executed so the studio skips its own cloud
+      // ActionScript/TestScript write — the /local-run/upload path is the
+      // single writer for local runs (avoids duplicate Firestore docs).
+      executionSource: "local",
+      // Resolved server-side (a UUID get-or-created per project, 1-1 with
+      // projectId but NOT equal to it). The MCP has no client-side source for
+      // it, so leave it empty here; STM-on-local needs a backend resolver.
+      sharedTestMemoryId: "",
+      runEnvironmentType: "local"
+    },
+    goal: params.testCase.goal,
+    url: params.localUrl,
+    description: params.testCase.title,
+    precondition: params.testCase.precondition ?? "",
+    instructions: params.testCase.instructions ?? "",
+    expectedResult: params.testCase.expectedResult,
+    steps: [],
+    ownerId: params.ownerUserId,
+    createdAt: Date.now(),
+    isRemoteScript: false,
+    status: "active"
+  };
+}
+function buildReplayActionScript(params) {
+  const testScriptRecord = params.testScript;
+  const projectId = getRequiredStringField({
+    source: testScriptRecord,
+    fieldName: "projectId",
+    sourceLabel: "testScript"
+  });
+  const useCaseId = getRequiredStringField({
+    source: testScriptRecord,
+    fieldName: "useCaseId",
+    sourceLabel: "testScript"
+  });
+  const rewrittenActionScript = rewriteActionScriptUrls({
+    actionScript: params.actionScript,
+    originalUrl: params.testScript.url,
+    localUrl: params.localUrl
+  });
+  return {
+    actionScriptId: params.testScript.actionScriptId,
+    actionScriptName: params.testScript.name,
+    actionType: "UserDefined",
+    actionParams: {
+      type: "Test Script Replay Workflow",
+      name: params.testScript.name,
+      ownerId: params.ownerUserId,
+      projectId,
+      useCaseId,
+      testCaseId: params.testScript.testCaseId,
+      testScriptId: params.testScript.id,
+      workflowRunId: params.runId,
+      // Tags the run as locally executed so the studio skips its own cloud
+      // ActionScript write — replay's cloud record is owned by the upload path
+      // (avoids duplicate Firestore docs).
+      executionSource: "local",
+      // Resolved server-side (a UUID get-or-created per project, 1-1 with
+      // projectId but NOT equal to it). The MCP has no client-side source for
+      // it, so leave it empty here; STM-on-local needs a backend resolver.
+      sharedTestMemoryId: "",
+      runEnvironmentType: "local"
+    },
+    goal: params.testScript.name,
+    url: params.localUrl,
+    description: params.testScript.name,
+    precondition: "",
+    expectedResult: "Replay completes without critical failures.",
+    steps: rewrittenActionScript,
+    ownerId: params.ownerUserId,
+    createdAt: Date.now(),
+    isRemoteScript: true,
+    status: "active"
+  };
+}
+
 // packages/mcps/src/mcp/local/services/local-execution-lock-constants.ts
 var LOCK_FILE_NAME = "local-execution.lock";
 var MODIFY_LOCK_SUFFIX = ".modify";
@@ -2157,51 +2313,34 @@ async function readLocalExecutionLockState() {
   return readState();
 }
 
-// packages/mcps/src/mcp/local/services/replay-url-rewrite.ts
-function rewriteActionScriptUrls(params) {
-  const { actionScript, originalUrl, localUrl } = params;
-  if (!originalUrl) {
-    return actionScript;
+// packages/mcps/src/mcp/local/services/execution-service.ts
+var logger4 = getLogger();
+function extractStudioCloudRefs(studioReturnedResult) {
+  if (typeof studioReturnedResult !== "object" || studioReturnedResult === null) {
+    return {};
   }
-  let originalHost;
-  let localOrigin;
+  const source = studioReturnedResult;
+  const asString = (value) => typeof value === "string" && value.trim() !== "" ? value : void 0;
+  const refs = {};
+  const viewUrl = asString(source.viewUrl);
+  const cloudTestScriptId = asString(source.testScriptId);
+  const cloudActionScriptId = asString(source.actionScriptId);
+  if (viewUrl !== void 0) refs.viewUrl = viewUrl;
+  if (cloudTestScriptId !== void 0) refs.cloudTestScriptId = cloudTestScriptId;
+  if (cloudActionScriptId !== void 0) refs.cloudActionScriptId = cloudActionScriptId;
+  return refs;
+}
+async function readCloudRefsFile(inputFilePath) {
+  const cloudRefsPath = path9.join(
+    path9.dirname(inputFilePath),
+    `cloudrefs_${path9.basename(inputFilePath)}`
+  );
   try {
-    originalHost = new URL(originalUrl).hostname;
-    localOrigin = new URL(localUrl).origin;
+    return JSON.parse(await fs8.readFile(cloudRefsPath, "utf-8"));
   } catch {
-    const serialized2 = JSON.stringify(actionScript);
-    const rewritten2 = serialized2.replace(new RegExp(escapeRegex(originalUrl), "g"), localUrl);
-    return JSON.parse(rewritten2);
-  }
-  const hostPattern = new RegExp(
-    `https?://(?:[a-z0-9-]+\\.)*${escapeRegex(originalHost)}(?=[/?#:"'\\\\]|$)`,
-    "gi"
-  );
-  const serialized = JSON.stringify(actionScript);
-  const rewritten = serialized.replace(hostPattern, localOrigin);
-  const result = JSON.parse(rewritten);
-  forceFirstNavigateUrl({ steps: result, localUrl });
-  return result;
-}
-function forceFirstNavigateUrl(params) {
-  for (const step of params.steps) {
-    if (!isPlainObject(step)) continue;
-    const operation = step["operation"];
-    if (!isPlainObject(operation)) continue;
-    if (operation["action"] !== "navigate") continue;
-    operation["url"] = params.localUrl;
-    return;
+    return void 0;
   }
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-// packages/mcps/src/mcp/local/services/execution-service.ts
-var logger4 = getLogger();
 var activeProcesses = /* @__PURE__ */ new Map();
 function getAuthenticatedUserId() {
   const authService = getAuthService();
@@ -2414,101 +2553,6 @@ function getElectronAppPathOrThrow() {
   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];
-  if (typeof value !== "string" || value.trim() === "") {
-    throw new Error(
-      `Missing required field '${params.fieldName}' in ${params.sourceLabel}. Please pass the full object from the corresponding muggle-remote-* get tool.`
-    );
-  }
-  return value;
-}
-function buildGenerationActionScript(params) {
-  const testCaseRecord = params.testCase;
-  const projectId = getRequiredStringField({
-    source: testCaseRecord,
-    fieldName: "projectId",
-    sourceLabel: "testCase"
-  });
-  const useCaseId = getRequiredStringField({
-    source: testCaseRecord,
-    fieldName: "useCaseId",
-    sourceLabel: "testCase"
-  });
-  return {
-    actionScriptId: params.localTestScriptId,
-    actionScriptName: `Local Generation ${params.testCase.title}`,
-    actionType: "UserDefined",
-    actionParams: {
-      type: "Test Script Generation Workflow",
-      name: `Local Generation ${params.testCase.title}`,
-      ownerId: params.ownerUserId,
-      projectId,
-      useCaseId,
-      testCaseId: params.testCase.id,
-      testScriptId: params.localTestScriptId,
-      actionScriptId: params.localTestScriptId,
-      workflowRunId: params.runId,
-      url: params.localUrl,
-      sharedTestMemoryId: ""
-    },
-    goal: params.testCase.goal,
-    url: params.localUrl,
-    description: params.testCase.title,
-    precondition: params.testCase.precondition ?? "",
-    instructions: params.testCase.instructions ?? "",
-    expectedResult: params.testCase.expectedResult,
-    steps: [],
-    ownerId: params.ownerUserId,
-    createdAt: Date.now(),
-    isRemoteScript: false,
-    status: "active"
-  };
-}
-function buildReplayActionScript(params) {
-  const testScriptRecord = params.testScript;
-  const projectId = getRequiredStringField({
-    source: testScriptRecord,
-    fieldName: "projectId",
-    sourceLabel: "testScript"
-  });
-  const useCaseId = getRequiredStringField({
-    source: testScriptRecord,
-    fieldName: "useCaseId",
-    sourceLabel: "testScript"
-  });
-  const rewrittenActionScript = rewriteActionScriptUrls({
-    actionScript: params.actionScript,
-    originalUrl: params.testScript.url,
-    localUrl: params.localUrl
-  });
-  return {
-    actionScriptId: params.testScript.actionScriptId,
-    actionScriptName: params.testScript.name,
-    actionType: "UserDefined",
-    actionParams: {
-      type: "Test Script Replay Workflow",
-      name: params.testScript.name,
-      ownerId: params.ownerUserId,
-      projectId,
-      useCaseId,
-      testCaseId: params.testScript.testCaseId,
-      testScriptId: params.testScript.id,
-      workflowRunId: params.runId,
-      sharedTestMemoryId: ""
-    },
-    goal: params.testScript.name,
-    url: params.localUrl,
-    description: params.testScript.name,
-    precondition: "",
-    expectedResult: "Replay completes without critical failures.",
-    steps: rewrittenActionScript,
-    ownerId: params.ownerUserId,
-    createdAt: Date.now(),
-    isRemoteScript: true,
-    status: "active"
-  };
-}
 async function executeElectronAppAsync(params) {
   const mode = params.runType === "generation" ? "explore" : "engine";
   const electronAppPath = getElectronAppPathOrThrow();
@@ -2709,18 +2753,24 @@ ${executionResult.stderr}`;
           path9.dirname(inputFilePath),
           `gen_${path9.basename(inputFilePath)}`
         );
+        let failedStudioResult;
         try {
+          const failedScriptRaw = await fs8.readFile(generatedScriptPath2, "utf-8");
+          failedStudioResult = JSON.parse(failedScriptRaw);
           await fs8.copyFile(generatedScriptPath2, path9.join(artifactsDir2, "action-script.json"));
           await fs8.unlink(generatedScriptPath2).catch(() => {
           });
         } catch {
         }
+        const failedStudioCloudRefs = extractStudioCloudRefs(await readCloudRefsFile(inputFilePath));
         storage.updateRunResult(runId, {
           status: "failed",
           testScriptId: localTestScript.id,
           executionTimeMs,
           errorMessage: failureMessage,
           artifactsDir: artifactsDir2,
+          studioReturnedResult: failedStudioResult,
+          ...failedStudioCloudRefs,
           localExecutionContext: {
             ...localExecutionContextBase,
             localExecutionCompletedAt: completedAt
@@ -2759,11 +2809,14 @@ ${executionResult.stderr}`;
         runId,
         generatedScriptPath
       });
+      const studioCloudRefs = extractStudioCloudRefs(await readCloudRefsFile(inputFilePath));
       storage.updateRunResult(runId, {
         status: "passed",
         testScriptId: localTestScript.id,
         executionTimeMs,
         artifactsDir,
+        studioReturnedResult: generatedScript,
+        ...studioCloudRefs,
         localExecutionContext: {
           ...localExecutionContextBase,
           localExecutionCompletedAt: completedAt
@@ -2900,10 +2953,14 @@ ${executionResult.stderr}`;
         };
       }
       const artifactsDir = path9.join(getStorageService().getSessionsDir(), runId);
+      const replayStudioResult = await readCloudRefsFile(inputFilePath);
+      const replayStudioCloudRefs = extractStudioCloudRefs(replayStudioResult);
       storage.updateRunResult(runId, {
         status: "passed",
         executionTimeMs,
         artifactsDir,
+        studioReturnedResult: replayStudioResult,
+        ...replayStudioCloudRefs,
         localExecutionContext: {
           ...localExecutionContextBase,
           localExecutionCompletedAt: completedAt
@@ -6152,10 +6209,6 @@ var TestScriptListInputSchema2 = z.object({
 var TestScriptGetInputSchema2 = z.object({
   testScriptId: MuggleEntityIdSchema.describe("Local stored test script ID (UUID) to retrieve")
 });
-var PublishTestScriptInputSchema = z.object({
-  runId: MuggleEntityIdSchema.describe("Local run result ID (UUID) from muggle_execute_test_generation"),
-  cloudTestCaseId: MuggleEntityIdSchema.describe("Cloud test case ID (UUID) to publish the script under")
-});
 var ListSessionsInputSchema = z.object({
   limit: z.number().int().positive().optional().describe("Maximum number of sessions to return. Defaults to 10.")
 });
@@ -6172,7 +6225,6 @@ var PreferenceKey = /* @__PURE__ */ ((PreferenceKey2) => {
   PreferenceKey2["ShowElectronBrowser"] = "showElectronBrowser";
   PreferenceKey2["OpenTestResultsAfterRun"] = "openTestResultsAfterRun";
   PreferenceKey2["DefaultExecutionMode"] = "defaultExecutionMode";
-  PreferenceKey2["AutoPublishLocalResults"] = "autoPublishLocalResults";
   PreferenceKey2["SuggestRelatedUseCases"] = "suggestRelatedUseCases";
   PreferenceKey2["SuggestRelatedTestCases"] = "suggestRelatedTestCases";
   PreferenceKey2["AutoDetectChanges"] = "autoDetectChanges";
@@ -6184,6 +6236,11 @@ var PreferenceKey = /* @__PURE__ */ ((PreferenceKey2) => {
   PreferenceKey2["AutoRebase"] = "autoRebase";
   PreferenceKey2["AutoCleanup"] = "autoCleanup";
   PreferenceKey2["AutoE2ETest"] = "autoE2ETest";
+  PreferenceKey2["AutoResolveConflicts"] = "autoResolveConflicts";
+  PreferenceKey2["AutoReuseValidationContext"] = "autoReuseValidationContext";
+  PreferenceKey2["AutoRouteBuildToMuggleDo"] = "autoRouteBuildToMuggleDo";
+  PreferenceKey2["AutoWatchPR"] = "autoWatchPR";
+  PreferenceKey2["ReusePreparePlan"] = "reusePreparePlan";
   return PreferenceKey2;
 })(PreferenceKey || {});
 var PreferenceValue = /* @__PURE__ */ ((PreferenceValue2) => {
@@ -6200,24 +6257,28 @@ var PREFERENCES_FILE_NAME = "preferences.json";
 var PREFERENCES_PROJECT_DIR_NAME = ".muggle-ai";
 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 */,
-  ["autoPublishLocalResults" /* AutoPublishLocalResults */]: "ask" /* Ask */,
-  ["suggestRelatedUseCases" /* SuggestRelatedUseCases */]: "ask" /* Ask */,
-  ["suggestRelatedTestCases" /* SuggestRelatedTestCases */]: "ask" /* Ask */,
-  ["autoDetectChanges" /* AutoDetectChanges */]: "ask" /* Ask */,
-  ["postPRVisualWalkthrough" /* PostPRVisualWalkthrough */]: "ask" /* Ask */,
-  ["autoCreatePR" /* AutoCreatePR */]: "ask" /* Ask */,
-  ["checkForUpdates" /* CheckForUpdates */]: "ask" /* Ask */,
-  ["verboseOutput" /* VerboseOutput */]: "ask" /* Ask */,
-  ["autoUseWorktree" /* AutoUseWorktree */]: "ask" /* Ask */,
-  ["autoRebase" /* AutoRebase */]: "ask" /* Ask */,
-  ["autoCleanup" /* AutoCleanup */]: "ask" /* Ask */,
-  ["autoE2ETest" /* AutoE2ETest */]: "always" /* Always */
+  ["autoLogin" /* AutoLogin */]: "always" /* Always */,
+  ["autoSelectProject" /* AutoSelectProject */]: "always" /* Always */,
+  ["autoSelectLocalHost" /* AutoSelectLocalHost */]: "always" /* Always */,
+  ["showElectronBrowser" /* ShowElectronBrowser */]: "always" /* Always */,
+  ["openTestResultsAfterRun" /* OpenTestResultsAfterRun */]: "always" /* Always */,
+  ["defaultExecutionMode" /* DefaultExecutionMode */]: "local" /* Local */,
+  ["suggestRelatedUseCases" /* SuggestRelatedUseCases */]: "always" /* Always */,
+  ["suggestRelatedTestCases" /* SuggestRelatedTestCases */]: "always" /* Always */,
+  ["autoDetectChanges" /* AutoDetectChanges */]: "always" /* Always */,
+  ["postPRVisualWalkthrough" /* PostPRVisualWalkthrough */]: "always" /* Always */,
+  ["autoCreatePR" /* AutoCreatePR */]: "always" /* Always */,
+  ["checkForUpdates" /* CheckForUpdates */]: "always" /* Always */,
+  ["verboseOutput" /* VerboseOutput */]: "never" /* Never */,
+  ["autoUseWorktree" /* AutoUseWorktree */]: "always" /* Always */,
+  ["autoRebase" /* AutoRebase */]: "always" /* Always */,
+  ["autoCleanup" /* AutoCleanup */]: "always" /* Always */,
+  ["autoE2ETest" /* AutoE2ETest */]: "always" /* Always */,
+  ["autoResolveConflicts" /* AutoResolveConflicts */]: "always" /* Always */,
+  ["autoReuseValidationContext" /* AutoReuseValidationContext */]: "always" /* Always */,
+  ["autoRouteBuildToMuggleDo" /* AutoRouteBuildToMuggleDo */]: "always" /* Always */,
+  ["autoWatchPR" /* AutoWatchPR */]: "always" /* Always */,
+  ["reusePreparePlan" /* ReusePreparePlan */]: "always" /* Always */
 };
 var ALWAYS_ASK_NEVER = [
   "always" /* Always */,
@@ -6240,7 +6301,6 @@ var PREFERENCE_ALLOWED_VALUES = {
   ["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,
@@ -6251,7 +6311,12 @@ var PREFERENCE_ALLOWED_VALUES = {
   ["autoUseWorktree" /* AutoUseWorktree */]: ALWAYS_ASK_NEVER,
   ["autoRebase" /* AutoRebase */]: ALWAYS_ASK_NEVER,
   ["autoCleanup" /* AutoCleanup */]: ALWAYS_ASK_NEVER,
-  ["autoE2ETest" /* AutoE2ETest */]: ALWAYS_ASK
+  ["autoE2ETest" /* AutoE2ETest */]: ALWAYS_ASK,
+  ["autoResolveConflicts" /* AutoResolveConflicts */]: ALWAYS_ASK_NEVER,
+  ["autoReuseValidationContext" /* AutoReuseValidationContext */]: ALWAYS_ASK_NEVER,
+  ["autoRouteBuildToMuggleDo" /* AutoRouteBuildToMuggleDo */]: ALWAYS_ASK_NEVER,
+  ["autoWatchPR" /* AutoWatchPR */]: ALWAYS_ASK_NEVER,
+  ["reusePreparePlan" /* ReusePreparePlan */]: ALWAYS_ASK_NEVER
 };
 var PREFERENCES_SCHEMA = {
   ["autoLogin" /* AutoLogin */]: {
@@ -6272,9 +6337,6 @@ var PREFERENCES_SCHEMA = {
   ["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 Test cloud for team visibility"
-  },
   ["suggestRelatedUseCases" /* SuggestRelatedUseCases */]: {
     description: "After creating or running a use case, suggest related use cases to add"
   },
@@ -6307,6 +6369,21 @@ var PREFERENCES_SCHEMA = {
   },
   ["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)"
+  },
+  ["autoResolveConflicts" /* AutoResolveConflicts */]: {
+    description: "When a rebase onto the default branch hits conflicts, resolve them autonomously behind a verify-or-rollback gate instead of aborting and escalating"
+  },
+  ["autoReuseValidationContext" /* AutoReuseValidationContext */]: {
+    description: "When a prior session left an E2E validation context for this working tree, reuse it instead of re-asking the validation questions"
+  },
+  ["autoRouteBuildToMuggleDo" /* AutoRouteBuildToMuggleDo */]: {
+    description: "When a prompt looks like a build/implement/fix request, route it through the /muggle-do pipeline (requirements \u2192 build \u2192 impact \u2192 tests \u2192 E2E \u2192 PR \u2192 watcher)"
+  },
+  ["autoWatchPR" /* AutoWatchPR */]: {
+    description: "After a test run opens a PR, start a muggle-pr-followup watcher that polls for new reviews and hands them to /muggle-do"
+  },
+  ["reusePreparePlan" /* ReusePreparePlan */]: {
+    description: "Reuse the saved prepare plan for this stack (skip discovery, jump to check-running + smoke-test) instead of rediscovering from scratch"
   }
 };
 
@@ -6659,7 +6736,11 @@ var runResultGetTool = {
       `**Status:** ${result.status}`,
       `**Cloud Test Case:** ${result.cloudTestCaseId}`,
       `**Duration:** ${result.executionTimeMs ?? 0}ms`,
-      result.errorMessage ? `**Error:** ${result.errorMessage}` : ""
+      result.errorMessage ? `**Error:** ${result.errorMessage}` : "",
+      // The studio publishes the run during execution; these are its returned cloud refs.
+      result.viewUrl ? `**View URL:** ${result.viewUrl}` : "",
+      result.cloudTestScriptId ? `**Cloud Test Script ID:** ${result.cloudTestScriptId}` : "",
+      result.cloudActionScriptId ? `**Cloud Action Script ID:** ${result.cloudActionScriptId}` : ""
     ];
     let testScriptSteps;
     if (result.testScriptId) {
@@ -6858,148 +6939,6 @@ var cancelExecutionTool = {
     return { content: `No active execution found with ID: ${input.runId}`, isError: true };
   }
 };
-var publishTestScriptTool = {
-  name: "muggle-local-publish-test-script",
-  description: "Publish a locally generated test script to the cloud. Uses the run ID from muggle_execute_test_generation to find the script and uploads it to the specified cloud test case. Returns a viewUrl that can be opened in the user's browser to view the published test script on the dashboard.",
-  inputSchema: PublishTestScriptInputSchema,
-  execute: async (ctx) => {
-    const logger6 = createChildLogger2(ctx.correlationId);
-    logger6.info("Executing muggle-local-publish-test-script");
-    const input = PublishTestScriptInputSchema.parse(ctx.input);
-    const storage = getRunResultStorageService();
-    const runResult = storage.getRunResult(input.runId);
-    if (!runResult) {
-      return { content: `Run result not found: ${input.runId}`, isError: true };
-    }
-    if (!runResult.testScriptId) {
-      return { content: `Run result ${input.runId} does not have an associated test script`, isError: true };
-    }
-    const testScript = storage.getTestScript(runResult.testScriptId);
-    if (!testScript) {
-      return { content: `Test script not found: ${runResult.testScriptId}`, isError: true };
-    }
-    if (runResult.runType !== "generation") {
-      return {
-        content: `Only generation runs can be published. Run ${input.runId} is '${runResult.runType}'.`,
-        isError: true
-      };
-    }
-    if (runResult.status !== "passed" && runResult.status !== "failed") {
-      return {
-        content: `Run ${input.runId} must be in passed/failed state before publishing. Current status: ${runResult.status}.`,
-        isError: true
-      };
-    }
-    if (!Array.isArray(testScript.actionScript) || testScript.actionScript.length === 0) {
-      return {
-        content: `Test script ${testScript.id} has no generated actionScript steps to publish.`,
-        isError: true
-      };
-    }
-    if (!runResult.projectId) {
-      return { content: `Run result ${input.runId} is missing projectId.`, isError: true };
-    }
-    if (!runResult.useCaseId) {
-      return { content: `Run result ${input.runId} is missing useCaseId.`, isError: true };
-    }
-    if (!runResult.productionUrl) {
-      return { content: `Run result ${input.runId} is missing productionUrl.`, isError: true };
-    }
-    if (!runResult.executionTimeMs && runResult.executionTimeMs !== 0) {
-      return { content: `Run result ${input.runId} is missing executionTimeMs.`, isError: true };
-    }
-    if (!runResult.localExecutionContext) {
-      return { content: `Run result ${input.runId} is missing localExecutionContext.`, isError: true };
-    }
-    if (!runResult.localExecutionContext.localExecutionCompletedAt) {
-      return {
-        content: `Run result ${input.runId} is missing localExecutionCompletedAt in localExecutionContext.`,
-        isError: true
-      };
-    }
-    const authStatus = getAuthService().getAuthStatus();
-    if (!authStatus.userId) {
-      return { content: "Authenticated user ID is missing. Please login again.", isError: true };
-    }
-    try {
-      const credentials = await getCallerCredentialsAsync();
-      const client = getPromptServiceClient();
-      const uploadedAt = Date.now();
-      const response = await client.execute(
-        {
-          method: "POST",
-          path: "/v1/protected/muggle-test/local-run/upload",
-          body: {
-            projectId: runResult.projectId,
-            useCaseId: runResult.useCaseId,
-            testCaseId: input.cloudTestCaseId,
-            runType: runResult.runType,
-            // A published run always originates from local Electron execution, so it
-            // belongs to the local lane — the cloud must resolve the developer's
-            // localhost credentials, not the remote managed-profile pool.
-            runEnvironmentType: "local" /* Local */,
-            productionUrl: runResult.productionUrl,
-            localExecutionContext: {
-              originalUrl: runResult.localExecutionContext.originalUrl,
-              productionUrl: runResult.localExecutionContext.productionUrl,
-              runByUserId: authStatus.userId,
-              machineHostname: runResult.localExecutionContext.machineHostname,
-              osInfo: runResult.localExecutionContext.osInfo,
-              electronAppVersion: runResult.localExecutionContext.electronAppVersion,
-              mcpServerVersion: runResult.localExecutionContext.mcpServerVersion,
-              localExecutionCompletedAt: runResult.localExecutionContext.localExecutionCompletedAt,
-              uploadedAt
-            },
-            actionScript: testScript.actionScript,
-            summaryStep: testScript.summaryStep,
-            status: runResult.status === "passed" ? "passed" : "failed",
-            executionTimeMs: runResult.executionTimeMs,
-            errorMessage: runResult.errorMessage
-          }
-        },
-        credentials,
-        ctx.correlationId
-      );
-      storage.updateTestScript(testScript.id, {
-        status: "published",
-        cloudActionScriptId: response.data.actionScriptId
-      });
-      storage.updateRunResult(runResult.id, {
-        localExecutionContext: {
-          ...runResult.localExecutionContext,
-          runByUserId: authStatus.userId
-        }
-      });
-      return {
-        content: [
-          "## Test Script Published",
-          "",
-          `**Run ID:** ${input.runId}`,
-          `**Local Test Script ID:** ${testScript.id}`,
-          `**Cloud Test Case ID:** ${input.cloudTestCaseId}`,
-          `**Cloud Test Script ID:** ${response.data.testScriptId}`,
-          `**Cloud Action Script ID:** ${response.data.actionScriptId}`,
-          `**Workflow Runtime ID:** ${response.data.workflowRuntimeId}`,
-          `**Workflow Run ID:** ${response.data.workflowRunId}`,
-          `**View URL:** ${response.data.viewUrl}`
-        ].join("\n"),
-        isError: false,
-        data: response.data
-      };
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger6.error("Failed to publish local test script to cloud", {
-        runId: input.runId,
-        cloudTestCaseId: input.cloudTestCaseId,
-        error: errorMessage
-      });
-      return {
-        content: `Failed to publish test script: ${errorMessage}`,
-        isError: true
-      };
-    }
-  }
-};
 var preferencesSetTool = {
   name: "muggle-local-preferences-set",
   description: "Set a Muggle AI user preference. Preferences control automation behavior (auto-login, show browser, suggest test cases, etc.). Values: 'always' (proceed without asking), 'ask' (prompt each time), 'never' (skip without asking). Scope: 'global' writes to ~/.muggle-ai/preferences.json, 'project' writes to .muggle-ai/preferences.json in the repo root.",
@@ -7194,8 +7133,6 @@ var allLocalQaTools = [
   executeTestGenerationTool,
   executeReplayTool,
   cancelExecutionTool,
-  // Publishing tools
-  publishTestScriptTool,
   // Preferences tools
   preferencesSetTool,
   // Last-project cache tools (per-repo "last used Muggle Test project")
@@ -7412,7 +7349,6 @@ __export(local_exports2, {
   LocalWorkflowRunStatus: () => LocalWorkflowRunStatus,
   MuggleEntityIdSchema: () => MuggleEntityIdSchema,
   PreferencesSetInputSchema: () => PreferencesSetInputSchema,
-  PublishTestScriptInputSchema: () => PublishTestScriptInputSchema,
   RunResultGetInputSchema: () => RunResultGetInputSchema,
   RunResultListInputSchema: () => RunResultListInputSchema,
   RunResultStorageService: () => RunResultStorageService,