agentv 4.38.1 → 4.40.1-next.1

package/dist/{chunk-VBHHZQS6.js → chunk-BLXYBUU4.js}

@@ -493,8 +493,8 @@ function getErrorMap() {
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path49, errorMaps, issueData } = params;
-  const fullPath = [...path49, ...issueData.path || []];
+  const { data, path: path50, errorMaps, issueData } = params;
+  const fullPath = [...path50, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -610,11 +610,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path49, key) {
+  constructor(parent, value, path50, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path49;
+    this._path = path50;
     this._key = key;
   }
   get path() {
@@ -4056,7 +4056,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-M54RBDXI.js
+// ../../packages/core/dist/chunk-5JNFEE7J.js
 import { parse } from "yaml";
 import os from "node:os";
 import path from "node:path";
@@ -5146,6 +5146,7 @@ function resolveStreamLog(target, envFallback) {
 function resolveCopilotSdkConfig(target, env, _evalFilePath) {
   const cliUrlSource = target.cli_url;
   const cliPathSource = target.cli_path;
+  const argsSource = target.args ?? target.arguments;
   const githubTokenSource = target.github_token;
   const modelSource = target.model;
   const cwdSource = target.cwd;
@@ -5166,6 +5167,7 @@ function resolveCopilotSdkConfig(target, env, _evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
+  const args = resolveOptionalStringArray(argsSource, env, `${target.name} copilot-sdk args`);
   const githubToken = resolveOptionalString(
     githubTokenSource,
     env,
@@ -5195,12 +5197,11 @@ function resolveCopilotSdkConfig(target, env, _evalFilePath) {
   );
   const logFormat = normalizeCopilotLogFormat(logFormatSource);
   const systemPrompt = typeof systemPromptSource === "string" && systemPromptSource.trim().length > 0 ? systemPromptSource.trim() : void 0;
-  const customProvider = resolveCopilotCustomProviderConfig(target, env, {
-    includeByokAlias: true
-  });
+  const customProvider = resolveCopilotFlatProviderConfig(target, env);
   return {
     cliUrl,
     cliPath,
+    args,
     githubToken,
     model,
     cwd,
@@ -5209,86 +5210,52 @@ function resolveCopilotSdkConfig(target, env, _evalFilePath) {
     logFormat,
     streamLog: streamLogResult.streamLog,
     systemPrompt,
-    ...customProvider ? {
-      customProvider,
-      byokType: customProvider.type,
-      byokBaseUrl: customProvider.baseUrl,
-      byokApiKey: customProvider.apiKey,
-      byokBearerToken: customProvider.bearerToken,
-      byokApiVersion: customProvider.apiVersion,
-      byokWireApi: customProvider.wireApi
-    } : {}
-  };
-}
-function resolveCopilotCustomProviderConfig(target, env, options = {}) {
-  const hasCustomProvider = target.custom_provider !== void 0;
-  const hasByokAlias = options.includeByokAlias === true && target.byok !== void 0;
-  if (!hasCustomProvider && !hasByokAlias) {
-    return void 0;
-  }
-  const sourceName = hasCustomProvider ? "custom_provider" : "byok";
-  const raw = sourceName === "custom_provider" ? target.custom_provider : target.byok;
-  if (raw === null) {
-    return void 0;
-  }
-  if (typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${target.name}: '${sourceName}' must be an object`);
-  }
-  const provider = raw;
-  const type = resolveOptionalString(provider.type, env, `${target.name} ${sourceName} type`, {
+    ...customProvider ? { customProvider } : {}
+  };
+}
+function resolveCopilotFlatProviderConfig(target, env) {
+  const baseUrlSource = target.base_url;
+  if (!baseUrlSource) return void 0;
+  const baseUrl = resolveOptionalString(baseUrlSource, env, `${target.name} copilot base URL`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const baseUrl = resolveOptionalString(
-    provider.base_url,
+  if (!baseUrl) return void 0;
+  const type = resolveOptionalString(
+    target.subprovider,
     env,
-    `${target.name} ${sourceName} base URL`,
+    `${target.name} copilot provider type`,
     {
       allowLiteral: true,
       optionalEnv: true
     }
   );
-  const apiKey = resolveOptionalString(
-    provider.api_key,
-    env,
-    `${target.name} ${sourceName} API key`,
-    {
-      allowLiteral: false,
-      optionalEnv: true
-    }
-  );
+  const apiKey = resolveOptionalString(target.api_key, env, `${target.name} copilot API key`, {
+    allowLiteral: false,
+    optionalEnv: true
+  });
   const bearerToken = resolveOptionalString(
-    provider.bearer_token,
+    target.bearer_token,
     env,
-    `${target.name} ${sourceName} bearer token`,
+    `${target.name} copilot bearer token`,
     {
       allowLiteral: false,
       optionalEnv: true
     }
   );
   const apiVersion = resolveOptionalString(
-    provider.api_version,
+    target.api_version,
     env,
-    `${target.name} ${sourceName} API version`,
+    `${target.name} copilot API version`,
     {
       allowLiteral: true,
       optionalEnv: true
     }
   );
-  const wireApi = resolveOptionalString(
-    provider.wire_api,
-    env,
-    `${target.name} ${sourceName} wire API`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (!baseUrl) {
-    throw new Error(
-      `${target.name}: '${sourceName}.base_url' is required when '${sourceName}' is specified`
-    );
-  }
+  const wireApi = resolveOptionalString(target.wire_api, env, `${target.name} copilot wire API`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
   return {
     ...type ? { type } : {},
     baseUrl,
@@ -5337,7 +5304,7 @@ function resolveCopilotCliConfig(target, env, _evalFilePath) {
   );
   const logFormat = normalizeCopilotLogFormat(logFormatSource);
   const systemPrompt = typeof systemPromptSource === "string" && systemPromptSource.trim().length > 0 ? systemPromptSource.trim() : void 0;
-  const customProvider = resolveCopilotCustomProviderConfig(target, env);
+  const customProvider = resolveCopilotFlatProviderConfig(target, env);
   return {
     executable,
     model,
@@ -5600,22 +5567,22 @@ function resolveReplayConfig(target, env, evalFilePath) {
   const fixtures = resolveOptionalString(target.fixtures, env, `${target.name} replay fixtures`, {
     allowLiteral: true
   });
-  const traceEnvelopes = resolveOptionalString(
-    target.trace_envelopes,
+  const executionTraces = resolveOptionalString(
+    target.execution_traces,
     env,
-    `${target.name} replay trace_envelopes`,
+    `${target.name} replay execution_traces`,
     {
       allowLiteral: true
     }
   );
-  if ((fixtures ? 1 : 0) + (traceEnvelopes ? 1 : 0) !== 1) {
+  if ((fixtures ? 1 : 0) + (executionTraces ? 1 : 0) !== 1) {
     throw new Error(
-      `Target "${target.name}" (provider: replay) requires exactly one replay source: "fixtures" or "trace_envelopes"`
+      `Target "${target.name}" (provider: replay) requires exactly one replay source: "fixtures" or "execution_traces"`
     );
   }
   const fixturesPath = fixtures ? resolveReplaySourcePath(fixtures, evalFilePath) : void 0;
-  const traceEnvelopesPath = traceEnvelopes ? resolveReplaySourcePath(traceEnvelopes, evalFilePath) : void 0;
-  const source = fixturesPath ? { kind: "fixtures", path: fixturesPath } : { kind: "trace_envelopes", path: traceEnvelopesPath };
+  const executionTracesPath = executionTraces ? resolveReplaySourcePath(executionTraces, evalFilePath) : void 0;
+  const source = fixturesPath ? { kind: "fixtures", path: fixturesPath } : { kind: "execution_traces", path: executionTracesPath };
   const sourceTarget = resolveString(
     target.source_target,
     env,
@@ -6184,11 +6151,11 @@ async function expandFileReferences(tests, evalFileDir) {
   return expanded;
 }
 
-// ../../packages/core/dist/chunk-RH5LAMMU.js
-import path48 from "node:path";
+// ../../packages/core/dist/chunk-M6LF2BEU.js
+import path49 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { existsSync as existsSync7 } from "node:fs";
-import path47 from "node:path";
+import path48 from "node:path";
 import micromatch4 from "micromatch";
 import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
 import path5 from "node:path";
@@ -6916,10 +6883,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path49) {
-  if (!path49)
+function getElementAtPath(obj, path50) {
+  if (!path50)
     return obj;
-  return path49.reduce((acc, key) => acc?.[key], obj);
+  return path50.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7239,11 +7206,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path49, issues) {
+function prefixIssues(path50, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path49);
+    iss.path.unshift(path50);
     return iss;
   });
 }
@@ -7380,7 +7347,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path49 = []) => {
+  const processError = (error41, path50 = []) => {
     var _a, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -7390,7 +7357,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path49, ...issue2.path];
+        const fullpath = [...path50, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7420,9 +7387,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path49) {
+function toDotPath(path50) {
   const segs = [];
-  for (const seg of path49) {
+  for (const seg of path50) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18852,7 +18819,7 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../packages/core/dist/chunk-RH5LAMMU.js
+// ../../packages/core/dist/chunk-M6LF2BEU.js
 import { exec as execCallback } from "node:child_process";
 import { readdirSync, statSync } from "node:fs";
 import { readFile as readFile32, readdir as readdir2, stat as stat2 } from "node:fs/promises";
@@ -18962,6 +18929,9 @@ import path44 from "node:path";
 import micromatch from "micromatch";
 import { readFile as readFile16 } from "node:fs/promises";
 import path43 from "node:path";
+import { mkdir as mkdir18, readFile as readFile20, writeFile as writeFile10 } from "node:fs/promises";
+import path47 from "node:path";
+import { readFile as readFile19 } from "node:fs/promises";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -19602,7 +19572,6 @@ var CodeGrader = class {
         getImageDir
       ),
       output: outputForPayload,
-      answer: context.candidate,
       messages: materializedMessages ?? [],
       outputPath,
       inputFiles: context.evalCase.file_paths,
@@ -19950,24 +19919,13 @@ var TEMPLATE_VARIABLES = {
   INPUT: "input",
   OUTPUT: "output",
   FILE_CHANGES: "file_changes",
-  TOOL_CALLS: "tool_calls",
-  /** @deprecated Use INPUT instead — resolves to the same text value. */
-  INPUT_TEXT: "input_text",
-  /** @deprecated Use OUTPUT instead — resolves to the same text value. */
-  OUTPUT_TEXT: "output_text",
-  /** @deprecated Use EXPECTED_OUTPUT instead — resolves to the same text value. */
-  EXPECTED_OUTPUT_TEXT: "expected_output_text"
+  TOOL_CALLS: "tool_calls"
 };
 var VALID_TEMPLATE_VARIABLES = new Set(Object.values(TEMPLATE_VARIABLES));
 var REQUIRED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Set([
   TEMPLATE_VARIABLES.OUTPUT,
   TEMPLATE_VARIABLES.EXPECTED_OUTPUT
 ]);
-var DEPRECATED_TEMPLATE_VARIABLES = /* @__PURE__ */ new Map([
-  [TEMPLATE_VARIABLES.INPUT_TEXT, TEMPLATE_VARIABLES.INPUT],
-  [TEMPLATE_VARIABLES.OUTPUT_TEXT, TEMPLATE_VARIABLES.OUTPUT],
-  [TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT, TEMPLATE_VARIABLES.EXPECTED_OUTPUT]
-]);
 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."
@@ -20087,11 +20045,7 @@ function buildTemplateVariables(context) {
     [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()
+    [TEMPLATE_VARIABLES.TOOL_CALLS]: context.toolCalls ?? ""
   };
 }
 function resolveContentBasePath(context) {
@@ -20168,7 +20122,6 @@ var LlmGrader = class {
     const variables = buildTemplateVariables(context);
     const systemPrompt = buildOutputSchema();
     const graderTemplate = context.graderTemplateOverride ?? this.graderTemplate ?? DEFAULT_GRADER_TEMPLATE;
-    warnDeprecatedTemplateVars(graderTemplate);
     let userPrompt = substituteVariables(graderTemplate, variables);
     if (context.fileChanges && !context.graderTemplateOverride && !this.graderTemplate) {
       userPrompt += `
@@ -20499,7 +20452,6 @@ ${context.toolCalls}`;
     const variables = buildTemplateVariables(context);
     const template = context.graderTemplateOverride ?? this.graderTemplate;
     if (template) {
-      warnDeprecatedTemplateVars(template);
       return substituteVariables(template, variables);
     }
     const config2 = context.evaluator;
@@ -20553,7 +20505,6 @@ ${context.toolCalls}`;
     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}
@@ -20707,7 +20658,6 @@ ${outputSchema}`;
   }
   buildCustomPrompt(context) {
     const template = context.graderTemplateOverride ?? this.graderTemplate ?? "";
-    warnDeprecatedTemplateVars(template);
     return substituteVariables(template, buildTemplateVariables(context));
   }
   buildRubricPrompt(context, rubrics) {
@@ -20890,26 +20840,6 @@ function substituteVariables(template, variables) {
     return variables[varName] ?? match;
   });
 }
-var ANSI_YELLOW2 = "\x1B[33m";
-var ANSI_RESET2 = "\x1B[0m";
-var warnedTemplateStrings = /* @__PURE__ */ new Set();
-function warnDeprecatedTemplateVars(template) {
-  if (warnedTemplateStrings.has(template)) return;
-  const used = [];
-  for (const [deprecated, replacement] of DEPRECATED_TEMPLATE_VARIABLES) {
-    if (new RegExp(`\\{\\{\\s*${deprecated}\\s*\\}\\}`).test(template)) {
-      used.push(`{{ ${deprecated} }} \u2192 {{ ${replacement} }}`);
-    }
-  }
-  if (used.length > 0) {
-    warnedTemplateStrings.add(template);
-    console.warn(
-      `${ANSI_YELLOW2}\u26A0 Deprecated template variables detected (they still work but will be removed in a future version):
-  ${used.join("\n  ")}
-  Update your custom grader template to use the new names.${ANSI_RESET2}`
-    );
-  }
-}
 function calculateRubricScore(result, rubrics) {
   const rubricMap = new Map(rubrics.map((rubric) => [rubric.id, rubric]));
   const assertions = [];
@@ -21473,7 +21403,7 @@ var CostGrader = class {
     };
   }
 };
-var NORMALIZED_TRAJECTORY_SCHEMA_VERSION = "agentv.trace.v1";
+var NORMALIZED_TRAJECTORY_SCHEMA_VERSION = "agentv.trajectory.v1";
 var NORMALIZED_TRACE_SOURCE_KINDS = [
   "agentv_run",
   "otlp",
@@ -22532,115 +22462,115 @@ var FieldAccuracyGrader = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path49, match, required: required2 = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path49);
-    const expectedValue = resolvePath(expectedData, path49);
+    const { path: path50, match, required: required2 = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path50);
+    const expectedValue = resolvePath(expectedData, path50);
     if (expectedValue === void 0) {
       return {
-        path: path49,
+        path: path50,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path49}: no expected value`
+        message: `${path50}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required2) {
         return {
-          path: path49,
+          path: path50,
           score: 0,
           weight,
           hit: false,
-          message: `${path49} (required, missing)`
+          message: `${path50} (required, missing)`
         };
       }
       return {
-        path: path49,
+        path: path50,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path49}: optional field missing`
+        message: `${path50}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path49, candidateValue, expectedValue, weight);
+        return this.compareExact(path50, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path49,
+          path50,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path49, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path50, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path49,
+          path: path50,
           score: 0,
           weight,
           hit: false,
-          message: `${path49}: unknown match type "${match}"`
+          message: `${path50}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path49, candidateValue, expectedValue, weight) {
+  compareExact(path50, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path49,
+        path: path50,
         score: 1,
         weight,
         hit: true,
-        message: path49
+        message: path50
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path49,
+        path: path50,
         score: 0,
         weight,
         hit: false,
-        message: `${path49} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path50} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path49,
+      path: path50,
       score: 0,
       weight,
       hit: false,
-      message: `${path49} (value mismatch)`
+      message: `${path50} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path49, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path50, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path49,
+        path: path50,
         score: 0,
         weight,
         hit: false,
-        message: `${path49} (non-numeric value)`
+        message: `${path50} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path49,
+        path: path50,
         score: 0,
         weight,
         hit: false,
-        message: `${path49} (invalid numeric value)`
+        message: `${path50} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -22653,61 +22583,61 @@ var FieldAccuracyGrader = class {
     }
     if (withinTolerance) {
       return {
-        path: path49,
+        path: path50,
         score: 1,
         weight,
         hit: true,
-        message: `${path49} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path50} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path49,
+      path: path50,
       score: 0,
       weight,
       hit: false,
-      message: `${path49} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path50} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path49, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path50, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path49,
+        path: path50,
         score: 0,
         weight,
         hit: false,
-        message: `${path49} (unparseable candidate date)`
+        message: `${path50} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path49,
+        path: path50,
         score: 0,
         weight,
         hit: false,
-        message: `${path49} (unparseable expected date)`
+        message: `${path50} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path49,
+        path: path50,
         score: 1,
         weight,
         hit: true,
-        message: path49
+        message: path50
       };
     }
     return {
-      path: path49,
+      path: path50,
       score: 0,
       weight,
       hit: false,
-      message: `${path49} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path50} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -22740,11 +22670,11 @@ var FieldAccuracyGrader = class {
     };
   }
 };
-function resolvePath(obj, path49) {
-  if (!path49 || !obj) {
+function resolvePath(obj, path50) {
+  if (!path50 || !obj) {
     return void 0;
   }
-  const parts = path49.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path50.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -22999,10 +22929,7 @@ function buildTemplateVariables2(input) {
     [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()
+    [TEMPLATE_VARIABLES.TOOL_CALLS]: input.toolCalls ?? ""
   };
 }
 function assembleLlmGraderPrompt(input) {
@@ -23278,8 +23205,8 @@ var TokenUsageGrader = class {
     };
   }
 };
-function getNestedValue(obj, path49) {
-  const parts = path49.split(".");
+function getNestedValue(obj, path50) {
+  const parts = path50.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -26420,11 +26347,13 @@ var CopilotCliProvider = class {
   supportsBatch = false;
   config;
   runPromptMode;
-  constructor(targetName, config2, promptRunner = defaultCopilotCliPromptRunner) {
+  spawnAcpProcess;
+  constructor(targetName, config2, promptRunner = defaultCopilotCliPromptRunner, spawnAcpProcess = spawn2) {
     this.id = `copilot-cli:${targetName}`;
     this.targetName = targetName;
     this.config = config2;
     this.runPromptMode = promptRunner;
+    this.spawnAcpProcess = spawnAcpProcess;
   }
   async invoke(request) {
     if (request.signal?.aborted) {
@@ -26432,14 +26361,12 @@ var CopilotCliProvider = class {
     }
     const startTime = (/* @__PURE__ */ new Date()).toISOString();
     const startMs = Date.now();
-    if (this.config.customProvider) {
-      return await this.invokePromptMode(request, startTime, startMs);
-    }
     const logger = await this.createStreamLogger(request, "acp").catch(() => void 0);
     const executable = this.resolveExecutable();
     const args = this.buildCliArgs();
-    const agentProcess = spawn2(executable, args, {
+    const agentProcess = this.spawnAcpProcess(executable, args, {
       env: buildCopilotCliProviderEnv(process.env, this.config.customProvider),
+      cwd: this.resolveCwd(request.cwd) ?? process.cwd(),
       stdio: ["pipe", "pipe", "inherit"]
     });
     trackChild(agentProcess);
@@ -26455,6 +26382,7 @@ var CopilotCliProvider = class {
     const input = Writable.toWeb(agentProcess.stdin);
     const output = Readable.toWeb(agentProcess.stdout);
     const stream = ndJsonStream(input, output);
+    const customProvider = this.config.customProvider;
     const client = {
       async requestPermission() {
         return {
@@ -26464,7 +26392,7 @@ var CopilotCliProvider = class {
       async sessionUpdate(params) {
         const update = params.update;
         const sessionUpdate = update.sessionUpdate;
-        logger?.handleEvent(sessionUpdate, update);
+        logger?.handleEvent(sessionUpdate, sanitizeSensitiveValue(update, customProvider));
         if (sessionUpdate === "tool_call") {
           const callId = update.toolCallId ?? randomUUID5();
           if (!update.status || update.status === "pending" || update.status === "in_progress") {
@@ -26956,6 +26884,26 @@ function sanitizeSensitiveText(text, customProvider) {
   }
   return sanitized;
 }
+function sanitizeSensitiveValue(value, customProvider) {
+  if (!customProvider) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return sanitizeSensitiveText(value, customProvider);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizeSensitiveValue(item, customProvider));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        sanitizeSensitiveValue(entry, customProvider)
+      ])
+    );
+  }
+  return value;
+}
 async function defaultCopilotCliPromptRunner(options) {
   return await new Promise((resolve, reject) => {
     const child = spawn2(options.executable, options.args, {
@@ -27322,12 +27270,14 @@ async function loadCopilotSdk() {
       const message = error40 instanceof Error ? error40.message : String(error40);
       if (message.includes("vscode-jsonrpc")) {
         throw new Error(
-          `Failed to load @github/copilot-sdk due to a known ESM compatibility issue with vscode-jsonrpc (https://github.com/github/copilot-sdk/issues/710).
+          `@github/copilot-sdk failed to load: vscode-jsonrpc ESM import specifier mismatch.
+The package imports 'vscode-jsonrpc/node' but the installed version exposes 'node.js'.
 
-Workarounds:
-  - Use the copilot-cli target instead (recommended): set target type to "copilot-cli" in your eval YAML
-  - If running under Node.js 24+: set NODE_OPTIONS="--experimental-specifier-resolution=node"
-  - Wait for vscode-jsonrpc@9.0.0 stable to be released upstream`
+Repair (run once in your project root):
+  node -e "const p=require.resolve('vscode-jsonrpc/package.json').replace('/package.json',''); require('fs').symlinkSync(p+'/node.js',p+'/node','file')" 2>/dev/null || true
+
+Or switch to the copilot-cli target (no SDK dependency):
+  Set provider: copilot-cli in your eval YAML`
         );
       }
       throw new Error(
@@ -27358,7 +27308,8 @@ var CopilotSdkProvider = class {
       throw new Error("Copilot SDK request was aborted before execution");
     }
     const sdk = await loadCopilotSdk();
-    const client = await this.getOrCreateClient(sdk);
+    const evalCwd = this.resolveCwd(request.cwd);
+    const client = await this.getOrCreateClient(sdk, evalCwd ?? void 0);
     const startTime = (/* @__PURE__ */ new Date()).toISOString();
     const startMs = Date.now();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
@@ -27368,10 +27319,9 @@ var CopilotSdkProvider = class {
     if (this.config.model) {
       sessionOptions.model = this.config.model;
     }
-    const cwd = this.resolveCwd(request.cwd);
-    if (cwd) {
-      sessionOptions.workingDirectory = cwd;
-      sessionOptions.skillDirectories = resolveSkillDirectories(cwd);
+    if (evalCwd) {
+      sessionOptions.workingDirectory = evalCwd;
+      sessionOptions.skillDirectories = resolveSkillDirectories(evalCwd);
     }
     const systemPrompt = this.config.systemPrompt;
     if (systemPrompt) {
@@ -27380,12 +27330,12 @@ var CopilotSdkProvider = class {
         content: systemPrompt
       };
     }
-    const customProvider = resolveCustomProviderConfig(this.config);
+    const customProvider = this.config.customProvider;
     if (customProvider) {
       const providerType = customProvider.type ?? "openai";
       const provider = {
         type: providerType,
-        baseUrl: normalizeByokBaseUrl(customProvider.baseUrl, providerType)
+        baseUrl: normalizeProviderBaseUrl(customProvider.baseUrl, providerType)
       };
       if (customProvider.bearerToken) {
         provider.bearerToken = customProvider.bearerToken;
@@ -27532,7 +27482,7 @@ var CopilotSdkProvider = class {
     }
   }
   // biome-ignore lint/suspicious/noExplicitAny: SDK client type is dynamically loaded
-  async getOrCreateClient(sdk) {
+  async getOrCreateClient(sdk, evalCwd) {
     if (!this.client) {
       const clientOptions = {};
       if (this.config.cliUrl) {
@@ -27546,6 +27496,11 @@ var CopilotSdkProvider = class {
           clientOptions.cliPath = nativePath;
         }
       }
+      const resolvedCwd = evalCwd ?? process.cwd();
+      clientOptions.cwd = resolvedCwd;
+      if (this.config.args && this.config.args.length > 0) {
+        clientOptions.cliArgs = [...this.config.args];
+      }
       if (this.config.githubToken) {
         clientOptions.githubToken = this.config.githubToken;
       }
@@ -27629,22 +27584,6 @@ var CopilotSdkProvider = class {
     }
   }
 };
-function resolveCustomProviderConfig(config2) {
-  if (config2.customProvider) {
-    return config2.customProvider;
-  }
-  if (!config2.byokBaseUrl) {
-    return void 0;
-  }
-  return {
-    ...config2.byokType ? { type: config2.byokType } : {},
-    baseUrl: config2.byokBaseUrl,
-    ...config2.byokApiKey ? { apiKey: config2.byokApiKey } : {},
-    ...config2.byokBearerToken ? { bearerToken: config2.byokBearerToken } : {},
-    ...config2.byokApiVersion ? { apiVersion: config2.byokApiVersion } : {},
-    ...config2.byokWireApi ? { wireApi: config2.byokWireApi } : {}
-  };
-}
 function resolveSkillDirectories(cwd) {
   const candidates = [
     path14.join(cwd, ".claude", "skills"),
@@ -27653,7 +27592,7 @@ function resolveSkillDirectories(cwd) {
   ];
   return candidates.filter((dir) => existsSync22(dir));
 }
-function normalizeByokBaseUrl(baseUrl, type) {
+function normalizeProviderBaseUrl(baseUrl, type) {
   const trimmed = baseUrl.trim().replace(/\/+$/, "");
   if (/^https?:\/\//i.test(trimmed)) {
     return trimmed;
@@ -29690,8 +29629,9 @@ function extractTranscript(raw) {
   const transcript = raw.transcript;
   return transcript;
 }
-var TRACE_ENVELOPE_SCHEMA_VERSION = "agentv.trace_envelope.v1";
+var EXECUTION_TRACE_SCHEMA_VERSION = "agentv.trace.v1";
 var TRACE_ENVELOPE_FORMAT = "otlp_openinference_spans";
+var TRANSCRIPT_MESSAGE_EVENT_NAME = "agentv.transcript.message";
 var CAPTURE_CONTENT_VALUES = ["none", "metadata", "full"];
 var REDACTION_LEVEL_VALUES = ["none", "partial", "full"];
 var WARNING_SEVERITY_VALUES = ["info", "warning", "error"];
@@ -29793,8 +29733,8 @@ var TraceEnvelopeScoreWireSchema = external_exports.object({
   evidence: AttributeMapWireSchema.optional()
 }).strict();
 var TraceEnvelopeWireSchema = external_exports.object({
-  schema_version: external_exports.literal(TRACE_ENVELOPE_SCHEMA_VERSION),
-  envelope_id: external_exports.string(),
+  schema_version: external_exports.literal(EXECUTION_TRACE_SCHEMA_VERSION),
+  artifact_id: external_exports.string(),
   created_at: external_exports.string(),
   eval: TraceEnvelopeEvalWireSchema,
   replay: TraceEnvelopeReplayWireSchema.optional(),
@@ -29808,6 +29748,9 @@ var TraceEnvelopeWireSchema = external_exports.object({
 function dropUndefined2(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function definedStringRecord(value) {
   if (!value) {
     return void 0;
@@ -29831,6 +29774,32 @@ function parseTimeMs(timestamp) {
 function msToUnixNano(ms) {
   return String(BigInt(Math.round(ms)) * 1000000n);
 }
+function compareUnixNanoStrings(first, second) {
+  try {
+    const left = BigInt(first);
+    const right = BigInt(second);
+    return left < right ? -1 : left > right ? 1 : 0;
+  } catch {
+    return first.localeCompare(second);
+  }
+}
+function compareSpanTime(first, second) {
+  const byStart = compareUnixNanoStrings(first.startTimeUnixNano, second.startTimeUnixNano);
+  if (byStart !== 0) {
+    return byStart;
+  }
+  if (first.spanId === second.parentSpanId) {
+    return -1;
+  }
+  if (second.spanId === first.parentSpanId) {
+    return 1;
+  }
+  const byEnd = compareUnixNanoStrings(first.endTimeUnixNano, second.endTimeUnixNano);
+  return byEnd !== 0 ? byEnd : first.spanId.localeCompare(second.spanId);
+}
+function orderedSpans(spans) {
+  return [...spans].sort(compareSpanTime);
+}
 function unixNanoToIso(value) {
   if (!value) {
     return void 0;
@@ -29919,6 +29888,41 @@ function maybeToolContentAttributes(toolCall, capture) {
     "gen_ai.tool.call.result": toolCall.output
   });
 }
+function toTranscriptToolCallWire(toolCall, capture) {
+  return dropUndefined2({
+    tool: toolCall.tool,
+    input: capture.content === "full" ? toolCall.input : void 0,
+    output: capture.content === "full" ? toolCall.output : void 0,
+    id: toolCall.id,
+    start_time: toolCall.startTime,
+    end_time: toolCall.endTime,
+    duration_ms: toolCall.durationMs
+  });
+}
+function toTranscriptMessageWire(message, capture) {
+  return dropUndefined2({
+    role: message.role,
+    name: message.name,
+    content: capture.content === "full" ? message.content : void 0,
+    tool_calls: message.toolCalls?.map((toolCall) => toTranscriptToolCallWire(toolCall, capture)),
+    start_time: message.startTime,
+    end_time: message.endTime,
+    duration_ms: message.durationMs,
+    metadata: message.metadata,
+    token_usage: message.tokenUsage
+  });
+}
+function transcriptMessageEvent(message, index, capture) {
+  const startMs = parseTimeMs(message.startTime);
+  return {
+    name: TRANSCRIPT_MESSAGE_EVENT_NAME,
+    timeUnixNano: startMs !== void 0 ? msToUnixNano(startMs) : void 0,
+    attributes: dropUndefined2({
+      "agentv.transcript.message.index": index,
+      "agentv.transcript.message": toTranscriptMessageWire(message, capture)
+    })
+  };
+}
 function spanStatusFromResult(result) {
   if (result.executionStatus === "execution_error" || result.error) {
     return { code: "ERROR", message: result.error };
@@ -29965,7 +29969,14 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
   const capture = capturePolicy(options);
   const source = sourceFromResult(result, options);
   const traceId = hashHex(
-    ["trace-envelope", result.timestamp, result.suite, result.testId, result.target, options.runId],
+    [
+      "execution-trace",
+      result.timestamp,
+      result.suite,
+      result.testId,
+      result.target,
+      options.runId
+    ],
     32
   );
   const rootSpanId = hashHex([traceId, "root"], 16);
@@ -29974,6 +29985,9 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
   const rootStatus = spanStatusFromResult(result);
   const conversionWarnings = [];
   const spans = [];
+  const rootEvents = result.trace.messages.map(
+    (message, index) => transcriptMessageEvent(message, index, capture)
+  );
   const rootAttributes = dropUndefined2({
     "gen_ai.operation.name": "invoke_agent",
     "gen_ai.provider.name": "agentv",
@@ -30005,12 +30019,13 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
     status: rootStatus,
     attributes: rootAttributes,
     events: result.error ? [
+      ...rootEvents,
       {
         name: "exception",
         timeUnixNano: msToUnixNano(Math.max(rootStartMs, rootEndMs)),
         attributes: { "exception.message": result.error }
       }
-    ] : []
+    ] : rootEvents
   });
   const assistantEntries = assistantMessages(result.trace.messages);
   const chatEntries = assistantEntries.length > 0 ? assistantEntries : result.output.length > 0 ? [{ message: { role: "assistant", content: result.output }, index: 0 }] : [];
@@ -30094,7 +30109,7 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
       });
     }
   }
-  const envelopeId = `trace-env-${hashHex([traceId, result.timestamp, result.score], 20)}`;
+  const artifactId = `execution-trace-${hashHex([traceId, result.timestamp, result.score], 20)}`;
   const evalIdentity = {
     evalId: options.evalId,
     evalPath: options.evalPath,
@@ -30109,8 +30124,8 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
     experiment: options.experiment
   };
   return {
-    schemaVersion: TRACE_ENVELOPE_SCHEMA_VERSION,
-    envelopeId,
+    schemaVersion: EXECUTION_TRACE_SCHEMA_VERSION,
+    artifactId,
     createdAt: now.toISOString(),
     eval: evalIdentity,
     replay: options.replay,
@@ -30133,7 +30148,7 @@ function toTraceEnvelopeWire(envelope) {
   return TraceEnvelopeWireSchema.parse(
     dropUndefined2({
       schema_version: envelope.schemaVersion,
-      envelope_id: envelope.envelopeId,
+      artifact_id: envelope.artifactId,
       created_at: envelope.createdAt,
       eval: toTraceEnvelopeEvalWire(envelope.eval),
       replay: envelope.replay ? toTraceEnvelopeReplayWire(envelope.replay) : void 0,
@@ -30150,7 +30165,7 @@ function fromTraceEnvelopeWire(input) {
   const wire = TraceEnvelopeWireSchema.parse(input);
   return {
     schemaVersion: wire.schema_version,
-    envelopeId: wire.envelope_id,
+    artifactId: wire.artifact_id,
     createdAt: wire.created_at,
     eval: fromTraceEnvelopeEvalWire(wire.eval),
     replay: wire.replay ? fromTraceEnvelopeReplayWire(wire.replay) : void 0,
@@ -30433,10 +30448,68 @@ function toolCallFromSpan(span) {
     durationMs: durationMsFromSpan(span)
   };
 }
-function traceEnvelopeToMessages(envelope) {
-  const spans = [...envelope.trace.spans].sort(
-    (first, second) => first.startTimeUnixNano.localeCompare(second.startTimeUnixNano)
-  );
+function buildSpanMap(spans) {
+  return new Map(spans.map((span) => [span.spanId, span]));
+}
+function ancestorSpanIds(span, spansById) {
+  const ancestors = [];
+  const seen = /* @__PURE__ */ new Set();
+  let parentSpanId = span.parentSpanId ?? void 0;
+  while (parentSpanId && !seen.has(parentSpanId)) {
+    seen.add(parentSpanId);
+    ancestors.push(parentSpanId);
+    parentSpanId = spansById.get(parentSpanId)?.parentSpanId ?? void 0;
+  }
+  return ancestors;
+}
+function nearestAncestorToolCallId(ancestorIds, spansById) {
+  for (const ancestorId of ancestorIds) {
+    const ancestor = spansById.get(ancestorId);
+    if (ancestor && isToolSpan(ancestor)) {
+      return toolCallFromSpan(ancestor).id;
+    }
+  }
+  return void 0;
+}
+function fromTranscriptToolCallWire(wire) {
+  if (!isRecord(wire) || typeof wire.tool !== "string") {
+    return void 0;
+  }
+  return {
+    tool: wire.tool,
+    input: wire.input,
+    output: wire.output,
+    id: typeof wire.id === "string" ? wire.id : void 0,
+    startTime: typeof wire.start_time === "string" ? wire.start_time : void 0,
+    endTime: typeof wire.end_time === "string" ? wire.end_time : void 0,
+    durationMs: numberAttribute(wire, "duration_ms")
+  };
+}
+function fromTranscriptMessageWire(wire) {
+  if (!isRecord(wire) || typeof wire.role !== "string") {
+    return void 0;
+  }
+  const toolCalls = Array.isArray(wire.tool_calls) ? wire.tool_calls.map(fromTranscriptToolCallWire).filter((toolCall) => toolCall !== void 0) : void 0;
+  return dropUndefined2({
+    role: wire.role,
+    name: typeof wire.name === "string" ? wire.name : void 0,
+    content: wire.content,
+    toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : void 0,
+    startTime: typeof wire.start_time === "string" ? wire.start_time : void 0,
+    endTime: typeof wire.end_time === "string" ? wire.end_time : void 0,
+    durationMs: numberAttribute(wire, "duration_ms"),
+    metadata: isRecord(wire.metadata) ? wire.metadata : void 0,
+    tokenUsage: isRecord(wire.token_usage) ? tokenUsageFromAttributes({
+      "gen_ai.usage.input_tokens": wire.token_usage.input,
+      "gen_ai.usage.output_tokens": wire.token_usage.output,
+      "gen_ai.usage.cache_read.input_tokens": wire.token_usage.cached,
+      "gen_ai.usage.reasoning.output_tokens": wire.token_usage.reasoning
+    }) : void 0
+  });
+}
+function traceEnvelopeToMessageEntries(envelope) {
+  const spans = orderedSpans(envelope.trace.spans);
+  const spansById = buildSpanMap(spans);
   const toolSpansByParent = /* @__PURE__ */ new Map();
   for (const span of spans.filter(isToolSpan)) {
     const parentSpanId = span.parentSpanId ?? envelope.trace.rootSpanId;
@@ -30444,20 +30517,97 @@ function traceEnvelopeToMessages(envelope) {
     existing.push(span);
     toolSpansByParent.set(parentSpanId, existing);
   }
-  return spans.filter(isChatSpan).map((span) => ({
-    role: "assistant",
-    content: span.attributes["gen_ai.output.messages"],
-    toolCalls: toolSpansByParent.get(span.spanId)?.map(toolCallFromSpan),
-    startTime: unixNanoToIso(span.startTimeUnixNano),
-    endTime: unixNanoToIso(span.endTimeUnixNano),
-    durationMs: durationMsFromSpan(span),
-    tokenUsage: tokenUsageFromAttributes(span.attributes),
-    metadata: {
-      span_id: span.spanId,
-      trace_id: span.traceId
+  return spans.filter(isChatSpan).map((span, fallbackIndex) => ({
+    index: numberAttribute(span.attributes, "agentv.message.index") ?? fallbackIndex,
+    timeUnixNano: span.startTimeUnixNano,
+    message: {
+      role: "assistant",
+      content: span.attributes["gen_ai.output.messages"],
+      toolCalls: toolSpansByParent.get(span.spanId)?.map(toolCallFromSpan),
+      startTime: unixNanoToIso(span.startTimeUnixNano),
+      endTime: unixNanoToIso(span.endTimeUnixNano),
+      durationMs: durationMsFromSpan(span),
+      tokenUsage: tokenUsageFromAttributes(span.attributes),
+      metadata: dropUndefined2({
+        span_id: span.spanId,
+        trace_id: span.traceId,
+        parent_span_id: span.parentSpanId ?? void 0,
+        parent_tool_call_id: nearestAncestorToolCallId(ancestorSpanIds(span, spansById), spansById)
+      })
     }
   }));
 }
+function traceEnvelopeToMessages(envelope) {
+  return traceEnvelopeToMessageEntries(envelope).map((entry) => entry.message);
+}
+function transcriptMessageEntries(envelope) {
+  const entries = [];
+  for (const span of orderedSpans(envelope.trace.spans)) {
+    for (const event of span.events ?? []) {
+      if (event.name !== TRANSCRIPT_MESSAGE_EVENT_NAME) {
+        continue;
+      }
+      const attributes = event.attributes ?? {};
+      const message = fromTranscriptMessageWire(attributes["agentv.transcript.message"]);
+      if (!message) {
+        continue;
+      }
+      entries.push({
+        index: numberAttribute(attributes, "agentv.transcript.message.index") ?? entries.length,
+        timeUnixNano: event.timeUnixNano,
+        message
+      });
+    }
+  }
+  return entries;
+}
+function traceEnvelopeToTranscriptMessages(envelope) {
+  const entries = transcriptMessageEntries(envelope);
+  if (entries.length === 0) {
+    return traceEnvelopeToMessages(envelope);
+  }
+  return [...entries].sort((first, second) => {
+    const byIndex = first.index - second.index;
+    if (byIndex !== 0) {
+      return byIndex;
+    }
+    if (first.timeUnixNano && second.timeUnixNano) {
+      return compareUnixNanoStrings(first.timeUnixNano, second.timeUnixNano);
+    }
+    return 0;
+  }).map((entry) => entry.message);
+}
+function traceEnvelopeToToolTrajectoryView(envelope) {
+  const spans = orderedSpans(envelope.trace.spans);
+  const spansById = buildSpanMap(spans);
+  const tools = spans.filter(isToolSpan).map((span, position) => {
+    const toolCall = toolCallFromSpan(span);
+    const toolCallId = toolCall.id ?? span.spanId;
+    const ancestorIds = ancestorSpanIds(span, spansById);
+    return {
+      position,
+      traceId: span.traceId,
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId ?? void 0,
+      ancestorSpanIds: ancestorIds,
+      tool: toolCall.tool,
+      toolCallId,
+      parentToolCallId: nearestAncestorToolCallId(ancestorIds, spansById),
+      input: toolCall.input,
+      output: toolCall.output,
+      status: span.status.code === "ERROR" ? "error" : "ok",
+      startTime: toolCall.startTime,
+      endTime: toolCall.endTime,
+      durationMs: toolCall.durationMs
+    };
+  });
+  return {
+    schemaVersion: NORMALIZED_TRAJECTORY_SCHEMA_VERSION,
+    traceId: envelope.trace.traceId,
+    rootSpanId: envelope.trace.rootSpanId,
+    tools
+  };
+}
 function traceEnvelopeToTraceSummary(envelope) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -30509,7 +30659,7 @@ function traceEnvelopeToTraceSummary(envelope) {
 function traceEnvelopeToTraceArtifact(envelope) {
   const events = [];
   let ordinal = 0;
-  for (const span of envelope.trace.spans) {
+  for (const span of orderedSpans(envelope.trace.spans)) {
     if (isChatSpan(span)) {
       events.push({
         eventId: `span-${span.spanId}`,
@@ -30578,6 +30728,95 @@ function traceEnvelopeToTraceArtifact(envelope) {
 function getTraceEnvelopeSummary(envelope) {
   return traceEnvelopeToTraceSummary(envelope).trace;
 }
+function traceEnvelopeToOtlpJson(envelope) {
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: attributesToOtlp(envelope.trace.resource?.attributes)
+        },
+        scopeSpans: [
+          {
+            scope: dropUndefined2({
+              name: envelope.trace.scope?.name,
+              version: envelope.trace.scope?.version
+            }),
+            spans: orderedSpans(envelope.trace.spans).map(
+              (span) => dropUndefined2({
+                traceId: span.traceId,
+                spanId: span.spanId,
+                parentSpanId: span.parentSpanId ?? void 0,
+                name: span.name,
+                kind: spanKindToOtlp(span.kind),
+                startTimeUnixNano: span.startTimeUnixNano,
+                endTimeUnixNano: span.endTimeUnixNano,
+                attributes: attributesToOtlp(span.attributes),
+                status: spanStatusToOtlp(span.status),
+                events: span.events?.map(
+                  (event) => dropUndefined2({
+                    name: event.name,
+                    timeUnixNano: event.timeUnixNano,
+                    attributes: attributesToOtlp(event.attributes)
+                  })
+                )
+              })
+            )
+          }
+        ]
+      }
+    ]
+  };
+}
+function spanKindToOtlp(kind) {
+  if (kind === "SERVER") {
+    return 1;
+  }
+  if (kind === "CLIENT") {
+    return 2;
+  }
+  if (kind === "PRODUCER") {
+    return 3;
+  }
+  if (kind === "CONSUMER") {
+    return 4;
+  }
+  return 0;
+}
+function spanStatusToOtlp(status) {
+  const code = status.code === "OK" ? 1 : status.code === "ERROR" ? 2 : 0;
+  return dropUndefined2({ code, message: status.message });
+}
+function attributesToOtlp(attributes) {
+  return Object.entries(attributes ?? {}).map(([key, value]) => ({
+    key,
+    value: toOtlpAnyValue(value)
+  }));
+}
+function toOtlpAnyValue(value) {
+  if (typeof value === "string") {
+    return { stringValue: value };
+  }
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+  }
+  if (typeof value === "boolean") {
+    return { boolValue: value };
+  }
+  if (Array.isArray(value)) {
+    return { arrayValue: { values: value.map(toOtlpAnyValue) } };
+  }
+  return { stringValue: stringifyOtlpAttribute(value) };
+}
+function stringifyOtlpAttribute(value) {
+  if (value === void 0) {
+    return "";
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 async function readTraceEnvelopeReplayRecords(sourcePath) {
   let raw;
   try {
@@ -30585,7 +30824,7 @@ async function readTraceEnvelopeReplayRecords(sourcePath) {
   } catch (error40) {
     const reason = error40 instanceof Error ? error40.message : String(error40);
     throw new Error(
-      `Trace envelope replay source not found or unreadable: ${sourcePath}: ${reason}`
+      `Execution trace replay source not found or unreadable: ${sourcePath}: ${reason}`
     );
   }
   const documents = parseTraceEnvelopeDocuments(raw, sourcePath);
@@ -30604,10 +30843,10 @@ function findTraceEnvelopeReplayRecord(records, lookup) {
   }
   const key = formatReplayLookupKey(lookup);
   if (matches.length === 0) {
-    throw new Error(`Trace envelope replay lookup found no record for ${key}`);
+    throw new Error(`Execution trace replay lookup found no record for ${key}`);
   }
   throw new Error(
-    `Trace envelope replay lookup found ${matches.length} duplicate records for ${key}`
+    `Execution trace replay lookup found ${matches.length} duplicate records for ${key}`
   );
 }
 function traceEnvelopeReplayRecordToProviderResponse(record2) {
@@ -30624,8 +30863,8 @@ function traceEnvelopeReplayRecordToProviderResponse(record2) {
     startTime: summary.startTime,
     endTime: summary.endTime,
     raw: {
-      replay_trace_envelope: dropUndefined3({
-        envelope_id: record2.envelope.envelopeId,
+      replay_execution_trace: dropUndefined3({
+        artifact_id: record2.envelope.artifactId,
         source_path: record2.sourcePath,
         line_number: record2.lineNumber,
         suite: identity.suite,
@@ -30668,7 +30907,7 @@ function parseTraceEnvelopeDocuments(raw, sourcePath) {
         documents.push({ value: JSON.parse(line), lineNumber: i + 1 });
       } catch (error40) {
         const reason = error40 instanceof Error ? error40.message : String(error40);
-        throw new Error(`Invalid trace envelope JSONL at ${sourcePath}:${i + 1}: ${reason}`);
+        throw new Error(`Invalid execution trace JSONL at ${sourcePath}:${i + 1}: ${reason}`);
       }
     }
     return documents;
@@ -30680,7 +30919,7 @@ function parseTraceEnvelopeDocument(value, sourcePath, lineNumber) {
   } catch (error40) {
     const location = lineNumber === void 0 ? sourcePath : `${sourcePath}:${lineNumber}`;
     const reason = error40 instanceof Error ? error40.message : String(error40);
-    throw new Error(`Invalid trace envelope replay record at ${location}: ${reason}`);
+    throw new Error(`Invalid execution trace replay record at ${location}: ${reason}`);
   }
 }
 function traceEnvelopeReplayIdentity(envelope) {
@@ -30705,13 +30944,13 @@ function lookupKeyNumber(lookupKey, key) {
 function assertReplayableMessages(output, record2) {
   if (output.length === 0) {
     throw new Error(
-      `Trace envelope replay source ${formatRecordLocation(record2)} cannot project to provider Message[]: no chat spans found`
+      `Execution trace replay source ${formatRecordLocation(record2)} cannot project to provider Message[]: no chat spans found`
     );
   }
   const lastAssistant = [...output].reverse().find((message) => message.role === "assistant");
   if (!lastAssistant || lastAssistant.content === void 0) {
     throw new Error(
-      `Trace envelope replay source ${formatRecordLocation(record2)} is missing assistant output content; replay requires a full-content trace envelope before grading`
+      `Execution trace replay source ${formatRecordLocation(record2)} is missing assistant output content; replay requires a full-content execution trace before grading`
     );
   }
 }
@@ -30740,7 +30979,7 @@ var ReplayProvider = class {
         const record2 = findReplayFixtureRecord(records, this.lookupForRequest(request));
         return replayFixtureRecordToProviderResponse(record2);
       }
-      case "trace_envelopes": {
+      case "execution_traces": {
         const records = await readTraceEnvelopeReplayRecords(source.path);
         const record2 = findTraceEnvelopeReplayRecord(records, this.lookupForRequest(request));
         return traceEnvelopeReplayRecordToProviderResponse(record2);
@@ -30758,7 +30997,7 @@ var ReplayProvider = class {
           )
         );
       }
-      case "trace_envelopes": {
+      case "execution_traces": {
         const records = await readTraceEnvelopeReplayRecords(source.path);
         return requests.map(
           (request) => traceEnvelopeReplayRecordToProviderResponse(
@@ -30791,7 +31030,7 @@ function resolveReplaySource(config2) {
     return { kind: "fixtures", path: config2.fixturesPath };
   }
   throw new Error(
-    "Replay provider requires exactly one replay source: fixtures or trace_envelopes"
+    "Replay provider requires exactly one replay source: fixtures or execution_traces"
   );
 }
 async function pathExists(target) {
@@ -32132,7 +32371,7 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
     };
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function extractTargetsArray(parsed, absolutePath) {
@@ -32143,7 +32382,7 @@ function extractTargetsArray(parsed, absolutePath) {
   return targets;
 }
 function assertTargetDefinition(value, index, filePath) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     throw new Error(`targets.yaml entry at index ${index} in ${filePath} must be an object`);
   }
   const name = value.name;
@@ -32176,7 +32415,7 @@ async function readTargetDefinitions(filePath) {
   }
   const raw = await readFile10(absolutePath, "utf8");
   const parsed = parseYamlValue(raw);
-  if (!isRecord(parsed)) {
+  if (!isRecord2(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
   }
   const targets = extractTargetsArray(parsed, absolutePath);
@@ -33248,13 +33487,22 @@ function fromYaml(raw) {
   }
   if (e.results && typeof e.results === "object") {
     const r = e.results;
-    if (typeof r.repo_url === "string" && r.repo_url.trim().length > 0) {
+    const repoUrl = typeof r.repo_url === "string" && r.repo_url.trim().length > 0 ? r.repo_url.trim() : void 0;
+    const repoPath = typeof r.repo_path === "string" && r.repo_path.trim().length > 0 ? r.repo_path.trim() : void 0;
+    if (repoUrl || repoPath) {
       const sync = r.sync && typeof r.sync === "object" ? r.sync : void 0;
       entry.results = {
-        repoUrl: r.repo_url.trim(),
+        ...repoUrl ? { repoUrl } : {},
+        ...repoPath ? { repoPath } : {},
         ...typeof r.branch === "string" && r.branch.trim().length > 0 ? { branch: r.branch.trim() } : {},
+        ...typeof r.remote === "string" && r.remote.trim().length > 0 ? { remote: r.remote.trim() } : {},
         ...typeof r.path === "string" && r.path.trim().length > 0 ? { path: r.path.trim() } : {},
-        ...sync && typeof sync.auto_push === "boolean" ? { sync: { autoPush: sync.auto_push } } : {},
+        ...sync && (typeof sync.auto_push === "boolean" || typeof sync.require_push === "boolean") ? {
+          sync: {
+            ...typeof sync.auto_push === "boolean" ? { autoPush: sync.auto_push } : {},
+            ...typeof sync.require_push === "boolean" ? { requirePush: sync.require_push } : {}
+          }
+        } : {},
         ...typeof r.branch_prefix === "string" && r.branch_prefix.trim().length > 0 ? { branchPrefix: r.branch_prefix.trim() } : {}
       };
     }
@@ -33273,11 +33521,20 @@ function toYaml(entry) {
   };
   if (entry.results) {
     yaml.results = {
-      repo_url: entry.results.repoUrl,
+      ...entry.results.repoUrl !== void 0 && { repo_url: entry.results.repoUrl },
+      ...entry.results.repoPath !== void 0 && { repo_path: entry.results.repoPath },
       ...entry.results.branch !== void 0 && { branch: entry.results.branch },
+      ...entry.results.remote !== void 0 && { remote: entry.results.remote },
       ...entry.results.path !== void 0 && { path: entry.results.path },
-      ...entry.results.sync?.autoPush !== void 0 && {
-        sync: { auto_push: entry.results.sync.autoPush }
+      ...(entry.results.sync?.autoPush !== void 0 || entry.results.sync?.requirePush !== void 0) && {
+        sync: {
+          ...entry.results.sync?.autoPush !== void 0 && {
+            auto_push: entry.results.sync.autoPush
+          },
+          ...entry.results.sync?.requirePush !== void 0 && {
+            require_push: entry.results.sync.requirePush
+          }
+        }
       },
       ...entry.results.branchPrefix !== void 0 && {
         branch_prefix: entry.results.branchPrefix
@@ -34031,9 +34288,9 @@ function cloneJsonValue(value) {
   return value;
 }
 var ANSI_RED = "\x1B[31m";
-var ANSI_RESET22 = "\x1B[0m";
+var ANSI_RESET2 = "\x1B[0m";
 function logError(msg) {
-  console.error(`${ANSI_RED}Error: ${msg}${ANSI_RESET22}`);
+  console.error(`${ANSI_RED}Error: ${msg}${ANSI_RESET2}`);
 }
 function isAgentSkillsFormat(parsed) {
   if (typeof parsed !== "object" || parsed === null) return false;
@@ -34201,8 +34458,8 @@ async function resolveFileReference3(rawValue, searchRoots) {
   }
   return { displayPath, attempted };
 }
-var ANSI_YELLOW22 = "\x1B[33m";
-var ANSI_RESET3 = "\x1B[0m";
+var ANSI_YELLOW2 = "\x1B[33m";
+var ANSI_RESET22 = "\x1B[0m";
 var DEFAULT_EVAL_PATTERNS = [
   "**/evals/**/*.eval.yaml",
   "**/evals/**/eval.yaml",
@@ -34566,13 +34823,20 @@ function parseResultsConfig(raw, configPath2) {
     return void 0;
   }
   const obj = raw;
-  if (obj.mode !== "github") {
+  if (obj.mode !== void 0 && obj.mode !== "github") {
     logWarning(`Invalid results.mode in ${configPath2}, expected 'github'`);
     return void 0;
   }
-  const repo = typeof obj.repo === "string" ? obj.repo.trim() : "";
-  if (!repo) {
-    logWarning(`Invalid results.repo in ${configPath2}, expected non-empty string`);
+  const legacyRepo = typeof obj.repo === "string" ? obj.repo.trim() : "";
+  const repoUrl = typeof obj.repo_url === "string" ? obj.repo_url.trim() : "";
+  const repoPath = typeof obj.repo_path === "string" ? obj.repo_path.trim() : "";
+  const repo = legacyRepo || repoUrl;
+  if (!repo && !repoPath) {
+    logWarning(`Invalid results in ${configPath2}, expected repo_url/repo or repo_path`);
+    return void 0;
+  }
+  if (repo && repoPath) {
+    logWarning(`Invalid results in ${configPath2}, set only one of repo_url/repo or repo_path`);
     return void 0;
   }
   let branch;
@@ -34583,6 +34847,14 @@ function parseResultsConfig(raw, configPath2) {
     }
     branch = obj.branch.trim();
   }
+  let remote;
+  if (obj.remote !== void 0) {
+    if (typeof obj.remote !== "string" || obj.remote.trim().length === 0) {
+      logWarning(`Invalid results.remote in ${configPath2}, expected non-empty string`);
+      return void 0;
+    }
+    remote = obj.remote.trim();
+  }
   let resultsPath;
   if (obj.path !== void 0) {
     if (typeof obj.path !== "string" || obj.path.trim().length === 0) {
@@ -34602,6 +34874,26 @@ function parseResultsConfig(raw, configPath2) {
     logWarning(`Invalid results.auto_push in ${configPath2}, expected boolean`);
     return void 0;
   }
+  let sync;
+  if (obj.sync !== void 0) {
+    if (typeof obj.sync !== "object" || obj.sync === null || Array.isArray(obj.sync)) {
+      logWarning(`Invalid results.sync in ${configPath2}, expected object`);
+      return void 0;
+    }
+    const syncObj = obj.sync;
+    if (syncObj.auto_push !== void 0 && typeof syncObj.auto_push !== "boolean") {
+      logWarning(`Invalid results.sync.auto_push in ${configPath2}, expected boolean`);
+      return void 0;
+    }
+    if (syncObj.require_push !== void 0 && typeof syncObj.require_push !== "boolean") {
+      logWarning(`Invalid results.sync.require_push in ${configPath2}, expected boolean`);
+      return void 0;
+    }
+    sync = {
+      ...typeof syncObj.auto_push === "boolean" && { auto_push: syncObj.auto_push },
+      ...typeof syncObj.require_push === "boolean" && { require_push: syncObj.require_push }
+    };
+  }
   let branchPrefix;
   if (obj.branch_prefix !== void 0) {
     if (typeof obj.branch_prefix !== "string" || obj.branch_prefix.trim().length === 0) {
@@ -34612,10 +34904,14 @@ function parseResultsConfig(raw, configPath2) {
   }
   return {
     mode: "github",
-    repo,
+    ...repo && { repo },
+    ...repoUrl && { repo_url: repoUrl },
+    ...repoPath && { repo_path: repoPath },
     ...branch !== void 0 && { branch },
+    ...remote !== void 0 && { remote },
     ...resultsPath !== void 0 && { path: resultsPath },
     ...typeof obj.auto_push === "boolean" && { auto_push: obj.auto_push },
+    ...sync && { sync },
     ...branchPrefix && { branch_prefix: branchPrefix }
   };
 }
@@ -34645,10 +34941,8 @@ function parseHooksConfig(raw, configPath2) {
   return void 0;
 }
 function logWarning(message) {
-  console.warn(`${ANSI_YELLOW22}Warning: ${message}${ANSI_RESET3}`);
+  console.warn(`${ANSI_YELLOW2}Warning: ${message}${ANSI_RESET22}`);
 }
-var ANSI_YELLOW3 = "\x1B[33m";
-var ANSI_RESET4 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
   const content = await readFile14(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
@@ -34666,8 +34960,8 @@ function validateTemplateVariables(content, source) {
     }
     match = variablePattern.exec(content);
   }
-  const hasCandidateAnswer = foundVariables.has(TEMPLATE_VARIABLES.OUTPUT) || foundVariables.has(TEMPLATE_VARIABLES.OUTPUT_TEXT);
-  const hasExpectedOutput = foundVariables.has(TEMPLATE_VARIABLES.EXPECTED_OUTPUT) || foundVariables.has(TEMPLATE_VARIABLES.EXPECTED_OUTPUT_TEXT);
+  const hasCandidateAnswer = foundVariables.has(TEMPLATE_VARIABLES.OUTPUT);
+  const hasExpectedOutput = foundVariables.has(TEMPLATE_VARIABLES.EXPECTED_OUTPUT);
   const hasRequiredFields = hasCandidateAnswer || hasExpectedOutput;
   if (!hasRequiredFields) {
     throw new Error(
@@ -34676,28 +34970,15 @@ function validateTemplateVariables(content, source) {
   - {{ ${TEMPLATE_VARIABLES.EXPECTED_OUTPUT} }}`
     );
   }
-  const deprecatedUsed = [];
-  for (const [deprecated, replacement] of DEPRECATED_TEMPLATE_VARIABLES) {
-    if (foundVariables.has(deprecated)) {
-      deprecatedUsed.push(`{{ ${deprecated} }} \u2192 {{ ${replacement} }}`);
-    }
-  }
-  if (deprecatedUsed.length > 0) {
-    console.warn(
-      `${ANSI_YELLOW3}Warning: Template at ${source} uses deprecated variable names:
-  ${deprecatedUsed.join("\n  ")}
-  These still work but will be removed in a future version.${ANSI_RESET4}`
-    );
-  }
   if (invalidVariables.length > 0) {
-    const warningMessage = `${ANSI_YELLOW3}Warning: Custom grader template at ${source}
+    const warningMessage = `Warning: Custom grader template at ${source}
   Contains invalid variables: ${invalidVariables.map((v) => `{{ ${v} }}`).join(", ")}
-  Valid variables: ${Array.from(VALID_TEMPLATE_VARIABLES).map((v) => `{{ ${v} }}`).join(", ")}${ANSI_RESET4}`;
+  Valid variables: ${Array.from(VALID_TEMPLATE_VARIABLES).map((v) => `{{ ${v} }}`).join(", ")}`;
     console.warn(warningMessage);
   }
 }
-var ANSI_YELLOW4 = "\x1B[33m";
-var ANSI_RESET5 = "\x1B[0m";
+var ANSI_YELLOW22 = "\x1B[33m";
+var ANSI_RESET3 = "\x1B[0m";
 var MAX_ASSERTION_INCLUDE_DEPTH = 3;
 var PROMPT_FILE_PREFIX = "file://";
 function normalizeGraderType(type) {
@@ -35027,7 +35308,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       let command;
       if (rawEvaluator.script !== void 0 && rawEvaluator.command === void 0) {
         console.warn(
-          `${ANSI_YELLOW4}Warning: 'script' is deprecated in evaluator '${name}' in '${evalId}'. Use 'command' instead.${ANSI_RESET5}`
+          `${ANSI_YELLOW22}Warning: 'script' is deprecated in evaluator '${name}' in '${evalId}'. Use 'command' instead.${ANSI_RESET3}`
         );
       }
       const rawCommand = rawEvaluator.command ?? rawEvaluator.script;
@@ -35909,7 +36190,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
     if (isJsonObject2(rawPrompt)) {
       if (rawPrompt.script !== void 0 && rawPrompt.command === void 0) {
         console.warn(
-          `${ANSI_YELLOW4}Warning: 'prompt.script' is deprecated in evaluator '${name}' in '${evalId}'. Use 'prompt.command' instead.${ANSI_RESET5}`
+          `${ANSI_YELLOW22}Warning: 'prompt.script' is deprecated in evaluator '${name}' in '${evalId}'. Use 'prompt.command' instead.${ANSI_RESET3}`
         );
       }
       const commandArray = asStringArray(
@@ -36210,10 +36491,10 @@ function warnUnconsumedCriteria(_criteria, _evaluators, _testId) {
 function logWarning2(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW4}Warning: ${message}
-${detailBlock}${ANSI_RESET5}`);
+    console.warn(`${ANSI_YELLOW22}Warning: ${message}
+${detailBlock}${ANSI_RESET3}`);
   } else {
-    console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET5}`);
+    console.warn(`${ANSI_YELLOW22}Warning: ${message}${ANSI_RESET3}`);
   }
 }
 function parseRequiredAndMinScore(rawRequired, rawMinScore, evaluatorName, evalId) {
@@ -36584,8 +36865,8 @@ function detectImageMediaType(filePath) {
   const ext = path43.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
-var ANSI_YELLOW5 = "\x1B[33m";
-var ANSI_RESET6 = "\x1B[0m";
+var ANSI_YELLOW3 = "\x1B[33m";
+var ANSI_RESET4 = "\x1B[0m";
 async function processMessages(options) {
   const { messages, searchRoots, repoRootPath, textParts, messageType, verbose } = options;
   const processedMessages = [];
@@ -36716,10 +36997,10 @@ function asString3(value) {
 function logWarning3(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW5}Warning: ${message}
-${detailBlock}${ANSI_RESET6}`);
+    console.warn(`${ANSI_YELLOW3}Warning: ${message}
+${detailBlock}${ANSI_RESET4}`);
   } else {
-    console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET6}`);
+    console.warn(`${ANSI_YELLOW3}Warning: ${message}${ANSI_RESET4}`);
   }
 }
 async function processExpectedMessages(options) {
@@ -36908,9 +37189,9 @@ function resolveInputMessages(raw, suiteInputFiles) {
 function resolveExpectedMessages(raw) {
   return expandExpectedOutputShorthand(raw.expected_output);
 }
-var ANSI_YELLOW6 = "\x1B[33m";
+var ANSI_YELLOW4 = "\x1B[33m";
 var ANSI_RED2 = "\x1B[31m";
-var ANSI_RESET7 = "\x1B[0m";
+var ANSI_RESET5 = "\x1B[0m";
 function matchesFilter(id, filter) {
   return typeof filter === "string" ? micromatch.isMatch(id, filter) : filter.some((pattern) => micromatch.isMatch(id, pattern));
 }
@@ -37100,19 +37381,19 @@ function asString4(value) {
 function logWarning4(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW6}Warning: ${message}
-${detailBlock}${ANSI_RESET7}`);
+    console.warn(`${ANSI_YELLOW4}Warning: ${message}
+${detailBlock}${ANSI_RESET5}`);
   } else {
-    console.warn(`${ANSI_YELLOW6}Warning: ${message}${ANSI_RESET7}`);
+    console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET5}`);
   }
 }
 function logError2(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
     console.error(`${ANSI_RED2}Error: ${message}
-${detailBlock}${ANSI_RESET7}`);
+${detailBlock}${ANSI_RESET5}`);
   } else {
-    console.error(`${ANSI_RED2}Error: ${message}${ANSI_RESET7}`);
+    console.error(`${ANSI_RED2}Error: ${message}${ANSI_RESET5}`);
   }
 }
 var MetadataSchema = external_exports.object({
@@ -37324,9 +37605,9 @@ function buildChatPromptFromSegments(options) {
   }
   return chatPrompt.length > 0 ? chatPrompt : void 0;
 }
-var ANSI_YELLOW7 = "\x1B[33m";
+var ANSI_YELLOW5 = "\x1B[33m";
 var ANSI_RED3 = "\x1B[31m";
-var ANSI_RESET8 = "\x1B[0m";
+var ANSI_RESET6 = "\x1B[0m";
 function matchesFilter2(id, filter) {
   return typeof filter === "string" ? micromatch2.isMatch(id, filter) : filter.some((pattern) => micromatch2.isMatch(id, pattern));
 }
@@ -37404,7 +37685,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-TJT6BGFF-DI7XNSO4.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-NWH3B4HG-UXXCZKLP.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
@@ -37439,7 +37720,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromAgentSkills(evalFilePath);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-TJT6BGFF-DI7XNSO4.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-NWH3B4HG-UXXCZKLP.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -38151,19 +38432,19 @@ function mergeSuiteMetadataPayload(caseMetadata, suitePayload) {
 function logWarning5(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
-    console.warn(`${ANSI_YELLOW7}Warning: ${message}
-${detailBlock}${ANSI_RESET8}`);
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}
+${detailBlock}${ANSI_RESET6}`);
   } else {
-    console.warn(`${ANSI_YELLOW7}Warning: ${message}${ANSI_RESET8}`);
+    console.warn(`${ANSI_YELLOW5}Warning: ${message}${ANSI_RESET6}`);
   }
 }
 function logError3(message, details) {
   if (details && details.length > 0) {
     const detailBlock = details.join("\n");
     console.error(`${ANSI_RED3}Error: ${message}
-${detailBlock}${ANSI_RESET8}`);
+${detailBlock}${ANSI_RESET6}`);
   } else {
-    console.error(`${ANSI_RED3}Error: ${message}${ANSI_RESET8}`);
+    console.error(`${ANSI_RED3}Error: ${message}${ANSI_RESET6}`);
   }
 }
 var execFileAsync2 = promisify6(execFile2);
@@ -38266,18 +38547,18 @@ function validateDependencyGraph(tests) {
   }
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
-  function visit(id, path49) {
+  function visit(id, path50) {
     if (visiting.has(id)) {
-      const cycle = [...path49.slice(path49.indexOf(id)), id];
+      const cycle = [...path50.slice(path50.indexOf(id)), id];
       throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
     }
     if (visited.has(id)) return;
     visiting.add(id);
-    path49.push(id);
+    path50.push(id);
     for (const dep of depMap.get(id) ?? []) {
-      visit(dep, path49);
+      visit(dep, path50);
     }
-    path49.pop();
+    path50.pop();
     visiting.delete(id);
     visited.add(id);
   }
@@ -41201,6 +41482,1179 @@ function createFunctionProvider(taskFn) {
     }
   };
 }
+function dropUndefined4(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function toTranscriptTokenUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  return dropUndefined4({
+    input: usage.input,
+    output: usage.output,
+    cached: usage.cached,
+    reasoning: usage.reasoning
+  });
+}
+function toTranscriptToolCall(toolCall) {
+  return dropUndefined4({
+    tool: toolCall.tool,
+    input: toolCall.input,
+    output: toolCall.output,
+    id: toolCall.id,
+    start_time: toolCall.startTime,
+    end_time: toolCall.endTime,
+    duration_ms: toolCall.durationMs
+  });
+}
+function toTranscriptMessageFields(message) {
+  return dropUndefined4({
+    role: message.role,
+    name: message.name,
+    content: message.content,
+    tool_calls: message.toolCalls?.map(toTranscriptToolCall),
+    start_time: message.startTime,
+    end_time: message.endTime,
+    duration_ms: message.durationMs,
+    metadata: message.metadata,
+    token_usage: toTranscriptTokenUsage(message.tokenUsage)
+  });
+}
+function toTranscriptJsonLines(entry, options) {
+  const source = {
+    provider: entry.source.provider,
+    session_id: entry.source.sessionId,
+    model: entry.source.model,
+    timestamp: entry.source.startedAt,
+    git_branch: entry.source.gitBranch,
+    cwd: entry.source.cwd ?? entry.source.projectPath,
+    version: entry.source.version
+  };
+  const transcriptTokenUsage = entry.tokenUsage ? {
+    input: entry.tokenUsage.input,
+    output: entry.tokenUsage.output,
+    cached: entry.tokenUsage.cached,
+    reasoning: entry.tokenUsage.reasoning
+  } : void 0;
+  const testId = options?.testId ?? entry.source.sessionId;
+  const target = options?.target ?? entry.source.provider;
+  return entry.messages.map((message, index) => ({
+    test_id: testId,
+    target,
+    message_index: index,
+    ...toTranscriptMessageFields(message),
+    transcript_token_usage: transcriptTokenUsage,
+    transcript_duration_ms: entry.durationMs,
+    transcript_cost_usd: entry.costUsd,
+    source
+  }));
+}
+function traceToTranscriptJsonLines(trace, options) {
+  const provider = (typeof trace.metadata?.provider === "string" ? trace.metadata.provider : void 0) ?? options?.target ?? "agentv";
+  const sessionId = (typeof trace.metadata?.provider_session_id === "string" ? trace.metadata.provider_session_id : void 0) ?? (typeof trace.metadata?.eval_case_id === "string" ? trace.metadata.eval_case_id : void 0) ?? options?.testId ?? "trace";
+  return toTranscriptJsonLines(
+    {
+      messages: [...trace.messages],
+      source: {
+        provider,
+        sessionId,
+        startedAt: trace.startTime
+      },
+      tokenUsage: trace.tokenUsage,
+      durationMs: trace.durationMs,
+      costUsd: trace.costUsd
+    },
+    options
+  );
+}
+function traceFromTranscriptJsonLines(lines) {
+  const [entry] = groupTranscriptJsonLines(lines);
+  if (!entry) {
+    return buildTraceFromMessages();
+  }
+  return buildTraceFromMessages({
+    output: entry.messages,
+    tokenUsage: entry.tokenUsage,
+    durationMs: entry.durationMs,
+    costUsd: entry.costUsd ?? void 0,
+    startTime: entry.source.startedAt,
+    provider: entry.source.provider,
+    target: entry.target,
+    testId: entry.testId,
+    conversationId: entry.source.sessionId
+  });
+}
+function fromTranscriptTokenUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  return {
+    input: usage.input,
+    output: usage.output,
+    cached: usage.cached,
+    reasoning: usage.reasoning
+  };
+}
+function readOptionalString(record2, key) {
+  const value = record2[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readOptionalNumber(record2, key) {
+  const value = record2[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function fromTranscriptToolCall(wire) {
+  const tool = readOptionalString(wire, "tool");
+  if (!tool) {
+    return void 0;
+  }
+  return {
+    tool,
+    input: wire.input,
+    output: wire.output,
+    id: readOptionalString(wire, "id"),
+    startTime: readOptionalString(wire, "start_time"),
+    endTime: readOptionalString(wire, "end_time"),
+    durationMs: readOptionalNumber(wire, "duration_ms")
+  };
+}
+function buildReplayMessage(line) {
+  return {
+    role: line.role,
+    name: line.name,
+    content: line.content,
+    toolCalls: line.tool_calls?.map(fromTranscriptToolCall).filter((toolCall) => toolCall !== void 0),
+    startTime: line.start_time,
+    endTime: line.end_time,
+    durationMs: line.duration_ms,
+    metadata: line.metadata,
+    tokenUsage: fromTranscriptTokenUsage(line.token_usage)
+  };
+}
+function groupTranscriptJsonLines(lines) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const existing = grouped.get(line.test_id);
+    const source = {
+      provider: line.source.provider,
+      sessionId: line.source.session_id,
+      startedAt: line.source.timestamp,
+      model: line.source.model,
+      gitBranch: line.source.git_branch,
+      cwd: line.source.cwd,
+      version: line.source.version
+    };
+    const transcriptTokenUsage = line.transcript_token_usage ? {
+      input: line.transcript_token_usage.input,
+      output: line.transcript_token_usage.output,
+      cached: line.transcript_token_usage.cached,
+      reasoning: line.transcript_token_usage.reasoning
+    } : void 0;
+    if (existing) {
+      existing.messages.push({ index: line.message_index, message: buildReplayMessage(line) });
+      continue;
+    }
+    grouped.set(line.test_id, {
+      target: line.target,
+      tokenUsage: transcriptTokenUsage,
+      durationMs: line.transcript_duration_ms,
+      costUsd: line.transcript_cost_usd,
+      source,
+      messages: [{ index: line.message_index, message: buildReplayMessage(line) }]
+    });
+  }
+  return [...grouped.entries()].map(([testId, entry]) => ({
+    testId,
+    target: entry.target,
+    tokenUsage: entry.tokenUsage,
+    durationMs: entry.durationMs,
+    costUsd: entry.costUsd,
+    source: entry.source,
+    messages: entry.messages.sort((first, second) => first.index - second.index).map((item) => item.message)
+  }));
+}
+async function readTranscriptJsonl(filePath) {
+  const text = await readFile19(filePath, "utf8");
+  return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+}
+async function readTranscriptFile(filePath) {
+  return readFile19(filePath, "utf8");
+}
+var ResultRowSchemaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ResultRowSchemaError";
+  }
+};
+var MIGRATION_GUIDANCE = "Expected an AgentV result row with a numeric score. Eval-case JSONL is input data, not a results artifact. Run `agentv eval <eval-file> --output <run-dir>` and pass the run workspace or its index.jsonl manifest.";
+var RESULT_ROW_ALIASES = {
+  answerPath: "answer_path",
+  artifactDir: "artifact_dir",
+  conversationId: "conversation_id",
+  costUsd: "cost_usd",
+  durationMs: "duration_ms",
+  endTime: "end_time",
+  evalPath: "eval_path",
+  executionStatus: "execution_status",
+  failureReasonCode: "failure_reason_code",
+  failureStage: "failure_stage",
+  filesPath: "files_path",
+  gradersPath: "graders_path",
+  gradingPath: "grading_path",
+  inputPath: "input_path",
+  outputPath: "output_path",
+  responsePath: "response_path",
+  startTime: "start_time",
+  targetsPath: "targets_path",
+  taskDir: "task_dir",
+  testId: "test_id",
+  timingPath: "timing_path",
+  tokenUsage: "token_usage",
+  transcriptPath: "transcript_path",
+  workspacePath: "workspace_path"
+};
+var TRACE_SUMMARY_ALIASES = {
+  costUsd: "cost_usd",
+  durationMs: "duration_ms",
+  errorCount: "error_count",
+  eventCount: "event_count",
+  llmCallCount: "llm_call_count",
+  tokenUsage: "token_usage",
+  toolCalls: "tool_calls",
+  toolDurations: "tool_durations"
+};
+var MESSAGE_ALIASES = {
+  durationMs: "duration_ms",
+  endTime: "end_time",
+  startTime: "start_time",
+  tokenUsage: "token_usage",
+  toolCalls: "tool_calls"
+};
+var TOOL_CALL_ALIASES = {
+  durationMs: "duration_ms",
+  endTime: "end_time",
+  startTime: "start_time"
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeKnownAliases(value, aliases) {
+  const normalized = { ...value };
+  for (const [camelKey, snakeKey] of Object.entries(aliases)) {
+    if (normalized[snakeKey] === void 0 && normalized[camelKey] !== void 0) {
+      normalized[snakeKey] = normalized[camelKey];
+    }
+    if (camelKey !== snakeKey) {
+      delete normalized[camelKey];
+    }
+  }
+  return normalized;
+}
+function normalizeToolCall2(value) {
+  if (!isRecord3(value)) {
+    return value;
+  }
+  return normalizeKnownAliases(value, TOOL_CALL_ALIASES);
+}
+function normalizeMessage(value) {
+  if (!isRecord3(value)) {
+    return value;
+  }
+  const normalized = normalizeKnownAliases(value, MESSAGE_ALIASES);
+  if (Array.isArray(normalized.tool_calls)) {
+    normalized.tool_calls = normalized.tool_calls.map(normalizeToolCall2);
+  }
+  return normalized;
+}
+function normalizeTraceSummary(value) {
+  if (!isRecord3(value)) {
+    return value;
+  }
+  const normalized = normalizeKnownAliases(value, TRACE_SUMMARY_ALIASES);
+  if (Array.isArray(normalized.messages)) {
+    normalized.messages = normalized.messages.map(normalizeMessage);
+  }
+  return normalized;
+}
+function normalizeOutput(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.map(normalizeMessage);
+}
+function buildSchemaError(context) {
+  const location = [
+    context.sourceLabel ? ` in ${context.sourceLabel}` : "",
+    context.lineNumber !== void 0 ? ` at line ${context.lineNumber}` : ""
+  ].join("");
+  return new ResultRowSchemaError(`Unsupported result row${location}. ${MIGRATION_GUIDANCE}`);
+}
+function buildInvalidScoreError(context) {
+  const location = [
+    context.sourceLabel ? ` in ${context.sourceLabel}` : "",
+    context.lineNumber !== void 0 ? ` at line ${context.lineNumber}` : ""
+  ].join("");
+  return new ResultRowSchemaError(`Missing or invalid score in result row${location}.`);
+}
+function looksLikeResultRow(value) {
+  return typeof value.test_id === "string" || Object.hasOwn(value, "score") || Object.hasOwn(value, "trace") || Object.hasOwn(value, "spans") || Object.hasOwn(value, "target") || Object.hasOwn(value, "grading_path") || Object.hasOwn(value, "timing_path");
+}
+function normalizeResultRow(value, context = {}) {
+  if (!isRecord3(value)) {
+    throw buildSchemaError(context);
+  }
+  const normalized = normalizeKnownAliases(value, RESULT_ROW_ALIASES);
+  if (normalized.trace !== void 0) {
+    normalized.trace = normalizeTraceSummary(normalized.trace);
+  }
+  if (normalized.output !== void 0) {
+    normalized.output = normalizeOutput(normalized.output);
+  }
+  if (typeof normalized.score !== "number" || !Number.isFinite(normalized.score)) {
+    if (looksLikeResultRow(normalized)) {
+      throw buildInvalidScoreError(context);
+    }
+    throw buildSchemaError(context);
+  }
+  return normalized;
+}
+var RESULT_INDEX_FILENAME = "index.jsonl";
+function buildTestTargetKey(testId, target) {
+  return `${testId ?? "unknown"}::${target ?? "unknown"}`;
+}
+function deduplicateByTestIdTarget(results) {
+  const seen = /* @__PURE__ */ new Map();
+  for (let i = 0; i < results.length; i++) {
+    seen.set(buildTestTargetKey(results[i].testId, results[i].target), i);
+  }
+  const deduped = [];
+  for (let i = 0; i < results.length; i++) {
+    const key = buildTestTargetKey(results[i].testId, results[i].target);
+    if (seen.get(key) === i) {
+      deduped.push(results[i]);
+    }
+  }
+  return deduped;
+}
+async function aggregateRunDir(runDir, options) {
+  const indexPath = path47.join(runDir, RESULT_INDEX_FILENAME);
+  const content = await readFile20(indexPath, "utf8");
+  const allResults = parseJsonlResults(content);
+  const results = deduplicateByTestIdTarget(allResults);
+  const timing = buildTimingArtifact(results);
+  const timingPath = path47.join(runDir, "timing.json");
+  await writeFile10(timingPath, `${JSON.stringify(timing, null, 2)}
+`, "utf8");
+  const plannedTestCount = options?.plannedTestCount ?? await readPlannedTestCount(path47.join(runDir, "benchmark.json"));
+  const benchmark = buildBenchmarkArtifact(
+    results,
+    options?.evalFile,
+    options?.experiment,
+    plannedTestCount
+  );
+  const benchmarkPath = path47.join(runDir, "benchmark.json");
+  await writeFile10(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+  const targetSet = new Set(results.map((r) => r.target ?? "unknown"));
+  return { benchmarkPath, timingPath, testCount: results.length, targetCount: targetSet.size };
+}
+async function readPlannedTestCount(benchmarkPath) {
+  try {
+    const raw = await readFile20(benchmarkPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const value = parsed.metadata?.planned_test_count;
+    return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function computeStats(values) {
+  if (values.length === 0) {
+    return { mean: 0, stddev: 0 };
+  }
+  const mean = values.reduce((sum, v) => sum + v, 0) / values.length;
+  const variance = values.reduce((sum, v) => sum + (v - mean) ** 2, 0) / values.length;
+  return {
+    mean: Math.round(mean * 1e3) / 1e3,
+    stddev: Math.round(Math.sqrt(variance) * 1e3) / 1e3
+  };
+}
+function computePassRate(result) {
+  const scores = result.scores;
+  if (scores && scores.length > 0) {
+    const passed = scores.filter((s) => s.score >= DEFAULT_THRESHOLD).length;
+    return passed / scores.length;
+  }
+  return (result.score ?? 0) >= DEFAULT_THRESHOLD ? 1 : 0;
+}
+function isExecutionError(result) {
+  return result.executionStatus === "execution_error";
+}
+function countToolCalls(result) {
+  const toolCalls = { ...result.trace?.toolCalls ?? {} };
+  const total = Object.values(toolCalls).reduce((sum, count) => sum + count, 0);
+  return { toolCalls, total };
+}
+function parseWorkspaceChanges(fileChanges) {
+  if (!fileChanges) {
+    return void 0;
+  }
+  let filesModified = 0;
+  let filesCreated = 0;
+  for (const line of fileChanges.split("\n")) {
+    if (line.startsWith("--- /dev/null")) {
+      filesCreated += 1;
+    } else if (line.startsWith("--- a/")) {
+      filesModified += 1;
+    }
+  }
+  const lines = fileChanges.split("\n");
+  const summaryLines = lines.slice(0, 20);
+  const diffSummary = lines.length > 20 ? `${summaryLines.join("\n")}
+... (${lines.length - 20} more lines)` : fileChanges;
+  return {
+    files_modified: filesModified,
+    files_created: filesCreated,
+    diff_summary: diffSummary
+  };
+}
+function buildAssertions(result) {
+  if (!result.assertions) return [];
+  return result.assertions.map((a) => ({
+    text: a.text,
+    passed: a.passed,
+    evidence: a.evidence ?? ""
+  }));
+}
+function buildEvaluators(scores) {
+  if (!scores || scores.length === 0) {
+    return void 0;
+  }
+  return scores.map((s) => ({
+    name: s.name,
+    type: s.type,
+    score: s.score,
+    reasoning: "",
+    weight: s.weight,
+    verdict: s.verdict,
+    assertions: s.assertions,
+    details: s.details
+  }));
+}
+function toIndexAssertion(assertion) {
+  return {
+    text: assertion.text,
+    passed: assertion.passed,
+    evidence: assertion.evidence
+  };
+}
+function toIndexScore(score) {
+  return {
+    name: score.name,
+    type: score.type,
+    score: score.score,
+    weight: score.weight,
+    verdict: score.verdict,
+    assertions: score.assertions.map(toIndexAssertion),
+    raw_request: score.rawRequest,
+    input: score.input,
+    target: score.target,
+    scores: score.scores?.map(toIndexScore),
+    details: score.details,
+    token_usage: score.tokenUsage,
+    duration_ms: score.durationMs,
+    started_at: score.startedAt,
+    ended_at: score.endedAt
+  };
+}
+function toIndexScores(scores) {
+  return scores?.map(toIndexScore);
+}
+function dropUndefined5(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toIndexRerunSource(value) {
+  if (!isRecord4(value)) {
+    return void 0;
+  }
+  return dropUndefined5({
+    mode: value.mode,
+    source_run_dir: value.sourceRunDir,
+    source_index_path: value.sourceIndexPath,
+    source_artifact_dir: value.sourceArtifactDir,
+    source_task_dir: value.sourceTaskDir,
+    source_test_id: value.sourceTestId,
+    source_target: value.sourceTarget,
+    source_timestamp: value.sourceTimestamp
+  });
+}
+function toIndexMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  const rerunSource = toIndexRerunSource(metadata.rerunSource);
+  if (!rerunSource) {
+    return { ...metadata };
+  }
+  return {
+    ...Object.fromEntries(Object.entries(metadata).filter(([key]) => key !== "rerunSource")),
+    rerun_source: rerunSource
+  };
+}
+function buildGradingArtifact(result) {
+  const assertions = buildAssertions(result);
+  const passed = assertions.filter((e) => e.passed).length;
+  const failed = assertions.filter((e) => !e.passed).length;
+  const total = assertions.length;
+  const { toolCalls, total: totalToolCalls } = countToolCalls(result);
+  const errorsEncountered = result.error ? 1 : 0;
+  return {
+    assertions,
+    summary: {
+      passed,
+      failed,
+      total,
+      pass_rate: total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0
+    },
+    execution_metrics: {
+      tool_calls: toolCalls,
+      total_tool_calls: totalToolCalls,
+      errors_encountered: errorsEncountered
+    },
+    graders: buildEvaluators(result.scores),
+    workspace_changes: parseWorkspaceChanges(result.fileChanges),
+    conversation: result.conversationId ? {
+      turns: result.trace?.messages.filter((message) => message.role === "assistant").length ?? 0,
+      conversation_id: result.conversationId
+    } : void 0
+  };
+}
+function buildTimingArtifact(results) {
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalReasoning = 0;
+  let totalDurationMs = 0;
+  for (const result of results) {
+    const usage = result.tokenUsage;
+    if (usage) {
+      totalInput += usage.input ?? 0;
+      totalOutput += usage.output ?? 0;
+      totalReasoning += usage.reasoning ?? 0;
+    }
+    if (result.durationMs != null) {
+      totalDurationMs += result.durationMs;
+    }
+  }
+  return {
+    total_tokens: totalInput + totalOutput,
+    duration_ms: totalDurationMs,
+    total_duration_seconds: Math.round(totalDurationMs / 1e3 * 1e3) / 1e3,
+    token_usage: {
+      input: totalInput,
+      output: totalOutput,
+      reasoning: totalReasoning
+    }
+  };
+}
+function buildBenchmarkArtifact(results, evalFile = "", experiment, plannedTestCount) {
+  const targetSet = /* @__PURE__ */ new Set();
+  const testIdSet = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    targetSet.add(result.target ?? "unknown");
+    testIdSet.add(result.testId ?? "unknown");
+  }
+  const targets = [...targetSet].sort();
+  const testIds = [...testIdSet].sort();
+  const runSummary = {};
+  const notes = [];
+  for (const target of targets) {
+    const targetResults = results.filter((r) => r.target === target);
+    const qualityResults = targetResults.filter((r) => !isExecutionError(r));
+    const passRates = qualityResults.map(computePassRate);
+    const timings = targetResults.filter((r) => r.durationMs != null).map((r) => r.durationMs / 1e3);
+    const tokens = targetResults.filter((r) => r.tokenUsage != null).map((r) => {
+      const usage = r.tokenUsage;
+      return (usage.input ?? 0) + (usage.output ?? 0);
+    });
+    const entry = {
+      pass_rate: computeStats(passRates),
+      time_seconds: computeStats(timings),
+      tokens: computeStats(tokens)
+    };
+    const toolCallCounts = targetResults.map((r) => countToolCalls(r).total);
+    if (toolCallCounts.some((count) => count > 0)) {
+      entry.tool_calls = computeStats(toolCallCounts);
+    }
+    const costs = targetResults.filter((r) => r.costUsd != null).map((r) => r.costUsd);
+    if (costs.length > 0) {
+      entry.cost_usd = computeStats(costs);
+    }
+    runSummary[target] = entry;
+  }
+  const evaluatorScores = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    if (isExecutionError(result)) {
+      continue;
+    }
+    for (const score of result.scores ?? []) {
+      const key = `${score.name}:${score.type}`;
+      if (!evaluatorScores.has(key)) {
+        evaluatorScores.set(key, []);
+      }
+      evaluatorScores.get(key)?.push(score.score);
+    }
+  }
+  let perEvaluatorSummary;
+  if (evaluatorScores.size > 0) {
+    perEvaluatorSummary = {};
+    for (const [key, scores] of evaluatorScores) {
+      perEvaluatorSummary[key] = computeStats(scores);
+    }
+  }
+  const errorCount = results.filter((r) => r.executionStatus === "execution_error").length;
+  if (errorCount > 0) {
+    notes.push(
+      `${errorCount} test(s) had execution errors and are excluded from quality pass_rate`
+    );
+  }
+  if (results.length === 0) {
+    notes.push("No results to summarize");
+  }
+  const firstResult = results[0];
+  const timestamp = firstResult?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    metadata: {
+      eval_file: evalFile,
+      timestamp,
+      targets,
+      tests_run: testIds,
+      experiment,
+      planned_test_count: plannedTestCount
+    },
+    run_summary: runSummary,
+    per_grader_summary: perEvaluatorSummary,
+    notes
+  };
+}
+async function writeInitialBenchmarkArtifact(runDir, options) {
+  await mkdir18(runDir, { recursive: true });
+  const stub = buildBenchmarkArtifact(
+    [],
+    options.evalFile,
+    options.experiment,
+    options.plannedTestCount
+  );
+  const benchmarkPath = path47.join(runDir, "benchmark.json");
+  await writeFile10(benchmarkPath, `${JSON.stringify(stub, null, 2)}
+`, "utf8");
+}
+function buildAggregateGradingArtifact(results) {
+  const assertions = [];
+  for (const result of results.filter((r) => !isExecutionError(r))) {
+    const testId = result.testId ?? "unknown";
+    for (const assertion of result.assertions ?? []) {
+      assertions.push({
+        test_id: testId,
+        text: assertion.text,
+        passed: assertion.passed,
+        evidence: assertion.evidence ?? ""
+      });
+    }
+  }
+  const passed = assertions.filter((a) => a.passed).length;
+  const failed = assertions.filter((a) => !a.passed).length;
+  const total = assertions.length;
+  return {
+    assertions,
+    summary: {
+      passed,
+      failed,
+      total,
+      pass_rate: total > 0 ? Math.round(passed / total * 1e3) / 1e3 : 0
+    }
+  };
+}
+function safeArtifactPathSegment(value, fallback) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return fallback;
+  }
+  return trimmed.replace(/[/\\:*?"<>|]/g, "_");
+}
+function safeTestId(testId) {
+  return safeArtifactPathSegment(testId, "unknown");
+}
+function getSuite(result) {
+  return result.suite;
+}
+function buildArtifactSubdir(result) {
+  const segments = [];
+  const evalSet = getSuite(result);
+  if (evalSet) {
+    segments.push(safeArtifactPathSegment(evalSet, "default"));
+  }
+  segments.push(safeTestId(result.testId));
+  return path47.posix.join(...segments);
+}
+function formatOutputMarkdown(output) {
+  return output.map((msg) => `@[${msg.role}]:
+${String(msg.content ?? "")}`).join("\n\n");
+}
+function extractInput(result) {
+  const input = result.input;
+  if (!input) return null;
+  if (typeof input === "string") return input;
+  if (Array.isArray(input) && input.length > 0) {
+    return formatOutputMarkdown(input);
+  }
+  return null;
+}
+function toRelativeArtifactPath(outputDir, filePath) {
+  return path47.relative(outputDir, filePath).split(path47.sep).join("/");
+}
+function findResultSourceTest(result, testByTestId) {
+  return testByTestId.get(result.testId ?? "unknown");
+}
+function resolveEnvelopeEvalPath(result, testByTestId, fallbackEvalFile) {
+  const source = findResultSourceTest(result, testByTestId)?.source;
+  return source?.evalFileRepoPath ?? source?.evalFilePath ?? fallbackEvalFile;
+}
+function resultHasExecutionTraceTranscript(result) {
+  return result.output.length > 0 || result.trace.messages.length > 0;
+}
+async function writeTraceEnvelopeSidecar(params) {
+  const hasTranscript = resultHasExecutionTraceTranscript(params.result);
+  const envelope = buildTraceEnvelopeFromEvaluationResult(params.result, {
+    evalPath: params.evalPath,
+    runId: path47.basename(params.outputDir),
+    experiment: params.experiment,
+    source: { path: RESULT_INDEX_FILENAME },
+    capture: { content: "full", redactionLevel: "none", redactedFields: [] },
+    artifacts: {
+      execution_trace_path: "outputs/execution-trace.json",
+      answer_path: params.result.output.length > 0 ? "outputs/answer.md" : void 0,
+      response_path: params.result.output.length > 0 ? "outputs/response.md" : void 0,
+      transcript_path: hasTranscript ? "outputs/transcript.jsonl" : void 0
+    }
+  });
+  await writeFile10(
+    path47.join(params.outputsDir, "execution-trace.json"),
+    `${JSON.stringify(toTraceEnvelopeWire(envelope), null, 2)}
+`,
+    "utf8"
+  );
+  return envelope;
+}
+function buildIndexArtifactEntry(result, options) {
+  return {
+    timestamp: result.timestamp,
+    test_id: result.testId ?? "unknown",
+    suite: getSuite(result),
+    category: result.category,
+    conversation_id: result.conversationId,
+    score: result.score,
+    target: result.target ?? "unknown",
+    token_usage: result.tokenUsage,
+    cost_usd: result.costUsd,
+    duration_ms: result.durationMs,
+    start_time: result.startTime,
+    end_time: result.endTime,
+    scores: toIndexScores(result.scores),
+    execution_status: result.executionStatus,
+    error: result.error,
+    failure_stage: result.failureStage,
+    failure_reason_code: result.failureReasonCode,
+    workspace_path: result.workspacePath,
+    artifact_dir: options.artifactDir ? toRelativeArtifactPath(options.outputDir, options.artifactDir) : void 0,
+    grading_path: toRelativeArtifactPath(options.outputDir, options.gradingPath),
+    timing_path: toRelativeArtifactPath(options.outputDir, options.timingPath),
+    output_path: options.outputPath ? toRelativeArtifactPath(options.outputDir, options.outputPath) : void 0,
+    answer_path: options.answerPath ? toRelativeArtifactPath(options.outputDir, options.answerPath) : void 0,
+    transcript_path: options.transcriptPath ? toRelativeArtifactPath(options.outputDir, options.transcriptPath) : void 0,
+    input_path: options.inputPath ? toRelativeArtifactPath(options.outputDir, options.inputPath) : void 0,
+    response_path: options.responsePath ? toRelativeArtifactPath(options.outputDir, options.responsePath) : void 0,
+    ...options.extraIndexFields,
+    metadata: toIndexMetadata(result.metadata)
+  };
+}
+function buildResultIndexArtifact(result, extraIndexFields) {
+  const artifactSubdir = buildArtifactSubdir(result);
+  const input = extractInput(result);
+  const hasAnswer = result.output.length > 0;
+  const hasTranscript = resultHasExecutionTraceTranscript(result);
+  return {
+    timestamp: result.timestamp,
+    test_id: result.testId ?? "unknown",
+    suite: getSuite(result),
+    category: result.category,
+    conversation_id: result.conversationId,
+    score: result.score,
+    target: result.target ?? "unknown",
+    token_usage: result.tokenUsage,
+    cost_usd: result.costUsd,
+    duration_ms: result.durationMs,
+    start_time: result.startTime,
+    end_time: result.endTime,
+    scores: toIndexScores(result.scores),
+    execution_status: result.executionStatus,
+    error: result.error,
+    failure_stage: result.failureStage,
+    failure_reason_code: result.failureReasonCode,
+    workspace_path: result.workspacePath,
+    artifact_dir: artifactSubdir,
+    grading_path: path47.posix.join(artifactSubdir, "grading.json"),
+    timing_path: path47.posix.join(artifactSubdir, "timing.json"),
+    input_path: input ? path47.posix.join(artifactSubdir, "input.md") : void 0,
+    output_path: hasAnswer ? path47.posix.join(artifactSubdir, "outputs", "answer.md") : void 0,
+    answer_path: hasAnswer ? path47.posix.join(artifactSubdir, "outputs", "answer.md") : void 0,
+    transcript_path: hasTranscript ? path47.posix.join(artifactSubdir, "outputs", "transcript.jsonl") : void 0,
+    response_path: hasAnswer ? path47.posix.join(artifactSubdir, "outputs", "response.md") : void 0,
+    ...extraIndexFields,
+    metadata: toIndexMetadata(result.metadata)
+  };
+}
+async function writeJsonlFile(filePath, records) {
+  const content = records.length === 0 ? "" : `${records.map((record2) => JSON.stringify(record2)).join("\n")}
+`;
+  await writeFile10(filePath, content, "utf8");
+}
+function traceProjectionForTranscript(result, envelope) {
+  return {
+    ...result.trace,
+    messages: traceEnvelopeToTranscriptMessages(envelope)
+  };
+}
+function hasTranscriptProjection(result, envelope) {
+  return result.output.length > 0 || traceEnvelopeToTranscriptMessages(envelope).length > 0;
+}
+async function writeTranscriptJsonl(filePath, result, envelope) {
+  const lines = traceToTranscriptJsonLines(traceProjectionForTranscript(result, envelope), {
+    testId: result.testId,
+    target: result.target
+  });
+  const content = lines.length > 0 ? `${lines.map((line) => JSON.stringify(line)).join("\n")}
+` : "";
+  await writeFile10(filePath, content, "utf8");
+}
+function indexRecordKey(record2) {
+  if (!isRecord4(record2)) {
+    return void 0;
+  }
+  const testId = typeof record2.test_id === "string" ? record2.test_id : typeof record2.testId === "string" ? record2.testId : void 0;
+  const target = typeof record2.target === "string" ? record2.target : void 0;
+  return testId ? buildTestTargetKey(testId, target) : void 0;
+}
+async function rewriteExistingIndexRecords(outputDir, replacements) {
+  if (replacements.length === 0) {
+    return;
+  }
+  const indexPath = path47.join(outputDir, RESULT_INDEX_FILENAME);
+  const content = await readFile20(indexPath, "utf8").catch(() => void 0);
+  if (content === void 0) {
+    return;
+  }
+  const replacementsByKey = new Map(
+    replacements.map((record2) => [buildTestTargetKey(record2.test_id, record2.target), record2])
+  );
+  const seen = /* @__PURE__ */ new Set();
+  const records = [];
+  for (const line of content.split("\n")) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(line);
+      const key = indexRecordKey(parsed);
+      const replacement = key ? replacementsByKey.get(key) : void 0;
+      if (key && replacement) {
+        records.push(replacement);
+        seen.add(key);
+      } else {
+        records.push(parsed);
+      }
+    } catch {
+    }
+  }
+  for (const replacement of replacements) {
+    const key = buildTestTargetKey(replacement.test_id, replacement.target);
+    if (!seen.has(key)) {
+      records.push(replacement);
+    }
+  }
+  await writeJsonlFile(indexPath, records);
+}
+function toCamelCase2(str) {
+  return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function toCamelCaseDeep2(obj) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => toCamelCaseDeep2(item));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[toCamelCase2(key)] = toCamelCaseDeep2(value);
+    }
+    return result;
+  }
+  return obj;
+}
+var EXECUTION_STATUSES = /* @__PURE__ */ new Set([
+  "ok",
+  "quality_failure",
+  "execution_error"
+]);
+function isAssertionEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.text === "string" && typeof candidate.passed === "boolean" && (candidate.evidence === void 0 || typeof candidate.evidence === "string");
+}
+function isOutputMessage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return typeof value.role === "string";
+}
+function isExecutionStatus(value) {
+  return typeof value === "string" && EXECUTION_STATUSES.has(value);
+}
+function isTraceRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Array.isArray(value.messages) && Array.isArray(value.events);
+}
+function normalizeParsedResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const result = value;
+  const legacyOutputMessages = Array.isArray(result.output) ? result.output.filter(isOutputMessage) : void 0;
+  const output = typeof result.output === "string" ? result.output : extractLastAssistantContent(legacyOutputMessages);
+  const legacySummary = result.trace && typeof result.trace === "object" && !Array.isArray(result.trace) ? result.trace : void 0;
+  const trace = isTraceRecord(result.trace) ? result.trace : buildTraceFromMessages({
+    input: Array.isArray(result.input) ? result.input : [],
+    output: legacyOutputMessages,
+    summary: legacySummary,
+    finalOutput: output,
+    tokenUsage: result.tokenUsage,
+    costUsd: typeof result.costUsd === "number" ? result.costUsd : void 0,
+    durationMs: typeof result.durationMs === "number" ? result.durationMs : void 0,
+    target: typeof result.target === "string" ? result.target : void 0,
+    testId: typeof result.testId === "string" ? result.testId : void 0
+  });
+  return {
+    ...result,
+    timestamp: typeof result.timestamp === "string" ? result.timestamp : (/* @__PURE__ */ new Date(0)).toISOString(),
+    testId: typeof result.testId === "string" ? result.testId : "unknown",
+    score: typeof result.score === "number" ? result.score : 0,
+    assertions: Array.isArray(result.assertions) ? result.assertions.filter(isAssertionEntry) : [],
+    target: typeof result.target === "string" ? result.target : "unknown",
+    output,
+    trace,
+    executionStatus: isExecutionStatus(result.executionStatus) ? result.executionStatus : "ok"
+  };
+}
+function parseJsonlResults(content) {
+  const results = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i]?.trim();
+    if (!trimmed) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const canonicalRow = normalizeResultRow(parsed, { lineNumber: i + 1 });
+    const camelCased = toCamelCaseDeep2(canonicalRow);
+    const normalized = normalizeParsedResult(camelCased);
+    if (normalized) {
+      results.push(normalized);
+    }
+  }
+  return results;
+}
+async function writeArtifacts(jsonlPath, outputDir, options) {
+  const content = await readFile20(jsonlPath, "utf8");
+  const results = parseJsonlResults(content);
+  return writeArtifactsFromResults(results, outputDir, options);
+}
+function buildTranscriptMessageLines(results) {
+  const lines = [];
+  for (const result of results) {
+    const transcriptLines = traceToTranscriptJsonLines(result.trace, {
+      testId: result.testId,
+      target: result.target
+    });
+    lines.push(...transcriptLines.map((line) => JSON.stringify(line)));
+  }
+  return lines.length > 0 ? `${lines.join("\n")}
+` : "";
+}
+async function collectAdditionalIndexFields(result, outputDir, testDir, testByTestId, additionalArtifacts) {
+  if (!additionalArtifacts) {
+    return void 0;
+  }
+  return additionalArtifacts({
+    result,
+    outputDir,
+    testDir,
+    sourceTest: testByTestId.get(result.testId ?? "unknown"),
+    sourceTestsById: testByTestId
+  });
+}
+async function writePerTestArtifacts(results, outputDir, options) {
+  await mkdir18(outputDir, { recursive: true });
+  const testByTestId = new Map((options?.sourceTests ?? []).map((test) => [test.id, test]));
+  const indexRecords = [];
+  for (const result of results) {
+    const grading = buildGradingArtifact(result);
+    const timing = buildTimingArtifact([result]);
+    const artifactSubdir = buildArtifactSubdir(result);
+    const testDir = path47.join(outputDir, artifactSubdir);
+    await mkdir18(testDir, { recursive: true });
+    await writeFile10(
+      path47.join(testDir, "grading.json"),
+      `${JSON.stringify(grading, null, 2)}
+`,
+      "utf8"
+    );
+    await writeFile10(
+      path47.join(testDir, "timing.json"),
+      `${JSON.stringify(timing, null, 2)}
+`,
+      "utf8"
+    );
+    const input = extractInput(result);
+    if (input) {
+      await writeFile10(path47.join(testDir, "input.md"), input, "utf8");
+    }
+    const outputsDir = path47.join(testDir, "outputs");
+    await mkdir18(outputsDir, { recursive: true });
+    if (result.output.length > 0) {
+      await writeFile10(path47.join(outputsDir, "answer.md"), result.output, "utf8");
+      await writeFile10(path47.join(outputsDir, "response.md"), result.output, "utf8");
+    }
+    const envelope = await writeTraceEnvelopeSidecar({
+      result,
+      outputDir,
+      outputsDir,
+      evalPath: resolveEnvelopeEvalPath(result, testByTestId, options?.evalFile),
+      experiment: options?.experiment
+    });
+    if (hasTranscriptProjection(result, envelope)) {
+      await writeTranscriptJsonl(path47.join(outputsDir, "transcript.jsonl"), result, envelope);
+    }
+    const extraIndexFields = await collectAdditionalIndexFields(
+      result,
+      outputDir,
+      testDir,
+      testByTestId,
+      options?.additionalArtifacts
+    );
+    indexRecords.push({
+      ...buildResultIndexArtifact(result, extraIndexFields),
+      experiment: options?.experiment
+    });
+  }
+  await rewriteExistingIndexRecords(outputDir, indexRecords);
+}
+async function writeArtifactsFromResults(results, outputDir, options) {
+  const testArtifactDir = outputDir;
+  const timingPath = path47.join(outputDir, "timing.json");
+  const benchmarkPath = path47.join(outputDir, "benchmark.json");
+  const indexPath = path47.join(outputDir, RESULT_INDEX_FILENAME);
+  await mkdir18(outputDir, { recursive: true });
+  const indexRecords = [];
+  const testByTestId = new Map((options?.sourceTests ?? []).map((test) => [test.id, test]));
+  for (const result of results) {
+    const grading = buildGradingArtifact(result);
+    const timing2 = buildTimingArtifact([result]);
+    const artifactSubdir = buildArtifactSubdir(result);
+    const testDir = path47.join(outputDir, artifactSubdir);
+    const gradingPath = path47.join(testDir, "grading.json");
+    const perTestTimingPath = path47.join(testDir, "timing.json");
+    await mkdir18(testDir, { recursive: true });
+    await writeFile10(gradingPath, `${JSON.stringify(grading, null, 2)}
+`, "utf8");
+    await writeFile10(perTestTimingPath, `${JSON.stringify(timing2, null, 2)}
+`, "utf8");
+    const input = extractInput(result);
+    const inputPath = input ? path47.join(testDir, "input.md") : void 0;
+    if (inputPath && input) {
+      await writeFile10(inputPath, input, "utf8");
+    }
+    const outputsDir = path47.join(testDir, "outputs");
+    await mkdir18(outputsDir, { recursive: true });
+    const answerPath = result.output.length > 0 ? path47.join(outputsDir, "answer.md") : void 0;
+    const responsePath = result.output.length > 0 ? path47.join(outputsDir, "response.md") : void 0;
+    if (answerPath && responsePath) {
+      await writeFile10(answerPath, result.output, "utf8");
+      await writeFile10(responsePath, result.output, "utf8");
+    }
+    const envelope = await writeTraceEnvelopeSidecar({
+      result,
+      outputDir,
+      outputsDir,
+      evalPath: resolveEnvelopeEvalPath(result, testByTestId, options?.evalFile),
+      experiment: options?.experiment
+    });
+    const transcriptPath = hasTranscriptProjection(result, envelope) ? path47.join(outputsDir, "transcript.jsonl") : void 0;
+    if (transcriptPath) {
+      await writeTranscriptJsonl(transcriptPath, result, envelope);
+    }
+    const extraIndexFields = await collectAdditionalIndexFields(
+      result,
+      outputDir,
+      testDir,
+      testByTestId,
+      options?.additionalArtifacts
+    );
+    indexRecords.push({
+      ...buildIndexArtifactEntry(result, {
+        outputDir,
+        artifactDir: testDir,
+        gradingPath,
+        timingPath: perTestTimingPath,
+        outputPath: answerPath,
+        answerPath,
+        transcriptPath,
+        inputPath,
+        responsePath,
+        extraIndexFields
+      }),
+      experiment: options?.experiment
+    });
+  }
+  const timing = buildTimingArtifact(results);
+  await writeFile10(timingPath, `${JSON.stringify(timing, null, 2)}
+`, "utf8");
+  const plannedTestCount = options?.plannedTestCount ?? await readPlannedTestCount(benchmarkPath);
+  const benchmark = buildBenchmarkArtifact(
+    results,
+    options?.evalFile,
+    options?.experiment,
+    plannedTestCount
+  );
+  await writeFile10(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
+`, "utf8");
+  await writeJsonlFile(indexPath, indexRecords);
+  await writeFile10(
+    path47.join(outputDir, "transcript.jsonl"),
+    buildTranscriptMessageLines(results),
+    "utf8"
+  );
+  return { testArtifactDir, timingPath, benchmarkPath, indexPath };
+}
 async function evaluate(config2) {
   const startTime = Date.now();
   if (config2.tests && config2.specFile) {
@@ -41246,7 +42700,7 @@ async function evaluate(config2) {
     cliNoCache: false,
     yamlCache: config2.cache === void 0 ? materialized.cache : void 0
   });
-  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path47.resolve(materialized.cachePath) : void 0) : void 0;
+  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path48.resolve(materialized.cachePath) : void 0) : void 0;
   const results = await runEvaluation({
     testFilePath,
     repoRoot,
@@ -41269,15 +42723,27 @@ async function evaluate(config2) {
   });
   const allResults = collectedResults.length > 0 ? collectedResults : [...results];
   const durationMs = Date.now() - startTime;
+  const outputDir = config2.outputDir ? path48.resolve(config2.outputDir) : void 0;
+  const artifacts = outputDir ? await writeArtifactsFromResults(allResults, outputDir, {
+    evalFile: config2.specFile ? testFilePath : "",
+    experiment: config2.experiment,
+    sourceTests: materialized.tests
+  }).then(({ benchmarkPath, indexPath, timingPath }) => ({
+    runDir: outputDir,
+    benchmarkPath,
+    indexPath,
+    timingPath
+  })) : void 0;
   return {
     results: allResults,
-    summary: computeSummary(allResults, durationMs, config2.threshold)
+    summary: computeSummary(allResults, durationMs, config2.threshold),
+    artifacts
   };
 }
 async function materializeEvalConfig(config2, options) {
   const baseDir = options?.baseDir ?? process.cwd();
   const repoRoot = options?.repoRoot ?? await findGitRoot(baseDir) ?? baseDir;
-  const testFilePath = config2.specFile ? path47.resolve(baseDir, config2.specFile) : path47.join(baseDir, "__programmatic__.yaml");
+  const testFilePath = config2.specFile ? path48.resolve(baseDir, config2.specFile) : path48.join(baseDir, "__programmatic__.yaml");
   const effectiveFilter = options?.filter ?? config2.filter;
   if (config2.specFile) {
     const suite = await loadTestSuite(testFilePath, repoRoot, {
@@ -41354,7 +42820,7 @@ function convertAssertions(entries) {
 }
 function buildInlineEvalTests(config2, options) {
   const suiteWorkspace = config2.beforeAll ? { hooks: { before_all: toBeforeAllHook(config2.beforeAll) } } : void 0;
-  const derivedSuiteName = path47.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
+  const derivedSuiteName = path48.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
   const suiteName = config2.metadata?.name ?? (derivedSuiteName || "eval");
   return (config2.tests ?? []).filter((test) => !options.filter || matchesFilter4(test.id, options.filter)).map((test) => {
     const isConversation = test.mode === "conversation" || test.turns && test.turns.length > 0;
@@ -41450,10 +42916,10 @@ function computeSummary(results, durationMs, threshold = DEFAULT_THRESHOLD) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path47.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path48.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path47.join(dir, candidate);
+      const targetsPath = path48.join(dir, candidate);
       if (!existsSync7(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -41470,7 +42936,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path47.join(dir, ".env");
+    const envPath = path48.join(dir, ".env");
     if (existsSync7(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
@@ -41496,7 +42962,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
 }
 var EXPORT_NAMES = ["default", "config", "evalConfig"];
 async function loadTsEvalFile(filePath) {
-  const absolutePath = path48.resolve(filePath);
+  const absolutePath = path49.resolve(filePath);
   const moduleUrl = pathToFileURL2(absolutePath).href;
   const module = await import(moduleUrl);
   let config2;
@@ -41518,7 +42984,7 @@ async function loadTsEvalSuite(filePath, repoRoot, options) {
   const { config: config2, filePath: absolutePath } = await loadTsEvalFile(filePath);
   const materialized = await materializeEvalConfig(config2, {
     repoRoot,
-    baseDir: path48.dirname(absolutePath),
+    baseDir: path49.dirname(absolutePath),
     filter: options?.filter,
     category: options?.category
   });
@@ -41718,7 +43184,7 @@ export {
   formatReplayLookupKey,
   replayFixtureRecordToProviderResponse,
   buildReplayFixtureRecord,
-  TRACE_ENVELOPE_SCHEMA_VERSION,
+  EXECUTION_TRACE_SCHEMA_VERSION,
   TraceEnvelopeEvalWireSchema,
   TraceEnvelopeReplayWireSchema,
   TraceEnvelopeSpanStatusWireSchema,
@@ -41735,9 +43201,12 @@ export {
   toTraceEnvelopeWire,
   fromTraceEnvelopeWire,
   traceEnvelopeToMessages,
+  traceEnvelopeToTranscriptMessages,
+  traceEnvelopeToToolTrajectoryView,
   traceEnvelopeToTraceSummary,
   traceEnvelopeToTraceArtifact,
   getTraceEnvelopeSummary,
+  traceEnvelopeToOtlpJson,
   readTraceEnvelopeReplayRecords,
   findTraceEnvelopeReplayRecord,
   traceEnvelopeReplayRecordToProviderResponse,
@@ -41804,8 +43273,31 @@ export {
   loadEvalCaseById,
   runEvaluation,
   runEvalCase,
+  toTranscriptJsonLines,
+  traceToTranscriptJsonLines,
+  traceFromTranscriptJsonLines,
+  groupTranscriptJsonLines,
+  readTranscriptJsonl,
+  readTranscriptFile,
+  ResultRowSchemaError,
+  normalizeResultRow,
+  RESULT_INDEX_FILENAME,
+  buildTestTargetKey,
+  deduplicateByTestIdTarget,
+  aggregateRunDir,
+  buildGradingArtifact,
+  buildTimingArtifact,
+  buildBenchmarkArtifact,
+  writeInitialBenchmarkArtifact,
+  buildAggregateGradingArtifact,
+  buildIndexArtifactEntry,
+  buildResultIndexArtifact,
+  parseJsonlResults,
+  writeArtifacts,
+  writePerTestArtifacts,
+  writeArtifactsFromResults,
   evaluate,
   loadTsEvalFile,
   loadTsEvalSuite
 };
-//# sourceMappingURL=chunk-VBHHZQS6.js.map
+//# sourceMappingURL=chunk-BLXYBUU4.js.map