@agentv/core 2.15.0 → 2.17.0

package/dist/index.cjs

@@ -1244,11 +1244,11 @@ function serializeAttributeValue(value) {
   if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
   return { stringValue: String(value) };
 }
-var import_promises32, import_node_path45, OtlpJsonFileExporter;
+var import_promises31, import_node_path45, OtlpJsonFileExporter;
 var init_otlp_json_file_exporter = __esm({
   "src/observability/otlp-json-file-exporter.ts"() {
     "use strict";
-    import_promises32 = require("fs/promises");
+    import_promises31 = require("fs/promises");
     import_node_path45 = require("path");
     OtlpJsonFileExporter = class {
       // biome-ignore lint/suspicious/noExplicitAny: serialized span data
@@ -1288,7 +1288,7 @@ var init_otlp_json_file_exporter = __esm({
       }
       async flush() {
         if (this.spans.length === 0) return;
-        await (0, import_promises32.mkdir)((0, import_node_path45.dirname)(this.filePath), { recursive: true });
+        await (0, import_promises31.mkdir)((0, import_node_path45.dirname)(this.filePath), { recursive: true });
         const otlpJson = {
           resourceSpans: [
             {
@@ -1302,8 +1302,8 @@ var init_otlp_json_file_exporter = __esm({
             }
           ]
         };
-        const { writeFile: writeFile10 } = await import("fs/promises");
-        await writeFile10(this.filePath, JSON.stringify(otlpJson, null, 2));
+        const { writeFile: writeFile9 } = await import("fs/promises");
+        await writeFile9(this.filePath, JSON.stringify(otlpJson, null, 2));
       }
     };
   }
@@ -1319,12 +1319,12 @@ function hrTimeDiffMs(start, end) {
   const diffNano = end[1] - start[1];
   return Math.round(diffSec * 1e3 + diffNano / 1e6);
 }
-var import_node_fs14, import_promises33, import_node_path46, SimpleTraceFileExporter;
+var import_node_fs13, import_promises32, import_node_path46, SimpleTraceFileExporter;
 var init_simple_trace_file_exporter = __esm({
   "src/observability/simple-trace-file-exporter.ts"() {
     "use strict";
-    import_node_fs14 = require("fs");
-    import_promises33 = require("fs/promises");
+    import_node_fs13 = require("fs");
+    import_promises32 = require("fs/promises");
     import_node_path46 = require("path");
     SimpleTraceFileExporter = class {
       stream = null;
@@ -1338,8 +1338,8 @@ var init_simple_trace_file_exporter = __esm({
       async ensureStream() {
         if (!this.streamReady) {
           this.streamReady = (async () => {
-            await (0, import_promises33.mkdir)((0, import_node_path46.dirname)(this.filePath), { recursive: true });
-            this.stream = (0, import_node_fs14.createWriteStream)(this.filePath, { flags: "w" });
+            await (0, import_promises32.mkdir)((0, import_node_path46.dirname)(this.filePath), { recursive: true });
+            this.stream = (0, import_node_fs13.createWriteStream)(this.filePath, { flags: "w" });
             return this.stream;
           })();
         }
@@ -1505,7 +1505,6 @@ __export(index_exports, {
   freeformEvaluationSchema: () => freeformEvaluationSchema,
   generateRubrics: () => generateRubrics,
   getAgentvHome: () => getAgentvHome,
-  getGitCacheRoot: () => getGitCacheRoot,
   getHitCount: () => getHitCount,
   getSubagentsRoot: () => getSubagentsRoot,
   getTraceStateRoot: () => getTraceStateRoot,
@@ -4741,16 +4740,31 @@ function parseRepoConfig(raw) {
     ...clone !== void 0 && { clone }
   };
 }
-function parseResetConfig(raw) {
+function parseWorkspaceHookConfig(raw, evalFileDir) {
   if (!isJsonObject(raw)) return void 0;
+  const script = parseWorkspaceScriptConfig(raw, evalFileDir);
   const obj = raw;
-  const strategy = obj.strategy === "none" || obj.strategy === "hard" || obj.strategy === "recreate" ? obj.strategy : void 0;
-  const afterEach = typeof obj.after_each === "boolean" ? obj.after_each : void 0;
-  if (!strategy && afterEach === void 0) return void 0;
+  const reset = obj.reset === "none" || obj.reset === "fast" || obj.reset === "strict" ? obj.reset : void 0;
+  if (!script && !reset) return void 0;
   return {
-    ...strategy !== void 0 && { strategy },
-    ...afterEach !== void 0 && { after_each: afterEach }
+    ...script ?? {},
+    ...reset !== void 0 && { reset }
+  };
+}
+function parseWorkspaceHooksConfig(raw, evalFileDir) {
+  if (!isJsonObject(raw)) return void 0;
+  const obj = raw;
+  const beforeAll = parseWorkspaceHookConfig(obj.before_all, evalFileDir);
+  const beforeEach = parseWorkspaceHookConfig(obj.before_each, evalFileDir);
+  const afterEach = parseWorkspaceHookConfig(obj.after_each, evalFileDir);
+  const afterAll = parseWorkspaceHookConfig(obj.after_all, evalFileDir);
+  const hooks = {
+    ...beforeAll !== void 0 && { before_all: beforeAll },
+    ...beforeEach !== void 0 && { before_each: beforeEach },
+    ...afterEach !== void 0 && { after_each: afterEach },
+    ...afterAll !== void 0 && { after_all: afterAll }
   };
+  return Object.keys(hooks).length > 0 ? hooks : void 0;
 }
 async function resolveWorkspaceConfig(raw, evalFileDir) {
   if (typeof raw === "string") {
@@ -4781,37 +4795,48 @@ function parseWorkspaceConfig(raw, evalFileDir) {
   }
   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;
-  const reset = parseResetConfig(obj.reset);
-  const beforeAll = parseWorkspaceScriptConfig(obj.before_all, evalFileDir);
-  const afterAll = parseWorkspaceScriptConfig(obj.after_all, evalFileDir);
-  const beforeEach = parseWorkspaceScriptConfig(obj.before_each, evalFileDir);
-  const afterEach = parseWorkspaceScriptConfig(obj.after_each, evalFileDir);
-  if (!template && !isolation && !repos && !reset && !beforeAll && !afterAll && !beforeEach && !afterEach)
+  const hooks = parseWorkspaceHooksConfig(obj.hooks, evalFileDir);
+  const mode = obj.mode === "pooled" || obj.mode === "ephemeral" || obj.mode === "static" ? obj.mode : void 0;
+  const staticPath = typeof obj.static_path === "string" ? obj.static_path : void 0;
+  const pool = typeof obj.pool === "boolean" ? obj.pool : void 0;
+  if (!template && !isolation && !repos && !hooks && !mode && !staticPath && pool === void 0)
     return void 0;
   return {
     ...template !== void 0 && { template },
     ...isolation !== void 0 && { isolation },
     ...repos !== void 0 && { repos },
-    ...reset !== void 0 && { reset },
-    ...beforeAll !== void 0 && { before_all: beforeAll },
-    ...afterAll !== void 0 && { after_all: afterAll },
-    ...beforeEach !== void 0 && { before_each: beforeEach },
-    ...afterEach !== void 0 && { after_each: afterEach }
+    ...hooks !== void 0 && { hooks },
+    ...mode !== void 0 && { mode },
+    ...staticPath !== void 0 && { static_path: staticPath },
+    ...pool !== void 0 && { pool }
   };
 }
 function mergeWorkspaceConfigs(suiteLevel, caseLevel) {
   if (!suiteLevel && !caseLevel) return void 0;
   if (!suiteLevel) return caseLevel;
   if (!caseLevel) return suiteLevel;
+  const mergeHook = (suiteHook, caseHook) => {
+    if (!suiteHook && !caseHook) return void 0;
+    return {
+      ...suiteHook ?? {},
+      ...caseHook ?? {}
+    };
+  };
+  const mergedHooks = {
+    before_all: mergeHook(suiteLevel.hooks?.before_all, caseLevel.hooks?.before_all),
+    before_each: mergeHook(suiteLevel.hooks?.before_each, caseLevel.hooks?.before_each),
+    after_each: mergeHook(suiteLevel.hooks?.after_each, caseLevel.hooks?.after_each),
+    after_all: mergeHook(suiteLevel.hooks?.after_all, caseLevel.hooks?.after_all)
+  };
+  const hasHooks = Object.values(mergedHooks).some((hook) => hook !== void 0);
   return {
     template: caseLevel.template ?? suiteLevel.template,
     isolation: caseLevel.isolation ?? suiteLevel.isolation,
     repos: caseLevel.repos ?? suiteLevel.repos,
-    reset: caseLevel.reset ?? suiteLevel.reset,
-    before_all: caseLevel.before_all ?? suiteLevel.before_all,
-    after_all: caseLevel.after_all ?? suiteLevel.after_all,
-    before_each: caseLevel.before_each ?? suiteLevel.before_each,
-    after_each: caseLevel.after_each ?? suiteLevel.after_each
+    ...hasHooks && { hooks: mergedHooks },
+    mode: caseLevel.mode ?? suiteLevel.mode,
+    static_path: caseLevel.static_path ?? suiteLevel.static_path,
+    pool: caseLevel.pool ?? suiteLevel.pool
   };
 }
 function asString6(value) {
@@ -7047,6 +7072,7 @@ var CopilotCliProvider = class {
     const agentProcess = (0, import_node_child_process2.spawn)(executable, args, {
       stdio: ["pipe", "pipe", "inherit"]
     });
+    await waitForProcessSpawn(agentProcess, executable, this.targetName);
     const toolCallsInProgress = /* @__PURE__ */ new Map();
     const completedToolCalls = [];
     let finalContent = "";
@@ -7326,6 +7352,47 @@ var CopilotCliProvider = class {
     }
   }
 };
+async function waitForProcessSpawn(proc, executable, targetName) {
+  if (proc.pid) {
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const onSpawn = () => {
+      cleanup();
+      resolve();
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(new Error(formatCopilotSpawnError(error, executable, targetName)));
+    };
+    const cleanup = () => {
+      proc.off("spawn", onSpawn);
+      proc.off("error", onError);
+    };
+    proc.once("spawn", onSpawn);
+    proc.once("error", onError);
+  });
+}
+function formatCopilotSpawnError(error, executable, targetName) {
+  const code = error.code;
+  const base = `Failed to start Copilot CLI executable '${executable}' for target '${targetName}'. ${error.message}`;
+  if (process.platform !== "win32") {
+    return base;
+  }
+  if (code !== "ENOENT" && code !== "EINVAL") {
+    return base;
+  }
+  return `${base}
+
+On Windows, shell commands like 'copilot -h' can work via .ps1/.bat shims, but AgentV launches a subprocess that needs a directly spawnable executable path.
+
+Fix options:
+1) Install native Copilot binary package:
+   npm install -g @github/copilot-win32-x64
+2) Set explicit executable for Copilot targets:
+   - In .env: COPILOT_EXE=C:\\Users\\<you>\\AppData\\Roaming\\npm\\node_modules\\@github\\copilot-win32-x64\\copilot.exe
+  - In .agentv/targets.yaml: executable: \${{ COPILOT_EXE }}`;
+}
 function summarizeAcpEvent(eventType, data) {
   if (!data || typeof data !== "object") {
     return eventType;
@@ -10077,9 +10144,6 @@ function getAgentvHome() {
 function getWorkspacesRoot() {
   return import_node_path23.default.join(getAgentvHome(), "workspaces");
 }
-function getGitCacheRoot() {
-  return import_node_path23.default.join(getAgentvHome(), "git-cache");
-}
 function getSubagentsRoot() {
   return import_node_path23.default.join(getAgentvHome(), "subagents");
 }
@@ -11539,16 +11603,16 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir17, readFile: readFile14, rm: rm7, writeFile: writeFile10 } = await import("fs/promises");
+  const { mkdir: mkdir16, readFile: readFile14, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
   const { tmpdir: tmpdir3 } = await import("os");
   const path44 = await import("path");
   const { randomUUID: randomUUID8 } = await import("crypto");
   const dir = path44.join(tmpdir3(), `agentv-exec-${randomUUID8()}`);
-  await mkdir17(dir, { recursive: true });
+  await mkdir16(dir, { recursive: true });
   const stdinPath = path44.join(dir, "stdin.txt");
   const stdoutPath = path44.join(dir, "stdout.txt");
   const stderrPath = path44.join(dir, "stderr.txt");
-  await writeFile10(stdinPath, stdinPayload, "utf8");
+  await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn4 } = await import("child_process");
   try {
@@ -11581,7 +11645,7 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
     const stderr = (await readFile14(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
-    await rm7(dir, { recursive: true, force: true });
+    await rm6(dir, { recursive: true, force: true });
   }
 }
 
@@ -14798,8 +14862,8 @@ function runEqualsAssertion(output, value) {
 }
 
 // src/evaluation/orchestrator.ts
-var import_node_crypto10 = require("crypto");
-var import_promises30 = require("fs/promises");
+var import_node_crypto9 = require("crypto");
+var import_promises29 = require("fs/promises");
 var import_node_path42 = __toESM(require("path"), 1);
 var import_micromatch4 = __toESM(require("micromatch"), 1);
 
@@ -15762,7 +15826,7 @@ var WorkspacePoolManager = class {
    * 7. Return the slot (with path, index, isExisting)
    */
   async acquireWorkspace(options) {
-    const { templatePath, repos, maxSlots, repoManager } = options;
+    const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(templatePath, repos);
     const poolDir = import_node_path39.default.join(this.poolRoot, fingerprint);
     await (0, import_promises27.mkdir)(poolDir, { recursive: true });
@@ -15782,7 +15846,7 @@ var WorkspacePoolManager = class {
       }
       const slotExists = (0, import_node_fs11.existsSync)(slotPath);
       if (slotExists) {
-        await this.resetSlot(slotPath, templatePath, repos);
+        await this.resetSlot(slotPath, templatePath, repos, poolReset);
         return {
           index: i,
           path: slotPath,
@@ -15914,15 +15978,19 @@ var WorkspacePoolManager = class {
    * 1. Reset repos (git reset --hard {ref} && git clean -fd per repo)
    * 2. Re-copy template files (skip repo directories)
    */
-  async resetSlot(slotPath, templatePath, repos) {
+  async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
       const repoDir = import_node_path39.default.join(slotPath, repo.path);
       if (!(0, import_node_fs11.existsSync)(repoDir)) {
         continue;
       }
+      if (poolReset === "none") {
+        continue;
+      }
       const ref = repo.checkout?.ref ?? "HEAD";
       await git(["reset", "--hard", ref], { cwd: repoDir });
-      await git(["clean", "-fd"], { cwd: repoDir });
+      const cleanFlag = poolReset === "strict" ? "-fdx" : "-fd";
+      await git(["clean", cleanFlag], { cwd: repoDir });
     }
     if (templatePath) {
       const repoDirNames = new Set(
@@ -15938,14 +16006,10 @@ var WorkspacePoolManager = class {
 
 // src/evaluation/workspace/repo-manager.ts
 var import_node_child_process8 = require("child_process");
-var import_node_crypto9 = require("crypto");
-var import_node_fs12 = require("fs");
-var import_promises28 = require("fs/promises");
 var import_node_path40 = __toESM(require("path"), 1);
 var import_node_util6 = require("util");
 var execFileAsync2 = (0, import_node_util6.promisify)(import_node_child_process8.execFile);
 var DEFAULT_TIMEOUT_MS2 = 3e5;
-var LOCK_TIMEOUT_MS = 6e4;
 function gitEnv2() {
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
@@ -15960,10 +16024,6 @@ function gitEnv2() {
     GIT_SSH_COMMAND: "ssh -o BatchMode=yes"
   };
 }
-function cacheKey(source) {
-  const raw = source.type === "git" ? source.url.toLowerCase().replace(/\.git$/, "") : source.path;
-  return (0, import_node_crypto9.createHash)("sha256").update(raw).digest("hex");
-}
 function getSourceUrl(source) {
   return source.type === "git" ? source.url : source.path;
 }
@@ -15977,33 +16037,9 @@ async function git2(args, opts) {
   });
   return stdout.trim();
 }
-async function acquireLock(lockPath) {
-  const start = Date.now();
-  while (Date.now() - start < LOCK_TIMEOUT_MS) {
-    try {
-      await (0, import_promises28.writeFile)(lockPath, String(process.pid), { flag: "wx" });
-      return;
-    } catch (err) {
-      if (err.code === "EEXIST") {
-        await new Promise((r) => setTimeout(r, 200));
-        continue;
-      }
-      throw err;
-    }
-  }
-  throw new Error(`Timed out waiting for lock: ${lockPath}`);
-}
-async function releaseLock(lockPath) {
-  try {
-    await (0, import_promises28.unlink)(lockPath);
-  } catch {
-  }
-}
 var RepoManager = class {
-  cacheDir;
   verbose;
-  constructor(cacheDir, verbose = false) {
-    this.cacheDir = cacheDir ?? getGitCacheRoot();
+  constructor(verbose = false) {
     this.verbose = verbose;
   }
   async runGit(args, opts) {
@@ -16028,86 +16064,18 @@ var RepoManager = class {
     }
   }
   /**
-   * Ensure a bare mirror cache exists for the given source.
-   * Creates on first access, fetches updates on subsequent calls.
-   * Returns the absolute path to the cache directory.
-   */
-  async ensureCache(source, depth, resolve) {
-    const key = cacheKey(source);
-    const cachePath = import_node_path40.default.join(this.cacheDir, key);
-    const lockPath = `${cachePath}.lock`;
-    const cacheExists = (0, import_node_fs12.existsSync)(import_node_path40.default.join(cachePath, "HEAD"));
-    if (this.verbose) {
-      console.log(
-        `[repo] ensureCache source=${getSourceUrl(source)} resolve=${resolve ?? "remote"} cache=${cachePath}`
-      );
-    }
-    if (resolve === "local") {
-      if (cacheExists) {
-        if (this.verbose) {
-          console.log(`[repo] using existing local cache ${cachePath}`);
-        }
-        return cachePath;
-      }
-      const url = getSourceUrl(source);
-      throw new Error(
-        `No cache found for \`${url}\`. Run \`agentv cache add --url ${url} --from <local-path>\` to seed it.`
-      );
-    }
-    await (0, import_promises28.mkdir)(this.cacheDir, { recursive: true });
-    const lockStartedAt = Date.now();
-    await acquireLock(lockPath);
-    if (this.verbose) {
-      console.log(`[repo] lock acquired path=${lockPath} waitedMs=${Date.now() - lockStartedAt}`);
-    }
-    try {
-      if (cacheExists) {
-        if (this.verbose) {
-          console.log(`[repo] refreshing existing cache ${cachePath}`);
-        }
-        const fetchArgs = ["fetch", "--prune"];
-        if (depth) {
-          fetchArgs.push("--depth", String(depth));
-        }
-        await this.runGit(fetchArgs, { cwd: cachePath });
-      } else {
-        if (this.verbose) {
-          console.log(`[repo] creating new cache ${cachePath}`);
-        }
-        const cloneArgs = ["clone", "--mirror", "--bare"];
-        if (depth) {
-          cloneArgs.push("--depth", String(depth));
-        }
-        const sourceUrl = getSourceUrl(source);
-        const cloneUrl = depth && source.type === "local" ? `file://${sourceUrl}` : sourceUrl;
-        cloneArgs.push(cloneUrl, cachePath);
-        await this.runGit(cloneArgs);
-      }
-    } finally {
-      await releaseLock(lockPath);
-      if (this.verbose) {
-        console.log(`[repo] lock released path=${lockPath}`);
-      }
-    }
-    return cachePath;
-  }
-  /**
-   * Clone a repo from cache into the workspace at the configured path.
+   * Clone a repo directly from source into the workspace at the configured path.
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
     const targetDir = import_node_path40.default.join(workspacePath, repo.path);
+    const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
       console.log(
-        `[repo] materialize start path=${repo.path} source=${getSourceUrl(repo.source)} workspace=${workspacePath}`
+        `[repo] materialize start path=${repo.path} source=${sourceUrl} workspace=${workspacePath}`
       );
     }
-    const cachePath = await this.ensureCache(
-      repo.source,
-      repo.clone?.depth,
-      repo.checkout?.resolve
-    );
     const cloneArgs = ["clone"];
     if (repo.clone?.depth) {
       cloneArgs.push("--depth", String(repo.clone.depth));
@@ -16116,7 +16084,7 @@ var RepoManager = class {
       cloneArgs.push("--filter", repo.clone.filter);
     }
     cloneArgs.push("--no-checkout");
-    const cloneUrl = repo.clone?.depth || repo.clone?.filter ? `file://${cachePath}` : cachePath;
+    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) {
@@ -16188,63 +16156,25 @@ var RepoManager = class {
     }
   }
   /** Reset repos in workspace to their checkout state. */
-  async reset(repos, workspacePath, strategy) {
-    if (strategy === "recreate") {
-      for (const repo of repos) {
-        const targetDir = import_node_path40.default.join(workspacePath, repo.path);
-        await (0, import_promises28.rm)(targetDir, { recursive: true, force: true });
-      }
-      await this.materializeAll(repos, workspacePath);
-      return;
-    }
+  async reset(repos, workspacePath, reset) {
+    const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
       const targetDir = import_node_path40.default.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
-      await this.runGit(["clean", "-fd"], { cwd: targetDir });
-    }
-  }
-  /**
-   * Seed the cache from a local repository, setting the remote to a given URL.
-   * Useful for avoiding slow network clones when a local clone already exists.
-   */
-  async seedCache(localPath, remoteUrl, opts) {
-    const source = { type: "git", url: remoteUrl };
-    const key = cacheKey(source);
-    const cachePath = import_node_path40.default.join(this.cacheDir, key);
-    const lockPath = `${cachePath}.lock`;
-    await (0, import_promises28.mkdir)(this.cacheDir, { recursive: true });
-    await acquireLock(lockPath);
-    try {
-      if ((0, import_node_fs12.existsSync)(import_node_path40.default.join(cachePath, "HEAD"))) {
-        if (!opts?.force) {
-          throw new Error(
-            `Cache already exists for ${remoteUrl} at ${cachePath}. Use force to overwrite.`
-          );
-        }
-        await (0, import_promises28.rm)(cachePath, { recursive: true, force: true });
-      }
-      await git2(["clone", "--mirror", "--bare", localPath, cachePath]);
-      await git2(["remote", "set-url", "origin", remoteUrl], { cwd: cachePath });
-    } finally {
-      await releaseLock(lockPath);
+      await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
-    return cachePath;
-  }
-  /** Remove the entire cache directory. */
-  async cleanCache() {
-    await (0, import_promises28.rm)(this.cacheDir, { recursive: true, force: true });
   }
 };
 
 // src/evaluation/workspace/resolve.ts
-var import_promises29 = require("fs/promises");
+var import_promises28 = require("fs/promises");
 var import_node_path41 = __toESM(require("path"), 1);
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
   const resolved = import_node_path41.default.resolve(templatePath);
-  const stats = await (0, import_promises29.stat)(resolved);
+  const stats = await (0, import_promises28.stat)(resolved);
   if (stats.isFile()) {
     return {
       dir: import_node_path41.default.dirname(resolved),
@@ -16254,7 +16184,7 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await (0, import_promises29.readdir)(resolved);
+  const entries = await (0, import_promises28.readdir)(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
@@ -16318,6 +16248,22 @@ function classifyQualityStatus(score) {
 function usesFileReferencePrompt(provider) {
   return isAgentProvider(provider) || provider.kind === "cli";
 }
+function toScriptConfig(hook, hookName, context2) {
+  const command = hook.command ?? hook.script;
+  if (!command || command.length === 0) {
+    throw new Error(`${hookName} hook in ${context2} requires command or script`);
+  }
+  return {
+    command,
+    ...hook.timeout_ms !== void 0 && { timeout_ms: hook.timeout_ms },
+    ...hook.timeoutMs !== void 0 && { timeoutMs: hook.timeoutMs },
+    ...hook.cwd !== void 0 && { cwd: hook.cwd },
+    ...hook.script !== void 0 && { script: hook.script }
+  };
+}
+function hasHookCommand(hook) {
+  return !!(hook?.command && hook.command.length > 0 || hook?.script && hook.script.length > 0);
+}
 function getWorkspaceTemplate(target) {
   const config = target.config;
   if ("workspaceTemplate" in config && typeof config.workspaceTemplate === "string") {
@@ -16351,7 +16297,12 @@ async function runEvaluation(options) {
     failOnError,
     poolWorkspaces,
     poolMaxSlots: configPoolMaxSlots,
-    workspace: userWorkspacePath
+    workspace: legacyWorkspacePath,
+    workspaceMode,
+    workspacePath,
+    workspaceClean,
+    retainOnSuccess,
+    retainOnFailure
   } = options;
   let useCache = options.useCache;
   if (trials && trials.count > 1 && useCache) {
@@ -16360,7 +16311,7 @@ async function runEvaluation(options) {
     );
     useCache = false;
   }
-  const evalRunId = (0, import_node_crypto10.randomUUID)();
+  const evalRunId = (0, import_node_crypto9.randomUUID)();
   const evalCases = preloadedEvalCases ?? await loadTests(evalFilePath, repoRoot, { verbose, filter });
   const filteredEvalCases = filterEvalCases(evalCases, filter);
   if (filteredEvalCases.length === 0) {
@@ -16487,13 +16438,22 @@ async function runEvaluation(options) {
     }
   };
   const isPerTestIsolation = suiteWorkspace?.isolation === "per_test";
-  if (userWorkspacePath && isPerTestIsolation) {
+  const configuredMode = suiteWorkspace?.mode ?? workspaceMode;
+  const configuredStaticPath = suiteWorkspace?.static_path ?? workspacePath ?? legacyWorkspacePath;
+  const useStaticWorkspace = configuredMode === "static" || !!configuredStaticPath && !configuredMode;
+  if (useStaticWorkspace && isPerTestIsolation) {
     throw new Error(
-      "--workspace is incompatible with isolation: per_test. Use isolation: shared (default)."
+      "static workspace mode is incompatible with isolation: per_test. Use isolation: shared (default)."
     );
   }
-  const hasSharedWorkspace = !!(userWorkspacePath || workspaceTemplate || suiteWorkspace?.before_all || suiteWorkspace?.repos?.length && !isPerTestIsolation);
-  const usePool = poolWorkspaces === true && !!suiteWorkspace?.repos?.length && !isPerTestIsolation && !userWorkspacePath;
+  if (configuredMode === "static" && !configuredStaticPath) {
+    throw new Error("workspace.mode=static requires workspace.static_path or --workspace-path");
+  }
+  const hasSharedWorkspace = !!(useStaticWorkspace || workspaceTemplate || suiteWorkspace?.hooks || suiteWorkspace?.repos?.length && !isPerTestIsolation);
+  const poolEnabled = configuredMode === "pooled" ? true : configuredMode === "ephemeral" || useStaticWorkspace ? false : suiteWorkspace?.pool ?? poolWorkspaces ?? true;
+  const usePool = poolEnabled !== false && !!suiteWorkspace?.repos?.length && !isPerTestIsolation && !useStaticWorkspace;
+  const resolvedRetainOnSuccess = retainOnSuccess ?? (keepWorkspaces ? "keep" : "cleanup");
+  const resolvedRetainOnFailure = retainOnFailure ?? (cleanupWorkspaces ? "cleanup" : "keep");
   const requestedWorkers = options.maxConcurrency ?? target.workers ?? 1;
   const workers = hasSharedWorkspace && !usePool ? 1 : requestedWorkers;
   setupLog(
@@ -16514,20 +16474,21 @@ async function runEvaluation(options) {
   const availablePoolSlots = [];
   const poolSlotBaselines = /* @__PURE__ */ new Map();
   const poolMaxSlots = Math.min(configPoolMaxSlots ?? 10, 50);
-  if (userWorkspacePath) {
-    sharedWorkspacePath = userWorkspacePath;
-    setupLog(`using user-provided workspace: ${userWorkspacePath}`);
+  if (useStaticWorkspace && configuredStaticPath) {
+    sharedWorkspacePath = configuredStaticPath;
+    setupLog(`using static workspace: ${configuredStaticPath}`);
   } else if (usePool && suiteWorkspace?.repos) {
     const slotsNeeded = workers;
     setupLog(`acquiring ${slotsNeeded} workspace pool slot(s) (pool capacity: ${poolMaxSlots})`);
     poolManager = new WorkspacePoolManager(getWorkspacePoolRoot());
-    const poolRepoManager = new RepoManager(void 0, verbose);
+    const poolRepoManager = new RepoManager(verbose);
     for (let i = 0; i < slotsNeeded; i++) {
       const slot = await poolManager.acquireWorkspace({
         templatePath: workspaceTemplate,
         repos: suiteWorkspace.repos,
         maxSlots: poolMaxSlots,
-        repoManager: poolRepoManager
+        repoManager: poolRepoManager,
+        poolReset: (workspaceClean === "full" ? "strict" : workspaceClean === "standard" ? "fast" : null) ?? "fast"
       });
       poolSlots.push(slot);
       setupLog(`pool slot ${i} acquired at: ${slot.path} (existing=${slot.isExisting})`);
@@ -16547,21 +16508,21 @@ async function runEvaluation(options) {
       const message = error instanceof Error ? error.message : String(error);
       throw new Error(`Failed to create shared workspace: ${message}`);
     }
-  } else if (suiteWorkspace?.before_all || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
+  } else if (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await (0, import_promises30.mkdir)(sharedWorkspacePath, { recursive: true });
+    await (0, import_promises29.mkdir)(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
       const copiedWorkspaceFile = import_node_path42.default.join(sharedWorkspacePath, import_node_path42.default.basename(suiteWorkspaceFile));
       try {
-        await (0, import_promises30.stat)(copiedWorkspaceFile);
+        await (0, import_promises29.stat)(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
     }
-    const repoManager = suiteWorkspace?.repos?.length && !usePool && !userWorkspacePath ? new RepoManager(void 0, verbose) : void 0;
+    const repoManager = suiteWorkspace?.repos?.length && !usePool && !useStaticWorkspace ? new RepoManager(verbose) : void 0;
     if (repoManager && sharedWorkspacePath && suiteWorkspace?.repos && !isPerTestIsolation) {
       setupLog(
         `materializing ${suiteWorkspace.repos.length} shared repo(s) into ${sharedWorkspacePath}`
@@ -16571,17 +16532,19 @@ async function runEvaluation(options) {
         setupLog("shared repo materialization complete");
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        if (sharedWorkspacePath && !userWorkspacePath) {
+        if (sharedWorkspacePath && !useStaticWorkspace) {
           await cleanupWorkspace(sharedWorkspacePath).catch(() => {
           });
         }
         throw new Error(`Failed to materialize repos: ${message}`);
       }
     }
-    if (sharedWorkspacePath && suiteWorkspace?.before_all) {
-      const beforeAllCommand = (suiteWorkspace.before_all.command ?? suiteWorkspace.before_all.script ?? []).join(" ");
+    const suiteBeforeAllHook = suiteWorkspace?.hooks?.before_all;
+    if (sharedWorkspacePath && hasHookCommand(suiteBeforeAllHook)) {
+      const beforeAllHook = suiteBeforeAllHook;
+      const beforeAllCommand = (beforeAllHook.command ?? beforeAllHook.script ?? []).join(" ");
       setupLog(
-        `running shared before_all in cwd=${suiteWorkspace.before_all.cwd ?? evalDir} command=${beforeAllCommand}`
+        `running shared before_all in cwd=${beforeAllHook.cwd ?? evalDir} command=${beforeAllCommand}`
       );
       const scriptContext = {
         workspacePath: sharedWorkspacePath,
@@ -16590,18 +16553,22 @@ async function runEvaluation(options) {
         evalDir
       };
       try {
-        beforeAllOutput = await executeWorkspaceScript(suiteWorkspace.before_all, scriptContext);
+        beforeAllOutput = await executeWorkspaceScript(
+          toScriptConfig(beforeAllHook, "before_all", "suite workspace"),
+          scriptContext
+        );
         setupLog("shared before_all completed");
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        if (sharedWorkspacePath && !userWorkspacePath) {
+        if (sharedWorkspacePath && !useStaticWorkspace) {
           await cleanupWorkspace(sharedWorkspacePath).catch(() => {
           });
         }
         throw new Error(`before_all script failed: ${message}`);
       }
     }
-    if (availablePoolSlots.length > 0 && suiteWorkspace?.before_all) {
+    if (availablePoolSlots.length > 0 && hasHookCommand(suiteBeforeAllHook)) {
+      const beforeAllHook = suiteBeforeAllHook;
       for (const slot of availablePoolSlots) {
         setupLog(`running before_all on pool slot ${slot.index}`);
         const scriptContext = {
@@ -16611,7 +16578,10 @@ async function runEvaluation(options) {
           evalDir
         };
         try {
-          const output = await executeWorkspaceScript(suiteWorkspace.before_all, scriptContext);
+          const output = await executeWorkspaceScript(
+            toScriptConfig(beforeAllHook, "before_all", "suite workspace"),
+            scriptContext
+          );
           if (!beforeAllOutput) beforeAllOutput = output;
           setupLog(`before_all completed on pool slot ${slot.index}`);
         } catch (error) {
@@ -16743,6 +16713,8 @@ async function runEvaluation(options) {
             evalRunId,
             keepWorkspaces,
             cleanupWorkspaces,
+            retainOnSuccess: resolvedRetainOnSuccess,
+            retainOnFailure: resolvedRetainOnFailure,
             sharedWorkspacePath: testWorkspacePath,
             sharedBaselineCommit: testBaselineCommit,
             suiteWorkspaceFile,
@@ -16836,7 +16808,9 @@ async function runEvaluation(options) {
       }
     }
     const afterAllWorkspaces = poolSlots.length > 1 ? poolSlots.map((s) => s.path) : sharedWorkspacePath ? [sharedWorkspacePath] : [];
-    if (afterAllWorkspaces.length > 0 && suiteWorkspace?.after_all) {
+    const suiteAfterAllHook = suiteWorkspace?.hooks?.after_all;
+    if (afterAllWorkspaces.length > 0 && hasHookCommand(suiteAfterAllHook)) {
+      const afterAllHook = suiteAfterAllHook;
       for (const wsPath of afterAllWorkspaces) {
         const scriptContext = {
           workspacePath: wsPath,
@@ -16846,7 +16820,7 @@ async function runEvaluation(options) {
         };
         try {
           const afterAllOutput = await executeWorkspaceScript(
-            suiteWorkspace.after_all,
+            toScriptConfig(afterAllHook, "after_all", "suite workspace"),
             scriptContext,
             "warn"
           );
@@ -16857,12 +16831,14 @@ async function runEvaluation(options) {
         }
       }
     }
-    if (sharedWorkspacePath && !poolSlot && poolSlots.length === 0 && !userWorkspacePath) {
+    if (sharedWorkspacePath && !poolSlot && poolSlots.length === 0 && !useStaticWorkspace) {
       const hasFailure = results.some((r) => !!r.error || r.score < 0.5);
-      if (cleanupWorkspaces) {
-        await cleanupWorkspace(sharedWorkspacePath).catch(() => {
-        });
-      } else if (!hasFailure && !keepWorkspaces) {
+      if (hasFailure) {
+        if (resolvedRetainOnFailure === "cleanup") {
+          await cleanupWorkspace(sharedWorkspacePath).catch(() => {
+          });
+        }
+      } else if (resolvedRetainOnSuccess === "cleanup") {
         await cleanupWorkspace(sharedWorkspacePath).catch(() => {
         });
       }
@@ -17056,6 +17032,8 @@ async function runEvalCase(options) {
     evalRunId,
     keepWorkspaces,
     cleanupWorkspaces: forceCleanup,
+    retainOnSuccess,
+    retainOnFailure,
     sharedWorkspacePath,
     sharedBaselineCommit,
     suiteWorkspaceFile,
@@ -17067,10 +17045,10 @@ async function runEvalCase(options) {
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
   const promptInputs = await buildPromptInputs(evalCase, formattingMode);
   const typeRegistry = providedTypeRegistry ?? createBuiltinRegistry();
-  const cacheKey2 = useCache ? createCacheKey(provider, target, evalCase, promptInputs) : void 0;
+  const cacheKey = useCache ? createCacheKey(provider, target, evalCase, promptInputs) : void 0;
   let cachedResponse;
-  if (cacheKey2 && cache) {
-    cachedResponse = await cache.get(cacheKey2);
+  if (cacheKey && cache) {
+    cachedResponse = await cache.get(cacheKey);
   }
   const nowFn = now ?? (() => /* @__PURE__ */ new Date());
   let workspacePath = sharedWorkspacePath;
@@ -17103,18 +17081,18 @@ async function runEvalCase(options) {
       if (caseWorkspaceFile && workspacePath) {
         const copiedFile = import_node_path42.default.join(workspacePath, import_node_path42.default.basename(caseWorkspaceFile));
         try {
-          await (0, import_promises30.stat)(copiedFile);
+          await (0, import_promises29.stat)(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
       }
     }
-    if (!workspacePath && (evalCase.workspace?.before_all || evalCase.workspace?.repos?.length) && evalRunId) {
+    if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await (0, import_promises30.mkdir)(workspacePath, { recursive: true });
+      await (0, import_promises29.mkdir)(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
-      const perCaseRepoManager = new RepoManager(void 0, setupDebug);
+      const perCaseRepoManager = new RepoManager(setupDebug);
       try {
         if (setupDebug) {
           console.log(
@@ -17139,11 +17117,13 @@ async function runEvalCase(options) {
         );
       }
     }
-    if (workspacePath && evalCase.workspace?.before_all) {
-      const beforeAllCommand = (evalCase.workspace.before_all.command ?? evalCase.workspace.before_all.script ?? []).join(" ");
+    const caseBeforeAllHook = evalCase.workspace?.hooks?.before_all;
+    if (workspacePath && hasHookCommand(caseBeforeAllHook)) {
+      const beforeAllHook = caseBeforeAllHook;
+      const beforeAllCommand = (beforeAllHook.command ?? beforeAllHook.script ?? []).join(" ");
       if (setupDebug) {
         console.log(
-          `[setup] test=${evalCase.id} running before_all in cwd=${evalCase.workspace.before_all.cwd ?? evalDir} command=${beforeAllCommand}`
+          `[setup] test=${evalCase.id} running before_all in cwd=${beforeAllHook.cwd ?? evalDir} command=${beforeAllCommand}`
         );
       }
       const scriptContext = {
@@ -17156,7 +17136,7 @@ async function runEvalCase(options) {
       };
       try {
         beforeAllOutput = await executeWorkspaceScript(
-          evalCase.workspace.before_all,
+          toScriptConfig(beforeAllHook, "before_all", `test '${evalCase.id}'`),
           scriptContext
         );
         if (setupDebug) {
@@ -17181,7 +17161,9 @@ async function runEvalCase(options) {
       }
     }
   }
-  if (workspacePath && evalCase.workspace?.before_each) {
+  const caseBeforeEachHook = evalCase.workspace?.hooks?.before_each;
+  if (workspacePath && hasHookCommand(caseBeforeEachHook)) {
+    const beforeEachHook = caseBeforeEachHook;
     const scriptContext = {
       workspacePath,
       testId: evalCase.id,
@@ -17192,7 +17174,7 @@ async function runEvalCase(options) {
     };
     try {
       beforeEachOutput = await executeWorkspaceScript(
-        evalCase.workspace.before_each,
+        toScriptConfig(beforeEachHook, "before_each", `test '${evalCase.id}'`),
         scriptContext
       );
     } catch (error) {
@@ -17280,8 +17262,8 @@ async function runEvalCase(options) {
     }
     return errorResult;
   }
-  if (cacheKey2 && cache && !cachedResponse) {
-    await cache.set(cacheKey2, providerResponse);
+  if (cacheKey && cache && !cachedResponse) {
+    await cache.set(cacheKey, providerResponse);
   }
   const output = providerResponse.output;
   const hasExecutionMetrics = providerResponse.tokenUsage !== void 0 || providerResponse.costUsd !== void 0 || providerResponse.durationMs !== void 0;
@@ -17309,17 +17291,19 @@ async function runEvalCase(options) {
     }
   }
   const providerError = extractProviderError(providerResponse);
-  if (repoManager && workspacePath && evalCase.workspace?.reset?.after_each && evalCase.workspace.reset.strategy && evalCase.workspace.reset.strategy !== "none" && evalCase.workspace.repos) {
+  if (repoManager && workspacePath && evalCase.workspace?.hooks?.after_each?.reset && evalCase.workspace.hooks.after_each.reset !== "none" && evalCase.workspace.repos) {
     try {
       await repoManager.reset(
         evalCase.workspace.repos,
         workspacePath,
-        evalCase.workspace.reset.strategy
+        evalCase.workspace.hooks.after_each.reset
       );
     } catch {
     }
   }
-  if (workspacePath && evalCase.workspace?.after_each) {
+  const caseAfterEachHook = evalCase.workspace?.hooks?.after_each;
+  if (workspacePath && hasHookCommand(caseAfterEachHook)) {
+    const afterEachHook = caseAfterEachHook;
     const scriptContext = {
       workspacePath,
       testId: evalCase.id,
@@ -17330,7 +17314,7 @@ async function runEvalCase(options) {
     };
     try {
       afterEachOutput = await executeWorkspaceScript(
-        evalCase.workspace.after_each,
+        toScriptConfig(afterEachHook, "after_each", `test '${evalCase.id}'`),
         scriptContext,
         "warn"
       );
@@ -17380,8 +17364,13 @@ async function runEvalCase(options) {
         await cleanupWorkspace(workspacePath).catch(() => {
         });
       } else if (isFailure) {
-        return { ...finalResult, workspacePath };
-      } else if (!keepWorkspaces) {
+        if ((retainOnFailure ?? "keep") === "cleanup") {
+          await cleanupWorkspace(workspacePath).catch(() => {
+          });
+        } else {
+          return { ...finalResult, workspacePath };
+        }
+      } else if ((retainOnSuccess ?? (keepWorkspaces ? "keep" : "cleanup")) !== "keep") {
         await cleanupWorkspace(workspacePath).catch(() => {
         });
       }
@@ -17399,11 +17388,12 @@ async function runEvalCase(options) {
       "evaluator_error"
     );
     if (workspacePath && !isSharedWorkspace) {
-      if (forceCleanup) {
+      if (forceCleanup || (retainOnFailure ?? "keep") === "cleanup") {
         await cleanupWorkspace(workspacePath).catch(() => {
         });
+      } else {
+        return { ...errorResult, workspacePath, beforeEachOutput, afterEachOutput };
       }
-      return { ...errorResult, workspacePath, beforeEachOutput, afterEachOutput };
     }
     return { ...errorResult, beforeEachOutput, afterEachOutput };
   }
@@ -17422,7 +17412,9 @@ async function runEvalCaseWithTrials(options, trialsConfig) {
       useCache: false,
       // Force cleanup for intermediate trials
       cleanupWorkspaces: isLastDeclaredTrial ? options.cleanupWorkspaces : true,
-      keepWorkspaces: isLastDeclaredTrial ? options.keepWorkspaces : false
+      keepWorkspaces: isLastDeclaredTrial ? options.keepWorkspaces : false,
+      retainOnSuccess: isLastDeclaredTrial ? options.retainOnSuccess : "cleanup",
+      retainOnFailure: isLastDeclaredTrial ? options.retainOnFailure : "cleanup"
     };
     const result = await runEvalCase(trialOptions);
     allResults.push(result);
@@ -17945,7 +17937,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = (0, import_node_crypto10.createHash)("sha256");
+  const hash = (0, import_node_crypto9.createHash)("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -18013,7 +18005,7 @@ function computeWeightedMean(entries) {
 }
 
 // src/evaluation/evaluate.ts
-var import_node_fs13 = require("fs");
+var import_node_fs12 = require("fs");
 var import_node_path43 = __toESM(require("path"), 1);
 async function evaluate(config) {
   const startTime = Date.now();
@@ -18132,7 +18124,7 @@ async function discoverDefaultTarget(repoRoot) {
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
       const targetsPath = import_node_path43.default.join(dir, candidate);
-      if (!(0, import_node_fs13.existsSync)(targetsPath)) continue;
+      if (!(0, import_node_fs12.existsSync)(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -18150,7 +18142,7 @@ async function loadEnvHierarchy(repoRoot) {
   const envFiles = [];
   for (const dir of chain) {
     const envPath = import_node_path43.default.join(dir, ".env");
-    if ((0, import_node_fs13.existsSync)(envPath)) envFiles.push(envPath);
+    if ((0, import_node_fs12.existsSync)(envPath)) envFiles.push(envPath);
   }
   for (let i = envFiles.length - 1; i >= 0; i--) {
     try {
@@ -18228,12 +18220,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync5 } = await import("fs");
+  const { existsSync: existsSync4 } = await import("fs");
   const { pathToFileURL } = await import("url");
   const { join: join2 } = await import("path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync5(filePath)) {
+    if (!existsSync4(filePath)) {
       continue;
     }
     try {
@@ -18330,7 +18322,7 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/cache/response-cache.ts
-var import_promises31 = require("fs/promises");
+var import_promises30 = require("fs/promises");
 var import_node_path44 = __toESM(require("path"), 1);
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -18341,7 +18333,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await (0, import_promises31.readFile)(filePath, "utf8");
+      const data = await (0, import_promises30.readFile)(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -18350,8 +18342,8 @@ var ResponseCache = class {
   async set(key, value) {
     const filePath = this.keyToPath(key);
     const dir = import_node_path44.default.dirname(filePath);
-    await (0, import_promises31.mkdir)(dir, { recursive: true });
-    await (0, import_promises31.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
+    await (0, import_promises30.mkdir)(dir, { recursive: true });
+    await (0, import_promises30.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
@@ -18890,7 +18882,6 @@ function createAgentKernel() {
   freeformEvaluationSchema,
   generateRubrics,
   getAgentvHome,
-  getGitCacheRoot,
   getHitCount,
   getSubagentsRoot,
   getTraceStateRoot,