@agentv/core 2.15.0 → 2.17.0

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   readTextFile,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-N55K52OO.js";
+} from "./chunk-CPPYERD2.js";
 import {
   OtlpJsonFileExporter
 } from "./chunk-HFSYZHGF.js";
@@ -3114,17 +3114,32 @@ 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") {
     const workspaceFilePath = path8.resolve(evalFileDir, raw);
@@ -3154,37 +3169,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) {
@@ -5304,6 +5330,7 @@ var CopilotCliProvider = class {
     const agentProcess = spawn(executable, args, {
       stdio: ["pipe", "pipe", "inherit"]
     });
+    await waitForProcessSpawn(agentProcess, executable, this.targetName);
     const toolCallsInProgress = /* @__PURE__ */ new Map();
     const completedToolCalls = [];
     let finalContent = "";
@@ -5583,6 +5610,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;
@@ -7238,9 +7306,6 @@ function getAgentvHome() {
 function getWorkspacesRoot() {
   return path21.join(getAgentvHome(), "workspaces");
 }
-function getGitCacheRoot() {
-  return path21.join(getAgentvHome(), "git-cache");
-}
 function getSubagentsRoot() {
   return path21.join(getAgentvHome(), "subagents");
 }
@@ -8700,16 +8765,16 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir15, readFile: readFile13, rm: rm7, writeFile: writeFile10 } = await import("node:fs/promises");
+  const { mkdir: mkdir14, readFile: readFile13, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
   const { tmpdir: tmpdir3 } = await import("node:os");
   const path42 = await import("node:path");
   const { randomUUID: randomUUID8 } = await import("node:crypto");
   const dir = path42.join(tmpdir3(), `agentv-exec-${randomUUID8()}`);
-  await mkdir15(dir, { recursive: true });
+  await mkdir14(dir, { recursive: true });
   const stdinPath = path42.join(dir, "stdin.txt");
   const stdoutPath = path42.join(dir, "stdout.txt");
   const stderrPath = path42.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("node:child_process");
   try {
@@ -8742,7 +8807,7 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
     const stderr = (await readFile13(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 });
   }
 }
 
@@ -11930,8 +11995,8 @@ function runEqualsAssertion(output, value) {
 }
 
 // src/evaluation/orchestrator.ts
-import { createHash as createHash3, randomUUID as randomUUID7 } from "node:crypto";
-import { mkdir as mkdir13, stat as stat7 } from "node:fs/promises";
+import { createHash as createHash2, randomUUID as randomUUID7 } from "node:crypto";
+import { mkdir as mkdir12, stat as stat7 } from "node:fs/promises";
 import path39 from "node:path";
 import micromatch4 from "micromatch";
 
@@ -12894,7 +12959,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 = path36.join(this.poolRoot, fingerprint);
     await mkdir11(poolDir, { recursive: true });
@@ -12914,7 +12979,7 @@ var WorkspacePoolManager = class {
       }
       const slotExists = existsSync2(slotPath);
       if (slotExists) {
-        await this.resetSlot(slotPath, templatePath, repos);
+        await this.resetSlot(slotPath, templatePath, repos, poolReset);
         return {
           index: i,
           path: slotPath,
@@ -13046,15 +13111,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 = path36.join(slotPath, repo.path);
       if (!existsSync2(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(
@@ -13070,14 +13139,10 @@ var WorkspacePoolManager = class {
 
 // src/evaluation/workspace/repo-manager.ts
 import { execFile as execFile2 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync3 } from "node:fs";
-import { mkdir as mkdir12, rm as rm6, unlink as unlink2, writeFile as writeFile8 } from "node:fs/promises";
 import path37 from "node:path";
 import { promisify as promisify6 } from "node:util";
 var execFileAsync2 = promisify6(execFile2);
 var DEFAULT_TIMEOUT_MS2 = 3e5;
-var LOCK_TIMEOUT_MS = 6e4;
 function gitEnv2() {
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
@@ -13092,10 +13157,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 createHash2("sha256").update(raw).digest("hex");
-}
 function getSourceUrl(source) {
   return source.type === "git" ? source.url : source.path;
 }
@@ -13109,33 +13170,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 writeFile8(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 unlink2(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) {
@@ -13160,86 +13197,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 = path37.join(this.cacheDir, key);
-    const lockPath = `${cachePath}.lock`;
-    const cacheExists = existsSync3(path37.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 mkdir12(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 = path37.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));
@@ -13248,7 +13217,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) {
@@ -13320,51 +13289,13 @@ 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 = path37.join(workspacePath, repo.path);
-        await rm6(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 = path37.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 = path37.join(this.cacheDir, key);
-    const lockPath = `${cachePath}.lock`;
-    await mkdir12(this.cacheDir, { recursive: true });
-    await acquireLock(lockPath);
-    try {
-      if (existsSync3(path37.join(cachePath, "HEAD"))) {
-        if (!opts?.force) {
-          throw new Error(
-            `Cache already exists for ${remoteUrl} at ${cachePath}. Use force to overwrite.`
-          );
-        }
-        await rm6(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 rm6(this.cacheDir, { recursive: true, force: true });
   }
 };
 
@@ -13450,6 +13381,22 @@ function classifyQualityStatus(score) {
 function usesFileReferencePrompt(provider) {
   return isAgentProvider(provider) || provider.kind === "cli";
 }
+function toScriptConfig(hook, hookName, context) {
+  const command = hook.command ?? hook.script;
+  if (!command || command.length === 0) {
+    throw new Error(`${hookName} hook in ${context} 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") {
@@ -13483,7 +13430,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) {
@@ -13619,13 +13571,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(
@@ -13646,20 +13607,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})`);
@@ -13679,9 +13641,9 @@ 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 mkdir13(sharedWorkspacePath, { recursive: true });
+    await mkdir12(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
@@ -13693,7 +13655,7 @@ async function runEvaluation(options) {
       } 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}`
@@ -13703,17 +13665,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,
@@ -13722,18 +13686,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 = {
@@ -13743,7 +13711,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) {
@@ -13875,6 +13846,8 @@ async function runEvaluation(options) {
             evalRunId,
             keepWorkspaces,
             cleanupWorkspaces,
+            retainOnSuccess: resolvedRetainOnSuccess,
+            retainOnFailure: resolvedRetainOnFailure,
             sharedWorkspacePath: testWorkspacePath,
             sharedBaselineCommit: testBaselineCommit,
             suiteWorkspaceFile,
@@ -13968,7 +13941,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,
@@ -13978,7 +13953,7 @@ async function runEvaluation(options) {
         };
         try {
           const afterAllOutput = await executeWorkspaceScript(
-            suiteWorkspace.after_all,
+            toScriptConfig(afterAllHook, "after_all", "suite workspace"),
             scriptContext,
             "warn"
           );
@@ -13989,12 +13964,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(() => {
         });
       }
@@ -14188,6 +14165,8 @@ async function runEvalCase(options) {
     evalRunId,
     keepWorkspaces,
     cleanupWorkspaces: forceCleanup,
+    retainOnSuccess,
+    retainOnFailure,
     sharedWorkspacePath,
     sharedBaselineCommit,
     suiteWorkspaceFile,
@@ -14199,10 +14178,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;
@@ -14241,12 +14220,12 @@ async function runEvalCase(options) {
         }
       }
     }
-    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 mkdir13(workspacePath, { recursive: true });
+      await mkdir12(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(
@@ -14271,11 +14250,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 = {
@@ -14288,7 +14269,7 @@ async function runEvalCase(options) {
       };
       try {
         beforeAllOutput = await executeWorkspaceScript(
-          evalCase.workspace.before_all,
+          toScriptConfig(beforeAllHook, "before_all", `test '${evalCase.id}'`),
           scriptContext
         );
         if (setupDebug) {
@@ -14313,7 +14294,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,
@@ -14324,7 +14307,7 @@ async function runEvalCase(options) {
     };
     try {
       beforeEachOutput = await executeWorkspaceScript(
-        evalCase.workspace.before_each,
+        toScriptConfig(beforeEachHook, "before_each", `test '${evalCase.id}'`),
         scriptContext
       );
     } catch (error) {
@@ -14412,8 +14395,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;
@@ -14441,17 +14424,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,
@@ -14462,7 +14447,7 @@ async function runEvalCase(options) {
     };
     try {
       afterEachOutput = await executeWorkspaceScript(
-        evalCase.workspace.after_each,
+        toScriptConfig(afterEachHook, "after_each", `test '${evalCase.id}'`),
         scriptContext,
         "warn"
       );
@@ -14512,8 +14497,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(() => {
         });
       }
@@ -14531,11 +14521,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 };
   }
@@ -14554,7 +14545,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);
@@ -15077,7 +15070,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = createHash3("sha256");
+  const hash = createHash2("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -15145,7 +15138,7 @@ function computeWeightedMean(entries) {
 }
 
 // src/evaluation/evaluate.ts
-import { existsSync as existsSync4 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import path40 from "node:path";
 async function evaluate(config) {
   const startTime = Date.now();
@@ -15264,7 +15257,7 @@ async function discoverDefaultTarget(repoRoot) {
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
       const targetsPath = path40.join(dir, candidate);
-      if (!existsSync4(targetsPath)) continue;
+      if (!existsSync3(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -15282,7 +15275,7 @@ async function loadEnvHierarchy(repoRoot) {
   const envFiles = [];
   for (const dir of chain) {
     const envPath = path40.join(dir, ".env");
-    if (existsSync4(envPath)) envFiles.push(envPath);
+    if (existsSync3(envPath)) envFiles.push(envPath);
   }
   for (let i = envFiles.length - 1; i >= 0; i--) {
     try {
@@ -15360,12 +15353,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync5 } = await import("node:fs");
+  const { existsSync: existsSync4 } = await import("node:fs");
   const { pathToFileURL } = await import("node:url");
   const { join: join2 } = await import("node:path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync5(filePath)) {
+    if (!existsSync4(filePath)) {
       continue;
     }
     try {
@@ -15462,7 +15455,7 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/cache/response-cache.ts
-import { mkdir as mkdir14, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile12, writeFile as writeFile8 } from "node:fs/promises";
 import path41 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -15482,8 +15475,8 @@ var ResponseCache = class {
   async set(key, value) {
     const filePath = this.keyToPath(key);
     const dir = path41.dirname(filePath);
-    await mkdir14(dir, { recursive: true });
-    await writeFile9(filePath, JSON.stringify(value, null, 2), "utf8");
+    await mkdir13(dir, { recursive: true });
+    await writeFile8(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
@@ -16017,7 +16010,6 @@ export {
   freeformEvaluationSchema,
   generateRubrics,
   getAgentvHome,
-  getGitCacheRoot,
   getHitCount,
   getSubagentsRoot,
   getTraceStateRoot,