@wix/evalforge-types 0.91.0 → 0.93.0

package/build/index.js

@@ -159,6 +159,7 @@ __export(index_exports, {
   PresetSchema: () => PresetSchema,
   ProjectSchema: () => ProjectSchema,
   PromptResultSchema: () => PromptResultSchema,
+  ProvisionedSiteSchema: () => ProvisionedSiteSchema,
   RUN_COMMAND_LABELS: () => RUN_COMMAND_LABELS,
   ReasoningEffortSchema: () => ReasoningEffortSchema,
   RuleSchema: () => RuleSchema,
@@ -166,13 +167,20 @@ __export(index_exports, {
   RunAnalysisFindingSchema: () => RunAnalysisFindingSchema,
   RunAnalysisSchema: () => RunAnalysisSchema,
   SEMVER_REGEX: () => SEMVER_REGEX,
+  SITE_SETUP_EXCLUSIVE_VARIABLES: () => SITE_SETUP_EXCLUSIVE_VARIABLES,
   SKILL_FOLDER_NAME_REGEX: () => SKILL_FOLDER_NAME_REGEX,
   SYSTEM_ASSERTIONS: () => SYSTEM_ASSERTIONS,
   SYSTEM_ASSERTION_IDS: () => SYSTEM_ASSERTION_IDS,
   ScenarioAssertionLinkSchema: () => ScenarioAssertionLinkSchema,
   ScenarioConversationSchema: () => ScenarioConversationSchema,
   SimpleAgentConfigSchema: () => SimpleAgentConfigSchema,
+  SiteBootstrapHttpMethodSchema: () => SiteBootstrapHttpMethodSchema,
+  SiteBootstrapResultSchema: () => SiteBootstrapResultSchema,
+  SiteBootstrapSchema: () => SiteBootstrapSchema,
+  SiteBootstrapStepResultSchema: () => SiteBootstrapStepResultSchema,
+  SiteBootstrapStepSchema: () => SiteBootstrapStepSchema,
   SiteConfigTestSchema: () => SiteConfigTestSchema,
+  SiteSetupConfigSchema: () => SiteSetupConfigSchema,
   SkillFileSchema: () => SkillFileSchema,
   SkillMetadataSchema: () => SkillMetadataSchema,
   SkillSchema: () => SkillSchema,
@@ -226,6 +234,7 @@ __export(index_exports, {
   UpdateTestScenarioInputSchema: () => UpdateTestScenarioInputSchema,
   UpdateTestSuiteInputSchema: () => UpdateTestSuiteInputSchema,
   VitestTestSchema: () => VitestTestSchema,
+  WixSiteSummarySchema: () => WixSiteSummarySchema,
   capabilityToMcp: () => capabilityToMcp,
   capabilityToRule: () => capabilityToRule,
   capabilityToSkill: () => capabilityToSkill,
@@ -233,6 +242,7 @@ __export(index_exports, {
   capabilityToSubAgent: () => capabilityToSubAgent,
   capabilityVersionToSkillVersion: () => capabilityVersionToSkillVersion,
   classifyAssertionRef: () => classifyAssertionRef,
+  extractVariableNamesFromPrompt: () => extractVariableNamesFromPrompt,
   formatTraceEventLine: () => formatTraceEventLine,
   getSystemAssertion: () => getSystemAssertion,
   getSystemAssertions: () => getSystemAssertions,
@@ -245,8 +255,11 @@ __export(index_exports, {
   normalizeModelId: () => normalizeModelId,
   parseBuildCommandToArgv: () => parseBuildCommandToArgv,
   parseTraceEventLine: () => parseTraceEventLine,
+  promptUsesSiteSetupExclusiveVariables: () => promptUsesSiteSetupExclusiveVariables,
+  resolveWixOriginTemplateId: () => resolveWixOriginTemplateId,
   validateAssertionConfig: () => validateAssertionConfig,
-  validateBuildPassedParamsInAssertionLinks: () => validateBuildPassedParamsInAssertionLinks
+  validateBuildPassedParamsInAssertionLinks: () => validateBuildPassedParamsInAssertionLinks,
+  validateSiteSetupExclusivity: () => validateSiteSetupExclusivity
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -438,6 +451,7 @@ var AVAILABLE_TOOL_NAMES = [
   "Grep",
   "Read",
   "Skill",
+  "WebFetch",
   "Write"
 ];
 
@@ -1072,14 +1086,65 @@ var EnvironmentSchema = import_zod22.z.object({
   metaSite: MetaSiteConfigSchema.optional()
 });
 
+// src/scenario/site-setup.ts
+var import_zod23 = require("zod");
+var SiteBootstrapHttpMethodSchema = import_zod23.z.enum([
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+]);
+var SiteBootstrapStepSchema = import_zod23.z.object({
+  label: import_zod23.z.string().optional(),
+  method: SiteBootstrapHttpMethodSchema,
+  url: import_zod23.z.string().min(1),
+  body: import_zod23.z.record(import_zod23.z.string(), import_zod23.z.unknown()).optional()
+});
+var SiteBootstrapSchema = import_zod23.z.object({
+  steps: import_zod23.z.array(SiteBootstrapStepSchema).default([])
+});
+var SiteBootstrapStepResultSchema = import_zod23.z.object({
+  label: import_zod23.z.string().optional(),
+  statusCode: import_zod23.z.number().int(),
+  ok: import_zod23.z.boolean(),
+  error: import_zod23.z.string().optional()
+});
+var SiteBootstrapResultSchema = import_zod23.z.object({
+  steps: import_zod23.z.array(SiteBootstrapStepResultSchema)
+});
+var SiteSetupConfigSchema = import_zod23.z.discriminatedUnion("mode", [
+  import_zod23.z.object({ mode: import_zod23.z.literal("none") }),
+  import_zod23.z.object({
+    mode: import_zod23.z.literal("clone"),
+    sourceSiteId: import_zod23.z.string().min(1),
+    bootstrap: SiteBootstrapSchema.optional()
+  }),
+  import_zod23.z.object({
+    mode: import_zod23.z.literal("template"),
+    templateId: import_zod23.z.string().min(1),
+    bootstrap: SiteBootstrapSchema.optional()
+  })
+]);
+var WixSiteSummarySchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  displayName: import_zod23.z.string(),
+  url: import_zod23.z.string().optional()
+});
+var ProvisionedSiteSchema = import_zod23.z.object({
+  id: import_zod23.z.string(),
+  url: import_zod23.z.string().optional(),
+  editorUrl: import_zod23.z.string().optional()
+});
+
 // src/scenario/test-scenario.ts
-var import_zod25 = require("zod");
+var import_zod26 = require("zod");
 
 // src/assertion/assertion.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 
 // src/assertion/build-passed-command.ts
-var import_zod23 = require("zod");
+var import_zod24 = require("zod");
 var ALLOWED_BUILD_COMMANDS = [
   "yarn build",
   "npm run build",
@@ -1105,10 +1170,10 @@ function parseBuildCommandToArgv(command) {
   return BUILD_COMMAND_ARGV[trimmed];
 }
 var enumTuple = ALLOWED_BUILD_COMMANDS;
-var BuildPassedCommandStringSchema = import_zod23.z.enum(enumTuple);
+var BuildPassedCommandStringSchema = import_zod24.z.enum(enumTuple);
 
 // src/assertion/assertion.ts
-var AssertionTypeSchema = import_zod24.z.enum([
+var AssertionTypeSchema = import_zod25.z.enum([
   "skill_was_called",
   "tool_called_with_param",
   "build_passed",
@@ -1117,61 +1182,61 @@ var AssertionTypeSchema = import_zod24.z.enum([
   "llm_judge",
   "api_call"
 ]);
-var AssertionParameterTypeSchema = import_zod24.z.enum([
+var AssertionParameterTypeSchema = import_zod25.z.enum([
   "string",
   "number",
   "boolean"
 ]);
-var AssertionParameterSchema = import_zod24.z.object({
+var AssertionParameterSchema = import_zod25.z.object({
   /** Parameter name (used as key in params object) */
-  name: import_zod24.z.string().min(1),
+  name: import_zod25.z.string().min(1),
   /** Display label for the parameter */
-  label: import_zod24.z.string().min(1),
+  label: import_zod25.z.string().min(1),
   /** Parameter type */
   type: AssertionParameterTypeSchema,
   /** Whether this parameter is required */
-  required: import_zod24.z.boolean(),
+  required: import_zod25.z.boolean(),
   /** Default value (optional, used when not provided) */
-  defaultValue: import_zod24.z.union([import_zod24.z.string(), import_zod24.z.number(), import_zod24.z.boolean()]).optional(),
+  defaultValue: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.number(), import_zod25.z.boolean()]).optional(),
   /** If true, parameter is hidden by default behind "Show advanced options" */
-  advanced: import_zod24.z.boolean().optional()
+  advanced: import_zod25.z.boolean().optional()
 });
-var ScenarioAssertionLinkSchema = import_zod24.z.object({
+var ScenarioAssertionLinkSchema = import_zod25.z.object({
   /** ID of the system assertion (e.g., 'system:skill_was_called') */
-  assertionId: import_zod24.z.string(),
+  assertionId: import_zod25.z.string(),
   /** Parameter values for this assertion in this scenario */
-  params: import_zod24.z.record(
-    import_zod24.z.string(),
-    import_zod24.z.union([import_zod24.z.string(), import_zod24.z.number(), import_zod24.z.boolean(), import_zod24.z.null()])
+  params: import_zod25.z.record(
+    import_zod25.z.string(),
+    import_zod25.z.union([import_zod25.z.string(), import_zod25.z.number(), import_zod25.z.boolean(), import_zod25.z.null()])
   ).optional()
 });
-var SkillWasCalledConfigSchema = import_zod24.z.object({
+var SkillWasCalledConfigSchema = import_zod25.z.object({
   /** Names of the skills that must have been called */
-  skillNames: import_zod24.z.array(import_zod24.z.string().min(1)).min(1)
+  skillNames: import_zod25.z.array(import_zod25.z.string().min(1)).min(1)
 });
-var CostConfigSchema = import_zod24.z.strictObject({
+var CostConfigSchema = import_zod25.z.strictObject({
   /** Maximum allowed cost in USD */
-  maxCostUsd: import_zod24.z.number().positive()
+  maxCostUsd: import_zod25.z.number().positive()
 });
-var ToolCalledWithParamConfigSchema = import_zod24.z.strictObject({
+var ToolCalledWithParamConfigSchema = import_zod25.z.strictObject({
   /** Name of the tool that must have been called */
-  toolName: import_zod24.z.string().min(1),
+  toolName: import_zod25.z.string().min(1),
   /** JSON string of key-value pairs for expected parameters (substring match). Optional — when omitted, only checks tool presence. */
-  expectedParams: import_zod24.z.string().min(1).optional(),
+  expectedParams: import_zod25.z.string().min(1).optional(),
   /** If true, the matching tool call must also have succeeded (step.success === true) */
-  requireSuccess: import_zod24.z.boolean().optional()
+  requireSuccess: import_zod25.z.boolean().optional()
 });
-var BuildPassedConfigSchema = import_zod24.z.strictObject({
+var BuildPassedConfigSchema = import_zod25.z.strictObject({
   /** Allowlisted command only (default at runtime: "npm run build") */
   command: BuildPassedCommandStringSchema.optional(),
   /** Expected exit code (default: 0) */
-  expectedExitCode: import_zod24.z.number().int().optional()
+  expectedExitCode: import_zod25.z.number().int().optional()
 });
-var TimeConfigSchema = import_zod24.z.strictObject({
+var TimeConfigSchema = import_zod25.z.strictObject({
   /** Maximum allowed duration in milliseconds */
-  maxDurationMs: import_zod24.z.number().int().positive()
+  maxDurationMs: import_zod25.z.number().int().positive()
 });
-var LlmJudgeConfigSchema = import_zod24.z.object({
+var LlmJudgeConfigSchema = import_zod25.z.object({
   /**
    * Prompt template with placeholders:
    * - {{output}}: agent's final output
@@ -1182,65 +1247,65 @@ var LlmJudgeConfigSchema = import_zod24.z.object({
    * - {{trace}}: step-by-step trace of tool calls
    * - Custom parameters defined in the parameters array
    */
-  prompt: import_zod24.z.string().min(1),
+  prompt: import_zod25.z.string().min(1),
   /** Minimum score to pass (0-10, default 7) */
-  minScore: import_zod24.z.number().int().min(0).max(10).optional(),
+  minScore: import_zod25.z.number().int().min(0).max(10).optional(),
   /** Model for the judge (e.g. claude-3-5-haiku-20241022) */
-  model: import_zod24.z.string().optional(),
+  model: import_zod25.z.string().optional(),
   /** Max output tokens */
-  maxTokens: import_zod24.z.number().int().optional(),
+  maxTokens: import_zod25.z.number().int().optional(),
   /** Temperature (0-1) */
-  temperature: import_zod24.z.number().min(0).max(1).optional(),
+  temperature: import_zod25.z.number().min(0).max(1).optional(),
   /** User-defined parameters for this assertion */
-  parameters: import_zod24.z.array(AssertionParameterSchema).optional()
+  parameters: import_zod25.z.array(AssertionParameterSchema).optional()
 });
-var ApiCallConfigSchema = import_zod24.z.strictObject({
+var ApiCallConfigSchema = import_zod25.z.strictObject({
   /** URL to call */
-  url: import_zod24.z.string().min(1),
+  url: import_zod25.z.string().min(1),
   /** HTTP method (default GET) */
-  method: import_zod24.z.enum(["GET", "POST"]).optional(),
+  method: import_zod25.z.enum(["GET", "POST"]).optional(),
   /** Request body (JSON string, for POST requests) */
-  requestBody: import_zod24.z.string().optional(),
+  requestBody: import_zod25.z.string().optional(),
   /** Expected JSON response to validate against (subset match — extra fields in actual are OK) */
-  expectedResponse: import_zod24.z.string().min(1),
+  expectedResponse: import_zod25.z.string().min(1),
   /** Request headers as JSON string of key-value pairs */
-  requestHeaders: import_zod24.z.string().optional(),
+  requestHeaders: import_zod25.z.string().optional(),
   /** Request timeout in milliseconds (default 30000) */
-  timeoutMs: import_zod24.z.number().int().positive().optional()
+  timeoutMs: import_zod25.z.number().int().positive().optional()
 });
 var AssertionBaseFields = {
   /** When true, the assertion's pass/fail logic is inverted (NOT operator). */
-  negate: import_zod24.z.boolean().optional()
+  negate: import_zod25.z.boolean().optional()
 };
 var SkillWasCalledAssertionSchema = SkillWasCalledConfigSchema.extend({
-  type: import_zod24.z.literal("skill_was_called"),
+  type: import_zod25.z.literal("skill_was_called"),
   ...AssertionBaseFields
 });
 var ToolCalledWithParamAssertionSchema = ToolCalledWithParamConfigSchema.extend({
-  type: import_zod24.z.literal("tool_called_with_param"),
+  type: import_zod25.z.literal("tool_called_with_param"),
   ...AssertionBaseFields
 });
 var BuildPassedAssertionSchema = BuildPassedConfigSchema.extend({
-  type: import_zod24.z.literal("build_passed"),
+  type: import_zod25.z.literal("build_passed"),
   ...AssertionBaseFields
 });
 var CostAssertionSchema = CostConfigSchema.extend({
-  type: import_zod24.z.literal("cost"),
+  type: import_zod25.z.literal("cost"),
   ...AssertionBaseFields
 });
 var LlmJudgeAssertionSchema = LlmJudgeConfigSchema.extend({
-  type: import_zod24.z.literal("llm_judge"),
+  type: import_zod25.z.literal("llm_judge"),
   ...AssertionBaseFields
 });
 var ApiCallAssertionSchema = ApiCallConfigSchema.extend({
-  type: import_zod24.z.literal("api_call"),
+  type: import_zod25.z.literal("api_call"),
   ...AssertionBaseFields
 });
 var TimeAssertionSchema = TimeConfigSchema.extend({
-  type: import_zod24.z.literal("time_limit"),
+  type: import_zod25.z.literal("time_limit"),
   ...AssertionBaseFields
 });
-var AssertionSchema = import_zod24.z.union([
+var AssertionSchema = import_zod25.z.union([
   SkillWasCalledAssertionSchema,
   ToolCalledWithParamAssertionSchema,
   BuildPassedAssertionSchema,
@@ -1249,7 +1314,7 @@ var AssertionSchema = import_zod24.z.union([
   LlmJudgeAssertionSchema,
   ApiCallAssertionSchema
 ]);
-var AssertionConfigSchema = import_zod24.z.union([
+var AssertionConfigSchema = import_zod25.z.union([
   LlmJudgeConfigSchema,
   // requires prompt - check first
   SkillWasCalledConfigSchema,
@@ -1264,7 +1329,7 @@ var AssertionConfigSchema = import_zod24.z.union([
   // requires maxCostUsd, uses strictObject
   BuildPassedConfigSchema,
   // all optional, uses strictObject to reject unknown keys
-  import_zod24.z.object({})
+  import_zod25.z.object({})
   // fallback empty config
 ]);
 function validateAssertionConfig(type, config) {
@@ -1510,36 +1575,67 @@ function getSystemAssertion(id) {
 
 // src/scenario/test-scenario.ts
 var MAX_IMAGE_BASE64_LENGTH = 4 * Math.ceil(2 * 1024 * 1024 / 3);
-var TriggerPromptImageSchema = import_zod25.z.object({
+var TriggerPromptImageSchema = import_zod26.z.object({
   /** Base64-encoded image data (no data URL prefix) */
-  base64: import_zod25.z.string().max(MAX_IMAGE_BASE64_LENGTH, "Image exceeds 2 MB size limit"),
+  base64: import_zod26.z.string().max(MAX_IMAGE_BASE64_LENGTH, "Image exceeds 2 MB size limit"),
   /** MIME type of the image */
-  mediaType: import_zod25.z.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
+  mediaType: import_zod26.z.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
   /** Original filename of the image */
-  name: import_zod25.z.string()
+  name: import_zod26.z.string()
 });
-var ExpectedFileSchema = import_zod25.z.object({
+var ExpectedFileSchema = import_zod26.z.object({
   /** Relative path where the file should be created */
-  path: import_zod25.z.string(),
+  path: import_zod26.z.string(),
   /** Optional expected content */
-  content: import_zod25.z.string().optional()
+  content: import_zod26.z.string().optional()
 });
 var TestScenarioSchema = TenantEntitySchema.extend({
   /** The prompt sent to the agent to trigger the task */
-  triggerPrompt: import_zod25.z.string().min(10),
+  triggerPrompt: import_zod26.z.string().min(10),
   /** ID of the template to use for this scenario (null = no template) */
-  templateId: import_zod25.z.string().nullish(),
+  templateId: import_zod26.z.string().nullish(),
   /** Inline assertions to evaluate for this scenario (legacy) */
-  assertions: import_zod25.z.array(AssertionSchema).optional(),
+  assertions: import_zod26.z.array(AssertionSchema).optional(),
   /** IDs of saved assertions to evaluate (from assertions table) - legacy, use assertionLinks */
-  assertionIds: import_zod25.z.array(import_zod25.z.string()).optional(),
+  assertionIds: import_zod26.z.array(import_zod26.z.string()).optional(),
   /** Linked assertions with per-scenario parameter values */
-  assertionLinks: import_zod25.z.array(ScenarioAssertionLinkSchema).optional(),
+  assertionLinks: import_zod26.z.array(ScenarioAssertionLinkSchema).optional(),
   /** Tags for categorisation and filtering */
-  tags: import_zod25.z.array(import_zod25.z.string()).optional(),
+  tags: import_zod26.z.array(import_zod26.z.string()).optional(),
   /** Base64-encoded images attached to the trigger prompt (max 3) */
-  triggerPromptImages: import_zod25.z.array(TriggerPromptImageSchema).max(3).optional()
-});
+  triggerPromptImages: import_zod26.z.array(TriggerPromptImageSchema).max(3).optional(),
+  /** Optional per-scenario Wix site provisioning instructions. Absent ≡ no site. */
+  siteSetup: SiteSetupConfigSchema.optional()
+});
+var SITE_SETUP_EXCLUSIVE_VARIABLES = ["site-id"];
+function extractVariableNamesFromPrompt(prompt) {
+  const names = /* @__PURE__ */ new Set();
+  for (const match of prompt.matchAll(/\{\{([\w-]+)\}\}/g)) {
+    names.add(match[1]);
+  }
+  return [...names];
+}
+function promptUsesSiteSetupExclusiveVariables(prompt) {
+  const names = extractVariableNamesFromPrompt(prompt);
+  return SITE_SETUP_EXCLUSIVE_VARIABLES.some(
+    (exclusive) => names.includes(exclusive)
+  );
+}
+function hasActiveSiteSetup(siteSetup) {
+  return siteSetup?.mode === "clone" || siteSetup?.mode === "template";
+}
+function validateSiteSetupExclusivity(data, ctx) {
+  if (!hasActiveSiteSetup(data.siteSetup)) return;
+  const prompt = data.triggerPrompt;
+  if (prompt === void 0 || !promptUsesSiteSetupExclusiveVariables(prompt)) {
+    return;
+  }
+  ctx.addIssue({
+    code: import_zod26.z.ZodIssueCode.custom,
+    message: "Site setup and {{site-id}} run variables cannot be used together. Remove {{site-id}} from the trigger prompt or disable site setup.",
+    path: ["triggerPrompt"]
+  });
+}
 function validateBuildPassedParamsInAssertionLinks(links, ctx) {
   if (!links) return;
   for (let i = 0; i < links.length; i++) {
@@ -1549,7 +1645,7 @@ function validateBuildPassedParamsInAssertionLinks(links, ctx) {
     if (cmd === void 0 || cmd === null) continue;
     if (typeof cmd !== "string") {
       ctx.addIssue({
-        code: import_zod25.z.ZodIssueCode.custom,
+        code: import_zod26.z.ZodIssueCode.custom,
         message: "build_passed command must be a string",
         path: ["assertionLinks", i, "params", "command"]
       });
@@ -1557,7 +1653,7 @@ function validateBuildPassedParamsInAssertionLinks(links, ctx) {
     }
     if (!isAllowedBuildCommandString(cmd)) {
       ctx.addIssue({
-        code: import_zod25.z.ZodIssueCode.custom,
+        code: import_zod26.z.ZodIssueCode.custom,
         message: "Invalid build_passed command. Allowed: yarn build, npm run build, pnpm run build, pnpm build",
         path: ["assertionLinks", i, "params", "command"]
       });
@@ -1572,27 +1668,56 @@ var TestScenarioCreateBaseSchema = TestScenarioSchema.omit({
 });
 var CreateTestScenarioInputSchema = TestScenarioCreateBaseSchema.superRefine((data, ctx) => {
   validateBuildPassedParamsInAssertionLinks(data.assertionLinks, ctx);
+  validateSiteSetupExclusivity(data, ctx);
 });
 var UpdateTestScenarioInputSchema = TestScenarioCreateBaseSchema.partial().superRefine((data, ctx) => {
   if (data.assertionLinks !== void 0) {
     validateBuildPassedParamsInAssertionLinks(data.assertionLinks, ctx);
   }
+  validateSiteSetupExclusivity(data, ctx);
 });
 
+// src/scenario/wix-origin-template-ids.ts
+var WIX_ORIGIN_TEMPLATE_ID_BY_ALIAS = {
+  ecommerce: "e5da13f4-c01e-4b61-a9c7-55dacd961d54",
+  default: "212b41cb-0da6-4401-9c72-7c579e6477a2",
+  blog: "68fc7371-365f-44c6-8467-69d88bfc172e",
+  astrowind: "9e9292c1-1a35-4ba0-8986-d06f2ecb5366",
+  scheduler: "72ade0e3-1871-4c04-ac54-419ca874d9d3",
+  registration: "e5d63bf1-cd06-48eb-ad77-0da9235adcf1",
+  "picasso-studio": "61f05de1-b0ce-4873-b9f5-52241a6fd262",
+  "picasso-ecom": "daa9187d-f010-4eb0-bd49-e658b5a5037a",
+  picasso: "99b9a3c7-82ad-4e1b-9066-e490bb9863af",
+  "ecom-editorless": "738c7c0b-046e-4bf0-87dd-9a06ee5a52c4"
+};
+var GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function resolveWixOriginTemplateId(templateId) {
+  if (GUID_PATTERN.test(templateId)) {
+    return templateId;
+  }
+  const originTemplateId = WIX_ORIGIN_TEMPLATE_ID_BY_ALIAS[templateId];
+  if (!originTemplateId) {
+    throw new Error(
+      `Unknown Wix site template alias "${templateId}". Use a GUID or one of: ${Object.keys(WIX_ORIGIN_TEMPLATE_ID_BY_ALIAS).join(", ")}`
+    );
+  }
+  return originTemplateId;
+}
+
 // src/scenario/batch-import.ts
-var import_zod26 = require("zod");
+var import_zod27 = require("zod");
 var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var BatchAssertionLinkSchema = import_zod26.z.union([
-  import_zod26.z.string().min(1),
+var BatchAssertionLinkSchema = import_zod27.z.union([
+  import_zod27.z.string().min(1),
   ScenarioAssertionLinkSchema
 ]);
-var BatchScenarioEntrySchema = import_zod26.z.object({
-  name: import_zod26.z.string().min(1, "name: Required"),
-  description: import_zod26.z.string().optional().default(""),
-  triggerPrompt: import_zod26.z.string().min(10, "triggerPrompt: Must be at least 10 characters"),
-  templateId: import_zod26.z.string().nullish(),
-  tags: import_zod26.z.array(import_zod26.z.string()).optional(),
-  assertionLinks: import_zod26.z.array(BatchAssertionLinkSchema).optional()
+var BatchScenarioEntrySchema = import_zod27.z.object({
+  name: import_zod27.z.string().min(1, "name: Required"),
+  description: import_zod27.z.string().optional().default(""),
+  triggerPrompt: import_zod27.z.string().min(10, "triggerPrompt: Must be at least 10 characters"),
+  templateId: import_zod27.z.string().nullish(),
+  tags: import_zod27.z.array(import_zod27.z.string()).optional(),
+  assertionLinks: import_zod27.z.array(BatchAssertionLinkSchema).optional()
 }).superRefine((data, ctx) => {
   if (!data.assertionLinks) return;
   const objectLinks = data.assertionLinks.filter(
@@ -1602,8 +1727,8 @@ var BatchScenarioEntrySchema = import_zod26.z.object({
     validateBuildPassedParamsInAssertionLinks(objectLinks, ctx);
   }
 });
-var BatchImportPayloadSchema = import_zod26.z.object({
-  scenarios: import_zod26.z.array(BatchScenarioEntrySchema).min(1, "scenarios array must contain at least one entry").max(100, "Maximum 100 scenarios per upload")
+var BatchImportPayloadSchema = import_zod27.z.object({
+  scenarios: import_zod27.z.array(BatchScenarioEntrySchema).min(1, "scenarios array must contain at least one entry").max(100, "Maximum 100 scenarios per upload")
 });
 var BATCH_IMPORT_LIMITS = {
   MAX_SCENARIOS: 100,
@@ -1625,29 +1750,29 @@ function normalizeBatchAssertionLink(link) {
   }
   return link;
 }
-var BatchResultItemSchema = import_zod26.z.object({
-  index: import_zod26.z.number(),
-  name: import_zod26.z.string(),
-  status: import_zod26.z.enum(["valid", "invalid"]),
-  id: import_zod26.z.string().nullable().optional(),
-  errors: import_zod26.z.array(import_zod26.z.string()).optional()
-});
-var BatchSummarySchema = import_zod26.z.object({
-  total: import_zod26.z.number(),
-  valid: import_zod26.z.number(),
-  invalid: import_zod26.z.number(),
-  created: import_zod26.z.number()
-});
-var BatchImportResponseSchema = import_zod26.z.object({
+var BatchResultItemSchema = import_zod27.z.object({
+  index: import_zod27.z.number(),
+  name: import_zod27.z.string(),
+  status: import_zod27.z.enum(["valid", "invalid"]),
+  id: import_zod27.z.string().nullable().optional(),
+  errors: import_zod27.z.array(import_zod27.z.string()).optional()
+});
+var BatchSummarySchema = import_zod27.z.object({
+  total: import_zod27.z.number(),
+  valid: import_zod27.z.number(),
+  invalid: import_zod27.z.number(),
+  created: import_zod27.z.number()
+});
+var BatchImportResponseSchema = import_zod27.z.object({
   summary: BatchSummarySchema,
-  results: import_zod26.z.array(BatchResultItemSchema)
+  results: import_zod27.z.array(BatchResultItemSchema)
 });
 
 // src/suite/test-suite.ts
-var import_zod27 = require("zod");
+var import_zod28 = require("zod");
 var TestSuiteSchema = TenantEntitySchema.extend({
   /** IDs of test scenarios in this suite */
-  scenarioIds: import_zod27.z.array(import_zod27.z.string())
+  scenarioIds: import_zod28.z.array(import_zod28.z.string())
 });
 var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
   id: true,
@@ -1658,21 +1783,21 @@ var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
 var UpdateTestSuiteInputSchema = CreateTestSuiteInputSchema.partial();
 
 // src/evaluation/metrics.ts
-var import_zod28 = require("zod");
-var TokenUsageSchema = import_zod28.z.object({
-  prompt: import_zod28.z.number(),
-  completion: import_zod28.z.number(),
-  total: import_zod28.z.number()
-});
-var EvalMetricsSchema = import_zod28.z.object({
-  totalAssertions: import_zod28.z.number(),
-  passed: import_zod28.z.number(),
-  failed: import_zod28.z.number(),
-  skipped: import_zod28.z.number(),
-  errors: import_zod28.z.number(),
-  passRate: import_zod28.z.number(),
-  avgDuration: import_zod28.z.number(),
-  totalDuration: import_zod28.z.number()
+var import_zod29 = require("zod");
+var TokenUsageSchema = import_zod29.z.object({
+  prompt: import_zod29.z.number(),
+  completion: import_zod29.z.number(),
+  total: import_zod29.z.number()
+});
+var EvalMetricsSchema = import_zod29.z.object({
+  totalAssertions: import_zod29.z.number(),
+  passed: import_zod29.z.number(),
+  failed: import_zod29.z.number(),
+  skipped: import_zod29.z.number(),
+  errors: import_zod29.z.number(),
+  passRate: import_zod29.z.number(),
+  avgDuration: import_zod29.z.number(),
+  totalDuration: import_zod29.z.number()
 });
 var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["PENDING"] = "pending";
@@ -1682,7 +1807,7 @@ var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["CANCELLED"] = "cancelled";
   return EvalStatus2;
 })(EvalStatus || {});
-var EvalStatusSchema = import_zod28.z.enum(EvalStatus);
+var EvalStatusSchema = import_zod29.z.enum(EvalStatus);
 var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["COMPLETION"] = "completion";
   LLMStepType2["TOOL_USE"] = "tool_use";
@@ -1690,54 +1815,54 @@ var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["THINKING"] = "thinking";
   return LLMStepType2;
 })(LLMStepType || {});
-var LLMTraceStepSchema = import_zod28.z.object({
-  id: import_zod28.z.string(),
-  stepNumber: import_zod28.z.number(),
-  type: import_zod28.z.enum(LLMStepType),
-  model: import_zod28.z.string(),
-  provider: import_zod28.z.string(),
-  startedAt: import_zod28.z.string(),
-  durationMs: import_zod28.z.number(),
+var LLMTraceStepSchema = import_zod29.z.object({
+  id: import_zod29.z.string(),
+  stepNumber: import_zod29.z.number(),
+  type: import_zod29.z.enum(LLMStepType),
+  model: import_zod29.z.string(),
+  provider: import_zod29.z.string(),
+  startedAt: import_zod29.z.string(),
+  durationMs: import_zod29.z.number(),
   tokenUsage: TokenUsageSchema,
-  costUsd: import_zod28.z.number(),
-  toolName: import_zod28.z.string().optional(),
-  toolArguments: import_zod28.z.string().optional(),
-  inputPreview: import_zod28.z.string().optional(),
-  outputPreview: import_zod28.z.string().optional(),
-  success: import_zod28.z.boolean(),
-  error: import_zod28.z.string().optional(),
-  turnIndex: import_zod28.z.number().optional()
-});
-var LLMBreakdownStatsSchema = import_zod28.z.object({
-  count: import_zod28.z.number(),
-  durationMs: import_zod28.z.number(),
-  tokens: import_zod28.z.number(),
-  costUsd: import_zod28.z.number()
-});
-var LLMTraceSummarySchema = import_zod28.z.object({
-  totalSteps: import_zod28.z.number(),
-  totalTurns: import_zod28.z.number().optional(),
-  totalDurationMs: import_zod28.z.number(),
+  costUsd: import_zod29.z.number(),
+  toolName: import_zod29.z.string().optional(),
+  toolArguments: import_zod29.z.string().optional(),
+  inputPreview: import_zod29.z.string().optional(),
+  outputPreview: import_zod29.z.string().optional(),
+  success: import_zod29.z.boolean(),
+  error: import_zod29.z.string().optional(),
+  turnIndex: import_zod29.z.number().optional()
+});
+var LLMBreakdownStatsSchema = import_zod29.z.object({
+  count: import_zod29.z.number(),
+  durationMs: import_zod29.z.number(),
+  tokens: import_zod29.z.number(),
+  costUsd: import_zod29.z.number()
+});
+var LLMTraceSummarySchema = import_zod29.z.object({
+  totalSteps: import_zod29.z.number(),
+  totalTurns: import_zod29.z.number().optional(),
+  totalDurationMs: import_zod29.z.number(),
   totalTokens: TokenUsageSchema,
-  totalCostUsd: import_zod28.z.number(),
-  stepTypeBreakdown: import_zod28.z.record(import_zod28.z.string(), LLMBreakdownStatsSchema).optional(),
-  modelBreakdown: import_zod28.z.record(import_zod28.z.string(), LLMBreakdownStatsSchema),
-  modelsUsed: import_zod28.z.array(import_zod28.z.string())
-});
-var LLMTraceSchema = import_zod28.z.object({
-  id: import_zod28.z.string(),
-  steps: import_zod28.z.array(LLMTraceStepSchema),
+  totalCostUsd: import_zod29.z.number(),
+  stepTypeBreakdown: import_zod29.z.record(import_zod29.z.string(), LLMBreakdownStatsSchema).optional(),
+  modelBreakdown: import_zod29.z.record(import_zod29.z.string(), LLMBreakdownStatsSchema),
+  modelsUsed: import_zod29.z.array(import_zod29.z.string())
+});
+var LLMTraceSchema = import_zod29.z.object({
+  id: import_zod29.z.string(),
+  steps: import_zod29.z.array(LLMTraceStepSchema),
   summary: LLMTraceSummarySchema
 });
 
 // src/evaluation/eval-result.ts
-var import_zod32 = require("zod");
+var import_zod33 = require("zod");
 
 // src/evaluation/eval-run.ts
-var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 
 // src/evaluation/live-trace.ts
-var import_zod29 = require("zod");
+var import_zod30 = require("zod");
 var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["THINKING"] = "thinking";
   LiveTraceEventType2["TOOL_USE"] = "tool_use";
@@ -1751,37 +1876,37 @@ var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["USER"] = "user";
   return LiveTraceEventType2;
 })(LiveTraceEventType || {});
-var LiveTraceEventSchema = import_zod29.z.object({
+var LiveTraceEventSchema = import_zod30.z.object({
   /** The evaluation run ID */
-  evalRunId: import_zod29.z.string(),
+  evalRunId: import_zod30.z.string(),
   /** The scenario ID being executed */
-  scenarioId: import_zod29.z.string(),
+  scenarioId: import_zod30.z.string(),
   /** The scenario name for display */
-  scenarioName: import_zod29.z.string(),
+  scenarioName: import_zod30.z.string(),
   /** The target ID (skill, agent, etc.) */
-  targetId: import_zod29.z.string(),
+  targetId: import_zod30.z.string(),
   /** The target name for display */
-  targetName: import_zod29.z.string(),
+  targetName: import_zod30.z.string(),
   /** Step number in the current scenario execution */
-  stepNumber: import_zod29.z.number(),
+  stepNumber: import_zod30.z.number(),
   /** Type of trace event */
-  type: import_zod29.z.enum(LiveTraceEventType),
+  type: import_zod30.z.enum(LiveTraceEventType),
   /** Tool name if this is a tool_use event */
-  toolName: import_zod29.z.string().optional(),
+  toolName: import_zod30.z.string().optional(),
   /** Tool arguments preview (truncated JSON) */
-  toolArgs: import_zod29.z.string().optional(),
+  toolArgs: import_zod30.z.string().optional(),
   /** Output preview (truncated text) */
-  outputPreview: import_zod29.z.string().optional(),
+  outputPreview: import_zod30.z.string().optional(),
   /** File path for file operations */
-  filePath: import_zod29.z.string().optional(),
+  filePath: import_zod30.z.string().optional(),
   /** Elapsed time in milliseconds for progress events */
-  elapsedMs: import_zod29.z.number().optional(),
+  elapsedMs: import_zod30.z.number().optional(),
   /** Thinking/reasoning text from Claude */
-  thinking: import_zod29.z.string().optional(),
+  thinking: import_zod30.z.string().optional(),
   /** Timestamp when this event occurred */
-  timestamp: import_zod29.z.string(),
+  timestamp: import_zod30.z.string(),
   /** Whether this is the final event for this scenario */
-  isComplete: import_zod29.z.boolean()
+  isComplete: import_zod30.z.boolean()
 });
 var TRACE_EVENT_PREFIX = "TRACE_EVENT:";
 function parseTraceEventLine(line) {
@@ -1810,40 +1935,40 @@ var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
   TriggerType2["SCHEDULED"] = "SCHEDULED";
   return TriggerType2;
 })(TriggerType || {});
-var TriggerMetadataSchema = import_zod30.z.object({
-  version: import_zod30.z.string().optional(),
-  resourceUpdated: import_zod30.z.array(import_zod30.z.string()).optional(),
-  scheduleId: import_zod30.z.string().optional()
+var TriggerMetadataSchema = import_zod31.z.object({
+  version: import_zod31.z.string().optional(),
+  resourceUpdated: import_zod31.z.array(import_zod31.z.string()).optional(),
+  scheduleId: import_zod31.z.string().optional()
 });
-var TriggerSchema = import_zod30.z.object({
-  id: import_zod30.z.string(),
+var TriggerSchema = import_zod31.z.object({
+  id: import_zod31.z.string(),
   metadata: TriggerMetadataSchema.optional(),
-  type: import_zod30.z.nativeEnum(TriggerType)
+  type: import_zod31.z.nativeEnum(TriggerType)
 });
-var DiffLineTypeSchema = import_zod30.z.enum(["added", "removed", "unchanged"]);
-var DiffLineSchema = import_zod30.z.object({
+var DiffLineTypeSchema = import_zod31.z.enum(["added", "removed", "unchanged"]);
+var DiffLineSchema = import_zod31.z.object({
   type: DiffLineTypeSchema,
-  content: import_zod30.z.string(),
-  lineNumber: import_zod30.z.number()
-});
-var DiffContentSchema = import_zod30.z.object({
-  path: import_zod30.z.string(),
-  expected: import_zod30.z.string(),
-  actual: import_zod30.z.string(),
-  diffLines: import_zod30.z.array(DiffLineSchema),
-  renamedFrom: import_zod30.z.string().optional(),
+  content: import_zod31.z.string(),
+  lineNumber: import_zod31.z.number()
+});
+var DiffContentSchema = import_zod31.z.object({
+  path: import_zod31.z.string(),
+  expected: import_zod31.z.string(),
+  actual: import_zod31.z.string(),
+  diffLines: import_zod31.z.array(DiffLineSchema),
+  renamedFrom: import_zod31.z.string().optional(),
   /** Whether this file is an infrastructure/config file (e.g. .claude/settings.json, .mcp.json) */
-  isInfrastructure: import_zod30.z.boolean().optional()
+  isInfrastructure: import_zod31.z.boolean().optional()
 });
-var CommandExecutionSchema = import_zod30.z.object({
-  command: import_zod30.z.string(),
-  exitCode: import_zod30.z.number(),
-  output: import_zod30.z.string().optional(),
-  duration: import_zod30.z.number()
+var CommandExecutionSchema = import_zod31.z.object({
+  command: import_zod31.z.string(),
+  exitCode: import_zod31.z.number(),
+  output: import_zod31.z.string().optional(),
+  duration: import_zod31.z.number()
 });
-var FileModificationSchema = import_zod30.z.object({
-  path: import_zod30.z.string(),
-  action: import_zod30.z.enum(["created", "modified", "deleted"])
+var FileModificationSchema = import_zod31.z.object({
+  path: import_zod31.z.string(),
+  action: import_zod31.z.enum(["created", "modified", "deleted"])
 });
 var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["NEW"] = "new";
@@ -1851,58 +1976,58 @@ var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["UNCHANGED"] = "unchanged";
   return TemplateFileStatus2;
 })(TemplateFileStatus || {});
-var TemplateFileSchema = import_zod30.z.object({
+var TemplateFileSchema = import_zod31.z.object({
   /** Relative path within the template */
-  path: import_zod30.z.string(),
+  path: import_zod31.z.string(),
   /** Full file content after execution */
-  content: import_zod30.z.string(),
+  content: import_zod31.z.string(),
   /** File status (new, modified, unchanged) */
-  status: import_zod30.z.enum(["new", "modified", "unchanged"]),
+  status: import_zod31.z.enum(["new", "modified", "unchanged"]),
   /** Whether this file is an infrastructure/config file (e.g. .claude/settings.json, .mcp.json) */
-  isInfrastructure: import_zod30.z.boolean().optional()
+  isInfrastructure: import_zod31.z.boolean().optional()
 });
-var ApiCallSchema = import_zod30.z.object({
-  endpoint: import_zod30.z.string(),
-  tokensUsed: import_zod30.z.number(),
-  duration: import_zod30.z.number()
+var ApiCallSchema = import_zod31.z.object({
+  endpoint: import_zod31.z.string(),
+  tokensUsed: import_zod31.z.number(),
+  duration: import_zod31.z.number()
 });
-var ExecutionTraceSchema = import_zod30.z.object({
-  commands: import_zod30.z.array(CommandExecutionSchema),
-  filesModified: import_zod30.z.array(FileModificationSchema),
-  apiCalls: import_zod30.z.array(ApiCallSchema),
-  totalDuration: import_zod30.z.number()
+var ExecutionTraceSchema = import_zod31.z.object({
+  commands: import_zod31.z.array(CommandExecutionSchema),
+  filesModified: import_zod31.z.array(FileModificationSchema),
+  apiCalls: import_zod31.z.array(ApiCallSchema),
+  totalDuration: import_zod31.z.number()
 });
-var RunAnalysisFindingSchema = import_zod30.z.object({
-  category: import_zod30.z.enum([
+var RunAnalysisFindingSchema = import_zod31.z.object({
+  category: import_zod31.z.enum([
     "failure_pattern",
     "cost_waste",
     "flakiness",
     "inefficiency",
     "positive"
   ]),
-  severity: import_zod30.z.enum(["high", "medium", "low"]),
-  description: import_zod30.z.string(),
-  affectedScenarios: import_zod30.z.array(import_zod30.z.string()),
-  recommendation: import_zod30.z.string().optional()
+  severity: import_zod31.z.enum(["high", "medium", "low"]),
+  description: import_zod31.z.string(),
+  affectedScenarios: import_zod31.z.array(import_zod31.z.string()),
+  recommendation: import_zod31.z.string().optional()
 });
-var RunAnalysisSchema = import_zod30.z.object({
-  generatedAt: import_zod30.z.string(),
-  summary: import_zod30.z.string(),
-  findings: import_zod30.z.array(RunAnalysisFindingSchema)
+var RunAnalysisSchema = import_zod31.z.object({
+  generatedAt: import_zod31.z.string(),
+  summary: import_zod31.z.string(),
+  findings: import_zod31.z.array(RunAnalysisFindingSchema)
 });
 var EvalRunSchema = TenantEntitySchema.extend({
   /** Agent ID for this run */
-  agentId: import_zod30.z.string().optional(),
+  agentId: import_zod31.z.string().optional(),
   /** Preset ID that originated this run (optional) */
-  presetId: import_zod30.z.string().optional(),
+  presetId: import_zod31.z.string().optional(),
   /** Scenario IDs to run (always present — resolved server-side from tags when needed) */
-  scenarioIds: import_zod30.z.array(import_zod30.z.string()),
+  scenarioIds: import_zod31.z.array(import_zod31.z.string()),
   /** Current status */
   status: EvalStatusSchema,
   /** Progress percentage (0-100) */
-  progress: import_zod30.z.number(),
+  progress: import_zod31.z.number(),
   /** Results for each scenario/target combination (lazy to break eval-result ↔ eval-run cycle) */
-  results: import_zod30.z.array(import_zod30.z.lazy(() => EvalRunResultSchema)),
+  results: import_zod31.z.array(import_zod31.z.lazy(() => EvalRunResultSchema)),
   /** Aggregated metrics across all results */
   aggregateMetrics: EvalMetricsSchema,
   /** Aggregated LLM trace summary */
@@ -1910,49 +2035,49 @@ var EvalRunSchema = TenantEntitySchema.extend({
   /** What triggered this run */
   trigger: TriggerSchema.optional(),
   /** When the run started (set when evaluation is triggered) */
-  startedAt: import_zod30.z.string().optional(),
+  startedAt: import_zod31.z.string().optional(),
   /** When the run completed */
-  completedAt: import_zod30.z.string().optional(),
+  completedAt: import_zod31.z.string().optional(),
   /** Live trace events captured during execution (for playback on results page) */
-  liveTraceEvents: import_zod30.z.array(LiveTraceEventSchema).optional(),
+  liveTraceEvents: import_zod31.z.array(LiveTraceEventSchema).optional(),
   /** Remote job ID for tracking execution in Dev Machines */
-  jobId: import_zod30.z.string().optional(),
+  jobId: import_zod31.z.string().optional(),
   /** Remote job status from the Dev Machine API (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED) */
-  jobStatus: import_zod30.z.string().optional(),
+  jobStatus: import_zod31.z.string().optional(),
   /** Remote job error message if the job failed */
-  jobError: import_zod30.z.string().optional(),
+  jobError: import_zod31.z.string().optional(),
   /** Timestamp of the last job status check */
-  jobStatusCheckedAt: import_zod30.z.string().optional(),
+  jobStatusCheckedAt: import_zod31.z.string().optional(),
   /** Unified capability IDs */
-  capabilityIds: import_zod30.z.array(import_zod30.z.string()).optional(),
+  capabilityIds: import_zod31.z.array(import_zod31.z.string()).optional(),
   /** Map of capabilityId to capabilityVersionId for version pinning */
-  capabilityVersions: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.string()).optional(),
+  capabilityVersions: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.string()).optional(),
   /** Tags used to select scenarios for this run (for traceability) */
-  tags: import_zod30.z.array(import_zod30.z.string()).optional(),
+  tags: import_zod31.z.array(import_zod31.z.string()).optional(),
   /** How many times each scenario is executed within this eval run. Default: 1. Max: 20. */
-  runsPerScenario: import_zod30.z.number().int().min(1).max(20).optional(),
+  runsPerScenario: import_zod31.z.number().int().min(1).max(20).optional(),
   /** Variable values to substitute in scenario trigger prompts at runtime */
-  variables: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.string()).optional(),
+  variables: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.string()).optional(),
   /** Snapshot of agent configuration captured at run creation time */
-  agentSnapshot: import_zod30.z.object({
-    name: import_zod30.z.string().optional(),
+  agentSnapshot: import_zod31.z.object({
+    name: import_zod31.z.string().optional(),
     agentType: AgentTypeSchema.optional(),
     runCommand: AgentRunCommandSchema.optional(),
-    systemPrompt: import_zod30.z.string().nullable().optional(),
+    systemPrompt: import_zod31.z.string().nullable().optional(),
     /** @deprecated retained for backward compat with stored snapshots */
     modelConfig: ModelConfigSchema.optional(),
-    config: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.unknown()).optional()
+    config: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.unknown()).optional()
   }).optional(),
   /** UUID linking all runs in a comparison group */
-  comparisonGroupId: import_zod30.z.string().optional(),
+  comparisonGroupId: import_zod31.z.string().optional(),
   /** Human-readable label for this variant (e.g., "MCP: Wix Stores") */
-  comparisonLabel: import_zod30.z.string().optional(),
+  comparisonLabel: import_zod31.z.string().optional(),
   /** LLM-generated analysis of the completed run */
   runAnalysis: RunAnalysisSchema.optional(),
   /** IDs of folders this run belongs to (read-only, managed via AddRunToFolder / RemoveRunFromFolder) */
-  folderIds: import_zod30.z.array(import_zod30.z.string()).optional(),
+  folderIds: import_zod31.z.array(import_zod31.z.string()).optional(),
   /** ID of the schedule that triggered this run, if any (read-only) */
-  scheduleId: import_zod30.z.string().optional()
+  scheduleId: import_zod31.z.string().optional()
 });
 var CreateEvalRunInputSchema = EvalRunSchema.omit({
   id: true,
@@ -1968,60 +2093,60 @@ var CreateEvalRunInputSchema = EvalRunSchema.omit({
   agentSnapshot: true
 }).extend({
   /** Optional on input — backend resolves from tags when not provided */
-  scenarioIds: import_zod30.z.array(import_zod30.z.string()).optional()
+  scenarioIds: import_zod31.z.array(import_zod31.z.string()).optional()
 }).refine(
   (data) => data.scenarioIds && data.scenarioIds.length > 0 || data.tags && data.tags.length > 0,
   { message: "Either scenarioIds or tags must be provided" }
 );
-var EvaluationProgressSchema = import_zod30.z.object({
-  runId: import_zod30.z.string(),
-  targetId: import_zod30.z.string(),
-  totalScenarios: import_zod30.z.number(),
-  completedScenarios: import_zod30.z.number(),
-  scenarioProgress: import_zod30.z.array(
-    import_zod30.z.object({
-      scenarioId: import_zod30.z.string(),
-      currentStep: import_zod30.z.string(),
-      error: import_zod30.z.string().optional()
+var EvaluationProgressSchema = import_zod31.z.object({
+  runId: import_zod31.z.string(),
+  targetId: import_zod31.z.string(),
+  totalScenarios: import_zod31.z.number(),
+  completedScenarios: import_zod31.z.number(),
+  scenarioProgress: import_zod31.z.array(
+    import_zod31.z.object({
+      scenarioId: import_zod31.z.string(),
+      currentStep: import_zod31.z.string(),
+      error: import_zod31.z.string().optional()
     })
   ),
-  createdAt: import_zod30.z.number()
-});
-var EvaluationLogSchema = import_zod30.z.object({
-  runId: import_zod30.z.string(),
-  scenarioId: import_zod30.z.string(),
-  log: import_zod30.z.object({
-    level: import_zod30.z.enum(["info", "error", "debug"]),
-    message: import_zod30.z.string().optional(),
-    args: import_zod30.z.array(import_zod30.z.any()).optional(),
-    error: import_zod30.z.string().optional()
+  createdAt: import_zod31.z.number()
+});
+var EvaluationLogSchema = import_zod31.z.object({
+  runId: import_zod31.z.string(),
+  scenarioId: import_zod31.z.string(),
+  log: import_zod31.z.object({
+    level: import_zod31.z.enum(["info", "error", "debug"]),
+    message: import_zod31.z.string().optional(),
+    args: import_zod31.z.array(import_zod31.z.any()).optional(),
+    error: import_zod31.z.string().optional()
   })
 });
 var LLM_TIMEOUT = 12e4;
 
 // src/evaluation/conversation.ts
-var import_zod31 = require("zod");
-var TextBlockSchema = import_zod31.z.object({
-  type: import_zod31.z.literal("text"),
-  text: import_zod31.z.string()
-});
-var ThinkingBlockSchema = import_zod31.z.object({
-  type: import_zod31.z.literal("thinking"),
-  thinking: import_zod31.z.string()
-});
-var ToolUseBlockSchema = import_zod31.z.object({
-  type: import_zod31.z.literal("tool_use"),
-  toolName: import_zod31.z.string(),
-  toolId: import_zod31.z.string(),
-  input: import_zod31.z.unknown()
-});
-var ToolResultBlockSchema = import_zod31.z.object({
-  type: import_zod31.z.literal("tool_result"),
-  toolUseId: import_zod31.z.string(),
-  content: import_zod31.z.string(),
-  isError: import_zod31.z.boolean().optional()
-});
-var ConversationBlockSchema = import_zod31.z.discriminatedUnion("type", [
+var import_zod32 = require("zod");
+var TextBlockSchema = import_zod32.z.object({
+  type: import_zod32.z.literal("text"),
+  text: import_zod32.z.string()
+});
+var ThinkingBlockSchema = import_zod32.z.object({
+  type: import_zod32.z.literal("thinking"),
+  thinking: import_zod32.z.string()
+});
+var ToolUseBlockSchema = import_zod32.z.object({
+  type: import_zod32.z.literal("tool_use"),
+  toolName: import_zod32.z.string(),
+  toolId: import_zod32.z.string(),
+  input: import_zod32.z.unknown()
+});
+var ToolResultBlockSchema = import_zod32.z.object({
+  type: import_zod32.z.literal("tool_result"),
+  toolUseId: import_zod32.z.string(),
+  content: import_zod32.z.string(),
+  isError: import_zod32.z.boolean().optional()
+});
+var ConversationBlockSchema = import_zod32.z.discriminatedUnion("type", [
   TextBlockSchema,
   ThinkingBlockSchema,
   ToolUseBlockSchema,
@@ -2032,22 +2157,22 @@ var ConversationMessageRoles = [
   "user",
   "system"
 ];
-var ConversationMessageSchema = import_zod31.z.object({
-  role: import_zod31.z.enum(ConversationMessageRoles),
-  content: import_zod31.z.array(ConversationBlockSchema),
-  timestamp: import_zod31.z.string()
+var ConversationMessageSchema = import_zod32.z.object({
+  role: import_zod32.z.enum(ConversationMessageRoles),
+  content: import_zod32.z.array(ConversationBlockSchema),
+  timestamp: import_zod32.z.string()
 });
-var ScenarioConversationSchema = import_zod31.z.object({
-  id: import_zod31.z.string(),
-  projectId: import_zod31.z.string(),
-  evalRunId: import_zod31.z.string(),
-  resultId: import_zod31.z.string(),
-  messages: import_zod31.z.array(ConversationMessageSchema),
-  createdAt: import_zod31.z.string()
+var ScenarioConversationSchema = import_zod32.z.object({
+  id: import_zod32.z.string(),
+  projectId: import_zod32.z.string(),
+  evalRunId: import_zod32.z.string(),
+  resultId: import_zod32.z.string(),
+  messages: import_zod32.z.array(ConversationMessageSchema),
+  createdAt: import_zod32.z.string()
 });
-var ConversationResponseSchema = import_zod31.z.object({
-  messages: import_zod31.z.array(ConversationMessageSchema),
-  isPartial: import_zod31.z.boolean()
+var ConversationResponseSchema = import_zod32.z.object({
+  messages: import_zod32.z.array(ConversationMessageSchema),
+  isPartial: import_zod32.z.boolean()
 });
 
 // src/evaluation/eval-result.ts
@@ -2058,98 +2183,98 @@ var AssertionResultStatus = /* @__PURE__ */ ((AssertionResultStatus2) => {
   AssertionResultStatus2["ERROR"] = "error";
   return AssertionResultStatus2;
 })(AssertionResultStatus || {});
-var AssertionResultSchema = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  assertionId: import_zod32.z.string(),
-  assertionType: import_zod32.z.string(),
-  assertionName: import_zod32.z.string(),
-  status: import_zod32.z.enum(AssertionResultStatus),
-  message: import_zod32.z.string().optional(),
-  expected: import_zod32.z.string().optional(),
-  actual: import_zod32.z.string().optional(),
-  duration: import_zod32.z.number().optional(),
-  details: import_zod32.z.record(import_zod32.z.string(), import_zod32.z.unknown()).optional(),
-  llmTraceSteps: import_zod32.z.array(LLMTraceStepSchema).optional()
-});
-var EvalRunResultSchema = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  targetId: import_zod32.z.string(),
-  targetName: import_zod32.z.string().optional(),
+var AssertionResultSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  assertionId: import_zod33.z.string(),
+  assertionType: import_zod33.z.string(),
+  assertionName: import_zod33.z.string(),
+  status: import_zod33.z.enum(AssertionResultStatus),
+  message: import_zod33.z.string().optional(),
+  expected: import_zod33.z.string().optional(),
+  actual: import_zod33.z.string().optional(),
+  duration: import_zod33.z.number().optional(),
+  details: import_zod33.z.record(import_zod33.z.string(), import_zod33.z.unknown()).optional(),
+  llmTraceSteps: import_zod33.z.array(LLMTraceStepSchema).optional()
+});
+var EvalRunResultSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  targetId: import_zod33.z.string(),
+  targetName: import_zod33.z.string().optional(),
   /** SkillVersion ID used for this evaluation (for version tracking) */
-  skillVersionId: import_zod32.z.string().optional(),
+  skillVersionId: import_zod33.z.string().optional(),
   /** SkillVersion semver string (e.g., "1.0.0", "1.2.3") for display */
-  skillVersion: import_zod32.z.string().optional(),
-  scenarioId: import_zod32.z.string(),
-  scenarioName: import_zod32.z.string(),
+  skillVersion: import_zod33.z.string().optional(),
+  scenarioId: import_zod33.z.string(),
+  scenarioName: import_zod33.z.string(),
   /** Snapshot of the trigger prompt used during the run (prevents stale display after edits) */
-  triggerPrompt: import_zod32.z.string().optional(),
+  triggerPrompt: import_zod33.z.string().optional(),
   modelConfig: ModelConfigSchema.optional(),
-  assertionResults: import_zod32.z.array(AssertionResultSchema),
+  assertionResults: import_zod33.z.array(AssertionResultSchema),
   metrics: EvalMetricsSchema.optional(),
-  passed: import_zod32.z.number(),
-  failed: import_zod32.z.number(),
-  passRate: import_zod32.z.number(),
-  duration: import_zod32.z.number(),
-  outputText: import_zod32.z.string().optional(),
-  files: import_zod32.z.array(ExpectedFileSchema).optional(),
-  fileDiffs: import_zod32.z.array(DiffContentSchema).optional(),
+  passed: import_zod33.z.number(),
+  failed: import_zod33.z.number(),
+  passRate: import_zod33.z.number(),
+  duration: import_zod33.z.number(),
+  outputText: import_zod33.z.string().optional(),
+  files: import_zod33.z.array(ExpectedFileSchema).optional(),
+  fileDiffs: import_zod33.z.array(DiffContentSchema).optional(),
   /** Full template files after execution with status indicators */
-  templateFiles: import_zod32.z.array(TemplateFileSchema).optional(),
-  startedAt: import_zod32.z.string().optional(),
-  completedAt: import_zod32.z.string().optional(),
+  templateFiles: import_zod33.z.array(TemplateFileSchema).optional(),
+  startedAt: import_zod33.z.string().optional(),
+  completedAt: import_zod33.z.string().optional(),
   llmTrace: LLMTraceSchema.optional(),
   /** Full conversation messages (only present in transit; stripped before DB storage) */
-  conversation: import_zod32.z.array(ConversationMessageSchema).optional(),
+  conversation: import_zod33.z.array(ConversationMessageSchema).optional(),
   /** 0-based iteration index when a scenario is run multiple times within a single eval run */
-  iterationIndex: import_zod32.z.number().int().min(0).optional()
-});
-var PromptResultSchema = import_zod32.z.object({
-  text: import_zod32.z.string(),
-  files: import_zod32.z.array(import_zod32.z.unknown()).optional(),
-  finishReason: import_zod32.z.string().optional(),
-  reasoning: import_zod32.z.string().optional(),
-  reasoningDetails: import_zod32.z.unknown().optional(),
-  toolCalls: import_zod32.z.array(import_zod32.z.unknown()).optional(),
-  toolResults: import_zod32.z.array(import_zod32.z.unknown()).optional(),
-  warnings: import_zod32.z.array(import_zod32.z.unknown()).optional(),
-  sources: import_zod32.z.array(import_zod32.z.unknown()).optional(),
-  steps: import_zod32.z.array(import_zod32.z.unknown()),
-  generationTimeMs: import_zod32.z.number(),
-  prompt: import_zod32.z.string(),
-  systemPrompt: import_zod32.z.string(),
-  usage: import_zod32.z.object({
-    totalTokens: import_zod32.z.number().optional(),
-    totalMicrocentsSpent: import_zod32.z.number().optional()
+  iterationIndex: import_zod33.z.number().int().min(0).optional()
+});
+var PromptResultSchema = import_zod33.z.object({
+  text: import_zod33.z.string(),
+  files: import_zod33.z.array(import_zod33.z.unknown()).optional(),
+  finishReason: import_zod33.z.string().optional(),
+  reasoning: import_zod33.z.string().optional(),
+  reasoningDetails: import_zod33.z.unknown().optional(),
+  toolCalls: import_zod33.z.array(import_zod33.z.unknown()).optional(),
+  toolResults: import_zod33.z.array(import_zod33.z.unknown()).optional(),
+  warnings: import_zod33.z.array(import_zod33.z.unknown()).optional(),
+  sources: import_zod33.z.array(import_zod33.z.unknown()).optional(),
+  steps: import_zod33.z.array(import_zod33.z.unknown()),
+  generationTimeMs: import_zod33.z.number(),
+  prompt: import_zod33.z.string(),
+  systemPrompt: import_zod33.z.string(),
+  usage: import_zod33.z.object({
+    totalTokens: import_zod33.z.number().optional(),
+    totalMicrocentsSpent: import_zod33.z.number().optional()
   })
 });
-var EvaluationResultSchema = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  runId: import_zod32.z.string(),
-  timestamp: import_zod32.z.number(),
+var EvaluationResultSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  runId: import_zod33.z.string(),
+  timestamp: import_zod33.z.number(),
   promptResult: PromptResultSchema,
-  testResults: import_zod32.z.array(import_zod32.z.unknown()),
-  tags: import_zod32.z.array(import_zod32.z.string()).optional(),
-  feedback: import_zod32.z.string().optional(),
-  score: import_zod32.z.number(),
-  suiteId: import_zod32.z.string().optional()
-});
-var LeanEvaluationResultSchema = import_zod32.z.object({
-  id: import_zod32.z.string(),
-  runId: import_zod32.z.string(),
-  timestamp: import_zod32.z.number(),
-  tags: import_zod32.z.array(import_zod32.z.string()).optional(),
-  scenarioId: import_zod32.z.string(),
-  scenarioVersion: import_zod32.z.number().optional(),
-  targetId: import_zod32.z.string(),
-  targetVersion: import_zod32.z.number().optional(),
-  suiteId: import_zod32.z.string().optional(),
-  score: import_zod32.z.number(),
-  time: import_zod32.z.number().optional(),
-  microcentsSpent: import_zod32.z.number().optional()
+  testResults: import_zod33.z.array(import_zod33.z.unknown()),
+  tags: import_zod33.z.array(import_zod33.z.string()).optional(),
+  feedback: import_zod33.z.string().optional(),
+  score: import_zod33.z.number(),
+  suiteId: import_zod33.z.string().optional()
+});
+var LeanEvaluationResultSchema = import_zod33.z.object({
+  id: import_zod33.z.string(),
+  runId: import_zod33.z.string(),
+  timestamp: import_zod33.z.number(),
+  tags: import_zod33.z.array(import_zod33.z.string()).optional(),
+  scenarioId: import_zod33.z.string(),
+  scenarioVersion: import_zod33.z.number().optional(),
+  targetId: import_zod33.z.string(),
+  targetVersion: import_zod33.z.number().optional(),
+  suiteId: import_zod33.z.string().optional(),
+  score: import_zod33.z.number(),
+  time: import_zod33.z.number().optional(),
+  microcentsSpent: import_zod33.z.number().optional()
 });
 
 // src/evaluation/eval-run-folder.ts
-var import_zod33 = require("zod");
+var import_zod34 = require("zod");
 var EvalRunFolderSchema = TenantEntitySchema.extend({});
 var CreateEvalRunFolderInputSchema = EvalRunFolderSchema.omit({
   id: true,
@@ -2163,26 +2288,26 @@ var UpdateEvalRunFolderInputSchema = EvalRunFolderSchema.omit({
   updatedAt: true,
   deleted: true
 }).partial();
-var EvalRunFolderMembershipSchema = import_zod33.z.object({
-  folderId: import_zod33.z.string(),
-  evalRunId: import_zod33.z.string(),
-  projectId: import_zod33.z.string(),
-  createdAt: import_zod33.z.string()
+var EvalRunFolderMembershipSchema = import_zod34.z.object({
+  folderId: import_zod34.z.string(),
+  evalRunId: import_zod34.z.string(),
+  projectId: import_zod34.z.string(),
+  createdAt: import_zod34.z.string()
 });
 
 // src/project/project.ts
-var import_zod34 = require("zod");
+var import_zod35 = require("zod");
 var ProjectSchema = BaseEntitySchema.extend({
-  appId: import_zod34.z.string().optional().describe("The ID of the app in Dev Center"),
-  scenarioTags: import_zod34.z.array(import_zod34.z.string()).optional().describe("Project-level tag vocabulary for scenarios"),
+  appId: import_zod35.z.string().optional().describe("The ID of the app in Dev Center"),
+  scenarioTags: import_zod35.z.array(import_zod35.z.string()).optional().describe("Project-level tag vocabulary for scenarios"),
   /** Per-project Wix auth token (write-only — never returned in GET responses). null = clear. */
-  wixAuthToken: import_zod34.z.string().nullable().optional().describe("Wix auth token for CLI/MCP authentication (encrypted at rest)"),
+  wixAuthToken: import_zod35.z.string().nullable().optional().describe("Wix auth token for CLI/MCP authentication (encrypted at rest)"),
   /** Per-project Base44 auth file content (write-only — never returned in GET responses). null = clear. */
-  base44AuthFile: import_zod34.z.string().nullable().optional().describe("Base64-encoded Base44 auth file content (encrypted at rest)"),
+  base44AuthFile: import_zod35.z.string().nullable().optional().describe("Base64-encoded Base44 auth file content (encrypted at rest)"),
   /** Resolved at runtime from the encrypted Wix auth token */
-  wixAuthEmail: import_zod34.z.string().optional().describe("Email associated with the Wix auth token (resolved at runtime)"),
+  wixAuthEmail: import_zod35.z.string().optional().describe("Email associated with the Wix auth token (resolved at runtime)"),
   /** Resolved at runtime from the encrypted Base44 auth file */
-  base44AuthEmail: import_zod34.z.string().optional().describe("Email from the Base44 auth file (resolved at runtime)")
+  base44AuthEmail: import_zod35.z.string().optional().describe("Email from the Base44 auth file (resolved at runtime)")
 });
 var CreateProjectInputSchema = ProjectSchema.omit({
   id: true,
@@ -2192,34 +2317,34 @@ var CreateProjectInputSchema = ProjectSchema.omit({
   wixAuthEmail: true,
   base44AuthEmail: true
 }).extend({
-  appId: import_zod34.z.string().describe(
+  appId: import_zod35.z.string().describe(
     "Required: The ID of the app in Dev Center for credential scoping"
   )
 });
 var UpdateProjectInputSchema = CreateProjectInputSchema.partial();
 
 // src/template/template.ts
-var import_zod35 = require("zod");
-var SourceFileSchema = import_zod35.z.object({
-  path: import_zod35.z.string().min(1),
-  content: import_zod35.z.string()
+var import_zod36 = require("zod");
+var SourceFileSchema = import_zod36.z.object({
+  path: import_zod36.z.string().min(1),
+  content: import_zod36.z.string()
 });
-var ExtraFileSchema = import_zod35.z.object({
-  path: import_zod35.z.string().min(1),
-  content: import_zod35.z.string().optional(),
+var ExtraFileSchema = import_zod36.z.object({
+  path: import_zod36.z.string().min(1),
+  content: import_zod36.z.string().optional(),
   gitSource: GitHubSourceSchema.optional()
 }).refine((ef) => ef.content !== void 0 || ef.gitSource !== void 0, {
   message: "ExtraFile must have either content or gitSource"
 });
-var TemplateFileEntrySchema = import_zod35.z.object({
-  path: import_zod35.z.string().min(1),
-  content: import_zod35.z.string(),
-  extra: import_zod35.z.boolean()
+var TemplateFileEntrySchema = import_zod36.z.object({
+  path: import_zod36.z.string().min(1),
+  content: import_zod36.z.string(),
+  extra: import_zod36.z.boolean()
 });
 var TemplateSchema = TenantEntitySchema.extend({
   source: GitHubSourceSchema.optional(),
-  sourceFiles: import_zod35.z.array(SourceFileSchema).optional(),
-  extraFiles: import_zod35.z.array(ExtraFileSchema).optional()
+  sourceFiles: import_zod36.z.array(SourceFileSchema).optional(),
+  extraFiles: import_zod36.z.array(ExtraFileSchema).optional()
 });
 var singleSourceKind = (t) => !(t.source && t.sourceFiles?.length);
 var singleSourceKindError = {
@@ -2239,66 +2364,66 @@ var UpdateTemplateInputSchema = TemplateSchema.omit({
 }).partial().refine(singleSourceKind, singleSourceKindError);
 
 // src/agent/agent-config.ts
-var import_zod36 = require("zod");
-var BaseAgentConfigSchema = import_zod36.z.object({
+var import_zod37 = require("zod");
+var BaseAgentConfigSchema = import_zod37.z.object({
   /** Model ID (Claude or OpenAI). */
   model: AnyModelSchema.optional(),
   /** Sampling temperature (0–1). */
-  temperature: import_zod36.z.number().min(0).max(1).optional(),
+  temperature: import_zod37.z.number().min(0).max(1).optional(),
   /** Max output tokens per turn. */
-  maxTokens: import_zod36.z.number().int().min(1).optional(),
+  maxTokens: import_zod37.z.number().int().min(1).optional(),
   /** Number of agentic turns. 0 = unlimited. */
-  maxTurns: import_zod36.z.number().int().min(0).optional(),
+  maxTurns: import_zod37.z.number().int().min(0).optional(),
   /** Execution timeout in milliseconds. Overrides the default maxTurns-based calculation. */
-  maxDurationMs: import_zod36.z.number().int().min(0).optional()
+  maxDurationMs: import_zod37.z.number().int().min(0).optional()
 });
-var EffortLevelSchema = import_zod36.z.enum(["low", "medium", "high", "max"]);
+var EffortLevelSchema = import_zod37.z.enum(["low", "medium", "high", "max"]);
 var ClaudeCodeConfigSchema = BaseAgentConfigSchema.extend({
   /** Extended thinking token budget. */
-  maxThinkingTokens: import_zod36.z.number().int().min(0).optional(),
+  maxThinkingTokens: import_zod37.z.number().int().min(0).optional(),
   /** Override the default allowedTools list passed to the SDK. */
-  allowedTools: import_zod36.z.array(import_zod36.z.string()).optional(),
+  allowedTools: import_zod37.z.array(import_zod37.z.string()).optional(),
   /** Tools to remove from the model's context entirely. */
-  disallowedTools: import_zod36.z.array(import_zod36.z.string()).optional(),
+  disallowedTools: import_zod37.z.array(import_zod37.z.string()).optional(),
   /** Controls thinking depth: low, medium, high, max. */
   effort: EffortLevelSchema.optional(),
   /** Maximum USD spend per run. Stops execution when reached. */
-  maxBudgetUsd: import_zod36.z.number().min(0).optional()
+  maxBudgetUsd: import_zod37.z.number().min(0).optional()
 });
-var PermissionValueSchema = import_zod36.z.enum(["allow", "deny"]);
-var OpenCodePermissionSchema = import_zod36.z.record(
-  import_zod36.z.string(),
-  import_zod36.z.union([PermissionValueSchema, import_zod36.z.record(import_zod36.z.string(), PermissionValueSchema)])
+var PermissionValueSchema = import_zod37.z.enum(["allow", "deny"]);
+var OpenCodePermissionSchema = import_zod37.z.record(
+  import_zod37.z.string(),
+  import_zod37.z.union([PermissionValueSchema, import_zod37.z.record(import_zod37.z.string(), PermissionValueSchema)])
 );
-var ThinkingVariantSchema = import_zod36.z.enum(["high", "low", "none"]);
+var ThinkingVariantSchema = import_zod37.z.enum(["high", "low", "none"]);
 var OpenCodeConfigSchema = BaseAgentConfigSchema.extend({
   /** Permission overrides (defaults: allow-all). */
   permission: OpenCodePermissionSchema.optional(),
   /** Maps to `--variant` CLI flag. 'none' omits --thinking entirely. Default: 'high'. */
   thinkingVariant: ThinkingVariantSchema.optional(),
   /** Nucleus sampling (0–1). Alternative to temperature. */
-  topP: import_zod36.z.number().min(0).max(1).optional()
+  topP: import_zod37.z.number().min(0).max(1).optional()
 }).omit({ maxTokens: true });
-var ReasoningEffortSchema = import_zod36.z.enum(["low", "medium", "high"]);
+var ReasoningEffortSchema = import_zod37.z.enum(["low", "medium", "high"]);
 var SimpleAgentConfigSchema = BaseAgentConfigSchema.extend({
   /** Anthropic thinking budget in tokens. Default: 10 000. */
-  thinkingBudgetTokens: import_zod36.z.number().int().min(0).optional(),
+  thinkingBudgetTokens: import_zod37.z.number().int().min(0).optional(),
   /** Nucleus sampling (0–1). Alternative to temperature. */
-  topP: import_zod36.z.number().min(0).max(1).optional(),
+  topP: import_zod37.z.number().min(0).max(1).optional(),
   /** Integer seed for deterministic/reproducible results (if model supports it). */
-  seed: import_zod36.z.number().int().optional(),
+  seed: import_zod37.z.number().int().optional(),
   /** Stop sequences — model stops when generating any of these strings. */
-  stopSequences: import_zod36.z.array(import_zod36.z.string()).optional(),
+  stopSequences: import_zod37.z.array(import_zod37.z.string()).optional(),
   /** OpenAI reasoning effort level. Default: 'high'. */
   reasoningEffort: ReasoningEffortSchema.optional(),
   /** Frequency penalty (−2 to 2). Reduces repetition of same tokens. */
-  frequencyPenalty: import_zod36.z.number().min(-2).max(2).optional(),
+  frequencyPenalty: import_zod37.z.number().min(-2).max(2).optional(),
   /** Presence penalty (−2 to 2). Encourages topic diversity. */
-  presencePenalty: import_zod36.z.number().min(-2).max(2).optional()
+  presencePenalty: import_zod37.z.number().min(-2).max(2).optional()
 });
 
 // src/schedule/eval-schedule.ts
-var import_zod37 = require("zod");
+var import_zod38 = require("zod");
 var FrequencyType = /* @__PURE__ */ ((FrequencyType2) => {
   FrequencyType2["DAILY"] = "daily";
   FrequencyType2["WEEKDAY"] = "weekday";
@@ -2308,31 +2433,31 @@ var FrequencyType = /* @__PURE__ */ ((FrequencyType2) => {
 })(FrequencyType || {});
 var EvalScheduleSchema = TenantEntitySchema.extend({
   /** Whether the schedule is active */
-  enabled: import_zod37.z.boolean(),
+  enabled: import_zod38.z.boolean(),
   /** Test suite to run */
-  suiteId: import_zod37.z.string(),
+  suiteId: import_zod38.z.string(),
   /** Preset that provides agent + entities for this schedule */
-  presetId: import_zod37.z.string(),
+  presetId: import_zod38.z.string(),
   /** How often to run */
-  frequencyType: import_zod37.z.nativeEnum(FrequencyType),
+  frequencyType: import_zod38.z.nativeEnum(FrequencyType),
   /** Time of day in 24h format (HH:MM), hours 00-23, minutes 00-59 */
-  timeOfDay: import_zod37.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+  timeOfDay: import_zod38.z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
   /** Day of week (0=Sun, 6=Sat) for weekly schedules */
-  dayOfWeek: import_zod37.z.number().min(0).max(6).optional(),
+  dayOfWeek: import_zod38.z.number().min(0).max(6).optional(),
   /** Day of month (1-31) for monthly schedules */
-  dayOfMonth: import_zod37.z.number().min(1).max(31).optional(),
+  dayOfMonth: import_zod38.z.number().min(1).max(31).optional(),
   /** IANA timezone (e.g., 'America/New_York') */
-  timezone: import_zod37.z.string(),
+  timezone: import_zod38.z.string(),
   /** ID of the last eval run created by this schedule */
-  lastRunId: import_zod37.z.string().optional(),
+  lastRunId: import_zod38.z.string().optional(),
   /** Denormalized status of the last run */
-  lastRunStatus: import_zod37.z.string().optional(),
+  lastRunStatus: import_zod38.z.string().optional(),
   /** ISO timestamp of the last run */
-  lastRunAt: import_zod37.z.string().optional(),
+  lastRunAt: import_zod38.z.string().optional(),
   /** Next scheduled run time in UTC (pre-computed for efficient querying, set by backend) */
-  nextRunAt: import_zod37.z.string().optional(),
+  nextRunAt: import_zod38.z.string().optional(),
   /** Per-scenario variable values forwarded to runs triggered by this schedule (scenarioId → varName → value) */
-  variables: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.record(import_zod37.z.string(), import_zod37.z.string())).optional()
+  variables: import_zod38.z.record(import_zod38.z.string(), import_zod38.z.record(import_zod38.z.string(), import_zod38.z.string())).optional()
 });
 function isValidTimezone(tz) {
   try {
@@ -2345,14 +2470,14 @@ function isValidTimezone(tz) {
 function validateScheduleFields(data, ctx, options) {
   if (data.frequencyType === "weekly" /* WEEKLY */ && data.dayOfWeek == null) {
     ctx.addIssue({
-      code: import_zod37.z.ZodIssueCode.custom,
+      code: import_zod38.z.ZodIssueCode.custom,
       message: "dayOfWeek is required for weekly schedules",
       path: ["dayOfWeek"]
     });
   }
   if (data.frequencyType === "monthly" /* MONTHLY */ && data.dayOfMonth == null) {
     ctx.addIssue({
-      code: import_zod37.z.ZodIssueCode.custom,
+      code: import_zod38.z.ZodIssueCode.custom,
       message: "dayOfMonth is required for monthly schedules",
       path: ["dayOfMonth"]
     });
@@ -2360,7 +2485,7 @@ function validateScheduleFields(data, ctx, options) {
   const shouldValidateTz = options.partial ? data.timezone !== void 0 : true;
   if (shouldValidateTz && !isValidTimezone(data.timezone)) {
     ctx.addIssue({
-      code: import_zod37.z.ZodIssueCode.custom,
+      code: import_zod38.z.ZodIssueCode.custom,
       message: "Invalid IANA timezone",
       path: ["timezone"]
     });
@@ -2524,6 +2649,7 @@ var UpdateEvalScheduleInputSchema = BaseCreateScheduleSchema.partial().superRefi
   PresetSchema,
   ProjectSchema,
   PromptResultSchema,
+  ProvisionedSiteSchema,
   RUN_COMMAND_LABELS,
   ReasoningEffortSchema,
   RuleSchema,
@@ -2531,13 +2657,20 @@ var UpdateEvalScheduleInputSchema = BaseCreateScheduleSchema.partial().superRefi
   RunAnalysisFindingSchema,
   RunAnalysisSchema,
   SEMVER_REGEX,
+  SITE_SETUP_EXCLUSIVE_VARIABLES,
   SKILL_FOLDER_NAME_REGEX,
   SYSTEM_ASSERTIONS,
   SYSTEM_ASSERTION_IDS,
   ScenarioAssertionLinkSchema,
   ScenarioConversationSchema,
   SimpleAgentConfigSchema,
+  SiteBootstrapHttpMethodSchema,
+  SiteBootstrapResultSchema,
+  SiteBootstrapSchema,
+  SiteBootstrapStepResultSchema,
+  SiteBootstrapStepSchema,
   SiteConfigTestSchema,
+  SiteSetupConfigSchema,
   SkillFileSchema,
   SkillMetadataSchema,
   SkillSchema,
@@ -2591,6 +2724,7 @@ var UpdateEvalScheduleInputSchema = BaseCreateScheduleSchema.partial().superRefi
   UpdateTestScenarioInputSchema,
   UpdateTestSuiteInputSchema,
   VitestTestSchema,
+  WixSiteSummarySchema,
   capabilityToMcp,
   capabilityToRule,
   capabilityToSkill,
@@ -2598,6 +2732,7 @@ var UpdateEvalScheduleInputSchema = BaseCreateScheduleSchema.partial().superRefi
   capabilityToSubAgent,
   capabilityVersionToSkillVersion,
   classifyAssertionRef,
+  extractVariableNamesFromPrompt,
   formatTraceEventLine,
   getSystemAssertion,
   getSystemAssertions,
@@ -2610,7 +2745,10 @@ var UpdateEvalScheduleInputSchema = BaseCreateScheduleSchema.partial().superRefi
   normalizeModelId,
   parseBuildCommandToArgv,
   parseTraceEventLine,
+  promptUsesSiteSetupExclusiveVariables,
+  resolveWixOriginTemplateId,
   validateAssertionConfig,
-  validateBuildPassedParamsInAssertionLinks
+  validateBuildPassedParamsInAssertionLinks,
+  validateSiteSetupExclusivity
 });
 //# sourceMappingURL=index.js.map