agentv 5.0.0-next.1 → 5.2.0-next.1

package/dist/{chunk-UG4JHZYM.js → chunk-ALVZQUZP.js}

@@ -8,57 +8,47 @@ import {
   external_exports,
   extractLastAssistantContent,
   getAgentvDataDir,
-  getRepoCheckoutRef,
   groupTranscriptJsonLines,
-  interpolateEnv,
   loadTests,
-  normalizeRepoIdentity,
   normalizeToolCall,
-  parseRepoConfig,
   parseYamlValue,
   prepareEvalCaseWorkspace,
   prepareSharedWorkspaceSetup,
   readTranscriptJsonl,
-  releaseSharedWorkspaceSetup,
-  resolveRepoCloneUrl
-} from "./chunk-GZJMODLW.js";
+  releaseSharedWorkspaceSetup
+} from "./chunk-3S6A2RKR.js";
 
 // ../../packages/core/dist/index.js
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
 import { readFileSync } from "node:fs";
-import path2 from "node:path";
+import path from "node:path";
 import { randomUUID } from "node:crypto";
-import path3 from "node:path";
+import path2 from "node:path";
 import micromatch from "micromatch";
-import { readFile as readFile2 } from "node:fs/promises";
-import path4 from "node:path";
 import { execFile, spawn } from "node:child_process";
-import { createHash as createHash2, randomBytes } 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, readdir, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
-import path5 from "node:path";
+import path3 from "node:path";
 import { promisify } from "node:util";
 import * as childProcess from "node:child_process";
 import { existsSync as existsSync2 } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { homedir } from "node:os";
-import path6 from "node:path";
+import path4 from "node:path";
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path7 from "node:path";
+import path5 from "node:path";
 var TRACE_SESSION_SCHEMA_VERSION = "agentv.dashboard.trace_session.v1";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1482,430 +1472,7 @@ function isPrimitive(value) {
 function dropUndefined2(value) {
   return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
 }
-var EXPERIMENT_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml", ".ts", ".js", ".mts", ".mjs"]);
-var VALID_SANDBOXES = /* @__PURE__ */ new Set(["auto", "docker", "vercel"]);
-var VALID_REPEAT_STRATEGIES = /* @__PURE__ */ new Set([
-  "pass_at_k",
-  "mean",
-  "confidence_interval"
-]);
-function isExperimentFileReference(value) {
-  const trimmed = value.trim();
-  if (!trimmed) {
-    return false;
-  }
-  return trimmed.includes("/") || trimmed.includes("\\") || EXPERIMENT_FILE_EXTENSIONS.has(path.extname(trimmed).toLowerCase());
-}
-function deriveExperimentNameFromPath(filePath) {
-  return path.basename(filePath).replace(/\.experiment\.(ya?ml|[cm]?[jt]s)$/i, "").replace(/\.(ya?ml|[cm]?[jt]s)$/i, "");
-}
-async function loadExperimentConfig(filePath) {
-  const resolvedPath = path.resolve(filePath);
-  const ext = path.extname(resolvedPath).toLowerCase();
-  let rawConfig;
-  if (ext === ".yaml" || ext === ".yml") {
-    rawConfig = parseYamlValue(await readFile(resolvedPath, "utf8"));
-  } else if (EXPERIMENT_FILE_EXTENSIONS.has(ext)) {
-    const moduleUrl = pathToFileURL(resolvedPath).href;
-    const mod = await import(moduleUrl);
-    rawConfig = mod.default ?? mod.config ?? mod;
-  } else {
-    throw new Error(
-      `Unsupported experiment file extension '${ext}'. Use .yaml, .yml, .ts, .js, .mts, or .mjs.`
-    );
-  }
-  return normalizeExperimentConfig(rawConfig, { sourcePath: resolvedPath });
-}
-function normalizeExperimentConfig(rawConfig, options = {}) {
-  if (!isRecord2(rawConfig)) {
-    throw new Error("Experiment config must be an object.");
-  }
-  const name = readOptionalString(rawConfig.name, "name");
-  const agent = readOptionalString(rawConfig.agent, "agent");
-  const target = readOptionalString(rawConfig.target, "target");
-  const targets = readTargets(rawConfig.targets);
-  const model = readOptionalString(rawConfig.model, "model");
-  const agentOptions = readOptionalRecord(rawConfig.agent_options ?? rawConfig.agentOptions);
-  const suites = readSuites(rawConfig.suites);
-  const scripts = readScriptArray(rawConfig.scripts, "scripts");
-  const repeat = readRepeat(rawConfig.repeat);
-  const runs = readOptionalPositiveInteger(rawConfig.runs, "runs");
-  if (repeat !== void 0 && runs !== void 0) {
-    throw new Error("Experiment repeat and runs cannot both be set. Use repeat for AgentV config.");
-  }
-  const earlyExit = readOptionalBoolean(rawConfig.early_exit ?? rawConfig.earlyExit, "early_exit");
-  const timeoutSeconds = readOptionalPositiveNumber(
-    rawConfig.timeout_seconds ?? rawConfig.timeoutSeconds,
-    "timeout_seconds"
-  );
-  const workers = readOptionalPositiveInteger(rawConfig.workers, "workers");
-  const budgetUsd = readOptionalPositiveNumber(
-    rawConfig.budget_usd ?? rawConfig.budgetUsd,
-    "budget_usd"
-  );
-  const sandbox = readOptionalSandbox(rawConfig.sandbox);
-  const workspace = readOptionalRecord(rawConfig.workspace);
-  const setup = readSetup(rawConfig.setup);
-  const configWithoutFingerprint = {
-    ...name !== void 0 && { name },
-    ...agent !== void 0 && { agent },
-    ...target !== void 0 && { target },
-    ...targets !== void 0 && { targets },
-    ...model !== void 0 && { model },
-    ...agentOptions !== void 0 && { agentOptions },
-    ...suites !== void 0 && { suites },
-    ...scripts !== void 0 && { scripts },
-    ...repeat !== void 0 && { repeat },
-    ...runs !== void 0 && { runs },
-    ...earlyExit !== void 0 && { earlyExit },
-    ...timeoutSeconds !== void 0 && { timeoutSeconds },
-    ...workers !== void 0 && { workers },
-    ...budgetUsd !== void 0 && { budgetUsd },
-    ...sandbox !== void 0 && { sandbox },
-    ...workspace !== void 0 && { workspace },
-    ...setup !== void 0 && { setup },
-    ...options.sourcePath !== void 0 && { sourcePath: options.sourcePath }
-  };
-  return {
-    ...configWithoutFingerprint,
-    fingerprint: fingerprintExperimentConfig(configWithoutFingerprint)
-  };
-}
-function fingerprintExperimentConfig(config) {
-  const stablePayload = toStableJsonValue(config);
-  return createHash("sha256").update(JSON.stringify(stablePayload)).digest("hex");
-}
-function buildExperimentArtifactMetadata(config) {
-  if (!config) {
-    return void 0;
-  }
-  const targets = config.targets?.map((target) => typeof target === "string" ? target : target.name).filter((target) => target.trim().length > 0);
-  return {
-    ...config.name !== void 0 && { name: config.name },
-    ...config.sourcePath !== void 0 && { source_path: config.sourcePath },
-    ...config.fingerprint !== void 0 && { fingerprint: config.fingerprint },
-    ...config.agent !== void 0 && { agent: config.agent },
-    ...config.target !== void 0 && { target: config.target },
-    ...targets && targets.length > 0 && { targets },
-    ...config.model !== void 0 && { model: config.model },
-    ...config.suites !== void 0 && { suites: config.suites.map(toSuiteArtifactMetadata) },
-    ...config.repeat !== void 0 && {
-      repeat: {
-        count: config.repeat.count,
-        strategy: config.repeat.strategy,
-        ...config.repeat.costLimitUsd !== void 0 && {
-          cost_limit_usd: config.repeat.costLimitUsd
-        }
-      }
-    },
-    ...config.runs !== void 0 && { runs: config.runs },
-    ...config.earlyExit !== void 0 && { early_exit: config.earlyExit },
-    ...config.timeoutSeconds !== void 0 && { timeout_seconds: config.timeoutSeconds },
-    ...config.workers !== void 0 && { workers: config.workers },
-    ...config.budgetUsd !== void 0 && { budget_usd: config.budgetUsd },
-    ...config.sandbox !== void 0 && { sandbox: config.sandbox }
-  };
-}
-function toSuiteArtifactMetadata(suite) {
-  return {
-    ref: suite.ref,
-    ...suite.select !== void 0 && {
-      select: {
-        test_ids: suite.select.testIds
-      }
-    }
-  };
-}
-function readRepeat(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!isRecord2(raw)) {
-    throw new Error("Experiment repeat must be an object.");
-  }
-  const count = readRequiredPositiveInteger(raw.count, "repeat.count");
-  const strategy = readOptionalRepeatStrategy(raw.strategy);
-  const costLimitUsd = readOptionalNonNegativeNumber(
-    raw.cost_limit_usd ?? raw.costLimitUsd,
-    "repeat.cost_limit_usd"
-  );
-  return {
-    count,
-    strategy: strategy ?? "pass_at_k",
-    ...costLimitUsd !== void 0 && { costLimitUsd }
-  };
-}
-function readTargets(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!Array.isArray(raw)) {
-    throw new Error("Experiment targets must be an array.");
-  }
-  return raw.map((entry, index) => {
-    if (typeof entry === "string" && entry.trim().length > 0) {
-      return entry.trim();
-    }
-    if (!isRecord2(entry)) {
-      throw new Error(`Experiment targets[${index}] must be a string or object.`);
-    }
-    const name = readRequiredString(entry.name, `targets[${index}].name`);
-    const useTarget = readOptionalString(
-      entry.use_target ?? entry.useTarget,
-      `targets[${index}].use_target`
-    );
-    const hooks = readOptionalRecord(entry.hooks);
-    return {
-      name,
-      ...useTarget !== void 0 && { useTarget },
-      ...hooks !== void 0 && { hooks }
-    };
-  });
-}
-function readSuites(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!Array.isArray(raw)) {
-    throw new Error("Experiment suites must be an array.");
-  }
-  if (raw.length === 0) {
-    throw new Error("Experiment suites must not be empty.");
-  }
-  return raw.map((entry, index) => {
-    if (!isRecord2(entry)) {
-      throw new Error(`Experiment suites[${index}] must be an object.`);
-    }
-    const ref = readRequiredString(entry.ref, `suites[${index}].ref`);
-    const select = readSuiteSelect(entry.select, `suites[${index}].select`);
-    return {
-      ref,
-      ...select !== void 0 && { select }
-    };
-  });
-}
-function readSuiteSelect(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!isRecord2(raw)) {
-    throw new Error(`Experiment ${location} must be an object.`);
-  }
-  const testIds = readOptionalStringArray(raw.test_ids ?? raw.testIds, `${location}.test_ids`);
-  if (testIds === void 0) {
-    throw new Error(`Experiment ${location}.test_ids is required when select is set.`);
-  }
-  return { testIds };
-}
-function readScriptArray(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!Array.isArray(raw)) {
-    throw new Error(`Experiment ${location} must be an array.`);
-  }
-  return raw.map((entry, index) => readScript(entry, `${location}[${index}]`));
-}
-function readSetup(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw === "function") {
-    return raw;
-  }
-  return readScriptArray(raw, "setup");
-}
-function readScript(raw, location) {
-  if (typeof raw === "string") {
-    const script2 = raw.trim();
-    if (!script2) {
-      throw new Error(`Experiment ${location} must not be empty.`);
-    }
-    return { script: script2 };
-  }
-  if (!isRecord2(raw)) {
-    throw new Error(`Experiment ${location} must be a string or object.`);
-  }
-  const command = readOptionalCommand(raw.command, `${location}.command`);
-  const script = readOptionalStringOrStringArray(raw.script, `${location}.script`);
-  if (command === void 0 && script === void 0) {
-    throw new Error(`Experiment ${location} must define command or script.`);
-  }
-  const timeoutSeconds = readOptionalPositiveNumber(
-    raw.timeout_seconds ?? raw.timeoutSeconds,
-    `${location}.timeout_seconds`
-  );
-  const cwd = readOptionalString(raw.cwd, `${location}.cwd`);
-  const env = readOptionalStringRecord(raw.env, `${location}.env`);
-  return {
-    ...command !== void 0 && { command },
-    ...script !== void 0 && { script },
-    ...timeoutSeconds !== void 0 && { timeoutSeconds },
-    ...cwd !== void 0 && { cwd },
-    ...env !== void 0 && { env }
-  };
-}
-function readOptionalCommand(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw === "string") {
-    const command = raw.trim();
-    if (!command) {
-      throw new Error(`Experiment ${location} must not be empty.`);
-    }
-    return ["sh", "-c", command];
-  }
-  if (Array.isArray(raw) && raw.length > 0 && raw.every((entry) => typeof entry === "string" && entry.trim())) {
-    return raw.map((entry) => entry.trim());
-  }
-  throw new Error(`Experiment ${location} must be a string or string array.`);
-}
-function readOptionalStringOrStringArray(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw === "string") {
-    const trimmed = raw.trim();
-    if (!trimmed) {
-      throw new Error(`Experiment ${location} must not be empty.`);
-    }
-    return trimmed;
-  }
-  if (Array.isArray(raw) && raw.length > 0 && raw.every((entry) => typeof entry === "string" && entry.trim())) {
-    return raw.map((entry) => entry.trim());
-  }
-  throw new Error(`Experiment ${location} must be a string or string array.`);
-}
-function readOptionalStringArray(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (Array.isArray(raw) && raw.length > 0 && raw.every((entry) => typeof entry === "string" && entry.trim())) {
-    return raw.map((entry) => entry.trim());
-  }
-  throw new Error(`Experiment ${location} must be a non-empty string array.`);
-}
-function readOptionalString(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "string" || raw.trim().length === 0) {
-    throw new Error(`Experiment ${location} must be a non-empty string.`);
-  }
-  return raw.trim();
-}
-function readRequiredString(raw, location) {
-  const value = readOptionalString(raw, location);
-  if (value === void 0) {
-    throw new Error(`Experiment ${location} is required.`);
-  }
-  return value;
-}
-function readRequiredPositiveInteger(raw, location) {
-  const value = readOptionalPositiveInteger(raw, location);
-  if (value === void 0) {
-    throw new Error(`Experiment ${location} is required.`);
-  }
-  return value;
-}
-function readOptionalBoolean(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "boolean") {
-    throw new Error(`Experiment ${location} must be a boolean.`);
-  }
-  return raw;
-}
-function readOptionalRepeatStrategy(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "string" || !VALID_REPEAT_STRATEGIES.has(raw)) {
-    throw new Error(
-      "Experiment repeat.strategy must be one of 'pass_at_k', 'mean', or 'confidence_interval'."
-    );
-  }
-  return raw;
-}
-function readOptionalPositiveInteger(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) {
-    throw new Error(`Experiment ${location} must be a positive integer.`);
-  }
-  return raw;
-}
-function readOptionalNonNegativeNumber(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) {
-    throw new Error(`Experiment ${location} must be a non-negative number.`);
-  }
-  return raw;
-}
-function readOptionalPositiveNumber(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "number" || !Number.isFinite(raw) || raw <= 0) {
-    throw new Error(`Experiment ${location} must be a positive number.`);
-  }
-  return raw;
-}
-function readOptionalSandbox(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (typeof raw !== "string" || !VALID_SANDBOXES.has(raw)) {
-    throw new Error("Experiment sandbox must be one of 'auto', 'docker', or 'vercel'.");
-  }
-  return raw;
-}
-function readOptionalRecord(raw) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!isRecord2(raw)) {
-    throw new Error("Experiment object field must be an object.");
-  }
-  return raw;
-}
-function readOptionalStringRecord(raw, location) {
-  if (raw === void 0) {
-    return void 0;
-  }
-  if (!isRecord2(raw)) {
-    throw new Error(`Experiment ${location} must be an object.`);
-  }
-  const entries = Object.entries(raw);
-  if (!entries.every((entry) => typeof entry[1] === "string")) {
-    throw new Error(`Experiment ${location} values must be strings.`);
-  }
-  return Object.fromEntries(entries);
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function toStableJsonValue(value) {
-  if (typeof value === "function") {
-    return "[function]";
-  }
-  if (value === null || typeof value !== "object") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(toStableJsonValue);
-  }
-  const record = value;
-  return Object.fromEntries(
-    Object.keys(record).sort().map((key) => [key, toStableJsonValue(record[key])])
-  );
-}
-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).`;
 }
@@ -1923,21 +1490,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}'`;
     }
@@ -1948,35 +1509,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";
     }
@@ -1985,14 +1538,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;
@@ -2001,7 +1552,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");
     }
@@ -2012,16 +1573,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;
@@ -2059,7 +1610,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}'`);
@@ -2068,10 +1618,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);
@@ -2083,10 +1630,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()) {
@@ -2139,12 +1687,12 @@ function transpileEvalYaml(suite, source = "EVAL.yaml") {
       files.delete("_no-skill");
     }
   }
-  return { files, warnings };
+  return { files, warnings: [] };
 }
 function transpileEvalYamlFile(evalYamlPath) {
   const content = readFileSync(evalYamlPath, "utf8");
   const parsed = parseYamlValue(content);
-  return transpileEvalYaml(parsed, path2.basename(evalYamlPath));
+  return transpileEvalYaml(parsed, path.basename(evalYamlPath));
 }
 function getOutputFilenames(result) {
   const names = /* @__PURE__ */ new Map();
@@ -2181,35 +1729,12 @@ 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 = path3.resolve(options.testFilePath);
+  const evalPath = path2.resolve(options.testFilePath);
   const evalRunId = randomUUID();
   const evalCases = options.evalCases ?? await loadTests(evalPath, options.repoRoot, {
     verbose: options.verbose,
@@ -2221,7 +1746,7 @@ async function prepareEvalWorkspace(options) {
     filter: options.filter,
     evalPath
   });
-  const evalDir = path3.dirname(evalPath);
+  const evalDir = path2.dirname(evalPath);
   const workers = options.maxConcurrency ?? 1;
   const retainOnSuccess = options.retainOnSuccess ?? (options.keepWorkspaces ? "keep" : "cleanup");
   const retainOnFailure = options.retainOnFailure ?? (options.cleanupWorkspaces ? "cleanup" : "keep");
@@ -2236,15 +1761,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,
@@ -2256,15 +1777,14 @@ async function prepareEvalWorkspace(options) {
       evalDir,
       cleanupWorkspaces: options.cleanupWorkspaces,
       targetHooks: options.targetHooks,
+      sharedExtensionState: sharedSetup.extensionState,
       setupDebug: options.verbose
     });
     if (!caseSetup.workspacePath) {
       throw new Error(
-        `No workspace was materialized for test "${evalCase.id}". Add workspace.template, workspace.repos, or workspace.hooks before preparing an external attempt.`
+        `No workspace was materialized for test "${evalCase.id}". Add environment.workdir before preparing an external attempt, or use an internal workspace override for private runtime plumbing.`
       );
     }
-    await releaseUnselectedPoolSlots(sharedSetup, caseSetup.workspacePath);
-    const pool = poolMetadata(sharedSetup, caseSetup.workspacePath);
     return {
       evalPath,
       testId: evalCase.id,
@@ -2276,6 +1796,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: {
@@ -2293,8 +1819,7 @@ async function prepareEvalWorkspace(options) {
         retainOnFailure,
         manualCleanup: true
       },
-      sharedWorkspace: caseSetup.isSharedWorkspace,
-      ...pool !== void 0 && { pool }
+      sharedWorkspace: caseSetup.isSharedWorkspace
     };
   } catch (error) {
     if (sharedSetup) {
@@ -2304,22 +1829,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 */
@@ -2332,13 +1886,6 @@ var AgentVConfigSchema = external_exports.object({
     /** Response cache directory */
     path: external_exports.string().optional()
   }).optional(),
-  /** Compatibility shorthand for experiments.default */
-  defaultExperiment: external_exports.string().optional(),
-  /** Experiment defaults */
-  experiments: external_exports.object({
-    /** Default experiment label or path used when eval runs omit --experiment */
-    default: external_exports.string().optional()
-  }).strict().optional(),
   /** Cost and duration limits */
   limits: external_exports.object({
     /** Maximum cost per run in USD */
@@ -2356,7 +1903,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);
@@ -2371,7 +1920,7 @@ var CONFIG_FILE_NAMES = [
 ];
 async function loadTsConfig(projectRoot) {
   const { existsSync: existsSync3 } = await import("node:fs");
-  const { pathToFileURL: pathToFileURL2 } = await import("node:url");
+  const { pathToFileURL } = await import("node:url");
   const { join } = await import("node:path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join(projectRoot, fileName);
@@ -2379,7 +1928,7 @@ async function loadTsConfig(projectRoot) {
       continue;
     }
     try {
-      const fileUrl = pathToFileURL2(filePath).href;
+      const fileUrl = pathToFileURL(filePath).href;
       const mod = await import(fileUrl);
       const config = mod.default ?? mod;
       return AgentVConfigSchema.parse(config);
@@ -2462,87 +2011,14 @@ function buildPrompt(criteria, question, referenceAnswer) {
   }
   return parts.join("\n");
 }
-async function scanRepoDeps(evalFilePaths) {
-  const seen = /* @__PURE__ */ new Map();
-  const errors = [];
-  for (const filePath of evalFilePaths) {
-    try {
-      const repos = await extractReposFromEvalFile(filePath);
-      for (const repo of repos) {
-        if (!repo.repo) continue;
-        const checkoutRef = getRepoCheckoutRef(repo);
-        const ref = checkoutRef === "HEAD" ? void 0 : checkoutRef;
-        const key = `${normalizeRepoIdentity(repo.repo)}\0${ref ?? ""}`;
-        const existing = seen.get(key);
-        if (existing) {
-          existing.usedBy.push(filePath);
-        } else {
-          seen.set(key, {
-            url: resolveRepoCloneUrl(repo.repo),
-            ref,
-            sparse: repo.sparse,
-            ancestor: repo.ancestor,
-            usedBy: [filePath]
-          });
-        }
-      }
-    } catch (err) {
-      errors.push({
-        file: filePath,
-        message: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return { repos: [...seen.values()], errors };
-}
-async function extractReposFromEvalFile(filePath) {
-  const content = await readFile2(filePath, "utf8");
-  const parsed = interpolateEnv(parseYamlValue(content), process.env);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
-  const obj = parsed;
-  const evalFileDir = path4.dirname(path4.resolve(filePath));
-  const repos = [];
-  const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
-  repos.push(...suiteRepos);
-  const tests = Array.isArray(obj.tests) ? obj.tests : [];
-  for (const test of tests) {
-    if (test && typeof test === "object" && !Array.isArray(test)) {
-      const testObj = test;
-      const testRepos = await extractReposFromWorkspaceRaw(testObj.workspace, evalFileDir);
-      repos.push(...testRepos);
-    }
-  }
-  return repos;
-}
-async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
-  if (typeof raw === "string") {
-    const workspaceFilePath = path4.resolve(evalFileDir, raw);
-    const content = await readFile2(workspaceFilePath, "utf8");
-    const parsed = interpolateEnv(parseYamlValue(content), process.env);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
-    return extractReposFromObject(parsed);
-  }
-  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
-    return extractReposFromObject(raw);
-  }
-  return [];
-}
-function extractReposFromObject(obj) {
-  const rawRepos = Array.isArray(obj.repos) ? obj.repos : [];
-  const result = [];
-  for (const r of rawRepos) {
-    const parsed = parseRepoConfig(r);
-    if (parsed?.repo) {
-      result.push(parsed);
-    }
-  }
-  return result;
-}
 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 = [
@@ -2563,121 +2039,11 @@ 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.
-# Append-only run index: union concurrent appends (lines are orthogonal).
-index.jsonl merge=union
-# Editable run overlay (tags/feedback): 3-way JSON set/field union via the
-# agentv-json driver; a genuine scalar conflict falls through to a human merge.
-metadata/runs/**/*.json merge=agentv-json
-`;
-var RESULTS_JSON_MERGE_DRIVER_NAME = "agentv-json";
-var RESULTS_JSON_MERGE_DRIVER_SCRIPT = `#!/usr/bin/env node
-// AgentV results overlay merge driver (merge=agentv-json).
-//
-// Performs a 3-way merge of AgentV's editable JSON overlay files (run tags /
-// feedback). Tag lists merge as a 3-way set so concurrent add/remove are
-// commutative; display-only bookkeeping scalars that always differ between
-// writers (updated_at) are regenerated to the larger value instead of
-// conflicting. Content-derived concurrency tokens (tag_revision) are dropped on
-// merge so the reader recomputes a token matching the merged content rather than
-// carrying a stale token that could bypass optimistic-concurrency checks. Any
-// other genuinely diverging scalar exits non-zero, leaving the file conflicted
-// so the caller can route it to a human GitHub merge.
-//
-// Invoked by git as: node json-merge-driver.mjs %O %A %B %P
-//   %O ancestor, %A current (overwritten with the result), %B other, %P path.
-import { readFileSync, writeFileSync } from 'node:fs';
-
-const [, , ancestorFile, currentFile, otherFile] = process.argv;
-const CONFLICT = Symbol('conflict');
-// Scalars that legitimately differ on every write and carry no merge meaning.
-const REGENERABLE_SCALARS = new Set(['updated_at']);
-// Content-derived tokens (a hash of {tags, updated_at}) that guard optimistic
-// concurrency. Carrying either side's pre-merge token forward would let a stale
-// client whose token happens to match bypass the concurrency check and silently
-// overwrite the merged set, so we drop them and let the reader recompute a token
-// that matches the merged content.
-const DROP_ON_MERGE = new Set(['tag_revision']);
-
-function readJson(file) {
-  try {
-    return JSON.parse(readFileSync(file, 'utf8'));
-  } catch {
-    return undefined;
-  }
-}
-
-function isPrimitiveArray(value) {
-  return (
-    Array.isArray(value) &&
-    value.every((entry) => entry === null || ['string', 'number', 'boolean'].includes(typeof entry))
-  );
-}
-
-function isPlainObject(value) {
-  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-
-function mergeSet(base, a, b) {
-  const baseSet = new Set((isPrimitiveArray(base) ? base : []).map(String));
-  const aSet = new Set(a.map(String));
-  const bSet = new Set(b.map(String));
-  const removed = new Set();
-  for (const value of baseSet) {
-    if (!aSet.has(value) || !bSet.has(value)) removed.add(value);
-  }
-  const merged = [];
-  const seen = new Set();
-  for (const value of [...a, ...b]) {
-    const key = String(value);
-    if (!removed.has(key) && !seen.has(key)) {
-      seen.add(key);
-      merged.push(value);
-    }
-  }
-  return merged;
-}
-
-function merge3(base, a, b, key) {
-  if (JSON.stringify(a) === JSON.stringify(b)) return a;
-  if (JSON.stringify(a) === JSON.stringify(base)) return b;
-  if (JSON.stringify(b) === JSON.stringify(base)) return a;
-  if (isPrimitiveArray(a) && isPrimitiveArray(b)) return mergeSet(base, a, b);
-  if (isPlainObject(a) && isPlainObject(b)) {
-    const keys = new Set([
-      ...Object.keys(a),
-      ...Object.keys(b),
-      ...(isPlainObject(base) ? Object.keys(base) : []),
-    ]);
-    const out = {};
-    for (const childKey of keys) {
-      if (DROP_ON_MERGE.has(childKey)) continue;
-      const merged = merge3(
-        isPlainObject(base) ? base[childKey] : undefined,
-        a[childKey],
-        b[childKey],
-        childKey,
-      );
-      if (merged === CONFLICT) return CONFLICT;
-      if (merged !== undefined) out[childKey] = merged;
-    }
-    return out;
-  }
-  if (REGENERABLE_SCALARS.has(key)) {
-    return [a, b].filter((value) => value !== undefined).sort().pop();
-  }
-  return CONFLICT;
-}
-
-const ancestor = readJson(ancestorFile) ?? {};
-const current = readJson(currentFile);
-const other = readJson(otherFile);
-if (current === undefined || other === undefined) process.exit(1);
-const result = merge3(ancestor, current, other, '');
-if (result === CONFLICT) process.exit(1);
-writeFileSync(currentFile, \`\${JSON.stringify(result, null, 2)}\\n\`);
-process.exit(0);
+${RESULTS_REPO_INDEXES_DIR}/*.jsonl merge=union
+*/.internal/index.jsonl merge=union
 `;
 var activeResultsRepoSyncs = /* @__PURE__ */ new Set();
 function sanitizeRepoSlug(repo) {
@@ -2693,37 +2059,34 @@ function withFriendlyGitHubAuthError(error) {
 }
 function expandHome(p) {
   if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-    return path5.join(os.homedir(), p.slice(1));
+    return path3.join(os.homedir(), p.slice(1));
   }
   return p;
 }
 function resolveLocalPath(p, baseDir) {
   const expanded = expandHome(p);
-  return path5.isAbsolute(expanded) ? expanded : path5.resolve(baseDir, expanded);
+  return path3.isAbsolute(expanded) ? expanded : path3.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() || "origin";
-  const autoPush = config.sync?.auto_push ?? config.auto_push === true;
-  const requirePush = config.sync?.require_push === true;
-  const configuredPushConflictPolicy = config.sync?.push_conflict_policy;
-  if (configuredPushConflictPolicy === "backup_and_force_push") {
-    throw new Error(
-      "results.sync.push_conflict_policy: 'backup_and_force_push' is no longer supported. Remove the field or set it to 'block'; AgentV never force-pushes result branches."
-    );
-  }
-  if (configuredPushConflictPolicy !== void 0 && configuredPushConflictPolicy !== "block") {
-    throw new Error("results.sync.push_conflict_policy must be 'block'");
-  }
-  const pushConflictPolicy = configuredPushConflictPolicy ?? "block";
+  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 ? path5.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path5.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
+  const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -2734,8 +2097,7 @@ 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
   };
 }
@@ -2754,11 +2116,11 @@ function resolveResultsRepoUrl(repo) {
   return trimmed;
 }
 function getResultsRepoLocalPaths(repo) {
-  const rootDir = path5.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  const rootDir = path3.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
-    repoDir: path5.join(rootDir, "repo"),
-    statusFile: path5.join(rootDir, "status.json")
+    repoDir: path3.join(rootDir, "repo"),
+    statusFile: path3.join(rootDir, "status.json")
   };
 }
 function usesStorageBranchWorktree(config) {
@@ -2775,7 +2137,7 @@ function readPersistedStatus(statusFile) {
   }
 }
 function writePersistedStatus(statusFile, status) {
-  mkdirSync(path5.dirname(statusFile), { recursive: true });
+  mkdirSync(path3.dirname(statusFile), { recursive: true });
   writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
 `, "utf8");
 }
@@ -3018,37 +2380,17 @@ async function ensureResultsMergeConfig(repoDir) {
   try {
     const { stdout } = await runGit(["rev-parse", "--git-common-dir"], { cwd: repoDir });
     const resolved = stdout.trim();
-    gitDir = resolved ? path5.isAbsolute(resolved) ? resolved : path5.join(repoDir, resolved) : path5.join(repoDir, ".git");
+    gitDir = resolved ? path3.isAbsolute(resolved) ? resolved : path3.join(repoDir, resolved) : path3.join(repoDir, ".git");
   } catch {
     return;
   }
-  const driverScriptPath = path5.join(gitDir, "agentv", "json-merge-driver.mjs");
-  let scriptCurrent = false;
-  try {
-    scriptCurrent = readFileSync2(driverScriptPath, "utf8") === RESULTS_JSON_MERGE_DRIVER_SCRIPT;
-  } catch {
-    scriptCurrent = false;
-  }
-  if (!scriptCurrent) {
-    mkdirSync(path5.dirname(driverScriptPath), { recursive: true });
-    writeFileSync(driverScriptPath, RESULTS_JSON_MERGE_DRIVER_SCRIPT, { mode: 493 });
-  }
-  const driverCommand = `node ${JSON.stringify(driverScriptPath)} %O %A %B %P`;
-  await runGit(
-    ["config", `merge.${RESULTS_JSON_MERGE_DRIVER_NAME}.name`, "AgentV results overlay JSON union"],
-    { cwd: repoDir, check: false }
-  );
-  await runGit(["config", `merge.${RESULTS_JSON_MERGE_DRIVER_NAME}.driver`, driverCommand], {
-    cwd: repoDir,
-    check: false
-  });
   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 = path5.join(gitDir, "info");
-  const attributesPath = path5.join(infoDir, "attributes");
+  const infoDir = path3.join(gitDir, "info");
+  const attributesPath = path3.join(infoDir, "attributes");
   const managedBlock = `${RESULTS_INFO_ATTRIBUTES_BEGIN}
 ${RESULTS_REPO_GITATTRIBUTES_CONTENT.trimEnd()}
 ${RESULTS_INFO_ATTRIBUTES_END}
@@ -3084,9 +2426,9 @@ async function addResultsGitattributesToIndex(repoDir, indexEnv) {
   if (existing === RESULTS_REPO_GITATTRIBUTES_CONTENT) {
     return;
   }
-  const scratchDir = mkdtempSync(path5.join(os.tmpdir(), "agentv-results-attrs-"));
+  const scratchDir = mkdtempSync(path3.join(os.tmpdir(), "agentv-results-attrs-"));
   try {
-    const scratchFile = path5.join(scratchDir, RESULTS_REPO_GITATTRIBUTES_FILE);
+    const scratchFile = path3.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
@@ -3105,7 +2447,7 @@ async function addResultsGitattributesToIndex(repoDir, indexEnv) {
   }
 }
 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, {
@@ -3126,9 +2468,9 @@ async function ensureResultsRepoClone(config) {
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
   mkdirSync(cachePaths.rootDir, { recursive: true });
-  mkdirSync(path5.dirname(cloneDir), { recursive: true });
+  mkdirSync(path3.dirname(cloneDir), { recursive: true });
   const cloneMissing = !existsSync(cloneDir);
-  const gitDir = path5.join(cloneDir, ".git");
+  const gitDir = path3.join(cloneDir, ".git");
   const cloneEmpty = !cloneMissing && !existsSync(gitDir) && (await readdir(cloneDir)).length === 0;
   if (cloneMissing || cloneEmpty) {
     try {
@@ -3174,7 +2516,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,
@@ -3295,7 +2636,7 @@ async function getStorageBranchWorktreeDirtyPaths(repoDir, config) {
   const comparisonRef = await gitRefExists(repoDir, localRef) ? localRef : await gitRefExists(repoDir, remoteRef) ? remoteRef : void 0;
   const dirtyPaths = [];
   for (const gitPath of safeDirtyPaths) {
-    const absolutePath = path5.join(repoDir, ...gitPath.split("/"));
+    const absolutePath = path3.join(repoDir, ...gitPath.split("/"));
     if (!existsSync(absolutePath)) {
       if (await readGitText(repoDir, comparisonRef, gitPath) !== void 0) {
         dirtyPaths.push(gitPath);
@@ -3401,7 +2742,7 @@ async function hasInProgressGitConflict(repoDir) {
       check: false
     });
     const markerPath = stdout.trim();
-    const resolvedMarkerPath = path5.isAbsolute(markerPath) ? markerPath : path5.join(repoDir, markerPath);
+    const resolvedMarkerPath = path3.isAbsolute(markerPath) ? markerPath : path3.join(repoDir, markerPath);
     if (markerPath && existsSync(resolvedMarkerPath)) {
       return true;
     }
@@ -3573,22 +2914,49 @@ function withActionFlags(status, flags) {
   };
 }
 function isSafeResultsRepoPath(p) {
-  return p === RESULTS_REPO_GITATTRIBUTES_FILE || RESULTS_REPO_TRACKED_DIRS.some((dir) => p === dir || p.startsWith(`${dir}/`));
-}
-async function existingTrackedResultsDirs(repoDir) {
-  const targets = [];
-  for (const dir of RESULTS_REPO_TRACKED_DIRS) {
-    if (existsSync(path5.join(repoDir, dir))) {
-      targets.push(dir);
+  const normalized = p.split(path3.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 existingTrackedResultsPathspecs(repoDir) {
+  const targets = /* @__PURE__ */ new Set();
+  if (existsSync(path3.join(repoDir, RESULTS_REPO_GITATTRIBUTES_FILE))) {
+    targets.add(RESULTS_REPO_GITATTRIBUTES_FILE);
+  }
+  for (const dir of RESULTS_REPO_TRACKED_DOT_DIRS) {
+    if (existsSync(path3.join(repoDir, dir))) {
+      targets.add(dir);
       continue;
     }
-    const { stdout } = await runGit(["ls-files", "--", dir], { cwd: repoDir, check: false });
-    if (stdout.trim().length > 0) {
-      targets.push(dir);
+    const { stdout: stdout2 } = await runGit(["ls-files", "--", dir], { cwd: repoDir, check: false });
+    if (stdout2.trim().length > 0) {
+      targets.add(dir);
     }
   }
-  return targets;
-}
+  for (const entry of await readdir(repoDir, { withFileTypes: true }).catch(() => [])) {
+    if (entry.name.startsWith(".") || !entry.isDirectory()) {
+      continue;
+    }
+    if (existsSync(path3.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 segments = normalized.split("/");
+    if (segments.length >= 2 && segments[0] && !segments[0].startsWith(".")) {
+      targets.add(segments[0]);
+    }
+  }
+  return [...targets].sort();
+}
 function areSafeResultsRepoPaths(paths) {
   return paths.length > 0 && paths.every(isSafeResultsRepoPath);
 }
@@ -3638,7 +3006,7 @@ async function getMergeBaseCommit(repoDir, a, b) {
   return exitCode === 0 && sha.length > 0 ? sha : void 0;
 }
 function buildNeedsHumanMergeReason(targetBranch, remoteCommit, localCommit) {
-  return `Results branch ${targetBranch} diverged from the remote and could not be auto-merged: a genuine content conflict in the editable overlay remains (remote ${formatShortSha(
+  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
@@ -3692,13 +3060,7 @@ async function countContributedRunDirs(repoDir, remoteTargetCommit, sourceCommit
     return void 0;
   }
   const { stdout, exitCode } = await runGit(
-    [
-      "diff",
-      "--name-only",
-      `${remoteTargetCommit}...${sourceCommit}`,
-      "--",
-      `${RESULTS_REPO_RUNS_DIR}/`
-    ],
+    ["diff", "--name-only", `${remoteTargetCommit}...${sourceCommit}`, "--", RESULTS_REPO_RUNS_DIR],
     { cwd: repoDir, check: false }
   );
   if (exitCode !== 0) {
@@ -3711,8 +3073,8 @@ async function countContributedRunDirs(repoDir, remoteTargetCommit, sourceCommit
       continue;
     }
     const segments = file.split("/");
-    if (segments[0] === RESULTS_REPO_RUNS_DIR && segments.length >= 3) {
-      runDirs.add(`${segments[0]}/${segments[1]}/${segments[2]}`);
+    if (segments.length >= 2 && segments[0] && !segments[0].startsWith(".")) {
+      runDirs.add(segments[0]);
     }
   }
   return runDirs.size;
@@ -3954,9 +3316,6 @@ async function getResultsRepoSyncStatus(config) {
   }
   try {
     if (usesStorageBranchWorktree(normalized)) {
-      await fetchResultsRepo(normalized.path, normalized.remote, normalized.branch).catch(
-        () => void 0
-      );
       return withGitInspection(
         baseStatus,
         await inspectResultsStorageBranchGit(normalized.path, normalized)
@@ -4331,10 +3690,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
           }
@@ -4552,8 +3917,8 @@ async function prepareResultsRepoBranch(config, branchName) {
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
   await fetchResultsRepo(cloneDir, normalized.remote);
-  const worktreeRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-repo-"));
-  const worktreeDir = path5.join(worktreeRoot, "repo");
+  const worktreeRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = path3.join(worktreeRoot, "repo");
   await runGit(
     ["worktree", "add", "-B", branchName, worktreeDir, `${normalized.remote}/${baseBranch}`],
     {
@@ -4575,12 +3940,12 @@ async function prepareResultsRepoBranch(config, branchName) {
 }
 async function stageResultsArtifacts(params) {
   rmSync(params.destinationDir, { recursive: true, force: true });
-  mkdirSync(path5.dirname(params.destinationDir), { recursive: true });
+  mkdirSync(path3.dirname(params.destinationDir), { recursive: true });
   await cp(params.sourceDir, params.destinationDir, { recursive: true });
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return path5.join(normalized.path, RESULTS_REPO_RESULTS_DIR);
+  return path3.join(normalized.path, RESULTS_REPO_RESULTS_DIR);
 }
 async function directorySizeBytes(targetPath) {
   const entry = await stat(targetPath);
@@ -4589,7 +3954,7 @@ async function directorySizeBytes(targetPath) {
   }
   let total = 0;
   for (const child of await readdir(targetPath, { withFileTypes: true })) {
-    total += await directorySizeBytes(path5.join(targetPath, child.name));
+    total += await directorySizeBytes(path3.join(targetPath, child.name));
   }
   return total;
 }
@@ -4656,7 +4021,7 @@ async function assertValidResultsBranchName(repoDir, branch) {
   await runGit(["check-ref-format", "--branch", branch], { cwd: repoDir });
 }
 function normalizeDestinationPath(destinationPath) {
-  const normalized = destinationPath.split(path5.sep).join("/");
+  const normalized = destinationPath.split(path3.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..") || normalized.split("").some((char) => {
     const code = char.charCodeAt(0);
@@ -4670,7 +4035,7 @@ async function listSourceFiles(sourceDir) {
   const entries = [];
   async function visit(dir) {
     for (const entry of await readdir(dir, { withFileTypes: true })) {
-      const absolutePath = path5.join(dir, entry.name);
+      const absolutePath = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(absolutePath);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
@@ -4682,20 +4047,18 @@ async function listSourceFiles(sourceDir) {
   entries.sort();
   return entries;
 }
-function isRecord3(value) {
+function isRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function artifactSidecarPointers(record) {
-  if (!isRecord3(record) || !isRecord3(record.artifact_pointers)) {
+  if (!isRecord2(record) || !isRecord2(record.artifact_pointers)) {
     return [];
   }
   const pointers = [];
-  for (const pointer of Object.values(record.artifact_pointers)) {
-    if (!isRecord3(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,
@@ -4706,15 +4069,56 @@ function artifactSidecarPointers(record) {
   return pointers;
 }
 function artifactSidecarKey(destinationPath, pointerPath) {
-  return path5.posix.join(
+  return path3.posix.join(
     RESULTS_REPO_RUNS_DIR,
     normalizeDestinationPath(destinationPath),
     normalizeDestinationPath(pointerPath)
   );
 }
+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;
+  }
+  if (path3.isAbsolute(manifestPath)) {
+    return void 0;
+  }
+  const normalized = path3.normalize(manifestPath);
+  if (normalized.startsWith("..") || path3.isAbsolute(normalized)) {
+    return void 0;
+  }
+  return path3.join(sourceDir, normalized);
+}
+function resolveLocalResultManifestPath(sourceDir) {
+  try {
+    const summary = JSON.parse(readFileSync2(path3.join(sourceDir, "summary.json"), "utf8"));
+    const manifestPath2 = safeLocalSummaryManifestPath(
+      sourceDir,
+      summary.index_path ?? summary.manifest_path
+    );
+    if (manifestPath2 && existsSync(manifestPath2)) {
+      return manifestPath2;
+    }
+  } catch {
+  }
+  const manifestPath = path3.join(sourceDir, RUN_INTERNAL_DIRNAME, RESULT_INDEX_FILENAME2);
+  if (existsSync(manifestPath)) {
+    return manifestPath;
+  }
+  const legacyManifestPath = path3.join(sourceDir, RESULT_INDEX_FILENAME2);
+  if (existsSync(legacyManifestPath)) {
+    return legacyManifestPath;
+  }
+  return void 0;
+}
 function collectArtifactSidecarPointers(sourceDir) {
-  const indexPath = path5.join(sourceDir, RESULT_INDEX_FILENAME2);
-  if (!existsSync(indexPath)) {
+  const indexPath = resolveLocalResultManifestPath(sourceDir);
+  if (!indexPath) {
     return [];
   }
   const pointers = [];
@@ -4732,16 +4136,16 @@ function collectArtifactSidecarPointers(sourceDir) {
 }
 function resolveArtifactPointerSourcePath(sourceDir, pointerPath) {
   const normalizedPointerPath = normalizeDestinationPath(pointerPath);
-  const sourceRoot = path5.resolve(sourceDir);
-  const sourcePath = path5.resolve(sourceRoot, ...normalizedPointerPath.split("/"));
-  const relative = path5.relative(sourceRoot, sourcePath);
-  if (relative.startsWith("..") || path5.isAbsolute(relative)) {
+  const sourceRoot = path3.resolve(sourceDir);
+  const sourcePath = path3.resolve(sourceRoot, ...normalizedPointerPath.split("/"));
+  const relative = path3.relative(sourceRoot, sourcePath);
+  if (relative.startsWith("..") || path3.isAbsolute(relative)) {
     throw new Error(`Artifact pointer path escapes run directory: ${pointerPath}`);
   }
   return sourcePath;
 }
 function verifyArtifactPointerChecksum(pointer, content) {
-  const sha256 = createHash2("sha256").update(content).digest("hex");
+  const sha256 = createHash("sha256").update(content).digest("hex");
   if (pointer.sha256 && pointer.sha256 !== sha256) {
     throw new Error(`Artifact pointer checksum mismatch for ${pointer.path}`);
   }
@@ -4753,7 +4157,7 @@ async function prepareArtifactSidecar(params) {
   if (params.pointers.length === 0) {
     return void 0;
   }
-  const sidecarRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-artifact-sidecar-"));
+  const sidecarRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-artifact-sidecar-"));
   const copied = /* @__PURE__ */ new Set();
   const contentByPath = /* @__PURE__ */ new Map();
   try {
@@ -4769,8 +4173,8 @@ async function prepareArtifactSidecar(params) {
       if (copied.has(relativePointerPath)) {
         continue;
       }
-      const destinationPath = path5.join(sidecarRoot, ...relativePointerPath.split("/"));
-      mkdirSync(path5.dirname(destinationPath), { recursive: true });
+      const destinationPath = path3.join(sidecarRoot, ...relativePointerPath.split("/"));
+      mkdirSync(path3.dirname(destinationPath), { recursive: true });
       writeFileSync(destinationPath, content);
       copied.add(relativePointerPath);
     }
@@ -4797,22 +4201,24 @@ function rewritePublishedIndexLine(line, destinationPath) {
   } catch {
     return line;
   }
-  if (!isRecord3(record) || !isRecord3(record.artifact_pointers)) {
+  if (!isRecord2(record) || !isRecord2(record.artifact_pointers)) {
     return line;
   }
   let changed = false;
-  for (const pointer of Object.values(record.artifact_pointers)) {
-    if (!isRecord3(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;
 }
@@ -4820,26 +4226,29 @@ async function preparePublishedResultsSource(params) {
   if (params.pointers.length === 0) {
     return void 0;
   }
-  const publishedRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-published-"));
+  const publishedRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-published-"));
   const omittedPaths = new Set(
     params.pointers.map((pointer) => normalizeDestinationPath(pointer.path))
   );
   try {
     const sourceFiles = await listSourceFiles(params.sourceDir);
     for (const sourceFile of sourceFiles) {
-      const relativeFile = path5.relative(params.sourceDir, sourceFile).split(path5.sep).join("/");
-      const destinationFile = path5.join(publishedRoot, ...relativeFile.split("/"));
-      if (relativeFile === RESULT_INDEX_FILENAME2) {
+      const relativeFile = path3.relative(params.sourceDir, sourceFile).split(path3.sep).join("/");
+      const destinationFile = path3.join(publishedRoot, ...relativeFile.split("/"));
+      if (isResultManifestFilename(path3.posix.basename(relativeFile))) {
         const original = readFileSync2(sourceFile, "utf8");
         const rewritten = original.split(/\r?\n/).map((line) => rewritePublishedIndexLine(line, params.destinationPath)).join("\n");
-        mkdirSync(path5.dirname(destinationFile), { recursive: true });
+        mkdirSync(path3.dirname(destinationFile), { recursive: true });
         writeFileSync(destinationFile, rewritten);
         continue;
       }
+      if (isDeprecatedTraceArtifactPath(relativeFile)) {
+        continue;
+      }
       if (omittedPaths.has(relativeFile)) {
         continue;
       }
-      mkdirSync(path5.dirname(destinationFile), { recursive: true });
+      mkdirSync(path3.dirname(destinationFile), { recursive: true });
       await cp(sourceFile, destinationFile, { dereference: false });
     }
   } catch (error) {
@@ -4906,8 +4315,8 @@ async function commitStorageBranchWorktreePaths(params) {
       normalized
     });
   }
-  const indexRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path5.join(indexRoot, "index");
+  const indexRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path3.join(indexRoot, "index");
   const indexEnv = { GIT_INDEX_FILE: indexFile };
   try {
     if (base.baseRef) {
@@ -4917,7 +4326,7 @@ async function commitStorageBranchWorktreePaths(params) {
     }
     await addResultsGitattributesToIndex(params.repoDir, indexEnv);
     for (const gitPath of paths) {
-      const sourcePath = path5.join(params.repoDir, ...gitPath.split("/"));
+      const sourcePath = path3.join(params.repoDir, ...gitPath.split("/"));
       if (!existsSync(sourcePath)) {
         await runGit(["update-index", "--force-remove", "--", gitPath], {
           cwd: params.repoDir,
@@ -4983,7 +4392,7 @@ async function commitResultsRunWithTemporaryIndex(params) {
   await assertValidResultsBranchName(params.repoDir, normalized.branch);
   await ensureResultsBranchNotCheckedOut(params.repoDir, normalized);
   const destinationRunPath = normalizeDestinationPath(params.destinationPath);
-  const destinationTreePath = path5.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
+  const destinationTreePath = path3.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
   let base = await resolveStorageBranchBase({
     repoDir: params.repoDir,
     normalized,
@@ -4997,8 +4406,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
       preferRemote: params.preferRemoteBase
     });
   }
-  const indexRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path5.join(indexRoot, "index");
+  const indexRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path3.join(indexRoot, "index");
   const indexEnv = { GIT_INDEX_FILE: indexFile };
   try {
     if (base.baseRef) {
@@ -5021,8 +4430,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
     }
     const sourceFiles = await listSourceFiles(params.sourceDir);
     for (const sourceFile of sourceFiles) {
-      const relativeFile = path5.relative(params.sourceDir, sourceFile).split(path5.sep).join("/");
-      const destinationFile = path5.posix.join(destinationTreePath, relativeFile);
+      const relativeFile = path3.relative(params.sourceDir, sourceFile).split(path3.sep).join("/");
+      const destinationFile = path3.posix.join(destinationTreePath, relativeFile);
       const fileStat = await lstat(sourceFile);
       let mode = fileStat.mode & 73 ? "100755" : "100644";
       let hashInputPath = sourceFile;
@@ -5295,17 +4704,70 @@ async function directPushResultsWithDetails(params) {
     await sidecar?.cleanup().catch(() => void 0);
   }
 }
-function buildGitRunId(relativeRunPath) {
-  const normalized = relativeRunPath.split(path5.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;
+function safeGitSummaryManifestPath(runDir, manifestPath) {
+  if (typeof manifestPath !== "string" || manifestPath.trim().length === 0) {
+    return void 0;
+  }
+  if (manifestPath.startsWith("/")) {
+    return void 0;
+  }
+  const normalized = path3.posix.normalize(manifestPath);
+  if (normalized === ".." || normalized.startsWith("../")) {
+    return void 0;
+  }
+  return path3.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 = path3.posix.dirname(summaryPath);
+    const relativeRunPath = path3.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);
     }
-    return `${experiment}::${timestamp}`;
   }
+  for (const treePath of treePaths) {
+    if (!treePath.endsWith(`/${RESULT_INDEX_FILENAME2}`)) {
+      continue;
+    }
+    const runDir = gitRunDirForManifestPath(treePath);
+    const relativeRunPath = path3.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 [
+    path3.posix.join(runDir, ".internal", RESULT_INDEX_FILENAME2),
+    path3.posix.join(runDir, RESULT_INDEX_FILENAME2)
+  ]) {
+    if (treePathSet.has(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function gitRunDirForManifestPath(manifestPath) {
+  const manifestDir = path3.posix.dirname(manifestPath);
+  return path3.posix.basename(manifestDir) === ".internal" ? path3.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(path3.sep).join("/");
+  const segments = normalized.split("/").filter(Boolean);
   return segments[0] ?? relativeRunPath;
 }
 function getRunExperiment(runId, summary) {
@@ -5433,7 +4895,7 @@ async function readGitResultArtifact(params) {
 }
 function buildWipBranchName(runDir) {
   const hostname = os.hostname().replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 40);
-  const runBasename = path5.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
+  const runBasename = path3.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
   return `agentv/wip/${hostname}/${runBasename}`;
 }
 async function setupWipWorktree(params) {
@@ -5452,8 +4914,8 @@ async function setupWipWorktree(params) {
   if (!baseRef) {
     throw new Error("Could not resolve a base ref for the WIP results branch");
   }
-  const worktreeRoot = await mkdtemp(path5.join(os.tmpdir(), "agentv-wip-"));
-  const worktreeDir = path5.join(worktreeRoot, "repo");
+  const worktreeRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-wip-"));
+  const worktreeDir = path3.join(worktreeRoot, "repo");
   await runGit(["worktree", "add", "-B", params.wipBranch, worktreeDir, baseRef], {
     cwd: cloneDir
   });
@@ -5472,7 +4934,7 @@ async function setupWipWorktree(params) {
   };
 }
 async function pushWipCheckpoint(params) {
-  const destinationDir = path5.join(
+  const destinationDir = path3.join(
     params.handle.worktreeDir,
     RESULTS_REPO_RUNS_DIR,
     params.destinationPath
@@ -5482,8 +4944,11 @@ async function pushWipCheckpoint(params) {
     sourceDir: params.sourceDir,
     destinationDir
   });
-  const trackedDirs = await existingTrackedResultsDirs(params.handle.worktreeDir);
-  await runGit(["add", "--all", "--", ...trackedDirs], {
+  writeFileSync(
+    path3.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"], {
@@ -5506,7 +4971,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 = [];
@@ -5518,7 +4995,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 = path3.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 path3.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 readFile(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(path3.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;
@@ -5536,19 +5113,7 @@ async function listGitRuns(repoDir, ref = "origin/main") {
     throw error;
   }
   const treePaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  const indexPaths = treePaths.filter((line) => line.endsWith("/index.jsonl"));
-  if (indexPaths.length === 0) {
-    return [];
-  }
-  const batchInput = `${indexPaths.map((indexPath) => `${ref}:${indexPath}`).join("\n")}
-`;
-  const blobs = parseGitBatchBlobs(await runGitBatch(repoDir, batchInput));
-  if (blobs.length !== indexPaths.length) {
-    throw new Error(
-      `Expected ${indexPaths.length} git blobs but received ${blobs.length} while listing results runs`
-    );
-  }
-  const summaryPaths = indexPaths.map((indexPath) => path5.posix.join(path5.posix.dirname(indexPath), "summary.json")).filter((summaryPath) => treePaths.includes(summaryPath));
+  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")}
@@ -5561,12 +5126,24 @@ async function listGitRuns(repoDir, ref = "origin/main") {
       summaryByPath.set(summaryPath, JSON.parse(blob.content.toString("utf8")));
     }
   }
+  const indexPaths = buildGitManifestPaths(treePaths, summaryByPath);
+  if (indexPaths.length === 0) {
+    return [];
+  }
+  const batchInput = `${indexPaths.map((indexPath) => `${ref}:${indexPath}`).join("\n")}
+`;
+  const blobs = parseGitBatchBlobs(await runGitBatch(repoDir, batchInput));
+  if (blobs.length !== indexPaths.length) {
+    throw new Error(
+      `Expected ${indexPaths.length} git blobs but received ${blobs.length} while listing results runs`
+    );
+  }
   const runs = blobs.flatMap((blob, index) => {
     const manifestPath = indexPaths[index];
-    const runDir = path5.posix.dirname(manifestPath);
-    const summaryPath = path5.posix.join(runDir, "summary.json");
+    const runDir = gitRunDirForManifestPath(manifestPath);
+    const summaryPath = path3.posix.join(runDir, "summary.json");
     const summary = summaryByPath.get(summaryPath);
-    const relativeRunPath = path5.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    const relativeRunPath = path3.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     const runId = buildGitRunId(relativeRunPath);
     const rows = blob.content.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap(
       (line) => {
@@ -5587,10 +5164,13 @@ async function listGitRuns(repoDir, ref = "origin/main") {
     ];
     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 || path5.posix.basename(runDir);
-    const displayName = summary?.metadata?.display_name?.trim() || path5.posix.basename(runDir);
+    const timestamp = summary?.metadata?.timestamp?.trim() || rows[0]?.timestamp || path3.posix.basename(runDir);
+    const displayName = summary?.metadata?.display_name?.trim() || path3.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,
@@ -5598,10 +5178,11 @@ async function listGitRuns(repoDir, ref = "origin/main") {
         timestamp,
         ...passRate !== void 0 && { pass_rate: passRate },
         ...targets.length === 1 && targets[0] ? { target: targets[0] } : {},
-        manifest_path: manifestPath,
+        index_path: manifestPath,
         ...summaryByPath.has(summaryPath) && { summary_path: summaryPath },
         display_name: displayName,
         test_count: summary?.metadata?.tests_run?.length ?? rowTestIds.length,
+        ...executionErrorCount > 0 && { execution_error_count: executionErrorCount },
         avg_score: avgScore,
         size_bytes: blob.size
       }
@@ -5611,9 +5192,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   return runs;
 }
 async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
-  const normalizedRunPath = relativeRunPath.split(path5.sep).join("/");
-  const runTreePath = path5.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
-  const targetRunDir = path5.join(repoDir, ...runTreePath.split("/"));
+  const normalizedRunPath = relativeRunPath.split(path3.sep).join("/");
+  const runTreePath = path3.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
+  const targetRunDir = path3.join(repoDir, ...runTreePath.split("/"));
   const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, runTreePath], {
     cwd: repoDir
   });
@@ -5629,16 +5210,16 @@ async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main")
       `Expected ${filePaths.length} git blobs but received ${blobs.length} while materializing results run`
     );
   }
-  const tempRoot = mkdtempSync(path5.join(repoDir, ".agentv-run-"));
-  const tempRunDir = path5.join(tempRoot, "run");
+  const tempRoot = mkdtempSync(path3.join(repoDir, ".agentv-run-"));
+  const tempRunDir = path3.join(tempRoot, "run");
   try {
     for (const [index, filePath] of filePaths.entries()) {
-      const relativeFilePath = path5.posix.relative(runTreePath, filePath);
-      const absolutePath = path5.join(tempRunDir, ...relativeFilePath.split("/"));
-      mkdirSync(path5.dirname(absolutePath), { recursive: true });
+      const relativeFilePath = path3.posix.relative(runTreePath, filePath);
+      const absolutePath = path3.join(tempRunDir, ...relativeFilePath.split("/"));
+      mkdirSync(path3.dirname(absolutePath), { recursive: true });
       writeFileSync(absolutePath, blobs[index].content);
     }
-    mkdirSync(path5.dirname(targetRunDir), { recursive: true });
+    mkdirSync(path3.dirname(targetRunDir), { recursive: true });
     try {
       renameSync(tempRunDir, targetRunDir);
     } catch (error) {
@@ -5720,483 +5301,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;
@@ -6376,7 +5480,7 @@ function parseClaudeSession(jsonl) {
     durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
   }
   const source = {
-    provider: "claude",
+    provider: "claude-sdk",
     sessionId,
     projectPath,
     startedAt: startTimestamp,
@@ -6426,7 +5530,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
@@ -6521,7 +5625,7 @@ function parseCodexSession(jsonl) {
             } else {
               input = payload.arguments;
             }
-            const toolCall = normalizeToolCall("codex", {
+            const toolCall = normalizeToolCall("codex-cli", {
               tool: toolName,
               input,
               id: callId
@@ -6549,7 +5653,7 @@ function parseCodexSession(jsonl) {
             } else {
               input = payload.arguments;
             }
-            const toolCall = normalizeToolCall("codex", {
+            const toolCall = normalizeToolCall("codex-cli", {
               tool: toolName,
               input,
               id: callId
@@ -6623,7 +5727,7 @@ function extractResponseItemContent(content) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-var DEFAULT_SESSIONS_DIR = () => path6.join(homedir(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => path4.join(homedir(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -6635,7 +5739,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path6.join(sessionsDir, year);
+    const yearPath = path4.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir2(yearPath);
@@ -6643,7 +5747,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path6.join(yearPath, month);
+      const monthPath = path4.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir2(monthPath);
@@ -6655,7 +5759,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path6.join(monthPath, day);
+        const dayPath = path4.join(monthPath, day);
         let files;
         try {
           files = await readdir2(dayPath);
@@ -6664,7 +5768,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path6.join(dayPath, file);
+          const filePath = path4.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
@@ -6683,7 +5787,7 @@ async function discoverCodexSessions(opts) {
   sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
   return sessions.slice(0, limit);
 }
-var DEFAULT_PROJECTS_DIR = () => path7.join(homedir2(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path5.join(homedir2(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -6702,7 +5806,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path7.join(projectsDir, projectDir);
+    const dirPath = path5.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir3(dirPath);
@@ -6713,7 +5817,7 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path7.join(dirPath, entry);
+      const filePath = path5.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat3(filePath);
@@ -6737,11 +5841,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.
@@ -6758,13 +5864,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 ? {
@@ -6778,7 +5882,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" };
 }
@@ -6788,12 +6038,6 @@ export {
   traceEnvelopeToTraceSessionResponse,
   buildTraceSpanTree,
   normalizeTraceArtifactToTraceSessionResponse,
-  isExperimentFileReference,
-  deriveExperimentNameFromPath,
-  loadExperimentConfig,
-  normalizeExperimentConfig,
-  fingerprintExperimentConfig,
-  buildExperimentArtifactMetadata,
   transpileEvalYaml,
   transpileEvalYamlFile,
   getOutputFilenames,
@@ -6801,7 +6045,6 @@ export {
   defineConfig,
   loadTsConfig,
   generateRubrics,
-  scanRepoDeps,
   normalizeResultsConfig,
   resolveResultsRepoUrl,
   getResultsRepoLocalPaths,
@@ -6827,15 +6070,14 @@ export {
   setupWipWorktree,
   pushWipCheckpoint,
   deleteWipBranch,
+  resolveGitResultsIndexCacheFile,
+  resolveGitRunsRefCommit,
+  listGitRunsCached,
   listGitRuns,
   materializeGitRun,
   syncProject,
   syncProjects,
   trimBaselineResult,
-  DEFAULT_CATEGORY,
-  deriveCategory,
-  OtelTraceExporter,
-  OtelStreamingObserver,
   RunBudgetTracker,
   parseEnvOutput,
   runBeforeSessionHook,
@@ -6844,6 +6086,7 @@ export {
   discoverCodexSessions,
   discoverClaudeSessions,
   TranscriptProvider,
+  parseCopilotEvents,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-UG4JHZYM.js.map
+//# sourceMappingURL=chunk-ALVZQUZP.js.map