agentv 5.1.0-next.1 → 5.3.0-next.1

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

@@ -8,20 +8,15 @@ import {
   external_exports,
   extractLastAssistantContent,
   getAgentvDataDir,
-  getRepoCheckoutRef,
   groupTranscriptJsonLines,
-  interpolateEnv,
   loadTests,
-  normalizeRepoIdentity,
   normalizeToolCall,
-  parseRepoConfig,
   parseYamlValue,
   prepareEvalCaseWorkspace,
   prepareSharedWorkspaceSetup,
   readTranscriptJsonl,
-  releaseSharedWorkspaceSetup,
-  resolveRepoCloneUrl
-} from "./chunk-ZGPCX334.js";
+  releaseSharedWorkspaceSetup
+} from "./chunk-6ZZCDZPD.js";
 
 // ../../packages/core/dist/index.js
 import { readFileSync } from "node:fs";
@@ -29,8 +24,6 @@ import path from "node:path";
 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 { createHash, randomBytes } from "node:crypto";
 import {
@@ -43,19 +36,19 @@ import {
   rmSync,
   writeFileSync
 } from "node:fs";
-import { cp, lstat, mkdtemp, readFile as readFile2, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { cp, lstat, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
-import path4 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 path5 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 path6 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);
@@ -1789,7 +1782,7 @@ async function prepareEvalWorkspace(options) {
     });
     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.`
       );
     }
     return {
@@ -2018,82 +2011,6 @@ 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 readFile(filePath, "utf8");
-  const parsed = interpolateEnv(parseYamlValue(content), process.env);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
-  const obj = parsed;
-  const evalFileDir = path3.dirname(path3.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 = 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 [];
-    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 = ".";
@@ -2142,13 +2059,13 @@ function withFriendlyGitHubAuthError(error) {
 }
 function expandHome(p) {
   if (p === "~" || p.startsWith("~/") || p.startsWith("~\\")) {
-    return path4.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 path4.isAbsolute(expanded) ? expanded : path4.resolve(baseDir, expanded);
+  return path3.isAbsolute(expanded) ? expanded : path3.resolve(baseDir, expanded);
 }
 function isNormalizedResultsConfig(config) {
   return typeof config.storageBranchWorktree === "boolean";
@@ -2169,7 +2086,7 @@ function normalizeResultsConfig(config, options) {
   const autoPush = config.auto_push === true;
   const requirePush = config.require_push === true;
   const resolvedRepoPath = repoPath ? resolveLocalPath(repoPath, baseDir) : void 0;
-  const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path4.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
+  const resolvedPath = explicitClonePath ? resolveLocalPath(explicitClonePath, baseDir) : repoUrl ? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repoUrl)) : resolvedRepoPath ?? path3.join(getAgentvDataDir(), "results", sanitizeRepoSlug(repo));
   return {
     mode: "github",
     repo,
@@ -2199,11 +2116,11 @@ function resolveResultsRepoUrl(repo) {
   return trimmed;
 }
 function getResultsRepoLocalPaths(repo) {
-  const rootDir = path4.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
+  const rootDir = path3.join(getAgentvDataDir(), "cache", "results-repo", sanitizeRepoSlug(repo));
   return {
     rootDir,
-    repoDir: path4.join(rootDir, "repo"),
-    statusFile: path4.join(rootDir, "status.json")
+    repoDir: path3.join(rootDir, "repo"),
+    statusFile: path3.join(rootDir, "status.json")
   };
 }
 function usesStorageBranchWorktree(config) {
@@ -2220,7 +2137,7 @@ function readPersistedStatus(statusFile) {
   }
 }
 function writePersistedStatus(statusFile, status) {
-  mkdirSync(path4.dirname(statusFile), { recursive: true });
+  mkdirSync(path3.dirname(statusFile), { recursive: true });
   writeFileSync(statusFile, `${JSON.stringify(status, null, 2)}
 `, "utf8");
 }
@@ -2463,7 +2380,7 @@ async function ensureResultsMergeConfig(repoDir) {
   try {
     const { stdout } = await runGit(["rev-parse", "--git-common-dir"], { cwd: repoDir });
     const resolved = stdout.trim();
-    gitDir = resolved ? path4.isAbsolute(resolved) ? resolved : path4.join(repoDir, resolved) : path4.join(repoDir, ".git");
+    gitDir = resolved ? path3.isAbsolute(resolved) ? resolved : path3.join(repoDir, resolved) : path3.join(repoDir, ".git");
   } catch {
     return;
   }
@@ -2472,8 +2389,8 @@ async function ensureResultsMergeConfig(repoDir) {
 var RESULTS_INFO_ATTRIBUTES_BEGIN = "# >>> agentv results merge attributes >>>";
 var RESULTS_INFO_ATTRIBUTES_END = "# <<< agentv results merge attributes <<<";
 function writeResultsInfoAttributes(gitDir) {
-  const infoDir = path4.join(gitDir, "info");
-  const attributesPath = path4.join(infoDir, "attributes");
+  const 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}
@@ -2509,9 +2426,9 @@ async function addResultsGitattributesToIndex(repoDir, indexEnv) {
   if (existing === RESULTS_REPO_GITATTRIBUTES_CONTENT) {
     return;
   }
-  const scratchDir = mkdtempSync(path4.join(os.tmpdir(), "agentv-results-attrs-"));
+  const scratchDir = mkdtempSync(path3.join(os.tmpdir(), "agentv-results-attrs-"));
   try {
-    const scratchFile = path4.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
@@ -2551,9 +2468,9 @@ async function ensureResultsRepoClone(config) {
   const cachePaths = getResultsRepoLocalPaths(normalized.repo);
   const cloneDir = normalized.path;
   mkdirSync(cachePaths.rootDir, { recursive: true });
-  mkdirSync(path4.dirname(cloneDir), { recursive: true });
+  mkdirSync(path3.dirname(cloneDir), { recursive: true });
   const cloneMissing = !existsSync(cloneDir);
-  const gitDir = path4.join(cloneDir, ".git");
+  const gitDir = path3.join(cloneDir, ".git");
   const cloneEmpty = !cloneMissing && !existsSync(gitDir) && (await readdir(cloneDir)).length === 0;
   if (cloneMissing || cloneEmpty) {
     try {
@@ -2719,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 = path4.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);
@@ -2825,7 +2742,7 @@ async function hasInProgressGitConflict(repoDir) {
       check: false
     });
     const markerPath = stdout.trim();
-    const resolvedMarkerPath = path4.isAbsolute(markerPath) ? markerPath : path4.join(repoDir, markerPath);
+    const resolvedMarkerPath = path3.isAbsolute(markerPath) ? markerPath : path3.join(repoDir, markerPath);
     if (markerPath && existsSync(resolvedMarkerPath)) {
       return true;
     }
@@ -2997,7 +2914,7 @@ function withActionFlags(status, flags) {
   };
 }
 function isSafeResultsRepoPath(p) {
-  const normalized = p.split(path4.sep).join("/");
+  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(
@@ -3006,11 +2923,11 @@ function isSafeResultsRepoPath(p) {
 }
 async function existingTrackedResultsPathspecs(repoDir) {
   const targets = /* @__PURE__ */ new Set();
-  if (existsSync(path4.join(repoDir, RESULTS_REPO_GITATTRIBUTES_FILE))) {
+  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(path4.join(repoDir, dir))) {
+    if (existsSync(path3.join(repoDir, dir))) {
       targets.add(dir);
       continue;
     }
@@ -3023,7 +2940,7 @@ async function existingTrackedResultsPathspecs(repoDir) {
     if (entry.name.startsWith(".") || !entry.isDirectory()) {
       continue;
     }
-    if (existsSync(path4.join(repoDir, entry.name, "summary.json"))) {
+    if (existsSync(path3.join(repoDir, entry.name, "summary.json"))) {
       targets.add(entry.name);
     }
   }
@@ -4000,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(path4.join(os.tmpdir(), "agentv-results-repo-"));
-  const worktreeDir = path4.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}`],
     {
@@ -4023,12 +3940,12 @@ async function prepareResultsRepoBranch(config, branchName) {
 }
 async function stageResultsArtifacts(params) {
   rmSync(params.destinationDir, { recursive: true, force: true });
-  mkdirSync(path4.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 path4.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);
@@ -4037,7 +3954,7 @@ async function directorySizeBytes(targetPath) {
   }
   let total = 0;
   for (const child of await readdir(targetPath, { withFileTypes: true })) {
-    total += await directorySizeBytes(path4.join(targetPath, child.name));
+    total += await directorySizeBytes(path3.join(targetPath, child.name));
   }
   return total;
 }
@@ -4104,7 +4021,7 @@ async function assertValidResultsBranchName(repoDir, branch) {
   await runGit(["check-ref-format", "--branch", branch], { cwd: repoDir });
 }
 function normalizeDestinationPath(destinationPath) {
-  const normalized = destinationPath.split(path4.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);
@@ -4118,7 +4035,7 @@ async function listSourceFiles(sourceDir) {
   const entries = [];
   async function visit(dir) {
     for (const entry of await readdir(dir, { withFileTypes: true })) {
-      const absolutePath = path4.join(dir, entry.name);
+      const absolutePath = path3.join(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(absolutePath);
       } else if (entry.isFile() || entry.isSymbolicLink()) {
@@ -4152,7 +4069,7 @@ function artifactSidecarPointers(record) {
   return pointers;
 }
 function artifactSidecarKey(destinationPath, pointerPath) {
-  return path4.posix.join(
+  return path3.posix.join(
     RESULTS_REPO_RUNS_DIR,
     normalizeDestinationPath(destinationPath),
     normalizeDestinationPath(pointerPath)
@@ -4168,18 +4085,18 @@ function safeLocalSummaryManifestPath(sourceDir, manifestPath) {
   if (typeof manifestPath !== "string" || manifestPath.trim().length === 0) {
     return void 0;
   }
-  if (path4.isAbsolute(manifestPath)) {
+  if (path3.isAbsolute(manifestPath)) {
     return void 0;
   }
-  const normalized = path4.normalize(manifestPath);
-  if (normalized.startsWith("..") || path4.isAbsolute(normalized)) {
+  const normalized = path3.normalize(manifestPath);
+  if (normalized.startsWith("..") || path3.isAbsolute(normalized)) {
     return void 0;
   }
-  return path4.join(sourceDir, normalized);
+  return path3.join(sourceDir, normalized);
 }
 function resolveLocalResultManifestPath(sourceDir) {
   try {
-    const summary = JSON.parse(readFileSync2(path4.join(sourceDir, "summary.json"), "utf8"));
+    const summary = JSON.parse(readFileSync2(path3.join(sourceDir, "summary.json"), "utf8"));
     const manifestPath2 = safeLocalSummaryManifestPath(
       sourceDir,
       summary.index_path ?? summary.manifest_path
@@ -4189,11 +4106,11 @@ function resolveLocalResultManifestPath(sourceDir) {
     }
   } catch {
   }
-  const manifestPath = path4.join(sourceDir, RUN_INTERNAL_DIRNAME, RESULT_INDEX_FILENAME2);
+  const manifestPath = path3.join(sourceDir, RUN_INTERNAL_DIRNAME, RESULT_INDEX_FILENAME2);
   if (existsSync(manifestPath)) {
     return manifestPath;
   }
-  const legacyManifestPath = path4.join(sourceDir, RESULT_INDEX_FILENAME2);
+  const legacyManifestPath = path3.join(sourceDir, RESULT_INDEX_FILENAME2);
   if (existsSync(legacyManifestPath)) {
     return legacyManifestPath;
   }
@@ -4219,10 +4136,10 @@ function collectArtifactSidecarPointers(sourceDir) {
 }
 function resolveArtifactPointerSourcePath(sourceDir, pointerPath) {
   const normalizedPointerPath = normalizeDestinationPath(pointerPath);
-  const sourceRoot = path4.resolve(sourceDir);
-  const sourcePath = path4.resolve(sourceRoot, ...normalizedPointerPath.split("/"));
-  const relative = path4.relative(sourceRoot, sourcePath);
-  if (relative.startsWith("..") || path4.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;
@@ -4240,7 +4157,7 @@ async function prepareArtifactSidecar(params) {
   if (params.pointers.length === 0) {
     return void 0;
   }
-  const sidecarRoot = await mkdtemp(path4.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 {
@@ -4256,8 +4173,8 @@ async function prepareArtifactSidecar(params) {
       if (copied.has(relativePointerPath)) {
         continue;
       }
-      const destinationPath = path4.join(sidecarRoot, ...relativePointerPath.split("/"));
-      mkdirSync(path4.dirname(destinationPath), { recursive: true });
+      const destinationPath = path3.join(sidecarRoot, ...relativePointerPath.split("/"));
+      mkdirSync(path3.dirname(destinationPath), { recursive: true });
       writeFileSync(destinationPath, content);
       copied.add(relativePointerPath);
     }
@@ -4309,19 +4226,19 @@ async function preparePublishedResultsSource(params) {
   if (params.pointers.length === 0) {
     return void 0;
   }
-  const publishedRoot = await mkdtemp(path4.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 = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
-      const destinationFile = path4.join(publishedRoot, ...relativeFile.split("/"));
-      if (isResultManifestFilename(path4.posix.basename(relativeFile))) {
+      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(path4.dirname(destinationFile), { recursive: true });
+        mkdirSync(path3.dirname(destinationFile), { recursive: true });
         writeFileSync(destinationFile, rewritten);
         continue;
       }
@@ -4331,7 +4248,7 @@ async function preparePublishedResultsSource(params) {
       if (omittedPaths.has(relativeFile)) {
         continue;
       }
-      mkdirSync(path4.dirname(destinationFile), { recursive: true });
+      mkdirSync(path3.dirname(destinationFile), { recursive: true });
       await cp(sourceFile, destinationFile, { dereference: false });
     }
   } catch (error) {
@@ -4398,8 +4315,8 @@ async function commitStorageBranchWorktreePaths(params) {
       normalized
     });
   }
-  const indexRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path4.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) {
@@ -4409,7 +4326,7 @@ async function commitStorageBranchWorktreePaths(params) {
     }
     await addResultsGitattributesToIndex(params.repoDir, indexEnv);
     for (const gitPath of paths) {
-      const sourcePath = path4.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,
@@ -4475,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 = path4.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,
@@ -4489,8 +4406,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
       preferRemote: params.preferRemoteBase
     });
   }
-  const indexRoot = await mkdtemp(path4.join(os.tmpdir(), "agentv-results-index-"));
-  const indexFile = path4.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) {
@@ -4513,8 +4430,8 @@ async function commitResultsRunWithTemporaryIndex(params) {
     }
     const sourceFiles = await listSourceFiles(params.sourceDir);
     for (const sourceFile of sourceFiles) {
-      const relativeFile = path4.relative(params.sourceDir, sourceFile).split(path4.sep).join("/");
-      const destinationFile = path4.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;
@@ -4794,18 +4711,18 @@ function safeGitSummaryManifestPath(runDir, manifestPath) {
   if (manifestPath.startsWith("/")) {
     return void 0;
   }
-  const normalized = path4.posix.normalize(manifestPath);
+  const normalized = path3.posix.normalize(manifestPath);
   if (normalized === ".." || normalized.startsWith("../")) {
     return void 0;
   }
-  return path4.posix.join(runDir, normalized);
+  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 = path4.posix.dirname(summaryPath);
-    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    const runDir = path3.posix.dirname(summaryPath);
+    const relativeRunPath = path3.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     if (!isV2ResultsRepoRunPath(relativeRunPath)) {
       continue;
     }
@@ -4819,7 +4736,7 @@ function buildGitManifestPaths(treePaths, summaryByPath) {
       continue;
     }
     const runDir = gitRunDirForManifestPath(treePath);
-    const relativeRunPath = path4.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
+    const relativeRunPath = path3.posix.relative(RESULTS_REPO_RUNS_DIR, runDir);
     if (!isV2ResultsRepoRunPath(relativeRunPath)) {
       continue;
     }
@@ -4831,8 +4748,8 @@ function buildGitManifestPaths(treePaths, summaryByPath) {
 }
 function fallbackGitManifestPath(runDir, treePathSet) {
   for (const candidate of [
-    path4.posix.join(runDir, ".internal", RESULT_INDEX_FILENAME2),
-    path4.posix.join(runDir, RESULT_INDEX_FILENAME2)
+    path3.posix.join(runDir, ".internal", RESULT_INDEX_FILENAME2),
+    path3.posix.join(runDir, RESULT_INDEX_FILENAME2)
   ]) {
     if (treePathSet.has(candidate)) {
       return candidate;
@@ -4841,15 +4758,15 @@ function fallbackGitManifestPath(runDir, treePathSet) {
   return void 0;
 }
 function gitRunDirForManifestPath(manifestPath) {
-  const manifestDir = path4.posix.dirname(manifestPath);
-  return path4.posix.basename(manifestDir) === ".internal" ? path4.posix.dirname(manifestDir) : manifestDir;
+  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(path4.sep).join("/");
+  const normalized = relativeRunPath.split(path3.sep).join("/");
   const segments = normalized.split("/").filter(Boolean);
   return segments[0] ?? relativeRunPath;
 }
@@ -4978,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 = path4.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) {
@@ -4997,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(path4.join(os.tmpdir(), "agentv-wip-"));
-  const worktreeDir = path4.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
   });
@@ -5017,7 +4934,7 @@ async function setupWipWorktree(params) {
   };
 }
 async function pushWipCheckpoint(params) {
-  const destinationDir = path4.join(
+  const destinationDir = path3.join(
     params.handle.worktreeDir,
     RESULTS_REPO_RUNS_DIR,
     params.destinationPath
@@ -5028,7 +4945,7 @@ async function pushWipCheckpoint(params) {
     destinationDir
   });
   writeFileSync(
-    path4.join(params.handle.worktreeDir, RESULTS_REPO_GITATTRIBUTES_FILE),
+    path3.join(params.handle.worktreeDir, RESULTS_REPO_GITATTRIBUTES_FILE),
     RESULTS_REPO_GITATTRIBUTES_CONTENT
   );
   await runGit(["add", "--all", "--", RESULTS_REPO_GITATTRIBUTES_FILE, params.destinationPath], {
@@ -5084,7 +5001,7 @@ function gitResultsIndexHash(value) {
   return createHash("sha256").update(value).digest("hex");
 }
 function resolveGitResultsIndexRepoDir(repoDir) {
-  const resolved = path4.resolve(repoDir);
+  const resolved = path3.resolve(repoDir);
   try {
     return realpathSync(resolved);
   } catch {
@@ -5100,7 +5017,7 @@ function gitResultsIndexRefKey(ref) {
 }
 function resolveGitResultsIndexCacheFile(params) {
   const ref = params.ref ?? "origin/main";
-  return path4.join(
+  return path3.join(
     getAgentvDataDir(),
     "cache",
     "results-index",
@@ -5127,7 +5044,7 @@ function validateGitResultsIndexCacheFile(value, params) {
 async function readGitResultsIndexCache(params) {
   const cacheFile = resolveGitResultsIndexCacheFile(params);
   try {
-    const parsed = JSON.parse(await readFile2(cacheFile, "utf8"));
+    const parsed = JSON.parse(await readFile(cacheFile, "utf8"));
     return validateGitResultsIndexCacheFile(parsed, params)?.runs;
   } catch {
     return void 0;
@@ -5146,7 +5063,7 @@ async function writeGitResultsIndexCache(params) {
     runs: params.runs
   };
   try {
-    mkdirSync(path4.dirname(cacheFile), { recursive: true });
+    mkdirSync(path3.dirname(cacheFile), { recursive: true });
     const tempFile = `${cacheFile}.${process.pid}.${Date.now()}.tmp`;
     await writeFile(tempFile, `${JSON.stringify(envelope, null, 2)}
 `, "utf8");
@@ -5224,9 +5141,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   const runs = blobs.flatMap((blob, index) => {
     const manifestPath = indexPaths[index];
     const runDir = gitRunDirForManifestPath(manifestPath);
-    const summaryPath = path4.posix.join(runDir, "summary.json");
+    const summaryPath = path3.posix.join(runDir, "summary.json");
     const summary = summaryByPath.get(summaryPath);
-    const relativeRunPath = path4.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) => {
@@ -5247,8 +5164,8 @@ 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 || path4.posix.basename(runDir);
-    const displayName = summary?.metadata?.display_name?.trim() || path4.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(
@@ -5275,9 +5192,9 @@ async function listGitRuns(repoDir, ref = "origin/main") {
   return runs;
 }
 async function materializeGitRun(repoDir, relativeRunPath, ref = "origin/main") {
-  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 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
   });
@@ -5293,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(path4.join(repoDir, ".agentv-run-"));
-  const tempRunDir = path4.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 = path4.posix.relative(runTreePath, filePath);
-      const absolutePath = path4.join(tempRunDir, ...relativeFilePath.split("/"));
-      mkdirSync(path4.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(path4.dirname(targetRunDir), { recursive: true });
+    mkdirSync(path3.dirname(targetRunDir), { recursive: true });
     try {
       renameSync(tempRunDir, targetRunDir);
     } catch (error) {
@@ -5810,7 +5727,7 @@ function extractResponseItemContent(content) {
   }
   return parts.length > 0 ? parts.join("") : void 0;
 }
-var DEFAULT_SESSIONS_DIR = () => path5.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;
@@ -5822,7 +5739,7 @@ async function discoverCodexSessions(opts) {
     return [];
   }
   for (const year of yearDirs) {
-    const yearPath = path5.join(sessionsDir, year);
+    const yearPath = path4.join(sessionsDir, year);
     let monthDirs;
     try {
       monthDirs = await readdir2(yearPath);
@@ -5830,7 +5747,7 @@ async function discoverCodexSessions(opts) {
       continue;
     }
     for (const month of monthDirs) {
-      const monthPath = path5.join(yearPath, month);
+      const monthPath = path4.join(yearPath, month);
       let dayDirs;
       try {
         dayDirs = await readdir2(monthPath);
@@ -5842,7 +5759,7 @@ async function discoverCodexSessions(opts) {
           const dirDate = `${year}-${month}-${day}`;
           if (dirDate !== opts.date) continue;
         }
-        const dayPath = path5.join(monthPath, day);
+        const dayPath = path4.join(monthPath, day);
         let files;
         try {
           files = await readdir2(dayPath);
@@ -5851,7 +5768,7 @@ async function discoverCodexSessions(opts) {
         }
         for (const file of files) {
           if (!file.startsWith("rollout-") || !file.endsWith(".jsonl")) continue;
-          const filePath = path5.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;
@@ -5870,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 = () => path6.join(homedir2(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path5.join(homedir2(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -5889,7 +5806,7 @@ async function discoverClaudeSessions(opts) {
   }
   const sessions = [];
   for (const projectDir of projectDirs) {
-    const dirPath = path6.join(projectsDir, projectDir);
+    const dirPath = path5.join(projectsDir, projectDir);
     let entries;
     try {
       entries = await readdir3(dirPath);
@@ -5900,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 = path6.join(dirPath, entry);
+      const filePath = path5.join(dirPath, entry);
       let updatedAt;
       try {
         const fileStat = await stat3(filePath);
@@ -6128,7 +6045,6 @@ export {
   defineConfig,
   loadTsConfig,
   generateRubrics,
-  scanRepoDeps,
   normalizeResultsConfig,
   resolveResultsRepoUrl,
   getResultsRepoLocalPaths,
@@ -6173,4 +6089,4 @@ export {
   parseCopilotEvents,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-GJWPQXHN.js.map
+//# sourceMappingURL=chunk-V52ATPTT.js.map