@muggleai/works 4.3.0 → 4.5.0

package/dist/{chunk-23NOSJFH.js → chunk-MNCBJEPQ.js}

@@ -1,9 +1,9 @@
 import * as fs3 from 'fs';
-import { readFileSync, existsSync, rmSync, mkdirSync, readdirSync, createWriteStream, writeFileSync, statSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync, writeFileSync, rmSync, readdirSync, createWriteStream, statSync } from 'fs';
 import * as os3 from 'os';
 import { platform, arch, homedir } from 'os';
 import * as path2 from 'path';
-import { dirname, resolve, join } from 'path';
+import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import winston from 'winston';
 import axios, { AxiosError } from 'axios';
@@ -34,6 +34,49 @@ var DATA_DIR_NAME = ".muggle-ai";
 function getDataDir() {
   return path2.join(os3.homedir(), DATA_DIR_NAME);
 }
+var DEV_MANIFEST = {
+  release: "dev",
+  buildId: "dev",
+  commitSha: "dev",
+  buildTime: "1970-01-01T00:00:00Z",
+  serviceName: "muggle-ai-works-mcp"
+};
+var MANIFEST_PATH = (() => {
+  try {
+    return join(dirname(fileURLToPath(import.meta.url)), "release-manifest.json");
+  } catch {
+    return "release-manifest.json";
+  }
+})();
+var cachedManifest;
+function isValidManifest(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 readReleaseManifest() {
+  if (cachedManifest !== void 0) return cachedManifest;
+  try {
+    const raw = readFileSync(MANIFEST_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isValidManifest(parsed)) {
+      cachedManifest = DEV_MANIFEST;
+      return cachedManifest;
+    }
+    cachedManifest = parsed;
+    return cachedManifest;
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT") {
+      console.warn(
+        "release_manifest: unexpected error reading manifest, using DEV fallback",
+        { error: err.message }
+      );
+    }
+    cachedManifest = DEV_MANIFEST;
+    return cachedManifest;
+  }
+}
 
 // packages/mcps/src/shared/config.ts
 var DEFAULT_PROMPT_SERVICE_PRODUCTION_URL = "https://promptservice.muggle-ai.com";
@@ -303,9 +346,10 @@ function getConfig() {
   if (configInstance) {
     return configInstance;
   }
+  const manifest = readReleaseManifest();
   configInstance = {
     serverName: "muggle",
-    serverVersion: "1.0.0",
+    serverVersion: manifest.release,
     logLevel: process.env.LOG_LEVEL ?? "info",
     auth0: buildAuth0Config(),
     e2e: buildE2eConfig(),
@@ -425,6 +469,14 @@ __export(e2e_exports2, {
   ApiKeyRevokeInputSchema: () => ApiKeyRevokeInputSchema,
   AuthLoginInputSchema: () => AuthLoginInputSchema,
   AuthPollInputSchema: () => AuthPollInputSchema,
+  BulkPreviewJobCancelInputSchema: () => BulkPreviewJobCancelInputSchema,
+  BulkPreviewJobGetInputSchema: () => BulkPreviewJobGetInputSchema,
+  BulkPreviewJobKindSchema: () => BulkPreviewJobKindSchema,
+  BulkPreviewJobListInputSchema: () => BulkPreviewJobListInputSchema,
+  BulkPreviewJobStatusSchema: () => BulkPreviewJobStatusSchema,
+  BulkPreviewPromptSchema: () => BulkPreviewPromptSchema,
+  BulkPreviewSubmitTestCaseInputSchema: () => BulkPreviewSubmitTestCaseInputSchema,
+  BulkPreviewSubmitUseCaseInputSchema: () => BulkPreviewSubmitUseCaseInputSchema,
   EmptyInputSchema: () => EmptyInputSchema,
   GatewayError: () => GatewayError,
   IdSchema: () => IdSchema,
@@ -467,11 +519,11 @@ __export(e2e_exports2, {
   TestCaseListInputSchema: () => TestCaseListInputSchema,
   TestScriptGetInputSchema: () => TestScriptGetInputSchema,
   TestScriptListInputSchema: () => TestScriptListInputSchema,
-  TestScriptListPaginatedInputSchema: () => TestScriptListPaginatedInputSchema,
   TokenPackageIdSchema: () => TokenPackageIdSchema,
   TokenUsageFilterTypeSchema: () => TokenUsageFilterTypeSchema,
   UseCaseCandidatesApproveInputSchema: () => UseCaseCandidatesApproveInputSchema,
   UseCaseCreateFromPromptsInputSchema: () => UseCaseCreateFromPromptsInputSchema,
+  UseCaseCreateInputSchema: () => UseCaseCreateInputSchema,
   UseCaseDiscoveryMemoryGetInputSchema: () => UseCaseDiscoveryMemoryGetInputSchema,
   UseCaseGetInputSchema: () => UseCaseGetInputSchema,
   UseCaseListInputSchema: () => UseCaseListInputSchema,
@@ -2837,7 +2889,7 @@ var LocalExecutionContextInputSchema = z.object({
   electronAppVersion: z.string().optional().describe("Electron app version used for local run"),
   mcpServerVersion: z.string().optional().describe("MCP server version used for local run"),
   localExecutionCompletedAt: z.number().int().positive().describe("Epoch milliseconds when local run completed"),
-  uploadedAt: z.number().int().positive().optional().describe("Epoch milliseconds when uploaded to cloud")
+  uploadedAt: z.number().int().positive().describe("Epoch milliseconds when uploaded to cloud")
 });
 var LocalRunUploadInputSchema = z.object({
   projectId: MuggleEntityIdSchema.describe("Project ID (UUID) for the local run"),
@@ -2854,8 +2906,10 @@ var LocalRunUploadInputSchema = z.object({
 
 // packages/mcps/src/mcp/e2e/contracts/index.ts
 var PaginationInputSchema = z.object({
-  page: z.number().int().positive().optional().describe("Page number (1-based)"),
-  pageSize: z.number().int().positive().max(100).optional().describe("Number of items per page")
+  page: z.number().int().positive().default(1).describe("Page number, 1-based. Defaults to 1 (the first page)."),
+  pageSize: z.number().int().positive().max(100).default(10).describe("Number of items per page. Defaults to 10, max 100."),
+  sortBy: z.enum(["createdAt", "updatedAt"]).default("createdAt").describe("Field to sort by. Defaults to createdAt (stable under concurrent writes)."),
+  sortOrder: z.enum(["asc", "desc"]).default("desc").describe("Sort direction. Defaults to desc (newest first).")
 });
 var IdSchema = MuggleEntityIdSchema;
 var RunBatchIdSchema = MuggleEntityIdSchema.describe("Bulk replay run batch ID (UUID)");
@@ -2961,15 +3015,67 @@ var UseCasePromptPreviewInputSchema = z.object({
 });
 var UseCaseCreateFromPromptsInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to create use cases for"),
-  prompts: z.array(z.object({
-    instruction: z.string().min(1).describe("Natural language instruction describing the use case")
-  })).min(1).describe("Array of prompts to generate use cases from")
+  instructions: z.array(z.string().min(1)).min(1).describe('Natural-language instructions \u2014 one use case is generated per string (e.g., ["As a user, I can log in"])')
 });
 var UseCaseUpdateFromPromptInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID)"),
   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 UseCaseCreateInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) the use case belongs to"),
+  title: z.string().min(1).describe("Use case title"),
+  description: z.string().min(1).describe("Description of the use case, including actor and preconditions"),
+  userStory: z.string().min(1).describe("One-line user story from the end-user point of view"),
+  url: z.string().url().optional().describe("URL where the use case takes place (defaults to project 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")
+  })).describe("Main/alternative/error flows broken down as requirement + acceptance criteria pairs"),
+  status: z.enum(["DRAFT", "IN_REVIEW", "APPROVED", "IMPLEMENTED", "ARCHIVED"]).describe("Use case status"),
+  priority: z.enum(["LOW", "MEDIUM", "HIGH", "CRITICAL"]).describe("Use case priority"),
+  source: z.enum(["PRD_FILE", "SITEMAP", "CRAWLER", "PROMPT", "MANUAL"]).describe("How this use case was produced"),
+  category: z.string().optional().describe("Optional category")
+});
+var BulkPreviewPromptSchema = z.object({
+  clientRef: z.string().max(128).optional().describe("Optional caller-supplied reference echoed back on results"),
+  instruction: z.string().min(1).max(4e3).describe("Natural language instruction (max 4000 chars)")
+});
+var BulkPreviewSubmitUseCaseInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) the use cases belong to"),
+  prompts: z.array(BulkPreviewPromptSchema).min(1).max(100).describe("Prompts to generate use cases from (max 100 per request)")
+});
+var BulkPreviewSubmitTestCaseInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  useCaseId: IdSchema.describe("Parent use case ID (UUID) the test cases will belong to"),
+  prompts: z.array(BulkPreviewPromptSchema).min(1).max(100).describe("Prompts to generate test cases from (max 100 per request)")
+});
+var BulkPreviewJobStatusSchema = z.enum([
+  "queued",
+  "submitted",
+  "running",
+  "succeeded",
+  "partial",
+  "failed",
+  "cancelled",
+  "expired"
+]);
+var BulkPreviewJobKindSchema = z.enum(["useCase", "testCase"]);
+var BulkPreviewJobGetInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  jobId: IdSchema.describe("Bulk-preview job ID (UUID)")
+});
+var BulkPreviewJobCancelInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID)"),
+  jobId: IdSchema.describe("Bulk-preview job ID (UUID) to cancel")
+});
+var BulkPreviewJobListInputSchema = z.object({
+  projectId: IdSchema.describe("Project ID (UUID) to list bulk-preview jobs for"),
+  status: z.array(BulkPreviewJobStatusSchema).optional().describe("Optional filter \u2014 only return jobs matching any of these statuses"),
+  kind: BulkPreviewJobKindSchema.optional().describe("Optional filter \u2014 only return jobs of this kind"),
+  limit: z.number().int().min(1).max(100).optional().describe("Max jobs to return (default 20, max 100)"),
+  cursor: z.string().optional().describe("Pagination cursor returned by a previous call")
+});
 var TestCaseListInputSchema = z.object({
   projectId: IdSchema.describe("Project ID (UUID) to list test cases for")
 }).merge(PaginationInputSchema);
@@ -3006,9 +3112,6 @@ var TestScriptListInputSchema = z.object({
 var TestScriptGetInputSchema = z.object({
   testScriptId: IdSchema.describe("Test script ID (UUID) to retrieve")
 });
-var TestScriptListPaginatedInputSchema = z.object({
-  projectId: IdSchema.describe("Project ID (UUID) to list test scripts for")
-}).merge(PaginationInputSchema);
 var ActionScriptGetInputSchema = z.object({
   actionScriptId: IdSchema.describe("Action script ID (UUID) to retrieve")
 });
@@ -3180,6 +3283,61 @@ var GatewayError = class extends Error {
     this.details = params.details;
   }
 };
+
+// packages/mcps/src/shared/host_detection.ts
+function detectMcpHost(env = process.env) {
+  if (env.CLAUDE_CODE || env.CLAUDECODE || env.CLAUDE_CODE_SSE_PORT) {
+    return "claude-code";
+  }
+  if (env.CURSOR_TRACE_ID || env.CURSOR_MCP) {
+    return "cursor";
+  }
+  if (env.CODEX || env.OPENAI_CODEX) {
+    return "codex";
+  }
+  if (env.WINDSURF_MCP || env.WINDSURF || env.CODEIUM_API_KEY) {
+    return "windsurf";
+  }
+  return "unknown";
+}
+var INSTALL_ID_FILENAME = "install-id.json";
+var cachedInstallId;
+function installIdFilePath() {
+  return join(getDataDir(), 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;
+  }
+}
+
+// packages/mcps/src/mcp/e2e/upstream-client.ts
 var ALLOWED_UPSTREAM_PREFIXES = [
   "/v1/protected/muggle-test/",
   "/v1/protected/wallet/",
@@ -3226,8 +3384,17 @@ var PromptServiceClient = class {
    * @returns Headers object.
    */
   buildHeaders(credentials, correlationId) {
+    const manifest = readReleaseManifest();
+    const installId = getInstallId();
+    const host = detectMcpHost();
     const headers = {
-      "X-Correlation-Id": correlationId
+      "X-Correlation-Id": correlationId,
+      "X-Client-Service-Name": manifest.serviceName,
+      "X-Client-Release": manifest.release,
+      "X-Client-Build-Id": manifest.buildId,
+      "X-Client-Commit-Sha": manifest.commitSha,
+      "X-Client-Install-Id": installId,
+      "X-Client-Host": host
     };
     if (credentials.bearerToken) {
       headers["Authorization"] = credentials.bearerToken.startsWith("Bearer ") ? credentials.bearerToken : `Bearer ${credentials.bearerToken}`;
@@ -3476,14 +3643,19 @@ var projectTools = [
   },
   {
     name: "muggle-remote-project-list",
-    description: "List all projects accessible to the authenticated user.",
+    description: "List projects accessible to the authenticated user. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
     inputSchema: ProjectListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/projects`,
-        queryParams: { page: data.page, pageSize: data.pageSize }
+        queryParams: {
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
@@ -3528,14 +3700,20 @@ var useCaseTools = [
   },
   {
     name: "muggle-remote-use-case-list",
-    description: "List all use cases for a project.",
+    description: "List use cases for a project. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
     inputSchema: UseCaseListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/use-cases`,
-        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+        queryParams: {
+          projectId: data.projectId,
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
@@ -3573,7 +3751,10 @@ var useCaseTools = [
       return {
         method: "POST",
         path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/prompts/bulk`,
-        body: { projectId: data.projectId, prompts: data.prompts }
+        body: {
+          projectId: data.projectId,
+          prompts: data.instructions.map((instruction) => ({ instruction }))
+        }
       };
     }
   },
@@ -3589,19 +3770,62 @@ var useCaseTools = [
         body: { instruction: data.instruction }
       };
     }
+  },
+  {
+    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.",
+    inputSchema: UseCaseCreateInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/use-cases`,
+        body: {
+          projectId: data.projectId,
+          title: data.title,
+          description: data.description,
+          userStory: data.userStory,
+          url: data.url,
+          useCaseBreakdown: data.useCaseBreakdown,
+          status: data.status,
+          priority: data.priority,
+          source: data.source,
+          category: data.category
+        }
+      };
+    }
+  },
+  {
+    name: "muggle-remote-use-case-bulk-preview-submit",
+    description: "Submit an async bulk-preview job that uses the OpenAI Batch API to generate use cases 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-use-case-create.",
+    inputSchema: BulkPreviewSubmitUseCaseInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/prompts/bulk-preview`,
+        body: { prompts: data.prompts }
+      };
+    }
   }
 ];
 var testCaseTools = [
   {
     name: "muggle-remote-test-case-list",
-    description: "List test cases for a project.",
+    description: "List test cases for a project. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
     inputSchema: TestCaseListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
         path: `${MUGGLE_TEST_PREFIX}/test-cases`,
-        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+        queryParams: {
+          projectId: data.projectId,
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
@@ -3668,44 +3892,95 @@ var testCaseTools = [
         }
       };
     }
+  },
+  {
+    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.",
+    inputSchema: BulkPreviewSubmitTestCaseInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "POST",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/use-cases/${data.useCaseId}/test-cases/prompts/bulk-preview`,
+        body: { prompts: data.prompts }
+      };
+    }
   }
 ];
-var testScriptTools = [
+var bulkPreviewTools = [
   {
-    name: "muggle-remote-test-script-list",
-    description: "List test scripts for a project, optionally filtered by test case.",
-    inputSchema: TestScriptListInputSchema,
+    name: "muggle-remote-bulk-preview-job-get",
+    description: "Get the current status and (when terminal) results of a bulk-preview job. Poll this after submitting a bulk-preview job \u2014 every 10\u201315 seconds is fine. Terminal statuses: succeeded, partial, failed, cancelled, expired.",
+    inputSchema: BulkPreviewJobGetInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/test-scripts`,
-        queryParams: { projectId: data.projectId, testCaseId: data.testCaseId, page: data.page, pageSize: data.pageSize }
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/bulk-preview-jobs/${data.jobId}`
       };
     }
   },
   {
-    name: "muggle-remote-test-script-get",
-    description: "Get details of a specific test script.",
-    inputSchema: TestScriptGetInputSchema,
+    name: "muggle-remote-bulk-preview-job-list",
+    description: "List bulk-preview jobs for a project, optionally filtered by status or kind.",
+    inputSchema: BulkPreviewJobListInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/test-scripts/${data.testScriptId}`
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/bulk-preview-jobs`,
+        queryParams: {
+          status: data.status?.join(","),
+          kind: data.kind,
+          limit: data.limit,
+          cursor: data.cursor
+        }
+      };
+    }
+  },
+  {
+    name: "muggle-remote-bulk-preview-job-cancel",
+    description: "Request cancellation of a bulk-preview job. Cancellation is cooperative \u2014 the harvester picks it up on its next tick and moves the job to status=cancelled.",
+    inputSchema: BulkPreviewJobCancelInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "DELETE",
+        path: `${MUGGLE_TEST_PREFIX}/projects/${data.projectId}/bulk-preview-jobs/${data.jobId}`
+      };
+    }
+  }
+];
+var testScriptTools = [
+  {
+    name: "muggle-remote-test-script-list",
+    description: "List test scripts for a project, optionally filtered by test case. Returns up to 10 items per page by default (max 100). Response includes pagination metadata (totalCount, totalPages, hasMore) \u2014 check `hasMore` to decide whether to fetch additional pages.",
+    inputSchema: TestScriptListInputSchema,
+    mapToUpstream: (input) => {
+      const data = input;
+      return {
+        method: "GET",
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts`,
+        queryParams: {
+          projectId: data.projectId,
+          testCaseId: data.testCaseId,
+          page: data.page,
+          pageSize: data.pageSize,
+          sortBy: data.sortBy,
+          sortOrder: data.sortOrder
+        }
       };
     }
   },
   {
-    name: "muggle-remote-test-script-list-paginated",
-    description: "List test scripts with full pagination support.",
-    inputSchema: TestScriptListPaginatedInputSchema,
+    name: "muggle-remote-test-script-get",
+    description: "Get details of a specific test script.",
+    inputSchema: TestScriptGetInputSchema,
     mapToUpstream: (input) => {
       const data = input;
       return {
         method: "GET",
-        path: `${MUGGLE_TEST_PREFIX}/test-scripts/paginated`,
-        queryParams: { projectId: data.projectId, page: data.page, pageSize: data.pageSize }
+        path: `${MUGGLE_TEST_PREFIX}/test-scripts/${data.testScriptId}`
       };
     }
   }
@@ -4691,6 +4966,7 @@ var allQaToolDefinitions = [
   ...projectTools,
   ...useCaseTools,
   ...testCaseTools,
+  ...bulkPreviewTools,
   ...testScriptTools,
   ...actionScriptTools,
   ...workflowTools,
@@ -5985,6 +6261,281 @@ async function startStdioServer(server) {
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("SIGINT", () => shutdown("SIGINT"));
 }
+
+// src/cli/pr-section/selectors.ts
+var ONE_LINER_BUDGET = 160;
+function selectHero(report) {
+  const firstFailed = report.tests.find(
+    (t) => t.status === "failed"
+  );
+  if (firstFailed) {
+    const step = firstFailed.steps.find((s) => s.stepIndex === firstFailed.failureStepIndex);
+    if (step) {
+      return {
+        screenshotUrl: step.screenshotUrl,
+        testName: firstFailed.name,
+        kind: "failure"
+      };
+    }
+  }
+  const firstPassedWithSteps = report.tests.find(
+    (t) => t.status === "passed" && t.steps.length > 0
+  );
+  if (firstPassedWithSteps) {
+    const lastStep = firstPassedWithSteps.steps[firstPassedWithSteps.steps.length - 1];
+    return {
+      screenshotUrl: lastStep.screenshotUrl,
+      testName: firstPassedWithSteps.name,
+      kind: "final"
+    };
+  }
+  return null;
+}
+function buildOneLiner(report) {
+  const total = report.tests.length;
+  if (total === 0) {
+    return "No acceptance tests were executed.";
+  }
+  const failed = report.tests.filter((t) => t.status === "failed");
+  if (failed.length === 0) {
+    return `All ${total} acceptance tests passed.`;
+  }
+  const first = failed[0];
+  const prefix = `${failed.length} of ${total} failed \u2014 "${first.name}" broke at step ${first.failureStepIndex}: `;
+  const available = ONE_LINER_BUDGET - prefix.length - 1;
+  const error = first.error.length > available ? first.error.slice(0, Math.max(0, available - 1)) + "\u2026" : first.error;
+  return `${prefix}${error}.`;
+}
+
+// src/cli/pr-section/render.ts
+var DASHBOARD_URL_BASE = "https://www.muggle-ai.com/muggleTestV0/dashboard/projects";
+var ROW_THUMB_WIDTH = 120;
+var DETAIL_THUMB_WIDTH = 200;
+var HERO_WIDTH = 480;
+function thumbnail(url, width) {
+  return `<a href="${url}"><img src="${url}" width="${width}"></a>`;
+}
+function counts(report) {
+  const passed = report.tests.filter((t) => t.status === "passed").length;
+  const failed = report.tests.filter((t) => t.status === "failed").length;
+  return { passed, failed, text: `**${passed} passed / ${failed} failed**` };
+}
+function renderSummary(report) {
+  const { text: countsLine } = counts(report);
+  const oneLiner = buildOneLiner(report);
+  const hero = selectHero(report);
+  const dashboard = `${DASHBOARD_URL_BASE}/${report.projectId}/scripts`;
+  const lines = [
+    countsLine,
+    "",
+    oneLiner,
+    ""
+  ];
+  if (hero) {
+    lines.push(
+      `<a href="${hero.screenshotUrl}"><img src="${hero.screenshotUrl}" width="${HERO_WIDTH}" alt="${hero.testName}"></a>`,
+      ""
+    );
+  }
+  lines.push(`[View project dashboard on muggle-ai.com](${dashboard})`);
+  return lines.join("\n");
+}
+function renderRow(test) {
+  const link = `[${test.name}](${test.viewUrl})`;
+  if (test.status === "passed") {
+    const lastStep = test.steps[test.steps.length - 1];
+    const thumb2 = lastStep ? thumbnail(lastStep.screenshotUrl, ROW_THUMB_WIDTH) : "\u2014";
+    return `| ${link} | \u2705 PASSED | ${thumb2} |`;
+  }
+  const failStep = test.steps.find((s) => s.stepIndex === test.failureStepIndex);
+  const thumb = failStep ? thumbnail(failStep.screenshotUrl, ROW_THUMB_WIDTH) : "\u2014";
+  return `| ${link} | \u274C FAILED \u2014 ${test.error} | ${thumb} |`;
+}
+function renderFailureDetails(test) {
+  const stepCount = test.steps.length;
+  const header2 = `<details>
+<summary>\u{1F4F8} <strong>${test.name}</strong> \u2014 ${stepCount} steps (failed at step ${test.failureStepIndex})</summary>
+
+| # | Action | Screenshot |
+|---|--------|------------|`;
+  const rows = test.steps.map((step) => renderFailureStepRow(step, test)).join("\n");
+  return `${header2}
+${rows}
+
+</details>`;
+}
+function renderFailureStepRow(step, test) {
+  const isFailure = step.stepIndex === test.failureStepIndex;
+  const marker = isFailure ? `${step.stepIndex} \u26A0\uFE0F` : String(step.stepIndex);
+  const action = isFailure ? `${step.action} \u2014 **${test.error}**` : step.action;
+  return `| ${marker} | ${action} | ${thumbnail(step.screenshotUrl, DETAIL_THUMB_WIDTH)} |`;
+}
+function renderRowsTable(report) {
+  if (report.tests.length === 0) {
+    return "_No tests were executed._";
+  }
+  const header2 = "| Test Case | Status | Evidence |\n|-----------|--------|----------|";
+  const rows = report.tests.map(renderRow).join("\n");
+  return `${header2}
+${rows}`;
+}
+function renderBody(report, opts) {
+  const sections = [
+    "## E2E Acceptance Results",
+    "",
+    renderSummary(report),
+    "",
+    renderRowsTable(report)
+  ];
+  const failures = report.tests.filter((t) => t.status === "failed");
+  if (failures.length > 0) {
+    if (opts.inlineFailureDetails) {
+      sections.push("", ...failures.map(renderFailureDetails));
+    } else {
+      sections.push(
+        "",
+        "_Full step-by-step evidence in the comment below \u2014 the PR description was too large to inline it._"
+      );
+    }
+  }
+  return sections.join("\n");
+}
+function renderComment(report) {
+  const failures = report.tests.filter((t) => t.status === "failed");
+  if (failures.length === 0) {
+    return "";
+  }
+  const sections = [
+    "## E2E acceptance evidence (overflow)",
+    "",
+    "_This comment was posted because the full step-by-step evidence did not fit in the PR description._",
+    "",
+    ...failures.map(renderFailureDetails)
+  ];
+  return sections.join("\n");
+}
+
+// src/cli/pr-section/overflow.ts
+function splitWithOverflow(report, opts) {
+  const inlineBody = renderBody(report, { inlineFailureDetails: true });
+  const inlineBytes = Buffer.byteLength(inlineBody, "utf-8");
+  if (inlineBytes <= opts.maxBodyBytes) {
+    return { body: inlineBody, comment: null };
+  }
+  const spilledBody = renderBody(report, { inlineFailureDetails: false });
+  const comment = renderComment(report);
+  return {
+    body: spilledBody,
+    comment: comment.length > 0 ? comment : null
+  };
+}
+var StepSchema = z.object({
+  stepIndex: z.number().int().nonnegative(),
+  action: z.string().min(1),
+  screenshotUrl: z.string().url()
+});
+var PassedTestSchema = z.object({
+  name: z.string().min(1),
+  testCaseId: z.string().min(1),
+  testScriptId: z.string().min(1).optional(),
+  runId: z.string().min(1),
+  viewUrl: z.string().url(),
+  status: z.literal("passed"),
+  steps: z.array(StepSchema)
+});
+var FailedTestSchema = z.object({
+  name: z.string().min(1),
+  testCaseId: z.string().min(1),
+  testScriptId: z.string().min(1).optional(),
+  runId: z.string().min(1),
+  viewUrl: z.string().url(),
+  status: z.literal("failed"),
+  steps: z.array(StepSchema),
+  failureStepIndex: z.number().int().nonnegative(),
+  error: z.string().min(1),
+  artifactsDir: z.string().min(1).optional()
+});
+var TestResultSchema = z.discriminatedUnion("status", [
+  PassedTestSchema,
+  FailedTestSchema
+]);
+var E2eReportSchema = z.object({
+  projectId: z.string().min(1),
+  tests: z.array(TestResultSchema)
+});
+
+// src/cli/pr-section/index.ts
+function buildPrSection(report, opts) {
+  return splitWithOverflow(report, opts);
+}
+
+// src/cli/build-pr-section.ts
+var DEFAULT_MAX_BODY_BYTES = 6e4;
+async function readAll(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function errMsg(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+async function runBuildPrSection(opts) {
+  let raw;
+  try {
+    raw = await readAll(opts.stdin);
+  } catch (err) {
+    opts.stderrWrite(`build-pr-section: failed to read stdin: ${errMsg(err)}
+`);
+    return 1;
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch (err) {
+    opts.stderrWrite(`build-pr-section: failed to parse stdin as JSON: ${errMsg(err)}
+`);
+    return 1;
+  }
+  let report;
+  try {
+    report = E2eReportSchema.parse(json);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      opts.stderrWrite(
+        `build-pr-section: report validation failed:
+${err.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n")}
+`
+      );
+    } else {
+      opts.stderrWrite(`build-pr-section: report validation failed: ${errMsg(err)}
+`);
+    }
+    return 1;
+  }
+  const result = buildPrSection(report, { maxBodyBytes: opts.maxBodyBytes });
+  opts.stdoutWrite(JSON.stringify({ body: result.body, comment: result.comment }));
+  return 0;
+}
+async function buildPrSectionCommand(options) {
+  const maxBodyBytes = options.maxBodyBytes ? Number(options.maxBodyBytes) : DEFAULT_MAX_BODY_BYTES;
+  if (!Number.isFinite(maxBodyBytes) || maxBodyBytes <= 0) {
+    process.stderr.write(`build-pr-section: --max-body-bytes must be a positive number
+`);
+    process.exitCode = 1;
+    return;
+  }
+  const code = await runBuildPrSection({
+    stdin: process.stdin,
+    stdoutWrite: (s) => process.stdout.write(s),
+    stderrWrite: (s) => process.stderr.write(s),
+    maxBodyBytes
+  });
+  if (code !== 0) {
+    process.exitCode = code;
+  }
+}
 var logger7 = getLogger();
 var ELECTRON_APP_DIR2 = "electron-app";
 var CURSOR_SKILLS_DIR = ".cursor";
@@ -7362,6 +7913,7 @@ function createProgram() {
   program.command("login").description("Authenticate with Muggle AI (uses device code flow)").option("--key-name <name>", "Name for the API key").option("--key-expiry <expiry>", "API key expiry: 30d, 90d, 1y, never", "90d").action(loginCommand);
   program.command("logout").description("Clear stored credentials").action(logoutCommand);
   program.command("status").description("Show authentication status").action(statusCommand);
+  program.command("build-pr-section").description("Render a muggle-do PR body evidence block from an e2e report on stdin").option("--max-body-bytes <n>", "Max UTF-8 byte budget for the PR body (default 60000)").action(buildPrSectionCommand);
   program.action(() => {
     helpCommand();
   });