@agentv/core 2.5.2 → 2.5.4

package/dist/index.js

@@ -3181,16 +3181,16 @@ async function runClaudeCodeWithTempFiles(options, stdoutFile, stderrFile, exitF
   let lastStdoutSize = 0;
   const readFileIfExists = async (filePath) => {
     try {
-      const { readFile: readFile8 } = await import("node:fs/promises");
-      return await readFile8(filePath, "utf8");
+      const { readFile: readFile10 } = await import("node:fs/promises");
+      return await readFile10(filePath, "utf8");
     } catch {
       return "";
     }
   };
   const fileExists4 = async (filePath) => {
     try {
-      const { access: access4 } = await import("node:fs/promises");
-      await access4(filePath);
+      const { access: access5 } = await import("node:fs/promises");
+      await access5(filePath);
       return true;
     } catch {
       return false;
@@ -5396,14 +5396,1037 @@ async function defaultPiRunner(options) {
   });
 }
 
-// src/evaluation/providers/vscode.ts
+// src/evaluation/providers/vscode-provider.ts
+import path23 from "node:path";
+
+// src/evaluation/providers/vscode/dispatch/agentDispatch.ts
+import { stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
+import path21 from "node:path";
+
+// src/evaluation/providers/vscode/utils/fs.ts
+import { constants as constants3 } from "node:fs";
+import { access as access3, mkdir as mkdir4, readdir, rm as rm4, stat } from "node:fs/promises";
 import path13 from "node:path";
-import {
-  dispatchAgentSession,
-  dispatchBatchAgent,
-  getSubagentRoot,
-  provisionSubagents
-} from "subagent";
+async function pathExists(target) {
+  try {
+    await access3(target, constants3.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(target) {
+  await mkdir4(target, { recursive: true });
+}
+async function readDirEntries(target) {
+  const entries = await readdir(target, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    absolutePath: path13.join(target, entry.name),
+    isDirectory: entry.isDirectory()
+  }));
+}
+async function removeIfExists(target) {
+  try {
+    await rm4(target, { force: true, recursive: false });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+
+// src/evaluation/providers/vscode/utils/path.ts
+import path14 from "node:path";
+function pathToFileUri2(filePath) {
+  const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.resolve(filePath);
+  const normalizedPath = absolutePath.replace(/\\/g, "/");
+  if (/^[a-zA-Z]:\//.test(normalizedPath)) {
+    return `file:///${normalizedPath}`;
+  }
+  return `file://${normalizedPath}`;
+}
+
+// src/evaluation/providers/vscode/dispatch/promptBuilder.ts
+import path15 from "node:path";
+
+// src/evaluation/providers/vscode/utils/template.ts
+function renderTemplate2(content, variables) {
+  if (!content) {
+    return content;
+  }
+  const variableLookup = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(variables)) {
+    variableLookup.set(key.toLowerCase(), value);
+  }
+  const referencedVariables = /* @__PURE__ */ new Set();
+  const result = content.replace(/\{\{([a-zA-Z_]+)\}\}/gi, (match, variableName) => {
+    const lowerCaseKey = variableName.toLowerCase();
+    referencedVariables.add(lowerCaseKey);
+    if (!variableLookup.has(lowerCaseKey)) {
+      throw new Error(
+        `Template variable '${variableName}' is not provided in the variables object`
+      );
+    }
+    return variableLookup.get(lowerCaseKey);
+  });
+  return result;
+}
+
+// src/evaluation/providers/vscode/dispatch/templates.ts
+var DEFAULT_REQUEST_TEMPLATE = `[[ ## task ## ]]
+
+{{userQuery}}
+
+[[ ## system_instructions ## ]]
+
+**IMPORTANT**: Follow these exact steps:
+1. Create and write your complete response to: {{responseFileTmp}}
+2. When completely finished, run these PowerShell commands to signal completion:
+\`\`\`
+Move-Item -LiteralPath '{{responseFileTmp}}' -Destination '{{responseFileFinal}}'
+if (Test-Path subagent.lock) { del subagent.lock }
+\`\`\`
+
+Do not proceed to step 2 until your response is completely written to the temporary file.
+`;
+var DEFAULT_BATCH_REQUEST_TEMPLATE = `[[ ## task ## ]]
+
+{{userQuery}}
+
+[[ ## system_instructions ## ]]
+
+**IMPORTANT**: Follow these exact steps:
+1. Create and write your complete response to: {{responseFileTmp}}
+2. When completely finished and the response is stable, rename it to: {{responseFileFinal}}
+3. Do not unlock the workspace from this request; batch orchestration will handle unlocking after all responses are ready.
+`;
+var DEFAULT_BATCH_ORCHESTRATOR_TEMPLATE = `MANDATORY: Run #runSubagent tool in your Available Actions for each request file to process them in isolated contexts.
+DO NOT read the request files yourself - only pass the file paths to each subagent:
+
+{{requestFiles}}
+
+After ALL queries complete, verify all responses exist and unlock:
+
+\`\`\`powershell
+$responses = @({{responseList}})
+$missing = $responses | Where-Object { -not (Test-Path "messages/$_") }
+if ($missing.Count -eq 0) { del subagent.lock }
+\`\`\`
+`;
+
+// src/evaluation/providers/vscode/dispatch/promptBuilder.ts
+function loadDefaultRequestTemplate() {
+  return DEFAULT_REQUEST_TEMPLATE;
+}
+function loadDefaultBatchRequestTemplate() {
+  return DEFAULT_BATCH_REQUEST_TEMPLATE;
+}
+function loadDefaultBatchOrchestratorTemplate() {
+  return DEFAULT_BATCH_ORCHESTRATOR_TEMPLATE;
+}
+function createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent) {
+  return renderTemplate2(templateContent, {
+    userQuery,
+    responseFileTmp,
+    responseFileFinal
+  });
+}
+function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent) {
+  return renderTemplate2(templateContent, {
+    userQuery,
+    responseFileTmp,
+    responseFileFinal
+  });
+}
+function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path15.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path15.basename(file)}"`).join(", ");
+  return renderTemplate2(templateContent, {
+    requestFiles: requestLines,
+    responseList
+  });
+}
+
+// src/evaluation/providers/vscode/dispatch/responseWaiter.ts
+import { readFile as readFile7 } from "node:fs/promises";
+import path16 from "node:path";
+
+// src/evaluation/providers/vscode/utils/time.ts
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/evaluation/providers/vscode/dispatch/responseWaiter.ts
+async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, silent = false) {
+  if (!silent) {
+    console.error(`waiting for agent to finish: ${responseFileFinal}`);
+  }
+  try {
+    while (!await pathExists(responseFileFinal)) {
+      await sleep2(pollInterval);
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+  let attempts = 0;
+  const maxAttempts = 10;
+  while (attempts < maxAttempts) {
+    try {
+      const content = await readFile7(responseFileFinal, { encoding: "utf8" });
+      if (!silent) {
+        process.stdout.write(`${content}
+`);
+      }
+      return true;
+    } catch (error) {
+      attempts += 1;
+      if (error.code !== "EBUSY" || attempts >= maxAttempts) {
+        if (!silent) {
+          console.error(`error: failed to read agent response: ${error.message}`);
+        }
+        return false;
+      }
+      await sleep2(pollInterval);
+    }
+  }
+  return false;
+}
+async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
+  if (!silent) {
+    const fileList = responseFilesFinal.map((file) => path16.basename(file)).join(", ");
+    console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
+  }
+  try {
+    const pending = new Set(responseFilesFinal);
+    while (pending.size > 0) {
+      for (const file of [...pending]) {
+        if (await pathExists(file)) {
+          pending.delete(file);
+        }
+      }
+      if (pending.size > 0) {
+        await sleep2(pollInterval);
+      }
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+  for (const file of responseFilesFinal) {
+    let attempts = 0;
+    const maxAttempts = 10;
+    while (attempts < maxAttempts) {
+      try {
+        const content = await readFile7(file, { encoding: "utf8" });
+        if (!silent) {
+          process.stdout.write(`${content}
+`);
+        }
+        break;
+      } catch (error) {
+        attempts += 1;
+        if (error.code !== "EBUSY" || attempts >= maxAttempts) {
+          if (!silent) {
+            console.error(`error: failed to read agent response: ${error.message}`);
+          }
+          return false;
+        }
+        await sleep2(pollInterval);
+      }
+    }
+  }
+  return true;
+}
+
+// src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
+import { exec, spawn as spawn4 } from "node:child_process";
+import { mkdir as mkdir5, writeFile as writeFile4 } from "node:fs/promises";
+import path18 from "node:path";
+import { promisify as promisify3 } from "node:util";
+
+// src/evaluation/providers/vscode/dispatch/constants.ts
+import os2 from "node:os";
+import path17 from "node:path";
+var DEFAULT_LOCK_NAME = "subagent.lock";
+var DEFAULT_ALIVE_FILENAME = ".alive";
+function getDefaultSubagentRoot(vscodeCmd = "code") {
+  const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
+  return path17.join(os2.homedir(), ".agentv", "subagents", folder);
+}
+var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
+
+// src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
+var execAsync3 = promisify3(exec);
+var DEFAULT_WAKEUP_CONTENT = `---
+description: 'Wake-up Signal'
+model: Grok Code Fast 1 (copilot)
+---`;
+async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
+  try {
+    const { stdout } = await execAsync3(`${vscodeCmd} --status`, {
+      timeout: 1e4,
+      windowsHide: true
+    });
+    return stdout.includes(workspaceName);
+  } catch {
+    return false;
+  }
+}
+async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir, vscodeCmd, pollInterval = 1, timeout = 60) {
+  const alreadyOpen = await checkWorkspaceOpened(workspaceName, vscodeCmd);
+  if (alreadyOpen) {
+    spawn4(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+    return true;
+  }
+  const aliveFile = path18.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  await removeIfExists(aliveFile);
+  const githubAgentsDir = path18.join(subagentDir, ".github", "agents");
+  await mkdir5(githubAgentsDir, { recursive: true });
+  const wakeupDst = path18.join(githubAgentsDir, "wakeup.md");
+  await writeFile4(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  spawn4(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+  await sleep2(100);
+  const wakeupChatId = "wakeup";
+  const chatArgs = [
+    "-r",
+    "chat",
+    "-m",
+    wakeupChatId,
+    `create a file named .alive in the ${path18.basename(subagentDir)} folder`
+  ];
+  spawn4(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+  const start = Date.now();
+  while (!await pathExists(aliveFile)) {
+    if (Date.now() - start > timeout * 1e3) {
+      console.error(`warning: Workspace readiness timeout after ${timeout}s`);
+      return false;
+    }
+    await sleep2(pollInterval * 1e3);
+  }
+  return true;
+}
+async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
+  try {
+    const workspacePath = path18.join(subagentDir, `${path18.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path18.join(subagentDir, "messages");
+    await mkdir5(messagesDir, { recursive: true });
+    const reqFile = path18.join(messagesDir, `${timestamp}_req.md`);
+    await writeFile4(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 [${path18.basename(reqFile)}](${reqUri})`);
+    const workspaceReady = await ensureWorkspaceFocused(
+      workspacePath,
+      path18.basename(subagentDir),
+      subagentDir,
+      vscodeCmd
+    );
+    if (!workspaceReady) {
+      console.error("warning: Workspace may not be fully ready");
+    }
+    await sleep2(500);
+    spawn4(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+    return true;
+  } catch (error) {
+    console.error(`warning: Failed to launch VS Code: ${error.message}`);
+    return false;
+  }
+}
+async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
+  try {
+    const workspacePath = path18.join(subagentDir, `${path18.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path18.join(subagentDir, "messages");
+    await mkdir5(messagesDir, { recursive: true });
+    const chatArgs = ["-r", "chat", "-m", chatId];
+    for (const attachment of attachmentPaths) {
+      chatArgs.push("-a", attachment);
+    }
+    chatArgs.push(chatInstruction);
+    const workspaceReady = await ensureWorkspaceFocused(
+      workspacePath,
+      path18.basename(subagentDir),
+      subagentDir,
+      vscodeCmd
+    );
+    if (!workspaceReady) {
+      console.error("warning: Workspace may not be fully ready");
+    }
+    await sleep2(500);
+    spawn4(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+    return true;
+  } catch (error) {
+    console.error(`warning: Failed to launch VS Code: ${error.message}`);
+    return false;
+  }
+}
+
+// src/evaluation/providers/vscode/dispatch/workspaceManager.ts
+import { copyFile, mkdir as mkdir6, readFile as readFile8, readdir as readdir2, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
+import path20 from "node:path";
+
+// src/evaluation/providers/vscode/utils/workspace.ts
+import path19 from "node:path";
+import JSON5 from "json5";
+function transformWorkspacePaths(workspaceContent, templateDir) {
+  let workspace;
+  try {
+    workspace = JSON5.parse(workspaceContent);
+  } catch (error) {
+    throw new Error(`Invalid workspace JSON: ${error.message}`);
+  }
+  if (!workspace.folders) {
+    throw new Error("Workspace file must contain a 'folders' array");
+  }
+  if (!Array.isArray(workspace.folders)) {
+    throw new Error("Workspace 'folders' must be an array");
+  }
+  const transformedFolders = workspace.folders.map((folder) => {
+    const folderPath = folder.path;
+    if (path19.isAbsolute(folderPath)) {
+      return folder;
+    }
+    const absolutePath = path19.resolve(templateDir, folderPath);
+    return {
+      ...folder,
+      path: absolutePath
+    };
+  });
+  const updatedFolders = [{ path: "." }, ...transformedFolders];
+  let transformedSettings = workspace.settings;
+  if (workspace.settings) {
+    transformedSettings = {
+      ...workspace.settings
+    };
+    const chatSettingsKeys = [
+      "chat.promptFilesLocations",
+      "chat.instructionsFilesLocations",
+      "chat.modeFilesLocations"
+    ];
+    for (const settingKey of chatSettingsKeys) {
+      const locationMap = workspace.settings[settingKey];
+      if (locationMap && typeof locationMap === "object") {
+        const transformedMap = {};
+        for (const [locationPath, value] of Object.entries(locationMap)) {
+          const isAbsolute = path19.isAbsolute(locationPath);
+          if (isAbsolute) {
+            transformedMap[locationPath] = value;
+          } else {
+            const firstGlobIndex = locationPath.search(/[*]/);
+            if (firstGlobIndex === -1) {
+              const resolvedPath = path19.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 = (path19.resolve(templateDir, basePath) + patternPath).replace(
+                /\\/g,
+                "/"
+              );
+              transformedMap[resolvedPath] = value;
+            }
+          }
+        }
+        transformedSettings[settingKey] = transformedMap;
+      }
+    }
+  }
+  const transformedWorkspace = {
+    ...workspace,
+    folders: updatedFolders,
+    settings: transformedSettings
+  };
+  return JSON.stringify(transformedWorkspace, null, 2);
+}
+
+// src/evaluation/providers/vscode/dispatch/workspaceManager.ts
+var DEFAULT_WORKSPACE_TEMPLATE = {
+  folders: [
+    {
+      path: "."
+    }
+  ]
+};
+function getSubagentRoot(vscodeCmd = "code") {
+  return getDefaultSubagentRoot(vscodeCmd);
+}
+async function findUnlockedSubagent(subagentRoot) {
+  if (!await pathExists(subagentRoot)) {
+    return null;
+  }
+  const entries = await readDirEntries(subagentRoot);
+  const subagents = entries.filter((entry) => entry.isDirectory && entry.name.startsWith("subagent-")).map((entry) => ({
+    absolutePath: entry.absolutePath,
+    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 = path20.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    if (!await pathExists(lockFile)) {
+      return subagent.absolutePath;
+    }
+  }
+  return null;
+}
+async function copyAgentConfig(subagentDir, workspaceTemplate) {
+  let workspaceContent;
+  if (workspaceTemplate) {
+    const workspaceSrc = path20.resolve(workspaceTemplate);
+    if (!await pathExists(workspaceSrc)) {
+      throw new Error(`workspace template not found: ${workspaceSrc}`);
+    }
+    const stats = await stat2(workspaceSrc);
+    if (!stats.isFile()) {
+      throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
+    }
+    const templateText = await readFile8(workspaceSrc, "utf8");
+    workspaceContent = JSON.parse(templateText);
+  } else {
+    workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
+  }
+  const workspaceName = `${path20.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path20.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path20.dirname(path20.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceJson = JSON.stringify(workspaceContent, null, 2);
+  const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
+  await writeFile5(workspaceDst, transformedContent, "utf8");
+  const messagesDir = path20.join(subagentDir, "messages");
+  await mkdir6(messagesDir, { recursive: true });
+  return { workspace: workspaceDst, messagesDir };
+}
+async function createSubagentLock(subagentDir) {
+  const messagesDir = path20.join(subagentDir, "messages");
+  if (await pathExists(messagesDir)) {
+    const files = await readdir2(messagesDir);
+    await Promise.all(
+      files.map(async (file) => {
+        const target = path20.join(messagesDir, file);
+        await removeIfExists(target);
+      })
+    );
+  }
+  const githubAgentsDir = path20.join(subagentDir, ".github", "agents");
+  if (await pathExists(githubAgentsDir)) {
+    const agentFiles = await readdir2(githubAgentsDir);
+    const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
+    await Promise.all(
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path20.join(githubAgentsDir, file)))
+    );
+  }
+  const lockFile = path20.join(subagentDir, DEFAULT_LOCK_NAME);
+  await writeFile5(lockFile, "", { encoding: "utf8" });
+  return lockFile;
+}
+async function removeSubagentLock(subagentDir) {
+  const lockFile = path20.join(subagentDir, DEFAULT_LOCK_NAME);
+  await removeIfExists(lockFile);
+}
+async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
+  if (dryRun) {
+    return 0;
+  }
+  try {
+    await copyAgentConfig(subagentDir, workspaceTemplate);
+  } catch (error) {
+    console.error(`error: ${error.message}`);
+    return 1;
+  }
+  try {
+    await createSubagentLock(subagentDir);
+  } catch (error) {
+    console.error(`error: Failed to create subagent lock: ${error.message}`);
+    return 1;
+  }
+  if (promptFile) {
+    const githubAgentsDir = path20.join(subagentDir, ".github", "agents");
+    await mkdir6(githubAgentsDir, { recursive: true });
+    const agentFile = path20.join(githubAgentsDir, `${chatId}.md`);
+    try {
+      await copyFile(promptFile, agentFile);
+    } catch (error) {
+      console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
+      return 1;
+    }
+  }
+  return 0;
+}
+
+// src/evaluation/providers/vscode/dispatch/agentDispatch.ts
+function generateTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+}
+async function resolvePromptFile(promptFile) {
+  if (!promptFile) {
+    return void 0;
+  }
+  const resolvedPrompt = path21.resolve(promptFile);
+  if (!await pathExists(resolvedPrompt)) {
+    throw new Error(`Prompt file not found: ${resolvedPrompt}`);
+  }
+  const promptStats = await stat3(resolvedPrompt);
+  if (!promptStats.isFile()) {
+    throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
+  }
+  return resolvedPrompt;
+}
+async function resolveAttachments(extraAttachments) {
+  if (!extraAttachments) {
+    return [];
+  }
+  const resolved = [];
+  for (const attachment of extraAttachments) {
+    const resolvedPath = path21.resolve(attachment);
+    if (!await pathExists(resolvedPath)) {
+      throw new Error(`Attachment not found: ${resolvedPath}`);
+    }
+    resolved.push(resolvedPath);
+  }
+  return resolved;
+}
+async function dispatchAgentSession(options) {
+  const {
+    userQuery,
+    promptFile,
+    requestTemplate,
+    extraAttachments,
+    workspaceTemplate,
+    dryRun = false,
+    wait = true,
+    vscodeCmd = "code",
+    subagentRoot,
+    silent = false
+  } = options;
+  try {
+    let resolvedPrompt;
+    try {
+      resolvedPrompt = await resolvePromptFile(promptFile);
+    } catch (error) {
+      return {
+        exitCode: 1,
+        error: error.message
+      };
+    }
+    const templateContent = requestTemplate ?? loadDefaultRequestTemplate();
+    const subagentRootPath = subagentRoot ?? getSubagentRoot(vscodeCmd);
+    const subagentDir = await findUnlockedSubagent(subagentRootPath);
+    if (!subagentDir) {
+      return {
+        exitCode: 1,
+        error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
+      };
+    }
+    const subagentName = path21.basename(subagentDir);
+    const chatId = Math.random().toString(16).slice(2, 10);
+    const preparationResult = await prepareSubagentDirectory(
+      subagentDir,
+      resolvedPrompt,
+      chatId,
+      workspaceTemplate,
+      dryRun
+    );
+    if (preparationResult !== 0) {
+      return {
+        exitCode: preparationResult,
+        subagentName,
+        error: "Failed to prepare subagent workspace"
+      };
+    }
+    let attachments;
+    try {
+      attachments = await resolveAttachments(extraAttachments);
+    } catch (attachmentError) {
+      return {
+        exitCode: 1,
+        subagentName,
+        error: attachmentError.message
+      };
+    }
+    const timestamp = generateTimestamp();
+    const messagesDir = path21.join(subagentDir, "messages");
+    const responseFileTmp = path21.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path21.join(messagesDir, `${timestamp}_res.md`);
+    const requestInstructions = createRequestPrompt(
+      userQuery,
+      responseFileTmp,
+      responseFileFinal,
+      templateContent
+    );
+    if (dryRun) {
+      return {
+        exitCode: 0,
+        subagentName,
+        responseFile: responseFileFinal,
+        tempFile: responseFileTmp
+      };
+    }
+    const launchSuccess = await launchVsCodeWithChat(
+      subagentDir,
+      chatId,
+      attachments,
+      requestInstructions,
+      timestamp,
+      vscodeCmd
+    );
+    if (!launchSuccess) {
+      return {
+        exitCode: 1,
+        subagentName,
+        responseFile: responseFileFinal,
+        tempFile: responseFileTmp,
+        error: "Failed to launch VS Code for subagent session"
+      };
+    }
+    if (!wait) {
+      return {
+        exitCode: 0,
+        subagentName,
+        responseFile: responseFileFinal,
+        tempFile: responseFileTmp
+      };
+    }
+    const received = await waitForResponseOutput(responseFileFinal, 1e3, silent);
+    if (!received) {
+      return {
+        exitCode: 1,
+        subagentName,
+        responseFile: responseFileFinal,
+        tempFile: responseFileTmp,
+        error: "Timed out waiting for agent response"
+      };
+    }
+    await removeSubagentLock(subagentDir);
+    return {
+      exitCode: 0,
+      subagentName,
+      responseFile: responseFileFinal,
+      tempFile: responseFileTmp
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      error: error.message
+    };
+  }
+}
+async function dispatchBatchAgent(options) {
+  const {
+    userQueries,
+    promptFile,
+    requestTemplate,
+    extraAttachments,
+    workspaceTemplate,
+    dryRun = false,
+    wait = false,
+    vscodeCmd = "code",
+    subagentRoot,
+    silent = false
+  } = options;
+  if (!userQueries || userQueries.length === 0) {
+    return {
+      exitCode: 1,
+      requestFiles: [],
+      queryCount: 0,
+      error: "At least one query is required for batch dispatch"
+    };
+  }
+  const queryCount = userQueries.length;
+  let requestFiles = [];
+  let responseFilesFinal = [];
+  let subagentName;
+  try {
+    let resolvedPrompt;
+    try {
+      resolvedPrompt = await resolvePromptFile(promptFile);
+    } catch (error) {
+      return {
+        exitCode: 1,
+        requestFiles,
+        queryCount,
+        error: error.message
+      };
+    }
+    const batchRequestTemplateContent = requestTemplate ?? loadDefaultBatchRequestTemplate();
+    const orchestratorTemplateContent = loadDefaultBatchOrchestratorTemplate();
+    const subagentRootPath = subagentRoot ?? getSubagentRoot(vscodeCmd);
+    const subagentDir = await findUnlockedSubagent(subagentRootPath);
+    if (!subagentDir) {
+      return {
+        exitCode: 1,
+        requestFiles,
+        queryCount,
+        error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
+      };
+    }
+    subagentName = path21.basename(subagentDir);
+    const chatId = Math.random().toString(16).slice(2, 10);
+    const preparationResult = await prepareSubagentDirectory(
+      subagentDir,
+      resolvedPrompt,
+      chatId,
+      workspaceTemplate,
+      dryRun
+    );
+    if (preparationResult !== 0) {
+      return {
+        exitCode: preparationResult,
+        subagentName,
+        requestFiles,
+        queryCount,
+        error: "Failed to prepare subagent workspace"
+      };
+    }
+    let attachments;
+    try {
+      attachments = await resolveAttachments(extraAttachments);
+    } catch (attachmentError) {
+      return {
+        exitCode: 1,
+        subagentName,
+        requestFiles,
+        queryCount,
+        error: attachmentError.message
+      };
+    }
+    const timestamp = generateTimestamp();
+    const messagesDir = path21.join(subagentDir, "messages");
+    requestFiles = userQueries.map(
+      (_, index) => path21.join(messagesDir, `${timestamp}_${index}_req.md`)
+    );
+    const responseTmpFiles = userQueries.map(
+      (_, index) => path21.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+    );
+    responseFilesFinal = userQueries.map(
+      (_, index) => path21.join(messagesDir, `${timestamp}_${index}_res.md`)
+    );
+    const orchestratorFile = path21.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 writeFile6(
+            reqFile,
+            createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
+            { encoding: "utf8" }
+          );
+        })
+      );
+      const orchestratorContent = createBatchOrchestratorPrompt(
+        requestFiles,
+        responseFilesFinal,
+        orchestratorTemplateContent
+      );
+      await writeFile6(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+    }
+    const chatAttachments = [orchestratorFile, ...attachments];
+    const orchestratorUri = pathToFileUri2(orchestratorFile);
+    const chatInstruction = `Follow instructions in [${timestamp}_orchestrator.md](${orchestratorUri}). Use #runSubagent tool.`;
+    if (dryRun) {
+      return {
+        exitCode: 0,
+        subagentName,
+        requestFiles,
+        responseFiles: wait ? responseFilesFinal : void 0,
+        queryCount
+      };
+    }
+    const launchSuccess = await launchVsCodeWithBatchChat(
+      subagentDir,
+      chatId,
+      chatAttachments,
+      chatInstruction,
+      vscodeCmd
+    );
+    if (!launchSuccess) {
+      return {
+        exitCode: 1,
+        subagentName,
+        requestFiles,
+        queryCount,
+        error: "Failed to launch VS Code for batch dispatch"
+      };
+    }
+    if (!wait) {
+      return {
+        exitCode: 0,
+        subagentName,
+        requestFiles,
+        queryCount
+      };
+    }
+    const responsesCompleted = await waitForBatchResponses(responseFilesFinal, 1e3, silent);
+    if (!responsesCompleted) {
+      return {
+        exitCode: 1,
+        subagentName,
+        requestFiles,
+        responseFiles: responseFilesFinal,
+        queryCount,
+        error: "Timed out waiting for batch responses"
+      };
+    }
+    await removeSubagentLock(subagentDir);
+    return {
+      exitCode: 0,
+      subagentName,
+      requestFiles,
+      responseFiles: responseFilesFinal,
+      queryCount
+    };
+  } catch (error) {
+    return {
+      exitCode: 1,
+      subagentName,
+      requestFiles,
+      responseFiles: responseFilesFinal.length > 0 ? responseFilesFinal : void 0,
+      queryCount,
+      error: error.message
+    };
+  }
+}
+
+// src/evaluation/providers/vscode/dispatch/provision.ts
+import { writeFile as writeFile7 } from "node:fs/promises";
+import path22 from "node:path";
+var DEFAULT_WORKSPACE_TEMPLATE2 = {
+  folders: [
+    {
+      path: "."
+    }
+  ],
+  settings: {
+    "chat.modeFilesLocations": {
+      ".github/agents/**/*.md": true
+    }
+  }
+};
+var DEFAULT_WAKEUP_CONTENT2 = `---
+description: 'Wake-up Signal'
+tools: ['edit', 'runNotebooks', 'search', 'new', 'runCommands', 'runTasks', 'usages', 'vscodeAPI', 'problems', 'changes', 'testFailure', 'openSimpleBrowser', 'fetch', 'githubRepo']
+model: GPT-4.1 (copilot)
+---`;
+async function provisionSubagents(options) {
+  const {
+    targetRoot,
+    subagents,
+    lockName = DEFAULT_LOCK_NAME,
+    force = false,
+    dryRun = false,
+    workspaceTemplate = DEFAULT_WORKSPACE_TEMPLATE2,
+    wakeupContent = DEFAULT_WAKEUP_CONTENT2
+  } = options;
+  if (!Number.isInteger(subagents) || subagents < 1) {
+    throw new Error("subagents must be a positive integer");
+  }
+  const targetPath = path22.resolve(targetRoot);
+  if (!dryRun) {
+    await ensureDir(targetPath);
+  }
+  let highestNumber = 0;
+  const lockedSubagents = /* @__PURE__ */ new Set();
+  const existingSubagents = [];
+  if (await pathExists(targetPath)) {
+    const entries = await readDirEntries(targetPath);
+    for (const entry of entries) {
+      if (!entry.isDirectory || !entry.name.startsWith("subagent-")) {
+        continue;
+      }
+      const suffix = entry.name.split("-")[1];
+      if (!suffix) continue;
+      const parsed = Number.parseInt(suffix, 10);
+      if (!Number.isInteger(parsed)) {
+        continue;
+      }
+      highestNumber = Math.max(highestNumber, parsed);
+      const lockFile = path22.join(entry.absolutePath, lockName);
+      const locked = await pathExists(lockFile);
+      if (locked) {
+        lockedSubagents.add(entry.absolutePath);
+      }
+      existingSubagents.push({ number: parsed, absolutePath: entry.absolutePath });
+    }
+    existingSubagents.sort((a, b) => a.number - b.number);
+  }
+  const created = [];
+  const skippedExisting = [];
+  let subagentsProvisioned = 0;
+  for (const subagent of existingSubagents) {
+    if (subagentsProvisioned >= subagents) {
+      break;
+    }
+    const subagentDir = subagent.absolutePath;
+    const githubAgentsDir = path22.join(subagentDir, ".github", "agents");
+    const lockFile = path22.join(subagentDir, lockName);
+    const workspaceDst = path22.join(subagentDir, `${path22.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path22.join(githubAgentsDir, "wakeup.md");
+    const isLocked = await pathExists(lockFile);
+    if (isLocked && !force) {
+      continue;
+    }
+    if (isLocked && force) {
+      if (!dryRun) {
+        await removeIfExists(lockFile);
+        await ensureDir(githubAgentsDir);
+        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile7(wakeupDst, wakeupContent, "utf8");
+      }
+      created.push(subagentDir);
+      lockedSubagents.delete(subagentDir);
+      subagentsProvisioned += 1;
+      continue;
+    }
+    if (!isLocked && force) {
+      if (!dryRun) {
+        await ensureDir(githubAgentsDir);
+        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile7(wakeupDst, wakeupContent, "utf8");
+      }
+      created.push(subagentDir);
+      subagentsProvisioned += 1;
+      continue;
+    }
+    if (!dryRun && !await pathExists(workspaceDst)) {
+      await ensureDir(githubAgentsDir);
+      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile7(wakeupDst, wakeupContent, "utf8");
+    }
+    skippedExisting.push(subagentDir);
+    subagentsProvisioned += 1;
+  }
+  let nextIndex = highestNumber;
+  while (subagentsProvisioned < subagents) {
+    nextIndex += 1;
+    const subagentDir = path22.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path22.join(subagentDir, ".github", "agents");
+    const workspaceDst = path22.join(subagentDir, `${path22.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path22.join(githubAgentsDir, "wakeup.md");
+    if (!dryRun) {
+      await ensureDir(subagentDir);
+      await ensureDir(githubAgentsDir);
+      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile7(wakeupDst, wakeupContent, "utf8");
+    }
+    created.push(subagentDir);
+    subagentsProvisioned += 1;
+  }
+  return {
+    created,
+    skippedExisting,
+    skippedLocked: Array.from(lockedSubagents).sort()
+  };
+}
 
 // src/evaluation/providers/vscode-templates.ts
 var AGENTV_REQUEST_TEMPLATE = `[[ ## task ## ]]
@@ -5440,7 +6463,7 @@ var AGENTV_BATCH_REQUEST_TEMPLATE = `[[ ## task ## ]]
 3. Do not unlock the workspace from this request; batch orchestration will handle unlocking after all responses are ready.
 `;
 
-// src/evaluation/providers/vscode.ts
+// src/evaluation/providers/vscode-provider.ts
 var VSCodeProvider = class {
   id;
   kind;
@@ -5572,8 +6595,8 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path13.basename(absolutePath);
-    const fileUri = pathToFileUri2(absolutePath);
+    const fileName = path23.basename(absolutePath);
+    const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
   const sections = [];
@@ -5597,8 +6620,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path13.resolve(attachment);
-    const normalized = absolutePath.split(path13.sep).join("/");
+    const absolutePath = path23.resolve(attachment);
+    const normalized = absolutePath.split(path23.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -5613,15 +6636,15 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path13.resolve(attachment);
+    const absolutePath = path23.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
   }
   return Array.from(unique.values());
 }
-function pathToFileUri2(filePath) {
-  const absolutePath = path13.isAbsolute(filePath) ? filePath : path13.resolve(filePath);
+function pathToFileUri3(filePath) {
+  const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -5634,7 +6657,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path13.resolve(attachment));
+    deduped.add(path23.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -5643,7 +6666,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path13.resolve(inputFile));
+      deduped.add(path23.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -5690,9 +6713,9 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 }
 
 // src/evaluation/providers/targets-file.ts
-import { constants as constants3 } from "node:fs";
-import { access as access3, readFile as readFile7 } from "node:fs/promises";
-import path14 from "node:path";
+import { constants as constants4 } from "node:fs";
+import { access as access4, readFile as readFile9 } from "node:fs/promises";
+import path24 from "node:path";
 import { parse as parse3 } from "yaml";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -5722,18 +6745,18 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await access3(filePath, constants3.F_OK);
+    await access4(filePath, constants4.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path14.resolve(filePath);
+  const absolutePath = path24.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile7(absolutePath, "utf8");
+  const raw = await readFile9(absolutePath, "utf8");
   const parsed = parse3(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -5897,10 +6920,10 @@ async function execFileWithStdinBun(argv, stdinPayload, options) {
   }
 }
 async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn4 } = await import("node:child_process");
+  const { spawn: spawn5 } = await import("node:child_process");
   return new Promise((resolve, reject) => {
     const [cmd, ...args] = argv;
-    const child = spawn4(cmd, args, {
+    const child = spawn5(cmd, args, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       // Merge additional env vars with process.env
@@ -5940,21 +6963,21 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir4, readFile: readFile8, rm: rm4, writeFile: writeFile4 } = await import("node:fs/promises");
+  const { mkdir: mkdir8, readFile: readFile10, rm: rm5, writeFile: writeFile8 } = await import("node:fs/promises");
   const { tmpdir: tmpdir4 } = await import("node:os");
-  const path16 = await import("node:path");
+  const path26 = await import("node:path");
   const { randomUUID: randomUUID4 } = await import("node:crypto");
-  const dir = path16.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
-  await mkdir4(dir, { recursive: true });
-  const stdinPath = path16.join(dir, "stdin.txt");
-  const stdoutPath = path16.join(dir, "stdout.txt");
-  const stderrPath = path16.join(dir, "stderr.txt");
-  await writeFile4(stdinPath, stdinPayload, "utf8");
+  const dir = path26.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
+  await mkdir8(dir, { recursive: true });
+  const stdinPath = path26.join(dir, "stdin.txt");
+  const stdoutPath = path26.join(dir, "stdout.txt");
+  const stderrPath = path26.join(dir, "stderr.txt");
+  await writeFile8(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
-  const { spawn: spawn4 } = await import("node:child_process");
+  const { spawn: spawn5 } = await import("node:child_process");
   try {
     const exitCode = await new Promise((resolve, reject) => {
-      const child = spawn4(wrappedCommand, {
+      const child = spawn5(wrappedCommand, {
         shell: true,
         cwd: options.cwd,
         stdio: ["ignore", "ignore", "ignore"],
@@ -5978,11 +7001,11 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile8(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile8(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile10(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile10(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
-    await rm4(dir, { recursive: true, force: true });
+    await rm5(dir, { recursive: true, force: true });
   }
 }
 
@@ -6251,7 +7274,7 @@ var CodeEvaluator = class {
       outputMessages: context.outputMessages ?? null,
       guidelineFiles: context.evalCase.guideline_paths,
       inputFiles: context.evalCase.file_paths.filter(
-        (path16) => !context.evalCase.guideline_paths.includes(path16)
+        (path26) => !context.evalCase.guideline_paths.includes(path26)
       ),
       inputMessages: context.evalCase.input_messages,
       traceSummary: context.traceSummary ?? null,
@@ -7171,115 +8194,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path16, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path16);
-    const expectedValue = resolvePath(expectedData, path16);
+    const { path: path26, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path26);
+    const expectedValue = resolvePath(expectedData, path26);
     if (expectedValue === void 0) {
       return {
-        path: path16,
+        path: path26,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path16}: no expected value`
+        message: `${path26}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path16,
+          path: path26,
           score: 0,
           weight,
           hit: false,
-          message: `${path16} (required, missing)`
+          message: `${path26} (required, missing)`
         };
       }
       return {
-        path: path16,
+        path: path26,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path16}: optional field missing`
+        message: `${path26}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path16, candidateValue, expectedValue, weight);
+        return this.compareExact(path26, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path16,
+          path26,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path16, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path26, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path16,
+          path: path26,
           score: 0,
           weight,
           hit: false,
-          message: `${path16}: unknown match type "${match}"`
+          message: `${path26}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path16, candidateValue, expectedValue, weight) {
+  compareExact(path26, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path16,
+        path: path26,
         score: 1,
         weight,
         hit: true,
-        message: path16
+        message: path26
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path16,
+        path: path26,
         score: 0,
         weight,
         hit: false,
-        message: `${path16} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path26} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path16,
+      path: path26,
       score: 0,
       weight,
       hit: false,
-      message: `${path16} (value mismatch)`
+      message: `${path26} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path16, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path26, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path16,
+        path: path26,
         score: 0,
         weight,
         hit: false,
-        message: `${path16} (non-numeric value)`
+        message: `${path26} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path16,
+        path: path26,
         score: 0,
         weight,
         hit: false,
-        message: `${path16} (invalid numeric value)`
+        message: `${path26} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -7292,61 +8315,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path16,
+        path: path26,
         score: 1,
         weight,
         hit: true,
-        message: `${path16} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path26} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path16,
+      path: path26,
       score: 0,
       weight,
       hit: false,
-      message: `${path16} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path26} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path16, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path26, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path16,
+        path: path26,
         score: 0,
         weight,
         hit: false,
-        message: `${path16} (unparseable candidate date)`
+        message: `${path26} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path16,
+        path: path26,
         score: 0,
         weight,
         hit: false,
-        message: `${path16} (unparseable expected date)`
+        message: `${path26} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path16,
+        path: path26,
         score: 1,
         weight,
         hit: true,
-        message: path16
+        message: path26
       };
     }
     return {
-      path: path16,
+      path: path26,
       score: 0,
       weight,
       hit: false,
-      message: `${path16} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path26} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -7386,11 +8409,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path16) {
-  if (!path16 || !obj) {
+function resolvePath(obj, path26) {
+  if (!path26 || !obj) {
     return void 0;
   }
-  const parts = path16.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path26.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -7910,7 +8933,7 @@ var ToolTrajectoryEvaluator = class {
 
 // src/evaluation/orchestrator.ts
 import { createHash } from "node:crypto";
-import path15 from "node:path";
+import path25 from "node:path";
 import micromatch4 from "micromatch";
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -8713,7 +9736,7 @@ async function runEvaluatorList(options) {
         });
       }
       if (evaluator.type === "composite") {
-        const evalFileDir = evalCase.guideline_paths[0] ? path15.dirname(evalCase.guideline_paths[0]) : process.cwd();
+        const evalFileDir = evalCase.guideline_paths[0] ? path25.dirname(evalCase.guideline_paths[0]) : process.cwd();
         const createEvaluator = (memberConfig) => {
           switch (memberConfig.type) {
             case "llm_judge":
@@ -9069,7 +10092,7 @@ async function executePromptTemplate(script, context, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path15.dirname(scriptPath);
+  const cwd = path25.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();