agentv 4.38.1 → 4.40.1-next.1

package/dist/{chunk-NLTIK3LV.js → chunk-I3SC4FOT.js}

@@ -1,17 +1,18 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
-  buildTraceFromMessages,
   external_exports,
   extractLastAssistantContent,
   getAgentvDataDir,
   getRepoCheckoutRef,
+  groupTranscriptJsonLines,
   interpolateEnv,
   normalizeRepoIdentity,
   normalizeToolCall,
   parseRepoConfig,
   parseYamlValue,
+  readTranscriptJsonl,
   resolveRepoCloneUrl
-} from "./chunk-VBHHZQS6.js";
+} from "./chunk-BLXYBUU4.js";
 
 // ../../packages/core/dist/index.js
 import { readFileSync } from "node:fs";
@@ -28,7 +29,7 @@ import {
   rmSync,
   writeFileSync
 } from "node:fs";
-import { cp, mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import { cp, lstat, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import os from "node:os";
 import path3 from "node:path";
 import { promisify } from "node:util";
@@ -41,7 +42,6 @@ import path4 from "node:path";
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import path5 from "node:path";
-import { readFile as readFile2 } from "node:fs/promises";
 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).`;
@@ -529,6 +529,8 @@ 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 DEFAULT_RESULTS_BRANCH = "agentv/results/v1";
+var GIT_EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
@@ -547,16 +549,26 @@ function expandHome(p) {
   }
   return 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));
+function normalizeResultsConfig(config, options) {
+  const repoUrl = (config.repo_url ?? config.repo)?.trim();
+  const repoPath = config.repo_path?.trim();
+  const repo = repoUrl ?? repoPath ?? "";
+  const branch = config.branch?.trim() || (repoPath ? DEFAULT_RESULTS_BRANCH : void 0);
+  const remote = config.remote?.trim() || "origin";
+  const autoPush = config.sync?.auto_push ?? config.auto_push === true;
+  const requirePush = config.sync?.require_push === true;
+  const resolvedRepoPath = repoPath ? path3.resolve(options?.baseDir ?? process.cwd(), expandHome(repoPath)) : void 0;
+  const resolvedPath = config.path ? expandHome(config.path.trim()) : repoUrl ? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
+    ...repoUrl ? { repo_url: repoUrl } : {},
+    ...resolvedRepoPath ? { repo_path: resolvedRepoPath } : {},
     ...branch ? { branch } : {},
+    remote,
     path: resolvedPath,
-    auto_push: config.auto_push === true,
+    auto_push: autoPush,
+    require_push: requirePush,
     branch_prefix: config.branch_prefix?.trim() || "eval-results"
   };
 }
@@ -614,10 +626,11 @@ function getGitEnv() {
       env[key] = value;
     }
   }
+  env.GIT_TERMINAL_PROMPT = "0";
   return env;
 }
 async function runGit(args, options) {
-  return runCommand("git", args, { ...options, env: getGitEnv() });
+  return runCommand("git", args, { ...options, env: { ...getGitEnv(), ...options?.env } });
 }
 async function runGh(args, options) {
   return runCommand("gh", args, options);
@@ -645,40 +658,34 @@ async function resolveDefaultBranch(repoDir) {
   }
   return "main";
 }
-async function fetchResultsRepo(repoDir) {
-  await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
+async function fetchResultsRepo(repoDir, remote = "origin") {
+  await runGit(["fetch", remote, "--prune"], { cwd: repoDir });
 }
-function remoteBranchRef(branch) {
-  return `origin/${branch}`;
+function remoteBranchRef(branch, remote = "origin") {
+  return `${remote}/${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);
+async function gitRefExists(repoDir, ref) {
   const { stdout } = await runGit(["rev-parse", "--verify", `${ref}^{commit}`], {
     cwd: repoDir,
     check: false
   });
-  if (!stdout.trim()) {
-    throw missingConfiguredBranchError(config);
+  return stdout.trim().length > 0;
+}
+async function configuredResultsBranchRef(repoDir, config) {
+  if (!config.branch) {
+    return void 0;
+  }
+  const remoteRef = remoteBranchRef(config.branch, config.remote);
+  if (await gitRefExists(repoDir, remoteRef)) {
+    return remoteRef;
   }
-  return ref;
+  if (await gitRefExists(repoDir, config.branch)) {
+    return config.branch;
+  }
+  return void 0;
+}
+async function assertConfiguredResultsBranchExists(repoDir, config) {
+  return configuredResultsBranchRef(repoDir, config);
 }
 async function localBranchExists(repoDir, branch) {
   const { stdout } = await runGit(["rev-parse", "--verify", `refs/heads/${branch}`], {
@@ -688,24 +695,40 @@ async function localBranchExists(repoDir, branch) {
   return stdout.trim().length > 0;
 }
 async function checkoutConfiguredResultsBranch(repoDir, config) {
+  const branch = config.branch;
+  if (!branch) {
+    return void 0;
+  }
   const remoteRef = await assertConfiguredResultsBranchExists(repoDir, config);
-  if (!config.branch || !remoteRef) {
+  if (!remoteRef) {
+    await createOrphanResultsBranch(repoDir, branch);
+    await runGit(["checkout", branch], { cwd: repoDir });
     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 });
+  if (currentBranch !== branch) {
+    if (await localBranchExists(repoDir, branch)) {
+      await runGit(["checkout", branch], { cwd: repoDir });
     } else {
-      await runGit(["checkout", "--track", "-b", config.branch, remoteRef], { cwd: repoDir });
+      await runGit(["checkout", "--track", "-b", branch, remoteRef], { cwd: repoDir });
     }
   }
-  await runGit(["branch", "--set-upstream-to", remoteRef, config.branch], {
-    cwd: repoDir,
-    check: false
-  });
+  if (remoteRef === remoteBranchRef(branch, config.remote)) {
+    await runGit(["branch", "--set-upstream-to", remoteRef, branch], {
+      cwd: repoDir,
+      check: false
+    });
+  }
   return remoteRef;
 }
+async function createOrphanResultsBranch(repoDir, branch) {
+  await ensureResultsRepoCommitIdentity(repoDir);
+  const { stdout } = await runGit(
+    ["commit-tree", GIT_EMPTY_TREE, "-m", "chore(results): initialize AgentV results branch"],
+    { cwd: repoDir }
+  );
+  await runGit(["update-ref", `refs/heads/${branch}`, stdout.trim()], { cwd: repoDir });
+}
 async function isGitRepository(repoDir) {
   try {
     const { stdout } = await runGit(["rev-parse", "--is-inside-work-tree"], { cwd: repoDir });
@@ -714,8 +737,13 @@ async function isGitRepository(repoDir) {
     return false;
   }
 }
+async function resolveGitTopLevel(repoDir) {
+  const { stdout } = await runGit(["rev-parse", "--show-toplevel"], { cwd: repoDir });
+  return stdout.trim() || repoDir;
+}
 function updateStatusFile(config, patch) {
-  const cachePaths = getResultsRepoLocalPaths(config.repo);
+  const repo = typeof config.repo === "string" ? config.repo : config.repo_url ?? config.repo_path ?? "";
+  const cachePaths = getResultsRepoLocalPaths(repo);
   const current = readPersistedStatus(cachePaths.statusFile);
   writePersistedStatus(cachePaths.statusFile, {
     ...current,
@@ -724,6 +752,12 @@ function updateStatusFile(config, patch) {
 }
 async function ensureResultsRepoClone(config) {
   const normalized = normalizeResultsConfig(config);
+  if (normalized.repo_path) {
+    if (!await isGitRepository(normalized.repo_path)) {
+      throw new Error(`Results repo_path is not a git repository: ${normalized.repo_path}`);
+    }
+    return resolveGitTopLevel(normalized.repo_path);
+  }
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
   mkdirSync(cachePaths.rootDir, { recursive: true });
@@ -736,7 +770,7 @@ async function ensureResultsRepoClone(config) {
       await runGit([
         "clone",
         "--filter=blob:none",
-        resolveResultsRepoUrl(normalized.repo),
+        resolveResultsRepoUrl(normalized.repo_url ?? normalized.repo),
         cloneDir
       ]);
       return cloneDir;
@@ -767,8 +801,10 @@ function getResultsRepoStatus(config) {
     configured: true,
     available: existsSync(normalized.path),
     repo: normalized.repo,
+    ...normalized.repo_path !== void 0 && { repo_path: normalized.repo_path },
     path: normalized.path,
     auto_push: normalized.auto_push,
+    require_push: normalized.require_push,
     branch_prefix: normalized.branch_prefix,
     local_dir: normalized.path,
     last_synced_at: persisted.last_synced_at,
@@ -822,7 +858,7 @@ async function resolveComparisonRef(repoDir, config) {
     return upstreamRef;
   }
   const baseBranch = await resolveDefaultBranch(repoDir);
-  const fallback = `origin/${baseBranch}`;
+  const fallback = `${config?.remote ?? "origin"}/${baseBranch}`;
   const { stdout: fallbackSha } = await runGit(["rev-parse", "--verify", fallback], {
     cwd: repoDir,
     check: false
@@ -845,6 +881,56 @@ async function getAheadBehind(repoDir, upstream) {
     ...Number.isFinite(behind) && { behind }
   };
 }
+async function getAheadBehindForRefs(repoDir, leftRef, rightRef) {
+  const { stdout } = await runGit(
+    ["rev-list", "--left-right", "--count", `${leftRef}...${rightRef}`],
+    {
+      cwd: repoDir,
+      check: false
+    }
+  );
+  const [aheadText, behindText] = stdout.trim().split(/\s+/);
+  const ahead = Number.parseInt(aheadText ?? "", 10);
+  const behind = Number.parseInt(behindText ?? "", 10);
+  return {
+    ...Number.isFinite(ahead) && { ahead },
+    ...Number.isFinite(behind) && { behind }
+  };
+}
+async function inspectResultsStorageBranchGit(repoDir, config) {
+  if (!config.branch) {
+    return {
+      syncStatus: "clean",
+      dirtyPaths: [],
+      conflictedPaths: []
+    };
+  }
+  const localRef = `refs/heads/${config.branch}`;
+  const upstream = remoteBranchRef(config.branch, config.remote);
+  const localExists = await gitRefExists(repoDir, localRef);
+  const remoteExists = await gitRefExists(repoDir, upstream);
+  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) {
+    syncStatus = "diverged";
+  } else if (behind > 0) {
+    syncStatus = "behind";
+  } else if (ahead > 0) {
+    syncStatus = "ahead";
+  }
+  return {
+    syncStatus,
+    branch: config.branch,
+    ...remoteExists && { upstream },
+    ahead,
+    behind,
+    dirtyPaths: [],
+    conflictedPaths: []
+  };
+}
 async function hasInProgressGitConflict(repoDir) {
   const markers = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD"];
   for (const marker of markers) {
@@ -971,18 +1057,19 @@ function isSafeResultsRepoPath(p) {
 function areSafeResultsRepoPaths(paths) {
   return paths.length > 0 && paths.every(isSafeResultsRepoPath);
 }
-async function getAheadPaths(repoDir, upstream) {
+async function getAheadPaths(repoDir, upstream, branch = "HEAD") {
   if (!upstream) {
     return [];
   }
-  const { stdout } = await runGit(["diff", "--name-only", `${upstream}..HEAD`], {
+  const { stdout } = await runGit(["diff", "--name-only", `${upstream}..${branch}`], {
     cwd: repoDir,
     check: false
   });
   return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).sort();
 }
-function getPushTargetBranch(upstream, baseBranch) {
-  return upstream?.startsWith("origin/") ? upstream.slice("origin/".length) : baseBranch;
+function getPushTargetBranch(upstream, baseBranch, remote = "origin") {
+  const prefix = `${remote}/`;
+  return upstream?.startsWith(prefix) ? upstream.slice(prefix.length) : baseBranch;
 }
 async function statusFromInspection(normalized, repoDir) {
   return withGitInspection(
@@ -1009,8 +1096,15 @@ async function getResultsRepoSyncStatus(config) {
     };
   }
   try {
+    if (normalized.repo_path) {
+      await fetchResultsRepo(normalized.path, normalized.remote).catch(() => void 0);
+      return withGitInspection(
+        baseStatus,
+        await inspectResultsStorageBranchGit(normalized.path, normalized)
+      );
+    }
     if (normalized.branch) {
-      await fetchResultsRepo(normalized.path);
+      await fetchResultsRepo(normalized.path, normalized.remote).catch(() => void 0);
       await checkoutConfiguredResultsBranch(normalized.path, normalized);
     }
     return withGitInspection(baseStatus, await inspectResultsRepoGit(normalized.path, normalized));
@@ -1027,8 +1121,10 @@ async function syncResultsRepo(config) {
   const normalized = normalizeResultsConfig(config);
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
-    await fetchResultsRepo(repoDir);
-    await checkoutConfiguredResultsBranch(repoDir, normalized);
+    await fetchResultsRepo(repoDir, normalized.remote);
+    if (!normalized.repo_path) {
+      await checkoutConfiguredResultsBranch(repoDir, normalized);
+    }
     updateStatusFile(normalized, {
       last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
       last_error: void 0
@@ -1061,7 +1157,59 @@ async function syncResultsRepoForProject(config) {
   let commitCreated = false;
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
-    await fetchResultsRepo(repoDir);
+    if (normalized.repo_path) {
+      try {
+        await fetchResultsRepo(repoDir, normalized.remote);
+      } catch (error) {
+        if (normalized.require_push) {
+          throw error;
+        }
+      }
+      if (normalized.auto_push || normalized.require_push) {
+        if (normalized.branch) {
+          const localRef = `refs/heads/${normalized.branch}`;
+          if (await gitRefExists(repoDir, localRef)) {
+            try {
+              await runGit(
+                [
+                  "push",
+                  "--porcelain",
+                  normalized.remote,
+                  `${localRef}:refs/heads/${normalized.branch}`
+                ],
+                { cwd: repoDir }
+              );
+              pushPerformed = true;
+            } 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
+                }
+              );
+            }
+          }
+        }
+      }
+      updateStatusFile(normalized, {
+        last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+        last_error: void 0
+      });
+      return withActionFlags(await getResultsRepoSyncStatus(normalized), {
+        pullPerformed,
+        pushPerformed,
+        commitCreated
+      });
+    }
+    await fetchResultsRepo(repoDir, normalized.remote);
     await checkoutConfiguredResultsBranch(repoDir, normalized);
     let inspection = await inspectResultsRepoGit(repoDir, normalized);
     if (inspection.syncStatus === "conflicted") {
@@ -1198,14 +1346,14 @@ async function syncResultsRepoForProject(config) {
         });
       }
       const baseBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
-      const targetBranch = getPushTargetBranch(inspection.upstream, baseBranch);
+      const targetBranch = getPushTargetBranch(inspection.upstream, baseBranch, normalized.remote);
       try {
-        await runGit(["push", "origin", `HEAD:${targetBranch}`], { cwd: repoDir });
+        await runGit(["push", normalized.remote, `HEAD:${targetBranch}`], { cwd: repoDir });
         pushPerformed = true;
-        await fetchResultsRepo(repoDir);
+        await fetchResultsRepo(repoDir, normalized.remote);
         inspection = await inspectResultsRepoGit(repoDir, normalized);
       } catch (error) {
-        await fetchResultsRepo(repoDir).catch(() => void 0);
+        await fetchResultsRepo(repoDir, normalized.remote).catch(() => void 0);
         inspection = await inspectResultsRepoGit(repoDir, normalized);
         const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
         const reason = `Results repo push was rejected: ${getStatusMessage(error)}`;
@@ -1239,8 +1387,10 @@ async function checkoutResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const repoDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(repoDir);
-  await fetchResultsRepo(repoDir);
-  await runGit(["checkout", "-B", branchName, `origin/${baseBranch}`], { cwd: repoDir });
+  await fetchResultsRepo(repoDir, normalized.remote);
+  await runGit(["checkout", "-B", branchName, `${normalized.remote}/${baseBranch}`], {
+    cwd: repoDir
+  });
   updateStatusFile(normalized, { last_error: void 0 });
   return {
     branchName,
@@ -1252,12 +1402,15 @@ async function prepareResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
-  await fetchResultsRepo(cloneDir);
+  await fetchResultsRepo(cloneDir, normalized.remote);
   const worktreeRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-repo-"));
   const worktreeDir = path3.join(worktreeRoot, "repo");
-  await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
-    cwd: cloneDir
-  });
+  await runGit(
+    ["worktree", "add", "-B", branchName, worktreeDir, `${normalized.remote}/${baseBranch}`],
+    {
+      cwd: cloneDir
+    }
+  );
   return {
     branchName,
     baseBranch,
@@ -1307,7 +1460,7 @@ async function commitAndPushResultsBranch(params) {
 }
 async function pushResultsRepoBranch(config, branchName, cwd) {
   const normalized = normalizeResultsConfig(config);
-  await runGit(["push", "-u", "origin", branchName], {
+  await runGit(["push", "-u", normalized.remote, branchName], {
     cwd: cwd ?? normalized.path
   });
   updateStatusFile(normalized, {
@@ -1337,27 +1490,230 @@ async function createDraftResultsPr(params) {
   return stdout.trim();
 }
 var DIRECT_PUSH_MAX_RETRIES = 3;
-async function hasUnpushedCommits(repoDir, upstreamRef) {
-  const { stdout } = await runGit(["rev-list", "--count", `${upstreamRef}..HEAD`], {
+async function hasUnpushedCommits(repoDir, upstreamRef, branch) {
+  const { stdout } = await runGit(["rev-list", "--count", `${upstreamRef}..refs/heads/${branch}`], {
     cwd: repoDir,
     check: false
   });
   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);
+    return code <= 31 || code === 127;
+  })) {
+    throw new Error(`Invalid results branch name: ${branch}`);
+  }
+  await runGit(["check-ref-format", "--branch", branch], { cwd: repoDir });
+}
+function normalizeDestinationPath(destinationPath) {
+  const normalized = destinationPath.split(path3.sep).join("/");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
+    throw new Error(`Invalid results destination path: ${destinationPath}`);
+  }
+  return segments.join("/");
+}
+async function listSourceFiles(sourceDir) {
+  const entries = [];
+  async function visit(dir) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const absolutePath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(absolutePath);
+      } else if (entry.isFile() || entry.isSymbolicLink()) {
+        entries.push(absolutePath);
+      }
+    }
+  }
+  await visit(sourceDir);
+  entries.sort();
+  return entries;
+}
+async function getExistingRunTreePaths(repoDir, ref, destinationTreePath) {
+  if (!ref) {
+    return [];
+  }
+  const { stdout } = await runGit(["ls-tree", "-r", "--name-only", ref, destinationTreePath], {
+    cwd: repoDir,
+    check: false
+  });
+  return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+async function resolveStorageBranchBase(params) {
+  const localRef = `refs/heads/${params.normalized.branch}`;
+  const remoteRef = `refs/remotes/${params.normalized.remote}/${params.normalized.branch}`;
+  const localExists = await gitRefExists(params.repoDir, localRef);
+  const remoteExists = await gitRefExists(params.repoDir, remoteRef);
+  const baseRef = params.preferRemote ? remoteExists ? remoteRef : localExists ? localRef : void 0 : localExists ? localRef : remoteExists ? remoteRef : void 0;
+  const baseCommit = baseRef ? (await runGit(["rev-parse", `${baseRef}^{commit}`], {
+    cwd: params.repoDir
+  })).stdout.trim() : void 0;
+  const baseTree = baseRef ? (await runGit(["rev-parse", `${baseRef}^{tree}`], {
+    cwd: params.repoDir
+  })).stdout.trim() : void 0;
+  return { baseRef, baseCommit, baseTree, localRef, localExists, remoteRef, remoteExists };
+}
+async function ensureResultsBranchNotCheckedOut(repoDir, normalized) {
+  const currentBranch = await getCurrentBranch(repoDir);
+  if (currentBranch !== normalized.branch) {
+    return;
+  }
+  if (normalized.repo_path) {
+    throw new Error(
+      `Refusing to publish results while '${normalized.branch}' is checked out in ${repoDir}`
+    );
+  }
+  await runGit(["checkout", "--detach"], { cwd: repoDir });
+}
+async function commitResultsRunWithTemporaryIndex(params) {
+  const { normalized } = params;
+  await assertValidResultsBranchName(params.repoDir, normalized.branch);
+  await ensureResultsBranchNotCheckedOut(params.repoDir, normalized);
+  const destinationRunPath = normalizeDestinationPath(params.destinationPath);
+  const destinationTreePath = path3.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
+  const base = await resolveStorageBranchBase({
+    repoDir: params.repoDir,
+    normalized,
+    preferRemote: params.preferRemoteBase
+  });
+  const indexRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path3.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 });
+    }
+    const existingPaths = await getExistingRunTreePaths(
+      params.repoDir,
+      base.baseRef,
+      destinationTreePath
+    );
+    for (const existingPath of existingPaths) {
+      await runGit(["update-index", "--force-remove", "--", existingPath], {
+        cwd: params.repoDir,
+        env: indexEnv,
+        check: false
+      });
+    }
+    const sourceFiles = await listSourceFiles(params.sourceDir);
+    for (const sourceFile of sourceFiles) {
+      const relativeFile = path3.relative(params.sourceDir, sourceFile).split(path3.sep).join("/");
+      const destinationFile = path3.posix.join(destinationTreePath, relativeFile);
+      const fileStat = await lstat(sourceFile);
+      let mode = fileStat.mode & 73 ? "100755" : "100644";
+      let hashInputPath = sourceFile;
+      if (fileStat.isSymbolicLink()) {
+        mode = "120000";
+        hashInputPath = sourceFile;
+      }
+      const { stdout: blob } = await runGit(["hash-object", "-w", "--no-filters", hashInputPath], {
+        cwd: params.repoDir
+      });
+      await runGit(
+        ["update-index", "--add", "--cacheinfo", `${mode},${blob.trim()},${destinationFile}`],
+        {
+          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 {
+        commitCreated: false,
+        branchUpdated: false,
+        upstreamRef: base.remoteExists ? base.remoteRef : void 0
+      };
+    }
+    await ensureResultsRepoCommitIdentity(params.repoDir);
+    const commitArgs = [
+      "commit-tree",
+      newTree,
+      ...base.baseCommit ? ["-p", base.baseCommit] : [],
+      "-m",
+      params.commitMessage,
+      "-m",
+      `AgentV-Run: ${params.targetRunId}`
+    ];
+    const { stdout: commitStdout } = await runGit(commitArgs, { cwd: params.repoDir });
+    const commitSha = commitStdout.trim();
+    await runGit(
+      [
+        "update-ref",
+        `refs/heads/${normalized.branch}`,
+        commitSha,
+        ...base.localExists && !params.preferRemoteBase ? [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 {
+      commitCreated: true,
+      branchUpdated: true,
+      upstreamRef: base.remoteExists ? base.remoteRef : void 0
+    };
+  } finally {
+    await rm(indexRoot, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
 async function pushDirectResultsToStorageBranch(params) {
   for (let attempt = 1; attempt <= DIRECT_PUSH_MAX_RETRIES; attempt++) {
     try {
-      await runGit(["push", "origin", `HEAD:${params.storageBranch}`], { cwd: params.repoDir });
+      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).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);
-        await runGit(["rebase", params.upstreamRef], { cwd: params.repoDir });
+        await fetchResultsRepo(params.repoDir, params.normalized.remote);
+        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;
       }
@@ -1367,43 +1723,63 @@ async function pushDirectResultsToStorageBranch(params) {
 async function directPushResults(params) {
   const normalized = normalizeResultsConfig(params.config);
   const repoDir = await ensureResultsRepoClone(normalized);
-  await fetchResultsRepo(repoDir);
-  const configuredRef = await checkoutConfiguredResultsBranch(repoDir, normalized);
+  await fetchResultsRepo(repoDir, normalized.remote).catch((error) => {
+    if (normalized.require_push) {
+      throw error;
+    }
+  });
   const storageBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
-  const upstreamRef = configuredRef ?? remoteBranchRef(storageBranch);
+  const storageConfig = {
+    ...normalized,
+    branch: storageBranch
+  };
   const targetRunId = buildGitRunId(params.destinationPath);
-  const destinationDir = path3.join(
-    repoDir,
-    RESULTS_REPO_RESULTS_DIR,
-    "runs",
-    params.destinationPath
-  );
-  await stageResultsArtifacts({
+  const result = await commitResultsRunWithTemporaryIndex({
+    normalized: storageConfig,
     repoDir,
     sourceDir: params.sourceDir,
-    destinationDir
-  });
-  await runGit(["add", "--all"], { cwd: repoDir });
-  const { stdout: status } = await runGit(["status", "--porcelain"], {
-    cwd: repoDir,
-    check: false
+    destinationPath: params.destinationPath,
+    commitMessage: params.commitMessage,
+    targetRunId
   });
-  if (status.trim().length === 0) {
-    if (await hasUnpushedCommits(repoDir, upstreamRef)) {
-      const aheadPaths = await getAheadPaths(repoDir, upstreamRef);
-      if (!areSafeResultsRepoPaths(aheadPaths)) {
-        throw new Error("Results repo has non-results committed changes");
+  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, repoDir, storageBranch, upstreamRef });
+      await pushDirectResultsToStorageBranch({
+        normalized: storageConfig,
+        repoDir,
+        storageBranch,
+        upstreamRef: result.upstreamRef,
+        sourceDir: params.sourceDir,
+        destinationPath: params.destinationPath,
+        commitMessage: params.commitMessage,
+        targetRunId
+      });
       return true;
     }
     return false;
   }
-  await ensureResultsRepoCommitIdentity(repoDir);
-  await runGit(["commit", "-m", params.commitMessage, "-m", `Agentv-Run: ${targetRunId}`], {
-    cwd: repoDir
+  await pushDirectResultsToStorageBranch({
+    normalized: storageConfig,
+    repoDir,
+    storageBranch,
+    upstreamRef: result.upstreamRef,
+    sourceDir: params.sourceDir,
+    destinationPath: params.destinationPath,
+    commitMessage: params.commitMessage,
+    targetRunId
   });
-  await pushDirectResultsToStorageBranch({ normalized, repoDir, storageBranch, upstreamRef });
   return true;
 }
 function buildGitRunId(relativeRunPath) {
@@ -1517,10 +1893,18 @@ function buildWipBranchName(runDir) {
 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));
+  await fetchResultsRepo(cloneDir, normalized.remote).catch((error) => {
+    if (normalized.require_push) {
+      throw error;
+    }
+  });
+  let baseRef = normalized.branch ? await configuredResultsBranchRef(cloneDir, normalized) : remoteBranchRef(await resolveDefaultBranch(cloneDir), normalized.remote);
+  if (!baseRef && normalized.branch) {
+    await createOrphanResultsBranch(cloneDir, normalized.branch);
+    baseRef = normalized.branch;
+  }
   if (!baseRef) {
-    throw missingConfiguredBranchError(normalized);
+    throw new Error("Could not resolve a base ref for the WIP results branch");
   }
   const worktreeRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-wip-"));
   const worktreeDir = path3.join(worktreeRoot, "repo");
@@ -1533,6 +1917,7 @@ async function setupWipWorktree(params) {
     wipBranch: params.wipBranch,
     worktreeDir,
     cloneDir,
+    remote: normalized.remote,
     cleanup: async () => {
       try {
         await runGit(["worktree", "remove", "--force", worktreeDir], { cwd: cloneDir });
@@ -1568,7 +1953,7 @@ async function pushWipCheckpoint(params) {
     ["commit", "--amend", "-m", `wip(results): checkpoint ${params.handle.wipBranch} ${timestamp}`],
     { cwd: params.handle.worktreeDir }
   );
-  await runGit(["push", "--force", "origin", params.handle.wipBranch], {
+  await runGit(["push", "--force", params.handle.remote, params.handle.wipBranch], {
     cwd: params.handle.worktreeDir
   });
   return true;
@@ -1576,7 +1961,7 @@ async function pushWipCheckpoint(params) {
 async function deleteWipBranch(params) {
   const normalized = normalizeResultsConfig(params.config);
   const cloneDir = await ensureResultsRepoClone(normalized);
-  await runGit(["push", "origin", "--delete", params.wipBranch], { cwd: cloneDir });
+  await runGit(["push", normalized.remote, "--delete", params.wipBranch], { cwd: cloneDir });
 }
 async function listGitRuns(repoDir, ref = "origin/main") {
   const { stdout: treeOut } = await runGit(
@@ -1745,38 +2130,6 @@ function deriveCategory(relativePath) {
   const dirs = parts.slice(0, -1).filter((d) => d !== "evals");
   return dirs.length > 0 ? dirs.join("/") : DEFAULT_CATEGORY;
 }
-var OTEL_BACKEND_PRESETS = {
-  langfuse: {
-    name: "langfuse",
-    endpoint: process.env.LANGFUSE_HOST ? `${process.env.LANGFUSE_HOST}/api/public/otel/v1/traces` : "https://cloud.langfuse.com/api/public/otel/v1/traces",
-    headers: (env) => {
-      const pub = env.LANGFUSE_PUBLIC_KEY ?? "";
-      const secret = env.LANGFUSE_SECRET_KEY ?? "";
-      return { Authorization: `Basic ${Buffer.from(`${pub}:${secret}`).toString("base64")}` };
-    }
-  },
-  braintrust: {
-    name: "braintrust",
-    endpoint: "https://api.braintrust.dev/otel/v1/traces",
-    headers: (env) => {
-      const headers = {
-        Authorization: `Bearer ${env.BRAINTRUST_API_KEY ?? ""}`
-      };
-      const parent = env.BRAINTRUST_PARENT ?? (env.BRAINTRUST_PROJECT_ID ? `project_id:${env.BRAINTRUST_PROJECT_ID}` : void 0) ?? (env.BRAINTRUST_PROJECT ? `project_name:${env.BRAINTRUST_PROJECT}` : void 0);
-      if (parent) {
-        headers["x-bt-parent"] = parent;
-      }
-      return headers;
-    }
-  },
-  confident: {
-    name: "confident",
-    endpoint: "https://otel.confident-ai.com/v1/traces",
-    headers: (env) => ({
-      "x-confident-api-key": env.CONFIDENT_API_KEY ?? ""
-    })
-  }
-};
 var OtelTraceExporter = class {
   constructor(options) {
     this.options = options;
@@ -1799,9 +2152,11 @@ var OtelTraceExporter = class {
       const { NodeTracerProvider: Provider, SimpleSpanProcessor } = sdkTraceNode;
       const { resourceFromAttributes } = resourcesMod;
       const { ATTR_SERVICE_NAME } = semconvMod;
-      const resource = resourceFromAttributes({
-        [ATTR_SERVICE_NAME]: this.options.serviceName ?? "agentv"
-      });
+      const resourceAttributes = {
+        [ATTR_SERVICE_NAME]: this.options.serviceName ?? "agentv",
+        ...this.options.resourceAttributes
+      };
+      const resource = resourceFromAttributes(resourceAttributes);
       const processors = [];
       if (this.options.endpoint) {
         const otlpHttp = await import("./esm-TTEMJEVV.js");
@@ -1813,9 +2168,11 @@ var OtelTraceExporter = class {
         processors.push(new SimpleSpanProcessor(exporter));
       }
       if (this.options.otlpFilePath) {
-        const { OtlpJsonFileExporter: OtlpJsonFileExporter2 } = await import("./otlp-json-file-exporter-RJFPCKVK-T6N4OGWG.js");
+        const { OtlpJsonFileExporter: OtlpJsonFileExporter2 } = await import("./otlp-json-file-exporter-RY63S3IG-PZBQPVYY.js");
         processors.push(
-          new SimpleSpanProcessor(new OtlpJsonFileExporter2(this.options.otlpFilePath))
+          new SimpleSpanProcessor(
+            new OtlpJsonFileExporter2(this.options.otlpFilePath, resourceAttributes)
+          )
         );
       }
       if (processors.length === 0) {
@@ -2776,204 +3133,6 @@ 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,
-    session_id: entry.source.sessionId,
-    model: entry.source.model,
-    timestamp: entry.source.startedAt,
-    git_branch: entry.source.gitBranch,
-    cwd: entry.source.cwd ?? entry.source.projectPath,
-    version: entry.source.version
-  };
-  const transcriptTokenUsage = entry.tokenUsage ? {
-    input: entry.tokenUsage.input,
-    output: entry.tokenUsage.output,
-    cached: entry.tokenUsage.cached,
-    reasoning: entry.tokenUsage.reasoning
-  } : void 0;
-  const testId = options?.testId ?? entry.source.sessionId;
-  const target = options?.target ?? entry.source.provider;
-  return entry.messages.map((message, index) => ({
-    test_id: testId,
-    target,
-    message_index: index,
-    ...toTranscriptMessageFields(message),
-    transcript_token_usage: transcriptTokenUsage,
-    transcript_duration_ms: entry.durationMs,
-    transcript_cost_usd: entry.costUsd,
-    source
-  }));
-}
-function traceToTranscriptJsonLines(trace, options) {
-  const provider = (typeof trace.metadata?.provider === "string" ? trace.metadata.provider : void 0) ?? options?.target ?? "agentv";
-  const sessionId = (typeof trace.metadata?.provider_session_id === "string" ? trace.metadata.provider_session_id : void 0) ?? (typeof trace.metadata?.eval_case_id === "string" ? trace.metadata.eval_case_id : void 0) ?? options?.testId ?? "trace";
-  return toTranscriptJsonLines(
-    {
-      messages: [...trace.messages],
-      source: {
-        provider,
-        sessionId,
-        startedAt: trace.startTime
-      },
-      tokenUsage: trace.tokenUsage,
-      durationMs: trace.durationMs,
-      costUsd: trace.costUsd
-    },
-    options
-  );
-}
-function traceFromTranscriptJsonLines(lines) {
-  const [entry] = groupTranscriptJsonLines(lines);
-  if (!entry) {
-    return buildTraceFromMessages();
-  }
-  return buildTraceFromMessages({
-    output: entry.messages,
-    tokenUsage: entry.tokenUsage,
-    durationMs: entry.durationMs,
-    costUsd: entry.costUsd ?? void 0,
-    startTime: entry.source.startedAt,
-    provider: entry.source.provider,
-    target: entry.target,
-    testId: entry.testId,
-    conversationId: entry.source.sessionId
-  });
-}
-function fromTranscriptTokenUsage(usage) {
-  if (!usage) {
-    return void 0;
-  }
-  return {
-    input: usage.input,
-    output: usage.output,
-    cached: usage.cached,
-    reasoning: usage.reasoning
-  };
-}
-function readOptionalString(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) {
-  return {
-    role: line.role,
-    name: line.name,
-    content: line.content,
-    toolCalls: line.tool_calls?.map(fromTranscriptToolCall).filter((toolCall) => toolCall !== void 0),
-    startTime: line.start_time,
-    endTime: line.end_time,
-    durationMs: line.duration_ms,
-    metadata: line.metadata,
-    tokenUsage: fromTranscriptTokenUsage(line.token_usage)
-  };
-}
-function groupTranscriptJsonLines(lines) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const line of lines) {
-    const existing = grouped.get(line.test_id);
-    const source = {
-      provider: line.source.provider,
-      sessionId: line.source.session_id,
-      startedAt: line.source.timestamp,
-      model: line.source.model,
-      gitBranch: line.source.git_branch,
-      cwd: line.source.cwd,
-      version: line.source.version
-    };
-    const transcriptTokenUsage = line.transcript_token_usage ? {
-      input: line.transcript_token_usage.input,
-      output: line.transcript_token_usage.output,
-      cached: line.transcript_token_usage.cached,
-      reasoning: line.transcript_token_usage.reasoning
-    } : void 0;
-    if (existing) {
-      existing.messages.push({ index: line.message_index, message: buildReplayMessage(line) });
-      continue;
-    }
-    grouped.set(line.test_id, {
-      target: line.target,
-      tokenUsage: transcriptTokenUsage,
-      durationMs: line.transcript_duration_ms,
-      costUsd: line.transcript_cost_usd,
-      source,
-      messages: [{ index: line.message_index, message: buildReplayMessage(line) }]
-    });
-  }
-  return [...grouped.entries()].map(([testId, entry]) => ({
-    testId,
-    target: entry.target,
-    tokenUsage: entry.tokenUsage,
-    durationMs: entry.durationMs,
-    costUsd: entry.costUsd,
-    source: entry.source,
-    messages: entry.messages.sort((first, second) => first.index - second.index).map((item) => item.message)
-  }));
-}
-async function readTranscriptJsonl(filePath) {
-  const text = await readFile2(filePath, "utf8");
-  return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
-}
-async function readTranscriptFile(filePath) {
-  return readFile2(filePath, "utf8");
-}
 var TranscriptProvider = class _TranscriptProvider {
   id;
   kind = "transcript";
@@ -3061,7 +3220,6 @@ export {
   trimBaselineResult,
   DEFAULT_CATEGORY,
   deriveCategory,
-  OTEL_BACKEND_PRESETS,
   OtelTraceExporter,
   OtelStreamingObserver,
   RunBudgetTracker,
@@ -3071,13 +3229,7 @@ export {
   parseCodexSession,
   discoverCodexSessions,
   discoverClaudeSessions,
-  toTranscriptJsonLines,
-  traceToTranscriptJsonLines,
-  traceFromTranscriptJsonLines,
-  groupTranscriptJsonLines,
-  readTranscriptJsonl,
-  readTranscriptFile,
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-NLTIK3LV.js.map
+//# sourceMappingURL=chunk-I3SC4FOT.js.map