@wix/evalforge-types 0.74.0 → 0.76.0

package/build/index.mjs

@@ -340,25 +340,19 @@ import { z as z9 } from "zod";
 var PresetSchema = TenantEntitySchema.extend({
   /** Agent ID for this preset */
   agentId: z9.string(),
-  /** Skill IDs included in this preset */
-  skillIds: z9.array(z9.string()).default([]),
-  /** Optional map of skillId → skillVersionId for version pinning */
-  skillVersions: z9.record(z9.string(), z9.string()).optional(),
-  /** MCP server IDs included in this preset */
-  mcpIds: z9.array(z9.string()).default([]),
-  /** Sub-agent IDs included in this preset */
-  subAgentIds: z9.array(z9.string()).default([]),
-  /** Rule IDs included in this preset */
-  ruleIds: z9.array(z9.string()).default([])
-});
-var atLeastOneEntity = (data) => (data.skillIds?.length ?? 0) > 0 || (data.mcpIds?.length ?? 0) > 0 || (data.subAgentIds?.length ?? 0) > 0 || (data.ruleIds?.length ?? 0) > 0;
-var AT_LEAST_ONE_ENTITY_MESSAGE = "At least one of skillIds, mcpIds, subAgentIds, or ruleIds must be non-empty";
+  /** Unified capability IDs */
+  capabilityIds: z9.array(z9.string()).optional(),
+  /** Map of capabilityId to capabilityVersionId for version pinning */
+  capabilityVersions: z9.record(z9.string(), z9.string()).optional()
+});
+var hasCapabilities = (data) => (data.capabilityIds?.length ?? 0) > 0;
+var CAPABILITY_IDS_REQUIRED_MESSAGE = "capabilityIds must be non-empty";
 var CreatePresetInputSchema = PresetSchema.omit({
   id: true,
   createdAt: true,
   updatedAt: true,
   deleted: true
-}).refine(atLeastOneEntity, { message: AT_LEAST_ONE_ENTITY_MESSAGE });
+}).refine(hasCapabilities, { message: CAPABILITY_IDS_REQUIRED_MESSAGE });
 var UpdatePresetInputSchema = PresetSchema.omit({
   id: true,
   createdAt: true,
@@ -366,11 +360,179 @@ var UpdatePresetInputSchema = PresetSchema.omit({
   deleted: true
 }).partial();
 
+// src/target/capability.ts
+import { z as z10 } from "zod";
+var CapabilityTypeSchema = z10.enum([
+  "SKILL",
+  "SUB_AGENT",
+  "RULE",
+  "MCP"
+]);
+var CAPABILITY_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function isValidCapabilityName(name) {
+  return typeof name === "string" && name.length > 0 && CAPABILITY_NAME_REGEX.test(name);
+}
+var KEBAB_CASE_MESSAGE2 = "Name must be in kebab-case (lowercase letters, numbers, hyphens only, e.g. my-capability)";
+var CapabilityContentSchema = z10.record(z10.string(), z10.unknown());
+var CapabilityVersionOriginSchema = z10.enum(["manual", "pr", "master"]);
+var CapabilitySchema = TenantEntitySchema.extend({
+  capabilityType: CapabilityTypeSchema,
+  source: GitHubSourceSchema.optional()
+});
+var CapabilityVersionSchema = z10.object({
+  id: z10.string(),
+  projectId: z10.string(),
+  capabilityId: z10.string(),
+  version: z10.string(),
+  origin: CapabilityVersionOriginSchema,
+  source: GitHubSourceSchema.optional(),
+  content: CapabilityContentSchema.optional(),
+  notes: z10.string().optional(),
+  createdAt: z10.string()
+});
+var CapabilityWithLatestVersionSchema = CapabilitySchema.extend({
+  latestVersion: CapabilityVersionSchema.optional()
+});
+var CapabilityInputBaseSchema = CapabilitySchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+  deleted: true,
+  description: true,
+  source: true
+}).extend({
+  description: z10.string().optional(),
+  source: GitHubSourceSchema.optional()
+});
+var InitialCapabilityVersionInputSchema = z10.object({
+  content: CapabilityContentSchema.optional(),
+  notes: z10.string().optional(),
+  source: GitHubSourceSchema.optional(),
+  version: z10.string().optional(),
+  origin: CapabilityVersionOriginSchema.optional()
+});
+var CreateCapabilityInputSchema = CapabilityInputBaseSchema.extend({
+  initialVersion: InitialCapabilityVersionInputSchema.optional()
+}).refine((data) => isValidCapabilityName(data.name), {
+  message: KEBAB_CASE_MESSAGE2,
+  path: ["name"]
+});
+var UpdateCapabilityInputSchema = CapabilityInputBaseSchema.omit({
+  capabilityType: true
+}).partial().refine(
+  (data) => data.name === void 0 || isValidCapabilityName(data.name),
+  { message: KEBAB_CASE_MESSAGE2, path: ["name"] }
+);
+var CreateCapabilityVersionInputSchema = z10.object({
+  source: GitHubSourceSchema.optional(),
+  version: z10.string().min(1),
+  notes: z10.string().optional(),
+  origin: CapabilityVersionOriginSchema.optional(),
+  content: CapabilityContentSchema.optional()
+});
+
+// src/target/capability-converters.ts
+function capabilityToSkill(cap) {
+  return {
+    id: cap.id,
+    projectId: cap.projectId,
+    name: cap.name,
+    description: cap.description,
+    source: cap.source,
+    createdAt: cap.createdAt,
+    updatedAt: cap.updatedAt,
+    deleted: cap.deleted
+  };
+}
+function capabilityVersionToSkillVersion(cv) {
+  const content = cv.content;
+  return {
+    id: cv.id,
+    projectId: cv.projectId,
+    skillId: cv.capabilityId,
+    version: cv.version,
+    origin: cv.origin,
+    source: cv.source,
+    files: content?.files,
+    notes: cv.notes,
+    createdAt: cv.createdAt
+  };
+}
+function capabilityToSkillWithLatestVersion(cap) {
+  const skill = capabilityToSkill(cap);
+  const latestVersion = cap.latestVersion ? capabilityVersionToSkillVersion(cap.latestVersion) : void 0;
+  return { ...skill, latestVersion };
+}
+function capabilityToSubAgent(cap) {
+  const content = cap.latestVersion?.content;
+  return {
+    id: cap.id,
+    projectId: cap.projectId,
+    name: cap.name,
+    description: cap.description,
+    subAgentMd: content?.subAgentMd ?? "",
+    source: cap.source,
+    createdAt: cap.createdAt,
+    updatedAt: cap.updatedAt,
+    deleted: cap.deleted
+  };
+}
+function capabilityToRule(cap) {
+  const content = cap.latestVersion?.content;
+  return {
+    id: cap.id,
+    projectId: cap.projectId,
+    name: cap.name,
+    description: cap.description,
+    ruleType: content?.ruleType ?? "claude-md",
+    content: content?.content ?? "",
+    createdAt: cap.createdAt,
+    updatedAt: cap.updatedAt,
+    deleted: cap.deleted
+  };
+}
+function capabilityToMcp(cap) {
+  const content = cap.latestVersion?.content;
+  return {
+    id: cap.id,
+    projectId: cap.projectId,
+    name: cap.name,
+    description: cap.description,
+    config: content?.config ?? {},
+    createdAt: cap.createdAt,
+    updatedAt: cap.updatedAt,
+    deleted: cap.deleted
+  };
+}
+function groupCapabilitiesByType(capabilities) {
+  const skills = [];
+  const subAgents = [];
+  const rules = [];
+  const mcps = [];
+  for (const cap of capabilities) {
+    switch (cap.capabilityType) {
+      case "SKILL":
+        skills.push(capabilityToSkillWithLatestVersion(cap));
+        break;
+      case "SUB_AGENT":
+        subAgents.push(capabilityToSubAgent(cap));
+        break;
+      case "RULE":
+        rules.push(capabilityToRule(cap));
+        break;
+      case "MCP":
+        mcps.push(capabilityToMcp(cap));
+        break;
+    }
+  }
+  return { skills, subAgents, rules, mcps };
+}
+
 // src/test/index.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/test/base.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var TestType = /* @__PURE__ */ ((TestType2) => {
   TestType2["LLM"] = "LLM";
   TestType2["TOOL"] = "TOOL";
@@ -383,7 +545,7 @@ var TestType = /* @__PURE__ */ ((TestType2) => {
   TestType2["PLAYWRIGHT_NL"] = "PLAYWRIGHT_NL";
   return TestType2;
 })(TestType || {});
-var TestTypeSchema = z10.enum(TestType);
+var TestTypeSchema = z11.enum(TestType);
 var TestImportance = /* @__PURE__ */ ((TestImportance2) => {
   TestImportance2["LOW"] = "low";
   TestImportance2["MEDIUM"] = "medium";
@@ -391,153 +553,153 @@ var TestImportance = /* @__PURE__ */ ((TestImportance2) => {
   TestImportance2["CRITICAL"] = "critical";
   return TestImportance2;
 })(TestImportance || {});
-var TestImportanceSchema = z10.enum(TestImportance);
-var BaseTestSchema = z10.object({
-  id: z10.string(),
+var TestImportanceSchema = z11.enum(TestImportance);
+var BaseTestSchema = z11.object({
+  id: z11.string(),
   type: TestTypeSchema,
-  name: z10.string().min(3),
-  description: z10.string().optional(),
+  name: z11.string().min(3),
+  description: z11.string().optional(),
   importance: TestImportanceSchema.optional()
 });
 
 // src/test/llm.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var LLMTestSchema = BaseTestSchema.extend({
-  type: z11.literal("LLM" /* LLM */),
+  type: z12.literal("LLM" /* LLM */),
   /** Maximum steps for the LLM to take */
-  maxSteps: z11.number().min(1).max(100),
+  maxSteps: z12.number().min(1).max(100),
   /** Prompt to send to the evaluator */
-  prompt: z11.string().min(1),
+  prompt: z12.string().min(1),
   /** ID of the evaluator agent to use */
-  evaluatorId: z11.string()
+  evaluatorId: z12.string()
 });
 
 // src/test/tool.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var ToolTestSchema = BaseTestSchema.extend({
-  type: z12.literal("TOOL" /* TOOL */),
+  type: z13.literal("TOOL" /* TOOL */),
   /** Name of the tool that should be called */
-  toolName: z12.string().min(3),
+  toolName: z13.string().min(3),
   /** Expected arguments for the tool call */
-  args: z12.record(z12.string(), z12.any()),
+  args: z13.record(z13.string(), z13.any()),
   /** Expected content in the tool results */
-  resultsContent: z12.string()
+  resultsContent: z13.string()
 });
 
 // src/test/site-config.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var SiteConfigTestSchema = BaseTestSchema.extend({
-  type: z13.literal("SITE_CONFIG" /* SITE_CONFIG */),
+  type: z14.literal("SITE_CONFIG" /* SITE_CONFIG */),
   /** URL to call */
-  url: z13.string().url(),
+  url: z14.string().url(),
   /** HTTP method */
-  method: z13.enum(["GET", "POST"]),
+  method: z14.enum(["GET", "POST"]),
   /** Request body (for POST) */
-  body: z13.string().optional(),
+  body: z14.string().optional(),
   /** Expected HTTP status code */
-  expectedStatusCode: z13.number().int().min(100).max(599),
+  expectedStatusCode: z14.number().int().min(100).max(599),
   /** Expected response content */
-  expectedResponse: z13.string().optional(),
+  expectedResponse: z14.string().optional(),
   /** JMESPath expression to extract from response */
-  expectedResponseJMESPath: z13.string().optional()
+  expectedResponseJMESPath: z14.string().optional()
 });
 
 // src/test/command-execution.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var AllowedCommands = [
   "yarn install --no-immutable && yarn build",
   "npm run build",
   "yarn typecheck"
 ];
 var CommandExecutionTestSchema = BaseTestSchema.extend({
-  type: z14.literal("COMMAND_EXECUTION" /* COMMAND_EXECUTION */),
+  type: z15.literal("COMMAND_EXECUTION" /* COMMAND_EXECUTION */),
   /** Command to execute (must be in AllowedCommands) */
-  command: z14.string().refine((value) => AllowedCommands.includes(value), {
+  command: z15.string().refine((value) => AllowedCommands.includes(value), {
     message: `Command must be one of: ${AllowedCommands.join(", ")}`
   }),
   /** Expected exit code (default: 0) */
-  expectedExitCode: z14.number().default(0).optional()
+  expectedExitCode: z15.number().default(0).optional()
 });
 
 // src/test/file-presence.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var FilePresenceTestSchema = BaseTestSchema.extend({
-  type: z15.literal("FILE_PRESENCE" /* FILE_PRESENCE */),
+  type: z16.literal("FILE_PRESENCE" /* FILE_PRESENCE */),
   /** Paths to check */
-  paths: z15.array(z15.string()),
+  paths: z16.array(z16.string()),
   /** Whether files should exist (true) or not exist (false) */
-  shouldExist: z15.boolean()
+  shouldExist: z16.boolean()
 });
 
 // src/test/file-content.ts
-import { z as z16 } from "zod";
-var FileContentCheckSchema = z16.object({
+import { z as z17 } from "zod";
+var FileContentCheckSchema = z17.object({
   /** Strings that must be present in the file */
-  contains: z16.array(z16.string()).optional(),
+  contains: z17.array(z17.string()).optional(),
   /** Strings that must NOT be present in the file */
-  notContains: z16.array(z16.string()).optional(),
+  notContains: z17.array(z17.string()).optional(),
   /** Regex pattern the content must match */
-  matches: z16.string().optional(),
+  matches: z17.string().optional(),
   /** JSON path checks for structured content */
-  jsonPath: z16.array(
-    z16.object({
-      path: z16.string(),
-      value: z16.unknown()
+  jsonPath: z17.array(
+    z17.object({
+      path: z17.string(),
+      value: z17.unknown()
     })
   ).optional(),
   /** Lines that should be added (for diff checking) */
-  added: z16.array(z16.string()).optional(),
+  added: z17.array(z17.string()).optional(),
   /** Lines that should be removed (for diff checking) */
-  removed: z16.array(z16.string()).optional()
+  removed: z17.array(z17.string()).optional()
 });
 var FileContentTestSchema = BaseTestSchema.extend({
-  type: z16.literal("FILE_CONTENT" /* FILE_CONTENT */),
+  type: z17.literal("FILE_CONTENT" /* FILE_CONTENT */),
   /** Path to the file to check */
-  path: z16.string(),
+  path: z17.string(),
   /** Content checks to perform */
   checks: FileContentCheckSchema
 });
 
 // src/test/build-check.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var BuildCheckTestSchema = BaseTestSchema.extend({
-  type: z17.literal("BUILD_CHECK" /* BUILD_CHECK */),
+  type: z18.literal("BUILD_CHECK" /* BUILD_CHECK */),
   /** Build command to execute */
-  command: z17.string(),
+  command: z18.string(),
   /** Whether the build should succeed */
-  expectSuccess: z17.boolean(),
+  expectSuccess: z18.boolean(),
   /** Maximum allowed warnings (optional) */
-  allowedWarnings: z17.number().optional(),
+  allowedWarnings: z18.number().optional(),
   /** Timeout in milliseconds */
-  timeout: z17.number().optional()
+  timeout: z18.number().optional()
 });
 
 // src/test/vitest.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var VitestTestSchema = BaseTestSchema.extend({
-  type: z18.literal("VITEST" /* VITEST */),
+  type: z19.literal("VITEST" /* VITEST */),
   /** Test file content */
-  testFile: z18.string(),
+  testFile: z19.string(),
   /** Name of the test file */
-  testFileName: z18.string(),
+  testFileName: z19.string(),
   /** Minimum pass rate required (0-100) */
-  minPassRate: z18.number().min(0).max(100)
+  minPassRate: z19.number().min(0).max(100)
 });
 
 // src/test/playwright-nl.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var PlaywrightNLTestSchema = BaseTestSchema.extend({
-  type: z19.literal("PLAYWRIGHT_NL" /* PLAYWRIGHT_NL */),
+  type: z20.literal("PLAYWRIGHT_NL" /* PLAYWRIGHT_NL */),
   /** Natural language steps to execute */
-  steps: z19.array(z19.string()),
+  steps: z20.array(z20.string()),
   /** Expected outcome description */
-  expectedOutcome: z19.string(),
+  expectedOutcome: z20.string(),
   /** Timeout in milliseconds */
-  timeout: z19.number().optional()
+  timeout: z20.number().optional()
 });
 
 // src/test/index.ts
-var TestSchema = z20.discriminatedUnion("type", [
+var TestSchema = z21.discriminatedUnion("type", [
   LLMTestSchema,
   ToolTestSchema,
   SiteConfigTestSchema,
@@ -550,33 +712,33 @@ var TestSchema = z20.discriminatedUnion("type", [
 ]);
 
 // src/scenario/environment.ts
-import { z as z21 } from "zod";
-var LocalProjectConfigSchema = z21.object({
+import { z as z22 } from "zod";
+var LocalProjectConfigSchema = z22.object({
   /** Template ID to use for the local project */
-  templateId: z21.string().optional(),
+  templateId: z22.string().optional(),
   /** Files to create in the project */
-  files: z21.array(
-    z21.object({
-      path: z21.string().min(1),
-      content: z21.string().min(1)
+  files: z22.array(
+    z22.object({
+      path: z22.string().min(1),
+      content: z22.string().min(1)
     })
   ).optional()
 });
-var MetaSiteConfigSchema = z21.object({
-  configurations: z21.array(
-    z21.object({
-      name: z21.string().min(1),
-      apiCalls: z21.array(
-        z21.object({
-          url: z21.string().url(),
-          method: z21.enum(["POST", "PUT"]),
-          body: z21.string()
+var MetaSiteConfigSchema = z22.object({
+  configurations: z22.array(
+    z22.object({
+      name: z22.string().min(1),
+      apiCalls: z22.array(
+        z22.object({
+          url: z22.string().url(),
+          method: z22.enum(["POST", "PUT"]),
+          body: z22.string()
         })
       )
     })
   ).optional()
 });
-var EnvironmentSchema = z21.object({
+var EnvironmentSchema = z22.object({
   /** Local project configuration */
   localProject: LocalProjectConfigSchema.optional(),
   /** Meta site configuration */
@@ -584,13 +746,13 @@ var EnvironmentSchema = z21.object({
 });
 
 // src/scenario/test-scenario.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 
 // src/assertion/assertion.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/assertion/build-passed-command.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var ALLOWED_BUILD_COMMANDS = [
   "yarn build",
   "npm run build",
@@ -616,10 +778,10 @@ function parseBuildCommandToArgv(command) {
   return BUILD_COMMAND_ARGV[trimmed];
 }
 var enumTuple = ALLOWED_BUILD_COMMANDS;
-var BuildPassedCommandStringSchema = z22.enum(enumTuple);
+var BuildPassedCommandStringSchema = z23.enum(enumTuple);
 
 // src/assertion/assertion.ts
-var AssertionTypeSchema = z23.enum([
+var AssertionTypeSchema = z24.enum([
   "skill_was_called",
   "tool_called_with_param",
   "build_passed",
@@ -628,61 +790,61 @@ var AssertionTypeSchema = z23.enum([
   "llm_judge",
   "api_call"
 ]);
-var AssertionParameterTypeSchema = z23.enum([
+var AssertionParameterTypeSchema = z24.enum([
   "string",
   "number",
   "boolean"
 ]);
-var AssertionParameterSchema = z23.object({
+var AssertionParameterSchema = z24.object({
   /** Parameter name (used as key in params object) */
-  name: z23.string().min(1),
+  name: z24.string().min(1),
   /** Display label for the parameter */
-  label: z23.string().min(1),
+  label: z24.string().min(1),
   /** Parameter type */
   type: AssertionParameterTypeSchema,
   /** Whether this parameter is required */
-  required: z23.boolean(),
+  required: z24.boolean(),
   /** Default value (optional, used when not provided) */
-  defaultValue: z23.union([z23.string(), z23.number(), z23.boolean()]).optional(),
+  defaultValue: z24.union([z24.string(), z24.number(), z24.boolean()]).optional(),
   /** If true, parameter is hidden by default behind "Show advanced options" */
-  advanced: z23.boolean().optional()
+  advanced: z24.boolean().optional()
 });
-var ScenarioAssertionLinkSchema = z23.object({
+var ScenarioAssertionLinkSchema = z24.object({
   /** ID of the system assertion (e.g., 'system:skill_was_called') */
-  assertionId: z23.string(),
+  assertionId: z24.string(),
   /** Parameter values for this assertion in this scenario */
-  params: z23.record(
-    z23.string(),
-    z23.union([z23.string(), z23.number(), z23.boolean(), z23.null()])
+  params: z24.record(
+    z24.string(),
+    z24.union([z24.string(), z24.number(), z24.boolean(), z24.null()])
   ).optional()
 });
-var SkillWasCalledConfigSchema = z23.object({
+var SkillWasCalledConfigSchema = z24.object({
   /** Names of the skills that must have been called */
-  skillNames: z23.array(z23.string().min(1)).min(1)
+  skillNames: z24.array(z24.string().min(1)).min(1)
 });
-var CostConfigSchema = z23.strictObject({
+var CostConfigSchema = z24.strictObject({
   /** Maximum allowed cost in USD */
-  maxCostUsd: z23.number().positive()
+  maxCostUsd: z24.number().positive()
 });
-var ToolCalledWithParamConfigSchema = z23.strictObject({
+var ToolCalledWithParamConfigSchema = z24.strictObject({
   /** Name of the tool that must have been called */
-  toolName: z23.string().min(1),
+  toolName: z24.string().min(1),
   /** JSON string of key-value pairs for expected parameters (substring match). Optional — when omitted, only checks tool presence. */
-  expectedParams: z23.string().min(1).optional(),
+  expectedParams: z24.string().min(1).optional(),
   /** If true, the matching tool call must also have succeeded (step.success === true) */
-  requireSuccess: z23.boolean().optional()
+  requireSuccess: z24.boolean().optional()
 });
-var BuildPassedConfigSchema = z23.strictObject({
+var BuildPassedConfigSchema = z24.strictObject({
   /** Allowlisted command only (default at runtime: "yarn build") */
   command: BuildPassedCommandStringSchema.optional(),
   /** Expected exit code (default: 0) */
-  expectedExitCode: z23.number().int().optional()
+  expectedExitCode: z24.number().int().optional()
 });
-var TimeConfigSchema = z23.strictObject({
+var TimeConfigSchema = z24.strictObject({
   /** Maximum allowed duration in milliseconds */
-  maxDurationMs: z23.number().int().positive()
+  maxDurationMs: z24.number().int().positive()
 });
-var LlmJudgeConfigSchema = z23.object({
+var LlmJudgeConfigSchema = z24.object({
   /**
    * Prompt template with placeholders:
    * - {{output}}: agent's final output
@@ -693,65 +855,65 @@ var LlmJudgeConfigSchema = z23.object({
    * - {{trace}}: step-by-step trace of tool calls
    * - Custom parameters defined in the parameters array
    */
-  prompt: z23.string().min(1),
+  prompt: z24.string().min(1),
   /** Minimum score to pass (0-10, default 7) */
-  minScore: z23.number().int().min(0).max(10).optional(),
+  minScore: z24.number().int().min(0).max(10).optional(),
   /** Model for the judge (e.g. claude-3-5-haiku-20241022) */
-  model: z23.string().optional(),
+  model: z24.string().optional(),
   /** Max output tokens */
-  maxTokens: z23.number().int().optional(),
+  maxTokens: z24.number().int().optional(),
   /** Temperature (0-1) */
-  temperature: z23.number().min(0).max(1).optional(),
+  temperature: z24.number().min(0).max(1).optional(),
   /** User-defined parameters for this assertion */
-  parameters: z23.array(AssertionParameterSchema).optional()
+  parameters: z24.array(AssertionParameterSchema).optional()
 });
-var ApiCallConfigSchema = z23.strictObject({
+var ApiCallConfigSchema = z24.strictObject({
   /** URL to call */
-  url: z23.string().min(1),
+  url: z24.string().min(1),
   /** HTTP method (default GET) */
-  method: z23.enum(["GET", "POST"]).optional(),
+  method: z24.enum(["GET", "POST"]).optional(),
   /** Request body (JSON string, for POST requests) */
-  requestBody: z23.string().optional(),
+  requestBody: z24.string().optional(),
   /** Expected JSON response to validate against (subset match — extra fields in actual are OK) */
-  expectedResponse: z23.string().min(1),
+  expectedResponse: z24.string().min(1),
   /** Request headers as JSON string of key-value pairs */
-  requestHeaders: z23.string().optional(),
+  requestHeaders: z24.string().optional(),
   /** Request timeout in milliseconds (default 30000) */
-  timeoutMs: z23.number().int().positive().optional()
+  timeoutMs: z24.number().int().positive().optional()
 });
 var AssertionBaseFields = {
   /** When true, the assertion's pass/fail logic is inverted (NOT operator). */
-  negate: z23.boolean().optional()
+  negate: z24.boolean().optional()
 };
 var SkillWasCalledAssertionSchema = SkillWasCalledConfigSchema.extend({
-  type: z23.literal("skill_was_called"),
+  type: z24.literal("skill_was_called"),
   ...AssertionBaseFields
 });
 var ToolCalledWithParamAssertionSchema = ToolCalledWithParamConfigSchema.extend({
-  type: z23.literal("tool_called_with_param"),
+  type: z24.literal("tool_called_with_param"),
   ...AssertionBaseFields
 });
 var BuildPassedAssertionSchema = BuildPassedConfigSchema.extend({
-  type: z23.literal("build_passed"),
+  type: z24.literal("build_passed"),
   ...AssertionBaseFields
 });
 var CostAssertionSchema = CostConfigSchema.extend({
-  type: z23.literal("cost"),
+  type: z24.literal("cost"),
   ...AssertionBaseFields
 });
 var LlmJudgeAssertionSchema = LlmJudgeConfigSchema.extend({
-  type: z23.literal("llm_judge"),
+  type: z24.literal("llm_judge"),
   ...AssertionBaseFields
 });
 var ApiCallAssertionSchema = ApiCallConfigSchema.extend({
-  type: z23.literal("api_call"),
+  type: z24.literal("api_call"),
   ...AssertionBaseFields
 });
 var TimeAssertionSchema = TimeConfigSchema.extend({
-  type: z23.literal("time_limit"),
+  type: z24.literal("time_limit"),
   ...AssertionBaseFields
 });
-var AssertionSchema = z23.union([
+var AssertionSchema = z24.union([
   SkillWasCalledAssertionSchema,
   ToolCalledWithParamAssertionSchema,
   BuildPassedAssertionSchema,
@@ -760,7 +922,7 @@ var AssertionSchema = z23.union([
   LlmJudgeAssertionSchema,
   ApiCallAssertionSchema
 ]);
-var AssertionConfigSchema = z23.union([
+var AssertionConfigSchema = z24.union([
   LlmJudgeConfigSchema,
   // requires prompt - check first
   SkillWasCalledConfigSchema,
@@ -775,7 +937,7 @@ var AssertionConfigSchema = z23.union([
   // requires maxCostUsd, uses strictObject
   BuildPassedConfigSchema,
   // all optional, uses strictObject to reject unknown keys
-  z23.object({})
+  z24.object({})
   // fallback empty config
 ]);
 function validateAssertionConfig(type, config) {
@@ -1021,35 +1183,35 @@ function getSystemAssertion(id) {
 
 // src/scenario/test-scenario.ts
 var MAX_IMAGE_BASE64_LENGTH = 4 * Math.ceil(2 * 1024 * 1024 / 3);
-var TriggerPromptImageSchema = z24.object({
+var TriggerPromptImageSchema = z25.object({
   /** Base64-encoded image data (no data URL prefix) */
-  base64: z24.string().max(MAX_IMAGE_BASE64_LENGTH, "Image exceeds 2 MB size limit"),
+  base64: z25.string().max(MAX_IMAGE_BASE64_LENGTH, "Image exceeds 2 MB size limit"),
   /** MIME type of the image */
-  mediaType: z24.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
+  mediaType: z25.enum(["image/jpeg", "image/png", "image/gif", "image/webp"]),
   /** Original filename of the image */
-  name: z24.string()
+  name: z25.string()
 });
-var ExpectedFileSchema = z24.object({
+var ExpectedFileSchema = z25.object({
   /** Relative path where the file should be created */
-  path: z24.string(),
+  path: z25.string(),
   /** Optional expected content */
-  content: z24.string().optional()
+  content: z25.string().optional()
 });
 var TestScenarioSchema = TenantEntitySchema.extend({
   /** The prompt sent to the agent to trigger the task */
-  triggerPrompt: z24.string().min(10),
+  triggerPrompt: z25.string().min(10),
   /** ID of the template to use for this scenario (null = no template) */
-  templateId: z24.string().nullish(),
+  templateId: z25.string().nullish(),
   /** Inline assertions to evaluate for this scenario (legacy) */
-  assertions: z24.array(AssertionSchema).optional(),
+  assertions: z25.array(AssertionSchema).optional(),
   /** IDs of saved assertions to evaluate (from assertions table) - legacy, use assertionLinks */
-  assertionIds: z24.array(z24.string()).optional(),
+  assertionIds: z25.array(z25.string()).optional(),
   /** Linked assertions with per-scenario parameter values */
-  assertionLinks: z24.array(ScenarioAssertionLinkSchema).optional(),
+  assertionLinks: z25.array(ScenarioAssertionLinkSchema).optional(),
   /** Tags for categorisation and filtering */
-  tags: z24.array(z24.string()).optional(),
+  tags: z25.array(z25.string()).optional(),
   /** Base64-encoded images attached to the trigger prompt (max 3) */
-  triggerPromptImages: z24.array(TriggerPromptImageSchema).max(3).optional()
+  triggerPromptImages: z25.array(TriggerPromptImageSchema).max(3).optional()
 });
 function validateBuildPassedParamsInAssertionLinks(links, ctx) {
   if (!links) return;
@@ -1060,7 +1222,7 @@ function validateBuildPassedParamsInAssertionLinks(links, ctx) {
     if (cmd === void 0 || cmd === null) continue;
     if (typeof cmd !== "string") {
       ctx.addIssue({
-        code: z24.ZodIssueCode.custom,
+        code: z25.ZodIssueCode.custom,
         message: "build_passed command must be a string",
         path: ["assertionLinks", i, "params", "command"]
       });
@@ -1068,7 +1230,7 @@ function validateBuildPassedParamsInAssertionLinks(links, ctx) {
     }
     if (!isAllowedBuildCommandString(cmd)) {
       ctx.addIssue({
-        code: z24.ZodIssueCode.custom,
+        code: z25.ZodIssueCode.custom,
         message: "Invalid build_passed command. Allowed: yarn build, npm run build, pnpm run build, pnpm build",
         path: ["assertionLinks", i, "params", "command"]
       });
@@ -1091,19 +1253,19 @@ var UpdateTestScenarioInputSchema = TestScenarioCreateBaseSchema.partial().super
 });
 
 // src/scenario/batch-import.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "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 = z25.union([
-  z25.string().min(1),
+var BatchAssertionLinkSchema = z26.union([
+  z26.string().min(1),
   ScenarioAssertionLinkSchema
 ]);
-var BatchScenarioEntrySchema = z25.object({
-  name: z25.string().min(1, "name: Required"),
-  description: z25.string().optional().default(""),
-  triggerPrompt: z25.string().min(10, "triggerPrompt: Must be at least 10 characters"),
-  templateId: z25.string().nullish(),
-  tags: z25.array(z25.string()).optional(),
-  assertionLinks: z25.array(BatchAssertionLinkSchema).optional()
+var BatchScenarioEntrySchema = z26.object({
+  name: z26.string().min(1, "name: Required"),
+  description: z26.string().optional().default(""),
+  triggerPrompt: z26.string().min(10, "triggerPrompt: Must be at least 10 characters"),
+  templateId: z26.string().nullish(),
+  tags: z26.array(z26.string()).optional(),
+  assertionLinks: z26.array(BatchAssertionLinkSchema).optional()
 }).superRefine((data, ctx) => {
   if (!data.assertionLinks) return;
   const objectLinks = data.assertionLinks.filter(
@@ -1113,8 +1275,8 @@ var BatchScenarioEntrySchema = z25.object({
     validateBuildPassedParamsInAssertionLinks(objectLinks, ctx);
   }
 });
-var BatchImportPayloadSchema = z25.object({
-  scenarios: z25.array(BatchScenarioEntrySchema).min(1, "scenarios array must contain at least one entry").max(100, "Maximum 100 scenarios per upload")
+var BatchImportPayloadSchema = z26.object({
+  scenarios: z26.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,
@@ -1136,29 +1298,29 @@ function normalizeBatchAssertionLink(link) {
   }
   return link;
 }
-var BatchResultItemSchema = z25.object({
-  index: z25.number(),
-  name: z25.string(),
-  status: z25.enum(["valid", "invalid"]),
-  id: z25.string().nullable().optional(),
-  errors: z25.array(z25.string()).optional()
-});
-var BatchSummarySchema = z25.object({
-  total: z25.number(),
-  valid: z25.number(),
-  invalid: z25.number(),
-  created: z25.number()
-});
-var BatchImportResponseSchema = z25.object({
+var BatchResultItemSchema = z26.object({
+  index: z26.number(),
+  name: z26.string(),
+  status: z26.enum(["valid", "invalid"]),
+  id: z26.string().nullable().optional(),
+  errors: z26.array(z26.string()).optional()
+});
+var BatchSummarySchema = z26.object({
+  total: z26.number(),
+  valid: z26.number(),
+  invalid: z26.number(),
+  created: z26.number()
+});
+var BatchImportResponseSchema = z26.object({
   summary: BatchSummarySchema,
-  results: z25.array(BatchResultItemSchema)
+  results: z26.array(BatchResultItemSchema)
 });
 
 // src/suite/test-suite.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var TestSuiteSchema = TenantEntitySchema.extend({
   /** IDs of test scenarios in this suite */
-  scenarioIds: z26.array(z26.string())
+  scenarioIds: z27.array(z27.string())
 });
 var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
   id: true,
@@ -1169,21 +1331,21 @@ var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
 var UpdateTestSuiteInputSchema = CreateTestSuiteInputSchema.partial();
 
 // src/evaluation/metrics.ts
-import { z as z27 } from "zod";
-var TokenUsageSchema = z27.object({
-  prompt: z27.number(),
-  completion: z27.number(),
-  total: z27.number()
-});
-var EvalMetricsSchema = z27.object({
-  totalAssertions: z27.number(),
-  passed: z27.number(),
-  failed: z27.number(),
-  skipped: z27.number(),
-  errors: z27.number(),
-  passRate: z27.number(),
-  avgDuration: z27.number(),
-  totalDuration: z27.number()
+import { z as z28 } from "zod";
+var TokenUsageSchema = z28.object({
+  prompt: z28.number(),
+  completion: z28.number(),
+  total: z28.number()
+});
+var EvalMetricsSchema = z28.object({
+  totalAssertions: z28.number(),
+  passed: z28.number(),
+  failed: z28.number(),
+  skipped: z28.number(),
+  errors: z28.number(),
+  passRate: z28.number(),
+  avgDuration: z28.number(),
+  totalDuration: z28.number()
 });
 var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["PENDING"] = "pending";
@@ -1193,7 +1355,7 @@ var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["CANCELLED"] = "cancelled";
   return EvalStatus2;
 })(EvalStatus || {});
-var EvalStatusSchema = z27.enum(EvalStatus);
+var EvalStatusSchema = z28.enum(EvalStatus);
 var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["COMPLETION"] = "completion";
   LLMStepType2["TOOL_USE"] = "tool_use";
@@ -1201,54 +1363,54 @@ var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["THINKING"] = "thinking";
   return LLMStepType2;
 })(LLMStepType || {});
-var LLMTraceStepSchema = z27.object({
-  id: z27.string(),
-  stepNumber: z27.number(),
-  type: z27.enum(LLMStepType),
-  model: z27.string(),
-  provider: z27.string(),
-  startedAt: z27.string(),
-  durationMs: z27.number(),
+var LLMTraceStepSchema = z28.object({
+  id: z28.string(),
+  stepNumber: z28.number(),
+  type: z28.enum(LLMStepType),
+  model: z28.string(),
+  provider: z28.string(),
+  startedAt: z28.string(),
+  durationMs: z28.number(),
   tokenUsage: TokenUsageSchema,
-  costUsd: z27.number(),
-  toolName: z27.string().optional(),
-  toolArguments: z27.string().optional(),
-  inputPreview: z27.string().optional(),
-  outputPreview: z27.string().optional(),
-  success: z27.boolean(),
-  error: z27.string().optional(),
-  turnIndex: z27.number().optional()
-});
-var LLMBreakdownStatsSchema = z27.object({
-  count: z27.number(),
-  durationMs: z27.number(),
-  tokens: z27.number(),
-  costUsd: z27.number()
-});
-var LLMTraceSummarySchema = z27.object({
-  totalSteps: z27.number(),
-  totalTurns: z27.number().optional(),
-  totalDurationMs: z27.number(),
+  costUsd: z28.number(),
+  toolName: z28.string().optional(),
+  toolArguments: z28.string().optional(),
+  inputPreview: z28.string().optional(),
+  outputPreview: z28.string().optional(),
+  success: z28.boolean(),
+  error: z28.string().optional(),
+  turnIndex: z28.number().optional()
+});
+var LLMBreakdownStatsSchema = z28.object({
+  count: z28.number(),
+  durationMs: z28.number(),
+  tokens: z28.number(),
+  costUsd: z28.number()
+});
+var LLMTraceSummarySchema = z28.object({
+  totalSteps: z28.number(),
+  totalTurns: z28.number().optional(),
+  totalDurationMs: z28.number(),
   totalTokens: TokenUsageSchema,
-  totalCostUsd: z27.number(),
-  stepTypeBreakdown: z27.record(z27.string(), LLMBreakdownStatsSchema).optional(),
-  modelBreakdown: z27.record(z27.string(), LLMBreakdownStatsSchema),
-  modelsUsed: z27.array(z27.string())
-});
-var LLMTraceSchema = z27.object({
-  id: z27.string(),
-  steps: z27.array(LLMTraceStepSchema),
+  totalCostUsd: z28.number(),
+  stepTypeBreakdown: z28.record(z28.string(), LLMBreakdownStatsSchema).optional(),
+  modelBreakdown: z28.record(z28.string(), LLMBreakdownStatsSchema),
+  modelsUsed: z28.array(z28.string())
+});
+var LLMTraceSchema = z28.object({
+  id: z28.string(),
+  steps: z28.array(LLMTraceStepSchema),
   summary: LLMTraceSummarySchema
 });
 
 // src/evaluation/eval-result.ts
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/evaluation/eval-run.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 
 // src/evaluation/live-trace.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["THINKING"] = "thinking";
   LiveTraceEventType2["TOOL_USE"] = "tool_use";
@@ -1262,37 +1424,37 @@ var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["USER"] = "user";
   return LiveTraceEventType2;
 })(LiveTraceEventType || {});
-var LiveTraceEventSchema = z28.object({
+var LiveTraceEventSchema = z29.object({
   /** The evaluation run ID */
-  evalRunId: z28.string(),
+  evalRunId: z29.string(),
   /** The scenario ID being executed */
-  scenarioId: z28.string(),
+  scenarioId: z29.string(),
   /** The scenario name for display */
-  scenarioName: z28.string(),
+  scenarioName: z29.string(),
   /** The target ID (skill, agent, etc.) */
-  targetId: z28.string(),
+  targetId: z29.string(),
   /** The target name for display */
-  targetName: z28.string(),
+  targetName: z29.string(),
   /** Step number in the current scenario execution */
-  stepNumber: z28.number(),
+  stepNumber: z29.number(),
   /** Type of trace event */
-  type: z28.enum(LiveTraceEventType),
+  type: z29.enum(LiveTraceEventType),
   /** Tool name if this is a tool_use event */
-  toolName: z28.string().optional(),
+  toolName: z29.string().optional(),
   /** Tool arguments preview (truncated JSON) */
-  toolArgs: z28.string().optional(),
+  toolArgs: z29.string().optional(),
   /** Output preview (truncated text) */
-  outputPreview: z28.string().optional(),
+  outputPreview: z29.string().optional(),
   /** File path for file operations */
-  filePath: z28.string().optional(),
+  filePath: z29.string().optional(),
   /** Elapsed time in milliseconds for progress events */
-  elapsedMs: z28.number().optional(),
+  elapsedMs: z29.number().optional(),
   /** Thinking/reasoning text from Claude */
-  thinking: z28.string().optional(),
+  thinking: z29.string().optional(),
   /** Timestamp when this event occurred */
-  timestamp: z28.string(),
+  timestamp: z29.string(),
   /** Whether this is the final event for this scenario */
-  isComplete: z28.boolean()
+  isComplete: z29.boolean()
 });
 var TRACE_EVENT_PREFIX = "TRACE_EVENT:";
 function parseTraceEventLine(line) {
@@ -1321,40 +1483,40 @@ var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
   TriggerType2["SCHEDULED"] = "SCHEDULED";
   return TriggerType2;
 })(TriggerType || {});
-var TriggerMetadataSchema = z29.object({
-  version: z29.string().optional(),
-  resourceUpdated: z29.array(z29.string()).optional(),
-  scheduleId: z29.string().optional()
+var TriggerMetadataSchema = z30.object({
+  version: z30.string().optional(),
+  resourceUpdated: z30.array(z30.string()).optional(),
+  scheduleId: z30.string().optional()
 });
-var TriggerSchema = z29.object({
-  id: z29.string(),
+var TriggerSchema = z30.object({
+  id: z30.string(),
   metadata: TriggerMetadataSchema.optional(),
-  type: z29.nativeEnum(TriggerType)
+  type: z30.nativeEnum(TriggerType)
 });
-var DiffLineTypeSchema = z29.enum(["added", "removed", "unchanged"]);
-var DiffLineSchema = z29.object({
+var DiffLineTypeSchema = z30.enum(["added", "removed", "unchanged"]);
+var DiffLineSchema = z30.object({
   type: DiffLineTypeSchema,
-  content: z29.string(),
-  lineNumber: z29.number()
-});
-var DiffContentSchema = z29.object({
-  path: z29.string(),
-  expected: z29.string(),
-  actual: z29.string(),
-  diffLines: z29.array(DiffLineSchema),
-  renamedFrom: z29.string().optional(),
+  content: z30.string(),
+  lineNumber: z30.number()
+});
+var DiffContentSchema = z30.object({
+  path: z30.string(),
+  expected: z30.string(),
+  actual: z30.string(),
+  diffLines: z30.array(DiffLineSchema),
+  renamedFrom: z30.string().optional(),
   /** Whether this file is an infrastructure/config file (e.g. .claude/settings.json, .mcp.json) */
-  isInfrastructure: z29.boolean().optional()
+  isInfrastructure: z30.boolean().optional()
 });
-var CommandExecutionSchema = z29.object({
-  command: z29.string(),
-  exitCode: z29.number(),
-  output: z29.string().optional(),
-  duration: z29.number()
+var CommandExecutionSchema = z30.object({
+  command: z30.string(),
+  exitCode: z30.number(),
+  output: z30.string().optional(),
+  duration: z30.number()
 });
-var FileModificationSchema = z29.object({
-  path: z29.string(),
-  action: z29.enum(["created", "modified", "deleted"])
+var FileModificationSchema = z30.object({
+  path: z30.string(),
+  action: z30.enum(["created", "modified", "deleted"])
 });
 var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["NEW"] = "new";
@@ -1362,62 +1524,58 @@ var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["UNCHANGED"] = "unchanged";
   return TemplateFileStatus2;
 })(TemplateFileStatus || {});
-var TemplateFileSchema = z29.object({
+var TemplateFileSchema = z30.object({
   /** Relative path within the template */
-  path: z29.string(),
+  path: z30.string(),
   /** Full file content after execution */
-  content: z29.string(),
+  content: z30.string(),
   /** File status (new, modified, unchanged) */
-  status: z29.enum(["new", "modified", "unchanged"]),
+  status: z30.enum(["new", "modified", "unchanged"]),
   /** Whether this file is an infrastructure/config file (e.g. .claude/settings.json, .mcp.json) */
-  isInfrastructure: z29.boolean().optional()
+  isInfrastructure: z30.boolean().optional()
 });
-var ApiCallSchema = z29.object({
-  endpoint: z29.string(),
-  tokensUsed: z29.number(),
-  duration: z29.number()
+var ApiCallSchema = z30.object({
+  endpoint: z30.string(),
+  tokensUsed: z30.number(),
+  duration: z30.number()
 });
-var ExecutionTraceSchema = z29.object({
-  commands: z29.array(CommandExecutionSchema),
-  filesModified: z29.array(FileModificationSchema),
-  apiCalls: z29.array(ApiCallSchema),
-  totalDuration: z29.number()
+var ExecutionTraceSchema = z30.object({
+  commands: z30.array(CommandExecutionSchema),
+  filesModified: z30.array(FileModificationSchema),
+  apiCalls: z30.array(ApiCallSchema),
+  totalDuration: z30.number()
 });
-var RunAnalysisFindingSchema = z29.object({
-  category: z29.enum([
+var RunAnalysisFindingSchema = z30.object({
+  category: z30.enum([
     "failure_pattern",
     "cost_waste",
     "flakiness",
     "inefficiency",
     "positive"
   ]),
-  severity: z29.enum(["high", "medium", "low"]),
-  description: z29.string(),
-  affectedScenarios: z29.array(z29.string()),
-  recommendation: z29.string().optional()
+  severity: z30.enum(["high", "medium", "low"]),
+  description: z30.string(),
+  affectedScenarios: z30.array(z30.string()),
+  recommendation: z30.string().optional()
 });
-var RunAnalysisSchema = z29.object({
-  generatedAt: z29.string(),
-  summary: z29.string(),
-  findings: z29.array(RunAnalysisFindingSchema)
+var RunAnalysisSchema = z30.object({
+  generatedAt: z30.string(),
+  summary: z30.string(),
+  findings: z30.array(RunAnalysisFindingSchema)
 });
 var EvalRunSchema = TenantEntitySchema.extend({
   /** Agent ID for this run */
-  agentId: z29.string().optional(),
+  agentId: z30.string().optional(),
   /** Preset ID that originated this run (optional) */
-  presetId: z29.string().optional(),
-  /** Skill IDs for this run */
-  skillIds: z29.array(z29.string()).optional(),
-  /** Map of skillId to skillVersionId for this run */
-  skillVersions: z29.record(z29.string(), z29.string()).optional(),
+  presetId: z30.string().optional(),
   /** Scenario IDs to run (always present — resolved server-side from tags when needed) */
-  scenarioIds: z29.array(z29.string()),
+  scenarioIds: z30.array(z30.string()),
   /** Current status */
   status: EvalStatusSchema,
   /** Progress percentage (0-100) */
-  progress: z29.number(),
+  progress: z30.number(),
   /** Results for each scenario/target combination (lazy to break eval-result ↔ eval-run cycle) */
-  results: z29.array(z29.lazy(() => EvalRunResultSchema)),
+  results: z30.array(z30.lazy(() => EvalRunResultSchema)),
   /** Aggregated metrics across all results */
   aggregateMetrics: EvalMetricsSchema,
   /** Aggregated LLM trace summary */
@@ -1425,41 +1583,39 @@ var EvalRunSchema = TenantEntitySchema.extend({
   /** What triggered this run */
   trigger: TriggerSchema.optional(),
   /** When the run started (set when evaluation is triggered) */
-  startedAt: z29.string().optional(),
+  startedAt: z30.string().optional(),
   /** When the run completed */
-  completedAt: z29.string().optional(),
+  completedAt: z30.string().optional(),
   /** Live trace events captured during execution (for playback on results page) */
-  liveTraceEvents: z29.array(LiveTraceEventSchema).optional(),
+  liveTraceEvents: z30.array(LiveTraceEventSchema).optional(),
   /** Remote job ID for tracking execution in Dev Machines */
-  jobId: z29.string().optional(),
+  jobId: z30.string().optional(),
   /** Remote job status from the Dev Machine API (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED) */
-  jobStatus: z29.string().optional(),
+  jobStatus: z30.string().optional(),
   /** Remote job error message if the job failed */
-  jobError: z29.string().optional(),
+  jobError: z30.string().optional(),
   /** Timestamp of the last job status check */
-  jobStatusCheckedAt: z29.string().optional(),
-  /** MCP server IDs to enable for this run (optional) */
-  mcpIds: z29.array(z29.string()).optional(),
-  /** Sub-agent IDs to enable for this run (optional) */
-  subAgentIds: z29.array(z29.string()).optional(),
-  /** Rule IDs to enable for this run (optional) */
-  ruleIds: z29.array(z29.string()).optional(),
+  jobStatusCheckedAt: z30.string().optional(),
+  /** Unified capability IDs */
+  capabilityIds: z30.array(z30.string()).optional(),
+  /** Map of capabilityId to capabilityVersionId for version pinning */
+  capabilityVersions: z30.record(z30.string(), z30.string()).optional(),
   /** Tags used to select scenarios for this run (for traceability) */
-  tags: z29.array(z29.string()).optional(),
+  tags: z30.array(z30.string()).optional(),
   /** How many times each scenario is executed within this eval run. Default: 1. Max: 20. */
-  runsPerScenario: z29.number().int().min(1).max(20).optional(),
+  runsPerScenario: z30.number().int().min(1).max(20).optional(),
   /** Snapshot of agent configuration captured at run creation time */
-  agentSnapshot: z29.object({
-    name: z29.string().optional(),
+  agentSnapshot: z30.object({
+    name: z30.string().optional(),
     agentType: AgentTypeSchema.optional(),
     runCommand: AgentRunCommandSchema.optional(),
-    systemPrompt: z29.string().nullable().optional(),
+    systemPrompt: z30.string().nullable().optional(),
     modelConfig: ModelConfigSchema.optional()
   }).optional(),
   /** UUID linking all runs in a comparison group */
-  comparisonGroupId: z29.string().optional(),
+  comparisonGroupId: z30.string().optional(),
   /** Human-readable label for this variant (e.g., "MCP: Wix Stores") */
-  comparisonLabel: z29.string().optional(),
+  comparisonLabel: z30.string().optional(),
   /** LLM-generated analysis of the completed run */
   runAnalysis: RunAnalysisSchema.optional()
 });
@@ -1477,60 +1633,60 @@ var CreateEvalRunInputSchema = EvalRunSchema.omit({
   agentSnapshot: true
 }).extend({
   /** Optional on input — backend resolves from tags when not provided */
-  scenarioIds: z29.array(z29.string()).optional()
+  scenarioIds: z30.array(z30.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 = z29.object({
-  runId: z29.string(),
-  targetId: z29.string(),
-  totalScenarios: z29.number(),
-  completedScenarios: z29.number(),
-  scenarioProgress: z29.array(
-    z29.object({
-      scenarioId: z29.string(),
-      currentStep: z29.string(),
-      error: z29.string().optional()
+var EvaluationProgressSchema = z30.object({
+  runId: z30.string(),
+  targetId: z30.string(),
+  totalScenarios: z30.number(),
+  completedScenarios: z30.number(),
+  scenarioProgress: z30.array(
+    z30.object({
+      scenarioId: z30.string(),
+      currentStep: z30.string(),
+      error: z30.string().optional()
     })
   ),
-  createdAt: z29.number()
-});
-var EvaluationLogSchema = z29.object({
-  runId: z29.string(),
-  scenarioId: z29.string(),
-  log: z29.object({
-    level: z29.enum(["info", "error", "debug"]),
-    message: z29.string().optional(),
-    args: z29.array(z29.any()).optional(),
-    error: z29.string().optional()
+  createdAt: z30.number()
+});
+var EvaluationLogSchema = z30.object({
+  runId: z30.string(),
+  scenarioId: z30.string(),
+  log: z30.object({
+    level: z30.enum(["info", "error", "debug"]),
+    message: z30.string().optional(),
+    args: z30.array(z30.any()).optional(),
+    error: z30.string().optional()
   })
 });
 var LLM_TIMEOUT = 12e4;
 
 // src/evaluation/conversation.ts
-import { z as z30 } from "zod";
-var TextBlockSchema = z30.object({
-  type: z30.literal("text"),
-  text: z30.string()
-});
-var ThinkingBlockSchema = z30.object({
-  type: z30.literal("thinking"),
-  thinking: z30.string()
-});
-var ToolUseBlockSchema = z30.object({
-  type: z30.literal("tool_use"),
-  toolName: z30.string(),
-  toolId: z30.string(),
-  input: z30.unknown()
-});
-var ToolResultBlockSchema = z30.object({
-  type: z30.literal("tool_result"),
-  toolUseId: z30.string(),
-  content: z30.string(),
-  isError: z30.boolean().optional()
-});
-var ConversationBlockSchema = z30.discriminatedUnion("type", [
+import { z as z31 } from "zod";
+var TextBlockSchema = z31.object({
+  type: z31.literal("text"),
+  text: z31.string()
+});
+var ThinkingBlockSchema = z31.object({
+  type: z31.literal("thinking"),
+  thinking: z31.string()
+});
+var ToolUseBlockSchema = z31.object({
+  type: z31.literal("tool_use"),
+  toolName: z31.string(),
+  toolId: z31.string(),
+  input: z31.unknown()
+});
+var ToolResultBlockSchema = z31.object({
+  type: z31.literal("tool_result"),
+  toolUseId: z31.string(),
+  content: z31.string(),
+  isError: z31.boolean().optional()
+});
+var ConversationBlockSchema = z31.discriminatedUnion("type", [
   TextBlockSchema,
   ThinkingBlockSchema,
   ToolUseBlockSchema,
@@ -1541,18 +1697,18 @@ var ConversationMessageRoles = [
   "user",
   "system"
 ];
-var ConversationMessageSchema = z30.object({
-  role: z30.enum(ConversationMessageRoles),
-  content: z30.array(ConversationBlockSchema),
-  timestamp: z30.string()
+var ConversationMessageSchema = z31.object({
+  role: z31.enum(ConversationMessageRoles),
+  content: z31.array(ConversationBlockSchema),
+  timestamp: z31.string()
 });
-var ScenarioConversationSchema = z30.object({
-  id: z30.string(),
-  projectId: z30.string(),
-  evalRunId: z30.string(),
-  resultId: z30.string(),
-  messages: z30.array(ConversationMessageSchema),
-  createdAt: z30.string()
+var ScenarioConversationSchema = z31.object({
+  id: z31.string(),
+  projectId: z31.string(),
+  evalRunId: z31.string(),
+  resultId: z31.string(),
+  messages: z31.array(ConversationMessageSchema),
+  createdAt: z31.string()
 });
 
 // src/evaluation/eval-result.ts
@@ -1563,98 +1719,98 @@ var AssertionResultStatus = /* @__PURE__ */ ((AssertionResultStatus2) => {
   AssertionResultStatus2["ERROR"] = "error";
   return AssertionResultStatus2;
 })(AssertionResultStatus || {});
-var AssertionResultSchema = z31.object({
-  id: z31.string(),
-  assertionId: z31.string(),
-  assertionType: z31.string(),
-  assertionName: z31.string(),
-  status: z31.enum(AssertionResultStatus),
-  message: z31.string().optional(),
-  expected: z31.string().optional(),
-  actual: z31.string().optional(),
-  duration: z31.number().optional(),
-  details: z31.record(z31.string(), z31.unknown()).optional(),
-  llmTraceSteps: z31.array(LLMTraceStepSchema).optional()
-});
-var EvalRunResultSchema = z31.object({
-  id: z31.string(),
-  targetId: z31.string(),
-  targetName: z31.string().optional(),
+var AssertionResultSchema = z32.object({
+  id: z32.string(),
+  assertionId: z32.string(),
+  assertionType: z32.string(),
+  assertionName: z32.string(),
+  status: z32.enum(AssertionResultStatus),
+  message: z32.string().optional(),
+  expected: z32.string().optional(),
+  actual: z32.string().optional(),
+  duration: z32.number().optional(),
+  details: z32.record(z32.string(), z32.unknown()).optional(),
+  llmTraceSteps: z32.array(LLMTraceStepSchema).optional()
+});
+var EvalRunResultSchema = z32.object({
+  id: z32.string(),
+  targetId: z32.string(),
+  targetName: z32.string().optional(),
   /** SkillVersion ID used for this evaluation (for version tracking) */
-  skillVersionId: z31.string().optional(),
+  skillVersionId: z32.string().optional(),
   /** SkillVersion semver string (e.g., "1.0.0", "1.2.3") for display */
-  skillVersion: z31.string().optional(),
-  scenarioId: z31.string(),
-  scenarioName: z31.string(),
+  skillVersion: z32.string().optional(),
+  scenarioId: z32.string(),
+  scenarioName: z32.string(),
   /** Snapshot of the trigger prompt used during the run (prevents stale display after edits) */
-  triggerPrompt: z31.string().optional(),
+  triggerPrompt: z32.string().optional(),
   modelConfig: ModelConfigSchema.optional(),
-  assertionResults: z31.array(AssertionResultSchema),
+  assertionResults: z32.array(AssertionResultSchema),
   metrics: EvalMetricsSchema.optional(),
-  passed: z31.number(),
-  failed: z31.number(),
-  passRate: z31.number(),
-  duration: z31.number(),
-  outputText: z31.string().optional(),
-  files: z31.array(ExpectedFileSchema).optional(),
-  fileDiffs: z31.array(DiffContentSchema).optional(),
+  passed: z32.number(),
+  failed: z32.number(),
+  passRate: z32.number(),
+  duration: z32.number(),
+  outputText: z32.string().optional(),
+  files: z32.array(ExpectedFileSchema).optional(),
+  fileDiffs: z32.array(DiffContentSchema).optional(),
   /** Full template files after execution with status indicators */
-  templateFiles: z31.array(TemplateFileSchema).optional(),
-  startedAt: z31.string().optional(),
-  completedAt: z31.string().optional(),
+  templateFiles: z32.array(TemplateFileSchema).optional(),
+  startedAt: z32.string().optional(),
+  completedAt: z32.string().optional(),
   llmTrace: LLMTraceSchema.optional(),
   /** Full conversation messages (only present in transit; stripped before DB storage) */
-  conversation: z31.array(ConversationMessageSchema).optional(),
+  conversation: z32.array(ConversationMessageSchema).optional(),
   /** 0-based iteration index when a scenario is run multiple times within a single eval run */
-  iterationIndex: z31.number().int().min(0).optional()
-});
-var PromptResultSchema = z31.object({
-  text: z31.string(),
-  files: z31.array(z31.unknown()).optional(),
-  finishReason: z31.string().optional(),
-  reasoning: z31.string().optional(),
-  reasoningDetails: z31.unknown().optional(),
-  toolCalls: z31.array(z31.unknown()).optional(),
-  toolResults: z31.array(z31.unknown()).optional(),
-  warnings: z31.array(z31.unknown()).optional(),
-  sources: z31.array(z31.unknown()).optional(),
-  steps: z31.array(z31.unknown()),
-  generationTimeMs: z31.number(),
-  prompt: z31.string(),
-  systemPrompt: z31.string(),
-  usage: z31.object({
-    totalTokens: z31.number().optional(),
-    totalMicrocentsSpent: z31.number().optional()
+  iterationIndex: z32.number().int().min(0).optional()
+});
+var PromptResultSchema = z32.object({
+  text: z32.string(),
+  files: z32.array(z32.unknown()).optional(),
+  finishReason: z32.string().optional(),
+  reasoning: z32.string().optional(),
+  reasoningDetails: z32.unknown().optional(),
+  toolCalls: z32.array(z32.unknown()).optional(),
+  toolResults: z32.array(z32.unknown()).optional(),
+  warnings: z32.array(z32.unknown()).optional(),
+  sources: z32.array(z32.unknown()).optional(),
+  steps: z32.array(z32.unknown()),
+  generationTimeMs: z32.number(),
+  prompt: z32.string(),
+  systemPrompt: z32.string(),
+  usage: z32.object({
+    totalTokens: z32.number().optional(),
+    totalMicrocentsSpent: z32.number().optional()
   })
 });
-var EvaluationResultSchema = z31.object({
-  id: z31.string(),
-  runId: z31.string(),
-  timestamp: z31.number(),
+var EvaluationResultSchema = z32.object({
+  id: z32.string(),
+  runId: z32.string(),
+  timestamp: z32.number(),
   promptResult: PromptResultSchema,
-  testResults: z31.array(z31.unknown()),
-  tags: z31.array(z31.string()).optional(),
-  feedback: z31.string().optional(),
-  score: z31.number(),
-  suiteId: z31.string().optional()
-});
-var LeanEvaluationResultSchema = z31.object({
-  id: z31.string(),
-  runId: z31.string(),
-  timestamp: z31.number(),
-  tags: z31.array(z31.string()).optional(),
-  scenarioId: z31.string(),
-  scenarioVersion: z31.number().optional(),
-  targetId: z31.string(),
-  targetVersion: z31.number().optional(),
-  suiteId: z31.string().optional(),
-  score: z31.number(),
-  time: z31.number().optional(),
-  microcentsSpent: z31.number().optional()
+  testResults: z32.array(z32.unknown()),
+  tags: z32.array(z32.string()).optional(),
+  feedback: z32.string().optional(),
+  score: z32.number(),
+  suiteId: z32.string().optional()
+});
+var LeanEvaluationResultSchema = z32.object({
+  id: z32.string(),
+  runId: z32.string(),
+  timestamp: z32.number(),
+  tags: z32.array(z32.string()).optional(),
+  scenarioId: z32.string(),
+  scenarioVersion: z32.number().optional(),
+  targetId: z32.string(),
+  targetVersion: z32.number().optional(),
+  suiteId: z32.string().optional(),
+  score: z32.number(),
+  time: z32.number().optional(),
+  microcentsSpent: z32.number().optional()
 });
 
 // src/evaluation/eval-run-folder.ts
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 var EvalRunFolderSchema = TenantEntitySchema.extend({});
 var CreateEvalRunFolderInputSchema = EvalRunFolderSchema.omit({
   id: true,
@@ -1668,26 +1824,26 @@ var UpdateEvalRunFolderInputSchema = EvalRunFolderSchema.omit({
   updatedAt: true,
   deleted: true
 }).partial();
-var EvalRunFolderMembershipSchema = z32.object({
-  folderId: z32.string(),
-  evalRunId: z32.string(),
-  projectId: z32.string(),
-  createdAt: z32.string()
+var EvalRunFolderMembershipSchema = z33.object({
+  folderId: z33.string(),
+  evalRunId: z33.string(),
+  projectId: z33.string(),
+  createdAt: z33.string()
 });
 
 // src/project/project.ts
-import { z as z33 } from "zod";
+import { z as z34 } from "zod";
 var ProjectSchema = BaseEntitySchema.extend({
-  appId: z33.string().optional().describe("The ID of the app in Dev Center"),
-  scenarioTags: z33.array(z33.string()).optional().describe("Project-level tag vocabulary for scenarios"),
+  appId: z34.string().optional().describe("The ID of the app in Dev Center"),
+  scenarioTags: z34.array(z34.string()).optional().describe("Project-level tag vocabulary for scenarios"),
   /** Per-project Wix auth token (write-only — never returned in GET responses). null = clear. */
-  wixAuthToken: z33.string().nullable().optional().describe("Wix auth token for CLI/MCP authentication (encrypted at rest)"),
+  wixAuthToken: z34.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: z33.string().nullable().optional().describe("Base64-encoded Base44 auth file content (encrypted at rest)"),
+  base44AuthFile: z34.string().nullable().optional().describe("Base64-encoded Base44 auth file content (encrypted at rest)"),
   /** Resolved at runtime from the encrypted Wix auth token */
-  wixAuthEmail: z33.string().optional().describe("Email associated with the Wix auth token (resolved at runtime)"),
+  wixAuthEmail: z34.string().optional().describe("Email associated with the Wix auth token (resolved at runtime)"),
   /** Resolved at runtime from the encrypted Base44 auth file */
-  base44AuthEmail: z33.string().optional().describe("Email from the Base44 auth file (resolved at runtime)")
+  base44AuthEmail: z34.string().optional().describe("Email from the Base44 auth file (resolved at runtime)")
 });
 var CreateProjectInputSchema = ProjectSchema.omit({
   id: true,
@@ -1697,7 +1853,7 @@ var CreateProjectInputSchema = ProjectSchema.omit({
   wixAuthEmail: true,
   base44AuthEmail: true
 }).extend({
-  appId: z33.string().describe(
+  appId: z34.string().describe(
     "Required: The ID of the app in Dev Center for credential scoping"
   )
 });
@@ -1717,7 +1873,7 @@ var CreateTemplateInputSchema = TemplateSchema.omit({
 var UpdateTemplateInputSchema = CreateTemplateInputSchema.partial();
 
 // src/schedule/eval-schedule.ts
-import { z as z34 } from "zod";
+import { z as z35 } from "zod";
 var FrequencyType = /* @__PURE__ */ ((FrequencyType2) => {
   FrequencyType2["DAILY"] = "daily";
   FrequencyType2["WEEKDAY"] = "weekday";
@@ -1727,29 +1883,29 @@ var FrequencyType = /* @__PURE__ */ ((FrequencyType2) => {
 })(FrequencyType || {});
 var EvalScheduleSchema = TenantEntitySchema.extend({
   /** Whether the schedule is active */
-  enabled: z34.boolean(),
+  enabled: z35.boolean(),
   /** Test suite to run */
-  suiteId: z34.string(),
+  suiteId: z35.string(),
   /** Preset that provides agent + entities for this schedule */
-  presetId: z34.string(),
+  presetId: z35.string(),
   /** How often to run */
-  frequencyType: z34.nativeEnum(FrequencyType),
+  frequencyType: z35.nativeEnum(FrequencyType),
   /** Time of day in 24h format (HH:MM), hours 00-23, minutes 00-59 */
-  timeOfDay: z34.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
+  timeOfDay: z35.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/),
   /** Day of week (0=Sun, 6=Sat) for weekly schedules */
-  dayOfWeek: z34.number().min(0).max(6).optional(),
+  dayOfWeek: z35.number().min(0).max(6).optional(),
   /** Day of month (1-31) for monthly schedules */
-  dayOfMonth: z34.number().min(1).max(31).optional(),
+  dayOfMonth: z35.number().min(1).max(31).optional(),
   /** IANA timezone (e.g., 'America/New_York') */
-  timezone: z34.string(),
+  timezone: z35.string(),
   /** ID of the last eval run created by this schedule */
-  lastRunId: z34.string().optional(),
+  lastRunId: z35.string().optional(),
   /** Denormalized status of the last run */
-  lastRunStatus: z34.string().optional(),
+  lastRunStatus: z35.string().optional(),
   /** ISO timestamp of the last run */
-  lastRunAt: z34.string().optional(),
+  lastRunAt: z35.string().optional(),
   /** Next scheduled run time in UTC (pre-computed for efficient querying, set by backend) */
-  nextRunAt: z34.string().optional()
+  nextRunAt: z35.string().optional()
 });
 function isValidTimezone(tz) {
   try {
@@ -1762,14 +1918,14 @@ function isValidTimezone(tz) {
 function validateScheduleFields(data, ctx, options) {
   if (data.frequencyType === "weekly" /* WEEKLY */ && data.dayOfWeek == null) {
     ctx.addIssue({
-      code: z34.ZodIssueCode.custom,
+      code: z35.ZodIssueCode.custom,
       message: "dayOfWeek is required for weekly schedules",
       path: ["dayOfWeek"]
     });
   }
   if (data.frequencyType === "monthly" /* MONTHLY */ && data.dayOfMonth == null) {
     ctx.addIssue({
-      code: z34.ZodIssueCode.custom,
+      code: z35.ZodIssueCode.custom,
       message: "dayOfMonth is required for monthly schedules",
       path: ["dayOfMonth"]
     });
@@ -1777,7 +1933,7 @@ function validateScheduleFields(data, ctx, options) {
   const shouldValidateTz = options.partial ? data.timezone !== void 0 : true;
   if (shouldValidateTz && !isValidTimezone(data.timezone)) {
     ctx.addIssue({
-      code: z34.ZodIssueCode.custom,
+      code: z35.ZodIssueCode.custom,
       message: "Invalid IANA timezone",
       path: ["timezone"]
     });
@@ -1841,6 +1997,13 @@ export {
   BulkImportResultItemSchema,
   BulkImportResultSchema,
   BulkImportSkillsInputSchema,
+  CAPABILITY_NAME_REGEX,
+  CapabilityContentSchema,
+  CapabilitySchema,
+  CapabilityTypeSchema,
+  CapabilityVersionOriginSchema,
+  CapabilityVersionSchema,
+  CapabilityWithLatestVersionSchema,
   ClaudeModel,
   ClaudeModelSchema,
   CommandExecutionSchema,
@@ -1851,6 +2014,8 @@ export {
   CostAssertionSchema,
   CostConfigSchema,
   CreateAgentInputSchema,
+  CreateCapabilityInputSchema,
+  CreateCapabilityVersionInputSchema,
   CreateEvalRunFolderInputSchema,
   CreateEvalRunInputSchema,
   CreateEvalScheduleInputSchema,
@@ -1890,6 +2055,7 @@ export {
   FilePresenceTestSchema,
   FrequencyType,
   GitHubSourceSchema,
+  InitialCapabilityVersionInputSchema,
   InitialVersionInputSchema,
   LEGACY_MODEL_ID_MAP,
   LLMBreakdownStatsSchema,
@@ -1966,6 +2132,7 @@ export {
   TriggerSchema,
   TriggerType,
   UpdateAgentInputSchema,
+  UpdateCapabilityInputSchema,
   UpdateEvalRunFolderInputSchema,
   UpdateEvalScheduleInputSchema,
   UpdateMcpInputSchema,
@@ -1978,12 +2145,20 @@ export {
   UpdateTestScenarioInputSchema,
   UpdateTestSuiteInputSchema,
   VitestTestSchema,
+  capabilityToMcp,
+  capabilityToRule,
+  capabilityToSkill,
+  capabilityToSkillWithLatestVersion,
+  capabilityToSubAgent,
+  capabilityVersionToSkillVersion,
   classifyAssertionRef,
   formatTraceEventLine,
   getSystemAssertion,
   getSystemAssertions,
+  groupCapabilitiesByType,
   isAllowedBuildCommandString,
   isSystemAssertionId,
+  isValidCapabilityName,
   isValidSkillFolderName,
   normalizeBatchAssertionLink,
   normalizeModelId,