@ai-sdk/harness 1.0.132 → 1.0.134

package/dist/utils/index.js

@@ -1,799 +1,667 @@
-// src/utils/sandbox-channel.ts
-import {
-  safeParseJSON,
-  safeValidateTypes
-} from "@ai-sdk/provider-utils";
-
-// src/utils/sleep.ts
-function sleep({
-  ms,
-  abortSignal
-}) {
-  return new Promise((resolve) => {
-    if (abortSignal?.aborted) {
-      resolve();
-      return;
-    }
-    let settled = false;
-    let onAbort = () => {
-    };
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      abortSignal?.removeEventListener("abort", onAbort);
-      resolve();
-    };
-    const timer = setTimeout(finish, ms);
-    timer.unref?.();
-    onAbort = () => {
-      clearTimeout(timer);
-      finish();
-    };
-    abortSignal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-// src/utils/sandbox-channel.ts
-var sandboxChannelEventCheckpointSymbol = /* @__PURE__ */ Symbol.for(
-  "vercel.ai.harness.sandboxChannelEventCheckpoint"
-);
-function getAbortReason({
-  abortSignal
-}) {
-  return abortSignal.reason ?? new Error("SandboxChannel connection aborted");
+import { isRecord, safeParseJSON, safeValidateTypes } from "@ai-sdk/provider-utils";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash, randomBytes } from "node:crypto";
+import path, { posix } from "node:path";
+import { z } from "zod/v4";
+import { readFile } from "node:fs/promises";
+//#region src/utils/sleep.ts
+function sleep({ ms, abortSignal }) {
+	return new Promise((resolve) => {
+		if (abortSignal?.aborted) {
+			resolve();
+			return;
+		}
+		let settled = false;
+		let onAbort = () => {};
+		const finish = () => {
+			if (settled) return;
+			settled = true;
+			abortSignal?.removeEventListener("abort", onAbort);
+			resolve();
+		};
+		const timer = setTimeout(finish, ms);
+		timer.unref?.();
+		onAbort = () => {
+			clearTimeout(timer);
+			finish();
+		};
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+//#region src/utils/sandbox-channel.ts
+const sandboxChannelEventCheckpointSymbol = Symbol.for("vercel.ai.harness.sandboxChannelEventCheckpoint");
+function getAbortReason({ abortSignal }) {
+	return abortSignal.reason ?? /* @__PURE__ */ new Error("SandboxChannel connection aborted");
 }
 function closeWebSocket({ ws }) {
-  try {
-    const terminable = ws;
-    if (terminable.terminate != null) {
-      terminable.terminate();
-    } else {
-      ws.close();
-    }
-  } catch {
-    try {
-      ws.close();
-    } catch {
-    }
-  }
-}
-async function awaitWebSocketConnection({
-  connection,
-  abortSignal
-}) {
-  if (abortSignal.aborted) {
-    void connection.then((ws) => closeWebSocket({ ws })).catch(() => {
-    });
-    throw getAbortReason({ abortSignal });
-  }
-  let onAbort;
-  const aborted = new Promise((_, reject) => {
-    onAbort = () => reject(getAbortReason({ abortSignal }));
-    abortSignal.addEventListener("abort", onAbort, { once: true });
-  });
-  try {
-    const ws = await Promise.race([connection, aborted]);
-    if (abortSignal.aborted) {
-      closeWebSocket({ ws });
-      throw getAbortReason({ abortSignal });
-    }
-    return ws;
-  } catch (error) {
-    if (abortSignal.aborted) {
-      void connection.then((ws) => closeWebSocket({ ws })).catch(() => {
-      });
-    }
-    throw error;
-  } finally {
-    if (onAbort != null) {
-      abortSignal.removeEventListener("abort", onAbort);
-    }
-  }
-}
+	try {
+		const terminable = ws;
+		if (terminable.terminate != null) terminable.terminate();
+		else ws.close();
+	} catch {
+		try {
+			ws.close();
+		} catch {}
+	}
+}
+async function awaitWebSocketConnection({ connection, abortSignal }) {
+	if (abortSignal.aborted) {
+		connection.then((ws) => closeWebSocket({ ws })).catch(() => {});
+		throw getAbortReason({ abortSignal });
+	}
+	let onAbort;
+	const aborted = new Promise((_, reject) => {
+		onAbort = () => reject(getAbortReason({ abortSignal }));
+		abortSignal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		const ws = await Promise.race([connection, aborted]);
+		if (abortSignal.aborted) {
+			closeWebSocket({ ws });
+			throw getAbortReason({ abortSignal });
+		}
+		return ws;
+	} catch (error) {
+		if (abortSignal.aborted) connection.then((ws) => closeWebSocket({ ws })).catch(() => {});
+		throw error;
+	} finally {
+		if (onAbort != null) abortSignal.removeEventListener("abort", onAbort);
+	}
+}
+/**
+* Host-side typed wrapper around the bridge WebSocket connection.
+*
+* Buffers inbound messages in arrival order while listeners attach, so callers
+* do not miss or reorder early frames. Listener registration drains the
+* ordered prefix synchronously. Selective listeners are given through the
+* current task (including its microtasks) to attach before unhandled event
+* types are retained independently, so they cannot block subscribed event
+* types indefinitely. A listener that claims an already-buffered event still
+* receives it if it unsubscribes before that ordered drain completes. Use
+* {@link SandboxChannel.beginListenerAttachment} to define an explicit
+* attachment boundary that spans asynchronous work. Inbound dispatch is
+* serialised through a promise chain so a `close` event that arrives on the
+* same microtask as the final `finish` message does not fire close handlers
+* until the message has been dispatched.
+*
+* Survives transient disconnects. The bridge keeps running and
+* accumulates events in an in-memory log keyed by a monotonic `seq`; on an
+* unexpected socket drop this channel re-invokes `connect`, re-wires the new
+* socket, and asks the bridge to replay everything past `lastSeenEventId`. The
+* in-flight turn never observes the blip — `onClose` fires only after a
+* host-initiated close or once the reconnect budget is exhausted.
+*/
 var SandboxChannel = class {
-  constructor(options) {
-    this.listeners = /* @__PURE__ */ new Map();
-    this.buffered = [];
-    this.bufferedByType = /* @__PURE__ */ new Map();
-    this.bufferedOffset = 0;
-    this.flushingBuffered = false;
-    this.bufferedFlushScheduled = false;
-    this.listenerAttachmentDepth = 0;
-    this.onCloseHandlers = /* @__PURE__ */ new Set();
-    this.onReconnectHandlers = /* @__PURE__ */ new Set();
-    this.connected = false;
-    /** Host has begun teardown; suppresses reconnect so a bridge-side close finalises. */
-    this.closing = false;
-    /**
-     * Host has gracefully suspended (slice boundary). Inbound frames are ignored
-     * from this point so the cursor stops advancing exactly at the last delivered
-     * event — the bridge keeps the turn running and the not-yet-delivered tail is
-     * replayed to the next process on `resume`.
-     */
-    this.suspended = false;
-    /** Channel is fully torn down; `send` throws and `onClose` has fired. */
-    this.terminal = false;
-    this._lastSeenEventId = 0;
-    this.pendingSends = [];
-    this.dispatchChain = Promise.resolve();
-    this.connectThunk = options.connect;
-    this.outboundSchema = options.outboundSchema;
-    this.onDebug = options.onDebug;
-    this.onDiagnostic = options.onDiagnostic;
-    this.onBridgeError = options.onBridgeError;
-    this.maxElapsedMs = options.reconnect?.maxElapsedMs ?? 3e4;
-    this.initialDelayMs = options.reconnect?.initialDelayMs ?? 50;
-    this.maxDelayMs = options.reconnect?.maxDelayMs ?? 2e3;
-    this._lastSeenEventId = options.initialLastSeenEventId ?? 0;
-  }
-  /**
-   * Highest bridge event `seq` this channel has observed. Persist it (e.g. via
-   * the adapter's resume handle) so a future process can seed
-   * {@link SandboxChannelOptions.initialLastSeenEventId} and attach.
-   */
-  get lastSeenEventId() {
-    return this._lastSeenEventId;
-  }
-  /**
-   * Establish the initial connection. A single attempt — startup failures
-   * reject so the caller can fail `doStart` cleanly. Reconnect retries apply
-   * only to drops after a successful open.
-   *
-   * Pass `{ resume: true }` to attach to a bridge that is already mid-session:
-   * after the socket opens, the channel sends `{ type: 'resume', lastSeenEventId }`
-   * so the bridge replays everything past the seeded cursor. This is the
-   * cross-process attach handshake — identical to what a transient reconnect
-   * does, but triggered by the initial open from a new process.
-   */
-  async open(opts) {
-    if (this.terminal) {
-      throw new Error("SandboxChannel: cannot open a closed channel.");
-    }
-    const abortController = new AbortController();
-    this.activeConnectAbortController = abortController;
-    try {
-      const ws = await this.connect({
-        abortSignal: abortController.signal
-      });
-      this.wire(ws);
-      this.ws = ws;
-      this.connected = true;
-      if (opts?.resume) {
-        this.rawSend(
-          JSON.stringify({
-            type: "resume",
-            lastSeenEventId: this._lastSeenEventId
-          })
-        );
-      }
-    } finally {
-      if (this.activeConnectAbortController === abortController) {
-        this.activeConnectAbortController = void 0;
-      }
-    }
-  }
-  on(type, listener) {
-    let set = this.listeners.get(type);
-    if (!set) {
-      set = /* @__PURE__ */ new Set();
-      this.listeners.set(type, set);
-    }
-    set.add(listener);
-    this.captureBufferedListeners(type);
-    if (this.listenerAttachmentDepth > 0) {
-      return () => {
-        set.delete(listener);
-      };
-    }
-    this.flushBufferedType(type);
-    this.flushBuffered();
-    this.scheduleSelectiveBufferedFlush();
-    return () => {
-      set.delete(listener);
-    };
-  }
-  /**
-   * Hold buffered event delivery while a consumer attaches a related set of
-   * listeners, including across asynchronous boundaries. Call the returned
-   * function once registration is complete. Buffered events are then replayed
-   * in arrival order; event types that remain unhandled are retained
-   * independently so they do not block subscribed types.
-   */
-  beginListenerAttachment() {
-    this.listenerAttachmentDepth++;
-    let finished = false;
-    return () => {
-      if (finished) return;
-      finished = true;
-      this.listenerAttachmentDepth--;
-      if (this.listenerAttachmentDepth > 0) return;
-      for (const type of this.listeners.keys()) {
-        this.flushBufferedType(type);
-      }
-      this.flushBuffered();
-      this.scheduleSelectiveBufferedFlush();
-    };
-  }
-  onClose(handler) {
-    this.onCloseHandlers.add(handler);
-  }
-  onReconnect(handler) {
-    this.onReconnectHandlers.add(handler);
-    return () => {
-      this.onReconnectHandlers.delete(handler);
-    };
-  }
-  send(message) {
-    if (this.terminal) {
-      throw new Error(
-        `SandboxChannel: cannot send ${message.type} \u2014 channel is closed.`
-      );
-    }
-    this.rawSend(JSON.stringify(message));
-  }
-  /**
-   * Mark that the host is tearing the session down. The next socket close is
-   * then treated as terminal rather than triggering a reconnect. Call before
-   * sending a `stop` / `destroy` message whose completion closes the bridge
-   * socket.
-   */
-  beginClose() {
-    this.closing = true;
-    this.abortActiveConnect();
-  }
-  close() {
-    if (this.terminal) return;
-    this.closing = true;
-    this.abortActiveConnect();
-    try {
-      this.ws?.close();
-    } catch {
-    }
-    this.enqueue(() => this.finalizeClose(1e3, "closed"));
-  }
-  /**
-   * Gracefully suspend at a slice boundary: stop processing inbound frames
-   * (so the cursor freezes at the last delivered event), drain any frames
-   * already queued for dispatch, then close the socket and finalise with the
-   * close reason `'suspended'`. Resolves with the final `lastSeenEventId`.
-   *
-   * The bridge keeps the in-flight turn running (a host socket close never
-   * aborts it) and accumulates events past the cursor for the next process to
-   * `resume`. Unlike {@link close}, the consumer's active turn is wound down
-   * cleanly — adapters distinguish a suspend from an unexpected drop via the
-   * `'suspended'` close reason and resolve `done` successfully. When an event
-   * checkpoint is pinned, the returned cursor points to that event so any
-   * already-dispatched tail is replayed by the next process.
-   */
-  suspend() {
-    return new Promise((resolve) => {
-      const pinnedSuspensionCursor = this.pinnedSuspensionCursor?.eventId;
-      if (this.terminal) {
-        resolve(pinnedSuspensionCursor ?? this._lastSeenEventId);
-        return;
-      }
-      this.suspended = true;
-      this.closing = true;
-      this.abortActiveConnect();
-      this.onClose(
-        () => resolve(pinnedSuspensionCursor ?? this._lastSeenEventId)
-      );
-      this.enqueue(() => {
-        try {
-          this.ws?.close();
-        } catch {
-        }
-        this.finalizeClose(1e3, "suspended");
-      });
-    });
-  }
-  isClosed() {
-    return this.terminal;
-  }
-  // ─── internals ──────────────────────────────────────────────────────
-  wire(ws) {
-    let dropped = false;
-    const onDrop = (code, reason) => {
-      if (dropped) return;
-      dropped = true;
-      if (ws !== this.ws) return;
-      this.connected = false;
-      if (this.closing) {
-        this.enqueue(() => this.finalizeClose(code, reason));
-      } else {
-        this.enqueue(() => this.reconnectLoop());
-      }
-    };
-    ws.on("message", (raw) => {
-      if (this.suspended) return;
-      const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
-      this.enqueue(() => this.handleIncoming(text));
-    });
-    ws.on(
-      "close",
-      (code, reason) => onDrop(code, reason?.toString?.("utf8") ?? "")
-    );
-    ws.on("error", () => onDrop(1006, "socket error"));
-  }
-  async reconnectLoop() {
-    if (this.terminal || this.closing) return;
-    const deadline = Date.now() + this.maxElapsedMs;
-    let attempt = 0;
-    let delay = this.initialDelayMs;
-    const reconnectAbortController = new AbortController();
-    this.reconnectAbortController = reconnectAbortController;
-    try {
-      while (!this.terminal && !this.closing) {
-        const remaining = deadline - Date.now();
-        if (remaining <= 0) {
-          this.failReconnect({
-            attempts: attempt,
-            cause: new Error("Reconnect deadline expired")
-          });
-          return;
-        }
-        attempt++;
-        this.onDebug?.({
-          event: "reconnect-attempt",
-          attempt,
-          lastSeenEventId: this._lastSeenEventId
-        });
-        const abortController = new AbortController();
-        this.activeConnectAbortController = abortController;
-        const abortConnect = () => abortController.abort(reconnectAbortController.signal.reason);
-        reconnectAbortController.signal.addEventListener(
-          "abort",
-          abortConnect,
-          {
-            once: true
-          }
-        );
-        const timeout = setTimeout(() => {
-          abortController.abort(new Error("Reconnect deadline expired"));
-        }, remaining);
-        timeout.unref?.();
-        try {
-          const ws = await this.connect({
-            abortSignal: abortController.signal
-          });
-          if (this.terminal || this.closing) {
-            closeWebSocket({ ws });
-            return;
-          }
-          this.wire(ws);
-          this.ws = ws;
-          this.connected = true;
-          this.rawSend(
-            JSON.stringify({
-              type: "resume",
-              lastSeenEventId: this._lastSeenEventId
-            })
-          );
-          this.flushPending();
-          for (const handler of this.onReconnectHandlers) handler();
-          this.onDebug?.({
-            event: "reconnected",
-            attempt,
-            lastSeenEventId: this._lastSeenEventId
-          });
-          return;
-        } catch (cause) {
-          if (this.terminal || this.closing || reconnectAbortController.signal.aborted) {
-            return;
-          }
-          const remainingAfterFailure = deadline - Date.now();
-          if (remainingAfterFailure <= 0) {
-            this.failReconnect({ attempts: attempt, cause });
-            return;
-          }
-          await sleep({
-            ms: Math.min(delay, remainingAfterFailure),
-            abortSignal: reconnectAbortController.signal
-          });
-          delay = Math.min(delay * 1.5, this.maxDelayMs);
-        } finally {
-          clearTimeout(timeout);
-          reconnectAbortController.signal.removeEventListener(
-            "abort",
-            abortConnect
-          );
-          if (this.activeConnectAbortController === abortController) {
-            this.activeConnectAbortController = void 0;
-          }
-        }
-      }
-    } finally {
-      if (this.reconnectAbortController === reconnectAbortController) {
-        this.reconnectAbortController = void 0;
-      }
-    }
-  }
-  connect({
-    abortSignal
-  }) {
-    return awaitWebSocketConnection({
-      connection: Promise.resolve().then(
-        () => this.connectThunk({ abortSignal })
-      ),
-      abortSignal
-    });
-  }
-  abortActiveConnect() {
-    const controller = this.activeConnectAbortController;
-    this.activeConnectAbortController = void 0;
-    controller?.abort(new Error("SandboxChannel connection aborted"));
-    this.reconnectAbortController?.abort(
-      new Error("SandboxChannel connection aborted")
-    );
-  }
-  failReconnect({
-    attempts,
-    cause
-  }) {
-    this.finalizeClose(1006, "reconnect failed");
-    this.onDebug?.({
-      event: "reconnect-failed",
-      attempts,
-      lastSeenEventId: this._lastSeenEventId,
-      cause
-    });
-  }
-  rawSend(text) {
-    if (this.connected && this.ws) {
-      this.ws.send(text);
-    } else {
-      this.pendingSends.push(text);
-    }
-  }
-  flushPending() {
-    if (!this.connected || !this.ws) return;
-    const queued = this.pendingSends.splice(0);
-    for (const text of queued) this.ws.send(text);
-  }
-  enqueue(work) {
-    this.dispatchChain = this.dispatchChain.then(work);
-  }
-  async handleIncoming(text) {
-    const raw = await safeParseJSON({ text });
-    let seq;
-    if (raw.success && raw.value != null && typeof raw.value === "object" && typeof raw.value.seq === "number") {
-      seq = raw.value.seq;
-    }
-    const validated = await safeValidateTypes({
-      value: raw.success ? raw.value : void 0,
-      schema: this.outboundSchema
-    });
-    if (validated.success) {
-      if (seq !== void 0) {
-        this.attachEventCheckpoint({ event: validated.value, eventId: seq });
-      }
-      this.dispatch(validated.value);
-    } else {
-      this.dispatch({
-        type: "error",
-        error: validated.error
-      });
-    }
-    if (seq !== void 0 && seq > this._lastSeenEventId) {
-      this._lastSeenEventId = seq;
-    }
-  }
-  dispatch(message) {
-    if (message.type === "sandbox-log" || message.type === "debug-event") {
-      this.onDiagnostic?.(
-        message
-      );
-      return;
-    }
-    if (message.type === "error") {
-      this.onBridgeError?.(message);
-    }
-    const type = message.type;
-    const set = this.listeners.get(type);
-    if (this.listenerAttachmentDepth > 0 || this.bufferedOffset < this.buffered.length || !set || set.size === 0) {
-      this.buffered.push({
-        message,
-        ...set != null && set.size > 0 ? { listeners: Array.from(set) } : {}
-      });
-      this.flushBuffered();
-      this.scheduleSelectiveBufferedFlush();
-      return;
-    }
-    for (const listener of set) {
-      listener(message);
-    }
-  }
-  flushBuffered({
-    selective = false
-  } = {}) {
-    if (this.flushingBuffered || this.listenerAttachmentDepth > 0) return;
-    this.flushingBuffered = true;
-    try {
-      while (this.bufferedOffset < this.buffered.length) {
-        const bufferedEvent = this.buffered[this.bufferedOffset];
-        const message = bufferedEvent.message;
-        const type = message.type;
-        const set = this.listeners.get(type);
-        const listeners = bufferedEvent.listeners ?? (set != null && set.size > 0 ? Array.from(set) : void 0);
-        if (!listeners || listeners.length === 0) {
-          if (!selective) return;
-          this.bufferedOffset++;
-          const buffered = this.bufferedByType.get(type);
-          if (buffered) {
-            buffered.push(message);
-          } else {
-            this.bufferedByType.set(type, [message]);
-          }
-          continue;
-        }
-        this.bufferedOffset++;
-        for (const listener of listeners) {
-          listener(message);
-        }
-      }
-    } finally {
-      if (this.bufferedOffset > 0) {
-        this.buffered.splice(0, this.bufferedOffset);
-        this.bufferedOffset = 0;
-      }
-      this.flushingBuffered = false;
-    }
-  }
-  captureBufferedListeners(type) {
-    const set = this.listeners.get(type);
-    if (!set || set.size === 0) return;
-    for (let i = this.bufferedOffset; i < this.buffered.length; i++) {
-      const bufferedEvent = this.buffered[i];
-      if (bufferedEvent.listeners == null && bufferedEvent.message.type === type) {
-        bufferedEvent.listeners = Array.from(set);
-      }
-    }
-  }
-  flushBufferedType(type) {
-    const buffered = this.bufferedByType.get(type);
-    if (!buffered) return;
-    let offset = 0;
-    try {
-      while (offset < buffered.length) {
-        const set = this.listeners.get(type);
-        if (!set || set.size === 0) return;
-        const message = buffered[offset++];
-        for (const listener of set) {
-          listener(message);
-        }
-      }
-    } finally {
-      if (offset === buffered.length) {
-        this.bufferedByType.delete(type);
-      } else if (offset > 0) {
-        buffered.splice(0, offset);
-      }
-    }
-  }
-  scheduleSelectiveBufferedFlush() {
-    if (this.bufferedFlushScheduled || this.bufferedOffset >= this.buffered.length || !this.hasListeners() || this.listenerAttachmentDepth > 0) {
-      return;
-    }
-    this.bufferedFlushScheduled = true;
-    setTimeout(() => {
-      this.bufferedFlushScheduled = false;
-      if (this.listenerAttachmentDepth > 0) return;
-      this.flushBuffered({ selective: true });
-    }, 0);
-  }
-  hasListeners() {
-    for (const listeners of this.listeners.values()) {
-      if (listeners.size > 0) return true;
-    }
-    return false;
-  }
-  attachEventCheckpoint(options) {
-    if (!Object.isExtensible(options.event)) return;
-    Object.defineProperty(options.event, sandboxChannelEventCheckpointSymbol, {
-      value: {
-        pin: () => {
-          const token = {};
-          this.pinnedSuspensionCursor = { eventId: options.eventId, token };
-          return () => {
-            if (this.pinnedSuspensionCursor?.token === token) {
-              this.pinnedSuspensionCursor = void 0;
-            }
-          };
-        }
-      }
-    });
-  }
-  finalizeClose(code, reason) {
-    if (this.terminal) return;
-    this.abortActiveConnect();
-    this.terminal = true;
-    this.connected = false;
-    for (const h of this.onCloseHandlers) h(code, reason);
-  }
+	constructor(options) {
+		this.listeners = /* @__PURE__ */ new Map();
+		this.buffered = [];
+		this.bufferedByType = /* @__PURE__ */ new Map();
+		this.bufferedOffset = 0;
+		this.flushingBuffered = false;
+		this.bufferedFlushScheduled = false;
+		this.listenerAttachmentDepth = 0;
+		this.onCloseHandlers = /* @__PURE__ */ new Set();
+		this.onReconnectHandlers = /* @__PURE__ */ new Set();
+		this.connected = false;
+		this.closing = false;
+		this.suspended = false;
+		this.terminal = false;
+		this._lastSeenEventId = 0;
+		this.pendingSends = [];
+		this.dispatchChain = Promise.resolve();
+		this.connectThunk = options.connect;
+		this.outboundSchema = options.outboundSchema;
+		this.onDebug = options.onDebug;
+		this.onDiagnostic = options.onDiagnostic;
+		this.onBridgeError = options.onBridgeError;
+		this.maxElapsedMs = options.reconnect?.maxElapsedMs ?? 3e4;
+		this.initialDelayMs = options.reconnect?.initialDelayMs ?? 50;
+		this.maxDelayMs = options.reconnect?.maxDelayMs ?? 2e3;
+		this._lastSeenEventId = options.initialLastSeenEventId ?? 0;
+	}
+	/**
+	* Highest bridge event `seq` this channel has observed. Persist it (e.g. via
+	* the adapter's resume handle) so a future process can seed
+	* {@link SandboxChannelOptions.initialLastSeenEventId} and attach.
+	*/
+	get lastSeenEventId() {
+		return this._lastSeenEventId;
+	}
+	/**
+	* Establish the initial connection. A single attempt — startup failures
+	* reject so the caller can fail `doStart` cleanly. Reconnect retries apply
+	* only to drops after a successful open.
+	*
+	* Pass `{ resume: true }` to attach to a bridge that is already mid-session:
+	* after the socket opens, the channel sends `{ type: 'resume', lastSeenEventId }`
+	* so the bridge replays everything past the seeded cursor. This is the
+	* cross-process attach handshake — identical to what a transient reconnect
+	* does, but triggered by the initial open from a new process.
+	*/
+	async open(opts) {
+		if (this.terminal) throw new Error("SandboxChannel: cannot open a closed channel.");
+		const abortController = new AbortController();
+		this.activeConnectAbortController = abortController;
+		try {
+			const ws = await this.connect({ abortSignal: abortController.signal });
+			this.wire(ws);
+			this.ws = ws;
+			this.connected = true;
+			if (opts?.resume) this.rawSend(JSON.stringify({
+				type: "resume",
+				lastSeenEventId: this._lastSeenEventId
+			}));
+		} finally {
+			if (this.activeConnectAbortController === abortController) this.activeConnectAbortController = void 0;
+		}
+	}
+	on(type, listener) {
+		let set = this.listeners.get(type);
+		if (!set) {
+			set = /* @__PURE__ */ new Set();
+			this.listeners.set(type, set);
+		}
+		set.add(listener);
+		this.captureBufferedListeners(type);
+		if (this.listenerAttachmentDepth > 0) return () => {
+			set.delete(listener);
+		};
+		this.flushBufferedType(type);
+		this.flushBuffered();
+		this.scheduleSelectiveBufferedFlush();
+		return () => {
+			set.delete(listener);
+		};
+	}
+	/**
+	* Hold buffered event delivery while a consumer attaches a related set of
+	* listeners, including across asynchronous boundaries. Call the returned
+	* function once registration is complete. Buffered events are then replayed
+	* in arrival order; event types that remain unhandled are retained
+	* independently so they do not block subscribed types.
+	*/
+	beginListenerAttachment() {
+		this.listenerAttachmentDepth++;
+		let finished = false;
+		return () => {
+			if (finished) return;
+			finished = true;
+			this.listenerAttachmentDepth--;
+			if (this.listenerAttachmentDepth > 0) return;
+			for (const type of this.listeners.keys()) this.flushBufferedType(type);
+			this.flushBuffered();
+			this.scheduleSelectiveBufferedFlush();
+		};
+	}
+	onClose(handler) {
+		this.onCloseHandlers.add(handler);
+	}
+	onReconnect(handler) {
+		this.onReconnectHandlers.add(handler);
+		return () => {
+			this.onReconnectHandlers.delete(handler);
+		};
+	}
+	send(message) {
+		if (this.terminal) throw new Error(`SandboxChannel: cannot send ${message.type} — channel is closed.`);
+		this.rawSend(JSON.stringify(message));
+	}
+	/**
+	* Mark that the host is tearing the session down. The next socket close is
+	* then treated as terminal rather than triggering a reconnect. Call before
+	* sending a `stop` / `destroy` message whose completion closes the bridge
+	* socket.
+	*/
+	beginClose() {
+		this.closing = true;
+		this.abortActiveConnect();
+	}
+	close() {
+		if (this.terminal) return;
+		this.closing = true;
+		this.abortActiveConnect();
+		try {
+			this.ws?.close();
+		} catch {}
+		this.enqueue(() => this.finalizeClose(1e3, "closed"));
+	}
+	/**
+	* Gracefully suspend at a slice boundary: stop processing inbound frames
+	* (so the cursor freezes at the last delivered event), drain any frames
+	* already queued for dispatch, then close the socket and finalise with the
+	* close reason `'suspended'`. Resolves with the final `lastSeenEventId`.
+	*
+	* The bridge keeps the in-flight turn running (a host socket close never
+	* aborts it) and accumulates events past the cursor for the next process to
+	* `resume`. Unlike {@link close}, the consumer's active turn is wound down
+	* cleanly — adapters distinguish a suspend from an unexpected drop via the
+	* `'suspended'` close reason and resolve `done` successfully. When an event
+	* checkpoint is pinned, the returned cursor points to that event so any
+	* already-dispatched tail is replayed by the next process.
+	*/
+	suspend() {
+		return new Promise((resolve) => {
+			const pinnedSuspensionCursor = this.pinnedSuspensionCursor?.eventId;
+			if (this.terminal) {
+				resolve(pinnedSuspensionCursor ?? this._lastSeenEventId);
+				return;
+			}
+			this.suspended = true;
+			this.closing = true;
+			this.abortActiveConnect();
+			this.onClose(() => resolve(pinnedSuspensionCursor ?? this._lastSeenEventId));
+			this.enqueue(() => {
+				try {
+					this.ws?.close();
+				} catch {}
+				this.finalizeClose(1e3, "suspended");
+			});
+		});
+	}
+	isClosed() {
+		return this.terminal;
+	}
+	wire(ws) {
+		let dropped = false;
+		const onDrop = (code, reason) => {
+			if (dropped) return;
+			dropped = true;
+			if (ws !== this.ws) return;
+			this.connected = false;
+			if (this.closing) this.enqueue(() => this.finalizeClose(code, reason));
+			else this.enqueue(() => this.reconnectLoop());
+		};
+		ws.on("message", (raw) => {
+			if (this.suspended) return;
+			const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
+			this.enqueue(() => this.handleIncoming(text));
+		});
+		ws.on("close", (code, reason) => onDrop(code, reason?.toString?.("utf8") ?? ""));
+		ws.on("error", () => onDrop(1006, "socket error"));
+	}
+	async reconnectLoop() {
+		if (this.terminal || this.closing) return;
+		const deadline = Date.now() + this.maxElapsedMs;
+		let attempt = 0;
+		let delay = this.initialDelayMs;
+		const reconnectAbortController = new AbortController();
+		this.reconnectAbortController = reconnectAbortController;
+		try {
+			while (!this.terminal && !this.closing) {
+				const remaining = deadline - Date.now();
+				if (remaining <= 0) {
+					this.failReconnect({
+						attempts: attempt,
+						cause: /* @__PURE__ */ new Error("Reconnect deadline expired")
+					});
+					return;
+				}
+				attempt++;
+				this.onDebug?.({
+					event: "reconnect-attempt",
+					attempt,
+					lastSeenEventId: this._lastSeenEventId
+				});
+				const abortController = new AbortController();
+				this.activeConnectAbortController = abortController;
+				const abortConnect = () => abortController.abort(reconnectAbortController.signal.reason);
+				reconnectAbortController.signal.addEventListener("abort", abortConnect, { once: true });
+				const timeout = setTimeout(() => {
+					abortController.abort(/* @__PURE__ */ new Error("Reconnect deadline expired"));
+				}, remaining);
+				timeout.unref?.();
+				try {
+					const ws = await this.connect({ abortSignal: abortController.signal });
+					if (this.terminal || this.closing) {
+						closeWebSocket({ ws });
+						return;
+					}
+					this.wire(ws);
+					this.ws = ws;
+					this.connected = true;
+					this.rawSend(JSON.stringify({
+						type: "resume",
+						lastSeenEventId: this._lastSeenEventId
+					}));
+					this.flushPending();
+					for (const handler of this.onReconnectHandlers) handler();
+					this.onDebug?.({
+						event: "reconnected",
+						attempt,
+						lastSeenEventId: this._lastSeenEventId
+					});
+					return;
+				} catch (cause) {
+					if (this.terminal || this.closing || reconnectAbortController.signal.aborted) return;
+					const remainingAfterFailure = deadline - Date.now();
+					if (remainingAfterFailure <= 0) {
+						this.failReconnect({
+							attempts: attempt,
+							cause
+						});
+						return;
+					}
+					await sleep({
+						ms: Math.min(delay, remainingAfterFailure),
+						abortSignal: reconnectAbortController.signal
+					});
+					delay = Math.min(delay * 1.5, this.maxDelayMs);
+				} finally {
+					clearTimeout(timeout);
+					reconnectAbortController.signal.removeEventListener("abort", abortConnect);
+					if (this.activeConnectAbortController === abortController) this.activeConnectAbortController = void 0;
+				}
+			}
+		} finally {
+			if (this.reconnectAbortController === reconnectAbortController) this.reconnectAbortController = void 0;
+		}
+	}
+	connect({ abortSignal }) {
+		return awaitWebSocketConnection({
+			connection: Promise.resolve().then(() => this.connectThunk({ abortSignal })),
+			abortSignal
+		});
+	}
+	abortActiveConnect() {
+		const controller = this.activeConnectAbortController;
+		this.activeConnectAbortController = void 0;
+		controller?.abort(/* @__PURE__ */ new Error("SandboxChannel connection aborted"));
+		this.reconnectAbortController?.abort(/* @__PURE__ */ new Error("SandboxChannel connection aborted"));
+	}
+	failReconnect({ attempts, cause }) {
+		this.finalizeClose(1006, "reconnect failed");
+		this.onDebug?.({
+			event: "reconnect-failed",
+			attempts,
+			lastSeenEventId: this._lastSeenEventId,
+			cause
+		});
+	}
+	rawSend(text) {
+		if (this.connected && this.ws) this.ws.send(text);
+		else this.pendingSends.push(text);
+	}
+	flushPending() {
+		if (!this.connected || !this.ws) return;
+		const queued = this.pendingSends.splice(0);
+		for (const text of queued) this.ws.send(text);
+	}
+	enqueue(work) {
+		this.dispatchChain = this.dispatchChain.then(work);
+	}
+	async handleIncoming(text) {
+		const raw = await safeParseJSON({ text });
+		let seq;
+		if (raw.success && raw.value != null && typeof raw.value === "object" && typeof raw.value.seq === "number") seq = raw.value.seq;
+		const validated = await safeValidateTypes({
+			value: raw.success ? raw.value : void 0,
+			schema: this.outboundSchema
+		});
+		if (validated.success) {
+			if (seq !== void 0) this.attachEventCheckpoint({
+				event: validated.value,
+				eventId: seq
+			});
+			this.dispatch(validated.value);
+		} else this.dispatch({
+			type: "error",
+			error: validated.error
+		});
+		if (seq !== void 0 && seq > this._lastSeenEventId) this._lastSeenEventId = seq;
+	}
+	dispatch(message) {
+		if (message.type === "sandbox-log" || message.type === "debug-event") {
+			this.onDiagnostic?.(message);
+			return;
+		}
+		if (message.type === "error") this.onBridgeError?.(message);
+		const type = message.type;
+		const set = this.listeners.get(type);
+		if (this.listenerAttachmentDepth > 0 || this.bufferedOffset < this.buffered.length || !set || set.size === 0) {
+			this.buffered.push({
+				message,
+				...set != null && set.size > 0 ? { listeners: Array.from(set) } : {}
+			});
+			this.flushBuffered();
+			this.scheduleSelectiveBufferedFlush();
+			return;
+		}
+		for (const listener of set) listener(message);
+	}
+	flushBuffered({ selective = false } = {}) {
+		if (this.flushingBuffered || this.listenerAttachmentDepth > 0) return;
+		this.flushingBuffered = true;
+		try {
+			while (this.bufferedOffset < this.buffered.length) {
+				const bufferedEvent = this.buffered[this.bufferedOffset];
+				const message = bufferedEvent.message;
+				const type = message.type;
+				const set = this.listeners.get(type);
+				const listeners = bufferedEvent.listeners ?? (set != null && set.size > 0 ? Array.from(set) : void 0);
+				if (!listeners || listeners.length === 0) {
+					if (!selective) return;
+					this.bufferedOffset++;
+					const buffered = this.bufferedByType.get(type);
+					if (buffered) buffered.push(message);
+					else this.bufferedByType.set(type, [message]);
+					continue;
+				}
+				this.bufferedOffset++;
+				for (const listener of listeners) listener(message);
+			}
+		} finally {
+			if (this.bufferedOffset > 0) {
+				this.buffered.splice(0, this.bufferedOffset);
+				this.bufferedOffset = 0;
+			}
+			this.flushingBuffered = false;
+		}
+	}
+	captureBufferedListeners(type) {
+		const set = this.listeners.get(type);
+		if (!set || set.size === 0) return;
+		for (let i = this.bufferedOffset; i < this.buffered.length; i++) {
+			const bufferedEvent = this.buffered[i];
+			if (bufferedEvent.listeners == null && bufferedEvent.message.type === type) bufferedEvent.listeners = Array.from(set);
+		}
+	}
+	flushBufferedType(type) {
+		const buffered = this.bufferedByType.get(type);
+		if (!buffered) return;
+		let offset = 0;
+		try {
+			while (offset < buffered.length) {
+				const set = this.listeners.get(type);
+				if (!set || set.size === 0) return;
+				const message = buffered[offset++];
+				for (const listener of set) listener(message);
+			}
+		} finally {
+			if (offset === buffered.length) this.bufferedByType.delete(type);
+			else if (offset > 0) buffered.splice(0, offset);
+		}
+	}
+	scheduleSelectiveBufferedFlush() {
+		if (this.bufferedFlushScheduled || this.bufferedOffset >= this.buffered.length || !this.hasListeners() || this.listenerAttachmentDepth > 0) return;
+		this.bufferedFlushScheduled = true;
+		setTimeout(() => {
+			this.bufferedFlushScheduled = false;
+			if (this.listenerAttachmentDepth > 0) return;
+			this.flushBuffered({ selective: true });
+		}, 0);
+	}
+	hasListeners() {
+		for (const listeners of this.listeners.values()) if (listeners.size > 0) return true;
+		return false;
+	}
+	attachEventCheckpoint(options) {
+		if (!Object.isExtensible(options.event)) return;
+		Object.defineProperty(options.event, sandboxChannelEventCheckpointSymbol, { value: { pin: () => {
+			const token = {};
+			this.pinnedSuspensionCursor = {
+				eventId: options.eventId,
+				token
+			};
+			return () => {
+				if (this.pinnedSuspensionCursor?.token === token) this.pinnedSuspensionCursor = void 0;
+			};
+		} } });
+	}
+	finalizeClose(code, reason) {
+		if (this.terminal) return;
+		this.abortActiveConnect();
+		this.terminal = true;
+		this.connected = false;
+		for (const h of this.onCloseHandlers) h(code, reason);
+	}
 };
-
-// src/utils/bridge-user-message-submitter.ts
+//#endregion
+//#region src/utils/bridge-user-message-submitter.ts
 function experimental_createBridgeUserMessageSubmitter(options) {
-  const pending = /* @__PURE__ */ new Map();
-  let closed = false;
-  const send = (request) => {
-    try {
-      options.send(request);
-    } catch (error) {
-      const entry = pending.get(request.messageId);
-      if (entry == null) return;
-      pending.delete(request.messageId);
-      entry.reject(error);
-    }
-  };
-  const unsubscribeResponse = options.onResponse((response) => {
-    const entry = pending.get(response.messageId);
-    if (entry == null) return;
-    pending.delete(response.messageId);
-    if (response.accepted) {
-      entry.resolve();
-    } else {
-      entry.reject(
-        new Error(
-          response.error?.message ?? "The runtime rejected the user message."
-        )
-      );
-    }
-  });
-  const unsubscribeReconnect = options.onReconnect(() => {
-    for (const entry of pending.values()) send(entry.request);
-  });
-  return {
-    submit: (text) => {
-      if (closed) {
-        return Promise.reject(
-          new Error("The bridge turn is no longer accepting user messages.")
-        );
-      }
-      const messageId = crypto.randomUUID();
-      const request = {
-        type: "user-message",
-        messageId,
-        text
-      };
-      const promise = new Promise((resolve, reject) => {
-        pending.set(messageId, { request, resolve, reject });
-      });
-      send(request);
-      return promise;
-    },
-    close: (error) => {
-      if (closed) return;
-      closed = true;
-      unsubscribeResponse();
-      unsubscribeReconnect();
-      const reason = error ?? new Error("The bridge turn ended before accepting the user message.");
-      for (const entry of pending.values()) entry.reject(reason);
-      pending.clear();
-    }
-  };
-}
-
-// src/utils/classify-disk-log.ts
-import { safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
+	const pending = /* @__PURE__ */ new Map();
+	let closed = false;
+	const send = (request) => {
+		try {
+			options.send(request);
+		} catch (error) {
+			const entry = pending.get(request.messageId);
+			if (entry == null) return;
+			pending.delete(request.messageId);
+			entry.reject(error);
+		}
+	};
+	const unsubscribeResponse = options.onResponse((response) => {
+		const entry = pending.get(response.messageId);
+		if (entry == null) return;
+		pending.delete(response.messageId);
+		if (response.accepted) entry.resolve();
+		else entry.reject(new Error(response.error?.message ?? "The runtime rejected the user message."));
+	});
+	const unsubscribeReconnect = options.onReconnect(() => {
+		for (const entry of pending.values()) send(entry.request);
+	});
+	return {
+		submit: (text) => {
+			if (closed) return Promise.reject(/* @__PURE__ */ new Error("The bridge turn is no longer accepting user messages."));
+			const messageId = crypto.randomUUID();
+			const request = {
+				type: "user-message",
+				messageId,
+				text
+			};
+			const promise = new Promise((resolve, reject) => {
+				pending.set(messageId, {
+					request,
+					resolve,
+					reject
+				});
+			});
+			send(request);
+			return promise;
+		},
+		close: (error) => {
+			if (closed) return;
+			closed = true;
+			unsubscribeResponse();
+			unsubscribeReconnect();
+			const reason = error ?? /* @__PURE__ */ new Error("The bridge turn ended before accepting the user message.");
+			for (const entry of pending.values()) entry.reject(reason);
+			pending.clear();
+		}
+	};
+}
+//#endregion
+//#region src/utils/classify-disk-log.ts
+/**
+* Decide whether a respawned bridge can `replay` a turn from its persisted
+* `event-log.ndjson`, or must `rerun` it from scratch.
+*
+* A turn is replayable only when its log ends in a terminal `finish` event —
+* a log that is missing, empty, or ends mid-turn means the bridge died before
+* completing the turn, so there is no coherent tail to deliver and the runtime
+* must re-run it (continuing its own thread from the sandbox snapshot).
+*
+* @param eventLog Raw contents of `event-log.ndjson` (newline-delimited JSON),
+*   or `null`/`undefined`/empty when the file is absent.
+*/
 async function classifyDiskLog(eventLog) {
-  if (!eventLog) return "rerun";
-  const lines = eventLog.split("\n").map((line) => line.trim()).filter(Boolean);
-  const lastLine = lines.at(-1);
-  if (lastLine == null) return "rerun";
-  const parsed = await safeParseJSON2({ text: lastLine });
-  if (parsed.success && parsed.value != null && typeof parsed.value === "object" && parsed.value.type === "finish") {
-    return "replay";
-  }
-  return "rerun";
-}
-
-// src/utils/ai-gateway-auth.ts
-var DEFAULT_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
-function getAiGatewayAuthFromEnv({
-  env
-}) {
-  return {
-    apiKey: env.AI_GATEWAY_API_KEY || env.VERCEL_OIDC_TOKEN || void 0,
-    baseUrl: env.AI_GATEWAY_BASE_URL ?? DEFAULT_AI_GATEWAY_BASE_URL
-  };
-}
-
-// src/utils/authentication-environment.ts
+	if (!eventLog) return "rerun";
+	const lastLine = eventLog.split("\n").map((line) => line.trim()).filter(Boolean).at(-1);
+	if (lastLine == null) return "rerun";
+	const parsed = await safeParseJSON({ text: lastLine });
+	if (parsed.success && parsed.value != null && typeof parsed.value === "object" && parsed.value.type === "finish") return "replay";
+	return "rerun";
+}
+//#endregion
+//#region src/utils/ai-gateway-auth.ts
+const DEFAULT_AI_GATEWAY_BASE_URL = "https://ai-gateway.vercel.sh";
+function getAiGatewayAuthFromEnv({ env }) {
+	return {
+		apiKey: env.AI_GATEWAY_API_KEY || env.VERCEL_OIDC_TOKEN || void 0,
+		baseUrl: env.AI_GATEWAY_BASE_URL ?? DEFAULT_AI_GATEWAY_BASE_URL
+	};
+}
+//#endregion
+//#region src/utils/authentication-environment.ts
 function isHarnessAuthenticationEnvironment(value) {
-  if (value == null || typeof value !== "object") {
-    return false;
-  }
-  if (Array.isArray(value) || Object.values(value).some((entry) => typeof entry !== "string")) {
-    throw new TypeError(
-      "Invalid auth: expected an authentication mode or a flat record with string values."
-    );
-  }
-  return true;
-}
-
-// src/utils/native-subscription/jwt.ts
-import { isRecord, safeParseJSON as safeParseJSON3 } from "@ai-sdk/provider-utils";
-async function parseJwtPayload({
-  token
-}) {
-  const segments = token.split(".");
-  if (segments.length !== 3) return void 0;
-  try {
-    const parsed = await safeParseJSON3({
-      text: Buffer.from(segments[1], "base64url").toString("utf8")
-    });
-    return parsed.success && isRecord(parsed.value) ? parsed.value : void 0;
-  } catch {
-    return void 0;
-  }
-}
-async function getJwtExpiresAt({
-  token
-}) {
-  const payload = await parseJwtPayload({ token });
-  const expiresAt = payload?.exp;
-  return typeof expiresAt === "number" && Number.isFinite(expiresAt) ? expiresAt * 1e3 : void 0;
-}
-
-// src/utils/native-subscription/linux-secret-service.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-async function readLinuxSecretServicePassword({
-  attributes
-}) {
-  try {
-    const result = await execFileAsync("secret-tool", [
-      "lookup",
-      ...Object.entries(attributes).flatMap(([attribute, value]) => [
-        attribute,
-        value
-      ])
-    ]);
-    return result.stdout || void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/utils/native-subscription/macos-keychain.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
-async function readMacOSKeychainPassword({
-  service,
-  account
-}) {
-  try {
-    const result = await execFileAsync2("/usr/bin/security", [
-      "find-generic-password",
-      "-s",
-      service,
-      "-a",
-      account,
-      "-w"
-    ]);
-    return result.stdout.trim() || void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/utils/native-subscription/should-resolve-native.ts
-function shouldResolveNativeSubscription({
-  auth,
-  env,
-  hasDirectCredential
-}) {
-  return auth !== "ai-gateway" && !hasDirectCredential && (auth === "direct" || getAiGatewayAuthFromEnv({ env }).apiKey == null);
-}
-
-// src/utils/native-subscription/windows-credential-manager.ts
-import { execFile as execFile3 } from "child_process";
-import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile3);
-var credentialManagerSource = `
+	if (value == null || typeof value !== "object") return false;
+	if (Array.isArray(value) || Object.values(value).some((entry) => typeof entry !== "string")) throw new TypeError("Invalid auth: expected an authentication mode or a flat record with string values.");
+	return true;
+}
+//#endregion
+//#region src/utils/native-subscription/jwt.ts
+async function parseJwtPayload({ token }) {
+	const segments = token.split(".");
+	if (segments.length !== 3) return void 0;
+	try {
+		const parsed = await safeParseJSON({ text: Buffer.from(segments[1], "base64url").toString("utf8") });
+		return parsed.success && isRecord(parsed.value) ? parsed.value : void 0;
+	} catch {
+		return;
+	}
+}
+async function getJwtExpiresAt({ token }) {
+	const expiresAt = (await parseJwtPayload({ token }))?.exp;
+	return typeof expiresAt === "number" && Number.isFinite(expiresAt) ? expiresAt * 1e3 : void 0;
+}
+//#endregion
+//#region src/utils/native-subscription/linux-secret-service.ts
+const execFileAsync$2 = promisify(execFile);
+async function readLinuxSecretServicePassword({ attributes }) {
+	try {
+		return (await execFileAsync$2("secret-tool", ["lookup", ...Object.entries(attributes).flatMap(([attribute, value]) => [attribute, value])])).stdout || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/utils/native-subscription/macos-keychain.ts
+const execFileAsync$1 = promisify(execFile);
+async function readMacOSKeychainPassword({ service, account }) {
+	try {
+		return (await execFileAsync$1("/usr/bin/security", [
+			"find-generic-password",
+			"-s",
+			service,
+			"-a",
+			account,
+			"-w"
+		])).stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/utils/native-subscription/should-resolve-native.ts
+function shouldResolveNativeSubscription({ auth, env, hasDirectCredential }) {
+	return auth !== "ai-gateway" && !hasDirectCredential && (auth === "direct" || getAiGatewayAuthFromEnv({ env }).apiKey == null);
+}
+//#endregion
+//#region src/utils/native-subscription/windows-credential-manager.ts
+const execFileAsync = promisify(execFile);
+const credentialManagerSource = `
 using System;
 using System.Runtime.InteropServices;
 using System.Text;
@@ -820,1750 +688,1335 @@ public static class AISDKCredentialManager {
     } finally { CredFree(pointer); }
   }
 }`;
-async function readWindowsCredentialManagerPassword({
-  targetName
-}) {
-  try {
-    const result = await execFileAsync3(
-      "powershell.exe",
-      [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `Add-Type -TypeDefinition $env:AI_SDK_WINDOWS_CREDENTIAL_MANAGER_SOURCE; $value = [AISDKCredentialManager]::Read($env:AI_SDK_WINDOWS_CREDENTIAL_MANAGER_TARGET); if ($null -ne $value) { [Console]::Out.Write($value) }`
-      ],
-      {
-        env: {
-          ...process.env,
-          AI_SDK_WINDOWS_CREDENTIAL_MANAGER_SOURCE: credentialManagerSource,
-          AI_SDK_WINDOWS_CREDENTIAL_MANAGER_TARGET: targetName
-        },
-        windowsHide: true
-      }
-    );
-    return result.stdout || void 0;
-  } catch {
-    return void 0;
-  }
-}
-
-// src/utils/oauth-access-token.ts
-import { isRecord as isRecord2, safeParseJSON as safeParseJSON4 } from "@ai-sdk/provider-utils";
-var DEFAULT_REFRESH_WINDOW_MS = 3e5;
-function isAccessTokenExpiringSoon({
-  expiresAt,
-  now = Date.now(),
-  refreshWindowMs = DEFAULT_REFRESH_WINDOW_MS
-}) {
-  return expiresAt <= now + refreshWindowMs;
-}
-async function refreshOAuthAccessToken({
-  tokenUrl,
-  clientId,
-  refreshToken,
-  requestFormat = "form",
-  headers,
-  fetch: fetchImplementation = globalThis.fetch
-}) {
-  const values = {
-    grant_type: "refresh_token",
-    client_id: clientId,
-    refresh_token: refreshToken
-  };
-  const response = await fetchImplementation(tokenUrl, {
-    method: "POST",
-    headers: {
-      "content-type": requestFormat === "json" ? "application/json" : "application/x-www-form-urlencoded",
-      ...headers
-    },
-    body: requestFormat === "json" ? JSON.stringify(values) : new URLSearchParams(values).toString()
-  });
-  const responseText = await response.text();
-  if (!response.ok) {
-    throw new Error(
-      `OAuth access token refresh failed with status ${response.status}.`
-    );
-  }
-  const parsed = await safeParseJSON4({ text: responseText });
-  if (!parsed.success || !isRecord2(parsed.value)) {
-    throw new Error("OAuth access token refresh returned invalid JSON.");
-  }
-  const accessToken = parsed.value.access_token;
-  if (typeof accessToken !== "string" || accessToken.length === 0) {
-    throw new Error(
-      "OAuth access token refresh response is missing access_token."
-    );
-  }
-  const expiresAt = await resolveExpiresAt({
-    accessToken,
-    expiresIn: parsed.value.expires_in
-  });
-  const rotatedRefreshToken = parsed.value.refresh_token;
-  if (rotatedRefreshToken != null && (typeof rotatedRefreshToken !== "string" || rotatedRefreshToken.length === 0)) {
-    throw new Error(
-      "OAuth access token refresh response contains an invalid refresh_token."
-    );
-  }
-  return {
-    accessToken,
-    expiresAt,
-    ...typeof rotatedRefreshToken === "string" ? { refreshToken: rotatedRefreshToken } : {}
-  };
-}
-async function resolveExpiresAt({
-  accessToken,
-  expiresIn
-}) {
-  if (typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn >= 0) {
-    return Date.now() + expiresIn * 1e3;
-  }
-  const jwtExpiresAt = await getJwtExpiresAt({ token: accessToken });
-  if (jwtExpiresAt != null) return jwtExpiresAt;
-  throw new Error(
-    "OAuth access token refresh response does not include a usable expiry."
-  );
-}
-
-// src/utils/os.ts
+async function readWindowsCredentialManagerPassword({ targetName }) {
+	try {
+		return (await execFileAsync("powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`Add-Type -TypeDefinition $env:AI_SDK_WINDOWS_CREDENTIAL_MANAGER_SOURCE; $value = [AISDKCredentialManager]::Read($env:AI_SDK_WINDOWS_CREDENTIAL_MANAGER_TARGET); if ($null -ne $value) { [Console]::Out.Write($value) }`
+		], {
+			env: {
+				...process.env,
+				AI_SDK_WINDOWS_CREDENTIAL_MANAGER_SOURCE: credentialManagerSource,
+				AI_SDK_WINDOWS_CREDENTIAL_MANAGER_TARGET: targetName
+			},
+			windowsHide: true
+		})).stdout || void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/utils/oauth-access-token.ts
+const DEFAULT_REFRESH_WINDOW_MS = 3e5;
+function isAccessTokenExpiringSoon({ expiresAt, now = Date.now(), refreshWindowMs = DEFAULT_REFRESH_WINDOW_MS }) {
+	return expiresAt <= now + refreshWindowMs;
+}
+async function refreshOAuthAccessToken({ tokenUrl, clientId, refreshToken, requestFormat = "form", headers, fetch: fetchImplementation = globalThis.fetch }) {
+	const values = {
+		grant_type: "refresh_token",
+		client_id: clientId,
+		refresh_token: refreshToken
+	};
+	const response = await fetchImplementation(tokenUrl, {
+		method: "POST",
+		headers: {
+			"content-type": requestFormat === "json" ? "application/json" : "application/x-www-form-urlencoded",
+			...headers
+		},
+		body: requestFormat === "json" ? JSON.stringify(values) : new URLSearchParams(values).toString()
+	});
+	const responseText = await response.text();
+	if (!response.ok) throw new Error(`OAuth access token refresh failed with status ${response.status}.`);
+	const parsed = await safeParseJSON({ text: responseText });
+	if (!parsed.success || !isRecord(parsed.value)) throw new Error("OAuth access token refresh returned invalid JSON.");
+	const accessToken = parsed.value.access_token;
+	if (typeof accessToken !== "string" || accessToken.length === 0) throw new Error("OAuth access token refresh response is missing access_token.");
+	const expiresAt = await resolveExpiresAt({
+		accessToken,
+		expiresIn: parsed.value.expires_in
+	});
+	const rotatedRefreshToken = parsed.value.refresh_token;
+	if (rotatedRefreshToken != null && (typeof rotatedRefreshToken !== "string" || rotatedRefreshToken.length === 0)) throw new Error("OAuth access token refresh response contains an invalid refresh_token.");
+	return {
+		accessToken,
+		expiresAt,
+		...typeof rotatedRefreshToken === "string" ? { refreshToken: rotatedRefreshToken } : {}
+	};
+}
+async function resolveExpiresAt({ accessToken, expiresIn }) {
+	if (typeof expiresIn === "number" && Number.isFinite(expiresIn) && expiresIn >= 0) return Date.now() + expiresIn * 1e3;
+	const jwtExpiresAt = await getJwtExpiresAt({ token: accessToken });
+	if (jwtExpiresAt != null) return jwtExpiresAt;
+	throw new Error("OAuth access token refresh response does not include a usable expiry.");
+}
+//#endregion
+//#region src/utils/os.ts
 function isMacOS(platform) {
-  return platform === "darwin";
+	return platform === "darwin";
 }
 function isLinux(platform) {
-  return platform === "linux";
+	return platform === "linux";
 }
 function isWindows(platform) {
-  return platform === "win32";
+	return platform === "win32";
 }
-
-// src/utils/sandbox-credential-brokering.ts
-import { randomBytes } from "crypto";
-var SANDBOX_CREDENTIAL_PLACEHOLDER_PREFIX = "aisdkhc_";
+//#endregion
+//#region src/utils/sandbox-credential-brokering.ts
+const SANDBOX_CREDENTIAL_PLACEHOLDER_PREFIX = "aisdkhc_";
 function generateSandboxCredentialPlaceholder() {
-  return `${SANDBOX_CREDENTIAL_PLACEHOLDER_PREFIX}${randomBytes(32).toString("base64url")}`;
+	return `${SANDBOX_CREDENTIAL_PLACEHOLDER_PREFIX}${randomBytes(32).toString("base64url")}`;
 }
 function isSandboxCredentialPlaceholder(value) {
-  return /^aisdkhc_[A-Za-z0-9_-]{43}$/.test(value);
+	return /^aisdkhc_[A-Za-z0-9_-]{43}$/.test(value);
 }
+/**
+* Warns when credential brokering is unavailable, but only if real credentials
+* remain among the credentials forwarded into the sandbox.
+*/
 function warnCredentialBrokeringUnavailable(options) {
-  const credentialEnvironmentVariables = [
-    ...new Set(options.credentialEnvironmentVariables)
-  ];
-  const credentials = credentialEnvironmentVariables.map((name) => options.environment[name]).filter(
-    (credential) => credential != null && credential.length > 0
-  );
-  const forwardedCredentials = credentialEnvironmentVariables.map((name) => options.forwardedEnvironment[name]).filter((credential) => credential != null);
-  if (!credentials.some(
-    (credential) => forwardedCredentials.some(
-      (forwardedCredential) => forwardedCredential.includes(credential)
-    )
-  )) {
-    return;
-  }
-  console.warn(
-    "The sandbox implementation does not support configuring request transformations, so credential brokering does not work. Falling back to less secure credential forwarding."
-  );
-}
-function maskSandboxCredentials({
-  environment,
-  credentialEnvironmentVariables
-}) {
-  const maskedEnvironment = { ...environment };
-  for (const name of credentialEnvironmentVariables) {
-    if (maskedEnvironment[name] != null) {
-      maskedEnvironment[name] = name;
-    }
-  }
-  return maskedEnvironment;
-}
-function createCredentialRequestTransformation({
-  matchUrl,
-  matchHeaders,
-  transformHeaders
-}) {
-  const url = new URL(matchUrl);
-  const pathname = url.pathname.replace(/\/+$/, "");
-  return {
-    match: {
-      host: url.hostname,
-      ...pathname.length === 0 ? {} : { path: { startsWith: pathname } },
-      headers: Object.entries(matchHeaders).map(([key, value]) => ({
-        key: { exact: key },
-        value: { exact: value }
-      }))
-    },
-    transform: { headers: transformHeaders }
-  };
-}
-
-// src/utils/credential-forwarding.ts
-async function applyCredentialForwarding({
-  environment,
-  credentialEnvironmentVariables,
-  credentialForwarding
-}) {
-  const forwardedEnvironment = { ...environment };
-  if (credentialForwarding == null) return forwardedEnvironment;
-  for (const environmentVariableName of new Set(
-    credentialEnvironmentVariables
-  )) {
-    const credential = forwardedEnvironment[environmentVariableName];
-    if (credential == null) continue;
-    forwardedEnvironment[environmentVariableName] = await credentialForwarding({
-      credential,
-      environmentVariableName
-    });
-  }
-  return forwardedEnvironment;
-}
-async function createSandboxCredentialEnvironment({
-  environment,
-  credentialEnvironmentVariables,
-  credentialForwarding
-}) {
-  const sandboxCredentialEnvironment = {};
-  for (const environmentVariableName of new Set(
-    credentialEnvironmentVariables
-  )) {
-    if (environment[environmentVariableName] == null) continue;
-    const placeholder = generateSandboxCredentialPlaceholder();
-    sandboxCredentialEnvironment[environmentVariableName] = credentialForwarding == null ? placeholder : await credentialForwarding({
-      credential: placeholder,
-      environmentVariableName
-    });
-  }
-  return sandboxCredentialEnvironment;
-}
-
-// src/utils/sandbox-home-dir.ts
-import path from "path";
-async function resolveSandboxHomeDir({
-  sandbox,
-  abortSignal
-}) {
-  const result = await sandbox.run({
-    command: 'printf "%s" "$HOME"',
-    abortSignal
-  });
-  const homeDir = result.stdout.trim();
-  if (result.exitCode !== 0 || !homeDir || !path.posix.isAbsolute(homeDir)) {
-    throw new Error(
-      `Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`
-    );
-  }
-  return homeDir;
-}
-
-// src/utils/shell-quote.ts
+	const credentialEnvironmentVariables = [...new Set(options.credentialEnvironmentVariables)];
+	const credentials = credentialEnvironmentVariables.map((name) => options.environment[name]).filter((credential) => credential != null && credential.length > 0);
+	const forwardedCredentials = credentialEnvironmentVariables.map((name) => options.forwardedEnvironment[name]).filter((credential) => credential != null);
+	if (!credentials.some((credential) => forwardedCredentials.some((forwardedCredential) => forwardedCredential.includes(credential)))) return;
+	console.warn("The sandbox implementation does not support configuring request transformations, so credential brokering does not work. Falling back to less secure credential forwarding.");
+}
+function maskSandboxCredentials({ environment, credentialEnvironmentVariables }) {
+	const maskedEnvironment = { ...environment };
+	for (const name of credentialEnvironmentVariables) if (maskedEnvironment[name] != null) maskedEnvironment[name] = name;
+	return maskedEnvironment;
+}
+function createCredentialRequestTransformation({ matchUrl, matchHeaders, transformHeaders }) {
+	const url = new URL(matchUrl);
+	const pathname = url.pathname.replace(/\/+$/, "");
+	return {
+		match: {
+			host: url.hostname,
+			...pathname.length === 0 ? {} : { path: { startsWith: pathname } },
+			headers: Object.entries(matchHeaders).map(([key, value]) => ({
+				key: { exact: key },
+				value: { exact: value }
+			}))
+		},
+		transform: { headers: transformHeaders }
+	};
+}
+//#endregion
+//#region src/utils/credential-forwarding.ts
+async function applyCredentialForwarding({ environment, credentialEnvironmentVariables, credentialForwarding }) {
+	const forwardedEnvironment = { ...environment };
+	if (credentialForwarding == null) return forwardedEnvironment;
+	for (const environmentVariableName of new Set(credentialEnvironmentVariables)) {
+		const credential = forwardedEnvironment[environmentVariableName];
+		if (credential == null) continue;
+		forwardedEnvironment[environmentVariableName] = await credentialForwarding({
+			credential,
+			environmentVariableName
+		});
+	}
+	return forwardedEnvironment;
+}
+async function resolveSandboxCredentialEnvironment({ environment, credentialEnvironmentVariables, credentialForwarding, previousSandboxCredentialEnvironment }) {
+	const sandboxCredentialEnvironment = {};
+	for (const environmentVariableName of new Set(credentialEnvironmentVariables)) {
+		if (environment[environmentVariableName] == null) continue;
+		if (previousSandboxCredentialEnvironment != null && Object.prototype.hasOwnProperty.call(previousSandboxCredentialEnvironment, environmentVariableName)) {
+			sandboxCredentialEnvironment[environmentVariableName] = previousSandboxCredentialEnvironment[environmentVariableName];
+			continue;
+		}
+		const placeholder = generateSandboxCredentialPlaceholder();
+		sandboxCredentialEnvironment[environmentVariableName] = credentialForwarding == null ? placeholder : await credentialForwarding({
+			credential: placeholder,
+			environmentVariableName
+		});
+	}
+	return sandboxCredentialEnvironment;
+}
+//#endregion
+//#region src/utils/sandbox-home-dir.ts
+async function resolveSandboxHomeDir({ sandbox, abortSignal }) {
+	const result = await sandbox.run({
+		command: "printf \"%s\" \"$HOME\"",
+		abortSignal
+	});
+	const homeDir = result.stdout.trim();
+	if (result.exitCode !== 0 || !homeDir || !path.posix.isAbsolute(homeDir)) throw new Error(`Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`);
+	return homeDir;
+}
+//#endregion
+//#region src/utils/shell-quote.ts
 function shellQuote(value) {
-  return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-
-// src/utils/write-instructions.ts
-import path2 from "path";
-import {
-  safeParseJSON as safeParseJSON5
-} from "@ai-sdk/provider-utils";
-var INSTRUCTIONS_METADATA_VERSION = 1;
-async function writeInstructions({
-  sandbox,
-  homePath,
-  instructionsFile,
-  instructions,
-  abortSignal
-}) {
-  const { targetPath, metadataPath } = resolveInstructionsFilePath({
-    homePath,
-    instructionsFile
-  });
-  const hasInstructions = typeof instructions === "string" && instructions.trim().length > 0;
-  const trimmedInstructions = hasInstructions ? instructions.trim() : "";
-  const currentDiskContent = await sandbox.readTextFile({
-    path: targetPath,
-    abortSignal
-  });
-  const existingMetadata = await readInstructionsMetadata({
-    sandbox,
-    metadataPath,
-    abortSignal
-  });
-  if (hasInstructions) {
-    const originalContent = deriveOriginalContent({
-      currentDiskContent,
-      existingMetadata
-    });
-    const targetContent = originalContent != null && originalContent.trim().length > 0 ? `${originalContent.replace(/\n+$/, "")}
-
-${trimmedInstructions}
-` : `${trimmedInstructions}
-`;
-    if (currentDiskContent === targetContent && existingMetadata != null && existingMetadata.instructions === trimmedInstructions && existingMetadata.originalContent === originalContent) {
-      return { changed: false, filePath: targetPath };
-    }
-    await sandbox.writeTextFile({
-      path: targetPath,
-      content: targetContent,
-      abortSignal
-    });
-    await writeInstructionsMetadata({
-      sandbox,
-      metadataPath,
-      metadata: {
-        version: INSTRUCTIONS_METADATA_VERSION,
-        originalContent,
-        instructions: trimmedInstructions,
-        appliedContent: targetContent
-      },
-      abortSignal
-    });
-    return { changed: true, filePath: targetPath };
-  }
-  if (existingMetadata == null) {
-    return { changed: false, filePath: targetPath };
-  }
-  const restoredContent = deriveRestoredContent({
-    currentDiskContent,
-    existingMetadata
-  });
-  if (restoredContent != null) {
-    const contentToWrite = `${restoredContent.replace(/\n+$/, "")}
-`;
-    await sandbox.writeTextFile({
-      path: targetPath,
-      content: contentToWrite,
-      abortSignal
-    });
-  } else {
-    await removeTargetFile({
-      sandbox,
-      targetPath,
-      abortSignal
-    });
-  }
-  await removeMetadataFile({
-    sandbox,
-    metadataPath,
-    abortSignal
-  });
-  return { changed: true, filePath: targetPath };
-}
-function deriveOriginalContent({
-  currentDiskContent,
-  existingMetadata
-}) {
-  if (existingMetadata == null) {
-    return currentDiskContent;
-  }
-  if (currentDiskContent == null) {
-    return existingMetadata.originalContent;
-  }
-  if (currentDiskContent === existingMetadata.appliedContent) {
-    return existingMetadata.originalContent;
-  }
-  const trimmedDisk = currentDiskContent.replace(/\n+$/, "");
-  const expectedSuffix = `
-
-${existingMetadata.instructions}`;
-  if (trimmedDisk.endsWith(expectedSuffix)) {
-    const userBase = trimmedDisk.slice(0, -expectedSuffix.length);
-    return userBase.length > 0 ? userBase : null;
-  }
-  if (trimmedDisk === existingMetadata.instructions) {
-    return null;
-  }
-  return existingMetadata.originalContent ?? currentDiskContent;
-}
-function deriveRestoredContent({
-  currentDiskContent,
-  existingMetadata
-}) {
-  if (currentDiskContent == null) {
-    return null;
-  }
-  if (currentDiskContent === existingMetadata.appliedContent) {
-    return existingMetadata.originalContent != null && existingMetadata.originalContent.trim().length > 0 ? existingMetadata.originalContent : null;
-  }
-  const trimmedDisk = currentDiskContent.replace(/\n+$/, "");
-  const expectedSuffix = `
-
-${existingMetadata.instructions}`;
-  if (trimmedDisk.endsWith(expectedSuffix)) {
-    const userBase = trimmedDisk.slice(0, -expectedSuffix.length);
-    return userBase.length > 0 ? userBase : null;
-  }
-  if (trimmedDisk === existingMetadata.instructions) {
-    return null;
-  }
-  return currentDiskContent;
-}
-function resolveInstructionsFilePath({
-  homePath,
-  instructionsFile
-}) {
-  if (typeof homePath !== "string" || homePath.trim().length === 0) {
-    throw new Error("Invalid homePath: expected a non-empty string.");
-  }
-  if (!path2.posix.isAbsolute(homePath)) {
-    throw new Error(
-      `Invalid homePath ${JSON.stringify(homePath)}: expected an absolute POSIX path.`
-    );
-  }
-  if (typeof instructionsFile !== "string" || instructionsFile.trim().length === 0) {
-    throw new Error(
-      `Invalid instructionsFile ${JSON.stringify(instructionsFile)}: expected a relative POSIX path without traversal.`
-    );
-  }
-  const containsTraversal = instructionsFile.split(/[\\/]/).some((segment) => segment === "..");
-  const normalizedInstructionsFile = path2.posix.normalize(
-    instructionsFile.trim()
-  );
-  const normalizedNoTrailingSlash = normalizedInstructionsFile.replace(
-    /\/+$/,
-    ""
-  );
-  if (instructionsFile.includes("\\") || path2.posix.isAbsolute(instructionsFile) || path2.win32.isAbsolute(instructionsFile) || containsTraversal || instructionsFile.endsWith("/") || instructionsFile.endsWith("\\") || instructionsFile.endsWith("/.") || instructionsFile.endsWith("/..") || normalizedNoTrailingSlash === "" || normalizedNoTrailingSlash === "." || normalizedInstructionsFile.startsWith("../") || normalizedInstructionsFile.includes("/../") || normalizedInstructionsFile.endsWith("/..")) {
-    throw new Error(
-      `Invalid instructionsFile ${JSON.stringify(instructionsFile)}: expected a relative POSIX path without traversal.`
-    );
-  }
-  const targetPath = path2.posix.join(homePath, normalizedNoTrailingSlash);
-  const relative = path2.posix.relative(homePath, targetPath);
-  if (relative === "" || relative.startsWith("..") || path2.posix.isAbsolute(relative)) {
-    throw new Error(
-      `Invalid instructionsFile ${JSON.stringify(instructionsFile)}: must be a subpath within homePath ${JSON.stringify(homePath)}.`
-    );
-  }
-  const dir = path2.posix.dirname(targetPath);
-  const base = path2.posix.basename(targetPath);
-  const metadataPath = path2.posix.join(
-    dir,
-    `.${base}.ai-sdk-harness-instructions.json`
-  );
-  return { targetPath, metadataPath };
-}
-async function readInstructionsMetadata({
-  sandbox,
-  metadataPath,
-  abortSignal
-}) {
-  const content = await sandbox.readTextFile({
-    path: metadataPath,
-    abortSignal
-  });
-  if (content == null) return void 0;
-  const parsed = await safeParseJSON5({ text: content });
-  if (!parsed.success || !isInstructionsMetadata(parsed.value)) {
-    throw new Error(
-      `Invalid AI SDK harness instructions metadata: ${metadataPath}`
-    );
-  }
-  return parsed.value;
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+//#endregion
+//#region src/utils/write-instructions.ts
+const INSTRUCTIONS_METADATA_VERSION = 1;
+async function writeInstructions({ sandbox, homePath, instructionsFile, instructions, abortSignal }) {
+	const { targetPath, metadataPath } = resolveInstructionsFilePath({
+		homePath,
+		instructionsFile
+	});
+	const hasInstructions = typeof instructions === "string" && instructions.trim().length > 0;
+	const trimmedInstructions = hasInstructions ? instructions.trim() : "";
+	const currentDiskContent = await sandbox.readTextFile({
+		path: targetPath,
+		abortSignal
+	});
+	const existingMetadata = await readInstructionsMetadata({
+		sandbox,
+		metadataPath,
+		abortSignal
+	});
+	if (hasInstructions) {
+		const originalContent = deriveOriginalContent({
+			currentDiskContent,
+			existingMetadata
+		});
+		const targetContent = originalContent != null && originalContent.trim().length > 0 ? `${originalContent.replace(/\n+$/, "")}\n\n${trimmedInstructions}\n` : `${trimmedInstructions}\n`;
+		if (currentDiskContent === targetContent && existingMetadata != null && existingMetadata.instructions === trimmedInstructions && existingMetadata.originalContent === originalContent) return {
+			changed: false,
+			filePath: targetPath
+		};
+		await sandbox.writeTextFile({
+			path: targetPath,
+			content: targetContent,
+			abortSignal
+		});
+		await writeInstructionsMetadata({
+			sandbox,
+			metadataPath,
+			metadata: {
+				version: INSTRUCTIONS_METADATA_VERSION,
+				originalContent,
+				instructions: trimmedInstructions,
+				appliedContent: targetContent
+			},
+			abortSignal
+		});
+		return {
+			changed: true,
+			filePath: targetPath
+		};
+	}
+	if (existingMetadata == null) return {
+		changed: false,
+		filePath: targetPath
+	};
+	const restoredContent = deriveRestoredContent({
+		currentDiskContent,
+		existingMetadata
+	});
+	if (restoredContent != null) {
+		const contentToWrite = `${restoredContent.replace(/\n+$/, "")}\n`;
+		await sandbox.writeTextFile({
+			path: targetPath,
+			content: contentToWrite,
+			abortSignal
+		});
+	} else await removeTargetFile({
+		sandbox,
+		targetPath,
+		abortSignal
+	});
+	await removeMetadataFile({
+		sandbox,
+		metadataPath,
+		abortSignal
+	});
+	return {
+		changed: true,
+		filePath: targetPath
+	};
+}
+function deriveOriginalContent({ currentDiskContent, existingMetadata }) {
+	if (existingMetadata == null) return currentDiskContent;
+	if (currentDiskContent == null) return existingMetadata.originalContent;
+	if (currentDiskContent === existingMetadata.appliedContent) return existingMetadata.originalContent;
+	const trimmedDisk = currentDiskContent.replace(/\n+$/, "");
+	const expectedSuffix = `\n\n${existingMetadata.instructions}`;
+	if (trimmedDisk.endsWith(expectedSuffix)) {
+		const userBase = trimmedDisk.slice(0, -expectedSuffix.length);
+		return userBase.length > 0 ? userBase : null;
+	}
+	if (trimmedDisk === existingMetadata.instructions) return null;
+	return existingMetadata.originalContent ?? currentDiskContent;
+}
+function deriveRestoredContent({ currentDiskContent, existingMetadata }) {
+	if (currentDiskContent == null) return null;
+	if (currentDiskContent === existingMetadata.appliedContent) return existingMetadata.originalContent != null && existingMetadata.originalContent.trim().length > 0 ? existingMetadata.originalContent : null;
+	const trimmedDisk = currentDiskContent.replace(/\n+$/, "");
+	const expectedSuffix = `\n\n${existingMetadata.instructions}`;
+	if (trimmedDisk.endsWith(expectedSuffix)) {
+		const userBase = trimmedDisk.slice(0, -expectedSuffix.length);
+		return userBase.length > 0 ? userBase : null;
+	}
+	if (trimmedDisk === existingMetadata.instructions) return null;
+	return currentDiskContent;
+}
+function resolveInstructionsFilePath({ homePath, instructionsFile }) {
+	if (typeof homePath !== "string" || homePath.trim().length === 0) throw new Error("Invalid homePath: expected a non-empty string.");
+	if (!path.posix.isAbsolute(homePath)) throw new Error(`Invalid homePath ${JSON.stringify(homePath)}: expected an absolute POSIX path.`);
+	if (typeof instructionsFile !== "string" || instructionsFile.trim().length === 0) throw new Error(`Invalid instructionsFile ${JSON.stringify(instructionsFile)}: expected a relative POSIX path without traversal.`);
+	const containsTraversal = instructionsFile.split(/[\\/]/).some((segment) => segment === "..");
+	const normalizedInstructionsFile = path.posix.normalize(instructionsFile.trim());
+	const normalizedNoTrailingSlash = normalizedInstructionsFile.replace(/\/+$/, "");
+	if (instructionsFile.includes("\\") || path.posix.isAbsolute(instructionsFile) || path.win32.isAbsolute(instructionsFile) || containsTraversal || instructionsFile.endsWith("/") || instructionsFile.endsWith("\\") || instructionsFile.endsWith("/.") || instructionsFile.endsWith("/..") || normalizedNoTrailingSlash === "" || normalizedNoTrailingSlash === "." || normalizedInstructionsFile.startsWith("../") || normalizedInstructionsFile.includes("/../") || normalizedInstructionsFile.endsWith("/..")) throw new Error(`Invalid instructionsFile ${JSON.stringify(instructionsFile)}: expected a relative POSIX path without traversal.`);
+	const targetPath = path.posix.join(homePath, normalizedNoTrailingSlash);
+	const relative = path.posix.relative(homePath, targetPath);
+	if (relative === "" || relative.startsWith("..") || path.posix.isAbsolute(relative)) throw new Error(`Invalid instructionsFile ${JSON.stringify(instructionsFile)}: must be a subpath within homePath ${JSON.stringify(homePath)}.`);
+	const dir = path.posix.dirname(targetPath);
+	const base = path.posix.basename(targetPath);
+	return {
+		targetPath,
+		metadataPath: path.posix.join(dir, `.${base}.ai-sdk-harness-instructions.json`)
+	};
+}
+async function readInstructionsMetadata({ sandbox, metadataPath, abortSignal }) {
+	const content = await sandbox.readTextFile({
+		path: metadataPath,
+		abortSignal
+	});
+	if (content == null) return void 0;
+	const parsed = await safeParseJSON({ text: content });
+	if (!parsed.success || !isInstructionsMetadata(parsed.value)) throw new Error(`Invalid AI SDK harness instructions metadata: ${metadataPath}`);
+	return parsed.value;
 }
 function isInstructionsMetadata(value) {
-  if (value == null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const candidate = value;
-  return candidate.version === INSTRUCTIONS_METADATA_VERSION && (candidate.originalContent === null || typeof candidate.originalContent === "string") && typeof candidate.instructions === "string" && typeof candidate.appliedContent === "string";
-}
-async function writeInstructionsMetadata({
-  sandbox,
-  metadataPath,
-  metadata,
-  abortSignal
-}) {
-  const temporaryPath = `${metadataPath}.tmp`;
-  await sandbox.writeTextFile({
-    path: temporaryPath,
-    content: `${JSON.stringify(metadata, null, 2)}
-`,
-    abortSignal
-  });
-  await runSandboxCommand({
-    sandbox,
-    command: `mv -f ${shellQuote(temporaryPath)} ${shellQuote(metadataPath)}`,
-    abortSignal,
-    errorMessage: `Failed to update instructions metadata: ${metadataPath}`
-  });
-}
-async function removeMetadataFile({
-  sandbox,
-  metadataPath,
-  abortSignal
-}) {
-  await runSandboxCommand({
-    sandbox,
-    command: `rm -f -- ${shellQuote(metadataPath)}`,
-    abortSignal,
-    errorMessage: `Failed to remove instructions metadata: ${metadataPath}`
-  });
-}
-async function removeTargetFile({
-  sandbox,
-  targetPath,
-  abortSignal
-}) {
-  await runSandboxCommand({
-    sandbox,
-    command: `rm -f -- ${shellQuote(targetPath)}`,
-    abortSignal,
-    errorMessage: `Failed to remove instructions file: ${targetPath}`
-  });
-}
-async function runSandboxCommand({
-  sandbox,
-  command,
-  abortSignal,
-  errorMessage
-}) {
-  const result = await sandbox.run({ command, abortSignal });
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `${errorMessage} (exit ${result.exitCode})${result.stderr ? `: ${result.stderr}` : ""}`
-    );
-  }
-}
-
-// src/utils/write-skills.ts
-import { createHash } from "crypto";
-import path3 from "path";
-import {
-  safeParseJSON as safeParseJSON6
-} from "@ai-sdk/provider-utils";
-var SKILLS_MANIFEST_FILENAME = ".ai-sdk-harness-skills.json";
-var SKILLS_MANIFEST_VERSION = 1;
-var SAFE_MANIFEST_SKILL_NAME = /^[A-Za-z0-9._-]+$/;
-async function writeSkills({
-  sandbox,
-  homePath,
-  skillsDir,
-  skills,
-  abortSignal,
-  skillNamePattern = /^[A-Za-z0-9._-]+$/,
-  invalidSkillNameMessage = ({ name }) => `Invalid skill name: ${name}`,
-  filePathMode = "relative",
-  invalidSkillFilePathMessage = ({ skillName, filePath }) => `Invalid skill file path for ${skillName}: ${filePath}`,
-  trailingNewline = false
-}) {
-  const rootDir = resolveSkillsRootDir({ homePath, skillsDir });
-  const projectedSkills = skills.map(
-    (skill) => projectSkill({
-      skill,
-      skillNamePattern,
-      invalidSkillNameMessage,
-      filePathMode,
-      invalidSkillFilePathMessage,
-      trailingNewline
-    })
-  ).sort((a, b) => a.name.localeCompare(b.name));
-  assertUniqueSkillNames(projectedSkills);
-  const manifestPath = path3.posix.join(rootDir, SKILLS_MANIFEST_FILENAME);
-  const existingManifest = await readSkillsManifest({
-    sandbox,
-    manifestPath,
-    abortSignal
-  });
-  const nextEntries = projectedSkills.map(({ name, hash }) => ({ name, hash }));
-  const nextByName = new Map(nextEntries.map((entry) => [entry.name, entry]));
-  if (existingManifest?.state === "pending") {
-    await ensureSkillsDirectory({ sandbox, rootDir, abortSignal });
-    const recoveryNames = existingManifest.skills.map((skill) => skill.name);
-    await removeSkillDirectories({
-      sandbox,
-      rootDir,
-      skillNames: recoveryNames,
-      abortSignal
-    });
-    const removed2 = recoveryNames.filter((name) => !nextByName.has(name)).sort((a, b) => a.localeCompare(b));
-    await writeProjectedSkills({
-      sandbox,
-      rootDir,
-      skills: projectedSkills,
-      abortSignal
-    });
-    await writeSkillsManifest({
-      sandbox,
-      manifestPath,
-      manifest: {
-        version: SKILLS_MANIFEST_VERSION,
-        state: "complete",
-        skills: nextEntries
-      },
-      abortSignal
-    });
-    return {
-      changed: recoveryNames.length > 0 || projectedSkills.length > 0,
-      written: projectedSkills.map((skill) => skill.name),
-      removed: removed2,
-      unchanged: []
-    };
-  }
-  const previousEntries = existingManifest?.skills ?? [];
-  const previousByName = new Map(
-    previousEntries.map((entry) => [entry.name, entry])
-  );
-  const removed = previousEntries.filter((entry) => !nextByName.has(entry.name)).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
-  const written = projectedSkills.filter((skill) => previousByName.get(skill.name)?.hash !== skill.hash).map((skill) => skill.name).sort((a, b) => a.localeCompare(b));
-  const unchanged = projectedSkills.filter((skill) => previousByName.get(skill.name)?.hash === skill.hash).map((skill) => skill.name).sort((a, b) => a.localeCompare(b));
-  const changed = removed.length > 0 || written.length > 0;
-  if (!changed && existingManifest != null) {
-    return { changed: false, written, removed, unchanged };
-  }
-  const previouslyOwned = new Set(previousEntries.map((entry) => entry.name));
-  for (const skillName of written) {
-    if (previouslyOwned.has(skillName)) continue;
-    await assertSkillDirectoryAvailable({
-      sandbox,
-      rootDir,
-      skillName,
-      abortSignal
-    });
-  }
-  await ensureSkillsDirectory({ sandbox, rootDir, abortSignal });
-  const pendingNames = Array.from(
-    /* @__PURE__ */ new Set([
-      ...previousEntries.map((entry) => entry.name),
-      ...nextEntries.map((entry) => entry.name)
-    ])
-  ).sort((a, b) => a.localeCompare(b));
-  await writeSkillsManifest({
-    sandbox,
-    manifestPath,
-    manifest: {
-      version: SKILLS_MANIFEST_VERSION,
-      state: "pending",
-      skills: pendingNames.map((name) => ({
-        name,
-        hash: nextByName.get(name)?.hash ?? previousByName.get(name).hash
-      }))
-    },
-    abortSignal
-  });
-  await removeSkillDirectories({
-    sandbox,
-    rootDir,
-    skillNames: [
-      ...removed,
-      ...written.filter((name) => previouslyOwned.has(name))
-    ],
-    abortSignal
-  });
-  const writtenSet = new Set(written);
-  await writeProjectedSkills({
-    sandbox,
-    rootDir,
-    skills: projectedSkills.filter((skill) => writtenSet.has(skill.name)),
-    abortSignal
-  });
-  await writeSkillsManifest({
-    sandbox,
-    manifestPath,
-    manifest: {
-      version: SKILLS_MANIFEST_VERSION,
-      state: "complete",
-      skills: nextEntries
-    },
-    abortSignal
-  });
-  return { changed, written, removed, unchanged };
-}
-async function ensureSkillsDirectory({
-  sandbox,
-  rootDir,
-  abortSignal
-}) {
-  await runSandboxCommand2({
-    sandbox,
-    command: `mkdir -p ${shellQuote(rootDir)}`,
-    abortSignal,
-    errorMessage: `Failed to create skills directory: ${rootDir}`
-  });
-}
-function projectSkill({
-  skill,
-  skillNamePattern,
-  invalidSkillNameMessage,
-  filePathMode,
-  invalidSkillFilePathMessage,
-  trailingNewline
-}) {
-  const name = validateSkillName({
-    name: skill.name,
-    pattern: skillNamePattern,
-    message: invalidSkillNameMessage
-  });
-  const files = /* @__PURE__ */ new Map();
-  files.set("SKILL.md", renderSkillFile({ skill, trailingNewline }));
-  for (const file of skill.files ?? []) {
-    files.set(
-      normalizeSkillFilePath({
-        skillName: skill.name,
-        filePath: file.path,
-        mode: filePathMode,
-        message: invalidSkillFilePathMessage
-      }),
-      file.content
-    );
-  }
-  const projectedFiles = Array.from(files, ([filePath, content]) => ({
-    path: filePath,
-    content
-  })).sort((a, b) => a.path.localeCompare(b.path));
-  const hash = createHash("sha256");
-  for (const file of projectedFiles) {
-    hash.update(String(Buffer.byteLength(file.path)));
-    hash.update(":");
-    hash.update(file.path);
-    hash.update(String(Buffer.byteLength(file.content)));
-    hash.update(":");
-    hash.update(file.content);
-  }
-  return { name, hash: hash.digest("hex"), files: projectedFiles };
-}
-async function readSkillsManifest({
-  sandbox,
-  manifestPath,
-  abortSignal
-}) {
-  const content = await sandbox.readTextFile({
-    path: manifestPath,
-    abortSignal
-  });
-  if (content == null) return void 0;
-  const parsed = await safeParseJSON6({ text: content });
-  if (!parsed.success || !isSkillsManifest(parsed.value)) {
-    throw new Error(`Invalid AI SDK harness skills manifest: ${manifestPath}`);
-  }
-  return parsed.value;
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	const candidate = value;
+	return candidate.version === INSTRUCTIONS_METADATA_VERSION && (candidate.originalContent === null || typeof candidate.originalContent === "string") && typeof candidate.instructions === "string" && typeof candidate.appliedContent === "string";
+}
+async function writeInstructionsMetadata({ sandbox, metadataPath, metadata, abortSignal }) {
+	const temporaryPath = `${metadataPath}.tmp`;
+	await sandbox.writeTextFile({
+		path: temporaryPath,
+		content: `${JSON.stringify(metadata, null, 2)}\n`,
+		abortSignal
+	});
+	await runSandboxCommand$1({
+		sandbox,
+		command: `mv -f ${shellQuote(temporaryPath)} ${shellQuote(metadataPath)}`,
+		abortSignal,
+		errorMessage: `Failed to update instructions metadata: ${metadataPath}`
+	});
+}
+async function removeMetadataFile({ sandbox, metadataPath, abortSignal }) {
+	await runSandboxCommand$1({
+		sandbox,
+		command: `rm -f -- ${shellQuote(metadataPath)}`,
+		abortSignal,
+		errorMessage: `Failed to remove instructions metadata: ${metadataPath}`
+	});
+}
+async function removeTargetFile({ sandbox, targetPath, abortSignal }) {
+	await runSandboxCommand$1({
+		sandbox,
+		command: `rm -f -- ${shellQuote(targetPath)}`,
+		abortSignal,
+		errorMessage: `Failed to remove instructions file: ${targetPath}`
+	});
+}
+async function runSandboxCommand$1({ sandbox, command, abortSignal, errorMessage }) {
+	const result = await sandbox.run({
+		command,
+		abortSignal
+	});
+	if (result.exitCode !== 0) throw new Error(`${errorMessage} (exit ${result.exitCode})${result.stderr ? `: ${result.stderr}` : ""}`);
+}
+//#endregion
+//#region src/utils/write-skills.ts
+const SKILLS_MANIFEST_FILENAME = ".ai-sdk-harness-skills.json";
+const SKILLS_MANIFEST_VERSION = 1;
+const SAFE_MANIFEST_SKILL_NAME = /^[A-Za-z0-9._-]+$/;
+async function writeSkills({ sandbox, homePath, skillsDir, skills, abortSignal, skillNamePattern = /^[A-Za-z0-9._-]+$/, invalidSkillNameMessage = ({ name }) => `Invalid skill name: ${name}`, filePathMode = "relative", invalidSkillFilePathMessage = ({ skillName, filePath }) => `Invalid skill file path for ${skillName}: ${filePath}`, trailingNewline = false }) {
+	const rootDir = resolveSkillsRootDir({
+		homePath,
+		skillsDir
+	});
+	const projectedSkills = skills.map((skill) => projectSkill({
+		skill,
+		skillNamePattern,
+		invalidSkillNameMessage,
+		filePathMode,
+		invalidSkillFilePathMessage,
+		trailingNewline
+	})).sort((a, b) => a.name.localeCompare(b.name));
+	assertUniqueSkillNames(projectedSkills);
+	const manifestPath = path.posix.join(rootDir, SKILLS_MANIFEST_FILENAME);
+	const existingManifest = await readSkillsManifest({
+		sandbox,
+		manifestPath,
+		abortSignal
+	});
+	const nextEntries = projectedSkills.map(({ name, hash }) => ({
+		name,
+		hash
+	}));
+	const nextByName = new Map(nextEntries.map((entry) => [entry.name, entry]));
+	if (existingManifest?.state === "pending") {
+		await ensureSkillsDirectory({
+			sandbox,
+			rootDir,
+			abortSignal
+		});
+		const recoveryNames = existingManifest.skills.map((skill) => skill.name);
+		await removeSkillDirectories({
+			sandbox,
+			rootDir,
+			skillNames: recoveryNames,
+			abortSignal
+		});
+		const removed = recoveryNames.filter((name) => !nextByName.has(name)).sort((a, b) => a.localeCompare(b));
+		await writeProjectedSkills({
+			sandbox,
+			rootDir,
+			skills: projectedSkills,
+			abortSignal
+		});
+		await writeSkillsManifest({
+			sandbox,
+			manifestPath,
+			manifest: {
+				version: SKILLS_MANIFEST_VERSION,
+				state: "complete",
+				skills: nextEntries
+			},
+			abortSignal
+		});
+		return {
+			changed: recoveryNames.length > 0 || projectedSkills.length > 0,
+			written: projectedSkills.map((skill) => skill.name),
+			removed,
+			unchanged: []
+		};
+	}
+	const previousEntries = existingManifest?.skills ?? [];
+	const previousByName = new Map(previousEntries.map((entry) => [entry.name, entry]));
+	const removed = previousEntries.filter((entry) => !nextByName.has(entry.name)).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
+	const written = projectedSkills.filter((skill) => previousByName.get(skill.name)?.hash !== skill.hash).map((skill) => skill.name).sort((a, b) => a.localeCompare(b));
+	const unchanged = projectedSkills.filter((skill) => previousByName.get(skill.name)?.hash === skill.hash).map((skill) => skill.name).sort((a, b) => a.localeCompare(b));
+	const changed = removed.length > 0 || written.length > 0;
+	if (!changed && existingManifest != null) return {
+		changed: false,
+		written,
+		removed,
+		unchanged
+	};
+	const previouslyOwned = new Set(previousEntries.map((entry) => entry.name));
+	for (const skillName of written) {
+		if (previouslyOwned.has(skillName)) continue;
+		await assertSkillDirectoryAvailable({
+			sandbox,
+			rootDir,
+			skillName,
+			abortSignal
+		});
+	}
+	await ensureSkillsDirectory({
+		sandbox,
+		rootDir,
+		abortSignal
+	});
+	const pendingNames = Array.from(/* @__PURE__ */ new Set([...previousEntries.map((entry) => entry.name), ...nextEntries.map((entry) => entry.name)])).sort((a, b) => a.localeCompare(b));
+	await writeSkillsManifest({
+		sandbox,
+		manifestPath,
+		manifest: {
+			version: SKILLS_MANIFEST_VERSION,
+			state: "pending",
+			skills: pendingNames.map((name) => ({
+				name,
+				hash: nextByName.get(name)?.hash ?? previousByName.get(name).hash
+			}))
+		},
+		abortSignal
+	});
+	await removeSkillDirectories({
+		sandbox,
+		rootDir,
+		skillNames: [...removed, ...written.filter((name) => previouslyOwned.has(name))],
+		abortSignal
+	});
+	const writtenSet = new Set(written);
+	await writeProjectedSkills({
+		sandbox,
+		rootDir,
+		skills: projectedSkills.filter((skill) => writtenSet.has(skill.name)),
+		abortSignal
+	});
+	await writeSkillsManifest({
+		sandbox,
+		manifestPath,
+		manifest: {
+			version: SKILLS_MANIFEST_VERSION,
+			state: "complete",
+			skills: nextEntries
+		},
+		abortSignal
+	});
+	return {
+		changed,
+		written,
+		removed,
+		unchanged
+	};
+}
+async function ensureSkillsDirectory({ sandbox, rootDir, abortSignal }) {
+	await runSandboxCommand({
+		sandbox,
+		command: `mkdir -p ${shellQuote(rootDir)}`,
+		abortSignal,
+		errorMessage: `Failed to create skills directory: ${rootDir}`
+	});
+}
+function projectSkill({ skill, skillNamePattern, invalidSkillNameMessage, filePathMode, invalidSkillFilePathMessage, trailingNewline }) {
+	const name = validateSkillName({
+		name: skill.name,
+		pattern: skillNamePattern,
+		message: invalidSkillNameMessage
+	});
+	const files = /* @__PURE__ */ new Map();
+	files.set("SKILL.md", renderSkillFile({
+		skill,
+		trailingNewline
+	}));
+	for (const file of skill.files ?? []) files.set(normalizeSkillFilePath({
+		skillName: skill.name,
+		filePath: file.path,
+		mode: filePathMode,
+		message: invalidSkillFilePathMessage
+	}), file.content);
+	const projectedFiles = Array.from(files, ([filePath, content]) => ({
+		path: filePath,
+		content
+	})).sort((a, b) => a.path.localeCompare(b.path));
+	const hash = createHash("sha256");
+	for (const file of projectedFiles) {
+		hash.update(String(Buffer.byteLength(file.path)));
+		hash.update(":");
+		hash.update(file.path);
+		hash.update(String(Buffer.byteLength(file.content)));
+		hash.update(":");
+		hash.update(file.content);
+	}
+	return {
+		name,
+		hash: hash.digest("hex"),
+		files: projectedFiles
+	};
+}
+async function readSkillsManifest({ sandbox, manifestPath, abortSignal }) {
+	const content = await sandbox.readTextFile({
+		path: manifestPath,
+		abortSignal
+	});
+	if (content == null) return void 0;
+	const parsed = await safeParseJSON({ text: content });
+	if (!parsed.success || !isSkillsManifest(parsed.value)) throw new Error(`Invalid AI SDK harness skills manifest: ${manifestPath}`);
+	return parsed.value;
 }
 function isSkillsManifest(value) {
-  if (value == null || typeof value !== "object" || Array.isArray(value)) {
-    return false;
-  }
-  const manifest = value;
-  if (manifest.version !== SKILLS_MANIFEST_VERSION || manifest.state !== "complete" && manifest.state !== "pending" || !Array.isArray(manifest.skills)) {
-    return false;
-  }
-  const names = /* @__PURE__ */ new Set();
-  for (const entry of manifest.skills) {
-    if (entry == null || typeof entry !== "object" || Array.isArray(entry)) {
-      return false;
-    }
-    const skill = entry;
-    if (typeof skill.name !== "string" || !isSafeManifestSkillName(skill.name) || typeof skill.hash !== "string" || !/^[a-f0-9]{64}$/.test(skill.hash) || names.has(skill.name)) {
-      return false;
-    }
-    names.add(skill.name);
-  }
-  return true;
-}
-async function writeSkillsManifest({
-  sandbox,
-  manifestPath,
-  manifest,
-  abortSignal
-}) {
-  const temporaryPath = `${manifestPath}.tmp`;
-  await sandbox.writeTextFile({
-    path: temporaryPath,
-    content: `${JSON.stringify(manifest, null, 2)}
-`,
-    abortSignal
-  });
-  await runSandboxCommand2({
-    sandbox,
-    command: `mv -f ${shellQuote(temporaryPath)} ${shellQuote(manifestPath)}`,
-    abortSignal,
-    errorMessage: `Failed to update skills manifest: ${manifestPath}`
-  });
-}
-async function assertSkillDirectoryAvailable({
-  sandbox,
-  rootDir,
-  skillName,
-  abortSignal
-}) {
-  const skillDir = path3.posix.join(rootDir, skillName);
-  const result = await sandbox.run({
-    command: `test ! -e ${shellQuote(skillDir)}`,
-    abortSignal
-  });
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Cannot write harness skill '${skillName}': ${skillDir} already exists and is not owned by the AI SDK harness.`
-    );
-  }
-}
-async function removeSkillDirectories({
-  sandbox,
-  rootDir,
-  skillNames,
-  abortSignal
-}) {
-  if (skillNames.length === 0) return;
-  const directories = Array.from(new Set(skillNames)).sort((a, b) => a.localeCompare(b)).map((name) => shellQuote(path3.posix.join(rootDir, name))).join(" ");
-  await runSandboxCommand2({
-    sandbox,
-    command: `rm -rf -- ${directories}`,
-    abortSignal,
-    errorMessage: `Failed to replace harness skills in: ${rootDir}`
-  });
-}
-async function writeProjectedSkills({
-  sandbox,
-  rootDir,
-  skills,
-  abortSignal
-}) {
-  for (const skill of skills) {
-    const skillDir = path3.posix.join(rootDir, skill.name);
-    for (const file of skill.files) {
-      await sandbox.writeTextFile({
-        path: path3.posix.join(skillDir, file.path),
-        content: file.content,
-        abortSignal
-      });
-    }
-  }
-}
-async function runSandboxCommand2({
-  sandbox,
-  command,
-  abortSignal,
-  errorMessage
-}) {
-  const result = await sandbox.run({ command, abortSignal });
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `${errorMessage} (exit ${result.exitCode})${result.stderr ? `: ${result.stderr}` : ""}`
-    );
-  }
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	const manifest = value;
+	if (manifest.version !== SKILLS_MANIFEST_VERSION || manifest.state !== "complete" && manifest.state !== "pending" || !Array.isArray(manifest.skills)) return false;
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of manifest.skills) {
+		if (entry == null || typeof entry !== "object" || Array.isArray(entry)) return false;
+		const skill = entry;
+		if (typeof skill.name !== "string" || !isSafeManifestSkillName(skill.name) || typeof skill.hash !== "string" || !/^[a-f0-9]{64}$/.test(skill.hash) || names.has(skill.name)) return false;
+		names.add(skill.name);
+	}
+	return true;
+}
+async function writeSkillsManifest({ sandbox, manifestPath, manifest, abortSignal }) {
+	const temporaryPath = `${manifestPath}.tmp`;
+	await sandbox.writeTextFile({
+		path: temporaryPath,
+		content: `${JSON.stringify(manifest, null, 2)}\n`,
+		abortSignal
+	});
+	await runSandboxCommand({
+		sandbox,
+		command: `mv -f ${shellQuote(temporaryPath)} ${shellQuote(manifestPath)}`,
+		abortSignal,
+		errorMessage: `Failed to update skills manifest: ${manifestPath}`
+	});
+}
+async function assertSkillDirectoryAvailable({ sandbox, rootDir, skillName, abortSignal }) {
+	const skillDir = path.posix.join(rootDir, skillName);
+	if ((await sandbox.run({
+		command: `test ! -e ${shellQuote(skillDir)}`,
+		abortSignal
+	})).exitCode !== 0) throw new Error(`Cannot write harness skill '${skillName}': ${skillDir} already exists and is not owned by the AI SDK harness.`);
+}
+async function removeSkillDirectories({ sandbox, rootDir, skillNames, abortSignal }) {
+	if (skillNames.length === 0) return;
+	await runSandboxCommand({
+		sandbox,
+		command: `rm -rf -- ${Array.from(new Set(skillNames)).sort((a, b) => a.localeCompare(b)).map((name) => shellQuote(path.posix.join(rootDir, name))).join(" ")}`,
+		abortSignal,
+		errorMessage: `Failed to replace harness skills in: ${rootDir}`
+	});
+}
+async function writeProjectedSkills({ sandbox, rootDir, skills, abortSignal }) {
+	for (const skill of skills) {
+		const skillDir = path.posix.join(rootDir, skill.name);
+		for (const file of skill.files) await sandbox.writeTextFile({
+			path: path.posix.join(skillDir, file.path),
+			content: file.content,
+			abortSignal
+		});
+	}
+}
+async function runSandboxCommand({ sandbox, command, abortSignal, errorMessage }) {
+	const result = await sandbox.run({
+		command,
+		abortSignal
+	});
+	if (result.exitCode !== 0) throw new Error(`${errorMessage} (exit ${result.exitCode})${result.stderr ? `: ${result.stderr}` : ""}`);
 }
 function assertUniqueSkillNames(skills) {
-  for (let index = 1; index < skills.length; index++) {
-    if (skills[index - 1].name === skills[index].name) {
-      throw new Error(`Duplicate skill name: ${skills[index].name}`);
-    }
-  }
+	for (let index = 1; index < skills.length; index++) if (skills[index - 1].name === skills[index].name) throw new Error(`Duplicate skill name: ${skills[index].name}`);
 }
 function isSafeManifestSkillName(name) {
-  SAFE_MANIFEST_SKILL_NAME.lastIndex = 0;
-  const matches = SAFE_MANIFEST_SKILL_NAME.test(name);
-  SAFE_MANIFEST_SKILL_NAME.lastIndex = 0;
-  return matches && name !== "." && name !== ".." && !name.includes("/");
-}
-function validateSkillName({
-  name,
-  pattern,
-  message
-}) {
-  pattern.lastIndex = 0;
-  const matches = pattern.test(name);
-  pattern.lastIndex = 0;
-  if (!matches || name === "." || name === "..") {
-    throw new Error(message?.({ name }) ?? `Invalid skill name: ${name}`);
-  }
-  return name;
-}
-function normalizeSkillFilePath({
-  skillName,
-  filePath,
-  mode,
-  message
-}) {
-  const normalized = mode === "strip-leading-slashes" ? filePath.replace(/^\/+/, "") : path3.posix.normalize(filePath);
-  const invalid = normalized === "" || mode === "relative" && normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..") || mode === "relative" && path3.posix.isAbsolute(normalized);
-  if (invalid) {
-    throw new Error(
-      message?.({ skillName: skillName ?? "", filePath }) ?? `Invalid skill file path for ${skillName}: ${filePath}`
-    );
-  }
-  return normalized;
-}
-function renderSkillFile({
-  skill,
-  trailingNewline
-}) {
-  const content = `---
-name: ${skill.name}
-description: ${skill.description}
----
-
-${skill.content}`;
-  return trailingNewline ? `${content}
-` : content;
-}
-function resolveSkillsRootDir({
-  homePath,
-  skillsDir
-}) {
-  if (typeof homePath !== "string" || homePath.trim().length === 0) {
-    throw new Error("Invalid homePath: expected a non-empty string.");
-  }
-  if (!path3.posix.isAbsolute(homePath)) {
-    throw new Error(
-      `Invalid homePath ${JSON.stringify(homePath)}: expected an absolute POSIX path.`
-    );
-  }
-  if (typeof skillsDir !== "string" || skillsDir.trim().length === 0) {
-    throw new Error(
-      `Invalid skillsDir ${JSON.stringify(skillsDir)}: expected a relative POSIX path without traversal.`
-    );
-  }
-  const containsTraversal = skillsDir.split(/[\\/]/).some((segment) => segment === "..");
-  const normalizedSkillsDir = path3.posix.normalize(skillsDir.trim());
-  const normalizedNoTrailingSlash = normalizedSkillsDir.replace(/\/+$/, "");
-  if (skillsDir.includes("\\") || path3.posix.isAbsolute(skillsDir) || path3.win32.isAbsolute(skillsDir) || containsTraversal || normalizedNoTrailingSlash === "" || normalizedNoTrailingSlash === "." || normalizedSkillsDir.startsWith("../") || normalizedSkillsDir.includes("/../") || normalizedSkillsDir.endsWith("/..")) {
-    throw new Error(
-      `Invalid skillsDir ${JSON.stringify(skillsDir)}: expected a relative POSIX path without traversal.`
-    );
-  }
-  const rootDir = path3.posix.join(homePath, normalizedNoTrailingSlash);
-  const relative = path3.posix.relative(homePath, rootDir);
-  if (relative === "" || relative.startsWith("..") || path3.posix.isAbsolute(relative)) {
-    throw new Error(
-      `Invalid skillsDir ${JSON.stringify(skillsDir)}: must be a subpath within homePath ${JSON.stringify(homePath)}.`
-    );
-  }
-  return rootDir;
-}
-
-// src/utils/bridge-ready.ts
-import {
-  safeParseJSON as safeParseJSON7
-} from "@ai-sdk/provider-utils";
-import { z as z4 } from "zod/v4";
-
-// src/v1/harness-v1-bridge-protocol.ts
-import { z as z3 } from "zod/v4";
-
-// src/v1/harness-v1-diagnostic.ts
-import { z } from "zod/v4";
-var harnessV1DebugLevelSchema = z.enum([
-  "error",
-  "warn",
-  "info",
-  "debug",
-  "trace"
+	SAFE_MANIFEST_SKILL_NAME.lastIndex = 0;
+	const matches = SAFE_MANIFEST_SKILL_NAME.test(name);
+	SAFE_MANIFEST_SKILL_NAME.lastIndex = 0;
+	return matches && name !== "." && name !== ".." && !name.includes("/");
+}
+function validateSkillName({ name, pattern, message }) {
+	pattern.lastIndex = 0;
+	const matches = pattern.test(name);
+	pattern.lastIndex = 0;
+	if (!matches || name === "." || name === "..") throw new Error(message?.({ name }) ?? `Invalid skill name: ${name}`);
+	return name;
+}
+function normalizeSkillFilePath({ skillName, filePath, mode, message }) {
+	const normalized = mode === "strip-leading-slashes" ? filePath.replace(/^\/+/, "") : path.posix.normalize(filePath);
+	if (normalized === "" || mode === "relative" && normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || normalized.endsWith("/..") || mode === "relative" && path.posix.isAbsolute(normalized)) throw new Error(message?.({
+		skillName: skillName ?? "",
+		filePath
+	}) ?? `Invalid skill file path for ${skillName}: ${filePath}`);
+	return normalized;
+}
+function renderSkillFile({ skill, trailingNewline }) {
+	const content = `---\nname: ${skill.name}\ndescription: ${skill.description}\n---\n\n${skill.content}`;
+	return trailingNewline ? `${content}\n` : content;
+}
+function resolveSkillsRootDir({ homePath, skillsDir }) {
+	if (typeof homePath !== "string" || homePath.trim().length === 0) throw new Error("Invalid homePath: expected a non-empty string.");
+	if (!path.posix.isAbsolute(homePath)) throw new Error(`Invalid homePath ${JSON.stringify(homePath)}: expected an absolute POSIX path.`);
+	if (typeof skillsDir !== "string" || skillsDir.trim().length === 0) throw new Error(`Invalid skillsDir ${JSON.stringify(skillsDir)}: expected a relative POSIX path without traversal.`);
+	const containsTraversal = skillsDir.split(/[\\/]/).some((segment) => segment === "..");
+	const normalizedSkillsDir = path.posix.normalize(skillsDir.trim());
+	const normalizedNoTrailingSlash = normalizedSkillsDir.replace(/\/+$/, "");
+	if (skillsDir.includes("\\") || path.posix.isAbsolute(skillsDir) || path.win32.isAbsolute(skillsDir) || containsTraversal || normalizedNoTrailingSlash === "" || normalizedNoTrailingSlash === "." || normalizedSkillsDir.startsWith("../") || normalizedSkillsDir.includes("/../") || normalizedSkillsDir.endsWith("/..")) throw new Error(`Invalid skillsDir ${JSON.stringify(skillsDir)}: expected a relative POSIX path without traversal.`);
+	const rootDir = path.posix.join(homePath, normalizedNoTrailingSlash);
+	const relative = path.posix.relative(homePath, rootDir);
+	if (relative === "" || relative.startsWith("..") || path.posix.isAbsolute(relative)) throw new Error(`Invalid skillsDir ${JSON.stringify(skillsDir)}: must be a subpath within homePath ${JSON.stringify(homePath)}.`);
+	return rootDir;
+}
+//#endregion
+//#region src/v1/harness-v1-diagnostic.ts
+/** Severity of a diagnostic, ordered most → least severe. */
+const harnessV1DebugLevelSchema = z.enum([
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
 ]);
-var harnessV1DebugConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  level: harnessV1DebugLevelSchema.optional(),
-  subsystems: z.array(z.string()).optional()
+/**
+* Per-session diagnostics configuration the framework hands an adapter (and the
+* host sends on `start.debug`). When absent or `enabled` is false the adapter
+* captures and emits nothing. `subsystems` filters structured events by dotted
+* prefix; console capture is independent of the subsystem filter.
+*/
+const harnessV1DebugConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	level: harnessV1DebugLevelSchema.optional(),
+	subsystems: z.array(z.string()).optional()
 });
-
-// src/v1/harness-v1-stream-part.ts
-import { z as z2 } from "zod/v4";
-var harnessV1JsonValueSchema = z2.lazy(
-  () => z2.union([
-    z2.string(),
-    z2.number(),
-    z2.boolean(),
-    z2.null(),
-    z2.array(harnessV1JsonValueSchema),
-    z2.record(z2.string(), harnessV1JsonValueSchema)
-  ])
-);
-var harnessV1ToolResultValueSchema = harnessV1JsonValueSchema;
-var harnessV1JsonObjectSchema = z2.record(
-  z2.string(),
-  harnessV1JsonValueSchema
-);
-var harnessV1MetadataSchema = z2.record(
-  z2.string(),
-  z2.record(z2.string(), harnessV1JsonValueSchema)
-);
-var harnessV1ProviderMetadataSchema = z2.record(
-  z2.string(),
-  z2.record(z2.string(), harnessV1JsonValueSchema)
-);
-var harnessV1CallWarningSchema = z2.union([
-  z2.object({
-    type: z2.literal("unsupported-setting"),
-    setting: z2.string(),
-    details: z2.string().optional()
-  }),
-  z2.object({
-    type: z2.literal("unsupported-tool"),
-    tool: z2.string(),
-    details: z2.string().optional()
-  }),
-  z2.object({ type: z2.literal("other"), message: z2.string() })
+//#endregion
+//#region src/v1/harness-v1-stream-part.ts
+const harnessV1JsonValueSchema = z.lazy(() => z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null(),
+	z.array(harnessV1JsonValueSchema),
+	z.record(z.string(), harnessV1JsonValueSchema)
+]));
+const harnessV1ToolResultValueSchema = harnessV1JsonValueSchema;
+const harnessV1JsonObjectSchema = z.record(z.string(), harnessV1JsonValueSchema);
+const harnessV1MetadataSchema = z.record(z.string(), z.record(z.string(), harnessV1JsonValueSchema));
+const harnessV1ProviderMetadataSchema = z.record(z.string(), z.record(z.string(), harnessV1JsonValueSchema));
+const harnessV1CallWarningSchema = z.union([
+	z.object({
+		type: z.literal("unsupported-setting"),
+		setting: z.string(),
+		details: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("unsupported-tool"),
+		tool: z.string(),
+		details: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("other"),
+		message: z.string()
+	})
 ]);
-var harnessV1UsageSchema = z2.object({
-  inputTokens: z2.object({
-    total: z2.number().optional(),
-    noCache: z2.number().optional(),
-    cacheRead: z2.number().optional(),
-    cacheWrite: z2.number().optional()
-  }),
-  outputTokens: z2.object({
-    total: z2.number().optional(),
-    text: z2.number().optional(),
-    reasoning: z2.number().optional()
-  }),
-  raw: harnessV1JsonObjectSchema.optional()
+const harnessV1UsageSchema = z.object({
+	inputTokens: z.object({
+		total: z.number().optional(),
+		noCache: z.number().optional(),
+		cacheRead: z.number().optional(),
+		cacheWrite: z.number().optional()
+	}),
+	outputTokens: z.object({
+		total: z.number().optional(),
+		text: z.number().optional(),
+		reasoning: z.number().optional()
+	}),
+	raw: harnessV1JsonObjectSchema.optional()
 });
-var harnessV1FinishReasonSchema = z2.object({
-  unified: z2.enum([
-    "stop",
-    "length",
-    "content-filter",
-    "tool-calls",
-    "error",
-    "other"
-  ]),
-  raw: z2.string().optional()
+const harnessV1FinishReasonSchema = z.object({
+	unified: z.enum([
+		"stop",
+		"length",
+		"content-filter",
+		"tool-calls",
+		"error",
+		"other"
+	]),
+	raw: z.string().optional()
 });
-var harnessV1StreamStartPartSchema = z2.object({
-  type: z2.literal("stream-start"),
-  warnings: z2.array(harnessV1CallWarningSchema).readonly().optional(),
-  modelId: z2.string().optional()
+const harnessV1StreamStartPartSchema = z.object({
+	type: z.literal("stream-start"),
+	warnings: z.array(harnessV1CallWarningSchema).readonly().optional(),
+	modelId: z.string().optional()
 });
-var harnessV1TextStartPartSchema = z2.object({
-  type: z2.literal("text-start"),
-  id: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1TextStartPartSchema = z.object({
+	type: z.literal("text-start"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1TextDeltaPartSchema = z2.object({
-  type: z2.literal("text-delta"),
-  id: z2.string(),
-  delta: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1TextDeltaPartSchema = z.object({
+	type: z.literal("text-delta"),
+	id: z.string(),
+	delta: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1TextEndPartSchema = z2.object({
-  type: z2.literal("text-end"),
-  id: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1TextEndPartSchema = z.object({
+	type: z.literal("text-end"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ReasoningStartPartSchema = z2.object({
-  type: z2.literal("reasoning-start"),
-  id: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1ReasoningStartPartSchema = z.object({
+	type: z.literal("reasoning-start"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ReasoningDeltaPartSchema = z2.object({
-  type: z2.literal("reasoning-delta"),
-  id: z2.string(),
-  delta: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1ReasoningDeltaPartSchema = z.object({
+	type: z.literal("reasoning-delta"),
+	id: z.string(),
+	delta: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ReasoningEndPartSchema = z2.object({
-  type: z2.literal("reasoning-end"),
-  id: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1ReasoningEndPartSchema = z.object({
+	type: z.literal("reasoning-end"),
+	id: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ToolInputStartPartSchema = z2.object({
-  type: z2.literal("tool-input-start"),
-  id: z2.string(),
-  toolName: z2.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional(),
-  providerExecuted: z2.boolean().optional(),
-  dynamic: z2.boolean().optional(),
-  title: z2.string().optional()
+const harnessV1ToolInputStartPartSchema = z.object({
+	type: z.literal("tool-input-start"),
+	id: z.string(),
+	toolName: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional(),
+	providerExecuted: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	title: z.string().optional()
 });
-var harnessV1ToolInputDeltaPartSchema = z2.object({
-  type: z2.literal("tool-input-delta"),
-  id: z2.string(),
-  delta: z2.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional()
+const harnessV1ToolInputDeltaPartSchema = z.object({
+	type: z.literal("tool-input-delta"),
+	id: z.string(),
+	delta: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1ToolInputEndPartSchema = z2.object({
-  type: z2.literal("tool-input-end"),
-  id: z2.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional()
+const harnessV1ToolInputEndPartSchema = z.object({
+	type: z.literal("tool-input-end"),
+	id: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1ToolCallPartSchema = z2.object({
-  type: z2.literal("tool-call"),
-  toolCallId: z2.string(),
-  toolName: z2.string(),
-  input: z2.string(),
-  providerExecuted: z2.boolean().optional(),
-  dynamic: z2.boolean().optional(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional(),
-  nativeName: z2.string().optional(),
-  stepToolCallCount: z2.number().int().positive().optional()
+const harnessV1ToolCallPartSchema = z.object({
+	type: z.literal("tool-call"),
+	toolCallId: z.string(),
+	toolName: z.string(),
+	input: z.string(),
+	providerExecuted: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional(),
+	nativeName: z.string().optional(),
+	stepToolCallCount: z.number().int().positive().optional()
 });
-var harnessV1ToolApprovalRequestPartSchema = z2.object({
-  type: z2.literal("tool-approval-request"),
-  approvalId: z2.string(),
-  toolCallId: z2.string(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional()
+const harnessV1ToolApprovalRequestPartSchema = z.object({
+	type: z.literal("tool-approval-request"),
+	approvalId: z.string(),
+	toolCallId: z.string(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1ToolResultPartSchema = z2.object({
-  type: z2.literal("tool-result"),
-  toolCallId: z2.string(),
-  toolName: z2.string(),
-  result: harnessV1ToolResultValueSchema,
-  isError: z2.boolean().optional(),
-  preliminary: z2.boolean().optional(),
-  dynamic: z2.boolean().optional(),
-  providerMetadata: harnessV1ProviderMetadataSchema.optional()
+const harnessV1ToolResultPartSchema = z.object({
+	type: z.literal("tool-result"),
+	toolCallId: z.string(),
+	toolName: z.string(),
+	result: harnessV1ToolResultValueSchema,
+	isError: z.boolean().optional(),
+	preliminary: z.boolean().optional(),
+	dynamic: z.boolean().optional(),
+	providerMetadata: harnessV1ProviderMetadataSchema.optional()
 });
-var harnessV1FinishStepPartSchema = z2.object({
-  type: z2.literal("finish-step"),
-  finishReason: harnessV1FinishReasonSchema,
-  usage: harnessV1UsageSchema,
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1FinishStepPartSchema = z.object({
+	type: z.literal("finish-step"),
+	finishReason: harnessV1FinishReasonSchema,
+	usage: harnessV1UsageSchema,
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1FinishPartSchema = z2.object({
-  type: z2.literal("finish"),
-  finishReason: harnessV1FinishReasonSchema,
-  totalUsage: harnessV1UsageSchema,
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1FinishPartSchema = z.object({
+	type: z.literal("finish"),
+	finishReason: harnessV1FinishReasonSchema,
+	totalUsage: harnessV1UsageSchema,
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1FileChangePartSchema = z2.object({
-  type: z2.literal("file-change"),
-  event: z2.enum(["create", "modify", "delete"]),
-  path: z2.string(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1FileChangePartSchema = z.object({
+	type: z.literal("file-change"),
+	event: z.enum([
+		"create",
+		"modify",
+		"delete"
+	]),
+	path: z.string(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1CompactionPartSchema = z2.object({
-  type: z2.literal("compaction"),
-  trigger: z2.enum(["manual", "auto"]),
-  summary: z2.string(),
-  tokensBefore: z2.number().optional(),
-  tokensAfter: z2.number().optional(),
-  harnessMetadata: harnessV1MetadataSchema.optional()
+const harnessV1CompactionPartSchema = z.object({
+	type: z.literal("compaction"),
+	trigger: z.enum(["manual", "auto"]),
+	summary: z.string(),
+	tokensBefore: z.number().optional(),
+	tokensAfter: z.number().optional(),
+	harnessMetadata: harnessV1MetadataSchema.optional()
 });
-var harnessV1ErrorPartSchema = z2.object({
-  type: z2.literal("error"),
-  error: z2.unknown()
+const harnessV1ErrorPartSchema = z.object({
+	type: z.literal("error"),
+	error: z.unknown()
 });
-var harnessV1RawPartSchema = z2.object({
-  type: z2.literal("raw"),
-  rawValue: z2.unknown()
+const harnessV1RawPartSchema = z.object({
+	type: z.literal("raw"),
+	rawValue: z.unknown()
 });
-var harnessV1StreamPartSchema = z2.discriminatedUnion("type", [
-  harnessV1StreamStartPartSchema,
-  harnessV1TextStartPartSchema,
-  harnessV1TextDeltaPartSchema,
-  harnessV1TextEndPartSchema,
-  harnessV1ReasoningStartPartSchema,
-  harnessV1ReasoningDeltaPartSchema,
-  harnessV1ReasoningEndPartSchema,
-  harnessV1ToolInputStartPartSchema,
-  harnessV1ToolInputDeltaPartSchema,
-  harnessV1ToolInputEndPartSchema,
-  harnessV1ToolCallPartSchema,
-  harnessV1ToolApprovalRequestPartSchema,
-  harnessV1ToolResultPartSchema,
-  harnessV1FinishStepPartSchema,
-  harnessV1FinishPartSchema,
-  harnessV1FileChangePartSchema,
-  harnessV1CompactionPartSchema,
-  harnessV1ErrorPartSchema,
-  harnessV1RawPartSchema
+z.discriminatedUnion("type", [
+	harnessV1StreamStartPartSchema,
+	harnessV1TextStartPartSchema,
+	harnessV1TextDeltaPartSchema,
+	harnessV1TextEndPartSchema,
+	harnessV1ReasoningStartPartSchema,
+	harnessV1ReasoningDeltaPartSchema,
+	harnessV1ReasoningEndPartSchema,
+	harnessV1ToolInputStartPartSchema,
+	harnessV1ToolInputDeltaPartSchema,
+	harnessV1ToolInputEndPartSchema,
+	harnessV1ToolCallPartSchema,
+	harnessV1ToolApprovalRequestPartSchema,
+	harnessV1ToolResultPartSchema,
+	harnessV1FinishStepPartSchema,
+	harnessV1FinishPartSchema,
+	harnessV1FileChangePartSchema,
+	harnessV1CompactionPartSchema,
+	harnessV1ErrorPartSchema,
+	harnessV1RawPartSchema
 ]);
-
-// src/v1/harness-v1-bridge-protocol.ts
-var harnessV1BridgeToolWireSchema = z3.object({
-  name: z3.string(),
-  description: z3.string().optional(),
-  inputSchema: z3.unknown().optional()
+//#endregion
+//#region src/v1/harness-v1-bridge-protocol.ts
+/**
+* The subset of a host-defined tool that travels on the `start` message. The
+* runtime only needs the name, description, and JSON-Schema input to surface
+* the tool; `execute` stays on the host.
+*/
+const harnessV1BridgeToolWireSchema = z.object({
+	name: z.string(),
+	description: z.string().optional(),
+	inputSchema: z.unknown().optional()
 });
-var harnessV1BridgePermissionModeSchema = z3.enum([
-  "allow-reads",
-  "allow-edits",
-  "allow-all"
-]);
-var harnessV1BridgeBuiltinToolFilteringSchema = z3.discriminatedUnion(
-  "mode",
-  [
-    z3.object({
-      mode: z3.literal("allow"),
-      toolNames: z3.array(z3.string())
-    }),
-    z3.object({
-      mode: z3.literal("deny"),
-      toolNames: z3.array(z3.string())
-    })
-  ]
-);
-var harnessV1BridgeResponseFormatSchema = z3.discriminatedUnion("type", [
-  z3.object({ type: z3.literal("text") }),
-  z3.object({
-    type: z3.literal("json"),
-    schema: z3.record(z3.string(), z3.json()).optional(),
-    name: z3.string().optional(),
-    description: z3.string().optional()
-  })
+const harnessV1BridgePermissionModeSchema = z.enum([
+	"allow-reads",
+	"allow-edits",
+	"allow-all"
 ]);
-var harnessV1BridgeStartBaseSchema = z3.object({
-  type: z3.literal("start"),
-  prompt: z3.string(),
-  tools: z3.array(harnessV1BridgeToolWireSchema).optional(),
-  model: z3.string().optional(),
-  debug: harnessV1DebugConfigSchema.optional(),
-  permissionMode: harnessV1BridgePermissionModeSchema.optional(),
-  builtinToolFiltering: harnessV1BridgeBuiltinToolFilteringSchema.optional(),
-  responseFormat: harnessV1BridgeResponseFormatSchema.optional()
-});
-var harnessV1BridgeHelloSchema = z3.object({
-  type: z3.literal("bridge-hello"),
-  state: z3.string().optional(),
-  lastSeq: z3.number().optional(),
-  capabilities: z3.object({
-    experimental_userMessageResponses: z3.boolean().optional()
-  }).optional()
-});
-var experimental_harnessV1BridgeUserMessageResponseSchema = z3.object({
-  type: z3.literal("user-message-response"),
-  messageId: z3.string(),
-  accepted: z3.boolean(),
-  error: z3.object({ message: z3.string() }).optional()
-});
-var harnessV1BridgeStopSchema = z3.object({
-  type: z3.literal("bridge-stop"),
-  data: z3.unknown()
-});
-var harnessV1BridgeThreadSchema = z3.object({
-  type: z3.literal("bridge-thread"),
-  threadId: z3.string()
+const harnessV1BridgeBuiltinToolFilteringSchema = z.discriminatedUnion("mode", [z.object({
+	mode: z.literal("allow"),
+	toolNames: z.array(z.string())
+}), z.object({
+	mode: z.literal("deny"),
+	toolNames: z.array(z.string())
+})]);
+const harnessV1BridgeResponseFormatSchema = z.discriminatedUnion("type", [z.object({ type: z.literal("text") }), z.object({
+	type: z.literal("json"),
+	schema: z.record(z.string(), z.json()).optional(),
+	name: z.string().optional(),
+	description: z.string().optional()
+})]);
+z.object({
+	type: z.literal("start"),
+	prompt: z.string(),
+	tools: z.array(harnessV1BridgeToolWireSchema).optional(),
+	model: z.string().optional(),
+	debug: harnessV1DebugConfigSchema.optional(),
+	permissionMode: harnessV1BridgePermissionModeSchema.optional(),
+	builtinToolFiltering: harnessV1BridgeBuiltinToolFilteringSchema.optional(),
+	responseFormat: harnessV1BridgeResponseFormatSchema.optional()
 });
-var harnessV1BridgeSandboxLogSchema = z3.object({
-  type: z3.literal("sandbox-log"),
-  source: z3.string(),
-  stream: z3.enum(["stdout", "stderr"]),
-  line: z3.string()
+/**
+* Sent the instant the bridge accepts an authenticated WS connection. The host
+* waits for it before sending `start`/`resume`, because some sandbox runtimes
+* complete the upstream WS handshake before the connection is wired through to
+* the bridge process — anything sent in that gap is dropped. Carries the
+* bridge's lifecycle `state` and highest emitted `seq` for reconnect.
+*/
+const harnessV1BridgeHelloSchema = z.object({
+	type: z.literal("bridge-hello"),
+	state: z.string().optional(),
+	lastSeq: z.number().optional(),
+	capabilities: z.object({ experimental_userMessageResponses: z.boolean().optional() }).optional()
 });
-var harnessV1BridgeDebugEventSchema = z3.object({
-  type: z3.literal("debug-event"),
-  level: harnessV1DebugLevelSchema,
-  subsystem: z3.string(),
-  message: z3.string(),
-  attrs: z3.record(z3.string(), z3.unknown()).optional(),
-  error: z3.object({
-    name: z3.string().optional(),
-    message: z3.string(),
-    stack: z3.string().optional()
-  }).optional()
+const experimental_harnessV1BridgeUserMessageResponseSchema = z.object({
+	type: z.literal("user-message-response"),
+	messageId: z.string(),
+	accepted: z.boolean(),
+	error: z.object({ message: z.string() }).optional()
 });
-var harnessV1BridgeOutboundMessageSchema = z3.discriminatedUnion(
-  "type",
-  [
-    harnessV1StreamStartPartSchema,
-    harnessV1TextStartPartSchema,
-    harnessV1TextDeltaPartSchema,
-    harnessV1TextEndPartSchema,
-    harnessV1ReasoningStartPartSchema,
-    harnessV1ReasoningDeltaPartSchema,
-    harnessV1ReasoningEndPartSchema,
-    harnessV1ToolInputStartPartSchema,
-    harnessV1ToolInputDeltaPartSchema,
-    harnessV1ToolInputEndPartSchema,
-    harnessV1ToolCallPartSchema,
-    harnessV1ToolApprovalRequestPartSchema,
-    harnessV1ToolResultPartSchema,
-    harnessV1FinishStepPartSchema,
-    harnessV1FinishPartSchema,
-    harnessV1FileChangePartSchema,
-    harnessV1CompactionPartSchema,
-    harnessV1ErrorPartSchema,
-    harnessV1RawPartSchema,
-    harnessV1BridgeHelloSchema,
-    experimental_harnessV1BridgeUserMessageResponseSchema,
-    harnessV1BridgeStopSchema,
-    harnessV1BridgeThreadSchema,
-    harnessV1BridgeSandboxLogSchema,
-    harnessV1BridgeDebugEventSchema
-  ]
-);
-var harnessV1BridgeToolResultInboundSchema = z3.object({
-  type: z3.literal("tool-result"),
-  toolCallId: z3.string(),
-  output: z3.unknown(),
-  isError: z3.boolean().optional(),
-  toolResult: z3.unknown().optional()
+/**
+* The bridge's reply to an inbound `stop`. Carries the adapter-specific
+* payload the host serializes into lifecycle state `data`.
+*/
+const harnessV1BridgeStopSchema = z.object({
+	type: z.literal("bridge-stop"),
+	data: z.unknown()
 });
-var harnessV1BridgeToolApprovalResponseInboundSchema = z3.object({
-  type: z3.literal("tool-approval-response"),
-  approvalId: z3.string(),
-  approved: z3.boolean(),
-  reason: z3.string().optional()
+/**
+* A resume coordinate the bridge proactively announces (e.g. Codex's thread id)
+* so the host can cache it for a later resume without waiting for `stop`.
+*/
+const harnessV1BridgeThreadSchema = z.object({
+	type: z.literal("bridge-thread"),
+	threadId: z.string()
 });
-var harnessV1BridgeUserMessageInboundSchema = z3.object({
-  type: z3.literal("user-message"),
-  messageId: z3.string().optional(),
-  text: z3.string()
+/**
+* One captured console line from inside the sandbox. The bridge line-buffers
+* `process.stdout`/`process.stderr` and emits one of these per complete line.
+* Routed host-side to the diagnostics sink, never to the consumer stream.
+*/
+const harnessV1BridgeSandboxLogSchema = z.object({
+	type: z.literal("sandbox-log"),
+	source: z.string(),
+	stream: z.enum(["stdout", "stderr"]),
+	line: z.string()
 });
-var experimental_harnessV1BridgeUserMessageInboundSchema = harnessV1BridgeUserMessageInboundSchema.extend({
-  messageId: z3.string()
+/**
+* A structured diagnostic an adapter emits from inside the bridge via
+* `turn.bridgeLog(...)`. Gated by the session's debug level + subsystem filter.
+*/
+const harnessV1BridgeDebugEventSchema = z.object({
+	type: z.literal("debug-event"),
+	level: harnessV1DebugLevelSchema,
+	subsystem: z.string(),
+	message: z.string(),
+	attrs: z.record(z.string(), z.unknown()).optional(),
+	error: z.object({
+		name: z.string().optional(),
+		message: z.string(),
+		stack: z.string().optional()
+	}).optional()
 });
-var harnessV1BridgeAbortInboundSchema = z3.object({
-  type: z3.literal("abort")
-});
-var harnessV1BridgeDestroyInboundSchema = z3.object({
-  type: z3.literal("destroy")
+z.discriminatedUnion("type", [
+	harnessV1StreamStartPartSchema,
+	harnessV1TextStartPartSchema,
+	harnessV1TextDeltaPartSchema,
+	harnessV1TextEndPartSchema,
+	harnessV1ReasoningStartPartSchema,
+	harnessV1ReasoningDeltaPartSchema,
+	harnessV1ReasoningEndPartSchema,
+	harnessV1ToolInputStartPartSchema,
+	harnessV1ToolInputDeltaPartSchema,
+	harnessV1ToolInputEndPartSchema,
+	harnessV1ToolCallPartSchema,
+	harnessV1ToolApprovalRequestPartSchema,
+	harnessV1ToolResultPartSchema,
+	harnessV1FinishStepPartSchema,
+	harnessV1FinishPartSchema,
+	harnessV1FileChangePartSchema,
+	harnessV1CompactionPartSchema,
+	harnessV1ErrorPartSchema,
+	harnessV1RawPartSchema,
+	harnessV1BridgeHelloSchema,
+	experimental_harnessV1BridgeUserMessageResponseSchema,
+	harnessV1BridgeStopSchema,
+	harnessV1BridgeThreadSchema,
+	harnessV1BridgeSandboxLogSchema,
+	harnessV1BridgeDebugEventSchema
+]);
+z.object({
+	type: z.literal("tool-result"),
+	toolCallId: z.string(),
+	output: z.unknown(),
+	isError: z.boolean().optional(),
+	toolResult: z.unknown().optional()
 });
-var harnessV1BridgeResumeInboundSchema = z3.object({
-  type: z3.literal("resume"),
-  lastSeenEventId: z3.number()
+z.object({
+	type: z.literal("tool-approval-response"),
+	approvalId: z.string(),
+	approved: z.boolean(),
+	reason: z.string().optional()
 });
-var harnessV1BridgeStopInboundSchema = z3.object({
-  type: z3.literal("stop")
+z.object({
+	type: z.literal("user-message"),
+	messageId: z.string().optional(),
+	text: z.string()
+}).extend({ messageId: z.string() });
+z.object({ type: z.literal("abort") });
+z.object({ type: z.literal("destroy") });
+z.object({
+	type: z.literal("resume"),
+	lastSeenEventId: z.number()
 });
-var harnessV1BridgeReadySchema = z3.object({
-  type: z3.literal("bridge-ready"),
-  port: z3.number()
+z.object({ type: z.literal("stop") });
+/**
+* The JSON line the bridge writes to stdout once its WebSocket server is bound,
+* announcing the port the host should connect to.
+*/
+const harnessV1BridgeReadySchema = z.object({
+	type: z.literal("bridge-ready"),
+	port: z.number()
 });
-
-// src/utils/bridge-ready.ts
-var bridgeMetaSchema = z4.object({
-  type: z4.string().optional(),
-  port: z4.number().optional(),
-  state: z4.string().optional(),
-  pid: z4.number().optional()
+//#endregion
+//#region src/utils/bridge-ready.ts
+const bridgeMetaSchema = z.object({
+	type: z.string().optional(),
+	port: z.number().optional(),
+	state: z.string().optional(),
+	pid: z.number().optional()
 });
-async function markBridgeStarting({
-  sandbox,
-  bridgeStateDir,
-  bridgeType,
-  abortSignal
-}) {
-  try {
-    await sandbox.writeTextFile({
-      path: bridgeMetaPath(bridgeStateDir),
-      content: JSON.stringify({ type: bridgeType, state: "starting" }),
-      abortSignal
-    });
-  } catch {
-  }
-}
-async function waitForBridgeReady({
-  proc,
-  sandbox,
-  bridgeStateDir,
-  bridgeType,
-  timeoutMs,
-  abortSignal,
-  pollIntervalMs = 100,
-  createTimeoutError,
-  createExitError
-}) {
-  const reader = proc.stdout.pipeThrough(new TextDecoderStream()).getReader();
-  const decoder = lineDecoder();
-  const stdoutTail = [];
-  const deadline = Date.now() + timeoutMs;
-  let pendingStdoutRead;
-  let pendingMetaRead;
-  let nextMetaReadAt = 0;
-  let cancelReader = false;
-  try {
-    while (true) {
-      if (abortSignal?.aborted) {
-        cancelReader = true;
-        await proc.kill();
-        throw abortSignal.reason ?? new DOMException("Aborted", "AbortError");
-      }
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) {
-        cancelReader = true;
-        await proc.kill();
-        throw await makeBridgeReadyError({
-          createError: createTimeoutError,
-          fallbackMessage: "bridge did not become ready in time.",
-          proc,
-          stdoutTail
-        });
-      }
-      pendingStdoutRead ??= reader.read();
-      const metaReadDelayMs = Math.max(0, nextMetaReadAt - Date.now());
-      if (pendingMetaRead === void 0 && metaReadDelayMs === 0) {
-        pendingMetaRead = readBridgeMetaReady({
-          sandbox,
-          bridgeStateDir,
-          bridgeType,
-          abortSignal
-        });
-      }
-      const result = await Promise.race([
-        pendingStdoutRead.then((read) => ({ source: "stdout", read })),
-        ...pendingMetaRead === void 0 ? [] : [
-          pendingMetaRead.then((port) => ({
-            source: "metadata",
-            port
-          }))
-        ],
-        sleep2(
-          Math.min(
-            remaining,
-            pendingMetaRead === void 0 ? metaReadDelayMs : pollIntervalMs
-          )
-        ).then(() => void 0)
-      ]);
-      if (result === void 0) continue;
-      if (result.source === "metadata") {
-        pendingMetaRead = void 0;
-        if (result.port !== void 0) {
-          cancelReader = true;
-          return {
-            port: result.port,
-            source: "metadata",
-            stdoutTail: [...stdoutTail]
-          };
-        }
-        nextMetaReadAt = Date.now() + pollIntervalMs;
-        continue;
-      }
-      pendingStdoutRead = void 0;
-      const { value, done } = result.read;
-      if (done) {
-        for (const line of decoder.flush()) {
-          pushTail({ lines: stdoutTail, line });
-        }
-        throw await makeBridgeReadyError({
-          createError: createExitError,
-          fallbackMessage: "bridge exited before becoming ready.",
-          proc,
-          stdoutTail
-        });
-      }
-      if (value === void 0) continue;
-      for (const line of decoder.push(value)) {
-        pushTail({ lines: stdoutTail, line });
-        const parsed = await safeParseJSON7({
-          text: line,
-          schema: harnessV1BridgeReadySchema
-        });
-        if (parsed.success) {
-          return {
-            port: parsed.value.port,
-            source: "stdout",
-            stdoutTail: [...stdoutTail]
-          };
-        }
-      }
-    }
-  } finally {
-    if (cancelReader) {
-      await Promise.race([reader.cancel().catch(() => {
-      }), sleep2(100)]);
-    }
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
-}
-async function readBridgeMetaReady({
-  sandbox,
-  bridgeStateDir,
-  bridgeType,
-  abortSignal
-}) {
-  const raw = await Promise.resolve(
-    sandbox.readTextFile({
-      path: bridgeMetaPath(bridgeStateDir),
-      abortSignal
-    })
-  ).catch(() => null);
-  if (raw == null) return void 0;
-  const parsed = await safeParseJSON7({ text: raw, schema: bridgeMetaSchema });
-  if (!parsed.success) return void 0;
-  if (parsed.value.type !== bridgeType) return void 0;
-  if (parsed.value.state !== "waiting") return void 0;
-  if (parsed.value.port === void 0 || parsed.value.port <= 0) {
-    return void 0;
-  }
-  return parsed.value.port;
-}
-async function makeBridgeReadyError({
-  createError,
-  fallbackMessage,
-  proc,
-  stdoutTail
-}) {
-  if (createError) {
-    return createError({ proc, stdoutTail: [...stdoutTail] });
-  }
-  return new Error(fallbackMessage);
+async function markBridgeStarting({ sandbox, bridgeStateDir, bridgeType, abortSignal }) {
+	try {
+		await sandbox.writeTextFile({
+			path: bridgeMetaPath(bridgeStateDir),
+			content: JSON.stringify({
+				type: bridgeType,
+				state: "starting"
+			}),
+			abortSignal
+		});
+	} catch {}
+}
+async function waitForBridgeReady({ proc, sandbox, bridgeStateDir, bridgeType, timeoutMs, abortSignal, pollIntervalMs = 100, createTimeoutError, createExitError }) {
+	const reader = proc.stdout.pipeThrough(new TextDecoderStream()).getReader();
+	const decoder = lineDecoder$1();
+	const stdoutTail = [];
+	const deadline = Date.now() + timeoutMs;
+	let pendingStdoutRead;
+	let pendingMetaRead;
+	let nextMetaReadAt = 0;
+	let cancelReader = false;
+	try {
+		while (true) {
+			if (abortSignal?.aborted) {
+				cancelReader = true;
+				await proc.kill();
+				throw abortSignal.reason ?? new DOMException("Aborted", "AbortError");
+			}
+			const remaining = deadline - Date.now();
+			if (remaining <= 0) {
+				cancelReader = true;
+				await proc.kill();
+				throw await makeBridgeReadyError({
+					createError: createTimeoutError,
+					fallbackMessage: "bridge did not become ready in time.",
+					proc,
+					stdoutTail
+				});
+			}
+			pendingStdoutRead ??= reader.read();
+			const metaReadDelayMs = Math.max(0, nextMetaReadAt - Date.now());
+			if (pendingMetaRead === void 0 && metaReadDelayMs === 0) pendingMetaRead = readBridgeMetaReady({
+				sandbox,
+				bridgeStateDir,
+				bridgeType,
+				abortSignal
+			});
+			const result = await Promise.race([
+				pendingStdoutRead.then((read) => ({
+					source: "stdout",
+					read
+				})),
+				...pendingMetaRead === void 0 ? [] : [pendingMetaRead.then((port) => ({
+					source: "metadata",
+					port
+				}))],
+				sleep$2(Math.min(remaining, pendingMetaRead === void 0 ? metaReadDelayMs : pollIntervalMs)).then(() => void 0)
+			]);
+			if (result === void 0) continue;
+			if (result.source === "metadata") {
+				pendingMetaRead = void 0;
+				if (result.port !== void 0) {
+					cancelReader = true;
+					return {
+						port: result.port,
+						source: "metadata",
+						stdoutTail: [...stdoutTail]
+					};
+				}
+				nextMetaReadAt = Date.now() + pollIntervalMs;
+				continue;
+			}
+			pendingStdoutRead = void 0;
+			const { value, done } = result.read;
+			if (done) {
+				for (const line of decoder.flush()) pushTail({
+					lines: stdoutTail,
+					line
+				});
+				throw await makeBridgeReadyError({
+					createError: createExitError,
+					fallbackMessage: "bridge exited before becoming ready.",
+					proc,
+					stdoutTail
+				});
+			}
+			if (value === void 0) continue;
+			for (const line of decoder.push(value)) {
+				pushTail({
+					lines: stdoutTail,
+					line
+				});
+				const parsed = await safeParseJSON({
+					text: line,
+					schema: harnessV1BridgeReadySchema
+				});
+				if (parsed.success) return {
+					port: parsed.value.port,
+					source: "stdout",
+					stdoutTail: [...stdoutTail]
+				};
+			}
+		}
+	} finally {
+		if (cancelReader) await Promise.race([reader.cancel().catch(() => {}), sleep$2(100)]);
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+async function readBridgeMetaReady({ sandbox, bridgeStateDir, bridgeType, abortSignal }) {
+	const raw = await Promise.resolve(sandbox.readTextFile({
+		path: bridgeMetaPath(bridgeStateDir),
+		abortSignal
+	})).catch(() => null);
+	if (raw == null) return void 0;
+	const parsed = await safeParseJSON({
+		text: raw,
+		schema: bridgeMetaSchema
+	});
+	if (!parsed.success) return void 0;
+	if (parsed.value.type !== bridgeType) return void 0;
+	if (parsed.value.state !== "waiting") return void 0;
+	if (parsed.value.port === void 0 || parsed.value.port <= 0) return;
+	return parsed.value.port;
+}
+async function makeBridgeReadyError({ createError, fallbackMessage, proc, stdoutTail }) {
+	if (createError) return createError({
+		proc,
+		stdoutTail: [...stdoutTail]
+	});
+	return new Error(fallbackMessage);
 }
 function bridgeMetaPath(bridgeStateDir) {
-  return `${bridgeStateDir}/bridge-meta.json`;
+	return `${bridgeStateDir}/bridge-meta.json`;
 }
 function pushTail({ lines, line }) {
-  lines.push(line);
-  if (lines.length > 20) lines.shift();
-}
-function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function lineDecoder() {
-  let buffer = "";
-  return {
-    push(chunk) {
-      buffer += chunk;
-      const lines = [];
-      let nl;
-      while ((nl = buffer.indexOf("\n")) !== -1) {
-        const raw = buffer.slice(0, nl);
-        buffer = buffer.slice(nl + 1);
-        const line = raw.replace(/\r$/, "").trim();
-        if (line.length > 0) lines.push(line);
-      }
-      return lines;
-    },
-    flush() {
-      const line = buffer.replace(/\r$/, "").trim();
-      buffer = "";
-      return line.length > 0 ? [line] : [];
-    }
-  };
-}
-
-// src/utils/bridge-token.ts
-import { randomBytes as randomBytes2 } from "crypto";
+	lines.push(line);
+	if (lines.length > 20) lines.shift();
+}
+function sleep$2(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function lineDecoder$1() {
+	let buffer = "";
+	return {
+		push(chunk) {
+			buffer += chunk;
+			const lines = [];
+			let nl;
+			while ((nl = buffer.indexOf("\n")) !== -1) {
+				const raw = buffer.slice(0, nl);
+				buffer = buffer.slice(nl + 1);
+				const line = raw.replace(/\r$/, "").trim();
+				if (line.length > 0) lines.push(line);
+			}
+			return lines;
+		},
+		flush() {
+			const line = buffer.replace(/\r$/, "").trim();
+			buffer = "";
+			return line.length > 0 ? [line] : [];
+		}
+	};
+}
+//#endregion
+//#region src/utils/bridge-token.ts
 function createBridgeToken() {
-  return randomBytes2(32).toString("hex");
-}
-function withBridgeToken({
-  endpoint,
-  token
-}) {
-  const bridgeUrl = new URL(endpoint.url);
-  bridgeUrl.searchParams.set("agent_bridge_token", token);
-  return { ...endpoint, url: bridgeUrl.toString() };
-}
-
-// src/utils/bridge-asset.ts
-import { readFile } from "fs/promises";
+	return randomBytes(32).toString("hex");
+}
+function withBridgeToken({ endpoint, token }) {
+	const bridgeUrl = new URL(endpoint.url);
+	bridgeUrl.searchParams.set("agent_bridge_token", token);
+	return {
+		...endpoint,
+		url: bridgeUrl.toString()
+	};
+}
+//#endregion
+//#region src/utils/bridge-asset.ts
 function createReadBridgeAsset(assetUrls) {
-  return async (name) => readFile(assetUrls[name], "utf8");
+	return async (name) => readFile(assetUrls[name], "utf8");
 }
-
-// src/utils/bridge-diagnostics.ts
-var DEFAULT_TAIL_LIMIT = 20;
+//#endregion
+//#region src/utils/bridge-diagnostics.ts
+const DEFAULT_TAIL_LIMIT = 20;
 function isSerializedError(error) {
-  return typeof error === "object" && error != null && typeof error.message === "string";
+	return typeof error === "object" && error != null && typeof error.message === "string";
 }
 function stringifyUnknown(value) {
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
 }
 function formatBridgeError(error) {
-  if (error instanceof Error) {
-    return error.stack ?? `${error.name}: ${error.message}`;
-  }
-  if (isSerializedError(error)) {
-    return error.stack ?? `${error.name ? `${error.name}: ` : ""}${error.message}`;
-  }
-  return stringifyUnknown(error);
+	if (error instanceof Error) return error.stack ?? `${error.name}: ${error.message}`;
+	if (isSerializedError(error)) return error.stack ?? `${error.name ? `${error.name}: ` : ""}${error.message}`;
+	return stringifyUnknown(error);
 }
 function writeToStderr(line) {
-  try {
-    process.stderr.write(line);
-  } catch {
-  }
-}
-function logBridgeError({
-  harnessId,
-  sessionId,
-  context,
-  error,
-  write = writeToStderr
-}) {
-  const prefix = `[harness:${harnessId}:error${sessionId ? ` session=${sessionId}` : ""}]`;
-  const message = context ? `${context}: ${formatBridgeError(error)}` : formatBridgeError(error);
-  for (const line of message.split("\n")) {
-    if (line.trim().length > 0) {
-      write(`${prefix} ${line}
-`);
-    }
-  }
-}
-function createBridgeErrorHandler({
-  harnessId,
-  sessionId
-}) {
-  return (event) => {
-    logBridgeError({
-      harnessId,
-      sessionId,
-      context: "bridge emitted an error frame",
-      error: event.error
-    });
-  };
-}
-async function createBridgeStartupError({
-  message,
-  proc,
-  stdoutTail,
-  stderrTail,
-  stderrDone
-}) {
-  if (stderrDone) {
-    await Promise.race([stderrDone, sleep3(250)]).catch(() => {
-    });
-  }
-  let exitStatus = "";
-  try {
-    const result = await Promise.race([
-      proc.wait(),
-      sleep3(250).then(() => void 0)
-    ]);
-    if (result?.exitCode !== void 0) {
-      exitStatus = ` Exit code: ${result.exitCode}.`;
-    }
-  } catch {
-  }
-  const details = [];
-  if (stdoutTail.length > 0) {
-    details.push(`stdout:
-${stdoutTail.join("\n")}`);
-  }
-  if (stderrTail.length > 0) {
-    details.push(`stderr:
-${stderrTail.join("\n")}`);
-  }
-  return new Error(
-    `${message}${exitStatus}${details.length > 0 ? `
-
-${details.join("\n\n")}` : ""}`
-  );
-}
-async function forwardBridgeProcessStream({
-  stream,
-  streamName,
-  source = "bridge",
-  collectTail,
-  tailLimit = DEFAULT_TAIL_LIMIT
-}) {
-  try {
-    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-    const decoder = lineDecoder2();
-    while (true) {
-      const { value, done } = await reader.read();
-      const lines = done ? decoder.flush() : value ? decoder.push(value) : [];
-      for (const line of lines) {
-        recordTail({ lines: collectTail, line, limit: tailLimit });
-        writeToStderr(`[harness:${source}:${streamName}] ${line}
-`);
-      }
-      if (done) return;
-    }
-  } catch {
-  }
+	try {
+		process.stderr.write(line);
+	} catch {}
+}
+function logBridgeError({ harnessId, sessionId, context, error, write = writeToStderr }) {
+	const prefix = `[harness:${harnessId}:error${sessionId ? ` session=${sessionId}` : ""}]`;
+	const message = context ? `${context}: ${formatBridgeError(error)}` : formatBridgeError(error);
+	for (const line of message.split("\n")) if (line.trim().length > 0) write(`${prefix} ${line}\n`);
+}
+function createBridgeErrorHandler({ harnessId, sessionId }) {
+	return (event) => {
+		logBridgeError({
+			harnessId,
+			sessionId,
+			context: "bridge emitted an error frame",
+			error: event.error
+		});
+	};
+}
+async function createBridgeStartupError({ message, proc, stdoutTail, stderrTail, stderrDone }) {
+	if (stderrDone) await Promise.race([stderrDone, sleep$1(250)]).catch(() => {});
+	let exitStatus = "";
+	try {
+		const result = await Promise.race([proc.wait(), sleep$1(250).then(() => void 0)]);
+		if (result?.exitCode !== void 0) exitStatus = ` Exit code: ${result.exitCode}.`;
+	} catch {}
+	const details = [];
+	if (stdoutTail.length > 0) details.push(`stdout:\n${stdoutTail.join("\n")}`);
+	if (stderrTail.length > 0) details.push(`stderr:\n${stderrTail.join("\n")}`);
+	return /* @__PURE__ */ new Error(`${message}${exitStatus}${details.length > 0 ? `\n\n${details.join("\n\n")}` : ""}`);
+}
+async function forwardBridgeProcessStream({ stream, streamName, source = "bridge", collectTail, tailLimit = DEFAULT_TAIL_LIMIT }) {
+	try {
+		const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+		const decoder = lineDecoder();
+		while (true) {
+			const { value, done } = await reader.read();
+			const lines = done ? decoder.flush() : value ? decoder.push(value) : [];
+			for (const line of lines) {
+				recordTail({
+					lines: collectTail,
+					line,
+					limit: tailLimit
+				});
+				writeToStderr(`[harness:${source}:${streamName}] ${line}\n`);
+			}
+			if (done) return;
+		}
+	} catch {}
 }
 async function drainBridgeProcessStream(stream) {
-  try {
-    const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
-    while (true) {
-      const { done } = await reader.read();
-      if (done) return;
-    }
-  } catch {
-  }
+	try {
+		const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+		while (true) {
+			const { done } = await reader.read();
+			if (done) return;
+		}
+	} catch {}
+}
+function recordTail({ lines, line, limit }) {
+	if (!lines) return;
+	lines.push(line);
+	while (lines.length > limit) lines.shift();
 }
-function recordTail({
-  lines,
-  line,
-  limit
-}) {
-  if (!lines) return;
-  lines.push(line);
-  while (lines.length > limit) lines.shift();
-}
-function lineDecoder2() {
-  let buffer = "";
-  return {
-    push(chunk) {
-      buffer += chunk;
-      const lines = [];
-      let nl;
-      while ((nl = buffer.indexOf("\n")) !== -1) {
-        const raw = buffer.slice(0, nl);
-        buffer = buffer.slice(nl + 1);
-        const line = raw.replace(/\r$/, "").trim();
-        if (line.length > 0) lines.push(line);
-      }
-      return lines;
-    },
-    flush() {
-      const line = buffer.replace(/\r$/, "").trim();
-      buffer = "";
-      return line.length > 0 ? [line] : [];
-    }
-  };
-}
-function sleep3(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/utils/resolve-sandbox-default-working-directory.ts
-import { posix } from "path";
-async function resolveSandboxDefaultWorkingDirectory({
-  sandboxSession,
-  abortSignal
-}) {
-  if ("defaultWorkingDirectory" in sandboxSession) {
-    return sandboxSession.defaultWorkingDirectory;
-  }
-  const result = await sandboxSession.run({
-    command: "pwd",
-    abortSignal
-  });
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Failed to resolve sandbox default working directory (exit ${result.exitCode}): ${result.stderr || result.stdout}`
-    );
-  }
-  const cwd = result.stdout.trim();
-  if (!posix.isAbsolute(cwd)) {
-    throw new Error(
-      `Failed to resolve sandbox default working directory: expected an absolute path, got ${JSON.stringify(cwd)}.`
-    );
-  }
-  return cwd === "/" ? cwd : cwd.replace(/\/+$/, "");
+function lineDecoder() {
+	let buffer = "";
+	return {
+		push(chunk) {
+			buffer += chunk;
+			const lines = [];
+			let nl;
+			while ((nl = buffer.indexOf("\n")) !== -1) {
+				const raw = buffer.slice(0, nl);
+				buffer = buffer.slice(nl + 1);
+				const line = raw.replace(/\r$/, "").trim();
+				if (line.length > 0) lines.push(line);
+			}
+			return lines;
+		},
+		flush() {
+			const line = buffer.replace(/\r$/, "").trim();
+			buffer = "";
+			return line.length > 0 ? [line] : [];
+		}
+	};
+}
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//#endregion
+//#region src/utils/resolve-sandbox-default-working-directory.ts
+async function resolveSandboxDefaultWorkingDirectory({ sandboxSession, abortSignal }) {
+	if ("defaultWorkingDirectory" in sandboxSession) return sandboxSession.defaultWorkingDirectory;
+	const result = await sandboxSession.run({
+		command: "pwd",
+		abortSignal
+	});
+	if (result.exitCode !== 0) throw new Error(`Failed to resolve sandbox default working directory (exit ${result.exitCode}): ${result.stderr || result.stdout}`);
+	const cwd = result.stdout.trim();
+	if (!posix.isAbsolute(cwd)) throw new Error(`Failed to resolve sandbox default working directory: expected an absolute path, got ${JSON.stringify(cwd)}.`);
+	return cwd === "/" ? cwd : cwd.replace(/\/+$/, "");
+}
+//#endregion
+//#region src/utils/get-restricted-sandbox-session.ts
+function getRestrictedSandboxSession(sandboxSession) {
+	return "restricted" in sandboxSession ? sandboxSession.restricted() : sandboxSession;
 }
+//#endregion
+export { SandboxChannel, applyCredentialForwarding, classifyDiskLog, createBridgeErrorHandler, createBridgeStartupError, createBridgeToken, createCredentialRequestTransformation, createReadBridgeAsset, drainBridgeProcessStream, experimental_createBridgeUserMessageSubmitter, formatBridgeError, forwardBridgeProcessStream, generateSandboxCredentialPlaceholder, getAiGatewayAuthFromEnv, getJwtExpiresAt, getRestrictedSandboxSession, isAccessTokenExpiringSoon, isHarnessAuthenticationEnvironment, isLinux, isMacOS, isSandboxCredentialPlaceholder, isWindows, logBridgeError, markBridgeStarting, maskSandboxCredentials, parseJwtPayload, readLinuxSecretServicePassword, readMacOSKeychainPassword, readWindowsCredentialManagerPassword, refreshOAuthAccessToken, resolveSandboxCredentialEnvironment, resolveSandboxDefaultWorkingDirectory, resolveSandboxHomeDir, shellQuote, shouldResolveNativeSubscription, sleep, waitForBridgeReady, warnCredentialBrokeringUnavailable, withBridgeToken, writeInstructions, writeSkills };
 
-// src/utils/get-restricted-sandbox-session.ts
-function getRestrictedSandboxSession(sandboxSession) {
-  return "restricted" in sandboxSession ? sandboxSession.restricted() : sandboxSession;
-}
-export {
-  SandboxChannel,
-  applyCredentialForwarding,
-  classifyDiskLog,
-  createBridgeErrorHandler,
-  createBridgeStartupError,
-  createBridgeToken,
-  createCredentialRequestTransformation,
-  createReadBridgeAsset,
-  createSandboxCredentialEnvironment,
-  drainBridgeProcessStream,
-  experimental_createBridgeUserMessageSubmitter,
-  formatBridgeError,
-  forwardBridgeProcessStream,
-  generateSandboxCredentialPlaceholder,
-  getAiGatewayAuthFromEnv,
-  getJwtExpiresAt,
-  getRestrictedSandboxSession,
-  isAccessTokenExpiringSoon,
-  isHarnessAuthenticationEnvironment,
-  isLinux,
-  isMacOS,
-  isSandboxCredentialPlaceholder,
-  isWindows,
-  logBridgeError,
-  markBridgeStarting,
-  maskSandboxCredentials,
-  parseJwtPayload,
-  readLinuxSecretServicePassword,
-  readMacOSKeychainPassword,
-  readWindowsCredentialManagerPassword,
-  refreshOAuthAccessToken,
-  resolveSandboxDefaultWorkingDirectory,
-  resolveSandboxHomeDir,
-  shellQuote,
-  shouldResolveNativeSubscription,
-  sleep,
-  waitForBridgeReady,
-  warnCredentialBrokeringUnavailable,
-  withBridgeToken,
-  writeInstructions,
-  writeSkills
-};
 //# sourceMappingURL=index.js.map