agentv 4.42.1-next.1 → 4.42.2

package/dist/{chunk-IX5KWMMM.js → chunk-SJTHFOPH.js}

@@ -4056,7 +4056,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-3EAL7M5J.js
+// ../../packages/core/dist/chunk-Z5WVZ5VI.js
 import { parse } from "yaml";
 import os from "node:os";
 import path from "node:path";
@@ -6156,7 +6156,7 @@ async function expandFileReferences(tests, evalFileDir) {
   return expanded;
 }
 
-// ../../packages/core/dist/chunk-7VCXX25H.js
+// ../../packages/core/dist/chunk-NFFWBMIM.js
 import path50 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { existsSync as existsSync7 } from "node:fs";
@@ -6164,7 +6164,7 @@ import path49 from "node:path";
 import micromatch4 from "micromatch";
 import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
 import path5 from "node:path";
-import { createHash as createHash5, randomUUID as randomUUID10 } from "node:crypto";
+import { createHash as createHash6, randomUUID as randomUUID10 } from "node:crypto";
 import path47 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import micromatch3 from "micromatch";
@@ -18820,7 +18820,7 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../packages/core/dist/chunk-7VCXX25H.js
+// ../../packages/core/dist/chunk-NFFWBMIM.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";
@@ -18858,6 +18858,7 @@ 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 { readFile as readFile7 } from "node:fs/promises";
+import { createHash as createHash3 } from "node:crypto";
 import { createHash as createHash2 } from "node:crypto";
 import { exec as exec2 } from "node:child_process";
 import { constants as constants2, access as access2 } from "node:fs/promises";
@@ -18900,12 +18901,12 @@ import { existsSync as existsSync6 } from "node:fs";
 import { copyFile as copyFile2, mkdir as mkdir17, readdir as readdir8, stat as stat8 } from "node:fs/promises";
 import path39 from "node:path";
 import { promisify as promisify6 } from "node:util";
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
 import { cp as cp2, mkdir as mkdir15, readFile as readFile11, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile9 } from "node:fs/promises";
 import path35 from "node:path";
 import { execFile, spawn as spawn5 } from "node:child_process";
-import { createHash as createHash4, randomUUID as randomUUID9 } from "node:crypto";
+import { createHash as createHash5, randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
 import { mkdir as mkdir16, rename, rm as rm6 } from "node:fs/promises";
 import path37 from "node:path";
@@ -21870,7 +21871,7 @@ function buildTraceFromMessages(options = {}) {
           callId: toolCall.id,
           input: toolCall.input,
           output: toolCall.output,
-          status: "ok"
+          status: toolCall.status ?? "ok"
         },
         metadata: {
           message_index: messageIndex,
@@ -21888,7 +21889,7 @@ function buildTraceFromMessages(options = {}) {
             name: toolCall.tool,
             callId: toolCall.id,
             output: toolCall.output,
-            status: "ok"
+            status: toolCall.status ?? "ok"
           },
           metadata: {
             message_index: messageIndex,
@@ -22120,12 +22121,13 @@ function toolCallFromTraceArtifactEvent(event) {
     id: tool.callId,
     input: tool.input,
     output: tool.output,
+    status: tool.status,
     startTime: event.timestamp,
     endTime: eventEndIso(event),
     durationMs: event.durationMs
   };
 }
-function attachTraceArtifactToolCall(messages, eventMessageIndex, event) {
+function attachTraceArtifactToolCall(messages, eventMessageIndex, eventToolIndex, event) {
   const toolCall = toolCallFromTraceArtifactEvent(event);
   if (!toolCall) {
     return;
@@ -22141,13 +22143,17 @@ function attachTraceArtifactToolCall(messages, eventMessageIndex, event) {
   const messageIndex = parentIndex ?? fallbackIndex;
   if (messageIndex >= 0) {
     const message = messages[messageIndex];
+    const toolIndex2 = message.toolCalls?.length ?? 0;
     messages[messageIndex] = {
       ...message,
       toolCalls: [...message.toolCalls ?? [], toolCall]
     };
+    eventMessageIndex.set(event.eventId, messageIndex);
+    eventToolIndex.set(event.eventId, { messageIndex, toolIndex: toolIndex2 });
     return;
   }
   const syntheticIndex = messages.length;
+  const toolIndex = 0;
   messages.push({
     role: "assistant",
     startTime: event.timestamp,
@@ -22157,6 +22163,53 @@ function attachTraceArtifactToolCall(messages, eventMessageIndex, event) {
     toolCalls: [toolCall]
   });
   eventMessageIndex.set(event.eventId, syntheticIndex);
+  eventToolIndex.set(event.eventId, { messageIndex: syntheticIndex, toolIndex });
+}
+function findTraceArtifactToolLocation(messages, eventToolIndex, event) {
+  if (event.parentEventId) {
+    const parentLocation = eventToolIndex.get(event.parentEventId);
+    if (parentLocation) {
+      return parentLocation;
+    }
+  }
+  const callId = event.tool?.callId;
+  if (!callId) {
+    return void 0;
+  }
+  for (let messageIndex = messages.length - 1; messageIndex >= 0; messageIndex--) {
+    const toolCalls = messages[messageIndex].toolCalls ?? [];
+    const toolIndex = toolCalls.findIndex((toolCall) => toolCall.id === callId);
+    if (toolIndex >= 0) {
+      return { messageIndex, toolIndex };
+    }
+  }
+  return void 0;
+}
+function mergeTraceArtifactToolResult(messages, eventToolIndex, event) {
+  const location = findTraceArtifactToolLocation(messages, eventToolIndex, event);
+  const result = toolCallFromTraceArtifactEvent(event);
+  if (!location || !result) {
+    return;
+  }
+  const message = messages[location.messageIndex];
+  const toolCalls = [...message.toolCalls ?? []];
+  const existing = toolCalls[location.toolIndex];
+  if (!existing) {
+    return;
+  }
+  const resultEndTime = result.endTime ?? event.timestamp;
+  const endTime = existing.endTime && existing.endTime !== existing.startTime ? existing.endTime : resultEndTime;
+  toolCalls[location.toolIndex] = {
+    ...existing,
+    output: existing.output ?? result.output,
+    status: result.status ?? existing.status,
+    endTime,
+    durationMs: existing.durationMs ?? result.durationMs
+  };
+  messages[location.messageIndex] = {
+    ...message,
+    toolCalls
+  };
 }
 function mergeTraceArtifactFinalResponse(messages, eventMessageIndex, event) {
   if (!event.parentEventId || !event.message) {
@@ -22195,6 +22248,7 @@ function traceFromTraceArtifact(artifact) {
   );
   const messages = [];
   const eventMessageIndex = /* @__PURE__ */ new Map();
+  const eventToolIndex = /* @__PURE__ */ new Map();
   for (const event of events) {
     if (event.type === "message" && event.message) {
       eventMessageIndex.set(event.eventId, messages.length);
@@ -22215,7 +22269,11 @@ function traceFromTraceArtifact(artifact) {
       continue;
     }
     if (event.type === "tool_call") {
-      attachTraceArtifactToolCall(messages, eventMessageIndex, event);
+      attachTraceArtifactToolCall(messages, eventMessageIndex, eventToolIndex, event);
+      continue;
+    }
+    if (event.type === "tool_result") {
+      mergeTraceArtifactToolResult(messages, eventToolIndex, event);
     }
   }
   const computed = computeTraceSummaryFromTraceArtifact(artifact);
@@ -25122,6 +25180,7 @@ var ToolCallSchema = external_exports.object({
   input: external_exports.unknown().optional(),
   output: external_exports.unknown().optional(),
   id: external_exports.string().optional(),
+  status: external_exports.enum(["ok", "error", "timeout", "cancelled", "unknown"]).optional(),
   start_time: external_exports.string().optional(),
   end_time: external_exports.string().optional(),
   duration_ms: external_exports.number().optional()
@@ -25178,6 +25237,7 @@ function convertMessages(messages) {
       input: tc.input,
       output: tc.output,
       id: tc.id,
+      status: tc.status,
       startTime: tc.start_time,
       endTime: tc.end_time,
       durationMs: tc.duration_ms
@@ -29410,6 +29470,7 @@ var ToolCallWireSchema = external_exports.object({
   input: external_exports.unknown().optional(),
   output: external_exports.unknown().optional(),
   id: external_exports.string().optional(),
+  status: external_exports.enum(["ok", "error", "timeout", "cancelled", "unknown"]).optional(),
   start_time: external_exports.string().optional(),
   end_time: external_exports.string().optional(),
   duration_ms: external_exports.number().nonnegative().optional()
@@ -29487,6 +29548,7 @@ function fromWireToolCall(wire) {
     input: wire.input,
     output: wire.output,
     id: wire.id,
+    status: wire.status,
     startTime: wire.start_time,
     endTime: wire.end_time,
     durationMs: wire.duration_ms
@@ -29535,6 +29597,7 @@ function toWireToolCall(toolCall) {
     input: toolCall.input,
     output: toolCall.output,
     id: toolCall.id,
+    status: toolCall.status,
     start_time: toolCall.startTime,
     end_time: toolCall.endTime,
     duration_ms: toolCall.durationMs
@@ -29759,8 +29822,265 @@ function extractTranscript(raw) {
   const transcript = raw.transcript;
   return transcript;
 }
+var PROJECTION_IDENTITY_SCHEMA_VERSION = "agentv.projection_identity.v1";
+var EXPORT_DUPLICATE_POLICY_VALUES = ["skip", "update", "error"];
+var PROJECTION_IDENTITY_ISSUE_SEVERITY_VALUES = ["warning", "error"];
+var ProjectionIdentityError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(
+      `Projection identity is missing required fields: ${issues.map((i) => i.field).join(", ")}`
+    );
+    this.name = "ProjectionIdentityError";
+    this.issues = issues;
+  }
+};
+var REQUIRED_STRING_FIELDS = [
+  "runId",
+  "testId",
+  "target",
+  "sourceTarget",
+  "envelopeId",
+  "traceId",
+  "rootSpanId",
+  "projectionFormat",
+  "projectionVersion"
+];
+var DIMENSION_KEY_ORDER = [
+  "projection_format",
+  "projection_version",
+  "run_id",
+  "suite",
+  "eval_path",
+  "test_id",
+  "target",
+  "source_target",
+  "attempt",
+  "variant",
+  "envelope_id",
+  "trace_id",
+  "root_span_id"
+];
+function normalizedString(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeAttempt(value) {
+  if (value === void 0) {
+    return 0;
+  }
+  if (!Number.isInteger(value) || value < 0) {
+    throw new ProjectionIdentityError([
+      {
+        code: "invalid_attempt",
+        severity: "error",
+        field: "attempt",
+        message: "Projection identity attempt must be a non-negative integer."
+      }
+    ]);
+  }
+  return value;
+}
+function normalizeVariant(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  return normalizedString(value) ?? null;
+}
+function missingRequiredIssue(field) {
+  return {
+    code: "missing_identity_field",
+    severity: "error",
+    field,
+    message: `Projection identity requires ${field}.`
+  };
+}
+function encodeKeyValue(value) {
+  if (value === null || value === void 0) {
+    return "~";
+  }
+  return encodeURIComponent(String(value));
+}
+function dimensionEntries(dimensions) {
+  return {
+    projection_format: dimensions.projectionFormat,
+    projection_version: dimensions.projectionVersion,
+    run_id: dimensions.runId,
+    suite: dimensions.suite ?? null,
+    eval_path: dimensions.evalPath ?? null,
+    test_id: dimensions.testId,
+    target: dimensions.target,
+    source_target: dimensions.sourceTarget,
+    attempt: dimensions.attempt,
+    variant: dimensions.variant,
+    envelope_id: dimensions.envelopeId,
+    trace_id: dimensions.traceId,
+    root_span_id: dimensions.rootSpanId
+  };
+}
+function buildProjectionIdentityKey(dimensions) {
+  const entries = dimensionEntries(dimensions);
+  const body = DIMENSION_KEY_ORDER.map((key) => `${key}=${encodeKeyValue(entries[key])}`).join("|");
+  return `${PROJECTION_IDENTITY_SCHEMA_VERSION}:${body}`;
+}
+function buildProjectionIdentity(input, options) {
+  const values = {
+    runId: normalizedString(input.runId),
+    suite: normalizedString(input.suite),
+    evalPath: normalizedString(input.evalPath),
+    testId: normalizedString(input.testId),
+    target: normalizedString(input.target),
+    sourceTarget: normalizedString(input.sourceTarget) ?? normalizedString(input.target),
+    envelopeId: normalizedString(input.envelopeId),
+    traceId: normalizedString(input.traceId),
+    rootSpanId: normalizedString(input.rootSpanId),
+    projectionFormat: normalizedString(input.projectionFormat),
+    projectionVersion: normalizedString(input.projectionVersion)
+  };
+  const issues = [];
+  for (const field of REQUIRED_STRING_FIELDS) {
+    if (!values[field]) {
+      issues.push(missingRequiredIssue(field));
+    }
+  }
+  if (!values.suite && !values.evalPath) {
+    issues.push({
+      code: "missing_suite_or_eval_path",
+      severity: "warning",
+      field: "suite/evalPath",
+      message: "Projection identity is more portable when at least one of suite or evalPath is present."
+    });
+  }
+  const errors = issues.filter((issue2) => issue2.severity === "error");
+  if (errors.length > 0 && (options?.missingFieldPolicy ?? "error") === "error") {
+    throw new ProjectionIdentityError(errors);
+  }
+  const dimensions = {
+    runId: values.runId ?? "unknown",
+    suite: values.suite,
+    evalPath: values.evalPath,
+    testId: values.testId ?? "unknown",
+    target: values.target ?? "unknown",
+    sourceTarget: values.sourceTarget ?? "unknown",
+    attempt: normalizeAttempt(input.attempt),
+    variant: normalizeVariant(input.variant),
+    envelopeId: values.envelopeId ?? "unknown",
+    traceId: values.traceId ?? "unknown",
+    rootSpanId: values.rootSpanId ?? "unknown",
+    projectionFormat: values.projectionFormat ?? "unknown",
+    projectionVersion: values.projectionVersion ?? "unknown"
+  };
+  const key = buildProjectionIdentityKey(dimensions);
+  const digest = createHash2("sha256").update(key).digest("hex");
+  return {
+    schemaVersion: PROJECTION_IDENTITY_SCHEMA_VERSION,
+    id: `agentv-prj-${digest.slice(0, 32)}`,
+    key,
+    dimensions,
+    issues: issues.length > 0 ? issues : void 0
+  };
+}
+var ProjectionIdentityIssueWireSchema = external_exports.object({
+  code: external_exports.string(),
+  severity: external_exports.enum(PROJECTION_IDENTITY_ISSUE_SEVERITY_VALUES),
+  field: external_exports.string().optional(),
+  message: external_exports.string()
+}).strict();
+var ProjectionIdentityDimensionsWireSchema = external_exports.object({
+  run_id: external_exports.string(),
+  suite: external_exports.string().optional(),
+  eval_path: external_exports.string().optional(),
+  test_id: external_exports.string(),
+  target: external_exports.string(),
+  source_target: external_exports.string(),
+  attempt: external_exports.number().int().nonnegative(),
+  variant: external_exports.string().nullable(),
+  envelope_id: external_exports.string(),
+  trace_id: external_exports.string(),
+  root_span_id: external_exports.string(),
+  projection_format: external_exports.string(),
+  projection_version: external_exports.string()
+}).strict();
+var ProjectionIdentityWireSchema = external_exports.object({
+  schema_version: external_exports.literal(PROJECTION_IDENTITY_SCHEMA_VERSION),
+  id: external_exports.string(),
+  key: external_exports.string(),
+  dimensions: ProjectionIdentityDimensionsWireSchema,
+  issues: external_exports.array(ProjectionIdentityIssueWireSchema).optional()
+}).strict();
+function dropUndefined2(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function toProjectionIdentityIssueWire(issue2) {
+  return ProjectionIdentityIssueWireSchema.parse(
+    dropUndefined2({
+      code: issue2.code,
+      severity: issue2.severity,
+      field: issue2.field,
+      message: issue2.message
+    })
+  );
+}
+function fromProjectionIdentityIssueWire(issue2) {
+  return {
+    code: issue2.code,
+    severity: issue2.severity,
+    field: issue2.field,
+    message: issue2.message
+  };
+}
+function toProjectionIdentityWire(identity) {
+  return ProjectionIdentityWireSchema.parse(
+    dropUndefined2({
+      schema_version: identity.schemaVersion,
+      id: identity.id,
+      key: identity.key,
+      dimensions: {
+        run_id: identity.dimensions.runId,
+        suite: identity.dimensions.suite,
+        eval_path: identity.dimensions.evalPath,
+        test_id: identity.dimensions.testId,
+        target: identity.dimensions.target,
+        source_target: identity.dimensions.sourceTarget,
+        attempt: identity.dimensions.attempt,
+        variant: identity.dimensions.variant,
+        envelope_id: identity.dimensions.envelopeId,
+        trace_id: identity.dimensions.traceId,
+        root_span_id: identity.dimensions.rootSpanId,
+        projection_format: identity.dimensions.projectionFormat,
+        projection_version: identity.dimensions.projectionVersion
+      },
+      issues: identity.issues?.map(toProjectionIdentityIssueWire)
+    })
+  );
+}
+function fromProjectionIdentityWire(input) {
+  const wire = ProjectionIdentityWireSchema.parse(input);
+  return {
+    schemaVersion: wire.schema_version,
+    id: wire.id,
+    key: wire.key,
+    dimensions: {
+      runId: wire.dimensions.run_id,
+      suite: wire.dimensions.suite,
+      evalPath: wire.dimensions.eval_path,
+      testId: wire.dimensions.test_id,
+      target: wire.dimensions.target,
+      sourceTarget: wire.dimensions.source_target,
+      attempt: wire.dimensions.attempt,
+      variant: wire.dimensions.variant,
+      envelopeId: wire.dimensions.envelope_id,
+      traceId: wire.dimensions.trace_id,
+      rootSpanId: wire.dimensions.root_span_id,
+      projectionFormat: wire.dimensions.projection_format,
+      projectionVersion: wire.dimensions.projection_version
+    },
+    issues: wire.issues?.map(fromProjectionIdentityIssueWire)
+  };
+}
 var EXECUTION_TRACE_SCHEMA_VERSION = "agentv.trace.v1";
 var TRACE_ENVELOPE_FORMAT = "otlp_openinference_spans";
+var TRACE_ENVELOPE_PROJECTION_FORMAT = "execution_trace";
 var TRANSCRIPT_MESSAGE_EVENT_NAME = "agentv.transcript.message";
 var CAPTURE_CONTENT_VALUES = ["none", "metadata", "full"];
 var REDACTION_LEVEL_VALUES = ["none", "partial", "full"];
@@ -29862,11 +30182,17 @@ var TraceEnvelopeScoreWireSchema = external_exports.object({
   target_span_id: external_exports.string().optional(),
   evidence: AttributeMapWireSchema.optional()
 }).strict();
+var TraceEnvelopeExportMetadataWireSchema = external_exports.object({
+  duplicate_policy: external_exports.enum(["skip", "update", "error"]).optional(),
+  identity_warnings: external_exports.array(ProjectionIdentityIssueWireSchema).optional()
+}).strict();
 var TraceEnvelopeWireSchema = external_exports.object({
   schema_version: external_exports.literal(EXECUTION_TRACE_SCHEMA_VERSION),
   artifact_id: external_exports.string(),
   created_at: external_exports.string(),
   eval: TraceEnvelopeEvalWireSchema,
+  projection_identity: ProjectionIdentityWireSchema.optional(),
+  export_metadata: TraceEnvelopeExportMetadataWireSchema.optional(),
   replay: TraceEnvelopeReplayWireSchema.optional(),
   trace: TraceEnvelopeBodyWireSchema,
   source: TraceEnvelopeSourceWireSchema,
@@ -29875,7 +30201,7 @@ var TraceEnvelopeWireSchema = external_exports.object({
   artifacts: external_exports.record(external_exports.string(), external_exports.string()).optional(),
   scores: external_exports.array(TraceEnvelopeScoreWireSchema).optional()
 }).strict();
-function dropUndefined2(value) {
+function dropUndefined3(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 function isRecord(value) {
@@ -29892,7 +30218,7 @@ function definedStringRecord(value) {
 }
 function hashHex(parts, length) {
   const stable = parts.map((part) => typeof part === "string" ? part : JSON.stringify(part)).join("\0");
-  return createHash2("sha256").update(stable).digest("hex").slice(0, length);
+  return createHash3("sha256").update(stable).digest("hex").slice(0, length);
 }
 function parseTimeMs(timestamp) {
   if (!timestamp) {
@@ -29961,7 +30287,7 @@ function tokenUsageAttributes(usage) {
   if (!usage) {
     return {};
   }
-  return dropUndefined2({
+  return dropUndefined3({
     "gen_ai.usage.input_tokens": usage.input,
     "gen_ai.usage.output_tokens": usage.output,
     "gen_ai.usage.cache_read.input_tokens": usage.cached,
@@ -29972,13 +30298,17 @@ function tokenUsageAttributes(usage) {
 }
 function sourceFromResult(result, options) {
   const traceProvider = typeof result.trace.metadata?.provider === "string" ? result.trace.metadata.provider : void 0;
+  const metadata = dropUndefined3({
+    ...result.trace.metadata,
+    ...options.source?.metadata
+  });
   return {
     kind: options.source?.kind ?? "agentv_run",
     path: options.source?.path,
     provider: options.source?.provider ?? traceProvider ?? result.target,
     format: options.source?.format ?? "agentv_result",
     version: options.source?.version ?? "1",
-    metadata: options.source?.metadata
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0
   };
 }
 function capturePolicy(options) {
@@ -30013,24 +30343,37 @@ function maybeToolContentAttributes(toolCall, capture) {
   if (capture.content !== "full") {
     return {};
   }
-  return dropUndefined2({
+  return dropUndefined3({
     "gen_ai.tool.call.arguments": toolCall.input,
     "gen_ai.tool.call.result": toolCall.output
   });
 }
+function toolCallStatusToSpanStatus(toolCall) {
+  if (toolCall.status === "error" || toolCall.status === "timeout" || toolCall.status === "cancelled") {
+    return { code: "ERROR", message: toolCall.status };
+  }
+  return { code: "OK" };
+}
+function spanStatusToToolCallStatus(status) {
+  if (status.code === "ERROR") {
+    return "error";
+  }
+  return "ok";
+}
 function toTranscriptToolCallWire(toolCall, capture) {
-  return dropUndefined2({
+  return dropUndefined3({
     tool: toolCall.tool,
     input: capture.content === "full" ? toolCall.input : void 0,
     output: capture.content === "full" ? toolCall.output : void 0,
     id: toolCall.id,
+    status: toolCall.status,
     start_time: toolCall.startTime,
     end_time: toolCall.endTime,
     duration_ms: toolCall.durationMs
   });
 }
 function toTranscriptMessageWire(message, capture) {
-  return dropUndefined2({
+  return dropUndefined3({
     role: message.role,
     name: message.name,
     content: capture.content === "full" ? message.content : void 0,
@@ -30047,7 +30390,7 @@ function transcriptMessageEvent(message, index, capture) {
   return {
     name: TRANSCRIPT_MESSAGE_EVENT_NAME,
     timeUnixNano: startMs !== void 0 ? msToUnixNano(startMs) : void 0,
-    attributes: dropUndefined2({
+    attributes: dropUndefined3({
       "agentv.transcript.message.index": index,
       "agentv.transcript.message": toTranscriptMessageWire(message, capture)
     })
@@ -30081,10 +30424,10 @@ function scoresFromResult(result, targetSpanId) {
     source: scoreSource(score.type),
     evaluatedAt: score.endedAt ?? score.startedAt ?? result.timestamp,
     targetSpanId,
-    evidence: dropUndefined2({
+    evidence: dropUndefined3({
       span_ids: [targetSpanId],
       assertions: score.assertions.map(
-        (assertion) => dropUndefined2({
+        (assertion) => dropUndefined3({
           text: assertion.text,
           passed: assertion.passed,
           evidence: assertion.evidence
@@ -30118,7 +30461,7 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
   const rootEvents = result.trace.messages.map(
     (message, index) => transcriptMessageEvent(message, index, capture)
   );
-  const rootAttributes = dropUndefined2({
+  const rootAttributes = dropUndefined3({
     "gen_ai.operation.name": "invoke_agent",
     "gen_ai.provider.name": "agentv",
     "gen_ai.agent.name": result.target,
@@ -30128,8 +30471,8 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
     "agentv.suite": result.suite,
     "agentv.category": result.category,
     "agentv.eval_path": options.evalPath,
-    "agentv.run_id": options.runId,
-    "agentv.attempt": options.attempt,
+    "agentv.run_id": options.runId ?? result.timestamp,
+    "agentv.attempt": options.attempt ?? 0,
     "agentv.variant": options.variant ?? void 0,
     "agentv.execution_status": result.executionStatus,
     "agentv.failure_stage": result.failureStage,
@@ -30180,7 +30523,7 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
       startTimeUnixNano: msToUnixNano(chatTiming.startMs),
       endTimeUnixNano: msToUnixNano(chatTiming.endMs),
       status: { code: "OK" },
-      attributes: dropUndefined2({
+      attributes: dropUndefined3({
         "gen_ai.operation.name": "chat",
         "gen_ai.provider.name": source.provider,
         "gen_ai.request.model": model,
@@ -30222,8 +30565,8 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
         kind: "INTERNAL",
         startTimeUnixNano: msToUnixNano(toolTiming.startMs),
         endTimeUnixNano: msToUnixNano(toolTiming.endMs),
-        status: { code: "OK" },
-        attributes: dropUndefined2({
+        status: toolCallStatusToSpanStatus(toolCall),
+        attributes: dropUndefined3({
           "gen_ai.operation.name": "execute_tool",
           "gen_ai.tool.name": toolCall.tool,
           "gen_ai.tool.call.id": generatedToolCallId,
@@ -30240,24 +30583,50 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
     }
   }
   const artifactId = `execution-trace-${hashHex([traceId, result.timestamp, result.score], 20)}`;
+  const sourceTarget = options.sourceTarget ?? result.target;
+  const attempt = options.attempt ?? 0;
+  const variant = options.variant ?? null;
+  const runId = options.runId ?? result.timestamp;
   const evalIdentity = {
     evalId: options.evalId,
     evalPath: options.evalPath,
     suite: result.suite,
     testId: result.testId,
     target: result.target,
-    sourceTarget: options.sourceTarget,
-    attempt: options.attempt,
-    variant: options.variant,
-    runId: options.runId,
+    sourceTarget,
+    attempt,
+    variant,
+    runId,
     category: result.category,
     experiment: options.experiment
   };
+  const projectionIdentity = buildProjectionIdentity({
+    runId,
+    suite: evalIdentity.suite,
+    evalPath: evalIdentity.evalPath,
+    testId: evalIdentity.testId,
+    target: evalIdentity.target,
+    sourceTarget,
+    attempt,
+    variant,
+    envelopeId: artifactId,
+    traceId,
+    rootSpanId,
+    projectionFormat: TRACE_ENVELOPE_PROJECTION_FORMAT,
+    projectionVersion: EXECUTION_TRACE_SCHEMA_VERSION
+  });
   return {
     schemaVersion: EXECUTION_TRACE_SCHEMA_VERSION,
     artifactId,
     createdAt: now.toISOString(),
     eval: evalIdentity,
+    projectionIdentity,
+    exportMetadata: options.duplicatePolicy ? {
+      duplicatePolicy: options.duplicatePolicy,
+      identityWarnings: projectionIdentity.issues?.filter(
+        (issue2) => issue2.severity === "warning"
+      )
+    } : void 0,
     replay: options.replay,
     trace: {
       format: TRACE_ENVELOPE_FORMAT,
@@ -30276,11 +30645,13 @@ function buildTraceEnvelopeFromEvaluationResult(result, options = {}) {
 }
 function toTraceEnvelopeWire(envelope) {
   return TraceEnvelopeWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       schema_version: envelope.schemaVersion,
       artifact_id: envelope.artifactId,
       created_at: envelope.createdAt,
       eval: toTraceEnvelopeEvalWire(envelope.eval),
+      projection_identity: envelope.projectionIdentity ? toProjectionIdentityWire(envelope.projectionIdentity) : void 0,
+      export_metadata: envelope.exportMetadata ? toTraceEnvelopeExportMetadataWire(envelope.exportMetadata) : void 0,
       replay: envelope.replay ? toTraceEnvelopeReplayWire(envelope.replay) : void 0,
       trace: toTraceEnvelopeBodyWire(envelope.trace),
       source: toTraceEnvelopeSourceWire(envelope.source),
@@ -30298,6 +30669,8 @@ function fromTraceEnvelopeWire(input) {
     artifactId: wire.artifact_id,
     createdAt: wire.created_at,
     eval: fromTraceEnvelopeEvalWire(wire.eval),
+    projectionIdentity: wire.projection_identity ? fromProjectionIdentityWire(wire.projection_identity) : void 0,
+    exportMetadata: wire.export_metadata ? fromTraceEnvelopeExportMetadataWire(wire.export_metadata) : void 0,
     replay: wire.replay ? fromTraceEnvelopeReplayWire(wire.replay) : void 0,
     trace: fromTraceEnvelopeBodyWire(wire.trace),
     source: fromTraceEnvelopeSourceWire(wire.source),
@@ -30309,7 +30682,7 @@ function fromTraceEnvelopeWire(input) {
 }
 function toTraceEnvelopeEvalWire(evaluation) {
   return TraceEnvelopeEvalWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       eval_id: evaluation.evalId,
       eval_path: evaluation.evalPath,
       suite: evaluation.suite,
@@ -30339,9 +30712,23 @@ function fromTraceEnvelopeEvalWire(evaluation) {
     experiment: evaluation.experiment
   };
 }
+function toTraceEnvelopeExportMetadataWire(metadata) {
+  return TraceEnvelopeExportMetadataWireSchema.parse(
+    dropUndefined3({
+      duplicate_policy: metadata.duplicatePolicy,
+      identity_warnings: metadata.identityWarnings?.map(toProjectionIdentityIssueWire)
+    })
+  );
+}
+function fromTraceEnvelopeExportMetadataWire(metadata) {
+  return {
+    duplicatePolicy: metadata.duplicate_policy,
+    identityWarnings: metadata.identity_warnings?.map(fromProjectionIdentityIssueWire)
+  };
+}
 function toTraceEnvelopeReplayWire(replay) {
   return TraceEnvelopeReplayWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       lookup_key: replay.lookupKey,
       fixture_id: replay.fixtureId,
       source_fixture_path: replay.sourceFixturePath
@@ -30357,7 +30744,7 @@ function fromTraceEnvelopeReplayWire(replay) {
 }
 function toTraceEnvelopeBodyWire(trace) {
   return TraceEnvelopeBodyWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       format: trace.format,
       trace_id: trace.traceId,
       root_span_id: trace.rootSpanId,
@@ -30379,7 +30766,7 @@ function fromTraceEnvelopeBodyWire(trace) {
 }
 function toTraceEnvelopeSpanWire(span) {
   return TraceEnvelopeSpanWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       trace_id: span.traceId,
       span_id: span.spanId,
       parent_span_id: span.parentSpanId,
@@ -30409,7 +30796,7 @@ function fromTraceEnvelopeSpanWire(span) {
 }
 function toTraceEnvelopeSpanEventWire(event) {
   return TraceEnvelopeSpanEventWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       name: event.name,
       time_unix_nano: event.timeUnixNano,
       attributes: event.attributes
@@ -30425,7 +30812,7 @@ function fromTraceEnvelopeSpanEventWire(event) {
 }
 function toTraceEnvelopeSourceWire(source) {
   return TraceEnvelopeSourceWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       kind: source.kind,
       path: source.path,
       provider: source.provider,
@@ -30447,7 +30834,7 @@ function fromTraceEnvelopeSourceWire(source) {
 }
 function toTraceEnvelopeCaptureWire(capture) {
   return TraceEnvelopeCaptureWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       content: capture.content,
       redaction_level: capture.redactionLevel,
       redacted_fields: capture.redactedFields,
@@ -30465,7 +30852,7 @@ function fromTraceEnvelopeCaptureWire(capture) {
 }
 function toTraceEnvelopeSourceRefWire(sourceRef) {
   return TraceEnvelopeSourceRefWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       event_id: sourceRef.eventId,
       message_id: sourceRef.messageId,
       span_id: sourceRef.spanId,
@@ -30491,7 +30878,7 @@ function fromTraceEnvelopeSourceRefWire(sourceRef) {
 }
 function toTraceEnvelopeConversionWarningWire(warning) {
   return TraceEnvelopeConversionWarningWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       code: warning.code,
       severity: warning.severity,
       span_id: warning.spanId,
@@ -30513,7 +30900,7 @@ function fromTraceEnvelopeConversionWarningWire(warning) {
 }
 function toTraceEnvelopeScoreWire(score) {
   return TraceEnvelopeScoreWireSchema.parse(
-    dropUndefined2({
+    dropUndefined3({
       name: score.name,
       type: score.type,
       score: score.score,
@@ -30573,6 +30960,7 @@ function toolCallFromSpan(span) {
     id: stringAttribute(attributes, "gen_ai.tool.call.id") ?? stringAttribute(attributes, "tool.id") ?? span.spanId,
     input: attributes["gen_ai.tool.call.arguments"],
     output: attributes["gen_ai.tool.call.result"],
+    status: spanStatusToToolCallStatus(span.status),
     startTime: unixNanoToIso(span.startTimeUnixNano),
     endTime: unixNanoToIso(span.endTimeUnixNano),
     durationMs: durationMsFromSpan(span)
@@ -30610,6 +30998,7 @@ function fromTranscriptToolCallWire(wire) {
     input: wire.input,
     output: wire.output,
     id: typeof wire.id === "string" ? wire.id : void 0,
+    status: wire.status === "ok" || wire.status === "error" || wire.status === "timeout" || wire.status === "cancelled" || wire.status === "unknown" ? wire.status : void 0,
     startTime: typeof wire.start_time === "string" ? wire.start_time : void 0,
     endTime: typeof wire.end_time === "string" ? wire.end_time : void 0,
     durationMs: numberAttribute(wire, "duration_ms")
@@ -30620,7 +31009,7 @@ function fromTranscriptMessageWire(wire) {
     return void 0;
   }
   const toolCalls = Array.isArray(wire.tool_calls) ? wire.tool_calls.map(fromTranscriptToolCallWire).filter((toolCall) => toolCall !== void 0) : void 0;
-  return dropUndefined2({
+  return dropUndefined3({
     role: wire.role,
     name: typeof wire.name === "string" ? wire.name : void 0,
     content: wire.content,
@@ -30658,7 +31047,7 @@ function traceEnvelopeToMessageEntries(envelope) {
       endTime: unixNanoToIso(span.endTimeUnixNano),
       durationMs: durationMsFromSpan(span),
       tokenUsage: tokenUsageFromAttributes(span.attributes),
-      metadata: dropUndefined2({
+      metadata: dropUndefined3({
         span_id: span.spanId,
         trace_id: span.traceId,
         parent_span_id: span.parentSpanId ?? void 0,
@@ -30725,7 +31114,7 @@ function traceEnvelopeToToolTrajectoryView(envelope) {
       parentToolCallId: nearestAncestorToolCallId(ancestorIds, spansById),
       input: toolCall.input,
       output: toolCall.output,
-      status: span.status.code === "ERROR" ? "error" : "ok",
+      status: spanStatusToToolCallStatus(span.status),
       startTime: toolCall.startTime,
       endTime: toolCall.endTime,
       durationMs: toolCall.durationMs
@@ -30822,7 +31211,7 @@ function traceEnvelopeToTraceArtifact(envelope) {
           callId: toolCall.id,
           input: toolCall.input,
           output: toolCall.output,
-          status: span.status.code === "ERROR" ? "error" : "ok"
+          status: spanStatusToToolCallStatus(span.status)
         },
         sourceRef: {
           spanId: span.spanId,
@@ -30865,12 +31254,12 @@ function traceEnvelopeToOtlpJson(envelope) {
         },
         scopeSpans: [
           {
-            scope: dropUndefined2({
+            scope: dropUndefined3({
               name: envelope.trace.scope?.name,
               version: envelope.trace.scope?.version
             }),
             spans: orderedSpans(envelope.trace.spans).map(
-              (span) => dropUndefined2({
+              (span) => dropUndefined3({
                 traceId: span.traceId,
                 spanId: span.spanId,
                 parentSpanId: span.parentSpanId ?? void 0,
@@ -30881,7 +31270,7 @@ function traceEnvelopeToOtlpJson(envelope) {
                 attributes: attributesToOtlp(span.attributes),
                 status: spanStatusToOtlp(span.status),
                 events: span.events?.map(
-                  (event) => dropUndefined2({
+                  (event) => dropUndefined3({
                     name: event.name,
                     timeUnixNano: event.timeUnixNano,
                     attributes: attributesToOtlp(event.attributes)
@@ -30912,7 +31301,7 @@ function spanKindToOtlp(kind) {
 }
 function spanStatusToOtlp(status) {
   const code = status.code === "OK" ? 1 : status.code === "ERROR" ? 2 : 0;
-  return dropUndefined2({ code, message: status.message });
+  return dropUndefined3({ code, message: status.message });
 }
 function attributesToOtlp(attributes) {
   return Object.entries(attributes ?? {}).map(([key, value]) => ({
@@ -30991,7 +31380,7 @@ function traceEnvelopeReplayRecordToProviderResponse(record2) {
     startTime: summary.startTime,
     endTime: summary.endTime,
     raw: {
-      replay_execution_trace: dropUndefined3({
+      replay_execution_trace: dropUndefined4({
         artifact_id: record2.envelope.artifactId,
         source_path: record2.sourcePath,
         line_number: record2.lineNumber,
@@ -31085,7 +31474,7 @@ function assertReplayableMessages(output, record2) {
 function formatRecordLocation(record2) {
   return record2.lineNumber === void 0 ? record2.sourcePath : `${record2.sourcePath}:${record2.lineNumber}`;
 }
-function dropUndefined3(value) {
+function dropUndefined4(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
 var ReplayProvider = class {
@@ -33427,7 +33816,7 @@ function computeWorkspaceFingerprint(repos) {
   const canonical = {
     repos: [...repos].sort((a, b) => (a.path ?? "").localeCompare(b.path ?? "")).map(normalizeRepoForFingerprint)
   };
-  return createHash3("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return createHash4("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
   await mkdir15(dest, { recursive: true });
@@ -34070,7 +34459,7 @@ ${output}` : ""}`
     return void 0;
   }
   gitCachePath(repoIdentity) {
-    const hash = createHash4("sha256").update(repoIdentity).digest("hex");
+    const hash = createHash5("sha256").update(repoIdentity).digest("hex");
     return path37.join(getAgentvDataDir(), "git-cache", hash);
   }
   async withMirrorCacheLock(mirrorPath, action) {
@@ -38731,7 +39120,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-DXSXFWYI-WV7NYVUG.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-YR5XK44N-V3P76ZCR.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
@@ -38760,7 +39149,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromAgentSkills(evalFilePath);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-DXSXFWYI-WV7NYVUG.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-YR5XK44N-V3P76ZCR.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -42003,7 +42392,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = createHash5("sha256");
+  const hash = createHash6("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -42148,37 +42537,60 @@ function createFunctionProvider(taskFn) {
     }
   };
 }
-function dropUndefined4(value) {
+var TRANSCRIPT_ROW_SCHEMA_VERSION = "agentv.transcript.v1";
+function dropUndefined5(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
 function toTranscriptTokenUsage(usage) {
   if (!usage) {
     return void 0;
   }
-  return dropUndefined4({
+  return dropUndefined5({
     input: usage.input,
     output: usage.output,
     cached: usage.cached,
     reasoning: usage.reasoning
   });
 }
-function toTranscriptToolCall(toolCall) {
-  return dropUndefined4({
-    tool: toolCall.tool,
-    input: toolCall.input,
-    output: toolCall.output,
-    id: toolCall.id,
-    start_time: toolCall.startTime,
-    end_time: toolCall.endTime,
-    duration_ms: toolCall.durationMs
-  });
+function toTranscriptCaptureState(capture) {
+  return {
+    content: capture?.content ?? "full",
+    redaction_level: capture?.redaction_level ?? "none",
+    ...capture?.redacted_fields ? { redacted_fields: capture.redacted_fields } : {}
+  };
+}
+function toTranscriptToolCall(toolCall, projection) {
+  const status = projection?.status ?? (toolCall.status ? toTranscriptToolCallStatus(toolCall.status) : void 0);
+  return {
+    tool: projection?.tool ?? toolCall.tool,
+    ...toolCall.input !== void 0 || projection?.input !== void 0 ? { input: toolCall.input !== void 0 ? toolCall.input : projection?.input } : {},
+    ...toolCall.output !== void 0 || projection?.output !== void 0 ? { output: toolCall.output !== void 0 ? toolCall.output : projection?.output } : {},
+    ...toolCall.id || projection?.id ? { id: toolCall.id ?? projection?.id } : {},
+    ...status ? { status } : {},
+    ...toolCall.startTime || projection?.start_time ? { start_time: toolCall.startTime ?? projection?.start_time } : {},
+    ...toolCall.endTime || projection?.end_time ? { end_time: toolCall.endTime ?? projection?.end_time } : {},
+    ...toolCall.durationMs !== void 0 || projection?.duration_ms !== void 0 ? { duration_ms: toolCall.durationMs ?? projection?.duration_ms } : {},
+    ...projection?.trace ? { trace: projection.trace } : {}
+  };
+}
+function toTranscriptToolCallStatus(status) {
+  if (status === "timeout" || status === "cancelled") {
+    return "error";
+  }
+  return status === "unknown" ? "unknown" : status;
 }
 function toTranscriptMessageFields(message) {
-  return dropUndefined4({
+  return dropUndefined5({
     role: message.role,
     name: message.name,
     content: message.content,
-    tool_calls: message.toolCalls?.map(toTranscriptToolCall),
+    tool_calls: message.toolCalls?.map((toolCall) => toTranscriptToolCall(toolCall)),
     start_time: message.startTime,
     end_time: message.endTime,
     duration_ms: message.durationMs,
@@ -42188,13 +42600,17 @@ function toTranscriptMessageFields(message) {
 }
 function toTranscriptJsonLines(entry, options) {
   const source = {
+    kind: entry.source.kind ?? "imported_transcript",
     provider: entry.source.provider,
     session_id: entry.source.sessionId,
+    path: entry.source.path,
+    format: entry.source.format,
     model: entry.source.model,
     timestamp: entry.source.startedAt,
     git_branch: entry.source.gitBranch,
     cwd: entry.source.cwd ?? entry.source.projectPath,
-    version: entry.source.version
+    version: entry.source.version,
+    metadata: entry.source.metadata
   };
   const transcriptTokenUsage = entry.tokenUsage ? {
     input: entry.tokenUsage.input,
@@ -42204,7 +42620,9 @@ function toTranscriptJsonLines(entry, options) {
   } : void 0;
   const testId = options?.testId ?? entry.source.sessionId;
   const target = options?.target ?? entry.source.provider;
+  const capture = toTranscriptCaptureState(void 0);
   return entry.messages.map((message, index) => ({
+    schema_version: TRANSCRIPT_ROW_SCHEMA_VERSION,
     test_id: testId,
     target,
     message_index: index,
@@ -42212,9 +42630,123 @@ function toTranscriptJsonLines(entry, options) {
     transcript_token_usage: transcriptTokenUsage,
     transcript_duration_ms: entry.durationMs,
     transcript_cost_usd: entry.costUsd,
-    source
+    capture,
+    source: dropUndefined5(source)
   }));
 }
+function traceRefFromEnvelope(envelope, spanId, parentSpanId) {
+  return dropUndefined5({
+    schema_version: EXECUTION_TRACE_SCHEMA_VERSION,
+    artifact_id: envelope.artifactId,
+    trace_id: envelope.trace.traceId,
+    span_id: spanId ?? envelope.trace.rootSpanId,
+    parent_span_id: parentSpanId
+  });
+}
+function sourceFromEnvelope(envelope, summary) {
+  const metadata = envelope.source.metadata;
+  const sessionId = optionalString(metadata?.provider_session_id) ?? optionalString(metadata?.session_id) ?? optionalString(metadata?.conversation_id) ?? envelope.eval.runId ?? envelope.eval.testId;
+  return dropUndefined5({
+    kind: envelope.source.kind,
+    provider: envelope.source.provider ?? envelope.eval.target,
+    session_id: sessionId,
+    path: envelope.source.path,
+    format: envelope.source.format,
+    model: optionalString(metadata?.model),
+    timestamp: summary.startTime ?? envelope.createdAt,
+    cwd: optionalString(metadata?.cwd),
+    version: envelope.source.version,
+    metadata
+  });
+}
+function captureFromEnvelope(envelope) {
+  return toTranscriptCaptureState({
+    content: envelope.capture.content,
+    redaction_level: envelope.capture.redactionLevel,
+    redacted_fields: envelope.capture.redactedFields
+  });
+}
+function messageTraceRefs(envelope) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const span of envelope.trace.spans) {
+    if (span.attributes["gen_ai.operation.name"] !== "chat" && span.attributes["openinference.span.kind"] !== "LLM") {
+      continue;
+    }
+    const index = span.attributes["agentv.message.index"];
+    if (typeof index === "number" && Number.isInteger(index)) {
+      refs.set(index, traceRefFromEnvelope(envelope, span.spanId, span.parentSpanId ?? void 0));
+    }
+  }
+  return refs;
+}
+function toolProjections(envelope) {
+  return traceEnvelopeToToolTrajectoryView(envelope).tools.map(
+    (tool) => dropUndefined5({
+      tool: tool.tool,
+      input: tool.input,
+      output: tool.output,
+      id: tool.toolCallId,
+      status: tool.status,
+      start_time: tool.startTime,
+      end_time: tool.endTime,
+      duration_ms: tool.durationMs,
+      trace: traceRefFromEnvelope(envelope, tool.spanId, tool.parentSpanId)
+    })
+  );
+}
+function projectedToolCalls(message, projections, usedProjectionIndexes) {
+  if (!message.toolCalls || message.toolCalls.length === 0) {
+    return void 0;
+  }
+  return message.toolCalls.map((toolCall) => {
+    const projectionIndex = projections.findIndex((candidate, index) => {
+      if (usedProjectionIndexes.has(index)) {
+        return false;
+      }
+      if (toolCall.id && candidate.id) {
+        return candidate.id === toolCall.id;
+      }
+      return candidate.tool === toolCall.tool;
+    });
+    const projection = projectionIndex >= 0 ? projections[projectionIndex] : void 0;
+    if (projectionIndex >= 0) {
+      usedProjectionIndexes.add(projectionIndex);
+    }
+    return toTranscriptToolCall(toolCall, projection);
+  });
+}
+function traceEnvelopeToTranscriptJsonLines(envelope, options) {
+  const messages = traceEnvelopeToTranscriptMessages(envelope);
+  const summary = traceEnvelopeToTraceSummary(envelope);
+  const source = sourceFromEnvelope(envelope, summary);
+  const capture = captureFromEnvelope(envelope);
+  const transcriptTokenUsage = summary.tokenUsage ? {
+    input: summary.tokenUsage.input,
+    output: summary.tokenUsage.output,
+    cached: summary.tokenUsage.cached,
+    reasoning: summary.tokenUsage.reasoning
+  } : void 0;
+  const refsByMessageIndex = messageTraceRefs(envelope);
+  const toolRows = toolProjections(envelope);
+  const usedToolIndexes = /* @__PURE__ */ new Set();
+  return messages.map((message, index) => {
+    const trace = refsByMessageIndex.get(index) ?? traceRefFromEnvelope(envelope);
+    return dropUndefined5({
+      schema_version: TRANSCRIPT_ROW_SCHEMA_VERSION,
+      test_id: options?.testId ?? envelope.eval.testId,
+      target: options?.target ?? envelope.eval.target,
+      message_index: index,
+      ...toTranscriptMessageFields({ ...message, toolCalls: void 0 }),
+      tool_calls: projectedToolCalls(message, toolRows, usedToolIndexes),
+      transcript_token_usage: transcriptTokenUsage,
+      transcript_duration_ms: summary.durationMs,
+      transcript_cost_usd: summary.costUsd,
+      capture,
+      trace,
+      source
+    });
+  });
+}
 function traceToTranscriptJsonLines(trace, options) {
   const provider = (typeof trace.metadata?.provider === "string" ? trace.metadata.provider : void 0) ?? options?.target ?? "agentv";
   const sessionId = (typeof trace.metadata?.provider_session_id === "string" ? trace.metadata.provider_session_id : void 0) ?? (typeof trace.metadata?.eval_case_id === "string" ? trace.metadata.eval_case_id : void 0) ?? options?.testId ?? "trace";
@@ -42222,9 +42754,11 @@ function traceToTranscriptJsonLines(trace, options) {
     {
       messages: [...trace.messages],
       source: {
+        kind: "agentv_run",
         provider,
         sessionId,
-        startedAt: trace.startTime
+        startedAt: trace.startTime,
+        metadata: isRecord3(trace.metadata) ? trace.metadata : void 0
       },
       tokenUsage: trace.tokenUsage,
       durationMs: trace.durationMs,
@@ -42270,6 +42804,9 @@ function readOptionalNumber(record2, key) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
 function fromTranscriptToolCall(wire) {
+  if (!isRecord3(wire)) {
+    return void 0;
+  }
   const tool = readOptionalString(wire, "tool");
   if (!tool) {
     return void 0;
@@ -42279,6 +42816,7 @@ function fromTranscriptToolCall(wire) {
     input: wire.input,
     output: wire.output,
     id: readOptionalString(wire, "id"),
+    status: wire.status === "ok" || wire.status === "error" || wire.status === "timeout" || wire.status === "cancelled" || wire.status === "unknown" ? wire.status : void 0,
     startTime: readOptionalString(wire, "start_time"),
     endTime: readOptionalString(wire, "end_time"),
     durationMs: readOptionalNumber(wire, "duration_ms")
@@ -42302,13 +42840,17 @@ function groupTranscriptJsonLines(lines) {
   for (const line of lines) {
     const existing = grouped.get(line.test_id);
     const source = {
+      kind: line.source.kind,
       provider: line.source.provider,
       sessionId: line.source.session_id,
+      path: line.source.path,
+      format: line.source.format,
       startedAt: line.source.timestamp,
       model: line.source.model,
       gitBranch: line.source.git_branch,
       cwd: line.source.cwd,
-      version: line.source.version
+      version: line.source.version,
+      metadata: line.source.metadata
     };
     const transcriptTokenUsage = line.transcript_token_usage ? {
       input: line.transcript_token_usage.input,
@@ -42401,7 +42943,7 @@ var TOOL_CALL_ALIASES = {
   endTime: "end_time",
   startTime: "start_time"
 };
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeKnownAliases(value, aliases) {
@@ -42417,13 +42959,13 @@ function normalizeKnownAliases(value, aliases) {
   return normalized;
 }
 function normalizeToolCall2(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return value;
   }
   return normalizeKnownAliases(value, TOOL_CALL_ALIASES);
 }
 function normalizeMessage(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return value;
   }
   const normalized = normalizeKnownAliases(value, MESSAGE_ALIASES);
@@ -42433,7 +42975,7 @@ function normalizeMessage(value) {
   return normalized;
 }
 function normalizeTraceSummary(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return value;
   }
   const normalized = normalizeKnownAliases(value, TRACE_SUMMARY_ALIASES);
@@ -42466,7 +43008,7 @@ function looksLikeResultRow(value) {
   return typeof value.test_id === "string" || Object.hasOwn(value, "score") || Object.hasOwn(value, "trace") || Object.hasOwn(value, "spans") || Object.hasOwn(value, "target") || Object.hasOwn(value, "grading_path") || Object.hasOwn(value, "timing_path");
 }
 function normalizeResultRow(value, context = {}) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     throw buildSchemaError(context);
   }
   const normalized = normalizeKnownAliases(value, RESULT_ROW_ALIASES);
@@ -42636,17 +43178,17 @@ function toIndexScore(score) {
 function toIndexScores(scores) {
   return scores?.map(toIndexScore);
 }
-function dropUndefined5(value) {
+function dropUndefined6(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toIndexRerunSource(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
-  return dropUndefined5({
+  return dropUndefined6({
     mode: value.mode,
     source_run_dir: value.sourceRunDir,
     source_index_path: value.sourceIndexPath,
@@ -42658,10 +43200,10 @@ function toIndexRerunSource(value) {
   });
 }
 function toIndexPreparedAttempt(value) {
-  if (!isRecord4(value)) {
+  if (!isRecord5(value)) {
     return void 0;
   }
-  return dropUndefined5({
+  return dropUndefined6({
     source: value.source,
     manifest_path: value.manifestPath,
     prepared_dir: value.preparedDir,
@@ -42691,6 +43233,17 @@ function toIndexMetadata(metadata) {
     ...preparedAttempt ? { prepared_attempt: preparedAttempt } : {}
   };
 }
+function buildExportMetadata(duplicatePolicy, projectionIdentity, options) {
+  if (!duplicatePolicy) {
+    return void 0;
+  }
+  const warnings = projectionIdentity?.issues?.filter((issue2) => issue2.severity === "warning").map(toProjectionIdentityIssueWire);
+  return {
+    duplicate_policy: duplicatePolicy,
+    identity_warnings: warnings && warnings.length > 0 ? warnings : void 0,
+    skipped: options?.skipped
+  };
+}
 function buildGradingArtifact(result) {
   const assertions = buildAssertions(result);
   const passed = assertions.filter((e) => e.passed).length;
@@ -42912,23 +43465,27 @@ function resolveEnvelopeEvalPath(result, testByTestId, fallbackEvalFile) {
 function resultHasExecutionTraceTranscript(result) {
   return result.output.length > 0 || result.trace.messages.length > 0;
 }
-async function writeTraceEnvelopeSidecar(params) {
+function buildTraceEnvelopeSidecar(params) {
   const hasTranscript = resultHasExecutionTraceTranscript(params.result);
-  const envelope = buildTraceEnvelopeFromEvaluationResult(params.result, {
+  return buildTraceEnvelopeFromEvaluationResult(params.result, {
     evalPath: params.evalPath,
-    runId: path48.basename(params.outputDir),
+    runId: params.runId ?? path48.basename(params.outputDir),
     experiment: params.experiment,
     source: { path: RESULT_INDEX_FILENAME },
     capture: { content: "full", redactionLevel: "none", redactedFields: [] },
     artifacts: {
-      execution_trace_path: "outputs/execution-trace.json",
+      trace_path: "outputs/trace.json",
       answer_path: params.result.output.length > 0 ? "outputs/answer.md" : void 0,
       response_path: params.result.output.length > 0 ? "outputs/response.md" : void 0,
       transcript_path: hasTranscript ? "outputs/transcript.jsonl" : void 0
-    }
+    },
+    duplicatePolicy: params.duplicatePolicy
   });
+}
+async function writeTraceEnvelopeSidecar(params) {
+  const envelope = buildTraceEnvelopeSidecar(params);
   await writeFile10(
-    path48.join(params.outputsDir, "execution-trace.json"),
+    path48.join(params.outputsDir, "trace.json"),
     `${JSON.stringify(toTraceEnvelopeWire(envelope), null, 2)}
 `,
     "utf8"
@@ -42964,10 +43521,12 @@ function buildIndexArtifactEntry(result, options) {
     input_path: options.inputPath ? toRelativeArtifactPath(options.outputDir, options.inputPath) : void 0,
     response_path: options.responsePath ? toRelativeArtifactPath(options.outputDir, options.responsePath) : void 0,
     ...options.extraIndexFields,
+    projection_identity: options.projectionIdentity ? toProjectionIdentityWire(options.projectionIdentity) : void 0,
+    export_metadata: buildExportMetadata(options.duplicatePolicy, options.projectionIdentity),
     metadata: toIndexMetadata(result.metadata)
   };
 }
-function buildResultIndexArtifact(result, extraIndexFields) {
+function buildResultIndexArtifact(result, extraIndexFields, options) {
   const artifactSubdir = buildArtifactSubdir(result);
   const input = extractInput(result);
   const hasAnswer = result.output.length > 0;
@@ -43000,6 +43559,8 @@ function buildResultIndexArtifact(result, extraIndexFields) {
     transcript_path: hasTranscript ? path48.posix.join(artifactSubdir, "outputs", "transcript.jsonl") : void 0,
     response_path: hasAnswer ? path48.posix.join(artifactSubdir, "outputs", "response.md") : void 0,
     ...extraIndexFields,
+    projection_identity: options?.projectionIdentity ? toProjectionIdentityWire(options.projectionIdentity) : void 0,
+    export_metadata: buildExportMetadata(options?.duplicatePolicy, options?.projectionIdentity),
     metadata: toIndexMetadata(result.metadata)
   };
 }
@@ -43008,17 +43569,11 @@ async function writeJsonlFile(filePath, records) {
 `;
   await writeFile10(filePath, content, "utf8");
 }
-function traceProjectionForTranscript(result, envelope) {
-  return {
-    ...result.trace,
-    messages: traceEnvelopeToTranscriptMessages(envelope)
-  };
-}
 function hasTranscriptProjection(result, envelope) {
   return result.output.length > 0 || traceEnvelopeToTranscriptMessages(envelope).length > 0;
 }
 async function writeTranscriptJsonl(filePath, result, envelope) {
-  const lines = traceToTranscriptJsonLines(traceProjectionForTranscript(result, envelope), {
+  const lines = traceEnvelopeToTranscriptJsonLines(envelope, {
     testId: result.testId,
     target: result.target
   });
@@ -43027,13 +43582,70 @@ async function writeTranscriptJsonl(filePath, result, envelope) {
   await writeFile10(filePath, content, "utf8");
 }
 function indexRecordKey(record2) {
-  if (!isRecord4(record2)) {
+  if (!isRecord5(record2)) {
     return void 0;
   }
   const testId = typeof record2.test_id === "string" ? record2.test_id : typeof record2.testId === "string" ? record2.testId : void 0;
   const target = typeof record2.target === "string" ? record2.target : void 0;
   return testId ? buildTestTargetKey(testId, target) : void 0;
 }
+function projectionIdentityRecordKey(record2) {
+  if (!isRecord5(record2) || !isRecord5(record2.projection_identity)) {
+    return void 0;
+  }
+  const id = record2.projection_identity.id;
+  return typeof id === "string" && id.trim().length > 0 ? id : void 0;
+}
+async function readExistingIndexRecords(outputDir) {
+  const indexPath = path48.join(outputDir, RESULT_INDEX_FILENAME);
+  const content = await readFile20(indexPath, "utf8").catch(() => void 0);
+  if (content === void 0) {
+    return [];
+  }
+  const records = [];
+  for (const line of content.split("\n")) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return records;
+}
+function existingRecordsByProjectionIdentity(records) {
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const record2 of records) {
+    const key = projectionIdentityRecordKey(record2);
+    if (key) {
+      byIdentity.set(key, record2);
+    }
+  }
+  return byIdentity;
+}
+function skippedExistingRecord(record2, identity, duplicatePolicy) {
+  if (!isRecord5(record2)) {
+    return record2;
+  }
+  return {
+    ...record2,
+    projection_identity: toProjectionIdentityWire(identity),
+    export_metadata: buildExportMetadata(duplicatePolicy, identity, { skipped: true })
+  };
+}
+function duplicateProjectionMessage(identity) {
+  const dimensions = identity.dimensions;
+  return [
+    `Duplicate export projection ${identity.id}`,
+    `test_id=${dimensions.testId}`,
+    `target=${dimensions.target}`,
+    `source_target=${dimensions.sourceTarget}`,
+    `attempt=${dimensions.attempt}`,
+    `variant=${dimensions.variant ?? "<none>"}`,
+    `run_id=${dimensions.runId}`
+  ].join(" ");
+}
 async function rewriteExistingIndexRecords(outputDir, replacements) {
   if (replacements.length === 0) {
     return;
@@ -43175,18 +43787,6 @@ async function writeArtifacts(jsonlPath, outputDir, options) {
   const results = parseJsonlResults(content);
   return writeArtifactsFromResults(results, outputDir, options);
 }
-function buildTranscriptMessageLines(results) {
-  const lines = [];
-  for (const result of results) {
-    const transcriptLines = traceToTranscriptJsonLines(result.trace, {
-      testId: result.testId,
-      target: result.target
-    });
-    lines.push(...transcriptLines.map((line) => JSON.stringify(line)));
-  }
-  return lines.length > 0 ? `${lines.join("\n")}
-` : "";
-}
 async function collectAdditionalIndexFields(result, outputDir, testDir, testByTestId, additionalArtifacts) {
   if (!additionalArtifacts) {
     return void 0;
@@ -43201,6 +43801,7 @@ async function collectAdditionalIndexFields(result, outputDir, testDir, testByTe
 }
 async function writePerTestArtifacts(results, outputDir, options) {
   await mkdir18(outputDir, { recursive: true });
+  const duplicatePolicy = options?.duplicatePolicy ?? "update";
   const testByTestId = new Map((options?.sourceTests ?? []).map((test) => [test.id, test]));
   const indexRecords = [];
   for (const result of results) {
@@ -43236,7 +43837,9 @@ async function writePerTestArtifacts(results, outputDir, options) {
       outputDir,
       outputsDir,
       evalPath: resolveEnvelopeEvalPath(result, testByTestId, options?.evalFile),
-      experiment: options?.experiment
+      experiment: options?.experiment,
+      runId: options?.runId,
+      duplicatePolicy
     });
     if (hasTranscriptProjection(result, envelope)) {
       await writeTranscriptJsonl(path48.join(outputsDir, "transcript.jsonl"), result, envelope);
@@ -43249,7 +43852,10 @@ async function writePerTestArtifacts(results, outputDir, options) {
       options?.additionalArtifacts
     );
     indexRecords.push({
-      ...buildResultIndexArtifact(result, extraIndexFields),
+      ...buildResultIndexArtifact(result, extraIndexFields, {
+        projectionIdentity: envelope.projectionIdentity,
+        duplicatePolicy
+      }),
       experiment: options?.experiment
     });
   }
@@ -43261,66 +43867,137 @@ async function writeArtifactsFromResults(results, outputDir, options) {
   const benchmarkPath = path48.join(outputDir, "benchmark.json");
   const indexPath = path48.join(outputDir, RESULT_INDEX_FILENAME);
   await mkdir18(outputDir, { recursive: true });
+  const duplicatePolicy = options?.duplicatePolicy ?? "update";
+  const existingRecords = await readExistingIndexRecords(outputDir);
+  const existingByIdentity = existingRecordsByProjectionIdentity(existingRecords);
   const indexRecords = [];
   const testByTestId = new Map((options?.sourceTests ?? []).map((test) => [test.id, test]));
-  for (const result of results) {
+  const emittedIdentityIds = /* @__PURE__ */ new Set();
+  const plans = results.map((result) => {
     const grading = buildGradingArtifact(result);
     const timing2 = buildTimingArtifact([result]);
     const artifactSubdir = buildArtifactSubdir(result);
     const testDir = path48.join(outputDir, artifactSubdir);
     const gradingPath = path48.join(testDir, "grading.json");
     const perTestTimingPath = path48.join(testDir, "timing.json");
-    await mkdir18(testDir, { recursive: true });
-    await writeFile10(gradingPath, `${JSON.stringify(grading, null, 2)}
-`, "utf8");
-    await writeFile10(perTestTimingPath, `${JSON.stringify(timing2, null, 2)}
-`, "utf8");
     const input = extractInput(result);
     const inputPath = input ? path48.join(testDir, "input.md") : void 0;
-    if (inputPath && input) {
-      await writeFile10(inputPath, input, "utf8");
-    }
     const outputsDir = path48.join(testDir, "outputs");
-    await mkdir18(outputsDir, { recursive: true });
     const answerPath = result.output.length > 0 ? path48.join(outputsDir, "answer.md") : void 0;
     const responsePath = result.output.length > 0 ? path48.join(outputsDir, "response.md") : void 0;
-    if (answerPath && responsePath) {
-      await writeFile10(answerPath, result.output, "utf8");
-      await writeFile10(responsePath, result.output, "utf8");
-    }
-    const envelope = await writeTraceEnvelopeSidecar({
+    const envelope = buildTraceEnvelopeSidecar({
       result,
       outputDir,
       outputsDir,
       evalPath: resolveEnvelopeEvalPath(result, testByTestId, options?.evalFile),
-      experiment: options?.experiment
+      experiment: options?.experiment,
+      runId: options?.runId,
+      duplicatePolicy
     });
     const transcriptPath = hasTranscriptProjection(result, envelope) ? path48.join(outputsDir, "transcript.jsonl") : void 0;
-    if (transcriptPath) {
-      await writeTranscriptJsonl(transcriptPath, result, envelope);
+    const projectionIdentity = envelope.projectionIdentity;
+    if (!projectionIdentity) {
+      throw new Error(`Result ${result.testId ?? "unknown"} is missing projection identity`);
+    }
+    const identityId = projectionIdentity.id;
+    return {
+      result,
+      grading,
+      timing: timing2,
+      testDir,
+      gradingPath,
+      perTestTimingPath,
+      input,
+      inputPath,
+      outputsDir,
+      answerPath,
+      responsePath,
+      envelope,
+      projectionIdentity,
+      transcriptPath,
+      identityId
+    };
+  });
+  if (duplicatePolicy === "error") {
+    const seen = /* @__PURE__ */ new Set();
+    for (const plan of plans) {
+      const duplicate = seen.has(plan.identityId) || existingByIdentity.has(plan.identityId) ? plan.projectionIdentity : void 0;
+      if (duplicate) {
+        throw new Error(
+          `${duplicateProjectionMessage(duplicate)}; use --duplicate-policy update or skip`
+        );
+      }
+      seen.add(plan.identityId);
+    }
+  }
+  for (const plan of plans) {
+    const { result, envelope, identityId } = plan;
+    const existing = existingByIdentity.get(identityId);
+    if (duplicatePolicy === "skip" && existing) {
+      indexRecords.push(skippedExistingRecord(existing, plan.projectionIdentity, duplicatePolicy));
+      emittedIdentityIds.add(identityId);
+      continue;
+    }
+    if (duplicatePolicy === "skip" && emittedIdentityIds.has(identityId)) {
+      continue;
+    }
+    await mkdir18(plan.testDir, { recursive: true });
+    await writeFile10(plan.gradingPath, `${JSON.stringify(plan.grading, null, 2)}
+`, "utf8");
+    await writeFile10(plan.perTestTimingPath, `${JSON.stringify(plan.timing, null, 2)}
+`, "utf8");
+    if (plan.inputPath && plan.input) {
+      await writeFile10(plan.inputPath, plan.input, "utf8");
+    }
+    await mkdir18(plan.outputsDir, { recursive: true });
+    if (plan.answerPath && plan.responsePath) {
+      await writeFile10(plan.answerPath, result.output, "utf8");
+      await writeFile10(plan.responsePath, result.output, "utf8");
+    }
+    await writeFile10(
+      path48.join(plan.outputsDir, "execution-trace.json"),
+      `${JSON.stringify(toTraceEnvelopeWire(envelope), null, 2)}
+`,
+      "utf8"
+    );
+    if (plan.transcriptPath) {
+      await writeTranscriptJsonl(plan.transcriptPath, result, envelope);
     }
     const extraIndexFields = await collectAdditionalIndexFields(
       result,
       outputDir,
-      testDir,
+      plan.testDir,
       testByTestId,
       options?.additionalArtifacts
     );
-    indexRecords.push({
+    const nextRecord = {
       ...buildIndexArtifactEntry(result, {
         outputDir,
-        artifactDir: testDir,
-        gradingPath,
-        timingPath: perTestTimingPath,
-        outputPath: answerPath,
-        answerPath,
-        transcriptPath,
-        inputPath,
-        responsePath,
-        extraIndexFields
+        artifactDir: plan.testDir,
+        gradingPath: plan.gradingPath,
+        timingPath: plan.perTestTimingPath,
+        outputPath: plan.answerPath,
+        answerPath: plan.answerPath,
+        transcriptPath: plan.transcriptPath,
+        inputPath: plan.inputPath,
+        responsePath: plan.responsePath,
+        extraIndexFields,
+        projectionIdentity: plan.projectionIdentity,
+        duplicatePolicy
       }),
       experiment: options?.experiment
-    });
+    };
+    if (duplicatePolicy === "update" && emittedIdentityIds.has(identityId)) {
+      const existingIndex = indexRecords.findIndex(
+        (record2) => projectionIdentityRecordKey(record2) === identityId
+      );
+      if (existingIndex >= 0) {
+        indexRecords[existingIndex] = nextRecord;
+      }
+    } else {
+      indexRecords.push(nextRecord);
+    }
+    emittedIdentityIds.add(identityId);
   }
   const timing = buildTimingArtifact(results);
   await writeFile10(timingPath, `${JSON.stringify(timing, null, 2)}
@@ -43335,11 +44012,6 @@ async function writeArtifactsFromResults(results, outputDir, options) {
   await writeFile10(benchmarkPath, `${JSON.stringify(benchmark, null, 2)}
 `, "utf8");
   await writeJsonlFile(indexPath, indexRecords);
-  await writeFile10(
-    path48.join(outputDir, "transcript.jsonl"),
-    buildTranscriptMessageLines(results),
-    "utf8"
-  );
   return { testArtifactDir, timingPath, benchmarkPath, indexPath };
 }
 async function evaluate(config2) {
@@ -43869,6 +44541,18 @@ export {
   formatReplayLookupKey,
   replayFixtureRecordToProviderResponse,
   buildReplayFixtureRecord,
+  PROJECTION_IDENTITY_SCHEMA_VERSION,
+  EXPORT_DUPLICATE_POLICY_VALUES,
+  ProjectionIdentityError,
+  buildProjectionIdentityKey,
+  buildProjectionIdentity,
+  ProjectionIdentityIssueWireSchema,
+  ProjectionIdentityDimensionsWireSchema,
+  ProjectionIdentityWireSchema,
+  toProjectionIdentityIssueWire,
+  fromProjectionIdentityIssueWire,
+  toProjectionIdentityWire,
+  fromProjectionIdentityWire,
   EXECUTION_TRACE_SCHEMA_VERSION,
   TraceEnvelopeEvalWireSchema,
   TraceEnvelopeReplayWireSchema,
@@ -43881,6 +44565,7 @@ export {
   TraceEnvelopeSourceRefWireSchema,
   TraceEnvelopeConversionWarningWireSchema,
   TraceEnvelopeScoreWireSchema,
+  TraceEnvelopeExportMetadataWireSchema,
   TraceEnvelopeWireSchema,
   buildTraceEnvelopeFromEvaluationResult,
   toTraceEnvelopeWire,
@@ -43963,7 +44648,9 @@ export {
   gradePreparedEvalCase,
   runEvaluation,
   runEvalCase,
+  TRANSCRIPT_ROW_SCHEMA_VERSION,
   toTranscriptJsonLines,
+  traceEnvelopeToTranscriptJsonLines,
   traceToTranscriptJsonLines,
   traceFromTranscriptJsonLines,
   groupTranscriptJsonLines,
@@ -43990,4 +44677,4 @@ export {
   loadTsEvalFile,
   loadTsEvalSuite
 };
-//# sourceMappingURL=chunk-IX5KWMMM.js.map
+//# sourceMappingURL=chunk-SJTHFOPH.js.map