agent-relay 6.0.19 → 6.0.21

package/dist/index.cjs

@@ -32456,6 +32456,456 @@ var require_src = __commonJS({
   }
 });
 
+// node_modules/axios/node_modules/agent-base/dist/src/promisify.js
+var require_promisify = __commonJS({
+  "node_modules/axios/node_modules/agent-base/dist/src/promisify.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    function promisify4(fn2) {
+      return function(req, opts) {
+        return new Promise((resolve4, reject) => {
+          fn2.call(this, req, opts, (err, rtn) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve4(rtn);
+            }
+          });
+        });
+      };
+    }
+    exports2.default = promisify4;
+  }
+});
+
+// node_modules/axios/node_modules/agent-base/dist/src/index.js
+var require_src2 = __commonJS({
+  "node_modules/axios/node_modules/agent-base/dist/src/index.js"(exports2, module2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    var events_1 = require("events");
+    var debug_1 = __importDefault(require_src());
+    var promisify_1 = __importDefault(require_promisify());
+    var debug = debug_1.default("agent-base");
+    function isAgent(v2) {
+      return Boolean(v2) && typeof v2.addRequest === "function";
+    }
+    function isSecureEndpoint() {
+      const { stack } = new Error();
+      if (typeof stack !== "string")
+        return false;
+      return stack.split("\n").some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+    }
+    function createAgent(callback, opts) {
+      return new createAgent.Agent(callback, opts);
+    }
+    (function(createAgent2) {
+      class Agent extends events_1.EventEmitter {
+        constructor(callback, _opts) {
+          super();
+          let opts = _opts;
+          if (typeof callback === "function") {
+            this.callback = callback;
+          } else if (callback) {
+            opts = callback;
+          }
+          this.timeout = null;
+          if (opts && typeof opts.timeout === "number") {
+            this.timeout = opts.timeout;
+          }
+          this.maxFreeSockets = 1;
+          this.maxSockets = 1;
+          this.maxTotalSockets = Infinity;
+          this.sockets = {};
+          this.freeSockets = {};
+          this.requests = {};
+          this.options = {};
+        }
+        get defaultPort() {
+          if (typeof this.explicitDefaultPort === "number") {
+            return this.explicitDefaultPort;
+          }
+          return isSecureEndpoint() ? 443 : 80;
+        }
+        set defaultPort(v2) {
+          this.explicitDefaultPort = v2;
+        }
+        get protocol() {
+          if (typeof this.explicitProtocol === "string") {
+            return this.explicitProtocol;
+          }
+          return isSecureEndpoint() ? "https:" : "http:";
+        }
+        set protocol(v2) {
+          this.explicitProtocol = v2;
+        }
+        callback(req, opts, fn2) {
+          throw new Error('"agent-base" has no default implementation, you must subclass and override `callback()`');
+        }
+        /**
+         * Called by node-core's "_http_client.js" module when creating
+         * a new HTTP request with this Agent instance.
+         *
+         * @api public
+         */
+        addRequest(req, _opts) {
+          const opts = Object.assign({}, _opts);
+          if (typeof opts.secureEndpoint !== "boolean") {
+            opts.secureEndpoint = isSecureEndpoint();
+          }
+          if (opts.host == null) {
+            opts.host = "localhost";
+          }
+          if (opts.port == null) {
+            opts.port = opts.secureEndpoint ? 443 : 80;
+          }
+          if (opts.protocol == null) {
+            opts.protocol = opts.secureEndpoint ? "https:" : "http:";
+          }
+          if (opts.host && opts.path) {
+            delete opts.path;
+          }
+          delete opts.agent;
+          delete opts.hostname;
+          delete opts._defaultAgent;
+          delete opts.defaultPort;
+          delete opts.createConnection;
+          req._last = true;
+          req.shouldKeepAlive = false;
+          let timedOut = false;
+          let timeoutId = null;
+          const timeoutMs = opts.timeout || this.timeout;
+          const onerror = (err) => {
+            if (req._hadError)
+              return;
+            req.emit("error", err);
+            req._hadError = true;
+          };
+          const ontimeout = () => {
+            timeoutId = null;
+            timedOut = true;
+            const err = new Error(`A "socket" was not created for HTTP request before ${timeoutMs}ms`);
+            err.code = "ETIMEOUT";
+            onerror(err);
+          };
+          const callbackError = (err) => {
+            if (timedOut)
+              return;
+            if (timeoutId !== null) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+            onerror(err);
+          };
+          const onsocket = (socket) => {
+            if (timedOut)
+              return;
+            if (timeoutId != null) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+            if (isAgent(socket)) {
+              debug("Callback returned another Agent instance %o", socket.constructor.name);
+              socket.addRequest(req, opts);
+              return;
+            }
+            if (socket) {
+              socket.once("free", () => {
+                this.freeSocket(socket, opts);
+              });
+              req.onSocket(socket);
+              return;
+            }
+            const err = new Error(`no Duplex stream was returned to agent-base for \`${req.method} ${req.path}\``);
+            onerror(err);
+          };
+          if (typeof this.callback !== "function") {
+            onerror(new Error("`callback` is not defined"));
+            return;
+          }
+          if (!this.promisifiedCallback) {
+            if (this.callback.length >= 3) {
+              debug("Converting legacy callback function to promise");
+              this.promisifiedCallback = promisify_1.default(this.callback);
+            } else {
+              this.promisifiedCallback = this.callback;
+            }
+          }
+          if (typeof timeoutMs === "number" && timeoutMs > 0) {
+            timeoutId = setTimeout(ontimeout, timeoutMs);
+          }
+          if ("port" in opts && typeof opts.port !== "number") {
+            opts.port = Number(opts.port);
+          }
+          try {
+            debug("Resolving socket for %o request: %o", opts.protocol, `${req.method} ${req.path}`);
+            Promise.resolve(this.promisifiedCallback(req, opts)).then(onsocket, callbackError);
+          } catch (err) {
+            Promise.reject(err).catch(callbackError);
+          }
+        }
+        freeSocket(socket, opts) {
+          debug("Freeing socket %o %o", socket.constructor.name, opts);
+          socket.destroy();
+        }
+        destroy() {
+          debug("Destroying agent %o", this.constructor.name);
+        }
+      }
+      createAgent2.Agent = Agent;
+      createAgent2.prototype = createAgent2.Agent.prototype;
+    })(createAgent || (createAgent = {}));
+    module2.exports = createAgent;
+  }
+});
+
+// node_modules/axios/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS({
+  "node_modules/axios/node_modules/https-proxy-agent/dist/parse-proxy-response.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var debug_1 = __importDefault(require_src());
+    var debug = debug_1.default("https-proxy-agent:parse-proxy-response");
+    function parseProxyResponse(socket) {
+      return new Promise((resolve4, reject) => {
+        let buffersLength = 0;
+        const buffers = [];
+        function read() {
+          const b2 = socket.read();
+          if (b2)
+            ondata(b2);
+          else
+            socket.once("readable", read);
+        }
+        function cleanup() {
+          socket.removeListener("end", onend);
+          socket.removeListener("error", onerror);
+          socket.removeListener("close", onclose);
+          socket.removeListener("readable", read);
+        }
+        function onclose(err) {
+          debug("onclose had error %o", err);
+        }
+        function onend() {
+          debug("onend");
+        }
+        function onerror(err) {
+          cleanup();
+          debug("onerror %o", err);
+          reject(err);
+        }
+        function ondata(b2) {
+          buffers.push(b2);
+          buffersLength += b2.length;
+          const buffered = Buffer.concat(buffers, buffersLength);
+          const endOfHeaders = buffered.indexOf("\r\n\r\n");
+          if (endOfHeaders === -1) {
+            debug("have not received end of HTTP headers yet...");
+            read();
+            return;
+          }
+          const firstLine = buffered.toString("ascii", 0, buffered.indexOf("\r\n"));
+          const statusCode = +firstLine.split(" ")[1];
+          debug("got proxy server response: %o", firstLine);
+          resolve4({
+            statusCode,
+            buffered
+          });
+        }
+        socket.on("error", onerror);
+        socket.on("close", onclose);
+        socket.on("end", onend);
+        read();
+      });
+    }
+    exports2.default = parseProxyResponse;
+  }
+});
+
+// node_modules/axios/node_modules/https-proxy-agent/dist/agent.js
+var require_agent = __commonJS({
+  "node_modules/axios/node_modules/https-proxy-agent/dist/agent.js"(exports2) {
+    "use strict";
+    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P2, generator) {
+      function adopt(value) {
+        return value instanceof P2 ? value : new P2(function(resolve4) {
+          resolve4(value);
+        });
+      }
+      return new (P2 || (P2 = Promise))(function(resolve4, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve4(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    var net_1 = __importDefault(require("net"));
+    var tls_1 = __importDefault(require("tls"));
+    var url_1 = __importDefault(require("url"));
+    var assert_1 = __importDefault(require("assert"));
+    var debug_1 = __importDefault(require_src());
+    var agent_base_1 = require_src2();
+    var parse_proxy_response_1 = __importDefault(require_parse_proxy_response());
+    var debug = debug_1.default("https-proxy-agent:agent");
+    var HttpsProxyAgent = class extends agent_base_1.Agent {
+      constructor(_opts) {
+        let opts;
+        if (typeof _opts === "string") {
+          opts = url_1.default.parse(_opts);
+        } else {
+          opts = _opts;
+        }
+        if (!opts) {
+          throw new Error("an HTTP(S) proxy server `host` and `port` must be specified!");
+        }
+        debug("creating new HttpsProxyAgent instance: %o", opts);
+        super(opts);
+        const proxy = Object.assign({}, opts);
+        this.secureProxy = opts.secureProxy || isHTTPS(proxy.protocol);
+        proxy.host = proxy.hostname || proxy.host;
+        if (typeof proxy.port === "string") {
+          proxy.port = parseInt(proxy.port, 10);
+        }
+        if (!proxy.port && proxy.host) {
+          proxy.port = this.secureProxy ? 443 : 80;
+        }
+        if (this.secureProxy && !("ALPNProtocols" in proxy)) {
+          proxy.ALPNProtocols = ["http 1.1"];
+        }
+        if (proxy.host && proxy.path) {
+          delete proxy.path;
+          delete proxy.pathname;
+        }
+        this.proxy = proxy;
+      }
+      /**
+       * Called when the node-core HTTP client library is creating a
+       * new HTTP request.
+       *
+       * @api protected
+       */
+      callback(req, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+          const { proxy, secureProxy } = this;
+          let socket;
+          if (secureProxy) {
+            debug("Creating `tls.Socket`: %o", proxy);
+            socket = tls_1.default.connect(proxy);
+          } else {
+            debug("Creating `net.Socket`: %o", proxy);
+            socket = net_1.default.connect(proxy);
+          }
+          const headers = Object.assign({}, proxy.headers);
+          const hostname3 = `${opts.host}:${opts.port}`;
+          let payload = `CONNECT ${hostname3} HTTP/1.1\r
+`;
+          if (proxy.auth) {
+            headers["Proxy-Authorization"] = `Basic ${Buffer.from(proxy.auth).toString("base64")}`;
+          }
+          let { host, port, secureEndpoint } = opts;
+          if (!isDefaultPort(port, secureEndpoint)) {
+            host += `:${port}`;
+          }
+          headers.Host = host;
+          headers.Connection = "close";
+          for (const name of Object.keys(headers)) {
+            payload += `${name}: ${headers[name]}\r
+`;
+          }
+          const proxyResponsePromise = parse_proxy_response_1.default(socket);
+          socket.write(`${payload}\r
+`);
+          const { statusCode, buffered } = yield proxyResponsePromise;
+          if (statusCode === 200) {
+            req.once("socket", resume);
+            if (opts.secureEndpoint) {
+              debug("Upgrading socket connection to TLS");
+              const servername = opts.servername || opts.host;
+              return tls_1.default.connect(Object.assign(Object.assign({}, omit2(opts, "host", "hostname", "path", "port")), {
+                socket,
+                servername
+              }));
+            }
+            return socket;
+          }
+          socket.destroy();
+          const fakeSocket = new net_1.default.Socket({ writable: false });
+          fakeSocket.readable = true;
+          req.once("socket", (s3) => {
+            debug("replaying proxy buffer for failed request");
+            assert_1.default(s3.listenerCount("data") > 0);
+            s3.push(buffered);
+            s3.push(null);
+          });
+          return fakeSocket;
+        });
+      }
+    };
+    exports2.default = HttpsProxyAgent;
+    function resume(socket) {
+      socket.resume();
+    }
+    function isDefaultPort(port, secure) {
+      return Boolean(!secure && port === 80 || secure && port === 443);
+    }
+    function isHTTPS(protocol) {
+      return typeof protocol === "string" ? /^https:?$/i.test(protocol) : false;
+    }
+    function omit2(obj, ...keys) {
+      const ret = {};
+      let key;
+      for (key in obj) {
+        if (!keys.includes(key)) {
+          ret[key] = obj[key];
+        }
+      }
+      return ret;
+    }
+  }
+});
+
+// node_modules/axios/node_modules/https-proxy-agent/dist/index.js
+var require_dist3 = __commonJS({
+  "node_modules/axios/node_modules/https-proxy-agent/dist/index.js"(exports2, module2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    var agent_1 = __importDefault(require_agent());
+    function createHttpsProxyAgent(opts) {
+      return new agent_1.default(opts);
+    }
+    (function(createHttpsProxyAgent2) {
+      createHttpsProxyAgent2.HttpsProxyAgent = agent_1.default;
+      createHttpsProxyAgent2.prototype = agent_1.default.prototype;
+    })(createHttpsProxyAgent || (createHttpsProxyAgent = {}));
+    module2.exports = createHttpsProxyAgent;
+  }
+});
+
 // node_modules/follow-redirects/debug.js
 var require_debug = __commonJS({
   "node_modules/follow-redirects/debug.js"(exports2, module2) {
@@ -32994,6 +33444,7 @@ var require_axios = __commonJS({
     var FormData$1 = require_form_data();
     var crypto3 = require("crypto");
     var url2 = require("url");
+    var HttpsProxyAgent = require_dist3();
     var http2 = require("http");
     var https3 = require("https");
     var http22 = require("http2");
@@ -33346,29 +33797,29 @@ var require_axios = __commonJS({
       return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
     }
     var toJSONObject = (obj) => {
-      const stack = new Array(10);
-      const visit = (source, i) => {
+      const visited = /* @__PURE__ */ new WeakSet();
+      const visit = (source) => {
         if (isObject3(source)) {
-          if (stack.indexOf(source) >= 0) {
+          if (visited.has(source)) {
             return;
           }
           if (isBuffer(source)) {
             return source;
           }
           if (!("toJSON" in source)) {
-            stack[i] = source;
+            visited.add(source);
             const target = isArray(source) ? [] : {};
             forEach(source, (value, key) => {
-              const reducedValue = visit(value, i + 1);
+              const reducedValue = visit(value);
               !isUndefined(reducedValue) && (target[key] = reducedValue);
             });
-            stack[i] = void 0;
+            visited.delete(source);
             return target;
           }
         }
         return source;
       };
-      return visit(obj, 0);
+      return visit(obj);
     };
     var isAsyncFn = kindOfTest("AsyncFunction");
     var isThenable = (thing) => thing && (isObject3(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
@@ -33480,8 +33931,6 @@ var require_axios = __commonJS({
       });
       return parsed;
     };
-    var $internals = /* @__PURE__ */ Symbol("internals");
-    var INVALID_HEADER_VALUE_CHARS_RE = /[^\x09\x20-\x7E\x80-\xFF]/g;
     function trimSPorHTAB(str) {
       let start = 0;
       let end = str.length;
@@ -33501,12 +33950,27 @@ var require_axios = __commonJS({
       }
       return start === 0 && end === str.length ? str : str.slice(start, end);
     }
+    var INVALID_UNICODE_HEADER_VALUE_CHARS = new RegExp("[\\u0000-\\u0008\\u000a-\\u001f\\u007f]+", "g");
+    var INVALID_BYTE_STRING_HEADER_VALUE_CHARS = new RegExp("[^\\u0009\\u0020-\\u007e\\u0080-\\u00ff]+", "g");
+    function sanitizeValue(value, invalidChars) {
+      if (utils$1.isArray(value)) {
+        return value.map((item) => sanitizeValue(item, invalidChars));
+      }
+      return trimSPorHTAB(String(value).replace(invalidChars, ""));
+    }
+    var sanitizeHeaderValue = (value) => sanitizeValue(value, INVALID_UNICODE_HEADER_VALUE_CHARS);
+    var sanitizeByteStringHeaderValue = (value) => sanitizeValue(value, INVALID_BYTE_STRING_HEADER_VALUE_CHARS);
+    function toByteStringHeaderObject(headers) {
+      const byteStringHeaders = /* @__PURE__ */ Object.create(null);
+      utils$1.forEach(headers.toJSON(), (value, header) => {
+        byteStringHeaders[header] = sanitizeByteStringHeaderValue(value);
+      });
+      return byteStringHeaders;
+    }
+    var $internals = /* @__PURE__ */ Symbol("internals");
     function normalizeHeader(header) {
       return header && String(header).trim().toLowerCase();
     }
-    function sanitizeHeaderValue(str) {
-      return trimSPorHTAB(str.replace(INVALID_HEADER_VALUE_CHARS_RE, ""));
-    }
     function normalizeValue(value) {
       if (value === false || value == null) {
         return value;
@@ -34199,7 +34663,7 @@ var require_axios = __commonJS({
           }
           return !isNumericKey;
         }
-        if (!target[name] || !utils$1.isObject(target[name])) {
+        if (!utils$1.hasOwnProp(target, name) || !utils$1.isObject(target[name])) {
           target[name] = [];
         }
         const result = buildPath(path29, value, target[name], index);
@@ -34444,12 +34908,12 @@ var require_axios = __commonJS({
     function getEnv(key) {
       return process.env[key.toLowerCase()] || process.env[key.toUpperCase()] || "";
     }
-    var VERSION = "1.16.0";
+    var VERSION = "1.16.1";
     function parseProtocol(url3) {
       const match = /^([-+\w]{1,25}):(?:\/\/)?/.exec(url3);
       return match && match[1] || "";
     }
-    var DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
+    var DATA_URL_PATTERN = /^([^,;]+\/[^,;]+)?((?:;[^,;=]+=[^,;]+)*)(;base64)?,([\s\S]*)$/;
     function fromDataURI(uri, asBlob, options) {
       const _Blob = options && options.Blob || platform2.classes.Blob;
       const protocol = parseProtocol(uri);
@@ -34462,10 +34926,17 @@ var require_axios = __commonJS({
         if (!match) {
           throw new AxiosError("Invalid URL", AxiosError.ERR_INVALID_URL);
         }
-        const mime = match[1];
-        const isBase64 = match[2];
-        const body = match[3];
-        const buffer = Buffer.from(decodeURIComponent(body), isBase64 ? "base64" : "utf8");
+        const type = match[1];
+        const params = match[2];
+        const encoding = match[3] ? "base64" : "utf8";
+        const body = match[4];
+        let mime;
+        if (type) {
+          mime = params ? type + params : type;
+        } else if (params) {
+          mime = "text/plain" + params;
+        }
+        const buffer = Buffer.from(decodeURIComponent(body), encoding);
         if (asBlob) {
           if (!_Blob) {
             throw new AxiosError("Blob is not supported", AxiosError.ERR_NOT_SUPPORT);
@@ -34903,6 +35374,9 @@ var require_axios = __commonJS({
       let bytesNotified = 0;
       const _speedometer = speedometer(50, 250);
       return throttle((e) => {
+        if (!e || typeof e.loaded !== "number") {
+          return;
+        }
         const rawLoaded = e.loaded;
         const total = e.lengthComputable ? e.total : void 0;
         const loaded = total != null ? Math.min(rawLoaded, total) : rawLoaded;
@@ -35031,6 +35505,23 @@ var require_axios = __commonJS({
     }
     var kAxiosSocketListener = /* @__PURE__ */ Symbol("axios.http.socketListener");
     var kAxiosCurrentReq = /* @__PURE__ */ Symbol("axios.http.currentReq");
+    var kAxiosInstalledTunnel = /* @__PURE__ */ Symbol("axios.http.installedTunnel");
+    var tunnelingAgentCache = /* @__PURE__ */ new Map();
+    var tunnelingAgentCacheUser = /* @__PURE__ */ new WeakMap();
+    function getTunnelingAgent(agentOptions, userHttpsAgent) {
+      const key = agentOptions.protocol + "//" + agentOptions.hostname + ":" + (agentOptions.port || "") + "#" + (agentOptions.auth || "");
+      const cache = userHttpsAgent ? tunnelingAgentCacheUser.get(userHttpsAgent) || tunnelingAgentCacheUser.set(userHttpsAgent, /* @__PURE__ */ new Map()).get(userHttpsAgent) : tunnelingAgentCache;
+      let agent = cache.get(key);
+      if (agent) return agent;
+      const merged = userHttpsAgent && userHttpsAgent.options ? {
+        ...userHttpsAgent.options,
+        ...agentOptions
+      } : agentOptions;
+      agent = new HttpsProxyAgent(merged);
+      agent[kAxiosInstalledTunnel] = true;
+      cache.set(key, agent);
+      return agent;
+    }
     var supportedProtocols = platform2.protocols.map((protocol) => {
       return protocol + ":";
     });
@@ -35128,7 +35619,7 @@ var require_axios = __commonJS({
         options.beforeRedirects.config(options, responseDetails, requestDetails);
       }
     }
-    function setProxy(options, configProxy, location, isRedirect) {
+    function setProxy(options, configProxy, location, isRedirect, configHttpsAgent) {
       let proxy = configProxy;
       if (!proxy && proxy !== false) {
         const proxyUrl = getProxyForUrl(location);
@@ -35145,6 +35636,9 @@ var require_axios = __commonJS({
           }
         }
       }
+      if (isRedirect && options.agent && options.agent[kAxiosInstalledTunnel]) {
+        options.agent = void 0;
+      }
       if (proxy) {
         const isProxyURL = proxy instanceof URL;
         const readProxyField = (key) => isProxyURL || utils$1.hasOwnProp(proxy, key) ? proxy[key] : void 0;
@@ -35166,31 +35660,59 @@ var require_axios = __commonJS({
               proxy
             });
           }
-          const base643 = Buffer.from(proxyAuth, "utf8").toString("base64");
-          options.headers["Proxy-Authorization"] = "Basic " + base643;
         }
-        let hasUserHostHeader = false;
-        for (const name of Object.keys(options.headers)) {
-          if (name.toLowerCase() === "host") {
-            hasUserHostHeader = true;
-            break;
+        const targetIsHttps = isHttps.test(options.protocol);
+        if (targetIsHttps) {
+          if (!(configHttpsAgent instanceof HttpsProxyAgent)) {
+            const proxyHost = readProxyField("hostname") || readProxyField("host");
+            const proxyPort = readProxyField("port");
+            const rawProxyProtocol = readProxyField("protocol");
+            const normalizedProtocol = rawProxyProtocol ? rawProxyProtocol.includes(":") ? rawProxyProtocol : `${rawProxyProtocol}:` : "http:";
+            const proxyHostForURL = proxyHost && proxyHost.includes(":") && !proxyHost.startsWith("[") ? `[${proxyHost}]` : proxyHost;
+            const proxyURL = new URL(`${normalizedProtocol}//${proxyHostForURL}${proxyPort ? ":" + proxyPort : ""}`);
+            const agentOptions = {
+              protocol: proxyURL.protocol,
+              hostname: proxyURL.hostname.replace(/^\[|\]$/g, ""),
+              port: proxyURL.port,
+              auth: proxyAuth && typeof proxyAuth === "string" ? proxyAuth : void 0
+            };
+            if (proxyURL.protocol === "https:") {
+              agentOptions.ALPNProtocols = ["http/1.1"];
+            }
+            const tunnelingAgent = getTunnelingAgent(agentOptions, configHttpsAgent);
+            options.agent = tunnelingAgent;
+            if (options.agents) {
+              options.agents.https = tunnelingAgent;
+            }
+          }
+        } else {
+          if (proxyAuth) {
+            const base643 = Buffer.from(proxyAuth, "utf8").toString("base64");
+            options.headers["Proxy-Authorization"] = "Basic " + base643;
+          }
+          let hasUserHostHeader = false;
+          for (const name of Object.keys(options.headers)) {
+            if (name.toLowerCase() === "host") {
+              hasUserHostHeader = true;
+              break;
+            }
+          }
+          if (!hasUserHostHeader) {
+            options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
+          }
+          const proxyHost = readProxyField("hostname") || readProxyField("host");
+          options.hostname = proxyHost;
+          options.host = proxyHost;
+          options.port = readProxyField("port");
+          options.path = location;
+          const proxyProtocol = readProxyField("protocol");
+          if (proxyProtocol) {
+            options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
           }
-        }
-        if (!hasUserHostHeader) {
-          options.headers.host = options.hostname + (options.port ? ":" + options.port : "");
-        }
-        const proxyHost = readProxyField("hostname") || readProxyField("host");
-        options.hostname = proxyHost;
-        options.host = proxyHost;
-        options.port = readProxyField("port");
-        options.path = location;
-        const proxyProtocol = readProxyField("protocol");
-        if (proxyProtocol) {
-          options.protocol = proxyProtocol.includes(":") ? proxyProtocol : `${proxyProtocol}:`;
         }
       }
       options.beforeRedirects.proxy = function beforeRedirect(redirectOptions) {
-        setProxy(redirectOptions, configProxy, redirectOptions.href, true);
+        setProxy(redirectOptions, configProxy, redirectOptions.href, true, configHttpsAgent);
       };
     }
     var isHttpAdapterSupported = typeof process !== "undefined" && utils$1.kindOf(process) === "process";
@@ -35495,7 +36017,7 @@ var require_axios = __commonJS({
         const options = Object.assign(/* @__PURE__ */ Object.create(null), {
           path: path$1,
           method,
-          headers: headers.toJSON(),
+          headers: toByteStringHeaderObject(headers),
           agents: {
             http: config2.httpAgent,
             https: config2.httpsAgent
@@ -35524,12 +36046,14 @@ var require_axios = __commonJS({
         } else {
           options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
           options.port = parsed.port;
-          setProxy(options, config2.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+          setProxy(options, config2.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path, false, config2.httpsAgent);
         }
         let transport;
         let isNativeTransport = false;
         const isHttpsRequest = isHttps.test(options.protocol);
-        options.agent = isHttpsRequest ? config2.httpsAgent : config2.httpAgent;
+        if (options.agent == null) {
+          options.agent = isHttpsRequest ? config2.httpsAgent : config2.httpAgent;
+        }
         if (isHttp2) {
           transport = http2Transport;
         } else {
@@ -36051,7 +36575,7 @@ var require_axios = __commonJS({
         };
         requestData === void 0 && requestHeaders.setContentType(null);
         if ("setRequestHeader" in request) {
-          utils$1.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
+          utils$1.forEach(toByteStringHeaderObject(requestHeaders), function setRequestHeader(val, key) {
             request.setRequestHeader(key, val);
           });
         }
@@ -36094,41 +36618,41 @@ var require_axios = __commonJS({
       });
     };
     var composeSignals = (signals2, timeout) => {
-      const {
-        length
-      } = signals2 = signals2 ? signals2.filter(Boolean) : [];
-      if (timeout || length) {
-        let controller = new AbortController();
-        let aborted2;
-        const onabort = function(reason) {
-          if (!aborted2) {
-            aborted2 = true;
-            unsubscribe();
-            const err = reason instanceof Error ? reason : this.reason;
-            controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
-          }
-        };
-        let timer = timeout && setTimeout(() => {
-          timer = null;
-          onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
-        }, timeout);
-        const unsubscribe = () => {
-          if (signals2) {
-            timer && clearTimeout(timer);
-            timer = null;
-            signals2.forEach((signal2) => {
-              signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
-            });
-            signals2 = null;
-          }
-        };
-        signals2.forEach((signal2) => signal2.addEventListener("abort", onabort));
-        const {
-          signal
-        } = controller;
-        signal.unsubscribe = () => utils$1.asap(unsubscribe);
-        return signal;
+      signals2 = signals2 ? signals2.filter(Boolean) : [];
+      if (!timeout && !signals2.length) {
+        return;
       }
+      const controller = new AbortController();
+      let aborted2 = false;
+      const onabort = function(reason) {
+        if (!aborted2) {
+          aborted2 = true;
+          unsubscribe();
+          const err = reason instanceof Error ? reason : this.reason;
+          controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
+        }
+      };
+      let timer = timeout && setTimeout(() => {
+        timer = null;
+        onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
+      }, timeout);
+      const unsubscribe = () => {
+        if (!signals2) {
+          return;
+        }
+        timer && clearTimeout(timer);
+        timer = null;
+        signals2.forEach((signal2) => {
+          signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
+        });
+        signals2 = null;
+      };
+      signals2.forEach((signal2) => signal2.addEventListener("abort", onabort));
+      const {
+        signal
+      } = controller;
+      signal.unsubscribe = () => utils$1.asap(unsubscribe);
+      return signal;
     };
     var streamChunk = function* (chunk, chunkSize) {
       let len = chunk.byteLength;
@@ -36223,8 +36747,7 @@ var require_axios = __commonJS({
       }
     };
     var factory = (env) => {
-      var _utils$global;
-      const globalObject = (_utils$global = utils$1.global) !== null && _utils$global !== void 0 ? _utils$global : globalThis;
+      const globalObject = utils$1.global !== void 0 && utils$1.global !== null ? utils$1.global : globalThis;
       const {
         ReadableStream: ReadableStream2,
         TextEncoder: TextEncoder2
@@ -36377,7 +36900,7 @@ var require_axios = __commonJS({
             ...fetchOptions,
             signal: composedSignal,
             method: method.toUpperCase(),
-            headers: headers.normalize().toJSON(),
+            headers: toByteStringHeaderObject(headers.normalize()),
             body: data,
             duplex: "half",
             credentials: isCredentialsSupported ? withCredentials : void 0
@@ -37369,7 +37892,7 @@ var require_priority_queue = __commonJS({
 });
 
 // node_modules/p-queue/dist/index.js
-var require_dist3 = __commonJS({
+var require_dist4 = __commonJS({
   "node_modules/p-queue/dist/index.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -38749,7 +39272,7 @@ var require_views = __commonJS({
 });
 
 // node_modules/@slack/types/dist/index.js
-var require_dist4 = __commonJS({
+var require_dist5 = __commonJS({
   "node_modules/@slack/types/dist/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m2, k2, k22) {
@@ -40414,7 +40937,7 @@ var require_methods = __commonJS({
       }
     };
     exports2.Methods = Methods;
-    __exportStar(require_dist4(), exports2);
+    __exportStar(require_dist5(), exports2);
   }
 });
 
@@ -40547,7 +41070,7 @@ var require_WebClient = __commonJS({
     var form_data_1 = __importDefault(require_form_data());
     var is_electron_1 = __importDefault(require_is_electron());
     var is_stream_1 = __importDefault(require_is_stream());
-    var p_queue_1 = __importDefault(require_dist3());
+    var p_queue_1 = __importDefault(require_dist4());
     var p_retry_1 = __importStar(require_p_retry());
     var chat_stream_1 = require_chat_stream();
     var errors_1 = require_errors2();
@@ -41148,7 +41671,7 @@ var require_WebClient = __commonJS({
 });
 
 // node_modules/@slack/web-api/dist/index.js
-var require_dist5 = __commonJS({
+var require_dist6 = __commonJS({
   "node_modules/@slack/web-api/dist/index.js"(exports2) {
     "use strict";
     var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m2, k2, k22) {
@@ -41218,7 +41741,7 @@ var import_web_api, SlackWebApiClient;
 var init_local_runtime2 = __esm({
   "packages/slack-primitive/src/local-runtime.ts"() {
     "use strict";
-    import_web_api = __toESM(require_dist5(), 1);
+    import_web_api = __toESM(require_dist6(), 1);
     init_adapter2();
     init_types2();
     SlackWebApiClient = class extends BaseSlackAdapter {
@@ -43070,6 +43593,7 @@ __export(index_exports, {
   findGitRoot: () => findGitRoot,
   findLocalSdkWorkspace: () => findLocalSdkWorkspace,
   findPersona: () => findPersona,
+  findPrUrl: () => findPrUrl,
   findRelayPtyBinary: () => findRelayPtyBinary,
   followLogs: () => followLogs,
   formatDryRunReport: () => formatDryRunReport,
@@ -50446,7 +50970,7 @@ var DefaultModels = {
 };
 
 // node_modules/@relaycast/sdk/dist/version.js
-var SDK_VERSION = "1.1.5";
+var SDK_VERSION = "1.1.7";
 
 // node_modules/@relaycast/sdk/node_modules/zod/v4/classic/external.js
 var external_exports2 = {};
@@ -65436,6 +65960,7 @@ var ChannelMessagePayloadSchema = CoreMessagePayloadSchema.extend({
   attachments: external_exports2.array(FileAttachmentSchema)
 });
 var MessageCreatedEventSchema = external_exports2.object({
+  id: external_exports2.string().uuid(),
   type: external_exports2.literal("message.created"),
   channel: external_exports2.string(),
   message: ChannelMessagePayloadSchema
@@ -65446,6 +65971,7 @@ var MessageUpdatedEventSchema = external_exports2.object({
   message: CoreMessagePayloadSchema
 });
 var ThreadReplyEventSchema = external_exports2.object({
+  id: external_exports2.string().uuid(),
   type: external_exports2.literal("thread.reply"),
   channel: external_exports2.string(),
   parent_id: external_exports2.string(),
@@ -65464,11 +65990,13 @@ var ReactionRemovedEventSchema = external_exports2.object({
   agent_name: external_exports2.string()
 });
 var DmReceivedEventSchema = external_exports2.object({
+  id: external_exports2.string().uuid(),
   type: external_exports2.literal("dm.received"),
   conversation_id: external_exports2.string(),
   message: CoreMessagePayloadSchema
 });
 var GroupDmReceivedEventSchema = external_exports2.object({
+  id: external_exports2.string().uuid(),
   type: external_exports2.literal("group_dm.received"),
   conversation_id: external_exports2.string(),
   message: CoreMessagePayloadSchema
@@ -65599,6 +66127,12 @@ var ServerEventSchema = external_exports2.discriminatedUnion("type", [
   CommandInvokedEventSchema,
   PongEventSchema
 ]);
+var RelaycastMessageEventSchema = external_exports2.discriminatedUnion("type", [
+  MessageCreatedEventSchema,
+  ThreadReplyEventSchema,
+  DmReceivedEventSchema,
+  GroupDmReceivedEventSchema
+]);
 var WsClientEventSchema = external_exports2.discriminatedUnion("type", [
   // Server events
   MessageCreatedEventSchema,
@@ -66147,6 +66681,9 @@ var WsClient = class {
   off(event, handler) {
     this.handlers.get(event)?.delete(handler);
   }
+  get connected() {
+    return this.isOpen;
+  }
   emit(event, data) {
     this.handlers.get(event)?.forEach((h) => h(data));
     this.handlers.get("*")?.forEach((h) => h(data));
@@ -66213,6 +66750,55 @@ var WsClient = class {
   }
 };
 
+// node_modules/@relaycast/sdk/dist/event-id.js
+function hashStringParts(parts) {
+  const input = JSON.stringify(parts);
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  let h3 = 3235826430;
+  let h4 = 2654435769;
+  for (let i = 0; i < input.length; i += 1) {
+    const code = input.charCodeAt(i);
+    h1 = Math.imul(h1 ^ code, 2654435761);
+    h2 = Math.imul(h2 ^ code, 1597334677);
+    h3 = Math.imul(h3 ^ code, 2246822507);
+    h4 = Math.imul(h4 ^ code, 3266489909);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h3 ^ h3 >>> 13, 3266489909);
+  h3 = Math.imul(h3 ^ h3 >>> 16, 2246822507) ^ Math.imul(h4 ^ h4 >>> 13, 3266489909);
+  h4 = Math.imul(h4 ^ h4 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return [h1 >>> 0, h2 >>> 0, h3 >>> 0, h4 >>> 0];
+}
+function formatUuidFromWords(words) {
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < words.length; i += 1) {
+    const word = words[i];
+    const offset = i * 4;
+    bytes[offset] = word >>> 24 & 255;
+    bytes[offset + 1] = word >>> 16 & 255;
+    bytes[offset + 2] = word >>> 8 & 255;
+    bytes[offset + 3] = word & 255;
+  }
+  bytes[6] = bytes[6] & 15 | 80;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex3 = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return [
+    hex3.slice(0, 8),
+    hex3.slice(8, 12),
+    hex3.slice(12, 16),
+    hex3.slice(16, 20),
+    hex3.slice(20, 32)
+  ].join("-");
+}
+function stableRelaycastEventId(...parts) {
+  const normalized = parts.map((part) => part?.trim()).filter((part) => typeof part === "string" && part.length > 0);
+  if (normalized.length === 0) {
+    return formatUuidFromWords(hashStringParts(["relaycast", "empty-event"]));
+  }
+  return formatUuidFromWords(hashStringParts(["relaycast", ...normalized]));
+}
+
 // node_modules/@relaycast/sdk/dist/agent.js
 function stripHash(channel) {
   return channel.startsWith("#") ? channel.slice(1) : channel;
@@ -66241,6 +66827,21 @@ function idempotencyHeaders(opts) {
     }
   };
 }
+function normalizeSubscriptionChannel(channel) {
+  const trimmed = channel.trim();
+  if (trimmed === "@self")
+    return trimmed;
+  return stripHash(trimmed);
+}
+function ensureRelaycastMessageEventId(event) {
+  if (typeof event.id === "string" && event.id.length > 0) {
+    return event;
+  }
+  return {
+    ...event,
+    id: stableRelaycastEventId(event.message.id)
+  };
+}
 var AgentClient = class {
   client;
   ws = null;
@@ -66248,6 +66849,9 @@ var AgentClient = class {
   autoHeartbeatTimer = null;
   pendingHeartbeat = null;
   wsOptions;
+  manualSubscriptions = /* @__PURE__ */ new Set();
+  managedSubscriptions = /* @__PURE__ */ new Map();
+  activeWsChannels = /* @__PURE__ */ new Set();
   constructor(client, options = {}) {
     this.client = client;
     this.autoHeartbeatMs = normalizeAutoHeartbeatMs(options.autoHeartbeatMs);
@@ -66305,12 +66909,15 @@ var AgentClient = class {
       void this.presence.markOnline().catch(() => {
       });
       this.startAutoHeartbeat();
+      this.syncDesiredSubscriptions({ resetRemoteState: true });
     });
     this.ws.on("close", () => {
       this.stopAutoHeartbeat();
+      this.activeWsChannels.clear();
     });
     this.ws.on("permanently_disconnected", () => {
       this.stopAutoHeartbeat();
+      this.activeWsChannels.clear();
     });
     this.ws.connect();
   }
@@ -66324,18 +66931,80 @@ var AgentClient = class {
       await this.pendingHeartbeat;
       this.pendingHeartbeat = null;
     }
+    for (const subscription of this.managedSubscriptions.values()) {
+      for (const stop of subscription.stops) {
+        stop();
+      }
+    }
+    this.managedSubscriptions.clear();
+    this.manualSubscriptions.clear();
     if (this.ws) {
       this.ws.disconnect();
       this.ws = null;
     }
+    this.activeWsChannels.clear();
     await this.client.post("/v1/agents/disconnect", {}).catch(() => {
     });
   }
-  subscribe(channels) {
-    this.ws?.subscribe(channels);
+  subscribe(channels, onMessage) {
+    const normalized = [...new Set(channels.map(normalizeSubscriptionChannel).filter(Boolean))];
+    if (normalized.length === 0) {
+      if (onMessage) {
+        return { channels: [], unsubscribe() {
+        } };
+      }
+      return;
+    }
+    if (!onMessage) {
+      for (const channel of normalized) {
+        this.manualSubscriptions.add(channel);
+      }
+      this.syncDesiredSubscriptions();
+      return;
+    }
+    this.connect();
+    const key = /* @__PURE__ */ Symbol("relaycast.subscription");
+    const channelSet = new Set(normalized);
+    const invoke = (event) => {
+      if (!this.matchesSubscription(channelSet, event)) {
+        return;
+      }
+      void Promise.resolve().then(() => onMessage(ensureRelaycastMessageEventId(event))).catch((err) => {
+        console.error("[relaycast] Subscription handler failed", err);
+      });
+    };
+    const stops = [
+      this.on.messageCreated((event) => invoke(event)),
+      this.on.threadReply((event) => invoke(event)),
+      this.on.dmReceived((event) => invoke(event)),
+      this.on.groupDmReceived((event) => invoke(event))
+    ];
+    this.managedSubscriptions.set(key, {
+      channels: channelSet,
+      handler: onMessage,
+      stops
+    });
+    this.syncDesiredSubscriptions();
+    return {
+      channels: Object.freeze([...normalized]),
+      unsubscribe: () => {
+        const current = this.managedSubscriptions.get(key);
+        if (!current)
+          return;
+        this.managedSubscriptions.delete(key);
+        for (const stop of current.stops) {
+          stop();
+        }
+        this.syncDesiredSubscriptions();
+      }
+    };
   }
   unsubscribe(channels) {
-    this.ws?.unsubscribe(channels);
+    const normalized = [...new Set(channels.map(normalizeSubscriptionChannel).filter(Boolean))];
+    for (const channel of normalized) {
+      this.manualSubscriptions.delete(channel);
+    }
+    this.syncDesiredSubscriptions();
   }
   onEvent(eventType, handler) {
     if (!this.ws) {
@@ -66399,6 +67068,9 @@ var AgentClient = class {
     };
     return this.client.post(`/v1/channels/${encodeURIComponent(name)}/messages`, body, idempotencyHeaders(opts));
   }
+  post(channel, text, opts) {
+    return this.send(channel, text, opts);
+  }
   async messages(channel, opts) {
     const name = stripHash(channel);
     const query = {};
@@ -66461,6 +67133,58 @@ var AgentClient = class {
     addParticipant: (conversationId, agent) => this.client.post(`/v1/dm/${encodeURIComponent(conversationId)}/participants`, { agentName: agent }),
     removeParticipant: (conversationId, agent) => this.client.delete(`/v1/dm/${encodeURIComponent(conversationId)}/participants/${encodeURIComponent(agent)}`)
   };
+  matchesSubscription(channels, event) {
+    switch (event.type) {
+      case "dm.received":
+      case "group_dm.received":
+        return channels.has("@self");
+      case "message.created":
+      case "thread.reply":
+        return channels.has(stripHash(event.channel));
+      default:
+        return false;
+    }
+  }
+  desiredWsChannels() {
+    const desired = /* @__PURE__ */ new Set();
+    for (const channel of this.manualSubscriptions) {
+      if (channel !== "@self") {
+        desired.add(channel);
+      }
+    }
+    for (const subscription of this.managedSubscriptions.values()) {
+      for (const channel of subscription.channels) {
+        if (channel !== "@self") {
+          desired.add(channel);
+        }
+      }
+    }
+    return desired;
+  }
+  syncDesiredSubscriptions(options = {}) {
+    if (!this.ws) {
+      return;
+    }
+    const desired = this.desiredWsChannels();
+    if (!this.ws.connected) {
+      if (options.resetRemoteState) {
+        this.activeWsChannels.clear();
+      }
+      return;
+    }
+    if (options.resetRemoteState) {
+      this.activeWsChannels.clear();
+    }
+    const toSubscribe = [...desired].filter((channel) => !this.activeWsChannels.has(channel));
+    const toUnsubscribe = [...this.activeWsChannels].filter((channel) => !desired.has(channel));
+    if (toSubscribe.length > 0) {
+      this.ws.subscribe(toSubscribe);
+    }
+    if (toUnsubscribe.length > 0) {
+      this.ws.unsubscribe(toUnsubscribe);
+    }
+    this.activeWsChannels = desired;
+  }
   // === Channels ===
   channels = {
     create: (data) => this.client.post("/v1/channels", data),
@@ -66557,6 +67281,10 @@ var RAW_CODE_MAP = {
   agent_already_exists: "name_conflict",
   not_found: "not_found",
   agent_not_found: "not_found",
+  rate_limit_exceeded: "rate_limited",
+  backpressure: "backpressure",
+  queue_overloaded: "backpressure",
+  workspace_stream_backpressure: "backpressure",
   unauthorized: "unauthorized",
   workspace_mismatch: "workspace_mismatch",
   workspace_not_found: "workspace_mismatch"
@@ -66572,12 +67300,18 @@ function normalizeRelayErrorCode(rawCode, statusCode) {
   if (statusCode === 404) {
     return "not_found";
   }
+  if (statusCode === 429) {
+    return "rate_limited";
+  }
   if (statusCode === 409) {
     return "name_conflict";
   }
   return "transport_error";
 }
 function relayErrorRetryable(code, statusCode) {
+  if (code === "rate_limited" || code === "backpressure") {
+    return true;
+  }
   if (code !== "transport_error") {
     return false;
   }
@@ -78611,6 +79345,14 @@ function runVerification(check2, output, stepName, injectedTaskText, options = {
       }
       break;
     }
+    case "pr_url": {
+      const found = findPrUrl(output, check2.value, injectedTaskText);
+      if (!found) {
+        const repoQualifier = check2.value ? ` for repository "${check2.value}"` : "";
+        return fail(`Verification failed for "${stepName}": step output does not contain a GitHub PR URL${repoQualifier}. Workers must open a pull request and include the URL in their output before reporting completion.`);
+      }
+      break;
+    }
     default:
       break;
   }
@@ -78663,6 +79405,24 @@ function checkOutputContains(output, token, injectedTaskText) {
   }
   return stripInjectedTaskEcho(output, injectedTaskText).includes(token);
 }
+var PR_URL_PATTERN = /https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)\b/gi;
+function findPrUrl(output, repoQualifier, injectedTaskText) {
+  const sanitized = stripInjectedTaskEcho(output, injectedTaskText);
+  const qualifier = repoQualifier?.trim().toLowerCase();
+  PR_URL_PATTERN.lastIndex = 0;
+  let match;
+  while (match = PR_URL_PATTERN.exec(sanitized)) {
+    if (!qualifier) {
+      return match[0];
+    }
+    const owner = match[1]?.toLowerCase();
+    const repo = match[2]?.toLowerCase();
+    if (`${owner}/${repo}` === qualifier) {
+      return match[0];
+    }
+  }
+  return null;
+}
 var DEFAULT_CUSTOM_VERIFY_TIMEOUT_MS = parseInt(process.env.CUSTOM_VERIFY_TIMEOUT_MS ?? "30000", 10);
 var REGEX_PREFIX = "regex:";
 function execCustomVerification(command, cwd, timeoutMs = DEFAULT_CUSTOM_VERIFY_TIMEOUT_MS) {
@@ -93531,6 +94291,7 @@ init_dist2();
   findGitRoot,
   findLocalSdkWorkspace,
   findPersona,
+  findPrUrl,
   findRelayPtyBinary,
   followLogs,
   formatDryRunReport,
@@ -93666,5 +94427,5 @@ mime-types/index.js:
    *)
 
 axios/dist/node/axios.cjs:
-  (*! Axios v1.16.0 Copyright (c) 2026 Matt Zabriskie and contributors *)
+  (*! Axios v1.16.1 Copyright (c) 2026 Matt Zabriskie and contributors *)
 */