@agentv/core 4.32.0-next.1 → 4.34.0-next.1

package/dist/index.js

@@ -15,9 +15,27 @@ import {
   GraderRegistry,
   LatencyGrader,
   LlmGrader,
+  NORMALIZED_REDACTION_LEVELS,
+  NORMALIZED_TOOL_STATUSES,
+  NORMALIZED_TRACE_EVENT_TYPES,
+  NORMALIZED_TRACE_SOURCE_KINDS,
+  NORMALIZED_TRAJECTORY_SCHEMA_VERSION,
+  NormalizedRawEvidenceWireSchema,
+  NormalizedRedactionStateWireSchema,
+  NormalizedTraceBranchWireSchema,
+  NormalizedTraceErrorWireSchema,
+  NormalizedTraceEventWireSchema,
+  NormalizedTraceMessageWireSchema,
+  NormalizedTraceModelWireSchema,
+  NormalizedTraceSessionWireSchema,
+  NormalizedTraceSourceRefWireSchema,
+  NormalizedTraceSourceWireSchema,
+  NormalizedTraceToolWireSchema,
+  NormalizedTrajectoryWireSchema,
   PASS_THRESHOLD,
   ProviderRegistry,
   RepoManager,
+  ResponseCache,
   SkillTriggerGrader,
   TemplateNotDirectoryError,
   TemplateNotFoundError,
@@ -37,6 +55,7 @@ import {
   cleanupEvalWorkspaces,
   cleanupWorkspace,
   computeTraceSummary,
+  computeTraceSummaryFromTrajectory,
   computeWorkspaceFingerprint,
   consumeClaudeLogEntries,
   consumeCodexLogEntries,
@@ -71,14 +90,9 @@ import {
   extractWorkersFromSuite,
   formatToolCalls,
   freeformEvaluationSchema,
-  getAgentvConfigDir,
-  getAgentvDataDir,
-  getAgentvHome,
-  getSubagentsRoot,
-  getTraceStateRoot,
+  fromNormalizedTrajectoryWire,
+  getSelectedTrajectoryEvents,
   getWorkspacePath,
-  getWorkspacePoolRoot,
-  getWorkspacesRoot,
   initializeBaseline,
   isAgentSkillsFormat,
   isNonEmptyString,
@@ -105,6 +119,7 @@ import {
   readTargetDefinitions,
   readTestSuiteMetadata,
   resolveAndCreateProvider,
+  resolveResultsConfigForProject,
   resolveWorkspaceTemplate,
   rubricEvaluationSchema,
   runContainsAllAssertion,
@@ -122,6 +137,8 @@ import {
   runStartsWithAssertion,
   scoreRangeEvaluationSchema,
   scoreToVerdict,
+  shouldEnableCache,
+  shouldSkipCacheForTemperature,
   subscribeToClaudeLogEntries,
   subscribeToCodexLogEntries,
   subscribeToCopilotCliLogEntries,
@@ -129,20 +146,29 @@ import {
   subscribeToPiLogEntries,
   substituteVariables,
   toCamelCaseDeep,
+  toNormalizedTrajectoryWire,
   toSnakeCaseDeep,
   tokensPerTool,
   trackChild,
   trackedChildCount
-} from "./chunk-N5EU446L.js";
+} from "./chunk-7QB53OPK.js";
 import {
   COMMON_TARGET_SETTINGS,
+  RUBRIC_OPERATOR_VALUES,
   TEST_MESSAGE_ROLES,
   buildDirectoryChain,
   buildSearchRoots,
   extractLastAssistantContent,
   fileExists,
   findGitRoot,
+  getAgentvConfigDir,
+  getAgentvDataDir,
+  getAgentvHome,
+  getSubagentsRoot,
   getTextContent,
+  getTraceStateRoot,
+  getWorkspacePoolRoot,
+  getWorkspacesRoot,
   interpolateEnv,
   isContent,
   isContentArray,
@@ -158,7 +184,7 @@ import {
   resolveDelegatedTargetDefinition,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-5RQMJZDJ.js";
+} from "./chunk-EW5X2RGJ.js";
 import "./chunk-3WGHC7LC.js";
 import "./chunk-YDFZ7XN3.js";
 import {
@@ -444,16 +470,14 @@ var AgentVConfigSchema = z.object({
   }).optional(),
   /** Output settings */
   output: z.object({
-    /** Output format */
-    format: z.enum(["jsonl", "yaml", "json", "xml"]).optional(),
-    /** Output directory */
+    /** Default eval run artifact directory */
     dir: z.string().optional()
-  }).optional(),
+  }).strict().optional(),
   /** Response caching */
   cache: z.object({
     /** Enable response caching */
     enabled: z.boolean().optional(),
-    /** Cache file path */
+    /** Response cache directory */
     path: z.string().optional()
   }).optional(),
   /** Cost and duration limits */
@@ -679,47 +703,6 @@ function extractReposFromObject(obj) {
   return result;
 }
 
-// src/evaluation/cache/response-cache.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import path3 from "node:path";
-var DEFAULT_CACHE_PATH = ".agentv/cache";
-var ResponseCache = class {
-  cachePath;
-  constructor(cachePath) {
-    this.cachePath = cachePath ?? DEFAULT_CACHE_PATH;
-  }
-  async get(key) {
-    const filePath = this.keyToPath(key);
-    try {
-      const data = await readFile2(filePath, "utf8");
-      return JSON.parse(data);
-    } catch {
-      return void 0;
-    }
-  }
-  async set(key, value) {
-    const filePath = this.keyToPath(key);
-    const dir = path3.dirname(filePath);
-    await mkdir(dir, { recursive: true });
-    await writeFile(filePath, JSON.stringify(value, null, 2), "utf8");
-  }
-  keyToPath(key) {
-    const prefix = key.slice(0, 2);
-    return path3.join(this.cachePath, prefix, `${key}.json`);
-  }
-};
-function shouldEnableCache(params) {
-  if (params.cliNoCache) return false;
-  return params.cliCache || params.yamlCache === true;
-}
-function shouldSkipCacheForTemperature(targetConfig) {
-  const temp = targetConfig.temperature;
-  if (typeof temp === "number" && temp > 0) {
-    return true;
-  }
-  return false;
-}
-
 // src/evaluation/results-repo.ts
 import { execFile, spawn } from "node:child_process";
 import {
@@ -733,11 +716,12 @@ import {
 } from "node:fs";
 import { cp, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import os from "node:os";
-import path4 from "node:path";
+import path3 from "node:path";
 import { promisify } from "node:util";
 var execFileAsync = promisify(execFile);
 var RESULTS_REPO_RESULTS_DIR = ".agentv/results";
 var RESULTS_REPO_RUNS_DIR = `${RESULTS_REPO_RESULTS_DIR}/runs`;
+var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
 }
@@ -751,13 +735,13 @@ function withFriendlyGitHubAuthError(error) {
 }
 function expandHome(p) {
   if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-    return path4.join(os.homedir(), p.slice(1));
+    return path3.join(os.homedir(), p.slice(1));
   }
   return p;
 }
 function normalizeResultsConfig(config) {
   const repo = config.repo.trim();
-  const resolvedPath = config.path ? expandHome(config.path.trim()) : path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
+  const resolvedPath = config.path ? expandHome(config.path.trim()) : path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -773,11 +757,11 @@ function resolveResultsRepoUrl(repo) {
   return `https://github.com/${repo}.git`;
 }
 function getResultsRepoLocalPaths(repo) {
-  const rootDir = path4.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  const rootDir = path3.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
-    repoDir: path4.join(rootDir, "repo"),
-    statusFile: path4.join(rootDir, "status.json")
+    repoDir: path3.join(rootDir, "repo"),
+    statusFile: path3.join(rootDir, "status.json")
   };
 }
 function readPersistedStatus(statusFile) {
@@ -791,7 +775,7 @@ function readPersistedStatus(statusFile) {
   }
 }
 function writePersistedStatus(statusFile, status) {
-  mkdirSync(path4.dirname(statusFile), { recursive: true });
+  mkdirSync(path3.dirname(statusFile), { recursive: true });
   writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
 `, "utf8");
 }
@@ -850,6 +834,14 @@ async function resolveDefaultBranch(repoDir) {
 async function fetchResultsRepo(repoDir) {
   await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
 }
+async function isGitRepository(repoDir) {
+  try {
+    const { stdout } = await runGit(["rev-parse", "--is-inside-work-tree"], { cwd: repoDir });
+    return stdout.trim() === "true";
+  } catch {
+    return false;
+  }
+}
 function updateStatusFile(config, patch) {
   const cachePaths = getResultsRepoLocalPaths(config.repo);
   const current = readPersistedStatus(cachePaths.statusFile);
@@ -863,9 +855,9 @@ async function ensureResultsRepoClone(config) {
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
   mkdirSync(cachePaths.rootDir, { recursive: true });
-  mkdirSync(path4.dirname(cloneDir), { recursive: true });
+  mkdirSync(path3.dirname(cloneDir), { recursive: true });
   const cloneMissing = !existsSync(cloneDir);
-  const gitDir = path4.join(cloneDir, ".git");
+  const gitDir = path3.join(cloneDir, ".git");
   const cloneEmpty = !cloneMissing && !existsSync(gitDir) && (await readdir(cloneDir)).length === 0;
   if (cloneMissing || cloneEmpty) {
     try {
@@ -892,7 +884,8 @@ function getResultsRepoStatus(config) {
       configured: false,
       available: false,
       repo: "",
-      local_dir: ""
+      local_dir: "",
+      sync_status: "unavailable"
     };
   }
   const normalized = normalizeResultsConfig(config);
@@ -907,9 +900,246 @@ function getResultsRepoStatus(config) {
     branch_prefix: normalized.branch_prefix,
     local_dir: normalized.path,
     last_synced_at: persisted.last_synced_at,
-    last_error: persisted.last_error
+    last_error: persisted.last_error,
+    sync_status: existsSync(normalized.path) ? "clean" : "unavailable"
   };
 }
+function parseGitPorcelainPaths(status) {
+  const dirtyPaths = /* @__PURE__ */ new Set();
+  const conflictedPaths = /* @__PURE__ */ new Set();
+  const conflictCodes = /* @__PURE__ */ new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
+  for (const line of status.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const code = line.slice(0, 2);
+    const rawPath = line.slice(3).trim();
+    const paths = rawPath.includes(" -> ") ? rawPath.split(" -> ") : [rawPath];
+    for (const p of paths.map((entry) => entry.trim()).filter(Boolean)) {
+      dirtyPaths.add(p);
+      if (conflictCodes.has(code)) {
+        conflictedPaths.add(p);
+      }
+    }
+  }
+  return {
+    dirtyPaths: [...dirtyPaths].sort(),
+    conflictedPaths: [...conflictedPaths].sort()
+  };
+}
+async function getCurrentBranch(repoDir) {
+  const { stdout } = await runGit(["branch", "--show-current"], { cwd: repoDir, check: false });
+  const branch = stdout.trim();
+  if (branch) {
+    return branch;
+  }
+  const { stdout: sha } = await runGit(["rev-parse", "--short", "HEAD"], {
+    cwd: repoDir,
+    check: false
+  });
+  return sha.trim() ? `HEAD@${sha.trim()}` : void 0;
+}
+async function resolveComparisonRef(repoDir) {
+  const { stdout: upstream } = await runGit(
+    ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+    { cwd: repoDir, check: false }
+  );
+  const upstreamRef = upstream.trim();
+  if (upstreamRef && !upstreamRef.includes("fatal:")) {
+    return upstreamRef;
+  }
+  const baseBranch = await resolveDefaultBranch(repoDir);
+  const fallback = `origin/${baseBranch}`;
+  const { stdout: fallbackSha } = await runGit(["rev-parse", "--verify", fallback], {
+    cwd: repoDir,
+    check: false
+  });
+  return fallbackSha.trim() ? fallback : void 0;
+}
+async function getAheadBehind(repoDir, upstream) {
+  if (!upstream) {
+    return {};
+  }
+  const { stdout } = await runGit(["rev-list", "--left-right", "--count", `HEAD...${upstream}`], {
+    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 hasInProgressGitConflict(repoDir) {
+  const markers = ["MERGE_HEAD", "CHERRY_PICK_HEAD", "REVERT_HEAD", "REBASE_HEAD"];
+  for (const marker of markers) {
+    const { stdout } = await runGit(["rev-parse", "--git-path", marker], {
+      cwd: repoDir,
+      check: false
+    });
+    const markerPath = stdout.trim();
+    const resolvedMarkerPath = path3.isAbsolute(markerPath) ? markerPath : path3.join(repoDir, markerPath);
+    if (markerPath && existsSync(resolvedMarkerPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function buildGitDiffSummary(repoDir, upstream) {
+  const summaries = [];
+  for (const args of [
+    ["diff", "--stat"],
+    ["diff", "--cached", "--stat"],
+    ...upstream ? [["diff", "--stat", `${upstream}..HEAD`]] : []
+  ]) {
+    const { stdout } = await runGit(args, { cwd: repoDir, check: false });
+    const summary = stdout.trim();
+    if (summary) {
+      summaries.push(summary);
+    }
+  }
+  return summaries.length > 0 ? summaries.join("\n") : void 0;
+}
+async function inspectResultsRepoGit(repoDir) {
+  const branch = await getCurrentBranch(repoDir);
+  const upstream = await resolveComparisonRef(repoDir);
+  const { stdout: porcelain } = await runGit(
+    ["status", "--porcelain=v1", "--untracked-files=all"],
+    {
+      cwd: repoDir,
+      check: false
+    }
+  );
+  const { stdout: shortStatus } = await runGit(["status", "--short", "--branch"], {
+    cwd: repoDir,
+    check: false
+  });
+  const { dirtyPaths: allDirtyPaths, conflictedPaths } = parseGitPorcelainPaths(porcelain);
+  const dirtyPaths = allDirtyPaths.filter(isSafeResultsRepoPath);
+  const { ahead = 0, behind = 0 } = await getAheadBehind(repoDir, upstream);
+  const inProgressConflict = await hasInProgressGitConflict(repoDir);
+  let syncStatus = "clean";
+  if (conflictedPaths.length > 0 || inProgressConflict) {
+    syncStatus = "conflicted";
+  } else if (dirtyPaths.length > 0) {
+    syncStatus = "dirty";
+  } else if (ahead > 0 && behind > 0) {
+    syncStatus = "diverged";
+  } else if (behind > 0) {
+    syncStatus = "behind";
+  } else if (ahead > 0) {
+    syncStatus = "ahead";
+  }
+  return {
+    syncStatus,
+    branch,
+    upstream,
+    ahead,
+    behind,
+    dirtyPaths,
+    conflictedPaths,
+    gitStatus: shortStatus.trim() || void 0,
+    gitDiffSummary: await buildGitDiffSummary(repoDir, upstream)
+  };
+}
+function withGitInspection(status, inspection) {
+  return {
+    ...status,
+    sync_status: inspection.syncStatus,
+    branch: inspection.branch,
+    upstream: inspection.upstream,
+    ahead: inspection.ahead,
+    behind: inspection.behind,
+    dirty_paths: inspection.dirtyPaths,
+    conflicted_paths: inspection.conflictedPaths,
+    git_status: inspection.gitStatus,
+    git_diff_summary: inspection.gitDiffSummary,
+    last_error: lastErrorForGitInspection(status, inspection)
+  };
+}
+function lastErrorForGitInspection(status, inspection) {
+  if (inspection.syncStatus === "conflicted") {
+    return "Results repo has unresolved git conflicts";
+  }
+  if (inspection.syncStatus === "diverged") {
+    return "Results repo local and remote histories have diverged";
+  }
+  if (inspection.syncStatus === "dirty") {
+    if (status.auto_push === false) {
+      return "Results repo has uncommitted changes and auto_push is disabled";
+    }
+  }
+  return void 0;
+}
+function withBlockedStatus(status, blockReason, flags) {
+  return {
+    ...status,
+    blocked: true,
+    block_reason: blockReason,
+    ...flags?.pullPerformed !== void 0 && { pull_performed: flags.pullPerformed },
+    ...flags?.pushPerformed !== void 0 && { push_performed: flags.pushPerformed },
+    ...flags?.commitCreated !== void 0 && { commit_created: flags.commitCreated }
+  };
+}
+function withActionFlags(status, flags) {
+  return {
+    ...status,
+    blocked: false,
+    pull_performed: flags.pullPerformed,
+    push_performed: flags.pushPerformed,
+    commit_created: flags.commitCreated
+  };
+}
+function isSafeResultsRepoPath(p) {
+  return p === RESULTS_REPO_RESULTS_DIR || p.startsWith(`${RESULTS_REPO_RESULTS_DIR}/`);
+}
+function areSafeResultsRepoPaths(paths) {
+  return paths.length > 0 && paths.every(isSafeResultsRepoPath);
+}
+async function getAheadPaths(repoDir, upstream) {
+  if (!upstream) {
+    return [];
+  }
+  const { stdout } = await runGit(["diff", "--name-only", `${upstream}..HEAD`], {
+    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;
+}
+async function statusFromInspection(normalized, repoDir) {
+  return withGitInspection(getResultsRepoStatus(normalized), await inspectResultsRepoGit(repoDir));
+}
+async function getResultsRepoSyncStatus(config) {
+  const baseStatus = getResultsRepoStatus(config);
+  if (!config) {
+    return baseStatus;
+  }
+  const normalized = normalizeResultsConfig(config);
+  if (activeResultsRepoSyncs.has(normalized.path)) {
+    return {
+      ...baseStatus,
+      sync_status: "syncing"
+    };
+  }
+  if (!existsSync(normalized.path) || !await isGitRepository(normalized.path)) {
+    return {
+      ...baseStatus,
+      sync_status: "unavailable"
+    };
+  }
+  try {
+    return withGitInspection(baseStatus, await inspectResultsRepoGit(normalized.path));
+  } catch (error) {
+    return {
+      ...baseStatus,
+      sync_status: "unavailable",
+      last_error: getStatusMessage(error)
+    };
+  }
+}
 async function syncResultsRepo(config) {
   const normalized = normalizeResultsConfig(config);
   try {
@@ -927,6 +1157,198 @@ async function syncResultsRepo(config) {
   }
   return getResultsRepoStatus(normalized);
 }
+function getStatusMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function syncResultsRepoForProject(config) {
+  const normalized = normalizeResultsConfig(config);
+  const syncKey = normalized.path;
+  if (activeResultsRepoSyncs.has(syncKey)) {
+    return {
+      ...await getResultsRepoSyncStatus(normalized),
+      sync_status: "syncing",
+      blocked: true,
+      block_reason: "Results repo sync is already in progress"
+    };
+  }
+  activeResultsRepoSyncs.add(syncKey);
+  let pullPerformed = false;
+  let pushPerformed = false;
+  let commitCreated = false;
+  try {
+    const repoDir = await ensureResultsRepoClone(normalized);
+    await fetchResultsRepo(repoDir);
+    let inspection = await inspectResultsRepoGit(repoDir);
+    if (inspection.syncStatus === "conflicted") {
+      const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+      updateStatusFile(normalized, {
+        last_error: "Results repo has unresolved git conflicts"
+      });
+      return withBlockedStatus(status, "Results repo has unresolved git conflicts", {
+        pullPerformed,
+        pushPerformed,
+        commitCreated
+      });
+    }
+    if (inspection.syncStatus === "dirty") {
+      if (!normalized.auto_push) {
+        const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+        updateStatusFile(normalized, {
+          last_error: "Results repo has uncommitted changes and auto_push is disabled"
+        });
+        return withBlockedStatus(
+          status,
+          "Results repo has uncommitted changes and auto_push is disabled",
+          {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          }
+        );
+      }
+      if ((inspection.behind ?? 0) > 0) {
+        if (!inspection.upstream) {
+          const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+          updateStatusFile(normalized, {
+            last_error: "Results repo has no upstream branch to pull from"
+          });
+          return withBlockedStatus(status, "Results repo has no upstream branch to pull from", {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
+        try {
+          await runGit(["merge", "--ff-only", inspection.upstream], { cwd: repoDir });
+          pullPerformed = true;
+          inspection = await inspectResultsRepoGit(repoDir);
+        } catch (error) {
+          inspection = await inspectResultsRepoGit(repoDir);
+          const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+          const reason = `Results repo could not be fast-forwarded: ${getStatusMessage(error)}`;
+          updateStatusFile(normalized, { last_error: reason });
+          return withBlockedStatus(status, reason, {
+            pullPerformed,
+            pushPerformed,
+            commitCreated
+          });
+        }
+      }
+      if (inspection.syncStatus === "dirty") {
+        await runGit(["add", "--all", "--", RESULTS_REPO_RESULTS_DIR], { cwd: repoDir });
+        await runGit(
+          [
+            "commit",
+            "-m",
+            "chore(results): sync local result metadata",
+            "--",
+            RESULTS_REPO_RESULTS_DIR
+          ],
+          {
+            cwd: repoDir
+          }
+        );
+        commitCreated = true;
+        inspection = await inspectResultsRepoGit(repoDir);
+      }
+    }
+    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
+      });
+    }
+    if ((inspection.behind ?? 0) > 0 && (inspection.ahead ?? 0) === 0) {
+      if (!inspection.upstream) {
+        const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+        updateStatusFile(normalized, {
+          last_error: "Results repo has no upstream branch to pull from"
+        });
+        return withBlockedStatus(status, "Results repo has no upstream branch to pull from", {
+          pullPerformed,
+          pushPerformed,
+          commitCreated
+        });
+      }
+      try {
+        await runGit(["merge", "--ff-only", inspection.upstream], { cwd: repoDir });
+        pullPerformed = true;
+        inspection = await inspectResultsRepoGit(repoDir);
+      } catch (error) {
+        inspection = await inspectResultsRepoGit(repoDir);
+        const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+        const reason = `Results repo could not be fast-forwarded: ${getStatusMessage(error)}`;
+        updateStatusFile(normalized, { last_error: reason });
+        return withBlockedStatus(status, reason, {
+          pullPerformed,
+          pushPerformed,
+          commitCreated
+        });
+      }
+    }
+    if ((inspection.ahead ?? 0) > 0) {
+      if (!normalized.auto_push) {
+        const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+        return withActionFlags(status, {
+          pullPerformed,
+          pushPerformed,
+          commitCreated
+        });
+      }
+      const aheadPaths = await getAheadPaths(repoDir, inspection.upstream);
+      if (!inspection.upstream || !areSafeResultsRepoPaths(aheadPaths)) {
+        const status = withGitInspection(getResultsRepoStatus(normalized), inspection);
+        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 = 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);
+      } catch (error) {
+        await fetchResultsRepo(repoDir).catch(() => void 0);
+        inspection = await inspectResultsRepoGit(repoDir);
+        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, {
+      last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+      last_error: void 0
+    });
+    return withActionFlags(await statusFromInspection(normalized, repoDir), {
+      pullPerformed,
+      pushPerformed,
+      commitCreated
+    });
+  } catch (error) {
+    updateStatusFile(normalized, {
+      last_error: withFriendlyGitHubAuthError(error).message
+    });
+    throw withFriendlyGitHubAuthError(error);
+  } finally {
+    activeResultsRepoSyncs.delete(syncKey);
+  }
+}
 async function checkoutResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const repoDir = await ensureResultsRepoClone(normalized);
@@ -945,8 +1367,8 @@ async function prepareResultsRepoBranch(config, branchName) {
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
   await fetchResultsRepo(cloneDir);
-  const worktreeRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-repo-"));
-  const worktreeDir = path4.join(worktreeRoot, "repo");
+  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
   });
@@ -965,12 +1387,12 @@ async function prepareResultsRepoBranch(config, branchName) {
 }
 async function stageResultsArtifacts(params) {
   rmSync(params.destinationDir, { recursive: true, force: true });
-  mkdirSync(path4.dirname(params.destinationDir), { recursive: true });
+  mkdirSync(path3.dirname(params.destinationDir), { recursive: true });
   await cp(params.sourceDir, params.destinationDir, { recursive: true });
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return path4.join(normalized.path, RESULTS_REPO_RESULTS_DIR, "runs");
+  return path3.join(normalized.path, RESULTS_REPO_RESULTS_DIR, "runs");
 }
 async function directorySizeBytes(targetPath) {
   const entry = await stat(targetPath);
@@ -979,7 +1401,7 @@ async function directorySizeBytes(targetPath) {
   }
   let total = 0;
   for (const child of await readdir(targetPath, { withFileTypes: true })) {
-    total += await directorySizeBytes(path4.join(targetPath, child.name));
+    total += await directorySizeBytes(path3.join(targetPath, child.name));
   }
   return total;
 }
@@ -1028,12 +1450,40 @@ 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`], {
+    cwd: repoDir,
+    check: false
+  });
+  return Number.parseInt(stdout.trim(), 10) > 0;
+}
+async function pushDirectResultsToBase(params) {
+  for (let attempt = 1; attempt <= DIRECT_PUSH_MAX_RETRIES; attempt++) {
+    try {
+      await runGit(["push", "origin", `HEAD:${params.baseBranch}`], { cwd: params.repoDir });
+      updateStatusFile(params.normalized, {
+        last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+        last_error: 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", `origin/${params.baseBranch}`], { cwd: params.repoDir });
+      } else {
+        throw error;
+      }
+    }
+  }
+}
 async function directPushResults(params) {
   const normalized = normalizeResultsConfig(params.config);
   const repoDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(repoDir);
   await fetchResultsRepo(repoDir);
-  const destinationDir = path4.join(
+  const targetRunId = buildGitRunId(params.destinationPath);
+  const destinationDir = path3.join(
     repoDir,
     RESULTS_REPO_RESULTS_DIR,
     "runs",
@@ -1050,40 +1500,24 @@ async function directPushResults(params) {
     check: false
   });
   if (status.trim().length === 0) {
-    return false;
-  }
-  await runGit(
-    [
-      "commit",
-      "-m",
-      params.commitMessage,
-      "-m",
-      `Agentv-Run: ${buildGitRunId(params.destinationPath)}`
-    ],
-    { cwd: repoDir }
-  );
-  for (let attempt = 1; attempt <= DIRECT_PUSH_MAX_RETRIES; attempt++) {
-    try {
-      await runGit(["push", "origin", `HEAD:${baseBranch}`], { cwd: repoDir });
-      updateStatusFile(normalized, {
-        last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
-        last_error: void 0
-      });
-      return true;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (attempt < DIRECT_PUSH_MAX_RETRIES && message.includes("non-fast-forward")) {
-        await fetchResultsRepo(repoDir);
-        await runGit(["rebase", `origin/${baseBranch}`], { cwd: repoDir });
-      } else {
-        throw error;
+    if (await hasUnpushedCommits(repoDir, baseBranch)) {
+      const aheadPaths = await getAheadPaths(repoDir, `origin/${baseBranch}`);
+      if (!areSafeResultsRepoPaths(aheadPaths)) {
+        throw new Error("Results repo has non-results committed changes");
       }
+      await pushDirectResultsToBase({ normalized, repoDir, baseBranch });
+      return true;
     }
+    return false;
   }
-  return false;
+  await runGit(["commit", "-m", params.commitMessage, "-m", `Agentv-Run: ${targetRunId}`], {
+    cwd: repoDir
+  });
+  await pushDirectResultsToBase({ normalized, repoDir, baseBranch });
+  return true;
 }
 function buildGitRunId(relativeRunPath) {
-  const normalized = relativeRunPath.split(path4.sep).join("/");
+  const normalized = relativeRunPath.split(path3.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length >= 2) {
     const experiment = segments.slice(0, -1).join("/");
@@ -1207,10 +1641,11 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   const runs = blobs.flatMap((blob, index) => {
     const benchmarkPath = benchmarkPaths[index];
     const benchmark = JSON.parse(blob.content.toString("utf8"));
-    const runDir = path4.posix.dirname(benchmarkPath);
-    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    const runDir = path3.posix.dirname(benchmarkPath);
+    const relativeRunPath = path3.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     const runId = buildGitRunId(relativeRunPath);
-    const timestamp = benchmark.metadata?.timestamp?.trim() || path4.posix.basename(runDir);
+    const timestamp = benchmark.metadata?.timestamp?.trim() || path3.posix.basename(runDir);
+    const displayName = benchmark.metadata?.display_name?.trim() || path3.posix.basename(runDir);
     const targets = benchmark.metadata?.targets ?? [];
     const passRate = computeAveragePassRate(benchmark.run_summary);
     return [
@@ -1220,9 +1655,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
         timestamp,
         ...passRate !== void 0 && { pass_rate: passRate },
         ...targets.length === 1 && targets[0] ? { target: targets[0] } : {},
-        manifest_path: path4.posix.join(runDir, "index.jsonl"),
+        manifest_path: path3.posix.join(runDir, "index.jsonl"),
         benchmark_path: benchmarkPath,
-        display_name: path4.posix.basename(runDir),
+        display_name: displayName,
         test_count: benchmark.metadata?.tests_run?.length ?? 0,
         avg_score: 0,
         size_bytes: blob.size
@@ -1233,9 +1668,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   return runs;
 }
 async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
-  const normalizedRunPath = relativeRunPath.split(path4.sep).join("/");
-  const runTreePath = path4.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
-  const targetRunDir = path4.join(repoDir, ...runTreePath.split("/"));
+  const normalizedRunPath = relativeRunPath.split(path3.sep).join("/");
+  const runTreePath = path3.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
+  const targetRunDir = path3.join(repoDir, ...runTreePath.split("/"));
   const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, runTreePath], {
     cwd: repoDir
   });
@@ -1251,16 +1686,16 @@ async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main")
       `Expected ${filePaths.length} git blobs but received ${blobs.length} while materializing results run`
     );
   }
-  const tempRoot = mkdtempSync(path4.join(repoDir, ".agentv-run-"));
-  const tempRunDir = path4.join(tempRoot, "run");
+  const tempRoot = mkdtempSync(path3.join(repoDir, ".agentv-run-"));
+  const tempRunDir = path3.join(tempRoot, "run");
   try {
     for (const [index, filePath] of filePaths.entries()) {
-      const relativeFilePath = path4.posix.relative(runTreePath, filePath);
-      const absolutePath = path4.join(tempRunDir, ...relativeFilePath.split("/"));
-      mkdirSync(path4.dirname(absolutePath), { recursive: true });
+      const relativeFilePath = path3.posix.relative(runTreePath, filePath);
+      const absolutePath = path3.join(tempRunDir, ...relativeFilePath.split("/"));
+      mkdirSync(path3.dirname(absolutePath), { recursive: true });
       writeFileSync(absolutePath, blobs[index].content);
     }
-    mkdirSync(path4.dirname(targetRunDir), { recursive: true });
+    mkdirSync(path3.dirname(targetRunDir), { recursive: true });
     try {
       renameSync(tempRunDir, targetRunDir);
     } catch (error) {
@@ -1276,67 +1711,11 @@ async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main")
 }
 
 // src/projects.ts
-import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
-  readdirSync,
-  renameSync as renameSync2,
-  statSync,
-  unlinkSync,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import path5 from "node:path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path4 from "node:path";
 import { stringify as stringifyYaml } from "yaml";
 function getProjectsRegistryPath() {
-  return path5.join(getAgentvConfigDir(), "projects.yaml");
-}
-function getLegacyBenchmarksRegistryPath() {
-  return path5.join(getAgentvConfigDir(), "benchmarks.yaml");
-}
-function migrateLegacyBenchmarksFile() {
-  const newPath = getProjectsRegistryPath();
-  const oldPath = getLegacyBenchmarksRegistryPath();
-  const newExists = existsSync2(newPath);
-  const oldExists = existsSync2(oldPath);
-  if (!oldExists) return;
-  if (newExists) {
-    console.warn(
-      `[agentv] Both ${oldPath} and ${newPath} exist. Using ${path5.basename(newPath)}; delete ${path5.basename(oldPath)} when you've confirmed the new file is correct.`
-    );
-    return;
-  }
-  let parsed = null;
-  try {
-    const raw = readFileSync3(oldPath, "utf-8");
-    parsed = parseYamlValue(raw);
-  } catch (err) {
-    console.warn(
-      `[agentv] Failed to read legacy ${path5.basename(oldPath)} for migration: ${err.message}. Leaving the file in place; you may need to migrate it manually.`
-    );
-    return;
-  }
-  const entries = parsed && typeof parsed === "object" && Array.isArray(parsed.benchmarks) ? parsed.benchmarks : [];
-  const newContent = stringifyYaml({ projects: entries });
-  const tempPath = `${newPath}.migrating`;
-  try {
-    mkdirSync2(path5.dirname(newPath), { recursive: true });
-    writeFileSync2(tempPath, newContent, "utf-8");
-    renameSync2(tempPath, newPath);
-    unlinkSync(oldPath);
-  } catch (err) {
-    try {
-      if (existsSync2(tempPath)) unlinkSync(tempPath);
-    } catch {
-    }
-    console.warn(
-      `[agentv] Failed to migrate ${path5.basename(oldPath)} \u2192 ${path5.basename(newPath)}: ${err.message}. Legacy file left in place.`
-    );
-    return;
-  }
-  console.log(
-    `[agentv] Migrated registry: ${path5.basename(oldPath)} \u2192 ${path5.basename(newPath)} (${entries.length} entr${entries.length === 1 ? "y" : "ies"})`
-  );
+  return path4.join(getAgentvConfigDir(), "config.yaml");
 }
 function fromYaml(raw) {
   if (!raw || typeof raw !== "object") return null;
@@ -1357,6 +1736,18 @@ function fromYaml(raw) {
       entry.source = { url: s.url, ref: s.ref };
     }
   }
+  if (e.results && typeof e.results === "object") {
+    const r = e.results;
+    if (r.mode === "github" && typeof r.repo === "string" && r.repo.trim().length > 0) {
+      entry.results = {
+        mode: "github",
+        repo: r.repo.trim(),
+        ...typeof r.path === "string" && r.path.trim().length > 0 ? { path: r.path.trim() } : {},
+        ...typeof r.auto_push === "boolean" ? { autoPush: r.auto_push } : {},
+        ...typeof r.branch_prefix === "string" && r.branch_prefix.trim().length > 0 ? { branchPrefix: r.branch_prefix.trim() } : {}
+      };
+    }
+  }
   return entry;
 }
 function toYaml(entry) {
@@ -1370,10 +1761,20 @@ function toYaml(entry) {
   if (entry.source) {
     yaml.source = { url: entry.source.url, ref: entry.source.ref };
   }
+  if (entry.results) {
+    yaml.results = {
+      mode: entry.results.mode,
+      repo: entry.results.repo,
+      ...entry.results.path !== void 0 && { path: entry.results.path },
+      ...entry.results.autoPush !== void 0 && { auto_push: entry.results.autoPush },
+      ...entry.results.branchPrefix !== void 0 && {
+        branch_prefix: entry.results.branchPrefix
+      }
+    };
+  }
   return yaml;
 }
 function loadProjectRegistry() {
-  migrateLegacyBenchmarksFile();
   const registryPath = getProjectsRegistryPath();
   if (!existsSync2(registryPath)) {
     return { projects: [] };
@@ -1393,15 +1794,24 @@ function loadProjectRegistry() {
 }
 function saveProjectRegistry(registry) {
   const registryPath = getProjectsRegistryPath();
-  const dir = path5.dirname(registryPath);
+  const dir = path4.dirname(registryPath);
   if (!existsSync2(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
-  const payload = { projects: registry.projects.map(toYaml) };
+  const payload = { ...readHomeConfig(registryPath), projects: registry.projects.map(toYaml) };
   writeFileSync2(registryPath, stringifyYaml(payload), "utf-8");
 }
+function readHomeConfig(configPath) {
+  if (!existsSync2(configPath)) return {};
+  try {
+    const parsed = parseYamlValue(readFileSync3(configPath, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
 function deriveProjectId(dirPath, existingIds) {
-  const base = path5.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  const base = path4.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   let candidate = base || "project";
   let suffix = 2;
   while (existingIds.includes(candidate)) {
@@ -1411,11 +1821,11 @@ function deriveProjectId(dirPath, existingIds) {
   return candidate;
 }
 function addProject(projectPath) {
-  const absPath = path5.resolve(projectPath);
+  const absPath = path4.resolve(projectPath);
   if (!existsSync2(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!existsSync2(path5.join(absPath, ".agentv"))) {
+  if (!existsSync2(path4.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadProjectRegistry();
@@ -1429,7 +1839,7 @@ function addProject(projectPath) {
       absPath,
       registry.projects.map((p) => p.id)
     ),
-    name: path5.basename(absPath),
+    name: path4.basename(absPath),
     path: absPath,
     addedAt: now,
     lastOpenedAt: now
@@ -1449,6 +1859,14 @@ function removeProject(projectId) {
 function getProject(projectId) {
   return loadProjectRegistry().projects.find((p) => p.id === projectId);
 }
+function getProjectForPath(fsPath) {
+  const absPath = path4.resolve(fsPath);
+  return loadProjectRegistry().projects.filter((p) => {
+    const projectPath = path4.resolve(p.path);
+    const relative = path4.relative(projectPath, absPath);
+    return relative === "" || !relative.startsWith("..") && !path4.isAbsolute(relative);
+  }).sort((a, b) => path4.resolve(b.path).length - path4.resolve(a.path).length)[0];
+}
 function touchProject(projectId) {
   const registry = loadProjectRegistry();
   const entry = registry.projects.find((p) => p.id === projectId);
@@ -1458,14 +1876,14 @@ function touchProject(projectId) {
   }
 }
 function discoverProjects(rootDir, maxDepth = 2) {
-  const absRoot = path5.resolve(rootDir);
+  const absRoot = path4.resolve(rootDir);
   if (!existsSync2(absRoot) || !statSync(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if (existsSync2(path5.join(dir, ".agentv"))) {
+    if (existsSync2(path4.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
@@ -1475,7 +1893,7 @@ function discoverProjects(rootDir, maxDepth = 2) {
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        scan(path5.join(dir, entry.name), depth + 1);
+        scan(path4.join(dir, entry.name), depth + 1);
       }
     } catch {
     }
@@ -2504,8 +2922,8 @@ function extractResponseItemContent(content) {
 // src/import/codex-session-discovery.ts
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { homedir } from "node:os";
-import path6 from "node:path";
-var DEFAULT_SESSIONS_DIR = () => path6.join(homedir(), ".codex", "sessions");
+import path5 from "node:path";
+var DEFAULT_SESSIONS_DIR = () => path5.join(homedir(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -2517,7 +2935,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path6.join(sessionsDir, year);
+    const yearPath = path5.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir2(yearPath);
@@ -2525,7 +2943,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path6.join(yearPath, month);
+      const monthPath = path5.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir2(monthPath);
@@ -2537,7 +2955,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path6.join(monthPath, day);
+        const dayPath = path5.join(monthPath, day);
         let files;
         try {
           files = await readdir2(dayPath);
@@ -2546,7 +2964,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path6.join(dayPath, file);
+          const filePath = path5.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
@@ -2569,8 +2987,8 @@ async function discoverCodexSessions(opts) {
 // src/import/session-discovery.ts
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path7 from "node:path";
-var DEFAULT_PROJECTS_DIR = () => path7.join(homedir2(), ".claude", "projects");
+import path6 from "node:path";
+var DEFAULT_PROJECTS_DIR = () => path6.join(homedir2(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -2589,7 +3007,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path7.join(projectsDir, projectDir);
+    const dirPath = path6.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir3(dirPath);
@@ -2600,7 +3018,7 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path7.join(dirPath, entry);
+      const filePath = path6.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat3(filePath);
@@ -2621,7 +3039,7 @@ async function discoverClaudeSessions(opts) {
 }
 
 // src/import/types.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 function toTranscriptJsonLines(entry, options) {
   const source = {
     provider: entry.source.provider,
@@ -2708,11 +3126,11 @@ function groupTranscriptJsonLines(lines) {
   }));
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await readFile3(filePath, "utf8");
+  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 readFile3(filePath, "utf8");
+  return readFile2(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts
@@ -2785,12 +3203,30 @@ export {
   GraderRegistry,
   LatencyGrader,
   LlmGrader,
+  NORMALIZED_REDACTION_LEVELS,
+  NORMALIZED_TOOL_STATUSES,
+  NORMALIZED_TRACE_EVENT_TYPES,
+  NORMALIZED_TRACE_SOURCE_KINDS,
+  NORMALIZED_TRAJECTORY_SCHEMA_VERSION,
+  NormalizedRawEvidenceWireSchema,
+  NormalizedRedactionStateWireSchema,
+  NormalizedTraceBranchWireSchema,
+  NormalizedTraceErrorWireSchema,
+  NormalizedTraceEventWireSchema,
+  NormalizedTraceMessageWireSchema,
+  NormalizedTraceModelWireSchema,
+  NormalizedTraceSessionWireSchema,
+  NormalizedTraceSourceRefWireSchema,
+  NormalizedTraceSourceWireSchema,
+  NormalizedTraceToolWireSchema,
+  NormalizedTrajectoryWireSchema,
   OTEL_BACKEND_PRESETS,
   OtelStreamingObserver,
   OtelTraceExporter,
   OtlpJsonFileExporter,
   PASS_THRESHOLD,
   ProviderRegistry,
+  RUBRIC_OPERATOR_VALUES,
   RepoManager,
   ResponseCache,
   RunBudgetTracker,
@@ -2820,6 +3256,7 @@ export {
   cleanupWorkspace,
   commitAndPushResultsBranch,
   computeTraceSummary,
+  computeTraceSummaryFromTrajectory,
   computeWorkspaceFingerprint,
   consumeClaudeLogEntries,
   consumeCodexLogEntries,
@@ -2868,15 +3305,19 @@ export {
   findGitRoot,
   formatToolCalls,
   freeformEvaluationSchema,
+  fromNormalizedTrajectoryWire,
   generateRubrics,
   getAgentvConfigDir,
   getAgentvDataDir,
   getAgentvHome,
   getOutputFilenames,
   getProject,
+  getProjectForPath,
   getProjectsRegistryPath,
   getResultsRepoLocalPaths,
   getResultsRepoStatus,
+  getResultsRepoSyncStatus,
+  getSelectedTrajectoryEvents,
   getSubagentsRoot,
   getTextContent,
   getTraceStateRoot,
@@ -2932,6 +3373,7 @@ export {
   resolveAndCreateProvider,
   resolveDelegatedTargetDefinition,
   resolveFileReference,
+  resolveResultsConfigForProject,
   resolveResultsRepoRunsDir,
   resolveResultsRepoUrl,
   resolveTargetDefinition,
@@ -2967,7 +3409,9 @@ export {
   syncProject,
   syncProjects,
   syncResultsRepo,
+  syncResultsRepoForProject,
   toCamelCaseDeep,
+  toNormalizedTrajectoryWire,
   toSnakeCaseDeep,
   toTranscriptJsonLines,
   tokensPerTool,