@agentv/core 4.13.0 → 4.14.0

package/dist/index.cjs

@@ -140,7 +140,7 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir17, readFile: readFile20, rm: rm7, writeFile: writeFile9 } = await import("fs/promises");
+  const { mkdir: mkdir17, readFile: readFile21, rm: rm7, writeFile: writeFile9 } = await import("fs/promises");
   const { tmpdir: tmpdir3 } = await import("os");
   const path56 = await import("path");
   const { randomUUID: randomUUID10 } = await import("crypto");
@@ -178,8 +178,8 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile20(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile20(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile21(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile21(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm7(dir, { recursive: true, force: true });
@@ -1698,12 +1698,12 @@ function serializeAttributeValue(value) {
   if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
   return { stringValue: String(value) };
 }
-var import_promises39, import_node_path55, OtlpJsonFileExporter;
+var import_promises40, import_node_path55, OtlpJsonFileExporter;
 var init_otlp_json_file_exporter = __esm({
   "src/observability/otlp-json-file-exporter.ts"() {
     "use strict";
     init_cjs_shims();
-    import_promises39 = require("fs/promises");
+    import_promises40 = require("fs/promises");
     import_node_path55 = require("path");
     OtlpJsonFileExporter = class {
       // biome-ignore lint/suspicious/noExplicitAny: serialized span data
@@ -1743,7 +1743,7 @@ var init_otlp_json_file_exporter = __esm({
       }
       async flush() {
         if (this.spans.length === 0) return;
-        await (0, import_promises39.mkdir)((0, import_node_path55.dirname)(this.filePath), { recursive: true });
+        await (0, import_promises40.mkdir)((0, import_node_path55.dirname)(this.filePath), { recursive: true });
         const otlpJson = {
           resourceSpans: [
             {
@@ -5751,7 +5751,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);
@@ -5764,7 +5768,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;
@@ -5926,6 +5931,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,
@@ -5943,11 +5953,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);
@@ -8925,12 +8937,125 @@ function formatElapsed3(startedAt) {
 // src/evaluation/providers/copilot-cli.ts
 init_cjs_shims();
 var import_node_crypto5 = require("crypto");
-var import_promises16 = require("fs/promises");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_promises17 = require("fs/promises");
+var import_node_os3 = require("os");
+var import_node_path19 = __toESM(require("path"), 1);
 var import_node_stream = require("stream");
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var acp = __toESM(require("@agentclientprotocol/sdk"), 1);
 
+// src/evaluation/workspace/file-changes.ts
+init_cjs_shims();
+var import_node_child_process3 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_promises16 = require("fs/promises");
+var import_node_path17 = __toESM(require("path"), 1);
+var import_node_util2 = require("util");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process3.exec);
+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 = (0, import_node_fs7.readdirSync)(workspacePath);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry === ".git" || entry === "node_modules") continue;
+    const childPath = import_node_path17.default.join(workspacePath, entry);
+    try {
+      if (!(0, import_node_fs7.statSync)(childPath).isDirectory()) continue;
+      if (!(0, import_node_fs7.statSync)(import_node_path17.default.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 (0, import_promises16.readdir)(currentDir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (SNAPSHOT_EXCLUDE_DIRS.has(entry)) continue;
+    const fullPath = import_node_path17.default.join(currentDir, entry);
+    let fileStat;
+    try {
+      fileStat = await (0, import_promises16.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 (0, import_promises16.readFile)(fullPath, "utf8");
+        if (content.includes("\0")) continue;
+      } catch {
+        continue;
+      }
+      const relativePath = import_node_path17.default.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
 init_cjs_shims();
 var GLOBAL_LOGS_KEY3 = Symbol.for("agentv.copilotCliLogs");
@@ -8988,9 +9113,9 @@ function subscribeToCopilotCliLogEntries(listener) {
 // src/evaluation/providers/copilot-utils.ts
 init_cjs_shims();
 var import_node_crypto4 = require("crypto");
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_node_url3 = require("url");
 var import_meta = {};
 function resolvePlatformCliPath() {
@@ -9015,30 +9140,30 @@ function resolvePlatformCliPath() {
   try {
     const resolved = import_meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? (0, import_node_url3.fileURLToPath)(resolved) : resolved;
-    const binaryPath = import_node_path17.default.join(import_node_path17.default.dirname(packageJsonPath), binaryName);
-    if ((0, import_node_fs7.existsSync)(binaryPath)) {
+    const binaryPath = import_node_path18.default.join(import_node_path18.default.dirname(packageJsonPath), binaryName);
+    if ((0, import_node_fs8.existsSync)(binaryPath)) {
       return binaryPath;
     }
   } catch {
   }
   let searchDir = process.cwd();
   for (let i = 0; i < 10; i++) {
-    const standardPath = import_node_path17.default.join(
+    const standardPath = import_node_path18.default.join(
       searchDir,
       "node_modules",
       ...packageName.split("/"),
       binaryName
     );
-    if ((0, import_node_fs7.existsSync)(standardPath)) {
+    if ((0, import_node_fs8.existsSync)(standardPath)) {
       return standardPath;
     }
-    const bunDir = import_node_path17.default.join(searchDir, "node_modules", ".bun");
+    const bunDir = import_node_path18.default.join(searchDir, "node_modules", ".bun");
     const prefix = `@github+copilot-${osPart}-${archPart}@`;
     try {
-      const entries = (0, import_node_fs7.readdirSync)(bunDir);
+      const entries = (0, import_node_fs8.readdirSync)(bunDir);
       for (const entry of entries) {
         if (entry.startsWith(prefix)) {
-          const candidate = import_node_path17.default.join(
+          const candidate = import_node_path18.default.join(
             bunDir,
             entry,
             "node_modules",
@@ -9046,23 +9171,23 @@ function resolvePlatformCliPath() {
             `copilot-${osPart}-${archPart}`,
             binaryName
           );
-          if ((0, import_node_fs7.existsSync)(candidate)) {
+          if ((0, import_node_fs8.existsSync)(candidate)) {
             return candidate;
           }
         }
       }
     } catch {
     }
-    const parent = import_node_path17.default.dirname(searchDir);
+    const parent = import_node_path18.default.dirname(searchDir);
     if (parent === searchDir) break;
     searchDir = parent;
   }
   for (const root of globalNpmRoots()) {
-    const hoisted = import_node_path17.default.join(root, "@github", `copilot-${osPart}-${archPart}`, binaryName);
-    if ((0, import_node_fs7.existsSync)(hoisted)) {
+    const hoisted = import_node_path18.default.join(root, "@github", `copilot-${osPart}-${archPart}`, binaryName);
+    if ((0, import_node_fs8.existsSync)(hoisted)) {
       return hoisted;
     }
-    const nested = import_node_path17.default.join(
+    const nested = import_node_path18.default.join(
       root,
       "@github",
       "copilot",
@@ -9071,7 +9196,7 @@ function resolvePlatformCliPath() {
       `copilot-${osPart}-${archPart}`,
       binaryName
     );
-    if ((0, import_node_fs7.existsSync)(nested)) {
+    if ((0, import_node_fs8.existsSync)(nested)) {
       return nested;
     }
   }
@@ -9083,20 +9208,20 @@ function globalNpmRoots() {
   const home = (0, import_node_os2.homedir)();
   if (os4 === "win32") {
     if (process.env.APPDATA) {
-      roots.push(import_node_path17.default.join(process.env.APPDATA, "npm", "node_modules"));
+      roots.push(import_node_path18.default.join(process.env.APPDATA, "npm", "node_modules"));
     }
-    roots.push(import_node_path17.default.join(home, "AppData", "Roaming", "npm", "node_modules"));
+    roots.push(import_node_path18.default.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(import_node_path17.default.join(home, ".npm-global", "lib", "node_modules"));
-    roots.push(import_node_path17.default.join(home, ".local", "lib", "node_modules"));
+    roots.push(import_node_path18.default.join(home, ".npm-global", "lib", "node_modules"));
+    roots.push(import_node_path18.default.join(home, ".local", "lib", "node_modules"));
   }
   if (process.env.npm_config_prefix) {
     const prefix = process.env.npm_config_prefix;
     roots.push(
-      os4 === "win32" ? import_node_path17.default.join(prefix, "node_modules") : import_node_path17.default.join(prefix, "lib", "node_modules")
+      os4 === "win32" ? import_node_path18.default.join(prefix, "node_modules") : import_node_path18.default.join(prefix, "lib", "node_modules")
     );
   }
   return Array.from(new Set(roots));
@@ -9143,14 +9268,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.stream = (0, import_node_fs7.createWriteStream)(filePath, { flags: "a" });
+    this.chunkExtractor = chunkExtractor;
+    this.stream = (0, import_node_fs8.createWriteStream)(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}`,
@@ -9166,19 +9299,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());
@@ -9215,7 +9371,7 @@ var CopilotCliProvider = class {
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     const executable = this.resolveExecutable();
     const args = this.buildCliArgs();
-    const agentProcess = (0, import_node_child_process3.spawn)(executable, args, {
+    const agentProcess = (0, import_node_child_process4.spawn)(executable, args, {
       stdio: ["pipe", "pipe", "inherit"]
     });
     await waitForProcessSpawn(agentProcess, executable, this.targetName);
@@ -9387,6 +9543,10 @@ var CopilotCliProvider = class {
           content: finalContent
         });
       }
+      const sessionId = session.sessionId;
+      const fileChanges = sessionId ? await captureSessionArtifacts(
+        import_node_path19.default.join((0, import_node_os3.homedir)(), ".copilot", "session-state", sessionId, "files")
+      ).catch(() => void 0) : void 0;
       return {
         raw: {
           model: this.config.model,
@@ -9398,7 +9558,8 @@ var CopilotCliProvider = class {
         costUsd,
         durationMs,
         startTime,
-        endTime
+        endTime,
+        ...fileChanges ? { fileChanges } : {}
       };
     } finally {
       await logger?.close();
@@ -9439,10 +9600,10 @@ var CopilotCliProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path18.default.resolve(cwdOverride);
+      return import_node_path19.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path18.default.resolve(this.config.cwd);
+      return import_node_path19.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -9461,9 +9622,9 @@ var CopilotCliProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path18.default.resolve(this.config.logDir);
+      return import_node_path19.default.resolve(this.config.logDir);
     }
-    return import_node_path18.default.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+    return import_node_path19.default.join(process.cwd(), ".agentv", "logs", "copilot-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -9471,13 +9632,13 @@ var CopilotCliProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises16.mkdir)(logDir, { recursive: true });
+      await (0, import_promises17.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path18.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
+    const filePath = import_node_path19.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-cli"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -9486,7 +9647,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
       );
@@ -9545,6 +9707,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;
@@ -9571,9 +9741,9 @@ function summarizeAcpEvent(eventType, data) {
 
 // src/evaluation/providers/copilot-log.ts
 init_cjs_shims();
-var import_promises18 = require("fs/promises");
-var import_node_os4 = require("os");
-var import_node_path20 = __toESM(require("path"), 1);
+var import_promises19 = require("fs/promises");
+var import_node_os5 = require("os");
+var import_node_path21 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/copilot-log-parser.ts
 init_cjs_shims();
@@ -9707,32 +9877,32 @@ function parseCopilotEvents(eventsJsonl) {
 
 // src/evaluation/providers/copilot-session-discovery.ts
 init_cjs_shims();
-var import_promises17 = require("fs/promises");
-var import_node_os3 = require("os");
-var import_node_path19 = __toESM(require("path"), 1);
+var import_promises18 = require("fs/promises");
+var import_node_os4 = require("os");
+var import_node_path20 = __toESM(require("path"), 1);
 var import_yaml7 = require("yaml");
-var DEFAULT_SESSION_STATE_DIR = () => import_node_path19.default.join((0, import_node_os3.homedir)(), ".copilot", "session-state");
+var DEFAULT_SESSION_STATE_DIR = () => import_node_path20.default.join((0, import_node_os4.homedir)(), ".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 (0, import_promises17.readdir)(sessionStateDir);
+    entries = await (0, import_promises18.readdir)(sessionStateDir);
   } catch {
     return [];
   }
   const sessions = [];
   for (const entry of entries) {
-    const sessionDir = import_node_path19.default.join(sessionStateDir, entry);
-    const workspacePath = import_node_path19.default.join(sessionDir, "workspace.yaml");
-    const eventsPath = import_node_path19.default.join(sessionDir, "events.jsonl");
+    const sessionDir = import_node_path20.default.join(sessionStateDir, entry);
+    const workspacePath = import_node_path20.default.join(sessionDir, "workspace.yaml");
+    const eventsPath = import_node_path20.default.join(sessionDir, "events.jsonl");
     try {
-      const workspaceContent = await (0, import_promises17.readFile)(workspacePath, "utf8");
+      const workspaceContent = await (0, import_promises18.readFile)(workspacePath, "utf8");
       const workspace = (0, import_yaml7.parse)(workspaceContent) ?? {};
       const cwd = String(workspace.cwd ?? "");
       let updatedAt;
       try {
-        const eventsStat = await (0, import_promises17.stat)(eventsPath);
+        const eventsStat = await (0, import_promises18.stat)(eventsPath);
         updatedAt = eventsStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -9786,21 +9956,24 @@ var CopilotLogProvider = class {
   }
   async invoke(_request) {
     const sessionDir = await this.resolveSessionDir();
-    const eventsPath = import_node_path20.default.join(sessionDir, "events.jsonl");
+    const eventsPath = import_node_path21.default.join(sessionDir, "events.jsonl");
     let eventsContent;
     try {
-      eventsContent = await (0, import_promises18.readFile)(eventsPath, "utf8");
+      eventsContent = await (0, import_promises19.readFile)(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 = import_node_path21.default.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() {
@@ -9808,8 +9981,8 @@ var CopilotLogProvider = class {
       return this.config.sessionDir;
     }
     if (this.config.sessionId) {
-      const stateDir = this.config.sessionStateDir ?? import_node_path20.default.join((0, import_node_os4.homedir)(), ".copilot", "session-state");
-      return import_node_path20.default.join(stateDir, this.config.sessionId);
+      const stateDir = this.config.sessionStateDir ?? import_node_path21.default.join((0, import_node_os5.homedir)(), ".copilot", "session-state");
+      return import_node_path21.default.join(stateDir, this.config.sessionId);
     }
     if (this.config.discover === "latest") {
       const sessions = await discoverCopilotSessions({
@@ -9833,9 +10006,9 @@ var CopilotLogProvider = class {
 // src/evaluation/providers/copilot-sdk.ts
 init_cjs_shims();
 var import_node_crypto6 = require("crypto");
-var import_node_fs8 = require("fs");
-var import_promises19 = require("fs/promises");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs9 = require("fs");
+var import_promises20 = require("fs/promises");
+var import_node_path22 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/copilot-sdk-log-tracker.ts
 init_cjs_shims();
@@ -10082,6 +10255,10 @@ var CopilotSdkProvider = class {
           content: finalContent
         });
       }
+      const sessionWorkspacePath = session.workspacePath;
+      const fileChanges = sessionWorkspacePath ? await captureSessionArtifacts(import_node_path22.default.join(sessionWorkspacePath, "files")).catch(
+        () => void 0
+      ) : void 0;
       return {
         raw: {
           model: this.config.model,
@@ -10093,7 +10270,8 @@ var CopilotSdkProvider = class {
         costUsd,
         durationMs,
         startTime,
-        endTime
+        endTime,
+        ...fileChanges ? { fileChanges } : {}
       };
     } finally {
       unsubscribe();
@@ -10146,10 +10324,10 @@ var CopilotSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path21.default.resolve(cwdOverride);
+      return import_node_path22.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path21.default.resolve(this.config.cwd);
+      return import_node_path22.default.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -10158,9 +10336,9 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return import_node_path21.default.resolve(this.config.logDir);
+      return import_node_path22.default.resolve(this.config.logDir);
     }
-    return import_node_path21.default.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
+    return import_node_path22.default.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -10168,13 +10346,13 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     try {
-      await (0, import_promises19.mkdir)(logDir, { recursive: true });
+      await (0, import_promises20.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path21.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
+    const filePath = import_node_path22.default.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -10183,7 +10361,8 @@ var CopilotSdkProvider = class {
           evalCaseId: request.evalCaseId,
           attempt: request.attempt,
           format: this.config.logFormat ?? "summary",
-          headerLabel: "Copilot SDK"
+          headerLabel: "Copilot SDK",
+          chunkExtractor: extractSdkChunk
         },
         summarizeSdkEvent
       );
@@ -10203,11 +10382,11 @@ var CopilotSdkProvider = class {
 };
 function resolveSkillDirectories(cwd) {
   const candidates = [
-    import_node_path21.default.join(cwd, ".claude", "skills"),
-    import_node_path21.default.join(cwd, ".agents", "skills"),
-    import_node_path21.default.join(cwd, ".codex", "skills")
+    import_node_path22.default.join(cwd, ".claude", "skills"),
+    import_node_path22.default.join(cwd, ".agents", "skills"),
+    import_node_path22.default.join(cwd, ".codex", "skills")
   ];
-  return candidates.filter((dir) => (0, import_node_fs8.existsSync)(dir));
+  return candidates.filter((dir) => (0, import_node_fs9.existsSync)(dir));
 }
 function normalizeByokBaseUrl(baseUrl, type) {
   const trimmed = baseUrl.trim().replace(/\/+$/, "");
@@ -10219,6 +10398,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;
@@ -10286,12 +10471,12 @@ var MockProvider = class {
 
 // src/evaluation/providers/pi-cli.ts
 init_cjs_shims();
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 var import_node_crypto7 = require("crypto");
-var import_node_fs9 = require("fs");
-var import_promises20 = require("fs/promises");
-var import_node_os5 = require("os");
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_promises21 = require("fs/promises");
+var import_node_os6 = require("os");
+var import_node_path23 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/pi-log-tracker.ts
 init_cjs_shims();
@@ -10500,8 +10685,8 @@ var PiCliProvider = class {
     const cwd = this.resolveCwd(workspaceRoot, request.cwd);
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = import_node_path22.default.join(cwd, PROMPT_FILENAME);
-      await (0, import_promises20.writeFile)(promptFile, request.question, "utf8");
+      const promptFile = import_node_path23.default.join(cwd, PROMPT_FILENAME);
+      await (0, import_promises21.writeFile)(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const result = await this.executePi(args, cwd, request.signal, logger);
       if (result.timedOut) {
@@ -10563,10 +10748,10 @@ var PiCliProvider = class {
   }
   resolveCwd(workspaceRoot, cwdOverride) {
     if (cwdOverride) {
-      return import_node_path22.default.resolve(cwdOverride);
+      return import_node_path23.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path22.default.resolve(this.config.cwd);
+      return import_node_path23.default.resolve(this.config.cwd);
     }
     if (workspaceRoot) {
       return workspaceRoot;
@@ -10672,19 +10857,19 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await (0, import_promises20.mkdtemp)(import_node_path22.default.join((0, import_node_os5.tmpdir)(), WORKSPACE_PREFIX));
+    return await (0, import_promises21.mkdtemp)(import_node_path23.default.join((0, import_node_os6.tmpdir)(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
-      await (0, import_promises20.rm)(workspaceRoot, { recursive: true, force: true });
+      await (0, import_promises21.rm)(workspaceRoot, { recursive: true, force: true });
     } catch {
     }
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return import_node_path22.default.resolve(this.config.logDir);
+      return import_node_path23.default.resolve(this.config.logDir);
     }
-    return import_node_path22.default.join(process.cwd(), ".agentv", "logs", "pi-cli");
+    return import_node_path23.default.join(process.cwd(), ".agentv", "logs", "pi-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -10692,13 +10877,13 @@ ${prompt}` : prompt;
       return void 0;
     }
     try {
-      await (0, import_promises20.mkdir)(logDir, { recursive: true });
+      await (0, import_promises21.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path22.default.join(logDir, buildLogFilename5(request, this.targetName));
+    const filePath = import_node_path23.default.join(logDir, buildLogFilename5(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -10731,7 +10916,7 @@ var PiStreamLogger = class _PiStreamLogger {
   constructor(filePath, format) {
     this.filePath = filePath;
     this.format = format;
-    this.stream = (0, import_node_fs9.createWriteStream)(filePath, { flags: "a" });
+    this.stream = (0, import_node_fs10.createWriteStream)(filePath, { flags: "a" });
   }
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
@@ -11160,19 +11345,19 @@ function resolveWindowsCmd(executable) {
   if (lower.endsWith(".js") || lower.endsWith(".exe")) return [executable, []];
   let fullPath;
   try {
-    fullPath = (0, import_node_child_process4.execSync)(`where ${executable}`, { encoding: "utf-8" }).trim().split(/\r?\n/)[0].trim();
+    fullPath = (0, import_node_child_process5.execSync)(`where ${executable}`, { encoding: "utf-8" }).trim().split(/\r?\n/)[0].trim();
   } catch {
     return [executable, []];
   }
   const cmdPath = fullPath.endsWith(".cmd") ? fullPath : `${fullPath}.cmd`;
   try {
-    const content = (0, import_node_fs9.readFileSync)(cmdPath, "utf-8");
+    const content = (0, import_node_fs10.readFileSync)(cmdPath, "utf-8");
     const match = content.match(/"?%_prog%"?\s+"([^"]+\.js)"/);
     if (match) {
-      const dp0 = import_node_path22.default.dirname(import_node_path22.default.resolve(cmdPath));
-      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${import_node_path22.default.sep}`);
+      const dp0 = import_node_path23.default.dirname(import_node_path23.default.resolve(cmdPath));
+      const scriptPath = match[1].replace(/%dp0%[/\\]?/gi, `${dp0}${import_node_path23.default.sep}`);
       try {
-        (0, import_node_fs9.accessSync)(scriptPath);
+        (0, import_node_fs10.accessSync)(scriptPath);
         return ["node", [scriptPath]];
       } catch {
       }
@@ -11187,7 +11372,7 @@ async function defaultPiRunner(options) {
     const [resolvedExe, prefixArgs] = resolveWindowsCmd(parts[0]);
     const executableArgs = [...prefixArgs, ...parts.slice(1)];
     const allArgs = [...executableArgs, ...options.args];
-    const child = (0, import_node_child_process4.spawn)(resolvedExe, allArgs, {
+    const child = (0, import_node_child_process5.spawn)(resolvedExe, allArgs, {
       cwd: options.cwd,
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -11246,18 +11431,18 @@ async function defaultPiRunner(options) {
 
 // src/evaluation/providers/pi-coding-agent.ts
 init_cjs_shims();
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 var import_node_crypto8 = require("crypto");
-var import_node_fs10 = require("fs");
-var import_promises21 = require("fs/promises");
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_promises22 = require("fs/promises");
+var import_node_path25 = __toESM(require("path"), 1);
 var import_node_readline = require("readline");
 var import_node_url4 = require("url");
 
 // src/paths.ts
 init_cjs_shims();
-var import_node_os6 = __toESM(require("os"), 1);
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_os7 = __toESM(require("os"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 var logged = false;
 function getAgentvHome() {
   const envHome = process.env.AGENTV_HOME;
@@ -11268,19 +11453,19 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return import_node_path23.default.join(import_node_os6.default.homedir(), ".agentv");
+  return import_node_path24.default.join(import_node_os7.default.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return import_node_path23.default.join(getAgentvHome(), "workspaces");
+  return import_node_path24.default.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return import_node_path23.default.join(getAgentvHome(), "subagents");
+  return import_node_path24.default.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return import_node_path23.default.join(getAgentvHome(), "trace-state");
+  return import_node_path24.default.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return import_node_path23.default.join(getAgentvHome(), "workspace-pool");
+  return import_node_path24.default.join(getAgentvHome(), "workspace-pool");
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
@@ -11302,11 +11487,11 @@ async function promptInstall() {
   }
 }
 function findManagedSdkInstallRoot() {
-  return import_node_path24.default.join(getAgentvHome(), "deps", "pi-sdk");
+  return import_node_path25.default.join(getAgentvHome(), "deps", "pi-sdk");
 }
 function resolveGlobalNpmRoot() {
   try {
-    const root = (0, import_node_child_process5.execSync)("npm root -g", {
+    const root = (0, import_node_child_process6.execSync)("npm root -g", {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
@@ -11316,12 +11501,12 @@ function resolveGlobalNpmRoot() {
   }
 }
 function buildGlobalModuleEntry(moduleName, globalNpmRoot) {
-  return import_node_path24.default.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
+  return import_node_path25.default.join(globalNpmRoot, ...moduleName.split("/"), "dist", "index.js");
 }
 function findAccessiblePath(paths) {
   for (const candidate of paths) {
     try {
-      (0, import_node_fs10.accessSync)(candidate);
+      (0, import_node_fs11.accessSync)(candidate);
       return candidate;
     } catch {
     }
@@ -11342,11 +11527,11 @@ async function tryImportLocalSdkModules() {
 async function tryImportManagedSdkModules() {
   const managedRoot = findManagedSdkInstallRoot();
   const piCodingAgentEntry = findAccessiblePath([
-    import_node_path24.default.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
+    import_node_path25.default.join(managedRoot, "node_modules", "@mariozechner", "pi-coding-agent", "dist", "index.js")
   ]);
   const piAiEntry = findAccessiblePath([
-    import_node_path24.default.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
-    import_node_path24.default.join(
+    import_node_path25.default.join(managedRoot, "node_modules", "@mariozechner", "pi-ai", "dist", "index.js"),
+    import_node_path25.default.join(
       managedRoot,
       "node_modules",
       "@mariozechner",
@@ -11377,7 +11562,7 @@ async function tryImportGlobalSdkModules() {
   ]);
   const piAiEntry = findAccessiblePath([
     buildGlobalModuleEntry("@mariozechner/pi-ai", globalNpmRoot),
-    import_node_path24.default.join(
+    import_node_path25.default.join(
       globalNpmRoot,
       "@mariozechner",
       "pi-coding-agent",
@@ -11401,8 +11586,8 @@ async function tryImportGlobalSdkModules() {
 }
 function installSdkModules(installDir) {
   console.error(`Installing @mariozechner/pi-coding-agent into ${installDir} via npm...`);
-  (0, import_node_fs10.mkdirSync)(installDir, { recursive: true });
-  (0, import_node_child_process5.execSync)("npm install --no-save --no-package-lock @mariozechner/pi-coding-agent", {
+  (0, import_node_fs11.mkdirSync)(installDir, { recursive: true });
+  (0, import_node_child_process6.execSync)("npm install --no-save --no-package-lock @mariozechner/pi-coding-agent", {
     cwd: installDir,
     stdio: "inherit"
   });
@@ -11678,10 +11863,10 @@ ${fileList}`;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return import_node_path24.default.resolve(cwdOverride);
+      return import_node_path25.default.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return import_node_path24.default.resolve(this.config.cwd);
+      return import_node_path25.default.resolve(this.config.cwd);
     }
     return process.cwd();
   }
@@ -11700,9 +11885,9 @@ ${fileList}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return import_node_path24.default.resolve(this.config.logDir);
+      return import_node_path25.default.resolve(this.config.logDir);
     }
-    return import_node_path24.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return import_node_path25.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -11710,13 +11895,13 @@ ${fileList}`;
       return void 0;
     }
     try {
-      await (0, import_promises21.mkdir)(logDir, { recursive: true });
+      await (0, import_promises22.mkdir)(logDir, { recursive: true });
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = import_node_path24.default.join(logDir, buildLogFilename6(request, this.targetName));
+    const filePath = import_node_path25.default.join(logDir, buildLogFilename6(request, this.targetName));
     try {
       const logger = await PiStreamLogger2.create({
         filePath,
@@ -11747,7 +11932,7 @@ var PiStreamLogger2 = class _PiStreamLogger {
   constructor(filePath, format) {
     this.filePath = filePath;
     this.format = format;
-    this.stream = (0, import_node_fs10.createWriteStream)(filePath, { flags: "a" });
+    this.stream = (0, import_node_fs11.createWriteStream)(filePath, { flags: "a" });
   }
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
@@ -11931,7 +12116,7 @@ var ProviderRegistry = class {
 
 // src/evaluation/providers/targets.ts
 init_cjs_shims();
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var import_zod3 = require("zod");
 var CliHealthcheckHttpInputSchema = import_zod3.z.object({
   url: import_zod3.z.string().min(1, "healthcheck URL is required"),
@@ -12018,11 +12203,11 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path25.default.isAbsolute(cwd)) {
-    cwd = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path26.default.isAbsolute(cwd)) {
+    cwd = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath));
+    cwd = import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath));
   }
   return {
     command,
@@ -12045,15 +12230,15 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   let cwd = resolveOptionalString(input.cwd, env, `${targetName} working directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path25.default.isAbsolute(cwd)) {
-    cwd = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path26.default.isAbsolute(cwd)) {
+    cwd = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), cwd);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12061,7 +12246,7 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
     );
   }
   if (!cwd && !workspaceTemplate && evalFilePath) {
-    cwd = import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath));
+    cwd = import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath));
   }
   const timeoutSeconds = input.timeout_seconds;
   const timeoutMs = timeoutSeconds !== void 0 ? Math.floor(timeoutSeconds * 1e3) : void 0;
@@ -12613,8 +12798,8 @@ function resolveCodexConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12698,8 +12883,8 @@ function resolveCopilotSdkConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12815,8 +13000,8 @@ function resolveCopilotCliConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12909,8 +13094,8 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -12995,8 +13180,8 @@ function resolvePiCliConfig(target, env, evalFilePath) {
     `${target.name} pi-cli workspace template`,
     { allowLiteral: true, optionalEnv: true }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(`${target.name}: 'cwd' and 'workspace_template' are mutually exclusive.`);
@@ -13050,8 +13235,8 @@ function resolveClaudeConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -13107,8 +13292,8 @@ function resolveVSCodeConfig(target, env, insiders, evalFilePath) {
       optionalEnv: true
     }
   ) : void 0;
-  if (workspaceTemplate && evalFilePath && !import_node_path25.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path26.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), workspaceTemplate);
   }
   const executableSource = target.executable;
   const waitSource = target.wait;
@@ -13171,11 +13356,11 @@ function resolveDiscoveredProviderConfig(target, providerKind, env, evalFilePath
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path25.default.isAbsolute(cwd)) {
-    cwd = import_node_path25.default.resolve(import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path26.default.isAbsolute(cwd)) {
+    cwd = import_node_path26.default.resolve(import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path25.default.dirname(import_node_path25.default.resolve(evalFilePath));
+    cwd = import_node_path26.default.dirname(import_node_path26.default.resolve(evalFilePath));
   }
   return {
     command,
@@ -13396,46 +13581,46 @@ function resolveOptionalNumberArray(source, description) {
 
 // src/evaluation/providers/vscode-provider.ts
 init_cjs_shims();
-var import_node_child_process7 = require("child_process");
-var import_promises28 = require("fs/promises");
-var import_node_path36 = __toESM(require("path"), 1);
-var import_node_util3 = require("util");
+var import_node_child_process8 = require("child_process");
+var import_promises29 = require("fs/promises");
+var import_node_path37 = __toESM(require("path"), 1);
+var import_node_util4 = require("util");
 
 // src/evaluation/providers/vscode/index.ts
 init_cjs_shims();
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
 init_cjs_shims();
-var import_promises26 = require("fs/promises");
-var import_node_path34 = __toESM(require("path"), 1);
+var import_promises27 = require("fs/promises");
+var import_node_path35 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
 init_cjs_shims();
-var import_node_fs11 = require("fs");
-var import_promises22 = require("fs/promises");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_fs12 = require("fs");
+var import_promises23 = require("fs/promises");
+var import_node_path27 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises22.access)(target, import_node_fs11.constants.F_OK);
+    await (0, import_promises23.access)(target, import_node_fs12.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(target) {
-  await (0, import_promises22.mkdir)(target, { recursive: true });
+  await (0, import_promises23.mkdir)(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await (0, import_promises22.readdir)(target, { withFileTypes: true });
+  const entries = await (0, import_promises23.readdir)(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: import_node_path26.default.join(target, entry.name),
+    absolutePath: import_node_path27.default.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
 async function removeIfExists(target) {
   try {
-    await (0, import_promises22.rm)(target, { force: true, recursive: false });
+    await (0, import_promises23.rm)(target, { force: true, recursive: false });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -13445,9 +13630,9 @@ async function removeIfExists(target) {
 
 // src/evaluation/providers/vscode/utils/path.ts
 init_cjs_shims();
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_path28 = __toESM(require("path"), 1);
 function pathToFileUri2(filePath) {
-  const absolutePath = import_node_path27.default.isAbsolute(filePath) ? filePath : import_node_path27.default.resolve(filePath);
+  const absolutePath = import_node_path28.default.isAbsolute(filePath) ? filePath : import_node_path28.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -13457,7 +13642,7 @@ function pathToFileUri2(filePath) {
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
 init_cjs_shims();
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/template.ts
 init_cjs_shims();
@@ -13551,8 +13736,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path28.default.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${import_node_path28.default.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path29.default.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${import_node_path29.default.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -13561,8 +13746,8 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
 init_cjs_shims();
-var import_promises23 = require("fs/promises");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_promises24 = require("fs/promises");
+var import_node_path30 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/time.ts
 init_cjs_shims();
@@ -13601,7 +13786,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await (0, import_promises23.readFile)(responseFileFinal, { encoding: "utf8" });
+      const content = await (0, import_promises24.readFile)(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -13622,7 +13807,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) => import_node_path29.default.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => import_node_path30.default.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -13631,7 +13816,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => import_node_path29.default.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => import_node_path30.default.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -13658,7 +13843,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await (0, import_promises23.readFile)(file, { encoding: "utf8" });
+        const content = await (0, import_promises24.readFile)(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -13681,24 +13866,24 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
 init_cjs_shims();
-var import_node_child_process6 = require("child_process");
-var import_promises24 = require("fs/promises");
-var import_node_path31 = __toESM(require("path"), 1);
-var import_node_util2 = require("util");
+var import_node_child_process7 = require("child_process");
+var import_promises25 = require("fs/promises");
+var import_node_path32 = __toESM(require("path"), 1);
+var import_node_util3 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
 init_cjs_shims();
-var import_node_path30 = __toESM(require("path"), 1);
+var import_node_path31 = __toESM(require("path"), 1);
 var DEFAULT_LOCK_NAME = "subagent.lock";
 var DEFAULT_ALIVE_FILENAME = ".alive";
 function getDefaultSubagentRoot(vscodeCmd = "code") {
   const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
-  return import_node_path30.default.join(getSubagentsRoot(), folder);
+  return import_node_path31.default.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process6.exec);
+var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process7.exec);
 function shellQuote(cmd) {
   return cmd.includes(" ") ? `"${cmd}"` : cmd;
 }
@@ -13709,7 +13894,7 @@ model: Grok Code Fast 1 (copilot)
 function spawnVsCode(vscodeCmd, args, options) {
   const useShell = options?.shell ?? true;
   const command = useShell ? shellQuote(vscodeCmd) : vscodeCmd;
-  const child = (0, import_node_child_process6.spawn)(command, args, {
+  const child = (0, import_node_child_process7.spawn)(command, args, {
     windowsHide: true,
     shell: useShell,
     detached: false
@@ -13744,7 +13929,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
     });
@@ -13760,12 +13945,12 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = import_node_path31.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = import_node_path32.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = import_node_path31.default.join(subagentDir, ".github", "agents");
-  await (0, import_promises24.mkdir)(githubAgentsDir, { recursive: true });
-  const wakeupDst = import_node_path31.default.join(githubAgentsDir, "wakeup.md");
-  await (0, import_promises24.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  const githubAgentsDir = import_node_path32.default.join(subagentDir, ".github", "agents");
+  await (0, import_promises25.mkdir)(githubAgentsDir, { recursive: true });
+  const wakeupDst = import_node_path32.default.join(githubAgentsDir, "wakeup.md");
+  await (0, import_promises25.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
   });
@@ -13777,7 +13962,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${import_node_path31.default.basename(subagentDir)} folder`
+    `create a file named .alive in the ${import_node_path32.default.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -13792,27 +13977,27 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path31.default.join(subagentDir, "messages");
-  await (0, import_promises24.mkdir)(messagesDir, { recursive: true });
-  const reqFile = import_node_path31.default.join(messagesDir, `${timestamp}_req.md`);
-  await (0, import_promises24.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
+  const workspacePath = import_node_path32.default.join(subagentDir, `${import_node_path32.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path32.default.join(subagentDir, "messages");
+  await (0, import_promises25.mkdir)(messagesDir, { recursive: true });
+  const reqFile = import_node_path32.default.join(messagesDir, `${timestamp}_req.md`);
+  await (0, import_promises25.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${import_node_path31.default.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${import_node_path32.default.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path31.default.basename(subagentDir),
+    import_node_path32.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path31.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path32.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -13820,9 +14005,9 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path31.default.join(subagentDir, "messages");
-  await (0, import_promises24.mkdir)(messagesDir, { recursive: true });
+  const workspacePath = import_node_path32.default.join(subagentDir, `${import_node_path32.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path32.default.join(subagentDir, "messages");
+  await (0, import_promises25.mkdir)(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
@@ -13830,13 +14015,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path31.default.basename(subagentDir),
+    import_node_path32.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path31.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path32.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -13846,12 +14031,12 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
 init_cjs_shims();
-var import_promises25 = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_promises26 = require("fs/promises");
+var import_node_path34 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/workspace.ts
 init_cjs_shims();
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_path33 = __toESM(require("path"), 1);
 var import_json5 = __toESM(require("json5"), 1);
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -13868,10 +14053,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (import_node_path32.default.isAbsolute(folderPath)) {
+    if (import_node_path33.default.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = import_node_path32.default.resolve(templateDir, folderPath);
+    const absolutePath = import_node_path33.default.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -13893,19 +14078,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = import_node_path32.default.isAbsolute(locationPath);
+          const isAbsolute = import_node_path33.default.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = import_node_path32.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = import_node_path33.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             } else {
               const basePathEnd = locationPath.lastIndexOf("/", firstGlobIndex);
               const basePath = basePathEnd !== -1 ? locationPath.substring(0, basePathEnd) : ".";
               const patternPath = locationPath.substring(basePathEnd !== -1 ? basePathEnd : 0);
-              const resolvedPath = (import_node_path32.default.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (import_node_path33.default.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -13946,7 +14131,7 @@ async function findUnlockedSubagent(subagentRoot) {
     number: Number.parseInt(entry.name.split("-")[1] ?? "", 10)
   })).filter((entry) => Number.isInteger(entry.number)).sort((a, b) => a.number - b.number);
   for (const subagent of subagents) {
-    const lockFile = import_node_path33.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = import_node_path34.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -13956,26 +14141,26 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = import_node_path33.default.resolve(workspaceTemplate);
+    const workspaceSrc = import_node_path34.default.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await (0, import_promises25.stat)(workspaceSrc);
+    const stats = await (0, import_promises26.stat)(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await (0, import_promises25.readFile)(workspaceSrc, "utf8");
+    const templateText = await (0, import_promises26.readFile)(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${import_node_path33.default.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = import_node_path33.default.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? import_node_path33.default.dirname(import_node_path33.default.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${import_node_path34.default.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = import_node_path34.default.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? import_node_path34.default.dirname(import_node_path34.default.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = import_node_path33.default.resolve(cwd);
+    const absCwd = import_node_path34.default.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -13983,36 +14168,36 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
       transformedContent = JSON.stringify(parsed, null, 2);
     }
   }
-  await (0, import_promises25.writeFile)(workspaceDst, transformedContent, "utf8");
-  const messagesDir = import_node_path33.default.join(subagentDir, "messages");
-  await (0, import_promises25.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises26.writeFile)(workspaceDst, transformedContent, "utf8");
+  const messagesDir = import_node_path34.default.join(subagentDir, "messages");
+  await (0, import_promises26.mkdir)(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = import_node_path33.default.join(subagentDir, "messages");
+  const messagesDir = import_node_path34.default.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await (0, import_promises25.readdir)(messagesDir);
+    const files = await (0, import_promises26.readdir)(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = import_node_path33.default.join(messagesDir, file);
+        const target = import_node_path34.default.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = import_node_path33.default.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = import_node_path34.default.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await (0, import_promises25.readdir)(githubAgentsDir);
+    const agentFiles = await (0, import_promises26.readdir)(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path33.default.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path34.default.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = import_node_path33.default.join(subagentDir, DEFAULT_LOCK_NAME);
-  await (0, import_promises25.writeFile)(lockFile, "", { encoding: "utf8" });
+  const lockFile = import_node_path34.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  await (0, import_promises26.writeFile)(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = import_node_path33.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = import_node_path34.default.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -14032,11 +14217,11 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = import_node_path33.default.join(subagentDir, ".github", "agents");
-    await (0, import_promises25.mkdir)(githubAgentsDir, { recursive: true });
-    const agentFile = import_node_path33.default.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = import_node_path34.default.join(subagentDir, ".github", "agents");
+    await (0, import_promises26.mkdir)(githubAgentsDir, { recursive: true });
+    const agentFile = import_node_path34.default.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await (0, import_promises25.copyFile)(promptFile, agentFile);
+      await (0, import_promises26.copyFile)(promptFile, agentFile);
     } catch (error) {
       console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
@@ -14053,11 +14238,11 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = import_node_path34.default.resolve(promptFile);
+  const resolvedPrompt = import_node_path35.default.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await (0, import_promises26.stat)(resolvedPrompt);
+  const promptStats = await (0, import_promises27.stat)(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -14069,7 +14254,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = import_node_path34.default.resolve(attachment);
+    const resolvedPath = import_node_path35.default.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -14111,7 +14296,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = import_node_path34.default.basename(subagentDir);
+    const subagentName = import_node_path35.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -14139,9 +14324,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path34.default.join(subagentDir, "messages");
-    const responseFileTmp = import_node_path34.default.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = import_node_path34.default.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = import_node_path35.default.join(subagentDir, "messages");
+    const responseFileTmp = import_node_path35.default.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = import_node_path35.default.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -14246,7 +14431,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = import_node_path34.default.basename(subagentDir);
+    subagentName = import_node_path35.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -14277,24 +14462,24 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path34.default.join(subagentDir, "messages");
+    const messagesDir = import_node_path35.default.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => import_node_path34.default.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => import_node_path35.default.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => import_node_path34.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => import_node_path35.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => import_node_path34.default.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => import_node_path35.default.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = import_node_path34.default.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = import_node_path35.default.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
           const reqFile = requestFiles[index];
           const tmpFile = responseTmpFiles[index];
           const finalFile = responseFilesFinal[index];
-          return (0, import_promises26.writeFile)(
+          return (0, import_promises27.writeFile)(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -14306,7 +14491,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await (0, import_promises26.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await (0, import_promises27.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -14373,8 +14558,8 @@ async function dispatchBatchAgent(options) {
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
 init_cjs_shims();
-var import_promises27 = require("fs/promises");
-var import_node_path35 = __toESM(require("path"), 1);
+var import_promises28 = require("fs/promises");
+var import_node_path36 = __toESM(require("path"), 1);
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -14405,7 +14590,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = import_node_path35.default.resolve(targetRoot);
+  const targetPath = import_node_path36.default.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -14425,7 +14610,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = import_node_path35.default.join(entry.absolutePath, lockName);
+      const lockFile = import_node_path36.default.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -14442,10 +14627,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = import_node_path35.default.join(subagentDir, ".github", "agents");
-    const lockFile = import_node_path35.default.join(subagentDir, lockName);
-    const workspaceDst = import_node_path35.default.join(subagentDir, `${import_node_path35.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path35.default.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = import_node_path36.default.join(subagentDir, ".github", "agents");
+    const lockFile = import_node_path36.default.join(subagentDir, lockName);
+    const workspaceDst = import_node_path36.default.join(subagentDir, `${import_node_path36.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path36.default.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -14454,8 +14639,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises28.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises28.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -14465,8 +14650,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises28.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises28.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -14474,8 +14659,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises28.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises28.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -14483,15 +14668,15 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = import_node_path35.default.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = import_node_path35.default.join(subagentDir, ".github", "agents");
-    const workspaceDst = import_node_path35.default.join(subagentDir, `${import_node_path35.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path35.default.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = import_node_path36.default.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = import_node_path36.default.join(subagentDir, ".github", "agents");
+    const workspaceDst = import_node_path36.default.join(subagentDir, `${import_node_path36.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path36.default.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await (0, import_promises27.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises27.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises28.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises28.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -14534,7 +14719,7 @@ var AGENTV_BATCH_REQUEST_TEMPLATE = `[[ ## task ## ]]
 `;
 
 // src/evaluation/providers/vscode-provider.ts
-var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process7.exec);
+var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process8.exec);
 var VSCodeProvider = class {
   id;
   kind;
@@ -14677,9 +14862,9 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = import_node_path36.default.isAbsolute(candidate) ? candidate : import_node_path36.default.resolve(candidate);
+    const resolved = import_node_path37.default.isAbsolute(candidate) ? candidate : import_node_path37.default.resolve(candidate);
     try {
-      await (0, import_promises28.access)(resolved, import_promises28.constants.F_OK);
+      await (0, import_promises29.access)(resolved, import_promises29.constants.F_OK);
       return resolved;
     } catch {
       throw new Error(
@@ -14689,10 +14874,10 @@ 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 (0, import_promises28.access)(lines[0], import_promises28.constants.F_OK);
+      await (0, import_promises29.access)(lines[0], import_promises29.constants.F_OK);
       return lines[0];
     }
   } catch {
@@ -14706,7 +14891,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await (0, import_promises28.stat)(import_node_path36.default.resolve(template));
+    const stats = await (0, import_promises29.stat)(import_node_path37.default.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -14730,7 +14915,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path36.default.basename(absolutePath);
+    const fileName = import_node_path37.default.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -14751,7 +14936,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path36.default.resolve(attachment);
+    const absolutePath = import_node_path37.default.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -14759,7 +14944,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = import_node_path36.default.isAbsolute(filePath) ? filePath : import_node_path36.default.resolve(filePath);
+  const absolutePath = import_node_path37.default.isAbsolute(filePath) ? filePath : import_node_path37.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -14772,7 +14957,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(import_node_path36.default.resolve(attachment));
+    deduped.add(import_node_path37.default.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -14781,7 +14966,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(import_node_path36.default.resolve(inputFile));
+      deduped.add(import_node_path37.default.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -14874,9 +15059,9 @@ function isAgentProvider(provider) {
 
 // src/evaluation/providers/targets-file.ts
 init_cjs_shims();
-var import_node_fs12 = require("fs");
-var import_promises29 = require("fs/promises");
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_fs13 = require("fs");
+var import_promises30 = require("fs/promises");
+var import_node_path38 = __toESM(require("path"), 1);
 var import_yaml8 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -14909,18 +15094,18 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises29.access)(filePath, import_node_fs12.constants.F_OK);
+    await (0, import_promises30.access)(filePath, import_node_fs13.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = import_node_path37.default.resolve(filePath);
+  const absolutePath = import_node_path38.default.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await (0, import_promises29.readFile)(absolutePath, "utf8");
+  const raw = await (0, import_promises30.readFile)(absolutePath, "utf8");
   const parsed = (0, import_yaml8.parse)(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -14937,16 +15122,16 @@ function listTargetNames(definitions) {
 
 // src/evaluation/providers/provider-discovery.ts
 init_cjs_shims();
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path39 = __toESM(require("path"), 1);
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path38.default.resolve(baseDir);
-  const root = import_node_path38.default.parse(dir).root;
+  let dir = import_node_path39.default.resolve(baseDir);
+  const root = import_node_path39.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path38.default.join(dir, ".agentv", "providers"));
-    dir = import_node_path38.default.dirname(dir);
+    candidateDirs.push(import_node_path39.default.join(dir, ".agentv", "providers"));
+    dir = import_node_path39.default.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -14962,7 +15147,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = import_node_path38.default.basename(filePath);
+    const basename = import_node_path39.default.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -15092,9 +15277,9 @@ function negateScore(score) {
 
 // src/evaluation/evaluators/code-evaluator.ts
 init_cjs_shims();
-var import_promises30 = require("fs/promises");
-var import_node_os7 = require("os");
-var import_node_path39 = require("path");
+var import_promises31 = require("fs/promises");
+var import_node_os8 = require("os");
+var import_node_path40 = require("path");
 init_exec();
 
 // src/runtime/target-proxy.ts
@@ -15429,8 +15614,8 @@ async function materializeContentForGrader(messages, getWorkDir) {
         const [, mediaType, base64Data] = match;
         const ext = mediaType.split("/")[1] === "jpeg" ? "jpg" : mediaType.split("/")[1] ?? "bin";
         const dir = await getWorkDir();
-        const filePath = (0, import_node_path39.join)(dir, `img-${counter++}.${ext}`);
-        await (0, import_promises30.writeFile)(filePath, Buffer.from(base64Data, "base64"));
+        const filePath = (0, import_node_path40.join)(dir, `img-${counter++}.${ext}`);
+        await (0, import_promises31.writeFile)(filePath, Buffer.from(base64Data, "base64"));
         blocks.push({ type: "image", media_type: img.media_type, path: filePath });
       } else {
         blocks.push({ type: "image", media_type: img.media_type, path: img.source });
@@ -15458,7 +15643,7 @@ var CodeEvaluator = class {
     let imageTmpDir;
     const getImageDir = async () => {
       if (!imageTmpDir) {
-        imageTmpDir = await (0, import_promises30.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-img-"));
+        imageTmpDir = await (0, import_promises31.mkdtemp)((0, import_node_path40.join)((0, import_node_os8.tmpdir)(), "agentv-img-"));
       }
       return imageTmpDir;
     };
@@ -15471,9 +15656,9 @@ var CodeEvaluator = class {
     if (outputForPayload) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
-        const tmpDir = await (0, import_promises30.mkdtemp)((0, import_node_path39.join)((0, import_node_os7.tmpdir)(), "agentv-grader-"));
-        outputPath = (0, import_node_path39.join)(tmpDir, "output.json");
-        await (0, import_promises30.writeFile)(outputPath, serialized);
+        const tmpDir = await (0, import_promises31.mkdtemp)((0, import_node_path40.join)((0, import_node_os8.tmpdir)(), "agentv-grader-"));
+        outputPath = (0, import_node_path40.join)(tmpDir, "output.json");
+        await (0, import_promises31.writeFile)(outputPath, serialized);
         outputForPayload = null;
       }
     }
@@ -15603,11 +15788,11 @@ var CodeEvaluator = class {
         await proxyShutdown();
       }
       if (outputPath) {
-        await (0, import_promises30.rm)((0, import_node_path39.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
+        await (0, import_promises31.rm)((0, import_node_path40.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
         });
       }
       if (imageTmpDir) {
-        await (0, import_promises30.rm)(imageTmpDir, { recursive: true, force: true }).catch(() => {
+        await (0, import_promises31.rm)(imageTmpDir, { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -15640,8 +15825,8 @@ var import_ai3 = require("ai");
 
 // src/evaluation/evaluators/llm-grader.ts
 init_cjs_shims();
-var import_promises31 = __toESM(require("fs/promises"), 1);
-var import_node_path40 = __toESM(require("path"), 1);
+var import_promises32 = __toESM(require("fs/promises"), 1);
+var import_node_path41 = __toESM(require("path"), 1);
 var import_ai2 = require("ai");
 var import_zod4 = require("zod");
 var DEFAULT_MAX_STEPS = 10;
@@ -16675,8 +16860,8 @@ function toAiSdkImageParts(images) {
   }));
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = import_node_path40.default.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + import_node_path40.default.sep) && resolved !== basePath) {
+  const resolved = import_node_path41.default.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + import_node_path41.default.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -16691,7 +16876,7 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const entries = await import_promises31.default.readdir(resolved, { withFileTypes: true });
+          const entries = await import_promises32.default.readdir(resolved, { withFileTypes: true });
           return entries.map((e) => ({
             name: e.name,
             type: e.isDirectory() ? "directory" : "file"
@@ -16709,20 +16894,20 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat12 = await import_promises31.default.stat(resolved);
-          if (stat12.isDirectory()) {
+          const stat13 = await import_promises32.default.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 fd = await import_promises31.default.open(resolved, "r");
+          const buffer = Buffer.alloc(Math.min(stat13.size, MAX_FILE_SIZE));
+          const fd = await import_promises32.default.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
           } finally {
             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) };
         }
@@ -16759,30 +16944,30 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   if (matches.length >= MAX_SEARCH_MATCHES) return;
   let entries;
   try {
-    entries = await import_promises31.default.readdir(dirPath, { withFileTypes: true });
+    entries = await import_promises32.default.readdir(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = import_node_path40.default.join(dirPath, entry.name);
+    const fullPath = import_node_path41.default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = import_node_path40.default.extname(entry.name).toLowerCase();
+      const ext = import_node_path41.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat12 = await import_promises31.default.stat(fullPath);
-        if (stat12.size > MAX_FILE_SIZE) continue;
-        const content = await import_promises31.default.readFile(fullPath, "utf-8");
+        const stat13 = await import_promises32.default.stat(fullPath);
+        if (stat13.size > MAX_FILE_SIZE) continue;
+        const content = await import_promises32.default.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (matches.length >= MAX_SEARCH_MATCHES) return;
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: import_node_path40.default.relative(workspacePath, fullPath),
+              file: import_node_path41.default.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -18752,7 +18937,7 @@ function runEqualsAssertion(output, value) {
 init_cjs_shims();
 var import_node_crypto11 = require("crypto");
 var import_node_fs16 = require("fs");
-var import_promises35 = require("fs/promises");
+var import_promises36 = require("fs/promises");
 var import_node_path49 = __toESM(require("path"), 1);
 var import_micromatch3 = __toESM(require("micromatch"), 1);
 
@@ -18980,7 +19165,7 @@ var InlineAssertEvaluator = class {
 
 // src/evaluation/evaluators/prompt-resolution.ts
 init_cjs_shims();
-var import_node_path41 = __toESM(require("path"), 1);
+var import_node_path42 = __toESM(require("path"), 1);
 async function resolveCustomPrompt(promptConfig, context2, timeoutMs) {
   if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
     if (!context2) {
@@ -19032,7 +19217,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = import_node_path41.default.dirname(scriptPath);
+  const cwd = import_node_path42.default.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -19316,16 +19501,16 @@ function createBuiltinRegistry() {
 
 // src/evaluation/registry/assertion-discovery.ts
 init_cjs_shims();
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_path43 = __toESM(require("path"), 1);
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path42.default.resolve(baseDir);
-  const root = import_node_path42.default.parse(dir).root;
+  let dir = import_node_path43.default.resolve(baseDir);
+  const root = import_node_path43.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path42.default.join(dir, ".agentv", "assertions"));
-    dir = import_node_path42.default.dirname(dir);
+    candidateDirs.push(import_node_path43.default.join(dir, ".agentv", "assertions"));
+    dir = import_node_path43.default.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -19341,7 +19526,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path42.default.basename(filePath);
+    const basename = import_node_path43.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -19360,17 +19545,17 @@ async function discoverAssertions(registry, baseDir) {
 
 // src/evaluation/registry/grader-discovery.ts
 init_cjs_shims();
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_path44 = __toESM(require("path"), 1);
 var import_fast_glob4 = __toESM(require("fast-glob"), 1);
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path43.default.resolve(baseDir);
-  const root = import_node_path43.default.parse(dir).root;
+  let dir = import_node_path44.default.resolve(baseDir);
+  const root = import_node_path44.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path43.default.join(dir, ".agentv", "graders"));
-    candidateDirs.push(import_node_path43.default.join(dir, ".agentv", "judges"));
-    dir = import_node_path43.default.dirname(dir);
+    candidateDirs.push(import_node_path44.default.join(dir, ".agentv", "graders"));
+    candidateDirs.push(import_node_path44.default.join(dir, ".agentv", "judges"));
+    dir = import_node_path44.default.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -19386,7 +19571,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path43.default.basename(filePath);
+    const basename = import_node_path44.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -19544,59 +19729,9 @@ function getTCritical(df) {
   return T_TABLE_95[df - 1];
 }
 
-// src/evaluation/workspace/file-changes.ts
-init_cjs_shims();
-var import_node_child_process8 = require("child_process");
-var import_node_fs13 = require("fs");
-var import_node_path44 = __toESM(require("path"), 1);
-var import_node_util4 = require("util");
-var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process8.exec);
-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 = (0, import_node_fs13.readdirSync)(workspacePath);
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = import_node_path44.default.join(workspacePath, entry);
-    try {
-      if (!(0, import_node_fs13.statSync)(childPath).isDirectory()) continue;
-      if (!(0, import_node_fs13.statSync)(import_node_path44.default.join(childPath, ".git")).isDirectory()) continue;
-    } catch {
-      continue;
-    }
-    const childOpts = gitExecOpts(childPath);
-    await execAsync4("git add -A", childOpts);
-  }
-}
-
 // src/evaluation/workspace/manager.ts
 init_cjs_shims();
-var import_promises32 = require("fs/promises");
+var import_promises33 = require("fs/promises");
 var import_node_path45 = __toESM(require("path"), 1);
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
@@ -19619,7 +19754,7 @@ var WorkspaceCreationError = class extends Error {
 };
 async function isDirectory(filePath) {
   try {
-    const stats = await (0, import_promises32.stat)(filePath);
+    const stats = await (0, import_promises33.stat)(filePath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -19630,8 +19765,8 @@ function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   return import_node_path45.default.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
-  await (0, import_promises32.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises32.readdir)(src, { withFileTypes: true });
+  await (0, import_promises33.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises33.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = import_node_path45.default.join(src, entry.name);
     const destPath = import_node_path45.default.join(dest, entry.name);
@@ -19641,7 +19776,7 @@ async function copyDirectoryRecursive(src, dest) {
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(srcPath, destPath);
     } else {
-      await (0, import_promises32.cp)(srcPath, destPath, { preserveTimestamps: true });
+      await (0, import_promises33.cp)(srcPath, destPath, { preserveTimestamps: true });
     }
   }
 }
@@ -19656,7 +19791,7 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
   const workspacePath = getWorkspacePath(evalRunId, caseId, workspaceRoot);
   try {
     if (await fileExists2(workspacePath)) {
-      await (0, import_promises32.rm)(workspacePath, { recursive: true, force: true });
+      await (0, import_promises33.rm)(workspacePath, { recursive: true, force: true });
     }
     await copyDirectoryRecursive(resolvedTemplatePath, workspacePath);
     return workspacePath;
@@ -19690,14 +19825,14 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
 }
 async function cleanupWorkspace(workspacePath) {
   if (await fileExists2(workspacePath)) {
-    await (0, import_promises32.rm)(workspacePath, { recursive: true, force: true });
+    await (0, import_promises33.rm)(workspacePath, { recursive: true, force: true });
   }
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
   const evalDir = import_node_path45.default.join(root, evalRunId);
   if (await fileExists2(evalDir)) {
-    await (0, import_promises32.rm)(evalDir, { recursive: true, force: true });
+    await (0, import_promises33.rm)(evalDir, { recursive: true, force: true });
   }
 }
 
@@ -19706,7 +19841,7 @@ init_cjs_shims();
 var import_node_child_process9 = require("child_process");
 var import_node_crypto10 = require("crypto");
 var import_node_fs14 = require("fs");
-var import_promises33 = require("fs/promises");
+var import_promises34 = require("fs/promises");
 var import_node_path46 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
 var execFileAsync = (0, import_node_util5.promisify)(import_node_child_process9.execFile);
@@ -19760,8 +19895,8 @@ function computeWorkspaceFingerprint(repos) {
   return (0, import_node_crypto10.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
-  await (0, import_promises33.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises33.readdir)(src, { withFileTypes: true });
+  await (0, import_promises34.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises34.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = import_node_path46.default.join(src, entry.name);
     const destPath = import_node_path46.default.join(dest, entry.name);
@@ -19774,7 +19909,7 @@ async function copyDirectoryRecursive2(src, dest, skipDirs) {
       }
       await copyDirectoryRecursive2(srcPath, destPath, skipDirs);
     } else {
-      await (0, import_promises33.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
+      await (0, import_promises34.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
     }
   }
 }
@@ -19798,7 +19933,7 @@ var WorkspacePoolManager = class {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
     const poolDir = import_node_path46.default.join(this.poolRoot, fingerprint);
-    await (0, import_promises33.mkdir)(poolDir, { recursive: true });
+    await (0, import_promises34.mkdir)(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
       console.warn(
@@ -19825,7 +19960,7 @@ var WorkspacePoolManager = class {
           poolDir
         };
       }
-      await (0, import_promises33.mkdir)(slotPath, { recursive: true });
+      await (0, import_promises34.mkdir)(slotPath, { recursive: true });
       if (templatePath) {
         await copyDirectoryRecursive2(templatePath, slotPath);
       }
@@ -19849,7 +19984,7 @@ var WorkspacePoolManager = class {
   /** Remove lock file to release a slot. */
   async releaseSlot(slot) {
     try {
-      await (0, import_promises33.unlink)(slot.lockPath);
+      await (0, import_promises34.unlink)(slot.lockPath);
     } catch {
     }
   }
@@ -19862,21 +19997,21 @@ var WorkspacePoolManager = class {
   async tryLock(lockPath) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        await (0, import_promises33.writeFile)(lockPath, String(process.pid), { flag: "wx" });
+        await (0, import_promises34.writeFile)(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code !== "EEXIST") {
           throw err;
         }
         try {
-          const pidStr = await (0, import_promises33.readFile)(lockPath, "utf-8");
+          const pidStr = await (0, import_promises34.readFile)(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
               process.kill(pid, 0);
               return false;
             } catch {
-              await (0, import_promises33.unlink)(lockPath).catch(() => {
+              await (0, import_promises34.unlink)(lockPath).catch(() => {
               });
               continue;
             }
@@ -19896,7 +20031,7 @@ var WorkspacePoolManager = class {
   async checkDrift(poolDir, fingerprint) {
     const metadataPath = import_node_path46.default.join(poolDir, "metadata.json");
     try {
-      const raw = await (0, import_promises33.readFile)(metadataPath, "utf-8");
+      const raw = await (0, import_promises34.readFile)(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -19911,17 +20046,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await (0, import_promises33.writeFile)(import_node_path46.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await (0, import_promises34.writeFile)(import_node_path46.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
-    const entries = await (0, import_promises33.readdir)(poolDir);
+    const entries = await (0, import_promises34.readdir)(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
         const lockPath = import_node_path46.default.join(poolDir, `${entry}.lock`);
         if ((0, import_node_fs14.existsSync)(lockPath)) {
           try {
-            const pidStr = await (0, import_promises33.readFile)(lockPath, "utf-8");
+            const pidStr = await (0, import_promises34.readFile)(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -19934,12 +20069,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await (0, import_promises33.rm)(import_node_path46.default.join(poolDir, entry), { recursive: true, force: true });
-        await (0, import_promises33.rm)(lockPath, { force: true }).catch(() => {
+        await (0, import_promises34.rm)(import_node_path46.default.join(poolDir, entry), { recursive: true, force: true });
+        await (0, import_promises34.rm)(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await (0, import_promises33.rm)(import_node_path46.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await (0, import_promises34.rm)(import_node_path46.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -20198,14 +20333,14 @@ ${lines.join("\n")}`;
 
 // src/evaluation/workspace/resolve.ts
 init_cjs_shims();
-var import_promises34 = require("fs/promises");
+var import_promises35 = require("fs/promises");
 var import_node_path48 = __toESM(require("path"), 1);
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
   const resolved = import_node_path48.default.resolve(templatePath);
-  const stats = await (0, import_promises34.stat)(resolved);
+  const stats = await (0, import_promises35.stat)(resolved);
   if (stats.isFile()) {
     return {
       dir: import_node_path48.default.dirname(resolved),
@@ -20215,7 +20350,7 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await (0, import_promises34.readdir)(resolved);
+  const entries = await (0, import_promises35.readdir)(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
@@ -20323,6 +20458,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, path56) {
+    if (visiting.has(id)) {
+      const cycle = [...path56.slice(path56.indexOf(id)), id];
+      throw new Error(`Circular dependency detected: ${cycle.join(" \u2192 ")}`);
+    }
+    if (visited.has(id)) return;
+    visiting.add(id);
+    path56.push(id);
+    for (const dep of depMap.get(id) ?? []) {
+      visit(dep, path56);
+    }
+    path56.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,
@@ -20590,14 +20819,14 @@ async function runEvaluation(options) {
   let staticMaterialised = false;
   const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
   if (useStaticWorkspace && configuredStaticPath) {
-    const dirExists = await (0, import_promises35.stat)(configuredStaticPath).then(
+    const dirExists = await (0, import_promises36.stat)(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
     );
-    const isEmpty = dirExists ? (await (0, import_promises35.readdir)(configuredStaticPath)).length === 0 : false;
+    const isEmpty = dirExists ? (await (0, import_promises36.readdir)(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await (0, import_promises35.mkdir)(configuredStaticPath, { recursive: true });
+        await (0, import_promises36.mkdir)(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -20642,14 +20871,45 @@ async function runEvaluation(options) {
     }
   } else if (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await (0, import_promises35.mkdir)(sharedWorkspacePath, { recursive: true });
+    await (0, import_promises36.mkdir)(sharedWorkspacePath, { recursive: true });
     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 = import_node_path49.default.join(sharedWorkspacePath, import_node_path49.default.basename(suiteWorkspaceFile));
       try {
-        await (0, import_promises35.stat)(copiedWorkspaceFile);
+        await (0, import_promises36.stat)(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
@@ -20756,8 +21016,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) {
@@ -20766,8 +21027,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}`
+          );
         }
       }
     }
@@ -20777,204 +21041,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);
         }
       }
     }
@@ -21219,7 +21538,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";
@@ -21263,7 +21583,7 @@ async function runEvalCase(options) {
       if (caseWorkspaceFile && workspacePath) {
         const copiedFile = import_node_path49.default.join(workspacePath, import_node_path49.default.basename(caseWorkspaceFile));
         try {
-          await (0, import_promises35.stat)(copiedFile);
+          await (0, import_promises36.stat)(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -21271,7 +21591,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await (0, import_promises35.mkdir)(workspacePath, { recursive: true });
+      await (0, import_promises36.mkdir)(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
@@ -21326,8 +21646,8 @@ async function runEvalCase(options) {
           const srcPath = import_node_path49.default.resolve(baseDir, relPath);
           const destPath = import_node_path49.default.resolve(workspacePath, relPath);
           try {
-            await (0, import_promises35.mkdir)(import_node_path49.default.dirname(destPath), { recursive: true });
-            await (0, import_promises35.copyFile)(srcPath, destPath);
+            await (0, import_promises36.mkdir)(import_node_path49.default.dirname(destPath), { recursive: true });
+            await (0, import_promises36.copyFile)(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             return buildErrorResult(
@@ -21427,7 +21747,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();
@@ -21538,6 +21862,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 {
@@ -21595,7 +21924,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;
@@ -21788,7 +22118,8 @@ async function evaluateCandidate(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
-    threshold: evalThreshold
+    threshold: evalThreshold,
+    dependencyResults
   } = options;
   const gradeTimestamp = nowFn();
   const { score, scores } = await runEvaluatorsForCase({
@@ -21815,7 +22146,8 @@ async function evaluateCandidate(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
-    threshold: evalThreshold
+    threshold: evalThreshold,
+    dependencyResults
   });
   const completedAt = nowFn();
   let agentRequest;
@@ -21891,7 +22223,8 @@ async function runEvaluatorsForCase(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
-    threshold
+    threshold,
+    dependencyResults
   } = options;
   if (evalCase.assertions && evalCase.assertions.length > 0) {
     return runEvaluatorList({
@@ -21919,7 +22252,8 @@ async function runEvaluatorsForCase(options) {
       fileChanges,
       workspacePath,
       dockerConfig,
-      threshold
+      threshold,
+      dependencyResults
     });
   }
   const evaluatorKind = evalCase.evaluator ?? "llm-grader";
@@ -21949,6 +22283,7 @@ async function runEvaluatorsForCase(options) {
     fileChanges,
     workspacePath,
     dockerConfig,
+    dependencyResults,
     ...implicitEvaluator ? { evaluator: implicitEvaluator } : {}
   });
   return { score };
@@ -21988,7 +22323,8 @@ async function runEvaluatorList(options) {
     availableTargets,
     fileChanges,
     workspacePath,
-    dockerConfig
+    dockerConfig,
+    dependencyResults
   } = options;
   const scored = [];
   const scores = [];
@@ -22012,7 +22348,8 @@ async function runEvaluatorList(options) {
     availableTargets,
     fileChanges,
     workspacePath,
-    dockerConfig
+    dockerConfig,
+    dependencyResults
   };
   const evalFileDir = evalCase.file_paths[0] ? import_node_path49.default.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
@@ -22742,7 +23079,7 @@ init_cjs_shims();
 
 // src/evaluation/workspace/deps-scanner.ts
 init_cjs_shims();
-var import_promises36 = require("fs/promises");
+var import_promises37 = require("fs/promises");
 var import_node_path51 = __toESM(require("path"), 1);
 var import_yaml9 = require("yaml");
 function normalizeGitUrl(url) {
@@ -22790,7 +23127,7 @@ async function scanRepoDeps(evalFilePaths) {
   return { repos: [...seen.values()], errors };
 }
 async function extractReposFromEvalFile(filePath) {
-  const content = await (0, import_promises36.readFile)(filePath, "utf8");
+  const content = await (0, import_promises37.readFile)(filePath, "utf8");
   const parsed = interpolateEnv((0, import_yaml9.parse)(content), process.env);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
   const obj = parsed;
@@ -22811,7 +23148,7 @@ async function extractReposFromEvalFile(filePath) {
 async function extractReposFromWorkspaceRaw(raw, evalFileDir) {
   if (typeof raw === "string") {
     const workspaceFilePath = import_node_path51.default.resolve(evalFileDir, raw);
-    const content = await (0, import_promises36.readFile)(workspaceFilePath, "utf8");
+    const content = await (0, import_promises37.readFile)(workspaceFilePath, "utf8");
     const parsed = interpolateEnv((0, import_yaml9.parse)(content), process.env);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
     return extractReposFromObject(parsed);
@@ -22843,7 +23180,7 @@ init_docker_workspace();
 
 // src/evaluation/cache/response-cache.ts
 init_cjs_shims();
-var import_promises37 = require("fs/promises");
+var import_promises38 = require("fs/promises");
 var import_node_path52 = __toESM(require("path"), 1);
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
@@ -22854,7 +23191,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await (0, import_promises37.readFile)(filePath, "utf8");
+      const data = await (0, import_promises38.readFile)(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -22863,8 +23200,8 @@ var ResponseCache = class {
   async set(key, value) {
     const filePath = this.keyToPath(key);
     const dir = import_node_path52.default.dirname(filePath);
-    await (0, import_promises37.mkdir)(dir, { recursive: true });
-    await (0, import_promises37.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
+    await (0, import_promises38.mkdir)(dir, { recursive: true });
+    await (0, import_promises38.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
@@ -22887,8 +23224,8 @@ function shouldSkipCacheForTemperature(targetConfig) {
 init_cjs_shims();
 var import_node_child_process11 = require("child_process");
 var import_node_fs18 = require("fs");
-var import_promises38 = require("fs/promises");
-var import_node_os8 = __toESM(require("os"), 1);
+var import_promises39 = require("fs/promises");
+var import_node_os9 = __toESM(require("os"), 1);
 var import_node_path53 = __toESM(require("path"), 1);
 var import_node_util7 = require("util");
 var execFileAsync3 = (0, import_node_util7.promisify)(import_node_child_process11.execFile);
@@ -23079,7 +23416,7 @@ async function prepareResultsRepoBranch(config, branchName) {
   const cloneDir = await ensureResultsRepoClone(normalized);
   const baseBranch = await resolveDefaultBranch(cloneDir);
   await updateCacheRepo(cloneDir, baseBranch);
-  const worktreeRoot = await (0, import_promises38.mkdtemp)(import_node_path53.default.join(import_node_os8.default.tmpdir(), "agentv-results-repo-"));
+  const worktreeRoot = await (0, import_promises39.mkdtemp)(import_node_path53.default.join(import_node_os9.default.tmpdir(), "agentv-results-repo-"));
   const worktreeDir = import_node_path53.default.join(worktreeRoot, "repo");
   await runGit(["worktree", "add", "-B", branchName, worktreeDir, `origin/${baseBranch}`], {
     cwd: cloneDir
@@ -23092,7 +23429,7 @@ async function prepareResultsRepoBranch(config, branchName) {
       try {
         await runGit(["worktree", "remove", "--force", worktreeDir], { cwd: cloneDir });
       } finally {
-        await (0, import_promises38.rm)(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
+        await (0, import_promises39.rm)(worktreeRoot, { recursive: true, force: true }).catch(() => void 0);
       }
     }
   };
@@ -23100,7 +23437,7 @@ async function prepareResultsRepoBranch(config, branchName) {
 async function stageResultsArtifacts(params) {
   (0, import_node_fs18.rmSync)(params.destinationDir, { recursive: true, force: true });
   (0, import_node_fs18.mkdirSync)(import_node_path53.default.dirname(params.destinationDir), { recursive: true });
-  await (0, import_promises38.cp)(params.sourceDir, params.destinationDir, { recursive: true });
+  await (0, import_promises39.cp)(params.sourceDir, params.destinationDir, { recursive: true });
 }
 function resolveResultsRepoRunsDir(config) {
   const normalized = normalizeResultsExportConfig(config);
@@ -23110,12 +23447,12 @@ function resolveResultsRepoRunsDir(config) {
   );
 }
 async function directorySizeBytes(targetPath) {
-  const entry = await (0, import_promises38.stat)(targetPath);
+  const entry = await (0, import_promises39.stat)(targetPath);
   if (entry.isFile()) {
     return entry.size;
   }
   let total = 0;
-  for (const child of await (0, import_promises38.readdir)(targetPath, { withFileTypes: true })) {
+  for (const child of await (0, import_promises39.readdir)(targetPath, { withFileTypes: true })) {
     total += await directorySizeBytes(import_node_path53.default.join(targetPath, child.name));
   }
   return total;
@@ -24198,17 +24535,17 @@ function extractResponseItemContent(content) {
 
 // src/import/codex-session-discovery.ts
 init_cjs_shims();
-var import_promises40 = require("fs/promises");
-var import_node_os9 = require("os");
+var import_promises41 = require("fs/promises");
+var import_node_os10 = require("os");
 var import_node_path56 = __toESM(require("path"), 1);
-var DEFAULT_SESSIONS_DIR = () => import_node_path56.default.join((0, import_node_os9.homedir)(), ".codex", "sessions");
+var DEFAULT_SESSIONS_DIR = () => import_node_path56.default.join((0, import_node_os10.homedir)(), ".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 (0, import_promises40.readdir)(sessionsDir);
+    yearDirs = await (0, import_promises41.readdir)(sessionsDir);
   } catch {
     return [];
   }
@@ -24216,7 +24553,7 @@ async function discoverCodexSessions(opts) {
     const yearPath = import_node_path56.default.join(sessionsDir, year);
     let monthDirs;
     try {
-      monthDirs = await (0, import_promises40.readdir)(yearPath);
+      monthDirs = await (0, import_promises41.readdir)(yearPath);
     } catch {
       continue;
     }
@@ -24224,7 +24561,7 @@ async function discoverCodexSessions(opts) {
       const monthPath = import_node_path56.default.join(yearPath, month);
       let dayDirs;
       try {
-        dayDirs = await (0, import_promises40.readdir)(monthPath);
+        dayDirs = await (0, import_promises41.readdir)(monthPath);
       } catch {
         continue;
       }
@@ -24236,7 +24573,7 @@ async function discoverCodexSessions(opts) {
         const dayPath = import_node_path56.default.join(monthPath, day);
         let files;
         try {
-          files = await (0, import_promises40.readdir)(dayPath);
+          files = await (0, import_promises41.readdir)(dayPath);
         } catch {
           continue;
         }
@@ -24248,7 +24585,7 @@ async function discoverCodexSessions(opts) {
           const sessionId = parts.length >= 6 ? parts.slice(-5).join("-") : nameWithoutExt;
           let updatedAt;
           try {
-            const fileStat = await (0, import_promises40.stat)(filePath);
+            const fileStat = await (0, import_promises41.stat)(filePath);
             updatedAt = fileStat.mtime;
           } catch {
             updatedAt = /* @__PURE__ */ new Date(0);
@@ -24264,10 +24601,10 @@ async function discoverCodexSessions(opts) {
 
 // src/import/session-discovery.ts
 init_cjs_shims();
-var import_promises41 = require("fs/promises");
-var import_node_os10 = require("os");
+var import_promises42 = require("fs/promises");
+var import_node_os11 = require("os");
 var import_node_path57 = __toESM(require("path"), 1);
-var DEFAULT_PROJECTS_DIR = () => import_node_path57.default.join((0, import_node_os10.homedir)(), ".claude", "projects");
+var DEFAULT_PROJECTS_DIR = () => import_node_path57.default.join((0, import_node_os11.homedir)(), ".claude", "projects");
 function encodeProjectPath(projectPath) {
   return projectPath.replace(/\//g, "-");
 }
@@ -24276,7 +24613,7 @@ async function discoverClaudeSessions(opts) {
   const limit = opts?.latest ? 1 : opts?.limit ?? 10;
   let projectDirs;
   try {
-    projectDirs = await (0, import_promises41.readdir)(projectsDir);
+    projectDirs = await (0, import_promises42.readdir)(projectsDir);
   } catch {
     return [];
   }
@@ -24289,7 +24626,7 @@ async function discoverClaudeSessions(opts) {
     const dirPath = import_node_path57.default.join(projectsDir, projectDir);
     let entries;
     try {
-      entries = await (0, import_promises41.readdir)(dirPath);
+      entries = await (0, import_promises42.readdir)(dirPath);
     } catch {
       continue;
     }
@@ -24300,7 +24637,7 @@ async function discoverClaudeSessions(opts) {
       const filePath = import_node_path57.default.join(dirPath, entry);
       let updatedAt;
       try {
-        const fileStat = await (0, import_promises41.stat)(filePath);
+        const fileStat = await (0, import_promises42.stat)(filePath);
         updatedAt = fileStat.mtime;
       } catch {
         updatedAt = /* @__PURE__ */ new Date(0);
@@ -24322,7 +24659,7 @@ init_cjs_shims();
 
 // src/import/types.ts
 init_cjs_shims();
-var import_promises42 = require("fs/promises");
+var import_promises43 = require("fs/promises");
 function toTranscriptJsonLine(entry) {
   const firstUserMessage = entry.messages.find((m) => m.role === "user");
   const input = typeof firstUserMessage?.content === "string" ? firstUserMessage.content : "";
@@ -24348,11 +24685,11 @@ function toTranscriptJsonLine(entry) {
   };
 }
 async function readTranscriptJsonl(filePath) {
-  const text = await (0, import_promises42.readFile)(filePath, "utf8");
+  const text = await (0, import_promises43.readFile)(filePath, "utf8");
   return text.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
 }
 async function readTranscriptFile(filePath) {
-  return (0, import_promises42.readFile)(filePath, "utf8");
+  return (0, import_promises43.readFile)(filePath, "utf8");
 }
 
 // src/import/transcript-provider.ts