agent-relay 7.0.0 → 7.1.0

package/dist/index.cjs

@@ -801,6 +801,10 @@ var require_receiver = __commonJS({
        *     extensions
        * @param {Boolean} [options.isServer=false] Specifies whether to operate in
        *     client or server mode
+       * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+       *     buffered data chunks
+       * @param {Number} [options.maxFragments=0] The maximum number of message
+       *     fragments
        * @param {Number} [options.maxPayload=0] The maximum allowed message length
        * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
        *     not to skip UTF-8 validation for text and close messages
@@ -811,6 +815,8 @@ var require_receiver = __commonJS({
         this._binaryType = options.binaryType || BINARY_TYPES[0];
         this._extensions = options.extensions || {};
         this._isServer = !!options.isServer;
+        this._maxBufferedChunks = options.maxBufferedChunks | 0;
+        this._maxFragments = options.maxFragments | 0;
         this._maxPayload = options.maxPayload | 0;
         this._skipUTF8Validation = !!options.skipUTF8Validation;
         this[kWebSocket] = void 0;
@@ -840,6 +846,18 @@ var require_receiver = __commonJS({
        */
       _write(chunk, encoding, cb) {
         if (this._opcode === 8 && this._state == GET_INFO) return cb();
+        if (this._maxBufferedChunks > 0 && this._buffers.length >= this._maxBufferedChunks) {
+          cb(
+            this.createError(
+              RangeError,
+              "Too many buffered chunks",
+              false,
+              1008,
+              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+            )
+          );
+          return;
+        }
         this._bufferedBytes += chunk.length;
         this._buffers.push(chunk);
         this.startLoop(cb);
@@ -1169,6 +1187,17 @@ var require_receiver = __commonJS({
           return;
         }
         if (data.length) {
+          if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+            const error51 = this.createError(
+              RangeError,
+              "Too many message fragments",
+              false,
+              1008,
+              "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+            );
+            cb(error51);
+            return;
+          }
           this._messageLength = this._totalPayloadLength;
           this._fragments.push(data);
         }
@@ -1198,6 +1227,17 @@ var require_receiver = __commonJS({
               cb(error51);
               return;
             }
+            if (this._maxFragments > 0 && this._fragments.length >= this._maxFragments) {
+              const error51 = this.createError(
+                RangeError,
+                "Too many message fragments",
+                false,
+                1008,
+                "WS_ERR_TOO_MANY_BUFFERED_PARTS"
+              );
+              cb(error51);
+              return;
+            }
             this._fragments.push(buf);
           }
           this.dataMessage(cb);
@@ -2404,6 +2444,10 @@ var require_websocket = __commonJS({
        *     multiple times in the same tick
        * @param {Function} [options.generateMask] The function used to generate the
        *     masking key
+       * @param {Number} [options.maxBufferedChunks=0] The maximum number of
+       *     buffered data chunks
+       * @param {Number} [options.maxFragments=0] The maximum number of message
+       *     fragments
        * @param {Number} [options.maxPayload=0] The maximum allowed message size
        * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
        *     not to skip UTF-8 validation for text and close messages
@@ -2415,6 +2459,8 @@ var require_websocket = __commonJS({
           binaryType: this.binaryType,
           extensions: this._extensions,
           isServer: this._isServer,
+          maxBufferedChunks: options.maxBufferedChunks,
+          maxFragments: options.maxFragments,
           maxPayload: options.maxPayload,
           skipUTF8Validation: options.skipUTF8Validation
         });
@@ -2714,6 +2760,8 @@ var require_websocket = __commonJS({
         autoPong: true,
         closeTimeout: CLOSE_TIMEOUT,
         protocolVersion: protocolVersions[1],
+        maxBufferedChunks: 1024 * 1024,
+        maxFragments: 128 * 1024,
         maxPayload: 100 * 1024 * 1024,
         skipUTF8Validation: false,
         perMessageDeflate: true,
@@ -2956,6 +3004,8 @@ var require_websocket = __commonJS({
         websocket.setSocket(socket, head, {
           allowSynchronousEvents: opts.allowSynchronousEvents,
           generateMask: opts.generateMask,
+          maxBufferedChunks: opts.maxBufferedChunks,
+          maxFragments: opts.maxFragments,
           maxPayload: opts.maxPayload,
           skipUTF8Validation: opts.skipUTF8Validation
         });
@@ -3181,7 +3231,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws2.readyState === ws2.CONNECTING) {
-          ws2.once("open", function open2() {
+          ws2.once("open", function open3() {
             duplex._final(callback);
           });
           return;
@@ -3202,7 +3252,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws2.readyState === ws2.CONNECTING) {
-          ws2.once("open", function open2() {
+          ws2.once("open", function open3() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3298,6 +3348,10 @@ var require_websocket_server = __commonJS({
        *     called
        * @param {Function} [options.handleProtocols] A hook to handle protocols
        * @param {String} [options.host] The hostname where to bind the server
+       * @param {Number} [options.maxBufferedChunks=1048576] The maximum number of
+       *     buffered data chunks
+       * @param {Number} [options.maxFragments=131072] The maximum number of message
+       *     fragments
        * @param {Number} [options.maxPayload=104857600] The maximum allowed message
        *     size
        * @param {Boolean} [options.noServer=false] Enable no server mode
@@ -3319,6 +3373,8 @@ var require_websocket_server = __commonJS({
         options = {
           allowSynchronousEvents: true,
           autoPong: true,
+          maxBufferedChunks: 1024 * 1024,
+          maxFragments: 128 * 1024,
           maxPayload: 100 * 1024 * 1024,
           skipUTF8Validation: false,
           perMessageDeflate: false,
@@ -3598,6 +3654,8 @@ var require_websocket_server = __commonJS({
         socket.removeListener("error", socketOnError);
         ws2.setSocket(socket, head, {
           allowSynchronousEvents: this.options.allowSynchronousEvents,
+          maxBufferedChunks: this.options.maxBufferedChunks,
+          maxFragments: this.options.maxFragments,
           maxPayload: this.options.maxPayload,
           skipUTF8Validation: this.options.skipUTF8Validation
         });
@@ -5133,18 +5191,18 @@ var require_source = __commonJS({
         }
       }
     });
-    var createStyler = (open2, close, parent) => {
+    var createStyler = (open3, close, parent) => {
       let openAll;
       let closeAll;
       if (parent === void 0) {
-        openAll = open2;
+        openAll = open3;
         closeAll = close;
       } else {
-        openAll = parent.openAll + open2;
+        openAll = parent.openAll + open3;
         closeAll = close + parent.closeAll;
       }
       return {
-        open: open2,
+        open: open3,
         close,
         openAll,
         closeAll,
@@ -13358,7 +13416,7 @@ var require_rfdc = __commonJS({
 });
 
 // node_modules/environment/index.js
-var isBrowser, isNode, isBun, isDeno, isElectron, isJsDom, isWebWorker, isDedicatedWorker, isSharedWorker, isServiceWorker, platform, isMacOs, isWindows, isLinux, isIos, isAndroid;
+var isBrowser, isNode, isBun, isDeno, isElectron, isJsDom, isWebWorker, isDedicatedWorker, isSharedWorker, isServiceWorker, platform2, isMacOs, isWindows, isLinux, isIos, isAndroid;
 var init_environment = __esm({
   "node_modules/environment/index.js"() {
     isBrowser = globalThis.window?.document !== void 0;
@@ -13371,12 +13429,12 @@ var init_environment = __esm({
     isDedicatedWorker = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
     isSharedWorker = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
     isServiceWorker = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
-    platform = globalThis.navigator?.userAgentData?.platform;
-    isMacOs = platform === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
-    isWindows = platform === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
-    isLinux = platform === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
-    isIos = platform === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
-    isAndroid = platform === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+    platform2 = globalThis.navigator?.userAgentData?.platform;
+    isMacOs = platform2 === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+    isWindows = platform2 === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+    isLinux = platform2 === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+    isIos = platform2 === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+    isAndroid = platform2 === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
   }
 });
 
@@ -13421,11 +13479,11 @@ __export(base_exports, {
   setCwd: () => setCwd,
   synchronizedOutput: () => synchronizedOutput
 });
-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 import_node_process, import_node_os14, 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_os13 = __toESM(require("node:os"), 1);
+    import_node_os14 = __toESM(require("node:os"), 1);
     init_environment();
     ESC = "\x1B[";
     OSC = "\x1B]";
@@ -13505,7 +13563,7 @@ var init_base = __esm({
       if (isBrowser || !isWindows2) {
         return false;
       }
-      const parts = import_node_os13.default.release().split(".");
+      const parts = import_node_os14.default.release().split(".");
       const major = Number(parts[0]);
       const build = Number(parts[2] ?? 0);
       if (major < 10) {
@@ -31566,12 +31624,12 @@ 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 {
-          fs15.stat(value.path, function(err, stat2) {
+          fs15.stat(value.path, function(err, stat3) {
             if (err) {
               callback(err);
               return;
             }
-            var fileSize = stat2.size - (value.start ? value.start : 0);
+            var fileSize = stat3.size - (value.start ? value.start : 0);
             callback(null, fileSize);
           });
         }
@@ -34615,14 +34673,14 @@ var require_axios = __commonJS({
       navigator: _navigator,
       origin
     });
-    var platform2 = {
+    var platform3 = {
       ...utils,
       ...platform$1
     };
     function toURLEncodedForm(data, options) {
-      return toFormData(data, new platform2.classes.URLSearchParams(), {
+      return toFormData(data, new platform3.classes.URLSearchParams(), {
         visitor: function(value, key, path29, helpers) {
-          if (platform2.isNode && utils$1.isBuffer(value)) {
+          if (platform3.isNode && utils$1.isBuffer(value)) {
             this.append(key, value.toString("base64"));
             return false;
           }
@@ -34773,8 +34831,8 @@ var require_axios = __commonJS({
       maxContentLength: -1,
       maxBodyLength: -1,
       env: {
-        FormData: platform2.classes.FormData,
-        Blob: platform2.classes.Blob
+        FormData: platform3.classes.FormData,
+        Blob: platform3.classes.Blob
       },
       validateStatus: function validateStatus(status) {
         return status >= 200 && status < 300;
@@ -34915,7 +34973,7 @@ var require_axios = __commonJS({
     }
     var DATA_URL_PATTERN = /^([^,;]+\/[^,;]+)?((?:;[^,;=]+=[^,;]+)*)(;base64)?,([\s\S]*)$/;
     function fromDataURI(uri, asBlob, options) {
-      const _Blob = options && options.Blob || platform2.classes.Blob;
+      const _Blob = options && options.Blob || platform3.classes.Blob;
       const protocol = parseProtocol(uri);
       if (asBlob === void 0 && _Blob) {
         asBlob = true;
@@ -35074,7 +35132,7 @@ var require_axios = __commonJS({
         yield blob;
       }
     };
-    var BOUNDARY_ALPHABET = platform2.ALPHABET.ALPHA_DIGIT + "-_";
+    var BOUNDARY_ALPHABET = platform3.ALPHABET.ALPHA_DIGIT + "-_";
     var textEncoder = typeof TextEncoder === "function" ? new TextEncoder() : new util2.TextEncoder();
     var CRLF = "\r\n";
     var CRLF_BYTES = textEncoder.encode(CRLF);
@@ -35122,7 +35180,7 @@ var require_axios = __commonJS({
       const {
         tag = "form-data-boundary",
         size = 25,
-        boundary = tag + "-" + platform2.generateString(size, BOUNDARY_ALPHABET)
+        boundary = tag + "-" + platform3.generateString(size, BOUNDARY_ALPHABET)
       } = options || {};
       if (!utils$1.isFormData(form)) {
         throw TypeError("FormData instance required");
@@ -35522,7 +35580,7 @@ var require_axios = __commonJS({
       cache.set(key, agent);
       return agent;
     }
-    var supportedProtocols = platform2.protocols.map((protocol) => {
+    var supportedProtocols = platform3.protocols.map((protocol) => {
       return protocol + ":";
     });
     var decodeURIComponentSafe = (value) => {
@@ -35883,7 +35941,7 @@ var require_axios = __commonJS({
           }
         });
         const fullPath = buildFullPath(config2.baseURL, config2.url, config2.allowAbsoluteUrls);
-        const parsed = new URL(fullPath, platform2.hasBrowserEnv ? platform2.origin : void 0);
+        const parsed = new URL(fullPath, platform3.hasBrowserEnv ? platform3.origin : void 0);
         const protocol = parsed.protocol || supportedProtocols[0];
         if (protocol === "data:") {
           if (config2.maxContentLength > -1) {
@@ -36284,11 +36342,11 @@ var require_axios = __commonJS({
         }
       });
     };
-    var isURLSameOrigin = platform2.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url3) => {
-      url3 = new URL(url3, platform2.origin);
+    var isURLSameOrigin = platform3.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url3) => {
+      url3 = new URL(url3, platform3.origin);
       return origin2.protocol === url3.protocol && origin2.host === url3.host && (isMSIE || origin2.port === url3.port);
-    })(new URL(platform2.origin), platform2.navigator && /(msie|trident)/i.test(platform2.navigator.userAgent)) : () => true;
-    var cookies = platform2.hasStandardBrowserEnv ? (
+    })(new URL(platform3.origin), platform3.navigator && /(msie|trident)/i.test(platform3.navigator.userAgent)) : () => true;
+    var cookies = platform3.hasStandardBrowserEnv ? (
       // Standard browser envs support document.cookie
       {
         write(name, value, expires, path29, domain2, secure, sameSite) {
@@ -36468,13 +36526,13 @@ var require_axios = __commonJS({
         headers.set("Authorization", "Basic " + btoa((auth.username || "") + ":" + (auth.password ? encodeUTF8(auth.password) : "")));
       }
       if (utils$1.isFormData(data)) {
-        if (platform2.hasStandardBrowserEnv || platform2.hasStandardBrowserWebWorkerEnv) {
+        if (platform3.hasStandardBrowserEnv || platform3.hasStandardBrowserWebWorkerEnv) {
           headers.setContentType(void 0);
         } else if (utils$1.isFunction(data.getHeaders)) {
           setFormDataHeaders(headers, data.getHeaders(), own2("formDataHeaderPolicy"));
         }
       }
-      if (platform2.hasStandardBrowserEnv) {
+      if (platform3.hasStandardBrowserEnv) {
         if (utils$1.isFunction(withXSRFToken)) {
           withXSRFToken = withXSRFToken(newConfig);
         }
@@ -36610,7 +36668,7 @@ var require_axios = __commonJS({
           }
         }
         const protocol = parseProtocol(_config.url);
-        if (protocol && !platform2.protocols.includes(protocol)) {
+        if (protocol && !platform3.protocols.includes(protocol)) {
           reject(new AxiosError("Unsupported protocol " + protocol + ":", AxiosError.ERR_BAD_REQUEST, config2));
           return;
         }
@@ -36773,7 +36831,7 @@ var require_axios = __commonJS({
       const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder2()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
       const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
         let duplexAccessed = false;
-        const request = new Request(platform2.origin, {
+        const request = new Request(platform3.origin, {
           body: new ReadableStream2(),
           method: "POST",
           get duplex() {
@@ -36810,7 +36868,7 @@ var require_axios = __commonJS({
           return body.size;
         }
         if (utils$1.isSpecCompliantForm(body)) {
-          const _request = new Request(platform2.origin, {
+          const _request = new Request(platform3.origin, {
             method: "POST",
             body
           });
@@ -43561,6 +43619,7 @@ __export(index_exports, {
   checkOutputContains: () => checkOutputContains,
   cleanLines: () => cleanLines,
   clearBinaryCache: () => clearBinaryCache,
+  clearBrokerLogs: () => clearBrokerLogs,
   clearResolveCache: () => clearResolveCache,
   collectCliSession: () => collectCliSession,
   collectOutput: () => collectOutput,
@@ -43614,6 +43673,7 @@ __export(index_exports, {
   generateUniqueAgentName: () => generateUniqueAgentName,
   getAgentName: () => getAgentName,
   getBaseCli: () => getBaseCli,
+  getBrokerLogDir: () => getBrokerLogDir,
   getCachedRelayPtyPath: () => getCachedRelayPtyPath,
   getCliDefinition: () => getCliDefinition,
   getCliRegistry: () => getCliRegistry,
@@ -43657,6 +43717,7 @@ __export(index_exports, {
   isTrajectoryTrackingAvailable: () => isTrajectoryTrackingAvailable,
   isValidAgentName: () => isValidAgentName,
   isWorktreeStep: () => isWorktreeStep,
+  listBrokerLogs: () => listBrokerLogs,
   listLoggedAgents: () => listLoggedAgents,
   listPersonas: () => listPersonas,
   listWorkflowSchedules: () => listWorkflowSchedules,
@@ -43672,6 +43733,7 @@ __export(index_exports, {
   parseTsxStderr: () => parseTsxStderr,
   parseVoteCommand: () => parseVoteCommand,
   printUpdateNotification: () => printUpdateNotification,
+  pruneBrokerLogs: () => pruneBrokerLogs,
   readInbox: () => readInbox,
   resetPatternMetrics: () => resetPatternMetrics,
   resolveAllCustomSteps: () => resolveAllCustomSteps,
@@ -43704,6 +43766,7 @@ __export(index_exports, {
   stripAnsi: () => stripAnsi,
   stripAnsiFast: () => stripAnsiFast,
   stripInjectedTaskEcho: () => stripInjectedTaskEcho,
+  tailBrokerLog: () => tailBrokerLog,
   toReleaseResult: () => toReleaseResult,
   toSpawnResult: () => toSpawnResult,
   trackPatternPerformance: () => trackPatternPerformance,
@@ -44235,8 +44298,8 @@ var import_node_child_process = require("node:child_process");
 var import_node_module = require("node:module");
 var import_node_url = require("node:url");
 var BROKER_NAME = "agent-relay-broker";
-function getOptionalDepPackageName(platform2 = process.platform, arch = process.arch) {
-  return `@agent-relay/broker-${platform2}-${arch}`;
+function getOptionalDepPackageName(platform3 = process.platform, arch = process.arch) {
+  return `@agent-relay/broker-${platform3}-${arch}`;
 }
 function addUniquePath(paths, candidate) {
   if (!candidate || paths.includes(candidate)) {
@@ -44426,10 +44489,18 @@ function formatBrokerNotFoundError() {
 
 // packages/sdk/dist/event-bus.js
 var EventBus = class {
+  // Stored type uses `unknown` for `R` so a single Set can hold handlers
+  // from any overload — the dispatcher casts back when it cares about a
+  // non-void return value (see `runBeforeSpawn` in `client.ts`).
   handlers = /* @__PURE__ */ new Map();
   /**
    * Register a handler for `event`. Returns an unsubscribe function that
    * removes the handler when called.
+   *
+   * The `R` generic is inferred from the handler return type; callers
+   * that don't care about the return get the default `void` shape, while
+   * events like `beforeAgentSpawn` can pass handlers that return a
+   * `SpawnPatch`.
    */
   addListener(event, handler) {
     let set2 = this.handlers.get(event);
@@ -44510,7 +44581,8 @@ function buildSpawnPtyBody(input) {
     ...input.continueFrom !== void 0 ? { continueFrom: input.continueFrom } : {},
     ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
     ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
-    ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {}
+    ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {},
+    ...input.agentResultSchema !== void 0 ? { agentResultSchema: input.agentResultSchema } : {}
   };
 }
 function buildSpawnProviderBody(input, transport) {
@@ -44530,6 +44602,7 @@ function buildSpawnProviderBody(input, transport) {
     ...input.idleThresholdSecs !== void 0 ? { idleThresholdSecs: input.idleThresholdSecs } : {},
     ...input.restartPolicy !== void 0 ? { restartPolicy: input.restartPolicy } : {},
     ...input.skipRelayPrompt !== void 0 ? { skipRelayPrompt: input.skipRelayPrompt } : {},
+    ...input.agentResultSchema !== void 0 ? { agentResultSchema: input.agentResultSchema } : {},
     transport
   };
 }
@@ -44569,6 +44642,8 @@ var AgentRelayClient = class _AgentRelayClient {
   child = null;
   /** Lease renewal timer (only for spawned brokers). */
   leaseTimer = null;
+  brokerExitInfo = null;
+  brokerExitListeners = /* @__PURE__ */ new Set();
   workspaceKey;
   /** Resolved broker URL — captured so call-site lifecycle contexts can surface it. */
   baseUrl;
@@ -44584,16 +44659,9 @@ var AgentRelayClient = class _AgentRelayClient {
       requestTimeoutMs: options.requestTimeoutMs
     });
   }
-  /**
-   * Register a listener on the client's event bus. Returns an unsubscribe
-   * function. Equivalent to `client.eventBus.addListener(...)` but mirrors
-   * the `AgentRelay` facade API so direct-client callers don't need to
-   * reach through `.eventBus`.
-   */
   addListener(event, handler) {
     return this.eventBus.addListener(event, handler);
   }
-  /** Remove a previously-registered listener. */
   removeListener(event, handler) {
     this.eventBus.removeListener(event, handler);
   }
@@ -44714,6 +44782,7 @@ var AgentRelayClient = class _AgentRelayClient {
       ...options?.eventBus ? { eventBus: options.eventBus } : {}
     });
     client.child = child;
+    client.installManagedBrokerExitHandler(child, stderrLines);
     const brokerExited = new Promise((_2, reject) => {
       child.once("exit", (code) => {
         reject(new Error(formatBrokerStartupError(`Broker process exited with code ${code} during initial handshake`, child, { binaryPath, args, cwd, stdoutLines, stderrLines })));
@@ -44734,18 +44803,13 @@ var AgentRelayClient = class _AgentRelayClient {
         await new Promise((resolve4) => setTimeout(resolve4, 1e3));
       }
     }
-    client.connectEvents();
-    client.leaseTimer = setInterval(() => {
-      client.renewLease().catch(() => {
-      });
-    }, 6e4);
-    child.on("exit", () => {
-      client.disconnectEvents();
-      if (client.leaseTimer) {
-        clearInterval(client.leaseTimer);
-        client.leaseTimer = null;
-      }
-    });
+    if (!client.brokerExitInfo) {
+      client.connectEvents();
+      client.leaseTimer = setInterval(() => {
+        client.renewLease().catch(() => {
+        });
+      }, 6e4);
+    }
     return client;
   }
   /** PID of the managed broker process, if spawned locally. */
@@ -44771,6 +44835,33 @@ var AgentRelayClient = class _AgentRelayClient {
   onEvent(listener) {
     return this.transport.onEvent(listener);
   }
+  /**
+   * Subscribe to managed broker child-process exit.
+   *
+   * Clients created with `new AgentRelayClient(...)` or `connect()` do not own a
+   * broker child process, so this is a no-op for them.
+   */
+  onBrokerExit(listener) {
+    if (!this.child && !this.brokerExitInfo) {
+      return () => {
+      };
+    }
+    this.brokerExitListeners.add(listener);
+    if (this.brokerExitInfo) {
+      const info = cloneBrokerExitInfo(this.brokerExitInfo);
+      queueMicrotask(() => {
+        if (this.brokerExitListeners.has(listener)) {
+          try {
+            listener(info);
+          } catch {
+          }
+        }
+      });
+    }
+    return () => {
+      this.brokerExitListeners.delete(listener);
+    };
+  }
   queryEvents(filter) {
     return this.transport.queryEvents(filter);
   }
@@ -45087,6 +45178,40 @@ var AgentRelayClient = class _AgentRelayClient {
   async getConfig() {
     return this.transport.request("/api/config");
   }
+  notifyBrokerExit(info) {
+    if (this.brokerExitInfo)
+      return;
+    this.brokerExitInfo = cloneBrokerExitInfo(info);
+    for (const listener of this.brokerExitListeners) {
+      try {
+        listener(cloneBrokerExitInfo(info));
+      } catch {
+      }
+    }
+  }
+  installManagedBrokerExitHandler(child, stderrLines) {
+    const handleExit = (code, signal) => {
+      this.notifyBrokerExit({
+        code,
+        signal,
+        pid: child.pid,
+        recentStderr: [...stderrLines]
+      });
+      this.disconnectEvents();
+      if (this.leaseTimer) {
+        clearInterval(this.leaseTimer);
+        this.leaseTimer = null;
+      }
+      if (this.child === child) {
+        this.child = null;
+      }
+    };
+    if (child.exitCode !== null || child.signalCode !== null) {
+      handleExit(child.exitCode, child.signalCode);
+      return;
+    }
+    child.once("exit", handleExit);
+  }
 };
 async function waitForApiUrl(child, timeoutMs, debug) {
   const { createInterface: createInterface2 } = await import("node:readline");
@@ -45150,6 +45275,12 @@ function pushBufferedLine(lines, line) {
     lines.splice(0, lines.length - 40);
   }
 }
+function cloneBrokerExitInfo(info) {
+  return {
+    ...info,
+    recentStderr: [...info.recentStderr]
+  };
+}
 function formatBrokerStartupError(message, child, debug) {
   const details = [
     `pid=${child.pid ?? "unknown"}`,
@@ -70714,27 +70845,9 @@ var AgentRelay = class {
    * the same events.
    */
   bus = new EventBus();
-  // ── Listener registration ───────────────────────────────────────────────
-  /**
-   * Register a listener for a relay lifecycle event. Returns an
-   * unsubscribe function.
-   *
-   * Example:
-   * ```ts
-   * const off = relay.addListener('agentSpawned', (agent) => console.log(agent.name));
-   * // later:
-   * off();
-   * ```
-   *
-   * Replaces the pre-2.x single-callback `on*` fields. Multiple listeners
-   * can register for the same event; they fire sequentially in
-   * registration order. Async handlers are awaited. Handler exceptions
-   * are caught and logged; one bad listener never blocks the others.
-   */
   addListener(event, handler) {
     return this.bus.addListener(event, handler);
   }
-  /** Remove a previously-registered listener. Idempotent. */
   removeListener(event, handler) {
     this.bus.removeListener(event, handler);
   }
@@ -70774,6 +70887,10 @@ var AgentRelay = class {
   deliveryStates = /* @__PURE__ */ new Map();
   agentActivityStates = /* @__PURE__ */ new Map();
   outputListeners = /* @__PURE__ */ new Map();
+  resultContracts = /* @__PURE__ */ new Map();
+  lastAgentResults = /* @__PURE__ */ new Map();
+  resultResolvers = /* @__PURE__ */ new Map();
+  resultResolverSeq = 0;
   exitResolvers = /* @__PURE__ */ new Map();
   exitResolverSeq = 0;
   idleResolvers = /* @__PURE__ */ new Map();
@@ -70919,6 +71036,10 @@ var AgentRelay = class {
     };
     await this.invokeLifecycleHook(input.onStart, lifecycleContext, `spawnPty("${input.name}") onStart`);
     let result;
+    const resultContract = this.prepareAgentResultContract(input.result);
+    if (resultContract) {
+      this.resultContracts.set(input.name, resultContract);
+    }
     try {
       result = await client.spawnPty({
         name: input.name,
@@ -70934,9 +71055,13 @@ var AgentRelay = class {
         shadowMode: input.shadowMode,
         idleThresholdSecs: input.idleThresholdSecs,
         restartPolicy: input.restartPolicy,
-        skipRelayPrompt: input.skipRelayPrompt
+        skipRelayPrompt: input.skipRelayPrompt,
+        agentResultSchema: resultContract?.jsonSchema
       });
     } catch (error51) {
+      if (resultContract) {
+        this.resultContracts.delete(input.name);
+      }
       await this.invokeLifecycleHook(input.onError, {
         ...lifecycleContext,
         error: error51
@@ -70944,6 +71069,10 @@ var AgentRelay = class {
       throw error51;
     }
     this.resetAgentLifecycleState(result.name);
+    if (result.name !== input.name && resultContract) {
+      this.resultContracts.delete(input.name);
+      this.resultContracts.set(result.name, resultContract);
+    }
     const agent = this.makeAgent(result.name, result.runtime, channels);
     this.knownAgents.set(agent.name, agent);
     await this.invokeLifecycleHook(input.onSuccess, {
@@ -70969,6 +71098,7 @@ var AgentRelay = class {
       idleThresholdSecs: options?.idleThresholdSecs,
       restartPolicy: options?.restartPolicy,
       skipRelayPrompt: options?.skipRelayPrompt,
+      result: options?.result,
       onStart: options?.onStart,
       onSuccess: options?.onSuccess,
       onError: options?.onError
@@ -71037,6 +71167,7 @@ var AgentRelay = class {
         idleThresholdSecs: options.idleThresholdSecs,
         restartPolicy: options.restartPolicy,
         skipRelayPrompt: options.skipRelayPrompt,
+        result: options.result,
         onStart: options.onStart,
         onSuccess: options.onSuccess,
         onError: options.onError
@@ -71395,6 +71526,15 @@ var AgentRelay = class {
       entry.resolve("exited");
     }
     this.idleResolvers.clear();
+    const shutdownError = new Error("AgentRelay shutdown before structured result was submitted");
+    for (const waiters of this.resultResolvers.values()) {
+      for (const waiter of waiters) {
+        waiter.reject(shutdownError);
+      }
+    }
+    this.resultResolvers.clear();
+    this.resultContracts.clear();
+    this.lastAgentResults.clear();
   }
   // ── Private helpers ─────────────────────────────────────────────────────
   ensureAgentHandle(name, runtime = "pty", channels = []) {
@@ -71652,10 +71792,14 @@ var AgentRelay = class {
           void this.bus.emit("agentReleased", agent);
           this.knownAgents.delete(event.name);
           this.outputListeners.delete(event.name);
+          this.resultContracts.delete(event.name);
           this.exitResolvers.get(event.name)?.resolve("released");
           this.exitResolvers.delete(event.name);
           this.idleResolvers.get(event.name)?.resolve("exited");
           this.idleResolvers.delete(event.name);
+          for (const waiter of this.takeResultResolvers(event.name)) {
+            waiter.reject(new Error(`Agent '${event.name}' was released before submitting a result`));
+          }
           break;
         }
         case "agent_exited": {
@@ -71673,10 +71817,14 @@ var AgentRelay = class {
           void this.bus.emit("agentExited", agent);
           this.knownAgents.delete(event.name);
           this.outputListeners.delete(event.name);
+          this.resultContracts.delete(event.name);
           this.exitResolvers.get(event.name)?.resolve("exited");
           this.exitResolvers.delete(event.name);
           this.idleResolvers.get(event.name)?.resolve("exited");
           this.idleResolvers.delete(event.name);
+          for (const waiter of this.takeResultResolvers(event.name)) {
+            waiter.reject(new Error(`Agent '${event.name}' exited before submitting a result`));
+          }
           break;
         }
         case "agent_exit": {
@@ -71765,12 +71913,141 @@ var AgentRelay = class {
           this.idleResolvers.delete(event.name);
           break;
         }
+        case "agent_result": {
+          this.dispatchAgentResult(event.name, {
+            name: event.name,
+            resultId: event.result_id,
+            data: event.data,
+            final: event.final,
+            metadata: event.metadata ?? void 0
+          });
+          break;
+        }
       }
       if (event.kind.startsWith("delivery_") || event.kind.startsWith("message_delivery_")) {
         void this.bus.emit("deliveryUpdate", event);
       }
     });
   }
+  prepareAgentResultContract(options) {
+    if (!options) {
+      return void 0;
+    }
+    return {
+      schema: options.schema,
+      jsonSchema: options.jsonSchema ?? this.schemaToJsonSchema(options.schema),
+      onResult: options.onResult
+    };
+  }
+  schemaToJsonSchema(schema) {
+    if (schema && typeof schema === "object" && this.isZodSchema(schema)) {
+      return zodToJsonSchema(schema, { target: "jsonSchema7" });
+    }
+    return true;
+  }
+  isZodSchema(schema) {
+    return "_def" in schema && typeof schema.safeParse === "function";
+  }
+  validateAgentResult(contract, value) {
+    const schema = contract?.schema;
+    if (!schema) {
+      return value;
+    }
+    if (typeof schema === "function") {
+      return schema(value);
+    }
+    if (typeof schema.safeParse === "function") {
+      const parsed = schema.safeParse(value);
+      if (parsed.success) {
+        return parsed.data;
+      }
+      throw new Error(`Agent result failed schema validation: ${String(parsed.error)}`);
+    }
+    if (typeof schema.parse === "function") {
+      return schema.parse(value);
+    }
+    return value;
+  }
+  takeResultResolvers(name) {
+    const waiters = this.resultResolvers.get(name);
+    if (!waiters || waiters.length === 0)
+      return [];
+    this.resultResolvers.delete(name);
+    return waiters;
+  }
+  dispatchAgentResult(name, raw) {
+    const contract = this.resultContracts.get(name);
+    let result;
+    try {
+      const data = this.validateAgentResult(contract, raw.data);
+      result = { ...raw, data };
+    } catch (error51) {
+      const err = error51 instanceof Error ? error51 : new Error(String(error51));
+      for (const waiter of this.takeResultResolvers(name))
+        waiter.reject(err);
+      console.warn(`[AgentRelay] structured result from "${name}" failed validation`, err);
+      return;
+    }
+    void this.bus.emit("agentResult", result);
+    if (contract?.onResult) {
+      Promise.resolve(contract.onResult(result.data, result)).catch((error51) => {
+        console.warn(`[AgentRelay] result("${name}") onResult hook threw`, error51);
+      });
+    }
+    if (result.final) {
+      this.lastAgentResults.set(name, result);
+      for (const waiter of this.takeResultResolvers(name))
+        waiter.resolve(result);
+    }
+  }
+  waitForAgentResult(name, timeoutMs) {
+    const existing = this.lastAgentResults.get(name);
+    if (existing) {
+      return Promise.resolve(existing);
+    }
+    if (!this.knownAgents.has(name) && !this.resultContracts.has(name)) {
+      return Promise.reject(new Error(`Agent '${name}' is not running and has no structured result`));
+    }
+    if (timeoutMs === 0) {
+      return Promise.reject(new Error(`Timed out waiting for structured result from '${name}'`));
+    }
+    return new Promise((resolve4, reject) => {
+      let timer;
+      const token = ++this.resultResolverSeq;
+      const waiter = {
+        resolve: (result) => {
+          if (timer)
+            clearTimeout(timer);
+          resolve4(result);
+        },
+        reject: (error51) => {
+          if (timer)
+            clearTimeout(timer);
+          reject(error51);
+        },
+        token
+      };
+      const existingWaiters = this.resultResolvers.get(name);
+      if (existingWaiters) {
+        existingWaiters.push(waiter);
+      } else {
+        this.resultResolvers.set(name, [waiter]);
+      }
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          const list = this.resultResolvers.get(name);
+          if (list) {
+            const idx = list.findIndex((w2) => w2.token === token);
+            if (idx >= 0)
+              list.splice(idx, 1);
+            if (list.length === 0)
+              this.resultResolvers.delete(name);
+          }
+          reject(new Error(`Timed out waiting for structured result from '${name}' after ${timeoutMs}ms`));
+        }, timeoutMs);
+      }
+    });
+  }
   makeAgent(name, runtime, channels) {
     const relay = this;
     let agentChannels = [...channels];
@@ -71819,6 +72096,11 @@ var AgentRelay = class {
             relay.exitResolvers.delete(name);
             relay.idleResolvers.get(name)?.resolve("exited");
             relay.idleResolvers.delete(name);
+            relay.resultContracts.delete(name);
+            relay.lastAgentResults.delete(name);
+            for (const waiter of relay.takeResultResolvers(name)) {
+              waiter.reject(new Error(`Agent '${name}' was released before submitting a result`));
+            }
             await relay.invokeLifecycleHook(releaseOptions.onSuccess, releaseContext, `release("${name}") onSuccess`);
             return;
           }
@@ -71894,6 +72176,9 @@ var AgentRelay = class {
           }
         });
       },
+      waitForResult(timeoutMs) {
+        return relay.waitForAgentResult(name, timeoutMs);
+      },
       async sendMessage(input) {
         const client = await relay.ensureStarted();
         let result;
@@ -71979,6 +72264,7 @@ var AgentRelay = class {
             idleThresholdSecs: options?.idleThresholdSecs,
             agentToken: options?.agentToken,
             skipRelayPrompt: options?.skipRelayPrompt,
+            result: options?.result,
             onStart: options?.onStart,
             onSuccess: options?.onSuccess,
             onError: options?.onError
@@ -71993,6 +72279,10 @@ var AgentRelay = class {
         };
         await this.invokeLifecycleHook(options?.onStart, lifecycleContext, `spawn("${name}") onStart`);
         let result;
+        const resultContract = this.prepareAgentResultContract(options?.result);
+        if (resultContract) {
+          this.resultContracts.set(name, resultContract);
+        }
         try {
           result = await client.spawnProvider({
             name,
@@ -72005,9 +72295,13 @@ var AgentRelay = class {
             cwd: options?.cwd,
             idleThresholdSecs: options?.idleThresholdSecs,
             agentToken: options?.agentToken,
-            skipRelayPrompt: options?.skipRelayPrompt
+            skipRelayPrompt: options?.skipRelayPrompt,
+            agentResultSchema: resultContract?.jsonSchema
           });
         } catch (error51) {
+          if (resultContract) {
+            this.resultContracts.delete(name);
+          }
           await this.invokeLifecycleHook(options?.onError, {
             ...lifecycleContext,
             error: error51
@@ -72015,6 +72309,10 @@ var AgentRelay = class {
           throw error51;
         }
         this.resetAgentLifecycleState(result.name);
+        if (result.name !== name && resultContract) {
+          this.resultContracts.delete(name);
+          this.resultContracts.set(result.name, resultContract);
+        }
         const agent = this.makeAgent(result.name, result.runtime, channels);
         this.knownAgents.set(agent.name, agent);
         await this.invokeLifecycleHook(options?.onSuccess, {
@@ -72042,6 +72340,10 @@ var AgentRelay = class {
     this.exitedAgents.delete(name);
     this.idleAgents.delete(name);
     this.agentActivityStates.delete(name);
+    this.lastAgentResults.delete(name);
+    for (const waiter of this.takeResultResolvers(name)) {
+      waiter.reject(new Error(`Agent '${name}' lifecycle reset before structured result was submitted`));
+    }
   }
   normalizeReleaseOptions(reasonOrOptions) {
     if (typeof reasonOrOptions === "string" || reasonOrOptions === void 0) {
@@ -72051,6 +72353,161 @@ var AgentRelay = class {
   }
 };
 
+// packages/sdk/dist/broker-logs.js
+var import_node_os4 = require("node:os");
+var import_node_path8 = require("node:path");
+var import_promises2 = require("node:fs/promises");
+var LOG_NAME_PATTERN = /^(?<brokerId>.+)\.log(?:\.(?<date>\d{4}-\d{2}-\d{2}))?$/;
+function getBrokerLogDir() {
+  const home = (0, import_node_os4.homedir)();
+  switch ((0, import_node_os4.platform)()) {
+    case "darwin":
+      return (0, import_node_path8.join)(home, "Library", "Logs", "agent-relay");
+    case "win32": {
+      const localAppData = process.env.LOCALAPPDATA ?? (0, import_node_path8.join)(home, "AppData", "Local");
+      return (0, import_node_path8.join)(localAppData, "agent-relay", "Logs");
+    }
+    default: {
+      const stateHome = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.length > 0 ? process.env.XDG_STATE_HOME : (0, import_node_path8.join)(home, ".local", "state");
+      return (0, import_node_path8.join)(stateHome, "agent-relay", "logs");
+    }
+  }
+}
+async function listBrokerLogs(dir) {
+  const logDir = dir ?? getBrokerLogDir();
+  let entries;
+  try {
+    entries = await (0, import_promises2.readdir)(logDir);
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    throw err;
+  }
+  const files = [];
+  for (const name of entries) {
+    const match = LOG_NAME_PATTERN.exec(name);
+    if (!match || !match.groups)
+      continue;
+    const fullPath = (0, import_node_path8.join)(logDir, name);
+    let info;
+    try {
+      info = await (0, import_promises2.stat)(fullPath);
+    } catch {
+      continue;
+    }
+    if (!info.isFile())
+      continue;
+    files.push({
+      path: fullPath,
+      name,
+      brokerId: match.groups.brokerId,
+      date: match.groups.date ?? null,
+      size: info.size,
+      mtime: info.mtime
+    });
+  }
+  files.sort((a, b2) => b2.mtime.getTime() - a.mtime.getTime());
+  return files;
+}
+async function tailBrokerLog(brokerId, options = {}) {
+  const lines = options.lines ?? 200;
+  const files = (await listBrokerLogs(options.dir)).filter((f2) => f2.brokerId === brokerId);
+  if (files.length === 0)
+    return null;
+  const target = files[0];
+  return { path: target.path, content: await tailFile2(target.path, lines) };
+}
+async function pruneBrokerLogs(options = {}) {
+  const keepDays = options.keepDays ?? 7;
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1e3;
+  const files = await listBrokerLogs(options.dir);
+  const removed = [];
+  const kept = [];
+  for (const file2 of files) {
+    if (options.brokerId && file2.brokerId !== options.brokerId) {
+      kept.push(file2);
+      continue;
+    }
+    if (file2.date === null) {
+      kept.push(file2);
+      continue;
+    }
+    if (file2.mtime.getTime() >= cutoff) {
+      kept.push(file2);
+      continue;
+    }
+    if (!options.dryRun) {
+      try {
+        await (0, import_promises2.unlink)(file2.path);
+      } catch (err) {
+        if (err.code !== "ENOENT")
+          throw err;
+      }
+    }
+    removed.push(file2);
+  }
+  return { removed, kept };
+}
+async function clearBrokerLogs(options = {}) {
+  const files = await listBrokerLogs(options.dir);
+  const target = options.brokerId ? files.filter((f2) => f2.brokerId === options.brokerId) : files;
+  if (options.dryRun)
+    return target;
+  for (const file2 of target) {
+    try {
+      await (0, import_promises2.unlink)(file2.path);
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+    }
+  }
+  return target;
+}
+async function tailFile2(filePath, lines) {
+  const CHUNK = 8192;
+  let fh;
+  try {
+    fh = await (0, import_promises2.open)(filePath, "r");
+    const { size } = await fh.stat();
+    if (size === 0)
+      return "";
+    if (size <= CHUNK) {
+      const buf = Buffer.alloc(size);
+      await fh.read(buf, 0, size, 0);
+      return tailLines(buf.toString("utf-8"), lines);
+    }
+    const chunks = [];
+    let position = size;
+    let newlines = 0;
+    while (position > 0 && newlines <= lines) {
+      const readSize = Math.min(CHUNK, position);
+      position -= readSize;
+      const buf = Buffer.alloc(readSize);
+      await fh.read(buf, 0, readSize, position);
+      chunks.unshift(buf);
+      newlines += countNewlines(buf);
+    }
+    const combined = Buffer.concat(chunks).toString("utf-8");
+    return tailLines(combined, lines);
+  } finally {
+    if (fh)
+      await fh.close();
+  }
+}
+function tailLines(text, count) {
+  const split = text.split("\n");
+  if (split.length > 0 && split[split.length - 1] === "")
+    split.pop();
+  return split.slice(-count).join("\n");
+}
+function countNewlines(buf) {
+  let n = 0;
+  for (const byte of buf)
+    if (byte === 10)
+      n++;
+  return n;
+}
+
 // packages/sdk/dist/consensus.js
 var import_node_crypto3 = require("node:crypto");
 var import_node_events = require("node:events");
@@ -72905,9 +73362,9 @@ function isRestrictedAgent(agent) {
 var import_node_child_process8 = require("node:child_process");
 var import_node_crypto8 = require("node:crypto");
 var import_node_fs21 = require("node:fs");
-var import_promises8 = require("node:fs/promises");
-var import_node_os9 = require("node:os");
-var import_node_path29 = __toESM(require("node:path"), 1);
+var import_promises9 = require("node:fs/promises");
+var import_node_os10 = require("node:os");
+var import_node_path30 = __toESM(require("node:path"), 1);
 var import_chalk = __toESM(require_source(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
 var import_yaml2 = __toESM(require_dist(), 1);
@@ -73108,10 +73565,10 @@ async function spawnFromEnv(options = {}) {
 
 // packages/sdk/dist/cli-resolver.js
 var import_node_child_process4 = require("node:child_process");
-var import_promises2 = require("node:fs/promises");
+var import_promises3 = require("node:fs/promises");
 var import_node_fs5 = require("node:fs");
-var import_node_path8 = require("node:path");
-var import_node_os4 = require("node:os");
+var import_node_path9 = require("node:path");
+var import_node_os5 = require("node:os");
 var import_node_util2 = require("node:util");
 var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process4.execFile);
 var resolveCache = /* @__PURE__ */ new Map();
@@ -73120,7 +73577,7 @@ function clearResolveCache() {
 }
 function expandHome2(p2) {
   if (p2.startsWith("~/")) {
-    return (0, import_node_path8.join)((0, import_node_os4.homedir)(), p2.slice(2));
+    return (0, import_node_path9.join)((0, import_node_os5.homedir)(), p2.slice(2));
   }
   return p2;
 }
@@ -73149,9 +73606,9 @@ async function resolveCli(cli) {
       if (seen.has(expanded))
         continue;
       seen.add(expanded);
-      const candidate = (0, import_node_path8.join)(expanded, binary);
+      const candidate = (0, import_node_path9.join)(expanded, binary);
       try {
-        await (0, import_promises2.access)(candidate, import_promises2.constants.X_OK);
+        await (0, import_promises3.access)(candidate, import_promises3.constants.X_OK);
         const result = { binary, path: candidate };
         resolveCache.set(cli, result);
         return result;
@@ -73188,7 +73645,7 @@ function resolveCliSync(cli) {
       if (seen.has(expanded))
         continue;
       seen.add(expanded);
-      const candidate = (0, import_node_path8.join)(expanded, binary);
+      const candidate = (0, import_node_path9.join)(expanded, binary);
       try {
         (0, import_node_fs5.accessSync)(candidate, import_node_fs5.constants.X_OK);
         const result = { binary, path: candidate };
@@ -73295,11 +73752,11 @@ function isProxyEnabled(agentDef, swarmConfig) {
 
 // packages/sdk/dist/workflows/custom-steps.js
 var import_node_fs6 = require("node:fs");
-var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
 var import_yaml = __toESM(require_dist(), 1);
 var CUSTOM_STEPS_FILE = ".relay/steps.yaml";
 function loadCustomSteps(cwd) {
-  const stepsPath = import_node_path9.default.join(cwd, CUSTOM_STEPS_FILE);
+  const stepsPath = import_node_path10.default.join(cwd, CUSTOM_STEPS_FILE);
   const steps = /* @__PURE__ */ new Map();
   if (!(0, import_node_fs6.existsSync)(stepsPath)) {
     return steps;
@@ -73555,20 +74012,20 @@ function resolveAllCustomSteps(steps, customSteps) {
   return steps.map((step) => resolveCustomStep(step, customSteps));
 }
 function customStepsFileExists(cwd) {
-  return (0, import_node_fs6.existsSync)(import_node_path9.default.join(cwd, CUSTOM_STEPS_FILE));
+  return (0, import_node_fs6.existsSync)(import_node_path10.default.join(cwd, CUSTOM_STEPS_FILE));
 }
 function getCustomStepsPath(cwd) {
-  return import_node_path9.default.join(cwd, CUSTOM_STEPS_FILE);
+  return import_node_path10.default.join(cwd, CUSTOM_STEPS_FILE);
 }
 
 // packages/sdk/dist/provisioner/index.js
 var import_node_fs16 = require("node:fs");
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
 
 // packages/sdk/dist/provisioner/audit.js
-var import_promises3 = require("node:fs/promises");
-var import_node_path10 = __toESM(require("node:path"), 1);
-var DEFAULT_PERMISSION_AUDIT_RELATIVE_PATH = import_node_path10.default.join(".agent-relay", "permission-audit.json");
+var import_promises4 = require("node:fs/promises");
+var import_node_path11 = __toESM(require("node:path"), 1);
+var DEFAULT_PERMISSION_AUDIT_RELATIVE_PATH = import_node_path11.default.join(".agent-relay", "permission-audit.json");
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -73591,7 +74048,7 @@ function sanitizeJsonValue(value, key) {
   return String(value);
 }
 function getDefaultPermissionAuditPath(projectDir) {
-  return import_node_path10.default.resolve(projectDir, DEFAULT_PERMISSION_AUDIT_RELATIVE_PATH);
+  return import_node_path11.default.resolve(projectDir, DEFAULT_PERMISSION_AUDIT_RELATIVE_PATH);
 }
 var PermissionAuditLog = class {
   entries = [];
@@ -73616,8 +74073,8 @@ var PermissionAuditLog = class {
     };
   }
   async writeTo(filePath) {
-    await (0, import_promises3.mkdir)(import_node_path10.default.dirname(filePath), { recursive: true });
-    await (0, import_promises3.writeFile)(filePath, `${JSON.stringify(this.toJSON(), null, 2)}
+    await (0, import_promises4.mkdir)(import_node_path11.default.dirname(filePath), { recursive: true });
+    await (0, import_promises4.writeFile)(filePath, `${JSON.stringify(this.toJSON(), null, 2)}
 `, "utf8");
   }
   summary() {
@@ -73638,7 +74095,7 @@ var PermissionAuditLog = class {
 // packages/sdk/dist/provisioner/compiler.js
 var import_ignore = __toESM(require_ignore(), 1);
 var import_node_fs7 = require("node:fs");
-var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
 var SKIPPED_DIRS = /* @__PURE__ */ new Set([".git", ".relay", "node_modules"]);
 function cleanPatterns(content) {
   return content.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#"));
@@ -73681,15 +74138,15 @@ function createMatcher(patterns) {
   return matcher;
 }
 function loadDotfileRules(projectDir, agentName) {
-  const resolvedProjectDir = import_node_path11.default.resolve(projectDir);
+  const resolvedProjectDir = import_node_path12.default.resolve(projectDir);
   return {
     deny: unique([
-      ...readPatternFile(import_node_path11.default.join(resolvedProjectDir, ".agentignore")),
-      ...readPatternFile(import_node_path11.default.join(resolvedProjectDir, `.${agentName}.agentignore`))
+      ...readPatternFile(import_node_path12.default.join(resolvedProjectDir, ".agentignore")),
+      ...readPatternFile(import_node_path12.default.join(resolvedProjectDir, `.${agentName}.agentignore`))
     ]),
     readonly: unique([
-      ...readPatternFile(import_node_path11.default.join(resolvedProjectDir, ".agentreadonly")),
-      ...readPatternFile(import_node_path11.default.join(resolvedProjectDir, `.${agentName}.agentreadonly`))
+      ...readPatternFile(import_node_path12.default.join(resolvedProjectDir, ".agentreadonly")),
+      ...readPatternFile(import_node_path12.default.join(resolvedProjectDir, `.${agentName}.agentreadonly`))
     ])
   };
 }
@@ -73704,9 +74161,9 @@ function resolveScopedWorkdirPatterns(projectDir, workdir) {
   if (!workdir) {
     return void 0;
   }
-  const resolvedProjectDir = import_node_path11.default.resolve(projectDir);
-  const resolvedWorkdir = import_node_path11.default.resolve(resolvedProjectDir, workdir);
-  const relativeWorkdir = normalizeRelativePath(import_node_path11.default.relative(resolvedProjectDir, resolvedWorkdir));
+  const resolvedProjectDir = import_node_path12.default.resolve(projectDir);
+  const resolvedWorkdir = import_node_path12.default.resolve(resolvedProjectDir, workdir);
+  const relativeWorkdir = normalizeRelativePath(import_node_path12.default.relative(resolvedProjectDir, resolvedWorkdir));
   if (relativeWorkdir === "" || relativeWorkdir === ".") {
     return void 0;
   }
@@ -73724,8 +74181,8 @@ function walkProjectFiles(projectDir, currentDir = projectDir, files = []) {
     if (entry.isDirectory() && SKIPPED_DIRS.has(entry.name)) {
       continue;
     }
-    const fullPath = import_node_path11.default.join(currentDir, entry.name);
-    const relativePath = normalizeRelativePath(import_node_path11.default.relative(projectDir, fullPath));
+    const fullPath = import_node_path12.default.join(currentDir, entry.name);
+    const relativePath = normalizeRelativePath(import_node_path12.default.relative(projectDir, fullPath));
     if (entry.isDirectory()) {
       walkProjectFiles(projectDir, fullPath, files);
       continue;
@@ -73769,7 +74226,7 @@ function buildSources(dotfileRules, preset, presetRules, fileRules, rawScopes, i
 function buildAcl(agentName, readonlyPaths, readwritePaths, deniedPaths) {
   const aclMap = /* @__PURE__ */ new Map();
   const addRule = (relativePath, rule) => {
-    const aclDir = normalizeAclDir(import_node_path11.default.posix.dirname(normalizeRelativePath(relativePath)));
+    const aclDir = normalizeAclDir(import_node_path12.default.posix.dirname(normalizeRelativePath(relativePath)));
     const rules = aclMap.get(aclDir) ?? /* @__PURE__ */ new Set();
     rules.add(rule);
     aclMap.set(aclDir, rules);
@@ -73783,13 +74240,13 @@ function buildAcl(agentName, readonlyPaths, readwritePaths, deniedPaths) {
   }
   const deniedDirs = /* @__PURE__ */ new Map();
   for (const relativePath of deniedPaths) {
-    const aclDir = normalizeAclDir(import_node_path11.default.posix.dirname(normalizeRelativePath(relativePath)));
+    const aclDir = normalizeAclDir(import_node_path12.default.posix.dirname(normalizeRelativePath(relativePath)));
     const summary = deniedDirs.get(aclDir) ?? { denied: 0, allowed: 0 };
     summary.denied += 1;
     deniedDirs.set(aclDir, summary);
   }
   for (const relativePath of [...readonlyPaths, ...readwritePaths]) {
-    const aclDir = normalizeAclDir(import_node_path11.default.posix.dirname(normalizeRelativePath(relativePath)));
+    const aclDir = normalizeAclDir(import_node_path12.default.posix.dirname(normalizeRelativePath(relativePath)));
     const summary = deniedDirs.get(aclDir) ?? { denied: 0, allowed: 0 };
     summary.allowed += 1;
     deniedDirs.set(aclDir, summary);
@@ -73839,7 +74296,7 @@ function compileAgentPermissions(input) {
   const permissions = input.permissions ?? {};
   const effectiveAccess = permissions.access ?? "readwrite";
   const inherited = effectiveAccess !== "full" && permissions.inherit !== false;
-  const projectDir = import_node_path11.default.resolve(input.projectDir);
+  const projectDir = import_node_path12.default.resolve(input.projectDir);
   const scopedInput = input;
   const dotfileRules = inherited ? loadDotfileRules(projectDir, input.agentName) : { deny: [], readonly: [] };
   const presetRules = expandPreset(effectiveAccess, {
@@ -73943,16 +74400,16 @@ function mergePermissionSources(dotfileScopes, yamlScopes, rawScopes) {
 var import_node_child_process5 = require("node:child_process");
 var import_node_crypto4 = require("node:crypto");
 var import_node_fs8 = require("node:fs");
-var import_promises4 = require("node:fs/promises");
+var import_promises5 = require("node:fs/promises");
 var import_node_https = __toESM(require("node:https"), 1);
-var import_node_os5 = __toESM(require("node:os"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var RELAYFILE_VERSION = "0.1.6";
 var RELEASE_BASE_URL = "https://github.com/AgentWorkforce/relayfile/releases/download";
 var CHECKSUMS_FILE = "checksums.txt";
-var CACHE_DIR = import_node_path12.default.join(import_node_os5.default.homedir(), ".agent-relay", "bin");
-var CACHE_PATH = import_node_path12.default.join(CACHE_DIR, "relayfile-mount");
-var VERSION_PATH = import_node_path12.default.join(CACHE_DIR, "relayfile-mount.version");
+var CACHE_DIR = import_node_path13.default.join(import_node_os6.default.homedir(), ".agent-relay", "bin");
+var CACHE_PATH = import_node_path13.default.join(CACHE_DIR, "relayfile-mount");
+var VERSION_PATH = import_node_path13.default.join(CACHE_DIR, "relayfile-mount.version");
 var SUPPORTED_TARGETS = ["darwin-arm64", "darwin-amd64", "linux-arm64", "linux-amd64"].join(", ");
 var PLATFORM_ARCH_MAP = {
   "darwin:arm64": "darwin-arm64",
@@ -73964,9 +74421,9 @@ function ensureCacheDir() {
   (0, import_node_fs8.mkdirSync)(CACHE_DIR, { recursive: true });
 }
 function getRelayfileTarget() {
-  const target = PLATFORM_ARCH_MAP[`${import_node_os5.default.platform()}:${import_node_os5.default.arch()}`];
+  const target = PLATFORM_ARCH_MAP[`${import_node_os6.default.platform()}:${import_node_os6.default.arch()}`];
   if (!target) {
-    throw new Error(`Unsupported platform for relayfile-mount: ${import_node_os5.default.platform()}-${import_node_os5.default.arch()}. Supported targets: ${SUPPORTED_TARGETS}.`);
+    throw new Error(`Unsupported platform for relayfile-mount: ${import_node_os6.default.platform()}-${import_node_os6.default.arch()}. Supported targets: ${SUPPORTED_TARGETS}.`);
   }
   return target;
 }
@@ -74079,7 +74536,7 @@ function getExpectedChecksum(checksumContent, binaryName) {
     if (!match) {
       continue;
     }
-    const entryName = import_node_path12.default.basename(match[2].trim());
+    const entryName = import_node_path13.default.basename(match[2].trim());
     if (entryName === binaryName) {
       return match[1].toLowerCase();
     }
@@ -74096,7 +74553,7 @@ async function verifyChecksum(filePath, binaryName) {
   }
 }
 function resignBinaryForMacOS(binaryPath) {
-  if (import_node_os5.default.platform() !== "darwin") {
+  if (import_node_os6.default.platform() !== "darwin") {
     return;
   }
   try {
@@ -74109,7 +74566,7 @@ async function ensureRelayfileMountBinary(binaryPath) {
     return binaryPath;
   }
   if (process.env.RELAYFILE_ROOT) {
-    return import_node_path12.default.join(process.env.RELAYFILE_ROOT, "bin", "relayfile-mount");
+    return import_node_path13.default.join(process.env.RELAYFILE_ROOT, "bin", "relayfile-mount");
   }
   const target = getRelayfileTarget();
   const binaryName = `relayfile-mount-${target}`;
@@ -74121,7 +74578,7 @@ async function ensureRelayfileMountBinary(binaryPath) {
     }
     return CACHE_PATH;
   }
-  const tempPath = import_node_path12.default.join(CACHE_DIR, `relayfile-mount.${process.pid}.${Date.now()}.download`);
+  const tempPath = import_node_path13.default.join(CACHE_DIR, `relayfile-mount.${process.pid}.${Date.now()}.download`);
   try {
     await downloadBinary(downloadUrl, tempPath);
     await verifyChecksum(tempPath, binaryName);
@@ -74193,7 +74650,7 @@ async function ensureRelayfileMount(config2) {
   if (!(0, import_node_fs8.existsSync)(binaryPath)) {
     throw new Error(`missing relayfile mount binary: ${binaryPath}`);
   }
-  const mountPoint = config2.mountPoint ?? await (0, import_promises4.mkdtemp)(import_node_path12.default.join(import_node_os5.default.tmpdir(), `relayfile-mount-${config2.workspace}-`));
+  const mountPoint = config2.mountPoint ?? await (0, import_promises5.mkdtemp)(import_node_path13.default.join(import_node_os6.default.tmpdir(), `relayfile-mount-${config2.workspace}-`));
   (0, import_node_fs8.mkdirSync)(mountPoint, { recursive: true });
   const mountBaseArgs = [
     "--base-url",
@@ -74237,12 +74694,12 @@ async function ensureRelayfileMount(config2) {
     if (mountProc) {
       await stopMountProcess(mountProc).catch(() => void 0);
     }
-    await (0, import_promises4.rm)(mountPoint, { recursive: true, force: true }).catch(() => void 0);
+    await (0, import_promises5.rm)(mountPoint, { recursive: true, force: true }).catch(() => void 0);
     const message = error51 instanceof Error ? error51.message : String(error51);
     throw new Error(`${startupPhase} failed for ${config2.workspace}: ${message}`);
   }
   if (!mountProc || typeof mountProc.pid !== "number") {
-    await (0, import_promises4.rm)(mountPoint, { recursive: true, force: true }).catch(() => void 0);
+    await (0, import_promises5.rm)(mountPoint, { recursive: true, force: true }).catch(() => void 0);
     throw new Error(`mount process startup failed for ${config2.workspace}: missing process id`);
   }
   let stopped = false;
@@ -74255,7 +74712,7 @@ async function ensureRelayfileMount(config2) {
       }
       stopped = true;
       await stopMountProcess(mountProc).catch(() => void 0);
-      await (0, import_promises4.rm)(mountPoint, { recursive: true, force: true }).catch(() => void 0);
+      await (0, import_promises5.rm)(mountPoint, { recursive: true, force: true }).catch(() => void 0);
     }
   };
 }
@@ -75101,7 +75558,7 @@ var debugEnabled2 = (() => {
 
 // packages/sdk/dist/provisioner/seeder.js
 var import_node_fs15 = __toESM(require("node:fs"), 1);
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 
 // node_modules/tar/dist/esm/index.min.js
 var import_events = __toESM(require("events"), 1);
@@ -75109,7 +75566,7 @@ var import_fs = __toESM(require("fs"), 1);
 var import_node_events2 = require("node:events");
 var import_node_stream = __toESM(require("node:stream"), 1);
 var import_node_string_decoder = require("node:string_decoder");
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var import_node_fs9 = __toESM(require("node:fs"), 1);
 var import_path = require("path");
 var import_events2 = require("events");
@@ -75117,27 +75574,27 @@ var import_assert = __toESM(require("assert"), 1);
 var import_buffer = require("buffer");
 var vs = __toESM(require("zlib"), 1);
 var import_zlib = __toESM(require("zlib"), 1);
-var import_node_path14 = require("node:path");
 var import_node_path15 = require("node:path");
+var import_node_path16 = require("node:path");
 var import_fs2 = __toESM(require("fs"), 1);
 var import_fs3 = __toESM(require("fs"), 1);
 var import_path2 = __toESM(require("path"), 1);
-var import_node_path16 = require("node:path");
+var import_node_path17 = require("node:path");
 var import_path3 = __toESM(require("path"), 1);
 var import_node_fs10 = __toESM(require("node:fs"), 1);
 var import_node_assert = __toESM(require("node:assert"), 1);
 var import_node_crypto5 = require("node:crypto");
 var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var import_fs4 = __toESM(require("fs"), 1);
 var import_node_fs12 = __toESM(require("node:fs"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_promises5 = __toESM(require("node:fs/promises"), 1);
 var import_node_path19 = __toESM(require("node:path"), 1);
-var import_node_path20 = require("node:path");
+var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_promises6 = __toESM(require("node:fs/promises"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path21 = require("node:path");
 var import_node_fs14 = __toESM(require("node:fs"), 1);
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 var vr = Object.defineProperty;
 var Mr = (s3, t) => {
   for (var e in t) vr(s3, e, { get: t[e], enumerable: true });
@@ -76030,12 +76487,12 @@ var k = class {
   }
 };
 var ln = (s3, t) => {
-  let i = s3, r = "", n, o = import_node_path14.posix.parse(s3).root || ".";
+  let i = s3, r = "", n, o = import_node_path15.posix.parse(s3).root || ".";
   if (Buffer.byteLength(i) < 100) n = [i, r, false];
   else {
-    r = import_node_path14.posix.dirname(i), i = import_node_path14.posix.basename(i);
+    r = import_node_path15.posix.dirname(i), i = import_node_path15.posix.basename(i);
     do
-      Buffer.byteLength(i) <= 100 && Buffer.byteLength(r) <= t ? n = [i, r, false] : Buffer.byteLength(i) > 100 && Buffer.byteLength(r) <= t ? n = [i.slice(0, 99), r, true] : (i = import_node_path14.posix.join(import_node_path14.posix.basename(r), i), r = import_node_path14.posix.dirname(r));
+      Buffer.byteLength(i) <= 100 && Buffer.byteLength(r) <= t ? n = [i, r, false] : Buffer.byteLength(i) > 100 && Buffer.byteLength(r) <= t ? n = [i.slice(0, 99), r, true] : (i = import_node_path15.posix.join(import_node_path15.posix.basename(r), i), r = import_node_path15.posix.dirname(r));
     while (r !== o && n === void 0);
     n || (n = [s3.slice(0, 99), "", true]);
   }
@@ -76081,7 +76538,7 @@ var ct = class s {
     if (t === "") return Buffer.allocUnsafe(0);
     let e = Buffer.byteLength(t), i = 512 * Math.ceil(1 + e / 512), r = Buffer.allocUnsafe(i);
     for (let n = 0; n < 512; n++) r[n] = 0;
-    new k({ path: ("PaxHeader/" + (0, import_node_path15.basename)(this.path ?? "")).slice(0, 99), mode: this.mode || 420, uid: this.uid, gid: this.gid, size: e, mtime: this.mtime, type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader", linkpath: "", uname: this.uname || "", gname: this.gname || "", devmaj: 0, devmin: 0, atime: this.atime, ctime: this.ctime }).encode(r), r.write(t, 512, e, "utf8");
+    new k({ path: ("PaxHeader/" + (0, import_node_path16.basename)(this.path ?? "")).slice(0, 99), mode: this.mode || 420, uid: this.uid, gid: this.gid, size: e, mtime: this.mtime, type: this.global ? "GlobalExtendedHeader" : "ExtendedHeader", linkpath: "", uname: this.uname || "", gname: this.gname || "", devmaj: 0, devmin: 0, atime: this.atime, ctime: this.ctime }).encode(r), r.write(t, 512, e, "utf8");
     for (let n = e + 512; n < r.length; n++) r[n] = 0;
     return r;
   }
@@ -76493,7 +76950,7 @@ var Ct = K(An, In, (s3) => new st(s3), (s3) => new st(s3), (s3, t) => {
   t?.length && $i(s3, t), s3.noResume || Dn(s3);
 });
 var Xi = (s3, t, e) => (s3 &= 4095, e && (s3 = (s3 | 384) & -19), t && (s3 & 256 && (s3 |= 64), s3 & 32 && (s3 |= 8), s3 & 4 && (s3 |= 1)), s3);
-var { isAbsolute: kn, parse: Ks } = import_node_path16.win32;
+var { isAbsolute: kn, parse: Ks } = import_node_path17.win32;
 var ce = (s3) => {
   let t = "", e = Ks(s3);
   for (; kn(s3) || e.root; ) {
@@ -77202,11 +77659,11 @@ var Wn = (s3, t) => {
 };
 var hr = (s3, t) => {
   t.forEach((e) => {
-    e.charAt(0) === "@" ? Ct({ file: import_node_path13.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
+    e.charAt(0) === "@" ? Ct({ file: import_node_path14.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
   }), s3.end();
 };
 var ar = async (s3, t) => {
-  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path13.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => {
+  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path14.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => {
     s3.add(i);
   } }) : s3.add(e);
   s3.end();
@@ -77244,13 +77701,13 @@ var pi = (s3, t, e, i) => {
   });
 };
 var qn = (s3, t, e, i, r) => {
-  if (t.isDirectory()) us(import_node_path18.default.resolve(s3, t.name), e, i, (n) => {
+  if (t.isDirectory()) us(import_node_path19.default.resolve(s3, t.name), e, i, (n) => {
     if (n) return r(n);
-    let o = import_node_path18.default.resolve(s3, t.name);
+    let o = import_node_path19.default.resolve(s3, t.name);
     pi(o, e, i, r);
   });
   else {
-    let n = import_node_path18.default.resolve(s3, t.name);
+    let n = import_node_path19.default.resolve(s3, t.name);
     pi(n, e, i, r);
   }
 };
@@ -77271,7 +77728,7 @@ var us = (s3, t, e, i) => {
   });
 };
 var Qn = (s3, t, e, i) => {
-  t.isDirectory() && ms(import_node_path18.default.resolve(s3, t.name), e, i), ds(import_node_path18.default.resolve(s3, t.name), e, i);
+  t.isDirectory() && ms(import_node_path19.default.resolve(s3, t.name), e, i), ds(import_node_path19.default.resolve(s3, t.name), e, i);
 };
 var ms = (s3, t, e) => {
   let i;
@@ -77320,13 +77777,13 @@ var wr = (s3, t, e) => {
     E ? e(E) : x && a ? us(x, o, h, (Le) => S(Le)) : n ? import_node_fs13.default.chmod(s3, r, e) : e();
   };
   if (s3 === d) return jn(s3, S);
-  if (l) return import_promises5.default.mkdir(s3, { mode: r, recursive: true }).then((E) => S(null, E ?? void 0), S);
-  let N = f(import_node_path19.default.relative(d, s3)).split("/");
+  if (l) return import_promises6.default.mkdir(s3, { mode: r, recursive: true }).then((E) => S(null, E ?? void 0), S);
+  let N = f(import_node_path20.default.relative(d, s3)).split("/");
   ps(d, N, r, c, d, void 0, S);
 };
 var ps = (s3, t, e, i, r, n, o) => {
   if (t.length === 0) return o(null, n);
-  let h = t.shift(), a = f(import_node_path19.default.resolve(s3 + "/" + h));
+  let h = t.shift(), a = f(import_node_path20.default.resolve(s3 + "/" + h));
   import_node_fs13.default.mkdir(a, e, Sr(a, t, e, i, r, n, o));
 };
 var Sr = (s3, t, e, i, r, n, o) => (h) => {
@@ -77360,9 +77817,9 @@ var yr = (s3, t) => {
   };
   if (s3 === c) return to(c), d();
   if (a) return d(import_node_fs13.default.mkdirSync(s3, { mode: i, recursive: true }) ?? void 0);
-  let T = f(import_node_path19.default.relative(c, s3)).split("/"), N;
+  let T = f(import_node_path20.default.relative(c, s3)).split("/"), N;
   for (let E = T.shift(), x = c; E && (x += "/" + E); E = T.shift()) {
-    x = f(import_node_path19.default.resolve(x));
+    x = f(import_node_path20.default.resolve(x));
     try {
       import_node_fs13.default.mkdirSync(x, i), N = N || x;
     } catch {
@@ -77391,14 +77848,14 @@ var eo = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform;
 var io = eo === "win32";
 var so = (s3) => s3.split("/").slice(0, -1).reduce((e, i) => {
   let r = e.at(-1);
-  return r !== void 0 && (i = (0, import_node_path20.join)(r, i)), e.push(i || "/"), e;
+  return r !== void 0 && (i = (0, import_node_path21.join)(r, i)), e.push(i || "/"), e;
 }, []);
 var Si = class {
   #t = /* @__PURE__ */ new Map();
   #i = /* @__PURE__ */ new Map();
   #s = /* @__PURE__ */ new Set();
   reserve(t, e) {
-    t = io ? ["win32 parallelization disabled"] : t.map((r) => mt((0, import_node_path20.join)(gr(r))));
+    t = io ? ["win32 parallelization disabled"] : t.map((r) => mt((0, import_node_path21.join)(gr(r))));
     let i = new Set(t.map((r) => so(r)).reduce((r, n) => r.concat(n)));
     this.#i.set(e, { dirs: i, paths: t });
     for (let r of t) {
@@ -77538,7 +77995,7 @@ var qt = class extends st {
       if (t.preserveOwner) throw new TypeError("cannot preserve owner in archive and also set owner explicitly");
       this.uid = t.uid, this.gid = t.gid, this.setOwner = true;
     } else this.uid = void 0, this.gid = void 0, this.setOwner = false;
-    this.preserveOwner = t.preserveOwner === void 0 && typeof t.uid != "number" ? !!(process.getuid && process.getuid() === 0) : !!t.preserveOwner, this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0, this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0, this.maxDepth = typeof t.maxDepth == "number" ? t.maxDepth : oo, this.forceChown = t.forceChown === true, this.win32 = !!t.win32 || Te, this.newer = !!t.newer, this.keep = !!t.keep, this.noMtime = !!t.noMtime, this.preservePaths = !!t.preservePaths, this.unlink = !!t.unlink, this.cwd = f(import_node_path17.default.resolve(t.cwd || process.cwd())), this.strip = Number(t.strip) || 0, this.processUmask = this.chmod ? typeof t.processUmask == "number" ? t.processUmask : _r() : 0, this.umask = typeof t.umask == "number" ? t.umask : this.processUmask, this.dmode = t.dmode || 511 & ~this.umask, this.fmode = t.fmode || 438 & ~this.umask, this.on("entry", (e) => this[Or](e));
+    this.preserveOwner = t.preserveOwner === void 0 && typeof t.uid != "number" ? !!(process.getuid && process.getuid() === 0) : !!t.preserveOwner, this.processUid = (this.preserveOwner || this.setOwner) && process.getuid ? process.getuid() : void 0, this.processGid = (this.preserveOwner || this.setOwner) && process.getgid ? process.getgid() : void 0, this.maxDepth = typeof t.maxDepth == "number" ? t.maxDepth : oo, this.forceChown = t.forceChown === true, this.win32 = !!t.win32 || Te, this.newer = !!t.newer, this.keep = !!t.keep, this.noMtime = !!t.noMtime, this.preservePaths = !!t.preservePaths, this.unlink = !!t.unlink, this.cwd = f(import_node_path18.default.resolve(t.cwd || process.cwd())), this.strip = Number(t.strip) || 0, this.processUmask = this.chmod ? typeof t.processUmask == "number" ? t.processUmask : _r() : 0, this.umask = typeof t.umask == "number" ? t.umask : this.processUmask, this.dmode = t.dmode || 511 & ~this.umask, this.fmode = t.fmode || 438 & ~this.umask, this.on("entry", (e) => this[Or](e));
   }
   warn(t, e, i = {}) {
     return (t === "TAR_BAD_ARCHIVE" || t === "TAR_ABORT") && (i.recoverable = false), super.warn(t, e, i);
@@ -77552,7 +78009,7 @@ var qt = class extends st {
     let [n, o] = ce(i), h = o.replaceAll(/\\/g, "/").split("/");
     if (h.includes("..") || Te && /^[a-z]:\.\.$/i.test(h[0] ?? "")) {
       if (e === "path" || r === "Link") return this.warn("TAR_ENTRY_ERROR", `${e} contains '..'`, { entry: t, [e]: i }), false;
-      let a = import_node_path17.default.posix.dirname(t.path), l = import_node_path17.default.posix.normalize(import_node_path17.default.posix.join(a, h.join("/")));
+      let a = import_node_path18.default.posix.dirname(t.path), l = import_node_path18.default.posix.normalize(import_node_path18.default.posix.join(a, h.join("/")));
       if (l.startsWith("../") || l === "..") return this.warn("TAR_ENTRY_ERROR", `${e} escapes extraction directory`, { entry: t, [e]: i }), false;
     }
     return n && (t[e] = String(o), this.warn("TAR_ENTRY_INFO", `stripping ${n} from absolute ${e}`, { entry: t, [e]: i })), true;
@@ -77570,12 +78027,12 @@ var qt = class extends st {
     }
     if (isFinite(this.maxDepth) && i.length > this.maxDepth) return this.warn("TAR_ENTRY_ERROR", "path excessively deep", { entry: t, path: e, depth: i.length, maxDepth: this.maxDepth }), false;
     if (!this[ws](t, "path") || !this[ws](t, "linkpath")) return false;
-    if (t.absolute = import_node_path17.default.isAbsolute(t.path) ? f(import_node_path17.default.resolve(t.path)) : f(import_node_path17.default.resolve(this.cwd, t.path)), !this.preservePaths && typeof t.absolute == "string" && t.absolute.indexOf(this.cwd + "/") !== 0 && t.absolute !== this.cwd) return this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { entry: t, path: f(t.path), resolvedPath: t.absolute, cwd: this.cwd }), false;
+    if (t.absolute = import_node_path18.default.isAbsolute(t.path) ? f(import_node_path18.default.resolve(t.path)) : f(import_node_path18.default.resolve(this.cwd, t.path)), !this.preservePaths && typeof t.absolute == "string" && t.absolute.indexOf(this.cwd + "/") !== 0 && t.absolute !== this.cwd) return this.warn("TAR_ENTRY_ERROR", "path escaped extraction target", { entry: t, path: f(t.path), resolvedPath: t.absolute, cwd: this.cwd }), false;
     if (t.absolute === this.cwd && t.type !== "Directory" && t.type !== "GNUDumpDir") return false;
     if (this.win32) {
-      let { root: r } = import_node_path17.default.win32.parse(String(t.absolute));
+      let { root: r } = import_node_path18.default.win32.parse(String(t.absolute));
       t.absolute = r + Qi(String(t.absolute).slice(r.length));
-      let { root: n } = import_node_path17.default.win32.parse(t.path);
+      let { root: n } = import_node_path18.default.win32.parse(t.path);
       t.path = n + Qi(t.path.slice(n.length));
     }
     return true;
@@ -77663,13 +78120,13 @@ var qt = class extends st {
     t.unsupported = true, this.warn("TAR_ENTRY_UNSUPPORTED", `unsupported entry type: ${t.type}`, { entry: t }), t.resume();
   }
   [xr](t, e) {
-    let i = f(import_node_path17.default.relative(this.cwd, import_node_path17.default.resolve(import_node_path17.default.dirname(String(t.absolute)), String(t.linkpath)))).split("/");
+    let i = f(import_node_path18.default.relative(this.cwd, import_node_path18.default.resolve(import_node_path18.default.dirname(String(t.absolute)), String(t.linkpath)))).split("/");
     this[Re](t, this.cwd, i, () => this[Ri](t, String(t.linkpath), "symlink", e), (r) => {
       this[O](r, t), e();
     });
   }
   [Lr](t, e) {
-    let i = f(import_node_path17.default.resolve(this.cwd, String(t.linkpath))), r = f(String(t.linkpath)).split("/");
+    let i = f(import_node_path18.default.resolve(this.cwd, String(t.linkpath))), r = f(String(t.linkpath)).split("/");
     this[Re](t, this.cwd, r, () => this[Ri](t, i, "link", e), (n) => {
       this[O](n, t), e();
     });
@@ -77677,10 +78134,10 @@ var qt = class extends st {
   [Re](t, e, i, r, n) {
     let o = i.shift();
     if (this.preservePaths || o === void 0) return r();
-    let h = import_node_path17.default.resolve(e, o);
+    let h = import_node_path18.default.resolve(e, o);
     import_node_fs11.default.lstat(h, (a, l) => {
       if (a) return r();
-      if (l?.isSymbolicLink()) return n(new St(h, import_node_path17.default.resolve(h, i.join("/"))));
+      if (l?.isSymbolicLink()) return n(new St(h, import_node_path18.default.resolve(h, i.join("/"))));
       this[Re](t, h, i, r, n);
     });
   }
@@ -77714,7 +78171,7 @@ var qt = class extends st {
       });
     }, n = () => {
       if (t.absolute !== this.cwd) {
-        let h = f(import_node_path17.default.dirname(String(t.absolute)));
+        let h = f(import_node_path18.default.dirname(String(t.absolute)));
         if (h !== this.cwd) return this[yt](h, this.dmode, (a) => {
           if (a) {
             this[O](a, t), i();
@@ -77789,7 +78246,7 @@ var xe = class extends qt {
       this[Oe] = true;
     }
     if (t.absolute !== this.cwd) {
-      let n = f(import_node_path17.default.dirname(String(t.absolute)));
+      let n = f(import_node_path18.default.dirname(String(t.absolute)));
       if (n !== this.cwd) {
         let o = this[yt](n, this.dmode);
         if (o) return this[O](o, t);
@@ -77889,10 +78346,10 @@ var xe = class extends qt {
     if (this.preservePaths || i.length === 0) return r();
     let o = e;
     for (let h of i) {
-      o = import_node_path17.default.resolve(o, h);
+      o = import_node_path18.default.resolve(o, h);
       let [a, l] = ye(() => import_node_fs11.default.lstatSync(o));
       if (a) return r();
-      if (l.isSymbolicLink()) return n(new St(o, import_node_path17.default.resolve(e, i.join("/"))));
+      if (l.isSymbolicLink()) return n(new St(o, import_node_path18.default.resolve(e, i.join("/"))));
     }
     r();
   }
@@ -77996,11 +78453,11 @@ var po = (s3, t) => {
 };
 var Eo = (s3, t) => {
   t.forEach((e) => {
-    e.charAt(0) === "@" ? Ct({ file: import_node_path21.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
+    e.charAt(0) === "@" ? Ct({ file: import_node_path22.default.resolve(s3.cwd, e.slice(1)), sync: true, noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
   }), s3.end();
 };
 var wo = async (s3, t) => {
-  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path21.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
+  for (let e of t) e.charAt(0) === "@" ? await Ct({ file: import_node_path22.default.resolve(String(s3.cwd), e.slice(1)), noResume: true, onReadEntry: (i) => s3.add(i) }) : s3.add(e);
   s3.end();
 };
 var vt = K(uo, po, () => {
@@ -78077,7 +78534,7 @@ function isUtf8(raw) {
   }
 }
 function buildSeedFilePayload(filePath, rootDir) {
-  const relative3 = import_node_path22.default.relative(rootDir, filePath).split(import_node_path22.default.sep).join("/");
+  const relative3 = import_node_path23.default.relative(rootDir, filePath).split(import_node_path23.default.sep).join("/");
   const raw = import_node_fs15.default.readFileSync(filePath);
   if (isUtf8(raw)) {
     return { path: `/${relative3}`, content: raw.toString("utf8"), encoding: "utf-8" };
@@ -78085,7 +78542,7 @@ function buildSeedFilePayload(filePath, rootDir) {
   return { path: `/${relative3}`, content: raw.toString("base64"), encoding: "base64" };
 }
 function collectSeedPaths(rootDir, currentRelative, excludeDirs, output) {
-  const absoluteDir = import_node_path22.default.join(rootDir, currentRelative);
+  const absoluteDir = import_node_path23.default.join(rootDir, currentRelative);
   const entries = import_node_fs15.default.readdirSync(absoluteDir, { withFileTypes: true });
   for (const entry of entries) {
     if (excludeDirs.has(entry.name)) {
@@ -78095,7 +78552,7 @@ function collectSeedPaths(rootDir, currentRelative, excludeDirs, output) {
       continue;
     }
     const nextRelative = currentRelative ? `${currentRelative}/${entry.name}` : entry.name;
-    const absolutePath = import_node_path22.default.join(rootDir, nextRelative);
+    const absolutePath = import_node_path23.default.join(rootDir, nextRelative);
     if (excludeDirs.has(nextRelative)) {
       continue;
     }
@@ -78110,15 +78567,15 @@ function collectSeedPaths(rootDir, currentRelative, excludeDirs, output) {
     if (entry.isSymbolicLink()) {
       try {
         const resolved = import_node_fs15.default.realpathSync(absolutePath);
-        if (!resolved.startsWith(rootDir + import_node_path22.default.sep) && resolved !== rootDir) {
+        if (!resolved.startsWith(rootDir + import_node_path23.default.sep) && resolved !== rootDir) {
           continue;
         }
-        const stat2 = import_node_fs15.default.statSync(resolved);
-        if (stat2.isDirectory()) {
+        const stat3 = import_node_fs15.default.statSync(resolved);
+        if (stat3.isDirectory()) {
           collectSeedPaths(rootDir, nextRelative, excludeDirs, output);
           continue;
         }
-        if (stat2.isFile()) {
+        if (stat3.isFile()) {
           output.push(absolutePath);
         }
       } catch {
@@ -78246,7 +78703,7 @@ async function seedAclRules(baseUrl, token, workspaceId, aclRules) {
 }
 async function seedWorkspace(baseUrl, token, workspaceId, projectDir, excludeDirs) {
   const workspace = normalizeWorkspaceId2(workspaceId);
-  const rootDir = import_node_path22.default.resolve(projectDir);
+  const rootDir = import_node_path23.default.resolve(projectDir);
   const excludes = normalizeExcludeDirs([...DEFAULT_EXCLUDED_DIRS, ...excludeDirs]);
   const seedPaths = [];
   collectSeedPaths(rootDir, "", excludes, seedPaths);
@@ -78419,7 +78876,7 @@ function buildSummary(compilations) {
 function buildAgentResult(projectDir, name, token, compiled, mountPoint) {
   return {
     name,
-    tokenPath: import_node_path23.default.resolve(projectDir, ".relay", "tokens", `${name}.jwt`),
+    tokenPath: import_node_path24.default.resolve(projectDir, ".relay", "tokens", `${name}.jwt`),
     token,
     scopes: [...compiled.scopes],
     compiled,
@@ -78478,7 +78935,7 @@ async function provisionWorkflowAgents(config2) {
         action: "mint",
         details: {
           workspace: config2.workspace,
-          jwtPath: import_node_path23.default.resolve(config2.projectDir, ".relay", "tokens", `${agent.name}.jwt`),
+          jwtPath: import_node_path24.default.resolve(config2.projectDir, ".relay", "tokens", `${agent.name}.jwt`),
           scopeCount: compiled.scopes.length,
           scopes: [...compiled.scopes],
           ttlSeconds: config2.tokenTtlSeconds ?? null
@@ -78556,7 +79013,7 @@ async function provisionWorkflowAgents(config2) {
       });
     }
     if (!config2.skipMount) {
-      const mountRoot = import_node_path23.default.resolve(config2.mountBaseDir ?? import_node_path23.default.join(config2.projectDir, ".relay"));
+      const mountRoot = import_node_path24.default.resolve(config2.mountBaseDir ?? import_node_path24.default.join(config2.projectDir, ".relay"));
       try {
         for (const agent of agents) {
           const token = tokens.get(agent.name);
@@ -78569,7 +79026,7 @@ async function provisionWorkflowAgents(config2) {
             relayfileUrl: config2.relayfileBaseUrl,
             workspace: config2.workspace,
             token,
-            mountPoint: import_node_path23.default.join(mountRoot, `workspace-${sanitizePathComponent(config2.workspace)}-${sanitizePathComponent(agent.name)}`)
+            mountPoint: import_node_path24.default.join(mountRoot, `workspace-${sanitizePathComponent(config2.workspace)}-${sanitizePathComponent(agent.name)}`)
           });
           mounts.set(agent.name, mountHandle);
           agentResults[agent.name] = buildAgentResult(config2.projectDir, agent.name, token, compiled, mountHandle.mountPoint);
@@ -78624,13 +79081,13 @@ async function provisionWorkflowAgents(config2) {
 
 // packages/sdk/dist/workflows/collectors/claude.js
 var import_node_fs17 = require("node:fs");
-var import_promises6 = require("node:fs/promises");
-var import_node_os6 = require("node:os");
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_promises7 = require("node:fs/promises");
+var import_node_os7 = require("node:os");
+var import_node_path25 = __toESM(require("node:path"), 1);
 var import_node_readline = require("node:readline");
-var CLAUDE_HOME = import_node_path24.default.join((0, import_node_os6.homedir)(), ".claude");
-var HISTORY_PATH = import_node_path24.default.join(CLAUDE_HOME, "history.jsonl");
-var PROJECTS_PATH = import_node_path24.default.join(CLAUDE_HOME, "projects");
+var CLAUDE_HOME = import_node_path25.default.join((0, import_node_os7.homedir)(), ".claude");
+var HISTORY_PATH = import_node_path25.default.join(CLAUDE_HOME, "history.jsonl");
+var PROJECTS_PATH = import_node_path25.default.join(CLAUDE_HOME, "projects");
 var HISTORY_LOOKBACK_MS = 5e3;
 var ClaudeCodeCollector = class {
   canCollect() {
@@ -78641,7 +79098,7 @@ var ClaudeCodeCollector = class {
     if (!historyEntry) {
       return null;
     }
-    const sessionPath = import_node_path24.default.join(PROJECTS_PATH, encodeProjectPath(historyEntry.project), `${historyEntry.sessionId}.jsonl`);
+    const sessionPath = import_node_path25.default.join(PROJECTS_PATH, encodeProjectPath(historyEntry.project), `${historyEntry.sessionId}.jsonl`);
     if (!await isReadableFileAsync(sessionPath)) {
       return null;
     }
@@ -78926,7 +79383,7 @@ function isReadableDirectory(dirPath) {
 }
 async function isReadableFileAsync(filePath) {
   try {
-    await (0, import_promises6.access)(filePath);
+    await (0, import_promises7.access)(filePath);
     return true;
   } catch {
     return false;
@@ -78935,13 +79392,13 @@ async function isReadableFileAsync(filePath) {
 
 // packages/sdk/dist/workflows/collectors/codex.js
 var import_node_fs18 = __toESM(require("node:fs"), 1);
-var import_node_os7 = __toESM(require("node:os"), 1);
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 var import_node_module2 = require("node:module");
 var require2 = (0, import_node_module2.createRequire)(import_meta_url);
-var CODEX_HOME = import_node_path25.default.join(import_node_os7.default.homedir(), ".codex");
-var DEFAULT_HISTORY_PATH = import_node_path25.default.join(CODEX_HOME, "history.jsonl");
-var DEFAULT_STATE_PATH = import_node_path25.default.join(CODEX_HOME, "state_5.sqlite");
+var CODEX_HOME = import_node_path26.default.join(import_node_os8.default.homedir(), ".codex");
+var DEFAULT_HISTORY_PATH = import_node_path26.default.join(CODEX_HOME, "history.jsonl");
+var DEFAULT_STATE_PATH = import_node_path26.default.join(CODEX_HOME, "state_5.sqlite");
 function loadBetterSqlite3() {
   try {
     return require2("better-sqlite3");
@@ -79175,11 +79632,11 @@ var CodexCollector = class {
 
 // packages/sdk/dist/workflows/collectors/opencode.js
 var import_node_fs19 = __toESM(require("node:fs"), 1);
-var import_node_os8 = __toESM(require("node:os"), 1);
-var import_node_path26 = __toESM(require("node:path"), 1);
+var import_node_os9 = __toESM(require("node:os"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 var import_node_module3 = require("node:module");
 var require3 = (0, import_node_module3.createRequire)(import_meta_url);
-var OPENCODE_DB_PATH = import_node_path26.default.join(import_node_os8.default.homedir(), ".local", "share", "opencode", "opencode.db");
+var OPENCODE_DB_PATH = import_node_path27.default.join(import_node_os9.default.homedir(), ".local", "share", "opencode", "opencode.db");
 var MATCH_WINDOW_GRACE_MS = 5e3;
 var ERROR_LINE_PATTERN = /^(Error|error:|Command failed|FAIL)\b/;
 function loadDatabaseConstructor() {
@@ -79920,7 +80377,7 @@ var import_node_child_process7 = require("node:child_process");
 // packages/sdk/dist/workflows/verification.js
 var import_node_child_process6 = require("node:child_process");
 var import_node_fs20 = require("node:fs");
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 var WorkflowCompletionError = class extends Error {
   completionReason;
   constructor(message, completionReason) {
@@ -80112,9 +80569,9 @@ function checkCustom(value, output, cwd = process.cwd()) {
   }
 }
 function checkFileExists(filePath, cwd = process.cwd()) {
-  const normalizedCwd = import_node_path27.default.resolve(cwd);
-  const resolved = import_node_path27.default.isAbsolute(filePath) ? import_node_path27.default.resolve(filePath) : import_node_path27.default.resolve(normalizedCwd, filePath);
-  if (!import_node_path27.default.isAbsolute(filePath) && !resolved.startsWith(normalizedCwd + import_node_path27.default.sep) && resolved !== normalizedCwd) {
+  const normalizedCwd = import_node_path28.default.resolve(cwd);
+  const resolved = import_node_path28.default.isAbsolute(filePath) ? import_node_path28.default.resolve(filePath) : import_node_path28.default.resolve(normalizedCwd, filePath);
+  if (!import_node_path28.default.isAbsolute(filePath) && !resolved.startsWith(normalizedCwd + import_node_path28.default.sep) && resolved !== normalizedCwd) {
     return false;
   }
   return (0, import_node_fs20.existsSync)(resolved);
@@ -80947,14 +81404,14 @@ function delay(ms2) {
 }
 
 // packages/sdk/dist/workflows/trajectory.js
-var import_node_path28 = require("node:path");
+var import_node_path29 = require("node:path");
 
 // node_modules/agent-trajectories/dist/chunk-WMJRBQB4.js
 var import_module = require("module");
 var import_crypto = require("crypto");
 var import_crypto2 = require("crypto");
 var import_fs5 = require("fs");
-var import_promises7 = require("fs/promises");
+var import_promises8 = require("fs/promises");
 var import_path4 = require("path");
 var ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
 var ID_LENGTH = 12;
@@ -81551,9 +82008,9 @@ var FileStorage = class {
    * Initialize storage directories
    */
   async initialize() {
-    await (0, import_promises7.mkdir)(this.trajectoriesDir, { recursive: true });
-    await (0, import_promises7.mkdir)(this.activeDir, { recursive: true });
-    await (0, import_promises7.mkdir)(this.completedDir, { recursive: true });
+    await (0, import_promises8.mkdir)(this.trajectoriesDir, { recursive: true });
+    await (0, import_promises8.mkdir)(this.activeDir, { recursive: true });
+    await (0, import_promises8.mkdir)(this.completedDir, { recursive: true });
     if (!(0, import_fs5.existsSync)(this.indexPath)) {
       await withIndexLock(this.indexPath, async () => {
         if (!(0, import_fs5.existsSync)(this.indexPath)) {
@@ -81592,7 +82049,7 @@ var FileStorage = class {
       const before = Object.keys(index.trajectories).length;
       const discovered = [];
       try {
-        const activeFiles = await (0, import_promises7.readdir)(this.activeDir);
+        const activeFiles = await (0, import_promises8.readdir)(this.activeDir);
         for (const file2 of activeFiles) {
           if (!file2.endsWith(".json")) continue;
           discovered.push((0, import_path4.join)(this.activeDir, file2));
@@ -81678,13 +82135,13 @@ var FileStorage = class {
     if (candidates.length === 0) {
       return { moved: [], targetDir };
     }
-    await (0, import_promises7.mkdir)(targetDir, { recursive: true });
+    await (0, import_promises8.mkdir)(targetDir, { recursive: true });
     const moved = [];
     for (const failure of candidates) {
       const dest = await this.resolveQuarantineDest(failure.path, targetDir);
       try {
-        await (0, import_promises7.mkdir)((0, import_path4.dirname)(dest), { recursive: true });
-        await (0, import_promises7.rename)(failure.path, dest);
+        await (0, import_promises8.mkdir)((0, import_path4.dirname)(dest), { recursive: true });
+        await (0, import_promises8.rename)(failure.path, dest);
         moved.push(failure);
       } catch (error51) {
         console.warn(
@@ -81726,7 +82183,7 @@ var FileStorage = class {
   async walkJsonFilesInto(dir, out) {
     let entries;
     try {
-      entries = await (0, import_promises7.readdir)(dir, { withFileTypes: true });
+      entries = await (0, import_promises8.readdir)(dir, { withFileTypes: true });
     } catch (error51) {
       if (error51.code === "ENOENT") return;
       throw error51;
@@ -81766,19 +82223,19 @@ var FileStorage = class {
         this.completedDir,
         `${date5.getFullYear()}-${String(date5.getMonth() + 1).padStart(2, "0")}`
       );
-      await (0, import_promises7.mkdir)(monthDir, { recursive: true });
+      await (0, import_promises8.mkdir)(monthDir, { recursive: true });
       filePath = (0, import_path4.join)(monthDir, `${trajectory2.id}.json`);
       const activePath = (0, import_path4.join)(this.activeDir, `${trajectory2.id}.json`);
       if ((0, import_fs5.existsSync)(activePath)) {
-        await (0, import_promises7.unlink)(activePath);
+        await (0, import_promises8.unlink)(activePath);
       }
       const mdPath = (0, import_path4.join)(monthDir, `${trajectory2.id}.md`);
       const markdown = exportToMarkdown(trajectory2);
-      await (0, import_promises7.writeFile)(mdPath, markdown, "utf-8");
+      await (0, import_promises8.writeFile)(mdPath, markdown, "utf-8");
     } else {
       filePath = (0, import_path4.join)(this.activeDir, `${trajectory2.id}.json`);
     }
-    await (0, import_promises7.writeFile)(filePath, JSON.stringify(trajectory2, null, 2), "utf-8");
+    await (0, import_promises8.writeFile)(filePath, JSON.stringify(trajectory2, null, 2), "utf-8");
     await this.updateIndex(trajectory2, filePath);
   }
   /**
@@ -81799,7 +82256,7 @@ var FileStorage = class {
       if ((0, import_fs5.existsSync)(flatPath)) {
         return this.readTrajectoryOrNull(flatPath);
       }
-      const months = await (0, import_promises7.readdir)(this.completedDir);
+      const months = await (0, import_promises8.readdir)(this.completedDir);
       for (const month of months) {
         const filePath = (0, import_path4.join)(this.completedDir, month, `${id}.json`);
         if ((0, import_fs5.existsSync)(filePath)) {
@@ -81818,7 +82275,7 @@ var FileStorage = class {
    */
   async getActive() {
     try {
-      const files = await (0, import_promises7.readdir)(this.activeDir);
+      const files = await (0, import_promises8.readdir)(this.activeDir);
       const jsonFiles = files.filter((f2) => f2.endsWith(".json"));
       if (jsonFiles.length === 0) {
         return null;
@@ -81903,16 +82360,16 @@ var FileStorage = class {
   async delete(id) {
     const activePath = (0, import_path4.join)(this.activeDir, `${id}.json`);
     if ((0, import_fs5.existsSync)(activePath)) {
-      await (0, import_promises7.unlink)(activePath);
+      await (0, import_promises8.unlink)(activePath);
     }
     await withIndexLock(this.indexPath, async () => {
       const index = await this.loadIndex();
       const entry = index.trajectories[id];
       if (entry?.path && (0, import_fs5.existsSync)(entry.path)) {
-        await (0, import_promises7.unlink)(entry.path);
+        await (0, import_promises8.unlink)(entry.path);
         const mdPath = entry.path.replace(".json", ".md");
         if ((0, import_fs5.existsSync)(mdPath)) {
-          await (0, import_promises7.unlink)(mdPath);
+          await (0, import_promises8.unlink)(mdPath);
         }
       }
       delete index.trajectories[id];
@@ -81965,7 +82422,7 @@ var FileStorage = class {
   async readTrajectoryFile(path28) {
     let content;
     try {
-      content = await (0, import_promises7.readFile)(path28, "utf-8");
+      content = await (0, import_promises8.readFile)(path28, "utf-8");
     } catch (error51) {
       return { ok: false, reason: "io_error", path: path28, error: error51 };
     }
@@ -82011,7 +82468,7 @@ var FileStorage = class {
   async loadIndex() {
     let content;
     try {
-      content = await (0, import_promises7.readFile)(this.indexPath, "utf-8");
+      content = await (0, import_promises8.readFile)(this.indexPath, "utf-8");
     } catch (error51) {
       if (error51.code !== "ENOENT") {
         console.error(
@@ -82054,8 +82511,8 @@ var FileStorage = class {
   async saveIndex(index) {
     index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
     const tmpPath = `${this.indexPath}.${process.pid}.${(0, import_crypto2.randomUUID)()}.tmp`;
-    await (0, import_promises7.writeFile)(tmpPath, JSON.stringify(index, null, 2), "utf-8");
-    await (0, import_promises7.rename)(tmpPath, this.indexPath);
+    await (0, import_promises8.writeFile)(tmpPath, JSON.stringify(index, null, 2), "utf-8");
+    await (0, import_promises8.rename)(tmpPath, this.indexPath);
   }
   async updateIndex(trajectory2, filePath) {
     await withIndexLock(this.indexPath, async () => {
@@ -82179,8 +82636,8 @@ var WorkflowTrajectory = class {
     this.reflectOnConverge = cfg.reflectOnConverge !== false;
     this.autoDecisions = cfg.autoDecisions !== false;
     this.runId = runId;
-    const dataDir = process.env.TRAJECTORIES_DATA_DIR ?? (0, import_node_path28.join)(cwd, ".trajectories");
-    this.storageBaseDir = process.env.TRAJECTORIES_DATA_DIR ? (0, import_node_path28.dirname)(dataDir) : cwd;
+    const dataDir = process.env.TRAJECTORIES_DATA_DIR ?? (0, import_node_path29.join)(cwd, ".trajectories");
+    this.storageBaseDir = process.env.TRAJECTORIES_DATA_DIR ? (0, import_node_path29.dirname)(dataDir) : cwd;
   }
   async start(workflowName, stepCount, trackInfo, description, pattern) {
     if (!this.enabled)
@@ -82639,8 +83096,8 @@ var WorkflowRunner = class _WorkflowRunner {
     this.workspaceId = options.workspaceId ?? "local";
     this.relayOptions = options.relay ?? {};
     this.cwd = options.cwd ?? process.cwd();
-    this.summaryDir = options.summaryDir ?? import_node_path29.default.join(this.cwd, ".relay", "summaries");
-    this.workersPath = import_node_path29.default.join(this.cwd, ".agent-relay", "team", "workers.json");
+    this.summaryDir = options.summaryDir ?? import_node_path30.default.join(this.cwd, ".relay", "summaries");
+    this.workersPath = import_node_path30.default.join(this.cwd, ".agent-relay", "team", "workers.json");
     this.executor = options.executor;
     this.processBackend = options.processBackend;
     this.envSecrets = options.envSecrets;
@@ -82678,7 +83135,7 @@ var WorkflowRunner = class _WorkflowRunner {
       }
       seenNames.add(pd.name);
       const expanded = _WorkflowRunner.resolveEnvVars(pd.path);
-      const abs = import_node_path29.default.resolve(baseCwd, expanded);
+      const abs = import_node_path30.default.resolve(baseCwd, expanded);
       resolved.set(pd.name, abs);
       const isRequired = pd.required !== false;
       if (!(0, import_node_fs21.existsSync)(abs)) {
@@ -83010,7 +83467,7 @@ var WorkflowRunner = class _WorkflowRunner {
       return resolved;
     }
     if (agent.cwd) {
-      return import_node_path29.default.resolve(this.cwd, agent.cwd);
+      return import_node_path30.default.resolve(this.cwd, agent.cwd);
     }
     return this.cwd;
   }
@@ -83029,7 +83486,7 @@ var WorkflowRunner = class _WorkflowRunner {
   }
   resolveEffectiveCwd(step, agentDef) {
     if (step.cwd) {
-      return import_node_path29.default.resolve(this.cwd, step.cwd);
+      return import_node_path30.default.resolve(this.cwd, step.cwd);
     }
     return this.resolveStepWorkdir(step) ?? (agentDef ? this.resolveAgentCwd(agentDef) : this.cwd);
   }
@@ -83038,14 +83495,14 @@ var WorkflowRunner = class _WorkflowRunner {
     if (!mount) {
       return cwd;
     }
-    const relative3 = import_node_path29.default.relative(this.cwd, cwd);
+    const relative3 = import_node_path30.default.relative(this.cwd, cwd);
     if (relative3 === "") {
       return mount.mountPoint;
     }
-    if (relative3 === ".." || relative3.startsWith(`..${import_node_path29.default.sep}`)) {
+    if (relative3 === ".." || relative3.startsWith(`..${import_node_path30.default.sep}`)) {
       return cwd;
     }
-    return import_node_path29.default.resolve(mount.mountPoint, relative3);
+    return import_node_path30.default.resolve(mount.mountPoint, relative3);
   }
   resolveExecutionCwd(step, agentDef) {
     const cwd = this.resolveEffectiveCwd(step, agentDef);
@@ -83350,7 +83807,7 @@ ${next}` : next;
   }
   uniqueEvidenceRoots(roots) {
     return [
-      ...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path29.default.resolve(root)))
+      ...new Set(roots.filter((root) => Boolean(root)).map((root) => import_node_path30.default.resolve(root)))
     ];
   }
   captureFileSnapshot(root) {
@@ -83368,7 +83825,7 @@ ${next}` : next;
         if (entry.isDirectory() && _WorkflowRunner.EVIDENCE_IGNORED_DIRS.has(entry.name)) {
           continue;
         }
-        const fullPath = import_node_path29.default.join(currentPath, entry.name);
+        const fullPath = import_node_path30.default.join(currentPath, entry.name);
         if (entry.isDirectory()) {
           visit(fullPath);
           continue;
@@ -83420,9 +83877,9 @@ ${next}` : next;
     return changes.sort((a, b2) => a.path.localeCompare(b2.path));
   }
   normalizeEvidencePath(filePath) {
-    const relative3 = import_node_path29.default.relative(this.cwd, filePath);
+    const relative3 = import_node_path30.default.relative(this.cwd, filePath);
     if (!relative3 || relative3 === "")
-      return import_node_path29.default.basename(filePath);
+      return import_node_path30.default.basename(filePath);
     return relative3.startsWith("..") ? filePath : relative3;
   }
   buildStepCompletionDecision(stepName, completionReason) {
@@ -83808,8 +84265,8 @@ ${next}` : next;
   // ── Parsing & validation ────────────────────────────────────────────────
   /** Parse a relay.yaml file from disk. */
   async parseYamlFile(filePath) {
-    const absPath = import_node_path29.default.resolve(this.cwd, filePath);
-    const raw = await (0, import_promises8.readFile)(absPath, "utf-8");
+    const absPath = import_node_path30.default.resolve(this.cwd, filePath);
+    const raw = await (0, import_promises9.readFile)(absPath, "utf-8");
     return this.parseYamlString(raw, absPath);
   }
   /** Parse a relay.yaml string. */
@@ -84008,14 +84465,14 @@ ${err.suggestion}`);
     }
     for (const agent of resolved.agents) {
       if (agent.cwd) {
-        const resolvedCwd = import_node_path29.default.resolve(this.cwd, agent.cwd);
+        const resolvedCwd = import_node_path30.default.resolve(this.cwd, agent.cwd);
         if (!(0, import_node_fs21.existsSync)(resolvedCwd)) {
           warnings.push(`Agent "${agent.name}" cwd "${agent.cwd}" resolves to "${resolvedCwd}" which does not exist`);
         }
       }
       if (agent.additionalPaths) {
         for (const ap of agent.additionalPaths) {
-          const resolvedPath = import_node_path29.default.resolve(this.cwd, ap);
+          const resolvedPath = import_node_path30.default.resolve(this.cwd, ap);
           if (!(0, import_node_fs21.existsSync)(resolvedPath)) {
             warnings.push(`Agent "${agent.name}" additionalPath "${ap}" resolves to "${resolvedPath}" which does not exist`);
           }
@@ -84590,7 +85047,7 @@ ${err.suggestion}`);
           }
         }
         this.log("Starting broker...");
-        const brokerBaseName = import_node_path29.default.basename(this.cwd) || "workflow";
+        const brokerBaseName = import_node_path30.default.basename(this.cwd) || "workflow";
         const brokerName = `${brokerBaseName}-${runId.slice(0, 8)}`;
         this.relay = new AgentRelay({
           ...this.relayOptions,
@@ -84612,7 +85069,7 @@ ${err.suggestion}`);
           if (/Read\(/.test(stripped)) {
             const m2 = stripped.match(/Read\(\s*~?([^\s)"']{8,})/);
             if (m2) {
-              const base = import_node_path29.default.basename(m2[1]);
+              const base = import_node_path30.default.basename(m2[1]);
               activity = base.length >= 3 ? `Reading ${base}` : "Reading file...";
             } else {
               activity = "Reading file...";
@@ -84620,7 +85077,7 @@ ${err.suggestion}`);
           } else if (/Edit\(/.test(stripped)) {
             const m2 = stripped.match(/Edit\(\s*~?([^\s)"']{8,})/);
             if (m2) {
-              const base = import_node_path29.default.basename(m2[1]);
+              const base = import_node_path30.default.basename(m2[1]);
               activity = base.length >= 3 ? `Editing ${base}` : "Editing file...";
             } else {
               activity = "Editing file...";
@@ -85461,14 +85918,14 @@ Repair only what is needed for this step to produce the required artifact or evi
         const stepOutputContext = this.buildStepOutputContext(stepStates, runId);
         const branch = this.interpolateStepTask(step.branch ?? "", stepOutputContext);
         const baseBranch = step.baseBranch ? this.interpolateStepTask(step.baseBranch, stepOutputContext) : "HEAD";
-        const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path29.default.join(".worktrees", step.name);
+        const worktreePath = step.path ? this.interpolateStepTask(step.path, stepOutputContext) : import_node_path30.default.join(".worktrees", step.name);
         const createBranch2 = step.createBranch !== false;
         const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
         this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
         if (!branch) {
           throw new Error('Worktree step missing required "branch" field');
         }
-        const absoluteWorktreePath = import_node_path29.default.resolve(stepCwd, worktreePath);
+        const absoluteWorktreePath = import_node_path30.default.resolve(stepCwd, worktreePath);
         let branchExists = false;
         await new Promise((resolve4) => {
           const checkChild = (0, import_node_child_process8.spawn)("git", ["rev-parse", "--verify", "--quiet", branch], {
@@ -86551,8 +87008,8 @@ WORKER COMPLETION CONTRACT:
         promptTaskText: taskText
       };
     }
-    const taskTmpDir = (0, import_node_fs21.mkdtempSync)(import_node_path29.default.join((0, import_node_os9.tmpdir)(), "relay-pty-task-"));
-    const taskTmpFile = import_node_path29.default.join(taskTmpDir, `${agentName}-${Date.now()}.txt`);
+    const taskTmpDir = (0, import_node_fs21.mkdtempSync)(import_node_path30.default.join((0, import_node_os10.tmpdir)(), "relay-pty-task-"));
+    const taskTmpFile = import_node_path30.default.join(taskTmpDir, `${agentName}-${Date.now()}.txt`);
     (0, import_node_fs21.writeFileSync)(taskTmpFile, taskText, { encoding: "utf8", mode: 384, flag: "wx" });
     const promptTaskText = `TASK_FILE:${taskTmpFile}
 Read that file completely before taking any action.
@@ -86958,7 +87415,7 @@ DO NOT:
 - Output only status messages without the actual deliverable content`;
     const { cmd, args } = _WorkflowRunner.buildNonInteractiveCommand(agentDef.cli, taskWithDeliverable, modelArgs);
     const logsDir = this.getWorkerLogsDir();
-    const logPath = import_node_path29.default.join(logsDir, `${agentName}.log`);
+    const logPath = import_node_path30.default.join(logsDir, `${agentName}.log`);
     const logStream = (0, import_node_fs21.createWriteStream)(logPath, { flags: "a" });
     this.registerWorker(agentName, agentDef.cli, step.task ?? "", void 0, false);
     let stopHeartbeat;
@@ -87126,7 +87583,7 @@ DO NOT:
     const preparedTask = this.prepareInteractiveSpawnTask(agentName, taskWithExit);
     this.ptyOutputBuffers.set(agentName, []);
     const logsDir = this.getWorkerLogsDir();
-    const logStream = (0, import_node_fs21.createWriteStream)(import_node_path29.default.join(logsDir, `${agentName}.log`), { flags: "a" });
+    const logStream = (0, import_node_fs21.createWriteStream)(import_node_path30.default.join(logsDir, `${agentName}.log`), { flags: "a" });
     this.ptyLogStreams.set(agentName, logStream);
     this.ptyListeners.set(agentName, (chunk) => {
       const stripped = _WorkflowRunner.stripAnsi(chunk);
@@ -87176,8 +87633,8 @@ DO NOT:
         const oldName = agentName;
         this.ptyOutputBuffers.set(agent.name, this.ptyOutputBuffers.get(oldName) ?? []);
         this.ptyOutputBuffers.delete(oldName);
-        const oldLogPath = import_node_path29.default.join(logsDir, `${oldName}.log`);
-        const newLogPath = import_node_path29.default.join(logsDir, `${agent.name}.log`);
+        const oldLogPath = import_node_path30.default.join(logsDir, `${oldName}.log`);
+        const newLogPath = import_node_path30.default.join(logsDir, `${agent.name}.log`);
         const oldLogStream = this.ptyLogStreams.get(oldName);
         if (oldLogStream) {
           oldLogStream.end();
@@ -87287,15 +87744,15 @@ DO NOT:
       this.supervisedRuntimeAgents.delete(agentName);
       this.runtimeStepAgents.delete(agentName);
       if (preparedTask.taskTmpFile) {
-        await (0, import_promises8.unlink)(preparedTask.taskTmpFile).catch(() => void 0);
+        await (0, import_promises9.unlink)(preparedTask.taskTmpFile).catch(() => void 0);
       }
     }
     let output;
     if (ptyChunks.length > 0) {
       output = ptyChunks.join("");
     } else {
-      const summaryPath = import_node_path29.default.join(this.summaryDir, `${step.name}.md`);
-      output = (0, import_node_fs21.existsSync)(summaryPath) ? await (0, import_promises8.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
+      const summaryPath = import_node_path30.default.join(this.summaryDir, `${step.name}.md`);
+      output = (0, import_node_fs21.existsSync)(summaryPath) ? await (0, import_promises9.readFile)(summaryPath, "utf-8") : exitResult === "timeout" ? "Agent completed (released after idle timeout)" : exitResult === "released" ? "Agent completed (idle \u2014 treated as done)" : `Agent exited (${exitResult})`;
     }
     if (ptyChunks.length === 0) {
       this.captureStepTerminalEvidence(evidenceStepName, { stdout: output, combined: output }, { exitCode: agent?.exitCode, exitSignal: agent?.exitSignal }, {
@@ -87747,7 +88204,7 @@ DO NOT:
       }
     }
     const outputDir = this.getStepOutputDir(runId);
-    const logsDir = import_node_path29.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
+    const logsDir = import_node_path30.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
     console.log("");
     console.log(`  Run ID:      ${runId}`);
     console.log(`  Step output: ${outputDir}`);
@@ -87833,7 +88290,7 @@ ${excerpt}` : "";
     if (!target)
       return;
     try {
-      (0, import_node_fs21.mkdirSync)(import_node_path29.default.dirname(target), { recursive: true });
+      (0, import_node_fs21.mkdirSync)(import_node_path30.default.dirname(target), { recursive: true });
       (0, import_node_fs21.writeFileSync)(target, runId + "\n", "utf8");
     } catch {
     }
@@ -87870,16 +88327,16 @@ ${excerpt}` : "";
   /** Directory for persisted step outputs: .agent-relay/step-outputs/{runId}/ */
   getStepOutputDir(runId) {
     this.validateRunId(runId);
-    return import_node_path29.default.join(this.cwd, ".agent-relay", "step-outputs", runId);
+    return import_node_path30.default.join(this.cwd, ".agent-relay", "step-outputs", runId);
   }
   /** Persist step output to disk and post full output as a channel message. */
   async persistStepOutput(runId, stepName, output) {
-    const outputPath = import_node_path29.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
+    const outputPath = import_node_path30.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
     try {
       const dir = this.getStepOutputDir(runId);
       (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
       const cleaned = _WorkflowRunner.stripAnsi(output);
-      await (0, import_promises8.writeFile)(outputPath, cleaned);
+      await (0, import_promises9.writeFile)(outputPath, cleaned);
     } catch {
     }
     this.recordStepToolSideEffect(stepName, {
@@ -87904,32 +88361,32 @@ ${preview}
 \`\`\``, { stepName });
   }
   async persistAgentReport(runId, stepName, report) {
-    const reportPath = import_node_path29.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
+    const reportPath = import_node_path30.default.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
     try {
       (0, import_node_fs21.mkdirSync)(this.getStepOutputDir(runId), { recursive: true });
-      await (0, import_promises8.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf8");
+      await (0, import_promises9.writeFile)(reportPath, JSON.stringify(report, null, 2), "utf8");
     } catch {
     }
   }
   /** Scan .agent-relay/step-outputs/ for the most recent run directory containing the needed steps. */
   findMostRecentRunWithSteps(stepNames) {
     try {
-      const baseDir = import_node_path29.default.join(this.cwd, ".agent-relay", "step-outputs");
+      const baseDir = import_node_path30.default.join(this.cwd, ".agent-relay", "step-outputs");
       if (!(0, import_node_fs21.existsSync)(baseDir))
         return void 0;
       const entries = (0, import_node_fs21.readdirSync)(baseDir);
       let best;
       for (const entry of entries) {
-        const dirPath = import_node_path29.default.join(baseDir, entry);
+        const dirPath = import_node_path30.default.join(baseDir, entry);
         try {
-          const stat2 = (0, import_node_fs21.statSync)(dirPath);
-          if (!stat2.isDirectory())
+          const stat3 = (0, import_node_fs21.statSync)(dirPath);
+          if (!stat3.isDirectory())
             continue;
-          const hasAny = [...stepNames].some((name) => (0, import_node_fs21.existsSync)(import_node_path29.default.join(dirPath, `${name}.md`)));
+          const hasAny = [...stepNames].some((name) => (0, import_node_fs21.existsSync)(import_node_path30.default.join(dirPath, `${name}.md`)));
           if (!hasAny)
             continue;
-          if (!best || stat2.mtimeMs > best.mtime) {
-            best = { name: entry, mtime: stat2.mtimeMs };
+          if (!best || stat3.mtimeMs > best.mtime) {
+            best = { name: entry, mtime: stat3.mtimeMs };
           }
         } catch {
           continue;
@@ -87943,7 +88400,7 @@ ${preview}
   /** Load persisted step output from disk. */
   loadStepOutput(runId, stepName) {
     try {
-      const filePath = import_node_path29.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
+      const filePath = import_node_path30.default.join(this.getStepOutputDir(runId), `${stepName}.md`);
       if (!(0, import_node_fs21.existsSync)(filePath))
         return void 0;
       return (0, import_node_fs21.readFileSync)(filePath, "utf-8");
@@ -87972,7 +88429,7 @@ ${preview}
       return null;
     let resumeConfig = config2 ?? this.currentConfig;
     if (!resumeConfig) {
-      const yamlPath = import_node_path29.default.join(this.cwd, "relay.yaml");
+      const yamlPath = import_node_path30.default.join(this.cwd, "relay.yaml");
       if ((0, import_node_fs21.existsSync)(yamlPath)) {
         try {
           const raw = (0, import_node_fs21.readFileSync)(yamlPath, "utf-8");
@@ -88001,8 +88458,8 @@ ${preview}
     let earliestMtime = Date.now();
     for (const stepName of cachedStepNames) {
       try {
-        const mdPath = import_node_path29.default.join(stepOutputDir, `${stepName}.md`);
-        const reportPath = import_node_path29.default.join(stepOutputDir, `${stepName}.report.json`);
+        const mdPath = import_node_path30.default.join(stepOutputDir, `${stepName}.md`);
+        const reportPath = import_node_path30.default.join(stepOutputDir, `${stepName}.report.json`);
         const mdStat = (0, import_node_fs21.existsSync)(mdPath) ? (0, import_node_fs21.statSync)(mdPath) : null;
         const reportStat = (0, import_node_fs21.existsSync)(reportPath) ? (0, import_node_fs21.statSync)(reportPath) : null;
         const mtime = Math.max(mdStat?.mtimeMs ?? 0, reportStat?.mtimeMs ?? 0);
@@ -88056,7 +88513,7 @@ ${preview}
   }
   /** Get or create the worker logs directory (.agent-relay/team/worker-logs) */
   getWorkerLogsDir() {
-    const logsDir = import_node_path29.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
+    const logsDir = import_node_path30.default.join(this.cwd, ".agent-relay", "team", "worker-logs");
     (0, import_node_fs21.mkdirSync)(logsDir, { recursive: true });
     return logsDir;
   }
@@ -88068,12 +88525,12 @@ ${preview}
       spawnedAt: Date.now(),
       pid,
       interactive,
-      logFile: import_node_path29.default.join(this.getWorkerLogsDir(), `${agentName}.log`)
+      logFile: import_node_path30.default.join(this.getWorkerLogsDir(), `${agentName}.log`)
     };
     this.activeWorkers.set(agentName, workerEntry);
     this.workersFileLock = this.workersFileLock.then(() => {
       try {
-        (0, import_node_fs21.mkdirSync)(import_node_path29.default.dirname(this.workersPath), { recursive: true });
+        (0, import_node_fs21.mkdirSync)(import_node_path30.default.dirname(this.workersPath), { recursive: true });
         const existing = this.readWorkers().filter((w2) => w2.name !== agentName);
         existing.push({ name: agentName, ...workerEntry });
         this.writeWorkers(existing);
@@ -88110,8 +88567,8 @@ ${preview}
 
 // packages/sdk/dist/workflows/file-db.js
 var import_node_fs22 = require("node:fs");
-var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path30 = __toESM(require("node:path"), 1);
+var import_node_os11 = __toESM(require("node:os"), 1);
+var import_node_path31 = __toESM(require("node:path"), 1);
 var JsonFileWorkflowDb = class _JsonFileWorkflowDb {
   filePath;
   /** Whether persistence is active. False = in-memory-only mode. */
@@ -88127,7 +88584,7 @@ var JsonFileWorkflowDb = class _JsonFileWorkflowDb {
   constructor(filePathOrOptions) {
     const options = typeof filePathOrOptions === "string" ? { filePath: filePathOrOptions } : filePathOrOptions;
     this.onWriteFailure = options.onWriteFailure;
-    const requestedPath = options.filePath ?? import_node_path30.default.join(".agent-relay", "workflow-runs.jsonl");
+    const requestedPath = options.filePath ?? import_node_path31.default.join(".agent-relay", "workflow-runs.jsonl");
     const homeFallback = options.homeFallback ?? false;
     const { resolvedPath, writable } = _JsonFileWorkflowDb.resolveStoragePath(requestedPath, homeFallback);
     this.filePath = resolvedPath;
@@ -88144,7 +88601,7 @@ var JsonFileWorkflowDb = class _JsonFileWorkflowDb {
   }
   hasStepOutputs(runId) {
     try {
-      const dir = import_node_path30.default.join(import_node_path30.default.dirname(this.filePath), "step-outputs", runId);
+      const dir = import_node_path31.default.join(import_node_path31.default.dirname(this.filePath), "step-outputs", runId);
       return (0, import_node_fs22.existsSync)(dir) && (0, import_node_fs22.readdirSync)(dir).length > 0;
     } catch {
       return false;
@@ -88154,16 +88611,16 @@ var JsonFileWorkflowDb = class _JsonFileWorkflowDb {
   static resolveStoragePath(requestedPath, homeFallback) {
     const candidates = [requestedPath];
     if (homeFallback) {
-      const base = import_node_path30.default.basename(requestedPath) || "workflow-runs.jsonl";
-      candidates.push(import_node_path30.default.join(import_node_os10.default.homedir(), ".agent-relay", `workflow-runs-${base}`));
+      const base = import_node_path31.default.basename(requestedPath) || "workflow-runs.jsonl";
+      candidates.push(import_node_path31.default.join(import_node_os11.default.homedir(), ".agent-relay", `workflow-runs-${base}`));
     }
     for (let i = 0; i < candidates.length; i++) {
       const candidate = candidates[i];
       const isLastCandidate = i === candidates.length - 1;
       try {
-        (0, import_node_fs22.mkdirSync)(import_node_path30.default.dirname(candidate), { recursive: true });
+        (0, import_node_fs22.mkdirSync)(import_node_path31.default.dirname(candidate), { recursive: true });
         if (!isLastCandidate) {
-          (0, import_node_fs22.accessSync)(import_node_path30.default.dirname(candidate), import_node_fs22.constants.W_OK);
+          (0, import_node_fs22.accessSync)(import_node_path31.default.dirname(candidate), import_node_fs22.constants.W_OK);
           if ((0, import_node_fs22.existsSync)(candidate)) {
             (0, import_node_fs22.accessSync)(candidate, import_node_fs22.constants.W_OK);
           }
@@ -88452,17 +88909,17 @@ async function runWorkflow(yamlPath, options = {}) {
 }
 
 // packages/cloud/src/auth.ts
-var import_promises9 = __toESM(require("node:fs/promises"), 1);
+var import_promises10 = __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_os13 = __toESM(require("node:os"), 1);
+var import_node_path33 = __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 import_node_os12 = __toESM(require("node:os"), 1);
+var import_node_path32 = __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");
+var AUTH_FILE_PATH = import_node_path32.default.join(import_node_os12.default.homedir(), ".agent-relay", "cloud-auth.json");
 function defaultApiUrl() {
   return process.env.CLOUD_API_URL?.trim() || "https://agentrelay.com/cloud";
 }
@@ -88530,7 +88987,7 @@ async function readStoredAuth(env = process.env) {
     return envAuth;
   }
   try {
-    const file2 = await import_promises9.default.readFile(AUTH_FILE_PATH, "utf8");
+    const file2 = await import_promises10.default.readFile(AUTH_FILE_PATH, "utf8");
     const parsed = JSON.parse(file2);
     return isValidStoredAuth(parsed) ? parsed : null;
   } catch {
@@ -88538,11 +88995,11 @@ async function readStoredAuth(env = process.env) {
   }
 }
 async function writeStoredAuth(auth) {
-  await import_promises9.default.mkdir(import_node_path32.default.dirname(AUTH_FILE_PATH), {
+  await import_promises10.default.mkdir(import_node_path33.default.dirname(AUTH_FILE_PATH), {
     recursive: true,
     mode: 448
   });
-  await import_promises9.default.writeFile(AUTH_FILE_PATH, `${JSON.stringify(auth, null, 2)}
+  await import_promises10.default.writeFile(AUTH_FILE_PATH, `${JSON.stringify(auth, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -88556,11 +89013,11 @@ function shouldRefresh(accessTokenExpiresAt) {
   return expiresAt - Date.now() <= REFRESH_WINDOW_MS;
 }
 function openBrowser(url2) {
-  const platform2 = import_node_os12.default.platform();
-  if (platform2 === "darwin") {
+  const platform3 = import_node_os13.default.platform();
+  if (platform3 === "darwin") {
     return (0, import_node_child_process9.spawn)("open", [url2], { stdio: "ignore", detached: true });
   }
-  if (platform2 === "win32") {
+  if (platform3 === "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 });
@@ -88757,8 +89214,8 @@ async function authorizedApiFetch(auth, requestPath, init) {
 }
 
 // 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_promises11 = __toESM(require("node:fs/promises"), 1);
+var import_node_path34 = __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);
@@ -88818,7 +89275,7 @@ ${message}`);
   }
 }
 function inferWorkflowFileType(filePath) {
-  const ext = import_node_path33.default.extname(filePath).toLowerCase();
+  const ext = import_node_path34.default.extname(filePath).toLowerCase();
   switch (ext) {
     case ".yaml":
     case ".yml":
@@ -88834,9 +89291,9 @@ function inferWorkflowFileType(filePath) {
   }
 }
 async function resolveWorkflowInput(workflowArg, explicitFileType) {
-  const looksLikeFile = import_node_path33.default.isAbsolute(workflowArg) || workflowArg.includes(import_node_path33.default.sep) || inferWorkflowFileType(workflowArg) !== null;
+  const looksLikeFile = import_node_path34.default.isAbsolute(workflowArg) || workflowArg.includes(import_node_path34.default.sep) || inferWorkflowFileType(workflowArg) !== null;
   try {
-    const workflow2 = await import_promises10.default.readFile(workflowArg, "utf-8");
+    const workflow2 = await import_promises11.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.`);
@@ -88875,7 +89332,7 @@ async function scheduleWorkflow(workflowArg, options = {}) {
     validateYamlWorkflow(input.workflow);
   }
   const requestBody = {
-    name: options.name?.trim() || import_node_path33.default.basename(workflowArg),
+    name: options.name?.trim() || import_node_path34.default.basename(workflowArg),
     schedule_type: hasCron ? "cron" : "once",
     timezone: options.timezone?.trim() || "UTC",
     workflowRequest: {
@@ -88976,7 +89433,7 @@ function isMissingFileError(error51) {
 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_node_path35 = __toESM(require("node:path"), 1);
 var import_yaml3 = __toESM(require_dist(), 1);
 
 // packages/sdk/dist/workflows/cloud-runner.js
@@ -89335,7 +89792,7 @@ var WorkflowBuilder = class {
   async run(options = {}) {
     const config2 = this.toConfig();
     const runnerCwd = options.cwd ?? process.cwd();
-    const dbPath = import_node_path34.default.join(runnerCwd, ".agent-relay", "workflow-runs.jsonl");
+    const dbPath = import_node_path35.default.join(runnerCwd, ".agent-relay", "workflow-runs.jsonl");
     const db = new JsonFileWorkflowDb(dbPath);
     const runner = new WorkflowRunner({
       cwd: options.cwd,
@@ -90253,7 +90710,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_path35 = __toESM(require("node:path"), 1);
+var import_node_path36 = __toESM(require("node:path"), 1);
 var import_node_url2 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
 var YAML_EXTENSIONS = [".yaml", ".yml"];
@@ -90278,7 +90735,7 @@ var TemplateRegistry = class {
   fetcher;
   constructor(options = {}) {
     this.builtInTemplatesDir = this.resolveBuiltInTemplatesDir(options.builtInTemplatesDir);
-    this.customTemplatesDir = options.customTemplatesDir ? import_node_path35.default.resolve(options.customTemplatesDir) : import_node_path35.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
+    this.customTemplatesDir = options.customTemplatesDir ? import_node_path36.default.resolve(options.customTemplatesDir) : import_node_path36.default.resolve(options.workspaceDir ?? process.cwd(), ".relay/workflows");
     this.fetcher = options.fetcher ?? fetch;
   }
   listBuiltInTemplates() {
@@ -90352,12 +90809,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_path35.default.isAbsolute(templateName)) {
+    if (templateName.includes("/") || templateName.includes("\\") || templateName.includes("..") || import_node_path36.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_path35.default.join(this.customTemplatesDir, `${templateName}.yaml`);
+    const targetPath = import_node_path36.default.join(this.customTemplatesDir, `${templateName}.yaml`);
     await import_node_fs23.promises.writeFile(targetPath, (0, import_yaml4.stringify)(parsed), "utf-8");
     return targetPath;
   }
@@ -90379,12 +90836,12 @@ var TemplateRegistry = class {
   }
   resolveBuiltInTemplatesDir(explicitDir) {
     if (explicitDir) {
-      return import_node_path35.default.resolve(explicitDir);
+      return import_node_path36.default.resolve(explicitDir);
     }
-    const currentDir = import_node_path35.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
+    const currentDir = import_node_path36.default.dirname((0, import_node_url2.fileURLToPath)(import_meta_url));
     const candidates = [
-      import_node_path35.default.resolve(currentDir, "builtin-templates"),
-      import_node_path35.default.resolve(currentDir, "../workflows/builtin-templates")
+      import_node_path36.default.resolve(currentDir, "builtin-templates"),
+      import_node_path36.default.resolve(currentDir, "../workflows/builtin-templates")
     ];
     for (const candidate of candidates) {
       if ((0, import_node_fs23.existsSync)(candidate)) {
@@ -90407,10 +90864,10 @@ var TemplateRegistry = class {
   }
   async findTemplatePath(directory, templateName) {
     for (const ext of YAML_EXTENSIONS) {
-      const candidate = import_node_path35.default.join(directory, `${templateName}${ext}`);
+      const candidate = import_node_path36.default.join(directory, `${templateName}${ext}`);
       try {
-        const stat2 = await import_node_fs23.promises.stat(candidate);
-        if (stat2.isFile()) {
+        const stat3 = await import_node_fs23.promises.stat(candidate);
+        if (stat3.isFile()) {
           return candidate;
         }
       } catch {
@@ -90755,7 +91212,7 @@ function pythonVerifyCommand() {
 
 // packages/sdk/dist/workflows/run-script.js
 var import_node_fs24 = __toESM(require("node:fs"), 1);
-var import_node_path36 = __toESM(require("node:path"), 1);
+var import_node_path37 = __toESM(require("node:path"), 1);
 var import_node_child_process10 = require("node:child_process");
 function diag(msg) {
   try {
@@ -90770,12 +91227,12 @@ function diag(msg) {
   }
 }
 function findLocalSdkWorkspace(startDir) {
-  let current = import_node_path36.default.resolve(startDir);
-  const root = import_node_path36.default.parse(current).root;
+  let current = import_node_path37.default.resolve(startDir);
+  const root = import_node_path37.default.parse(current).root;
   while (true) {
-    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");
+    const packageJsonPath = import_node_path37.default.join(current, "package.json");
+    const sdkDir = import_node_path37.default.join(current, "packages", "sdk");
+    const sdkPackageJsonPath = import_node_path37.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"));
@@ -90788,14 +91245,14 @@ function findLocalSdkWorkspace(startDir) {
     }
     if (current === root)
       return null;
-    current = import_node_path36.default.dirname(current);
+    current = import_node_path37.default.dirname(current);
   }
 }
 function ensureLocalSdkWorkflowRuntime(startDir, execRunner = import_node_child_process10.execFileSync) {
   const workspace = findLocalSdkWorkspace(startDir);
   if (!workspace)
     return;
-  const workflowsEntry = import_node_path36.default.join(workspace.sdkDir, "dist", "workflows", "index.js");
+  const workflowsEntry = import_node_path37.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 SDK workflow dependencies...");
@@ -90858,8 +91315,8 @@ function resolveLocalTypeScriptImport(fromFile, specifier) {
   if (!specifier.startsWith(".") && !specifier.startsWith("/")) {
     return null;
   }
-  const basePath = specifier.startsWith("/") ? import_node_path36.default.resolve(specifier) : import_node_path36.default.resolve(import_node_path36.default.dirname(fromFile), specifier);
-  const ext = import_node_path36.default.extname(basePath);
+  const basePath = specifier.startsWith("/") ? import_node_path37.default.resolve(specifier) : import_node_path37.default.resolve(import_node_path37.default.dirname(fromFile), specifier);
+  const ext = import_node_path37.default.extname(basePath);
   const candidates = ext === ".js" || ext === ".mjs" || ext === ".cjs" ? [
     `${basePath.slice(0, -ext.length)}.ts`,
     `${basePath.slice(0, -ext.length)}.tsx`,
@@ -90871,10 +91328,10 @@ function resolveLocalTypeScriptImport(fromFile, specifier) {
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    import_node_path36.default.join(basePath, "index.ts"),
-    import_node_path36.default.join(basePath, "index.tsx"),
-    import_node_path36.default.join(basePath, "index.mts"),
-    import_node_path36.default.join(basePath, "index.cts")
+    import_node_path37.default.join(basePath, "index.ts"),
+    import_node_path37.default.join(basePath, "index.tsx"),
+    import_node_path37.default.join(basePath, "index.mts"),
+    import_node_path37.default.join(basePath, "index.cts")
   ];
   for (const candidate of candidates) {
     if (/\.(?:ts|tsx|mts|cts)$/.test(candidate) && import_node_fs24.default.existsSync(candidate)) {
@@ -90895,7 +91352,7 @@ function findStaticLocalTypeScriptImports(filePath, source) {
   return imports;
 }
 function shouldSkipNodeStripTypesPreflight(filePath, seen = /* @__PURE__ */ new Set(), isEntry = true) {
-  const resolvedPath = import_node_path36.default.resolve(filePath);
+  const resolvedPath = import_node_path37.default.resolve(filePath);
   if (seen.has(resolvedPath)) {
     return false;
   }
@@ -91024,14 +91481,14 @@ async function spawnRunnerWithStderrCapture(command, args, env) {
 }
 async function runScriptWorkflow(filePath, options = {}) {
   diag(`runScriptWorkflow: resolving ${filePath}`);
-  const resolved = import_node_path36.default.resolve(filePath);
+  const resolved = import_node_path37.default.resolve(filePath);
   if (!import_node_fs24.default.existsSync(resolved)) {
     throw new Error(`File not found: ${resolved}`);
   }
-  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`);
+  const ext = import_node_path37.default.extname(resolved).toLowerCase();
+  const runIdFile = import_node_path37.default.join(process.cwd(), ".agent-relay", `script-run-id-${process.pid}-${Date.now()}.txt`);
   try {
-    import_node_fs24.default.mkdirSync(import_node_path36.default.dirname(runIdFile), { recursive: true });
+    import_node_fs24.default.mkdirSync(import_node_path37.default.dirname(runIdFile), { recursive: true });
   } catch {
   }
   const childEnv = { ...process.env, AGENT_RELAY_RUN_ID_FILE: runIdFile };
@@ -91069,7 +91526,7 @@ Run ID: ${runId}`;
   };
   if (ext === ".ts" || ext === ".tsx") {
     diag("runScriptWorkflow: ensureLocalSdkWorkflowRuntime start");
-    ensureLocalSdkWorkflowRuntime(import_node_path36.default.dirname(resolved));
+    ensureLocalSdkWorkflowRuntime(import_node_path37.default.dirname(resolved));
     diag("runScriptWorkflow: ensureLocalSdkWorkflowRuntime done");
     const wrapRunnerError = (runner, result) => {
       const parsed = parseTsxStderr(result.stderr);
@@ -92495,7 +92952,7 @@ function isValidAgentName(name) {
 
 // packages/utils/dist/logger.js
 var import_node_fs25 = __toESM(require("node:fs"), 1);
-var import_node_path37 = __toESM(require("node:path"), 1);
+var import_node_path38 = __toESM(require("node:path"), 1);
 function getLogFile() {
   return process.env.AGENT_RELAY_LOG_FILE;
 }
@@ -92513,7 +92970,7 @@ var LEVEL_PRIORITY = {
 };
 var createdLogDirs = /* @__PURE__ */ new Set();
 function ensureLogDir(logFile) {
-  const logDir = import_node_path37.default.dirname(logFile);
+  const logDir = import_node_path38.default.dirname(logFile);
   if (!createdLogDirs.has(logDir) && !import_node_fs25.default.existsSync(logDir)) {
     import_node_fs25.default.mkdirSync(logDir, { recursive: true });
     createdLogDirs.add(logDir);
@@ -92959,16 +93416,16 @@ function getRepoFullNameFromPath(workingDirectory) {
 
 // packages/utils/dist/update-checker.js
 var import_node_fs27 = __toESM(require("node:fs"), 1);
-var import_node_path38 = __toESM(require("node:path"), 1);
+var import_node_path39 = __toESM(require("node:path"), 1);
 var import_node_https2 = __toESM(require("node:https"), 1);
-var import_node_os14 = __toESM(require("node:os"), 1);
+var import_node_os15 = __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_path38.default.join(import_node_os14.default.homedir(), ".agent-relay");
-  return import_node_path38.default.join(cacheDir, "update-cache.json");
+  const cacheDir = import_node_path39.default.join(import_node_os15.default.homedir(), ".agent-relay");
+  return import_node_path39.default.join(cacheDir, "update-cache.json");
 }
 function readCache() {
   try {
@@ -92984,7 +93441,7 @@ function readCache() {
 function writeCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = import_node_path38.default.dirname(cachePath);
+    const cacheDir = import_node_path39.default.dirname(cachePath);
     if (!import_node_fs27.default.existsSync(cacheDir)) {
       import_node_fs27.default.mkdirSync(cacheDir, { recursive: true });
     }
@@ -93268,8 +93725,8 @@ function validateModelForCli(cli, model) {
 
 // packages/utils/dist/relay-pty-path.js
 var import_node_fs28 = __toESM(require("node:fs"), 1);
-var import_node_os15 = __toESM(require("node:os"), 1);
-var import_node_path39 = __toESM(require("node:path"), 1);
+var import_node_os16 = __toESM(require("node:os"), 1);
+var import_node_path40 = __toESM(require("node:path"), 1);
 var SUPPORTED_PLATFORMS = {
   darwin: {
     arm64: "relay-pty-darwin-arm64",
@@ -93281,14 +93738,14 @@ var SUPPORTED_PLATFORMS = {
   }
 };
 function getPlatformBinaryName() {
-  const platform2 = import_node_os15.default.platform();
-  const arch = import_node_os15.default.arch();
-  return SUPPORTED_PLATFORMS[platform2]?.[arch] ?? null;
+  const platform3 = import_node_os16.default.platform();
+  const arch = import_node_os16.default.arch();
+  return SUPPORTED_PLATFORMS[platform3]?.[arch] ?? null;
 }
 function isPlatformSupported() {
-  const platform2 = import_node_os15.default.platform();
-  const arch = import_node_os15.default.arch();
-  return SUPPORTED_PLATFORMS[platform2]?.[arch] !== void 0;
+  const platform3 = import_node_os16.default.platform();
+  const arch = import_node_os16.default.arch();
+  return SUPPORTED_PLATFORMS[platform3]?.[arch] !== void 0;
 }
 function getSupportedPlatforms() {
   const platforms = [];
@@ -93317,19 +93774,19 @@ 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_path39.default.join(scopedMatch[1], "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(scopedMatch[1], "agent-relay"));
   }
   if (directMatch) {
     packageRoots.push(directMatch[1]);
   }
   const home = process.env.HOME || process.env.USERPROFILE || "";
   if (home) {
-    const npxCacheBase = import_node_path39.default.join(home, ".npm", "_npx");
+    const npxCacheBase = import_node_path40.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_path39.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
+          const npxPackage = import_node_path40.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
           if (import_node_fs28.default.existsSync(npxPackage)) {
             packageRoots.push(npxPackage);
           }
@@ -93338,42 +93795,42 @@ function findRelayPtyBinary(callerDirname) {
       }
     }
   }
-  packageRoots.push(import_node_path39.default.join(process.cwd(), "node_modules", "agent-relay"));
+  packageRoots.push(import_node_path40.default.join(process.cwd(), "node_modules", "agent-relay"));
   if (home) {
-    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(import_node_path40.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, "n", "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
+    packageRoots.push(import_node_path40.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
+  }
+  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path40.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path40.default.join(home, ".agent-relay", "bin") : null;
+  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path40.default.join(home, ".local", "bin") : null);
+  const nodePrefix = import_node_path40.default.resolve(import_node_path40.default.dirname(process.execPath), "..");
+  packageRoots.push(import_node_path40.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_path39.default.join(root, "bin", platformBinary));
+      candidates.push(import_node_path40.default.join(root, "bin", platformBinary));
     }
-    candidates.push(import_node_path39.default.join(root, "bin", "relay-pty"));
+    candidates.push(import_node_path40.default.join(root, "bin", "relay-pty"));
   }
   if (bashInstallerDir) {
     if (platformBinary) {
-      candidates.push(import_node_path39.default.join(bashInstallerDir, platformBinary));
+      candidates.push(import_node_path40.default.join(bashInstallerDir, platformBinary));
     }
-    candidates.push(import_node_path39.default.join(bashInstallerDir, "relay-pty"));
+    candidates.push(import_node_path40.default.join(bashInstallerDir, "relay-pty"));
   }
   if (bashInstallerBinDir) {
     if (platformBinary) {
-      candidates.push(import_node_path39.default.join(bashInstallerBinDir, platformBinary));
+      candidates.push(import_node_path40.default.join(bashInstallerBinDir, platformBinary));
     }
-    candidates.push(import_node_path39.default.join(bashInstallerBinDir, "relay-pty"));
+    candidates.push(import_node_path40.default.join(bashInstallerBinDir, "relay-pty"));
   }
   candidates.push("/app/bin/relay-pty");
   candidates.push("/usr/local/bin/relay-pty");
@@ -93404,11 +93861,11 @@ function isPlatformCompatibleBinary(filePath) {
       return false;
     }
     const magic = header.readUInt32BE(0);
-    const platform2 = import_node_os15.default.platform();
-    if (platform2 === "darwin") {
+    const platform3 = import_node_os16.default.platform();
+    if (platform3 === "darwin") {
       return isMachOBinary(magic);
     }
-    if (platform2 === "linux") {
+    if (platform3 === "linux") {
       return magic === 2135247942;
     }
     return true;
@@ -94037,52 +94494,52 @@ 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_path40 = __toESM(require("node:path"), 1);
+var import_node_path41 = __toESM(require("node:path"), 1);
 var import_node_fs29 = __toESM(require("node:fs"), 1);
-var import_node_os16 = __toESM(require("node:os"), 1);
+var import_node_os17 = __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_path40.default.join(xdgDataHome, "agent-relay");
+    return import_node_path41.default.join(xdgDataHome, "agent-relay");
   }
-  return import_node_path40.default.join(import_node_os16.default.homedir(), ".agent-relay");
+  return import_node_path41.default.join(import_node_os17.default.homedir(), ".agent-relay");
 }
 var GLOBAL_BASE_DIR2 = getGlobalBaseDir2();
 var PROJECT_DATA_DIR = ".agent-relay";
 function hashPath(projectPath) {
-  const normalized = import_node_path40.default.resolve(projectPath);
+  const normalized = import_node_path41.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_path40.default.resolve(process.env.AGENT_RELAY_PROJECT);
+    return import_node_path41.default.resolve(process.env.AGENT_RELAY_PROJECT);
   }
-  let current = import_node_path40.default.resolve(startDir);
-  const root = import_node_path40.default.parse(current).root;
+  let current = import_node_path41.default.resolve(startDir);
+  const root = import_node_path41.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_path40.default.join(current, marker))) {
+      if (import_node_fs29.default.existsSync(import_node_path41.default.join(current, marker))) {
         return current;
       }
     }
-    current = import_node_path40.default.dirname(current);
+    current = import_node_path41.default.dirname(current);
   }
-  return import_node_path40.default.resolve(startDir);
+  return import_node_path41.default.resolve(startDir);
 }
 function getProjectPaths2(projectRoot) {
   const root = projectRoot ?? findProjectRoot();
   const projectId = hashPath(root);
-  const dataDir = import_node_path40.default.join(root, PROJECT_DATA_DIR);
+  const dataDir = import_node_path41.default.join(root, PROJECT_DATA_DIR);
   return {
     dataDir,
-    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"),
+    teamDir: import_node_path41.default.join(dataDir, "team"),
+    dbPath: import_node_path41.default.join(dataDir, "messages.sqlite"),
+    socketPath: import_node_path41.default.join(dataDir, "relay.sock"),
     projectRoot: root,
     projectId
   };
@@ -94090,22 +94547,22 @@ function getProjectPaths2(projectRoot) {
 
 // packages/config/dist/trajectory-config.js
 var import_node_fs30 = require("node:fs");
-var import_node_path41 = require("node:path");
-var import_node_os17 = require("node:os");
+var import_node_path42 = require("node:path");
+var import_node_os18 = require("node:os");
 var import_node_crypto17 = require("node:crypto");
 function getAgentRelayConfigDir() {
-  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path41.join)((0, import_node_os17.homedir)(), ".config", "agent-relay");
+  return process.env.AGENT_RELAY_CONFIG_DIR ?? (0, import_node_path42.join)((0, import_node_os18.homedir)(), ".config", "agent-relay");
 }
 var configCache = null;
 function getRelayConfigPath(_projectRoot) {
-  return (0, import_node_path41.join)(getAgentRelayConfigDir(), "relay.json");
+  return (0, import_node_path42.join)(getAgentRelayConfigDir(), "relay.json");
 }
 function readRelayConfig(projectRoot) {
   const configPath = getRelayConfigPath(projectRoot);
   if (configCache && configCache.path === configPath) {
     try {
-      const stat2 = (0, import_node_fs30.statSync)(configPath);
-      if (stat2.mtimeMs === configCache.mtime) {
+      const stat3 = (0, import_node_fs30.statSync)(configPath);
+      if (stat3.mtimeMs === configCache.mtime) {
         return configCache.config;
       }
     } catch {
@@ -94118,8 +94575,8 @@ function readRelayConfig(projectRoot) {
     const content = (0, import_node_fs30.readFileSync)(configPath, "utf-8");
     const config2 = JSON.parse(content);
     try {
-      const stat2 = (0, import_node_fs30.statSync)(configPath);
-      configCache = { path: configPath, config: config2, mtime: stat2.mtimeMs };
+      const stat3 = (0, import_node_fs30.statSync)(configPath);
+      configCache = { path: configPath, config: config2, mtime: stat3.mtimeMs };
     } catch {
     }
     return config2;
@@ -94138,12 +94595,12 @@ function getProjectHash(projectRoot) {
 }
 function getUserTrajectoriesDir(projectRoot) {
   const projectHash = getProjectHash(projectRoot);
-  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);
+  const configDir = process.env.XDG_CONFIG_HOME || (0, import_node_path42.join)((0, import_node_os18.homedir)(), ".config");
+  return (0, import_node_path42.join)(configDir, "agent-relay", "trajectories", projectHash);
 }
 function getRepoTrajectoriesDir(projectRoot) {
   const root = projectRoot ?? getProjectPaths2().projectRoot;
-  return (0, import_node_path41.join)(root, ".trajectories");
+  return (0, import_node_path42.join)(root, ".trajectories");
 }
 function getPrimaryTrajectoriesDir(projectRoot) {
   if (shouldStoreInRepo(projectRoot)) {
@@ -94784,7 +95241,7 @@ var HookEmitter = class {
 
 // packages/hooks/dist/inbox-check/utils.js
 var import_node_fs31 = require("node:fs");
-var import_node_path42 = require("node:path");
+var import_node_path43 = require("node:path");
 var DEFAULT_INBOX_DIR = "/tmp/agent-relay";
 function getAgentName() {
   return process.env.AGENT_RELAY_NAME;
@@ -94794,7 +95251,7 @@ function getInboxPath(config2) {
   if (!agentName) {
     throw new Error("Agent name not configured. Set AGENT_RELAY_NAME env var.");
   }
-  return (0, import_node_path42.join)(config2.inboxDir, agentName, "inbox.md");
+  return (0, import_node_path43.join)(config2.inboxDir, agentName, "inbox.md");
 }
 function inboxExists(inboxPath) {
   return (0, import_node_fs31.existsSync)(inboxPath);
@@ -94948,6 +95405,7 @@ init_dist2();
   checkOutputContains,
   cleanLines,
   clearBinaryCache,
+  clearBrokerLogs,
   clearResolveCache,
   collectCliSession,
   collectOutput,
@@ -95001,6 +95459,7 @@ init_dist2();
   generateUniqueAgentName,
   getAgentName,
   getBaseCli,
+  getBrokerLogDir,
   getCachedRelayPtyPath,
   getCliDefinition,
   getCliRegistry,
@@ -95044,6 +95503,7 @@ init_dist2();
   isTrajectoryTrackingAvailable,
   isValidAgentName,
   isWorktreeStep,
+  listBrokerLogs,
   listLoggedAgents,
   listPersonas,
   listWorkflowSchedules,
@@ -95059,6 +95519,7 @@ init_dist2();
   parseTsxStderr,
   parseVoteCommand,
   printUpdateNotification,
+  pruneBrokerLogs,
   readInbox,
   resetPatternMetrics,
   resolveAllCustomSteps,
@@ -95091,6 +95552,7 @@ init_dist2();
   stripAnsi,
   stripAnsiFast,
   stripInjectedTaskEcho,
+  tailBrokerLog,
   toReleaseResult,
   toSpawnResult,
   trackPatternPerformance,