agentv 5.2.0-next.1 → 5.3.0-next.1

package/dist/{chunk-3S6A2RKR.js → chunk-6ZZCDZPD.js}

@@ -8114,7 +8114,7 @@ function toFiniteNumber(value) {
   return void 0;
 }
 
-// ../../packages/core/dist/chunk-3A6FPNWI.js
+// ../../packages/core/dist/chunk-QMPBDTFI.js
 var SDK_CHILD_PROTOCOL_VERSION = 1;
 function providerRequestToWire(request) {
   if (request.tools && request.tools.length > 0) {
@@ -8146,6 +8146,7 @@ function providerResponseFromWire(response) {
   return {
     raw: response.raw,
     usage: response.usage,
+    metadata: response.metadata,
     output: response.output,
     tokenUsage: response.token_usage,
     costUsd: response.cost_usd,
@@ -12198,7 +12199,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-DYGAVJOU.js
+// ../../packages/core/dist/chunk-RXN2AWVO.js
 import { parse } from "yaml";
 import path3 from "node:path";
 import path22 from "node:path";
@@ -12292,6 +12293,13 @@ var GRADER_KIND_VALUES = [
   "script",
   "llm-grader",
   "tool-trajectory",
+  "skill-used",
+  "not-skill-used",
+  "trajectory:tool-used",
+  "trajectory:tool-args-match",
+  "trajectory:tool-sequence",
+  "trajectory:step-count",
+  "trajectory:goal-success",
   "field-accuracy",
   "latency",
   "cost",
@@ -15846,6 +15854,141 @@ function subscribeToCodexLogEntries(listener) {
   };
 }
 
+// ../../packages/core/dist/chunk-7FVITOZM.js
+var SKILL_PATH_PATTERN = /(?:^|[/"'\s])(?:\.agents\/)?skills\/([^/"'\s]+)\/SKILL\.md(?:$|[)"'\s,;:])/g;
+function deriveSkillCallsFromMessages(messages) {
+  if (!messages) {
+    return [];
+  }
+  return deriveSkillCallsFromToolCalls(messages.flatMap((message) => message.toolCalls ?? []));
+}
+function deriveSkillCallsFromToolCalls(toolCalls) {
+  if (!toolCalls) {
+    return [];
+  }
+  const skillCalls = [];
+  const heuristicKeys = /* @__PURE__ */ new Set();
+  const pushHeuristic = (entry) => {
+    const key = `${entry.name}\0${entry.path ?? ""}\0${entry.source ?? ""}`;
+    if (heuristicKeys.has(key)) {
+      return;
+    }
+    heuristicKeys.add(key);
+    skillCalls.push(entry);
+  };
+  for (const toolCall of toolCalls) {
+    const toolName = toolCall.tool.toLowerCase();
+    const input = asRecord(toolCall.input);
+    const isError = isErroredToolCall(toolCall);
+    if (toolName === "skill") {
+      const skillName = normalizeSkillName(input?.skill ?? input?.name);
+      if (skillName) {
+        skillCalls.push(
+          dropUndefined({ name: skillName, input: toolCall.input, source: "tool", isError })
+        );
+      }
+      continue;
+    }
+    if (toolName === "read") {
+      const path49 = normalizeText(input?.file_path ?? input?.path ?? input?.filePath);
+      const skillName = path49 ? skillNameFromPath(path49) : void 0;
+      if (skillName) {
+        pushHeuristic(
+          dropUndefined({
+            name: skillName,
+            input: toolCall.input,
+            path: path49,
+            source: "heuristic",
+            isError
+          })
+        );
+      }
+      continue;
+    }
+    if (toolName === "bash") {
+      const command = normalizeText(input?.command);
+      if (command) {
+        for (const candidate of skillPathCandidates(command)) {
+          pushHeuristic(
+            dropUndefined({
+              name: candidate.name,
+              input: toolCall.input,
+              path: candidate.path,
+              source: "heuristic",
+              isError
+            })
+          );
+        }
+      }
+    }
+    if (toolCall.output !== void 0) {
+      const outputText = typeof toolCall.output === "string" ? toolCall.output : JSON.stringify(toolCall.output);
+      for (const candidate of skillPathCandidates(outputText)) {
+        pushHeuristic(
+          dropUndefined({
+            name: candidate.name,
+            path: candidate.path,
+            source: "heuristic",
+            isError
+          })
+        );
+      }
+    }
+  }
+  return skillCalls;
+}
+function skillCallMetadata(skillCalls) {
+  if (skillCalls.length === 0) {
+    return void 0;
+  }
+  return { skillCalls };
+}
+function skillPathCandidates(text) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const rawToken of text.split(/\s+/)) {
+    const token = rawToken.replace(/^[`"'([{<]+|[`"',;:)\]}>]+$/g, "").replace(/\\/g, "/");
+    const match = token.match(/(?:^|\/)(?:\.agents\/)?skills\/([^/\s]+)\/SKILL\.md$/);
+    if (match && isValidSkillName(match[1])) {
+      candidates.set(token, { name: match[1], path: token });
+    }
+  }
+  for (const match of text.replace(/\\/g, "/").matchAll(SKILL_PATH_PATTERN)) {
+    const pathMatch = match[0].match(/(?:\.agents\/)?skills\/([^/"'\s]+)\/SKILL\.md/);
+    const name = pathMatch?.[1];
+    if (name && isValidSkillName(name)) {
+      candidates.set(pathMatch[0], { name, path: pathMatch[0] });
+    }
+  }
+  return Array.from(candidates.values());
+}
+function skillNameFromPath(path49) {
+  const normalized = path49.replace(/\\/g, "/");
+  const match = normalized.match(/(?:^|\/)(?:\.agents\/)?skills\/([^/\s]+)\/SKILL\.md$/);
+  const name = match?.[1];
+  return name && isValidSkillName(name) ? name : void 0;
+}
+function isErroredToolCall(toolCall) {
+  if (toolCall.status === void 0 || toolCall.status === "ok" || toolCall.status === "unknown") {
+    return void 0;
+  }
+  return true;
+}
+function normalizeSkillName(value) {
+  return normalizeText(value);
+}
+function normalizeText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function isValidSkillName(name) {
+  return /^[A-Za-z0-9._:-]+$/.test(name);
+}
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+
 // ../../packages/core/dist/chunk-YRELA7BA.js
 var TOOL_NAME_MAP = /* @__PURE__ */ new Map([
   // --- Claude (already canonical) ---
@@ -16093,7 +16236,7 @@ function pathToFileUri(filePath) {
   return `file://${normalizedPath}`;
 }
 
-// ../../packages/core/dist/chunk-3B7EZ2GI.js
+// ../../packages/core/dist/chunk-WBZHD7AZ.js
 import path48 from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 import { existsSync as existsSync6 } from "node:fs";
@@ -16120,6 +16263,7 @@ import path42 from "node:path";
 import { readFile as readFile23 } from "node:fs/promises";
 import path33 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import path52 from "node:path";
 import { pathToFileURL as pathToFileURL22 } from "node:url";
 import { spawn } from "node:child_process";
@@ -28763,7 +28907,7 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../packages/core/dist/chunk-3B7EZ2GI.js
+// ../../packages/core/dist/chunk-WBZHD7AZ.js
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { mkdir as mkdir6, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
@@ -28912,8 +29056,8 @@ function shouldSkipCacheForTemperature(targetConfig) {
   return false;
 }
 var DEFAULT_THRESHOLD2 = 0.8;
-function scoreToVerdict(score, threshold = DEFAULT_THRESHOLD2) {
-  return score >= threshold ? "pass" : "fail";
+function scoreToVerdict(score2, threshold = DEFAULT_THRESHOLD2) {
+  return score2 >= threshold ? "pass" : "fail";
 }
 function clampScore(value) {
   if (Number.isNaN(value) || !Number.isFinite(value)) {
@@ -28984,12 +29128,12 @@ var NEGATED_VERDICT = {
   fail: "pass",
   skip: "skip"
 };
-function negateScore(score) {
+function negateScore(score2) {
   return {
-    ...score,
-    score: clampScore(1 - score.score),
-    verdict: NEGATED_VERDICT[score.verdict],
-    assertions: score.assertions.map((a) => ({
+    ...score2,
+    score: clampScore(1 - score2.score),
+    verdict: NEGATED_VERDICT[score2.verdict],
+    assertions: score2.assertions.map((a) => ({
       ...a,
       passed: !a.passed,
       evidence: a.evidence ? `[Negated] ${a.evidence}` : void 0
@@ -29905,14 +30049,14 @@ function checksToAssertions(checks) {
 }
 function normalizeScriptProtocol(parsed) {
   const checks = parseScriptChecks(parsed.checks);
-  const score = optionalScore(parsed, "score") ?? (checks.length > 0 ? checks.reduce((sum, check2) => sum + (check2.score ?? (check2.pass ? 1 : 0)), 0) / checks.length : typeof parsed.pass === "boolean" ? parsed.pass ? 1 : 0 : 0);
-  const pass = typeof parsed.pass === "boolean" ? parsed.pass : scoreToVerdict(score) === "pass";
+  const score2 = optionalScore(parsed, "score") ?? (checks.length > 0 ? checks.reduce((sum, check2) => sum + (check2.score ?? (check2.pass ? 1 : 0)), 0) / checks.length : typeof parsed.pass === "boolean" ? parsed.pass ? 1 : 0 : 0);
+  const pass = typeof parsed.pass === "boolean" ? parsed.pass : scoreToVerdict(score2) === "pass";
   const reason = optionalString(parsed, "reason");
   const details = parsed.details && typeof parsed.details === "object" && !Array.isArray(parsed.details) ? parsed.details : void 0;
   if (typeof parsed.pass !== "boolean" && typeof parsed.score !== "number" && checks.length === 0) {
     throw new Error("Script evaluator JSON must include pass, score, or checks[]");
   }
-  return { pass, score, reason, checks, details };
+  return { pass, score: score2, reason, checks, details };
 }
 var ScriptGrader = class {
   kind = "script";
@@ -30051,8 +30195,8 @@ var ScriptGrader = class {
       const protocol = parsed != null ? normalizeScriptProtocol(parsed) : void 0;
       const checks = protocol?.checks ?? [];
       const assertions = protocol != null ? checksToAssertions(checks) : [{ text: stdout.trim() || (passed ? "exit 0" : `exit ${exitCode}`), passed }];
-      const score = protocol?.score ?? (passed ? 1 : 0);
-      const verdict = protocol ? protocol.pass ? "pass" : "fail" : scoreToVerdict(score);
+      const score2 = protocol?.score ?? (passed ? 1 : 0);
+      const verdict = protocol ? protocol.pass ? "pass" : "fail" : scoreToVerdict(score2);
       const reason = protocol?.reason;
       const details = protocol?.details;
       const proxyUsage = getProxyUsage?.();
@@ -30067,7 +30211,7 @@ var ScriptGrader = class {
         } : {}
       };
       return {
-        score,
+        score: score2,
         verdict,
         reason,
         checks,
@@ -30174,10 +30318,10 @@ var CostGrader = class {
       };
     }
     const passed = costUsd <= budget;
-    const score = passed ? 1 : 0;
+    const score2 = passed ? 1 : 0;
     const formatCost = (n) => `$${n.toFixed(4)}`;
     return {
-      score,
+      score: score2,
       verdict: passed ? "pass" : "fail",
       assertions: [
         passed ? { text: `Cost ${formatCost(costUsd)} <= ${formatCost(budget)} budget`, passed: true } : { text: `Cost ${formatCost(costUsd)} > ${formatCost(budget)} budget`, passed: false }
@@ -31279,10 +31423,10 @@ var ExecutionMetricsGrader = class {
     }
     const totalChecks = assertions.length;
     const passedCount = assertions.filter((a) => a.passed).length;
-    const score = totalChecks > 0 ? passedCount / totalChecks : 0;
+    const score2 = totalChecks > 0 ? passedCount / totalChecks : 0;
     return {
-      score,
-      verdict: scoreToVerdict(score),
+      score: score2,
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: totalChecks || 1,
       graderRawRequest: {
@@ -31618,22 +31762,22 @@ var FieldAccuracyGrader = class {
     for (const result of results) {
       assertions.push({ text: result.message, passed: result.hit });
     }
-    let score;
+    let score2;
     if (aggregation === "all_or_nothing") {
       const hasFailed = assertions.some((a) => !a.passed);
-      score = hasFailed ? 0 : 1;
+      score2 = hasFailed ? 0 : 1;
     } else {
       const totalWeight = results.reduce((sum, r) => sum + r.weight, 0);
       if (totalWeight === 0) {
-        score = results.length === 0 ? 1 : 0;
+        score2 = results.length === 0 ? 1 : 0;
       } else {
         const weightedSum = results.reduce((sum, r) => sum + r.score * r.weight, 0);
-        score = weightedSum / totalWeight;
+        score2 = weightedSum / totalWeight;
       }
     }
     return {
-      score: clampScore(score),
-      verdict: scoreToVerdict(score),
+      score: clampScore(score2),
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: results.length
     };
@@ -31752,9 +31896,9 @@ var LatencyGrader = class {
       };
     }
     const passed = durationMs <= threshold;
-    const score = passed ? 1 : 0;
+    const score2 = passed ? 1 : 0;
     return {
-      score,
+      score: score2,
       verdict: passed ? "pass" : "fail",
       assertions: [
         passed ? { text: `Duration ${durationMs}ms <= ${threshold}ms threshold`, passed: true } : { text: `Duration ${durationMs}ms > ${threshold}ms threshold`, passed: false }
@@ -32139,12 +32283,12 @@ function promptfooFallbackText(config2, fallbackText) {
   }
   return fallbackText;
 }
-function promptfooFallbackReason(pass, score, threshold) {
+function promptfooFallbackReason(pass, score2, threshold) {
   if (pass) {
     return "Grading passed";
   }
-  if (threshold !== void 0 && score < threshold) {
-    return `Score ${score} below threshold ${threshold}`;
+  if (threshold !== void 0 && score2 < threshold) {
+    return `Score ${score2} below threshold ${threshold}`;
   }
   return "Grading failed";
 }
@@ -32187,14 +32331,14 @@ function normalizePromptfooGradingResult(options) {
   });
   const threshold = promptfooThreshold(options.config);
   const rawPass = data.pass !== void 0 ? normalizePromptfooPass(data.pass) : normalizedChecks && normalizedChecks.length > 0 ? normalizedChecks.every((check2) => check2.pass) : true;
-  const score = data.score !== void 0 ? normalizePromptfooScore(data.score, rawPass) : normalizedChecks && normalizedChecks.length > 0 ? normalizedChecks.reduce((total, check2) => {
+  const score2 = data.score !== void 0 ? normalizePromptfooScore(data.score, rawPass) : normalizedChecks && normalizedChecks.length > 0 ? normalizedChecks.reduce((total, check2) => {
     if (typeof check2.score === "number") {
       return total + check2.score;
     }
     return total + Number(check2.pass);
   }, 0) / normalizedChecks.length : normalizePromptfooScore(void 0, rawPass);
-  const pass = threshold !== void 0 ? rawPass && score >= threshold : rawPass;
-  const reason = data.reason?.trim() || promptfooFallbackReason(pass, score, threshold);
+  const pass = threshold !== void 0 ? rawPass && score2 >= threshold : rawPass;
+  const reason = data.reason?.trim() || promptfooFallbackReason(pass, score2, threshold);
   const assertions = normalizedChecks && normalizedChecks.length > 0 ? normalizedChecks.map((check2) => ({
     text: check2.text,
     passed: check2.pass,
@@ -32207,12 +32351,12 @@ function normalizePromptfooGradingResult(options) {
     }
   ];
   return {
-    score,
+    score: score2,
     verdict: pass ? "pass" : "fail",
     assertions,
     details: {
       pass,
-      score,
+      score: score2,
       reason,
       ...threshold !== void 0 ? { threshold } : {},
       ...normalizedChecks && normalizedChecks.length > 0 ? { checks: normalizedChecks } : {}
@@ -32318,11 +32462,11 @@ ${context.toolCalls}`;
             });
           }
           const data2 = freeformEvaluationSchema.parse(raw);
-          const score = clampScore(data2.score);
+          const score2 = clampScore(data2.score);
           const assertions = Array.isArray(data2.assertions) ? data2.assertions.slice(0, 8) : [];
           return {
-            score,
-            verdict: scoreToVerdict(score),
+            score: score2,
+            verdict: scoreToVerdict(score2),
             assertions,
             details: data2.details
           };
@@ -32436,9 +32580,9 @@ ${context.toolCalls}`;
         schema: scoreRangeEvaluationSchema,
         images
       });
-      const { score, verdict, assertions, details } = calculateScoreRangeResult(data, rubrics);
+      const { score: score2, verdict, assertions, details } = calculateScoreRangeResult(data, rubrics);
       return {
-        score,
+        score: score2,
         verdict,
         assertions,
         expectedAspectCount: rubrics.length,
@@ -32774,9 +32918,9 @@ ${outputSchema}`;
           };
         }
         const data2 = rubricEvaluationSchema.parse(parsed);
-        const { score: score2, verdict, assertions: assertions2 } = calculateRubricScore(data2, rubrics);
+        const { score: score3, verdict, assertions: assertions2 } = calculateRubricScore(data2, rubrics);
         return {
-          score: score2,
+          score: score3,
           verdict,
           assertions: assertions2,
           expectedAspectCount: rubrics.length,
@@ -32802,11 +32946,11 @@ ${outputSchema}`;
         };
       }
       const data = freeformEvaluationSchema.parse(parsed);
-      const score = clampScore(data.score);
+      const score2 = clampScore(data.score);
       const assertions = Array.isArray(data.assertions) ? data.assertions.slice(0, 8) : [];
       return {
-        score,
-        verdict: scoreToVerdict(score),
+        score: score2,
+        verdict: scoreToVerdict(score2),
         assertions,
         expectedAspectCount: Math.max(assertions.length, 1),
         graderRawRequest,
@@ -33131,9 +33275,9 @@ function calculateRubricScore(result, rubrics) {
       failedRequired = true;
     }
   }
-  const score = totalWeight > 0 ? Math.min(1, Math.max(0, earnedWeight / totalWeight)) : 0;
-  const verdict = failedRequired ? "fail" : scoreToVerdict(score);
-  return { score, verdict, assertions };
+  const score2 = totalWeight > 0 ? Math.min(1, Math.max(0, earnedWeight / totalWeight)) : 0;
+  const verdict = failedRequired ? "fail" : scoreToVerdict(score2);
+  return { score: score2, verdict, assertions };
 }
 function buildScoreRangeFormatInstructions() {
   return `You must return a valid JSON object matching this schema:
@@ -33190,10 +33334,10 @@ function calculateScoreRangeResult(result, rubrics) {
       evidence: check2.reasoning
     });
   }
-  const score = totalWeight > 0 ? Math.min(1, Math.max(0, weightedScoreSum / totalWeight)) : 0;
-  const verdict = failedRequired ? "fail" : scoreToVerdict(score);
+  const score2 = totalWeight > 0 ? Math.min(1, Math.max(0, weightedScoreSum / totalWeight)) : 0;
+  const verdict = failedRequired ? "fail" : scoreToVerdict(score2);
   return {
-    score,
+    score: score2,
     verdict,
     assertions,
     details: {
@@ -33473,6 +33617,174 @@ var SkillTriggerGrader = class {
     };
   }
 };
+var SkillUsedGrader = class {
+  constructor(config2) {
+    this.config = config2;
+    this.kind = config2.type;
+  }
+  kind;
+  evaluate(context) {
+    const inverse = this.config.type === "not-skill-used" || this.config.negate === true;
+    const skillCalls = getSkillCalls(context);
+    const actualSkills = skillCalls.map(formatSkillCall);
+    const expected = resolveSkillMatchers(this.config.value);
+    if (expected.kind === "list") {
+      return handleListSkillAssertion({
+        config: this.config,
+        inverse,
+        skillCalls,
+        actualSkills,
+        expected
+      });
+    }
+    return handleCountSkillAssertion({
+      config: this.config,
+      inverse,
+      skillCalls,
+      actualSkills,
+      matcher: expected.matcher
+    });
+  }
+};
+function getSkillCalls(context) {
+  const responseMetadata = context.responseMetadata ?? {};
+  const metadata = responseMetadata.metadata;
+  const rawSkillCalls = responseMetadata.skill_calls ?? responseMetadata.skillCalls ?? (isRecord2(metadata) ? metadata.skillCalls ?? metadata.skill_calls : void 0);
+  if (!Array.isArray(rawSkillCalls)) {
+    return [];
+  }
+  return rawSkillCalls.filter(
+    (entry) => isRecord2(entry) && typeof entry.name === "string" && entry.name.trim().length > 0 && entry.isError !== true && entry.is_error !== true
+  );
+}
+function matchesSkill(skillCall, matcher) {
+  if (matcher.name && skillCall.name !== matcher.name) {
+    return false;
+  }
+  if (matcher.pattern && !matchesPattern(skillCall.name, matcher.pattern)) {
+    return false;
+  }
+  return true;
+}
+function formatSkillCall(skillCall) {
+  const details = [skillCall.source, skillCall.path].filter(Boolean).join(", ");
+  return details ? `${skillCall.name} (${details})` : skillCall.name;
+}
+function resolveSkillMatchers(value) {
+  const normalizeText2 = (text) => typeof text === "string" ? text.trim() : void 0;
+  const validateCount = (field, count) => {
+    if (!Number.isFinite(count) || !Number.isInteger(count) || count < 0) {
+      throw new Error(`skill-used assertion object ${field} must be a finite non-negative integer`);
+    }
+  };
+  if (typeof value === "string" && value.trim()) {
+    const name = value.trim();
+    return {
+      kind: "list",
+      matchers: [{ name }]
+    };
+  }
+  if (Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.trim())) {
+    return {
+      kind: "list",
+      matchers: value.map((item) => ({ name: item.trim() }))
+    };
+  }
+  if (isRecord2(value)) {
+    const name = normalizeText2(value.name);
+    const pattern = normalizeText2(value.pattern);
+    if (!name && !pattern) {
+      throw new Error("skill-used assertion object must include a name or pattern property");
+    }
+    if ("min" in value) {
+      validateCount("min", value.min);
+    }
+    if ("max" in value) {
+      validateCount("max", value.max);
+    }
+    if (typeof value.min === "number" && typeof value.max === "number" && value.max < value.min) {
+      throw new Error("skill-used assertion object max must be greater than or equal to min");
+    }
+    return {
+      kind: "count",
+      matcher: {
+        max: typeof value.max === "number" ? value.max : void 0,
+        min: typeof value.min === "number" ? value.min : void 0,
+        name,
+        pattern
+      }
+    };
+  }
+  throw new Error("skill-used assertion must have a string, string array, or object value");
+}
+function handleListSkillAssertion(params) {
+  const { config: config2, inverse, skillCalls, actualSkills, expected } = params;
+  const missing = expected.matchers.filter(
+    (matcher) => !skillCalls.some((skillCall) => matchesSkill(skillCall, matcher))
+  );
+  const matched = expected.matchers.filter(
+    (matcher) => skillCalls.some((skillCall) => matchesSkill(skillCall, matcher))
+  );
+  const pass = inverse ? matched.length === 0 : missing.length === 0;
+  const expectedSkills = expected.matchers.map((matcher) => matcher.name);
+  const actualSummary = actualSkills.length > 0 ? actualSkills.join(", ") : "(none)";
+  let reason;
+  if (inverse) {
+    reason = pass ? `Forbidden skill(s) were not used: ${expectedSkills.join(", ")}` : `Forbidden skill(s) were used: ${matched.map((matcher) => matcher.name).join(", ")}. Actual skills: ${actualSummary}`;
+  } else if (pass) {
+    reason = `Observed required skill(s): ${expectedSkills.join(", ")}. Actual skills: ${actualSummary}`;
+  } else {
+    reason = `Missing required skill(s): ${missing.map((matcher) => matcher.name).join(", ")}. Actual skills: ${actualSummary}`;
+  }
+  return skillScore(config2, pass, reason);
+}
+function handleCountSkillAssertion(params) {
+  const { config: config2, inverse, skillCalls, actualSkills, matcher } = params;
+  const hasExplicitMin = matcher.min !== void 0;
+  const hasExplicitMax = matcher.max !== void 0;
+  const min = matcher.min ?? (hasExplicitMax ? 0 : 1);
+  const max = matcher.max;
+  const matchingSkillCalls = skillCalls.filter((skillCall) => matchesSkill(skillCall, matcher));
+  const count = matchingSkillCalls.length;
+  const matcherLabel = matcher.pattern || matcher.name || "*";
+  if (inverse) {
+    if (hasExplicitMin || hasExplicitMax && max !== 0) {
+      throw new Error(
+        "not-skill-used object assertions only support name/pattern with no count bounds, or max: 0"
+      );
+    }
+    const pass2 = count === 0;
+    const actualSummary = actualSkills.length > 0 ? actualSkills.join(", ") : "(none)";
+    const reason2 = pass2 ? `Forbidden skill "${matcherLabel}" was not used. Actual skills: ${actualSummary}` : `Forbidden skill "${matcherLabel}" was used ${count} time(s). Matches: ${matchingSkillCalls.map(formatSkillCall).join(", ")}`;
+    return skillScore(config2, pass2, reason2);
+  }
+  const pass = count >= min && (max === void 0 || count <= max);
+  let reason = `Matched skill "${matcherLabel}" ${count} time(s)`;
+  reason += max === void 0 ? ` (expected at least ${min})` : ` (expected ${min}-${max})`;
+  if (matchingSkillCalls.length > 0) {
+    reason += `. Matches: ${matchingSkillCalls.map(formatSkillCall).join(", ")}`;
+  }
+  return skillScore(config2, pass, reason);
+}
+function skillScore(config2, pass, reason) {
+  return {
+    score: pass ? 1 : 0,
+    verdict: pass ? "pass" : "fail",
+    reason,
+    assertions: [{ text: reason, passed: pass }],
+    expectedAspectCount: 1,
+    details: {
+      assertion_type: config2.type
+    }
+  };
+}
+function matchesPattern(skillName, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`, "i").test(skillName);
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function stringifyPretty2(value) {
   return value === void 0 ? "" : JSON.stringify(value, null, 2);
 }
@@ -33952,10 +34264,10 @@ var ToolTrajectoryGrader = class {
       }
     }
     const passedCount = assertions.filter((a) => a.passed).length;
-    const score = passedCount / toolNames.length;
+    const score2 = passedCount / toolNames.length;
     return {
-      score,
-      verdict: scoreToVerdict(score),
+      score: score2,
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: toolNames.length
     };
@@ -34038,10 +34350,10 @@ var ToolTrajectoryGrader = class {
     }
     const effectiveLatencyAssertions = latencyAssertionCount - latencySkips;
     const totalAssertions = expected.length + effectiveLatencyAssertions;
-    const score = totalAssertions > 0 ? (sequenceHits + latencyHits) / totalAssertions : 1;
+    const score2 = totalAssertions > 0 ? (sequenceHits + latencyHits) / totalAssertions : 1;
     return {
-      score,
-      verdict: scoreToVerdict(score),
+      score: score2,
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: totalAssertions
     };
@@ -34120,10 +34432,10 @@ var ToolTrajectoryGrader = class {
     }
     const effectiveLatencyAssertions = latencyAssertionCount - latencySkips;
     const totalAssertions = expected.length + effectiveLatencyAssertions;
-    const score = totalAssertions > 0 ? (sequenceHits + latencyHits) / totalAssertions : 1;
+    const score2 = totalAssertions > 0 ? (sequenceHits + latencyHits) / totalAssertions : 1;
     return {
-      score,
-      verdict: scoreToVerdict(score),
+      score: score2,
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: totalAssertions
     };
@@ -34168,10 +34480,10 @@ var ToolTrajectoryGrader = class {
       }
     }
     const passedCount = assertions.filter((a) => a.passed).length;
-    const score = expected.length > 0 ? passedCount / expected.length : 1;
+    const score2 = expected.length > 0 ? passedCount / expected.length : 1;
     return {
-      score,
-      verdict: scoreToVerdict(score),
+      score: score2,
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: expected.length
     };
@@ -34236,15 +34548,608 @@ var ToolTrajectoryGrader = class {
       }
     }
     const passedCount = assertions.filter((a) => a.passed).length;
-    const score = toolCalls.length > 0 ? passedCount / toolCalls.length : 1;
+    const score2 = toolCalls.length > 0 ? passedCount / toolCalls.length : 1;
     return {
-      score,
-      verdict: scoreToVerdict(score),
+      score: score2,
+      verdict: scoreToVerdict(score2),
       assertions,
       expectedAspectCount: toolCalls.length
     };
   }
 };
+var COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set(["exec_command", "local_shell", "shell"]);
+var SEARCH_NAME_PATTERN = /(^|[\s._:/-])(search|find|lookup|retriev(?:e|al))($|[\s._:/-])/i;
+function isRecord22(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function matchesPattern2(value, pattern) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  return new RegExp(`^${regexPattern}$`, "i").test(value);
+}
+function normalizeStructuredValue(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return trimmed;
+  }
+}
+function getFirstString(values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function commandFromInput(input) {
+  if (!isRecord22(input)) {
+    return void 0;
+  }
+  const command = input.cmd ?? input.command ?? input.commands;
+  if (typeof command === "string" && command.trim()) {
+    return command.trim();
+  }
+  if (Array.isArray(command)) {
+    const joined = command.map((part) => String(part).trim()).filter(Boolean).join(command === input.commands ? "; " : " ");
+    return joined || void 0;
+  }
+  return void 0;
+}
+function executableFromCommand(command) {
+  return command.trim().split(/\s+/)[0] || void 0;
+}
+function classifyMessageStep(event) {
+  const itemType = event.metadata?.["codex.item.type"] ?? event.message?.metadata?.["codex.item.type"];
+  if (itemType === "reasoning") {
+    return "reasoning";
+  }
+  return "message";
+}
+function eventToTrajectoryStep(event) {
+  const attributes = {
+    ...event.metadata ?? {},
+    ...event.message?.metadata ?? {},
+    ...event.tool?.metadata ?? {}
+  };
+  if (event.type === "tool_call" && event.tool) {
+    const toolName = event.tool.name;
+    const args = normalizeStructuredValue(event.tool.input);
+    const command = COMMAND_TOOL_NAMES.has(toolName.toLowerCase()) ? commandFromInput(args) : void 0;
+    if (command) {
+      const aliases = /* @__PURE__ */ new Set([command, toolName]);
+      const executable = executableFromCommand(command);
+      if (executable) {
+        aliases.add(executable);
+      }
+      return {
+        aliases: [...aliases],
+        ...args === void 0 ? {} : { args },
+        attributes,
+        name: command,
+        spanName: toolName,
+        startTime: event.timestamp,
+        type: "command"
+      };
+    }
+    return {
+      aliases: [toolName],
+      ...args === void 0 ? {} : { args },
+      attributes,
+      name: toolName,
+      spanName: toolName,
+      startTime: event.timestamp,
+      type: "tool"
+    };
+  }
+  const messageName = event.message?.name ?? event.type;
+  const query = getFirstString([event.metadata?.query, event.metadata?.search_query]);
+  if (query && SEARCH_NAME_PATTERN.test(messageName)) {
+    return {
+      aliases: [query, messageName],
+      attributes,
+      name: query,
+      spanName: messageName,
+      startTime: event.timestamp,
+      type: "search"
+    };
+  }
+  const messageType = event.type === "message" || event.type === "final_response";
+  const type = messageType ? classifyMessageStep(event) : "span";
+  return {
+    aliases: [messageName, type],
+    attributes,
+    name: messageName,
+    spanName: messageName,
+    startTime: event.timestamp,
+    type
+  };
+}
+function extractTrajectorySteps(trace) {
+  return [...trace.events].sort((left, right) => {
+    const leftTime = left.timestamp ? Date.parse(left.timestamp) : Number.NaN;
+    const rightTime = right.timestamp ? Date.parse(right.timestamp) : Number.NaN;
+    if (Number.isFinite(leftTime) && Number.isFinite(rightTime) && leftTime !== rightTime) {
+      return leftTime - rightTime;
+    }
+    return left.ordinal - right.ordinal;
+  }).map(eventToTrajectoryStep);
+}
+function normalizeMatcher(matcher, defaultType) {
+  if (typeof matcher === "string") {
+    return { pattern: matcher, ...defaultType ? { type: defaultType } : {} };
+  }
+  return { ...matcher, ...matcher.type ? {} : defaultType ? { type: defaultType } : {} };
+}
+function matchesTrajectoryStep(step, matcher, defaultType) {
+  const normalized = normalizeMatcher(matcher, defaultType);
+  if (normalized.type) {
+    const allowedTypes = Array.isArray(normalized.type) ? normalized.type : [normalized.type];
+    if (!allowedTypes.includes(step.type)) {
+      return false;
+    }
+  }
+  const matchPattern = normalized.pattern ?? normalized.name;
+  return matchPattern ? step.aliases.some((alias) => matchesPattern2(alias, matchPattern)) : true;
+}
+function formatStep(step) {
+  return `${step.type}:${step.name}`;
+}
+function formatArgs(args) {
+  if (args === void 0) {
+    return "(none)";
+  }
+  try {
+    return JSON.stringify(args) ?? String(args);
+  } catch {
+    return String(args);
+  }
+}
+function formatStepList(stepLabels) {
+  return stepLabels.length > 0 ? stepLabels.join(", ") : "(none)";
+}
+function score(pass, text) {
+  return {
+    score: pass ? 1 : 0,
+    verdict: scoreToVerdict(pass ? 1 : 0),
+    assertions: [{ text, passed: pass }],
+    expectedAspectCount: 1
+  };
+}
+function missingTrace(type) {
+  return score(false, `No trace data available for ${type} assertion`);
+}
+function requireNamedMatcher(matcher, assertionType, index) {
+  if (matcher.pattern || matcher.name) {
+    return;
+  }
+  const label = index === void 0 ? "object" : `step ${index + 1}`;
+  throw new Error(`${assertionType} assertion ${label} must include a name or pattern property`);
+}
+function resolveToolMatchers(value) {
+  if (typeof value === "string") {
+    return { kind: "list", matchers: [normalizeMatcher(value, "tool")] };
+  }
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return { kind: "list", matchers: value.map((item) => normalizeMatcher(item, "tool")) };
+  }
+  if (isRecord22(value)) {
+    const matcher = normalizeMatcher(value, "tool");
+    return {
+      kind: "count",
+      matcher: {
+        ...matcher,
+        ...typeof value.min === "number" ? { min: value.min } : {},
+        ...typeof value.max === "number" ? { max: value.max } : {}
+      }
+    };
+  }
+  throw new Error(
+    "trajectory:tool-used assertion must have a string, string array, or object value"
+  );
+}
+function evaluateToolUsed(config2, trace) {
+  const steps = extractTrajectorySteps(trace).filter((step) => step.type === "tool");
+  const expected = resolveToolMatchers(config2.value);
+  const inverse = config2.inverse === true;
+  if (expected.kind === "list") {
+    if (expected.matchers.length === 0) {
+      throw new Error("trajectory:tool-used assertion requires at least one expected tool");
+    }
+    const missing = expected.matchers.filter(
+      (matcher2) => !steps.some((step) => matchesTrajectoryStep(step, matcher2))
+    );
+    const matched = expected.matchers.filter(
+      (matcher2) => steps.some((step) => matchesTrajectoryStep(step, matcher2))
+    );
+    const pass2 = inverse ? matched.length === 0 : missing.length === 0;
+    const actualTools = steps.map(formatStep);
+    const expectedTools = expected.matchers.map(
+      (matcher2) => matcher2.pattern ?? matcher2.name ?? "*"
+    );
+    if (inverse) {
+      return score(
+        pass2,
+        pass2 ? `Forbidden tool(s) were not used: ${expectedTools.join(", ")}` : `Forbidden tool(s) were used: ${matched.map((matcher2) => matcher2.pattern ?? matcher2.name ?? "*").join(", ")}. Actual tools: ${formatStepList(actualTools)}`
+      );
+    }
+    return score(
+      pass2,
+      pass2 ? `Observed required tool(s): ${expectedTools.join(", ")}. Actual tools: ${formatStepList(actualTools)}` : `Missing required tool(s): ${missing.map((matcher2) => matcher2.pattern ?? matcher2.name ?? "*").join(", ")}. Actual tools: ${formatStepList(actualTools)}`
+    );
+  }
+  const matcher = expected.matcher;
+  const min = matcher.min ?? 1;
+  const max = matcher.max;
+  requireNamedMatcher(matcher, "trajectory:tool-used");
+  const matches = steps.filter((step) => matchesTrajectoryStep(step, matcher));
+  const count = matches.length;
+  const basePass = count >= min && (max === void 0 || count <= max);
+  const pass = inverse ? !basePass : basePass;
+  const label = matcher.pattern ?? matcher.name ?? "*";
+  if (inverse) {
+    return score(
+      pass,
+      basePass ? `Tool "${label}" matched ${count} time(s), which violates the inverse assertion` : `Tool "${label}" did not satisfy the forbidden match condition`
+    );
+  }
+  let reason = `Matched tool "${label}" ${count} time(s)`;
+  reason += max === void 0 ? ` (expected at least ${min})` : ` (expected ${min}-${max})`;
+  if (matches.length > 0) {
+    reason += `. Matches: ${matches.map(formatStep).join(", ")}`;
+  }
+  return score(pass, reason);
+}
+function resolveSequenceValue(value) {
+  if (Array.isArray(value)) {
+    return { mode: "in_order", steps: value };
+  }
+  if (isRecord22(value)) {
+    return {
+      mode: value.mode === "exact" ? "exact" : "in_order",
+      steps: Array.isArray(value.steps) ? value.steps : []
+    };
+  }
+  throw new Error("trajectory:tool-sequence assertion must have an array or object value");
+}
+function evaluateToolSequence(config2, trace) {
+  const toolSteps = extractTrajectorySteps(trace).filter((step) => step.type === "tool");
+  const value = resolveSequenceValue(config2.value);
+  const expected = value.steps.map((step, index) => {
+    const matcher = normalizeMatcher(step, "tool");
+    requireNamedMatcher(matcher, "trajectory:tool-sequence", index);
+    return matcher;
+  });
+  if (expected.length === 0) {
+    throw new Error("trajectory:tool-sequence assertion requires at least one expected step");
+  }
+  const actualTools = toolSteps.map(formatStep);
+  let basePass = false;
+  let reason = "";
+  if (value.mode === "exact") {
+    basePass = toolSteps.length === expected.length && expected.every((matcher, index) => matchesTrajectoryStep(toolSteps[index], matcher));
+    reason = basePass ? `Observed exact tool sequence: ${formatStepList(actualTools)}` : `Expected exact tool sequence of ${expected.map((matcher) => matcher.pattern ?? matcher.name ?? "*").join(", ")}, but actual tools were ${formatStepList(actualTools)}`;
+  } else {
+    let expectedIndex = 0;
+    const matchedSteps = [];
+    for (const step of toolSteps) {
+      if (expectedIndex >= expected.length) {
+        break;
+      }
+      if (matchesTrajectoryStep(step, expected[expectedIndex])) {
+        matchedSteps.push(formatStep(step));
+        expectedIndex += 1;
+      }
+    }
+    basePass = expectedIndex === expected.length;
+    reason = basePass ? `Observed tool sequence in order: ${matchedSteps.join(", ")}. Actual tools: ${formatStepList(actualTools)}` : `Expected tool "${expected[expectedIndex]?.pattern ?? expected[expectedIndex]?.name ?? "*"}" was not observed in order. Actual tools: ${formatStepList(actualTools)}`;
+  }
+  const inverse = config2.inverse === true;
+  return score(
+    inverse ? !basePass : basePass,
+    inverse ? basePass ? `Forbidden tool sequence was observed. Actual tools: ${formatStepList(actualTools)}` : "Forbidden tool sequence was not observed" : reason
+  );
+}
+function matchesExpectedArgsPartial(actual, expected) {
+  if (Array.isArray(expected)) {
+    return Array.isArray(actual) && actual.length === expected.length && expected.every((item, index) => matchesExpectedArgsPartial(actual[index], item));
+  }
+  if (isRecord22(expected)) {
+    if (!isRecord22(actual)) {
+      return false;
+    }
+    return Object.entries(expected).every(
+      ([key, expectedValue]) => Object.hasOwn(actual, key) && matchesExpectedArgsPartial(actual[key], expectedValue)
+    );
+  }
+  return isDeepStrictEqual(actual, expected);
+}
+function stripKeys(value, shouldStrip) {
+  if (!isRecord22(value)) {
+    return { cleaned: value, stripped: [] };
+  }
+  const cleaned = {};
+  const stripped = [];
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (shouldStrip(key, entryValue)) {
+      stripped.push(key);
+      continue;
+    }
+    Object.defineProperty(cleaned, key, {
+      value: entryValue,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  }
+  return { cleaned, stripped };
+}
+function stripDefaults(actual, defaults) {
+  if (!defaults) {
+    return { cleaned: actual, stripped: [] };
+  }
+  return stripKeys(
+    actual,
+    (key, value) => Object.hasOwn(defaults, key) && isDeepStrictEqual(value, defaults[key])
+  );
+}
+function stripIgnored(value, ignore) {
+  return stripKeys(
+    value,
+    (key) => ignore.some((entry) => /[*?]/.test(entry) ? matchesPattern2(key, entry) : entry === key)
+  );
+}
+function resolveArgsMatchValue(value) {
+  if (!isRecord22(value)) {
+    throw new Error("trajectory:tool-args-match assertion must have an object value");
+  }
+  const matcher = normalizeMatcher(value, "tool");
+  requireNamedMatcher(matcher, "trajectory:tool-args-match");
+  const expectedArgs = Object.hasOwn(value, "args") ? value.args : value.arguments;
+  if (expectedArgs === void 0) {
+    throw new Error(
+      "trajectory:tool-args-match assertion must include an args or arguments property"
+    );
+  }
+  const mode = value.mode ?? "partial";
+  if (mode !== "partial" && mode !== "exact") {
+    throw new Error('trajectory:tool-args-match assertion mode must be "partial" or "exact"');
+  }
+  const defaults = value.defaults;
+  if (defaults !== void 0 && !isRecord22(defaults)) {
+    throw new Error(
+      "trajectory:tool-args-match assertion defaults must be an object mapping argument names to default values"
+    );
+  }
+  const rawIgnore = value.ignore;
+  const ignore = rawIgnore === void 0 ? [] : Array.isArray(rawIgnore) ? rawIgnore : [rawIgnore];
+  if (ignore.some((entry) => typeof entry !== "string" || entry.trim().length === 0)) {
+    throw new Error(
+      "trajectory:tool-args-match assertion ignore must be a non-empty string or an array of non-empty strings"
+    );
+  }
+  return {
+    matcher,
+    expectedArgs,
+    mode,
+    defaults,
+    ignore
+  };
+}
+function argsMatch2(actual, expected, mode, defaults, ignore) {
+  const cleanedActual = stripDefaults(stripIgnored(actual, ignore).cleaned, defaults).cleaned;
+  const cleanedExpected = stripIgnored(expected, ignore).cleaned;
+  return mode === "exact" ? isDeepStrictEqual(cleanedActual, cleanedExpected) : matchesExpectedArgsPartial(cleanedActual, cleanedExpected);
+}
+function evaluateToolArgsMatch(config2, trace) {
+  const toolSteps = extractTrajectorySteps(trace).filter((step) => step.type === "tool");
+  const { matcher, expectedArgs, mode, defaults, ignore } = resolveArgsMatchValue(config2.value);
+  const label = matcher.pattern ?? matcher.name ?? "*";
+  const actualTools = toolSteps.map(formatStep);
+  const matchingSteps = toolSteps.filter((step) => matchesTrajectoryStep(step, matcher));
+  const stepsWithArgs = matchingSteps.filter((step) => step.args !== void 0);
+  const matchedStep = stepsWithArgs.find(
+    (step) => argsMatch2(step.args, expectedArgs, mode, defaults, ignore)
+  );
+  const basePass = matchedStep !== void 0;
+  const inverse = config2.inverse === true;
+  const pass = inverse ? !basePass : basePass;
+  const observedArgs = stepsWithArgs.length > 0 ? stepsWithArgs.map((step) => formatArgs(step.args)).join(", ") : "(none)";
+  if (inverse) {
+    if (basePass) {
+      return score(
+        pass,
+        `Forbidden argument match for tool "${label}" was observed on ${formatStep(
+          matchedStep
+        )}. Args: ${formatArgs(matchedStep?.args)}`
+      );
+    }
+    return score(
+      pass,
+      matchingSteps.length === 0 ? `Forbidden argument match for tool "${label}" was not observed because no tool call matched it` : `Forbidden argument match for tool "${label}" was not observed. Observed args: ${observedArgs}`
+    );
+  }
+  if (basePass) {
+    const ignoredArgs = stripIgnored(matchedStep.args, ignore).stripped;
+    const ignoredDefaults = stripDefaults(
+      stripIgnored(matchedStep.args, ignore).cleaned,
+      defaults
+    ).stripped;
+    const ignoredArgsSuffix = ignoredArgs.length > 0 ? `. Ignored argument(s): ${ignoredArgs.join(", ")}` : "";
+    const ignoredDefaultsSuffix = ignoredDefaults.length > 0 ? `. Ignored default argument(s): ${ignoredDefaults.join(", ")}` : "";
+    return score(
+      true,
+      `Tool "${label}" matched expected arguments (${mode}) on ${formatStep(
+        matchedStep
+      )}. Args: ${formatArgs(matchedStep.args)}${ignoredArgsSuffix}${ignoredDefaultsSuffix}`
+    );
+  }
+  if (matchingSteps.length === 0) {
+    return score(
+      false,
+      `No tool call matched "${label}". Actual tools: ${formatStepList(actualTools)}`
+    );
+  }
+  if (stepsWithArgs.length === 0) {
+    return score(
+      false,
+      `Tool "${label}" was observed but no arguments were captured. Actual tools: ${formatStepList(
+        actualTools
+      )}`
+    );
+  }
+  return score(
+    false,
+    `No call to tool "${label}" matched expected arguments (${mode}): ${formatArgs(
+      expectedArgs
+    )}. Observed args: ${observedArgs}`
+  );
+}
+function resolveStepCountValue(value) {
+  if (!isRecord22(value)) {
+    throw new Error("trajectory:step-count assertion must have an object value");
+  }
+  const matcher = normalizeMatcher(value);
+  return {
+    ...matcher,
+    ...typeof value.min === "number" ? { min: value.min } : {},
+    ...typeof value.max === "number" ? { max: value.max } : {}
+  };
+}
+function evaluateStepCount(config2, trace) {
+  const matcher = resolveStepCountValue(config2.value);
+  if (matcher.min === void 0 && matcher.max === void 0) {
+    throw new Error("trajectory:step-count assertion must include a min or max property");
+  }
+  const matchingSteps = extractTrajectorySteps(trace).filter(
+    (step) => matchesTrajectoryStep(step, matcher)
+  );
+  const count = matchingSteps.length;
+  const basePass = (matcher.min === void 0 || count >= matcher.min) && (matcher.max === void 0 || count <= matcher.max);
+  const inverse = config2.inverse === true;
+  const filterParts = [];
+  if (matcher.type) {
+    const types = Array.isArray(matcher.type) ? matcher.type : [matcher.type];
+    filterParts.push(`type=${types.join("|")}`);
+  }
+  const pattern = matcher.pattern ?? matcher.name;
+  if (pattern) {
+    filterParts.push(`pattern=${pattern}`);
+  }
+  let reason = `Matched ${count} trajectory step(s)`;
+  if (filterParts.length > 0) {
+    reason += ` for ${filterParts.join(", ")}`;
+  }
+  if (matcher.min !== void 0 && matcher.max !== void 0) {
+    reason += ` (expected ${matcher.min}-${matcher.max})`;
+  } else if (matcher.min !== void 0) {
+    reason += ` (expected at least ${matcher.min})`;
+  } else {
+    reason += ` (expected at most ${matcher.max})`;
+  }
+  if (matchingSteps.length > 0) {
+    reason += `. Matches: ${matchingSteps.map(formatStep).join(", ")}`;
+  }
+  return score(
+    inverse ? !basePass : basePass,
+    inverse ? basePass ? "Trajectory step count satisfied the forbidden range" : "Trajectory step count did not satisfy the forbidden range" : reason
+  );
+}
+function resolveGoal(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (isRecord22(value) && typeof value.goal === "string" && value.goal.trim()) {
+    return value.goal.trim();
+  }
+  throw new Error(
+    "trajectory:goal-success assertion must have a string value or an object with a goal property"
+  );
+}
+function summarizeTrajectoryForJudge(trace) {
+  const steps = extractTrajectorySteps(trace).map((step, index) => ({
+    index: index + 1,
+    type: step.type,
+    name: step.name,
+    ...step.spanName === step.name ? {} : { spanName: step.spanName }
+  }));
+  return JSON.stringify({ stepCount: steps.length, steps }, null, 2);
+}
+function buildGoalCriteria(goal, trajectory, output) {
+  return [
+    "Determine whether the agent successfully achieved the goal using the observed trajectory and final output.",
+    "",
+    `Goal: ${goal}`,
+    "",
+    "Trajectory:",
+    trajectory,
+    "",
+    "Final output:",
+    output
+  ].join("\n");
+}
+var TrajectoryGrader = class {
+  kind;
+  config;
+  llmGrader;
+  constructor(options) {
+    this.config = options.config;
+    this.kind = options.config.type;
+    this.llmGrader = options.llmGrader;
+  }
+  async evaluate(context) {
+    const trace = context.trace;
+    if (!trace) {
+      return missingTrace(this.config.type);
+    }
+    switch (this.config.type) {
+      case "trajectory:tool-used":
+        return evaluateToolUsed(this.config, trace);
+      case "trajectory:tool-args-match":
+        return evaluateToolArgsMatch(this.config, trace);
+      case "trajectory:tool-sequence":
+        return evaluateToolSequence(this.config, trace);
+      case "trajectory:step-count":
+        return evaluateStepCount(this.config, trace);
+      case "trajectory:goal-success": {
+        if (!this.llmGrader) {
+          throw new Error("trajectory:goal-success assertion requires an LLM grader");
+        }
+        const goal = resolveGoal(this.config.value);
+        const result = await this.llmGrader.evaluate({
+          ...context,
+          evalCase: {
+            ...context.evalCase,
+            criteria: buildGoalCriteria(
+              goal,
+              summarizeTrajectoryForJudge(trace),
+              context.candidate
+            )
+          },
+          evaluator: this.config
+        });
+        if (this.config.inverse !== true) {
+          return result;
+        }
+        const negated = negateScore(result);
+        const assertion = {
+          text: result.score >= 0.5 ? `Agent unexpectedly achieved the goal: ${goal}` : `Agent did not achieve the forbidden goal: ${goal}`,
+          passed: negated.score >= 0.5
+        };
+        return { ...negated, assertions: [assertion] };
+      }
+    }
+  }
+};
 function runContainsAssertion(output, value) {
   const passed = output.includes(value);
   return {
@@ -34672,6 +35577,7 @@ var ClaudeCliProvider = class {
           args,
           exitCode: result.exitCode
         },
+        metadata: skillCallMetadata(deriveSkillCallsFromToolCalls(completedToolCalls)),
         output,
         tokenUsage,
         costUsd,
@@ -36640,6 +37546,7 @@ ${basePrompt}` : basePrompt;
           inputFiles,
           logFile: logger?.filePath
         },
+        metadata: skillCallMetadata(deriveSkillCallsFromMessages(messages)),
         output: messages,
         durationMs,
         targetExecution: {
@@ -40308,7 +41215,7 @@ function toWireRecord(record2) {
     start_time: record2.startTime,
     end_time: record2.endTime
   };
-  const parsed = ReplayFixtureWireSchema.parse(dropUndefined(wire));
+  const parsed = ReplayFixtureWireSchema.parse(dropUndefined2(wire));
   return parsed;
 }
 function toWireMessage(message) {
@@ -40336,7 +41243,7 @@ function toWireToolCall(toolCall) {
     duration_ms: toolCall.durationMs
   };
 }
-function dropUndefined(value) {
+function dropUndefined2(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 function formatZodError(error40) {
@@ -40452,13 +41359,14 @@ function formatReplayLookupKey(lookup) {
 function replayFixtureRecordToProviderResponse(record2) {
   return {
     output: record2.output,
+    metadata: skillCallMetadata(deriveSkillCallsFromMessages(record2.output)),
     tokenUsage: record2.tokenUsage,
     costUsd: record2.costUsd,
     durationMs: record2.durationMs,
     startTime: record2.startTime,
     endTime: record2.endTime,
     raw: {
-      replay_fixture: dropUndefined({
+      replay_fixture: dropUndefined2({
         fixture_id: record2.fixtureId,
         suite: record2.suite,
         eval_path: record2.evalPath,
@@ -40531,7 +41439,7 @@ function buildFixtureId(input) {
   return `${input.sourceTarget}-${input.testId}-${digest}`;
 }
 function buildSourceMetadata(target, sourceTarget) {
-  return dropUndefined({
+  return dropUndefined2({
     provider: target.kind,
     target_name: sourceTarget,
     resolved_target: target.name,
@@ -40596,7 +41504,7 @@ var EXTERNAL_TRACE_KEYS = [
   "target"
 ];
 var TRACEPARENT_RE = /^[\da-f]{2}-[\da-f]{32}-[\da-f]{16}-[\da-f]{2}$/i;
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stringValue(value) {
@@ -40741,7 +41649,7 @@ function omitExternalTraceMetadataKeys(value) {
   return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
 function sanitizeExternalTraceMetadata(value) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     return void 0;
   }
   return sanitizeExternalTraceObject(externalTraceInputFromRecord(value));
@@ -41095,12 +42003,12 @@ var ProjectionIdentityWireSchema = external_exports.object({
   dimensions: ProjectionIdentityDimensionsWireSchema,
   issues: external_exports.array(ProjectionIdentityIssueWireSchema).optional()
 }).strict();
-function dropUndefined2(value) {
+function dropUndefined22(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 function toProjectionIdentityIssueWire(issue2) {
   return ProjectionIdentityIssueWireSchema.parse(
-    dropUndefined2({
+    dropUndefined22({
       code: issue2.code,
       severity: issue2.severity,
       field: issue2.field,
@@ -41118,7 +42026,7 @@ function fromProjectionIdentityIssueWire(issue2) {
 }
 function toProjectionIdentityWire(identity) {
   return ProjectionIdentityWireSchema.parse(
-    dropUndefined2({
+    dropUndefined22({
       schema_version: identity.schemaVersion,
       id: identity.id,
       key: identity.key,
@@ -41292,7 +42200,7 @@ var TraceEnvelopeWireSchema = external_exports.object({
 function dropUndefined3(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function isRecord22(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function definedStringRecord(value) {
@@ -41503,25 +42411,25 @@ function scoresFromResult(result, targetSpanId) {
   if (!result.scores || result.scores.length === 0) {
     return void 0;
   }
-  return result.scores.map((score) => ({
-    name: score.name,
-    type: score.type,
-    score: score.score,
-    weight: score.weight,
-    verdict: score.verdict,
-    source: scoreSource(score.type),
-    evaluatedAt: score.endedAt ?? score.startedAt ?? result.timestamp,
+  return result.scores.map((score2) => ({
+    name: score2.name,
+    type: score2.type,
+    score: score2.score,
+    weight: score2.weight,
+    verdict: score2.verdict,
+    source: scoreSource(score2.type),
+    evaluatedAt: score2.endedAt ?? score2.startedAt ?? result.timestamp,
     targetSpanId,
     evidence: dropUndefined3({
       span_ids: [targetSpanId],
-      assertions: (score.assertions ?? []).map(
+      assertions: (score2.assertions ?? []).map(
         (assertion) => dropUndefined3({
           text: assertion.text,
           passed: assertion.passed,
           evidence: assertion.evidence
         })
       ),
-      details: score.details
+      details: score2.details
     })
   }));
 }
@@ -41990,32 +42898,32 @@ function fromTraceEnvelopeConversionWarningWire(warning) {
     details: warning.details
   };
 }
-function toTraceEnvelopeScoreWire(score) {
+function toTraceEnvelopeScoreWire(score2) {
   return TraceEnvelopeScoreWireSchema.parse(
     dropUndefined3({
-      name: score.name,
-      type: score.type,
-      score: score.score,
-      weight: score.weight,
-      verdict: score.verdict,
-      source: score.source,
-      evaluated_at: score.evaluatedAt,
-      target_span_id: score.targetSpanId,
-      evidence: score.evidence
+      name: score2.name,
+      type: score2.type,
+      score: score2.score,
+      weight: score2.weight,
+      verdict: score2.verdict,
+      source: score2.source,
+      evaluated_at: score2.evaluatedAt,
+      target_span_id: score2.targetSpanId,
+      evidence: score2.evidence
     })
   );
 }
-function fromTraceEnvelopeScoreWire(score) {
+function fromTraceEnvelopeScoreWire(score2) {
   return {
-    name: score.name,
-    type: score.type,
-    score: score.score,
-    weight: score.weight,
-    verdict: score.verdict,
-    source: score.source,
-    evaluatedAt: score.evaluated_at,
-    targetSpanId: score.target_span_id,
-    evidence: score.evidence
+    name: score2.name,
+    type: score2.type,
+    score: score2.score,
+    weight: score2.weight,
+    verdict: score2.verdict,
+    source: score2.source,
+    evaluatedAt: score2.evaluated_at,
+    targetSpanId: score2.target_span_id,
+    evidence: score2.evidence
   };
 }
 function isToolSpan(span) {
@@ -42082,7 +42990,7 @@ function nearestAncestorToolCallId(ancestorIds, spansById) {
   return void 0;
 }
 function fromTranscriptToolCallWire(wire) {
-  if (!isRecord22(wire) || typeof wire.tool !== "string") {
+  if (!isRecord4(wire) || typeof wire.tool !== "string") {
     return void 0;
   }
   return {
@@ -42097,7 +43005,7 @@ function fromTranscriptToolCallWire(wire) {
   };
 }
 function fromTranscriptMessageWire(wire) {
-  if (!isRecord22(wire) || typeof wire.role !== "string") {
+  if (!isRecord4(wire) || typeof wire.role !== "string") {
     return void 0;
   }
   const toolCalls = Array.isArray(wire.tool_calls) ? wire.tool_calls.map(fromTranscriptToolCallWire).filter((toolCall) => toolCall !== void 0) : void 0;
@@ -42109,8 +43017,8 @@ function fromTranscriptMessageWire(wire) {
     startTime: typeof wire.start_time === "string" ? wire.start_time : void 0,
     endTime: typeof wire.end_time === "string" ? wire.end_time : void 0,
     durationMs: numberAttribute(wire, "duration_ms"),
-    metadata: isRecord22(wire.metadata) ? wire.metadata : void 0,
-    tokenUsage: isRecord22(wire.token_usage) ? tokenUsageFromAttributes({
+    metadata: isRecord4(wire.metadata) ? wire.metadata : void 0,
+    tokenUsage: isRecord4(wire.token_usage) ? tokenUsageFromAttributes({
       "gen_ai.usage.input_tokens": wire.token_usage.input,
       "gen_ai.usage.output_tokens": wire.token_usage.output,
       "gen_ai.usage.cache_read.input_tokens": wire.token_usage.cached,
@@ -42466,6 +43374,7 @@ function traceEnvelopeReplayRecordToProviderResponse(record2) {
   const wire = toTraceEnvelopeWire(record2.envelope);
   return {
     output,
+    metadata: skillCallMetadata(deriveSkillCallsFromMessages(output)),
     tokenUsage: summary.tokenUsage,
     costUsd: summary.costUsd,
     durationMs: summary.durationMs,
@@ -42581,9 +43490,10 @@ var CANONICAL_TRANSCRIPT_ARTIFACT_PATH = "transcript.json";
 var CANONICAL_METRICS_ARTIFACT_PATH = "metrics.json";
 var CANONICAL_FILE_CHANGES_ARTIFACT_PATH = "outputs/file_changes.diff";
 var TRANSCRIPT_SCHEMA_VERSION = "agentv.normalized_transcript.v1";
-var METRICS_SCHEMA_VERSION = "agentv.metrics.v1";
+var LEGACY_METRICS_SCHEMA_VERSION = "agentv.metrics.v1";
+var METRICS_SCHEMA_VERSION = "agentv.metrics.v2";
 var TRANSCRIPT_JSON_MEDIA_TYPE = "application/vnd.agentv.normalized-transcript.v1+json";
-var METRICS_JSON_MEDIA_TYPE = "application/vnd.agentv.metrics.v1+json";
+var METRICS_JSON_MEDIA_TYPE = "application/vnd.agentv.metrics.v2+json";
 function toResultArtifactPointerWire(pointer) {
   return {
     ref: pointer.ref,
@@ -42668,7 +43578,7 @@ var COMMAND_KEYS = /* @__PURE__ */ new Set([
   "_extractedcommand"
 ]);
 var URL_KEYS = /* @__PURE__ */ new Set(["url", "uri", "href", "extractedurl", "_extractedurl"]);
-function isRecord3(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizedKey(key) {
@@ -42747,7 +43657,7 @@ function stringValuesByKey(value, keys, maxDepth = 6) {
       }
       return;
     }
-    if (!isRecord3(entry)) {
+    if (!isRecord5(entry)) {
       return;
     }
     for (const [key, nested] of Object.entries(entry)) {
@@ -42799,7 +43709,7 @@ function collectThinkingBlocks(messages) {
     }
     for (const block of content) {
       const entry = block;
-      if (!isRecord3(entry)) {
+      if (!isRecord5(entry)) {
         continue;
       }
       if (entry.type === "thinking" || entry.type === "reasoning") {
@@ -42814,7 +43724,7 @@ function errorFromToolCall(toolCall, toolName) {
     return void 0;
   }
   const output = toolCall.output;
-  const message = typeof output === "string" ? output : isRecord3(output) && typeof output.message === "string" ? output.message : `Tool ${toolCall.tool} ${toolCall.status}`;
+  const message = typeof output === "string" ? output : isRecord5(output) && typeof output.message === "string" ? output.message : `Tool ${toolCall.tool} ${toolCall.status}`;
   return {
     message,
     ...toolCall.id ? { tool_call_id: toolCall.id } : {},
@@ -42877,7 +43787,7 @@ var TRANSCRIPT_ROW_SCHEMA_VERSION = "agentv.transcript.v1";
 function dropUndefined5(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function isRecord4(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString2(value) {
@@ -43110,7 +44020,7 @@ function normalizedContentBlocks(message, messageIndex, providerId) {
   } else if (Array.isArray(content)) {
     for (const contentBlock of content) {
       const block = contentBlock;
-      if (!isRecord4(block) || typeof block.type !== "string") {
+      if (!isRecord6(block) || typeof block.type !== "string") {
         continue;
       }
       if (block.type === "text" && typeof block.text === "string") {
@@ -43303,7 +44213,7 @@ function traceToTranscriptJsonLines(trace, options) {
         provider,
         sessionId,
         startedAt: trace.startTime,
-        metadata: isRecord4(trace.metadata) ? trace.metadata : void 0
+        metadata: isRecord6(trace.metadata) ? trace.metadata : void 0
       },
       tokenUsage: trace.tokenUsage,
       durationMs: trace.durationMs,
@@ -43349,7 +44259,7 @@ function readOptionalNumber(record2, key) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function fromTranscriptToolCall(wire) {
-  if (!isRecord4(wire)) {
+  if (!isRecord6(wire)) {
     return void 0;
   }
   const tool = readOptionalString3(wire, "tool");
@@ -43457,6 +44367,7 @@ function transcriptReplayRecordToProviderResponse(record2) {
   const entry = record2.entry;
   return {
     output: entry.messages,
+    metadata: skillCallMetadata(deriveSkillCallsFromMessages(entry.messages)),
     tokenUsage: entry.tokenUsage,
     durationMs: entry.durationMs,
     costUsd: entry.costUsd ?? void 0,
@@ -45189,7 +46100,7 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
     };
   }
 }
-function isRecord5(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function extractTargetsArray(parsed, absolutePath) {
@@ -45200,7 +46111,7 @@ function extractTargetsArray(parsed, absolutePath) {
   return targets;
 }
 function assertTargetDefinition(value, index, filePath) {
-  if (!isRecord5(value)) {
+  if (!isRecord7(value)) {
     throw new Error(`targets.yaml entry at index ${index} in ${filePath} must be an object`);
   }
   const id = value.id;
@@ -45241,7 +46152,7 @@ async function readTargetDefinitions(filePath) {
   }
   const raw = await readFile8(absolutePath, "utf8");
   const parsed = parseYamlValue(raw);
-  if (!isRecord5(parsed)) {
+  if (!isRecord7(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
   }
   const targets = extractTargetsArray(parsed, absolutePath);
@@ -45522,11 +46433,11 @@ var InlineAssertGrader = class {
       criteria: context.evalCase.criteria,
       metadata: context.evalCase.metadata
     });
-    const score = clampScore(result.score);
+    const score2 = clampScore(result.score);
     return {
-      score,
-      verdict: scoreToVerdict(score),
-      assertions: [{ text: result.name, passed: score >= 0.5 }],
+      score: score2,
+      verdict: scoreToVerdict(score2),
+      assertions: [{ text: result.name, passed: score2 >= 0.5 }],
       expectedAspectCount: 1,
       details: result.metadata ? result.metadata : void 0
     };
@@ -45627,17 +46538,17 @@ function normalizeScriptResult(result, fallbackText, threshold) {
     };
   }
   if (typeof result === "number") {
-    const score2 = clampScore(result);
-    const passed2 = score2 >= passThreshold;
+    const score3 = clampScore(result);
+    const passed2 = score3 >= passThreshold;
     return {
-      score: score2,
+      score: score3,
       verdict: passed2 ? "pass" : "fail",
       assertions: [{ text: passed2 ? "Assertion passed" : fallbackText, passed: passed2 }],
       expectedAspectCount: 1
     };
   }
-  const score = typeof result.score === "number" ? clampScore(result.score) : result.pass === true ? 1 : result.pass === false ? 0 : 0;
-  const passed = result.pass ?? score >= passThreshold;
+  const score2 = typeof result.score === "number" ? clampScore(result.score) : result.pass === true ? 1 : result.pass === false ? 0 : 0;
+  const passed = result.pass ?? score2 >= passThreshold;
   const assertions = result.assertions && result.assertions.length > 0 ? result.assertions : [
     {
       text: result.reason ?? (passed ? "Assertion passed" : fallbackText),
@@ -45645,7 +46556,7 @@ function normalizeScriptResult(result, fallbackText, threshold) {
     }
   ];
   return {
-    score,
+    score: score2,
     verdict: passed ? "pass" : "fail",
     assertions,
     expectedAspectCount: assertions.length || 1,
@@ -45809,12 +46720,12 @@ var AssertSetGrader = class {
         tokenUsage: result.tokenUsage
       });
     }
-    const totalWeight = scores.reduce((sum, score2) => sum + (score2.weight ?? 1), 0) || 1;
-    const score = scores.reduce((sum, item) => sum + item.score * (item.weight ?? 1), 0) / totalWeight;
+    const totalWeight = scores.reduce((sum, score3) => sum + (score3.weight ?? 1), 0) || 1;
+    const score2 = scores.reduce((sum, item) => sum + item.score * (item.weight ?? 1), 0) / totalWeight;
     const threshold = this.config.threshold;
-    const passed = threshold !== void 0 ? score >= threshold : scores.every((item) => (item.weight ?? 1) === 0 || item.verdict === "pass");
+    const passed = threshold !== void 0 ? score2 >= threshold : scores.every((item) => (item.weight ?? 1) === 0 || item.verdict === "pass");
     return {
-      score,
+      score: score2,
       verdict: passed ? "pass" : "fail",
       assertions: scores.flatMap((item) => item.assertions),
       expectedAspectCount: scores.reduce((sum, item) => sum + item.assertions.length, 0) || 1,
@@ -46016,6 +46927,12 @@ var toolTrajectoryFactory = (config2) => {
     config: config2
   });
 };
+var trajectoryFactory = (config2, context) => {
+  return new TrajectoryGrader({
+    config: config2,
+    llmGrader: context.llmGrader
+  });
+};
 var fieldAccuracyFactory = (config2) => {
   return new FieldAccuracyGrader({
     config: config2
@@ -46038,6 +46955,9 @@ var executionMetricsFactory = (config2) => {
 var skillTriggerFactory = (config2) => {
   return new SkillTriggerGrader(config2);
 };
+var skillUsedFactory = (config2) => {
+  return new SkillUsedGrader(config2);
+};
 var containsFactory = (config2) => {
   const c = config2;
   return new DeterministicAssertionGrader("contains", (ctx) => {
@@ -46171,7 +47091,7 @@ var endsWithFactory = (config2) => {
 };
 function createBuiltinRegistry() {
   const registry2 = new GraderRegistry();
-  registry2.register("llm-grader", llmGraderFactory).register("llm-rubric", llmRubricFactory).register("script", scriptFactory).register("tool-trajectory", toolTrajectoryFactory).register("field-accuracy", fieldAccuracyFactory).register("latency", latencyFactory).register("cost", costFactory).register("token-usage", tokenUsageFactory).register("execution-metrics", executionMetricsFactory).register("skill-trigger", skillTriggerFactory).register("assert-set", assertSetFactory).register("contains", containsFactory).register("contains-any", containsAnyFactory).register("contains-all", containsAllFactory).register("icontains", icontainsFactory).register("icontains-any", icontainsAnyFactory).register("icontains-all", icontainsAllFactory).register("starts-with", startsWithFactory).register("ends-with", endsWithFactory).register("regex", regexFactory).register("is-json", isJsonFactory).register("equals", equalsFactory).register("javascript", javascriptFactory).register("python", pythonFactory).register("webhook", webhookFactory).register("similar", similarFactory).register("inline-assert", (config2) => {
+  registry2.register("llm-grader", llmGraderFactory).register("llm-rubric", llmRubricFactory).register("script", scriptFactory).register("tool-trajectory", toolTrajectoryFactory).register("trajectory:tool-used", trajectoryFactory).register("trajectory:tool-args-match", trajectoryFactory).register("trajectory:tool-sequence", trajectoryFactory).register("trajectory:step-count", trajectoryFactory).register("trajectory:goal-success", trajectoryFactory).register("field-accuracy", fieldAccuracyFactory).register("latency", latencyFactory).register("cost", costFactory).register("token-usage", tokenUsageFactory).register("execution-metrics", executionMetricsFactory).register("skill-used", skillUsedFactory).register("not-skill-used", skillUsedFactory).register("skill-trigger", skillTriggerFactory).register("assert-set", assertSetFactory).register("contains", containsFactory).register("contains-any", containsAnyFactory).register("contains-all", containsAllFactory).register("icontains", icontainsFactory).register("icontains-any", icontainsAnyFactory).register("icontains-all", icontainsAllFactory).register("starts-with", startsWithFactory).register("ends-with", endsWithFactory).register("regex", regexFactory).register("is-json", isJsonFactory).register("equals", equalsFactory).register("javascript", javascriptFactory).register("python", pythonFactory).register("webhook", webhookFactory).register("similar", similarFactory).register("inline-assert", (config2) => {
     const fn = config2[INLINE_ASSERT_FN];
     if (!fn) {
       throw new Error(
@@ -49161,7 +50081,7 @@ var REPEAT_FIELDS = /* @__PURE__ */ new Set([
   "cost_limit_usd"
 ]);
 function normalizeExperimentConfig(rawConfig) {
-  if (!isRecord6(rawConfig)) {
+  if (!isRecord8(rawConfig)) {
     throw new Error("Experiment config must be an object.");
   }
   const name = readOptionalString22(rawConfig.name, "name");
@@ -49202,7 +50122,7 @@ function normalizeExperimentConfig(rawConfig) {
   };
 }
 function normalizeExperimentRunOverride(rawConfig) {
-  if (!isRecord6(rawConfig)) {
+  if (!isRecord8(rawConfig)) {
     throw new Error("Run override must be an object.");
   }
   for (const key of Object.keys(rawConfig)) {
@@ -49272,7 +50192,7 @@ function readRepeat(raw) {
       strategy: "pass_any"
     };
   }
-  if (!isRecord6(raw)) {
+  if (!isRecord8(raw)) {
     throw new Error("Experiment repeat must be a positive integer or object.");
   }
   for (const key of Object.keys(raw)) {
@@ -49304,7 +50224,7 @@ function readTargets(raw) {
     if (typeof entry === "string" && entry.trim().length > 0) {
       return entry.trim();
     }
-    if (!isRecord6(entry)) {
+    if (!isRecord8(entry)) {
       throw new Error(`Experiment targets[${index}] must be a string or object.`);
     }
     const name = readRequiredString3(entry.name, `targets[${index}].name`);
@@ -49415,7 +50335,7 @@ function readOptionalRecord(raw) {
   if (raw === void 0) {
     return void 0;
   }
-  if (!isRecord6(raw)) {
+  if (!isRecord8(raw)) {
     throw new Error("Experiment object field must be an object.");
   }
   return raw;
@@ -49436,7 +50356,7 @@ function rejectExperimentWorkers(raw) {
     "Experiment workers has been removed from eval YAML. Set authored eval concurrency with evaluate_options.max_concurrency."
   );
 }
-function isRecord6(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function rejectExperimentLifecycleCommands(rawConfig) {
@@ -50321,18 +51241,83 @@ var UNSUPPORTED_PROMPTFOO_ASSERTION_TYPES = /* @__PURE__ */ new Set([
   "human",
   "max-score",
   "tool-call-f1",
-  "skill-used",
-  "trajectory:goal-success",
-  "trajectory:tool-args-match",
-  "trajectory:step-count",
-  "trajectory:tool-sequence",
-  "trajectory:tool-used",
   "trace-error-spans",
   "trace-span-count",
   "trace-span-duration",
   "search-rubric",
   "word-count"
 ]);
+var TRAJECTORY_GRADER_TYPES = /* @__PURE__ */ new Set([
+  "trajectory:tool-used",
+  "trajectory:tool-args-match",
+  "trajectory:tool-sequence",
+  "trajectory:step-count",
+  "trajectory:goal-success"
+]);
+function isTrajectoryGraderKind(value) {
+  return TRAJECTORY_GRADER_TYPES.has(value);
+}
+function formatJsonValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function hasToolTrajectoryLatencyCheck(rawEvaluator) {
+  const expected = rawEvaluator.expected;
+  return Array.isArray(expected) && expected.some(
+    (item) => isJsonObject2(item) && (item.max_duration_ms !== void 0 || item.maxDurationMs !== void 0)
+  );
+}
+function staleSkillTriggerMessage(rawEvaluator) {
+  const skillName = asString3(rawEvaluator.skill);
+  const shouldTrigger = rawEvaluator.should_trigger !== false;
+  if (!skillName) {
+    return "Authored assertion type 'skill-trigger' has been removed. Use 'skill-used' with value: <skill> for expected skill use, or 'not-skill-used' with value: <skill> when the skill must not be used.";
+  }
+  const replacementType = shouldTrigger ? "skill-used" : "not-skill-used";
+  return `Authored assertion type 'skill-trigger' has been removed. Replace skill: ${skillName} with type: ${replacementType}, value: ${skillName}.`;
+}
+function staleToolTrajectoryMessage(rawEvaluator) {
+  const mode = asString3(rawEvaluator.mode);
+  if (hasToolTrajectoryLatencyCheck(rawEvaluator)) {
+    return "Authored assertion type 'tool-trajectory' has been removed. Per-tool latency checks such as max_duration_ms have no Promptfoo trajectory:* equivalent in AgentV yet; use a custom script assertion or track this as unsupported future scope.";
+  }
+  if (mode === "any_order" && isJsonObject2(rawEvaluator.minimums)) {
+    const entries = Object.entries(rawEvaluator.minimums);
+    const [toolName, min] = entries[0] ?? [];
+    const example = typeof toolName === "string" ? ` For example: type: trajectory:tool-used, value: { name: ${toolName}, min: ${formatJsonValue(min)} }.` : "";
+    return `Authored assertion type 'tool-trajectory' has been removed. Replace mode: any_order minimums with one Promptfoo trajectory:tool-used assertion per tool.${example}`;
+  }
+  if ((mode === "in_order" || mode === "exact") && Array.isArray(rawEvaluator.expected)) {
+    const steps = rawEvaluator.expected.filter(isJsonObject2).map((item) => item.tool).filter((tool) => typeof tool === "string");
+    const hasArgs = rawEvaluator.expected.some(
+      (item) => isJsonObject2(item) && item.args !== void 0 && item.args !== "any"
+    );
+    const sequenceHint = steps.length > 0 ? ` Use type: trajectory:tool-sequence, value: { mode: ${mode}, steps: ${formatJsonValue(steps)} }.` : " Use type: trajectory:tool-sequence with value: { mode, steps }.";
+    const argsHint = hasArgs ? " Move expected args checks to trajectory:tool-args-match with Promptfoo mode: partial or exact." : "";
+    return `Authored assertion type 'tool-trajectory' has been removed.${sequenceHint}${argsHint}`;
+  }
+  return "Authored assertion type 'tool-trajectory' has been removed. Use Promptfoo trajectory:* assertions: trajectory:tool-used for tool presence/counts, trajectory:tool-sequence for in_order/exact steps, and trajectory:tool-args-match for argument checks. AgentV-specific latency checks are unsupported future scope.";
+}
+function staleAuthoredGraderMessage(rawEvaluator) {
+  const rawType = rawEvaluator.type;
+  if (typeof rawType !== "string") {
+    return void 0;
+  }
+  const type = rawType.replace(/_/g, "-");
+  if (type === "skill-trigger") {
+    return staleSkillTriggerMessage(rawEvaluator);
+  }
+  if (type === "tool-trajectory") {
+    return staleToolTrajectoryMessage(rawEvaluator);
+  }
+  return void 0;
+}
 function assertSupportedPromptfooType(type, evalId, name) {
   const baseType = type.startsWith("not-") ? type.slice(4) : type;
   if (!UNSUPPORTED_PROMPTFOO_ASSERTION_TYPES.has(baseType)) {
@@ -50607,15 +51592,24 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
     const rawEvaluator = withInheritedAssertionConfig(rawEvaluatorEntry, inheritedAssertionConfig);
     const rawName = asString3(rawEvaluator.metric);
     const rawType = rawEvaluator.type;
-    const typeValue = typeof rawType === "string" ? normalizeGraderType(rawType) : rawType;
-    if (typeof typeValue === "string") {
-      const replacement = removedGraderReplacement(typeValue);
+    const normalizedType = typeof rawType === "string" ? normalizeGraderType(rawType) : rawType;
+    const negatedType = typeof normalizedType === "string" && normalizedType.startsWith("not-") ? normalizedType.slice(4) : void 0;
+    const typeValue = negatedType && isTrajectoryGraderKind(negatedType) ? negatedType : normalizedType;
+    const inverse = negatedType && isTrajectoryGraderKind(negatedType) ? true : void 0;
+    if (typeof normalizedType === "string") {
+      const staleMessage = staleAuthoredGraderMessage(rawEvaluator);
+      if (staleMessage) {
+        throw new Error(
+          `Unsupported grader '${rawType}' in '${evalId}'${rawName ? ` for evaluator '${rawName}'` : ""}. ${staleMessage}`
+        );
+      }
+      const replacement = removedGraderReplacement(normalizedType);
       if (replacement) {
         throw new Error(
           `Unsupported grader '${rawType}' in '${evalId}'. Use '${replacement}' instead.`
         );
       }
-      assertSupportedPromptfooType(typeValue, evalId, rawName);
+      assertSupportedPromptfooType(normalizedType, evalId, rawName);
     }
     const isCustomType = typeof typeValue === "string" && !isGraderKind(typeValue);
     if (typeof typeValue !== "string") {
@@ -50648,6 +51642,25 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       evaluators.push(transform2 !== void 0 ? { ...config22, transform: transform2 } : config22);
     };
     const inheritedInternalPreprocessors = defaultPreprocessors;
+    if (isTrajectoryGraderKind(typeValue)) {
+      const weight2 = validateWeight(rawEvaluator.weight, name, evalId);
+      const { required: required22, min_score: min_score2 } = parseRequiredAndMinScore(
+        rawEvaluator.required,
+        rawEvaluator.min_score,
+        name,
+        evalId
+      );
+      pushEvaluator({
+        name,
+        type: typeValue,
+        ...rawEvaluator.value !== void 0 ? { value: rawEvaluator.value } : {},
+        ...weight2 !== void 0 ? { weight: weight2 } : {},
+        ...required22 !== void 0 ? { required: required22 } : {},
+        ...min_score2 !== void 0 ? { min_score: min_score2 } : {},
+        ...inverse || negate ? { inverse: true } : {}
+      });
+      continue;
+    }
     if (isCustomType) {
       const weight2 = validateWeight(rawEvaluator.weight, name, evalId);
       const { required: required22, min_score: min_score2 } = parseRequiredAndMinScore(
@@ -50862,18 +51875,18 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         }
       }
       const rawArgsMatch = rawEvaluator.args_match ?? rawEvaluator.argsMatch;
-      let argsMatch2;
+      let argsMatch3;
       if (rawArgsMatch !== void 0) {
         if (Array.isArray(rawArgsMatch)) {
           const fieldList = rawArgsMatch.filter(
             (f) => typeof f === "string" && f.length > 0
           );
           if (fieldList.length > 0) {
-            argsMatch2 = fieldList;
+            argsMatch3 = fieldList;
           }
         } else if (typeof rawArgsMatch === "string") {
           if (rawArgsMatch === "exact" || rawArgsMatch === "superset" || rawArgsMatch === "subset" || rawArgsMatch === "ignore") {
-            argsMatch2 = rawArgsMatch;
+            argsMatch3 = rawArgsMatch;
           } else {
             logWarning2(
               `Invalid args_match '${rawArgsMatch}' for tool-trajectory evaluator '${name}' in '${evalId}': must be exact, superset, subset, ignore, or a string array`
@@ -50959,11 +51972,30 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         ...required22 !== void 0 ? { required: required22 } : {},
         ...min_score2 !== void 0 ? { min_score: min_score2 } : {},
         ...negate !== void 0 ? { negate } : {},
-        ...argsMatch2 !== void 0 ? { argsMatch: argsMatch2 } : {}
+        ...argsMatch3 !== void 0 ? { argsMatch: argsMatch3 } : {}
       };
       pushEvaluator(config22);
       continue;
     }
+    if (typeValue === "skill-used" || typeValue === "not-skill-used") {
+      const weight2 = validateWeight(rawEvaluator.weight, name, evalId);
+      const { required: required22, min_score: min_score2 } = parseRequiredAndMinScore(
+        rawEvaluator.required,
+        rawEvaluator.min_score,
+        name,
+        evalId
+      );
+      pushEvaluator({
+        name,
+        type: typeValue,
+        value: rawEvaluator.value,
+        ...weight2 !== void 0 ? { weight: weight2 } : {},
+        ...required22 !== void 0 ? { required: required22 } : {},
+        ...min_score2 !== void 0 ? { min_score: min_score2 } : {},
+        ...negate !== void 0 ? { negate } : {}
+      });
+      continue;
+    }
     if (typeValue === "field-accuracy") {
       const rawFields = rawEvaluator.fields;
       if (!Array.isArray(rawFields)) {
@@ -51667,6 +52699,17 @@ function generateAssertionName(typeValue, rawEvaluator) {
   const value = asString3(rawEvaluator.value);
   const arrayValue = Array.isArray(rawEvaluator.value) ? rawEvaluator.value : void 0;
   switch (typeValue) {
+    case "skill-used":
+    case "not-skill-used": {
+      const rawValue = rawEvaluator.value;
+      if (typeof rawValue === "string" && rawValue.trim()) {
+        return `${typeValue}-${rawValue.trim()}`;
+      }
+      if (Array.isArray(rawValue)) {
+        return `${typeValue}-${rawValue.length}`;
+      }
+      return typeValue;
+    }
     case "skill-trigger": {
       const skillValue = asString3(rawEvaluator.skill);
       return skillValue ? `skill-trigger-${skillValue}` : "skill-trigger";
@@ -53538,7 +54581,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromJsonl(evalFilePath, repoRoot, options) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-OMG2JBHP-OP5RR7A3.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-DQDYRULE-V3377FOL.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed } = await loadTestsFromYaml(evalFilePath, repoRoot, options);
@@ -53560,7 +54603,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromJsonl(evalFilePath, repoRoot, options);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-OMG2JBHP-OP5RR7A3.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-DQDYRULE-V3377FOL.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -55111,17 +56154,17 @@ ${detailBlock}${ANSI_RESET5}`);
 function pathFromRoot(root) {
   return root instanceof URL ? fileURLToPath3(root) : String(root);
 }
-function classifyQualityStatus(score, threshold = DEFAULT_THRESHOLD2) {
-  return score >= threshold ? "ok" : "quality_failure";
+function classifyQualityStatus(score2, threshold = DEFAULT_THRESHOLD2) {
+  return score2 >= threshold ? "ok" : "quality_failure";
 }
 function buildSkippedEvaluatorError(scores) {
-  const skippedScores = scores?.filter((score) => score.verdict === "skip") ?? [];
+  const skippedScores = scores?.filter((score2) => score2.verdict === "skip") ?? [];
   if (skippedScores.length === 0) {
     return void 0;
   }
-  const messages = skippedScores.map((score) => {
-    const label = score.name || score.type;
-    const assertionMessage = score.assertions.find((assertion) => !assertion.passed)?.text ?? "Grader skipped";
+  const messages = skippedScores.map((score2) => {
+    const label = score2.name || score2.type;
+    const assertionMessage = score2.assertions.find((assertion) => !assertion.passed)?.text ?? "Grader skipped";
     return `${label}: ${assertionMessage}`;
   });
   return messages.length === 1 ? messages[0] : `Graders skipped: ${messages.join(" | ")}`;
@@ -55424,7 +56467,7 @@ async function gradePreparedEvalCase(options) {
     const gradingOutput = evalCase.outputTransform ? [
       { role: "assistant", content: preparedCandidate.candidate }
     ] : preparedTrace ? outputMessages : void 0;
-    const { score, scores } = await runEvaluatorsForCase({
+    const { score: score2, scores } = await runEvaluatorsForCase({
       evalCase,
       candidate: preparedCandidate.candidate,
       candidateValue: preparedCandidate.candidateValue,
@@ -55458,7 +56501,7 @@ async function gradePreparedEvalCase(options) {
       ...graderTokens ? { tokenUsage: graderTokens } : {}
     };
     const skippedEvaluatorError = buildSkippedEvaluatorError(scores);
-    const executionStatus = skippedEvaluatorError ? "execution_error" : classifyQualityStatus(score.score, effectiveThreshold);
+    const executionStatus = skippedEvaluatorError ? "execution_error" : classifyQualityStatus(score2.score, effectiveThreshold);
     const baseResult = {
       timestamp: timestamp.toISOString(),
       testId: authoredResultTestId(evalCase),
@@ -55467,10 +56510,10 @@ async function gradePreparedEvalCase(options) {
       suite: evalCase.suite,
       category: evalCase.category,
       conversationId: evalCase.conversation_id,
-      score: skippedEvaluatorError ? 0 : score.score,
-      reason: score.reason,
-      checks: score.checks,
-      assertions: score.assertions,
+      score: skippedEvaluatorError ? 0 : score2.score,
+      reason: score2.reason,
+      checks: score2.checks,
+      assertions: score2.assertions,
       target: target.name,
       input,
       output: preparedCandidate.candidate,
@@ -56946,7 +57989,7 @@ async function runEvalCaseWithTrials(options, trialsConfig) {
       break;
     }
   }
-  const { score, aggregation } = aggregateTrials(trialResults, trialsConfig);
+  const { score: score2, aggregation } = aggregateTrials(trialResults, trialsConfig);
   const bestTrialIndex = trialResults.reduce(
     (bestIdx, t, idx) => t.score > trialResults[bestIdx].score ? idx : bestIdx,
     0
@@ -56960,7 +58003,7 @@ async function runEvalCaseWithTrials(options, trialsConfig) {
   const aggregateExecutionError = aggregateExecutionStatus === "execution_error" ? baseResult.executionError : void 0;
   return {
     ...baseResult,
-    score,
+    score: score2,
     sampleIndex: void 0,
     retryIndex: void 0,
     trials: trialResults,
@@ -57020,6 +58063,9 @@ function toJsonValue(value) {
 function buildProviderResponseTransformMetadata(response) {
   const metadata = {};
   const fields = [
+    ["metadata", response.metadata],
+    ["skill_calls", response.metadata?.skillCalls],
+    ["attempted_skill_calls", response.metadata?.attemptedSkillCalls],
     ["raw", response.raw],
     ["usage", response.usage],
     ["token_usage", response.tokenUsage],
@@ -57118,7 +58164,7 @@ async function evaluateCandidate(options) {
   const gradingOutput = evalCase.outputTransform ? [
     { role: "assistant", content: preparedCandidate.candidate }
   ] : output;
-  const { score, scores } = await runEvaluatorsForCase({
+  const { score: score2, scores } = await runEvaluatorsForCase({
     evalCase,
     candidate: preparedCandidate.candidate,
     candidateValue: preparedCandidate.candidateValue,
@@ -57166,7 +58212,7 @@ async function evaluateCandidate(options) {
       };
     }
   }
-  const evaluatorRequest = scores ? void 0 : score.graderRawRequest;
+  const evaluatorRequest = scores ? void 0 : score2.graderRawRequest;
   const effectiveAgentRequest = agentRequest && Object.keys(agentRequest).length > 0 ? agentRequest : void 0;
   const requests = effectiveAgentRequest || lmRequest || evaluatorRequest ? {
     ...effectiveAgentRequest ? { agent: effectiveAgentRequest } : {},
@@ -57183,10 +58229,10 @@ async function evaluateCandidate(options) {
     suite: evalCase.suite,
     category: evalCase.category,
     conversationId: evalCase.conversation_id,
-    score: score.score,
-    reason: score.reason,
-    checks: score.checks,
-    assertions: score.assertions,
+    score: score2.score,
+    reason: score2.reason,
+    checks: score2.checks,
+    assertions: score2.assertions,
     target: target.name,
     tokenUsage,
     costUsd,
@@ -57200,7 +58246,7 @@ async function evaluateCandidate(options) {
     trace: evaluationTrace,
     rawProviderLogPath,
     fileChanges,
-    executionStatus: classifyQualityStatus(score.score, evalThreshold)
+    executionStatus: classifyQualityStatus(score2.score, evalThreshold)
   };
 }
 async function runEvaluatorsForCase(options) {
@@ -57288,7 +58334,7 @@ async function runEvaluatorsForCase(options) {
     throw new Error(`No evaluator registered for kind '${evaluatorKind}'`);
   }
   const implicitEvaluator = evaluatorKind === "llm-grader" && !evalCase.assertions ? buildImplicitLlmGraderConfig(evalCase) : void 0;
-  const score = await activeEvaluator.evaluate({
+  const score2 = await activeEvaluator.evaluate({
     evalCase,
     candidate,
     candidateValue,
@@ -57315,7 +58361,7 @@ async function runEvaluatorsForCase(options) {
     dependencyResults,
     ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
-  return { score };
+  return { score: score2 };
 }
 function buildImplicitLlmGraderConfig(evalCase) {
   if (!evalCase.preprocessors || evalCase.preprocessors.length === 0) {
@@ -57435,11 +58481,11 @@ async function runEvaluatorList(options) {
         evalContext,
         evaluatorConfig
       );
-      const score2 = await evaluatorInstance.evaluate(transformedContext.context);
+      const score3 = await evaluatorInstance.evaluate(transformedContext.context);
       const endedAt = /* @__PURE__ */ new Date();
       const weight = evaluatorConfig.weight ?? 1;
       scored.push({
-        score: score2,
+        score: score3,
         name: evaluatorConfig.name,
         type: evaluatorConfig.type,
         weight,
@@ -57449,17 +58495,17 @@ async function runEvaluatorList(options) {
       scores.push({
         name: evaluatorConfig.name,
         type: evaluatorConfig.type,
-        score: score2.score,
+        score: score3.score,
         weight,
-        verdict: score2.verdict,
-        reason: score2.reason,
-        checks: score2.checks,
-        assertions: score2.assertions,
-        input: transformedContext.input ?? score2.graderRawRequest,
-        target: score2.graderTarget,
-        details: transformedContext.details && score2.details ? { ...transformedContext.details, ...score2.details } : transformedContext.details ?? score2.details,
-        scores: mapChildResults(score2.scores),
-        tokenUsage: score2.tokenUsage,
+        verdict: score3.verdict,
+        reason: score3.reason,
+        checks: score3.checks,
+        assertions: score3.assertions,
+        input: transformedContext.input ?? score3.graderRawRequest,
+        target: score3.graderTarget,
+        details: transformedContext.details && score3.details ? { ...transformedContext.details, ...score3.details } : transformedContext.details ?? score3.details,
+        scores: mapChildResults(score3.scores),
+        tokenUsage: score3.tokenUsage,
         durationMs: endedAt.getTime() - startedAt.getTime(),
         startedAt: startedAt.toISOString(),
         endedAt: endedAt.toISOString()
@@ -57528,13 +58574,13 @@ async function runEvaluatorList(options) {
   ) : 0;
   const assertions = scored.flatMap((entry) => entry.score.assertions);
   const expectedAspectCount = assertions.length || 1;
-  const score = {
+  const score2 = {
     score: aggregateScore,
     verdict: scoreToVerdict(aggregateScore, effectiveThreshold),
     assertions,
     expectedAspectCount
   };
-  return { score, scores };
+  return { score: score2, scores };
 }
 function formatFilter(filter) {
   return typeof filter === "string" ? filter : filter.join(", ");
@@ -58255,7 +59301,7 @@ var MetricsWireSchema = external_exports.object({
   reasoning_blocks: external_exports.array(ReasoningBlockWireSchema),
   thinking_blocks: external_exports.number().int().nonnegative()
 }).strict();
-var MetricsArtifactWireSchema = external_exports.object({
+var MetricsArtifactBaseWireSchema = external_exports.object({
   schema_version: external_exports.literal(METRICS_SCHEMA_VERSION),
   artifact_id: external_exports.string(),
   generated_at: external_exports.string(),
@@ -58263,12 +59309,6 @@ var MetricsArtifactWireSchema = external_exports.object({
   target: external_exports.string(),
   suite: external_exports.string().optional(),
   category: external_exports.string().optional(),
-  trace: external_exports.object({
-    schema_version: external_exports.literal(EXECUTION_TRACE_SCHEMA_VERSION),
-    artifact_id: external_exports.string(),
-    trace_id: external_exports.string(),
-    root_span_id: external_exports.string()
-  }).strict(),
   source_artifacts: external_exports.object({
     transcript_path: external_exports.string().optional(),
     grading_path: external_exports.string().optional(),
@@ -58278,17 +59318,32 @@ var MetricsArtifactWireSchema = external_exports.object({
   tokens: MetricsTokensWireSchema.optional(),
   cost: MetricsCostWireSchema.optional(),
   execution: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
-  trajectory: external_exports.record(external_exports.string(), external_exports.unknown()).optional(),
-  metrics: MetricsWireSchema
+  trajectory: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
 }).strict();
+var MetricsArtifactWireSchema = MetricsArtifactBaseWireSchema.merge(MetricsWireSchema);
 function dropUndefined7(value) {
   return Object.fromEntries(
     Object.entries(value).filter(([, entryValue]) => entryValue !== void 0)
   );
 }
-function isRecord7(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function normalizeMetricsArtifactWire(value) {
+  if (!isRecord9(value)) {
+    return void 0;
+  }
+  const nestedMetrics = isRecord9(value.metrics) ? value.metrics : {};
+  const normalized = Object.fromEntries(
+    Object.entries({
+      ...value,
+      ...nestedMetrics,
+      schema_version: METRICS_SCHEMA_VERSION
+    }).filter(([key]) => key !== "trace" && key !== "metrics")
+  );
+  const parsed = MetricsArtifactWireSchema.safeParse(normalized);
+  return parsed.success ? parsed.data : void 0;
+}
 function normalizedKey2(key) {
   return key.replace(/[^A-Za-z0-9]+/g, "").toLowerCase();
 }
@@ -58314,7 +59369,7 @@ function collectStringValuesByKey(value, keys, options = {}) {
       }
       return;
     }
-    if (!isRecord7(entry)) {
+    if (!isRecord9(entry)) {
       return;
     }
     for (const [key, nested] of Object.entries(entry)) {
@@ -58350,7 +59405,7 @@ function findNumberByKey(value, keys, maxDepth = 4) {
       }
       return void 0;
     }
-    if (!isRecord7(entry)) {
+    if (!isRecord9(entry)) {
       return void 0;
     }
     for (const [key, nested] of Object.entries(entry)) {
@@ -58451,7 +59506,7 @@ function toolSucceeded(toolCall) {
   if (toolCall.status === "error" || toolCall.status === "timeout" || toolCall.status === "cancelled") {
     return false;
   }
-  const explicitSuccess = booleanValue(isRecord7(toolCall.output) ? toolCall.output.success : void 0) ?? booleanValue(isRecord7(toolCall.output) ? toolCall.output.ok : void 0);
+  const explicitSuccess = booleanValue(isRecord9(toolCall.output) ? toolCall.output.success : void 0) ?? booleanValue(isRecord9(toolCall.output) ? toolCall.output.ok : void 0);
   if (explicitSuccess !== void 0) {
     return explicitSuccess;
   }
@@ -58635,7 +59690,7 @@ function buildWebFetches(calls) {
     return [
       dropUndefined7({
         url: url2,
-        method: stringValue2(isRecord7(call.toolCall.input) ? call.toolCall.input.method : void 0),
+        method: stringValue2(isRecord9(call.toolCall.input) ? call.toolCall.input.method : void 0),
         status: findNumberByKey(call.toolCall.output, STATUS_CODE_KEY_SET),
         success: toolSucceeded(call.toolCall),
         tool_call_id: call.toolCall.id
@@ -58647,7 +59702,7 @@ function errorFromUnknown(value, fallback) {
   if (typeof value === "string" && value.trim().length > 0) {
     return dropUndefined7({ message: value.trim(), ...fallback });
   }
-  if (!isRecord7(value)) {
+  if (!isRecord9(value)) {
     return void 0;
   }
   const message = stringValue2(value.message) ?? stringValue2(value.error) ?? stringValue2(value.reason);
@@ -58710,7 +59765,7 @@ function contentBlockText(value) {
   if (typeof value === "string") {
     return value.trim().length > 0 ? value : void 0;
   }
-  if (!isRecord7(value)) {
+  if (!isRecord9(value)) {
     return void 0;
   }
   return stringValue2(value.text) ?? stringValue2(value.content) ?? stringValue2(value.value) ?? stringValue2(value.summary);
@@ -58764,7 +59819,7 @@ function buildReasoningBlocks(messages, events) {
     if (Array.isArray(content)) {
       for (const item of content) {
         const block = item;
-        if (!isRecord7(block)) {
+        if (!isRecord9(block)) {
           continue;
         }
         const blockType = block.type;
@@ -58843,18 +59898,12 @@ function buildMetricsArtifact(result, envelope, options = {}) {
       target: result.target ?? "unknown",
       suite: result.suite,
       category: result.category,
-      trace: {
-        schema_version: EXECUTION_TRACE_SCHEMA_VERSION,
-        artifact_id: envelope.artifactId,
-        trace_id: envelope.trace.traceId,
-        root_span_id: envelope.trace.rootSpanId
-      },
       source_artifacts: dropUndefined7({
         transcript_path: options.transcriptPath,
         grading_path: options.gradingPath,
         file_changes_path: options.fileChangesPath
       }),
-      metrics: buildMetrics(result)
+      ...buildMetrics(result)
     })
   );
 }
@@ -58929,7 +59978,7 @@ var TOOL_CALL_ALIASES = {
   endTime: "end_time",
   startTime: "start_time"
 };
-function isRecord8(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeKnownAliases(value, aliases) {
@@ -58945,13 +59994,13 @@ function normalizeKnownAliases(value, aliases) {
   return normalized;
 }
 function normalizeToolCall2(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     return value;
   }
   return normalizeKnownAliases(value, TOOL_CALL_ALIASES);
 }
 function normalizeMessage(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     return value;
   }
   const normalized = normalizeKnownAliases(value, MESSAGE_ALIASES);
@@ -58961,7 +60010,7 @@ function normalizeMessage(value) {
   return normalized;
 }
 function normalizeTraceSummary(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     return value;
   }
   const normalized = normalizeKnownAliases(value, TRACE_SUMMARY_ALIASES);
@@ -59003,7 +60052,7 @@ function looksLikeResultRow(value) {
   return typeof value.test_id === "string" || Object.hasOwn(value, "score") || Object.hasOwn(value, "trace") || Object.hasOwn(value, "spans") || Object.hasOwn(value, "target") || Object.hasOwn(value, "summary_path") || Object.hasOwn(value, "grading_path") || Object.hasOwn(value, "timing_path");
 }
 function normalizeResultRow(value, context = {}) {
-  if (!isRecord8(value)) {
+  if (!isRecord10(value)) {
     throw buildSchemaError(context);
   }
   for (const field of Object.keys(
@@ -59066,11 +60115,11 @@ function stringField2(record2, key) {
 }
 function resultProjectionDimensions(result) {
   const projectionIdentity = result.projectionIdentity;
-  if (!isRecord9(projectionIdentity)) {
+  if (!isRecord11(projectionIdentity)) {
     return void 0;
   }
   const dimensions = projectionIdentity.dimensions;
-  return isRecord9(dimensions) ? dimensions : void 0;
+  return isRecord11(dimensions) ? dimensions : void 0;
 }
 function buildEvaluationResultTargetKey(result) {
   const dimensions = resultProjectionDimensions(result);
@@ -59206,7 +60255,7 @@ function normalizeEnvironmentSummaries(value) {
     return void 0;
   }
   const summaries = value.filter((entry) => {
-    if (!isRecord9(entry)) {
+    if (!isRecord11(entry)) {
       return false;
     }
     return entry.schema_version === "agentv.environment_summary.v1" && (entry.type === "host" || entry.type === "docker") && typeof entry.workdir === "string" && typeof entry.recipe_sha256 === "string" && (entry.authored_kind === "inline" || entry.authored_kind === "file");
@@ -59214,7 +60263,7 @@ function normalizeEnvironmentSummaries(value) {
   return summaries.length > 0 ? summaries : void 0;
 }
 function normalizeStringRecord(value) {
-  if (!isRecord9(value)) {
+  if (!isRecord11(value)) {
     return void 0;
   }
   const out = {};
@@ -59290,7 +60339,7 @@ function parseWorkspaceChanges(fileChanges) {
 }
 function resultVerdict(result) {
   const scores = result.scores ?? [];
-  if (scores.length > 0 && scores.every((score) => score.verdict === "skip")) {
+  if (scores.length > 0 && scores.every((score2) => score2.verdict === "skip")) {
     return "skip";
   }
   if (result.executionStatus === "ok") {
@@ -59298,8 +60347,8 @@ function resultVerdict(result) {
   }
   return "fail";
 }
-function passFromVerdict(verdict, score) {
-  return verdict ? verdict === "pass" : score >= DEFAULT_THRESHOLD2;
+function passFromVerdict(verdict, score2) {
+  return verdict ? verdict === "pass" : score2 >= DEFAULT_THRESHOLD2;
 }
 function assertionMetadata(metadata) {
   const compact = dropUndefined8(metadata);
@@ -59334,10 +60383,10 @@ function assertionToComponent(assertion, parent) {
   };
 }
 function checkToComponent(check2, parent) {
-  const score = clampScore(check2.score ?? (check2.pass ? 1 : 0));
+  const score2 = clampScore(check2.score ?? (check2.pass ? 1 : 0));
   return {
     pass: check2.pass,
-    score,
+    score: score2,
     reason: check2.reason || check2.evidence || check2.text,
     assertion: assertionMetadata({
       ...parent,
@@ -59359,59 +60408,59 @@ function sanitizePublicGradingMetadata(value) {
   if (Array.isArray(value)) {
     return value.map(sanitizePublicGradingMetadata);
   }
-  if (!isRecord9(value)) {
+  if (!isRecord11(value)) {
     return value;
   }
   const entries = Object.entries(value).filter(([key]) => !PUBLIC_GRADING_FORBIDDEN_METADATA_KEYS.has(key)).map(([key, entry]) => [key, sanitizePublicGradingMetadata(entry)]).filter(([, entry]) => entry !== void 0);
   return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
-function scoreMetadata(score) {
+function scoreMetadata(score2) {
   const metadata = dropUndefined8({
-    details: sanitizePublicGradingMetadata(score.details),
-    token_usage: score.tokenUsage,
-    duration_ms: score.durationMs,
-    started_at: score.startedAt,
-    ended_at: score.endedAt
+    details: sanitizePublicGradingMetadata(score2.details),
+    token_usage: score2.tokenUsage,
+    duration_ms: score2.durationMs,
+    started_at: score2.startedAt,
+    ended_at: score2.endedAt
   });
   return Object.keys(metadata).length > 0 ? metadata : void 0;
 }
-function scoreReason(score, pass) {
-  const reason = score.reason?.trim();
+function scoreReason(score2, pass) {
+  const reason = score2.reason?.trim();
   if (reason) {
     return reason;
   }
-  const failed = (score.checks ?? []).find((check2) => !check2.pass);
+  const failed = (score2.checks ?? []).find((check2) => !check2.pass);
   if (failed?.reason) {
     return failed.reason;
   }
-  const failedAssertion = (score.assertions ?? []).find((assertion) => !assertion.passed);
+  const failedAssertion = (score2.assertions ?? []).find((assertion) => !assertion.passed);
   if (failedAssertion?.evidence || failedAssertion?.text) {
     return failedAssertion.evidence ?? failedAssertion.text;
   }
   return pass ? "Grader passed." : "Grader failed.";
 }
-function scoreToComponent(score) {
-  const pass = passFromVerdict(score.verdict, score.score);
+function scoreToComponent(score2) {
+  const pass = passFromVerdict(score2.verdict, score2.score);
   const assertion = assertionMetadata({
-    name: score.name,
-    type: score.type,
-    weight: score.weight,
-    target: score.target
+    name: score2.name,
+    type: score2.type,
+    weight: score2.weight,
+    target: score2.target
   });
   const componentResults = [
-    ...(score.checks ?? []).map((check2) => checkToComponent(check2, assertion)),
-    ...(score.scores ?? []).map(scoreToComponent),
-    ...score.checks && score.checks.length > 0 ? [] : (score.assertions ?? []).map((entry) => assertionToComponent(entry, assertion))
+    ...(score2.checks ?? []).map((check2) => checkToComponent(check2, assertion)),
+    ...(score2.scores ?? []).map(scoreToComponent),
+    ...score2.checks && score2.checks.length > 0 ? [] : (score2.assertions ?? []).map((entry) => assertionToComponent(entry, assertion))
   ];
-  const namedScores = collectNamedScores(score.scores);
+  const namedScores = collectNamedScores(score2.scores);
   return dropUndefined8({
     pass,
-    score: clampScore(score.score),
-    reason: scoreReason(score, pass),
+    score: clampScore(score2.score),
+    reason: scoreReason(score2, pass),
     component_results: componentResults.length > 0 ? componentResults : void 0,
     assertion,
     named_scores: namedScores,
-    metadata: scoreMetadata(score)
+    metadata: scoreMetadata(score2)
   });
 }
 function buildComponentResults(result) {
@@ -59426,39 +60475,39 @@ function buildComponentResults(result) {
   }
   return void 0;
 }
-function toIndexScore(score) {
-  const pass = passFromVerdict(score.verdict, score.score);
+function toIndexScore(score2) {
+  const pass = passFromVerdict(score2.verdict, score2.score);
   return dropUndefined8({
-    name: score.name,
-    type: score.type,
+    name: score2.name,
+    type: score2.type,
     pass,
-    score: score.score,
-    reason: scoreReason(score, pass),
-    weight: score.weight,
-    target: score.target,
-    scores: score.scores?.map(toIndexScore),
-    named_scores: collectNamedScores(score.scores),
-    token_usage: score.tokenUsage,
-    duration_ms: score.durationMs,
-    started_at: score.startedAt,
-    ended_at: score.endedAt
+    score: score2.score,
+    reason: scoreReason(score2, pass),
+    weight: score2.weight,
+    target: score2.target,
+    scores: score2.scores?.map(toIndexScore),
+    named_scores: collectNamedScores(score2.scores),
+    token_usage: score2.tokenUsage,
+    duration_ms: score2.durationMs,
+    started_at: score2.startedAt,
+    ended_at: score2.endedAt
   });
 }
 function toIndexScores(scores) {
   return scores?.map(toIndexScore);
 }
 function collectNamedScores(scores, out = {}) {
-  for (const score of scores ?? []) {
-    if (score.name) {
-      out[score.name] = score.score;
+  for (const score2 of scores ?? []) {
+    if (score2.name) {
+      out[score2.name] = score2.score;
     }
-    collectNamedScores(score.scores, out);
+    collectNamedScores(score2.scores, out);
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
 function resultDerivedMetrics(result) {
   const value = result.metadata?.derived_metrics ?? result.metadata?.derivedMetrics;
-  return isRecord9(value) ? value : void 0;
+  return isRecord11(value) ? value : void 0;
 }
 function resultProvenance(result) {
   const value = result.metadata?.provenance;
@@ -59533,11 +60582,11 @@ function toTrialAggregationArtifact(aggregation) {
 function dropUndefined8(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function isRecord9(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toIndexRerunSource(value) {
-  if (!isRecord9(value)) {
+  if (!isRecord11(value)) {
     return void 0;
   }
   return dropUndefined8({
@@ -59638,7 +60687,7 @@ function buildRepeatCaseSummaryArtifact(result, timing, fingerprint) {
   };
 }
 function toFilePathList(entries) {
-  return entries.map((entry) => isRecord9(entry) && typeof entry.path === "string" ? entry.path : void 0).filter((entry) => entry !== void 0);
+  return entries.map((entry) => isRecord11(entry) && typeof entry.path === "string" ? entry.path : void 0).filter((entry) => entry !== void 0);
 }
 function resultTranscriptProviderId(result) {
   const provider = result.trace.metadata?.provider;
@@ -59715,7 +60764,7 @@ async function writeEnvironmentArtifact(params) {
   };
 }
 function buildAgentVRunResultArtifact(params) {
-  const metrics = params.metricsArtifact.metrics;
+  const metrics = params.metricsArtifact;
   const fileChangesPath = params.hasFileChanges ? `./${CANONICAL_FILE_CHANGES_ARTIFACT_PATH}` : void 0;
   return dropUndefined8({
     execution_status: params.trial.executionStatus ?? params.result.executionStatus,
@@ -59909,7 +60958,7 @@ async function writeTrialRunArtifacts(params) {
   );
 }
 function toIndexPreparedAttempt(value) {
-  if (!isRecord9(value)) {
+  if (!isRecord11(value)) {
     return void 0;
   }
   return dropUndefined8({
@@ -59994,7 +61043,7 @@ function timingMetadataSource(metadata, sourceKey) {
   const usageSources = metadata?.usage_sources;
   const usageSummary = metadata?.usage_summary;
   const legacyKey = sourceKey === "duration" ? "duration_source" : sourceKey === "cost" ? "cost_source" : "token_usage_source";
-  const value = isRecord9(usageSources) ? usageSources[sourceKey] : isRecord9(usageSummary) ? usageSummary[legacyKey] : metadata?.[legacyKey];
+  const value = isRecord11(usageSources) ? usageSources[sourceKey] : isRecord11(usageSummary) ? usageSummary[legacyKey] : metadata?.[legacyKey];
   return typeof value === "string" && TIMING_SOURCE_VALUES2.includes(value) ? value : void 0;
 }
 function sumMessageTokenUsage(messages) {
@@ -60152,12 +61201,12 @@ function buildRunSummaryArtifact(results, evalFile = "", experiment, runId, plan
     if (isExecutionError(result)) {
       continue;
     }
-    for (const score of result.scores ?? []) {
-      const key = `${score.name}:${score.type}`;
+    for (const score2 of result.scores ?? []) {
+      const key = `${score2.name}:${score2.type}`;
       if (!evaluatorScores.has(key)) {
         evaluatorScores.set(key, []);
       }
-      evaluatorScores.get(key)?.push(score.score);
+      evaluatorScores.get(key)?.push(score2.score);
     }
   }
   let perEvaluatorSummary;
@@ -60323,7 +61372,7 @@ async function writeInitialRunSummaryArtifact(runDir, options) {
 async function readRunConfigArtifact(runDir) {
   try {
     const parsed = JSON.parse(await readFile16(runInternalPath(runDir, RUN_CONFIG_FILENAME), "utf8"));
-    if (!isRecord9(parsed) || parsed.schema_version !== "agentv.run_config.v1") {
+    if (!isRecord11(parsed) || parsed.schema_version !== "agentv.run_config.v1") {
       return void 0;
     }
     return parsed;
@@ -60333,7 +61382,7 @@ async function readRunConfigArtifact(runDir) {
 }
 function buildAggregateGradingArtifact(results) {
   const qualityResults = results.filter((r) => !isExecutionError(r));
-  const score = qualityResults.length > 0 ? Math.round(
+  const score2 = qualityResults.length > 0 ? Math.round(
     qualityResults.reduce((sum, result) => sum + clampScore(result.score), 0) / qualityResults.length * 1e3
   ) / 1e3 : 0;
   const pass = qualityResults.length > 0 && qualityResults.every((result) => resultVerdict(result) === "pass");
@@ -60347,7 +61396,7 @@ function buildAggregateGradingArtifact(results) {
   }));
   return dropUndefined8({
     pass,
-    score,
+    score: score2,
     reason: results.length === 0 ? "No results to summarize." : pass ? "All quality results passed." : "One or more quality results failed.",
     component_results: componentResults.length > 0 ? componentResults : void 0,
     named_scores: collectNamedScores(qualityResults.flatMap((result) => result.scores ?? [])),
@@ -60734,7 +61783,7 @@ async function writeMetricsArtifact(params) {
   return artifactWithTiming;
 }
 function indexRecordKey(record2) {
-  if (!isRecord9(record2)) {
+  if (!isRecord11(record2)) {
     return void 0;
   }
   const testId = typeof record2.test_id === "string" ? record2.test_id : typeof record2.testId === "string" ? record2.testId : void 0;
@@ -60752,7 +61801,7 @@ function indexRecordReplacementKeys(record2) {
   return Array.from(new Set(keys));
 }
 function projectionIdentityRecordKey(record2) {
-  if (!isRecord9(record2) || !isRecord9(record2.projection_identity)) {
+  if (!isRecord11(record2) || !isRecord11(record2.projection_identity)) {
     return void 0;
   }
   const id = record2.projection_identity.id;
@@ -60790,7 +61839,7 @@ function existingRecordsByProjectionIdentity(records) {
   return byIdentity;
 }
 function skippedExistingRecord(record2, identity, duplicatePolicy) {
-  if (!isRecord9(record2)) {
+  if (!isRecord11(record2)) {
     return record2;
   }
   return {
@@ -60869,23 +61918,23 @@ async function readJsonFile2(filePath) {
   }
 }
 function summaryRunId(summary, fallback) {
-  if (!isRecord9(summary)) {
+  if (!isRecord11(summary)) {
     return fallback;
   }
-  const runId = isRecord9(summary.metadata) ? summary.metadata.run_id : void 0;
+  const runId = isRecord11(summary.metadata) ? summary.metadata.run_id : void 0;
   return typeof runId === "string" && runId.trim().length > 0 ? runId : fallback;
 }
 function summaryTimestamp(summary) {
-  if (!isRecord9(summary) || !isRecord9(summary.metadata)) {
+  if (!isRecord11(summary) || !isRecord11(summary.metadata)) {
     return void 0;
   }
   return typeof summary.metadata.timestamp === "string" ? summary.metadata.timestamp : void 0;
 }
 function summaryTargets(summary) {
-  return isRecord9(summary) && isRecord9(summary.metadata) ? summary.metadata.targets : void 0;
+  return isRecord11(summary) && isRecord11(summary.metadata) ? summary.metadata.targets : void 0;
 }
 function summaryTags(summary) {
-  return isRecord9(summary) && isRecord9(summary.metadata) ? summary.metadata.tags : void 0;
+  return isRecord11(summary) && isRecord11(summary.metadata) ? summary.metadata.tags : void 0;
 }
 async function readJsonlFile(filePath) {
   const content = await readTextIfExists(filePath);
@@ -60905,7 +61954,7 @@ async function readJsonlFile(filePath) {
   return records;
 }
 function buildCrossRunRunRecord(params) {
-  const summary = isRecord9(params.summary) ? params.summary : {};
+  const summary = isRecord11(params.summary) ? params.summary : {};
   return dropUndefined8({
     run_id: params.runId,
     run_dir: params.runDirName,
@@ -60920,7 +61969,7 @@ function buildCrossRunRunRecord(params) {
   });
 }
 function buildCrossRunCaseRecord(params) {
-  if (!isRecord9(params.caseRecord)) {
+  if (!isRecord11(params.caseRecord)) {
     return void 0;
   }
   return dropUndefined8({
@@ -61895,9 +62944,11 @@ export {
   extractImageBlocks,
   formatToolCalls,
   SkillTriggerGrader,
+  SkillUsedGrader,
   assembleLlmGraderPrompt,
   TokenUsageGrader,
   ToolTrajectoryGrader,
+  TrajectoryGrader,
   runContainsAssertion,
   runContainsAnyAssertion,
   runContainsAllAssertion,
@@ -61981,6 +63032,7 @@ export {
   CANONICAL_METRICS_ARTIFACT_PATH,
   CANONICAL_FILE_CHANGES_ARTIFACT_PATH,
   TRANSCRIPT_SCHEMA_VERSION,
+  LEGACY_METRICS_SCHEMA_VERSION,
   METRICS_SCHEMA_VERSION,
   TRANSCRIPT_JSON_MEDIA_TYPE,
   METRICS_JSON_MEDIA_TYPE,
@@ -62072,6 +63124,7 @@ export {
   runEvalCase,
   MetricsWireSchema,
   MetricsArtifactWireSchema,
+  normalizeMetricsArtifactWire,
   buildMetricsArtifact,
   ResultRowSchemaError,
   normalizeResultRow,
@@ -62104,4 +63157,4 @@ export {
 chokidar/index.js:
   (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-3S6A2RKR.js.map
+//# sourceMappingURL=chunk-6ZZCDZPD.js.map