@agentv/core 2.5.5 → 2.5.6

package/dist/index.js

@@ -10,7 +10,7 @@ import {
   readTextFile,
   resolveFileReference,
   resolveTargetDefinition
-} from "./chunk-RP3M7COZ.js";
+} from "./chunk-LGQ5OPJD.js";
 
 // src/evaluation/types.ts
 var TEST_MESSAGE_ROLE_VALUES = ["system", "user", "assistant", "tool"];
@@ -3222,8 +3222,8 @@ async function runClaudeCodeWithTempFiles(options, stdoutFile, stderrFile, exitF
   };
   const fileExists4 = async (filePath) => {
     try {
-      const { access: access5 } = await import("node:fs/promises");
-      await access5(filePath);
+      const { access: access6 } = await import("node:fs/promises");
+      await access6(filePath);
       return true;
     } catch {
       return false;
@@ -4548,6 +4548,538 @@ function shouldShellExecute(executable) {
   return lower.endsWith(".cmd") || lower.endsWith(".bat") || lower.endsWith(".ps1");
 }
 
+// src/evaluation/providers/copilot-cli.ts
+import { exec as execCallback2, spawn as spawn3 } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { constants as constants3, createWriteStream as createWriteStream3 } from "node:fs";
+import { access as access3, copyFile, mkdir as mkdir3, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import path12 from "node:path";
+import { promisify as promisify3 } from "node:util";
+
+// src/evaluation/providers/copilot-cli-log-tracker.ts
+var GLOBAL_LOGS_KEY3 = Symbol.for("agentv.copilotCliLogs");
+var GLOBAL_SUBSCRIBERS_KEY3 = Symbol.for("agentv.copilotCliLogSubscribers");
+function getCopilotCliLogStore() {
+  const globalObject = globalThis;
+  const existing = globalObject[GLOBAL_LOGS_KEY3];
+  if (existing) {
+    return existing;
+  }
+  const created = [];
+  globalObject[GLOBAL_LOGS_KEY3] = created;
+  return created;
+}
+function getSubscriberStore3() {
+  const globalObject = globalThis;
+  const existing = globalObject[GLOBAL_SUBSCRIBERS_KEY3];
+  if (existing) {
+    return existing;
+  }
+  const created = /* @__PURE__ */ new Set();
+  globalObject[GLOBAL_SUBSCRIBERS_KEY3] = created;
+  return created;
+}
+function notifySubscribers3(entry) {
+  const subscribers = Array.from(getSubscriberStore3());
+  for (const listener of subscribers) {
+    try {
+      listener(entry);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Copilot CLI log subscriber failed: ${message}`);
+    }
+  }
+}
+function recordCopilotCliLogEntry(entry) {
+  getCopilotCliLogStore().push(entry);
+  notifySubscribers3(entry);
+}
+function consumeCopilotCliLogEntries() {
+  const store = getCopilotCliLogStore();
+  if (store.length === 0) {
+    return [];
+  }
+  return store.splice(0, store.length);
+}
+function subscribeToCopilotCliLogEntries(listener) {
+  const store = getSubscriberStore3();
+  store.add(listener);
+  return () => {
+    store.delete(listener);
+  };
+}
+
+// src/evaluation/providers/copilot-cli.ts
+var execAsync3 = promisify3(execCallback2);
+var WORKSPACE_PREFIX3 = "agentv-copilot-";
+var PROMPT_FILENAME3 = "prompt.md";
+var DEFAULT_SYSTEM_PROMPT4 = `**IMPORTANT**: Follow these instructions for your response:
+- Do NOT create any additional output files in the workspace.
+- All intended file outputs/changes MUST be written in your response.
+- For each intended file, include the relative path and unified git diff following the convention \`diff --git ...\`.
+This is required for evaluation scoring.`;
+async function copyInputFilesToWorkspace(workspaceRoot, inputFiles) {
+  const usedNames = /* @__PURE__ */ new Map();
+  const mappings = [];
+  for (const originalPath of inputFiles) {
+    const ext = path12.extname(originalPath);
+    const stem = path12.basename(originalPath, ext);
+    let relativeName;
+    const baseKey = `${stem}${ext}`;
+    const count = usedNames.get(baseKey) ?? 0;
+    if (count === 0) {
+      relativeName = baseKey;
+    } else {
+      relativeName = `${stem}_${count}${ext}`;
+    }
+    usedNames.set(baseKey, count + 1);
+    const dest = path12.join(workspaceRoot, relativeName);
+    await copyFile(originalPath, dest);
+    mappings.push({ originalPath, workspaceRelativePath: relativeName });
+  }
+  return mappings;
+}
+function buildCopilotFilePrereadBlock(guidelineMappings, inputMappings) {
+  if (guidelineMappings.length === 0 && inputMappings.length === 0) {
+    return "";
+  }
+  const buildList = (mappings) => mappings.map((m) => `* ${m.workspaceRelativePath}`).join("\n");
+  const sections = [];
+  if (guidelineMappings.length > 0) {
+    sections.push(`Read all guideline files:
+${buildList(guidelineMappings)}.`);
+  }
+  if (inputMappings.length > 0) {
+    sections.push(`Read all input files:
+${buildList(inputMappings)}.`);
+  }
+  sections.push(
+    "If any file is missing, fail with ERROR: missing-file <filename> and stop.",
+    "Then apply system_instructions on the user query below."
+  );
+  return sections.join("\n");
+}
+var CopilotCliProvider = class {
+  id;
+  kind = "copilot-cli";
+  targetName;
+  supportsBatch = false;
+  config;
+  runCopilot;
+  environmentCheck;
+  resolvedExecutable;
+  constructor(targetName, config, runner = defaultCopilotCliRunner) {
+    this.id = `copilot-cli:${targetName}`;
+    this.targetName = targetName;
+    this.config = config;
+    this.runCopilot = runner;
+  }
+  async invoke(request) {
+    if (request.signal?.aborted) {
+      throw new Error("Copilot CLI request was aborted before execution");
+    }
+    await this.ensureEnvironmentReady();
+    const inputFiles = normalizeInputFiles(request.inputFiles);
+    const workspaceRoot = await this.createWorkspace();
+    const logger = await this.createStreamLogger(request).catch(() => void 0);
+    try {
+      const copiedFiles = inputFiles ? await copyInputFilesToWorkspace(workspaceRoot, inputFiles) : [];
+      const guidelineFileSet = new Set(
+        collectGuidelineFiles(inputFiles, request.guideline_patterns)
+      );
+      const guidelineMappings = copiedFiles.filter((m) => guidelineFileSet.has(m.originalPath));
+      const nonGuidelineMappings = copiedFiles.filter((m) => !guidelineFileSet.has(m.originalPath));
+      const prereadBlock = buildCopilotFilePrereadBlock(guidelineMappings, nonGuidelineMappings);
+      const systemPrompt = this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT4;
+      const promptParts = [systemPrompt];
+      if (prereadBlock.length > 0) {
+        promptParts.push("", prereadBlock);
+      }
+      promptParts.push("", "[[ ## user_query ## ]]", request.question.trim());
+      const promptContent = promptParts.join("\n");
+      const promptFile = path12.join(workspaceRoot, PROMPT_FILENAME3);
+      await writeFile3(promptFile, promptContent, "utf8");
+      const args = this.buildCopilotArgs(promptContent);
+      const cwd = this.resolveCwd(workspaceRoot);
+      const result = await this.executeCopilot(args, cwd, promptContent, request.signal, logger);
+      if (result.timedOut) {
+        throw new Error(
+          `Copilot CLI timed out${formatTimeoutSuffix4(this.config.timeoutMs ?? void 0)}`
+        );
+      }
+      if (result.exitCode !== 0) {
+        const detail = pickDetail3(result.stderr, result.stdout);
+        const prefix = `Copilot CLI exited with code ${result.exitCode}`;
+        throw new Error(detail ? `${prefix}: ${detail}` : prefix);
+      }
+      const assistantText = extractCopilotResponse(result.stdout);
+      return {
+        raw: {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode,
+          args,
+          executable: this.resolvedExecutable ?? this.config.executable,
+          promptFile,
+          workspace: workspaceRoot,
+          inputFiles,
+          copiedFiles,
+          logFile: logger?.filePath
+        },
+        outputMessages: [{ role: "assistant", content: assistantText }]
+      };
+    } finally {
+      await logger?.close();
+      await this.cleanupWorkspace(workspaceRoot);
+    }
+  }
+  async ensureEnvironmentReady() {
+    if (!this.environmentCheck) {
+      this.environmentCheck = this.validateEnvironment();
+    }
+    await this.environmentCheck;
+  }
+  async validateEnvironment() {
+    this.resolvedExecutable = await locateExecutable2(this.config.executable);
+  }
+  resolveCwd(workspaceRoot) {
+    if (!this.config.cwd) {
+      return workspaceRoot;
+    }
+    return path12.resolve(this.config.cwd);
+  }
+  buildCopilotArgs(prompt) {
+    const args = [];
+    args.push("-s");
+    args.push("--allow-all-tools");
+    args.push("--no-color");
+    if (this.config.model) {
+      args.push("--model", this.config.model);
+    }
+    if (this.config.args && this.config.args.length > 0) {
+      args.push(...this.config.args);
+    }
+    args.push("-p", prompt);
+    return args;
+  }
+  async executeCopilot(args, cwd, promptContent, signal, logger) {
+    try {
+      return await this.runCopilot({
+        executable: this.resolvedExecutable ?? this.config.executable,
+        args,
+        cwd,
+        prompt: promptContent,
+        timeoutMs: this.config.timeoutMs,
+        env: process.env,
+        signal,
+        onStdoutChunk: logger ? (chunk) => logger.handleStdoutChunk(chunk) : void 0,
+        onStderrChunk: logger ? (chunk) => logger.handleStderrChunk(chunk) : void 0
+      });
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        throw new Error(
+          `Copilot executable '${this.config.executable}' was not found. Update the target settings.executable or add it to PATH.`
+        );
+      }
+      throw error;
+    }
+  }
+  async createWorkspace() {
+    return await mkdtemp3(path12.join(tmpdir3(), WORKSPACE_PREFIX3));
+  }
+  async cleanupWorkspace(workspaceRoot) {
+    try {
+      await rm3(workspaceRoot, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  resolveLogDirectory() {
+    const disabled = isCopilotLogStreamingDisabled();
+    if (disabled) {
+      return void 0;
+    }
+    if (this.config.logDir) {
+      return path12.resolve(this.config.logDir);
+    }
+    return path12.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+  }
+  async createStreamLogger(request) {
+    const logDir = this.resolveLogDirectory();
+    if (!logDir) {
+      return void 0;
+    }
+    try {
+      await mkdir3(logDir, { recursive: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`Skipping Copilot CLI stream logging (could not create ${logDir}): ${message}`);
+      return void 0;
+    }
+    const filePath = path12.join(logDir, buildLogFilename3(request, this.targetName));
+    try {
+      const logger = await CopilotCliStreamLogger.create({
+        filePath,
+        targetName: this.targetName,
+        evalCaseId: request.evalCaseId,
+        attempt: request.attempt,
+        format: this.config.logFormat ?? "summary"
+      });
+      recordCopilotCliLogEntry({
+        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 Copilot CLI stream logging for ${filePath}: ${message}`);
+      return void 0;
+    }
+  }
+};
+var CopilotCliStreamLogger = class _CopilotCliStreamLogger {
+  filePath;
+  stream;
+  startedAt = Date.now();
+  stdoutBuffer = "";
+  stderrBuffer = "";
+  format;
+  constructor(filePath, format) {
+    this.filePath = filePath;
+    this.format = format;
+    this.stream = createWriteStream3(filePath, { flags: "a" });
+  }
+  static async create(options) {
+    const logger = new _CopilotCliStreamLogger(options.filePath, options.format);
+    const header = [
+      "# Copilot CLI 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));
+    logger.writeLines(header);
+    return logger;
+  }
+  handleStdoutChunk(chunk) {
+    this.stdoutBuffer += chunk;
+    this.flushBuffer("stdout");
+  }
+  handleStderrChunk(chunk) {
+    this.stderrBuffer += chunk;
+    this.flushBuffer("stderr");
+  }
+  async close() {
+    this.flushBuffer("stdout");
+    this.flushBuffer("stderr");
+    this.flushRemainder();
+    await new Promise((resolve, reject) => {
+      this.stream.once("error", reject);
+      this.stream.end(() => resolve());
+    });
+  }
+  writeLines(lines) {
+    for (const line of lines) {
+      this.stream.write(`${line}
+`);
+    }
+  }
+  flushBuffer(source) {
+    const buffer = source === "stdout" ? this.stdoutBuffer : this.stderrBuffer;
+    const lines = buffer.split(/\r?\n/);
+    const remainder = lines.pop() ?? "";
+    if (source === "stdout") {
+      this.stdoutBuffer = remainder;
+    } else {
+      this.stderrBuffer = remainder;
+    }
+    for (const line of lines) {
+      const formatted = this.formatLine(line, source);
+      if (formatted) {
+        this.stream.write(formatted);
+        this.stream.write("\n");
+      }
+    }
+  }
+  formatLine(rawLine, source) {
+    const trimmed = rawLine.trim();
+    if (trimmed.length === 0) {
+      return void 0;
+    }
+    const prefix = source === "stderr" ? "stderr: " : "";
+    return `[+${formatElapsed3(this.startedAt)}] [${source}] ${prefix}${trimmed}`;
+  }
+  flushRemainder() {
+    const stdoutRemainder = this.stdoutBuffer.trim();
+    if (stdoutRemainder.length > 0) {
+      const formatted = this.formatLine(stdoutRemainder, "stdout");
+      if (formatted) {
+        this.stream.write(formatted);
+        this.stream.write("\n");
+      }
+    }
+    const stderrRemainder = this.stderrBuffer.trim();
+    if (stderrRemainder.length > 0) {
+      const formatted = this.formatLine(stderrRemainder, "stderr");
+      if (formatted) {
+        this.stream.write(formatted);
+        this.stream.write("\n");
+      }
+    }
+    this.stdoutBuffer = "";
+    this.stderrBuffer = "";
+  }
+};
+function isCopilotLogStreamingDisabled() {
+  const envValue = process.env.AGENTV_COPILOT_STREAM_LOGS;
+  if (!envValue) {
+    return false;
+  }
+  const normalized = envValue.trim().toLowerCase();
+  return normalized === "false" || normalized === "0" || normalized === "off";
+}
+function buildLogFilename3(request, targetName) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const evalId = sanitizeForFilename3(request.evalCaseId ?? "copilot");
+  const attemptSuffix = request.attempt !== void 0 ? `_attempt-${request.attempt + 1}` : "";
+  const target = sanitizeForFilename3(targetName);
+  return `${timestamp}_${target}_${evalId}${attemptSuffix}_${randomUUID3().slice(0, 8)}.log`;
+}
+function sanitizeForFilename3(value) {
+  const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "_");
+  return sanitized.length > 0 ? sanitized : "copilot";
+}
+function formatElapsed3(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")}`;
+}
+var ANSI_ESCAPE_RE = /\x1B\[[0-9;]*[A-Za-z]/g;
+var ANSI_OSC_RE = /\x1B\][^\x07]*\x07/g;
+function stripAnsiEscapes(text) {
+  return text.replace(ANSI_ESCAPE_RE, "").replace(ANSI_OSC_RE, "");
+}
+function extractCopilotResponse(stdout) {
+  const cleaned = stripAnsiEscapes(stdout).trim();
+  if (cleaned.length === 0) {
+    throw new Error("Copilot CLI produced no output");
+  }
+  return cleaned;
+}
+function pickDetail3(stderr, stdout) {
+  const errorText = stderr.trim();
+  if (errorText.length > 0) {
+    return errorText;
+  }
+  const stdoutText = stdout.trim();
+  return stdoutText.length > 0 ? stdoutText : void 0;
+}
+function formatTimeoutSuffix4(timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return "";
+  }
+  const seconds = Math.ceil(timeoutMs / 1e3);
+  return ` after ${seconds}s`;
+}
+async function locateExecutable2(candidate) {
+  const includesPathSeparator = candidate.includes("/") || candidate.includes("\\");
+  if (includesPathSeparator) {
+    const resolved = path12.isAbsolute(candidate) ? candidate : path12.resolve(candidate);
+    await access3(resolved, constants3.F_OK);
+    return resolved;
+  }
+  const locator = process.platform === "win32" ? "where" : "which";
+  try {
+    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 access3(lines[0], constants3.F_OK);
+      return lines[0];
+    }
+  } catch {
+  }
+  throw new Error(`Copilot executable '${candidate}' was not found on PATH`);
+}
+function shouldShellExecute2(executable) {
+  if (process.platform !== "win32") {
+    return false;
+  }
+  const lower = executable.toLowerCase();
+  return lower.endsWith(".cmd") || lower.endsWith(".bat") || lower.endsWith(".ps1");
+}
+async function defaultCopilotCliRunner(options) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn3(options.executable, options.args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: shouldShellExecute2(options.executable)
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const onAbort = () => {
+      child.kill("SIGTERM");
+    };
+    if (options.signal) {
+      if (options.signal.aborted) {
+        onAbort();
+      } else {
+        options.signal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    let timeoutHandle;
+    if (options.timeoutMs && options.timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+      }, options.timeoutMs);
+      timeoutHandle.unref?.();
+    }
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      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/mock.ts
 var DEFAULT_MOCK_RESPONSE = '{"answer":"Mock provider response. Configure targets.yaml to supply a custom value."}';
 var MockProvider = class {
@@ -4751,38 +5283,38 @@ function extractToolCalls2(content) {
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
-import { spawn as spawn3 } from "node:child_process";
-import { randomUUID as randomUUID3 } from "node:crypto";
-import { createWriteStream as createWriteStream3 } from "node:fs";
-import { mkdir as mkdir3, mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
-import { tmpdir as tmpdir3 } from "node:os";
-import path12 from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { createWriteStream as createWriteStream4 } from "node:fs";
+import { mkdir as mkdir4, mkdtemp as mkdtemp4, rm as rm4, writeFile as writeFile4 } from "node:fs/promises";
+import { tmpdir as tmpdir4 } from "node:os";
+import path13 from "node:path";
 
 // src/evaluation/providers/pi-log-tracker.ts
-var GLOBAL_LOGS_KEY3 = Symbol.for("agentv.piLogs");
-var GLOBAL_SUBSCRIBERS_KEY3 = Symbol.for("agentv.piLogSubscribers");
+var GLOBAL_LOGS_KEY4 = Symbol.for("agentv.piLogs");
+var GLOBAL_SUBSCRIBERS_KEY4 = Symbol.for("agentv.piLogSubscribers");
 function getPiLogStore() {
   const globalObject = globalThis;
-  const existing = globalObject[GLOBAL_LOGS_KEY3];
+  const existing = globalObject[GLOBAL_LOGS_KEY4];
   if (existing) {
     return existing;
   }
   const created = [];
-  globalObject[GLOBAL_LOGS_KEY3] = created;
+  globalObject[GLOBAL_LOGS_KEY4] = created;
   return created;
 }
-function getSubscriberStore3() {
+function getSubscriberStore4() {
   const globalObject = globalThis;
-  const existing = globalObject[GLOBAL_SUBSCRIBERS_KEY3];
+  const existing = globalObject[GLOBAL_SUBSCRIBERS_KEY4];
   if (existing) {
     return existing;
   }
   const created = /* @__PURE__ */ new Set();
-  globalObject[GLOBAL_SUBSCRIBERS_KEY3] = created;
+  globalObject[GLOBAL_SUBSCRIBERS_KEY4] = created;
   return created;
 }
-function notifySubscribers3(entry) {
-  const subscribers = Array.from(getSubscriberStore3());
+function notifySubscribers4(entry) {
+  const subscribers = Array.from(getSubscriberStore4());
   for (const listener of subscribers) {
     try {
       listener(entry);
@@ -4794,7 +5326,7 @@ function notifySubscribers3(entry) {
 }
 function recordPiLogEntry(entry) {
   getPiLogStore().push(entry);
-  notifySubscribers3(entry);
+  notifySubscribers4(entry);
 }
 function consumePiLogEntries() {
   const store = getPiLogStore();
@@ -4804,7 +5336,7 @@ function consumePiLogEntries() {
   return store.splice(0, store.length);
 }
 function subscribeToPiLogEntries(listener) {
-  const store = getSubscriberStore3();
+  const store = getSubscriberStore4();
   store.add(listener);
   return () => {
     store.delete(listener);
@@ -4812,9 +5344,9 @@ function subscribeToPiLogEntries(listener) {
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
-var WORKSPACE_PREFIX3 = "agentv-pi-";
-var PROMPT_FILENAME3 = "prompt.md";
-var DEFAULT_SYSTEM_PROMPT4 = `**IMPORTANT**: Follow these instructions for your response:
+var WORKSPACE_PREFIX4 = "agentv-pi-";
+var PROMPT_FILENAME4 = "prompt.md";
+var DEFAULT_SYSTEM_PROMPT5 = `**IMPORTANT**: Follow these instructions for your response:
 - Do NOT create any additional output files in the workspace.
 - All intended file outputs/changes MUST be written in your response.
 - For each intended file, include the relative path and unified git diff following the convention \`diff --git ...\`.
@@ -4840,18 +5372,18 @@ var PiCodingAgentProvider = class {
     const workspaceRoot = await this.createWorkspace();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = path12.join(workspaceRoot, PROMPT_FILENAME3);
-      await writeFile3(promptFile, request.question, "utf8");
+      const promptFile = path13.join(workspaceRoot, PROMPT_FILENAME4);
+      await writeFile4(promptFile, request.question, "utf8");
       const args = this.buildPiArgs(request.question, inputFiles);
       const cwd = this.resolveCwd(workspaceRoot);
       const result = await this.executePi(args, cwd, request.signal, logger);
       if (result.timedOut) {
         throw new Error(
-          `Pi coding agent timed out${formatTimeoutSuffix4(this.config.timeoutMs ?? void 0)}`
+          `Pi coding agent timed out${formatTimeoutSuffix5(this.config.timeoutMs ?? void 0)}`
         );
       }
       if (result.exitCode !== 0) {
-        const detail = pickDetail3(result.stderr, result.stdout);
+        const detail = pickDetail4(result.stderr, result.stdout);
         const prefix = `Pi coding agent exited with code ${result.exitCode}`;
         throw new Error(detail ? `${prefix}: ${detail}` : prefix);
       }
@@ -4882,7 +5414,7 @@ var PiCodingAgentProvider = class {
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return path12.resolve(this.config.cwd);
+    return path13.resolve(this.config.cwd);
   }
   buildPiArgs(prompt, inputFiles) {
     const args = [];
@@ -4912,7 +5444,7 @@ var PiCodingAgentProvider = class {
         args.push(`@${file}`);
       }
     }
-    const systemPrompt = this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT4;
+    const systemPrompt = this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT5;
     const fullPrompt = `${systemPrompt}
 
 ${prompt}`;
@@ -4971,19 +5503,19 @@ ${prompt}`;
     return env;
   }
   async createWorkspace() {
-    return await mkdtemp3(path12.join(tmpdir3(), WORKSPACE_PREFIX3));
+    return await mkdtemp4(path13.join(tmpdir4(), WORKSPACE_PREFIX4));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
-      await rm3(workspaceRoot, { recursive: true, force: true });
+      await rm4(workspaceRoot, { recursive: true, force: true });
     } catch {
     }
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return path12.resolve(this.config.logDir);
+      return path13.resolve(this.config.logDir);
     }
-    return path12.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return path13.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -4991,13 +5523,13 @@ ${prompt}`;
       return void 0;
     }
     try {
-      await mkdir3(logDir, { recursive: true });
+      await mkdir4(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 = path12.join(logDir, buildLogFilename3(request, this.targetName));
+    const filePath = path13.join(logDir, buildLogFilename4(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -5030,7 +5562,7 @@ var PiStreamLogger = class _PiStreamLogger {
   constructor(filePath, format) {
     this.filePath = filePath;
     this.format = format;
-    this.stream = createWriteStream3(filePath, { flags: "a" });
+    this.stream = createWriteStream4(filePath, { flags: "a" });
   }
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
@@ -5091,7 +5623,7 @@ var PiStreamLogger = class _PiStreamLogger {
       return void 0;
     }
     const message = this.format === "json" ? formatPiJsonLog(trimmed) : formatPiLogMessage(trimmed, source);
-    return `[+${formatElapsed3(this.startedAt)}] [${source}] ${message}`;
+    return `[+${formatElapsed4(this.startedAt)}] [${source}] ${message}`;
   }
   flushRemainder() {
     const stdoutRemainder = this.stdoutBuffer.trim();
@@ -5114,18 +5646,18 @@ var PiStreamLogger = class _PiStreamLogger {
     this.stderrBuffer = "";
   }
 };
-function buildLogFilename3(request, targetName) {
+function buildLogFilename4(request, targetName) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  const evalId = sanitizeForFilename3(request.evalCaseId ?? "pi");
+  const evalId = sanitizeForFilename4(request.evalCaseId ?? "pi");
   const attemptSuffix = request.attempt !== void 0 ? `_attempt-${request.attempt + 1}` : "";
-  const target = sanitizeForFilename3(targetName);
-  return `${timestamp}_${target}_${evalId}${attemptSuffix}_${randomUUID3().slice(0, 8)}.log`;
+  const target = sanitizeForFilename4(targetName);
+  return `${timestamp}_${target}_${evalId}${attemptSuffix}_${randomUUID4().slice(0, 8)}.log`;
 }
-function sanitizeForFilename3(value) {
+function sanitizeForFilename4(value) {
   const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "_");
   return sanitized.length > 0 ? sanitized : "pi";
 }
-function formatElapsed3(startedAt) {
+function formatElapsed4(startedAt) {
   const elapsedSeconds = Math.floor((Date.now() - startedAt) / 1e3);
   const hours = Math.floor(elapsedSeconds / 3600);
   const minutes = Math.floor(elapsedSeconds % 3600 / 60);
@@ -5346,7 +5878,7 @@ function extractAssistantText2(messages) {
 function escapeAtSymbols(prompt) {
   return prompt.replace(/@\[([^\]]+)\]:/g, "[[$1]]:");
 }
-function pickDetail3(stderr, stdout) {
+function pickDetail4(stderr, stdout) {
   const errorText = stderr.trim();
   if (errorText.length > 0) {
     return errorText;
@@ -5354,7 +5886,7 @@ function pickDetail3(stderr, stdout) {
   const stdoutText = stdout.trim();
   return stdoutText.length > 0 ? stdoutText : void 0;
 }
-function formatTimeoutSuffix4(timeoutMs) {
+function formatTimeoutSuffix5(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
     return "";
   }
@@ -5367,7 +5899,7 @@ async function defaultPiRunner(options) {
     const executable = parts[0];
     const executableArgs = parts.slice(1);
     const allArgs = [...executableArgs, ...options.args];
-    const child = spawn3(executable, allArgs, {
+    const child = spawn4(executable, allArgs, {
       cwd: options.cwd,
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -5430,38 +5962,38 @@ async function defaultPiRunner(options) {
 }
 
 // src/evaluation/providers/vscode-provider.ts
-import path23 from "node:path";
+import path24 from "node:path";
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
-import { stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
-import path21 from "node:path";
+import { stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
+import path22 from "node:path";
 
 // src/evaluation/providers/vscode/utils/fs.ts
-import { constants as constants3 } from "node:fs";
-import { access as access3, mkdir as mkdir4, readdir, rm as rm4, stat } from "node:fs/promises";
-import path13 from "node:path";
+import { constants as constants4 } from "node:fs";
+import { access as access4, mkdir as mkdir5, readdir, rm as rm5, stat } from "node:fs/promises";
+import path14 from "node:path";
 async function pathExists(target) {
   try {
-    await access3(target, constants3.F_OK);
+    await access4(target, constants4.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(target) {
-  await mkdir4(target, { recursive: true });
+  await mkdir5(target, { recursive: true });
 }
 async function readDirEntries(target) {
   const entries = await readdir(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: path13.join(target, entry.name),
+    absolutePath: path14.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
 async function removeIfExists(target) {
   try {
-    await rm4(target, { force: true, recursive: false });
+    await rm5(target, { force: true, recursive: false });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -5470,9 +6002,9 @@ async function removeIfExists(target) {
 }
 
 // src/evaluation/providers/vscode/utils/path.ts
-import path14 from "node:path";
+import path15 from "node:path";
 function pathToFileUri2(filePath) {
-  const absolutePath = path14.isAbsolute(filePath) ? filePath : path14.resolve(filePath);
+  const absolutePath = path15.isAbsolute(filePath) ? filePath : path15.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -5481,7 +6013,7 @@ function pathToFileUri2(filePath) {
 }
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/evaluation/providers/vscode/utils/template.ts
 function renderTemplate2(content, variables) {
@@ -5573,8 +6105,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path15.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${path15.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${path16.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${path16.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -5583,7 +6115,7 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
 import { readFile as readFile7 } from "node:fs/promises";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // src/evaluation/providers/vscode/utils/time.ts
 function sleep2(ms) {
@@ -5632,7 +6164,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file) => path16.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => path17.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   try {
@@ -5680,31 +6212,31 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 }
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-import { exec, spawn as spawn4 } from "node:child_process";
-import { mkdir as mkdir5, writeFile as writeFile4 } from "node:fs/promises";
-import path18 from "node:path";
-import { promisify as promisify3 } from "node:util";
+import { exec, spawn as spawn5 } from "node:child_process";
+import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
+import path19 from "node:path";
+import { promisify as promisify4 } from "node:util";
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
 import os2 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 var DEFAULT_LOCK_NAME = "subagent.lock";
 var DEFAULT_ALIVE_FILENAME = ".alive";
 function getDefaultSubagentRoot(vscodeCmd = "code") {
   const folder = vscodeCmd === "code-insiders" ? "vscode-insiders-agents" : "vscode-agents";
-  return path17.join(os2.homedir(), ".agentv", "subagents", folder);
+  return path18.join(os2.homedir(), ".agentv", "subagents", folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var execAsync3 = promisify3(exec);
+var execAsync4 = promisify4(exec);
 var DEFAULT_WAKEUP_CONTENT = `---
 description: 'Wake-up Signal'
 model: Grok Code Fast 1 (copilot)
 ---`;
 async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
   try {
-    const { stdout } = await execAsync3(`${vscodeCmd} --status`, {
+    const { stdout } = await execAsync4(`${vscodeCmd} --status`, {
       timeout: 1e4,
       windowsHide: true
     });
@@ -5716,16 +6248,16 @@ async function checkWorkspaceOpened(workspaceName, vscodeCmd) {
 async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir, vscodeCmd, pollInterval = 1, timeout = 60) {
   const alreadyOpen = await checkWorkspaceOpened(workspaceName, vscodeCmd);
   if (alreadyOpen) {
-    spawn4(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+    spawn5(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
     return true;
   }
-  const aliveFile = path18.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = path19.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = path18.join(subagentDir, ".github", "agents");
-  await mkdir5(githubAgentsDir, { recursive: true });
-  const wakeupDst = path18.join(githubAgentsDir, "wakeup.md");
-  await writeFile4(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
-  spawn4(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+  const githubAgentsDir = path19.join(subagentDir, ".github", "agents");
+  await mkdir6(githubAgentsDir, { recursive: true });
+  const wakeupDst = path19.join(githubAgentsDir, "wakeup.md");
+  await writeFile5(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  spawn5(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
   await sleep2(100);
   const wakeupChatId = "wakeup";
   const chatArgs = [
@@ -5733,9 +6265,9 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${path18.basename(subagentDir)} folder`
+    `create a file named .alive in the ${path19.basename(subagentDir)} folder`
   ];
-  spawn4(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+  spawn5(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
   const start = Date.now();
   while (!await pathExists(aliveFile)) {
     if (Date.now() - start > timeout * 1e3) {
@@ -5748,21 +6280,21 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
   try {
-    const workspacePath = path18.join(subagentDir, `${path18.basename(subagentDir)}.code-workspace`);
-    const messagesDir = path18.join(subagentDir, "messages");
-    await mkdir5(messagesDir, { recursive: true });
-    const reqFile = path18.join(messagesDir, `${timestamp}_req.md`);
-    await writeFile4(reqFile, requestInstructions, { encoding: "utf8" });
+    const workspacePath = path19.join(subagentDir, `${path19.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path19.join(subagentDir, "messages");
+    await mkdir6(messagesDir, { recursive: true });
+    const reqFile = path19.join(messagesDir, `${timestamp}_req.md`);
+    await writeFile5(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 [${path18.basename(reqFile)}](${reqUri})`);
+    chatArgs.push(`Follow instructions in [${path19.basename(reqFile)}](${reqUri})`);
     const workspaceReady = await ensureWorkspaceFocused(
       workspacePath,
-      path18.basename(subagentDir),
+      path19.basename(subagentDir),
       subagentDir,
       vscodeCmd
     );
@@ -5770,7 +6302,7 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
       console.error("warning: Workspace may not be fully ready");
     }
     await sleep2(500);
-    spawn4(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+    spawn5(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
     return true;
   } catch (error) {
     console.error(`warning: Failed to launch VS Code: ${error.message}`);
@@ -5779,9 +6311,9 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
   try {
-    const workspacePath = path18.join(subagentDir, `${path18.basename(subagentDir)}.code-workspace`);
-    const messagesDir = path18.join(subagentDir, "messages");
-    await mkdir5(messagesDir, { recursive: true });
+    const workspacePath = path19.join(subagentDir, `${path19.basename(subagentDir)}.code-workspace`);
+    const messagesDir = path19.join(subagentDir, "messages");
+    await mkdir6(messagesDir, { recursive: true });
     const chatArgs = ["-r", "chat", "-m", chatId];
     for (const attachment of attachmentPaths) {
       chatArgs.push("-a", attachment);
@@ -5789,7 +6321,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
     chatArgs.push(chatInstruction);
     const workspaceReady = await ensureWorkspaceFocused(
       workspacePath,
-      path18.basename(subagentDir),
+      path19.basename(subagentDir),
       subagentDir,
       vscodeCmd
     );
@@ -5797,7 +6329,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
       console.error("warning: Workspace may not be fully ready");
     }
     await sleep2(500);
-    spawn4(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+    spawn5(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
     return true;
   } catch (error) {
     console.error(`warning: Failed to launch VS Code: ${error.message}`);
@@ -5806,11 +6338,11 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-import { copyFile, mkdir as mkdir6, readFile as readFile8, readdir as readdir2, stat as stat2, writeFile as writeFile5 } from "node:fs/promises";
-import path20 from "node:path";
+import { copyFile as copyFile2, mkdir as mkdir7, readFile as readFile8, readdir as readdir2, stat as stat2, writeFile as writeFile6 } from "node:fs/promises";
+import path21 from "node:path";
 
 // src/evaluation/providers/vscode/utils/workspace.ts
-import path19 from "node:path";
+import path20 from "node:path";
 import JSON5 from "json5";
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -5827,10 +6359,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (path19.isAbsolute(folderPath)) {
+    if (path20.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = path19.resolve(templateDir, folderPath);
+    const absolutePath = path20.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -5852,19 +6384,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = path19.isAbsolute(locationPath);
+          const isAbsolute = path20.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = path19.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = path20.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 = (path19.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (path20.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -5905,7 +6437,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 = path20.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = path21.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -5915,7 +6447,7 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = path20.resolve(workspaceTemplate);
+    const workspaceSrc = path21.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
@@ -5928,41 +6460,41 @@ async function copyAgentConfig(subagentDir, workspaceTemplate) {
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${path20.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = path20.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? path20.dirname(path20.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${path21.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = path21.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? path21.dirname(path21.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
-  await writeFile5(workspaceDst, transformedContent, "utf8");
-  const messagesDir = path20.join(subagentDir, "messages");
-  await mkdir6(messagesDir, { recursive: true });
+  await writeFile6(workspaceDst, transformedContent, "utf8");
+  const messagesDir = path21.join(subagentDir, "messages");
+  await mkdir7(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = path20.join(subagentDir, "messages");
+  const messagesDir = path21.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
     const files = await readdir2(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = path20.join(messagesDir, file);
+        const target = path21.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = path20.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = path21.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
     const agentFiles = await readdir2(githubAgentsDir);
     const preservedFiles = /* @__PURE__ */ new Set(["wakeup.md", "subagent.md"]);
     await Promise.all(
-      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path20.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(path21.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = path20.join(subagentDir, DEFAULT_LOCK_NAME);
-  await writeFile5(lockFile, "", { encoding: "utf8" });
+  const lockFile = path21.join(subagentDir, DEFAULT_LOCK_NAME);
+  await writeFile6(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = path20.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = path21.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
@@ -5982,11 +6514,11 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = path20.join(subagentDir, ".github", "agents");
-    await mkdir6(githubAgentsDir, { recursive: true });
-    const agentFile = path20.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = path21.join(subagentDir, ".github", "agents");
+    await mkdir7(githubAgentsDir, { recursive: true });
+    const agentFile = path21.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await copyFile(promptFile, agentFile);
+      await copyFile2(promptFile, agentFile);
     } catch (error) {
       console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
@@ -6003,7 +6535,7 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = path21.resolve(promptFile);
+  const resolvedPrompt = path22.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
@@ -6019,7 +6551,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = path21.resolve(attachment);
+    const resolvedPath = path22.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -6059,7 +6591,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = path21.basename(subagentDir);
+    const subagentName = path22.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -6086,9 +6618,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path21.join(subagentDir, "messages");
-    const responseFileTmp = path21.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = path21.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = path22.join(subagentDir, "messages");
+    const responseFileTmp = path22.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = path22.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -6201,7 +6733,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = path21.basename(subagentDir);
+    subagentName = path22.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -6232,24 +6764,24 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = path21.join(subagentDir, "messages");
+    const messagesDir = path22.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => path21.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => path22.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => path21.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => path22.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => path21.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => path22.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = path21.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = path22.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 writeFile6(
+          return writeFile7(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -6261,7 +6793,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await writeFile6(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await writeFile7(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -6331,8 +6863,8 @@ async function dispatchBatchAgent(options) {
 }
 
 // src/evaluation/providers/vscode/dispatch/provision.ts
-import { writeFile as writeFile7 } from "node:fs/promises";
-import path22 from "node:path";
+import { writeFile as writeFile8 } from "node:fs/promises";
+import path23 from "node:path";
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -6363,7 +6895,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = path22.resolve(targetRoot);
+  const targetPath = path23.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -6383,7 +6915,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = path22.join(entry.absolutePath, lockName);
+      const lockFile = path23.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -6400,10 +6932,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = path22.join(subagentDir, ".github", "agents");
-    const lockFile = path22.join(subagentDir, lockName);
-    const workspaceDst = path22.join(subagentDir, `${path22.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path22.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = path23.join(subagentDir, ".github", "agents");
+    const lockFile = path23.join(subagentDir, lockName);
+    const workspaceDst = path23.join(subagentDir, `${path23.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path23.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -6412,8 +6944,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile7(wakeupDst, wakeupContent, "utf8");
+        await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile8(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -6423,8 +6955,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await writeFile7(wakeupDst, wakeupContent, "utf8");
+        await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await writeFile8(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -6432,8 +6964,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile7(wakeupDst, wakeupContent, "utf8");
+      await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile8(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -6441,15 +6973,15 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = path22.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = path22.join(subagentDir, ".github", "agents");
-    const workspaceDst = path22.join(subagentDir, `${path22.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = path22.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = path23.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = path23.join(subagentDir, ".github", "agents");
+    const workspaceDst = path23.join(subagentDir, `${path23.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = path23.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await writeFile7(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await writeFile7(wakeupDst, wakeupContent, "utf8");
+      await writeFile8(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await writeFile8(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -6628,7 +7160,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = path23.basename(absolutePath);
+    const fileName = path24.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -6653,8 +7185,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path23.resolve(attachment);
-    const normalized = absolutePath.split(path23.sep).join("/");
+    const absolutePath = path24.resolve(attachment);
+    const normalized = absolutePath.split(path24.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -6669,7 +7201,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = path23.resolve(attachment);
+    const absolutePath = path24.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -6677,7 +7209,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = path23.isAbsolute(filePath) ? filePath : path23.resolve(filePath);
+  const absolutePath = path24.isAbsolute(filePath) ? filePath : path24.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -6690,7 +7222,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(path23.resolve(attachment));
+    deduped.add(path24.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -6699,7 +7231,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(path23.resolve(inputFile));
+      deduped.add(path24.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -6746,9 +7278,9 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 }
 
 // src/evaluation/providers/targets-file.ts
-import { constants as constants4 } from "node:fs";
-import { access as access4, readFile as readFile9 } from "node:fs/promises";
-import path24 from "node:path";
+import { constants as constants5 } from "node:fs";
+import { access as access5, readFile as readFile9 } from "node:fs/promises";
+import path25 from "node:path";
 import { parse as parse3 } from "yaml";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -6778,14 +7310,14 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await access4(filePath, constants4.F_OK);
+    await access5(filePath, constants5.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = path24.resolve(filePath);
+  const absolutePath = path25.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
@@ -6817,6 +7349,8 @@ function createProvider(target) {
       return new CliProvider(target.name, target.config);
     case "codex":
       return new CodexProvider(target.name, target.config);
+    case "copilot-cli":
+      return new CopilotCliProvider(target.name, target.config);
     case "pi-coding-agent":
       return new PiCodingAgentProvider(target.name, target.config);
     case "pi-agent-sdk":
@@ -6953,10 +7487,10 @@ async function execFileWithStdinBun(argv, stdinPayload, options) {
   }
 }
 async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("node:child_process");
+  const { spawn: spawn6 } = await import("node:child_process");
   return new Promise((resolve, reject) => {
     const [cmd, ...args] = argv;
-    const child = spawn5(cmd, args, {
+    const child = spawn6(cmd, args, {
       cwd: options.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       // Merge additional env vars with process.env
@@ -6996,21 +7530,21 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir8, readFile: readFile10, rm: rm5, writeFile: writeFile8 } = await import("node:fs/promises");
-  const { tmpdir: tmpdir4 } = await import("node:os");
-  const path26 = await import("node:path");
-  const { randomUUID: randomUUID4 } = await import("node:crypto");
-  const dir = path26.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
-  await mkdir8(dir, { recursive: true });
-  const stdinPath = path26.join(dir, "stdin.txt");
-  const stdoutPath = path26.join(dir, "stdout.txt");
-  const stderrPath = path26.join(dir, "stderr.txt");
-  await writeFile8(stdinPath, stdinPayload, "utf8");
+  const { mkdir: mkdir9, readFile: readFile10, rm: rm6, writeFile: writeFile9 } = await import("node:fs/promises");
+  const { tmpdir: tmpdir5 } = await import("node:os");
+  const path27 = await import("node:path");
+  const { randomUUID: randomUUID5 } = await import("node:crypto");
+  const dir = path27.join(tmpdir5(), `agentv-exec-${randomUUID5()}`);
+  await mkdir9(dir, { recursive: true });
+  const stdinPath = path27.join(dir, "stdin.txt");
+  const stdoutPath = path27.join(dir, "stdout.txt");
+  const stderrPath = path27.join(dir, "stderr.txt");
+  await writeFile9(stdinPath, stdinPayload, "utf8");
   const wrappedCommand = process.platform === "win32" ? `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
-  const { spawn: spawn5 } = await import("node:child_process");
+  const { spawn: spawn6 } = await import("node:child_process");
   try {
     const exitCode = await new Promise((resolve, reject) => {
-      const child = spawn5(wrappedCommand, {
+      const child = spawn6(wrappedCommand, {
         shell: true,
         cwd: options.cwd,
         stdio: ["ignore", "ignore", "ignore"],
@@ -7038,7 +7572,7 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
     const stderr = (await readFile10(stderrPath, "utf8")).replace(/\r\n/g, "\n");
     return { stdout, stderr, exitCode };
   } finally {
-    await rm5(dir, { recursive: true, force: true });
+    await rm6(dir, { recursive: true, force: true });
   }
 }
 
@@ -7307,7 +7841,7 @@ var CodeEvaluator = class {
       outputMessages: context.outputMessages ?? null,
       guidelineFiles: context.evalCase.guideline_paths,
       inputFiles: context.evalCase.file_paths.filter(
-        (path26) => !context.evalCase.guideline_paths.includes(path26)
+        (path27) => !context.evalCase.guideline_paths.includes(path27)
       ),
       inputMessages: context.evalCase.input_messages,
       traceSummary: context.traceSummary ?? null,
@@ -8227,115 +8761,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path26, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path26);
-    const expectedValue = resolvePath(expectedData, path26);
+    const { path: path27, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path27);
+    const expectedValue = resolvePath(expectedData, path27);
     if (expectedValue === void 0) {
       return {
-        path: path26,
+        path: path27,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path26}: no expected value`
+        message: `${path27}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path26,
+          path: path27,
           score: 0,
           weight,
           hit: false,
-          message: `${path26} (required, missing)`
+          message: `${path27} (required, missing)`
         };
       }
       return {
-        path: path26,
+        path: path27,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path26}: optional field missing`
+        message: `${path27}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path26, candidateValue, expectedValue, weight);
+        return this.compareExact(path27, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path26,
+          path27,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path26, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path27, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path26,
+          path: path27,
           score: 0,
           weight,
           hit: false,
-          message: `${path26}: unknown match type "${match}"`
+          message: `${path27}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path26, candidateValue, expectedValue, weight) {
+  compareExact(path27, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path26,
+        path: path27,
         score: 1,
         weight,
         hit: true,
-        message: path26
+        message: path27
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path26,
+        path: path27,
         score: 0,
         weight,
         hit: false,
-        message: `${path26} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path27} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path26,
+      path: path27,
       score: 0,
       weight,
       hit: false,
-      message: `${path26} (value mismatch)`
+      message: `${path27} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path26, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path27, 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: path26,
+        path: path27,
         score: 0,
         weight,
         hit: false,
-        message: `${path26} (non-numeric value)`
+        message: `${path27} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path26,
+        path: path27,
         score: 0,
         weight,
         hit: false,
-        message: `${path26} (invalid numeric value)`
+        message: `${path27} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -8348,61 +8882,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path26,
+        path: path27,
         score: 1,
         weight,
         hit: true,
-        message: `${path26} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path27} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path26,
+      path: path27,
       score: 0,
       weight,
       hit: false,
-      message: `${path26} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path27} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path26, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path27, 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: path26,
+        path: path27,
         score: 0,
         weight,
         hit: false,
-        message: `${path26} (unparseable candidate date)`
+        message: `${path27} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path26,
+        path: path27,
         score: 0,
         weight,
         hit: false,
-        message: `${path26} (unparseable expected date)`
+        message: `${path27} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path26,
+        path: path27,
         score: 1,
         weight,
         hit: true,
-        message: path26
+        message: path27
       };
     }
     return {
-      path: path26,
+      path: path27,
       score: 0,
       weight,
       hit: false,
-      message: `${path26} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path27} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -8442,11 +8976,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path26) {
-  if (!path26 || !obj) {
+function resolvePath(obj, path27) {
+  if (!path27 || !obj) {
     return void 0;
   }
-  const parts = path26.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path27.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -8966,7 +9500,7 @@ var ToolTrajectoryEvaluator = class {
 
 // src/evaluation/orchestrator.ts
 import { createHash } from "node:crypto";
-import path25 from "node:path";
+import path26 from "node:path";
 import micromatch4 from "micromatch";
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -9769,7 +10303,7 @@ async function runEvaluatorList(options) {
         });
       }
       if (evaluator.type === "composite") {
-        const evalFileDir = evalCase.guideline_paths[0] ? path25.dirname(evalCase.guideline_paths[0]) : process.cwd();
+        const evalFileDir = evalCase.guideline_paths[0] ? path26.dirname(evalCase.guideline_paths[0]) : process.cwd();
         const createEvaluator = (memberConfig) => {
           switch (memberConfig.type) {
             case "llm_judge":
@@ -10125,7 +10659,7 @@ async function executePromptTemplate(script, context, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = path25.dirname(scriptPath);
+  const cwd = path26.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -10399,6 +10933,7 @@ export {
   computeTraceSummary,
   consumeClaudeCodeLogEntries,
   consumeCodexLogEntries,
+  consumeCopilotCliLogEntries,
   consumePiLogEntries,
   createAgentKernel,
   createProvider,
@@ -10438,6 +10973,7 @@ export {
   scoreToVerdict,
   subscribeToClaudeCodeLogEntries,
   subscribeToCodexLogEntries,
+  subscribeToCopilotCliLogEntries,
   subscribeToPiLogEntries,
   tokensPerTool
 };