@agentv/core 4.31.0-next.1 → 4.31.1-next.1

package/dist/index.cjs

@@ -1168,6 +1168,9 @@ function parseExecutionDefaults(raw, configPath) {
   }
   return Object.keys(result).length > 0 ? result : void 0;
 }
+function isFilesystemPath(p) {
+  return p.startsWith("/") || p.startsWith("~/") || p.startsWith("~\\") || p === "~" || /^[A-Za-z]:[/\\]/.test(p);
+}
 function parseResultsConfig(raw, configPath) {
   if (raw === void 0 || raw === null) {
     return void 0;
@@ -1177,15 +1180,29 @@ function parseResultsConfig(raw, configPath) {
     return void 0;
   }
   const obj = raw;
+  if (obj.mode !== "github") {
+    logWarning(`Invalid results.mode in ${configPath}, expected 'github'`);
+    return void 0;
+  }
   const repo = typeof obj.repo === "string" ? obj.repo.trim() : "";
-  const resultsPath = typeof obj.path === "string" ? obj.path.trim() : "";
   if (!repo) {
     logWarning(`Invalid results.repo in ${configPath}, expected non-empty string`);
     return void 0;
   }
-  if (!resultsPath) {
-    logWarning(`Invalid results.path in ${configPath}, expected non-empty string`);
-    return void 0;
+  let resultsPath;
+  if (obj.path !== void 0) {
+    if (typeof obj.path !== "string" || obj.path.trim().length === 0) {
+      logWarning(`Invalid results.path in ${configPath}, expected non-empty string`);
+      return void 0;
+    }
+    const trimmedPath = obj.path.trim();
+    if (!isFilesystemPath(trimmedPath)) {
+      logWarning(
+        `Invalid results.path in ${configPath}: '${trimmedPath}' looks like a repo subdirectory. results.path now specifies the local filesystem directory for the clone (e.g., ~/data/agentv-results). Remove 'path' to use the default or set an absolute/home-relative path.`
+      );
+      return void 0;
+    }
+    resultsPath = trimmedPath;
   }
   if (obj.auto_push !== void 0 && typeof obj.auto_push !== "boolean") {
     logWarning(`Invalid results.auto_push in ${configPath}, expected boolean`);
@@ -1200,8 +1217,9 @@ function parseResultsConfig(raw, configPath) {
     branchPrefix = obj.branch_prefix.trim();
   }
   return {
+    mode: "github",
     repo,
-    path: resultsPath,
+    ...resultsPath !== void 0 && { path: resultsPath },
     ...typeof obj.auto_push === "boolean" && { auto_push: obj.auto_push },
     ...branchPrefix && { branch_prefix: branchPrefix }
   };
@@ -1314,10 +1332,10 @@ async function execFileWithStdinBun(argv, stdinPayload, options) {
   }
 }
 async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("child_process");
+  const { spawn: spawn6 } = await import("child_process");
   return new Promise((resolve, reject) => {
     const [cmd, ...args] = argv;
-    const child = spawn5(cmd, args, {
+    const child = spawn6(cmd, args, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       // Merge additional env vars with process.env
@@ -1368,10 +1386,10 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
   const stderrPath = path57.join(dir, "stderr.txt");
   await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
-  const { spawn: spawn5 } = await import("child_process");
+  const { spawn: spawn6 } = await import("child_process");
   try {
     const exitCode = await new Promise((resolve, reject) => {
-      const child = spawn5(wrappedCommand, {
+      const child = spawn6(wrappedCommand, {
         shell: true,
         cwd: options.cwd,
         stdio: ["ignore", "ignore", "ignore"],
@@ -4651,7 +4669,7 @@ function getAgentvHome() {
   if (envHome && envHome !== "undefined") {
     if (!logged) {
       logged = true;
-      console.warn(`Using AGENTV_HOME: ${envHome}`);
+      console.log(`Using AGENTV_HOME: ${envHome}`);
     }
     return envHome;
   }
@@ -24814,7 +24832,7 @@ __export(index_exports, {
   getOutputFilenames: () => getOutputFilenames,
   getProject: () => getProject,
   getProjectsRegistryPath: () => getProjectsRegistryPath,
-  getResultsRepoCachePaths: () => getResultsRepoCachePaths,
+  getResultsRepoLocalPaths: () => getResultsRepoLocalPaths,
   getResultsRepoStatus: () => getResultsRepoStatus,
   getSubagentsRoot: () => getSubagentsRoot,
   getTextContent: () => getTextContent,
@@ -24834,6 +24852,7 @@ __export(index_exports, {
   isTestMessage: () => isTestMessage,
   isTestMessageRole: () => isTestMessageRole,
   killAllTrackedChildren: () => killAllTrackedChildren,
+  listGitRuns: () => listGitRuns,
   listTargetNames: () => listTargetNames,
   loadConfig: () => loadConfig,
   loadEvalCaseById: () => loadEvalCaseById,
@@ -24845,6 +24864,7 @@ __export(index_exports, {
   loadTests: () => loadTests,
   loadTsConfig: () => loadTsConfig,
   loadTsEvalFile: () => loadTsEvalFile,
+  materializeGitRun: () => materializeGitRun,
   mergeExecutionMetrics: () => mergeExecutionMetrics,
   negateScore: () => negateScore,
   normalizeLineEndings: () => normalizeLineEndings,
@@ -25537,10 +25557,19 @@ function withFriendlyGitHubAuthError(error) {
   }
   return new Error(message);
 }
+function expandHome(p) {
+  if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
+    return import_node_path54.default.join(import_node_os10.default.homedir(), p.slice(1));
+  }
+  return p;
+}
 function normalizeResultsConfig(config) {
+  const repo = config.repo.trim();
+  const resolvedPath = config.path ? expandHome(config.path.trim()) : import_node_path54.default.join(getAgentvHome(), "results", sanitizeRepoSlug(repo));
   return {
-    repo: config.repo.trim(),
-    path: config.path.trim().replace(/^\/+|\/+$/g, ""),
+    mode: "github",
+    repo,
+    path: resolvedPath,
     auto_push: config.auto_push === true,
     branch_prefix: config.branch_prefix?.trim() || "eval-results"
   };
@@ -25551,7 +25580,7 @@ function resolveResultsRepoUrl(repo) {
   }
   return `https://github.com/${repo}.git`;
 }
-function getResultsRepoCachePaths(repo) {
+function getResultsRepoLocalPaths(repo) {
   const rootDir = import_node_path54.default.join(getAgentvHome(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
@@ -25578,7 +25607,7 @@ async function runCommand(executable, args, options) {
   try {
     const { stdout, stderr } = await execFileAsync4(executable, [...args], {
       cwd: options?.cwd,
-      env: process.env
+      env: options?.env ?? process.env
     });
     return { stdout, stderr };
   } catch (error) {
@@ -25592,8 +25621,17 @@ async function runCommand(executable, args, options) {
     throw withFriendlyGitHubAuthError(error);
   }
 }
+function getGitEnv() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && !(key.startsWith("GIT_") && key !== "GIT_SSH_COMMAND")) {
+      env[key] = value;
+    }
+  }
+  return env;
+}
 async function runGit(args, options) {
-  return runCommand("git", args, options);
+  return runCommand("git", args, { ...options, env: getGitEnv() });
 }
 async function runGh(args, options) {
   return runCommand("gh", args, options);
@@ -25617,13 +25655,11 @@ async function resolveDefaultBranch(repoDir) {
   }
   return "main";
 }
-async function updateCacheRepo(repoDir, baseBranch) {
+async function fetchResultsRepo(repoDir) {
   await runGit(["fetch", "origin", "--prune"], { cwd: repoDir });
-  await runGit(["checkout", baseBranch], { cwd: repoDir });
-  await runGit(["pull", "--ff-only", "origin", baseBranch], { cwd: repoDir });
 }
 function updateStatusFile(config, patch) {
-  const cachePaths = getResultsRepoCachePaths(config.repo);
+  const cachePaths = getResultsRepoLocalPaths(config.repo);
   const current = readPersistedStatus(cachePaths.statusFile);
   writePersistedStatus(cachePaths.statusFile, {
     ...current,
@@ -25632,26 +25668,31 @@ function updateStatusFile(config, patch) {
 }
 async function ensureResultsRepoClone(config) {
   const normalized = normalizeResultsConfig(config);
-  const cachePaths = getResultsRepoCachePaths(normalized.repo);
+  const cachePaths = getResultsRepoLocalPaths(normalized.repo);
+  const cloneDir = normalized.path;
   (0, import_node_fs19.mkdirSync)(cachePaths.rootDir, { recursive: true });
-  if (!(0, import_node_fs19.existsSync)(cachePaths.repoDir)) {
+  (0, import_node_fs19.mkdirSync)(import_node_path54.default.dirname(cloneDir), { recursive: true });
+  const cloneMissing = !(0, import_node_fs19.existsSync)(cloneDir);
+  const gitDir = import_node_path54.default.join(cloneDir, ".git");
+  const cloneEmpty = !cloneMissing && !(0, import_node_fs19.existsSync)(gitDir) && (await (0, import_promises39.readdir)(cloneDir)).length === 0;
+  if (cloneMissing || cloneEmpty) {
     try {
       await runGit([
         "clone",
         "--filter=blob:none",
         resolveResultsRepoUrl(normalized.repo),
-        cachePaths.repoDir
+        cloneDir
       ]);
-      return cachePaths.repoDir;
+      return cloneDir;
     } catch (error) {
       updateStatusFile(normalized, { last_error: withFriendlyGitHubAuthError(error).message });
       throw withFriendlyGitHubAuthError(error);
     }
   }
-  if (!(0, import_node_fs19.existsSync)(import_node_path54.default.join(cachePaths.repoDir, ".git"))) {
-    throw new Error(`Results repo cache is not a git repository: ${cachePaths.repoDir}`);
+  if (!(0, import_node_fs19.existsSync)(gitDir)) {
+    throw new Error(`Results repo clone path is not a git repository: ${cloneDir}`);
   }
-  return cachePaths.repoDir;
+  return cloneDir;
 }
 function getResultsRepoStatus(config) {
   if (!config) {
@@ -25659,20 +25700,20 @@ function getResultsRepoStatus(config) {
       configured: false,
       available: false,
       repo: "",
-      cache_dir: ""
+      local_dir: ""
     };
   }
   const normalized = normalizeResultsConfig(config);
-  const cachePaths = getResultsRepoCachePaths(normalized.repo);
-  const persisted = readPersistedStatus(cachePaths.statusFile);
+  const localPaths = getResultsRepoLocalPaths(normalized.repo);
+  const persisted = readPersistedStatus(localPaths.statusFile);
   return {
     configured: true,
-    available: (0, import_node_fs19.existsSync)(cachePaths.repoDir),
+    available: (0, import_node_fs19.existsSync)(normalized.path),
     repo: normalized.repo,
     path: normalized.path,
     auto_push: normalized.auto_push,
     branch_prefix: normalized.branch_prefix,
-    cache_dir: cachePaths.repoDir,
+    local_dir: normalized.path,
     last_synced_at: persisted.last_synced_at,
     last_error: persisted.last_error
   };
@@ -25681,8 +25722,7 @@ async function syncResultsRepo(config) {
   const normalized = normalizeResultsConfig(config);
   try {
     const repoDir = await ensureResultsRepoClone(normalized);
-    const baseBranch = await resolveDefaultBranch(repoDir);
-    await updateCacheRepo(repoDir, baseBranch);
+    await fetchResultsRepo(repoDir);
     updateStatusFile(normalized, {
       last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
       last_error: void 0
@@ -25699,7 +25739,7 @@ async function checkoutResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const repoDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(repoDir);
-  await updateCacheRepo(repoDir, baseBranch);
+  await fetchResultsRepo(repoDir);
   await runGit(["checkout", "-B", branchName, `origin/${baseBranch}`], { cwd: repoDir });
   updateStatusFile(normalized, { last_error: void 0 });
   return {
@@ -25712,7 +25752,7 @@ async function prepareResultsRepoBranch(config, branchName) {
   const normalized = normalizeResultsConfig(config);
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
-  await updateCacheRepo(cloneDir, baseBranch);
+  await fetchResultsRepo(cloneDir);
   const worktreeRoot = await (0, import_promises39.mkdtemp)(import_node_path54.default.join(import_node_os10.default.tmpdir(), "agentv-results-repo-"));
   const worktreeDir = import_node_path54.default.join(worktreeRoot, "repo");
   await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
@@ -25738,10 +25778,7 @@ async function stageResultsArtifacts(params) {
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return import_node_path54.default.join(
-    getResultsRepoCachePaths(normalized.repo).repoDir,
-    ...normalized.path.split("/")
-  );
+  return import_node_path54.default.join(normalized.path, "runs");
 }
 async function directorySizeBytes(targetPath) {
   const entry = await (0, import_promises39.stat)(targetPath);
@@ -25770,7 +25807,7 @@ async function commitAndPushResultsBranch(params) {
 async function pushResultsRepoBranch(config, branchName, cwd) {
   const normalized = normalizeResultsConfig(config);
   await runGit(["push", "-u", "origin", branchName], {
-    cwd: cwd ?? getResultsRepoCachePaths(normalized.repo).repoDir
+    cwd: cwd ?? normalized.path
   });
   updateStatusFile(normalized, {
     last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
@@ -25803,8 +25840,8 @@ async function directPushResults(params) {
   const normalized = normalizeResultsConfig(params.config);
   const repoDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(repoDir);
-  await updateCacheRepo(repoDir, baseBranch);
-  const destinationDir = import_node_path54.default.join(repoDir, normalized.path, params.destinationPath);
+  await fetchResultsRepo(repoDir);
+  const destinationDir = import_node_path54.default.join(repoDir, "runs", params.destinationPath);
   await stageResultsArtifacts({
     repoDir,
     sourceDir: params.sourceDir,
@@ -25818,10 +25855,19 @@ async function directPushResults(params) {
   if (status.trim().length === 0) {
     return false;
   }
-  await runGit(["commit", "-m", params.commitMessage], { cwd: repoDir });
+  await runGit(
+    [
+      "commit",
+      "-m",
+      params.commitMessage,
+      "-m",
+      `Agentv-Run: ${buildGitRunId(params.destinationPath)}`
+    ],
+    { cwd: repoDir }
+  );
   for (let attempt = 1; attempt <= DIRECT_PUSH_MAX_RETRIES; attempt++) {
     try {
-      await runGit(["push", "origin", baseBranch], { cwd: repoDir });
+      await runGit(["push", "origin", `HEAD:${baseBranch}`], { cwd: repoDir });
       updateStatusFile(normalized, {
         last_synced_at: (/* @__PURE__ */ new Date()).toISOString(),
         last_error: void 0
@@ -25830,7 +25876,8 @@ async function directPushResults(params) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (attempt < DIRECT_PUSH_MAX_RETRIES && message.includes("non-fast-forward")) {
-        await runGit(["pull", "--rebase", "origin", baseBranch], { cwd: repoDir });
+        await fetchResultsRepo(repoDir);
+        await runGit(["rebase", `origin/${baseBranch}`], { cwd: repoDir });
       } else {
         throw error;
       }
@@ -25838,6 +25885,195 @@ async function directPushResults(params) {
   }
   return false;
 }
+function buildGitRunId(relativeRunPath) {
+  const normalized = relativeRunPath.split(import_node_path54.default.sep).join("/");
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length >= 2) {
+    const experiment = segments.slice(0, -1).join("/");
+    const timestamp = segments.at(-1);
+    if (experiment === "default") {
+      return timestamp ?? normalized;
+    }
+    return `${experiment}::${timestamp}`;
+  }
+  return segments[0] ?? relativeRunPath;
+}
+function getRunExperiment(runId, benchmark) {
+  const experiment = benchmark.metadata?.experiment?.trim();
+  if (experiment) {
+    return experiment;
+  }
+  const separatorIndex = runId.lastIndexOf("::");
+  return separatorIndex === -1 ? "default" : runId.slice(0, separatorIndex);
+}
+function computeAveragePassRate(runSummary) {
+  if (!runSummary) {
+    return void 0;
+  }
+  const passRates = Object.values(runSummary).map((summary) => summary.pass_rate?.mean).filter((value) => typeof value === "number" && Number.isFinite(value));
+  if (passRates.length === 0) {
+    return void 0;
+  }
+  return passRates.reduce((sum, value) => sum + value, 0) / passRates.length;
+}
+async function runGitBatch(repoDir, input) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process12.spawn)("git", ["cat-file", "--batch"], {
+      cwd: repoDir,
+      env: getGitEnv(),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => {
+      stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    child.on("error", (error) => reject(withFriendlyGitHubAuthError(error)));
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(Buffer.concat(stdoutChunks));
+        return;
+      }
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+      reject(
+        withFriendlyGitHubAuthError(
+          stderr.length > 0 ? new Error(stderr) : new Error("git cat-file failed")
+        )
+      );
+    });
+    child.stdin.end(input);
+  });
+}
+function parseGitBatchBlobs(output) {
+  const blobs = [];
+  let offset = 0;
+  while (offset < output.length) {
+    const headerEnd = output.indexOf(10, offset);
+    if (headerEnd === -1) {
+      throw new Error("Malformed git cat-file output: missing header terminator");
+    }
+    const header = output.subarray(offset, headerEnd).toString("utf8");
+    offset = headerEnd + 1;
+    if (header.length === 0) {
+      continue;
+    }
+    const missingMatch = /^(.*) missing$/.exec(header);
+    if (missingMatch) {
+      continue;
+    }
+    const headerMatch = /^(.*) (\w+) (\d+)$/.exec(header);
+    if (!headerMatch) {
+      throw new Error(`Malformed git cat-file header: ${header}`);
+    }
+    const [, objectRef, objectType, sizeText] = headerMatch;
+    if (objectType !== "blob") {
+      throw new Error(`Unsupported git object type for ${objectRef}: ${objectType}`);
+    }
+    const size = Number.parseInt(sizeText, 10);
+    const contentEnd = offset + size;
+    if (contentEnd > output.length) {
+      throw new Error(`Malformed git cat-file output for ${objectRef}: truncated blob content`);
+    }
+    blobs.push({
+      size,
+      content: output.subarray(offset, contentEnd)
+    });
+    offset = contentEnd;
+    if (offset < output.length && output[offset] === 10) {
+      offset += 1;
+    }
+  }
+  return blobs;
+}
+async function listGitRuns(repoDir, ref = "origin/main") {
+  const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, "runs"], {
+    cwd: repoDir
+  });
+  const benchmarkPaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.endsWith("/benchmark.json"));
+  if (benchmarkPaths.length === 0) {
+    return [];
+  }
+  const batchInput = `${benchmarkPaths.map((benchmarkPath) => `${ref}:${benchmarkPath}`).join("\n")}
+`;
+  const blobs = parseGitBatchBlobs(await runGitBatch(repoDir, batchInput));
+  if (blobs.length !== benchmarkPaths.length) {
+    throw new Error(
+      `Expected ${benchmarkPaths.length} git blobs but received ${blobs.length} while listing results runs`
+    );
+  }
+  const runs = blobs.flatMap((blob, index) => {
+    const benchmarkPath = benchmarkPaths[index];
+    const benchmark = JSON.parse(blob.content.toString("utf8"));
+    const runDir = import_node_path54.default.posix.dirname(benchmarkPath);
+    const relativeRunPath = import_node_path54.default.posix.relative("runs", runDir);
+    const runId = buildGitRunId(relativeRunPath);
+    const timestamp = benchmark.metadata?.timestamp?.trim() || import_node_path54.default.posix.basename(runDir);
+    const targets = benchmark.metadata?.targets ?? [];
+    const passRate = computeAveragePassRate(benchmark.run_summary);
+    return [
+      {
+        run_id: runId,
+        experiment: getRunExperiment(runId, benchmark),
+        timestamp,
+        ...passRate !== void 0 && { pass_rate: passRate },
+        ...targets.length === 1 && targets[0] ? { target: targets[0] } : {},
+        manifest_path: import_node_path54.default.posix.join(runDir, "index.jsonl"),
+        benchmark_path: benchmarkPath,
+        display_name: import_node_path54.default.posix.basename(runDir),
+        test_count: benchmark.metadata?.tests_run?.length ?? 0,
+        avg_score: 0,
+        size_bytes: blob.size
+      }
+    ];
+  });
+  runs.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+  return runs;
+}
+async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
+  const normalizedRunPath = relativeRunPath.split(import_node_path54.default.sep).join("/");
+  const runTreePath = import_node_path54.default.posix.join("runs", normalizedRunPath);
+  const targetRunDir = import_node_path54.default.join(repoDir, ...runTreePath.split("/"));
+  const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, runTreePath], {
+    cwd: repoDir
+  });
+  const filePaths = treeOut.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (filePaths.length === 0) {
+    return;
+  }
+  const batchInput = `${filePaths.map((filePath) => `${ref}:${filePath}`).join("\n")}
+`;
+  const blobs = parseGitBatchBlobs(await runGitBatch(repoDir, batchInput));
+  if (blobs.length !== filePaths.length) {
+    throw new Error(
+      `Expected ${filePaths.length} git blobs but received ${blobs.length} while materializing results run`
+    );
+  }
+  const tempRoot = (0, import_node_fs19.mkdtempSync)(import_node_path54.default.join(repoDir, ".agentv-run-"));
+  const tempRunDir = import_node_path54.default.join(tempRoot, "run");
+  try {
+    for (const [index, filePath] of filePaths.entries()) {
+      const relativeFilePath = import_node_path54.default.posix.relative(runTreePath, filePath);
+      const absolutePath = import_node_path54.default.join(tempRunDir, ...relativeFilePath.split("/"));
+      (0, import_node_fs19.mkdirSync)(import_node_path54.default.dirname(absolutePath), { recursive: true });
+      (0, import_node_fs19.writeFileSync)(absolutePath, blobs[index].content);
+    }
+    (0, import_node_fs19.mkdirSync)(import_node_path54.default.dirname(targetRunDir), { recursive: true });
+    try {
+      (0, import_node_fs19.renameSync)(tempRunDir, targetRunDir);
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+      if ((code === "EEXIST" || code === "ENOTEMPTY") && (0, import_node_fs19.existsSync)(targetRunDir)) {
+        return;
+      }
+      throw error;
+    }
+  } finally {
+    (0, import_node_fs19.rmSync)(tempRoot, { recursive: true, force: true });
+  }
+}
 
 // src/index.ts
 init_paths();
@@ -27477,7 +27713,7 @@ function createAgentKernel() {
   getOutputFilenames,
   getProject,
   getProjectsRegistryPath,
-  getResultsRepoCachePaths,
+  getResultsRepoLocalPaths,
   getResultsRepoStatus,
   getSubagentsRoot,
   getTextContent,
@@ -27497,6 +27733,7 @@ function createAgentKernel() {
   isTestMessage,
   isTestMessageRole,
   killAllTrackedChildren,
+  listGitRuns,
   listTargetNames,
   loadConfig,
   loadEvalCaseById,
@@ -27508,6 +27745,7 @@ function createAgentKernel() {
   loadTests,
   loadTsConfig,
   loadTsEvalFile,
+  materializeGitRun,
   mergeExecutionMetrics,
   negateScore,
   normalizeLineEndings,