@agentv/core 2.5.5 → 2.5.6

package/dist/index.cjs

@@ -49,6 +49,7 @@ __export(index_exports, {
   computeTraceSummary: () => computeTraceSummary,
   consumeClaudeCodeLogEntries: () => consumeClaudeCodeLogEntries,
   consumeCodexLogEntries: () => consumeCodexLogEntries,
+  consumeCopilotCliLogEntries: () => consumeCopilotCliLogEntries,
   consumePiLogEntries: () => consumePiLogEntries,
   createAgentKernel: () => createAgentKernel,
   createProvider: () => createProvider,
@@ -88,6 +89,7 @@ __export(index_exports, {
   scoreToVerdict: () => scoreToVerdict,
   subscribeToClaudeCodeLogEntries: () => subscribeToClaudeCodeLogEntries,
   subscribeToCodexLogEntries: () => subscribeToCodexLogEntries,
+  subscribeToCopilotCliLogEntries: () => subscribeToCopilotCliLogEntries,
   subscribeToPiLogEntries: () => subscribeToPiLogEntries,
   tokensPerTool: () => tokensPerTool
 });
@@ -3418,8 +3420,8 @@ async function runClaudeCodeWithTempFiles(options, stdoutFile, stderrFile, exitF
   };
   const fileExists4 = async (filePath) => {
     try {
-      const { access: access6 } = await import("fs/promises");
-      await access6(filePath);
+      const { access: access7 } = await import("fs/promises");
+      await access7(filePath);
       return true;
     } catch {
       return false;
@@ -4744,6 +4746,538 @@ function shouldShellExecute(executable) {
   return lower.endsWith(".cmd") || lower.endsWith(".bat") || lower.endsWith(".ps1");
 }
 
+// src/evaluation/providers/copilot-cli.ts
+var import_node_child_process4 = require("child_process");
+var import_node_crypto3 = require("crypto");
+var import_node_fs5 = require("fs");
+var import_promises12 = require("fs/promises");
+var import_node_os4 = require("os");
+var import_node_path13 = __toESM(require("path"), 1);
+var import_node_util3 = require("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 = (0, import_node_util3.promisify)(import_node_child_process4.exec);
+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 = import_node_path13.default.extname(originalPath);
+    const stem = import_node_path13.default.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 = import_node_path13.default.join(workspaceRoot, relativeName);
+    await (0, import_promises12.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 = import_node_path13.default.join(workspaceRoot, PROMPT_FILENAME3);
+      await (0, import_promises12.writeFile)(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 import_node_path13.default.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 (0, import_promises12.mkdtemp)(import_node_path13.default.join((0, import_node_os4.tmpdir)(), WORKSPACE_PREFIX3));
+  }
+  async cleanupWorkspace(workspaceRoot) {
+    try {
+      await (0, import_promises12.rm)(workspaceRoot, { recursive: true, force: true });
+    } catch {
+    }
+  }
+  resolveLogDirectory() {
+    const disabled = isCopilotLogStreamingDisabled();
+    if (disabled) {
+      return void 0;
+    }
+    if (this.config.logDir) {
+      return import_node_path13.default.resolve(this.config.logDir);
+    }
+    return import_node_path13.default.join(process.cwd(), ".agentv", "logs", "copilot-cli");
+  }
+  async createStreamLogger(request) {
+    const logDir = this.resolveLogDirectory();
+    if (!logDir) {
+      return void 0;
+    }
+    try {
+      await (0, import_promises12.mkdir)(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 = import_node_path13.default.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 = (0, import_node_fs5.createWriteStream)(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}_${(0, import_node_crypto3.randomUUID)().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 = import_node_path13.default.isAbsolute(candidate) ? candidate : import_node_path13.default.resolve(candidate);
+    await (0, import_promises12.access)(resolved, import_node_fs5.constants.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 (0, import_promises12.access)(lines[0], import_node_fs5.constants.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 = (0, import_node_child_process4.spawn)(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 {
@@ -4947,38 +5481,38 @@ function extractToolCalls2(content) {
 }
 
 // src/evaluation/providers/pi-coding-agent.ts
-var import_node_child_process4 = require("child_process");
-var import_node_crypto3 = require("crypto");
-var import_node_fs5 = require("fs");
-var import_promises12 = require("fs/promises");
-var import_node_os4 = require("os");
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_child_process5 = require("child_process");
+var import_node_crypto4 = require("crypto");
+var import_node_fs6 = require("fs");
+var import_promises13 = require("fs/promises");
+var import_node_os5 = require("os");
+var import_node_path14 = __toESM(require("path"), 1);
 
 // 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);
@@ -4990,7 +5524,7 @@ function notifySubscribers3(entry) {
 }
 function recordPiLogEntry(entry) {
   getPiLogStore().push(entry);
-  notifySubscribers3(entry);
+  notifySubscribers4(entry);
 }
 function consumePiLogEntries() {
   const store = getPiLogStore();
@@ -5000,7 +5534,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);
@@ -5008,9 +5542,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 ...\`.
@@ -5036,18 +5570,18 @@ var PiCodingAgentProvider = class {
     const workspaceRoot = await this.createWorkspace();
     const logger = await this.createStreamLogger(request).catch(() => void 0);
     try {
-      const promptFile = import_node_path13.default.join(workspaceRoot, PROMPT_FILENAME3);
-      await (0, import_promises12.writeFile)(promptFile, request.question, "utf8");
+      const promptFile = import_node_path14.default.join(workspaceRoot, PROMPT_FILENAME4);
+      await (0, import_promises13.writeFile)(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);
       }
@@ -5078,7 +5612,7 @@ var PiCodingAgentProvider = class {
     if (!this.config.cwd) {
       return workspaceRoot;
     }
-    return import_node_path13.default.resolve(this.config.cwd);
+    return import_node_path14.default.resolve(this.config.cwd);
   }
   buildPiArgs(prompt, inputFiles) {
     const args = [];
@@ -5108,7 +5642,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}`;
@@ -5167,19 +5701,19 @@ ${prompt}`;
     return env;
   }
   async createWorkspace() {
-    return await (0, import_promises12.mkdtemp)(import_node_path13.default.join((0, import_node_os4.tmpdir)(), WORKSPACE_PREFIX3));
+    return await (0, import_promises13.mkdtemp)(import_node_path14.default.join((0, import_node_os5.tmpdir)(), WORKSPACE_PREFIX4));
   }
   async cleanupWorkspace(workspaceRoot) {
     try {
-      await (0, import_promises12.rm)(workspaceRoot, { recursive: true, force: true });
+      await (0, import_promises13.rm)(workspaceRoot, { recursive: true, force: true });
     } catch {
     }
   }
   resolveLogDirectory() {
     if (this.config.logDir) {
-      return import_node_path13.default.resolve(this.config.logDir);
+      return import_node_path14.default.resolve(this.config.logDir);
     }
-    return import_node_path13.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
+    return import_node_path14.default.join(process.cwd(), ".agentv", "logs", "pi-coding-agent");
   }
   async createStreamLogger(request) {
     const logDir = this.resolveLogDirectory();
@@ -5187,13 +5721,13 @@ ${prompt}`;
       return void 0;
     }
     try {
-      await (0, import_promises12.mkdir)(logDir, { recursive: true });
+      await (0, import_promises13.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_path13.default.join(logDir, buildLogFilename3(request, this.targetName));
+    const filePath = import_node_path14.default.join(logDir, buildLogFilename4(request, this.targetName));
     try {
       const logger = await PiStreamLogger.create({
         filePath,
@@ -5226,7 +5760,7 @@ var PiStreamLogger = class _PiStreamLogger {
   constructor(filePath, format) {
     this.filePath = filePath;
     this.format = format;
-    this.stream = (0, import_node_fs5.createWriteStream)(filePath, { flags: "a" });
+    this.stream = (0, import_node_fs6.createWriteStream)(filePath, { flags: "a" });
   }
   static async create(options) {
     const logger = new _PiStreamLogger(options.filePath, options.format);
@@ -5287,7 +5821,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();
@@ -5310,18 +5844,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}_${(0, import_node_crypto3.randomUUID)().slice(0, 8)}.log`;
+  const target = sanitizeForFilename4(targetName);
+  return `${timestamp}_${target}_${evalId}${attemptSuffix}_${(0, import_node_crypto4.randomUUID)().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);
@@ -5542,7 +6076,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;
@@ -5550,7 +6084,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 "";
   }
@@ -5563,7 +6097,7 @@ async function defaultPiRunner(options) {
     const executable = parts[0];
     const executableArgs = parts.slice(1);
     const allArgs = [...executableArgs, ...options.args];
-    const child = (0, import_node_child_process4.spawn)(executable, allArgs, {
+    const child = (0, import_node_child_process5.spawn)(executable, allArgs, {
       cwd: options.cwd,
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -5626,7 +6160,7 @@ async function defaultPiRunner(options) {
 }
 
 // src/evaluation/providers/targets.ts
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_zod2 = require("zod");
 var CliHealthcheckHttpInputSchema = import_zod2.z.object({
   type: import_zod2.z.literal("http"),
@@ -5732,11 +6266,11 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path14.default.isAbsolute(cwd)) {
-    cwd = import_node_path14.default.resolve(import_node_path14.default.dirname(import_node_path14.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path15.default.isAbsolute(cwd)) {
+    cwd = import_node_path15.default.resolve(import_node_path15.default.dirname(import_node_path15.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path14.default.dirname(import_node_path14.default.resolve(evalFilePath));
+    cwd = import_node_path15.default.dirname(import_node_path15.default.resolve(evalFilePath));
   }
   return {
     type: "command",
@@ -5763,11 +6297,11 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
     allowLiteral: true,
     optionalEnv: true
   });
-  if (cwd && evalFilePath && !import_node_path14.default.isAbsolute(cwd)) {
-    cwd = import_node_path14.default.resolve(import_node_path14.default.dirname(import_node_path14.default.resolve(evalFilePath)), cwd);
+  if (cwd && evalFilePath && !import_node_path15.default.isAbsolute(cwd)) {
+    cwd = import_node_path15.default.resolve(import_node_path15.default.dirname(import_node_path15.default.resolve(evalFilePath)), cwd);
   }
   if (!cwd && evalFilePath) {
-    cwd = import_node_path14.default.dirname(import_node_path14.default.resolve(evalFilePath));
+    cwd = import_node_path15.default.dirname(import_node_path15.default.resolve(evalFilePath));
   }
   const timeoutSeconds = input.timeout_seconds ?? input.timeoutSeconds;
   const timeoutMs = timeoutSeconds !== void 0 ? Math.floor(timeoutSeconds * 1e3) : void 0;
@@ -5891,6 +6425,15 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         providerBatching,
         config: resolveCodexConfig(parsed, env)
       };
+    case "copilot-cli":
+      return {
+        kind: "copilot-cli",
+        name: parsed.name,
+        judgeTarget: parsed.judge_target,
+        workers: parsed.workers,
+        providerBatching,
+        config: resolveCopilotConfig(parsed, env)
+      };
     case "pi":
     case "pi-coding-agent":
       return {
@@ -6067,6 +6610,44 @@ function normalizeCodexLogFormat(value) {
   }
   throw new Error("codex log format must be 'summary' or 'json'");
 }
+function resolveCopilotConfig(target, env) {
+  const executableSource = target.executable ?? target.command ?? target.binary;
+  const modelSource = target.model;
+  const argsSource = target.args ?? target.arguments;
+  const cwdSource = target.cwd;
+  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 ?? target.log_output_format ?? target.logOutputFormat;
+  const systemPromptSource = target.system_prompt ?? target.systemPrompt;
+  const executable = resolveOptionalString(executableSource, env, `${target.name} copilot executable`, {
+    allowLiteral: true,
+    optionalEnv: true
+  }) ?? "copilot";
+  const model = resolveOptionalString(modelSource, env, `${target.name} copilot model`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const args = resolveOptionalStringArray(argsSource, env, `${target.name} copilot args`);
+  const cwd = resolveOptionalString(cwdSource, env, `${target.name} copilot cwd`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} copilot timeout`);
+  const logDir = resolveOptionalString(logDirSource, env, `${target.name} copilot log directory`, {
+    allowLiteral: true,
+    optionalEnv: true
+  });
+  const logFormat = normalizeCopilotLogFormat(logFormatSource);
+  const systemPrompt = typeof systemPromptSource === "string" && systemPromptSource.trim().length > 0 ? systemPromptSource.trim() : void 0;
+  return { executable, model, args, cwd, timeoutMs, logDir, logFormat, systemPrompt };
+}
+function normalizeCopilotLogFormat(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error("copilot log format must be 'summary' or 'json'");
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "json" || normalized === "summary") return normalized;
+  throw new Error("copilot log format must be 'summary' or 'json'");
+}
 function resolvePiCodingAgentConfig(target, env) {
   const executableSource = target.executable ?? target.command ?? target.binary;
   const providerSource = target.pi_provider ?? target.piProvider ?? target.llm_provider;
@@ -6272,8 +6853,8 @@ function resolveCliConfig(target, env, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
-    const path28 = firstError?.path.join(".") || "";
-    const prefix = path28 ? `${target.name} ${path28}: ` : `${target.name}: `;
+    const path29 = firstError?.path.join(".") || "";
+    const prefix = path29 ? `${target.name} ${path29}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
   const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
@@ -6461,38 +7042,38 @@ function resolveOptionalNumberArray(source, description) {
 }
 
 // src/evaluation/providers/vscode-provider.ts
-var import_node_path25 = __toESM(require("path"), 1);
+var import_node_path26 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/dispatch/agentDispatch.ts
-var import_promises17 = require("fs/promises");
-var import_node_path23 = __toESM(require("path"), 1);
+var import_promises18 = require("fs/promises");
+var import_node_path24 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/fs.ts
-var import_node_fs6 = require("fs");
-var import_promises13 = require("fs/promises");
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+var import_promises14 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
 async function pathExists(target) {
   try {
-    await (0, import_promises13.access)(target, import_node_fs6.constants.F_OK);
+    await (0, import_promises14.access)(target, import_node_fs7.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function ensureDir(target) {
-  await (0, import_promises13.mkdir)(target, { recursive: true });
+  await (0, import_promises14.mkdir)(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await (0, import_promises13.readdir)(target, { withFileTypes: true });
+  const entries = await (0, import_promises14.readdir)(target, { withFileTypes: true });
   return entries.map((entry) => ({
     name: entry.name,
-    absolutePath: import_node_path15.default.join(target, entry.name),
+    absolutePath: import_node_path16.default.join(target, entry.name),
     isDirectory: entry.isDirectory()
   }));
 }
 async function removeIfExists(target) {
   try {
-    await (0, import_promises13.rm)(target, { force: true, recursive: false });
+    await (0, import_promises14.rm)(target, { force: true, recursive: false });
   } catch (error) {
     if (error.code !== "ENOENT") {
       throw error;
@@ -6501,9 +7082,9 @@ async function removeIfExists(target) {
 }
 
 // src/evaluation/providers/vscode/utils/path.ts
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 function pathToFileUri2(filePath) {
-  const absolutePath = import_node_path16.default.isAbsolute(filePath) ? filePath : import_node_path16.default.resolve(filePath);
+  const absolutePath = import_node_path17.default.isAbsolute(filePath) ? filePath : import_node_path17.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -6512,7 +7093,7 @@ function pathToFileUri2(filePath) {
 }
 
 // src/evaluation/providers/vscode/dispatch/promptBuilder.ts
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/template.ts
 function renderTemplate2(content, variables) {
@@ -6604,8 +7185,8 @@ function createBatchRequestPrompt(userQuery, responseFileTmp, responseFileFinal,
   });
 }
 function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateContent) {
-  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path17.default.basename(file)}`).join("\n");
-  const responseList = responseFiles.map((file) => `"${import_node_path17.default.basename(file)}"`).join(", ");
+  const requestLines = requestFiles.map((file, index) => `${index + 1}. messages/${import_node_path18.default.basename(file)}`).join("\n");
+  const responseList = responseFiles.map((file) => `"${import_node_path18.default.basename(file)}"`).join(", ");
   return renderTemplate2(templateContent, {
     requestFiles: requestLines,
     responseList
@@ -6613,8 +7194,8 @@ function createBatchOrchestratorPrompt(requestFiles, responseFiles, templateCont
 }
 
 // src/evaluation/providers/vscode/dispatch/responseWaiter.ts
-var import_promises14 = require("fs/promises");
-var import_node_path18 = __toESM(require("path"), 1);
+var import_promises15 = require("fs/promises");
+var import_node_path19 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/time.ts
 function sleep2(ms) {
@@ -6642,7 +7223,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
   const maxAttempts = 10;
   while (attempts < maxAttempts) {
     try {
-      const content = await (0, import_promises14.readFile)(responseFileFinal, { encoding: "utf8" });
+      const content = await (0, import_promises15.readFile)(responseFileFinal, { encoding: "utf8" });
       if (!silent) {
         process.stdout.write(`${content}
 `);
@@ -6663,7 +7244,7 @@ async function waitForResponseOutput(responseFileFinal, pollInterval = 1e3, sile
 }
 async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, silent = false) {
   if (!silent) {
-    const fileList = responseFilesFinal.map((file) => import_node_path18.default.basename(file)).join(", ");
+    const fileList = responseFilesFinal.map((file) => import_node_path19.default.basename(file)).join(", ");
     console.error(`waiting for ${responseFilesFinal.length} batch response(s): ${fileList}`);
   }
   try {
@@ -6689,7 +7270,7 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
     const maxAttempts = 10;
     while (attempts < maxAttempts) {
       try {
-        const content = await (0, import_promises14.readFile)(file, { encoding: "utf8" });
+        const content = await (0, import_promises15.readFile)(file, { encoding: "utf8" });
         if (!silent) {
           process.stdout.write(`${content}
 `);
@@ -6711,31 +7292,31 @@ async function waitForBatchResponses(responseFilesFinal, pollInterval = 1e3, sil
 }
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var import_node_child_process5 = require("child_process");
-var import_promises15 = require("fs/promises");
-var import_node_path20 = __toESM(require("path"), 1);
-var import_node_util3 = require("util");
+var import_node_child_process6 = require("child_process");
+var import_promises16 = require("fs/promises");
+var import_node_path21 = __toESM(require("path"), 1);
+var import_node_util4 = require("util");
 
 // src/evaluation/providers/vscode/dispatch/constants.ts
-var import_node_os5 = __toESM(require("os"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_os6 = __toESM(require("os"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 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_path19.default.join(import_node_os5.default.homedir(), ".agentv", "subagents", folder);
+  return import_node_path20.default.join(import_node_os6.default.homedir(), ".agentv", "subagents", folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
 // src/evaluation/providers/vscode/dispatch/vscodeProcess.ts
-var execAsync3 = (0, import_node_util3.promisify)(import_node_child_process5.exec);
+var execAsync4 = (0, import_node_util4.promisify)(import_node_child_process6.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
     });
@@ -6747,16 +7328,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) {
-    (0, import_node_child_process5.spawn)(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+    (0, import_node_child_process6.spawn)(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
     return true;
   }
-  const aliveFile = import_node_path20.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
+  const aliveFile = import_node_path21.default.join(subagentDir, DEFAULT_ALIVE_FILENAME);
   await removeIfExists(aliveFile);
-  const githubAgentsDir = import_node_path20.default.join(subagentDir, ".github", "agents");
-  await (0, import_promises15.mkdir)(githubAgentsDir, { recursive: true });
-  const wakeupDst = import_node_path20.default.join(githubAgentsDir, "wakeup.md");
-  await (0, import_promises15.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
-  (0, import_node_child_process5.spawn)(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
+  const githubAgentsDir = import_node_path21.default.join(subagentDir, ".github", "agents");
+  await (0, import_promises16.mkdir)(githubAgentsDir, { recursive: true });
+  const wakeupDst = import_node_path21.default.join(githubAgentsDir, "wakeup.md");
+  await (0, import_promises16.writeFile)(wakeupDst, DEFAULT_WAKEUP_CONTENT, "utf8");
+  (0, import_node_child_process6.spawn)(vscodeCmd, [workspacePath], { windowsHide: true, shell: true, detached: false });
   await sleep2(100);
   const wakeupChatId = "wakeup";
   const chatArgs = [
@@ -6764,9 +7345,9 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
     "chat",
     "-m",
     wakeupChatId,
-    `create a file named .alive in the ${import_node_path20.default.basename(subagentDir)} folder`
+    `create a file named .alive in the ${import_node_path21.default.basename(subagentDir)} folder`
   ];
-  (0, import_node_child_process5.spawn)(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+  (0, import_node_child_process6.spawn)(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
   const start = Date.now();
   while (!await pathExists(aliveFile)) {
     if (Date.now() - start > timeout * 1e3) {
@@ -6779,21 +7360,21 @@ async function ensureWorkspaceFocused(workspacePath, workspaceName, subagentDir,
 }
 async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, requestInstructions, timestamp, vscodeCmd) {
   try {
-    const workspacePath = import_node_path20.default.join(subagentDir, `${import_node_path20.default.basename(subagentDir)}.code-workspace`);
-    const messagesDir = import_node_path20.default.join(subagentDir, "messages");
-    await (0, import_promises15.mkdir)(messagesDir, { recursive: true });
-    const reqFile = import_node_path20.default.join(messagesDir, `${timestamp}_req.md`);
-    await (0, import_promises15.writeFile)(reqFile, requestInstructions, { encoding: "utf8" });
+    const workspacePath = import_node_path21.default.join(subagentDir, `${import_node_path21.default.basename(subagentDir)}.code-workspace`);
+    const messagesDir = import_node_path21.default.join(subagentDir, "messages");
+    await (0, import_promises16.mkdir)(messagesDir, { recursive: true });
+    const reqFile = import_node_path21.default.join(messagesDir, `${timestamp}_req.md`);
+    await (0, import_promises16.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_path20.default.basename(reqFile)}](${reqUri})`);
+    chatArgs.push(`Follow instructions in [${import_node_path21.default.basename(reqFile)}](${reqUri})`);
     const workspaceReady = await ensureWorkspaceFocused(
       workspacePath,
-      import_node_path20.default.basename(subagentDir),
+      import_node_path21.default.basename(subagentDir),
       subagentDir,
       vscodeCmd
     );
@@ -6801,7 +7382,7 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
       console.error("warning: Workspace may not be fully ready");
     }
     await sleep2(500);
-    (0, import_node_child_process5.spawn)(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+    (0, import_node_child_process6.spawn)(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
     return true;
   } catch (error) {
     console.error(`warning: Failed to launch VS Code: ${error.message}`);
@@ -6810,9 +7391,9 @@ async function launchVsCodeWithChat(subagentDir, chatId, attachmentPaths, reques
 }
 async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, chatInstruction, vscodeCmd) {
   try {
-    const workspacePath = import_node_path20.default.join(subagentDir, `${import_node_path20.default.basename(subagentDir)}.code-workspace`);
-    const messagesDir = import_node_path20.default.join(subagentDir, "messages");
-    await (0, import_promises15.mkdir)(messagesDir, { recursive: true });
+    const workspacePath = import_node_path21.default.join(subagentDir, `${import_node_path21.default.basename(subagentDir)}.code-workspace`);
+    const messagesDir = import_node_path21.default.join(subagentDir, "messages");
+    await (0, import_promises16.mkdir)(messagesDir, { recursive: true });
     const chatArgs = ["-r", "chat", "-m", chatId];
     for (const attachment of attachmentPaths) {
       chatArgs.push("-a", attachment);
@@ -6820,7 +7401,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
     chatArgs.push(chatInstruction);
     const workspaceReady = await ensureWorkspaceFocused(
       workspacePath,
-      import_node_path20.default.basename(subagentDir),
+      import_node_path21.default.basename(subagentDir),
       subagentDir,
       vscodeCmd
     );
@@ -6828,7 +7409,7 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
       console.error("warning: Workspace may not be fully ready");
     }
     await sleep2(500);
-    (0, import_node_child_process5.spawn)(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
+    (0, import_node_child_process6.spawn)(vscodeCmd, chatArgs, { windowsHide: true, shell: true, detached: false });
     return true;
   } catch (error) {
     console.error(`warning: Failed to launch VS Code: ${error.message}`);
@@ -6837,11 +7418,11 @@ async function launchVsCodeWithBatchChat(subagentDir, chatId, attachmentPaths, c
 }
 
 // src/evaluation/providers/vscode/dispatch/workspaceManager.ts
-var import_promises16 = require("fs/promises");
-var import_node_path22 = __toESM(require("path"), 1);
+var import_promises17 = require("fs/promises");
+var import_node_path23 = __toESM(require("path"), 1);
 
 // src/evaluation/providers/vscode/utils/workspace.ts
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_path22 = __toESM(require("path"), 1);
 var import_json5 = __toESM(require("json5"), 1);
 function transformWorkspacePaths(workspaceContent, templateDir) {
   let workspace;
@@ -6858,10 +7439,10 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
   }
   const transformedFolders = workspace.folders.map((folder) => {
     const folderPath = folder.path;
-    if (import_node_path21.default.isAbsolute(folderPath)) {
+    if (import_node_path22.default.isAbsolute(folderPath)) {
       return folder;
     }
-    const absolutePath = import_node_path21.default.resolve(templateDir, folderPath);
+    const absolutePath = import_node_path22.default.resolve(templateDir, folderPath);
     return {
       ...folder,
       path: absolutePath
@@ -6883,19 +7464,19 @@ function transformWorkspacePaths(workspaceContent, templateDir) {
       if (locationMap && typeof locationMap === "object") {
         const transformedMap = {};
         for (const [locationPath, value] of Object.entries(locationMap)) {
-          const isAbsolute = import_node_path21.default.isAbsolute(locationPath);
+          const isAbsolute = import_node_path22.default.isAbsolute(locationPath);
           if (isAbsolute) {
             transformedMap[locationPath] = value;
           } else {
             const firstGlobIndex = locationPath.search(/[*]/);
             if (firstGlobIndex === -1) {
-              const resolvedPath = import_node_path21.default.resolve(templateDir, locationPath).replace(/\\/g, "/");
+              const resolvedPath = import_node_path22.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_path21.default.resolve(templateDir, basePath) + patternPath).replace(
+              const resolvedPath = (import_node_path22.default.resolve(templateDir, basePath) + patternPath).replace(
                 /\\/g,
                 "/"
               );
@@ -6936,7 +7517,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_path22.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
+    const lockFile = import_node_path23.default.join(subagent.absolutePath, DEFAULT_LOCK_NAME);
     if (!await pathExists(lockFile)) {
       return subagent.absolutePath;
     }
@@ -6946,54 +7527,54 @@ async function findUnlockedSubagent(subagentRoot) {
 async function copyAgentConfig(subagentDir, workspaceTemplate) {
   let workspaceContent;
   if (workspaceTemplate) {
-    const workspaceSrc = import_node_path22.default.resolve(workspaceTemplate);
+    const workspaceSrc = import_node_path23.default.resolve(workspaceTemplate);
     if (!await pathExists(workspaceSrc)) {
       throw new Error(`workspace template not found: ${workspaceSrc}`);
     }
-    const stats = await (0, import_promises16.stat)(workspaceSrc);
+    const stats = await (0, import_promises17.stat)(workspaceSrc);
     if (!stats.isFile()) {
       throw new Error(`workspace template must be a file, not a directory: ${workspaceSrc}`);
     }
-    const templateText = await (0, import_promises16.readFile)(workspaceSrc, "utf8");
+    const templateText = await (0, import_promises17.readFile)(workspaceSrc, "utf8");
     workspaceContent = JSON.parse(templateText);
   } else {
     workspaceContent = DEFAULT_WORKSPACE_TEMPLATE;
   }
-  const workspaceName = `${import_node_path22.default.basename(subagentDir)}.code-workspace`;
-  const workspaceDst = import_node_path22.default.join(subagentDir, workspaceName);
-  const templateDir = workspaceTemplate ? import_node_path22.default.dirname(import_node_path22.default.resolve(workspaceTemplate)) : subagentDir;
+  const workspaceName = `${import_node_path23.default.basename(subagentDir)}.code-workspace`;
+  const workspaceDst = import_node_path23.default.join(subagentDir, workspaceName);
+  const templateDir = workspaceTemplate ? import_node_path23.default.dirname(import_node_path23.default.resolve(workspaceTemplate)) : subagentDir;
   const workspaceJson = JSON.stringify(workspaceContent, null, 2);
   const transformedContent = transformWorkspacePaths(workspaceJson, templateDir);
-  await (0, import_promises16.writeFile)(workspaceDst, transformedContent, "utf8");
-  const messagesDir = import_node_path22.default.join(subagentDir, "messages");
-  await (0, import_promises16.mkdir)(messagesDir, { recursive: true });
+  await (0, import_promises17.writeFile)(workspaceDst, transformedContent, "utf8");
+  const messagesDir = import_node_path23.default.join(subagentDir, "messages");
+  await (0, import_promises17.mkdir)(messagesDir, { recursive: true });
   return { workspace: workspaceDst, messagesDir };
 }
 async function createSubagentLock(subagentDir) {
-  const messagesDir = import_node_path22.default.join(subagentDir, "messages");
+  const messagesDir = import_node_path23.default.join(subagentDir, "messages");
   if (await pathExists(messagesDir)) {
-    const files = await (0, import_promises16.readdir)(messagesDir);
+    const files = await (0, import_promises17.readdir)(messagesDir);
     await Promise.all(
       files.map(async (file) => {
-        const target = import_node_path22.default.join(messagesDir, file);
+        const target = import_node_path23.default.join(messagesDir, file);
         await removeIfExists(target);
       })
     );
   }
-  const githubAgentsDir = import_node_path22.default.join(subagentDir, ".github", "agents");
+  const githubAgentsDir = import_node_path23.default.join(subagentDir, ".github", "agents");
   if (await pathExists(githubAgentsDir)) {
-    const agentFiles = await (0, import_promises16.readdir)(githubAgentsDir);
+    const agentFiles = await (0, import_promises17.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_path22.default.join(githubAgentsDir, file)))
+      agentFiles.filter((file) => file.endsWith(".md") && !preservedFiles.has(file)).map((file) => removeIfExists(import_node_path23.default.join(githubAgentsDir, file)))
     );
   }
-  const lockFile = import_node_path22.default.join(subagentDir, DEFAULT_LOCK_NAME);
-  await (0, import_promises16.writeFile)(lockFile, "", { encoding: "utf8" });
+  const lockFile = import_node_path23.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  await (0, import_promises17.writeFile)(lockFile, "", { encoding: "utf8" });
   return lockFile;
 }
 async function removeSubagentLock(subagentDir) {
-  const lockFile = import_node_path22.default.join(subagentDir, DEFAULT_LOCK_NAME);
+  const lockFile = import_node_path23.default.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
 async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
@@ -7013,11 +7594,11 @@ async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspa
     return 1;
   }
   if (promptFile) {
-    const githubAgentsDir = import_node_path22.default.join(subagentDir, ".github", "agents");
-    await (0, import_promises16.mkdir)(githubAgentsDir, { recursive: true });
-    const agentFile = import_node_path22.default.join(githubAgentsDir, `${chatId}.md`);
+    const githubAgentsDir = import_node_path23.default.join(subagentDir, ".github", "agents");
+    await (0, import_promises17.mkdir)(githubAgentsDir, { recursive: true });
+    const agentFile = import_node_path23.default.join(githubAgentsDir, `${chatId}.md`);
     try {
-      await (0, import_promises16.copyFile)(promptFile, agentFile);
+      await (0, import_promises17.copyFile)(promptFile, agentFile);
     } catch (error) {
       console.error(`error: Failed to copy prompt file to agent mode: ${error.message}`);
       return 1;
@@ -7034,11 +7615,11 @@ async function resolvePromptFile(promptFile) {
   if (!promptFile) {
     return void 0;
   }
-  const resolvedPrompt = import_node_path23.default.resolve(promptFile);
+  const resolvedPrompt = import_node_path24.default.resolve(promptFile);
   if (!await pathExists(resolvedPrompt)) {
     throw new Error(`Prompt file not found: ${resolvedPrompt}`);
   }
-  const promptStats = await (0, import_promises17.stat)(resolvedPrompt);
+  const promptStats = await (0, import_promises18.stat)(resolvedPrompt);
   if (!promptStats.isFile()) {
     throw new Error(`Prompt file must be a file, not a directory: ${resolvedPrompt}`);
   }
@@ -7050,7 +7631,7 @@ async function resolveAttachments(extraAttachments) {
   }
   const resolved = [];
   for (const attachment of extraAttachments) {
-    const resolvedPath = import_node_path23.default.resolve(attachment);
+    const resolvedPath = import_node_path24.default.resolve(attachment);
     if (!await pathExists(resolvedPath)) {
       throw new Error(`Attachment not found: ${resolvedPath}`);
     }
@@ -7090,7 +7671,7 @@ async function dispatchAgentSession(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    const subagentName = import_node_path23.default.basename(subagentDir);
+    const subagentName = import_node_path24.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -7117,9 +7698,9 @@ async function dispatchAgentSession(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path23.default.join(subagentDir, "messages");
-    const responseFileTmp = import_node_path23.default.join(messagesDir, `${timestamp}_res.tmp.md`);
-    const responseFileFinal = import_node_path23.default.join(messagesDir, `${timestamp}_res.md`);
+    const messagesDir = import_node_path24.default.join(subagentDir, "messages");
+    const responseFileTmp = import_node_path24.default.join(messagesDir, `${timestamp}_res.tmp.md`);
+    const responseFileFinal = import_node_path24.default.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(
       userQuery,
       responseFileTmp,
@@ -7232,7 +7813,7 @@ async function dispatchBatchAgent(options) {
         error: "No unlocked subagents available. Provision additional subagents with: subagent code provision --subagents <desired_total>"
       };
     }
-    subagentName = import_node_path23.default.basename(subagentDir);
+    subagentName = import_node_path24.default.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
     const preparationResult = await prepareSubagentDirectory(
       subagentDir,
@@ -7263,24 +7844,24 @@ async function dispatchBatchAgent(options) {
       };
     }
     const timestamp = generateTimestamp();
-    const messagesDir = import_node_path23.default.join(subagentDir, "messages");
+    const messagesDir = import_node_path24.default.join(subagentDir, "messages");
     requestFiles = userQueries.map(
-      (_, index) => import_node_path23.default.join(messagesDir, `${timestamp}_${index}_req.md`)
+      (_, index) => import_node_path24.default.join(messagesDir, `${timestamp}_${index}_req.md`)
     );
     const responseTmpFiles = userQueries.map(
-      (_, index) => import_node_path23.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
+      (_, index) => import_node_path24.default.join(messagesDir, `${timestamp}_${index}_res.tmp.md`)
     );
     responseFilesFinal = userQueries.map(
-      (_, index) => import_node_path23.default.join(messagesDir, `${timestamp}_${index}_res.md`)
+      (_, index) => import_node_path24.default.join(messagesDir, `${timestamp}_${index}_res.md`)
     );
-    const orchestratorFile = import_node_path23.default.join(messagesDir, `${timestamp}_orchestrator.md`);
+    const orchestratorFile = import_node_path24.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_promises17.writeFile)(
+          return (0, import_promises18.writeFile)(
             reqFile,
             createBatchRequestPrompt(query, tmpFile, finalFile, batchRequestTemplateContent),
             { encoding: "utf8" }
@@ -7292,7 +7873,7 @@ async function dispatchBatchAgent(options) {
         responseFilesFinal,
         orchestratorTemplateContent
       );
-      await (0, import_promises17.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
+      await (0, import_promises18.writeFile)(orchestratorFile, orchestratorContent, { encoding: "utf8" });
     }
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri2(orchestratorFile);
@@ -7362,8 +7943,8 @@ async function dispatchBatchAgent(options) {
 }
 
 // src/evaluation/providers/vscode/dispatch/provision.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);
 var DEFAULT_WORKSPACE_TEMPLATE2 = {
   folders: [
     {
@@ -7394,7 +7975,7 @@ async function provisionSubagents(options) {
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
-  const targetPath = import_node_path24.default.resolve(targetRoot);
+  const targetPath = import_node_path25.default.resolve(targetRoot);
   if (!dryRun) {
     await ensureDir(targetPath);
   }
@@ -7414,7 +7995,7 @@ async function provisionSubagents(options) {
         continue;
       }
       highestNumber = Math.max(highestNumber, parsed);
-      const lockFile = import_node_path24.default.join(entry.absolutePath, lockName);
+      const lockFile = import_node_path25.default.join(entry.absolutePath, lockName);
       const locked = await pathExists(lockFile);
       if (locked) {
         lockedSubagents.add(entry.absolutePath);
@@ -7431,10 +8012,10 @@ async function provisionSubagents(options) {
       break;
     }
     const subagentDir = subagent.absolutePath;
-    const githubAgentsDir = import_node_path24.default.join(subagentDir, ".github", "agents");
-    const lockFile = import_node_path24.default.join(subagentDir, lockName);
-    const workspaceDst = import_node_path24.default.join(subagentDir, `${import_node_path24.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path24.default.join(githubAgentsDir, "wakeup.md");
+    const githubAgentsDir = import_node_path25.default.join(subagentDir, ".github", "agents");
+    const lockFile = import_node_path25.default.join(subagentDir, lockName);
+    const workspaceDst = import_node_path25.default.join(subagentDir, `${import_node_path25.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path25.default.join(githubAgentsDir, "wakeup.md");
     const isLocked = await pathExists(lockFile);
     if (isLocked && !force) {
       continue;
@@ -7443,8 +8024,8 @@ async function provisionSubagents(options) {
       if (!dryRun) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
-        await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises19.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises19.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       lockedSubagents.delete(subagentDir);
@@ -7454,8 +8035,8 @@ async function provisionSubagents(options) {
     if (!isLocked && force) {
       if (!dryRun) {
         await ensureDir(githubAgentsDir);
-        await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-        await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+        await (0, import_promises19.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+        await (0, import_promises19.writeFile)(wakeupDst, wakeupContent, "utf8");
       }
       created.push(subagentDir);
       subagentsProvisioned += 1;
@@ -7463,8 +8044,8 @@ async function provisionSubagents(options) {
     }
     if (!dryRun && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
-      await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises19.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises19.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     skippedExisting.push(subagentDir);
     subagentsProvisioned += 1;
@@ -7472,15 +8053,15 @@ async function provisionSubagents(options) {
   let nextIndex = highestNumber;
   while (subagentsProvisioned < subagents) {
     nextIndex += 1;
-    const subagentDir = import_node_path24.default.join(targetPath, `subagent-${nextIndex}`);
-    const githubAgentsDir = import_node_path24.default.join(subagentDir, ".github", "agents");
-    const workspaceDst = import_node_path24.default.join(subagentDir, `${import_node_path24.default.basename(subagentDir)}.code-workspace`);
-    const wakeupDst = import_node_path24.default.join(githubAgentsDir, "wakeup.md");
+    const subagentDir = import_node_path25.default.join(targetPath, `subagent-${nextIndex}`);
+    const githubAgentsDir = import_node_path25.default.join(subagentDir, ".github", "agents");
+    const workspaceDst = import_node_path25.default.join(subagentDir, `${import_node_path25.default.basename(subagentDir)}.code-workspace`);
+    const wakeupDst = import_node_path25.default.join(githubAgentsDir, "wakeup.md");
     if (!dryRun) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
-      await (0, import_promises18.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
-      await (0, import_promises18.writeFile)(wakeupDst, wakeupContent, "utf8");
+      await (0, import_promises19.writeFile)(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
+      await (0, import_promises19.writeFile)(wakeupDst, wakeupContent, "utf8");
     }
     created.push(subagentDir);
     subagentsProvisioned += 1;
@@ -7659,7 +8240,7 @@ function buildMandatoryPrereadBlock2(guidelineFiles, attachmentFiles) {
     return "";
   }
   const buildList = (files) => files.map((absolutePath) => {
-    const fileName = import_node_path25.default.basename(absolutePath);
+    const fileName = import_node_path26.default.basename(absolutePath);
     const fileUri = pathToFileUri3(absolutePath);
     return `* [${fileName}](${fileUri})`;
   });
@@ -7684,8 +8265,8 @@ function collectGuidelineFiles2(attachments, guidelinePatterns) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path25.default.resolve(attachment);
-    const normalized = absolutePath.split(import_node_path25.default.sep).join("/");
+    const absolutePath = import_node_path26.default.resolve(attachment);
+    const normalized = absolutePath.split(import_node_path26.default.sep).join("/");
     if (isGuidelineFile(normalized, guidelinePatterns)) {
       if (!unique.has(absolutePath)) {
         unique.set(absolutePath, absolutePath);
@@ -7700,7 +8281,7 @@ function collectAttachmentFiles(attachments) {
   }
   const unique = /* @__PURE__ */ new Map();
   for (const attachment of attachments) {
-    const absolutePath = import_node_path25.default.resolve(attachment);
+    const absolutePath = import_node_path26.default.resolve(attachment);
     if (!unique.has(absolutePath)) {
       unique.set(absolutePath, absolutePath);
     }
@@ -7708,7 +8289,7 @@ function collectAttachmentFiles(attachments) {
   return Array.from(unique.values());
 }
 function pathToFileUri3(filePath) {
-  const absolutePath = import_node_path25.default.isAbsolute(filePath) ? filePath : import_node_path25.default.resolve(filePath);
+  const absolutePath = import_node_path26.default.isAbsolute(filePath) ? filePath : import_node_path26.default.resolve(filePath);
   const normalizedPath = absolutePath.replace(/\\/g, "/");
   if (/^[a-zA-Z]:\//.test(normalizedPath)) {
     return `file:///${normalizedPath}`;
@@ -7721,7 +8302,7 @@ function normalizeAttachments(attachments) {
   }
   const deduped = /* @__PURE__ */ new Set();
   for (const attachment of attachments) {
-    deduped.add(import_node_path25.default.resolve(attachment));
+    deduped.add(import_node_path26.default.resolve(attachment));
   }
   return Array.from(deduped);
 }
@@ -7730,7 +8311,7 @@ function mergeAttachments(all) {
   for (const list of all) {
     if (!list) continue;
     for (const inputFile of list) {
-      deduped.add(import_node_path25.default.resolve(inputFile));
+      deduped.add(import_node_path26.default.resolve(inputFile));
     }
   }
   return deduped.size > 0 ? Array.from(deduped) : void 0;
@@ -7777,9 +8358,9 @@ total unlocked subagents available: ${result.created.length + result.skippedExis
 }
 
 // src/evaluation/providers/targets-file.ts
-var import_node_fs7 = require("fs");
-var import_promises19 = require("fs/promises");
-var import_node_path26 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_promises20 = require("fs/promises");
+var import_node_path27 = __toESM(require("path"), 1);
 var import_yaml4 = require("yaml");
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -7809,18 +8390,18 @@ function assertTargetDefinition(value, index, filePath) {
 }
 async function fileExists3(filePath) {
   try {
-    await (0, import_promises19.access)(filePath, import_node_fs7.constants.F_OK);
+    await (0, import_promises20.access)(filePath, import_node_fs8.constants.F_OK);
     return true;
   } catch {
     return false;
   }
 }
 async function readTargetDefinitions(filePath) {
-  const absolutePath = import_node_path26.default.resolve(filePath);
+  const absolutePath = import_node_path27.default.resolve(filePath);
   if (!await fileExists3(absolutePath)) {
     throw new Error(`targets.yaml not found at ${absolutePath}`);
   }
-  const raw = await (0, import_promises19.readFile)(absolutePath, "utf8");
+  const raw = await (0, import_promises20.readFile)(absolutePath, "utf8");
   const parsed = (0, import_yaml4.parse)(raw);
   if (!isRecord(parsed)) {
     throw new Error(`targets.yaml at ${absolutePath} must be a YAML object with a 'targets' field`);
@@ -7848,6 +8429,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":
@@ -7984,10 +8567,10 @@ async function execFileWithStdinBun(argv, stdinPayload, options) {
   }
 }
 async function execFileWithStdinNode(argv, stdinPayload, options) {
-  const { spawn: spawn5 } = await import("child_process");
+  const { spawn: spawn6 } = await import("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
@@ -8027,21 +8610,21 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
   });
 }
 async function execShellWithStdin(command, stdinPayload, options = {}) {
-  const { mkdir: mkdir8, readFile: readFile11, rm: rm5, writeFile: writeFile8 } = await import("fs/promises");
-  const { tmpdir: tmpdir4 } = await import("os");
-  const path28 = await import("path");
-  const { randomUUID: randomUUID4 } = await import("crypto");
-  const dir = path28.join(tmpdir4(), `agentv-exec-${randomUUID4()}`);
-  await mkdir8(dir, { recursive: true });
-  const stdinPath = path28.join(dir, "stdin.txt");
-  const stdoutPath = path28.join(dir, "stdout.txt");
-  const stderrPath = path28.join(dir, "stderr.txt");
-  await writeFile8(stdinPath, stdinPayload, "utf8");
+  const { mkdir: mkdir9, readFile: readFile11, rm: rm6, writeFile: writeFile9 } = await import("fs/promises");
+  const { tmpdir: tmpdir5 } = await import("os");
+  const path29 = await import("path");
+  const { randomUUID: randomUUID5 } = await import("crypto");
+  const dir = path29.join(tmpdir5(), `agentv-exec-${randomUUID5()}`);
+  await mkdir9(dir, { recursive: true });
+  const stdinPath = path29.join(dir, "stdin.txt");
+  const stdoutPath = path29.join(dir, "stdout.txt");
+  const stderrPath = path29.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");
+  const { spawn: spawn6 } = await import("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"],
@@ -8069,17 +8652,17 @@ async function execShellWithStdin(command, stdinPayload, options = {}) {
     const stderr = (await readFile11(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 });
   }
 }
 
 // src/runtime/target-proxy.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = 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_crypto4.randomBytes)(32).toString("hex");
+  const token = (0, import_node_crypto5.randomBytes)(32).toString("hex");
   let callCount = 0;
   let isShutdown = false;
   const targetsList = availableTargets ?? [defaultProvider.targetName];
@@ -8338,7 +8921,7 @@ var CodeEvaluator = class {
       outputMessages: context.outputMessages ?? null,
       guidelineFiles: context.evalCase.guideline_paths,
       inputFiles: context.evalCase.file_paths.filter(
-        (path28) => !context.evalCase.guideline_paths.includes(path28)
+        (path29) => !context.evalCase.guideline_paths.includes(path29)
       ),
       inputMessages: context.evalCase.input_messages,
       traceSummary: context.traceSummary ?? null,
@@ -8454,6 +9037,7 @@ var import_ai3 = require("ai");
 // src/evaluation/providers/types.ts
 var AGENT_PROVIDER_KINDS = [
   "codex",
+  "copilot-cli",
   "pi-coding-agent",
   "claude-code",
   "vscode",
@@ -9285,115 +9869,115 @@ var FieldAccuracyEvaluator = class {
    * Evaluate a single field against the expected value.
    */
   evaluateField(fieldConfig, candidateData, expectedData) {
-    const { path: path28, match, required = true, weight = 1 } = fieldConfig;
-    const candidateValue = resolvePath(candidateData, path28);
-    const expectedValue = resolvePath(expectedData, path28);
+    const { path: path29, match, required = true, weight = 1 } = fieldConfig;
+    const candidateValue = resolvePath(candidateData, path29);
+    const expectedValue = resolvePath(expectedData, path29);
     if (expectedValue === void 0) {
       return {
-        path: path28,
+        path: path29,
         score: 1,
         // No expected value means no comparison needed
         weight,
         hit: true,
-        message: `${path28}: no expected value`
+        message: `${path29}: no expected value`
       };
     }
     if (candidateValue === void 0) {
       if (required) {
         return {
-          path: path28,
+          path: path29,
           score: 0,
           weight,
           hit: false,
-          message: `${path28} (required, missing)`
+          message: `${path29} (required, missing)`
         };
       }
       return {
-        path: path28,
+        path: path29,
         score: 1,
         // Don't penalize missing optional fields
         weight: 0,
         // Zero weight means it won't affect the score
         hit: true,
-        message: `${path28}: optional field missing`
+        message: `${path29}: optional field missing`
       };
     }
     switch (match) {
       case "exact":
-        return this.compareExact(path28, candidateValue, expectedValue, weight);
+        return this.compareExact(path29, candidateValue, expectedValue, weight);
       case "numeric_tolerance":
         return this.compareNumericTolerance(
-          path28,
+          path29,
           candidateValue,
           expectedValue,
           fieldConfig,
           weight
         );
       case "date":
-        return this.compareDate(path28, candidateValue, expectedValue, fieldConfig, weight);
+        return this.compareDate(path29, candidateValue, expectedValue, fieldConfig, weight);
       default:
         return {
-          path: path28,
+          path: path29,
           score: 0,
           weight,
           hit: false,
-          message: `${path28}: unknown match type "${match}"`
+          message: `${path29}: unknown match type "${match}"`
         };
     }
   }
   /**
    * Exact equality comparison.
    */
-  compareExact(path28, candidateValue, expectedValue, weight) {
+  compareExact(path29, candidateValue, expectedValue, weight) {
     if (deepEqual(candidateValue, expectedValue)) {
       return {
-        path: path28,
+        path: path29,
         score: 1,
         weight,
         hit: true,
-        message: path28
+        message: path29
       };
     }
     if (typeof candidateValue !== typeof expectedValue) {
       return {
-        path: path28,
+        path: path29,
         score: 0,
         weight,
         hit: false,
-        message: `${path28} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
+        message: `${path29} (type mismatch: got ${typeof candidateValue}, expected ${typeof expectedValue})`
       };
     }
     return {
-      path: path28,
+      path: path29,
       score: 0,
       weight,
       hit: false,
-      message: `${path28} (value mismatch)`
+      message: `${path29} (value mismatch)`
     };
   }
   /**
    * Numeric comparison with absolute or relative tolerance.
    */
-  compareNumericTolerance(path28, candidateValue, expectedValue, fieldConfig, weight) {
+  compareNumericTolerance(path29, 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: path28,
+        path: path29,
         score: 0,
         weight,
         hit: false,
-        message: `${path28} (non-numeric value)`
+        message: `${path29} (non-numeric value)`
       };
     }
     if (!Number.isFinite(candidateNum) || !Number.isFinite(expectedNum)) {
       return {
-        path: path28,
+        path: path29,
         score: 0,
         weight,
         hit: false,
-        message: `${path28} (invalid numeric value)`
+        message: `${path29} (invalid numeric value)`
       };
     }
     const diff = Math.abs(candidateNum - expectedNum);
@@ -9406,61 +9990,61 @@ var FieldAccuracyEvaluator = class {
     }
     if (withinTolerance) {
       return {
-        path: path28,
+        path: path29,
         score: 1,
         weight,
         hit: true,
-        message: `${path28} (within tolerance: diff=${diff.toFixed(2)})`
+        message: `${path29} (within tolerance: diff=${diff.toFixed(2)})`
       };
     }
     return {
-      path: path28,
+      path: path29,
       score: 0,
       weight,
       hit: false,
-      message: `${path28} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
+      message: `${path29} (outside tolerance: diff=${diff.toFixed(2)}, tolerance=${tolerance})`
     };
   }
   /**
    * Date comparison with format normalization.
    */
-  compareDate(path28, candidateValue, expectedValue, fieldConfig, weight) {
+  compareDate(path29, 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: path28,
+        path: path29,
         score: 0,
         weight,
         hit: false,
-        message: `${path28} (unparseable candidate date)`
+        message: `${path29} (unparseable candidate date)`
       };
     }
     if (expectedDate === null) {
       return {
-        path: path28,
+        path: path29,
         score: 0,
         weight,
         hit: false,
-        message: `${path28} (unparseable expected date)`
+        message: `${path29} (unparseable expected date)`
       };
     }
     if (candidateDate.getFullYear() === expectedDate.getFullYear() && candidateDate.getMonth() === expectedDate.getMonth() && candidateDate.getDate() === expectedDate.getDate()) {
       return {
-        path: path28,
+        path: path29,
         score: 1,
         weight,
         hit: true,
-        message: path28
+        message: path29
       };
     }
     return {
-      path: path28,
+      path: path29,
       score: 0,
       weight,
       hit: false,
-      message: `${path28} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
+      message: `${path29} (date mismatch: got ${formatDateISO(candidateDate)}, expected ${formatDateISO(expectedDate)})`
     };
   }
   /**
@@ -9500,11 +10084,11 @@ var FieldAccuracyEvaluator = class {
     };
   }
 };
-function resolvePath(obj, path28) {
-  if (!path28 || !obj) {
+function resolvePath(obj, path29) {
+  if (!path29 || !obj) {
     return void 0;
   }
-  const parts = path28.split(/\.|\[|\]/).filter((p) => p.length > 0);
+  const parts = path29.split(/\.|\[|\]/).filter((p) => p.length > 0);
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0) {
@@ -10023,8 +10607,8 @@ var ToolTrajectoryEvaluator = class {
 };
 
 // src/evaluation/orchestrator.ts
-var import_node_crypto5 = require("crypto");
-var import_node_path27 = __toESM(require("path"), 1);
+var import_node_crypto6 = require("crypto");
+var import_node_path28 = __toESM(require("path"), 1);
 var import_micromatch4 = __toESM(require("micromatch"), 1);
 
 // ../../node_modules/.bun/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -10827,7 +11411,7 @@ async function runEvaluatorList(options) {
         });
       }
       if (evaluator.type === "composite") {
-        const evalFileDir = evalCase.guideline_paths[0] ? import_node_path27.default.dirname(evalCase.guideline_paths[0]) : process.cwd();
+        const evalFileDir = evalCase.guideline_paths[0] ? import_node_path28.default.dirname(evalCase.guideline_paths[0]) : process.cwd();
         const createEvaluator = (memberConfig) => {
           switch (memberConfig.type) {
             case "llm_judge":
@@ -11183,7 +11767,7 @@ async function executePromptTemplate(script, context, config, timeoutMs) {
   };
   const inputJson = JSON.stringify(toSnakeCaseDeep(payload), null, 2);
   const scriptPath = script[script.length - 1];
-  const cwd = import_node_path27.default.dirname(scriptPath);
+  const cwd = import_node_path28.default.dirname(scriptPath);
   try {
     const stdout = await executeScript(script, inputJson, timeoutMs, cwd);
     const prompt = stdout.trim();
@@ -11297,7 +11881,7 @@ function extractProviderError(response) {
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function createCacheKey(provider, target, evalCase, promptInputs) {
-  const hash = (0, import_node_crypto5.createHash)("sha256");
+  const hash = (0, import_node_crypto6.createHash)("sha256");
   hash.update(provider.id);
   hash.update(target.name);
   hash.update(evalCase.id);
@@ -11458,6 +12042,7 @@ function createAgentKernel() {
   computeTraceSummary,
   consumeClaudeCodeLogEntries,
   consumeCodexLogEntries,
+  consumeCopilotCliLogEntries,
   consumePiLogEntries,
   createAgentKernel,
   createProvider,
@@ -11497,6 +12082,7 @@ function createAgentKernel() {
   scoreToVerdict,
   subscribeToClaudeCodeLogEntries,
   subscribeToCodexLogEntries,
+  subscribeToCopilotCliLogEntries,
   subscribeToPiLogEntries,
   tokensPerTool
 });