@agentv/core 4.15.9-next.1 → 4.16.0-next.1

package/dist/index.cjs

@@ -1857,6 +1857,7 @@ __export(index_exports, {
   extractJsonBlob: () => extractJsonBlob,
   extractLastAssistantContent: () => extractLastAssistantContent,
   extractTargetFromSuite: () => extractTargetFromSuite,
+  extractTargetRefsFromSuite: () => extractTargetRefsFromSuite,
   extractTargetsFromSuite: () => extractTargetsFromSuite,
   extractTargetsFromTestCase: () => extractTargetsFromTestCase,
   extractThreshold: () => extractThreshold,
@@ -1866,6 +1867,7 @@ __export(index_exports, {
   findGitRoot: () => findGitRoot,
   freeformEvaluationSchema: () => freeformEvaluationSchema,
   generateRubrics: () => generateRubrics,
+  getAgentvConfigDir: () => getAgentvConfigDir,
   getAgentvHome: () => getAgentvHome,
   getBenchmark: () => getBenchmark,
   getBenchmarksRegistryPath: () => getBenchmarksRegistryPath,
@@ -2655,17 +2657,76 @@ function extractTargetFromSuite(suite) {
   }
   return void 0;
 }
-function extractTargetsFromSuite(suite) {
+function extractTargetRefsFromSuite(suite) {
   const execution = suite.execution;
   if (!execution || typeof execution !== "object" || Array.isArray(execution)) {
     return void 0;
   }
   const targets = execution.targets;
-  if (Array.isArray(targets)) {
-    const valid = targets.filter((t) => typeof t === "string" && t.trim().length > 0);
-    return valid.length > 0 ? valid.map((t) => t.trim()) : void 0;
+  if (!Array.isArray(targets)) {
+    return void 0;
   }
-  return void 0;
+  const refs = [];
+  for (const t of targets) {
+    if (typeof t === "string" && t.trim().length > 0) {
+      refs.push({ name: t.trim() });
+    } else if (t && typeof t === "object" && !Array.isArray(t) && "name" in t) {
+      const obj = t;
+      const name = typeof obj.name === "string" ? obj.name.trim() : "";
+      if (name.length === 0) continue;
+      const useTarget = typeof obj.use_target === "string" ? obj.use_target.trim() : void 0;
+      const hooks = parseTargetHooks(obj.hooks);
+      refs.push({
+        name,
+        ...useTarget && { use_target: useTarget },
+        ...hooks && { hooks }
+      });
+    }
+  }
+  return refs.length > 0 ? refs : void 0;
+}
+function extractTargetsFromSuite(suite) {
+  const refs = extractTargetRefsFromSuite(suite);
+  if (!refs) return void 0;
+  const names = refs.map((r) => r.name);
+  return names.length > 0 ? names : void 0;
+}
+function parseHookConfig(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const obj = raw;
+  let command;
+  if (typeof obj.command === "string") {
+    command = ["sh", "-c", obj.command];
+  } else if (Array.isArray(obj.command)) {
+    command = obj.command.filter((s) => typeof s === "string");
+  } else if (typeof obj.script === "string") {
+    command = ["sh", "-c", obj.script];
+  } else if (Array.isArray(obj.script)) {
+    command = obj.script.filter((s) => typeof s === "string");
+  }
+  if (!command || command.length === 0) return void 0;
+  const timeoutMs = typeof obj.timeout_ms === "number" ? obj.timeout_ms : typeof obj.timeoutMs === "number" ? obj.timeoutMs : void 0;
+  const cwd = typeof obj.cwd === "string" ? obj.cwd : void 0;
+  return {
+    command,
+    ...timeoutMs !== void 0 && { timeout_ms: timeoutMs },
+    ...cwd && { cwd }
+  };
+}
+function parseTargetHooks(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const obj = raw;
+  const beforeAll = parseHookConfig(obj.before_all);
+  const beforeEach = parseHookConfig(obj.before_each);
+  const afterEach = parseHookConfig(obj.after_each);
+  const afterAll = parseHookConfig(obj.after_all);
+  if (!beforeAll && !beforeEach && !afterEach && !afterAll) return void 0;
+  return {
+    ...beforeAll && { before_all: beforeAll },
+    ...beforeEach && { before_each: beforeEach },
+    ...afterEach && { after_each: afterEach },
+    ...afterAll && { after_all: afterAll }
+  };
 }
 function extractWorkersFromSuite(suite) {
   const execution = suite.execution;
@@ -3337,7 +3398,11 @@ async function parseEvaluatorList(candidateEvaluators, searchRoots, evalId, defa
     }
     const placeholderIndex = result.indexOf(PLACEHOLDER);
     if (strings.length > 0 && placeholderIndex !== -1) {
-      result[placeholderIndex] = { type: "rubrics", criteria: strings };
+      result[placeholderIndex] = {
+        type: "rubrics",
+        criteria: strings,
+        weight: strings.length
+      };
     } else if (placeholderIndex !== -1) {
       result.splice(placeholderIndex, 1);
     }
@@ -5739,6 +5804,7 @@ async function readTestSuiteMetadata(testFilePath) {
     return {
       target: extractTargetFromSuite(parsed),
       targets: extractTargetsFromSuite(parsed),
+      targetRefs: extractTargetRefsFromSuite(parsed),
       trials: extractTrialsConfig(parsed)
     };
   } catch {
@@ -5765,6 +5831,7 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     tests,
     trials: extractTrialsConfig(parsed),
     targets: extractTargetsFromSuite(parsed),
+    targetRefs: extractTargetRefsFromSuite(parsed),
     workers: extractWorkersFromSuite(parsed),
     cacheConfig: extractCacheConfig(parsed),
     totalBudgetUsd: extractTotalBudgetUsd(parsed),
@@ -7519,7 +7586,7 @@ var ClaudeCliProvider = class {
       if (options.cwd) {
         spawnOptions.cwd = options.cwd;
       }
-      const child = (0, import_node_child_process.spawn)("claude", options.args, spawnOptions);
+      const child = (0, import_node_child_process.spawn)(this.config.executable, options.args, spawnOptions);
       let stdout = "";
       let stderr = "";
       let timedOut = false;
@@ -7578,7 +7645,7 @@ var ClaudeCliProvider = class {
         if (err.code === "ENOENT") {
           reject(
             new Error(
-              `Claude CLI executable 'claude' was not found on PATH. Install claude-code or ensure it is in PATH.`
+              `Claude CLI executable '${this.config.executable}' was not found on PATH. Install claude-code or ensure it is in PATH.`
             )
           );
         } else {
@@ -11671,6 +11738,9 @@ init_cjs_shims();
 var import_node_os7 = __toESM(require("os"), 1);
 var import_node_path24 = __toESM(require("path"), 1);
 var logged = false;
+function getAgentvConfigDir() {
+  return import_node_path24.default.join(import_node_os7.default.homedir(), ".agentv");
+}
 function getAgentvHome() {
   const envHome = process.env.AGENTV_HOME;
   if (envHome && envHome !== "undefined") {
@@ -12343,6 +12413,8 @@ var ProviderRegistry = class {
 
 // src/evaluation/providers/targets.ts
 init_cjs_shims();
+var import_node_fs12 = require("fs");
+var import_node_os8 = require("os");
 var import_node_path26 = __toESM(require("path"), 1);
 var import_zod3 = require("zod");
 var CliHealthcheckHttpInputSchema = import_zod3.z.object({
@@ -12368,8 +12440,6 @@ var CliTargetInputSchema = import_zod3.z.object({
   attachments_format: import_zod3.z.string().optional(),
   // Working directory - optional
   cwd: import_zod3.z.string().optional(),
-  // Workspace template directory - optional (mutually exclusive with cwd)
-  workspace_template: import_zod3.z.string().optional(),
   // Timeout in seconds - optional
   timeout_seconds: import_zod3.z.number().positive().optional(),
   // Healthcheck configuration - optional
@@ -12404,7 +12474,6 @@ var CliTargetConfigSchema = import_zod3.z.object({
   command: import_zod3.z.string().min(1),
   filesFormat: import_zod3.z.string().optional(),
   cwd: import_zod3.z.string().optional(),
-  workspaceTemplate: import_zod3.z.string().optional(),
   timeoutMs: import_zod3.z.number().positive().optional(),
   healthcheck: CliHealthcheckSchema.optional(),
   verbose: import_zod3.z.boolean().optional(),
@@ -12447,19 +12516,6 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
   const command = resolveString(input.command, env, `${targetName} CLI command`, true);
   const filesFormatSource = input.files_format ?? input.attachments_format;
   const filesFormat = resolveOptionalLiteralString(filesFormatSource);
-  const workspaceTemplateSource = input.workspace_template;
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${targetName} workspace template`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
   let cwd = resolveOptionalString(input.cwd, env, `${targetName} working directory`, {
     allowLiteral: true,
     optionalEnv: true
@@ -12467,12 +12523,7 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
   if (cwd && evalFilePath && !import_node_path26.default.isAbsolute(cwd)) {
     cwd = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), cwd);
   }
-  if (cwd && workspaceTemplate) {
-    throw new Error(
-      `${targetName}: 'cwd' and 'workspace_template' are mutually exclusive. Use 'cwd' to run in an existing directory, or 'workspace_template' to copy a template to a temp location.`
-    );
-  }
-  if (!cwd && !workspaceTemplate && evalFilePath) {
+  if (!cwd && evalFilePath) {
     cwd = import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath));
   }
   const timeoutSeconds = input.timeout_seconds;
@@ -12484,7 +12535,6 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
     command,
     filesFormat,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     healthcheck,
     verbose,
@@ -12553,11 +12603,6 @@ function collectDeprecatedCamelCaseWarnings(value, location, aliases) {
   return warnings;
 }
 function assertNoDeprecatedCamelCaseTargetFields(definition) {
-  if (Object.prototype.hasOwnProperty.call(definition, "workspaceTemplate")) {
-    throw new Error(
-      `${definition.name}: target-level workspace_template has been removed. Use eval-level workspace.template.`
-    );
-  }
   const warning = findDeprecatedCamelCaseTargetWarnings(
     definition,
     `target "${definition.name}"`
@@ -12607,7 +12652,6 @@ var BASE_TARGET_SCHEMA = import_zod3.z.object({
   judge_target: import_zod3.z.string().optional(),
   // backward compat
   workers: import_zod3.z.number().int().min(1).optional(),
-  workspace_template: import_zod3.z.string().optional(),
   subagent_mode_allowed: import_zod3.z.boolean().optional(),
   fallback_targets: import_zod3.z.array(import_zod3.z.string().min(1)).optional()
 }).passthrough();
@@ -12704,11 +12748,6 @@ function resolveDelegatedTargetDefinition(name, definitions, env = process.env)
 function resolveTargetDefinition(definition, env = process.env, evalFilePath, options) {
   assertNoDeprecatedCamelCaseTargetFields(definition);
   const parsed = BASE_TARGET_SCHEMA.parse(definition);
-  if (parsed.workspace_template !== void 0) {
-    throw new Error(
-      `${parsed.name}: target-level workspace_template has been removed. Use eval-level workspace.template.`
-    );
-  }
   if (!parsed.provider) {
     throw new Error(
       `${parsed.name}: 'provider' is required (targets with use_target must be resolved before calling resolveTargetDefinition)`
@@ -12805,6 +12844,20 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath, op
         ...base,
         config: resolvePiCliConfig(parsed, env, evalFilePath)
       };
+    case "cc-mirror": {
+      const variantName = resolveOptionalString(parsed.variant, env, `${parsed.name} cc-mirror variant`, {
+        allowLiteral: true,
+        optionalEnv: true
+      }) ?? parsed.name;
+      if (!parsed.executable) {
+        parsed.executable = resolveCcMirrorBinaryPath(variantName);
+      }
+      return {
+        kind: "claude-cli",
+        ...base,
+        config: resolveClaudeConfig(parsed, env, evalFilePath)
+      };
+    }
     case "claude":
     case "claude-code":
     case "claude-cli":
@@ -12993,12 +13046,11 @@ function resolveGeminiConfig(target, env) {
     retry
   };
 }
-function resolveCodexConfig(target, env, evalFilePath) {
+function resolveCodexConfig(target, env, _evalFilePath) {
   const modelSource = target.model;
   const executableSource = target.executable ?? target.command ?? target.binary;
   const argsSource = target.args ?? target.arguments;
   const cwdSource = target.cwd;
-  const workspaceTemplateSource = target.workspace_template;
   const timeoutSource = target.timeout_seconds;
   const logDirSource = target.log_dir ?? target.log_directory;
   const logFormatSource = target.log_format ?? target.log_output_format ?? env.AGENTV_CODEX_LOG_FORMAT;
@@ -13021,23 +13073,6 @@ function resolveCodexConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${target.name} codex workspace template`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
-  if (cwd && workspaceTemplate) {
-    throw new Error(
-      `${target.name}: 'cwd' and 'workspace_template' are mutually exclusive. Use 'cwd' to run in an existing directory, or 'workspace_template' to copy a template to a temp location.`
-    );
-  }
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} codex timeout`);
   const logDir = resolveOptionalString(logDirSource, env, `${target.name} codex log directory`, {
     allowLiteral: true,
@@ -13050,7 +13085,6 @@ function resolveCodexConfig(target, env, evalFilePath) {
     executable,
     args,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     logDir,
     logFormat,
@@ -13103,13 +13137,12 @@ function resolveStreamLog(target, envFallback) {
     deprecationWarning: `${target.name}: 'log_format' is deprecated and will be removed in v4.16. Use 'stream_log: ${streamLogEquivalent}' instead (log_format: '${normalized}' \u2192 stream_log: '${streamLogEquivalent}').`
   };
 }
-function resolveCopilotSdkConfig(target, env, evalFilePath) {
+function resolveCopilotSdkConfig(target, env, _evalFilePath) {
   const cliUrlSource = target.cli_url;
   const cliPathSource = target.cli_path;
   const githubTokenSource = target.github_token;
   const modelSource = target.model;
   const cwdSource = target.cwd;
-  const workspaceTemplateSource = target.workspace_template;
   const timeoutSource = target.timeout_seconds;
   const logDirSource = target.log_dir ?? target.log_directory;
   const logFormatSource = target.log_format;
@@ -13144,23 +13177,6 @@ function resolveCopilotSdkConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${target.name} copilot-sdk workspace template`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
-  if (cwd && workspaceTemplate) {
-    throw new Error(
-      `${target.name}: 'cwd' and 'workspace_template' are mutually exclusive. Use 'cwd' to run in an existing directory, or 'workspace_template' to copy a template to a temp location.`
-    );
-  }
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} copilot-sdk timeout`);
   const logDir = resolveOptionalString(
     logDirSource,
@@ -13225,7 +13241,6 @@ function resolveCopilotSdkConfig(target, env, evalFilePath) {
     githubToken,
     model,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     logDir,
     logFormat,
@@ -13239,12 +13254,11 @@ function resolveCopilotSdkConfig(target, env, evalFilePath) {
     byokWireApi
   };
 }
-function resolveCopilotCliConfig(target, env, evalFilePath) {
+function resolveCopilotCliConfig(target, env, _evalFilePath) {
   const executableSource = target.executable ?? target.command ?? target.binary;
   const modelSource = target.model;
   const argsSource = target.args ?? target.arguments;
   const cwdSource = target.cwd;
-  const workspaceTemplateSource = target.workspace_template;
   const timeoutSource = target.timeout_seconds;
   const logDirSource = target.log_dir ?? target.log_directory;
   const logFormatSource = target.log_format;
@@ -13267,23 +13281,6 @@ function resolveCopilotCliConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${target.name} copilot-cli workspace template`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
-  if (cwd && workspaceTemplate) {
-    throw new Error(
-      `${target.name}: 'cwd' and 'workspace_template' are mutually exclusive. Use 'cwd' to run in an existing directory, or 'workspace_template' to copy a template to a temp location.`
-    );
-  }
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} copilot-cli timeout`);
   const logDir = resolveOptionalString(
     logDirSource,
@@ -13301,7 +13298,6 @@ function resolveCopilotCliConfig(target, env, evalFilePath) {
     model,
     args,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     logDir,
     logFormat,
@@ -13316,14 +13312,13 @@ function normalizeCopilotLogFormat(value) {
   if (normalized === "json" || normalized === "summary") return normalized;
   throw new Error("copilot log format must be 'summary' or 'json'");
 }
-function resolvePiCodingAgentConfig(target, env, evalFilePath) {
+function resolvePiCodingAgentConfig(target, env, _evalFilePath) {
   const subproviderSource = target.subprovider;
   const modelSource = target.model ?? target.pi_model;
   const apiKeySource = target.api_key;
   const toolsSource = target.tools ?? target.pi_tools;
   const thinkingSource = target.thinking ?? target.pi_thinking;
   const cwdSource = target.cwd;
-  const workspaceTemplateSource = target.workspace_template;
   const timeoutSource = target.timeout_seconds;
   const logDirSource = target.log_dir ?? target.log_directory;
   const logFormatSource = target.log_format;
@@ -13367,23 +13362,6 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${target.name} pi workspace template`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
-  if (cwd && workspaceTemplate) {
-    throw new Error(
-      `${target.name}: 'cwd' and 'workspace_template' are mutually exclusive. Use 'cwd' to run in an existing directory, or 'workspace_template' to copy a template to a temp location.`
-    );
-  }
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} pi timeout`);
   const logDir = resolveOptionalString(logDirSource, env, `${target.name} pi log directory`, {
     allowLiteral: true,
@@ -13399,7 +13377,6 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
     tools,
     thinking,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     logDir,
     logFormat,
@@ -13407,7 +13384,7 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
     systemPrompt
   };
 }
-function resolvePiCliConfig(target, env, evalFilePath) {
+function resolvePiCliConfig(target, env, _evalFilePath) {
   const executableSource = target.executable ?? target.command ?? target.binary;
   const subproviderSource = target.subprovider;
   const modelSource = target.model ?? target.pi_model;
@@ -13415,7 +13392,6 @@ function resolvePiCliConfig(target, env, evalFilePath) {
   const toolsSource = target.tools ?? target.pi_tools;
   const thinkingSource = target.thinking ?? target.pi_thinking;
   const cwdSource = target.cwd;
-  const workspaceTemplateSource = target.workspace_template;
   const timeoutSource = target.timeout_seconds;
   const logDirSource = target.log_dir ?? target.log_directory;
   const logFormatSource = target.log_format;
@@ -13462,18 +13438,6 @@ function resolvePiCliConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${target.name} pi-cli workspace template`,
-    { allowLiteral: true, optionalEnv: true }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
-  if (cwd && workspaceTemplate) {
-    throw new Error(`${target.name}: 'cwd' and 'workspace_template' are mutually exclusive.`);
-  }
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} pi-cli timeout`);
   const logDir = resolveOptionalString(logDirSource, env, `${target.name} pi-cli log directory`, {
     allowLiteral: true,
@@ -13491,7 +13455,6 @@ function resolvePiCliConfig(target, env, evalFilePath) {
     thinking,
     args,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     logDir,
     logFormat,
@@ -13499,10 +13462,10 @@ function resolvePiCliConfig(target, env, evalFilePath) {
     systemPrompt
   };
 }
-function resolveClaudeConfig(target, env, evalFilePath) {
+function resolveClaudeConfig(target, env, _evalFilePath) {
+  const executableSource = target.executable ?? target.command ?? target.binary;
   const modelSource = target.model;
   const cwdSource = target.cwd;
-  const workspaceTemplateSource = target.workspace_template;
   const timeoutSource = target.timeout_seconds;
   const logDirSource = target.log_dir ?? target.log_directory;
   const logFormatSource = target.log_format ?? target.log_output_format ?? env.AGENTV_CLAUDE_LOG_FORMAT;
@@ -13512,6 +13475,10 @@ function resolveClaudeConfig(target, env, evalFilePath) {
     process.stderr.write(`[agentv] \u26A0 ${streamLogResult.deprecationWarning}
 `);
   }
+  const executable = resolveOptionalString(executableSource, env, `${target.name} claude-cli executable`, {
+    allowLiteral: true,
+    optionalEnv: true
+  }) ?? "claude";
   const model = resolveOptionalString(modelSource, env, `${target.name} claude model`, {
     allowLiteral: true,
     optionalEnv: true
@@ -13520,23 +13487,6 @@ function resolveClaudeConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  let workspaceTemplate = resolveOptionalString(
-    workspaceTemplateSource,
-    env,
-    `${target.name} claude workspace template`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  );
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
-  if (cwd && workspaceTemplate) {
-    throw new Error(
-      `${target.name}: 'cwd' and 'workspace_template' are mutually exclusive. Use 'cwd' to run in an existing directory, or 'workspace_template' to copy a template to a temp location.`
-    );
-  }
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} claude timeout`);
   const logDir = resolveOptionalString(logDirSource, env, `${target.name} claude log directory`, {
     allowLiteral: true,
@@ -13547,10 +13497,10 @@ function resolveClaudeConfig(target, env, evalFilePath) {
   const maxTurns = typeof target.max_turns === "number" ? target.max_turns : void 0;
   const maxBudgetUsd = typeof target.max_budget_usd === "number" ? target.max_budget_usd : void 0;
   return {
+    executable,
     model,
     systemPrompt,
     cwd,
-    workspaceTemplate,
     timeoutMs,
     maxTurns,
     maxBudgetUsd,
@@ -13559,6 +13509,28 @@ function resolveClaudeConfig(target, env, evalFilePath) {
     streamLog: streamLogResult.streamLog
   };
 }
+function resolveCcMirrorBinaryPath(variant) {
+  const variantJsonPath = import_node_path26.default.join((0, import_node_os8.homedir)(), ".cc-mirror", variant, "variant.json");
+  if (!(0, import_node_fs12.existsSync)(variantJsonPath)) {
+    throw new Error(
+      `cc-mirror variant "${variant}": ${variantJsonPath} not found. Install the variant or set "executable" explicitly.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs12.readFileSync)(variantJsonPath, "utf8"));
+  } catch (e) {
+    throw new Error(
+      `cc-mirror variant "${variant}": failed to parse ${variantJsonPath}: ${e.message}`
+    );
+  }
+  if (typeof parsed.binaryPath !== "string" || parsed.binaryPath.trim().length === 0) {
+    throw new Error(
+      `cc-mirror variant "${variant}": ${variantJsonPath} missing "binaryPath" field`
+    );
+  }
+  return parsed.binaryPath;
+}
 function normalizeClaudeLogFormat(value) {
   if (value === void 0 || value === null) {
     return void 0;
@@ -13576,20 +13548,7 @@ function resolveMockConfig(target) {
   const response = typeof target.response === "string" ? target.response : void 0;
   return { response };
 }
-function resolveVSCodeConfig(target, env, insiders, evalFilePath) {
-  const workspaceTemplateEnvVar = resolveOptionalLiteralString(target.workspace_template);
-  let workspaceTemplate = workspaceTemplateEnvVar ? resolveOptionalString(
-    workspaceTemplateEnvVar,
-    env,
-    `${target.name} workspace template path`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
-  ) : void 0;
-  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
-  }
+function resolveVSCodeConfig(target, env, insiders, _evalFilePath) {
   const executableSource = target.executable;
   const waitSource = target.wait;
   const dryRunSource = target.dry_run;
@@ -13609,7 +13568,6 @@ function resolveVSCodeConfig(target, env, insiders, evalFilePath) {
       allowLiteral: true,
       optionalEnv: true
     }),
-    workspaceTemplate,
     timeoutMs
   };
 }
@@ -13891,12 +13849,12 @@ var import_node_path35 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
+var import_node_fs13 = require("fs");
 var import_promises23 = require("fs/promises");
 var import_node_path27 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises23.access)(target, import_node_fs12.constants.F_OK);
+    await (0, import_promises23.access)(target, import_node_fs13.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -15035,7 +14993,7 @@ var VSCodeProvider = class {
     await this.ensureEnvironmentReady();
     const inputFiles = normalizeAttachments(request.inputFiles);
     const promptContent = buildPromptDocument2(request, inputFiles);
-    const workspaceTemplate = request.workspaceFile ?? await resolveWorkspaceTemplateFile(this.config.workspaceTemplate);
+    const workspaceTemplate = request.workspaceFile;
     const startTime = Date.now();
     const session = await dispatchAgentSession({
       userQuery: promptContent,
@@ -15091,9 +15049,6 @@ var VSCodeProvider = class {
     const userQueries = normalizedRequests.map(
       ({ request, inputFiles }) => buildPromptDocument2(request, inputFiles)
     );
-    const batchWorkspaceTemplate = await resolveWorkspaceTemplateFile(
-      this.config.workspaceTemplate
-    );
     const startTime = Date.now();
     const session = await dispatchBatchAgent({
       userQueries,
@@ -15103,7 +15058,7 @@ var VSCodeProvider = class {
       dryRun: this.config.dryRun,
       vscodeCmd: this.config.executable,
       subagentRoot: this.config.subagentRoot,
-      workspaceTemplate: batchWorkspaceTemplate,
+      workspaceTemplate: void 0,
       silent: true,
       timeoutMs: this.config.timeoutMs
     });
@@ -15183,17 +15138,6 @@ async function locateVSCodeExecutable(candidate) {
     `VS Code executable '${candidate}' was not found on PATH. Check the 'executable' setting in your target configuration.`
   );
 }
-async function resolveWorkspaceTemplateFile(template) {
-  if (!template) {
-    return void 0;
-  }
-  try {
-    const stats = await (0, import_promises29.stat)(import_node_path37.default.resolve(template));
-    return stats.isFile() ? template : void 0;
-  } catch {
-    return template;
-  }
-}
 function buildPromptDocument2(request, attachments) {
   const parts = [];
   if (request.systemPrompt && request.systemPrompt.trim().length > 0) {
@@ -15356,7 +15300,7 @@ function isAgentProvider(provider) {
 
 // src/evaluation/providers/targets-file.ts
 init_cjs_shims();
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_promises30 = require("fs/promises");
 var import_node_path38 = __toESM(require("path"), 1);
 var import_yaml8 = require("yaml");
@@ -15391,7 +15335,7 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises30.access)(filePath, import_node_fs13.constants.F_OK);
+    await (0, import_promises30.access)(filePath, import_node_fs14.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -15575,7 +15519,7 @@ function negateScore(score) {
 // src/evaluation/evaluators/code-evaluator.ts
 init_cjs_shims();
 var import_promises31 = require("fs/promises");
-var import_node_os8 = require("os");
+var import_node_os9 = require("os");
 var import_node_path40 = require("path");
 init_exec();
 
@@ -15940,7 +15884,7 @@ var CodeEvaluator = class {
     let imageTmpDir;
     const getImageDir = async () => {
       if (!imageTmpDir) {
-        imageTmpDir = await (0, import_promises31.mkdtemp)((0, import_node_path40.join)((0, import_node_os8.tmpdir)(), "agentv-img-"));
+        imageTmpDir = await (0, import_promises31.mkdtemp)((0, import_node_path40.join)((0, import_node_os9.tmpdir)(), "agentv-img-"));
       }
       return imageTmpDir;
     };
@@ -15953,7 +15897,7 @@ var CodeEvaluator = class {
     if (outputForPayload) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
-        const tmpDir = await (0, import_promises31.mkdtemp)((0, import_node_path40.join)((0, import_node_os8.tmpdir)(), "agentv-grader-"));
+        const tmpDir = await (0, import_promises31.mkdtemp)((0, import_node_path40.join)((0, import_node_os9.tmpdir)(), "agentv-grader-"));
         outputPath = (0, import_node_path40.join)(tmpDir, "output.json");
         await (0, import_promises31.writeFile)(outputPath, serialized);
         outputForPayload = null;
@@ -16452,7 +16396,7 @@ ${context2.fileChanges}`;
     const workspacePath = context2.workspacePath;
     if (!workspacePath) {
       throw new Error(
-        "llm-grader built-in agent mode requires a workspace_template target (workspacePath is not set)"
+        "llm-grader built-in agent mode requires a workspace (workspacePath is not set)"
       );
     }
     const systemPrompt = this.buildAgentSystemPrompt(context2);
@@ -17191,11 +17135,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat13 = await import_promises32.default.stat(resolved);
-          if (stat13.isDirectory()) {
+          const stat12 = await import_promises32.default.stat(resolved);
+          if (stat12.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
-          const buffer = Buffer.alloc(Math.min(stat13.size, MAX_FILE_SIZE));
+          const buffer = Buffer.alloc(Math.min(stat12.size, MAX_FILE_SIZE));
           const fd = await import_promises32.default.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -17203,8 +17147,8 @@ function createFilesystemTools(workspacePath) {
             await fd.close();
           }
           const content = buffer.toString("utf-8");
-          const truncated = stat13.size > MAX_FILE_SIZE;
-          return { content, truncated, size: stat13.size };
+          const truncated = stat12.size > MAX_FILE_SIZE;
+          return { content, truncated, size: stat12.size };
         } catch (error) {
           return { error: error instanceof Error ? error.message : String(error) };
         }
@@ -17255,8 +17199,8 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
       const ext = import_node_path41.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat13 = await import_promises32.default.stat(fullPath);
-        if (stat13.size > MAX_FILE_SIZE) continue;
+        const stat12 = await import_promises32.default.stat(fullPath);
+        if (stat12.size > MAX_FILE_SIZE) continue;
         const content = await import_promises32.default.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -19159,7 +19103,7 @@ function runEqualsAssertion(output, value) {
 init_cjs_shims();
 var import_node_child_process11 = require("child_process");
 var import_node_crypto11 = require("crypto");
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_promises36 = require("fs/promises");
 var import_node_path49 = __toESM(require("path"), 1);
 var import_node_util7 = require("util");
@@ -20064,7 +20008,7 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 init_cjs_shims();
 var import_node_child_process9 = require("child_process");
 var import_node_crypto10 = require("crypto");
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_promises34 = require("fs/promises");
 var import_node_path46 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
@@ -20172,7 +20116,7 @@ var WorkspacePoolManager = class {
       if (!locked) {
         continue;
       }
-      const slotExists = (0, import_node_fs14.existsSync)(slotPath);
+      const slotExists = (0, import_node_fs15.existsSync)(slotPath);
       if (slotExists) {
         await this.resetSlot(slotPath, templatePath, repos, poolReset);
         return {
@@ -20278,7 +20222,7 @@ var WorkspacePoolManager = class {
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
         const lockPath = import_node_path46.default.join(poolDir, `${entry}.lock`);
-        if ((0, import_node_fs14.existsSync)(lockPath)) {
+        if ((0, import_node_fs15.existsSync)(lockPath)) {
           try {
             const pidStr = await (0, import_promises34.readFile)(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
@@ -20310,7 +20254,7 @@ var WorkspacePoolManager = class {
     for (const repo of repos) {
       if (!repo.path || !repo.source) continue;
       const repoDir = import_node_path46.default.join(slotPath, repo.path);
-      if (!(0, import_node_fs14.existsSync)(repoDir)) {
+      if (!(0, import_node_fs15.existsSync)(repoDir)) {
         continue;
       }
       if (poolReset === "none") {
@@ -20346,7 +20290,7 @@ var WorkspacePoolManager = class {
 // src/evaluation/workspace/repo-manager.ts
 init_cjs_shims();
 var import_node_child_process10 = require("child_process");
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_path47 = __toESM(require("path"), 1);
 var import_node_util6 = require("util");
 var execFileAsync2 = (0, import_node_util6.promisify)(import_node_child_process10.execFile);
@@ -20398,7 +20342,7 @@ var RepoManager = class {
           resolvedSourcePath: sourcePath ?? "",
           reason: "empty_path"
         });
-      } else if (!(0, import_node_fs15.existsSync)(sourcePath)) {
+      } else if (!(0, import_node_fs16.existsSync)(sourcePath)) {
         errors.push({
           repoPath: repo.path ?? "(none)",
           resolvedSourcePath: sourcePath,
@@ -20692,7 +20636,7 @@ function workspaceGitEnv() {
   };
 }
 async function resetWorkspaceRoot(workspacePath, resetMode, baselineRef) {
-  if (!(0, import_node_fs16.existsSync)(import_node_path49.default.join(workspacePath, ".git"))) {
+  if (!(0, import_node_fs17.existsSync)(import_node_path49.default.join(workspacePath, ".git"))) {
     return false;
   }
   const cleanFlag = resetMode === "strict" ? "-fdx" : "-fd";
@@ -20706,13 +20650,6 @@ async function resetWorkspaceRoot(workspacePath, resetMode, baselineRef) {
   await execFileAsync3("git", ["clean", cleanFlag], opts);
   return true;
 }
-function getWorkspaceTemplate(target) {
-  const config = target.config;
-  if ("workspaceTemplate" in config && typeof config.workspaceTemplate === "string") {
-    return config.workspaceTemplate;
-  }
-  return void 0;
-}
 function validateDependencyGraph(tests) {
   const ids = /* @__PURE__ */ new Set();
   for (const test of tests) {
@@ -20986,7 +20923,7 @@ async function runEvaluation(options) {
     }
   }
   const suiteWorkspace = filteredEvalCases[0]?.workspace;
-  const rawTemplate = suiteWorkspace?.template ?? getWorkspaceTemplate(target);
+  const rawTemplate = suiteWorkspace?.template;
   const resolvedTemplate = await resolveWorkspaceTemplate(rawTemplate);
   const workspaceTemplate = resolvedTemplate?.dir;
   let suiteWorkspaceFile = resolvedTemplate?.workspaceFile;
@@ -21184,7 +21121,7 @@ async function runEvaluation(options) {
           for (const repo of suiteWorkspace.repos) {
             if (!repo.path || !repo.source) continue;
             const targetDir = import_node_path49.default.join(sharedWorkspacePath, repo.path);
-            if ((0, import_node_fs16.existsSync)(targetDir)) {
+            if ((0, import_node_fs17.existsSync)(targetDir)) {
               setupLog(`reusing existing repo at: ${targetDir}`);
               continue;
             }
@@ -21274,6 +21211,54 @@ async function runEvaluation(options) {
         }
       }
     }
+    const targetHooks = options.targetHooks;
+    const targetBeforeAllHook = targetHooks?.before_all;
+    if (sharedWorkspacePath && hasHookCommand(targetBeforeAllHook)) {
+      const beforeAllCommand = (targetBeforeAllHook.command ?? []).join(" ");
+      setupLog(`running target before_all command=${beforeAllCommand}`);
+      const scriptContext = {
+        workspacePath: sharedWorkspacePath,
+        testId: "__target_before_all__",
+        evalRunId,
+        evalDir,
+        workspaceFileDir: suiteWorkspace?.workspaceFileDir
+      };
+      try {
+        await executeWorkspaceScript(
+          toScriptConfig(targetBeforeAllHook, "before_all", "target hooks"),
+          scriptContext
+        );
+        setupLog("target before_all completed");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (sharedWorkspacePath && !useStaticWorkspace) {
+          await cleanupWorkspace(sharedWorkspacePath).catch(() => {
+          });
+        }
+        throw new Error(`target before_all hook failed: ${message}`);
+      }
+    }
+    if (availablePoolSlots.length > 0 && hasHookCommand(targetBeforeAllHook)) {
+      for (const slot of availablePoolSlots) {
+        setupLog(`running target before_all on pool slot ${slot.index}`);
+        const scriptContext = {
+          workspacePath: slot.path,
+          testId: "__target_before_all__",
+          evalRunId,
+          evalDir,
+          workspaceFileDir: suiteWorkspace?.workspaceFileDir
+        };
+        try {
+          await executeWorkspaceScript(
+            toScriptConfig(targetBeforeAllHook, "before_all", "target hooks"),
+            scriptContext
+          );
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error(`target before_all hook failed on pool slot ${slot.index}: ${message}`);
+        }
+      }
+    }
     if (sharedWorkspacePath) {
       try {
         sharedBaselineCommit = await initializeBaseline(sharedWorkspacePath);
@@ -21419,6 +21404,7 @@ async function runEvaluation(options) {
           evalDir,
           verbose,
           threshold: scoreThreshold,
+          targetHooks: options.targetHooks,
           ...depResults && Object.keys(depResults).length > 0 ? { dependencyResults: depResults } : {}
         };
         let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
@@ -21560,6 +21546,26 @@ async function runEvaluation(options) {
       }
     }
     const afterAllWorkspaces = poolSlots.length > 1 ? poolSlots.map((s) => s.path) : sharedWorkspacePath ? [sharedWorkspacePath] : [];
+    const targetAfterAllHook = targetHooks?.after_all;
+    if (afterAllWorkspaces.length > 0 && hasHookCommand(targetAfterAllHook)) {
+      for (const wsPath of afterAllWorkspaces) {
+        const scriptContext = {
+          workspacePath: wsPath,
+          testId: "__target_after_all__",
+          evalRunId,
+          evalDir,
+          workspaceFileDir: suiteWorkspace?.workspaceFileDir
+        };
+        try {
+          await executeWorkspaceScript(
+            toScriptConfig(targetAfterAllHook, "after_all", "target hooks"),
+            scriptContext,
+            "warn"
+          );
+        } catch {
+        }
+      }
+    }
     const suiteAfterAllHook = suiteWorkspace?.hooks?.after_all;
     if (afterAllWorkspaces.length > 0 && suiteHooksEnabled && hasHookCommand(suiteAfterAllHook)) {
       const afterAllHook = suiteAfterAllHook;
@@ -21822,7 +21828,7 @@ async function runEvalCase(options) {
   let caseWorkspaceFile;
   const caseHooksEnabled = hooksEnabled(evalCase.workspace);
   if (!workspacePath) {
-    const rawCaseTemplate = evalCase.workspace?.template ?? getWorkspaceTemplate(target);
+    const rawCaseTemplate = evalCase.workspace?.template;
     const resolvedCaseTemplate = await resolveWorkspaceTemplate(rawCaseTemplate);
     const caseWorkspaceTemplate = resolvedCaseTemplate?.dir;
     caseWorkspaceFile = resolvedCaseTemplate?.workspaceFile;
@@ -22040,6 +22046,38 @@ async function runEvalCase(options) {
       );
     }
   }
+  const targetBeforeEachHook = options.targetHooks?.before_each;
+  if (workspacePath && hasHookCommand(targetBeforeEachHook)) {
+    const scriptContext = {
+      workspacePath,
+      testId: evalCase.id,
+      evalRunId: evalRunId ?? "",
+      caseInput: evalCase.question,
+      caseMetadata: evalCase.metadata,
+      evalDir,
+      workspaceFileDir: evalCase.workspace?.workspaceFileDir
+    };
+    try {
+      await executeWorkspaceScript(
+        toScriptConfig(targetBeforeEachHook, "before_each", `target hook for '${evalCase.id}'`),
+        scriptContext
+      );
+      beforeEachNeedsFreshBaseline = true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return buildErrorResult(
+        evalCase,
+        target.name,
+        nowFn(),
+        new Error(`target before_each hook failed: ${message}`),
+        promptInputs,
+        provider,
+        "setup",
+        "script_error",
+        verbose
+      );
+    }
+  }
   let baselineCommit = beforeEachNeedsFreshBaseline ? void 0 : sharedBaselineCommit;
   if (!baselineCommit && workspacePath) {
     try {
@@ -22194,6 +22232,26 @@ async function runEvalCase(options) {
 ${providerFileChanges}` : providerFileChanges;
   }
   const providerError = extractProviderError(providerResponse);
+  const targetAfterEachHook = options.targetHooks?.after_each;
+  if (workspacePath && hasHookCommand(targetAfterEachHook)) {
+    const scriptContext = {
+      workspacePath,
+      testId: evalCase.id,
+      evalRunId: evalRunId ?? "",
+      caseInput: evalCase.question,
+      caseMetadata: evalCase.metadata,
+      evalDir,
+      workspaceFileDir: evalCase.workspace?.workspaceFileDir
+    };
+    try {
+      await executeWorkspaceScript(
+        toScriptConfig(targetAfterEachHook, "after_each", `target hook for '${evalCase.id}'`),
+        scriptContext,
+        "warn"
+      );
+    } catch {
+    }
+  }
   if (caseHooksEnabled && workspacePath && evalCase.workspace?.hooks?.after_each?.reset && evalCase.workspace.hooks.after_each.reset !== "none") {
     try {
       if (repoManager && evalCase.workspace.repos?.length) {
@@ -23324,7 +23382,7 @@ function computeWeightedMean(entries) {
 
 // src/evaluation/evaluate.ts
 init_cjs_shims();
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_path50 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/function-provider.ts
@@ -23482,7 +23540,7 @@ async function discoverDefaultTarget(repoRoot) {
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
       const targetsPath = import_node_path50.default.join(dir, candidate);
-      if (!(0, import_node_fs17.existsSync)(targetsPath)) continue;
+      if (!(0, import_node_fs18.existsSync)(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -23494,16 +23552,16 @@ async function discoverDefaultTarget(repoRoot) {
   return null;
 }
 async function loadEnvHierarchy(repoRoot, startPath) {
-  const { readFileSync: readFileSync5 } = await import("fs");
+  const { readFileSync: readFileSync6 } = await import("fs");
   const chain = buildDirectoryChain2(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
     const envPath = import_node_path50.default.join(dir, ".env");
-    if ((0, import_node_fs17.existsSync)(envPath)) envFiles.push(envPath);
+    if ((0, import_node_fs18.existsSync)(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
-      const content = readFileSync5(envFiles[i], "utf8");
+      const content = readFileSync6(envFiles[i], "utf8");
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed || trimmed.startsWith("#")) continue;
@@ -23576,12 +23634,12 @@ var CONFIG_FILE_NAMES = [
   ".agentv/config.js"
 ];
 async function loadTsConfig(projectRoot) {
-  const { existsSync: existsSync9 } = await import("fs");
+  const { existsSync: existsSync10 } = await import("fs");
   const { pathToFileURL: pathToFileURL2 } = await import("url");
   const { join: join2 } = await import("path");
   for (const fileName of CONFIG_FILE_NAMES) {
     const filePath = join2(projectRoot, fileName);
-    if (!existsSync9(filePath)) {
+    if (!existsSync10(filePath)) {
       continue;
     }
     try {
@@ -23830,9 +23888,9 @@ function shouldSkipCacheForTemperature(targetConfig) {
 // src/evaluation/results-repo.ts
 init_cjs_shims();
 var import_node_child_process12 = require("child_process");
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_promises39 = require("fs/promises");
-var import_node_os9 = __toESM(require("os"), 1);
+var import_node_os10 = __toESM(require("os"), 1);
 var import_node_path53 = __toESM(require("path"), 1);
 var import_node_util8 = require("util");
 var execFileAsync4 = (0, import_node_util8.promisify)(import_node_child_process12.execFile);
@@ -23870,18 +23928,18 @@ function getResultsRepoCachePaths(repo) {
   };
 }
 function readPersistedStatus(statusFile) {
-  if (!(0, import_node_fs18.existsSync)(statusFile)) {
+  if (!(0, import_node_fs19.existsSync)(statusFile)) {
     return {};
   }
   try {
-    return JSON.parse((0, import_node_fs18.readFileSync)(statusFile, "utf8"));
+    return JSON.parse((0, import_node_fs19.readFileSync)(statusFile, "utf8"));
   } catch {
     return {};
   }
 }
 function writePersistedStatus(statusFile, status) {
-  (0, import_node_fs18.mkdirSync)(import_node_path53.default.dirname(statusFile), { recursive: true });
-  (0, import_node_fs18.writeFileSync)(statusFile, `${JSON.stringify(status, null, 2)}
+  (0, import_node_fs19.mkdirSync)(import_node_path53.default.dirname(statusFile), { recursive: true });
+  (0, import_node_fs19.writeFileSync)(statusFile, `${JSON.stringify(status, null, 2)}
 `, "utf8");
 }
 async function runCommand(executable, args, options) {
@@ -23943,8 +24001,8 @@ function updateStatusFile(config, patch) {
 async function ensureResultsRepoClone(config) {
   const normalized = normalizeResultsExportConfig(config);
   const cachePaths = getResultsRepoCachePaths(normalized.repo);
-  (0, import_node_fs18.mkdirSync)(cachePaths.rootDir, { recursive: true });
-  if (!(0, import_node_fs18.existsSync)(cachePaths.repoDir)) {
+  (0, import_node_fs19.mkdirSync)(cachePaths.rootDir, { recursive: true });
+  if (!(0, import_node_fs19.existsSync)(cachePaths.repoDir)) {
     try {
       await runGit([
         "clone",
@@ -23958,7 +24016,7 @@ async function ensureResultsRepoClone(config) {
       throw withFriendlyGitHubAuthError(error);
     }
   }
-  if (!(0, import_node_fs18.existsSync)(import_node_path53.default.join(cachePaths.repoDir, ".git"))) {
+  if (!(0, import_node_fs19.existsSync)(import_node_path53.default.join(cachePaths.repoDir, ".git"))) {
     throw new Error(`Results repo cache is not a git repository: ${cachePaths.repoDir}`);
   }
   return cachePaths.repoDir;
@@ -23977,7 +24035,7 @@ function getResultsRepoStatus(config) {
   const persisted = readPersistedStatus(cachePaths.statusFile);
   return {
     configured: true,
-    available: (0, import_node_fs18.existsSync)(cachePaths.repoDir),
+    available: (0, import_node_fs19.existsSync)(cachePaths.repoDir),
     repo: normalized.repo,
     path: normalized.path,
     auto_push: normalized.auto_push,
@@ -24023,7 +24081,7 @@ async function prepareResultsRepoBranch(config, branchName) {
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
   await updateCacheRepo(cloneDir, baseBranch);
-  const worktreeRoot = await (0, import_promises39.mkdtemp)(import_node_path53.default.join(import_node_os9.default.tmpdir(), "agentv-results-repo-"));
+  const worktreeRoot = await (0, import_promises39.mkdtemp)(import_node_path53.default.join(import_node_os10.default.tmpdir(), "agentv-results-repo-"));
   const worktreeDir = import_node_path53.default.join(worktreeRoot, "repo");
   await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
     cwd: cloneDir
@@ -24042,8 +24100,8 @@ async function prepareResultsRepoBranch(config, branchName) {
   };
 }
 async function stageResultsArtifacts(params) {
-  (0, import_node_fs18.rmSync)(params.destinationDir, { recursive: true, force: true });
-  (0, import_node_fs18.mkdirSync)(import_node_path53.default.dirname(params.destinationDir), { recursive: true });
+  (0, import_node_fs19.rmSync)(params.destinationDir, { recursive: true, force: true });
+  (0, import_node_fs19.mkdirSync)(import_node_path53.default.dirname(params.destinationDir), { recursive: true });
   await (0, import_promises39.cp)(params.sourceDir, params.destinationDir, { recursive: true });
 }
 function resolveResultsRepoRunsDir(config) {
@@ -24111,19 +24169,31 @@ async function createDraftResultsPr(params) {
 
 // src/benchmarks.ts
 init_cjs_shims();
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_path54 = __toESM(require("path"), 1);
 var import_yaml10 = require("yaml");
 function getBenchmarksRegistryPath() {
-  return import_node_path54.default.join(getAgentvHome(), "projects.yaml");
+  return import_node_path54.default.join(getAgentvConfigDir(), "projects.yaml");
+}
+function migrateProjectsYaml(targetPath) {
+  const dataHome = getAgentvHome();
+  const configDir = getAgentvConfigDir();
+  if (dataHome === configDir) return;
+  const legacyPath = import_node_path54.default.join(dataHome, "projects.yaml");
+  if (!(0, import_node_fs20.existsSync)(legacyPath)) return;
+  (0, import_node_fs20.mkdirSync)(import_node_path54.default.dirname(targetPath), { recursive: true });
+  (0, import_node_fs20.copyFileSync)(legacyPath, targetPath);
 }
 function loadBenchmarkRegistry() {
   const registryPath = getBenchmarksRegistryPath();
-  if (!(0, import_node_fs19.existsSync)(registryPath)) {
+  if (!(0, import_node_fs20.existsSync)(registryPath)) {
+    migrateProjectsYaml(registryPath);
+  }
+  if (!(0, import_node_fs20.existsSync)(registryPath)) {
     return { benchmarks: [] };
   }
   try {
-    const raw = (0, import_node_fs19.readFileSync)(registryPath, "utf-8");
+    const raw = (0, import_node_fs20.readFileSync)(registryPath, "utf-8");
     const parsed = (0, import_yaml10.parse)(raw);
     if (!parsed || !Array.isArray(parsed.benchmarks)) {
       return { benchmarks: [] };
@@ -24136,10 +24206,10 @@ function loadBenchmarkRegistry() {
 function saveBenchmarkRegistry(registry) {
   const registryPath = getBenchmarksRegistryPath();
   const dir = import_node_path54.default.dirname(registryPath);
-  if (!(0, import_node_fs19.existsSync)(dir)) {
-    (0, import_node_fs19.mkdirSync)(dir, { recursive: true });
+  if (!(0, import_node_fs20.existsSync)(dir)) {
+    (0, import_node_fs20.mkdirSync)(dir, { recursive: true });
   }
-  (0, import_node_fs19.writeFileSync)(registryPath, (0, import_yaml10.stringify)({ benchmarks: registry.benchmarks }), "utf-8");
+  (0, import_node_fs20.writeFileSync)(registryPath, (0, import_yaml10.stringify)({ benchmarks: registry.benchmarks }), "utf-8");
 }
 function deriveBenchmarkId(dirPath, existingIds) {
   const base = import_node_path54.default.basename(dirPath).toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
@@ -24153,10 +24223,10 @@ function deriveBenchmarkId(dirPath, existingIds) {
 }
 function addBenchmark(benchmarkPath) {
   const absPath = import_node_path54.default.resolve(benchmarkPath);
-  if (!(0, import_node_fs19.existsSync)(absPath)) {
+  if (!(0, import_node_fs20.existsSync)(absPath)) {
     throw new Error(`Directory not found: ${absPath}`);
   }
-  if (!(0, import_node_fs19.existsSync)(import_node_path54.default.join(absPath, ".agentv"))) {
+  if (!(0, import_node_fs20.existsSync)(import_node_path54.default.join(absPath, ".agentv"))) {
     throw new Error(`No .agentv/ directory found in ${absPath}. Run an evaluation first.`);
   }
   const registry = loadBenchmarkRegistry();
@@ -24200,19 +24270,19 @@ function touchBenchmark(benchmarkId) {
 }
 function discoverBenchmarks(rootDir, maxDepth = 2) {
   const absRoot = import_node_path54.default.resolve(rootDir);
-  if (!(0, import_node_fs19.existsSync)(absRoot) || !(0, import_node_fs19.statSync)(absRoot).isDirectory()) {
+  if (!(0, import_node_fs20.existsSync)(absRoot) || !(0, import_node_fs20.statSync)(absRoot).isDirectory()) {
     return [];
   }
   const results = [];
   function scan(dir, depth) {
     if (depth > maxDepth) return;
-    if ((0, import_node_fs19.existsSync)(import_node_path54.default.join(dir, ".agentv"))) {
+    if ((0, import_node_fs20.existsSync)(import_node_path54.default.join(dir, ".agentv"))) {
       results.push(dir);
       return;
     }
     if (depth === maxDepth) return;
     try {
-      const entries = (0, import_node_fs19.readdirSync)(dir, { withFileTypes: true });
+      const entries = (0, import_node_fs20.readdirSync)(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
@@ -25153,9 +25223,9 @@ function extractResponseItemContent(content) {
 // src/import/codex-session-discovery.ts
 init_cjs_shims();
 var import_promises41 = require("fs/promises");
-var import_node_os10 = require("os");
+var import_node_os11 = require("os");
 var import_node_path56 = __toESM(require("path"), 1);
-var DEFAULT_SESSIONS_DIR = () => import_node_path56.default.join((0, import_node_os10.homedir)(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => import_node_path56.default.join((0, import_node_os11.homedir)(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
@@ -25219,9 +25289,9 @@ async function discoverCodexSessions(opts) {
 // src/import/session-discovery.ts
 init_cjs_shims();
 var import_promises42 = require("fs/promises");
-var import_node_os11 = require("os");
+var import_node_os12 = require("os");
 var import_node_path57 = __toESM(require("path"), 1);
-var DEFAULT_PROJECTS_DIR = () => import_node_path57.default.join((0, import_node_os11.homedir)(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => import_node_path57.default.join((0, import_node_os12.homedir)(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -25515,6 +25585,7 @@ function createAgentKernel() {
   extractJsonBlob,
   extractLastAssistantContent,
   extractTargetFromSuite,
+  extractTargetRefsFromSuite,
   extractTargetsFromSuite,
   extractTargetsFromTestCase,
   extractThreshold,
@@ -25524,6 +25595,7 @@ function createAgentKernel() {
   findGitRoot,
   freeformEvaluationSchema,
   generateRubrics,
+  getAgentvConfigDir,
   getAgentvHome,
   getBenchmark,
   getBenchmarksRegistryPath,