agentv 2.5.1 → 2.5.2

package/dist/{chunk-XREH4WAJ.js → chunk-PQSPRPW4.js}

@@ -1,10 +1,764 @@
 import {
   __commonJS,
   __export,
+  __require,
   __toESM,
   require_token_error
 } from "./chunk-UE4GLFVL.js";
 
+// ../../node_modules/.bun/didyoumean@1.2.2/node_modules/didyoumean/didYouMean-1.2.1.js
+var require_didYouMean_1_2_1 = __commonJS({
+  "../../node_modules/.bun/didyoumean@1.2.2/node_modules/didyoumean/didYouMean-1.2.1.js"(exports, module) {
+    "use strict";
+    (function() {
+      "use strict";
+      function didYouMean2(str, list, key2) {
+        if (!str) return null;
+        if (!didYouMean2.caseSensitive) {
+          str = str.toLowerCase();
+        }
+        var thresholdRelative = didYouMean2.threshold === null ? null : didYouMean2.threshold * str.length, thresholdAbsolute = didYouMean2.thresholdAbsolute, winningVal;
+        if (thresholdRelative !== null && thresholdAbsolute !== null) winningVal = Math.min(thresholdRelative, thresholdAbsolute);
+        else if (thresholdRelative !== null) winningVal = thresholdRelative;
+        else if (thresholdAbsolute !== null) winningVal = thresholdAbsolute;
+        else winningVal = null;
+        var winner, candidate, testCandidate, val, i, len = list.length;
+        for (i = 0; i < len; i++) {
+          candidate = list[i];
+          if (key2) {
+            candidate = candidate[key2];
+          }
+          if (!candidate) {
+            continue;
+          }
+          if (!didYouMean2.caseSensitive) {
+            testCandidate = candidate.toLowerCase();
+          } else {
+            testCandidate = candidate;
+          }
+          val = getEditDistance(str, testCandidate, winningVal);
+          if (winningVal === null || val < winningVal) {
+            winningVal = val;
+            if (key2 && didYouMean2.returnWinningObject) winner = list[i];
+            else winner = candidate;
+            if (didYouMean2.returnFirstMatch) return winner;
+          }
+        }
+        return winner || didYouMean2.nullResultValue;
+      }
+      didYouMean2.threshold = 0.4;
+      didYouMean2.thresholdAbsolute = 20;
+      didYouMean2.caseSensitive = false;
+      didYouMean2.nullResultValue = null;
+      didYouMean2.returnWinningObject = null;
+      didYouMean2.returnFirstMatch = false;
+      if (typeof module !== "undefined" && module.exports) {
+        module.exports = didYouMean2;
+      } else {
+        window.didYouMean = didYouMean2;
+      }
+      var MAX_INT = Math.pow(2, 32) - 1;
+      function getEditDistance(a, b, max) {
+        max = max || max === 0 ? max : MAX_INT;
+        var lena = a.length;
+        var lenb = b.length;
+        if (lena === 0) return Math.min(max + 1, lenb);
+        if (lenb === 0) return Math.min(max + 1, lena);
+        if (Math.abs(lena - lenb) > max) return max + 1;
+        var matrix = [], i, j, colMin, minJ, maxJ;
+        for (i = 0; i <= lenb; i++) {
+          matrix[i] = [i];
+        }
+        for (j = 0; j <= lena; j++) {
+          matrix[0][j] = j;
+        }
+        for (i = 1; i <= lenb; i++) {
+          colMin = MAX_INT;
+          minJ = 1;
+          if (i > max) minJ = i - max;
+          maxJ = lenb + 1;
+          if (maxJ > max + i) maxJ = max + i;
+          for (j = 1; j <= lena; j++) {
+            if (j < minJ || j > maxJ) {
+              matrix[i][j] = max + 1;
+            } else {
+              if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+              } else {
+                matrix[i][j] = Math.min(
+                  matrix[i - 1][j - 1] + 1,
+                  // Substitute
+                  Math.min(
+                    matrix[i][j - 1] + 1,
+                    // Insert
+                    matrix[i - 1][j] + 1
+                  )
+                );
+              }
+            }
+            if (matrix[i][j] < colMin) colMin = matrix[i][j];
+          }
+          if (colMin > max) return max + 1;
+        }
+        return matrix[lenb][lena];
+      }
+    })();
+  }
+});
+
+// ../../node_modules/.bun/ms@2.1.3/node_modules/ms/index.js
+var require_ms = __commonJS({
+  "../../node_modules/.bun/ms@2.1.3/node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse9(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse9(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name16) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name16 + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env2) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce2;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env2).forEach((key2) => {
+        createDebug[key2] = env2[key2];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug2(...args) {
+          if (!debug2.enabled) {
+            return;
+          }
+          const self = debug2;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug2.namespace = namespace;
+        debug2.useColors = createDebug.useColors();
+        debug2.color = createDebug.selectColor(namespace);
+        debug2.extend = extend2;
+        debug2.destroy = createDebug.destroy;
+        Object.defineProperty(debug2, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug2);
+        }
+        return debug2;
+      }
+      function extend2(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name16) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name16, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name16, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce2(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c3 = "color: " + this.color;
+      args.splice(1, 0, c3, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c3);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error40) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error40) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error40) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error40) {
+        return "[UnexpectedJSONParseError]: " + error40.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty2 = __require("tty");
+    var util3 = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util3.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor2 = __require("supports-color");
+      if (supportsColor2 && (supportsColor2.stderr || supportsColor2).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error40) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key2) => {
+      return /^debug_/i.test(key2);
+    }).reduce((obj, key2) => {
+      const prop = key2.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key2];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty2.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name16, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c3 = this.color;
+        const colorCode = "\x1B[3" + (c3 < 8 ? c3 : "8;5;" + c3);
+        const prefix = `  ${colorCode};1m${name16} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name16 + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util3.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug2) {
+      debug2.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug2.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util3.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util3.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// ../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "../../node_modules/.bun/debug@4.4.3/node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
 // ../../node_modules/.bun/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-context.js
 var require_get_context = __commonJS({
   "../../node_modules/.bun/@vercel+oidc@3.0.5/node_modules/@vercel/oidc/dist/get-context.js"(exports, module) {
@@ -71,11 +825,11 @@ var require_get_vercel_oidc_token = __commonJS({
     var import_token_error = require_token_error();
     async function getVercelOidcToken3() {
       let token2 = "";
-      let err;
+      let err2;
       try {
         token2 = getVercelOidcTokenSync2();
       } catch (error40) {
-        err = error40;
+        err2 = error40;
       }
       try {
         const [{ getTokenPayload, isExpired }, { refreshToken }] = await Promise.all([
@@ -87,8 +841,8 @@ var require_get_vercel_oidc_token = __commonJS({
           token2 = getVercelOidcTokenSync2();
         }
       } catch (error40) {
-        if (err?.message && error40 instanceof Error) {
-          error40.message = `${err.message}
+        if (err2?.message && error40 instanceof Error) {
+          error40.message = `${err2.message}
 ${error40.message}`;
         }
         throw new import_token_error.VercelOidcTokenError(`Failed to refresh OIDC token`, error40);
@@ -142,11 +896,1816 @@ var require_dist = __commonJS({
 
 // src/index.ts
 import { readFileSync as readFileSync4 } from "node:fs";
-import { binary, run, subcommands as subcommands2 } from "cmd-ts";
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer2 = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer2 >> 16 & 255,
+          integer2 >> 8 & 255,
+          integer2 & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+import process2 from "node:process";
+import os from "node:os";
+import tty from "node:tty";
+function hasFlag(flag2, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
+  const prefix = flag2.startsWith("-") ? "" : flag2.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag2);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process2;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  }
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== void 0) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === void 0) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process2.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key2) => key2 in env)) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign2) => sign2 in env) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string5, substring, replacer) {
+  let index = string5.indexOf(substring);
+  if (index === -1) {
+    return string5;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string5.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string5.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string5.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string5, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string5[index - 1] === "\r";
+    returnValue += string5.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    endIndex = index + 1;
+    index = string5.indexOf("\n", endIndex);
+  } while (index !== -1);
+  returnValue += string5.slice(endIndex);
+  return returnValue;
+}
+
+// ../../node_modules/.bun/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = /* @__PURE__ */ Object.create(null);
+var applyOptions = (object3, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object3.level = options.level === void 0 ? colorLevel : options.level;
+};
+var chalkFactory = (options) => {
+  const chalk2 = (...strings) => strings.join(" ");
+  applyOptions(chalk2, options);
+  Object.setPrototypeOf(chalk2, createChalk.prototype);
+  return chalk2;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    }
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
+  }
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
+    }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
+    }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
+  }
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+var proto = Object.defineProperties(() => {
+}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === void 0) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self, string5) => {
+  if (self.level <= 0 || !string5) {
+    return self[IS_EMPTY] ? "" : string5;
+  }
+  let styler = self[STYLER];
+  if (styler === void 0) {
+    return string5;
+  }
+  const { openAll, closeAll } = styler;
+  if (string5.includes("\x1B")) {
+    while (styler !== void 0) {
+      string5 = stringReplaceAll(string5, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+  const lfIndex = string5.indexOf("\n");
+  if (lfIndex !== -1) {
+    string5 = stringEncaseCRLFWithFirstIndex(string5, closeAll, openAll, lfIndex);
+  }
+  return openAll + string5 + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/subcommands.js
+var import_didyoumean = __toESM(require_didYouMean_1_2_1());
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/Result.js
+function ok(value) {
+  return { _tag: "ok", value };
+}
+function err(error40) {
+  return { _tag: "error", error: error40 };
+}
+function isOk(result) {
+  return result._tag === "ok";
+}
+function isErr(either) {
+  return either._tag === "error";
+}
+async function safeAsync(promise2) {
+  try {
+    const value = await promise2;
+    return ok(value);
+  } catch (e) {
+    return err(e);
+  }
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/effects.js
+var Exit = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  run() {
+    const output = this.output();
+    output(this.config.message);
+    process.exit(this.config.exitCode);
+  }
+  dryRun() {
+    const { into, message, exitCode } = this.config;
+    const coloredExit = source_default.dim(`process exited with status ${exitCode} (${into})`);
+    return `${message}
+
+${coloredExit}`;
+  }
+  output() {
+    if (this.config.into === "stderr") {
+      return console.error;
+    }
+    return console.log;
+  }
+};
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/newparser/findOption.js
+function findOption(nodes, opts) {
+  const result = [];
+  for (const node of nodes) {
+    if (node.type === "longOption" && opts.longNames.includes(node.key)) {
+      result.push(node);
+      continue;
+    }
+    if (node.type === "shortOptions" && opts.shortNames.length) {
+      for (const option2 of node.options) {
+        if (opts.shortNames.includes(option2.key)) {
+          result.push(option2);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/from.js
+function identity() {
+  return {
+    async from(a) {
+      return a;
+    }
+  };
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/type.js
+function typeDef(from) {
+  if (typeof from === "function") {
+    return {};
+  }
+  return from;
+}
+function fromFn(t) {
+  if (typeof t === "function") {
+    return t;
+  }
+  return t.from;
+}
+function extendType(base, nextTypeOrDecodingFunction) {
+  const { defaultValue: _defaultValue, onMissing: _onMissing, from: _from, ...t1WithoutDefault } = base;
+  const t2Object = typeDef(nextTypeOrDecodingFunction);
+  const t2From = fromFn(nextTypeOrDecodingFunction);
+  return {
+    ...t1WithoutDefault,
+    ...t2Object,
+    async from(a) {
+      const f1Result = await base.from(a);
+      return await t2From(f1Result);
+    }
+  };
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/types.js
+var number = {
+  async from(str) {
+    const decoded = Number.parseFloat(str);
+    if (Number.isNaN(decoded)) {
+      throw new Error("Not a number");
+    }
+    return decoded;
+  },
+  displayName: "number",
+  description: "a number"
+};
+var string = {
+  ...identity(),
+  description: "a string",
+  displayName: "str"
+};
+var boolean = {
+  ...identity(),
+  description: "a boolean",
+  displayName: "true/false",
+  defaultValue() {
+    return false;
+  }
+};
+function optional(t) {
+  return {
+    ...t,
+    defaultValue() {
+      return void 0;
+    }
+  };
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/flag.js
+var boolean2 = {
+  async from(str) {
+    if (str === "true")
+      return true;
+    if (str === "false")
+      return false;
+    throw new Error(`expected value to be either "true" or "false". got: "${str}"`);
+  },
+  displayName: "true/false",
+  defaultValue: () => false
+};
+function fullFlag(config2) {
+  var _a17;
+  const decoder = extendType(boolean2, config2.type);
+  return {
+    description: (_a17 = config2.description) !== null && _a17 !== void 0 ? _a17 : config2.type.description,
+    helpTopics() {
+      var _a18, _b8;
+      let usage = `--${config2.long}`;
+      if (config2.short) {
+        usage += `, -${config2.short}`;
+      }
+      const defaults = [];
+      if (config2.env) {
+        const env2 = process.env[config2.env] === void 0 ? "" : `=${source_default.italic(process.env[config2.env])}`;
+        defaults.push(`env: ${config2.env}${env2}`);
+      }
+      if (config2.defaultValue) {
+        try {
+          const defaultValue = config2.defaultValue();
+          if (config2.defaultValueIsSerializable) {
+            defaults.push(`default: ${source_default.italic(defaultValue)}`);
+          } else {
+            defaults.push("optional");
+          }
+        } catch (e) {
+        }
+      } else if (config2.type.defaultValue) {
+        try {
+          const defaultValue = config2.type.defaultValue();
+          if (config2.type.defaultValueIsSerializable) {
+            defaults.push(`default: ${source_default.italic(defaultValue)}`);
+          } else {
+            defaults.push("optional");
+          }
+        } catch (e) {
+        }
+      } else if (config2.onMissing || config2.type.onMissing) {
+        defaults.push("optional");
+      }
+      return [
+        {
+          category: "flags",
+          usage,
+          defaults,
+          description: (_b8 = (_a18 = config2.description) !== null && _a18 !== void 0 ? _a18 : config2.type.description) !== null && _b8 !== void 0 ? _b8 : "self explanatory"
+        }
+      ];
+    },
+    register(opts) {
+      opts.forceFlagLongNames.add(config2.long);
+      if (config2.short) {
+        opts.forceFlagShortNames.add(config2.short);
+      }
+    },
+    async parse({ nodes, visitedNodes }) {
+      var _a18, _b8;
+      const options = findOption(nodes, {
+        longNames: [config2.long],
+        shortNames: config2.short ? [config2.short] : []
+      }).filter((x) => !visitedNodes.has(x));
+      options.forEach((opt) => visitedNodes.add(opt));
+      if (options.length > 1) {
+        return err({
+          errors: [
+            {
+              nodes: options,
+              message: `Expected 1 occurence, got ${options.length}`
+            }
+          ]
+        });
+      }
+      const valueFromEnv = config2.env ? process.env[config2.env] : void 0;
+      const onMissingFn = config2.onMissing || config2.type.onMissing;
+      let rawValue;
+      let envPrefix = "";
+      if (options.length === 0 && valueFromEnv !== void 0) {
+        rawValue = valueFromEnv;
+        envPrefix = `env[${source_default.italic(config2.env)}]: `;
+      } else if (options.length === 0 && config2.defaultValue) {
+        try {
+          const defaultValue = config2.defaultValue();
+          return ok(defaultValue);
+        } catch (e) {
+          const message = `Default value not found for '--${config2.long}': ${e.message}`;
+          return err({
+            errors: [{ message, nodes: [] }]
+          });
+        }
+      } else if (options.length === 0 && onMissingFn) {
+        try {
+          const missingValue = await onMissingFn();
+          return ok(missingValue);
+        } catch (e) {
+          const message = `Failed to get missing value for '--${config2.long}': ${e.message}`;
+          return err({
+            errors: [{ message, nodes: [] }]
+          });
+        }
+      } else if (options.length === 0 && config2.type.defaultValue) {
+        try {
+          const defaultValue = config2.type.defaultValue();
+          return ok(defaultValue);
+        } catch (e) {
+          const message = `Default value not found for '--${config2.long}': ${e.message}`;
+          return err({
+            errors: [{ message, nodes: [] }]
+          });
+        }
+      } else if (options.length === 1) {
+        rawValue = (_b8 = (_a18 = options[0].value) === null || _a18 === void 0 ? void 0 : _a18.node.raw) !== null && _b8 !== void 0 ? _b8 : "true";
+      } else {
+        return err({
+          errors: [
+            { nodes: [], message: `No value provided for --${config2.long}` }
+          ]
+        });
+      }
+      const decoded = await safeAsync(decoder.from(rawValue));
+      if (isErr(decoded)) {
+        return err({
+          errors: [
+            {
+              nodes: options,
+              message: envPrefix + decoded.error.message
+            }
+          ]
+        });
+      }
+      return decoded;
+    }
+  };
+}
+function flag(config2) {
+  return fullFlag({
+    type: boolean,
+    ...config2
+  });
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/circuitbreaker.js
+var helpFlag = flag({
+  long: "help",
+  short: "h",
+  type: boolean,
+  description: "show help"
+});
+var versionFlag = flag({
+  long: "version",
+  short: "v",
+  type: boolean,
+  description: "print the version"
+});
+function handleCircuitBreaker(context, value, breaker) {
+  if (isErr(breaker)) {
+    return;
+  }
+  if (breaker.value === "help") {
+    const message = value.printHelp(context);
+    throw new Exit({ exitCode: 0, message, into: "stdout" });
+  }
+  if (breaker.value === "version") {
+    const message = value.version || "0.0.0";
+    throw new Exit({ exitCode: 0, message, into: "stdout" });
+  }
+}
+function createCircuitBreaker(withVersion) {
+  return {
+    register(opts) {
+      helpFlag.register(opts);
+      if (withVersion) {
+        versionFlag.register(opts);
+      }
+    },
+    helpTopics() {
+      const helpTopics = helpFlag.helpTopics();
+      if (withVersion) {
+        helpTopics.push(...versionFlag.helpTopics());
+      }
+      return helpTopics;
+    },
+    async parse(context) {
+      const help = await helpFlag.parse(context);
+      const version2 = withVersion ? await versionFlag.parse(context) : void 0;
+      if (isErr(help) || version2 && isErr(version2)) {
+        const helpErrors = isErr(help) ? help.error.errors : [];
+        const versionErrors = version2 && isErr(version2) ? version2.error.errors : [];
+        return err({ errors: [...helpErrors, ...versionErrors] });
+      }
+      if (help.value) {
+        return ok("help");
+      }
+      if (version2 === null || version2 === void 0 ? void 0 : version2.value) {
+        return ok("version");
+      }
+      return err({
+        errors: [
+          {
+            nodes: [],
+            message: "Neither help nor version"
+          }
+        ]
+      });
+    }
+  };
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/positional.js
+function fullPositional(config2) {
+  var _a17, _b8, _c;
+  const displayName = (_b8 = (_a17 = config2.displayName) !== null && _a17 !== void 0 ? _a17 : config2.type.displayName) !== null && _b8 !== void 0 ? _b8 : "arg";
+  return {
+    description: (_c = config2.description) !== null && _c !== void 0 ? _c : config2.type.description,
+    helpTopics() {
+      var _a18, _b9, _c2, _d;
+      const defaults = [];
+      const defaultValueFn = (_a18 = config2.defaultValue) !== null && _a18 !== void 0 ? _a18 : config2.type.defaultValue;
+      if (defaultValueFn) {
+        try {
+          const defaultValue = defaultValueFn();
+          if ((_b9 = config2.defaultValueIsSerializable) !== null && _b9 !== void 0 ? _b9 : config2.type.defaultValueIsSerializable) {
+            defaults.push(`default: ${source_default.italic(defaultValue)}`);
+          } else {
+            defaults.push("optional");
+          }
+        } catch (e) {
+        }
+      }
+      const usage = defaults.length > 0 ? `[${displayName}]` : `<${displayName}>`;
+      return [
+        {
+          category: "arguments",
+          usage,
+          description: (_d = (_c2 = config2.description) !== null && _c2 !== void 0 ? _c2 : config2.type.description) !== null && _d !== void 0 ? _d : "self explanatory",
+          defaults
+        }
+      ];
+    },
+    register(_opts) {
+    },
+    async parse({ nodes, visitedNodes }) {
+      var _a18;
+      const positionals = nodes.filter((node) => node.type === "positionalArgument" && !visitedNodes.has(node));
+      const defaultValueFn = (_a18 = config2.defaultValue) !== null && _a18 !== void 0 ? _a18 : config2.type.defaultValue;
+      const positional3 = positionals[0];
+      if (!positional3) {
+        if (defaultValueFn) {
+          return ok(defaultValueFn());
+        }
+        return err({
+          errors: [
+            {
+              nodes: [],
+              message: `No value provided for ${displayName}`
+            }
+          ]
+        });
+      }
+      visitedNodes.add(positional3);
+      const decoded = await safeAsync(config2.type.from(positional3.raw));
+      if (isErr(decoded)) {
+        return err({
+          errors: [
+            {
+              nodes: [positional3],
+              message: decoded.error.message
+            }
+          ]
+        });
+      }
+      return ok(decoded.value);
+    }
+  };
+}
+function positional(config2) {
+  return fullPositional({
+    type: string,
+    ...config2
+  });
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/subcommands.js
+function subcommands(config2) {
+  const circuitbreaker = createCircuitBreaker(!!config2.version);
+  const type = {
+    async from(str) {
+      const commands = Object.entries(config2.cmds).map(([name16, cmd2]) => {
+        var _a17;
+        return {
+          cmdName: name16,
+          names: [name16, ...(_a17 = cmd2.aliases) !== null && _a17 !== void 0 ? _a17 : []]
+        };
+      });
+      const cmd = commands.find((x) => x.names.includes(str));
+      if (cmd) {
+        return cmd.cmdName;
+      }
+      let errorMessage = "Not a valid subcommand name";
+      const closeOptions = (0, import_didyoumean.default)(str, flatMap(commands, (x) => x.names));
+      if (closeOptions) {
+        const option2 = Array.isArray(closeOptions) ? closeOptions[0] : closeOptions;
+        errorMessage += `
+Did you mean ${source_default.italic(option2)}?`;
+      }
+      throw new Error(errorMessage);
+    }
+  };
+  const subcommand = positional({
+    displayName: "subcommand",
+    description: `one of ${Object.keys(config2.cmds).join(", ")}`,
+    type
+  });
+  function normalizeContext(context) {
+    var _a17;
+    if (((_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.length) === 0) {
+      context.hotPath.push(config2.name);
+    }
+    if (!context.nodes.some((n) => !context.visitedNodes.has(n))) {
+      context.nodes.push({
+        type: "longOption",
+        index: 0,
+        key: "help",
+        raw: "--help"
+      });
+    }
+  }
+  return {
+    version: config2.version,
+    description: config2.description,
+    name: config2.name,
+    handler: (value) => {
+      const cmd = config2.cmds[value.command];
+      return cmd.handler(value.args);
+    },
+    register(opts) {
+      for (const cmd of Object.values(config2.cmds)) {
+        cmd.register(opts);
+      }
+      circuitbreaker.register(opts);
+    },
+    printHelp(context) {
+      var _a17, _b8, _c, _d;
+      const lines = [];
+      const argsSoFar = (_b8 = (_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.join(" ")) !== null && _b8 !== void 0 ? _b8 : "cli";
+      lines.push(source_default.bold(argsSoFar + source_default.italic(" <subcommand>")));
+      if (config2.description) {
+        lines.push(source_default.dim("> ") + config2.description);
+      }
+      lines.push("");
+      lines.push(`where ${source_default.italic("<subcommand>")} can be one of:`);
+      lines.push("");
+      for (const key2 of Object.keys(config2.cmds)) {
+        const cmd = config2.cmds[key2];
+        let description = (_c = cmd.description) !== null && _c !== void 0 ? _c : "";
+        description = description && ` - ${description} `;
+        if ((_d = cmd.aliases) === null || _d === void 0 ? void 0 : _d.length) {
+          const aliasTxt = cmd.aliases.length === 1 ? "alias" : "aliases";
+          const aliases = cmd.aliases.join(", ");
+          description += source_default.dim(`[${aliasTxt}: ${aliases}]`);
+        }
+        const row = source_default.dim("- ") + key2 + description;
+        lines.push(row.trim());
+      }
+      const helpCommand = source_default.yellow(`${argsSoFar} <subcommand> --help`);
+      lines.push("");
+      lines.push(source_default.dim(`For more help, try running \`${helpCommand}\``));
+      return lines.join("\n");
+    },
+    async parse(context) {
+      var _a17;
+      normalizeContext(context);
+      const parsed = await subcommand.parse(context);
+      if (isErr(parsed)) {
+        return err({
+          errors: parsed.error.errors,
+          partialValue: {}
+        });
+      }
+      (_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.push(parsed.value);
+      const cmd = config2.cmds[parsed.value];
+      const parsedCommand = await cmd.parse(context);
+      if (isErr(parsedCommand)) {
+        return err({
+          errors: parsedCommand.error.errors,
+          partialValue: {
+            command: parsed.value,
+            args: parsedCommand.error.partialValue
+          }
+        });
+      }
+      return ok({
+        args: parsedCommand.value,
+        command: parsed.value
+      });
+    },
+    async run(context) {
+      var _a17;
+      normalizeContext(context);
+      const parsedSubcommand = await subcommand.parse(context);
+      if (isErr(parsedSubcommand)) {
+        const breaker = await circuitbreaker.parse(context);
+        handleCircuitBreaker(context, this, breaker);
+        return err({ ...parsedSubcommand.error, partialValue: {} });
+      }
+      (_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.push(parsedSubcommand.value);
+      const cmd = config2.cmds[parsedSubcommand.value];
+      const commandRun = await cmd.run(context);
+      if (isOk(commandRun)) {
+        return ok({
+          command: parsedSubcommand.value,
+          value: commandRun.value
+        });
+      }
+      return err({
+        ...commandRun.error,
+        partialValue: {
+          command: parsedSubcommand.value,
+          value: commandRun.error.partialValue
+        }
+      });
+    }
+  };
+}
+function flatMap(array2, f) {
+  const rs = [];
+  for (const item of array2) {
+    rs.push(...f(item));
+  }
+  return rs;
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/binary.js
+function binary(cmd) {
+  return {
+    ...cmd,
+    run(context) {
+      var _a17;
+      const name16 = cmd.name || context.nodes[1].raw;
+      (_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.push(name16);
+      context.nodes.splice(0, 1);
+      context.nodes[0].raw = name16;
+      context.visitedNodes.add(context.nodes[0]);
+      return cmd.run(context);
+    }
+  };
+}
+
+// ../../node_modules/.bun/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// ../../node_modules/.bun/strip-ansi@7.1.2/node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string5) {
+  if (typeof string5 !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string5}\``);
+  }
+  return string5.replace(regex, "");
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/utils.js
+function padNoAnsi(str, length, place) {
+  const noAnsiStr = stripAnsi(str);
+  if (length < noAnsiStr.length)
+    return str;
+  const pad = Array(length - noAnsiStr.length + 1).join(" ");
+  if (place === "end") {
+    return str + pad;
+  }
+  return pad + str;
+}
+function groupBy(objs, f) {
+  var _a17;
+  const result = {};
+  for (const obj of objs) {
+    const key2 = f(obj);
+    result[key2] = (_a17 = result[key2]) !== null && _a17 !== void 0 ? _a17 : [];
+    result[key2].push(obj);
+  }
+  return result;
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
+function* enumerate(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    yield [i, arr[i]];
+  }
+}
+function flatMap2(xs, fn) {
+  const results = [];
+  for (const x of xs) {
+    results.push(...fn(x));
+  }
+  return results;
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/command.js
+function command(config2) {
+  const argEntries = entries(config2.args);
+  const circuitbreaker = createCircuitBreaker(!!config2.version);
+  return {
+    name: config2.name,
+    aliases: config2.aliases,
+    handler: config2.handler,
+    description: config2.description,
+    version: config2.version,
+    helpTopics() {
+      return flatMap2(Object.values(config2.args).concat([circuitbreaker]), (x) => {
+        var _a17, _b8;
+        return (_b8 = (_a17 = x.helpTopics) === null || _a17 === void 0 ? void 0 : _a17.call(x)) !== null && _b8 !== void 0 ? _b8 : [];
+      });
+    },
+    printHelp(context) {
+      var _a17, _b8;
+      const lines = [];
+      let name16 = (_b8 = (_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.join(" ")) !== null && _b8 !== void 0 ? _b8 : "";
+      if (!name16) {
+        name16 = config2.name;
+      }
+      name16 = source_default.bold(name16);
+      if (config2.version) {
+        name16 += ` ${source_default.dim(config2.version)}`;
+      }
+      lines.push(name16);
+      if (config2.description) {
+        lines.push(source_default.dim("> ") + config2.description);
+      }
+      const usageBreakdown = groupBy(this.helpTopics(), (x) => x.category);
+      for (const [category, helpTopics] of entries(usageBreakdown)) {
+        lines.push("");
+        lines.push(`${category.toUpperCase()}:`);
+        const widestUsage = helpTopics.reduce((len, curr) => {
+          return Math.max(len, curr.usage.length);
+        }, 0);
+        for (const helpTopic of helpTopics) {
+          let line2 = "";
+          line2 += `  ${padNoAnsi(helpTopic.usage, widestUsage, "end")}`;
+          line2 += " - ";
+          line2 += helpTopic.description;
+          for (const defaultValue of helpTopic.defaults) {
+            line2 += source_default.dim(` [${defaultValue}]`);
+          }
+          lines.push(line2);
+        }
+      }
+      return lines.join("\n");
+    },
+    register(opts) {
+      var _a17;
+      for (const [, arg] of argEntries) {
+        (_a17 = arg.register) === null || _a17 === void 0 ? void 0 : _a17.call(arg, opts);
+      }
+    },
+    async parse(context) {
+      var _a17;
+      if (((_a17 = context.hotPath) === null || _a17 === void 0 ? void 0 : _a17.length) === 0) {
+        context.hotPath.push(config2.name);
+      }
+      const resultObject = {};
+      const errors = [];
+      for (const [argName, arg] of argEntries) {
+        const result = await arg.parse(context);
+        if (isErr(result)) {
+          errors.push(...result.error.errors);
+        } else {
+          resultObject[argName] = result.value;
+        }
+      }
+      const unknownArguments = [];
+      for (const node of context.nodes) {
+        if (context.visitedNodes.has(node)) {
+          continue;
+        }
+        if (node.type === "forcePositional") {
+        } else if (node.type === "shortOptions") {
+          for (const option2 of node.options) {
+            if (context.visitedNodes.has(option2)) {
+              continue;
+            }
+            unknownArguments.push(option2);
+          }
+        } else {
+          unknownArguments.push(node);
+        }
+      }
+      if (unknownArguments.length > 0) {
+        errors.push({
+          message: "Unknown arguments",
+          nodes: unknownArguments
+        });
+      }
+      if (errors.length > 0) {
+        return err({
+          errors,
+          partialValue: resultObject
+        });
+      }
+      return ok(resultObject);
+    },
+    async run(context) {
+      const breaker = await circuitbreaker.parse(context);
+      handleCircuitBreaker(context, this, breaker);
+      const parsed = await this.parse(context);
+      if (isErr(parsed)) {
+        return err(parsed.error);
+      }
+      return ok(await this.handler(parsed.value));
+    }
+  };
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/option.js
+function fullOption(config2) {
+  var _a17;
+  return {
+    description: (_a17 = config2.description) !== null && _a17 !== void 0 ? _a17 : config2.type.description,
+    helpTopics() {
+      var _a18, _b8, _c;
+      const displayName = (_a18 = config2.type.displayName) !== null && _a18 !== void 0 ? _a18 : "value";
+      let usage = `--${config2.long}`;
+      if (config2.short) {
+        usage += `, -${config2.short}`;
+      }
+      usage += ` <${displayName}>`;
+      const defaults = [];
+      if (config2.env) {
+        const env2 = process.env[config2.env] === void 0 ? "" : `=${source_default.italic(process.env[config2.env])}`;
+        defaults.push(`env: ${config2.env}${env2}`);
+      }
+      if (config2.defaultValue) {
+        try {
+          const defaultValue = config2.defaultValue();
+          if (config2.defaultValueIsSerializable) {
+            defaults.push(`default: ${source_default.italic(defaultValue)}`);
+          } else {
+            defaults.push("optional");
+          }
+        } catch (e) {
+        }
+      } else if (config2.type.defaultValue) {
+        try {
+          const defaultValue = config2.type.defaultValue();
+          if (config2.type.defaultValueIsSerializable) {
+            defaults.push(`default: ${source_default.italic(defaultValue)}`);
+          } else {
+            defaults.push("optional");
+          }
+        } catch (e) {
+        }
+      } else if (config2.onMissing || config2.type.onMissing) {
+        defaults.push("optional");
+      }
+      return [
+        {
+          category: "options",
+          usage,
+          defaults,
+          description: (_c = (_b8 = config2.description) !== null && _b8 !== void 0 ? _b8 : config2.type.description) !== null && _c !== void 0 ? _c : "self explanatory"
+        }
+      ];
+    },
+    register(opts) {
+      opts.forceOptionLongNames.add(config2.long);
+      if (config2.short) {
+        opts.forceOptionShortNames.add(config2.short);
+      }
+    },
+    async parse({ nodes, visitedNodes }) {
+      const options = findOption(nodes, {
+        longNames: [config2.long],
+        shortNames: config2.short ? [config2.short] : []
+      }).filter((x) => !visitedNodes.has(x));
+      options.forEach((opt) => visitedNodes.add(opt));
+      if (options.length > 1) {
+        const error40 = {
+          message: `Too many times provided. Expected 1, got: ${options.length}`,
+          nodes: options
+        };
+        return err({ errors: [error40] });
+      }
+      const valueFromEnv = config2.env ? process.env[config2.env] : void 0;
+      const defaultValueFn = config2.defaultValue || config2.type.defaultValue;
+      const onMissingFn = config2.onMissing || config2.type.onMissing;
+      const option2 = options[0];
+      let rawValue;
+      let envPrefix = "";
+      if (option2 === null || option2 === void 0 ? void 0 : option2.value) {
+        rawValue = option2.value.node.raw;
+      } else if (valueFromEnv !== void 0) {
+        rawValue = valueFromEnv;
+        envPrefix = `env[${source_default.italic(config2.env)}]: `;
+      } else if (defaultValueFn) {
+        try {
+          const defaultValue = defaultValueFn();
+          return ok(defaultValue);
+        } catch (e) {
+          const message = `Default value not found for '--${config2.long}': ${e.message}`;
+          return err({
+            errors: [
+              {
+                nodes: [],
+                message
+              }
+            ]
+          });
+        }
+      } else if (onMissingFn) {
+        try {
+          const missingValue = await onMissingFn();
+          return ok(missingValue);
+        } catch (e) {
+          const message = `Failed to get missing value for '--${config2.long}': ${e.message}`;
+          return err({
+            errors: [
+              {
+                nodes: [],
+                message
+              }
+            ]
+          });
+        }
+      } else {
+        const raw = (option2 === null || option2 === void 0 ? void 0 : option2.type) === "shortOption" ? `-${option2 === null || option2 === void 0 ? void 0 : option2.key}` : `--${config2.long}`;
+        return err({
+          errors: [
+            {
+              nodes: options,
+              message: `No value provided for ${raw}`
+            }
+          ]
+        });
+      }
+      const decoded = await safeAsync(config2.type.from(rawValue));
+      if (isErr(decoded)) {
+        return err({
+          errors: [
+            { nodes: options, message: envPrefix + decoded.error.message }
+          ]
+        });
+      }
+      return ok(decoded.value);
+    }
+  };
+}
+function option(config2) {
+  return fullOption({
+    type: string,
+    ...config2
+  });
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/errorBox.js
+function highlight(nodes, error40) {
+  const strings = [];
+  let errorIndex = void 0;
+  function foundError() {
+    if (errorIndex !== void 0)
+      return;
+    errorIndex = stripAnsi(strings.join(" ")).length;
+  }
+  if (error40.nodes.length === 0)
+    return;
+  nodes.forEach((node) => {
+    if (error40.nodes.includes(node)) {
+      foundError();
+      return strings.push(source_default.red(node.raw));
+    }
+    if (node.type === "shortOptions") {
+      let failed = false;
+      let s = "";
+      for (const option2 of node.options) {
+        if (error40.nodes.includes(option2)) {
+          s += source_default.red(option2.raw);
+          failed = true;
+        } else {
+          s += source_default.dim(option2.raw);
+        }
+      }
+      const prefix = failed ? source_default.red("-") : source_default.dim("-");
+      if (failed) {
+        foundError();
+      }
+      return strings.push(prefix + s);
+    }
+    return strings.push(source_default.dim(node.raw));
+  });
+  return { colorized: strings.join(" "), errorIndex: errorIndex !== null && errorIndex !== void 0 ? errorIndex : 0 };
+}
+function errorBox(nodes, errors, breadcrumbs) {
+  const withHighlight = [];
+  const errorMessages = [];
+  for (const error40 of errors) {
+    const highlighted = highlight(nodes, error40);
+    withHighlight.push({ message: error40.message, highlighted });
+  }
+  let number5 = 1;
+  const maxNumberWidth = String(withHighlight.length).length;
+  errorMessages.push(`${source_default.red.bold("error: ")}found ${source_default.yellow(withHighlight.length)} error${withHighlight.length > 1 ? "s" : ""}`);
+  errorMessages.push("");
+  withHighlight.filter((x) => x.highlighted).forEach((x) => {
+    if (!x.highlighted) {
+      throw new Error("WELP");
+    }
+    const pad = "".padStart(x.highlighted.errorIndex);
+    errorMessages.push(`  ${x.highlighted.colorized}`);
+    for (const [index, line2] of enumerate(x.message.split("\n"))) {
+      const prefix = index === 0 ? source_default.bold("^") : " ";
+      const msg = source_default.red(`  ${pad} ${prefix} ${line2}`);
+      errorMessages.push(msg);
+    }
+    errorMessages.push("");
+    number5++;
+  });
+  const withNoHighlight = withHighlight.filter((x) => !x.highlighted);
+  if (number5 > 1) {
+    if (withNoHighlight.length === 1) {
+      errorMessages.push("Along with the following error:");
+    } else if (withNoHighlight.length > 1) {
+      errorMessages.push("Along with the following errors:");
+    }
+  }
+  withNoHighlight.forEach(({ message }) => {
+    const num = source_default.red.bold(`${padNoAnsi(number5.toString(), maxNumberWidth, "start")}.`);
+    errorMessages.push(`  ${num} ${source_default.red(message)}`);
+    number5++;
+  });
+  const helpCmd = source_default.yellow(`${breadcrumbs.join(" ")} --help`);
+  errorMessages.push("");
+  errorMessages.push(`${source_default.red.bold("hint: ")}for more information, try '${helpCmd}'`);
+  return errorMessages.join("\n");
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/newparser/parser.js
+var import_debug = __toESM(require_src());
+var debug = (0, import_debug.default)("cmd-ts:parser");
+function parse(tokens, forceFlag) {
+  if (debug.enabled) {
+    const registered = {
+      shortFlags: [...forceFlag.forceFlagShortNames],
+      longFlags: [...forceFlag.forceFlagLongNames],
+      shortOptions: [...forceFlag.forceOptionShortNames],
+      longOptions: [...forceFlag.forceOptionLongNames]
+    };
+    debug("Registered:", JSON.stringify(registered));
+  }
+  const nodes = [];
+  let index = 0;
+  let forcedPositional = false;
+  function getToken() {
+    return tokens[index++];
+  }
+  function peekToken() {
+    return tokens[index];
+  }
+  while (index < tokens.length) {
+    const currentToken = getToken();
+    if (!currentToken)
+      break;
+    if (currentToken.type === "argumentDivider") {
+      continue;
+    }
+    if (forcedPositional) {
+      let str = currentToken.raw;
+      let nextToken = getToken();
+      while (nextToken && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) !== "argumentDivider") {
+        str += nextToken.raw;
+        nextToken = getToken();
+      }
+      nodes.push({
+        type: "positionalArgument",
+        index: currentToken.index,
+        raw: str
+      });
+      continue;
+    }
+    if (currentToken.type === "char") {
+      let str = currentToken.raw;
+      let nextToken = getToken();
+      while (nextToken && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) !== "argumentDivider") {
+        str += nextToken.raw;
+        nextToken = getToken();
+      }
+      nodes.push({
+        type: "positionalArgument",
+        index: currentToken.index,
+        raw: str
+      });
+      continue;
+    }
+    if (currentToken.type === "longPrefix") {
+      let nextToken = getToken();
+      if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === "argumentDivider" || !nextToken) {
+        nodes.push({
+          type: "forcePositional",
+          index: currentToken.index,
+          raw: "--"
+        });
+        forcedPositional = true;
+        continue;
+      }
+      let key2 = "";
+      while (nextToken && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.raw) !== "=" && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) !== "argumentDivider") {
+        key2 += nextToken.raw;
+        nextToken = getToken();
+      }
+      const parsedValue = parseOptionValue({
+        key: key2,
+        delimiterToken: nextToken,
+        forceFlag: forceFlag.forceFlagLongNames,
+        getToken,
+        peekToken,
+        forceOption: forceFlag.forceOptionLongNames
+      });
+      let raw = `--${key2}`;
+      if (parsedValue) {
+        raw += parsedValue.raw;
+      }
+      nodes.push({
+        type: "longOption",
+        key: key2,
+        index: currentToken.index,
+        raw,
+        value: parsedValue
+      });
+      continue;
+    }
+    if (currentToken.type === "shortPrefix") {
+      const keys = [];
+      let nextToken = getToken();
+      if ((nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) === "argumentDivider" || !nextToken) {
+        nodes.push({
+          type: "positionalArgument",
+          index: currentToken.index,
+          raw: "-"
+        });
+        continue;
+      }
+      while (nextToken && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) !== "argumentDivider" && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.raw) !== "=") {
+        keys.push(nextToken);
+        nextToken = getToken();
+      }
+      const lastKey = keys.pop();
+      const parsedValue = parseOptionValue({
+        key: lastKey.raw,
+        delimiterToken: nextToken,
+        forceFlag: forceFlag.forceFlagShortNames,
+        forceOption: forceFlag.forceOptionShortNames,
+        getToken,
+        peekToken
+      });
+      const options = [];
+      for (const key2 of keys) {
+        options.push({
+          type: "shortOption",
+          index: key2.index,
+          raw: key2.raw,
+          key: key2.raw
+        });
+      }
+      let lastKeyRaw = lastKey.raw;
+      if (parsedValue) {
+        lastKeyRaw += parsedValue.raw;
+      }
+      options.push({
+        type: "shortOption",
+        index: lastKey.index,
+        raw: lastKeyRaw,
+        value: parsedValue,
+        key: lastKey.raw
+      });
+      let optionsRaw = `-${keys.map((x) => x.raw).join("")}${lastKey.raw}`;
+      if (parsedValue) {
+        optionsRaw += parsedValue.raw;
+      }
+      const shortOptions = {
+        type: "shortOptions",
+        index: currentToken.index,
+        raw: optionsRaw,
+        options
+      };
+      nodes.push(shortOptions);
+      continue;
+    }
+    index++;
+  }
+  if (debug.enabled) {
+    const objectNodes = nodes.map((node) => ({ [node.type]: node.raw }));
+    debug("Parsed items:", JSON.stringify(objectNodes));
+  }
+  return nodes;
+}
+function parseOptionValue(opts) {
+  var _a17;
+  const { getToken, delimiterToken, forceFlag, key: key2, forceOption } = opts;
+  const shouldReadKeyAsOption = forceOption.has(key2);
+  const shouldReadKeyAsFlag = !shouldReadKeyAsOption && (forceFlag.has(key2) || ((_a17 = opts.peekToken()) === null || _a17 === void 0 ? void 0 : _a17.type) !== "char");
+  if (!delimiterToken || delimiterToken.raw !== "=" && shouldReadKeyAsFlag) {
+    return;
+  }
+  const delimiter = delimiterToken.raw === "=" ? "=" : " ";
+  const delimiterIndex = delimiterToken.index;
+  let nextToken = getToken();
+  if (!nextToken) {
+    return;
+  }
+  let value = "";
+  const valueIndex = nextToken.index;
+  while (nextToken && (nextToken === null || nextToken === void 0 ? void 0 : nextToken.type) !== "argumentDivider") {
+    value += nextToken.raw;
+    nextToken = getToken();
+  }
+  return {
+    type: "optionValue",
+    index: delimiterToken.index,
+    delimiter: { type: "delimiter", raw: delimiter, index: delimiterIndex },
+    node: { type: "value", raw: value, index: valueIndex },
+    raw: `${delimiter}${value}`
+  };
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/newparser/tokenizer.js
+function tokenize(strings) {
+  const tokens = [];
+  let overallIndex = 0;
+  const push2 = (token2) => {
+    tokens.push(token2);
+    overallIndex += token2.raw.length;
+  };
+  for (const [stringIndex, string5] of enumerate(strings)) {
+    const chars = [...string5];
+    for (let i = 0; i < chars.length; i++) {
+      if (chars[i] === "-" && chars[i + 1] === "-") {
+        push2({ type: "longPrefix", raw: "--", index: overallIndex });
+        i++;
+      } else if (chars[i] === "-") {
+        push2({ type: "shortPrefix", raw: "-", index: overallIndex });
+      } else {
+        push2({ type: "char", raw: chars[i], index: overallIndex });
+      }
+    }
+    if (stringIndex + 1 !== strings.length) {
+      push2({ type: "argumentDivider", raw: " ", index: overallIndex });
+    }
+  }
+  return tokens;
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/runner.js
+async function run(ap, strings) {
+  const result = await runSafely(ap, strings);
+  if (isErr(result)) {
+    return result.error.run();
+  }
+  return result.value;
+}
+async function runSafely(ap, strings) {
+  const hotPath = [];
+  const nodes = parseCommon(ap, strings);
+  try {
+    const result = await ap.run({ nodes, visitedNodes: /* @__PURE__ */ new Set(), hotPath });
+    if (isErr(result)) {
+      throw new Exit({
+        message: errorBox(nodes, result.error.errors, hotPath),
+        exitCode: 1,
+        into: "stderr"
+      });
+    }
+    return ok(result.value);
+  } catch (e) {
+    if (e instanceof Exit) {
+      return err(e);
+    }
+    throw e;
+  }
+}
+function parseCommon(ap, strings) {
+  const longFlagKeys = /* @__PURE__ */ new Set();
+  const shortFlagKeys = /* @__PURE__ */ new Set();
+  const longOptionKeys = /* @__PURE__ */ new Set();
+  const shortOptionKeys = /* @__PURE__ */ new Set();
+  const registerContext = {
+    forceFlagShortNames: shortFlagKeys,
+    forceFlagLongNames: longFlagKeys,
+    forceOptionShortNames: shortOptionKeys,
+    forceOptionLongNames: longOptionKeys
+  };
+  ap.register(registerContext);
+  const tokens = tokenize(strings);
+  return parse(tokens, registerContext);
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/restPositionals.js
+function fullRestPositionals(config2) {
+  return {
+    helpTopics() {
+      var _a17, _b8, _c, _d;
+      const displayName = (_b8 = (_a17 = config2.displayName) !== null && _a17 !== void 0 ? _a17 : config2.type.displayName) !== null && _b8 !== void 0 ? _b8 : "arg";
+      return [
+        {
+          usage: `[...${displayName}]`,
+          category: "arguments",
+          defaults: [],
+          description: (_d = (_c = config2.description) !== null && _c !== void 0 ? _c : config2.type.description) !== null && _d !== void 0 ? _d : ""
+        }
+      ];
+    },
+    register(_opts) {
+    },
+    async parse({ nodes, visitedNodes }) {
+      const positionals = nodes.filter((node) => node.type === "positionalArgument" && !visitedNodes.has(node));
+      const results = [];
+      const errors = [];
+      for (const positional3 of positionals) {
+        visitedNodes.add(positional3);
+        const decoded = await safeAsync(config2.type.from(positional3.raw));
+        if (isOk(decoded)) {
+          results.push(decoded.value);
+        } else {
+          errors.push({
+            nodes: [positional3],
+            message: decoded.error.message
+          });
+        }
+      }
+      if (errors.length > 0) {
+        return err({
+          errors
+        });
+      }
+      return ok(results);
+    }
+  };
+}
+function restPositionals(config2) {
+  return fullRestPositionals({
+    type: string,
+    ...config2
+  });
+}
+
+// ../../node_modules/.bun/cmd-ts@0.14.3/node_modules/cmd-ts/dist/esm/oneOf.js
+import { inspect } from "node:util";
+function oneOf(literals) {
+  const examples = literals.map((x) => inspect(x)).join(", ");
+  return {
+    async from(str) {
+      const value = literals.find((x) => x === str);
+      if (!value) {
+        throw new Error(`Invalid value '${str}'. Expected one of: ${examples}`);
+      }
+      return value;
+    },
+    description: `One of ${examples}`
+  };
+}
 
 // src/commands/compare/index.ts
 import { readFileSync } from "node:fs";
-import { command, flag, number, oneOf, option, optional, positional, string } from "cmd-ts";
 
 // src/utils/case-conversion.ts
 function toSnakeCase(str) {
@@ -264,15 +2823,15 @@ function formatOutcome(outcome) {
   }
 }
 var ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
-function stripAnsi(str) {
+function stripAnsi2(str) {
   return str.replace(ansiPattern, "");
 }
 function padRight(str, len) {
-  const plainLen = stripAnsi(str).length;
+  const plainLen = stripAnsi2(str).length;
   return str + " ".repeat(Math.max(0, len - plainLen));
 }
 function padLeft(str, len) {
-  const plainLen = stripAnsi(str).length;
+  const plainLen = stripAnsi2(str).length;
   return " ".repeat(Math.max(0, len - plainLen)) + str;
 }
 function formatTable(comparison, file1, file2) {
@@ -1119,8 +3678,8 @@ var ZodType = class {
         } : {
           issues: ctx.common.issues
         };
-      } catch (err) {
-        if (err?.message?.toLowerCase()?.includes("encountered")) {
+      } catch (err2) {
+        if (err2?.message?.toLowerCase()?.includes("encountered")) {
           this["~standard"].async = true;
         }
         ctx.common = {
@@ -1260,8 +3819,8 @@ var ZodType = class {
   promise() {
     return ZodPromise.create(this, this._def);
   }
-  or(option6) {
-    return ZodUnion.create([this, option6], this._def);
+  or(option2) {
+    return ZodUnion.create([this, option2], this._def);
   }
   and(incoming) {
     return ZodIntersection.create(this, incoming, this._def);
@@ -1351,13 +3910,13 @@ function timeRegex(args) {
   return new RegExp(`^${timeRegexSource(args)}$`);
 }
 function datetimeRegex(args) {
-  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
+  let regex2 = `${dateRegexSource}T${timeRegexSource(args)}`;
   const opts = [];
   opts.push(args.local ? `Z?` : `Z`);
   if (args.offset)
     opts.push(`([+-]\\d{2}:?\\d{2})`);
-  regex = `${regex}(${opts.join("|")})`;
-  return new RegExp(`^${regex}$`);
+  regex2 = `${regex2}(${opts.join("|")})`;
+  return new RegExp(`^${regex2}$`);
 }
 function isValidIP(ip, version2) {
   if ((version2 === "v4" || !version2) && ipv4Regex.test(ip)) {
@@ -1603,8 +4162,8 @@ var ZodString = class _ZodString2 extends ZodType {
           status.dirty();
         }
       } else if (check2.kind === "datetime") {
-        const regex = datetimeRegex(check2);
-        if (!regex.test(input.data)) {
+        const regex2 = datetimeRegex(check2);
+        if (!regex2.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
@@ -1614,8 +4173,8 @@ var ZodString = class _ZodString2 extends ZodType {
           status.dirty();
         }
       } else if (check2.kind === "date") {
-        const regex = dateRegex;
-        if (!regex.test(input.data)) {
+        const regex2 = dateRegex;
+        if (!regex2.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
@@ -1625,8 +4184,8 @@ var ZodString = class _ZodString2 extends ZodType {
           status.dirty();
         }
       } else if (check2.kind === "time") {
-        const regex = timeRegex(check2);
-        if (!regex.test(input.data)) {
+        const regex2 = timeRegex(check2);
+        if (!regex2.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
           addIssueToContext(ctx, {
             code: ZodIssueCode.invalid_string,
@@ -1701,8 +4260,8 @@ var ZodString = class _ZodString2 extends ZodType {
     }
     return { status: status.value, value: input.data };
   }
-  _regex(regex, validation, message) {
-    return this.refinement((data) => regex.test(data), {
+  _regex(regex2, validation, message) {
+    return this.refinement((data) => regex2.test(data), {
       validation,
       code: ZodIssueCode.invalid_string,
       ...errorUtil.errToObj(message)
@@ -1794,10 +4353,10 @@ var ZodString = class _ZodString2 extends ZodType {
   duration(message) {
     return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
   }
-  regex(regex, message) {
+  regex(regex2, message) {
     return this._addCheck({
       kind: "regex",
-      regex,
+      regex: regex2,
       ...errorUtil.errToObj(message)
     });
   }
@@ -3111,7 +5670,7 @@ var ZodUnion = class extends ZodType {
       return INVALID;
     }
     if (ctx.common.async) {
-      return Promise.all(options.map(async (option6) => {
+      return Promise.all(options.map(async (option2) => {
         const childCtx = {
           ...ctx,
           common: {
@@ -3121,7 +5680,7 @@ var ZodUnion = class extends ZodType {
           parent: null
         };
         return {
-          result: await option6._parseAsync({
+          result: await option2._parseAsync({
             data: ctx.data,
             path: ctx.path,
             parent: childCtx
@@ -3132,7 +5691,7 @@ var ZodUnion = class extends ZodType {
     } else {
       let dirty = void 0;
       const issues = [];
-      for (const option6 of options) {
+      for (const option2 of options) {
         const childCtx = {
           ...ctx,
           common: {
@@ -3141,7 +5700,7 @@ var ZodUnion = class extends ZodType {
           },
           parent: null
         };
-        const result = option6._parseSync({
+        const result = option2._parseSync({
           data: ctx.data,
           path: ctx.path,
           parent: childCtx
@@ -3222,8 +5781,8 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
     }
     const discriminator = this.discriminator;
     const discriminatorValue = ctx.data[discriminator];
-    const option6 = this.optionsMap.get(discriminatorValue);
-    if (!option6) {
+    const option2 = this.optionsMap.get(discriminatorValue);
+    if (!option2) {
       addIssueToContext(ctx, {
         code: ZodIssueCode.invalid_union_discriminator,
         options: Array.from(this.optionsMap.keys()),
@@ -3232,13 +5791,13 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
       return INVALID;
     }
     if (ctx.common.async) {
-      return option6._parseAsync({
+      return option2._parseAsync({
         data: ctx.data,
         path: ctx.path,
         parent: ctx
       });
     } else {
-      return option6._parseSync({
+      return option2._parseSync({
         data: ctx.data,
         path: ctx.path,
         parent: ctx
@@ -4606,11 +7165,11 @@ var CliTargetConfigSchema = external_exports.object({
   verbose: external_exports.boolean().optional(),
   keepTempFiles: external_exports.boolean().optional()
 }).strict();
-function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
+function normalizeCliHealthcheck(input, env2, targetName, evalFilePath) {
   const timeoutSeconds = input.timeout_seconds ?? input.timeoutSeconds;
   const timeoutMs = timeoutSeconds !== void 0 ? Math.floor(timeoutSeconds * 1e3) : void 0;
   if (input.type === "http") {
-    const url2 = resolveString(input.url, env, `${targetName} healthcheck URL`);
+    const url2 = resolveString(input.url, env2, `${targetName} healthcheck URL`);
     return {
       type: "http",
       url: url2,
@@ -4625,11 +7184,11 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
   }
   const commandTemplate = resolveString(
     commandTemplateSource,
-    env,
+    env2,
     `${targetName} healthcheck command template`,
     true
   );
-  let cwd = resolveOptionalString(input.cwd, env, `${targetName} healthcheck cwd`, {
+  let cwd = resolveOptionalString(input.cwd, env2, `${targetName} healthcheck cwd`, {
     allowLiteral: true,
     optionalEnv: true
   });
@@ -4646,7 +7205,7 @@ function normalizeCliHealthcheck(input, env, targetName, evalFilePath) {
     timeoutMs
   };
 }
-function normalizeCliTargetInput(input, env, evalFilePath) {
+function normalizeCliTargetInput(input, env2, evalFilePath) {
   const targetName = input.name;
   const commandTemplateSource = input.command_template ?? input.commandTemplate;
   if (commandTemplateSource === void 0) {
@@ -4654,13 +7213,13 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
   }
   const commandTemplate = resolveString(
     commandTemplateSource,
-    env,
+    env2,
     `${targetName} CLI command template`,
     true
   );
   const filesFormatSource = input.files_format ?? input.filesFormat ?? input.attachments_format ?? input.attachmentsFormat;
   const filesFormat = resolveOptionalLiteralString(filesFormatSource);
-  let cwd = resolveOptionalString(input.cwd, env, `${targetName} working directory`, {
+  let cwd = resolveOptionalString(input.cwd, env2, `${targetName} working directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
@@ -4676,7 +7235,7 @@ function normalizeCliTargetInput(input, env, evalFilePath) {
   const keepTempFiles = resolveOptionalBoolean(
     input.keep_temp_files ?? input.keepTempFiles ?? input.keep_output_files ?? input.keepOutputFiles
   );
-  const healthcheck = input.healthcheck ? normalizeCliHealthcheck(input.healthcheck, env, targetName, evalFilePath) : void 0;
+  const healthcheck = input.healthcheck ? normalizeCliHealthcheck(input.healthcheck, env2, targetName, evalFilePath) : void 0;
   return {
     commandTemplate,
     filesFormat,
@@ -4745,7 +7304,7 @@ function resolveRetryConfig(target) {
     retryableStatusCodes
   };
 }
-function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
+function resolveTargetDefinition(definition, env2 = process.env, evalFilePath) {
   const parsed = BASE_TARGET_SCHEMA.parse(definition);
   const provider = parsed.provider.toLowerCase();
   const providerBatching = resolveOptionalBoolean(
@@ -4760,7 +7319,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveAzureConfig(parsed, env)
+        config: resolveAzureConfig(parsed, env2)
       };
     case "anthropic":
       return {
@@ -4769,7 +7328,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveAnthropicConfig(parsed, env)
+        config: resolveAnthropicConfig(parsed, env2)
       };
     case "gemini":
     case "google":
@@ -4780,7 +7339,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveGeminiConfig(parsed, env)
+        config: resolveGeminiConfig(parsed, env2)
       };
     case "codex":
     case "codex-cli":
@@ -4790,7 +7349,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveCodexConfig(parsed, env)
+        config: resolveCodexConfig(parsed, env2)
       };
     case "pi":
     case "pi-coding-agent":
@@ -4800,7 +7359,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolvePiCodingAgentConfig(parsed, env)
+        config: resolvePiCodingAgentConfig(parsed, env2)
       };
     case "pi-agent-sdk":
       return {
@@ -4809,7 +7368,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolvePiAgentSdkConfig(parsed, env)
+        config: resolvePiAgentSdkConfig(parsed, env2)
       };
     case "claude-code":
       return {
@@ -4818,7 +7377,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveClaudeCodeConfig(parsed, env)
+        config: resolveClaudeCodeConfig(parsed, env2)
       };
     case "mock":
       return {
@@ -4837,7 +7396,7 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveVSCodeConfig(parsed, env, provider === "vscode-insiders")
+        config: resolveVSCodeConfig(parsed, env2, provider === "vscode-insiders")
       };
     case "cli":
       return {
@@ -4846,24 +7405,24 @@ function resolveTargetDefinition(definition, env = process.env, evalFilePath) {
         judgeTarget: parsed.judge_target,
         workers: parsed.workers,
         providerBatching,
-        config: resolveCliConfig(parsed, env, evalFilePath)
+        config: resolveCliConfig(parsed, env2, evalFilePath)
       };
     default:
       throw new Error(`Unsupported provider '${parsed.provider}' in target '${parsed.name}'`);
   }
 }
-function resolveAzureConfig(target, env) {
+function resolveAzureConfig(target, env2) {
   const endpointSource = target.endpoint ?? target.resource ?? target.resourceName;
   const apiKeySource = target.api_key ?? target.apiKey;
   const deploymentSource = target.deployment ?? target.deploymentName ?? target.model;
   const versionSource = target.version ?? target.api_version;
   const temperatureSource = target.temperature;
   const maxTokensSource = target.max_output_tokens ?? target.maxTokens;
-  const resourceName = resolveString(endpointSource, env, `${target.name} endpoint`);
-  const apiKey = resolveString(apiKeySource, env, `${target.name} api key`);
-  const deploymentName = resolveString(deploymentSource, env, `${target.name} deployment`);
+  const resourceName = resolveString(endpointSource, env2, `${target.name} endpoint`);
+  const apiKey = resolveString(apiKeySource, env2, `${target.name} api key`);
+  const deploymentName = resolveString(deploymentSource, env2, `${target.name} deployment`);
   const version2 = normalizeAzureApiVersion(
-    resolveOptionalString(versionSource, env, `${target.name} api version`, {
+    resolveOptionalString(versionSource, env2, `${target.name} api version`, {
       allowLiteral: true,
       optionalEnv: true
     })
@@ -4884,14 +7443,14 @@ function resolveAzureConfig(target, env) {
     retry
   };
 }
-function resolveAnthropicConfig(target, env) {
+function resolveAnthropicConfig(target, env2) {
   const apiKeySource = target.api_key ?? target.apiKey;
   const modelSource = target.model ?? target.deployment ?? target.variant;
   const temperatureSource = target.temperature;
   const maxTokensSource = target.max_output_tokens ?? target.maxTokens;
   const thinkingBudgetSource = target.thinking_budget ?? target.thinkingBudget;
-  const apiKey = resolveString(apiKeySource, env, `${target.name} Anthropic api key`);
-  const model = resolveString(modelSource, env, `${target.name} Anthropic model`);
+  const apiKey = resolveString(apiKeySource, env2, `${target.name} Anthropic api key`);
+  const model = resolveString(modelSource, env2, `${target.name} Anthropic model`);
   const retry = resolveRetryConfig(target);
   return {
     apiKey,
@@ -4902,13 +7461,13 @@ function resolveAnthropicConfig(target, env) {
     retry
   };
 }
-function resolveGeminiConfig(target, env) {
+function resolveGeminiConfig(target, env2) {
   const apiKeySource = target.api_key ?? target.apiKey;
   const modelSource = target.model ?? target.deployment ?? target.variant;
   const temperatureSource = target.temperature;
   const maxTokensSource = target.max_output_tokens ?? target.maxTokens;
-  const apiKey = resolveString(apiKeySource, env, `${target.name} Google API key`);
-  const model = resolveOptionalString(modelSource, env, `${target.name} Gemini model`, {
+  const apiKey = resolveString(apiKeySource, env2, `${target.name} Google API key`);
+  const model = resolveOptionalString(modelSource, env2, `${target.name} Gemini model`, {
     allowLiteral: true,
     optionalEnv: true
   }) ?? "gemini-2.5-flash";
@@ -4921,25 +7480,25 @@ function resolveGeminiConfig(target, env) {
     retry
   };
 }
-function resolveCodexConfig(target, env) {
+function resolveCodexConfig(target, env2) {
   const executableSource = target.executable ?? target.command ?? target.binary;
   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 ?? env.AGENTV_CODEX_LOG_FORMAT;
+  const logFormatSource = target.log_format ?? target.logFormat ?? target.log_output_format ?? target.logOutputFormat ?? env2.AGENTV_CODEX_LOG_FORMAT;
   const systemPromptSource = target.system_prompt ?? target.systemPrompt;
-  const executable = resolveOptionalString(executableSource, env, `${target.name} codex executable`, {
+  const executable = resolveOptionalString(executableSource, env2, `${target.name} codex executable`, {
     allowLiteral: true,
     optionalEnv: true
   }) ?? "codex";
-  const args = resolveOptionalStringArray(argsSource, env, `${target.name} codex args`);
-  const cwd = resolveOptionalString(cwdSource, env, `${target.name} codex cwd`, {
+  const args = resolveOptionalStringArray(argsSource, env2, `${target.name} codex args`);
+  const cwd = resolveOptionalString(cwdSource, env2, `${target.name} codex cwd`, {
     allowLiteral: true,
     optionalEnv: true
   });
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} codex timeout`);
-  const logDir = resolveOptionalString(logDirSource, env, `${target.name} codex log directory`, {
+  const logDir = resolveOptionalString(logDirSource, env2, `${target.name} codex log directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
@@ -4968,7 +7527,7 @@ function normalizeCodexLogFormat(value) {
   }
   throw new Error("codex log format must be 'summary' or 'json'");
 }
-function resolvePiCodingAgentConfig(target, env) {
+function resolvePiCodingAgentConfig(target, env2) {
   const executableSource = target.executable ?? target.command ?? target.binary;
   const providerSource = target.pi_provider ?? target.piProvider ?? target.llm_provider;
   const modelSource = target.model ?? target.pi_model ?? target.piModel;
@@ -4981,37 +7540,37 @@ function resolvePiCodingAgentConfig(target, env) {
   const logDirSource = target.log_dir ?? target.logDir ?? target.log_directory ?? target.logDirectory;
   const logFormatSource = target.log_format ?? target.logFormat;
   const systemPromptSource = target.system_prompt ?? target.systemPrompt;
-  const executable = resolveOptionalString(executableSource, env, `${target.name} pi executable`, {
+  const executable = resolveOptionalString(executableSource, env2, `${target.name} pi executable`, {
     allowLiteral: true,
     optionalEnv: true
   }) ?? "pi";
-  const provider = resolveOptionalString(providerSource, env, `${target.name} pi provider`, {
+  const provider = resolveOptionalString(providerSource, env2, `${target.name} pi provider`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const model = resolveOptionalString(modelSource, env, `${target.name} pi model`, {
+  const model = resolveOptionalString(modelSource, env2, `${target.name} pi model`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const apiKey = resolveOptionalString(apiKeySource, env, `${target.name} pi api key`, {
+  const apiKey = resolveOptionalString(apiKeySource, env2, `${target.name} pi api key`, {
     allowLiteral: false,
     optionalEnv: true
   });
-  const tools = resolveOptionalString(toolsSource, env, `${target.name} pi tools`, {
+  const tools = resolveOptionalString(toolsSource, env2, `${target.name} pi tools`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const thinking = resolveOptionalString(thinkingSource, env, `${target.name} pi thinking`, {
+  const thinking = resolveOptionalString(thinkingSource, env2, `${target.name} pi thinking`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const args = resolveOptionalStringArray(argsSource, env, `${target.name} pi args`);
-  const cwd = resolveOptionalString(cwdSource, env, `${target.name} pi cwd`, {
+  const args = resolveOptionalStringArray(argsSource, env2, `${target.name} pi args`);
+  const cwd = resolveOptionalString(cwdSource, env2, `${target.name} pi cwd`, {
     allowLiteral: true,
     optionalEnv: true
   });
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} pi timeout`);
-  const logDir = resolveOptionalString(logDirSource, env, `${target.name} pi log directory`, {
+  const logDir = resolveOptionalString(logDirSource, env2, `${target.name} pi log directory`, {
     allowLiteral: true,
     optionalEnv: true
   });
@@ -5032,7 +7591,7 @@ function resolvePiCodingAgentConfig(target, env) {
     systemPrompt
   };
 }
-function resolvePiAgentSdkConfig(target, env) {
+function resolvePiAgentSdkConfig(target, env2) {
   const providerSource = target.pi_provider ?? target.piProvider ?? target.llm_provider;
   const modelSource = target.model ?? target.pi_model ?? target.piModel;
   const apiKeySource = target.api_key ?? target.apiKey;
@@ -5040,18 +7599,18 @@ function resolvePiAgentSdkConfig(target, env) {
   const systemPromptSource = target.system_prompt ?? target.systemPrompt;
   const provider = resolveOptionalString(
     providerSource,
-    env,
+    env2,
     `${target.name} pi-agent-sdk provider`,
     {
       allowLiteral: true,
       optionalEnv: true
     }
   );
-  const model = resolveOptionalString(modelSource, env, `${target.name} pi-agent-sdk model`, {
+  const model = resolveOptionalString(modelSource, env2, `${target.name} pi-agent-sdk model`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const apiKey = resolveOptionalString(apiKeySource, env, `${target.name} pi-agent-sdk api key`, {
+  const apiKey = resolveOptionalString(apiKeySource, env2, `${target.name} pi-agent-sdk api key`, {
     allowLiteral: false,
     optionalEnv: true
   });
@@ -5065,32 +7624,32 @@ function resolvePiAgentSdkConfig(target, env) {
     systemPrompt
   };
 }
-function resolveClaudeCodeConfig(target, env) {
+function resolveClaudeCodeConfig(target, env2) {
   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 ?? env.AGENTV_CLAUDE_CODE_LOG_FORMAT;
+  const logFormatSource = target.log_format ?? target.logFormat ?? target.log_output_format ?? target.logOutputFormat ?? env2.AGENTV_CLAUDE_CODE_LOG_FORMAT;
   const systemPromptSource = target.system_prompt ?? target.systemPrompt;
-  const executable = resolveOptionalString(executableSource, env, `${target.name} claude-code executable`, {
+  const executable = resolveOptionalString(executableSource, env2, `${target.name} claude-code executable`, {
     allowLiteral: true,
     optionalEnv: true
   }) ?? "claude";
-  const model = resolveOptionalString(modelSource, env, `${target.name} claude-code model`, {
+  const model = resolveOptionalString(modelSource, env2, `${target.name} claude-code model`, {
     allowLiteral: true,
     optionalEnv: true
   });
-  const args = resolveOptionalStringArray(argsSource, env, `${target.name} claude-code args`);
-  const cwd = resolveOptionalString(cwdSource, env, `${target.name} claude-code cwd`, {
+  const args = resolveOptionalStringArray(argsSource, env2, `${target.name} claude-code args`);
+  const cwd = resolveOptionalString(cwdSource, env2, `${target.name} claude-code cwd`, {
     allowLiteral: true,
     optionalEnv: true
   });
   const timeoutMs = resolveTimeoutMs(timeoutSource, `${target.name} claude-code timeout`);
   const logDir = resolveOptionalString(
     logDirSource,
-    env,
+    env2,
     `${target.name} claude-code log directory`,
     {
       allowLiteral: true,
@@ -5127,13 +7686,13 @@ function resolveMockConfig(target) {
   const response = typeof target.response === "string" ? target.response : void 0;
   return { response };
 }
-function resolveVSCodeConfig(target, env, insiders) {
+function resolveVSCodeConfig(target, env2, insiders) {
   const workspaceTemplateEnvVar = resolveOptionalLiteralString(
     target.workspace_template ?? target.workspaceTemplate
   );
   const workspaceTemplate = workspaceTemplateEnvVar ? resolveOptionalString(
     workspaceTemplateEnvVar,
-    env,
+    env2,
     `${target.name} workspace template path`,
     {
       allowLiteral: false,
@@ -5145,12 +7704,12 @@ function resolveVSCodeConfig(target, env, insiders) {
   const dryRunSource = target.dry_run ?? target.dryRun;
   const subagentRootSource = target.subagent_root ?? target.subagentRoot;
   const defaultCommand = insiders ? "code-insiders" : "code";
-  const command7 = resolveOptionalLiteralString(commandSource) ?? defaultCommand;
+  const command2 = resolveOptionalLiteralString(commandSource) ?? defaultCommand;
   return {
-    command: command7,
+    command: command2,
     waitForResponse: resolveOptionalBoolean(waitSource) ?? true,
     dryRun: resolveOptionalBoolean(dryRunSource) ?? false,
-    subagentRoot: resolveOptionalString(subagentRootSource, env, `${target.name} subagent root`, {
+    subagentRoot: resolveOptionalString(subagentRootSource, env2, `${target.name} subagent root`, {
       allowLiteral: true,
       optionalEnv: true
     }),
@@ -5169,7 +7728,7 @@ var cliErrorMap = (issue2, ctx) => {
   }
   return { message: ctx.defaultError };
 };
-function resolveCliConfig(target, env, evalFilePath) {
+function resolveCliConfig(target, env2, evalFilePath) {
   const parseResult = CliTargetInputSchema.safeParse(target, { errorMap: cliErrorMap });
   if (!parseResult.success) {
     const firstError = parseResult.error.errors[0];
@@ -5177,7 +7736,7 @@ function resolveCliConfig(target, env, evalFilePath) {
     const prefix = path34 ? `${target.name} ${path34}: ` : `${target.name}: `;
     throw new Error(`${prefix}${firstError?.message}`);
   }
-  const normalized = normalizeCliTargetInput(parseResult.data, env, evalFilePath);
+  const normalized = normalizeCliTargetInput(parseResult.data, env2, evalFilePath);
   assertSupportedCliPlaceholders(normalized.commandTemplate, `${target.name} CLI command template`);
   if (normalized.healthcheck?.type === "command") {
     assertSupportedCliPlaceholders(
@@ -5217,8 +7776,8 @@ function extractCliPlaceholders(template) {
   }
   return results;
 }
-function resolveString(source2, env, description, allowLiteral = false) {
-  const value = resolveOptionalString(source2, env, description, {
+function resolveString(source2, env2, description, allowLiteral = false) {
+  const value = resolveOptionalString(source2, env2, description, {
     allowLiteral,
     optionalEnv: false
   });
@@ -5227,7 +7786,7 @@ function resolveString(source2, env, description, allowLiteral = false) {
   }
   return value;
 }
-function resolveOptionalString(source2, env, description, options) {
+function resolveOptionalString(source2, env2, description, options) {
   if (source2 === void 0 || source2 === null) {
     return void 0;
   }
@@ -5241,7 +7800,7 @@ function resolveOptionalString(source2, env, description, options) {
   const envVarMatch = trimmed.match(/^\$\{\{\s*([A-Z0-9_]+)\s*\}\}$/i);
   if (envVarMatch) {
     const varName = envVarMatch[1];
-    const envValue = env[varName];
+    const envValue = env2[varName];
     const optionalEnv = options?.optionalEnv ?? false;
     if (envValue === void 0 || envValue.trim().length === 0) {
       if (optionalEnv) {
@@ -5303,7 +7862,7 @@ function resolveOptionalBoolean(source2) {
   }
   throw new Error("expected boolean value");
 }
-function resolveOptionalStringArray(source2, env, description) {
+function resolveOptionalStringArray(source2, env2, description) {
   if (source2 === void 0 || source2 === null) {
     return void 0;
   }
@@ -5326,7 +7885,7 @@ function resolveOptionalStringArray(source2, env, description) {
     const envVarMatch = trimmed.match(/^\$\{\{\s*([A-Z0-9_]+)\s*\}\}$/i);
     if (envVarMatch) {
       const varName = envVarMatch[1];
-      const envValue = env[varName];
+      const envValue = env2[varName];
       if (envValue !== void 0) {
         if (envValue.trim().length === 0) {
           throw new Error(`Environment variable '${varName}' for ${description}[${i}] is empty`);
@@ -5425,7 +7984,7 @@ import { parse as parse22 } from "yaml";
 import { readFile as readFile4 } from "node:fs/promises";
 import path22 from "node:path";
 import micromatch from "micromatch";
-import { parse as parse5 } from "yaml";
+import { parse as parse7 } from "yaml";
 import { constants as constants3 } from "node:fs";
 import { access as access3 } from "node:fs/promises";
 import path13 from "node:path";
@@ -5961,7 +8520,7 @@ __export(external_exports2, {
   base64: () => base642,
   base64url: () => base64url2,
   bigint: () => bigint2,
-  boolean: () => boolean2,
+  boolean: () => boolean4,
   catch: () => _catch2,
   check: () => check,
   cidrv4: () => cidrv42,
@@ -6035,7 +8594,7 @@ __export(external_exports2, {
   object: () => object,
   optional: () => optional2,
   overwrite: () => _overwrite,
-  parse: () => parse2,
+  parse: () => parse4,
   parseAsync: () => parseAsync2,
   partialRecord: () => partialRecord,
   pipe: () => pipe,
@@ -6318,7 +8877,7 @@ __export(core_exports2, {
   isValidBase64URL: () => isValidBase64URL,
   isValidJWT: () => isValidJWT2,
   locales: () => locales_exports,
-  parse: () => parse,
+  parse: () => parse3,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
   regexes: () => regexes_exports,
@@ -6458,9 +9017,9 @@ function assertNever(_x) {
 }
 function assert(_) {
 }
-function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+function getEnumValues(entries2) {
+  const numericValues = Object.values(entries2).filter((v) => typeof v === "number");
+  const values = Object.entries(entries2).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
   return values;
 }
 function joinValues(array2, separator = "|") {
@@ -7074,7 +9633,7 @@ var _parse = (_Err) => (schema, value, _ctx, _params) => {
   }
   return result.value;
 };
-var parse = /* @__PURE__ */ _parse($ZodRealError);
+var parse3 = /* @__PURE__ */ _parse($ZodRealError);
 var _parseAsync = (_Err) => async (schema, value, _ctx, params) => {
   const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
   let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -7119,7 +9678,7 @@ __export(regexes_exports, {
   base64: () => base64,
   base64url: () => base64url,
   bigint: () => bigint,
-  boolean: () => boolean,
+  boolean: () => boolean3,
   browserEmail: () => browserEmail,
   cidrv4: () => cidrv4,
   cidrv6: () => cidrv6,
@@ -7196,8 +9755,8 @@ var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][
 var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
 function timeSource(args) {
   const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
-  return regex;
+  const regex2 = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  return regex2;
 }
 function time(args) {
   return new RegExp(`^${timeSource(args)}$`);
@@ -7213,13 +9772,13 @@ function datetime(args) {
   return new RegExp(`^${dateSource}T(?:${timeRegex2})$`);
 }
 var string2 = (params) => {
-  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-  return new RegExp(`^${regex}$`);
+  const regex2 = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex2}$`);
 };
 var bigint = /^\d+n?$/;
 var integer = /^\d+$/;
 var number2 = /^-?\d+(?:\.\d+)?/i;
-var boolean = /true|false/i;
+var boolean3 = /true|false/i;
 var _null = /null/i;
 var _undefined = /undefined/i;
 var lowercase = /^[^A-Z]*$/;
@@ -8234,7 +10793,7 @@ var $ZodNumberFormat = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) =>
 });
 var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
   $ZodType.init(inst, def);
-  inst._zod.pattern = boolean;
+  inst._zod.pattern = boolean3;
   inst._zod.parse = (payload, _ctx) => {
     if (def.coerce)
       try {
@@ -8633,7 +11192,7 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
   defineLazy(inst._zod, "values", () => {
     if (def.options.every((o) => o._zod.values)) {
-      return new Set(def.options.flatMap((option6) => Array.from(option6._zod.values)));
+      return new Set(def.options.flatMap((option2) => Array.from(option2._zod.values)));
     }
     return void 0;
   });
@@ -8647,8 +11206,8 @@ var $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   inst._zod.parse = (payload, ctx) => {
     let async = false;
     const results = [];
-    for (const option6 of def.options) {
-      const result = option6._zod.run({
+    for (const option2 of def.options) {
+      const result = option2._zod.run({
         value: payload.value,
         issues: []
       }, ctx);
@@ -8673,10 +11232,10 @@ var $ZodDiscriminatedUnion = /* @__PURE__ */ $constructor("$ZodDiscriminatedUnio
   const _super = inst._zod.parse;
   defineLazy(inst._zod, "propValues", () => {
     const propValues = {};
-    for (const option6 of def.options) {
-      const pv = option6._zod.propValues;
+    for (const option2 of def.options) {
+      const pv = option2._zod.propValues;
       if (!pv || Object.keys(pv).length === 0)
-        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option6)}"`);
+        throw new Error(`Invalid discriminated union option at index "${def.options.indexOf(option2)}"`);
       for (const [k, v] of Object.entries(pv)) {
         if (!propValues[k])
           propValues[k] = /* @__PURE__ */ new Set();
@@ -14909,17 +17468,17 @@ function _set(Class2, valueType, params) {
   });
 }
 function _enum(Class2, values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries2 = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
   return new Class2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...normalizeParams(params)
   });
 }
-function _nativeEnum(Class2, entries, params) {
+function _nativeEnum(Class2, entries2, params) {
   return new Class2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...normalizeParams(params)
   });
 }
@@ -15117,12 +17676,12 @@ var $ZodFunction = class {
       throw new Error("implement() must be called with a function");
     }
     const impl = (...args) => {
-      const parsedArgs = this._def.input ? parse(this._def.input, args, void 0, { callee: impl }) : args;
+      const parsedArgs = this._def.input ? parse3(this._def.input, args, void 0, { callee: impl }) : args;
       if (!Array.isArray(parsedArgs)) {
         throw new Error("Invalid arguments schema: not an array or tuple schema.");
       }
       const output = func(...parsedArgs);
-      return this._def.output ? parse(this._def.output, output, void 0, { callee: impl }) : output;
+      return this._def.output ? parse3(this._def.output, output, void 0, { callee: impl }) : output;
     };
     return impl;
   }
@@ -15248,9 +17807,9 @@ var JSONSchemaGenerator = class {
                 json2.pattern = regexes[0].source;
               else if (regexes.length > 1) {
                 result.schema.allOf = [
-                  ...regexes.map((regex) => ({
+                  ...regexes.map((regex2) => ({
                     ...this.target === "draft-7" ? { type: "string" } : {},
-                    pattern: regex.source
+                    pattern: regex2.source
                   }))
                 ];
               }
@@ -15880,8 +18439,8 @@ function isTransforming(_schema, _ctx) {
       return false;
     }
     case "union": {
-      for (const option6 of def.options) {
-        if (isTransforming(option6, ctx))
+      for (const option2 of def.options) {
+        if (isTransforming(option2, ctx))
           return true;
       }
       return false;
@@ -16022,7 +18581,7 @@ var ZodRealError = $constructor("ZodError", initializer2, {
 });
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v4/classic/parse.js
-var parse2 = /* @__PURE__ */ _parse(ZodRealError);
+var parse4 = /* @__PURE__ */ _parse(ZodRealError);
 var parseAsync2 = /* @__PURE__ */ _parseAsync(ZodRealError);
 var safeParse2 = /* @__PURE__ */ _safeParse(ZodRealError);
 var safeParseAsync2 = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -16050,7 +18609,7 @@ var ZodType2 = /* @__PURE__ */ $constructor("ZodType", (inst, def) => {
     reg.add(inst, meta);
     return inst;
   };
-  inst.parse = (data, params) => parse2(inst, data, params, { callee: inst.parse });
+  inst.parse = (data, params) => parse4(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => safeParse2(inst, data, params);
   inst.parseAsync = async (data, params) => parseAsync2(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => safeParseAsync2(inst, data, params);
@@ -16354,7 +18913,7 @@ var ZodBoolean2 = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
   $ZodBoolean.init(inst, def);
   ZodType2.init(inst, def);
 });
-function boolean2(params) {
+function boolean4(params) {
   return _boolean(ZodBoolean2, params);
 }
 var ZodBigInt2 = /* @__PURE__ */ $constructor("ZodBigInt", (inst, def) => {
@@ -16664,17 +19223,17 @@ var ZodEnum2 = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   };
 });
 function _enum2(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries2 = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
   return new ZodEnum2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...util_exports.normalizeParams(params)
   });
 }
-function nativeEnum(entries, params) {
+function nativeEnum(entries2, params) {
   return new ZodEnum2({
     type: "enum",
-    entries,
+    entries: entries2,
     ...util_exports.normalizeParams(params)
   });
 }
@@ -16956,7 +19515,7 @@ var stringbool = (...args) => _stringbool({
 }, ...args);
 function json(params) {
   const jsonSchema2 = lazy(() => {
-    return union([string3(params), number3(), boolean2(), _null3(), array(jsonSchema2), record(string3(), jsonSchema2)]);
+    return union([string3(params), number3(), boolean4(), _null3(), array(jsonSchema2), record(string3(), jsonSchema2)]);
   });
   return jsonSchema2;
 }
@@ -16991,7 +19550,7 @@ function getErrorMap2() {
 var coerce_exports = {};
 __export(coerce_exports, {
   bigint: () => bigint3,
-  boolean: () => boolean3,
+  boolean: () => boolean5,
   date: () => date4,
   number: () => number4,
   string: () => string4
@@ -17002,7 +19561,7 @@ function string4(params) {
 function number4(params) {
   return _coercedNumber(ZodNumber2, params);
 }
-function boolean3(params) {
+function boolean5(params) {
   return _coercedBoolean(ZodBoolean2, params);
 }
 function bigint3(params) {
@@ -18286,7 +20845,7 @@ function addFormat(schema, value, message, refs) {
     schema.format = value;
   }
 }
-function addPattern(schema, regex, message, refs) {
+function addPattern(schema, regex2, message, refs) {
   var _a17;
   if (schema.pattern || ((_a17 = schema.allOf) == null ? void 0 : _a17.some((x) => x.pattern))) {
     if (!schema.allOf) {
@@ -18299,27 +20858,27 @@ function addPattern(schema, regex, message, refs) {
       delete schema.pattern;
     }
     schema.allOf.push({
-      pattern: stringifyRegExpWithFlags(regex, refs),
+      pattern: stringifyRegExpWithFlags(regex2, refs),
       ...message && refs.errorMessages && { errorMessage: { pattern: message } }
     });
   } else {
-    schema.pattern = stringifyRegExpWithFlags(regex, refs);
+    schema.pattern = stringifyRegExpWithFlags(regex2, refs);
   }
 }
-function stringifyRegExpWithFlags(regex, refs) {
+function stringifyRegExpWithFlags(regex2, refs) {
   var _a17;
-  if (!refs.applyRegexFlags || !regex.flags) {
-    return regex.source;
+  if (!refs.applyRegexFlags || !regex2.flags) {
+    return regex2.source;
   }
   const flags = {
-    i: regex.flags.includes("i"),
+    i: regex2.flags.includes("i"),
     // Case-insensitive
-    m: regex.flags.includes("m"),
+    m: regex2.flags.includes("m"),
     // `^` and `$` matches adjacent to newline characters
-    s: regex.flags.includes("s")
+    s: regex2.flags.includes("s")
     // `.` matches newlines
   };
-  const source2 = flags.i ? regex.source.toLowerCase() : regex.source;
+  const source2 = flags.i ? regex2.source.toLowerCase() : regex2.source;
   let pattern = "";
   let isEscaped = false;
   let inCharGroup = false;
@@ -18384,7 +20943,7 @@ function stringifyRegExpWithFlags(regex, refs) {
         "/"
       )} to a flag-independent form! Falling back to the flag-ignorant source`
     );
-    return regex.source;
+    return regex2.source;
   }
   return pattern;
 }
@@ -29300,13 +31859,13 @@ function registerGlobal(type, instance, diag, allowOverride) {
     version: VERSION6
   };
   if (!allowOverride && api[type]) {
-    var err = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
-    diag.error(err.stack || err.message);
+    var err2 = new Error("@opentelemetry/api: Attempted duplicate registration of API: " + type);
+    diag.error(err2.stack || err2.message);
     return false;
   }
   if (api.version !== VERSION6) {
-    var err = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION6);
-    diag.error(err.stack || err.message);
+    var err2 = new Error("@opentelemetry/api: Registration of version v" + api.version + " for " + type + " does not match previously registered API v" + VERSION6);
+    diag.error(err2.stack || err2.message);
     return false;
   }
   api[type] = instance;
@@ -29497,8 +32056,8 @@ var DiagAPI = (
           optionsOrLogLevel = { logLevel: DiagLogLevel.INFO };
         }
         if (logger === self) {
-          var err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
-          self.error((_a17 = err.stack) !== null && _a17 !== void 0 ? _a17 : err.message);
+          var err2 = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self.error((_a17 = err2.stack) !== null && _a17 !== void 0 ? _a17 : err2.message);
           return false;
         }
         if (typeof optionsOrLogLevel === "number") {
@@ -33034,7 +35593,7 @@ import path92 from "node:path";
 import path82 from "node:path";
 import { exec as execWithCallback } from "node:child_process";
 import fs from "node:fs/promises";
-import os2 from "node:os";
+import os3 from "node:os";
 import path102 from "node:path";
 import { promisify as promisify2 } from "node:util";
 import { exec as execCallback, spawn as spawn22 } from "node:child_process";
@@ -33072,8 +35631,8 @@ async function ensureDir(target) {
   await mkdir(target, { recursive: true });
 }
 async function readDirEntries(target) {
-  const entries = await readdir(target, { withFileTypes: true });
-  return entries.map((entry) => ({
+  const entries2 = await readdir(target, { withFileTypes: true });
+  return entries2.map((entry) => ({
     name: entry.name,
     absolutePath: path3.join(target, entry.name),
     isDirectory: entry.isDirectory()
@@ -33304,13 +35863,13 @@ import path8 from "node:path";
 import { promisify } from "node:util";
 
 // ../../node_modules/.bun/subagent@0.5.6/node_modules/subagent/dist/vscode/constants.js
-import os from "node:os";
+import os2 from "node:os";
 import path7 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 path7.join(os.homedir(), ".subagent", folder);
+  return path7.join(os2.homedir(), ".subagent", folder);
 }
 var DEFAULT_SUBAGENT_ROOT = getDefaultSubagentRoot();
 
@@ -33455,7 +36014,7 @@ var column;
 var token;
 var key;
 var root;
-var parse3 = function parse4(text2, reviver) {
+var parse5 = function parse6(text2, reviver) {
   source = String(text2);
   parseState = "start";
   stack = [];
@@ -34281,10 +36840,10 @@ function formatChar(c3) {
   return c3;
 }
 function syntaxError(message) {
-  const err = new SyntaxError(message);
-  err.lineNumber = line;
-  err.columnNumber = column;
-  return err;
+  const err2 = new SyntaxError(message);
+  err2.lineNumber = line;
+  err2.columnNumber = column;
+  return err2;
 }
 var stringify = function stringify2(value, replacer, space) {
   const stack2 = [];
@@ -34499,7 +37058,7 @@ var stringify = function stringify2(value, replacer, space) {
   }
 };
 var JSON5 = {
-  parse: parse3,
+  parse: parse5,
   stringify
 };
 var lib = JSON5;
@@ -34590,8 +37149,8 @@ async function findUnlockedSubagent(subagentRoot) {
   if (!await pathExists(subagentRoot)) {
     return null;
   }
-  const entries = await readDirEntries(subagentRoot);
-  const subagents = entries.filter((entry) => entry.isDirectory && entry.name.startsWith("subagent-")).map((entry) => ({
+  const entries2 = await readDirEntries(subagentRoot);
+  const subagents = entries2.filter((entry) => entry.isDirectory && entry.name.startsWith("subagent-")).map((entry) => ({
     absolutePath: entry.absolutePath,
     number: Number.parseInt(entry.name.split("-")[1] ?? "", 10)
   })).filter((entry) => Number.isInteger(entry.number)).sort((a, b) => a.number - b.number);
@@ -34652,8 +37211,8 @@ async function removeSubagentLock(subagentDir) {
   const lockFile = path10.join(subagentDir, DEFAULT_LOCK_NAME);
   await removeIfExists(lockFile);
 }
-async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun) {
-  if (dryRun) {
+async function prepareSubagentDirectory(subagentDir, promptFile, chatId, workspaceTemplate, dryRun2) {
+  if (dryRun2) {
     return 0;
   }
   try {
@@ -34715,7 +37274,7 @@ async function resolveAttachments(extraAttachments) {
   return resolved;
 }
 async function dispatchAgentSession(options) {
-  const { userQuery, promptFile, requestTemplate, extraAttachments, workspaceTemplate, dryRun = false, wait = true, vscodeCmd = "code", subagentRoot, silent = false } = options;
+  const { userQuery, promptFile, requestTemplate, extraAttachments, workspaceTemplate, dryRun: dryRun2 = false, wait = true, vscodeCmd = "code", subagentRoot, silent = false } = options;
   try {
     let resolvedPrompt;
     try {
@@ -34737,7 +37296,7 @@ async function dispatchAgentSession(options) {
     }
     const subagentName = path11.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
-    const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
+    const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun2);
     if (preparationResult !== 0) {
       return {
         exitCode: preparationResult,
@@ -34760,7 +37319,7 @@ async function dispatchAgentSession(options) {
     const responseFileTmp = path11.join(messagesDir, `${timestamp}_res.tmp.md`);
     const responseFileFinal = path11.join(messagesDir, `${timestamp}_res.md`);
     const requestInstructions = createRequestPrompt(userQuery, responseFileTmp, responseFileFinal, templateContent);
-    if (dryRun) {
+    if (dryRun2) {
       return {
         exitCode: 0,
         subagentName,
@@ -34811,7 +37370,7 @@ async function dispatchAgentSession(options) {
   }
 }
 async function dispatchBatchAgent(options) {
-  const { userQueries, promptFile, requestTemplate, extraAttachments, workspaceTemplate, dryRun = false, wait = false, vscodeCmd = "code", subagentRoot, silent = false } = options;
+  const { userQueries, promptFile, requestTemplate, extraAttachments, workspaceTemplate, dryRun: dryRun2 = false, wait = false, vscodeCmd = "code", subagentRoot, silent = false } = options;
   if (!userQueries || userQueries.length === 0) {
     return {
       exitCode: 1,
@@ -34850,7 +37409,7 @@ async function dispatchBatchAgent(options) {
     }
     subagentName = path11.basename(subagentDir);
     const chatId = Math.random().toString(16).slice(2, 10);
-    const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun);
+    const preparationResult = await prepareSubagentDirectory(subagentDir, resolvedPrompt, chatId, workspaceTemplate, dryRun2);
     if (preparationResult !== 0) {
       return {
         exitCode: preparationResult,
@@ -34878,7 +37437,7 @@ async function dispatchBatchAgent(options) {
     const responseTmpFiles = userQueries.map((_, index) => path11.join(messagesDir, `${timestamp}_${index}_res.tmp.md`));
     responseFilesFinal = userQueries.map((_, index) => path11.join(messagesDir, `${timestamp}_${index}_res.md`));
     const orchestratorFile = path11.join(messagesDir, `${timestamp}_orchestrator.md`);
-    if (!dryRun) {
+    if (!dryRun2) {
       await Promise.all(userQueries.map((query, index) => writeFile3(requestFiles[index], createBatchRequestPrompt(query, responseTmpFiles[index], responseFilesFinal[index], batchRequestTemplateContent), { encoding: "utf8" })));
       const orchestratorContent = createBatchOrchestratorPrompt(requestFiles, responseFilesFinal, orchestratorTemplateContent);
       await writeFile3(orchestratorFile, orchestratorContent, { encoding: "utf8" });
@@ -34886,7 +37445,7 @@ async function dispatchBatchAgent(options) {
     const chatAttachments = [orchestratorFile, ...attachments];
     const orchestratorUri = pathToFileUri(orchestratorFile);
     const chatInstruction = `Follow instructions in [${timestamp}_orchestrator.md](${orchestratorUri}). Use #runSubagent tool.`;
-    if (dryRun) {
+    if (dryRun2) {
       return {
         exitCode: 0,
         subagentName,
@@ -34965,20 +37524,20 @@ tools: ['edit', 'runNotebooks', 'search', 'new', 'runCommands', 'runTasks', 'usa
 model: GPT-4.1 (copilot)
 ---`;
 async function provisionSubagents(options) {
-  const { targetRoot, subagents, lockName = DEFAULT_LOCK_NAME, force = false, dryRun = false, workspaceTemplate = DEFAULT_WORKSPACE_TEMPLATE2, wakeupContent = DEFAULT_WAKEUP_CONTENT2 } = options;
+  const { targetRoot, subagents, lockName = DEFAULT_LOCK_NAME, force = false, dryRun: dryRun2 = false, workspaceTemplate = DEFAULT_WORKSPACE_TEMPLATE2, wakeupContent = DEFAULT_WAKEUP_CONTENT2 } = options;
   if (!Number.isInteger(subagents) || subagents < 1) {
     throw new Error("subagents must be a positive integer");
   }
   const targetPath = path12.resolve(targetRoot);
-  if (!dryRun) {
+  if (!dryRun2) {
     await ensureDir(targetPath);
   }
   let highestNumber = 0;
   const lockedSubagents = /* @__PURE__ */ new Set();
   const existingSubagents = [];
   if (await pathExists(targetPath)) {
-    const entries = await readDirEntries(targetPath);
-    for (const entry of entries) {
+    const entries2 = await readDirEntries(targetPath);
+    for (const entry of entries2) {
       if (!entry.isDirectory || !entry.name.startsWith("subagent-")) {
         continue;
       }
@@ -35017,7 +37576,7 @@ async function provisionSubagents(options) {
       continue;
     }
     if (isLocked && force) {
-      if (!dryRun) {
+      if (!dryRun2) {
         await removeIfExists(lockFile);
         await ensureDir(githubAgentsDir);
         await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
@@ -35029,7 +37588,7 @@ async function provisionSubagents(options) {
       continue;
     }
     if (!isLocked && force) {
-      if (!dryRun) {
+      if (!dryRun2) {
         await ensureDir(githubAgentsDir);
         await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
         await writeFile4(wakeupDst, wakeupContent, "utf8");
@@ -35038,7 +37597,7 @@ async function provisionSubagents(options) {
       subagentsProvisioned += 1;
       continue;
     }
-    if (!dryRun && !await pathExists(workspaceDst)) {
+    if (!dryRun2 && !await pathExists(workspaceDst)) {
       await ensureDir(githubAgentsDir);
       await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
       await writeFile4(wakeupDst, wakeupContent, "utf8");
@@ -35054,7 +37613,7 @@ async function provisionSubagents(options) {
     const workspaceDst = path12.join(subagentDir, `${path12.basename(subagentDir)}.code-workspace`);
     const wakeupDst = path12.join(githubAgentsDir, "wakeup.md");
     const subagentDst = path12.join(githubAgentsDir, "subagent.md");
-    if (!dryRun) {
+    if (!dryRun2) {
       await ensureDir(subagentDir);
       await ensureDir(githubAgentsDir);
       await writeFile4(workspaceDst, JSON.stringify(workspaceTemplate, null, 2), "utf8");
@@ -35273,7 +37832,7 @@ async function loadConfig(evalFilePath, repoRoot) {
     }
     try {
       const rawConfig = await readFile4(configPath, "utf8");
-      const parsed = parse5(rawConfig);
+      const parsed = parse7(rawConfig);
       if (!isJsonObject(parsed)) {
         logWarning(`Invalid .agentv/config.yaml format at ${configPath}`);
         continue;
@@ -35903,11 +38462,11 @@ function asStringArray(value, description) {
   }
   return result;
 }
-function parseCommandToArgv(command7) {
+function parseCommandToArgv(command2) {
   if (process.platform === "win32") {
-    return ["cmd.exe", "/c", command7];
+    return ["cmd.exe", "/c", command2];
   }
-  return ["sh", "-lc", command7];
+  return ["sh", "-lc", command2];
 }
 function isJsonObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -36285,8 +38844,8 @@ function asString3(value) {
   return typeof value === "string" ? value : void 0;
 }
 function cloneJsonObject(source2) {
-  const entries = Object.entries(source2).map(([key2, value]) => [key2, cloneJsonValue(value)]);
-  return Object.fromEntries(entries);
+  const entries2 = Object.entries(source2).map(([key2, value]) => [key2, cloneJsonValue(value)]);
+  return Object.fromEntries(entries2);
 }
 function cloneJsonValue(value) {
   if (value === null) {
@@ -37608,10 +40167,10 @@ ${filesContext}`;
     return args;
   }
   buildEnv() {
-    const env = { ...process.env };
-    env.CLAUDECODE = void 0;
-    env.CLAUDE_CODE_ENTRYPOINT = void 0;
-    return env;
+    const env2 = { ...process.env };
+    env2.CLAUDECODE = void 0;
+    env2.CLAUDE_CODE_ENTRYPOINT = void 0;
+    return env2;
   }
   async executeClaudeCode(args, cwd, signal, logger) {
     try {
@@ -37626,8 +40185,8 @@ ${filesContext}`;
         onStderrChunk: logger ? (chunk) => logger.handleStderrChunk(chunk) : void 0
       });
     } catch (error40) {
-      const err = error40;
-      if (err.code === "ENOENT") {
+      const err2 = error40;
+      if (err2.code === "ENOENT") {
         throw new Error(
           `Claude Code executable '${this.config.executable}' was not found. Update the target settings.executable or add it to PATH.`
         );
@@ -38253,7 +40812,7 @@ function convertOutputMessages(messages) {
 }
 var execAsync2 = promisify2(execWithCallback);
 var DEFAULT_MAX_BUFFER = 10 * 1024 * 1024;
-async function defaultCommandRunner(command7, options) {
+async function defaultCommandRunner(command2, options) {
   const execOptions = {
     cwd: options.cwd,
     env: options.env,
@@ -38263,7 +40822,7 @@ async function defaultCommandRunner(command7, options) {
     shell: process.platform === "win32" ? "powershell.exe" : void 0
   };
   try {
-    const { stdout, stderr } = await execAsync2(command7, execOptions);
+    const { stdout, stderr } = await execAsync2(command2, execOptions);
     return {
       stdout,
       stderr,
@@ -38687,7 +41246,7 @@ function generateOutputFilePath(evalCaseId, extension = ".json") {
   const safeEvalId = evalCaseId || "unknown";
   const timestamp = Date.now();
   const random = Math.random().toString(36).substring(2, 9);
-  return path102.join(os2.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
+  return path102.join(os3.tmpdir(), `agentv-${safeEvalId}-${timestamp}-${random}${extension}`);
 }
 function formatTimeoutSuffix2(timeoutMs) {
   if (!timeoutMs || timeoutMs <= 0) {
@@ -38860,8 +41419,8 @@ ${basePrompt}`;
         onStderrChunk: logger ? (chunk) => logger.handleStderrChunk(chunk) : void 0
       });
     } catch (error40) {
-      const err = error40;
-      if (err.code === "ENOENT") {
+      const err2 = error40;
+      if (err2.code === "ENOENT") {
         throw new Error(
           `Codex executable '${this.config.executable}' was not found. Update the target settings.executable or add it to PATH.`
         );
@@ -39782,8 +42341,8 @@ ${prompt}`;
         onStderrChunk: logger ? (chunk) => logger.handleStderrChunk(chunk) : void 0
       });
     } catch (error40) {
-      const err = error40;
-      if (err.code === "ENOENT") {
+      const err2 = error40;
+      if (err2.code === "ENOENT") {
         throw new Error(
           `Pi coding agent executable '${this.config.executable}' was not found. Update the target settings.executable or add it to PATH.`
         );
@@ -39792,32 +42351,32 @@ ${prompt}`;
     }
   }
   buildEnv() {
-    const env = { ...process.env };
+    const env2 = { ...process.env };
     if (this.config.apiKey) {
       const provider = this.config.provider?.toLowerCase() ?? "google";
       switch (provider) {
         case "google":
         case "gemini":
-          env.GEMINI_API_KEY = this.config.apiKey;
+          env2.GEMINI_API_KEY = this.config.apiKey;
           break;
         case "anthropic":
-          env.ANTHROPIC_API_KEY = this.config.apiKey;
+          env2.ANTHROPIC_API_KEY = this.config.apiKey;
           break;
         case "openai":
-          env.OPENAI_API_KEY = this.config.apiKey;
+          env2.OPENAI_API_KEY = this.config.apiKey;
           break;
         case "groq":
-          env.GROQ_API_KEY = this.config.apiKey;
+          env2.GROQ_API_KEY = this.config.apiKey;
           break;
         case "xai":
-          env.XAI_API_KEY = this.config.apiKey;
+          env2.XAI_API_KEY = this.config.apiKey;
           break;
         case "openrouter":
-          env.OPENROUTER_API_KEY = this.config.apiKey;
+          env2.OPENROUTER_API_KEY = this.config.apiKey;
           break;
       }
     }
-    return env;
+    return env2;
   }
   async createWorkspace() {
     return await mkdtemp3(path122.join(tmpdir3(), WORKSPACE_PREFIX3));
@@ -40712,9 +43271,9 @@ async function execFileWithStdin(argv, stdinPayload, options = {}) {
   return execFileWithStdinNode(argv, stdinPayload, options);
 }
 async function execFileWithStdinBun(argv, stdinPayload, options) {
-  const command7 = [...argv];
+  const command2 = [...argv];
   const encoder = new TextEncoder();
-  const proc = Bun.spawn(command7, {
+  const proc = Bun.spawn(command2, {
     cwd: options.cwd,
     stdin: encoder.encode(stdinPayload),
     stdout: "pipe",
@@ -40792,7 +43351,7 @@ async function execFileWithStdinNode(argv, stdinPayload, options) {
     }
   });
 }
-async function execShellWithStdin(command7, stdinPayload, options = {}) {
+async function execShellWithStdin(command2, stdinPayload, options = {}) {
   const { mkdir: mkdir42, readFile: readFile82, rm: rm4, writeFile: writeFile42 } = await import("node:fs/promises");
   const { tmpdir: tmpdir4 } = await import("node:os");
   const path162 = await import("node:path");
@@ -40803,7 +43362,7 @@ async function execShellWithStdin(command7, stdinPayload, options = {}) {
   const stdoutPath = path162.join(dir, "stdout.txt");
   const stderrPath = path162.join(dir, "stderr.txt");
   await writeFile42(stdinPath, stdinPayload, "utf8");
-  const wrappedCommand = process.platform === "win32" ? `(${command7}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command7}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
+  const wrappedCommand = process.platform === "win32" ? `(${command2}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}` : `(${command2}) < ${shellEscapePath(stdinPath)} > ${shellEscapePath(stdoutPath)} 2> ${shellEscapePath(stderrPath)}`;
   const { spawn: spawn4 } = await import("node:child_process");
   try {
     const exitCode = await new Promise((resolve2, reject) => {
@@ -41007,8 +43566,8 @@ async function createTargetProxy(options) {
     shutdown: async () => {
       isShutdown = true;
       return new Promise((resolve2, reject) => {
-        server.close((err) => {
-          if (err) reject(err);
+        server.close((err2) => {
+          if (err2) reject(err2);
           else resolve2();
         });
       });
@@ -41185,8 +43744,8 @@ var CodeEvaluator = class {
     }
   }
 };
-async function executeScript(scriptPath, input, agentTimeoutMs, cwd, env) {
-  const { stdout, stderr, exitCode } = typeof scriptPath === "string" ? await execShellWithStdin(scriptPath, input, { cwd, timeoutMs: agentTimeoutMs, env }) : await execFileWithStdin(scriptPath, input, { cwd, timeoutMs: agentTimeoutMs, env });
+async function executeScript(scriptPath, input, agentTimeoutMs, cwd, env2) {
+  const { stdout, stderr, exitCode } = typeof scriptPath === "string" ? await execShellWithStdin(scriptPath, input, { cwd, timeoutMs: agentTimeoutMs, env: env2 }) : await execFileWithStdin(scriptPath, input, { cwd, timeoutMs: agentTimeoutMs, env: env2 });
   if (exitCode !== 0) {
     const trimmedErr = formatStderr(stderr);
     throw new Error(
@@ -42877,7 +45436,7 @@ async function runEvaluation(options) {
     repoRoot,
     target,
     targets,
-    env,
+    env: env2,
     providerFactory,
     evaluators,
     maxRetries,
@@ -42905,7 +45464,7 @@ async function runEvaluation(options) {
   for (const definition of targets ?? []) {
     targetDefinitions.set(definition.name, definition);
   }
-  const envLookup = env ?? process.env;
+  const envLookup = env2 ?? process.env;
   const providerCache = /* @__PURE__ */ new Map();
   const getOrCreateProvider = (resolved) => {
     const existing = providerCache.get(resolved.name);
@@ -44043,10 +46602,10 @@ function mapChildResults(children) {
     details: child.details
   }));
 }
-function computeWeightedMean(entries) {
+function computeWeightedMean(entries2) {
   let totalWeight = 0;
   let weightedSum = 0;
-  for (const entry of entries) {
+  for (const entry of entries2) {
     const weight = entry.weight ?? 1;
     totalWeight += weight;
     weightedSum += entry.score * weight;
@@ -44131,7 +46690,6 @@ function buildPrompt(expectedOutcome, question, referenceAnswer) {
 }
 
 // src/commands/convert/index.ts
-import { command as command2, option as option2, optional as optional3, positional as positional2, string as string5 } from "cmd-ts";
 import { stringify as stringifyYaml } from "yaml";
 function convertJsonlToYaml(inputPath, outputPath) {
   const content = readFileSync2(inputPath, "utf8");
@@ -44152,17 +46710,17 @@ function convertJsonlToYaml(inputPath, outputPath) {
   writeFileSync(outputPath, yamlOutput);
   return lines.length;
 }
-var convertCommand = command2({
+var convertCommand = command({
   name: "convert",
   description: "Convert evaluation results from JSONL to YAML format",
   args: {
-    input: positional2({
-      type: string5,
+    input: positional({
+      type: string,
       displayName: "input",
       description: "Path to input JSONL file"
     }),
-    out: option2({
-      type: optional3(string5),
+    out: option({
+      type: optional(string),
       long: "out",
       short: "o",
       description: "Output file path (defaults to input path with .yaml extension)"
@@ -44187,15 +46745,6 @@ var convertCommand = command2({
 // src/commands/eval/index.ts
 import { stat as stat4 } from "node:fs/promises";
 import path25 from "node:path";
-import {
-  command as command3,
-  flag as flag2,
-  number as number5,
-  option as option3,
-  optional as optional4,
-  restPositionals,
-  string as string6
-} from "cmd-ts";
 import fg from "fast-glob";
 
 // src/commands/eval/run-eval.ts
@@ -44836,7 +47385,7 @@ function formatEvaluationSummary(summary) {
 // ../../packages/core/dist/evaluation/validation/index.js
 import { readFile as readFile8 } from "node:fs/promises";
 import path20 from "node:path";
-import { parse as parse6 } from "yaml";
+import { parse as parse8 } from "yaml";
 import { readFile as readFile23 } from "node:fs/promises";
 import path23 from "node:path";
 import { parse as parse23 } from "yaml";
@@ -44854,7 +47403,7 @@ var SCHEMA_CONFIG_V2 = "agentv-config-v2";
 async function detectFileType(filePath) {
   try {
     const content = await readFile8(filePath, "utf8");
-    const parsed = parse6(content);
+    const parsed = parse8(content);
     if (typeof parsed !== "object" || parsed === null) {
       return inferFileTypeFromPath(filePath);
     }
@@ -45753,11 +48302,11 @@ async function selectTarget(options) {
     cwd,
     explicitTargetsPath,
     cliTargetName,
-    dryRun,
+    dryRun: dryRun2,
     dryRunDelay,
     dryRunDelayMin,
     dryRunDelayMax,
-    env
+    env: env2
   } = options;
   const targetsFilePath = await discoverTargetsFile({
     explicitPath: explicitTargetsPath,
@@ -45803,7 +48352,7 @@ Errors in ${targetsFilePath}:`);
       `Target '${targetChoice.name}' not found in ${targetsFilePath}. Available targets: ${available}`
     );
   }
-  if (dryRun) {
+  if (dryRun2) {
     const mockTarget = {
       kind: "mock",
       name: `${targetDefinition.name}-dry-run`,
@@ -45824,7 +48373,7 @@ Errors in ${targetsFilePath}:`);
     };
   }
   try {
-    const resolvedTarget = resolveTargetDefinition(targetDefinition, env, testFilePath);
+    const resolvedTarget = resolveTargetDefinition(targetDefinition, env2, testFilePath);
     return {
       definitions,
       resolvedTarget,
@@ -46219,87 +48768,87 @@ async function resolveEvaluationRunner() {
 }
 
 // src/commands/eval/index.ts
-var evalCommand = command3({
+var evalCommand = command({
   name: "eval",
   description: "Run eval suites and report results",
   args: {
     evalPaths: restPositionals({
-      type: string6,
+      type: string,
       displayName: "eval-paths",
       description: "Path(s) or glob(s) to evaluation .yaml file(s)"
     }),
-    target: option3({
-      type: string6,
+    target: option({
+      type: string,
       long: "target",
       description: "Override target name from targets.yaml",
       defaultValue: () => "default"
     }),
-    targets: option3({
-      type: optional4(string6),
+    targets: option({
+      type: optional(string),
       long: "targets",
       description: "Path to targets.yaml (overrides discovery)"
     }),
-    evalId: option3({
-      type: optional4(string6),
+    evalId: option({
+      type: optional(string),
       long: "eval-id",
       description: 'Filter eval cases by ID pattern (glob supported, e.g., "summary-*")'
     }),
-    workers: option3({
-      type: number5,
+    workers: option({
+      type: number,
       long: "workers",
       description: "Number of parallel workers (default: 3, max: 50). Can also be set per-target in targets.yaml",
       defaultValue: () => 3
     }),
-    out: option3({
-      type: optional4(string6),
+    out: option({
+      type: optional(string),
       long: "out",
       description: "Write results to the specified path"
     }),
-    outputFormat: option3({
-      type: string6,
+    outputFormat: option({
+      type: string,
       long: "output-format",
       description: "Output format: 'jsonl' or 'yaml' (default: jsonl)",
       defaultValue: () => "jsonl"
     }),
-    dryRun: flag2({
+    dryRun: flag({
       long: "dry-run",
       description: "Use mock provider responses instead of real LLM calls"
     }),
-    dryRunDelay: option3({
-      type: number5,
+    dryRunDelay: option({
+      type: number,
       long: "dry-run-delay",
       description: "Fixed delay in milliseconds for dry-run mode (overridden by delay range if specified)",
       defaultValue: () => 0
     }),
-    dryRunDelayMin: option3({
-      type: number5,
+    dryRunDelayMin: option({
+      type: number,
       long: "dry-run-delay-min",
       description: "Minimum delay in milliseconds for dry-run mode (requires --dry-run-delay-max)",
       defaultValue: () => 0
     }),
-    dryRunDelayMax: option3({
-      type: number5,
+    dryRunDelayMax: option({
+      type: number,
       long: "dry-run-delay-max",
       description: "Maximum delay in milliseconds for dry-run mode (requires --dry-run-delay-min)",
       defaultValue: () => 0
     }),
-    agentTimeout: option3({
-      type: number5,
+    agentTimeout: option({
+      type: number,
       long: "agent-timeout",
       description: "Timeout in seconds for provider responses (default: 120)",
       defaultValue: () => 120
     }),
-    maxRetries: option3({
-      type: number5,
+    maxRetries: option({
+      type: number,
       long: "max-retries",
       description: "Retry count for timeout recoveries (default: 2)",
       defaultValue: () => 2
     }),
-    cache: flag2({
+    cache: flag({
       long: "cache",
       description: "Enable in-memory provider response cache"
     }),
-    verbose: flag2({
+    verbose: flag({
       long: "verbose",
       description: "Enable verbose logging"
     })
@@ -46372,9 +48921,6 @@ async function resolveEvalPaths(evalPaths, cwd) {
   return sorted;
 }
 
-// src/commands/generate/index.ts
-import { command as command4, flag as flag3, option as option4, optional as optional5, positional as positional4, string as string7, subcommands } from "cmd-ts";
-
 // src/commands/generate/rubrics.ts
 import { readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
 import path26 from "node:path";
@@ -46514,22 +49060,22 @@ function extractQuestion(evalCase) {
 }
 
 // src/commands/generate/index.ts
-var rubricsCommand = command4({
+var rubricsCommand = command({
   name: "rubrics",
   description: "Generate rubrics from expected_outcome in YAML eval file",
   args: {
-    file: positional4({
-      type: string7,
+    file: positional({
+      type: string,
       displayName: "file",
       description: "Path to YAML eval file"
     }),
-    target: option4({
-      type: optional5(string7),
+    target: option({
+      type: optional(string),
       long: "target",
       short: "t",
       description: "Override target for rubric generation (default: file target or openai:gpt-4o)"
     }),
-    verbose: flag3({
+    verbose: flag({
       long: "verbose",
       short: "v",
       description: "Show detailed progress"
@@ -46560,7 +49106,6 @@ var generateCommand = subcommands({
 import { existsSync, mkdirSync, writeFileSync as writeFileSync2 } from "node:fs";
 import path28 from "node:path";
 import * as readline from "node:readline/promises";
-import { command as command5, option as option5, optional as optional6, string as string8 } from "cmd-ts";
 
 // src/templates/index.ts
 import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
@@ -46616,8 +49161,8 @@ function getRepoRootFromDev() {
 }
 function readTemplatesRecursively(dir, relativePath) {
   const templates = [];
-  const entries = readdirSync(dir);
-  for (const entry of entries) {
+  const entries2 = readdirSync(dir);
+  for (const entry of entries2) {
     const fullPath = path27.join(dir, entry);
     const stat6 = statSync(fullPath);
     const entryRelativePath = relativePath ? path27.join(relativePath, entry) : entry;
@@ -46768,12 +49313,12 @@ Files installed to ${path28.relative(targetPath, claudeDir)}:`);
   console.log("  2. Configure targets in .agentv/targets.yaml");
   console.log("  3. Create eval files using the schema and prompt templates");
 }
-var initCmdTsCommand = command5({
+var initCmdTsCommand = command({
   name: "init",
   description: "Initialize AgentV in your project (installs prompt templates and schema to .github)",
   args: {
-    path: option5({
-      type: optional6(string8),
+    path: option({
+      type: optional(string),
       long: "path",
       description: "Target directory for initialization (default: current directory)"
     })
@@ -46788,9 +49333,6 @@ var initCmdTsCommand = command5({
   }
 });
 
-// src/commands/validate/index.ts
-import { command as command6, restPositionals as restPositionals2, string as string9 } from "cmd-ts";
-
 // src/commands/validate/format-output.ts
 var ANSI_RED4 = "\x1B[31m";
 var ANSI_YELLOW9 = "\x1B[33m";
@@ -46939,8 +49481,8 @@ async function expandPaths(paths) {
 async function findYamlFiles(dirPath) {
   const results = [];
   try {
-    const entries = await readdir3(dirPath, { withFileTypes: true });
-    for (const entry of entries) {
+    const entries2 = await readdir3(dirPath, { withFileTypes: true });
+    for (const entry of entries2) {
       const fullPath = path29.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name.startsWith(".")) {
@@ -46975,12 +49517,12 @@ async function runValidateCommand(paths) {
     process.exit(1);
   }
 }
-var validateCommand = command6({
+var validateCommand = command({
   name: "validate",
   description: "Validate AgentV eval and targets YAML files",
   args: {
-    paths: restPositionals2({
-      type: string9,
+    paths: restPositionals({
+      type: string,
       displayName: "paths",
       description: "Files or directories to validate"
     })
@@ -46997,7 +49539,7 @@ var validateCommand = command6({
 
 // src/index.ts
 var packageJson = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8"));
-var app = subcommands2({
+var app = subcommands({
   name: "agentv",
   description: "AgentV CLI",
   version: packageJson.version,
@@ -47018,4 +49560,4 @@ export {
   app,
   runCli
 };
-//# sourceMappingURL=chunk-XREH4WAJ.js.map
+//# sourceMappingURL=chunk-PQSPRPW4.js.map