agent-relay 6.0.14 → 6.0.16

package/dist/index.cjs

@@ -2234,7 +2234,7 @@ var require_websocket = __commonJS({
     "use strict";
     var EventEmitter6 = require("events");
     var https3 = require("https");
-    var http = require("http");
+    var http2 = require("http");
     var net = require("net");
     var tls = require("tls");
     var { randomBytes: randomBytes9, createHash: createHash4 } = require("crypto");
@@ -2768,7 +2768,7 @@ var require_websocket = __commonJS({
       }
       const defaultPort = isSecure ? 443 : 80;
       const key = randomBytes9(16).toString("base64");
-      const request = isSecure ? https3.request : http.request;
+      const request = isSecure ? https3.request : http2.request;
       const protocolSet = /* @__PURE__ */ new Set();
       let perMessageDeflate;
       opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
@@ -3262,7 +3262,7 @@ var require_websocket_server = __commonJS({
   "node_modules/ws/lib/websocket-server.js"(exports2, module2) {
     "use strict";
     var EventEmitter6 = require("events");
-    var http = require("http");
+    var http2 = require("http");
     var { Duplex } = require("stream");
     var { createHash: createHash4 } = require("crypto");
     var extension2 = require_extension();
@@ -3337,8 +3337,8 @@ var require_websocket_server = __commonJS({
           );
         }
         if (options.port != null) {
-          this._server = http.createServer((req, res) => {
-            const body = http.STATUS_CODES[426];
+          this._server = http2.createServer((req, res) => {
+            const body = http2.STATUS_CODES[426];
             res.writeHead(426, {
               "Content-Length": body.length,
               "Content-Type": "text/plain"
@@ -3625,7 +3625,7 @@ var require_websocket_server = __commonJS({
       this.destroy();
     }
     function abortHandshake(socket, code, message, headers) {
-      message = message || http.STATUS_CODES[code];
+      message = message || http2.STATUS_CODES[code];
       headers = {
         Connection: "close",
         "Content-Type": "text/html",
@@ -3634,7 +3634,7 @@ var require_websocket_server = __commonJS({
       };
       socket.once("finish", socket.destroy);
       socket.end(
-        `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}\r
+        `HTTP/1.1 ${code} ${http2.STATUS_CODES[code]}\r
 ` + Object.keys(headers).map((h) => `${h}: ${headers[h]}`).join("\r\n") + "\r\n\r\n" + message
       );
     }
@@ -4531,15 +4531,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path25 = [graph[toModel].parent, toModel];
+      const path28 = [graph[toModel].parent, toModel];
       let fn2 = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path25.unshift(graph[cur].parent);
+        path28.unshift(graph[cur].parent);
         fn2 = link2(conversions[graph[cur].parent][cur], fn2);
         cur = graph[cur].parent;
       }
-      fn2.conversion = path25;
+      fn2.conversion = path28;
       return fn2;
     }
     module2.exports = function(fromModel) {
@@ -4779,7 +4779,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os12 = require("os");
+    var os14 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -4827,7 +4827,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os12.release().split(".");
+        const osRelease = os14.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -5505,7 +5505,7 @@ var require_ignore = __commonJS({
       //   path matching.
       // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
       // @returns {TestResult} true if a file is ignored
-      test(path25, checkUnignored, mode) {
+      test(path28, checkUnignored, mode) {
         let ignored = false;
         let unignored = false;
         let matchedRule;
@@ -5514,7 +5514,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule[mode].test(path25);
+          const matched = rule[mode].test(path28);
           if (!matched) {
             return;
           }
@@ -5535,17 +5535,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path25, originalPath, doThrow) => {
-      if (!isString2(path25)) {
+    var checkPath = (path28, originalPath, doThrow) => {
+      if (!isString2(path28)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path25) {
+      if (!path28) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path25)) {
+      if (checkPath.isNotRelative(path28)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -5554,7 +5554,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path25) => REGEX_TEST_INVALID_PATH.test(path25);
+    var isNotRelative = (path28) => REGEX_TEST_INVALID_PATH.test(path28);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p2) => p2;
     var Ignore = class {
@@ -5584,19 +5584,19 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path25 = originalPath && checkPath.convert(originalPath);
+        const path28 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path25,
+          path28,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path25, cache, checkUnignored, slices);
+        return this._t(path28, cache, checkUnignored, slices);
       }
-      checkIgnore(path25) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path25)) {
-          return this.test(path25);
+      checkIgnore(path28) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path28)) {
+          return this.test(path28);
         }
-        const slices = path25.split(SLASH).filter(Boolean);
+        const slices = path28.split(SLASH).filter(Boolean);
         slices.pop();
         if (slices.length) {
           const parent = this._t(
@@ -5609,18 +5609,18 @@ var require_ignore = __commonJS({
             return parent;
           }
         }
-        return this._rules.test(path25, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path28, false, MODE_CHECK_IGNORE);
       }
-      _t(path25, cache, checkUnignored, slices) {
-        if (path25 in cache) {
-          return cache[path25];
+      _t(path28, cache, checkUnignored, slices) {
+        if (path28 in cache) {
+          return cache[path28];
         }
         if (!slices) {
-          slices = path25.split(SLASH).filter(Boolean);
+          slices = path28.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path25] = this._rules.test(path25, checkUnignored, MODE_IGNORE);
+          return cache[path28] = this._rules.test(path28, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -5628,29 +5628,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path25] = parent.ignored ? parent : this._rules.test(path25, checkUnignored, MODE_IGNORE);
+        return cache[path28] = parent.ignored ? parent : this._rules.test(path28, checkUnignored, MODE_IGNORE);
       }
-      ignores(path25) {
-        return this._test(path25, this._ignoreCache, false).ignored;
+      ignores(path28) {
+        return this._test(path28, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path25) => !this.ignores(path25);
+        return (path28) => !this.ignores(path28);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path25) {
-        return this._test(path25, this._testCache, true);
+      test(path28) {
+        return this._test(path28, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path25) => checkPath(path25 && checkPath.convert(path25), path25, RETURN_FALSE);
+    var isPathValid = (path28) => checkPath(path28 && checkPath.convert(path28), path28, RETURN_FALSE);
     var setupWindows = () => {
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path25) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path25) || isNotRelative(path25);
+      checkPath.isNotRelative = (path28) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path28) || isNotRelative(path28);
     };
     if (
       // Detect `process` so that it can run in browsers.
@@ -5742,17 +5742,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path25) {
-      const ctrl = callVisitor(key, node, visitor, path25);
+    function visit_(key, node, visitor, path28) {
+      const ctrl = callVisitor(key, node, visitor, path28);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path25, ctrl);
-        return visit_(key, ctrl, visitor, path25);
+        replaceNode(key, path28, ctrl);
+        return visit_(key, ctrl, visitor, path28);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path25 = Object.freeze(path25.concat(node));
+          path28 = Object.freeze(path28.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = visit_(i, node.items[i], visitor, path25);
+            const ci2 = visit_(i, node.items[i], visitor, path28);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -5763,13 +5763,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path25 = Object.freeze(path25.concat(node));
-          const ck = visit_("key", node.key, visitor, path25);
+          path28 = Object.freeze(path28.concat(node));
+          const ck = visit_("key", node.key, visitor, path28);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path25);
+          const cv = visit_("value", node.value, visitor, path28);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5790,17 +5790,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path25) {
-      const ctrl = await callVisitor(key, node, visitor, path25);
+    async function visitAsync_(key, node, visitor, path28) {
+      const ctrl = await callVisitor(key, node, visitor, path28);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path25, ctrl);
-        return visitAsync_(key, ctrl, visitor, path25);
+        replaceNode(key, path28, ctrl);
+        return visitAsync_(key, ctrl, visitor, path28);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path25 = Object.freeze(path25.concat(node));
+          path28 = Object.freeze(path28.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = await visitAsync_(i, node.items[i], visitor, path25);
+            const ci2 = await visitAsync_(i, node.items[i], visitor, path28);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -5811,13 +5811,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path25 = Object.freeze(path25.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path25);
+          path28 = Object.freeze(path28.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path28);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path25);
+          const cv = await visitAsync_("value", node.value, visitor, path28);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5844,23 +5844,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path25) {
+    function callVisitor(key, node, visitor, path28) {
       if (typeof visitor === "function")
-        return visitor(key, node, path25);
+        return visitor(key, node, path28);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path25);
+        return visitor.Map?.(key, node, path28);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path25);
+        return visitor.Seq?.(key, node, path28);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path25);
+        return visitor.Pair?.(key, node, path28);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path25);
+        return visitor.Scalar?.(key, node, path28);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path25);
+        return visitor.Alias?.(key, node, path28);
       return void 0;
     }
-    function replaceNode(key, path25, node) {
-      const parent = path25[path25.length - 1];
+    function replaceNode(key, path28, node) {
+      const parent = path28[path28.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -6470,10 +6470,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path25, value) {
+    function collectionFromPath(schema, path28, value) {
       let v2 = value;
-      for (let i = path25.length - 1; i >= 0; --i) {
-        const k2 = path25[i];
+      for (let i = path28.length - 1; i >= 0; --i) {
+        const k2 = path28[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -6492,7 +6492,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path25) => path25 == null || typeof path25 === "object" && !!path25[Symbol.iterator]().next().done;
+    var isEmptyPath = (path28) => path28 == null || typeof path28 === "object" && !!path28[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -6522,11 +6522,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path25, value) {
-        if (isEmptyPath(path25))
+      addIn(path28, value) {
+        if (isEmptyPath(path28))
           this.add(value);
         else {
-          const [key, ...rest] = path25;
+          const [key, ...rest] = path28;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -6540,8 +6540,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path25) {
-        const [key, ...rest] = path25;
+      deleteIn(path28) {
+        const [key, ...rest] = path28;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -6555,8 +6555,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path25, keepScalar) {
-        const [key, ...rest] = path25;
+      getIn(path28, keepScalar) {
+        const [key, ...rest] = path28;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -6574,8 +6574,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path25) {
-        const [key, ...rest] = path25;
+      hasIn(path28) {
+        const [key, ...rest] = path28;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -6585,8 +6585,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path25, value) {
-        const [key, ...rest] = path25;
+      setIn(path28, value) {
+        const [key, ...rest] = path28;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -9101,9 +9101,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path25, value) {
+      addIn(path28, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path25, value);
+          this.contents.addIn(path28, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -9178,14 +9178,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path25) {
-        if (Collection.isEmptyPath(path25)) {
+      deleteIn(path28) {
+        if (Collection.isEmptyPath(path28)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path25) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path28) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -9200,10 +9200,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path25, keepScalar) {
-        if (Collection.isEmptyPath(path25))
+      getIn(path28, keepScalar) {
+        if (Collection.isEmptyPath(path28))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path25, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path28, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -9214,10 +9214,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path25) {
-        if (Collection.isEmptyPath(path25))
+      hasIn(path28) {
+        if (Collection.isEmptyPath(path28))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path25) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path28) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -9234,13 +9234,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path25, value) {
-        if (Collection.isEmptyPath(path25)) {
+      setIn(path28, value) {
+        if (Collection.isEmptyPath(path28)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path25), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path28), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path25, value);
+          this.contents.setIn(path28, value);
         }
       }
       /**
@@ -10815,8 +10815,10 @@ ${cb}` : comment;
           }
         }
         if (afterDoc) {
-          Array.prototype.push.apply(doc.errors, this.errors);
-          Array.prototype.push.apply(doc.warnings, this.warnings);
+          for (let i = 0; i < this.errors.length; ++i)
+            doc.errors.push(this.errors[i]);
+          for (let i = 0; i < this.warnings.length; ++i)
+            doc.warnings.push(this.warnings[i]);
         } else {
           doc.errors = this.errors;
           doc.warnings = this.warnings;
@@ -11198,9 +11200,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path25) => {
+    visit.itemAtPath = (cst, path28) => {
       let item = cst;
-      for (const [field, index] of path25) {
+      for (const [field, index] of path28) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -11209,23 +11211,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path25) => {
-      const parent = visit.itemAtPath(cst, path25.slice(0, -1));
-      const field = path25[path25.length - 1][0];
+    visit.parentCollection = (cst, path28) => {
+      const parent = visit.itemAtPath(cst, path28.slice(0, -1));
+      const field = path28[path28.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path25, item, visitor) {
-      let ctrl = visitor(item, path25);
+    function _visit(path28, item, visitor) {
+      let ctrl = visitor(item, path28);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci2 = _visit(Object.freeze(path25.concat([[field, i]])), token.items[i], visitor);
+            const ci2 = _visit(Object.freeze(path28.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -11236,10 +11238,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path25);
+            ctrl = ctrl(item, path28);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path25) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path28) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -11549,7 +11551,7 @@ var require_lexer = __commonJS({
           const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
           this.indentNext = this.indentValue + 1;
           this.indentValue += n;
-          return yield* this.parseBlockStart();
+          return "block-start";
         }
         return "doc";
       }
@@ -11848,28 +11850,38 @@ var require_lexer = __commonJS({
         return 0;
       }
       *pushIndicators() {
-        switch (this.charAt(0)) {
-          case "!":
-            return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
-          case "&":
-            return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
-          case "-":
-          // this is an error
-          case "?":
-          // this is an error outside flow collections
-          case ":": {
-            const inFlow = this.flowLevel > 0;
-            const ch1 = this.charAt(1);
-            if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
-              if (!inFlow)
-                this.indentNext = this.indentValue + 1;
-              else if (this.flowKey)
-                this.flowKey = false;
-              return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+        let n = 0;
+        loop: while (true) {
+          switch (this.charAt(0)) {
+            case "!":
+              n += yield* this.pushTag();
+              n += yield* this.pushSpaces(true);
+              continue loop;
+            case "&":
+              n += yield* this.pushUntil(isNotAnchorChar);
+              n += yield* this.pushSpaces(true);
+              continue loop;
+            case "-":
+            // this is an error
+            case "?":
+            // this is an error outside flow collections
+            case ":": {
+              const inFlow = this.flowLevel > 0;
+              const ch1 = this.charAt(1);
+              if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
+                if (!inFlow)
+                  this.indentNext = this.indentValue + 1;
+                else if (this.flowKey)
+                  this.flowKey = false;
+                n += yield* this.pushCount(1);
+                n += yield* this.pushSpaces(true);
+                continue loop;
+              }
             }
           }
+          break loop;
         }
-        return 0;
+        return n;
       }
       *pushTag() {
         if (this.charAt(1) === "<") {
@@ -12028,6 +12040,13 @@ var require_parser = __commonJS({
       }
       return prev.splice(i, prev.length);
     }
+    function arrayPushArray(target, source) {
+      if (source.length < 1e5)
+        Array.prototype.push.apply(target, source);
+      else
+        for (let i = 0; i < source.length; ++i)
+          target.push(source[i]);
+    }
     function fixFlowSeqItems(fc) {
       if (fc.start.type === "flow-seq-start") {
         for (const it2 of fc.items) {
@@ -12037,11 +12056,11 @@ var require_parser = __commonJS({
             delete it2.key;
             if (isFlowToken(it2.value)) {
               if (it2.value.end)
-                Array.prototype.push.apply(it2.value.end, it2.sep);
+                arrayPushArray(it2.value.end, it2.sep);
               else
                 it2.value.end = it2.sep;
             } else
-              Array.prototype.push.apply(it2.start, it2.sep);
+              arrayPushArray(it2.start, it2.sep);
             delete it2.sep;
           }
         }
@@ -12396,7 +12415,7 @@ var require_parser = __commonJS({
                 const prev = map2.items[map2.items.length - 2];
                 const end = prev?.value?.end;
                 if (Array.isArray(end)) {
-                  Array.prototype.push.apply(end, it2.start);
+                  arrayPushArray(end, it2.start);
                   end.push(this.sourceToken);
                   map2.items.pop();
                   return;
@@ -12524,14 +12543,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs13 = this.flowScalar(this.type);
+              const fs15 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map2.items.push({ start, key: fs13, sep: [] });
+                map2.items.push({ start, key: fs15, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs13);
+                this.stack.push(fs15);
               } else {
-                Object.assign(it2, { key: fs13, sep: [] });
+                Object.assign(it2, { key: fs15, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -12584,7 +12603,7 @@ var require_parser = __commonJS({
                 const prev = seq.items[seq.items.length - 2];
                 const end = prev?.value?.end;
                 if (Array.isArray(end)) {
-                  Array.prototype.push.apply(end, it2.start);
+                  arrayPushArray(end, it2.start);
                   end.push(this.sourceToken);
                   seq.items.pop();
                   return;
@@ -12659,13 +12678,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs13 = this.flowScalar(this.type);
+              const fs15 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs13, sep: [] });
+                fc.items.push({ start: [], key: fs15, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs13);
+                this.stack.push(fs15);
               else
-                Object.assign(it2, { key: fs13, sep: [] });
+                Object.assign(it2, { key: fs15, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -13397,11 +13416,11 @@ __export(base_exports, {
   setCwd: () => setCwd,
   synchronizedOutput: () => synchronizedOutput
 });
-var import_node_process, import_node_os11, ESC, OSC, BEL, SEP, isTerminalApp, isWindows2, isTmux, cwdFunction, wrapOsc, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, isOldWindows, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beginSynchronizedOutput, endSynchronizedOutput, synchronizedOutput, beep, link, image, iTerm, ConEmu, setCwd;
+var import_node_process, import_node_os13, ESC, OSC, BEL, SEP, isTerminalApp, isWindows2, isTmux, cwdFunction, wrapOsc, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearViewport, isOldWindows, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beginSynchronizedOutput, endSynchronizedOutput, synchronizedOutput, beep, link, image, iTerm, ConEmu, setCwd;
 var init_base = __esm({
   "node_modules/ansi-escapes/base.js"() {
     import_node_process = __toESM(require("node:process"), 1);
-    import_node_os11 = __toESM(require("node:os"), 1);
+    import_node_os13 = __toESM(require("node:os"), 1);
     init_environment();
     ESC = "\x1B[";
     OSC = "\x1B]";
@@ -13481,7 +13500,7 @@ var init_base = __esm({
       if (isBrowser || !isWindows2) {
         return false;
       }
-      const parts = import_node_os11.default.release().split(".");
+      const parts = import_node_os13.default.release().split(".");
       const major = Number(parts[0]);
       const build = Number(parts[2] ?? 0);
       if (major < 10) {
@@ -18838,8 +18857,8 @@ function repoEndpoint(owner, repo, suffix = "") {
   assertOwnerRepo(owner, repo);
   return `/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}${suffix}`;
 }
-function contentsEndpoint(owner, repo, path25 = "") {
-  const normalizedPath = normalizeRepoPath(path25);
+function contentsEndpoint(owner, repo, path28 = "") {
+  const normalizedPath = normalizeRepoPath(path28);
   const suffix = normalizedPath ? `/contents/${encodeRepoPath(normalizedPath)}` : "/contents";
   return repoEndpoint(owner, repo, suffix);
 }
@@ -18847,8 +18866,8 @@ function branchEndpoint(owner, repo, branch) {
   const normalizedBranch = assertNonEmptyString(branch, "branch");
   return repoEndpoint(owner, repo, `/branches/${encodeURIComponent(normalizedBranch)}`);
 }
-function normalizeRepoPath(path25) {
-  return path25?.trim().replace(/^\/+/, "").replace(/\/+$/, "") ?? "";
+function normalizeRepoPath(path28) {
+  return path28?.trim().replace(/^\/+/, "").replace(/\/+$/, "") ?? "";
 }
 function normalizePerPage(perPage) {
   if (typeof perPage === "undefined") {
@@ -18874,9 +18893,9 @@ function hasDefinedValue(values) {
 function optionalRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
-function appendQuery(path25, query) {
+function appendQuery(path28, query) {
   if (!query) {
-    return path25;
+    return path28;
   }
   const params = new URLSearchParams();
   for (const [name, rawValue] of Object.entries(query)) {
@@ -18889,9 +18908,9 @@ function appendQuery(path25, query) {
   }
   const serialized = params.toString();
   if (!serialized) {
-    return path25;
+    return path28;
   }
-  return `${path25}${path25.includes("?") ? "&" : "?"}${serialized}`;
+  return `${path28}${path28.includes("?") ? "&" : "?"}${serialized}`;
 }
 function nonEmpty(value) {
   const trimmed = value?.trim();
@@ -18966,8 +18985,8 @@ function visibilityValue(value, isPrivate) {
 function errorMessage(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
-function encodeRepoPath(path25) {
-  return path25.split("/").map(encodeURIComponent).join("/");
+function encodeRepoPath(path28) {
+  return path28.split("/").map(encodeURIComponent).join("/");
 }
 var init_utils = __esm({
   "packages/github-primitive/src/actions/utils.ts"() {
@@ -19104,10 +19123,10 @@ var init_commits = __esm({
 });
 
 // packages/github-primitive/src/actions/files.ts
-async function listFiles(adapter, owner, repo, path25 = "", options = {}) {
-  return withActionError(`list GitHub files at ${owner}/${repo}/${path25}`, async () => {
+async function listFiles(adapter, owner, repo, path28 = "", options = {}) {
+  return withActionError(`list GitHub files at ${owner}/${repo}/${path28}`, async () => {
     assertOwnerRepo(owner, repo);
-    const response = await adapter.request("GET", contentsEndpoint(owner, repo, path25), {
+    const response = await adapter.request("GET", contentsEndpoint(owner, repo, path28), {
       query: {
         ref: options.ref
       }
@@ -19115,32 +19134,32 @@ async function listFiles(adapter, owner, repo, path25 = "", options = {}) {
     return Array.isArray(response) ? asArray(response, "repository contents").map(mapFile) : [mapFile(response)];
   });
 }
-async function readFile3(adapter, owner, repo, path25, ref) {
-  return withActionError(`read GitHub file ${owner}/${repo}/${path25}`, async () => {
+async function readFile3(adapter, owner, repo, path28, ref) {
+  return withActionError(`read GitHub file ${owner}/${repo}/${path28}`, async () => {
     assertOwnerRepo(owner, repo);
-    assertNonEmptyString(normalizeRepoPath(path25), "file path");
-    const response = await adapter.request("GET", contentsEndpoint(owner, repo, path25), {
+    assertNonEmptyString(normalizeRepoPath(path28), "file path");
+    const response = await adapter.request("GET", contentsEndpoint(owner, repo, path28), {
       query: {
         ref
       }
     });
     const file2 = mapFile(response);
     if (file2.type !== "file") {
-      throw new Error(`GitHub path "${path25}" is not a file.`);
+      throw new Error(`GitHub path "${path28}" is not a file.`);
     }
     if (!file2.content) {
-      throw new Error(`GitHub file "${path25}" did not include content in the API response.`);
+      throw new Error(`GitHub file "${path28}" did not include content in the API response.`);
     }
     if (file2.encoding && file2.encoding !== "base64") {
-      throw new Error(`GitHub file "${path25}" used unsupported encoding "${file2.encoding}".`);
+      throw new Error(`GitHub file "${path28}" used unsupported encoding "${file2.encoding}".`);
     }
     return import_node_buffer.Buffer.from(file2.content.replace(/\s/g, ""), "base64").toString("utf8");
   });
 }
-async function createFile(adapter, owner, repo, path25, content, message, options = {}) {
-  return withActionError(`create GitHub file ${owner}/${repo}/${path25}`, async () => {
+async function createFile(adapter, owner, repo, path28, content, message, options = {}) {
+  return withActionError(`create GitHub file ${owner}/${repo}/${path28}`, async () => {
     assertOwnerRepo(owner, repo);
-    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path28), "file path");
     const commitMessage = assertNonEmptyString(message, "commit message");
     await adapter.request("PUT", contentsEndpoint(owner, repo, normalizedPath), {
       body: removeUndefinedValues({
@@ -19152,10 +19171,10 @@ async function createFile(adapter, owner, repo, path25, content, message, option
     });
   });
 }
-async function updateFile(adapter, owner, repo, path25, content, message, sha, options = {}) {
-  return withActionError(`update GitHub file ${owner}/${repo}/${path25}`, async () => {
+async function updateFile(adapter, owner, repo, path28, content, message, sha, options = {}) {
+  return withActionError(`update GitHub file ${owner}/${repo}/${path28}`, async () => {
     assertOwnerRepo(owner, repo);
-    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path28), "file path");
     const commitMessage = assertNonEmptyString(message, "commit message");
     const fileSha = assertNonEmptyString(sha, "file sha");
     const response = await adapter.request("PUT", contentsEndpoint(owner, repo, normalizedPath), {
@@ -19171,10 +19190,10 @@ async function updateFile(adapter, owner, repo, path25, content, message, sha, o
     return mapFile(contentRecord);
   });
 }
-async function deleteFile(adapter, owner, repo, path25, sha, message, options = {}) {
-  return withActionError(`delete GitHub file ${owner}/${repo}/${path25}`, async () => {
+async function deleteFile(adapter, owner, repo, path28, sha, message, options = {}) {
+  return withActionError(`delete GitHub file ${owner}/${repo}/${path28}`, async () => {
     assertOwnerRepo(owner, repo);
-    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path25), "file path");
+    const normalizedPath = assertNonEmptyString(normalizeRepoPath(path28), "file path");
     const fileSha = assertNonEmptyString(sha, "file sha");
     const commitMessage = assertNonEmptyString(message, "commit message");
     await adapter.request("DELETE", contentsEndpoint(owner, repo, normalizedPath), {
@@ -19538,15 +19557,15 @@ var init_repos = __esm({
 // packages/github-primitive/src/actions/users.ts
 async function getUser(adapter, params = {}) {
   return withActionError("get GitHub user", async () => {
-    const path25 = params.username ? `/users/${encodeURIComponent(assertNonEmptyString(params.username, "username"))}` : "/user";
-    const response = await adapter.request("GET", path25);
+    const path28 = params.username ? `/users/${encodeURIComponent(assertNonEmptyString(params.username, "username"))}` : "/user";
+    const response = await adapter.request("GET", path28);
     return mapUser(response);
   });
 }
 async function listOrganizations(adapter, params = {}) {
   return withActionError("list GitHub organizations", async () => {
-    const path25 = params.username ? `/users/${encodeURIComponent(assertNonEmptyString(params.username, "username"))}/orgs` : "/user/orgs";
-    const response = await adapter.request("GET", path25, {
+    const path28 = params.username ? `/users/${encodeURIComponent(assertNonEmptyString(params.username, "username"))}/orgs` : "/user/orgs";
+    const response = await adapter.request("GET", path28, {
       query: queryWithPerPage({}, params.perPage)
     });
     return asArray(response, "organizations").map(mapOrganization);
@@ -19588,11 +19607,11 @@ __export(local_runtime_exports, {
   GhCliClient: () => GhCliClient,
   GhCliError: () => GhCliError
 });
-var import_node_child_process10, GhCliError, GhCliClient;
+var import_node_child_process11, GhCliError, GhCliClient;
 var init_local_runtime = __esm({
   "packages/github-primitive/src/local-runtime.ts"() {
     "use strict";
-    import_node_child_process10 = require("node:child_process");
+    import_node_child_process11 = require("node:child_process");
     init_adapter();
     init_utils();
     init_types();
@@ -19647,9 +19666,9 @@ var init_local_runtime = __esm({
           type: user.type
         };
       }
-      async request(method, path25, options = {}) {
+      async request(method, path28, options = {}) {
         return this.executeWithRetries(async () => {
-          const request = this.buildApiCommand(method, path25, options);
+          const request = this.buildApiCommand(method, path28, options);
           const result = await this.runGhCommand(request.args, {
             input: request.input,
             parseJson: true,
@@ -19669,7 +19688,7 @@ var init_local_runtime = __esm({
           ...options.env
         };
         return new Promise((resolve4, reject) => {
-          const child = (0, import_node_child_process10.spawn)(command, args, {
+          const child = (0, import_node_child_process11.spawn)(command, args, {
             cwd: options.cwd ?? this.config.cwd,
             env,
             stdio: ["pipe", "pipe", "pipe"]
@@ -19783,10 +19802,10 @@ var init_local_runtime = __esm({
           }
         });
       }
-      buildApiCommand(method, path25, options) {
+      buildApiCommand(method, path28, options) {
         const args = [
           "api",
-          appendQuery(path25, options.query),
+          appendQuery(path28, options.query),
           "--method",
           method,
           "--header",
@@ -19863,13 +19882,13 @@ async function parseJsonResponse(response) {
     );
   }
 }
-function buildNangoProxyUrl(baseUrl, path25, query) {
+function buildNangoProxyUrl(baseUrl, path28, query) {
   const base = trimTrailingSlash(baseUrl) ?? DEFAULT_NANGO_BASE_URL;
-  const endpoint = stripLeadingSlash(path25);
+  const endpoint = stripLeadingSlash(path28);
   return appendQuery(`${base}/proxy/${endpoint}`, query);
 }
-function joinUrl(baseUrl, path25) {
-  return `${trimTrailingSlash(baseUrl) ?? baseUrl}/${stripLeadingSlash(path25)}`;
+function joinUrl(baseUrl, path28) {
+  return `${trimTrailingSlash(baseUrl) ?? baseUrl}/${stripLeadingSlash(path28)}`;
 }
 function stripLeadingSlash(value) {
   return value.replace(/^\/+/, "");
@@ -19923,18 +19942,18 @@ var init_cloud_runtime = __esm({
           type: user.type
         };
       }
-      async request(method, path25, options = {}) {
+      async request(method, path28, options = {}) {
         return this.executeWithRetries(async () => {
           if (this.hasNangoCredentials()) {
             try {
-              return await this.requestViaNango(method, path25, options);
+              return await this.requestViaNango(method, path28, options);
             } catch (error51) {
               if (!this.hasRelayCloudCredentials()) {
                 throw error51;
               }
               this.lastNangoFallbackError = error51;
               try {
-                return await this.requestViaRelayCloud(method, path25, options);
+                return await this.requestViaRelayCloud(method, path28, options);
               } catch (relayError) {
                 throw new GitHubApiError(
                   `Nango GitHub proxy failed, then relay-cloud fallback failed: ${errorMessage2(relayError)}`,
@@ -19949,7 +19968,7 @@ var init_cloud_runtime = __esm({
             }
           }
           if (this.hasRelayCloudCredentials()) {
-            return this.requestViaRelayCloud(method, path25, options);
+            return this.requestViaRelayCloud(method, path28, options);
           }
           throw new GitHubApiError(
             "Cloud GitHub runtime requires Nango credentials or relay-cloud proxy configuration."
@@ -19962,14 +19981,14 @@ var init_cloud_runtime = __esm({
       getLastNangoFallbackError() {
         return this.lastNangoFallbackError;
       }
-      async requestViaNango(method, path25, options) {
+      async requestViaNango(method, path28, options) {
         const secretKey = this.config.nango.secretKey;
         const connectionId = this.config.nango.connectionId;
         const providerConfigKey = this.config.nango.providerConfigKey;
         if (!secretKey || !connectionId || !providerConfigKey) {
           throw new GitHubApiError("Nango GitHub proxy requires secretKey, connectionId, and providerConfigKey.");
         }
-        const url2 = buildNangoProxyUrl(this.config.nango.baseUrl, path25, options.query);
+        const url2 = buildNangoProxyUrl(this.config.nango.baseUrl, path28, options.query);
         const response = await this.fetchWithTimeout(url2, {
           method,
           headers: {
@@ -19987,7 +20006,7 @@ var init_cloud_runtime = __esm({
         });
         return parseJsonResponse(response);
       }
-      async requestViaRelayCloud(method, path25, options) {
+      async requestViaRelayCloud(method, path28, options) {
         const apiUrl = this.config.relayCloud.apiUrl;
         const accessToken = this.config.relayCloud.accessToken;
         const endpoint = this.config.relayCloud.endpoint ?? DEFAULT_RELAY_CLOUD_GITHUB_PROXY_ENDPOINT;
@@ -19996,7 +20015,7 @@ var init_cloud_runtime = __esm({
         }
         const payload = {
           method,
-          path: path25,
+          path: path28,
           query: options.query,
           body: options.body,
           headers: options.headers,
@@ -20192,11 +20211,11 @@ function delay3(ms2) {
     setTimeout(resolve4, ms2);
   });
 }
-var import_node_child_process11, import_node_util4, execFileAsync2, GitHubRuntimeDetector, BaseGitHubAdapter, GitHubAdapterFactory, GitHubClientFactory;
+var import_node_child_process12, import_node_util4, execFileAsync2, GitHubRuntimeDetector, BaseGitHubAdapter, GitHubAdapterFactory, GitHubClientFactory;
 var init_adapter = __esm({
   "packages/github-primitive/src/adapter.ts"() {
     "use strict";
-    import_node_child_process11 = require("node:child_process");
+    import_node_child_process12 = require("node:child_process");
     import_node_util4 = require("node:util");
     init_branches();
     init_commits();
@@ -20208,7 +20227,7 @@ var init_adapter = __esm({
     init_utils();
     init_constants();
     init_types();
-    execFileAsync2 = (0, import_node_util4.promisify)(import_node_child_process11.execFile);
+    execFileAsync2 = (0, import_node_util4.promisify)(import_node_child_process12.execFile);
     GitHubRuntimeDetector = class {
       static async detect(config2 = {}) {
         const normalized = normalizeGitHubRuntimeConfig(config2);
@@ -20373,23 +20392,23 @@ var init_adapter = __esm({
         return mergePR(this, owner, repo, pullNumber, options);
       }
       async listFiles(params) {
-        const { owner, repo, path: path25, ...options } = params;
-        return listFiles(this, owner, repo, path25, options);
+        const { owner, repo, path: path28, ...options } = params;
+        return listFiles(this, owner, repo, path28, options);
       }
       async readFile(params) {
         return readFile3(this, params.owner, params.repo, params.path, params.ref);
       }
       async createFile(params) {
-        const { owner, repo, path: path25, content, message, ...options } = params;
-        return createFile(this, owner, repo, path25, content, message, options);
+        const { owner, repo, path: path28, content, message, ...options } = params;
+        return createFile(this, owner, repo, path28, content, message, options);
       }
       async updateFile(params) {
-        const { owner, repo, path: path25, content, message, sha, ...options } = params;
-        return updateFile(this, owner, repo, path25, content, message, sha, options);
+        const { owner, repo, path: path28, content, message, sha, ...options } = params;
+        return updateFile(this, owner, repo, path28, content, message, sha, options);
       }
       async deleteFile(params) {
-        const { owner, repo, path: path25, sha, message, ...options } = params;
-        return deleteFile(this, owner, repo, path25, sha, message, options);
+        const { owner, repo, path: path28, sha, message, ...options } = params;
+        return deleteFile(this, owner, repo, path28, sha, message, options);
       }
       async listBranches(params) {
         return listBranches(this, params.owner, params.repo);
@@ -21148,7 +21167,7 @@ var require_instrument = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.addAppMetadata = addAppMetadata;
     exports2.getUserAgent = getUserAgent;
-    var os12 = __importStar(require("node:os"));
+    var os14 = __importStar(require("node:os"));
     var node_path_1 = require("node:path");
     var packageJson = require_package();
     function replaceSlashes(s3) {
@@ -21162,7 +21181,7 @@ var require_instrument = __commonJS({
       }
       return result;
     }
-    var baseUserAgent = `${replaceSlashes(packageJson.name)}/${packageJson.version} ${toLatin1Safe((0, node_path_1.basename)(process.title))}/${process.version.replace("v", "")} ${os12.platform()}/${os12.release()}`;
+    var baseUserAgent = `${replaceSlashes(packageJson.name)}/${packageJson.version} ${toLatin1Safe((0, node_path_1.basename)(process.title))}/${process.version.replace("v", "")} ${os14.platform()}/${os14.release()}`;
     var appMetadata = {};
     function addAppMetadata({ name, version: version2 }) {
       appMetadata[replaceSlashes(name)] = version2;
@@ -30362,11 +30381,11 @@ var require_mime_types = __commonJS({
       }
       return exts[0];
     }
-    function lookup(path25) {
-      if (!path25 || typeof path25 !== "string") {
+    function lookup(path28) {
+      if (!path28 || typeof path28 !== "string") {
         return false;
       }
-      var extension3 = extname("x." + path25).toLowerCase().substr(1);
+      var extension3 = extname("x." + path28).toLowerCase().substr(1);
       if (!extension3) {
         return false;
       }
@@ -31471,11 +31490,11 @@ var require_form_data = __commonJS({
     "use strict";
     var CombinedStream = require_combined_stream();
     var util2 = require("util");
-    var path25 = require("path");
-    var http = require("http");
+    var path28 = require("path");
+    var http2 = require("http");
     var https3 = require("https");
     var parseUrl = require("url").parse;
-    var fs13 = require("fs");
+    var fs15 = require("fs");
     var Stream = require("stream").Stream;
     var crypto3 = require("crypto");
     var mime = require_mime_types();
@@ -31542,7 +31561,7 @@ var require_form_data = __commonJS({
         if (value.end != void 0 && value.end != Infinity && value.start != void 0) {
           callback(null, value.end + 1 - (value.start ? value.start : 0));
         } else {
-          fs13.stat(value.path, function(err, stat2) {
+          fs15.stat(value.path, function(err, stat2) {
             if (err) {
               callback(err);
               return;
@@ -31599,11 +31618,11 @@ var require_form_data = __commonJS({
     FormData2.prototype._getContentDisposition = function(value, options) {
       var filename;
       if (typeof options.filepath === "string") {
-        filename = path25.normalize(options.filepath).replace(/\\/g, "/");
+        filename = path28.normalize(options.filepath).replace(/\\/g, "/");
       } else if (options.filename || value && (value.name || value.path)) {
-        filename = path25.basename(options.filename || value && (value.name || value.path));
+        filename = path28.basename(options.filename || value && (value.name || value.path));
       } else if (value && value.readable && hasOwn(value, "httpVersion")) {
-        filename = path25.basename(value.client._httpMessage.path || "");
+        filename = path28.basename(value.client._httpMessage.path || "");
       }
       if (filename) {
         return 'filename="' + filename + '"';
@@ -31744,7 +31763,7 @@ var require_form_data = __commonJS({
       if (options.protocol === "https:") {
         request = https3.request(options);
       } else {
-        request = http.request(options);
+        request = http2.request(options);
       }
       this.getLength(function(err, length) {
         if (err && err !== "Unknown stream") {
@@ -32457,7 +32476,7 @@ var require_follow_redirects = __commonJS({
   "node_modules/follow-redirects/index.js"(exports2, module2) {
     var url2 = require("url");
     var URL2 = url2.URL;
-    var http = require("http");
+    var http2 = require("http");
     var https3 = require("https");
     var Writable2 = require("stream").Writable;
     var assert2 = require("assert");
@@ -32958,7 +32977,7 @@ var require_follow_redirects = __commonJS({
     function escapeRegex3(regex4) {
       return regex4.replace(/[\]\\/()*+?.$]/g, "\\$&");
     }
-    module2.exports = wrap({ http, https: https3 });
+    module2.exports = wrap({ http: http2, https: https3 });
     module2.exports.wrap = wrap;
   }
 });
@@ -32970,11 +32989,11 @@ var require_axios = __commonJS({
     var FormData$1 = require_form_data();
     var crypto3 = require("crypto");
     var url2 = require("url");
-    var http = require("http");
+    var http2 = require("http");
     var https3 = require("https");
-    var http2 = require("http2");
+    var http22 = require("http2");
     var util2 = require("util");
-    var path25 = require("path");
+    var path28 = require("path");
     var followRedirects = require_follow_redirects();
     var zlib = require("zlib");
     var stream = require("stream");
@@ -33848,9 +33867,9 @@ var require_axios = __commonJS({
     function removeBrackets(key) {
       return utils$1.endsWith(key, "[]") ? key.slice(0, -2) : key;
     }
-    function renderKey(path26, key, dots) {
-      if (!path26) return key;
-      return path26.concat(key).map(function each(token, i) {
+    function renderKey(path29, key, dots) {
+      if (!path29) return key;
+      return path29.concat(key).map(function each(token, i) {
         token = removeBrackets(token);
         return !dots && i ? "[" + token + "]" : token;
       }).join(dots ? "." : "");
@@ -33899,13 +33918,13 @@ var require_axios = __commonJS({
         }
         return value;
       }
-      function defaultVisitor(value, key, path26) {
+      function defaultVisitor(value, key, path29) {
         let arr = value;
         if (utils$1.isReactNative(formData) && utils$1.isReactNativeBlob(value)) {
-          formData.append(renderKey(path26, key, dots), convertValue(value));
+          formData.append(renderKey(path29, key, dots), convertValue(value));
           return false;
         }
-        if (value && !path26 && typeof value === "object") {
+        if (value && !path29 && typeof value === "object") {
           if (utils$1.endsWith(key, "{}")) {
             key = metaTokens ? key : key.slice(0, -2);
             value = JSON.stringify(value);
@@ -33924,7 +33943,7 @@ var require_axios = __commonJS({
         if (isVisitable(value)) {
           return true;
         }
-        formData.append(renderKey(path26, key, dots), convertValue(value));
+        formData.append(renderKey(path29, key, dots), convertValue(value));
         return false;
       }
       const stack = [];
@@ -33933,19 +33952,19 @@ var require_axios = __commonJS({
         convertValue,
         isVisitable
       });
-      function build(value, path26, depth = 0) {
+      function build(value, path29, depth = 0) {
         if (utils$1.isUndefined(value)) return;
         if (depth > maxDepth) {
           throw new AxiosError("Object is too deeply nested (" + depth + " levels). Max depth: " + maxDepth, AxiosError.ERR_FORM_DATA_DEPTH_EXCEEDED);
         }
         if (stack.indexOf(value) !== -1) {
-          throw Error("Circular reference detected in " + path26.join("."));
+          throw Error("Circular reference detected in " + path29.join("."));
         }
         stack.push(value);
         utils$1.forEach(value, function each(el, key) {
-          const result = !(utils$1.isUndefined(el) || el === null) && visitor.call(formData, el, utils$1.isString(key) ? key.trim() : key, path26, exposedHelpers);
+          const result = !(utils$1.isUndefined(el) || el === null) && visitor.call(formData, el, utils$1.isString(key) ? key.trim() : key, path29, exposedHelpers);
           if (result === true) {
-            build(el, path26 ? path26.concat(key) : [key], depth + 1);
+            build(el, path29 ? path29.concat(key) : [key], depth + 1);
           }
         });
         stack.pop();
@@ -34133,7 +34152,7 @@ var require_axios = __commonJS({
     };
     function toURLEncodedForm(data, options) {
       return toFormData(data, new platform2.classes.URLSearchParams(), {
-        visitor: function(value, key, path26, helpers) {
+        visitor: function(value, key, path29, helpers) {
           if (platform2.isNode && utils$1.isBuffer(value)) {
             this.append(key, value.toString("base64"));
             return false;
@@ -34161,11 +34180,11 @@ var require_axios = __commonJS({
       return obj;
     }
     function formDataToJSON(formData) {
-      function buildPath(path26, value, target, index) {
-        let name = path26[index++];
+      function buildPath(path29, value, target, index) {
+        let name = path29[index++];
         if (name === "__proto__") return true;
         const isNumericKey = Number.isFinite(+name);
-        const isLast = index >= path26.length;
+        const isLast = index >= path29.length;
         name = !name && utils$1.isArray(target) ? target.length : name;
         if (isLast) {
           if (utils$1.hasOwnProp(target, name)) {
@@ -34178,7 +34197,7 @@ var require_axios = __commonJS({
         if (!target[name] || !utils$1.isObject(target[name])) {
           target[name] = [];
         }
-        const result = buildPath(path26, value, target[name], index);
+        const result = buildPath(path29, value, target[name], index);
         if (result && utils$1.isArray(target[name])) {
           target[name] = arrayToObject(target[name]);
         }
@@ -35042,7 +35061,7 @@ var require_axios = __commonJS({
             }
           }
         }
-        const session = http2.connect(authority, options);
+        const session = http22.connect(authority, options);
         let removed;
         const removeSession = () => {
           if (removed) {
@@ -35219,7 +35238,7 @@ var require_axios = __commonJS({
           HTTP2_HEADER_METHOD,
           HTTP2_HEADER_PATH,
           HTTP2_HEADER_STATUS
-        } = http2.constants;
+        } = http22.constants;
         const http2Headers = {
           [HTTP2_HEADER_SCHEME]: options.protocol.replace(":", ""),
           [HTTP2_HEADER_METHOD]: options.method,
@@ -35490,8 +35509,8 @@ var require_axios = __commonJS({
           }
           if (config2.allowedSocketPaths != null) {
             const allowed = Array.isArray(config2.allowedSocketPaths) ? config2.allowedSocketPaths : [config2.allowedSocketPaths];
-            const resolvedSocket = path25.resolve(config2.socketPath);
-            const isAllowed = allowed.some((entry) => typeof entry === "string" && path25.resolve(entry) === resolvedSocket);
+            const resolvedSocket = path28.resolve(config2.socketPath);
+            const isAllowed = allowed.some((entry) => typeof entry === "string" && path28.resolve(entry) === resolvedSocket);
             if (!isAllowed) {
               return reject(new AxiosError(`socketPath "${config2.socketPath}" is not permitted by allowedSocketPaths`, AxiosError.ERR_BAD_OPTION_VALUE, config2));
             }
@@ -35513,7 +35532,7 @@ var require_axios = __commonJS({
           if (configTransport) {
             transport = configTransport;
           } else if (config2.maxRedirects === 0) {
-            transport = isHttpsRequest ? https3 : http;
+            transport = isHttpsRequest ? https3 : http2;
             isNativeTransport = true;
           } else {
             if (config2.maxRedirects) {
@@ -35743,14 +35762,14 @@ var require_axios = __commonJS({
     var cookies = platform2.hasStandardBrowserEnv ? (
       // Standard browser envs support document.cookie
       {
-        write(name, value, expires, path26, domain2, secure, sameSite) {
+        write(name, value, expires, path29, domain2, secure, sameSite) {
           if (typeof document === "undefined") return;
           const cookie = [`${name}=${encodeURIComponent(value)}`];
           if (utils$1.isNumber(expires)) {
             cookie.push(`expires=${new Date(expires).toUTCString()}`);
           }
-          if (utils$1.isString(path26)) {
-            cookie.push(`path=${path26}`);
+          if (utils$1.isString(path29)) {
+            cookie.push(`path=${path29}`);
           }
           if (utils$1.isString(domain2)) {
             cookie.push(`domain=${domain2}`);
@@ -41989,8 +42008,8 @@ var init_supermemory = __esm({
       /**
        * Make a fetch request to the Supermemory API
        */
-      async fetch(path25, options) {
-        const url2 = `${this.endpoint}${path25}`;
+      async fetch(path28, options) {
+        const url2 = `${this.endpoint}${path28}`;
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
@@ -43050,6 +43069,7 @@ __export(index_exports, {
   isWorktreeStep: () => isWorktreeStep,
   listLoggedAgents: () => listLoggedAgents,
   listPersonas: () => listPersonas,
+  listWorkflowSchedules: () => listWorkflowSchedules,
   loadCustomSteps: () => loadCustomSteps,
   loadPersona: () => loadPersona,
   logAndTraceError: () => logAndTraceError,
@@ -43083,6 +43103,7 @@ __export(index_exports, {
   runScriptWorkflow: () => runScriptWorkflow,
   runVerification: () => runVerification,
   runWorkflow: () => runWorkflow,
+  scheduleWorkflow: () => scheduleWorkflow,
   scrubForChannel: () => scrubForChannel,
   scrubSecrets: () => scrubSecrets,
   sendToChannel: () => sendToChannel,
@@ -43157,7 +43178,7 @@ var BrokerTransport = class {
     return this.baseUrl.replace(/^http/, "ws") + "/ws";
   }
   // ── HTTP ─────────────────────────────────────────────────────────────
-  async request(path25, init) {
+  async request(path28, init) {
     const headers = new Headers(init?.headers);
     if (!headers.has("Content-Type")) {
       headers.set("Content-Type", "application/json");
@@ -43166,7 +43187,7 @@ var BrokerTransport = class {
       headers.set("X-API-Key", this.apiKey);
     }
     const signal = init?.signal ?? AbortSignal.timeout(this.requestTimeoutMs);
-    const res = await fetch(`${this.baseUrl}${path25}`, { ...init, headers, signal });
+    const res = await fetch(`${this.baseUrl}${path28}`, { ...init, headers, signal });
     if (!res.ok) {
       let body;
       try {
@@ -43632,6 +43653,7 @@ var AgentRelayClient = class _AgentRelayClient {
       stdoutLines,
       stderrLines
     });
+    drainBrokerStdioAfterStartup(child);
     const client = new _AgentRelayClient({
       baseUrl,
       apiKey,
@@ -43930,6 +43952,15 @@ async function waitForApiUrl(child, timeoutMs, debug) {
     });
   });
 }
+function drainBrokerStdioAfterStartup(child) {
+  for (const stream of [child.stdout, child.stderr]) {
+    if (!stream)
+      continue;
+    stream.on("data", () => {
+    });
+    stream.resume();
+  }
+}
 function pushBufferedLine(lines, line) {
   lines.push(line);
   if (lines.length > 40) {
@@ -44494,8 +44525,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path25, errorMaps, issueData } = params;
-  const fullPath = [...path25, ...issueData.path || []];
+  const { data, path: path28, errorMaps, issueData } = params;
+  const fullPath = [...path28, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -44611,11 +44642,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path25, key) {
+  constructor(parent, value, path28, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path25;
+    this._path = path28;
     this._key = key;
   }
   get path() {
@@ -51121,10 +51152,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path25) {
-  if (!path25)
+function getElementAtPath(obj, path28) {
+  if (!path28)
     return obj;
-  return path25.reduce((acc, key) => acc?.[key], obj);
+  return path28.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -51533,11 +51564,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path25, issues) {
+function prefixIssues(path28, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path25);
+    iss.path.unshift(path28);
     return iss;
   });
 }
@@ -51684,16 +51715,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path25 = []) => {
+  const processError = (error52, path28 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path28, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path28, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -51720,17 +51751,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path25 = []) => {
+  const processError = (error52, path28 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path25, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path28, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path25, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path28, ...issue2.path]);
       } else {
-        const fullpath = [...path25, ...issue2.path];
+        const fullpath = [...path28, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -51762,8 +51793,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path25) {
+  const path28 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path28) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -64455,13 +64486,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path25 = ref.slice(1).split("/").filter(Boolean);
-  if (path25.length === 0) {
+  const path28 = ref.slice(1).split("/").filter(Boolean);
+  if (path28.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path25[0] === defsKey) {
-    const key = path25[1];
+  if (path28[0] === defsKey) {
+    const key = path28[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -66624,8 +66655,8 @@ var HttpClient = class _HttpClient {
       version: this._originVersion
     }));
   }
-  async request(method, path25, body, query, options) {
-    const url2 = new URL(path25, this._baseUrl);
+  async request(method, path28, body, query, options) {
+    const url2 = new URL(path28, this._baseUrl);
     if (query) {
       for (const [k2, v2] of Object.entries(query)) {
         if (v2 !== void 0)
@@ -66695,20 +66726,20 @@ var HttpClient = class _HttpClient {
       return camelizeKeys(parsedData);
     }
   }
-  get(path25, query, options) {
-    return this.request("GET", path25, void 0, query, options);
+  get(path28, query, options) {
+    return this.request("GET", path28, void 0, query, options);
   }
-  post(path25, body, options) {
-    return this.request("POST", path25, body, void 0, options);
+  post(path28, body, options) {
+    return this.request("POST", path28, body, void 0, options);
   }
-  patch(path25, body, options) {
-    return this.request("PATCH", path25, body, void 0, options);
+  patch(path28, body, options) {
+    return this.request("PATCH", path28, body, void 0, options);
   }
-  put(path25, body, options) {
-    return this.request("PUT", path25, body, void 0, options);
+  put(path28, body, options) {
+    return this.request("PUT", path28, body, void 0, options);
   }
-  async delete(path25, options) {
-    await this.request("DELETE", path25, void 0, void 0, options);
+  async delete(path28, options) {
+    await this.request("DELETE", path28, void 0, void 0, options);
   }
 };
 
@@ -68760,15 +68791,15 @@ function listPersonas(options = {}) {
     for (const file2 of entries) {
       if (!file2.endsWith(".json"))
         continue;
-      const path25 = (0, import_node_path5.join)(dir, file2);
+      const path28 = (0, import_node_path5.join)(dir, file2);
       let spec;
       try {
-        spec = parsePersonaFile(JSON.parse((0, import_node_fs3.readFileSync)(path25, "utf8")), path25);
+        spec = parsePersonaFile(JSON.parse((0, import_node_fs3.readFileSync)(path28, "utf8")), path28);
       } catch {
         continue;
       }
       if (!byId.has(spec.id)) {
-        byId.set(spec.id, { id: spec.id, path: path25, spec });
+        byId.set(spec.id, { id: spec.id, path: path28, spec });
       }
     }
   }
@@ -68801,11 +68832,11 @@ function findPersona(id, options = {}) {
     for (const file2 of entries) {
       if (!file2.endsWith(".json"))
         continue;
-      const path25 = (0, import_node_path5.join)(dir, file2);
+      const path28 = (0, import_node_path5.join)(dir, file2);
       try {
-        const spec = parsePersonaFile(JSON.parse((0, import_node_fs3.readFileSync)(path25, "utf8")), path25);
+        const spec = parsePersonaFile(JSON.parse((0, import_node_fs3.readFileSync)(path28, "utf8")), path28);
         if (spec.id === id)
-          return { id, path: path25, spec };
+          return { id, path: path28, spec };
       } catch {
         continue;
       }
@@ -71688,9 +71719,9 @@ async function resolveCli(cli) {
   for (const binary of def.binaries) {
     try {
       const { stdout } = await execFileAsync("which", [binary]);
-      const path25 = stdout.trim();
-      if (path25) {
-        const result = { binary, path: path25 };
+      const path28 = stdout.trim();
+      if (path28) {
+        const result = { binary, path: path28 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -71727,9 +71758,9 @@ function resolveCliSync(cli) {
   for (const binary of def.binaries) {
     try {
       const stdout = execFileSync3("which", [binary], { stdio: ["pipe", "pipe", "ignore"] });
-      const path25 = stdout.toString().trim();
-      if (path25) {
-        const result = { binary, path: path25 };
+      const path28 = stdout.toString().trim();
+      if (path28) {
+        const result = { binary, path: path28 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -73061,10 +73092,10 @@ var RelayFileClient = class {
       signal: options.signal
     });
   }
-  async readFile(workspaceOrInput, path25, correlationId, signal) {
+  async readFile(workspaceOrInput, path28, correlationId, signal) {
     const input = typeof workspaceOrInput === "string" ? {
       workspaceId: workspaceOrInput,
-      path: path25 ?? "",
+      path: path28 ?? "",
       correlationId,
       signal
     } : workspaceOrInput;
@@ -73111,8 +73142,8 @@ var RelayFileClient = class {
     });
   }
   async writeFile(input) {
-    const { workspaceId, path: path25, correlationId, baseRevision, content, contentType, encoding, contentIdentity, signal } = input;
-    const query = buildQuery({ path: path25, forkId: input.forkId });
+    const { workspaceId, path: path28, correlationId, baseRevision, content, contentType, encoding, contentIdentity, signal } = input;
+    const query = buildQuery({ path: path28, forkId: input.forkId });
     return this.request({
       method: "PUT",
       path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/fs/file${query}`,
@@ -80006,11 +80037,11 @@ function extractDecisions(trajectory2) {
   }
   return decisions;
 }
-function expandPath(path25) {
-  if (path25.startsWith("~")) {
-    return (0, import_path4.join)(process.env.HOME ?? "", path25.slice(1));
+function expandPath(path28) {
+  if (path28.startsWith("~")) {
+    return (0, import_path4.join)(process.env.HOME ?? "", path28.slice(1));
   }
-  return path25;
+  return path28;
 }
 function describeReadFailure(reason, error51) {
   if (reason === "schema_violation" && error51 && typeof error51 === "object" && "issues" in error51) {
@@ -80027,11 +80058,11 @@ function describeReadFailure(reason, error51) {
   return String(error51);
 }
 var indexLocks = /* @__PURE__ */ new Map();
-function withIndexLock(path25, task) {
-  const prev = indexLocks.get(path25) ?? Promise.resolve();
+function withIndexLock(path28, task) {
+  const prev = indexLocks.get(path28) ?? Promise.resolve();
   const next = prev.then(task, task);
   indexLocks.set(
-    path25,
+    path28,
     next.catch(() => void 0)
   );
   return next;
@@ -80260,8 +80291,8 @@ var FileStorage = class {
     const validation = validateTrajectory(input);
     if (!validation.success) {
       const issues = validation.errors?.issues.map((issue2) => {
-        const path25 = issue2.path.length > 0 ? issue2.path.join(".") : "root";
-        return `${path25}: ${issue2.message}`;
+        const path28 = issue2.path.length > 0 ? issue2.path.join(".") : "root";
+        return `${path28}: ${issue2.message}`;
       }).join("; ") ?? "unknown validation error";
       throw new Error(`Cannot save invalid trajectory: ${issues}`);
     }
@@ -80470,18 +80501,18 @@ var FileStorage = class {
    *
    * Does NOT log. Callers choose whether to warn, swallow, or throw.
    */
-  async readTrajectoryFile(path25) {
+  async readTrajectoryFile(path28) {
     let content;
     try {
-      content = await (0, import_promises7.readFile)(path25, "utf-8");
+      content = await (0, import_promises7.readFile)(path28, "utf-8");
     } catch (error51) {
-      return { ok: false, reason: "io_error", path: path25, error: error51 };
+      return { ok: false, reason: "io_error", path: path28, error: error51 };
     }
     let data;
     try {
       data = JSON.parse(content);
     } catch (error51) {
-      return { ok: false, reason: "malformed_json", path: path25, error: error51 };
+      return { ok: false, reason: "malformed_json", path: path28, error: error51 };
     }
     const validation = validateTrajectory(data);
     if (validation.success) {
@@ -80490,7 +80521,7 @@ var FileStorage = class {
     return {
       ok: false,
       reason: "schema_violation",
-      path: path25,
+      path: path28,
       error: validation.errors
     };
   }
@@ -80499,8 +80530,8 @@ var FileStorage = class {
    * trajectory. Returns null for any failure and writes nothing to the
    * console — so nothing leaks into test output or the CLI spinner.
    */
-  async readTrajectoryOrNull(path25) {
-    const result = await this.readTrajectoryFile(path25);
+  async readTrajectoryOrNull(path28) {
+    const result = await this.readTrajectoryFile(path28);
     return result.ok ? result.trajectory : null;
   }
   /**
@@ -87033,8 +87064,531 @@ async function runWorkflow(yamlPath, options = {}) {
   return runner.execute(config2, options.workflow, options.vars, executeOptions);
 }
 
-// packages/sdk/dist/workflows/builder.js
+// packages/cloud/src/auth.ts
+var import_promises9 = __toESM(require("node:fs/promises"), 1);
+var import_node_http = __toESM(require("node:http"), 1);
+var import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_path32 = __toESM(require("node:path"), 1);
+var import_node_child_process9 = require("node:child_process");
+
+// packages/cloud/src/types.ts
+var import_node_os11 = __toESM(require("node:os"), 1);
 var import_node_path31 = __toESM(require("node:path"), 1);
+var REFRESH_WINDOW_MS = 6e4;
+var AUTH_FILE_PATH = import_node_path31.default.join(import_node_os11.default.homedir(), ".agent-relay", "cloud-auth.json");
+function defaultApiUrl() {
+  return process.env.CLOUD_API_URL?.trim() || "https://agentrelay.com/cloud";
+}
+
+// packages/cloud/src/api-client.ts
+function trimLeadingSlash(p2) {
+  return p2.replace(/^\/+/, "");
+}
+function withTrailingSlash(p2) {
+  return p2.endsWith("/") ? p2 : `${p2}/`;
+}
+function buildApiUrl(apiUrl, p2) {
+  return new URL(trimLeadingSlash(p2), withTrailingSlash(apiUrl));
+}
+
+// packages/cloud/src/auth.ts
+var envBackedAuth = /* @__PURE__ */ new WeakSet();
+function markEnvBackedAuth(auth) {
+  envBackedAuth.add(auth);
+  return auth;
+}
+function isEnvBackedAuth(auth) {
+  return envBackedAuth.has(auth);
+}
+function readEnvAuth(env = process.env) {
+  const apiUrl = env.CLOUD_API_URL?.trim();
+  const accessToken = env.CLOUD_API_ACCESS_TOKEN?.trim();
+  const refreshToken = env.CLOUD_API_REFRESH_TOKEN?.trim();
+  const accessTokenExpiresAt = env.CLOUD_API_ACCESS_TOKEN_EXPIRES_AT?.trim();
+  if (!apiUrl || !accessToken || !refreshToken || !accessTokenExpiresAt) {
+    return null;
+  }
+  try {
+    new URL(apiUrl);
+  } catch {
+    return null;
+  }
+  if (Number.isNaN(Date.parse(accessTokenExpiresAt))) {
+    return null;
+  }
+  return markEnvBackedAuth({
+    apiUrl,
+    accessToken,
+    refreshToken,
+    accessTokenExpiresAt
+  });
+}
+function toEnvAuthRefreshError(error51) {
+  const message = error51 instanceof Error && error51.message ? `${error51.message}. ` : "";
+  return new Error(
+    `${message}Env-backed cloud auth could not be refreshed interactively; re-provision CLOUD_API_URL, CLOUD_API_ACCESS_TOKEN, CLOUD_API_REFRESH_TOKEN, and CLOUD_API_ACCESS_TOKEN_EXPIRES_AT.`,
+    error51 instanceof Error ? { cause: error51 } : void 0
+  );
+}
+function isValidStoredAuth(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const auth = value;
+  return typeof auth.accessToken === "string" && typeof auth.refreshToken === "string" && typeof auth.accessTokenExpiresAt === "string" && typeof auth.apiUrl === "string";
+}
+async function readStoredAuth(env = process.env) {
+  const envAuth = readEnvAuth(env);
+  if (envAuth) {
+    return envAuth;
+  }
+  try {
+    const file2 = await import_promises9.default.readFile(AUTH_FILE_PATH, "utf8");
+    const parsed = JSON.parse(file2);
+    return isValidStoredAuth(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function writeStoredAuth(auth) {
+  await import_promises9.default.mkdir(import_node_path32.default.dirname(AUTH_FILE_PATH), {
+    recursive: true,
+    mode: 448
+  });
+  await import_promises9.default.writeFile(AUTH_FILE_PATH, `${JSON.stringify(auth, null, 2)}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+}
+function shouldRefresh(accessTokenExpiresAt) {
+  const expiresAt = Date.parse(accessTokenExpiresAt);
+  if (Number.isNaN(expiresAt)) {
+    return true;
+  }
+  return expiresAt - Date.now() <= REFRESH_WINDOW_MS;
+}
+function openBrowser(url2) {
+  const platform2 = import_node_os12.default.platform();
+  if (platform2 === "darwin") {
+    return (0, import_node_child_process9.spawn)("open", [url2], { stdio: "ignore", detached: true });
+  }
+  if (platform2 === "win32") {
+    return (0, import_node_child_process9.spawn)("cmd", ["/c", "start", "", url2], { stdio: "ignore", detached: true });
+  }
+  return (0, import_node_child_process9.spawn)("xdg-open", [url2], { stdio: "ignore", detached: true });
+}
+function redirectToHostedCliAuthPage(response, apiUrl, options) {
+  const resultUrl = buildApiUrl(apiUrl, "/cli/auth-result");
+  resultUrl.searchParams.set("status", options.status);
+  if (options.detail) {
+    resultUrl.searchParams.set("detail", options.detail);
+  }
+  response.statusCode = 302;
+  response.setHeader("location", resultUrl.toString());
+  response.end();
+}
+async function beginBrowserLogin(apiUrl) {
+  const state = crypto.randomUUID();
+  return new Promise((resolve4, reject) => {
+    let settled = false;
+    const server = import_node_http.default.createServer((request, response) => {
+      const requestUrl = new URL(request.url || "/", "http://127.0.0.1");
+      if (requestUrl.pathname !== "/callback") {
+        response.statusCode = 404;
+        response.end("Not found");
+        return;
+      }
+      const returnedState = requestUrl.searchParams.get("state");
+      if (returnedState !== state) {
+        redirectToHostedCliAuthPage(response, apiUrl, {
+          status: "error",
+          detail: "Invalid state parameter"
+        });
+        if (!settled) {
+          settled = true;
+          server.close();
+          reject(new Error("Invalid state parameter in CLI login callback"));
+        }
+        return;
+      }
+      const error51 = requestUrl.searchParams.get("error");
+      if (error51) {
+        redirectToHostedCliAuthPage(response, apiUrl, {
+          status: "error",
+          detail: error51
+        });
+        if (!settled) {
+          settled = true;
+          server.close();
+          reject(new Error(error51));
+        }
+        return;
+      }
+      const accessToken = requestUrl.searchParams.get("access_token");
+      const refreshToken = requestUrl.searchParams.get("refresh_token");
+      const accessTokenExpiresAt = requestUrl.searchParams.get("access_token_expires_at");
+      const returnedApiUrl = requestUrl.searchParams.get("api_url");
+      if (!accessToken || !refreshToken || !accessTokenExpiresAt || !returnedApiUrl) {
+        redirectToHostedCliAuthPage(response, apiUrl, {
+          status: "error",
+          detail: "Expected access token, refresh token, API URL, and expiration timestamp."
+        });
+        if (!settled) {
+          settled = true;
+          server.close();
+          reject(new Error("CLI login callback was missing required fields"));
+        }
+        return;
+      }
+      redirectToHostedCliAuthPage(response, returnedApiUrl, {
+        status: "success",
+        detail: `API endpoint: ${returnedApiUrl}`
+      });
+      if (!settled) {
+        settled = true;
+        server.close();
+        resolve4({
+          accessToken,
+          refreshToken,
+          accessTokenExpiresAt,
+          apiUrl: returnedApiUrl
+        });
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        if (!settled) {
+          settled = true;
+          server.close();
+          reject(new Error("Failed to start local callback server"));
+        }
+        return;
+      }
+      const callbackUrl = new URL("/callback", `http://127.0.0.1:${address.port}`);
+      const loginUrl = buildApiUrl(apiUrl, "/api/v1/cli/login");
+      loginUrl.searchParams.set("redirect_uri", callbackUrl.toString());
+      loginUrl.searchParams.set("state", state);
+      console.log(`Opening browser for cloud login: ${loginUrl.toString()}`);
+      console.log("If the browser does not open, paste this URL into your browser.");
+      try {
+        const child = openBrowser(loginUrl.toString());
+        child.unref();
+      } catch {
+      }
+    });
+    server.on("error", (error51) => {
+      if (!settled) {
+        settled = true;
+        reject(error51);
+      }
+    });
+    setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        server.close();
+        reject(new Error("Timed out waiting for browser login"));
+      }
+    }, 5 * 6e4).unref();
+  });
+}
+async function refreshStoredAuth(auth) {
+  const response = await fetch(buildApiUrl(auth.apiUrl, "/api/v1/auth/token/refresh"), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ refreshToken: auth.refreshToken })
+  });
+  const payload = await response.json().catch(() => null);
+  if (!response.ok || !payload?.accessToken || !payload?.refreshToken || !payload?.accessTokenExpiresAt) {
+    throw new Error("Stored cloud login has expired");
+  }
+  const nextAuth = {
+    apiUrl: auth.apiUrl,
+    accessToken: payload.accessToken,
+    refreshToken: payload.refreshToken,
+    accessTokenExpiresAt: payload.accessTokenExpiresAt
+  };
+  if (isEnvBackedAuth(auth)) {
+    return markEnvBackedAuth(nextAuth);
+  }
+  await writeStoredAuth(nextAuth);
+  return nextAuth;
+}
+async function loginWithBrowser(apiUrl) {
+  const auth = await beginBrowserLogin(apiUrl);
+  await writeStoredAuth(auth);
+  console.log(`Logged in to ${auth.apiUrl}`);
+  return auth;
+}
+async function ensureAuthenticated(apiUrl, options) {
+  const force = options?.force === true;
+  const stored = !force ? await readStoredAuth() : null;
+  if (!stored) {
+    return loginWithBrowser(apiUrl);
+  }
+  if (!shouldRefresh(stored.accessTokenExpiresAt)) {
+    return stored;
+  }
+  try {
+    return await refreshStoredAuth(stored);
+  } catch (error51) {
+    if (isEnvBackedAuth(stored)) {
+      throw toEnvAuthRefreshError(error51);
+    }
+    return loginWithBrowser(stored.apiUrl);
+  }
+}
+function apiFetch(apiUrl, accessToken, requestPath, init) {
+  return fetch(buildApiUrl(apiUrl, requestPath), {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${accessToken}`,
+      ...init.headers ?? {}
+    }
+  });
+}
+async function authorizedApiFetch(auth, requestPath, init) {
+  let activeAuth = auth;
+  let response = await apiFetch(activeAuth.apiUrl, activeAuth.accessToken, requestPath, init);
+  if (response.status !== 401) {
+    return { response, auth: activeAuth };
+  }
+  try {
+    activeAuth = await refreshStoredAuth(activeAuth);
+  } catch (error51) {
+    if (isEnvBackedAuth(activeAuth)) {
+      throw toEnvAuthRefreshError(error51);
+    }
+    activeAuth = await loginWithBrowser(activeAuth.apiUrl);
+  }
+  response = await apiFetch(activeAuth.apiUrl, activeAuth.accessToken, requestPath, init);
+  return { response, auth: activeAuth };
+}
+
+// packages/cloud/src/workflows.ts
+var import_promises10 = __toESM(require("node:fs/promises"), 1);
+var import_node_path33 = __toESM(require("node:path"), 1);
+var import_ignore3 = __toESM(require_ignore(), 1);
+function validateYamlWorkflow(content) {
+  const hasField = (field) => new RegExp(`^${field}\\s*:`, "m").test(content);
+  if (!hasField("version")) {
+    throw new Error('missing required field "version"');
+  }
+  if (!hasField("swarm")) {
+    throw new Error('missing required field "swarm"');
+  }
+  if (!hasField("agents")) {
+    throw new Error('missing required field "agents"');
+  }
+  if (!hasField("workflows")) {
+    throw new Error('missing required field "workflows"');
+  }
+}
+async function validateTypeScriptWorkflow(content) {
+  const Bun = globalThis.Bun;
+  if (typeof Bun !== "undefined") {
+    try {
+      const result = await Bun.build({
+        stdin: { contents: content, loader: "ts" },
+        throw: false
+      });
+      if (!result.success && result.logs?.length) {
+        const errors = result.logs.filter((l) => l.level === "error").map((l) => l.message).join("\n");
+        if (errors) {
+          throw new Error(`Workflow file has syntax errors:
+${errors}`);
+        }
+      }
+      return;
+    } catch (error51) {
+      if (error51 instanceof Error && error51.message.startsWith("Workflow file has syntax errors")) {
+        throw error51;
+      }
+      return;
+    }
+  }
+  try {
+    const { execSync: execSync6 } = await import("node:child_process");
+    execSync6("npx --yes esbuild --loader=ts", {
+      input: content,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3e4
+    });
+  } catch (error51) {
+    const err = error51;
+    const stderr = typeof err.stderr === "string" ? err.stderr.trim() : "";
+    if (err.killed || !err.status || err.status === 127 || /command not found|not found/i.test(stderr)) {
+      return;
+    }
+    const message = stderr || "TypeScript validation failed";
+    throw new Error(`Workflow file has syntax errors:
+${message}`);
+  }
+}
+function inferWorkflowFileType(filePath) {
+  const ext = import_node_path33.default.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".yaml":
+    case ".yml":
+      return "yaml";
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "ts";
+    case ".py":
+      return "py";
+    default:
+      return null;
+  }
+}
+async function resolveWorkflowInput(workflowArg, explicitFileType) {
+  const looksLikeFile = import_node_path33.default.isAbsolute(workflowArg) || workflowArg.includes(import_node_path33.default.sep) || inferWorkflowFileType(workflowArg) !== null;
+  try {
+    const workflow2 = await import_promises10.default.readFile(workflowArg, "utf-8");
+    const fileType = explicitFileType ?? inferWorkflowFileType(workflowArg);
+    if (!fileType) {
+      throw new Error(`Could not infer workflow type from ${workflowArg}. Use --file-type.`);
+    }
+    return { workflow: workflow2, fileType };
+  } catch (error51) {
+    const err = error51;
+    if (err.code === "EISDIR") {
+      throw new Error(`Workflow path is not a file: ${workflowArg}`);
+    }
+    if (!isMissingFileError(error51)) {
+      throw error51;
+    }
+  }
+  if (looksLikeFile) {
+    throw new Error(`Workflow file not found: ${workflowArg}`);
+  }
+  return {
+    workflow: workflowArg,
+    fileType: explicitFileType ?? "yaml"
+  };
+}
+async function scheduleWorkflow(workflowArg, options = {}) {
+  const hasCron = typeof options.cron === "string" && options.cron.trim().length > 0;
+  const hasAt = typeof options.at === "string" && options.at.trim().length > 0;
+  if (hasCron === hasAt) {
+    throw new Error("Provide exactly one of --cron or --at.");
+  }
+  const apiUrl = options.apiUrl ?? defaultApiUrl();
+  const auth = await ensureAuthenticated(apiUrl);
+  const input = await resolveWorkflowInput(workflowArg, options.fileType);
+  if (input.fileType === "ts") {
+    await validateTypeScriptWorkflow(input.workflow);
+  } else if (input.fileType === "yaml") {
+    console.error("Validating workflow...");
+    validateYamlWorkflow(input.workflow);
+  }
+  const requestBody = {
+    name: options.name?.trim() || import_node_path33.default.basename(workflowArg),
+    schedule_type: hasCron ? "cron" : "once",
+    timezone: options.timezone?.trim() || "UTC",
+    workflowRequest: {
+      workflow: input.workflow,
+      fileType: input.fileType,
+      ...input.sourceFileType ? { sourceFileType: input.sourceFileType } : {}
+    }
+  };
+  if (options.description?.trim()) {
+    requestBody.description = options.description.trim();
+  }
+  if (hasCron) {
+    requestBody.cron_expression = options.cron?.trim();
+  } else {
+    const scheduledAt = new Date(String(options.at));
+    if (Number.isNaN(scheduledAt.getTime())) {
+      throw new Error(`Invalid date for --at: ${options.at}`);
+    }
+    requestBody.scheduled_at = scheduledAt.toISOString();
+  }
+  const { response } = await authorizedApiFetch(auth, "/api/v1/workflows/schedules", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const payload = await readJsonResponse(response);
+  if (!response.ok) {
+    throw new Error(`Workflow schedule failed: ${describeResponseError(response, payload)}`);
+  }
+  if (!isWorkflowScheduleEnvelope(payload)) {
+    throw new Error("Workflow schedule response was not valid JSON.");
+  }
+  return payload.schedule;
+}
+async function listWorkflowSchedules(options = {}) {
+  const apiUrl = options.apiUrl ?? defaultApiUrl();
+  const auth = await ensureAuthenticated(apiUrl);
+  const { response } = await authorizedApiFetch(auth, "/api/v1/workflows/schedules", {
+    headers: { Accept: "application/json" }
+  });
+  const payload = await readJsonResponse(response);
+  if (!response.ok) {
+    throw new Error(`Schedule list failed: ${describeResponseError(response, payload)}`);
+  }
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("Schedule list response was not valid JSON.");
+  }
+  const schedules = payload.schedules;
+  if (!Array.isArray(schedules)) {
+    throw new Error("Schedule list response was not valid JSON.");
+  }
+  return schedules.filter(isWorkflowSchedule);
+}
+async function readJsonResponse(response) {
+  const rawBody = await response.text();
+  if (!rawBody) {
+    return null;
+  }
+  try {
+    return JSON.parse(rawBody);
+  } catch {
+    return rawBody;
+  }
+}
+function describeResponseError(response, payload) {
+  if (typeof payload === "string" && payload.trim()) {
+    return `${response.status} ${response.statusText}: ${payload.trim()}`;
+  }
+  if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+    const record2 = payload;
+    const message = record2.error ?? record2.message;
+    if (typeof message === "string" && message.trim()) {
+      return `${response.status} ${response.statusText}: ${message.trim()}`;
+    }
+  }
+  return `${response.status} ${response.statusText}`;
+}
+function isWorkflowScheduleEnvelope(payload) {
+  return Boolean(payload) && typeof payload === "object" && !Array.isArray(payload) && isWorkflowSchedule(payload.schedule);
+}
+function isWorkflowSchedule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const record2 = value;
+  const hasNullableString = (field) => record2[field] === null || typeof record2[field] === "string";
+  return typeof record2.id === "string" && typeof record2.relaycronScheduleId === "string" && typeof record2.userId === "string" && typeof record2.workspaceId === "string" && typeof record2.organizationId === "string" && typeof record2.name === "string" && hasNullableString("description") && (record2.scheduleType === "once" || record2.scheduleType === "cron") && hasNullableString("cronExpression") && hasNullableString("scheduledAt") && typeof record2.timezone === "string" && typeof record2.status === "string" && hasNullableString("lastTriggeredRunId") && hasNullableString("lastTriggeredAt") && typeof record2.createdAt === "string" && typeof record2.updatedAt === "string";
+}
+function isMissingFileError(error51) {
+  return Boolean(error51 && typeof error51 === "object" && "code" in error51 && error51.code === "ENOENT");
+}
+
+// packages/cloud/src/lib/ssh-interactive.ts
+var DEBUG = process.env.AGENT_RELAY_DEBUG_SSH === "1";
+
+// packages/sdk/dist/workflows/builder.js
+var import_node_path34 = __toESM(require("node:path"), 1);
 var import_yaml3 = __toESM(require_dist(), 1);
 
 // packages/sdk/dist/workflows/cloud-runner.js
@@ -87393,7 +87947,7 @@ var WorkflowBuilder = class {
   async run(options = {}) {
     const config2 = this.toConfig();
     const runnerCwd = options.cwd ?? process.cwd();
-    const dbPath = import_node_path31.default.join(runnerCwd, ".agent-relay", "workflow-runs.jsonl");
+    const dbPath = import_node_path34.default.join(runnerCwd, ".agent-relay", "workflow-runs.jsonl");
     const db = new JsonFileWorkflowDb(dbPath);
     const runner = new WorkflowRunner({
       cwd: options.cwd,
@@ -88311,7 +88865,7 @@ var StateStore = class extends import_node_events5.EventEmitter {
 
 // packages/sdk/dist/workflows/templates.js
 var import_node_fs23 = require("node:fs");
-var import_node_path32 = __toESM(require("node:path"), 1);
+var import_node_path35 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
 var YAML_EXTENSIONS = [".yaml", ".yml"];
@@ -88336,7 +88890,7 @@ var TemplateRegistry = class {
   fetcher;
   constructor(options = {}) {
     this.builtInTemplatesDir = this.resolveBuiltInTemplatesDir(options.builtInTemplatesDir);
-    this.customTemplatesDir = options.customTemplatesDir ? import_node_path32.default.resolve(options.customTemplatesDir) : import_node_path32.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
+    this.customTemplatesDir = options.customTemplatesDir ? import_node_path35.default.resolve(options.customTemplatesDir) : import_node_path35.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
     this.fetcher = options.fetcher ?? fetch;
   }
   listBuiltInTemplates() {
@@ -88410,12 +88964,12 @@ var TemplateRegistry = class {
     if (!templateName) {
       throw new Error('Template name is required. Provide name explicitly or include a string "name" field.');
     }
-    if (templateName.includes("/") || templateName.includes("\\") || templateName.includes("..") || import_node_path32.default.isAbsolute(templateName)) {
+    if (templateName.includes("/") || templateName.includes("\\") || templateName.includes("..") || import_node_path35.default.isAbsolute(templateName)) {
       throw new Error(`Invalid template name: "${templateName}" contains path separators or traversal sequences`);
     }
     this.validateRelayConfig(parsed, url2);
     await import_node_fs23.promises.mkdir(this.customTemplatesDir, { recursive: true });
-    const targetPath = import_node_path32.default.join(this.customTemplatesDir, `${templateName}.yaml`);
+    const targetPath = import_node_path35.default.join(this.customTemplatesDir, `${templateName}.yaml`);
     await import_node_fs23.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
     return targetPath;
   }
@@ -88437,12 +88991,12 @@ var TemplateRegistry = class {
   }
   resolveBuiltInTemplatesDir(explicitDir) {
     if (explicitDir) {
-      return import_node_path32.default.resolve(explicitDir);
+      return import_node_path35.default.resolve(explicitDir);
     }
-    const currentDir = import_node_path32.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
+    const currentDir = import_node_path35.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
     const candidates = [
-      import_node_path32.default.resolve(currentDir, "builtin-templates"),
-      import_node_path32.default.resolve(currentDir, "../workflows/builtin-templates")
+      import_node_path35.default.resolve(currentDir, "builtin-templates"),
+      import_node_path35.default.resolve(currentDir, "../workflows/builtin-templates")
     ];
     for (const candidate of candidates) {
       if ((0, import_node_fs23.existsSync)(candidate)) {
@@ -88465,7 +89019,7 @@ var TemplateRegistry = class {
   }
   async findTemplatePath(directory, templateName) {
     for (const ext of YAML_EXTENSIONS) {
-      const candidate = import_node_path32.default.join(directory, `${templateName}${ext}`);
+      const candidate = import_node_path35.default.join(directory, `${templateName}${ext}`);
       try {
         const stat2 = await import_node_fs23.promises.stat(candidate);
         if (stat2.isFile()) {
@@ -88813,8 +89367,8 @@ function pythonVerifyCommand() {
 
 // packages/sdk/dist/workflows/run-script.js
 var import_node_fs24 = __toESM(require("node:fs"), 1);
-var import_node_path33 = __toESM(require("node:path"), 1);
-var import_node_child_process9 = require("node:child_process");
+var import_node_path36 = __toESM(require("node:path"), 1);
+var import_node_child_process10 = require("node:child_process");
 function diag(msg) {
   try {
     process.stderr.write(`[agent-relay] ${msg}
@@ -88828,12 +89382,12 @@ function diag(msg) {
   }
 }
 function findLocalSdkWorkspace(startDir) {
-  let current = import_node_path33.default.resolve(startDir);
-  const root = import_node_path33.default.parse(current).root;
+  let current = import_node_path36.default.resolve(startDir);
+  const root = import_node_path36.default.parse(current).root;
   while (true) {
-    const packageJsonPath = import_node_path33.default.join(current, "package.json");
-    const sdkDir = import_node_path33.default.join(current, "packages", "sdk");
-    const sdkPackageJsonPath = import_node_path33.default.join(sdkDir, "package.json");
+    const packageJsonPath = import_node_path36.default.join(current, "package.json");
+    const sdkDir = import_node_path36.default.join(current, "packages", "sdk");
+    const sdkPackageJsonPath = import_node_path36.default.join(sdkDir, "package.json");
     try {
       if (import_node_fs24.default.existsSync(packageJsonPath) && import_node_fs24.default.existsSync(sdkPackageJsonPath)) {
         const pkg = JSON.parse(import_node_fs24.default.readFileSync(packageJsonPath, "utf8"));
@@ -88846,14 +89400,14 @@ function findLocalSdkWorkspace(startDir) {
     }
     if (current === root)
       return null;
-    current = import_node_path33.default.dirname(current);
+    current = import_node_path36.default.dirname(current);
   }
 }
-function ensureLocalSdkWorkflowRuntime(startDir, execRunner = import_node_child_process9.execFileSync) {
+function ensureLocalSdkWorkflowRuntime(startDir, execRunner = import_node_child_process10.execFileSync) {
   const workspace = findLocalSdkWorkspace(startDir);
   if (!workspace)
     return;
-  const workflowsEntry = import_node_path33.default.join(workspace.sdkDir, "dist", "workflows", "index.js");
+  const workflowsEntry = import_node_path36.default.join(workspace.sdkDir, "dist", "workflows", "index.js");
   if (import_node_fs24.default.existsSync(workflowsEntry))
     return;
   console.log("[agent-relay] Detected local @agent-relay/sdk workspace without built workflows runtime; building packages/sdk...");
@@ -88935,7 +89489,7 @@ function formatWorkflowParseError(parsed) {
 }
 async function spawnRunnerWithStderrCapture(command, args, env) {
   return new Promise((resolve4) => {
-    const child = (0, import_node_child_process9.spawn)(command, args, {
+    const child = (0, import_node_child_process10.spawn)(command, args, {
       stdio: ["inherit", "inherit", "pipe"],
       env
     });
@@ -88958,14 +89512,14 @@ async function spawnRunnerWithStderrCapture(command, args, env) {
 }
 async function runScriptWorkflow(filePath, options = {}) {
   diag(`runScriptWorkflow: resolving ${filePath}`);
-  const resolved = import_node_path33.default.resolve(filePath);
+  const resolved = import_node_path36.default.resolve(filePath);
   if (!import_node_fs24.default.existsSync(resolved)) {
     throw new Error(`File not found: ${resolved}`);
   }
-  const ext = import_node_path33.default.extname(resolved).toLowerCase();
-  const runIdFile = import_node_path33.default.join(process.cwd(), ".agent-relay", `script-run-id-${process.pid}-${Date.now()}.txt`);
+  const ext = import_node_path36.default.extname(resolved).toLowerCase();
+  const runIdFile = import_node_path36.default.join(process.cwd(), ".agent-relay", `script-run-id-${process.pid}-${Date.now()}.txt`);
   try {
-    import_node_fs24.default.mkdirSync(import_node_path33.default.dirname(runIdFile), { recursive: true });
+    import_node_fs24.default.mkdirSync(import_node_path36.default.dirname(runIdFile), { recursive: true });
   } catch {
   }
   const childEnv = { ...process.env, AGENT_RELAY_RUN_ID_FILE: runIdFile };
@@ -89003,7 +89557,7 @@ Run ID: ${runId}`;
   };
   if (ext === ".ts" || ext === ".tsx") {
     diag("runScriptWorkflow: ensureLocalSdkWorkflowRuntime start");
-    ensureLocalSdkWorkflowRuntime(import_node_path33.default.dirname(resolved));
+    ensureLocalSdkWorkflowRuntime(import_node_path36.default.dirname(resolved));
     diag("runScriptWorkflow: ensureLocalSdkWorkflowRuntime done");
     const wrapRunnerError = (runner, result) => {
       const parsed = parseTsxStderr(result.stderr);
@@ -89058,7 +89612,7 @@ Run ID: ${runId}`;
     const runners = ["python3", "python"];
     for (const runner of runners) {
       diag(`runScriptWorkflow: trying runner ${runner}`);
-      const spawnResult = (0, import_node_child_process9.spawnSync)(runner, [resolved], {
+      const spawnResult = (0, import_node_child_process10.spawnSync)(runner, [resolved], {
         stdio: "inherit",
         env: childEnv
       });
@@ -89208,8 +89762,8 @@ var GitHubClient = class _GitHubClient {
   /**
    * Execute a raw GitHub API request through the selected adapter.
    */
-  async request(method, path25, options) {
-    return (await this.getAdapter()).request(method, path25, options);
+  async request(method, path28, options) {
+    return (await this.getAdapter()).request(method, path28, options);
   }
   /**
    * Execute any registered GitHub primitive action by action name.
@@ -89309,23 +89863,23 @@ var GitHubClient = class _GitHubClient {
   /**
    * List files or directories at a repository path.
    */
-  async listFiles(owner, repo, path25 = "", options = {}) {
-    return (await this.getAdapter()).listFiles({ owner, repo, path: path25, ...options });
+  async listFiles(owner, repo, path28 = "", options = {}) {
+    return (await this.getAdapter()).listFiles({ owner, repo, path: path28, ...options });
   }
   /**
    * Read a repository file and return decoded UTF-8 content.
    */
-  async readFile(owner, repo, path25, ref) {
-    return (await this.getAdapter()).readFile({ owner, repo, path: path25, ref });
+  async readFile(owner, repo, path28, ref) {
+    return (await this.getAdapter()).readFile({ owner, repo, path: path28, ref });
   }
   /**
    * Create a repository file with a commit message.
    */
-  async createFile(owner, repo, path25, content, message, options = {}) {
+  async createFile(owner, repo, path28, content, message, options = {}) {
     await (await this.getAdapter()).createFile({
       owner,
       repo,
-      path: path25,
+      path: path28,
       content,
       message,
       ...options
@@ -89334,11 +89888,11 @@ var GitHubClient = class _GitHubClient {
   /**
    * Update a repository file with a commit message.
    */
-  async updateFile(owner, repo, path25, content, message, sha, options = {}) {
+  async updateFile(owner, repo, path28, content, message, sha, options = {}) {
     return (await this.getAdapter()).updateFile({
       owner,
       repo,
-      path: path25,
+      path: path28,
       content,
       message,
       sha,
@@ -89348,11 +89902,11 @@ var GitHubClient = class _GitHubClient {
   /**
    * Delete a repository file with a commit message.
    */
-  async deleteFile(owner, repo, path25, sha, message, options = {}) {
+  async deleteFile(owner, repo, path28, sha, message, options = {}) {
     await (await this.getAdapter()).deleteFile({
       owner,
       repo,
-      path: path25,
+      path: path28,
       sha,
       message,
       ...options
@@ -89734,10 +90288,10 @@ function projectionToText(value) {
   }
   return JSON.stringify(value);
 }
-function resolvePath2(value, path25) {
-  if (!path25) return value;
+function resolvePath2(value, path28) {
+  if (!path28) return value;
   let current = value;
-  for (const segment of path25.split(".")) {
+  for (const segment of path28.split(".")) {
     if (Array.isArray(current) && /^\d+$/.test(segment)) {
       current = current[Number(segment)];
       continue;
@@ -90053,13 +90607,13 @@ function slackStepConfigFromWorkflowStep(step, resolvedParams) {
 function renderSlackTemplates(value, data) {
   return value.replace(
     /\{\{\s*steps\.([A-Za-z0-9_-]+)\.output(?:\.([A-Za-z0-9_.-]+))?\s*\}\}/g,
-    (_match, step, path25) => {
+    (_match, step, path28) => {
       const stepData = data.steps;
       if (!isRecord3(stepData)) return "";
       const entry = stepData[String(step)];
       if (!isRecord3(entry)) return "";
       const output = entry.output;
-      const resolved = typeof path25 === "string" && path25.length > 0 ? resolvePath3(output, path25) : output;
+      const resolved = typeof path28 === "string" && path28.length > 0 ? resolvePath3(output, path28) : output;
       return projectionToText2(resolved);
     }
   );
@@ -90197,10 +90751,10 @@ function projectionToText2(value) {
   }
   return JSON.stringify(value);
 }
-function resolvePath3(value, path25) {
-  if (!path25) return value;
+function resolvePath3(value, path28) {
+  if (!path28) return value;
   let current = value;
-  for (const segment of path25.split(".")) {
+  for (const segment of path28.split(".")) {
     if (Array.isArray(current) && /^\d+$/.test(segment)) {
       current = current[Number(segment)];
       continue;
@@ -90425,7 +90979,7 @@ function isValidAgentName(name) {
 
 // packages/utils/dist/logger.js
 var import_node_fs25 = __toESM(require("node:fs"), 1);
-var import_node_path34 = __toESM(require("node:path"), 1);
+var import_node_path37 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
 }
@@ -90443,7 +90997,7 @@ var LEVEL_PRIORITY = {
 };
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
-  const logDir = import_node_path34.default.dirname(logFile);
+  const logDir = import_node_path37.default.dirname(logFile);
   if (!createdLogDirs.has(logDir) && !import_node_fs25.default.existsSync(logDir)) {
     import_node_fs25.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
@@ -90744,14 +91298,14 @@ function benchmarkPatterns(iterations = 1e4) {
 }
 
 // packages/utils/dist/command-resolver.js
-var import_node_child_process12 = require("node:child_process");
+var import_node_child_process13 = require("node:child_process");
 var import_node_fs26 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
   }
   try {
-    const output = (0, import_node_child_process12.execSync)(`which ${command}`, {
+    const output = (0, import_node_child_process13.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       // Ensure we have a reasonable PATH
@@ -90785,7 +91339,7 @@ function resolveSymlinks(filePath) {
 }
 function commandExists(command) {
   try {
-    (0, import_node_child_process12.execSync)(`which ${command}`, {
+    (0, import_node_child_process13.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -90796,9 +91350,9 @@ function commandExists(command) {
 }
 
 // packages/utils/dist/git-remote.js
-var fs9 = __toESM(require("node:fs"), 1);
-var path21 = __toESM(require("node:path"), 1);
-var import_node_child_process13 = require("node:child_process");
+var fs11 = __toESM(require("node:fs"), 1);
+var path24 = __toESM(require("node:path"), 1);
+var import_node_child_process14 = require("node:child_process");
 function parseGitRemoteUrl(url2) {
   if (!url2)
     return null;
@@ -90814,11 +91368,11 @@ function parseGitRemoteUrl(url2) {
 }
 function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
   try {
-    const gitDir = path21.join(workingDirectory, ".git");
-    if (!fs9.existsSync(gitDir)) {
+    const gitDir = path24.join(workingDirectory, ".git");
+    if (!fs11.existsSync(gitDir)) {
       return null;
     }
-    const result = (0, import_node_child_process13.execSync)(`git remote get-url ${remoteName}`, {
+    const result = (0, import_node_child_process14.execSync)(`git remote get-url ${remoteName}`, {
       cwd: workingDirectory,
       encoding: "utf-8",
       timeout: 5e3,
@@ -90827,11 +91381,11 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
     return result.trim() || null;
   } catch {
     try {
-      const configPath = path21.join(workingDirectory, ".git", "config");
-      if (!fs9.existsSync(configPath)) {
+      const configPath = path24.join(workingDirectory, ".git", "config");
+      if (!fs11.existsSync(configPath)) {
         return null;
       }
-      const config2 = fs9.readFileSync(configPath, "utf-8");
+      const config2 = fs11.readFileSync(configPath, "utf-8");
       const remoteSection = new RegExp(`\\[remote\\s+"${remoteName}"\\][^\\[]*url\\s*=\\s*([^\\n]+)`, "i");
       const match = config2.match(remoteSection);
       return match?.[1]?.trim() || null;
@@ -90848,13 +91402,13 @@ function getRepoFullName(workingDirectory) {
   return parseGitRemoteUrl(remoteUrl);
 }
 function findGitRoot(startPath) {
-  let currentPath = path21.resolve(startPath);
-  const root = path21.parse(currentPath).root;
+  let currentPath = path24.resolve(startPath);
+  const root = path24.parse(currentPath).root;
   while (currentPath !== root) {
-    if (fs9.existsSync(path21.join(currentPath, ".git"))) {
+    if (fs11.existsSync(path24.join(currentPath, ".git"))) {
       return currentPath;
     }
-    currentPath = path21.dirname(currentPath);
+    currentPath = path24.dirname(currentPath);
   }
   return null;
 }
@@ -90872,16 +91426,16 @@ function getRepoFullNameFromPath(workingDirectory) {
 
 // packages/utils/dist/update-checker.js
 var import_node_fs27 = __toESM(require("node:fs"), 1);
-var import_node_path35 = __toESM(require("node:path"), 1);
+var import_node_path38 = __toESM(require("node:path"), 1);
 var import_node_https2 = __toESM(require("node:https"), 1);
-var import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_os14 = __toESM(require("node:os"), 1);
 var import_compare_versions = __toESM(require_umd(), 1);
 var PACKAGE_NAME = "agent-relay";
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 function getCachePath() {
-  const cacheDir = import_node_path35.default.join(import_node_os12.default.homedir(), ".agent-relay");
-  return import_node_path35.default.join(cacheDir, "update-cache.json");
+  const cacheDir = import_node_path38.default.join(import_node_os14.default.homedir(), ".agent-relay");
+  return import_node_path38.default.join(cacheDir, "update-cache.json");
 }
 function readCache() {
   try {
@@ -90897,7 +91451,7 @@ function readCache() {
 function writeCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = import_node_path35.default.dirname(cachePath);
+    const cacheDir = import_node_path38.default.dirname(cachePath);
     if (!import_node_fs27.default.existsSync(cacheDir)) {
       import_node_fs27.default.mkdirSync(cacheDir, { recursive: true });
     }
@@ -91181,8 +91735,8 @@ function validateModelForCli(cli, model) {
 
 // packages/utils/dist/relay-pty-path.js
 var import_node_fs28 = __toESM(require("node:fs"), 1);
-var import_node_os13 = __toESM(require("node:os"), 1);
-var import_node_path36 = __toESM(require("node:path"), 1);
+var import_node_os15 = __toESM(require("node:os"), 1);
+var import_node_path39 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
   darwin: {
     arm64: "relay-pty-darwin-arm64",
@@ -91194,20 +91748,20 @@ var SUPPORTED_PLATFORMS = {
   }
 };
 function getPlatformBinaryName() {
-  const platform2 = import_node_os13.default.platform();
-  const arch = import_node_os13.default.arch();
+  const platform2 = import_node_os15.default.platform();
+  const arch = import_node_os15.default.arch();
   return SUPPORTED_PLATFORMS[platform2]?.[arch] ?? null;
 }
 function isPlatformSupported() {
-  const platform2 = import_node_os13.default.platform();
-  const arch = import_node_os13.default.arch();
+  const platform2 = import_node_os15.default.platform();
+  const arch = import_node_os15.default.arch();
   return SUPPORTED_PLATFORMS[platform2]?.[arch] !== void 0;
 }
 function getSupportedPlatforms() {
   const platforms = [];
-  for (const [os12, archs] of Object.entries(SUPPORTED_PLATFORMS)) {
+  for (const [os14, archs] of Object.entries(SUPPORTED_PLATFORMS)) {
     for (const arch of Object.keys(archs)) {
-      platforms.push(`${os12}-${arch}`);
+      platforms.push(`${os14}-${arch}`);
     }
   }
   return platforms.join(", ");
@@ -91230,22 +91784,22 @@ function findRelayPtyBinary(callerDirname) {
   const scopedMatch = normalizedCaller.match(/^(.+?\/node_modules)\/@agent-relay\//);
   const directMatch = normalizedCaller.match(/^(.+?\/node_modules\/agent-relay)/);
   if (scopedMatch) {
-    packageRoots.push(import_node_path36.default.join(scopedMatch[1], "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(scopedMatch[1], "agent-relay"));
   }
   if (directMatch) {
     packageRoots.push(directMatch[1]);
   }
   if (!normalizedCaller.includes("node_modules")) {
-    packageRoots.push(import_node_path36.default.join(callerDirname, "..", "..", ".."));
+    packageRoots.push(import_node_path39.default.join(callerDirname, "..", "..", ".."));
   }
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
-    const npxCacheBase = import_node_path36.default.join(home, ".npm", "_npx");
+    const npxCacheBase = import_node_path39.default.join(home, ".npm", "_npx");
     if (import_node_fs28.default.existsSync(npxCacheBase)) {
       try {
         const entries = import_node_fs28.default.readdirSync(npxCacheBase);
         for (const entry of entries) {
-          const npxPackage = import_node_path36.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
+          const npxPackage = import_node_path39.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
           if (import_node_fs28.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
@@ -91254,42 +91808,42 @@ function findRelayPtyBinary(callerDirname) {
       }
     }
   }
-  packageRoots.push(import_node_path36.default.join(process.cwd(), "node_modules", "agent-relay"));
+  packageRoots.push(import_node_path39.default.join(process.cwd(), "node_modules", "agent-relay"));
   if (home) {
-    packageRoots.push(import_node_path36.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, "n", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path36.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
-  }
-  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path36.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path36.default.join(home, ".agent-relay", "bin") : null;
-  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path36.default.join(home, ".local", "bin") : null);
-  const nodePrefix = import_node_path36.default.resolve(import_node_path36.default.dirname(process.execPath), "..");
-  packageRoots.push(import_node_path36.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, "n", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path39.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
+  }
+  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path39.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path39.default.join(home, ".agent-relay", "bin") : null;
+  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path39.default.join(home, ".local", "bin") : null);
+  const nodePrefix = import_node_path39.default.resolve(import_node_path39.default.dirname(process.execPath), "..");
+  packageRoots.push(import_node_path39.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
   packageRoots.push("/usr/local/lib/node_modules/agent-relay");
   packageRoots.push("/opt/homebrew/lib/node_modules/agent-relay");
   packageRoots.push("/usr/lib/node_modules/agent-relay");
   const candidates = [];
   for (const root of packageRoots) {
     if (platformBinary) {
-      candidates.push(import_node_path36.default.join(root, "bin", platformBinary));
+      candidates.push(import_node_path39.default.join(root, "bin", platformBinary));
     }
-    candidates.push(import_node_path36.default.join(root, "bin", "relay-pty"));
+    candidates.push(import_node_path39.default.join(root, "bin", "relay-pty"));
   }
   if (bashInstallerDir) {
     if (platformBinary) {
-      candidates.push(import_node_path36.default.join(bashInstallerDir, platformBinary));
+      candidates.push(import_node_path39.default.join(bashInstallerDir, platformBinary));
     }
-    candidates.push(import_node_path36.default.join(bashInstallerDir, "relay-pty"));
+    candidates.push(import_node_path39.default.join(bashInstallerDir, "relay-pty"));
   }
   if (bashInstallerBinDir) {
     if (platformBinary) {
-      candidates.push(import_node_path36.default.join(bashInstallerBinDir, platformBinary));
+      candidates.push(import_node_path39.default.join(bashInstallerBinDir, platformBinary));
     }
-    candidates.push(import_node_path36.default.join(bashInstallerBinDir, "relay-pty"));
+    candidates.push(import_node_path39.default.join(bashInstallerBinDir, "relay-pty"));
   }
   candidates.push("/app/bin/relay-pty");
   candidates.push("/usr/local/bin/relay-pty");
@@ -91320,7 +91874,7 @@ function isPlatformCompatibleBinary(filePath) {
       return false;
     }
     const magic = header.readUInt32BE(0);
-    const platform2 = import_node_os13.default.platform();
+    const platform2 = import_node_os15.default.platform();
     if (platform2 === "darwin") {
       return isMachOBinary(magic);
     }
@@ -91949,56 +92503,56 @@ var HookRegistry = class {
 };
 
 // packages/trajectory/dist/integration.js
-var import_node_child_process14 = require("node:child_process");
+var import_node_child_process15 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
 var import_node_crypto16 = __toESM(require("node:crypto"), 1);
-var import_node_path37 = __toESM(require("node:path"), 1);
+var import_node_path40 = __toESM(require("node:path"), 1);
 var import_node_fs29 = __toESM(require("node:fs"), 1);
-var import_node_os14 = __toESM(require("node:os"), 1);
+var import_node_os16 = __toESM(require("node:os"), 1);
 function getGlobalBaseDir2() {
   if (process.env.AGENT_RELAY_DATA_DIR) {
     return process.env.AGENT_RELAY_DATA_DIR;
   }
   const xdgDataHome = process.env.XDG_DATA_HOME;
   if (xdgDataHome) {
-    return import_node_path37.default.join(xdgDataHome, "agent-relay");
+    return import_node_path40.default.join(xdgDataHome, "agent-relay");
   }
-  return import_node_path37.default.join(import_node_os14.default.homedir(), ".agent-relay");
+  return import_node_path40.default.join(import_node_os16.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
 var PROJECT_DATA_DIR = ".agent-relay";
 function hashPath(projectPath) {
-  const normalized = import_node_path37.default.resolve(projectPath);
+  const normalized = import_node_path40.default.resolve(projectPath);
   const hash2 = import_node_crypto16.default.createHash("sha256").update(normalized).digest("hex");
   return hash2.substring(0, 12);
 }
 function findProjectRoot(startDir = process.cwd()) {
   if (process.env.AGENT_RELAY_PROJECT) {
-    return import_node_path37.default.resolve(process.env.AGENT_RELAY_PROJECT);
+    return import_node_path40.default.resolve(process.env.AGENT_RELAY_PROJECT);
   }
-  let current = import_node_path37.default.resolve(startDir);
-  const root = import_node_path37.default.parse(current).root;
+  let current = import_node_path40.default.resolve(startDir);
+  const root = import_node_path40.default.parse(current).root;
   const markers = [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".agent-relay"];
   while (current !== root) {
     for (const marker of markers) {
-      if (import_node_fs29.default.existsSync(import_node_path37.default.join(current, marker))) {
+      if (import_node_fs29.default.existsSync(import_node_path40.default.join(current, marker))) {
         return current;
       }
     }
-    current = import_node_path37.default.dirname(current);
+    current = import_node_path40.default.dirname(current);
   }
-  return import_node_path37.default.resolve(startDir);
+  return import_node_path40.default.resolve(startDir);
 }
 function getProjectPaths2(projectRoot) {
   const root = projectRoot ?? findProjectRoot();
   const projectId = hashPath(root);
-  const dataDir = import_node_path37.default.join(root, PROJECT_DATA_DIR);
+  const dataDir = import_node_path40.default.join(root, PROJECT_DATA_DIR);
   return {
     dataDir,
-    teamDir: import_node_path37.default.join(dataDir, "team"),
-    dbPath: import_node_path37.default.join(dataDir, "messages.sqlite"),
-    socketPath: import_node_path37.default.join(dataDir, "relay.sock"),
+    teamDir: import_node_path40.default.join(dataDir, "team"),
+    dbPath: import_node_path40.default.join(dataDir, "messages.sqlite"),
+    socketPath: import_node_path40.default.join(dataDir, "relay.sock"),
     projectRoot: root,
     projectId
   };
@@ -92006,15 +92560,15 @@ function getProjectPaths2(projectRoot) {
 
 // packages/config/dist/trajectory-config.js
 var import_node_fs30 = require("node:fs");
-var import_node_path38 = require("node:path");
-var import_node_os15 = require("node:os");
+var import_node_path41 = require("node:path");
+var import_node_os17 = require("node:os");
 var import_node_crypto17 = require("node:crypto");
 function getAgentRelayConfigDir() {
-  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path38.join)((0, import_node_os15.homedir)(), ".config", "agent-relay");
+  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path41.join)((0, import_node_os17.homedir)(), ".config", "agent-relay");
 }
 var configCache = null;
 function getRelayConfigPath(_projectRoot) {
-  return (0, import_node_path38.join)(getAgentRelayConfigDir(), "relay.json");
+  return (0, import_node_path41.join)(getAgentRelayConfigDir(), "relay.json");
 }
 function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
@@ -92054,12 +92608,12 @@ function getProjectHash(projectRoot) {
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
-  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path38.join)((0, import_node_os15.homedir)(), ".config");
-  return (0, import_node_path38.join)(configDir, "agent-relay", "trajectories", projectHash);
+  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path41.join)((0, import_node_os17.homedir)(), ".config");
+  return (0, import_node_path41.join)(configDir, "agent-relay", "trajectories", projectHash);
 }
 function getRepoTrajectoriesDir(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_path38.join)(root, ".trajectories");
+  return (0, import_node_path41.join)(root, ".trajectories");
 }
 function getPrimaryTrajectoriesDir(projectRoot) {
   if (shouldStoreInRepo(projectRoot)) {
@@ -92078,7 +92632,7 @@ function getTrajectoryEnvVars(projectRoot) {
 async function runTrail(args) {
   return new Promise((resolve4) => {
     const trajectoryEnv = getTrajectoryEnvVars();
-    const proc = (0, import_node_child_process14.spawn)("trail", args, {
+    const proc = (0, import_node_child_process15.spawn)("trail", args, {
       cwd: getProjectPaths2().projectRoot,
       env: { ...process.env, ...trajectoryEnv },
       stdio: ["pipe", "pipe", "pipe"]
@@ -92349,7 +92903,7 @@ var TrajectoryIntegration = class {
    */
   isTrailInstalledSync() {
     try {
-      (0, import_node_child_process14.execSync)("which trail", { stdio: "pipe" });
+      (0, import_node_child_process15.execSync)("which trail", { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -92700,7 +93254,7 @@ var HookEmitter = class {
 
 // packages/hooks/dist/inbox-check/utils.js
 var import_node_fs31 = require("node:fs");
-var import_node_path39 = require("node:path");
+var import_node_path42 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
   return process.env.AGENT_RELAY_NAME;
@@ -92710,7 +93264,7 @@ function getInboxPath(config2) {
   if (!agentName) {
     throw new Error("Agent name not configured. Set AGENT_RELAY_NAME env var.");
   }
-  return (0, import_node_path39.join)(config2.inboxDir, agentName, "inbox.md");
+  return (0, import_node_path42.join)(config2.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
   return (0, import_node_fs31.existsSync)(inboxPath);
@@ -92959,6 +93513,7 @@ init_dist2();
   isWorktreeStep,
   listLoggedAgents,
   listPersonas,
+  listWorkflowSchedules,
   loadCustomSteps,
   loadPersona,
   logAndTraceError,
@@ -92992,6 +93547,7 @@ init_dist2();
   runScriptWorkflow,
   runVerification,
   runWorkflow,
+  scheduleWorkflow,
   scrubForChannel,
   scrubSecrets,
   sendToChannel,