agentv 4.35.1 → 4.36.0-next.1

package/dist/{chunk-6QEIZ33V.js → chunk-TUTURE2B.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: path47, errorMaps, issueData } = params;
-  const fullPath = [...path47, ...issueData.path || []];
+  const { data, path: path48, errorMaps, issueData } = params;
+  const fullPath = [...path48, ...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, path47, key) {
+  constructor(parent, value, path48, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path47;
+    this._path = path48;
     this._key = key;
   }
   get path() {
@@ -4056,7 +4056,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-EW5X2RGJ.js
+// ../../packages/core/dist/chunk-GPRJDMQ6.js
 import { parse } from "yaml";
 import os from "node:os";
 import path from "node:path";
@@ -4348,7 +4348,8 @@ var KNOWN_PROVIDERS = [
   "vscode",
   "vscode-insiders",
   "agentv",
-  "transcript"
+  "transcript",
+  "replay"
 ];
 var PROVIDER_ALIASES = [
   "azure-openai",
@@ -4890,6 +4891,12 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath, op
         ...base,
         config: resolveCliConfig(parsed, env, evalFilePath)
       };
+    case "replay":
+      return {
+        kind: "replay",
+        ...base,
+        config: resolveReplayConfig(parsed, env, evalFilePath)
+      };
     default:
       return {
         kind: "cli",
@@ -5549,6 +5556,35 @@ function resolveMockConfig(target) {
   const response = typeof target.response === "string" ? target.response : void 0;
   return { response };
 }
+function resolveReplayConfig(target, env, evalFilePath) {
+  const fixtures = resolveString(target.fixtures, env, `${target.name} replay fixtures`, true);
+  const fixturesPath = evalFilePath && !path3.isAbsolute(fixtures) ? path3.resolve(path3.dirname(path3.resolve(evalFilePath)), fixtures) : path3.resolve(fixtures);
+  const sourceTarget = resolveString(
+    target.source_target,
+    env,
+    `${target.name} replay source_target`,
+    true
+  );
+  const suite = resolveOptionalString(target.suite, env, `${target.name} replay suite`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const evalPath = resolveOptionalString(target.eval_path, env, `${target.name} replay eval_path`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const variant = resolveOptionalString(target.variant, env, `${target.name} replay variant`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  return {
+    fixturesPath,
+    sourceTarget,
+    suite,
+    evalPath,
+    variant
+  };
+}
 function resolveVSCodeConfig(target, env, insiders, _evalFilePath) {
   const executableSource = target.executable;
   const waitSource = target.wait;
@@ -6087,19 +6123,20 @@ async function expandFileReferences(tests, evalFileDir) {
   return expanded;
 }
 
-// ../../packages/core/dist/chunk-7QB53OPK.js
-import path46 from "node:path";
+// ../../packages/core/dist/chunk-FQ5QRJIT.js
+import path47 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { existsSync as existsSync6 } from "node:fs";
-import path45 from "node:path";
+import path46 from "node:path";
 import micromatch4 from "micromatch";
 import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
 import path5 from "node:path";
 import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir15, readdir as readdir8, stat as stat9 } from "node:fs/promises";
-import path44 from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir16, readdir as readdir8, stat as stat9 } from "node:fs/promises";
+import path45 from "node:path";
+import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify7 } from "node:util";
 import micromatch3 from "micromatch";
 import { mkdtemp, rm, writeFile as writeFile2 } from "node:fs/promises";
@@ -6818,10 +6855,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path47) {
-  if (!path47)
+function getElementAtPath(obj, path48) {
+  if (!path48)
     return obj;
-  return path47.reduce((acc, key) => acc?.[key], obj);
+  return path48.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7141,11 +7178,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path47, issues) {
+function prefixIssues(path48, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path47);
+    iss.path.unshift(path48);
     return iss;
   });
 }
@@ -7282,7 +7319,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path47 = []) => {
+  const processError = (error41, path48 = []) => {
     var _a, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -7292,7 +7329,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path47, ...issue2.path];
+        const fullpath = [...path48, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7322,9 +7359,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path47) {
+function toDotPath(path48) {
   const segs = [];
-  for (const seg of path47) {
+  for (const seg of path48) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18754,7 +18791,7 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../packages/core/dist/chunk-7QB53OPK.js
+// ../../packages/core/dist/chunk-FQ5QRJIT.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";
@@ -18788,74 +18825,77 @@ import { mkdir as mkdir8 } from "node:fs/promises";
 import path16 from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
+import { createHash } from "node:crypto";
+import { mkdir as mkdir9, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
+import path17 from "node:path";
 import { exec as exec2 } from "node:child_process";
 import { constants as constants2, access as access2 } from "node:fs/promises";
-import path27 from "node:path";
+import path28 from "node:path";
 import { promisify as promisify4 } from "node:util";
-import { stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
-import path25 from "node:path";
+import { stat as stat5, writeFile as writeFile7 } from "node:fs/promises";
+import path26 from "node:path";
 import { constants as constants3 } from "node:fs";
-import { access as access3, mkdir as mkdir9, readdir as readdir3, rm as rm3, stat as stat3 } from "node:fs/promises";
-import path17 from "node:path";
+import { access as access3, mkdir as mkdir10, readdir as readdir3, rm as rm3, stat as stat3 } from "node:fs/promises";
 import path18 from "node:path";
 import path19 from "node:path";
-import { readFile as readFile6 } from "node:fs/promises";
 import path20 from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import path21 from "node:path";
 import { exec, spawn as spawn4 } from "node:child_process";
-import { mkdir as mkdir10, writeFile as writeFile4 } from "node:fs/promises";
-import path222 from "node:path";
+import { mkdir as mkdir11, writeFile as writeFile5 } from "node:fs/promises";
+import path23 from "node:path";
 import { promisify as promisify3 } from "node:util";
-import path21 from "node:path";
-import { copyFile, mkdir as mkdir11, readFile as readFile7, readdir as readdir4, stat as stat4, writeFile as writeFile5 } from "node:fs/promises";
+import path222 from "node:path";
+import { copyFile, mkdir as mkdir12, readFile as readFile8, readdir as readdir4, stat as stat4, writeFile as writeFile6 } from "node:fs/promises";
+import path25 from "node:path";
 import path24 from "node:path";
-import path23 from "node:path";
 import JSON5 from "json5";
-import { writeFile as writeFile7 } from "node:fs/promises";
-import path26 from "node:path";
+import { writeFile as writeFile8 } from "node:fs/promises";
+import path27 from "node:path";
 import { constants as constants32 } from "node:fs";
-import { access as access32, readFile as readFile8 } from "node:fs/promises";
-import path28 from "node:path";
+import { access as access32, readFile as readFile9 } from "node:fs/promises";
 import path29 from "node:path";
-import fg2 from "fast-glob";
 import path30 from "node:path";
+import fg2 from "fast-glob";
 import path31 from "node:path";
-import fg22 from "fast-glob";
 import path322 from "node:path";
-import fg3 from "fast-glob";
-import { cp, mkdir as mkdir13, readdir as readdir5, rm as rm4, stat as stat6 } from "node:fs/promises";
+import fg22 from "fast-glob";
 import path33 from "node:path";
+import fg3 from "fast-glob";
+import { cp, mkdir as mkdir14, readdir as readdir5, rm as rm4, stat as stat6 } from "node:fs/promises";
+import path34 from "node:path";
 import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, mkdir as mkdir14, readFile as readFile9, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile8 } from "node:fs/promises";
-import path34 from "node:path";
+import { cp as cp2, mkdir as mkdir15, readFile as readFile10, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile9 } from "node:fs/promises";
+import path35 from "node:path";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-import path35 from "node:path";
+import path36 from "node:path";
 import { promisify as promisify6 } from "node:util";
 import { readdir as readdir7, stat as stat7 } from "node:fs/promises";
-import path36 from "node:path";
-import { readFile as readFile16, stat as stat8 } from "node:fs/promises";
-import path43 from "node:path";
+import path37 from "node:path";
+import { readFile as readFile17, stat as stat8 } from "node:fs/promises";
+import path44 from "node:path";
 import micromatch2 from "micromatch";
 import { stringify as stringifyYaml } from "yaml";
-import { readFile as readFile10 } from "node:fs/promises";
-import path37 from "node:path";
 import { readFile as readFile11 } from "node:fs/promises";
-import path39 from "node:path";
+import path38 from "node:path";
+import { readFile as readFile12 } from "node:fs/promises";
+import path40 from "node:path";
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path38 from "node:path";
+import path39 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
+import { readFile as readFile14 } from "node:fs/promises";
+import path41 from "node:path";
 import { readFile as readFile13 } from "node:fs/promises";
-import path40 from "node:path";
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
+import path43 from "node:path";
+import micromatch from "micromatch";
 import { readFile as readFile15 } from "node:fs/promises";
 import path422 from "node:path";
-import micromatch from "micromatch";
-import { readFile as readFile14 } from "node:fs/promises";
-import path41 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -19469,13 +19509,14 @@ var CodeGrader = class {
       }
       return imageTmpDir;
     };
-    const materializedOutput = await materializeContentForGrader(
-      context.output,
+    const transcriptMessages = context.trace?.messages ?? context.output ?? [];
+    const materializedMessages = await materializeContentForGrader(
+      transcriptMessages,
       getImageDir
     );
-    let outputForPayload = materializedOutput;
+    let outputForPayload = context.candidate;
     let outputPath;
-    if (outputForPayload) {
+    if (outputForPayload !== null) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
         const tmpDir = await mkdtemp(join(tmpdir(), "agentv-grader-"));
@@ -19484,6 +19525,10 @@ var CodeGrader = class {
         outputForPayload = null;
       }
     }
+    const traceForPayload = context.trace ? {
+      ...context.trace,
+      messages: materializedMessages ?? context.trace.messages
+    } : null;
     const payload = {
       criteria: context.evalCase.criteria,
       expectedOutput: await materializeContentForGrader(
@@ -19491,6 +19536,8 @@ var CodeGrader = class {
         getImageDir
       ),
       output: outputForPayload,
+      answer: context.candidate,
+      messages: materializedMessages ?? [],
       outputPath,
       inputFiles: context.evalCase.file_paths,
       input: await materializeContentForGrader(
@@ -19498,7 +19545,14 @@ var CodeGrader = class {
         getImageDir
       ),
       metadata: context.evalCase.metadata ?? null,
-      trace: context.trace ?? null,
+      trace: traceForPayload,
+      traceSummary: context.trace ? {
+        eventCount: context.trace.eventCount,
+        toolCalls: context.trace.toolCalls,
+        errorCount: context.trace.errorCount,
+        toolDurations: context.trace.toolDurations,
+        llmCallCount: context.trace.llmCallCount
+      } : null,
       tokenUsage: context.tokenUsage ?? null,
       costUsd: context.costUsd ?? null,
       durationMs: context.durationMs ?? null,
@@ -21367,10 +21421,17 @@ var NORMALIZED_TRACE_EVENT_TYPES = [
   "message",
   "model_turn",
   "tool_call",
-  "tool_result"
+  "tool_result",
+  "final_response",
+  "error"
 ];
 var NORMALIZED_TOOL_STATUSES = ["ok", "error", "timeout", "cancelled", "unknown"];
 var NORMALIZED_REDACTION_LEVELS = ["none", "partial", "full"];
+var TRACE_SCHEMA_VERSION = NORMALIZED_TRAJECTORY_SCHEMA_VERSION;
+var TRACE_SOURCE_KINDS = NORMALIZED_TRACE_SOURCE_KINDS;
+var TRACE_EVENT_TYPES = NORMALIZED_TRACE_EVENT_TYPES;
+var TRACE_TOOL_STATUSES = NORMALIZED_TOOL_STATUSES;
+var TRACE_REDACTION_LEVELS = NORMALIZED_REDACTION_LEVELS;
 function omitUndefinedProperties(value) {
   return Object.fromEntries(
     Object.entries(value).filter(([, property]) => property !== void 0)
@@ -21474,6 +21535,7 @@ var NormalizedTraceEventWireSchema = external_exports.object({
   message: NormalizedTraceMessageWireSchema.optional(),
   model: NormalizedTraceModelWireSchema.optional(),
   tool: NormalizedTraceToolWireSchema.optional(),
+  error: NormalizedTraceErrorWireSchema.optional(),
   source_ref: NormalizedTraceSourceRefWireSchema.optional(),
   raw_evidence: external_exports.array(NormalizedRawEvidenceWireSchema).optional(),
   redaction: NormalizedRedactionStateWireSchema.optional(),
@@ -21492,6 +21554,18 @@ var NormalizedTrajectoryWireSchema = external_exports.object({
   ended_at: external_exports.string().optional(),
   metadata: MetadataWireSchema.optional()
 });
+var TraceRedactionStateWireSchema = NormalizedRedactionStateWireSchema;
+var TraceErrorWireSchema = NormalizedTraceErrorWireSchema;
+var TraceSourceWireSchema = NormalizedTraceSourceWireSchema;
+var TraceSessionWireSchema = NormalizedTraceSessionWireSchema;
+var TraceBranchWireSchema = NormalizedTraceBranchWireSchema;
+var TraceSourceRefWireSchema = NormalizedTraceSourceRefWireSchema;
+var TraceRawEvidenceWireSchema = NormalizedRawEvidenceWireSchema;
+var TraceMessageWireSchema = NormalizedTraceMessageWireSchema;
+var TraceModelWireSchema = NormalizedTraceModelWireSchema;
+var TraceToolWireSchema = NormalizedTraceToolWireSchema;
+var TraceEventWireSchema = NormalizedTraceEventWireSchema;
+var TraceArtifactWireSchema = NormalizedTrajectoryWireSchema;
 function toNormalizedTrajectoryWire(trajectory) {
   return NormalizedTrajectoryWireSchema.parse(
     omitUndefinedProperties({
@@ -21525,6 +21599,12 @@ function fromNormalizedTrajectoryWire(input) {
     metadata: wire.metadata
   };
 }
+function toTraceArtifactWire(artifact) {
+  return toNormalizedTrajectoryWire(artifact);
+}
+function fromTraceArtifactWire(input) {
+  return fromNormalizedTrajectoryWire(input);
+}
 function toNormalizedTraceSourceWire(source) {
   return omitUndefinedProperties({
     kind: source.kind,
@@ -21599,6 +21679,7 @@ function toNormalizedTraceEventWire(event) {
       message: event.message ? toNormalizedTraceMessageWire(event.message) : void 0,
       model: event.model ? toNormalizedTraceModelWire(event.model) : void 0,
       tool: event.tool ? toNormalizedTraceToolWire(event.tool) : void 0,
+      error: event.error ? toNormalizedTraceErrorWire(event.error) : void 0,
       source_ref: event.sourceRef ? toNormalizedTraceSourceRefWire(event.sourceRef) : void 0,
       raw_evidence: event.rawEvidence?.map(toNormalizedRawEvidenceWire),
       redaction: event.redaction,
@@ -21619,6 +21700,7 @@ function fromNormalizedTraceEventWire(event) {
     message: event.message ? fromNormalizedTraceMessageWire(event.message) : void 0,
     model: event.model ? fromNormalizedTraceModelWire(event.model) : void 0,
     tool: event.tool ? fromNormalizedTraceToolWire(event.tool) : void 0,
+    error: event.error ? fromNormalizedTraceErrorWire(event.error) : void 0,
     sourceRef: event.source_ref ? fromNormalizedTraceSourceRefWire(event.source_ref) : void 0,
     rawEvidence: event.raw_evidence?.map(fromNormalizedRawEvidenceWire),
     redaction: event.redaction,
@@ -21687,6 +21769,24 @@ function fromNormalizedTraceToolWire(tool) {
     metadata: tool.metadata
   };
 }
+function toNormalizedTraceErrorWire(error40) {
+  return omitUndefinedProperties({
+    message: error40.message,
+    name: error40.name,
+    code: error40.code,
+    stack: error40.stack,
+    metadata: error40.metadata
+  });
+}
+function fromNormalizedTraceErrorWire(error40) {
+  return {
+    message: error40.message,
+    name: error40.name,
+    code: error40.code,
+    stack: error40.stack,
+    metadata: error40.metadata
+  };
+}
 function toNormalizedTraceSourceRefWire(sourceRef) {
   return omitUndefinedProperties({
     event_id: sourceRef.eventId,
@@ -21731,6 +21831,163 @@ function fromNormalizedRawEvidenceWire(evidence) {
     metadata: evidence.metadata
   };
 }
+function sameMessageContent(first, second) {
+  if (!first || !second) return false;
+  return first.role === second.role && JSON.stringify(first.content) === JSON.stringify(second.content);
+}
+function buildTraceMessages(input, output) {
+  const outputMessages = output ?? [];
+  if (outputMessages.length === 0) {
+    return input ?? [];
+  }
+  const outputLooksLikeFullTranscript = outputMessages.some(
+    (message) => message.role === "user" || message.role === "system"
+  );
+  if (outputLooksLikeFullTranscript) {
+    return outputMessages;
+  }
+  const inputMessages = input ?? [];
+  if (inputMessages.length === 1 && outputMessages.length > 0 && sameMessageContent(inputMessages[0], outputMessages[0])) {
+    return outputMessages;
+  }
+  return [...inputMessages, ...outputMessages];
+}
+function toTraceMessage(message) {
+  return {
+    role: message.role,
+    name: message.name,
+    content: message.content,
+    tokenUsage: message.tokenUsage,
+    metadata: message.metadata
+  };
+}
+function toTraceError(error40) {
+  return typeof error40 === "string" ? { message: error40 } : error40;
+}
+function buildTraceFromMessages(options = {}) {
+  const messages = buildTraceMessages(options.input, options.output);
+  const computed = computeTraceSummary(messages);
+  const summary = options.summary ?? computed.trace;
+  const events = [];
+  let ordinal = 0;
+  for (const [messageIndex, message] of messages.entries()) {
+    const eventId = `message-${messageIndex}`;
+    events.push({
+      eventId,
+      ordinal: ordinal++,
+      type: "message",
+      timestamp: message.startTime,
+      durationMs: message.durationMs,
+      message: toTraceMessage(message),
+      metadata: { message_index: messageIndex }
+    });
+    for (const [toolIndex, toolCall] of (message.toolCalls ?? []).entries()) {
+      const toolEventId = `message-${messageIndex}-tool-${toolIndex}`;
+      events.push({
+        eventId: toolEventId,
+        parentEventId: eventId,
+        ordinal: ordinal++,
+        type: "tool_call",
+        timestamp: toolCall.startTime,
+        durationMs: toolCall.durationMs,
+        tool: {
+          name: toolCall.tool,
+          callId: toolCall.id,
+          input: toolCall.input,
+          output: toolCall.output,
+          status: "ok"
+        },
+        metadata: {
+          message_index: messageIndex,
+          tool_index: toolIndex
+        }
+      });
+      if (toolCall.output !== void 0) {
+        events.push({
+          eventId: `${toolEventId}-result`,
+          parentEventId: toolEventId,
+          ordinal: ordinal++,
+          type: "tool_result",
+          timestamp: toolCall.endTime,
+          tool: {
+            name: toolCall.tool,
+            callId: toolCall.id,
+            output: toolCall.output,
+            status: "ok"
+          },
+          metadata: {
+            message_index: messageIndex,
+            tool_index: toolIndex
+          }
+        });
+      }
+    }
+  }
+  const finalAssistantIndex = [...messages].map((message, index) => ({ message, index })).reverse().find((entry) => entry.message.role === "assistant")?.index;
+  if (finalAssistantIndex !== void 0) {
+    const finalMessage = messages[finalAssistantIndex];
+    events.push({
+      eventId: "final-response",
+      parentEventId: `message-${finalAssistantIndex}`,
+      ordinal: ordinal++,
+      type: "final_response",
+      timestamp: finalMessage.endTime ?? finalMessage.startTime ?? options.endTime,
+      message: {
+        ...toTraceMessage(finalMessage),
+        content: options.finalOutput ?? finalMessage.content
+      },
+      metadata: { message_index: finalAssistantIndex }
+    });
+  }
+  if (options.error) {
+    events.push({
+      eventId: "error",
+      ordinal: ordinal++,
+      type: "error",
+      timestamp: options.endTime,
+      error: toTraceError(options.error)
+    });
+  }
+  return {
+    schemaVersion: TRACE_SCHEMA_VERSION,
+    eventCount: summary.eventCount,
+    toolCalls: summary.toolCalls,
+    errorCount: summary.errorCount + (options.error ? 1 : 0),
+    llmCallCount: summary.llmCallCount,
+    ...summary.toolDurations ? { toolDurations: summary.toolDurations } : {},
+    messages,
+    events,
+    tokenUsage: options.tokenUsage,
+    costUsd: options.costUsd,
+    durationMs: options.durationMs,
+    startTime: options.startTime ?? computed.startTime,
+    endTime: options.endTime ?? computed.endTime,
+    metadata: {
+      ...options.provider ? { provider: options.provider } : {},
+      ...options.target ? { target: options.target } : {},
+      ...options.testId ? { eval_case_id: options.testId } : {},
+      ...options.conversationId ? { provider_session_id: options.conversationId } : {},
+      ...options.metadata
+    }
+  };
+}
+function appendErrorEventToTrace(trace, error40, metadata) {
+  return {
+    ...trace,
+    errorCount: trace.errorCount + 1,
+    events: [
+      ...trace.events,
+      {
+        eventId: `error-${trace.events.length}`,
+        ordinal: trace.events.length,
+        type: "error",
+        timestamp: trace.endTime,
+        error: toTraceError(error40),
+        metadata
+      }
+    ]
+  };
+}
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -22209,115 +22466,115 @@ var FieldAccuracyGrader = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path47, match, required: required2 = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path47);
-    const expectedValue = resolvePath(expectedData, path47);
+    const { path: path48, match, required: required2 = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path48);
+    const expectedValue = resolvePath(expectedData, path48);
     if (expectedValue === void 0) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path47}: no expected value`
+        message: `${path48}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required2) {
         return {
-          path: path47,
+          path: path48,
           score: 0,
           weight,
           hit: false,
-          message: `${path47} (required, missing)`
+          message: `${path48} (required, missing)`
         };
       }
       return {
-        path: path47,
+        path: path48,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path47}: optional field missing`
+        message: `${path48}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path47, candidateValue, expectedValue, weight);
+        return this.compareExact(path48, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path47,
+          path48,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path47, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path48, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path47,
+          path: path48,
           score: 0,
           weight,
           hit: false,
-          message: `${path47}: unknown match type "${match}"`
+          message: `${path48}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path47, candidateValue, expectedValue, weight) {
+  compareExact(path48, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         weight,
         hit: true,
-        message: path47
+        message: path48
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path48} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path47,
+      path: path48,
       score: 0,
       weight,
       hit: false,
-      message: `${path47} (value mismatch)`
+      message: `${path48} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path47, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path48, 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: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (non-numeric value)`
+        message: `${path48} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (invalid numeric value)`
+        message: `${path48} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -22330,61 +22587,61 @@ var FieldAccuracyGrader = class {
     }
     if (withinTolerance) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         weight,
         hit: true,
-        message: `${path47} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path48} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path47,
+      path: path48,
       score: 0,
       weight,
       hit: false,
-      message: `${path47} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path48} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path47, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path48, 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: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (unparseable candidate date)`
+        message: `${path48} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (unparseable expected date)`
+        message: `${path48} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         weight,
         hit: true,
-        message: path47
+        message: path48
       };
     }
     return {
-      path: path47,
+      path: path48,
       score: 0,
       weight,
       hit: false,
-      message: `${path47} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path48} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -22417,11 +22674,11 @@ var FieldAccuracyGrader = class {
     };
   }
 };
-function resolvePath(obj, path47) {
-  if (!path47 || !obj) {
+function resolvePath(obj, path48) {
+  if (!path48 || !obj) {
     return void 0;
   }
-  const parts = path47.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path48.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -22955,8 +23212,8 @@ var TokenUsageGrader = class {
     };
   }
 };
-function getNestedValue(obj, path47) {
-  const parts = path47.split(".");
+function getNestedValue(obj, path48) {
+  const parts = path48.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -27515,7 +27772,11 @@ ${prompt}` : prompt;
         env.AZURE_OPENAI_API_KEY = this.config.apiKey;
       }
       if (this.config.baseUrl) {
-        env.AZURE_OPENAI_RESOURCE_NAME = extractAzureResourceName(this.config.baseUrl);
+        if (/^https?:\/\//.test(this.config.baseUrl)) {
+          env.AZURE_OPENAI_BASE_URL = this.config.baseUrl;
+        } else {
+          env.AZURE_OPENAI_RESOURCE_NAME = extractAzureResourceName(this.config.baseUrl);
+        }
       }
     } else {
       if (this.config.apiKey) {
@@ -28774,6 +29035,399 @@ var ProviderRegistry = class {
     return factory(target);
   }
 };
+var REPLAY_FIXTURE_SCHEMA_VERSION = "agentv.replay_fixture.v1";
+var TokenUsageWireSchema2 = external_exports.object({
+  input: external_exports.number().nonnegative(),
+  output: external_exports.number().nonnegative(),
+  cached: external_exports.number().nonnegative().optional(),
+  reasoning: external_exports.number().nonnegative().optional()
+}).strict();
+var ToolCallWireSchema = external_exports.object({
+  tool: external_exports.string().min(1),
+  input: external_exports.unknown().optional(),
+  output: external_exports.unknown().optional(),
+  id: external_exports.string().optional(),
+  start_time: external_exports.string().optional(),
+  end_time: external_exports.string().optional(),
+  duration_ms: external_exports.number().nonnegative().optional()
+}).strict();
+var MessageWireSchema = external_exports.object({
+  role: external_exports.string().min(1),
+  name: external_exports.string().optional(),
+  content: external_exports.unknown().optional(),
+  tool_calls: external_exports.array(ToolCallWireSchema).optional(),
+  start_time: external_exports.string().optional(),
+  end_time: external_exports.string().optional(),
+  duration_ms: external_exports.number().nonnegative().optional(),
+  metadata: external_exports.record(external_exports.unknown()).optional(),
+  token_usage: TokenUsageWireSchema2.optional()
+}).strict();
+var ReplayFixtureWireSchema = external_exports.object({
+  schema_version: external_exports.literal(REPLAY_FIXTURE_SCHEMA_VERSION),
+  suite: external_exports.string().min(1),
+  eval_path: external_exports.string().min(1).optional(),
+  test_id: external_exports.string().min(1),
+  source_target: external_exports.string().min(1),
+  attempt: external_exports.number().int().min(0).optional(),
+  variant: external_exports.string().min(1).nullable().optional(),
+  fixture_id: external_exports.string().min(1).optional(),
+  recorded_at: external_exports.string().optional(),
+  source: external_exports.record(external_exports.unknown()).optional(),
+  redaction: external_exports.record(external_exports.unknown()).optional(),
+  output: external_exports.array(MessageWireSchema),
+  transcript: external_exports.unknown().optional(),
+  token_usage: TokenUsageWireSchema2.optional(),
+  cost_usd: external_exports.number().nonnegative().optional(),
+  duration_ms: external_exports.number().nonnegative().optional(),
+  start_time: external_exports.string().optional(),
+  end_time: external_exports.string().optional()
+}).strict();
+var appendQueues = /* @__PURE__ */ new Map();
+function fromWireRecord(wire) {
+  return {
+    schemaVersion: wire.schema_version,
+    suite: wire.suite,
+    evalPath: wire.eval_path,
+    testId: wire.test_id,
+    sourceTarget: wire.source_target,
+    attempt: wire.attempt ?? 0,
+    variant: wire.variant ?? void 0,
+    fixtureId: wire.fixture_id,
+    recordedAt: wire.recorded_at,
+    source: wire.source,
+    redaction: wire.redaction,
+    output: wire.output.map(fromWireMessage),
+    transcript: wire.transcript,
+    tokenUsage: wire.token_usage,
+    costUsd: wire.cost_usd,
+    durationMs: wire.duration_ms,
+    startTime: wire.start_time,
+    endTime: wire.end_time
+  };
+}
+function fromWireMessage(wire) {
+  return {
+    role: wire.role,
+    name: wire.name,
+    content: wire.content,
+    toolCalls: wire.tool_calls?.map(fromWireToolCall),
+    startTime: wire.start_time,
+    endTime: wire.end_time,
+    durationMs: wire.duration_ms,
+    metadata: wire.metadata,
+    tokenUsage: wire.token_usage
+  };
+}
+function fromWireToolCall(wire) {
+  return {
+    tool: wire.tool,
+    input: wire.input,
+    output: wire.output,
+    id: wire.id,
+    startTime: wire.start_time,
+    endTime: wire.end_time,
+    durationMs: wire.duration_ms
+  };
+}
+function toWireRecord(record2) {
+  const wire = {
+    schema_version: record2.schemaVersion,
+    suite: record2.suite,
+    eval_path: record2.evalPath,
+    test_id: record2.testId,
+    source_target: record2.sourceTarget,
+    attempt: record2.attempt,
+    variant: record2.variant ?? null,
+    fixture_id: record2.fixtureId,
+    recorded_at: record2.recordedAt,
+    source: record2.source,
+    redaction: record2.redaction,
+    output: record2.output.map(toWireMessage),
+    transcript: record2.transcript,
+    token_usage: record2.tokenUsage,
+    cost_usd: record2.costUsd,
+    duration_ms: record2.durationMs,
+    start_time: record2.startTime,
+    end_time: record2.endTime
+  };
+  const parsed = ReplayFixtureWireSchema.parse(dropUndefined(wire));
+  return parsed;
+}
+function toWireMessage(message) {
+  return {
+    role: message.role,
+    name: message.name,
+    content: message.content,
+    tool_calls: message.toolCalls?.map(toWireToolCall),
+    start_time: message.startTime,
+    end_time: message.endTime,
+    duration_ms: message.durationMs,
+    metadata: message.metadata,
+    token_usage: message.tokenUsage
+  };
+}
+function toWireToolCall(toolCall) {
+  return {
+    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 dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function formatZodError(error40) {
+  return error40.errors.map((issue2) => {
+    const location = issue2.path.length > 0 ? issue2.path.join(".") : "<record>";
+    return `${location}: ${issue2.message}`;
+  }).join("; ");
+}
+async function readReplayFixtureRecords(fixturesPath) {
+  let raw;
+  try {
+    raw = await readFile6(fixturesPath, "utf8");
+  } catch (error40) {
+    const reason = error40 instanceof Error ? error40.message : String(error40);
+    throw new Error(`Replay fixture file not found or unreadable: ${fixturesPath}: ${reason}`);
+  }
+  const records = [];
+  const lines = raw.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error40) {
+      const reason = error40 instanceof Error ? error40.message : String(error40);
+      throw new Error(`Invalid replay fixture JSONL at ${fixturesPath}:${i + 1}: ${reason}`);
+    }
+    const result = ReplayFixtureWireSchema.safeParse(parsed);
+    if (!result.success) {
+      throw new Error(
+        `Invalid replay fixture record at ${fixturesPath}:${i + 1}: ${formatZodError(result.error)}`
+      );
+    }
+    records.push(fromWireRecord(result.data));
+  }
+  return records;
+}
+function serializeReplayFixtureRecord(record2) {
+  return JSON.stringify(toWireRecord(record2));
+}
+async function appendReplayFixtureRecord(fixturesPath, record2) {
+  const absolutePath = path17.resolve(fixturesPath);
+  const previous = appendQueues.get(absolutePath) ?? Promise.resolve();
+  const next = previous.then(async () => {
+    await mkdir9(path17.dirname(absolutePath), { recursive: true });
+    await writeFile4(absolutePath, `${serializeReplayFixtureRecord(record2)}
+`, {
+      encoding: "utf8",
+      flag: "a"
+    });
+  });
+  appendQueues.set(
+    absolutePath,
+    next.catch(() => {
+    })
+  );
+  await next;
+}
+function findReplayFixtureRecord(records, lookup) {
+  const matches = records.filter((record2) => replayRecordMatches(record2, lookup));
+  if (matches.length === 1) {
+    return matches[0];
+  }
+  const key = formatLookupKey(lookup);
+  if (matches.length === 0) {
+    throw new Error(`Replay fixture lookup found no record for ${key}`);
+  }
+  throw new Error(`Replay fixture lookup found ${matches.length} duplicate records for ${key}`);
+}
+function replayRecordMatches(record2, lookup) {
+  if (lookup.suite && record2.suite !== lookup.suite) {
+    return false;
+  }
+  if (!lookup.suite && !lookup.evalPath) {
+    throw new Error("Replay fixture lookup requires suite or eval_path identity");
+  }
+  if (record2.evalPath && !lookup.evalPath) {
+    return false;
+  }
+  if (record2.evalPath && lookup.evalPath && !sameEvalPath(record2.evalPath, lookup.evalPath)) {
+    return false;
+  }
+  return record2.testId === lookup.testId && record2.sourceTarget === lookup.sourceTarget && record2.attempt === (lookup.attempt ?? 0) && (record2.variant ?? null) === (lookup.variant ?? null);
+}
+function normalizeEvalPath(value) {
+  return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
+}
+function sameEvalPath(recordPath, lookupPath) {
+  const record2 = normalizeEvalPath(recordPath);
+  const lookup = normalizeEvalPath(lookupPath);
+  if (record2 === lookup) {
+    return true;
+  }
+  return path17.isAbsolute(lookupPath) && lookup.endsWith(`/${record2}`);
+}
+function formatLookupKey(lookup) {
+  const parts = [
+    lookup.suite ? `suite=${lookup.suite}` : void 0,
+    lookup.evalPath ? `eval_path=${lookup.evalPath}` : void 0,
+    `test_id=${lookup.testId}`,
+    `source_target=${lookup.sourceTarget}`,
+    `attempt=${lookup.attempt ?? 0}`,
+    `variant=${lookup.variant ?? "<none>"}`
+  ].filter((part) => part !== void 0);
+  return parts.join(" ");
+}
+function replayFixtureRecordToProviderResponse(record2) {
+  return {
+    output: record2.output,
+    tokenUsage: record2.tokenUsage,
+    costUsd: record2.costUsd,
+    durationMs: record2.durationMs,
+    startTime: record2.startTime,
+    endTime: record2.endTime,
+    raw: {
+      replay_fixture: dropUndefined({
+        fixture_id: record2.fixtureId,
+        suite: record2.suite,
+        eval_path: record2.evalPath,
+        test_id: record2.testId,
+        source_target: record2.sourceTarget,
+        attempt: record2.attempt,
+        variant: record2.variant,
+        source: record2.source,
+        redaction: record2.redaction,
+        transcript: record2.transcript
+      })
+    }
+  };
+}
+function buildReplayFixtureRecord({
+  evalCase,
+  evalFilePath,
+  repoRoot,
+  target,
+  sourceTarget,
+  attempt,
+  variant,
+  response,
+  now = () => /* @__PURE__ */ new Date()
+}) {
+  const suite = evalCase.suite?.trim();
+  if (!suite) {
+    throw new Error(`Cannot record replay fixture for test '${evalCase.id}': suite is missing`);
+  }
+  const evalPath = path17.relative(repoRoot, path17.resolve(evalFilePath)).replace(/\\/g, "/");
+  const resolvedSourceTarget = sourceTarget?.trim() || target.name;
+  const fixtureId = buildFixtureId({
+    suite,
+    evalPath,
+    testId: evalCase.id,
+    sourceTarget: resolvedSourceTarget,
+    attempt,
+    variant
+  });
+  return {
+    schemaVersion: REPLAY_FIXTURE_SCHEMA_VERSION,
+    suite,
+    evalPath,
+    testId: evalCase.id,
+    sourceTarget: resolvedSourceTarget,
+    attempt,
+    variant,
+    fixtureId,
+    recordedAt: now().toISOString(),
+    source: buildSourceMetadata(target, resolvedSourceTarget),
+    output: response.output ?? [],
+    transcript: extractTranscript(response.raw),
+    tokenUsage: response.tokenUsage,
+    costUsd: response.costUsd,
+    durationMs: response.durationMs,
+    startTime: response.startTime,
+    endTime: response.endTime
+  };
+}
+function buildFixtureId(input) {
+  const stable = [
+    input.suite,
+    input.evalPath,
+    input.testId,
+    input.sourceTarget,
+    String(input.attempt),
+    input.variant ?? ""
+  ].join("\0");
+  const digest = createHash("sha256").update(stable).digest("hex").slice(0, 12);
+  return `${input.sourceTarget}-${input.testId}-${digest}`;
+}
+function buildSourceMetadata(target, sourceTarget) {
+  return dropUndefined({
+    provider: target.kind,
+    target_name: sourceTarget,
+    resolved_target: target.name,
+    model: extractModelName(target)
+  });
+}
+function extractModelName(target) {
+  const config2 = target.config;
+  if (typeof config2.model === "string") {
+    return config2.model;
+  }
+  if (typeof config2.deploymentName === "string") {
+    return config2.deploymentName;
+  }
+  return void 0;
+}
+function extractTranscript(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return void 0;
+  }
+  const transcript = raw.transcript;
+  return transcript;
+}
+var ReplayProvider = class {
+  id;
+  kind = "replay";
+  targetName;
+  supportsBatch = true;
+  config;
+  constructor(targetName, config2) {
+    this.id = `replay:${targetName}`;
+    this.targetName = targetName;
+    this.config = config2;
+  }
+  async invoke(request) {
+    const records = await readReplayFixtureRecords(this.config.fixturesPath);
+    return this.responseForRequest(records, request);
+  }
+  async invokeBatch(requests) {
+    const records = await readReplayFixtureRecords(this.config.fixturesPath);
+    return requests.map((request) => this.responseForRequest(records, request));
+  }
+  responseForRequest(records, request) {
+    const testId = request.evalCaseId;
+    if (!testId) {
+      throw new Error("Replay provider requires evalCaseId on provider requests");
+    }
+    const record2 = findReplayFixtureRecord(records, {
+      suite: this.config.suite ?? request.suite,
+      evalPath: this.config.evalPath ?? request.evalFilePath,
+      testId,
+      sourceTarget: this.config.sourceTarget,
+      attempt: request.attempt ?? 0,
+      variant: this.config.variant
+    });
+    return replayFixtureRecordToProviderResponse(record2);
+  }
+};
 async function pathExists(target) {
   try {
     await access3(target, constants3.F_OK);
@@ -28783,13 +29437,13 @@ async function pathExists(target) {
   }
 }
 async function ensureDir(target) {
-  await mkdir9(target, { recursive: true });
+  await mkdir10(target, { recursive: true });
 }
 async function readDirEntries(target) {
   const entries = await readdir3(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path17.join(target, entry.name),
+    absolutePath: path18.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -28803,7 +29457,7 @@ async function removeIfExists(target) {
   }
 }
 function pathToFileUri2(filePath) {
-  const absolutePath = path18.isAbsolute(filePath) ? filePath : path18.resolve(filePath);
+  const absolutePath = path19.isAbsolute(filePath) ? filePath : path19.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -28895,8 +29549,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file2, index) => `${index + 1}. messages/${path19.basename(file2)}`).join("\n");
-  const responseList = responseFiles.map((file2) => `"${path19.basename(file2)}"`).join(", ");
+  const requestLines = requestFiles.map((file2, index) => `${index + 1}. messages/${path20.basename(file2)}`).join("\n");
+  const responseList = responseFiles.map((file2) => `"${path20.basename(file2)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -28935,7 +29589,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile6(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile7(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -28956,7 +29610,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file2) => path20.basename(file2)).join(", ");
+    const fileList = responseFilesFinal.map((file2) => path21.basename(file2)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -28965,7 +29619,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => path20.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => path21.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -28992,7 +29646,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile6(file2, { encoding: "utf8" });
+        const content = await readFile7(file2, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -29016,7 +29670,7 @@ var DEFAULT_LOCK_NAME = "subagent.lock";
 var DEFAULT_ALIVE_FILENAME = ".alive";
 function getDefaultSubagentRoot(vscodeCmd = "code") {
   const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
-  return path21.join(getSubagentsRoot(), folder);
+  return path222.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 var execAsync3 = promisify3(exec);
@@ -29082,12 +29736,12 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = path222.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path23.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path222.join(subagentDir, ".github", "agents");
-  await mkdir10(githubAgentsDir, { recursive: true });
-  const wakeupDst = path222.join(githubAgentsDir, "wakeup.md");
-  await writeFile4(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  const githubAgentsDir = path23.join(subagentDir, ".github", "agents");
+  await mkdir11(githubAgentsDir, { recursive: true });
+  const wakeupDst = path23.join(githubAgentsDir, "wakeup.md");
+  await writeFile5(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
   });
@@ -29099,7 +29753,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path222.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path23.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -29114,27 +29768,27 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = path222.join(subagentDir, `${path222.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path222.join(subagentDir, "messages");
-  await mkdir10(messagesDir, { recursive: true });
-  const reqFile = path222.join(messagesDir, `${timestamp}_req.md`);
-  await writeFile4(reqFile, requestInstructions, { encoding: "utf8" });
+  const workspacePath = path23.join(subagentDir, `${path23.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path23.join(subagentDir, "messages");
+  await mkdir11(messagesDir, { recursive: true });
+  const reqFile = path23.join(messagesDir, `${timestamp}_req.md`);
+  await writeFile5(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${path222.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${path23.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path222.basename(subagentDir),
+    path23.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path222.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path23.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep(500);
@@ -29142,9 +29796,9 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = path222.join(subagentDir, `${path222.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path222.join(subagentDir, "messages");
-  await mkdir10(messagesDir, { recursive: true });
+  const workspacePath = path23.join(subagentDir, `${path23.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path23.join(subagentDir, "messages");
+  await mkdir11(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
@@ -29152,13 +29806,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path222.basename(subagentDir),
+    path23.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path222.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path23.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep(500);
@@ -29180,10 +29834,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path23.isAbsolute(folderPath)) {
+    if (path24.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path23.resolve(templateDir, folderPath);
+    const absolutePath = path24.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -29205,19 +29859,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path23.isAbsolute(locationPath);
+          const isAbsolute = path24.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path23.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path24.resolve(templateDir, locationPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             } else {
               const basePathEnd = locationPath.lastIndexOf("/", firstGlobIndex);
               const basePath = basePathEnd !== -1 ? locationPath.substring(0, basePathEnd) : ".";
               const patternPath = locationPath.substring(basePathEnd !== -1 ? basePathEnd : 0);
-              const resolvedPath = (path23.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path24.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -29256,7 +29910,7 @@ async function findUnlockedSubagent(subagentRoot) {
     number: Number.parseInt(entry.name.split("-")[1] ?? "", 10)
   })).filter((entry) => Number.isInteger(entry.number)).sort((a, b) => a.number - b.number);
   for (const subagent of subagents) {
-    const lockFile = path24.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path25.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -29266,7 +29920,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path24.resolve(workspaceTemplate);
+    const workspaceSrc = path25.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -29274,18 +29928,18 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile7(workspaceSrc, "utf8");
+    const templateText = await readFile8(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path24.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path24.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path24.dirname(path24.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path25.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path25.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path25.dirname(path25.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = path24.resolve(cwd);
+    const absCwd = path25.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -29293,36 +29947,36 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
       transformedContent = JSON.stringify(parsed, null, 2);
     }
   }
-  await writeFile5(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path24.join(subagentDir, "messages");
-  await mkdir11(messagesDir, { recursive: true });
+  await writeFile6(workspaceDst, transformedContent, "utf8");
+  const messagesDir = path25.join(subagentDir, "messages");
+  await mkdir12(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path24.join(subagentDir, "messages");
+  const messagesDir = path25.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir4(messagesDir);
     await Promise.all(
       files.map(async (file2) => {
-        const target = path24.join(messagesDir, file2);
+        const target = path25.join(messagesDir, file2);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path24.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path25.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
     const agentFiles = await readdir4(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path24.join(githubAgentsDir, file2)))
+      agentFiles.filter((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path25.join(githubAgentsDir, file2)))
     );
   }
-  const lockFile = path24.join(subagentDir, DEFAULT_LOCK_NAME);
-  await writeFile5(lockFile, "", { encoding: "utf8" });
+  const lockFile = path25.join(subagentDir, DEFAULT_LOCK_NAME);
+  await writeFile6(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path24.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path25.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -29342,9 +29996,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path24.join(subagentDir, ".github", "agents");
-    await mkdir11(githubAgentsDir, { recursive: true });
-    const agentFile = path24.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = path25.join(subagentDir, ".github", "agents");
+    await mkdir12(githubAgentsDir, { recursive: true });
+    const agentFile = path25.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error40) {
@@ -29361,7 +30015,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path25.resolve(promptFile);
+  const resolvedPrompt = path26.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -29377,7 +30031,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path25.resolve(attachment);
+    const resolvedPath = path26.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -29419,7 +30073,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path25.basename(subagentDir);
+    const subagentName = path26.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -29447,9 +30101,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path25.join(subagentDir, "messages");
-    const responseFileTmp = path25.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path25.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path26.join(subagentDir, "messages");
+    const responseFileTmp = path26.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path26.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -29554,7 +30208,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path25.basename(subagentDir);
+    subagentName = path26.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -29585,24 +30239,24 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path25.join(subagentDir, "messages");
+    const messagesDir = path26.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path25.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path26.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path25.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path26.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path25.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path26.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path25.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path26.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
           const reqFile = requestFiles[index];
           const tmpFile = responseTmpFiles[index];
           const finalFile = responseFilesFinal[index];
-          return writeFile6(
+          return writeFile7(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -29614,7 +30268,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await writeFile6(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await writeFile7(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -29708,7 +30362,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path26.resolve(targetRoot);
+  const targetPath = path27.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -29728,7 +30382,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path26.join(entry.absolutePath, lockName);
+      const lockFile = path27.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -29745,10 +30399,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path26.join(subagentDir, ".github", "agents");
-    const lockFile = path26.join(subagentDir, lockName);
-    const workspaceDst = path26.join(subagentDir, `${path26.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path26.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+    const lockFile = path27.join(subagentDir, lockName);
+    const workspaceDst = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path27.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -29757,8 +30411,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile7(wakeupDst, wakeupContent, "utf8");
+        await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile8(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -29768,8 +30422,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile7(wakeupDst, wakeupContent, "utf8");
+        await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile8(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -29777,8 +30431,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile7(wakeupDst, wakeupContent, "utf8");
+      await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile8(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -29786,15 +30440,15 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path26.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path26.join(subagentDir, ".github", "agents");
-    const workspaceDst = path26.join(subagentDir, `${path26.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path26.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path27.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+    const workspaceDst = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path27.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile7(wakeupDst, wakeupContent, "utf8");
+      await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile8(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -29974,7 +30628,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path27.isAbsolute(candidate) ? candidate : path27.resolve(candidate);
+    const resolved = path28.isAbsolute(candidate) ? candidate : path28.resolve(candidate);
     try {
       await access2(resolved, constants2.F_OK);
       return resolved;
@@ -30016,7 +30670,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path27.basename(absolutePath);
+    const fileName = path28.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -30037,7 +30691,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path27.resolve(attachment);
+    const absolutePath = path28.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -30045,7 +30699,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path27.isAbsolute(filePath) ? filePath : path27.resolve(filePath);
+  const absolutePath = path28.isAbsolute(filePath) ? filePath : path28.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -30058,7 +30712,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path27.resolve(attachment));
+    deduped.add(path28.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -30067,7 +30721,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path27.resolve(inputFile));
+      deduped.add(path28.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -30150,11 +30804,11 @@ async function fileExists2(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path28.resolve(filePath);
+  const absolutePath = path29.resolve(filePath);
   if (!await fileExists2(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile8(absolutePath, "utf8");
+  const raw = await readFile9(absolutePath, "utf8");
   const parsed = parseYamlValue(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -30171,11 +30825,11 @@ function listTargetNames(definitions) {
 async function discoverProviders(registry2, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path29.resolve(baseDir);
-  const root = path29.parse(dir).root;
+  let dir = path30.resolve(baseDir);
+  const root = path30.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path29.join(dir, ".agentv", "providers"));
-    dir = path29.dirname(dir);
+    candidateDirs.push(path30.join(dir, ".agentv", "providers"));
+    dir = path30.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -30191,7 +30845,7 @@ async function discoverProviders(registry2, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = path29.basename(filePath);
+    const basename = path30.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry2.has(kindName)) {
       continue;
@@ -30207,7 +30861,7 @@ async function discoverProviders(registry2, baseDir) {
 }
 function createBuiltinProviderRegistry() {
   const registry2 = new ProviderRegistry();
-  registry2.register("openai", (t) => new OpenAIProvider(t.name, t.config)).register("openrouter", (t) => new OpenRouterProvider(t.name, t.config)).register("azure", (t) => new AzureProvider(t.name, t.config)).register("anthropic", (t) => new AnthropicProvider(t.name, t.config)).register("gemini", (t) => new GeminiProvider(t.name, t.config)).register("cli", (t) => new CliProvider(t.name, t.config)).register("codex", (t) => new CodexProvider(t.name, t.config)).register("copilot-sdk", (t) => new CopilotSdkProvider(t.name, t.config)).register("copilot-cli", (t) => new CopilotCliProvider(t.name, t.config)).register("copilot-log", (t) => new CopilotLogProvider(t.name, t.config)).register("pi-coding-agent", (t) => new PiCodingAgentProvider(t.name, t.config)).register("pi-cli", (t) => new PiCliProvider(t.name, t.config)).register("claude-cli", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude-sdk", (t) => new ClaudeSdkProvider(t.name, t.config)).register("mock", (t) => new MockProvider(t.name, t.config)).register("agentv", (t) => new AgentvProvider(t.name, t.config)).register("vscode", (t) => new VSCodeProvider(t.name, t.config, "vscode")).register(
+  registry2.register("openai", (t) => new OpenAIProvider(t.name, t.config)).register("openrouter", (t) => new OpenRouterProvider(t.name, t.config)).register("azure", (t) => new AzureProvider(t.name, t.config)).register("anthropic", (t) => new AnthropicProvider(t.name, t.config)).register("gemini", (t) => new GeminiProvider(t.name, t.config)).register("cli", (t) => new CliProvider(t.name, t.config)).register("codex", (t) => new CodexProvider(t.name, t.config)).register("copilot-sdk", (t) => new CopilotSdkProvider(t.name, t.config)).register("copilot-cli", (t) => new CopilotCliProvider(t.name, t.config)).register("copilot-log", (t) => new CopilotLogProvider(t.name, t.config)).register("pi-coding-agent", (t) => new PiCodingAgentProvider(t.name, t.config)).register("pi-cli", (t) => new PiCliProvider(t.name, t.config)).register("claude-cli", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude-sdk", (t) => new ClaudeSdkProvider(t.name, t.config)).register("mock", (t) => new MockProvider(t.name, t.config)).register("agentv", (t) => new AgentvProvider(t.name, t.config)).register("replay", (t) => new ReplayProvider(t.name, t.config)).register("vscode", (t) => new VSCodeProvider(t.name, t.config, "vscode")).register(
     "vscode-insiders",
     (t) => new VSCodeProvider(t.name, t.config, "vscode-insiders")
   );
@@ -30326,10 +30980,13 @@ function containsTemplateVariables(text) {
   return false;
 }
 async function executePromptTemplate(script, context, config2, timeoutMs) {
+  const messages = context.trace?.messages ?? context.output ?? [];
   const payload = {
     criteria: context.evalCase.criteria,
     expectedOutput: context.evalCase.expected_output,
-    output: context.output ?? null,
+    output: context.candidate,
+    answer: context.candidate,
+    messages,
     inputFiles: context.evalCase.file_paths,
     input: context.evalCase.input,
     metadata: context.evalCase.metadata ?? null,
@@ -30340,7 +30997,7 @@ async function executePromptTemplate(script, context, config2, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path30.dirname(scriptPath);
+  const cwd = path31.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -30622,11 +31279,11 @@ function createBuiltinRegistry() {
 async function discoverAssertions(registry2, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path31.resolve(baseDir);
-  const root = path31.parse(dir).root;
+  let dir = path322.resolve(baseDir);
+  const root = path322.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path31.join(dir, ".agentv", "assertions"));
-    dir = path31.dirname(dir);
+    candidateDirs.push(path322.join(dir, ".agentv", "assertions"));
+    dir = path322.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -30642,7 +31299,7 @@ async function discoverAssertions(registry2, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path31.basename(filePath);
+    const basename = path322.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry2.has(typeName)) {
       continue;
@@ -30661,12 +31318,12 @@ async function discoverAssertions(registry2, baseDir) {
 async function discoverGraders(registry2, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path322.resolve(baseDir);
-  const root = path322.parse(dir).root;
+  let dir = path33.resolve(baseDir);
+  const root = path33.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path322.join(dir, ".agentv", "graders"));
-    candidateDirs.push(path322.join(dir, ".agentv", "judges"));
-    dir = path322.dirname(dir);
+    candidateDirs.push(path33.join(dir, ".agentv", "graders"));
+    candidateDirs.push(path33.join(dir, ".agentv", "judges"));
+    dir = path33.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -30682,7 +31339,7 @@ async function discoverGraders(registry2, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path322.basename(filePath);
+    const basename = path33.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry2.has(typeName)) {
       continue;
@@ -30865,14 +31522,14 @@ async function isDirectory(filePath) {
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  return path33.join(root, evalRunId, caseId);
+  return path34.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
-  await mkdir13(dest, { recursive: true });
+  await mkdir14(dest, { recursive: true });
   const entries = await readdir5(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path33.join(src, entry.name);
-    const destPath = path33.join(dest, entry.name);
+    const srcPath = path34.join(src, entry.name);
+    const destPath = path34.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -30884,7 +31541,7 @@ async function copyDirectoryRecursive(src, dest) {
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = path33.resolve(templatePath);
+  const resolvedTemplatePath = path34.resolve(templatePath);
   if (!await fileExists(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -30933,7 +31590,7 @@ async function cleanupWorkspace(workspacePath) {
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  const evalDir = path33.join(root, evalRunId);
+  const evalDir = path34.join(root, evalRunId);
   if (await fileExists(evalDir)) {
     await rm4(evalDir, { recursive: true, force: true });
   }
@@ -30986,14 +31643,14 @@ function computeWorkspaceFingerprint(repos) {
   const canonical = {
     repos: [...repos].sort((a, b) => (a.path ?? "").localeCompare(b.path ?? "")).map(normalizeRepoForFingerprint)
   };
-  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return createHash2("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
-  await mkdir14(dest, { recursive: true });
+  await mkdir15(dest, { recursive: true });
   const entries = await readdir6(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path34.join(src, entry.name);
-    const destPath = path34.join(dest, entry.name);
+    const srcPath = path35.join(src, entry.name);
+    const destPath = path35.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -31026,8 +31683,8 @@ var WorkspacePoolManager = class {
   async acquireWorkspace(options) {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
-    const poolDir = path34.join(this.poolRoot, fingerprint);
-    await mkdir14(poolDir, { recursive: true });
+    const poolDir = path35.join(this.poolRoot, fingerprint);
+    await mkdir15(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
       console.warn(
@@ -31036,7 +31693,7 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = path34.join(poolDir, `slot-${i}`);
+      const slotPath = path35.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
@@ -31054,7 +31711,7 @@ var WorkspacePoolManager = class {
           poolDir
         };
       }
-      await mkdir14(slotPath, { recursive: true });
+      await mkdir15(slotPath, { recursive: true });
       if (templatePath) {
         await copyDirectoryRecursive2(templatePath, slotPath);
       }
@@ -31091,14 +31748,14 @@ var WorkspacePoolManager = class {
   async tryLock(lockPath) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        await writeFile8(lockPath, String(process.pid), { flag: "wx" });
+        await writeFile9(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code !== "EEXIST") {
           throw err;
         }
         try {
-          const pidStr = await readFile9(lockPath, "utf-8");
+          const pidStr = await readFile10(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -31123,9 +31780,9 @@ var WorkspacePoolManager = class {
    * Returns false (no drift) if metadata.json doesn't exist (first use).
    */
   async checkDrift(poolDir, fingerprint) {
-    const metadataPath = path34.join(poolDir, "metadata.json");
+    const metadataPath = path35.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile9(metadataPath, "utf-8");
+      const raw = await readFile10(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -31140,17 +31797,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile8(path34.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await writeFile9(path35.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
     const entries = await readdir6(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
-        const lockPath = path34.join(poolDir, `${entry}.lock`);
+        const lockPath = path35.join(poolDir, `${entry}.lock`);
         if (existsSync3(lockPath)) {
           try {
-            const pidStr = await readFile9(lockPath, "utf-8");
+            const pidStr = await readFile10(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -31163,12 +31820,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await rm5(path34.join(poolDir, entry), { recursive: true, force: true });
+        await rm5(path35.join(poolDir, entry), { recursive: true, force: true });
         await rm5(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await rm5(path34.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await rm5(path35.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -31179,7 +31836,7 @@ var WorkspacePoolManager = class {
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
       if (!repo.path || !repo.source) continue;
-      const repoDir = path34.join(slotPath, repo.path);
+      const repoDir = path35.join(slotPath, repo.path);
       if (!existsSync3(repoDir)) {
         continue;
       }
@@ -31319,7 +31976,7 @@ ${lines.join("\n")}`;
       }
       return;
     }
-    const targetDir = path35.join(workspacePath, repo.path);
+    const targetDir = path36.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -31416,7 +32073,7 @@ ${lines.join("\n")}`;
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
       if (!repo.path || !repo.source) continue;
-      const targetDir = path35.join(workspacePath, repo.path);
+      const targetDir = path36.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -31426,11 +32083,11 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = path36.resolve(templatePath);
+  const resolved = path37.resolve(templatePath);
   const stats = await stat7(resolved);
   if (stats.isFile()) {
     return {
-      dir: path36.dirname(resolved),
+      dir: path37.dirname(resolved),
       workspaceFile: resolved
     };
   }
@@ -31442,14 +32099,14 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: path36.join(resolved, workspaceFiles[0])
+      workspaceFile: path37.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? path36.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? path37.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -31568,14 +32225,14 @@ function isAgentSkillsFormat(parsed) {
   return Array.isArray(obj.evals);
 }
 async function loadTestsFromAgentSkills(filePath) {
-  const raw = await readFile10(filePath, "utf8");
+  const raw = await readFile11(filePath, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
     throw new Error(`Invalid Agent Skills evals.json: failed to parse JSON in '${filePath}'`);
   }
-  return parseAgentSkillsEvals(parsed, filePath, path37.dirname(path37.resolve(filePath)));
+  return parseAgentSkillsEvals(parsed, filePath, path38.dirname(path38.resolve(filePath)));
 }
 function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
   if (!isAgentSkillsFormat(parsed)) {
@@ -31613,7 +32270,7 @@ function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
       if (baseDir) {
         metadata.agent_skills_base_dir = baseDir;
         for (const file2 of evalCase.files) {
-          filePaths.push(path37.resolve(baseDir, file2));
+          filePaths.push(path38.resolve(baseDir, file2));
         }
       }
     }
@@ -31649,15 +32306,15 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file:")) {
       return fileURLToPath4(candidate);
     }
-    return path38.resolve(candidate);
+    return path39.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = path38.resolve(repoRoot);
-  let current = path38.resolve(path38.dirname(filePath));
+  const boundary = path39.resolve(repoRoot);
+  let current = path39.resolve(path39.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -31666,7 +32323,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = path38.dirname(current);
+    const parent = path39.dirname(current);
     if (parent === current) {
       break;
     }
@@ -31680,16 +32337,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = path38.resolve(root);
+    const normalized = path39.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = path38.dirname(evalPath);
+  let currentDir = path39.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = path38.dirname(currentDir);
+    const parentDir = path39.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -31707,16 +32364,16 @@ function trimLeadingSeparators2(value) {
 async function resolveFileReference3(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (path38.isAbsolute(rawValue)) {
-    potentialPaths.push(path38.normalize(rawValue));
+  if (path39.isAbsolute(rawValue)) {
+    potentialPaths.push(path39.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(path38.resolve(base, displayPath));
+    potentialPaths.push(path39.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = path38.resolve(candidate);
+    const absoluteCandidate = path39.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -31737,9 +32394,9 @@ var DEFAULT_EVAL_PATTERNS = [
 ];
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain2(evalFilePath, repoRoot);
-  const globalConfigPath = path39.join(getAgentvConfigDir(), "config.yaml");
+  const globalConfigPath = path40.join(getAgentvConfigDir(), "config.yaml");
   for (const directory of directories) {
-    const configPath = path39.join(directory, ".agentv", "config.yaml");
+    const configPath = path40.join(directory, ".agentv", "config.yaml");
     if (!await fileExists3(configPath)) {
       continue;
     }
@@ -31752,7 +32409,7 @@ async function loadConfig(evalFilePath, repoRoot) {
 }
 async function readConfigFile(configPath) {
   try {
-    const rawConfig = await readFile11(configPath, "utf8");
+    const rawConfig = await readFile12(configPath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(rawConfig), process.env);
     if (!isJsonObject(parsed)) {
       logWarning(`Invalid config.yaml format at ${configPath}`);
@@ -32102,6 +32759,14 @@ function parseResultsConfig(raw, configPath) {
     logWarning(`Invalid results.repo in ${configPath}, expected non-empty string`);
     return void 0;
   }
+  let branch;
+  if (obj.branch !== void 0) {
+    if (typeof obj.branch !== "string" || obj.branch.trim().length === 0) {
+      logWarning(`Invalid results.branch in ${configPath}, expected non-empty string`);
+      return void 0;
+    }
+    branch = obj.branch.trim();
+  }
   let resultsPath;
   if (obj.path !== void 0) {
     if (typeof obj.path !== "string" || obj.path.trim().length === 0) {
@@ -32132,6 +32797,7 @@ function parseResultsConfig(raw, configPath) {
   return {
     mode: "github",
     repo,
+    ...branch !== void 0 && { branch },
     ...resultsPath !== void 0 && { path: resultsPath },
     ...typeof obj.auto_push === "boolean" && { auto_push: obj.auto_push },
     ...branchPrefix && { branch_prefix: branchPrefix }
@@ -32168,7 +32834,7 @@ function logWarning(message) {
 var ANSI_YELLOW3 = "\x1B[33m";
 var ANSI_RESET4 = "\x1B[0m";
 async function validateCustomPromptContent(promptPath) {
-  const content = await readFile12(promptPath, "utf8");
+  const content = await readFile13(promptPath, "utf8");
   validateTemplateVariables(content, promptPath);
 }
 function validateTemplateVariables(content, source) {
@@ -32257,8 +32923,8 @@ function isTemplateReference(value) {
 }
 async function resolveAssertionTemplateReference(include, searchRoots) {
   const templateCandidates = isTemplateReference(include) ? [
-    path40.join(".agentv", "templates", `${include}.yaml`),
-    path40.join(".agentv", "templates", `${include}.yml`)
+    path41.join(".agentv", "templates", `${include}.yaml`),
+    path41.join(".agentv", "templates", `${include}.yml`)
   ] : [include];
   const attempted = [];
   for (const candidate of templateCandidates) {
@@ -32298,7 +32964,7 @@ ${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
     const cycle = [...includeContext.chain, resolved.resolvedPath].join(" -> ");
     throw new Error(`Assertion template cycle detected in '${evalId}': ${cycle}`);
   }
-  const content = await readFile13(resolved.resolvedPath, "utf8");
+  const content = await readFile14(resolved.resolvedPath, "utf8");
   const parsed = interpolateEnv(parseYamlValue(content), process.env);
   if (!isJsonObject2(parsed)) {
     throw new Error(
@@ -32311,10 +32977,10 @@ ${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
       `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} is missing a top-level assertions array`
     );
   }
-  const templateDir = path40.dirname(resolved.resolvedPath);
+  const templateDir = path41.dirname(resolved.resolvedPath);
   const nestedSearchRoots = [
     templateDir,
-    ...searchRoots.filter((root) => path40.resolve(root) !== templateDir)
+    ...searchRoots.filter((root) => path41.resolve(root) !== templateDir)
   ];
   return await expandGraderEntries(assertions, nestedSearchRoots, evalId, {
     depth: nextDepth,
@@ -32375,20 +33041,20 @@ async function collectAssertionTemplateReferencesFromValue(value, searchRoots, e
         references.push({
           kind: "assertion_template",
           displayPath: resolved.displayPath,
-          ...resolved.resolvedPath ? { resolvedPath: path40.resolve(resolved.resolvedPath) } : {}
+          ...resolved.resolvedPath ? { resolvedPath: path41.resolve(resolved.resolvedPath) } : {}
         });
         if (resolved.resolvedPath) {
           if (includeContext.chain.includes(resolved.resolvedPath)) {
             const cycle = [...includeContext.chain, resolved.resolvedPath].join(" -> ");
             throw new Error(`Assertion template cycle detected in '${evalId}': ${cycle}`);
           }
-          const content = await readFile13(resolved.resolvedPath, "utf8");
+          const content = await readFile14(resolved.resolvedPath, "utf8");
           const parsed = interpolateEnv(parseYamlValue(content), process.env);
           if (isJsonObject2(parsed) && Array.isArray(parsed.assertions)) {
-            const templateDir = path40.dirname(resolved.resolvedPath);
+            const templateDir = path41.dirname(resolved.resolvedPath);
             const nestedSearchRoots = [
               templateDir,
-              ...searchRoots.filter((root) => path40.resolve(root) !== templateDir)
+              ...searchRoots.filter((root) => path41.resolve(root) !== templateDir)
             ];
             references.push(
               ...await collectAssertionTemplateReferencesFromValue(
@@ -32574,7 +33240,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       if (cwd) {
         const resolved = await resolveFileReference3(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = path40.resolve(resolved.resolvedPath);
+          resolvedCwd = path41.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -32760,7 +33426,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference3(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = path40.resolve(resolved.resolvedPath);
+              promptPath2 = path41.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -33440,7 +34106,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       const commandPath = commandArray[commandArray.length - 1];
       const resolved = await resolveFileReference3(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), path40.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), path41.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Grader '${name}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -33455,7 +34121,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         prompt = fileRef;
         const resolved = await resolveFileReference3(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = path40.resolve(resolved.resolvedPath);
+          promptPath = path41.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error40) {
@@ -33613,7 +34279,7 @@ async function parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId)
     preprocessors.push({
       type,
       command,
-      resolvedCommand: [...command.slice(0, -1), path40.resolve(resolved.resolvedPath)]
+      resolvedCommand: [...command.slice(0, -1), path41.resolve(resolved.resolvedPath)]
     });
   }
   return preprocessors;
@@ -33708,10 +34374,10 @@ async function resolveOptionalCommandSource(command, searchRoots) {
     return void 0;
   }
   const resolved = await resolveFileReference3(candidate, searchRoots);
-  return resolved.resolvedPath ? path40.resolve(resolved.resolvedPath) : void 0;
+  return resolved.resolvedPath ? path41.resolve(resolved.resolvedPath) : void 0;
 }
 function looksLikeFilePath(value) {
-  return path40.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
+  return path41.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
 }
 function parseCommandToArgv(command) {
   if (process.platform === "win32") {
@@ -34099,7 +34765,7 @@ var IMAGE_MEDIA_TYPES = {
   ".bmp": "image/bmp"
 };
 function detectImageMediaType(filePath) {
-  const ext = path41.extname(filePath).toLowerCase();
+  const ext = path422.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
 var ANSI_YELLOW5 = "\x1B[33m";
@@ -34158,12 +34824,12 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const fileContent = (await readFile14(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+          const fileContent = (await readFile15(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
           processedContent.push({
             ...cloneJsonObject(rawSegment),
             path: displayPath,
             text: fileContent,
-            resolvedPath: path41.resolve(resolvedPath)
+            resolvedPath: path422.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -34199,7 +34865,7 @@ async function processMessages(options) {
           continue;
         }
         try {
-          const imageBuffer = await readFile14(resolvedPath);
+          const imageBuffer = await readFile15(resolvedPath);
           const base643 = imageBuffer.toString("base64");
           processedContent.push({
             type: "image",
@@ -34282,12 +34948,12 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const fileContent = (await readFile14(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            const fileContent = (await readFile15(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
             processedContent.push({
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: path41.resolve(resolvedPath)
+              resolvedPath: path422.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -34322,7 +34988,7 @@ async function processExpectedMessages(options) {
             continue;
           }
           try {
-            const imageBuffer = await readFile14(resolvedPath);
+            const imageBuffer = await readFile15(resolvedPath);
             const base643 = imageBuffer.toString("base64");
             processedContent.push({
               type: "image",
@@ -34433,7 +35099,7 @@ function matchesFilter(id, filter) {
   return typeof filter === "string" ? micromatch.isMatch(id, filter) : filter.some((pattern) => micromatch.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = path422.extname(filePath).toLowerCase();
+  const ext = path43.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -34443,9 +35109,9 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = path422.dirname(jsonlPath);
-  const base = path422.basename(jsonlPath, ".jsonl");
-  const sidecarPath = path422.join(dir, `${base}.yaml`);
+  const dir = path43.dirname(jsonlPath);
+  const base = path43.basename(jsonlPath, ".jsonl");
+  const sidecarPath = path43.join(dir, `${base}.yaml`);
   if (!await fileExists3(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
@@ -34453,7 +35119,7 @@ async function loadSidecarMetadata(jsonlPath, verbose) {
     return {};
   }
   try {
-    const content = await readFile15(sidecarPath, "utf8");
+    const content = await readFile16(sidecarPath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!isJsonObject(parsed)) {
       logWarning4(`Invalid sidecar metadata format in ${sidecarPath}`);
@@ -34494,13 +35160,13 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path422.resolve(evalFilePath);
+  const absoluteTestPath = path43.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
-  const rawFile = await readFile15(absoluteTestPath, "utf8");
+  const rawFile = await readFile16(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackSuiteName = path422.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackSuiteName = path43.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
   const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm-grader";
   const globalExecution = sidecar.execution;
@@ -34906,8 +35572,8 @@ function interpolateRawEvalCase(raw, vars) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path43.resolve(testFilePath);
-    const content = await readFile16(absolutePath, "utf8");
+    const absolutePath = path44.resolve(testFilePath);
+    const content = await readFile17(absolutePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!isJsonObject(parsed)) {
       return {};
@@ -34931,7 +35597,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-EQJX3OLT-THE7D3GR.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-4DU65XGW-YM47FFG2.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
@@ -34966,7 +35632,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromAgentSkills(evalFilePath);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-EQJX3OLT-THE7D3GR.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-4DU65XGW-YM47FFG2.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -34977,11 +35643,11 @@ var loadEvalCases = loadTests;
 async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path43.resolve(evalFilePath);
+  const absoluteTestPath = path44.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config2 = await loadConfig(absoluteTestPath, repoRootPath);
-  const rawFile = await readFile16(absoluteTestPath, "utf8");
+  const rawFile = await readFile17(absoluteTestPath, "utf8");
   const rawParsed = parseYamlValue(rawFile);
   const rawCaseSnapshots = buildRawInlineTestSnapshots(rawParsed);
   const interpolated = interpolateEnv(rawParsed, process.env);
@@ -34990,7 +35656,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   }
   const suite = interpolated;
   const suiteNameFromFile = asString5(suite.name)?.trim();
-  const fallbackSuiteName = path43.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
+  const fallbackSuiteName = path44.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
   const suiteName = suiteNameFromFile && suiteNameFromFile.length > 0 ? suiteNameFromFile : fallbackSuiteName;
   const rawTestCases = resolveTests(suite);
   const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm-grader";
@@ -35000,10 +35666,10 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     "<suite>",
     absoluteTestPath
   );
-  const evalFileDir = path43.dirname(absoluteTestPath);
+  const evalFileDir = path44.dirname(absoluteTestPath);
   let expandedTestCases;
   if (typeof rawTestCases === "string") {
-    const externalPath = path43.resolve(evalFileDir, rawTestCases);
+    const externalPath = path44.resolve(evalFileDir, rawTestCases);
     let isDir = false;
     try {
       const pathStat = await stat8(externalPath);
@@ -35307,7 +35973,7 @@ function collectInputSourceReferences(inputMessages) {
       references.push({
         kind: "input_file",
         displayPath,
-        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path43.resolve(segment.resolvedPath) } : {}
+        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path44.resolve(segment.resolvedPath) } : {}
       });
     }
   }
@@ -35380,7 +36046,7 @@ function collectSingleGraderSourceReferences(evaluator) {
       references.push({
         kind: "code_grader_command",
         displayPath: evaluator.aggregator.path,
-        resolvedPath: path43.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
+        resolvedPath: path44.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
         graderName: evaluator.name
       });
     } else if (evaluator.aggregator.type === "llm-grader" && evaluator.aggregator.promptPath) {
@@ -35413,9 +36079,9 @@ function dedupeSourceReferences(references) {
   return deduped;
 }
 function toPortableRelativePath(root, candidate) {
-  const relative = path43.relative(root, candidate);
-  if (relative && !relative.startsWith("..") && !path43.isAbsolute(relative)) {
-    return relative.split(path43.sep).join("/");
+  const relative = path44.relative(root, candidate);
+  if (relative && !relative.startsWith("..") && !path44.isAbsolute(relative)) {
+    return relative.split(path44.sep).join("/");
   }
   return void 0;
 }
@@ -35469,8 +36135,8 @@ function parseWorkspaceScriptConfig(raw, evalFileDir) {
   if (!command) return void 0;
   const timeoutMs = typeof obj.timeout_ms === "number" ? obj.timeout_ms : void 0;
   let cwd = typeof obj.cwd === "string" ? obj.cwd : void 0;
-  if (cwd && !path43.isAbsolute(cwd)) {
-    cwd = path43.resolve(evalFileDir, cwd);
+  if (cwd && !path44.isAbsolute(cwd)) {
+    cwd = path44.resolve(evalFileDir, cwd);
   }
   const config2 = { command };
   if (timeoutMs !== void 0) {
@@ -35508,10 +36174,10 @@ function parseWorkspaceHooksConfig(raw, evalFileDir) {
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path43.resolve(evalFileDir, raw);
+    const workspaceFilePath = path44.resolve(evalFileDir, raw);
     let content;
     try {
-      content = await readFile16(workspaceFilePath, "utf8");
+      content = await readFile17(workspaceFilePath, "utf8");
     } catch {
       throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
     }
@@ -35521,7 +36187,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
       );
     }
-    const workspaceFileDir = path43.dirname(workspaceFilePath);
+    const workspaceFileDir = path44.dirname(workspaceFilePath);
     const resolvedWorkspace = parseWorkspaceConfig(parsed, workspaceFileDir);
     if (resolvedWorkspace) {
       return { ...resolvedWorkspace, workspaceFileDir };
@@ -35555,8 +36221,8 @@ function parseWorkspaceConfig(raw, evalFileDir) {
     throw new Error("workspace.static has been removed. Use workspace.mode='static'.");
   }
   let template = typeof obj.template === "string" ? obj.template : void 0;
-  if (template && !path43.isAbsolute(template)) {
-    template = path43.resolve(evalFileDir, template);
+  if (template && !path44.isAbsolute(template)) {
+    template = path44.resolve(evalFileDir, template);
   }
   const isolation = obj.isolation === "shared" || obj.isolation === "per_test" ? obj.isolation : void 0;
   const repos = Array.isArray(obj.repos) ? obj.repos.map(parseRepoConfig).filter(Boolean) : void 0;
@@ -35695,6 +36361,9 @@ ${detailBlock}${ANSI_RESET8}`);
 }
 var execFileAsync3 = promisify7(execFile3);
 var WORKSPACE_GIT_TIMEOUT_MS = 3e5;
+function pathFromRoot(root) {
+  return root instanceof URL ? fileURLToPath5(root) : String(root);
+}
 function classifyQualityStatus(score, threshold = DEFAULT_THRESHOLD) {
   return score >= threshold ? "ok" : "quality_failure";
 }
@@ -35747,7 +36416,7 @@ function workspaceGitEnv() {
   };
 }
 async function resetWorkspaceRoot(workspacePath, resetMode, baselineRef) {
-  if (!existsSync5(path44.join(workspacePath, ".git"))) {
+  if (!existsSync5(path45.join(workspacePath, ".git"))) {
     return false;
   }
   const cleanFlag = resetMode === "strict" ? "-fdx" : "-fd";
@@ -35790,18 +36459,18 @@ function validateDependencyGraph(tests) {
   }
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
-  function visit(id, path47) {
+  function visit(id, path48) {
     if (visiting.has(id)) {
-      const cycle = [...path47.slice(path47.indexOf(id)), id];
+      const cycle = [...path48.slice(path48.indexOf(id)), id];
       throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
     }
     if (visited.has(id)) return;
     visiting.add(id);
-    path47.push(id);
+    path48.push(id);
     for (const dep of depMap.get(id) ?? []) {
-      visit(dep, path47);
+      visit(dep, path48);
     }
-    path47.pop();
+    path48.pop();
     visiting.delete(id);
     visited.add(id);
   }
@@ -35890,8 +36559,10 @@ async function runEvaluation(options) {
     retainOnFailure,
     graderTarget: cliGraderTarget,
     model: cliModel,
-    threshold: scoreThreshold
+    threshold: scoreThreshold,
+    replayRecording
   } = options;
+  const repoRootPath = pathFromRoot(repoRoot);
   let useCache = options.useCache;
   if (trials && trials.count > 1 && useCache) {
     console.warn(
@@ -35981,7 +36652,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path44.dirname(path44.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path45.dirname(path45.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -36023,7 +36694,10 @@ async function runEvaluation(options) {
         agentTimeoutMs,
         targetResolver,
         availableTargets,
-        threshold: scoreThreshold
+        threshold: scoreThreshold,
+        replayRecording,
+        evalFilePath,
+        repoRoot: repoRootPath
       });
     } catch (error40) {
       if (verbose) {
@@ -36135,7 +36809,7 @@ async function runEvaluation(options) {
     const isEmpty = dirExists ? (await readdir8(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await mkdir15(configuredStaticPath, { recursive: true });
+        await mkdir16(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -36180,15 +36854,14 @@ async function runEvaluation(options) {
     }
   } else if (!isPerTestIsolation && (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length)) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await mkdir15(sharedWorkspacePath, { recursive: true });
+    await mkdir16(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
     let toDependencyResult2 = function(r) {
-      const outputText = extractLastAssistantContent(r.output);
       return {
         score: r.score,
-        output: outputText,
+        output: r.output,
         workspace_path: r.workspacePath,
         details: r.scores ? Object.fromEntries(
           r.scores.map((s) => [s.name, { score: s.score, verdict: s.verdict }])
@@ -36222,7 +36895,7 @@ async function runEvaluation(options) {
     };
     var toDependencyResult = toDependencyResult2, checkDependencies = checkDependencies2, extractEvaluationCostUsd = extractEvaluationCostUsd2;
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = path44.join(sharedWorkspacePath, path44.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = path45.join(sharedWorkspacePath, path45.basename(suiteWorkspaceFile));
       try {
         await stat9(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
@@ -36238,7 +36911,7 @@ async function runEvaluation(options) {
         if (needsPerRepoCheck) {
           for (const repo of suiteWorkspace.repos) {
             if (!repo.path || !repo.source) continue;
-            const targetDir = path44.join(sharedWorkspacePath, repo.path);
+            const targetDir = path45.join(sharedWorkspacePath, repo.path);
             if (existsSync5(targetDir)) {
               setupLog(`reusing existing repo at: ${targetDir}`);
               continue;
@@ -36427,6 +37100,7 @@ async function runEvaluation(options) {
       const workerId = nextWorkerId++;
       workerIdByEvalId.set(evalCase.id, workerId);
       if (runBudgetTracker?.isExceeded()) {
+        const errorMessage = `Run budget exceeded ($${runBudgetTracker.currentCostUsd.toFixed(4)} / $${runBudgetTracker.budgetCapUsd.toFixed(4)})`;
         const budgetResult = {
           timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
           testId: evalCase.id,
@@ -36434,15 +37108,24 @@ async function runEvaluation(options) {
           category: evalCase.category,
           score: 0,
           assertions: [],
-          output: [],
+          output: errorMessage,
+          trace: buildTraceFromMessages({
+            input: evalCase.input,
+            output: [{ role: "assistant", content: errorMessage }],
+            finalOutput: errorMessage,
+            target: target.name,
+            testId: evalCase.id,
+            conversationId: evalCase.conversation_id,
+            error: errorMessage
+          }),
           target: target.name,
-          error: `Run budget exceeded ($${runBudgetTracker.currentCostUsd.toFixed(4)} / $${runBudgetTracker.budgetCapUsd.toFixed(4)})`,
+          error: errorMessage,
           budgetExceeded: true,
           executionStatus: "execution_error",
           failureStage: "setup",
           failureReasonCode: "budget_exceeded",
           executionError: {
-            message: `Run budget exceeded ($${runBudgetTracker.currentCostUsd.toFixed(4)} / $${runBudgetTracker.budgetCapUsd.toFixed(4)})`,
+            message: errorMessage,
             stage: "setup"
           }
         };
@@ -36463,6 +37146,7 @@ async function runEvaluation(options) {
         return budgetResult;
       }
       if (budgetUsd !== void 0 && budgetExhausted) {
+        const errorMessage = `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${budgetUsd.toFixed(4)})`;
         const budgetResult = {
           timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
           testId: evalCase.id,
@@ -36470,15 +37154,24 @@ async function runEvaluation(options) {
           category: evalCase.category,
           score: 0,
           assertions: [],
-          output: [],
+          output: errorMessage,
+          trace: buildTraceFromMessages({
+            input: evalCase.input,
+            output: [{ role: "assistant", content: errorMessage }],
+            finalOutput: errorMessage,
+            target: target.name,
+            testId: evalCase.id,
+            conversationId: evalCase.conversation_id,
+            error: errorMessage
+          }),
           target: target.name,
-          error: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${budgetUsd.toFixed(4)})`,
+          error: errorMessage,
           budgetExceeded: true,
           executionStatus: "execution_error",
           failureStage: "setup",
           failureReasonCode: "budget_exceeded",
           executionError: {
-            message: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${budgetUsd.toFixed(4)})`,
+            message: errorMessage,
             stage: "setup"
           }
         };
@@ -36507,7 +37200,16 @@ async function runEvaluation(options) {
           category: evalCase.category,
           score: 0,
           assertions: [],
-          output: [],
+          output: errorMsg,
+          trace: buildTraceFromMessages({
+            input: evalCase.input,
+            output: [{ role: "assistant", content: errorMsg }],
+            finalOutput: errorMsg,
+            target: target.name,
+            testId: evalCase.id,
+            conversationId: evalCase.conversation_id,
+            error: errorMsg
+          }),
           target: target.name,
           error: errorMsg,
           executionStatus: "execution_error",
@@ -36572,6 +37274,9 @@ async function runEvaluation(options) {
           verbose,
           threshold: scoreThreshold,
           targetHooks: options.targetHooks,
+          replayRecording,
+          evalFilePath,
+          repoRoot: repoRootPath,
           ...depResults && Object.keys(depResults).length > 0 ? { dependencyResults: depResults } : {}
         };
         let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
@@ -36653,7 +37358,16 @@ async function runEvaluation(options) {
                   category: evalCase.category,
                   score: 0,
                   assertions: [],
-                  output: [],
+                  output: errorMsg,
+                  trace: buildTraceFromMessages({
+                    input: evalCase.input,
+                    output: [{ role: "assistant", content: errorMsg }],
+                    finalOutput: errorMsg,
+                    target: target.name,
+                    testId: evalCase.id,
+                    conversationId: evalCase.conversation_id,
+                    error: errorMsg
+                  }),
                   target: target.name,
                   error: errorMsg,
                   executionStatus: "execution_error",
@@ -36803,7 +37517,10 @@ async function runBatchEvaluation(options) {
     agentTimeoutMs,
     targetResolver,
     availableTargets,
-    threshold: batchThreshold
+    threshold: batchThreshold,
+    replayRecording,
+    evalFilePath,
+    repoRoot
   } = options;
   const promptInputsList = [];
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
@@ -36817,7 +37534,9 @@ async function runBatchEvaluation(options) {
       question: promptInputs.question,
       systemPrompt: promptInputs.systemMessage,
       inputFiles: evalCase.file_paths,
-      evalCaseId: evalCase.id
+      evalCaseId: evalCase.id,
+      suite: evalCase.suite,
+      evalFilePath
     };
   });
   const batchResponse = await provider.invokeBatch?.(batchRequests);
@@ -36845,6 +37564,16 @@ async function runBatchEvaluation(options) {
     const evalCase = evalCases[i];
     const promptInputs = promptInputsList[i];
     const providerResponse = batchResponse[i];
+    await maybeRecordReplayFixture({
+      replayRecording,
+      evalCase,
+      evalFilePath,
+      repoRoot,
+      target,
+      attempt: 0,
+      response: providerResponse,
+      nowFn
+    });
     const output = providerResponse.output;
     const hasExecutionMetrics = providerResponse.tokenUsage !== void 0 || providerResponse.costUsd !== void 0 || providerResponse.durationMs !== void 0;
     const computed = output ? computeTraceSummary(output) : hasExecutionMetrics ? { trace: { eventCount: 0, toolCalls: {}, errorCount: 0 } } : void 0;
@@ -36892,6 +37621,10 @@ async function runBatchEvaluation(options) {
       if (providerError) {
         result = {
           ...result,
+          trace: appendErrorEventToTrace(result.trace, providerError, {
+            failure_stage: "agent",
+            failure_reason_code: "provider_error"
+          }),
           error: providerError,
           executionStatus: "execution_error",
           failureStage: "agent",
@@ -36950,6 +37683,27 @@ async function runBatchEvaluation(options) {
   }
   return results;
 }
+async function maybeRecordReplayFixture(options) {
+  const { replayRecording, evalCase, evalFilePath, repoRoot, target, attempt, response, nowFn } = options;
+  if (!replayRecording || target.kind === "replay") {
+    return;
+  }
+  if (!evalFilePath || !repoRoot) {
+    throw new Error("Replay recording requires evalFilePath and repoRoot");
+  }
+  const record2 = buildReplayFixtureRecord({
+    evalCase,
+    evalFilePath,
+    repoRoot,
+    target,
+    sourceTarget: replayRecording.sourceTarget,
+    attempt,
+    variant: replayRecording.variant,
+    response,
+    now: nowFn
+  });
+  await appendReplayFixtureRecord(replayRecording.fixturesPath, record2);
+}
 async function runEvalCase(options) {
   const {
     evalCase,
@@ -36978,7 +37732,10 @@ async function runEvalCase(options) {
     evalDir,
     verbose,
     threshold: caseThreshold,
-    dependencyResults
+    dependencyResults,
+    replayRecording,
+    evalFilePath,
+    repoRoot
   } = options;
   const setupDebug = process.env.AGENTV_SETUP_DEBUG === "1";
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
@@ -37020,7 +37777,7 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = path44.join(workspacePath, path44.basename(caseWorkspaceFile));
+        const copiedFile = path45.join(workspacePath, path45.basename(caseWorkspaceFile));
         try {
           await stat9(copiedFile);
           caseWorkspaceFile = copiedFile;
@@ -37030,7 +37787,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await mkdir15(workspacePath, { recursive: true });
+      await mkdir16(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
@@ -37082,10 +37839,10 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = path44.resolve(baseDir, relPath);
-          const destPath = path44.resolve(workspacePath, relPath);
+          const srcPath = path45.resolve(baseDir, relPath);
+          const destPath = path45.resolve(workspacePath, relPath);
           try {
-            await mkdir15(path44.dirname(destPath), { recursive: true });
+            await mkdir16(path45.dirname(destPath), { recursive: true });
             await copyFile2(srcPath, destPath);
           } catch (error40) {
             const message = error40 instanceof Error ? error40.message : String(error40);
@@ -37277,7 +38034,8 @@ async function runEvalCase(options) {
       verbose,
       threshold: evalCase.threshold ?? caseThreshold,
       targetResolver,
-      availableTargets
+      availableTargets,
+      evalFilePath
     });
     if (workspacePath && !isSharedWorkspace) {
       const shouldRetain = conversationResult.executionStatus === "ok" ? retainOnSuccess === "keep" || keepWorkspaces : retainOnFailure === "keep" || !forceCleanup && !keepWorkspaces;
@@ -37301,6 +38059,7 @@ async function runEvalCase(options) {
         target,
         promptInputs,
         attempt,
+        evalFilePath,
         agentTimeoutMs,
         signal,
         cwd: workspacePath,
@@ -37331,6 +38090,7 @@ async function runEvalCase(options) {
           target,
           promptInputs,
           attempt: 0,
+          evalFilePath,
           agentTimeoutMs,
           signal,
           cwd: workspacePath,
@@ -37366,6 +38126,19 @@ async function runEvalCase(options) {
     }
     return errorResult;
   }
+  const responseWasCached = cachedResponse !== void 0 && providerResponse === cachedResponse;
+  if (!responseWasCached) {
+    await maybeRecordReplayFixture({
+      replayRecording,
+      evalCase,
+      evalFilePath,
+      repoRoot,
+      target: targetUsed ? { ...target, name: targetUsed } : target,
+      attempt,
+      response: providerResponse,
+      nowFn
+    });
+  }
   if (cacheKey && cache && !cachedResponse) {
     await cache.set(cacheKey, providerResponse);
   }
@@ -37512,6 +38285,10 @@ ${providerFileChanges}` : providerFileChanges;
       ...result,
       ...targetUsedField,
       evalRun,
+      trace: appendErrorEventToTrace(result.trace, providerError, {
+        failure_stage: "agent",
+        failure_reason_code: "provider_error"
+      }),
       error: providerError,
       executionStatus,
       failureStage: "agent",
@@ -37525,6 +38302,10 @@ ${providerFileChanges}` : providerFileChanges;
       ...targetUsedField,
       score: 0,
       evalRun,
+      trace: appendErrorEventToTrace(result.trace, skippedEvaluatorError, {
+        failure_stage: "evaluator",
+        failure_reason_code: "evaluator_error"
+      }),
       error: skippedEvaluatorError,
       executionStatus,
       failureStage: "evaluator",
@@ -37689,6 +38470,23 @@ async function evaluateCandidate(options) {
     threshold: evalThreshold,
     dependencyResults
   } = options;
+  const input = buildResultInput(promptInputs);
+  const outputMessages = output ?? [{ role: "assistant", content: candidate }];
+  const evaluationTrace = buildTraceFromMessages({
+    input,
+    output: outputMessages,
+    summary: trace,
+    finalOutput: candidate,
+    tokenUsage,
+    costUsd,
+    durationMs,
+    startTime,
+    endTime,
+    provider: provider.kind,
+    target: target.name,
+    testId: evalCase.id,
+    conversationId: evalCase.conversation_id
+  });
   const gradeTimestamp = nowFn();
   const { score, scores } = await runEvaluatorsForCase({
     evalCase,
@@ -37703,7 +38501,7 @@ async function evaluateCandidate(options) {
     graderProvider,
     agentTimeoutMs,
     output,
-    trace,
+    trace: evaluationTrace,
     costUsd,
     durationMs,
     tokenUsage,
@@ -37743,7 +38541,6 @@ async function evaluateCandidate(options) {
     ...lmRequest ? { lm: lmRequest } : {},
     ...evaluatorRequest ? { evaluator: evaluatorRequest } : {}
   } : void 0;
-  const input = buildResultInput(promptInputs);
   return {
     timestamp: completedAt.toISOString(),
     testId: evalCase.id,
@@ -37760,9 +38557,9 @@ async function evaluateCandidate(options) {
     endTime,
     requests,
     input,
-    output: output ?? [{ role: "assistant", content: candidate }],
+    output: candidate,
     scores,
-    trace,
+    trace: evaluationTrace,
     fileChanges,
     executionStatus: classifyQualityStatus(score.score, evalThreshold)
   };
@@ -37925,7 +38722,7 @@ async function runEvaluatorList(options) {
     dockerConfig,
     dependencyResults
   };
-  const evalFileDir = evalCase.file_paths[0] ? path44.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? path45.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -38082,7 +38879,8 @@ async function runConversationMode(options) {
     verbose,
     threshold,
     targetResolver,
-    availableTargets
+    availableTargets,
+    evalFilePath
   } = options;
   const turns = evalCase.turns;
   const aggregation = evalCase.aggregation ?? "mean";
@@ -38120,6 +38918,8 @@ async function runConversationMode(options) {
         question: userContent,
         chatPrompt: chatPromptForProvider,
         evalCaseId: `${evalCase.id}/turn-${turnIndex}`,
+        suite: evalCase.suite,
+        evalFilePath,
         signal,
         cwd: workspacePath,
         workspaceFile: caseWorkspaceFile,
@@ -38257,8 +39057,19 @@ async function runConversationMode(options) {
     role: m.role,
     content: m.content
   }));
-  const flatAssertions = allResultScores.flatMap((s) => [...s.assertions]);
   const totalDurationMs = Date.now() - caseStartMs;
+  const finalOutput = extractLastAssistantContent(outputMessages);
+  const trace = buildTraceFromMessages({
+    input: evalCase.input,
+    output: outputMessages,
+    finalOutput,
+    durationMs: totalDurationMs,
+    provider: provider.kind,
+    target: target.name,
+    testId: evalCase.id,
+    conversationId: evalCase.conversation_id
+  });
+  const flatAssertions = allResultScores.flatMap((s) => [...s.assertions]);
   return {
     timestamp: nowFn().toISOString(),
     testId: evalCase.id,
@@ -38267,7 +39078,8 @@ async function runConversationMode(options) {
     score: finalScore,
     assertions: flatAssertions,
     target: target.name,
-    output: outputMessages,
+    output: finalOutput,
+    trace,
     scores: allResultScores,
     executionStatus: classifyQualityStatus(finalScore, threshold ?? DEFAULT_THRESHOLD),
     input: evalCase.input.map((m) => ({
@@ -38339,6 +39151,7 @@ async function invokeProvider(provider, options) {
     evalCase,
     promptInputs,
     attempt,
+    evalFilePath,
     agentTimeoutMs,
     signal,
     cwd,
@@ -38359,6 +39172,8 @@ async function invokeProvider(provider, options) {
       chatPrompt: promptInputs.chatPrompt,
       inputFiles: evalCase.file_paths,
       evalCaseId: evalCase.id,
+      suite: evalCase.suite,
+      evalFilePath,
       attempt,
       signal: controller.signal,
       cwd,
@@ -38400,6 +39215,16 @@ function buildErrorResult(evalCase, targetName, timestamp, error40, promptInputs
     ...lmRequest ? { lm: lmRequest } : {}
   } : void 0;
   const input = buildResultInput(promptInputs);
+  const output = `Error occurred: ${message}`;
+  const trace = buildTraceFromMessages({
+    input,
+    output: [{ role: "assistant", content: output }],
+    finalOutput: output,
+    target: targetName,
+    testId: evalCase.id,
+    conversationId: evalCase.conversation_id,
+    error: message
+  });
   return {
     timestamp: timestamp.toISOString(),
     testId: evalCase.id,
@@ -38411,7 +39236,8 @@ function buildErrorResult(evalCase, targetName, timestamp, error40, promptInputs
     target: targetName,
     requests,
     input,
-    output: [{ role: "assistant", content: `Error occurred: ${message}` }],
+    output,
+    trace,
     error: message,
     executionStatus: "execution_error",
     failureStage,
@@ -38432,7 +39258,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = createHash2("sha256");
+  const hash = createHash3("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -38654,7 +39480,7 @@ async function evaluate(config2) {
     cliNoCache: false,
     yamlCache: config2.cache === void 0 ? materialized.cache : void 0
   });
-  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path45.resolve(materialized.cachePath) : void 0) : void 0;
+  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path46.resolve(materialized.cachePath) : void 0) : void 0;
   const results = await runEvaluation({
     testFilePath,
     repoRoot,
@@ -38685,7 +39511,7 @@ async function evaluate(config2) {
 async function materializeEvalConfig(config2, options) {
   const baseDir = options?.baseDir ?? process.cwd();
   const repoRoot = options?.repoRoot ?? await findGitRoot(baseDir) ?? baseDir;
-  const testFilePath = config2.specFile ? path45.resolve(baseDir, config2.specFile) : path45.join(baseDir, "__programmatic__.yaml");
+  const testFilePath = config2.specFile ? path46.resolve(baseDir, config2.specFile) : path46.join(baseDir, "__programmatic__.yaml");
   const effectiveFilter = options?.filter ?? config2.filter;
   if (config2.specFile) {
     const suite = await loadTestSuite(testFilePath, repoRoot, {
@@ -38762,7 +39588,7 @@ function convertAssertions(entries) {
 }
 function buildInlineEvalTests(config2, options) {
   const suiteWorkspace = config2.beforeAll ? { hooks: { before_all: toBeforeAllHook(config2.beforeAll) } } : void 0;
-  const derivedSuiteName = path45.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
+  const derivedSuiteName = path46.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;
@@ -38858,10 +39684,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(path45.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path46.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path45.join(dir, candidate);
+      const targetsPath = path46.join(dir, candidate);
       if (!existsSync6(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -38878,7 +39704,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path45.join(dir, ".env");
+    const envPath = path46.join(dir, ".env");
     if (existsSync6(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
@@ -38904,7 +39730,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
 }
 var EXPORT_NAMES = ["default", "config", "evalConfig"];
 async function loadTsEvalFile(filePath) {
-  const absolutePath = path46.resolve(filePath);
+  const absolutePath = path47.resolve(filePath);
   const moduleUrl = pathToFileURL2(absolutePath).href;
   const module = await import(moduleUrl);
   let config2;
@@ -38926,7 +39752,7 @@ async function loadTsEvalSuite(filePath, repoRoot, options) {
   const { config: config2, filePath: absolutePath } = await loadTsEvalFile(filePath);
   const materialized = await materializeEvalConfig(config2, {
     repoRoot,
-    baseDir: path46.dirname(absolutePath),
+    baseDir: path47.dirname(absolutePath),
     filter: options?.filter,
     category: options?.category
   });
@@ -39034,6 +39860,11 @@ export {
   NORMALIZED_TRACE_EVENT_TYPES,
   NORMALIZED_TOOL_STATUSES,
   NORMALIZED_REDACTION_LEVELS,
+  TRACE_SCHEMA_VERSION,
+  TRACE_SOURCE_KINDS,
+  TRACE_EVENT_TYPES,
+  TRACE_TOOL_STATUSES,
+  TRACE_REDACTION_LEVELS,
   NormalizedRedactionStateWireSchema,
   NormalizedTraceErrorWireSchema,
   NormalizedTraceSourceWireSchema,
@@ -39046,8 +39877,24 @@ export {
   NormalizedTraceToolWireSchema,
   NormalizedTraceEventWireSchema,
   NormalizedTrajectoryWireSchema,
+  TraceRedactionStateWireSchema,
+  TraceErrorWireSchema,
+  TraceSourceWireSchema,
+  TraceSessionWireSchema,
+  TraceBranchWireSchema,
+  TraceSourceRefWireSchema,
+  TraceRawEvidenceWireSchema,
+  TraceMessageWireSchema,
+  TraceModelWireSchema,
+  TraceToolWireSchema,
+  TraceEventWireSchema,
+  TraceArtifactWireSchema,
   toNormalizedTrajectoryWire,
   fromNormalizedTrajectoryWire,
+  toTraceArtifactWire,
+  fromTraceArtifactWire,
+  buildTraceFromMessages,
+  appendErrorEventToTrace,
   computeTraceSummary,
   getSelectedTrajectoryEvents,
   computeTraceSummaryFromTrajectory,
@@ -39094,6 +39941,14 @@ export {
   consumePiLogEntries,
   subscribeToPiLogEntries,
   ProviderRegistry,
+  REPLAY_FIXTURE_SCHEMA_VERSION,
+  readReplayFixtureRecords,
+  serializeReplayFixtureRecord,
+  appendReplayFixtureRecord,
+  findReplayFixtureRecord,
+  replayFixtureRecordToProviderResponse,
+  buildReplayFixtureRecord,
+  ReplayProvider,
   ensureVSCodeSubagents,
   readTargetDefinitions,
   listTargetNames,
@@ -39150,4 +40005,4 @@ export {
   loadTsEvalFile,
   loadTsEvalSuite
 };
-//# sourceMappingURL=chunk-6QEIZ33V.js.map
+//# sourceMappingURL=chunk-TUTURE2B.js.map