agentv 4.37.0-next.1 → 4.38.0

package/dist/{chunk-RL4S2FBZ.js → chunk-VBHHZQS6.js}

@@ -493,8 +493,8 @@ function getErrorMap() {
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path48, errorMaps, issueData } = params;
-  const fullPath = [...path48, ...issueData.path || []];
+  const { data, path: path49, errorMaps, issueData } = params;
+  const fullPath = [...path49, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -610,11 +610,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path48, key) {
+  constructor(parent, value, path49, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path48;
+    this._path = path49;
     this._key = key;
   }
   get path() {
@@ -4056,7 +4056,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-M4YHZQII.js
+// ../../packages/core/dist/chunk-M54RBDXI.js
 import { parse } from "yaml";
 import os from "node:os";
 import path from "node:path";
@@ -6184,21 +6184,21 @@ async function expandFileReferences(tests, evalFileDir) {
   return expanded;
 }
 
-// ../../packages/core/dist/chunk-RRVABR4Z.js
-import path47 from "node:path";
+// ../../packages/core/dist/chunk-RH5LAMMU.js
+import path48 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { existsSync as existsSync6 } from "node:fs";
-import path46 from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import path47 from "node:path";
 import micromatch4 from "micromatch";
 import { mkdir, readFile as readFile3, writeFile } from "node:fs/promises";
 import path5 from "node:path";
-import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash4, randomUUID as randomUUID9 } from "node:crypto";
-import { existsSync as existsSync5 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir16, readdir as readdir8, stat as stat9 } from "node:fs/promises";
-import path45 from "node:path";
+import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash5, randomUUID as randomUUID10 } from "node:crypto";
+import { existsSync as existsSync6 } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir17, readdir as readdir8, stat as stat9 } from "node:fs/promises";
+import path46 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
-import { promisify as promisify7 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 import micromatch3 from "micromatch";
 import { mkdtemp, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -6916,10 +6916,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path48) {
-  if (!path48)
+function getElementAtPath(obj, path49) {
+  if (!path49)
     return obj;
-  return path48.reduce((acc, key) => acc?.[key], obj);
+  return path49.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7239,11 +7239,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path48, issues) {
+function prefixIssues(path49, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path48);
+    iss.path.unshift(path49);
     return iss;
   });
 }
@@ -7380,7 +7380,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path48 = []) => {
+  const processError = (error41, path49 = []) => {
     var _a, _b;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -7390,7 +7390,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path48, ...issue2.path];
+        const fullpath = [...path49, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7420,9 +7420,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path48) {
+function toDotPath(path49) {
   const segs = [];
-  for (const seg of path48) {
+  for (const seg of path49) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18852,7 +18852,7 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../packages/core/dist/chunk-RRVABR4Z.js
+// ../../packages/core/dist/chunk-RH5LAMMU.js
 import { exec as execCallback } from "node:child_process";
 import { readdirSync, statSync } from "node:fs";
 import { readFile as readFile32, readdir as readdir2, stat as stat2 } from "node:fs/promises";
@@ -18927,38 +18927,41 @@ import path33 from "node:path";
 import fg3 from "fast-glob";
 import { cp, mkdir as mkdir14, readdir as readdir5, rm as rm4, stat as stat6 } from "node:fs/promises";
 import path34 from "node:path";
-import { execFile } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
 import { cp as cp2, mkdir as mkdir15, readFile as readFile11, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile9 } from "node:fs/promises";
 import path35 from "node:path";
+import { execFile, spawn as spawn5 } from "node:child_process";
+import { createHash as createHash4, randomUUID as randomUUID9 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+import { mkdir as mkdir16, rename, rm as rm6 } from "node:fs/promises";
+import path37 from "node:path";
 import { promisify as promisify5 } from "node:util";
-import { execFile as execFile2 } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync22, readdirSync as readdirSync3, statSync as statSync2, writeFileSync } from "node:fs";
 import path36 from "node:path";
-import { promisify as promisify6 } from "node:util";
+import { stringify as stringifyYaml } from "yaml";
 import { readdir as readdir7, stat as stat7 } from "node:fs/promises";
-import path37 from "node:path";
+import path38 from "node:path";
 import { readFile as readFile18, stat as stat8 } from "node:fs/promises";
-import path44 from "node:path";
+import path45 from "node:path";
 import micromatch2 from "micromatch";
-import { stringify as stringifyYaml } from "yaml";
+import { stringify as stringifyYaml2 } from "yaml";
 import { readFile as readFile12 } from "node:fs/promises";
-import path38 from "node:path";
+import path39 from "node:path";
 import { readFile as readFile13 } from "node:fs/promises";
-import path40 from "node:path";
+import path41 from "node:path";
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path39 from "node:path";
+import path40 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { readFile as readFile15 } from "node:fs/promises";
-import path41 from "node:path";
+import path422 from "node:path";
 import { readFile as readFile14 } from "node:fs/promises";
 import { readFile as readFile17 } from "node:fs/promises";
-import path43 from "node:path";
+import path44 from "node:path";
 import micromatch from "micromatch";
 import { readFile as readFile16 } from "node:fs/promises";
-import path422 from "node:path";
+import path43 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -19489,14 +19492,14 @@ function toCamelCaseDeep(obj) {
   }
   return obj;
 }
-function getRepoCheckoutRef(checkout) {
-  return checkout?.base_commit ?? checkout?.ref ?? "HEAD";
+function getRepoCheckoutRef(repo) {
+  return repo?.commit ?? repo?.base_commit ?? "HEAD";
 }
 function getRepoCheckoutTargets(repos) {
   if (!repos) return [];
-  return repos.filter((repo) => repo.checkout?.base_commit || repo.checkout?.ref).map((repo) => ({
+  return repos.filter((repo) => repo.commit || repo.base_commit).map((repo) => ({
     path: repo.path,
-    ref: getRepoCheckoutRef(repo.checkout)
+    ref: getRepoCheckoutRef(repo)
   }));
 }
 var FILE_BACKED_OUTPUT_THRESHOLD = 5e4;
@@ -22529,115 +22532,115 @@ var FieldAccuracyGrader = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path48, match, required: required2 = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path48);
-    const expectedValue = resolvePath(expectedData, path48);
+    const { path: path49, match, required: required2 = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path49);
+    const expectedValue = resolvePath(expectedData, path49);
     if (expectedValue === void 0) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path48}: no expected value`
+        message: `${path49}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required2) {
         return {
-          path: path48,
+          path: path49,
           score: 0,
           weight,
           hit: false,
-          message: `${path48} (required, missing)`
+          message: `${path49} (required, missing)`
         };
       }
       return {
-        path: path48,
+        path: path49,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path48}: optional field missing`
+        message: `${path49}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path48, candidateValue, expectedValue, weight);
+        return this.compareExact(path49, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path48,
+          path49,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path48, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path49, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path48,
+          path: path49,
           score: 0,
           weight,
           hit: false,
-          message: `${path48}: unknown match type "${match}"`
+          message: `${path49}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path48, candidateValue, expectedValue, weight) {
+  compareExact(path49, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         weight,
         hit: true,
-        message: path48
+        message: path49
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path49} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path48,
+      path: path49,
       score: 0,
       weight,
       hit: false,
-      message: `${path48} (value mismatch)`
+      message: `${path49} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path48, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path49, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (non-numeric value)`
+        message: `${path49} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (invalid numeric value)`
+        message: `${path49} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -22650,61 +22653,61 @@ var FieldAccuracyGrader = class {
     }
     if (withinTolerance) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         weight,
         hit: true,
-        message: `${path48} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path49} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path48,
+      path: path49,
       score: 0,
       weight,
       hit: false,
-      message: `${path48} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path49} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path48, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path49, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (unparseable candidate date)`
+        message: `${path49} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path48,
+        path: path49,
         score: 0,
         weight,
         hit: false,
-        message: `${path48} (unparseable expected date)`
+        message: `${path49} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path48,
+        path: path49,
         score: 1,
         weight,
         hit: true,
-        message: path48
+        message: path49
       };
     }
     return {
-      path: path48,
+      path: path49,
       score: 0,
       weight,
       hit: false,
-      message: `${path48} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path49} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -22737,11 +22740,11 @@ var FieldAccuracyGrader = class {
     };
   }
 };
-function resolvePath(obj, path48) {
-  if (!path48 || !obj) {
+function resolvePath(obj, path49) {
+  if (!path49 || !obj) {
     return void 0;
   }
-  const parts = path48.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path49.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -23275,8 +23278,8 @@ var TokenUsageGrader = class {
     };
   }
 };
-function getNestedValue(obj, path48) {
-  const parts = path48.split(".");
+function getNestedValue(obj, path49) {
+  const parts = path49.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -32958,47 +32961,57 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
     await rm4(evalDir, { recursive: true, force: true });
   }
 }
-var execFileAsync = promisify5(execFile);
-function gitEnv() {
-  const env = { ...process.env };
-  for (const key of Object.keys(env)) {
-    if (key.startsWith("GIT_") && key !== "GIT_SSH_COMMAND") {
-      delete env[key];
+var GITHUB_SHORTHAND_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function resolveRepoCloneUrl(repo) {
+  const trimmed = repo.trim();
+  if (GITHUB_SHORTHAND_RE.test(trimmed)) {
+    return `https://github.com/${trimmed}.git`;
+  }
+  return trimmed;
+}
+function normalizeRepoIdentity(repo) {
+  const cloneUrl = resolveRepoCloneUrl(repo);
+  const sshMatch = /^git@([^:]+):(.+)$/.exec(cloneUrl);
+  if (sshMatch) {
+    return normalizeHostPath(sshMatch[1], sshMatch[2]);
+  }
+  try {
+    const parsed = new URL(cloneUrl);
+    if (parsed.protocol === "ssh:" && parsed.username === "git") {
+      return normalizeHostPath(parsed.hostname, parsed.pathname);
+    }
+    if (parsed.protocol === "http:" || parsed.protocol === "https:") {
+      return normalizeHostPath(parsed.hostname, parsed.pathname);
     }
+    if (parsed.protocol === "file:") {
+      return `file://${stripGitSuffix(decodeURIComponent(parsed.pathname)).replace(/\/+$/, "")}`;
+    }
+  } catch {
   }
-  return {
-    ...env,
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_ASKPASS: "",
-    GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
-  };
+  return stripGitSuffix(cloneUrl).replace(/\/+$/, "");
 }
-async function git(args, opts) {
-  const { stdout } = await execFileAsync("git", args, {
-    cwd: opts?.cwd,
-    timeout: opts?.timeout ?? 3e5,
-    env: gitEnv(),
-    maxBuffer: 50 * 1024 * 1024
-  });
-  return stdout.trim();
+function normalizeHostPath(host, rawPath) {
+  const normalizedPath = stripGitSuffix(rawPath.replace(/^\/+/, "").replace(/\/+$/, ""));
+  const normalized = host.toLowerCase() === "github.com" ? normalizedPath.toLowerCase() : normalizedPath;
+  return `${host.toLowerCase()}/${normalized}`;
+}
+function stripGitSuffix(value) {
+  return value.replace(/\.git$/i, "");
 }
 function normalizeRepoForFingerprint(repo) {
   const result = {};
   if (repo.path) {
     result.path = repo.path;
   }
-  if (repo.source) {
-    result.source = repo.source.type === "git" ? { type: "git", url: repo.source.url.toLowerCase().replace(/\.git$/, "") } : { type: "local", path: repo.source.path };
-  }
-  result.ref = getRepoCheckoutRef(repo.checkout);
-  if (repo.clone?.depth !== void 0) {
-    result.depth = repo.clone.depth;
+  if (repo.repo) {
+    result.repo = normalizeRepoIdentity(repo.repo);
   }
-  if (repo.clone?.filter !== void 0) {
-    result.filter = repo.clone.filter;
+  result.ref = getRepoCheckoutRef(repo);
+  if (repo.ancestor !== void 0) {
+    result.ancestor = repo.ancestor;
   }
-  if (repo.clone?.sparse?.length) {
-    result.sparse = [...repo.clone.sparse].sort();
+  if (repo.sparse?.length) {
+    result.sparse = [...repo.sparse].sort();
   }
   return result;
 }
@@ -33064,7 +33077,7 @@ var WorkspacePoolManager = class {
       }
       const slotExists = existsSync3(slotPath);
       if (slotExists) {
-        await this.resetSlot(slotPath, templatePath, repos, poolReset);
+        await this.resetSlot(slotPath, templatePath, repos, options.repoManager, poolReset);
         return {
           index: i,
           path: slotPath,
@@ -33193,33 +33206,12 @@ var WorkspacePoolManager = class {
   }
   /**
    * Reset an existing slot for reuse:
-   * 1. Reset repos (fetch from origin when resolve=remote, then git reset --hard && git clean per repo)
+   * 1. Reset repos to their declared checkout, then git clean per repo
    * 2. Re-copy template files (skip repo directories)
    */
-  async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
-    for (const repo of repos) {
-      if (!repo.path || !repo.source) continue;
-      const repoDir = path35.join(slotPath, repo.path);
-      if (!existsSync3(repoDir)) {
-        continue;
-      }
-      if (poolReset === "none") {
-        continue;
-      }
-      const ref = getRepoCheckoutRef(repo.checkout);
-      const resolve = repo.checkout?.resolve ?? "remote";
-      if (resolve === "remote") {
-        const fetchArgs = ["fetch", "origin", ref];
-        if (repo.clone?.depth) {
-          fetchArgs.splice(1, 0, "--depth", String(repo.clone.depth));
-        }
-        await git(fetchArgs, { cwd: repoDir });
-        await git(["reset", "--hard", "FETCH_HEAD"], { cwd: repoDir });
-      } else {
-        await git(["reset", "--hard", ref], { cwd: repoDir });
-      }
-      const cleanFlag = poolReset === "strict" ? "-fdx" : "-fd";
-      await git(["clean", cleanFlag], { cwd: repoDir });
+  async resetSlot(slotPath, templatePath, repos, repoManager, poolReset = "fast") {
+    if (poolReset !== "none") {
+      await repoManager.reset(repos, slotPath, poolReset);
     }
     if (templatePath) {
       const repoDirNames = new Set(
@@ -33232,9 +33224,201 @@ var WorkspacePoolManager = class {
     }
   }
 };
-var execFileAsync2 = promisify6(execFile2);
+function getProjectsRegistryPath() {
+  return path36.join(getAgentvConfigDir(), "config.yaml");
+}
+function fromYaml(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const e = raw;
+  if (typeof e.id !== "string" || typeof e.name !== "string" || typeof e.path !== "string") {
+    return null;
+  }
+  const entry = {
+    id: e.id,
+    name: e.name,
+    path: e.path,
+    addedAt: typeof e.added_at === "string" ? e.added_at : "",
+    lastOpenedAt: typeof e.last_opened_at === "string" ? e.last_opened_at : ""
+  };
+  if (typeof e.repo_url === "string" && e.repo_url.trim().length > 0) {
+    entry.repoUrl = e.repo_url.trim();
+  }
+  if (typeof e.ref === "string" && e.ref.trim().length > 0) {
+    entry.ref = e.ref.trim();
+  }
+  if (e.results && typeof e.results === "object") {
+    const r = e.results;
+    if (typeof r.repo_url === "string" && r.repo_url.trim().length > 0) {
+      const sync = r.sync && typeof r.sync === "object" ? r.sync : void 0;
+      entry.results = {
+        repoUrl: r.repo_url.trim(),
+        ...typeof r.branch === "string" && r.branch.trim().length > 0 ? { branch: r.branch.trim() } : {},
+        ...typeof r.path === "string" && r.path.trim().length > 0 ? { path: r.path.trim() } : {},
+        ...sync && typeof sync.auto_push === "boolean" ? { sync: { autoPush: sync.auto_push } } : {},
+        ...typeof r.branch_prefix === "string" && r.branch_prefix.trim().length > 0 ? { branchPrefix: r.branch_prefix.trim() } : {}
+      };
+    }
+  }
+  return entry;
+}
+function toYaml(entry) {
+  const yaml = {
+    id: entry.id,
+    name: entry.name,
+    ...entry.repoUrl !== void 0 && { repo_url: entry.repoUrl },
+    path: entry.path,
+    ...entry.ref !== void 0 && { ref: entry.ref },
+    added_at: entry.addedAt,
+    last_opened_at: entry.lastOpenedAt
+  };
+  if (entry.results) {
+    yaml.results = {
+      repo_url: entry.results.repoUrl,
+      ...entry.results.branch !== void 0 && { branch: entry.results.branch },
+      ...entry.results.path !== void 0 && { path: entry.results.path },
+      ...entry.results.sync?.autoPush !== void 0 && {
+        sync: { auto_push: entry.results.sync.autoPush }
+      },
+      ...entry.results.branchPrefix !== void 0 && {
+        branch_prefix: entry.results.branchPrefix
+      }
+    };
+  }
+  return yaml;
+}
+function loadProjectRegistry() {
+  const registryPath = getProjectsRegistryPath();
+  if (!existsSync4(registryPath)) {
+    return { projects: [] };
+  }
+  try {
+    const raw = readFileSync22(registryPath, "utf-8");
+    const parsed = parseYamlValue(raw);
+    if (!parsed || typeof parsed !== "object") {
+      return { projects: [] };
+    }
+    const env = process.env;
+    const projects = Array.isArray(parsed.projects) ? parsed.projects.map((e) => fromYaml(interpolateEnv(e, env))).filter((e) => e !== null) : [];
+    return { projects };
+  } catch {
+    return { projects: [] };
+  }
+}
+function saveProjectRegistry(registry2) {
+  const registryPath = getProjectsRegistryPath();
+  const dir = path36.dirname(registryPath);
+  if (!existsSync4(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  const payload = { ...readHomeConfig(registryPath), projects: registry2.projects.map(toYaml) };
+  writeFileSync(registryPath, stringifyYaml(payload), "utf-8");
+}
+function readHomeConfig(configPath2) {
+  if (!existsSync4(configPath2)) return {};
+  try {
+    const parsed = parseYamlValue(readFileSync22(configPath2, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function deriveProjectId(dirPath, existingIds) {
+  const base = path36.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  let candidate = base || "project";
+  let suffix = 2;
+  while (existingIds.includes(candidate)) {
+    candidate = `${base}-${suffix}`;
+    suffix++;
+  }
+  return candidate;
+}
+function addProject(projectPath) {
+  const absPath = path36.resolve(projectPath);
+  if (!existsSync4(absPath)) {
+    throw new Error(`Directory not found: ${absPath}`);
+  }
+  if (!existsSync4(path36.join(absPath, ".agentv"))) {
+    throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
+  }
+  const registry2 = loadProjectRegistry();
+  const existing = registry2.projects.find((p) => p.path === absPath);
+  if (existing) {
+    return existing;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: deriveProjectId(
+      absPath,
+      registry2.projects.map((p) => p.id)
+    ),
+    name: path36.basename(absPath),
+    path: absPath,
+    addedAt: now,
+    lastOpenedAt: now
+  };
+  registry2.projects.push(entry);
+  saveProjectRegistry(registry2);
+  return entry;
+}
+function removeProject(projectId) {
+  const registry2 = loadProjectRegistry();
+  const idx = registry2.projects.findIndex((p) => p.id === projectId);
+  if (idx < 0) return false;
+  registry2.projects.splice(idx, 1);
+  saveProjectRegistry(registry2);
+  return true;
+}
+function getProject(projectId) {
+  return loadProjectRegistry().projects.find((p) => p.id === projectId);
+}
+function getProjectForPath(fsPath) {
+  const absPath = path36.resolve(fsPath);
+  return loadProjectRegistry().projects.filter((p) => {
+    const projectPath = path36.resolve(p.path);
+    const relative = path36.relative(projectPath, absPath);
+    return relative === "" || !relative.startsWith("..") && !path36.isAbsolute(relative);
+  }).sort((a, b) => path36.resolve(b.path).length - path36.resolve(a.path).length)[0];
+}
+function touchProject(projectId) {
+  const registry2 = loadProjectRegistry();
+  const entry = registry2.projects.find((p) => p.id === projectId);
+  if (entry) {
+    entry.lastOpenedAt = (/* @__PURE__ */ new Date()).toISOString();
+    saveProjectRegistry(registry2);
+  }
+}
+function discoverProjects(rootDir, maxDepth = 2) {
+  const absRoot = path36.resolve(rootDir);
+  if (!existsSync4(absRoot) || !statSync2(absRoot).isDirectory()) {
+    return [];
+  }
+  const results = [];
+  function scan(dir, depth) {
+    if (depth > maxDepth) return;
+    if (existsSync4(path36.join(dir, ".agentv"))) {
+      results.push(dir);
+      return;
+    }
+    if (depth === maxDepth) return;
+    try {
+      const entries = readdirSync3(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        scan(path36.join(dir, entry.name), depth + 1);
+      }
+    } catch {
+    }
+  }
+  scan(absRoot, 0);
+  return results.sort();
+}
+var execFileAsync = promisify5(execFile);
 var DEFAULT_TIMEOUT_MS2 = 3e5;
-function gitEnv2() {
+var DEFAULT_HEARTBEAT_MS = 3e4;
+var ERROR_OUTPUT_LIMIT = 1024 * 1024;
+var LOCK_POLL_MS = 100;
+function gitEnv() {
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
     if (key.startsWith("GIT_") && key !== "GIT_SSH_COMMAND") {
@@ -33248,64 +33432,62 @@ function gitEnv2() {
     GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
   };
 }
-function getSourceUrl(source) {
-  return source.type === "git" ? source.url : source.path;
+function appendLimited(current, chunk) {
+  if (current.length >= ERROR_OUTPUT_LIMIT) return current;
+  const next = current + chunk.toString();
+  return next.length > ERROR_OUTPUT_LIMIT ? next.slice(-ERROR_OUTPUT_LIMIT) : next;
+}
+function formatDuration(ms) {
+  const seconds = Math.round(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainder = seconds % 60;
+  return remainder === 0 ? `${minutes}m` : `${minutes}m ${remainder}s`;
 }
 function isFullCommitSha(ref) {
   return typeof ref === "string" && /^[0-9a-f]{40}$/i.test(ref);
 }
-async function git2(args, opts) {
-  const { stdout } = await execFileAsync2("git", args, {
+function assertSafeGitOperand(value, label) {
+  if (value.length === 0) {
+    throw new Error(`${label} must not be empty.`);
+  }
+  if (value.includes("\0")) {
+    throw new Error(`${label} must not contain NUL bytes.`);
+  }
+  if (value.startsWith("-")) {
+    throw new Error(`${label} must not start with '-'.`);
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function configPath() {
+  return path37.join(getAgentvConfigDir(), "config.yaml");
+}
+function expandHome(value) {
+  if (value === "~") return process.env.HOME ?? value;
+  if (value.startsWith("~/")) return path37.join(process.env.HOME ?? "~", value.slice(2));
+  return value;
+}
+async function git(args, opts) {
+  const { stdout } = await execFileAsync("git", args, {
     cwd: opts?.cwd,
     timeout: opts?.timeout ?? DEFAULT_TIMEOUT_MS2,
-    env: gitEnv2(),
+    env: gitEnv(),
     maxBuffer: 50 * 1024 * 1024
-    // 50MB
   });
   return stdout.trim();
 }
 var RepoManager = class {
   verbose;
-  constructor(verbose = false) {
+  progress;
+  heartbeatMs;
+  timeoutMs;
+  constructor(verbose = false, options = {}) {
     this.verbose = verbose;
-  }
-  /**
-   * Validate that all local repo source paths exist before attempting materialization.
-   * Returns an array of validation errors (empty if all paths are valid).
-   */
-  static validateLocalPaths(repos) {
-    const errors = [];
-    for (const repo of repos) {
-      if (!repo.source || repo.source.type !== "local") continue;
-      const sourcePath = repo.source.path;
-      if (!sourcePath || sourcePath.trim() === "") {
-        errors.push({
-          repoPath: repo.path ?? "(none)",
-          resolvedSourcePath: sourcePath ?? "",
-          reason: "empty_path"
-        });
-      } else if (!existsSync4(sourcePath)) {
-        errors.push({
-          repoPath: repo.path ?? "(none)",
-          resolvedSourcePath: sourcePath,
-          reason: "not_found"
-        });
-      }
-    }
-    return errors;
-  }
-  /**
-   * Format validation errors into a human-readable warning message.
-   */
-  static formatValidationErrors(errors) {
-    const lines = errors.map((e) => {
-      if (e.reason === "empty_path") {
-        return `  - repo "${e.repoPath}": local source path is empty (check that the env var is set)`;
-      }
-      return `  - repo "${e.repoPath}": local source path not found: ${e.resolvedSourcePath}`;
-    });
-    return `Local repo path validation failed:
-${lines.join("\n")}`;
+    this.progress = options.progress ?? true;
+    this.heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   }
   async runGit(args, opts) {
     const startedAt = Date.now();
@@ -33313,7 +33495,7 @@ ${lines.join("\n")}`;
       console.log(`[repo] git start cwd=${opts?.cwd ?? process.cwd()} args=${args.join(" ")}`);
     }
     try {
-      const output = await git2(args, opts);
+      const output = await git(args, { ...opts, timeout: opts?.timeout ?? this.timeoutMs });
       if (this.verbose) {
         console.log(`[repo] git ok durationMs=${Date.now() - startedAt} args=${args.join(" ")}`);
       }
@@ -33328,100 +33510,370 @@ ${lines.join("\n")}`;
       throw error40;
     }
   }
+  runGitStreaming(args, opts) {
+    const startedAt = Date.now();
+    const timeout = opts.timeout ?? this.timeoutMs;
+    if (this.verbose) {
+      console.log(`[repo] git start cwd=${opts.cwd ?? process.cwd()} args=${args.join(" ")}`);
+    }
+    return new Promise((resolve, reject) => {
+      let stdout = "";
+      let stderr = "";
+      let settled = false;
+      let timedOut = false;
+      const child = spawn5("git", args, {
+        cwd: opts.cwd,
+        env: gitEnv(),
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let timeoutHandle;
+      const resetIdleTimeout = () => {
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+        timeoutHandle = setTimeout(() => {
+          timedOut = true;
+          child.kill("SIGTERM");
+        }, timeout);
+      };
+      resetIdleTimeout();
+      const heartbeatHandle = this.progress && this.heartbeatMs > 0 ? setInterval(() => {
+        const elapsed = formatDuration(Date.now() - startedAt);
+        console.error(`[repo] ${opts.description} still running after ${elapsed}`);
+      }, this.heartbeatMs) : void 0;
+      const finish = (error40) => {
+        if (settled) return;
+        settled = true;
+        if (timeoutHandle) clearTimeout(timeoutHandle);
+        if (heartbeatHandle) clearInterval(heartbeatHandle);
+        if (error40) {
+          reject(error40);
+        } else {
+          resolve();
+        }
+      };
+      child.stdout.on("data", (chunk) => {
+        stdout = appendLimited(stdout, chunk);
+        if (!timedOut) resetIdleTimeout();
+        if (this.progress) process.stdout.write(chunk);
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr = appendLimited(stderr, chunk);
+        if (!timedOut) resetIdleTimeout();
+        if (this.progress) process.stderr.write(chunk);
+      });
+      child.on("error", (error40) => finish(error40));
+      child.on("close", (code, signal) => {
+        const durationMs = Date.now() - startedAt;
+        if (this.verbose) {
+          console.log(
+            `[repo] git ${code === 0 ? "ok" : "fail"} durationMs=${durationMs} args=${args.join(" ")}`
+          );
+        }
+        if (timedOut) {
+          finish(
+            new Error(
+              `${opts.description} made no progress for ${formatDuration(timeout)}. Register a matching local checkout, configure git_cache.mirrors in ${configPath()}, or check network connectivity.`
+            )
+          );
+          return;
+        }
+        if (code !== 0) {
+          const output = [stderr.trim(), stdout.trim()].filter(Boolean).join("\n");
+          finish(
+            new Error(
+              `git ${args.join(" ")} failed with code ${code ?? "unknown"}${signal ? ` (signal ${signal})` : ""}${output ? `:
+${output}` : ""}`
+            )
+          );
+          return;
+        }
+        finish();
+      });
+    });
+  }
+  loadConfiguredMirrors() {
+    const filePath = configPath();
+    if (!existsSync5(filePath)) return {};
+    try {
+      const parsed = parseYamlValue(readFileSync3(filePath, "utf-8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+      const config2 = parsed;
+      const gitCache = config2.git_cache;
+      if (!gitCache || typeof gitCache !== "object" || Array.isArray(gitCache)) return {};
+      const mirrors = gitCache.mirrors;
+      if (!mirrors || typeof mirrors !== "object" || Array.isArray(mirrors)) return {};
+      const result = {};
+      for (const [repo, localPath] of Object.entries(mirrors)) {
+        if (typeof localPath === "string" && localPath.trim().length > 0) {
+          result[repo] = expandHome(localPath.trim());
+        }
+      }
+      return result;
+    } catch {
+      return {};
+    }
+  }
+  findConfiguredMirror(repoIdentity) {
+    const mirrors = this.loadConfiguredMirrors();
+    for (const [repo, localPath] of Object.entries(mirrors)) {
+      if (normalizeRepoIdentity(repo) !== repoIdentity) continue;
+      if (!existsSync5(localPath)) {
+        console.warn(`[repo] configured mirror not found, falling back: ${localPath}`);
+        continue;
+      }
+      return localPath;
+    }
+    return void 0;
+  }
+  async findRegisteredProject(repoIdentity) {
+    for (const project of loadProjectRegistry().projects) {
+      if (!existsSync5(project.path)) continue;
+      try {
+        const origin = await this.runGit(["remote", "get-url", "origin"], {
+          cwd: project.path,
+          timeout: 1e4
+        });
+        if (normalizeRepoIdentity(origin) === repoIdentity) {
+          return project.path;
+        }
+      } catch {
+        if (project.repoUrl && normalizeRepoIdentity(project.repoUrl) === repoIdentity) {
+          return project.path;
+        }
+      }
+    }
+    return void 0;
+  }
+  gitCachePath(repoIdentity) {
+    const hash = createHash4("sha256").update(repoIdentity).digest("hex");
+    return path37.join(getAgentvDataDir(), "git-cache", hash);
+  }
+  async withMirrorCacheLock(mirrorPath, action) {
+    const lockPath = `${mirrorPath}.lock`;
+    const startedAt = Date.now();
+    while (true) {
+      try {
+        await mkdir16(lockPath);
+        break;
+      } catch (error40) {
+        const code = error40.code;
+        if (code !== "EEXIST") throw error40;
+        if (Date.now() - startedAt > this.timeoutMs) {
+          throw new Error(`Timed out waiting for git cache lock: ${lockPath}`);
+        }
+        await sleep2(LOCK_POLL_MS);
+      }
+    }
+    try {
+      return await action();
+    } finally {
+      await rm6(lockPath, { recursive: true, force: true });
+    }
+  }
+  async isValidBareRepo(repoPath) {
+    if (!existsSync5(path37.join(repoPath, "HEAD"))) return false;
+    try {
+      return await this.runGit(["rev-parse", "--is-bare-repository"], {
+        cwd: repoPath,
+        timeout: 1e4
+      }) === "true";
+    } catch {
+      return false;
+    }
+  }
+  async removeInvalidMirrorCache(mirrorPath) {
+    if (!existsSync5(mirrorPath)) return;
+    const quarantinePath = `${mirrorPath}.invalid-${process.pid}-${Date.now()}-${randomUUID9()}`;
+    try {
+      await rename(mirrorPath, quarantinePath);
+      await rm6(quarantinePath, { recursive: true, force: true });
+    } catch {
+      await rm6(mirrorPath, { recursive: true, force: true });
+    }
+  }
+  async prepareMirrorCache(seedSource, repoIdentity) {
+    assertSafeGitOperand(seedSource, "repo clone source");
+    const mirrorPath = this.gitCachePath(repoIdentity);
+    try {
+      await mkdir16(path37.dirname(mirrorPath), { recursive: true });
+      return await this.withMirrorCacheLock(mirrorPath, async () => {
+        if (await this.isValidBareRepo(mirrorPath)) {
+          try {
+            await this.runGit(["remote", "set-url", "origin", seedSource], {
+              cwd: mirrorPath,
+              timeout: 1e4
+            });
+            await this.runGitStreaming(["fetch", "--prune", "--progress", "origin"], {
+              cwd: mirrorPath,
+              description: `git fetch cache for ${seedSource}`
+            });
+          } catch (error40) {
+            const message = error40 instanceof Error ? error40.message : String(error40);
+            console.warn(`[repo] mirror cache fetch failed; using existing cache: ${message}`);
+          }
+          return mirrorPath;
+        }
+        await this.removeInvalidMirrorCache(mirrorPath);
+        const tempPath = path37.join(
+          path37.dirname(mirrorPath),
+          `${path37.basename(mirrorPath)}.tmp-${process.pid}-${Date.now()}-${randomUUID9()}`
+        );
+        try {
+          await this.runGitStreaming(
+            ["clone", "--mirror", "--progress", "--", seedSource, tempPath],
+            {
+              description: `git mirror clone ${seedSource}`
+            }
+          );
+          if (!await this.isValidBareRepo(tempPath)) {
+            throw new Error(`git mirror clone did not create a valid bare repo at ${tempPath}`);
+          }
+          await rename(tempPath, mirrorPath);
+          return mirrorPath;
+        } finally {
+          await rm6(tempPath, { recursive: true, force: true });
+        }
+      });
+    } catch (error40) {
+      const message = error40 instanceof Error ? error40.message : String(error40);
+      console.warn(`[repo] mirror cache unavailable; trying next acquisition source: ${message}`);
+      return void 0;
+    }
+  }
+  async resolveCommit(ref, cwd) {
+    assertSafeGitOperand(ref, "repo checkout ref");
+    const candidates = [ref];
+    if (!ref.startsWith("refs/") && !ref.startsWith("origin/") && !isFullCommitSha(ref)) {
+      candidates.push(`refs/remotes/origin/${ref}`);
+    }
+    for (const candidate of candidates) {
+      try {
+        return await this.runGit(
+          ["rev-parse", "--verify", "--end-of-options", `${candidate}^{commit}`],
+          { cwd }
+        );
+      } catch {
+      }
+    }
+    throw new Error(`Cannot resolve ref '${ref}' to a commit.`);
+  }
+  async resolveCheckoutCommit(repo, targetDir) {
+    const ref = getRepoCheckoutRef(repo);
+    const checkoutSha = await this.resolveCommit(ref, targetDir);
+    const ancestor = repo.ancestor ?? 0;
+    if (ancestor === 0) {
+      return checkoutSha;
+    }
+    try {
+      return await this.resolveCommit(`${checkoutSha}~${ancestor}`, targetDir);
+    } catch {
+      const shallowHint = isFullCommitSha(ref) ? "" : " Ensure the declared commit has enough reachable history in the selected repo.";
+      throw new Error(`Cannot resolve ancestor ${ancestor} of ref '${ref}'.${shallowHint}`);
+    }
+  }
+  assertNoUserOwnedAlternates(targetDir, acquisition) {
+    const alternatesPath = path37.join(targetDir, ".git", "objects", "info", "alternates");
+    if (!existsSync5(alternatesPath)) return;
+    const alternates = readFileSync3(alternatesPath, "utf-8").trim();
+    if (alternates.length > 0) {
+      throw new Error(
+        `git clone for ${acquisition.kind} left an alternates dependency at ${alternatesPath}`
+      );
+    }
+  }
+  async resolveAcquisition(repo) {
+    const declaredRepo = repo.repo;
+    if (!declaredRepo) {
+      throw new Error(`repo is required for workspace repo at path ${repo.path ?? "(none)"}`);
+    }
+    const originUrl = resolveRepoCloneUrl(declaredRepo);
+    const repoIdentity = normalizeRepoIdentity(declaredRepo);
+    const registeredProject = await this.findRegisteredProject(repoIdentity);
+    if (registeredProject) {
+      const mirrorCache2 = await this.prepareMirrorCache(registeredProject, repoIdentity);
+      if (mirrorCache2) {
+        return {
+          kind: "registered-project",
+          sourceUrl: mirrorCache2,
+          originUrl
+        };
+      }
+    }
+    const configuredMirror = this.findConfiguredMirror(repoIdentity);
+    if (configuredMirror) {
+      const mirrorCache2 = await this.prepareMirrorCache(configuredMirror, repoIdentity);
+      if (mirrorCache2) {
+        return {
+          kind: "configured-mirror",
+          sourceUrl: mirrorCache2,
+          originUrl
+        };
+      }
+    }
+    const mirrorCache = await this.prepareMirrorCache(originUrl, repoIdentity);
+    if (mirrorCache) {
+      return {
+        kind: "mirror-cache",
+        sourceUrl: mirrorCache,
+        originUrl
+      };
+    }
+    return { kind: "remote", sourceUrl: originUrl, originUrl };
+  }
   /**
-   * Clone a repo directly from source into the workspace at the configured path.
-   * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
+   * Clone a repo into the workspace at the configured path.
+   * Handles acquisition resolution, sparse checkout, commit checkout, and ancestor walking.
    */
   async materialize(repo, workspacePath) {
-    if (!repo.source || !repo.path) {
+    if (!repo.repo || !repo.path) {
       if (this.verbose) {
-        console.log(`[repo] materialize skip path=${repo.path ?? "(none)"} (no source or path)`);
+        console.log(`[repo] materialize skip path=${repo.path ?? "(none)"} (no repo or path)`);
       }
       return;
     }
-    const targetDir = path36.join(workspacePath, repo.path);
-    const sourceUrl = getSourceUrl(repo.source);
+    const targetDir = path37.join(workspacePath, repo.path);
+    const acquisition = await this.resolveAcquisition(repo);
     const startedAt = Date.now();
     if (this.verbose) {
       console.log(
-        `[repo] materialize start path=${repo.path} source=${sourceUrl} workspace=${workspacePath}`
+        `[repo] materialize start path=${repo.path} repo=${repo.repo} acquisition=${acquisition.kind} workspace=${workspacePath}`
       );
     }
-    const cloneArgs = ["clone"];
-    if (repo.clone?.depth) {
-      cloneArgs.push("--depth", String(repo.clone.depth));
-    }
-    if (repo.clone?.filter) {
-      cloneArgs.push("--filter", repo.clone.filter);
+    const cloneArgs = ["clone", "--progress", "--no-checkout"];
+    assertSafeGitOperand(acquisition.sourceUrl, "repo clone source");
+    cloneArgs.push("--", acquisition.sourceUrl, targetDir);
+    await this.runGitStreaming(cloneArgs, {
+      description: `git clone ${repo.repo}`
+    });
+    this.assertNoUserOwnedAlternates(targetDir, acquisition);
+    if (acquisition.sourceUrl !== acquisition.originUrl) {
+      assertSafeGitOperand(acquisition.originUrl, "repo origin URL");
+      await this.runGit(["remote", "set-url", "origin", acquisition.originUrl], { cwd: targetDir });
     }
-    cloneArgs.push("--no-checkout");
-    const cloneUrl = (repo.clone?.depth || repo.clone?.filter) && repo.source.type === "local" ? `file://${sourceUrl}` : sourceUrl;
-    cloneArgs.push(cloneUrl, targetDir);
-    await this.runGit(cloneArgs);
-    if (repo.clone?.sparse?.length) {
-      await this.runGit(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
-      await this.runGit(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
-    }
-    const ref = getRepoCheckoutRef(repo.checkout);
-    const resolve = repo.checkout?.resolve ?? "remote";
-    const baseCommit = repo.checkout?.base_commit;
-    const shouldResolveLocally = resolve === "local" || repo.source.type === "git" && isFullCommitSha(baseCommit);
-    let resolvedSha;
-    if (!shouldResolveLocally && repo.source.type === "git") {
-      const url2 = getSourceUrl(repo.source);
-      try {
-        const lsOutput = await this.runGit(["ls-remote", url2, ref]);
-        const match = lsOutput.split("	")[0];
-        if (!match) {
-          throw new Error(`Ref '${ref}' not found on remote ${url2}`);
-        }
-        resolvedSha = match;
-      } catch (err) {
-        if (err instanceof Error && err.message.includes("not found")) throw err;
-        resolvedSha = ref;
+    if (repo.sparse?.length) {
+      for (const sparsePath of repo.sparse) {
+        assertSafeGitOperand(sparsePath, "repo sparse path");
       }
-    } else {
-      resolvedSha = ref;
+      await this.runGit(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
+      await this.runGit(["sparse-checkout", "set", "--", ...repo.sparse], { cwd: targetDir });
     }
+    const ref = getRepoCheckoutRef(repo);
     if (this.verbose) {
-      console.log(
-        `[repo] checkout path=${repo.path} ref=${ref} resolved=${resolvedSha} resolve=${resolve}`
-      );
-    }
-    await this.runGit(["checkout", resolvedSha], { cwd: targetDir });
-    const ancestor = repo.checkout?.ancestor ?? 0;
-    if (ancestor > 0) {
-      try {
-        const ancestorSha = await this.runGit(["rev-parse", `HEAD~${ancestor}`], {
-          cwd: targetDir
-        });
-        await this.runGit(["checkout", ancestorSha], { cwd: targetDir });
-      } catch {
-        if (repo.clone?.depth) {
-          await this.runGit(["fetch", "--deepen", String(ancestor)], { cwd: targetDir });
-          const ancestorSha = await this.runGit(["rev-parse", `HEAD~${ancestor}`], {
-            cwd: targetDir
-          });
-          await this.runGit(["checkout", ancestorSha], { cwd: targetDir });
-        } else {
-          throw new Error(
-            `Cannot resolve ancestor ${ancestor} of ref '${ref}'. If using shallow clone, increase clone.depth to at least ${ancestor + 1}.`
-          );
-        }
-      }
+      console.log(`[repo] checkout path=${repo.path} ref=${ref}`);
     }
+    const checkoutSha = await this.resolveCheckoutCommit(repo, targetDir);
+    await this.runGit(["checkout", "--detach", checkoutSha], { cwd: targetDir });
     if (this.verbose) {
       console.log(
         `[repo] materialize done path=${repo.path} target=${targetDir} durationMs=${Date.now() - startedAt}`
       );
     }
   }
-  /** Materialize all repos into the workspace. Skips repos without source (Docker-only repos). */
+  /** Materialize all repos into the workspace. Skips repos without repo (Docker-only repos). */
   async materializeAll(repos, workspacePath) {
-    const materializableRepos = repos.filter((r) => r.source);
+    const materializableRepos = repos.filter((r) => r.repo);
     if (this.verbose) {
       console.log(
-        `[repo] materializeAll count=${materializableRepos.length} (${repos.length - materializableRepos.length} skipped, no source) workspace=${workspacePath}`
+        `[repo] materializeAll count=${materializableRepos.length} (${repos.length - materializableRepos.length} skipped, no repo) workspace=${workspacePath}`
       );
     }
     for (const repo of materializableRepos) {
@@ -33431,13 +33883,14 @@ ${lines.join("\n")}`;
       console.log("[repo] materializeAll complete");
     }
   }
-  /** Reset repos in workspace to their checkout state. Skips repos without path or source. */
+  /** Reset repos in workspace to their checkout state. Skips repos without path or repo. */
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
-      if (!repo.path || !repo.source) continue;
-      const targetDir = path36.join(workspacePath, repo.path);
-      await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
+      if (!repo.path || !repo.repo) continue;
+      const targetDir = path37.join(workspacePath, repo.path);
+      const resetSha = await this.resolveCheckoutCommit(repo, targetDir);
+      await this.runGit(["reset", "--hard", resetSha], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
   }
@@ -33446,11 +33899,11 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = path37.resolve(templatePath);
+  const resolved = path38.resolve(templatePath);
   const stats = await stat7(resolved);
   if (stats.isFile()) {
     return {
-      dir: path37.dirname(resolved),
+      dir: path38.dirname(resolved),
       workspaceFile: resolved
     };
   }
@@ -33462,14 +33915,14 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: path37.join(resolved, workspaceFiles[0])
+      workspaceFile: path38.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? path37.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? path38.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -33595,7 +34048,7 @@ async function loadTestsFromAgentSkills(filePath) {
   } catch {
     throw new Error(`Invalid Agent Skills evals.json: failed to parse JSON in '${filePath}'`);
   }
-  return parseAgentSkillsEvals(parsed, filePath, path38.dirname(path38.resolve(filePath)));
+  return parseAgentSkillsEvals(parsed, filePath, path39.dirname(path39.resolve(filePath)));
 }
 function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
   if (!isAgentSkillsFormat(parsed)) {
@@ -33633,7 +34086,7 @@ function parseAgentSkillsEvals(parsed, source = "evals.json", baseDir) {
       if (baseDir) {
         metadata.agent_skills_base_dir = baseDir;
         for (const file2 of evalCase.files) {
-          filePaths.push(path38.resolve(baseDir, file2));
+          filePaths.push(path39.resolve(baseDir, file2));
         }
       }
     }
@@ -33669,15 +34122,15 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file:")) {
       return fileURLToPath4(candidate);
     }
-    return path39.resolve(candidate);
+    return path40.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = path39.resolve(repoRoot);
-  let current = path39.resolve(path39.dirname(filePath));
+  const boundary = path40.resolve(repoRoot);
+  let current = path40.resolve(path40.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -33686,7 +34139,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = path39.dirname(current);
+    const parent = path40.dirname(current);
     if (parent === current) {
       break;
     }
@@ -33700,16 +34153,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root) => {
-    const normalized = path39.resolve(root);
+    const normalized = path40.resolve(root);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = path39.dirname(evalPath);
+  let currentDir = path40.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = path39.dirname(currentDir);
+    const parentDir = path40.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -33727,16 +34180,16 @@ function trimLeadingSeparators2(value) {
 async function resolveFileReference3(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (path39.isAbsolute(rawValue)) {
-    potentialPaths.push(path39.normalize(rawValue));
+  if (path40.isAbsolute(rawValue)) {
+    potentialPaths.push(path40.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(path39.resolve(base, displayPath));
+    potentialPaths.push(path40.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = path39.resolve(candidate);
+    const absoluteCandidate = path40.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -33757,48 +34210,48 @@ var DEFAULT_EVAL_PATTERNS = [
 ];
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain2(evalFilePath, repoRoot);
-  const globalConfigPath = path40.join(getAgentvConfigDir(), "config.yaml");
+  const globalConfigPath = path41.join(getAgentvConfigDir(), "config.yaml");
   for (const directory of directories) {
-    const configPath = path40.join(directory, ".agentv", "config.yaml");
-    if (!await fileExists3(configPath)) {
+    const configPath2 = path41.join(directory, ".agentv", "config.yaml");
+    if (!await fileExists3(configPath2)) {
       continue;
     }
-    const config2 = await readConfigFile(configPath);
+    const config2 = await readConfigFile(configPath2);
     if (config2) {
       return config2;
     }
   }
   return await fileExists3(globalConfigPath) ? readConfigFile(globalConfigPath) : null;
 }
-async function readConfigFile(configPath) {
+async function readConfigFile(configPath2) {
   try {
-    const rawConfig = await readFile13(configPath, "utf8");
+    const rawConfig = await readFile13(configPath2, "utf8");
     const parsed = interpolateEnv(parseYamlValue(rawConfig), process.env);
     if (!isJsonObject(parsed)) {
-      logWarning(`Invalid config.yaml format at ${configPath}`);
+      logWarning(`Invalid config.yaml format at ${configPath2}`);
       return null;
     }
     const config2 = parsed;
     const requiredVersion = parsed.required_version;
     if (requiredVersion !== void 0 && typeof requiredVersion !== "string") {
-      logWarning(`Invalid required_version in ${configPath}, expected string`);
+      logWarning(`Invalid required_version in ${configPath2}, expected string`);
       return null;
     }
     const evalPatterns = config2.eval_patterns;
     if (evalPatterns !== void 0 && !Array.isArray(evalPatterns)) {
-      logWarning(`Invalid eval_patterns in ${configPath}, expected array`);
+      logWarning(`Invalid eval_patterns in ${configPath2}, expected array`);
       return null;
     }
     if (Array.isArray(evalPatterns) && !evalPatterns.every((p) => typeof p === "string")) {
-      logWarning(`Invalid eval_patterns in ${configPath}, all entries must be strings`);
+      logWarning(`Invalid eval_patterns in ${configPath2}, all entries must be strings`);
       return null;
     }
     const executionDefaults = parseExecutionDefaults(
       parsed.execution,
-      configPath
+      configPath2
     );
-    const results = parseResultsConfig(parsed.results, configPath);
-    const hooks = parseHooksConfig(parsed.hooks, configPath);
+    const results = parseResultsConfig(parsed.results, configPath2);
+    const hooks = parseHooksConfig(parsed.hooks, configPath2);
     return {
       required_version: requiredVersion,
       eval_patterns: evalPatterns,
@@ -33807,7 +34260,7 @@ async function readConfigFile(configPath) {
       ...hooks && { hooks }
     };
   } catch (error40) {
-    logWarning(`Could not read config.yaml at ${configPath}: ${error40.message}`);
+    logWarning(`Could not read config.yaml at ${configPath2}: ${error40.message}`);
     return null;
   }
 }
@@ -34045,7 +34498,7 @@ function extractThreshold(suite) {
   logWarning(`Invalid execution.threshold: ${raw}. Must be a number between 0 and 1. Ignoring.`);
   return void 0;
 }
-function parseExecutionDefaults(raw, configPath) {
+function parseExecutionDefaults(raw, configPath2) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     return void 0;
   }
@@ -34054,78 +34507,78 @@ function parseExecutionDefaults(raw, configPath) {
   if (typeof obj.verbose === "boolean") {
     result.verbose = obj.verbose;
   } else if (obj.verbose !== void 0) {
-    logWarning(`Invalid execution.verbose in ${configPath}, expected boolean`);
+    logWarning(`Invalid execution.verbose in ${configPath2}, expected boolean`);
   }
   if (typeof obj.keep_workspaces === "boolean") {
     result.keep_workspaces = obj.keep_workspaces;
   } else if (obj.keep_workspaces !== void 0) {
-    logWarning(`Invalid execution.keep_workspaces in ${configPath}, expected boolean`);
+    logWarning(`Invalid execution.keep_workspaces in ${configPath2}, expected boolean`);
   }
   const otelFile = obj.otel_file;
   if (typeof otelFile === "string" && otelFile.trim().length > 0) {
     result.otel_file = otelFile.trim();
   } else if (otelFile !== void 0) {
-    logWarning(`Invalid execution.otel_file in ${configPath}, expected non-empty string`);
+    logWarning(`Invalid execution.otel_file in ${configPath2}, expected non-empty string`);
   }
   if (typeof obj.export_otel === "boolean") {
     result.export_otel = obj.export_otel;
   } else if (obj.export_otel !== void 0) {
-    logWarning(`Invalid execution.export_otel in ${configPath}, expected boolean`);
+    logWarning(`Invalid execution.export_otel in ${configPath2}, expected boolean`);
   }
   const otelBackend = obj.otel_backend;
   if (typeof otelBackend === "string" && otelBackend.trim().length > 0) {
     result.otel_backend = otelBackend.trim();
   } else if (otelBackend !== void 0) {
-    logWarning(`Invalid execution.otel_backend in ${configPath}, expected non-empty string`);
+    logWarning(`Invalid execution.otel_backend in ${configPath2}, expected non-empty string`);
   }
   if (typeof obj.otel_capture_content === "boolean") {
     result.otel_capture_content = obj.otel_capture_content;
   } else if (obj.otel_capture_content !== void 0) {
-    logWarning(`Invalid execution.otel_capture_content in ${configPath}, expected boolean`);
+    logWarning(`Invalid execution.otel_capture_content in ${configPath2}, expected boolean`);
   }
   if (typeof obj.otel_group_turns === "boolean") {
     result.otel_group_turns = obj.otel_group_turns;
   } else if (obj.otel_group_turns !== void 0) {
-    logWarning(`Invalid execution.otel_group_turns in ${configPath}, expected boolean`);
+    logWarning(`Invalid execution.otel_group_turns in ${configPath2}, expected boolean`);
   }
   if (typeof obj.pool_workspaces === "boolean") {
     result.pool_workspaces = obj.pool_workspaces;
   } else if (obj.pool_workspaces !== void 0) {
-    logWarning(`Invalid execution.pool_workspaces in ${configPath}, expected boolean`);
+    logWarning(`Invalid execution.pool_workspaces in ${configPath2}, expected boolean`);
   }
   const poolSlots = obj.pool_slots;
   if (typeof poolSlots === "number" && Number.isInteger(poolSlots) && poolSlots >= 1 && poolSlots <= 50) {
     result.pool_slots = poolSlots;
   } else if (poolSlots !== void 0) {
-    logWarning(`Invalid execution.pool_slots in ${configPath}, expected integer 1-50`);
+    logWarning(`Invalid execution.pool_slots in ${configPath2}, expected integer 1-50`);
   }
   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) {
+function parseResultsConfig(raw, configPath2) {
   if (raw === void 0 || raw === null) {
     return void 0;
   }
   if (typeof raw !== "object" || Array.isArray(raw)) {
-    logWarning(`Invalid results in ${configPath}, expected object`);
+    logWarning(`Invalid results in ${configPath2}, expected object`);
     return void 0;
   }
   const obj = raw;
   if (obj.mode !== "github") {
-    logWarning(`Invalid results.mode in ${configPath}, expected 'github'`);
+    logWarning(`Invalid results.mode in ${configPath2}, expected 'github'`);
     return void 0;
   }
   const repo = typeof obj.repo === "string" ? obj.repo.trim() : "";
   if (!repo) {
-    logWarning(`Invalid results.repo in ${configPath}, expected non-empty string`);
+    logWarning(`Invalid results.repo in ${configPath2}, expected non-empty string`);
     return void 0;
   }
   let branch;
   if (obj.branch !== void 0) {
     if (typeof obj.branch !== "string" || obj.branch.trim().length === 0) {
-      logWarning(`Invalid results.branch in ${configPath}, expected non-empty string`);
+      logWarning(`Invalid results.branch in ${configPath2}, expected non-empty string`);
       return void 0;
     }
     branch = obj.branch.trim();
@@ -34133,26 +34586,26 @@ function parseResultsConfig(raw, configPath) {
   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`);
+      logWarning(`Invalid results.path in ${configPath2}, 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.`
+        `Invalid results.path in ${configPath2}: '${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`);
+    logWarning(`Invalid results.auto_push in ${configPath2}, expected boolean`);
     return void 0;
   }
   let branchPrefix;
   if (obj.branch_prefix !== void 0) {
     if (typeof obj.branch_prefix !== "string" || obj.branch_prefix.trim().length === 0) {
-      logWarning(`Invalid results.branch_prefix in ${configPath}, expected non-empty string`);
+      logWarning(`Invalid results.branch_prefix in ${configPath2}, expected non-empty string`);
       return void 0;
     }
     branchPrefix = obj.branch_prefix.trim();
@@ -34172,19 +34625,19 @@ function resolveResultsConfigForProject(config2, _projectId) {
   }
   return config2.results;
 }
-function parseHooksConfig(raw, configPath) {
+function parseHooksConfig(raw, configPath2) {
   if (raw === void 0 || raw === null) {
     return void 0;
   }
   if (typeof raw !== "object" || Array.isArray(raw)) {
-    logWarning(`Invalid hooks in ${configPath}, expected object`);
+    logWarning(`Invalid hooks in ${configPath2}, expected object`);
     return void 0;
   }
   const obj = raw;
   const beforeSession = obj.before_session;
   if (beforeSession !== void 0) {
     if (typeof beforeSession !== "string" || beforeSession.trim().length === 0) {
-      logWarning(`Invalid hooks.before_session in ${configPath}, expected non-empty string`);
+      logWarning(`Invalid hooks.before_session in ${configPath2}, expected non-empty string`);
       return void 0;
     }
     return { before_session: beforeSession.trim() };
@@ -34286,8 +34739,8 @@ function isTemplateReference(value) {
 }
 async function resolveAssertionTemplateReference(include, searchRoots) {
   const templateCandidates = isTemplateReference(include) ? [
-    path41.join(".agentv", "templates", `${include}.yaml`),
-    path41.join(".agentv", "templates", `${include}.yml`)
+    path422.join(".agentv", "templates", `${include}.yaml`),
+    path422.join(".agentv", "templates", `${include}.yml`)
   ] : [include];
   const attempted = [];
   for (const candidate of templateCandidates) {
@@ -34340,10 +34793,10 @@ ${resolved.attempted.map((attempt) => `  Tried: ${attempt}`).join("\n")}` : "";
       `Invalid assertion template file in '${evalId}': ${resolved.resolvedPath} is missing a top-level assertions array`
     );
   }
-  const templateDir = path41.dirname(resolved.resolvedPath);
+  const templateDir = path422.dirname(resolved.resolvedPath);
   const nestedSearchRoots = [
     templateDir,
-    ...searchRoots.filter((root) => path41.resolve(root) !== templateDir)
+    ...searchRoots.filter((root) => path422.resolve(root) !== templateDir)
   ];
   return await expandGraderEntries(assertions, nestedSearchRoots, evalId, {
     depth: nextDepth,
@@ -34404,7 +34857,7 @@ async function collectAssertionTemplateReferencesFromValue(value, searchRoots, e
         references.push({
           kind: "assertion_template",
           displayPath: resolved.displayPath,
-          ...resolved.resolvedPath ? { resolvedPath: path41.resolve(resolved.resolvedPath) } : {}
+          ...resolved.resolvedPath ? { resolvedPath: path422.resolve(resolved.resolvedPath) } : {}
         });
         if (resolved.resolvedPath) {
           if (includeContext.chain.includes(resolved.resolvedPath)) {
@@ -34414,10 +34867,10 @@ async function collectAssertionTemplateReferencesFromValue(value, searchRoots, e
           const content = await readFile15(resolved.resolvedPath, "utf8");
           const parsed = interpolateEnv(parseYamlValue(content), process.env);
           if (isJsonObject2(parsed) && Array.isArray(parsed.assertions)) {
-            const templateDir = path41.dirname(resolved.resolvedPath);
+            const templateDir = path422.dirname(resolved.resolvedPath);
             const nestedSearchRoots = [
               templateDir,
-              ...searchRoots.filter((root) => path41.resolve(root) !== templateDir)
+              ...searchRoots.filter((root) => path422.resolve(root) !== templateDir)
             ];
             references.push(
               ...await collectAssertionTemplateReferencesFromValue(
@@ -34603,7 +35056,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       if (cwd) {
         const resolved = await resolveFileReference3(cwd, searchRoots);
         if (resolved.resolvedPath) {
-          resolvedCwd = path41.resolve(resolved.resolvedPath);
+          resolvedCwd = path422.resolve(resolved.resolvedPath);
         } else {
           logWarning2(
             `Code-grader evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
@@ -34789,7 +35242,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
             aggregatorPrompt = fileRef;
             const resolved = await resolveFileReference3(fileRef, searchRoots);
             if (resolved.resolvedPath) {
-              promptPath2 = path41.resolve(resolved.resolvedPath);
+              promptPath2 = path422.resolve(resolved.resolvedPath);
             } else {
               throw new Error(
                 `Composite aggregator in '${evalId}': prompt file not found: ${resolved.displayPath}`
@@ -35469,7 +35922,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
       const commandPath = commandArray[commandArray.length - 1];
       const resolved = await resolveFileReference3(commandPath, searchRoots);
       if (resolved.resolvedPath) {
-        resolvedPromptScript = [...commandArray.slice(0, -1), path41.resolve(resolved.resolvedPath)];
+        resolvedPromptScript = [...commandArray.slice(0, -1), path422.resolve(resolved.resolvedPath)];
       } else {
         throw new Error(
           `Grader '${name}' in '${evalId}': prompt command file not found: ${resolved.displayPath}`
@@ -35484,7 +35937,7 @@ async function parseGraderList(candidateEvaluators, searchRoots, evalId, default
         prompt = fileRef;
         const resolved = await resolveFileReference3(fileRef, searchRoots);
         if (resolved.resolvedPath) {
-          promptPath = path41.resolve(resolved.resolvedPath);
+          promptPath = path422.resolve(resolved.resolvedPath);
           try {
             await validateCustomPromptContent(promptPath);
           } catch (error40) {
@@ -35642,7 +36095,7 @@ async function parsePreprocessors(rawValue, searchRoots, evaluatorName, evalId)
     preprocessors.push({
       type,
       command,
-      resolvedCommand: [...command.slice(0, -1), path41.resolve(resolved.resolvedPath)]
+      resolvedCommand: [...command.slice(0, -1), path422.resolve(resolved.resolvedPath)]
     });
   }
   return preprocessors;
@@ -35737,10 +36190,10 @@ async function resolveOptionalCommandSource(command, searchRoots) {
     return void 0;
   }
   const resolved = await resolveFileReference3(candidate, searchRoots);
-  return resolved.resolvedPath ? path41.resolve(resolved.resolvedPath) : void 0;
+  return resolved.resolvedPath ? path422.resolve(resolved.resolvedPath) : void 0;
 }
 function looksLikeFilePath(value) {
-  return path41.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
+  return path422.isAbsolute(value) || value.startsWith(".") || value.includes("/") || value.includes("\\") || /\.[cm]?[jt]sx?$|\.py$|\.sh$|\.bash$|\.rb$|\.go$|\.rs$/i.test(value);
 }
 function parseCommandToArgv(command) {
   if (process.platform === "win32") {
@@ -36128,7 +36581,7 @@ var IMAGE_MEDIA_TYPES = {
   ".bmp": "image/bmp"
 };
 function detectImageMediaType(filePath) {
-  const ext = path422.extname(filePath).toLowerCase();
+  const ext = path43.extname(filePath).toLowerCase();
   return IMAGE_MEDIA_TYPES[ext];
 }
 var ANSI_YELLOW5 = "\x1B[33m";
@@ -36192,7 +36645,7 @@ async function processMessages(options) {
             ...cloneJsonObject(rawSegment),
             path: displayPath,
             text: fileContent,
-            resolvedPath: path422.resolve(resolvedPath)
+            resolvedPath: path43.resolve(resolvedPath)
           });
           if (verbose) {
             const label = messageType === "input" ? "[File]" : "[Expected Output File]";
@@ -36316,7 +36769,7 @@ async function processExpectedMessages(options) {
               type: "file",
               path: displayPath,
               text: fileContent,
-              resolvedPath: path422.resolve(resolvedPath)
+              resolvedPath: path43.resolve(resolvedPath)
             });
             if (verbose) {
               console.log(`  [Expected Output File] Found: ${displayPath}`);
@@ -36462,7 +36915,7 @@ function matchesFilter(id, filter) {
   return typeof filter === "string" ? micromatch.isMatch(id, filter) : filter.some((pattern) => micromatch.isMatch(id, pattern));
 }
 function detectFormat(filePath) {
-  const ext = path43.extname(filePath).toLowerCase();
+  const ext = path44.extname(filePath).toLowerCase();
   if (ext === ".jsonl") return "jsonl";
   if (ext === ".yaml" || ext === ".yml") return "yaml";
   if (ext === ".json") return "agent-skills-json";
@@ -36472,9 +36925,9 @@ function detectFormat(filePath) {
   );
 }
 async function loadSidecarMetadata(jsonlPath, verbose) {
-  const dir = path43.dirname(jsonlPath);
-  const base = path43.basename(jsonlPath, ".jsonl");
-  const sidecarPath = path43.join(dir, `${base}.yaml`);
+  const dir = path44.dirname(jsonlPath);
+  const base = path44.basename(jsonlPath, ".jsonl");
+  const sidecarPath = path44.join(dir, `${base}.yaml`);
   if (!await fileExists3(sidecarPath)) {
     if (verbose) {
       logWarning4(`Sidecar metadata file not found: ${sidecarPath} (using defaults)`);
@@ -36523,13 +36976,13 @@ function parseJsonlContent(content, filePath) {
 async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path43.resolve(evalFilePath);
+  const absoluteTestPath = path44.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const sidecar = await loadSidecarMetadata(absoluteTestPath, verbose);
   const rawFile = await readFile17(absoluteTestPath, "utf8");
   const rawCases = parseJsonlContent(rawFile, evalFilePath);
-  const fallbackSuiteName = path43.basename(absoluteTestPath, ".jsonl") || "eval";
+  const fallbackSuiteName = path44.basename(absoluteTestPath, ".jsonl") || "eval";
   const suiteName = sidecar.name && sidecar.name.trim().length > 0 ? sidecar.name : fallbackSuiteName;
   const globalEvaluator = coerceEvaluator(sidecar.evaluator, "sidecar") ?? "llm-grader";
   const globalExecution = sidecar.execution;
@@ -36687,60 +37140,51 @@ function parseMetadata(suite) {
     requires: suite.requires
   });
 }
-function parseRepoSource(raw) {
+function readString(obj, key) {
+  const value = obj[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readStringArray(obj, key) {
+  const value = obj[key];
+  if (!Array.isArray(value)) return void 0;
+  const strings = value.filter((item) => typeof item === "string");
+  return strings.length > 0 ? strings : void 0;
+}
+function parseRepoConfig(raw) {
   if (!isJsonObject(raw)) return void 0;
   const obj = raw;
-  if (obj.type === "git" && typeof obj.url === "string") {
-    return { type: "git", url: obj.url };
+  if ("source" in obj) {
+    throw new Error("workspace.repos[].source has been removed. Use workspace.repos[].repo.");
+  }
+  if ("checkout" in obj) {
+    throw new Error(
+      "workspace.repos[].checkout has been removed. Use top-level commit, base_commit, and ancestor."
+    );
   }
-  if (obj.type === "local" && typeof obj.path === "string") {
-    return { type: "local", path: obj.path };
+  if ("clone" in obj) {
+    throw new Error("workspace.repos[].clone has been removed. Use top-level sparse if needed.");
   }
-  return void 0;
-}
-function parseRepoCheckout(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  const ref = typeof obj.ref === "string" ? obj.ref : void 0;
-  const baseCommit = typeof obj.base_commit === "string" ? obj.base_commit : void 0;
-  const resolve = obj.resolve === "remote" || obj.resolve === "local" ? obj.resolve : void 0;
+  const repoPath = readString(obj, "path");
+  const repo = readString(obj, "repo");
+  const commit = readString(obj, "commit");
+  const baseCommit = readString(obj, "base_commit");
   const ancestor = typeof obj.ancestor === "number" ? obj.ancestor : void 0;
-  if (!ref && !baseCommit && !resolve && ancestor === void 0) return void 0;
+  const sparse = readStringArray(obj, "sparse");
+  if (commit !== void 0 && baseCommit !== void 0 && commit !== baseCommit) {
+    throw new Error("workspace.repos[].commit and workspace.repos[].base_commit must match.");
+  }
+  if (!repoPath && !repo && !commit && !baseCommit && ancestor === void 0 && !sparse) {
+    return void 0;
+  }
   return {
-    ...ref !== void 0 && { ref },
+    ...repoPath !== void 0 && { path: repoPath },
+    ...repo !== void 0 && { repo },
+    ...commit !== void 0 && { commit },
     ...baseCommit !== void 0 && { base_commit: baseCommit },
-    ...resolve !== void 0 && { resolve },
-    ...ancestor !== void 0 && { ancestor }
-  };
-}
-function parseRepoClone(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  const depth = typeof obj.depth === "number" ? obj.depth : void 0;
-  const filter = typeof obj.filter === "string" ? obj.filter : void 0;
-  const sparse = Array.isArray(obj.sparse) ? obj.sparse.filter((s) => typeof s === "string") : void 0;
-  if (depth === void 0 && !filter && !sparse) return void 0;
-  return {
-    ...depth !== void 0 && { depth },
-    ...filter !== void 0 && { filter },
+    ...ancestor !== void 0 && { ancestor },
     ...sparse !== void 0 && { sparse }
   };
 }
-function parseRepoConfig(raw) {
-  if (!isJsonObject(raw)) return void 0;
-  const obj = raw;
-  const repoPath = typeof obj.path === "string" ? obj.path : void 0;
-  const source = parseRepoSource(obj.source);
-  const checkout = parseRepoCheckout(obj.checkout);
-  const clone2 = parseRepoClone(obj.clone);
-  if (!repoPath && !source && !checkout && !clone2) return void 0;
-  return {
-    ...repoPath !== void 0 && { path: repoPath },
-    ...source !== void 0 && { source },
-    ...checkout !== void 0 && { checkout },
-    ...clone2 !== void 0 && { clone: clone2 }
-  };
-}
 async function buildPromptInputs(testCase, mode = "lm") {
   const segmentsByMessage = testCase.input.map(
     (message) => extractContentSegments(message.content)
@@ -36935,7 +37379,7 @@ function interpolateRawEvalCase(raw, vars) {
 }
 async function readTestSuiteMetadata(testFilePath) {
   try {
-    const absolutePath = path44.resolve(testFilePath);
+    const absolutePath = path45.resolve(testFilePath);
     const content = await readFile18(absolutePath, "utf8");
     const parsed = interpolateEnv(parseYamlValue(content), process.env);
     if (!isJsonObject(parsed)) {
@@ -36960,7 +37404,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-RBTB2HG2-H5TRXZLO.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-TJT6BGFF-DI7XNSO4.js");
     return loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
   }
   const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
@@ -36995,7 +37439,7 @@ async function loadTests(evalFilePath, repoRoot, options) {
     return loadTestsFromAgentSkills(evalFilePath);
   }
   if (format === "typescript") {
-    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-RBTB2HG2-H5TRXZLO.js");
+    const { loadTsEvalSuite: loadTsEvalSuite2 } = await import("./ts-eval-loader-TJT6BGFF-DI7XNSO4.js");
     const suite = await loadTsEvalSuite2(evalFilePath, resolveToAbsolutePath(repoRoot), options);
     return suite.tests;
   }
@@ -37006,7 +37450,7 @@ var loadEvalCases = loadTests;
 async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
   const filterPattern = options?.filter;
-  const absoluteTestPath = path44.resolve(evalFilePath);
+  const absoluteTestPath = path45.resolve(evalFilePath);
   const repoRootPath = resolveToAbsolutePath(repoRoot);
   const searchRoots = buildSearchRoots2(absoluteTestPath, repoRootPath);
   const config2 = await loadConfig(absoluteTestPath, repoRootPath);
@@ -37019,7 +37463,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   }
   const suite = interpolated;
   const suiteNameFromFile = asString5(suite.name)?.trim();
-  const fallbackSuiteName = path44.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
+  const fallbackSuiteName = path45.basename(absoluteTestPath).replace(/\.eval\.ya?ml$/i, "").replace(/\.ya?ml$/i, "") || "eval";
   const suiteName = suiteNameFromFile && suiteNameFromFile.length > 0 ? suiteNameFromFile : fallbackSuiteName;
   const rawTestCases = resolveTests(suite);
   const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm-grader";
@@ -37029,10 +37473,10 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     "<suite>",
     absoluteTestPath
   );
-  const evalFileDir = path44.dirname(absoluteTestPath);
+  const evalFileDir = path45.dirname(absoluteTestPath);
   let expandedTestCases;
   if (typeof rawTestCases === "string") {
-    const externalPath = path44.resolve(evalFileDir, rawTestCases);
+    const externalPath = path45.resolve(evalFileDir, rawTestCases);
     let isDir = false;
     try {
       const pathStat = await stat8(externalPath);
@@ -37266,7 +37710,7 @@ function buildEvalTestSource(params) {
   };
 }
 function stringifySourceYaml(value) {
-  return stringifyYaml(sanitizeSourceValue(value), { lineWidth: 0 }).trimEnd();
+  return stringifyYaml2(sanitizeSourceValue(value), { lineWidth: 0 }).trimEnd();
 }
 function sanitizeSourceValue(value, keyHint) {
   if (keyHint && SOURCE_SECRET_KEY_PATTERN.test(keyHint)) {
@@ -37336,7 +37780,7 @@ function collectInputSourceReferences(inputMessages) {
       references.push({
         kind: "input_file",
         displayPath,
-        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path44.resolve(segment.resolvedPath) } : {}
+        ...typeof segment.resolvedPath === "string" ? { resolvedPath: path45.resolve(segment.resolvedPath) } : {}
       });
     }
   }
@@ -37409,7 +37853,7 @@ function collectSingleGraderSourceReferences(evaluator) {
       references.push({
         kind: "code_grader_command",
         displayPath: evaluator.aggregator.path,
-        resolvedPath: path44.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
+        resolvedPath: path45.resolve(evaluator.aggregator.cwd ?? "", evaluator.aggregator.path),
         graderName: evaluator.name
       });
     } else if (evaluator.aggregator.type === "llm-grader" && evaluator.aggregator.promptPath) {
@@ -37442,9 +37886,9 @@ function dedupeSourceReferences(references) {
   return deduped;
 }
 function toPortableRelativePath(root, candidate) {
-  const relative = path44.relative(root, candidate);
-  if (relative && !relative.startsWith("..") && !path44.isAbsolute(relative)) {
-    return relative.split(path44.sep).join("/");
+  const relative = path45.relative(root, candidate);
+  if (relative && !relative.startsWith("..") && !path45.isAbsolute(relative)) {
+    return relative.split(path45.sep).join("/");
   }
   return void 0;
 }
@@ -37498,8 +37942,8 @@ function parseWorkspaceScriptConfig(raw, evalFileDir) {
   if (!command) return void 0;
   const timeoutMs = typeof obj.timeout_ms === "number" ? obj.timeout_ms : void 0;
   let cwd = typeof obj.cwd === "string" ? obj.cwd : void 0;
-  if (cwd && !path44.isAbsolute(cwd)) {
-    cwd = path44.resolve(evalFileDir, cwd);
+  if (cwd && !path45.isAbsolute(cwd)) {
+    cwd = path45.resolve(evalFileDir, cwd);
   }
   const config2 = { command };
   if (timeoutMs !== void 0) {
@@ -37537,7 +37981,7 @@ function parseWorkspaceHooksConfig(raw, evalFileDir) {
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
-    const workspaceFilePath = path44.resolve(evalFileDir, raw);
+    const workspaceFilePath = path45.resolve(evalFileDir, raw);
     let content;
     try {
       content = await readFile18(workspaceFilePath, "utf8");
@@ -37550,7 +37994,7 @@ async function resolveWorkspaceConfig(raw, evalFileDir) {
         `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
       );
     }
-    const workspaceFileDir = path44.dirname(workspaceFilePath);
+    const workspaceFileDir = path45.dirname(workspaceFilePath);
     const resolvedWorkspace = parseWorkspaceConfig(parsed, workspaceFileDir);
     if (resolvedWorkspace) {
       return { ...resolvedWorkspace, workspaceFileDir };
@@ -37584,8 +38028,8 @@ function parseWorkspaceConfig(raw, evalFileDir) {
     throw new Error("workspace.static has been removed. Use workspace.mode='static'.");
   }
   let template = typeof obj.template === "string" ? obj.template : void 0;
-  if (template && !path44.isAbsolute(template)) {
-    template = path44.resolve(evalFileDir, template);
+  if (template && !path45.isAbsolute(template)) {
+    template = path45.resolve(evalFileDir, template);
   }
   const isolation = obj.isolation === "shared" || obj.isolation === "per_test" ? obj.isolation : void 0;
   const repos = Array.isArray(obj.repos) ? obj.repos.map(parseRepoConfig).filter(Boolean) : void 0;
@@ -37722,7 +38166,7 @@ ${detailBlock}${ANSI_RESET8}`);
     console.error(`${ANSI_RED3}Error: ${message}${ANSI_RESET8}`);
   }
 }
-var execFileAsync3 = promisify7(execFile3);
+var execFileAsync2 = promisify6(execFile2);
 var WORKSPACE_GIT_TIMEOUT_MS = 3e5;
 function pathFromRoot(root) {
   return root instanceof URL ? fileURLToPath5(root) : String(root);
@@ -37779,7 +38223,7 @@ function workspaceGitEnv() {
   };
 }
 async function resetWorkspaceRoot(workspacePath, resetMode, baselineRef) {
-  if (!existsSync5(path45.join(workspacePath, ".git"))) {
+  if (!existsSync6(path46.join(workspacePath, ".git"))) {
     return false;
   }
   const cleanFlag = resetMode === "strict" ? "-fdx" : "-fd";
@@ -37789,8 +38233,8 @@ async function resetWorkspaceRoot(workspacePath, resetMode, baselineRef) {
     env: workspaceGitEnv(),
     maxBuffer: 50 * 1024 * 1024
   };
-  await execFileAsync3("git", ["reset", "--hard", baselineRef ?? "HEAD"], opts);
-  await execFileAsync3("git", ["clean", cleanFlag], opts);
+  await execFileAsync2("git", ["reset", "--hard", baselineRef ?? "HEAD"], opts);
+  await execFileAsync2("git", ["clean", cleanFlag], opts);
   return true;
 }
 function validateDependencyGraph(tests) {
@@ -37822,18 +38266,18 @@ function validateDependencyGraph(tests) {
   }
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
-  function visit(id, path48) {
+  function visit(id, path49) {
     if (visiting.has(id)) {
-      const cycle = [...path48.slice(path48.indexOf(id)), id];
+      const cycle = [...path49.slice(path49.indexOf(id)), id];
       throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
     }
     if (visited.has(id)) return;
     visiting.add(id);
-    path48.push(id);
+    path49.push(id);
     for (const dep of depMap.get(id) ?? []) {
-      visit(dep, path48);
+      visit(dep, path49);
     }
-    path48.pop();
+    path49.pop();
     visiting.delete(id);
     visited.add(id);
   }
@@ -37933,7 +38377,7 @@ async function runEvaluation(options) {
     );
     useCache = false;
   }
-  const evalRunId = randomUUID9();
+  const evalRunId = randomUUID10();
   const evalCases = preloadedEvalCases ?? await loadTests(evalFilePath, repoRoot, { verbose, filter });
   const filteredEvalCases = filterEvalCases(evalCases, filter);
   if (filteredEvalCases.length === 0) {
@@ -38015,7 +38459,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path45.dirname(path45.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path46.dirname(path46.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -38081,29 +38525,6 @@ async function runEvaluation(options) {
       console.log(`[setup] ${message}`);
     }
   };
-  const allRepos = /* @__PURE__ */ new Map();
-  for (const ec of filteredEvalCases) {
-    if (ec.workspace?.repos) {
-      for (const repo of ec.workspace.repos) {
-        if (!repo.source) continue;
-        const key = `${repo.path ?? ""}::${repo.source.type === "local" ? repo.source.path : ""}`;
-        if (!allRepos.has(key)) {
-          allRepos.set(key, repo);
-        }
-      }
-    }
-  }
-  if (allRepos.size > 0) {
-    const localPathErrors = RepoManager.validateLocalPaths([...allRepos.values()]);
-    if (localPathErrors.length > 0) {
-      const message = RepoManager.formatValidationErrors(localPathErrors);
-      console.warn(`Warning: ${message}`);
-      const invalidLocalRepoPaths = new Set(localPathErrors.map((e) => e.repoPath));
-      if (suiteWorkspace?.repos?.some((r) => r.path && invalidLocalRepoPaths.has(r.path))) {
-        throw new Error(message);
-      }
-    }
-  }
   const isPerTestIsolation = suiteWorkspace?.isolation === "per_test";
   const cliWorkspacePath = workspacePath ?? legacyWorkspacePath;
   const yamlWorkspacePath = suiteWorkspace?.path;
@@ -38172,7 +38593,7 @@ async function runEvaluation(options) {
     const isEmpty = dirExists ? (await readdir8(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await mkdir16(configuredStaticPath, { recursive: true });
+        await mkdir17(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -38217,7 +38638,7 @@ async function runEvaluation(options) {
     }
   } else if (!isPerTestIsolation && (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length)) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await mkdir16(sharedWorkspacePath, { recursive: true });
+    await mkdir17(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
@@ -38258,7 +38679,7 @@ async function runEvaluation(options) {
     };
     var toDependencyResult = toDependencyResult2, checkDependencies = checkDependencies2, extractEvaluationCostUsd = extractEvaluationCostUsd2;
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = path45.join(sharedWorkspacePath, path45.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = path46.join(sharedWorkspacePath, path46.basename(suiteWorkspaceFile));
       try {
         await stat9(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
@@ -38273,9 +38694,9 @@ async function runEvaluation(options) {
       try {
         if (needsPerRepoCheck) {
           for (const repo of suiteWorkspace.repos) {
-            if (!repo.path || !repo.source) continue;
-            const targetDir = path45.join(sharedWorkspacePath, repo.path);
-            if (existsSync5(targetDir)) {
+            if (!repo.path || !repo.repo) continue;
+            const targetDir = path46.join(sharedWorkspacePath, repo.path);
+            if (existsSync6(targetDir)) {
               setupLog(`reusing existing repo at: ${targetDir}`);
               continue;
             }
@@ -39140,7 +39561,7 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = path45.join(workspacePath, path45.basename(caseWorkspaceFile));
+        const copiedFile = path46.join(workspacePath, path46.basename(caseWorkspaceFile));
         try {
           await stat9(copiedFile);
           caseWorkspaceFile = copiedFile;
@@ -39150,25 +39571,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await mkdir16(workspacePath, { recursive: true });
-    }
-    if (evalCase.workspace?.repos?.length && workspacePath) {
-      const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
-      if (localPathErrors.length > 0) {
-        const message = RepoManager.formatValidationErrors(localPathErrors);
-        console.warn(`Warning: test=${evalCase.id} ${message}`);
-        return buildErrorResult(
-          evalCase,
-          target.name,
-          nowFn(),
-          new Error(message),
-          promptInputs,
-          provider,
-          "repo_setup",
-          "local_path_not_found",
-          verbose
-        );
-      }
+      await mkdir17(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const perCaseRepoManager = new RepoManager(setupDebug);
@@ -39202,10 +39605,10 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = path45.resolve(baseDir, relPath);
-          const destPath = path45.resolve(workspacePath, relPath);
+          const srcPath = path46.resolve(baseDir, relPath);
+          const destPath = path46.resolve(workspacePath, relPath);
           try {
-            await mkdir16(path45.dirname(destPath), { recursive: true });
+            await mkdir17(path46.dirname(destPath), { recursive: true });
             await copyFile2(srcPath, destPath);
           } catch (error40) {
             const message = error40 instanceof Error ? error40.message : String(error40);
@@ -39434,7 +39837,7 @@ async function runEvalCase(options) {
       lastError = error40;
       if (attempt + 1 < attemptBudget) {
         const delayMs = retryBackoffMs(attempt);
-        await sleep2(delayMs, signal);
+        await sleep3(delayMs, signal);
         attempt += 1;
         continue;
       }
@@ -40085,7 +40488,7 @@ async function runEvaluatorList(options) {
     dockerConfig,
     dependencyResults
   };
-  const evalFileDir = evalCase.file_paths[0] ? path45.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? path46.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -40621,7 +41024,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = createHash4("sha256");
+  const hash = createHash5("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -40706,7 +41109,7 @@ function extractErrorMessage(error40) {
 function retryBackoffMs(attempt) {
   return Math.min(2 ** attempt * 1e3, 3e4);
 }
-function sleep2(ms, signal) {
+function sleep3(ms, signal) {
   if (signal?.aborted) return Promise.resolve();
   return new Promise((resolve) => {
     const timer = setTimeout(resolve, ms);
@@ -40748,15 +41151,15 @@ function computeWeightedMean(entries) {
   return totalWeight > 0 ? weightedSum / totalWeight : 0;
 }
 async function runPreflightChecks(env, cwd, log) {
-  const execFileAsync4 = promisify7(execFile3);
+  const execFileAsync3 = promisify6(execFile2);
   const missing = [];
   for (const cmd of env.required_commands ?? []) {
     log(`preflight: checking command "${cmd}"`);
     try {
       if (process.platform === "win32") {
-        await execFileAsync4("where", [cmd], { cwd });
+        await execFileAsync3("where", [cmd], { cwd });
       } else {
-        await execFileAsync4("sh", ["-c", `command -v ${cmd}`], { cwd });
+        await execFileAsync3("sh", ["-c", `command -v ${cmd}`], { cwd });
       }
     } catch {
       missing.push(`command: ${cmd}`);
@@ -40765,7 +41168,7 @@ async function runPreflightChecks(env, cwd, log) {
   for (const mod of env.required_python_modules ?? []) {
     log(`preflight: checking Python module "${mod}"`);
     try {
-      await execFileAsync4("python3", ["-c", `import ${mod}`], { cwd });
+      await execFileAsync3("python3", ["-c", `import ${mod}`], { cwd });
     } catch {
       missing.push(`python module: ${mod}`);
     }
@@ -40843,7 +41246,7 @@ async function evaluate(config2) {
     cliNoCache: false,
     yamlCache: config2.cache === void 0 ? materialized.cache : void 0
   });
-  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path46.resolve(materialized.cachePath) : void 0) : void 0;
+  const cache = cacheEnabled ? new ResponseCache(materialized.cachePath ? path47.resolve(materialized.cachePath) : void 0) : void 0;
   const results = await runEvaluation({
     testFilePath,
     repoRoot,
@@ -40874,7 +41277,7 @@ async function evaluate(config2) {
 async function materializeEvalConfig(config2, options) {
   const baseDir = options?.baseDir ?? process.cwd();
   const repoRoot = options?.repoRoot ?? await findGitRoot(baseDir) ?? baseDir;
-  const testFilePath = config2.specFile ? path46.resolve(baseDir, config2.specFile) : path46.join(baseDir, "__programmatic__.yaml");
+  const testFilePath = config2.specFile ? path47.resolve(baseDir, config2.specFile) : path47.join(baseDir, "__programmatic__.yaml");
   const effectiveFilter = options?.filter ?? config2.filter;
   if (config2.specFile) {
     const suite = await loadTestSuite(testFilePath, repoRoot, {
@@ -40951,7 +41354,7 @@ function convertAssertions(entries) {
 }
 function buildInlineEvalTests(config2, options) {
   const suiteWorkspace = config2.beforeAll ? { hooks: { before_all: toBeforeAllHook(config2.beforeAll) } } : void 0;
-  const derivedSuiteName = path46.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
+  const derivedSuiteName = path47.basename(options.testFilePath).replace(/\.eval\.[cm]?ts$/i, "").replace(/\.[cm]?ts$/i, "");
   const suiteName = config2.metadata?.name ?? (derivedSuiteName || "eval");
   return (config2.tests ?? []).filter((test) => !options.filter || matchesFilter4(test.id, options.filter)).map((test) => {
     const isConversation = test.mode === "conversation" || test.turns && test.turns.length > 0;
@@ -41047,11 +41450,11 @@ function computeSummary(results, durationMs, threshold = DEFAULT_THRESHOLD) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path46.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path47.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path46.join(dir, candidate);
-      if (!existsSync6(targetsPath)) continue;
+      const targetsPath = path47.join(dir, candidate);
+      if (!existsSync7(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -41063,16 +41466,16 @@ async function discoverDefaultTarget(repoRoot) {
   return null;
 }
 async function loadEnvHierarchy(repoRoot, startPath) {
-  const { readFileSync: readFileSync22 } = await import("node:fs");
+  const { readFileSync: readFileSync4 } = await import("node:fs");
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path46.join(dir, ".env");
-    if (existsSync6(envPath)) envFiles.push(envPath);
+    const envPath = path47.join(dir, ".env");
+    if (existsSync7(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
-      const content = readFileSync22(envFiles[i], "utf8");
+      const content = readFileSync4(envFiles[i], "utf8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
@@ -41093,7 +41496,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
 }
 var EXPORT_NAMES = ["default", "config", "evalConfig"];
 async function loadTsEvalFile(filePath) {
-  const absolutePath = path47.resolve(filePath);
+  const absolutePath = path48.resolve(filePath);
   const moduleUrl = pathToFileURL2(absolutePath).href;
   const module = await import(moduleUrl);
   let config2;
@@ -41115,7 +41518,7 @@ async function loadTsEvalSuite(filePath, repoRoot, options) {
   const { config: config2, filePath: absolutePath } = await loadTsEvalFile(filePath);
   const materialized = await materializeEvalConfig(config2, {
     repoRoot,
-    baseDir: path47.dirname(absolutePath),
+    baseDir: path48.dirname(absolutePath),
     filter: options?.filter,
     category: options?.category
   });
@@ -41203,6 +41606,7 @@ export {
   negateScore,
   toSnakeCaseDeep,
   toCamelCaseDeep,
+  getRepoCheckoutRef,
   CodeGrader,
   executeScript,
   DEFAULT_GRADER_TEMPLATE,
@@ -41357,8 +41761,20 @@ export {
   createTempWorkspace,
   cleanupWorkspace,
   cleanupEvalWorkspaces,
+  resolveRepoCloneUrl,
+  normalizeRepoIdentity,
   computeWorkspaceFingerprint,
   WorkspacePoolManager,
+  getProjectsRegistryPath,
+  loadProjectRegistry,
+  saveProjectRegistry,
+  deriveProjectId,
+  addProject,
+  removeProject,
+  getProject,
+  getProjectForPath,
+  touchProject,
+  discoverProjects,
   RepoManager,
   resolveWorkspaceTemplate,
   executeWorkspaceScript,
@@ -41377,9 +41793,7 @@ export {
   extractThreshold,
   resolveResultsConfigForProject,
   detectFormat,
-  parseRepoSource,
-  parseRepoCheckout,
-  parseRepoClone,
+  parseRepoConfig,
   buildPromptInputs,
   readTestSuiteMetadata,
   loadTestSuite,
@@ -41394,4 +41808,4 @@ export {
   loadTsEvalFile,
   loadTsEvalSuite
 };
-//# sourceMappingURL=chunk-RL4S2FBZ.js.map
+//# sourceMappingURL=chunk-VBHHZQS6.js.map