@agentv/core 4.32.0-next.1 → 4.33.0-next.1

package/dist/{chunk-N5EU446L.js → chunk-7QB53OPK.js}

@@ -1,10 +1,16 @@
 import {
   LLM_GRADER_CAPABLE_KINDS,
+  RUBRIC_OPERATOR_VALUES,
   buildDirectoryChain,
   expandFileReferences,
   extractLastAssistantContent,
   fileExists,
   findGitRoot,
+  getAgentvConfigDir,
+  getAgentvDataDir,
+  getSubagentsRoot,
+  getWorkspacePoolRoot,
+  getWorkspacesRoot,
   interpolateEnv,
   interpolateTemplateVars,
   isAgentProvider,
@@ -18,7 +24,7 @@ import {
   readTextFile,
   resolveDelegatedTargetDefinition,
   resolveTargetDefinition
-} from "./chunk-5RQMJZDJ.js";
+} from "./chunk-EW5X2RGJ.js";
 import {
   execFileWithStdin,
   execShellWithStdin
@@ -41,6 +47,49 @@ import { existsSync as existsSync6 } from "node:fs";
 import path45 from "node:path";
 import micromatch4 from "micromatch";
 
+// src/evaluation/cache/response-cache.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+var DEFAULT_CACHE_PATH = ".agentv/cache";
+var ResponseCache = class {
+  cachePath;
+  constructor(cachePath) {
+    this.cachePath = cachePath ?? DEFAULT_CACHE_PATH;
+  }
+  async get(key) {
+    const filePath = this.keyToPath(key);
+    try {
+      const data = await readFile(filePath, "utf8");
+      return JSON.parse(data);
+    } catch {
+      return void 0;
+    }
+  }
+  async set(key, value) {
+    const filePath = this.keyToPath(key);
+    const dir = path.dirname(filePath);
+    await mkdir(dir, { recursive: true });
+    await writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
+  }
+  keyToPath(key) {
+    const prefix = key.slice(0, 2);
+    return path.join(this.cachePath, prefix, `${key}.json`);
+  }
+};
+function shouldEnableCache(params) {
+  if (params.cliNoCache) return false;
+  if (params.cliCache) return true;
+  if (params.yamlCache !== void 0) return params.yamlCache;
+  return params.tsConfigCache === true;
+}
+function shouldSkipCacheForTemperature(targetConfig) {
+  const temp = targetConfig.temperature;
+  if (typeof temp === "number" && temp > 0) {
+    return true;
+  }
+  return false;
+}
+
 // src/evaluation/graders/scoring.ts
 var DEFAULT_THRESHOLD = 0.8;
 var PASS_THRESHOLD = DEFAULT_THRESHOLD;
@@ -133,7 +182,7 @@ function negateScore(score) {
 import { execFile as execFile3 } from "node:child_process";
 import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir14, readdir as readdir8, stat as stat9 } from "node:fs/promises";
+import { copyFile as copyFile2, mkdir as mkdir15, readdir as readdir8, stat as stat9 } from "node:fs/promises";
 import path44 from "node:path";
 import { promisify as promisify7 } from "node:util";
 import micromatch3 from "micromatch";
@@ -277,38 +326,8 @@ function validateConcurrency(concurrency) {
   }
 }
 
-// src/paths.ts
-import os from "node:os";
-import path from "node:path";
-function readEnvPath(name) {
-  const value = process.env[name];
-  if (!value || value === "undefined") return void 0;
-  return value;
-}
-function getAgentvConfigDir() {
-  return readEnvPath("AGENTV_HOME") ?? path.join(os.homedir(), ".agentv");
-}
-function getAgentvHome() {
-  return getAgentvConfigDir();
-}
-function getAgentvDataDir() {
-  return readEnvPath("AGENTV_DATA_DIR") ?? getAgentvConfigDir();
-}
-function getWorkspacesRoot() {
-  return path.join(getAgentvDataDir(), "workspaces");
-}
-function getSubagentsRoot() {
-  return path.join(getAgentvDataDir(), "subagents");
-}
-function getTraceStateRoot() {
-  return path.join(getAgentvDataDir(), "trace-state");
-}
-function getWorkspacePoolRoot() {
-  return path.join(getAgentvDataDir(), "workspace-pool");
-}
-
 // src/evaluation/graders/code-grader.ts
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
@@ -642,7 +661,7 @@ async function materializeContentForGrader(messages, getWorkDir) {
         const ext = mediaType.split("/")[1] === "jpeg" ? "jpg" : mediaType.split("/")[1] ?? "bin";
         const dir = await getWorkDir();
         const filePath = join(dir, `img-${counter++}.${ext}`);
-        await writeFile(filePath, Buffer.from(base64Data, "base64"));
+        await writeFile2(filePath, Buffer.from(base64Data, "base64"));
         blocks.push({ type: "image", media_type: img.media_type, path: filePath });
       } else {
         blocks.push({ type: "image", media_type: img.media_type, path: img.source });
@@ -685,7 +704,7 @@ var CodeGrader = class {
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
         const tmpDir = await mkdtemp(join(tmpdir(), "agentv-grader-"));
         outputPath = join(tmpDir, "output.json");
-        await writeFile(outputPath, serialized);
+        await writeFile2(outputPath, serialized);
         outputForPayload = null;
       }
     }
@@ -702,6 +721,7 @@ var CodeGrader = class {
         context.evalCase.input,
         getImageDir
       ),
+      metadata: context.evalCase.metadata ?? null,
       trace: context.trace ?? null,
       tokenUsage: context.tokenUsage ?? null,
       costUsd: context.costUsd ?? null,
@@ -874,7 +894,7 @@ import path3 from "node:path";
 import { z } from "zod";
 
 // src/evaluation/content-preprocessor.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import path2 from "node:path";
 import { fileURLToPath } from "node:url";
 var MIME_TYPE_ALIASES = {
@@ -943,7 +963,7 @@ async function preprocessContentFile(block, preprocessors, basePath) {
     return runContentPreprocessor(block, resolvedPath, preprocessor);
   }
   try {
-    const buffer = await readFile(resolvedPath);
+    const buffer = await readFile2(resolvedPath);
     const text = buffer.toString("utf8").replace(/\r\n/g, "\n");
     if (buffer.includes(0) || text.includes(REPLACEMENT_CHAR)) {
       return {
@@ -1039,6 +1059,10 @@ ${text}`;
 var TEMPLATE_VARIABLES = {
   EXPECTED_OUTPUT: "expected_output",
   CRITERIA: "criteria",
+  METADATA: "metadata",
+  METADATA_JSON: "metadata_json",
+  RUBRICS: "rubrics",
+  RUBRICS_JSON: "rubrics_json",
   INPUT: "input",
   OUTPUT: "output",
   FILE_CHANGES: "file_changes",
@@ -1061,6 +1085,27 @@ var DEPRECATED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Map([
   [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT, TEMPLATE_VARIABLES.EXPECTED_OUTPUT]
 ]);
 
+// src/evaluation/graders/rubric-operators.ts
+var OPERATOR_GUIDANCE = {
+  correctness: "Correctness: mark satisfied only when the answer positively supports or fulfills the outcome. Omission or contradiction should not satisfy it.",
+  contradiction: "Contradiction guard: mark satisfied when the answer does not make a claim that contradicts the outcome. Do not require the answer to mention the outcome; mark unsatisfied only for incompatible claims."
+};
+function formatRubricOperatorLabel(operator) {
+  return operator ? ` (operator: ${operator})` : "";
+}
+function formatRubricOperatorGuidance(rubrics) {
+  const operators = /* @__PURE__ */ new Set();
+  for (const rubric of rubrics) {
+    if (rubric.operator) {
+      operators.add(rubric.operator);
+    }
+  }
+  if (operators.size === 0) {
+    return [];
+  }
+  return [...operators].map((operator) => OPERATOR_GUIDANCE[operator]);
+}
+
 // src/evaluation/graders/llm-grader.ts
 var DEFAULT_MAX_STEPS = 10;
 var MAX_STEPS_LIMIT = 50;
@@ -1143,6 +1188,32 @@ var scoreRangeEvaluationSchema = z.object({
   checks: z.array(scoreRangeCheckResultSchema).describe("Scores for each rubric criterion"),
   overall_reasoning: z.string().describe("Overall assessment summary (1-2 sentences)").optional()
 });
+function stringifyPretty(value) {
+  return value === void 0 ? "" : JSON.stringify(value, null, 2);
+}
+function stringifyCompact(value) {
+  return value === void 0 ? "" : JSON.stringify(value);
+}
+function buildTemplateVariables(context) {
+  const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
+  const rubrics = context.evaluator?.type === "llm-grader" ? context.evaluator.rubrics : void 0;
+  return {
+    [TEMPLATE_VARIABLES.INPUT]: formattedQuestion.trim(),
+    [TEMPLATE_VARIABLES.OUTPUT]: context.candidate.trim(),
+    [TEMPLATE_VARIABLES.EXPECTED_OUTPUT]: (context.evalCase.reference_answer ?? "").trim(),
+    [TEMPLATE_VARIABLES.CRITERIA]: context.evalCase.criteria.trim(),
+    [TEMPLATE_VARIABLES.METADATA]: stringifyPretty(context.evalCase.metadata),
+    [TEMPLATE_VARIABLES.METADATA_JSON]: stringifyCompact(context.evalCase.metadata),
+    [TEMPLATE_VARIABLES.RUBRICS]: stringifyPretty(rubrics),
+    [TEMPLATE_VARIABLES.RUBRICS_JSON]: stringifyCompact(rubrics),
+    [TEMPLATE_VARIABLES.FILE_CHANGES]: context.fileChanges ?? "",
+    [TEMPLATE_VARIABLES.TOOL_CALLS]: context.toolCalls ?? "",
+    // Deprecated aliases — same values as the primary variables above
+    [TEMPLATE_VARIABLES.INPUT_TEXT]: formattedQuestion.trim(),
+    [TEMPLATE_VARIABLES.OUTPUT_TEXT]: context.candidate.trim(),
+    [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT]: (context.evalCase.reference_answer ?? "").trim()
+  };
+}
 function resolveContentBasePath(context) {
   if (context.workspacePath) {
     return context.workspacePath;
@@ -1214,19 +1285,7 @@ var LlmGrader = class {
   // LLM mode (existing)
   // ---------------------------------------------------------------------------
   async evaluateFreeform(context, graderProvider) {
-    const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
-    const variables = {
-      [TEMPLATE_VARIABLES.INPUT]: formattedQuestion.trim(),
-      [TEMPLATE_VARIABLES.OUTPUT]: context.candidate.trim(),
-      [TEMPLATE_VARIABLES.EXPECTED_OUTPUT]: (context.evalCase.reference_answer ?? "").trim(),
-      [TEMPLATE_VARIABLES.CRITERIA]: context.evalCase.criteria.trim(),
-      [TEMPLATE_VARIABLES.FILE_CHANGES]: context.fileChanges ?? "",
-      [TEMPLATE_VARIABLES.TOOL_CALLS]: context.toolCalls ?? "",
-      // Deprecated aliases — same values as the primary variables above
-      [TEMPLATE_VARIABLES.INPUT_TEXT]: formattedQuestion.trim(),
-      [TEMPLATE_VARIABLES.OUTPUT_TEXT]: context.candidate.trim(),
-      [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT]: (context.evalCase.reference_answer ?? "").trim()
-    };
+    const variables = buildTemplateVariables(context);
     const systemPrompt = buildOutputSchema();
     const graderTemplate = context.graderTemplateOverride ?? this.graderTemplate ?? DEFAULT_GRADER_TEMPLATE;
     warnDeprecatedTemplateVars(graderTemplate);
@@ -1293,7 +1352,7 @@ ${context.toolCalls}`;
     if (hasScoreRanges) {
       return this.evaluateWithScoreRanges(context, graderProvider, rubrics);
     }
-    const prompt = this.buildRubricPrompt(context, rubrics);
+    const prompt = context.graderTemplateOverride || this.graderTemplate ? this.buildCustomPrompt(context) : this.buildRubricPrompt(context, rubrics);
     const systemPrompt = buildRubricOutputSchema();
     const graderRawRequest = {
       userPrompt: prompt,
@@ -1338,7 +1397,7 @@ ${context.toolCalls}`;
    * Each criterion is scored 0-10 and normalized to 0-1.
    */
   async evaluateWithScoreRanges(context, graderProvider, rubrics) {
-    const prompt = this.buildScoreRangePrompt(context, rubrics);
+    const prompt = context.graderTemplateOverride || this.graderTemplate ? this.buildCustomPrompt(context) : this.buildScoreRangePrompt(context, rubrics);
     const systemPrompt = buildScoreRangeOutputSchema();
     const graderRawRequest = {
       userPrompt: prompt,
@@ -1557,21 +1616,11 @@ ${context.toolCalls}`;
    */
   buildAgentUserPrompt(context) {
     const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
-    const variables = {
-      [TEMPLATE_VARIABLES.CRITERIA]: context.evalCase.criteria.trim(),
-      [TEMPLATE_VARIABLES.INPUT]: formattedQuestion.trim(),
-      [TEMPLATE_VARIABLES.OUTPUT]: context.candidate.trim(),
-      [TEMPLATE_VARIABLES.EXPECTED_OUTPUT]: (context.evalCase.reference_answer ?? "").trim(),
-      [TEMPLATE_VARIABLES.FILE_CHANGES]: context.fileChanges ?? "",
-      [TEMPLATE_VARIABLES.TOOL_CALLS]: context.toolCalls ?? "",
-      // Deprecated aliases
-      [TEMPLATE_VARIABLES.INPUT_TEXT]: formattedQuestion.trim(),
-      [TEMPLATE_VARIABLES.OUTPUT_TEXT]: context.candidate.trim(),
-      [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT]: (context.evalCase.reference_answer ?? "").trim()
-    };
-    if (this.graderTemplate) {
-      warnDeprecatedTemplateVars(this.graderTemplate);
-      return substituteVariables(this.graderTemplate, variables);
+    const variables = buildTemplateVariables(context);
+    const template = context.graderTemplateOverride ?? this.graderTemplate;
+    if (template) {
+      warnDeprecatedTemplateVars(template);
+      return substituteVariables(template, variables);
     }
     const config = context.evaluator;
     const rubrics = config?.type === "llm-grader" ? config.rubrics : void 0;
@@ -1621,21 +1670,11 @@ ${context.toolCalls}`;
     const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
     const config = context.evaluator;
     const rubrics = config?.type === "llm-grader" ? config.rubrics : void 0;
-    if (this.graderTemplate) {
-      const variables = {
-        [TEMPLATE_VARIABLES.CRITERIA]: context.evalCase.criteria.trim(),
-        [TEMPLATE_VARIABLES.INPUT]: formattedQuestion.trim(),
-        [TEMPLATE_VARIABLES.OUTPUT]: context.candidate.trim(),
-        [TEMPLATE_VARIABLES.EXPECTED_OUTPUT]: (context.evalCase.reference_answer ?? "").trim(),
-        [TEMPLATE_VARIABLES.FILE_CHANGES]: context.fileChanges ?? "",
-        [TEMPLATE_VARIABLES.TOOL_CALLS]: context.toolCalls ?? "",
-        // Deprecated aliases
-        [TEMPLATE_VARIABLES.INPUT_TEXT]: formattedQuestion.trim(),
-        [TEMPLATE_VARIABLES.OUTPUT_TEXT]: context.candidate.trim(),
-        [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT]: (context.evalCase.reference_answer ?? "").trim()
-      };
-      warnDeprecatedTemplateVars(this.graderTemplate);
-      const customPrompt = substituteVariables(this.graderTemplate, variables);
+    const template = context.graderTemplateOverride ?? this.graderTemplate;
+    if (template) {
+      const variables = buildTemplateVariables(context);
+      warnDeprecatedTemplateVars(template);
+      const customPrompt = substituteVariables(template, variables);
       const outputSchema = rubrics && rubrics.length > 0 ? buildRubricOutputSchema() : buildOutputSchema();
       return `${customPrompt}
 
@@ -1761,6 +1800,9 @@ ${outputSchema}`;
       const weightLabel = rubric.weight !== 1 ? ` (weight: ${rubric.weight})` : "";
       const minScoreLabel = rubric.min_score !== void 0 ? ` [REQUIRED: min score ${rubric.min_score}]` : rubric.required_min_score !== void 0 ? ` [REQUIRED: min score ${rubric.required_min_score}]` : "";
       parts.push("", `### Criterion: ${rubric.id}${weightLabel}${minScoreLabel}`);
+      if (rubric.operator) {
+        parts.push(`Operator: ${rubric.operator}`);
+      }
       if (rubric.outcome) {
         parts.push(`Description: ${rubric.outcome}`);
       }
@@ -1773,12 +1815,21 @@ ${outputSchema}`;
         }
       }
     }
+    const operatorGuidance = formatRubricOperatorGuidance(rubrics);
+    if (operatorGuidance.length > 0) {
+      parts.push("", ...operatorGuidance);
+    }
     parts.push(
       "",
       "For each criterion, provide an integer score 0-10 that matches one of its defined score ranges."
     );
     return parts.join("\n");
   }
+  buildCustomPrompt(context) {
+    const template = context.graderTemplateOverride ?? this.graderTemplate ?? "";
+    warnDeprecatedTemplateVars(template);
+    return substituteVariables(template, buildTemplateVariables(context));
+  }
   buildRubricPrompt(context, rubrics) {
     const formattedQuestion = context.promptInputs.question && context.promptInputs.question.trim().length > 0 ? context.promptInputs.question : context.evalCase.question;
     const parts = [
@@ -1802,10 +1853,21 @@ ${outputSchema}`;
       parts.push("[[ ## tool_calls ## ]]", context.toolCalls, "");
     }
     parts.push("[[ ## rubrics ## ]]");
+    const operatorGuidance = formatRubricOperatorGuidance(rubrics);
+    if (operatorGuidance.length > 0) {
+      parts.push("", "Operator guidance:");
+      for (const guidance of operatorGuidance) {
+        parts.push(`- ${guidance}`);
+      }
+      parts.push("");
+    }
     for (const rubric of rubrics) {
       const requiredLabel = rubric.required ? " (REQUIRED)" : "";
       const weightLabel = rubric.weight !== 1 ? ` (weight: ${rubric.weight})` : "";
-      parts.push(`- [${rubric.id}]${requiredLabel}${weightLabel}: ${rubric.outcome}`);
+      const operatorLabel = formatRubricOperatorLabel(rubric.operator);
+      parts.push(
+        `- [${rubric.id}]${requiredLabel}${weightLabel}${operatorLabel}: ${rubric.outcome}`
+      );
     }
     parts.push("", "For each rubric, determine if it is satisfied and provide brief reasoning.");
     return parts.join("\n");
@@ -2537,6 +2599,385 @@ var CostGrader = class {
 };
 
 // src/evaluation/trace.ts
+import { z as z2 } from "zod";
+var NORMALIZED_TRAJECTORY_SCHEMA_VERSION = "agentv.trace.v1";
+var NORMALIZED_TRACE_SOURCE_KINDS = [
+  "agentv_run",
+  "otlp",
+  "phoenix",
+  "langfuse",
+  "pi_session",
+  "imported_transcript",
+  "compact_transcript"
+];
+var NORMALIZED_TRACE_EVENT_TYPES = [
+  "message",
+  "model_turn",
+  "tool_call",
+  "tool_result"
+];
+var NORMALIZED_TOOL_STATUSES = ["ok", "error", "timeout", "cancelled", "unknown"];
+var NORMALIZED_REDACTION_LEVELS = ["none", "partial", "full"];
+function omitUndefinedProperties(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, property]) => property !== void 0)
+  );
+}
+var MetadataWireSchema = z2.record(z2.string(), z2.unknown());
+var TokenUsageWireSchema = z2.object({
+  input: z2.number(),
+  output: z2.number(),
+  cached: z2.number().optional(),
+  reasoning: z2.number().optional()
+});
+var NormalizedRedactionStateWireSchema = z2.object({
+  level: z2.enum(NORMALIZED_REDACTION_LEVELS),
+  fields: z2.array(z2.string()).optional(),
+  reason: z2.string().optional()
+});
+var NormalizedTraceErrorWireSchema = z2.object({
+  message: z2.string(),
+  name: z2.string().optional(),
+  code: z2.string().optional(),
+  stack: z2.string().optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceSourceWireSchema = z2.object({
+  kind: z2.enum(NORMALIZED_TRACE_SOURCE_KINDS),
+  path: z2.string().optional(),
+  url: z2.string().optional(),
+  provider: z2.string().optional(),
+  format: z2.string().optional(),
+  version: z2.string().optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceSessionWireSchema = z2.object({
+  session_id: z2.string().optional(),
+  conversation_id: z2.string().optional(),
+  cwd: z2.string().optional(),
+  started_at: z2.string().optional(),
+  ended_at: z2.string().optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceBranchWireSchema = z2.object({
+  selected_leaf_id: z2.string().optional(),
+  selected_path_ids: z2.array(z2.string()).optional(),
+  included_event_ids: z2.array(z2.string()).optional(),
+  omitted_event_ids: z2.array(z2.string()).optional(),
+  selection_reason: z2.string().optional()
+});
+var NormalizedTraceSourceRefWireSchema = z2.object({
+  event_id: z2.string().optional(),
+  message_id: z2.string().optional(),
+  span_id: z2.string().optional(),
+  trace_id: z2.string().optional(),
+  raw_kind: z2.string().optional(),
+  path: z2.string().optional(),
+  line: z2.number().int().nonnegative().optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedRawEvidenceWireSchema = z2.object({
+  kind: z2.string(),
+  ref: z2.string().optional(),
+  media_type: z2.string().optional(),
+  content: z2.unknown().optional(),
+  redacted: z2.boolean().optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceMessageWireSchema = z2.object({
+  role: z2.string(),
+  name: z2.string().optional(),
+  content: z2.unknown().optional(),
+  redaction: NormalizedRedactionStateWireSchema.optional(),
+  token_usage: TokenUsageWireSchema.optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceModelWireSchema = z2.object({
+  provider: z2.string().optional(),
+  name: z2.string().optional(),
+  invocation_id: z2.string().optional(),
+  token_usage: TokenUsageWireSchema.optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceToolWireSchema = z2.object({
+  name: z2.string(),
+  call_id: z2.string().optional(),
+  input: z2.unknown().optional(),
+  output: z2.unknown().optional(),
+  status: z2.enum(NORMALIZED_TOOL_STATUSES).optional(),
+  error: NormalizedTraceErrorWireSchema.optional(),
+  redaction: NormalizedRedactionStateWireSchema.optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTraceEventWireSchema = z2.object({
+  event_id: z2.string(),
+  parent_event_id: z2.string().optional(),
+  ordinal: z2.number().int().nonnegative(),
+  type: z2.enum(NORMALIZED_TRACE_EVENT_TYPES),
+  timestamp: z2.string().optional(),
+  duration_ms: z2.number().nonnegative().optional(),
+  duration_inferred: z2.boolean().optional(),
+  turn_index: z2.number().int().nonnegative().optional(),
+  message: NormalizedTraceMessageWireSchema.optional(),
+  model: NormalizedTraceModelWireSchema.optional(),
+  tool: NormalizedTraceToolWireSchema.optional(),
+  source_ref: NormalizedTraceSourceRefWireSchema.optional(),
+  raw_evidence: z2.array(NormalizedRawEvidenceWireSchema).optional(),
+  redaction: NormalizedRedactionStateWireSchema.optional(),
+  metadata: MetadataWireSchema.optional()
+});
+var NormalizedTrajectoryWireSchema = z2.object({
+  schema_version: z2.literal(NORMALIZED_TRAJECTORY_SCHEMA_VERSION),
+  source: NormalizedTraceSourceWireSchema,
+  session: NormalizedTraceSessionWireSchema,
+  branch: NormalizedTraceBranchWireSchema.optional(),
+  events: z2.array(NormalizedTraceEventWireSchema),
+  token_usage: TokenUsageWireSchema.optional(),
+  cost_usd: z2.number().optional(),
+  duration_ms: z2.number().optional(),
+  started_at: z2.string().optional(),
+  ended_at: z2.string().optional(),
+  metadata: MetadataWireSchema.optional()
+});
+function toNormalizedTrajectoryWire(trajectory) {
+  return NormalizedTrajectoryWireSchema.parse(
+    omitUndefinedProperties({
+      schema_version: trajectory.schemaVersion,
+      source: toNormalizedTraceSourceWire(trajectory.source),
+      session: toNormalizedTraceSessionWire(trajectory.session),
+      branch: trajectory.branch ? toNormalizedTraceBranchWire(trajectory.branch) : void 0,
+      events: trajectory.events.map(toNormalizedTraceEventWire),
+      token_usage: trajectory.tokenUsage,
+      cost_usd: trajectory.costUsd,
+      duration_ms: trajectory.durationMs,
+      started_at: trajectory.startedAt,
+      ended_at: trajectory.endedAt,
+      metadata: trajectory.metadata
+    })
+  );
+}
+function fromNormalizedTrajectoryWire(input) {
+  const wire = NormalizedTrajectoryWireSchema.parse(input);
+  return {
+    schemaVersion: wire.schema_version,
+    source: fromNormalizedTraceSourceWire(wire.source),
+    session: fromNormalizedTraceSessionWire(wire.session),
+    branch: wire.branch ? fromNormalizedTraceBranchWire(wire.branch) : void 0,
+    events: wire.events.map(fromNormalizedTraceEventWire),
+    tokenUsage: wire.token_usage,
+    costUsd: wire.cost_usd,
+    durationMs: wire.duration_ms,
+    startedAt: wire.started_at,
+    endedAt: wire.ended_at,
+    metadata: wire.metadata
+  };
+}
+function toNormalizedTraceSourceWire(source) {
+  return omitUndefinedProperties({
+    kind: source.kind,
+    path: source.path,
+    url: source.url,
+    provider: source.provider,
+    format: source.format,
+    version: source.version,
+    metadata: source.metadata
+  });
+}
+function fromNormalizedTraceSourceWire(source) {
+  return {
+    kind: source.kind,
+    path: source.path,
+    url: source.url,
+    provider: source.provider,
+    format: source.format,
+    version: source.version,
+    metadata: source.metadata
+  };
+}
+function toNormalizedTraceSessionWire(session) {
+  return omitUndefinedProperties({
+    session_id: session.sessionId,
+    conversation_id: session.conversationId,
+    cwd: session.cwd,
+    started_at: session.startedAt,
+    ended_at: session.endedAt,
+    metadata: session.metadata
+  });
+}
+function fromNormalizedTraceSessionWire(session) {
+  return {
+    sessionId: session.session_id,
+    conversationId: session.conversation_id,
+    cwd: session.cwd,
+    startedAt: session.started_at,
+    endedAt: session.ended_at,
+    metadata: session.metadata
+  };
+}
+function toNormalizedTraceBranchWire(branch) {
+  return omitUndefinedProperties({
+    selected_leaf_id: branch.selectedLeafId,
+    selected_path_ids: branch.selectedPathIds,
+    included_event_ids: branch.includedEventIds,
+    omitted_event_ids: branch.omittedEventIds,
+    selection_reason: branch.selectionReason
+  });
+}
+function fromNormalizedTraceBranchWire(branch) {
+  return {
+    selectedLeafId: branch.selected_leaf_id,
+    selectedPathIds: branch.selected_path_ids,
+    includedEventIds: branch.included_event_ids,
+    omittedEventIds: branch.omitted_event_ids,
+    selectionReason: branch.selection_reason
+  };
+}
+function toNormalizedTraceEventWire(event) {
+  return NormalizedTraceEventWireSchema.parse(
+    omitUndefinedProperties({
+      event_id: event.eventId,
+      parent_event_id: event.parentEventId,
+      ordinal: event.ordinal,
+      type: event.type,
+      timestamp: event.timestamp,
+      duration_ms: event.durationMs,
+      duration_inferred: event.durationInferred,
+      turn_index: event.turnIndex,
+      message: event.message ? toNormalizedTraceMessageWire(event.message) : void 0,
+      model: event.model ? toNormalizedTraceModelWire(event.model) : void 0,
+      tool: event.tool ? toNormalizedTraceToolWire(event.tool) : void 0,
+      source_ref: event.sourceRef ? toNormalizedTraceSourceRefWire(event.sourceRef) : void 0,
+      raw_evidence: event.rawEvidence?.map(toNormalizedRawEvidenceWire),
+      redaction: event.redaction,
+      metadata: event.metadata
+    })
+  );
+}
+function fromNormalizedTraceEventWire(event) {
+  return {
+    eventId: event.event_id,
+    parentEventId: event.parent_event_id,
+    ordinal: event.ordinal,
+    type: event.type,
+    timestamp: event.timestamp,
+    durationMs: event.duration_ms,
+    durationInferred: event.duration_inferred,
+    turnIndex: event.turn_index,
+    message: event.message ? fromNormalizedTraceMessageWire(event.message) : void 0,
+    model: event.model ? fromNormalizedTraceModelWire(event.model) : void 0,
+    tool: event.tool ? fromNormalizedTraceToolWire(event.tool) : void 0,
+    sourceRef: event.source_ref ? fromNormalizedTraceSourceRefWire(event.source_ref) : void 0,
+    rawEvidence: event.raw_evidence?.map(fromNormalizedRawEvidenceWire),
+    redaction: event.redaction,
+    metadata: event.metadata
+  };
+}
+function toNormalizedTraceMessageWire(message) {
+  return omitUndefinedProperties({
+    role: message.role,
+    name: message.name,
+    content: message.content,
+    redaction: message.redaction,
+    token_usage: message.tokenUsage,
+    metadata: message.metadata
+  });
+}
+function fromNormalizedTraceMessageWire(message) {
+  return {
+    role: message.role,
+    name: message.name,
+    content: message.content,
+    redaction: message.redaction,
+    tokenUsage: message.token_usage,
+    metadata: message.metadata
+  };
+}
+function toNormalizedTraceModelWire(model) {
+  return omitUndefinedProperties({
+    provider: model.provider,
+    name: model.name,
+    invocation_id: model.invocationId,
+    token_usage: model.tokenUsage,
+    metadata: model.metadata
+  });
+}
+function fromNormalizedTraceModelWire(model) {
+  return {
+    provider: model.provider,
+    name: model.name,
+    invocationId: model.invocation_id,
+    tokenUsage: model.token_usage,
+    metadata: model.metadata
+  };
+}
+function toNormalizedTraceToolWire(tool) {
+  return omitUndefinedProperties({
+    name: tool.name,
+    call_id: tool.callId,
+    input: tool.input,
+    output: tool.output,
+    status: tool.status,
+    error: tool.error,
+    redaction: tool.redaction,
+    metadata: tool.metadata
+  });
+}
+function fromNormalizedTraceToolWire(tool) {
+  return {
+    name: tool.name,
+    callId: tool.call_id,
+    input: tool.input,
+    output: tool.output,
+    status: tool.status,
+    error: tool.error,
+    redaction: tool.redaction,
+    metadata: tool.metadata
+  };
+}
+function toNormalizedTraceSourceRefWire(sourceRef) {
+  return omitUndefinedProperties({
+    event_id: sourceRef.eventId,
+    message_id: sourceRef.messageId,
+    span_id: sourceRef.spanId,
+    trace_id: sourceRef.traceId,
+    raw_kind: sourceRef.rawKind,
+    path: sourceRef.path,
+    line: sourceRef.line,
+    metadata: sourceRef.metadata
+  });
+}
+function fromNormalizedTraceSourceRefWire(sourceRef) {
+  return {
+    eventId: sourceRef.event_id,
+    messageId: sourceRef.message_id,
+    spanId: sourceRef.span_id,
+    traceId: sourceRef.trace_id,
+    rawKind: sourceRef.raw_kind,
+    path: sourceRef.path,
+    line: sourceRef.line,
+    metadata: sourceRef.metadata
+  };
+}
+function toNormalizedRawEvidenceWire(evidence) {
+  return omitUndefinedProperties({
+    kind: evidence.kind,
+    ref: evidence.ref,
+    media_type: evidence.mediaType,
+    content: evidence.content,
+    redacted: evidence.redacted,
+    metadata: evidence.metadata
+  });
+}
+function fromNormalizedRawEvidenceWire(evidence) {
+  return {
+    kind: evidence.kind,
+    ref: evidence.ref,
+    mediaType: evidence.media_type,
+    content: evidence.content,
+    redacted: evidence.redacted,
+    metadata: evidence.metadata
+  };
+}
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -2604,6 +3045,82 @@ function computeTraceSummary(messages) {
     endTime: latestEnd?.toISOString()
   };
 }
+function getSelectedTrajectoryEvents(trajectory) {
+  if (!trajectory.branch?.includedEventIds || trajectory.branch.includedEventIds.length === 0) {
+    return trajectory.events;
+  }
+  const includedIds = new Set(trajectory.branch.includedEventIds);
+  return trajectory.events.filter((event) => includedIds.has(event.eventId));
+}
+function computeTraceSummaryFromTrajectory(trajectory) {
+  const selectedEvents = getSelectedTrajectoryEvents(trajectory);
+  const hasModelTurnEvents = selectedEvents.some((event) => event.type === "model_turn");
+  const toolCallCounts = {};
+  const toolDurations = {};
+  let totalToolCalls = 0;
+  let errorCount = 0;
+  let llmCallCount = 0;
+  let earliestStart;
+  let latestEnd;
+  let hasAnyDuration = false;
+  for (const event of selectedEvents) {
+    if (event.type === "model_turn" || !hasModelTurnEvents && event.type === "message" && event.message?.role === "assistant") {
+      llmCallCount++;
+    }
+    const eventStart = parseTimestamp(event.timestamp);
+    if (eventStart && (!earliestStart || eventStart < earliestStart)) {
+      earliestStart = eventStart;
+    }
+    const eventEnd = deriveEventEnd(eventStart, event.durationMs);
+    if (eventEnd && (!latestEnd || eventEnd > latestEnd)) {
+      latestEnd = eventEnd;
+    }
+    if (event.type !== "tool_call" || !event.tool) {
+      continue;
+    }
+    toolCallCounts[event.tool.name] = (toolCallCounts[event.tool.name] ?? 0) + 1;
+    totalToolCalls++;
+    if (isErrorToolEvent(event)) {
+      errorCount++;
+    }
+    if (event.durationMs !== void 0) {
+      hasAnyDuration = true;
+      if (!toolDurations[event.tool.name]) {
+        toolDurations[event.tool.name] = [];
+      }
+      toolDurations[event.tool.name].push(event.durationMs);
+    }
+  }
+  return {
+    trace: {
+      eventCount: totalToolCalls,
+      toolCalls: toolCallCounts,
+      errorCount,
+      llmCallCount,
+      ...hasAnyDuration ? { toolDurations } : {}
+    },
+    tokenUsage: trajectory.tokenUsage,
+    costUsd: trajectory.costUsd,
+    durationMs: trajectory.durationMs,
+    startTime: trajectory.startedAt ?? earliestStart?.toISOString(),
+    endTime: trajectory.endedAt ?? latestEnd?.toISOString()
+  };
+}
+function parseTimestamp(timestamp) {
+  if (!timestamp) return void 0;
+  const value = new Date(timestamp);
+  return Number.isNaN(value.getTime()) ? void 0 : value;
+}
+function deriveEventEnd(start, durationMs) {
+  if (!start) return void 0;
+  if (durationMs === void 0) return start;
+  return new Date(start.getTime() + durationMs);
+}
+function isErrorToolEvent(event) {
+  return Boolean(
+    event.tool?.error || event.tool?.status === "error" || event.tool?.status === "timeout" || event.tool?.status === "cancelled"
+  );
+}
 var DEFAULT_EXPLORATION_TOOLS = [
   "read",
   "grep",
@@ -3400,6 +3917,30 @@ var SkillTriggerGrader = class {
 };
 
 // src/evaluation/graders/llm-grader-prompt.ts
+function stringifyPretty2(value) {
+  return value === void 0 ? "" : JSON.stringify(value, null, 2);
+}
+function stringifyCompact2(value) {
+  return value === void 0 ? "" : JSON.stringify(value);
+}
+function buildTemplateVariables2(input) {
+  const formattedQuestion = input.promptInputs.question && input.promptInputs.question.trim().length > 0 ? input.promptInputs.question : input.evalCase.question;
+  return {
+    [TEMPLATE_VARIABLES.INPUT]: formattedQuestion.trim(),
+    [TEMPLATE_VARIABLES.OUTPUT]: input.candidate.trim(),
+    [TEMPLATE_VARIABLES.EXPECTED_OUTPUT]: (input.evalCase.reference_answer ?? "").trim(),
+    [TEMPLATE_VARIABLES.CRITERIA]: input.evalCase.criteria.trim(),
+    [TEMPLATE_VARIABLES.METADATA]: stringifyPretty2(input.evalCase.metadata),
+    [TEMPLATE_VARIABLES.METADATA_JSON]: stringifyCompact2(input.evalCase.metadata),
+    [TEMPLATE_VARIABLES.RUBRICS]: stringifyPretty2(input.rubrics),
+    [TEMPLATE_VARIABLES.RUBRICS_JSON]: stringifyCompact2(input.rubrics),
+    [TEMPLATE_VARIABLES.FILE_CHANGES]: input.fileChanges ?? "",
+    [TEMPLATE_VARIABLES.TOOL_CALLS]: input.toolCalls ?? "",
+    [TEMPLATE_VARIABLES.INPUT_TEXT]: formattedQuestion.trim(),
+    [TEMPLATE_VARIABLES.OUTPUT_TEXT]: input.candidate.trim(),
+    [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT]: (input.evalCase.reference_answer ?? "").trim()
+  };
+}
 function assembleLlmGraderPrompt(input) {
   const {
     evalCase,
@@ -3412,6 +3953,17 @@ function assembleLlmGraderPrompt(input) {
   } = input;
   const rubrics = evaluatorConfig?.rubrics;
   if (rubrics && rubrics.length > 0) {
+    if (graderTemplateOverride) {
+      return assembleCustom(
+        evalCase,
+        candidate,
+        promptInputs,
+        rubrics,
+        fileChanges,
+        toolCalls,
+        graderTemplateOverride
+      );
+    }
     const hasScoreRanges = rubrics.some((r) => r.score_ranges && r.score_ranges.length > 0);
     if (hasScoreRanges) {
       return assembleScoreRange(evalCase, candidate, promptInputs, rubrics, fileChanges, toolCalls);
@@ -3428,19 +3980,13 @@ function assembleLlmGraderPrompt(input) {
   );
 }
 function assembleFreeform(evalCase, candidate, promptInputs, fileChanges, toolCalls, graderTemplateOverride) {
-  const formattedQuestion = promptInputs.question && promptInputs.question.trim().length > 0 ? promptInputs.question : evalCase.question;
-  const variables = {
-    [TEMPLATE_VARIABLES.INPUT]: formattedQuestion.trim(),
-    [TEMPLATE_VARIABLES.OUTPUT]: candidate.trim(),
-    [TEMPLATE_VARIABLES.EXPECTED_OUTPUT]: (evalCase.reference_answer ?? "").trim(),
-    [TEMPLATE_VARIABLES.CRITERIA]: evalCase.criteria.trim(),
-    [TEMPLATE_VARIABLES.FILE_CHANGES]: fileChanges ?? "",
-    [TEMPLATE_VARIABLES.TOOL_CALLS]: toolCalls ?? "",
-    // Deprecated aliases
-    [TEMPLATE_VARIABLES.INPUT_TEXT]: formattedQuestion.trim(),
-    [TEMPLATE_VARIABLES.OUTPUT_TEXT]: candidate.trim(),
-    [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT]: (evalCase.reference_answer ?? "").trim()
-  };
+  const variables = buildTemplateVariables2({
+    evalCase,
+    candidate,
+    promptInputs,
+    fileChanges,
+    toolCalls
+  });
   const systemPrompt = buildOutputSchema();
   const template = graderTemplateOverride ?? DEFAULT_GRADER_TEMPLATE;
   let userPrompt = substituteVariables(template, variables);
@@ -3463,6 +4009,27 @@ ${toolCalls}`;
     mode: "freeform"
   };
 }
+function assembleCustom(evalCase, candidate, promptInputs, rubrics, fileChanges, toolCalls, graderTemplateOverride) {
+  const hasScoreRanges = rubrics.some((r) => r.score_ranges && r.score_ranges.length > 0);
+  const systemPrompt = hasScoreRanges ? buildScoreRangeOutputSchema() : buildRubricOutputSchema();
+  const userPrompt = substituteVariables(
+    graderTemplateOverride,
+    buildTemplateVariables2({
+      evalCase,
+      candidate,
+      promptInputs,
+      rubrics,
+      fileChanges,
+      toolCalls
+    })
+  );
+  return {
+    systemPrompt,
+    userPrompt,
+    responseSchema: systemPrompt,
+    mode: hasScoreRanges ? "score_range" : "checklist"
+  };
+}
 function assembleChecklist(evalCase, candidate, promptInputs, rubrics, fileChanges, toolCalls) {
   const formattedQuestion = promptInputs.question && promptInputs.question.trim().length > 0 ? promptInputs.question : evalCase.question;
   const parts = [
@@ -3486,10 +4053,19 @@ function assembleChecklist(evalCase, candidate, promptInputs, rubrics, fileChang
     parts.push("[[ ## tool_calls ## ]]", toolCalls, "");
   }
   parts.push("[[ ## rubrics ## ]]");
+  const operatorGuidance = formatRubricOperatorGuidance(rubrics);
+  if (operatorGuidance.length > 0) {
+    parts.push("", "Operator guidance:");
+    for (const guidance of operatorGuidance) {
+      parts.push(`- ${guidance}`);
+    }
+    parts.push("");
+  }
   for (const rubric of rubrics) {
     const requiredLabel = rubric.required ? " (REQUIRED)" : "";
     const weightLabel = rubric.weight !== 1 ? ` (weight: ${rubric.weight})` : "";
-    parts.push(`- [${rubric.id}]${requiredLabel}${weightLabel}: ${rubric.outcome}`);
+    const operatorLabel = formatRubricOperatorLabel(rubric.operator);
+    parts.push(`- [${rubric.id}]${requiredLabel}${weightLabel}${operatorLabel}: ${rubric.outcome}`);
   }
   parts.push("", "For each rubric, determine if it is satisfied and provide brief reasoning.");
   const systemPrompt = buildRubricOutputSchema();
@@ -3529,6 +4105,9 @@ function assembleScoreRange(evalCase, candidate, promptInputs, rubrics, fileChan
     const weightLabel = rubric.weight !== 1 ? ` (weight: ${rubric.weight})` : "";
     const minScoreLabel = rubric.required_min_score !== void 0 ? ` [REQUIRED: min score ${rubric.required_min_score}]` : "";
     parts.push("", `### Criterion: ${rubric.id}${weightLabel}${minScoreLabel}`);
+    if (rubric.operator) {
+      parts.push(`Operator: ${rubric.operator}`);
+    }
     if (rubric.outcome) {
       parts.push(`Description: ${rubric.outcome}`);
     }
@@ -3541,6 +4120,10 @@ function assembleScoreRange(evalCase, candidate, promptInputs, rubrics, fileChan
       }
     }
   }
+  const operatorGuidance = formatRubricOperatorGuidance(rubrics);
+  if (operatorGuidance.length > 0) {
+    parts.push("", ...operatorGuidance);
+  }
   parts.push(
     "",
     "For each criterion, provide an integer score 0-10 that matches one of its defined score ranges."
@@ -4259,7 +4842,7 @@ function runEqualsAssertion(output, value) {
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { mkdir as mkdir2 } from "node:fs/promises";
 import path5 from "node:path";
 
 // src/runtime/child-tracker.ts
@@ -4759,7 +5342,7 @@ var ClaudeCliProvider = class {
       return void 0;
     }
     try {
-      await mkdir(logDir, { recursive: true });
+      await mkdir2(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Claude CLI stream logging (could not create ${logDir}): ${message}`);
@@ -5069,7 +5652,7 @@ function tryParseJson(line) {
 // src/evaluation/providers/claude-sdk.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir2 } from "node:fs/promises";
+import { mkdir as mkdir3 } from "node:fs/promises";
 import path6 from "node:path";
 var claudeSdkModule = null;
 async function loadClaudeSdk() {
@@ -5254,7 +5837,7 @@ var ClaudeSdkProvider = class {
       return void 0;
     }
     try {
-      await mkdir2(logDir, { recursive: true });
+      await mkdir3(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Claude stream logging (could not create ${logDir}): ${message}`);
@@ -5449,44 +6032,44 @@ function formatElapsed2(startedAt) {
 // src/evaluation/providers/cli.ts
 import { exec as execWithCallback } from "node:child_process";
 import fs2 from "node:fs/promises";
-import os2 from "node:os";
+import os from "node:os";
 import path7 from "node:path";
 import { promisify } from "node:util";
-import { z as z2 } from "zod";
-var ToolCallSchema = z2.object({
-  tool: z2.string(),
-  input: z2.unknown().optional(),
-  output: z2.unknown().optional(),
-  id: z2.string().optional(),
-  start_time: z2.string().optional(),
-  end_time: z2.string().optional(),
-  duration_ms: z2.number().optional()
+import { z as z3 } from "zod";
+var ToolCallSchema = z3.object({
+  tool: z3.string(),
+  input: z3.unknown().optional(),
+  output: z3.unknown().optional(),
+  id: z3.string().optional(),
+  start_time: z3.string().optional(),
+  end_time: z3.string().optional(),
+  duration_ms: z3.number().optional()
 });
-var MessageInputSchema = z2.object({
-  role: z2.string(),
-  name: z2.string().optional(),
-  content: z2.unknown().optional(),
-  tool_calls: z2.array(ToolCallSchema).optional(),
-  start_time: z2.string().optional(),
-  end_time: z2.string().optional(),
-  duration_ms: z2.number().optional(),
-  metadata: z2.record(z2.unknown()).optional()
+var MessageInputSchema = z3.object({
+  role: z3.string(),
+  name: z3.string().optional(),
+  content: z3.unknown().optional(),
+  tool_calls: z3.array(ToolCallSchema).optional(),
+  start_time: z3.string().optional(),
+  end_time: z3.string().optional(),
+  duration_ms: z3.number().optional(),
+  metadata: z3.record(z3.unknown()).optional()
 });
-var TokenUsageSchema = z2.object({
-  input: z2.number(),
-  output: z2.number(),
-  cached: z2.number().optional()
+var TokenUsageSchema = z3.object({
+  input: z3.number(),
+  output: z3.number(),
+  cached: z3.number().optional()
 });
-var CliOutputSchema = z2.object({
-  text: z2.unknown().optional(),
-  output: z2.array(MessageInputSchema).optional(),
-  output_messages: z2.array(MessageInputSchema).optional(),
+var CliOutputSchema = z3.object({
+  text: z3.unknown().optional(),
+  output: z3.array(MessageInputSchema).optional(),
+  output_messages: z3.array(MessageInputSchema).optional(),
   token_usage: TokenUsageSchema.optional(),
-  cost_usd: z2.number().optional(),
-  duration_ms: z2.number().optional()
+  cost_usd: z3.number().optional(),
+  duration_ms: z3.number().optional()
 });
 var CliJsonlRecordSchema = CliOutputSchema.extend({
-  id: z2.string().min(1)
+  id: z3.string().min(1)
 });
 function validateMetrics(costUsd, durationMs, context) {
   let validCostUsd = costUsd;
@@ -5991,7 +6574,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path7.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return path7.join(os.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -6004,7 +6587,7 @@ function formatTimeoutSuffix2(timeoutMs) {
 // src/evaluation/providers/codex.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream as createWriteStream3 } from "node:fs";
-import { mkdir as mkdir3 } from "node:fs/promises";
+import { mkdir as mkdir4 } from "node:fs/promises";
 import path8 from "node:path";
 
 // src/evaluation/providers/codex-log-tracker.ts
@@ -6097,6 +6680,9 @@ var CodexProvider = class {
     const startMs = Date.now();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     const codexOptions = {};
+    if (this.config.executable) {
+      codexOptions.codexPathOverride = this.config.executable;
+    }
     if (this.config.model) {
       codexOptions.config = { model: this.config.model };
     }
@@ -6108,6 +6694,9 @@ var CodexProvider = class {
     if (cwd) {
       threadOptions.workingDirectory = cwd;
     }
+    if (this.config.modelReasoningEffort) {
+      threadOptions.modelReasoningEffort = this.config.modelReasoningEffort;
+    }
     const thread = codex.startThread(threadOptions);
     const inputFiles = normalizeInputFiles(request.inputFiles);
     const basePrompt = buildPromptDocument(request, inputFiles);
@@ -6255,7 +6844,7 @@ ${basePrompt}` : basePrompt;
   }
   resolveLogDirectory() {
     const disabled = isCodexLogStreamingDisabled();
-    if (disabled) {
+    if (disabled || this.config.streamLog === false) {
       return void 0;
     }
     if (this.config.logDir) {
@@ -6269,7 +6858,7 @@ ${basePrompt}` : basePrompt;
       return void 0;
     }
     try {
-      await mkdir3(logDir, { recursive: true });
+      await mkdir4(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Codex SDK stream logging (could not create ${logDir}): ${message}`);
@@ -6282,7 +6871,7 @@ ${basePrompt}` : basePrompt;
         targetName: this.targetName,
         evalCaseId: request.evalCaseId,
         attempt: request.attempt,
-        format: this.config.logFormat ?? "summary"
+        format: this.config.streamLog === "raw" ? "json" : "summary"
       });
       recordCodexLogEntry({
         filePath,
@@ -6418,7 +7007,7 @@ function formatElapsed3(startedAt) {
 
 // src/evaluation/providers/copilot-cli.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { mkdir as mkdir4 } from "node:fs/promises";
+import { mkdir as mkdir5 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import path11 from "node:path";
 import { Readable, Writable } from "node:stream";
@@ -6428,7 +7017,7 @@ import * as acp from "@agentclientprotocol/sdk";
 // src/evaluation/workspace/file-changes.ts
 import { exec as execCallback } from "node:child_process";
 import { readdirSync, statSync } from "node:fs";
-import { readFile as readFile2, readdir, stat } from "node:fs/promises";
+import { readFile as readFile3, readdir, stat } from "node:fs/promises";
 import path9 from "node:path";
 import { promisify as promisify2 } from "node:util";
 var execAsync2 = promisify2(execCallback);
@@ -6503,7 +7092,7 @@ async function walkDir(rootDir, currentDir, snapshot) {
       if (fileStat.size > SNAPSHOT_MAX_FILE_BYTES) continue;
       let content;
       try {
-        content = await readFile2(fullPath, "utf8");
+        content = await readFile3(fullPath, "utf8");
         if (content.includes("\0")) continue;
       } catch {
         continue;
@@ -6596,7 +7185,7 @@ import { arch, homedir, platform } from "node:os";
 import path10 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolvePlatformCliPath() {
-  const os3 = platform();
+  const os2 = platform();
   const cpu = arch();
   const platformMap = {
     linux: "linux",
@@ -6607,13 +7196,13 @@ function resolvePlatformCliPath() {
     x64: "x64",
     arm64: "arm64"
   };
-  const osPart = platformMap[os3];
+  const osPart = platformMap[os2];
   const archPart = archMap[cpu];
   if (!osPart || !archPart) {
     return void 0;
   }
   const packageName = `@github/copilot-${osPart}-${archPart}`;
-  const binaryName = os3 === "win32" ? "copilot.exe" : "copilot";
+  const binaryName = os2 === "win32" ? "copilot.exe" : "copilot";
   try {
     const resolved = import.meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath2(resolved) : resolved;
@@ -6681,9 +7270,9 @@ function resolvePlatformCliPath() {
 }
 function globalNpmRoots() {
   const roots = [];
-  const os3 = platform();
+  const os2 = platform();
   const home = homedir();
-  if (os3 === "win32") {
+  if (os2 === "win32") {
     if (process.env.APPDATA) {
       roots.push(path10.join(process.env.APPDATA, "npm", "node_modules"));
     }
@@ -6698,7 +7287,7 @@ function globalNpmRoots() {
   if (process.env.npm_config_prefix) {
     const prefix = process.env.npm_config_prefix;
     roots.push(
-      os3 === "win32" ? path10.join(prefix, "node_modules") : path10.join(prefix, "lib", "node_modules")
+      os2 === "win32" ? path10.join(prefix, "node_modules") : path10.join(prefix, "lib", "node_modules")
     );
   }
   return Array.from(new Set(roots));
@@ -7119,7 +7708,7 @@ var CopilotCliProvider = class {
       return void 0;
     }
     try {
-      await mkdir4(logDir, { recursive: true });
+      await mkdir5(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
@@ -7227,7 +7816,7 @@ function summarizeAcpEvent(eventType, data) {
 }
 
 // src/evaluation/providers/copilot-log.ts
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import path13 from "node:path";
 
@@ -7363,7 +7952,7 @@ function parseCopilotEvents(eventsJsonl) {
 }
 
 // src/evaluation/providers/copilot-session-discovery.ts
-import { readFile as readFile3, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile4, readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import path12 from "node:path";
 var DEFAULT_SESSION_STATE_DIR = () => path12.join(homedir3(), ".copilot", "session-state");
@@ -7382,7 +7971,7 @@ async function discoverCopilotSessions(opts) {
     const workspacePath = path12.join(sessionDir, "workspace.yaml");
     const eventsPath = path12.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await readFile3(workspacePath, "utf8");
+      const workspaceContent = await readFile4(workspacePath, "utf8");
       const workspace = parseYamlValue(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
@@ -7444,7 +8033,7 @@ var CopilotLogProvider = class {
     const eventsPath = path13.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await readFile4(eventsPath, "utf8");
+      eventsContent = await readFile5(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
@@ -7491,7 +8080,7 @@ var CopilotLogProvider = class {
 // src/evaluation/providers/copilot-sdk.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { mkdir as mkdir6 } from "node:fs/promises";
 import path14 from "node:path";
 
 // src/evaluation/providers/copilot-sdk-log-tracker.ts
@@ -7831,7 +8420,7 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     try {
-      await mkdir5(logDir, { recursive: true });
+      await mkdir6(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
@@ -7957,7 +8546,7 @@ var MockProvider = class {
 import { execSync, spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { accessSync, createWriteStream as createWriteStream5, readFileSync } from "node:fs";
-import { mkdir as mkdir6, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir7, mkdtemp as mkdtemp2, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
 import path15 from "node:path";
 
@@ -8166,7 +8755,7 @@ var PiCliProvider = class {
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
       const promptFile = path15.join(cwd, PROMPT_FILENAME);
-      await writeFile2(promptFile, request.question, "utf8");
+      await writeFile3(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const result = await this.executePi(args, cwd, request.signal, logger);
       if (result.timedOut) {
@@ -8357,7 +8946,7 @@ ${prompt}` : prompt;
       return void 0;
     }
     try {
-      await mkdir6(logDir, { recursive: true });
+      await mkdir7(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
@@ -8920,7 +9509,7 @@ async function defaultPiRunner(options) {
 import { execSync as execSync2 } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { accessSync as accessSync2, createWriteStream as createWriteStream6, mkdirSync } from "node:fs";
-import { mkdir as mkdir7 } from "node:fs/promises";
+import { mkdir as mkdir8 } from "node:fs/promises";
 import path16 from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
@@ -9357,7 +9946,7 @@ ${fileList}`;
       return void 0;
     }
     try {
-      await mkdir7(logDir, { recursive: true });
+      await mkdir8(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
@@ -9582,12 +10171,12 @@ import path27 from "node:path";
 import { promisify as promisify4 } from "node:util";
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
-import { stat as stat5, writeFile as writeFile5 } from "node:fs/promises";
+import { stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
 import path25 from "node:path";
 
 // src/evaluation/providers/vscode/utils/fs.ts
 import { constants } from "node:fs";
-import { access, mkdir as mkdir8, readdir as readdir3, rm as rm3, stat as stat3 } from "node:fs/promises";
+import { access, mkdir as mkdir9, readdir as readdir3, rm as rm3, stat as stat3 } from "node:fs/promises";
 import path17 from "node:path";
 async function pathExists(target) {
   try {
@@ -9598,7 +10187,7 @@ async function pathExists(target) {
   }
 }
 async function ensureDir(target) {
-  await mkdir8(target, { recursive: true });
+  await mkdir9(target, { recursive: true });
 }
 async function readDirEntries(target) {
   const entries = await readdir3(target, { withFileTypes: true });
@@ -9731,7 +10320,7 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 }
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import path20 from "node:path";
 
 // src/evaluation/providers/vscode/utils/time.ts
@@ -9770,7 +10359,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile5(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile6(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -9827,7 +10416,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile5(file, { encoding: "utf8" });
+        const content = await readFile6(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -9850,7 +10439,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 import { exec, spawn as spawn4 } from "node:child_process";
-import { mkdir as mkdir9, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir10, writeFile as writeFile4 } from "node:fs/promises";
 import path22 from "node:path";
 import { promisify as promisify3 } from "node:util";
 
@@ -9931,9 +10520,9 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   const aliveFile = path22.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
   const githubAgentsDir = path22.join(subagentDir, ".github", "agents");
-  await mkdir9(githubAgentsDir, { recursive: true });
+  await mkdir10(githubAgentsDir, { recursive: true });
   const wakeupDst = path22.join(githubAgentsDir, "wakeup.md");
-  await writeFile3(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  await writeFile4(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
   });
@@ -9962,9 +10551,9 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
   const workspacePath = path22.join(subagentDir, `${path22.basename(subagentDir)}.code-workspace`);
   const messagesDir = path22.join(subagentDir, "messages");
-  await mkdir9(messagesDir, { recursive: true });
+  await mkdir10(messagesDir, { recursive: true });
   const reqFile = path22.join(messagesDir, `${timestamp}_req.md`);
-  await writeFile3(reqFile, requestInstructions, { encoding: "utf8" });
+  await writeFile4(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -9990,7 +10579,7 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
   const workspacePath = path22.join(subagentDir, `${path22.basename(subagentDir)}.code-workspace`);
   const messagesDir = path22.join(subagentDir, "messages");
-  await mkdir9(messagesDir, { recursive: true });
+  await mkdir10(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
@@ -10013,7 +10602,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-import { copyFile, mkdir as mkdir10, readFile as readFile6, readdir as readdir4, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import { copyFile, mkdir as mkdir11, readFile as readFile7, readdir as readdir4, stat as stat4, writeFile as writeFile5 } from "node:fs/promises";
 import path24 from "node:path";
 
 // src/evaluation/providers/vscode/utils/workspace.ts
@@ -10130,7 +10719,7 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile6(workspaceSrc, "utf8");
+    const templateText = await readFile7(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
@@ -10149,9 +10738,9 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
       transformedContent = JSON.stringify(parsed, null, 2);
     }
   }
-  await writeFile4(workspaceDst, transformedContent, "utf8");
+  await writeFile5(workspaceDst, transformedContent, "utf8");
   const messagesDir = path24.join(subagentDir, "messages");
-  await mkdir10(messagesDir, { recursive: true });
+  await mkdir11(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
@@ -10174,7 +10763,7 @@ async function createSubagentLock(subagentDir) {
     );
   }
   const lockFile = path24.join(subagentDir, DEFAULT_LOCK_NAME);
-  await writeFile4(lockFile, "", { encoding: "utf8" });
+  await writeFile5(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
@@ -10199,7 +10788,7 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
   }
   if (promptFile) {
     const githubAgentsDir = path24.join(subagentDir, ".github", "agents");
-    await mkdir10(githubAgentsDir, { recursive: true });
+    await mkdir11(githubAgentsDir, { recursive: true });
     const agentFile = path24.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
@@ -10460,7 +11049,7 @@ async function dispatchBatchAgent(options) {
           const reqFile = requestFiles[index];
           const tmpFile = responseTmpFiles[index];
           const finalFile = responseFilesFinal[index];
-          return writeFile5(
+          return writeFile6(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -10472,7 +11061,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await writeFile5(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await writeFile6(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -10538,7 +11127,7 @@ async function dispatchBatchAgent(options) {
 }
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
-import { writeFile as writeFile6 } from "node:fs/promises";
+import { writeFile as writeFile7 } from "node:fs/promises";
 import path26 from "node:path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
@@ -10619,8 +11208,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await writeFile6(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile6(wakeupDst, wakeupContent, "utf8");
+        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile7(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -10630,8 +11219,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await writeFile6(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile6(wakeupDst, wakeupContent, "utf8");
+        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile7(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -10639,8 +11228,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await writeFile6(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile6(wakeupDst, wakeupContent, "utf8");
+      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile7(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -10655,8 +11244,8 @@ async function provisionSubagents(options) {
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await writeFile6(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile6(wakeupDst, wakeupContent, "utf8");
+      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile7(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -10981,7 +11570,7 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 
 // src/evaluation/providers/targets-file.ts
 import { constants as constants3 } from "node:fs";
-import { access as access3, readFile as readFile7 } from "node:fs/promises";
+import { access as access3, readFile as readFile8 } from "node:fs/promises";
 import path28 from "node:path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -11025,7 +11614,7 @@ async function readTargetDefinitions(filePath) {
   if (!await fileExists2(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile7(absolutePath, "utf8");
+  const raw = await readFile8(absolutePath, "utf8");
   const parsed = parseYamlValue(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -11216,6 +11805,7 @@ async function executePromptTemplate(script, context, config, timeoutMs) {
     output: context.output ?? null,
     inputFiles: context.evalCase.file_paths,
     input: context.evalCase.input,
+    metadata: context.evalCase.metadata ?? null,
     trace: context.trace ?? null,
     fileChanges: context.fileChanges ?? null,
     workspacePath: context.workspacePath ?? null,
@@ -11733,7 +12323,7 @@ function getTCritical(df) {
 }
 
 // src/evaluation/workspace/manager.ts
-import { cp, mkdir as mkdir12, readdir as readdir5, rm as rm4, stat as stat6 } from "node:fs/promises";
+import { cp, mkdir as mkdir13, readdir as readdir5, rm as rm4, stat as stat6 } from "node:fs/promises";
 import path33 from "node:path";
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
@@ -11767,7 +12357,7 @@ function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   return path33.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
-  await mkdir12(dest, { recursive: true });
+  await mkdir13(dest, { recursive: true });
   const entries = await readdir5(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path33.join(src, entry.name);
@@ -11842,7 +12432,7 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, readFile as readFile8, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir14, readFile as readFile9, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile8 } from "node:fs/promises";
 import path34 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync = promisify5(execFile);
@@ -11896,7 +12486,7 @@ function computeWorkspaceFingerprint(repos) {
   return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
-  await mkdir13(dest, { recursive: true });
+  await mkdir14(dest, { recursive: true });
   const entries = await readdir6(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path34.join(src, entry.name);
@@ -11934,7 +12524,7 @@ var WorkspacePoolManager = class {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
     const poolDir = path34.join(this.poolRoot, fingerprint);
-    await mkdir13(poolDir, { recursive: true });
+    await mkdir14(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
       console.warn(
@@ -11961,7 +12551,7 @@ var WorkspacePoolManager = class {
           poolDir
         };
       }
-      await mkdir13(slotPath, { recursive: true });
+      await mkdir14(slotPath, { recursive: true });
       if (templatePath) {
         await copyDirectoryRecursive2(templatePath, slotPath);
       }
@@ -11998,14 +12588,14 @@ var WorkspacePoolManager = class {
   async tryLock(lockPath) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        await writeFile7(lockPath, String(process.pid), { flag: "wx" });
+        await writeFile8(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code !== "EEXIST") {
           throw err;
         }
         try {
-          const pidStr = await readFile8(lockPath, "utf-8");
+          const pidStr = await readFile9(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -12032,7 +12622,7 @@ var WorkspacePoolManager = class {
   async checkDrift(poolDir, fingerprint) {
     const metadataPath = path34.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile8(metadataPath, "utf-8");
+      const raw = await readFile9(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -12047,7 +12637,7 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile7(path34.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await writeFile8(path34.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
@@ -12057,7 +12647,7 @@ var WorkspacePoolManager = class {
         const lockPath = path34.join(poolDir, `${entry}.lock`);
         if (existsSync3(lockPath)) {
           try {
-            const pidStr = await readFile8(lockPath, "utf-8");
+            const pidStr = await readFile9(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -12416,9 +13006,10 @@ async function executeWorkspaceScript(config, context, failureMode = "fatal") {
 }
 
 // src/evaluation/yaml-parser.ts
-import { readFile as readFile15, stat as stat8 } from "node:fs/promises";
+import { readFile as readFile16, stat as stat8 } from "node:fs/promises";
 import path43 from "node:path";
 import micromatch2 from "micromatch";
+import { stringify as stringifyYaml } from "yaml";
 
 // src/evaluation/input-message-utils.ts
 function flattenInputMessages(messages) {
@@ -12485,7 +13076,7 @@ function cloneJsonValue(value) {
 }
 
 // src/evaluation/loaders/agent-skills-parser.ts
-import { readFile as readFile9 } from "node:fs/promises";
+import { readFile as readFile10 } from "node:fs/promises";
 import path37 from "node:path";
 var ANSI_RED = "\x1B[31m";
 var ANSI_RESET2 = "\x1B[0m";
@@ -12498,7 +13089,7 @@ function isAgentSkillsFormat(parsed) {
   return Array.isArray(obj.evals);
 }
 async function loadTestsFromAgentSkills(filePath) {
-  const raw = await readFile9(filePath, "utf8");
+  const raw = await readFile10(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -12565,7 +13156,7 @@ function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
 }
 
 // src/evaluation/loaders/config-loader.ts
-import { readFile as readFile10 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import path39 from "node:path";
 
 // src/evaluation/loaders/file-resolver.ts
@@ -12679,20 +13270,22 @@ var DEFAULT_EVAL_PATTERNS = [
 ];
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain2(evalFilePath, repoRoot);
+  const globalConfigPath = path39.join(getAgentvConfigDir(), "config.yaml");
   for (const directory of directories) {
     const configPath = path39.join(directory, ".agentv", "config.yaml");
     if (!await fileExists3(configPath)) {
       continue;
     }
     const config = await readConfigFile(configPath);
-    if (config) return config;
+    if (config) {
+      return config;
+    }
   }
-  const globalConfigPath = path39.join(getAgentvConfigDir(), "config.yaml");
   return await fileExists3(globalConfigPath) ? readConfigFile(globalConfigPath) : null;
 }
 async function readConfigFile(configPath) {
   try {
-    const rawConfig = await readFile10(configPath, "utf8");
+    const rawConfig = await readFile11(configPath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(rawConfig), process.env);
     if (!isJsonObject(parsed)) {
       logWarning(`Invalid config.yaml format at ${configPath}`);
@@ -12905,7 +13498,10 @@ function extractCacheConfig(suite) {
     logWarning(`Invalid execution.cache: ${cache}. Must be a boolean. Ignoring.`);
     return void 0;
   }
-  const cachePath = executionObj.cache_path ?? executionObj.cachePath;
+  if (executionObj.cachePath !== void 0) {
+    logWarning("Invalid execution.cachePath: use snake_case execution.cache_path in YAML.");
+  }
+  const cachePath = executionObj.cache_path;
   const resolvedCachePath = typeof cachePath === "string" && cachePath.trim().length > 0 ? cachePath.trim() : void 0;
   return { enabled: cache, cachePath: resolvedCachePath };
 }
@@ -13074,6 +13670,12 @@ function parseResultsConfig(raw, configPath) {
     ...branchPrefix && { branch_prefix: branchPrefix }
   };
 }
+function resolveResultsConfigForProject(config, _projectId) {
+  if (!config) {
+    return void 0;
+  }
+  return config.results;
+}
 function parseHooksConfig(raw, configPath) {
   if (raw === void 0 || raw === null) {
     return void 0;
@@ -13098,15 +13700,15 @@ function logWarning(message) {
 }
 
 // src/evaluation/loaders/grader-parser.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 import path40 from "node:path";
 
 // src/evaluation/validation/prompt-validator.ts
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 var ANSI_YELLOW3 = "\x1B[33m";
 var ANSI_RESET4 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
-  const content = await readFile11(promptPath, "utf8");
+  const content = await readFile12(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
 }
 function validateTemplateVariables(content, source) {
@@ -13238,7 +13840,7 @@ ${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
     const cycle = [...includeContext.chain, resolved.resolvedPath].join(" -> ");
     throw new Error(`Assertion template cycle detected in '${evalId}': ${cycle}`);
   }
-  const content = await readFile12(resolved.resolvedPath, "utf8");
+  const content = await readFile13(resolved.resolvedPath, "utf8");
   const parsed = interpolateEnv(parseYamlValue(content), process.env);
   if (!isJsonObject2(parsed)) {
     throw new Error(
@@ -13285,6 +13887,103 @@ async function expandGraderEntries(candidateEvaluators, searchRoots, evalId, inc
   }
   return expanded;
 }
+async function collectAssertionTemplateSourceReferences(rawEvalCase, globalExecution, searchRoots, evalId) {
+  const execution = rawEvalCase.execution;
+  const executionObject = isJsonObject2(execution) ? execution : void 0;
+  const caseEvaluators = rawEvalCase.assertions ?? rawEvalCase.assert ?? (executionObject ? executionObject.evaluators : void 0) ?? rawEvalCase.evaluators;
+  const skipDefaults = executionObject?.skip_defaults === true;
+  const rootEvaluators = skipDefaults ? void 0 : globalExecution?.assertions ?? globalExecution?.assert ?? globalExecution?.evaluators;
+  return [
+    ...await collectAssertionTemplateReferencesFromValue(caseEvaluators, searchRoots, evalId),
+    ...await collectAssertionTemplateReferencesFromValue(rootEvaluators, searchRoots, evalId)
+  ];
+}
+async function collectAssertionTemplateReferencesFromValue(value, searchRoots, evalId, includeContext = { depth: 0, chain: [] }) {
+  if (value === void 0) {
+    return [];
+  }
+  const references = [];
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (isIncludeEntry(item)) {
+        const nextDepth = includeContext.depth + 1;
+        if (nextDepth > MAX_ASSERTION_INCLUDE_DEPTH) {
+          const chain = [...includeContext.chain, item.include].join(" -> ");
+          throw new Error(
+            `Assertion template include depth exceeded ${MAX_ASSERTION_INCLUDE_DEPTH} in '${evalId}'. Include chain: ${chain}`
+          );
+        }
+        const resolved = await resolveAssertionTemplateReference(item.include, searchRoots);
+        references.push({
+          kind: "assertion_template",
+          displayPath: resolved.displayPath,
+          ...resolved.resolvedPath ? { resolvedPath: path40.resolve(resolved.resolvedPath) } : {}
+        });
+        if (resolved.resolvedPath) {
+          if (includeContext.chain.includes(resolved.resolvedPath)) {
+            const cycle = [...includeContext.chain, resolved.resolvedPath].join(" -> ");
+            throw new Error(`Assertion template cycle detected in '${evalId}': ${cycle}`);
+          }
+          const content = await readFile13(resolved.resolvedPath, "utf8");
+          const parsed = interpolateEnv(parseYamlValue(content), process.env);
+          if (isJsonObject2(parsed) && Array.isArray(parsed.assertions)) {
+            const templateDir = path40.dirname(resolved.resolvedPath);
+            const nestedSearchRoots = [
+              templateDir,
+              ...searchRoots.filter((root) => path40.resolve(root) !== templateDir)
+            ];
+            references.push(
+              ...await collectAssertionTemplateReferencesFromValue(
+                parsed.assertions,
+                nestedSearchRoots,
+                evalId,
+                {
+                  depth: nextDepth,
+                  chain: [...includeContext.chain, resolved.resolvedPath]
+                }
+              )
+            );
+          }
+        }
+        continue;
+      }
+      if (isJsonObject2(item)) {
+        references.push(
+          ...await collectAssertionTemplateReferencesFromObject(
+            item,
+            searchRoots,
+            evalId,
+            includeContext
+          )
+        );
+      }
+    }
+  } else if (isJsonObject2(value)) {
+    references.push(
+      ...await collectAssertionTemplateReferencesFromObject(
+        value,
+        searchRoots,
+        evalId,
+        includeContext
+      )
+    );
+  }
+  return references;
+}
+async function collectAssertionTemplateReferencesFromObject(value, searchRoots, evalId, includeContext) {
+  const references = [];
+  for (const key of ["assertions", "assert", "evaluators"]) {
+    references.push(
+      ...await collectAssertionTemplateReferencesFromValue(
+        value[key],
+        searchRoots,
+        evalId,
+        includeContext
+      )
+    );
+  }
+  return references;
+}
 async function parseGraderList(candidateEvaluators, searchRoots, evalId, defaultPreprocessors) {
   const expandedEvaluators = await expandGraderEntries(candidateEvaluators, searchRoots, evalId);
   if (!expandedEvaluators) {
@@ -13411,6 +14110,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         continue;
       }
       const weight2 = validateWeight(rawEvaluator.weight, name, evalId);
+      const resolvedScriptPath = await resolveOptionalCommandSource(command, searchRoots);
       const cwd = asString(rawEvaluator.cwd);
       let resolvedCwd;
       if (cwd) {
@@ -13476,6 +14176,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         name,
         type: "code-grader",
         command,
+        ...resolvedScriptPath ? { resolvedScriptPath } : {},
         cwd,
         resolvedCwd,
         ...weight2 !== void 0 ? { weight: weight2 } : {},
@@ -14543,6 +15244,17 @@ function asStringArray(value, description) {
   }
   return result;
 }
+async function resolveOptionalCommandSource(command, searchRoots) {
+  const candidate = command.at(-1);
+  if (!candidate || !looksLikeFilePath(candidate)) {
+    return void 0;
+  }
+  const resolved = await resolveFileReference(candidate, searchRoots);
+  return resolved.resolvedPath ? path40.resolve(resolved.resolvedPath) : void 0;
+}
+function looksLikeFilePath(value) {
+  return path40.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
+}
 function parseCommandToArgv(command) {
   if (process.platform === "win32") {
     return ["cmd.exe", "/c", command];
@@ -14611,6 +15323,19 @@ var VALID_FIELD_AGGREGATION_TYPES = /* @__PURE__ */ new Set(["weighted_average",
 function isValidFieldAggregationType(value) {
   return typeof value === "string" && VALID_FIELD_AGGREGATION_TYPES.has(value);
 }
+var VALID_RUBRIC_OPERATORS = new Set(RUBRIC_OPERATOR_VALUES);
+function parseRubricOperator(value, rubricId, evaluatorName, evalId) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && VALID_RUBRIC_OPERATORS.has(value)) {
+    return value;
+  }
+  logWarning2(
+    `Ignoring invalid operator for rubric '${rubricId}' in evaluator '${evaluatorName}' in '${evalId}': must be one of ${RUBRIC_OPERATOR_VALUES.join(", ")}`
+  );
+  return void 0;
+}
 function parseRubricItems(rawRubrics, evaluatorName, evalId) {
   const items = [];
   for (const [index, rawRubric] of rawRubrics.entries()) {
@@ -14621,7 +15346,8 @@ function parseRubricItems(rawRubrics, evaluatorName, evalId) {
       continue;
     }
     const id = asString(rawRubric.id) ?? `rubric-${index + 1}`;
-    const expectedOutcome = asString(rawRubric.outcome) ?? "";
+    const expectedOutcome = asString(rawRubric.outcome) ?? asString(rawRubric.criteria) ?? "";
+    const operator = parseRubricOperator(rawRubric.operator, id, evaluatorName, evalId);
     const weight = typeof rawRubric.weight === "number" ? rawRubric.weight : 1;
     let minScore;
     let requiredMinScore;
@@ -14665,6 +15391,7 @@ function parseRubricItems(rawRubrics, evaluatorName, evalId) {
         id,
         weight,
         ...expectedOutcome.length > 0 ? { outcome: expectedOutcome } : {},
+        ...operator !== void 0 ? { operator } : {},
         ...required !== void 0 ? { required } : {},
         ...minScore !== void 0 ? { min_score: minScore } : {},
         ...requiredMinScore !== void 0 ? { required_min_score: requiredMinScore } : {},
@@ -14680,6 +15407,7 @@ function parseRubricItems(rawRubrics, evaluatorName, evalId) {
       items.push({
         id,
         outcome: expectedOutcome,
+        ...operator !== void 0 ? { operator } : {},
         weight,
         // Default to required: true if not specified (backward compatibility)
         required: required ?? true,
@@ -14802,6 +15530,8 @@ function parseInlineRubrics(rawRubrics) {
       };
     }
     const expectedOutcome = asString(rubric.outcome) ?? "";
+    const id = asString(rubric.id) ?? `rubric-${index + 1}`;
+    const operator = parseRubricOperator(rubric.operator, id, "rubrics", "<inline>");
     const rawScoreRanges = rubric.score_ranges;
     const normalizedScoreRanges = rawScoreRanges !== void 0 ? normalizeScoreRangesShorthand(rawScoreRanges) : void 0;
     const scoreRanges = Array.isArray(normalizedScoreRanges) && normalizedScoreRanges.length > 0 ? normalizedScoreRanges.filter((r) => isJsonObject2(r)).map((range) => ({
@@ -14809,7 +15539,8 @@ function parseInlineRubrics(rawRubrics) {
       outcome: asString(range.outcome) ?? ""
     })).filter((r) => r.outcome.length > 0) : void 0;
     const baseRubric = {
-      id: asString(rubric.id) ?? `rubric-${index + 1}`,
+      id,
+      ...operator !== void 0 ? { operator } : {},
       weight: typeof rubric.weight === "number" ? rubric.weight : 1
     };
     let inlineMinScore;
@@ -14850,12 +15581,12 @@ function parseInlineRubrics(rawRubrics) {
 }
 
 // src/evaluation/loaders/jsonl-parser.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 import path42 from "node:path";
 import micromatch from "micromatch";
 
 // src/evaluation/loaders/message-processor.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 import path41 from "node:path";
 
 // src/evaluation/formatting/segment-formatter.ts
@@ -14982,7 +15713,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await readFile13(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile14(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           processedContent.push({
             ...cloneJsonObject(rawSegment),
             path: displayPath,
@@ -15023,7 +15754,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await readFile13(resolvedPath);
+          const imageBuffer = await readFile14(resolvedPath);
           const base64 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -15106,7 +15837,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await readFile13(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await readFile14(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
@@ -15146,7 +15877,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await readFile13(resolvedPath);
+            const imageBuffer = await readFile14(resolvedPath);
             const base64 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -15188,6 +15919,12 @@ function expandInputShorthand(value) {
   if (typeof value === "string") {
     return [{ role: "user", content: value }];
   }
+  if (isJsonObject(value)) {
+    if ("role" in value) {
+      return isTestMessage(value) ? [value] : void 0;
+    }
+    return [{ role: "user", content: value }];
+  }
   if (Array.isArray(value)) {
     const messages = value.filter((msg) => isTestMessage(msg));
     return messages.length > 0 ? messages : void 0;
@@ -15275,7 +16012,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile14(sidecarPath, "utf8");
+    const content = await readFile15(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -15320,7 +16057,7 @@ async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await readFile14(absoluteTestPath, "utf8");
+  const rawFile = await readFile15(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
   const fallbackSuiteName = path42.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
@@ -15457,16 +16194,16 @@ ${detailBlock}${ANSI_RESET7}`);
 }
 
 // src/evaluation/metadata.ts
-import { z as z3 } from "zod";
-var MetadataSchema = z3.object({
-  name: z3.string().min(1).max(64).regex(/^[a-z0-9-]+$/).optional(),
-  description: z3.string().min(1).max(1024).optional(),
-  version: z3.string().optional(),
-  author: z3.string().optional(),
-  tags: z3.array(z3.string()).optional(),
-  license: z3.string().optional(),
-  requires: z3.object({
-    agentv: z3.string().optional()
+import { z as z4 } from "zod";
+var MetadataSchema = z4.object({
+  name: z4.string().min(1).max(64).regex(/^[a-z0-9-]+$/).optional(),
+  description: z4.string().min(1).max(1024).optional(),
+  version: z4.string().optional(),
+  author: z4.string().optional(),
+  tags: z4.array(z4.string()).optional(),
+  license: z4.string().optional(),
+  requires: z4.object({
+    agentv: z4.string().optional()
   }).optional()
 });
 function parseMetadata(suite) {
@@ -15738,7 +16475,7 @@ function interpolateRawEvalCase(raw, vars) {
 async function readTestSuiteMetadata(testFilePath) {
   try {
     const absolutePath = path43.resolve(testFilePath);
-    const content = await readFile15(absolutePath, "utf8");
+    const content = await readFile16(absolutePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
@@ -15762,7 +16499,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-Z6IUSDNA.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-EQJX3OLT.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
@@ -15797,7 +16534,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromAgentSkills(evalFilePath);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-Z6IUSDNA.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-EQJX3OLT.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -15812,8 +16549,10 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots(absoluteTestPath, repoRootPath);
   const config = await loadConfig(absoluteTestPath, repoRootPath);
-  const rawFile = await readFile15(absoluteTestPath, "utf8");
-  const interpolated = interpolateEnv(parseYamlValue(rawFile), process.env);
+  const rawFile = await readFile16(absoluteTestPath, "utf8");
+  const rawParsed = parseYamlValue(rawFile);
+  const rawCaseSnapshots = buildRawInlineTestSnapshots(rawParsed);
+  const interpolated = interpolateEnv(rawParsed, process.env);
   if (!isJsonObject(interpolated)) {
     throw new Error(`Invalid test file format: ${evalFilePath}`);
   }
@@ -15850,7 +16589,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     throw new Error(`Invalid test file format: ${evalFilePath} - missing 'tests' field`);
   }
   const suiteWorkspace = await resolveWorkspaceConfig(suite.workspace, evalFileDir);
-  const suiteGovernance = extractSuiteGovernance(suite);
+  const suiteMetadataPayload = extractSuiteMetadataPayload(suite);
   const rawSuiteInput = suite.input;
   const rawSuiteInputFiles = suite.input_files;
   const rawGlobalExecution = isJsonObject(suite.execution) ? suite.execution : void 0;
@@ -15952,6 +16691,12 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       logError3(`Skipping test '${id}': ${message}`);
       continue;
     }
+    const assertionTemplateReferences = await collectAssertionTemplateSourceReferences(
+      renderedCase,
+      globalExecution,
+      searchRoots,
+      id ?? "unknown"
+    );
     const inlineRubrics = renderedCase.rubrics;
     if (inlineRubrics !== void 0 && Array.isArray(inlineRubrics)) {
       const rubricEvaluator = parseInlineRubrics(inlineRubrics);
@@ -15964,8 +16709,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     const caseWorkspace = await resolveWorkspaceConfig(renderedCase.workspace, evalFileDir);
     const mergedWorkspace = mergeWorkspaceConfigs(suiteWorkspace, caseWorkspace);
     const rawCaseMetadata = isJsonObject(renderedCase.metadata) ? renderedCase.metadata : void 0;
-    const suitePayload = suiteGovernance !== void 0 ? { governance: suiteGovernance } : void 0;
-    const metadata = mergeSuiteMetadataPayload(rawCaseMetadata, suitePayload);
+    const metadata = mergeSuiteMetadataPayload(rawCaseMetadata, suiteMetadataPayload);
     const caseTargets = extractTargetsFromTestCase(renderedCase);
     const dependsOn = Array.isArray(renderedCase.depends_on) ? renderedCase.depends_on.filter(
       (v) => typeof v === "string"
@@ -16004,12 +16748,245 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       ...onTurnFailure ? { on_turn_failure: onTurnFailure } : {},
       ...windowSize !== void 0 ? { window_size: windowSize } : {},
       ...dependsOn && dependsOn.length > 0 ? { depends_on: dependsOn } : {},
-      ...onDependencyFailure ? { on_dependency_failure: onDependencyFailure } : {}
+      ...onDependencyFailure ? { on_dependency_failure: onDependencyFailure } : {},
+      source: buildEvalTestSource({
+        evalFilePath,
+        absoluteTestPath,
+        repoRootPath,
+        id,
+        renderedCase,
+        rawCaseSnapshots,
+        inputMessages,
+        evaluators,
+        assertionTemplateReferences
+      })
     };
     results.push(testCase);
   }
   return { tests: results, parsed: suite, suiteWorkspacePath: suiteWorkspace?.path };
 }
+var SOURCE_SECRET_KEY_PATTERN = /(api[_-]?key|authorization|bearer|credential|password|private[_-]?key|secret|token)/i;
+var REDACTED_SOURCE_VALUE = "[redacted]";
+function buildRawInlineTestSnapshots(rawParsed) {
+  const snapshots = /* @__PURE__ */ new Map();
+  if (!isJsonObject(rawParsed)) {
+    return snapshots;
+  }
+  const rawTests = rawParsed.tests ?? rawParsed.eval_cases ?? rawParsed.evalcases;
+  if (!Array.isArray(rawTests)) {
+    return snapshots;
+  }
+  for (const rawTest of rawTests) {
+    if (!isJsonObject(rawTest) || typeof rawTest.id !== "string") {
+      continue;
+    }
+    snapshots.set(rawTest.id, stringifySourceYaml(rawTest));
+  }
+  return snapshots;
+}
+function buildEvalTestSource(params) {
+  const evalFileRepoPath = toPortableRelativePath(params.repoRootPath, params.absoluteTestPath);
+  const testSnapshotYaml = params.rawCaseSnapshots.get(params.id) ?? stringifySourceYaml(params.renderedCase);
+  const evaluatorReferences = collectGraderSourceReferences(params.evaluators);
+  const inputReferences = collectInputSourceReferences(params.inputMessages);
+  const references = dedupeSourceReferences([
+    ...inputReferences,
+    ...evaluatorReferences,
+    ...params.assertionTemplateReferences
+  ]);
+  return {
+    evalFilePath: params.evalFilePath,
+    evalFileAbsolutePath: params.absoluteTestPath,
+    ...evalFileRepoPath ? { evalFileRepoPath } : {},
+    testId: params.id,
+    testSnapshotYaml,
+    graderDefinitions: buildGraderSourceDefinitions(params.evaluators),
+    references
+  };
+}
+function stringifySourceYaml(value) {
+  return stringifyYaml(sanitizeSourceValue(value), { lineWidth: 0 }).trimEnd();
+}
+function sanitizeSourceValue(value, keyHint) {
+  if (keyHint && SOURCE_SECRET_KEY_PATTERN.test(keyHint)) {
+    return REDACTED_SOURCE_VALUE;
+  }
+  if (value === null || typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeSourceValue(item));
+  }
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.entries(value).map(([key, entryValue]) => [
+      key,
+      sanitizeSourceValue(entryValue, key)
+    ]);
+    return Object.fromEntries(entries);
+  }
+  return String(value);
+}
+function buildGraderSourceDefinitions(evaluators) {
+  return (evaluators ?? []).map((evaluator) => ({
+    name: evaluator.name,
+    type: evaluator.type,
+    ...evaluator.weight !== void 0 ? { weight: evaluator.weight } : {},
+    ...evaluator.required !== void 0 ? { required: evaluator.required } : {},
+    ..."min_score" in evaluator && evaluator.min_score !== void 0 ? { minScore: evaluator.min_score } : {},
+    definition: sanitizeGraderDefinition(evaluator)
+  }));
+}
+function sanitizeGraderDefinition(evaluator) {
+  const copy = sanitizeSourceValue(evaluator);
+  return stripRuntimeResolutionFields(copy);
+}
+function stripRuntimeResolutionFields(value) {
+  const stripped = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key === "resolvedPromptPath" || key === "promptPath" || key === "resolvedPromptScript" || key === "resolvedScriptPath" || key === "resolvedCwd" || key === "resolvedCommand") {
+      continue;
+    }
+    if (Array.isArray(entryValue)) {
+      stripped[key] = entryValue.map(
+        (item) => isJsonObject(item) ? stripRuntimeResolutionFields(item) : item
+      );
+    } else if (isJsonObject(entryValue)) {
+      stripped[key] = stripRuntimeResolutionFields(entryValue);
+    } else {
+      stripped[key] = entryValue;
+    }
+  }
+  return stripped;
+}
+function collectInputSourceReferences(inputMessages) {
+  const references = [];
+  for (const message of inputMessages) {
+    if (!Array.isArray(message.content)) {
+      continue;
+    }
+    for (const segment of message.content) {
+      if (!isJsonObject(segment) || segment.type !== "file") {
+        continue;
+      }
+      const displayPath = typeof segment.path === "string" ? segment.path : typeof segment.value === "string" ? segment.value : "input file";
+      references.push({
+        kind: "input_file",
+        displayPath,
+        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path43.resolve(segment.resolvedPath) } : {}
+      });
+    }
+  }
+  return references;
+}
+function collectGraderSourceReferences(evaluators) {
+  const references = [];
+  for (const evaluator of evaluators ?? []) {
+    references.push(...collectSingleGraderSourceReferences(evaluator));
+  }
+  return references;
+}
+function collectSingleGraderSourceReferences(evaluator) {
+  const references = [];
+  if (evaluator.type === "code-grader") {
+    const command = evaluator.command ?? evaluator.script ?? [];
+    references.push({
+      kind: "code_grader_command",
+      displayPath: evaluator.resolvedScriptPath ?? command.join(" "),
+      ...evaluator.resolvedScriptPath ? { resolvedPath: evaluator.resolvedScriptPath } : {},
+      graderName: evaluator.name,
+      command
+    });
+    if (evaluator.resolvedCwd) {
+      references.push({
+        kind: "code_grader_cwd",
+        displayPath: evaluator.cwd ?? evaluator.resolvedCwd,
+        resolvedPath: evaluator.resolvedCwd,
+        graderName: evaluator.name
+      });
+    }
+  }
+  if (evaluator.type === "llm-grader") {
+    const promptPath = evaluator.resolvedPromptPath ?? evaluator.promptPath;
+    if (promptPath) {
+      references.push({
+        kind: "llm_grader_prompt",
+        displayPath: typeof evaluator.prompt === "string" ? evaluator.prompt : promptPath,
+        resolvedPath: promptPath,
+        graderName: evaluator.name
+      });
+    }
+    if (evaluator.resolvedPromptScript && evaluator.resolvedPromptScript.length > 0) {
+      references.push({
+        kind: "prompt_script",
+        displayPath: evaluator.resolvedPromptScript.at(-1) ?? evaluator.name,
+        resolvedPath: evaluator.resolvedPromptScript.at(-1),
+        graderName: evaluator.name,
+        command: evaluator.resolvedPromptScript
+      });
+    }
+  }
+  const preprocessors = "preprocessors" in evaluator ? evaluator.preprocessors : void 0;
+  for (const preprocessor of preprocessors ?? []) {
+    if (preprocessor.resolvedCommand && preprocessor.resolvedCommand.length > 0) {
+      references.push({
+        kind: "preprocessor_command",
+        displayPath: preprocessor.resolvedCommand.at(-1) ?? preprocessor.type,
+        resolvedPath: preprocessor.resolvedCommand.at(-1),
+        graderName: evaluator.name,
+        command: preprocessor.resolvedCommand
+      });
+    }
+  }
+  if (evaluator.type === "composite") {
+    for (const member of evaluator.assertions) {
+      references.push(...collectSingleGraderSourceReferences(member));
+    }
+    if (evaluator.aggregator.type === "code-grader") {
+      references.push({
+        kind: "code_grader_command",
+        displayPath: evaluator.aggregator.path,
+        resolvedPath: path43.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
+        graderName: evaluator.name
+      });
+    } else if (evaluator.aggregator.type === "llm-grader" && evaluator.aggregator.promptPath) {
+      references.push({
+        kind: "llm_grader_prompt",
+        displayPath: evaluator.aggregator.prompt ?? evaluator.aggregator.promptPath,
+        resolvedPath: evaluator.aggregator.promptPath,
+        graderName: evaluator.name
+      });
+    }
+  }
+  return references;
+}
+function dedupeSourceReferences(references) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const reference of references) {
+    const key = JSON.stringify([
+      reference.kind,
+      reference.resolvedPath ?? reference.displayPath,
+      reference.graderName ?? "",
+      reference.command?.join("\0") ?? ""
+    ]);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(reference);
+  }
+  return deduped;
+}
+function toPortableRelativePath(root, candidate) {
+  const relative = path43.relative(root, candidate);
+  if (relative && !relative.startsWith("..") && !path43.isAbsolute(relative)) {
+    return relative.split(path43.sep).join("/");
+  }
+  return void 0;
+}
 async function loadTestById(evalFilePath, repoRoot, evalId) {
   const tests = await loadTests(evalFilePath, repoRoot);
   const match = tests.find((c) => c.id === evalId);
@@ -16102,7 +17079,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
     const workspaceFilePath = path43.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await readFile15(workspaceFilePath, "utf8");
+      content = await readFile16(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
@@ -16226,19 +17203,18 @@ function mergeWorkspaceConfigs(suiteLevel, caseLevel) {
 function asString5(value) {
   return typeof value === "string" ? value : void 0;
 }
-function extractSuiteGovernance(suite) {
+function extractSuiteMetadataPayload(suite) {
+  const payload = isJsonObject(suite.metadata) ? { ...suite.metadata } : {};
   const top = suite.governance;
   if (isJsonObject(top)) {
-    return top;
-  }
-  const wrapper = suite.metadata;
-  if (isJsonObject(wrapper)) {
-    const nested = wrapper.governance;
+    payload.governance = top;
+  } else {
+    const nested = payload.governance;
     if (isJsonObject(nested)) {
-      return nested;
+      payload.governance = nested;
     }
   }
-  return void 0;
+  return Object.keys(payload).length > 0 ? payload : void 0;
 }
 function mergeSuiteMetadataPayload(caseMetadata, suitePayload) {
   if (!suitePayload) return caseMetadata;
@@ -16729,7 +17705,7 @@ async function runEvaluation(options) {
     const isEmpty = dirExists ? (await readdir8(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await mkdir14(configuredStaticPath, { recursive: true });
+        await mkdir15(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -16774,7 +17750,7 @@ async function runEvaluation(options) {
     }
   } else if (!isPerTestIsolation && (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length)) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await mkdir14(sharedWorkspacePath, { recursive: true });
+    await mkdir15(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
@@ -17624,7 +18600,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await mkdir14(workspacePath, { recursive: true });
+      await mkdir15(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
@@ -17679,7 +18655,7 @@ async function runEvalCase(options) {
           const srcPath = path44.resolve(baseDir, relPath);
           const destPath = path44.resolve(workspacePath, relPath);
           try {
-            await mkdir14(path44.dirname(destPath), { recursive: true });
+            await mkdir15(path44.dirname(destPath), { recursive: true });
             await copyFile2(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -19247,6 +20223,12 @@ async function evaluate(config) {
     resolvedTarget = resolveTargetDefinition(targetDef);
   }
   const collectedResults = [];
+  const cacheEnabled = shouldEnableCache({
+    cliCache: config.cache === true,
+    cliNoCache: false,
+    yamlCache: config.cache === void 0 ? materialized.cache : void 0
+  });
+  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path45.resolve(materialized.cachePath) : void 0) : void 0;
   const results = await runEvaluation({
     testFilePath,
     repoRoot,
@@ -19259,6 +20241,8 @@ async function evaluate(config) {
     filter: config.filter,
     threshold: config.threshold,
     evalCases: materialized.tests,
+    cache,
+    useCache: !!cache && !shouldSkipCacheForTemperature(resolvedTarget.config),
     ...materialized.budgetUsd !== void 0 && { budgetUsd: materialized.budgetUsd },
     onResult: async (result) => {
       collectedResults.push(result);
@@ -19289,6 +20273,7 @@ async function materializeEvalConfig(config, options) {
       tests: tests2,
       workers: config.workers ?? suite.workers,
       cache: config.cache ?? suite.cacheConfig?.enabled,
+      cachePath: config.cachePath ?? suite.cacheConfig?.cachePath,
       budgetUsd: config.budgetUsd ?? suite.budgetUsd,
       threshold: config.threshold ?? suite.threshold,
       metadata: config.metadata ?? suite.metadata,
@@ -19307,6 +20292,7 @@ async function materializeEvalConfig(config, options) {
     tests,
     workers: config.workers,
     cache: config.cache,
+    cachePath: config.cachePath,
     budgetUsd: config.budgetUsd,
     threshold: config.threshold,
     metadata: config.metadata,
@@ -19424,9 +20410,11 @@ function mapAssertionType(type) {
 }
 function computeSummary(results, durationMs, threshold = DEFAULT_THRESHOLD) {
   const total = results.length;
+  const qualityResults = results.filter((r) => r.executionStatus !== "execution_error");
+  const executionErrors = total - qualityResults.length;
   let passed = 0;
   let scoreSum = 0;
-  for (const r of results) {
+  for (const r of qualityResults) {
     scoreSum += r.score;
     if (r.score >= threshold) {
       passed++;
@@ -19435,9 +20423,10 @@ function computeSummary(results, durationMs, threshold = DEFAULT_THRESHOLD) {
   return {
     total,
     passed,
-    failed: total - passed,
+    failed: qualityResults.length - passed,
+    executionErrors,
     durationMs,
-    meanScore: total > 0 ? scoreSum / total : 0
+    meanScore: qualityResults.length > 0 ? scoreSum / qualityResults.length : 0
   };
 }
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
@@ -19520,7 +20509,12 @@ async function loadTsEvalSuite(filePath, repoRoot, options) {
   return {
     tests: materialized.tests,
     ...materialized.workers !== void 0 && { workers: materialized.workers },
-    ...materialized.cache !== void 0 && { cacheConfig: { enabled: materialized.cache } },
+    ...materialized.cache !== void 0 && {
+      cacheConfig: {
+        enabled: materialized.cache,
+        ...materialized.cachePath !== void 0 && { cachePath: materialized.cachePath }
+      }
+    },
     ...materialized.budgetUsd !== void 0 && { budgetUsd: materialized.budgetUsd },
     ...materialized.threshold !== void 0 && { threshold: materialized.threshold },
     ...materialized.metadata !== void 0 && { metadata: materialized.metadata },
@@ -19543,7 +20537,28 @@ function isEvalConfigLike(value) {
 }
 
 export {
+  NORMALIZED_TRAJECTORY_SCHEMA_VERSION,
+  NORMALIZED_TRACE_SOURCE_KINDS,
+  NORMALIZED_TRACE_EVENT_TYPES,
+  NORMALIZED_TOOL_STATUSES,
+  NORMALIZED_REDACTION_LEVELS,
+  NormalizedRedactionStateWireSchema,
+  NormalizedTraceErrorWireSchema,
+  NormalizedTraceSourceWireSchema,
+  NormalizedTraceSessionWireSchema,
+  NormalizedTraceBranchWireSchema,
+  NormalizedTraceSourceRefWireSchema,
+  NormalizedRawEvidenceWireSchema,
+  NormalizedTraceMessageWireSchema,
+  NormalizedTraceModelWireSchema,
+  NormalizedTraceToolWireSchema,
+  NormalizedTraceEventWireSchema,
+  NormalizedTrajectoryWireSchema,
+  toNormalizedTrajectoryWire,
+  fromNormalizedTrajectoryWire,
   computeTraceSummary,
+  getSelectedTrajectoryEvents,
+  computeTraceSummaryFromTrajectory,
   DEFAULT_EXPLORATION_TOOLS,
   explorationRatio,
   tokensPerTool,
@@ -19551,13 +20566,6 @@ export {
   mergeExecutionMetrics,
   isAgentSkillsFormat,
   parseAgentSkillsEvals,
-  getAgentvConfigDir,
-  getAgentvHome,
-  getAgentvDataDir,
-  getWorkspacesRoot,
-  getSubagentsRoot,
-  getTraceStateRoot,
-  getWorkspacePoolRoot,
   DEFAULT_EVAL_PATTERNS,
   loadConfig,
   extractTargetFromSuite,
@@ -19569,11 +20577,15 @@ export {
   extractCacheConfig,
   extractFailOnError,
   extractThreshold,
+  resolveResultsConfigForProject,
   detectFormat,
   parseRepoSource,
   parseRepoCheckout,
   parseRepoClone,
   buildPromptInputs,
+  ResponseCache,
+  shouldEnableCache,
+  shouldSkipCacheForTemperature,
   DEFAULT_THRESHOLD,
   PASS_THRESHOLD,
   scoreToVerdict,
@@ -19676,4 +20688,4 @@ export {
   loadTestById,
   loadEvalCaseById
 };
-//# sourceMappingURL=chunk-N5EU446L.js.map
+//# sourceMappingURL=chunk-7QB53OPK.js.map