agentv 2.14.2 → 2.14.3

package/dist/{chunk-OQN2GDEU.js → chunk-TK4PB62M.js}

@@ -632,8 +632,8 @@ function getErrorMap() {
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path40, errorMaps, issueData } = params;
-  const fullPath = [...path40, ...issueData.path || []];
+  const { data, path: path41, errorMaps, issueData } = params;
+  const fullPath = [...path41, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -749,11 +749,11 @@ var errorUtil;
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path40, key) {
+  constructor(parent, value, path41, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path40;
+    this._path = path41;
     this._key = key;
   }
   get path() {
@@ -6661,10 +6661,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path40) {
-  if (!path40)
+function getElementAtPath(obj, path41) {
+  if (!path41)
     return obj;
-  return path40.reduce((acc, key) => acc?.[key], obj);
+  return path41.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -6984,11 +6984,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path40, issues) {
+function prefixIssues(path41, issues) {
   return issues.map((iss) => {
     var _a17;
     (_a17 = iss).path ?? (_a17.path = []);
-    iss.path.unshift(path40);
+    iss.path.unshift(path41);
     return iss;
   });
 }
@@ -7125,7 +7125,7 @@ function treeifyError(error40, _mapper) {
     return issue2.message;
   };
   const result = { errors: [] };
-  const processError = (error41, path40 = []) => {
+  const processError = (error41, path41 = []) => {
     var _a17, _b8;
     for (const issue2 of error41.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -7135,7 +7135,7 @@ function treeifyError(error40, _mapper) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path40, ...issue2.path];
+        const fullpath = [...path41, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -7165,9 +7165,9 @@ function treeifyError(error40, _mapper) {
   processError(error40);
   return result;
 }
-function toDotPath(path40) {
+function toDotPath(path41) {
   const segs = [];
-  for (const seg of path40) {
+  for (const seg of path41) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -26720,14 +26720,14 @@ function createAzure(options = {}) {
     description: "Azure OpenAI resource name"
   });
   const apiVersion = (_a17 = options.apiVersion) != null ? _a17 : "v1";
-  const url2 = ({ path: path40, modelId }) => {
+  const url2 = ({ path: path41, modelId }) => {
     var _a24;
     const baseUrlPrefix = (_a24 = options.baseURL) != null ? _a24 : `https://${getResourceName()}.openai.azure.com/openai`;
     let fullUrl;
     if (options.useDeploymentBasedUrls) {
-      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path40}`);
+      fullUrl = new URL(`${baseUrlPrefix}/deployments/${modelId}${path41}`);
     } else {
-      fullUrl = new URL(`${baseUrlPrefix}/v1${path40}`);
+      fullUrl = new URL(`${baseUrlPrefix}/v1${path41}`);
     }
     fullUrl.searchParams.set("api-version", apiVersion);
     return fullUrl.toString();
@@ -33923,10 +33923,10 @@ import { tmpdir } from "node:os";
 import path16 from "node:path";
 import { exec as exec2 } from "node:child_process";
 import { constants as constants3, access as access3, stat as stat4 } from "node:fs/promises";
-import path27 from "node:path";
+import path28 from "node:path";
 import { promisify as promisify3 } from "node:util";
 import { stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path25 from "node:path";
+import path26 from "node:path";
 import { constants as constants22 } from "node:fs";
 import { access as access22, mkdir as mkdir6, readdir, rm as rm2, stat } from "node:fs/promises";
 import path17 from "node:path";
@@ -33936,21 +33936,22 @@ import { readFile as readFile8 } from "node:fs/promises";
 import path20 from "node:path";
 import { exec, spawn as spawn3 } from "node:child_process";
 import { mkdir as mkdir7, writeFile as writeFile2 } from "node:fs/promises";
-import path222 from "node:path";
+import path23 from "node:path";
 import { promisify as promisify2 } from "node:util";
+import path222 from "node:path";
 import os2 from "node:os";
 import path21 from "node:path";
 import { copyFile, mkdir as mkdir8, readFile as readFile9, readdir as readdir2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import path25 from "node:path";
 import path24 from "node:path";
-import path23 from "node:path";
 import JSON5 from "json5";
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path26 from "node:path";
+import path27 from "node:path";
 import { constants as constants4 } from "node:fs";
 import { access as access4, readFile as readFile10 } from "node:fs/promises";
-import path28 from "node:path";
-import { parse as parse32 } from "yaml";
 import path29 from "node:path";
+import { parse as parse32 } from "yaml";
+import path30 from "node:path";
 import fg2 from "fast-glob";
 import { mkdtemp as mkdtemp2, rm as rm3, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
@@ -33958,35 +33959,33 @@ import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import fs2 from "node:fs/promises";
-import path30 from "node:path";
+import path31 from "node:path";
 import { createHash as createHash2, randomUUID as randomUUID7 } from "node:crypto";
 import { mkdir as mkdir12, stat as stat7 } from "node:fs/promises";
-import path37 from "node:path";
+import path38 from "node:path";
 import micromatch4 from "micromatch";
 import { readFileSync } from "node:fs";
-import path31 from "node:path";
 import path322 from "node:path";
+import path33 from "node:path";
 import fg3 from "fast-glob";
 import { exec as execCallback } from "node:child_process";
 import { readdirSync as readdirSync2, statSync } from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 import { promisify as promisify4 } from "node:util";
 import { cp, mkdir as mkdir10, readdir as readdir3, rm as rm4, stat as stat5 } from "node:fs/promises";
-import os3 from "node:os";
-import path34 from "node:path";
+import path35 from "node:path";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
 import { mkdir as mkdir11, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
-import os4 from "node:os";
-import path35 from "node:path";
+import path36 from "node:path";
 import { promisify as promisify5 } from "node:util";
 import { readdir as readdir4, stat as stat6 } from "node:fs/promises";
-import path36 from "node:path";
+import path37 from "node:path";
 import { existsSync as existsSync3 } from "node:fs";
-import path38 from "node:path";
-import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
 import path39 from "node:path";
+import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
+import path40 from "node:path";
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -34183,7 +34182,7 @@ async function resolveFileReference2(ref, evalFileDir) {
   const rawPath = extractFilePath(ref);
   const absolutePattern = path3.resolve(evalFileDir, rawPath);
   if (isGlobPattern(rawPath)) {
-    const matches = await fg(absolutePattern, {
+    const matches = await fg(absolutePattern.replaceAll("\\", "/"), {
       onlyFiles: true,
       absolute: true
     });
@@ -38891,7 +38890,7 @@ function subscribeToCopilotCliLogEntries(listener) {
   };
 }
 function resolvePlatformCliPath() {
-  const os5 = platform();
+  const os3 = platform();
   const cpu = arch();
   const platformMap = {
     linux: "linux",
@@ -38902,13 +38901,13 @@ function resolvePlatformCliPath() {
     x64: "x64",
     arm64: "arm64"
   };
-  const osPart = platformMap[os5];
+  const osPart = platformMap[os3];
   const archPart = archMap[cpu];
   if (!osPart || !archPart) {
     return void 0;
   }
   const packageName = `@github/copilot-${osPart}-${archPart}`;
-  const binaryName = os5 === "win32" ? "copilot.exe" : "copilot";
+  const binaryName = os3 === "win32" ? "copilot.exe" : "copilot";
   try {
     const resolved = import.meta.resolve(`${packageName}/package.json`);
     const packageJsonPath = resolved.startsWith("file:") ? fileURLToPath2(resolved) : resolved;
@@ -40915,11 +40914,35 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
   }
   return true;
 }
+var logged = false;
+function getAgentvHome() {
+  const envHome = process.env.AGENTV_HOME;
+  if (envHome) {
+    if (!logged) {
+      logged = true;
+      console.warn(`Using AGENTV_HOME: ${envHome}`);
+    }
+    return envHome;
+  }
+  return path21.join(os2.homedir(), ".agentv");
+}
+function getWorkspacesRoot() {
+  return path21.join(getAgentvHome(), "workspaces");
+}
+function getGitCacheRoot() {
+  return path21.join(getAgentvHome(), "git-cache");
+}
+function getSubagentsRoot() {
+  return path21.join(getAgentvHome(), "subagents");
+}
+function getTraceStateRoot() {
+  return path21.join(getAgentvHome(), "trace-state");
+}
 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 path21.join(os2.homedir(), ".agentv", "subagents", folder);
+  return path222.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 var execAsync2 = promisify2(exec);
@@ -40931,12 +40954,19 @@ description: 'Wake-up Signal'
 model: Grok Code Fast 1 (copilot)
 ---`;
 function spawnVsCode(vscodeCmd, args, options) {
-  const child = spawn3(vscodeCmd, args, {
+  const useShell = options?.shell ?? true;
+  const command = useShell ? shellQuote(vscodeCmd) : vscodeCmd;
+  const child = spawn3(command, args, {
     windowsHide: true,
-    shell: options?.shell ?? true,
+    shell: useShell,
     detached: false
   });
-  child.on("error", () => {
+  child.on("error", (error40) => {
+    const label = options?.label ?? "spawn";
+    const renderedArgs = args.map((value) => JSON.stringify(value)).join(" ");
+    console.error(
+      `[vscode] ${label} failed: command=${JSON.stringify(vscodeCmd)} args=${renderedArgs} error=${error40.message}`
+    );
   });
   return child;
 }
@@ -40973,16 +41003,20 @@ async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
 async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir, vscodeCmd, pollInterval = 1, timeout = 60) {
   const alreadyOpen = await checkWorkspaceOpened(workspaceName, vscodeCmd);
   if (alreadyOpen) {
-    spawnVsCode(shellQuote(vscodeCmd), [workspacePath]);
+    const child = spawnVsCode(vscodeCmd, [workspacePath], { label: "focus-existing-workspace" });
+    await raceSpawnError(child);
     return true;
   }
-  const aliveFile = path222.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path23.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path222.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path23.join(subagentDir, ".github", "agents");
   await mkdir7(githubAgentsDir, { recursive: true });
-  const wakeupDst = path222.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = path23.join(githubAgentsDir, "wakeup.md");
   await writeFile2(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
-  spawnVsCode(shellQuote(vscodeCmd), [workspacePath]);
+  const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
+    label: "open-workspace"
+  });
+  await raceSpawnError(workspaceChild);
   await sleep2(100);
   const wakeupChatId = "wakeup";
   const chatArgs = [
@@ -40990,9 +41024,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path222.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path23.basename(subagentDir)} folder`
   ];
-  spawnVsCode(shellQuote(vscodeCmd), chatArgs);
+  const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
+  await raceSpawnError(wakeupChild);
   const start = Date.now();
   while (!await pathExists(aliveFile)) {
     if (Date.now() - start > timeout * 1e3) {
@@ -41004,10 +41039,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = path222.join(subagentDir, `${path222.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path222.join(subagentDir, "messages");
+  const workspacePath = path23.join(subagentDir, `${path23.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path23.join(subagentDir, "messages");
   await mkdir7(messagesDir, { recursive: true });
-  const reqFile = path222.join(messagesDir, `${timestamp}_req.md`);
+  const reqFile = path23.join(messagesDir, `${timestamp}_req.md`);
   await writeFile2(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
@@ -41015,25 +41050,25 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${path222.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${path23.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path222.basename(subagentDir),
+    path23.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path222.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path23.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
-  const child = spawnVsCode(shellQuote(vscodeCmd), chatArgs);
+  const child = spawnVsCode(vscodeCmd, chatArgs, { label: "send-chat" });
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = path222.join(subagentDir, `${path222.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path222.join(subagentDir, "messages");
+  const workspacePath = path23.join(subagentDir, `${path23.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path23.join(subagentDir, "messages");
   await mkdir7(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -41042,17 +41077,17 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path222.basename(subagentDir),
+    path23.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path222.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path23.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
-  const child = spawnVsCode(shellQuote(vscodeCmd), chatArgs);
+  const child = spawnVsCode(vscodeCmd, chatArgs, { label: "send-batch-chat" });
   await raceSpawnError(child);
 }
 function transformWorkspacePaths(workspaceContent, templateDir) {
@@ -41070,10 +41105,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path23.isAbsolute(folderPath)) {
+    if (path24.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path23.resolve(templateDir, folderPath);
+    const absolutePath = path24.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -41095,19 +41130,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path23.isAbsolute(locationPath);
+          const isAbsolute = path24.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path23.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path24.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 = (path23.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path24.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -41146,7 +41181,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 = path24.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path25.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -41156,7 +41191,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path24.resolve(workspaceTemplate);
+    const workspaceSrc = path25.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -41169,13 +41204,13 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path24.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path24.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path24.dirname(path24.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path25.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path25.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path25.dirname(path25.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = path24.resolve(cwd);
+    const absCwd = path25.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -41184,35 +41219,35 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     }
   }
   await writeFile3(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path24.join(subagentDir, "messages");
+  const messagesDir = path25.join(subagentDir, "messages");
   await mkdir8(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path24.join(subagentDir, "messages");
+  const messagesDir = path25.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir2(messagesDir);
     await Promise.all(
       files.map(async (file2) => {
-        const target = path24.join(messagesDir, file2);
+        const target = path25.join(messagesDir, file2);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path24.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path25.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(path24.join(githubAgentsDir, file2)))
+      agentFiles.filter((file2) => file2.endsWith(".md") && !preservedFiles.has(file2)).map((file2) => removeIfExists(path25.join(githubAgentsDir, file2)))
     );
   }
-  const lockFile = path24.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path25.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile3(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path24.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path25.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -41232,9 +41267,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path24.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = path25.join(subagentDir, ".github", "agents");
     await mkdir8(githubAgentsDir, { recursive: true });
-    const agentFile = path24.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = path25.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error40) {
@@ -41251,7 +41286,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path25.resolve(promptFile);
+  const resolvedPrompt = path26.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -41267,7 +41302,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path25.resolve(attachment);
+    const resolvedPath = path26.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -41309,7 +41344,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path25.basename(subagentDir);
+    const subagentName = path26.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -41337,9 +41372,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path25.join(subagentDir, "messages");
-    const responseFileTmp = path25.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path25.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path26.join(subagentDir, "messages");
+    const responseFileTmp = path26.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path26.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -41444,7 +41479,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path25.basename(subagentDir);
+    subagentName = path26.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -41475,17 +41510,17 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path25.join(subagentDir, "messages");
+    const messagesDir = path26.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path25.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path26.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path25.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path26.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path25.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path26.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path25.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path26.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
@@ -41598,7 +41633,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path26.resolve(targetRoot);
+  const targetPath = path27.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -41618,7 +41653,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path26.join(entry.absolutePath, lockName);
+      const lockFile = path27.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -41635,10 +41670,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path26.join(subagentDir, ".github", "agents");
-    const lockFile = path26.join(subagentDir, lockName);
-    const workspaceDst = path26.join(subagentDir, `${path26.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path26.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+    const lockFile = path27.join(subagentDir, lockName);
+    const workspaceDst = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path27.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -41676,10 +41711,10 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path26.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path26.join(subagentDir, ".github", "agents");
-    const workspaceDst = path26.join(subagentDir, `${path26.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path26.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path27.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+    const workspaceDst = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path27.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -41869,7 +41904,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path27.isAbsolute(candidate) ? candidate : path27.resolve(candidate);
+    const resolved = path28.isAbsolute(candidate) ? candidate : path28.resolve(candidate);
     try {
       await access3(resolved, constants3.F_OK);
       return resolved;
@@ -41898,7 +41933,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await stat4(path27.resolve(template));
+    const stats = await stat4(path28.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -41924,7 +41959,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path27.basename(absolutePath);
+    const fileName = path28.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -41949,8 +41984,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path27.resolve(attachment);
-    const normalized = absolutePath.split(path27.sep).join("/");
+    const absolutePath = path28.resolve(attachment);
+    const normalized = absolutePath.split(path28.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -41965,7 +42000,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path27.resolve(attachment);
+    const absolutePath = path28.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -41973,7 +42008,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path27.isAbsolute(filePath) ? filePath : path27.resolve(filePath);
+  const absolutePath = path28.isAbsolute(filePath) ? filePath : path28.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -41986,7 +42021,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path27.resolve(attachment));
+    deduped.add(path28.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -41995,7 +42030,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path27.resolve(inputFile));
+      deduped.add(path28.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -42075,7 +42110,7 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path28.resolve(filePath);
+  const absolutePath = path29.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
@@ -42096,11 +42131,11 @@ function listTargetNames(definitions) {
 async function discoverProviders(registry2, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path29.resolve(baseDir);
-  const root = path29.parse(dir).root;
+  let dir = path30.resolve(baseDir);
+  const root = path30.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path29.join(dir, ".agentv", "providers"));
-    dir = path29.dirname(dir);
+    candidateDirs.push(path30.join(dir, ".agentv", "providers"));
+    dir = path30.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -42116,7 +42151,7 @@ async function discoverProviders(registry2, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = path29.basename(filePath);
+    const basename = path30.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry2.has(kindName)) {
       continue;
@@ -42314,13 +42349,13 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
 async function execShellWithStdin(command, stdinPayload, options = {}) {
   const { mkdir: mkdir14, readFile: readFile12, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const path40 = await import("node:path");
+  const path41 = await import("node:path");
   const { randomUUID: randomUUID8 } = await import("node:crypto");
-  const dir = path40.join(tmpdir3(), `agentv-exec-${randomUUID8()}`);
+  const dir = path41.join(tmpdir3(), `agentv-exec-${randomUUID8()}`);
   await mkdir14(dir, { recursive: true });
-  const stdinPath = path40.join(dir, "stdin.txt");
-  const stdoutPath = path40.join(dir, "stdout.txt");
-  const stderrPath = path40.join(dir, "stderr.txt");
+  const stdinPath = path41.join(dir, "stdin.txt");
+  const stdoutPath = path41.join(dir, "stdout.txt");
+  const stderrPath = path41.join(dir, "stderr.txt");
   await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn4 } = await import("node:child_process");
@@ -42664,7 +42699,7 @@ var CodeEvaluator = class {
       outputPath,
       guidelineFiles: context.evalCase.guideline_paths,
       inputFiles: context.evalCase.file_paths.filter(
-        (path40) => !context.evalCase.guideline_paths.includes(path40)
+        (path41) => !context.evalCase.guideline_paths.includes(path41)
       ),
       input: context.evalCase.input,
       trace: context.trace ?? null,
@@ -43847,115 +43882,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path40, match, required: required2 = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path40);
-    const expectedValue = resolvePath(expectedData, path40);
+    const { path: path41, match, required: required2 = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path41);
+    const expectedValue = resolvePath(expectedData, path41);
     if (expectedValue === void 0) {
       return {
-        path: path40,
+        path: path41,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path40}: no expected value`
+        message: `${path41}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required2) {
         return {
-          path: path40,
+          path: path41,
           score: 0,
           weight,
           hit: false,
-          message: `${path40} (required, missing)`
+          message: `${path41} (required, missing)`
         };
       }
       return {
-        path: path40,
+        path: path41,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path40}: optional field missing`
+        message: `${path41}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path40, candidateValue, expectedValue, weight);
+        return this.compareExact(path41, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path40,
+          path41,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path40, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path41, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path40,
+          path: path41,
           score: 0,
           weight,
           hit: false,
-          message: `${path40}: unknown match type "${match}"`
+          message: `${path41}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path40, candidateValue, expectedValue, weight) {
+  compareExact(path41, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path40,
+        path: path41,
         score: 1,
         weight,
         hit: true,
-        message: path40
+        message: path41
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path40,
+        path: path41,
         score: 0,
         weight,
         hit: false,
-        message: `${path40} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path41} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path40,
+      path: path41,
       score: 0,
       weight,
       hit: false,
-      message: `${path40} (value mismatch)`
+      message: `${path41} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path40, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path41, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber2(candidateValue);
     const expectedNum = toNumber2(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path40,
+        path: path41,
         score: 0,
         weight,
         hit: false,
-        message: `${path40} (non-numeric value)`
+        message: `${path41} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path40,
+        path: path41,
         score: 0,
         weight,
         hit: false,
-        message: `${path40} (invalid numeric value)`
+        message: `${path41} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -43968,61 +44003,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path40,
+        path: path41,
         score: 1,
         weight,
         hit: true,
-        message: `${path40} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path41} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path40,
+      path: path41,
       score: 0,
       weight,
       hit: false,
-      message: `${path40} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path41} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path40, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path41, candidateValue, expectedValue, fieldConfig, weight) {
     const formats = fieldConfig.formats ?? DEFAULT_DATE_FORMATS;
     const candidateDate = parseDate(String(candidateValue), formats);
     const expectedDate = parseDate(String(expectedValue), formats);
     if (candidateDate === null) {
       return {
-        path: path40,
+        path: path41,
         score: 0,
         weight,
         hit: false,
-        message: `${path40} (unparseable candidate date)`
+        message: `${path41} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path40,
+        path: path41,
         score: 0,
         weight,
         hit: false,
-        message: `${path40} (unparseable expected date)`
+        message: `${path41} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path40,
+        path: path41,
         score: 1,
         weight,
         hit: true,
-        message: path40
+        message: path41
       };
     }
     return {
-      path: path40,
+      path: path41,
       score: 0,
       weight,
       hit: false,
-      message: `${path40} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path41} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -44063,11 +44098,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path40) {
-  if (!path40 || !obj) {
+function resolvePath(obj, path41) {
+  if (!path41 || !obj) {
     return void 0;
   }
-  const parts = path40.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path41.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -44540,8 +44575,8 @@ ${outputSchema2}`;
   }
 };
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = path30.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + path30.sep) && resolved !== basePath) {
+  const resolved = path31.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + path31.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -44624,11 +44659,11 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = path30.join(dirPath, entry.name);
+    const fullPath = path31.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = path30.extname(entry.name).toLowerCase();
+      const ext = path31.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
         const stat8 = await fs2.stat(fullPath);
@@ -44640,7 +44675,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: path30.relative(workspacePath, fullPath),
+              file: path31.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -44871,8 +44906,8 @@ var TokenUsageEvaluator = class {
     };
   }
 };
-function getNestedValue(obj, path40) {
-  const parts = path40.split(".");
+function getNestedValue(obj, path41) {
+  const parts = path41.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -45655,7 +45690,7 @@ async function executePromptTemplate(script, context, config2, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path31.dirname(scriptPath);
+  const cwd = path322.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -45947,11 +45982,11 @@ function createBuiltinRegistry() {
 async function discoverAssertions(registry2, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path322.resolve(baseDir);
-  const root = path322.parse(dir).root;
+  let dir = path33.resolve(baseDir);
+  const root = path33.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path322.join(dir, ".agentv", "assertions"));
-    dir = path322.dirname(dir);
+    candidateDirs.push(path33.join(dir, ".agentv", "assertions"));
+    dir = path33.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -45967,7 +46002,7 @@ async function discoverAssertions(registry2, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path322.basename(filePath);
+    const basename = path33.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry2.has(typeName)) {
       continue;
@@ -46153,10 +46188,10 @@ async function stageNestedRepoChanges(workspacePath) {
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = path33.join(workspacePath, entry);
+    const childPath = path34.join(workspacePath, entry);
     try {
       if (!statSync(childPath).isDirectory()) continue;
-      if (!statSync(path33.join(childPath, ".git")).isDirectory()) continue;
+      if (!statSync(path34.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -46164,7 +46199,6 @@ async function stageNestedRepoChanges(workspacePath) {
     await execAsync4("git add -A", childOpts);
   }
 }
-var DEFAULT_WORKSPACE_ROOT = path34.join(os3.homedir(), ".agentv", "workspaces");
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
     super(`Workspace template not found: ${templatePath}`);
@@ -46193,15 +46227,15 @@ async function isDirectory(filePath) {
   }
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
-  const root = workspaceRoot ?? DEFAULT_WORKSPACE_ROOT;
-  return path34.join(root, evalRunId, caseId);
+  const root = workspaceRoot ?? getWorkspacesRoot();
+  return path35.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
   await mkdir10(dest, { recursive: true });
   const entries = await readdir3(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path34.join(src, entry.name);
-    const destPath = path34.join(dest, entry.name);
+    const srcPath = path35.join(src, entry.name);
+    const destPath = path35.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -46213,7 +46247,7 @@ async function copyDirectoryRecursive(src, dest) {
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = path34.resolve(templatePath);
+  const resolvedTemplatePath = path35.resolve(templatePath);
   if (!await fileExists(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -46261,14 +46295,13 @@ async function cleanupWorkspace(workspacePath) {
   }
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
-  const root = workspaceRoot ?? DEFAULT_WORKSPACE_ROOT;
-  const evalDir = path34.join(root, evalRunId);
+  const root = workspaceRoot ?? getWorkspacesRoot();
+  const evalDir = path35.join(root, evalRunId);
   if (await fileExists(evalDir)) {
     await rm4(evalDir, { recursive: true, force: true });
   }
 }
 var execFileAsync = promisify5(execFile);
-var DEFAULT_CACHE_DIR = path35.join(os4.homedir(), ".agentv", "git-cache");
 var DEFAULT_TIMEOUT_MS2 = 3e5;
 var LOCK_TIMEOUT_MS = 6e4;
 function gitEnv() {
@@ -46326,8 +46359,35 @@ async function releaseLock(lockPath) {
 }
 var RepoManager = class {
   cacheDir;
-  constructor(cacheDir) {
-    this.cacheDir = cacheDir ?? DEFAULT_CACHE_DIR;
+  verbose;
+  constructor(cacheDir, verbose = false) {
+    this.cacheDir = cacheDir ?? getGitCacheRoot();
+    this.verbose = verbose;
+  }
+  async runGit(args, opts) {
+    const startedAt = Date.now();
+    if (this.verbose) {
+      console.log(
+        `[repo] git start cwd=${opts?.cwd ?? process.cwd()} args=${args.join(" ")}`
+      );
+    }
+    try {
+      const output = await git(args, opts);
+      if (this.verbose) {
+        console.log(
+          `[repo] git ok durationMs=${Date.now() - startedAt} args=${args.join(" ")}`
+        );
+      }
+      return output;
+    } catch (error40) {
+      if (this.verbose) {
+        const message = error40 instanceof Error ? error40.message : String(error40);
+        console.log(
+          `[repo] git fail durationMs=${Date.now() - startedAt} args=${args.join(" ")} error=${message}`
+        );
+      }
+      throw error40;
+    }
   }
   /**
    * Ensure a bare mirror cache exists for the given source.
@@ -46336,11 +46396,19 @@ var RepoManager = class {
    */
   async ensureCache(source, depth, resolve2) {
     const key = cacheKey(source);
-    const cachePath = path35.join(this.cacheDir, key);
+    const cachePath = path36.join(this.cacheDir, key);
     const lockPath = `${cachePath}.lock`;
-    const cacheExists = existsSync2(path35.join(cachePath, "HEAD"));
+    const cacheExists = existsSync2(path36.join(cachePath, "HEAD"));
+    if (this.verbose) {
+      console.log(
+        `[repo] ensureCache source=${getSourceUrl(source)} resolve=${resolve2 ?? "remote"} cache=${cachePath}`
+      );
+    }
     if (resolve2 === "local") {
       if (cacheExists) {
+        if (this.verbose) {
+          console.log(`[repo] using existing local cache ${cachePath}`);
+        }
         return cachePath;
       }
       const url2 = getSourceUrl(source);
@@ -46349,15 +46417,27 @@ var RepoManager = class {
       );
     }
     await mkdir11(this.cacheDir, { recursive: true });
+    const lockStartedAt = Date.now();
     await acquireLock(lockPath);
+    if (this.verbose) {
+      console.log(
+        `[repo] lock acquired path=${lockPath} waitedMs=${Date.now() - lockStartedAt}`
+      );
+    }
     try {
       if (cacheExists) {
+        if (this.verbose) {
+          console.log(`[repo] refreshing existing cache ${cachePath}`);
+        }
         const fetchArgs = ["fetch", "--prune"];
         if (depth) {
           fetchArgs.push("--depth", String(depth));
         }
-        await git(fetchArgs, { cwd: cachePath });
+        await this.runGit(fetchArgs, { cwd: cachePath });
       } else {
+        if (this.verbose) {
+          console.log(`[repo] creating new cache ${cachePath}`);
+        }
         const cloneArgs = ["clone", "--mirror", "--bare"];
         if (depth) {
           cloneArgs.push("--depth", String(depth));
@@ -46365,10 +46445,13 @@ var RepoManager = class {
         const sourceUrl = getSourceUrl(source);
         const cloneUrl = depth && source.type === "local" ? `file://${sourceUrl}` : sourceUrl;
         cloneArgs.push(cloneUrl, cachePath);
-        await git(cloneArgs);
+        await this.runGit(cloneArgs);
       }
     } finally {
       await releaseLock(lockPath);
+      if (this.verbose) {
+        console.log(`[repo] lock released path=${lockPath}`);
+      }
     }
     return cachePath;
   }
@@ -46377,7 +46460,13 @@ var RepoManager = class {
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = path35.join(workspacePath, repo.path);
+    const targetDir = path36.join(workspacePath, repo.path);
+    const startedAt = Date.now();
+    if (this.verbose) {
+      console.log(
+        `[repo] materialize start path=${repo.path} source=${getSourceUrl(repo.source)} workspace=${workspacePath}`
+      );
+    }
     const cachePath = await this.ensureCache(
       repo.source,
       repo.clone?.depth,
@@ -46393,10 +46482,10 @@ var RepoManager = class {
     cloneArgs.push("--no-checkout");
     const cloneUrl = repo.clone?.depth || repo.clone?.filter ? `file://${cachePath}` : cachePath;
     cloneArgs.push(cloneUrl, targetDir);
-    await git(cloneArgs);
+    await this.runGit(cloneArgs);
     if (repo.clone?.sparse?.length) {
-      await git(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
-      await git(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
+      await this.runGit(["sparse-checkout", "init", "--cone"], { cwd: targetDir });
+      await this.runGit(["sparse-checkout", "set", ...repo.clone.sparse], { cwd: targetDir });
     }
     const ref = repo.checkout?.ref ?? "HEAD";
     const resolve2 = repo.checkout?.resolve ?? "remote";
@@ -46404,7 +46493,7 @@ var RepoManager = class {
     if (resolve2 === "remote" && repo.source.type === "git") {
       const url2 = getSourceUrl(repo.source);
       try {
-        const lsOutput = await git(["ls-remote", url2, ref]);
+        const lsOutput = await this.runGit(["ls-remote", url2, ref]);
         const match = lsOutput.split("	")[0];
         if (!match) {
           throw new Error(`Ref '${ref}' not found on remote ${url2}`);
@@ -46417,17 +46506,26 @@ var RepoManager = class {
     } else {
       resolvedSha = ref;
     }
-    await git(["checkout", resolvedSha], { cwd: targetDir });
+    if (this.verbose) {
+      console.log(
+        `[repo] checkout path=${repo.path} ref=${ref} resolved=${resolvedSha} resolve=${resolve2}`
+      );
+    }
+    await this.runGit(["checkout", resolvedSha], { cwd: targetDir });
     const ancestor = repo.checkout?.ancestor ?? 0;
     if (ancestor > 0) {
       try {
-        const ancestorSha = await git(["rev-parse", `HEAD~${ancestor}`], { cwd: targetDir });
-        await git(["checkout", ancestorSha], { cwd: targetDir });
+        const ancestorSha = await this.runGit(["rev-parse", `HEAD~${ancestor}`], {
+          cwd: targetDir
+        });
+        await this.runGit(["checkout", ancestorSha], { cwd: targetDir });
       } catch {
         if (repo.clone?.depth) {
-          await git(["fetch", "--deepen", String(ancestor)], { cwd: targetDir });
-          const ancestorSha = await git(["rev-parse", `HEAD~${ancestor}`], { cwd: targetDir });
-          await git(["checkout", ancestorSha], { cwd: targetDir });
+          await this.runGit(["fetch", "--deepen", String(ancestor)], { cwd: targetDir });
+          const ancestorSha = await this.runGit(["rev-parse", `HEAD~${ancestor}`], {
+            cwd: targetDir
+          });
+          await this.runGit(["checkout", ancestorSha], { cwd: targetDir });
         } else {
           throw new Error(
             `Cannot resolve ancestor ${ancestor} of ref '${ref}'. If using shallow clone, increase clone.depth to at least ${ancestor + 1}.`
@@ -46435,27 +46533,38 @@ var RepoManager = class {
         }
       }
     }
+    if (this.verbose) {
+      console.log(
+        `[repo] materialize done path=${repo.path} target=${targetDir} durationMs=${Date.now() - startedAt}`
+      );
+    }
   }
   /** Materialize all repos into the workspace. */
   async materializeAll(repos, workspacePath) {
+    if (this.verbose) {
+      console.log(`[repo] materializeAll count=${repos.length} workspace=${workspacePath}`);
+    }
     for (const repo of repos) {
       await this.materialize(repo, workspacePath);
     }
+    if (this.verbose) {
+      console.log("[repo] materializeAll complete");
+    }
   }
   /** Reset repos in workspace to their checkout state. */
   async reset(repos, workspacePath, strategy) {
     if (strategy === "recreate") {
       for (const repo of repos) {
-        const targetDir = path35.join(workspacePath, repo.path);
+        const targetDir = path36.join(workspacePath, repo.path);
         await rm5(targetDir, { recursive: true, force: true });
       }
       await this.materializeAll(repos, workspacePath);
       return;
     }
     for (const repo of repos) {
-      const targetDir = path35.join(workspacePath, repo.path);
-      await git(["reset", "--hard", "HEAD"], { cwd: targetDir });
-      await git(["clean", "-fd"], { cwd: targetDir });
+      const targetDir = path36.join(workspacePath, repo.path);
+      await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
+      await this.runGit(["clean", "-fd"], { cwd: targetDir });
     }
   }
   /**
@@ -46465,12 +46574,12 @@ var RepoManager = class {
   async seedCache(localPath, remoteUrl, opts) {
     const source = { type: "git", url: remoteUrl };
     const key = cacheKey(source);
-    const cachePath = path35.join(this.cacheDir, key);
+    const cachePath = path36.join(this.cacheDir, key);
     const lockPath = `${cachePath}.lock`;
     await mkdir11(this.cacheDir, { recursive: true });
     await acquireLock(lockPath);
     try {
-      if (existsSync2(path35.join(cachePath, "HEAD"))) {
+      if (existsSync2(path36.join(cachePath, "HEAD"))) {
         if (!opts?.force) {
           throw new Error(
             `Cache already exists for ${remoteUrl} at ${cachePath}. Use force to overwrite.`
@@ -46494,11 +46603,11 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = path36.resolve(templatePath);
+  const resolved = path37.resolve(templatePath);
   const stats = await stat6(resolved);
   if (stats.isFile()) {
     return {
-      dir: path36.dirname(resolved),
+      dir: path37.dirname(resolved),
       workspaceFile: resolved
     };
   }
@@ -46510,14 +46619,14 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: path36.join(resolved, workspaceFiles[0])
+      workspaceFile: path37.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? path36.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? path37.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -46669,7 +46778,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveJudgeProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path37.dirname(path37.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path38.dirname(path38.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   const providerRegistry = createBuiltinProviderRegistry();
@@ -46725,10 +46834,18 @@ async function runEvaluation(options) {
   const resolvedTemplate = await resolveWorkspaceTemplate(rawTemplate);
   const workspaceTemplate = resolvedTemplate?.dir;
   let suiteWorkspaceFile = resolvedTemplate?.workspaceFile;
+  const setupLog = (message) => {
+    if (verbose) {
+      console.log(`[setup] ${message}`);
+    }
+  };
   const isPerTestIsolation = suiteWorkspace?.isolation === "per_test";
   const hasSharedWorkspace = !!(workspaceTemplate || suiteWorkspace?.before_all || suiteWorkspace?.repos?.length && !isPerTestIsolation);
   const requestedWorkers = options.maxConcurrency ?? target.workers ?? 1;
   const workers = hasSharedWorkspace ? 1 : requestedWorkers;
+  setupLog(
+    `sharedWorkspace=${hasSharedWorkspace} perTestIsolation=${isPerTestIsolation} requestedWorkers=${requestedWorkers} effectiveWorkers=${workers}`
+  );
   if (hasSharedWorkspace && requestedWorkers > 1) {
     console.warn(
       `Warning: Shared workspace requires sequential execution. Overriding workers from ${requestedWorkers} to 1.`
@@ -46739,14 +46856,16 @@ async function runEvaluation(options) {
   let sharedBaselineCommit;
   let beforeAllOutput;
   if (workspaceTemplate) {
+    setupLog(`creating shared workspace from template: ${workspaceTemplate}`);
     try {
       sharedWorkspacePath = await createTempWorkspace(workspaceTemplate, evalRunId, "shared");
+      setupLog(`shared workspace created at: ${sharedWorkspacePath}`);
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
       throw new Error(`Failed to create shared workspace: ${message}`);
     }
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = path37.join(sharedWorkspacePath, path37.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = path38.join(sharedWorkspacePath, path38.basename(suiteWorkspaceFile));
       try {
         await stat7(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
@@ -46756,11 +46875,14 @@ async function runEvaluation(options) {
   } else if (suiteWorkspace?.before_all || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
     await mkdir12(sharedWorkspacePath, { recursive: true });
+    setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
-  const repoManager = suiteWorkspace?.repos?.length ? new RepoManager() : void 0;
+  const repoManager = suiteWorkspace?.repos?.length ? new RepoManager(void 0, verbose) : void 0;
   if (repoManager && sharedWorkspacePath && suiteWorkspace?.repos && !isPerTestIsolation) {
+    setupLog(`materializing ${suiteWorkspace.repos.length} shared repo(s) into ${sharedWorkspacePath}`);
     try {
       await repoManager.materializeAll(suiteWorkspace.repos, sharedWorkspacePath);
+      setupLog("shared repo materialization complete");
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
       if (sharedWorkspacePath) {
@@ -46771,6 +46893,10 @@ async function runEvaluation(options) {
     }
   }
   if (sharedWorkspacePath && suiteWorkspace?.before_all) {
+    const beforeAllCommand = (suiteWorkspace.before_all.command ?? suiteWorkspace.before_all.script ?? []).join(" ");
+    setupLog(
+      `running shared before_all in cwd=${suiteWorkspace.before_all.cwd ?? evalDir} command=${beforeAllCommand}`
+    );
     const scriptContext = {
       workspacePath: sharedWorkspacePath,
       testId: "__before_all__",
@@ -46779,6 +46905,7 @@ async function runEvaluation(options) {
     };
     try {
       beforeAllOutput = await executeWorkspaceScript(suiteWorkspace.before_all, scriptContext);
+      setupLog("shared before_all completed");
     } catch (error40) {
       const message = error40 instanceof Error ? error40.message : String(error40);
       if (sharedWorkspacePath) {
@@ -46791,7 +46918,9 @@ async function runEvaluation(options) {
   if (sharedWorkspacePath) {
     try {
       sharedBaselineCommit = await initializeBaseline(sharedWorkspacePath);
+      setupLog(`shared baseline initialized: ${sharedBaselineCommit}`);
     } catch {
+      setupLog("shared baseline initialization skipped (non-fatal)");
     }
   }
   let nextWorkerId = 1;
@@ -47195,6 +47324,7 @@ async function runEvalCase(options) {
     repoManager,
     evalDir
   } = options;
+  const setupDebug = process.env.AGENTV_SETUP_DEBUG === "1";
   const formattingMode = usesFileReferencePrompt(provider) ? "agent" : "lm";
   const promptInputs = await buildPromptInputs(evalCase, formattingMode);
   const typeRegistry = providedTypeRegistry ?? createBuiltinRegistry();
@@ -47232,7 +47362,7 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = path37.join(workspacePath, path37.basename(caseWorkspaceFile));
+        const copiedFile = path38.join(workspacePath, path38.basename(caseWorkspaceFile));
         try {
           await stat7(copiedFile);
           caseWorkspaceFile = copiedFile;
@@ -47245,9 +47375,17 @@ async function runEvalCase(options) {
       await mkdir12(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
-      const perCaseRepoManager = new RepoManager();
+      const perCaseRepoManager = new RepoManager(void 0, setupDebug);
       try {
+        if (setupDebug) {
+          console.log(
+            `[setup] test=${evalCase.id} materializing ${evalCase.workspace.repos.length} per-test repo(s) into ${workspacePath}`
+          );
+        }
         await perCaseRepoManager.materializeAll(evalCase.workspace.repos, workspacePath);
+        if (setupDebug) {
+          console.log(`[setup] test=${evalCase.id} per-test repo materialization complete`);
+        }
       } catch (error40) {
         const message = error40 instanceof Error ? error40.message : String(error40);
         return buildErrorResult(
@@ -47263,6 +47401,12 @@ async function runEvalCase(options) {
       }
     }
     if (workspacePath && evalCase.workspace?.before_all) {
+      const beforeAllCommand = (evalCase.workspace.before_all.command ?? evalCase.workspace.before_all.script ?? []).join(" ");
+      if (setupDebug) {
+        console.log(
+          `[setup] test=${evalCase.id} running before_all in cwd=${evalCase.workspace.before_all.cwd ?? evalDir} command=${beforeAllCommand}`
+        );
+      }
       const scriptContext = {
         workspacePath,
         testId: evalCase.id,
@@ -47276,6 +47420,9 @@ async function runEvalCase(options) {
           evalCase.workspace.before_all,
           scriptContext
         );
+        if (setupDebug) {
+          console.log(`[setup] test=${evalCase.id} before_all completed`);
+        }
       } catch (error40) {
         const message = error40 instanceof Error ? error40.message : String(error40);
         if (forceCleanup && workspacePath) {
@@ -47825,7 +47972,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  const evalFileDir = evalCase.guideline_paths[0] ? path37.dirname(evalCase.guideline_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.guideline_paths[0] ? path38.dirname(evalCase.guideline_paths[0]) : process.cwd();
   const dispatchContext = {
     judgeProvider,
     targetResolver,
@@ -48146,13 +48293,13 @@ async function evaluate(config2) {
   let evalCases;
   let testFilePath;
   if (config2.specFile) {
-    testFilePath = path38.resolve(config2.specFile);
+    testFilePath = path39.resolve(config2.specFile);
     evalCases = await loadTests(testFilePath, repoRoot, {
       verbose: config2.verbose,
       filter: config2.filter
     });
   } else {
-    testFilePath = path38.join(process.cwd(), "__programmatic__.yaml");
+    testFilePath = path39.join(process.cwd(), "__programmatic__.yaml");
     evalCases = (config2.tests ?? []).map((test) => {
       const input = typeof test.input === "string" ? [{ role: "user", content: test.input }] : test.input;
       const question = typeof test.input === "string" ? test.input : test.input.find((m) => m.role === "user")?.content ?? "";
@@ -48238,10 +48385,10 @@ function computeSummary(results, durationMs) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path38.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path39.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path38.join(dir, candidate);
+      const targetsPath = path39.join(dir, candidate);
       if (!existsSync3(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -48256,10 +48403,10 @@ async function discoverDefaultTarget(repoRoot) {
 async function loadEnvHierarchy(repoRoot) {
   const { readFileSync: readFileSync2 } = await import("node:fs");
   const cwd = process.cwd();
-  const chain = buildDirectoryChain(path38.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path39.join(cwd, "_placeholder"), repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path38.join(dir, ".env");
+    const envPath = path39.join(dir, ".env");
     if (existsSync3(envPath)) envFiles.push(envPath);
   }
   for (let i = envFiles.length - 1; i >= 0; i--) {
@@ -48448,13 +48595,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = path39.dirname(filePath);
+    const dir = path40.dirname(filePath);
     await mkdir13(dir, { recursive: true });
     await writeFile8(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return path39.join(this.cachePath, prefix, `${key}.json`);
+    return path40.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -48958,6 +49105,11 @@ export {
   consumePiLogEntries,
   subscribeToPiLogEntries,
   ProviderRegistry,
+  getAgentvHome,
+  getWorkspacesRoot,
+  getGitCacheRoot,
+  getSubagentsRoot,
+  getTraceStateRoot,
   ensureVSCodeSubagents,
   readTargetDefinitions,
   listTargetNames,
@@ -49037,4 +49189,4 @@ export {
   OtelStreamingObserver,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-OQN2GDEU.js.map
+//# sourceMappingURL=chunk-TK4PB62M.js.map