agentv 4.44.0-next.1 → 5.1.0-next.1

package/dist/{chunk-NCNDA3F6.js → chunk-GJWPQXHN.js}

@@ -21,7 +21,7 @@ import {
   readTranscriptJsonl,
   releaseSharedWorkspaceSetup,
   resolveRepoCloneUrl
-} from "./chunk-5DYGN547.js";
+} from "./chunk-ZGPCX334.js";
 
 // ../../packages/core/dist/index.js
 import { readFileSync } from "node:fs";
@@ -32,17 +32,18 @@ import micromatch from "micromatch";
 import { readFile } from "node:fs/promises";
 import path3 from "node:path";
 import { execFile, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import {
   existsSync,
   mkdirSync,
   mkdtempSync,
   readFileSync as readFileSync2,
+  realpathSync,
   renameSync,
   rmSync,
   writeFileSync
 } from "node:fs";
-import { cp, lstat, mkdtemp, readdir, rm, stat } from "node:fs/promises";
+import { cp, lstat, mkdtemp, readFile as readFile2, readdir, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path4 from "node:path";
 import { promisify } from "node:util";
@@ -1478,7 +1479,7 @@ function isPrimitive(value) {
 function dropUndefined2(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-function codeGraderInstruction(graderName, description) {
+function scriptGraderInstruction(graderName, description) {
   const desc = description ? ` This grader: ${description}.` : "";
   return `Run \`agentv eval assert ${graderName} --agent-output <agent_output> --agent-input <original_prompt>\` and check the result.${desc} The command accepts --agent-output (the agent's full response text) and --agent-input (the original user prompt). It returns JSON on stdout: {"score": 0-1, "reasoning": "..."}. A score >= 0.5 means pass (exit 0); below 0.5 means fail (exit 1).`;
 }
@@ -1496,21 +1497,15 @@ function assertionToNaturalLanguage(entry) {
   switch (type) {
     case "skill-trigger":
       return null;
-    case "rubrics": {
-      if (typeof entry.criteria === "string") {
-        return entry.criteria;
-      }
-      return null;
-    }
+    case "llm-rubric":
+      return typeof entry.value === "string" ? entry.value : null;
     case "contains":
       return `Output contains '${entry.value}'`;
-    case "contains-any":
-    case "contains_any": {
+    case "contains-any": {
       const values = Array.isArray(entry.value) ? entry.value.join("', '") : entry.value;
       return `Output contains any of: '${values}'`;
     }
-    case "contains-all":
-    case "contains_all": {
+    case "contains-all": {
       const values = Array.isArray(entry.value) ? entry.value.join("', '") : entry.value;
       return `Output contains all of: '${values}'`;
     }
@@ -1521,35 +1516,27 @@ function assertionToNaturalLanguage(entry) {
     case "equals":
       return `Output exactly equals: ${entry.value}`;
     case "is-json":
-    case "is_json":
       return "Output is valid JSON";
     case "starts-with":
-    case "starts_with":
       return `Output starts with '${entry.value}'`;
     case "ends-with":
-    case "ends_with":
       return `Output ends with '${entry.value}'`;
     case "llm-grader":
-    case "llm_grader": {
       if (Array.isArray(entry.rubrics) && entry.rubrics.length > 0) {
         return null;
       }
       return typeof entry.prompt === "string" ? entry.prompt : null;
-    }
-    case "tool-trajectory":
-    case "tool_trajectory": {
+    case "tool-trajectory": {
       const expectedArr = Array.isArray(entry.expected) ? entry.expected : [];
       const tools = expectedArr.map((e) => e.tool).filter(Boolean).join(", ");
       return tools ? `Agent called tools in order: ${tools}` : "Agent followed expected tool trajectory";
     }
-    case "code-grader":
-    case "code_grader": {
-      const graderName = entry.name ?? deriveGraderNameFromCommand(entry.command) ?? "code-grader";
+    case "script": {
+      const graderName = entry.metric ?? deriveGraderNameFromCommand(entry.command) ?? "script";
       const desc = typeof entry.description === "string" ? entry.description : void 0;
-      return codeGraderInstruction(graderName, desc);
+      return scriptGraderInstruction(graderName, desc);
     }
-    case "field-accuracy":
-    case "field_accuracy": {
+    case "field-accuracy": {
       const fieldPaths = Array.isArray(entry.fields) ? entry.fields.map((f) => f.path).filter(Boolean).join(", ") : "";
       return fieldPaths ? `Fields ${fieldPaths} match expected values` : "Fields match expected values";
     }
@@ -1558,14 +1545,12 @@ function assertionToNaturalLanguage(entry) {
     case "cost":
       return typeof entry.budget === "number" ? `Cost under $${entry.budget}` : "Cost within budget";
     case "token-usage":
-    case "token_usage":
       return "Token usage within limits";
     case "execution-metrics":
-    case "execution_metrics":
       return "Execution within metric bounds";
     default: {
       if (entry.command !== void 0 && type) {
-        return codeGraderInstruction(deriveGraderNameFromCommand(entry.command) ?? type);
+        return scriptGraderInstruction(deriveGraderNameFromCommand(entry.command) ?? type);
       }
       if (typeof entry.criteria === "string") return entry.criteria;
       if (typeof entry.prompt === "string") return entry.prompt;
@@ -1574,7 +1559,17 @@ function assertionToNaturalLanguage(entry) {
   }
 }
 function assertionToNaturalLanguageList(entry) {
-  if (entry.type === "llm-grader" || entry.type === "llm_grader") {
+  if (entry.type === "llm-rubric") {
+    if (Array.isArray(entry.value) && entry.value.length > 0) {
+      return entry.value.map((rubric) => {
+        if (typeof rubric === "string") return rubric;
+        if (!rubric || typeof rubric !== "object") return void 0;
+        const item = rubric;
+        return item.outcome ?? item.criteria ?? item.id;
+      }).filter((value) => typeof value === "string");
+    }
+  }
+  if (entry.type === "llm-grader") {
     if (Array.isArray(entry.rubrics) && entry.rubrics.length > 0) {
       return entry.rubrics.map((r) => r.outcome ?? r.criteria ?? r.id).filter((s) => typeof s === "string");
     }
@@ -1585,16 +1580,6 @@ function assertionToNaturalLanguageList(entry) {
 function extractTriggerAssertions(assertions) {
   return assertions.filter((a) => a.type === "skill-trigger");
 }
-function resolveAssertions(rawCase) {
-  if (Array.isArray(rawCase.assertions)) return rawCase.assertions;
-  if (Array.isArray(rawCase.assert)) return rawCase.assert;
-  return [];
-}
-function resolveSuiteAssertions(suite) {
-  if (Array.isArray(suite.assertions)) return suite.assertions;
-  if (Array.isArray(suite.assert)) return suite.assert;
-  return [];
-}
 function extractInput(rawCase) {
   const files = Array.isArray(rawCase.input_files) ? rawCase.input_files.filter((f) => typeof f === "string") : [];
   const input = rawCase.input;
@@ -1632,7 +1617,6 @@ function extractExpectedOutput(raw) {
   return JSON.stringify(raw);
 }
 function transpileEvalYaml(suite, source = "EVAL.yaml") {
-  const warnings = [];
   const files = /* @__PURE__ */ new Map();
   if (typeof suite !== "object" || suite === null) {
     throw new Error(`Invalid EVAL.yaml: expected an object in '${source}'`);
@@ -1641,10 +1625,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
   if (!Array.isArray(rawSuite.tests)) {
     throw new Error(`Invalid EVAL.yaml: missing 'tests' array in '${source}'`);
   }
-  if (rawSuite.assert !== void 0 && rawSuite.assertions === void 0) {
-    warnings.push("'assert' is deprecated at the suite level. Use 'assertions' instead.");
-  }
-  const suiteAssertions = resolveSuiteAssertions(rawSuite);
+  const suiteAssertions = rawSuite.assert ?? [];
   const suiteNlAssertions = suiteAssertions.filter((a) => a.type !== "skill-trigger").flatMap(assertionToNaturalLanguageList);
   function getSkillFile(skillName) {
     const existing = files.get(skillName);
@@ -1656,10 +1637,11 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
   const tests = rawSuite.tests;
   for (let idx = 0; idx < tests.length; idx++) {
     const rawCase = tests[idx];
-    const caseAssertions = resolveAssertions(rawCase);
-    if (rawCase.assert !== void 0 && rawCase.assertions === void 0) {
-      const caseId = rawCase.id ?? idx + 1;
-      warnings.push(`Test '${caseId}': 'assert' is deprecated. Use 'assertions' instead.`);
+    const caseAssertions = rawCase.assert ?? [];
+    if (typeof rawCase.criteria === "string" && rawCase.criteria.trim() && rawCase.assert !== void 0) {
+      throw new Error(
+        `Invalid EVAL.yaml test '${rawCase.id ?? idx + 1}' in '${source}': do not combine test-level 'criteria' with 'assert'. Put human-readable case descriptions in 'description', or express grading text as an explicit assertion such as { type: 'llm-rubric', value: ... }.`
+      );
     }
     const nlAssertions = [];
     if (typeof rawCase.criteria === "string" && rawCase.criteria.trim()) {
@@ -1712,7 +1694,7 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
       files.delete("_no-skill");
     }
   }
-  return { files, warnings };
+  return { files, warnings: [] };
 }
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
@@ -1754,33 +1736,10 @@ function toRepoPins(repos) {
     ...repo.path !== void 0 && { path: repo.path },
     ...repo.repo !== void 0 && { repo: repo.repo },
     ...repo.commit !== void 0 && { commit: repo.commit },
-    ...repo.base_commit !== void 0 && { baseCommit: repo.base_commit },
     ...repo.ancestor !== void 0 && { ancestor: repo.ancestor },
     ...repo.sparse !== void 0 && { sparse: repo.sparse }
   }));
 }
-function poolMetadata(setup, selectedSlotPath) {
-  const slot = setup.poolSlot ?? setup.poolSlots.find((candidate) => candidate.path === selectedSlotPath);
-  if (!slot) {
-    return void 0;
-  }
-  return {
-    fingerprint: slot.fingerprint,
-    slotIndex: slot.index,
-    lockPath: slot.lockPath
-  };
-}
-async function releaseUnselectedPoolSlots(setup, selectedSlotPath) {
-  if (!setup.poolManager) {
-    return;
-  }
-  for (const slot of setup.poolSlots) {
-    if (slot.path !== selectedSlotPath) {
-      await setup.poolManager.releaseSlot(slot).catch(() => {
-      });
-    }
-  }
-}
 async function prepareEvalWorkspace(options) {
   const evalPath = path2.resolve(options.testFilePath);
   const evalRunId = randomUUID();
@@ -1809,15 +1768,11 @@ async function prepareEvalWorkspace(options) {
       evalDir,
       verbose: options.verbose,
       workers,
-      poolMaxSlots: options.poolMaxSlots,
       workspacePath: options.workspacePath,
-      legacyWorkspacePath: options.workspace,
-      workspaceMode: options.workspaceMode,
-      workspaceClean: options.workspaceClean
+      legacyWorkspacePath: options.workspace
     });
-    const testPoolSlot = sharedSetup.availablePoolSlots.length > 0 ? sharedSetup.availablePoolSlots.pop() : void 0;
-    const selectedWorkspacePath = testPoolSlot?.path ?? sharedSetup.sharedWorkspacePath;
-    const selectedBaselineCommit = testPoolSlot ? sharedSetup.poolSlotBaselines.get(testPoolSlot.path) : sharedSetup.sharedBaselineCommit;
+    const selectedWorkspacePath = sharedSetup.sharedWorkspacePath;
+    const selectedBaselineCommit = sharedSetup.sharedBaselineCommit;
     const caseSetup = await prepareEvalCaseWorkspace({
       evalCase,
       targetName: options.target.name,
@@ -1829,6 +1784,7 @@ async function prepareEvalWorkspace(options) {
       evalDir,
       cleanupWorkspaces: options.cleanupWorkspaces,
       targetHooks: options.targetHooks,
+      sharedExtensionState: sharedSetup.extensionState,
       setupDebug: options.verbose
     });
     if (!caseSetup.workspacePath) {
@@ -1836,8 +1792,6 @@ async function prepareEvalWorkspace(options) {
         `No workspace was materialized for test "${evalCase.id}". Add workspace.template, workspace.repos, or workspace.hooks before preparing an external attempt.`
       );
     }
-    await releaseUnselectedPoolSlots(sharedSetup, caseSetup.workspacePath);
-    const pool = poolMetadata(sharedSetup, caseSetup.workspacePath);
     return {
       evalPath,
       testId: evalCase.id,
@@ -1849,6 +1803,12 @@ async function prepareEvalWorkspace(options) {
       },
       createdAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
       hookExecutions: [...sharedSetup.hookExecutions, ...caseSetup.hookExecutions],
+      ...caseSetup.extensionState?.providerContext !== void 0 && {
+        providerContext: caseSetup.extensionState.providerContext
+      },
+      ...caseSetup.extensionState?.metadata !== void 0 && {
+        metadata: caseSetup.extensionState.metadata
+      },
       repoPins: toRepoPins(evalCase.workspace?.repos),
       baseline: caseSetup.baselineCommit ? { status: "initialized", commit: caseSetup.baselineCommit } : { status: "unavailable" },
       promptSource: {
@@ -1866,8 +1826,7 @@ async function prepareEvalWorkspace(options) {
         retainOnFailure,
         manualCleanup: true
       },
-      sharedWorkspace: caseSetup.isSharedWorkspace,
-      ...pool !== void 0 && { pool }
+      sharedWorkspace: caseSetup.isSharedWorkspace
     };
   } catch (error) {
     if (sharedSetup) {
@@ -1877,22 +1836,51 @@ async function prepareEvalWorkspace(options) {
     throw error;
   }
 }
+var ExecutionConfigSchema = external_exports.object({
+  /** General eval parallelism (default: 3) */
+  maxConcurrency: external_exports.number().int().min(1).max(50).optional(),
+  /** Maximum retries on failure (default: 2) */
+  maxRetries: external_exports.number().int().min(0).optional(),
+  /** Agent timeout in milliseconds. No timeout if not set. */
+  agentTimeoutMs: external_exports.number().int().min(0).optional(),
+  /** Enable verbose logging */
+  verbose: external_exports.boolean().optional(),
+  /** Always keep temp workspaces after eval */
+  keepWorkspaces: external_exports.boolean().optional()
+}).passthrough().superRefine((value, ctx) => {
+  const supportedFields = /* @__PURE__ */ new Set([
+    "maxConcurrency",
+    "maxRetries",
+    "agentTimeoutMs",
+    "verbose",
+    "keepWorkspaces"
+  ]);
+  if ("otelFile" in value) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["otelFile"],
+      message: "execution.otelFile has been removed. Emit OpenTelemetry/OpenInference traces from the system under test or provider and correlate AgentV run artifacts with external_trace metadata."
+    });
+  }
+  for (const key of Object.keys(value)) {
+    if (!supportedFields.has(key) && key !== "otelFile") {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: [key],
+        message: `Unsupported execution field '${key}'`
+      });
+    }
+  }
+}).transform(({ maxConcurrency, maxRetries, agentTimeoutMs, verbose, keepWorkspaces }) => ({
+  ...maxConcurrency !== void 0 && { maxConcurrency },
+  ...maxRetries !== void 0 && { maxRetries },
+  ...agentTimeoutMs !== void 0 && { agentTimeoutMs },
+  ...verbose !== void 0 && { verbose },
+  ...keepWorkspaces !== void 0 && { keepWorkspaces }
+}));
 var AgentVConfigSchema = external_exports.object({
   /** Default execution settings */
-  execution: external_exports.object({
-    /** Number of parallel workers (default: 3) */
-    workers: external_exports.number().int().min(1).max(50).optional(),
-    /** Maximum retries on failure (default: 2) */
-    maxRetries: external_exports.number().int().min(0).optional(),
-    /** Agent timeout in milliseconds. No timeout if not set. */
-    agentTimeoutMs: external_exports.number().int().min(0).optional(),
-    /** Enable verbose logging */
-    verbose: external_exports.boolean().optional(),
-    /** Always keep temp workspaces after eval */
-    keepWorkspaces: external_exports.boolean().optional(),
-    /** Write OTLP JSON trace to this path (supports {timestamp} placeholder) */
-    otelFile: external_exports.string().optional()
-  }).optional(),
+  execution: ExecutionConfigSchema.optional(),
   /** Output settings */
   output: external_exports.object({
     /** Default eval run artifact directory */
@@ -1922,7 +1910,9 @@ var AgentVConfigSchema = external_exports.object({
      * stderr is forwarded to the user. Non-zero exit aborts with an error.
      */
     beforeSession: external_exports.string().optional()
-  }).optional()
+  }).optional(),
+  /** Project-local reusable references for fields that support ref://name */
+  refs: external_exports.record(external_exports.string().min(1)).optional()
 });
 function defineConfig(config) {
   return AgentVConfigSchema.parse(config);
@@ -2106,9 +2096,12 @@ function extractReposFromObject(obj) {
 }
 var execFileAsync = promisify(execFile);
 var RESULTS_REPO_RESULTS_DIR = ".agentv/results";
-var RESULTS_REPO_RUNS_DIR = "runs";
-var RESULTS_REPO_METADATA_DIR = "metadata";
-var RESULTS_REPO_TRACKED_DIRS = [RESULTS_REPO_RUNS_DIR, RESULTS_REPO_METADATA_DIR];
+var RESULTS_REPO_RUNS_DIR = ".";
+var RESULTS_REPO_INDEXES_DIR = ".indexes";
+var RESULTS_REPO_CACHE_DIR = ".cache";
+var RESULTS_REPO_TRACKED_DOT_DIRS = [RESULTS_REPO_INDEXES_DIR, RESULTS_REPO_CACHE_DIR];
+var GIT_RESULTS_INDEX_CACHE_SCHEMA_VERSION = "agentv.git_results_index_cache.v1";
+var GIT_RESULTS_INDEX_LAYOUT_VERSION = "agentv.results_repo_branch_root.v1";
 var FALLBACK_RESULTS_REPO_COMMIT_EMAIL = "agentv@results-repo";
 var FALLBACK_RESULTS_REPO_COMMIT_NAME = "AgentV Results";
 var GIT_COMMIT_IDENTITY_ENV_KEYS = [
@@ -2125,11 +2118,16 @@ var GIT_ENV_INHERIT_ALLOWLIST = /* @__PURE__ */ new Set([
   "GIT_USERNAME"
 ]);
 var DEFAULT_RESULTS_BRANCH = AGENTV_RESULTS_PRIMARY_REF;
-var MANAGED_RESULTS_REMOTE = "agentv-results";
 var GIT_EMPTY_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var RESULTS_REPO_GENESIS_MESSAGE = "chore(results): initialize AgentV results branch";
 var RESULTS_REPO_GENESIS_DATE = "@0 +0000";
 var RESULT_INDEX_FILENAME2 = "index.jsonl";
+var RUN_INTERNAL_DIRNAME = ".internal";
+var RESULTS_REPO_GITATTRIBUTES_FILE = ".gitattributes";
+var RESULTS_REPO_GITATTRIBUTES_CONTENT = `# Managed by AgentV. Artifact-aware merge so results sync never force-pushes.
+${RESULTS_REPO_INDEXES_DIR}/*.jsonl merge=union
+*/.internal/index.jsonl merge=union
+`;
 var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
   return repo.trim().replace(/[^A-Za-z0-9._-]+/g, "-");
@@ -2152,18 +2150,24 @@ function resolveLocalPath(p, baseDir) {
   const expanded = expandHome(p);
   return path4.isAbsolute(expanded) ? expanded : path4.resolve(baseDir, expanded);
 }
+function isNormalizedResultsConfig(config) {
+  return typeof config.storageBranchWorktree === "boolean";
+}
 function normalizeResultsConfig(config, options) {
+  if (isNormalizedResultsConfig(config)) {
+    return config;
+  }
   const baseDir = options?.baseDir ?? process.cwd();
   const repoUrl = (config.repo_url ?? config.repo)?.trim();
-  const repoPath = config.repo_path?.trim();
-  const explicitClonePath = config.path?.trim();
+  const explicitPath = config.path?.trim();
+  const repoPath = config.repo_path?.trim() ?? (repoUrl ? void 0 : explicitPath);
+  const explicitClonePath = repoUrl ? explicitPath : void 0;
   const repo = repoUrl ?? repoPath ?? "";
   const branch = config.branch?.trim() || (repoPath ? DEFAULT_RESULTS_BRANCH : void 0);
   const useStorageBranchWorktree = Boolean(repoPath || repoUrl && explicitClonePath && branch);
-  const remote = config.remote?.trim() || (repoUrl && useStorageBranchWorktree ? MANAGED_RESULTS_REMOTE : "origin");
-  const autoPush = config.sync?.auto_push ?? config.auto_push === true;
-  const requirePush = config.sync?.require_push === true;
-  const pushConflictPolicy = config.sync?.push_conflict_policy ?? "block";
+  const remote = config.remote?.trim() || "origin";
+  const autoPush = config.auto_push === true;
+  const requirePush = config.require_push === true;
   const resolvedRepoPath = repoPath ? resolveLocalPath(repoPath, baseDir) : void 0;
   const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
@@ -2176,16 +2180,23 @@ function normalizeResultsConfig(config, options) {
     path: resolvedPath,
     auto_push: autoPush,
     require_push: requirePush,
-    push_conflict_policy: pushConflictPolicy,
-    branch_prefix: config.branch_prefix?.trim() || "eval-results",
+    push_conflict_policy: "block",
     storageBranchWorktree: useStorageBranchWorktree
   };
 }
+var GITHUB_OWNER_REPO_SHORTHAND = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function isExplicitRemoteUrl(value) {
+  return value.includes("://") || value.startsWith("git@");
+}
 function resolveResultsRepoUrl(repo) {
-  if (repo.includes("://") || repo.startsWith("git@")) {
-    return repo;
+  const trimmed = repo.trim();
+  if (isExplicitRemoteUrl(trimmed)) {
+    return trimmed;
   }
-  return `https://github.com/${repo}.git`;
+  if (GITHUB_OWNER_REPO_SHORTHAND.test(trimmed)) {
+    return `https://github.com/${trimmed}.git`;
+  }
+  return trimmed;
 }
 function getResultsRepoLocalPaths(repo) {
   const rootDir = path4.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
@@ -2447,26 +2458,79 @@ async function resolveGitTopLevel(repoDir) {
   const { stdout } = await runGit(["rev-parse", "--show-toplevel"], { cwd: repoDir });
   return stdout.trim() || repoDir;
 }
-async function ensureResultsRepoRemote(repoDir, config) {
-  if (!config.repo_url) {
+async function ensureResultsMergeConfig(repoDir) {
+  let gitDir;
+  try {
+    const { stdout } = await runGit(["rev-parse", "--git-common-dir"], { cwd: repoDir });
+    const resolved = stdout.trim();
+    gitDir = resolved ? path4.isAbsolute(resolved) ? resolved : path4.join(repoDir, resolved) : path4.join(repoDir, ".git");
+  } catch {
     return;
   }
-  const remoteUrl = resolveResultsRepoUrl(config.repo_url);
-  const { stdout } = await runGit(["remote", "get-url", config.remote], {
-    cwd: repoDir,
-    check: false
-  });
-  const existingUrl = stdout.trim();
-  if (!existingUrl) {
-    await runGit(["remote", "add", config.remote, remoteUrl], { cwd: repoDir });
+  writeResultsInfoAttributes(gitDir);
+}
+var RESULTS_INFO_ATTRIBUTES_BEGIN = "# >>> agentv results merge attributes >>>";
+var RESULTS_INFO_ATTRIBUTES_END = "# <<< agentv results merge attributes <<<";
+function writeResultsInfoAttributes(gitDir) {
+  const infoDir = path4.join(gitDir, "info");
+  const attributesPath = path4.join(infoDir, "attributes");
+  const managedBlock = `${RESULTS_INFO_ATTRIBUTES_BEGIN}
+${RESULTS_REPO_GITATTRIBUTES_CONTENT.trimEnd()}
+${RESULTS_INFO_ATTRIBUTES_END}
+`;
+  let existing = "";
+  try {
+    existing = readFileSync2(attributesPath, "utf8");
+  } catch {
+    existing = "";
+  }
+  const blockPattern = new RegExp(
+    `${escapeRegExp(RESULTS_INFO_ATTRIBUTES_BEGIN)}[\\s\\S]*?${escapeRegExp(
+      RESULTS_INFO_ATTRIBUTES_END
+    )}\\n?`
+  );
+  const withoutManaged = existing.replace(blockPattern, "");
+  const next = withoutManaged.length > 0 && !withoutManaged.endsWith("\n") ? `${withoutManaged}
+${managedBlock}` : `${withoutManaged}${managedBlock}`;
+  if (next === existing) {
+    return;
+  }
+  mkdirSync(infoDir, { recursive: true });
+  writeFileSync(attributesPath, next);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function addResultsGitattributesToIndex(repoDir, indexEnv) {
+  const { stdout: existing } = await runGit(
+    ["cat-file", "-p", `:0:${RESULTS_REPO_GITATTRIBUTES_FILE}`],
+    { cwd: repoDir, env: indexEnv, check: false }
+  );
+  if (existing === RESULTS_REPO_GITATTRIBUTES_CONTENT) {
     return;
   }
-  if (existingUrl !== remoteUrl) {
-    await runGit(["remote", "set-url", config.remote, remoteUrl], { cwd: repoDir });
+  const scratchDir = mkdtempSync(path4.join(os.tmpdir(), "agentv-results-attrs-"));
+  try {
+    const scratchFile = path4.join(scratchDir, RESULTS_REPO_GITATTRIBUTES_FILE);
+    writeFileSync(scratchFile, RESULTS_REPO_GITATTRIBUTES_CONTENT);
+    const { stdout: blob } = await runGit(["hash-object", "-w", "--no-filters", scratchFile], {
+      cwd: repoDir
+    });
+    await runGit(
+      [
+        "update-index",
+        "--add",
+        "--cacheinfo",
+        `100644,${blob.trim()},${RESULTS_REPO_GITATTRIBUTES_FILE}`
+      ],
+      { cwd: repoDir, env: indexEnv }
+    );
+  } finally {
+    rmSync(scratchDir, { recursive: true, force: true });
   }
 }
 function updateStatusFile(config, patch) {
-  const repo = typeof config.repo === "string" ? config.repo : config.repo_url ?? config.repo_path ?? "";
+  const repo = normalizeResultsConfig(config).repo;
   const cachePaths = getResultsRepoLocalPaths(repo);
   const current = readPersistedStatus(cachePaths.statusFile);
   writePersistedStatus(cachePaths.statusFile, {
@@ -2480,7 +2544,9 @@ async function ensureResultsRepoClone(config) {
     if (!await isGitRepository(normalized.repo_path)) {
       throw new Error(`Results repo_path is not a git repository: ${normalized.repo_path}`);
     }
-    return resolveGitTopLevel(normalized.repo_path);
+    const topLevel = await resolveGitTopLevel(normalized.repo_path);
+    await ensureResultsMergeConfig(topLevel);
+    return topLevel;
   }
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
@@ -2494,10 +2560,11 @@ async function ensureResultsRepoClone(config) {
       await runGit([
         "clone",
         "--filter=blob:none",
+        ...normalized.remote === "origin" ? [] : ["--origin", normalized.remote],
         resolveResultsRepoUrl(normalized.repo_url ?? normalized.repo),
         cloneDir
       ]);
-      await ensureResultsRepoRemote(cloneDir, normalized);
+      await ensureResultsMergeConfig(cloneDir);
       return cloneDir;
     } catch (error) {
       updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
@@ -2507,7 +2574,7 @@ async function ensureResultsRepoClone(config) {
   if (!existsSync(gitDir)) {
     throw new Error(`Results repo clone path is not a git repository: ${cloneDir}`);
   }
-  await ensureResultsRepoRemote(cloneDir, normalized);
+  await ensureResultsMergeConfig(cloneDir);
   return cloneDir;
 }
 function getResultsRepoStatus(config) {
@@ -2532,7 +2599,6 @@ function getResultsRepoStatus(config) {
     auto_push: normalized.auto_push,
     require_push: normalized.require_push,
     push_conflict_policy: normalized.push_conflict_policy,
-    branch_prefix: normalized.branch_prefix,
     local_dir: normalized.path,
     last_synced_at: persisted.last_synced_at,
     last_error: persisted.last_error,
@@ -2859,6 +2925,17 @@ var ResultsBranchPushConflictError = class extends Error {
     this.name = "ResultsBranchPushConflictError";
   }
 };
+function pendingMergeToWire(details) {
+  return {
+    temp_branch: details.tempBranch,
+    target_branch: details.targetBranch,
+    ...details.compareUrl !== void 0 && { compare_url: details.compareUrl },
+    ...details.contributedRunCount !== void 0 && {
+      contributed_run_count: details.contributedRunCount
+    },
+    created_at: details.createdAt
+  };
+}
 function pushDetailsToWire(details) {
   if (!details) {
     return {};
@@ -2876,7 +2953,11 @@ function pushDetailsToWire(details) {
     ...details.forcePushedCommit !== void 0 && {
       force_pushed_commit: details.forcePushedCommit
     },
-    ...details.leaseCommit !== void 0 && { lease_commit: details.leaseCommit }
+    ...details.leaseCommit !== void 0 && { lease_commit: details.leaseCommit },
+    ...details.autoMergedRemote === true && { auto_merged_remote: true },
+    ...details.pendingMerge !== void 0 && {
+      pending_merge: pendingMergeToWire(details.pendingMerge)
+    }
   };
 }
 function withBlockedStatus(status, blockReason, flags) {
@@ -2894,11 +2975,13 @@ function withPushConflictStatus(status, blockReason, details, flags) {
   return withBlockedStatus(
     {
       ...status,
-      sync_status: "push_conflict"
+      sync_status: flags.syncStatus ?? "push_conflict"
     },
     blockReason,
     {
-      ...flags,
+      pullPerformed: flags.pullPerformed,
+      pushPerformed: flags.pushPerformed,
+      commitCreated: flags.commitCreated,
       pushDetails: details
     }
   );
@@ -2914,21 +2997,48 @@ function withActionFlags(status, flags) {
   };
 }
 function isSafeResultsRepoPath(p) {
-  return RESULTS_REPO_TRACKED_DIRS.some((dir) => p === dir || p.startsWith(`${dir}/`));
+  const normalized = p.split(path4.sep).join("/");
+  const segments = normalized.split("/").filter(Boolean);
+  const isRunBundlePath = segments.length >= 2 && !segments[0]?.startsWith(".") && segments[0] !== RESULTS_REPO_GITATTRIBUTES_FILE;
+  return normalized === RESULTS_REPO_GITATTRIBUTES_FILE || RESULTS_REPO_TRACKED_DOT_DIRS.some(
+    (dir) => normalized === dir || normalized.startsWith(`${dir}/`)
+  ) || isRunBundlePath;
 }
-async function existingTrackedResultsDirs(repoDir) {
-  const targets = [];
-  for (const dir of RESULTS_REPO_TRACKED_DIRS) {
+async function existingTrackedResultsPathspecs(repoDir) {
+  const targets = /* @__PURE__ */ new Set();
+  if (existsSync(path4.join(repoDir, RESULTS_REPO_GITATTRIBUTES_FILE))) {
+    targets.add(RESULTS_REPO_GITATTRIBUTES_FILE);
+  }
+  for (const dir of RESULTS_REPO_TRACKED_DOT_DIRS) {
     if (existsSync(path4.join(repoDir, dir))) {
-      targets.push(dir);
+      targets.add(dir);
+      continue;
+    }
+    const { stdout: stdout2 } = await runGit(["ls-files", "--", dir], { cwd: repoDir, check: false });
+    if (stdout2.trim().length > 0) {
+      targets.add(dir);
+    }
+  }
+  for (const entry of await readdir(repoDir, { withFileTypes: true }).catch(() => [])) {
+    if (entry.name.startsWith(".") || !entry.isDirectory()) {
+      continue;
+    }
+    if (existsSync(path4.join(repoDir, entry.name, "summary.json"))) {
+      targets.add(entry.name);
+    }
+  }
+  const { stdout } = await runGit(["ls-files"], { cwd: repoDir, check: false });
+  for (const file of stdout.split(/\r?\n/)) {
+    const normalized = file.trim();
+    if (!normalized) {
       continue;
     }
-    const { stdout } = await runGit(["ls-files", "--", dir], { cwd: repoDir, check: false });
-    if (stdout.trim().length > 0) {
-      targets.push(dir);
+    const segments = normalized.split("/");
+    if (segments.length >= 2 && segments[0] && !segments[0].startsWith(".")) {
+      targets.add(segments[0]);
     }
   }
-  return targets;
+  return [...targets].sort();
 }
 function areSafeResultsRepoPaths(paths) {
   return paths.length > 0 && paths.every(isSafeResultsRepoPath);
@@ -2947,19 +3057,8 @@ function getPushTargetBranch(upstream, baseBranch, remote = "origin") {
   const prefix = `${remote}/`;
   return upstream?.startsWith(prefix) ? upstream.slice(prefix.length) : baseBranch;
 }
-function timestampForBackupRef(date = /* @__PURE__ */ new Date()) {
-  const pad = (value) => String(value).padStart(2, "0");
-  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T${pad(
-    date.getUTCHours()
-  )}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
-}
-function slugifyBackupTargetBranch(branch) {
-  return branch.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "results";
-}
-function buildResultsBackupRef(targetBranch, remoteCommit) {
-  return `agentv/backups/${timestampForBackupRef()}-${slugifyBackupTargetBranch(
-    targetBranch
-  )}-${remoteCommit.slice(0, 7)}`;
+function formatShortSha(sha) {
+  return sha ? sha.slice(0, 12) : "unknown";
 }
 async function getCommitSha(repoDir, ref) {
   if (!ref) {
@@ -2976,91 +3075,303 @@ function isNonFastForwardPushError(error) {
   const text = gitErrorText(error);
   return text.includes("non-fast-forward") || text.includes("fetch first") || text.includes("tip is behind its remote") || text.includes("note about fast-forwards") || text.includes("stale info");
 }
-function formatShortSha(sha) {
-  return sha ? sha.slice(0, 12) : "unknown";
+var RESULTS_PUSH_MERGE_MAX_ATTEMPTS = 5;
+async function isAncestorCommit(repoDir, ancestor, descendant) {
+  const { exitCode } = await runGit(["merge-base", "--is-ancestor", ancestor, descendant], {
+    cwd: repoDir,
+    check: false
+  });
+  return exitCode === 0;
 }
-function buildBlockedPushConflictReason(details) {
-  return `Results branch push conflict on ${details.targetBranch}: remote ${formatShortSha(
-    details.remoteCommit
-  )}, local ${formatShortSha(details.localCommit)}. Configure results.sync.push_conflict_policy: backup_and_force_push to back up the remote ref before replacing it.`;
+async function getMergeBaseCommit(repoDir, a, b) {
+  const { stdout, exitCode } = await runGit(["merge-base", a, b], { cwd: repoDir, check: false });
+  const sha = stdout.trim();
+  return exitCode === 0 && sha.length > 0 ? sha : void 0;
 }
-async function resolveResultBranchPushConflict(params) {
-  await fetchResultsRepo(params.repoDir, params.normalized.remote, params.targetBranch);
-  const remoteRef = remoteBranchRef(params.targetBranch, params.normalized.remote);
-  const remoteCommit = await getCommitSha(params.repoDir, remoteRef);
-  const localCommit = await getCommitSha(params.repoDir, params.sourceRef);
-  const baseDetails = {
-    pushConflictPolicy: params.normalized.push_conflict_policy,
-    targetBranch: params.targetBranch,
-    ...remoteCommit !== void 0 && {
-      remoteCommit,
-      previousRemoteCommit: remoteCommit,
-      leaseCommit: remoteCommit
-    },
-    ...localCommit !== void 0 && { localCommit }
-  };
-  if (!remoteCommit) {
-    return {
-      blocked: true,
-      blockReason: `Results branch push conflict on ${params.targetBranch}: remote commit could not be resolved after fetch`,
-      details: baseDetails
-    };
+function buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit) {
+  return `Results branch ${targetBranch} diverged from the remote and could not be auto-merged: a genuine results content conflict remains (remote ${formatShortSha(
+    remoteCommit
+  )}, local ${formatShortSha(
+    localCommit
+  )}). The remote branch is unchanged and no history was rewritten; resolve it with a GitHub pull request.`;
+}
+function timestampForResultsRef(date = /* @__PURE__ */ new Date()) {
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date.getUTCFullYear()}${pad(date.getUTCMonth() + 1)}${pad(date.getUTCDate())}T${pad(
+    date.getUTCHours()
+  )}${pad(date.getUTCMinutes())}${pad(date.getUTCSeconds())}Z`;
+}
+function slugifyResultsTargetBranch(branch) {
+  return branch.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "results";
+}
+function randomResultsRefToken() {
+  return randomBytes(4).toString("hex").slice(0, 6);
+}
+function buildResultsSyncBranchName(targetBranch, token = randomResultsRefToken()) {
+  return `agentv/results-sync/${timestampForResultsRef()}-${slugifyResultsTargetBranch(
+    targetBranch
+  )}-${token}`;
+}
+function buildResultsCompareUrl(remoteUrl, targetBranch, syncBranch) {
+  if (!remoteUrl) {
+    return void 0;
   }
-  if (params.normalized.push_conflict_policy === "block") {
-    return {
-      blocked: true,
-      blockReason: buildBlockedPushConflictReason(baseDetails),
-      details: baseDetails
-    };
+  const match = remoteUrl.trim().match(/github\.com[:/]([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/i);
+  if (!match) {
+    return void 0;
   }
-  const backupRef = buildResultsBackupRef(params.targetBranch, remoteCommit);
-  const backupDetails = {
-    ...baseDetails,
-    backupRef,
-    backupCommit: remoteCommit
-  };
-  try {
-    await assertValidResultsBranchName(params.repoDir, backupRef);
-    await runGit(
-      ["push", "--porcelain", params.normalized.remote, `${remoteCommit}:refs/heads/${backupRef}`],
-      { cwd: params.repoDir }
-    );
-  } catch (error) {
-    return {
-      blocked: true,
-      blockReason: `Results branch backup creation failed for ${params.targetBranch} at ${formatShortSha(
-        remoteCommit
-      )}: ${getStatusMessage(error)}`,
-      details: backupDetails
-    };
+  const [, owner, repo] = match;
+  return `https://github.com/${owner}/${repo}/compare/${encodeURIComponent(
+    targetBranch
+  )}...${encodeURIComponent(syncBranch)}?expand=1`;
+}
+async function resolveRemotePushUrl(repoDir, remote) {
+  for (const args of [
+    ["remote", "get-url", "--push", remote],
+    ["remote", "get-url", remote]
+  ]) {
+    const { stdout, exitCode } = await runGit(args, { cwd: repoDir, check: false });
+    const url = stdout.trim();
+    if (exitCode === 0 && url.length > 0) {
+      return url;
+    }
+  }
+  return void 0;
+}
+async function countContributedRunDirs(repoDir, remoteTargetCommit, sourceCommit) {
+  if (!remoteTargetCommit) {
+    return void 0;
+  }
+  const { stdout, exitCode } = await runGit(
+    ["diff", "--name-only", `${remoteTargetCommit}...${sourceCommit}`, "--", RESULTS_REPO_RUNS_DIR],
+    { cwd: repoDir, check: false }
+  );
+  if (exitCode !== 0) {
+    return void 0;
+  }
+  const runDirs = /* @__PURE__ */ new Set();
+  for (const line of stdout.split(/\r?\n/)) {
+    const file = line.trim();
+    if (!file) {
+      continue;
+    }
+    const segments = file.split("/");
+    if (segments.length >= 2 && segments[0] && !segments[0].startsWith(".")) {
+      runDirs.add(segments[0]);
+    }
   }
+  return runDirs.size;
+}
+async function pushResultsSyncBranch(params) {
+  const { repoDir, remote, sourceCommit, targetBranch } = params;
+  const remoteTargetCommit = await getCommitSha(repoDir, remoteBranchRef(targetBranch, remote));
+  let syncBranch = buildResultsSyncBranchName(targetBranch);
+  await assertValidResultsBranchName(repoDir, syncBranch);
   try {
-    await runGit(
-      [
-        "push",
-        "--porcelain",
-        `--force-with-lease=refs/heads/${params.targetBranch}:${remoteCommit}`,
-        params.normalized.remote,
-        `${params.sourceRef}:refs/heads/${params.targetBranch}`
-      ],
-      { cwd: params.repoDir }
-    );
+    await runGit(["push", "--porcelain", remote, `${sourceCommit}:refs/heads/${syncBranch}`], {
+      cwd: repoDir
+    });
   } catch (error) {
-    return {
-      blocked: true,
-      blockReason: `Results branch force push lease failed for ${params.targetBranch}; remote changed after backup ${backupRef} was created with lease ${formatShortSha(
-        remoteCommit
-      )}: ${getStatusMessage(error)}`,
-      details: backupDetails
-    };
+    if (!isRefAlreadyExistsPushError(error)) {
+      throw error;
+    }
+    syncBranch = buildResultsSyncBranchName(targetBranch);
+    await assertValidResultsBranchName(repoDir, syncBranch);
+    await runGit(["push", "--porcelain", remote, `${sourceCommit}:refs/heads/${syncBranch}`], {
+      cwd: repoDir
+    });
   }
+  const compareUrl = buildResultsCompareUrl(
+    await resolveRemotePushUrl(repoDir, remote),
+    targetBranch,
+    syncBranch
+  );
+  const contributedRunCount = await countContributedRunDirs(
+    repoDir,
+    remoteTargetCommit,
+    sourceCommit
+  ).catch(() => void 0);
   return {
-    blocked: false,
-    details: {
-      ...backupDetails,
-      ...localCommit !== void 0 && { forcePushedCommit: localCommit }
+    tempBranch: syncBranch,
+    targetBranch,
+    ...compareUrl !== void 0 && { compareUrl },
+    ...contributedRunCount !== void 0 && { contributedRunCount },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function isRefAlreadyExistsPushError(error) {
+  const text = gitErrorText(error);
+  return text.includes("already exists") || text.includes("cannot lock ref") || text.includes("reference already exists");
+}
+async function mergeRemoteIntoCheckedOutBranch(repoDir, remoteCommit) {
+  const args = ["merge", "--no-edit", "-m", "chore(results): merge remote results", remoteCommit];
+  let result = await runGit(args, {
+    cwd: repoDir,
+    check: false,
+    env: configuredGitCommitIdentityEnv()
+  });
+  if (result.exitCode !== 0 && isMissingGitIdentityError({ stderr: result.stderr })) {
+    await runGit(["merge", "--abort"], { cwd: repoDir, check: false });
+    result = await runGit(args, {
+      cwd: repoDir,
+      check: false,
+      env: { ...configuredGitCommitIdentityEnv(), ...fallbackResultsRepoCommitEnv() }
+    });
+  }
+  return result.exitCode;
+}
+async function resolveResultBranchPushConflict(params) {
+  await ensureResultsMergeConfig(params.repoDir);
+  const { repoDir, targetBranch } = params;
+  const remote = params.normalized.remote;
+  const localRef = params.sourceRef;
+  const remoteRef = remoteBranchRef(targetBranch, remote);
+  const branchCheckedOut = params.sourceRef === "HEAD";
+  let lastDetails = {
+    pushConflictPolicy: params.normalized.push_conflict_policy,
+    targetBranch
+  };
+  const buildHumanMergeOutcome = async (reason, details) => {
+    if (!details.localCommit) {
+      return { blocked: true, blockReason: reason, details, syncStatus: "needs_human_merge" };
+    }
+    try {
+      const pendingMerge = await pushResultsSyncBranch({
+        repoDir,
+        remote,
+        sourceCommit: details.localCommit,
+        targetBranch: details.targetBranch
+      });
+      return {
+        blocked: true,
+        blockReason: reason,
+        details: { ...details, pendingMerge },
+        syncStatus: "needs_human_merge"
+      };
+    } catch (error) {
+      return {
+        blocked: true,
+        blockReason: `${reason} (could not create the temp branch for the GitHub merge: ${getStatusMessage(
+          error
+        )})`,
+        details,
+        syncStatus: "needs_human_merge"
+      };
     }
   };
+  for (let attempt = 1; attempt <= RESULTS_PUSH_MERGE_MAX_ATTEMPTS; attempt += 1) {
+    await fetchResultsRepo(repoDir, remote, targetBranch);
+    const remoteCommit = await getCommitSha(repoDir, remoteRef);
+    const localCommit = await getCommitSha(repoDir, localRef);
+    const details = {
+      pushConflictPolicy: params.normalized.push_conflict_policy,
+      targetBranch,
+      ...remoteCommit !== void 0 && { remoteCommit, previousRemoteCommit: remoteCommit },
+      ...localCommit !== void 0 && { localCommit }
+    };
+    lastDetails = details;
+    if (!remoteCommit) {
+      return {
+        blocked: true,
+        blockReason: `Results branch push conflict on ${targetBranch}: remote commit could not be resolved after fetch`,
+        details,
+        syncStatus: "push_conflict"
+      };
+    }
+    if (!localCommit) {
+      return {
+        blocked: true,
+        blockReason: `Results branch push conflict on ${targetBranch}: local commit could not be resolved`,
+        details,
+        syncStatus: "push_conflict"
+      };
+    }
+    if (await isAncestorCommit(repoDir, localCommit, remoteCommit)) {
+      if (branchCheckedOut) {
+        await runGit(["merge", "--ff-only", remoteCommit], { cwd: repoDir, check: false });
+      } else {
+        await runGit(["update-ref", localRef, remoteCommit, localCommit], {
+          cwd: repoDir,
+          check: false
+        });
+      }
+      return { blocked: false, details };
+    }
+    let pushSpec = branchCheckedOut ? "HEAD" : localCommit;
+    let autoMergedRemote = false;
+    if (!await isAncestorCommit(repoDir, remoteCommit, localCommit)) {
+      if (branchCheckedOut) {
+        const exitCode = await mergeRemoteIntoCheckedOutBranch(repoDir, remoteCommit);
+        if (exitCode !== 0) {
+          await runGit(["merge", "--abort"], { cwd: repoDir, check: false });
+          return await buildHumanMergeOutcome(
+            buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit),
+            details
+          );
+        }
+        pushSpec = "HEAD";
+        autoMergedRemote = true;
+      } else {
+        const base = await getMergeBaseCommit(repoDir, localCommit, remoteCommit);
+        if (!base) {
+          return await buildHumanMergeOutcome(
+            buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit),
+            details
+          );
+        }
+        const merge = await runGit(
+          ["merge-tree", "--write-tree", `--merge-base=${base}`, localCommit, remoteCommit],
+          { cwd: repoDir, check: false }
+        );
+        const mergedTree = merge.stdout.trim().split(/\r?\n/)[0]?.trim();
+        if (merge.exitCode !== 0 || !mergedTree) {
+          return await buildHumanMergeOutcome(
+            buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit),
+            details
+          );
+        }
+        const { stdout: mergeCommitOut } = await runGitWithFallbackCommitIdentity(
+          [
+            "commit-tree",
+            mergedTree,
+            "-p",
+            localCommit,
+            "-p",
+            remoteCommit,
+            "-m",
+            "chore(results): merge remote results"
+          ],
+          { cwd: repoDir }
+        );
+        pushSpec = mergeCommitOut.trim();
+        await runGit(["update-ref", localRef, pushSpec, localCommit], { cwd: repoDir });
+        autoMergedRemote = true;
+      }
+    }
+    try {
+      await runGit(["push", "--porcelain", remote, `${pushSpec}:refs/heads/${targetBranch}`], {
+        cwd: repoDir
+      });
+    } catch (error) {
+      if (isNonFastForwardPushError(error)) {
+        continue;
+      }
+      throw error;
+    }
+    const pushedCommit = await getCommitSha(repoDir, pushSpec) ?? localCommit;
+    return {
+      blocked: false,
+      details: {
+        ...details,
+        localCommit: pushedCommit,
+        ...autoMergedRemote && { autoMergedRemote }
+      }
+    };
+  }
+  return await buildHumanMergeOutcome(
+    `Results branch ${targetBranch} could not be reconciled after ${RESULTS_PUSH_MERGE_MAX_ATTEMPTS} attempts because the remote kept advancing; retry sync. The remote branch is unchanged.`,
+    lastDetails
+  );
 }
 async function statusFromInspection(normalized, repoDir) {
   return withGitInspection(
@@ -3087,11 +3398,7 @@ async function getResultsRepoSyncStatus(config) {
     };
   }
   try {
-    await ensureResultsRepoRemote(normalized.path, normalized);
     if (usesStorageBranchWorktree(normalized)) {
-      await fetchResultsRepo(normalized.path, normalized.remote, normalized.branch).catch(
-        () => void 0
-      );
       return withGitInspection(
         baseStatus,
         await inspectResultsStorageBranchGit(normalized.path, normalized)
@@ -3252,7 +3559,8 @@ async function syncResultsRepoForProject(config) {
           return withPushConflictStatus(status2, outcome.blockReason, outcome.details, {
             pullPerformed,
             pushPerformed,
-            commitCreated
+            commitCreated,
+            syncStatus: outcome.syncStatus
           });
         }
         pushPerformed = true;
@@ -3369,7 +3677,8 @@ async function syncResultsRepoForProject(config) {
                   return withPushConflictStatus(status2, outcome.blockReason, outcome.details, {
                     pullPerformed,
                     pushPerformed,
-                    commitCreated
+                    commitCreated,
+                    syncStatus: outcome.syncStatus
                   });
                 }
               } else {
@@ -3464,10 +3773,16 @@ async function syncResultsRepoForProject(config) {
         }
       }
       if (inspection.syncStatus === "dirty") {
-        const trackedDirs = await existingTrackedResultsDirs(repoDir);
-        await runGit(["add", "--all", "--", ...trackedDirs], { cwd: repoDir });
+        const trackedPathspecs = await existingTrackedResultsPathspecs(repoDir);
+        await runGit(["add", "--all", "--", ...trackedPathspecs], { cwd: repoDir });
         await runGitWithFallbackCommitIdentity(
-          ["commit", "-m", "chore(results): sync local result metadata", "--", ...trackedDirs],
+          [
+            "commit",
+            "-m",
+            "chore(results): sync local results branch changes",
+            "--",
+            ...trackedPathspecs
+          ],
           {
             cwd: repoDir
           }
@@ -3502,7 +3817,8 @@ async function syncResultsRepoForProject(config) {
         return withPushConflictStatus(status, outcome.blockReason, outcome.details, {
           pullPerformed,
           pushPerformed,
-          commitCreated
+          commitCreated,
+          syncStatus: outcome.syncStatus
         });
       }
       pushPerformed = true;
@@ -3587,7 +3903,8 @@ async function syncResultsRepoForProject(config) {
             return withPushConflictStatus(status, outcome.blockReason, outcome.details, {
               pullPerformed,
               pushPerformed,
-              commitCreated
+              commitCreated,
+              syncStatus: outcome.syncStatus
             });
           }
         } else {
@@ -3625,6 +3942,44 @@ async function syncResultsRepoForProject(config) {
     activeResultsRepoSyncs.delete(syncKey);
   }
 }
+async function fastForwardResultsTowardTarget(repoDir, normalized, targetBranch) {
+  const upstreamRef = remoteBranchRef(targetBranch, normalized.remote);
+  if (!await gitRefExists(repoDir, upstreamRef)) {
+    return;
+  }
+  const upstreamCommit = await getCommitSha(repoDir, upstreamRef);
+  if (!upstreamCommit) {
+    return;
+  }
+  if (usesStorageBranchWorktree(normalized) && normalized.branch) {
+    const localRef = `refs/heads/${normalized.branch}`;
+    if (!await gitRefExists(repoDir, localRef)) {
+      await runGit(["update-ref", localRef, upstreamCommit], { cwd: repoDir, check: false });
+      await runGit(["branch", "--set-upstream-to", upstreamRef, normalized.branch], {
+        cwd: repoDir,
+        check: false
+      });
+      return;
+    }
+    const localCommit = await getCommitSha(repoDir, localRef);
+    if (localCommit && await isAncestorCommit(repoDir, localCommit, upstreamCommit)) {
+      await runGit(["update-ref", localRef, upstreamCommit, localCommit], {
+        cwd: repoDir,
+        check: false
+      });
+    }
+    return;
+  }
+  await runGit(["merge", "--ff-only", upstreamRef], { cwd: repoDir, check: false });
+}
+async function confirmResultsMergeAndPull(config) {
+  const normalized = normalizeResultsConfig(config);
+  const repoDir = await ensureResultsRepoClone(normalized);
+  const targetBranch = normalized.branch ?? await resolveDefaultBranch(repoDir);
+  await fetchResultsRepo(repoDir, normalized.remote, normalized.branch).catch(() => void 0);
+  await fastForwardResultsTowardTarget(repoDir, normalized, targetBranch);
+  return syncResultsRepoForProject(config);
+}
 async function checkoutResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const repoDir = await ensureResultsRepoClone(normalized);
@@ -3783,12 +4138,10 @@ function artifactSidecarPointers(record) {
     return [];
   }
   const pointers = [];
-  for (const pointer of Object.values(record.artifact_pointers)) {
-    if (!isRecord2(pointer)) {
-      continue;
-    }
+  const pointer = record.artifact_pointers.transcript;
+  if (isRecord2(pointer)) {
     if (pointer.ref !== AGENTV_RESULTS_ARTIFACTS_REF || typeof pointer.path !== "string") {
-      continue;
+      return pointers;
     }
     pointers.push({
       path: pointer.path,
@@ -3805,17 +4158,58 @@ function artifactSidecarKey(destinationPath, pointerPath) {
     normalizeDestinationPath(pointerPath)
   );
 }
-function collectArtifactSidecarPointers(sourceDir) {
-  const indexPath = path4.join(sourceDir, RESULT_INDEX_FILENAME2);
-  if (!existsSync(indexPath)) {
-    return [];
+function isDeprecatedTraceArtifactPath(relativePath) {
+  return relativePath === "trace.json" || relativePath.endsWith("/trace.json");
+}
+function isResultManifestFilename(filename) {
+  return filename === RESULT_INDEX_FILENAME2;
+}
+function safeLocalSummaryManifestPath(sourceDir, manifestPath) {
+  if (typeof manifestPath !== "string" || manifestPath.trim().length === 0) {
+    return void 0;
   }
-  const pointers = [];
-  for (const line of readFileSync2(indexPath, "utf8").split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
+  if (path4.isAbsolute(manifestPath)) {
+    return void 0;
+  }
+  const normalized = path4.normalize(manifestPath);
+  if (normalized.startsWith("..") || path4.isAbsolute(normalized)) {
+    return void 0;
+  }
+  return path4.join(sourceDir, normalized);
+}
+function resolveLocalResultManifestPath(sourceDir) {
+  try {
+    const summary = JSON.parse(readFileSync2(path4.join(sourceDir, "summary.json"), "utf8"));
+    const manifestPath2 = safeLocalSummaryManifestPath(
+      sourceDir,
+      summary.index_path ?? summary.manifest_path
+    );
+    if (manifestPath2 && existsSync(manifestPath2)) {
+      return manifestPath2;
+    }
+  } catch {
+  }
+  const manifestPath = path4.join(sourceDir, RUN_INTERNAL_DIRNAME, RESULT_INDEX_FILENAME2);
+  if (existsSync(manifestPath)) {
+    return manifestPath;
+  }
+  const legacyManifestPath = path4.join(sourceDir, RESULT_INDEX_FILENAME2);
+  if (existsSync(legacyManifestPath)) {
+    return legacyManifestPath;
+  }
+  return void 0;
+}
+function collectArtifactSidecarPointers(sourceDir) {
+  const indexPath = resolveLocalResultManifestPath(sourceDir);
+  if (!indexPath) {
+    return [];
+  }
+  const pointers = [];
+  for (const line of readFileSync2(indexPath, "utf8").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
     try {
       pointers.push(...artifactSidecarPointers(JSON.parse(trimmed)));
     } catch {
@@ -3894,18 +4288,20 @@ function rewritePublishedIndexLine(line, destinationPath) {
     return line;
   }
   let changed = false;
-  for (const pointer of Object.values(record.artifact_pointers)) {
-    if (!isRecord2(pointer)) {
-      continue;
-    }
-    if (pointer.ref !== AGENTV_RESULTS_ARTIFACTS_REF || typeof pointer.path !== "string") {
-      continue;
-    }
+  const pointer = record.artifact_pointers.transcript;
+  if (isRecord2(pointer) && pointer.ref === AGENTV_RESULTS_ARTIFACTS_REF && typeof pointer.path === "string") {
     const key = artifactSidecarKey(destinationPath, pointer.path);
     if (pointer.key !== key) {
       pointer.key = key;
       changed = true;
     }
+    if (Object.keys(record.artifact_pointers).length !== 1 || record.artifact_pointers.transcript !== pointer) {
+      changed = true;
+    }
+    record.artifact_pointers = { transcript: pointer };
+  } else {
+    record.artifact_pointers = void 0;
+    changed = true;
   }
   return changed ? JSON.stringify(record) : line;
 }
@@ -3922,13 +4318,16 @@ async function preparePublishedResultsSource(params) {
     for (const sourceFile of sourceFiles) {
       const relativeFile = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
       const destinationFile = path4.join(publishedRoot, ...relativeFile.split("/"));
-      if (relativeFile === RESULT_INDEX_FILENAME2) {
+      if (isResultManifestFilename(path4.posix.basename(relativeFile))) {
         const original = readFileSync2(sourceFile, "utf8");
         const rewritten = original.split(/\r?\n/).map((line) => rewritePublishedIndexLine(line, params.destinationPath)).join("\n");
         mkdirSync(path4.dirname(destinationFile), { recursive: true });
         writeFileSync(destinationFile, rewritten);
         continue;
       }
+      if (isDeprecatedTraceArtifactPath(relativeFile)) {
+        continue;
+      }
       if (omittedPaths.has(relativeFile)) {
         continue;
       }
@@ -4008,6 +4407,7 @@ async function commitStorageBranchWorktreePaths(params) {
     } else {
       await runGit(["read-tree", "--empty"], { cwd: params.repoDir, env: indexEnv });
     }
+    await addResultsGitattributesToIndex(params.repoDir, indexEnv);
     for (const gitPath of paths) {
       const sourcePath = path4.join(params.repoDir, ...gitPath.split("/"));
       if (!existsSync(sourcePath)) {
@@ -4098,6 +4498,7 @@ async function commitResultsRunWithTemporaryIndex(params) {
     } else {
       await runGit(["read-tree", "--empty"], { cwd: params.repoDir, env: indexEnv });
     }
+    await addResultsGitattributesToIndex(params.repoDir, indexEnv);
     const existingPaths = await getExistingRunTreePaths(
       params.repoDir,
       base.baseRef,
@@ -4189,7 +4590,7 @@ function buildDirectPushResult(normalized, changed, outcome) {
     ...outcome?.blocked === true && {
       blocked: true,
       block_reason: outcome.blockReason,
-      sync_status: "push_conflict"
+      sync_status: outcome.syncStatus ?? "push_conflict"
     },
     ...pushDetailsToWire(details)
   };
@@ -4199,10 +4600,11 @@ function mergeDirectPushResults(normalized, results) {
   if (blocked) {
     return blocked;
   }
-  const detailed = [...results].reverse().find((result) => result.backup_ref !== void 0);
+  const detailed = [...results].reverse().find((result) => result.backup_ref !== void 0 || result.auto_merged_remote === true);
   return {
     changed: results.some((result) => result.changed),
     push_conflict_policy: normalized.push_conflict_policy,
+    ...detailed?.auto_merged_remote === true && { auto_merged_remote: true },
     ...detailed?.backup_ref !== void 0 && {
       backup_ref: detailed.backup_ref
     },
@@ -4385,21 +4787,74 @@ async function directPushResultsWithDetails(params) {
     await sidecar?.cleanup().catch(() => void 0);
   }
 }
+function safeGitSummaryManifestPath(runDir, manifestPath) {
+  if (typeof manifestPath !== "string" || manifestPath.trim().length === 0) {
+    return void 0;
+  }
+  if (manifestPath.startsWith("/")) {
+    return void 0;
+  }
+  const normalized = path4.posix.normalize(manifestPath);
+  if (normalized === ".." || normalized.startsWith("../")) {
+    return void 0;
+  }
+  return path4.posix.join(runDir, normalized);
+}
+function buildGitManifestPaths(treePaths, summaryByPath) {
+  const treePathSet = new Set(treePaths);
+  const manifestByRunDir = /* @__PURE__ */ new Map();
+  for (const [summaryPath, summary] of summaryByPath) {
+    const runDir = path4.posix.dirname(summaryPath);
+    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    if (!isV2ResultsRepoRunPath(relativeRunPath)) {
+      continue;
+    }
+    const manifestPath = safeGitSummaryManifestPath(runDir, summary.index_path ?? summary.manifest_path) ?? fallbackGitManifestPath(runDir, treePathSet);
+    if (manifestPath && treePathSet.has(manifestPath)) {
+      manifestByRunDir.set(runDir, manifestPath);
+    }
+  }
+  for (const treePath of treePaths) {
+    if (!treePath.endsWith(`/${RESULT_INDEX_FILENAME2}`)) {
+      continue;
+    }
+    const runDir = gitRunDirForManifestPath(treePath);
+    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    if (!isV2ResultsRepoRunPath(relativeRunPath)) {
+      continue;
+    }
+    if (!manifestByRunDir.has(runDir)) {
+      manifestByRunDir.set(runDir, treePath);
+    }
+  }
+  return [...manifestByRunDir.values()].sort();
+}
+function fallbackGitManifestPath(runDir, treePathSet) {
+  for (const candidate of [
+    path4.posix.join(runDir, ".internal", RESULT_INDEX_FILENAME2),
+    path4.posix.join(runDir, RESULT_INDEX_FILENAME2)
+  ]) {
+    if (treePathSet.has(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function gitRunDirForManifestPath(manifestPath) {
+  const manifestDir = path4.posix.dirname(manifestPath);
+  return path4.posix.basename(manifestDir) === ".internal" ? path4.posix.dirname(manifestDir) : manifestDir;
+}
+function isV2ResultsRepoRunPath(relativeRunPath) {
+  const segments = relativeRunPath.split("/").filter(Boolean);
+  return segments.length === 1 && !segments[0].startsWith(".");
+}
 function buildGitRunId(relativeRunPath) {
   const normalized = relativeRunPath.split(path4.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
-  if (segments.length >= 2) {
-    const experiment = segments.slice(0, -1).join("/");
-    const timestamp = segments.at(-1);
-    if (experiment === "default") {
-      return timestamp ?? normalized;
-    }
-    return `${experiment}::${timestamp}`;
-  }
   return segments[0] ?? relativeRunPath;
 }
-function getRunExperiment(runId, benchmark) {
-  const experiment = benchmark.metadata?.experiment?.trim();
+function getRunExperiment(runId, summary) {
+  const experiment = summary?.metadata?.experiment?.trim();
   if (experiment) {
     return experiment;
   }
@@ -4572,8 +5027,11 @@ async function pushWipCheckpoint(params) {
     sourceDir: params.sourceDir,
     destinationDir
   });
-  const trackedDirs = await existingTrackedResultsDirs(params.handle.worktreeDir);
-  await runGit(["add", "--all", "--", ...trackedDirs], {
+  writeFileSync(
+    path4.join(params.handle.worktreeDir, RESULTS_REPO_GITATTRIBUTES_FILE),
+    RESULTS_REPO_GITATTRIBUTES_CONTENT
+  );
+  await runGit(["add", "--all", "--", RESULTS_REPO_GITATTRIBUTES_FILE, params.destinationPath], {
     cwd: params.handle.worktreeDir
   });
   const { stdout: status } = await runGit(["status", "--porcelain"], {
@@ -4596,7 +5054,19 @@ async function pushWipCheckpoint(params) {
 async function deleteWipBranch(params) {
   const normalized = normalizeResultsConfig(params.config);
   const cloneDir = await ensureResultsRepoClone(normalized);
-  await runGit(["push", normalized.remote, "--delete", params.wipBranch], { cwd: cloneDir });
+  const result = await runGit(["push", normalized.remote, "--delete", params.wipBranch], {
+    cwd: cloneDir,
+    check: false
+  });
+  if (result.exitCode === 0 || isMissingRemoteRefDelete(result)) {
+    return;
+  }
+  throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to delete WIP branch");
+}
+function isMissingRemoteRefDelete(result) {
+  const text = `${result.stderr}
+${result.stdout}`.toLowerCase();
+  return text.includes("remote ref does not exist");
 }
 function isMissingGitRefError(error) {
   const parts = [];
@@ -4608,7 +5078,107 @@ function isMissingGitRefError(error) {
     parts.push(error);
   }
   const haystack = parts.join("\n").toLowerCase();
-  return haystack.includes("not a valid object name") || haystack.includes("unknown revision or path") || haystack.includes("bad revision") || haystack.includes("does not exist");
+  return haystack.includes("not a valid object name") || haystack.includes("unknown revision or path") || haystack.includes("bad revision") || haystack.includes("does not exist") || haystack.includes("needed a single revision");
+}
+function gitResultsIndexHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function resolveGitResultsIndexRepoDir(repoDir) {
+  const resolved = path4.resolve(repoDir);
+  try {
+    return realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function gitResultsIndexRepoKey(repoDir) {
+  return `sha256-${gitResultsIndexHash(resolveGitResultsIndexRepoDir(repoDir)).slice(0, 32)}`;
+}
+function gitResultsIndexRefKey(ref) {
+  const slug = sanitizeRepoSlug(ref).slice(0, 80) || "default";
+  return `${slug}-${gitResultsIndexHash(ref).slice(0, 16)}`;
+}
+function resolveGitResultsIndexCacheFile(params) {
+  const ref = params.ref ?? "origin/main";
+  return path4.join(
+    getAgentvDataDir(),
+    "cache",
+    "results-index",
+    gitResultsIndexRepoKey(params.repoDir),
+    gitResultsIndexRefKey(ref),
+    `${params.commitSha}.json`
+  );
+}
+function isGitListedRun(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.run_id === "string" && typeof record.experiment === "string" && typeof record.timestamp === "string" && (typeof record.index_path === "string" || typeof record.manifest_path === "string") && typeof record.display_name === "string" && typeof record.test_count === "number" && typeof record.avg_score === "number" && typeof record.size_bytes === "number" && (record.execution_error_count === void 0 || typeof record.execution_error_count === "number") && (record.pass_rate === void 0 || typeof record.pass_rate === "number") && (record.target === void 0 || typeof record.target === "string") && (record.summary_path === void 0 || typeof record.summary_path === "string");
+}
+function validateGitResultsIndexCacheFile(value, params) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const repoDir = resolveGitResultsIndexRepoDir(params.repoDir);
+  const repoKey = gitResultsIndexRepoKey(params.repoDir);
+  if (record.schema_version !== GIT_RESULTS_INDEX_CACHE_SCHEMA_VERSION || record.result_layout_version !== GIT_RESULTS_INDEX_LAYOUT_VERSION || record.repo_key !== repoKey || record.repo_dir !== repoDir || record.ref !== params.ref || record.commit_sha !== params.commitSha || !Array.isArray(record.runs) || !record.runs.every(isGitListedRun)) {
+    return void 0;
+  }
+  return value;
+}
+async function readGitResultsIndexCache(params) {
+  const cacheFile = resolveGitResultsIndexCacheFile(params);
+  try {
+    const parsed = JSON.parse(await readFile2(cacheFile, "utf8"));
+    return validateGitResultsIndexCacheFile(parsed, params)?.runs;
+  } catch {
+    return void 0;
+  }
+}
+async function writeGitResultsIndexCache(params) {
+  const cacheFile = resolveGitResultsIndexCacheFile(params);
+  const envelope = {
+    schema_version: GIT_RESULTS_INDEX_CACHE_SCHEMA_VERSION,
+    result_layout_version: GIT_RESULTS_INDEX_LAYOUT_VERSION,
+    repo_key: gitResultsIndexRepoKey(params.repoDir),
+    repo_dir: resolveGitResultsIndexRepoDir(params.repoDir),
+    ref: params.ref,
+    commit_sha: params.commitSha,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    runs: params.runs
+  };
+  try {
+    mkdirSync(path4.dirname(cacheFile), { recursive: true });
+    const tempFile = `${cacheFile}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tempFile, `${JSON.stringify(envelope, null, 2)}
+`, "utf8");
+    renameSync(tempFile, cacheFile);
+  } catch {
+  }
+}
+async function resolveGitRunsRefCommit(repoDir, ref = "origin/main") {
+  try {
+    const { stdout } = await runGit(["rev-parse", "--verify", `${ref}^{commit}`], {
+      cwd: repoDir
+    });
+    return stdout.trim() || void 0;
+  } catch (error) {
+    if (isMissingGitRefError(error)) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function listGitRunsCached(repoDir, ref = "origin/main") {
+  const commitSha = await resolveGitRunsRefCommit(repoDir, ref);
+  if (!commitSha) {
+    return [];
+  }
+  const cached = await readGitResultsIndexCache({ repoDir, ref, commitSha });
+  if (cached) {
+    return [...cached];
+  }
+  const runs = await listGitRuns(repoDir, ref);
+  await writeGitResultsIndexCache({ repoDir, ref, commitSha, runs });
+  return runs;
 }
 async function listGitRuns(repoDir, ref = "origin/main") {
   let treeOut;
@@ -4625,40 +5195,78 @@ async function listGitRuns(repoDir, ref = "origin/main") {
     }
     throw error;
   }
-  const benchmarkPaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.endsWith("/benchmark.json"));
-  if (benchmarkPaths.length === 0) {
+  const treePaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const summaryPaths = treePaths.filter((line) => line.endsWith("/summary.json"));
+  const summaryByPath = /* @__PURE__ */ new Map();
+  if (summaryPaths.length > 0) {
+    const summaryBatchInput = `${summaryPaths.map((summaryPath) => `${ref}:${summaryPath}`).join("\n")}
+`;
+    const summaryBlobs = parseGitBatchBlobs(await runGitBatch(repoDir, summaryBatchInput));
+    for (let i = 0; i < summaryBlobs.length; i++) {
+      const summaryPath = summaryPaths[i];
+      const blob = summaryBlobs[i];
+      if (!summaryPath || !blob) continue;
+      summaryByPath.set(summaryPath, JSON.parse(blob.content.toString("utf8")));
+    }
+  }
+  const indexPaths = buildGitManifestPaths(treePaths, summaryByPath);
+  if (indexPaths.length === 0) {
     return [];
   }
-  const batchInput = `${benchmarkPaths.map((benchmarkPath) => `${ref}:${benchmarkPath}`).join("\n")}
+  const batchInput = `${indexPaths.map((indexPath) => `${ref}:${indexPath}`).join("\n")}
 `;
   const blobs = parseGitBatchBlobs(await runGitBatch(repoDir, batchInput));
-  if (blobs.length !== benchmarkPaths.length) {
+  if (blobs.length !== indexPaths.length) {
     throw new Error(
-      `Expected ${benchmarkPaths.length} git blobs but received ${blobs.length} while listing results runs`
+      `Expected ${indexPaths.length} git blobs but received ${blobs.length} while listing results runs`
     );
   }
   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 manifestPath = indexPaths[index];
+    const runDir = gitRunDirForManifestPath(manifestPath);
+    const summaryPath = path4.posix.join(runDir, "summary.json");
+    const summary = summaryByPath.get(summaryPath);
     const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     const runId = buildGitRunId(relativeRunPath);
-    const timestamp = benchmark.metadata?.timestamp?.trim() || path4.posix.basename(runDir);
-    const displayName = benchmark.metadata?.display_name?.trim() || path4.posix.basename(runDir);
-    const targets = benchmark.metadata?.targets ?? [];
-    const passRate = computeAveragePassRate(benchmark.run_summary);
+    const rows = blob.content.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap(
+      (line) => {
+        try {
+          return [
+            JSON.parse(line)
+          ];
+        } catch {
+          return [];
+        }
+      }
+    );
+    const rowTargets = [
+      ...new Set(rows.map((row) => row.target).filter((target) => !!target))
+    ];
+    const rowTestIds = [
+      ...new Set(rows.map((row) => row.test_id).filter((testId) => !!testId))
+    ];
+    const rowScores = rows.map((row) => row.score).filter((score) => typeof score === "number" && Number.isFinite(score));
+    const avgScore = rowScores.length > 0 ? rowScores.reduce((sum, score) => sum + score, 0) / rowScores.length : 0;
+    const timestamp = summary?.metadata?.timestamp?.trim() || rows[0]?.timestamp || path4.posix.basename(runDir);
+    const displayName = summary?.metadata?.display_name?.trim() || path4.posix.basename(runDir);
+    const targets = summary?.metadata?.targets ?? rowTargets;
+    const passRate = computeAveragePassRate(summary?.run_summary) ?? avgScore;
+    const executionErrorCount = rows.filter(
+      (row) => row.execution_status === "execution_error"
+    ).length;
     return [
       {
         run_id: runId,
-        experiment: getRunExperiment(runId, benchmark),
+        experiment: getRunExperiment(runId, summary),
         timestamp,
         ...passRate !== void 0 && { pass_rate: passRate },
         ...targets.length === 1 && targets[0] ? { target: targets[0] } : {},
-        manifest_path: path4.posix.join(runDir, "index.jsonl"),
-        benchmark_path: benchmarkPath,
+        index_path: manifestPath,
+        ...summaryByPath.has(summaryPath) && { summary_path: summaryPath },
         display_name: displayName,
-        test_count: benchmark.metadata?.tests_run?.length ?? 0,
-        avg_score: 0,
+        test_count: summary?.metadata?.tests_run?.length ?? rowTestIds.length,
+        ...executionErrorCount > 0 && { execution_error_count: executionErrorCount },
+        avg_score: avgScore,
         size_bytes: blob.size
       }
     ];
@@ -4776,483 +5384,6 @@ function trimBaselineResult(result) {
   }
   return trimmed;
 }
-var DEFAULT_CATEGORY = "Uncategorized";
-function deriveCategory(relativePath) {
-  const parts = relativePath.split(/[/\\]/);
-  if (parts.length <= 1) {
-    return DEFAULT_CATEGORY;
-  }
-  const dirs = parts.slice(0, -1).filter((d) => d !== "evals");
-  return dirs.length > 0 ? dirs.join("/") : DEFAULT_CATEGORY;
-}
-var OtelTraceExporter = class {
-  constructor(options) {
-    this.options = options;
-  }
-  provider = null;
-  tracer = null;
-  api = null;
-  // biome-ignore lint/suspicious/noExplicitAny: OTel types loaded dynamically
-  W3CPropagator = null;
-  /** Initialize the OTel SDK. Returns false if OTel packages are not available. */
-  async init() {
-    try {
-      const [sdkTraceNode, resourcesMod, semconvMod, api, coreMod] = await Promise.all([
-        import("./src-76ISS3LH.js"),
-        import("./esm-NNMQYIKT.js"),
-        import("./esm-RVQPUGWH.js"),
-        import("./esm-R77SNOF5.js"),
-        import("./esm-ZADQ4XQH-QUFGGZL4.js").catch(() => null)
-      ]);
-      const { NodeTracerProvider: Provider, SimpleSpanProcessor } = sdkTraceNode;
-      const { resourceFromAttributes } = resourcesMod;
-      const { ATTR_SERVICE_NAME } = semconvMod;
-      const resourceAttributes = {
-        [ATTR_SERVICE_NAME]: this.options.serviceName ?? "agentv",
-        ...this.options.resourceAttributes
-      };
-      const resource = resourceFromAttributes(resourceAttributes);
-      const processors = [];
-      if (this.options.endpoint) {
-        const otlpHttp = await import("./esm-TTEMJEVV.js");
-        const { OTLPTraceExporter } = otlpHttp;
-        const exporter = new OTLPTraceExporter({
-          url: this.options.endpoint,
-          headers: this.options.headers
-        });
-        processors.push(new SimpleSpanProcessor(exporter));
-      }
-      if (this.options.otlpFilePath) {
-        const { OtlpJsonFileExporter: OtlpJsonFileExporter2 } = await import("./otlp-json-file-exporter-RY63S3IG-PZBQPVYY.js");
-        processors.push(
-          new SimpleSpanProcessor(
-            new OtlpJsonFileExporter2(this.options.otlpFilePath, resourceAttributes)
-          )
-        );
-      }
-      if (processors.length === 0) {
-        return false;
-      }
-      this.provider = new Provider({
-        resource,
-        spanProcessors: processors
-      });
-      this.provider.register();
-      this.api = api;
-      this.tracer = api.trace.getTracer("agentv", "1.0.0");
-      this.W3CPropagator = coreMod?.W3CTraceContextPropagator ?? null;
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /** Export a single evaluation result as an OTel trace. */
-  async exportResult(result) {
-    if (!this.tracer || !this.api) return;
-    const api = this.api;
-    const tracer = this.tracer;
-    const captureContent = this.options.captureContent ?? false;
-    const startHr = toHrTime(result.startTime ?? result.timestamp);
-    const endHr = toHrTime(result.endTime ?? result.timestamp);
-    let parentCtx = api.ROOT_CONTEXT;
-    const traceparent = process.env.TRACEPARENT;
-    if (traceparent && this.W3CPropagator) {
-      try {
-        const propagator = new this.W3CPropagator();
-        parentCtx = propagator.extract(
-          api.ROOT_CONTEXT,
-          { traceparent, tracestate: process.env.TRACESTATE ?? "" },
-          {
-            get: (carrier, key) => carrier[key],
-            keys: (carrier) => Object.keys(carrier)
-          }
-        );
-      } catch {
-      }
-    }
-    tracer.startActiveSpan(
-      "agentv.eval",
-      { startTime: startHr },
-      parentCtx,
-      (rootSpan) => {
-        rootSpan.setAttribute("gen_ai.operation.name", "evaluate");
-        rootSpan.setAttribute("gen_ai.system", "agentv");
-        rootSpan.setAttribute("agentv.test_id", result.testId);
-        rootSpan.setAttribute("agentv.target", result.target);
-        if (result.suite) rootSpan.setAttribute("agentv.suite", result.suite);
-        rootSpan.setAttribute("agentv.score", result.score);
-        if (captureContent && result.output.length > 0) {
-          rootSpan.setAttribute("agentv.output_text", result.output);
-        }
-        if (result.durationMs != null)
-          rootSpan.setAttribute("agentv.trace.duration_ms", result.durationMs);
-        if (result.costUsd != null) rootSpan.setAttribute("agentv.trace.cost_usd", result.costUsd);
-        if (result.tokenUsage) {
-          if (result.tokenUsage.input != null) {
-            rootSpan.setAttribute("agentv.trace.token_input", result.tokenUsage.input);
-          }
-          if (result.tokenUsage.output != null) {
-            rootSpan.setAttribute("agentv.trace.token_output", result.tokenUsage.output);
-          }
-          if (result.tokenUsage.cached != null) {
-            rootSpan.setAttribute("agentv.trace.token_cached", result.tokenUsage.cached);
-          }
-        }
-        if (result.trace) {
-          const t = result.trace;
-          rootSpan.setAttribute("agentv.trace.event_count", t.eventCount);
-          rootSpan.setAttribute(
-            "agentv.trace.tool_names",
-            Object.keys(t.toolCalls).sort().join(",")
-          );
-          if (t.llmCallCount != null)
-            rootSpan.setAttribute("agentv.trace.llm_call_count", t.llmCallCount);
-        }
-        const traceMessages = result.trace?.messages ?? [];
-        if (traceMessages.length > 0) {
-          const parentCtx2 = api.trace.setSpan(api.context.active(), rootSpan);
-          if (this.options.groupTurns) {
-            const turns = groupMessagesIntoTurns(traceMessages);
-            if (turns.length > 1) {
-              for (const [i, turn] of turns.entries()) {
-                api.context.with(parentCtx2, () => {
-                  tracer.startActiveSpan(
-                    `agentv.turn.${i + 1}`,
-                    {},
-                    (turnSpan) => {
-                      const turnCtx = api.trace.setSpan(api.context.active(), turnSpan);
-                      for (const msg of turn.messages) {
-                        this.exportMessage(tracer, api, turnCtx, msg, captureContent);
-                      }
-                      turnSpan.end();
-                    }
-                  );
-                });
-              }
-            } else {
-              for (const msg of traceMessages) {
-                this.exportMessage(tracer, api, parentCtx2, msg, captureContent);
-              }
-            }
-          } else {
-            for (const msg of traceMessages) {
-              this.exportMessage(tracer, api, parentCtx2, msg, captureContent);
-            }
-          }
-        }
-        if (result.scores) {
-          for (const score of result.scores) {
-            rootSpan.addEvent(`agentv.grader.${score.name}`, {
-              "agentv.grader.score": score.score,
-              "agentv.grader.type": score.type,
-              ...score.verdict ? { "agentv.grader.verdict": score.verdict } : {}
-            });
-          }
-        }
-        if (result.error) {
-          rootSpan.setStatus({ code: api.SpanStatusCode.ERROR, message: result.error });
-        } else {
-          rootSpan.setStatus({ code: api.SpanStatusCode.OK });
-        }
-        rootSpan.end(endHr);
-      }
-    );
-  }
-  /** Flush pending spans and shut down. */
-  async shutdown() {
-    await this.provider?.shutdown();
-  }
-  /** Create a streaming observer for real-time span export */
-  createStreamingObserver() {
-    if (!this.tracer || !this.api) return null;
-    let parentCtx;
-    const traceparent = process.env.TRACEPARENT;
-    if (traceparent && this.W3CPropagator) {
-      try {
-        const propagator = new this.W3CPropagator();
-        parentCtx = propagator.extract(
-          this.api.ROOT_CONTEXT,
-          { traceparent, tracestate: process.env.TRACESTATE ?? "" },
-          {
-            get: (carrier, key) => carrier[key],
-            keys: (carrier) => Object.keys(carrier)
-          }
-        );
-      } catch {
-      }
-    }
-    return new OtelStreamingObserver(
-      this.tracer,
-      this.api,
-      this.options.captureContent ?? false,
-      parentCtx
-    );
-  }
-  // -----------------------------------------------------------------------
-  // Private helpers
-  // -----------------------------------------------------------------------
-  exportMessage(tracer, api, parentCtx, msg, captureContent) {
-    const isAssistant = msg.role === "assistant";
-    const model = msg.metadata?.model ? String(msg.metadata.model) : void 0;
-    const spanName = isAssistant ? `chat ${model ?? "unknown"}` : `gen_ai.message.${msg.role}`;
-    const startHr = toHrTime(msg.startTime);
-    const endHr = toHrTime(msg.endTime);
-    api.context.with(parentCtx, () => {
-      tracer.startActiveSpan(
-        spanName,
-        { startTime: startHr },
-        parentCtx,
-        (span) => {
-          if (isAssistant) {
-            span.setAttribute("gen_ai.operation.name", "chat");
-          }
-          if (model) {
-            span.setAttribute("gen_ai.request.model", model);
-            span.setAttribute("gen_ai.response.model", model);
-          }
-          if (msg.tokenUsage) {
-            if (msg.tokenUsage.input != null) {
-              span.setAttribute("gen_ai.usage.input_tokens", msg.tokenUsage.input);
-            }
-            if (msg.tokenUsage.output != null) {
-              span.setAttribute("gen_ai.usage.output_tokens", msg.tokenUsage.output);
-            }
-            if (msg.tokenUsage.cached != null) {
-              span.setAttribute("gen_ai.usage.cache_read.input_tokens", msg.tokenUsage.cached);
-            }
-          }
-          if (captureContent && msg.content != null) {
-            span.setAttribute(
-              "gen_ai.output.messages",
-              typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
-            );
-          }
-          if (msg.toolCalls) {
-            const msgCtx = api.trace.setSpan(api.context.active(), span);
-            for (const tc of msg.toolCalls) {
-              api.context.with(msgCtx, () => {
-                tracer.startActiveSpan(
-                  `execute_tool ${tc.tool}`,
-                  {},
-                  msgCtx,
-                  (toolSpan) => {
-                    toolSpan.setAttribute("gen_ai.tool.name", tc.tool);
-                    if (tc.id) toolSpan.setAttribute("gen_ai.tool.call.id", tc.id);
-                    if (captureContent) {
-                      if (tc.input != null) {
-                        toolSpan.setAttribute(
-                          "gen_ai.tool.call.arguments",
-                          typeof tc.input === "string" ? tc.input : JSON.stringify(tc.input)
-                        );
-                      }
-                      if (tc.output != null) {
-                        toolSpan.setAttribute(
-                          "gen_ai.tool.call.result",
-                          typeof tc.output === "string" ? tc.output : JSON.stringify(tc.output)
-                        );
-                      }
-                    }
-                    toolSpan.end();
-                  }
-                );
-              });
-            }
-          }
-          span.end(endHr);
-        }
-      );
-    });
-  }
-};
-var OtelStreamingObserver = class {
-  constructor(tracer, api, captureContent, parentCtx) {
-    this.tracer = tracer;
-    this.api = api;
-    this.captureContent = captureContent;
-    this.parentCtx = parentCtx;
-  }
-  // biome-ignore lint/suspicious/noExplicitAny: OTel span type loaded dynamically
-  rootSpan = null;
-  // biome-ignore lint/suspicious/noExplicitAny: OTel context loaded dynamically
-  rootCtx = null;
-  observedChildSpans = false;
-  pendingMetrics = null;
-  /** Create root eval span immediately (visible in backend right away) */
-  startEvalCase(testId, target, evalSet) {
-    this.pendingMetrics = null;
-    this.observedChildSpans = false;
-    const ctx = this.parentCtx ?? this.api.context.active();
-    this.rootSpan = this.tracer.startSpan("agentv.eval", void 0, ctx);
-    this.rootSpan.setAttribute("gen_ai.operation.name", "evaluate");
-    this.rootSpan.setAttribute("gen_ai.system", "agentv");
-    this.rootSpan.setAttribute("agentv.test_id", testId);
-    this.rootSpan.setAttribute("agentv.target", target);
-    if (evalSet) this.rootSpan.setAttribute("agentv.suite", evalSet);
-    this.rootCtx = this.api.trace.setSpan(this.api.context.active(), this.rootSpan);
-  }
-  /** Create and immediately export a tool span */
-  onToolCall(name, input, output, _durationMs, toolCallId) {
-    if (!this.rootCtx) return;
-    this.observedChildSpans = true;
-    this.api.context.with(this.rootCtx, () => {
-      const span = this.tracer.startSpan(`execute_tool ${name}`, void 0, this.rootCtx);
-      span.setAttribute("gen_ai.tool.name", name);
-      if (toolCallId) span.setAttribute("gen_ai.tool.call.id", toolCallId);
-      if (this.captureContent) {
-        if (input != null)
-          span.setAttribute(
-            "gen_ai.tool.call.arguments",
-            typeof input === "string" ? input : JSON.stringify(input)
-          );
-        if (output != null)
-          span.setAttribute(
-            "gen_ai.tool.call.result",
-            typeof output === "string" ? output : JSON.stringify(output)
-          );
-      }
-      span.end();
-    });
-  }
-  /** Create and immediately export an LLM span */
-  onLlmCall(model, tokenUsage) {
-    if (!this.rootCtx) return;
-    this.observedChildSpans = true;
-    this.api.context.with(this.rootCtx, () => {
-      const span = this.tracer.startSpan(`chat ${model}`, void 0, this.rootCtx);
-      span.setAttribute("gen_ai.operation.name", "chat");
-      span.setAttribute("gen_ai.request.model", model);
-      span.setAttribute("gen_ai.response.model", model);
-      if (tokenUsage) {
-        if (tokenUsage.input != null)
-          span.setAttribute("gen_ai.usage.input_tokens", tokenUsage.input);
-        if (tokenUsage.output != null)
-          span.setAttribute("gen_ai.usage.output_tokens", tokenUsage.output);
-        if (tokenUsage.cached != null)
-          span.setAttribute("gen_ai.usage.cache_read.input_tokens", tokenUsage.cached);
-      }
-      span.end();
-    });
-  }
-  /** Record final execution metrics before the root span is finalized. */
-  recordEvalMetrics(result) {
-    this.pendingMetrics = result;
-  }
-  /** Finalize root span with score/verdict after evaluation completes */
-  finalizeEvalCase(score, error) {
-    if (!this.rootSpan) return;
-    this.rootSpan.setAttribute("agentv.score", score);
-    if (this.pendingMetrics?.durationMs != null) {
-      this.rootSpan.setAttribute("agentv.trace.duration_ms", this.pendingMetrics.durationMs);
-    }
-    if (this.pendingMetrics?.costUsd != null) {
-      this.rootSpan.setAttribute("agentv.trace.cost_usd", this.pendingMetrics.costUsd);
-    }
-    if (this.pendingMetrics?.tokenUsage) {
-      if (this.pendingMetrics.tokenUsage.input != null) {
-        this.rootSpan.setAttribute(
-          "agentv.trace.token_input",
-          this.pendingMetrics.tokenUsage.input
-        );
-      }
-      if (this.pendingMetrics.tokenUsage.output != null) {
-        this.rootSpan.setAttribute(
-          "agentv.trace.token_output",
-          this.pendingMetrics.tokenUsage.output
-        );
-      }
-      if (this.pendingMetrics.tokenUsage.cached != null) {
-        this.rootSpan.setAttribute(
-          "agentv.trace.token_cached",
-          this.pendingMetrics.tokenUsage.cached
-        );
-      }
-    }
-    if (this.pendingMetrics?.trace) {
-      this.rootSpan.setAttribute("agentv.trace.event_count", this.pendingMetrics.trace.eventCount);
-      this.rootSpan.setAttribute(
-        "agentv.trace.tool_names",
-        Object.keys(this.pendingMetrics.trace.toolCalls).sort().join(",")
-      );
-      if (this.pendingMetrics.trace.llmCallCount != null) {
-        this.rootSpan.setAttribute(
-          "agentv.trace.llm_call_count",
-          this.pendingMetrics.trace.llmCallCount
-        );
-      }
-    }
-    if (error) {
-      this.rootSpan.setStatus({ code: this.api.SpanStatusCode.ERROR, message: error });
-    } else {
-      this.rootSpan.setStatus({ code: this.api.SpanStatusCode.OK });
-    }
-    this.rootSpan.end();
-    this.rootSpan = null;
-    this.rootCtx = null;
-    this.observedChildSpans = false;
-    this.pendingMetrics = null;
-  }
-  /** Backfill child spans from the completed result when the provider emitted no live callbacks. */
-  completeFromResult(result) {
-    this.recordEvalMetrics({
-      durationMs: result.durationMs,
-      costUsd: result.costUsd,
-      tokenUsage: result.tokenUsage,
-      trace: result.trace
-    });
-    if (this.observedChildSpans || !this.rootCtx) {
-      return;
-    }
-    const model = result.trace.messages.find((msg) => msg.role === "assistant")?.metadata?.model ?? result.target ?? "unknown";
-    this.onLlmCall(String(model), result.tokenUsage);
-    for (const message of result.trace.messages) {
-      for (const toolCall of message.toolCalls ?? []) {
-        this.onToolCall(
-          toolCall.tool,
-          toolCall.input,
-          toolCall.output,
-          toolCall.durationMs ?? 0,
-          toolCall.id
-        );
-      }
-    }
-  }
-  /** Return the active eval span's trace ID and span ID for Braintrust trace bridging */
-  getActiveSpanIds() {
-    if (!this.rootSpan) return null;
-    try {
-      const spanCtx = this.rootSpan.spanContext?.() ?? this.rootSpan._spanContext;
-      if (!spanCtx?.traceId || !spanCtx?.spanId) return null;
-      return { parentSpanId: spanCtx.spanId, rootSpanId: spanCtx.traceId };
-    } catch {
-      return null;
-    }
-  }
-  /** Get ProviderStreamCallbacks for passing to providers */
-  getStreamCallbacks() {
-    return {
-      onToolCallEnd: (name, input, output, durationMs, toolCallId) => this.onToolCall(name, input, output, durationMs, toolCallId),
-      onLlmCallEnd: (model, tokenUsage) => this.onLlmCall(model, tokenUsage),
-      getActiveSpanIds: () => this.getActiveSpanIds()
-    };
-  }
-};
-function groupMessagesIntoTurns(messages) {
-  const turns = [];
-  let current = [];
-  for (const msg of messages) {
-    if (msg.role === "user" && current.length > 0) {
-      turns.push({ messages: current });
-      current = [];
-    }
-    current.push(msg);
-  }
-  if (current.length > 0) turns.push({ messages: current });
-  return turns;
-}
-function toHrTime(iso) {
-  if (!iso) return void 0;
-  return new Date(iso).getTime();
-}
 var RunBudgetTracker = class {
   constructor(capUsd) {
     this.capUsd = capUsd;
@@ -5432,7 +5563,7 @@ function parseClaudeSession(jsonl) {
     durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
   }
   const source = {
-    provider: "claude",
+    provider: "claude-sdk",
     sessionId,
     projectPath,
     startedAt: startTimestamp,
@@ -5482,7 +5613,7 @@ function extractAssistantContent(content) {
       case "tool_use":
         if (block.name) {
           toolCalls.push(
-            normalizeToolCall("claude", {
+            normalizeToolCall("claude-sdk", {
               tool: block.name,
               input: block.input,
               id: block.id
@@ -5577,7 +5708,7 @@ function parseCodexSession(jsonl) {
             } else {
               input = payload.arguments;
             }
-            const toolCall = normalizeToolCall("codex", {
+            const toolCall = normalizeToolCall("codex-cli", {
               tool: toolName,
               input,
               id: callId
@@ -5605,7 +5736,7 @@ function parseCodexSession(jsonl) {
             } else {
               input = payload.arguments;
             }
-            const toolCall = normalizeToolCall("codex", {
+            const toolCall = normalizeToolCall("codex-cli", {
               tool: toolName,
               input,
               id: callId
@@ -5793,11 +5924,13 @@ var TranscriptProvider = class _TranscriptProvider {
   kind = "transcript";
   targetName;
   entries;
+  entriesByTestId;
   cursor = 0;
   constructor(targetName, entries) {
     this.targetName = targetName;
     this.id = `transcript:${targetName}`;
     this.entries = entries;
+    this.entriesByTestId = new Map(entries.map((entry) => [entry.testId, entry]));
   }
   /**
    * Create a TranscriptProvider from a JSONL file path.
@@ -5814,13 +5947,11 @@ var TranscriptProvider = class _TranscriptProvider {
   get lineCount() {
     return this.entries.length;
   }
-  async invoke(_request) {
-    if (this.cursor >= this.entries.length) {
-      throw new Error(
-        `Transcript exhausted: ${this.entries.length} entr${this.entries.length === 1 ? "y" : "ies"} available but ${this.cursor + 1} invocations attempted. Each transcript entry maps to one test case.`
-      );
-    }
-    const entry = this.entries[this.cursor++];
+  get testIds() {
+    return this.entries.map((entry) => entry.testId);
+  }
+  async invoke(request) {
+    const entry = request.evalCaseId ? this.entryForTestId(request.evalCaseId) : this.nextPositionalEntry();
     return {
       output: entry.messages,
       tokenUsage: entry.tokenUsage ? {
@@ -5834,7 +5965,153 @@ var TranscriptProvider = class _TranscriptProvider {
       startTime: entry.source.startedAt
     };
   }
+  entryForTestId(testId) {
+    const entry = this.entriesByTestId.get(testId);
+    if (entry) {
+      return entry;
+    }
+    throw new Error(
+      `Transcript replay found no entry for test_id=${testId}. Available test_id values: ${this.testIds.join(", ") || "<none>"}`
+    );
+  }
+  nextPositionalEntry() {
+    if (this.cursor >= this.entries.length) {
+      throw new Error(
+        `Transcript exhausted: ${this.entries.length} entr${this.entries.length === 1 ? "y" : "ies"} available but ${this.cursor + 1} invocations attempted. Each transcript entry maps to one test case.`
+      );
+    }
+    return this.entries[this.cursor++];
+  }
 };
+function parseCopilotEvents(eventsJsonl) {
+  const messages = [];
+  const meta = { sessionId: "", model: "", cwd: "" };
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let hasUsage = false;
+  let startTimestamp;
+  let endTimestamp;
+  const toolCallsInProgress = /* @__PURE__ */ new Map();
+  const lines = eventsJsonl.split("\n").filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const eventType = event.type;
+    if (!eventType) continue;
+    const data = event.data ?? {};
+    switch (eventType) {
+      case "session.start": {
+        meta.sessionId = String(data.sessionId ?? "");
+        const ctx = data.context;
+        meta.cwd = String(ctx?.cwd ?? "");
+        meta.repository = ctx?.repository ? String(ctx.repository) : void 0;
+        meta.branch = ctx?.branch ? String(ctx.branch) : void 0;
+        const ts = event.timestamp ?? data.startTime;
+        meta.startedAt = ts ? String(ts) : void 0;
+        startTimestamp = ts ? String(ts) : void 0;
+        break;
+      }
+      case "user.message": {
+        messages.push({
+          role: "user",
+          content: data.content != null ? String(data.content) : ""
+        });
+        break;
+      }
+      case "assistant.message": {
+        const toolRequests = data.toolRequests;
+        const toolCalls = (toolRequests ?? []).map(
+          (req) => normalizeToolCall("copilot-events", {
+            tool: String(req.name ?? req.toolName ?? ""),
+            input: req.arguments,
+            id: req.toolCallId ? String(req.toolCallId) : void 0
+          })
+        );
+        messages.push({
+          role: "assistant",
+          content: data.content != null ? String(data.content) : void 0,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "skill.invoked": {
+        const skillName = String(data.name ?? "");
+        messages.push({
+          role: "assistant",
+          toolCalls: [
+            {
+              tool: "Skill",
+              input: { skill: skillName }
+            }
+          ]
+        });
+        break;
+      }
+      case "tool.execution_start": {
+        const toolCallId = String(data.toolCallId ?? "");
+        if (toolCallId) {
+          toolCallsInProgress.set(toolCallId, {
+            toolName: String(data.toolName ?? ""),
+            input: data.arguments,
+            toolCallId
+          });
+        }
+        break;
+      }
+      case "tool.execution_complete": {
+        const toolCallId = String(data.toolCallId ?? "");
+        const started = toolCallsInProgress.get(toolCallId);
+        if (started) {
+          toolCallsInProgress.delete(toolCallId);
+          messages.push({
+            role: "assistant",
+            toolCalls: [
+              normalizeToolCall("copilot-events", {
+                tool: started.toolName,
+                input: started.input,
+                output: data.result,
+                id: toolCallId
+              })
+            ]
+          });
+        }
+        break;
+      }
+      case "session.shutdown": {
+        endTimestamp = event.timestamp ? String(event.timestamp) : void 0;
+        const modelMetrics = data.modelMetrics;
+        if (modelMetrics) {
+          for (const metrics of Object.values(modelMetrics)) {
+            if (metrics.usage) {
+              hasUsage = true;
+              totalInputTokens += Number(metrics.usage.inputTokens ?? 0);
+              totalOutputTokens += Number(metrics.usage.outputTokens ?? 0);
+            }
+          }
+        }
+        const currentModel = data.currentModel;
+        if (currentModel && !meta.model) {
+          meta.model = String(currentModel);
+        }
+        break;
+      }
+    }
+  }
+  let durationMs;
+  if (startTimestamp && endTimestamp) {
+    durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
+  }
+  return {
+    messages,
+    meta,
+    tokenUsage: hasUsage ? { input: totalInputTokens, output: totalOutputTokens } : void 0,
+    durationMs
+  };
+}
 function createAgentKernel() {
   return { status: "stub" };
 }
@@ -5857,9 +6134,11 @@ export {
   getResultsRepoLocalPaths,
   ensureResultsRepoClone,
   getResultsRepoStatus,
+  buildResultsCompareUrl,
   getResultsRepoSyncStatus,
   syncResultsRepo,
   syncResultsRepoForProject,
+  confirmResultsMergeAndPull,
   checkoutResultsRepoBranch,
   prepareResultsRepoBranch,
   stageResultsArtifacts,
@@ -5875,15 +6154,14 @@ export {
   setupWipWorktree,
   pushWipCheckpoint,
   deleteWipBranch,
+  resolveGitResultsIndexCacheFile,
+  resolveGitRunsRefCommit,
+  listGitRunsCached,
   listGitRuns,
   materializeGitRun,
   syncProject,
   syncProjects,
   trimBaselineResult,
-  DEFAULT_CATEGORY,
-  deriveCategory,
-  OtelTraceExporter,
-  OtelStreamingObserver,
   RunBudgetTracker,
   parseEnvOutput,
   runBeforeSessionHook,
@@ -5892,6 +6170,7 @@ export {
   discoverCodexSessions,
   discoverClaudeSessions,
   TranscriptProvider,
+  parseCopilotEvents,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-NCNDA3F6.js.map
+//# sourceMappingURL=chunk-GJWPQXHN.js.map