@wix/evalforge-types 0.37.0 → 0.39.0

package/build/index.mjs

@@ -975,6 +975,33 @@ var ModelConfigSchema = z4.object({
   maxTokens: z4.preprocess(nullToUndefined, z4.number().min(1).optional())
 });
 
+// src/common/rule.ts
+import { z as z5 } from "zod";
+var RuleTypeSchema = z5.enum(["claude-md", "agents-md", "cursor-rule"]);
+var RuleSchema = TenantEntitySchema.extend({
+  ruleType: RuleTypeSchema,
+  content: z5.string()
+});
+var RuleInputBaseSchema = RuleSchema.omit({
+  id: true,
+  createdAt: true,
+  updatedAt: true,
+  deleted: true
+});
+var CreateRuleInputSchema = RuleInputBaseSchema;
+var UpdateRuleInputSchema = RuleInputBaseSchema.partial();
+
+// src/common/tool-names.ts
+var AVAILABLE_TOOL_NAMES = [
+  "Bash",
+  "Edit",
+  "Glob",
+  "Grep",
+  "Read",
+  "Skill",
+  "Write"
+];
+
 // src/target/target.ts
 var TargetSchema = TenantEntitySchema.extend({
   // Base for all testable entities
@@ -982,7 +1009,7 @@ var TargetSchema = TenantEntitySchema.extend({
 });
 
 // src/target/agent.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var AgentRunCommand = /* @__PURE__ */ ((AgentRunCommand2) => {
   AgentRunCommand2["CLAUDE"] = "claude";
   return AgentRunCommand2;
@@ -991,7 +1018,7 @@ var AVAILABLE_RUN_COMMANDS = Object.values(AgentRunCommand);
 var RUN_COMMAND_LABELS = {
   ["claude" /* CLAUDE */]: "Claude Code"
 };
-var AgentRunCommandSchema = z5.nativeEnum(AgentRunCommand);
+var AgentRunCommandSchema = z6.nativeEnum(AgentRunCommand);
 var AgentSchema = TargetSchema.extend({
   /** Command to run the agent */
   runCommand: AgentRunCommandSchema,
@@ -1009,51 +1036,51 @@ var UpdateAgentInputSchema = CreateAgentInputSchema.partial().extend({
 });
 
 // src/target/skill.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 var SKILL_FOLDER_NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
 var SEMVER_REGEX = /^\d+\.\d+\.\d+$/;
-var SkillVersionOriginSchema = z6.enum(["manual", "pr", "master"]);
+var SkillVersionOriginSchema = z7.enum(["manual", "pr", "master"]);
 function isValidSkillFolderName(name) {
   return typeof name === "string" && name.length > 0 && SKILL_FOLDER_NAME_REGEX.test(name.trim());
 }
-var SkillMetadataSchema = z6.object({
-  name: z6.string(),
-  description: z6.string(),
-  allowedTools: z6.array(z6.string()).optional(),
-  skills: z6.array(z6.string()).optional()
+var SkillMetadataSchema = z7.object({
+  name: z7.string(),
+  description: z7.string(),
+  allowedTools: z7.array(z7.string()).optional(),
+  skills: z7.array(z7.string()).optional()
 });
-var SkillFileSchema = z6.object({
+var SkillFileSchema = z7.object({
   /** Relative path within the skill directory, e.g. "SKILL.md" or "references/API_SPEC.md" */
-  path: z6.string().min(1),
+  path: z7.string().min(1),
   /** File content (UTF-8 text) */
-  content: z6.string()
+  content: z7.string()
 });
-var SkillVersionSchema = z6.object({
-  id: z6.string(),
-  projectId: z6.string(),
-  skillId: z6.string(),
+var SkillVersionSchema = z7.object({
+  id: z7.string(),
+  projectId: z7.string(),
+  skillId: z7.string(),
   /** Semver string (e.g. "1.2.0") or Falcon fingerprint */
-  version: z6.string(),
+  version: z7.string(),
   /** How this version was created */
   origin: SkillVersionOriginSchema,
   /** Where this snapshot was taken from */
   source: GitHubSourceSchema.optional(),
   /** Frozen snapshot of all files in the skill directory */
-  files: z6.array(SkillFileSchema).optional(),
+  files: z7.array(SkillFileSchema).optional(),
   /** Optional notes about this version (changelog, reason for change) */
-  notes: z6.string().optional(),
-  createdAt: z6.string()
+  notes: z7.string().optional(),
+  createdAt: z7.string()
 });
-var CreateSkillVersionInputSchema = z6.object({
+var CreateSkillVersionInputSchema = z7.object({
   /** GitHub source to snapshot from. If not provided, uses the Skill's source. */
   source: GitHubSourceSchema.optional(),
   /** Version string for this snapshot (e.g. "1.0.0", "1.0.3"). */
-  version: z6.string().min(1),
-  notes: z6.string().optional(),
+  version: z7.string().min(1),
+  notes: z7.string().optional(),
   /** Origin of this version. Defaults to 'manual' in backend. */
   origin: SkillVersionOriginSchema.optional(),
   /** Pre-edited files to store directly (bypasses GitHub fetch when provided) */
-  files: z6.array(SkillFileSchema).optional()
+  files: z7.array(SkillFileSchema).optional()
 });
 var SkillSchema = TargetSchema.extend({
   /** GitHub source reference for live content fetching */
@@ -1069,15 +1096,15 @@ var SkillInputBaseSchema = SkillSchema.omit({
   source: true
 }).extend({
   /** Optional - not stored on Skill; content description lives in SkillVersion */
-  description: z6.string().optional(),
+  description: z7.string().optional(),
   /** GitHub source reference for live content fetching */
   source: GitHubSourceSchema.optional()
 });
-var InitialVersionInputSchema = z6.object({
-  files: z6.array(SkillFileSchema).optional(),
-  notes: z6.string().optional(),
+var InitialVersionInputSchema = z7.object({
+  files: z7.array(SkillFileSchema).optional(),
+  notes: z7.string().optional(),
   source: GitHubSourceSchema.optional(),
-  version: z6.string().optional(),
+  version: z7.string().optional(),
   origin: SkillVersionOriginSchema.optional()
 });
 var CreateSkillInputSchema = SkillInputBaseSchema.extend({
@@ -1095,10 +1122,10 @@ var SkillWithLatestVersionSchema = SkillSchema.extend({
 });
 
 // src/target/skills-group.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var SkillsGroupSchema = TenantEntitySchema.extend({
   /** IDs of skills in this group */
-  skillIds: z7.array(z7.string())
+  skillIds: z8.array(z8.string())
 });
 var CreateSkillsGroupInputSchema = SkillsGroupSchema.omit({
   id: true,
@@ -1109,10 +1136,10 @@ var CreateSkillsGroupInputSchema = SkillsGroupSchema.omit({
 var UpdateSkillsGroupInputSchema = CreateSkillsGroupInputSchema.partial();
 
 // src/target/sub-agent.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var SubAgentSchema = TargetSchema.extend({
   /** The full sub-agent markdown content (YAML frontmatter + body) */
-  subAgentMd: z8.string()
+  subAgentMd: z9.string()
 });
 var SubAgentInputBaseSchema = SubAgentSchema.omit({
   id: true,
@@ -1124,10 +1151,10 @@ var CreateSubAgentInputSchema = SubAgentInputBaseSchema;
 var UpdateSubAgentInputSchema = SubAgentInputBaseSchema.partial();
 
 // src/test/index.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // src/test/base.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var TestType = /* @__PURE__ */ ((TestType2) => {
   TestType2["LLM"] = "LLM";
   TestType2["TOOL"] = "TOOL";
@@ -1140,7 +1167,7 @@ var TestType = /* @__PURE__ */ ((TestType2) => {
   TestType2["PLAYWRIGHT_NL"] = "PLAYWRIGHT_NL";
   return TestType2;
 })(TestType || {});
-var TestTypeSchema = z9.enum(TestType);
+var TestTypeSchema = z10.enum(TestType);
 var TestImportance = /* @__PURE__ */ ((TestImportance2) => {
   TestImportance2["LOW"] = "low";
   TestImportance2["MEDIUM"] = "medium";
@@ -1148,153 +1175,153 @@ var TestImportance = /* @__PURE__ */ ((TestImportance2) => {
   TestImportance2["CRITICAL"] = "critical";
   return TestImportance2;
 })(TestImportance || {});
-var TestImportanceSchema = z9.enum(TestImportance);
-var BaseTestSchema = z9.object({
-  id: z9.string(),
+var TestImportanceSchema = z10.enum(TestImportance);
+var BaseTestSchema = z10.object({
+  id: z10.string(),
   type: TestTypeSchema,
-  name: z9.string().min(3),
-  description: z9.string().optional(),
+  name: z10.string().min(3),
+  description: z10.string().optional(),
   importance: TestImportanceSchema.optional()
 });
 
 // src/test/llm.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var LLMTestSchema = BaseTestSchema.extend({
-  type: z10.literal("LLM" /* LLM */),
+  type: z11.literal("LLM" /* LLM */),
   /** Maximum steps for the LLM to take */
-  maxSteps: z10.number().min(1).max(100),
+  maxSteps: z11.number().min(1).max(100),
   /** Prompt to send to the evaluator */
-  prompt: z10.string().min(1),
+  prompt: z11.string().min(1),
   /** ID of the evaluator agent to use */
-  evaluatorId: z10.string()
+  evaluatorId: z11.string()
 });
 
 // src/test/tool.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var ToolTestSchema = BaseTestSchema.extend({
-  type: z11.literal("TOOL" /* TOOL */),
+  type: z12.literal("TOOL" /* TOOL */),
   /** Name of the tool that should be called */
-  toolName: z11.string().min(3),
+  toolName: z12.string().min(3),
   /** Expected arguments for the tool call */
-  args: z11.record(z11.string(), z11.any()),
+  args: z12.record(z12.string(), z12.any()),
   /** Expected content in the tool results */
-  resultsContent: z11.string()
+  resultsContent: z12.string()
 });
 
 // src/test/site-config.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var SiteConfigTestSchema = BaseTestSchema.extend({
-  type: z12.literal("SITE_CONFIG" /* SITE_CONFIG */),
+  type: z13.literal("SITE_CONFIG" /* SITE_CONFIG */),
   /** URL to call */
-  url: z12.string().url(),
+  url: z13.string().url(),
   /** HTTP method */
-  method: z12.enum(["GET", "POST"]),
+  method: z13.enum(["GET", "POST"]),
   /** Request body (for POST) */
-  body: z12.string().optional(),
+  body: z13.string().optional(),
   /** Expected HTTP status code */
-  expectedStatusCode: z12.number().int().min(100).max(599),
+  expectedStatusCode: z13.number().int().min(100).max(599),
   /** Expected response content */
-  expectedResponse: z12.string().optional(),
+  expectedResponse: z13.string().optional(),
   /** JMESPath expression to extract from response */
-  expectedResponseJMESPath: z12.string().optional()
+  expectedResponseJMESPath: z13.string().optional()
 });
 
 // src/test/command-execution.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var AllowedCommands = [
   "yarn install --no-immutable && yarn build",
   "npm run build",
   "yarn typecheck"
 ];
 var CommandExecutionTestSchema = BaseTestSchema.extend({
-  type: z13.literal("COMMAND_EXECUTION" /* COMMAND_EXECUTION */),
+  type: z14.literal("COMMAND_EXECUTION" /* COMMAND_EXECUTION */),
   /** Command to execute (must be in AllowedCommands) */
-  command: z13.string().refine((value) => AllowedCommands.includes(value), {
+  command: z14.string().refine((value) => AllowedCommands.includes(value), {
     message: `Command must be one of: ${AllowedCommands.join(", ")}`
   }),
   /** Expected exit code (default: 0) */
-  expectedExitCode: z13.number().default(0).optional()
+  expectedExitCode: z14.number().default(0).optional()
 });
 
 // src/test/file-presence.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var FilePresenceTestSchema = BaseTestSchema.extend({
-  type: z14.literal("FILE_PRESENCE" /* FILE_PRESENCE */),
+  type: z15.literal("FILE_PRESENCE" /* FILE_PRESENCE */),
   /** Paths to check */
-  paths: z14.array(z14.string()),
+  paths: z15.array(z15.string()),
   /** Whether files should exist (true) or not exist (false) */
-  shouldExist: z14.boolean()
+  shouldExist: z15.boolean()
 });
 
 // src/test/file-content.ts
-import { z as z15 } from "zod";
-var FileContentCheckSchema = z15.object({
+import { z as z16 } from "zod";
+var FileContentCheckSchema = z16.object({
   /** Strings that must be present in the file */
-  contains: z15.array(z15.string()).optional(),
+  contains: z16.array(z16.string()).optional(),
   /** Strings that must NOT be present in the file */
-  notContains: z15.array(z15.string()).optional(),
+  notContains: z16.array(z16.string()).optional(),
   /** Regex pattern the content must match */
-  matches: z15.string().optional(),
+  matches: z16.string().optional(),
   /** JSON path checks for structured content */
-  jsonPath: z15.array(
-    z15.object({
-      path: z15.string(),
-      value: z15.unknown()
+  jsonPath: z16.array(
+    z16.object({
+      path: z16.string(),
+      value: z16.unknown()
     })
   ).optional(),
   /** Lines that should be added (for diff checking) */
-  added: z15.array(z15.string()).optional(),
+  added: z16.array(z16.string()).optional(),
   /** Lines that should be removed (for diff checking) */
-  removed: z15.array(z15.string()).optional()
+  removed: z16.array(z16.string()).optional()
 });
 var FileContentTestSchema = BaseTestSchema.extend({
-  type: z15.literal("FILE_CONTENT" /* FILE_CONTENT */),
+  type: z16.literal("FILE_CONTENT" /* FILE_CONTENT */),
   /** Path to the file to check */
-  path: z15.string(),
+  path: z16.string(),
   /** Content checks to perform */
   checks: FileContentCheckSchema
 });
 
 // src/test/build-check.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var BuildCheckTestSchema = BaseTestSchema.extend({
-  type: z16.literal("BUILD_CHECK" /* BUILD_CHECK */),
+  type: z17.literal("BUILD_CHECK" /* BUILD_CHECK */),
   /** Build command to execute */
-  command: z16.string(),
+  command: z17.string(),
   /** Whether the build should succeed */
-  expectSuccess: z16.boolean(),
+  expectSuccess: z17.boolean(),
   /** Maximum allowed warnings (optional) */
-  allowedWarnings: z16.number().optional(),
+  allowedWarnings: z17.number().optional(),
   /** Timeout in milliseconds */
-  timeout: z16.number().optional()
+  timeout: z17.number().optional()
 });
 
 // src/test/vitest.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var VitestTestSchema = BaseTestSchema.extend({
-  type: z17.literal("VITEST" /* VITEST */),
+  type: z18.literal("VITEST" /* VITEST */),
   /** Test file content */
-  testFile: z17.string(),
+  testFile: z18.string(),
   /** Name of the test file */
-  testFileName: z17.string(),
+  testFileName: z18.string(),
   /** Minimum pass rate required (0-100) */
-  minPassRate: z17.number().min(0).max(100)
+  minPassRate: z18.number().min(0).max(100)
 });
 
 // src/test/playwright-nl.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var PlaywrightNLTestSchema = BaseTestSchema.extend({
-  type: z18.literal("PLAYWRIGHT_NL" /* PLAYWRIGHT_NL */),
+  type: z19.literal("PLAYWRIGHT_NL" /* PLAYWRIGHT_NL */),
   /** Natural language steps to execute */
-  steps: z18.array(z18.string()),
+  steps: z19.array(z19.string()),
   /** Expected outcome description */
-  expectedOutcome: z18.string(),
+  expectedOutcome: z19.string(),
   /** Timeout in milliseconds */
-  timeout: z18.number().optional()
+  timeout: z19.number().optional()
 });
 
 // src/test/index.ts
-var TestSchema = z19.discriminatedUnion("type", [
+var TestSchema = z20.discriminatedUnion("type", [
   LLMTestSchema,
   ToolTestSchema,
   SiteConfigTestSchema,
@@ -1307,44 +1334,52 @@ var TestSchema = z19.discriminatedUnion("type", [
 ]);
 
 // src/scenario/assertions.ts
-import { z as z20 } from "zod";
-var SkillWasCalledAssertionSchema = z20.object({
-  type: z20.literal("skill_was_called"),
+import { z as z21 } from "zod";
+var SkillWasCalledAssertionSchema = z21.object({
+  type: z21.literal("skill_was_called"),
   /** Names of the skills that must have been called (matched against trace Skill tool args) */
-  skillNames: z20.array(z20.string().min(1)).min(1)
+  skillNames: z21.array(z21.string().min(1)).min(1)
 });
-var BuildPassedAssertionSchema = z20.object({
-  type: z20.literal("build_passed"),
+var ToolCalledWithParamAssertionSchema = z21.object({
+  type: z21.literal("tool_called_with_param"),
+  /** Name of the tool that must have been called */
+  toolName: z21.string().min(1),
+  /** JSON string of key-value pairs for expected parameters (substring match) */
+  expectedParams: z21.string().min(1)
+});
+var BuildPassedAssertionSchema = z21.object({
+  type: z21.literal("build_passed"),
   /** Command to run (default: "yarn build") */
-  command: z20.string().optional(),
+  command: z21.string().optional(),
   /** Expected exit code (default: 0) */
-  expectedExitCode: z20.number().int().optional()
+  expectedExitCode: z21.number().int().optional()
 });
-var CostAssertionSchema = z20.object({
-  type: z20.literal("cost"),
+var CostAssertionSchema = z21.object({
+  type: z21.literal("cost"),
   /** Maximum allowed cost in USD */
-  maxCostUsd: z20.number().positive()
+  maxCostUsd: z21.number().positive()
 });
-var LlmJudgeAssertionSchema = z20.object({
-  type: z20.literal("llm_judge"),
+var LlmJudgeAssertionSchema = z21.object({
+  type: z21.literal("llm_judge"),
   /** Prompt template; placeholders: {{output}}, {{cwd}}, {{changedFiles}}, {{trace}} */
-  prompt: z20.string(),
+  prompt: z21.string(),
   /** Optional system prompt for the judge (default asks for JSON with score) */
-  systemPrompt: z20.string().optional(),
+  systemPrompt: z21.string().optional(),
   /** Minimum score to pass (0-100, default 70) */
-  minScore: z20.number().int().min(0).max(100).optional(),
+  minScore: z21.number().int().min(0).max(100).optional(),
   /** Model for the judge (e.g. claude-3-5-haiku) */
-  model: z20.string().optional(),
-  maxTokens: z20.number().int().optional(),
-  temperature: z20.number().min(0).max(1).optional()
+  model: z21.string().optional(),
+  maxTokens: z21.number().int().optional(),
+  temperature: z21.number().min(0).max(1).optional()
 });
-var TimeAssertionSchema = z20.object({
-  type: z20.literal("time_limit"),
+var TimeAssertionSchema = z21.object({
+  type: z21.literal("time_limit"),
   /** Maximum allowed duration in milliseconds */
-  maxDurationMs: z20.number().int().positive()
+  maxDurationMs: z21.number().int().positive()
 });
-var AssertionSchema = z20.union([
+var AssertionSchema = z21.union([
   SkillWasCalledAssertionSchema,
+  ToolCalledWithParamAssertionSchema,
   BuildPassedAssertionSchema,
   TimeAssertionSchema,
   CostAssertionSchema,
@@ -1352,33 +1387,33 @@ var AssertionSchema = z20.union([
 ]);
 
 // 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 */
@@ -1386,64 +1421,71 @@ var EnvironmentSchema = z21.object({
 });
 
 // src/scenario/test-scenario.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // src/assertion/assertion.ts
-import { z as z22 } from "zod";
-var AssertionTypeSchema = z22.enum([
+import { z as z23 } from "zod";
+var AssertionTypeSchema = z23.enum([
   "skill_was_called",
+  "tool_called_with_param",
   "build_passed",
   "time_limit",
   "cost",
   "llm_judge"
 ]);
-var AssertionParameterTypeSchema = z22.enum([
+var AssertionParameterTypeSchema = z23.enum([
   "string",
   "number",
   "boolean"
 ]);
-var AssertionParameterSchema = z22.object({
+var AssertionParameterSchema = z23.object({
   /** Parameter name (used as key in params object) */
-  name: z22.string().min(1),
+  name: z23.string().min(1),
   /** Display label for the parameter */
-  label: z22.string().min(1),
+  label: z23.string().min(1),
   /** Parameter type */
   type: AssertionParameterTypeSchema,
   /** Whether this parameter is required */
-  required: z22.boolean(),
+  required: z23.boolean(),
   /** Default value (optional, used when not provided) */
-  defaultValue: z22.union([z22.string(), z22.number(), z22.boolean()]).optional(),
+  defaultValue: z23.union([z23.string(), z23.number(), z23.boolean()]).optional(),
   /** If true, parameter is hidden by default behind "Show advanced options" */
-  advanced: z22.boolean().optional()
+  advanced: z23.boolean().optional()
 });
-var ScenarioAssertionLinkSchema = z22.object({
+var ScenarioAssertionLinkSchema = z23.object({
   /** ID of the assertion (can be system assertion like 'system:skill_was_called' or custom assertion UUID) */
-  assertionId: z22.string(),
+  assertionId: z23.string(),
   /** Parameter values for this assertion in this scenario */
-  params: z22.record(
-    z22.string(),
-    z22.union([z22.string(), z22.number(), z22.boolean(), z22.null()])
+  params: z23.record(
+    z23.string(),
+    z23.union([z23.string(), z23.number(), z23.boolean(), z23.null()])
   ).optional()
 });
-var SkillWasCalledConfigSchema = z22.object({
+var SkillWasCalledConfigSchema = z23.object({
   /** Names of the skills that must have been called */
-  skillNames: z22.array(z22.string().min(1)).min(1)
+  skillNames: z23.array(z23.string().min(1)).min(1)
 });
-var CostConfigSchema = z22.strictObject({
+var CostConfigSchema = z23.strictObject({
   /** Maximum allowed cost in USD */
-  maxCostUsd: z22.number().positive()
+  maxCostUsd: z23.number().positive()
+});
+var ToolCalledWithParamConfigSchema = z23.strictObject({
+  /** Name of the tool that must have been called */
+  toolName: z23.string().min(1),
+  /** JSON string of key-value pairs for expected parameters (substring match) */
+  expectedParams: z23.string().min(1)
 });
-var BuildPassedConfigSchema = z22.strictObject({
+var BuildPassedConfigSchema = z23.strictObject({
   /** Command to run (default: "yarn build") */
-  command: z22.string().optional(),
+  command: z23.string().optional(),
   /** Expected exit code (default: 0) */
-  expectedExitCode: z22.number().int().optional()
+  expectedExitCode: z23.number().int().optional()
 });
-var TimeConfigSchema = z22.strictObject({
+var TimeConfigSchema = z23.strictObject({
   /** Maximum allowed duration in milliseconds */
-  maxDurationMs: z22.number().int().positive()
+  maxDurationMs: z23.number().int().positive()
 });
-var LlmJudgeConfigSchema = z22.object({
+var LlmJudgeConfigSchema = z23.object({
   /**
    * Prompt template with placeholders:
    * - {{output}}: agent's final output
@@ -1454,32 +1496,34 @@ var LlmJudgeConfigSchema = z22.object({
    * - {{trace}}: step-by-step trace of tool calls
    * - Custom parameters defined in the parameters array
    */
-  prompt: z22.string().min(1),
+  prompt: z23.string().min(1),
   /** Optional system prompt for the judge */
-  systemPrompt: z22.string().optional(),
+  systemPrompt: z23.string().optional(),
   /** Minimum score to pass (0-100, default 70) */
-  minScore: z22.number().int().min(0).max(100).optional(),
+  minScore: z23.number().int().min(0).max(100).optional(),
   /** Model for the judge (e.g. claude-3-5-haiku-20241022) */
-  model: z22.string().optional(),
+  model: z23.string().optional(),
   /** Max output tokens */
-  maxTokens: z22.number().int().optional(),
+  maxTokens: z23.number().int().optional(),
   /** Temperature (0-1) */
-  temperature: z22.number().min(0).max(1).optional(),
+  temperature: z23.number().min(0).max(1).optional(),
   /** User-defined parameters for this assertion */
-  parameters: z22.array(AssertionParameterSchema).optional()
+  parameters: z23.array(AssertionParameterSchema).optional()
 });
-var AssertionConfigSchema = z22.union([
+var AssertionConfigSchema = z23.union([
   LlmJudgeConfigSchema,
   // requires prompt - check first
   SkillWasCalledConfigSchema,
   // requires skillNames
+  ToolCalledWithParamConfigSchema,
+  // requires toolName + expectedParams, uses strictObject
   TimeConfigSchema,
   // requires maxDurationMs, uses strictObject
   CostConfigSchema,
   // requires maxCostUsd, uses strictObject
   BuildPassedConfigSchema,
   // all optional, uses strictObject to reject unknown keys
-  z22.object({})
+  z23.object({})
   // fallback empty config
 ]);
 var CustomAssertionSchema = TenantEntitySchema.extend({
@@ -1501,6 +1545,8 @@ function validateAssertionConfig(type, config) {
       return SkillWasCalledConfigSchema.safeParse(config).success;
     case "cost":
       return CostConfigSchema.safeParse(config).success;
+    case "tool_called_with_param":
+      return ToolCalledWithParamConfigSchema.safeParse(config).success;
     case "build_passed":
       return BuildPassedConfigSchema.safeParse(config).success;
     case "time_limit":
@@ -1528,23 +1574,23 @@ function getLlmJudgeConfig(assertion) {
 }
 
 // src/scenario/test-scenario.ts
-var ExpectedFileSchema = z23.object({
+var ExpectedFileSchema = z24.object({
   /** Relative path where the file should be created */
-  path: z23.string(),
+  path: z24.string(),
   /** Optional expected content */
-  content: z23.string().optional()
+  content: z24.string().optional()
 });
 var TestScenarioSchema = TenantEntitySchema.extend({
   /** The prompt sent to the agent to trigger the task */
-  triggerPrompt: z23.string().min(10),
+  triggerPrompt: z24.string().min(10),
   /** ID of the template to use for this scenario (null = no template) */
-  templateId: z23.string().nullish(),
+  templateId: z24.string().nullish(),
   /** Inline assertions to evaluate for this scenario (legacy) */
-  assertions: z23.array(AssertionSchema).optional(),
+  assertions: z24.array(AssertionSchema).optional(),
   /** IDs of saved assertions to evaluate (from assertions table) - legacy, use assertionLinks */
-  assertionIds: z23.array(z23.string()).optional(),
+  assertionIds: z24.array(z24.string()).optional(),
   /** Linked assertions with per-scenario parameter values */
-  assertionLinks: z23.array(ScenarioAssertionLinkSchema).optional()
+  assertionLinks: z24.array(ScenarioAssertionLinkSchema).optional()
 });
 var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
   id: true,
@@ -1555,10 +1601,10 @@ var CreateTestScenarioInputSchema = TestScenarioSchema.omit({
 var UpdateTestScenarioInputSchema = CreateTestScenarioInputSchema.partial();
 
 // src/suite/test-suite.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var TestSuiteSchema = TenantEntitySchema.extend({
   /** IDs of test scenarios in this suite */
-  scenarioIds: z24.array(z24.string())
+  scenarioIds: z25.array(z25.string())
 });
 var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
   id: true,
@@ -1569,21 +1615,21 @@ var CreateTestSuiteInputSchema = TestSuiteSchema.omit({
 var UpdateTestSuiteInputSchema = CreateTestSuiteInputSchema.partial();
 
 // src/evaluation/metrics.ts
-import { z as z25 } from "zod";
-var TokenUsageSchema = z25.object({
-  prompt: z25.number(),
-  completion: z25.number(),
-  total: z25.number()
-});
-var EvalMetricsSchema = z25.object({
-  totalAssertions: z25.number(),
-  passed: z25.number(),
-  failed: z25.number(),
-  skipped: z25.number(),
-  errors: z25.number(),
-  passRate: z25.number(),
-  avgDuration: z25.number(),
-  totalDuration: z25.number()
+import { z as z26 } from "zod";
+var TokenUsageSchema = z26.object({
+  prompt: z26.number(),
+  completion: z26.number(),
+  total: z26.number()
+});
+var EvalMetricsSchema = z26.object({
+  totalAssertions: z26.number(),
+  passed: z26.number(),
+  failed: z26.number(),
+  skipped: z26.number(),
+  errors: z26.number(),
+  passRate: z26.number(),
+  avgDuration: z26.number(),
+  totalDuration: z26.number()
 });
 var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["PENDING"] = "pending";
@@ -1593,7 +1639,7 @@ var EvalStatus = /* @__PURE__ */ ((EvalStatus2) => {
   EvalStatus2["CANCELLED"] = "cancelled";
   return EvalStatus2;
 })(EvalStatus || {});
-var EvalStatusSchema = z25.enum(EvalStatus);
+var EvalStatusSchema = z26.enum(EvalStatus);
 var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["COMPLETION"] = "completion";
   LLMStepType2["TOOL_USE"] = "tool_use";
@@ -1601,52 +1647,52 @@ var LLMStepType = /* @__PURE__ */ ((LLMStepType2) => {
   LLMStepType2["THINKING"] = "thinking";
   return LLMStepType2;
 })(LLMStepType || {});
-var LLMTraceStepSchema = z25.object({
-  id: z25.string(),
-  stepNumber: z25.number(),
-  type: z25.enum(LLMStepType),
-  model: z25.string(),
-  provider: z25.string(),
-  startedAt: z25.string(),
-  durationMs: z25.number(),
+var LLMTraceStepSchema = z26.object({
+  id: z26.string(),
+  stepNumber: z26.number(),
+  type: z26.enum(LLMStepType),
+  model: z26.string(),
+  provider: z26.string(),
+  startedAt: z26.string(),
+  durationMs: z26.number(),
   tokenUsage: TokenUsageSchema,
-  costUsd: z25.number(),
-  toolName: z25.string().optional(),
-  toolArguments: z25.string().optional(),
-  inputPreview: z25.string().optional(),
-  outputPreview: z25.string().optional(),
-  success: z25.boolean(),
-  error: z25.string().optional()
-});
-var LLMBreakdownStatsSchema = z25.object({
-  count: z25.number(),
-  durationMs: z25.number(),
-  tokens: z25.number(),
-  costUsd: z25.number()
-});
-var LLMTraceSummarySchema = z25.object({
-  totalSteps: z25.number(),
-  totalDurationMs: z25.number(),
+  costUsd: z26.number(),
+  toolName: z26.string().optional(),
+  toolArguments: z26.string().optional(),
+  inputPreview: z26.string().optional(),
+  outputPreview: z26.string().optional(),
+  success: z26.boolean(),
+  error: z26.string().optional()
+});
+var LLMBreakdownStatsSchema = z26.object({
+  count: z26.number(),
+  durationMs: z26.number(),
+  tokens: z26.number(),
+  costUsd: z26.number()
+});
+var LLMTraceSummarySchema = z26.object({
+  totalSteps: z26.number(),
+  totalDurationMs: z26.number(),
   totalTokens: TokenUsageSchema,
-  totalCostUsd: z25.number(),
-  stepTypeBreakdown: z25.record(z25.string(), LLMBreakdownStatsSchema).optional(),
-  modelBreakdown: z25.record(z25.string(), LLMBreakdownStatsSchema),
-  modelsUsed: z25.array(z25.string())
-});
-var LLMTraceSchema = z25.object({
-  id: z25.string(),
-  steps: z25.array(LLMTraceStepSchema),
+  totalCostUsd: z26.number(),
+  stepTypeBreakdown: z26.record(z26.string(), LLMBreakdownStatsSchema).optional(),
+  modelBreakdown: z26.record(z26.string(), LLMBreakdownStatsSchema),
+  modelsUsed: z26.array(z26.string())
+});
+var LLMTraceSchema = z26.object({
+  id: z26.string(),
+  steps: z26.array(LLMTraceStepSchema),
   summary: LLMTraceSummarySchema
 });
 
 // src/evaluation/eval-result.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 
 // src/evaluation/eval-run.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 
 // src/evaluation/live-trace.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["THINKING"] = "thinking";
   LiveTraceEventType2["TOOL_USE"] = "tool_use";
@@ -1660,37 +1706,37 @@ var LiveTraceEventType = /* @__PURE__ */ ((LiveTraceEventType2) => {
   LiveTraceEventType2["USER"] = "user";
   return LiveTraceEventType2;
 })(LiveTraceEventType || {});
-var LiveTraceEventSchema = z26.object({
+var LiveTraceEventSchema = z27.object({
   /** The evaluation run ID */
-  evalRunId: z26.string(),
+  evalRunId: z27.string(),
   /** The scenario ID being executed */
-  scenarioId: z26.string(),
+  scenarioId: z27.string(),
   /** The scenario name for display */
-  scenarioName: z26.string(),
+  scenarioName: z27.string(),
   /** The target ID (skill, agent, etc.) */
-  targetId: z26.string(),
+  targetId: z27.string(),
   /** The target name for display */
-  targetName: z26.string(),
+  targetName: z27.string(),
   /** Step number in the current scenario execution */
-  stepNumber: z26.number(),
+  stepNumber: z27.number(),
   /** Type of trace event */
-  type: z26.enum(LiveTraceEventType),
+  type: z27.enum(LiveTraceEventType),
   /** Tool name if this is a tool_use event */
-  toolName: z26.string().optional(),
+  toolName: z27.string().optional(),
   /** Tool arguments preview (truncated JSON) */
-  toolArgs: z26.string().optional(),
+  toolArgs: z27.string().optional(),
   /** Output preview (truncated text) */
-  outputPreview: z26.string().optional(),
+  outputPreview: z27.string().optional(),
   /** File path for file operations */
-  filePath: z26.string().optional(),
+  filePath: z27.string().optional(),
   /** Elapsed time in milliseconds for progress events */
-  elapsedMs: z26.number().optional(),
+  elapsedMs: z27.number().optional(),
   /** Thinking/reasoning text from Claude */
-  thinking: z26.string().optional(),
+  thinking: z27.string().optional(),
   /** Timestamp when this event occurred */
-  timestamp: z26.string(),
+  timestamp: z27.string(),
   /** Whether this is the final event for this scenario */
-  isComplete: z26.boolean()
+  isComplete: z27.boolean()
 });
 var TRACE_EVENT_PREFIX = "TRACE_EVENT:";
 function parseTraceEventLine(line) {
@@ -1718,14 +1764,14 @@ var TriggerType = /* @__PURE__ */ ((TriggerType2) => {
   TriggerType2["MANUAL"] = "MANUAL";
   return TriggerType2;
 })(TriggerType || {});
-var TriggerMetadataSchema = z27.object({
-  version: z27.string().optional(),
-  resourceUpdated: z27.array(z27.string()).optional()
+var TriggerMetadataSchema = z28.object({
+  version: z28.string().optional(),
+  resourceUpdated: z28.array(z28.string()).optional()
 });
-var TriggerSchema = z27.object({
-  id: z27.string(),
+var TriggerSchema = z28.object({
+  id: z28.string(),
   metadata: TriggerMetadataSchema.optional(),
-  type: z27.enum(TriggerType)
+  type: z28.enum(TriggerType)
 });
 var FailureCategory = /* @__PURE__ */ ((FailureCategory2) => {
   FailureCategory2["MISSING_FILE"] = "missing_file";
@@ -1743,28 +1789,28 @@ var FailureSeverity = /* @__PURE__ */ ((FailureSeverity2) => {
   FailureSeverity2["LOW"] = "low";
   return FailureSeverity2;
 })(FailureSeverity || {});
-var DiffLineTypeSchema = z27.enum(["added", "removed", "unchanged"]);
-var DiffLineSchema = z27.object({
+var DiffLineTypeSchema = z28.enum(["added", "removed", "unchanged"]);
+var DiffLineSchema = z28.object({
   type: DiffLineTypeSchema,
-  content: z27.string(),
-  lineNumber: z27.number()
-});
-var DiffContentSchema = z27.object({
-  path: z27.string(),
-  expected: z27.string(),
-  actual: z27.string(),
-  diffLines: z27.array(DiffLineSchema),
-  renamedFrom: z27.string().optional()
-});
-var CommandExecutionSchema = z27.object({
-  command: z27.string(),
-  exitCode: z27.number(),
-  output: z27.string().optional(),
-  duration: z27.number()
-});
-var FileModificationSchema = z27.object({
-  path: z27.string(),
-  action: z27.enum(["created", "modified", "deleted"])
+  content: z28.string(),
+  lineNumber: z28.number()
+});
+var DiffContentSchema = z28.object({
+  path: z28.string(),
+  expected: z28.string(),
+  actual: z28.string(),
+  diffLines: z28.array(DiffLineSchema),
+  renamedFrom: z28.string().optional()
+});
+var CommandExecutionSchema = z28.object({
+  command: z28.string(),
+  exitCode: z28.number(),
+  output: z28.string().optional(),
+  duration: z28.number()
+});
+var FileModificationSchema = z28.object({
+  path: z28.string(),
+  action: z28.enum(["created", "modified", "deleted"])
 });
 var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["NEW"] = "new";
@@ -1772,81 +1818,83 @@ var TemplateFileStatus = /* @__PURE__ */ ((TemplateFileStatus2) => {
   TemplateFileStatus2["UNCHANGED"] = "unchanged";
   return TemplateFileStatus2;
 })(TemplateFileStatus || {});
-var TemplateFileSchema = z27.object({
+var TemplateFileSchema = z28.object({
   /** Relative path within the template */
-  path: z27.string(),
+  path: z28.string(),
   /** Full file content after execution */
-  content: z27.string(),
+  content: z28.string(),
   /** File status (new, modified, unchanged) */
-  status: z27.enum(["new", "modified", "unchanged"])
-});
-var ApiCallSchema = z27.object({
-  endpoint: z27.string(),
-  tokensUsed: z27.number(),
-  duration: z27.number()
-});
-var ExecutionTraceSchema = z27.object({
-  commands: z27.array(CommandExecutionSchema),
-  filesModified: z27.array(FileModificationSchema),
-  apiCalls: z27.array(ApiCallSchema),
-  totalDuration: z27.number()
-});
-var FailureAnalysisSchema = z27.object({
-  category: z27.enum(FailureCategory),
-  severity: z27.enum(FailureSeverity),
-  summary: z27.string(),
-  details: z27.string(),
-  rootCause: z27.string(),
-  suggestedFix: z27.string(),
-  relatedAssertions: z27.array(z27.string()),
-  codeSnippet: z27.string().optional(),
-  similarIssues: z27.array(z27.string()).optional(),
-  patternId: z27.string().optional(),
+  status: z28.enum(["new", "modified", "unchanged"])
+});
+var ApiCallSchema = z28.object({
+  endpoint: z28.string(),
+  tokensUsed: z28.number(),
+  duration: z28.number()
+});
+var ExecutionTraceSchema = z28.object({
+  commands: z28.array(CommandExecutionSchema),
+  filesModified: z28.array(FileModificationSchema),
+  apiCalls: z28.array(ApiCallSchema),
+  totalDuration: z28.number()
+});
+var FailureAnalysisSchema = z28.object({
+  category: z28.enum(FailureCategory),
+  severity: z28.enum(FailureSeverity),
+  summary: z28.string(),
+  details: z28.string(),
+  rootCause: z28.string(),
+  suggestedFix: z28.string(),
+  relatedAssertions: z28.array(z28.string()),
+  codeSnippet: z28.string().optional(),
+  similarIssues: z28.array(z28.string()).optional(),
+  patternId: z28.string().optional(),
   // Extended fields for detailed debugging
   diff: DiffContentSchema.optional(),
   executionTrace: ExecutionTraceSchema.optional()
 });
 var EvalRunSchema = TenantEntitySchema.extend({
   /** Agent ID for this run */
-  agentId: z27.string().optional(),
+  agentId: z28.string().optional(),
   /** Skills group ID for this run */
-  skillsGroupId: z27.string().optional(),
+  skillsGroupId: z28.string().optional(),
   /** Map of skillId to skillVersionId for this run */
-  skillVersions: z27.record(z27.string(), z27.string()).optional(),
+  skillVersions: z28.record(z28.string(), z28.string()).optional(),
   /** Scenario IDs to run */
-  scenarioIds: z27.array(z27.string()),
+  scenarioIds: z28.array(z28.string()),
   /** Current status */
   status: EvalStatusSchema,
   /** Progress percentage (0-100) */
-  progress: z27.number(),
+  progress: z28.number(),
   /** Results for each scenario/target combination (lazy to break eval-result ↔ eval-run cycle) */
-  results: z27.array(z27.lazy(() => EvalRunResultSchema)),
+  results: z28.array(z28.lazy(() => EvalRunResultSchema)),
   /** Aggregated metrics across all results */
   aggregateMetrics: EvalMetricsSchema,
   /** Failure analyses */
-  failureAnalyses: z27.array(FailureAnalysisSchema).optional(),
+  failureAnalyses: z28.array(FailureAnalysisSchema).optional(),
   /** Aggregated LLM trace summary */
   llmTraceSummary: LLMTraceSummarySchema.optional(),
   /** What triggered this run */
   trigger: TriggerSchema.optional(),
   /** When the run started (set when evaluation is triggered) */
-  startedAt: z27.string().optional(),
+  startedAt: z28.string().optional(),
   /** When the run completed */
-  completedAt: z27.string().optional(),
+  completedAt: z28.string().optional(),
   /** Live trace events captured during execution (for playback on results page) */
-  liveTraceEvents: z27.array(LiveTraceEventSchema).optional(),
+  liveTraceEvents: z28.array(LiveTraceEventSchema).optional(),
   /** Remote job ID for tracking execution in Dev Machines */
-  jobId: z27.string().optional(),
+  jobId: z28.string().optional(),
   /** Remote job status from the Dev Machine API (PENDING, RUNNING, COMPLETED, FAILED, CANCELLED) */
-  jobStatus: z27.string().optional(),
+  jobStatus: z28.string().optional(),
   /** Remote job error message if the job failed */
-  jobError: z27.string().optional(),
+  jobError: z28.string().optional(),
   /** Timestamp of the last job status check */
-  jobStatusCheckedAt: z27.string().optional(),
+  jobStatusCheckedAt: z28.string().optional(),
   /** MCP server IDs to enable for this run (optional) */
-  mcpIds: z27.array(z27.string()).optional(),
+  mcpIds: z28.array(z28.string()).optional(),
   /** Sub-agent IDs to enable for this run (optional) */
-  subAgentIds: z27.array(z27.string()).optional()
+  subAgentIds: z28.array(z28.string()).optional(),
+  /** Rule IDs to enable for this run (optional) */
+  ruleIds: z28.array(z28.string()).optional()
 });
 var CreateEvalRunInputSchema = EvalRunSchema.omit({
   id: true,
@@ -1859,28 +1907,28 @@ var CreateEvalRunInputSchema = EvalRunSchema.omit({
   startedAt: true,
   completedAt: true
 });
-var EvaluationProgressSchema = z27.object({
-  runId: z27.string(),
-  targetId: z27.string(),
-  totalScenarios: z27.number(),
-  completedScenarios: z27.number(),
-  scenarioProgress: z27.array(
-    z27.object({
-      scenarioId: z27.string(),
-      currentStep: z27.string(),
-      error: z27.string().optional()
+var EvaluationProgressSchema = z28.object({
+  runId: z28.string(),
+  targetId: z28.string(),
+  totalScenarios: z28.number(),
+  completedScenarios: z28.number(),
+  scenarioProgress: z28.array(
+    z28.object({
+      scenarioId: z28.string(),
+      currentStep: z28.string(),
+      error: z28.string().optional()
     })
   ),
-  createdAt: z27.number()
+  createdAt: z28.number()
 });
-var EvaluationLogSchema = z27.object({
-  runId: z27.string(),
-  scenarioId: z27.string(),
-  log: z27.object({
-    level: z27.enum(["info", "error", "debug"]),
-    message: z27.string().optional(),
-    args: z27.array(z27.any()).optional(),
-    error: z27.string().optional()
+var EvaluationLogSchema = z28.object({
+  runId: z28.string(),
+  scenarioId: z28.string(),
+  log: z28.object({
+    level: z28.enum(["info", "error", "debug"]),
+    message: z28.string().optional(),
+    args: z28.array(z28.any()).optional(),
+    error: z28.string().optional()
   })
 });
 var LLM_TIMEOUT = 12e4;
@@ -1893,95 +1941,95 @@ var AssertionResultStatus = /* @__PURE__ */ ((AssertionResultStatus2) => {
   AssertionResultStatus2["ERROR"] = "error";
   return AssertionResultStatus2;
 })(AssertionResultStatus || {});
-var AssertionResultSchema = z28.object({
-  id: z28.string(),
-  assertionId: z28.string(),
-  assertionType: z28.string(),
-  assertionName: z28.string(),
-  status: z28.enum(AssertionResultStatus),
-  message: z28.string().optional(),
-  expected: z28.string().optional(),
-  actual: z28.string().optional(),
-  duration: z28.number().optional(),
-  details: z28.record(z28.string(), z28.unknown()).optional(),
-  llmTraceSteps: z28.array(LLMTraceStepSchema).optional()
-});
-var EvalRunResultSchema = z28.object({
-  id: z28.string(),
-  targetId: z28.string(),
-  targetName: z28.string().optional(),
+var AssertionResultSchema = z29.object({
+  id: z29.string(),
+  assertionId: z29.string(),
+  assertionType: z29.string(),
+  assertionName: z29.string(),
+  status: z29.enum(AssertionResultStatus),
+  message: z29.string().optional(),
+  expected: z29.string().optional(),
+  actual: z29.string().optional(),
+  duration: z29.number().optional(),
+  details: z29.record(z29.string(), z29.unknown()).optional(),
+  llmTraceSteps: z29.array(LLMTraceStepSchema).optional()
+});
+var EvalRunResultSchema = z29.object({
+  id: z29.string(),
+  targetId: z29.string(),
+  targetName: z29.string().optional(),
   /** SkillVersion ID used for this evaluation (for version tracking) */
-  skillVersionId: z28.string().optional(),
+  skillVersionId: z29.string().optional(),
   /** SkillVersion semver string (e.g., "1.0.0", "1.2.3") for display */
-  skillVersion: z28.string().optional(),
-  scenarioId: z28.string(),
-  scenarioName: z28.string(),
+  skillVersion: z29.string().optional(),
+  scenarioId: z29.string(),
+  scenarioName: z29.string(),
   modelConfig: ModelConfigSchema.optional(),
-  assertionResults: z28.array(AssertionResultSchema),
+  assertionResults: z29.array(AssertionResultSchema),
   metrics: EvalMetricsSchema.optional(),
-  passed: z28.number(),
-  failed: z28.number(),
-  passRate: z28.number(),
-  duration: z28.number(),
-  outputText: z28.string().optional(),
-  files: z28.array(ExpectedFileSchema).optional(),
-  fileDiffs: z28.array(DiffContentSchema).optional(),
+  passed: z29.number(),
+  failed: z29.number(),
+  passRate: z29.number(),
+  duration: z29.number(),
+  outputText: z29.string().optional(),
+  files: z29.array(ExpectedFileSchema).optional(),
+  fileDiffs: z29.array(DiffContentSchema).optional(),
   /** Full template files after execution with status indicators */
-  templateFiles: z28.array(TemplateFileSchema).optional(),
-  startedAt: z28.string().optional(),
-  completedAt: z28.string().optional(),
+  templateFiles: z29.array(TemplateFileSchema).optional(),
+  startedAt: z29.string().optional(),
+  completedAt: z29.string().optional(),
   llmTrace: LLMTraceSchema.optional()
 });
-var PromptResultSchema = z28.object({
-  text: z28.string(),
-  files: z28.array(z28.unknown()).optional(),
-  finishReason: z28.string().optional(),
-  reasoning: z28.string().optional(),
-  reasoningDetails: z28.unknown().optional(),
-  toolCalls: z28.array(z28.unknown()).optional(),
-  toolResults: z28.array(z28.unknown()).optional(),
-  warnings: z28.array(z28.unknown()).optional(),
-  sources: z28.array(z28.unknown()).optional(),
-  steps: z28.array(z28.unknown()),
-  generationTimeMs: z28.number(),
-  prompt: z28.string(),
-  systemPrompt: z28.string(),
-  usage: z28.object({
-    totalTokens: z28.number().optional(),
-    totalMicrocentsSpent: z28.number().optional()
+var PromptResultSchema = z29.object({
+  text: z29.string(),
+  files: z29.array(z29.unknown()).optional(),
+  finishReason: z29.string().optional(),
+  reasoning: z29.string().optional(),
+  reasoningDetails: z29.unknown().optional(),
+  toolCalls: z29.array(z29.unknown()).optional(),
+  toolResults: z29.array(z29.unknown()).optional(),
+  warnings: z29.array(z29.unknown()).optional(),
+  sources: z29.array(z29.unknown()).optional(),
+  steps: z29.array(z29.unknown()),
+  generationTimeMs: z29.number(),
+  prompt: z29.string(),
+  systemPrompt: z29.string(),
+  usage: z29.object({
+    totalTokens: z29.number().optional(),
+    totalMicrocentsSpent: z29.number().optional()
   })
 });
-var EvaluationResultSchema = z28.object({
-  id: z28.string(),
-  runId: z28.string(),
-  timestamp: z28.number(),
+var EvaluationResultSchema = z29.object({
+  id: z29.string(),
+  runId: z29.string(),
+  timestamp: z29.number(),
   promptResult: PromptResultSchema,
-  testResults: z28.array(z28.unknown()),
-  tags: z28.array(z28.string()).optional(),
-  feedback: z28.string().optional(),
-  score: z28.number(),
-  suiteId: z28.string().optional()
-});
-var LeanEvaluationResultSchema = z28.object({
-  id: z28.string(),
-  runId: z28.string(),
-  timestamp: z28.number(),
-  tags: z28.array(z28.string()).optional(),
-  scenarioId: z28.string(),
-  scenarioVersion: z28.number().optional(),
-  targetId: z28.string(),
-  targetVersion: z28.number().optional(),
-  suiteId: z28.string().optional(),
-  score: z28.number(),
-  time: z28.number().optional(),
-  microcentsSpent: z28.number().optional()
+  testResults: z29.array(z29.unknown()),
+  tags: z29.array(z29.string()).optional(),
+  feedback: z29.string().optional(),
+  score: z29.number(),
+  suiteId: z29.string().optional()
+});
+var LeanEvaluationResultSchema = z29.object({
+  id: z29.string(),
+  runId: z29.string(),
+  timestamp: z29.number(),
+  tags: z29.array(z29.string()).optional(),
+  scenarioId: z29.string(),
+  scenarioVersion: z29.number().optional(),
+  targetId: z29.string(),
+  targetVersion: z29.number().optional(),
+  suiteId: z29.string().optional(),
+  score: z29.number(),
+  time: z29.number().optional(),
+  microcentsSpent: z29.number().optional()
 });
 
 // src/project/project.ts
-import { z as z29 } from "zod";
+import { z as z30 } from "zod";
 var ProjectSchema = BaseEntitySchema.extend({
-  appId: z29.string().optional().describe("The ID of the app in Dev Center"),
-  appSecret: z29.string().optional().describe("The secret of the app in Dev Center")
+  appId: z30.string().optional().describe("The ID of the app in Dev Center"),
+  appSecret: z30.string().optional().describe("The secret of the app in Dev Center")
 });
 var CreateProjectInputSchema = ProjectSchema.omit({
   id: true,
@@ -2007,6 +2055,7 @@ var UpdateTemplateInputSchema = CreateTemplateInputSchema.partial();
 // src/assertion/system-assertions.ts
 var SYSTEM_ASSERTION_IDS = {
   SKILL_WAS_CALLED: "system:skill_was_called",
+  TOOL_CALLED_WITH_PARAM: "system:tool_called_with_param",
   BUILD_PASSED: "system:build_passed",
   TIME_LIMIT: "system:time_limit",
   COST: "system:cost",
@@ -2030,6 +2079,26 @@ var SYSTEM_ASSERTIONS = {
       }
     ]
   },
+  [SYSTEM_ASSERTION_IDS.TOOL_CALLED_WITH_PARAM]: {
+    id: SYSTEM_ASSERTION_IDS.TOOL_CALLED_WITH_PARAM,
+    name: "Tool Called With Param",
+    description: "Check that a tool was called with expected parameters",
+    type: "tool_called_with_param",
+    parameters: [
+      {
+        name: "toolName",
+        label: "Tool Name",
+        type: "string",
+        required: true
+      },
+      {
+        name: "expectedParams",
+        label: "Expected Parameters (JSON, substring match)",
+        type: "string",
+        required: true
+      }
+    ]
+  },
   [SYSTEM_ASSERTION_IDS.BUILD_PASSED]: {
     id: SYSTEM_ASSERTION_IDS.BUILD_PASSED,
     name: "Build Passed",
@@ -2148,6 +2217,7 @@ var export_ClaudeModel = import_types.ClaudeModel;
 export {
   AVAILABLE_MODEL_IDS,
   AVAILABLE_RUN_COMMANDS,
+  AVAILABLE_TOOL_NAMES,
   AgentRunCommand,
   AgentRunCommandSchema,
   AgentSchema,
@@ -2176,6 +2246,7 @@ export {
   CreateEvalRunInputSchema,
   CreateMcpInputSchema,
   CreateProjectInputSchema,
+  CreateRuleInputSchema,
   CreateSkillInputSchema,
   CreateSkillVersionInputSchema,
   CreateSkillsGroupInputSchema,
@@ -2230,6 +2301,8 @@ export {
   ProjectSchema,
   PromptResultSchema,
   RUN_COMMAND_LABELS,
+  RuleSchema,
+  RuleTypeSchema,
   SEMVER_REGEX,
   SKILL_FOLDER_NAME_REGEX,
   SYSTEM_ASSERTIONS,
@@ -2262,6 +2335,8 @@ export {
   TimeAssertionSchema,
   TimeConfigSchema,
   TokenUsageSchema,
+  ToolCalledWithParamAssertionSchema,
+  ToolCalledWithParamConfigSchema,
   ToolTestSchema,
   TriggerMetadataSchema,
   TriggerSchema,
@@ -2270,6 +2345,7 @@ export {
   UpdateCustomAssertionInputSchema,
   UpdateMcpInputSchema,
   UpdateProjectInputSchema,
+  UpdateRuleInputSchema,
   UpdateSkillInputSchema,
   UpdateSkillsGroupInputSchema,
   UpdateSubAgentInputSchema,