agentv 0.18.0 → 0.20.0

package/dist/{chunk-PHILDJ3W.js → chunk-N7M3URIJ.js}

@@ -145,17 +145,17 @@ import { readFileSync as readFileSync2 } from "node:fs";
 import { Command } from "commander";
 
 // src/commands/eval/index.ts
-import { stat as stat3 } from "node:fs/promises";
+import { stat as stat4 } from "node:fs/promises";
 import path19 from "node:path";
 import fg from "fast-glob";
 
 // 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 { access as access6, mkdir as mkdir7 } from "node:fs/promises";
 import path18 from "node:path";
 import { pathToFileURL } from "node:url";
 
-// ../../packages/core/dist/chunk-QHEZJRTU.js
+// ../../packages/core/dist/chunk-SVY324GN.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -4201,7 +4201,7 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../packages/core/dist/chunk-QHEZJRTU.js
+// ../../packages/core/dist/chunk-SVY324GN.js
 async function fileExists(filePath) {
   try {
     await access(filePath, constants.F_OK);
@@ -4874,18 +4874,18 @@ function isAgentProvider(provider) {
 import { readFile as readFile5 } from "node:fs/promises";
 import path62 from "node:path";
 import { parse as parse22 } from "yaml";
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile6 } from "node:fs/promises";
 import path22 from "node:path";
 import micromatch from "micromatch";
 import { parse as parse5 } from "yaml";
 import { constants as constants3 } from "node:fs";
 import { access as access3 } from "node:fs/promises";
-import path8 from "node:path";
+import path12 from "node:path";
 import path32 from "node:path";
 import { readFile as readFile22 } from "node:fs/promises";
 import { readFile as readFile32 } from "node:fs/promises";
 import path42 from "node:path";
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile42 } from "node:fs/promises";
 import path52 from "node:path";
 
 // ../../node_modules/.bun/@ai-sdk+provider@2.0.0/node_modules/@ai-sdk/provider/dist/index.mjs
@@ -32481,34 +32481,21 @@ import { promisify as promisify2 } from "node:util";
 import { exec as execCallback, spawn as spawn2 } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { constants as constants22, createWriteStream } from "node:fs";
-import { access as access22, mkdir as mkdir3, mkdtemp, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { access as access22, mkdir as mkdir4, mkdtemp, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path9 from "node:path";
+import path92 from "node:path";
 import { promisify as promisify22 } from "node:util";
 import path82 from "node:path";
-import path10 from "node:path";
+import path102 from "node:path";
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/vscode/agentDispatch.js
-import { exec, spawn } from "child_process";
-import { copyFile, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
-import path6 from "path";
-import { promisify } from "util";
-
-// ../../node_modules/.bun/subagent@0.4.7/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();
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/agentDispatch.js
+import { stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import path10 from "node:path";
 
-// ../../node_modules/.bun/subagent@0.4.7/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";
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/utils/fs.js
+import { constants as constants2 } from "node:fs";
+import { access as access2, mkdir, readdir, rm, stat } from "node:fs/promises";
+import path2 from "node:path";
 async function pathExists(target) {
   try {
     await access2(target, constants2.F_OK);
@@ -32524,7 +32511,7 @@ async function readDirEntries(target) {
   const entries = await readdir(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path3.join(target, entry.name),
+    absolutePath: path2.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -32538,10 +32525,10 @@ async function removeIfExists(target) {
   }
 }
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/utils/path.js
-import path4 from "path";
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/utils/path.js
+import path3 from "node:path";
 function pathToFileUri(filePath) {
-  const absolutePath = path4.isAbsolute(filePath) ? filePath : path4.resolve(filePath);
+  const absolutePath = path3.isAbsolute(filePath) ? filePath : path3.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -32549,15 +32536,333 @@ function pathToFileUri(filePath) {
   return `file://${normalizedPath}`;
 }
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/utils/time.js
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/promptBuilder.js
+import { readFile as readFile2 } from "node:fs/promises";
+import path4 from "node:path";
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/utils/template.js
+function renderTemplate(content, variables) {
+  if (!content) {
+    return content;
+  }
+  const variableLookup = /* @__PURE__ */ new Map();
+  for (const [key2, value] of Object.entries(variables)) {
+    variableLookup.set(key2.toLowerCase(), value);
+  }
+  const referencedVariables = /* @__PURE__ */ new Set();
+  const result = content.replace(/\{\{([a-zA-Z_]+)\}\}/gi, (match, variableName) => {
+    const lowerCaseKey = variableName.toLowerCase();
+    referencedVariables.add(lowerCaseKey);
+    if (!variableLookup.has(lowerCaseKey)) {
+      throw new Error(`Template variable '${variableName}' is not provided in the variables object`);
+    }
+    return variableLookup.get(lowerCaseKey);
+  });
+  return result;
+}
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/templates.js
+var DEFAULT_REQUEST_TEMPLATE = `[[ ## system_instructions ## ]]
+
+**IMPORTANT**: Follow these exact steps:
+1. Create and write your complete response to: {{responseFileTmp}}
+2. When completely finished, run these PowerShell commands to signal completion:
+\`\`\`
+Move-Item -LiteralPath '{{responseFileTmp}}' -Destination '{{responseFileFinal}}'
+if (Test-Path subagent.lock) { del subagent.lock }
+\`\`\`
+
+Do not proceed to step 2 until your response is completely written to the temporary file.
+
+[[ ## task ## ]]
+
+{{userQuery}}
+`;
+var DEFAULT_BATCH_REQUEST_TEMPLATE = `[[ ## system_instructions ## ]]
+
+**IMPORTANT**: Follow these exact steps:
+1. Create and write your complete response to: {{responseFileTmp}}
+2. When completely finished and the response is stable, rename it to: {{responseFileFinal}}
+5. Do not unlock the workspace from this request; batch orchestration will handle unlocking after all responses are ready.
+
+[[ ## task ## ]]
+
+{{userQuery}}
+`;
+var DEFAULT_BATCH_ORCHESTRATOR_TEMPLATE = `MANDATORY: Run #runSubagent tool in your Available Actions for each request file to process them in isolated contexts.
+DO NOT read the request files yourself - only pass the file paths to each subagent:
+
+{{requestFiles}}
+
+After ALL queries complete, verify all responses exist and unlock:
+
+\`\`\`powershell
+$responses = @({{responseList}})
+$missing = $responses | Where-Object { -not (Test-Path "messages/$_") }
+if ($missing.Count -eq 0) { del subagent.lock }
+\`\`\`
+`;
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/promptBuilder.js
+async function loadTemplateFile(filePath) {
+  try {
+    return await readFile2(filePath, "utf8");
+  } catch (error40) {
+    throw new Error(`Failed to load template file '${filePath}': ${error40.message}`);
+  }
+}
+function loadDefaultRequestTemplate() {
+  return DEFAULT_REQUEST_TEMPLATE;
+}
+function loadDefaultBatchRequestTemplate() {
+  return DEFAULT_BATCH_REQUEST_TEMPLATE;
+}
+function loadDefaultBatchOrchestratorTemplate() {
+  return DEFAULT_BATCH_ORCHESTRATOR_TEMPLATE;
+}
+function createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent) {
+  return renderTemplate(templateContent, {
+    userQuery,
+    responseFileTmp,
+    responseFileFinal
+  });
+}
+function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent) {
+  return renderTemplate(templateContent, {
+    userQuery,
+    responseFileTmp,
+    responseFileFinal
+  });
+}
+function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
+  const requestLines = requestFiles.map((file2, index) => `${index + 1}. messages/${path4.basename(file2)}`).join("\n");
+  const responseList = responseFiles.map((file2) => `"${path4.basename(file2)}"`).join(", ");
+  return renderTemplate(templateContent, {
+    requestFiles: requestLines,
+    responseList
+  });
+}
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/responseWaiter.js
+import { readFile as readFile3 } from "node:fs/promises";
+import path5 from "node:path";
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/utils/time.js
 function sleep(ms) {
   return new Promise((resolve2) => {
     setTimeout(resolve2, ms);
   });
 }
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/utils/workspace.js
-import path5 from "path";
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/responseWaiter.js
+async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, silent = false) {
+  if (!silent) {
+    console.error(`waiting for agent to finish: ${responseFileFinal}`);
+  }
+  try {
+    while (!await pathExists(responseFileFinal)) {
+      await sleep(pollInterval);
+    }
+  } catch (error40) {
+    if (error40.code === "ENOENT") {
+      return false;
+    }
+    throw error40;
+  }
+  let attempts = 0;
+  const maxAttempts = 10;
+  while (attempts < maxAttempts) {
+    try {
+      const content = await readFile3(responseFileFinal, { encoding: "utf8" });
+      if (!silent) {
+        process.stdout.write(`${content}
+`);
+      }
+      return true;
+    } catch (error40) {
+      attempts += 1;
+      if (error40.code !== "EBUSY" || attempts >= maxAttempts) {
+        if (!silent) {
+          console.error(`error: failed to read agent response: ${error40.message}`);
+        }
+        return false;
+      }
+      await sleep(pollInterval);
+    }
+  }
+  return false;
+}
+async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
+  if (!silent) {
+    const fileList = responseFilesFinal.map((file2) => path5.basename(file2)).join(", ");
+    console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
+  }
+  try {
+    const pending = new Set(responseFilesFinal);
+    while (pending.size > 0) {
+      for (const file2 of [...pending]) {
+        if (await pathExists(file2)) {
+          pending.delete(file2);
+        }
+      }
+      if (pending.size > 0) {
+        await sleep(pollInterval);
+      }
+    }
+  } catch (error40) {
+    if (error40.code === "ENOENT") {
+      return false;
+    }
+    throw error40;
+  }
+  for (const file2 of responseFilesFinal) {
+    let attempts = 0;
+    const maxAttempts = 10;
+    while (attempts < maxAttempts) {
+      try {
+        const content = await readFile3(file2, { encoding: "utf8" });
+        if (!silent) {
+          process.stdout.write(`${content}
+`);
+        }
+        break;
+      } catch (error40) {
+        attempts += 1;
+        if (error40.code !== "EBUSY" || attempts >= maxAttempts) {
+          if (!silent) {
+            console.error(`error: failed to read agent response: ${error40.message}`);
+          }
+          return false;
+        }
+        await sleep(pollInterval);
+      }
+    }
+  }
+  return true;
+}
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/vscodeProcess.js
+import { exec, spawn } from "node:child_process";
+import { mkdir as mkdir2, writeFile } from "node:fs/promises";
+import path7 from "node:path";
+import { promisify } from "node:util";
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/constants.js
+import os from "node:os";
+import path6 from "node:path";
+var DEFAULT_LOCK_NAME = "subagent.lock";
+var DEFAULT_ALIVE_FILENAME = ".alive";
+function getDefaultSubagentRoot(vscodeCmd = "code") {
+  const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
+  return path6.join(os.homedir(), ".subagent", folder);
+}
+var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/vscodeProcess.js
+var execAsync = promisify(exec);
+var DEFAULT_WAKEUP_CONTENT = `---
+description: 'Wake-up Signal'
+model: Grok Code Fast 1 (copilot)
+---`;
+async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
+  try {
+    const { stdout } = await execAsync(`${vscodeCmd} --status`, {
+      timeout: 1e4,
+      windowsHide: true
+    });
+    return stdout.includes(workspaceName);
+  } catch {
+    return false;
+  }
+}
+async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir, vscodeCmd, pollInterval = 1, timeout = 60) {
+  const alreadyOpen = await checkWorkspaceOpened(workspaceName, vscodeCmd);
+  if (alreadyOpen) {
+    spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+    return true;
+  }
+  const aliveFile = path7.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  await removeIfExists(aliveFile);
+  const githubAgentsDir = path7.join(subagentDir, ".github", "agents");
+  await mkdir2(githubAgentsDir, { recursive: true });
+  const wakeupDst = path7.join(githubAgentsDir, "wakeup.md");
+  await writeFile(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+  await sleep(100);
+  const wakeupChatId = "wakeup";
+  const chatArgs = [
+    "-r",
+    "chat",
+    "-m",
+    wakeupChatId,
+    `create a file named .alive in the ${path7.basename(subagentDir)} folder`
+  ];
+  spawn(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+  const start = Date.now();
+  while (!await pathExists(aliveFile)) {
+    if (Date.now() - start > timeout * 1e3) {
+      console.error(`warning: Workspace readiness timeout after ${timeout}s`);
+      return false;
+    }
+    await sleep(pollInterval * 1e3);
+  }
+  return true;
+}
+async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
+  try {
+    const workspacePath = path7.join(subagentDir, `${path7.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path7.join(subagentDir, "messages");
+    await mkdir2(messagesDir, { recursive: true });
+    const reqFile = path7.join(messagesDir, `${timestamp}_req.md`);
+    await writeFile(reqFile, requestInstructions, { encoding: "utf8" });
+    const reqUri = pathToFileUri(reqFile);
+    const chatArgs = ["-r", "chat", "-m", chatId];
+    for (const attachment of attachmentPaths) {
+      chatArgs.push("-a", attachment);
+    }
+    chatArgs.push("-a", reqFile);
+    chatArgs.push(`Follow instructions in [${path7.basename(reqFile)}](${reqUri})`);
+    const workspaceReady = await ensureWorkspaceFocused(workspacePath, path7.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 (error40) {
+    console.error(`warning: Failed to launch VS Code: ${error40.message}`);
+    return false;
+  }
+}
+async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
+  try {
+    const workspacePath = path7.join(subagentDir, `${path7.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path7.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, path7.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 (error40) {
+    console.error(`warning: Failed to launch VS Code: ${error40.message}`);
+    return false;
+  }
+}
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/workspaceManager.js
+import { copyFile, mkdir as mkdir3, readFile as readFile4, readdir as readdir2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import path9 from "node:path";
+
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/utils/workspace.js
+import path8 from "node:path";
 
 // ../../node_modules/.bun/json5@2.2.3/node_modules/json5/dist/index.mjs
 var Space_Separator = /[\u1680\u2000-\u200A\u202F\u205F\u3000]/;
@@ -33644,7 +33949,7 @@ var JSON5 = {
 var lib = JSON5;
 var dist_default = lib;
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/utils/workspace.js
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/utils/workspace.js
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
   try {
@@ -33660,19 +33965,16 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path5.isAbsolute(folderPath)) {
+    if (path8.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path5.resolve(templateDir, folderPath);
+    const absolutePath = path8.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
     };
   });
-  const updatedFolders = [
-    { path: "." },
-    ...transformedFolders
-  ];
+  const updatedFolders = [{ path: "." }, ...transformedFolders];
   let transformedSettings = workspace.settings;
   if (workspace.settings) {
     transformedSettings = {
@@ -33688,19 +33990,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path5.isAbsolute(locationPath);
+          const isAbsolute = path8.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path5.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path8.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 = (path5.resolve(templateDir, basePath) + patternPath).replace(/\\/g, "/");
+              const resolvedPath = (path8.resolve(templateDir, basePath) + patternPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             }
           }
@@ -33717,11 +34019,7 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   return JSON.stringify(transformedWorkspace, null, 2);
 }
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/vscode/agentDispatch.js
-var execAsync = promisify(exec);
-function generateTimestamp() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
-}
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/workspaceManager.js
 var DEFAULT_WORKSPACE_TEMPLATE = {
   folders: [
     {
@@ -33729,27 +34027,9 @@ var DEFAULT_WORKSPACE_TEMPLATE = {
     }
   ]
 };
-var DEFAULT_WAKEUP_CONTENT = `---
-description: 'Wake-up Signal'
-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;
@@ -33760,53 +34040,17 @@ 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 = path6.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path9.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
   }
   return null;
 }
-async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
-  try {
-    const { stdout } = await execAsync(`${vscodeCmd} --status`, { timeout: 1e4, windowsHide: true });
-    return stdout.includes(workspaceName);
-  } catch {
-    return false;
-  }
-}
-async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir, vscodeCmd, pollInterval = 1, timeout = 60) {
-  const alreadyOpen = await checkWorkspaceOpened(workspaceName, vscodeCmd);
-  if (alreadyOpen) {
-    spawn(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
-    return true;
-  }
-  const aliveFile = path6.join(subagentDir, DEFAULT_ALIVE_FILENAME);
-  await removeIfExists(aliveFile);
-  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);
-  const wakeupChatId = "wakeup";
-  const chatArgs = ["-r", "chat", "-m", wakeupChatId, `create a file named .alive in the ${path6.basename(subagentDir)} folder`];
-  spawn(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
-  const start = Date.now();
-  while (!await pathExists(aliveFile)) {
-    if (Date.now() - start > timeout * 1e3) {
-      console.error(`warning: Workspace readiness timeout after ${timeout}s`);
-      return false;
-    }
-    await sleep(pollInterval * 1e3);
-  }
-  return true;
-}
 async function copyAgentConfig(subagentDir, workspaceTemplate) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path6.resolve(workspaceTemplate);
+    const workspaceSrc = path9.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -33814,129 +34058,44 @@ async function copyAgentConfig(subagentDir, workspaceTemplate) {
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile2(workspaceSrc, "utf8");
+    const templateText = await readFile4(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path6.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path6.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path6.dirname(path6.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path9.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path9.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path9.dirname(path9.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
-  await writeFile(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path6.join(subagentDir, "messages");
-  await mkdir2(messagesDir, { recursive: true });
+  await writeFile2(workspaceDst, transformedContent, "utf8");
+  const messagesDir = path9.join(subagentDir, "messages");
+  await mkdir3(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path6.join(subagentDir, "messages");
+  const messagesDir = path9.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir2(messagesDir);
     await Promise.all(files.map(async (file2) => {
-      const target = path6.join(messagesDir, file2);
+      const target = path9.join(messagesDir, file2);
       await removeIfExists(target);
     }));
   }
-  const githubAgentsDir = path6.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path9.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((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path6.join(githubAgentsDir, file2))));
+    await Promise.all(agentFiles.filter((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path9.join(githubAgentsDir, file2))));
   }
-  const lockFile = path6.join(subagentDir, DEFAULT_LOCK_NAME);
-  await writeFile(lockFile, "", { encoding: "utf8" });
+  const lockFile = path9.join(subagentDir, DEFAULT_LOCK_NAME);
+  await writeFile2(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path6.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path9.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
-async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, silent = false) {
-  if (!silent) {
-    console.error(`waiting for agent to finish: ${responseFileFinal}`);
-  }
-  try {
-    while (!await pathExists(responseFileFinal)) {
-      await sleep(pollInterval);
-    }
-  } catch (error40) {
-    if (error40.code === "ENOENT") {
-      return false;
-    }
-    throw error40;
-  }
-  let attempts = 0;
-  const maxAttempts = 10;
-  while (attempts < maxAttempts) {
-    try {
-      const content = await readFile2(responseFileFinal, { encoding: "utf8" });
-      if (!silent) {
-        process.stdout.write(`${content}
-`);
-      }
-      return true;
-    } catch (error40) {
-      attempts += 1;
-      if (error40.code !== "EBUSY" || attempts >= maxAttempts) {
-        if (!silent) {
-          console.error(`error: failed to read agent response: ${error40.message}`);
-        }
-        return false;
-      }
-      await sleep(pollInterval);
-    }
-  }
-  return false;
-}
-async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
-  if (!silent) {
-    const fileList = responseFilesFinal.map((file2) => path6.basename(file2)).join(", ");
-    console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
-  }
-  try {
-    const pending = new Set(responseFilesFinal);
-    while (pending.size > 0) {
-      for (const file2 of [...pending]) {
-        if (await pathExists(file2)) {
-          pending.delete(file2);
-        }
-      }
-      if (pending.size > 0) {
-        await sleep(pollInterval);
-      }
-    }
-  } catch (error40) {
-    if (error40.code === "ENOENT") {
-      return false;
-    }
-    throw error40;
-  }
-  for (const file2 of responseFilesFinal) {
-    let attempts = 0;
-    const maxAttempts = 10;
-    while (attempts < maxAttempts) {
-      try {
-        const content = await readFile2(file2, { encoding: "utf8" });
-        if (!silent) {
-          process.stdout.write(`${content}
-`);
-        }
-        break;
-      } catch (error40) {
-        attempts += 1;
-        if (error40.code !== "EBUSY" || attempts >= maxAttempts) {
-          if (!silent) {
-            console.error(`error: failed to read agent response: ${error40.message}`);
-          }
-          return false;
-        }
-        await sleep(pollInterval);
-      }
-    }
-  }
-  return true;
-}
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
   if (dryRun) {
     return 0;
@@ -33954,9 +34113,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path6.join(subagentDir, ".github", "agents");
-    await mkdir2(githubAgentsDir, { recursive: true });
-    const agentFile = path6.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = path9.join(subagentDir, ".github", "agents");
+    await mkdir3(githubAgentsDir, { recursive: true });
+    const agentFile = path9.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error40) {
@@ -33966,50 +34125,24 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
   }
   return 0;
 }
-function createRequestPrompt(userQuery, responseFileTmp, responseFileFinal) {
-  return `[[ ## task ## ]]
-
-${userQuery}
-
-[[ ## system_instructions ## ]]
-
-**IMPORTANT**: Follow these exact steps:
-1. Create and write your complete response to: ${responseFileTmp}
-2. When completely finished, run these PowerShell commands to signal completion:
-\`\`\`
-Move-Item -LiteralPath '${responseFileTmp}' -Destination '${responseFileFinal}'
-if (Test-Path subagent.lock) { del subagent.lock }
-\`\`\`
 
-Do not proceed to step 2 until your response is completely written to the temporary file.`;
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/agentDispatch.js
+function generateTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
 }
-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((file2, index) => `${index + 1}. messages/${path6.basename(file2)}`).join("\n");
-  const responseList = responseFiles.map((file2) => `"${path6.basename(file2)}"`).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 resolvePromptFile(promptFile) {
+  if (!promptFile) {
+    return void 0;
+  }
+  const resolvedPrompt = path10.resolve(promptFile);
+  if (!await pathExists(resolvedPrompt)) {
+    throw new Error(`Prompt file not found: ${resolvedPrompt}`);
+  }
+  const promptStats = await stat3(resolvedPrompt);
+  if (!promptStats.isFile()) {
+    throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
+  }
+  return resolvedPrompt;
 }
 async function resolveAttachments(extraAttachments) {
   if (!extraAttachments) {
@@ -34017,7 +34150,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path6.resolve(attachment);
+    const resolvedPath = path10.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -34025,55 +34158,8 @@ async function resolveAttachments(extraAttachments) {
   }
   return resolved;
 }
-async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  try {
-    const workspacePath = path6.join(subagentDir, `${path6.basename(subagentDir)}.code-workspace`);
-    const messagesDir = path6.join(subagentDir, "messages");
-    await mkdir2(messagesDir, { recursive: true });
-    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 ${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 (error40) {
-    console.error(`warning: Failed to launch VS Code: ${error40.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");
-    }
-    await sleep(500);
-    spawn(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
-    return true;
-  } catch (error40) {
-    console.error(`warning: Failed to launch VS Code: ${error40.message}`);
-    return false;
-  }
-}
 async function dispatchAgentSession(options) {
-  const { userQuery, promptFile, extraAttachments, workspaceTemplate, dryRun = false, wait = true, vscodeCmd = "code", subagentRoot, silent = false } = options;
+  const { userQuery, promptFile, requestTemplate, extraAttachments, workspaceTemplate, dryRun = false, wait = true, vscodeCmd = "code", subagentRoot, silent = false } = options;
   try {
     let resolvedPrompt;
     try {
@@ -34084,6 +34170,15 @@ async function dispatchAgentSession(options) {
         error: error40.message
       };
     }
+    let templateContent;
+    try {
+      templateContent = requestTemplate ? await loadTemplateFile(path10.resolve(requestTemplate)) : loadDefaultRequestTemplate();
+    } catch (error40) {
+      return {
+        exitCode: 1,
+        error: error40.message
+      };
+    }
     const subagentRootPath = subagentRoot ?? getSubagentRoot(vscodeCmd);
     const subagentDir = await findUnlockedSubagent(subagentRootPath);
     if (!subagentDir) {
@@ -34092,7 +34187,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path6.basename(subagentDir);
+    const subagentName = path10.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
     if (preparationResult !== 0) {
@@ -34113,10 +34208,10 @@ async function dispatchAgentSession(options) {
       };
     }
     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);
+    const messagesDir = path10.join(subagentDir, "messages");
+    const responseFileTmp = path10.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path10.join(messagesDir, `${timestamp}_res.md`);
+    const requestInstructions = createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent);
     if (dryRun) {
       return {
         exitCode: 0,
@@ -34168,7 +34263,7 @@ async function dispatchAgentSession(options) {
   }
 }
 async function dispatchBatchAgent(options) {
-  const { userQueries, promptFile, extraAttachments, workspaceTemplate, dryRun = false, wait = false, vscodeCmd = "code", subagentRoot, silent = false } = options;
+  const { userQueries, promptFile, requestTemplate, extraAttachments, workspaceTemplate, dryRun = false, wait = false, vscodeCmd = "code", subagentRoot, silent = false } = options;
   if (!userQueries || userQueries.length === 0) {
     return {
       exitCode: 1,
@@ -34193,6 +34288,18 @@ async function dispatchBatchAgent(options) {
         error: error40.message
       };
     }
+    let batchRequestTemplateContent;
+    try {
+      batchRequestTemplateContent = requestTemplate ? await loadTemplateFile(path10.resolve(requestTemplate)) : loadDefaultBatchRequestTemplate();
+    } catch (error40) {
+      return {
+        exitCode: 1,
+        requestFiles,
+        queryCount,
+        error: error40.message
+      };
+    }
+    const orchestratorTemplateContent = loadDefaultBatchOrchestratorTemplate();
     const subagentRootPath = subagentRoot ?? getSubagentRoot(vscodeCmd);
     const subagentDir = await findUnlockedSubagent(subagentRootPath);
     if (!subagentDir) {
@@ -34203,7 +34310,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path6.basename(subagentDir);
+    subagentName = path10.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
     if (preparationResult !== 0) {
@@ -34228,15 +34335,15 @@ async function dispatchBatchAgent(options) {
       };
     }
     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`);
+    const messagesDir = path10.join(subagentDir, "messages");
+    requestFiles = userQueries.map((_, index) => path10.join(messagesDir, `${timestamp}_${index}_req.md`));
+    const responseTmpFiles = userQueries.map((_, index) => path10.join(messagesDir, `${timestamp}_${index}_res.tmp.md`));
+    responseFilesFinal = userQueries.map((_, index) => path10.join(messagesDir, `${timestamp}_${index}_res.md`));
+    const orchestratorFile = path10.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" });
+      await Promise.all(userQueries.map((query, index) => writeFile3(requestFiles[index], createBatchRequestPrompt(query, responseTmpFiles[index], responseFilesFinal[index], batchRequestTemplateContent), { encoding: "utf8" })));
+      const orchestratorContent = createBatchOrchestratorPrompt(requestFiles, responseFilesFinal, orchestratorTemplateContent);
+      await writeFile3(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri(orchestratorFile);
@@ -34299,9 +34406,9 @@ async function dispatchBatchAgent(options) {
   }
 }
 
-// ../../node_modules/.bun/subagent@0.4.7/node_modules/subagent/dist/vscode/provision.js
-import { writeFile as writeFile2 } from "fs/promises";
-import path7 from "path";
+// ../../node_modules/.bun/subagent@0.5.5/node_modules/subagent/dist/vscode/provision.js
+import { writeFile as writeFile4 } from "node:fs/promises";
+import path11 from "node:path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -34324,7 +34431,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path7.resolve(targetRoot);
+  const targetPath = path11.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -34338,12 +34445,14 @@ async function provisionSubagents(options) {
         continue;
       }
       const suffix = entry.name.split("-")[1];
+      if (!suffix)
+        continue;
       const parsed = Number.parseInt(suffix, 10);
       if (!Number.isInteger(parsed)) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path7.join(entry.absolutePath, lockName);
+      const lockFile = path11.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -34360,11 +34469,11 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    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 githubAgentsDir = path11.join(subagentDir, ".github", "agents");
+    const lockFile = path11.join(subagentDir, lockName);
+    const workspaceDst = path11.join(subagentDir, `${path11.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path11.join(githubAgentsDir, "wakeup.md");
+    const subagentDst = path11.join(githubAgentsDir, "subagent.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -34373,8 +34482,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await writeFile2(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile2(wakeupDst, wakeupContent, "utf8");
+        await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile4(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -34384,8 +34493,8 @@ 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");
+        await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile4(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -34393,8 +34502,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await writeFile2(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile2(wakeupDst, wakeupContent, "utf8");
+      await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile4(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -34402,16 +34511,16 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    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");
+    const subagentDir = path11.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path11.join(subagentDir, ".github", "agents");
+    const workspaceDst = path11.join(subagentDir, `${path11.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path11.join(githubAgentsDir, "wakeup.md");
+    const subagentDst = path11.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");
+      await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile4(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -34425,12 +34534,12 @@ async function provisionSubagents(options) {
 
 // ../../packages/core/dist/index.js
 import { constants as constants32 } from "node:fs";
-import { access as access32, readFile as readFile6 } from "node:fs/promises";
-import path11 from "node:path";
+import { access as access32, readFile as readFile62 } from "node:fs/promises";
+import path112 from "node:path";
 import { parse as parse32 } from "yaml";
 import { createHash, randomUUID as randomUUID2 } from "node:crypto";
 import { mkdir as mkdir22, writeFile as writeFile22 } from "node:fs/promises";
-import path12 from "node:path";
+import path122 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) {
@@ -34568,15 +34677,15 @@ function resolveToAbsolutePath(candidate) {
     if (candidate.startsWith("file://")) {
       return new URL(candidate).pathname;
     }
-    return path8.resolve(candidate);
+    return path12.resolve(candidate);
   }
   throw new TypeError("Unsupported repoRoot value. Expected string or URL.");
 }
 function buildDirectoryChain2(filePath, repoRoot) {
   const directories = [];
   const seen = /* @__PURE__ */ new Set();
-  const boundary = path8.resolve(repoRoot);
-  let current = path8.resolve(path8.dirname(filePath));
+  const boundary = path12.resolve(repoRoot);
+  let current = path12.resolve(path12.dirname(filePath));
   while (current !== void 0) {
     if (!seen.has(current)) {
       directories.push(current);
@@ -34585,7 +34694,7 @@ function buildDirectoryChain2(filePath, repoRoot) {
     if (current === boundary) {
       break;
     }
-    const parent = path8.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current) {
       break;
     }
@@ -34599,16 +34708,16 @@ function buildDirectoryChain2(filePath, repoRoot) {
 function buildSearchRoots2(evalPath, repoRoot) {
   const uniqueRoots = [];
   const addRoot = (root2) => {
-    const normalized = path8.resolve(root2);
+    const normalized = path12.resolve(root2);
     if (!uniqueRoots.includes(normalized)) {
       uniqueRoots.push(normalized);
     }
   };
-  let currentDir = path8.dirname(evalPath);
+  let currentDir = path12.dirname(evalPath);
   let reachedBoundary = false;
   while (!reachedBoundary) {
     addRoot(currentDir);
-    const parentDir = path8.dirname(currentDir);
+    const parentDir = path12.dirname(currentDir);
     if (currentDir === repoRoot || parentDir === currentDir) {
       reachedBoundary = true;
     } else {
@@ -34626,16 +34735,16 @@ function trimLeadingSeparators2(value) {
 async function resolveFileReference2(rawValue, searchRoots) {
   const displayPath = trimLeadingSeparators2(rawValue);
   const potentialPaths = [];
-  if (path8.isAbsolute(rawValue)) {
-    potentialPaths.push(path8.normalize(rawValue));
+  if (path12.isAbsolute(rawValue)) {
+    potentialPaths.push(path12.normalize(rawValue));
   }
   for (const base of searchRoots) {
-    potentialPaths.push(path8.resolve(base, displayPath));
+    potentialPaths.push(path12.resolve(base, displayPath));
   }
   const attempted = [];
   const seen = /* @__PURE__ */ new Set();
   for (const candidate of potentialPaths) {
-    const absoluteCandidate = path8.resolve(candidate);
+    const absoluteCandidate = path12.resolve(candidate);
     if (seen.has(absoluteCandidate)) {
       continue;
     }
@@ -34658,7 +34767,7 @@ async function loadConfig(evalFilePath, repoRoot) {
       continue;
     }
     try {
-      const rawConfig = await readFile3(configPath, "utf8");
+      const rawConfig = await readFile6(configPath, "utf8");
       const parsed = parse5(rawConfig);
       if (!isJsonObject(parsed)) {
         logWarning(`Invalid .agentv/config.yaml format at ${configPath}`);
@@ -35053,7 +35162,7 @@ async function buildPromptInputs(testCase, mode = "lm") {
       continue;
     }
     try {
-      const content = (await readFile4(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
+      const content = (await readFile42(absolutePath, "utf8")).replace(/\r\n/g, "\n").trim();
       guidelineParts.push({
         content,
         isFile: true,
@@ -35799,7 +35908,7 @@ var CliProvider = class {
     await this.ensureHealthy(request.signal);
     const outputFilePath = generateOutputFilePath(request.evalCaseId);
     const templateValues = buildTemplateValues(request, this.config, outputFilePath);
-    const renderedCommand = renderTemplate(this.config.commandTemplate, templateValues);
+    const renderedCommand = renderTemplate2(this.config.commandTemplate, templateValues);
     const result = await this.runCommand(renderedCommand, {
       cwd: this.config.cwd,
       env: process.env,
@@ -35877,7 +35986,7 @@ var CliProvider = class {
       }
       return;
     }
-    const renderedCommand = renderTemplate(
+    const renderedCommand = renderTemplate2(
       healthcheck.commandTemplate,
       buildTemplateValues(
         {
@@ -35945,7 +36054,7 @@ function formatFileList(files, template) {
     return formatter.replaceAll("{path}", escapedPath).replaceAll("{basename}", escapedName);
   }).join(" ");
 }
-function renderTemplate(template, values) {
+function renderTemplate2(template, values) {
   return template.replace(/\{([A-Z_]+)\}/g, (match, key2) => {
     const replacement = values[key2];
     return replacement !== void 0 ? replacement : match;
@@ -36143,8 +36252,8 @@ var CodexProvider = class {
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
       const promptContent = buildPromptDocument(request, inputFiles);
-      const promptFile = path9.join(workspaceRoot, PROMPT_FILENAME);
-      await writeFile3(promptFile, promptContent, "utf8");
+      const promptFile = path92.join(workspaceRoot, PROMPT_FILENAME);
+      await writeFile5(promptFile, promptContent, "utf8");
       const args = this.buildCodexArgs();
       const cwd = this.resolveCwd(workspaceRoot);
       const result = await this.executeCodex(args, cwd, promptContent, request.signal, logger);
@@ -36193,7 +36302,7 @@ var CodexProvider = class {
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return path9.resolve(this.config.cwd);
+    return path92.resolve(this.config.cwd);
   }
   buildCodexArgs() {
     const args = [
@@ -36235,7 +36344,7 @@ var CodexProvider = class {
     }
   }
   async createWorkspace() {
-    return await mkdtemp(path9.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path92.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -36249,9 +36358,9 @@ var CodexProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path9.resolve(this.config.logDir);
+      return path92.resolve(this.config.logDir);
     }
-    return path9.join(process.cwd(), ".agentv", "logs", "codex");
+    return path92.join(process.cwd(), ".agentv", "logs", "codex");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -36259,13 +36368,13 @@ var CodexProvider = class {
       return void 0;
     }
     try {
-      await mkdir3(logDir, { recursive: true });
+      await mkdir4(logDir, { recursive: true });
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
       console.warn(`Skipping Codex stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path9.join(logDir, buildLogFilename(request, this.targetName));
+    const filePath = path92.join(logDir, buildLogFilename(request, this.targetName));
     try {
       const logger = await CodexStreamLogger.create({
         filePath,
@@ -36480,7 +36589,7 @@ function tryParseJsonValue(rawLine) {
 async function locateExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path9.isAbsolute(candidate) ? candidate : path9.resolve(candidate);
+    const resolved = path92.isAbsolute(candidate) ? candidate : path92.resolve(candidate);
     const executablePath = await ensureWindowsExecutableVariant(resolved);
     await access22(executablePath, constants22.F_OK);
     return executablePath;
@@ -36823,6 +36932,39 @@ var MockProvider = class {
     return this.delayMs;
   }
 };
+var AGENTV_REQUEST_TEMPLATE = `[[ ## system_instructions ## ]]
+
+**IMPORTANT**: You are processing an evaluation request from AgentV. Follow these exact steps:
+
+1. Read and understand all guideline files and attachments provided above
+2. Process the user query below according to the guidelines
+3. Write your complete response to: {{responseFileTmp}}
+4. When completely finished, run these PowerShell commands to signal completion:
+\`\`\`powershell
+Move-Item -LiteralPath '{{responseFileTmp}}' -Destination '{{responseFileFinal}}'
+if (Test-Path subagent.lock) { Remove-Item subagent.lock }
+\`\`\`
+
+Do not proceed to step 4 until your response is completely written to the temporary file.
+
+[[ ## task ## ]]
+
+{{userQuery}}
+`;
+var AGENTV_BATCH_REQUEST_TEMPLATE = `[[ ## system_instructions ## ]]
+
+**IMPORTANT**: You are processing a batch evaluation request from AgentV. Follow these exact steps:
+
+1. Read and understand all guideline files and attachments provided above
+2. Process the user query below according to the guidelines
+3. Write your complete response to: {{responseFileTmp}}
+4. When completely finished and the response is stable, rename it to: {{responseFileFinal}}
+5. Do not unlock the workspace from this request; batch orchestration will handle unlocking after all responses are ready.
+
+[[ ## task ## ]]
+
+{{userQuery}}
+`;
 var VSCodeProvider = class {
   id;
   kind;
@@ -36844,6 +36986,7 @@ var VSCodeProvider = class {
     const session = await dispatchAgentSession({
       userQuery: promptContent,
       extraAttachments: inputFiles,
+      requestTemplate: AGENTV_REQUEST_TEMPLATE,
       wait: this.config.waitForResponse,
       dryRun: this.config.dryRun,
       vscodeCmd: this.config.command,
@@ -36890,6 +37033,7 @@ var VSCodeProvider = class {
     const session = await dispatchBatchAgent({
       userQueries,
       extraAttachments: combinedInputFiles,
+      requestTemplate: AGENTV_BATCH_REQUEST_TEMPLATE,
       wait: this.config.waitForResponse,
       dryRun: this.config.dryRun,
       vscodeCmd: this.config.command,
@@ -36952,7 +37096,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path10.basename(absolutePath);
+    const fileName = path102.basename(absolutePath);
     const fileUri = pathToFileUri22(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -36977,8 +37121,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path10.resolve(attachment);
-    const normalized = absolutePath.split(path10.sep).join("/");
+    const absolutePath = path102.resolve(attachment);
+    const normalized = absolutePath.split(path102.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -36993,7 +37137,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path10.resolve(attachment);
+    const absolutePath = path102.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -37001,7 +37145,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri22(filePath) {
-  const absolutePath = path10.isAbsolute(filePath) ? filePath : path10.resolve(filePath);
+  const absolutePath = path102.isAbsolute(filePath) ? filePath : path102.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -37014,7 +37158,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path10.resolve(attachment));
+    deduped.add(path102.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -37023,7 +37167,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path10.resolve(inputFile));
+      deduped.add(path102.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -37103,11 +37247,11 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path11.resolve(filePath);
+  const absolutePath = path112.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile6(absolutePath, "utf8");
+  const raw = await readFile62(absolutePath, "utf8");
   const parsed = parse32(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -38238,8 +38382,8 @@ function buildEvaluatorRegistry(overrides, resolveJudgeProvider) {
 async function dumpPrompt(directory, evalCase, promptInputs) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `${timestamp}_${sanitizeFilename(evalCase.id)}.json`;
-  const filePath = path12.resolve(directory, filename);
-  await mkdir22(path12.dirname(filePath), { recursive: true });
+  const filePath = path122.resolve(directory, filename);
+  await mkdir22(path122.dirname(filePath), { recursive: true });
   const payload = {
     eval_id: evalCase.id,
     question: promptInputs.question,
@@ -38422,7 +38566,7 @@ async function loadEnvFromHierarchy(options) {
 
 // src/commands/eval/jsonl-writer.ts
 import { createWriteStream as createWriteStream2 } from "node:fs";
-import { mkdir as mkdir4 } from "node:fs/promises";
+import { mkdir as mkdir5 } from "node:fs/promises";
 import path14 from "node:path";
 import { finished } from "node:stream/promises";
 
@@ -38641,7 +38785,7 @@ var JsonlWriter = class _JsonlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir4(path14.dirname(filePath), { recursive: true });
+    await mkdir5(path14.dirname(filePath), { recursive: true });
     const stream = createWriteStream2(filePath, { flags: "w", encoding: "utf8" });
     return new _JsonlWriter(stream);
   }
@@ -38672,7 +38816,7 @@ var JsonlWriter = class _JsonlWriter {
 
 // src/commands/eval/yaml-writer.ts
 import { createWriteStream as createWriteStream3 } from "node:fs";
-import { mkdir as mkdir5 } from "node:fs/promises";
+import { mkdir as mkdir6 } from "node:fs/promises";
 import path15 from "node:path";
 import { finished as finished2 } from "node:stream/promises";
 import { stringify as stringifyYaml } from "yaml";
@@ -38685,7 +38829,7 @@ var YamlWriter = class _YamlWriter {
     this.stream = stream;
   }
   static async open(filePath) {
-    await mkdir5(path15.dirname(filePath), { recursive: true });
+    await mkdir6(path15.dirname(filePath), { recursive: true });
     const stream = createWriteStream3(filePath, { flags: "w", encoding: "utf8" });
     return new _YamlWriter(stream);
   }
@@ -39099,7 +39243,7 @@ import { parse as parse23 } from "yaml";
 import { readFile as readFile33 } from "node:fs/promises";
 import path23 from "node:path";
 import { parse as parse33 } from "yaml";
-import { readFile as readFile42 } from "node:fs/promises";
+import { readFile as readFile43 } from "node:fs/promises";
 import { parse as parse42 } from "yaml";
 import { readFile as readFile52 } from "node:fs/promises";
 import path33 from "node:path";
@@ -39754,7 +39898,7 @@ var SCHEMA_CONFIG_V222 = "agentv-config-v2";
 async function validateConfigFile(filePath) {
   const errors = [];
   try {
-    const content = await readFile42(filePath, "utf8");
+    const content = await readFile43(filePath, "utf8");
     const parsed = parse42(content);
     if (typeof parsed !== "object" || parsed === null) {
       errors.push({
@@ -40297,7 +40441,7 @@ async function runSingleEvalFile(params) {
   }
   const promptDumpDir = resolvePromptDirectory(options.dumpPrompts, cwd);
   if (promptDumpDir) {
-    await mkdir6(promptDumpDir, { recursive: true });
+    await mkdir7(promptDumpDir, { recursive: true });
     if (options.verbose) {
       console.log(`Prompt dumps enabled at: ${promptDumpDir}`);
     }
@@ -40550,7 +40694,7 @@ async function resolveEvalPaths(evalPaths, cwd) {
   for (const pattern of normalizedInputs) {
     const candidatePath = path19.isAbsolute(pattern) ? path19.normalize(pattern) : path19.resolve(cwd, pattern);
     try {
-      const stats = await stat3(candidatePath);
+      const stats = await stat4(candidatePath);
       if (stats.isFile() && /\.ya?ml$/i.test(candidatePath)) {
         results.add(candidatePath);
         continue;
@@ -40620,9 +40764,9 @@ function readTemplatesRecursively(dir, relativePath) {
   const entries = readdirSync(dir);
   for (const entry of entries) {
     const fullPath = path20.join(dir, entry);
-    const stat5 = statSync(fullPath);
+    const stat6 = statSync(fullPath);
     const entryRelativePath = relativePath ? path20.join(relativePath, entry) : entry;
-    if (stat5.isDirectory()) {
+    if (stat6.isDirectory()) {
       templates.push(...readTemplatesRecursively(fullPath, entryRelativePath));
     } else {
       const content = readFileSync(fullPath, "utf-8");
@@ -40861,7 +41005,7 @@ function isTTY2() {
 
 // src/commands/validate/validate-files.ts
 import { constants as constants7 } from "node:fs";
-import { access as access7, readdir as readdir3, stat as stat4 } from "node:fs/promises";
+import { access as access7, readdir as readdir3, stat as stat5 } from "node:fs/promises";
 import path24 from "node:path";
 async function validateFiles(paths) {
   const filePaths = await expandPaths(paths);
@@ -40926,7 +41070,7 @@ async function expandPaths(paths) {
       console.warn(`Warning: Path not found: ${inputPath}`);
       continue;
     }
-    const stats = await stat4(absolutePath);
+    const stats = await stat5(absolutePath);
     if (stats.isFile()) {
       if (isYamlFile(absolutePath)) {
         expanded.push(absolutePath);
@@ -41019,4 +41163,4 @@ export {
   createProgram,
   runCli
 };
-//# sourceMappingURL=chunk-PHILDJ3W.js.map
+//# sourceMappingURL=chunk-N7M3URIJ.js.map