agent-relay 6.0.2 → 6.0.3

package/dist/index.cjs

@@ -4531,15 +4531,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path24 = [graph[toModel].parent, toModel];
+      const path25 = [graph[toModel].parent, toModel];
       let fn2 = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path24.unshift(graph[cur].parent);
+        path25.unshift(graph[cur].parent);
         fn2 = link2(conversions[graph[cur].parent][cur], fn2);
         cur = graph[cur].parent;
       }
-      fn2.conversion = path24;
+      fn2.conversion = path25;
       return fn2;
     }
     module2.exports = function(fromModel) {
@@ -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(path24, checkUnignored, mode) {
+      test(path25, 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(path24);
+          const matched = rule[mode].test(path25);
           if (!matched) {
             return;
           }
@@ -5535,17 +5535,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path24, originalPath, doThrow) => {
-      if (!isString(path24)) {
+    var checkPath = (path25, originalPath, doThrow) => {
+      if (!isString(path25)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path24) {
+      if (!path25) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path24)) {
+      if (checkPath.isNotRelative(path25)) {
         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 = (path24) => REGEX_TEST_INVALID_PATH.test(path24);
+    var isNotRelative = (path25) => REGEX_TEST_INVALID_PATH.test(path25);
     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 path24 = originalPath && checkPath.convert(originalPath);
+        const path25 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path24,
+          path25,
           originalPath,
           this._strictPathCheck ? throwError : RETURN_FALSE
         );
-        return this._t(path24, cache, checkUnignored, slices);
+        return this._t(path25, cache, checkUnignored, slices);
       }
-      checkIgnore(path24) {
-        if (!REGEX_TEST_TRAILING_SLASH.test(path24)) {
-          return this.test(path24);
+      checkIgnore(path25) {
+        if (!REGEX_TEST_TRAILING_SLASH.test(path25)) {
+          return this.test(path25);
         }
-        const slices = path24.split(SLASH).filter(Boolean);
+        const slices = path25.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(path24, false, MODE_CHECK_IGNORE);
+        return this._rules.test(path25, false, MODE_CHECK_IGNORE);
       }
-      _t(path24, cache, checkUnignored, slices) {
-        if (path24 in cache) {
-          return cache[path24];
+      _t(path25, cache, checkUnignored, slices) {
+        if (path25 in cache) {
+          return cache[path25];
         }
         if (!slices) {
-          slices = path24.split(SLASH).filter(Boolean);
+          slices = path25.split(SLASH).filter(Boolean);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path24] = this._rules.test(path24, checkUnignored, MODE_IGNORE);
+          return cache[path25] = this._rules.test(path25, checkUnignored, MODE_IGNORE);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -5628,29 +5628,29 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path24] = parent.ignored ? parent : this._rules.test(path24, checkUnignored, MODE_IGNORE);
+        return cache[path25] = parent.ignored ? parent : this._rules.test(path25, checkUnignored, MODE_IGNORE);
       }
-      ignores(path24) {
-        return this._test(path24, this._ignoreCache, false).ignored;
+      ignores(path25) {
+        return this._test(path25, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path24) => !this.ignores(path24);
+        return (path25) => !this.ignores(path25);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path24) {
-        return this._test(path24, this._testCache, true);
+      test(path25) {
+        return this._test(path25, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path24) => checkPath(path24 && checkPath.convert(path24), path24, RETURN_FALSE);
+    var isPathValid = (path25) => checkPath(path25 && checkPath.convert(path25), path25, 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 = (path24) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path24) || isNotRelative(path24);
+      checkPath.isNotRelative = (path25) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path25) || isNotRelative(path25);
     };
     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, path24) {
-      const ctrl = callVisitor(key, node, visitor, path24);
+    function visit_(key, node, visitor, path25) {
+      const ctrl = callVisitor(key, node, visitor, path25);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path24, ctrl);
-        return visit_(key, ctrl, visitor, path24);
+        replaceNode(key, path25, ctrl);
+        return visit_(key, ctrl, visitor, path25);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path24 = Object.freeze(path24.concat(node));
+          path25 = Object.freeze(path25.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = visit_(i, node.items[i], visitor, path24);
+            const ci2 = visit_(i, node.items[i], visitor, path25);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -5763,13 +5763,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path24 = Object.freeze(path24.concat(node));
-          const ck = visit_("key", node.key, visitor, path24);
+          path25 = Object.freeze(path25.concat(node));
+          const ck = visit_("key", node.key, visitor, path25);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path24);
+          const cv = visit_("value", node.value, visitor, path25);
           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, path24) {
-      const ctrl = await callVisitor(key, node, visitor, path24);
+    async function visitAsync_(key, node, visitor, path25) {
+      const ctrl = await callVisitor(key, node, visitor, path25);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path24, ctrl);
-        return visitAsync_(key, ctrl, visitor, path24);
+        replaceNode(key, path25, ctrl);
+        return visitAsync_(key, ctrl, visitor, path25);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path24 = Object.freeze(path24.concat(node));
+          path25 = Object.freeze(path25.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci2 = await visitAsync_(i, node.items[i], visitor, path24);
+            const ci2 = await visitAsync_(i, node.items[i], visitor, path25);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -5811,13 +5811,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path24 = Object.freeze(path24.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path24);
+          path25 = Object.freeze(path25.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path25);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path24);
+          const cv = await visitAsync_("value", node.value, visitor, path25);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -5844,23 +5844,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path24) {
+    function callVisitor(key, node, visitor, path25) {
       if (typeof visitor === "function")
-        return visitor(key, node, path24);
+        return visitor(key, node, path25);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path24);
+        return visitor.Map?.(key, node, path25);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path24);
+        return visitor.Seq?.(key, node, path25);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path24);
+        return visitor.Pair?.(key, node, path25);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path24);
+        return visitor.Scalar?.(key, node, path25);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path24);
+        return visitor.Alias?.(key, node, path25);
       return void 0;
     }
-    function replaceNode(key, path24, node) {
-      const parent = path24[path24.length - 1];
+    function replaceNode(key, path25, node) {
+      const parent = path25[path25.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -6468,10 +6468,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path24, value) {
+    function collectionFromPath(schema, path25, value) {
       let v2 = value;
-      for (let i = path24.length - 1; i >= 0; --i) {
-        const k2 = path24[i];
+      for (let i = path25.length - 1; i >= 0; --i) {
+        const k2 = path25[i];
         if (typeof k2 === "number" && Number.isInteger(k2) && k2 >= 0) {
           const a = [];
           a[k2] = v2;
@@ -6490,7 +6490,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path24) => path24 == null || typeof path24 === "object" && !!path24[Symbol.iterator]().next().done;
+    var isEmptyPath = (path25) => path25 == null || typeof path25 === "object" && !!path25[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -6520,11 +6520,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(path24, value) {
-        if (isEmptyPath(path24))
+      addIn(path25, value) {
+        if (isEmptyPath(path25))
           this.add(value);
         else {
-          const [key, ...rest] = path24;
+          const [key, ...rest] = path25;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -6538,8 +6538,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path24) {
-        const [key, ...rest] = path24;
+      deleteIn(path25) {
+        const [key, ...rest] = path25;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -6553,8 +6553,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path24, keepScalar) {
-        const [key, ...rest] = path24;
+      getIn(path25, keepScalar) {
+        const [key, ...rest] = path25;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -6572,8 +6572,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path24) {
-        const [key, ...rest] = path24;
+      hasIn(path25) {
+        const [key, ...rest] = path25;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -6583,8 +6583,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(path24, value) {
-        const [key, ...rest] = path24;
+      setIn(path25, value) {
+        const [key, ...rest] = path25;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -9096,9 +9096,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path24, value) {
+      addIn(path25, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path24, value);
+          this.contents.addIn(path25, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -9173,14 +9173,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path24) {
-        if (Collection.isEmptyPath(path24)) {
+      deleteIn(path25) {
+        if (Collection.isEmptyPath(path25)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path24) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path25) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -9195,10 +9195,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path24, keepScalar) {
-        if (Collection.isEmptyPath(path24))
+      getIn(path25, keepScalar) {
+        if (Collection.isEmptyPath(path25))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path24, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path25, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -9209,10 +9209,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path24) {
-        if (Collection.isEmptyPath(path24))
+      hasIn(path25) {
+        if (Collection.isEmptyPath(path25))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path24) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path25) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -9229,13 +9229,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(path24, value) {
-        if (Collection.isEmptyPath(path24)) {
+      setIn(path25, value) {
+        if (Collection.isEmptyPath(path25)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path24), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path25), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path24, value);
+          this.contents.setIn(path25, value);
         }
       }
       /**
@@ -11192,9 +11192,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path24) => {
+    visit.itemAtPath = (cst, path25) => {
       let item = cst;
-      for (const [field, index] of path24) {
+      for (const [field, index] of path25) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -11203,23 +11203,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path24) => {
-      const parent = visit.itemAtPath(cst, path24.slice(0, -1));
-      const field = path24[path24.length - 1][0];
+    visit.parentCollection = (cst, path25) => {
+      const parent = visit.itemAtPath(cst, path25.slice(0, -1));
+      const field = path25[path25.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path24, item, visitor) {
-      let ctrl = visitor(item, path24);
+    function _visit(path25, item, visitor) {
+      let ctrl = visitor(item, path25);
       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(path24.concat([[field, i]])), token.items[i], visitor);
+            const ci2 = _visit(Object.freeze(path25.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci2 === "number")
               i = ci2 - 1;
             else if (ci2 === BREAK)
@@ -11230,10 +11230,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path24);
+            ctrl = ctrl(item, path25);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path24) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path25) : ctrl;
     }
     exports2.visit = visit;
   }
@@ -12518,14 +12518,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs12 = this.flowScalar(this.type);
+              const fs13 = this.flowScalar(this.type);
               if (atNextItem || it2.value) {
-                map2.items.push({ start, key: fs12, sep: [] });
+                map2.items.push({ start, key: fs13, sep: [] });
                 this.onKeyLine = true;
               } else if (it2.sep) {
-                this.stack.push(fs12);
+                this.stack.push(fs13);
               } else {
-                Object.assign(it2, { key: fs12, sep: [] });
+                Object.assign(it2, { key: fs13, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -12653,13 +12653,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs12 = this.flowScalar(this.type);
+              const fs13 = this.flowScalar(this.type);
               if (!it2 || it2.value)
-                fc.items.push({ start: [], key: fs12, sep: [] });
+                fc.items.push({ start: [], key: fs13, sep: [] });
               else if (it2.sep)
-                this.stack.push(fs12);
+                this.stack.push(fs13);
               else
-                Object.assign(it2, { key: fs12, sep: [] });
+                Object.assign(it2, { key: fs13, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -15801,13 +15801,60 @@ function baseVisible(segment) {
 function isZeroWidthCluster(segment) {
   return zeroWidthClusterRegex.test(segment);
 }
-function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
-  let extra = 0;
-  if (segment.length > 1) {
-    for (const char of segment.slice(1)) {
-      if (char >= "\uFF00" && char <= "\uFFEF") {
-        extra += eastAsianWidth(char.codePointAt(0), eastAsianWidthOptions);
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (zeroWidthClusterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
       }
+      for (let remaining = index; remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (character >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
     }
   }
   return extra;
@@ -15840,9 +15887,15 @@ function stringWidth2(input, options = {}) {
       width += 2;
       continue;
     }
-    const codePoint = baseVisible(segment).codePointAt(0);
+    const visibleSegment = baseVisible(segment);
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== void 0) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
     width += eastAsianWidth(codePoint, eastAsianWidthOptions);
-    width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+    width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
   }
   return width;
 }
@@ -19260,8 +19313,8 @@ var init_supermemory = __esm({
       /**
        * Make a fetch request to the Supermemory API
        */
-      async fetch(path24, options) {
-        const url2 = `${this.endpoint}${path24}`;
+      async fetch(path25, options) {
+        const url2 = `${this.endpoint}${path25}`;
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         try {
@@ -20243,11 +20296,13 @@ __export(index_exports, {
   createWorkflowRenderer: () => createWorkflowRenderer,
   customStepsFileExists: () => customStepsFileExists,
   detectCompletion: () => detectCompletion,
+  ensureLocalSdkWorkflowRuntime: () => ensureLocalSdkWorkflowRuntime,
   estimateContextTokens: () => estimateContextTokens,
   estimateTokens: () => estimateTokens,
   execCustomVerification: () => execCustomVerification,
   executeApiStep: () => executeApiStep,
   findGitRoot: () => findGitRoot,
+  findLocalSdkWorkspace: () => findLocalSdkWorkspace,
   findRelayPtyBinary: () => findRelayPtyBinary,
   followLogs: () => followLogs,
   formatDryRunReport: () => formatDryRunReport,
@@ -20257,6 +20312,7 @@ __export(index_exports, {
   formatResultMessage: () => formatResultMessage,
   formatRunSummaryTable: () => formatRunSummaryTable,
   formatStepOutput: () => formatStepOutput,
+  formatWorkflowParseError: () => formatWorkflowParseError,
   generateAgentName: () => generateAgentName,
   generateErrorId: () => generateErrorId,
   generateRequestId: () => generateRequestId,
@@ -20313,6 +20369,7 @@ __export(index_exports, {
   parseMessages: () => parseMessages,
   parseProposalCommand: () => parseProposalCommand,
   parseSpawnEnv: () => parseSpawnEnv,
+  parseTsxStderr: () => parseTsxStderr,
   parseVoteCommand: () => parseVoteCommand,
   printUpdateNotification: () => printUpdateNotification,
   readInbox: () => readInbox,
@@ -20332,6 +20389,7 @@ __export(index_exports, {
   resolveTemplateForShell: () => resolveTemplateForShell,
   resolveVariables: () => resolveVariables,
   routerLog: () => routerLog,
+  runScriptWorkflow: () => runScriptWorkflow,
   runVerification: () => runVerification,
   runWorkflow: () => runWorkflow,
   scrubForChannel: () => scrubForChannel,
@@ -20407,7 +20465,7 @@ var BrokerTransport = class {
     return this.baseUrl.replace(/^http/, "ws") + "/ws";
   }
   // ── HTTP ─────────────────────────────────────────────────────────────
-  async request(path24, init) {
+  async request(path25, init) {
     const headers = new Headers(init?.headers);
     if (!headers.has("Content-Type")) {
       headers.set("Content-Type", "application/json");
@@ -20416,7 +20474,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}${path24}`, { ...init, headers, signal });
+    const res = await fetch(`${this.baseUrl}${path25}`, { ...init, headers, signal });
     if (!res.ok) {
       let body;
       try {
@@ -21736,8 +21794,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path24, errorMaps, issueData } = params;
-  const fullPath = [...path24, ...issueData.path || []];
+  const { data, path: path25, errorMaps, issueData } = params;
+  const fullPath = [...path25, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -21853,11 +21911,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path24, key) {
+  constructor(parent, value, path25, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path24;
+    this._path = path25;
     this._key = key;
   }
   get path() {
@@ -28364,10 +28422,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path24) {
-  if (!path24)
+function getElementAtPath(obj, path25) {
+  if (!path25)
     return obj;
-  return path24.reduce((acc, key) => acc?.[key], obj);
+  return path25.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -28750,11 +28808,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path24, issues) {
+function prefixIssues(path25, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path24);
+    iss.path.unshift(path25);
     return iss;
   });
 }
@@ -28937,7 +28995,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path24 = []) => {
+  const processError = (error49, path25 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -28947,7 +29005,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path24, ...issue2.path];
+        const fullpath = [...path25, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -28979,8 +29037,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path24 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path24) {
+  const path25 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path25) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -40957,13 +41015,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path24 = ref.slice(1).split("/").filter(Boolean);
-  if (path24.length === 0) {
+  const path25 = ref.slice(1).split("/").filter(Boolean);
+  if (path25.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path24[0] === defsKey) {
-    const key = path24[1];
+  if (path25[0] === defsKey) {
+    const key = path25[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -43120,8 +43178,8 @@ var HttpClient = class _HttpClient {
       version: this._originVersion
     }));
   }
-  async request(method, path24, body, query, options) {
-    const url2 = new URL(path24, this._baseUrl);
+  async request(method, path25, body, query, options) {
+    const url2 = new URL(path25, this._baseUrl);
     if (query) {
       for (const [k2, v2] of Object.entries(query)) {
         if (v2 !== void 0)
@@ -43191,20 +43249,20 @@ var HttpClient = class _HttpClient {
       return camelizeKeys(parsedData);
     }
   }
-  get(path24, query, options) {
-    return this.request("GET", path24, void 0, query, options);
+  get(path25, query, options) {
+    return this.request("GET", path25, void 0, query, options);
   }
-  post(path24, body, options) {
-    return this.request("POST", path24, body, void 0, options);
+  post(path25, body, options) {
+    return this.request("POST", path25, body, void 0, options);
   }
-  patch(path24, body, options) {
-    return this.request("PATCH", path24, body, void 0, options);
+  patch(path25, body, options) {
+    return this.request("PATCH", path25, body, void 0, options);
   }
-  put(path24, body, options) {
-    return this.request("PUT", path24, body, void 0, options);
+  put(path25, body, options) {
+    return this.request("PUT", path25, body, void 0, options);
   }
-  async delete(path24, options) {
-    await this.request("DELETE", path24, void 0, void 0, options);
+  async delete(path25, options) {
+    await this.request("DELETE", path25, void 0, void 0, options);
   }
 };
 
@@ -45896,6 +45954,23 @@ var RelayAdapter = class {
   }
 };
 
+// packages/workflow-types/src/index.ts
+function isDeterministicStep(step) {
+  return step.type === "deterministic";
+}
+function isWorktreeStep(step) {
+  return step.type === "worktree";
+}
+function isIntegrationStep(step) {
+  return step.type === "integration";
+}
+function isCustomStep(step) {
+  return step.use !== void 0;
+}
+function isAgentStep(step) {
+  return step.type !== "deterministic" && step.type !== "worktree" && step.type !== "integration";
+}
+
 // packages/sdk/dist/workflows/types.js
 function isRestrictedAgent(agent) {
   const perms = agent.permissions;
@@ -45913,21 +45988,6 @@ function isRestrictedAgent(agent) {
     return true;
   return false;
 }
-function isDeterministicStep(step) {
-  return step.type === "deterministic";
-}
-function isWorktreeStep(step) {
-  return step.type === "worktree";
-}
-function isIntegrationStep(step) {
-  return step.type === "integration";
-}
-function isCustomStep(step) {
-  return step.use !== void 0;
-}
-function isAgentStep(step) {
-  return step.type !== "deterministic" && step.type !== "worktree" && step.type !== "integration";
-}
 
 // packages/sdk/dist/workflows/runner.js
 var import_node_child_process8 = require("node:child_process");
@@ -46194,9 +46254,9 @@ async function resolveCli(cli) {
   for (const binary of def.binaries) {
     try {
       const { stdout } = await execFileAsync("which", [binary]);
-      const path24 = stdout.trim();
-      if (path24) {
-        const result = { binary, path: path24 };
+      const path25 = stdout.trim();
+      if (path25) {
+        const result = { binary, path: path25 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -46229,13 +46289,13 @@ function resolveCliSync(cli) {
   const def = getCliDefinition(cli);
   if (!def)
     return void 0;
-  const { execFileSync: execFileSync2 } = require("node:child_process");
+  const { execFileSync: execFileSync3 } = require("node:child_process");
   for (const binary of def.binaries) {
     try {
-      const stdout = execFileSync2("which", [binary], { stdio: ["pipe", "pipe", "ignore"] });
-      const path24 = stdout.toString().trim();
-      if (path24) {
-        const result = { binary, path: path24 };
+      const stdout = execFileSync3("which", [binary], { stdio: ["pipe", "pipe", "ignore"] });
+      const path25 = stdout.toString().trim();
+      if (path25) {
+        const result = { binary, path: path25 };
         resolveCache.set(cli, result);
         return result;
       }
@@ -47540,8 +47600,8 @@ var RelayFileClient = class {
       signal: options.signal
     });
   }
-  async readFile(workspaceId, path24, correlationId, signal) {
-    const query = buildQuery({ path: path24 });
+  async readFile(workspaceId, path25, correlationId, signal) {
+    const query = buildQuery({ path: path25 });
     return this.request({
       method: "GET",
       path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/fs/file${query}`,
@@ -47582,8 +47642,8 @@ var RelayFileClient = class {
     });
   }
   async writeFile(input) {
-    const { workspaceId, path: path24, correlationId, baseRevision, content, contentType, encoding, semantics, signal } = input;
-    const query = buildQuery({ path: path24 });
+    const { workspaceId, path: path25, correlationId, baseRevision, content, contentType, encoding, semantics, signal } = input;
+    const query = buildQuery({ path: path25 });
     return this.request({
       method: "PUT",
       path: `/v1/workspaces/${encodeURIComponent(workspaceId)}/fs/file${query}`,
@@ -54398,18 +54458,18 @@ function extractDecisions(trajectory2) {
   }
   return decisions;
 }
-function expandPath(path24) {
-  if (path24.startsWith("~")) {
-    return (0, import_path4.join)(process.env.HOME ?? "", path24.slice(1));
+function expandPath(path25) {
+  if (path25.startsWith("~")) {
+    return (0, import_path4.join)(process.env.HOME ?? "", path25.slice(1));
   }
-  return path24;
+  return path25;
 }
 var indexLocks = /* @__PURE__ */ new Map();
-function withIndexLock(path24, task) {
-  const prev = indexLocks.get(path24) ?? Promise.resolve();
+function withIndexLock(path25, task) {
+  const prev = indexLocks.get(path25) ?? Promise.resolve();
   const next = prev.then(task, task);
   indexLocks.set(
-    path24,
+    path25,
     next.catch(() => void 0)
   );
   return next;
@@ -54565,8 +54625,8 @@ var FileStorage = class {
     const validation = validateTrajectory(input);
     if (!validation.success) {
       const issues = validation.errors?.issues.map((issue2) => {
-        const path24 = issue2.path.length > 0 ? issue2.path.join(".") : "root";
-        return `${path24}: ${issue2.message}`;
+        const path25 = issue2.path.length > 0 ? issue2.path.join(".") : "root";
+        return `${path25}: ${issue2.message}`;
       }).join("; ") ?? "unknown validation error";
       throw new Error(`Cannot save invalid trajectory: ${issues}`);
     }
@@ -54775,18 +54835,18 @@ var FileStorage = class {
    *
    * Does NOT log. Callers choose whether to warn, swallow, or throw.
    */
-  async readTrajectoryFile(path24) {
+  async readTrajectoryFile(path25) {
     let content;
     try {
-      content = await (0, import_promises7.readFile)(path24, "utf-8");
+      content = await (0, import_promises7.readFile)(path25, "utf-8");
     } catch (error48) {
-      return { ok: false, reason: "io_error", path: path24, error: error48 };
+      return { ok: false, reason: "io_error", path: path25, error: error48 };
     }
     let data;
     try {
       data = JSON.parse(content);
     } catch (error48) {
-      return { ok: false, reason: "malformed_json", path: path24, error: error48 };
+      return { ok: false, reason: "malformed_json", path: path25, error: error48 };
     }
     const validation = validateTrajectory(data);
     if (validation.success) {
@@ -54795,7 +54855,7 @@ var FileStorage = class {
     return {
       ok: false,
       reason: "schema_violation",
-      path: path24,
+      path: path25,
       error: validation.errors
     };
   }
@@ -54804,8 +54864,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(path24) {
-    const result = await this.readTrajectoryFile(path24);
+  async readTrajectoryOrNull(path25) {
+    const result = await this.readTrajectoryFile(path25);
     return result.ok ? result.trajectory : null;
   }
   /**
@@ -62808,6 +62868,282 @@ function pythonVerifyCommand() {
   ].join("\n");
 }
 
+// packages/sdk/dist/workflows/run-script.js
+var import_node_fs23 = __toESM(require("node:fs"), 1);
+var import_node_path32 = __toESM(require("node:path"), 1);
+var import_node_child_process9 = require("node:child_process");
+function diag(msg) {
+  try {
+    process.stderr.write(`[agent-relay] ${msg}
+`);
+  } catch {
+    try {
+      process.stdout.write(`[agent-relay] ${msg}
+`);
+    } catch {
+    }
+  }
+}
+function findLocalSdkWorkspace(startDir) {
+  let current = import_node_path32.default.resolve(startDir);
+  const root = import_node_path32.default.parse(current).root;
+  while (true) {
+    const packageJsonPath = import_node_path32.default.join(current, "package.json");
+    const sdkDir = import_node_path32.default.join(current, "packages", "sdk");
+    const sdkPackageJsonPath = import_node_path32.default.join(sdkDir, "package.json");
+    try {
+      if (import_node_fs23.default.existsSync(packageJsonPath) && import_node_fs23.default.existsSync(sdkPackageJsonPath)) {
+        const pkg = JSON.parse(import_node_fs23.default.readFileSync(packageJsonPath, "utf8"));
+        const sdkPkg = JSON.parse(import_node_fs23.default.readFileSync(sdkPackageJsonPath, "utf8"));
+        if (pkg.name === "agent-relay" && sdkPkg.name === "@agent-relay/sdk") {
+          return { rootDir: current, sdkDir };
+        }
+      }
+    } catch {
+    }
+    if (current === root)
+      return null;
+    current = import_node_path32.default.dirname(current);
+  }
+}
+function ensureLocalSdkWorkflowRuntime(startDir, execRunner = import_node_child_process9.execFileSync) {
+  const workspace = findLocalSdkWorkspace(startDir);
+  if (!workspace)
+    return;
+  const workflowsEntry = import_node_path32.default.join(workspace.sdkDir, "dist", "workflows", "index.js");
+  if (import_node_fs23.default.existsSync(workflowsEntry))
+    return;
+  console.log("[agent-relay] Detected local @agent-relay/sdk workspace without built workflows runtime; building packages/sdk...");
+  execRunner("npm", ["run", "build:sdk"], {
+    cwd: workspace.rootDir,
+    stdio: "inherit",
+    env: process.env
+  });
+  if (!import_node_fs23.default.existsSync(workflowsEntry)) {
+    throw new Error(`Local SDK workflows runtime is still missing after build: ${workflowsEntry}`);
+  }
+}
+function parseTsxStderr(stderr) {
+  const clean = stderr.replace(/\x1b\[[0-9;]*m/g, "");
+  const inlineMatch = clean.match(/(\/[^\s:]+\.(?:ts|tsx|mts|cts)):(\d+):(\d+):\s*ERROR:\s*([^\n]+)/);
+  if (inlineMatch) {
+    return {
+      file: inlineMatch[1],
+      line: Number(inlineMatch[2]),
+      column: Number(inlineMatch[3]),
+      message: inlineMatch[4].trim()
+    };
+  }
+  const prettyError = clean.match(/✘\s*\[ERROR\]\s*([^\n]+)/);
+  if (prettyError) {
+    const locationMatch = clean.match(/(\/[^\s:]+\.(?:ts|tsx|mts|cts)):(\d+):(\d+):/);
+    if (locationMatch) {
+      return {
+        file: locationMatch[1],
+        line: Number(locationMatch[2]),
+        column: Number(locationMatch[3]),
+        message: prettyError[1].trim()
+      };
+    }
+  }
+  if (/Transform failed with \d+ error/i.test(clean) || /TransformError/.test(clean)) {
+    const looseMatch = clean.match(/(\/[^\s:]+\.(?:ts|tsx|mts|cts)):(\d+):(\d+)/);
+    if (looseMatch) {
+      return {
+        file: looseMatch[1],
+        line: Number(looseMatch[2]),
+        column: Number(looseMatch[3]),
+        message: "TypeScript parse error (see tsx output above)"
+      };
+    }
+  }
+  return null;
+}
+function formatWorkflowParseError(parsed) {
+  const where = parsed.line !== void 0 ? `${parsed.file}:${parsed.line}${parsed.column !== void 0 ? `:${parsed.column}` : ""}` : parsed.file;
+  const hints = [];
+  const text = parsed.message;
+  if (/Expected "\}" but found/i.test(text) || /Unterminated template literal/i.test(text)) {
+    hints.push("Likely a JavaScript template literal metacharacter inside a `command:` or `task:` block. Inside workflow .ts files every `command: \\`...\\`` is a JavaScript template literal \u2014 backticks terminate it and `${...}` triggers JS interpolation before the shell ever sees the string.", "Fixes: use single quotes instead of backticks in prose/commit messages; for shell variables use `$VAR` (no braces) or escape as `\\${VAR}`; never write literal `\\n` inside a shell comment (it becomes a real newline).");
+  }
+  if (/Unexpected "\$"/.test(text)) {
+    hints.push("Unexpected `$` inside a template literal usually means `${...}` was interpreted as JS interpolation. Escape it as `\\${...}` or drop the braces and use plain `$VAR`.");
+  }
+  if (/Expected identifier/.test(text) && /template/i.test(text)) {
+    hints.push("A template literal interpolation `${...}` needs a valid JS expression inside. If you meant a shell variable, escape the `$` or drop the braces.");
+  }
+  const lines = ["", `Workflow file failed to parse: ${where}`, `  ${text}`];
+  if (parsed.lineText) {
+    lines.push(`  | ${parsed.lineText}`);
+    if (parsed.column !== void 0 && parsed.column >= 0) {
+      lines.push(`  | ${" ".repeat(parsed.column)}^`);
+    }
+  }
+  if (hints.length > 0) {
+    lines.push("");
+    for (const hint of hints) {
+      lines.push(`Hint: ${hint}`);
+    }
+  }
+  lines.push("");
+  const wrapped = new Error(lines.join("\n"));
+  wrapped.code = "WORKFLOW_PARSE_ERROR";
+  return wrapped;
+}
+async function spawnRunnerWithStderrCapture(command, args, env) {
+  return new Promise((resolve4) => {
+    const child = (0, import_node_child_process9.spawn)(command, args, {
+      stdio: ["inherit", "inherit", "pipe"],
+      env
+    });
+    let stderrBuf = "";
+    child.stderr?.on("data", (chunk) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      stderrBuf += text;
+      try {
+        process.stderr.write(text);
+      } catch {
+      }
+    });
+    child.on("error", (err) => {
+      resolve4({ status: null, stderr: stderrBuf, error: err });
+    });
+    child.on("close", (status) => {
+      resolve4({ status, stderr: stderrBuf });
+    });
+  });
+}
+async function runScriptWorkflow(filePath, options = {}) {
+  diag(`runScriptWorkflow: resolving ${filePath}`);
+  const resolved = import_node_path32.default.resolve(filePath);
+  if (!import_node_fs23.default.existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  const ext = import_node_path32.default.extname(resolved).toLowerCase();
+  const runIdFile = import_node_path32.default.join(process.cwd(), ".agent-relay", `script-run-id-${process.pid}-${Date.now()}.txt`);
+  try {
+    import_node_fs23.default.mkdirSync(import_node_path32.default.dirname(runIdFile), { recursive: true });
+  } catch {
+  }
+  const childEnv = { ...process.env, AGENT_RELAY_RUN_ID_FILE: runIdFile };
+  if (options.dryRun)
+    childEnv.DRY_RUN = "true";
+  if (options.resume)
+    childEnv.RESUME_RUN_ID = options.resume;
+  if (options.startFrom)
+    childEnv.START_FROM = options.startFrom;
+  if (options.previousRunId)
+    childEnv.PREVIOUS_RUN_ID = options.previousRunId;
+  const augmentErrorWithRunId = (err) => {
+    try {
+      if (import_node_fs23.default.existsSync(runIdFile)) {
+        const runId = import_node_fs23.default.readFileSync(runIdFile, "utf8").trim();
+        if (runId && typeof err?.message === "string" && !err.message.includes("Run ID:")) {
+          err.message += `
+Run ID: ${runId}`;
+        }
+      }
+    } catch {
+    } finally {
+      try {
+        import_node_fs23.default.rmSync(runIdFile, { force: true });
+      } catch {
+      }
+    }
+    throw err;
+  };
+  const cleanupRunIdFile = () => {
+    try {
+      import_node_fs23.default.rmSync(runIdFile, { force: true });
+    } catch {
+    }
+  };
+  if (ext === ".ts" || ext === ".tsx") {
+    diag("runScriptWorkflow: ensureLocalSdkWorkflowRuntime start");
+    ensureLocalSdkWorkflowRuntime(import_node_path32.default.dirname(resolved));
+    diag("runScriptWorkflow: ensureLocalSdkWorkflowRuntime done");
+    const wrapRunnerError = (runner, result) => {
+      const parsed = parseTsxStderr(result.stderr);
+      if (parsed) {
+        return formatWorkflowParseError(parsed);
+      }
+      return new Error(`${runner} exited with code ${result.status}`);
+    };
+    const runners = [
+      {
+        label: "node --experimental-strip-types",
+        bin: "node",
+        preArgs: ["--experimental-strip-types", "--no-warnings=ExperimentalWarning"]
+      },
+      { label: "tsx", bin: "tsx", preArgs: [] },
+      { label: "ts-node", bin: "ts-node", preArgs: [] }
+    ];
+    for (const { label, bin, preArgs } of runners) {
+      diag(`runScriptWorkflow: trying runner ${label}`);
+      const result = await spawnRunnerWithStderrCapture(bin, [...preArgs, resolved], childEnv);
+      if (result.error) {
+        if (result.error.code === "ENOENT") {
+          diag(`runScriptWorkflow: runner ${label} returned ENOENT \u2014 trying next`);
+          continue;
+        }
+        return augmentErrorWithRunId(result.error);
+      }
+      if (result.status !== 0) {
+        if (bin === "node" && result.status === 9) {
+          diag(`runScriptWorkflow: runner ${label} unsupported on this Node (exit 9) \u2014 trying next`);
+          continue;
+        }
+        return augmentErrorWithRunId(wrapRunnerError(label, result));
+      }
+      diag(`runScriptWorkflow: runner ${label} completed exit=0`);
+      cleanupRunIdFile();
+      return;
+    }
+    diag("runScriptWorkflow: falling back to npx tsx");
+    const npxResult = await spawnRunnerWithStderrCapture("npx", ["tsx", resolved], childEnv);
+    if (npxResult.error) {
+      return augmentErrorWithRunId(npxResult.error);
+    }
+    if (npxResult.status !== 0) {
+      return augmentErrorWithRunId(wrapRunnerError("npx tsx", npxResult));
+    }
+    diag("runScriptWorkflow: npx tsx completed");
+    cleanupRunIdFile();
+    return;
+  }
+  if (ext === ".py") {
+    const runners = ["python3", "python"];
+    for (const runner of runners) {
+      diag(`runScriptWorkflow: trying runner ${runner}`);
+      const spawnResult = (0, import_node_child_process9.spawnSync)(runner, [resolved], {
+        stdio: "inherit",
+        env: childEnv
+      });
+      if (spawnResult.error) {
+        if (spawnResult.error.code === "ENOENT") {
+          diag(`runScriptWorkflow: runner ${runner} returned ENOENT \u2014 trying next`);
+          continue;
+        }
+        return augmentErrorWithRunId(spawnResult.error);
+      }
+      if (spawnResult.status !== 0) {
+        const err = new Error(`${runner} exited with code ${spawnResult.status}`);
+        return augmentErrorWithRunId(err);
+      }
+      diag(`runScriptWorkflow: runner ${runner} completed exit=0`);
+      cleanupRunIdFile();
+      return;
+    }
+    cleanupRunIdFile();
+    throw new Error("Python not found. Install Python 3.10+ to run .py workflow files.");
+  }
+  try {
+    import_node_fs23.default.rmSync(runIdFile, { force: true });
+  } catch {
+  }
+  throw new Error(`Unsupported file type: ${ext}. Use .yaml, .yml, .ts, or .py`);
+}
+
 // packages/utils/dist/name-generator.js
 var ADJECTIVES = [
   "Blue",
@@ -62959,8 +63295,8 @@ function isValidAgentName(name) {
 }
 
 // packages/utils/dist/logger.js
-var import_node_fs23 = __toESM(require("node:fs"), 1);
-var import_node_path32 = __toESM(require("node:path"), 1);
+var import_node_fs24 = __toESM(require("node:fs"), 1);
+var import_node_path33 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
 }
@@ -62978,9 +63314,9 @@ var LEVEL_PRIORITY = {
 };
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
-  const logDir = import_node_path32.default.dirname(logFile);
-  if (!createdLogDirs.has(logDir) && !import_node_fs23.default.existsSync(logDir)) {
-    import_node_fs23.default.mkdirSync(logDir, { recursive: true });
+  const logDir = import_node_path33.default.dirname(logFile);
+  if (!createdLogDirs.has(logDir) && !import_node_fs24.default.existsSync(logDir)) {
+    import_node_fs24.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
   }
 }
@@ -63009,7 +63345,7 @@ function log(level, component, msg, extra) {
   const logFile = getLogFile();
   if (logFile) {
     ensureLogDir(logFile);
-    import_node_fs23.default.appendFileSync(logFile, formatted + "\n");
+    import_node_fs24.default.appendFileSync(logFile, formatted + "\n");
     return;
   }
   if (level === "ERROR" || level === "WARN") {
@@ -63279,14 +63615,14 @@ function benchmarkPatterns(iterations = 1e4) {
 }
 
 // packages/utils/dist/command-resolver.js
-var import_node_child_process9 = require("node:child_process");
-var import_node_fs24 = __toESM(require("node:fs"), 1);
+var import_node_child_process10 = require("node:child_process");
+var import_node_fs25 = __toESM(require("node:fs"), 1);
 function resolveCommand(command) {
   if (command.startsWith("/")) {
     return resolveSymlinks(command);
   }
   try {
-    const output = (0, import_node_child_process9.execSync)(`which ${command}`, {
+    const output = (0, import_node_child_process10.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"],
       // Ensure we have a reasonable PATH
@@ -63306,7 +63642,7 @@ function resolveCommand(command) {
 }
 function resolveSymlinks(filePath) {
   try {
-    const resolved = import_node_fs24.default.realpathSync(filePath);
+    const resolved = import_node_fs25.default.realpathSync(filePath);
     if (resolved !== filePath && process.env.DEBUG_SPAWN === "1") {
       console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
     }
@@ -63320,7 +63656,7 @@ function resolveSymlinks(filePath) {
 }
 function commandExists(command) {
   try {
-    (0, import_node_child_process9.execSync)(`which ${command}`, {
+    (0, import_node_child_process10.execSync)(`which ${command}`, {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     });
@@ -63331,9 +63667,9 @@ function commandExists(command) {
 }
 
 // packages/utils/dist/git-remote.js
-var fs8 = __toESM(require("node:fs"), 1);
-var path20 = __toESM(require("node:path"), 1);
-var import_node_child_process10 = require("node:child_process");
+var fs9 = __toESM(require("node:fs"), 1);
+var path21 = __toESM(require("node:path"), 1);
+var import_node_child_process11 = require("node:child_process");
 function parseGitRemoteUrl(url2) {
   if (!url2)
     return null;
@@ -63349,11 +63685,11 @@ function parseGitRemoteUrl(url2) {
 }
 function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
   try {
-    const gitDir = path20.join(workingDirectory, ".git");
-    if (!fs8.existsSync(gitDir)) {
+    const gitDir = path21.join(workingDirectory, ".git");
+    if (!fs9.existsSync(gitDir)) {
       return null;
     }
-    const result = (0, import_node_child_process10.execSync)(`git remote get-url ${remoteName}`, {
+    const result = (0, import_node_child_process11.execSync)(`git remote get-url ${remoteName}`, {
       cwd: workingDirectory,
       encoding: "utf-8",
       timeout: 5e3,
@@ -63362,11 +63698,11 @@ function getGitRemoteUrl(workingDirectory, remoteName = "origin") {
     return result.trim() || null;
   } catch {
     try {
-      const configPath = path20.join(workingDirectory, ".git", "config");
-      if (!fs8.existsSync(configPath)) {
+      const configPath = path21.join(workingDirectory, ".git", "config");
+      if (!fs9.existsSync(configPath)) {
         return null;
       }
-      const config2 = fs8.readFileSync(configPath, "utf-8");
+      const config2 = fs9.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;
@@ -63383,13 +63719,13 @@ function getRepoFullName(workingDirectory) {
   return parseGitRemoteUrl(remoteUrl);
 }
 function findGitRoot(startPath) {
-  let currentPath = path20.resolve(startPath);
-  const root = path20.parse(currentPath).root;
+  let currentPath = path21.resolve(startPath);
+  const root = path21.parse(currentPath).root;
   while (currentPath !== root) {
-    if (fs8.existsSync(path20.join(currentPath, ".git"))) {
+    if (fs9.existsSync(path21.join(currentPath, ".git"))) {
       return currentPath;
     }
-    currentPath = path20.dirname(currentPath);
+    currentPath = path21.dirname(currentPath);
   }
   return null;
 }
@@ -63406,8 +63742,8 @@ function getRepoFullNameFromPath(workingDirectory) {
 }
 
 // packages/utils/dist/update-checker.js
-var import_node_fs25 = __toESM(require("node:fs"), 1);
-var import_node_path33 = __toESM(require("node:path"), 1);
+var import_node_fs26 = __toESM(require("node:fs"), 1);
+var import_node_path34 = __toESM(require("node:path"), 1);
 var import_node_https2 = __toESM(require("node:https"), 1);
 var import_node_os11 = __toESM(require("node:os"), 1);
 var import_compare_versions = __toESM(require_umd(), 1);
@@ -63415,15 +63751,15 @@ 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_path33.default.join(import_node_os11.default.homedir(), ".agent-relay");
-  return import_node_path33.default.join(cacheDir, "update-cache.json");
+  const cacheDir = import_node_path34.default.join(import_node_os11.default.homedir(), ".agent-relay");
+  return import_node_path34.default.join(cacheDir, "update-cache.json");
 }
 function readCache() {
   try {
     const cachePath = getCachePath();
-    if (!import_node_fs25.default.existsSync(cachePath))
+    if (!import_node_fs26.default.existsSync(cachePath))
       return null;
-    const data = import_node_fs25.default.readFileSync(cachePath, "utf-8");
+    const data = import_node_fs26.default.readFileSync(cachePath, "utf-8");
     return JSON.parse(data);
   } catch {
     return null;
@@ -63432,11 +63768,11 @@ function readCache() {
 function writeCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = import_node_path33.default.dirname(cachePath);
-    if (!import_node_fs25.default.existsSync(cacheDir)) {
-      import_node_fs25.default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = import_node_path34.default.dirname(cachePath);
+    if (!import_node_fs26.default.existsSync(cacheDir)) {
+      import_node_fs26.default.mkdirSync(cacheDir, { recursive: true });
     }
-    import_node_fs25.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+    import_node_fs26.default.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
   } catch {
   }
 }
@@ -63715,9 +64051,9 @@ function validateModelForCli(cli, model) {
 }
 
 // packages/utils/dist/relay-pty-path.js
-var import_node_fs26 = __toESM(require("node:fs"), 1);
+var import_node_fs27 = __toESM(require("node:fs"), 1);
 var import_node_os12 = __toESM(require("node:os"), 1);
-var import_node_path34 = __toESM(require("node:path"), 1);
+var import_node_path35 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
   darwin: {
     arm64: "relay-pty-darwin-arm64",
@@ -63765,23 +64101,23 @@ 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_path34.default.join(scopedMatch[1], "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(scopedMatch[1], "agent-relay"));
   }
   if (directMatch) {
     packageRoots.push(directMatch[1]);
   }
   if (!normalizedCaller.includes("node_modules")) {
-    packageRoots.push(import_node_path34.default.join(callerDirname, "..", "..", ".."));
+    packageRoots.push(import_node_path35.default.join(callerDirname, "..", "..", ".."));
   }
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
-    const npxCacheBase = import_node_path34.default.join(home, ".npm", "_npx");
-    if (import_node_fs26.default.existsSync(npxCacheBase)) {
+    const npxCacheBase = import_node_path35.default.join(home, ".npm", "_npx");
+    if (import_node_fs27.default.existsSync(npxCacheBase)) {
       try {
-        const entries = import_node_fs26.default.readdirSync(npxCacheBase);
+        const entries = import_node_fs27.default.readdirSync(npxCacheBase);
         for (const entry of entries) {
-          const npxPackage = import_node_path34.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
-          if (import_node_fs26.default.existsSync(npxPackage)) {
+          const npxPackage = import_node_path35.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
+          if (import_node_fs27.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
         }
@@ -63789,42 +64125,42 @@ function findRelayPtyBinary(callerDirname) {
       }
     }
   }
-  packageRoots.push(import_node_path34.default.join(process.cwd(), "node_modules", "agent-relay"));
+  packageRoots.push(import_node_path35.default.join(process.cwd(), "node_modules", "agent-relay"));
   if (home) {
-    packageRoots.push(import_node_path34.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, "n", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path34.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
-  }
-  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path34.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path34.default.join(home, ".agent-relay", "bin") : null;
-  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path34.default.join(home, ".local", "bin") : null);
-  const nodePrefix = import_node_path34.default.resolve(import_node_path34.default.dirname(process.execPath), "..");
-  packageRoots.push(import_node_path34.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, "n", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path35.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
+  }
+  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path35.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path35.default.join(home, ".agent-relay", "bin") : null;
+  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path35.default.join(home, ".local", "bin") : null);
+  const nodePrefix = import_node_path35.default.resolve(import_node_path35.default.dirname(process.execPath), "..");
+  packageRoots.push(import_node_path35.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_path34.default.join(root, "bin", platformBinary));
+      candidates.push(import_node_path35.default.join(root, "bin", platformBinary));
     }
-    candidates.push(import_node_path34.default.join(root, "bin", "relay-pty"));
+    candidates.push(import_node_path35.default.join(root, "bin", "relay-pty"));
   }
   if (bashInstallerDir) {
     if (platformBinary) {
-      candidates.push(import_node_path34.default.join(bashInstallerDir, platformBinary));
+      candidates.push(import_node_path35.default.join(bashInstallerDir, platformBinary));
     }
-    candidates.push(import_node_path34.default.join(bashInstallerDir, "relay-pty"));
+    candidates.push(import_node_path35.default.join(bashInstallerDir, "relay-pty"));
   }
   if (bashInstallerBinDir) {
     if (platformBinary) {
-      candidates.push(import_node_path34.default.join(bashInstallerBinDir, platformBinary));
+      candidates.push(import_node_path35.default.join(bashInstallerBinDir, platformBinary));
     }
-    candidates.push(import_node_path34.default.join(bashInstallerBinDir, "relay-pty"));
+    candidates.push(import_node_path35.default.join(bashInstallerBinDir, "relay-pty"));
   }
   candidates.push("/app/bin/relay-pty");
   candidates.push("/usr/local/bin/relay-pty");
@@ -63839,7 +64175,7 @@ function findRelayPtyBinary(callerDirname) {
 }
 function isExecutable2(filePath) {
   try {
-    import_node_fs26.default.accessSync(filePath, import_node_fs26.default.constants.X_OK);
+    import_node_fs27.default.accessSync(filePath, import_node_fs27.default.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -63848,9 +64184,9 @@ function isExecutable2(filePath) {
 function isPlatformCompatibleBinary(filePath) {
   let fd;
   try {
-    fd = import_node_fs26.default.openSync(filePath, "r");
+    fd = import_node_fs27.default.openSync(filePath, "r");
     const header = Buffer.alloc(4);
-    const bytesRead = import_node_fs26.default.readSync(fd, header, 0, 4, 0);
+    const bytesRead = import_node_fs27.default.readSync(fd, header, 0, 4, 0);
     if (bytesRead < 4) {
       return false;
     }
@@ -63868,7 +64204,7 @@ function isPlatformCompatibleBinary(filePath) {
   } finally {
     if (fd !== void 0) {
       try {
-        import_node_fs26.default.closeSync(fd);
+        import_node_fs27.default.closeSync(fd);
       } catch {
       }
     }
@@ -64484,12 +64820,12 @@ var HookRegistry = class {
 };
 
 // packages/trajectory/dist/integration.js
-var import_node_child_process11 = require("node:child_process");
+var import_node_child_process12 = require("node:child_process");
 
 // packages/config/dist/project-namespace.js
 var import_node_crypto16 = __toESM(require("node:crypto"), 1);
-var import_node_path35 = __toESM(require("node:path"), 1);
-var import_node_fs27 = __toESM(require("node:fs"), 1);
+var import_node_path36 = __toESM(require("node:path"), 1);
+var import_node_fs28 = __toESM(require("node:fs"), 1);
 var import_node_os13 = __toESM(require("node:os"), 1);
 function getGlobalBaseDir2() {
   if (process.env.AGENT_RELAY_DATA_DIR) {
@@ -64497,65 +64833,65 @@ function getGlobalBaseDir2() {
   }
   const xdgDataHome = process.env.XDG_DATA_HOME;
   if (xdgDataHome) {
-    return import_node_path35.default.join(xdgDataHome, "agent-relay");
+    return import_node_path36.default.join(xdgDataHome, "agent-relay");
   }
-  return import_node_path35.default.join(import_node_os13.default.homedir(), ".agent-relay");
+  return import_node_path36.default.join(import_node_os13.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
 var PROJECT_DATA_DIR = ".agent-relay";
 function hashPath(projectPath) {
-  const normalized = import_node_path35.default.resolve(projectPath);
+  const normalized = import_node_path36.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_path35.default.resolve(process.env.AGENT_RELAY_PROJECT);
+    return import_node_path36.default.resolve(process.env.AGENT_RELAY_PROJECT);
   }
-  let current = import_node_path35.default.resolve(startDir);
-  const root = import_node_path35.default.parse(current).root;
+  let current = import_node_path36.default.resolve(startDir);
+  const root = import_node_path36.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_fs27.default.existsSync(import_node_path35.default.join(current, marker))) {
+      if (import_node_fs28.default.existsSync(import_node_path36.default.join(current, marker))) {
         return current;
       }
     }
-    current = import_node_path35.default.dirname(current);
+    current = import_node_path36.default.dirname(current);
   }
-  return import_node_path35.default.resolve(startDir);
+  return import_node_path36.default.resolve(startDir);
 }
 function getProjectPaths2(projectRoot) {
   const root = projectRoot ?? findProjectRoot();
   const projectId = hashPath(root);
-  const dataDir = import_node_path35.default.join(root, PROJECT_DATA_DIR);
+  const dataDir = import_node_path36.default.join(root, PROJECT_DATA_DIR);
   return {
     dataDir,
-    teamDir: import_node_path35.default.join(dataDir, "team"),
-    dbPath: import_node_path35.default.join(dataDir, "messages.sqlite"),
-    socketPath: import_node_path35.default.join(dataDir, "relay.sock"),
+    teamDir: import_node_path36.default.join(dataDir, "team"),
+    dbPath: import_node_path36.default.join(dataDir, "messages.sqlite"),
+    socketPath: import_node_path36.default.join(dataDir, "relay.sock"),
     projectRoot: root,
     projectId
   };
 }
 
 // packages/config/dist/trajectory-config.js
-var import_node_fs28 = require("node:fs");
-var import_node_path36 = require("node:path");
+var import_node_fs29 = require("node:fs");
+var import_node_path37 = require("node:path");
 var import_node_os14 = require("node:os");
 var import_node_crypto17 = require("node:crypto");
 function getAgentRelayConfigDir() {
-  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".config", "agent-relay");
+  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path37.join)((0, import_node_os14.homedir)(), ".config", "agent-relay");
 }
 var configCache = null;
 function getRelayConfigPath(_projectRoot) {
-  return (0, import_node_path36.join)(getAgentRelayConfigDir(), "relay.json");
+  return (0, import_node_path37.join)(getAgentRelayConfigDir(), "relay.json");
 }
 function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
   if (configCache && configCache.path === configPath) {
     try {
-      const stat2 = (0, import_node_fs28.statSync)(configPath);
+      const stat2 = (0, import_node_fs29.statSync)(configPath);
       if (stat2.mtimeMs === configCache.mtime) {
         return configCache.config;
       }
@@ -64563,13 +64899,13 @@ function readRelayConfig(projectRoot) {
     }
   }
   try {
-    if (!(0, import_node_fs28.existsSync)(configPath)) {
+    if (!(0, import_node_fs29.existsSync)(configPath)) {
       return {};
     }
-    const content = (0, import_node_fs28.readFileSync)(configPath, "utf-8");
+    const content = (0, import_node_fs29.readFileSync)(configPath, "utf-8");
     const config2 = JSON.parse(content);
     try {
-      const stat2 = (0, import_node_fs28.statSync)(configPath);
+      const stat2 = (0, import_node_fs29.statSync)(configPath);
       configCache = { path: configPath, config: config2, mtime: stat2.mtimeMs };
     } catch {
     }
@@ -64589,12 +64925,12 @@ function getProjectHash(projectRoot) {
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
-  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path36.join)((0, import_node_os14.homedir)(), ".config");
-  return (0, import_node_path36.join)(configDir, "agent-relay", "trajectories", projectHash);
+  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path37.join)((0, import_node_os14.homedir)(), ".config");
+  return (0, import_node_path37.join)(configDir, "agent-relay", "trajectories", projectHash);
 }
 function getRepoTrajectoriesDir(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_path36.join)(root, ".trajectories");
+  return (0, import_node_path37.join)(root, ".trajectories");
 }
 function getPrimaryTrajectoriesDir(projectRoot) {
   if (shouldStoreInRepo(projectRoot)) {
@@ -64613,7 +64949,7 @@ function getTrajectoryEnvVars(projectRoot) {
 async function runTrail(args) {
   return new Promise((resolve4) => {
     const trajectoryEnv = getTrajectoryEnvVars();
-    const proc = (0, import_node_child_process11.spawn)("trail", args, {
+    const proc = (0, import_node_child_process12.spawn)("trail", args, {
       cwd: getProjectPaths2().projectRoot,
       env: { ...process.env, ...trajectoryEnv },
       stdio: ["pipe", "pipe", "pipe"]
@@ -64884,7 +65220,7 @@ var TrajectoryIntegration = class {
    */
   isTrailInstalledSync() {
     try {
-      (0, import_node_child_process11.execSync)("which trail", { stdio: "pipe" });
+      (0, import_node_child_process12.execSync)("which trail", { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -65234,8 +65570,8 @@ var HookEmitter = class {
 };
 
 // packages/hooks/dist/inbox-check/utils.js
-var import_node_fs29 = require("node:fs");
-var import_node_path37 = require("node:path");
+var import_node_fs30 = require("node:fs");
+var import_node_path38 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
   return process.env.AGENT_RELAY_NAME;
@@ -65245,16 +65581,16 @@ function getInboxPath(config2) {
   if (!agentName) {
     throw new Error("Agent name not configured. Set AGENT_RELAY_NAME env var.");
   }
-  return (0, import_node_path37.join)(config2.inboxDir, agentName, "inbox.md");
+  return (0, import_node_path38.join)(config2.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
-  return (0, import_node_fs29.existsSync)(inboxPath);
+  return (0, import_node_fs30.existsSync)(inboxPath);
 }
 function readInbox(inboxPath) {
   if (!inboxExists(inboxPath)) {
     return "";
   }
-  return (0, import_node_fs29.readFileSync)(inboxPath, "utf-8");
+  return (0, import_node_fs30.readFileSync)(inboxPath, "utf-8");
 }
 function hasUnreadMessages(inboxPath) {
   const content = readInbox(inboxPath);
@@ -65416,11 +65752,13 @@ init_dist2();
   createWorkflowRenderer,
   customStepsFileExists,
   detectCompletion,
+  ensureLocalSdkWorkflowRuntime,
   estimateContextTokens,
   estimateTokens,
   execCustomVerification,
   executeApiStep,
   findGitRoot,
+  findLocalSdkWorkspace,
   findRelayPtyBinary,
   followLogs,
   formatDryRunReport,
@@ -65430,6 +65768,7 @@ init_dist2();
   formatResultMessage,
   formatRunSummaryTable,
   formatStepOutput,
+  formatWorkflowParseError,
   generateAgentName,
   generateErrorId,
   generateRequestId,
@@ -65486,6 +65825,7 @@ init_dist2();
   parseMessages,
   parseProposalCommand,
   parseSpawnEnv,
+  parseTsxStderr,
   parseVoteCommand,
   printUpdateNotification,
   readInbox,
@@ -65505,6 +65845,7 @@ init_dist2();
   resolveTemplateForShell,
   resolveVariables,
   routerLog,
+  runScriptWorkflow,
   runVerification,
   runWorkflow,
   scrubForChannel,