agentv 4.40.1 → 4.41.1-next.1

package/dist/{chunk-I3SC4FOT.js → chunk-Z45FKRMJ.js}

@@ -1,24 +1,33 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 import {
+  AGENT_PROVIDER_KINDS,
+  buildPromptInputs,
   external_exports,
   extractLastAssistantContent,
   getAgentvDataDir,
   getRepoCheckoutRef,
   groupTranscriptJsonLines,
   interpolateEnv,
+  loadTests,
   normalizeRepoIdentity,
   normalizeToolCall,
   parseRepoConfig,
   parseYamlValue,
+  prepareEvalCaseWorkspace,
+  prepareSharedWorkspaceSetup,
   readTranscriptJsonl,
+  releaseSharedWorkspaceSetup,
   resolveRepoCloneUrl
-} from "./chunk-BLXYBUU4.js";
+} from "./chunk-ENHX2CCS.js";
 
 // ../../packages/core/dist/index.js
 import { readFileSync } from "node:fs";
 import path from "node:path";
-import { readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import path2 from "node:path";
+import micromatch from "micromatch";
+import { readFile } from "node:fs/promises";
+import path3 from "node:path";
 import { execFile, spawn } from "node:child_process";
 import {
   existsSync,
@@ -31,17 +40,17 @@ import {
 } from "node:fs";
 import { cp, lstat, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import os from "node:os";
-import path3 from "node:path";
+import path4 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 path4 from "node:path";
+import path5 from "node:path";
 import { readdir as readdir3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 function codeGraderInstruction(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).`;
@@ -297,6 +306,150 @@ function getOutputFilenames(result) {
   }
   return names;
 }
+function matchesFilter(id, filter) {
+  return typeof filter === "string" ? micromatch.isMatch(id, filter) : filter.some((pattern) => micromatch.isMatch(id, pattern));
+}
+function selectSingleCase(options) {
+  const selected = options.testId ? options.evalCases.filter((evalCase) => evalCase.id === options.testId) : options.filter ? options.evalCases.filter((evalCase) => matchesFilter(evalCase.id, options.filter ?? "")) : options.evalCases;
+  if (selected.length !== 1) {
+    const selector = options.testId ? `test_id "${options.testId}"` : options.filter ? `filter "${Array.isArray(options.filter) ? options.filter.join(",") : options.filter}"` : "the eval file";
+    throw new Error(
+      `prepareEvalWorkspace requires exactly one test, but ${selector} matched ${selected.length} in ${options.evalPath}.`
+    );
+  }
+  return selected[0];
+}
+function promptModeForTarget(target) {
+  return AGENT_PROVIDER_KINDS.includes(target.kind) || target.kind === "cli" ? "agent" : "lm";
+}
+function toRepoPins(repos) {
+  return (repos ?? []).map((repo) => ({
+    ...repo.path !== void 0 && { path: repo.path },
+    ...repo.repo !== void 0 && { repo: repo.repo },
+    ...repo.commit !== void 0 && { commit: repo.commit },
+    ...repo.base_commit !== void 0 && { baseCommit: repo.base_commit },
+    ...repo.ancestor !== void 0 && { ancestor: repo.ancestor },
+    ...repo.sparse !== void 0 && { sparse: repo.sparse }
+  }));
+}
+function poolMetadata(setup, selectedSlotPath) {
+  const slot = setup.poolSlot ?? setup.poolSlots.find((candidate) => candidate.path === selectedSlotPath);
+  if (!slot) {
+    return void 0;
+  }
+  return {
+    fingerprint: slot.fingerprint,
+    slotIndex: slot.index,
+    lockPath: slot.lockPath
+  };
+}
+async function releaseUnselectedPoolSlots(setup, selectedSlotPath) {
+  if (!setup.poolManager) {
+    return;
+  }
+  for (const slot of setup.poolSlots) {
+    if (slot.path !== selectedSlotPath) {
+      await setup.poolManager.releaseSlot(slot).catch(() => {
+      });
+    }
+  }
+}
+async function prepareEvalWorkspace(options) {
+  const evalPath = path2.resolve(options.testFilePath);
+  const evalRunId = randomUUID();
+  const evalCases = options.evalCases ?? await loadTests(evalPath, options.repoRoot, {
+    verbose: options.verbose,
+    filter: options.testId ?? options.filter
+  });
+  const evalCase = selectSingleCase({
+    evalCases,
+    testId: options.testId,
+    filter: options.filter,
+    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");
+  const formattingMode = promptModeForTarget(options.target);
+  const promptInputs = await buildPromptInputs(evalCase, formattingMode);
+  let sharedSetup;
+  try {
+    sharedSetup = await prepareSharedWorkspaceSetup({
+      evalRunId,
+      evalCases: [evalCase],
+      targetHooks: options.targetHooks,
+      evalDir,
+      verbose: options.verbose,
+      workers,
+      poolMaxSlots: options.poolMaxSlots,
+      workspacePath: options.workspacePath,
+      legacyWorkspacePath: options.workspace,
+      workspaceMode: options.workspaceMode,
+      workspaceClean: options.workspaceClean
+    });
+    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 caseSetup = await prepareEvalCaseWorkspace({
+      evalCase,
+      targetName: options.target.name,
+      evalRunId,
+      sharedWorkspacePath: selectedWorkspacePath,
+      sharedBaselineCommit: selectedBaselineCommit,
+      suiteWorkspaceFile: sharedSetup.suiteWorkspaceFile,
+      repoManager: sharedSetup.repoManager,
+      evalDir,
+      cleanupWorkspaces: options.cleanupWorkspaces,
+      targetHooks: options.targetHooks,
+      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.`
+      );
+    }
+    await releaseUnselectedPoolSlots(sharedSetup, caseSetup.workspacePath);
+    const pool = poolMetadata(sharedSetup, caseSetup.workspacePath);
+    return {
+      evalPath,
+      testId: evalCase.id,
+      target: options.target.name,
+      evalRunId,
+      workspacePath: caseSetup.workspacePath,
+      ...caseSetup.caseWorkspaceFile !== void 0 && {
+        workspaceFile: caseSetup.caseWorkspaceFile
+      },
+      createdAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+      hookExecutions: [...sharedSetup.hookExecutions, ...caseSetup.hookExecutions],
+      repoPins: toRepoPins(evalCase.workspace?.repos),
+      baseline: caseSetup.baselineCommit ? { status: "initialized", commit: caseSetup.baselineCommit } : { status: "unavailable" },
+      promptSource: {
+        kind: "eval_case",
+        formattingMode,
+        question: promptInputs.question,
+        ...promptInputs.systemMessage !== void 0 && {
+          systemMessage: promptInputs.systemMessage
+        },
+        ...promptInputs.chatPrompt !== void 0 && { chatPrompt: promptInputs.chatPrompt }
+      },
+      cleanupPolicy: {
+        mode: sharedSetup.configuredMode,
+        retainOnSuccess,
+        retainOnFailure,
+        manualCleanup: true
+      },
+      sharedWorkspace: caseSetup.isSharedWorkspace,
+      ...pool !== void 0 && { pool }
+    };
+  } catch (error) {
+    if (sharedSetup) {
+      await releaseSharedWorkspaceSetup(sharedSetup).catch(() => {
+      });
+    }
+    throw error;
+  }
+}
 var AgentVConfigSchema = external_exports.object({
   /** Default execution settings */
   execution: external_exports.object({
@@ -486,7 +639,7 @@ async function extractReposFromEvalFile(filePath) {
   const parsed = interpolateEnv(parseYamlValue(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
-  const evalFileDir = path2.dirname(path2.resolve(filePath));
+  const evalFileDir = path3.dirname(path3.resolve(filePath));
   const repos = [];
   const suiteRepos = await extractReposFromWorkspaceRaw(obj.workspace, evalFileDir);
   repos.push(...suiteRepos);
@@ -502,7 +655,7 @@ async function extractReposFromEvalFile(filePath) {
 }
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path2.resolve(evalFileDir, raw);
+    const workspaceFilePath = path3.resolve(evalFileDir, raw);
     const content = await readFile(workspaceFilePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
@@ -545,7 +698,7 @@ function withFriendlyGitHubAuthError(error) {
 }
 function expandHome(p) {
   if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-    return path3.join(os.homedir(), p.slice(1));
+    return path4.join(os.homedir(), p.slice(1));
   }
   return p;
 }
@@ -557,8 +710,8 @@ function normalizeResultsConfig(config, options) {
   const remote = config.remote?.trim() || "origin";
   const autoPush = config.sync?.auto_push ?? config.auto_push === true;
   const requirePush = config.sync?.require_push === true;
-  const resolvedRepoPath = repoPath ? path3.resolve(options?.baseDir ?? process.cwd(), expandHome(repoPath)) : void 0;
-  const resolvedPath = config.path ? expandHome(config.path.trim()) : repoUrl ? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
+  const resolvedRepoPath = repoPath ? path4.resolve(options?.baseDir ?? process.cwd(), expandHome(repoPath)) : void 0;
+  const resolvedPath = config.path ? expandHome(config.path.trim()) : repoUrl ? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -579,11 +732,11 @@ function resolveResultsRepoUrl(repo) {
   return `https://github.com/${repo}.git`;
 }
 function getResultsRepoLocalPaths(repo) {
-  const rootDir = path3.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  const rootDir = path4.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
-    repoDir: path3.join(rootDir, "repo"),
-    statusFile: path3.join(rootDir, "status.json")
+    repoDir: path4.join(rootDir, "repo"),
+    statusFile: path4.join(rootDir, "status.json")
   };
 }
 function readPersistedStatus(statusFile) {
@@ -597,7 +750,7 @@ function readPersistedStatus(statusFile) {
   }
 }
 function writePersistedStatus(statusFile, status) {
-  mkdirSync(path3.dirname(statusFile), { recursive: true });
+  mkdirSync(path4.dirname(statusFile), { recursive: true });
   writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
 `, "utf8");
 }
@@ -761,9 +914,9 @@ async function ensureResultsRepoClone(config) {
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
   mkdirSync(cachePaths.rootDir, { recursive: true });
-  mkdirSync(path3.dirname(cloneDir), { recursive: true });
+  mkdirSync(path4.dirname(cloneDir), { recursive: true });
   const cloneMissing = !existsSync(cloneDir);
-  const gitDir = path3.join(cloneDir, ".git");
+  const gitDir = path4.join(cloneDir, ".git");
   const cloneEmpty = !cloneMissing && !existsSync(gitDir) && (await readdir(cloneDir)).length === 0;
   if (cloneMissing || cloneEmpty) {
     try {
@@ -939,7 +1092,7 @@ async function hasInProgressGitConflict(repoDir) {
       check: false
     });
     const markerPath = stdout.trim();
-    const resolvedMarkerPath = path3.isAbsolute(markerPath) ? markerPath : path3.join(repoDir, markerPath);
+    const resolvedMarkerPath = path4.isAbsolute(markerPath) ? markerPath : path4.join(repoDir, markerPath);
     if (markerPath && existsSync(resolvedMarkerPath)) {
       return true;
     }
@@ -1403,8 +1556,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(path3.join(os.tmpdir(), "agentv-results-repo-"));
-  const worktreeDir = path3.join(worktreeRoot, "repo");
+  const worktreeRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-repo-"));
+  const worktreeDir = path4.join(worktreeRoot, "repo");
   await runGit(
     ["worktree", "add", "-B", branchName, worktreeDir, `${normalized.remote}/${baseBranch}`],
     {
@@ -1426,12 +1579,12 @@ async function prepareResultsRepoBranch(config, branchName) {
 }
 async function stageResultsArtifacts(params) {
   rmSync(params.destinationDir, { recursive: true, force: true });
-  mkdirSync(path3.dirname(params.destinationDir), { recursive: true });
+  mkdirSync(path4.dirname(params.destinationDir), { recursive: true });
   await cp(params.sourceDir, params.destinationDir, { recursive: true });
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsConfig(config);
-  return path3.join(normalized.path, RESULTS_REPO_RESULTS_DIR, "runs");
+  return path4.join(normalized.path, RESULTS_REPO_RESULTS_DIR, "runs");
 }
 async function directorySizeBytes(targetPath) {
   const entry = await stat(targetPath);
@@ -1440,7 +1593,7 @@ async function directorySizeBytes(targetPath) {
   }
   let total = 0;
   for (const child of await readdir(targetPath, { withFileTypes: true })) {
-    total += await directorySizeBytes(path3.join(targetPath, child.name));
+    total += await directorySizeBytes(path4.join(targetPath, child.name));
   }
   return total;
 }
@@ -1515,7 +1668,7 @@ async function assertValidResultsBranchName(repoDir, branch) {
   await runGit(["check-ref-format", "--branch", branch], { cwd: repoDir });
 }
 function normalizeDestinationPath(destinationPath) {
-  const normalized = destinationPath.split(path3.sep).join("/");
+  const normalized = destinationPath.split(path4.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length === 0 || normalized.startsWith("/") || segments.some((segment) => segment === "..")) {
     throw new Error(`Invalid results destination path: ${destinationPath}`);
@@ -1526,7 +1679,7 @@ async function listSourceFiles(sourceDir) {
   const entries = [];
   async function visit(dir) {
     for (const entry of await readdir(dir, { withFileTypes: true })) {
-      const absolutePath = path3.join(dir, entry.name);
+      const absolutePath = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(absolutePath);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
@@ -1579,14 +1732,14 @@ async function commitResultsRunWithTemporaryIndex(params) {
   await assertValidResultsBranchName(params.repoDir, normalized.branch);
   await ensureResultsBranchNotCheckedOut(params.repoDir, normalized);
   const destinationRunPath = normalizeDestinationPath(params.destinationPath);
-  const destinationTreePath = path3.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
+  const destinationTreePath = path4.posix.join(RESULTS_REPO_RUNS_DIR, destinationRunPath);
   const base = await resolveStorageBranchBase({
     repoDir: params.repoDir,
     normalized,
     preferRemote: params.preferRemoteBase
   });
-  const indexRoot = await mkdtemp(path3.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path3.join(indexRoot, "index");
+  const indexRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-index-"));
+  const indexFile = path4.join(indexRoot, "index");
   const indexEnv = { GIT_INDEX_FILE: indexFile };
   try {
     if (base.baseRef) {
@@ -1608,8 +1761,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
     }
     const sourceFiles = await listSourceFiles(params.sourceDir);
     for (const sourceFile of sourceFiles) {
-      const relativeFile = path3.relative(params.sourceDir, sourceFile).split(path3.sep).join("/");
-      const destinationFile = path3.posix.join(destinationTreePath, relativeFile);
+      const relativeFile = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
+      const destinationFile = path4.posix.join(destinationTreePath, relativeFile);
       const fileStat = await lstat(sourceFile);
       let mode = fileStat.mode & 73 ? "100755" : "100644";
       let hashInputPath = sourceFile;
@@ -1783,7 +1936,7 @@ async function directPushResults(params) {
   return true;
 }
 function buildGitRunId(relativeRunPath) {
-  const normalized = relativeRunPath.split(path3.sep).join("/");
+  const normalized = relativeRunPath.split(path4.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   if (segments.length >= 2) {
     const experiment = segments.slice(0, -1).join("/");
@@ -1887,8 +2040,8 @@ function parseGitBatchBlobs(output) {
 }
 function buildWipBranchName(runDir) {
   const hostname = os.hostname().replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 40);
-  const runBasename = path3.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
-  return `agentv/inflight/${hostname}/${runBasename}`;
+  const runBasename = path4.basename(runDir).replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 60);
+  return `agentv/wip/${hostname}/${runBasename}`;
 }
 async function setupWipWorktree(params) {
   const normalized = normalizeResultsConfig(params.config);
@@ -1906,8 +2059,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(path3.join(os.tmpdir(), "agentv-wip-"));
-  const worktreeDir = path3.join(worktreeRoot, "repo");
+  const worktreeRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-wip-"));
+  const worktreeDir = path4.join(worktreeRoot, "repo");
   await runGit(["worktree", "add", "-B", params.wipBranch, worktreeDir, baseRef], {
     cwd: cloneDir
   });
@@ -1928,7 +2081,7 @@ async function setupWipWorktree(params) {
   };
 }
 async function pushWipCheckpoint(params) {
-  const destinationDir = path3.join(
+  const destinationDir = path4.join(
     params.handle.worktreeDir,
     RESULTS_REPO_RUNS_DIR,
     params.destinationPath
@@ -1985,11 +2138,11 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   const runs = blobs.flatMap((blob, index) => {
     const benchmarkPath = benchmarkPaths[index];
     const benchmark = JSON.parse(blob.content.toString("utf8"));
-    const runDir = path3.posix.dirname(benchmarkPath);
-    const relativeRunPath = path3.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    const runDir = path4.posix.dirname(benchmarkPath);
+    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     const runId = buildGitRunId(relativeRunPath);
-    const timestamp = benchmark.metadata?.timestamp?.trim() || path3.posix.basename(runDir);
-    const displayName = benchmark.metadata?.display_name?.trim() || path3.posix.basename(runDir);
+    const timestamp = benchmark.metadata?.timestamp?.trim() || path4.posix.basename(runDir);
+    const displayName = benchmark.metadata?.display_name?.trim() || path4.posix.basename(runDir);
     const targets = benchmark.metadata?.targets ?? [];
     const passRate = computeAveragePassRate(benchmark.run_summary);
     return [
@@ -1999,7 +2152,7 @@ async function listGitRuns(repoDir, ref = "origin/main") {
         timestamp,
         ...passRate !== void 0 && { pass_rate: passRate },
         ...targets.length === 1 && targets[0] ? { target: targets[0] } : {},
-        manifest_path: path3.posix.join(runDir, "index.jsonl"),
+        manifest_path: path4.posix.join(runDir, "index.jsonl"),
         benchmark_path: benchmarkPath,
         display_name: displayName,
         test_count: benchmark.metadata?.tests_run?.length ?? 0,
@@ -2012,9 +2165,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   return runs;
 }
 async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
-  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 normalizedRunPath = relativeRunPath.split(path4.sep).join("/");
+  const runTreePath = path4.posix.join(RESULTS_REPO_RUNS_DIR, normalizedRunPath);
+  const targetRunDir = path4.join(repoDir, ...runTreePath.split("/"));
   const { stdout: treeOut } = await runGit(["ls-tree", "-r", "--name-only", ref, runTreePath], {
     cwd: repoDir
   });
@@ -2030,16 +2183,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(path3.join(repoDir, ".agentv-run-"));
-  const tempRunDir = path3.join(tempRoot, "run");
+  const tempRoot = mkdtempSync(path4.join(repoDir, ".agentv-run-"));
+  const tempRunDir = path4.join(tempRoot, "run");
   try {
     for (const [index, filePath] of filePaths.entries()) {
-      const relativeFilePath = path3.posix.relative(runTreePath, filePath);
-      const absolutePath = path3.join(tempRunDir, ...relativeFilePath.split("/"));
-      mkdirSync(path3.dirname(absolutePath), { recursive: true });
+      const relativeFilePath = path4.posix.relative(runTreePath, filePath);
+      const absolutePath = path4.join(tempRunDir, ...relativeFilePath.split("/"));
+      mkdirSync(path4.dirname(absolutePath), { recursive: true });
       writeFileSync(absolutePath, blobs[index].content);
     }
-    mkdirSync(path3.dirname(targetRunDir), { recursive: true });
+    mkdirSync(path4.dirname(targetRunDir), { recursive: true });
     try {
       renameSync(tempRunDir, targetRunDir);
     } catch (error) {
@@ -3024,7 +3177,7 @@ function extractResponseItemContent(content) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-var DEFAULT_SESSIONS_DIR = () => path4.join(homedir(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => path5.join(homedir(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -3036,7 +3189,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path4.join(sessionsDir, year);
+    const yearPath = path5.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir2(yearPath);
@@ -3044,7 +3197,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path4.join(yearPath, month);
+      const monthPath = path5.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir2(monthPath);
@@ -3056,7 +3209,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path4.join(monthPath, day);
+        const dayPath = path5.join(monthPath, day);
         let files;
         try {
           files = await readdir2(dayPath);
@@ -3065,7 +3218,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path4.join(dayPath, file);
+          const filePath = path5.join(dayPath, file);
           const nameWithoutExt = file.replace(/\.jsonl$/, "");
           const parts = nameWithoutExt.split("-");
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
@@ -3084,7 +3237,7 @@ async function discoverCodexSessions(opts) {
   sessions.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
   return sessions.slice(0, limit);
 }
-var DEFAULT_PROJECTS_DIR = () => path5.join(homedir2(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path6.join(homedir2(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -3103,7 +3256,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path5.join(projectsDir, projectDir);
+    const dirPath = path6.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir3(dirPath);
@@ -3114,7 +3267,7 @@ async function discoverClaudeSessions(opts) {
       if (!entry.endsWith(".jsonl")) continue;
       const sessionId = entry.replace(/\.jsonl$/, "");
       if (opts?.sessionId && sessionId !== opts.sessionId) continue;
-      const filePath = path5.join(dirPath, entry);
+      const filePath = path6.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat3(filePath);
@@ -3188,6 +3341,7 @@ export {
   transpileEvalYaml,
   transpileEvalYamlFile,
   getOutputFilenames,
+  prepareEvalWorkspace,
   defineConfig,
   loadTsConfig,
   generateRubrics,
@@ -3232,4 +3386,4 @@ export {
   TranscriptProvider,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-I3SC4FOT.js.map
+//# sourceMappingURL=chunk-Z45FKRMJ.js.map