agentv 3.13.3 → 3.14.0

package/dist/{chunk-D3LNJUUB.js → chunk-3TBDSUYD.js}

@@ -301,7 +301,7 @@ var require_dist = __commonJS({
   }
 });
 
-// ../../packages/core/dist/chunk-ZB3AUPES.js
+// ../../packages/core/dist/chunk-HP5PFOVK.js
 import { constants } from "node:fs";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
@@ -419,7 +419,7 @@ __export(external_exports2, {
   void: () => voidType
 });
 
-// ../../packages/core/dist/chunk-ZB3AUPES.js
+// ../../packages/core/dist/chunk-HP5PFOVK.js
 import { readFile as readFile2 } from "node:fs/promises";
 import path3 from "node:path";
 import fg from "fast-glob";
@@ -926,6 +926,15 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         providerBatching,
         config: resolveCopilotCliConfig(parsed, env, evalFilePath)
       };
+    case "copilot-log":
+      return {
+        kind: "copilot-log",
+        name: parsed.name,
+        graderTarget: parsed.grader_target ?? parsed.judge_target,
+        workers: parsed.workers,
+        providerBatching,
+        config: resolveCopilotLogConfig(parsed, env)
+      };
     case "pi":
     case "pi-coding-agent":
       return {
@@ -1644,8 +1653,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path45 = firstError?.path.join(".") || "";
-    const prefix = path45 ? `${target.name} ${path45}: ` : `${target.name}: `;
+    const path47 = firstError?.path.join(".") || "";
+    const prefix = path47 ? `${target.name} ${path47}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -1718,6 +1727,43 @@ function resolveString(source, env, description, allowLiteral = false) {
   }
   return value;
 }
+function resolveDiscover(value, targetName) {
+  if (value === void 0 || value === null) return void 0;
+  if (value === "latest") return "latest";
+  throw new Error(`Target "${targetName}": discover must be "latest" (got "${String(value)}")`);
+}
+function resolveCopilotLogConfig(target, env) {
+  const sessionDirSource = target.session_dir ?? target.sessionDir;
+  const sessionIdSource = target.session_id ?? target.sessionId;
+  const discoverSource = target.discover;
+  const sessionStateDirSource = target.session_state_dir ?? target.sessionStateDir;
+  const cwdSource = target.cwd;
+  return {
+    sessionDir: resolveOptionalString(
+      sessionDirSource,
+      env,
+      `${target.name} copilot-log session_dir`,
+      { allowLiteral: true, optionalEnv: true }
+    ),
+    sessionId: resolveOptionalString(
+      sessionIdSource,
+      env,
+      `${target.name} copilot-log session_id`,
+      { allowLiteral: true, optionalEnv: true }
+    ),
+    discover: resolveDiscover(discoverSource, target.name),
+    sessionStateDir: resolveOptionalString(
+      sessionStateDirSource,
+      env,
+      `${target.name} copilot-log session_state_dir`,
+      { allowLiteral: true, optionalEnv: true }
+    ),
+    cwd: resolveOptionalString(cwdSource, env, `${target.name} copilot-log cwd`, {
+      allowLiteral: true,
+      optionalEnv: true
+    })
+  };
+}
 function resolveOptionalString(source, env, description, options) {
   if (source === void 0 || source === null) {
     return void 0;
@@ -2001,6 +2047,7 @@ var KNOWN_PROVIDERS = [
   "codex",
   "copilot-sdk",
   "copilot-cli",
+  "copilot-log",
   "pi-coding-agent",
   "pi-cli",
   "claude",
@@ -6687,7 +6734,7 @@ function createOpenRouter(options = {}) {
   );
   const createChatModel = (modelId, settings = {}) => new OpenRouterChatLanguageModel(modelId, settings, {
     provider: "openrouter.chat",
-    url: ({ path: path45 }) => `${baseURL}${path45}`,
+    url: ({ path: path47 }) => `${baseURL}${path47}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6695,7 +6742,7 @@ function createOpenRouter(options = {}) {
   });
   const createCompletionModel = (modelId, settings = {}) => new OpenRouterCompletionLanguageModel(modelId, settings, {
     provider: "openrouter.completion",
-    url: ({ path: path45 }) => `${baseURL}${path45}`,
+    url: ({ path: path47 }) => `${baseURL}${path47}`,
     headers: getHeaders,
     compatibility,
     fetch: options.fetch,
@@ -6703,14 +6750,14 @@ function createOpenRouter(options = {}) {
   });
   const createEmbeddingModel = (modelId, settings = {}) => new OpenRouterEmbeddingModel(modelId, settings, {
     provider: "openrouter.embedding",
-    url: ({ path: path45 }) => `${baseURL}${path45}`,
+    url: ({ path: path47 }) => `${baseURL}${path47}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
   });
   const createImageModel = (modelId, settings = {}) => new OpenRouterImageModel(modelId, settings, {
     provider: "openrouter.image",
-    url: ({ path: path45 }) => `${baseURL}${path45}`,
+    url: ({ path: path47 }) => `${baseURL}${path47}`,
     headers: getHeaders,
     fetch: options.fetch,
     extraBody: options.extraBody
@@ -14210,52 +14257,60 @@ import { createWriteStream as createWriteStream4, existsSync, readdirSync } from
 import { arch, platform } from "node:os";
 import path14 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readFile as readFile8 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path17 from "node:path";
+import { readFile as readFile7, readdir, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path16 from "node:path";
+import { parse as parseYaml22 } from "yaml";
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { mkdir as mkdir5 } from "node:fs/promises";
-import path16 from "node:path";
+import path18 from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 import { randomUUID as randomUUID7 } from "node:crypto";
 import { createWriteStream as createWriteStream5 } from "node:fs";
 import { mkdir as mkdir6, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path17 from "node:path";
+import path19 from "node:path";
 import { execSync } from "node:child_process";
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { createWriteStream as createWriteStream6 } from "node:fs";
+import { accessSync, createWriteStream as createWriteStream6 } from "node:fs";
 import { mkdir as mkdir7 } from "node:fs/promises";
-import path18 from "node:path";
+import path20 from "node:path";
 import { createInterface } from "node:readline";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { exec as exec2 } from "node:child_process";
-import { constants as constants3, access as access3, stat as stat4 } from "node:fs/promises";
-import path30 from "node:path";
+import { constants as constants3, access as access3, stat as stat5 } from "node:fs/promises";
+import path322 from "node:path";
 import { promisify as promisify3 } from "node:util";
-import { stat as stat3, writeFile as writeFile4 } from "node:fs/promises";
-import path28 from "node:path";
+import { stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
+import path30 from "node:path";
 import { constants as constants22 } from "node:fs";
-import { access as access22, mkdir as mkdir8, readdir, rm as rm2, stat } from "node:fs/promises";
-import path19 from "node:path";
-import path20 from "node:path";
+import { access as access22, mkdir as mkdir8, readdir as readdir2, rm as rm2, stat as stat2 } from "node:fs/promises";
 import path21 from "node:path";
-import { readFile as readFile7 } from "node:fs/promises";
 import path222 from "node:path";
+import path23 from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import path24 from "node:path";
 import { exec, spawn as spawn4 } from "node:child_process";
 import { mkdir as mkdir9, writeFile as writeFile2 } from "node:fs/promises";
-import path25 from "node:path";
-import { promisify as promisify2 } from "node:util";
-import path24 from "node:path";
-import os2 from "node:os";
-import path23 from "node:path";
-import { copyFile, mkdir as mkdir10, readFile as readFile8, readdir as readdir2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import path27 from "node:path";
+import { promisify as promisify2 } from "node:util";
 import path26 from "node:path";
+import os2 from "node:os";
+import path25 from "node:path";
+import { copyFile, mkdir as mkdir10, readFile as readFile10, readdir as readdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
+import path29 from "node:path";
+import path28 from "node:path";
 import JSON5 from "json5";
 import { writeFile as writeFile5 } from "node:fs/promises";
-import path29 from "node:path";
-import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile9 } from "node:fs/promises";
 import path31 from "node:path";
+import { constants as constants4 } from "node:fs";
+import { access as access4, readFile as readFile11 } from "node:fs/promises";
+import path33 from "node:path";
 import { parse as parse4 } from "yaml";
-import path322 from "node:path";
+import path34 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";
@@ -14263,38 +14318,38 @@ import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import fs2 from "node:fs/promises";
-import path33 from "node:path";
+import path35 from "node:path";
 import { createHash as createHash2, randomUUID as randomUUID9 } from "node:crypto";
-import { copyFile as copyFile2, mkdir as mkdir14, readdir as readdir6, stat as stat7 } from "node:fs/promises";
-import path422 from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir14, readdir as readdir7, stat as stat8 } from "node:fs/promises";
+import path44 from "node:path";
 import micromatch3 from "micromatch";
-import path34 from "node:path";
-import path35 from "node:path";
-import fg22 from "fast-glob";
 import path36 from "node:path";
+import path37 from "node:path";
+import fg22 from "fast-glob";
+import path38 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 path37 from "node:path";
+import path39 from "node:path";
 import { promisify as promisify4 } from "node:util";
-import { cp, mkdir as mkdir12, readdir as readdir3, rm as rm4, stat as stat5 } from "node:fs/promises";
-import path38 from "node:path";
+import { cp, mkdir as mkdir12, readdir as readdir4, rm as rm4, stat as stat6 } from "node:fs/promises";
+import path40 from "node:path";
 import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync as existsSync2 } from "node:fs";
-import { cp as cp2, mkdir as mkdir13, readFile as readFile10, readdir as readdir4, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
-import path39 from "node:path";
+import { cp as cp2, mkdir as mkdir13, readFile as readFile12, readdir as readdir5, rm as rm5, unlink, writeFile as writeFile7 } from "node:fs/promises";
+import path41 from "node:path";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
-import path40 from "node:path";
+import path422 from "node:path";
 import { promisify as promisify6 } from "node:util";
-import { readdir as readdir5, stat as stat6 } from "node:fs/promises";
-import path41 from "node:path";
-import { existsSync as existsSync4 } from "node:fs";
+import { readdir as readdir6, stat as stat7 } from "node:fs/promises";
 import path43 from "node:path";
-import { mkdir as mkdir15, readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
-import path44 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import path45 from "node:path";
+import { mkdir as mkdir15, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
+import path46 from "node:path";
 function computeTraceSummary(messages) {
   const toolCallCounts = {};
   const toolDurations = {};
@@ -20541,6 +20596,249 @@ function summarizeAcpEvent(eventType, data) {
       return void 0;
   }
 }
+function parseCopilotEvents(eventsJsonl) {
+  const messages = [];
+  const meta = { sessionId: "", model: "", cwd: "" };
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  let hasUsage = false;
+  let startTimestamp;
+  let endTimestamp;
+  const toolCallsInProgress = /* @__PURE__ */ new Map();
+  const lines = eventsJsonl.split("\n").filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const eventType = event.type;
+    if (!eventType) continue;
+    const data = event.data ?? {};
+    switch (eventType) {
+      case "session.start": {
+        meta.sessionId = String(data.sessionId ?? "");
+        const ctx = data.context;
+        meta.cwd = String(ctx?.cwd ?? "");
+        meta.repository = ctx?.repository ? String(ctx.repository) : void 0;
+        meta.branch = ctx?.branch ? String(ctx.branch) : void 0;
+        const ts = event.timestamp ?? data.startTime;
+        meta.startedAt = ts ? String(ts) : void 0;
+        startTimestamp = ts ? String(ts) : void 0;
+        break;
+      }
+      case "user.message": {
+        messages.push({
+          role: "user",
+          content: data.content != null ? String(data.content) : ""
+        });
+        break;
+      }
+      case "assistant.message": {
+        const toolRequests = data.toolRequests;
+        const toolCalls = (toolRequests ?? []).map((req) => ({
+          tool: String(req.name ?? req.toolName ?? ""),
+          input: req.arguments,
+          id: req.toolCallId ? String(req.toolCallId) : void 0
+        }));
+        messages.push({
+          role: "assistant",
+          content: data.content != null ? String(data.content) : void 0,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+        });
+        break;
+      }
+      case "skill.invoked": {
+        const skillName = String(data.name ?? "");
+        messages.push({
+          role: "assistant",
+          toolCalls: [
+            {
+              tool: "Skill",
+              input: { skill: skillName }
+            }
+          ]
+        });
+        break;
+      }
+      case "tool.execution_start": {
+        const toolCallId = String(data.toolCallId ?? "");
+        if (toolCallId) {
+          toolCallsInProgress.set(toolCallId, {
+            toolName: String(data.toolName ?? ""),
+            input: data.arguments,
+            toolCallId
+          });
+        }
+        break;
+      }
+      case "tool.execution_complete": {
+        const toolCallId = String(data.toolCallId ?? "");
+        const started = toolCallsInProgress.get(toolCallId);
+        if (started) {
+          toolCallsInProgress.delete(toolCallId);
+          messages.push({
+            role: "assistant",
+            toolCalls: [
+              {
+                tool: started.toolName,
+                input: started.input,
+                output: data.result,
+                id: toolCallId
+              }
+            ]
+          });
+        }
+        break;
+      }
+      case "session.shutdown": {
+        endTimestamp = event.timestamp ? String(event.timestamp) : void 0;
+        const modelMetrics = data.modelMetrics;
+        if (modelMetrics) {
+          for (const metrics of Object.values(modelMetrics)) {
+            if (metrics.usage) {
+              hasUsage = true;
+              totalInputTokens += Number(metrics.usage.inputTokens ?? 0);
+              totalOutputTokens += Number(metrics.usage.outputTokens ?? 0);
+            }
+          }
+        }
+        const currentModel = data.currentModel;
+        if (currentModel && !meta.model) {
+          meta.model = String(currentModel);
+        }
+        break;
+      }
+    }
+  }
+  let durationMs;
+  if (startTimestamp && endTimestamp) {
+    durationMs = new Date(endTimestamp).getTime() - new Date(startTimestamp).getTime();
+  }
+  return {
+    messages,
+    meta,
+    tokenUsage: hasUsage ? { input: totalInputTokens, output: totalOutputTokens } : void 0,
+    durationMs
+  };
+}
+var DEFAULT_SESSION_STATE_DIR = () => path16.join(homedir(), ".copilot", "session-state");
+async function discoverCopilotSessions(opts) {
+  const sessionStateDir = opts?.sessionStateDir ?? DEFAULT_SESSION_STATE_DIR();
+  const limit = opts?.limit ?? 10;
+  let entries;
+  try {
+    entries = await readdir(sessionStateDir);
+  } catch {
+    return [];
+  }
+  const sessions = [];
+  for (const entry of entries) {
+    const sessionDir = path16.join(sessionStateDir, entry);
+    const workspacePath = path16.join(sessionDir, "workspace.yaml");
+    const eventsPath = path16.join(sessionDir, "events.jsonl");
+    try {
+      const workspaceContent = await readFile7(workspacePath, "utf8");
+      const workspace = parseYaml22(workspaceContent) ?? {};
+      const cwd = String(workspace.cwd ?? "");
+      let updatedAt;
+      try {
+        const eventsStat = await stat(eventsPath);
+        updatedAt = eventsStat.mtime;
+      } catch {
+        updatedAt = /* @__PURE__ */ new Date(0);
+      }
+      let isActive = true;
+      try {
+        const fd = await import("node:fs/promises").then((fs3) => fs3.open(eventsPath, "r"));
+        try {
+          const fstat = await fd.stat();
+          const tailSize = Math.min(fstat.size, 4096);
+          const buf = Buffer.alloc(tailSize);
+          await fd.read(buf, 0, tailSize, Math.max(0, fstat.size - tailSize));
+          isActive = !buf.toString("utf8").includes('"session.shutdown"');
+        } finally {
+          await fd.close();
+        }
+      } catch {
+      }
+      sessions.push({
+        sessionId: entry,
+        sessionDir,
+        cwd,
+        repository: workspace.repository ? String(workspace.repository) : void 0,
+        updatedAt,
+        isActive
+      });
+    } catch {
+    }
+  }
+  let filtered = sessions;
+  if (opts?.cwd) {
+    filtered = filtered.filter((s) => s.cwd === opts.cwd);
+  }
+  if (opts?.repository) {
+    filtered = filtered.filter((s) => s.repository === opts.repository);
+  }
+  filtered.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  return filtered.slice(0, limit);
+}
+var CopilotLogProvider = class {
+  id;
+  kind = "copilot-log";
+  targetName;
+  config;
+  constructor(targetName, config) {
+    this.targetName = targetName;
+    this.id = `copilot-log:${targetName}`;
+    this.config = config;
+  }
+  async invoke(_request) {
+    const sessionDir = await this.resolveSessionDir();
+    const eventsPath = path17.join(sessionDir, "events.jsonl");
+    let eventsContent;
+    try {
+      eventsContent = await readFile8(eventsPath, "utf8");
+    } catch (err) {
+      throw new Error(
+        `Failed to read Copilot session transcript at ${eventsPath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    const parsed = parseCopilotEvents(eventsContent);
+    return {
+      output: parsed.messages,
+      tokenUsage: parsed.tokenUsage,
+      durationMs: parsed.durationMs,
+      startTime: parsed.meta.startedAt
+    };
+  }
+  async resolveSessionDir() {
+    if (this.config.sessionDir) {
+      return this.config.sessionDir;
+    }
+    if (this.config.sessionId) {
+      const stateDir = this.config.sessionStateDir ?? path17.join(homedir2(), ".copilot", "session-state");
+      return path17.join(stateDir, this.config.sessionId);
+    }
+    if (this.config.discover === "latest") {
+      const sessions = await discoverCopilotSessions({
+        sessionStateDir: this.config.sessionStateDir,
+        cwd: this.config.cwd,
+        limit: 1
+      });
+      if (sessions.length === 0) {
+        throw new Error(
+          `No Copilot CLI sessions found${this.config.cwd ? ` for cwd=${this.config.cwd}` : ""}. Check that sessions exist in ${this.config.sessionStateDir ?? "~/.copilot/session-state/"}`
+        );
+      }
+      return sessions[0].sessionDir;
+    }
+    throw new Error(
+      'CopilotLogProvider requires one of: sessionDir, sessionId, or discover="latest"'
+    );
+  }
+};
 var GLOBAL_LOGS_KEY4 = Symbol.for("agentv.copilotSdkLogs");
 var GLOBAL_SUBSCRIBERS_KEY4 = Symbol.for("agentv.copilotSdkLogSubscribers");
 function getCopilotSdkLogStore() {
@@ -20826,10 +21124,10 @@ var CopilotSdkProvider = class {
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path16.resolve(cwdOverride);
+      return path18.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path16.resolve(this.config.cwd);
+      return path18.resolve(this.config.cwd);
     }
     return void 0;
   }
@@ -20838,9 +21136,9 @@ var CopilotSdkProvider = class {
       return void 0;
     }
     if (this.config.logDir) {
-      return path16.resolve(this.config.logDir);
+      return path18.resolve(this.config.logDir);
     }
-    return path16.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
+    return path18.join(process.cwd(), ".agentv", "logs", "copilot-sdk");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -20854,7 +21152,7 @@ var CopilotSdkProvider = class {
       console.warn(`Skipping Copilot SDK stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path16.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
+    const filePath = path18.join(logDir, buildLogFilename4(request, this.targetName, "copilot-sdk"));
     try {
       const logger = await CopilotStreamLogger.create(
         {
@@ -21038,13 +21336,14 @@ var PiCliProvider = class {
     const inputFiles = normalizeInputFiles(request.inputFiles);
     const startTime = (/* @__PURE__ */ new Date()).toISOString();
     const startMs = Date.now();
-    const workspaceRoot = await this.createWorkspace();
+    const hasExternalCwd = !!(request.cwd || this.config.cwd);
+    const workspaceRoot = hasExternalCwd ? void 0 : await this.createWorkspace();
+    const cwd = this.resolveCwd(workspaceRoot, request.cwd);
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path17.join(workspaceRoot, PROMPT_FILENAME);
+      const promptFile = path19.join(cwd, PROMPT_FILENAME);
       await writeFile(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
-      const cwd = this.resolveCwd(workspaceRoot, request.cwd);
       const result = await this.executePi(args, cwd, request.signal, logger);
       if (result.timedOut) {
         throw new Error(
@@ -21086,7 +21385,7 @@ var PiCliProvider = class {
           args,
           executable: this.config.executable,
           promptFile,
-          workspace: workspaceRoot,
+          workspace: workspaceRoot ?? cwd,
           inputFiles,
           logFile: logger?.filePath
         },
@@ -21098,17 +21397,22 @@ var PiCliProvider = class {
       };
     } finally {
       await logger?.close();
-      await this.cleanupWorkspace(workspaceRoot);
+      if (workspaceRoot) {
+        await this.cleanupWorkspace(workspaceRoot);
+      }
     }
   }
   resolveCwd(workspaceRoot, cwdOverride) {
     if (cwdOverride) {
-      return path17.resolve(cwdOverride);
+      return path19.resolve(cwdOverride);
+    }
+    if (this.config.cwd) {
+      return path19.resolve(this.config.cwd);
     }
-    if (!this.config.cwd) {
+    if (workspaceRoot) {
       return workspaceRoot;
     }
-    return path17.resolve(this.config.cwd);
+    return process.cwd();
   }
   buildPiArgs(prompt, inputFiles) {
     const args = [];
@@ -21189,7 +21493,7 @@ ${prompt}` : prompt;
     return env;
   }
   async createWorkspace() {
-    return await mkdtemp(path17.join(tmpdir(), WORKSPACE_PREFIX));
+    return await mkdtemp(path19.join(tmpdir(), WORKSPACE_PREFIX));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
@@ -21199,9 +21503,9 @@ ${prompt}` : prompt;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path17.resolve(this.config.logDir);
+      return path19.resolve(this.config.logDir);
     }
-    return path17.join(process.cwd(), ".agentv", "logs", "pi-cli");
+    return path19.join(process.cwd(), ".agentv", "logs", "pi-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -21215,7 +21519,7 @@ ${prompt}` : prompt;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path17.join(logDir, buildLogFilename5(request, this.targetName));
+    const filePath = path19.join(logDir, buildLogFilename5(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -21652,9 +21956,10 @@ async function defaultPiRunner(options) {
 }
 var piCodingAgentModule = null;
 var piAiModule = null;
+var loadingPromise = null;
 async function promptInstall() {
   if (!process.stdout.isTTY) return false;
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
   try {
     return await new Promise((resolve2) => {
       rl.question(
@@ -21666,43 +21971,74 @@ async function promptInstall() {
     rl.close();
   }
 }
-async function loadSdkModules() {
-  if (!piCodingAgentModule || !piAiModule) {
+function findAgentvRoot() {
+  const thisFile = fileURLToPath3(import.meta.url);
+  let dir = path20.dirname(thisFile);
+  for (let i = 0; i < 10; i++) {
     try {
+      const pkg = path20.join(dir, "package.json");
+      accessSync(pkg);
+      return dir;
+    } catch {
+      const parent = path20.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return path20.dirname(thisFile);
+}
+async function doLoadSdkModules() {
+  try {
+    [piCodingAgentModule, piAiModule] = await Promise.all([
+      import("@mariozechner/pi-coding-agent"),
+      import("@mariozechner/pi-ai")
+    ]);
+  } catch {
+    if (await promptInstall()) {
+      const installDir = findAgentvRoot();
+      console.error(`Installing @mariozechner/pi-coding-agent into ${installDir}...`);
+      execSync("bun add @mariozechner/pi-coding-agent", {
+        cwd: installDir,
+        stdio: "inherit"
+      });
       [piCodingAgentModule, piAiModule] = await Promise.all([
         import("@mariozechner/pi-coding-agent"),
         import("@mariozechner/pi-ai")
       ]);
-    } catch {
-      if (await promptInstall()) {
-        console.error("Installing @mariozechner/pi-coding-agent...");
-        execSync("bun add @mariozechner/pi-coding-agent", { stdio: "inherit" });
-        [piCodingAgentModule, piAiModule] = await Promise.all([
-          import("@mariozechner/pi-coding-agent"),
-          import("@mariozechner/pi-ai")
-        ]);
-      } else {
-        throw new Error(
-          "pi-coding-agent SDK is not installed. Install it with:\n  bun add @mariozechner/pi-coding-agent"
-        );
-      }
+    } else {
+      throw new Error(
+        "pi-coding-agent SDK is not installed. Install it with:\n  bun add @mariozechner/pi-coding-agent"
+      );
     }
   }
+}
+async function loadSdkModules() {
+  if (!piCodingAgentModule || !piAiModule) {
+    if (!loadingPromise) {
+      loadingPromise = doLoadSdkModules().catch((err) => {
+        loadingPromise = null;
+        throw err;
+      });
+    }
+    await loadingPromise;
+  }
+  const piSdk = piCodingAgentModule;
+  const piAi = piAiModule;
   const toolMap = {
-    read: piCodingAgentModule.readTool,
-    bash: piCodingAgentModule.bashTool,
-    edit: piCodingAgentModule.editTool,
-    write: piCodingAgentModule.writeTool,
-    grep: piCodingAgentModule.grepTool,
-    find: piCodingAgentModule.findTool,
-    ls: piCodingAgentModule.lsTool
+    read: piSdk.readTool,
+    bash: piSdk.bashTool,
+    edit: piSdk.editTool,
+    write: piSdk.writeTool,
+    grep: piSdk.grepTool,
+    find: piSdk.findTool,
+    ls: piSdk.lsTool
   };
   return {
-    createAgentSession: piCodingAgentModule.createAgentSession,
-    codingTools: piCodingAgentModule.codingTools,
+    createAgentSession: piSdk.createAgentSession,
+    codingTools: piSdk.codingTools,
     toolMap,
-    SessionManager: piCodingAgentModule.SessionManager,
-    getModel: piAiModule.getModel
+    SessionManager: piSdk.SessionManager,
+    getModel: piAi.getModel
   };
 }
 var PiCodingAgentProvider = class {
@@ -21891,10 +22227,10 @@ ${fileList}`;
   }
   resolveCwd(cwdOverride) {
     if (cwdOverride) {
-      return path18.resolve(cwdOverride);
+      return path20.resolve(cwdOverride);
     }
     if (this.config.cwd) {
-      return path18.resolve(this.config.cwd);
+      return path20.resolve(this.config.cwd);
     }
     return process.cwd();
   }
@@ -21913,9 +22249,9 @@ ${fileList}`;
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path18.resolve(this.config.logDir);
+      return path20.resolve(this.config.logDir);
     }
-    return path18.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path20.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -21929,7 +22265,7 @@ ${fileList}`;
       console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
       return void 0;
     }
-    const filePath = path18.join(logDir, buildLogFilename6(request, this.targetName));
+    const filePath = path20.join(logDir, buildLogFilename6(request, this.targetName));
     try {
       const logger = await PiStreamLogger2.create({
         filePath,
@@ -22149,10 +22485,10 @@ async function ensureDir(target) {
   await mkdir8(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await readdir(target, { withFileTypes: true });
+  const entries = await readdir2(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path19.join(target, entry.name),
+    absolutePath: path21.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
@@ -22166,7 +22502,7 @@ async function removeIfExists(target) {
   }
 }
 function pathToFileUri2(filePath) {
-  const absolutePath = path20.isAbsolute(filePath) ? filePath : path20.resolve(filePath);
+  const absolutePath = path222.isAbsolute(filePath) ? filePath : path222.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -22258,8 +22594,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path21.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${path21.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path23.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path23.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -22298,7 +22634,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await readFile7(responseFileFinal, { encoding: "utf8" });
+      const content = await readFile9(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -22319,7 +22655,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false, timeoutMs = DEFAULT_TIMEOUT_MS) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file) => path222.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => path24.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -22328,7 +22664,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => path222.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => path24.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -22355,7 +22691,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await readFile7(file, { encoding: "utf8" });
+        const content = await readFile9(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -22385,25 +22721,25 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return path23.join(os2.homedir(), ".agentv");
+  return path25.join(os2.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return path23.join(getAgentvHome(), "workspaces");
+  return path25.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return path23.join(getAgentvHome(), "subagents");
+  return path25.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return path23.join(getAgentvHome(), "trace-state");
+  return path25.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return path23.join(getAgentvHome(), "workspace-pool");
+  return path25.join(getAgentvHome(), "workspace-pool");
 }
 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 path24.join(getSubagentsRoot(), folder);
+  return path26.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 var execAsync2 = promisify2(exec);
@@ -22468,11 +22804,11 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = path25.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path27.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path25.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
   await mkdir9(githubAgentsDir, { recursive: true });
-  const wakeupDst = path25.join(githubAgentsDir, "wakeup.md");
+  const wakeupDst = path27.join(githubAgentsDir, "wakeup.md");
   await writeFile2(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
@@ -22485,7 +22821,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path25.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path27.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -22500,10 +22836,10 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = path25.join(subagentDir, `${path25.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path25.join(subagentDir, "messages");
+  const workspacePath = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path27.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
-  const reqFile = path25.join(messagesDir, `${timestamp}_req.md`);
+  const reqFile = path27.join(messagesDir, `${timestamp}_req.md`);
   await writeFile2(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
@@ -22511,16 +22847,16 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${path25.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${path27.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path25.basename(subagentDir),
+    path27.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path25.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path27.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -22528,8 +22864,8 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = path25.join(subagentDir, `${path25.basename(subagentDir)}.code-workspace`);
-  const messagesDir = path25.join(subagentDir, "messages");
+  const workspacePath = path27.join(subagentDir, `${path27.basename(subagentDir)}.code-workspace`);
+  const messagesDir = path27.join(subagentDir, "messages");
   await mkdir9(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
@@ -22538,13 +22874,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    path25.basename(subagentDir),
+    path27.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${path25.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${path27.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -22566,10 +22902,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path26.isAbsolute(folderPath)) {
+    if (path28.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path26.resolve(templateDir, folderPath);
+    const absolutePath = path28.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -22591,19 +22927,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path26.isAbsolute(locationPath);
+          const isAbsolute = path28.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path26.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path28.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 = (path26.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path28.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -22642,7 +22978,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 = path27.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path29.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -22652,26 +22988,26 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path27.resolve(workspaceTemplate);
+    const workspaceSrc = path29.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await stat2(workspaceSrc);
+    const stats = await stat3(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await readFile8(workspaceSrc, "utf8");
+    const templateText = await readFile10(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path27.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path27.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path27.dirname(path27.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path29.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path29.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path29.dirname(path29.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = path27.resolve(cwd);
+    const absCwd = path29.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -22680,35 +23016,35 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
     }
   }
   await writeFile3(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path27.join(subagentDir, "messages");
+  const messagesDir = path29.join(subagentDir, "messages");
   await mkdir10(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path27.join(subagentDir, "messages");
+  const messagesDir = path29.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await readdir2(messagesDir);
+    const files = await readdir3(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = path27.join(messagesDir, file);
+        const target = path29.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await readdir2(githubAgentsDir);
+    const agentFiles = await readdir3(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path27.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path29.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = path27.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path29.join(subagentDir, DEFAULT_LOCK_NAME);
   await writeFile3(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path27.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path29.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -22728,9 +23064,9 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path27.join(subagentDir, ".github", "agents");
+    const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
     await mkdir10(githubAgentsDir, { recursive: true });
-    const agentFile = path27.join(githubAgentsDir, `${chatId}.md`);
+    const agentFile = path29.join(githubAgentsDir, `${chatId}.md`);
     try {
       await copyFile(promptFile, agentFile);
     } catch (error) {
@@ -22747,11 +23083,11 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path28.resolve(promptFile);
+  const resolvedPrompt = path30.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await stat3(resolvedPrompt);
+  const promptStats = await stat4(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -22763,7 +23099,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path28.resolve(attachment);
+    const resolvedPath = path30.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -22805,7 +23141,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path28.basename(subagentDir);
+    const subagentName = path30.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -22833,9 +23169,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path28.join(subagentDir, "messages");
-    const responseFileTmp = path28.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path28.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path30.join(subagentDir, "messages");
+    const responseFileTmp = path30.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path30.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -22940,7 +23276,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path28.basename(subagentDir);
+    subagentName = path30.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -22971,17 +23307,17 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path28.join(subagentDir, "messages");
+    const messagesDir = path30.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path28.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path30.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path28.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path30.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path28.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path30.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path28.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path30.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
@@ -23094,7 +23430,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path29.resolve(targetRoot);
+  const targetPath = path31.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -23114,7 +23450,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path29.join(entry.absolutePath, lockName);
+      const lockFile = path31.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -23131,10 +23467,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
-    const lockFile = path29.join(subagentDir, lockName);
-    const workspaceDst = path29.join(subagentDir, `${path29.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path29.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path31.join(subagentDir, ".github", "agents");
+    const lockFile = path31.join(subagentDir, lockName);
+    const workspaceDst = path31.join(subagentDir, `${path31.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path31.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -23172,10 +23508,10 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path29.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path29.join(subagentDir, ".github", "agents");
-    const workspaceDst = path29.join(subagentDir, `${path29.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path29.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path31.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path31.join(subagentDir, ".github", "agents");
+    const workspaceDst = path31.join(subagentDir, `${path31.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path31.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
@@ -23361,7 +23697,7 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = path30.isAbsolute(candidate) ? candidate : path30.resolve(candidate);
+    const resolved = path322.isAbsolute(candidate) ? candidate : path322.resolve(candidate);
     try {
       await access3(resolved, constants3.F_OK);
       return resolved;
@@ -23390,7 +23726,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await stat4(path30.resolve(template));
+    const stats = await stat5(path322.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -23414,7 +23750,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path30.basename(absolutePath);
+    const fileName = path322.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -23435,7 +23771,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path30.resolve(attachment);
+    const absolutePath = path322.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -23443,7 +23779,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path30.isAbsolute(filePath) ? filePath : path30.resolve(filePath);
+  const absolutePath = path322.isAbsolute(filePath) ? filePath : path322.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -23456,7 +23792,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path30.resolve(attachment));
+    deduped.add(path322.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -23465,7 +23801,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path30.resolve(inputFile));
+      deduped.add(path322.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -23545,11 +23881,11 @@ async function fileExists3(filePath) {
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path31.resolve(filePath);
+  const absolutePath = path33.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await readFile9(absolutePath, "utf8");
+  const raw = await readFile11(absolutePath, "utf8");
   const parsed = parse4(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -23566,11 +23902,11 @@ function listTargetNames(definitions) {
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path322.resolve(baseDir);
-  const root = path322.parse(dir).root;
+  let dir = path34.resolve(baseDir);
+  const root = path34.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path322.join(dir, ".agentv", "providers"));
-    dir = path322.dirname(dir);
+    candidateDirs.push(path34.join(dir, ".agentv", "providers"));
+    dir = path34.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -23586,7 +23922,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = path322.basename(filePath);
+    const basename = path34.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -23602,7 +23938,7 @@ async function discoverProviders(registry, baseDir) {
 }
 function createBuiltinProviderRegistry() {
   const registry = new ProviderRegistry();
-  registry.register("openai", (t) => new OpenAIProvider(t.name, t.config)).register("openrouter", (t) => new OpenRouterProvider(t.name, t.config)).register("azure", (t) => new AzureProvider(t.name, t.config)).register("anthropic", (t) => new AnthropicProvider(t.name, t.config)).register("gemini", (t) => new GeminiProvider(t.name, t.config)).register("cli", (t) => new CliProvider(t.name, t.config)).register("codex", (t) => new CodexProvider(t.name, t.config)).register("copilot-sdk", (t) => new CopilotSdkProvider(t.name, t.config)).register("copilot-cli", (t) => new CopilotCliProvider(t.name, t.config)).register("pi-coding-agent", (t) => new PiCodingAgentProvider(t.name, t.config)).register("pi-cli", (t) => new PiCliProvider(t.name, t.config)).register("claude-cli", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude-sdk", (t) => new ClaudeSdkProvider(t.name, t.config)).register("mock", (t) => new MockProvider(t.name, t.config)).register("agentv", (t) => new AgentvProvider(t.name, t.config)).register("vscode", (t) => new VSCodeProvider(t.name, t.config, "vscode")).register(
+  registry.register("openai", (t) => new OpenAIProvider(t.name, t.config)).register("openrouter", (t) => new OpenRouterProvider(t.name, t.config)).register("azure", (t) => new AzureProvider(t.name, t.config)).register("anthropic", (t) => new AnthropicProvider(t.name, t.config)).register("gemini", (t) => new GeminiProvider(t.name, t.config)).register("cli", (t) => new CliProvider(t.name, t.config)).register("codex", (t) => new CodexProvider(t.name, t.config)).register("copilot-sdk", (t) => new CopilotSdkProvider(t.name, t.config)).register("copilot-cli", (t) => new CopilotCliProvider(t.name, t.config)).register("copilot-log", (t) => new CopilotLogProvider(t.name, t.config)).register("pi-coding-agent", (t) => new PiCodingAgentProvider(t.name, t.config)).register("pi-cli", (t) => new PiCliProvider(t.name, t.config)).register("claude-cli", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude", (t) => new ClaudeCliProvider(t.name, t.config)).register("claude-sdk", (t) => new ClaudeSdkProvider(t.name, t.config)).register("mock", (t) => new MockProvider(t.name, t.config)).register("agentv", (t) => new AgentvProvider(t.name, t.config)).register("vscode", (t) => new VSCodeProvider(t.name, t.config, "vscode")).register(
     "vscode-insiders",
     (t) => new VSCodeProvider(t.name, t.config, "vscode-insiders")
   );
@@ -23800,15 +24136,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir16, readFile: readFile12, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
+  const { mkdir: mkdir16, readFile: readFile14, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
   const { tmpdir: tmpdir3 } = await import("node:os");
-  const path45 = await import("node:path");
+  const path47 = await import("node:path");
   const { randomUUID: randomUUID10 } = await import("node:crypto");
-  const dir = path45.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  const dir = path47.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
   await mkdir16(dir, { recursive: true });
-  const stdinPath = path45.join(dir, "stdin.txt");
-  const stdoutPath = path45.join(dir, "stdout.txt");
-  const stderrPath = path45.join(dir, "stderr.txt");
+  const stdinPath = path47.join(dir, "stdin.txt");
+  const stdoutPath = path47.join(dir, "stdout.txt");
+  const stderrPath = path47.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: spawn5 } = await import("node:child_process");
@@ -23838,8 +24174,8 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
         resolve2(code ?? 0);
       });
     });
-    const stdout = (await readFile12(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
-    const stderr = (await readFile12(stderrPath, "utf8")).replace(/\r\n/g, "\n");
+    const stdout = (await readFile14(stdoutPath, "utf8")).replace(/\r\n/g, "\n");
+    const stderr = (await readFile14(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
     await rm6(dir, { recursive: true, force: true });
@@ -25125,8 +25461,8 @@ function calculateScoreRangeResult(result, rubrics) {
   };
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = path33.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + path33.sep) && resolved !== basePath) {
+  const resolved = path35.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + path35.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -25159,11 +25495,11 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat8 = await fs2.stat(resolved);
-          if (stat8.isDirectory()) {
+          const stat9 = await fs2.stat(resolved);
+          if (stat9.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
-          const buffer = Buffer.alloc(Math.min(stat8.size, MAX_FILE_SIZE));
+          const buffer = Buffer.alloc(Math.min(stat9.size, MAX_FILE_SIZE));
           const fd = await fs2.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
@@ -25171,8 +25507,8 @@ function createFilesystemTools(workspacePath) {
             await fd.close();
           }
           const content = buffer.toString("utf-8");
-          const truncated = stat8.size > MAX_FILE_SIZE;
-          return { content, truncated, size: stat8.size };
+          const truncated = stat9.size > MAX_FILE_SIZE;
+          return { content, truncated, size: stat9.size };
         } catch (error) {
           return { error: error instanceof Error ? error.message : String(error) };
         }
@@ -25216,15 +25552,15 @@ 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 = path33.join(dirPath, entry.name);
+    const fullPath = path35.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = path33.extname(entry.name).toLowerCase();
+      const ext = path35.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat8 = await fs2.stat(fullPath);
-        if (stat8.size > MAX_FILE_SIZE) continue;
+        const stat9 = await fs2.stat(fullPath);
+        if (stat9.size > MAX_FILE_SIZE) continue;
         const content = await fs2.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
@@ -25232,7 +25568,7 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: path33.relative(workspacePath, fullPath),
+              file: path35.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -25857,115 +26193,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path45, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path45);
-    const expectedValue = resolvePath(expectedData, path45);
+    const { path: path47, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path47);
+    const expectedValue = resolvePath(expectedData, path47);
     if (expectedValue === void 0) {
       return {
-        path: path45,
+        path: path47,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path45}: no expected value`
+        message: `${path47}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path45,
+          path: path47,
           score: 0,
           weight,
           hit: false,
-          message: `${path45} (required, missing)`
+          message: `${path47} (required, missing)`
         };
       }
       return {
-        path: path45,
+        path: path47,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path45}: optional field missing`
+        message: `${path47}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path45, candidateValue, expectedValue, weight);
+        return this.compareExact(path47, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path45,
+          path47,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path45, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path47, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path45,
+          path: path47,
           score: 0,
           weight,
           hit: false,
-          message: `${path45}: unknown match type "${match}"`
+          message: `${path47}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path45, candidateValue, expectedValue, weight) {
+  compareExact(path47, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path45,
+        path: path47,
         score: 1,
         weight,
         hit: true,
-        message: path45
+        message: path47
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path45,
+        path: path47,
         score: 0,
         weight,
         hit: false,
-        message: `${path45} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path47} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path45,
+      path: path47,
       score: 0,
       weight,
       hit: false,
-      message: `${path45} (value mismatch)`
+      message: `${path47} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path45, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path47, candidateValue, expectedValue, fieldConfig, weight) {
     const { tolerance = 0, relative = false } = fieldConfig;
     const candidateNum = toNumber(candidateValue);
     const expectedNum = toNumber(expectedValue);
     if (candidateNum === null || expectedNum === null) {
       return {
-        path: path45,
+        path: path47,
         score: 0,
         weight,
         hit: false,
-        message: `${path45} (non-numeric value)`
+        message: `${path47} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path45,
+        path: path47,
         score: 0,
         weight,
         hit: false,
-        message: `${path45} (invalid numeric value)`
+        message: `${path47} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -25978,61 +26314,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path45,
+        path: path47,
         score: 1,
         weight,
         hit: true,
-        message: `${path45} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path47} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path45,
+      path: path47,
       score: 0,
       weight,
       hit: false,
-      message: `${path45} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path47} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path45, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path47, 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: path45,
+        path: path47,
         score: 0,
         weight,
         hit: false,
-        message: `${path45} (unparseable candidate date)`
+        message: `${path47} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path45,
+        path: path47,
         score: 0,
         weight,
         hit: false,
-        message: `${path45} (unparseable expected date)`
+        message: `${path47} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path45,
+        path: path47,
         score: 1,
         weight,
         hit: true,
-        message: path45
+        message: path47
       };
     }
     return {
-      path: path45,
+      path: path47,
       score: 0,
       weight,
       hit: false,
-      message: `${path45} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path47} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -26065,11 +26401,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path45) {
-  if (!path45 || !obj) {
+function resolvePath(obj, path47) {
+  if (!path47 || !obj) {
     return void 0;
   }
-  const parts = path45.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path47.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -26233,6 +26569,7 @@ var PROVIDER_TOOL_SEMANTICS = {
   "pi-coding-agent": PI_CODING_AGENT_MATCHER,
   "pi-cli": PI_CODING_AGENT_MATCHER,
   "copilot-cli": COPILOT_MATCHER,
+  "copilot-log": COPILOT_MATCHER,
   "copilot-sdk": COPILOT_MATCHER,
   vscode: COPILOT_MATCHER,
   "vscode-insiders": COPILOT_MATCHER
@@ -26259,8 +26596,9 @@ var SkillTriggerEvaluator = class {
     let triggered = false;
     let evidence = "";
     for (const toolCall of allToolCalls) {
+      const toolName = toolCall.tool ?? "";
       const input = toolCall.input ?? {};
-      if (matcher.skillTools.includes(toolCall.tool)) {
+      if (matcher.skillTools.includes(toolName)) {
         const skillArg = String(input[matcher.skillInputField] ?? "");
         if (skillArg.includes(skillName)) {
           triggered = true;
@@ -26268,12 +26606,12 @@ var SkillTriggerEvaluator = class {
           break;
         }
       } else if (matcher.skillToolPrefixes?.some(
-        (prefix) => toolCall.tool.startsWith(prefix) && toolCall.tool.includes(skillName)
+        (prefix) => toolName.startsWith(prefix) && toolName.includes(skillName)
       )) {
         triggered = true;
-        evidence = `Skill tool invoked via tool name "${toolCall.tool}"`;
+        evidence = `Skill tool invoked via tool name "${toolName}"`;
         break;
-      } else if (matcher.readTools.includes(toolCall.tool)) {
+      } else if (matcher.readTools.includes(toolName)) {
         const filePath = this.readPathFromInput(input, matcher);
         if (filePath.includes(skillName)) {
           triggered = true;
@@ -26281,10 +26619,10 @@ var SkillTriggerEvaluator = class {
           break;
         }
       } else if (matcher.readToolPrefixes?.some(
-        (prefix) => toolCall.tool.startsWith(prefix) && toolCall.tool.includes(skillName)
+        (prefix) => toolName.startsWith(prefix) && toolName.includes(skillName)
       )) {
         triggered = true;
-        evidence = `Read tool loaded skill file via tool name "${toolCall.tool}"`;
+        evidence = `Read tool loaded skill file via tool name "${toolName}"`;
         break;
       }
     }
@@ -26540,8 +26878,8 @@ var TokenUsageEvaluator = class {
     };
   }
 };
-function getNestedValue(obj, path45) {
-  const parts = path45.split(".");
+function getNestedValue(obj, path47) {
+  const parts = path47.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -27404,7 +27742,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path34.dirname(scriptPath);
+  const cwd = path36.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -27675,11 +28013,11 @@ function createBuiltinRegistry() {
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path35.resolve(baseDir);
-  const root = path35.parse(dir).root;
+  let dir = path37.resolve(baseDir);
+  const root = path37.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path35.join(dir, ".agentv", "assertions"));
-    dir = path35.dirname(dir);
+    candidateDirs.push(path37.join(dir, ".agentv", "assertions"));
+    dir = path37.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -27695,7 +28033,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path35.basename(filePath);
+    const basename = path37.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -27714,12 +28052,12 @@ async function discoverAssertions(registry, baseDir) {
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = path36.resolve(baseDir);
-  const root = path36.parse(dir).root;
+  let dir = path38.resolve(baseDir);
+  const root = path38.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(path36.join(dir, ".agentv", "graders"));
-    candidateDirs.push(path36.join(dir, ".agentv", "judges"));
-    dir = path36.dirname(dir);
+    candidateDirs.push(path38.join(dir, ".agentv", "graders"));
+    candidateDirs.push(path38.join(dir, ".agentv", "judges"));
+    dir = path38.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -27735,7 +28073,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = path36.basename(filePath);
+    const basename = path38.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -27921,10 +28259,10 @@ async function stageNestedRepoChanges(workspacePath) {
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = path37.join(workspacePath, entry);
+    const childPath = path39.join(workspacePath, entry);
     try {
       if (!statSync(childPath).isDirectory()) continue;
-      if (!statSync(path37.join(childPath, ".git")).isDirectory()) continue;
+      if (!statSync(path39.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -27953,7 +28291,7 @@ var WorkspaceCreationError = class extends Error {
 };
 async function isDirectory(filePath) {
   try {
-    const stats = await stat5(filePath);
+    const stats = await stat6(filePath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -27961,14 +28299,14 @@ async function isDirectory(filePath) {
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  return path38.join(root, evalRunId, caseId);
+  return path40.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
   await mkdir12(dest, { recursive: true });
-  const entries = await readdir3(src, { withFileTypes: true });
+  const entries = await readdir4(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path38.join(src, entry.name);
-    const destPath = path38.join(dest, entry.name);
+    const srcPath = path40.join(src, entry.name);
+    const destPath = path40.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -27980,7 +28318,7 @@ async function copyDirectoryRecursive(src, dest) {
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = path38.resolve(templatePath);
+  const resolvedTemplatePath = path40.resolve(templatePath);
   if (!await fileExists(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -28029,7 +28367,7 @@ async function cleanupWorkspace(workspacePath) {
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  const evalDir = path38.join(root, evalRunId);
+  const evalDir = path40.join(root, evalRunId);
   if (await fileExists(evalDir)) {
     await rm4(evalDir, { recursive: true, force: true });
   }
@@ -28084,10 +28422,10 @@ function computeWorkspaceFingerprint(repos) {
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
   await mkdir13(dest, { recursive: true });
-  const entries = await readdir4(src, { withFileTypes: true });
+  const entries = await readdir5(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path39.join(src, entry.name);
-    const destPath = path39.join(dest, entry.name);
+    const srcPath = path41.join(src, entry.name);
+    const destPath = path41.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -28120,7 +28458,7 @@ var WorkspacePoolManager = class {
   async acquireWorkspace(options) {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
-    const poolDir = path39.join(this.poolRoot, fingerprint);
+    const poolDir = path41.join(this.poolRoot, fingerprint);
     await mkdir13(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
@@ -28130,7 +28468,7 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = path39.join(poolDir, `slot-${i}`);
+      const slotPath = path41.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
@@ -28192,7 +28530,7 @@ var WorkspacePoolManager = class {
           throw err;
         }
         try {
-          const pidStr = await readFile10(lockPath, "utf-8");
+          const pidStr = await readFile12(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
@@ -28217,9 +28555,9 @@ var WorkspacePoolManager = class {
    * Returns false (no drift) if metadata.json doesn't exist (first use).
    */
   async checkDrift(poolDir, fingerprint) {
-    const metadataPath = path39.join(poolDir, "metadata.json");
+    const metadataPath = path41.join(poolDir, "metadata.json");
     try {
-      const raw = await readFile10(metadataPath, "utf-8");
+      const raw = await readFile12(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -28234,17 +28572,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await writeFile7(path39.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await writeFile7(path41.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
   }
   /** Remove all slot directories and their lock files from a pool directory. */
   async removeAllSlots(poolDir) {
-    const entries = await readdir4(poolDir);
+    const entries = await readdir5(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
-        const lockPath = path39.join(poolDir, `${entry}.lock`);
+        const lockPath = path41.join(poolDir, `${entry}.lock`);
         if (existsSync2(lockPath)) {
           try {
-            const pidStr = await readFile10(lockPath, "utf-8");
+            const pidStr = await readFile12(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -28257,12 +28595,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await rm5(path39.join(poolDir, entry), { recursive: true, force: true });
+        await rm5(path41.join(poolDir, entry), { recursive: true, force: true });
         await rm5(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await rm5(path39.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await rm5(path41.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -28272,7 +28610,7 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
-      const repoDir = path39.join(slotPath, repo.path);
+      const repoDir = path41.join(slotPath, repo.path);
       if (!existsSync2(repoDir)) {
         continue;
       }
@@ -28393,7 +28731,7 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = path40.join(workspacePath, repo.path);
+    const targetDir = path422.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -28484,7 +28822,7 @@ ${lines.join("\n")}`;
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
-      const targetDir = path40.join(workspacePath, repo.path);
+      const targetDir = path422.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -28494,30 +28832,30 @@ async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = path41.resolve(templatePath);
-  const stats = await stat6(resolved);
+  const resolved = path43.resolve(templatePath);
+  const stats = await stat7(resolved);
   if (stats.isFile()) {
     return {
-      dir: path41.dirname(resolved),
+      dir: path43.dirname(resolved),
       workspaceFile: resolved
     };
   }
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await readdir5(resolved);
+  const entries = await readdir6(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: path41.join(resolved, workspaceFiles[0])
+      workspaceFile: path43.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? path41.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? path43.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -28729,7 +29067,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? path422.dirname(path422.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? path44.dirname(path44.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -28869,11 +29207,11 @@ async function runEvaluation(options) {
   let staticMaterialised = false;
   if (useStaticWorkspace && configuredStaticPath) {
     const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
-    const dirExists = await stat7(configuredStaticPath).then(
+    const dirExists = await stat8(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
     );
-    const isEmpty = dirExists ? (await readdir6(configuredStaticPath)).length === 0 : false;
+    const isEmpty = dirExists ? (await readdir7(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
         await mkdir14(configuredStaticPath, { recursive: true });
@@ -28926,9 +29264,9 @@ async function runEvaluation(options) {
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = path422.join(sharedWorkspacePath, path422.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = path44.join(sharedWorkspacePath, path44.basename(suiteWorkspaceFile));
       try {
-        await stat7(copiedWorkspaceFile);
+        await stat8(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
@@ -29508,9 +29846,9 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = path422.join(workspacePath, path422.basename(caseWorkspaceFile));
+        const copiedFile = path44.join(workspacePath, path44.basename(caseWorkspaceFile));
         try {
-          await stat7(copiedFile);
+          await stat8(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -29570,10 +29908,10 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = path422.resolve(baseDir, relPath);
-          const destPath = path422.resolve(workspacePath, relPath);
+          const srcPath = path44.resolve(baseDir, relPath);
+          const destPath = path44.resolve(workspacePath, relPath);
           try {
-            await mkdir14(path422.dirname(destPath), { recursive: true });
+            await mkdir14(path44.dirname(destPath), { recursive: true });
             await copyFile2(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -30219,7 +30557,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  const evalFileDir = evalCase.file_paths[0] ? path422.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? path44.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -30582,7 +30920,7 @@ async function evaluate(config) {
   }
   const gitRoot = await findGitRoot(process.cwd());
   const repoRoot = gitRoot ?? process.cwd();
-  const testFilePath = config.specFile ? path43.resolve(config.specFile) : path43.join(process.cwd(), "__programmatic__.yaml");
+  const testFilePath = config.specFile ? path45.resolve(config.specFile) : path45.join(process.cwd(), "__programmatic__.yaml");
   await loadEnvHierarchy(repoRoot, testFilePath);
   let resolvedTarget;
   let taskProvider;
@@ -30703,10 +31041,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(path43.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain(path45.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = path43.join(dir, candidate);
+      const targetsPath = path45.join(dir, candidate);
       if (!existsSync4(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
@@ -30723,7 +31061,7 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = path43.join(dir, ".env");
+    const envPath = path45.join(dir, ".env");
     if (existsSync4(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
@@ -30902,7 +31240,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await readFile11(filePath, "utf8");
+      const data = await readFile13(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -30910,13 +31248,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = path44.dirname(filePath);
+    const dir = path46.dirname(filePath);
     await mkdir15(dir, { recursive: true });
     await writeFile8(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return path44.join(this.cachePath, prefix, `${key}.json`);
+    return path46.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -31530,6 +31868,7 @@ export {
   subscribeToCodexLogEntries,
   consumeCopilotCliLogEntries,
   subscribeToCopilotCliLogEntries,
+  discoverCopilotSessions,
   consumeCopilotSdkLogEntries,
   subscribeToCopilotSdkLogEntries,
   consumePiLogEntries,
@@ -31622,4 +31961,4 @@ export {
   OtelStreamingObserver,
   createAgentKernel
 };
-//# sourceMappingURL=chunk-D3LNJUUB.js.map
+//# sourceMappingURL=chunk-3TBDSUYD.js.map