agentv 4.38.1 → 4.40.1-next.1

package/dist/{chunk-6M5S4IJW.js → chunk-WKA5QDNQ.js}

@@ -1,22 +1,8 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
-  RESULT_INDEX_FILENAME,
-  RESULT_RUNS_DIRNAME,
-  aggregateRunDir,
-  buildDefaultRunDir,
-  buildTestTargetKey,
-  deduplicateByTestIdTarget,
-  isDirectoryPath,
-  normalizeExperimentName,
-  parseJsonlResults,
-  resolveExistingRunPrimaryPath,
-  resolveRunIndexPath,
-  resolveRunManifestPath,
-  resolveWorkspaceOrFilePath,
   toSnakeCaseDeep as toSnakeCaseDeep2,
-  writeArtifactsFromResults,
-  writeInitialBenchmarkArtifact
-} from "./chunk-DKUAETXE.js";
+  writeArtifactsFromResults
+} from "./chunk-TWQP7JYQ.js";
 import {
   RunBudgetTracker,
   buildWipBranchName,
@@ -32,9 +18,8 @@ import {
   pushWipCheckpoint,
   resolveResultsRepoRunsDir,
   setupWipWorktree,
-  syncResultsRepoForProject,
-  traceFromTranscriptJsonLines
-} from "./chunk-NLTIK3LV.js";
+  syncResultsRepoForProject
+} from "./chunk-I3SC4FOT.js";
 import {
   CLI_PLACEHOLDERS,
   COMMON_TARGET_SETTINGS,
@@ -43,9 +28,13 @@ import {
   KNOWN_PROVIDERS,
   PROVIDER_ALIASES,
   ResponseCache,
+  ResultRowSchemaError,
+  aggregateRunDir,
   buildDirectoryChain,
   buildSearchRoots,
+  buildTestTargetKey,
   buildTraceFromMessages,
+  deduplicateByTestIdTarget,
   ensureVSCodeSubagents,
   findDeprecatedCamelCaseTargetWarnings,
   findGitRoot,
@@ -59,6 +48,8 @@ import {
   loadCasesFromFile,
   loadConfig,
   loadTestSuite,
+  normalizeResultRow,
+  parseJsonlResults,
   parseYamlValue,
   readTargetDefinitions,
   readTestSuiteMetadata,
@@ -73,8 +64,10 @@ import {
   subscribeToCopilotSdkLogEntries,
   subscribeToPiLogEntries,
   toCamelCaseDeep,
-  toSnakeCaseDeep
-} from "./chunk-VBHHZQS6.js";
+  toSnakeCaseDeep,
+  traceFromTranscriptJsonLines,
+  writeInitialBenchmarkArtifact
+} from "./chunk-BLXYBUU4.js";
 
 // src/commands/eval/shared.ts
 import { constants } from "node:fs";
@@ -190,7 +183,7 @@ async function findRepoRoot(start) {
 // package.json
 var package_default = {
   name: "agentv",
-  version: "4.38.1",
+  version: "4.40.1-next.1",
   description: "CLI entry point for AgentV",
   type: "module",
   repository: {
@@ -298,10 +291,10 @@ async function discoverTargetsFile(options) {
 }
 
 // src/commands/eval/run-eval.ts
-import { constants as constants4, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "node:fs";
-import { access as access5, readFile as readFile8 } from "node:fs/promises";
-import path12 from "node:path";
-import { pathToFileURL } from "node:url";
+import { constants as constants4, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "node:fs";
+import { access as access6, readFile as readFile8 } from "node:fs/promises";
+import path14 from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/version-check.ts
 import { coerce, satisfies, validRange } from "semver";
@@ -355,19 +348,100 @@ function enforceRequiredVersion(requiredVersion, options) {
 }
 
 // src/commands/results/remote.ts
-import { existsSync as existsSync4 } from "node:fs";
-import path7 from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import path8 from "node:path";
 
 // src/commands/inspect/utils.ts
-import { readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
-import path4 from "node:path";
+import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "node:fs";
+import path5 from "node:path";
 
-// src/commands/results/manifest.ts
-import { existsSync, readFileSync } from "node:fs";
+// src/commands/eval/result-layout.ts
+import { existsSync, statSync } from "node:fs";
 import path3 from "node:path";
+var RESULT_INDEX_FILENAME = "index.jsonl";
+var RESULT_RUNS_DIRNAME = "runs";
+var DEFAULT_EXPERIMENT_NAME = "default";
+function normalizeExperimentName(experiment) {
+  const trimmed = experiment?.trim();
+  if (!trimmed) {
+    return DEFAULT_EXPERIMENT_NAME;
+  }
+  if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+    throw new Error(
+      `Invalid experiment name "${trimmed}". Use only letters, numbers, ".", "_" and "-".`
+    );
+  }
+  return trimmed;
+}
+function createRunDirName(timestamp = /* @__PURE__ */ new Date()) {
+  return timestamp.toISOString().replace(/[:.]/g, "-");
+}
+function buildDefaultRunDir(cwd, experiment, timestamp = /* @__PURE__ */ new Date()) {
+  return path3.join(
+    cwd,
+    ".agentv",
+    "results",
+    RESULT_RUNS_DIRNAME,
+    normalizeExperimentName(experiment),
+    createRunDirName(timestamp)
+  );
+}
+function resolveRunIndexPath(runDir) {
+  return path3.join(runDir, RESULT_INDEX_FILENAME);
+}
+function isRunManifestPath(filePath) {
+  return path3.basename(filePath) === RESULT_INDEX_FILENAME;
+}
+function resolveExistingRunPrimaryPath(runDir) {
+  const indexPath = resolveRunIndexPath(runDir);
+  if (existsSync(indexPath)) {
+    return indexPath;
+  }
+  return void 0;
+}
+function isDirectoryPath(filePath) {
+  try {
+    return statSync(filePath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function resolveWorkspaceOrFilePath(filePath) {
+  if (!isDirectoryPath(filePath)) {
+    return filePath;
+  }
+  const existing = resolveExistingRunPrimaryPath(filePath);
+  if (!existing) {
+    throw new Error(`Result workspace is missing ${RESULT_INDEX_FILENAME}: ${filePath}`);
+  }
+  return existing;
+}
+function resolveRunManifestPath(filePath) {
+  if (isDirectoryPath(filePath)) {
+    return resolveWorkspaceOrFilePath(filePath);
+  }
+  if (!isRunManifestPath(filePath)) {
+    throw new Error(
+      `Expected a run workspace directory or ${RESULT_INDEX_FILENAME} manifest: ${filePath}`
+    );
+  }
+  return filePath;
+}
+
+// src/commands/results/manifest.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import path4 from "node:path";
 function parseJsonlLines(content) {
   return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).map((line) => JSON.parse(line));
 }
+function parseResultRows(content, sourceLabel) {
+  return content.split(/\r?\n/).map((line, index) => ({ line: line.trim(), lineNumber: index + 1 })).filter(({ line }) => line.length > 0).map(
+    ({ line, lineNumber }) => normalizeResultRow(JSON.parse(line), {
+      lineNumber,
+      sourceLabel
+    })
+  );
+}
 function parseMarkdownMessages(content) {
   const trimmed = content.trim();
   if (!trimmed.startsWith("@[")) {
@@ -383,8 +457,8 @@ function readOptionalText(baseDir, relativePath) {
   if (!relativePath) {
     return void 0;
   }
-  const absolutePath = path3.join(baseDir, relativePath);
-  if (!existsSync(absolutePath)) {
+  const absolutePath = path4.join(baseDir, relativePath);
+  if (!existsSync2(absolutePath)) {
     return void 0;
   }
   return readFileSync(absolutePath, "utf8");
@@ -430,6 +504,7 @@ function hydrateTrace(baseDir, record) {
   return buildTraceFromMessages({
     input: hydrateInput(baseDir, record),
     output: output ? [{ role: "assistant", content: output }] : [],
+    summary: record.trace ? toCamelCaseDeep(record.trace) : void 0,
     finalOutput: output,
     target: record.target,
     testId: record.test_id
@@ -484,11 +559,11 @@ function hydrateManifestRecord(baseDir, record) {
   };
 }
 function parseResultManifest(content) {
-  return parseJsonlLines(content);
+  return parseResultRows(content);
 }
 function resolveResultSourcePath(source, cwd) {
-  const resolved = path3.isAbsolute(source) ? source : path3.resolve(cwd ?? process.cwd(), source);
-  if (isDirectoryPath(resolved) || path3.basename(resolved) === RESULT_INDEX_FILENAME) {
+  const resolved = path4.isAbsolute(source) ? source : path4.resolve(cwd ?? process.cwd(), source);
+  if (isDirectoryPath(resolved) || path4.basename(resolved) === RESULT_INDEX_FILENAME) {
     return resolveRunManifestPath(resolved);
   }
   return resolved;
@@ -496,8 +571,8 @@ function resolveResultSourcePath(source, cwd) {
 function loadManifestResults(sourceFile) {
   const resolvedSourceFile = resolveRunManifestPath(sourceFile);
   const content = readFileSync(resolvedSourceFile, "utf8");
-  const records = parseResultManifest(content);
-  const baseDir = path3.dirname(resolvedSourceFile);
+  const records = parseResultRows(content, resolvedSourceFile);
+  const baseDir = path4.dirname(resolvedSourceFile);
   return records.map((record) => hydrateManifestRecord(baseDir, record));
 }
 function loadLightweightResults(sourceFile) {
@@ -544,10 +619,10 @@ function padLeft(str, len) {
 }
 function loadResultFile(filePath) {
   const resolvedFilePath = resolveTraceResultPath(filePath);
-  if (path4.extname(resolvedFilePath) === ".json") {
+  if (path5.extname(resolvedFilePath) === ".json") {
     return loadOtlpTraceFile(resolvedFilePath);
   }
-  if (path4.basename(resolvedFilePath) === RESULT_INDEX_FILENAME) {
+  if (path5.basename(resolvedFilePath) === RESULT_INDEX_FILENAME) {
     return loadManifestAsRawResults(resolvedFilePath);
   }
   return loadJsonlRecords(resolvedFilePath);
@@ -555,15 +630,33 @@ function loadResultFile(filePath) {
 function resolveTraceResultPath(filePath) {
   return resolveWorkspaceOrFilePath(filePath);
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function shouldUseTraceScoreError(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return typeof value.test_id === "string" || typeof value.testId === "string" || Object.hasOwn(value, "score") || Object.hasOwn(value, "trace") || Object.hasOwn(value, "spans");
+}
 function loadJsonlRecords(filePath) {
   const content = readFileSync2(filePath, "utf8");
   const lines = content.trim().split("\n").filter((line) => line.trim());
   return lines.map((line, i) => {
-    const record = JSON.parse(line);
-    if (typeof record.score !== "number") {
-      throw new Error(`Missing or invalid score in result at line ${i + 1}: ${line.slice(0, 100)}`);
+    const parsed = JSON.parse(line);
+    try {
+      return normalizeResultRow(parsed, {
+        lineNumber: i + 1,
+        sourceLabel: filePath
+      });
+    } catch (error) {
+      if (error instanceof ResultRowSchemaError && shouldUseTraceScoreError(parsed)) {
+        throw new Error(
+          `Missing or invalid score in result at line ${i + 1}: ${line.slice(0, 100)}`
+        );
+      }
+      throw error;
     }
-    return record;
   });
 }
 function loadManifestAsRawResults(filePath) {
@@ -827,7 +920,7 @@ function toTraceSummary(result) {
   return toCamelCaseDeep(rawTrace);
 }
 function buildRunId(relativeRunPath) {
-  const normalized = relativeRunPath.split(path4.sep).join("/");
+  const normalized = relativeRunPath.split(path5.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length >= 2) {
     const experiment = segments.slice(0, -1).join("/");
@@ -841,7 +934,7 @@ function buildRunId(relativeRunPath) {
 }
 function readRunDisplayName(runDir) {
   try {
-    const benchmark = JSON.parse(readFileSync2(path4.join(runDir, "benchmark.json"), "utf8"));
+    const benchmark = JSON.parse(readFileSync2(path5.join(runDir, "benchmark.json"), "utf8"));
     const displayName = benchmark.metadata?.display_name;
     return typeof displayName === "string" && displayName.trim() ? displayName.trim() : void 0;
   } catch {
@@ -851,8 +944,8 @@ function readRunDisplayName(runDir) {
 function collectRunManifestPaths(runsDir, currentDir, files) {
   const primaryPath = resolveExistingRunPrimaryPath(currentDir);
   if (primaryPath) {
-    const relativeRunPath = path4.relative(runsDir, currentDir);
-    const sortName = path4.basename(currentDir);
+    const relativeRunPath = path5.relative(runsDir, currentDir);
+    const sortName = path5.basename(currentDir);
     files.push({
       filePath: primaryPath,
       displayName: readRunDisplayName(currentDir) ?? sortName,
@@ -864,7 +957,7 @@ function collectRunManifestPaths(runsDir, currentDir, files) {
   const entries = readdirSync(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isDirectory()) {
-      collectRunManifestPaths(runsDir, path4.join(currentDir, entry.name), files);
+      collectRunManifestPaths(runsDir, path5.join(currentDir, entry.name), files);
     }
   }
 }
@@ -874,7 +967,7 @@ function listResultFilesFromRunsDir(runsDir, limit) {
     const entries = readdirSync(runsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        collectRunManifestPaths(runsDir, path4.join(runsDir, entry.name), files);
+        collectRunManifestPaths(runsDir, path5.join(runsDir, entry.name), files);
       }
     }
   } catch {
@@ -884,7 +977,7 @@ function listResultFilesFromRunsDir(runsDir, limit) {
   const metas = [];
   for (const { filePath, displayName, runId } of limited) {
     try {
-      const fileStat = statSync(filePath);
+      const fileStat = statSync2(filePath);
       const results = loadResultFile(filePath);
       const testCount = results.length;
       const passCount = results.filter((r) => r.score >= DEFAULT_THRESHOLD).length;
@@ -909,7 +1002,7 @@ function listResultFilesFromRunsDir(runsDir, limit) {
 }
 function listResultFiles(cwd, limit) {
   return listResultFilesFromRunsDir(
-    path4.join(cwd, ".agentv", "results", RESULT_RUNS_DIRNAME),
+    path5.join(cwd, ".agentv", "results", RESULT_RUNS_DIRNAME),
     limit
   );
 }
@@ -945,21 +1038,21 @@ function formatScore(score) {
 
 // src/commands/results/remote-metadata.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path6 from "node:path";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import path7 from "node:path";
 
 // src/commands/results/run-tags.ts
-import { existsSync as existsSync2, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "node:fs";
-import path5 from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, unlinkSync, writeFileSync } from "node:fs";
+import path6 from "node:path";
 var RUN_TAGS_FILENAME = "tags.json";
 var MAX_TAGS_PER_RUN = 20;
 var MAX_TAG_LENGTH = 60;
 function runTagsPath(manifestPath) {
-  return path5.join(path5.dirname(manifestPath), RUN_TAGS_FILENAME);
+  return path6.join(path6.dirname(manifestPath), RUN_TAGS_FILENAME);
 }
 function readRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
-  if (!existsSync2(fp)) return void 0;
+  if (!existsSync3(fp)) return void 0;
   try {
     const parsed = JSON.parse(readFileSync3(fp, "utf8"));
     if (!parsed || typeof parsed !== "object") return void 0;
@@ -993,7 +1086,7 @@ function writeRunTags(manifestPath, tags) {
 }
 function deleteRunTags(manifestPath) {
   const fp = runTagsPath(manifestPath);
-  if (existsSync2(fp)) {
+  if (existsSync3(fp)) {
     unlinkSync(fp);
   }
 }
@@ -1026,8 +1119,8 @@ function normalizeTags(tags) {
 }
 
 // src/commands/results/remote-metadata.ts
-var RESULTS_RUNS_DIR = path6.join(".agentv", "results", "runs");
-var REMOTE_METADATA_RUNS_DIR = path6.join(".agentv", "results", "metadata", "runs");
+var RESULTS_RUNS_DIR = path7.join(".agentv", "results", "runs");
+var REMOTE_METADATA_RUNS_DIR = path7.join(".agentv", "results", "metadata", "runs");
 function cleanGitEnv() {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -1053,10 +1146,10 @@ function tryRunGit(repoDir, args) {
   }
 }
 function toGitPath(filePath) {
-  return filePath.split(path6.sep).join("/");
+  return filePath.split(path7.sep).join("/");
 }
 function readTagsFile(filePath) {
-  if (!existsSync3(filePath)) return void 0;
+  if (!existsSync4(filePath)) return void 0;
   try {
     return parseTagsFile(readFileSync4(filePath, "utf8"));
   } catch {
@@ -1099,27 +1192,27 @@ function resolveComparisonRef(repoDir) {
   return tryRunGit(repoDir, ["rev-parse", "--verify", "HEAD"]) ? "HEAD" : void 0;
 }
 function resolveRemoteRunMetadataPaths(repoDir, manifestPath) {
-  const runsRoot = path6.resolve(repoDir, RESULTS_RUNS_DIR);
-  const manifestDir = path6.resolve(path6.dirname(manifestPath));
-  const runRelativePath = path6.relative(runsRoot, manifestDir);
-  if (runRelativePath.length === 0 || runRelativePath.startsWith("..") || path6.isAbsolute(runRelativePath)) {
+  const runsRoot = path7.resolve(repoDir, RESULTS_RUNS_DIR);
+  const manifestDir = path7.resolve(path7.dirname(manifestPath));
+  const runRelativePath = path7.relative(runsRoot, manifestDir);
+  if (runRelativePath.length === 0 || runRelativePath.startsWith("..") || path7.isAbsolute(runRelativePath)) {
     throw new Error(
       `Remote run manifest is outside the results repo runs directory: ${manifestPath}`
     );
   }
-  const overlayTagsPath = path6.join(
+  const overlayTagsPath = path7.join(
     repoDir,
     REMOTE_METADATA_RUNS_DIR,
     runRelativePath,
     RUN_TAGS_FILENAME
   );
-  const artifactTagsPath = path6.join(runsRoot, runRelativePath, RUN_TAGS_FILENAME);
+  const artifactTagsPath = path7.join(runsRoot, runRelativePath, RUN_TAGS_FILENAME);
   return {
     runRelativePath,
     artifactTagsPath,
-    artifactTagsGitPath: toGitPath(path6.relative(repoDir, artifactTagsPath)),
+    artifactTagsGitPath: toGitPath(path7.relative(repoDir, artifactTagsPath)),
     overlayTagsPath,
-    overlayTagsGitPath: toGitPath(path6.relative(repoDir, overlayTagsPath))
+    overlayTagsGitPath: toGitPath(path7.relative(repoDir, overlayTagsPath))
   };
 }
 function readRemoteRunTagsContext(repoDir, manifestPath) {
@@ -1149,7 +1242,7 @@ function toRemoteRunTagState(context) {
   };
 }
 function assertWritableResultsRepo(repoDir) {
-  if (!existsSync3(repoDir)) {
+  if (!existsSync4(repoDir)) {
     throw new Error("Writable results repo is not configured for remote metadata");
   }
   const insideWorkTree = tryRunGit(repoDir, ["rev-parse", "--is-inside-work-tree"]);
@@ -1174,7 +1267,7 @@ function writeRemoteRunTags(repoDir, manifestPath, tags) {
     tags: cleaned,
     updated_at: (/* @__PURE__ */ new Date()).toISOString()
   };
-  mkdirSync(path6.dirname(context.paths.overlayTagsPath), { recursive: true });
+  mkdirSync(path7.dirname(context.paths.overlayTagsPath), { recursive: true });
   writeFileSync2(context.paths.overlayTagsPath, `${JSON.stringify(entry, null, 2)}
 `, "utf8");
   return readRemoteRunTags(repoDir, manifestPath);
@@ -1187,7 +1280,7 @@ function deleteRemoteRunTags(repoDir, manifestPath) {
 var gitRunsCache = /* @__PURE__ */ new Map();
 var GIT_RUNS_CACHE_TTL_MS = 6e4;
 function getResultsStorageRef(config) {
-  return config.branch ? `origin/${config.branch}` : void 0;
+  return config.branch;
 }
 function cachedListGitRuns(repoDir, ref) {
   const now = Date.now();
@@ -1220,13 +1313,13 @@ function getStatusMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function getRelativeRunPath(cwd, runDir) {
-  const relative = path7.relative(path7.join(cwd, ".agentv", "results", "runs"), runDir);
-  if (!relative.startsWith("..") && !path7.isAbsolute(relative)) {
+  const relative = path8.relative(path8.join(cwd, ".agentv", "results", "runs"), runDir);
+  if (!relative.startsWith("..") && !path8.isAbsolute(relative)) {
     return relative;
   }
-  const experiment = path7.basename(path7.dirname(runDir));
-  const runName = path7.basename(runDir);
-  return experiment && experiment !== runName ? path7.join(experiment, runName) : runName;
+  const experiment = path8.basename(path8.dirname(runDir));
+  const runName = path8.basename(runDir);
+  return experiment && experiment !== runName ? path8.join(experiment, runName) : runName;
 }
 function buildCommitTitle(payload) {
   const passed = payload.results.filter((result) => result.score >= DEFAULT_THRESHOLD).length;
@@ -1242,23 +1335,65 @@ async function maybeWarnLargeArtifact(runDir) {
     );
   }
 }
-async function loadNormalizedResultsConfig(cwd, projectId) {
+async function loadNormalizedResultsConfig(cwd, projectId, overrides) {
   const repoRoot = await findRepoRoot(cwd) ?? cwd;
-  const config = await loadConfig(path7.join(cwd, "_"), repoRoot);
+  const config = await loadConfig(path8.join(cwd, "_"), repoRoot);
   const project = projectId !== void 0 ? getProject(projectId) : getProjectForPath(repoRoot) ?? getProjectForPath(cwd);
   const projectResults = project?.results ? {
     mode: "github",
-    repo: project.results.repoUrl,
-    branch: project.results.branch,
-    path: project.results.path,
-    auto_push: project.results.sync?.autoPush,
-    branch_prefix: project.results.branchPrefix
+    ...project.results.repoUrl !== void 0 && {
+      repo: project.results.repoUrl,
+      repo_url: project.results.repoUrl
+    },
+    ...project.results.repoPath !== void 0 && { repo_path: project.results.repoPath },
+    ...project.results.branch !== void 0 && { branch: project.results.branch },
+    ...project.results.remote !== void 0 && { remote: project.results.remote },
+    ...project.results.path !== void 0 && { path: project.results.path },
+    ...(project.results.sync?.autoPush !== void 0 || project.results.sync?.requirePush !== void 0) && {
+      sync: {
+        ...project.results.sync?.autoPush !== void 0 && {
+          auto_push: project.results.sync.autoPush
+        },
+        ...project.results.sync?.requirePush !== void 0 && {
+          require_push: project.results.sync.requirePush
+        }
+      }
+    },
+    ...project.results.branchPrefix !== void 0 && {
+      branch_prefix: project.results.branchPrefix
+    }
   } : void 0;
   const resultsConfig = projectResults ?? resolveResultsConfigForProject(config, project?.id);
-  if (!resultsConfig) {
+  if (!resultsConfig && !overrides) {
     return void 0;
   }
-  return normalizeResultsConfig(resultsConfig);
+  const baseConfig = resultsConfig ? normalizeResultsConfig(resultsConfig, { baseDir: project?.path ?? repoRoot }) : void 0;
+  const repoOverride = overrides?.repo ?? overrides?.repo_url ?? overrides?.repo_path;
+  if (!baseConfig && !repoOverride) {
+    return void 0;
+  }
+  if (!overrides) {
+    return baseConfig;
+  }
+  const merged = {
+    mode: "github",
+    ...overrides.repo !== void 0 ? { repo: overrides.repo } : overrides.repo_url !== void 0 ? { repo_url: overrides.repo_url } : overrides.repo_path !== void 0 ? { repo_path: overrides.repo_path } : baseConfig?.repo_path ? { repo_path: baseConfig.repo_path } : baseConfig?.repo_url ? { repo_url: baseConfig.repo_url } : baseConfig?.repo ? { repo: baseConfig.repo } : {},
+    ...overrides.branch !== void 0 ? { branch: overrides.branch } : baseConfig?.branch ? { branch: baseConfig.branch } : {},
+    ...overrides.remote !== void 0 ? { remote: overrides.remote } : baseConfig?.remote ? { remote: baseConfig.remote } : {},
+    ...repoOverride === void 0 && baseConfig?.repo_path === void 0 && baseConfig?.path ? { path: baseConfig.path } : {},
+    ...(overrides.auto_push !== void 0 || overrides.require_push !== void 0 || baseConfig?.auto_push !== void 0 || baseConfig?.require_push !== void 0) && {
+      sync: {
+        ...(overrides.auto_push ?? baseConfig?.auto_push) !== void 0 && {
+          auto_push: overrides.auto_push ?? baseConfig?.auto_push
+        },
+        ...(overrides.require_push ?? baseConfig?.require_push) !== void 0 && {
+          require_push: overrides.require_push ?? baseConfig?.require_push
+        }
+      }
+    },
+    ...baseConfig?.branch_prefix ? { branch_prefix: baseConfig.branch_prefix } : {}
+  };
+  return normalizeResultsConfig(merged, { baseDir: project?.path ?? repoRoot });
 }
 function encodeRemoteRunId(filename) {
   return `${REMOTE_RUN_PREFIX}${filename}`;
@@ -1348,7 +1483,7 @@ async function listMergedResultFiles(cwd, limit, projectId) {
         filename: encodeRemoteRunId(r.run_id),
         raw_filename: r.run_id,
         source: "remote",
-        path: path7.join(config.path, r.manifest_path),
+        path: path8.join(config.path, r.manifest_path),
         displayName: r.display_name,
         timestamp: r.timestamp,
         testCount: r.test_count,
@@ -1394,20 +1529,20 @@ async function findRunById(cwd, runId, projectId) {
   return runs.find((run) => run.filename === runId);
 }
 async function ensureRemoteRunAvailable(cwd, meta, projectId) {
-  if (meta.source !== "remote" || existsSync4(meta.path)) {
+  if (meta.source !== "remote" || existsSync5(meta.path)) {
     return;
   }
   const config = await loadNormalizedResultsConfig(cwd, projectId);
   if (!config) {
     throw new Error("Remote results are not configured");
   }
-  const relativeManifestPath = path7.relative(config.path, meta.path).split(path7.sep).join("/");
+  const relativeManifestPath = path8.relative(config.path, meta.path).split(path8.sep).join("/");
   if (relativeManifestPath.length === 0 || relativeManifestPath === meta.path || relativeManifestPath.startsWith("../")) {
     throw new Error(`Remote manifest path is outside the results repo clone: ${meta.path}`);
   }
-  const relativeRunPath = path7.posix.relative(
+  const relativeRunPath = path8.posix.relative(
     ".agentv/results/runs",
-    path7.posix.dirname(relativeManifestPath)
+    path8.posix.dirname(relativeManifestPath)
   );
   await materializeGitRun(config.path, relativeRunPath, getResultsStorageRef(config));
 }
@@ -1444,8 +1579,12 @@ async function clearRemoteRunTags(cwd, meta, projectId) {
   return deleteRemoteRunTags(config.path, meta.path);
 }
 async function maybeAutoExportRunArtifacts(payload) {
-  const config = await loadNormalizedResultsConfig(payload.cwd);
-  if (!config?.auto_push) {
+  const config = await loadNormalizedResultsConfig(
+    payload.cwd,
+    void 0,
+    payload.results_overrides
+  );
+  if (!config) {
     return "disabled";
   }
   try {
@@ -1459,12 +1598,18 @@ async function maybeAutoExportRunArtifacts(payload) {
       commitMessage: commitTitle
     });
     if (!pushed) {
-      console.warn("Warning: results export produced no git changes. Skipping push.");
+      console.warn("Warning: results export produced no git changes.");
       return "already_published";
     }
-    console.log(`Results pushed to ${config.repo} (${config.path}/${relativeRunPath})`);
+    const pushLabel = config.auto_push || config.require_push ? "pushed" : "published locally";
+    console.log(
+      `Results ${pushLabel} to ${config.repo} (${config.branch ?? "default branch"}:${relativeRunPath})`
+    );
     return "published";
   } catch (error) {
+    if (config.require_push) {
+      throw error;
+    }
     console.warn(`Warning: skipping results export: ${getStatusMessage(error)}`);
     console.warn("Warning: Run 'gh auth login' if GitHub authentication is missing.");
     return "failed";
@@ -1474,13 +1619,13 @@ async function maybeAutoExportRunArtifacts(payload) {
 // src/commands/eval/env.ts
 import { constants as constants3 } from "node:fs";
 import { access as access3 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 import { config as loadDotenv } from "dotenv";
 function uniqueDirs(directories) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dir of directories) {
-    const absolute = path8.resolve(dir);
+    const absolute = path9.resolve(dir);
     if (seen.has(absolute)) {
       continue;
     }
@@ -1499,14 +1644,14 @@ async function fileExists2(filePath) {
 }
 function collectAncestorDirectories(start, boundary) {
   const directories = [];
-  const boundaryDir = path8.resolve(boundary);
-  let current = path8.resolve(start);
+  const boundaryDir = path9.resolve(boundary);
+  let current = path9.resolve(start);
   while (current !== void 0) {
     directories.push(current);
     if (current === boundaryDir) {
       break;
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) {
       break;
     }
@@ -1516,12 +1661,12 @@ function collectAncestorDirectories(start, boundary) {
 }
 async function loadEnvFromHierarchy(options) {
   const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path8.dirname(path8.resolve(testFilePath));
+  const testDir = path9.dirname(path9.resolve(testFilePath));
   const cwd = process.cwd();
   const searchDirs = uniqueDirs([...collectAncestorDirectories(testDir, repoRoot), repoRoot, cwd]);
   const envFiles = [];
   for (const dir of searchDirs) {
-    const candidate = path8.join(dir, ".env");
+    const candidate = path9.join(dir, ".env");
     if (await fileExists2(candidate)) {
       envFiles.push(candidate);
     }
@@ -1542,10 +1687,118 @@ async function loadEnvFromHierarchy(options) {
   return envFiles[0];
 }
 
+// src/commands/eval/otel-backends.ts
+import { access as access4 } from "node:fs/promises";
+import path10 from "node:path";
+import { pathToFileURL } from "node:url";
+var RESOLVER_EXTENSIONS = [".mjs", ".js"];
+var builtinOtelBackendResolvers = [
+  {
+    name: "langfuse",
+    resolve: ({ env }) => {
+      const baseUrl = trimTrailingSlash(env.LANGFUSE_HOST ?? "https://cloud.langfuse.com");
+      const publicKey = env.LANGFUSE_PUBLIC_KEY ?? "";
+      const secretKey = env.LANGFUSE_SECRET_KEY ?? "";
+      return {
+        endpoint: `${baseUrl}/api/public/otel/v1/traces`,
+        headers: {
+          Authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}`
+        }
+      };
+    }
+  },
+  {
+    name: "braintrust",
+    resolve: ({ 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 {
+        endpoint: "https://api.braintrust.dev/otel/v1/traces",
+        headers
+      };
+    }
+  },
+  {
+    name: "confident",
+    resolve: ({ env }) => ({
+      endpoint: "https://otel.confident-ai.com/v1/traces",
+      headers: {
+        "x-confident-api-key": env.CONFIDENT_API_KEY ?? ""
+      }
+    })
+  }
+];
+var builtinOtelBackendResolversByName = new Map(
+  builtinOtelBackendResolvers.map((resolver) => [resolver.name, resolver])
+);
+async function resolveOtelBackend(name, context) {
+  const resolver = await loadOtelBackendResolver(name, context.cwd);
+  return resolver?.resolve(context);
+}
+async function loadOtelBackendResolver(name, cwd) {
+  const localResolverPath = await findLocalOtelBackendResolver(name, cwd);
+  if (localResolverPath) {
+    return importOtelBackendResolver(localResolverPath, name);
+  }
+  return builtinOtelBackendResolversByName.get(name);
+}
+async function findLocalOtelBackendResolver(name, cwd) {
+  if (!isSafeResolverName(name)) {
+    return void 0;
+  }
+  for (const dir of getResolverSearchDirs(cwd)) {
+    for (const ext of RESOLVER_EXTENSIONS) {
+      const candidate = path10.join(dir, `${name}${ext}`);
+      try {
+        await access4(candidate);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function getResolverSearchDirs(cwd) {
+  const dirs = [];
+  let current = path10.resolve(cwd);
+  const root = path10.parse(current).root;
+  while (current !== root) {
+    dirs.push(path10.join(current, ".agentv", "otel-backends"));
+    current = path10.dirname(current);
+  }
+  return dirs;
+}
+function isSafeResolverName(name) {
+  return name.length > 0 && !name.includes("/") && !name.includes("\\") && !name.startsWith(".");
+}
+async function importOtelBackendResolver(filePath, fallbackName) {
+  const mod = await import(pathToFileURL(filePath).href);
+  const candidate = [mod.default, mod.otelBackend, mod.resolver].find(
+    (value) => value && typeof value.resolve === "function"
+  );
+  if (!candidate) {
+    throw new Error(
+      `OTel backend resolver '${fallbackName}' from ${filePath} must export a resolver object`
+    );
+  }
+  return {
+    ...candidate,
+    name: typeof candidate.name === "string" && candidate.name.length > 0 ? candidate.name : fallbackName
+  };
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+
 // src/commands/eval/jsonl-writer.ts
 import { createWriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
-import path9 from "node:path";
+import path11 from "node:path";
 import { finished } from "node:stream/promises";
 
 // ../../node_modules/.bun/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
@@ -1763,7 +2016,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath, options) {
-    await mkdir(path9.dirname(filePath), { recursive: true });
+    await mkdir(path11.dirname(filePath), { recursive: true });
     const flags = options?.append ? "a" : "w";
     const stream = createWriteStream(filePath, { flags, encoding: "utf8" });
     return new _JsonlWriter(stream);
@@ -1888,12 +2141,12 @@ var ProgressDisplay = class {
   }
   addLogPaths(paths) {
     const newPaths = [];
-    for (const path14 of paths) {
-      if (this.logPathSet.has(path14)) {
+    for (const path16 of paths) {
+      if (this.logPathSet.has(path16)) {
         continue;
       }
-      this.logPathSet.add(path14);
-      newPaths.push(path14);
+      this.logPathSet.add(path16);
+      newPaths.push(path16);
     }
     if (newPaths.length === 0) {
       return;
@@ -1946,9 +2199,9 @@ async function loadNonErrorResults(jsonlPath) {
 }
 
 // src/commands/eval/run-cache.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { mkdir as mkdir2, readFile, writeFile } from "node:fs/promises";
-import path10 from "node:path";
+import path12 from "node:path";
 var CACHE_FILENAME = "cache.json";
 function resolveRunCacheFile(cache) {
   if (cache.lastRunDir) {
@@ -1957,7 +2210,7 @@ function resolveRunCacheFile(cache) {
   return "";
 }
 function cachePath(cwd) {
-  return path10.join(cwd, ".agentv", CACHE_FILENAME);
+  return path12.join(cwd, ".agentv", CACHE_FILENAME);
 }
 async function loadRunCache(cwd) {
   try {
@@ -1970,17 +2223,17 @@ async function loadRunCache(cwd) {
 async function resolveCachedRunDir(cwd) {
   const cache = await loadRunCache(cwd);
   if (!cache?.lastRunDir) return void 0;
-  if (!existsSync5(cache.lastRunDir)) return void 0;
+  if (!existsSync6(cache.lastRunDir)) return void 0;
   return cache.lastRunDir;
 }
 async function saveRunCache(cwd, resultPath) {
-  if (path10.basename(resultPath) !== RESULT_INDEX_FILENAME) {
+  if (path12.basename(resultPath) !== RESULT_INDEX_FILENAME) {
     return;
   }
-  const dir = path10.join(cwd, ".agentv");
+  const dir = path12.join(cwd, ".agentv");
   await mkdir2(dir, { recursive: true });
   const cache = {
-    lastRunDir: path10.dirname(resultPath),
+    lastRunDir: path12.dirname(resultPath),
     timestamp: (/* @__PURE__ */ new Date()).toISOString()
   };
   await writeFile(cachePath(cwd), `${JSON.stringify(cache, null, 2)}
@@ -2249,7 +2502,7 @@ function formatMatrixSummary(results) {
 
 // ../../packages/core/dist/evaluation/validation/index.js
 import { readFile as readFile2 } from "node:fs/promises";
-import path11 from "node:path";
+import path13 from "node:path";
 import { readFile as readFile22, readdir, stat as stat2 } from "node:fs/promises";
 import path22 from "node:path";
 import { readFile as readFile3 } from "node:fs/promises";
@@ -2260,7 +2513,7 @@ import { readFile as readFile5 } from "node:fs/promises";
 import path52 from "node:path";
 import { readFile as readFile6 } from "node:fs/promises";
 import path62 from "node:path";
-import { access as access4, readFile as readFile7 } from "node:fs/promises";
+import { access as access5, readFile as readFile7 } from "node:fs/promises";
 import path72 from "node:path";
 var SCHEMA_EVAL_V2 = "agentv-eval-v2";
 var SCHEMA_TARGETS_V2 = "agentv-targets-v2.2";
@@ -2295,8 +2548,8 @@ async function detectFileType(filePath) {
   }
 }
 function inferFileTypeFromPath(filePath) {
-  const normalized = path11.normalize(filePath).replace(/\\/g, "/");
-  const basename = path11.basename(filePath);
+  const normalized = path13.normalize(filePath).replace(/\\/g, "/");
+  const basename = path13.basename(filePath);
   if (normalized.includes("/.agentv/")) {
     if (basename === "config.yaml" || basename === "config.yml") {
       return "config";
@@ -3258,6 +3511,8 @@ var COPILOT_SDK_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
   "cli_url",
   "cli_path",
+  "args",
+  "arguments",
   "github_token",
   "model",
   "cwd",
@@ -3266,8 +3521,12 @@ var COPILOT_SDK_SETTINGS = /* @__PURE__ */ new Set([
   "log_format",
   "stream_log",
   "system_prompt",
-  "custom_provider",
-  "byok"
+  "subprovider",
+  "base_url",
+  "api_key",
+  "bearer_token",
+  "api_version",
+  "wire_api"
 ]);
 var COPILOT_CLI_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
@@ -3283,7 +3542,12 @@ var COPILOT_CLI_SETTINGS = /* @__PURE__ */ new Set([
   "log_format",
   "stream_log",
   "system_prompt",
-  "custom_provider"
+  "subprovider",
+  "base_url",
+  "api_key",
+  "bearer_token",
+  "api_version",
+  "wire_api"
 ]);
 var VSCODE_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
@@ -3302,7 +3566,7 @@ var MOCK_SETTINGS = /* @__PURE__ */ new Set([
 var REPLAY_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
   "fixtures",
-  "trace_envelopes",
+  "execution_traces",
   "source_target",
   "suite",
   "eval_path",
@@ -3648,13 +3912,13 @@ async function validateTargetsFile(filePath) {
     }
     if (providerValue === "replay") {
       const hasFixtures = isNonEmptyString(target.fixtures);
-      const hasTraceEnvelopes = isNonEmptyString(target.trace_envelopes);
-      if (hasFixtures === hasTraceEnvelopes) {
+      const hasExecutionTraces = isNonEmptyString(target.execution_traces);
+      if (hasFixtures === hasExecutionTraces) {
         errors.push({
           severity: "error",
           filePath: absolutePath,
           location,
-          message: "Replay provider requires exactly one replay source: 'fixtures' or 'trace_envelopes'"
+          message: "Replay provider requires exactly one replay source: 'fixtures' or 'execution_traces'"
         });
       }
       if (!isNonEmptyString(target.source_target)) {
@@ -3909,7 +4173,27 @@ function validateProjectResultsConfig(errors, filePath, rawResults, location) {
       });
     }
   }
-  validateGitRemoteUrl(errors, filePath, resultsRecord.repo_url, `${location}.repo_url`);
+  const hasRepoUrl = resultsRecord.repo_url !== void 0;
+  const hasRepoPath = resultsRecord.repo_path !== void 0;
+  if (hasRepoUrl && hasRepoPath) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location,
+      message: `Field '${location}' must set only one of repo_url or repo_path`
+    });
+  } else if (hasRepoUrl) {
+    validateGitRemoteUrl(errors, filePath, resultsRecord.repo_url, `${location}.repo_url`);
+  } else if (hasRepoPath) {
+    validateRequiredString(errors, filePath, resultsRecord.repo_path, `${location}.repo_path`);
+  } else {
+    errors.push({
+      severity: "error",
+      filePath,
+      location,
+      message: `Field '${location}' must set repo_url or repo_path`
+    });
+  }
   if (resultsRecord.branch !== void 0 && (typeof resultsRecord.branch !== "string" || resultsRecord.branch.trim().length === 0)) {
     errors.push({
       severity: "error",
@@ -3918,6 +4202,14 @@ function validateProjectResultsConfig(errors, filePath, rawResults, location) {
       message: `Field '${location}.branch' must be a non-empty string`
     });
   }
+  if (resultsRecord.remote !== void 0 && (typeof resultsRecord.remote !== "string" || resultsRecord.remote.trim().length === 0)) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.remote`,
+      message: `Field '${location}.remote' must be a non-empty string`
+    });
+  }
   if (resultsRecord.path !== void 0) {
     if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
       errors.push({
@@ -3953,6 +4245,14 @@ function validateProjectResultsConfig(errors, filePath, rawResults, location) {
           message: `Field '${location}.sync.auto_push' must be a boolean`
         });
       }
+      if (syncRecord.require_push !== void 0 && typeof syncRecord.require_push !== "boolean") {
+        errors.push({
+          severity: "error",
+          filePath,
+          location: `${location}.sync.require_push`,
+          message: `Field '${location}.sync.require_push' must be a boolean`
+        });
+      }
     }
   }
   if (resultsRecord.branch_prefix !== void 0 && (typeof resultsRecord.branch_prefix !== "string" || resultsRecord.branch_prefix.trim().length === 0)) {
@@ -3978,7 +4278,7 @@ function validateResultsConfig(errors, filePath, rawResults, location) {
     return;
   }
   const resultsRecord = rawResults;
-  if (resultsRecord.mode !== "github") {
+  if (resultsRecord.mode !== void 0 && resultsRecord.mode !== "github") {
     errors.push({
       severity: "error",
       filePath,
@@ -3986,7 +4286,31 @@ function validateResultsConfig(errors, filePath, rawResults, location) {
       message: `Field '${location}.mode' must be 'github'`
     });
   }
-  validateRequiredString(errors, filePath, resultsRecord.repo, `${location}.repo`);
+  const hasLegacyRepo = resultsRecord.repo !== void 0;
+  const hasRepoUrl = resultsRecord.repo_url !== void 0;
+  const hasRepoPath = resultsRecord.repo_path !== void 0;
+  const sourceCount = [hasLegacyRepo, hasRepoUrl, hasRepoPath].filter(Boolean).length;
+  if (sourceCount === 0) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location,
+      message: `Field '${location}' must set repo_url/repo or repo_path`
+    });
+  } else if (sourceCount > 1) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location,
+      message: `Field '${location}' must set only one of repo_url/repo or repo_path`
+    });
+  } else if (hasLegacyRepo) {
+    validateRequiredString(errors, filePath, resultsRecord.repo, `${location}.repo`);
+  } else if (hasRepoUrl) {
+    validateGitRemoteUrl(errors, filePath, resultsRecord.repo_url, `${location}.repo_url`);
+  } else {
+    validateRequiredString(errors, filePath, resultsRecord.repo_path, `${location}.repo_path`);
+  }
   if (resultsRecord.branch !== void 0 && (typeof resultsRecord.branch !== "string" || resultsRecord.branch.trim().length === 0)) {
     errors.push({
       severity: "error",
@@ -3995,6 +4319,14 @@ function validateResultsConfig(errors, filePath, rawResults, location) {
       message: `Field '${location}.branch' must be a non-empty string`
     });
   }
+  if (resultsRecord.remote !== void 0 && (typeof resultsRecord.remote !== "string" || resultsRecord.remote.trim().length === 0)) {
+    errors.push({
+      severity: "error",
+      filePath,
+      location: `${location}.remote`,
+      message: `Field '${location}.remote' must be a non-empty string`
+    });
+  }
   if (resultsRecord.path !== void 0) {
     if (typeof resultsRecord.path !== "string" || resultsRecord.path.trim().length === 0) {
       errors.push({
@@ -4023,6 +4355,34 @@ function validateResultsConfig(errors, filePath, rawResults, location) {
       message: `Field '${location}.auto_push' must be a boolean`
     });
   }
+  if (resultsRecord.sync !== void 0) {
+    if (typeof resultsRecord.sync !== "object" || resultsRecord.sync === null || Array.isArray(resultsRecord.sync)) {
+      errors.push({
+        severity: "error",
+        filePath,
+        location: `${location}.sync`,
+        message: `Field '${location}.sync' must be an object`
+      });
+    } else {
+      const syncRecord = resultsRecord.sync;
+      if (syncRecord.auto_push !== void 0 && typeof syncRecord.auto_push !== "boolean") {
+        errors.push({
+          severity: "error",
+          filePath,
+          location: `${location}.sync.auto_push`,
+          message: `Field '${location}.sync.auto_push' must be a boolean`
+        });
+      }
+      if (syncRecord.require_push !== void 0 && typeof syncRecord.require_push !== "boolean") {
+        errors.push({
+          severity: "error",
+          filePath,
+          location: `${location}.sync.require_push`,
+          message: `Field '${location}.sync.require_push' must be a boolean`
+        });
+      }
+    }
+  }
   if (resultsRecord.branch_prefix !== void 0 && (typeof resultsRecord.branch_prefix !== "string" || resultsRecord.branch_prefix.trim().length === 0)) {
     errors.push({
       severity: "error",
@@ -4251,7 +4611,7 @@ function looksLikeFilePath(arg) {
 }
 async function fileExists3(filePath) {
   try {
-    await access4(filePath);
+    await access5(filePath);
     return true;
   } catch {
     return false;
@@ -4609,6 +4969,15 @@ function normalizeString(value) {
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
+function resultsRepoOverride(value) {
+  if (!value) {
+    return {};
+  }
+  if (value === "current" || value === "." || value.startsWith("./") || value.startsWith("../") || value.startsWith("/") || value.startsWith("~/") || value.startsWith("~\\") || /^[A-Za-z]:[/\\]/.test(value)) {
+    return { repo_path: value === "current" ? "." : value };
+  }
+  return { repo: value };
+}
 function resolveTimestampPlaceholder(value) {
   if (!value.includes("{timestamp}")) {
     return value;
@@ -4664,13 +5033,13 @@ function normalizeSourceMetadataByEvalFile(value) {
     const entries = [...value.entries()].filter(
       (entry) => typeof entry[0] === "string" && typeof entry[1] === "object" && entry[1] !== null && !Array.isArray(entry[1])
     );
-    return entries.length > 0 ? new Map(entries.map(([key, metadata]) => [path12.resolve(key), metadata])) : void 0;
+    return entries.length > 0 ? new Map(entries.map(([key, metadata]) => [path14.resolve(key), metadata])) : void 0;
   }
   if (typeof value === "object" && value !== null && !Array.isArray(value)) {
     const entries = Object.entries(value).filter(
       (entry) => typeof entry[1] === "object" && entry[1] !== null && !Array.isArray(entry[1])
     );
-    return entries.length > 0 ? new Map(entries.map(([key, metadata]) => [path12.resolve(key), metadata])) : void 0;
+    return entries.length > 0 ? new Map(entries.map(([key, metadata]) => [path14.resolve(key), metadata])) : void 0;
   }
   return void 0;
 }
@@ -4684,10 +5053,10 @@ var LEGACY_OUTPUT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".htm"
 ]);
 function looksLikeLegacyOutputFilePath(value) {
-  return LEGACY_OUTPUT_FILE_EXTENSIONS.has(path12.extname(value).toLowerCase());
+  return LEGACY_OUTPUT_FILE_EXTENSIONS.has(path14.extname(value).toLowerCase());
 }
 function outputFileMigrationMessage(value) {
-  const ext = path12.extname(value).toLowerCase();
+  const ext = path14.extname(value).toLowerCase();
   const removalHint = ext === ".xml" ? "JUnit XML export from agentv eval has been removed." : "Flat result file export from agentv eval has been removed.";
   return `--output expects a run directory, not a file path: ${value}
 ${removalHint} Set --output <dir> for the canonical run artifacts; AgentV always writes <dir>/index.jsonl.`;
@@ -4695,7 +5064,7 @@ ${removalHint} Set --output <dir> for the canonical run artifacts; AgentV always
 function artifactsMigrationMessage(artifactsDir, outputDir) {
   const lines = [`--artifacts was removed from agentv eval. Use --output ${artifactsDir} instead.`];
   if (outputDir && looksLikeLegacyOutputFilePath(outputDir)) {
-    const ext = path12.extname(outputDir).toLowerCase();
+    const ext = path14.extname(outputDir).toLowerCase();
     lines.push(
       ext === ".xml" ? "JUnit XML export from agentv eval has been removed." : "Flat result file export from agentv eval has been removed."
     );
@@ -4774,6 +5143,21 @@ function normalizeOptions(rawOptions, config, yamlExecution) {
   const yamlWorkspacePath = normalizeString(yamlExecutionRecord?.workspace_path);
   const workspacePath = cliWorkspacePath ?? yamlWorkspacePath;
   const workspaceMode = cliWorkspacePath ? "static" : cliWorkspaceMode ?? yamlWorkspaceMode;
+  const resultsRepo = normalizeString(rawOptions.resultsRepo);
+  const resultsPush = normalizeBoolean(rawOptions.resultsPush);
+  const resultsNoPush = normalizeBoolean(rawOptions.noResultsPush);
+  const resultsRequirePush = normalizeBoolean(rawOptions.resultsRequirePush);
+  const resultsOverrides = {
+    ...resultsRepoOverride(resultsRepo),
+    ...normalizeString(rawOptions.resultsBranch) !== void 0 && {
+      branch: normalizeString(rawOptions.resultsBranch)
+    },
+    ...normalizeString(rawOptions.resultsRemote) !== void 0 && {
+      remote: normalizeString(rawOptions.resultsRemote)
+    },
+    ...resultsPush || resultsNoPush ? { auto_push: resultsPush && !resultsNoPush } : {},
+    ...resultsRequirePush ? { require_push: true } : {}
+  };
   return {
     target: singleTarget,
     cliTargets,
@@ -4825,11 +5209,12 @@ function normalizeOptions(rawOptions, config, yamlExecution) {
     budgetUsd: normalizeOptionalNumber(rawOptions.budgetUsd),
     sourceMetadataByEvalFile: normalizeSourceMetadataByEvalFile(
       rawOptions.sourceMetadataByEvalFile
-    )
+    ),
+    resultsOverrides: Object.keys(resultsOverrides).length > 0 ? resultsOverrides : void 0
   };
 }
 function withSourceMetadata(result, testFilePath, options) {
-  const sourceMetadata = options.sourceMetadataByEvalFile?.get(path12.resolve(testFilePath));
+  const sourceMetadata = options.sourceMetadataByEvalFile?.get(path14.resolve(testFilePath));
   if (!sourceMetadata) {
     return result;
   }
@@ -4843,7 +5228,7 @@ function withSourceMetadata(result, testFilePath, options) {
 }
 async function ensureFileExists(filePath, description) {
   try {
-    await access5(filePath, constants4.F_OK);
+    await access6(filePath, constants4.F_OK);
   } catch {
     throw new Error(`${description} not found: ${filePath}`);
   }
@@ -4851,7 +5236,7 @@ async function ensureFileExists(filePath, description) {
 function buildDefaultOutputPathForExperiment(cwd, experiment) {
   const runDir = buildDefaultRunDir(cwd, experiment);
   mkdirSync2(runDir, { recursive: true });
-  return path12.join(runDir, "index.jsonl");
+  return path14.join(runDir, "index.jsonl");
 }
 function createProgressReporter(maxWorkers, options) {
   const display = new ProgressDisplay(maxWorkers, options);
@@ -4865,7 +5250,7 @@ function createProgressReporter(maxWorkers, options) {
   };
 }
 function makeTestCaseKey(testFilePath, testId) {
-  return `${path12.resolve(testFilePath)}::${testId}`;
+  return `${path14.resolve(testFilePath)}::${testId}`;
 }
 function resolveTargetLabel(requestedName, resolvedName) {
   if (resolvedName !== requestedName) {
@@ -4927,7 +5312,7 @@ async function prepareFileMetadata(params) {
     repoRoot,
     verbose: options.verbose
   });
-  const relativePath = path12.relative(cwd, testFilePath);
+  const relativePath = path14.relative(cwd, testFilePath);
   const category = deriveCategory(relativePath);
   const suite = await loadTestSuite(testFilePath, repoRoot, {
     verbose: options.verbose,
@@ -4952,7 +5337,7 @@ async function prepareFileMetadata(params) {
     selections = [
       {
         selection: transcriptSelection,
-        inlineTargetLabel: `transcript (${path12.basename(options.transcript)})`
+        inlineTargetLabel: `transcript (${path14.basename(options.transcript)})`
       }
     ];
   } else if (suite.inlineTarget && options.cliTargets.length === 0) {
@@ -5118,7 +5503,7 @@ async function runSingleEvalFile(params) {
   } = params;
   const targetName = selection.targetName;
   const replayRecording = options.recordReplay ? {
-    fixturesPath: path12.resolve(options.recordReplay),
+    fixturesPath: path14.resolve(options.recordReplay),
     sourceTarget: targetName,
     variant: options.recordReplayVariant
   } : void 0;
@@ -5269,7 +5654,7 @@ async function runEvalCommand(input) {
     );
   }
   const repoRoot = await findRepoRoot(cwd);
-  const yamlConfig = await loadConfig(path12.join(cwd, "_"), repoRoot);
+  const yamlConfig = await loadConfig(path14.join(cwd, "_"), repoRoot);
   let requiredVersionCheck;
   if (yamlConfig?.required_version) {
     requiredVersionCheck = await enforceRequiredVersion(yamlConfig.required_version, {
@@ -5305,7 +5690,7 @@ async function runEvalCommand(input) {
   }
   let retryNonErrorResults;
   if (options.retryErrors) {
-    const retryPath = path12.resolve(options.retryErrors);
+    const retryPath = path14.resolve(options.retryErrors);
     await ensureFileExists(retryPath, "Retry-errors JSONL file");
     const completedIds = await loadFullyCompletedTestIds(retryPath);
     const errorIds = await loadErrorTestIds(retryPath);
@@ -5323,7 +5708,7 @@ async function runEvalCommand(input) {
     if (cachedDir) {
       options = { ...options, outputDir: cachedDir };
       const flagLabel = options.rerunFailed ? "rerun-failed" : "resume";
-      const displayDir = path12.relative(cwd, cachedDir) || cachedDir;
+      const displayDir = path14.relative(cwd, cachedDir) || cachedDir;
       console.log(`Auto-detected last run dir for --${flagLabel}: ${displayDir}`);
     }
   }
@@ -5332,8 +5717,8 @@ async function runEvalCommand(input) {
   if (options.resume && !options.retryErrors) {
     const explicitResumeDir = options.outputDir;
     if (explicitResumeDir) {
-      const resumeIndexPath = path12.join(path12.resolve(explicitResumeDir), "index.jsonl");
-      if (existsSync6(resumeIndexPath)) {
+      const resumeIndexPath = path14.join(path14.resolve(explicitResumeDir), "index.jsonl");
+      if (existsSync7(resumeIndexPath)) {
         const content = await readFile8(resumeIndexPath, "utf8");
         const existingResults = parseJsonlResults(content);
         resumeSkipKeys = /* @__PURE__ */ new Set();
@@ -5357,7 +5742,7 @@ async function runEvalCommand(input) {
     }
   }
   if (options.workspacePath) {
-    const resolvedWorkspace = path12.resolve(options.workspacePath);
+    const resolvedWorkspace = path14.resolve(options.workspacePath);
     try {
       const { stat: stat3 } = await import("node:fs/promises");
       const stats = await stat3(resolvedWorkspace);
@@ -5379,27 +5764,35 @@ async function runEvalCommand(input) {
   let runDir;
   let outputPath;
   if (explicitDir) {
-    runDir = path12.resolve(explicitDir);
+    runDir = path14.resolve(explicitDir);
     mkdirSync2(runDir, { recursive: true });
-    outputPath = path12.join(runDir, "index.jsonl");
+    outputPath = path14.join(runDir, "index.jsonl");
   } else {
     outputPath = buildDefaultOutputPathForExperiment(cwd, options.experiment);
-    runDir = path12.dirname(outputPath);
+    runDir = path14.dirname(outputPath);
   }
   let otelExporter = null;
   const useFileExport = !!options.otelFile;
   if (options.exportOtel || useFileExport) {
     try {
-      const { OtelTraceExporter, OTEL_BACKEND_PRESETS } = await import("./dist-HVLBDG5F.js");
+      const { OtelTraceExporter } = await import("./dist-6Z4OSITR.js");
       let endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
       let headers = {};
+      let resourceAttributes = {};
       if (options.otelBackend) {
-        const preset = OTEL_BACKEND_PRESETS[options.otelBackend];
-        if (preset) {
-          endpoint = preset.endpoint;
-          headers = preset.headers(process.env);
+        const resolvedBackend = await resolveOtelBackend(options.otelBackend, {
+          env: process.env,
+          cwd
+        });
+        if (resolvedBackend) {
+          endpoint = resolvedBackend.endpoint;
+          headers = { ...headers, ...resolvedBackend.headers };
+          resourceAttributes = { ...resourceAttributes, ...resolvedBackend.resourceAttributes };
+          for (const warning of resolvedBackend.warnings ?? []) {
+            console.warn(warning);
+          }
         } else {
-          console.warn(`Unknown OTel backend preset: ${options.otelBackend}`);
+          console.warn(`Unknown OTel backend resolver: ${options.otelBackend}`);
         }
       }
       if (process.env.OTEL_EXPORTER_OTLP_HEADERS) {
@@ -5412,9 +5805,10 @@ async function runEvalCommand(input) {
       otelExporter = new OtelTraceExporter({
         endpoint,
         headers,
+        resourceAttributes,
         captureContent,
         groupTurns: options.otelGroupTurns,
-        otlpFilePath: options.otelFile ? path12.resolve(options.otelFile) : void 0
+        otlpFilePath: options.otelFile ? path14.resolve(options.otelFile) : void 0
       });
       const initialized = await otelExporter.init();
       if (!initialized) {
@@ -5432,9 +5826,9 @@ async function runEvalCommand(input) {
   }
   const primaryWritePath = outputPath;
   console.log(`Artifact directory: ${runDir}`);
-  const resolvedTestFiles = input.testFiles.map((file) => path12.resolve(file));
+  const resolvedTestFiles = input.testFiles.map((file) => path14.resolve(file));
   if (options.otelFile) {
-    console.log(`OTLP JSON file: ${path12.resolve(options.otelFile)}`);
+    console.log(`OTLP JSON file: ${path14.resolve(options.otelFile)}`);
   }
   const evaluationRunner = await resolveEvaluationRunner();
   const allResults = [];
@@ -5462,7 +5856,7 @@ async function runEvalCommand(input) {
     for (const [testFilePath, meta] of fileMetadata.entries()) {
       if (!matchesTagFilters(meta.tags, options.tags, options.excludeTags)) {
         fileMetadata.delete(testFilePath);
-        skippedFiles.push(path12.relative(cwd, testFilePath));
+        skippedFiles.push(path14.relative(cwd, testFilePath));
       }
     }
     if (skippedFiles.length > 0 && options.verbose) {
@@ -5485,12 +5879,12 @@ async function runEvalCommand(input) {
     tsConfigCache: options.tsConfigCache
   });
   const activeCachePath = options.cachePath ?? yamlCachePath ?? options.tsConfigCachePath;
-  const cache = cacheEnabled ? new ResponseCache(activeCachePath ? path12.resolve(activeCachePath) : void 0) : void 0;
+  const cache = cacheEnabled ? new ResponseCache(activeCachePath ? path14.resolve(activeCachePath) : void 0) : void 0;
   if (cache) {
     console.log(`Response cache: enabled (${cache.cachePath})`);
   }
   if (options.recordReplay) {
-    console.log(`Replay recording: ${path12.resolve(options.recordReplay)}`);
+    console.log(`Replay recording: ${path14.resolve(options.recordReplay)}`);
   }
   const yamlThreshold = firstMeta?.threshold;
   const resolvedThreshold = options.threshold ?? yamlThreshold;
@@ -5586,7 +5980,7 @@ async function runEvalCommand(input) {
   const activeTestFiles = resolvedTestFiles.filter((f) => fileMetadata.has(f));
   let transcriptProviderFactory;
   if (options.transcript) {
-    const { TranscriptProvider } = await import("./dist-HVLBDG5F.js");
+    const { TranscriptProvider } = await import("./dist-6Z4OSITR.js");
     const transcriptProvider = await TranscriptProvider.fromFile(options.transcript);
     const totalTests = [...fileMetadata.values()].reduce(
       (sum, meta) => sum + meta.testCases.length,
@@ -5614,7 +6008,11 @@ async function runEvalCommand(input) {
   let wipCleanedUp = false;
   let finalExportStatus = "disabled";
   {
-    const wipConfig = await loadNormalizedResultsConfig(cwd).catch(() => void 0);
+    const wipConfig = await loadNormalizedResultsConfig(
+      cwd,
+      void 0,
+      options.resultsOverrides
+    ).catch(() => void 0);
     if (wipConfig?.auto_push) {
       wipLoop = new WipCheckpointLoop({
         config: wipConfig,
@@ -5631,7 +6029,7 @@ async function runEvalCommand(input) {
         if (!targetPrep2) continue;
         const budgetMsg = `Run budget exceeded ($${runBudgetTracker.currentCostUsd.toFixed(4)} / $${runBudgetTracker.budgetCapUsd.toFixed(4)})`;
         console.log(`
-\u26A0 ${budgetMsg} \u2014 skipping ${path12.basename(testFilePath)}`);
+\u26A0 ${budgetMsg} \u2014 skipping ${path14.basename(testFilePath)}`);
         for (const { selection } of targetPrep2.selections) {
           const skippedResults = targetPrep2.testCases.map((testCase) => ({
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5710,7 +6108,7 @@ async function runEvalCommand(input) {
               threshold: resolvedThreshold,
               providerFactory: transcriptProviderFactory ?? targetPrep.providerFactory
             });
-            const evalFile = path12.relative(cwd, testFilePath);
+            const evalFile = path14.relative(cwd, testFilePath);
             const existingSummary = remoteEvalSummaries.find(
               (summary2) => summary2.evalFile === evalFile
             );
@@ -5727,7 +6125,7 @@ async function runEvalCommand(input) {
             const message = fileError instanceof Error ? fileError.message : String(fileError);
             console.error(
               `
-[ERROR] \u26A0 Eval file failed: ${path12.basename(testFilePath)} \u2014 ${message}
+[ERROR] \u26A0 Eval file failed: ${path14.basename(testFilePath)} \u2014 ${message}
 `
             );
             const errorResults = filteredTestCases.map(
@@ -5806,7 +6204,7 @@ ${formatRequiredVersionFailureNote(requiredVersionCheck)}`);
       );
       const taskBundleTargets = buildTaskBundleTargetSelections(activeTestFiles, fileMetadata);
       if (isResumeAppend) {
-        const { writePerTestArtifacts } = await import("./artifact-writer-MK5X5MSO.js");
+        const { writePerTestArtifacts } = await import("./artifact-writer-GIAIMGPQ.js");
         await writePerTestArtifacts(allResults, runDir, {
           experiment: normalizeExperimentName(options.experiment),
           cwd,
@@ -5818,7 +6216,7 @@ ${formatRequiredVersionFailureNote(requiredVersionCheck)}`);
           runDir,
           { evalFile, experiment: normalizeExperimentName(options.experiment) }
         );
-        const indexPath = path12.join(runDir, "index.jsonl");
+        const indexPath = path14.join(runDir, "index.jsonl");
         console.log(`Artifact workspace updated: ${runDir}`);
         console.log(`  Index: ${indexPath}`);
         console.log(`  Per-test artifacts: ${runDir} (${allResults.length} new test directories)`);
@@ -5879,13 +6277,14 @@ Results written to: ${outputPath}`);
             status: result.executionStatus === "execution_error" || result.error ? "ERROR" : result.score >= DEFAULT_THRESHOLD ? "PASS" : "FAIL"
           }))
         })),
-        experiment: normalizeExperimentName(options.experiment)
+        experiment: normalizeExperimentName(options.experiment),
+        results_overrides: options.resultsOverrides
       });
     }
     if (summary.executionErrorCount > 0 && !options.retryErrors && !options.resume) {
-      const evalFileArgs = activeTestFiles.map((f) => path12.relative(cwd, f)).join(" ");
+      const evalFileArgs = activeTestFiles.map((f) => path14.relative(cwd, f)).join(" ");
       const targetFlag = options.target ? ` --target ${options.target}` : "";
-      const relativeRunDir = path12.relative(cwd, runDir);
+      const relativeRunDir = path14.relative(cwd, runDir);
       console.log(
         `
 Tip: ${summary.executionErrorCount} execution error(s) detected. Re-run failed tests with:
@@ -5934,8 +6333,8 @@ async function resolveEvaluationRunner() {
   if (!overridePath) {
     return runEvaluation;
   }
-  const resolved = path12.isAbsolute(overridePath) ? overridePath : path12.resolve(process.cwd(), overridePath);
-  const moduleUrl = pathToFileURL(resolved).href;
+  const resolved = path14.isAbsolute(overridePath) ? overridePath : path14.resolve(process.cwd(), overridePath);
+  const moduleUrl = pathToFileURL2(resolved).href;
   const mod = await import(moduleUrl);
   const candidate = mod.runEvaluation;
   if (typeof candidate !== "function") {
@@ -5947,11 +6346,11 @@ async function resolveEvaluationRunner() {
 }
 
 // src/commands/eval/discover.ts
-import path13 from "node:path";
+import path15 from "node:path";
 import fg2 from "fast-glob";
 async function discoverEvalFiles(cwd) {
   const repoRoot = await findRepoRoot(cwd);
-  const config = await loadConfig(path13.join(cwd, "_"), repoRoot);
+  const config = await loadConfig(path15.join(cwd, "_"), repoRoot);
   const patterns = config?.eval_patterns && config.eval_patterns.length > 0 ? config.eval_patterns : DEFAULT_EVAL_PATTERNS;
   const ignore = ["**/node_modules/**", "**/dist/**"];
   const matches = await fg2(patterns, {
@@ -5963,7 +6362,7 @@ async function discoverEvalFiles(cwd) {
     caseSensitiveMatch: false
   });
   const evalFiles = matches.map((absPath) => {
-    const relativePath = path13.relative(cwd, absPath);
+    const relativePath = path15.relative(cwd, absPath);
     const category = deriveCategory(relativePath);
     return { path: absPath, relativePath, category };
   });
@@ -5987,6 +6386,10 @@ export {
   resolveEvalPaths,
   findRepoRoot,
   package_default,
+  RESULT_INDEX_FILENAME,
+  createRunDirName,
+  buildDefaultRunDir,
+  resolveRunManifestPath,
   parseResultManifest,
   resolveResultSourcePath,
   loadManifestResults,
@@ -6036,4 +6439,4 @@ export {
   getCategories,
   filterByCategory
 };
-//# sourceMappingURL=chunk-6M5S4IJW.js.map
+//# sourceMappingURL=chunk-WKA5QDNQ.js.map