@agentv/core 4.13.0 → 4.14.0

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   resolveDelegatedTargetDefinition,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-SWLNU3I6.js";
+} from "./chunk-A3HYVKTI.js";
 import {
   execFileWithStdin,
   execShellWithStdin
@@ -3568,7 +3568,11 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
   if (format === "agent-skills-json") {
     return { tests: await loadTestsFromAgentSkills(evalFilePath) };
   }
-  const { tests, parsed } = await loadTestsFromYaml(evalFilePath, repoRoot, options);
+  const { tests, parsed, suiteWorkspacePath } = await loadTestsFromYaml(
+    evalFilePath,
+    repoRoot,
+    options
+  );
   const metadata = parseMetadata(parsed);
   const failOnError = extractFailOnError(parsed);
   const threshold = extractThreshold(parsed);
@@ -3581,7 +3585,8 @@ async function loadTestSuite(evalFilePath, repoRoot, options) {
     totalBudgetUsd: extractTotalBudgetUsd(parsed),
     ...metadata !== void 0 && { metadata },
     ...failOnError !== void 0 && { failOnError },
-    ...threshold !== void 0 && { threshold }
+    ...threshold !== void 0 && { threshold },
+    ...suiteWorkspacePath !== void 0 && { workspacePath: suiteWorkspacePath }
   };
 }
 var loadEvalSuite = loadTestSuite;
@@ -3743,6 +3748,11 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
     const mergedWorkspace = mergeWorkspaceConfigs(suiteWorkspace, caseWorkspace);
     const metadata = isJsonObject(testCaseConfig.metadata) ? testCaseConfig.metadata : void 0;
     const caseTargets = extractTargetsFromTestCase(testCaseConfig);
+    const dependsOn = Array.isArray(testCaseConfig.depends_on) ? testCaseConfig.depends_on.filter(
+      (v) => typeof v === "string"
+    ) : void 0;
+    const onDependencyFailureRaw = asString5(testCaseConfig.on_dependency_failure);
+    const onDependencyFailure = onDependencyFailureRaw === "skip" || onDependencyFailureRaw === "fail" || onDependencyFailureRaw === "run" ? onDependencyFailureRaw : void 0;
     const testCase = {
       id,
       suite: suiteName,
@@ -3760,11 +3770,13 @@ async function loadTestsFromYaml(evalFilePath, repoRoot, options) {
       workspace: mergedWorkspace,
       metadata,
       targets: caseTargets,
-      ...caseThreshold !== void 0 ? { threshold: caseThreshold } : {}
+      ...caseThreshold !== void 0 ? { threshold: caseThreshold } : {},
+      ...dependsOn && dependsOn.length > 0 ? { depends_on: dependsOn } : {},
+      ...onDependencyFailure ? { on_dependency_failure: onDependencyFailure } : {}
     };
     results.push(testCase);
   }
-  return { tests: results, parsed: suite };
+  return { tests: results, parsed: suite, suiteWorkspacePath: suiteWorkspace?.path };
 }
 async function loadTestById(evalFilePath, repoRoot, evalId) {
   const tests = await loadTests(evalFilePath, repoRoot);
@@ -6612,11 +6624,123 @@ function formatElapsed3(startedAt) {
 // src/evaluation/providers/copilot-cli.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path16 from "node:path";
+import { homedir as homedir2 } from "node:os";
+import path17 from "node:path";
 import { Readable, Writable } from "node:stream";
 import { spawn as spawn2 } from "node:child_process";
 import * as acp from "@agentclientprotocol/sdk";
 
+// src/evaluation/workspace/file-changes.ts
+import { exec as execCallback } from "node:child_process";
+import { readdirSync, statSync } from "node:fs";
+import { readFile as readFile9, readdir, stat } from "node:fs/promises";
+import path15 from "node:path";
+import { promisify as promisify2 } from "node:util";
+var execAsync2 = promisify2(execCallback);
+var SNAPSHOT_MAX_FILE_BYTES = 512 * 1024;
+var SNAPSHOT_EXCLUDE_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".agentv", "__pycache__"]);
+function gitExecOpts(workspacePath) {
+  const { GIT_DIR: _, GIT_WORK_TREE: __, ...env } = process.env;
+  return { cwd: workspacePath, env };
+}
+async function initializeBaseline(workspacePath) {
+  const opts = gitExecOpts(workspacePath);
+  await execAsync2("git init", opts);
+  await execAsync2("git add -A", opts);
+  await execAsync2(
+    'git -c user.email=agentv@localhost -c user.name=agentv commit --allow-empty -m "agentv-baseline"',
+    opts
+  );
+  const { stdout } = await execAsync2("git rev-parse HEAD", opts);
+  return stdout.trim();
+}
+async function captureFileChanges(workspacePath, baselineCommit) {
+  const opts = gitExecOpts(workspacePath);
+  await stageNestedRepoChanges(workspacePath);
+  await execAsync2("git add -A", opts);
+  const { stdout } = await execAsync2(`git diff ${baselineCommit} --submodule=diff`, opts);
+  return stdout.trim();
+}
+async function stageNestedRepoChanges(workspacePath) {
+  let entries;
+  try {
+    entries = readdirSync(workspacePath);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry === ".git" || entry === "node_modules") continue;
+    const childPath = path15.join(workspacePath, entry);
+    try {
+      if (!statSync(childPath).isDirectory()) continue;
+      if (!statSync(path15.join(childPath, ".git")).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const childOpts = gitExecOpts(childPath);
+    await execAsync2("git add -A", childOpts);
+  }
+}
+async function captureSnapshot(dir) {
+  const snapshot = /* @__PURE__ */ new Map();
+  await walkDir(dir, dir, snapshot);
+  return snapshot;
+}
+async function walkDir(rootDir, currentDir, snapshot) {
+  let entries;
+  try {
+    entries = await readdir(currentDir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SNAPSHOT_EXCLUDE_DIRS.has(entry)) continue;
+    const fullPath = path15.join(currentDir, entry);
+    let fileStat;
+    try {
+      fileStat = await stat(fullPath);
+    } catch {
+      continue;
+    }
+    if (fileStat.isDirectory()) {
+      await walkDir(rootDir, fullPath, snapshot);
+    } else if (fileStat.isFile()) {
+      if (fileStat.size > SNAPSHOT_MAX_FILE_BYTES) continue;
+      let content;
+      try {
+        content = await readFile9(fullPath, "utf8");
+        if (content.includes("\0")) continue;
+      } catch {
+        continue;
+      }
+      const relativePath = path15.relative(rootDir, fullPath).replace(/\\/g, "/");
+      snapshot.set(relativePath, content);
+    }
+  }
+}
+function generateNewFileDiff(relativePath, content) {
+  const lines = content.endsWith("\n") ? content.slice(0, -1).split("\n") : content.split("\n");
+  const addedLines = lines.map((l) => `+${l}`).join("\n");
+  return [
+    `diff --git a/${relativePath} b/${relativePath}`,
+    "new file mode 100644",
+    "--- /dev/null",
+    `+++ b/${relativePath}`,
+    `@@ -0,0 +1,${lines.length} @@`,
+    addedLines
+  ].join("\n");
+}
+async function captureSessionArtifacts(filesDir, pathPrefix = "") {
+  const snapshot = await captureSnapshot(filesDir).catch(() => void 0);
+  if (!snapshot || snapshot.size === 0) return void 0;
+  const parts = [];
+  for (const [relPath, content] of snapshot) {
+    const displayPath = pathPrefix ? `${pathPrefix}/${relPath}` : relPath;
+    parts.push(generateNewFileDiff(displayPath, content));
+  }
+  return parts.join("\n");
+}
+
 // src/evaluation/providers/copilot-cli-log-tracker.ts
 var GLOBAL_LOGS_KEY3 = Symbol.for("agentv.copilotCliLogs");
 var GLOBAL_SUBSCRIBERS_KEY3 = Symbol.for("agentv.copilotCliLogSubscribers");
@@ -6672,9 +6796,9 @@ function subscribeToCopilotCliLogEntries(listener) {
 
 // src/evaluation/providers/copilot-utils.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { createWriteStream as createWriteStream4, existsSync, readdirSync } from "node:fs";
+import { createWriteStream as createWriteStream4, existsSync, readdirSync as readdirSync2 } from "node:fs";
 import { arch, homedir, platform } from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function resolvePlatformCliPath() {
   const os4 = platform();
@@ -6698,7 +6822,7 @@ function resolvePlatformCliPath() {
   try {
     const resolved = import.meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath3(resolved) : resolved;
-    const binaryPath = path15.join(path15.dirname(packageJsonPath), binaryName);
+    const binaryPath = path16.join(path16.dirname(packageJsonPath), binaryName);
     if (existsSync(binaryPath)) {
       return binaryPath;
     }
@@ -6706,7 +6830,7 @@ function resolvePlatformCliPath() {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    const standardPath = path15.join(
+    const standardPath = path16.join(
       searchDir,
       "node_modules",
       ...packageName.split("/"),
@@ -6715,13 +6839,13 @@ function resolvePlatformCliPath() {
     if (existsSync(standardPath)) {
       return standardPath;
     }
-    const bunDir = path15.join(searchDir, "node_modules", ".bun");
+    const bunDir = path16.join(searchDir, "node_modules", ".bun");
     const prefix = `@github+copilot-${osPart}-${archPart}@`;
     try {
-      const entries = readdirSync(bunDir);
+      const entries = readdirSync2(bunDir);
       for (const entry of entries) {
         if (entry.startsWith(prefix)) {
-          const candidate = path15.join(
+          const candidate = path16.join(
             bunDir,
             entry,
             "node_modules",
@@ -6736,16 +6860,16 @@ function resolvePlatformCliPath() {
       }
     } catch {
     }
-    const parent = path15.dirname(searchDir);
+    const parent = path16.dirname(searchDir);
     if (parent === searchDir) break;
     searchDir = parent;
   }
   for (const root of globalNpmRoots()) {
-    const hoisted = path15.join(root, "@github", `copilot-${osPart}-${archPart}`, binaryName);
+    const hoisted = path16.join(root, "@github", `copilot-${osPart}-${archPart}`, binaryName);
     if (existsSync(hoisted)) {
       return hoisted;
     }
-    const nested = path15.join(
+    const nested = path16.join(
       root,
       "@github",
       "copilot",
@@ -6766,20 +6890,20 @@ function globalNpmRoots() {
   const home = homedir();
   if (os4 === "win32") {
     if (process.env.APPDATA) {
-      roots.push(path15.join(process.env.APPDATA, "npm", "node_modules"));
+      roots.push(path16.join(process.env.APPDATA, "npm", "node_modules"));
     }
-    roots.push(path15.join(home, "AppData", "Roaming", "npm", "node_modules"));
+    roots.push(path16.join(home, "AppData", "Roaming", "npm", "node_modules"));
   } else {
     roots.push("/opt/homebrew/lib/node_modules");
     roots.push("/usr/local/lib/node_modules");
     roots.push("/usr/lib/node_modules");
-    roots.push(path15.join(home, ".npm-global", "lib", "node_modules"));
-    roots.push(path15.join(home, ".local", "lib", "node_modules"));
+    roots.push(path16.join(home, ".npm-global", "lib", "node_modules"));
+    roots.push(path16.join(home, ".local", "lib", "node_modules"));
   }
   if (process.env.npm_config_prefix) {
     const prefix = process.env.npm_config_prefix;
     roots.push(
-      os4 === "win32" ? path15.join(prefix, "node_modules") : path15.join(prefix, "lib", "node_modules")
+      os4 === "win32" ? path16.join(prefix, "node_modules") : path16.join(prefix, "lib", "node_modules")
     );
   }
   return Array.from(new Set(roots));
@@ -6826,14 +6950,22 @@ var CopilotStreamLogger = class _CopilotStreamLogger {
   startedAt = Date.now();
   format;
   summarize;
-  constructor(filePath, format, summarize) {
+  chunkExtractor;
+  pendingText = "";
+  constructor(filePath, format, summarize, chunkExtractor) {
     this.filePath = filePath;
     this.format = format;
     this.summarize = summarize;
+    this.chunkExtractor = chunkExtractor;
     this.stream = createWriteStream4(filePath, { flags: "a" });
   }
   static async create(options, summarize) {
-    const logger = new _CopilotStreamLogger(options.filePath, options.format, summarize);
+    const logger = new _CopilotStreamLogger(
+      options.filePath,
+      options.format,
+      summarize,
+      options.chunkExtractor
+    );
     const header = [
       `# ${options.headerLabel} stream log`,
       `# target: ${options.targetName}`,
@@ -6849,19 +6981,42 @@ var CopilotStreamLogger = class _CopilotStreamLogger {
     return logger;
   }
   handleEvent(eventType, data) {
-    const elapsed = formatElapsed4(this.startedAt);
     if (this.format === "json") {
-      this.stream.write(`${JSON.stringify({ time: elapsed, event: eventType, data })}
-`);
-    } else {
-      const summary = this.summarize(eventType, data);
-      if (summary) {
-        this.stream.write(`[+${elapsed}] [${eventType}] ${summary}
+      const elapsed2 = formatElapsed4(this.startedAt);
+      this.stream.write(`${JSON.stringify({ time: elapsed2, event: eventType, data })}
 `);
+      return;
+    }
+    if (this.chunkExtractor) {
+      const chunkText = this.chunkExtractor(eventType, data);
+      if (chunkText === null) {
+        this.pendingText = "";
+        return;
+      }
+      if (chunkText !== void 0) {
+        this.pendingText += chunkText;
+        return;
       }
+      this.flushPendingText();
+    }
+    const elapsed = formatElapsed4(this.startedAt);
+    const summary = this.summarize(eventType, data);
+    if (summary) {
+      this.stream.write(`[+${elapsed}] [${eventType}] ${summary}
+`);
     }
   }
+  flushPendingText() {
+    if (!this.pendingText) return;
+    const elapsed = formatElapsed4(this.startedAt);
+    this.stream.write(`[+${elapsed}] [assistant_message] ${this.pendingText}
+`);
+    this.pendingText = "";
+  }
   async close() {
+    if (this.format !== "json") {
+      this.flushPendingText();
+    }
     await new Promise((resolve, reject) => {
       this.stream.once("error", reject);
       this.stream.end(() => resolve());
@@ -7070,6 +7225,10 @@ var CopilotCliProvider = class {
           content: finalContent
         });
       }
+      const sessionId = session.sessionId;
+      const fileChanges = sessionId ? await captureSessionArtifacts(
+        path17.join(homedir2(), ".copilot", "session-state", sessionId, "files")
+      ).catch(() => void 0) : void 0;
       return {
         raw: {
           model: this.config.model,
@@ -7081,7 +7240,8 @@ var CopilotCliProvider = class {
         costUsd,
         durationMs,
         startTime,
-        endTime
+        endTime,
+        ...fileChanges ? { fileChanges } : {}
       };
     } finally {
       await logger?.close();
@@ -7122,10 +7282,10 @@ var CopilotCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path16.resolve(cwdOverride);
+      return path17.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path16.resolve(this.config.cwd);
+      return path17.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -7144,9 +7304,9 @@ var CopilotCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path16.resolve(this.config.logDir);
+      return path17.resolve(this.config.logDir);
     }
-    return path16.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+    return path17.join(process.cwd(), ".agentv", "logs", "copilot-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -7160,7 +7320,7 @@ var CopilotCliProvider = class {
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path16.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
+    const filePath = path17.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -7169,7 +7329,8 @@ var CopilotCliProvider = class {
           evalCaseId: request.evalCaseId,
           attempt: request.attempt,
           format: this.config.logFormat ?? "summary",
-          headerLabel: "Copilot CLI (ACP)"
+          headerLabel: "Copilot CLI (ACP)",
+          chunkExtractor: extractAcpChunk
         },
         summarizeAcpEvent
       );
@@ -7228,6 +7389,14 @@ Fix options:
    - In .env: COPILOT_EXE=C:\\Users\\<you>\\AppData\\Roaming\\npm\\node_modules\\@github\\copilot-win32-x64\\copilot.exe
   - In .agentv/targets.yaml: executable: \${{ COPILOT_EXE }}`;
 }
+function extractAcpChunk(eventType, data) {
+  if (eventType === "agent_thought_chunk") return null;
+  if (eventType !== "agent_message_chunk") return void 0;
+  if (!data || typeof data !== "object") return void 0;
+  const d = data;
+  const content = d.content;
+  return content?.type === "text" && typeof content.text === "string" ? content.text : void 0;
+}
 function summarizeAcpEvent(eventType, data) {
   if (!data || typeof data !== "object") {
     return eventType;
@@ -7253,9 +7422,9 @@ function summarizeAcpEvent(eventType, data) {
 }
 
 // src/evaluation/providers/copilot-log.ts
-import { readFile as readFile10 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import path18 from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import path19 from "node:path";
 
 // src/evaluation/providers/copilot-log-parser.ts
 function parseCopilotEvents(eventsJsonl) {
@@ -7387,32 +7556,32 @@ function parseCopilotEvents(eventsJsonl) {
 }
 
 // src/evaluation/providers/copilot-session-discovery.ts
-import { readFile as readFile9, readdir, stat } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import path17 from "node:path";
+import { readFile as readFile10, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import path18 from "node:path";
 import { parse as parseYaml2 } from "yaml";
-var DEFAULT_SESSION_STATE_DIR = () => path17.join(homedir2(), ".copilot", "session-state");
+var DEFAULT_SESSION_STATE_DIR = () => path18.join(homedir3(), ".copilot", "session-state");
 async function discoverCopilotSessions(opts) {
   const sessionStateDir = opts?.sessionStateDir ?? DEFAULT_SESSION_STATE_DIR();
   const limit = opts?.limit ?? 10;
   let entries;
   try {
-    entries = await readdir(sessionStateDir);
+    entries = await readdir2(sessionStateDir);
   } catch {
     return [];
   }
   const sessions = [];
   for (const entry of entries) {
-    const sessionDir = path17.join(sessionStateDir, entry);
-    const workspacePath = path17.join(sessionDir, "workspace.yaml");
-    const eventsPath = path17.join(sessionDir, "events.jsonl");
+    const sessionDir = path18.join(sessionStateDir, entry);
+    const workspacePath = path18.join(sessionDir, "workspace.yaml");
+    const eventsPath = path18.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await readFile9(workspacePath, "utf8");
+      const workspaceContent = await readFile10(workspacePath, "utf8");
       const workspace = parseYaml2(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
       try {
-        const eventsStat = await stat(eventsPath);
+        const eventsStat = await stat2(eventsPath);
         updatedAt = eventsStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -7466,21 +7635,24 @@ var CopilotLogProvider = class {
   }
   async invoke(_request) {
     const sessionDir = await this.resolveSessionDir();
-    const eventsPath = path18.join(sessionDir, "events.jsonl");
+    const eventsPath = path19.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await readFile10(eventsPath, "utf8");
+      eventsContent = await readFile11(eventsPath, "utf8");
     } catch (err) {
       throw new Error(
         `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
       );
     }
     const parsed = parseCopilotEvents(eventsContent);
+    const filesDir = path19.join(sessionDir, "files");
+    const fileChanges = await captureSessionArtifacts(filesDir).catch(() => void 0);
     return {
       output: parsed.messages,
       tokenUsage: parsed.tokenUsage,
       durationMs: parsed.durationMs,
-      startTime: parsed.meta.startedAt
+      startTime: parsed.meta.startedAt,
+      ...fileChanges ? { fileChanges } : {}
     };
   }
   async resolveSessionDir() {
@@ -7488,8 +7660,8 @@ var CopilotLogProvider = class {
       return this.config.sessionDir;
     }
     if (this.config.sessionId) {
-      const stateDir = this.config.sessionStateDir ?? path18.join(homedir3(), ".copilot", "session-state");
-      return path18.join(stateDir, this.config.sessionId);
+      const stateDir = this.config.sessionStateDir ?? path19.join(homedir4(), ".copilot", "session-state");
+      return path19.join(stateDir, this.config.sessionId);
     }
     if (this.config.discover === "latest") {
       const sessions = await discoverCopilotSessions({
@@ -7514,7 +7686,7 @@ var CopilotLogProvider = class {
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path19 from "node:path";
+import path20 from "node:path";
 
 // src/evaluation/providers/copilot-sdk-log-tracker.ts
 var GLOBAL_LOGS_KEY4 = Symbol.for("agentv.copilotSdkLogs");
@@ -7760,6 +7932,10 @@ var CopilotSdkProvider = class {
           content: finalContent
         });
       }
+      const sessionWorkspacePath = session.workspacePath;
+      const fileChanges = sessionWorkspacePath ? await captureSessionArtifacts(path20.join(sessionWorkspacePath, "files")).catch(
+        () => void 0
+      ) : void 0;
       return {
         raw: {
           model: this.config.model,
@@ -7771,7 +7947,8 @@ var CopilotSdkProvider = class {
         costUsd,
         durationMs,
         startTime,
-        endTime
+        endTime,
+        ...fileChanges ? { fileChanges } : {}
       };
     } finally {
       unsubscribe();
@@ -7824,10 +8001,10 @@ var CopilotSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path19.resolve(cwdOverride);
+      return path20.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path19.resolve(this.config.cwd);
+      return path20.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -7836,9 +8013,9 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path19.resolve(this.config.logDir);
+      return path20.resolve(this.config.logDir);
     }
-    return path19.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
+    return path20.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -7852,7 +8029,7 @@ var CopilotSdkProvider = class {
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path19.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
+    const filePath = path20.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -7861,7 +8038,8 @@ var CopilotSdkProvider = class {
           evalCaseId: request.evalCaseId,
           attempt: request.attempt,
           format: this.config.logFormat ?? "summary",
-          headerLabel: "Copilot SDK"
+          headerLabel: "Copilot SDK",
+          chunkExtractor: extractSdkChunk
         },
         summarizeSdkEvent
       );
@@ -7881,9 +8059,9 @@ var CopilotSdkProvider = class {
 };
 function resolveSkillDirectories(cwd) {
   const candidates = [
-    path19.join(cwd, ".claude", "skills"),
-    path19.join(cwd, ".agents", "skills"),
-    path19.join(cwd, ".codex", "skills")
+    path20.join(cwd, ".claude", "skills"),
+    path20.join(cwd, ".agents", "skills"),
+    path20.join(cwd, ".codex", "skills")
   ];
   return candidates.filter((dir) => existsSync2(dir));
 }
@@ -7897,6 +8075,12 @@ function normalizeByokBaseUrl(baseUrl, type) {
   }
   return trimmed;
 }
+function extractSdkChunk(eventType, data) {
+  if (eventType !== "assistant.message_delta") return void 0;
+  if (!data || typeof data !== "object") return void 0;
+  const d = data;
+  return typeof d.deltaContent === "string" ? d.deltaContent : void 0;
+}
 function summarizeSdkEvent(eventType, data) {
   if (!data || typeof data !== "object") {
     return eventType;
@@ -7967,7 +8151,7 @@ import { randomUUID as randomUUID7 } from "node:crypto";
 import { accessSync, createWriteStream as createWriteStream5, readFileSync as readFileSync2 } from "node:fs";
 import { mkdir as mkdir6, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 
 // src/evaluation/providers/pi-log-tracker.ts
 var GLOBAL_LOGS_KEY5 = Symbol.for("agentv.piLogs");
@@ -8173,7 +8357,7 @@ var PiCliProvider = class {
     const cwd = this.resolveCwd(workspaceRoot, request.cwd);
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path20.join(cwd, PROMPT_FILENAME);
+      const promptFile = path21.join(cwd, PROMPT_FILENAME);
       await writeFile(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const result = await this.executePi(args, cwd, request.signal, logger);
@@ -8236,10 +8420,10 @@ var PiCliProvider = class {
   }
   resolveCwd(workspaceRoot, cwdOverride) {
     if (cwdOverride) {
-      return path20.resolve(cwdOverride);
+      return path21.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path20.resolve(this.config.cwd);
+      return path21.resolve(this.config.cwd);
     }
     if (workspaceRoot) {
       return workspaceRoot;
@@ -8345,7 +8529,7 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await mkdtemp(path20.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path21.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -8355,9 +8539,9 @@ ${prompt}` : prompt;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path20.resolve(this.config.logDir);
+      return path21.resolve(this.config.logDir);
     }
-    return path20.join(process.cwd(), ".agentv", "logs", "pi-cli");
+    return path21.join(process.cwd(), ".agentv", "logs", "pi-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -8371,7 +8555,7 @@ ${prompt}` : prompt;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path20.join(logDir, buildLogFilename5(request, this.targetName));
+    const filePath = path21.join(logDir, buildLogFilename5(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -8842,8 +9026,8 @@ function resolveWindowsCmd(executable) {
     const content = readFileSync2(cmdPath, "utf-8");
     const match = content.match(/"?%_prog%"?\s+"([^"]+\.js)"/);
     if (match) {
-      const dp0 = path20.dirname(path20.resolve(cmdPath));
-      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${path20.sep}`);
+      const dp0 = path21.dirname(path21.resolve(cmdPath));
+      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${path21.sep}`);
       try {
         accessSync(scriptPath);
         return ["node", [scriptPath]];
@@ -8922,13 +9106,13 @@ import { execSync as execSync2 } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { accessSync as accessSync2, createWriteStream as createWriteStream6, mkdirSync } from "node:fs";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import path22 from "node:path";
+import path23 from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath as fileURLToPath4, pathToFileURL } from "node:url";
 
 // src/paths.ts
 import os2 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 var logged = false;
 function getAgentvHome() {
   const envHome = process.env.AGENTV_HOME;
@@ -8939,19 +9123,19 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return path21.join(os2.homedir(), ".agentv");
+  return path22.join(os2.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return path21.join(getAgentvHome(), "workspaces");
+  return path22.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return path21.join(getAgentvHome(), "subagents");
+  return path22.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return path21.join(getAgentvHome(), "trace-state");
+  return path22.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return path21.join(getAgentvHome(), "workspace-pool");
+  return path22.join(getAgentvHome(), "workspace-pool");
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
@@ -8973,7 +9157,7 @@ async function promptInstall() {
   }
 }
 function findManagedSdkInstallRoot() {
-  return path22.join(getAgentvHome(), "deps", "pi-sdk");
+  return path23.join(getAgentvHome(), "deps", "pi-sdk");
 }
 function resolveGlobalNpmRoot() {
   try {
@@ -8987,7 +9171,7 @@ function resolveGlobalNpmRoot() {
   }
 }
 function buildGlobalModuleEntry(moduleName, globalNpmRoot) {
-  return path22.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
+  return path23.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
 }
 function findAccessiblePath(paths) {
   for (const candidate of paths) {
@@ -9013,11 +9197,11 @@ async function tryImportLocalSdkModules() {
 async function tryImportManagedSdkModules() {
   const managedRoot = findManagedSdkInstallRoot();
   const piCodingAgentEntry = findAccessiblePath([
-    path22.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
+    path23.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
   ]);
   const piAiEntry = findAccessiblePath([
-    path22.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
-    path22.join(
+    path23.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
+    path23.join(
       managedRoot,
       "node_modules",
       "@mariozechner",
@@ -9048,7 +9232,7 @@ async function tryImportGlobalSdkModules() {
   ]);
   const piAiEntry = findAccessiblePath([
     buildGlobalModuleEntry("@mariozechner/pi-ai", globalNpmRoot),
-    path22.join(
+    path23.join(
       globalNpmRoot,
       "@mariozechner",
       "pi-coding-agent",
@@ -9349,10 +9533,10 @@ ${fileList}`;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path22.resolve(cwdOverride);
+      return path23.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path22.resolve(this.config.cwd);
+      return path23.resolve(this.config.cwd);
     }
     return process.cwd();
   }
@@ -9371,9 +9555,9 @@ ${fileList}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path22.resolve(this.config.logDir);
+      return path23.resolve(this.config.logDir);
     }
-    return path22.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path23.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -9387,7 +9571,7 @@ ${fileList}`;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path22.join(logDir, buildLogFilename6(request, this.targetName));
+    const filePath = path23.join(logDir, buildLogFilename6(request, this.targetName));
     try {
       const logger = await PiStreamLogger2.create({
         filePath,
@@ -9601,18 +9785,18 @@ var ProviderRegistry = class {
 
 // src/evaluation/providers/vscode-provider.ts
 import { exec as exec2 } from "node:child_process";
-import { constants as constants3, access as access3, stat as stat5 } from "node:fs/promises";
-import path33 from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { constants as constants3, access as access3, stat as stat6 } from "node:fs/promises";
+import path34 from "node:path";
+import { promisify as promisify4 } from "node:util";
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
-import { stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
-import path31 from "node:path";
+import { stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
+import path32 from "node:path";
 
 // src/evaluation/providers/vscode/utils/fs.ts
 import { constants as constants2 } from "node:fs";
-import { access as access2, mkdir as mkdir8, readdir as readdir2, rm as rm2, stat as stat2 } from "node:fs/promises";
-import path23 from "node:path";
+import { access as access2, mkdir as mkdir8, readdir as readdir3, rm as rm2, stat as stat3 } from "node:fs/promises";
+import path24 from "node:path";
 async function pathExists(target) {
   try {
     await access2(target, constants2.F_OK);
@@ -9625,10 +9809,10 @@ async function ensureDir(target) {
   await mkdir8(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await readdir2(target, { withFileTypes: true });
+  const entries = await readdir3(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path23.join(target, entry.name),
+    absolutePath: path24.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -9643,9 +9827,9 @@ async function removeIfExists(target) {
 }
 
 // src/evaluation/providers/vscode/utils/path.ts
-import path24 from "node:path";
+import path25 from "node:path";
 function pathToFileUri2(filePath) {
-  const absolutePath = path24.isAbsolute(filePath) ? filePath : path24.resolve(filePath);
+  const absolutePath = path25.isAbsolute(filePath) ? filePath : path25.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -9654,7 +9838,7 @@ function pathToFileUri2(filePath) {
 }
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
-import path25 from "node:path";
+import path26 from "node:path";
 
 // src/evaluation/providers/vscode/utils/template.ts
 function renderTemplate2(content, variables) {
@@ -9746,8 +9930,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path25.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${path25.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path26.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path26.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -9755,8 +9939,8 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 }
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
-import { readFile as readFile11 } from "node:fs/promises";
-import path26 from "node:path";
+import { readFile as readFile12 } from "node:fs/promises";
+import path27 from "node:path";
 
 // src/evaluation/providers/vscode/utils/time.ts
 function sleep2(ms) {
@@ -9794,7 +9978,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile11(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile12(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -9815,7 +9999,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file) => path26.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => path27.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -9824,7 +10008,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => path26.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => path27.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -9851,7 +10035,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile11(file, { encoding: "utf8" });
+        const content = await readFile12(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -9875,21 +10059,21 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 import { exec, spawn as spawn4 } from "node:child_process";
 import { mkdir as mkdir9, writeFile as writeFile2 } from "node:fs/promises";
-import path28 from "node:path";
-import { promisify as promisify2 } from "node:util";
+import path29 from "node:path";
+import { promisify as promisify3 } from "node:util";
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
-import path27 from "node:path";
+import path28 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 path27.join(getSubagentsRoot(), folder);
+  return path28.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var execAsync2 = promisify2(exec);
+var execAsync3 = promisify3(exec);
 function shellQuote(cmd) {
   return cmd.includes(" ") ? `"${cmd}"` : cmd;
 }
@@ -9935,7 +10119,7 @@ async function raceSpawnError(child, graceMs = 200) {
 }
 async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
   try {
-    const { stdout } = await execAsync2(`${shellQuote(vscodeCmd)} --status`, {
+    const { stdout } = await execAsync3(`${shellQuote(vscodeCmd)} --status`, {
       timeout: 1e4,
       windowsHide: true
     });
@@ -9951,11 +10135,11 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = path28.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path29.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path28.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
   await mkdir9(githubAgentsDir, { recursive: true });
-  const wakeupDst = path28.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = path29.join(githubAgentsDir, "wakeup.md");
   await writeFile2(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
@@ -9968,7 +10152,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path28.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path29.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -9983,10 +10167,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = path28.join(subagentDir, `${path28.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path28.join(subagentDir, "messages");
+  const workspacePath = path29.join(subagentDir, `${path29.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path29.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
-  const reqFile = path28.join(messagesDir, `${timestamp}_req.md`);
+  const reqFile = path29.join(messagesDir, `${timestamp}_req.md`);
   await writeFile2(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
@@ -9994,16 +10178,16 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${path28.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${path29.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path28.basename(subagentDir),
+    path29.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path28.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path29.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -10011,8 +10195,8 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = path28.join(subagentDir, `${path28.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path28.join(subagentDir, "messages");
+  const workspacePath = path29.join(subagentDir, `${path29.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path29.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -10021,13 +10205,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path28.basename(subagentDir),
+    path29.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path28.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path29.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -10036,11 +10220,11 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-import { copyFile, mkdir as mkdir10, readFile as readFile12, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
-import path30 from "node:path";
+import { copyFile, mkdir as mkdir10, readFile as readFile13, readdir as readdir4, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
+import path31 from "node:path";
 
 // src/evaluation/providers/vscode/utils/workspace.ts
-import path29 from "node:path";
+import path30 from "node:path";
 import JSON5 from "json5";
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -10057,10 +10241,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path29.isAbsolute(folderPath)) {
+    if (path30.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path29.resolve(templateDir, folderPath);
+    const absolutePath = path30.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -10082,19 +10266,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path29.isAbsolute(locationPath);
+          const isAbsolute = path30.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path29.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path30.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 = (path29.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path30.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -10135,7 +10319,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 = path30.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path31.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -10145,26 +10329,26 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path30.resolve(workspaceTemplate);
+    const workspaceSrc = path31.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await stat3(workspaceSrc);
+    const stats = await stat4(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile12(workspaceSrc, "utf8");
+    const templateText = await readFile13(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path30.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path30.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path30.dirname(path30.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path31.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path31.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path31.dirname(path31.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = path30.resolve(cwd);
+    const absCwd = path31.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -10173,35 +10357,35 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     }
   }
   await writeFile3(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path30.join(subagentDir, "messages");
+  const messagesDir = path31.join(subagentDir, "messages");
   await mkdir10(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path30.join(subagentDir, "messages");
+  const messagesDir = path31.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await readdir3(messagesDir);
+    const files = await readdir4(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = path30.join(messagesDir, file);
+        const target = path31.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path30.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path31.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await readdir3(githubAgentsDir);
+    const agentFiles = await readdir4(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path30.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path31.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = path30.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path31.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile3(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path30.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path31.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -10221,9 +10405,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path30.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = path31.join(subagentDir, ".github", "agents");
     await mkdir10(githubAgentsDir, { recursive: true });
-    const agentFile = path30.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = path31.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error) {
@@ -10242,11 +10426,11 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path31.resolve(promptFile);
+  const resolvedPrompt = path32.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await stat4(resolvedPrompt);
+  const promptStats = await stat5(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -10258,7 +10442,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path31.resolve(attachment);
+    const resolvedPath = path32.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -10300,7 +10484,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path31.basename(subagentDir);
+    const subagentName = path32.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -10328,9 +10512,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path31.join(subagentDir, "messages");
-    const responseFileTmp = path31.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path31.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path32.join(subagentDir, "messages");
+    const responseFileTmp = path32.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path32.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -10435,7 +10619,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path31.basename(subagentDir);
+    subagentName = path32.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -10466,17 +10650,17 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path31.join(subagentDir, "messages");
+    const messagesDir = path32.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path31.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path32.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path31.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path32.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path31.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path32.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path31.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path32.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
@@ -10562,7 +10746,7 @@ async function dispatchBatchAgent(options) {
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path32 from "node:path";
+import path33 from "node:path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -10593,7 +10777,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path32.resolve(targetRoot);
+  const targetPath = path33.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -10613,7 +10797,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path32.join(entry.absolutePath, lockName);
+      const lockFile = path33.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -10630,10 +10814,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path32.join(subagentDir, ".github", "agents");
-    const lockFile = path32.join(subagentDir, lockName);
-    const workspaceDst = path32.join(subagentDir, `${path32.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path32.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path33.join(subagentDir, ".github", "agents");
+    const lockFile = path33.join(subagentDir, lockName);
+    const workspaceDst = path33.join(subagentDir, `${path33.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path33.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -10671,10 +10855,10 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path32.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path32.join(subagentDir, ".github", "agents");
-    const workspaceDst = path32.join(subagentDir, `${path32.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path32.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path33.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path33.join(subagentDir, ".github", "agents");
+    const workspaceDst = path33.join(subagentDir, `${path33.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path33.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -10721,7 +10905,7 @@ var AGENTV_BATCH_REQUEST_TEMPLATE = `[[ ## task ## ]]
 `;
 
 // src/evaluation/providers/vscode-provider.ts
-var execAsync3 = promisify3(exec2);
+var execAsync4 = promisify4(exec2);
 var VSCodeProvider = class {
   id;
   kind;
@@ -10864,7 +11048,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path33.isAbsolute(candidate) ? candidate : path33.resolve(candidate);
+    const resolved = path34.isAbsolute(candidate) ? candidate : path34.resolve(candidate);
     try {
       await access3(resolved, constants3.F_OK);
       return resolved;
@@ -10876,7 +11060,7 @@ async function locateVSCodeExecutable(candidate) {
   }
   const locator = process.platform === "win32" ? "where" : "which";
   try {
-    const { stdout } = await execAsync3(`${locator} ${candidate}`);
+    const { stdout } = await execAsync4(`${locator} ${candidate}`);
     const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
     if (lines.length > 0 && lines[0]) {
       await access3(lines[0], constants3.F_OK);
@@ -10893,7 +11077,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await stat5(path33.resolve(template));
+    const stats = await stat6(path34.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -10917,7 +11101,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path33.basename(absolutePath);
+    const fileName = path34.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -10938,7 +11122,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path33.resolve(attachment);
+    const absolutePath = path34.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -10946,7 +11130,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path33.isAbsolute(filePath) ? filePath : path33.resolve(filePath);
+  const absolutePath = path34.isAbsolute(filePath) ? filePath : path34.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -10959,7 +11143,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path33.resolve(attachment));
+    deduped.add(path34.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -10968,7 +11152,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path33.resolve(inputFile));
+      deduped.add(path34.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -11016,8 +11200,8 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 
 // src/evaluation/providers/targets-file.ts
 import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile13 } from "node:fs/promises";
-import path34 from "node:path";
+import { access as access4, readFile as readFile14 } from "node:fs/promises";
+import path35 from "node:path";
 import { parse as parse5 } from "yaml";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -11057,11 +11241,11 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path34.resolve(filePath);
+  const absolutePath = path35.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile13(absolutePath, "utf8");
+  const raw = await readFile14(absolutePath, "utf8");
   const parsed = parse5(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -11077,16 +11261,16 @@ function listTargetNames(definitions) {
 }
 
 // src/evaluation/providers/provider-discovery.ts
-import path35 from "node:path";
+import path36 from "node:path";
 import fg from "fast-glob";
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path35.resolve(baseDir);
-  const root = path35.parse(dir).root;
+  let dir = path36.resolve(baseDir);
+  const root = path36.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path35.join(dir, ".agentv", "providers"));
-    dir = path35.dirname(dir);
+    candidateDirs.push(path36.join(dir, ".agentv", "providers"));
+    dir = path36.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -11102,7 +11286,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = path35.basename(filePath);
+    const basename = path36.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -11767,7 +11951,7 @@ import { generateText as generateText3 } from "ai";
 
 // src/evaluation/evaluators/llm-grader.ts
 import fs2 from "node:fs/promises";
-import path36 from "node:path";
+import path37 from "node:path";
 import { generateText as generateText2, stepCountIs, tool } from "ai";
 import { z as z3 } from "zod";
 var DEFAULT_MAX_STEPS = 10;
@@ -12801,8 +12985,8 @@ function toAiSdkImageParts(images) {
   }));
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = path36.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + path36.sep) && resolved !== basePath) {
+  const resolved = path37.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + path37.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -12835,11 +13019,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat12 = await fs2.stat(resolved);
-          if (stat12.isDirectory()) {
+          const stat13 = await fs2.stat(resolved);
+          if (stat13.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
-          const buffer = Buffer.alloc(Math.min(stat12.size, MAX_FILE_SIZE));
+          const buffer = Buffer.alloc(Math.min(stat13.size, MAX_FILE_SIZE));
           const fd = await fs2.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -12847,8 +13031,8 @@ function createFilesystemTools(workspacePath) {
             await fd.close();
           }
           const content = buffer.toString("utf-8");
-          const truncated = stat12.size > MAX_FILE_SIZE;
-          return { content, truncated, size: stat12.size };
+          const truncated = stat13.size > MAX_FILE_SIZE;
+          return { content, truncated, size: stat13.size };
         } catch (error) {
           return { error: error instanceof Error ? error.message : String(error) };
         }
@@ -12892,15 +13076,15 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = path36.join(dirPath, entry.name);
+    const fullPath = path37.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = path36.extname(entry.name).toLowerCase();
+      const ext = path37.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat12 = await fs2.stat(fullPath);
-        if (stat12.size > MAX_FILE_SIZE) continue;
+        const stat13 = await fs2.stat(fullPath);
+        if (stat13.size > MAX_FILE_SIZE) continue;
         const content = await fs2.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -12908,7 +13092,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: path36.relative(workspacePath, fullPath),
+              file: path37.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -14868,7 +15052,7 @@ function runEqualsAssertion(output, value) {
 // src/evaluation/orchestrator.ts
 import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir14, readdir as readdir7, stat as stat8 } from "node:fs/promises";
+import { copyFile as copyFile2, mkdir as mkdir14, readdir as readdir8, stat as stat9 } from "node:fs/promises";
 import path45 from "node:path";
 import micromatch3 from "micromatch";
 
@@ -15083,7 +15267,7 @@ var InlineAssertEvaluator = class {
 };
 
 // src/evaluation/evaluators/prompt-resolution.ts
-import path37 from "node:path";
+import path38 from "node:path";
 async function resolveCustomPrompt(promptConfig, context, timeoutMs) {
   if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
     if (!context) {
@@ -15135,7 +15319,7 @@ async function executePromptTemplate(script, context, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path37.dirname(scriptPath);
+  const cwd = path38.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -15418,16 +15602,16 @@ function createBuiltinRegistry() {
 }
 
 // src/evaluation/registry/assertion-discovery.ts
-import path38 from "node:path";
+import path39 from "node:path";
 import fg2 from "fast-glob";
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path38.resolve(baseDir);
-  const root = path38.parse(dir).root;
+  let dir = path39.resolve(baseDir);
+  const root = path39.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path38.join(dir, ".agentv", "assertions"));
-    dir = path38.dirname(dir);
+    candidateDirs.push(path39.join(dir, ".agentv", "assertions"));
+    dir = path39.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -15443,7 +15627,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path38.basename(filePath);
+    const basename = path39.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -15461,17 +15645,17 @@ async function discoverAssertions(registry, baseDir) {
 }
 
 // src/evaluation/registry/grader-discovery.ts
-import path39 from "node:path";
+import path40 from "node:path";
 import fg3 from "fast-glob";
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path39.resolve(baseDir);
-  const root = path39.parse(dir).root;
+  let dir = path40.resolve(baseDir);
+  const root = path40.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path39.join(dir, ".agentv", "graders"));
-    candidateDirs.push(path39.join(dir, ".agentv", "judges"));
-    dir = path39.dirname(dir);
+    candidateDirs.push(path40.join(dir, ".agentv", "graders"));
+    candidateDirs.push(path40.join(dir, ".agentv", "judges"));
+    dir = path40.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -15487,7 +15671,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path39.basename(filePath);
+    const basename = path40.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -15644,57 +15828,8 @@ function getTCritical(df) {
   return T_TABLE_95[df - 1];
 }
 
-// src/evaluation/workspace/file-changes.ts
-import { exec as execCallback } from "node:child_process";
-import { readdirSync as readdirSync2, statSync } from "node:fs";
-import path40 from "node:path";
-import { promisify as promisify4 } from "node:util";
-var execAsync4 = promisify4(execCallback);
-function gitExecOpts(workspacePath) {
-  const { GIT_DIR: _, GIT_WORK_TREE: __, ...env } = process.env;
-  return { cwd: workspacePath, env };
-}
-async function initializeBaseline(workspacePath) {
-  const opts = gitExecOpts(workspacePath);
-  await execAsync4("git init", opts);
-  await execAsync4("git add -A", opts);
-  await execAsync4(
-    'git -c user.email=agentv@localhost -c user.name=agentv commit --allow-empty -m "agentv-baseline"',
-    opts
-  );
-  const { stdout } = await execAsync4("git rev-parse HEAD", opts);
-  return stdout.trim();
-}
-async function captureFileChanges(workspacePath, baselineCommit) {
-  const opts = gitExecOpts(workspacePath);
-  await stageNestedRepoChanges(workspacePath);
-  await execAsync4("git add -A", opts);
-  const { stdout } = await execAsync4(`git diff ${baselineCommit} --submodule=diff`, opts);
-  return stdout.trim();
-}
-async function stageNestedRepoChanges(workspacePath) {
-  let entries;
-  try {
-    entries = readdirSync2(workspacePath);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = path40.join(workspacePath, entry);
-    try {
-      if (!statSync(childPath).isDirectory()) continue;
-      if (!statSync(path40.join(childPath, ".git")).isDirectory()) continue;
-    } catch {
-      continue;
-    }
-    const childOpts = gitExecOpts(childPath);
-    await execAsync4("git add -A", childOpts);
-  }
-}
-
 // src/evaluation/workspace/manager.ts
-import { cp, mkdir as mkdir12, readdir as readdir4, rm as rm4, stat as stat6 } from "node:fs/promises";
+import { cp, mkdir as mkdir12, readdir as readdir5, rm as rm4, stat as stat7 } from "node:fs/promises";
 import path41 from "node:path";
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
@@ -15717,7 +15852,7 @@ var WorkspaceCreationError = class extends Error {
 };
 async function isDirectory(filePath) {
   try {
-    const stats = await stat6(filePath);
+    const stats = await stat7(filePath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -15729,7 +15864,7 @@ function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
 }
 async function copyDirectoryRecursive(src, dest) {
   await mkdir12(dest, { recursive: true });
-  const entries = await readdir4(src, { withFileTypes: true });
+  const entries = await readdir5(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path41.join(src, entry.name);
     const destPath = path41.join(dest, entry.name);
@@ -15803,7 +15938,7 @@ async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, readFile as readFile14, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import { cp as cp2, mkdir as mkdir13, readFile as readFile15, readdir as readdir6, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
 import path42 from "node:path";
 import { promisify as promisify5 } from "node:util";
 var execFileAsync = promisify5(execFile);
@@ -15858,7 +15993,7 @@ function computeWorkspaceFingerprint(repos) {
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
   await mkdir13(dest, { recursive: true });
-  const entries = await readdir5(src, { withFileTypes: true });
+  const entries = await readdir6(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path42.join(src, entry.name);
     const destPath = path42.join(dest, entry.name);
@@ -15966,7 +16101,7 @@ var WorkspacePoolManager = class {
           throw err;
         }
         try {
-          const pidStr = await readFile14(lockPath, "utf-8");
+          const pidStr = await readFile15(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -15993,7 +16128,7 @@ var WorkspacePoolManager = class {
   async checkDrift(poolDir, fingerprint) {
     const metadataPath = path42.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile14(metadataPath, "utf-8");
+      const raw = await readFile15(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -16012,13 +16147,13 @@ var WorkspacePoolManager = class {
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
-    const entries = await readdir5(poolDir);
+    const entries = await readdir6(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
         const lockPath = path42.join(poolDir, `${entry}.lock`);
         if (existsSync3(lockPath)) {
           try {
-            const pidStr = await readFile14(lockPath, "utf-8");
+            const pidStr = await readFile15(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -16293,14 +16428,14 @@ ${lines.join("\n")}`;
 };
 
 // src/evaluation/workspace/resolve.ts
-import { readdir as readdir6, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir7, stat as stat8 } from "node:fs/promises";
 import path44 from "node:path";
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
   const resolved = path44.resolve(templatePath);
-  const stats = await stat7(resolved);
+  const stats = await stat8(resolved);
   if (stats.isFile()) {
     return {
       dir: path44.dirname(resolved),
@@ -16310,7 +16445,7 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await readdir6(resolved);
+  const entries = await readdir7(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
@@ -16416,6 +16551,100 @@ function getWorkspaceTemplate(target) {
   }
   return void 0;
 }
+function validateDependencyGraph(tests) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const test of tests) {
+    if (ids.has(test.id)) {
+      throw new Error(`Duplicate test ID '${test.id}' \u2014 each test must have a unique ID`);
+    }
+    ids.add(test.id);
+  }
+  for (const test of tests) {
+    if (!test.depends_on) continue;
+    for (const dep of test.depends_on) {
+      if (!ids.has(dep)) {
+        throw new Error(
+          `Test '${test.id}' depends on '${dep}', but no test with that ID exists in this suite`
+        );
+      }
+      if (dep === test.id) {
+        throw new Error(`Test '${test.id}' depends on itself`);
+      }
+    }
+  }
+  const depMap = /* @__PURE__ */ new Map();
+  for (const test of tests) {
+    if (test.depends_on && test.depends_on.length > 0) {
+      depMap.set(test.id, test.depends_on);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(id, path53) {
+    if (visiting.has(id)) {
+      const cycle = [...path53.slice(path53.indexOf(id)), id];
+      throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
+    }
+    if (visited.has(id)) return;
+    visiting.add(id);
+    path53.push(id);
+    for (const dep of depMap.get(id) ?? []) {
+      visit(dep, path53);
+    }
+    path53.pop();
+    visiting.delete(id);
+    visited.add(id);
+  }
+  for (const test of tests) {
+    visit(test.id, []);
+  }
+}
+function computeWaves(tests) {
+  const hasDeps = tests.some((t) => t.depends_on && t.depends_on.length > 0);
+  if (!hasDeps) {
+    return [tests.slice()];
+  }
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const testById = /* @__PURE__ */ new Map();
+  for (const test of tests) {
+    testById.set(test.id, test);
+    inDegree.set(test.id, 0);
+  }
+  for (const test of tests) {
+    if (!test.depends_on) continue;
+    inDegree.set(test.id, test.depends_on.length);
+    for (const dep of test.depends_on) {
+      const list = dependents.get(dep) ?? [];
+      list.push(test.id);
+      dependents.set(dep, list);
+    }
+  }
+  const waves = [];
+  let ready = tests.filter((t) => (inDegree.get(t.id) ?? 0) === 0);
+  while (ready.length > 0) {
+    waves.push(ready);
+    const nextReady = [];
+    for (const test of ready) {
+      for (const depId of dependents.get(test.id) ?? []) {
+        const newDeg = (inDegree.get(depId) ?? 1) - 1;
+        inDegree.set(depId, newDeg);
+        if (newDeg === 0) {
+          const depTest = testById.get(depId);
+          if (depTest) nextReady.push(depTest);
+        }
+      }
+    }
+    ready = nextReady;
+  }
+  const totalScheduled = waves.reduce((sum, w) => sum + w.length, 0);
+  if (totalScheduled !== tests.length) {
+    throw new Error(
+      `Internal error: ${tests.length - totalScheduled} tests were not scheduled (possible undetected cycle)`
+    );
+  }
+  return waves;
+}
 async function runEvaluation(options) {
   const {
     testFilePath: evalFilePath,
@@ -16683,11 +16912,11 @@ async function runEvaluation(options) {
   let staticMaterialised = false;
   const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
   if (useStaticWorkspace && configuredStaticPath) {
-    const dirExists = await stat8(configuredStaticPath).then(
+    const dirExists = await stat9(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
     );
-    const isEmpty = dirExists ? (await readdir7(configuredStaticPath)).length === 0 : false;
+    const isEmpty = dirExists ? (await readdir8(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
         await mkdir14(configuredStaticPath, { recursive: true });
@@ -16739,10 +16968,41 @@ async function runEvaluation(options) {
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
+    let toDependencyResult2 = function(r) {
+      const outputText = extractLastAssistantContent(r.output);
+      return {
+        score: r.score,
+        output: outputText,
+        workspace_path: r.workspacePath,
+        details: r.scores ? Object.fromEntries(
+          r.scores.map((s) => [s.name, { score: s.score, verdict: s.verdict }])
+        ) : void 0,
+        status: r.executionStatus === "ok" ? "passed" : r.executionStatus === "execution_error" ? "error" : "failed"
+      };
+    }, checkDependencies2 = function(evalCase) {
+      const depResults = {};
+      if (!evalCase.depends_on || evalCase.depends_on.length === 0) {
+        return { ok: true, depResults };
+      }
+      let allPassed = true;
+      for (const depId of evalCase.depends_on) {
+        const depResult = completedResults.get(depId);
+        if (depResult) {
+          depResults[depId] = toDependencyResult2(depResult);
+          if (depResult.executionStatus === "execution_error") {
+            allPassed = false;
+          }
+        } else {
+          allPassed = false;
+        }
+      }
+      return { ok: allPassed, depResults };
+    };
+    var toDependencyResult = toDependencyResult2, checkDependencies = checkDependencies2;
     if (suiteWorkspaceFile && sharedWorkspacePath) {
       const copiedWorkspaceFile = path45.join(sharedWorkspacePath, path45.basename(suiteWorkspaceFile));
       try {
-        await stat8(copiedWorkspaceFile);
+        await stat9(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
@@ -16849,8 +17109,9 @@ async function runEvaluation(options) {
       try {
         sharedBaselineCommit = await initializeBaseline(sharedWorkspacePath);
         setupLog(`shared baseline initialized: ${sharedBaselineCommit}`);
-      } catch {
-        setupLog("shared baseline initialization skipped (non-fatal)");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        setupLog(`shared baseline initialization failed (file_changes unavailable): ${message}`);
       }
     }
     if (availablePoolSlots.length > 0) {
@@ -16859,8 +17120,11 @@ async function runEvaluation(options) {
           const baseline = await initializeBaseline(slot.path);
           poolSlotBaselines.set(slot.path, baseline);
           setupLog(`pool slot ${slot.index} baseline initialized: ${baseline}`);
-        } catch {
-          setupLog(`pool slot ${slot.index} baseline initialization skipped (non-fatal)`);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          setupLog(
+            `pool slot ${slot.index} baseline initialization failed (file_changes unavailable): ${message}`
+          );
         }
       }
     }
@@ -16870,204 +17134,259 @@ async function runEvaluation(options) {
     let cumulativeBudgetCost = 0;
     let budgetExhausted = false;
     let failOnErrorTriggered = false;
-    const promises = filteredEvalCases.map(
-      (evalCase) => limit(async () => {
-        const workerId = nextWorkerId++;
-        workerIdByEvalId.set(evalCase.id, workerId);
-        if (totalBudgetUsd !== void 0 && budgetExhausted) {
-          const budgetResult = {
-            timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+    validateDependencyGraph(filteredEvalCases);
+    const waves = computeWaves(filteredEvalCases);
+    const completedResults = /* @__PURE__ */ new Map();
+    const results = [];
+    async function dispatchTest(evalCase, depResults) {
+      const workerId = nextWorkerId++;
+      workerIdByEvalId.set(evalCase.id, workerId);
+      if (totalBudgetUsd !== void 0 && budgetExhausted) {
+        const budgetResult = {
+          timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+          testId: evalCase.id,
+          suite: evalCase.suite,
+          category: evalCase.category,
+          score: 0,
+          assertions: [],
+          output: [],
+          target: target.name,
+          error: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
+          budgetExceeded: true,
+          executionStatus: "execution_error",
+          failureStage: "setup",
+          failureReasonCode: "budget_exceeded",
+          executionError: {
+            message: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
+            stage: "setup"
+          }
+        };
+        if (onProgress) {
+          await onProgress({
+            workerId,
             testId: evalCase.id,
-            suite: evalCase.suite,
-            category: evalCase.category,
-            score: 0,
-            assertions: [],
-            output: [],
-            target: target.name,
-            error: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
-            budgetExceeded: true,
-            executionStatus: "execution_error",
-            failureStage: "setup",
-            failureReasonCode: "budget_exceeded",
-            executionError: {
-              message: `Suite budget exceeded ($${cumulativeBudgetCost.toFixed(4)} / $${totalBudgetUsd.toFixed(4)})`,
-              stage: "setup"
+            status: "failed",
+            completedAt: Date.now(),
+            error: budgetResult.error,
+            score: budgetResult.score,
+            executionStatus: budgetResult.executionStatus
+          });
+        }
+        if (onResult) {
+          await onResult(budgetResult);
+        }
+        return budgetResult;
+      }
+      if (failOnError === true && failOnErrorTriggered) {
+        const errorMsg = "Halted: execution error encountered with fail_on_error enabled";
+        const haltResult = {
+          timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+          testId: evalCase.id,
+          suite: evalCase.suite,
+          category: evalCase.category,
+          score: 0,
+          assertions: [],
+          output: [],
+          target: target.name,
+          error: errorMsg,
+          executionStatus: "execution_error",
+          failureStage: "setup",
+          failureReasonCode: "error_threshold_exceeded",
+          executionError: { message: errorMsg, stage: "setup" }
+        };
+        if (onProgress) {
+          await onProgress({
+            workerId,
+            testId: evalCase.id,
+            status: "failed",
+            completedAt: Date.now(),
+            error: haltResult.error,
+            score: haltResult.score,
+            executionStatus: haltResult.executionStatus
+          });
+        }
+        if (onResult) {
+          await onResult(haltResult);
+        }
+        return haltResult;
+      }
+      if (onProgress) {
+        await onProgress({
+          workerId,
+          testId: evalCase.id,
+          status: "running",
+          startedAt: Date.now()
+        });
+      }
+      const testPoolSlot = availablePoolSlots.length > 0 ? availablePoolSlots.pop() : void 0;
+      const testWorkspacePath = testPoolSlot?.path ?? sharedWorkspacePath;
+      const testBaselineCommit = testPoolSlot ? poolSlotBaselines.get(testPoolSlot.path) : sharedBaselineCommit;
+      try {
+        const graderProvider = await resolveGraderProvider(target);
+        const runCaseOptions = {
+          evalCase,
+          provider: primaryProvider,
+          target,
+          evaluators: evaluatorRegistry,
+          maxRetries,
+          agentTimeoutMs,
+          cache,
+          useCache,
+          now,
+          graderProvider,
+          targetResolver,
+          availableTargets,
+          evalRunId,
+          keepWorkspaces,
+          cleanupWorkspaces,
+          retainOnSuccess: resolvedRetainOnSuccess,
+          retainOnFailure: resolvedRetainOnFailure,
+          sharedWorkspacePath: testWorkspacePath,
+          sharedBaselineCommit: testBaselineCommit,
+          suiteWorkspaceFile,
+          streamCallbacks,
+          typeRegistry,
+          repoManager,
+          evalDir,
+          verbose,
+          threshold: scoreThreshold,
+          ...depResults && Object.keys(depResults).length > 0 ? { dependencyResults: depResults } : {}
+        };
+        let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
+        if (totalBudgetUsd !== void 0) {
+          let caseCost;
+          if (result.trials && result.trials.length > 0) {
+            const trialCostSum = result.trials.reduce((sum, t) => sum + (t.costUsd ?? 0), 0);
+            if (trialCostSum > 0) {
+              caseCost = trialCostSum;
             }
-          };
-          if (onProgress) {
-            await onProgress({
-              workerId,
-              testId: evalCase.id,
-              status: "failed",
-              completedAt: Date.now(),
-              error: budgetResult.error,
-              score: budgetResult.score,
-              executionStatus: budgetResult.executionStatus
-            });
+          } else {
+            caseCost = result.costUsd;
           }
-          if (onResult) {
-            await onResult(budgetResult);
+          if (caseCost !== void 0) {
+            cumulativeBudgetCost += caseCost;
+            if (cumulativeBudgetCost >= totalBudgetUsd) {
+              budgetExhausted = true;
+            }
           }
-          return budgetResult;
         }
-        if (failOnError === true && failOnErrorTriggered) {
-          const errorMsg = "Halted: execution error encountered with fail_on_error enabled";
-          const haltResult = {
-            timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+        if (failOnError === true && result.executionStatus === "execution_error") {
+          failOnErrorTriggered = true;
+        }
+        if (beforeAllOutput && !beforeAllOutputAttached) {
+          result = { ...result, beforeAllOutput };
+          beforeAllOutputAttached = true;
+        }
+        if (onProgress) {
+          await onProgress({
+            workerId,
             testId: evalCase.id,
-            suite: evalCase.suite,
-            category: evalCase.category,
-            score: 0,
-            assertions: [],
-            output: [],
-            target: target.name,
-            error: errorMsg,
-            executionStatus: "execution_error",
-            failureStage: "setup",
-            failureReasonCode: "error_threshold_exceeded",
-            executionError: { message: errorMsg, stage: "setup" }
-          };
-          if (onProgress) {
-            await onProgress({
-              workerId,
-              testId: evalCase.id,
-              status: "failed",
-              completedAt: Date.now(),
-              error: haltResult.error,
-              score: haltResult.score,
-              executionStatus: haltResult.executionStatus
-            });
-          }
-          if (onResult) {
-            await onResult(haltResult);
-          }
-          return haltResult;
+            status: result.error ? "failed" : "completed",
+            startedAt: 0,
+            // Not used for completed status
+            completedAt: Date.now(),
+            error: result.error,
+            score: result.score,
+            executionStatus: result.executionStatus
+          });
         }
+        if (onResult) {
+          await onResult(result);
+        }
+        return result;
+      } catch (error) {
         if (onProgress) {
           await onProgress({
             workerId,
             testId: evalCase.id,
-            status: "running",
-            startedAt: Date.now()
+            status: "failed",
+            completedAt: Date.now(),
+            error: error instanceof Error ? error.message : String(error)
           });
         }
-        const testPoolSlot = availablePoolSlots.length > 0 ? availablePoolSlots.pop() : void 0;
-        const testWorkspacePath = testPoolSlot?.path ?? sharedWorkspacePath;
-        const testBaselineCommit = testPoolSlot ? poolSlotBaselines.get(testPoolSlot.path) : sharedBaselineCommit;
-        try {
-          const graderProvider = await resolveGraderProvider(target);
-          const runCaseOptions = {
-            evalCase,
-            provider: primaryProvider,
-            target,
-            evaluators: evaluatorRegistry,
-            maxRetries,
-            agentTimeoutMs,
-            cache,
-            useCache,
-            now,
-            graderProvider,
-            targetResolver,
-            availableTargets,
-            evalRunId,
-            keepWorkspaces,
-            cleanupWorkspaces,
-            retainOnSuccess: resolvedRetainOnSuccess,
-            retainOnFailure: resolvedRetainOnFailure,
-            sharedWorkspacePath: testWorkspacePath,
-            sharedBaselineCommit: testBaselineCommit,
-            suiteWorkspaceFile,
-            streamCallbacks,
-            typeRegistry,
-            repoManager,
-            evalDir,
-            verbose,
-            threshold: scoreThreshold
-          };
-          let result = trials && trials.count > 1 ? await runEvalCaseWithTrials(runCaseOptions, trials) : await runEvalCase(runCaseOptions);
-          if (totalBudgetUsd !== void 0) {
-            let caseCost;
-            if (result.trials && result.trials.length > 0) {
-              const trialCostSum = result.trials.reduce((sum, t) => sum + (t.costUsd ?? 0), 0);
-              if (trialCostSum > 0) {
-                caseCost = trialCostSum;
-              }
-            } else {
-              caseCost = result.costUsd;
-            }
-            if (caseCost !== void 0) {
-              cumulativeBudgetCost += caseCost;
-              if (cumulativeBudgetCost >= totalBudgetUsd) {
-                budgetExhausted = true;
+        throw error;
+      } finally {
+        if (testPoolSlot) {
+          availablePoolSlots.push(testPoolSlot);
+        }
+      }
+    }
+    for (const wave of waves) {
+      const wavePromises = wave.map(
+        (evalCase) => limit(async () => {
+          if (evalCase.depends_on && evalCase.depends_on.length > 0) {
+            const { ok, depResults } = checkDependencies2(evalCase);
+            if (!ok) {
+              const policy = evalCase.on_dependency_failure ?? "skip";
+              if (policy === "skip" || policy === "fail") {
+                const failedDeps = evalCase.depends_on.filter(
+                  (d) => completedResults.get(d)?.executionStatus === "execution_error"
+                );
+                const prefix = policy === "skip" ? "Skipped" : "Failed";
+                const errorMsg = `${prefix}: dependency failed (${failedDeps.join(", ")})`;
+                const depFailResult = {
+                  timestamp: (now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+                  testId: evalCase.id,
+                  suite: evalCase.suite,
+                  category: evalCase.category,
+                  score: 0,
+                  assertions: [],
+                  output: [],
+                  target: target.name,
+                  error: errorMsg,
+                  executionStatus: "execution_error",
+                  failureStage: "setup",
+                  failureReasonCode: "dependency_failed",
+                  executionError: { message: errorMsg, stage: "setup" }
+                };
+                if (onProgress) {
+                  await onProgress({
+                    workerId: nextWorkerId++,
+                    testId: evalCase.id,
+                    status: "failed",
+                    completedAt: Date.now(),
+                    error: depFailResult.error,
+                    score: 0,
+                    executionStatus: depFailResult.executionStatus
+                  });
+                }
+                if (onResult) {
+                  await onResult(depFailResult);
+                }
+                return depFailResult;
               }
             }
+            return dispatchTest(evalCase, depResults);
           }
-          if (failOnError === true && result.executionStatus === "execution_error") {
-            failOnErrorTriggered = true;
-          }
-          if (beforeAllOutput && !beforeAllOutputAttached) {
-            result = { ...result, beforeAllOutput };
-            beforeAllOutputAttached = true;
-          }
-          if (onProgress) {
-            await onProgress({
-              workerId,
-              testId: evalCase.id,
-              status: result.error ? "failed" : "completed",
-              startedAt: 0,
-              // Not used for completed status
-              completedAt: Date.now(),
-              error: result.error,
-              score: result.score,
-              executionStatus: result.executionStatus
-            });
-          }
+          return dispatchTest(evalCase);
+        })
+      );
+      const settled = await Promise.allSettled(wavePromises);
+      for (let i = 0; i < settled.length; i++) {
+        const outcome = settled[i];
+        const evalCase = wave[i];
+        if (outcome.status === "fulfilled") {
+          completedResults.set(evalCase.id, outcome.value);
+          results.push(outcome.value);
+        } else {
+          const formattingMode = usesFileReferencePrompt(primaryProvider) ? "agent" : "lm";
+          const promptInputs = await buildPromptInputs(evalCase, formattingMode);
+          const errorResult = buildErrorResult(
+            evalCase,
+            target.name,
+            (now ?? (() => /* @__PURE__ */ new Date()))(),
+            outcome.reason,
+            promptInputs,
+            primaryProvider,
+            "agent",
+            "provider_error",
+            verbose
+          );
+          completedResults.set(evalCase.id, errorResult);
+          results.push(errorResult);
           if (onResult) {
-            await onResult(result);
+            await onResult(errorResult);
           }
-          return result;
-        } catch (error) {
-          if (onProgress) {
-            await onProgress({
-              workerId,
-              testId: evalCase.id,
-              status: "failed",
-              completedAt: Date.now(),
-              error: error instanceof Error ? error.message : String(error)
-            });
-          }
-          throw error;
-        } finally {
-          if (testPoolSlot) {
-            availablePoolSlots.push(testPoolSlot);
-          }
-        }
-      })
-    );
-    const settled = await Promise.allSettled(promises);
-    const results = [];
-    for (let i = 0; i < settled.length; i++) {
-      const outcome = settled[i];
-      if (outcome.status === "fulfilled") {
-        results.push(outcome.value);
-      } else {
-        const evalCase = filteredEvalCases[i];
-        const formattingMode = usesFileReferencePrompt(primaryProvider) ? "agent" : "lm";
-        const promptInputs = await buildPromptInputs(evalCase, formattingMode);
-        const errorResult = buildErrorResult(
-          evalCase,
-          target.name,
-          (now ?? (() => /* @__PURE__ */ new Date()))(),
-          outcome.reason,
-          promptInputs,
-          primaryProvider,
-          "agent",
-          "provider_error",
-          verbose
-        );
-        results.push(errorResult);
-        if (onResult) {
-          await onResult(errorResult);
         }
       }
     }
@@ -17312,7 +17631,8 @@ async function runEvalCase(options) {
     repoManager,
     evalDir,
     verbose,
-    threshold: caseThreshold
+    threshold: caseThreshold,
+    dependencyResults
   } = options;
   const setupDebug = process.env.AGENTV_SETUP_DEBUG === "1";
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
@@ -17356,7 +17676,7 @@ async function runEvalCase(options) {
       if (caseWorkspaceFile && workspacePath) {
         const copiedFile = path45.join(workspacePath, path45.basename(caseWorkspaceFile));
         try {
-          await stat8(copiedFile);
+          await stat9(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -17520,7 +17840,11 @@ async function runEvalCase(options) {
   if (!baselineCommit && workspacePath) {
     try {
       baselineCommit = await initializeBaseline(workspacePath);
-    } catch {
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (verbose) {
+        console.warn(`[setup] test=${evalCase.id} baseline initialization failed: ${message}`);
+      }
     }
   }
   const caseStartMs = Date.now();
@@ -17631,6 +17955,11 @@ async function runEvalCase(options) {
     } catch {
     }
   }
+  const providerFileChanges = providerResponse?.fileChanges;
+  if (providerFileChanges) {
+    fileChanges = fileChanges ? `${fileChanges}
+${providerFileChanges}` : providerFileChanges;
+  }
   const providerError = extractProviderError(providerResponse);
   if (caseHooksEnabled && repoManager && workspacePath && evalCase.workspace?.hooks?.after_each?.reset && evalCase.workspace.hooks.after_each.reset !== "none" && evalCase.workspace.repos) {
     try {
@@ -17688,7 +18017,8 @@ async function runEvalCase(options) {
       workspacePath,
       dockerConfig: evalCase.workspace?.docker,
       verbose,
-      threshold: evalCase.threshold ?? caseThreshold
+      threshold: evalCase.threshold ?? caseThreshold,
+      dependencyResults
     });
     const effectiveThreshold = evalCase.threshold ?? caseThreshold;
     const totalDurationMs = Date.now() - caseStartMs;
@@ -17881,7 +18211,8 @@ async function evaluateCandidate(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
-    threshold: evalThreshold
+    threshold: evalThreshold,
+    dependencyResults
   } = options;
   const gradeTimestamp = nowFn();
   const { score, scores } = await runEvaluatorsForCase({
@@ -17908,7 +18239,8 @@ async function evaluateCandidate(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
-    threshold: evalThreshold
+    threshold: evalThreshold,
+    dependencyResults
   });
   const completedAt = nowFn();
   let agentRequest;
@@ -17984,7 +18316,8 @@ async function runEvaluatorsForCase(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
-    threshold
+    threshold,
+    dependencyResults
   } = options;
   if (evalCase.assertions && evalCase.assertions.length > 0) {
     return runEvaluatorList({
@@ -18012,7 +18345,8 @@ async function runEvaluatorsForCase(options) {
       fileChanges,
       workspacePath,
       dockerConfig,
-      threshold
+      threshold,
+      dependencyResults
     });
   }
   const evaluatorKind = evalCase.evaluator ?? "llm-grader";
@@ -18042,6 +18376,7 @@ async function runEvaluatorsForCase(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
+    dependencyResults,
     ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
   return { score };
@@ -18081,7 +18416,8 @@ async function runEvaluatorList(options) {
     availableTargets,
     fileChanges,
     workspacePath,
-    dockerConfig
+    dockerConfig,
+    dependencyResults
   } = options;
   const scored = [];
   const scores = [];
@@ -18105,7 +18441,8 @@ async function runEvaluatorList(options) {
     availableTargets,
     fileChanges,
     workspacePath,
-    dockerConfig
+    dockerConfig,
+    dependencyResults
   };
   const evalFileDir = evalCase.file_paths[0] ? path45.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
@@ -18824,7 +19161,7 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/workspace/deps-scanner.ts
-import { readFile as readFile15 } from "node:fs/promises";
+import { readFile as readFile16 } from "node:fs/promises";
 import path47 from "node:path";
 import { parse as parse6 } from "yaml";
 function normalizeGitUrl(url) {
@@ -18872,7 +19209,7 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await readFile15(filePath, "utf8");
+  const content = await readFile16(filePath, "utf8");
   const parsed = interpolateEnv(parse6(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
@@ -18893,7 +19230,7 @@ async function extractReposFromEvalFile(filePath) {
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
     const workspaceFilePath = path47.resolve(evalFileDir, raw);
-    const content = await readFile15(workspaceFilePath, "utf8");
+    const content = await readFile16(workspaceFilePath, "utf8");
     const parsed = interpolateEnv(parse6(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
@@ -18921,7 +19258,7 @@ function extractReposFromObject(obj) {
 }
 
 // src/evaluation/cache/response-cache.ts
-import { mkdir as mkdir15, readFile as readFile16, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir15, readFile as readFile17, writeFile as writeFile8 } from "node:fs/promises";
 import path48 from "node:path";
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -18932,7 +19269,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile16(filePath, "utf8");
+      const data = await readFile17(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -18964,7 +19301,7 @@ function shouldSkipCacheForTemperature(targetConfig) {
 // src/evaluation/results-repo.ts
 import { execFile as execFile3 } from "node:child_process";
 import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync3, rmSync, writeFileSync } from "node:fs";
-import { cp as cp3, mkdtemp as mkdtemp3, readdir as readdir8, rm as rm6, stat as stat9 } from "node:fs/promises";
+import { cp as cp3, mkdtemp as mkdtemp3, readdir as readdir9, rm as rm6, stat as stat10 } from "node:fs/promises";
 import os3 from "node:os";
 import path49 from "node:path";
 import { promisify as promisify7 } from "node:util";
@@ -19187,12 +19524,12 @@ function resolveResultsRepoRunsDir(config) {
   );
 }
 async function directorySizeBytes(targetPath) {
-  const entry = await stat9(targetPath);
+  const entry = await stat10(targetPath);
   if (entry.isFile()) {
     return entry.size;
   }
   let total = 0;
-  for (const child of await readdir8(targetPath, { withFileTypes: true })) {
+  for (const child of await readdir9(targetPath, { withFileTypes: true })) {
     total += await directorySizeBytes(path49.join(targetPath, child.name));
   }
   return total;
@@ -20259,17 +20596,17 @@ function extractResponseItemContent(content) {
 }
 
 // src/import/codex-session-discovery.ts
-import { readdir as readdir9, stat as stat10 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+import { readdir as readdir10, stat as stat11 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
 import path51 from "node:path";
-var DEFAULT_SESSIONS_DIR = () => path51.join(homedir4(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => path51.join(homedir5(), ".codex", "sessions");
 async function discoverCodexSessions(opts) {
   const sessionsDir = opts?.sessionsDir ?? DEFAULT_SESSIONS_DIR();
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   const sessions = [];
   let yearDirs;
   try {
-    yearDirs = await readdir9(sessionsDir);
+    yearDirs = await readdir10(sessionsDir);
   } catch {
     return [];
   }
@@ -20277,7 +20614,7 @@ async function discoverCodexSessions(opts) {
     const yearPath = path51.join(sessionsDir, year);
     let monthDirs;
     try {
-      monthDirs = await readdir9(yearPath);
+      monthDirs = await readdir10(yearPath);
     } catch {
       continue;
     }
@@ -20285,7 +20622,7 @@ async function discoverCodexSessions(opts) {
       const monthPath = path51.join(yearPath, month);
       let dayDirs;
       try {
-        dayDirs = await readdir9(monthPath);
+        dayDirs = await readdir10(monthPath);
       } catch {
         continue;
       }
@@ -20297,7 +20634,7 @@ async function discoverCodexSessions(opts) {
         const dayPath = path51.join(monthPath, day);
         let files;
         try {
-          files = await readdir9(dayPath);
+          files = await readdir10(dayPath);
         } catch {
           continue;
         }
@@ -20309,7 +20646,7 @@ async function discoverCodexSessions(opts) {
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
           let updatedAt;
           try {
-            const fileStat = await stat10(filePath);
+            const fileStat = await stat11(filePath);
             updatedAt = fileStat.mtime;
           } catch {
             updatedAt = /* @__PURE__ */ new Date(0);
@@ -20324,10 +20661,10 @@ async function discoverCodexSessions(opts) {
 }
 
 // src/import/session-discovery.ts
-import { readdir as readdir10, stat as stat11 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
+import { readdir as readdir11, stat as stat12 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
 import path52 from "node:path";
-var DEFAULT_PROJECTS_DIR = () => path52.join(homedir5(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => path52.join(homedir6(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -20336,7 +20673,7 @@ async function discoverClaudeSessions(opts) {
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   let projectDirs;
   try {
-    projectDirs = await readdir10(projectsDir);
+    projectDirs = await readdir11(projectsDir);
   } catch {
     return [];
   }
@@ -20349,7 +20686,7 @@ async function discoverClaudeSessions(opts) {
     const dirPath = path52.join(projectsDir, projectDir);
     let entries;
     try {
-      entries = await readdir10(dirPath);
+      entries = await readdir11(dirPath);
     } catch {
       continue;
     }
@@ -20360,7 +20697,7 @@ async function discoverClaudeSessions(opts) {
       const filePath = path52.join(dirPath, entry);
       let updatedAt;
       try {
-        const fileStat = await stat11(filePath);
+        const fileStat = await stat12(filePath);
         updatedAt = fileStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -20378,7 +20715,7 @@ async function discoverClaudeSessions(opts) {
 }
 
 // src/import/types.ts
-import { readFile as readFile17 } from "node:fs/promises";
+import { readFile as readFile18 } from "node:fs/promises";
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -20404,11 +20741,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await readFile17(filePath, "utf8");
+  const text = await readFile18(filePath, "utf8");
   return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return readFile17(filePath, "utf8");
+  return readFile18(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts