agentv 4.42.4 → 4.43.0-next.1

package/dist/{chunk-RBOP5X36.js → chunk-5NDSGGMJ.js}

@@ -1,6 +1,9 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
+  AGENTV_RESULTS_ARTIFACTS_REF,
+  AGENTV_RESULTS_PRIMARY_REF,
   AGENT_PROVIDER_KINDS,
+  EXECUTION_TRACE_SCHEMA_VERSION,
   buildPromptInputs,
   external_exports,
   extractLastAssistantContent,
@@ -18,7 +21,7 @@ import {
   readTranscriptJsonl,
   releaseSharedWorkspaceSetup,
   resolveRepoCloneUrl
-} from "./chunk-ZPFM52HV.js";
+} from "./chunk-RFJM2UBD.js";
 
 // ../../packages/core/dist/index.js
 import { readFileSync } from "node:fs";
@@ -29,6 +32,7 @@ import micromatch from "micromatch";
 import { readFile } from "node:fs/promises";
 import path3 from "node:path";
 import { execFile, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
@@ -51,6 +55,1429 @@ import path5 from "node:path";
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import path6 from "node:path";
+var TRACE_SESSION_SCHEMA_VERSION = "agentv.dashboard.trace_session.v1";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function finiteInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function boolValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function compactRecord(value) {
+  const compacted = dropUndefined(value);
+  return Object.keys(compacted).length > 0 ? compacted : void 0;
+}
+function nonEmptyArray(value) {
+  return value && value.length > 0 ? value : void 0;
+}
+function unixNanoToIso(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    return new Date(Number(BigInt(value) / 1000000n)).toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function durationMsFromNanos(start, end) {
+  if (!start || !end) {
+    return void 0;
+  }
+  try {
+    const startNanos = BigInt(start);
+    const endNanos = BigInt(end);
+    if (endNanos < startNanos) {
+      return void 0;
+    }
+    return Number(endNanos - startNanos) / 1e6;
+  } catch {
+    return void 0;
+  }
+}
+function numberFromAttributes(attributes, keys) {
+  for (const key of keys) {
+    const value = finiteNumber(attributes[key]);
+    if (value !== void 0) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function tokenUsageFromAttributes(attributes) {
+  if (!attributes) {
+    return void 0;
+  }
+  const nested = asRecord(attributes.token_usage);
+  const usage = compactRecord({
+    input: finiteNumber(nested?.input) ?? numberFromAttributes(attributes, [
+      "gen_ai.usage.input_tokens",
+      "llm.token_count.prompt",
+      "input_tokens"
+    ]),
+    output: finiteNumber(nested?.output) ?? numberFromAttributes(attributes, [
+      "gen_ai.usage.output_tokens",
+      "llm.token_count.completion",
+      "output_tokens"
+    ]),
+    reasoning: finiteNumber(nested?.reasoning) ?? numberFromAttributes(attributes, [
+      "gen_ai.usage.reasoning.output_tokens",
+      "reasoning_tokens"
+    ]),
+    cached: finiteNumber(nested?.cached) ?? numberFromAttributes(attributes, ["gen_ai.usage.cache_read.input_tokens", "cached_tokens"]),
+    total: finiteNumber(nested?.total) ?? numberFromAttributes(attributes, ["total_tokens"])
+  });
+  return usage;
+}
+function isExternalTraceKey(key) {
+  return key === "external_trace" || key.startsWith("external_trace_") || key.startsWith("external_trace.");
+}
+function isCredentialLikeKey(key) {
+  const normalized = key.toLowerCase();
+  if (normalized === "token_usage" || normalized.endsWith("_tokens") || normalized.endsWith(".tokens") || normalized.includes("usage.")) {
+    return false;
+  }
+  return /(^|[._-])(api[._-]?key|authorization|bearer|password|secret|private[._-]?key|access[._-]?token|auth[._-]?token|client[._-]?secret|id[._-]?token|refresh[._-]?token|session[._-]?token|token)($|[._-])/.test(
+    normalized
+  );
+}
+function sanitizeAttributeMap(value) {
+  if (!value) {
+    return void 0;
+  }
+  const entries = Object.entries(value).flatMap(([key, entry]) => {
+    if (isExternalTraceKey(key) || isCredentialLikeKey(key)) {
+      return [];
+    }
+    if (isRecord(entry)) {
+      const nested = sanitizeAttributeMap(entry);
+      return nested ? [[key, nested]] : [];
+    }
+    return [[key, entry]];
+  });
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function spanStatusFromValue(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  return compactRecord({
+    code: stringValue(record.code) ?? (typeof record.code === "number" ? String(record.code) : void 0),
+    message: stringValue(record.message)
+  });
+}
+function eventKind(name, attributes) {
+  const lowerName = name.toLowerCase();
+  if (lowerName.includes("score") || numberFromAttributes(attributes ?? {}, [
+    "score",
+    "agentv.score",
+    "agentv.grader.score",
+    "gen_ai.evaluation.score.value",
+    "openinference.evaluation.score"
+  ]) !== void 0) {
+    return "score";
+  }
+  if (lowerName.includes("annotation") || stringValue(attributes?.text) !== void 0 || stringValue(attributes?.annotation) !== void 0 || stringValue(attributes?.["agentv.annotation.text"]) !== void 0) {
+    return "annotation";
+  }
+  if (lowerName === "exception") {
+    return "exception";
+  }
+  return "event";
+}
+function scoreFromEvent(attributes) {
+  if (!attributes) {
+    return void 0;
+  }
+  return finiteNumber(attributes.score) ?? finiteNumber(attributes["agentv.score"]) ?? finiteNumber(attributes["agentv.grader.score"]) ?? finiteNumber(attributes["gen_ai.evaluation.score.value"]) ?? finiteNumber(attributes["openinference.evaluation.score"]);
+}
+function textFromEvent(attributes) {
+  if (!attributes) {
+    return void 0;
+  }
+  return stringValue(attributes.text) ?? stringValue(attributes.annotation) ?? stringValue(attributes["agentv.annotation.text"]) ?? stringValue(attributes["gen_ai.evaluation.explanation"]) ?? stringValue(attributes["gen_ai.evaluation.score.label"]) ?? stringValue(attributes["exception.message"]);
+}
+function passedFromEvent(attributes) {
+  if (!attributes) {
+    return void 0;
+  }
+  return boolValue(attributes.passed) ?? boolValue(attributes["agentv.annotation.passed"]) ?? boolValue(attributes["agentv.grader.passed"]) ?? boolValue(attributes["gen_ai.evaluation.passed"]);
+}
+function eventId(spanId, index, attributes) {
+  return stringValue(attributes?.event_id) ?? stringValue(attributes?.["agentv.event_id"]) ?? `${spanId}:event:${index}`;
+}
+function projectSpanEvent(spanId, event, index) {
+  const record = asRecord(event);
+  if (!record) {
+    return void 0;
+  }
+  const name = stringValue(record.name);
+  if (!name) {
+    return void 0;
+  }
+  const attributes = asRecord(record.attributes);
+  const safeAttributes = sanitizeAttributeMap(attributes);
+  return dropUndefined({
+    event_id: eventId(spanId, index, attributes),
+    span_id: spanId,
+    name,
+    kind: eventKind(name, attributes),
+    time_unix_nano: stringValue(record.time_unix_nano),
+    timestamp: unixNanoToIso(stringValue(record.time_unix_nano)),
+    score: scoreFromEvent(attributes),
+    text: textFromEvent(attributes),
+    passed: passedFromEvent(attributes),
+    attributes: safeAttributes
+  });
+}
+function projectSpan(span, index) {
+  const record = asRecord(span);
+  if (!record) {
+    return void 0;
+  }
+  const spanId = stringValue(record.span_id) ?? `span-${index}`;
+  const traceId = stringValue(record.trace_id);
+  const parentSpanId = record.parent_span_id === null ? null : stringValue(record.parent_span_id);
+  const attributes = asRecord(record.attributes);
+  const safeAttributes = sanitizeAttributeMap(attributes);
+  const startTimeUnixNano = stringValue(record.start_time_unix_nano);
+  const endTimeUnixNano = stringValue(record.end_time_unix_nano);
+  const events = asArray(record.events).map((event, eventIndex) => projectSpanEvent(spanId, event, eventIndex)).filter((event) => event !== void 0);
+  return dropUndefined({
+    id: spanId,
+    trace_id: traceId,
+    span_id: spanId,
+    parent_span_id: parentSpanId,
+    name: stringValue(record.name) ?? spanId,
+    kind: stringValue(record.kind),
+    status: spanStatusFromValue(record.status),
+    start_time_unix_nano: startTimeUnixNano,
+    end_time_unix_nano: endTimeUnixNano,
+    start_time: unixNanoToIso(startTimeUnixNano),
+    end_time: unixNanoToIso(endTimeUnixNano),
+    duration_ms: durationMsFromNanos(startTimeUnixNano, endTimeUnixNano),
+    token_usage: tokenUsageFromAttributes(attributes),
+    resource_attributes: sanitizeAttributeMap(asRecord(record.resource_attributes)),
+    attributes: safeAttributes,
+    events: events.length > 0 ? events : void 0
+  });
+}
+function projectScores(scores) {
+  const projected = [];
+  for (const score of asArray(scores)) {
+    const record = asRecord(score);
+    const name = stringValue(record?.name);
+    const value = finiteNumber(record?.score);
+    if (!record || !name || value === void 0) {
+      continue;
+    }
+    projected.push(
+      dropUndefined({
+        name,
+        type: stringValue(record.type),
+        score: value,
+        weight: finiteNumber(record.weight),
+        verdict: stringValue(record.verdict),
+        source: stringValue(record.source),
+        evaluated_at: stringValue(record.evaluated_at),
+        target_span_id: stringValue(record.target_span_id),
+        evidence: asRecord(record.evidence)
+      })
+    );
+  }
+  return projected.length > 0 ? projected : void 0;
+}
+var EXTERNAL_TRACE_KEYS = [
+  "provider",
+  "source",
+  "endpoint",
+  "profile",
+  "project",
+  "project_id",
+  "session_id",
+  "session_node_id",
+  "trace_id",
+  "trace_node_id",
+  "span_id",
+  "span_node_id",
+  "traceparent",
+  "tracestate",
+  "ui_url",
+  "run_id",
+  "test_id",
+  "target"
+];
+function sanitizeUrl(value) {
+  const raw = stringValue(value);
+  if (!raw) {
+    return void 0;
+  }
+  try {
+    const url = new URL(raw);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
+      return void 0;
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return void 0;
+  }
+}
+function sanitizeExternalTrace(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  const sanitized = compactRecord({
+    provider: stringValue(record.provider),
+    source: stringValue(record.source),
+    endpoint: sanitizeUrl(record.endpoint),
+    profile: stringValue(record.profile),
+    project: stringValue(record.project),
+    project_id: stringValue(record.project_id) ?? stringValue(record.projectId),
+    session_id: stringValue(record.session_id) ?? stringValue(record.session),
+    session_node_id: stringValue(record.session_node_id) ?? stringValue(record.session_node) ?? stringValue(record.node_id),
+    trace_id: stringValue(record.trace_id) ?? stringValue(record.trace),
+    trace_node_id: stringValue(record.trace_node_id) ?? stringValue(record.trace_node),
+    span_id: stringValue(record.span_id) ?? stringValue(record.span),
+    span_node_id: stringValue(record.span_node_id) ?? stringValue(record.span_node),
+    traceparent: stringValue(record.traceparent),
+    tracestate: stringValue(record.tracestate),
+    ui_url: sanitizeUrl(record.ui_url ?? record.url ?? record.href),
+    run_id: stringValue(record.run_id),
+    test_id: stringValue(record.test_id),
+    target: stringValue(record.target)
+  });
+  return sanitized && EXTERNAL_TRACE_KEYS.some((key) => sanitized[key] !== void 0) ? sanitized : void 0;
+}
+function externalTraceFromFlatMetadata(metadata) {
+  if (!metadata) {
+    return void 0;
+  }
+  return sanitizeExternalTrace({
+    provider: metadata.external_trace_provider ?? metadata["external_trace.provider"],
+    source: metadata.external_trace_source ?? metadata["external_trace.source"],
+    endpoint: metadata.external_trace_endpoint ?? metadata["external_trace.endpoint"],
+    profile: metadata.external_trace_profile ?? metadata["external_trace.profile"],
+    project: metadata.external_trace_project ?? metadata["external_trace.project"],
+    project_id: metadata.external_trace_project_id ?? metadata["external_trace.project_id"],
+    session_id: metadata.external_trace_session_id ?? metadata.external_trace_session ?? metadata["external_trace.session_id"] ?? metadata["external_trace.session"],
+    session_node_id: metadata.external_trace_session_node_id ?? metadata.external_trace_node_id ?? metadata["external_trace.session_node_id"] ?? metadata["external_trace.node_id"],
+    trace_id: metadata.external_trace_trace_id ?? metadata.external_trace_trace ?? metadata["external_trace.trace_id"] ?? metadata["external_trace.trace"],
+    trace_node_id: metadata.external_trace_trace_node_id ?? metadata["external_trace.trace_node_id"],
+    span_id: metadata.external_trace_span_id ?? metadata.external_trace_span ?? metadata["external_trace.span_id"] ?? metadata["external_trace.span"],
+    span_node_id: metadata.external_trace_span_node_id ?? metadata["external_trace.span_node_id"],
+    traceparent: metadata.external_trace_traceparent ?? metadata["external_trace.traceparent"],
+    tracestate: metadata.external_trace_tracestate ?? metadata["external_trace.tracestate"],
+    ui_url: metadata.external_trace_ui_url ?? metadata.external_trace_url ?? metadata["external_trace.ui_url"] ?? metadata["external_trace.url"],
+    run_id: metadata.external_trace_run_id ?? metadata["external_trace.run_id"],
+    test_id: metadata.external_trace_test_id ?? metadata["external_trace.test_id"],
+    target: metadata.external_trace_target ?? metadata["external_trace.target"]
+  });
+}
+function sanitizeMetadataValue(value) {
+  if (Array.isArray(value)) {
+    const sanitized = value.map(sanitizeMetadataValue).filter((entry) => entry !== void 0);
+    return sanitized.length > 0 ? sanitized : void 0;
+  }
+  if (isRecord(value)) {
+    return sanitizeMetadata(value);
+  }
+  return value;
+}
+function sanitizeMetadata(value) {
+  if (!value) {
+    return void 0;
+  }
+  const entries = Object.entries(value).flatMap(([key, entry]) => {
+    if (isExternalTraceKey(key) || isCredentialLikeKey(key)) {
+      return [];
+    }
+    const sanitized = sanitizeMetadataValue(entry);
+    return sanitized !== void 0 ? [[key, sanitized]] : [];
+  });
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+}
+function sourceFromEnvelope(source, artifactPath) {
+  if (!source && !artifactPath) {
+    return void 0;
+  }
+  return compactRecord({
+    kind: stringValue(source?.kind),
+    path: stringValue(source?.path),
+    provider: stringValue(source?.provider),
+    format: stringValue(source?.format),
+    version: stringValue(source?.version),
+    artifact_path: artifactPath,
+    metadata: sanitizeMetadata(asRecord(source?.metadata))
+  });
+}
+function safeArtifactPath(value) {
+  const raw = stringValue(value);
+  if (!raw || raw.includes("\0")) {
+    return void 0;
+  }
+  const normalized = raw.replace(/\\/g, "/");
+  if (normalized.startsWith("/") || normalized.startsWith("//")) {
+    return void 0;
+  }
+  if (/^[a-z][a-z0-9+.-]*:/i.test(normalized)) {
+    return void 0;
+  }
+  if (normalized.split("/").includes("..")) {
+    return void 0;
+  }
+  return normalized;
+}
+function projectArtifactLinks(artifacts) {
+  const record = asRecord(artifacts);
+  if (!record) {
+    return void 0;
+  }
+  const links = Object.entries(record).flatMap(([name, value]) => {
+    if (!stringValue(name) || isCredentialLikeKey(name)) {
+      return [];
+    }
+    const artifactPath = safeArtifactPath(value);
+    return artifactPath ? [{ name, path: artifactPath }] : [];
+  }).sort((first, second) => first.name.localeCompare(second.name));
+  return links.length > 0 ? links : void 0;
+}
+function projectSourceRef(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return void 0;
+  }
+  return compactRecord({
+    event_id: stringValue(record.event_id),
+    message_id: stringValue(record.message_id),
+    span_id: stringValue(record.span_id),
+    trace_id: stringValue(record.trace_id),
+    raw_kind: stringValue(record.raw_kind),
+    path: safeArtifactPath(record.path),
+    line: finiteInteger(record.line),
+    metadata: sanitizeMetadata(asRecord(record.metadata))
+  });
+}
+function projectConversionWarnings(warnings) {
+  const projected = [];
+  for (const warning of asArray(warnings)) {
+    const record = asRecord(warning);
+    const code = stringValue(record?.code);
+    const message = stringValue(record?.message);
+    if (!record || !code || !message) {
+      continue;
+    }
+    projected.push(
+      dropUndefined({
+        code,
+        severity: stringValue(record.severity),
+        span_id: stringValue(record.span_id),
+        source_ref: projectSourceRef(record.source_ref),
+        message,
+        details: sanitizeMetadata(asRecord(record.details))
+      })
+    );
+  }
+  return projected.length > 0 ? projected : void 0;
+}
+function externalTraceFromEnvelope(envelope) {
+  const source = asRecord(envelope.source);
+  const sourceMetadata = asRecord(source?.metadata);
+  const trace = asRecord(envelope.trace);
+  const rootSpanId = stringValue(trace?.root_span_id);
+  const rootSpan = asArray(trace?.spans).map(asRecord).find((span) => stringValue(span?.span_id) === rootSpanId);
+  const rootAttributes = asRecord(rootSpan?.attributes);
+  return sanitizeExternalTrace(envelope.external_trace) ?? sanitizeExternalTrace(sourceMetadata?.external_trace) ?? externalTraceFromFlatMetadata(sourceMetadata) ?? externalTraceFromFlatMetadata(rootAttributes);
+}
+function traceEnvelopeToTraceSessionResponse(input, options = {}) {
+  const envelope = asRecord(input) ?? {};
+  const evaluation = asRecord(envelope.eval);
+  const trace = asRecord(envelope.trace);
+  const traceResource = asRecord(trace?.resource);
+  const spans = asArray(trace?.spans).map(projectSpan).filter((span) => span !== void 0);
+  const events = spans.flatMap((span) => span.events ?? []);
+  return dropUndefined({
+    schema_version: TRACE_SESSION_SCHEMA_VERSION,
+    artifact_id: stringValue(envelope.artifact_id),
+    created_at: stringValue(envelope.created_at),
+    run_id: options.runId ?? stringValue(evaluation?.run_id),
+    test_id: stringValue(evaluation?.test_id),
+    suite: stringValue(evaluation?.suite),
+    target: stringValue(evaluation?.target),
+    trace_id: stringValue(trace?.trace_id),
+    root_span_id: stringValue(trace?.root_span_id),
+    source: sourceFromEnvelope(asRecord(envelope.source), options.artifactPath),
+    external_trace: externalTraceFromEnvelope(envelope),
+    artifact_links: projectArtifactLinks(envelope.artifacts),
+    resource_attributes: sanitizeAttributeMap(asRecord(traceResource?.attributes)),
+    conversion_warnings: projectConversionWarnings(envelope.conversion_warnings),
+    spans,
+    events,
+    scores: projectScores(envelope.scores)
+  });
+}
+function buildTraceSpanTree(spans) {
+  const nodes = [];
+  const firstNodeBySpanId = /* @__PURE__ */ new Map();
+  const spanIdCounts = /* @__PURE__ */ new Map();
+  spans.forEach((span, index) => {
+    const rawSpanId = stringValue(span.span_id);
+    const spanId = rawSpanId ?? `missing-span-${index}`;
+    const occurrence = (spanIdCounts.get(spanId) ?? 0) + 1;
+    spanIdCounts.set(spanId, occurrence);
+    const node = {
+      id: occurrence === 1 ? spanId : `${spanId}#${occurrence}`,
+      spanId,
+      parentSpanId: span.parent_span_id,
+      span,
+      children: [],
+      diagnostics: rawSpanId ? void 0 : [
+        {
+          code: "missing_span_id",
+          message: "Span was missing span_id and was assigned a stable node id.",
+          node_id: spanId
+        }
+      ]
+    };
+    if (occurrence > 1) {
+      addNodeDiagnostic(node, {
+        code: "duplicate_span_id",
+        message: "Duplicate span_id was preserved with a collision-free node id.",
+        span_id: spanId,
+        node_id: node.id
+      });
+    }
+    if (!firstNodeBySpanId.has(spanId)) {
+      firstNodeBySpanId.set(spanId, node);
+    }
+    nodes.push(node);
+  });
+  const parentByNodeId = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const parentSpanId = typeof node.parentSpanId === "string" && node.parentSpanId.length > 0 ? node.parentSpanId : void 0;
+    if (!parentSpanId) {
+      continue;
+    }
+    if (parentSpanId === node.spanId) {
+      addNodeDiagnostic(node, {
+        code: "self_parent",
+        message: "Span parent_span_id points to itself; span was promoted to a root.",
+        span_id: node.spanId,
+        node_id: node.id,
+        parent_span_id: parentSpanId
+      });
+      continue;
+    }
+    const parent = firstNodeBySpanId.get(parentSpanId);
+    if (!parent) {
+      addNodeDiagnostic(node, {
+        code: "missing_parent",
+        message: "Span parent_span_id was not present in this trace; span was promoted to a root.",
+        span_id: node.spanId,
+        node_id: node.id,
+        parent_span_id: parentSpanId
+      });
+      continue;
+    }
+    parentByNodeId.set(node.id, parent);
+  }
+  const cyclicNodes = [];
+  for (const node of nodes) {
+    if (hasAncestorCycle(node, parentByNodeId)) {
+      cyclicNodes.push(node);
+    }
+  }
+  for (const node of cyclicNodes) {
+    parentByNodeId.delete(node.id);
+    addNodeDiagnostic(node, {
+      code: "cycle",
+      message: "Span parent chain contains a cycle; span was promoted to a root.",
+      span_id: node.spanId,
+      node_id: node.id,
+      parent_span_id: typeof node.parentSpanId === "string" ? node.parentSpanId : void 0
+    });
+  }
+  const roots = [];
+  for (const node of nodes) {
+    const parent = parentByNodeId.get(node.id);
+    if (parent) {
+      parent.children.push(node);
+    } else {
+      roots.push(node);
+    }
+  }
+  sortTraceSpanNodes(roots);
+  return roots;
+}
+function addNodeDiagnostic(node, diagnostic) {
+  node.diagnostics = [...node.diagnostics ?? [], diagnostic];
+}
+function hasAncestorCycle(node, parentByNodeId) {
+  const seen = /* @__PURE__ */ new Set();
+  let cursor = parentByNodeId.get(node.id);
+  while (cursor) {
+    if (cursor.id === node.id || seen.has(cursor.id)) {
+      return true;
+    }
+    seen.add(cursor.id);
+    cursor = parentByNodeId.get(cursor.id);
+  }
+  return false;
+}
+function compareUnixNanoValue(first, second) {
+  if (first === second) {
+    return 0;
+  }
+  if (!first) {
+    return 1;
+  }
+  if (!second) {
+    return -1;
+  }
+  try {
+    const firstValue = BigInt(first);
+    const secondValue = BigInt(second);
+    return firstValue < secondValue ? -1 : firstValue > secondValue ? 1 : 0;
+  } catch {
+    return first.localeCompare(second);
+  }
+}
+function compareTraceSpanNodes(first, second) {
+  const byStart = compareUnixNanoValue(
+    first.span.start_time_unix_nano,
+    second.span.start_time_unix_nano
+  );
+  if (byStart !== 0) {
+    return byStart;
+  }
+  if (first.spanId === second.parentSpanId) {
+    return -1;
+  }
+  if (second.spanId === first.parentSpanId) {
+    return 1;
+  }
+  const bySpanId = first.spanId.localeCompare(second.spanId);
+  return bySpanId !== 0 ? bySpanId : first.id.localeCompare(second.id);
+}
+function sortTraceSpanNodes(nodes) {
+  nodes.sort(compareTraceSpanNodes);
+  for (const node of nodes) {
+    node.children.sort(compareTraceSpanNodes);
+    if (node.children.length > 0) {
+      sortTraceSpanNodes(node.children);
+    }
+    node.diagnostics = nonEmptyArray(node.diagnostics);
+  }
+}
+var TRACE_ENVELOPE_FORMAT = "otlp_openinference_spans";
+var OTLP_ROOT_FIELDS = /* @__PURE__ */ new Set(["resourceSpans"]);
+var OTLP_RESOURCE_SPAN_FIELDS = /* @__PURE__ */ new Set(["resource", "scopeSpans", "schemaUrl"]);
+var OTLP_RESOURCE_FIELDS = /* @__PURE__ */ new Set(["attributes", "droppedAttributesCount"]);
+var OTLP_SCOPE_SPAN_FIELDS = /* @__PURE__ */ new Set(["scope", "spans", "schemaUrl"]);
+var OTLP_SCOPE_FIELDS = /* @__PURE__ */ new Set(["name", "version", "attributes", "droppedAttributesCount"]);
+var OTLP_SPAN_FIELDS = /* @__PURE__ */ new Set([
+  "traceId",
+  "spanId",
+  "parentSpanId",
+  "traceState",
+  "name",
+  "kind",
+  "startTimeUnixNano",
+  "endTimeUnixNano",
+  "attributes",
+  "droppedAttributesCount",
+  "events",
+  "droppedEventsCount",
+  "links",
+  "droppedLinksCount",
+  "status"
+]);
+var OTLP_EVENT_FIELDS = /* @__PURE__ */ new Set(["timeUnixNano", "name", "attributes", "droppedAttributesCount"]);
+var OTLP_STATUS_FIELDS = /* @__PURE__ */ new Set(["code", "message"]);
+var OTLP_ATTRIBUTE_FIELDS = /* @__PURE__ */ new Set(["key", "value"]);
+var OTLP_ANY_VALUE_FIELDS = /* @__PURE__ */ new Set([
+  "stringValue",
+  "boolValue",
+  "intValue",
+  "doubleValue",
+  "arrayValue",
+  "kvlistValue",
+  "bytesValue"
+]);
+function normalizeTraceArtifactToTraceSessionResponse(input, options = {}) {
+  const artifact = asRecord2(input);
+  if (!artifact) {
+    return {
+      status: "unsupported",
+      message: "Trace artifact is not a JSON object."
+    };
+  }
+  if (stringValue2(artifact.schema_version) === EXECUTION_TRACE_SCHEMA_VERSION) {
+    return normalizeAgentVTraceEnvelope(artifact, options);
+  }
+  if (Object.hasOwn(artifact, "resourceSpans")) {
+    return normalizeOtlpJson(artifact, options);
+  }
+  return {
+    status: "unsupported",
+    message: "Trace artifact is not an agentv.trace.v1 envelope or OTLP JSON resourceSpans body."
+  };
+}
+function normalizeAgentVTraceEnvelope(artifact, options) {
+  const trace = asRecord2(artifact.trace);
+  if (!Array.isArray(trace?.spans)) {
+    return {
+      status: "unsupported",
+      message: "Trace artifact is not an agentv.trace.v1 envelope with trace.spans."
+    };
+  }
+  const traceSession = traceEnvelopeToTraceSessionResponse(artifact, options);
+  return {
+    status: "ok",
+    format: "agentv_trace_v1",
+    traceSession,
+    warnings: traceSession.conversion_warnings
+  };
+}
+function normalizeOtlpJson(artifact, options) {
+  const warnings = [];
+  warnUnknownFields(artifact, OTLP_ROOT_FIELDS, warnings, {
+    rawKind: "otlp_json",
+    path: options.artifactPath
+  });
+  const resourceSpans = Array.isArray(artifact.resourceSpans) ? artifact.resourceSpans : [];
+  if (!Array.isArray(artifact.resourceSpans)) {
+    addWarning(warnings, "malformed_otlp_resource_spans", "OTLP resourceSpans must be an array.", {
+      rawKind: "otlp_json",
+      path: options.artifactPath
+    });
+  }
+  const spans = [];
+  const resourceAttributeSets = [];
+  let scopeSpanCount = 0;
+  let firstScope;
+  resourceSpans.forEach((resourceSpan, resourceSpanIndex) => {
+    const resourceRecord = asRecord2(resourceSpan);
+    if (!resourceRecord) {
+      addWarning(
+        warnings,
+        "malformed_otlp_resource_span",
+        "OTLP resourceSpans entry must be an object and was skipped.",
+        {
+          rawKind: "otlp_resource_span",
+          path: options.artifactPath,
+          details: { resource_span_index: resourceSpanIndex }
+        }
+      );
+      return;
+    }
+    warnUnknownFields(resourceRecord, OTLP_RESOURCE_SPAN_FIELDS, warnings, {
+      rawKind: "otlp_resource_span",
+      path: options.artifactPath,
+      details: { resource_span_index: resourceSpanIndex }
+    });
+    const resource = asRecord2(resourceRecord.resource);
+    if (resource) {
+      warnUnknownFields(resource, OTLP_RESOURCE_FIELDS, warnings, {
+        rawKind: "otlp_resource",
+        path: options.artifactPath,
+        details: { resource_span_index: resourceSpanIndex }
+      });
+    }
+    const resourceAttributes2 = parseOtlpAttributes(resource?.attributes, warnings, {
+      rawKind: "otlp_resource_attributes",
+      path: options.artifactPath,
+      details: { resource_span_index: resourceSpanIndex }
+    });
+    if (resourceAttributes2 && Object.keys(resourceAttributes2).length > 0) {
+      resourceAttributeSets.push(resourceAttributes2);
+    }
+    const scopeSpans = Array.isArray(resourceRecord.scopeSpans) ? resourceRecord.scopeSpans : [];
+    if (!Array.isArray(resourceRecord.scopeSpans)) {
+      addWarning(
+        warnings,
+        "malformed_otlp_scope_spans",
+        "OTLP resourceSpans.scopeSpans must be an array and was skipped.",
+        {
+          rawKind: "otlp_resource_span",
+          path: options.artifactPath,
+          details: { resource_span_index: resourceSpanIndex }
+        }
+      );
+    }
+    scopeSpans.forEach((scopeSpan, scopeSpanIndex) => {
+      const scopeSpanRecord = asRecord2(scopeSpan);
+      if (!scopeSpanRecord) {
+        addWarning(
+          warnings,
+          "malformed_otlp_scope_span",
+          "OTLP scopeSpans entry must be an object and was skipped.",
+          {
+            rawKind: "otlp_scope_span",
+            path: options.artifactPath,
+            details: { resource_span_index: resourceSpanIndex, scope_span_index: scopeSpanIndex }
+          }
+        );
+        return;
+      }
+      scopeSpanCount += 1;
+      warnUnknownFields(scopeSpanRecord, OTLP_SCOPE_SPAN_FIELDS, warnings, {
+        rawKind: "otlp_scope_span",
+        path: options.artifactPath,
+        details: { resource_span_index: resourceSpanIndex, scope_span_index: scopeSpanIndex }
+      });
+      const scope = normalizeOtlpScope(scopeSpanRecord.scope, warnings, {
+        rawKind: "otlp_scope",
+        path: options.artifactPath,
+        details: { resource_span_index: resourceSpanIndex, scope_span_index: scopeSpanIndex }
+      });
+      firstScope ??= scope;
+      const otlpSpans = Array.isArray(scopeSpanRecord.spans) ? scopeSpanRecord.spans : [];
+      if (!Array.isArray(scopeSpanRecord.spans)) {
+        addWarning(
+          warnings,
+          "malformed_otlp_spans",
+          "OTLP scopeSpans.spans must be an array and was skipped.",
+          {
+            rawKind: "otlp_scope_span",
+            path: options.artifactPath,
+            details: { resource_span_index: resourceSpanIndex, scope_span_index: scopeSpanIndex }
+          }
+        );
+      }
+      otlpSpans.forEach((span, spanIndex) => {
+        const normalized = normalizeOtlpSpan(span, warnings, {
+          resourceAttributes: resourceAttributes2,
+          path: options.artifactPath,
+          resourceSpanIndex,
+          scopeSpanIndex,
+          spanIndex
+        });
+        if (normalized) {
+          spans.push(normalized);
+        }
+      });
+    });
+  });
+  if (spans.length === 0) {
+    addWarning(warnings, "empty_otlp_trace", "OTLP JSON did not contain any readable spans.", {
+      rawKind: "otlp_json",
+      path: options.artifactPath
+    });
+  }
+  const traceId = firstString(spans.map((span) => span.trace_id));
+  const rootSpanId = firstRootSpanId(spans);
+  const resourceAttributes = singleDistinctRecord(resourceAttributeSets);
+  const createdAt = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+  const artifactPath = options.artifactPath;
+  const envelope = dropUndefined2({
+    schema_version: EXECUTION_TRACE_SCHEMA_VERSION,
+    artifact_id: `otlp-trace-${traceId ?? rootSpanId ?? "unknown"}`,
+    created_at: createdAt,
+    eval: dropUndefined2({
+      run_id: options.runId,
+      test_id: options.testId ?? traceId ?? "otlp-trace",
+      suite: options.suite,
+      target: options.target ?? "unknown"
+    }),
+    trace: dropUndefined2({
+      format: TRACE_ENVELOPE_FORMAT,
+      trace_id: traceId,
+      root_span_id: rootSpanId,
+      resource: resourceAttributes ? { attributes: resourceAttributes } : void 0,
+      scope: firstScope,
+      spans
+    }),
+    source: dropUndefined2({
+      kind: "otlp",
+      path: artifactPath,
+      format: "otlp_json",
+      version: "1",
+      metadata: dropUndefined2({
+        resource_spans_count: resourceSpans.length,
+        scope_spans_count: scopeSpanCount
+      })
+    }),
+    capture: {
+      content: "metadata",
+      redaction_level: "partial"
+    },
+    conversion_warnings: warnings.length > 0 ? warnings : void 0,
+    artifacts: artifactPath ? { raw_trace_path: artifactPath } : void 0
+  });
+  const traceSession = traceEnvelopeToTraceSessionResponse(envelope, options);
+  return {
+    status: "ok",
+    format: "otlp_json",
+    traceSession,
+    warnings: traceSession.conversion_warnings
+  };
+}
+function normalizeOtlpScope(value, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const scope = asRecord2(value);
+  if (!scope) {
+    addWarning(warnings, "malformed_otlp_scope", "OTLP scope must be an object and was ignored.", {
+      ...context,
+      rawKind: context.rawKind ?? "otlp_scope"
+    });
+    return void 0;
+  }
+  warnUnknownFields(scope, OTLP_SCOPE_FIELDS, warnings, context);
+  const normalized = dropUndefined2({
+    name: stringValue2(scope.name),
+    version: stringValue2(scope.version)
+  });
+  return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function normalizeOtlpSpan(value, warnings, context) {
+  const span = asRecord2(value);
+  const details = {
+    resource_span_index: context.resourceSpanIndex,
+    scope_span_index: context.scopeSpanIndex,
+    span_index: context.spanIndex
+  };
+  if (!span) {
+    addWarning(warnings, "malformed_otlp_span", "OTLP span must be an object and was skipped.", {
+      rawKind: "otlp_span",
+      path: context.path,
+      details
+    });
+    return void 0;
+  }
+  warnUnknownFields(span, OTLP_SPAN_FIELDS, warnings, {
+    rawKind: "otlp_span",
+    path: context.path,
+    details
+  });
+  const spanId = stringValue2(span.spanId) ?? `missing-span-${context.resourceSpanIndex}-${context.scopeSpanIndex}-${context.spanIndex}`;
+  if (!stringValue2(span.spanId)) {
+    addWarning(
+      warnings,
+      "missing_span_id",
+      "OTLP span was missing spanId; a stable ID was assigned.",
+      {
+        rawKind: "otlp_span",
+        path: context.path,
+        spanId,
+        details
+      }
+    );
+  }
+  const traceId = stringValue2(span.traceId);
+  if (!traceId) {
+    addWarning(warnings, "missing_trace_id", "OTLP span was missing traceId.", {
+      rawKind: "otlp_span",
+      path: context.path,
+      spanId,
+      details
+    });
+  }
+  const name = stringValue2(span.name) ?? spanId;
+  if (!stringValue2(span.name)) {
+    addWarning(warnings, "missing_span_name", "OTLP span was missing name; spanId was used.", {
+      rawKind: "otlp_span",
+      path: context.path,
+      spanId,
+      details
+    });
+  }
+  const parentSpanId = span.parentSpanId === void 0 || span.parentSpanId === null || span.parentSpanId === "" ? null : stringValue2(span.parentSpanId);
+  if (span.parentSpanId !== void 0 && span.parentSpanId !== null && span.parentSpanId !== "" && !parentSpanId) {
+    addWarning(
+      warnings,
+      "malformed_parent_span_id",
+      "OTLP span parentSpanId was not a string and was ignored.",
+      {
+        rawKind: "otlp_span",
+        path: context.path,
+        spanId,
+        details
+      }
+    );
+  }
+  const attributes = parseOtlpAttributes(span.attributes, warnings, {
+    rawKind: "otlp_span_attributes",
+    path: context.path,
+    spanId,
+    details
+  });
+  const events = normalizeOtlpEvents(span.events, warnings, {
+    path: context.path,
+    spanId,
+    details
+  });
+  return dropUndefined2({
+    trace_id: traceId,
+    span_id: spanId,
+    parent_span_id: parentSpanId,
+    name,
+    kind: normalizeOtlpSpanKind(span.kind, warnings, {
+      rawKind: "otlp_span",
+      path: context.path,
+      spanId,
+      details
+    }),
+    start_time_unix_nano: normalizeUnixNano(span.startTimeUnixNano, "startTimeUnixNano", warnings, {
+      rawKind: "otlp_span",
+      path: context.path,
+      spanId,
+      details
+    }),
+    end_time_unix_nano: normalizeUnixNano(span.endTimeUnixNano, "endTimeUnixNano", warnings, {
+      rawKind: "otlp_span",
+      path: context.path,
+      spanId,
+      details
+    }),
+    status: normalizeOtlpStatus(span.status, warnings, {
+      rawKind: "otlp_span_status",
+      path: context.path,
+      spanId,
+      details
+    }),
+    resource_attributes: context.resourceAttributes,
+    attributes,
+    events
+  });
+}
+function normalizeOtlpEvents(value, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    addWarning(warnings, "malformed_otlp_events", "OTLP span events must be an array.", {
+      rawKind: "otlp_span_events",
+      path: context.path,
+      spanId: context.spanId,
+      details: context.details
+    });
+    return void 0;
+  }
+  const events = value.flatMap((event, eventIndex) => {
+    const eventRecord = asRecord2(event);
+    const details = { ...context.details, event_index: eventIndex };
+    if (!eventRecord) {
+      addWarning(
+        warnings,
+        "malformed_otlp_event",
+        "OTLP span event must be an object and was skipped.",
+        {
+          rawKind: "otlp_span_event",
+          path: context.path,
+          spanId: context.spanId,
+          details
+        }
+      );
+      return [];
+    }
+    warnUnknownFields(eventRecord, OTLP_EVENT_FIELDS, warnings, {
+      rawKind: "otlp_span_event",
+      path: context.path,
+      spanId: context.spanId,
+      details
+    });
+    const name = stringValue2(eventRecord.name) ?? `event-${eventIndex}`;
+    if (!stringValue2(eventRecord.name)) {
+      addWarning(
+        warnings,
+        "missing_event_name",
+        "OTLP span event was missing name; a stable name was assigned.",
+        {
+          rawKind: "otlp_span_event",
+          path: context.path,
+          spanId: context.spanId,
+          details
+        }
+      );
+    }
+    return [
+      dropUndefined2({
+        name,
+        time_unix_nano: normalizeUnixNano(eventRecord.timeUnixNano, "timeUnixNano", warnings, {
+          rawKind: "otlp_span_event",
+          path: context.path,
+          spanId: context.spanId,
+          details
+        }),
+        attributes: parseOtlpAttributes(eventRecord.attributes, warnings, {
+          rawKind: "otlp_event_attributes",
+          path: context.path,
+          spanId: context.spanId,
+          details
+        })
+      })
+    ];
+  });
+  return events.length > 0 ? events : void 0;
+}
+function parseOtlpAttributes(value, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (asRecord2(value)) {
+    addWarning(
+      warnings,
+      "nonstandard_otlp_attribute_map",
+      "OTLP attributes were an object map; values were preserved as-is.",
+      context
+    );
+    return value;
+  }
+  if (!Array.isArray(value)) {
+    addWarning(warnings, "malformed_otlp_attributes", "OTLP attributes must be an array.", context);
+    return void 0;
+  }
+  const attributes = {};
+  value.forEach((attribute, attributeIndex) => {
+    const attributeRecord = asRecord2(attribute);
+    const details = { ...context.details ?? {}, attribute_index: attributeIndex };
+    if (!attributeRecord) {
+      addWarning(
+        warnings,
+        "malformed_otlp_attribute",
+        "OTLP attribute must be an object and was skipped.",
+        { ...context, details }
+      );
+      return;
+    }
+    warnUnknownFields(attributeRecord, OTLP_ATTRIBUTE_FIELDS, warnings, {
+      ...context,
+      rawKind: context.rawKind ?? "otlp_attribute",
+      details
+    });
+    const key = stringValue2(attributeRecord.key);
+    if (!key) {
+      addWarning(
+        warnings,
+        "malformed_otlp_attribute",
+        "OTLP attribute was missing key and was skipped.",
+        {
+          ...context,
+          details
+        }
+      );
+      return;
+    }
+    if (Object.hasOwn(attributes, key)) {
+      addWarning(
+        warnings,
+        "duplicate_otlp_attribute",
+        `OTLP attribute "${key}" appeared more than once; the last value was used.`,
+        {
+          ...context,
+          details: { ...details, key }
+        }
+      );
+    }
+    const parsed = parseOtlpAnyValue(attributeRecord.value, warnings, {
+      ...context,
+      rawKind: "otlp_attribute_value",
+      details: { ...details, key }
+    });
+    if (parsed.ok) {
+      attributes[key] = parsed.value;
+    }
+  });
+  return Object.keys(attributes).length > 0 ? attributes : void 0;
+}
+function parseOtlpAnyValue(value, warnings, context) {
+  if (isPrimitive(value)) {
+    addWarning(
+      warnings,
+      "nonstandard_otlp_value",
+      "OTLP attribute value was primitive; value was preserved as-is.",
+      context
+    );
+    return { ok: true, value };
+  }
+  const record = asRecord2(value);
+  if (!record) {
+    addWarning(
+      warnings,
+      "malformed_otlp_value",
+      "OTLP attribute value must be an object.",
+      context
+    );
+    return { ok: false };
+  }
+  const presentFields = Object.keys(record).filter((key) => OTLP_ANY_VALUE_FIELDS.has(key));
+  const unknownFields = Object.keys(record).filter((key) => !OTLP_ANY_VALUE_FIELDS.has(key));
+  if (unknownFields.length > 0) {
+    addWarning(
+      warnings,
+      "unknown_otlp_value_field",
+      `Unknown OTLP attribute value field(s) ignored: ${unknownFields.join(", ")}.`,
+      { ...context, details: { ...context.details ?? {}, fields: unknownFields } }
+    );
+  }
+  if (presentFields.length > 1) {
+    addWarning(
+      warnings,
+      "ambiguous_otlp_value",
+      `OTLP attribute value had multiple value fields; ${presentFields[0]} was used.`,
+      { ...context, details: { ...context.details ?? {}, fields: presentFields } }
+    );
+  }
+  const field = presentFields[0];
+  if (!field) {
+    addWarning(
+      warnings,
+      "malformed_otlp_value",
+      "OTLP attribute value did not contain a recognized value field; raw value was preserved.",
+      context
+    );
+    return { ok: true, value };
+  }
+  switch (field) {
+    case "stringValue":
+    case "bytesValue":
+      return { ok: true, value: stringValue2(record[field]) ?? String(record[field] ?? "") };
+    case "boolValue":
+      return { ok: true, value: Boolean(record.boolValue) };
+    case "intValue":
+      return { ok: true, value: integerOrString(record.intValue) };
+    case "doubleValue":
+      return { ok: true, value: numberOrString(record.doubleValue) };
+    case "arrayValue":
+      return parseOtlpArrayValue(record.arrayValue, warnings, context);
+    case "kvlistValue":
+      return parseOtlpKeyValueList(record.kvlistValue, warnings, context);
+    default:
+      return { ok: true, value };
+  }
+}
+function parseOtlpArrayValue(value, warnings, context) {
+  const arrayValue = asRecord2(value);
+  if (!arrayValue || !Array.isArray(arrayValue.values)) {
+    addWarning(
+      warnings,
+      "malformed_otlp_array_value",
+      "OTLP arrayValue.values must be an array.",
+      context
+    );
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    value: arrayValue.values.map(
+      (entry, index) => parseOtlpAnyValue(entry, warnings, {
+        ...context,
+        details: { ...context.details ?? {}, value_index: index }
+      }).value
+    )
+  };
+}
+function parseOtlpKeyValueList(value, warnings, context) {
+  const kvlistValue = asRecord2(value);
+  if (!kvlistValue || !Array.isArray(kvlistValue.values)) {
+    addWarning(
+      warnings,
+      "malformed_otlp_kvlist_value",
+      "OTLP kvlistValue.values must be an array.",
+      context
+    );
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    value: parseOtlpAttributes(kvlistValue.values, warnings, context) ?? {}
+  };
+}
+function normalizeOtlpSpanKind(value, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return value.replace(/^SPAN_KIND_/, "");
+  }
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    addWarning(
+      warnings,
+      "malformed_span_kind",
+      "OTLP span kind was not a string or integer.",
+      context
+    );
+    return void 0;
+  }
+  if (value === 0) return "INTERNAL";
+  if (value === 1) return "SERVER";
+  if (value === 2) return "CLIENT";
+  if (value === 3) return "PRODUCER";
+  if (value === 4 || value === 5) return "CONSUMER";
+  addWarning(
+    warnings,
+    "unknown_span_kind",
+    `Unknown OTLP span kind ${value} was preserved as a string.`,
+    context
+  );
+  return String(value);
+}
+function normalizeOtlpStatus(value, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const status = asRecord2(value);
+  if (!status) {
+    addWarning(warnings, "malformed_otlp_status", "OTLP span status must be an object.", context);
+    return void 0;
+  }
+  warnUnknownFields(status, OTLP_STATUS_FIELDS, warnings, context);
+  return dropUndefined2({
+    code: normalizeStatusCode(status.code, warnings, context),
+    message: stringValue2(status.message)
+  });
+}
+function normalizeStatusCode(value, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    return value.replace(/^STATUS_CODE_/, "");
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    if (value === 0) return "UNSET";
+    if (value === 1) return "OK";
+    if (value === 2) return "ERROR";
+    addWarning(
+      warnings,
+      "unknown_status_code",
+      `Unknown OTLP status code ${value} was preserved as a string.`,
+      context
+    );
+    return String(value);
+  }
+  addWarning(
+    warnings,
+    "malformed_status_code",
+    "OTLP status code was not a string or integer.",
+    context
+  );
+  return void 0;
+}
+function normalizeUnixNano(value, field, warnings, context) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string" && value.length > 0) {
+    if (!/^\d+$/.test(value)) {
+      addWarning(
+        warnings,
+        "malformed_unix_nano",
+        `OTLP ${field} was not an unsigned integer string.`,
+        context
+      );
+    }
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+    return String(Math.trunc(value));
+  }
+  addWarning(warnings, "malformed_unix_nano", `OTLP ${field} was not a string or number.`, context);
+  return void 0;
+}
+function firstRootSpanId(spans) {
+  const spanIds = new Set(spans.map((span) => span.span_id));
+  return spans.find(
+    (span) => !span.parent_span_id || typeof span.parent_span_id === "string" && !spanIds.has(span.parent_span_id)
+  )?.span_id ?? spans[0]?.span_id;
+}
+function singleDistinctRecord(records) {
+  if (records.length === 0) {
+    return void 0;
+  }
+  const unique = new Map(records.map((record) => [stableRecordKey(record), record]));
+  return unique.size === 1 ? [...unique.values()][0] : void 0;
+}
+function stableRecordKey(record) {
+  return JSON.stringify(
+    Object.keys(record).sort().map((key) => [key, record[key]])
+  );
+}
+function firstString(values) {
+  return values.find((value) => typeof value === "string" && value.length > 0);
+}
+function integerOrString(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const numberValue = Number(value);
+    return Number.isSafeInteger(numberValue) ? numberValue : value;
+  }
+  return String(value ?? "");
+}
+function numberOrString(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const numberValue = Number(value);
+    return Number.isFinite(numberValue) ? numberValue : value;
+  }
+  return String(value ?? "");
+}
+function warnUnknownFields(record, allowed, warnings, context) {
+  const unknownFields = Object.keys(record).filter((key) => !allowed.has(key));
+  for (const field of unknownFields) {
+    addWarning(
+      warnings,
+      "unknown_otlp_field",
+      `Unknown OTLP ${context.rawKind ?? "object"} field "${field}" was ignored.`,
+      { ...context, details: { ...context.details ?? {}, field } }
+    );
+  }
+}
+function addWarning(warnings, code, message, context = {}) {
+  warnings.push(
+    dropUndefined2({
+      code,
+      severity: "warning",
+      span_id: context.spanId,
+      source_ref: context.path || context.rawKind ? dropUndefined2({
+        path: context.path,
+        raw_kind: context.rawKind,
+        span_id: context.spanId
+      }) : void 0,
+      message,
+      details: context.details
+    })
+  );
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function stringValue2(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null;
+}
+function dropUndefined2(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
 function codeGraderInstruction(graderName, description) {
   const desc = description ? ` This grader: ${description}.` : "";
   return `Run \`agentv eval assert ${graderName} --agent-output <agent_output> --agent-input <original_prompt>\` and check the result.${desc} The command accepts --agent-output (the agent's full response text) and --agent-input (the original user prompt). It returns JSON on stdout: {"score": 0-1, "reasoning": "..."}. A score >= 0.5 means pass (exit 0); below 0.5 means fail (exit 1).`;
@@ -682,12 +2109,27 @@ var RESULTS_REPO_RESULTS_DIR = ".agentv/results";
 var RESULTS_REPO_RUNS_DIR = "runs";
 var RESULTS_REPO_METADATA_DIR = "metadata";
 var RESULTS_REPO_TRACKED_DIRS = [RESULTS_REPO_RUNS_DIR, RESULTS_REPO_METADATA_DIR];
-var RESULTS_REPO_COMMIT_EMAIL = "agentv@results-repo";
-var RESULTS_REPO_COMMIT_NAME = "AgentV Results";
-var DEFAULT_RESULTS_BRANCH = "agentv/results/v1";
+var FALLBACK_RESULTS_REPO_COMMIT_EMAIL = "agentv@results-repo";
+var FALLBACK_RESULTS_REPO_COMMIT_NAME = "AgentV Results";
+var GIT_COMMIT_IDENTITY_ENV_KEYS = [
+  "GIT_AUTHOR_NAME",
+  "GIT_AUTHOR_EMAIL",
+  "GIT_COMMITTER_NAME",
+  "GIT_COMMITTER_EMAIL"
+];
+var GIT_ENV_INHERIT_ALLOWLIST = /* @__PURE__ */ new Set([
+  "GIT_ASKPASS",
+  "GIT_PASSWORD",
+  "GIT_SSH_COMMAND",
+  "GIT_TOKEN",
+  "GIT_USERNAME"
+]);
+var DEFAULT_RESULTS_BRANCH = AGENTV_RESULTS_PRIMARY_REF;
+var MANAGED_RESULTS_REMOTE = "agentv-results";
 var GIT_EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var RESULTS_REPO_GENESIS_MESSAGE = "chore(results): initialize AgentV results branch";
 var RESULTS_REPO_GENESIS_DATE = "@0 +0000";
+var RESULT_INDEX_FILENAME2 = "index.jsonl";
 var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
@@ -706,16 +2148,24 @@ function expandHome(p) {
   }
   return p;
 }
+function resolveLocalPath(p, baseDir) {
+  const expanded = expandHome(p);
+  return path4.isAbsolute(expanded) ? expanded : path4.resolve(baseDir, expanded);
+}
 function normalizeResultsConfig(config, options) {
+  const baseDir = options?.baseDir ?? process.cwd();
   const repoUrl = (config.repo_url ?? config.repo)?.trim();
   const repoPath = config.repo_path?.trim();
+  const explicitClonePath = config.path?.trim();
   const repo = repoUrl ?? repoPath ?? "";
   const branch = config.branch?.trim() || (repoPath ? DEFAULT_RESULTS_BRANCH : void 0);
-  const remote = config.remote?.trim() || "origin";
+  const useStorageBranchWorktree = Boolean(repoPath || repoUrl && explicitClonePath && branch);
+  const remote = config.remote?.trim() || (repoUrl && useStorageBranchWorktree ? MANAGED_RESULTS_REMOTE : "origin");
   const autoPush = config.sync?.auto_push ?? config.auto_push === true;
   const requirePush = config.sync?.require_push === true;
-  const resolvedRepoPath = repoPath ? path4.resolve(options?.baseDir ?? process.cwd(), expandHome(repoPath)) : void 0;
-  const resolvedPath = config.path ? expandHome(config.path.trim()) : repoUrl ? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
+  const pushConflictPolicy = config.sync?.push_conflict_policy ?? "block";
+  const resolvedRepoPath = repoPath ? resolveLocalPath(repoPath, baseDir) : void 0;
+  const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -726,7 +2176,9 @@ function normalizeResultsConfig(config, options) {
     path: resolvedPath,
     auto_push: autoPush,
     require_push: requirePush,
-    branch_prefix: config.branch_prefix?.trim() || "eval-results"
+    push_conflict_policy: pushConflictPolicy,
+    branch_prefix: config.branch_prefix?.trim() || "eval-results",
+    storageBranchWorktree: useStorageBranchWorktree
   };
 }
 function resolveResultsRepoUrl(repo) {
@@ -743,6 +2195,9 @@ function getResultsRepoLocalPaths(repo) {
     statusFile: path4.join(rootDir, "status.json")
   };
 }
+function usesStorageBranchWorktree(config) {
+  return config.storageBranchWorktree === true || Boolean(config.repo_path);
+}
 function readPersistedStatus(statusFile) {
   if (!existsSync(statusFile)) {
     return {};
@@ -764,13 +2219,14 @@ async function runCommand(executable, args, options) {
       cwd: options?.cwd,
       env: options?.env ?? process.env
     });
-    return { stdout, stderr };
+    return { stdout, stderr, exitCode: 0 };
   } catch (error) {
     if (options?.check === false && error && typeof error === "object") {
       const execError = error;
       return {
         stdout: execError.stdout ?? "",
-        stderr: execError.stderr ?? ""
+        stderr: execError.stderr ?? "",
+        exitCode: typeof execError.code === "number" ? execError.code : 1
       };
     }
     throw withFriendlyGitHubAuthError(error);
@@ -779,7 +2235,7 @@ async function runCommand(executable, args, options) {
 function getGitEnv() {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
-    if (value !== void 0 && !(key.startsWith("GIT_") && key !== "GIT_SSH_COMMAND")) {
+    if (value !== void 0 && (!key.startsWith("GIT_") || GIT_ENV_INHERIT_ALLOWLIST.has(key))) {
       env[key] = value;
     }
   }
@@ -792,9 +2248,59 @@ async function runGit(args, options) {
 async function runGh(args, options) {
   return runCommand("gh", args, options);
 }
-async function ensureResultsRepoCommitIdentity(repoDir) {
-  await runGit(["config", "user.email", RESULTS_REPO_COMMIT_EMAIL], { cwd: repoDir });
-  await runGit(["config", "user.name", RESULTS_REPO_COMMIT_NAME], { cwd: repoDir });
+function gitErrorText(error) {
+  const parts = [];
+  if (error && typeof error === "object") {
+    const record = error;
+    if (typeof record.stdout === "string") parts.push(record.stdout);
+    if (typeof record.stderr === "string") parts.push(record.stderr);
+    if (typeof record.message === "string") parts.push(record.message);
+  } else if (typeof error === "string") {
+    parts.push(error);
+  }
+  return parts.join("\n").toLowerCase();
+}
+function isMissingGitIdentityError(error) {
+  const text = gitErrorText(error);
+  return text.includes("author identity unknown") || text.includes("committer identity unknown") || text.includes("please tell me who you are") || text.includes("unable to auto-detect email address") || text.includes("empty ident name");
+}
+function fallbackResultsRepoCommitEnv() {
+  return {
+    GIT_AUTHOR_NAME: FALLBACK_RESULTS_REPO_COMMIT_NAME,
+    GIT_AUTHOR_EMAIL: FALLBACK_RESULTS_REPO_COMMIT_EMAIL,
+    GIT_COMMITTER_NAME: FALLBACK_RESULTS_REPO_COMMIT_NAME,
+    GIT_COMMITTER_EMAIL: FALLBACK_RESULTS_REPO_COMMIT_EMAIL
+  };
+}
+function configuredGitCommitIdentityEnv() {
+  const env = {};
+  for (const key of GIT_COMMIT_IDENTITY_ENV_KEYS) {
+    const value = process.env[key];
+    if (value !== void 0) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+async function runGitWithFallbackCommitIdentity(args, options) {
+  const env = {
+    ...configuredGitCommitIdentityEnv(),
+    ...options.env
+  };
+  try {
+    return await runGit(args, { ...options, env });
+  } catch (error) {
+    if (!isMissingGitIdentityError(error)) {
+      throw error;
+    }
+    return runGit(args, {
+      ...options,
+      env: {
+        ...env,
+        ...fallbackResultsRepoCommitEnv()
+      }
+    });
+  }
 }
 async function resolveDefaultBranch(repoDir) {
   try {
@@ -816,16 +2322,39 @@ async function resolveDefaultBranch(repoDir) {
   return "main";
 }
 async function fetchResultsRepo(repoDir, remote = "origin", branch) {
-  await runGit(["fetch", remote, "--prune"], { cwd: repoDir });
   if (branch) {
     await fetchResultsBranchRef(repoDir, remote, branch);
+    await runGit(["remote", "prune", remote], { cwd: repoDir, check: false });
+    return;
   }
+  await runGit(["fetch", remote, "--prune"], { cwd: repoDir });
+}
+function isMissingRemoteBranchFetch(stderr) {
+  const lower = stderr.toLowerCase();
+  return lower.includes("couldn't find remote ref") || lower.includes("could not find remote ref");
 }
 async function fetchResultsBranchRef(repoDir, remote, branch) {
-  await runGit(["fetch", remote, `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`], {
+  const { exitCode, stderr } = await runGit(
+    ["fetch", remote, `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`],
+    {
+      cwd: repoDir,
+      check: false
+    }
+  );
+  const fetchError = stderr.trim();
+  if (exitCode !== 0 && !isMissingRemoteBranchFetch(fetchError)) {
+    throw new Error(fetchError);
+  }
+}
+async function fetchResultsArtifactRef(repoDir, remote, branch) {
+  const refspec = `+refs/heads/${branch}:refs/remotes/${remote}/${branch}`;
+  await runGit(["fetch", "--filter=blob:none", remote, refspec], {
     cwd: repoDir,
     check: false
   });
+  if (!await gitRefExists(repoDir, `refs/remotes/${remote}/${branch}`)) {
+    await fetchResultsBranchRef(repoDir, remote, branch);
+  }
 }
 function remoteBranchRef(branch, remote = "origin") {
   return `${remote}/${branch}`;
@@ -893,16 +2422,12 @@ async function createOrphanResultsBranch(repoDir, branch) {
   });
 }
 async function createResultsGenesisCommit(repoDir) {
-  await ensureResultsRepoCommitIdentity(repoDir);
   const { stdout } = await runGit(
     ["commit-tree", GIT_EMPTY_TREE, "-m", RESULTS_REPO_GENESIS_MESSAGE],
     {
       cwd: repoDir,
       env: {
-        GIT_AUTHOR_NAME: RESULTS_REPO_COMMIT_NAME,
-        GIT_AUTHOR_EMAIL: RESULTS_REPO_COMMIT_EMAIL,
-        GIT_COMMITTER_NAME: RESULTS_REPO_COMMIT_NAME,
-        GIT_COMMITTER_EMAIL: RESULTS_REPO_COMMIT_EMAIL,
+        ...fallbackResultsRepoCommitEnv(),
         GIT_AUTHOR_DATE: RESULTS_REPO_GENESIS_DATE,
         GIT_COMMITTER_DATE: RESULTS_REPO_GENESIS_DATE
       }
@@ -922,6 +2447,24 @@ async function resolveGitTopLevel(repoDir) {
   const { stdout } = await runGit(["rev-parse", "--show-toplevel"], { cwd: repoDir });
   return stdout.trim() || repoDir;
 }
+async function ensureResultsRepoRemote(repoDir, config) {
+  if (!config.repo_url) {
+    return;
+  }
+  const remoteUrl = resolveResultsRepoUrl(config.repo_url);
+  const { stdout } = await runGit(["remote", "get-url", config.remote], {
+    cwd: repoDir,
+    check: false
+  });
+  const existingUrl = stdout.trim();
+  if (!existingUrl) {
+    await runGit(["remote", "add", config.remote, remoteUrl], { cwd: repoDir });
+    return;
+  }
+  if (existingUrl !== remoteUrl) {
+    await runGit(["remote", "set-url", config.remote, remoteUrl], { cwd: repoDir });
+  }
+}
 function updateStatusFile(config, patch) {
   const repo = typeof config.repo === "string" ? config.repo : config.repo_url ?? config.repo_path ?? "";
   const cachePaths = getResultsRepoLocalPaths(repo);
@@ -954,6 +2497,7 @@ async function ensureResultsRepoClone(config) {
         resolveResultsRepoUrl(normalized.repo_url ?? normalized.repo),
         cloneDir
       ]);
+      await ensureResultsRepoRemote(cloneDir, normalized);
       return cloneDir;
     } catch (error) {
       updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
@@ -963,6 +2507,7 @@ async function ensureResultsRepoClone(config) {
   if (!existsSync(gitDir)) {
     throw new Error(`Results repo clone path is not a git repository: ${cloneDir}`);
   }
+  await ensureResultsRepoRemote(cloneDir, normalized);
   return cloneDir;
 }
 function getResultsRepoStatus(config) {
@@ -986,6 +2531,7 @@ function getResultsRepoStatus(config) {
     path: normalized.path,
     auto_push: normalized.auto_push,
     require_push: normalized.require_push,
+    push_conflict_policy: normalized.push_conflict_policy,
     branch_prefix: normalized.branch_prefix,
     local_dir: normalized.path,
     last_synced_at: persisted.last_synced_at,
@@ -1078,6 +2624,50 @@ async function getAheadBehindForRefs(repoDir, leftRef, rightRef) {
     ...Number.isFinite(behind) && { behind }
   };
 }
+async function readGitText(repoDir, ref, gitPath) {
+  if (!ref) {
+    return void 0;
+  }
+  const { stdout } = await runGit(["show", `${ref}:${gitPath}`], {
+    cwd: repoDir,
+    check: false
+  });
+  return stdout.length > 0 ? stdout : void 0;
+}
+async function getStorageBranchWorktreeDirtyPaths(repoDir, config) {
+  const { stdout: porcelain } = await runGit(
+    ["status", "--porcelain=v1", "--untracked-files=all"],
+    {
+      cwd: repoDir,
+      check: false
+    }
+  );
+  const parsed = parseGitPorcelainPaths(porcelain);
+  const safeDirtyPaths = parsed.dirtyPaths.filter(isSafeResultsRepoPath);
+  const conflictedPaths = parsed.conflictedPaths.filter(isSafeResultsRepoPath);
+  if (safeDirtyPaths.length === 0) {
+    return { dirtyPaths: [], conflictedPaths };
+  }
+  const localRef = `refs/heads/${config.branch}`;
+  const remoteRef = remoteBranchRef(config.branch, config.remote);
+  const comparisonRef = await gitRefExists(repoDir, localRef) ? localRef : await gitRefExists(repoDir, remoteRef) ? remoteRef : void 0;
+  const dirtyPaths = [];
+  for (const gitPath of safeDirtyPaths) {
+    const absolutePath = path4.join(repoDir, ...gitPath.split("/"));
+    if (!existsSync(absolutePath)) {
+      if (await readGitText(repoDir, comparisonRef, gitPath) !== void 0) {
+        dirtyPaths.push(gitPath);
+      }
+      continue;
+    }
+    const localContent = readFileSync2(absolutePath, "utf8");
+    const branchContent = await readGitText(repoDir, comparisonRef, gitPath);
+    if (branchContent === void 0 || localContent !== branchContent) {
+      dirtyPaths.push(gitPath);
+    }
+  }
+  return { dirtyPaths: dirtyPaths.sort(), conflictedPaths };
+}
 async function inspectResultsStorageBranchGit(repoDir, config) {
   if (!config.branch) {
     return {
@@ -1090,12 +2680,20 @@ async function inspectResultsStorageBranchGit(repoDir, config) {
   const upstream = remoteBranchRef(config.branch, config.remote);
   const localExists = await gitRefExists(repoDir, localRef);
   const remoteExists = await gitRefExists(repoDir, upstream);
+  const worktree = await getStorageBranchWorktreeDirtyPaths(repoDir, {
+    ...config,
+    branch: config.branch
+  });
   const { ahead = 0, behind = 0 } = localExists && remoteExists ? await getAheadBehindForRefs(repoDir, localRef, upstream) : {
     ahead: localExists && !remoteExists ? 1 : 0,
     behind: !localExists && remoteExists ? 1 : 0
   };
   let syncStatus = "clean";
-  if (ahead > 0 && behind > 0) {
+  if (worktree.conflictedPaths.length > 0) {
+    syncStatus = "conflicted";
+  } else if (worktree.dirtyPaths.length > 0) {
+    syncStatus = "dirty";
+  } else if (ahead > 0 && behind > 0) {
     syncStatus = "diverged";
   } else if (behind > 0) {
     syncStatus = "behind";
@@ -1108,10 +2706,51 @@ async function inspectResultsStorageBranchGit(repoDir, config) {
     ...remoteExists && { upstream },
     ahead,
     behind,
-    dirtyPaths: [],
-    conflictedPaths: []
+    dirtyPaths: worktree.dirtyPaths,
+    conflictedPaths: worktree.conflictedPaths
   };
 }
+async function fastForwardStorageBranchRef(repoDir, normalized, upstream) {
+  await assertValidResultsBranchName(repoDir, normalized.branch);
+  await ensureResultsBranchNotCheckedOut(repoDir, normalized);
+  const localRef = `refs/heads/${normalized.branch}`;
+  const localExists = await gitRefExists(repoDir, localRef);
+  const updateArgs = ["update-ref", localRef, upstream];
+  if (localExists) {
+    const { stdout: localSha } = await runGit(["rev-parse", localRef], { cwd: repoDir });
+    updateArgs.push(localSha.trim());
+  }
+  await runGit(updateArgs, { cwd: repoDir });
+  await runGit(["branch", "--set-upstream-to", upstream, normalized.branch], {
+    cwd: repoDir,
+    check: false
+  });
+}
+async function getDirtyPathsChangedUpstream(repoDir, normalized, dirtyPaths, upstream) {
+  const safeDirtyPaths = [...new Set(dirtyPaths.filter(isSafeResultsRepoPath))].sort();
+  if (safeDirtyPaths.length === 0) {
+    return [];
+  }
+  const localRef = `refs/heads/${normalized.branch}`;
+  const localExists = await gitRefExists(repoDir, localRef);
+  let changedPaths;
+  if (localExists) {
+    const { stdout } = await runGit(["diff", "--name-only", `${localRef}..${upstream}`], {
+      cwd: repoDir,
+      check: false
+    });
+    changedPaths = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).filter(isSafeResultsRepoPath).sort();
+  } else {
+    changedPaths = [];
+    for (const dirtyPath of safeDirtyPaths) {
+      if (await readGitText(repoDir, upstream, dirtyPath) !== void 0) {
+        changedPaths.push(dirtyPath);
+      }
+    }
+  }
+  const dirtySet = new Set(safeDirtyPaths);
+  return [...new Set(changedPaths.filter((changedPath) => dirtySet.has(changedPath)))].sort();
+}
 async function hasInProgressGitConflict(repoDir) {
   const markers = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD"];
   for (const marker of markers) {
@@ -1213,9 +2852,37 @@ function lastErrorForGitInspection(status, inspection) {
   }
   return void 0;
 }
+var ResultsBranchPushConflictError = class extends Error {
+  constructor(result) {
+    super(result.block_reason ?? "Results branch push conflict");
+    this.result = result;
+    this.name = "ResultsBranchPushConflictError";
+  }
+};
+function pushDetailsToWire(details) {
+  if (!details) {
+    return {};
+  }
+  return {
+    push_conflict_policy: details.pushConflictPolicy,
+    target_branch: details.targetBranch,
+    ...details.remoteCommit !== void 0 && { remote_commit: details.remoteCommit },
+    ...details.localCommit !== void 0 && { local_commit: details.localCommit },
+    ...details.backupRef !== void 0 && { backup_ref: details.backupRef },
+    ...details.backupCommit !== void 0 && { backup_commit: details.backupCommit },
+    ...details.previousRemoteCommit !== void 0 && {
+      previous_remote_commit: details.previousRemoteCommit
+    },
+    ...details.forcePushedCommit !== void 0 && {
+      force_pushed_commit: details.forcePushedCommit
+    },
+    ...details.leaseCommit !== void 0 && { lease_commit: details.leaseCommit }
+  };
+}
 function withBlockedStatus(status, blockReason, flags) {
   return {
     ...status,
+    ...pushDetailsToWire(flags?.pushDetails),
     blocked: true,
     block_reason: blockReason,
     ...flags?.pullPerformed !== void 0 && { pull_performed: flags.pullPerformed },
@@ -1223,9 +2890,23 @@ function withBlockedStatus(status, blockReason, flags) {
     ...flags?.commitCreated !== void 0 && { commit_created: flags.commitCreated }
   };
 }
+function withPushConflictStatus(status, blockReason, details, flags) {
+  return withBlockedStatus(
+    {
+      ...status,
+      sync_status: "push_conflict"
+    },
+    blockReason,
+    {
+      ...flags,
+      pushDetails: details
+    }
+  );
+}
 function withActionFlags(status, flags) {
   return {
     ...status,
+    ...pushDetailsToWire(flags.pushDetails),
     blocked: false,
     pull_performed: flags.pullPerformed,
     push_performed: flags.pushPerformed,
@@ -1266,6 +2947,121 @@ function getPushTargetBranch(upstream, baseBranch, remote = "origin") {
   const prefix = `${remote}/`;
   return upstream?.startsWith(prefix) ? upstream.slice(prefix.length) : baseBranch;
 }
+function timestampForBackupRef(date = /* @__PURE__ */ new Date()) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T${pad(
+    date.getUTCHours()
+  )}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
+}
+function slugifyBackupTargetBranch(branch) {
+  return branch.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "results";
+}
+function buildResultsBackupRef(targetBranch, remoteCommit) {
+  return `agentv/backups/${timestampForBackupRef()}-${slugifyBackupTargetBranch(
+    targetBranch
+  )}-${remoteCommit.slice(0, 7)}`;
+}
+async function getCommitSha(repoDir, ref) {
+  if (!ref) {
+    return void 0;
+  }
+  const { stdout } = await runGit(["rev-parse", "--verify", `${ref}^{commit}`], {
+    cwd: repoDir,
+    check: false
+  });
+  const sha = stdout.trim();
+  return sha.length > 0 ? sha : void 0;
+}
+function isNonFastForwardPushError(error) {
+  const text = gitErrorText(error);
+  return text.includes("non-fast-forward") || text.includes("fetch first") || text.includes("tip is behind its remote") || text.includes("note about fast-forwards") || text.includes("stale info");
+}
+function formatShortSha(sha) {
+  return sha ? sha.slice(0, 12) : "unknown";
+}
+function buildBlockedPushConflictReason(details) {
+  return `Results branch push conflict on ${details.targetBranch}: remote ${formatShortSha(
+    details.remoteCommit
+  )}, local ${formatShortSha(details.localCommit)}. Configure results.sync.push_conflict_policy: backup_and_force_push to back up the remote ref before replacing it.`;
+}
+async function resolveResultBranchPushConflict(params) {
+  await fetchResultsRepo(params.repoDir, params.normalized.remote, params.targetBranch);
+  const remoteRef = remoteBranchRef(params.targetBranch, params.normalized.remote);
+  const remoteCommit = await getCommitSha(params.repoDir, remoteRef);
+  const localCommit = await getCommitSha(params.repoDir, params.sourceRef);
+  const baseDetails = {
+    pushConflictPolicy: params.normalized.push_conflict_policy,
+    targetBranch: params.targetBranch,
+    ...remoteCommit !== void 0 && {
+      remoteCommit,
+      previousRemoteCommit: remoteCommit,
+      leaseCommit: remoteCommit
+    },
+    ...localCommit !== void 0 && { localCommit }
+  };
+  if (!remoteCommit) {
+    return {
+      blocked: true,
+      blockReason: `Results branch push conflict on ${params.targetBranch}: remote commit could not be resolved after fetch`,
+      details: baseDetails
+    };
+  }
+  if (params.normalized.push_conflict_policy === "block") {
+    return {
+      blocked: true,
+      blockReason: buildBlockedPushConflictReason(baseDetails),
+      details: baseDetails
+    };
+  }
+  const backupRef = buildResultsBackupRef(params.targetBranch, remoteCommit);
+  const backupDetails = {
+    ...baseDetails,
+    backupRef,
+    backupCommit: remoteCommit
+  };
+  try {
+    await assertValidResultsBranchName(params.repoDir, backupRef);
+    await runGit(
+      ["push", "--porcelain", params.normalized.remote, `${remoteCommit}:refs/heads/${backupRef}`],
+      { cwd: params.repoDir }
+    );
+  } catch (error) {
+    return {
+      blocked: true,
+      blockReason: `Results branch backup creation failed for ${params.targetBranch} at ${formatShortSha(
+        remoteCommit
+      )}: ${getStatusMessage(error)}`,
+      details: backupDetails
+    };
+  }
+  try {
+    await runGit(
+      [
+        "push",
+        "--porcelain",
+        `--force-with-lease=refs/heads/${params.targetBranch}:${remoteCommit}`,
+        params.normalized.remote,
+        `${params.sourceRef}:refs/heads/${params.targetBranch}`
+      ],
+      { cwd: params.repoDir }
+    );
+  } catch (error) {
+    return {
+      blocked: true,
+      blockReason: `Results branch force push lease failed for ${params.targetBranch}; remote changed after backup ${backupRef} was created with lease ${formatShortSha(
+        remoteCommit
+      )}: ${getStatusMessage(error)}`,
+      details: backupDetails
+    };
+  }
+  return {
+    blocked: false,
+    details: {
+      ...backupDetails,
+      ...localCommit !== void 0 && { forcePushedCommit: localCommit }
+    }
+  };
+}
 async function statusFromInspection(normalized, repoDir) {
   return withGitInspection(
     getResultsRepoStatus(normalized),
@@ -1291,7 +3087,8 @@ async function getResultsRepoSyncStatus(config) {
     };
   }
   try {
-    if (normalized.repo_path) {
+    await ensureResultsRepoRemote(normalized.path, normalized);
+    if (usesStorageBranchWorktree(normalized)) {
       await fetchResultsRepo(normalized.path, normalized.remote, normalized.branch).catch(
         () => void 0
       );
@@ -1321,7 +3118,7 @@ async function syncResultsRepo(config) {
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
     await fetchResultsRepo(repoDir, normalized.remote, normalized.branch);
-    if (!normalized.repo_path) {
+    if (!usesStorageBranchWorktree(normalized)) {
       await checkoutConfiguredResultsBranch(repoDir, normalized);
     }
     updateStatusFile(normalized, {
@@ -1354,9 +3151,10 @@ async function syncResultsRepoForProject(config) {
   let pullPerformed = false;
   let pushPerformed = false;
   let commitCreated = false;
+  let pushDetails;
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
-    if (normalized.repo_path) {
+    if (usesStorageBranchWorktree(normalized)) {
       try {
         await fetchResultsRepo(repoDir, normalized.remote, normalized.branch);
       } catch (error) {
@@ -1364,6 +3162,171 @@ async function syncResultsRepoForProject(config) {
           throw error;
         }
       }
+      let inspection2 = await inspectResultsStorageBranchGit(repoDir, normalized);
+      const fastForwardBehindStorageBranch = async () => {
+        if ((inspection2.behind ?? 0) <= 0 || (inspection2.ahead ?? 0) > 0) {
+          return void 0;
+        }
+        if (!inspection2.upstream) {
+          const status2 = withGitInspection(getResultsRepoStatus(normalized), inspection2);
+          updateStatusFile(normalized, {
+            last_error: "Results repo has no upstream branch to pull from"
+          });
+          return withBlockedStatus(status2, "Results repo has no upstream branch to pull from", {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
+        if (!normalized.branch) {
+          return void 0;
+        }
+        try {
+          await fastForwardStorageBranchRef(
+            repoDir,
+            { ...normalized, branch: normalized.branch },
+            inspection2.upstream
+          );
+          pullPerformed = true;
+          inspection2 = await inspectResultsStorageBranchGit(repoDir, normalized);
+          return void 0;
+        } catch (error) {
+          inspection2 = await inspectResultsStorageBranchGit(repoDir, normalized);
+          const status2 = withGitInspection(getResultsRepoStatus(normalized), inspection2);
+          const reason = `Results repo could not be fast-forwarded: ${getStatusMessage(error)}`;
+          updateStatusFile(normalized, { last_error: reason });
+          return withBlockedStatus(status2, reason, {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
+      };
+      if (inspection2.syncStatus === "conflicted") {
+        const status2 = withGitInspection(getResultsRepoStatus(normalized), inspection2);
+        updateStatusFile(normalized, {
+          last_error: "Results repo has unresolved git conflicts"
+        });
+        return withBlockedStatus(status2, "Results repo has unresolved git conflicts", {
+          pullPerformed,
+          pushPerformed,
+          commitCreated
+        });
+      }
+      if ((inspection2.ahead ?? 0) > 0 && (inspection2.behind ?? 0) > 0) {
+        const status2 = withGitInspection(getResultsRepoStatus(normalized), inspection2);
+        if (!normalized.branch) {
+          updateStatusFile(normalized, {
+            last_error: "Results repo local and remote histories have diverged"
+          });
+          return withBlockedStatus(
+            status2,
+            "Results repo local and remote histories have diverged",
+            {
+              pullPerformed,
+              pushPerformed,
+              commitCreated
+            }
+          );
+        }
+        const localRef = `refs/heads/${normalized.branch}`;
+        const aheadPaths = await getAheadPaths(repoDir, inspection2.upstream, localRef);
+        if (!inspection2.upstream || !areSafeResultsRepoPaths(aheadPaths)) {
+          const reason = !inspection2.upstream ? "Results repo has no upstream branch to push to" : "Results repo has non-results committed changes";
+          updateStatusFile(normalized, { last_error: reason });
+          return withBlockedStatus(status2, reason, {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
+        const outcome = await resolveResultBranchPushConflict({
+          normalized: { ...normalized, branch: normalized.branch },
+          repoDir,
+          targetBranch: normalized.branch,
+          sourceRef: localRef
+        });
+        pushDetails = outcome.details;
+        if (outcome.blocked) {
+          updateStatusFile(normalized, { last_error: outcome.blockReason });
+          return withPushConflictStatus(status2, outcome.blockReason, outcome.details, {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
+        pushPerformed = true;
+        await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(
+          () => void 0
+        );
+        inspection2 = await inspectResultsStorageBranchGit(repoDir, normalized);
+      }
+      if (inspection2.syncStatus === "dirty") {
+        if (!normalized.auto_push && !normalized.require_push) {
+          const status2 = withGitInspection(getResultsRepoStatus(normalized), inspection2);
+          updateStatusFile(normalized, {
+            last_error: "Results repo has uncommitted changes and auto_push is disabled"
+          });
+          return withBlockedStatus(
+            status2,
+            "Results repo has uncommitted changes and auto_push is disabled",
+            {
+              pullPerformed,
+              pushPerformed,
+              commitCreated
+            }
+          );
+        }
+        if ((inspection2.behind ?? 0) > 0) {
+          if (inspection2.upstream && normalized.branch) {
+            const changedDirtyPaths = await getDirtyPathsChangedUpstream(
+              repoDir,
+              { ...normalized, branch: normalized.branch },
+              inspection2.dirtyPaths,
+              inspection2.upstream
+            );
+            if (changedDirtyPaths.length > 0) {
+              const conflictInspection = {
+                ...inspection2,
+                syncStatus: "conflicted",
+                conflictedPaths: [
+                  .../* @__PURE__ */ new Set([...inspection2.conflictedPaths, ...changedDirtyPaths])
+                ].sort()
+              };
+              const status2 = withGitInspection(
+                getResultsRepoStatus(normalized),
+                conflictInspection
+              );
+              const reason = `Results repo local metadata changes conflict with upstream changes: ${changedDirtyPaths.join(", ")}`;
+              updateStatusFile(normalized, { last_error: reason });
+              return withBlockedStatus(status2, reason, {
+                pullPerformed,
+                pushPerformed,
+                commitCreated
+              });
+            }
+          }
+          const blockedStatus = await fastForwardBehindStorageBranch();
+          if (blockedStatus) {
+            return blockedStatus;
+          }
+        }
+        if (normalized.branch) {
+          commitCreated = await commitStorageBranchWorktreePaths({
+            normalized: { ...normalized, branch: normalized.branch },
+            repoDir,
+            paths: inspection2.dirtyPaths,
+            commitMessage: "chore(results): sync local result metadata"
+          });
+          inspection2 = await inspectResultsStorageBranchGit(repoDir, normalized);
+        }
+      }
+      if ((inspection2.behind ?? 0) > 0 && (inspection2.ahead ?? 0) === 0) {
+        const blockedStatus = await fastForwardBehindStorageBranch();
+        if (blockedStatus) {
+          return blockedStatus;
+        }
+      }
       if (normalized.auto_push || normalized.require_push) {
         if (normalized.branch) {
           const localRef = `refs/heads/${normalized.branch}`;
@@ -1379,21 +3342,55 @@ async function syncResultsRepoForProject(config) {
                 { cwd: repoDir }
               );
               pushPerformed = true;
+              await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(
+                () => void 0
+              );
             } catch (error) {
-              updateStatusFile(normalized, { last_error: getStatusMessage(error) });
-              if (normalized.require_push) {
-                throw error;
-              }
-              const status = await getResultsRepoSyncStatus(normalized);
-              return withBlockedStatus(
-                status,
-                `Results repo push was rejected: ${getStatusMessage(error)}`,
-                {
-                  pullPerformed,
-                  pushPerformed,
-                  commitCreated
+              if (isNonFastForwardPushError(error)) {
+                const outcome = await resolveResultBranchPushConflict({
+                  normalized: { ...normalized, branch: normalized.branch },
+                  repoDir,
+                  targetBranch: normalized.branch,
+                  sourceRef: localRef
+                });
+                pushDetails = outcome.details;
+                if (!outcome.blocked) {
+                  pushPerformed = true;
+                  await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(
+                    () => void 0
+                  );
+                  inspection2 = await inspectResultsStorageBranchGit(repoDir, normalized);
+                } else {
+                  updateStatusFile(normalized, { last_error: outcome.blockReason });
+                  const status2 = withGitInspection(
+                    getResultsRepoStatus(normalized),
+                    await inspectResultsStorageBranchGit(repoDir, normalized)
+                  );
+                  return withPushConflictStatus(status2, outcome.blockReason, outcome.details, {
+                    pullPerformed,
+                    pushPerformed,
+                    commitCreated
+                  });
                 }
-              );
+              } else {
+                updateStatusFile(normalized, { last_error: getStatusMessage(error) });
+                if (normalized.require_push) {
+                  throw error;
+                }
+                const status2 = withGitInspection(
+                  getResultsRepoStatus(normalized),
+                  await inspectResultsStorageBranchGit(repoDir, normalized)
+                );
+                return withBlockedStatus(
+                  status2,
+                  `Results repo push was rejected: ${getStatusMessage(error)}`,
+                  {
+                    pullPerformed,
+                    pushPerformed,
+                    commitCreated
+                  }
+                );
+              }
             }
           }
         }
@@ -1402,11 +3399,11 @@ async function syncResultsRepoForProject(config) {
         last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
         last_error: void 0
       });
-      return withActionFlags(await getResultsRepoSyncStatus(normalized), {
-        pullPerformed,
-        pushPerformed,
-        commitCreated
-      });
+      const status = withGitInspection(
+        getResultsRepoStatus(normalized),
+        await inspectResultsStorageBranchGit(repoDir, normalized)
+      );
+      return withActionFlags(status, { pullPerformed, pushPerformed, commitCreated, pushDetails });
     }
     await fetchResultsRepo(repoDir, normalized.remote, normalized.branch);
     await checkoutConfiguredResultsBranch(repoDir, normalized);
@@ -1469,8 +3466,7 @@ async function syncResultsRepoForProject(config) {
       if (inspection.syncStatus === "dirty") {
         const trackedDirs = await existingTrackedResultsDirs(repoDir);
         await runGit(["add", "--all", "--", ...trackedDirs], { cwd: repoDir });
-        await ensureResultsRepoCommitIdentity(repoDir);
-        await runGit(
+        await runGitWithFallbackCommitIdentity(
           ["commit", "-m", "chore(results): sync local result metadata", "--", ...trackedDirs],
           {
             cwd: repoDir
@@ -1482,14 +3478,36 @@ async function syncResultsRepoForProject(config) {
     }
     if (inspection.syncStatus === "diverged") {
       const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
-      updateStatusFile(normalized, {
-        last_error: "Results repo local and remote histories have diverged"
-      });
-      return withBlockedStatus(status, "Results repo local and remote histories have diverged", {
-        pullPerformed,
-        pushPerformed,
-        commitCreated
+      const aheadPaths = await getAheadPaths(repoDir, inspection.upstream);
+      if (!inspection.upstream || !areSafeResultsRepoPaths(aheadPaths)) {
+        const reason = !inspection.upstream ? "Results repo has no upstream branch to push to" : "Results repo has non-results committed changes";
+        updateStatusFile(normalized, { last_error: reason });
+        return withBlockedStatus(status, reason, {
+          pullPerformed,
+          pushPerformed,
+          commitCreated
+        });
+      }
+      const baseBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
+      const targetBranch = getPushTargetBranch(inspection.upstream, baseBranch, normalized.remote);
+      const outcome = await resolveResultBranchPushConflict({
+        normalized: { ...normalized, branch: targetBranch },
+        repoDir,
+        targetBranch,
+        sourceRef: "HEAD"
       });
+      pushDetails = outcome.details;
+      if (outcome.blocked) {
+        updateStatusFile(normalized, { last_error: outcome.blockReason });
+        return withPushConflictStatus(status, outcome.blockReason, outcome.details, {
+          pullPerformed,
+          pushPerformed,
+          commitCreated
+        });
+      }
+      pushPerformed = true;
+      await fetchResultsRepo(repoDir, normalized.remote, normalized.branch);
+      inspection = await inspectResultsRepoGit(repoDir, normalized);
     }
     if ((inspection.behind ?? 0) > 0 && (inspection.ahead ?? 0) === 0) {
       if (!inspection.upstream) {
@@ -1547,18 +3565,45 @@ async function syncResultsRepoForProject(config) {
         await fetchResultsRepo(repoDir, normalized.remote, normalized.branch);
         inspection = await inspectResultsRepoGit(repoDir, normalized);
       } catch (error) {
-        await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(
-          () => void 0
-        );
-        inspection = await inspectResultsRepoGit(repoDir, normalized);
-        const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
-        const reason = `Results repo push was rejected: ${getStatusMessage(error)}`;
-        updateStatusFile(normalized, { last_error: reason });
-        return withBlockedStatus(status, reason, {
-          pullPerformed,
-          pushPerformed,
-          commitCreated
-        });
+        if (isNonFastForwardPushError(error)) {
+          const outcome = await resolveResultBranchPushConflict({
+            normalized: { ...normalized, branch: targetBranch },
+            repoDir,
+            targetBranch,
+            sourceRef: "HEAD"
+          });
+          pushDetails = outcome.details;
+          if (!outcome.blocked) {
+            pushPerformed = true;
+            await fetchResultsRepo(repoDir, normalized.remote, normalized.branch);
+            inspection = await inspectResultsRepoGit(repoDir, normalized);
+          } else {
+            await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(
+              () => void 0
+            );
+            inspection = await inspectResultsRepoGit(repoDir, normalized);
+            const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+            updateStatusFile(normalized, { last_error: outcome.blockReason });
+            return withPushConflictStatus(status, outcome.blockReason, outcome.details, {
+              pullPerformed,
+              pushPerformed,
+              commitCreated
+            });
+          }
+        } else {
+          await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(
+            () => void 0
+          );
+          inspection = await inspectResultsRepoGit(repoDir, normalized);
+          const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+          const reason = `Results repo push was rejected: ${getStatusMessage(error)}`;
+          updateStatusFile(normalized, { last_error: reason });
+          return withBlockedStatus(status, reason, {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
       }
     }
     updateStatusFile(normalized, {
@@ -1568,7 +3613,8 @@ async function syncResultsRepoForProject(config) {
     return withActionFlags(await statusFromInspection(normalized, repoDir), {
       pullPerformed,
       pushPerformed,
-      commitCreated
+      commitCreated,
+      pushDetails
     });
   } catch (error) {
     updateStatusFile(normalized, {
@@ -1627,7 +3673,7 @@ async function stageResultsArtifacts(params) {
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return path4.join(normalized.path, RESULTS_REPO_RESULTS_DIR, "runs");
+  return path4.join(normalized.path, RESULTS_REPO_RESULTS_DIR);
 }
 async function directorySizeBytes(targetPath) {
   const entry = await stat(targetPath);
@@ -1649,8 +3695,9 @@ async function commitAndPushResultsBranch(params) {
   if (diffStdout.trim().length === 0) {
     return false;
   }
-  await ensureResultsRepoCommitIdentity(params.repoDir);
-  await runGit(["commit", "-m", params.commitMessage], { cwd: params.repoDir });
+  await runGitWithFallbackCommitIdentity(["commit", "-m", params.commitMessage], {
+    cwd: params.repoDir
+  });
   await runGit(["push", "-u", "origin", params.branchName], { cwd: params.repoDir });
   return true;
 }
@@ -1685,7 +3732,6 @@ async function createDraftResultsPr(params) {
   );
   return stdout.trim();
 }
-var DIRECT_PUSH_MAX_RETRIES = 3;
 async function hasUnpushedCommits(repoDir, upstreamRef, branch) {
   const { stdout } = await runGit(["rev-list", "--count", `${upstreamRef}..refs/heads/${branch}`], {
     cwd: repoDir,
@@ -1693,14 +3739,6 @@ async function hasUnpushedCommits(repoDir, upstreamRef, branch) {
   });
   return Number.parseInt(stdout.trim(), 10) > 0;
 }
-async function countUnpushedCommits(repoDir, upstreamRef, branch) {
-  const { stdout } = await runGit(["rev-list", "--count", `${upstreamRef}..refs/heads/${branch}`], {
-    cwd: repoDir,
-    check: false
-  });
-  const count = Number.parseInt(stdout.trim(), 10);
-  return Number.isFinite(count) ? count : 0;
-}
 async function assertValidResultsBranchName(repoDir, branch) {
   if (branch.length === 0 || branch.includes("..") || branch.startsWith("/") || branch.endsWith("/") || branch.endsWith(".lock") || [...branch].some((char) => {
     const code = char.charCodeAt(0);
@@ -1713,7 +3751,10 @@ async function assertValidResultsBranchName(repoDir, branch) {
 function normalizeDestinationPath(destinationPath) {
   const normalized = destinationPath.split(path4.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
-  if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+  if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..") || normalized.split("").some((char) => {
+    const code = char.charCodeAt(0);
+    return code <= 31 || code === 127;
+  })) {
     throw new Error(`Invalid results destination path: ${destinationPath}`);
   }
   return segments.join("/");
@@ -1734,6 +3775,175 @@ async function listSourceFiles(sourceDir) {
   entries.sort();
   return entries;
 }
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function artifactSidecarPointers(record) {
+  if (!isRecord2(record) || !isRecord2(record.artifact_pointers)) {
+    return [];
+  }
+  const pointers = [];
+  for (const pointer of Object.values(record.artifact_pointers)) {
+    if (!isRecord2(pointer)) {
+      continue;
+    }
+    if (pointer.ref !== AGENTV_RESULTS_ARTIFACTS_REF || typeof pointer.path !== "string") {
+      continue;
+    }
+    pointers.push({
+      path: pointer.path,
+      ...typeof pointer.sha256 === "string" ? { sha256: pointer.sha256 } : {},
+      ...typeof pointer.object_version === "string" ? { objectVersion: pointer.object_version } : {}
+    });
+  }
+  return pointers;
+}
+function artifactSidecarKey(destinationPath, pointerPath) {
+  return path4.posix.join(
+    RESULTS_REPO_RUNS_DIR,
+    normalizeDestinationPath(destinationPath),
+    normalizeDestinationPath(pointerPath)
+  );
+}
+function collectArtifactSidecarPointers(sourceDir) {
+  const indexPath = path4.join(sourceDir, RESULT_INDEX_FILENAME2);
+  if (!existsSync(indexPath)) {
+    return [];
+  }
+  const pointers = [];
+  for (const line of readFileSync2(indexPath, "utf8").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      pointers.push(...artifactSidecarPointers(JSON.parse(trimmed)));
+    } catch {
+    }
+  }
+  return pointers;
+}
+function resolveArtifactPointerSourcePath(sourceDir, pointerPath) {
+  const normalizedPointerPath = normalizeDestinationPath(pointerPath);
+  const sourceRoot = path4.resolve(sourceDir);
+  const sourcePath = path4.resolve(sourceRoot, ...normalizedPointerPath.split("/"));
+  const relative = path4.relative(sourceRoot, sourcePath);
+  if (relative.startsWith("..") || path4.isAbsolute(relative)) {
+    throw new Error(`Artifact pointer path escapes run directory: ${pointerPath}`);
+  }
+  return sourcePath;
+}
+function verifyArtifactPointerChecksum(pointer, content) {
+  const sha256 = createHash("sha256").update(content).digest("hex");
+  if (pointer.sha256 && pointer.sha256 !== sha256) {
+    throw new Error(`Artifact pointer checksum mismatch for ${pointer.path}`);
+  }
+  if (pointer.objectVersion && pointer.objectVersion !== `sha256:${sha256}`) {
+    throw new Error(`Artifact pointer object_version mismatch for ${pointer.path}`);
+  }
+}
+async function prepareArtifactSidecar(params) {
+  if (params.pointers.length === 0) {
+    return void 0;
+  }
+  const sidecarRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-artifact-sidecar-"));
+  const copied = /* @__PURE__ */ new Set();
+  const contentByPath = /* @__PURE__ */ new Map();
+  try {
+    for (const pointer of params.pointers) {
+      const relativePointerPath = normalizeDestinationPath(pointer.path);
+      let content = contentByPath.get(relativePointerPath);
+      if (!content) {
+        const sourcePath = resolveArtifactPointerSourcePath(params.sourceDir, relativePointerPath);
+        content = readFileSync2(sourcePath);
+        contentByPath.set(relativePointerPath, content);
+      }
+      verifyArtifactPointerChecksum(pointer, content);
+      if (copied.has(relativePointerPath)) {
+        continue;
+      }
+      const destinationPath = path4.join(sidecarRoot, ...relativePointerPath.split("/"));
+      mkdirSync(path4.dirname(destinationPath), { recursive: true });
+      writeFileSync(destinationPath, content);
+      copied.add(relativePointerPath);
+    }
+  } catch (error) {
+    await rm(sidecarRoot, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  if (copied.size === 0) {
+    await rm(sidecarRoot, { recursive: true, force: true }).catch(() => void 0);
+    return void 0;
+  }
+  return {
+    sourceDir: sidecarRoot,
+    cleanup: () => rm(sidecarRoot, { recursive: true, force: true })
+  };
+}
+function rewritePublishedIndexLine(line, destinationPath) {
+  if (!line.trim()) {
+    return line;
+  }
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return line;
+  }
+  if (!isRecord2(record) || !isRecord2(record.artifact_pointers)) {
+    return line;
+  }
+  let changed = false;
+  for (const pointer of Object.values(record.artifact_pointers)) {
+    if (!isRecord2(pointer)) {
+      continue;
+    }
+    if (pointer.ref !== AGENTV_RESULTS_ARTIFACTS_REF || typeof pointer.path !== "string") {
+      continue;
+    }
+    const key = artifactSidecarKey(destinationPath, pointer.path);
+    if (pointer.key !== key) {
+      pointer.key = key;
+      changed = true;
+    }
+  }
+  return changed ? JSON.stringify(record) : line;
+}
+async function preparePublishedResultsSource(params) {
+  if (params.pointers.length === 0) {
+    return void 0;
+  }
+  const publishedRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-published-"));
+  const omittedPaths = new Set(
+    params.pointers.map((pointer) => normalizeDestinationPath(pointer.path))
+  );
+  try {
+    const sourceFiles = await listSourceFiles(params.sourceDir);
+    for (const sourceFile of sourceFiles) {
+      const relativeFile = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
+      const destinationFile = path4.join(publishedRoot, ...relativeFile.split("/"));
+      if (relativeFile === RESULT_INDEX_FILENAME2) {
+        const original = readFileSync2(sourceFile, "utf8");
+        const rewritten = original.split(/\r?\n/).map((line) => rewritePublishedIndexLine(line, params.destinationPath)).join("\n");
+        mkdirSync(path4.dirname(destinationFile), { recursive: true });
+        writeFileSync(destinationFile, rewritten);
+        continue;
+      }
+      if (omittedPaths.has(relativeFile)) {
+        continue;
+      }
+      mkdirSync(path4.dirname(destinationFile), { recursive: true });
+      await cp(sourceFile, destinationFile, { dereference: false });
+    }
+  } catch (error) {
+    await rm(publishedRoot, { recursive: true, force: true }).catch(() => void 0);
+    throw error;
+  }
+  return {
+    sourceDir: publishedRoot,
+    cleanup: () => rm(publishedRoot, { recursive: true, force: true })
+  };
+}
 async function getExistingRunTreePaths(repoDir, ref, destinationTreePath) {
   if (!ref) {
     return [];
@@ -1763,13 +3973,103 @@ async function ensureResultsBranchNotCheckedOut(repoDir, normalized) {
   if (currentBranch !== normalized.branch) {
     return;
   }
-  if (normalized.repo_path) {
+  if (usesStorageBranchWorktree(normalized)) {
     throw new Error(
       `Refusing to publish results while '${normalized.branch}' is checked out in ${repoDir}`
     );
   }
   await runGit(["checkout", "--detach"], { cwd: repoDir });
 }
+async function commitStorageBranchWorktreePaths(params) {
+  const { normalized } = params;
+  const paths = [...new Set(params.paths.filter(isSafeResultsRepoPath))].sort();
+  if (paths.length === 0) {
+    return false;
+  }
+  await assertValidResultsBranchName(params.repoDir, normalized.branch);
+  await ensureResultsBranchNotCheckedOut(params.repoDir, normalized);
+  let base = await resolveStorageBranchBase({
+    repoDir: params.repoDir,
+    normalized
+  });
+  if (!base.baseRef) {
+    await createOrphanResultsBranch(params.repoDir, normalized.branch);
+    base = await resolveStorageBranchBase({
+      repoDir: params.repoDir,
+      normalized
+    });
+  }
+  const indexRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path4.join(indexRoot, "index");
+  const indexEnv = { GIT_INDEX_FILE: indexFile };
+  try {
+    if (base.baseRef) {
+      await runGit(["read-tree", base.baseRef], { cwd: params.repoDir, env: indexEnv });
+    } else {
+      await runGit(["read-tree", "--empty"], { cwd: params.repoDir, env: indexEnv });
+    }
+    for (const gitPath of paths) {
+      const sourcePath = path4.join(params.repoDir, ...gitPath.split("/"));
+      if (!existsSync(sourcePath)) {
+        await runGit(["update-index", "--force-remove", "--", gitPath], {
+          cwd: params.repoDir,
+          env: indexEnv,
+          check: false
+        });
+        continue;
+      }
+      const fileStat = await lstat(sourcePath);
+      let mode = fileStat.mode & 73 ? "100755" : "100644";
+      if (fileStat.isSymbolicLink()) {
+        mode = "120000";
+      }
+      const { stdout: blob } = await runGit(["hash-object", "-w", "--no-filters", sourcePath], {
+        cwd: params.repoDir
+      });
+      await runGit(["update-index", "--add", "--cacheinfo", `${mode},${blob.trim()},${gitPath}`], {
+        cwd: params.repoDir,
+        env: indexEnv
+      });
+    }
+    const { stdout: newTreeStdout } = await runGit(["write-tree"], {
+      cwd: params.repoDir,
+      env: indexEnv
+    });
+    const newTree = newTreeStdout.trim();
+    if (base.baseTree && newTree === base.baseTree) {
+      return false;
+    }
+    const commitArgs = [
+      "commit-tree",
+      newTree,
+      ...base.baseCommit ? ["-p", base.baseCommit] : [],
+      "-m",
+      params.commitMessage
+    ];
+    const { stdout: commitStdout } = await runGitWithFallbackCommitIdentity(commitArgs, {
+      cwd: params.repoDir
+    });
+    const commitSha = commitStdout.trim();
+    await runGit(
+      [
+        "update-ref",
+        `refs/heads/${normalized.branch}`,
+        commitSha,
+        ...base.localExists ? [base.baseCommit ?? ""] : []
+      ].filter(Boolean),
+      { cwd: params.repoDir }
+    );
+    if (base.remoteExists) {
+      await runGit(["branch", "--set-upstream-to", base.remoteRef, normalized.branch], {
+        cwd: params.repoDir,
+        check: false
+      });
+    }
+    return true;
+  } finally {
+    await rm(indexRoot, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
 async function commitResultsRunWithTemporaryIndex(params) {
   const { normalized } = params;
   await assertValidResultsBranchName(params.repoDir, normalized.branch);
@@ -1844,7 +4144,6 @@ async function commitResultsRunWithTemporaryIndex(params) {
         upstreamRef: base.remoteExists ? base.remoteRef : void 0
       };
     }
-    await ensureResultsRepoCommitIdentity(params.repoDir);
     const commitArgs = [
       "commit-tree",
       newTree,
@@ -1854,7 +4153,9 @@ async function commitResultsRunWithTemporaryIndex(params) {
       "-m",
       `AgentV-Run: ${params.targetRunId}`
     ];
-    const { stdout: commitStdout } = await runGit(commitArgs, { cwd: params.repoDir });
+    const { stdout: commitStdout } = await runGitWithFallbackCommitIdentity(commitArgs, {
+      cwd: params.repoDir
+    });
     const commitSha = commitStdout.trim();
     await runGit(
       [
@@ -1880,53 +4181,141 @@ async function commitResultsRunWithTemporaryIndex(params) {
     await rm(indexRoot, { recursive: true, force: true }).catch(() => void 0);
   }
 }
+function buildDirectPushResult(normalized, changed, outcome) {
+  const details = outcome?.details;
+  return {
+    changed,
+    push_conflict_policy: normalized.push_conflict_policy,
+    ...outcome?.blocked === true && {
+      blocked: true,
+      block_reason: outcome.blockReason,
+      sync_status: "push_conflict"
+    },
+    ...pushDetailsToWire(details)
+  };
+}
+function mergeDirectPushResults(normalized, results) {
+  const blocked = results.find((result) => result.blocked);
+  if (blocked) {
+    return blocked;
+  }
+  const detailed = [...results].reverse().find((result) => result.backup_ref !== void 0);
+  return {
+    changed: results.some((result) => result.changed),
+    push_conflict_policy: normalized.push_conflict_policy,
+    ...detailed?.backup_ref !== void 0 && {
+      backup_ref: detailed.backup_ref
+    },
+    ...detailed?.target_branch !== void 0 && { target_branch: detailed.target_branch },
+    ...detailed?.remote_commit !== void 0 && { remote_commit: detailed.remote_commit },
+    ...detailed?.local_commit !== void 0 && { local_commit: detailed.local_commit },
+    ...detailed?.backup_commit !== void 0 && { backup_commit: detailed.backup_commit },
+    ...detailed?.previous_remote_commit !== void 0 && {
+      previous_remote_commit: detailed.previous_remote_commit
+    },
+    ...detailed?.force_pushed_commit !== void 0 && {
+      force_pushed_commit: detailed.force_pushed_commit
+    },
+    ...detailed?.lease_commit !== void 0 && { lease_commit: detailed.lease_commit }
+  };
+}
 async function pushDirectResultsToStorageBranch(params) {
-  for (let attempt = 1; attempt <= DIRECT_PUSH_MAX_RETRIES; attempt++) {
-    try {
-      await runGit(
-        [
-          "push",
-          "--porcelain",
-          params.normalized.remote,
-          `refs/heads/${params.storageBranch}:refs/heads/${params.storageBranch}`
-        ],
-        { cwd: params.repoDir }
-      );
-      updateStatusFile(params.normalized, {
-        last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
-        last_error: void 0
-      });
-      await fetchResultsRepo(params.repoDir, params.normalized.remote, params.storageBranch).catch(
-        () => void 0
-      );
-      return;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (attempt < DIRECT_PUSH_MAX_RETRIES && message.includes("non-fast-forward")) {
-        await fetchResultsRepo(params.repoDir, params.normalized.remote, params.storageBranch);
-        const remoteRef = remoteBranchRef(params.storageBranch, params.normalized.remote);
-        const localOnlyCount = await gitRefExists(params.repoDir, remoteRef) ? await countUnpushedCommits(params.repoDir, remoteRef, params.storageBranch) : 0;
-        if (localOnlyCount > 1) {
-          throw new Error(
-            `Results branch has ${localOnlyCount} local commits and remote advanced; push manually after reconciling ${params.storageBranch}`
-          );
-        }
-        await commitResultsRunWithTemporaryIndex({
-          normalized: params.normalized,
-          repoDir: params.repoDir,
-          sourceDir: params.sourceDir,
-          destinationPath: params.destinationPath,
-          commitMessage: params.commitMessage,
-          targetRunId: params.targetRunId,
-          preferRemoteBase: true
-        });
-      } else {
-        throw error;
-      }
+  try {
+    await runGit(
+      [
+        "push",
+        "--porcelain",
+        params.normalized.remote,
+        `refs/heads/${params.storageBranch}:refs/heads/${params.storageBranch}`
+      ],
+      { cwd: params.repoDir }
+    );
+    updateStatusFile(params.normalized, {
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: void 0
+    });
+    await fetchResultsRepo(params.repoDir, params.normalized.remote, params.storageBranch).catch(
+      () => void 0
+    );
+    return void 0;
+  } catch (error) {
+    if (!isNonFastForwardPushError(error)) {
+      throw error;
+    }
+    const outcome = await resolveResultBranchPushConflict({
+      normalized: params.normalized,
+      repoDir: params.repoDir,
+      targetBranch: params.storageBranch,
+      sourceRef: `refs/heads/${params.storageBranch}`
+    });
+    if (outcome.blocked) {
+      updateStatusFile(params.normalized, { last_error: outcome.blockReason });
+      return outcome;
+    }
+    updateStatusFile(params.normalized, {
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: void 0
+    });
+    await fetchResultsRepo(params.repoDir, params.normalized.remote, params.storageBranch).catch(
+      () => void 0
+    );
+    return outcome;
+  }
+}
+async function commitAndMaybePushRunTree(params) {
+  const result = await commitResultsRunWithTemporaryIndex({
+    normalized: params.normalized,
+    repoDir: params.repoDir,
+    sourceDir: params.sourceDir,
+    destinationPath: params.destinationPath,
+    commitMessage: params.commitMessage,
+    targetRunId: params.targetRunId
+  });
+  if (!params.shouldPush) {
+    updateStatusFile(params.normalized, { last_error: void 0 });
+    return buildDirectPushResult(params.normalized, result.commitCreated);
+  }
+  if (!result.commitCreated) {
+    const localBranchExists2 = await gitRefExists(
+      params.repoDir,
+      `refs/heads/${params.normalized.branch}`
+    );
+    const hasUnpushed = result.upstreamRef ? localBranchExists2 ? await hasUnpushedCommits(params.repoDir, result.upstreamRef, params.normalized.branch) : false : localBranchExists2;
+    if (!hasUnpushed) {
+      return buildDirectPushResult(params.normalized, false);
     }
+    const aheadPaths = result.upstreamRef ? await getAheadPaths(
+      params.repoDir,
+      result.upstreamRef,
+      `refs/heads/${params.normalized.branch}`
+    ) : [];
+    if (result.upstreamRef && !areSafeResultsRepoPaths(aheadPaths)) {
+      const error = new Error("Results repo has non-results committed changes");
+      updateStatusFile(params.normalized, { last_error: error.message });
+      throw error;
+    }
+    const outcome2 = await pushDirectResultsToStorageBranch({
+      normalized: params.normalized,
+      repoDir: params.repoDir,
+      storageBranch: params.normalized.branch
+    });
+    return buildDirectPushResult(params.normalized, !outcome2?.blocked, outcome2);
   }
+  const outcome = await pushDirectResultsToStorageBranch({
+    normalized: params.normalized,
+    repoDir: params.repoDir,
+    storageBranch: params.normalized.branch
+  });
+  return buildDirectPushResult(params.normalized, !outcome?.blocked, outcome);
 }
 async function directPushResults(params) {
+  const result = await directPushResultsWithDetails(params);
+  if (result.blocked) {
+    throw new ResultsBranchPushConflictError(result);
+  }
+  return result.changed;
+}
+async function directPushResultsWithDetails(params) {
   const normalized = normalizeResultsConfig(params.config);
   const repoDir = await ensureResultsRepoClone(normalized);
   await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch((error) => {
@@ -1940,53 +4329,61 @@ async function directPushResults(params) {
     branch: storageBranch
   };
   const targetRunId = buildGitRunId(params.destinationPath);
-  const result = await commitResultsRunWithTemporaryIndex({
-    normalized: storageConfig,
-    repoDir,
+  const shouldPush = normalized.auto_push || normalized.require_push;
+  const sidecarPointers = collectArtifactSidecarPointers(params.sourceDir);
+  const sidecar = await prepareArtifactSidecar({
     sourceDir: params.sourceDir,
-    destinationPath: params.destinationPath,
-    commitMessage: params.commitMessage,
-    targetRunId
+    pointers: sidecarPointers
   });
-  const shouldPush = normalized.auto_push || normalized.require_push;
-  if (!shouldPush) {
-    updateStatusFile(storageConfig, { last_error: void 0 });
-    return result.commitCreated;
-  }
-  if (!result.commitCreated) {
-    const hasUnpushed = result.upstreamRef ? await hasUnpushedCommits(repoDir, result.upstreamRef, storageBranch) : true;
-    if (hasUnpushed) {
-      const aheadPaths = result.upstreamRef ? await getAheadPaths(repoDir, result.upstreamRef, `refs/heads/${storageBranch}`) : [];
-      if (result.upstreamRef && !areSafeResultsRepoPaths(aheadPaths)) {
-        const error = new Error("Results repo has non-results committed changes");
-        updateStatusFile(storageConfig, { last_error: error.message });
-        throw error;
-      }
-      await pushDirectResultsToStorageBranch({
-        normalized: storageConfig,
+  let publishedResultsSource;
+  try {
+    publishedResultsSource = await preparePublishedResultsSource({
+      sourceDir: params.sourceDir,
+      destinationPath: params.destinationPath,
+      pointers: sidecarPointers
+    });
+    const pushResults = [];
+    if (sidecar) {
+      await fetchResultsRepo(repoDir, normalized.remote, AGENTV_RESULTS_ARTIFACTS_REF).catch(
+        (error) => {
+          if (normalized.require_push) {
+            throw error;
+          }
+        }
+      );
+      const sidecarResult = await commitAndMaybePushRunTree({
+        normalized: {
+          ...normalized,
+          branch: AGENTV_RESULTS_ARTIFACTS_REF
+        },
         repoDir,
-        storageBranch,
-        upstreamRef: result.upstreamRef,
-        sourceDir: params.sourceDir,
+        sourceDir: sidecar.sourceDir,
         destinationPath: params.destinationPath,
-        commitMessage: params.commitMessage,
-        targetRunId
+        commitMessage: `chore(results): publish artifact sidecars for ${targetRunId}`,
+        targetRunId,
+        shouldPush
       });
-      return true;
+      pushResults.push(sidecarResult);
+      if (sidecarResult.blocked) {
+        return sidecarResult;
+      }
     }
-    return false;
+    pushResults.push(
+      await commitAndMaybePushRunTree({
+        normalized: storageConfig,
+        repoDir,
+        sourceDir: publishedResultsSource?.sourceDir ?? params.sourceDir,
+        destinationPath: params.destinationPath,
+        commitMessage: params.commitMessage,
+        targetRunId,
+        shouldPush
+      })
+    );
+    return mergeDirectPushResults(normalized, pushResults);
+  } finally {
+    await publishedResultsSource?.cleanup().catch(() => void 0);
+    await sidecar?.cleanup().catch(() => void 0);
   }
-  await pushDirectResultsToStorageBranch({
-    normalized: storageConfig,
-    repoDir,
-    storageBranch,
-    upstreamRef: result.upstreamRef,
-    sourceDir: params.sourceDir,
-    destinationPath: params.destinationPath,
-    commitMessage: params.commitMessage,
-    targetRunId
-  });
-  return true;
 }
 function buildGitRunId(relativeRunPath) {
   const normalized = relativeRunPath.split(path4.sep).join("/");
@@ -2091,6 +4488,39 @@ function parseGitBatchBlobs(output) {
   }
   return blobs;
 }
+async function readGitResultArtifact(params) {
+  const artifactRef = params.ref ?? AGENTV_RESULTS_ARTIFACTS_REF;
+  const normalizedKey = normalizeDestinationPath(params.key);
+  const remote = params.remote ?? "origin";
+  if (!artifactRef.startsWith("refs/")) {
+    await fetchResultsArtifactRef(params.repoDir, remote, artifactRef).catch(() => void 0);
+  }
+  const candidateRefs = [
+    `refs/remotes/${remote}/${artifactRef}`,
+    `refs/heads/${artifactRef}`,
+    artifactRef
+  ].filter((candidate, index, all) => all.indexOf(candidate) === index);
+  for (const candidateRef of candidateRefs) {
+    const blobs = parseGitBatchBlobs(
+      await runGitBatch(params.repoDir, `${candidateRef}:${normalizedKey}
+`)
+    );
+    const blob = blobs[0];
+    if (!blob) {
+      continue;
+    }
+    verifyArtifactPointerChecksum(
+      {
+        path: normalizedKey,
+        ...params.sha256 ? { sha256: params.sha256 } : {},
+        ...params.objectVersion ? { objectVersion: params.objectVersion } : {}
+      },
+      blob.content
+    );
+    return Buffer.from(blob.content);
+  }
+  return void 0;
+}
 function buildWipBranchName(runDir) {
   const hostname = os.hostname().replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 40);
   const runBasename = path4.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
@@ -2117,8 +4547,6 @@ async function setupWipWorktree(params) {
   await runGit(["worktree", "add", "-B", params.wipBranch, worktreeDir, baseRef], {
     cwd: cloneDir
   });
-  await runGit(["config", "user.email", "agentv@wip-checkpoint"], { cwd: worktreeDir });
-  await runGit(["config", "user.name", "AgentV WIP Checkpoint"], { cwd: worktreeDir });
   return {
     wipBranch: params.wipBranch,
     worktreeDir,
@@ -2156,7 +4584,7 @@ async function pushWipCheckpoint(params) {
     return false;
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  await runGit(
+  await runGitWithFallbackCommitIdentity(
     ["commit", "--amend", "-m", `wip(results): checkpoint ${params.handle.wipBranch} ${timestamp}`],
     { cwd: params.handle.worktreeDir }
   );
@@ -2282,10 +4710,10 @@ async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main")
 }
 async function syncProject(entry) {
   if (!entry.repoUrl) {
-    throw new Error(`Project '${entry.id}' has no repo_url defined`);
+    throw new Error(`Project '${entry.id}' has no repo.url defined`);
   }
   if (!entry.ref) {
-    throw new Error(`Project '${entry.id}' has no ref defined`);
+    throw new Error(`Project '${entry.id}' has no repo.branch defined`);
   }
   const dest = entry.path;
   if (existsSync2(`${dest}/.git`)) {
@@ -3412,6 +5840,10 @@ function createAgentKernel() {
 }
 
 export {
+  TRACE_SESSION_SCHEMA_VERSION,
+  traceEnvelopeToTraceSessionResponse,
+  buildTraceSpanTree,
+  normalizeTraceArtifactToTraceSessionResponse,
   transpileEvalYaml,
   transpileEvalYamlFile,
   getOutputFilenames,
@@ -3437,6 +5869,8 @@ export {
   pushResultsRepoBranch,
   createDraftResultsPr,
   directPushResults,
+  directPushResultsWithDetails,
+  readGitResultArtifact,
   buildWipBranchName,
   setupWipWorktree,
   pushWipCheckpoint,
@@ -3460,4 +5894,4 @@ export {
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-RBOP5X36.js.map
+//# sourceMappingURL=chunk-5NDSGGMJ.js.map