@agentv/core 3.11.0 → 3.12.0

package/dist/index.cjs

@@ -1315,12 +1315,12 @@ function serializeAttributeValue(value) {
   if (Array.isArray(value)) return { arrayValue: { values: value.map(serializeAttributeValue) } };
   return { stringValue: String(value) };
 }
-var import_promises32, import_node_path48, OtlpJsonFileExporter;
+var import_promises33, import_node_path49, OtlpJsonFileExporter;
 var init_otlp_json_file_exporter = __esm({
   "src/observability/otlp-json-file-exporter.ts"() {
     "use strict";
-    import_promises32 = require("fs/promises");
-    import_node_path48 = require("path");
+    import_promises33 = require("fs/promises");
+    import_node_path49 = require("path");
     OtlpJsonFileExporter = class {
       // biome-ignore lint/suspicious/noExplicitAny: serialized span data
       spans = [];
@@ -1359,7 +1359,7 @@ var init_otlp_json_file_exporter = __esm({
       }
       async flush() {
         if (this.spans.length === 0) return;
-        await (0, import_promises32.mkdir)((0, import_node_path48.dirname)(this.filePath), { recursive: true });
+        await (0, import_promises33.mkdir)((0, import_node_path49.dirname)(this.filePath), { recursive: true });
         const otlpJson = {
           resourceSpans: [
             {
@@ -1390,27 +1390,28 @@ function hrTimeDiffMs(start, end) {
   const diffNano = end[1] - start[1];
   return Math.round(diffSec * 1e3 + diffNano / 1e6);
 }
-var import_node_fs15, import_promises33, import_node_path49, SimpleTraceFileExporter;
+var import_node_fs16, import_promises34, import_node_path50, SimpleTraceFileExporter;
 var init_simple_trace_file_exporter = __esm({
   "src/observability/simple-trace-file-exporter.ts"() {
     "use strict";
-    import_node_fs15 = require("fs");
-    import_promises33 = require("fs/promises");
-    import_node_path49 = require("path");
+    import_node_fs16 = require("fs");
+    import_promises34 = require("fs/promises");
+    import_node_path50 = require("path");
     SimpleTraceFileExporter = class {
       stream = null;
       filePath;
       streamReady = null;
       pendingWrites = [];
       _shuttingDown = false;
+      spansByTraceId = /* @__PURE__ */ new Map();
       constructor(filePath) {
         this.filePath = filePath;
       }
       async ensureStream() {
         if (!this.streamReady) {
           this.streamReady = (async () => {
-            await (0, import_promises33.mkdir)((0, import_node_path49.dirname)(this.filePath), { recursive: true });
-            this.stream = (0, import_node_fs15.createWriteStream)(this.filePath, { flags: "w" });
+            await (0, import_promises34.mkdir)((0, import_node_path50.dirname)(this.filePath), { recursive: true });
+            this.stream = (0, import_node_fs16.createWriteStream)(this.filePath, { flags: "w" });
             return this.stream;
           })();
         }
@@ -1421,25 +1422,27 @@ var init_simple_trace_file_exporter = __esm({
           resultCallback({ code: 0 });
           return;
         }
-        const spanMap = /* @__PURE__ */ new Map();
-        const childMap = /* @__PURE__ */ new Map();
+        const rootSpans = [];
         for (const span of spans) {
-          spanMap.set(span.spanContext().spanId, span);
-          const parentId = span.parentSpanId;
-          if (parentId) {
-            if (!childMap.has(parentId)) childMap.set(parentId, []);
-            childMap.get(parentId)?.push(span);
+          const traceId = span.spanContext().traceId;
+          const existing = this.spansByTraceId.get(traceId) ?? [];
+          existing.push(span);
+          this.spansByTraceId.set(traceId, existing);
+          if (span.name === "agentv.eval") {
+            rootSpans.push(span);
           }
         }
-        const rootSpans = spans.filter(
-          (s) => !s.parentSpanId || !spanMap.has(s.parentSpanId)
-        );
         const writePromise = this.ensureStream().then((stream) => {
           for (const root of rootSpans) {
-            const children = this.collectChildren(root.spanContext().spanId, childMap);
+            const traceId = root.spanContext().traceId;
+            const traceSpans = this.spansByTraceId.get(traceId) ?? [root];
+            const children = traceSpans.filter(
+              (span) => span.spanContext().spanId !== root.spanContext().spanId
+            );
             const record = this.buildSimpleRecord(root, children);
             stream.write(`${JSON.stringify(record)}
 `);
+            this.spansByTraceId.delete(traceId);
           }
         });
         this.pendingWrites.push(writePromise);
@@ -1449,6 +1452,7 @@ var init_simple_trace_file_exporter = __esm({
         this._shuttingDown = true;
         await Promise.all(this.pendingWrites);
         this.pendingWrites = [];
+        this.spansByTraceId.clear();
         return new Promise((resolve) => {
           if (this.stream) {
             this.stream.end(() => resolve());
@@ -1461,17 +1465,9 @@ var init_simple_trace_file_exporter = __esm({
         await Promise.all(this.pendingWrites);
         this.pendingWrites = [];
       }
-      collectChildren(spanId, childMap) {
-        const direct = childMap.get(spanId) || [];
-        const all = [...direct];
-        for (const child of direct) {
-          all.push(...this.collectChildren(child.spanContext().spanId, childMap));
-        }
-        return all;
-      }
       buildSimpleRecord(root, children) {
         const attrs = root.attributes || {};
-        const durationMs = hrTimeDiffMs(root.startTime, root.endTime);
+        const durationMs = typeof attrs["agentv.trace.duration_ms"] === "number" ? attrs["agentv.trace.duration_ms"] : hrTimeDiffMs(root.startTime, root.endTime);
         let inputTokens = 0;
         let outputTokens = 0;
         for (const child of children) {
@@ -1479,6 +1475,14 @@ var init_simple_trace_file_exporter = __esm({
           if (ca["gen_ai.usage.input_tokens"]) inputTokens += ca["gen_ai.usage.input_tokens"];
           if (ca["gen_ai.usage.output_tokens"]) outputTokens += ca["gen_ai.usage.output_tokens"];
         }
+        const rootInputTokens = typeof attrs["agentv.trace.token_input"] === "number" ? attrs["agentv.trace.token_input"] : 0;
+        const rootOutputTokens = typeof attrs["agentv.trace.token_output"] === "number" ? attrs["agentv.trace.token_output"] : 0;
+        const rootCachedTokens = typeof attrs["agentv.trace.token_cached"] === "number" ? attrs["agentv.trace.token_cached"] : void 0;
+        const llmSpans = children.filter((s) => s.attributes?.["gen_ai.operation.name"] === "chat").map((s) => ({
+          type: "llm",
+          name: s.name,
+          duration_ms: hrTimeDiffMs(s.startTime, s.endTime)
+        }));
         const toolSpans = children.filter((s) => s.attributes?.["gen_ai.tool.name"]).map((s) => ({
           type: "tool",
           name: s.attributes["gen_ai.tool.name"],
@@ -1490,8 +1494,12 @@ var init_simple_trace_file_exporter = __esm({
           score: attrs["agentv.score"],
           duration_ms: durationMs,
           cost_usd: attrs["agentv.trace.cost_usd"],
-          token_usage: inputTokens || outputTokens ? { input: inputTokens, output: outputTokens } : void 0,
-          spans: toolSpans.length > 0 ? toolSpans : void 0
+          token_usage: inputTokens || outputTokens || rootInputTokens || rootOutputTokens || rootCachedTokens ? {
+            input: inputTokens || rootInputTokens,
+            output: outputTokens || rootOutputTokens,
+            ...rootCachedTokens ? { cached: rootCachedTokens } : {}
+          } : void 0,
+          spans: [...llmSpans, ...toolSpans].length > 0 ? [...llmSpans, ...toolSpans] : void 0
         };
       }
     };
@@ -8749,265 +8757,7 @@ var MockProvider = class {
   }
 };
 
-// src/evaluation/providers/pi-utils.ts
-function extractPiTextContent(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  if (!Array.isArray(content)) {
-    return void 0;
-  }
-  const textParts = [];
-  for (const part of content) {
-    if (!part || typeof part !== "object") {
-      continue;
-    }
-    const p = part;
-    if (p.type === "text" && typeof p.text === "string") {
-      textParts.push(p.text);
-    }
-  }
-  return textParts.length > 0 ? textParts.join("\n") : void 0;
-}
-function toFiniteNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  return void 0;
-}
-
-// src/evaluation/providers/pi-agent-sdk.ts
-var piAgentModule = null;
-var piAiModule = null;
-async function loadPiModules() {
-  if (!piAgentModule || !piAiModule) {
-    try {
-      [piAgentModule, piAiModule] = await Promise.all([
-        import("@mariozechner/pi-agent-core"),
-        import("@mariozechner/pi-ai")
-      ]);
-    } catch (error) {
-      throw new Error(
-        `Failed to load pi-agent-sdk dependencies. Please install them:
-  npm install @mariozechner/pi-agent-core @mariozechner/pi-ai
-
-Original error: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return {
-    Agent: piAgentModule.Agent,
-    getModel: piAiModule.getModel,
-    getEnvApiKey: piAiModule.getEnvApiKey
-  };
-}
-var PiAgentSdkProvider = class {
-  id;
-  kind = "pi-agent-sdk";
-  targetName;
-  supportsBatch = false;
-  config;
-  constructor(targetName, config) {
-    this.id = `pi-agent-sdk:${targetName}`;
-    this.targetName = targetName;
-    this.config = config;
-  }
-  async invoke(request) {
-    if (request.signal?.aborted) {
-      throw new Error("Pi agent SDK request was aborted before execution");
-    }
-    const { Agent, getModel, getEnvApiKey } = await loadPiModules();
-    const startTimeIso = (/* @__PURE__ */ new Date()).toISOString();
-    const startMs = Date.now();
-    const providerName = this.config.subprovider ?? "anthropic";
-    const modelId = this.config.model ?? "claude-sonnet-4-20250514";
-    const model = getModel(providerName, modelId);
-    const systemPrompt = this.config.systemPrompt ?? "Answer directly and concisely.";
-    const agent = new Agent({
-      initialState: {
-        systemPrompt,
-        model,
-        tools: [],
-        // No tools for simple Q&A
-        messages: []
-      },
-      getApiKey: async (provider) => {
-        return this.config.apiKey ?? getEnvApiKey(provider) ?? void 0;
-      }
-    });
-    let tokenUsage;
-    let costUsd;
-    const toolTrackers = /* @__PURE__ */ new Map();
-    const completedToolResults = /* @__PURE__ */ new Map();
-    const unsubscribe = agent.subscribe((event) => {
-      switch (event.type) {
-        case "message_end": {
-          const msg = event.message;
-          if (msg && typeof msg === "object" && "role" in msg && msg.role === "assistant" && "usage" in msg) {
-            const usage = msg.usage;
-            if (usage && typeof usage === "object") {
-              const u = usage;
-              const input = toFiniteNumber(u.input);
-              const output = toFiniteNumber(u.output);
-              const cached = toFiniteNumber(u.cacheRead);
-              let callDelta;
-              if (input !== void 0 || output !== void 0) {
-                callDelta = {
-                  input: input ?? 0,
-                  output: output ?? 0,
-                  ...cached !== void 0 ? { cached } : {}
-                };
-                tokenUsage = {
-                  input: (tokenUsage?.input ?? 0) + callDelta.input,
-                  output: (tokenUsage?.output ?? 0) + callDelta.output,
-                  ...cached !== void 0 ? { cached: (tokenUsage?.cached ?? 0) + cached } : tokenUsage?.cached !== void 0 ? { cached: tokenUsage.cached } : {}
-                };
-              }
-              const cost = u.cost;
-              if (cost && typeof cost === "object") {
-                const total = toFiniteNumber(cost.total);
-                if (total !== void 0) {
-                  costUsd = (costUsd ?? 0) + total;
-                }
-              }
-              request.streamCallbacks?.onLlmCallEnd?.(modelId, callDelta);
-            }
-          }
-          break;
-        }
-        case "tool_execution_start": {
-          toolTrackers.set(event.toolCallId, {
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            args: event.args,
-            startMs: Date.now(),
-            startTime: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          request.streamCallbacks?.onToolCallStart?.(event.toolName, event.toolCallId);
-          break;
-        }
-        case "tool_execution_end": {
-          const tracker = toolTrackers.get(event.toolCallId);
-          const durationMs = tracker ? Date.now() - tracker.startMs : 0;
-          completedToolResults.set(event.toolCallId, {
-            output: event.result,
-            durationMs
-          });
-          request.streamCallbacks?.onToolCallEnd?.(
-            event.toolName,
-            tracker?.args,
-            event.result,
-            durationMs,
-            event.toolCallId
-          );
-          toolTrackers.delete(event.toolCallId);
-          break;
-        }
-      }
-    });
-    try {
-      if (this.config.timeoutMs) {
-        const timeoutMs = this.config.timeoutMs;
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(
-            () => reject(new Error(`Pi agent SDK timed out after ${timeoutMs}ms`)),
-            timeoutMs
-          );
-        });
-        await Promise.race([agent.prompt(request.question), timeoutPromise]);
-      } else {
-        await agent.prompt(request.question);
-      }
-      await agent.waitForIdle();
-      const agentMessages = agent.state.messages;
-      const output = [];
-      for (const msg of agentMessages) {
-        output.push(convertAgentMessage(msg, toolTrackers, completedToolResults));
-      }
-      const endTimeIso = (/* @__PURE__ */ new Date()).toISOString();
-      const durationMs = Date.now() - startMs;
-      return {
-        raw: {
-          messages: agentMessages,
-          systemPrompt,
-          model: this.config.model,
-          subprovider: this.config.subprovider
-        },
-        output,
-        tokenUsage,
-        costUsd,
-        durationMs,
-        startTime: startTimeIso,
-        endTime: endTimeIso
-      };
-    } finally {
-      unsubscribe();
-    }
-  }
-};
-function convertAgentMessage(message, toolTrackers, completedToolResults) {
-  if (!message || typeof message !== "object") {
-    return { role: "unknown", content: String(message) };
-  }
-  const msg = message;
-  const role = typeof msg.role === "string" ? msg.role : "unknown";
-  const content = extractPiTextContent(msg.content);
-  const toolCalls = extractToolCalls3(msg.content, toolTrackers, completedToolResults);
-  const startTime = typeof msg.timestamp === "number" ? new Date(msg.timestamp).toISOString() : typeof msg.timestamp === "string" ? msg.timestamp : void 0;
-  let msgTokenUsage;
-  if (msg.usage && typeof msg.usage === "object") {
-    const u = msg.usage;
-    const input = toFiniteNumber(u.input);
-    const output = toFiniteNumber(u.output);
-    if (input !== void 0 || output !== void 0) {
-      msgTokenUsage = {
-        input: input ?? 0,
-        output: output ?? 0,
-        ...toFiniteNumber(u.cacheRead) !== void 0 ? { cached: toFiniteNumber(u.cacheRead) } : {}
-      };
-    }
-  }
-  const metadata = {};
-  if (msg.api) metadata.api = msg.api;
-  if (msg.provider) metadata.provider = msg.provider;
-  if (msg.model) metadata.model = msg.model;
-  if (msg.stopReason) metadata.stopReason = msg.stopReason;
-  return {
-    role,
-    content,
-    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
-    startTime,
-    metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
-    tokenUsage: msgTokenUsage
-  };
-}
-function extractToolCalls3(content, toolTrackers, completedToolResults) {
-  if (!Array.isArray(content)) {
-    return [];
-  }
-  const toolCalls = [];
-  for (const part of content) {
-    if (!part || typeof part !== "object") {
-      continue;
-    }
-    const p = part;
-    if (p.type === "toolCall" && typeof p.name === "string") {
-      const id = typeof p.id === "string" ? p.id : void 0;
-      const tracker = id ? toolTrackers.get(id) : void 0;
-      const completed = id ? completedToolResults.get(id) : void 0;
-      toolCalls.push({
-        tool: p.name,
-        input: p.arguments,
-        id,
-        output: completed?.output,
-        durationMs: completed?.durationMs,
-        startTime: tracker?.startTime,
-        endTime: tracker?.startTime && completed?.durationMs !== void 0 ? new Date(new Date(tracker.startTime).getTime() + completed.durationMs).toISOString() : void 0
-      });
-    }
-  }
-  return toolCalls;
-}
-
-// src/evaluation/providers/pi-coding-agent.ts
+// src/evaluation/providers/pi-cli.ts
 var import_node_child_process4 = require("child_process");
 var import_node_crypto7 = require("crypto");
 var import_node_fs8 = require("fs");
@@ -9068,25 +8818,50 @@ function subscribeToPiLogEntries(listener) {
   };
 }
 
-// src/evaluation/providers/pi-coding-agent.ts
+// src/evaluation/providers/pi-utils.ts
+function extractPiTextContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return void 0;
+  }
+  const textParts = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    const p = part;
+    if (p.type === "text" && typeof p.text === "string") {
+      textParts.push(p.text);
+    }
+  }
+  return textParts.length > 0 ? textParts.join("\n") : void 0;
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  return void 0;
+}
+
+// src/evaluation/providers/pi-cli.ts
 var WORKSPACE_PREFIX = "agentv-pi-";
 var PROMPT_FILENAME = "prompt.md";
-var PiCodingAgentProvider = class {
+var PiCliProvider = class {
   id;
-  kind = "pi-coding-agent";
+  kind = "pi-cli";
   targetName;
   supportsBatch = false;
   config;
   runPi;
   constructor(targetName, config, runner = defaultPiRunner) {
-    this.id = `pi-coding-agent:${targetName}`;
+    this.id = `pi-cli:${targetName}`;
     this.targetName = targetName;
     this.config = config;
     this.runPi = runner;
   }
   async invoke(request) {
     if (request.signal?.aborted) {
-      throw new Error("Pi coding agent request was aborted before execution");
+      throw new Error("Pi CLI request was aborted before execution");
     }
     const inputFiles = normalizeInputFiles(request.inputFiles);
     const startTime = (/* @__PURE__ */ new Date()).toISOString();
@@ -9096,17 +8871,17 @@ var PiCodingAgentProvider = class {
     try {
       const promptFile = import_node_path19.default.join(workspaceRoot, PROMPT_FILENAME);
       await (0, import_promises16.writeFile)(promptFile, request.question, "utf8");
-      const args = this.buildPiArgs(request.question, inputFiles, request.captureFileChanges);
+      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(
-          `Pi coding agent timed out${formatTimeoutSuffix3(this.config.timeoutMs ?? void 0)}`
+          `Pi CLI timed out${formatTimeoutSuffix3(this.config.timeoutMs ?? void 0)}`
         );
       }
       if (result.exitCode !== 0) {
         const detail = pickDetail(result.stderr, result.stdout);
-        const prefix = `Pi coding agent exited with code ${result.exitCode}`;
+        const prefix = `Pi CLI exited with code ${result.exitCode}`;
         throw new Error(detail ? `${prefix}: ${detail}` : prefix);
       }
       const parsed = parsePiJsonl(result.stdout);
@@ -9163,7 +8938,7 @@ var PiCodingAgentProvider = class {
     }
     return import_node_path19.default.resolve(this.config.cwd);
   }
-  buildPiArgs(prompt, inputFiles, _captureFileChanges) {
+  buildPiArgs(prompt, inputFiles) {
     const args = [];
     if (this.config.subprovider) {
       args.push("--provider", this.config.subprovider);
@@ -9215,7 +8990,7 @@ ${prompt}` : prompt;
       const err = error;
       if (err.code === "ENOENT") {
         throw new Error(
-          `Pi coding agent executable '${this.config.executable}' was not found. Update the target settings.executable or add it to PATH.`
+          `Pi CLI executable '${this.config.executable}' was not found. Update the target executable or add it to PATH.`
         );
       }
       throw error;
@@ -9225,26 +9000,18 @@ ${prompt}` : prompt;
     const env = { ...process.env };
     if (this.config.apiKey) {
       const provider = this.config.subprovider?.toLowerCase() ?? "google";
-      switch (provider) {
-        case "google":
-        case "gemini":
-          env.GEMINI_API_KEY = this.config.apiKey;
-          break;
-        case "anthropic":
-          env.ANTHROPIC_API_KEY = this.config.apiKey;
-          break;
-        case "openai":
-          env.OPENAI_API_KEY = this.config.apiKey;
-          break;
-        case "groq":
-          env.GROQ_API_KEY = this.config.apiKey;
-          break;
-        case "xai":
-          env.XAI_API_KEY = this.config.apiKey;
-          break;
-        case "openrouter":
-          env.OPENROUTER_API_KEY = this.config.apiKey;
-          break;
+      const ENV_KEY_MAP = {
+        google: "GEMINI_API_KEY",
+        gemini: "GEMINI_API_KEY",
+        anthropic: "ANTHROPIC_API_KEY",
+        openai: "OPENAI_API_KEY",
+        groq: "GROQ_API_KEY",
+        xai: "XAI_API_KEY",
+        openrouter: "OPENROUTER_API_KEY"
+      };
+      const envKey = ENV_KEY_MAP[provider];
+      if (envKey) {
+        env[envKey] = this.config.apiKey;
       }
     }
     return env;
@@ -9262,7 +9029,7 @@ ${prompt}` : prompt;
     if (this.config.logDir) {
       return import_node_path19.default.resolve(this.config.logDir);
     }
-    return import_node_path19.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return import_node_path19.default.join(process.cwd(), ".agentv", "logs", "pi-cli");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -9314,7 +9081,7 @@ var PiStreamLogger = class _PiStreamLogger {
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
     const header = [
-      "# Pi Coding Agent stream log",
+      "# Pi CLI stream log",
       `# target: ${options.targetName}`,
       options.evalCaseId ? `# eval: ${options.evalCaseId}` : void 0,
       options.attempt !== void 0 ? `# attempt: ${options.attempt + 1}` : void 0,
@@ -9463,10 +9230,10 @@ function summarizePiEvent(event) {
       return `${type}: ${role}`;
     }
     case "message_update": {
-      const event2 = record.assistantMessageEvent;
-      const eventType = event2?.type;
+      const evt = record.assistantMessageEvent;
+      const eventType = evt?.type;
       if (eventType === "text_delta") {
-        const delta = event2?.delta;
+        const delta = evt?.delta;
         if (typeof delta === "string") {
           const preview = delta.length > 50 ? `${delta.slice(0, 50)}...` : delta;
           return `text_delta: ${preview}`;
@@ -9488,7 +9255,7 @@ function tryParseJsonValue(rawLine) {
 function parsePiJsonl(output) {
   const trimmed = output.trim();
   if (trimmed.length === 0) {
-    throw new Error("Pi coding agent produced no output");
+    throw new Error("Pi CLI produced no output");
   }
   const lines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
   const parsed = [];
@@ -9499,38 +9266,27 @@ function parsePiJsonl(output) {
     }
   }
   if (parsed.length === 0) {
-    throw new Error("Pi coding agent produced no valid JSON output");
+    throw new Error("Pi CLI produced no valid JSON output");
   }
   return parsed;
 }
 function extractMessages(events) {
   for (let i = events.length - 1; i >= 0; i--) {
     const event = events[i];
-    if (!event || typeof event !== "object") {
-      continue;
-    }
+    if (!event || typeof event !== "object") continue;
     const record = event;
-    if (record.type !== "agent_end") {
-      continue;
-    }
+    if (record.type !== "agent_end") continue;
     const messages = record.messages;
-    if (!Array.isArray(messages)) {
-      continue;
-    }
+    if (!Array.isArray(messages)) continue;
     return messages.map(convertPiMessage).filter((m) => m !== void 0);
   }
   const output = [];
   for (const event of events) {
-    if (!event || typeof event !== "object") {
-      continue;
-    }
+    if (!event || typeof event !== "object") continue;
     const record = event;
     if (record.type === "turn_end") {
-      const message = record.message;
-      const converted = convertPiMessage(message);
-      if (converted) {
-        output.push(converted);
-      }
+      const converted = convertPiMessage(record.message);
+      if (converted) output.push(converted);
     }
   }
   return output;
@@ -9547,10 +9303,7 @@ function extractTokenUsage(events) {
       const input = toFiniteNumber(u.input_tokens ?? u.inputTokens ?? u.input);
       const output = toFiniteNumber(u.output_tokens ?? u.outputTokens ?? u.output);
       if (input !== void 0 || output !== void 0) {
-        const result = {
-          input: input ?? 0,
-          output: output ?? 0
-        };
+        const result = { input: input ?? 0, output: output ?? 0 };
         const cached = toFiniteNumber(u.cache_read_input_tokens ?? u.cached ?? u.cachedTokens);
         const reasoning = toFiniteNumber(u.reasoning_tokens ?? u.reasoningTokens ?? u.reasoning);
         return {
@@ -9598,16 +9351,12 @@ function aggregateUsageFromMessages(messages) {
   return result;
 }
 function convertPiMessage(message) {
-  if (!message || typeof message !== "object") {
-    return void 0;
-  }
+  if (!message || typeof message !== "object") return void 0;
   const msg = message;
   const role = msg.role;
-  if (typeof role !== "string") {
-    return void 0;
-  }
+  if (typeof role !== "string") return void 0;
   const content = extractPiTextContent(msg.content);
-  const toolCalls = extractToolCalls4(msg.content);
+  const toolCalls = extractToolCalls3(msg.content);
   const startTime = typeof msg.timestamp === "number" ? new Date(msg.timestamp).toISOString() : typeof msg.timestamp === "string" ? msg.timestamp : void 0;
   const metadata = {};
   if (msg.api) metadata.api = msg.api;
@@ -9623,15 +9372,11 @@ function convertPiMessage(message) {
     metadata: Object.keys(metadata).length > 0 ? metadata : void 0
   };
 }
-function extractToolCalls4(content) {
-  if (!Array.isArray(content)) {
-    return [];
-  }
+function extractToolCalls3(content) {
+  if (!Array.isArray(content)) return [];
   const toolCalls = [];
   for (const part of content) {
-    if (!part || typeof part !== "object") {
-      continue;
-    }
+    if (!part || typeof part !== "object") continue;
     const p = part;
     if (p.type === "tool_use" && typeof p.name === "string") {
       toolCalls.push({
@@ -9651,10 +9396,7 @@ function extractToolCalls4(content) {
       const existing = toolCalls.find((tc) => tc.id === p.tool_use_id);
       if (existing) {
         const idx = toolCalls.indexOf(existing);
-        toolCalls[idx] = {
-          ...existing,
-          output: p.content
-        };
+        toolCalls[idx] = { ...existing, output: p.content };
       }
     }
   }
@@ -9665,18 +9407,13 @@ function escapeAtSymbols(prompt) {
 }
 function pickDetail(stderr, stdout) {
   const errorText = stderr.trim();
-  if (errorText.length > 0) {
-    return errorText;
-  }
+  if (errorText.length > 0) return errorText;
   const stdoutText = stdout.trim();
   return stdoutText.length > 0 ? stdoutText : void 0;
 }
 function formatTimeoutSuffix3(timeoutMs) {
-  if (!timeoutMs || timeoutMs <= 0) {
-    return "";
-  }
-  const seconds = Math.ceil(timeoutMs / 1e3);
-  return ` after ${seconds}s`;
+  if (!timeoutMs || timeoutMs <= 0) return "";
+  return ` after ${Math.ceil(timeoutMs / 1e3)}s`;
 }
 async function defaultPiRunner(options) {
   return await new Promise((resolve, reject) => {
@@ -9711,39 +9448,497 @@ async function defaultPiRunner(options) {
       }, options.timeoutMs);
       timeoutHandle.unref?.();
     }
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk;
-      options.onStdoutChunk?.(chunk);
-    });
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-      options.onStderrChunk?.(chunk);
-    });
-    child.stdin.end();
-    const cleanup = () => {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-      }
-      if (options.signal) {
-        options.signal.removeEventListener("abort", onAbort);
-      }
-    };
-    child.on("error", (error) => {
-      cleanup();
-      reject(error);
-    });
-    child.on("close", (code) => {
-      cleanup();
-      resolve({
-        stdout,
-        stderr,
-        exitCode: typeof code === "number" ? code : -1,
-        timedOut
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      options.onStdoutChunk?.(chunk);
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      options.onStderrChunk?.(chunk);
+    });
+    child.stdin.end();
+    const cleanup = () => {
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      if (options.signal) options.signal.removeEventListener("abort", onAbort);
+    };
+    child.on("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.on("close", (code) => {
+      cleanup();
+      resolve({
+        stdout,
+        stderr,
+        exitCode: typeof code === "number" ? code : -1,
+        timedOut
+      });
+    });
+  });
+}
+
+// src/evaluation/providers/pi-coding-agent.ts
+var import_node_child_process5 = require("child_process");
+var import_node_crypto8 = require("crypto");
+var import_node_fs9 = require("fs");
+var import_promises17 = require("fs/promises");
+var import_node_path20 = __toESM(require("path"), 1);
+var import_node_readline = require("readline");
+var piCodingAgentModule = null;
+var piAiModule = null;
+async function promptInstall() {
+  if (!process.stdout.isTTY) return false;
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stderr });
+  try {
+    return await new Promise((resolve) => {
+      rl.question(
+        "@mariozechner/pi-coding-agent is not installed. Install it now? (y/N) ",
+        (answer) => resolve(answer.trim().toLowerCase() === "y")
+      );
+    });
+  } finally {
+    rl.close();
+  }
+}
+async function loadSdkModules() {
+  if (!piCodingAgentModule || !piAiModule) {
+    try {
+      [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...");
+        (0, import_node_child_process5.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"
+        );
+      }
+    }
+  }
+  const toolMap = {
+    read: piCodingAgentModule.readTool,
+    bash: piCodingAgentModule.bashTool,
+    edit: piCodingAgentModule.editTool,
+    write: piCodingAgentModule.writeTool,
+    grep: piCodingAgentModule.grepTool,
+    find: piCodingAgentModule.findTool,
+    ls: piCodingAgentModule.lsTool
+  };
+  return {
+    createAgentSession: piCodingAgentModule.createAgentSession,
+    codingTools: piCodingAgentModule.codingTools,
+    toolMap,
+    SessionManager: piCodingAgentModule.SessionManager,
+    getModel: piAiModule.getModel
+  };
+}
+var PiCodingAgentProvider = class {
+  id;
+  kind = "pi-coding-agent";
+  targetName;
+  supportsBatch = false;
+  config;
+  constructor(targetName, config) {
+    this.id = `pi-coding-agent:${targetName}`;
+    this.targetName = targetName;
+    this.config = config;
+  }
+  async invoke(request) {
+    if (request.signal?.aborted) {
+      throw new Error("Pi coding agent request was aborted before execution");
+    }
+    const inputFiles = normalizeInputFiles(request.inputFiles);
+    const startTime = (/* @__PURE__ */ new Date()).toISOString();
+    const startMs = Date.now();
+    const sdk = await loadSdkModules();
+    const logger = await this.createStreamLogger(request).catch(() => void 0);
+    try {
+      const cwd = this.resolveCwd(request.cwd);
+      const providerName = this.config.subprovider ?? "google";
+      const modelId = this.config.model ?? "gemini-2.5-flash";
+      this.setApiKeyEnv(providerName);
+      const model = sdk.getModel(providerName, modelId);
+      const tools = this.resolveTools(sdk);
+      const { session } = await sdk.createAgentSession({
+        cwd,
+        model,
+        tools,
+        thinkingLevel: this.config.thinking,
+        sessionManager: sdk.SessionManager.inMemory(cwd)
+      });
+      let tokenUsage;
+      let costUsd;
+      const toolTrackers = /* @__PURE__ */ new Map();
+      const completedToolResults = /* @__PURE__ */ new Map();
+      const unsubscribe = session.subscribe((event) => {
+        logger?.handleEvent(event);
+        switch (event.type) {
+          case "message_end": {
+            const msg = event.message;
+            if (msg && typeof msg === "object" && "role" in msg && msg.role === "assistant" && "usage" in msg) {
+              const usage = msg.usage;
+              if (usage && typeof usage === "object") {
+                const u = usage;
+                const input = toFiniteNumber(u.input);
+                const output = toFiniteNumber(u.output);
+                const cached = toFiniteNumber(u.cacheRead);
+                let callDelta;
+                if (input !== void 0 || output !== void 0) {
+                  callDelta = {
+                    input: input ?? 0,
+                    output: output ?? 0,
+                    ...cached !== void 0 ? { cached } : {}
+                  };
+                  tokenUsage = {
+                    input: (tokenUsage?.input ?? 0) + callDelta.input,
+                    output: (tokenUsage?.output ?? 0) + callDelta.output,
+                    ...cached !== void 0 ? { cached: (tokenUsage?.cached ?? 0) + cached } : tokenUsage?.cached !== void 0 ? { cached: tokenUsage.cached } : {}
+                  };
+                }
+                const cost = u.cost;
+                if (cost && typeof cost === "object") {
+                  const total = toFiniteNumber(cost.total);
+                  if (total !== void 0) {
+                    costUsd = (costUsd ?? 0) + total;
+                  }
+                }
+                request.streamCallbacks?.onLlmCallEnd?.(modelId, callDelta);
+              }
+            }
+            break;
+          }
+          case "tool_execution_start": {
+            toolTrackers.set(event.toolCallId, {
+              toolCallId: event.toolCallId,
+              toolName: event.toolName,
+              args: event.args,
+              startMs: Date.now(),
+              startTime: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            request.streamCallbacks?.onToolCallStart?.(event.toolName, event.toolCallId);
+            break;
+          }
+          case "tool_execution_end": {
+            const tracker = toolTrackers.get(event.toolCallId);
+            const durationMs = tracker ? Date.now() - tracker.startMs : 0;
+            completedToolResults.set(event.toolCallId, {
+              output: event.result,
+              durationMs
+            });
+            request.streamCallbacks?.onToolCallEnd?.(
+              event.toolName,
+              tracker?.args,
+              event.result,
+              durationMs,
+              event.toolCallId
+            );
+            toolTrackers.delete(event.toolCallId);
+            break;
+          }
+        }
+      });
+      try {
+        const systemPrompt = this.config.systemPrompt;
+        let prompt = request.question;
+        if (systemPrompt) {
+          prompt = `${systemPrompt}
+
+${prompt}`;
+        }
+        if (inputFiles && inputFiles.length > 0) {
+          const fileList = inputFiles.map((f) => `@${f}`).join("\n");
+          prompt = `${prompt}
+
+Files:
+${fileList}`;
+        }
+        if (this.config.timeoutMs) {
+          const timeoutMs = this.config.timeoutMs;
+          let timeoutId;
+          const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(
+              () => reject(
+                new Error(`Pi coding agent timed out after ${Math.ceil(timeoutMs / 1e3)}s`)
+              ),
+              timeoutMs
+            );
+          });
+          try {
+            await Promise.race([session.prompt(prompt), timeoutPromise]);
+          } finally {
+            if (timeoutId !== void 0) clearTimeout(timeoutId);
+          }
+        } else {
+          await session.prompt(prompt);
+        }
+        const agentMessages = session.agent.state.messages;
+        const output = [];
+        for (const msg of agentMessages) {
+          output.push(convertAgentMessage(msg, toolTrackers, completedToolResults));
+        }
+        const endTime = (/* @__PURE__ */ new Date()).toISOString();
+        const durationMs = Date.now() - startMs;
+        return {
+          raw: {
+            messages: agentMessages,
+            model: this.config.model,
+            provider: this.config.subprovider
+          },
+          output,
+          tokenUsage,
+          costUsd,
+          durationMs,
+          startTime,
+          endTime
+        };
+      } finally {
+        unsubscribe();
+        session.dispose();
+      }
+    } finally {
+      await logger?.close();
+    }
+  }
+  /** Maps config apiKey to the provider-specific env var the SDK reads. */
+  setApiKeyEnv(providerName) {
+    if (!this.config.apiKey) return;
+    const ENV_KEY_MAP = {
+      google: "GEMINI_API_KEY",
+      gemini: "GEMINI_API_KEY",
+      anthropic: "ANTHROPIC_API_KEY",
+      openai: "OPENAI_API_KEY",
+      groq: "GROQ_API_KEY",
+      xai: "XAI_API_KEY",
+      openrouter: "OPENROUTER_API_KEY"
+    };
+    const envKey = ENV_KEY_MAP[providerName.toLowerCase()];
+    if (envKey) {
+      process.env[envKey] = this.config.apiKey;
+    }
+  }
+  resolveCwd(cwdOverride) {
+    if (cwdOverride) {
+      return import_node_path20.default.resolve(cwdOverride);
+    }
+    if (this.config.cwd) {
+      return import_node_path20.default.resolve(this.config.cwd);
+    }
+    return process.cwd();
+  }
+  resolveTools(sdk) {
+    if (!this.config.tools) {
+      return sdk.codingTools;
+    }
+    const toolNames = this.config.tools.split(",").map((t) => t.trim().toLowerCase());
+    const selected = [];
+    for (const name of toolNames) {
+      if (name in sdk.toolMap) {
+        selected.push(sdk.toolMap[name]);
+      }
+    }
+    return selected.length > 0 ? selected : sdk.codingTools;
+  }
+  resolveLogDirectory() {
+    if (this.config.logDir) {
+      return import_node_path20.default.resolve(this.config.logDir);
+    }
+    return import_node_path20.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+  }
+  async createStreamLogger(request) {
+    const logDir = this.resolveLogDirectory();
+    if (!logDir) {
+      return void 0;
+    }
+    try {
+      await (0, import_promises17.mkdir)(logDir, { recursive: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Skipping Pi stream logging (could not create ${logDir}): ${message}`);
+      return void 0;
+    }
+    const filePath = import_node_path20.default.join(logDir, buildLogFilename6(request, this.targetName));
+    try {
+      const logger = await PiStreamLogger2.create({
+        filePath,
+        targetName: this.targetName,
+        evalCaseId: request.evalCaseId,
+        attempt: request.attempt,
+        format: this.config.logFormat ?? "summary"
+      });
+      recordPiLogEntry({
+        filePath,
+        targetName: this.targetName,
+        evalCaseId: request.evalCaseId,
+        attempt: request.attempt
+      });
+      return logger;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Skipping Pi stream logging for ${filePath}: ${message}`);
+      return void 0;
+    }
+  }
+};
+var PiStreamLogger2 = class _PiStreamLogger {
+  filePath;
+  stream;
+  startedAt = Date.now();
+  format;
+  constructor(filePath, format) {
+    this.filePath = filePath;
+    this.format = format;
+    this.stream = (0, import_node_fs9.createWriteStream)(filePath, { flags: "a" });
+  }
+  static async create(options) {
+    const logger = new _PiStreamLogger(options.filePath, options.format);
+    const header = [
+      "# Pi Coding Agent stream log",
+      `# target: ${options.targetName}`,
+      options.evalCaseId ? `# eval: ${options.evalCaseId}` : void 0,
+      options.attempt !== void 0 ? `# attempt: ${options.attempt + 1}` : void 0,
+      `# started: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      ""
+    ].filter((line) => Boolean(line));
+    for (const line of header) {
+      logger.stream.write(`${line}
+`);
+    }
+    return logger;
+  }
+  handleEvent(event) {
+    if (!event || typeof event !== "object") return;
+    const record = event;
+    const type = typeof record.type === "string" ? record.type : void 0;
+    if (!type) return;
+    const message = this.format === "json" ? JSON.stringify(event, null, 2) : summarizeSdkEvent2(event);
+    if (message) {
+      this.stream.write(`[+${formatElapsed6(this.startedAt)}] ${message}
+`);
+    }
+  }
+  async close() {
+    await new Promise((resolve, reject) => {
+      this.stream.once("error", reject);
+      this.stream.end(() => resolve());
+    });
+  }
+};
+function summarizeSdkEvent2(event) {
+  if (!event || typeof event !== "object") return void 0;
+  const record = event;
+  const type = typeof record.type === "string" ? record.type : void 0;
+  if (!type) return void 0;
+  switch (type) {
+    case "agent_start":
+    case "agent_end":
+    case "turn_start":
+    case "turn_end":
+      return type;
+    case "message_start":
+    case "message_end": {
+      const msg = record.message;
+      return `${type}: ${msg?.role ?? "unknown"}`;
+    }
+    case "tool_execution_start":
+      return `tool_start: ${record.toolName}`;
+    case "tool_execution_end":
+      return `tool_end: ${record.toolName}`;
+    default:
+      return type;
+  }
+}
+function buildLogFilename6(request, targetName) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const evalId = sanitizeForFilename6(request.evalCaseId ?? "pi");
+  const attemptSuffix = request.attempt !== void 0 ? `_attempt-${request.attempt + 1}` : "";
+  const target = sanitizeForFilename6(targetName);
+  return `${timestamp}_${target}_${evalId}${attemptSuffix}_${(0, import_node_crypto8.randomUUID)().slice(0, 8)}.log`;
+}
+function sanitizeForFilename6(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "_");
+  return sanitized.length > 0 ? sanitized : "pi";
+}
+function formatElapsed6(startedAt) {
+  const elapsedSeconds = Math.floor((Date.now() - startedAt) / 1e3);
+  const hours = Math.floor(elapsedSeconds / 3600);
+  const minutes = Math.floor(elapsedSeconds % 3600 / 60);
+  const seconds = elapsedSeconds % 60;
+  if (hours > 0) {
+    return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+  }
+  return `${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`;
+}
+function convertAgentMessage(message, toolTrackers, completedToolResults) {
+  if (!message || typeof message !== "object") {
+    return { role: "unknown", content: String(message) };
+  }
+  const msg = message;
+  const role = typeof msg.role === "string" ? msg.role : "unknown";
+  const content = extractPiTextContent(msg.content);
+  const toolCalls = extractToolCalls4(msg.content, toolTrackers, completedToolResults);
+  const startTimeVal = typeof msg.timestamp === "number" ? new Date(msg.timestamp).toISOString() : typeof msg.timestamp === "string" ? msg.timestamp : void 0;
+  let msgTokenUsage;
+  if (msg.usage && typeof msg.usage === "object") {
+    const u = msg.usage;
+    const input = toFiniteNumber(u.input);
+    const output = toFiniteNumber(u.output);
+    if (input !== void 0 || output !== void 0) {
+      msgTokenUsage = {
+        input: input ?? 0,
+        output: output ?? 0,
+        ...toFiniteNumber(u.cacheRead) !== void 0 ? { cached: toFiniteNumber(u.cacheRead) } : {}
+      };
+    }
+  }
+  const metadata = {};
+  if (msg.api) metadata.api = msg.api;
+  if (msg.provider) metadata.provider = msg.provider;
+  if (msg.model) metadata.model = msg.model;
+  if (msg.stopReason) metadata.stopReason = msg.stopReason;
+  return {
+    role,
+    content,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    startTime: startTimeVal,
+    metadata: Object.keys(metadata).length > 0 ? metadata : void 0,
+    tokenUsage: msgTokenUsage
+  };
+}
+function extractToolCalls4(content, toolTrackers, completedToolResults) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  const toolCalls = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object") {
+      continue;
+    }
+    const p = part;
+    if (p.type === "toolCall" && typeof p.name === "string") {
+      const id = typeof p.id === "string" ? p.id : void 0;
+      const tracker = id ? toolTrackers.get(id) : void 0;
+      const completed = id ? completedToolResults.get(id) : void 0;
+      toolCalls.push({
+        tool: p.name,
+        input: p.arguments,
+        id,
+        output: completed?.output,
+        durationMs: completed?.durationMs,
+        startTime: tracker?.startTime,
+        endTime: tracker?.startTime && completed?.durationMs !== void 0 ? new Date(new Date(tracker.startTime).getTime() + completed.durationMs).toISOString() : void 0
       });
-    });
-  });
+    }
+  }
+  return toolCalls;
 }
 
 // src/evaluation/providers/provider-registry.ts
@@ -9782,7 +9977,7 @@ var ProviderRegistry = class {
 };
 
 // src/evaluation/providers/targets.ts
-var import_node_path20 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 var import_zod3 = require("zod");
 var CliHealthcheckHttpInputSchema = import_zod3.z.object({
   url: import_zod3.z.string().min(1, "healthcheck URL is required"),
@@ -9879,11 +10074,11 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path20.default.isAbsolute(cwd)) {
-    cwd = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path21.default.isAbsolute(cwd)) {
+    cwd = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath));
+    cwd = import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath));
   }
   return {
     command,
@@ -9906,15 +10101,15 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   let cwd = resolveOptionalString(input.cwd, env, `${targetName} working directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path20.default.isAbsolute(cwd)) {
-    cwd = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path21.default.isAbsolute(cwd)) {
+    cwd = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), cwd);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -9922,7 +10117,7 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
     );
   }
   if (!cwd && !workspaceTemplate && evalFilePath) {
-    cwd = import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath));
+    cwd = import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath));
   }
   const timeoutSeconds = input.timeout_seconds ?? input.timeoutSeconds;
   const timeoutMs = timeoutSeconds !== void 0 ? Math.floor(timeoutSeconds * 1e3) : void 0;
@@ -10110,14 +10305,14 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         providerBatching,
         config: resolvePiCodingAgentConfig(parsed, env, evalFilePath)
       };
-    case "pi-agent-sdk":
+    case "pi-cli":
       return {
-        kind: "pi-agent-sdk",
+        kind: "pi-cli",
         name: parsed.name,
         graderTarget: parsed.grader_target ?? parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolvePiAgentSdkConfig(parsed, env)
+        config: resolvePiCliConfig(parsed, env, evalFilePath)
       };
     case "claude":
     case "claude-code":
@@ -10344,8 +10539,8 @@ function resolveCodexConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -10429,8 +10624,8 @@ function resolveCopilotSdkConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -10494,8 +10689,8 @@ function resolveCopilotCliConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -10534,23 +10729,17 @@ function normalizeCopilotLogFormat(value) {
   throw new Error("copilot log format must be 'summary' or 'json'");
 }
 function resolvePiCodingAgentConfig(target, env, evalFilePath) {
-  const executableSource = target.executable ?? target.command ?? target.binary;
   const subproviderSource = target.subprovider;
   const modelSource = target.model ?? target.pi_model ?? target.piModel;
   const apiKeySource = target.api_key ?? target.apiKey;
   const toolsSource = target.tools ?? target.pi_tools ?? target.piTools;
   const thinkingSource = target.thinking ?? target.pi_thinking ?? target.piThinking;
-  const argsSource = target.args ?? target.arguments;
   const cwdSource = target.cwd;
   const workspaceTemplateSource = target.workspace_template ?? target.workspaceTemplate;
   const timeoutSource = target.timeout_seconds ?? target.timeoutSeconds;
   const logDirSource = target.log_dir ?? target.logDir ?? target.log_directory ?? target.logDirectory;
   const logFormatSource = target.log_format ?? target.logFormat;
   const systemPromptSource = target.system_prompt ?? target.systemPrompt;
-  const executable = resolveOptionalString(executableSource, env, `${target.name} pi executable`, {
-    allowLiteral: true,
-    optionalEnv: true
-  }) ?? "pi";
   const subprovider = resolveOptionalString(
     subproviderSource,
     env,
@@ -10576,7 +10765,6 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  const args = resolveOptionalStringArray(argsSource, env, `${target.name} pi args`);
   const cwd = resolveOptionalString(cwdSource, env, `${target.name} pi cwd`, {
     allowLiteral: true,
     optionalEnv: true
@@ -10590,8 +10778,8 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -10606,13 +10794,11 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
   const logFormat = logFormatSource === "json" || logFormatSource === "summary" ? logFormatSource : void 0;
   const systemPrompt = typeof systemPromptSource === "string" && systemPromptSource.trim().length > 0 ? systemPromptSource.trim() : void 0;
   return {
-    executable,
     subprovider,
     model,
     apiKey,
     tools,
     thinking,
-    args,
     cwd,
     workspaceTemplate,
     timeoutMs,
@@ -10621,36 +10807,83 @@ function resolvePiCodingAgentConfig(target, env, evalFilePath) {
     systemPrompt
   };
 }
-function resolvePiAgentSdkConfig(target, env) {
+function resolvePiCliConfig(target, env, evalFilePath) {
+  const executableSource = target.executable ?? target.command ?? target.binary;
   const subproviderSource = target.subprovider;
   const modelSource = target.model ?? target.pi_model ?? target.piModel;
   const apiKeySource = target.api_key ?? target.apiKey;
+  const toolsSource = target.tools ?? target.pi_tools ?? target.piTools;
+  const thinkingSource = target.thinking ?? target.pi_thinking ?? target.piThinking;
+  const cwdSource = target.cwd;
+  const workspaceTemplateSource = target.workspace_template ?? target.workspaceTemplate;
   const timeoutSource = target.timeout_seconds ?? target.timeoutSeconds;
+  const logDirSource = target.log_dir ?? target.logDir ?? target.log_directory ?? target.logDirectory;
+  const logFormatSource = target.log_format ?? target.logFormat;
   const systemPromptSource = target.system_prompt ?? target.systemPrompt;
+  const executable = resolveOptionalString(executableSource, env, `${target.name} pi-cli executable`, {
+    allowLiteral: true,
+    optionalEnv: true
+  }) ?? "pi";
   const subprovider = resolveOptionalString(
     subproviderSource,
     env,
-    `${target.name} pi-agent-sdk subprovider`,
-    {
-      allowLiteral: true,
-      optionalEnv: true
-    }
+    `${target.name} pi-cli subprovider`,
+    { allowLiteral: true, optionalEnv: true }
   );
-  const model = resolveOptionalString(modelSource, env, `${target.name} pi-agent-sdk model`, {
+  const model = resolveOptionalString(modelSource, env, `${target.name} pi-cli model`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const apiKey = resolveOptionalString(apiKeySource, env, `${target.name} pi-agent-sdk api key`, {
+  const apiKey = resolveOptionalString(apiKeySource, env, `${target.name} pi-cli api key`, {
     allowLiteral: false,
     optionalEnv: true
   });
-  const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} pi-agent-sdk timeout`);
+  const tools = resolveOptionalString(toolsSource, env, `${target.name} pi-cli tools`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const thinking = resolveOptionalString(thinkingSource, env, `${target.name} pi-cli thinking`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const rawArgs = target.args ?? target.arguments;
+  const args = resolveOptionalStringArray(rawArgs, env, `${target.name} pi-cli args`);
+  const cwd = resolveOptionalString(cwdSource, env, `${target.name} pi-cli cwd`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  let workspaceTemplate = resolveOptionalString(
+    workspaceTemplateSource,
+    env,
+    `${target.name} pi-cli workspace template`,
+    { allowLiteral: true, optionalEnv: true }
+  );
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
+  }
+  if (cwd && workspaceTemplate) {
+    throw new Error(`${target.name}: 'cwd' and 'workspace_template' are mutually exclusive.`);
+  }
+  const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} pi-cli timeout`);
+  const logDir = resolveOptionalString(logDirSource, env, `${target.name} pi-cli log directory`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const logFormat = logFormatSource === "json" || logFormatSource === "summary" ? logFormatSource : void 0;
   const systemPrompt = typeof systemPromptSource === "string" && systemPromptSource.trim().length > 0 ? systemPromptSource.trim() : void 0;
   return {
+    executable,
     subprovider,
     model,
     apiKey,
+    tools,
+    thinking,
+    args,
+    cwd,
+    workspaceTemplate,
     timeoutMs,
+    logDir,
+    logFormat,
     systemPrompt
   };
 }
@@ -10679,8 +10912,8 @@ function resolveClaudeConfig(target, env, evalFilePath) {
       optionalEnv: true
     }
   );
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   if (cwd && workspaceTemplate) {
     throw new Error(
@@ -10738,8 +10971,8 @@ function resolveVSCodeConfig(target, env, insiders, evalFilePath) {
       optionalEnv: true
     }
   ) : void 0;
-  if (workspaceTemplate && evalFilePath && !import_node_path20.default.isAbsolute(workspaceTemplate)) {
-    workspaceTemplate = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), workspaceTemplate);
+  if (workspaceTemplate && evalFilePath && !import_node_path21.default.isAbsolute(workspaceTemplate)) {
+    workspaceTemplate = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), workspaceTemplate);
   }
   const executableSource = target.executable;
   const waitSource = target.wait;
@@ -10780,8 +11013,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path47 = firstError?.path.join(".") || "";
-    const prefix = path47 ? `${target.name} ${path47}: ` : `${target.name}: `;
+    const path48 = firstError?.path.join(".") || "";
+    const prefix = path48 ? `${target.name} ${path48}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -10802,11 +11035,11 @@ function resolveDiscoveredProviderConfig(target, providerKind, env, evalFilePath
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path20.default.isAbsolute(cwd)) {
-    cwd = import_node_path20.default.resolve(import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path21.default.isAbsolute(cwd)) {
+    cwd = import_node_path21.default.resolve(import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path20.default.dirname(import_node_path20.default.resolve(evalFilePath));
+    cwd = import_node_path21.default.dirname(import_node_path21.default.resolve(evalFilePath));
   }
   return {
     command,
@@ -10989,41 +11222,41 @@ function resolveOptionalNumberArray(source, description) {
 }
 
 // src/evaluation/providers/vscode-provider.ts
-var import_node_child_process6 = require("child_process");
-var import_promises23 = require("fs/promises");
-var import_node_path32 = __toESM(require("path"), 1);
+var import_node_child_process7 = require("child_process");
+var import_promises24 = require("fs/promises");
+var import_node_path33 = __toESM(require("path"), 1);
 var import_node_util3 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
-var import_promises21 = require("fs/promises");
-var import_node_path30 = __toESM(require("path"), 1);
+var import_promises22 = require("fs/promises");
+var import_node_path31 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
-var import_node_fs9 = require("fs");
-var import_promises17 = require("fs/promises");
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs10 = require("fs");
+var import_promises18 = require("fs/promises");
+var import_node_path22 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises17.access)(target, import_node_fs9.constants.F_OK);
+    await (0, import_promises18.access)(target, import_node_fs10.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(target) {
-  await (0, import_promises17.mkdir)(target, { recursive: true });
+  await (0, import_promises18.mkdir)(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await (0, import_promises17.readdir)(target, { withFileTypes: true });
+  const entries = await (0, import_promises18.readdir)(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: import_node_path21.default.join(target, entry.name),
+    absolutePath: import_node_path22.default.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
 async function removeIfExists(target) {
   try {
-    await (0, import_promises17.rm)(target, { force: true, recursive: false });
+    await (0, import_promises18.rm)(target, { force: true, recursive: false });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -11032,9 +11265,9 @@ async function removeIfExists(target) {
 }
 
 // src/evaluation/providers/vscode/utils/path.ts
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 function pathToFileUri2(filePath) {
-  const absolutePath = import_node_path22.default.isAbsolute(filePath) ? filePath : import_node_path22.default.resolve(filePath);
+  const absolutePath = import_node_path23.default.isAbsolute(filePath) ? filePath : import_node_path23.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -11043,7 +11276,7 @@ function pathToFileUri2(filePath) {
 }
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
-var import_node_path23 = __toESM(require("path"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/template.ts
 function renderTemplate2(content, variables) {
@@ -11135,8 +11368,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path23.default.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${import_node_path23.default.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path24.default.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${import_node_path24.default.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -11144,8 +11377,8 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 }
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
-var import_promises18 = require("fs/promises");
-var import_node_path24 = __toESM(require("path"), 1);
+var import_promises19 = require("fs/promises");
+var import_node_path25 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/time.ts
 function sleep2(ms) {
@@ -11183,7 +11416,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await (0, import_promises18.readFile)(responseFileFinal, { encoding: "utf8" });
+      const content = await (0, import_promises19.readFile)(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -11204,7 +11437,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) => import_node_path24.default.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => import_node_path25.default.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   const deadline = Date.now() + timeoutMs;
@@ -11213,7 +11446,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     while (pending.size > 0) {
       if (Date.now() >= deadline) {
         if (!silent) {
-          const remaining = [...pending].map((f) => import_node_path24.default.basename(f)).join(", ");
+          const remaining = [...pending].map((f) => import_node_path25.default.basename(f)).join(", ");
           console.error(
             `error: timed out after ${Math.round(timeoutMs / 1e3)}s waiting for batch responses. Still pending: ${remaining}`
           );
@@ -11240,7 +11473,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await (0, import_promises18.readFile)(file, { encoding: "utf8" });
+        const content = await (0, import_promises19.readFile)(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -11262,17 +11495,17 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 }
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var import_node_child_process5 = require("child_process");
-var import_promises19 = require("fs/promises");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_child_process6 = require("child_process");
+var import_promises20 = require("fs/promises");
+var import_node_path28 = __toESM(require("path"), 1);
 var import_node_util2 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_path27 = __toESM(require("path"), 1);
 
 // src/paths.ts
 var import_node_os4 = __toESM(require("os"), 1);
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 var logged = false;
 function getAgentvHome() {
   const envHome = process.env.AGENTV_HOME;
@@ -11283,19 +11516,19 @@ function getAgentvHome() {
     }
     return envHome;
   }
-  return import_node_path25.default.join(import_node_os4.default.homedir(), ".agentv");
+  return import_node_path26.default.join(import_node_os4.default.homedir(), ".agentv");
 }
 function getWorkspacesRoot() {
-  return import_node_path25.default.join(getAgentvHome(), "workspaces");
+  return import_node_path26.default.join(getAgentvHome(), "workspaces");
 }
 function getSubagentsRoot() {
-  return import_node_path25.default.join(getAgentvHome(), "subagents");
+  return import_node_path26.default.join(getAgentvHome(), "subagents");
 }
 function getTraceStateRoot() {
-  return import_node_path25.default.join(getAgentvHome(), "trace-state");
+  return import_node_path26.default.join(getAgentvHome(), "trace-state");
 }
 function getWorkspacePoolRoot() {
-  return import_node_path25.default.join(getAgentvHome(), "workspace-pool");
+  return import_node_path26.default.join(getAgentvHome(), "workspace-pool");
 }
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
@@ -11303,12 +11536,12 @@ var DEFAULT_LOCK_NAME = "subagent.lock";
 var DEFAULT_ALIVE_FILENAME = ".alive";
 function getDefaultSubagentRoot(vscodeCmd = "code") {
   const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
-  return import_node_path26.default.join(getSubagentsRoot(), folder);
+  return import_node_path27.default.join(getSubagentsRoot(), folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process5.exec);
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process6.exec);
 function shellQuote(cmd) {
   return cmd.includes(" ") ? `"${cmd}"` : cmd;
 }
@@ -11319,7 +11552,7 @@ model: Grok Code Fast 1 (copilot)
 function spawnVsCode(vscodeCmd, args, options) {
   const useShell = options?.shell ?? true;
   const command = useShell ? shellQuote(vscodeCmd) : vscodeCmd;
-  const child = (0, import_node_child_process5.spawn)(command, args, {
+  const child = (0, import_node_child_process6.spawn)(command, args, {
     windowsHide: true,
     shell: useShell,
     detached: false
@@ -11370,12 +11603,12 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     await raceSpawnError(child);
     return true;
   }
-  const aliveFile = import_node_path27.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = import_node_path28.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = import_node_path27.default.join(subagentDir, ".github", "agents");
-  await (0, import_promises19.mkdir)(githubAgentsDir, { recursive: true });
-  const wakeupDst = import_node_path27.default.join(githubAgentsDir, "wakeup.md");
-  await (0, import_promises19.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  const githubAgentsDir = import_node_path28.default.join(subagentDir, ".github", "agents");
+  await (0, import_promises20.mkdir)(githubAgentsDir, { recursive: true });
+  const wakeupDst = import_node_path28.default.join(githubAgentsDir, "wakeup.md");
+  await (0, import_promises20.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
   const workspaceChild = spawnVsCode(vscodeCmd, [workspacePath], {
     label: "open-workspace"
   });
@@ -11387,7 +11620,7 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${import_node_path27.default.basename(subagentDir)} folder`
+    `create a file named .alive in the ${import_node_path28.default.basename(subagentDir)} folder`
   ];
   const wakeupChild = spawnVsCode(vscodeCmd, chatArgs, { label: "send-wakeup-chat" });
   await raceSpawnError(wakeupChild);
@@ -11402,27 +11635,27 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
   return true;
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
-  const workspacePath = import_node_path27.default.join(subagentDir, `${import_node_path27.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path27.default.join(subagentDir, "messages");
-  await (0, import_promises19.mkdir)(messagesDir, { recursive: true });
-  const reqFile = import_node_path27.default.join(messagesDir, `${timestamp}_req.md`);
-  await (0, import_promises19.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
+  const workspacePath = import_node_path28.default.join(subagentDir, `${import_node_path28.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path28.default.join(subagentDir, "messages");
+  await (0, import_promises20.mkdir)(messagesDir, { recursive: true });
+  const reqFile = import_node_path28.default.join(messagesDir, `${timestamp}_req.md`);
+  await (0, import_promises20.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
   const reqUri = pathToFileUri2(reqFile);
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
   }
   chatArgs.push("-a", reqFile);
-  chatArgs.push(`Follow instructions in [${import_node_path27.default.basename(reqFile)}](${reqUri})`);
+  chatArgs.push(`Follow instructions in [${import_node_path28.default.basename(reqFile)}](${reqUri})`);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path27.default.basename(subagentDir),
+    import_node_path28.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path27.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path28.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -11430,9 +11663,9 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
   await raceSpawnError(child);
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
-  const workspacePath = import_node_path27.default.join(subagentDir, `${import_node_path27.default.basename(subagentDir)}.code-workspace`);
-  const messagesDir = import_node_path27.default.join(subagentDir, "messages");
-  await (0, import_promises19.mkdir)(messagesDir, { recursive: true });
+  const workspacePath = import_node_path28.default.join(subagentDir, `${import_node_path28.default.basename(subagentDir)}.code-workspace`);
+  const messagesDir = import_node_path28.default.join(subagentDir, "messages");
+  await (0, import_promises20.mkdir)(messagesDir, { recursive: true });
   const chatArgs = ["-r", "chat", "-m", chatId];
   for (const attachment of attachmentPaths) {
     chatArgs.push("-a", attachment);
@@ -11440,13 +11673,13 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
   chatArgs.push(chatInstruction);
   const workspaceReady = await ensureWorkspaceFocused(
     workspacePath,
-    import_node_path27.default.basename(subagentDir),
+    import_node_path28.default.basename(subagentDir),
     subagentDir,
     vscodeCmd
   );
   if (!workspaceReady) {
     throw new Error(
-      `VS Code workspace '${import_node_path27.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
+      `VS Code workspace '${import_node_path28.default.basename(subagentDir)}' failed to become ready within the timeout. Check that '${vscodeCmd}' can open workspaces.`
     );
   }
   await sleep2(500);
@@ -11455,11 +11688,11 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-var import_promises20 = require("fs/promises");
-var import_node_path29 = __toESM(require("path"), 1);
+var import_promises21 = require("fs/promises");
+var import_node_path30 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/workspace.ts
-var import_node_path28 = __toESM(require("path"), 1);
+var import_node_path29 = __toESM(require("path"), 1);
 var import_json5 = __toESM(require("json5"), 1);
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -11476,10 +11709,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (import_node_path28.default.isAbsolute(folderPath)) {
+    if (import_node_path29.default.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = import_node_path28.default.resolve(templateDir, folderPath);
+    const absolutePath = import_node_path29.default.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -11501,19 +11734,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = import_node_path28.default.isAbsolute(locationPath);
+          const isAbsolute = import_node_path29.default.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = import_node_path28.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = import_node_path29.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
               transformedMap[resolvedPath] = value;
             } else {
               const basePathEnd = locationPath.lastIndexOf("/", firstGlobIndex);
               const basePath = basePathEnd !== -1 ? locationPath.substring(0, basePathEnd) : ".";
               const patternPath = locationPath.substring(basePathEnd !== -1 ? basePathEnd : 0);
-              const resolvedPath = (import_node_path28.default.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (import_node_path29.default.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -11554,7 +11787,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 = import_node_path29.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = import_node_path30.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -11564,26 +11797,26 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = import_node_path29.default.resolve(workspaceTemplate);
+    const workspaceSrc = import_node_path30.default.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await (0, import_promises20.stat)(workspaceSrc);
+    const stats = await (0, import_promises21.stat)(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await (0, import_promises20.readFile)(workspaceSrc, "utf8");
+    const templateText = await (0, import_promises21.readFile)(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${import_node_path29.default.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = import_node_path29.default.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? import_node_path29.default.dirname(import_node_path29.default.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${import_node_path30.default.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = import_node_path30.default.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? import_node_path30.default.dirname(import_node_path30.default.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   let transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
   if (cwd) {
-    const absCwd = import_node_path29.default.resolve(cwd);
+    const absCwd = import_node_path30.default.resolve(cwd);
     const parsed = JSON.parse(transformedContent);
     const alreadyPresent = parsed.folders.some((f) => f.path === absCwd);
     if (!alreadyPresent) {
@@ -11591,36 +11824,36 @@ async function copyAgentConfig(subagentDir, workspaceTemplate, cwd) {
       transformedContent = JSON.stringify(parsed, null, 2);
     }
   }
-  await (0, import_promises20.writeFile)(workspaceDst, transformedContent, "utf8");
-  const messagesDir = import_node_path29.default.join(subagentDir, "messages");
-  await (0, import_promises20.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises21.writeFile)(workspaceDst, transformedContent, "utf8");
+  const messagesDir = import_node_path30.default.join(subagentDir, "messages");
+  await (0, import_promises21.mkdir)(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = import_node_path29.default.join(subagentDir, "messages");
+  const messagesDir = import_node_path30.default.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await (0, import_promises20.readdir)(messagesDir);
+    const files = await (0, import_promises21.readdir)(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = import_node_path29.default.join(messagesDir, file);
+        const target = import_node_path30.default.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = import_node_path29.default.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = import_node_path30.default.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await (0, import_promises20.readdir)(githubAgentsDir);
+    const agentFiles = await (0, import_promises21.readdir)(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path29.default.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path30.default.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = import_node_path29.default.join(subagentDir, DEFAULT_LOCK_NAME);
-  await (0, import_promises20.writeFile)(lockFile, "", { encoding: "utf8" });
+  const lockFile = import_node_path30.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  await (0, import_promises21.writeFile)(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = import_node_path29.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = import_node_path30.default.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun, cwd) {
@@ -11640,11 +11873,11 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = import_node_path29.default.join(subagentDir, ".github", "agents");
-    await (0, import_promises20.mkdir)(githubAgentsDir, { recursive: true });
-    const agentFile = import_node_path29.default.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = import_node_path30.default.join(subagentDir, ".github", "agents");
+    await (0, import_promises21.mkdir)(githubAgentsDir, { recursive: true });
+    const agentFile = import_node_path30.default.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await (0, import_promises20.copyFile)(promptFile, agentFile);
+      await (0, import_promises21.copyFile)(promptFile, agentFile);
     } catch (error) {
       console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
@@ -11661,11 +11894,11 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = import_node_path30.default.resolve(promptFile);
+  const resolvedPrompt = import_node_path31.default.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await (0, import_promises21.stat)(resolvedPrompt);
+  const promptStats = await (0, import_promises22.stat)(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -11677,7 +11910,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = import_node_path30.default.resolve(attachment);
+    const resolvedPath = import_node_path31.default.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -11719,7 +11952,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = import_node_path30.default.basename(subagentDir);
+    const subagentName = import_node_path31.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -11747,9 +11980,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path30.default.join(subagentDir, "messages");
-    const responseFileTmp = import_node_path30.default.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = import_node_path30.default.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = import_node_path31.default.join(subagentDir, "messages");
+    const responseFileTmp = import_node_path31.default.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = import_node_path31.default.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -11854,7 +12087,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = import_node_path30.default.basename(subagentDir);
+    subagentName = import_node_path31.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -11885,24 +12118,24 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path30.default.join(subagentDir, "messages");
+    const messagesDir = import_node_path31.default.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => import_node_path30.default.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => import_node_path31.default.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => import_node_path30.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => import_node_path31.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => import_node_path30.default.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => import_node_path31.default.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = import_node_path30.default.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = import_node_path31.default.join(messagesDir, `${timestamp}_orchestrator.md`);
     if (!dryRun) {
       await Promise.all(
         userQueries.map((query, index) => {
           const reqFile = requestFiles[index];
           const tmpFile = responseTmpFiles[index];
           const finalFile = responseFilesFinal[index];
-          return (0, import_promises21.writeFile)(
+          return (0, import_promises22.writeFile)(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -11914,7 +12147,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await (0, import_promises21.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await (0, import_promises22.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -11980,8 +12213,8 @@ async function dispatchBatchAgent(options) {
 }
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
-var import_promises22 = require("fs/promises");
-var import_node_path31 = __toESM(require("path"), 1);
+var import_promises23 = require("fs/promises");
+var import_node_path32 = __toESM(require("path"), 1);
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -12012,7 +12245,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = import_node_path31.default.resolve(targetRoot);
+  const targetPath = import_node_path32.default.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -12032,7 +12265,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = import_node_path31.default.join(entry.absolutePath, lockName);
+      const lockFile = import_node_path32.default.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -12049,10 +12282,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = import_node_path31.default.join(subagentDir, ".github", "agents");
-    const lockFile = import_node_path31.default.join(subagentDir, lockName);
-    const workspaceDst = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path31.default.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = import_node_path32.default.join(subagentDir, ".github", "agents");
+    const lockFile = import_node_path32.default.join(subagentDir, lockName);
+    const workspaceDst = import_node_path32.default.join(subagentDir, `${import_node_path32.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path32.default.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -12061,8 +12294,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await (0, import_promises22.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises22.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises23.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises23.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -12072,8 +12305,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await (0, import_promises22.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises22.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises23.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises23.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -12081,8 +12314,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await (0, import_promises22.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises22.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises23.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises23.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -12090,15 +12323,15 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = import_node_path31.default.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = import_node_path31.default.join(subagentDir, ".github", "agents");
-    const workspaceDst = import_node_path31.default.join(subagentDir, `${import_node_path31.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path31.default.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = import_node_path32.default.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = import_node_path32.default.join(subagentDir, ".github", "agents");
+    const workspaceDst = import_node_path32.default.join(subagentDir, `${import_node_path32.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path32.default.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await (0, import_promises22.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises22.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises23.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises23.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -12140,7 +12373,7 @@ var AGENTV_BATCH_REQUEST_TEMPLATE = `[[ ## task ## ]]
 `;
 
 // src/evaluation/providers/vscode-provider.ts
-var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process6.exec);
+var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process7.exec);
 var VSCodeProvider = class {
   id;
   kind;
@@ -12283,9 +12516,9 @@ var VSCodeProvider = class {
 async function locateVSCodeExecutable(candidate) {
   const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
   if (includesPathSeparator) {
-    const resolved = import_node_path32.default.isAbsolute(candidate) ? candidate : import_node_path32.default.resolve(candidate);
+    const resolved = import_node_path33.default.isAbsolute(candidate) ? candidate : import_node_path33.default.resolve(candidate);
     try {
-      await (0, import_promises23.access)(resolved, import_promises23.constants.F_OK);
+      await (0, import_promises24.access)(resolved, import_promises24.constants.F_OK);
       return resolved;
     } catch {
       throw new Error(
@@ -12298,7 +12531,7 @@ async function locateVSCodeExecutable(candidate) {
     const { stdout } = await execAsync3(`${locator} ${candidate}`);
     const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
     if (lines.length > 0 && lines[0]) {
-      await (0, import_promises23.access)(lines[0], import_promises23.constants.F_OK);
+      await (0, import_promises24.access)(lines[0], import_promises24.constants.F_OK);
       return lines[0];
     }
   } catch {
@@ -12312,7 +12545,7 @@ async function resolveWorkspaceTemplateFile(template) {
     return void 0;
   }
   try {
-    const stats = await (0, import_promises23.stat)(import_node_path32.default.resolve(template));
+    const stats = await (0, import_promises24.stat)(import_node_path33.default.resolve(template));
     return stats.isFile() ? template : void 0;
   } catch {
     return template;
@@ -12336,7 +12569,7 @@ function buildMandatoryPrereadBlock2(attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path32.default.basename(absolutePath);
+    const fileName = import_node_path33.default.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -12357,7 +12590,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path32.default.resolve(attachment);
+    const absolutePath = import_node_path33.default.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -12365,7 +12598,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = import_node_path32.default.isAbsolute(filePath) ? filePath : import_node_path32.default.resolve(filePath);
+  const absolutePath = import_node_path33.default.isAbsolute(filePath) ? filePath : import_node_path33.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -12378,7 +12611,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(import_node_path32.default.resolve(attachment));
+    deduped.add(import_node_path33.default.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -12387,7 +12620,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(import_node_path32.default.resolve(inputFile));
+      deduped.add(import_node_path33.default.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -12434,9 +12667,9 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 }
 
 // src/evaluation/providers/targets-file.ts
-var import_node_fs10 = require("fs");
-var import_promises24 = require("fs/promises");
-var import_node_path33 = __toESM(require("path"), 1);
+var import_node_fs11 = require("fs");
+var import_promises25 = require("fs/promises");
+var import_node_path34 = __toESM(require("path"), 1);
 var import_yaml6 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12466,18 +12699,18 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises24.access)(filePath, import_node_fs10.constants.F_OK);
+    await (0, import_promises25.access)(filePath, import_node_fs11.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = import_node_path33.default.resolve(filePath);
+  const absolutePath = import_node_path34.default.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await (0, import_promises24.readFile)(absolutePath, "utf8");
+  const raw = await (0, import_promises25.readFile)(absolutePath, "utf8");
   const parsed = (0, import_yaml6.parse)(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -12493,16 +12726,16 @@ function listTargetNames(definitions) {
 }
 
 // src/evaluation/providers/provider-discovery.ts
-var import_node_path34 = __toESM(require("path"), 1);
+var import_node_path35 = __toESM(require("path"), 1);
 var import_fast_glob2 = __toESM(require("fast-glob"), 1);
 async function discoverProviders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path34.default.resolve(baseDir);
-  const root = import_node_path34.default.parse(dir).root;
+  let dir = import_node_path35.default.resolve(baseDir);
+  const root = import_node_path35.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path34.default.join(dir, ".agentv", "providers"));
-    dir = import_node_path34.default.dirname(dir);
+    candidateDirs.push(import_node_path35.default.join(dir, ".agentv", "providers"));
+    dir = import_node_path35.default.dirname(dir);
   }
   let files = [];
   for (const providersDir of candidateDirs) {
@@ -12518,7 +12751,7 @@ async function discoverProviders(registry, baseDir) {
   }
   const discoveredKinds = [];
   for (const filePath of files) {
-    const basename = import_node_path34.default.basename(filePath);
+    const basename = import_node_path35.default.basename(filePath);
     const kindName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(kindName)) {
       continue;
@@ -12536,7 +12769,7 @@ async function discoverProviders(registry, baseDir) {
 // src/evaluation/providers/index.ts
 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-agent-sdk", (t) => new PiAgentSdkProvider(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("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")
   );
@@ -12625,9 +12858,9 @@ function negateScore(score) {
 }
 
 // src/evaluation/evaluators/code-evaluator.ts
-var import_promises25 = require("fs/promises");
+var import_promises26 = require("fs/promises");
 var import_node_os5 = require("os");
-var import_node_path35 = require("path");
+var import_node_path36 = require("path");
 
 // src/runtime/exec.ts
 function shellEscapePath(value) {
@@ -12727,15 +12960,15 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir17, readFile: readFile14, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
+  const { mkdir: mkdir18, readFile: readFile14, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
   const { tmpdir: tmpdir3 } = await import("os");
-  const path47 = await import("path");
-  const { randomUUID: randomUUID9 } = await import("crypto");
-  const dir = path47.join(tmpdir3(), `agentv-exec-${randomUUID9()}`);
-  await mkdir17(dir, { recursive: true });
-  const stdinPath = path47.join(dir, "stdin.txt");
-  const stdoutPath = path47.join(dir, "stdout.txt");
-  const stderrPath = path47.join(dir, "stderr.txt");
+  const path48 = await import("path");
+  const { randomUUID: randomUUID10 } = await import("crypto");
+  const dir = path48.join(tmpdir3(), `agentv-exec-${randomUUID10()}`);
+  await mkdir18(dir, { recursive: true });
+  const stdinPath = path48.join(dir, "stdin.txt");
+  const stdoutPath = path48.join(dir, "stdout.txt");
+  const stderrPath = path48.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("child_process");
@@ -12774,12 +13007,12 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
 }
 
 // src/runtime/target-proxy.ts
-var import_node_crypto8 = require("crypto");
+var import_node_crypto9 = require("crypto");
 var import_node_http = require("http");
 var DEFAULT_MAX_CALLS = 50;
 async function createTargetProxy(options) {
   const { defaultProvider, targetResolver, availableTargets, maxCalls } = options;
-  const token = (0, import_node_crypto8.randomBytes)(32).toString("hex");
+  const token = (0, import_node_crypto9.randomBytes)(32).toString("hex");
   let callCount = 0;
   let isShutdown = false;
   let totalInputTokens = 0;
@@ -13071,9 +13304,9 @@ var CodeEvaluator = class {
     if (outputForPayload) {
       const serialized = JSON.stringify(outputForPayload);
       if (serialized.length > FILE_BACKED_OUTPUT_THRESHOLD) {
-        const tmpDir = await (0, import_promises25.mkdtemp)((0, import_node_path35.join)((0, import_node_os5.tmpdir)(), "agentv-judge-"));
-        outputPath = (0, import_node_path35.join)(tmpDir, "output.json");
-        await (0, import_promises25.writeFile)(outputPath, serialized);
+        const tmpDir = await (0, import_promises26.mkdtemp)((0, import_node_path36.join)((0, import_node_os5.tmpdir)(), "agentv-judge-"));
+        outputPath = (0, import_node_path36.join)(tmpDir, "output.json");
+        await (0, import_promises26.writeFile)(outputPath, serialized);
         outputForPayload = null;
       }
     }
@@ -13182,7 +13415,7 @@ var CodeEvaluator = class {
         await proxyShutdown();
       }
       if (outputPath) {
-        await (0, import_promises25.rm)((0, import_node_path35.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
+        await (0, import_promises26.rm)((0, import_node_path36.dirname)(outputPath), { recursive: true, force: true }).catch(() => {
         });
       }
     }
@@ -13218,7 +13451,7 @@ var AGENT_PROVIDER_KINDS = [
   "copilot-sdk",
   "copilot-cli",
   "pi-coding-agent",
-  "pi-agent-sdk",
+  "pi-cli",
   "claude",
   "claude-cli",
   "claude-sdk",
@@ -13245,8 +13478,8 @@ function isAgentProvider(provider) {
 }
 
 // src/evaluation/evaluators/llm-grader.ts
-var import_promises26 = __toESM(require("fs/promises"), 1);
-var import_node_path36 = __toESM(require("path"), 1);
+var import_promises27 = __toESM(require("fs/promises"), 1);
+var import_node_path37 = __toESM(require("path"), 1);
 var import_ai2 = require("ai");
 var import_zod4 = require("zod");
 var DEFAULT_MAX_STEPS = 10;
@@ -13435,7 +13668,7 @@ ${context2.fileChanges}`;
   async evaluateWithRubrics(context2, graderProvider, rubrics) {
     if (!rubrics || rubrics.length === 0) {
       throw new Error(
-        `No rubrics found for evaluator "${context2.evaluator?.name ?? "llm-grader"}". Run "agentv generate rubrics" first.`
+        `No rubrics found for evaluator "${context2.evaluator?.name ?? "llm-grader"}". Add rubric criteria under assertions or use the agentv-eval-writer skill for authoring help.`
       );
     }
     const hasScoreRanges = rubrics.some((r) => r.score_ranges && r.score_ranges.length > 0);
@@ -14101,8 +14334,8 @@ function calculateScoreRangeResult(result, rubrics) {
   };
 }
 function resolveSandboxed(basePath, relativePath) {
-  const resolved = import_node_path36.default.resolve(basePath, relativePath);
-  if (!resolved.startsWith(basePath + import_node_path36.default.sep) && resolved !== basePath) {
+  const resolved = import_node_path37.default.resolve(basePath, relativePath);
+  if (!resolved.startsWith(basePath + import_node_path37.default.sep) && resolved !== basePath) {
     throw new Error(`Path '${relativePath}' is outside the workspace`);
   }
   return resolved;
@@ -14117,7 +14350,7 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const entries = await import_promises26.default.readdir(resolved, { withFileTypes: true });
+          const entries = await import_promises27.default.readdir(resolved, { withFileTypes: true });
           return entries.map((e) => ({
             name: e.name,
             type: e.isDirectory() ? "directory" : "file"
@@ -14135,12 +14368,12 @@ function createFilesystemTools(workspacePath) {
       execute: async (input) => {
         try {
           const resolved = resolveSandboxed(workspacePath, input.path);
-          const stat8 = await import_promises26.default.stat(resolved);
+          const stat8 = await import_promises27.default.stat(resolved);
           if (stat8.isDirectory()) {
             return { error: `'${input.path}' is a directory, not a file` };
           }
           const buffer = Buffer.alloc(Math.min(stat8.size, MAX_FILE_SIZE));
-          const fd = await import_promises26.default.open(resolved, "r");
+          const fd = await import_promises27.default.open(resolved, "r");
           try {
             await fd.read(buffer, 0, buffer.length, 0);
           } finally {
@@ -14185,30 +14418,30 @@ async function searchDirectory(dirPath, workspacePath, regex, matches) {
   if (matches.length >= MAX_SEARCH_MATCHES) return;
   let entries;
   try {
-    entries = await import_promises26.default.readdir(dirPath, { withFileTypes: true });
+    entries = await import_promises27.default.readdir(dirPath, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (matches.length >= MAX_SEARCH_MATCHES) return;
     if (SEARCH_SKIP_DIRS.has(entry.name)) continue;
-    const fullPath = import_node_path36.default.join(dirPath, entry.name);
+    const fullPath = import_node_path37.default.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       await searchDirectory(fullPath, workspacePath, regex, matches);
     } else if (entry.isFile()) {
-      const ext = import_node_path36.default.extname(entry.name).toLowerCase();
+      const ext = import_node_path37.default.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) continue;
       try {
-        const stat8 = await import_promises26.default.stat(fullPath);
+        const stat8 = await import_promises27.default.stat(fullPath);
         if (stat8.size > MAX_FILE_SIZE) continue;
-        const content = await import_promises26.default.readFile(fullPath, "utf-8");
+        const content = await import_promises27.default.readFile(fullPath, "utf-8");
         const lines = content.split("\n");
         for (let i = 0; i < lines.length; i++) {
           if (matches.length >= MAX_SEARCH_MATCHES) return;
           regex.lastIndex = 0;
           if (regex.test(lines[i])) {
             matches.push({
-              file: import_node_path36.default.relative(workspacePath, fullPath),
+              file: import_node_path37.default.relative(workspacePath, fullPath),
               line: i + 1,
               text: lines[i].substring(0, 200)
             });
@@ -14843,115 +15076,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path47, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path47);
-    const expectedValue = resolvePath(expectedData, path47);
+    const { path: path48, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path48);
+    const expectedValue = resolvePath(expectedData, path48);
     if (expectedValue === void 0) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path47}: no expected value`
+        message: `${path48}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path47,
+          path: path48,
           score: 0,
           weight,
           hit: false,
-          message: `${path47} (required, missing)`
+          message: `${path48} (required, missing)`
         };
       }
       return {
-        path: path47,
+        path: path48,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path47}: optional field missing`
+        message: `${path48}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path47, candidateValue, expectedValue, weight);
+        return this.compareExact(path48, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path47,
+          path48,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path47, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path48, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path47,
+          path: path48,
           score: 0,
           weight,
           hit: false,
-          message: `${path47}: unknown match type "${match}"`
+          message: `${path48}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path47, candidateValue, expectedValue, weight) {
+  compareExact(path48, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         weight,
         hit: true,
-        message: path47
+        message: path48
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path48} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path47,
+      path: path48,
       score: 0,
       weight,
       hit: false,
-      message: `${path47} (value mismatch)`
+      message: `${path48} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path47, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path48, 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: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (non-numeric value)`
+        message: `${path48} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (invalid numeric value)`
+        message: `${path48} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -14964,61 +15197,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         weight,
         hit: true,
-        message: `${path47} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path48} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path47,
+      path: path48,
       score: 0,
       weight,
       hit: false,
-      message: `${path47} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path48} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path47, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path48, 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: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (unparseable candidate date)`
+        message: `${path48} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path47,
+        path: path48,
         score: 0,
         weight,
         hit: false,
-        message: `${path47} (unparseable expected date)`
+        message: `${path48} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path47,
+        path: path48,
         score: 1,
         weight,
         hit: true,
-        message: path47
+        message: path48
       };
     }
     return {
-      path: path47,
+      path: path48,
       score: 0,
       weight,
       hit: false,
-      message: `${path47} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path48} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -15051,11 +15284,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path47) {
-  if (!path47 || !obj) {
+function resolvePath(obj, path48) {
+  if (!path48 || !obj) {
     return void 0;
   }
-  const parts = path47.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path48.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -15221,9 +15454,7 @@ var PROVIDER_TOOL_SEMANTICS = {
   "claude-sdk": CLAUDE_MATCHER,
   codex: CODEX_MATCHER,
   "pi-coding-agent": PI_CODING_AGENT_MATCHER,
-  // pi-agent-sdk has no tools, so skill detection is a no-op. Kept for completeness.
-  // TODO: consider removing pi-agent-sdk provider entirely.
-  "pi-agent-sdk": PI_CODING_AGENT_MATCHER,
+  "pi-cli": PI_CODING_AGENT_MATCHER,
   "copilot-cli": COPILOT_MATCHER,
   "copilot-sdk": COPILOT_MATCHER,
   vscode: COPILOT_MATCHER,
@@ -15538,8 +15769,8 @@ var TokenUsageEvaluator = class {
 };
 
 // src/evaluation/evaluators/tool-trajectory.ts
-function getNestedValue(obj, path47) {
-  const parts = path47.split(".");
+function getNestedValue(obj, path48) {
+  const parts = path48.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") {
@@ -16159,9 +16390,9 @@ function runEqualsAssertion(output, value) {
 }
 
 // src/evaluation/orchestrator.ts
-var import_node_crypto10 = require("crypto");
-var import_promises30 = require("fs/promises");
-var import_node_path45 = __toESM(require("path"), 1);
+var import_node_crypto11 = require("crypto");
+var import_promises31 = require("fs/promises");
+var import_node_path46 = __toESM(require("path"), 1);
 var import_micromatch3 = __toESM(require("micromatch"), 1);
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -16375,7 +16606,7 @@ var InlineAssertEvaluator = class {
 };
 
 // src/evaluation/evaluators/prompt-resolution.ts
-var import_node_path37 = __toESM(require("path"), 1);
+var import_node_path38 = __toESM(require("path"), 1);
 async function resolveCustomPrompt(promptConfig, context2, timeoutMs) {
   if (promptConfig.resolvedPromptScript && promptConfig.resolvedPromptScript.length > 0) {
     if (!context2) {
@@ -16421,7 +16652,7 @@ async function executePromptTemplate(script, context2, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = import_node_path37.default.dirname(scriptPath);
+  const cwd = import_node_path38.default.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -16693,16 +16924,16 @@ function createBuiltinRegistry() {
 }
 
 // src/evaluation/registry/assertion-discovery.ts
-var import_node_path38 = __toESM(require("path"), 1);
+var import_node_path39 = __toESM(require("path"), 1);
 var import_fast_glob3 = __toESM(require("fast-glob"), 1);
 async function discoverAssertions(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path38.default.resolve(baseDir);
-  const root = import_node_path38.default.parse(dir).root;
+  let dir = import_node_path39.default.resolve(baseDir);
+  const root = import_node_path39.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path38.default.join(dir, ".agentv", "assertions"));
-    dir = import_node_path38.default.dirname(dir);
+    candidateDirs.push(import_node_path39.default.join(dir, ".agentv", "assertions"));
+    dir = import_node_path39.default.dirname(dir);
   }
   let files = [];
   for (const assertionsDir of candidateDirs) {
@@ -16718,7 +16949,7 @@ async function discoverAssertions(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path38.default.basename(filePath);
+    const basename = import_node_path39.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -16736,17 +16967,17 @@ async function discoverAssertions(registry, baseDir) {
 }
 
 // src/evaluation/registry/grader-discovery.ts
-var import_node_path39 = __toESM(require("path"), 1);
+var import_node_path40 = __toESM(require("path"), 1);
 var import_fast_glob4 = __toESM(require("fast-glob"), 1);
 async function discoverGraders(registry, baseDir) {
   const patterns = ["*.ts", "*.js", "*.mts", "*.mjs"];
   const candidateDirs = [];
-  let dir = import_node_path39.default.resolve(baseDir);
-  const root = import_node_path39.default.parse(dir).root;
+  let dir = import_node_path40.default.resolve(baseDir);
+  const root = import_node_path40.default.parse(dir).root;
   while (dir !== root) {
-    candidateDirs.push(import_node_path39.default.join(dir, ".agentv", "graders"));
-    candidateDirs.push(import_node_path39.default.join(dir, ".agentv", "judges"));
-    dir = import_node_path39.default.dirname(dir);
+    candidateDirs.push(import_node_path40.default.join(dir, ".agentv", "graders"));
+    candidateDirs.push(import_node_path40.default.join(dir, ".agentv", "judges"));
+    dir = import_node_path40.default.dirname(dir);
   }
   let files = [];
   for (const gradersDir of candidateDirs) {
@@ -16762,7 +16993,7 @@ async function discoverGraders(registry, baseDir) {
   }
   const discoveredTypes = [];
   for (const filePath of files) {
-    const basename = import_node_path39.default.basename(filePath);
+    const basename = import_node_path40.default.basename(filePath);
     const typeName = basename.replace(/\.(ts|js|mts|mjs)$/, "");
     if (registry.has(typeName)) {
       continue;
@@ -16920,11 +17151,11 @@ function getTCritical(df) {
 }
 
 // src/evaluation/workspace/file-changes.ts
-var import_node_child_process7 = require("child_process");
-var import_node_fs11 = require("fs");
-var import_node_path40 = __toESM(require("path"), 1);
+var import_node_child_process8 = require("child_process");
+var import_node_fs12 = require("fs");
+var import_node_path41 = __toESM(require("path"), 1);
 var import_node_util4 = require("util");
-var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process7.exec);
+var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process8.exec);
 function gitExecOpts(workspacePath) {
   const { GIT_DIR: _, GIT_WORK_TREE: __, ...env } = process.env;
   return { cwd: workspacePath, env };
@@ -16950,16 +17181,16 @@ async function captureFileChanges(workspacePath, baselineCommit) {
 async function stageNestedRepoChanges(workspacePath) {
   let entries;
   try {
-    entries = (0, import_node_fs11.readdirSync)(workspacePath);
+    entries = (0, import_node_fs12.readdirSync)(workspacePath);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry === ".git" || entry === "node_modules") continue;
-    const childPath = import_node_path40.default.join(workspacePath, entry);
+    const childPath = import_node_path41.default.join(workspacePath, entry);
     try {
-      if (!(0, import_node_fs11.statSync)(childPath).isDirectory()) continue;
-      if (!(0, import_node_fs11.statSync)(import_node_path40.default.join(childPath, ".git")).isDirectory()) continue;
+      if (!(0, import_node_fs12.statSync)(childPath).isDirectory()) continue;
+      if (!(0, import_node_fs12.statSync)(import_node_path41.default.join(childPath, ".git")).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -16969,8 +17200,8 @@ async function stageNestedRepoChanges(workspacePath) {
 }
 
 // src/evaluation/workspace/manager.ts
-var import_promises27 = require("fs/promises");
-var import_node_path41 = __toESM(require("path"), 1);
+var import_promises28 = require("fs/promises");
+var import_node_path42 = __toESM(require("path"), 1);
 var TemplateNotFoundError = class extends Error {
   constructor(templatePath) {
     super(`Workspace template not found: ${templatePath}`);
@@ -16992,7 +17223,7 @@ var WorkspaceCreationError = class extends Error {
 };
 async function isDirectory(filePath) {
   try {
-    const stats = await (0, import_promises27.stat)(filePath);
+    const stats = await (0, import_promises28.stat)(filePath);
     return stats.isDirectory();
   } catch {
     return false;
@@ -17000,26 +17231,26 @@ async function isDirectory(filePath) {
 }
 function getWorkspacePath(evalRunId, caseId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  return import_node_path41.default.join(root, evalRunId, caseId);
+  return import_node_path42.default.join(root, evalRunId, caseId);
 }
 async function copyDirectoryRecursive(src, dest) {
-  await (0, import_promises27.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises27.readdir)(src, { withFileTypes: true });
+  await (0, import_promises28.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises28.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_node_path41.default.join(src, entry.name);
-    const destPath = import_node_path41.default.join(dest, entry.name);
+    const srcPath = import_node_path42.default.join(src, entry.name);
+    const destPath = import_node_path42.default.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
     if (entry.isDirectory()) {
       await copyDirectoryRecursive(srcPath, destPath);
     } else {
-      await (0, import_promises27.cp)(srcPath, destPath, { preserveTimestamps: true });
+      await (0, import_promises28.cp)(srcPath, destPath, { preserveTimestamps: true });
     }
   }
 }
 async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoot) {
-  const resolvedTemplatePath = import_node_path41.default.resolve(templatePath);
+  const resolvedTemplatePath = import_node_path42.default.resolve(templatePath);
   if (!await fileExists2(resolvedTemplatePath)) {
     throw new TemplateNotFoundError(resolvedTemplatePath);
   }
@@ -17029,7 +17260,7 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
   const workspacePath = getWorkspacePath(evalRunId, caseId, workspaceRoot);
   try {
     if (await fileExists2(workspacePath)) {
-      await (0, import_promises27.rm)(workspacePath, { recursive: true, force: true });
+      await (0, import_promises28.rm)(workspacePath, { recursive: true, force: true });
     }
     await copyDirectoryRecursive(resolvedTemplatePath, workspacePath);
     return workspacePath;
@@ -17063,25 +17294,25 @@ async function createTempWorkspace(templatePath, evalRunId, caseId, workspaceRoo
 }
 async function cleanupWorkspace(workspacePath) {
   if (await fileExists2(workspacePath)) {
-    await (0, import_promises27.rm)(workspacePath, { recursive: true, force: true });
+    await (0, import_promises28.rm)(workspacePath, { recursive: true, force: true });
   }
 }
 async function cleanupEvalWorkspaces(evalRunId, workspaceRoot) {
   const root = workspaceRoot ?? getWorkspacesRoot();
-  const evalDir = import_node_path41.default.join(root, evalRunId);
+  const evalDir = import_node_path42.default.join(root, evalRunId);
   if (await fileExists2(evalDir)) {
-    await (0, import_promises27.rm)(evalDir, { recursive: true, force: true });
+    await (0, import_promises28.rm)(evalDir, { recursive: true, force: true });
   }
 }
 
 // src/evaluation/workspace/pool-manager.ts
-var import_node_child_process8 = require("child_process");
-var import_node_crypto9 = require("crypto");
-var import_node_fs12 = require("fs");
-var import_promises28 = require("fs/promises");
-var import_node_path42 = __toESM(require("path"), 1);
+var import_node_child_process9 = require("child_process");
+var import_node_crypto10 = require("crypto");
+var import_node_fs13 = require("fs");
+var import_promises29 = require("fs/promises");
+var import_node_path43 = __toESM(require("path"), 1);
 var import_node_util5 = require("util");
-var execFileAsync = (0, import_node_util5.promisify)(import_node_child_process8.execFile);
+var execFileAsync = (0, import_node_util5.promisify)(import_node_child_process9.execFile);
 function gitEnv() {
   const env = { ...process.env };
   for (const key of Object.keys(env)) {
@@ -17127,14 +17358,14 @@ function computeWorkspaceFingerprint(repos) {
   const canonical = {
     repos: [...repos].sort((a, b) => a.path.localeCompare(b.path)).map(normalizeRepoForFingerprint)
   };
-  return (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
+  return (0, import_node_crypto10.createHash)("sha256").update(JSON.stringify(canonical)).digest("hex");
 }
 async function copyDirectoryRecursive2(src, dest, skipDirs) {
-  await (0, import_promises28.mkdir)(dest, { recursive: true });
-  const entries = await (0, import_promises28.readdir)(src, { withFileTypes: true });
+  await (0, import_promises29.mkdir)(dest, { recursive: true });
+  const entries = await (0, import_promises29.readdir)(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = import_node_path42.default.join(src, entry.name);
-    const destPath = import_node_path42.default.join(dest, entry.name);
+    const srcPath = import_node_path43.default.join(src, entry.name);
+    const destPath = import_node_path43.default.join(dest, entry.name);
     if (entry.name === ".git") {
       continue;
     }
@@ -17144,7 +17375,7 @@ async function copyDirectoryRecursive2(src, dest, skipDirs) {
       }
       await copyDirectoryRecursive2(srcPath, destPath, skipDirs);
     } else {
-      await (0, import_promises28.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
+      await (0, import_promises29.cp)(srcPath, destPath, { preserveTimestamps: true, force: true });
     }
   }
 }
@@ -17167,8 +17398,8 @@ var WorkspacePoolManager = class {
   async acquireWorkspace(options) {
     const { templatePath, repos, maxSlots, repoManager, poolReset } = options;
     const fingerprint = computeWorkspaceFingerprint(repos);
-    const poolDir = import_node_path42.default.join(this.poolRoot, fingerprint);
-    await (0, import_promises28.mkdir)(poolDir, { recursive: true });
+    const poolDir = import_node_path43.default.join(this.poolRoot, fingerprint);
+    await (0, import_promises29.mkdir)(poolDir, { recursive: true });
     const drifted = await this.checkDrift(poolDir, fingerprint);
     if (drifted) {
       console.warn(
@@ -17177,13 +17408,13 @@ var WorkspacePoolManager = class {
       await this.removeAllSlots(poolDir);
     }
     for (let i = 0; i < maxSlots; i++) {
-      const slotPath = import_node_path42.default.join(poolDir, `slot-${i}`);
+      const slotPath = import_node_path43.default.join(poolDir, `slot-${i}`);
       const lockPath = `${slotPath}.lock`;
       const locked = await this.tryLock(lockPath);
       if (!locked) {
         continue;
       }
-      const slotExists = (0, import_node_fs12.existsSync)(slotPath);
+      const slotExists = (0, import_node_fs13.existsSync)(slotPath);
       if (slotExists) {
         await this.resetSlot(slotPath, templatePath, repos, poolReset);
         return {
@@ -17195,7 +17426,7 @@ var WorkspacePoolManager = class {
           poolDir
         };
       }
-      await (0, import_promises28.mkdir)(slotPath, { recursive: true });
+      await (0, import_promises29.mkdir)(slotPath, { recursive: true });
       if (templatePath) {
         await copyDirectoryRecursive2(templatePath, slotPath);
       }
@@ -17219,7 +17450,7 @@ var WorkspacePoolManager = class {
   /** Remove lock file to release a slot. */
   async releaseSlot(slot) {
     try {
-      await (0, import_promises28.unlink)(slot.lockPath);
+      await (0, import_promises29.unlink)(slot.lockPath);
     } catch {
     }
   }
@@ -17232,21 +17463,21 @@ var WorkspacePoolManager = class {
   async tryLock(lockPath) {
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
-        await (0, import_promises28.writeFile)(lockPath, String(process.pid), { flag: "wx" });
+        await (0, import_promises29.writeFile)(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code !== "EEXIST") {
           throw err;
         }
         try {
-          const pidStr = await (0, import_promises28.readFile)(lockPath, "utf-8");
+          const pidStr = await (0, import_promises29.readFile)(lockPath, "utf-8");
           const pid = Number.parseInt(pidStr.trim(), 10);
           if (!Number.isNaN(pid)) {
             try {
               process.kill(pid, 0);
               return false;
             } catch {
-              await (0, import_promises28.unlink)(lockPath).catch(() => {
+              await (0, import_promises29.unlink)(lockPath).catch(() => {
               });
               continue;
             }
@@ -17264,9 +17495,9 @@ var WorkspacePoolManager = class {
    * Returns false (no drift) if metadata.json doesn't exist (first use).
    */
   async checkDrift(poolDir, fingerprint) {
-    const metadataPath = import_node_path42.default.join(poolDir, "metadata.json");
+    const metadataPath = import_node_path43.default.join(poolDir, "metadata.json");
     try {
-      const raw = await (0, import_promises28.readFile)(metadataPath, "utf-8");
+      const raw = await (0, import_promises29.readFile)(metadataPath, "utf-8");
       const metadata = JSON.parse(raw);
       return metadata.fingerprint !== fingerprint;
     } catch {
@@ -17281,17 +17512,17 @@ var WorkspacePoolManager = class {
       repos,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    await (0, import_promises28.writeFile)(import_node_path42.default.join(poolDir, "metadata.json"), JSON.stringify(metadata, null, 2));
+    await (0, import_promises29.writeFile)(import_node_path43.default.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 (0, import_promises28.readdir)(poolDir);
+    const entries = await (0, import_promises29.readdir)(poolDir);
     for (const entry of entries) {
       if (entry.startsWith("slot-") && !entry.endsWith(".lock")) {
-        const lockPath = import_node_path42.default.join(poolDir, `${entry}.lock`);
-        if ((0, import_node_fs12.existsSync)(lockPath)) {
+        const lockPath = import_node_path43.default.join(poolDir, `${entry}.lock`);
+        if ((0, import_node_fs13.existsSync)(lockPath)) {
           try {
-            const pidStr = await (0, import_promises28.readFile)(lockPath, "utf-8");
+            const pidStr = await (0, import_promises29.readFile)(lockPath, "utf-8");
             const pid = Number.parseInt(pidStr.trim(), 10);
             if (!Number.isNaN(pid)) {
               try {
@@ -17304,12 +17535,12 @@ var WorkspacePoolManager = class {
           } catch {
           }
         }
-        await (0, import_promises28.rm)(import_node_path42.default.join(poolDir, entry), { recursive: true, force: true });
-        await (0, import_promises28.rm)(lockPath, { force: true }).catch(() => {
+        await (0, import_promises29.rm)(import_node_path43.default.join(poolDir, entry), { recursive: true, force: true });
+        await (0, import_promises29.rm)(lockPath, { force: true }).catch(() => {
         });
       }
     }
-    await (0, import_promises28.rm)(import_node_path42.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
+    await (0, import_promises29.rm)(import_node_path43.default.join(poolDir, "metadata.json"), { force: true }).catch(() => {
     });
   }
   /**
@@ -17319,8 +17550,8 @@ var WorkspacePoolManager = class {
    */
   async resetSlot(slotPath, templatePath, repos, poolReset = "fast") {
     for (const repo of repos) {
-      const repoDir = import_node_path42.default.join(slotPath, repo.path);
-      if (!(0, import_node_fs12.existsSync)(repoDir)) {
+      const repoDir = import_node_path43.default.join(slotPath, repo.path);
+      if (!(0, import_node_fs13.existsSync)(repoDir)) {
         continue;
       }
       if (poolReset === "none") {
@@ -17344,11 +17575,11 @@ var WorkspacePoolManager = class {
 };
 
 // src/evaluation/workspace/repo-manager.ts
-var import_node_child_process9 = require("child_process");
-var import_node_fs13 = require("fs");
-var import_node_path43 = __toESM(require("path"), 1);
+var import_node_child_process10 = require("child_process");
+var import_node_fs14 = require("fs");
+var import_node_path44 = __toESM(require("path"), 1);
 var import_node_util6 = require("util");
-var execFileAsync2 = (0, import_node_util6.promisify)(import_node_child_process9.execFile);
+var execFileAsync2 = (0, import_node_util6.promisify)(import_node_child_process10.execFile);
 var DEFAULT_TIMEOUT_MS2 = 3e5;
 function gitEnv2() {
   const env = { ...process.env };
@@ -17397,7 +17628,7 @@ var RepoManager = class {
           resolvedSourcePath: sourcePath ?? "",
           reason: "empty_path"
         });
-      } else if (!(0, import_node_fs13.existsSync)(sourcePath)) {
+      } else if (!(0, import_node_fs14.existsSync)(sourcePath)) {
         errors.push({
           repoPath: repo.path,
           resolvedSourcePath: sourcePath,
@@ -17446,7 +17677,7 @@ ${lines.join("\n")}`;
    * Handles checkout, ref resolution, ancestor walking, shallow clone, sparse checkout.
    */
   async materialize(repo, workspacePath) {
-    const targetDir = import_node_path43.default.join(workspacePath, repo.path);
+    const targetDir = import_node_path44.default.join(workspacePath, repo.path);
     const sourceUrl = getSourceUrl(repo.source);
     const startedAt = Date.now();
     if (this.verbose) {
@@ -17537,7 +17768,7 @@ ${lines.join("\n")}`;
   async reset(repos, workspacePath, reset) {
     const cleanFlag = reset === "strict" ? "-fdx" : "-fd";
     for (const repo of repos) {
-      const targetDir = import_node_path43.default.join(workspacePath, repo.path);
+      const targetDir = import_node_path44.default.join(workspacePath, repo.path);
       await this.runGit(["reset", "--hard", "HEAD"], { cwd: targetDir });
       await this.runGit(["clean", cleanFlag], { cwd: targetDir });
     }
@@ -17545,36 +17776,36 @@ ${lines.join("\n")}`;
 };
 
 // src/evaluation/workspace/resolve.ts
-var import_promises29 = require("fs/promises");
-var import_node_path44 = __toESM(require("path"), 1);
+var import_promises30 = require("fs/promises");
+var import_node_path45 = __toESM(require("path"), 1);
 async function resolveWorkspaceTemplate(templatePath) {
   if (!templatePath) {
     return void 0;
   }
-  const resolved = import_node_path44.default.resolve(templatePath);
-  const stats = await (0, import_promises29.stat)(resolved);
+  const resolved = import_node_path45.default.resolve(templatePath);
+  const stats = await (0, import_promises30.stat)(resolved);
   if (stats.isFile()) {
     return {
-      dir: import_node_path44.default.dirname(resolved),
+      dir: import_node_path45.default.dirname(resolved),
       workspaceFile: resolved
     };
   }
   if (!stats.isDirectory()) {
     throw new Error(`workspace template is neither a file nor a directory: ${resolved}`);
   }
-  const entries = await (0, import_promises29.readdir)(resolved);
+  const entries = await (0, import_promises30.readdir)(resolved);
   const workspaceFiles = entries.filter((e) => e.endsWith(".code-workspace"));
   if (workspaceFiles.length === 1) {
     return {
       dir: resolved,
-      workspaceFile: import_node_path44.default.join(resolved, workspaceFiles[0])
+      workspaceFile: import_node_path45.default.join(resolved, workspaceFiles[0])
     };
   }
   if (workspaceFiles.length > 1) {
     const conventionFile = workspaceFiles.find((f) => f === "template.code-workspace");
     return {
       dir: resolved,
-      workspaceFile: conventionFile ? import_node_path44.default.join(resolved, conventionFile) : void 0
+      workspaceFile: conventionFile ? import_node_path45.default.join(resolved, conventionFile) : void 0
     };
   }
   return { dir: resolved };
@@ -17711,7 +17942,7 @@ async function runEvaluation(options) {
     );
     useCache = false;
   }
-  const evalRunId = (0, import_node_crypto10.randomUUID)();
+  const evalRunId = (0, import_node_crypto11.randomUUID)();
   const evalCases = preloadedEvalCases ?? await loadTests(evalFilePath, repoRoot, { verbose, filter });
   const filteredEvalCases = filterEvalCases(evalCases, filter);
   if (filteredEvalCases.length === 0) {
@@ -17790,7 +18021,7 @@ async function runEvaluation(options) {
   ];
   const evaluatorRegistry = buildEvaluatorRegistry(evaluators, resolveGraderProvider);
   const typeRegistry = createBuiltinRegistry();
-  const discoveryBaseDir = evalFilePath ? import_node_path45.default.dirname(import_node_path45.default.resolve(evalFilePath)) : process.cwd();
+  const discoveryBaseDir = evalFilePath ? import_node_path46.default.dirname(import_node_path46.default.resolve(evalFilePath)) : process.cwd();
   const evalDir = discoveryBaseDir;
   await discoverAssertions(typeRegistry, discoveryBaseDir);
   await discoverGraders(typeRegistry, discoveryBaseDir);
@@ -17930,14 +18161,14 @@ async function runEvaluation(options) {
   let staticMaterialised = false;
   if (useStaticWorkspace && configuredStaticPath) {
     const isYamlConfiguredPath = !cliWorkspacePath && !!yamlWorkspacePath;
-    const dirExists = await (0, import_promises30.stat)(configuredStaticPath).then(
+    const dirExists = await (0, import_promises31.stat)(configuredStaticPath).then(
       (s) => s.isDirectory(),
       () => false
     );
-    const isEmpty = dirExists ? (await (0, import_promises30.readdir)(configuredStaticPath)).length === 0 : false;
+    const isEmpty = dirExists ? (await (0, import_promises31.readdir)(configuredStaticPath)).length === 0 : false;
     if (isYamlConfiguredPath && (!dirExists || isEmpty)) {
       if (!dirExists) {
-        await (0, import_promises30.mkdir)(configuredStaticPath, { recursive: true });
+        await (0, import_promises31.mkdir)(configuredStaticPath, { recursive: true });
       }
       if (workspaceTemplate) {
         await copyDirectoryRecursive(workspaceTemplate, configuredStaticPath);
@@ -17982,14 +18213,14 @@ async function runEvaluation(options) {
     }
   } else if (suiteWorkspace?.hooks || suiteWorkspace?.repos?.length && !isPerTestIsolation) {
     sharedWorkspacePath = getWorkspacePath(evalRunId, "shared");
-    await (0, import_promises30.mkdir)(sharedWorkspacePath, { recursive: true });
+    await (0, import_promises31.mkdir)(sharedWorkspacePath, { recursive: true });
     setupLog(`created empty shared workspace at: ${sharedWorkspacePath}`);
   }
   try {
     if (suiteWorkspaceFile && sharedWorkspacePath) {
-      const copiedWorkspaceFile = import_node_path45.default.join(sharedWorkspacePath, import_node_path45.default.basename(suiteWorkspaceFile));
+      const copiedWorkspaceFile = import_node_path46.default.join(sharedWorkspacePath, import_node_path46.default.basename(suiteWorkspaceFile));
       try {
-        await (0, import_promises30.stat)(copiedWorkspaceFile);
+        await (0, import_promises31.stat)(copiedWorkspaceFile);
         suiteWorkspaceFile = copiedWorkspaceFile;
       } catch {
       }
@@ -18569,9 +18800,9 @@ async function runEvalCase(options) {
         );
       }
       if (caseWorkspaceFile && workspacePath) {
-        const copiedFile = import_node_path45.default.join(workspacePath, import_node_path45.default.basename(caseWorkspaceFile));
+        const copiedFile = import_node_path46.default.join(workspacePath, import_node_path46.default.basename(caseWorkspaceFile));
         try {
-          await (0, import_promises30.stat)(copiedFile);
+          await (0, import_promises31.stat)(copiedFile);
           caseWorkspaceFile = copiedFile;
         } catch {
         }
@@ -18579,7 +18810,7 @@ async function runEvalCase(options) {
     }
     if (!workspacePath && (evalCase.workspace?.hooks || evalCase.workspace?.repos?.length) && evalRunId) {
       workspacePath = getWorkspacePath(evalRunId, evalCase.id);
-      await (0, import_promises30.mkdir)(workspacePath, { recursive: true });
+      await (0, import_promises31.mkdir)(workspacePath, { recursive: true });
     }
     if (evalCase.workspace?.repos?.length && workspacePath) {
       const localPathErrors = RepoManager.validateLocalPaths(evalCase.workspace.repos);
@@ -18631,11 +18862,11 @@ async function runEvalCase(options) {
       const files = evalCase.metadata.agent_skills_files;
       if (baseDir && files.length > 0) {
         for (const relPath of files) {
-          const srcPath = import_node_path45.default.resolve(baseDir, relPath);
-          const destPath = import_node_path45.default.resolve(workspacePath, relPath);
+          const srcPath = import_node_path46.default.resolve(baseDir, relPath);
+          const destPath = import_node_path46.default.resolve(workspacePath, relPath);
           try {
-            await (0, import_promises30.mkdir)(import_node_path45.default.dirname(destPath), { recursive: true });
-            await (0, import_promises30.copyFile)(srcPath, destPath);
+            await (0, import_promises31.mkdir)(import_node_path46.default.dirname(destPath), { recursive: true });
+            await (0, import_promises31.copyFile)(srcPath, destPath);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             return buildErrorResult(
@@ -19280,7 +19511,7 @@ async function runEvaluatorList(options) {
     fileChanges,
     workspacePath
   };
-  const evalFileDir = evalCase.file_paths[0] ? import_node_path45.default.dirname(evalCase.file_paths[0]) : process.cwd();
+  const evalFileDir = evalCase.file_paths[0] ? import_node_path46.default.dirname(evalCase.file_paths[0]) : process.cwd();
   const dispatchContext = {
     graderProvider,
     targetResolver,
@@ -19510,7 +19741,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = (0, import_node_crypto10.createHash)("sha256");
+  const hash = (0, import_node_crypto11.createHash)("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -19613,8 +19844,8 @@ function computeWeightedMean(entries) {
 }
 
 // src/evaluation/evaluate.ts
-var import_node_fs14 = require("fs");
-var import_node_path46 = __toESM(require("path"), 1);
+var import_node_fs15 = require("fs");
+var import_node_path47 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/function-provider.ts
 function createFunctionProvider(taskFn) {
@@ -19651,7 +19882,7 @@ async function evaluate(config) {
   }
   const gitRoot = await findGitRoot(process.cwd());
   const repoRoot = gitRoot ?? process.cwd();
-  const testFilePath = config.specFile ? import_node_path46.default.resolve(config.specFile) : import_node_path46.default.join(process.cwd(), "__programmatic__.yaml");
+  const testFilePath = config.specFile ? import_node_path47.default.resolve(config.specFile) : import_node_path47.default.join(process.cwd(), "__programmatic__.yaml");
   await loadEnvHierarchy(repoRoot, testFilePath);
   let resolvedTarget;
   let taskProvider;
@@ -19772,11 +20003,11 @@ function computeSummary(results, durationMs) {
 var TARGET_FILE_CANDIDATES = [".agentv/targets.yaml", ".agentv/targets.yml"];
 async function discoverDefaultTarget(repoRoot) {
   const cwd = process.cwd();
-  const chain = buildDirectoryChain2(import_node_path46.default.join(cwd, "_placeholder"), repoRoot);
+  const chain = buildDirectoryChain2(import_node_path47.default.join(cwd, "_placeholder"), repoRoot);
   for (const dir of chain) {
     for (const candidate of TARGET_FILE_CANDIDATES) {
-      const targetsPath = import_node_path46.default.join(dir, candidate);
-      if (!(0, import_node_fs14.existsSync)(targetsPath)) continue;
+      const targetsPath = import_node_path47.default.join(dir, candidate);
+      if (!(0, import_node_fs15.existsSync)(targetsPath)) continue;
       try {
         const definitions = await readTargetDefinitions(targetsPath);
         const defaultTarget = definitions.find((d) => d.name === "default");
@@ -19792,8 +20023,8 @@ async function loadEnvHierarchy(repoRoot, startPath) {
   const chain = buildDirectoryChain2(startPath, repoRoot);
   const envFiles = [];
   for (const dir of chain) {
-    const envPath = import_node_path46.default.join(dir, ".env");
-    if ((0, import_node_fs14.existsSync)(envPath)) envFiles.push(envPath);
+    const envPath = import_node_path47.default.join(dir, ".env");
+    if ((0, import_node_fs15.existsSync)(envPath)) envFiles.push(envPath);
   }
   for (let i = 0; i < envFiles.length; i++) {
     try {
@@ -19973,8 +20204,8 @@ function buildPrompt(criteria, question, referenceAnswer) {
 }
 
 // src/evaluation/cache/response-cache.ts
-var import_promises31 = require("fs/promises");
-var import_node_path47 = __toESM(require("path"), 1);
+var import_promises32 = require("fs/promises");
+var import_node_path48 = __toESM(require("path"), 1);
 var DEFAULT_CACHE_PATH = ".agentv/cache";
 var ResponseCache = class {
   cachePath;
@@ -19984,7 +20215,7 @@ var ResponseCache = class {
   async get(key) {
     const filePath = this.keyToPath(key);
     try {
-      const data = await (0, import_promises31.readFile)(filePath, "utf8");
+      const data = await (0, import_promises32.readFile)(filePath, "utf8");
       return JSON.parse(data);
     } catch {
       return void 0;
@@ -19992,13 +20223,13 @@ var ResponseCache = class {
   }
   async set(key, value) {
     const filePath = this.keyToPath(key);
-    const dir = import_node_path47.default.dirname(filePath);
-    await (0, import_promises31.mkdir)(dir, { recursive: true });
-    await (0, import_promises31.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
+    const dir = import_node_path48.default.dirname(filePath);
+    await (0, import_promises32.mkdir)(dir, { recursive: true });
+    await (0, import_promises32.writeFile)(filePath, JSON.stringify(value, null, 2), "utf8");
   }
   keyToPath(key) {
     const prefix = key.slice(0, 2);
-    return import_node_path47.default.join(this.cachePath, prefix, `${key}.json`);
+    return import_node_path48.default.join(this.cachePath, prefix, `${key}.json`);
   }
 };
 function shouldEnableCache(params) {
@@ -20196,6 +20427,17 @@ var OtelTraceExporter = class {
         if (result.durationMs != null)
           rootSpan.setAttribute("agentv.trace.duration_ms", result.durationMs);
         if (result.costUsd != null) rootSpan.setAttribute("agentv.trace.cost_usd", result.costUsd);
+        if (result.tokenUsage) {
+          if (result.tokenUsage.input != null) {
+            rootSpan.setAttribute("agentv.trace.token_input", result.tokenUsage.input);
+          }
+          if (result.tokenUsage.output != null) {
+            rootSpan.setAttribute("agentv.trace.token_output", result.tokenUsage.output);
+          }
+          if (result.tokenUsage.cached != null) {
+            rootSpan.setAttribute("agentv.trace.token_cached", result.tokenUsage.cached);
+          }
+        }
         if (result.trace) {
           const t = result.trace;
           rootSpan.setAttribute("agentv.trace.event_count", t.eventCount);
@@ -20298,6 +20540,7 @@ var OtelTraceExporter = class {
       tracer.startActiveSpan(
         spanName,
         { startTime: startHr },
+        parentCtx,
         (span) => {
           if (isAssistant) {
             span.setAttribute("gen_ai.operation.name", "chat");
@@ -20330,6 +20573,7 @@ var OtelTraceExporter = class {
                 tracer.startActiveSpan(
                   `execute_tool ${tc.tool}`,
                   {},
+                  msgCtx,
                   (toolSpan) => {
                     toolSpan.setAttribute("gen_ai.tool.name", tc.tool);
                     if (tc.id) toolSpan.setAttribute("gen_ai.tool.call.id", tc.id);
@@ -20370,8 +20614,12 @@ var OtelStreamingObserver = class {
   rootSpan = null;
   // biome-ignore lint/suspicious/noExplicitAny: OTel context loaded dynamically
   rootCtx = null;
+  observedChildSpans = false;
+  pendingMetrics = null;
   /** Create root eval span immediately (visible in backend right away) */
   startEvalCase(testId, target, evalSet) {
+    this.pendingMetrics = null;
+    this.observedChildSpans = false;
     const ctx = this.parentCtx ?? this.api.context.active();
     this.rootSpan = this.tracer.startSpan("agentv.eval", void 0, ctx);
     this.rootSpan.setAttribute("gen_ai.operation.name", "evaluate");
@@ -20384,8 +20632,9 @@ var OtelStreamingObserver = class {
   /** Create and immediately export a tool span */
   onToolCall(name, input, output, _durationMs, toolCallId) {
     if (!this.rootCtx) return;
+    this.observedChildSpans = true;
     this.api.context.with(this.rootCtx, () => {
-      const span = this.tracer.startSpan(`execute_tool ${name}`);
+      const span = this.tracer.startSpan(`execute_tool ${name}`, void 0, this.rootCtx);
       span.setAttribute("gen_ai.tool.name", name);
       if (toolCallId) span.setAttribute("gen_ai.tool.call.id", toolCallId);
       if (this.captureContent) {
@@ -20406,8 +20655,9 @@ var OtelStreamingObserver = class {
   /** Create and immediately export an LLM span */
   onLlmCall(model, tokenUsage) {
     if (!this.rootCtx) return;
+    this.observedChildSpans = true;
     this.api.context.with(this.rootCtx, () => {
-      const span = this.tracer.startSpan(`chat ${model}`);
+      const span = this.tracer.startSpan(`chat ${model}`, void 0, this.rootCtx);
       span.setAttribute("gen_ai.operation.name", "chat");
       span.setAttribute("gen_ai.request.model", model);
       span.setAttribute("gen_ai.response.model", model);
@@ -20422,10 +20672,53 @@ var OtelStreamingObserver = class {
       span.end();
     });
   }
+  /** Record final execution metrics before the root span is finalized. */
+  recordEvalMetrics(result) {
+    this.pendingMetrics = result;
+  }
   /** Finalize root span with score/verdict after evaluation completes */
   finalizeEvalCase(score, error) {
     if (!this.rootSpan) return;
     this.rootSpan.setAttribute("agentv.score", score);
+    if (this.pendingMetrics?.durationMs != null) {
+      this.rootSpan.setAttribute("agentv.trace.duration_ms", this.pendingMetrics.durationMs);
+    }
+    if (this.pendingMetrics?.costUsd != null) {
+      this.rootSpan.setAttribute("agentv.trace.cost_usd", this.pendingMetrics.costUsd);
+    }
+    if (this.pendingMetrics?.tokenUsage) {
+      if (this.pendingMetrics.tokenUsage.input != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.token_input",
+          this.pendingMetrics.tokenUsage.input
+        );
+      }
+      if (this.pendingMetrics.tokenUsage.output != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.token_output",
+          this.pendingMetrics.tokenUsage.output
+        );
+      }
+      if (this.pendingMetrics.tokenUsage.cached != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.token_cached",
+          this.pendingMetrics.tokenUsage.cached
+        );
+      }
+    }
+    if (this.pendingMetrics?.trace) {
+      this.rootSpan.setAttribute("agentv.trace.event_count", this.pendingMetrics.trace.eventCount);
+      this.rootSpan.setAttribute(
+        "agentv.trace.tool_names",
+        Object.keys(this.pendingMetrics.trace.toolCalls).sort().join(",")
+      );
+      if (this.pendingMetrics.trace.llmCallCount != null) {
+        this.rootSpan.setAttribute(
+          "agentv.trace.llm_call_count",
+          this.pendingMetrics.trace.llmCallCount
+        );
+      }
+    }
     if (error) {
       this.rootSpan.setStatus({ code: this.api.SpanStatusCode.ERROR, message: error });
     } else {
@@ -20434,6 +20727,33 @@ var OtelStreamingObserver = class {
     this.rootSpan.end();
     this.rootSpan = null;
     this.rootCtx = null;
+    this.observedChildSpans = false;
+    this.pendingMetrics = null;
+  }
+  /** Backfill child spans from the completed result when the provider emitted no live callbacks. */
+  completeFromResult(result) {
+    this.recordEvalMetrics({
+      durationMs: result.durationMs,
+      costUsd: result.costUsd,
+      tokenUsage: result.tokenUsage,
+      trace: result.trace
+    });
+    if (this.observedChildSpans || !this.rootCtx) {
+      return;
+    }
+    const model = result.output.find((msg) => msg.role === "assistant")?.metadata?.model ?? result.target ?? "unknown";
+    this.onLlmCall(String(model), result.tokenUsage);
+    for (const message of result.output) {
+      for (const toolCall of message.toolCalls ?? []) {
+        this.onToolCall(
+          toolCall.tool,
+          toolCall.input,
+          toolCall.output,
+          toolCall.durationMs ?? 0,
+          toolCall.id
+        );
+      }
+    }
   }
   /** Return the active eval span's trace ID and span ID for Braintrust trace bridging */
   getActiveSpanIds() {