@agentv/core 2.14.2 → 2.15.0

package/dist/index.cjs

@@ -1244,12 +1244,12 @@ function serializeAttributeValue(value) {
   if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
   return { stringValue: String(value) };
 }
-var import_promises31, import_node_path43, OtlpJsonFileExporter;
+var import_promises32, import_node_path45, OtlpJsonFileExporter;
 var init_otlp_json_file_exporter = __esm({
   "src/observability/otlp-json-file-exporter.ts"() {
     "use strict";
-    import_promises31 = require("fs/promises");
-    import_node_path43 = require("path");
+    import_promises32 = require("fs/promises");
+    import_node_path45 = require("path");
     OtlpJsonFileExporter = class {
       // biome-ignore lint/suspicious/noExplicitAny: serialized span data
       spans = [];
@@ -1288,7 +1288,7 @@ var init_otlp_json_file_exporter = __esm({
       }
       async flush() {
         if (this.spans.length === 0) return;
-        await (0, import_promises31.mkdir)((0, import_node_path43.dirname)(this.filePath), { recursive: true });
+        await (0, import_promises32.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: writeFile9 } = await import("fs/promises");
-        await writeFile9(this.filePath, JSON.stringify(otlpJson, null, 2));
+        const { writeFile: writeFile10 } = await import("fs/promises");
+        await writeFile10(this.filePath, JSON.stringify(otlpJson, null, 2));
       }
     };
   }
@@ -1319,13 +1319,13 @@ function hrTimeDiffMs(start, end) {
   const diffNano = end[1] - start[1];
   return Math.round(diffSec * 1e3 + diffNano / 1e6);
 }
-var import_node_fs13, import_promises32, import_node_path44, SimpleTraceFileExporter;
+var import_node_fs14, import_promises33, import_node_path46, SimpleTraceFileExporter;
 var init_simple_trace_file_exporter = __esm({
   "src/observability/simple-trace-file-exporter.ts"() {
     "use strict";
-    import_node_fs13 = require("fs");
-    import_promises32 = require("fs/promises");
-    import_node_path44 = require("path");
+    import_node_fs14 = require("fs");
+    import_promises33 = require("fs/promises");
+    import_node_path46 = require("path");
     SimpleTraceFileExporter = class {
       stream = null;
       filePath;
@@ -1338,8 +1338,8 @@ var init_simple_trace_file_exporter = __esm({
       async ensureStream() {
         if (!this.streamReady) {
           this.streamReady = (async () => {
-            await (0, import_promises32.mkdir)((0, import_node_path44.dirname)(this.filePath), { recursive: true });
-            this.stream = (0, import_node_fs13.createWriteStream)(this.filePath, { flags: "w" });
+            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" });
             return this.stream;
           })();
         }
@@ -1457,6 +1457,7 @@ __export(index_exports, {
   TokenUsageEvaluator: () => TokenUsageEvaluator,
   ToolTrajectoryEvaluator: () => ToolTrajectoryEvaluator,
   WorkspaceCreationError: () => WorkspaceCreationError,
+  WorkspacePoolManager: () => WorkspacePoolManager,
   assembleLlmJudgePrompt: () => assembleLlmJudgePrompt,
   avgToolDurationMs: () => avgToolDurationMs,
   buildDirectoryChain: () => buildDirectoryChain2,
@@ -1471,6 +1472,7 @@ __export(index_exports, {
   cleanupEvalWorkspaces: () => cleanupEvalWorkspaces,
   cleanupWorkspace: () => cleanupWorkspace,
   computeTraceSummary: () => computeTraceSummary,
+  computeWorkspaceFingerprint: () => computeWorkspaceFingerprint,
   consumeClaudeLogEntries: () => consumeClaudeLogEntries,
   consumeCodexLogEntries: () => consumeCodexLogEntries,
   consumeCopilotCliLogEntries: () => consumeCopilotCliLogEntries,
@@ -1502,8 +1504,14 @@ __export(index_exports, {
   findGitRoot: () => findGitRoot,
   freeformEvaluationSchema: () => freeformEvaluationSchema,
   generateRubrics: () => generateRubrics,
+  getAgentvHome: () => getAgentvHome,
+  getGitCacheRoot: () => getGitCacheRoot,
   getHitCount: () => getHitCount,
+  getSubagentsRoot: () => getSubagentsRoot,
+  getTraceStateRoot: () => getTraceStateRoot,
   getWorkspacePath: () => getWorkspacePath,
+  getWorkspacePoolRoot: () => getWorkspacePoolRoot,
+  getWorkspacesRoot: () => getWorkspacesRoot,
   initializeBaseline: () => initializeBaseline,
   isEvaluatorKind: () => isEvaluatorKind,
   isGuidelineFile: () => isGuidelineFile,
@@ -1853,7 +1861,7 @@ async function resolveFileReference(ref, evalFileDir) {
   const rawPath = extractFilePath(ref);
   const absolutePattern = import_node_path.default.resolve(evalFileDir, rawPath);
   if (isGlobPattern(rawPath)) {
-    const matches = await (0, import_fast_glob.default)(absolutePattern, {
+    const matches = await (0, import_fast_glob.default)(absolutePattern.replaceAll("\\", "/"), {
       onlyFiles: true,
       absolute: true
     });
@@ -2231,6 +2239,17 @@ function parseExecutionDefaults(raw, configPath) {
   } else if (otelFile !== void 0) {
     logWarning(`Invalid execution.otel_file in ${configPath}, expected non-empty string`);
   }
+  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`);
+  }
+  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`);
+  }
   return Object.keys(result).length > 0 ? result : void 0;
 }
 function logWarning(message) {
@@ -3672,6 +3691,7 @@ async function processMessages(options) {
     repoRootPath,
     guidelinePatterns,
     guidelinePaths,
+    treatFileSegmentsAsGuidelines,
     textParts,
     messageType,
     verbose
@@ -3719,16 +3739,20 @@ async function processMessages(options) {
         }
         try {
           const fileContent = (await (0, import_promises5.readFile)(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
-          if (messageType === "input" && guidelinePatterns && guidelinePaths) {
-            const relativeToRepo = import_node_path5.default.relative(repoRootPath, resolvedPath);
-            if (isGuidelineFile(relativeToRepo, guidelinePatterns)) {
-              guidelinePaths.push(import_node_path5.default.resolve(resolvedPath));
-              if (verbose) {
-                console.log(`  [Guideline] Found: ${displayPath}`);
-                console.log(`    Resolved to: ${resolvedPath}`);
-              }
-              continue;
+          const classifyAsGuideline = shouldTreatAsGuideline({
+            messageType,
+            resolvedPath,
+            repoRootPath,
+            guidelinePatterns,
+            treatFileSegmentsAsGuidelines
+          });
+          if (classifyAsGuideline && guidelinePaths) {
+            guidelinePaths.push(import_node_path5.default.resolve(resolvedPath));
+            if (verbose) {
+              console.log(`  [Guideline] Found: ${displayPath}`);
+              console.log(`    Resolved to: ${resolvedPath}`);
             }
+            continue;
           }
           segments.push({
             type: "file",
@@ -3757,6 +3781,26 @@ async function processMessages(options) {
   }
   return segments;
 }
+function shouldTreatAsGuideline(options) {
+  const {
+    messageType,
+    resolvedPath,
+    repoRootPath,
+    guidelinePatterns,
+    treatFileSegmentsAsGuidelines
+  } = options;
+  if (messageType !== "input") {
+    return false;
+  }
+  if (treatFileSegmentsAsGuidelines) {
+    return true;
+  }
+  if (!guidelinePatterns || guidelinePatterns.length === 0) {
+    return false;
+  }
+  const relativeToRepo = import_node_path5.default.relative(repoRootPath, resolvedPath);
+  return isGuidelineFile(relativeToRepo, guidelinePatterns);
+}
 function asString3(value) {
   return typeof value === "string" ? value : void 0;
 }
@@ -4095,6 +4139,8 @@ async function loadTestsFromJsonl(evalFilePath, repoRoot, options) {
         for (const guidelinePath of testCase.guideline_paths) {
           console.log(`    - ${guidelinePath}`);
         }
+      } else if (!guidelinePatterns || guidelinePatterns.length === 0) {
+        console.log("  No guidelines found (guideline_patterns not configured)");
       } else {
         console.log("  No guidelines found");
       }
@@ -4464,7 +4510,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
   } else {
     throw new Error(`Invalid test file format: ${evalFilePath} - missing 'tests' field`);
   }
-  const suiteWorkspace = parseWorkspaceConfig(suite.workspace, evalFileDir);
+  const suiteWorkspace = await resolveWorkspaceConfig(suite.workspace, evalFileDir);
   const suiteInputMessages = expandInputShorthand(suite.input);
   const rawGlobalExecution = isJsonObject(suite.execution) ? suite.execution : void 0;
   const _globalTarget = asString6(rawGlobalExecution?.target) ?? asString6(suite.target);
@@ -4500,12 +4546,24 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     }
     const caseExecution = isJsonObject(evalcase.execution) ? evalcase.execution : void 0;
     const skipDefaults = caseExecution?.skip_defaults === true;
-    const inputMessages = suiteInputMessages && !skipDefaults ? [...suiteInputMessages, ...testInputMessages] : testInputMessages;
+    const effectiveSuiteInputMessages = suiteInputMessages && !skipDefaults ? suiteInputMessages : void 0;
+    const inputMessages = effectiveSuiteInputMessages ? [...effectiveSuiteInputMessages, ...testInputMessages] : testInputMessages;
     const hasExpectedMessages = expectedMessages.length > 0;
     const guidelinePaths = [];
     const inputTextParts = [];
-    const inputSegments = await processMessages({
-      messages: inputMessages,
+    const suiteInputSegments = effectiveSuiteInputMessages ? await processMessages({
+      messages: effectiveSuiteInputMessages,
+      searchRoots,
+      repoRootPath,
+      guidelinePatterns,
+      guidelinePaths,
+      treatFileSegmentsAsGuidelines: true,
+      textParts: inputTextParts,
+      messageType: "input",
+      verbose
+    }) : [];
+    const testInputSegments = await processMessages({
+      messages: testInputMessages,
       searchRoots,
       repoRootPath,
       guidelinePatterns,
@@ -4514,6 +4572,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       messageType: "input",
       verbose
     });
+    const inputSegments = [...suiteInputSegments, ...testInputSegments];
     const outputSegments = hasExpectedMessages ? await processExpectedMessages({
       messages: expectedMessages,
       searchRoots,
@@ -4561,7 +4620,7 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       ...guidelinePaths.map((guidelinePath) => import_node_path8.default.resolve(guidelinePath)),
       ...userFilePaths
     ];
-    const caseWorkspace = parseWorkspaceConfig(evalcase.workspace, evalFileDir);
+    const caseWorkspace = await resolveWorkspaceConfig(evalcase.workspace, evalFileDir);
     const mergedWorkspace = mergeWorkspaceConfigs(suiteWorkspace, caseWorkspace);
     const metadata = isJsonObject(evalcase.metadata) ? evalcase.metadata : void 0;
     const caseTargets = extractTargetsFromTestCase(evalcase);
@@ -4592,6 +4651,8 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
         for (const guidelinePath of testCase.guideline_paths) {
           console.log(`    - ${guidelinePath}`);
         }
+      } else if (!guidelinePatterns || guidelinePatterns.length === 0) {
+        console.log("  No guidelines found (guideline_patterns not configured)");
       } else {
         console.log("  No guidelines found");
       }
@@ -4691,6 +4752,26 @@ function parseResetConfig(raw) {
     ...afterEach !== void 0 && { after_each: afterEach }
   };
 }
+async function resolveWorkspaceConfig(raw, evalFileDir) {
+  if (typeof raw === "string") {
+    const workspaceFilePath = import_node_path8.default.resolve(evalFileDir, raw);
+    let content;
+    try {
+      content = await (0, import_promises8.readFile)(workspaceFilePath, "utf8");
+    } catch {
+      throw new Error(`Workspace file not found: ${raw} (resolved to ${workspaceFilePath})`);
+    }
+    const parsed = (0, import_yaml4.parse)(content);
+    if (!isJsonObject(parsed)) {
+      throw new Error(
+        `Invalid workspace file format: ${workspaceFilePath} (expected a YAML object)`
+      );
+    }
+    const workspaceFileDir = import_node_path8.default.dirname(workspaceFilePath);
+    return parseWorkspaceConfig(parsed, workspaceFileDir);
+  }
+  return parseWorkspaceConfig(raw, evalFileDir);
+}
 function parseWorkspaceConfig(raw, evalFileDir) {
   if (!isJsonObject(raw)) return void 0;
   const obj = raw;
@@ -6784,7 +6865,7 @@ var import_node_path14 = __toESM(require("path"), 1);
 var import_node_url2 = require("url");
 var import_meta = {};
 function resolvePlatformCliPath() {
-  const os5 = (0, import_node_os2.platform)();
+  const os3 = (0, import_node_os2.platform)();
   const cpu = (0, import_node_os2.arch)();
   const platformMap = {
     linux: "linux",
@@ -6795,13 +6876,13 @@ function resolvePlatformCliPath() {
     x64: "x64",
     arm64: "arm64"
   };
-  const osPart = platformMap[os5];
+  const osPart = platformMap[os3];
   const archPart = archMap[cpu];
   if (!osPart || !archPart) {
     return void 0;
   }
   const packageName = `@github/copilot-${osPart}-${archPart}`;
-  const binaryName = os5 === "win32" ? "copilot.exe" : "copilot";
+  const binaryName = os3 === "win32" ? "copilot.exe" : "copilot";
   try {
     const resolved = import_meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? (0, import_node_url2.fileURLToPath)(resolved) : resolved;
@@ -9488,8 +9569,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path42 = firstError?.path.join(".") || "";
-    const prefix = path42 ? `${target.name} ${path42}: ` : `${target.name}: `;
+    const path44 = firstError?.path.join(".") || "";
+    const prefix = path44 ? `${target.name} ${path44}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -9699,12 +9780,12 @@ function resolveOptionalNumberArray(source, description) {
 // src/evaluation/providers/vscode-provider.ts
 var import_node_child_process5 = require("child_process");
 var import_promises22 = require("fs/promises");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_node_path30 = __toESM(require("path"), 1);
 var import_node_util3 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
 var import_promises20 = require("fs/promises");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
 var import_node_fs7 = require("fs");
@@ -9972,17 +10053,49 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 var import_node_child_process4 = require("child_process");
 var import_promises18 = require("fs/promises");
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 var import_node_util2 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
+var import_node_path24 = __toESM(require("path"), 1);
+
+// src/paths.ts
 var import_node_os4 = __toESM(require("os"), 1);
 var import_node_path23 = __toESM(require("path"), 1);
+var logged = false;
+function getAgentvHome() {
+  const envHome = process.env.AGENTV_HOME;
+  if (envHome) {
+    if (!logged) {
+      logged = true;
+      console.warn(`Using AGENTV_HOME: ${envHome}`);
+    }
+    return envHome;
+  }
+  return import_node_path23.default.join(import_node_os4.default.homedir(), ".agentv");
+}
+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");
+}
+function getTraceStateRoot() {
+  return import_node_path23.default.join(getAgentvHome(), "trace-state");
+}
+function getWorkspacePoolRoot() {
+  return import_node_path23.default.join(getAgentvHome(), "workspace-pool");
+}
+
+// src/evaluation/providers/vscode/dispatch/constants.ts
 var DEFAULT_LOCK_NAME = "subagent.lock";
 var DEFAULT_ALIVE_FILENAME = ".alive";
 function getDefaultSubagentRoot(vscodeCmd = "code") {
   const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
-  return import_node_path23.default.join(import_node_os4.default.homedir(), ".agentv", "subagents", folder);
+  return import_node_path24.default.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
@@ -9996,12 +10109,19 @@ description: 'Wake-up Signal'
 model: Grok Code Fast 1 (copilot)
 ---`;
 function spawnVsCode(vscodeCmd, args, options) {
-  const child = (0, import_node_child_process4.spawn)(vscodeCmd, args, {
+  const useShell = options?.shell ?? true;
+  const command = useShell ? shellQuote(vscodeCmd) : vscodeCmd;
+  const child = (0, import_node_child_process4.spawn)(command, args, {
     windowsHide: true,
-    shell: options?.shell ?? true,
+    shell: useShell,
     detached: false
   });
-  child.on("error", () => {
+  child.on("error", (error) => {
+    const label = options?.label ?? "spawn";
+    const renderedArgs = args.map((value) => JSON.stringify(value)).join(" ");
+    console.error(
+      `[vscode] ${label} failed: command=${JSON.stringify(vscodeCmd)} args=${renderedArgs} error=${error.message}`
+    );
   });
   return child;
 }
@@ -10038,16 +10158,20 @@ async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
 async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir, vscodeCmd, pollInterval = 1, timeout = 60) {
   const alreadyOpen = await checkWorkspaceOpened(workspaceName, vscodeCmd);
   if (alreadyOpen) {
-    spawnVsCode(shellQuote(vscodeCmd), [workspacePath]);
+    const child = spawnVsCode(vscodeCmd, [workspacePath], { label: "focus-existing-workspace" });
+    await raceSpawnError(child);
     return true;
   }
-  const aliveFile = import_node_path24.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = import_node_path25.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = import_node_path24.default.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = import_node_path25.default.join(subagentDir, ".github", "agents");
   await (0, import_promises18.mkdir)(githubAgentsDir, { recursive: true });
-  const wakeupDst = import_node_path24.default.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = import_node_path25.default.join(githubAgentsDir, "wakeup.md");
   await (0, import_promises18.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
-  spawnVsCode(shellQuote(vscodeCmd), [workspacePath]);
+  const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
+    label: "open-workspace"
+  });
+  await raceSpawnError(workspaceChild);
   await sleep2(100);
   const wakeupChatId = "wakeup";
   const chatArgs = [
@@ -10055,9 +10179,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${import_node_path24.default.basename(subagentDir)} folder`
+    `create a file named .alive in the ${import_node_path25.default.basename(subagentDir)} folder`
   ];
-  spawnVsCode(shellQuote(vscodeCmd), chatArgs);
+  const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
+  await raceSpawnError(wakeupChild);
   const start = Date.now();
   while (!await pathExists(aliveFile)) {
     if (Date.now() - start > timeout * 1e3) {
@@ -10069,10 +10194,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = import_node_path24.default.join(subagentDir, `${import_node_path24.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path24.default.join(subagentDir, "messages");
+  const workspacePath = import_node_path25.default.join(subagentDir, `${import_node_path25.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path25.default.join(subagentDir, "messages");
   await (0, import_promises18.mkdir)(messagesDir, { recursive: true });
-  const reqFile = import_node_path24.default.join(messagesDir, `${timestamp}_req.md`);
+  const reqFile = import_node_path25.default.join(messagesDir, `${timestamp}_req.md`);
   await (0, import_promises18.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
@@ -10080,25 +10205,25 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${import_node_path24.default.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${import_node_path25.default.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path24.default.basename(subagentDir),
+    import_node_path25.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path24.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path25.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
-  const child = spawnVsCode(shellQuote(vscodeCmd), chatArgs);
+  const child = spawnVsCode(vscodeCmd, chatArgs, { label: "send-chat" });
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = import_node_path24.default.join(subagentDir, `${import_node_path24.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path24.default.join(subagentDir, "messages");
+  const workspacePath = import_node_path25.default.join(subagentDir, `${import_node_path25.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path25.default.join(subagentDir, "messages");
   await (0, import_promises18.mkdir)(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -10107,26 +10232,26 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path24.default.basename(subagentDir),
+    import_node_path25.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path24.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path25.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
-  const child = spawnVsCode(shellQuote(vscodeCmd), chatArgs);
+  const child = spawnVsCode(vscodeCmd, chatArgs, { label: "send-batch-chat" });
   await raceSpawnError(child);
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
 var import_promises19 = require("fs/promises");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/workspace.ts
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_json5 = __toESM(require("json5"), 1);
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -10143,10 +10268,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (import_node_path25.default.isAbsolute(folderPath)) {
+    if (import_node_path26.default.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = import_node_path25.default.resolve(templateDir, folderPath);
+    const absolutePath = import_node_path26.default.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -10168,19 +10293,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = import_node_path25.default.isAbsolute(locationPath);
+          const isAbsolute = import_node_path26.default.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = import_node_path25.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = import_node_path26.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             } else {
               const basePathEnd = locationPath.lastIndexOf("/", firstGlobIndex);
               const basePath = basePathEnd !== -1 ? locationPath.substring(0, basePathEnd) : ".";
               const patternPath = locationPath.substring(basePathEnd !== -1 ? basePathEnd : 0);
-              const resolvedPath = (import_node_path25.default.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (import_node_path26.default.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -10221,7 +10346,7 @@ async function findUnlockedSubagent(subagentRoot) {
     number: Number.parseInt(entry.name.split("-")[1] ?? "", 10)
   })).filter((entry) => Number.isInteger(entry.number)).sort((a, b) => a.number - b.number);
   for (const subagent of subagents) {
-    const lockFile = import_node_path26.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = import_node_path27.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -10231,7 +10356,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = import_node_path26.default.resolve(workspaceTemplate);
+    const workspaceSrc = import_node_path27.default.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -10244,13 +10369,13 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${import_node_path26.default.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = import_node_path26.default.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? import_node_path26.default.dirname(import_node_path26.default.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${import_node_path27.default.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = import_node_path27.default.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? import_node_path27.default.dirname(import_node_path27.default.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = import_node_path26.default.resolve(cwd);
+    const absCwd = import_node_path27.default.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -10259,35 +10384,35 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     }
   }
   await (0, import_promises19.writeFile)(workspaceDst, transformedContent, "utf8");
-  const messagesDir = import_node_path26.default.join(subagentDir, "messages");
+  const messagesDir = import_node_path27.default.join(subagentDir, "messages");
   await (0, import_promises19.mkdir)(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = import_node_path26.default.join(subagentDir, "messages");
+  const messagesDir = import_node_path27.default.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await (0, import_promises19.readdir)(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = import_node_path26.default.join(messagesDir, file);
+        const target = import_node_path27.default.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = import_node_path26.default.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = import_node_path27.default.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
     const agentFiles = await (0, import_promises19.readdir)(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path26.default.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path27.default.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = import_node_path26.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = import_node_path27.default.join(subagentDir, DEFAULT_LOCK_NAME);
   await (0, import_promises19.writeFile)(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = import_node_path26.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = import_node_path27.default.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -10307,9 +10432,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = import_node_path26.default.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = import_node_path27.default.join(subagentDir, ".github", "agents");
     await (0, import_promises19.mkdir)(githubAgentsDir, { recursive: true });
-    const agentFile = import_node_path26.default.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = import_node_path27.default.join(githubAgentsDir, `${chatId}.md`);
     try {
       await (0, import_promises19.copyFile)(promptFile, agentFile);
     } catch (error) {
@@ -10328,7 +10453,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = import_node_path27.default.resolve(promptFile);
+  const resolvedPrompt = import_node_path28.default.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -10344,7 +10469,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = import_node_path27.default.resolve(attachment);
+    const resolvedPath = import_node_path28.default.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -10386,7 +10511,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = import_node_path27.default.basename(subagentDir);
+    const subagentName = import_node_path28.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -10414,9 +10539,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path27.default.join(subagentDir, "messages");
-    const responseFileTmp = import_node_path27.default.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = import_node_path27.default.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = import_node_path28.default.join(subagentDir, "messages");
+    const responseFileTmp = import_node_path28.default.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = import_node_path28.default.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -10521,7 +10646,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = import_node_path27.default.basename(subagentDir);
+    subagentName = import_node_path28.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -10552,17 +10677,17 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path27.default.join(subagentDir, "messages");
+    const messagesDir = import_node_path28.default.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => import_node_path27.default.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => import_node_path28.default.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => import_node_path27.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => import_node_path28.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => import_node_path27.default.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => import_node_path28.default.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = import_node_path27.default.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = import_node_path28.default.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
@@ -10648,7 +10773,7 @@ async function dispatchBatchAgent(options) {
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
 var import_promises21 = require("fs/promises");
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -10679,7 +10804,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = import_node_path28.default.resolve(targetRoot);
+  const targetPath = import_node_path29.default.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -10699,7 +10824,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = import_node_path28.default.join(entry.absolutePath, lockName);
+      const lockFile = import_node_path29.default.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -10716,10 +10841,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = import_node_path28.default.join(subagentDir, ".github", "agents");
-    const lockFile = import_node_path28.default.join(subagentDir, lockName);
-    const workspaceDst = import_node_path28.default.join(subagentDir, `${import_node_path28.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path28.default.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = import_node_path29.default.join(subagentDir, ".github", "agents");
+    const lockFile = import_node_path29.default.join(subagentDir, lockName);
+    const workspaceDst = import_node_path29.default.join(subagentDir, `${import_node_path29.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path29.default.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -10757,10 +10882,10 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = import_node_path28.default.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = import_node_path28.default.join(subagentDir, ".github", "agents");
-    const workspaceDst = import_node_path28.default.join(subagentDir, `${import_node_path28.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path28.default.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = import_node_path29.default.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = import_node_path29.default.join(subagentDir, ".github", "agents");
+    const workspaceDst = import_node_path29.default.join(subagentDir, `${import_node_path29.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path29.default.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -10786,8 +10911,6 @@ var AGENTV_REQUEST_TEMPLATE = `[[ ## task ## ]]
 
 **IMPORTANT**: Follow these exact steps:
 1. Create and write your complete response to: {{responseFileTmp}}
-    - All intended file outputs/changes MUST be written in your response file.
-    - For each intended file, include the repo name, relative path and unified git diff following the convention \`diff --git ...\`.
 2. When completely finished, run these PowerShell commands to signal completion:
 \`\`\`
 Move-Item -LiteralPath '{{responseFileTmp}}' -Destination '{{responseFileFinal}}'
@@ -10804,8 +10927,6 @@ var AGENTV_BATCH_REQUEST_TEMPLATE = `[[ ## task ## ]]
 
 **IMPORTANT**: Follow these exact steps:
 1. Create and write your complete response to: {{responseFileTmp}}
-    - All intended file outputs/changes MUST be written in your response file.
-    - For each intended file, include the repo name, relative path and unified git diff following the convention \`diff --git ...\`.
 2. When completely finished and the response is stable, rename it to: {{responseFileFinal}}
 3. Do not unlock the workspace from this request; batch orchestration will handle unlocking after all responses are ready.
 `;
@@ -10954,7 +11075,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = import_node_path29.default.isAbsolute(candidate) ? candidate : import_node_path29.default.resolve(candidate);
+    const resolved = import_node_path30.default.isAbsolute(candidate) ? candidate : import_node_path30.default.resolve(candidate);
     try {
       await (0, import_promises22.access)(resolved, import_promises22.constants.F_OK);
       return resolved;
@@ -10983,7 +11104,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await (0, import_promises22.stat)(import_node_path29.default.resolve(template));
+    const stats = await (0, import_promises22.stat)(import_node_path30.default.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -11009,7 +11130,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path29.default.basename(absolutePath);
+    const fileName = import_node_path30.default.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -11034,8 +11155,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path29.default.resolve(attachment);
-    const normalized = absolutePath.split(import_node_path29.default.sep).join("/");
+    const absolutePath = import_node_path30.default.resolve(attachment);
+    const normalized = absolutePath.split(import_node_path30.default.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -11050,7 +11171,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path29.default.resolve(attachment);
+    const absolutePath = import_node_path30.default.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -11058,7 +11179,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = import_node_path29.default.isAbsolute(filePath) ? filePath : import_node_path29.default.resolve(filePath);
+  const absolutePath = import_node_path30.default.isAbsolute(filePath) ? filePath : import_node_path30.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -11071,7 +11192,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(import_node_path29.default.resolve(attachment));
+    deduped.add(import_node_path30.default.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -11080,7 +11201,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(import_node_path29.default.resolve(inputFile));
+      deduped.add(import_node_path30.default.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -11129,7 +11250,7 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 // src/evaluation/providers/targets-file.ts
 var import_node_fs8 = require("fs");
 var import_promises23 = require("fs/promises");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 var import_yaml5 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -11166,7 +11287,7 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = import_node_path30.default.resolve(filePath);
+  const absolutePath = import_node_path31.default.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
@@ -11186,16 +11307,16 @@ function listTargetNames(definitions) {
 }
 
 // src/evaluation/providers/provider-discovery.ts
-var import_node_path31 = __toESM(require("path"), 1);
+var import_node_path32 = __toESM(require("path"), 1);
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path31.default.resolve(baseDir);
-  const root = import_node_path31.default.parse(dir).root;
+  let dir = import_node_path32.default.resolve(baseDir);
+  const root = import_node_path32.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path31.default.join(dir, ".agentv", "providers"));
-    dir = import_node_path31.default.dirname(dir);
+    candidateDirs.push(import_node_path32.default.join(dir, ".agentv", "providers"));
+    dir = import_node_path32.default.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -11211,7 +11332,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = import_node_path31.default.basename(filePath);
+    const basename = import_node_path32.default.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -11318,7 +11439,7 @@ function negateScore(score) {
 // src/evaluation/evaluators/code-evaluator.ts
 var import_promises24 = require("fs/promises");
 var import_node_os5 = require("os");
-var import_node_path32 = require("path");
+var import_node_path33 = require("path");
 
 // src/runtime/exec.ts
 function shellEscapePath(value) {
@@ -11418,16 +11539,16 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: readFile13, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
+  const { mkdir: mkdir17, readFile: readFile14, rm: rm7, writeFile: writeFile10 } = await import("fs/promises");
   const { tmpdir: tmpdir3 } = await import("os");
-  const path42 = await import("path");
+  const path44 = await import("path");
   const { randomUUID: randomUUID8 } = await import("crypto");
-  const dir = path42.join(tmpdir3(), `agentv-exec-${randomUUID8()}`);
-  await mkdir16(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 writeFile9(stdinPath, stdinPayload, "utf8");
+  const dir = path44.join(tmpdir3(), `agentv-exec-${randomUUID8()}`);
+  await mkdir17(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");
   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 {
@@ -11456,11 +11577,11 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile13(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile13(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile14(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile14(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
-    await rm6(dir, { recursive: true, force: true });
+    await rm7(dir, { recursive: true, force: true });
   }
 }
 
@@ -11762,8 +11883,8 @@ var CodeEvaluator = class {
     if (outputForPayload) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
-        const tmpDir = await (0, import_promises24.mkdtemp)((0, import_node_path32.join)((0, import_node_os5.tmpdir)(), "agentv-judge-"));
-        outputPath = (0, import_node_path32.join)(tmpDir, "output.json");
+        const tmpDir = await (0, import_promises24.mkdtemp)((0, import_node_path33.join)((0, import_node_os5.tmpdir)(), "agentv-judge-"));
+        outputPath = (0, import_node_path33.join)(tmpDir, "output.json");
         await (0, import_promises24.writeFile)(outputPath, serialized);
         outputForPayload = null;
       }
@@ -11778,7 +11899,7 @@ var CodeEvaluator = class {
       outputPath,
       guidelineFiles: context2.evalCase.guideline_paths,
       inputFiles: context2.evalCase.file_paths.filter(
-        (path42) => !context2.evalCase.guideline_paths.includes(path42)
+        (path44) => !context2.evalCase.guideline_paths.includes(path44)
       ),
       input: context2.evalCase.input,
       trace: context2.trace ?? null,
@@ -11876,7 +11997,7 @@ var CodeEvaluator = class {
         await proxyShutdown();
       }
       if (outputPath) {
-        await (0, import_promises24.rm)((0, import_node_path32.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
+        await (0, import_promises24.rm)((0, import_node_path33.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -12057,6 +12178,8 @@ ${context2.fileChanges}`;
       };
     } catch (e) {
       const message = e instanceof Error ? e.message : String(e);
+      const evalName = context2.evaluator?.name ?? "llm-judge";
+      console.warn(`\u26A0 LLM judge "${evalName}" failed after 3 attempts (${message}) \u2014 skipped`);
       return {
         score: 0,
         verdict: "skip",
@@ -12085,24 +12208,39 @@ ${context2.fileChanges}`;
       systemPrompt,
       target: judgeProvider.targetName
     };
-    const { data, tokenUsage } = await this.runWithRetry({
-      context: context2,
-      judgeProvider,
-      systemPrompt,
-      userPrompt: prompt,
-      schema: rubricEvaluationSchema
-    });
-    const { score, verdict, hits, misses } = calculateRubricScore(data, rubrics);
-    return {
-      score,
-      verdict,
-      hits,
-      misses,
-      expectedAspectCount: rubrics.length,
-      reasoning: data.overall_reasoning,
-      evaluatorRawRequest,
-      tokenUsage
-    };
+    try {
+      const { data, tokenUsage } = await this.runWithRetry({
+        context: context2,
+        judgeProvider,
+        systemPrompt,
+        userPrompt: prompt,
+        schema: rubricEvaluationSchema
+      });
+      const { score, verdict, hits, misses } = calculateRubricScore(data, rubrics);
+      return {
+        score,
+        verdict,
+        hits,
+        misses,
+        expectedAspectCount: rubrics.length,
+        reasoning: data.overall_reasoning,
+        evaluatorRawRequest,
+        tokenUsage
+      };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      const evalName = context2.evaluator?.name ?? "llm-judge";
+      console.warn(`\u26A0 LLM judge "${evalName}" failed after 3 attempts (${message}) \u2014 skipped`);
+      return {
+        score: 0,
+        verdict: "skip",
+        hits: [],
+        misses: [`Judge parse failure after 3 attempts: ${message}`],
+        expectedAspectCount: rubrics.length,
+        reasoning: `Judge parse failure after 3 attempts: ${message}`,
+        evaluatorRawRequest
+      };
+    }
   }
   /**
    * Evaluate using score-range rubrics (analytic rubric scoring).
@@ -12116,25 +12254,40 @@ ${context2.fileChanges}`;
       systemPrompt,
       target: judgeProvider.targetName
     };
-    const { data, tokenUsage } = await this.runWithRetry({
-      context: context2,
-      judgeProvider,
-      systemPrompt,
-      userPrompt: prompt,
-      schema: scoreRangeEvaluationSchema
-    });
-    const { score, verdict, hits, misses, details } = calculateScoreRangeResult(data, rubrics);
-    return {
-      score,
-      verdict,
-      hits,
-      misses,
-      expectedAspectCount: rubrics.length,
-      reasoning: data.overall_reasoning,
-      evaluatorRawRequest,
-      details,
-      tokenUsage
-    };
+    try {
+      const { data, tokenUsage } = await this.runWithRetry({
+        context: context2,
+        judgeProvider,
+        systemPrompt,
+        userPrompt: prompt,
+        schema: scoreRangeEvaluationSchema
+      });
+      const { score, verdict, hits, misses, details } = calculateScoreRangeResult(data, rubrics);
+      return {
+        score,
+        verdict,
+        hits,
+        misses,
+        expectedAspectCount: rubrics.length,
+        reasoning: data.overall_reasoning,
+        evaluatorRawRequest,
+        details,
+        tokenUsage
+      };
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      const evalName = context2.evaluator?.name ?? "llm-judge";
+      console.warn(`\u26A0 LLM judge "${evalName}" failed after 3 attempts (${message}) \u2014 skipped`);
+      return {
+        score: 0,
+        verdict: "skip",
+        hits: [],
+        misses: [`Judge parse failure after 3 attempts: ${message}`],
+        expectedAspectCount: rubrics.length,
+        reasoning: `Judge parse failure after 3 attempts: ${message}`,
+        evaluatorRawRequest
+      };
+    }
   }
   /**
    * Build prompt for score-range rubric evaluation.
@@ -12420,19 +12573,13 @@ var CompositeEvaluator = class {
   runWeightedAverage(results, weights) {
     let totalWeight = 0;
     let weightedSum = 0;
+    let evaluatedCount = 0;
     const allHits = [];
     const allMisses = [];
     const reasoningParts = [];
     const scores = [];
     for (const member of results) {
       const weight = weights?.[member.id] ?? 1;
-      totalWeight += weight;
-      weightedSum += member.result.score * weight;
-      allHits.push(...member.result.hits.map((h) => `[${member.id}] ${h}`));
-      allMisses.push(...member.result.misses.map((m) => `[${member.id}] ${m}`));
-      if (member.result.reasoning) {
-        reasoningParts.push(`${member.id}: ${member.result.reasoning}`);
-      }
       scores.push({
         name: member.id,
         type: member.type,
@@ -12447,6 +12594,32 @@ var CompositeEvaluator = class {
         details: member.result.details,
         tokenUsage: member.result.tokenUsage
       });
+      if (member.result.verdict === "skip") {
+        continue;
+      }
+      evaluatedCount++;
+      totalWeight += weight;
+      weightedSum += member.result.score * weight;
+      allHits.push(...member.result.hits.map((h) => `[${member.id}] ${h}`));
+      allMisses.push(...member.result.misses.map((m) => `[${member.id}] ${m}`));
+      if (member.result.reasoning) {
+        reasoningParts.push(`${member.id}: ${member.result.reasoning}`);
+      }
+    }
+    if (evaluatedCount === 0 && results.length > 0) {
+      return {
+        score: 0,
+        verdict: "skip",
+        hits: [],
+        misses: [],
+        expectedAspectCount: 1,
+        reasoning: "All evaluators skipped (infrastructure failure)",
+        evaluatorRawRequest: {
+          aggregator: "weighted_average",
+          ...weights ? { weights } : {}
+        },
+        scores
+      };
     }
     const finalScore = totalWeight > 0 ? weightedSum / totalWeight : 0;
     return {
@@ -12470,19 +12643,8 @@ var CompositeEvaluator = class {
     const reasoningParts = [];
     let passingCount = 0;
     let borderlineCount = 0;
+    let evaluatedCount = 0;
     for (const member of results) {
-      const isPassing = member.result.verdict === "pass" || member.result.verdict === "borderline";
-      if (isPassing) {
-        passingCount++;
-        if (member.result.verdict === "borderline") {
-          borderlineCount++;
-        }
-      }
-      allHits.push(...member.result.hits.map((h) => `[${member.id}] ${h}`));
-      allMisses.push(...member.result.misses.map((m) => `[${member.id}] ${m}`));
-      if (member.result.reasoning) {
-        reasoningParts.push(`${member.id}: ${member.result.reasoning}`);
-      }
       scores.push({
         name: member.id,
         type: member.type,
@@ -12496,8 +12658,39 @@ var CompositeEvaluator = class {
         details: member.result.details,
         tokenUsage: member.result.tokenUsage
       });
+      if (member.result.verdict === "skip") {
+        continue;
+      }
+      evaluatedCount++;
+      const isPassing = member.result.verdict === "pass" || member.result.verdict === "borderline";
+      if (isPassing) {
+        passingCount++;
+        if (member.result.verdict === "borderline") {
+          borderlineCount++;
+        }
+      }
+      allHits.push(...member.result.hits.map((h) => `[${member.id}] ${h}`));
+      allMisses.push(...member.result.misses.map((m) => `[${member.id}] ${m}`));
+      if (member.result.reasoning) {
+        reasoningParts.push(`${member.id}: ${member.result.reasoning}`);
+      }
     }
-    const totalCount = results.length;
+    if (evaluatedCount === 0 && results.length > 0) {
+      return {
+        score: 0,
+        verdict: "skip",
+        hits: [],
+        misses: [],
+        expectedAspectCount: 1,
+        reasoning: "All evaluators skipped (infrastructure failure)",
+        evaluatorRawRequest: {
+          aggregator: "threshold",
+          threshold
+        },
+        scores
+      };
+    }
+    const totalCount = evaluatedCount;
     const score = totalCount > 0 ? passingCount / totalCount : 0;
     const pass = score >= threshold;
     if (pass && borderlineCount > 0) {
@@ -13005,115 +13198,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path42, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path42);
-    const expectedValue = resolvePath(expectedData, path42);
+    const { path: path44, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path44);
+    const expectedValue = resolvePath(expectedData, path44);
     if (expectedValue === void 0) {
       return {
-        path: path42,
+        path: path44,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path42}: no expected value`
+        message: `${path44}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path42,
+          path: path44,
           score: 0,
           weight,
           hit: false,
-          message: `${path42} (required, missing)`
+          message: `${path44} (required, missing)`
         };
       }
       return {
-        path: path42,
+        path: path44,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path42}: optional field missing`
+        message: `${path44}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path42, candidateValue, expectedValue, weight);
+        return this.compareExact(path44, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path42,
+          path44,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path42, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path44, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path42,
+          path: path44,
           score: 0,
           weight,
           hit: false,
-          message: `${path42}: unknown match type "${match}"`
+          message: `${path44}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path42, candidateValue, expectedValue, weight) {
+  compareExact(path44, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path42,
+        path: path44,
         score: 1,
         weight,
         hit: true,
-        message: path42
+        message: path44
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path42,
+        path: path44,
         score: 0,
         weight,
         hit: false,
-        message: `${path42} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path44} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path42,
+      path: path44,
       score: 0,
       weight,
       hit: false,
-      message: `${path42} (value mismatch)`
+      message: `${path44} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path42, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path44, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber2(candidateValue);
     const expectedNum = toNumber2(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path42,
+        path: path44,
         score: 0,
         weight,
         hit: false,
-        message: `${path42} (non-numeric value)`
+        message: `${path44} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path42,
+        path: path44,
         score: 0,
         weight,
         hit: false,
-        message: `${path42} (invalid numeric value)`
+        message: `${path44} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -13126,61 +13319,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path42,
+        path: path44,
         score: 1,
         weight,
         hit: true,
-        message: `${path42} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path44} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path42,
+      path: path44,
       score: 0,
       weight,
       hit: false,
-      message: `${path42} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path44} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path42, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path44, 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: path42,
+        path: path44,
         score: 0,
         weight,
         hit: false,
-        message: `${path42} (unparseable candidate date)`
+        message: `${path44} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path42,
+        path: path44,
         score: 0,
         weight,
         hit: false,
-        message: `${path42} (unparseable expected date)`
+        message: `${path44} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path42,
+        path: path44,
         score: 1,
         weight,
         hit: true,
-        message: path42
+        message: path44
       };
     }
     return {
-      path: path42,
+      path: path44,
       score: 0,
       weight,
       hit: false,
-      message: `${path42} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path44} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -13221,11 +13414,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path42) {
-  if (!path42 || !obj) {
+function resolvePath(obj, path44) {
+  if (!path44 || !obj) {
     return void 0;
   }
-  const parts = path42.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path44.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -13357,7 +13550,7 @@ var LatencyEvaluator = class {
 
 // src/evaluation/evaluators/agent-judge.ts
 var import_promises25 = __toESM(require("fs/promises"), 1);
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_path34 = __toESM(require("path"), 1);
 var import_ai4 = require("ai");
 var import_zod5 = require("zod");
 var DEFAULT_MAX_STEPS = 10;
@@ -13706,8 +13899,8 @@ ${outputSchema}`;
   }
 };
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = import_node_path33.default.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + import_node_path33.default.sep) && resolved !== basePath) {
+  const resolved = import_node_path34.default.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + import_node_path34.default.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -13790,11 +13983,11 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = import_node_path33.default.join(dirPath, entry.name);
+    const fullPath = import_node_path34.default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = import_node_path33.default.extname(entry.name).toLowerCase();
+      const ext = import_node_path34.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
         const stat8 = await import_promises25.default.stat(fullPath);
@@ -13806,7 +13999,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: import_node_path33.default.relative(workspacePath, fullPath),
+              file: import_node_path34.default.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -14043,8 +14236,8 @@ var TokenUsageEvaluator = class {
 };
 
 // src/evaluation/evaluators/tool-trajectory.ts
-function getNestedValue(obj, path42) {
-  const parts = path42.split(".");
+function getNestedValue(obj, path44) {
+  const parts = path44.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -14605,9 +14798,9 @@ function runEqualsAssertion(output, value) {
 }
 
 // src/evaluation/orchestrator.ts
-var import_node_crypto9 = require("crypto");
-var import_promises29 = require("fs/promises");
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_crypto10 = require("crypto");
+var import_promises30 = require("fs/promises");
+var import_node_path42 = __toESM(require("path"), 1);
 var import_micromatch4 = __toESM(require("micromatch"), 1);
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -14798,7 +14991,7 @@ var DeterministicAssertionEvaluator = class {
 var import_node_fs9 = require("fs");
 
 // src/evaluation/evaluators/prompt-resolution.ts
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_path35 = __toESM(require("path"), 1);
 async function resolveCustomPrompt(promptConfig, context2, timeoutMs) {
   if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
     if (!context2) {
@@ -14847,7 +15040,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = import_node_path34.default.dirname(scriptPath);
+  const cwd = import_node_path35.default.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -15140,16 +15333,16 @@ function createBuiltinRegistry() {
 }
 
 // src/evaluation/registry/assertion-discovery.ts
-var import_node_path35 = __toESM(require("path"), 1);
+var import_node_path36 = __toESM(require("path"), 1);
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path35.default.resolve(baseDir);
-  const root = import_node_path35.default.parse(dir).root;
+  let dir = import_node_path36.default.resolve(baseDir);
+  const root = import_node_path36.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path35.default.join(dir, ".agentv", "assertions"));
-    dir = import_node_path35.default.dirname(dir);
+    candidateDirs.push(import_node_path36.default.join(dir, ".agentv", "assertions"));
+    dir = import_node_path36.default.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -15165,7 +15358,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path35.default.basename(filePath);
+    const basename = import_node_path36.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -15325,7 +15518,7 @@ function getTCritical(df) {
 // src/evaluation/workspace/file-changes.ts
 var import_node_child_process6 = require("child_process");
 var import_node_fs10 = require("fs");
-var import_node_path36 = __toESM(require("path"), 1);
+var import_node_path37 = __toESM(require("path"), 1);
 var import_node_util4 = require("util");
 var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process6.exec);
 function gitExecOpts(workspacePath) {
@@ -15359,10 +15552,10 @@ async function stageNestedRepoChanges(workspacePath) {
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = import_node_path36.default.join(workspacePath, entry);
+    const childPath = import_node_path37.default.join(workspacePath, entry);
     try {
       if (!(0, import_node_fs10.statSync)(childPath).isDirectory()) continue;
-      if (!(0, import_node_fs10.statSync)(import_node_path36.default.join(childPath, ".git")).isDirectory()) continue;
+      if (!(0, import_node_fs10.statSync)(import_node_path37.default.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -15373,9 +15566,7 @@ async function stageNestedRepoChanges(workspacePath) {
 
 // src/evaluation/workspace/manager.ts
 var import_promises26 = require("fs/promises");
-var import_node_os6 = __toESM(require("os"), 1);
-var import_node_path37 = __toESM(require("path"), 1);
-var DEFAULT_WORKSPACE_ROOT = import_node_path37.default.join(import_node_os6.default.homedir(), ".agentv", "workspaces");
+var import_node_path38 = __toESM(require("path"), 1);
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
     super(`Workspace template not found: ${templatePath}`);
@@ -15404,15 +15595,15 @@ async function isDirectory(filePath) {
   }
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
-  const root = workspaceRoot ?? DEFAULT_WORKSPACE_ROOT;
-  return import_node_path37.default.join(root, evalRunId, caseId);
+  const root = workspaceRoot ?? getWorkspacesRoot();
+  return import_node_path38.default.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
   await (0, import_promises26.mkdir)(dest, { recursive: true });
   const entries = await (0, import_promises26.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_node_path37.default.join(src, entry.name);
-    const destPath = import_node_path37.default.join(dest, entry.name);
+    const srcPath = import_node_path38.default.join(src, entry.name);
+    const destPath = import_node_path38.default.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -15424,7 +15615,7 @@ async function copyDirectoryRecursive(src, dest) {
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = import_node_path37.default.resolve(templatePath);
+  const resolvedTemplatePath = import_node_path38.default.resolve(templatePath);
   if (!await fileExists2(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -15472,25 +15663,21 @@ async function cleanupWorkspace(workspacePath) {
   }
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
-  const root = workspaceRoot ?? DEFAULT_WORKSPACE_ROOT;
-  const evalDir = import_node_path37.default.join(root, evalRunId);
+  const root = workspaceRoot ?? getWorkspacesRoot();
+  const evalDir = import_node_path38.default.join(root, evalRunId);
   if (await fileExists2(evalDir)) {
     await (0, import_promises26.rm)(evalDir, { recursive: true, force: true });
   }
 }
 
-// src/evaluation/workspace/repo-manager.ts
+// src/evaluation/workspace/pool-manager.ts
 var import_node_child_process7 = require("child_process");
 var import_node_crypto8 = require("crypto");
 var import_node_fs11 = require("fs");
 var import_promises27 = require("fs/promises");
-var import_node_os7 = __toESM(require("os"), 1);
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path39 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
 var execFileAsync = (0, import_node_util5.promisify)(import_node_child_process7.execFile);
-var DEFAULT_CACHE_DIR = import_node_path38.default.join(import_node_os7.default.homedir(), ".agentv", "git-cache");
-var DEFAULT_TIMEOUT_MS2 = 3e5;
-var LOCK_TIMEOUT_MS = 6e4;
 function gitEnv() {
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
@@ -15505,49 +15692,340 @@ function gitEnv() {
     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_crypto8.createHash)("sha256").update(raw).digest("hex");
-}
-function getSourceUrl(source) {
-  return source.type === "git" ? source.url : source.path;
-}
 async function git(args, opts) {
   const { stdout } = await execFileAsync("git", args, {
     cwd: opts?.cwd,
-    timeout: opts?.timeout ?? DEFAULT_TIMEOUT_MS2,
+    timeout: opts?.timeout ?? 3e5,
     env: gitEnv(),
     maxBuffer: 50 * 1024 * 1024
-    // 50MB
   });
   return stdout.trim();
 }
-async function acquireLock(lockPath) {
-  const start = Date.now();
-  while (Date.now() - start < LOCK_TIMEOUT_MS) {
-    try {
-      await (0, import_promises27.writeFile)(lockPath, String(process.pid), { flag: "wx" });
-      return;
-    } catch (err) {
-      if (err.code === "EEXIST") {
-        await new Promise((r) => setTimeout(r, 200));
+function normalizeRepoForFingerprint(repo) {
+  const source = repo.source.type === "git" ? { type: "git", url: repo.source.url.toLowerCase().replace(/\.git$/, "") } : { type: "local", path: repo.source.path };
+  const result = {
+    path: repo.path,
+    source,
+    ref: repo.checkout?.ref ?? "HEAD"
+  };
+  if (repo.clone?.depth !== void 0) {
+    result.depth = repo.clone.depth;
+  }
+  if (repo.clone?.filter !== void 0) {
+    result.filter = repo.clone.filter;
+  }
+  if (repo.clone?.sparse?.length) {
+    result.sparse = [...repo.clone.sparse].sort();
+  }
+  return result;
+}
+function computeWorkspaceFingerprint(templatePath, repos) {
+  const canonical = {
+    templatePath: templatePath ?? null,
+    repos: [...repos].sort((a, b) => a.path.localeCompare(b.path)).map(normalizeRepoForFingerprint)
+  };
+  return (0, import_node_crypto8.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+async function copyDirectoryRecursive2(src, dest, skipDirs) {
+  await (0, import_promises27.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises27.readdir)(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = import_node_path39.default.join(src, entry.name);
+    const destPath = import_node_path39.default.join(dest, entry.name);
+    if (entry.name === ".git") {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      if (skipDirs?.has(entry.name)) {
         continue;
       }
-      throw err;
+      await copyDirectoryRecursive2(srcPath, destPath, skipDirs);
+    } else {
+      await (0, import_promises27.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
     }
   }
-  throw new Error(`Timed out waiting for lock: ${lockPath}`);
 }
-async function releaseLock(lockPath) {
+var WorkspacePoolManager = class {
+  poolRoot;
+  constructor(poolRoot) {
+    this.poolRoot = poolRoot ?? getWorkspacePoolRoot();
+  }
+  /**
+   * Acquire a workspace slot from the pool.
+   *
+   * 1. Compute fingerprint from template + repos
+   * 2. Check drift (compare stored metadata.json fingerprint vs computed)
+   * 3. If drift: warn, remove all slots, rematerialize
+   * 4. Acquire a slot (try-lock slot-0, slot-1, ..., up to maxSlots)
+   * 5. If slot exists: reset repos, re-copy template files (skip repo directories)
+   * 6. If new slot: copy template, materialize all repos, write metadata.json
+   * 7. Return the slot (with path, index, isExisting)
+   */
+  async acquireWorkspace(options) {
+    const { templatePath, repos, maxSlots, repoManager } = options;
+    const fingerprint = computeWorkspaceFingerprint(templatePath, repos);
+    const poolDir = import_node_path39.default.join(this.poolRoot, fingerprint);
+    await (0, import_promises27.mkdir)(poolDir, { recursive: true });
+    const drifted = await this.checkDrift(poolDir, fingerprint);
+    if (drifted) {
+      console.warn(
+        `[workspace-pool] Drift detected for fingerprint ${fingerprint.slice(0, 12)}... Removing stale slots.`
+      );
+      await this.removeAllSlots(poolDir);
+    }
+    for (let i = 0; i < maxSlots; i++) {
+      const slotPath = import_node_path39.default.join(poolDir, `slot-${i}`);
+      const lockPath = `${slotPath}.lock`;
+      const locked = await this.tryLock(lockPath);
+      if (!locked) {
+        continue;
+      }
+      const slotExists = (0, import_node_fs11.existsSync)(slotPath);
+      if (slotExists) {
+        await this.resetSlot(slotPath, templatePath, repos);
+        return {
+          index: i,
+          path: slotPath,
+          isExisting: true,
+          lockPath,
+          fingerprint,
+          poolDir
+        };
+      }
+      await (0, import_promises27.mkdir)(slotPath, { recursive: true });
+      if (templatePath) {
+        await copyDirectoryRecursive2(templatePath, slotPath);
+      }
+      if (repos.length > 0) {
+        await repoManager.materializeAll(repos, slotPath);
+      }
+      await this.writeMetadata(poolDir, fingerprint, templatePath ?? null, repos);
+      return {
+        index: i,
+        path: slotPath,
+        isExisting: false,
+        lockPath,
+        fingerprint,
+        poolDir
+      };
+    }
+    throw new Error(
+      `All ${maxSlots} pool slots are locked for fingerprint ${fingerprint.slice(0, 12)}...`
+    );
+  }
+  /** Remove lock file to release a slot. */
+  async releaseSlot(slot) {
+    try {
+      await (0, import_promises27.unlink)(slot.lockPath);
+    } catch {
+    }
+  }
+  /**
+   * Try to acquire a PID-based lock file.
+   * On EEXIST, read PID and check if process is alive. If dead, stale lock — remove and retry.
+   * Returns true if lock acquired, false if slot is actively locked.
+   * Uses a bounded loop (max 3 attempts) to avoid unbounded recursion.
+   */
+  async tryLock(lockPath) {
+    for (let attempt = 0; attempt < 3; attempt++) {
+      try {
+        await (0, import_promises27.writeFile)(lockPath, String(process.pid), { flag: "wx" });
+        return true;
+      } catch (err) {
+        if (err.code !== "EEXIST") {
+          throw err;
+        }
+        try {
+          const pidStr = await (0, import_promises27.readFile)(lockPath, "utf-8");
+          const pid = Number.parseInt(pidStr.trim(), 10);
+          if (!Number.isNaN(pid)) {
+            try {
+              process.kill(pid, 0);
+              return false;
+            } catch {
+              await (0, import_promises27.unlink)(lockPath).catch(() => {
+              });
+              continue;
+            }
+          }
+        } catch {
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if the stored fingerprint in metadata.json differs from the computed one.
+   * Returns true if drifted, false otherwise.
+   * Returns false (no drift) if metadata.json doesn't exist (first use).
+   */
+  async checkDrift(poolDir, fingerprint) {
+    const metadataPath = import_node_path39.default.join(poolDir, "metadata.json");
+    try {
+      const raw = await (0, import_promises27.readFile)(metadataPath, "utf-8");
+      const metadata = JSON.parse(raw);
+      return metadata.fingerprint !== fingerprint;
+    } catch {
+      return false;
+    }
+  }
+  /** Write metadata.json with fingerprint, inputs, and timestamp. */
+  async writeMetadata(poolDir, fingerprint, templatePath, repos) {
+    const metadata = {
+      fingerprint,
+      templatePath,
+      repos,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await (0, import_promises27.writeFile)(import_node_path39.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+  }
+  /** Remove all slot directories and their lock files from a pool directory. */
+  async removeAllSlots(poolDir) {
+    const entries = await (0, import_promises27.readdir)(poolDir);
+    for (const entry of entries) {
+      if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
+        const lockPath = import_node_path39.default.join(poolDir, `${entry}.lock`);
+        if ((0, import_node_fs11.existsSync)(lockPath)) {
+          try {
+            const pidStr = await (0, import_promises27.readFile)(lockPath, "utf-8");
+            const pid = Number.parseInt(pidStr.trim(), 10);
+            if (!Number.isNaN(pid)) {
+              try {
+                process.kill(pid, 0);
+                console.warn(`[workspace-pool] Skipping slot ${entry}: locked by PID ${pid}`);
+                continue;
+              } catch {
+              }
+            }
+          } catch {
+          }
+        }
+        await (0, import_promises27.rm)(import_node_path39.default.join(poolDir, entry), { recursive: true, force: true });
+        await (0, import_promises27.rm)(lockPath, { force: true }).catch(() => {
+        });
+      }
+    }
+    await (0, import_promises27.rm)(import_node_path39.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    });
+  }
+  /**
+   * Reset an existing slot for reuse:
+   * 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) {
+    for (const repo of repos) {
+      const repoDir = import_node_path39.default.join(slotPath, repo.path);
+      if (!(0, import_node_fs11.existsSync)(repoDir)) {
+        continue;
+      }
+      const ref = repo.checkout?.ref ?? "HEAD";
+      await git(["reset", "--hard", ref], { cwd: repoDir });
+      await git(["clean", "-fd"], { cwd: repoDir });
+    }
+    if (templatePath) {
+      const repoDirNames = new Set(
+        repos.map((r) => {
+          const normalized = r.path.replace(/^\.\//, "");
+          return normalized.split("/")[0];
+        })
+      );
+      await copyDirectoryRecursive2(templatePath, slotPath, repoDirNames);
+    }
+  }
+};
+
+// 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)) {
+    if (key.startsWith("GIT_") && key !== "GIT_SSH_COMMAND") {
+      delete env[key];
+    }
+  }
+  return {
+    ...env,
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: "",
+    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;
+}
+async function git2(args, opts) {
+  const { stdout } = await execFileAsync2("git", args, {
+    cwd: opts?.cwd,
+    timeout: opts?.timeout ?? DEFAULT_TIMEOUT_MS2,
+    env: gitEnv2(),
+    maxBuffer: 50 * 1024 * 1024
+    // 50MB
+  });
+  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_promises27.unlink)(lockPath);
+    await (0, import_promises28.unlink)(lockPath);
   } catch {
   }
 }
 var RepoManager = class {
   cacheDir;
-  constructor(cacheDir) {
-    this.cacheDir = cacheDir ?? DEFAULT_CACHE_DIR;
+  verbose;
+  constructor(cacheDir, verbose = false) {
+    this.cacheDir = cacheDir ?? getGitCacheRoot();
+    this.verbose = verbose;
+  }
+  async runGit(args, opts) {
+    const startedAt = Date.now();
+    if (this.verbose) {
+      console.log(`[repo] git start cwd=${opts?.cwd ?? process.cwd()} args=${args.join(" ")}`);
+    }
+    try {
+      const output = await git2(args, opts);
+      if (this.verbose) {
+        console.log(`[repo] git ok durationMs=${Date.now() - startedAt} args=${args.join(" ")}`);
+      }
+      return output;
+    } catch (error) {
+      if (this.verbose) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(
+          `[repo] git fail durationMs=${Date.now() - startedAt} args=${args.join(" ")} error=${message}`
+        );
+      }
+      throw error;
+    }
   }
   /**
    * Ensure a bare mirror cache exists for the given source.
@@ -15556,11 +16034,19 @@ var RepoManager = class {
    */
   async ensureCache(source, depth, resolve) {
     const key = cacheKey(source);
-    const cachePath = import_node_path38.default.join(this.cacheDir, key);
+    const cachePath = import_node_path40.default.join(this.cacheDir, key);
     const lockPath = `${cachePath}.lock`;
-    const cacheExists = (0, import_node_fs11.existsSync)(import_node_path38.default.join(cachePath, "HEAD"));
+    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);
@@ -15568,16 +16054,26 @@ var RepoManager = class {
         `No cache found for \`${url}\`. Run \`agentv cache add --url ${url} --from <local-path>\` to seed it.`
       );
     }
-    await (0, import_promises27.mkdir)(this.cacheDir, { recursive: true });
+    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 git(fetchArgs, { cwd: cachePath });
+        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));
@@ -15585,10 +16081,13 @@ var RepoManager = class {
         const sourceUrl = getSourceUrl(source);
         const cloneUrl = depth && source.type === "local" ? `file://${sourceUrl}` : sourceUrl;
         cloneArgs.push(cloneUrl, cachePath);
-        await git(cloneArgs);
+        await this.runGit(cloneArgs);
       }
     } finally {
       await releaseLock(lockPath);
+      if (this.verbose) {
+        console.log(`[repo] lock released path=${lockPath}`);
+      }
     }
     return cachePath;
   }
@@ -15597,7 +16096,13 @@ var RepoManager = class {
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = import_node_path38.default.join(workspacePath, repo.path);
+    const targetDir = import_node_path40.default.join(workspacePath, repo.path);
+    const startedAt = Date.now();
+    if (this.verbose) {
+      console.log(
+        `[repo] materialize start path=${repo.path} source=${getSourceUrl(repo.source)} workspace=${workspacePath}`
+      );
+    }
     const cachePath = await this.ensureCache(
       repo.source,
       repo.clone?.depth,
@@ -15613,10 +16118,10 @@ var RepoManager = class {
     cloneArgs.push("--no-checkout");
     const cloneUrl = repo.clone?.depth || repo.clone?.filter ? `file://${cachePath}` : cachePath;
     cloneArgs.push(cloneUrl, targetDir);
-    await git(cloneArgs);
+    await this.runGit(cloneArgs);
     if (repo.clone?.sparse?.length) {
-      await git(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
-      await git(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
+      await this.runGit(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
+      await this.runGit(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
     }
     const ref = repo.checkout?.ref ?? "HEAD";
     const resolve = repo.checkout?.resolve ?? "remote";
@@ -15624,7 +16129,7 @@ var RepoManager = class {
     if (resolve === "remote" && repo.source.type === "git") {
       const url = getSourceUrl(repo.source);
       try {
-        const lsOutput = await git(["ls-remote", url, ref]);
+        const lsOutput = await this.runGit(["ls-remote", url, ref]);
         const match = lsOutput.split("	")[0];
         if (!match) {
           throw new Error(`Ref '${ref}' not found on remote ${url}`);
@@ -15637,17 +16142,26 @@ var RepoManager = class {
     } else {
       resolvedSha = ref;
     }
-    await git(["checkout", resolvedSha], { cwd: targetDir });
+    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 git(["rev-parse", `HEAD~${ancestor}`], { cwd: targetDir });
-        await git(["checkout", ancestorSha], { cwd: targetDir });
+        const ancestorSha = await this.runGit(["rev-parse", `HEAD~${ancestor}`], {
+          cwd: targetDir
+        });
+        await this.runGit(["checkout", ancestorSha], { cwd: targetDir });
       } catch {
         if (repo.clone?.depth) {
-          await git(["fetch", "--deepen", String(ancestor)], { cwd: targetDir });
-          const ancestorSha = await git(["rev-parse", `HEAD~${ancestor}`], { cwd: targetDir });
-          await git(["checkout", ancestorSha], { cwd: targetDir });
+          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}.`
@@ -15655,27 +16169,38 @@ var RepoManager = class {
         }
       }
     }
+    if (this.verbose) {
+      console.log(
+        `[repo] materialize done path=${repo.path} target=${targetDir} durationMs=${Date.now() - startedAt}`
+      );
+    }
   }
   /** Materialize all repos into the workspace. */
   async materializeAll(repos, workspacePath) {
+    if (this.verbose) {
+      console.log(`[repo] materializeAll count=${repos.length} workspace=${workspacePath}`);
+    }
     for (const repo of repos) {
       await this.materialize(repo, workspacePath);
     }
+    if (this.verbose) {
+      console.log("[repo] materializeAll complete");
+    }
   }
   /** 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_path38.default.join(workspacePath, repo.path);
-        await (0, import_promises27.rm)(targetDir, { recursive: true, force: true });
+        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;
     }
     for (const repo of repos) {
-      const targetDir = import_node_path38.default.join(workspacePath, repo.path);
-      await git(["reset", "--hard", "HEAD"], { cwd: targetDir });
-      await git(["clean", "-fd"], { cwd: targetDir });
+      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 });
     }
   }
   /**
@@ -15685,21 +16210,21 @@ var RepoManager = class {
   async seedCache(localPath, remoteUrl, opts) {
     const source = { type: "git", url: remoteUrl };
     const key = cacheKey(source);
-    const cachePath = import_node_path38.default.join(this.cacheDir, key);
+    const cachePath = import_node_path40.default.join(this.cacheDir, key);
     const lockPath = `${cachePath}.lock`;
-    await (0, import_promises27.mkdir)(this.cacheDir, { recursive: true });
+    await (0, import_promises28.mkdir)(this.cacheDir, { recursive: true });
     await acquireLock(lockPath);
     try {
-      if ((0, import_node_fs11.existsSync)(import_node_path38.default.join(cachePath, "HEAD"))) {
+      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_promises27.rm)(cachePath, { recursive: true, force: true });
+        await (0, import_promises28.rm)(cachePath, { recursive: true, force: true });
       }
-      await git(["clone", "--mirror", "--bare", localPath, cachePath]);
-      await git(["remote", "set-url", "origin", remoteUrl], { cwd: cachePath });
+      await git2(["clone", "--mirror", "--bare", localPath, cachePath]);
+      await git2(["remote", "set-url", "origin", remoteUrl], { cwd: cachePath });
     } finally {
       await releaseLock(lockPath);
     }
@@ -15707,41 +16232,41 @@ var RepoManager = class {
   }
   /** Remove the entire cache directory. */
   async cleanCache() {
-    await (0, import_promises27.rm)(this.cacheDir, { recursive: true, force: true });
+    await (0, import_promises28.rm)(this.cacheDir, { recursive: true, force: true });
   }
 };
 
 // src/evaluation/workspace/resolve.ts
-var import_promises28 = require("fs/promises");
-var import_node_path39 = __toESM(require("path"), 1);
+var import_promises29 = require("fs/promises");
+var import_node_path41 = __toESM(require("path"), 1);
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = import_node_path39.default.resolve(templatePath);
-  const stats = await (0, import_promises28.stat)(resolved);
+  const resolved = import_node_path41.default.resolve(templatePath);
+  const stats = await (0, import_promises29.stat)(resolved);
   if (stats.isFile()) {
     return {
-      dir: import_node_path39.default.dirname(resolved),
+      dir: import_node_path41.default.dirname(resolved),
       workspaceFile: resolved
     };
   }
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await (0, import_promises28.readdir)(resolved);
+  const entries = await (0, import_promises29.readdir)(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: import_node_path39.default.join(resolved, workspaceFiles[0])
+      workspaceFile: import_node_path41.default.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? import_node_path39.default.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? import_node_path41.default.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -15823,7 +16348,10 @@ async function runEvaluation(options) {
     trials,
     streamCallbacks,
     totalBudgetUsd,
-    failOnError
+    failOnError,
+    poolWorkspaces,
+    poolMaxSlots: configPoolMaxSlots,
+    workspace: userWorkspacePath
   } = options;
   let useCache = options.useCache;
   if (trials && trials.count > 1 && useCache) {
@@ -15832,7 +16360,7 @@ async function runEvaluation(options) {
     );
     useCache = false;
   }
-  const evalRunId = (0, import_node_crypto9.randomUUID)();
+  const evalRunId = (0, import_node_crypto10.randomUUID)();
   const evalCases = preloadedEvalCases ?? await loadTests(evalFilePath, repoRoot, { verbose, filter });
   const filteredEvalCases = filterEvalCases(evalCases, filter);
   if (filteredEvalCases.length === 0) {
@@ -15897,7 +16425,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveJudgeProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? import_node_path40.default.dirname(import_node_path40.default.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? import_node_path42.default.dirname(import_node_path42.default.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   const providerRegistry = createBuiltinProviderRegistry();
@@ -15953,11 +16481,25 @@ async function runEvaluation(options) {
   const resolvedTemplate = await resolveWorkspaceTemplate(rawTemplate);
   const workspaceTemplate = resolvedTemplate?.dir;
   let suiteWorkspaceFile = resolvedTemplate?.workspaceFile;
+  const setupLog = (message) => {
+    if (verbose) {
+      console.log(`[setup] ${message}`);
+    }
+  };
   const isPerTestIsolation = suiteWorkspace?.isolation === "per_test";
-  const hasSharedWorkspace = !!(workspaceTemplate || suiteWorkspace?.before_all || suiteWorkspace?.repos?.length && !isPerTestIsolation);
+  if (userWorkspacePath && isPerTestIsolation) {
+    throw new Error(
+      "--workspace 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;
   const requestedWorkers = options.maxConcurrency ?? target.workers ?? 1;
-  const workers = hasSharedWorkspace ? 1 : requestedWorkers;
-  if (hasSharedWorkspace && requestedWorkers > 1) {
+  const workers = hasSharedWorkspace && !usePool ? 1 : requestedWorkers;
+  setupLog(
+    `sharedWorkspace=${hasSharedWorkspace} perTestIsolation=${isPerTestIsolation} usePool=${usePool} requestedWorkers=${requestedWorkers} effectiveWorkers=${workers}`
+  );
+  if (hasSharedWorkspace && !usePool && requestedWorkers > 1) {
     console.warn(
       `Warning: Shared workspace requires sequential execution. Overriding workers from ${requestedWorkers} to 1.`
     );
@@ -15966,285 +16508,383 @@ async function runEvaluation(options) {
   let sharedWorkspacePath;
   let sharedBaselineCommit;
   let beforeAllOutput;
-  if (workspaceTemplate) {
+  let poolManager;
+  let poolSlot;
+  const poolSlots = [];
+  const availablePoolSlots = [];
+  const poolSlotBaselines = /* @__PURE__ */ new Map();
+  const poolMaxSlots = Math.min(configPoolMaxSlots ?? 10, 50);
+  if (userWorkspacePath) {
+    sharedWorkspacePath = userWorkspacePath;
+    setupLog(`using user-provided workspace: ${userWorkspacePath}`);
+  } 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);
+    for (let i = 0; i < slotsNeeded; i++) {
+      const slot = await poolManager.acquireWorkspace({
+        templatePath: workspaceTemplate,
+        repos: suiteWorkspace.repos,
+        maxSlots: poolMaxSlots,
+        repoManager: poolRepoManager
+      });
+      poolSlots.push(slot);
+      setupLog(`pool slot ${i} acquired at: ${slot.path} (existing=${slot.isExisting})`);
+    }
+    if (slotsNeeded === 1) {
+      poolSlot = poolSlots[0];
+      sharedWorkspacePath = poolSlot.path;
+    } else {
+      availablePoolSlots.push(...poolSlots);
+    }
+  } else if (workspaceTemplate) {
+    setupLog(`creating shared workspace from template: ${workspaceTemplate}`);
     try {
       sharedWorkspacePath = await createTempWorkspace(workspaceTemplate, evalRunId, "shared");
+      setupLog(`shared workspace created at: ${sharedWorkspacePath}`);
     } catch (error) {
       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) {
+    sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
+    await (0, import_promises30.mkdir)(sharedWorkspacePath, { recursive: true });
+    setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
+  }
+  try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = import_node_path40.default.join(sharedWorkspacePath, import_node_path40.default.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = import_node_path42.default.join(sharedWorkspacePath, import_node_path42.default.basename(suiteWorkspaceFile));
       try {
-        await (0, import_promises29.stat)(copiedWorkspaceFile);
+        await (0, import_promises30.stat)(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
     }
-  } else if (suiteWorkspace?.before_all || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
-    sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await (0, import_promises29.mkdir)(sharedWorkspacePath, { recursive: true });
-  }
-  const repoManager = suiteWorkspace?.repos?.length ? new RepoManager() : void 0;
-  if (repoManager && sharedWorkspacePath && suiteWorkspace?.repos && !isPerTestIsolation) {
-    try {
-      await repoManager.materializeAll(suiteWorkspace.repos, sharedWorkspacePath);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (sharedWorkspacePath) {
-        await cleanupWorkspace(sharedWorkspacePath).catch(() => {
-        });
-      }
-      throw new Error(`Failed to materialize repos: ${message}`);
-    }
-  }
-  if (sharedWorkspacePath && suiteWorkspace?.before_all) {
-    const scriptContext = {
-      workspacePath: sharedWorkspacePath,
-      testId: "__before_all__",
-      evalRunId,
-      evalDir
-    };
-    try {
-      beforeAllOutput = await executeWorkspaceScript(suiteWorkspace.before_all, scriptContext);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (sharedWorkspacePath) {
-        await cleanupWorkspace(sharedWorkspacePath).catch(() => {
-        });
-      }
-      throw new Error(`before_all script failed: ${message}`);
-    }
-  }
-  if (sharedWorkspacePath) {
-    try {
-      sharedBaselineCommit = await initializeBaseline(sharedWorkspacePath);
-    } catch {
-    }
-  }
-  let nextWorkerId = 1;
-  const workerIdByEvalId = /* @__PURE__ */ new Map();
-  let beforeAllOutputAttached = false;
-  let cumulativeBudgetCost = 0;
-  let budgetExhausted = false;
-  let failOnErrorTriggered = false;
-  const promises = filteredEvalCases.map(
-    (evalCase) => limit(async () => {
-      const workerId = nextWorkerId++;
-      workerIdByEvalId.set(evalCase.id, workerId);
-      if (totalBudgetUsd !== void 0 && budgetExhausted) {
-        const budgetResult = {
-          timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-          testId: evalCase.id,
-          dataset: evalCase.dataset,
-          score: 0,
-          hits: [],
-          misses: [],
-          answer: "",
-          target: target.name,
-          error: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
-          budgetExceeded: true,
-          executionStatus: "execution_error",
-          failureStage: "setup",
-          failureReasonCode: "budget_exceeded",
-          executionError: {
-            message: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
-            stage: "setup"
-          }
-        };
-        if (onProgress) {
-          await onProgress({
-            workerId,
-            testId: evalCase.id,
-            status: "failed",
-            completedAt: Date.now(),
-            error: budgetResult.error
+    const repoManager = suiteWorkspace?.repos?.length && !usePool && !userWorkspacePath ? new RepoManager(void 0, verbose) : void 0;
+    if (repoManager && sharedWorkspacePath && suiteWorkspace?.repos && !isPerTestIsolation) {
+      setupLog(
+        `materializing ${suiteWorkspace.repos.length} shared repo(s) into ${sharedWorkspacePath}`
+      );
+      try {
+        await repoManager.materializeAll(suiteWorkspace.repos, sharedWorkspacePath);
+        setupLog("shared repo materialization complete");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (sharedWorkspacePath && !userWorkspacePath) {
+          await cleanupWorkspace(sharedWorkspacePath).catch(() => {
           });
         }
-        if (onResult) {
-          await onResult(budgetResult);
-        }
-        return budgetResult;
+        throw new Error(`Failed to materialize repos: ${message}`);
       }
-      if (failOnError === true && failOnErrorTriggered) {
-        const errorMsg = "Halted: execution error encountered with fail_on_error enabled";
-        const haltResult = {
-          timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
-          testId: evalCase.id,
-          dataset: evalCase.dataset,
-          score: 0,
-          hits: [],
-          misses: [],
-          answer: "",
-          target: target.name,
-          error: errorMsg,
-          executionStatus: "execution_error",
-          failureStage: "setup",
-          failureReasonCode: "error_threshold_exceeded",
-          executionError: { message: errorMsg, stage: "setup" }
-        };
-        if (onProgress) {
-          await onProgress({
-            workerId,
-            testId: evalCase.id,
-            status: "failed",
-            completedAt: Date.now(),
-            error: haltResult.error
+    }
+    if (sharedWorkspacePath && suiteWorkspace?.before_all) {
+      const beforeAllCommand = (suiteWorkspace.before_all.command ?? suiteWorkspace.before_all.script ?? []).join(" ");
+      setupLog(
+        `running shared before_all in cwd=${suiteWorkspace.before_all.cwd ?? evalDir} command=${beforeAllCommand}`
+      );
+      const scriptContext = {
+        workspacePath: sharedWorkspacePath,
+        testId: "__before_all__",
+        evalRunId,
+        evalDir
+      };
+      try {
+        beforeAllOutput = await executeWorkspaceScript(suiteWorkspace.before_all, scriptContext);
+        setupLog("shared before_all completed");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (sharedWorkspacePath && !userWorkspacePath) {
+          await cleanupWorkspace(sharedWorkspacePath).catch(() => {
           });
         }
-        if (onResult) {
-          await onResult(haltResult);
-        }
-        return haltResult;
-      }
-      if (onProgress) {
-        await onProgress({
-          workerId,
-          testId: evalCase.id,
-          status: "running",
-          startedAt: Date.now()
-        });
+        throw new Error(`before_all script failed: ${message}`);
       }
-      try {
-        const judgeProvider = await resolveJudgeProvider(target);
-        const runCaseOptions = {
-          evalCase,
-          provider: primaryProvider,
-          target,
-          evaluators: evaluatorRegistry,
-          maxRetries,
-          agentTimeoutMs,
-          cache,
-          useCache,
-          now,
-          judgeProvider,
-          targetResolver,
-          availableTargets,
+    }
+    if (availablePoolSlots.length > 0 && suiteWorkspace?.before_all) {
+      for (const slot of availablePoolSlots) {
+        setupLog(`running before_all on pool slot ${slot.index}`);
+        const scriptContext = {
+          workspacePath: slot.path,
+          testId: "__before_all__",
           evalRunId,
-          keepWorkspaces,
-          cleanupWorkspaces,
-          sharedWorkspacePath,
-          sharedBaselineCommit,
-          suiteWorkspaceFile,
-          streamCallbacks,
-          typeRegistry,
-          repoManager,
           evalDir
         };
-        let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
-        if (totalBudgetUsd !== void 0) {
-          let caseCost;
-          if (result.trials && result.trials.length > 0) {
-            const trialCostSum = result.trials.reduce((sum, t) => sum + (t.costUsd ?? 0), 0);
-            if (trialCostSum > 0) {
-              caseCost = trialCostSum;
+        try {
+          const output = await executeWorkspaceScript(suiteWorkspace.before_all, scriptContext);
+          if (!beforeAllOutput) beforeAllOutput = output;
+          setupLog(`before_all completed on pool slot ${slot.index}`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error(`before_all script failed on pool slot ${slot.index}: ${message}`);
+        }
+      }
+    }
+    if (sharedWorkspacePath) {
+      try {
+        sharedBaselineCommit = await initializeBaseline(sharedWorkspacePath);
+        setupLog(`shared baseline initialized: ${sharedBaselineCommit}`);
+      } catch {
+        setupLog("shared baseline initialization skipped (non-fatal)");
+      }
+    }
+    if (availablePoolSlots.length > 0) {
+      for (const slot of availablePoolSlots) {
+        try {
+          const baseline = await initializeBaseline(slot.path);
+          poolSlotBaselines.set(slot.path, baseline);
+          setupLog(`pool slot ${slot.index} baseline initialized: ${baseline}`);
+        } catch {
+          setupLog(`pool slot ${slot.index} baseline initialization skipped (non-fatal)`);
+        }
+      }
+    }
+    let nextWorkerId = 1;
+    const workerIdByEvalId = /* @__PURE__ */ new Map();
+    let beforeAllOutputAttached = false;
+    let cumulativeBudgetCost = 0;
+    let budgetExhausted = false;
+    let failOnErrorTriggered = false;
+    const promises = filteredEvalCases.map(
+      (evalCase) => limit(async () => {
+        const workerId = nextWorkerId++;
+        workerIdByEvalId.set(evalCase.id, workerId);
+        if (totalBudgetUsd !== void 0 && budgetExhausted) {
+          const budgetResult = {
+            timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+            testId: evalCase.id,
+            dataset: evalCase.dataset,
+            score: 0,
+            hits: [],
+            misses: [],
+            answer: "",
+            target: target.name,
+            error: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
+            budgetExceeded: true,
+            executionStatus: "execution_error",
+            failureStage: "setup",
+            failureReasonCode: "budget_exceeded",
+            executionError: {
+              message: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
+              stage: "setup"
             }
-          } else {
-            caseCost = result.costUsd;
+          };
+          if (onProgress) {
+            await onProgress({
+              workerId,
+              testId: evalCase.id,
+              status: "failed",
+              completedAt: Date.now(),
+              error: budgetResult.error
+            });
           }
-          if (caseCost !== void 0) {
-            cumulativeBudgetCost += caseCost;
-            if (cumulativeBudgetCost >= totalBudgetUsd) {
-              budgetExhausted = true;
-            }
+          if (onResult) {
+            await onResult(budgetResult);
           }
+          return budgetResult;
         }
-        if (failOnError === true && result.executionStatus === "execution_error") {
-          failOnErrorTriggered = true;
-        }
-        if (beforeAllOutput && !beforeAllOutputAttached) {
-          result = { ...result, beforeAllOutput };
-          beforeAllOutputAttached = true;
+        if (failOnError === true && failOnErrorTriggered) {
+          const errorMsg = "Halted: execution error encountered with fail_on_error enabled";
+          const haltResult = {
+            timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+            testId: evalCase.id,
+            dataset: evalCase.dataset,
+            score: 0,
+            hits: [],
+            misses: [],
+            answer: "",
+            target: target.name,
+            error: errorMsg,
+            executionStatus: "execution_error",
+            failureStage: "setup",
+            failureReasonCode: "error_threshold_exceeded",
+            executionError: { message: errorMsg, stage: "setup" }
+          };
+          if (onProgress) {
+            await onProgress({
+              workerId,
+              testId: evalCase.id,
+              status: "failed",
+              completedAt: Date.now(),
+              error: haltResult.error
+            });
+          }
+          if (onResult) {
+            await onResult(haltResult);
+          }
+          return haltResult;
         }
         if (onProgress) {
           await onProgress({
             workerId,
             testId: evalCase.id,
-            status: result.error ? "failed" : "completed",
-            startedAt: 0,
-            // Not used for completed status
-            completedAt: Date.now(),
-            error: result.error
+            status: "running",
+            startedAt: Date.now()
           });
         }
-        if (onResult) {
-          await onResult(result);
+        const testPoolSlot = availablePoolSlots.length > 0 ? availablePoolSlots.pop() : void 0;
+        const testWorkspacePath = testPoolSlot?.path ?? sharedWorkspacePath;
+        const testBaselineCommit = testPoolSlot ? poolSlotBaselines.get(testPoolSlot.path) : sharedBaselineCommit;
+        try {
+          const judgeProvider = await resolveJudgeProvider(target);
+          const runCaseOptions = {
+            evalCase,
+            provider: primaryProvider,
+            target,
+            evaluators: evaluatorRegistry,
+            maxRetries,
+            agentTimeoutMs,
+            cache,
+            useCache,
+            now,
+            judgeProvider,
+            targetResolver,
+            availableTargets,
+            evalRunId,
+            keepWorkspaces,
+            cleanupWorkspaces,
+            sharedWorkspacePath: testWorkspacePath,
+            sharedBaselineCommit: testBaselineCommit,
+            suiteWorkspaceFile,
+            streamCallbacks,
+            typeRegistry,
+            repoManager,
+            evalDir
+          };
+          let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
+          if (totalBudgetUsd !== void 0) {
+            let caseCost;
+            if (result.trials && result.trials.length > 0) {
+              const trialCostSum = result.trials.reduce((sum, t) => sum + (t.costUsd ?? 0), 0);
+              if (trialCostSum > 0) {
+                caseCost = trialCostSum;
+              }
+            } else {
+              caseCost = result.costUsd;
+            }
+            if (caseCost !== void 0) {
+              cumulativeBudgetCost += caseCost;
+              if (cumulativeBudgetCost >= totalBudgetUsd) {
+                budgetExhausted = true;
+              }
+            }
+          }
+          if (failOnError === true && result.executionStatus === "execution_error") {
+            failOnErrorTriggered = true;
+          }
+          if (beforeAllOutput && !beforeAllOutputAttached) {
+            result = { ...result, beforeAllOutput };
+            beforeAllOutputAttached = true;
+          }
+          if (onProgress) {
+            await onProgress({
+              workerId,
+              testId: evalCase.id,
+              status: result.error ? "failed" : "completed",
+              startedAt: 0,
+              // Not used for completed status
+              completedAt: Date.now(),
+              error: result.error
+            });
+          }
+          if (onResult) {
+            await onResult(result);
+          }
+          return result;
+        } catch (error) {
+          if (onProgress) {
+            await onProgress({
+              workerId,
+              testId: evalCase.id,
+              status: "failed",
+              completedAt: Date.now(),
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+          throw error;
+        } finally {
+          if (testPoolSlot) {
+            availablePoolSlots.push(testPoolSlot);
+          }
         }
-        return result;
-      } catch (error) {
-        if (onProgress) {
-          await onProgress({
-            workerId,
-            testId: evalCase.id,
-            status: "failed",
-            completedAt: Date.now(),
-            error: error instanceof Error ? error.message : String(error)
-          });
+      })
+    );
+    const settled = await Promise.allSettled(promises);
+    const results = [];
+    for (let i = 0; i < settled.length; i++) {
+      const outcome = settled[i];
+      if (outcome.status === "fulfilled") {
+        results.push(outcome.value);
+      } else {
+        const evalCase = filteredEvalCases[i];
+        const formattingMode = usesFileReferencePrompt(primaryProvider) ? "agent" : "lm";
+        const promptInputs = await buildPromptInputs(evalCase, formattingMode);
+        const errorResult = buildErrorResult(
+          evalCase,
+          target.name,
+          (now ?? (() => /* @__PURE__ */ new Date()))(),
+          outcome.reason,
+          promptInputs,
+          primaryProvider,
+          "agent",
+          "provider_error"
+        );
+        results.push(errorResult);
+        if (onResult) {
+          await onResult(errorResult);
         }
-        throw error;
       }
-    })
-  );
-  const settled = await Promise.allSettled(promises);
-  const results = [];
-  for (let i = 0; i < settled.length; i++) {
-    const outcome = settled[i];
-    if (outcome.status === "fulfilled") {
-      results.push(outcome.value);
-    } else {
-      const evalCase = filteredEvalCases[i];
-      const formattingMode = usesFileReferencePrompt(primaryProvider) ? "agent" : "lm";
-      const promptInputs = await buildPromptInputs(evalCase, formattingMode);
-      const errorResult = buildErrorResult(
-        evalCase,
-        target.name,
-        (now ?? (() => /* @__PURE__ */ new Date()))(),
-        outcome.reason,
-        promptInputs,
-        primaryProvider,
-        "agent",
-        "provider_error"
-      );
-      results.push(errorResult);
-      if (onResult) {
-        await onResult(errorResult);
+    }
+    const afterAllWorkspaces = poolSlots.length > 1 ? poolSlots.map((s) => s.path) : sharedWorkspacePath ? [sharedWorkspacePath] : [];
+    if (afterAllWorkspaces.length > 0 && suiteWorkspace?.after_all) {
+      for (const wsPath of afterAllWorkspaces) {
+        const scriptContext = {
+          workspacePath: wsPath,
+          testId: "__after_all__",
+          evalRunId,
+          evalDir
+        };
+        try {
+          const afterAllOutput = await executeWorkspaceScript(
+            suiteWorkspace.after_all,
+            scriptContext,
+            "warn"
+          );
+          if (afterAllOutput && results.length > 0 && wsPath === afterAllWorkspaces[0]) {
+            results[results.length - 1] = { ...results[results.length - 1], afterAllOutput };
+          }
+        } catch {
+        }
       }
     }
-  }
-  if (sharedWorkspacePath && suiteWorkspace?.after_all) {
-    const scriptContext = {
-      workspacePath: sharedWorkspacePath,
-      testId: "__after_all__",
-      evalRunId,
-      evalDir
-    };
-    try {
-      const afterAllOutput = await executeWorkspaceScript(
-        suiteWorkspace.after_all,
-        scriptContext,
-        "warn"
-      );
-      if (afterAllOutput && results.length > 0) {
-        results[results.length - 1] = { ...results[results.length - 1], afterAllOutput };
+    if (sharedWorkspacePath && !poolSlot && poolSlots.length === 0 && !userWorkspacePath) {
+      const hasFailure = results.some((r) => !!r.error || r.score < 0.5);
+      if (cleanupWorkspaces) {
+        await cleanupWorkspace(sharedWorkspacePath).catch(() => {
+        });
+      } else if (!hasFailure && !keepWorkspaces) {
+        await cleanupWorkspace(sharedWorkspacePath).catch(() => {
+        });
       }
-    } catch {
     }
-  }
-  if (sharedWorkspacePath) {
-    const hasFailure = results.some((r) => !!r.error || r.score < 0.5);
     if (cleanupWorkspaces) {
-      await cleanupWorkspace(sharedWorkspacePath).catch(() => {
-      });
-    } else if (!hasFailure && !keepWorkspaces) {
-      await cleanupWorkspace(sharedWorkspacePath).catch(() => {
+      await cleanupEvalWorkspaces(evalRunId).catch(() => {
       });
     }
+    return results;
+  } finally {
+    if (poolManager) {
+      if (poolSlot) {
+        await poolManager.releaseSlot(poolSlot);
+      }
+      for (const slot of poolSlots) {
+        if (slot !== poolSlot) {
+          await poolManager.releaseSlot(slot).catch(() => {
+          });
+        }
+      }
+    }
   }
-  if (cleanupWorkspaces) {
-    await cleanupEvalWorkspaces(evalRunId).catch(() => {
-    });
-  }
-  return results;
 }
 async function runBatchEvaluation(options) {
   const {
@@ -16423,6 +17063,7 @@ async function runEvalCase(options) {
     repoManager,
     evalDir
   } = options;
+  const setupDebug = process.env.AGENTV_SETUP_DEBUG === "1";
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
   const promptInputs = await buildPromptInputs(evalCase, formattingMode);
   const typeRegistry = providedTypeRegistry ?? createBuiltinRegistry();
@@ -16460,9 +17101,9 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = import_node_path40.default.join(workspacePath, import_node_path40.default.basename(caseWorkspaceFile));
+        const copiedFile = import_node_path42.default.join(workspacePath, import_node_path42.default.basename(caseWorkspaceFile));
         try {
-          await (0, import_promises29.stat)(copiedFile);
+          await (0, import_promises30.stat)(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -16470,12 +17111,20 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.before_all || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await (0, import_promises29.mkdir)(workspacePath, { recursive: true });
+      await (0, import_promises30.mkdir)(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
-      const perCaseRepoManager = new RepoManager();
+      const perCaseRepoManager = new RepoManager(void 0, setupDebug);
       try {
+        if (setupDebug) {
+          console.log(
+            `[setup] test=${evalCase.id} materializing ${evalCase.workspace.repos.length} per-test repo(s) into ${workspacePath}`
+          );
+        }
         await perCaseRepoManager.materializeAll(evalCase.workspace.repos, workspacePath);
+        if (setupDebug) {
+          console.log(`[setup] test=${evalCase.id} per-test repo materialization complete`);
+        }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return buildErrorResult(
@@ -16491,6 +17140,12 @@ async function runEvalCase(options) {
       }
     }
     if (workspacePath && evalCase.workspace?.before_all) {
+      const beforeAllCommand = (evalCase.workspace.before_all.command ?? evalCase.workspace.before_all.script ?? []).join(" ");
+      if (setupDebug) {
+        console.log(
+          `[setup] test=${evalCase.id} running before_all in cwd=${evalCase.workspace.before_all.cwd ?? evalDir} command=${beforeAllCommand}`
+        );
+      }
       const scriptContext = {
         workspacePath,
         testId: evalCase.id,
@@ -16504,6 +17159,9 @@ async function runEvalCase(options) {
           evalCase.workspace.before_all,
           scriptContext
         );
+        if (setupDebug) {
+          console.log(`[setup] test=${evalCase.id} before_all completed`);
+        }
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         if (forceCleanup && workspacePath) {
@@ -17053,7 +17711,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  const evalFileDir = evalCase.guideline_paths[0] ? import_node_path40.default.dirname(evalCase.guideline_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.guideline_paths[0] ? import_node_path42.default.dirname(evalCase.guideline_paths[0]) : process.cwd();
   const dispatchContext = {
     judgeProvider,
     targetResolver,
@@ -17287,7 +17945,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = (0, import_node_crypto9.createHash)("sha256");
+  const hash = (0, import_node_crypto10.createHash)("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -17355,8 +18013,8 @@ function computeWeightedMean(entries) {
 }
 
 // src/evaluation/evaluate.ts
-var import_node_fs12 = require("fs");
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_node_path43 = __toESM(require("path"), 1);
 async function evaluate(config) {
   const startTime = Date.now();
   if (config.tests && config.specFile) {
@@ -17378,13 +18036,13 @@ async function evaluate(config) {
   let evalCases;
   let testFilePath;
   if (config.specFile) {
-    testFilePath = import_node_path41.default.resolve(config.specFile);
+    testFilePath = import_node_path43.default.resolve(config.specFile);
     evalCases = await loadTests(testFilePath, repoRoot, {
       verbose: config.verbose,
       filter: config.filter
     });
   } else {
-    testFilePath = import_node_path41.default.join(process.cwd(), "__programmatic__.yaml");
+    testFilePath = import_node_path43.default.join(process.cwd(), "__programmatic__.yaml");
     evalCases = (config.tests ?? []).map((test) => {
       const input = typeof test.input === "string" ? [{ role: "user", content: test.input }] : test.input;
       const question = typeof test.input === "string" ? test.input : test.input.find((m) => m.role === "user")?.content ?? "";
@@ -17470,11 +18128,11 @@ function computeSummary(results, durationMs) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain2(import_node_path41.default.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain2(import_node_path43.default.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = import_node_path41.default.join(dir, candidate);
-      if (!(0, import_node_fs12.existsSync)(targetsPath)) continue;
+      const targetsPath = import_node_path43.default.join(dir, candidate);
+      if (!(0, import_node_fs13.existsSync)(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -17488,11 +18146,11 @@ async function discoverDefaultTarget(repoRoot) {
 async function loadEnvHierarchy(repoRoot) {
   const { readFileSync: readFileSync2 } = await import("fs");
   const cwd = process.cwd();
-  const chain = buildDirectoryChain2(import_node_path41.default.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain2(import_node_path43.default.join(cwd, "_placeholder"), repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = import_node_path41.default.join(dir, ".env");
-    if ((0, import_node_fs12.existsSync)(envPath)) envFiles.push(envPath);
+    const envPath = import_node_path43.default.join(dir, ".env");
+    if ((0, import_node_fs13.existsSync)(envPath)) envFiles.push(envPath);
   }
   for (let i = envFiles.length - 1; i >= 0; i--) {
     try {
@@ -17570,12 +18228,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync4 } = await import("fs");
+  const { existsSync: existsSync5 } = 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 (!existsSync4(filePath)) {
+    if (!existsSync5(filePath)) {
       continue;
     }
     try {
@@ -17672,8 +18330,8 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/cache/response-cache.ts
-var import_promises30 = require("fs/promises");
-var import_node_path42 = __toESM(require("path"), 1);
+var import_promises31 = require("fs/promises");
+var import_node_path44 = __toESM(require("path"), 1);
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -17683,7 +18341,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await (0, import_promises30.readFile)(filePath, "utf8");
+      const data = await (0, import_promises31.readFile)(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -17691,13 +18349,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = import_node_path42.default.dirname(filePath);
-    await (0, import_promises30.mkdir)(dir, { recursive: true });
-    await (0, import_promises30.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
+    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");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return import_node_path42.default.join(this.cachePath, prefix, `${key}.json`);
+    return import_node_path44.default.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -18184,6 +18842,7 @@ function createAgentKernel() {
   TokenUsageEvaluator,
   ToolTrajectoryEvaluator,
   WorkspaceCreationError,
+  WorkspacePoolManager,
   assembleLlmJudgePrompt,
   avgToolDurationMs,
   buildDirectoryChain,
@@ -18198,6 +18857,7 @@ function createAgentKernel() {
   cleanupEvalWorkspaces,
   cleanupWorkspace,
   computeTraceSummary,
+  computeWorkspaceFingerprint,
   consumeClaudeLogEntries,
   consumeCodexLogEntries,
   consumeCopilotCliLogEntries,
@@ -18229,8 +18889,14 @@ function createAgentKernel() {
   findGitRoot,
   freeformEvaluationSchema,
   generateRubrics,
+  getAgentvHome,
+  getGitCacheRoot,
   getHitCount,
+  getSubagentsRoot,
+  getTraceStateRoot,
   getWorkspacePath,
+  getWorkspacePoolRoot,
+  getWorkspacesRoot,
   initializeBaseline,
   isEvaluatorKind,
   isGuidelineFile,