agentv 0.2.8 → 0.5.0

package/dist/{chunk-RLBRJX7V.js → chunk-THVRLL37.js}

@@ -585,7 +585,7 @@ var require_utc = __commonJS({
 import { Command } from "commander";
 import { readFileSync as readFileSync2 } from "node:fs";
 
-// ../../packages/core/dist/chunk-XXNQA4EW.js
+// ../../packages/core/dist/chunk-NL7K4CAK.js
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
 import path from "node:path";
@@ -692,6 +692,8 @@ var KNOWN_PROVIDERS = [
   "azure",
   "anthropic",
   "gemini",
+  "codex",
+  "cli",
   "mock",
   "vscode",
   "vscode-insiders"
@@ -703,6 +705,8 @@ var PROVIDER_ALIASES = [
   // alias for "gemini"
   "google-gemini",
   // alias for "gemini"
+  "codex-cli",
+  // alias for "codex"
   "openai",
   // legacy/future support
   "bedrock",
@@ -716,7 +720,7 @@ var TARGETS_SCHEMA_V2 = "agentv-targets-v2";
 import micromatch from "micromatch";
 import { constants as constants3 } from "node:fs";
 import { access as access3, readFile as readFile2 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parse3 } from "yaml";
 
@@ -5031,6 +5035,11 @@ var _c = pr();
 var ya = new Error("Agent description must be at least 20 characters (explain in detail what the agent does)");
 var ba = new Error("Agent definition is the prompt you give to the LLM for the agent. It must be detailed and at least 100 characters");
 
+// ../../packages/core/dist/index.js
+import { exec as execWithCallback } from "node:child_process";
+import path22 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -5509,8 +5518,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path17, errorMaps, issueData } = params;
-  const fullPath = [...path17, ...issueData.path || []];
+  const { data, path: path18, errorMaps, issueData } = params;
+  const fullPath = [...path18, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -5626,11 +5635,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path17, key2) {
+  constructor(parent, value, path18, key2) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path17;
+    this._path = path18;
     this._key = key2;
   }
   get path() {
@@ -9074,27 +9083,26 @@ var NEVER = INVALID;
 
 // ../../packages/core/dist/index.js
 import { readFile as readFile22 } from "node:fs/promises";
-import path22 from "node:path";
+import path32 from "node:path";
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/vscode/agentDispatch.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/vscode/agentDispatch.js
 import { exec, spawn } from "child_process";
 import { copyFile, mkdir as mkdir2, readdir as readdir2, readFile, stat as stat2, writeFile } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { promisify } from "util";
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/vscode/constants.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/vscode/constants.js
 import os from "os";
 import path2 from "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 path2.join(os.homedir(), ".subagent", folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
-var DEFAULT_WAKEUP_FILENAME = "wakeup.chatmode.md";
-var DEFAULT_ALIVE_FILENAME = ".alive";
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/utils/fs.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/utils/fs.js
 import { constants as constants2 } from "fs";
 import { access as access2, mkdir, readdir, rm, stat } from "fs/promises";
 import path3 from "path";
@@ -9127,15 +9135,26 @@ async function removeIfExists(target) {
   }
 }
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/utils/time.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/utils/path.js
+import path4 from "path";
+function pathToFileUri(filePath) {
+  const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(filePath);
+  const normalizedPath = absolutePath.replace(/\\/g, "/");
+  if (/^[a-zA-Z]:\//.test(normalizedPath)) {
+    return `file:///${normalizedPath}`;
+  }
+  return `file://${normalizedPath}`;
+}
+
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/utils/time.js
 function sleep(ms2) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms2);
   });
 }
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/utils/workspace.js
-import path4 from "path";
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/utils/workspace.js
+import path5 from "path";
 
 // ../../node_modules/.pnpm/json5@2.2.3/node_modules/json5/dist/index.mjs
 var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
@@ -10222,7 +10241,7 @@ var JSON5 = {
 var lib = JSON5;
 var dist_default = lib;
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/utils/workspace.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/utils/workspace.js
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
   try {
@@ -10238,10 +10257,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path4.isAbsolute(folderPath)) {
+    if (path5.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path4.resolve(templateDir, folderPath);
+    const absolutePath = path5.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -10266,19 +10285,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path4.isAbsolute(locationPath);
+          const isAbsolute = path5.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path4.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path5.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 = (path4.resolve(templateDir, basePath) + patternPath).replace(/\\/g, "/");
+              const resolvedPath = (path5.resolve(templateDir, basePath) + patternPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             }
           }
@@ -10295,28 +10314,39 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   return JSON.stringify(transformedWorkspace, null, 2);
 }
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/vscode/agentDispatch.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/vscode/agentDispatch.js
 var execAsync = promisify(exec);
+function generateTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
+}
 var DEFAULT_WORKSPACE_TEMPLATE = {
   folders: [
     {
       path: "."
     }
-  ],
-  settings: {
-    "chat.modeFilesLocations": {
-      "**/*.chatmode.md": true
-    }
-  }
+  ]
 };
 var DEFAULT_WAKEUP_CONTENT = `---
 description: 'Wake-up Signal'
-tools: ['edit', 'runNotebooks', 'search', 'new', 'runCommands', 'runTasks', 'usages', 'vscodeAPI', 'problems', 'changes', 'testFailure', 'openSimpleBrowser', 'fetch', 'githubRepo']
-model: GPT-4.1 (copilot)
+model: Grok Code Fast 1 (copilot)
 ---`;
 function getSubagentRoot(vscodeCmd = "code") {
   return getDefaultSubagentRoot(vscodeCmd);
 }
+async function resolvePromptFile(promptFile) {
+  if (!promptFile) {
+    return void 0;
+  }
+  const resolvedPrompt = path6.resolve(promptFile);
+  if (!await pathExists(resolvedPrompt)) {
+    throw new Error(`Prompt file not found: ${resolvedPrompt}`);
+  }
+  const promptStats = await stat2(resolvedPrompt);
+  if (!promptStats.isFile()) {
+    throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
+  }
+  return resolvedPrompt;
+}
 async function findUnlockedSubagent(subagentRoot) {
   if (!await pathExists(subagentRoot)) {
     return null;
@@ -10327,7 +10357,7 @@ async function findUnlockedSubagent(subagentRoot) {
     number: Number.parseInt(entry.name.split("-")[1] ?? "", 10)
   })).filter((entry) => Number.isInteger(entry.number)).sort((a, b) => a.number - b.number);
   for (const subagent of subagents) {
-    const lockFile = path5.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path6.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -10348,9 +10378,12 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
     return true;
   }
-  const aliveFile = path5.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path6.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const wakeupDst = path5.join(subagentDir, DEFAULT_WAKEUP_FILENAME);
+  const githubAgentsDir = path6.join(subagentDir, ".github", "agents");
+  await mkdir2(githubAgentsDir, { recursive: true });
+  const wakeupDst = path6.join(githubAgentsDir, "wakeup.md");
+  const subagentDst = path6.join(githubAgentsDir, "subagent.md");
   await writeFile(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
   await sleep(100);
@@ -10370,7 +10403,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
 async function copyAgentConfig(subagentDir, workspaceTemplate) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path5.resolve(workspaceTemplate);
+    const workspaceSrc = path6.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -10383,33 +10416,37 @@ async function copyAgentConfig(subagentDir, workspaceTemplate) {
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path5.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path5.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path5.dirname(path5.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path6.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path6.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path6.dirname(path6.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   await writeFile(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path5.join(subagentDir, "messages");
+  const messagesDir = path6.join(subagentDir, "messages");
   await mkdir2(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path5.join(subagentDir, "messages");
+  const messagesDir = path6.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir2(messagesDir);
     await Promise.all(files.map(async (file) => {
-      const target = path5.join(messagesDir, file);
+      const target = path6.join(messagesDir, file);
       await removeIfExists(target);
     }));
   }
-  const chatmodeFiles = await readdir2(subagentDir);
-  await Promise.all(chatmodeFiles.filter((file) => file.endsWith(".chatmode.md")).map((file) => removeIfExists(path5.join(subagentDir, file))));
-  const lockFile = path5.join(subagentDir, DEFAULT_LOCK_NAME);
+  const githubAgentsDir = path6.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(path6.join(githubAgentsDir, file))));
+  }
+  const lockFile = path6.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path5.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path6.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, silent = false) {
@@ -10449,6 +10486,54 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   }
   return false;
 }
+async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
+  if (!silent) {
+    const fileList = responseFilesFinal.map((file) => path6.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 sleep(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 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 sleep(pollInterval);
+      }
+    }
+  }
+  return true;
+}
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
   if (dryRun) {
     return 0;
@@ -10466,17 +10551,19 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const chatmodeFile = path5.join(subagentDir, `${chatId}.chatmode.md`);
+    const githubAgentsDir = path6.join(subagentDir, ".github", "agents");
+    await mkdir2(githubAgentsDir, { recursive: true });
+    const agentFile = path6.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await copyFile(promptFile, chatmodeFile);
+      await copyFile(promptFile, agentFile);
     } catch (error) {
-      console.error(`error: Failed to copy prompt file to chatmode: ${error.message}`);
+      console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
     }
   }
   return 0;
 }
-function createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, subagentName, vscodeCmd) {
+function createRequestPrompt(userQuery, responseFileTmp, responseFileFinal) {
   return `[[ ## task ## ]]
 
 ${userQuery}
@@ -10488,18 +10575,46 @@ ${userQuery}
 2. When completely finished, run these PowerShell commands to signal completion:
 \`\`\`
 Move-Item -LiteralPath '${responseFileTmp}' -Destination '${responseFileFinal}'
-subagent ${vscodeCmd} unlock --subagent ${subagentName}
+if (Test-Path subagent.lock) { del subagent.lock }
 \`\`\`
 
 Do not proceed to step 2 until your response is completely written to the temporary file.`;
 }
+function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal) {
+  return `[[ ## task ## ]]
+
+${userQuery}
+
+[[ ## system_instructions ## ]]
+
+Write your complete response to: ${responseFileTmp}
+When completely finished and the response is stable, rename it to: ${responseFileFinal}
+Do not unlock the workspace from this request; batch orchestration will handle unlocking after all responses are ready.`;
+}
+function createBatchOrchestratorPrompt(requestFiles, responseFiles) {
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path6.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path6.basename(file)}"`).join(", ");
+  return `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:
+
+${requestLines}
+
+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 }
+\`\`\`
+`;
+}
 async function resolveAttachments(extraAttachments) {
   if (!extraAttachments) {
     return [];
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path5.resolve(attachment);
+    const resolvedPath = path6.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -10509,18 +10624,40 @@ async function resolveAttachments(extraAttachments) {
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
   try {
-    const workspacePath = path5.join(subagentDir, `${path5.basename(subagentDir)}.code-workspace`);
-    const messagesDir = path5.join(subagentDir, "messages");
+    const workspacePath = path6.join(subagentDir, `${path6.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path6.join(subagentDir, "messages");
     await mkdir2(messagesDir, { recursive: true });
-    const reqFile = path5.join(messagesDir, `${timestamp}_req.md`);
+    const reqFile = path6.join(messagesDir, `${timestamp}_req.md`);
     await writeFile(reqFile, requestInstructions, { encoding: "utf8" });
     const chatArgs = ["-r", "chat", "-m", chatId];
     for (const attachment of attachmentPaths) {
       chatArgs.push("-a", attachment);
     }
     chatArgs.push("-a", reqFile);
-    chatArgs.push(`Follow instructions in ${path5.basename(reqFile)}`);
-    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path5.basename(subagentDir), subagentDir, vscodeCmd);
+    chatArgs.push(`Follow instructions in ${path6.basename(reqFile)}`);
+    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path6.basename(subagentDir), subagentDir, vscodeCmd);
+    if (!workspaceReady) {
+      console.error("warning: Workspace may not be fully ready");
+    }
+    await sleep(500);
+    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 = path6.join(subagentDir, `${path6.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path6.join(subagentDir, "messages");
+    await mkdir2(messagesDir, { recursive: true });
+    const chatArgs = ["-r", "chat", "-m", chatId];
+    for (const attachment of attachmentPaths) {
+      chatArgs.push("-a", attachment);
+    }
+    chatArgs.push(chatInstruction);
+    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path6.basename(subagentDir), subagentDir, vscodeCmd);
     if (!workspaceReady) {
       console.error("warning: Workspace may not be fully ready");
     }
@@ -10536,21 +10673,13 @@ async function dispatchAgentSession(options) {
   const { userQuery, promptFile, extraAttachments, workspaceTemplate, dryRun = false, wait = true, vscodeCmd = "code", subagentRoot, silent = false } = options;
   try {
     let resolvedPrompt;
-    if (promptFile) {
-      resolvedPrompt = path5.resolve(promptFile);
-      if (!await pathExists(resolvedPrompt)) {
-        return {
-          exitCode: 1,
-          error: `Prompt file not found: ${resolvedPrompt}`
-        };
-      }
-      const promptStats = await stat2(resolvedPrompt);
-      if (!promptStats.isFile()) {
-        return {
-          exitCode: 1,
-          error: `Prompt file must be a file, not a directory: ${resolvedPrompt}`
-        };
-      }
+    try {
+      resolvedPrompt = await resolvePromptFile(promptFile);
+    } catch (error) {
+      return {
+        exitCode: 1,
+        error: error.message
+      };
     }
     const subagentRootPath = subagentRoot ?? getSubagentRoot(vscodeCmd);
     const subagentDir = await findUnlockedSubagent(subagentRootPath);
@@ -10560,7 +10689,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path5.basename(subagentDir);
+    const subagentName = path6.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
     if (preparationResult !== 0) {
@@ -10580,11 +10709,11 @@ async function dispatchAgentSession(options) {
         error: attachmentError.message
       };
     }
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
-    const messagesDir = path5.join(subagentDir, "messages");
-    const responseFileTmp = path5.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path5.join(messagesDir, `${timestamp}_res.md`);
-    const requestInstructions = createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, subagentName, vscodeCmd);
+    const timestamp = generateTimestamp();
+    const messagesDir = path6.join(subagentDir, "messages");
+    const responseFileTmp = path6.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path6.join(messagesDir, `${timestamp}_res.md`);
+    const requestInstructions = createRequestPrompt(userQuery, responseFileTmp, responseFileFinal);
     if (dryRun) {
       return {
         exitCode: 0,
@@ -10635,10 +10764,141 @@ async function dispatchAgentSession(options) {
     };
   }
 }
+async function dispatchBatchAgent(options) {
+  const { userQueries, promptFile, 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 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 = path6.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 = path6.join(subagentDir, "messages");
+    requestFiles = userQueries.map((_, index) => path6.join(messagesDir, `${timestamp}_${index}_req.md`));
+    const responseTmpFiles = userQueries.map((_, index) => path6.join(messagesDir, `${timestamp}_${index}_res.tmp.md`));
+    responseFilesFinal = userQueries.map((_, index) => path6.join(messagesDir, `${timestamp}_${index}_res.md`));
+    const orchestratorFile = path6.join(messagesDir, `${timestamp}_orchestrator.md`);
+    if (!dryRun) {
+      await Promise.all(userQueries.map((query, index) => writeFile(requestFiles[index], createBatchRequestPrompt(query, responseTmpFiles[index], responseFilesFinal[index]), { encoding: "utf8" })));
+      const orchestratorContent = createBatchOrchestratorPrompt(requestFiles, responseFilesFinal);
+      await writeFile(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+    }
+    const chatAttachments = [orchestratorFile, ...attachments];
+    const orchestratorUri = pathToFileUri(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
+    };
+  }
+}
 
-// ../../node_modules/.pnpm/subagent@0.4.2/node_modules/subagent/dist/vscode/provision.js
+// ../../node_modules/.pnpm/subagent@0.4.6/node_modules/subagent/dist/vscode/provision.js
 import { writeFile as writeFile2 } from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -10647,7 +10907,7 @@ var DEFAULT_WORKSPACE_TEMPLATE2 = {
   ],
   settings: {
     "chat.modeFilesLocations": {
-      "**/*.chatmode.md": true
+      ".github/agents/**/*.md": true
     }
   }
 };
@@ -10661,7 +10921,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path6.resolve(targetRoot);
+  const targetPath = path7.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -10680,7 +10940,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path6.join(entry.absolutePath, lockName);
+      const lockFile = path7.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -10697,9 +10957,11 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const lockFile = path6.join(subagentDir, lockName);
-    const workspaceDst = path6.join(subagentDir, `${path6.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path6.join(subagentDir, DEFAULT_WAKEUP_FILENAME);
+    const githubAgentsDir = path7.join(subagentDir, ".github", "agents");
+    const lockFile = path7.join(subagentDir, lockName);
+    const workspaceDst = path7.join(subagentDir, `${path7.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path7.join(githubAgentsDir, "wakeup.md");
+    const subagentDst = path7.join(githubAgentsDir, "subagent.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -10707,6 +10969,7 @@ async function provisionSubagents(options) {
     if (isLocked && force) {
       if (!dryRun) {
         await removeIfExists(lockFile);
+        await ensureDir(githubAgentsDir);
         await writeFile2(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
         await writeFile2(wakeupDst, wakeupContent, "utf8");
       }
@@ -10717,6 +10980,7 @@ async function provisionSubagents(options) {
     }
     if (!isLocked && force) {
       if (!dryRun) {
+        await ensureDir(githubAgentsDir);
         await writeFile2(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
         await writeFile2(wakeupDst, wakeupContent, "utf8");
       }
@@ -10725,6 +10989,7 @@ async function provisionSubagents(options) {
       continue;
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
+      await ensureDir(githubAgentsDir);
       await writeFile2(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
       await writeFile2(wakeupDst, wakeupContent, "utf8");
     }
@@ -10734,11 +10999,14 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path6.join(targetPath, `subagent-${nextIndex}`);
-    const workspaceDst = path6.join(subagentDir, `${path6.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path6.join(subagentDir, DEFAULT_WAKEUP_FILENAME);
+    const subagentDir = path7.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path7.join(subagentDir, ".github", "agents");
+    const workspaceDst = path7.join(subagentDir, `${path7.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path7.join(githubAgentsDir, "wakeup.md");
+    const subagentDst = path7.join(githubAgentsDir, "subagent.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
+      await ensureDir(githubAgentsDir);
       await writeFile2(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
       await writeFile2(wakeupDst, wakeupContent, "utf8");
     }
@@ -10753,14 +11021,21 @@ async function provisionSubagents(options) {
 }
 
 // ../../packages/core/dist/index.js
+import { exec as execCallback, spawn as spawn2 } from "node:child_process";
 import { constants as constants22 } from "node:fs";
-import { access as access22, readFile as readFile3 } from "node:fs/promises";
-import path32 from "node:path";
+import { access as access22, copyFile as copyFile2, mkdtemp, mkdir as mkdir3, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path52 from "node:path";
+import { promisify as promisify22 } from "node:util";
+import path42 from "node:path";
+import { constants as constants32 } from "node:fs";
+import { access as access32, readFile as readFile3 } from "node:fs/promises";
+import path62 from "node:path";
 import { parse as parse22 } from "yaml";
 import { randomUUID } from "node:crypto";
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir3, writeFile as writeFile22 } from "node:fs/promises";
-import path42 from "node:path";
+import { mkdir as mkdir22, readFile as readFile4, writeFile as writeFile22 } from "node:fs/promises";
+import path72 from "node:path";
 var TEST_MESSAGE_ROLE_VALUES = ["system", "user", "assistant", "tool"];
 var TEST_MESSAGE_ROLE_SET = new Set(TEST_MESSAGE_ROLE_VALUES);
 function isTestMessageRole(value) {
@@ -10800,10 +11075,10 @@ function isTestMessage(value) {
   }
   return candidate.content.every(isJsonObject);
 }
-var GRADER_KIND_VALUES = ["heuristic", "llm_judge"];
-var GRADER_KIND_SET = new Set(GRADER_KIND_VALUES);
-function isGraderKind(value) {
-  return typeof value === "string" && GRADER_KIND_SET.has(value);
+var EVALUATOR_KIND_VALUES = ["code", "llm_judge"];
+var EVALUATOR_KIND_SET = new Set(EVALUATOR_KIND_VALUES);
+function isEvaluatorKind(value) {
+  return typeof value === "string" && EVALUATOR_KIND_SET.has(value);
 }
 var CODE_BLOCK_PATTERN = /```[\s\S]*?```/g;
 var ANSI_YELLOW = "\x1B[33m";
@@ -10813,7 +11088,7 @@ var SCHEMA_CONFIG_V2 = "agentv-config-v2";
 async function loadConfig(evalFilePath, repoRoot) {
   const directories = buildDirectoryChain(evalFilePath, repoRoot);
   for (const directory of directories) {
-    const configPath = path7.join(directory, ".agentv", "config.yaml");
+    const configPath = path8.join(directory, ".agentv", "config.yaml");
     if (!await fileExists2(configPath)) {
       continue;
     }
@@ -10876,7 +11151,7 @@ function extractCodeBlocks(segments) {
 }
 async function loadEvalCases(evalFilePath, repoRoot, options) {
   const verbose = options?.verbose ?? false;
-  const absoluteTestPath = path7.resolve(evalFilePath);
+  const absoluteTestPath = path8.resolve(evalFilePath);
   if (!await fileExists2(absoluteTestPath)) {
     throw new Error(`Test file not found: ${evalFilePath}`);
   }
@@ -10900,7 +11175,7 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
   if (!Array.isArray(rawTestcases)) {
     throw new Error(`Invalid test file format: ${evalFilePath} - missing 'evalcases' field`);
   }
-  const globalGrader = coerceGrader(suite.grader) ?? "llm_judge";
+  const globalEvaluator = coerceEvaluator(suite.evaluator, "global") ?? "llm_judge";
   const results = [];
   for (const rawEvalcase of rawTestcases) {
     if (!isJsonObject(rawEvalcase)) {
@@ -10987,9 +11262,9 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
           }
           try {
             const fileContent = (await readFile2(resolvedPath, "utf8")).replace(/\r\n/g, "\n");
-            const relativeToRepo = path7.relative(repoRootPath, resolvedPath);
+            const relativeToRepo = path8.relative(repoRootPath, resolvedPath);
             if (isGuidelineFile(relativeToRepo, guidelinePatterns)) {
-              guidelinePaths.push(path7.resolve(resolvedPath));
+              guidelinePaths.push(path8.resolve(resolvedPath));
               if (verbose) {
                 console.log(`  [Guideline] Found: ${displayPath}`);
                 console.log(`    Resolved to: ${resolvedPath}`);
@@ -10999,7 +11274,7 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
                 type: "file",
                 path: displayPath,
                 text: fileContent,
-                resolvedPath: path7.resolve(resolvedPath)
+                resolvedPath: path8.resolve(resolvedPath)
               });
               if (verbose) {
                 console.log(`  [File] Found: ${displayPath}`);
@@ -11023,7 +11298,8 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
     const assistantContent = assistantMessages[0]?.content;
     const expectedAssistantRaw = await resolveAssistantContent(assistantContent, searchRoots, verbose);
     const userTextPrompt = userTextParts.map((part) => part.trim()).filter((part) => part.length > 0).join(" ");
-    const testCaseGrader = coerceGrader(evalcase.grader) ?? globalGrader;
+    const testCaseEvaluatorKind = coerceEvaluator(evalcase.evaluator, id) ?? globalEvaluator;
+    const evaluators = await parseEvaluators(evalcase, searchRoots, id ?? "unknown");
     const userFilePaths = [];
     for (const segment of userSegments) {
       if (segment.type === "file" && typeof segment.resolvedPath === "string") {
@@ -11031,7 +11307,7 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
       }
     }
     const allFilePaths = [
-      ...guidelinePaths.map((guidelinePath) => path7.resolve(guidelinePath)),
+      ...guidelinePaths.map((guidelinePath) => path8.resolve(guidelinePath)),
       ...userFilePaths
     ];
     const testCase = {
@@ -11041,12 +11317,13 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
       user_segments: userSegments,
       system_message: systemMessageContent,
       expected_assistant_raw: expectedAssistantRaw,
-      guideline_paths: guidelinePaths.map((guidelinePath) => path7.resolve(guidelinePath)),
+      guideline_paths: guidelinePaths.map((guidelinePath) => path8.resolve(guidelinePath)),
       guideline_patterns: guidelinePatterns,
       file_paths: allFilePaths,
       code_snippets: codeSnippets,
       outcome,
-      grader: testCaseGrader
+      evaluator: testCaseEvaluatorKind,
+      evaluators
     };
     if (verbose) {
       console.log(`
@@ -11067,14 +11344,14 @@ Please add '$schema: ${SCHEMA_EVAL_V2}' at the top of the file.`;
 async function buildPromptInputs(testCase) {
   const guidelineContents = [];
   for (const rawPath of testCase.guideline_paths) {
-    const absolutePath = path7.resolve(rawPath);
+    const absolutePath = path8.resolve(rawPath);
     if (!await fileExists2(absolutePath)) {
       logWarning(`Could not read guideline file ${absolutePath}: file does not exist`);
       continue;
     }
     try {
       const content = (await readFile2(absolutePath, "utf8")).replace(/\r\n/g, "\n");
-      guidelineContents.push(`=== ${path7.basename(absolutePath)} ===
+      guidelineContents.push(`=== ${path8.basename(absolutePath)} ===
 ${content}`);
     } catch (error) {
       logWarning(`Could not read guideline file ${absolutePath}: ${error.message}`);
@@ -11127,7 +11404,7 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file://")) {
       return fileURLToPath(new URL(candidate));
     }
-    return path7.resolve(candidate);
+    return path8.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
@@ -11207,14 +11484,88 @@ async function resolveAssistantContent(content, searchRoots, verbose) {
   }
   return parts.join(" ");
 }
-function coerceGrader(candidate) {
+async function parseEvaluators(rawEvalCase, searchRoots, evalId) {
+  const execution = rawEvalCase.execution;
+  const candidateEvaluators = isJsonObject(execution) ? execution.evaluators ?? rawEvalCase.evaluators : rawEvalCase.evaluators;
+  if (candidateEvaluators === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(candidateEvaluators)) {
+    logWarning(`Skipping evaluators for '${evalId}': expected array`);
+    return void 0;
+  }
+  const evaluators = [];
+  for (const rawEvaluator of candidateEvaluators) {
+    if (!isJsonObject(rawEvaluator)) {
+      logWarning(`Skipping invalid evaluator entry for '${evalId}' (expected object)`);
+      continue;
+    }
+    const name = asString(rawEvaluator.name);
+    const typeValue = rawEvaluator.type;
+    if (!name || !isEvaluatorKind(typeValue)) {
+      logWarning(`Skipping evaluator with invalid name/type in '${evalId}'`);
+      continue;
+    }
+    if (typeValue === "code") {
+      const script = asString(rawEvaluator.script);
+      if (!script) {
+        logWarning(`Skipping code evaluator '${name}' in '${evalId}': missing script`);
+        continue;
+      }
+      const cwd = asString(rawEvaluator.cwd);
+      let resolvedCwd;
+      if (cwd) {
+        const resolved = await resolveFileReference(cwd, searchRoots);
+        if (resolved.resolvedPath) {
+          resolvedCwd = path8.resolve(resolved.resolvedPath);
+        } else {
+          logWarning(
+            `Code evaluator '${name}' in '${evalId}': cwd not found (${resolved.displayPath})`,
+            resolved.attempted.length > 0 ? resolved.attempted.map((attempt) => `  Tried: ${attempt}`) : void 0
+          );
+        }
+      }
+      evaluators.push({
+        name,
+        type: "code",
+        script,
+        cwd,
+        resolvedCwd
+      });
+      continue;
+    }
+    const prompt = asString(rawEvaluator.prompt);
+    let promptPath;
+    if (prompt) {
+      const resolved = await resolveFileReference(prompt, searchRoots);
+      if (resolved.resolvedPath) {
+        promptPath = path8.resolve(resolved.resolvedPath);
+      } else {
+        logWarning(
+          `Inline prompt used for evaluator '${name}' in '${evalId}' (file not found: ${resolved.displayPath})`,
+          resolved.attempted.length > 0 ? resolved.attempted.map((attempt) => `  Tried: ${attempt}`) : void 0
+        );
+      }
+    }
+    const model = asString(rawEvaluator.model);
+    evaluators.push({
+      name,
+      type: "llm_judge",
+      prompt,
+      promptPath,
+      model
+    });
+  }
+  return evaluators.length > 0 ? evaluators : void 0;
+}
+function coerceEvaluator(candidate, contextId) {
   if (typeof candidate !== "string") {
     return void 0;
   }
-  if (isGraderKind(candidate)) {
+  if (isEvaluatorKind(candidate)) {
     return candidate;
   }
-  logWarning(`Unknown grader '${candidate}', falling back to default`);
+  logWarning(`Unknown evaluator '${candidate}' in ${contextId}, falling back to default`);
   return void 0;
 }
 function logWarning(message, details) {
@@ -11406,49 +11757,253 @@ var GeminiProvider = class {
     return mapResponse(ensureChatResponse(response));
   }
 };
-var DEFAULT_MOCK_RESPONSE = '{"answer":"Mock provider response. Configure targets.yaml to supply a custom value."}';
-var MockProvider = class {
+var execAsync2 = promisify2(execWithCallback);
+var DEFAULT_MAX_BUFFER = 10 * 1024 * 1024;
+async function defaultCommandRunner(command, options) {
+  const execOptions = {
+    cwd: options.cwd,
+    env: options.env,
+    timeout: options.timeoutMs,
+    signal: options.signal,
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    shell: process.platform === "win32" ? "powershell.exe" : void 0
+  };
+  try {
+    const { stdout, stderr } = await execAsync2(command, execOptions);
+    return {
+      stdout,
+      stderr,
+      exitCode: 0,
+      failed: false,
+      timedOut: false,
+      signal: null
+    };
+  } catch (error) {
+    const execError = error;
+    return {
+      stdout: execError.stdout ?? "",
+      stderr: execError.stderr ?? "",
+      exitCode: typeof execError.code === "number" ? execError.code : null,
+      failed: true,
+      timedOut: execError.timedOut === true || execError.killed === true,
+      signal: execError.signal ?? null
+    };
+  }
+}
+var CliProvider = class {
   id;
-  kind = "mock";
+  kind = "cli";
   targetName;
-  cannedResponse;
-  delayMs;
-  delayMinMs;
-  delayMaxMs;
-  constructor(targetName, config) {
-    this.id = `mock:${targetName}`;
+  supportsBatch = false;
+  config;
+  runCommand;
+  healthcheckPromise;
+  constructor(targetName, config, runner = defaultCommandRunner) {
     this.targetName = targetName;
-    this.cannedResponse = config.response ?? DEFAULT_MOCK_RESPONSE;
-    this.delayMs = config.delayMs ?? 0;
-    this.delayMinMs = config.delayMinMs ?? 0;
-    this.delayMaxMs = config.delayMaxMs ?? 0;
+    this.id = `cli:${targetName}`;
+    this.config = config;
+    this.runCommand = runner;
   }
   async invoke(request) {
-    const delay = this.calculateDelay();
-    if (delay > 0) {
-      await new Promise((resolve) => setTimeout(resolve, delay));
+    if (request.signal?.aborted) {
+      throw new Error("CLI provider request was aborted before execution");
+    }
+    await this.ensureHealthy(request.signal);
+    const templateValues = buildTemplateValues(request, this.config);
+    const renderedCommand = renderTemplate(this.config.commandTemplate, templateValues);
+    const env = this.config.env ? { ...process.env, ...this.config.env } : process.env;
+    const result = await this.runCommand(renderedCommand, {
+      cwd: this.config.cwd,
+      env,
+      timeoutMs: this.config.timeoutMs,
+      signal: request.signal
+    });
+    if (result.failed || (result.exitCode ?? 0) !== 0) {
+      if (request.signal?.aborted) {
+        throw new Error("CLI provider request was aborted");
+      }
+      if (result.timedOut) {
+        throw new Error(
+          `CLI provider timed out${formatTimeoutSuffix(this.config.timeoutMs ?? void 0)}`
+        );
+      }
+      const codeText = result.exitCode !== null ? result.exitCode : "unknown";
+      const detail = result.stderr.trim() || result.stdout.trim();
+      const message = detail ? `${detail} (exit code ${codeText})` : `CLI exited with code ${codeText}`;
+      throw new Error(message);
     }
     return {
-      text: this.cannedResponse,
+      text: result.stdout,
       raw: {
-        prompt: request.prompt,
-        guidelines: request.guidelines
+        command: renderedCommand,
+        stderr: result.stderr,
+        exitCode: result.exitCode ?? 0,
+        cwd: this.config.cwd
       }
     };
   }
-  calculateDelay() {
-    if (this.delayMinMs > 0 || this.delayMaxMs > 0) {
-      const min = Math.max(0, this.delayMinMs);
-      const max = Math.max(min, this.delayMaxMs);
-      return Math.floor(Math.random() * (max - min + 1)) + min;
+  async ensureHealthy(signal) {
+    if (!this.config.healthcheck) {
+      return;
     }
-    return this.delayMs;
+    if (!this.healthcheckPromise) {
+      this.healthcheckPromise = this.runHealthcheck(this.config.healthcheck, signal);
+    }
+    return this.healthcheckPromise;
   }
-};
-var BASE_TARGET_SCHEMA = external_exports.object({
-  name: external_exports.string().min(1, "target name is required"),
-  provider: external_exports.string().min(1, "provider is required"),
-  settings: external_exports.record(external_exports.unknown()).optional(),
+  async runHealthcheck(healthcheck, signal) {
+    if (!healthcheck) {
+      return;
+    }
+    const timeoutMs = healthcheck.timeoutMs ?? this.config.timeoutMs;
+    if (healthcheck.type === "http") {
+      const controller = new AbortController();
+      const timer = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : void 0;
+      signal?.addEventListener("abort", () => controller.abort(), { once: true });
+      try {
+        const response = await fetch(healthcheck.url, { method: "GET", signal: controller.signal });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status} ${response.statusText}`);
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new Error(`CLI healthcheck failed for '${this.targetName}': ${reason}`);
+      } finally {
+        if (timer !== void 0) {
+          clearTimeout(timer);
+        }
+      }
+      return;
+    }
+    const renderedCommand = renderTemplate(
+      healthcheck.commandTemplate,
+      buildTemplateValues(
+        {
+          prompt: "",
+          guidelines: "",
+          inputFiles: [],
+          evalCaseId: "",
+          attempt: 0
+        },
+        this.config
+      )
+    );
+    const env = this.config.env ? { ...process.env, ...this.config.env } : process.env;
+    const result = await this.runCommand(renderedCommand, {
+      cwd: healthcheck.cwd ?? this.config.cwd,
+      env,
+      timeoutMs,
+      signal
+    });
+    if (result.failed || (result.exitCode ?? 0) !== 0) {
+      const codeText = result.exitCode !== null ? result.exitCode : "unknown";
+      const detail = result.stderr.trim() || result.stdout.trim();
+      const message = detail ? `${detail} (exit code ${codeText})` : `CLI healthcheck command exited with code ${codeText}`;
+      throw new Error(`CLI healthcheck failed for '${this.targetName}': ${message}`);
+    }
+  }
+};
+function buildTemplateValues(request, config) {
+  const inputFiles = normalizeInputFiles(request.inputFiles);
+  return {
+    PROMPT: shellEscape(request.prompt ?? ""),
+    GUIDELINES: shellEscape(request.guidelines ?? ""),
+    EVAL_ID: shellEscape(request.evalCaseId ?? ""),
+    ATTEMPT: shellEscape(String(request.attempt ?? 0)),
+    FILES: formatFileList(inputFiles, config.filesFormat)
+  };
+}
+function normalizeInputFiles(inputFiles) {
+  if (!inputFiles || inputFiles.length === 0) {
+    return void 0;
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const inputFile of inputFiles) {
+    const absolutePath = path22.resolve(inputFile);
+    if (!unique.has(absolutePath)) {
+      unique.set(absolutePath, absolutePath);
+    }
+  }
+  return Array.from(unique.values());
+}
+function formatFileList(files, template) {
+  if (!files || files.length === 0) {
+    return "";
+  }
+  const formatter = template ?? "{path}";
+  return files.map((filePath) => {
+    const escapedPath = shellEscape(filePath);
+    const escapedName = shellEscape(path22.basename(filePath));
+    return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
+  }).join(" ");
+}
+function renderTemplate(template, values) {
+  return template.replace(/\{([A-Z_]+)\}/g, (match, key2) => {
+    const replacement = values[key2];
+    return replacement !== void 0 ? replacement : match;
+  });
+}
+function shellEscape(value) {
+  if (value.length === 0) {
+    return "''";
+  }
+  if (process.platform === "win32") {
+    const escaped = value.replace(/"/g, '\\"');
+    return `"${escaped}"`;
+  }
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function formatTimeoutSuffix(timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return "";
+  }
+  const seconds = Math.ceil(timeoutMs / 1e3);
+  return ` after ${seconds}s`;
+}
+var DEFAULT_MOCK_RESPONSE = '{"answer":"Mock provider response. Configure targets.yaml to supply a custom value."}';
+var MockProvider = class {
+  id;
+  kind = "mock";
+  targetName;
+  cannedResponse;
+  delayMs;
+  delayMinMs;
+  delayMaxMs;
+  constructor(targetName, config) {
+    this.id = `mock:${targetName}`;
+    this.targetName = targetName;
+    this.cannedResponse = config.response ?? DEFAULT_MOCK_RESPONSE;
+    this.delayMs = config.delayMs ?? 0;
+    this.delayMinMs = config.delayMinMs ?? 0;
+    this.delayMaxMs = config.delayMaxMs ?? 0;
+  }
+  async invoke(request) {
+    const delay = this.calculateDelay();
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    return {
+      text: this.cannedResponse,
+      raw: {
+        prompt: request.prompt,
+        guidelines: request.guidelines
+      }
+    };
+  }
+  calculateDelay() {
+    if (this.delayMinMs > 0 || this.delayMaxMs > 0) {
+      const min = Math.max(0, this.delayMinMs);
+      const max = Math.max(min, this.delayMaxMs);
+      return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    return this.delayMs;
+  }
+};
+var CLI_PLACEHOLDERS = /* @__PURE__ */ new Set(["PROMPT", "GUIDELINES", "EVAL_ID", "ATTEMPT", "FILES"]);
+var BASE_TARGET_SCHEMA = external_exports.object({
+  name: external_exports.string().min(1, "target name is required"),
+  provider: external_exports.string().min(1, "provider is required"),
+  settings: external_exports.record(external_exports.unknown()).optional(),
   judge_target: external_exports.string().optional(),
   workers: external_exports.number().int().min(1).optional()
 });
@@ -11467,6 +12022,9 @@ function normalizeAzureApiVersion(value) {
 function resolveTargetDefinition(definition, env = process.env) {
   const parsed = BASE_TARGET_SCHEMA.parse(definition);
   const provider = parsed.provider.toLowerCase();
+  const providerBatching = resolveOptionalBoolean(
+    parsed.settings?.provider_batching ?? parsed.settings?.providerBatching
+  );
   switch (provider) {
     case "azure":
     case "azure-openai":
@@ -11475,6 +12033,7 @@ function resolveTargetDefinition(definition, env = process.env) {
         name: parsed.name,
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
+        providerBatching,
         config: resolveAzureConfig(parsed, env)
       };
     case "anthropic":
@@ -11483,6 +12042,7 @@ function resolveTargetDefinition(definition, env = process.env) {
         name: parsed.name,
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
+        providerBatching,
         config: resolveAnthropicConfig(parsed, env)
       };
     case "gemini":
@@ -11493,14 +12053,26 @@ function resolveTargetDefinition(definition, env = process.env) {
         name: parsed.name,
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
+        providerBatching,
         config: resolveGeminiConfig(parsed, env)
       };
+    case "codex":
+    case "codex-cli":
+      return {
+        kind: "codex",
+        name: parsed.name,
+        judgeTarget: parsed.judge_target,
+        workers: parsed.workers,
+        providerBatching,
+        config: resolveCodexConfig(parsed, env)
+      };
     case "mock":
       return {
         kind: "mock",
         name: parsed.name,
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
+        providerBatching,
         config: resolveMockConfig(parsed)
       };
     case "vscode":
@@ -11510,8 +12082,18 @@ function resolveTargetDefinition(definition, env = process.env) {
         name: parsed.name,
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
+        providerBatching,
         config: resolveVSCodeConfig(parsed, env, provider === "vscode-insiders")
       };
+    case "cli":
+      return {
+        kind: "cli",
+        name: parsed.name,
+        judgeTarget: parsed.judge_target,
+        workers: parsed.workers,
+        providerBatching,
+        config: resolveCliConfig(parsed, env)
+      };
     default:
       throw new Error(`Unsupported provider '${parsed.provider}' in target '${parsed.name}'`);
   }
@@ -11579,6 +12161,29 @@ function resolveGeminiConfig(target, env) {
     maxOutputTokens: resolveOptionalNumber(maxTokensSource, `${target.name} max output tokens`)
   };
 }
+function resolveCodexConfig(target, env) {
+  const settings = target.settings ?? {};
+  const executableSource = settings.executable ?? settings.command ?? settings.binary;
+  const argsSource = settings.args ?? settings.arguments;
+  const cwdSource = settings.cwd;
+  const timeoutSource = settings.timeout_seconds ?? settings.timeoutSeconds;
+  const executable = resolveOptionalString(executableSource, env, `${target.name} codex executable`, {
+    allowLiteral: true,
+    optionalEnv: true
+  }) ?? "codex";
+  const args = resolveOptionalStringArray(argsSource, env, `${target.name} codex args`);
+  const cwd = resolveOptionalString(cwdSource, env, `${target.name} codex cwd`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} codex timeout`);
+  return {
+    executable,
+    args,
+    cwd,
+    timeoutMs
+  };
+}
 function resolveMockConfig(target) {
   const settings = target.settings ?? {};
   const response = typeof settings.response === "string" ? settings.response : void 0;
@@ -11608,6 +12213,125 @@ function resolveVSCodeConfig(target, env, insiders) {
     workspaceTemplate
   };
 }
+function resolveCliConfig(target, env) {
+  const settings = target.settings ?? {};
+  const commandTemplateSource = settings.command_template ?? settings.commandTemplate;
+  const filesFormat = resolveOptionalLiteralString(
+    settings.files_format ?? settings.filesFormat ?? settings.attachments_format ?? settings.attachmentsFormat
+  );
+  const cwd = resolveOptionalString(settings.cwd, env, `${target.name} working directory`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const envOverrides = resolveEnvOverrides(settings.env, env, target.name);
+  const timeoutMs = resolveTimeoutMs(settings.timeout_seconds ?? settings.timeoutSeconds, `${target.name} timeout`);
+  const healthcheck = resolveCliHealthcheck(settings.healthcheck, env, target.name);
+  const commandTemplate = resolveString(
+    commandTemplateSource,
+    env,
+    `${target.name} CLI command template`,
+    true
+  );
+  assertSupportedCliPlaceholders(commandTemplate, `${target.name} CLI command template`);
+  return {
+    commandTemplate,
+    filesFormat,
+    cwd,
+    env: envOverrides,
+    timeoutMs,
+    healthcheck
+  };
+}
+function resolveEnvOverrides(source2, env, targetName) {
+  if (source2 === void 0 || source2 === null) {
+    return void 0;
+  }
+  if (typeof source2 !== "object" || Array.isArray(source2)) {
+    throw new Error(`${targetName} env overrides must be an object map of strings`);
+  }
+  const entries = Object.entries(source2);
+  const resolved = {};
+  for (const [key2, value] of entries) {
+    if (typeof value !== "string") {
+      throw new Error(`${targetName} env override '${key2}' must be a string`);
+    }
+    const resolvedValue = resolveString(value, env, `${targetName} env override '${key2}'`);
+    resolved[key2] = resolvedValue;
+  }
+  return Object.keys(resolved).length > 0 ? resolved : void 0;
+}
+function resolveTimeoutMs(source2, description) {
+  const seconds = resolveOptionalNumber(source2, `${description} (seconds)`);
+  if (seconds === void 0) {
+    return void 0;
+  }
+  if (seconds <= 0) {
+    throw new Error(`${description} must be greater than zero seconds`);
+  }
+  return Math.floor(seconds * 1e3);
+}
+function resolveCliHealthcheck(source2, env, targetName) {
+  if (source2 === void 0 || source2 === null) {
+    return void 0;
+  }
+  if (typeof source2 !== "object" || Array.isArray(source2)) {
+    throw new Error(`${targetName} healthcheck must be an object`);
+  }
+  const candidate = source2;
+  const type = candidate.type;
+  const timeoutMs = resolveTimeoutMs(
+    candidate.timeout_seconds ?? candidate.timeoutSeconds,
+    `${targetName} healthcheck timeout`
+  );
+  if (type === "http") {
+    const url = resolveString(candidate.url, env, `${targetName} healthcheck URL`);
+    return {
+      type: "http",
+      url,
+      timeoutMs
+    };
+  }
+  if (type === "command") {
+    const commandTemplate = resolveString(
+      candidate.command_template ?? candidate.commandTemplate,
+      env,
+      `${targetName} healthcheck command template`,
+      true
+    );
+    assertSupportedCliPlaceholders(commandTemplate, `${targetName} healthcheck command template`);
+    const cwd = resolveOptionalString(candidate.cwd, env, `${targetName} healthcheck cwd`, {
+      allowLiteral: true,
+      optionalEnv: true
+    });
+    return {
+      type: "command",
+      commandTemplate,
+      timeoutMs,
+      cwd
+    };
+  }
+  throw new Error(`${targetName} healthcheck type must be 'http' or 'command'`);
+}
+function assertSupportedCliPlaceholders(template, description) {
+  const placeholders = extractCliPlaceholders(template);
+  for (const placeholder of placeholders) {
+    if (!CLI_PLACEHOLDERS.has(placeholder)) {
+      throw new Error(
+        `${description} includes unsupported placeholder '{${placeholder}}'. Supported placeholders: ${Array.from(CLI_PLACEHOLDERS).join(", ")}`
+      );
+    }
+  }
+}
+function extractCliPlaceholders(template) {
+  const matches = template.matchAll(/\{([A-Z_]+)\}/g);
+  const results = [];
+  for (const match of matches) {
+    if (match[1]) {
+      results.push(match[1]);
+    }
+  }
+  return results;
+}
 function resolveString(source2, env, description, allowLiteral = false) {
   const value = resolveOptionalString(source2, env, description, {
     allowLiteral,
@@ -11638,11 +12362,14 @@ function resolveOptionalString(source2, env, description, options) {
   }
   const allowLiteral = options?.allowLiteral ?? false;
   const optionalEnv = options?.optionalEnv ?? false;
-  if (!allowLiteral && isLikelyEnvReference(trimmed)) {
+  const looksLikeEnv = isLikelyEnvReference(trimmed);
+  if (looksLikeEnv) {
     if (optionalEnv) {
       return void 0;
     }
-    throw new Error(`Environment variable '${trimmed}' required for ${description} is not set`);
+    if (!allowLiteral) {
+      throw new Error(`Environment variable '${trimmed}' required for ${description} is not set`);
+    }
   }
   return trimmed;
 }
@@ -11692,10 +12419,43 @@ function resolveOptionalBoolean(source2) {
 function isLikelyEnvReference(value) {
   return /^[A-Z0-9_]+$/.test(value);
 }
+function resolveOptionalStringArray(source2, env, description) {
+  if (source2 === void 0 || source2 === null) {
+    return void 0;
+  }
+  if (!Array.isArray(source2)) {
+    throw new Error(`${description} must be an array of strings`);
+  }
+  if (source2.length === 0) {
+    return void 0;
+  }
+  const resolved = [];
+  for (let i6 = 0; i6 < source2.length; i6++) {
+    const item = source2[i6];
+    if (typeof item !== "string") {
+      throw new Error(`${description}[${i6}] must be a string`);
+    }
+    const trimmed = item.trim();
+    if (trimmed.length === 0) {
+      throw new Error(`${description}[${i6}] cannot be empty`);
+    }
+    const envValue = env[trimmed];
+    if (envValue !== void 0) {
+      if (envValue.trim().length === 0) {
+        throw new Error(`Environment variable '${trimmed}' for ${description}[${i6}] is empty`);
+      }
+      resolved.push(envValue);
+    } else {
+      resolved.push(trimmed);
+    }
+  }
+  return resolved.length > 0 ? resolved : void 0;
+}
 var VSCodeProvider = class {
   id;
   kind;
   targetName;
+  supportsBatch = true;
   config;
   constructor(targetName, config, kind) {
     this.id = `${kind}:${targetName}`;
@@ -11707,12 +12467,11 @@ var VSCodeProvider = class {
     if (request.signal?.aborted) {
       throw new Error("VS Code provider request was aborted before dispatch");
     }
-    const attachments = normalizeAttachments(request.attachments);
-    const promptContent = buildPromptDocument(request, attachments, request.guideline_patterns);
+    const inputFiles = normalizeAttachments(request.inputFiles);
+    const promptContent = buildPromptDocument(request, inputFiles, request.guideline_patterns);
     const session = await dispatchAgentSession({
       userQuery: promptContent,
-      // Use full prompt content instead of just request.prompt
-      extraAttachments: attachments,
+      extraAttachments: inputFiles,
       wait: this.config.waitForResponse,
       dryRun: this.config.dryRun,
       vscodeCmd: this.config.command,
@@ -11729,7 +12488,7 @@ var VSCodeProvider = class {
         text: "",
         raw: {
           session,
-          attachments
+          inputFiles
         }
       };
     }
@@ -11738,42 +12497,106 @@ var VSCodeProvider = class {
       text: responseText,
       raw: {
         session,
-        attachments
+        inputFiles
       }
     };
   }
+  async invokeBatch(requests) {
+    if (requests.length === 0) {
+      return [];
+    }
+    const normalizedRequests = requests.map((req) => ({
+      request: req,
+      inputFiles: normalizeAttachments(req.inputFiles)
+    }));
+    const combinedInputFiles = mergeAttachments(
+      normalizedRequests.map(({ inputFiles }) => inputFiles)
+    );
+    const userQueries = normalizedRequests.map(
+      ({ request, inputFiles }) => buildPromptDocument(request, inputFiles, request.guideline_patterns)
+    );
+    const session = await dispatchBatchAgent({
+      userQueries,
+      extraAttachments: combinedInputFiles,
+      wait: this.config.waitForResponse,
+      dryRun: this.config.dryRun,
+      vscodeCmd: this.config.command,
+      subagentRoot: this.config.subagentRoot,
+      workspaceTemplate: this.config.workspaceTemplate,
+      silent: true
+    });
+    if (session.exitCode !== 0 || !session.responseFiles) {
+      const failure = session.error ?? "VS Code subagent did not produce batch responses";
+      throw new Error(failure);
+    }
+    if (this.config.dryRun) {
+      return normalizedRequests.map(({ inputFiles }) => ({
+        text: "",
+        raw: {
+          session,
+          inputFiles,
+          allInputFiles: combinedInputFiles
+        }
+      }));
+    }
+    if (session.responseFiles.length !== requests.length) {
+      throw new Error(
+        `VS Code batch returned ${session.responseFiles.length} responses for ${requests.length} requests`
+      );
+    }
+    const responses = [];
+    for (const [index, responseFile] of session.responseFiles.entries()) {
+      const responseText = await readFile22(responseFile, "utf8");
+      responses.push({
+        text: responseText,
+        raw: {
+          session,
+          inputFiles: normalizedRequests[index]?.inputFiles,
+          allInputFiles: combinedInputFiles,
+          responseFile
+        }
+      });
+    }
+    return responses;
+  }
 };
 function buildPromptDocument(request, attachments, guidelinePatterns) {
   const parts = [];
   const guidelineFiles = collectGuidelineFiles(attachments, guidelinePatterns);
-  if (guidelineFiles.length > 0) {
-    parts.push("\n", buildMandatoryPrereadBlock(guidelineFiles));
+  const attachmentFiles = collectAttachmentFiles(attachments);
+  const nonGuidelineAttachments = attachmentFiles.filter(
+    (file) => !guidelineFiles.includes(file)
+  );
+  const prereadBlock = buildMandatoryPrereadBlock(guidelineFiles, nonGuidelineAttachments);
+  if (prereadBlock.length > 0) {
+    parts.push("\n", prereadBlock);
   }
   parts.push("\n[[ ## user_query ## ]]\n", request.prompt.trim());
   return parts.join("\n").trim();
 }
-function buildMandatoryPrereadBlock(guidelineFiles) {
-  if (guidelineFiles.length === 0) {
+function buildMandatoryPrereadBlock(guidelineFiles, attachmentFiles) {
+  if (guidelineFiles.length === 0 && attachmentFiles.length === 0) {
     return "";
   }
-  const fileList = [];
-  let counter = 0;
-  for (const absolutePath of guidelineFiles) {
-    counter += 1;
-    const fileName = path22.basename(absolutePath);
-    const fileUri = pathToFileUri(absolutePath);
-    fileList.push(`* [${fileName}](${fileUri})`);
-  }
-  const filesText = fileList.join("\n");
-  const instruction = [
-    `Read all guideline files:
-${filesText}.
-`,
-    `If any file is missing, fail with ERROR: missing-file <filename> and stop.
-`,
-    `Then apply system_instructions on the user query below.`
-  ].join("");
-  return `${instruction}`;
+  const buildList = (files) => files.map((absolutePath) => {
+    const fileName = path32.basename(absolutePath);
+    const fileUri = pathToFileUri2(absolutePath);
+    return `* [${fileName}](${fileUri})`;
+  });
+  const sections = [];
+  if (guidelineFiles.length > 0) {
+    sections.push(`Read all guideline files:
+${buildList(guidelineFiles).join("\n")}.`);
+  }
+  if (attachmentFiles.length > 0) {
+    sections.push(`Read all attachment files:
+${buildList(attachmentFiles).join("\n")}.`);
+  }
+  sections.push(
+    "If any file is missing, fail with ERROR: missing-file <filename> and stop.",
+    "Then apply system_instructions on the user query below."
+  );
+  return sections.join("\n");
 }
 function collectGuidelineFiles(attachments, guidelinePatterns) {
   if (!attachments || attachments.length === 0) {
@@ -11781,8 +12604,8 @@ function collectGuidelineFiles(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path22.resolve(attachment);
-    const normalized = absolutePath.split(path22.sep).join("/");
+    const absolutePath = path32.resolve(attachment);
+    const normalized = absolutePath.split(path32.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -11791,8 +12614,21 @@ function collectGuidelineFiles(attachments, guidelinePatterns) {
   }
   return Array.from(unique.values());
 }
-function pathToFileUri(filePath) {
-  const absolutePath = path22.isAbsolute(filePath) ? filePath : path22.resolve(filePath);
+function collectAttachmentFiles(attachments) {
+  if (!attachments || attachments.length === 0) {
+    return [];
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const attachment of attachments) {
+    const absolutePath = path32.resolve(attachment);
+    if (!unique.has(absolutePath)) {
+      unique.set(absolutePath, absolutePath);
+    }
+  }
+  return Array.from(unique.values());
+}
+function pathToFileUri2(filePath) {
+  const absolutePath = path32.isAbsolute(filePath) ? filePath : path32.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -11805,10 +12641,20 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path22.resolve(attachment));
+    deduped.add(path32.resolve(attachment));
   }
   return Array.from(deduped);
 }
+function mergeAttachments(all) {
+  const deduped = /* @__PURE__ */ new Set();
+  for (const list of all) {
+    if (!list) continue;
+    for (const inputFile of list) {
+      deduped.add(path32.resolve(inputFile));
+    }
+  }
+  return deduped.size > 0 ? Array.from(deduped) : void 0;
+}
 async function ensureVSCodeSubagents(options) {
   const { kind, count, verbose = false } = options;
   const vscodeCmd = kind === "vscode-insiders" ? "code-insiders" : "code";
@@ -11847,6 +12693,569 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
     };
   }
 }
+function buildPromptDocument2(request, inputFiles, options) {
+  const parts = [];
+  const guidelineFiles = collectGuidelineFiles2(
+    inputFiles,
+    options?.guidelinePatterns ?? request.guideline_patterns,
+    options?.guidelineOverrides
+  );
+  const inputFilesList = collectInputFiles(inputFiles);
+  const nonGuidelineInputFiles = inputFilesList.filter(
+    (file) => !guidelineFiles.includes(file)
+  );
+  const prereadBlock = buildMandatoryPrereadBlock2(guidelineFiles, nonGuidelineInputFiles);
+  if (prereadBlock.length > 0) {
+    parts.push("\n", prereadBlock);
+  }
+  parts.push("\n[[ ## user_query ## ]]\n", request.prompt.trim());
+  return parts.join("\n").trim();
+}
+function normalizeInputFiles2(inputFiles) {
+  if (!inputFiles || inputFiles.length === 0) {
+    return void 0;
+  }
+  const deduped = /* @__PURE__ */ new Map();
+  for (const inputFile of inputFiles) {
+    const absolutePath = path42.resolve(inputFile);
+    if (!deduped.has(absolutePath)) {
+      deduped.set(absolutePath, absolutePath);
+    }
+  }
+  return Array.from(deduped.values());
+}
+function collectGuidelineFiles2(inputFiles, guidelinePatterns, overrides) {
+  if (!inputFiles || inputFiles.length === 0) {
+    return [];
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const inputFile of inputFiles) {
+    const absolutePath = path42.resolve(inputFile);
+    if (overrides?.has(absolutePath)) {
+      if (!unique.has(absolutePath)) {
+        unique.set(absolutePath, absolutePath);
+      }
+      continue;
+    }
+    const normalized = absolutePath.split(path42.sep).join("/");
+    if (isGuidelineFile(normalized, guidelinePatterns)) {
+      if (!unique.has(absolutePath)) {
+        unique.set(absolutePath, absolutePath);
+      }
+    }
+  }
+  return Array.from(unique.values());
+}
+function collectInputFiles(inputFiles) {
+  if (!inputFiles || inputFiles.length === 0) {
+    return [];
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (const inputFile of inputFiles) {
+    const absolutePath = path42.resolve(inputFile);
+    if (!unique.has(absolutePath)) {
+      unique.set(absolutePath, absolutePath);
+    }
+  }
+  return Array.from(unique.values());
+}
+function buildMandatoryPrereadBlock2(guidelineFiles, inputFiles) {
+  if (guidelineFiles.length === 0 && inputFiles.length === 0) {
+    return "";
+  }
+  const buildList = (files) => files.map((absolutePath) => {
+    const fileName = path42.basename(absolutePath);
+    const fileUri = pathToFileUri22(absolutePath);
+    return `* [${fileName}](${fileUri})`;
+  });
+  const sections = [];
+  if (guidelineFiles.length > 0) {
+    sections.push(`Read all guideline files:
+${buildList(guidelineFiles).join("\n")}.`);
+  }
+  if (inputFiles.length > 0) {
+    sections.push(`Read all input files:
+${buildList(inputFiles).join("\n")}.`);
+  }
+  sections.push(
+    "If any file is missing, fail with ERROR: missing-file <filename> and stop.",
+    "Then apply system_instructions on the user query below."
+  );
+  return sections.join("\n");
+}
+function pathToFileUri22(filePath) {
+  const absolutePath = path42.isAbsolute(filePath) ? filePath : path42.resolve(filePath);
+  const normalizedPath = absolutePath.replace(/\\/g, "/");
+  if (/^[a-zA-Z]:\//.test(normalizedPath)) {
+    return `file:///${normalizedPath}`;
+  }
+  return `file://${normalizedPath}`;
+}
+var execAsync22 = promisify22(execCallback);
+var WORKSPACE_PREFIX = "agentv-codex-";
+var PROMPT_FILENAME = "prompt.md";
+var FILES_DIR = "files";
+var JSONL_TYPE_ITEM_COMPLETED = "item.completed";
+var CodexProvider = class {
+  id;
+  kind = "codex";
+  targetName;
+  supportsBatch = false;
+  config;
+  runCodex;
+  environmentCheck;
+  resolvedExecutable;
+  constructor(targetName, config, runner = defaultCodexRunner) {
+    this.id = `codex:${targetName}`;
+    this.targetName = targetName;
+    this.config = config;
+    this.runCodex = runner;
+  }
+  async invoke(request) {
+    if (request.signal?.aborted) {
+      throw new Error("Codex provider request was aborted before execution");
+    }
+    await this.ensureEnvironmentReady();
+    const inputFiles = normalizeInputFiles2(request.inputFiles);
+    const originalGuidelines = new Set(
+      collectGuidelineFiles2(inputFiles, request.guideline_patterns).map((file) => path52.resolve(file))
+    );
+    const workspaceRoot = await this.createWorkspace();
+    try {
+      const { mirroredInputFiles, guidelineMirrors } = await this.mirrorInputFiles(
+        inputFiles,
+        workspaceRoot,
+        originalGuidelines
+      );
+      const promptContent = buildPromptDocument2(request, mirroredInputFiles, {
+        guidelinePatterns: request.guideline_patterns,
+        guidelineOverrides: guidelineMirrors
+      });
+      const promptFile = path52.join(workspaceRoot, PROMPT_FILENAME);
+      await writeFile3(promptFile, promptContent, "utf8");
+      const args = this.buildCodexArgs();
+      const cwd = this.resolveCwd(workspaceRoot);
+      const result = await this.executeCodex(args, cwd, promptContent, request.signal);
+      if (result.timedOut) {
+        throw new Error(
+          `Codex CLI timed out${formatTimeoutSuffix2(this.config.timeoutMs ?? void 0)}`
+        );
+      }
+      if (result.exitCode !== 0) {
+        const detail = pickDetail(result.stderr, result.stdout);
+        const prefix = `Codex CLI exited with code ${result.exitCode}`;
+        throw new Error(detail ? `${prefix}: ${detail}` : prefix);
+      }
+      const parsed = parseCodexJson(result.stdout);
+      const assistantText = extractAssistantText(parsed);
+      return {
+        text: assistantText,
+        raw: {
+          response: parsed,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode,
+          args,
+          executable: this.resolvedExecutable ?? this.config.executable,
+          promptFile,
+          workspace: workspaceRoot,
+          inputFiles: mirroredInputFiles
+        }
+      };
+    } finally {
+      await this.cleanupWorkspace(workspaceRoot);
+    }
+  }
+  async ensureEnvironmentReady() {
+    if (!this.environmentCheck) {
+      this.environmentCheck = this.validateEnvironment();
+    }
+    await this.environmentCheck;
+  }
+  async validateEnvironment() {
+    this.resolvedExecutable = await locateExecutable(this.config.executable);
+  }
+  resolveCwd(workspaceRoot) {
+    if (!this.config.cwd) {
+      return workspaceRoot;
+    }
+    return path52.resolve(this.config.cwd);
+  }
+  buildCodexArgs() {
+    const args = ["--ask-for-approval", "never", "exec", "--json", "--color", "never", "--skip-git-repo-check"];
+    if (this.config.args && this.config.args.length > 0) {
+      args.push(...this.config.args);
+    }
+    args.push("-");
+    return args;
+  }
+  async executeCodex(args, cwd, promptContent, signal) {
+    try {
+      return await this.runCodex({
+        executable: this.resolvedExecutable ?? this.config.executable,
+        args,
+        cwd,
+        prompt: promptContent,
+        timeoutMs: this.config.timeoutMs,
+        env: process.env,
+        signal
+      });
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        throw new Error(
+          `Codex executable '${this.config.executable}' was not found. Update the target settings.executable or add it to PATH.`
+        );
+      }
+      throw error;
+    }
+  }
+  async mirrorInputFiles(inputFiles, workspaceRoot, guidelineOriginals) {
+    if (!inputFiles || inputFiles.length === 0) {
+      return {
+        mirroredInputFiles: void 0,
+        guidelineMirrors: /* @__PURE__ */ new Set()
+      };
+    }
+    const filesRoot = path52.join(workspaceRoot, FILES_DIR);
+    await mkdir3(filesRoot, { recursive: true });
+    const mirrored = [];
+    const guidelineMirrors = /* @__PURE__ */ new Set();
+    const nameCounts = /* @__PURE__ */ new Map();
+    for (const inputFile of inputFiles) {
+      const absoluteSource = path52.resolve(inputFile);
+      const baseName = path52.basename(absoluteSource);
+      const count = nameCounts.get(baseName) ?? 0;
+      nameCounts.set(baseName, count + 1);
+      const finalName = count === 0 ? baseName : `${baseName}.${count}`;
+      const destination = path52.join(filesRoot, finalName);
+      await copyFile2(absoluteSource, destination);
+      const resolvedDestination = path52.resolve(destination);
+      mirrored.push(resolvedDestination);
+      if (guidelineOriginals.has(absoluteSource)) {
+        guidelineMirrors.add(resolvedDestination);
+      }
+    }
+    return {
+      mirroredInputFiles: mirrored,
+      guidelineMirrors
+    };
+  }
+  async createWorkspace() {
+    return await mkdtemp(path52.join(tmpdir(), WORKSPACE_PREFIX));
+  }
+  async cleanupWorkspace(workspaceRoot) {
+    try {
+      await rm2(workspaceRoot, { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+async function locateExecutable(candidate) {
+  const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
+  if (includesPathSeparator) {
+    const resolved = path52.isAbsolute(candidate) ? candidate : path52.resolve(candidate);
+    const executablePath = await ensureWindowsExecutableVariant(resolved);
+    await access22(executablePath, constants22.F_OK);
+    return executablePath;
+  }
+  const locator = process.platform === "win32" ? "where" : "which";
+  try {
+    const { stdout } = await execAsync22(`${locator} ${candidate}`);
+    const lines = stdout.split(/\r?\n/).map((line2) => line2.trim()).filter((line2) => line2.length > 0);
+    const preferred = selectExecutableCandidate(lines);
+    if (preferred) {
+      const executablePath = await ensureWindowsExecutableVariant(preferred);
+      await access22(executablePath, constants22.F_OK);
+      return executablePath;
+    }
+  } catch {
+  }
+  throw new Error(`Codex executable '${candidate}' was not found on PATH`);
+}
+function selectExecutableCandidate(candidates) {
+  if (candidates.length === 0) {
+    return void 0;
+  }
+  if (process.platform !== "win32") {
+    return candidates[0];
+  }
+  const extensions = getWindowsExecutableExtensions();
+  for (const ext of extensions) {
+    const match = candidates.find((candidate) => candidate.toLowerCase().endsWith(ext));
+    if (match) {
+      return match;
+    }
+  }
+  return candidates[0];
+}
+async function ensureWindowsExecutableVariant(candidate) {
+  if (process.platform !== "win32") {
+    return candidate;
+  }
+  if (hasExecutableExtension(candidate)) {
+    return candidate;
+  }
+  const extensions = getWindowsExecutableExtensions();
+  for (const ext of extensions) {
+    const withExtension = `${candidate}${ext}`;
+    try {
+      await access22(withExtension, constants22.F_OK);
+      return withExtension;
+    } catch {
+    }
+  }
+  return candidate;
+}
+function hasExecutableExtension(candidate) {
+  const lower = candidate.toLowerCase();
+  return getWindowsExecutableExtensions().some((ext) => lower.endsWith(ext));
+}
+var DEFAULT_WINDOWS_EXTENSIONS = [".com", ".exe", ".bat", ".cmd", ".ps1"];
+function getWindowsExecutableExtensions() {
+  if (process.platform !== "win32") {
+    return [];
+  }
+  const fromEnv = process.env.PATHEXT?.split(";").map((ext) => ext.trim().toLowerCase()).filter((ext) => ext.length > 0);
+  return fromEnv && fromEnv.length > 0 ? fromEnv : DEFAULT_WINDOWS_EXTENSIONS;
+}
+function parseCodexJson(output) {
+  const trimmed = output.trim();
+  if (trimmed.length === 0) {
+    throw new Error("Codex CLI produced no output in --json mode");
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const lineObjects = parseJsonLines(trimmed);
+    if (lineObjects) {
+      return lineObjects;
+    }
+    const lastBrace = trimmed.lastIndexOf("{");
+    if (lastBrace >= 0) {
+      const candidate = trimmed.slice(lastBrace);
+      try {
+        return JSON.parse(candidate);
+      } catch {
+      }
+    }
+    const preview = trimmed.slice(0, 200);
+    throw new Error(`Codex CLI emitted invalid JSON: ${preview}${trimmed.length > 200 ? "\u2026" : ""}`);
+  }
+}
+function extractAssistantText(parsed) {
+  if (Array.isArray(parsed)) {
+    const text = extractFromEventStream(parsed);
+    if (text) {
+      return text;
+    }
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Codex CLI JSON response did not include an assistant message");
+  }
+  const record = parsed;
+  const eventText = extractFromEvent(record);
+  if (eventText) {
+    return eventText;
+  }
+  const messages = Array.isArray(record.messages) ? record.messages : void 0;
+  if (messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+      const entry = messages[index];
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const role = entry.role;
+      if (role !== "assistant") {
+        continue;
+      }
+      const content = entry.content;
+      const flattened = flattenContent(content);
+      if (flattened) {
+        return flattened;
+      }
+    }
+  }
+  const response = record.response;
+  if (response && typeof response === "object") {
+    const content = response.content;
+    const flattened = flattenContent(content);
+    if (flattened) {
+      return flattened;
+    }
+  }
+  const output = record.output;
+  const flattenedOutput = flattenContent(output);
+  if (flattenedOutput) {
+    return flattenedOutput;
+  }
+  throw new Error("Codex CLI JSON response did not include an assistant message");
+}
+function extractFromEventStream(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const candidate = events[index];
+    const text = extractFromEvent(candidate);
+    if (text) {
+      return text;
+    }
+  }
+  return void 0;
+}
+function extractFromEvent(event) {
+  if (!event || typeof event !== "object") {
+    return void 0;
+  }
+  const record = event;
+  const type = typeof record.type === "string" ? record.type : void 0;
+  if (type === JSONL_TYPE_ITEM_COMPLETED) {
+    const item = record.item;
+    const text = extractFromItem(item);
+    if (text) {
+      return text;
+    }
+  }
+  const output = record.output ?? record.content;
+  const flattened = flattenContent(output);
+  if (flattened) {
+    return flattened;
+  }
+  return void 0;
+}
+function extractFromItem(item) {
+  if (!item || typeof item !== "object") {
+    return void 0;
+  }
+  const record = item;
+  const itemType = typeof record.type === "string" ? record.type : void 0;
+  if (itemType === "agent_message" || itemType === "response" || itemType === "output") {
+    const text = flattenContent(record.text ?? record.content ?? record.output);
+    if (text) {
+      return text;
+    }
+  }
+  return void 0;
+}
+function flattenContent(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((segment) => {
+      if (typeof segment === "string") {
+        return segment;
+      }
+      if (segment && typeof segment === "object" && "text" in segment) {
+        const text = segment.text;
+        return typeof text === "string" ? text : void 0;
+      }
+      return void 0;
+    }).filter((part) => typeof part === "string" && part.length > 0);
+    return parts.length > 0 ? parts.join(" \n") : void 0;
+  }
+  if (value && typeof value === "object" && "text" in value) {
+    const text = value.text;
+    return typeof text === "string" ? text : void 0;
+  }
+  return void 0;
+}
+function parseJsonLines(output) {
+  const lines = output.split(/\r?\n/).map((line2) => line2.trim()).filter((line2) => line2.length > 0);
+  if (lines.length <= 1) {
+    return void 0;
+  }
+  const parsed = [];
+  for (const line2 of lines) {
+    try {
+      parsed.push(JSON.parse(line2));
+    } catch {
+      return void 0;
+    }
+  }
+  return parsed;
+}
+function pickDetail(stderr, stdout) {
+  const errorText = stderr.trim();
+  if (errorText.length > 0) {
+    return errorText;
+  }
+  const stdoutText = stdout.trim();
+  return stdoutText.length > 0 ? stdoutText : void 0;
+}
+function formatTimeoutSuffix2(timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return "";
+  }
+  const seconds = Math.ceil(timeoutMs / 1e3);
+  return ` after ${seconds}s`;
+}
+async function defaultCodexRunner(options) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn2(options.executable, options.args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: shouldShellExecute(options.executable)
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (options.signal) {
+      if (options.signal.aborted) {
+        onAbort();
+      } else {
+        options.signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    let timeoutHandle;
+    if (options.timeoutMs && options.timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+      }, options.timeoutMs);
+      timeoutHandle.unref?.();
+    }
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.stdin.end(options.prompt);
+    const cleanup = () => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      if (options.signal) {
+        options.signal.removeEventListener("abort", onAbort);
+      }
+    };
+    child.on("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      cleanup();
+      resolve({
+        stdout,
+        stderr,
+        exitCode: typeof code === "number" ? code : -1,
+        timedOut
+      });
+    });
+  });
+}
+function shouldShellExecute(executable) {
+  if (process.platform !== "win32") {
+    return false;
+  }
+  const lower = executable.toLowerCase();
+  return lower.endsWith(".cmd") || lower.endsWith(".bat") || lower.endsWith(".ps1");
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -11901,14 +13310,14 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await access22(filePath, constants22.F_OK);
+    await access32(filePath, constants32.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path32.resolve(filePath);
+  const absolutePath = path62.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
@@ -11933,6 +13342,10 @@ function createProvider(target) {
       return new AnthropicProvider(target.name, target.config);
     case "gemini":
       return new GeminiProvider(target.name, target.config);
+    case "cli":
+      return new CliProvider(target.name, target.config);
+    case "codex":
+      return new CodexProvider(target.name, target.config);
     case "mock":
       return new MockProvider(target.name, target.config);
     case "vscode":
@@ -11944,222 +13357,28 @@ function createProvider(target) {
     }
   }
 }
-var KEY_TERM_MATCH_THRESHOLD = 0.5;
-var ACTION_WORDS = /* @__PURE__ */ new Set([
-  "use",
-  "avoid",
-  "prefer",
-  "replace",
-  "consider",
-  "ensure",
-  "remove",
-  "add"
-]);
-var STOP_WORDS = /* @__PURE__ */ new Set([
-  "the",
-  "a",
-  "an",
-  "and",
-  "or",
-  "but",
-  "in",
-  "on",
-  "at",
-  "to",
-  "for",
-  "of",
-  "with",
-  "by",
-  "is",
-  "are",
-  "was",
-  "were",
-  "be",
-  "been",
-  "being",
-  "have",
-  "has",
-  "had",
-  "do",
-  "does",
-  "did",
-  "will",
-  "would",
-  "could",
-  "should"
-]);
-var ERROR_PREFIXES = [
-  "error:",
-  "err:",
-  "vs code command failed",
-  "exception",
-  "traceback",
-  "no response file was generated",
-  "timed out",
-  "cli not found"
-];
-function extractAspects(expectedResponse) {
-  const lines = expectedResponse.split(/\r?\n/).map((line2) => line2.trim());
-  const aspects = [];
-  for (const line2 of lines) {
-    if (line2.length === 0) {
-      continue;
-    }
-    const bulletMatch = /^([-*•]|[0-9]+\.)\s*(.+)$/.exec(line2);
-    if (bulletMatch) {
-      const normalized = normalizeAspect(bulletMatch[2]);
-      if (normalized.length > 0) {
-        aspects.push(normalized);
-      }
-      continue;
-    }
-    const lowered = line2.toLowerCase();
-    if (Array.from(ACTION_WORDS).some((word) => lowered.startsWith(word))) {
-      const normalized = normalizeAspect(line2);
-      if (normalized.length > 0) {
-        aspects.push(normalized);
-      }
-    }
-  }
-  return aspects;
-}
-function calculateHits(candidateResponse, expectedAspects) {
-  const { normalizedText, words } = normalizeCandidate(candidateResponse);
-  const hits = [];
-  for (const aspect of expectedAspects) {
-    if (matchesAspect(aspect, normalizedText, words)) {
-      hits.push(aspect);
-    }
-  }
-  return hits;
-}
-function scoreCandidateResponse(candidateResponse, expectedAspects) {
-  if (expectedAspects.length === 0) {
-    if (isErrorLike(candidateResponse)) {
-      return {
-        score: 0,
-        hits: [],
-        misses: ["Model produced an error instead of an answer."],
-        hitCount: 0,
-        totalAspects: 0,
-        rawAspects: []
-      };
-    }
-    return {
-      score: 1,
-      hits: [],
-      misses: [],
-      hitCount: 0,
-      totalAspects: 0,
-      rawAspects: []
-    };
-  }
-  const hits = calculateHits(candidateResponse, expectedAspects);
-  const misses = expectedAspects.filter((aspect) => !hits.includes(aspect));
-  const score = expectedAspects.length > 0 ? hits.length / expectedAspects.length : 0;
-  return {
-    score,
-    hits,
-    misses,
-    hitCount: hits.length,
-    totalAspects: expectedAspects.length,
-    rawAspects: expectedAspects
-  };
-}
-function isErrorLike(text) {
-  if (!text) {
-    return false;
-  }
-  const lowered = text.trim().toLowerCase();
-  return ERROR_PREFIXES.some((prefix) => lowered.startsWith(prefix));
-}
-function normalizeAspect(aspect) {
-  const sanitized = aspect.toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
-  return sanitized;
-}
-function normalizeCandidate(candidate) {
-  const lowered = candidate.toLowerCase();
-  const normalizedText = lowered.replace(/[^\w\s]/g, " ");
-  const words = new Set(normalizedText.split(/\s+/).filter((word) => word.length > 0));
-  return { normalizedText, words };
-}
-function matchesAspect(aspect, candidateNormalized, candidateWords) {
-  const keyTerms = extractKeyTerms(aspect);
-  if (keyTerms.length === 0) {
-    return false;
-  }
-  const matches = keyTerms.filter((term) => candidateWords.has(term)).length;
-  const ratio = matches / keyTerms.length;
-  if (ratio >= KEY_TERM_MATCH_THRESHOLD) {
-    return true;
-  }
-  const aspectWords = aspect.split(" ");
-  if (aspectWords.length >= 2) {
-    for (let index = 0; index < aspectWords.length - 1; index += 1) {
-      const phrase = `${aspectWords[index]} ${aspectWords[index + 1]}`;
-      if (candidateNormalized.includes(phrase)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function extractKeyTerms(aspect, maxTerms = 5) {
-  const terms = [];
-  const words = aspect.split(" ");
-  for (const word of words) {
-    if (word.length <= 2) {
-      continue;
-    }
-    if (STOP_WORDS.has(word)) {
-      continue;
-    }
-    terms.push(word);
-    if (terms.length >= maxTerms) {
-      break;
-    }
-  }
-  return terms;
-}
-var HeuristicGrader = class {
-  kind = "heuristic";
-  grade(context2) {
-    const expectedAspects = extractAspects(context2.evalCase.expected_assistant_raw);
-    const result = scoreCandidateResponse(context2.candidate, expectedAspects);
-    const misses = [...result.misses];
-    if (expectedAspects.length === 0 && isErrorLike(context2.candidate)) {
-      const firstLine = context2.candidate.split(/\r?\n/)[0]?.trim();
-      if (firstLine && !misses.includes(firstLine)) {
-        misses.unshift(firstLine);
-      }
-    }
-    return {
-      score: result.score,
-      hits: result.hits,
-      misses,
-      expectedAspectCount: result.totalAspects,
-      rawAspects: result.rawAspects
-    };
-  }
-};
-var QualityGrader = class {
+var LlmJudgeEvaluator = class {
   kind = "llm_judge";
   resolveJudgeProvider;
   maxOutputTokens;
   temperature;
+  customPrompt;
   constructor(options) {
     this.resolveJudgeProvider = options.resolveJudgeProvider;
     this.maxOutputTokens = options.maxOutputTokens;
     this.temperature = options.temperature;
+    this.customPrompt = options.customPrompt;
   }
-  async grade(context2) {
+  async evaluate(context2) {
     const judgeProvider = await this.resolveJudgeProvider(context2);
     if (!judgeProvider) {
       throw new Error("No judge provider available for LLM grading");
     }
     const prompt = buildQualityPrompt(context2.evalCase, context2.candidate);
+    const systemPrompt = context2.systemPrompt ?? this.customPrompt ?? QUALITY_SYSTEM_PROMPT;
     const metadata = {
-      systemPrompt: QUALITY_SYSTEM_PROMPT
+      ...systemPrompt !== void 0 ? { systemPrompt } : {},
+      ...context2.judgeModel !== void 0 ? { model: context2.judgeModel } : {}
     };
     const response = await judgeProvider.invoke({
       prompt,
@@ -12174,12 +13393,13 @@ var QualityGrader = class {
     const hits = Array.isArray(parsed.hits) ? parsed.hits.filter(isNonEmptyString).slice(0, 4) : [];
     const misses = Array.isArray(parsed.misses) ? parsed.misses.filter(isNonEmptyString).slice(0, 4) : [];
     const reasoning = parsed.reasoning ?? response.reasoning;
-    const graderRawRequest = {
+    const evaluatorRawRequest = {
       id: randomUUID(),
       provider: judgeProvider.id,
       prompt,
-      systemPrompt: QUALITY_SYSTEM_PROMPT,
-      target: context2.target.name
+      target: context2.target.name,
+      ...systemPrompt !== void 0 ? { systemPrompt } : {},
+      ...context2.judgeModel !== void 0 ? { model: context2.judgeModel } : {}
     };
     return {
       score,
@@ -12187,7 +13407,7 @@ var QualityGrader = class {
       misses,
       expectedAspectCount: hits.length + misses.length || 1,
       reasoning,
-      graderRawRequest
+      evaluatorRawRequest
     };
   }
 };
@@ -12302,8 +13522,114 @@ function extractJsonBlob(text) {
   const match = text.match(/\{[\s\S]*\}/);
   return match?.[0];
 }
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+var CodeEvaluator = class {
+  kind = "code";
+  script;
+  cwd;
+  agentTimeoutMs;
+  constructor(options) {
+    this.script = options.script;
+    this.cwd = options.cwd;
+    this.agentTimeoutMs = options.agentTimeoutMs;
+  }
+  async evaluate(context2) {
+    const inputPayload = JSON.stringify(
+      {
+        task: context2.evalCase.task,
+        outcome: context2.evalCase.outcome,
+        expected: context2.evalCase.expected_assistant_raw,
+        output: context2.candidate,
+        system_message: context2.promptInputs.systemMessage ?? "",
+        guideline_paths: context2.evalCase.guideline_paths,
+        attachments: context2.evalCase.file_paths,
+        user_segments: context2.evalCase.user_segments
+      },
+      null,
+      2
+    );
+    try {
+      const stdout = await executeScript(this.script, inputPayload, this.agentTimeoutMs, this.cwd);
+      const parsed = parseJsonSafe(stdout);
+      const score = clampScore(typeof parsed?.score === "number" ? parsed.score : 0);
+      const hits = Array.isArray(parsed?.hits) ? parsed.hits.filter(isNonEmptyString) : [];
+      const misses = Array.isArray(parsed?.misses) ? parsed.misses.filter(isNonEmptyString) : [];
+      const reasoning = typeof parsed?.reasoning === "string" ? parsed.reasoning : void 0;
+      return {
+        score,
+        hits,
+        misses,
+        expectedAspectCount: hits.length + misses.length || 1,
+        reasoning,
+        evaluatorRawRequest: {
+          script: this.script,
+          ...this.cwd ? { cwd: this.cwd } : {}
+        }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        score: 0,
+        hits: [],
+        misses: [`Code evaluator failed: ${message}`],
+        expectedAspectCount: 1,
+        reasoning: message,
+        evaluatorRawRequest: {
+          script: this.script,
+          ...this.cwd ? { cwd: this.cwd } : {},
+          error: message
+        }
+      };
+    }
+  }
+};
+async function executeScript(scriptPath, input, agentTimeoutMs, cwd) {
+  const { spawn: spawn22 } = await import("node:child_process");
+  return await new Promise((resolve, reject) => {
+    const child = spawn22(scriptPath, {
+      shell: true,
+      cwd
+    });
+    let stdout = "";
+    let stderr = "";
+    const timeout = agentTimeoutMs ? setTimeout(() => {
+      child.kill();
+      reject(new Error(`Code evaluator timed out after ${agentTimeoutMs}ms`));
+    }, agentTimeoutMs) : void 0;
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (error) => {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      if (timeout !== void 0) {
+        clearTimeout(timeout);
+      }
+      if (code && code !== 0 && stderr.length > 0) {
+        reject(new Error(`Code evaluator exited with code ${code}: ${stderr.trim()}`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+    child.stdin?.write(input);
+    child.stdin?.end();
+  });
+}
+function parseJsonSafe(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return void 0;
+  }
 }
 var Node = class {
   value;
@@ -12445,7 +13771,7 @@ async function runEvaluation(options) {
     targets,
     env,
     providerFactory,
-    graders,
+    evaluators,
     maxRetries,
     agentTimeoutMs,
     promptDumpDir,
@@ -12504,8 +13830,14 @@ async function runEvaluation(options) {
     }
     return getOrCreateProvider(resolvedJudge);
   };
-  const graderRegistry = buildGraderRegistry(graders, resolveJudgeProvider);
+  const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveJudgeProvider);
   const primaryProvider = getOrCreateProvider(target);
+  const providerSupportsBatch = target.providerBatching === true && primaryProvider.supportsBatch === true && typeof primaryProvider.invokeBatch === "function";
+  if (target.providerBatching && !providerSupportsBatch && verbose) {
+    console.warn(
+      `Provider batching requested for target '${target.name}', but provider does not advertise batch support. Using per-case dispatch.`
+    );
+  }
   if (onProgress && filteredEvalCases.length > 0) {
     for (let i6 = 0; i6 < filteredEvalCases.length; i6++) {
       await onProgress({
@@ -12515,6 +13847,28 @@ async function runEvaluation(options) {
       });
     }
   }
+  if (providerSupportsBatch) {
+    try {
+      return await runBatchEvaluation({
+        evalCases: filteredEvalCases,
+        provider: primaryProvider,
+        target,
+        evaluatorRegistry,
+        promptDumpDir,
+        nowFn: now ?? (() => /* @__PURE__ */ new Date()),
+        onProgress,
+        onResult,
+        verbose,
+        resolveJudgeProvider,
+        agentTimeoutMs
+      });
+    } catch (error) {
+      if (verbose) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Provider batch execution failed, falling back to per-case dispatch: ${message}`);
+      }
+    }
+  }
   const workers = options.maxConcurrency ?? target.workers ?? 1;
   const limit = pLimit(workers);
   let nextWorkerId = 1;
@@ -12537,7 +13891,7 @@ async function runEvaluation(options) {
           evalCase,
           provider: primaryProvider,
           target,
-          graders: graderRegistry,
+          evaluators: evaluatorRegistry,
           maxRetries,
           agentTimeoutMs,
           promptDumpDir,
@@ -12598,12 +13952,118 @@ async function runEvaluation(options) {
   }
   return results;
 }
+async function runBatchEvaluation(options) {
+  const {
+    evalCases,
+    provider,
+    target,
+    evaluatorRegistry,
+    promptDumpDir,
+    nowFn,
+    onProgress,
+    onResult,
+    resolveJudgeProvider,
+    agentTimeoutMs
+  } = options;
+  const promptInputsList = [];
+  for (const evalCase of evalCases) {
+    const promptInputs = await buildPromptInputs(evalCase);
+    if (promptDumpDir) {
+      await dumpPrompt(promptDumpDir, evalCase, promptInputs);
+    }
+    promptInputsList.push(promptInputs);
+  }
+  const batchRequests = evalCases.map((evalCase, index) => {
+    const promptInputs = promptInputsList[index];
+    return {
+      prompt: promptInputs.request,
+      guidelines: promptInputs.guidelines,
+      guideline_patterns: evalCase.guideline_patterns,
+      inputFiles: evalCase.file_paths,
+      evalCaseId: evalCase.id,
+      metadata: {
+        systemPrompt: promptInputs.systemMessage ?? ""
+      }
+    };
+  });
+  const batchResponse = await provider.invokeBatch?.(batchRequests);
+  if (!Array.isArray(batchResponse)) {
+    throw new Error("Provider batching failed: invokeBatch did not return an array");
+  }
+  if (batchResponse.length !== evalCases.length) {
+    throw new Error(
+      `Provider batching failed: expected ${evalCases.length} responses, received ${batchResponse.length}`
+    );
+  }
+  if (onProgress) {
+    const startedAt = Date.now();
+    for (let i6 = 0; i6 < evalCases.length; i6++) {
+      await onProgress({
+        workerId: 1,
+        evalId: evalCases[i6].id,
+        status: "running",
+        startedAt
+      });
+    }
+  }
+  const results = [];
+  for (let i6 = 0; i6 < evalCases.length; i6++) {
+    const evalCase = evalCases[i6];
+    const promptInputs = promptInputsList[i6];
+    const providerResponse = batchResponse[i6];
+    let result;
+    try {
+      result = await evaluateCandidate({
+        evalCase,
+        candidate: providerResponse.text ?? "",
+        target,
+        provider,
+        evaluators: evaluatorRegistry,
+        promptInputs,
+        nowFn,
+        attempt: 0,
+        judgeProvider: await resolveJudgeProvider(target),
+        agentTimeoutMs
+      });
+    } catch (error) {
+      const errorResult = buildErrorResult(evalCase, target.name, nowFn(), error, promptInputs);
+      results.push(errorResult);
+      if (onResult) {
+        await onResult(errorResult);
+      }
+      if (onProgress) {
+        await onProgress({
+          workerId: 1,
+          evalId: evalCase.id,
+          status: "failed",
+          completedAt: Date.now(),
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      continue;
+    }
+    results.push(result);
+    if (onResult) {
+      await onResult(result);
+    }
+    if (onProgress) {
+      await onProgress({
+        workerId: 1,
+        evalId: evalCase.id,
+        status: "completed",
+        startedAt: 0,
+        completedAt: Date.now()
+      });
+    }
+  }
+  return results;
+}
 async function runEvalCase(options) {
   const {
     evalCase,
     provider,
     target,
-    graders,
+    evaluators,
     now,
     maxRetries,
     agentTimeoutMs,
@@ -12658,27 +14118,49 @@ async function runEvalCase(options) {
   if (cacheKey && cache && !cachedResponse) {
     await cache.set(cacheKey, providerResponse);
   }
-  const graderKind = evalCase.grader ?? "heuristic";
-  const activeGrader = graders[graderKind] ?? graders.heuristic;
-  if (!activeGrader) {
-    throw new Error(`No grader registered for kind '${graderKind}'`);
-  }
-  let grade;
   try {
-    const gradeTimestamp = nowFn();
-    grade = await activeGrader.grade({
+    return await evaluateCandidate({
       evalCase,
       candidate: providerResponse.text ?? "",
       target,
       provider,
-      attempt,
+      evaluators,
       promptInputs,
-      now: gradeTimestamp,
-      judgeProvider
+      nowFn,
+      attempt,
+      judgeProvider,
+      agentTimeoutMs
     });
   } catch (error) {
     return buildErrorResult(evalCase, target.name, nowFn(), error, promptInputs);
   }
+}
+async function evaluateCandidate(options) {
+  const {
+    evalCase,
+    candidate,
+    target,
+    provider,
+    evaluators,
+    promptInputs,
+    nowFn,
+    attempt,
+    judgeProvider,
+    agentTimeoutMs
+  } = options;
+  const gradeTimestamp = nowFn();
+  const { score, evaluatorResults } = await runEvaluatorsForCase({
+    evalCase,
+    candidate,
+    target,
+    provider,
+    evaluators,
+    attempt,
+    promptInputs,
+    now: gradeTimestamp,
+    judgeProvider,
+    agentTimeoutMs
+  });
   const completedAt = nowFn();
   const rawRequest = {
     request: promptInputs.request,
@@ -12689,18 +14171,191 @@ async function runEvalCase(options) {
   return {
     eval_id: evalCase.id,
     conversation_id: evalCase.conversation_id,
-    score: grade.score,
-    hits: grade.hits,
-    misses: grade.misses,
-    model_answer: providerResponse.text ?? "",
-    expected_aspect_count: grade.expectedAspectCount,
+    score: score.score,
+    hits: score.hits,
+    misses: score.misses,
+    model_answer: candidate,
+    expected_aspect_count: score.expectedAspectCount,
     target: target.name,
     timestamp: completedAt.toISOString(),
-    reasoning: grade.reasoning,
-    raw_aspects: grade.rawAspects,
+    reasoning: score.reasoning,
+    raw_aspects: score.rawAspects,
     raw_request: rawRequest,
-    grader_raw_request: grade.graderRawRequest
+    evaluator_raw_request: evaluatorResults ? void 0 : score.evaluatorRawRequest,
+    evaluator_results: evaluatorResults
+  };
+}
+async function runEvaluatorsForCase(options) {
+  const { evalCase, candidate, target, provider, evaluators, attempt, promptInputs, now, judgeProvider, agentTimeoutMs } = options;
+  if (evalCase.evaluators && evalCase.evaluators.length > 0) {
+    return runEvaluatorList({
+      evalCase,
+      evaluators: evalCase.evaluators,
+      candidate,
+      target,
+      provider,
+      evaluatorRegistry: evaluators,
+      attempt,
+      promptInputs,
+      now,
+      judgeProvider,
+      agentTimeoutMs
+    });
+  }
+  const evaluatorKind = evalCase.evaluator ?? "llm_judge";
+  const activeEvaluator = evaluators[evaluatorKind] ?? evaluators.llm_judge;
+  if (!activeEvaluator) {
+    throw new Error(`No evaluator registered for kind '${evaluatorKind}'`);
+  }
+  const score = await activeEvaluator.evaluate({
+    evalCase,
+    candidate,
+    target,
+    provider,
+    attempt,
+    promptInputs,
+    now,
+    judgeProvider
+  });
+  return { score };
+}
+async function runEvaluatorList(options) {
+  const {
+    evalCase,
+    evaluators,
+    candidate,
+    target,
+    provider,
+    evaluatorRegistry,
+    attempt,
+    promptInputs,
+    now,
+    judgeProvider,
+    agentTimeoutMs
+  } = options;
+  const scored = [];
+  const evaluatorResults = [];
+  for (const evaluator of evaluators ?? []) {
+    try {
+      if (evaluator.type === "llm_judge") {
+        const score2 = await runLlmJudgeEvaluator({
+          config: evaluator,
+          evalCase,
+          candidate,
+          target,
+          provider,
+          evaluatorRegistry,
+          attempt,
+          promptInputs,
+          now,
+          judgeProvider
+        });
+        scored.push({ score: score2, name: evaluator.name, type: evaluator.type });
+        evaluatorResults.push({
+          name: evaluator.name,
+          type: evaluator.type,
+          score: score2.score,
+          hits: score2.hits,
+          misses: score2.misses,
+          reasoning: score2.reasoning,
+          evaluator_raw_request: score2.evaluatorRawRequest
+        });
+        continue;
+      }
+      if (evaluator.type === "code") {
+        const codeEvaluator = new CodeEvaluator({
+          script: evaluator.script,
+          cwd: evaluator.resolvedCwd ?? evaluator.cwd,
+          agentTimeoutMs
+        });
+        const score2 = await codeEvaluator.evaluate({
+          evalCase,
+          candidate,
+          target,
+          provider,
+          attempt,
+          promptInputs,
+          now
+        });
+        scored.push({ score: score2, name: evaluator.name, type: evaluator.type });
+        evaluatorResults.push({
+          name: evaluator.name,
+          type: evaluator.type,
+          score: score2.score,
+          hits: score2.hits,
+          misses: score2.misses,
+          reasoning: score2.reasoning,
+          evaluator_raw_request: score2.evaluatorRawRequest
+        });
+        continue;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const fallbackScore = {
+        score: 0,
+        hits: [],
+        misses: [`Evaluator '${evaluator.name}' failed: ${message}`],
+        expectedAspectCount: 1,
+        reasoning: message
+      };
+      scored.push({ score: fallbackScore, name: evaluator.name ?? "unknown", type: evaluator.type ?? "unknown" });
+      evaluatorResults.push({
+        name: evaluator.name ?? "unknown",
+        type: evaluator.type ?? "unknown",
+        score: 0,
+        hits: [],
+        misses: [`Evaluator '${evaluator.name ?? "unknown"}' failed: ${message}`],
+        reasoning: message
+      });
+    }
+  }
+  const aggregateScore = scored.length > 0 ? scored.reduce((total, entry) => total + entry.score.score, 0) / scored.length : 0;
+  const hits = scored.flatMap((entry) => entry.score.hits);
+  const misses = scored.flatMap((entry) => entry.score.misses);
+  const expectedAspectCount = scored.reduce((total, entry) => total + (entry.score.expectedAspectCount ?? 0), 0);
+  const rawAspects = scored.flatMap((entry) => entry.score.rawAspects ?? []);
+  const reasoningParts = scored.map((entry) => entry.score.reasoning ? `${entry.name}: ${entry.score.reasoning}` : void 0).filter(isNonEmptyString2);
+  const reasoning = reasoningParts.length > 0 ? reasoningParts.join(" | ") : void 0;
+  const score = {
+    score: aggregateScore,
+    hits,
+    misses,
+    expectedAspectCount,
+    reasoning,
+    rawAspects: rawAspects.length > 0 ? rawAspects : void 0
   };
+  return { score, evaluatorResults };
+}
+async function runLlmJudgeEvaluator(options) {
+  const { config, evalCase, candidate, target, provider, evaluatorRegistry, attempt, promptInputs, now, judgeProvider } = options;
+  const customPrompt = await resolveCustomPrompt(config);
+  return evaluatorRegistry.llm_judge.evaluate({
+    evalCase,
+    candidate,
+    target,
+    provider,
+    attempt,
+    promptInputs,
+    now,
+    judgeProvider,
+    systemPrompt: customPrompt,
+    evaluator: config,
+    judgeModel: config.model
+  });
+}
+async function resolveCustomPrompt(config) {
+  if (config.promptPath) {
+    try {
+      return await readFile4(config.promptPath, "utf8");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Could not read custom prompt at ${config.promptPath}: ${message}`);
+    }
+  }
+  return config.prompt;
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0;
 }
 function filterEvalCases(evalCases, evalId) {
   if (!evalId) {
@@ -12708,9 +14363,8 @@ function filterEvalCases(evalCases, evalId) {
   }
   return evalCases.filter((evalCase) => evalCase.id === evalId);
 }
-function buildGraderRegistry(overrides, resolveJudgeProvider) {
-  const heuristic = overrides?.heuristic ?? new HeuristicGrader();
-  const llmJudge = overrides?.llm_judge ?? new QualityGrader({
+function buildEvaluatorRegistry(overrides, resolveJudgeProvider) {
+  const llmJudge = overrides?.llm_judge ?? new LlmJudgeEvaluator({
     resolveJudgeProvider: async (context2) => {
       if (context2.judgeProvider) {
         return context2.judgeProvider;
@@ -12720,15 +14374,14 @@ function buildGraderRegistry(overrides, resolveJudgeProvider) {
   });
   return {
     ...overrides,
-    heuristic,
     llm_judge: llmJudge
   };
 }
 async function dumpPrompt(directory, evalCase, promptInputs) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `${timestamp}_${sanitizeFilename(evalCase.id)}.json`;
-  const filePath = path42.resolve(directory, filename);
-  await mkdir3(path42.dirname(filePath), { recursive: true });
+  const filePath = path72.resolve(directory, filename);
+  await mkdir22(path72.dirname(filePath), { recursive: true });
   const payload = {
     eval_id: evalCase.id,
     request: promptInputs.request,
@@ -12745,7 +14398,7 @@ function sanitizeFilename(value) {
   return sanitized.length > 0 ? sanitized : randomUUID2();
 }
 async function invokeProvider(provider, options) {
-  const { evalCase, target, promptInputs, attempt, agentTimeoutMs, signal } = options;
+  const { evalCase, promptInputs, attempt, agentTimeoutMs, signal } = options;
   const controller = new AbortController();
   const timeout = agentTimeoutMs ? setTimeout(() => controller.abort(), agentTimeoutMs) : void 0;
   if (signal) {
@@ -12756,7 +14409,7 @@ async function invokeProvider(provider, options) {
       prompt: promptInputs.request,
       guidelines: promptInputs.guidelines,
       guideline_patterns: evalCase.guideline_patterns,
-      attachments: evalCase.file_paths,
+      inputFiles: evalCase.file_paths,
       evalCaseId: evalCase.id,
       attempt,
       metadata: {
@@ -12825,19 +14478,19 @@ function createAgentKernel() {
 // src/commands/eval/run-eval.ts
 import { constants as constants6 } from "node:fs";
 import { access as access6, mkdir as mkdir6 } from "node:fs/promises";
-import path12 from "node:path";
+import path13 from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/commands/eval/env.ts
 import { config as loadDotenv } from "dotenv";
 import { constants as constants4 } from "node:fs";
 import { access as access4 } from "node:fs/promises";
-import path8 from "node:path";
+import path9 from "node:path";
 function uniqueDirs(directories) {
   const seen = /* @__PURE__ */ new Set();
   const result = [];
   for (const dir of directories) {
-    const absolute = path8.resolve(dir);
+    const absolute = path9.resolve(dir);
     if (seen.has(absolute)) {
       continue;
     }
@@ -12856,14 +14509,14 @@ async function fileExists4(filePath) {
 }
 function collectAncestorDirectories(start, boundary) {
   const directories = [];
-  const boundaryDir = path8.resolve(boundary);
-  let current = path8.resolve(start);
+  const boundaryDir = path9.resolve(boundary);
+  let current = path9.resolve(start);
   while (current !== void 0) {
     directories.push(current);
     if (current === boundaryDir) {
       break;
     }
-    const parent = path8.dirname(current);
+    const parent = path9.dirname(current);
     if (parent === current) {
       break;
     }
@@ -12873,7 +14526,7 @@ function collectAncestorDirectories(start, boundary) {
 }
 async function loadEnvFromHierarchy(options) {
   const { testFilePath, repoRoot, verbose } = options;
-  const testDir = path8.dirname(path8.resolve(testFilePath));
+  const testDir = path9.dirname(path9.resolve(testFilePath));
   const cwd = process.cwd();
   const searchDirs = uniqueDirs([
     ...collectAncestorDirectories(testDir, repoRoot),
@@ -12881,7 +14534,7 @@ async function loadEnvFromHierarchy(options) {
     cwd
   ]);
   for (const dir of searchDirs) {
-    const candidate = path8.join(dir, ".env");
+    const candidate = path9.join(dir, ".env");
     if (await fileExists4(candidate)) {
       loadDotenv({ path: candidate, override: false });
       if (verbose) {
@@ -13105,7 +14758,7 @@ var Mutex = class {
 // src/commands/eval/jsonl-writer.ts
 import { createWriteStream } from "node:fs";
 import { mkdir as mkdir4 } from "node:fs/promises";
-import path9 from "node:path";
+import path10 from "node:path";
 import { finished } from "node:stream/promises";
 var JsonlWriter = class _JsonlWriter {
   stream;
@@ -13115,7 +14768,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir4(path9.dirname(filePath), { recursive: true });
+    await mkdir4(path10.dirname(filePath), { recursive: true });
     const stream = createWriteStream(filePath, { flags: "w", encoding: "utf8" });
     return new _JsonlWriter(stream);
   }
@@ -13147,7 +14800,7 @@ var JsonlWriter = class _JsonlWriter {
 // src/commands/eval/yaml-writer.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path10 from "node:path";
+import path11 from "node:path";
 import { finished as finished2 } from "node:stream/promises";
 import { stringify as stringifyYaml } from "yaml";
 var YamlWriter = class _YamlWriter {
@@ -13159,7 +14812,7 @@ var YamlWriter = class _YamlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir5(path10.dirname(filePath), { recursive: true });
+    await mkdir5(path11.dirname(filePath), { recursive: true });
     const stream = createWriteStream2(filePath, { flags: "w", encoding: "utf8" });
     return new _YamlWriter(stream);
   }
@@ -13467,14 +15120,14 @@ function formatEvaluationSummary(summary) {
 
 // src/commands/eval/targets.ts
 import { constants as constants5 } from "node:fs";
-import { access as access5, readFile as readFile4 } from "node:fs/promises";
-import path11 from "node:path";
+import { access as access5, readFile as readFile5 } from "node:fs/promises";
+import path12 from "node:path";
 import { parse as parse4 } from "yaml";
 var TARGET_FILE_CANDIDATES = [
   "targets.yaml",
   "targets.yml",
-  path11.join(".agentv", "targets.yaml"),
-  path11.join(".agentv", "targets.yml")
+  path12.join(".agentv", "targets.yaml"),
+  path12.join(".agentv", "targets.yml")
 ];
 async function fileExists5(filePath) {
   try {
@@ -13486,7 +15139,7 @@ async function fileExists5(filePath) {
 }
 async function readTestSuiteTarget(testFilePath) {
   try {
-    const raw = await readFile4(path11.resolve(testFilePath), "utf8");
+    const raw = await readFile5(path12.resolve(testFilePath), "utf8");
     const parsed = parse4(raw);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const targetValue = parsed.target;
@@ -13501,12 +15154,12 @@ async function readTestSuiteTarget(testFilePath) {
 async function discoverTargetsFile(options) {
   const { explicitPath, testFilePath, repoRoot, cwd } = options;
   if (explicitPath) {
-    const resolvedExplicit = path11.resolve(explicitPath);
+    const resolvedExplicit = path12.resolve(explicitPath);
     if (await fileExists5(resolvedExplicit)) {
       return resolvedExplicit;
     }
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const nested = path11.join(resolvedExplicit, candidate);
+      const nested = path12.join(resolvedExplicit, candidate);
       if (await fileExists5(nested)) {
         return nested;
       }
@@ -13514,13 +15167,13 @@ async function discoverTargetsFile(options) {
     throw new Error(`targets.yaml not found at provided path: ${resolvedExplicit}`);
   }
   const directories = [...buildDirectoryChain(testFilePath, repoRoot)];
-  const resolvedCwd = path11.resolve(cwd);
+  const resolvedCwd = path12.resolve(cwd);
   if (!directories.includes(resolvedCwd)) {
     directories.push(resolvedCwd);
   }
   for (const directory of directories) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const fullPath = path11.join(directory, candidate);
+      const fullPath = path12.join(directory, candidate);
       if (await fileExists5(fullPath)) {
         return fullPath;
       }
@@ -13645,15 +15298,15 @@ async function ensureFileExists(filePath, description) {
   }
 }
 async function findRepoRoot(start) {
-  const fallback = path12.resolve(start);
+  const fallback = path13.resolve(start);
   let current = fallback;
   while (current !== void 0) {
-    const candidate = path12.join(current, ".git");
+    const candidate = path13.join(current, ".git");
     try {
       await access6(candidate, constants6.F_OK);
       return current;
     } catch {
-      const parent = path12.dirname(current);
+      const parent = path13.dirname(current);
       if (parent === current) {
         break;
       }
@@ -13663,21 +15316,21 @@ async function findRepoRoot(start) {
   return fallback;
 }
 function buildDefaultOutputPath(testFilePath, cwd, format) {
-  const testFileName = path12.basename(testFilePath);
+  const testFileName = path13.basename(testFilePath);
   const withoutExtension = testFileName.replace(/\.test\.ya?ml$/i, "").replace(/\.ya?ml$/i, "");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const baseName = withoutExtension.length > 0 ? withoutExtension : "results";
   const extension = getDefaultExtension(format);
-  return path12.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
+  return path13.join(cwd, ".agentv", "results", `${baseName}_${timestamp}${extension}`);
 }
 function resolvePromptDirectory(option, cwd) {
   if (option === void 0) {
     return void 0;
   }
   if (typeof option === "string" && option.trim().length > 0) {
-    return path12.resolve(cwd, option);
+    return path13.resolve(cwd, option);
   }
-  return path12.join(cwd, ".agentv", "prompts");
+  return path13.join(cwd, ".agentv", "prompts");
 }
 function createEvaluationCache() {
   const store = /* @__PURE__ */ new Map();
@@ -13693,7 +15346,7 @@ function createEvaluationCache() {
 async function runEvalCommand(input) {
   const options = normalizeOptions(input.rawOptions);
   const cwd = process.cwd();
-  const testFilePath = path12.resolve(input.testFile);
+  const testFilePath = path13.resolve(input.testFile);
   await ensureFileExists(testFilePath, "Test file");
   const repoRoot = await findRepoRoot(cwd);
   if (options.verbose) {
@@ -13719,7 +15372,7 @@ async function runEvalCommand(input) {
   const providerLabel = options.dryRun ? `${targetSelection.resolvedTarget.kind} (dry-run)` : targetSelection.resolvedTarget.kind;
   const targetMessage = options.verbose ? `Using target (${targetSelection.targetSource}): ${targetSelection.targetName} [provider=${providerLabel}] via ${targetSelection.targetsFilePath}` : `Using target: ${targetSelection.targetName} [provider=${providerLabel}]`;
   console.log(targetMessage);
-  const outputPath = options.outPath ? path12.resolve(options.outPath) : buildDefaultOutputPath(testFilePath, cwd, options.format);
+  const outputPath = options.outPath ? path13.resolve(options.outPath) : buildDefaultOutputPath(testFilePath, cwd, options.format);
   console.log(`Output path: ${outputPath}`);
   const promptDumpDir = resolvePromptDirectory(options.dumpPrompts, cwd);
   if (promptDumpDir) {
@@ -13811,7 +15464,7 @@ async function resolveEvaluationRunner() {
   if (!overridePath) {
     return runEvaluation;
   }
-  const resolved = path12.isAbsolute(overridePath) ? overridePath : path12.resolve(process.cwd(), overridePath);
+  const resolved = path13.isAbsolute(overridePath) ? overridePath : path13.resolve(process.cwd(), overridePath);
   const moduleUrl = pathToFileURL(resolved).href;
   const mod = await import(moduleUrl);
   const candidate = mod.runEvaluation;
@@ -13872,31 +15525,31 @@ function registerEvalCommand(program) {
 
 // src/commands/init/index.ts
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import path14 from "node:path";
+import path15 from "node:path";
 
 // src/templates/index.ts
 import { readFileSync } from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var TemplateManager = class {
   static getTemplates() {
-    const currentDir = path13.dirname(fileURLToPath2(import.meta.url));
+    const currentDir = path14.dirname(fileURLToPath2(import.meta.url));
     let templatesDir;
-    if (currentDir.includes(path13.sep + "dist")) {
-      templatesDir = path13.join(currentDir, "templates");
+    if (currentDir.includes(path14.sep + "dist")) {
+      templatesDir = path14.join(currentDir, "templates");
     } else {
       templatesDir = currentDir;
     }
     const evalBuildPrompt = readFileSync(
-      path13.join(templatesDir, "eval-build.prompt.md"),
+      path14.join(templatesDir, "eval-build.prompt.md"),
       "utf-8"
     );
     const evalSchema = readFileSync(
-      path13.join(templatesDir, "eval-schema.json"),
+      path14.join(templatesDir, "eval-schema.json"),
       "utf-8"
     );
     const configSchema = readFileSync(
-      path13.join(templatesDir, "config-schema.json"),
+      path14.join(templatesDir, "config-schema.json"),
       "utf-8"
     );
     return [
@@ -13918,28 +15571,37 @@ var TemplateManager = class {
 
 // src/commands/init/index.ts
 async function initCommand(options = {}) {
-  const targetPath = path14.resolve(options.targetPath ?? ".");
-  const githubDir = path14.join(targetPath, ".github");
+  const targetPath = path15.resolve(options.targetPath ?? ".");
+  const githubDir = path15.join(targetPath, ".github");
   if (!existsSync(githubDir)) {
     mkdirSync(githubDir, { recursive: true });
   }
   const templates = TemplateManager.getTemplates();
   for (const template of templates) {
-    const targetFilePath = path14.join(githubDir, template.path);
-    const targetDirPath = path14.dirname(targetFilePath);
+    const targetFilePath = path15.join(githubDir, template.path);
+    const targetDirPath = path15.dirname(targetFilePath);
     if (!existsSync(targetDirPath)) {
       mkdirSync(targetDirPath, { recursive: true });
     }
     writeFileSync(targetFilePath, template.content, "utf-8");
-    console.log(`Created ${path14.relative(targetPath, targetFilePath)}`);
+    console.log(`Created ${path15.relative(targetPath, targetFilePath)}`);
   }
   console.log("\nAgentV initialized successfully!");
   console.log(`
-Files installed to ${path14.relative(targetPath, githubDir)}:`);
+Files installed to ${path15.relative(targetPath, githubDir)}:`);
   templates.forEach((t) => console.log(`  - ${t.path}`));
   console.log("\nYou can now create eval files using the schema and prompt templates.");
 }
 
+// src/commands/status.ts
+function registerStatusCommand(program) {
+  program.command("status").description("Show the latest AgentV kernel status").action(() => {
+    const kernel = createAgentKernel();
+    console.log(`Kernel status: ${kernel.status}`);
+  });
+  return program;
+}
+
 // src/commands/validate/format-output.ts
 var ANSI_RED = "\x1B[31m";
 var ANSI_YELLOW2 = "\x1B[33m";
@@ -14012,10 +15674,10 @@ function isTTY() {
 }
 
 // ../../packages/core/dist/evaluation/validation/index.js
-import { readFile as readFile5 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import { parse as parse5 } from "yaml";
 import { readFile as readFile23 } from "node:fs/promises";
-import path15 from "node:path";
+import path16 from "node:path";
 import { parse as parse23 } from "yaml";
 import { readFile as readFile32 } from "node:fs/promises";
 import path23 from "node:path";
@@ -14030,7 +15692,7 @@ var SCHEMA_TARGETS_V2 = "agentv-targets-v2";
 var SCHEMA_CONFIG_V22 = "agentv-config-v2";
 async function detectFileType(filePath) {
   try {
-    const content = await readFile5(filePath, "utf8");
+    const content = await readFile6(filePath, "utf8");
     const parsed = parse5(content);
     if (typeof parsed !== "object" || parsed === null) {
       return "unknown";
@@ -14060,7 +15722,7 @@ function isObject(value) {
 }
 async function validateEvalFile(filePath) {
   const errors = [];
-  const absolutePath = path15.resolve(filePath);
+  const absolutePath = path16.resolve(filePath);
   let parsed;
   try {
     const content = await readFile23(absolutePath, "utf8");
@@ -14249,6 +15911,7 @@ function validateMessages(messages, location, filePath, errors) {
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var CLI_PLACEHOLDERS2 = /* @__PURE__ */ new Set(["PROMPT", "GUIDELINES", "EVAL_ID", "ATTEMPT", "FILES"]);
 async function validateTargetsFile(filePath) {
   const errors = [];
   const absolutePath = path23.resolve(filePath);
@@ -14269,6 +15932,182 @@ async function validateTargetsFile(filePath) {
       errors
     };
   }
+  function validateCliSettings(settings, absolutePath2, location, errors2) {
+    if (!isObject2(settings)) {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location,
+        message: "CLI provider requires a 'settings' object"
+      });
+      return;
+    }
+    const commandTemplate = settings["command_template"] ?? settings["commandTemplate"];
+    if (typeof commandTemplate !== "string" || commandTemplate.trim().length === 0) {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.commandTemplate`,
+        message: "CLI provider requires 'commandTemplate' as a non-empty string"
+      });
+    } else {
+      recordUnknownPlaceholders(commandTemplate, absolutePath2, `${location}.commandTemplate`, errors2);
+    }
+    const attachmentsFormat = settings["attachments_format"] ?? settings["attachmentsFormat"];
+    if (attachmentsFormat !== void 0 && typeof attachmentsFormat !== "string") {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.attachmentsFormat`,
+        message: "'attachmentsFormat' must be a string when provided"
+      });
+    }
+    const filesFormat = settings["files_format"] ?? settings["filesFormat"];
+    if (filesFormat !== void 0 && typeof filesFormat !== "string") {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.filesFormat`,
+        message: "'filesFormat' must be a string when provided"
+      });
+    }
+    const cwd = settings["cwd"];
+    if (cwd !== void 0 && typeof cwd !== "string") {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.cwd`,
+        message: "'cwd' must be a string when provided"
+      });
+    }
+    const timeoutSeconds = settings["timeout_seconds"] ?? settings["timeoutSeconds"];
+    if (timeoutSeconds !== void 0) {
+      const numericTimeout = Number(timeoutSeconds);
+      if (!Number.isFinite(numericTimeout) || numericTimeout <= 0) {
+        errors2.push({
+          severity: "error",
+          filePath: absolutePath2,
+          location: `${location}.timeoutSeconds`,
+          message: "'timeoutSeconds' must be a positive number when provided"
+        });
+      }
+    }
+    const envOverrides = settings["env"];
+    if (envOverrides !== void 0) {
+      if (!isObject2(envOverrides)) {
+        errors2.push({
+          severity: "error",
+          filePath: absolutePath2,
+          location: `${location}.env`,
+          message: "'env' must be an object with string values"
+        });
+      } else {
+        for (const [key2, value] of Object.entries(envOverrides)) {
+          if (typeof value !== "string" || value.trim().length === 0) {
+            errors2.push({
+              severity: "error",
+              filePath: absolutePath2,
+              location: `${location}.env.${key2}`,
+              message: `Environment override '${key2}' must be a non-empty string`
+            });
+          }
+        }
+      }
+    }
+    const healthcheck = settings["healthcheck"];
+    if (healthcheck !== void 0) {
+      validateCliHealthcheck(healthcheck, absolutePath2, `${location}.healthcheck`, errors2);
+    }
+  }
+  function validateCliHealthcheck(healthcheck, absolutePath2, location, errors2) {
+    if (!isObject2(healthcheck)) {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location,
+        message: "'healthcheck' must be an object when provided"
+      });
+      return;
+    }
+    const type = healthcheck["type"];
+    if (type !== "http" && type !== "command") {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.type`,
+        message: "healthcheck.type must be either 'http' or 'command'"
+      });
+      return;
+    }
+    const timeoutSeconds = healthcheck["timeout_seconds"] ?? healthcheck["timeoutSeconds"];
+    if (timeoutSeconds !== void 0) {
+      const numericTimeout = Number(timeoutSeconds);
+      if (!Number.isFinite(numericTimeout) || numericTimeout <= 0) {
+        errors2.push({
+          severity: "error",
+          filePath: absolutePath2,
+          location: `${location}.timeoutSeconds`,
+          message: "healthcheck.timeoutSeconds must be a positive number when provided"
+        });
+      }
+    }
+    if (type === "http") {
+      const url = healthcheck["url"];
+      if (typeof url !== "string" || url.trim().length === 0) {
+        errors2.push({
+          severity: "error",
+          filePath: absolutePath2,
+          location: `${location}.url`,
+          message: "healthcheck.url must be a non-empty string for http checks"
+        });
+      }
+      return;
+    }
+    const commandTemplate = healthcheck["command_template"] ?? healthcheck["commandTemplate"];
+    if (typeof commandTemplate !== "string" || commandTemplate.trim().length === 0) {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.commandTemplate`,
+        message: "healthcheck.commandTemplate must be a non-empty string for command checks"
+      });
+    } else {
+      recordUnknownPlaceholders(commandTemplate, absolutePath2, `${location}.commandTemplate`, errors2);
+    }
+    const cwd = healthcheck["cwd"];
+    if (cwd !== void 0 && typeof cwd !== "string") {
+      errors2.push({
+        severity: "error",
+        filePath: absolutePath2,
+        location: `${location}.cwd`,
+        message: "healthcheck.cwd must be a string when provided"
+      });
+    }
+  }
+  function recordUnknownPlaceholders(template, absolutePath2, location, errors2) {
+    const placeholders = extractPlaceholders(template);
+    for (const placeholder of placeholders) {
+      if (!CLI_PLACEHOLDERS2.has(placeholder)) {
+        errors2.push({
+          severity: "error",
+          filePath: absolutePath2,
+          location,
+          message: `Unknown CLI placeholder '{${placeholder}}'. Supported placeholders: ${Array.from(CLI_PLACEHOLDERS2).join(", ")}`
+        });
+      }
+    }
+  }
+  function extractPlaceholders(template) {
+    const matches = template.matchAll(/\{([A-Z_]+)\}/g);
+    const result = [];
+    for (const match of matches) {
+      const placeholder = match[1];
+      if (placeholder) {
+        result.push(placeholder);
+      }
+    }
+    return result;
+  }
   if (!isObject2(parsed)) {
     errors.push({
       severity: "error",
@@ -14330,6 +16169,7 @@ async function validateTargetsFile(filePath) {
       });
     }
     const provider = target["provider"];
+    const providerValue = typeof provider === "string" ? provider.trim().toLowerCase() : void 0;
     if (typeof provider !== "string" || provider.trim().length === 0) {
       errors.push({
         severity: "error",
@@ -14346,7 +16186,7 @@ async function validateTargetsFile(filePath) {
       });
     }
     const settings = target["settings"];
-    if (settings !== void 0 && !isObject2(settings)) {
+    if (providerValue !== "cli" && settings !== void 0 && !isObject2(settings)) {
       errors.push({
         severity: "error",
         filePath: absolutePath,
@@ -14354,6 +16194,9 @@ async function validateTargetsFile(filePath) {
         message: "Invalid 'settings' field (must be an object)"
       });
     }
+    if (providerValue === "cli") {
+      validateCliSettings(settings, absolutePath, `${location}.settings`, errors);
+    }
     const judgeTarget = target["judge_target"];
     if (judgeTarget !== void 0 && typeof judgeTarget !== "string") {
       errors.push({
@@ -14558,7 +16401,7 @@ async function validateMessagesFileRefs(messages, location, searchRoots, filePat
 // src/commands/validate/validate-files.ts
 import { constants as constants7 } from "node:fs";
 import { access as access7, readdir as readdir3, stat as stat3 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
   const results = [];
@@ -14576,7 +16419,7 @@ async function validateFiles(paths) {
   };
 }
 async function validateSingleFile(filePath) {
-  const absolutePath = path16.resolve(filePath);
+  const absolutePath = path17.resolve(filePath);
   const fileType = await detectFileType(absolutePath);
   if (fileType === "unknown") {
     return {
@@ -14615,7 +16458,7 @@ async function validateSingleFile(filePath) {
 async function expandPaths(paths) {
   const expanded = [];
   for (const inputPath of paths) {
-    const absolutePath = path16.resolve(inputPath);
+    const absolutePath = path17.resolve(inputPath);
     try {
       await access7(absolutePath, constants7.F_OK);
     } catch {
@@ -14639,7 +16482,7 @@ async function findYamlFiles(dirPath) {
   try {
     const entries = await readdir3(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path16.join(dirPath, entry.name);
+      const fullPath = path17.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
           continue;
@@ -14656,7 +16499,7 @@ async function findYamlFiles(dirPath) {
   return results;
 }
 function isYamlFile(filePath) {
-  const ext = path16.extname(filePath).toLowerCase();
+  const ext = path17.extname(filePath).toLowerCase();
   return ext === ".yaml" || ext === ".yml";
 }
 
@@ -14685,15 +16528,6 @@ function registerValidateCommand(program) {
   return program;
 }
 
-// src/commands/status.ts
-function registerStatusCommand(program) {
-  program.command("status").description("Show the latest AgentV kernel status").action(() => {
-    const kernel = createAgentKernel();
-    console.log(`Kernel status: ${kernel.status}`);
-  });
-  return program;
-}
-
 // src/index.ts
 var packageJson = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
 function createProgram() {
@@ -14722,4 +16556,4 @@ export {
   createProgram,
   runCli
 };
-//# sourceMappingURL=chunk-RLBRJX7V.js.map
+//# sourceMappingURL=chunk-THVRLL37.js.map