agentv 4.35.1 → 4.37.0-next.1

package/dist/{chunk-KNF3AGCI.js → chunk-OYI35QFW.js}

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
+  buildTraceFromMessages,
   external_exports,
   extractLastAssistantContent,
   getAgentvConfigDir,
@@ -9,10 +10,8 @@ import {
   parseRepoCheckout,
   parseRepoClone,
   parseRepoSource,
-  parseYamlValue,
-  toCamelCaseDeep,
-  toSnakeCaseDeep
-} from "./chunk-6QEIZ33V.js";
+  parseYamlValue
+} from "./chunk-RL4S2FBZ.js";
 
 // ../../packages/core/dist/index.js
 import { readFileSync } from "node:fs";
@@ -547,6 +546,8 @@ function extractReposFromObject(obj) {
 var execFileAsync = promisify(execFile);
 var RESULTS_REPO_RESULTS_DIR = ".agentv/results";
 var RESULTS_REPO_RUNS_DIR = `${RESULTS_REPO_RESULTS_DIR}/runs`;
+var RESULTS_REPO_COMMIT_EMAIL = "agentv@results-repo";
+var RESULTS_REPO_COMMIT_NAME = "AgentV Results";
 var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
@@ -567,10 +568,12 @@ function expandHome(p) {
 }
 function normalizeResultsConfig(config) {
   const repo = config.repo.trim();
+  const branch = config.branch?.trim();
   const resolvedPath = config.path ? expandHome(config.path.trim()) : path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
+    ...branch ? { branch } : {},
     path: resolvedPath,
     auto_push: config.auto_push === true,
     branch_prefix: config.branch_prefix?.trim() || "eval-results"
@@ -638,6 +641,10 @@ 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 });
+}
 async function resolveDefaultBranch(repoDir) {
   try {
     const { stdout } = await runGit(["symbolic-ref", "refs/remotes/origin/HEAD"], { cwd: repoDir });
@@ -660,6 +667,64 @@ async function resolveDefaultBranch(repoDir) {
 async function fetchResultsRepo(repoDir) {
   await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
 }
+function remoteBranchRef(branch) {
+  return `origin/${branch}`;
+}
+function missingConfiguredBranchError(config) {
+  const branch = config.branch ?? "<unknown>";
+  return new Error(
+    [
+      `Results repo remote branch '${branch}' does not exist in ${config.repo}.`,
+      "Create the storage branch once, then retry. Example:",
+      `  git clone ${resolveResultsRepoUrl(config.repo)} /tmp/agentv-results-init`,
+      "  cd /tmp/agentv-results-init",
+      `  git switch --orphan ${branch}`,
+      "  git rm -rf .",
+      '  git commit --allow-empty -m "chore(results): initialize AgentV results branch"',
+      `  git push origin HEAD:${branch}`
+    ].join("\n")
+  );
+}
+async function assertConfiguredResultsBranchExists(repoDir, config) {
+  if (!config.branch) {
+    return void 0;
+  }
+  const ref = remoteBranchRef(config.branch);
+  const { stdout } = await runGit(["rev-parse", "--verify", `${ref}^{commit}`], {
+    cwd: repoDir,
+    check: false
+  });
+  if (!stdout.trim()) {
+    throw missingConfiguredBranchError(config);
+  }
+  return ref;
+}
+async function localBranchExists(repoDir, branch) {
+  const { stdout } = await runGit(["rev-parse", "--verify", `refs/heads/${branch}`], {
+    cwd: repoDir,
+    check: false
+  });
+  return stdout.trim().length > 0;
+}
+async function checkoutConfiguredResultsBranch(repoDir, config) {
+  const remoteRef = await assertConfiguredResultsBranchExists(repoDir, config);
+  if (!config.branch || !remoteRef) {
+    return void 0;
+  }
+  const currentBranch = await getCurrentBranch(repoDir);
+  if (currentBranch !== config.branch) {
+    if (await localBranchExists(repoDir, config.branch)) {
+      await runGit(["checkout", config.branch], { cwd: repoDir });
+    } else {
+      await runGit(["checkout", "--track", "-b", config.branch, remoteRef], { cwd: repoDir });
+    }
+  }
+  await runGit(["branch", "--set-upstream-to", remoteRef, config.branch], {
+    cwd: repoDir,
+    check: false
+  });
+  return remoteRef;
+}
 async function isGitRepository(repoDir) {
   try {
     const { stdout } = await runGit(["rev-parse", "--is-inside-work-tree"], { cwd: repoDir });
@@ -763,7 +828,10 @@ async function getCurrentBranch(repoDir) {
   });
   return sha.trim() ? `HEAD@${sha.trim()}` : void 0;
 }
-async function resolveComparisonRef(repoDir) {
+async function resolveComparisonRef(repoDir, config) {
+  if (config?.branch) {
+    return assertConfiguredResultsBranchExists(repoDir, config);
+  }
   const { stdout: upstream } = await runGit(
     ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
     { cwd: repoDir, check: false }
@@ -826,9 +894,9 @@ async function buildGitDiffSummary(repoDir, upstream) {
   }
   return summaries.length > 0 ? summaries.join("\n") : void 0;
 }
-async function inspectResultsRepoGit(repoDir) {
+async function inspectResultsRepoGit(repoDir, config) {
   const branch = await getCurrentBranch(repoDir);
-  const upstream = await resolveComparisonRef(repoDir);
+  const upstream = await resolveComparisonRef(repoDir, config);
   const { stdout: porcelain } = await runGit(
     ["status", "--porcelain=v1", "--untracked-files=all"],
     {
@@ -936,7 +1004,10 @@ function getPushTargetBranch(upstream, baseBranch) {
   return upstream?.startsWith("origin/") ? upstream.slice("origin/".length) : baseBranch;
 }
 async function statusFromInspection(normalized, repoDir) {
-  return withGitInspection(getResultsRepoStatus(normalized), await inspectResultsRepoGit(repoDir));
+  return withGitInspection(
+    getResultsRepoStatus(normalized),
+    await inspectResultsRepoGit(repoDir, normalized)
+  );
 }
 async function getResultsRepoSyncStatus(config) {
   const baseStatus = getResultsRepoStatus(config);
@@ -957,10 +1028,15 @@ async function getResultsRepoSyncStatus(config) {
     };
   }
   try {
-    return withGitInspection(baseStatus, await inspectResultsRepoGit(normalized.path));
+    if (normalized.branch) {
+      await fetchResultsRepo(normalized.path);
+      await checkoutConfiguredResultsBranch(normalized.path, normalized);
+    }
+    return withGitInspection(baseStatus, await inspectResultsRepoGit(normalized.path, normalized));
   } catch (error) {
     return {
       ...baseStatus,
+      ...normalized.branch ? { available: false } : {},
       sync_status: "unavailable",
       last_error: getStatusMessage(error)
     };
@@ -971,6 +1047,7 @@ async function syncResultsRepo(config) {
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
     await fetchResultsRepo(repoDir);
+    await checkoutConfiguredResultsBranch(repoDir, normalized);
     updateStatusFile(normalized, {
       last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
       last_error: void 0
@@ -1004,7 +1081,8 @@ async function syncResultsRepoForProject(config) {
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
     await fetchResultsRepo(repoDir);
-    let inspection = await inspectResultsRepoGit(repoDir);
+    await checkoutConfiguredResultsBranch(repoDir, normalized);
+    let inspection = await inspectResultsRepoGit(repoDir, normalized);
     if (inspection.syncStatus === "conflicted") {
       const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
       updateStatusFile(normalized, {
@@ -1047,9 +1125,9 @@ async function syncResultsRepoForProject(config) {
         try {
           await runGit(["merge", "--ff-only", inspection.upstream], { cwd: repoDir });
           pullPerformed = true;
-          inspection = await inspectResultsRepoGit(repoDir);
+          inspection = await inspectResultsRepoGit(repoDir, normalized);
         } catch (error) {
-          inspection = await inspectResultsRepoGit(repoDir);
+          inspection = await inspectResultsRepoGit(repoDir, normalized);
           const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
           const reason = `Results repo could not be fast-forwarded: ${getStatusMessage(error)}`;
           updateStatusFile(normalized, { last_error: reason });
@@ -1062,6 +1140,7 @@ async function syncResultsRepoForProject(config) {
       }
       if (inspection.syncStatus === "dirty") {
         await runGit(["add", "--all", "--", RESULTS_REPO_RESULTS_DIR], { cwd: repoDir });
+        await ensureResultsRepoCommitIdentity(repoDir);
         await runGit(
           [
             "commit",
@@ -1075,7 +1154,7 @@ async function syncResultsRepoForProject(config) {
           }
         );
         commitCreated = true;
-        inspection = await inspectResultsRepoGit(repoDir);
+        inspection = await inspectResultsRepoGit(repoDir, normalized);
       }
     }
     if (inspection.syncStatus === "diverged") {
@@ -1104,9 +1183,9 @@ async function syncResultsRepoForProject(config) {
       try {
         await runGit(["merge", "--ff-only", inspection.upstream], { cwd: repoDir });
         pullPerformed = true;
-        inspection = await inspectResultsRepoGit(repoDir);
+        inspection = await inspectResultsRepoGit(repoDir, normalized);
       } catch (error) {
-        inspection = await inspectResultsRepoGit(repoDir);
+        inspection = await inspectResultsRepoGit(repoDir, normalized);
         const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
         const reason = `Results repo could not be fast-forwarded: ${getStatusMessage(error)}`;
         updateStatusFile(normalized, { last_error: reason });
@@ -1137,16 +1216,16 @@ async function syncResultsRepoForProject(config) {
           commitCreated
         });
       }
-      const baseBranch = await resolveDefaultBranch(repoDir);
+      const baseBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
       const targetBranch = getPushTargetBranch(inspection.upstream, baseBranch);
       try {
         await runGit(["push", "origin", `HEAD:${targetBranch}`], { cwd: repoDir });
         pushPerformed = true;
         await fetchResultsRepo(repoDir);
-        inspection = await inspectResultsRepoGit(repoDir);
+        inspection = await inspectResultsRepoGit(repoDir, normalized);
       } catch (error) {
         await fetchResultsRepo(repoDir).catch(() => void 0);
-        inspection = await inspectResultsRepoGit(repoDir);
+        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 });
@@ -1240,6 +1319,7 @@ 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 runGit(["push", "-u", "origin", params.branchName], { cwd: params.repoDir });
   return true;
@@ -1276,17 +1356,17 @@ async function createDraftResultsPr(params) {
   return stdout.trim();
 }
 var DIRECT_PUSH_MAX_RETRIES = 3;
-async function hasUnpushedCommits(repoDir, baseBranch) {
-  const { stdout } = await runGit(["rev-list", "--count", `origin/${baseBranch}..HEAD`], {
+async function hasUnpushedCommits(repoDir, upstreamRef) {
+  const { stdout } = await runGit(["rev-list", "--count", `${upstreamRef}..HEAD`], {
     cwd: repoDir,
     check: false
   });
   return Number.parseInt(stdout.trim(), 10) > 0;
 }
-async function pushDirectResultsToBase(params) {
+async function pushDirectResultsToStorageBranch(params) {
   for (let attempt = 1; attempt <= DIRECT_PUSH_MAX_RETRIES; attempt++) {
     try {
-      await runGit(["push", "origin", `HEAD:${params.baseBranch}`], { cwd: params.repoDir });
+      await runGit(["push", "origin", `HEAD:${params.storageBranch}`], { cwd: params.repoDir });
       updateStatusFile(params.normalized, {
         last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
         last_error: void 0
@@ -1296,7 +1376,7 @@ async function pushDirectResultsToBase(params) {
       const message = error instanceof Error ? error.message : String(error);
       if (attempt < DIRECT_PUSH_MAX_RETRIES && message.includes("non-fast-forward")) {
         await fetchResultsRepo(params.repoDir);
-        await runGit(["rebase", `origin/${params.baseBranch}`], { cwd: params.repoDir });
+        await runGit(["rebase", params.upstreamRef], { cwd: params.repoDir });
       } else {
         throw error;
       }
@@ -1306,8 +1386,10 @@ async function pushDirectResultsToBase(params) {
 async function directPushResults(params) {
   const normalized = normalizeResultsConfig(params.config);
   const repoDir = await ensureResultsRepoClone(normalized);
-  const baseBranch = await resolveDefaultBranch(repoDir);
   await fetchResultsRepo(repoDir);
+  const configuredRef = await checkoutConfiguredResultsBranch(repoDir, normalized);
+  const storageBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
+  const upstreamRef = configuredRef ?? remoteBranchRef(storageBranch);
   const targetRunId = buildGitRunId(params.destinationPath);
   const destinationDir = path3.join(
     repoDir,
@@ -1326,20 +1408,21 @@ async function directPushResults(params) {
     check: false
   });
   if (status.trim().length === 0) {
-    if (await hasUnpushedCommits(repoDir, baseBranch)) {
-      const aheadPaths = await getAheadPaths(repoDir, `origin/${baseBranch}`);
+    if (await hasUnpushedCommits(repoDir, upstreamRef)) {
+      const aheadPaths = await getAheadPaths(repoDir, upstreamRef);
       if (!areSafeResultsRepoPaths(aheadPaths)) {
         throw new Error("Results repo has non-results committed changes");
       }
-      await pushDirectResultsToBase({ normalized, repoDir, baseBranch });
+      await pushDirectResultsToStorageBranch({ normalized, repoDir, storageBranch, upstreamRef });
       return true;
     }
     return false;
   }
+  await ensureResultsRepoCommitIdentity(repoDir);
   await runGit(["commit", "-m", params.commitMessage, "-m", `Agentv-Run: ${targetRunId}`], {
     cwd: repoDir
   });
-  await pushDirectResultsToBase({ normalized, repoDir, baseBranch });
+  await pushDirectResultsToStorageBranch({ normalized, repoDir, storageBranch, upstreamRef });
   return true;
 }
 function buildGitRunId(relativeRunPath) {
@@ -1445,6 +1528,75 @@ function parseGitBatchBlobs(output) {
   }
   return blobs;
 }
+function buildWipBranchName(runDir) {
+  const hostname = os.hostname().replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 40);
+  const runBasename = path3.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
+  return `agentv/inflight/${hostname}/${runBasename}`;
+}
+async function setupWipWorktree(params) {
+  const normalized = normalizeResultsConfig(params.config);
+  const cloneDir = await ensureResultsRepoClone(normalized);
+  await fetchResultsRepo(cloneDir);
+  const baseRef = normalized.branch ? await assertConfiguredResultsBranchExists(cloneDir, normalized) : remoteBranchRef(await resolveDefaultBranch(cloneDir));
+  if (!baseRef) {
+    throw missingConfiguredBranchError(normalized);
+  }
+  const worktreeRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-wip-"));
+  const worktreeDir = path3.join(worktreeRoot, "repo");
+  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,
+    cloneDir,
+    cleanup: async () => {
+      try {
+        await runGit(["worktree", "remove", "--force", worktreeDir], { cwd: cloneDir });
+      } finally {
+        await rm(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
+      }
+    }
+  };
+}
+async function pushWipCheckpoint(params) {
+  const destinationDir = path3.join(
+    params.handle.worktreeDir,
+    RESULTS_REPO_RUNS_DIR,
+    params.destinationPath
+  );
+  await stageResultsArtifacts({
+    repoDir: params.handle.worktreeDir,
+    sourceDir: params.sourceDir,
+    destinationDir
+  });
+  await runGit(["add", "--all", "--", RESULTS_REPO_RESULTS_DIR], {
+    cwd: params.handle.worktreeDir
+  });
+  const { stdout: status } = await runGit(["status", "--porcelain"], {
+    cwd: params.handle.worktreeDir,
+    check: false
+  });
+  if (!status.trim()) {
+    return false;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  await runGit(
+    ["commit", "--amend", "-m", `wip(results): checkpoint ${params.handle.wipBranch} ${timestamp}`],
+    { cwd: params.handle.worktreeDir }
+  );
+  await runGit(["push", "--force", "origin", params.handle.wipBranch], {
+    cwd: params.handle.worktreeDir
+  });
+  return true;
+}
+async function deleteWipBranch(params) {
+  const normalized = normalizeResultsConfig(params.config);
+  const cloneDir = await ensureResultsRepoClone(normalized);
+  await runGit(["push", "origin", "--delete", params.wipBranch], { cwd: cloneDir });
+}
 async function listGitRuns(repoDir, ref = "origin/main") {
   const { stdout: treeOut } = await runGit(
     ["ls-tree", "-r", "--name-only", ref, RESULTS_REPO_RUNS_DIR],
@@ -1563,6 +1715,7 @@ function fromYaml(raw) {
       const sync = r.sync && typeof r.sync === "object" ? r.sync : void 0;
       entry.results = {
         repoUrl: r.repo_url.trim(),
+        ...typeof r.branch === "string" && r.branch.trim().length > 0 ? { branch: r.branch.trim() } : {},
         ...typeof r.path === "string" && r.path.trim().length > 0 ? { path: r.path.trim() } : {},
         ...sync && typeof sync.auto_push === "boolean" ? { sync: { autoPush: sync.auto_push } } : {},
         ...typeof r.branch_prefix === "string" && r.branch_prefix.trim().length > 0 ? { branchPrefix: r.branch_prefix.trim() } : {}
@@ -1584,6 +1737,7 @@ function toYaml(entry) {
   if (entry.results) {
     yaml.results = {
       repo_url: entry.results.repoUrl,
+      ...entry.results.branch !== void 0 && { branch: entry.results.branch },
       ...entry.results.path !== void 0 && { path: entry.results.path },
       ...entry.results.sync?.autoPush !== void 0 && {
         sync: { auto_push: entry.results.sync.autoPush }
@@ -1924,9 +2078,7 @@ var OtelTraceExporter = class {
         if (result.suite) rootSpan.setAttribute("agentv.suite", result.suite);
         rootSpan.setAttribute("agentv.score", result.score);
         if (captureContent && result.output.length > 0) {
-          const lastMsg = result.output[result.output.length - 1];
-          const text = typeof lastMsg.content === "string" ? lastMsg.content : JSON.stringify(lastMsg.content);
-          rootSpan.setAttribute("agentv.output_text", text);
+          rootSpan.setAttribute("agentv.output_text", result.output);
         }
         if (result.durationMs != null)
           rootSpan.setAttribute("agentv.trace.duration_ms", result.durationMs);
@@ -1952,10 +2104,11 @@ var OtelTraceExporter = class {
           if (t.llmCallCount != null)
             rootSpan.setAttribute("agentv.trace.llm_call_count", t.llmCallCount);
         }
-        if (result.output) {
+        const traceMessages = result.trace?.messages ?? [];
+        if (traceMessages.length > 0) {
           const parentCtx2 = api.trace.setSpan(api.context.active(), rootSpan);
           if (this.options.groupTurns) {
-            const turns = groupMessagesIntoTurns(result.output);
+            const turns = groupMessagesIntoTurns(traceMessages);
             if (turns.length > 1) {
               for (const [i, turn] of turns.entries()) {
                 api.context.with(parentCtx2, () => {
@@ -1973,12 +2126,12 @@ var OtelTraceExporter = class {
                 });
               }
             } else {
-              for (const msg of result.output) {
+              for (const msg of traceMessages) {
                 this.exportMessage(tracer, api, parentCtx2, msg, captureContent);
               }
             }
           } else {
-            for (const msg of result.output) {
+            for (const msg of traceMessages) {
               this.exportMessage(tracer, api, parentCtx2, msg, captureContent);
             }
           }
@@ -2245,9 +2398,9 @@ var OtelStreamingObserver = class {
     if (this.observedChildSpans || !this.rootCtx) {
       return;
     }
-    const model = result.output.find((msg) => msg.role === "assistant")?.metadata?.model ?? result.target ?? "unknown";
+    const model = result.trace.messages.find((msg) => msg.role === "assistant")?.metadata?.model ?? result.target ?? "unknown";
     this.onLlmCall(String(model), result.tokenUsage);
-    for (const message of result.output) {
+    for (const message of result.trace.messages) {
       for (const toolCall of message.toolCalls ?? []) {
         this.onToolCall(
           toolCall.tool,
@@ -2831,6 +2984,44 @@ async function discoverClaudeSessions(opts) {
   sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
   return sessions.slice(0, limit);
 }
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function toTranscriptTokenUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  return dropUndefined({
+    input: usage.input,
+    output: usage.output,
+    cached: usage.cached,
+    reasoning: usage.reasoning
+  });
+}
+function toTranscriptToolCall(toolCall) {
+  return dropUndefined({
+    tool: toolCall.tool,
+    input: toolCall.input,
+    output: toolCall.output,
+    id: toolCall.id,
+    start_time: toolCall.startTime,
+    end_time: toolCall.endTime,
+    duration_ms: toolCall.durationMs
+  });
+}
+function toTranscriptMessageFields(message) {
+  return dropUndefined({
+    role: message.role,
+    name: message.name,
+    content: message.content,
+    tool_calls: message.toolCalls?.map(toTranscriptToolCall),
+    start_time: message.startTime,
+    end_time: message.endTime,
+    duration_ms: message.durationMs,
+    metadata: message.metadata,
+    token_usage: toTranscriptTokenUsage(message.tokenUsage)
+  });
+}
 function toTranscriptJsonLines(entry, options) {
   const source = {
     provider: entry.source.provider,
@@ -2853,25 +3044,93 @@ function toTranscriptJsonLines(entry, options) {
     test_id: testId,
     target,
     message_index: index,
-    ...toSnakeCaseDeep(message),
+    ...toTranscriptMessageFields(message),
     transcript_token_usage: transcriptTokenUsage,
     transcript_duration_ms: entry.durationMs,
     transcript_cost_usd: entry.costUsd,
     source
   }));
 }
+function traceToTranscriptJsonLines(trace, options) {
+  const provider = (typeof trace.metadata?.provider === "string" ? trace.metadata.provider : void 0) ?? options?.target ?? "agentv";
+  const sessionId = (typeof trace.metadata?.provider_session_id === "string" ? trace.metadata.provider_session_id : void 0) ?? (typeof trace.metadata?.eval_case_id === "string" ? trace.metadata.eval_case_id : void 0) ?? options?.testId ?? "trace";
+  return toTranscriptJsonLines(
+    {
+      messages: [...trace.messages],
+      source: {
+        provider,
+        sessionId,
+        startedAt: trace.startTime
+      },
+      tokenUsage: trace.tokenUsage,
+      durationMs: trace.durationMs,
+      costUsd: trace.costUsd
+    },
+    options
+  );
+}
+function traceFromTranscriptJsonLines(lines) {
+  const [entry] = groupTranscriptJsonLines(lines);
+  if (!entry) {
+    return buildTraceFromMessages();
+  }
+  return buildTraceFromMessages({
+    output: entry.messages,
+    tokenUsage: entry.tokenUsage,
+    durationMs: entry.durationMs,
+    costUsd: entry.costUsd ?? void 0,
+    startTime: entry.source.startedAt,
+    provider: entry.source.provider,
+    target: entry.target,
+    testId: entry.testId,
+    conversationId: entry.source.sessionId
+  });
+}
+function fromTranscriptTokenUsage(usage) {
+  if (!usage) {
+    return void 0;
+  }
+  return {
+    input: usage.input,
+    output: usage.output,
+    cached: usage.cached,
+    reasoning: usage.reasoning
+  };
+}
+function readOptionalString(record, key) {
+  const value = record[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readOptionalNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function fromTranscriptToolCall(wire) {
+  const tool = readOptionalString(wire, "tool");
+  if (!tool) {
+    return void 0;
+  }
+  return {
+    tool,
+    input: wire.input,
+    output: wire.output,
+    id: readOptionalString(wire, "id"),
+    startTime: readOptionalString(wire, "start_time"),
+    endTime: readOptionalString(wire, "end_time"),
+    durationMs: readOptionalNumber(wire, "duration_ms")
+  };
+}
 function buildReplayMessage(line) {
-  const camelCased = toCamelCaseDeep(line);
   return {
-    role: camelCased.role,
-    name: camelCased.name,
-    content: camelCased.content,
-    toolCalls: camelCased.toolCalls,
-    startTime: camelCased.startTime,
-    endTime: camelCased.endTime,
-    durationMs: camelCased.durationMs,
-    metadata: camelCased.metadata,
-    tokenUsage: camelCased.tokenUsage
+    role: line.role,
+    name: line.name,
+    content: line.content,
+    toolCalls: line.tool_calls?.map(fromTranscriptToolCall).filter((toolCall) => toolCall !== void 0),
+    startTime: line.start_time,
+    endTime: line.end_time,
+    durationMs: line.duration_ms,
+    metadata: line.metadata,
+    tokenUsage: fromTranscriptTokenUsage(line.token_usage)
   };
 }
 function groupTranscriptJsonLines(lines) {
@@ -2999,6 +3258,10 @@ export {
   pushResultsRepoBranch,
   createDraftResultsPr,
   directPushResults,
+  buildWipBranchName,
+  setupWipWorktree,
+  pushWipCheckpoint,
+  deleteWipBranch,
   listGitRuns,
   materializeGitRun,
   getProjectsRegistryPath,
@@ -3027,10 +3290,12 @@ export {
   discoverCodexSessions,
   discoverClaudeSessions,
   toTranscriptJsonLines,
+  traceToTranscriptJsonLines,
+  traceFromTranscriptJsonLines,
   groupTranscriptJsonLines,
   readTranscriptJsonl,
   readTranscriptFile,
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-KNF3AGCI.js.map
+//# sourceMappingURL=chunk-OYI35QFW.js.map