@agentv/core 2.5.3 → 2.5.5

package/dist/index.cjs

@@ -1068,12 +1068,13 @@ function parseRubricItems(rawRubrics, evaluatorName, evalId) {
     let scoreRanges;
     const rawScoreRanges = rawRubric.score_ranges;
     if (rawScoreRanges !== void 0) {
-      if (!Array.isArray(rawScoreRanges)) {
+      const normalized = normalizeScoreRangesShorthand(rawScoreRanges);
+      if (!Array.isArray(normalized)) {
         throw new Error(
-          `Invalid score_ranges for rubric '${id}' in evaluator '${evaluatorName}' in '${evalId}': must be an array`
+          `Invalid score_ranges for rubric '${id}' in evaluator '${evaluatorName}' in '${evalId}': must be an array or shorthand map`
         );
       }
-      scoreRanges = parseScoreRanges(rawScoreRanges, id, evaluatorName, evalId);
+      scoreRanges = parseScoreRanges(normalized, id, evaluatorName, evalId);
       items.push({
         id,
         weight,
@@ -1101,6 +1102,37 @@ function parseRubricItems(rawRubrics, evaluatorName, evalId) {
   }
   return items.length > 0 ? items : void 0;
 }
+function normalizeScoreRangesShorthand(raw) {
+  if (Array.isArray(raw)) return raw;
+  if (!isJsonObject2(raw)) return raw;
+  const keys = Object.keys(raw);
+  if (keys.length === 0) return raw;
+  const numericKeys = [];
+  for (const key of keys) {
+    const num = Number(key);
+    if (!Number.isInteger(num) || num < 0 || num > 10) {
+      return raw;
+    }
+    if (typeof raw[key] !== "string" || raw[key].length === 0) {
+      return raw;
+    }
+    numericKeys.push(num);
+  }
+  numericKeys.sort((a, b) => a - b);
+  if (numericKeys[0] !== 0) {
+    throw new Error(`score_ranges shorthand map must start at 0 (got ${numericKeys[0]})`);
+  }
+  const result = [];
+  for (let i = 0; i < numericKeys.length; i++) {
+    const min = numericKeys[i];
+    const max = i < numericKeys.length - 1 ? numericKeys[i + 1] - 1 : 10;
+    result.push({
+      score_range: [min, max],
+      expected_outcome: raw[String(min)]
+    });
+  }
+  return result;
+}
 function parseScoreRanges(rawRanges, rubricId, evaluatorName, evalId) {
   const ranges = [];
   for (const [index, rawRange] of rawRanges.entries()) {
@@ -1183,7 +1215,8 @@ function parseInlineRubrics(rawRubrics) {
     }
     const expectedOutcome = asString(rubric.expected_outcome) ?? asString(rubric.description) ?? "";
     const rawScoreRanges = rubric.score_ranges;
-    const scoreRanges = Array.isArray(rawScoreRanges) && rawScoreRanges.length > 0 ? rawScoreRanges.filter((r) => isJsonObject2(r)).map((range) => ({
+    const normalizedScoreRanges = rawScoreRanges !== void 0 ? normalizeScoreRangesShorthand(rawScoreRanges) : void 0;
+    const scoreRanges = Array.isArray(normalizedScoreRanges) && normalizedScoreRanges.length > 0 ? normalizedScoreRanges.filter((r) => isJsonObject2(r)).map((range) => ({
       score_range: Array.isArray(range.score_range) ? range.score_range : [0, 10],
       expected_outcome: asString(range.expected_outcome) ?? asString(range.description) ?? ""
     })).filter((r) => r.expected_outcome.length > 0) : void 0;
@@ -3377,16 +3410,16 @@ async function runClaudeCodeWithTempFiles(options, stdoutFile, stderrFile, exitF
   let lastStdoutSize = 0;
   const readFileIfExists = async (filePath) => {
     try {
-      const { readFile: readFile9 } = await import("fs/promises");
-      return await readFile9(filePath, "utf8");
+      const { readFile: readFile11 } = await import("fs/promises");
+      return await readFile11(filePath, "utf8");
     } catch {
       return "";
     }
   };
   const fileExists4 = async (filePath) => {
     try {
-      const { access: access5 } = await import("fs/promises");
-      await access5(filePath);
+      const { access: access6 } = await import("fs/promises");
+      await access6(filePath);
       return true;
     } catch {
       return false;
@@ -6239,8 +6272,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path18 = firstError?.path.join(".") || "";
-    const prefix = path18 ? `${target.name} ${path18}: ` : `${target.name}: `;
+    const path28 = firstError?.path.join(".") || "";
+    const prefix = path28 ? `${target.name} ${path28}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -6427,9 +6460,1037 @@ function resolveOptionalNumberArray(source, description) {
   return resolved.length > 0 ? resolved : void 0;
 }
 
-// src/evaluation/providers/vscode.ts
+// src/evaluation/providers/vscode-provider.ts
+var import_node_path25 = __toESM(require("path"), 1);
+
+// src/evaluation/providers/vscode/dispatch/agentDispatch.ts
+var import_promises17 = require("fs/promises");
+var import_node_path23 = __toESM(require("path"), 1);
+
+// src/evaluation/providers/vscode/utils/fs.ts
+var import_node_fs6 = require("fs");
+var import_promises13 = require("fs/promises");
 var import_node_path15 = __toESM(require("path"), 1);
-var import_subagent = require("subagent");
+async function pathExists(target) {
+  try {
+    await (0, import_promises13.access)(target, import_node_fs6.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(target) {
+  await (0, import_promises13.mkdir)(target, { recursive: true });
+}
+async function readDirEntries(target) {
+  const entries = await (0, import_promises13.readdir)(target, { withFileTypes: true });
+  return entries.map((entry) => ({
+    name: entry.name,
+    absolutePath: import_node_path15.default.join(target, entry.name),
+    isDirectory: entry.isDirectory()
+  }));
+}
+async function removeIfExists(target) {
+  try {
+    await (0, import_promises13.rm)(target, { force: true, recursive: false });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+
+// src/evaluation/providers/vscode/utils/path.ts
+var import_node_path16 = __toESM(require("path"), 1);
+function pathToFileUri2(filePath) {
+  const absolutePath = import_node_path16.default.isAbsolute(filePath) ? filePath : import_node_path16.default.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
+var import_node_path17 = __toESM(require("path"), 1);
+
+// 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/${import_node_path17.default.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${import_node_path17.default.basename(file)}"`).join(", ");
+  return renderTemplate2(templateContent, {
+    requestFiles: requestLines,
+    responseList
+  });
+}
+
+// src/evaluation/providers/vscode/dispatch/responseWaiter.ts
+var import_promises14 = require("fs/promises");
+var import_node_path18 = __toESM(require("path"), 1);
+
+// 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 (0, import_promises14.readFile)(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) => import_node_path18.default.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 (0, import_promises14.readFile)(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
+var import_node_child_process5 = require("child_process");
+var import_promises15 = require("fs/promises");
+var import_node_path20 = __toESM(require("path"), 1);
+var import_node_util3 = require("util");
+
+// src/evaluation/providers/vscode/dispatch/constants.ts
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_path19 = __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_path19.default.join(import_node_os5.default.homedir(), ".agentv", "subagents", folder);
+}
+var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
+
+// src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
+var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process5.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) {
+    (0, import_node_child_process5.spawn)(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+    return true;
+  }
+  const aliveFile = import_node_path20.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  await removeIfExists(aliveFile);
+  const githubAgentsDir = import_node_path20.default.join(subagentDir, ".github", "agents");
+  await (0, import_promises15.mkdir)(githubAgentsDir, { recursive: true });
+  const wakeupDst = import_node_path20.default.join(githubAgentsDir, "wakeup.md");
+  await (0, import_promises15.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  (0, import_node_child_process5.spawn)(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 ${import_node_path20.default.basename(subagentDir)} folder`
+  ];
+  (0, import_node_child_process5.spawn)(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 = import_node_path20.default.join(subagentDir, `${import_node_path20.default.basename(subagentDir)}.code-workspace`);
+    const messagesDir = import_node_path20.default.join(subagentDir, "messages");
+    await (0, import_promises15.mkdir)(messagesDir, { recursive: true });
+    const reqFile = import_node_path20.default.join(messagesDir, `${timestamp}_req.md`);
+    await (0, import_promises15.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_path20.default.basename(reqFile)}](${reqUri})`);
+    const workspaceReady = await ensureWorkspaceFocused(
+      workspacePath,
+      import_node_path20.default.basename(subagentDir),
+      subagentDir,
+      vscodeCmd
+    );
+    if (!workspaceReady) {
+      console.error("warning: Workspace may not be fully ready");
+    }
+    await sleep2(500);
+    (0, import_node_child_process5.spawn)(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 = import_node_path20.default.join(subagentDir, `${import_node_path20.default.basename(subagentDir)}.code-workspace`);
+    const messagesDir = import_node_path20.default.join(subagentDir, "messages");
+    await (0, import_promises15.mkdir)(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,
+      import_node_path20.default.basename(subagentDir),
+      subagentDir,
+      vscodeCmd
+    );
+    if (!workspaceReady) {
+      console.error("warning: Workspace may not be fully ready");
+    }
+    await sleep2(500);
+    (0, import_node_child_process5.spawn)(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
+var import_promises16 = require("fs/promises");
+var import_node_path22 = __toESM(require("path"), 1);
+
+// src/evaluation/providers/vscode/utils/workspace.ts
+var import_node_path21 = __toESM(require("path"), 1);
+var import_json5 = __toESM(require("json5"), 1);
+function transformWorkspacePaths(workspaceContent, templateDir) {
+  let workspace;
+  try {
+    workspace = import_json5.default.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 (import_node_path21.default.isAbsolute(folderPath)) {
+      return folder;
+    }
+    const absolutePath = import_node_path21.default.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 = import_node_path21.default.isAbsolute(locationPath);
+          if (isAbsolute) {
+            transformedMap[locationPath] = value;
+          } else {
+            const firstGlobIndex = locationPath.search(/[*]/);
+            if (firstGlobIndex === -1) {
+              const resolvedPath = import_node_path21.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_path21.default.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 = import_node_path22.default.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 = import_node_path22.default.resolve(workspaceTemplate);
+    if (!await pathExists(workspaceSrc)) {
+      throw new Error(`workspace template not found: ${workspaceSrc}`);
+    }
+    const stats = await (0, import_promises16.stat)(workspaceSrc);
+    if (!stats.isFile()) {
+      throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
+    }
+    const templateText = await (0, import_promises16.readFile)(workspaceSrc, "utf8");
+    workspaceContent = JSON.parse(templateText);
+  } else {
+    workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
+  }
+  const workspaceName = `${import_node_path22.default.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = import_node_path22.default.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? import_node_path22.default.dirname(import_node_path22.default.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceJson = JSON.stringify(workspaceContent, null, 2);
+  const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
+  await (0, import_promises16.writeFile)(workspaceDst, transformedContent, "utf8");
+  const messagesDir = import_node_path22.default.join(subagentDir, "messages");
+  await (0, import_promises16.mkdir)(messagesDir, { recursive: true });
+  return { workspace: workspaceDst, messagesDir };
+}
+async function createSubagentLock(subagentDir) {
+  const messagesDir = import_node_path22.default.join(subagentDir, "messages");
+  if (await pathExists(messagesDir)) {
+    const files = await (0, import_promises16.readdir)(messagesDir);
+    await Promise.all(
+      files.map(async (file) => {
+        const target = import_node_path22.default.join(messagesDir, file);
+        await removeIfExists(target);
+      })
+    );
+  }
+  const githubAgentsDir = import_node_path22.default.join(subagentDir, ".github", "agents");
+  if (await pathExists(githubAgentsDir)) {
+    const agentFiles = await (0, import_promises16.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_path22.default.join(githubAgentsDir, file)))
+    );
+  }
+  const lockFile = import_node_path22.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  await (0, import_promises16.writeFile)(lockFile, "", { encoding: "utf8" });
+  return lockFile;
+}
+async function removeSubagentLock(subagentDir) {
+  const lockFile = import_node_path22.default.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 = import_node_path22.default.join(subagentDir, ".github", "agents");
+    await (0, import_promises16.mkdir)(githubAgentsDir, { recursive: true });
+    const agentFile = import_node_path22.default.join(githubAgentsDir, `${chatId}.md`);
+    try {
+      await (0, import_promises16.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 = import_node_path23.default.resolve(promptFile);
+  if (!await pathExists(resolvedPrompt)) {
+    throw new Error(`Prompt file not found: ${resolvedPrompt}`);
+  }
+  const promptStats = await (0, import_promises17.stat)(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 = import_node_path23.default.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 = import_node_path23.default.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 = import_node_path23.default.join(subagentDir, "messages");
+    const responseFileTmp = import_node_path23.default.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = import_node_path23.default.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 = import_node_path23.default.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 = import_node_path23.default.join(subagentDir, "messages");
+    requestFiles = userQueries.map(
+      (_, index) => import_node_path23.default.join(messagesDir, `${timestamp}_${index}_req.md`)
+    );
+    const responseTmpFiles = userQueries.map(
+      (_, index) => import_node_path23.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+    );
+    responseFilesFinal = userQueries.map(
+      (_, index) => import_node_path23.default.join(messagesDir, `${timestamp}_${index}_res.md`)
+    );
+    const orchestratorFile = import_node_path23.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_promises17.writeFile)(
+            reqFile,
+            createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
+            { encoding: "utf8" }
+          );
+        })
+      );
+      const orchestratorContent = createBatchOrchestratorPrompt(
+        requestFiles,
+        responseFilesFinal,
+        orchestratorTemplateContent
+      );
+      await (0, import_promises17.writeFile)(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
+var import_promises18 = require("fs/promises");
+var import_node_path24 = __toESM(require("path"), 1);
+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 = import_node_path24.default.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 = import_node_path24.default.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 = import_node_path24.default.join(subagentDir, ".github", "agents");
+    const lockFile = import_node_path24.default.join(subagentDir, lockName);
+    const workspaceDst = import_node_path24.default.join(subagentDir, `${import_node_path24.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path24.default.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 (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+      }
+      created.push(subagentDir);
+      lockedSubagents.delete(subagentDir);
+      subagentsProvisioned += 1;
+      continue;
+    }
+    if (!isLocked && force) {
+      if (!dryRun) {
+        await ensureDir(githubAgentsDir);
+        await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+      }
+      created.push(subagentDir);
+      subagentsProvisioned += 1;
+      continue;
+    }
+    if (!dryRun && !await pathExists(workspaceDst)) {
+      await ensureDir(githubAgentsDir);
+      await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+    }
+    skippedExisting.push(subagentDir);
+    subagentsProvisioned += 1;
+  }
+  let nextIndex = highestNumber;
+  while (subagentsProvisioned < subagents) {
+    nextIndex += 1;
+    const subagentDir = import_node_path24.default.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = import_node_path24.default.join(subagentDir, ".github", "agents");
+    const workspaceDst = import_node_path24.default.join(subagentDir, `${import_node_path24.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path24.default.join(githubAgentsDir, "wakeup.md");
+    if (!dryRun) {
+      await ensureDir(subagentDir);
+      await ensureDir(githubAgentsDir);
+      await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises18.writeFile)(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 ## ]]
@@ -6466,7 +7527,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;
@@ -6485,7 +7546,7 @@ var VSCodeProvider = class {
     }
     const inputFiles = normalizeAttachments(request.inputFiles);
     const promptContent = buildPromptDocument2(request, inputFiles, request.guideline_patterns);
-    const session = await (0, import_subagent.dispatchAgentSession)({
+    const session = await dispatchAgentSession({
       userQuery: promptContent,
       extraAttachments: inputFiles,
       requestTemplate: AGENTV_REQUEST_TEMPLATE,
@@ -6532,7 +7593,7 @@ var VSCodeProvider = class {
     const userQueries = normalizedRequests.map(
       ({ request, inputFiles }) => buildPromptDocument2(request, inputFiles, request.guideline_patterns)
     );
-    const session = await (0, import_subagent.dispatchBatchAgent)({
+    const session = await dispatchBatchAgent({
       userQueries,
       extraAttachments: combinedInputFiles,
       requestTemplate: AGENTV_BATCH_REQUEST_TEMPLATE,
@@ -6598,8 +7659,8 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path15.default.basename(absolutePath);
-    const fileUri = pathToFileUri2(absolutePath);
+    const fileName = import_node_path25.default.basename(absolutePath);
+    const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
   const sections = [];
@@ -6623,8 +7684,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path15.default.resolve(attachment);
-    const normalized = absolutePath.split(import_node_path15.default.sep).join("/");
+    const absolutePath = import_node_path25.default.resolve(attachment);
+    const normalized = absolutePath.split(import_node_path25.default.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -6639,15 +7700,15 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path15.default.resolve(attachment);
+    const absolutePath = import_node_path25.default.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
   }
   return Array.from(unique.values());
 }
-function pathToFileUri2(filePath) {
-  const absolutePath = import_node_path15.default.isAbsolute(filePath) ? filePath : import_node_path15.default.resolve(filePath);
+function pathToFileUri3(filePath) {
+  const absolutePath = import_node_path25.default.isAbsolute(filePath) ? filePath : import_node_path25.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -6660,7 +7721,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(import_node_path15.default.resolve(attachment));
+    deduped.add(import_node_path25.default.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -6669,7 +7730,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(import_node_path15.default.resolve(inputFile));
+      deduped.add(import_node_path25.default.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -6677,12 +7738,12 @@ function mergeAttachments(all) {
 async function ensureVSCodeSubagents(options) {
   const { kind, count, verbose = false } = options;
   const vscodeCmd = kind === "vscode-insiders" ? "code-insiders" : "code";
-  const subagentRoot = (0, import_subagent.getSubagentRoot)(vscodeCmd);
+  const subagentRoot = getSubagentRoot(vscodeCmd);
   try {
     if (verbose) {
       console.log(`Provisioning ${count} subagent(s) via: subagent ${vscodeCmd} provision`);
     }
-    const result = await (0, import_subagent.provisionSubagents)({
+    const result = await provisionSubagents({
       targetRoot: subagentRoot,
       subagents: count,
       dryRun: false
@@ -6716,9 +7777,9 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 }
 
 // src/evaluation/providers/targets-file.ts
-var import_node_fs6 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+var import_promises19 = require("fs/promises");
+var import_node_path26 = __toESM(require("path"), 1);
 var import_yaml4 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6748,18 +7809,18 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises13.access)(filePath, import_node_fs6.constants.F_OK);
+    await (0, import_promises19.access)(filePath, import_node_fs7.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = import_node_path16.default.resolve(filePath);
+  const absolutePath = import_node_path26.default.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await (0, import_promises13.readFile)(absolutePath, "utf8");
+  const raw = await (0, import_promises19.readFile)(absolutePath, "utf8");
   const parsed = (0, import_yaml4.parse)(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -6923,10 +7984,10 @@ async function execFileWithStdinBun(argv, stdinPayload, options) {
   }
 }
 async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn4 } = await import("child_process");
+  const { spawn: spawn5 } = await import("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
@@ -6966,21 +8027,21 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir4, readFile: readFile9, rm: rm4, writeFile: writeFile4 } = await import("fs/promises");
+  const { mkdir: mkdir8, readFile: readFile11, rm: rm5, writeFile: writeFile8 } = await import("fs/promises");
   const { tmpdir: tmpdir4 } = await import("os");
-  const path18 = await import("path");
+  const path28 = await import("path");
   const { randomUUID: randomUUID4 } = await import("crypto");
-  const dir = path18.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
-  await mkdir4(dir, { recursive: true });
-  const stdinPath = path18.join(dir, "stdin.txt");
-  const stdoutPath = path18.join(dir, "stdout.txt");
-  const stderrPath = path18.join(dir, "stderr.txt");
-  await writeFile4(stdinPath, stdinPayload, "utf8");
+  const dir = path28.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
+  await mkdir8(dir, { recursive: true });
+  const stdinPath = path28.join(dir, "stdin.txt");
+  const stdoutPath = path28.join(dir, "stdout.txt");
+  const stderrPath = path28.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("child_process");
+  const { spawn: spawn5 } = await import("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"],
@@ -7004,11 +8065,11 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve(code ?? 0);
       });
     });
-    const stdout = (await readFile9(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile9(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile11(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile11(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 });
   }
 }
 
@@ -7277,7 +8338,7 @@ var CodeEvaluator = class {
       outputMessages: context.outputMessages ?? null,
       guidelineFiles: context.evalCase.guideline_paths,
       inputFiles: context.evalCase.file_paths.filter(
-        (path18) => !context.evalCase.guideline_paths.includes(path18)
+        (path28) => !context.evalCase.guideline_paths.includes(path28)
       ),
       inputMessages: context.evalCase.input_messages,
       traceSummary: context.traceSummary ?? null,
@@ -8224,115 +9285,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path18, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path18);
-    const expectedValue = resolvePath(expectedData, path18);
+    const { path: path28, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path28);
+    const expectedValue = resolvePath(expectedData, path28);
     if (expectedValue === void 0) {
       return {
-        path: path18,
+        path: path28,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path18}: no expected value`
+        message: `${path28}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path18,
+          path: path28,
           score: 0,
           weight,
           hit: false,
-          message: `${path18} (required, missing)`
+          message: `${path28} (required, missing)`
         };
       }
       return {
-        path: path18,
+        path: path28,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path18}: optional field missing`
+        message: `${path28}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path18, candidateValue, expectedValue, weight);
+        return this.compareExact(path28, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path18,
+          path28,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path18, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path28, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path18,
+          path: path28,
           score: 0,
           weight,
           hit: false,
-          message: `${path18}: unknown match type "${match}"`
+          message: `${path28}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path18, candidateValue, expectedValue, weight) {
+  compareExact(path28, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path18,
+        path: path28,
         score: 1,
         weight,
         hit: true,
-        message: path18
+        message: path28
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path18,
+        path: path28,
         score: 0,
         weight,
         hit: false,
-        message: `${path18} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path28} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path18,
+      path: path28,
       score: 0,
       weight,
       hit: false,
-      message: `${path18} (value mismatch)`
+      message: `${path28} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path18, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path28, 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: path18,
+        path: path28,
         score: 0,
         weight,
         hit: false,
-        message: `${path18} (non-numeric value)`
+        message: `${path28} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path18,
+        path: path28,
         score: 0,
         weight,
         hit: false,
-        message: `${path18} (invalid numeric value)`
+        message: `${path28} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -8345,61 +9406,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path18,
+        path: path28,
         score: 1,
         weight,
         hit: true,
-        message: `${path18} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path28} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path18,
+      path: path28,
       score: 0,
       weight,
       hit: false,
-      message: `${path18} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path28} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path18, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path28, 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: path18,
+        path: path28,
         score: 0,
         weight,
         hit: false,
-        message: `${path18} (unparseable candidate date)`
+        message: `${path28} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path18,
+        path: path28,
         score: 0,
         weight,
         hit: false,
-        message: `${path18} (unparseable expected date)`
+        message: `${path28} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path18,
+        path: path28,
         score: 1,
         weight,
         hit: true,
-        message: path18
+        message: path28
       };
     }
     return {
-      path: path18,
+      path: path28,
       score: 0,
       weight,
       hit: false,
-      message: `${path18} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path28} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -8439,11 +9500,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path18) {
-  if (!path18 || !obj) {
+function resolvePath(obj, path28) {
+  if (!path28 || !obj) {
     return void 0;
   }
-  const parts = path18.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path28.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -8963,7 +10024,7 @@ var ToolTrajectoryEvaluator = class {
 
 // src/evaluation/orchestrator.ts
 var import_node_crypto5 = require("crypto");
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 var import_micromatch4 = __toESM(require("micromatch"), 1);
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -9766,7 +10827,7 @@ async function runEvaluatorList(options) {
         });
       }
       if (evaluator.type === "composite") {
-        const evalFileDir = evalCase.guideline_paths[0] ? import_node_path17.default.dirname(evalCase.guideline_paths[0]) : process.cwd();
+        const evalFileDir = evalCase.guideline_paths[0] ? import_node_path27.default.dirname(evalCase.guideline_paths[0]) : process.cwd();
         const createEvaluator = (memberConfig) => {
           switch (memberConfig.type) {
             case "llm_judge":
@@ -10122,7 +11183,7 @@ async function executePromptTemplate(script, context, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = import_node_path17.default.dirname(scriptPath);
+  const cwd = import_node_path27.default.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();