agentv 0.23.0 → 0.25.0

package/dist/{chunk-4T62HFF4.js → chunk-ZVSFP6NK.js}

@@ -146,7 +146,7 @@ import { binary, run, subcommands as subcommands2 } from "cmd-ts";
 
 // src/commands/eval/index.ts
 import { stat as stat4 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 import {
   command,
   flag,
@@ -161,13 +161,14 @@ import fg from "fast-glob";
 // src/commands/eval/run-eval.ts
 import { constants as constants6 } from "node:fs";
 import { access as access6, mkdir as mkdir7 } from "node:fs/promises";
-import path18 from "node:path";
+import path19 from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../../packages/core/dist/chunk-B2J23S7D.js
+// ../../packages/core/dist/chunk-OYTL3LNN.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
+import path2 from "node:path";
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -647,8 +648,8 @@ function getErrorMap() {
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path26, errorMaps, issueData } = params;
-  const fullPath = [...path26, ...issueData.path || []];
+  const { data, path: path27, errorMaps, issueData } = params;
+  const fullPath = [...path27, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -764,11 +765,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path26, key2) {
+  constructor(parent, value, path27, key2) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path26;
+    this._path = path27;
     this._key = key2;
   }
   get path() {
@@ -4210,7 +4211,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-B2J23S7D.js
+// ../../packages/core/dist/chunk-OYTL3LNN.js
 async function fileExists(filePath) {
   try {
     await access(filePath, constants.F_OK);
@@ -4226,6 +4227,10 @@ async function readTextFile(filePath) {
   const content = await readFile(filePath, "utf8");
   return normalizeLineEndings(content);
 }
+async function readJsonFile(filePath) {
+  const content = await readFile(filePath, "utf8");
+  return JSON.parse(content);
+}
 async function findGitRoot(startPath) {
   let currentDir = path.dirname(path.resolve(startPath));
   const root2 = path.parse(currentDir).root;
@@ -4331,7 +4336,7 @@ var BASE_TARGET_SCHEMA = external_exports.object({
   judge_target: external_exports.string().optional(),
   workers: external_exports.number().int().min(1).optional()
 }).passthrough();
-var DEFAULT_AZURE_API_VERSION = "2024-10-01-preview";
+var DEFAULT_AZURE_API_VERSION = "2024-12-01-preview";
 function normalizeAzureApiVersion(value) {
   if (!value) {
     return DEFAULT_AZURE_API_VERSION;
@@ -4375,7 +4380,7 @@ function resolveRetryConfig(target) {
     retryableStatusCodes
   };
 }
-function resolveTargetDefinition(definition, env = process.env) {
+function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
   const parsed = BASE_TARGET_SCHEMA.parse(definition);
   const provider = parsed.provider.toLowerCase();
   const providerBatching = resolveOptionalBoolean(
@@ -4448,7 +4453,7 @@ function resolveTargetDefinition(definition, env = process.env) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveCliConfig(parsed, env)
+        config: resolveCliConfig(parsed, env, evalFilePath)
       };
     default:
       throw new Error(`Unsupported provider '${parsed.provider}' in target '${parsed.name}'`);
@@ -4566,7 +4571,8 @@ function normalizeCodexLogFormat(value) {
 }
 function resolveMockConfig(target) {
   const response = typeof target.response === "string" ? target.response : void 0;
-  return { response };
+  const trace2 = Array.isArray(target.trace) ? target.trace : void 0;
+  return { response, trace: trace2 };
 }
 function resolveVSCodeConfig(target, env, insiders) {
   const workspaceTemplateEnvVar = resolveOptionalLiteralString(
@@ -4598,15 +4604,18 @@ function resolveVSCodeConfig(target, env, insiders) {
     workspaceTemplate
   };
 }
-function resolveCliConfig(target, env) {
+function resolveCliConfig(target, env, evalFilePath) {
   const commandTemplateSource = target.command_template ?? target.commandTemplate;
   const filesFormat = resolveOptionalLiteralString(
     target.files_format ?? target.filesFormat ?? target.attachments_format ?? target.attachmentsFormat
   );
-  const cwd = resolveOptionalString(target.cwd, env, `${target.name} working directory`, {
+  let cwd = resolveOptionalString(target.cwd, env, `${target.name} working directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
+  if (!cwd && evalFilePath) {
+    cwd = path2.dirname(path2.resolve(evalFilePath));
+  }
   const timeoutMs = resolveTimeoutMs(
     target.timeout_seconds ?? target.timeoutSeconds,
     `${target.name} timeout`
@@ -4724,17 +4733,15 @@ function resolveOptionalString(source2, env, description, options) {
   if (envVarMatch) {
     const varName = envVarMatch[1];
     const envValue = env[varName];
-    if (envValue !== void 0) {
-      if (envValue.trim().length === 0) {
-        throw new Error(`Environment variable '${varName}' for ${description} is empty`);
-      }
-      return envValue;
-    }
     const optionalEnv = options?.optionalEnv ?? false;
-    if (optionalEnv) {
-      return void 0;
+    if (envValue === void 0 || envValue.trim().length === 0) {
+      if (optionalEnv) {
+        return void 0;
+      }
+      const status = envValue === void 0 ? "is not set" : "is empty";
+      throw new Error(`Environment variable '${varName}' required for ${description} ${status}`);
     }
-    throw new Error(`Environment variable '${varName}' required for ${description} is not set`);
+    return envValue;
   }
   const allowLiteral = options?.allowLiteral ?? false;
   if (!allowLiteral) {
@@ -4889,7 +4896,7 @@ import micromatch from "micromatch";
 import { parse as parse5 } from "yaml";
 import { constants as constants3 } from "node:fs";
 import { access as access3 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 import path32 from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
 import { readFile as readFile32 } from "node:fs/promises";
@@ -5985,10 +5992,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path26) {
-  if (!path26)
+function getElementAtPath(obj, path27) {
+  if (!path27)
     return obj;
-  return path26.reduce((acc, key2) => acc?.[key2], obj);
+  return path27.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6308,11 +6315,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path26, issues) {
+function prefixIssues(path27, issues) {
   return issues.map((iss) => {
     var _a17;
     (_a17 = iss).path ?? (_a17.path = []);
-    iss.path.unshift(path26);
+    iss.path.unshift(path27);
     return iss;
   });
 }
@@ -6449,7 +6456,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path26 = []) => {
+  const processError = (error41, path27 = []) => {
     var _a17, _b8;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -6459,7 +6466,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path26, ...issue2.path];
+        const fullpath = [...path27, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -6489,9 +6496,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path26) {
+function toDotPath(path27) {
   const segs = [];
-  for (const seg of path26) {
+  for (const seg of path27) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -26044,14 +26051,14 @@ function createAzure(options = {}) {
     description: "Azure OpenAI resource name"
   });
   const apiVersion = (_a17 = options.apiVersion) != null ? _a17 : "v1";
-  const url2 = ({ path: path26, modelId }) => {
+  const url2 = ({ path: path27, modelId }) => {
     var _a24;
     const baseUrlPrefix = (_a24 = options.baseURL) != null ? _a24 : `https://${getResourceName()}.openai.azure.com/openai`;
     let fullUrl;
     if (options.useDeploymentBasedUrls) {
-      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path26}`);
+      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path27}`);
     } else {
-      fullUrl = new URL(`${baseUrlPrefix}/v1${path26}`);
+      fullUrl = new URL(`${baseUrlPrefix}/v1${path27}`);
     }
     fullUrl.searchParams.set("api-version", apiVersion);
     return fullUrl.toString();
@@ -32499,12 +32506,12 @@ import path102 from "node:path";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/agentDispatch.js
 import { stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/utils/fs.js
 import { constants as constants2 } from "node:fs";
 import { access as access2, mkdir, readdir, rm, stat } from "node:fs/promises";
-import path2 from "node:path";
+import path3 from "node:path";
 async function pathExists(target) {
   try {
     await access2(target, constants2.F_OK);
@@ -32520,7 +32527,7 @@ async function readDirEntries(target) {
   const entries = await readdir(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path2.join(target, entry.name),
+    absolutePath: path3.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -32535,9 +32542,9 @@ async function removeIfExists(target) {
 }
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/utils/path.js
-import path3 from "node:path";
+import path4 from "node:path";
 function pathToFileUri(filePath) {
-  const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(filePath);
+  const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -32546,7 +32553,7 @@ function pathToFileUri(filePath) {
 }
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/promptBuilder.js
-import path4 from "node:path";
+import path5 from "node:path";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/utils/template.js
 function renderTemplate(content, variables) {
@@ -32636,8 +32643,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file2, index) => `${index + 1}. messages/${path4.basename(file2)}`).join("\n");
-  const responseList = responseFiles.map((file2) => `"${path4.basename(file2)}"`).join(", ");
+  const requestLines = requestFiles.map((file2, index) => `${index + 1}. messages/${path5.basename(file2)}`).join("\n");
+  const responseList = responseFiles.map((file2) => `"${path5.basename(file2)}"`).join(", ");
   return renderTemplate(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -32646,7 +32653,7 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/responseWaiter.js
 import { readFile as readFile2 } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/utils/time.js
 function sleep(ms) {
@@ -32695,7 +32702,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file2) => path5.basename(file2)).join(", ");
+    const fileList = responseFilesFinal.map((file2) => path6.basename(file2)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   try {
@@ -32745,17 +32752,17 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/vscodeProcess.js
 import { exec, spawn } from "node:child_process";
 import { mkdir as mkdir2, writeFile } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 import { promisify } from "node:util";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/constants.js
 import os from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 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 path6.join(os.homedir(), ".subagent", folder);
+  return path7.join(os.homedir(), ".subagent", folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
@@ -32782,11 +32789,11 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
     return true;
   }
-  const aliveFile = path7.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path8.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path7.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path8.join(subagentDir, ".github", "agents");
   await mkdir2(githubAgentsDir, { recursive: true });
-  const wakeupDst = path7.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = path8.join(githubAgentsDir, "wakeup.md");
   await writeFile(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
   await sleep(100);
@@ -32796,7 +32803,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path7.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path8.basename(subagentDir)} folder`
   ];
   spawn(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
   const start = Date.now();
@@ -32811,10 +32818,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
   try {
-    const workspacePath = path7.join(subagentDir, `${path7.basename(subagentDir)}.code-workspace`);
-    const messagesDir = path7.join(subagentDir, "messages");
+    const workspacePath = path8.join(subagentDir, `${path8.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path8.join(subagentDir, "messages");
     await mkdir2(messagesDir, { recursive: true });
-    const reqFile = path7.join(messagesDir, `${timestamp}_req.md`);
+    const reqFile = path8.join(messagesDir, `${timestamp}_req.md`);
     await writeFile(reqFile, requestInstructions, { encoding: "utf8" });
     const reqUri = pathToFileUri(reqFile);
     const chatArgs = ["-r", "chat", "-m", chatId];
@@ -32822,8 +32829,8 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
       chatArgs.push("-a", attachment);
     }
     chatArgs.push("-a", reqFile);
-    chatArgs.push(`Follow instructions in [${path7.basename(reqFile)}](${reqUri})`);
-    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path7.basename(subagentDir), subagentDir, vscodeCmd);
+    chatArgs.push(`Follow instructions in [${path8.basename(reqFile)}](${reqUri})`);
+    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path8.basename(subagentDir), subagentDir, vscodeCmd);
     if (!workspaceReady) {
       console.error("warning: Workspace may not be fully ready");
     }
@@ -32837,15 +32844,15 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
   try {
-    const workspacePath = path7.join(subagentDir, `${path7.basename(subagentDir)}.code-workspace`);
-    const messagesDir = path7.join(subagentDir, "messages");
+    const workspacePath = path8.join(subagentDir, `${path8.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path8.join(subagentDir, "messages");
     await mkdir2(messagesDir, { recursive: true });
     const chatArgs = ["-r", "chat", "-m", chatId];
     for (const attachment of attachmentPaths) {
       chatArgs.push("-a", attachment);
     }
     chatArgs.push(chatInstruction);
-    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path7.basename(subagentDir), subagentDir, vscodeCmd);
+    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path8.basename(subagentDir), subagentDir, vscodeCmd);
     if (!workspaceReady) {
       console.error("warning: Workspace may not be fully ready");
     }
@@ -32860,10 +32867,10 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/workspaceManager.js
 import { copyFile, mkdir as mkdir3, readFile as readFile3, readdir as readdir2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/utils/workspace.js
-import path8 from "node:path";
+import path9 from "node:path";
 
 // ../../node_modules/.bun/json5@2.2.3/node_modules/json5/dist/index.mjs
 var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
@@ -33966,10 +33973,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path8.isAbsolute(folderPath)) {
+    if (path9.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path8.resolve(templateDir, folderPath);
+    const absolutePath = path9.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -33991,19 +33998,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path8.isAbsolute(locationPath);
+          const isAbsolute = path9.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path8.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path9.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 = (path8.resolve(templateDir, basePath) + patternPath).replace(/\\/g, "/");
+              const resolvedPath = (path9.resolve(templateDir, basePath) + patternPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             }
           }
@@ -34041,7 +34048,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 = path9.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path10.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -34051,7 +34058,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path9.resolve(workspaceTemplate);
+    const workspaceSrc = path10.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -34064,37 +34071,37 @@ async function copyAgentConfig(subagentDir, workspaceTemplate) {
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path9.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path9.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path9.dirname(path9.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path10.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path10.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path10.dirname(path10.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   await writeFile2(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path9.join(subagentDir, "messages");
+  const messagesDir = path10.join(subagentDir, "messages");
   await mkdir3(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path9.join(subagentDir, "messages");
+  const messagesDir = path10.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir2(messagesDir);
     await Promise.all(files.map(async (file2) => {
-      const target = path9.join(messagesDir, file2);
+      const target = path10.join(messagesDir, file2);
       await removeIfExists(target);
     }));
   }
-  const githubAgentsDir = path9.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path10.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
     const agentFiles = await readdir2(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
-    await Promise.all(agentFiles.filter((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path9.join(githubAgentsDir, file2))));
+    await Promise.all(agentFiles.filter((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path10.join(githubAgentsDir, file2))));
   }
-  const lockFile = path9.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path10.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile2(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path9.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path10.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
@@ -34114,9 +34121,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path9.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = path10.join(subagentDir, ".github", "agents");
     await mkdir3(githubAgentsDir, { recursive: true });
-    const agentFile = path9.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = path10.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error40) {
@@ -34135,7 +34142,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path10.resolve(promptFile);
+  const resolvedPrompt = path11.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -34151,7 +34158,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path10.resolve(attachment);
+    const resolvedPath = path11.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -34180,7 +34187,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path10.basename(subagentDir);
+    const subagentName = path11.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
     if (preparationResult !== 0) {
@@ -34201,9 +34208,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path10.join(subagentDir, "messages");
-    const responseFileTmp = path10.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path10.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path11.join(subagentDir, "messages");
+    const responseFileTmp = path11.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path11.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent);
     if (dryRun) {
       return {
@@ -34293,7 +34300,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path10.basename(subagentDir);
+    subagentName = path11.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
     if (preparationResult !== 0) {
@@ -34318,11 +34325,11 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path10.join(subagentDir, "messages");
-    requestFiles = userQueries.map((_, index) => path10.join(messagesDir, `${timestamp}_${index}_req.md`));
-    const responseTmpFiles = userQueries.map((_, index) => path10.join(messagesDir, `${timestamp}_${index}_res.tmp.md`));
-    responseFilesFinal = userQueries.map((_, index) => path10.join(messagesDir, `${timestamp}_${index}_res.md`));
-    const orchestratorFile = path10.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const messagesDir = path11.join(subagentDir, "messages");
+    requestFiles = userQueries.map((_, index) => path11.join(messagesDir, `${timestamp}_${index}_req.md`));
+    const responseTmpFiles = userQueries.map((_, index) => path11.join(messagesDir, `${timestamp}_${index}_res.tmp.md`));
+    responseFilesFinal = userQueries.map((_, index) => path11.join(messagesDir, `${timestamp}_${index}_res.md`));
+    const orchestratorFile = path11.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(userQueries.map((query, index) => writeFile3(requestFiles[index], createBatchRequestPrompt(query, responseTmpFiles[index], responseFilesFinal[index], batchRequestTemplateContent), { encoding: "utf8" })));
       const orchestratorContent = createBatchOrchestratorPrompt(requestFiles, responseFilesFinal, orchestratorTemplateContent);
@@ -34391,7 +34398,7 @@ async function dispatchBatchAgent(options) {
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/provision.js
 import { writeFile as writeFile4 } from "node:fs/promises";
-import path11 from "node:path";
+import path12 from "node:path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -34414,7 +34421,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path11.resolve(targetRoot);
+  const targetPath = path12.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -34435,7 +34442,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path11.join(entry.absolutePath, lockName);
+      const lockFile = path12.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -34452,11 +34459,11 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path11.join(subagentDir, ".github", "agents");
-    const lockFile = path11.join(subagentDir, lockName);
-    const workspaceDst = path11.join(subagentDir, `${path11.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path11.join(githubAgentsDir, "wakeup.md");
-    const subagentDst = path11.join(githubAgentsDir, "subagent.md");
+    const githubAgentsDir = path12.join(subagentDir, ".github", "agents");
+    const lockFile = path12.join(subagentDir, lockName);
+    const workspaceDst = path12.join(subagentDir, `${path12.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path12.join(githubAgentsDir, "wakeup.md");
+    const subagentDst = path12.join(githubAgentsDir, "subagent.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -34494,11 +34501,11 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path11.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path11.join(subagentDir, ".github", "agents");
-    const workspaceDst = path11.join(subagentDir, `${path11.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path11.join(githubAgentsDir, "wakeup.md");
-    const subagentDst = path11.join(githubAgentsDir, "subagent.md");
+    const subagentDir = path12.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path12.join(subagentDir, ".github", "agents");
+    const workspaceDst = path12.join(subagentDir, `${path12.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path12.join(githubAgentsDir, "wakeup.md");
+    const subagentDst = path12.join(githubAgentsDir, "subagent.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -34562,11 +34569,47 @@ function isTestMessage(value) {
   }
   return candidate.content.every(isJsonObject);
 }
-var EVALUATOR_KIND_VALUES = ["code_judge", "llm_judge", "rubric", "composite"];
+var EVALUATOR_KIND_VALUES = [
+  "code_judge",
+  "llm_judge",
+  "rubric",
+  "composite",
+  "tool_trajectory",
+  "expected_messages"
+];
 var EVALUATOR_KIND_SET = new Set(EVALUATOR_KIND_VALUES);
 function isEvaluatorKind(value) {
   return typeof value === "string" && EVALUATOR_KIND_SET.has(value);
 }
+function isTraceEventType(value) {
+  return typeof value === "string" && ["model_step", "tool_call", "tool_result", "message", "error"].includes(value);
+}
+function isTraceEvent(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return isTraceEventType(candidate.type) && typeof candidate.timestamp === "string";
+}
+function computeTraceSummary(trace2) {
+  const toolCallCounts = {};
+  let errorCount = 0;
+  for (const event of trace2) {
+    if (event.type === "tool_call" && event.name) {
+      toolCallCounts[event.name] = (toolCallCounts[event.name] ?? 0) + 1;
+    }
+    if (event.type === "error") {
+      errorCount++;
+    }
+  }
+  const toolNames = Object.keys(toolCallCounts).sort();
+  return {
+    eventCount: trace2.length,
+    toolNames,
+    toolCallsByName: toolCallCounts,
+    errorCount
+  };
+}
 function extractCodeBlocks(segments) {
   const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
   const codeBlocks = [];
@@ -34660,15 +34703,15 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file://")) {
       return new URL(candidate).pathname;
     }
-    return path12.resolve(candidate);
+    return path13.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = path12.resolve(repoRoot);
-  let current = path12.resolve(path12.dirname(filePath));
+  const boundary = path13.resolve(repoRoot);
+  let current = path13.resolve(path13.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -34677,7 +34720,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = path12.dirname(current);
+    const parent = path13.dirname(current);
     if (parent === current) {
       break;
     }
@@ -34691,16 +34734,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root2) => {
-    const normalized = path12.resolve(root2);
+    const normalized = path13.resolve(root2);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = path12.dirname(evalPath);
+  let currentDir = path13.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = path12.dirname(currentDir);
+    const parentDir = path13.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -34718,16 +34761,16 @@ function trimLeadingSeparators2(value) {
 async function resolveFileReference2(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (path12.isAbsolute(rawValue)) {
-    potentialPaths.push(path12.normalize(rawValue));
+  if (path13.isAbsolute(rawValue)) {
+    potentialPaths.push(path13.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(path12.resolve(base, displayPath));
+    potentialPaths.push(path13.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = path12.resolve(candidate);
+    const absoluteCandidate = path13.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -35008,6 +35051,75 @@ async function parseEvaluators(rawEvalCase, globalExecution, searchRoots, evalId
       });
       continue;
     }
+    if (typeValue === "expected_messages") {
+      evaluators.push({
+        name: name16,
+        type: "expected_messages"
+      });
+      continue;
+    }
+    if (typeValue === "tool_trajectory") {
+      const mode = asString2(rawEvaluator.mode);
+      if (mode !== "any_order" && mode !== "in_order" && mode !== "exact") {
+        logWarning2(
+          `Skipping tool_trajectory evaluator '${name16}' in '${evalId}': invalid mode '${mode}' (must be any_order, in_order, or exact)`
+        );
+        continue;
+      }
+      const rawMinimums = rawEvaluator.minimums;
+      let minimums;
+      if (rawMinimums !== void 0) {
+        if (!isJsonObject2(rawMinimums)) {
+          logWarning2(
+            `Skipping tool_trajectory evaluator '${name16}' in '${evalId}': minimums must be an object`
+          );
+          continue;
+        }
+        minimums = {};
+        for (const [toolName, count] of Object.entries(rawMinimums)) {
+          if (typeof count === "number" && count >= 0) {
+            minimums[toolName] = count;
+          }
+        }
+      }
+      const rawExpected = rawEvaluator.expected;
+      let expected;
+      if (rawExpected !== void 0) {
+        if (!Array.isArray(rawExpected)) {
+          logWarning2(
+            `Skipping tool_trajectory evaluator '${name16}' in '${evalId}': expected must be an array`
+          );
+          continue;
+        }
+        expected = [];
+        for (const item of rawExpected) {
+          if (isJsonObject2(item) && typeof item.tool === "string") {
+            expected.push({ tool: item.tool });
+          }
+        }
+      }
+      if (mode === "any_order" && !minimums) {
+        logWarning2(
+          `Skipping tool_trajectory evaluator '${name16}' in '${evalId}': any_order mode requires minimums`
+        );
+        continue;
+      }
+      if ((mode === "in_order" || mode === "exact") && !expected) {
+        logWarning2(
+          `Skipping tool_trajectory evaluator '${name16}' in '${evalId}': ${mode} mode requires expected`
+        );
+        continue;
+      }
+      const config2 = {
+        name: name16,
+        type: "tool_trajectory",
+        mode,
+        ...minimums ? { minimums } : {},
+        ...expected ? { expected } : {}
+      };
+      evaluators.push(config2);
+      continue;
+    }
     const prompt = asString2(rawEvaluator.prompt);
     let promptPath;
     if (prompt) {
@@ -35257,6 +35369,67 @@ ${detailBlock}${ANSI_RESET4}`);
     console.warn(`${ANSI_YELLOW4}Warning: ${message}${ANSI_RESET4}`);
   }
 }
+async function processExpectedMessages(options) {
+  const { messages, searchRoots, repoRootPath, verbose } = options;
+  const segments = [];
+  for (const message of messages) {
+    const segment = {
+      role: message.role
+    };
+    if (message.role === "assistant" && message.tool_calls !== void 0) {
+      segment.tool_calls = message.tool_calls;
+    }
+    const content = message.content;
+    if (typeof content === "string") {
+      segment.content = content;
+    } else if (Array.isArray(content)) {
+      const processedContent = [];
+      for (const rawSegment of content) {
+        if (!isJsonObject(rawSegment)) {
+          continue;
+        }
+        const segmentType = asString3(rawSegment.type);
+        if (segmentType === "file") {
+          const rawValue = asString3(rawSegment.value);
+          if (!rawValue) {
+            continue;
+          }
+          const { displayPath, resolvedPath, attempted } = await resolveFileReference2(
+            rawValue,
+            searchRoots
+          );
+          if (!resolvedPath) {
+            const attempts = attempted.length ? ["  Tried:", ...attempted.map((candidate) => `    ${candidate}`)] : void 0;
+            logWarning3(`File not found in expected_messages: ${displayPath}`, attempts);
+            continue;
+          }
+          try {
+            const fileContent = (await readFile32(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
+            processedContent.push({
+              type: "file",
+              path: displayPath,
+              text: fileContent,
+              resolvedPath: path42.resolve(resolvedPath)
+            });
+            if (verbose) {
+              console.log(`  [Expected Output File] Found: ${displayPath}`);
+              console.log(`    Resolved to: ${resolvedPath}`);
+            }
+          } catch (error40) {
+            logWarning3(
+              `Could not read expected output file ${resolvedPath}: ${error40.message}`
+            );
+          }
+          continue;
+        }
+        processedContent.push(cloneJsonObject(rawSegment));
+      }
+      segment.content = processedContent;
+    }
+    segments.push(segment);
+  }
+  return segments;
+}
 var ANSI_YELLOW5 = "\x1B[33m";
 var ANSI_RESET5 = "\x1B[0m";
 async function buildPromptInputs(testCase, mode = "lm") {
@@ -35555,12 +35728,10 @@ async function loadEvalCases(evalFilePath, repoRoot, options) {
       messageType: "input",
       verbose
     });
-    const outputSegments = hasExpectedMessages ? await processMessages({
+    const outputSegments = hasExpectedMessages ? await processExpectedMessages({
       messages: expectedMessages,
       searchRoots,
       repoRootPath,
-      guidelinePatterns,
-      messageType: "output",
       verbose
     }) : [];
     const codeSnippets = extractCodeBlocks(inputSegments);
@@ -36071,9 +36242,11 @@ var CliProvider = class {
       const message = detail ? `${detail} (exit code ${codeText})` : `CLI exited with code ${codeText}`;
       throw new Error(message);
     }
-    const responseText = await this.readAndCleanupOutputFile(outputFilePath);
+    const responseContent = await this.readAndCleanupOutputFile(outputFilePath);
+    const parsed = this.parseOutputContent(responseContent);
     return {
-      text: responseText,
+      text: parsed.text,
+      trace: parsed.trace,
       raw: {
         command: renderedCommand,
         stderr: result.stderr,
@@ -36083,6 +36256,31 @@ var CliProvider = class {
       }
     };
   }
+  /**
+   * Parse output content from CLI.
+   * If the content is valid JSON with a 'text' field, extract text and optional trace.
+   * Otherwise, treat the entire content as plain text.
+   */
+  parseOutputContent(content) {
+    try {
+      const parsed = JSON.parse(content);
+      if (typeof parsed === "object" && parsed !== null && "text" in parsed) {
+        const obj = parsed;
+        const text2 = typeof obj.text === "string" ? obj.text : String(obj.text);
+        const trace2 = this.parseTrace(obj.trace);
+        return { text: text2, trace: trace2 };
+      }
+    } catch {
+    }
+    return { text: content };
+  }
+  parseTrace(trace2) {
+    if (!Array.isArray(trace2)) {
+      return void 0;
+    }
+    const validEvents = trace2.filter(isTraceEvent);
+    return validEvents.length > 0 ? validEvents : void 0;
+  }
   async readAndCleanupOutputFile(filePath) {
     try {
       const content = await readTextFile(filePath);
@@ -37044,6 +37242,7 @@ var MockProvider = class {
   delayMs;
   delayMinMs;
   delayMaxMs;
+  trace;
   constructor(targetName, config2) {
     this.id = `mock:${targetName}`;
     this.targetName = targetName;
@@ -37051,6 +37250,7 @@ var MockProvider = class {
     this.delayMs = config2.delayMs ?? 0;
     this.delayMinMs = config2.delayMinMs ?? 0;
     this.delayMaxMs = config2.delayMaxMs ?? 0;
+    this.trace = config2.trace;
   }
   async invoke(request) {
     const delay2 = this.calculateDelay();
@@ -37062,7 +37262,8 @@ var MockProvider = class {
       raw: {
         question: request.question,
         guidelines: request.guidelines
-      }
+      },
+      trace: this.trace
     };
   }
   calculateDelay() {
@@ -37827,6 +38028,251 @@ function substituteVariables(template, variables) {
     return variables[varName] ?? match;
   });
 }
+var ToolTrajectoryEvaluator = class {
+  kind = "tool_trajectory";
+  config;
+  constructor(options) {
+    this.config = options.config;
+  }
+  evaluate(context) {
+    const { candidateTrace, candidateTraceSummary } = context;
+    if (!candidateTrace || !candidateTraceSummary) {
+      return {
+        score: 0,
+        verdict: "fail",
+        hits: [],
+        misses: ["No trace available for evaluation"],
+        expectedAspectCount: 1
+      };
+    }
+    switch (this.config.mode) {
+      case "any_order":
+        return this.evaluateAnyOrder(candidateTraceSummary);
+      case "in_order":
+        return this.evaluateInOrder(candidateTrace);
+      case "exact":
+        return this.evaluateExact(candidateTrace);
+      default:
+        return {
+          score: 0,
+          verdict: "fail",
+          hits: [],
+          misses: [`Unknown mode: ${this.config.mode}`],
+          expectedAspectCount: 1
+        };
+    }
+  }
+  evaluateAnyOrder(summary) {
+    const minimums = this.config.minimums ?? {};
+    const toolNames = Object.keys(minimums);
+    if (toolNames.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool requirements specified"],
+        misses: [],
+        expectedAspectCount: 0
+      };
+    }
+    const hits = [];
+    const misses = [];
+    for (const toolName of toolNames) {
+      const required2 = minimums[toolName];
+      const actual = summary.toolCallsByName[toolName] ?? 0;
+      if (actual >= required2) {
+        hits.push(`${toolName}: called ${actual} times (required \u2265${required2})`);
+      } else {
+        misses.push(`${toolName}: called ${actual} times (required \u2265${required2})`);
+      }
+    }
+    const score = hits.length / toolNames.length;
+    return {
+      score,
+      verdict: scoreToVerdict(score),
+      hits,
+      misses,
+      expectedAspectCount: toolNames.length
+    };
+  }
+  evaluateInOrder(trace2) {
+    const expected = this.config.expected ?? [];
+    if (expected.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool sequence specified"],
+        misses: [],
+        expectedAspectCount: 0
+      };
+    }
+    const actualToolCalls = trace2.filter((e) => e.type === "tool_call" && e.name);
+    const hits = [];
+    const misses = [];
+    let actualIndex = 0;
+    for (let i = 0; i < expected.length; i++) {
+      const expectedTool = expected[i].tool;
+      let found = false;
+      while (actualIndex < actualToolCalls.length) {
+        if (actualToolCalls[actualIndex].name === expectedTool) {
+          hits.push(`Found ${expectedTool} at position ${actualIndex}`);
+          actualIndex++;
+          found = true;
+          break;
+        }
+        actualIndex++;
+      }
+      if (!found) {
+        misses.push(`Expected ${expectedTool} at position ${i}, not found in remaining trace`);
+      }
+    }
+    const score = hits.length / expected.length;
+    return {
+      score,
+      verdict: scoreToVerdict(score),
+      hits,
+      misses,
+      expectedAspectCount: expected.length
+    };
+  }
+  evaluateExact(trace2) {
+    const expected = this.config.expected ?? [];
+    if (expected.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool sequence specified"],
+        misses: [],
+        expectedAspectCount: 0
+      };
+    }
+    const actualToolCalls = trace2.filter((e) => e.type === "tool_call" && e.name);
+    const hits = [];
+    const misses = [];
+    if (actualToolCalls.length !== expected.length) {
+      misses.push(`Expected ${expected.length} tool calls, got ${actualToolCalls.length}`);
+    }
+    const checkLength = Math.min(expected.length, actualToolCalls.length);
+    for (let i = 0; i < checkLength; i++) {
+      const expectedTool = expected[i].tool;
+      const actualTool = actualToolCalls[i].name;
+      if (actualTool === expectedTool) {
+        hits.push(`Position ${i}: ${expectedTool} \u2713`);
+      } else {
+        misses.push(`Position ${i}: expected ${expectedTool}, got ${actualTool}`);
+      }
+    }
+    for (let i = checkLength; i < expected.length; i++) {
+      misses.push(`Position ${i}: expected ${expected[i].tool}, got nothing`);
+    }
+    const score = hits.length / expected.length;
+    return {
+      score,
+      verdict: scoreToVerdict(score),
+      hits,
+      misses,
+      expectedAspectCount: expected.length
+    };
+  }
+};
+var ExpectedMessagesEvaluator = class {
+  kind = "expected_messages";
+  evaluate(context) {
+    const { candidateTrace, evalCase } = context;
+    const expectedSegments = evalCase.expected_segments;
+    const expectedToolCalls = this.extractExpectedToolCalls(expectedSegments);
+    if (expectedToolCalls.length === 0) {
+      return {
+        score: 1,
+        verdict: "pass",
+        hits: ["No tool_calls specified in expected_messages"],
+        misses: [],
+        expectedAspectCount: 1
+      };
+    }
+    if (!candidateTrace || candidateTrace.length === 0) {
+      return {
+        score: 0,
+        verdict: "fail",
+        hits: [],
+        misses: ["No trace available to validate tool_calls"],
+        expectedAspectCount: expectedToolCalls.length
+      };
+    }
+    const actualToolCalls = candidateTrace.filter((e) => e.type === "tool_call");
+    return this.validateToolCalls(expectedToolCalls, actualToolCalls);
+  }
+  extractExpectedToolCalls(segments) {
+    if (!segments) {
+      return [];
+    }
+    const toolCalls = [];
+    for (const segment of segments) {
+      const role = segment.role;
+      const segmentToolCalls = segment.tool_calls;
+      if (role === "assistant" && Array.isArray(segmentToolCalls)) {
+        for (const tc of segmentToolCalls) {
+          if (typeof tc === "object" && tc !== null && typeof tc.tool === "string") {
+            const toolCall = tc;
+            toolCalls.push({ tool: toolCall.tool, input: toolCall.input });
+          }
+        }
+      }
+    }
+    return toolCalls;
+  }
+  validateToolCalls(expected, actual) {
+    const hits = [];
+    const misses = [];
+    for (let i = 0; i < expected.length; i++) {
+      const expectedCall = expected[i];
+      const actualCall = actual[i];
+      if (!actualCall) {
+        misses.push(
+          `tool_calls[${i}]: expected ${expectedCall.tool}, but no more tool calls in trace`
+        );
+        continue;
+      }
+      if (actualCall.name !== expectedCall.tool) {
+        misses.push(
+          `tool_calls[${i}]: expected ${expectedCall.tool}, got ${actualCall.name ?? "unknown"}`
+        );
+        continue;
+      }
+      if (expectedCall.input !== void 0) {
+        if (!this.deepEquals(expectedCall.input, actualCall.input)) {
+          misses.push(`tool_calls[${i}]: ${expectedCall.tool} input mismatch`);
+          continue;
+        }
+      }
+      hits.push(`tool_calls[${i}]: ${expectedCall.tool} matched`);
+    }
+    const totalChecks = expected.length || 1;
+    const score = hits.length / totalChecks;
+    return {
+      score,
+      verdict: score >= 0.8 ? "pass" : score >= 0.6 ? "borderline" : "fail",
+      hits,
+      misses,
+      expectedAspectCount: totalChecks
+    };
+  }
+  deepEquals(a, b) {
+    if (a === b) return true;
+    if (typeof a !== typeof b) return false;
+    if (typeof a !== "object" || a === null || b === null) return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      return a.every((val, i) => this.deepEquals(val, b[i]));
+    }
+    if (Array.isArray(a) || Array.isArray(b)) return false;
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key2) => this.deepEquals(aObj[key2], bObj[key2]));
+  }
+};
 var DEFAULT_COMPOSITE_AGGREGATOR_PROMPT = `Review the following evaluation results:
 {{EVALUATOR_RESULTS_JSON}}
 
@@ -38239,7 +38685,7 @@ async function runEvaluation(options) {
     if (!definition) {
       return void 0;
     }
-    const resolved = resolveTargetDefinition(definition, envLookup);
+    const resolved = resolveTargetDefinition(definition, envLookup, evalFilePath);
     resolvedTargetsByName.set(name16, resolved);
     return resolved;
   };
@@ -38553,6 +38999,17 @@ async function runEvalCase(options) {
   if (cacheKey && cache && !cachedResponse) {
     await cache.set(cacheKey, providerResponse);
   }
+  let candidateTrace = providerResponse.trace;
+  if (!candidateTrace && providerResponse.traceRef) {
+    try {
+      const rawTrace = await readJsonFile(providerResponse.traceRef);
+      if (Array.isArray(rawTrace) && rawTrace.every(isTraceEvent)) {
+        candidateTrace = rawTrace;
+      }
+    } catch {
+    }
+  }
+  const candidateTraceSummary = candidateTrace ? computeTraceSummary(candidateTrace) : void 0;
   try {
     return await evaluateCandidate({
       evalCase,
@@ -38564,7 +39021,9 @@ async function runEvalCase(options) {
       nowFn,
       attempt,
       judgeProvider,
-      agentTimeoutMs
+      agentTimeoutMs,
+      candidateTrace,
+      candidateTraceSummary
     });
   } catch (error40) {
     return buildErrorResult(evalCase, target.name, nowFn(), error40, promptInputs, provider);
@@ -38581,7 +39040,9 @@ async function evaluateCandidate(options) {
     nowFn,
     attempt,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   } = options;
   const gradeTimestamp = nowFn();
   const { score, evaluatorResults } = await runEvaluatorsForCase({
@@ -38594,7 +39055,9 @@ async function evaluateCandidate(options) {
     promptInputs,
     now: gradeTimestamp,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   });
   const completedAt = nowFn();
   let agentProviderRequest;
@@ -38633,7 +39096,8 @@ async function evaluateCandidate(options) {
     agent_provider_request: agentProviderRequest,
     lm_provider_request: lmProviderRequest,
     evaluator_provider_request: evaluatorResults ? void 0 : score.evaluatorRawRequest,
-    evaluator_results: evaluatorResults
+    evaluator_results: evaluatorResults,
+    trace_summary: candidateTraceSummary
   };
 }
 async function runEvaluatorsForCase(options) {
@@ -38647,7 +39111,9 @@ async function runEvaluatorsForCase(options) {
     promptInputs,
     now,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   } = options;
   if (evalCase.evaluators && evalCase.evaluators.length > 0) {
     return runEvaluatorList({
@@ -38661,7 +39127,9 @@ async function runEvaluatorsForCase(options) {
       promptInputs,
       now,
       judgeProvider,
-      agentTimeoutMs
+      agentTimeoutMs,
+      candidateTrace,
+      candidateTraceSummary
     });
   }
   const evaluatorKind = evalCase.evaluator ?? "llm_judge";
@@ -38677,7 +39145,9 @@ async function runEvaluatorsForCase(options) {
     attempt,
     promptInputs,
     now,
-    judgeProvider
+    judgeProvider,
+    candidateTrace,
+    candidateTraceSummary
   });
   return { score };
 }
@@ -38693,7 +39163,9 @@ async function runEvaluatorList(options) {
     promptInputs,
     now,
     judgeProvider,
-    agentTimeoutMs
+    agentTimeoutMs,
+    candidateTrace,
+    candidateTraceSummary
   } = options;
   const scored = [];
   const evaluatorResults = [];
@@ -38769,6 +39241,12 @@ async function runEvaluatorList(options) {
                 cwd: evalFileDir,
                 evaluatorFactory: { create: createEvaluator }
               });
+            case "tool_trajectory":
+              return new ToolTrajectoryEvaluator({
+                config: memberConfig
+              });
+            case "expected_messages":
+              return new ExpectedMessagesEvaluator();
             default: {
               const unknownConfig = memberConfig;
               throw new Error(`Unsupported evaluator type in composite: ${unknownConfig.type}`);
@@ -38803,6 +39281,56 @@ async function runEvaluatorList(options) {
           evaluator_results: mapChildResults(score2.evaluatorResults)
         });
       }
+      if (evaluator.type === "tool_trajectory") {
+        const trajectoryEvaluator = new ToolTrajectoryEvaluator({
+          config: evaluator
+        });
+        const score2 = trajectoryEvaluator.evaluate({
+          evalCase,
+          candidate,
+          target,
+          provider,
+          attempt,
+          promptInputs,
+          now,
+          candidateTrace,
+          candidateTraceSummary
+        });
+        scored.push({ score: score2, name: evaluator.name, type: evaluator.type });
+        evaluatorResults.push({
+          name: evaluator.name,
+          type: evaluator.type,
+          score: score2.score,
+          verdict: score2.verdict,
+          hits: score2.hits,
+          misses: score2.misses,
+          reasoning: score2.reasoning
+        });
+      }
+      if (evaluator.type === "expected_messages") {
+        const expectedMessagesEvaluator = new ExpectedMessagesEvaluator();
+        const score2 = expectedMessagesEvaluator.evaluate({
+          evalCase,
+          candidate,
+          target,
+          provider,
+          attempt,
+          promptInputs,
+          now,
+          candidateTrace,
+          candidateTraceSummary
+        });
+        scored.push({ score: score2, name: evaluator.name, type: evaluator.type });
+        evaluatorResults.push({
+          name: evaluator.name,
+          type: evaluator.type,
+          score: score2.score,
+          verdict: score2.verdict,
+          hits: score2.hits,
+          misses: score2.misses,
+          reasoning: score2.reasoning
+        });
+      }
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
       const fallbackScore = {
@@ -39136,13 +39664,13 @@ function buildPrompt(expectedOutcome, question, referenceAnswer) {
 // src/commands/eval/env.ts
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path13 from "node:path";
+import path14 from "node:path";
 import { config as loadDotenv } from "dotenv";
 function uniqueDirs(directories) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dir of directories) {
-    const absolute = path13.resolve(dir);
+    const absolute = path14.resolve(dir);
     if (seen.has(absolute)) {
       continue;
     }
@@ -39161,14 +39689,14 @@ async function fileExists4(filePath) {
 }
 function collectAncestorDirectories(start, boundary) {
   const directories = [];
-  const boundaryDir = path13.resolve(boundary);
-  let current = path13.resolve(start);
+  const boundaryDir = path14.resolve(boundary);
+  let current = path14.resolve(start);
   while (current !== void 0) {
     directories.push(current);
     if (current === boundaryDir) {
       break;
     }
-    const parent = path13.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current) {
       break;
     }
@@ -39178,29 +39706,36 @@ function collectAncestorDirectories(start, boundary) {
 }
 async function loadEnvFromHierarchy(options) {
   const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path13.dirname(path13.resolve(testFilePath));
+  const testDir = path14.dirname(path14.resolve(testFilePath));
   const cwd = process.cwd();
   const searchDirs = uniqueDirs([...collectAncestorDirectories(testDir, repoRoot), repoRoot, cwd]);
+  const envFiles = [];
   for (const dir of searchDirs) {
-    const candidate = path13.join(dir, ".env");
+    const candidate = path14.join(dir, ".env");
     if (await fileExists4(candidate)) {
-      loadDotenv({ path: candidate, override: false });
-      if (verbose) {
-        console.log(`Loaded environment from: ${candidate}`);
-      }
-      return candidate;
+      envFiles.push(candidate);
     }
   }
-  if (verbose) {
-    console.log("No .env file found in hierarchy");
+  if (envFiles.length === 0) {
+    if (verbose) {
+      console.log("No .env file found in hierarchy");
+    }
+    return void 0;
   }
-  return void 0;
+  for (let i = envFiles.length - 1; i >= 0; i--) {
+    const envFile = envFiles[i];
+    loadDotenv({ path: envFile, override: false });
+    if (verbose) {
+      console.log(`Loaded environment from: ${envFile}`);
+    }
+  }
+  return envFiles[0];
 }
 
 // src/commands/eval/jsonl-writer.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path14 from "node:path";
+import path15 from "node:path";
 import { finished } from "node:stream/promises";
 
 // ../../node_modules/.bun/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
@@ -39418,7 +39953,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir5(path14.dirname(filePath), { recursive: true });
+    await mkdir5(path15.dirname(filePath), { recursive: true });
     const stream = createWriteStream2(filePath, { flags: "w", encoding: "utf8" });
     return new _JsonlWriter(stream);
   }
@@ -39450,7 +39985,7 @@ var JsonlWriter = class _JsonlWriter {
 // src/commands/eval/yaml-writer.ts
 import { createWriteStream as createWriteStream3 } from "node:fs";
 import { mkdir as mkdir6 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 import { finished as finished2 } from "node:stream/promises";
 import { stringify as stringifyYaml } from "yaml";
 var YamlWriter = class _YamlWriter {
@@ -39462,7 +39997,7 @@ var YamlWriter = class _YamlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir6(path15.dirname(filePath), { recursive: true });
+    await mkdir6(path16.dirname(filePath), { recursive: true });
     const stream = createWriteStream3(filePath, { flags: "w", encoding: "utf8" });
     return new _YamlWriter(stream);
   }
@@ -39586,12 +40121,12 @@ var ProgressDisplay = class {
   }
   addLogPaths(paths) {
     const newPaths = [];
-    for (const path26 of paths) {
-      if (this.logPathSet.has(path26)) {
+    for (const path27 of paths) {
+      if (this.logPathSet.has(path27)) {
         continue;
       }
-      this.logPathSet.add(path26);
-      newPaths.push(path26);
+      this.logPathSet.add(path27);
+      newPaths.push(path27);
     }
     if (newPaths.length === 0) {
       return;
@@ -39607,8 +40142,8 @@ var ProgressDisplay = class {
       this.hasPrintedLogHeader = true;
     }
     const startIndex = this.logPaths.length - newPaths.length;
-    newPaths.forEach((path26, offset) => {
-      console.log(`${startIndex + offset + 1}. ${path26}`);
+    newPaths.forEach((path27, offset) => {
+      console.log(`${startIndex + offset + 1}. ${path27}`);
     });
   }
   scheduleRender() {
@@ -39656,8 +40191,8 @@ var ProgressDisplay = class {
     if (this.logPaths.length > 0) {
       lines.push("");
       lines.push("Codex CLI logs:");
-      this.logPaths.forEach((path26, index) => {
-        lines.push(`${index + 1}. ${path26}`);
+      this.logPaths.forEach((path27, index) => {
+        lines.push(`${index + 1}. ${path27}`);
       });
     }
     const rowCount = this.getRenderedRowCount(lines);
@@ -39864,7 +40399,7 @@ function formatEvaluationSummary(summary) {
 
 // ../../packages/core/dist/evaluation/validation/index.js
 import { readFile as readFile7 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 import { parse as parse6 } from "yaml";
 import { readFile as readFile23 } from "node:fs/promises";
 import path23 from "node:path";
@@ -39907,8 +40442,8 @@ async function detectFileType(filePath) {
   }
 }
 function inferFileTypeFromPath(filePath) {
-  const normalized = path16.normalize(filePath).replace(/\\/g, "/");
-  const basename = path16.basename(filePath);
+  const normalized = path17.normalize(filePath).replace(/\\/g, "/");
+  const basename = path17.basename(filePath);
   if (normalized.includes("/.agentv/")) {
     if (basename === "config.yaml" || basename === "config.yml") {
       return "config";
@@ -40053,6 +40588,26 @@ function validateMessages(messages, location, filePath, errors) {
         message: `Invalid role '${role}'. Must be one of: ${validRoles.join(", ")}`
       });
     }
+    const toolCalls = message.tool_calls;
+    if (toolCalls !== void 0) {
+      if (role !== "assistant") {
+        errors.push({
+          severity: "error",
+          filePath,
+          location: `${msgLocation}.tool_calls`,
+          message: "tool_calls can only be specified on assistant messages"
+        });
+      } else if (!Array.isArray(toolCalls)) {
+        errors.push({
+          severity: "error",
+          filePath,
+          location: `${msgLocation}.tool_calls`,
+          message: "tool_calls must be an array"
+        });
+      } else {
+        validateToolCalls(toolCalls, `${msgLocation}.tool_calls`, filePath, errors);
+      }
+    }
     const content = message.content;
     if (typeof content === "string") {
       validateContentForRoleMarkers(content, `${msgLocation}.content`, filePath, errors);
@@ -40117,6 +40672,30 @@ function validateContentForRoleMarkers(content, location, filePath, errors) {
     }
   }
 }
+function validateToolCalls(toolCalls, location, filePath, errors) {
+  for (let i = 0; i < toolCalls.length; i++) {
+    const toolCall = toolCalls[i];
+    const callLocation = `${location}[${i}]`;
+    if (!isObject2(toolCall)) {
+      errors.push({
+        severity: "error",
+        filePath,
+        location: callLocation,
+        message: "Tool call must be an object"
+      });
+      continue;
+    }
+    const tool2 = toolCall.tool;
+    if (typeof tool2 !== "string" || tool2.trim().length === 0) {
+      errors.push({
+        severity: "error",
+        filePath,
+        location: `${callLocation}.tool`,
+        message: "Missing or invalid 'tool' field (must be a non-empty string)"
+      });
+    }
+  }
+}
 function isObject22(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -40212,7 +40791,9 @@ var MOCK_SETTINGS = /* @__PURE__ */ new Set([
   "response",
   "delayMs",
   "delayMinMs",
-  "delayMaxMs"
+  "delayMaxMs",
+  "trace"
+  // For testing tool_trajectory evaluator
 ]);
 var CLI_SETTINGS = /* @__PURE__ */ new Set([
   ...COMMON_SETTINGS,
@@ -40735,12 +41316,12 @@ async function validateMessagesFileRefs(messages, location, searchRoots, filePat
 // src/utils/targets.ts
 import { constants as constants5 } from "node:fs";
 import { access as access5 } from "node:fs/promises";
-import path17 from "node:path";
+import path18 from "node:path";
 var TARGET_FILE_CANDIDATES = [
   "targets.yaml",
   "targets.yml",
-  path17.join(".agentv", "targets.yaml"),
-  path17.join(".agentv", "targets.yml")
+  path18.join(".agentv", "targets.yaml"),
+  path18.join(".agentv", "targets.yml")
 ];
 async function fileExists5(filePath) {
   try {
@@ -40753,12 +41334,12 @@ async function fileExists5(filePath) {
 async function discoverTargetsFile(options) {
   const { explicitPath, testFilePath, repoRoot, cwd } = options;
   if (explicitPath) {
-    const resolvedExplicit = path17.resolve(explicitPath);
+    const resolvedExplicit = path18.resolve(explicitPath);
     if (await fileExists5(resolvedExplicit)) {
       return resolvedExplicit;
     }
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const nested = path17.join(resolvedExplicit, candidate);
+      const nested = path18.join(resolvedExplicit, candidate);
       if (await fileExists5(nested)) {
         return nested;
       }
@@ -40766,13 +41347,13 @@ async function discoverTargetsFile(options) {
     throw new Error(`targets.yaml not found at provided path: ${resolvedExplicit}`);
   }
   const directories = [...buildDirectoryChain(testFilePath, repoRoot)];
-  const resolvedCwd = path17.resolve(cwd);
+  const resolvedCwd = path18.resolve(cwd);
   if (!directories.includes(resolvedCwd)) {
     directories.push(resolvedCwd);
   }
   for (const directory of directories) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path17.join(directory, candidate);
+      const fullPath = path18.join(directory, candidate);
       if (await fileExists5(fullPath)) {
         return fullPath;
       }
@@ -40881,7 +41462,7 @@ Errors in ${targetsFilePath}:`);
     };
   }
   try {
-    const resolvedTarget = resolveTargetDefinition(targetDefinition, env);
+    const resolvedTarget = resolveTargetDefinition(targetDefinition, env, testFilePath);
     return {
       definitions,
       resolvedTarget,
@@ -40938,7 +41519,9 @@ function normalizeOptions(rawOptions) {
     maxRetries: normalizeNumber(rawOptions.maxRetries, 2),
     cache: normalizeBoolean(rawOptions.cache),
     verbose: normalizeBoolean(rawOptions.verbose),
-    dumpPrompts: rawOptions.dumpPrompts
+    dumpPrompts: rawOptions.dumpPrompts,
+    dumpTraces: normalizeBoolean(rawOptions.dumpTraces),
+    includeTrace: normalizeBoolean(rawOptions.includeTrace)
   };
 }
 async function ensureFileExists(filePath, description) {
@@ -40949,15 +41532,15 @@ async function ensureFileExists(filePath, description) {
   }
 }
 async function findRepoRoot(start) {
-  const fallback = path18.resolve(start);
+  const fallback = path19.resolve(start);
   let current = fallback;
   while (current !== void 0) {
-    const candidate = path18.join(current, ".git");
+    const candidate = path19.join(current, ".git");
     try {
       await access6(candidate, constants6.F_OK);
       return current;
     } catch {
-      const parent = path18.dirname(current);
+      const parent = path19.dirname(current);
       if (parent === current) {
         break;
       }
@@ -40970,16 +41553,16 @@ function buildDefaultOutputPath(cwd, format) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const baseName = "eval";
   const extension = getDefaultExtension(format);
-  return path18.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
+  return path19.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
 }
 function resolvePromptDirectory(option4, cwd) {
   if (option4 === void 0) {
     return void 0;
   }
   if (typeof option4 === "string" && option4.trim().length > 0) {
-    return path18.resolve(cwd, option4);
+    return path19.resolve(cwd, option4);
   }
-  return path18.join(cwd, ".agentv", "prompts");
+  return path19.join(cwd, ".agentv", "prompts");
 }
 function createEvaluationCache() {
   const store = /* @__PURE__ */ new Map();
@@ -41004,7 +41587,7 @@ function createProgressReporter(maxWorkers) {
   };
 }
 function makeEvalKey(testFilePath, evalId) {
-  return `${path18.resolve(testFilePath)}::${evalId}`;
+  return `${path19.resolve(testFilePath)}::${evalId}`;
 }
 function createDisplayIdTracker() {
   const map2 = /* @__PURE__ */ new Map();
@@ -41108,10 +41691,6 @@ async function runSingleEvalFile(params) {
     );
     resolvedWorkers = 1;
   }
-  if (options.verbose) {
-    const workersSource = workerPreference ? "CLI flag (balanced across files)" : resolvedTargetSelection.resolvedTarget.workers ? "target setting" : "default";
-    console.log(`Using ${resolvedWorkers} worker(s) (source: ${workersSource})`);
-  }
   if (isVSCodeProvider && !options.dryRun) {
     await ensureVSCodeSubagents({
       kind: resolvedTargetSelection.resolvedTarget.kind,
@@ -41164,7 +41743,7 @@ async function runEvalCommand(input) {
   if (options.verbose) {
     console.log(`Repository root: ${repoRoot}`);
   }
-  const outputPath = options.outPath ? path18.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
+  const outputPath = options.outPath ? path19.resolve(options.outPath) : buildDefaultOutputPath(cwd, options.format);
   console.log(`Output path: ${outputPath}`);
   const outputWriter = await createOutputWriter(outputPath, options.format);
   const cache = options.cache ? createEvaluationCache() : void 0;
@@ -41172,7 +41751,7 @@ async function runEvalCommand(input) {
   const allResults = [];
   let lastPromptDumpDir;
   const seenEvalCases = /* @__PURE__ */ new Set();
-  const resolvedTestFiles = input.testFiles.map((file2) => path18.resolve(file2));
+  const resolvedTestFiles = input.testFiles.map((file2) => path19.resolve(file2));
   const displayIdTracker = createDisplayIdTracker();
   const totalWorkers = options.workers ?? DEFAULT_WORKERS;
   const fileConcurrency = Math.min(
@@ -41268,7 +41847,7 @@ async function resolveEvaluationRunner() {
   if (!overridePath) {
     return runEvaluation;
   }
-  const resolved = path18.isAbsolute(overridePath) ? overridePath : path18.resolve(process.cwd(), overridePath);
+  const resolved = path19.isAbsolute(overridePath) ? overridePath : path19.resolve(process.cwd(), overridePath);
   const moduleUrl = pathToFileURL(resolved).href;
   const mod = await import(moduleUrl);
   const candidate = mod.runEvaluation;
@@ -41369,6 +41948,14 @@ var evalCommand = command({
       type: optional2(string4),
       long: "dump-prompts",
       description: "Directory path for persisting prompt payloads for debugging"
+    }),
+    dumpTraces: flag({
+      long: "dump-traces",
+      description: "Write trace files to .agentv/traces/"
+    }),
+    includeTrace: flag({
+      long: "include-trace",
+      description: "Include full trace in result output (verbose)"
     })
   },
   handler: async (args) => {
@@ -41389,7 +41976,9 @@ var evalCommand = command({
       maxRetries: args.maxRetries,
       cache: args.cache,
       verbose: args.verbose,
-      dumpPrompts
+      dumpPrompts,
+      dumpTraces: args.dumpTraces,
+      includeTrace: args.includeTrace
     };
     await runEvalCommand({ testFiles: resolvedPaths, rawOptions });
   }
@@ -41402,7 +41991,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
   const unmatched = [];
   const results = /* @__PURE__ */ new Set();
   for (const pattern of normalizedInputs) {
-    const candidatePath = path19.isAbsolute(pattern) ? path19.normalize(pattern) : path19.resolve(cwd, pattern);
+    const candidatePath = path20.isAbsolute(pattern) ? path20.normalize(pattern) : path20.resolve(cwd, pattern);
     try {
       const stats = await stat4(candidatePath);
       if (stats.isFile() && /\.ya?ml$/i.test(candidatePath)) {
@@ -41426,7 +42015,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
       continue;
     }
     for (const filePath of yamlMatches) {
-      results.add(path19.normalize(filePath));
+      results.add(path20.normalize(filePath));
     }
   }
   if (unmatched.length > 0) {
@@ -41446,7 +42035,7 @@ import { command as command2, flag as flag2, option as option2, optional as opti
 
 // src/commands/generate/rubrics.ts
 import { readFile as readFile8, writeFile as writeFile6 } from "node:fs/promises";
-import path20 from "node:path";
+import path21 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { isMap, isSeq, parseDocument } from "yaml";
 function isJsonObject3(value) {
@@ -41458,7 +42047,7 @@ function asString6(value) {
 async function loadRubricGenerator() {
   const customGenerator = process.env.AGENTEVO_CLI_RUBRIC_GENERATOR;
   if (customGenerator) {
-    const generatorPath = path20.resolve(customGenerator);
+    const generatorPath = path21.resolve(customGenerator);
     const generatorUrl = pathToFileURL2(generatorPath).href;
     const module = await import(generatorUrl);
     return module.generateRubrics;
@@ -41468,7 +42057,7 @@ async function loadRubricGenerator() {
 async function generateRubricsCommand(options) {
   const { file: file2, target: targetOverride, verbose } = options;
   console.log(`Generating rubrics for: ${file2}`);
-  const absolutePath = path20.resolve(file2);
+  const absolutePath = path21.resolve(file2);
   const content = await readFile8(absolutePath, "utf8");
   const doc = parseDocument(content);
   const parsed = doc.toJSON();
@@ -41629,13 +42218,13 @@ var generateCommand = subcommands({
 
 // src/commands/init/index.ts
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import * as readline from "node:readline/promises";
 import { command as command3, option as option3, optional as optional4, string as string6 } from "cmd-ts";
 
 // src/templates/index.ts
 import { readFileSync, readdirSync, statSync } from "node:fs";
-import path21 from "node:path";
+import path24 from "node:path";
 import { fileURLToPath } from "node:url";
 function getGithubTemplates() {
   return getTemplatesFromDir(".github");
@@ -41647,12 +42236,12 @@ function getClaudeTemplates() {
   return getTemplatesFromDir(".claude");
 }
 function getTemplatesFromDir(subdir) {
-  const currentDir = path21.dirname(fileURLToPath(import.meta.url));
+  const currentDir = path24.dirname(fileURLToPath(import.meta.url));
   let templatesDir;
-  if (currentDir.includes(`${path21.sep}dist`)) {
-    templatesDir = path21.join(currentDir, "templates", subdir);
+  if (currentDir.includes(`${path24.sep}dist`)) {
+    templatesDir = path24.join(currentDir, "templates", subdir);
   } else {
-    templatesDir = path21.join(currentDir, subdir);
+    templatesDir = path24.join(currentDir, subdir);
   }
   return readTemplatesRecursively(templatesDir, "");
 }
@@ -41660,15 +42249,15 @@ function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
   const entries = readdirSync(dir);
   for (const entry of entries) {
-    const fullPath = path21.join(dir, entry);
+    const fullPath = path24.join(dir, entry);
     const stat6 = statSync(fullPath);
-    const entryRelativePath = relativePath ? path21.join(relativePath, entry) : entry;
+    const entryRelativePath = relativePath ? path24.join(relativePath, entry) : entry;
     if (stat6.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync(fullPath, "utf-8");
       templates.push({
-        path: entryRelativePath.split(path21.sep).join("/"),
+        path: entryRelativePath.split(path24.sep).join("/"),
         // Normalize to forward slashes
         content
       });
@@ -41691,10 +42280,10 @@ async function promptYesNo(message) {
   }
 }
 async function initCommand(options = {}) {
-  const targetPath = path24.resolve(options.targetPath ?? ".");
-  const githubDir = path24.join(targetPath, ".github");
-  const agentvDir = path24.join(targetPath, ".agentv");
-  const claudeDir = path24.join(targetPath, ".claude");
+  const targetPath = path25.resolve(options.targetPath ?? ".");
+  const githubDir = path25.join(targetPath, ".github");
+  const agentvDir = path25.join(targetPath, ".agentv");
+  const claudeDir = path25.join(targetPath, ".claude");
   const githubTemplates = getGithubTemplates();
   const agentvTemplates = getAgentvTemplates();
   const claudeTemplates = getClaudeTemplates();
@@ -41702,32 +42291,32 @@ async function initCommand(options = {}) {
   const otherAgentvTemplates = agentvTemplates.filter((t) => t.path !== ".env.template");
   const existingFiles = [];
   if (envTemplate) {
-    const envFilePath = path24.join(targetPath, ".env.template");
+    const envFilePath = path25.join(targetPath, ".env.template");
     if (existsSync(envFilePath)) {
       existingFiles.push(".env.template");
     }
   }
   if (existsSync(githubDir)) {
     for (const template of githubTemplates) {
-      const targetFilePath = path24.join(githubDir, template.path);
+      const targetFilePath = path25.join(githubDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path24.relative(targetPath, targetFilePath));
+        existingFiles.push(path25.relative(targetPath, targetFilePath));
       }
     }
   }
   if (existsSync(agentvDir)) {
     for (const template of otherAgentvTemplates) {
-      const targetFilePath = path24.join(agentvDir, template.path);
+      const targetFilePath = path25.join(agentvDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path24.relative(targetPath, targetFilePath));
+        existingFiles.push(path25.relative(targetPath, targetFilePath));
       }
     }
   }
   if (existsSync(claudeDir)) {
     for (const template of claudeTemplates) {
-      const targetFilePath = path24.join(claudeDir, template.path);
+      const targetFilePath = path25.join(claudeDir, template.path);
       if (existsSync(targetFilePath)) {
-        existingFiles.push(path24.relative(targetPath, targetFilePath));
+        existingFiles.push(path25.relative(targetPath, targetFilePath));
       }
     }
   }
@@ -41754,36 +42343,36 @@ async function initCommand(options = {}) {
     mkdirSync(claudeDir, { recursive: true });
   }
   if (envTemplate) {
-    const envFilePath = path24.join(targetPath, ".env.template");
+    const envFilePath = path25.join(targetPath, ".env.template");
     writeFileSync(envFilePath, envTemplate.content, "utf-8");
     console.log("Created .env.template");
   }
   for (const template of githubTemplates) {
-    const targetFilePath = path24.join(githubDir, template.path);
-    const targetDirPath = path24.dirname(targetFilePath);
+    const targetFilePath = path25.join(githubDir, template.path);
+    const targetDirPath = path25.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path24.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path25.relative(targetPath, targetFilePath)}`);
   }
   for (const template of otherAgentvTemplates) {
-    const targetFilePath = path24.join(agentvDir, template.path);
-    const targetDirPath = path24.dirname(targetFilePath);
+    const targetFilePath = path25.join(agentvDir, template.path);
+    const targetDirPath = path25.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path24.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path25.relative(targetPath, targetFilePath)}`);
   }
   for (const template of claudeTemplates) {
-    const targetFilePath = path24.join(claudeDir, template.path);
-    const targetDirPath = path24.dirname(targetFilePath);
+    const targetFilePath = path25.join(claudeDir, template.path);
+    const targetDirPath = path25.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path24.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path25.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log("\nFiles installed to root:");
@@ -41791,17 +42380,17 @@ async function initCommand(options = {}) {
     console.log("  - .env.template");
   }
   console.log(`
-Files installed to ${path24.relative(targetPath, githubDir)}:`);
+Files installed to ${path25.relative(targetPath, githubDir)}:`);
   for (const t of githubTemplates) {
     console.log(`  - ${t.path}`);
   }
   console.log(`
-Files installed to ${path24.relative(targetPath, agentvDir)}:`);
+Files installed to ${path25.relative(targetPath, agentvDir)}:`);
   for (const t of otherAgentvTemplates) {
     console.log(`  - ${t.path}`);
   }
   console.log(`
-Files installed to ${path24.relative(targetPath, claudeDir)}:`);
+Files installed to ${path25.relative(targetPath, claudeDir)}:`);
   for (const t of claudeTemplates) {
     console.log(`  - ${t.path}`);
   }
@@ -41916,7 +42505,7 @@ function isTTY2() {
 // src/commands/validate/validate-files.ts
 import { constants as constants7 } from "node:fs";
 import { access as access7, readdir as readdir3, stat as stat5 } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
   const results = [];
@@ -41934,7 +42523,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path25.resolve(filePath);
+  const absolutePath = path26.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   let result;
   if (fileType === "eval") {
@@ -41959,7 +42548,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = [];
   for (const inputPath of paths) {
-    const absolutePath = path25.resolve(inputPath);
+    const absolutePath = path26.resolve(inputPath);
     try {
       await access7(absolutePath, constants7.F_OK);
     } catch {
@@ -41983,7 +42572,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries = await readdir3(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path25.join(dirPath, entry.name);
+      const fullPath = path26.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -42000,7 +42589,7 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path25.extname(filePath).toLowerCase();
+  const ext = path26.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 
@@ -42058,4 +42647,4 @@ export {
   app,
   runCli
 };
-//# sourceMappingURL=chunk-4T62HFF4.js.map
+//# sourceMappingURL=chunk-ZVSFP6NK.js.map