@ai-sdk/harness-claude-code 1.0.137 → 1.0.138

package/dist/bridge/index.mjs

@@ -1,1910 +1,1737 @@
-// ../harness/dist/bridge/index.js
-import { appendFile, mkdir, writeFile } from "fs/promises";
-import { existsSync, readFileSync } from "fs";
-import { randomUUID } from "crypto";
-import { env as procEnv, pid, stdout } from "process";
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { existsSync, readFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { argv, env, pid, stdout } from "node:process";
 import { WebSocketServer } from "ws";
-var DEBUG_LEVEL_WEIGHT = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  debug: 3,
-  trace: 4
+import * as claudeAgentSdk from "@anthropic-ai/claude-agent-sdk";
+import * as mcpServerModule from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod/v4";
+//#region ../harness/dist/bridge/index.js
+const DEBUG_LEVEL_WEIGHT = {
+	error: 0,
+	warn: 1,
+	info: 2,
+	debug: 3,
+	trace: 4
 };
+/** Exact-or-dotted-prefix subsystem match (`'bridge'` matches `'bridge.turn'`). */
 function subsystemMatches(filters, subsystem) {
-  if (!filters || filters.length === 0) return true;
-  return filters.some(
-    (filter) => subsystem === filter || subsystem.startsWith(`${filter}.`)
-  );
+	if (!filters || filters.length === 0) return true;
+	return filters.some((filter) => subsystem === filter || subsystem.startsWith(`${filter}.`));
 }
 function formatBridgeError(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  if (typeof err === "string") {
-    return { message: err };
-  }
-  if (err !== null && typeof err === "object") {
-    try {
-      return { message: JSON.stringify(err) };
-    } catch {
-    }
-  }
-  return { message: String(err) };
+	if (err instanceof Error) return {
+		name: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+	if (typeof err === "string") return { message: err };
+	if (err !== null && typeof err === "object") try {
+		return { message: JSON.stringify(err) };
+	} catch {}
+	return { message: String(err) };
 }
 function createBridgeUserMessageQueue(options) {
-  const messages = [];
-  const waiters = [];
-  const entries = /* @__PURE__ */ new Map();
-  let closed = false;
-  let pendingCount = 0;
-  const enqueue = (input) => {
-    const existing = entries.get(input.messageId);
-    if (existing != null) {
-      if (existing.response != null) {
-        options.respond(existing.response);
-      }
-      return;
-    }
-    let settled = false;
-    const settle = (response) => {
-      if (settled) return;
-      settled = true;
-      pendingCount--;
-      const entry = entries.get(input.messageId);
-      if (entry != null) entry.response = response;
-      options.respond(response);
-    };
-    const message = {
-      messageId: input.messageId,
-      text: input.text,
-      accept: () => {
-        settle({
-          type: "user-message-response",
-          messageId: input.messageId,
-          accepted: true
-        });
-      },
-      reject: (error) => {
-        settle({
-          type: "user-message-response",
-          messageId: input.messageId,
-          accepted: false,
-          error: { message: formatBridgeError(error).message }
-        });
-      }
-    };
-    entries.set(input.messageId, {
-      reject: message.reject
-    });
-    pendingCount++;
-    if (closed) {
-      message.reject(
-        new Error("The bridge turn is no longer accepting user messages.")
-      );
-      return;
-    }
-    const waiter = waiters.shift();
-    if (waiter != null) {
-      waiter({ done: false, value: message });
-    } else {
-      messages.push(message);
-    }
-  };
-  const close = (error) => {
-    if (closed) return;
-    closed = true;
-    const reason = error ?? new Error("The bridge turn ended before accepting the user message.");
-    for (const entry of entries.values()) {
-      if (entry.response == null) entry.reject(reason);
-    }
-    messages.length = 0;
-    while (waiters.length > 0) {
-      waiters.shift()({ done: true, value: void 0 });
-    }
-  };
-  return {
-    get pendingCount() {
-      return pendingCount;
-    },
-    enqueue,
-    close,
-    [Symbol.asyncIterator]() {
-      return {
-        next: () => {
-          const message = messages.shift();
-          if (message != null) {
-            return Promise.resolve({ done: false, value: message });
-          }
-          if (closed) {
-            return Promise.resolve({
-              done: true,
-              value: void 0
-            });
-          }
-          return new Promise(
-            (resolve) => {
-              waiters.push(resolve);
-            }
-          );
-        }
-      };
-    }
-  };
+	const messages = [];
+	const waiters = [];
+	const entries = /* @__PURE__ */ new Map();
+	let closed = false;
+	let pendingCount = 0;
+	const enqueue = (input) => {
+		const existing = entries.get(input.messageId);
+		if (existing != null) {
+			if (existing.response != null) options.respond(existing.response);
+			return;
+		}
+		let settled = false;
+		const settle = (response) => {
+			if (settled) return;
+			settled = true;
+			pendingCount--;
+			const entry = entries.get(input.messageId);
+			if (entry != null) entry.response = response;
+			options.respond(response);
+		};
+		const message = {
+			messageId: input.messageId,
+			text: input.text,
+			accept: () => {
+				settle({
+					type: "user-message-response",
+					messageId: input.messageId,
+					accepted: true
+				});
+			},
+			reject: (error) => {
+				settle({
+					type: "user-message-response",
+					messageId: input.messageId,
+					accepted: false,
+					error: { message: formatBridgeError(error).message }
+				});
+			}
+		};
+		entries.set(input.messageId, { reject: message.reject });
+		pendingCount++;
+		if (closed) {
+			message.reject(/* @__PURE__ */ new Error("The bridge turn is no longer accepting user messages."));
+			return;
+		}
+		const waiter = waiters.shift();
+		if (waiter != null) waiter({
+			done: false,
+			value: message
+		});
+		else messages.push(message);
+	};
+	const close = (error) => {
+		if (closed) return;
+		closed = true;
+		const reason = error ?? /* @__PURE__ */ new Error("The bridge turn ended before accepting the user message.");
+		for (const entry of entries.values()) if (entry.response == null) entry.reject(reason);
+		messages.length = 0;
+		while (waiters.length > 0) waiters.shift()({
+			done: true,
+			value: void 0
+		});
+	};
+	return {
+		get pendingCount() {
+			return pendingCount;
+		},
+		enqueue,
+		close,
+		[Symbol.asyncIterator]() {
+			return { next: () => {
+				const message = messages.shift();
+				if (message != null) return Promise.resolve({
+					done: false,
+					value: message
+				});
+				if (closed) return Promise.resolve({
+					done: true,
+					value: void 0
+				});
+				return new Promise((resolve) => {
+					waiters.push(resolve);
+				});
+			} };
+		}
+	};
 }
 function parseEnvList(value) {
-  if (!value) return void 0;
-  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
-  return items.length > 0 ? items : void 0;
+	if (!value) return void 0;
+	const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+	return items.length > 0 ? items : void 0;
 }
-var ENV_TRUTHY = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var WS_OPEN = 1;
+const ENV_TRUTHY = /* @__PURE__ */ new Set([
+	"1",
+	"true",
+	"yes",
+	"on"
+]);
+const WS_OPEN = 1;
 async function runBridge(options) {
-  const { bridgeType, bridgeStateDir: bridgeStateDir2, onStart, onStop, onDestroy } = options;
-  const teardownGraceMs = options.turnTeardownGraceMs ?? 1e4;
-  const expectedToken = options.token ?? procEnv.BRIDGE_CHANNEL_TOKEN ?? "";
-  const bridgeWsPort = options.port ?? parseInt(procEnv.BRIDGE_WS_PORT ?? "0", 10);
-  const bridgeMetaPath = `${bridgeStateDir2}/bridge-meta.json`;
-  const startConfigPath = `${bridgeStateDir2}/start-config.json`;
-  const rerunStartConfigPath = `${bridgeStateDir2}/rerun-start-config.json`;
-  const eventLogPath = `${bridgeStateDir2}/event-log.ndjson`;
-  try {
-    await mkdir(bridgeStateDir2, { recursive: true });
-  } catch {
-  }
-  let currentBoundPort = 0;
-  let currentTurnState = "init";
-  let activeSocket;
-  let isFirstTurn = true;
-  let turnAbort;
-  let currentUserMessages;
-  let activeTurn;
-  let debugConfig;
-  let consoleCaptureInstalled = false;
-  const envDebugEnabled = ENV_TRUTHY.has(
-    (procEnv.HARNESS_DEBUG ?? "").toLowerCase()
-  );
-  let seqCounter = 0;
-  let eventLog = [];
-  let diskBuffer = "";
-  let flushPromise = null;
-  const flushEventsToDisk = async () => {
-    while (diskBuffer.length > 0) {
-      const buf = diskBuffer;
-      diskBuffer = "";
-      await appendFile(eventLogPath, buf).catch(() => {
-      });
-    }
-  };
-  const scheduleEventFlush = () => {
-    if (flushPromise) return;
-    flushPromise = new Promise((resolve) => {
-      setImmediate(() => {
-        void flushEventsToDisk().finally(resolve);
-      });
-    }).finally(() => {
-      flushPromise = null;
-      if (diskBuffer.length > 0) {
-        scheduleEventFlush();
-      }
-    });
-  };
-  const flushPendingEventsToDisk = async () => {
-    if (diskBuffer.length > 0 && !flushPromise) {
-      scheduleEventFlush();
-    }
-    let inFlight = flushPromise;
-    while (inFlight) {
-      await inFlight;
-      inFlight = flushPromise;
-    }
-  };
-  const replayFromDisk = procEnv.BRIDGE_REPLAY_FROM_DISK === "1";
-  if (replayFromDisk && existsSync(eventLogPath)) {
-    try {
-      const lines = readFileSync(eventLogPath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean);
-      eventLog = lines.map((line) => ({
-        seq: JSON.parse(line).seq,
-        line
-      }));
-      seqCounter = eventLog.at(-1)?.seq ?? 0;
-    } catch {
-      eventLog = [];
-      seqCounter = 0;
-    }
-  }
-  const pendingToolResults = /* @__PURE__ */ new Map();
-  const bufferedToolResults = [];
-  const pendingToolApprovals = /* @__PURE__ */ new Map();
-  const writeBridgeMeta = async (state) => {
-    try {
-      await writeFile(
-        bridgeMetaPath,
-        JSON.stringify({
-          type: bridgeType,
-          port: currentBoundPort,
-          state,
-          pid
-        })
-      );
-    } catch {
-    }
-  };
-  const writeStartConfig = async (start) => {
-    try {
-      const serialized = JSON.stringify(start);
-      await writeFile(startConfigPath, serialized);
-      if (!existsSync(rerunStartConfigPath)) {
-        await writeFile(rerunStartConfigPath, serialized);
-      }
-    } catch {
-    }
-  };
-  const emit = (event) => {
-    const seq = ++seqCounter;
-    const line = JSON.stringify({ ...event, seq });
-    eventLog.push({ seq, line });
-    diskBuffer += `${line}
-`;
-    scheduleEventFlush();
-    if (activeSocket?.readyState === WS_OPEN) {
-      try {
-        activeSocket.send(line);
-      } catch {
-      }
-    }
-  };
-  const replay = (ws, afterSeq) => {
-    for (const entry of eventLog) {
-      if (entry.seq > afterSeq && ws.readyState === WS_OPEN) {
-        ws.send(entry.line);
-      }
-    }
-  };
-  const shouldEmitDebugEvent = (level, subsystem) => {
-    if (!debugConfig?.enabled) return false;
-    const threshold = debugConfig.level ?? "debug";
-    if (DEBUG_LEVEL_WEIGHT[level] > DEBUG_LEVEL_WEIGHT[threshold]) return false;
-    return subsystemMatches(debugConfig.subsystems, subsystem);
-  };
-  const rawStdoutWrite = process.stdout.write.bind(process.stdout);
-  const rawStderrWrite = process.stderr.write.bind(process.stderr);
-  const writeErrorToStderr = (input) => {
-    try {
-      const formatted = formatBridgeError(input.error);
-      rawStderrWrite(
-        `[harness:${bridgeType}:error] ${input.message}: ${formatted.message}
-`
-      );
-      if (formatted.stack) {
-        rawStderrWrite(`${formatted.stack}
-`);
-      }
-    } catch {
-    }
-  };
-  const emitWarning = (input) => {
-    try {
-      for (const line of input.message.split("\n")) {
-        if (line.trim().length > 0) {
-          rawStderrWrite(`[harness:${bridgeType}:warn] ${line}
-`);
-        }
-      }
-    } catch {
-    }
-  };
-  const emitError = (input) => {
-    writeErrorToStderr({
-      message: input.message ?? "bridge error",
-      error: input.error
-    });
-    emit({ type: "error", error: serialiseError(input.error) });
-  };
-  const installConsoleCapture = () => {
-    if (consoleCaptureInstalled) return;
-    consoleCaptureInstalled = true;
-    const buffers = {
-      stdout: "",
-      stderr: ""
-    };
-    const patch = (stream, raw) => (chunk, encoding, cb) => {
-      if (debugConfig?.enabled) {
-        try {
-          const enc = typeof encoding === "string" ? encoding : "utf8";
-          const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(
-            enc
-          );
-          const combined = buffers[stream] + text.replace(/\r\n/g, "\n");
-          const parts = combined.split("\n");
-          buffers[stream] = parts.pop() ?? "";
-          for (const line of parts) {
-            const trimmed = line.replace(/\s+$/, "");
-            if (trimmed) {
-              emit({
-                type: "sandbox-log",
-                source: bridgeType,
-                stream,
-                line: trimmed
-              });
-            }
-          }
-        } catch {
-        }
-      }
-      return raw(
-        chunk,
-        encoding,
-        cb
-      );
-    };
-    process.stdout.write = patch(
-      "stdout",
-      rawStdoutWrite
-    );
-    process.stderr.write = patch(
-      "stderr",
-      rawStderrWrite
-    );
-  };
-  const handleInbound = async (msg, ws) => {
-    switch (msg.type) {
-      case "start": {
-        for (; ; ) {
-          const pendingTurn = activeTurn;
-          if (pendingTurn == null) break;
-          turnAbort?.abort();
-          currentUserMessages?.close(
-            new Error("A new bridge turn replaced the active turn.")
-          );
-          let graceTimer;
-          const settled = await Promise.race([
-            pendingTurn.then(() => true),
-            new Promise((resolve) => {
-              graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
-              graceTimer.unref?.();
-            })
-          ]);
-          clearTimeout(graceTimer);
-          if (!settled) break;
-        }
-        let turnFinished;
-        const thisTurn = new Promise((resolve) => turnFinished = resolve);
-        activeTurn = thisTurn;
-        activeSocket = ws;
-        const firstTurn = isFirstTurn;
-        isFirstTurn = false;
-        eventLog = [];
-        diskBuffer = "";
-        void writeFile(eventLogPath, "").catch(() => {
-        });
-        turnAbort = new AbortController();
-        currentTurnState = "running";
-        void writeStartConfig(msg);
-        void writeBridgeMeta("running");
-        const startDebug = msg.debug;
-        debugConfig = {
-          enabled: startDebug?.enabled ?? envDebugEnabled,
-          level: startDebug?.level ?? procEnv.HARNESS_DEBUG_LEVEL,
-          subsystems: startDebug?.subsystems ?? parseEnvList(procEnv.HARNESS_DEBUG_SUBSYSTEMS)
-        };
-        if (debugConfig.enabled) {
-          installConsoleCapture();
-        }
-        const userMessages = createBridgeUserMessageQueue({ respond: emit });
-        const turn = {
-          emit,
-          requestToolResult: (requestInput) => {
-            const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
-            const bufferedIndex = bufferedToolResults.findIndex(
-              (buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true
-            );
-            if (bufferedIndex >= 0) {
-              return Promise.resolve(
-                bufferedToolResults.splice(bufferedIndex, 1)[0].result
-              );
-            }
-            return new Promise((resolve) => {
-              pendingToolResults.set(request.toolCallId, {
-                resolve,
-                matches: request.matches
-              });
-            });
-          },
-          requestToolApproval: (approvalId) => new Promise((resolve) => {
-            pendingToolApprovals.set(approvalId, resolve);
-          }),
-          experimental_userMessages: userMessages,
-          abortSignal: turnAbort.signal,
-          firstTurn,
-          bridgeLog: (input) => {
-            const level = input.level ?? "debug";
-            if (!shouldEmitDebugEvent(level, input.subsystem)) return;
-            emit({
-              type: "debug-event",
-              level,
-              subsystem: input.subsystem,
-              message: input.message,
-              ...input.attrs ? { attrs: input.attrs } : {},
-              ...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
-            });
-          },
-          emitWarning,
-          emitError
-        };
-        currentUserMessages = userMessages;
-        try {
-          await onStart(msg, turn);
-        } catch (err) {
-          emitError({ error: err, message: "bridge turn failed" });
-        } finally {
-          userMessages.close();
-          if (currentUserMessages === userMessages) {
-            currentUserMessages = void 0;
-          }
-          if (activeTurn === thisTurn) {
-            activeTurn = void 0;
-            currentTurnState = "waiting";
-            void writeBridgeMeta("waiting");
-          }
-          turnFinished();
-        }
-        return;
-      }
-      case "tool-result": {
-        const result = {
-          output: msg.output,
-          isError: msg.isError,
-          toolResult: msg.toolResult
-        };
-        const exactPending = pendingToolResults.get(msg.toolCallId);
-        const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(
-          ([, pending2]) => pending2.matches?.(result) === true
-        ) : void 0;
-        const pending = exactPending ?? matchingPending?.[1];
-        const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
-        if (pending != null && pendingId != null) {
-          pendingToolResults.delete(pendingId);
-          pending.resolve(result);
-        } else {
-          bufferedToolResults.push({
-            toolCallId: msg.toolCallId,
-            result
-          });
-        }
-        return;
-      }
-      case "tool-approval-response": {
-        const resolver = pendingToolApprovals.get(msg.approvalId);
-        if (resolver) {
-          pendingToolApprovals.delete(msg.approvalId);
-          resolver({ approved: msg.approved, reason: msg.reason });
-        }
-        return;
-      }
-      case "user-message": {
-        const messageId = msg.messageId ?? randomUUID();
-        if (currentUserMessages == null) {
-          sendControl(ws, {
-            type: "user-message-response",
-            messageId,
-            accepted: false,
-            error: { message: "The bridge has no active turn to steer." }
-          });
-          return;
-        }
-        if (ws !== activeSocket) {
-          sendControl(ws, {
-            type: "user-message-response",
-            messageId,
-            accepted: false,
-            error: {
-              message: "The connection does not own the active bridge turn."
-            }
-          });
-          return;
-        }
-        currentUserMessages.enqueue({
-          messageId,
-          text: msg.text
-        });
-        return;
-      }
-      case "abort":
-        turnAbort?.abort();
-        return;
-      case "resume":
-        activeSocket = ws;
-        replay(ws, msg.lastSeenEventId);
-        return;
-      case "destroy":
-        currentTurnState = "done";
-        void writeBridgeMeta("done");
-        await onDestroy?.();
-        drainThenExit(ws, 1e3, "destroy");
-        return;
-      case "stop": {
-        currentTurnState = "done";
-        void writeBridgeMeta("done");
-        const data = await onStop?.() ?? {};
-        sendControl(ws, { type: "bridge-stop", data });
-        drainThenExit(ws, 1e3, "stop");
-      }
-    }
-  };
-  void writeBridgeMeta("init");
-  const wss = new WebSocketServer({ port: bridgeWsPort, host: "0.0.0.0" });
-  const exit = () => {
-    if (options.onExit) {
-      options.onExit();
-      return;
-    }
-    wss.close(() => process.exit(0));
-    setTimeout(() => process.exit(0), 1e3).unref();
-  };
-  const drainThenExit = (ws, code, reason) => {
-    const start = Date.now();
-    const tick = () => {
-      const drained = ws.bufferedAmount === 0 || ws.readyState !== WS_OPEN;
-      if (drained || Date.now() - start >= 5e3) {
-        void flushPendingEventsToDisk().finally(() => {
-          try {
-            ws.close(code, reason);
-          } finally {
-            exit();
-          }
-        });
-        return;
-      }
-      setTimeout(tick, 10).unref();
-    };
-    tick();
-  };
-  wss.on("listening", () => {
-    const addr = wss.address();
-    currentBoundPort = typeof addr === "object" && addr ? addr.port : 0;
-    currentTurnState = "waiting";
-    void writeBridgeMeta("waiting");
-    stdout.write(
-      JSON.stringify({
-        type: "bridge-ready",
-        port: currentBoundPort
-      }) + "\n"
-    );
-    options.onListening?.(currentBoundPort);
-  });
-  wss.on("connection", (ws, req) => {
-    const url = new URL(req.url ?? "/", "http://localhost");
-    if (url.searchParams.get("agent_bridge_token") !== expectedToken) {
-      ws.close(1008, "unauthorized");
-      return;
-    }
-    sendControl(ws, {
-      type: "bridge-hello",
-      state: currentTurnState,
-      lastSeq: seqCounter,
-      capabilities: { experimental_userMessageResponses: true }
-    });
-    ws.on("message", (raw) => {
-      let parsed;
-      try {
-        const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
-        parsed = JSON.parse(text);
-      } catch (err) {
-        sendControl(ws, {
-          type: "error",
-          error: `protocol parse error: ${err.message}`
-        });
-        return;
-      }
-      void handleInbound(parsed, ws);
-    });
-    ws.on("close", () => {
-      if (activeSocket === ws) {
-        activeSocket = void 0;
-      }
-    });
-    ws.on("error", () => {
-    });
-  });
-  process.on("uncaughtException", (err) => {
-    emitError({ error: err, message: "uncaught exception" });
-  });
-  process.on("unhandledRejection", (err) => {
-    emitError({ error: err, message: "unhandled rejection" });
-  });
-  await new Promise((resolve, reject) => {
-    if (wss.address() != null) {
-      resolve();
-      return;
-    }
-    wss.once("listening", resolve);
-    wss.once("error", reject);
-  });
-  return {
-    port: currentBoundPort,
-    close: () => new Promise((resolve) => {
-      wss.close(() => resolve());
-    })
-  };
+	const { bridgeType, bridgeStateDir, onStart, onStop, onDestroy } = options;
+	const teardownGraceMs = options.turnTeardownGraceMs ?? 1e4;
+	const expectedToken = options.token ?? env.BRIDGE_CHANNEL_TOKEN ?? "";
+	const bridgeWsPort = options.port ?? parseInt(env.BRIDGE_WS_PORT ?? "0", 10);
+	const bridgeMetaPath = `${bridgeStateDir}/bridge-meta.json`;
+	const startConfigPath = `${bridgeStateDir}/start-config.json`;
+	const rerunStartConfigPath = `${bridgeStateDir}/rerun-start-config.json`;
+	const eventLogPath = `${bridgeStateDir}/event-log.ndjson`;
+	try {
+		await mkdir(bridgeStateDir, { recursive: true });
+	} catch {}
+	let currentBoundPort = 0;
+	let currentTurnState = "init";
+	let activeSocket;
+	let isFirstTurn = true;
+	let turnAbort;
+	let currentUserMessages;
+	/**
+	* Settles when the in-flight turn has fully wound down — `onStart`
+	* returned or threw AND its completion state was recorded. `undefined`
+	* between turns. A new `start` fences on this so turns never overlap.
+	*/
+	let activeTurn;
+	let debugConfig;
+	let consoleCaptureInstalled = false;
+	const envDebugEnabled = ENV_TRUTHY.has((env.HARNESS_DEBUG ?? "").toLowerCase());
+	let seqCounter = 0;
+	let eventLog = [];
+	let diskBuffer = "";
+	let flushPromise = null;
+	const flushEventsToDisk = async () => {
+		while (diskBuffer.length > 0) {
+			const buf = diskBuffer;
+			diskBuffer = "";
+			await appendFile(eventLogPath, buf).catch(() => {});
+		}
+	};
+	const scheduleEventFlush = () => {
+		if (flushPromise) return;
+		flushPromise = new Promise((resolve) => {
+			setImmediate(() => {
+				flushEventsToDisk().finally(resolve);
+			});
+		}).finally(() => {
+			flushPromise = null;
+			if (diskBuffer.length > 0) scheduleEventFlush();
+		});
+	};
+	const flushPendingEventsToDisk = async () => {
+		if (diskBuffer.length > 0 && !flushPromise) scheduleEventFlush();
+		let inFlight = flushPromise;
+		while (inFlight) {
+			await inFlight;
+			inFlight = flushPromise;
+		}
+	};
+	if (env.BRIDGE_REPLAY_FROM_DISK === "1" && existsSync(eventLogPath)) try {
+		eventLog = readFileSync(eventLogPath, "utf8").split("\n").map((line) => line.trim()).filter(Boolean).map((line) => ({
+			seq: JSON.parse(line).seq,
+			line
+		}));
+		seqCounter = eventLog.at(-1)?.seq ?? 0;
+	} catch {
+		eventLog = [];
+		seqCounter = 0;
+	}
+	const pendingToolResults = /* @__PURE__ */ new Map();
+	const bufferedToolResults = [];
+	const pendingToolApprovals = /* @__PURE__ */ new Map();
+	const writeBridgeMeta = async (state) => {
+		try {
+			await writeFile(bridgeMetaPath, JSON.stringify({
+				type: bridgeType,
+				port: currentBoundPort,
+				state,
+				pid
+			}));
+		} catch {}
+	};
+	const writeStartConfig = async (start) => {
+		try {
+			const serialized = JSON.stringify(start);
+			await writeFile(startConfigPath, serialized);
+			if (!existsSync(rerunStartConfigPath)) await writeFile(rerunStartConfigPath, serialized);
+		} catch {}
+	};
+	const emit = (event) => {
+		const seq = ++seqCounter;
+		const line = JSON.stringify({
+			...event,
+			seq
+		});
+		eventLog.push({
+			seq,
+			line
+		});
+		diskBuffer += `${line}\n`;
+		scheduleEventFlush();
+		if (activeSocket?.readyState === WS_OPEN) try {
+			activeSocket.send(line);
+		} catch {}
+	};
+	const replay = (ws, afterSeq) => {
+		for (const entry of eventLog) if (entry.seq > afterSeq && ws.readyState === WS_OPEN) ws.send(entry.line);
+	};
+	const shouldEmitDebugEvent = (level, subsystem) => {
+		if (!debugConfig?.enabled) return false;
+		const threshold = debugConfig.level ?? "debug";
+		if (DEBUG_LEVEL_WEIGHT[level] > DEBUG_LEVEL_WEIGHT[threshold]) return false;
+		return subsystemMatches(debugConfig.subsystems, subsystem);
+	};
+	const rawStdoutWrite = process.stdout.write.bind(process.stdout);
+	const rawStderrWrite = process.stderr.write.bind(process.stderr);
+	const writeErrorToStderr = (input) => {
+		try {
+			const formatted = formatBridgeError(input.error);
+			rawStderrWrite(`[harness:${bridgeType}:error] ${input.message}: ${formatted.message}\n`);
+			if (formatted.stack) rawStderrWrite(`${formatted.stack}\n`);
+		} catch {}
+	};
+	const emitWarning = (input) => {
+		try {
+			for (const line of input.message.split("\n")) if (line.trim().length > 0) rawStderrWrite(`[harness:${bridgeType}:warn] ${line}\n`);
+		} catch {}
+	};
+	const emitError = (input) => {
+		writeErrorToStderr({
+			message: input.message ?? "bridge error",
+			error: input.error
+		});
+		emit({
+			type: "error",
+			error: serialiseError(input.error)
+		});
+	};
+	const installConsoleCapture = () => {
+		if (consoleCaptureInstalled) return;
+		consoleCaptureInstalled = true;
+		const buffers = {
+			stdout: "",
+			stderr: ""
+		};
+		const patch = (stream, raw) => (chunk, encoding, cb) => {
+			if (debugConfig?.enabled) try {
+				const enc = typeof encoding === "string" ? encoding : "utf8";
+				const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString(enc);
+				const parts = (buffers[stream] + text.replace(/\r\n/g, "\n")).split("\n");
+				buffers[stream] = parts.pop() ?? "";
+				for (const line of parts) {
+					const trimmed = line.replace(/\s+$/, "");
+					if (trimmed) emit({
+						type: "sandbox-log",
+						source: bridgeType,
+						stream,
+						line: trimmed
+					});
+				}
+			} catch {}
+			return raw(chunk, encoding, cb);
+		};
+		process.stdout.write = patch("stdout", rawStdoutWrite);
+		process.stderr.write = patch("stderr", rawStderrWrite);
+	};
+	const handleInbound = async (msg, ws) => {
+		switch (msg.type) {
+			case "start": {
+				for (;;) {
+					const pendingTurn = activeTurn;
+					if (pendingTurn == null) break;
+					turnAbort?.abort();
+					currentUserMessages?.close(/* @__PURE__ */ new Error("A new bridge turn replaced the active turn."));
+					let graceTimer;
+					const settled = await Promise.race([pendingTurn.then(() => true), new Promise((resolve) => {
+						graceTimer = setTimeout(() => resolve(false), teardownGraceMs);
+						graceTimer.unref?.();
+					})]);
+					clearTimeout(graceTimer);
+					if (!settled) break;
+				}
+				let turnFinished;
+				const thisTurn = new Promise((resolve) => turnFinished = resolve);
+				activeTurn = thisTurn;
+				activeSocket = ws;
+				const firstTurn = isFirstTurn;
+				isFirstTurn = false;
+				eventLog = [];
+				diskBuffer = "";
+				writeFile(eventLogPath, "").catch(() => {});
+				turnAbort = new AbortController();
+				currentTurnState = "running";
+				writeStartConfig(msg);
+				writeBridgeMeta("running");
+				const startDebug = msg.debug;
+				debugConfig = {
+					enabled: startDebug?.enabled ?? envDebugEnabled,
+					level: startDebug?.level ?? env.HARNESS_DEBUG_LEVEL,
+					subsystems: startDebug?.subsystems ?? parseEnvList(env.HARNESS_DEBUG_SUBSYSTEMS)
+				};
+				if (debugConfig.enabled) installConsoleCapture();
+				const userMessages = createBridgeUserMessageQueue({ respond: emit });
+				const turn = {
+					emit,
+					requestToolResult: (requestInput) => {
+						const request = typeof requestInput === "string" ? { toolCallId: requestInput } : requestInput;
+						const bufferedIndex = bufferedToolResults.findIndex((buffered) => buffered.toolCallId === request.toolCallId || request.matches?.(buffered.result) === true);
+						if (bufferedIndex >= 0) return Promise.resolve(bufferedToolResults.splice(bufferedIndex, 1)[0].result);
+						return new Promise((resolve) => {
+							pendingToolResults.set(request.toolCallId, {
+								resolve,
+								matches: request.matches
+							});
+						});
+					},
+					requestToolApproval: (approvalId) => new Promise((resolve) => {
+						pendingToolApprovals.set(approvalId, resolve);
+					}),
+					experimental_userMessages: userMessages,
+					abortSignal: turnAbort.signal,
+					firstTurn,
+					bridgeLog: (input) => {
+						const level = input.level ?? "debug";
+						if (!shouldEmitDebugEvent(level, input.subsystem)) return;
+						emit({
+							type: "debug-event",
+							level,
+							subsystem: input.subsystem,
+							message: input.message,
+							...input.attrs ? { attrs: input.attrs } : {},
+							...input.error !== void 0 ? { error: formatBridgeError(input.error) } : {}
+						});
+					},
+					emitWarning,
+					emitError
+				};
+				currentUserMessages = userMessages;
+				try {
+					await onStart(msg, turn);
+				} catch (err) {
+					emitError({
+						error: err,
+						message: "bridge turn failed"
+					});
+				} finally {
+					userMessages.close();
+					if (currentUserMessages === userMessages) currentUserMessages = void 0;
+					if (activeTurn === thisTurn) {
+						activeTurn = void 0;
+						currentTurnState = "waiting";
+						writeBridgeMeta("waiting");
+					}
+					turnFinished();
+				}
+				return;
+			}
+			case "tool-result": {
+				const result = {
+					output: msg.output,
+					isError: msg.isError,
+					toolResult: msg.toolResult
+				};
+				const exactPending = pendingToolResults.get(msg.toolCallId);
+				const matchingPending = exactPending == null ? Array.from(pendingToolResults.entries()).find(([, pending]) => pending.matches?.(result) === true) : void 0;
+				const pending = exactPending ?? matchingPending?.[1];
+				const pendingId = exactPending != null ? msg.toolCallId : matchingPending?.[0];
+				if (pending != null && pendingId != null) {
+					pendingToolResults.delete(pendingId);
+					pending.resolve(result);
+				} else bufferedToolResults.push({
+					toolCallId: msg.toolCallId,
+					result
+				});
+				return;
+			}
+			case "tool-approval-response": {
+				const resolver = pendingToolApprovals.get(msg.approvalId);
+				if (resolver) {
+					pendingToolApprovals.delete(msg.approvalId);
+					resolver({
+						approved: msg.approved,
+						reason: msg.reason
+					});
+				}
+				return;
+			}
+			case "user-message": {
+				const messageId = msg.messageId ?? randomUUID();
+				if (currentUserMessages == null) {
+					sendControl(ws, {
+						type: "user-message-response",
+						messageId,
+						accepted: false,
+						error: { message: "The bridge has no active turn to steer." }
+					});
+					return;
+				}
+				if (ws !== activeSocket) {
+					sendControl(ws, {
+						type: "user-message-response",
+						messageId,
+						accepted: false,
+						error: { message: "The connection does not own the active bridge turn." }
+					});
+					return;
+				}
+				currentUserMessages.enqueue({
+					messageId,
+					text: msg.text
+				});
+				return;
+			}
+			case "abort":
+				turnAbort?.abort();
+				return;
+			case "resume":
+				activeSocket = ws;
+				replay(ws, msg.lastSeenEventId);
+				return;
+			case "destroy":
+				currentTurnState = "done";
+				writeBridgeMeta("done");
+				await onDestroy?.();
+				drainThenExit(ws, 1e3, "destroy");
+				return;
+			case "stop":
+				currentTurnState = "done";
+				writeBridgeMeta("done");
+				sendControl(ws, {
+					type: "bridge-stop",
+					data: await onStop?.() ?? {}
+				});
+				drainThenExit(ws, 1e3, "stop");
+		}
+	};
+	writeBridgeMeta("init");
+	const wss = new WebSocketServer({
+		port: bridgeWsPort,
+		host: "0.0.0.0"
+	});
+	const exit = () => {
+		if (options.onExit) {
+			options.onExit();
+			return;
+		}
+		wss.close(() => process.exit(0));
+		setTimeout(() => process.exit(0), 1e3).unref();
+	};
+	const drainThenExit = (ws, code, reason) => {
+		const start = Date.now();
+		const tick = () => {
+			if (ws.bufferedAmount === 0 || ws.readyState !== WS_OPEN || Date.now() - start >= 5e3) {
+				flushPendingEventsToDisk().finally(() => {
+					try {
+						ws.close(code, reason);
+					} finally {
+						exit();
+					}
+				});
+				return;
+			}
+			setTimeout(tick, 10).unref();
+		};
+		tick();
+	};
+	wss.on("listening", () => {
+		const addr = wss.address();
+		currentBoundPort = typeof addr === "object" && addr ? addr.port : 0;
+		currentTurnState = "waiting";
+		writeBridgeMeta("waiting");
+		stdout.write(JSON.stringify({
+			type: "bridge-ready",
+			port: currentBoundPort
+		}) + "\n");
+		options.onListening?.(currentBoundPort);
+	});
+	wss.on("connection", (ws, req) => {
+		if (new URL(req.url ?? "/", "http://localhost").searchParams.get("agent_bridge_token") !== expectedToken) {
+			ws.close(1008, "unauthorized");
+			return;
+		}
+		sendControl(ws, {
+			type: "bridge-hello",
+			state: currentTurnState,
+			lastSeq: seqCounter,
+			capabilities: { experimental_userMessageResponses: true }
+		});
+		ws.on("message", (raw) => {
+			let parsed;
+			try {
+				const text = typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8");
+				parsed = JSON.parse(text);
+			} catch (err) {
+				sendControl(ws, {
+					type: "error",
+					error: `protocol parse error: ${err.message}`
+				});
+				return;
+			}
+			handleInbound(parsed, ws);
+		});
+		ws.on("close", () => {
+			if (activeSocket === ws) activeSocket = void 0;
+		});
+		ws.on("error", () => {});
+	});
+	process.on("uncaughtException", (err) => {
+		emitError({
+			error: err,
+			message: "uncaught exception"
+		});
+	});
+	process.on("unhandledRejection", (err) => {
+		emitError({
+			error: err,
+			message: "unhandled rejection"
+		});
+	});
+	await new Promise((resolve, reject) => {
+		if (wss.address() != null) {
+			resolve();
+			return;
+		}
+		wss.once("listening", resolve);
+		wss.once("error", reject);
+	});
+	return {
+		port: currentBoundPort,
+		close: () => new Promise((resolve) => {
+			wss.close(() => resolve());
+		})
+	};
 }
 function sendControl(socket, message) {
-  if (socket?.readyState === WS_OPEN) {
-    try {
-      socket.send(JSON.stringify(message));
-    } catch {
-    }
-  }
+	if (socket?.readyState === WS_OPEN) try {
+		socket.send(JSON.stringify(message));
+	} catch {}
 }
 function serialiseError(err) {
-  if (err instanceof Error) {
-    return { name: err.name, message: err.message, stack: err.stack };
-  }
-  return err;
+	if (err instanceof Error) return {
+		name: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+	return err;
 }
-
-// src/bridge/compaction-latch.ts
+//#endregion
+//#region src/bridge/compaction-latch.ts
 function createCompactionLatch(emit) {
-  let boundary;
-  let summary;
-  const tryEmit = () => {
-    if (!boundary || summary === void 0) return;
-    emit({
-      type: "compaction",
-      trigger: boundary.trigger,
-      summary,
-      ...boundary.tokensBefore !== void 0 ? { tokensBefore: boundary.tokensBefore } : {},
-      ...boundary.tokensAfter !== void 0 ? { tokensAfter: boundary.tokensAfter } : {}
-    });
-    boundary = void 0;
-    summary = void 0;
-  };
-  return {
-    onBoundary(next) {
-      boundary = next;
-      tryEmit();
-    },
-    onSummary(next) {
-      summary = next;
-      tryEmit();
-    }
-  };
+	let boundary;
+	let summary;
+	const tryEmit = () => {
+		if (!boundary || summary === void 0) return;
+		emit({
+			type: "compaction",
+			trigger: boundary.trigger,
+			summary,
+			...boundary.tokensBefore !== void 0 ? { tokensBefore: boundary.tokensBefore } : {},
+			...boundary.tokensAfter !== void 0 ? { tokensAfter: boundary.tokensAfter } : {}
+		});
+		boundary = void 0;
+		summary = void 0;
+	};
+	return {
+		onBoundary(next) {
+			boundary = next;
+			tryEmit();
+		},
+		onSummary(next) {
+			summary = next;
+			tryEmit();
+		}
+	};
 }
-
-// src/bridge/index.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { argv, env as procEnv2, stdout as stdout2 } from "process";
-import * as claudeAgentSdk from "@anthropic-ai/claude-agent-sdk";
-import * as mcpServerModule from "@modelcontextprotocol/sdk/server/mcp.js";
-
-// src/bridge/claude-code-system-prompt.ts
+//#endregion
+//#region src/bridge/claude-code-system-prompt.ts
 function createClaudeCodeSystemPrompt(instructions) {
-  return {
-    type: "preset",
-    preset: "claude_code",
-    ...instructions ? { append: instructions } : {}
-  };
+	return {
+		type: "preset",
+		preset: "claude_code",
+		...instructions ? { append: instructions } : {}
+	};
 }
-
-// src/bridge/claude-skills-option.ts
+//#endregion
+//#region src/bridge/claude-skills-option.ts
 function toClaudeSkillsOption(skills) {
-  return skills && skills.length > 0 ? "all" : void 0;
+	return skills && skills.length > 0 ? "all" : void 0;
 }
-
-// src/bridge/create-emit-stream-event.ts
-import { randomUUID as randomUUID2 } from "crypto";
+//#endregion
+//#region src/bridge/create-emit-stream-event.ts
 function createClaudeStreamEventState() {
-  return {
-    nativeToolCallNames: /* @__PURE__ */ new Map(),
-    approvalRequestedToolUseIds: /* @__PURE__ */ new Set(),
-    partialBlocks: /* @__PURE__ */ new Map(),
-    stepUsage: void 0,
-    pendingStepToolUseIds: /* @__PURE__ */ new Set(),
-    pendingStepAssistantUsage: void 0,
-    pendingStepDeltaUsage: void 0,
-    pendingStepUsage: void 0,
-    stepOpen: false,
-    mcpToolUseIds: /* @__PURE__ */ new Set(),
-    externalMcpToolUseIds: /* @__PURE__ */ new Set(),
-    structuredOutputToolUseIds: /* @__PURE__ */ new Set(),
-    observedTerminalError: void 0
-  };
+	return {
+		nativeToolCallNames: /* @__PURE__ */ new Map(),
+		approvalRequestedToolUseIds: /* @__PURE__ */ new Set(),
+		partialBlocks: /* @__PURE__ */ new Map(),
+		stepUsage: void 0,
+		pendingStepToolUseIds: /* @__PURE__ */ new Set(),
+		pendingStepAssistantUsage: void 0,
+		pendingStepDeltaUsage: void 0,
+		pendingStepUsage: void 0,
+		pendingResponseUsage: void 0,
+		stepOpen: false,
+		mcpToolUseIds: /* @__PURE__ */ new Set(),
+		externalMcpToolUseIds: /* @__PURE__ */ new Set(),
+		structuredOutputToolUseIds: /* @__PURE__ */ new Set(),
+		observedTerminalError: void 0
+	};
 }
-var UNRECOVERABLE_API_RETRY_STATUSES = /* @__PURE__ */ new Set([401, 403, 404]);
-var HOST_TOOL_PREFIX = "mcp__harness-tools__";
+const UNRECOVERABLE_API_RETRY_STATUSES = /* @__PURE__ */ new Set([
+	401,
+	403,
+	404
+]);
+const HOST_TOOL_PREFIX = "mcp__harness-tools__";
+const RAW_TASK_MESSAGE_SUBTYPES = /* @__PURE__ */ new Set([
+	"background_tasks_changed",
+	"task_started",
+	"task_progress",
+	"task_updated",
+	"task_notification"
+]);
 function isExternalMcpTool(nativeName) {
-  return nativeName.startsWith("mcp__") && !nativeName.startsWith(HOST_TOOL_PREFIX);
+	return nativeName.startsWith("mcp__") && !nativeName.startsWith(HOST_TOOL_PREFIX);
 }
-function createEmitStreamEvent({
-  state,
-  emit,
-  emitWarning,
-  emitTerminalError,
-  onCompactionBoundary,
-  toCommonName: toCommonName2
-}) {
-  let streamStarted = false;
-  return (msg) => {
-    const type = msg.type;
-    if (!streamStarted) {
-      const initModel = type === "system" && msg.subtype === "init" && typeof msg.model === "string" ? msg.model : void 0;
-      emit({
-        type: "stream-start",
-        ...initModel ? { modelId: initModel } : {}
-      });
-      streamStarted = true;
-    }
-    if (type === "system" && msg.subtype === "api_retry") {
-      if (typeof msg.error_status === "number" && UNRECOVERABLE_API_RETRY_STATUSES.has(msg.error_status)) {
-        emitTerminalError(
-          `HTTP ${msg.error_status}: ${msg.error ?? "provider request failed"}`
-        );
-        return;
-      }
-      emitWarning({ message: formatApiRetryWarning(msg) });
-      return;
-    }
-    if (typeof msg.error === "string" && msg.error.trim()) {
-      state.observedTerminalError = msg.error.trim();
-    }
-    if (type === "auth_status" && typeof msg.error === "string" && msg.error.trim()) {
-      emitTerminalError(msg.error);
-      return;
-    }
-    if (type === "system" && msg.subtype === "task_updated" && msg.patch?.status === "failed" && typeof msg.patch.error === "string") {
-      emitTerminalError(msg.patch.error);
-      return;
-    }
-    if (type === "system" && msg.subtype === "compact_boundary") {
-      const meta = msg.compact_metadata;
-      if (meta) {
-        onCompactionBoundary({
-          trigger: meta.trigger,
-          ...typeof meta.pre_tokens === "number" ? { tokensBefore: meta.pre_tokens } : {},
-          ...typeof meta.post_tokens === "number" ? { tokensAfter: meta.post_tokens } : {}
-        });
-      }
-      return;
-    }
-    if (msg.parent_tool_use_id != null) {
-      return;
-    }
-    if (type === "stream_event") {
-      handleStreamEvent({
-        event: msg.event,
-        state,
-        send: emit,
-        toCommonName: toCommonName2
-      });
-      return;
-    }
-    const messageContent = msg.message?.content;
-    if (type === "assistant" && Array.isArray(messageContent)) {
-      const usage = toUsageRecord(msg.message?.usage);
-      const toolUseIds = [];
-      let opensStep = false;
-      for (const block of messageContent) {
-        if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
-          toolUseIds.push(block.id);
-          if (block.name === "StructuredOutput") {
-            state.structuredOutputToolUseIds.add(block.id);
-            continue;
-          }
-          if (block.name.startsWith(HOST_TOOL_PREFIX)) {
-            state.pendingStepToolUseIds.add(block.id);
-            state.mcpToolUseIds.add(block.id);
-            opensStep = true;
-            continue;
-          }
-          state.nativeToolCallNames.set(block.id, block.name);
-          if (block.name === "AskUserQuestion") {
-            state.pendingStepToolUseIds.add(block.id);
-            opensStep = true;
-            continue;
-          }
-          const dynamic = isExternalMcpTool(block.name);
-          if (dynamic) state.externalMcpToolUseIds.add(block.id);
-          if (state.approvalRequestedToolUseIds.has(block.id)) {
-            continue;
-          }
-          state.pendingStepToolUseIds.add(block.id);
-          opensStep = true;
-          emit({
-            type: "tool-call",
-            toolCallId: block.id,
-            toolName: toCommonName2(block.name),
-            nativeName: block.name,
-            input: JSON.stringify(block.input ?? {}),
-            providerExecuted: true,
-            ...dynamic ? { dynamic: true } : {}
-          });
-        }
-      }
-      if (opensStep || toolUseIds.length === 0) {
-        state.stepOpen = true;
-        if (usage) {
-          state.pendingStepAssistantUsage = usage;
-          updatePendingStepUsage(state);
-        }
-      }
-      return;
-    }
-    if (type === "user" && Array.isArray(messageContent)) {
-      const toolResultBlocks = messageContent.filter(
-        (block) => block.type === "tool_result"
-      );
-      const toolUseResult = toolResultBlocks.length === 1 ? msg.tool_use_result : void 0;
-      for (const block of messageContent) {
-        if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
-          if (state.structuredOutputToolUseIds.delete(block.tool_use_id)) {
-            continue;
-          }
-          if (state.mcpToolUseIds.has(block.tool_use_id)) {
-            state.mcpToolUseIds.delete(block.tool_use_id);
-            state.pendingStepToolUseIds.delete(block.tool_use_id);
-            continue;
-          }
-          state.approvalRequestedToolUseIds.delete(block.tool_use_id);
-          const nativeName = state.nativeToolCallNames.get(block.tool_use_id) ?? "unknown";
-          state.nativeToolCallNames.delete(block.tool_use_id);
-          const toolName = toCommonName2(nativeName);
-          const dynamic = state.externalMcpToolUseIds.delete(block.tool_use_id);
-          const isError = !!block.is_error;
-          const result = toolUseResult !== void 0 ? toolUseResult : resolveToolResult({
-            toolName,
-            dynamic,
-            isError,
-            rawContent: block.content
-          });
-          emit({
-            type: "tool-result",
-            toolCallId: block.tool_use_id,
-            toolName,
-            result,
-            isError,
-            ...dynamic ? { dynamic: true } : {}
-          });
-          state.pendingStepToolUseIds.delete(block.tool_use_id);
-        }
-      }
-      closeStepIfReady({ state, emit });
-    }
-  };
+function createEmitStreamEvent({ state, emit, emitWarning, emitTerminalError, onCompactionBoundary, toCommonName }) {
+	let streamStarted = false;
+	return (msg) => {
+		const type = msg.type;
+		if (!streamStarted) {
+			const initModel = type === "system" && msg.subtype === "init" && typeof msg.model === "string" ? msg.model : void 0;
+			emit({
+				type: "stream-start",
+				...initModel ? { modelId: initModel } : {}
+			});
+			streamStarted = true;
+		}
+		if (type === "system" && msg.subtype === "api_retry") {
+			if (typeof msg.error_status === "number" && UNRECOVERABLE_API_RETRY_STATUSES.has(msg.error_status)) {
+				emitTerminalError(`HTTP ${msg.error_status}: ${msg.error ?? "provider request failed"}`);
+				return;
+			}
+			emitWarning({ message: formatApiRetryWarning(msg) });
+			return;
+		}
+		if (typeof msg.error === "string" && msg.error.trim()) state.observedTerminalError = msg.error.trim();
+		if (type === "auth_status" && typeof msg.error === "string" && msg.error.trim()) {
+			emitTerminalError(msg.error);
+			return;
+		}
+		if (type === "system" && msg.subtype === "task_updated" && msg.patch?.status === "failed" && typeof msg.patch.error === "string") {
+			emitTerminalError(msg.patch.error);
+			return;
+		}
+		if (type === "system" && msg.subtype === "compact_boundary") {
+			const meta = msg.compact_metadata;
+			if (meta) onCompactionBoundary({
+				trigger: meta.trigger,
+				...typeof meta.pre_tokens === "number" ? { tokensBefore: meta.pre_tokens } : {},
+				...typeof meta.post_tokens === "number" ? { tokensAfter: meta.post_tokens } : {}
+			});
+			return;
+		}
+		if (type === "tool_progress" || type === "system" && msg.subtype != null && RAW_TASK_MESSAGE_SUBTYPES.has(msg.subtype)) {
+			emit({
+				type: "raw",
+				rawValue: msg
+			});
+			return;
+		}
+		if (msg.parent_tool_use_id != null) {
+			emit({
+				type: "raw",
+				rawValue: msg
+			});
+			return;
+		}
+		if (type === "stream_event") {
+			handleStreamEvent({
+				event: msg.event,
+				message: msg,
+				state,
+				send: emit,
+				toCommonName
+			});
+			return;
+		}
+		const messageContent = msg.message?.content;
+		if (type === "assistant" && Array.isArray(messageContent)) {
+			const usage = toUsageRecord(msg.message?.usage);
+			const toolUseIds = [];
+			let opensStep = false;
+			for (const block of messageContent) if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+				toolUseIds.push(block.id);
+				if (block.name === "StructuredOutput") {
+					state.structuredOutputToolUseIds.add(block.id);
+					continue;
+				}
+				if (block.name.startsWith(HOST_TOOL_PREFIX)) {
+					state.pendingStepToolUseIds.add(block.id);
+					state.mcpToolUseIds.add(block.id);
+					opensStep = true;
+					continue;
+				}
+				state.nativeToolCallNames.set(block.id, block.name);
+				if (block.name === "AskUserQuestion") {
+					state.pendingStepToolUseIds.add(block.id);
+					opensStep = true;
+					continue;
+				}
+				const dynamic = isExternalMcpTool(block.name);
+				if (dynamic) state.externalMcpToolUseIds.add(block.id);
+				if (state.approvalRequestedToolUseIds.has(block.id)) continue;
+				state.pendingStepToolUseIds.add(block.id);
+				opensStep = true;
+				emit({
+					type: "tool-call",
+					toolCallId: block.id,
+					toolName: toCommonName(block.name),
+					nativeName: block.name,
+					input: JSON.stringify(block.input ?? {}),
+					providerExecuted: true,
+					...dynamic ? { dynamic: true } : {}
+				});
+			}
+			if (opensStep || toolUseIds.length === 0) {
+				state.stepOpen = true;
+				if (usage) {
+					state.pendingStepAssistantUsage = usage;
+					updatePendingStepUsage(state);
+				}
+			}
+			return;
+		}
+		if (type === "user" && Array.isArray(messageContent)) {
+			const toolUseResult = messageContent.filter((block) => block.type === "tool_result").length === 1 ? msg.tool_use_result : void 0;
+			for (const block of messageContent) if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+				if (state.structuredOutputToolUseIds.delete(block.tool_use_id)) continue;
+				if (state.mcpToolUseIds.has(block.tool_use_id)) {
+					state.mcpToolUseIds.delete(block.tool_use_id);
+					state.pendingStepToolUseIds.delete(block.tool_use_id);
+					continue;
+				}
+				state.approvalRequestedToolUseIds.delete(block.tool_use_id);
+				const nativeName = state.nativeToolCallNames.get(block.tool_use_id) ?? "unknown";
+				state.nativeToolCallNames.delete(block.tool_use_id);
+				const toolName = toCommonName(nativeName);
+				const dynamic = state.externalMcpToolUseIds.delete(block.tool_use_id);
+				const isError = !!block.is_error;
+				const result = toolUseResult !== void 0 ? toolUseResult : resolveToolResult({
+					toolName,
+					dynamic,
+					isError,
+					rawContent: block.content
+				});
+				emit({
+					type: "tool-result",
+					toolCallId: block.tool_use_id,
+					toolName,
+					result,
+					isError,
+					...dynamic ? { dynamic: true } : {}
+				});
+				state.pendingStepToolUseIds.delete(block.tool_use_id);
+			}
+			closeStepIfReady({
+				state,
+				emit
+			});
+		}
+	};
 }
-function finishApprovalStep({
-  state,
-  emit,
-  approvalId
-}) {
-  state.stepOpen = true;
-  state.pendingStepToolUseIds.delete(approvalId);
-  closeStepIfReady({ state, emit });
+function finishApprovalStep({ state, emit, approvalId }) {
+	state.stepOpen = true;
+	state.pendingStepToolUseIds.delete(approvalId);
+	closeStepIfReady({
+		state,
+		emit
+	});
 }
-function emitFinishStep({
-  state,
-  emit,
-  usage
-}) {
-  emit({
-    type: "finish-step",
-    finishReason: { unified: "stop", raw: "stop" },
-    usage: usage ?? defaultUsage()
-  });
-  state.stepUsage = usage ?? state.stepUsage;
-  state.pendingStepAssistantUsage = void 0;
-  state.pendingStepDeltaUsage = void 0;
-  state.pendingStepUsage = void 0;
-  state.pendingStepToolUseIds = /* @__PURE__ */ new Set();
-  state.stepOpen = false;
+function emitFinishStep({ state, emit, usage }) {
+	emit({
+		type: "finish-step",
+		finishReason: {
+			unified: "stop",
+			raw: "stop"
+		},
+		usage: usage ?? defaultUsage()
+	});
+	state.stepUsage = usage ?? state.stepUsage;
+	state.pendingStepAssistantUsage = void 0;
+	state.pendingStepDeltaUsage = void 0;
+	state.pendingStepUsage = void 0;
+	state.pendingStepToolUseIds = /* @__PURE__ */ new Set();
+	state.stepOpen = false;
 }
-function closeStepIfReady({
-  state,
-  emit
-}) {
-  if (!state.stepOpen || state.pendingStepToolUseIds.size > 0 || state.partialBlocks.size > 0) {
-    return;
-  }
-  emitFinishStep({ state, emit, usage: state.pendingStepUsage });
+function closeStepIfReady({ state, emit }) {
+	if (!state.stepOpen || state.pendingStepToolUseIds.size > 0 || state.partialBlocks.size > 0) return;
+	emitFinishStep({
+		state,
+		emit,
+		usage: state.pendingStepUsage
+	});
 }
 function formatApiRetryWarning(msg) {
-  const details = [];
-  if (typeof msg.attempt === "number") {
-    const maxRetries = typeof msg.max_retries === "number" ? `/${msg.max_retries}` : "";
-    details.push(`attempt ${msg.attempt}${maxRetries}`);
-  }
-  if (typeof msg.error_status === "number") {
-    details.push(`HTTP ${msg.error_status}`);
-  }
-  if (typeof msg.retry_delay_ms === "number") {
-    details.push(`retrying in ${msg.retry_delay_ms}ms`);
-  }
-  if (msg.error) details.push(msg.error);
-  return details.length > 0 ? `Claude Code API retry: ${details.join("; ")}` : "Claude Code API retry";
+	const details = [];
+	if (typeof msg.attempt === "number") {
+		const maxRetries = typeof msg.max_retries === "number" ? `/${msg.max_retries}` : "";
+		details.push(`attempt ${msg.attempt}${maxRetries}`);
+	}
+	if (typeof msg.error_status === "number") details.push(`HTTP ${msg.error_status}`);
+	if (typeof msg.retry_delay_ms === "number") details.push(`retrying in ${msg.retry_delay_ms}ms`);
+	if (msg.error) details.push(msg.error);
+	return details.length > 0 ? `Claude Code API retry: ${details.join("; ")}` : "Claude Code API retry";
 }
-function handleStreamEvent({
-  event,
-  state,
-  send,
-  toCommonName: toCommonName2
-}) {
-  if (!event) return;
-  if (event.type === "message_delta") {
-    const usage = toUsageRecord(event.usage);
-    if (usage) {
-      state.pendingStepDeltaUsage = mergeNonNullUsage(
-        state.pendingStepDeltaUsage,
-        usage
-      );
-      updatePendingStepUsage(state);
-    }
-    return;
-  }
-  if (typeof event.index !== "number") return;
-  const index = event.index;
-  const partialBlocks = state.partialBlocks;
-  if (event.type === "content_block_start") {
-    const blockType = event.content_block?.type;
-    if (blockType === "text") {
-      const id = randomUUID2();
-      partialBlocks.set(index, { id, kind: "text" });
-      send({ type: "text-start", id });
-    } else if (blockType === "thinking") {
-      const id = randomUUID2();
-      partialBlocks.set(index, { id, kind: "thinking" });
-      send({ type: "reasoning-start", id });
-    } else if (blockType === "tool_use" && typeof event.content_block?.id === "string" && typeof event.content_block.name === "string") {
-      const id = event.content_block.id;
-      const nativeName = event.content_block.name;
-      if (nativeName === "StructuredOutput") {
-        return;
-      }
-      if (nativeName === "AskUserQuestion") {
-        return;
-      }
-      const hostToolName = nativeName.startsWith(HOST_TOOL_PREFIX) ? nativeName.slice(HOST_TOOL_PREFIX.length) : void 0;
-      const dynamic = isExternalMcpTool(nativeName);
-      partialBlocks.set(index, { id, kind: "tool-input" });
-      send({
-        type: "tool-input-start",
-        id,
-        toolName: hostToolName ?? toCommonName2(nativeName),
-        providerExecuted: hostToolName === void 0,
-        ...dynamic ? { dynamic: true } : {}
-      });
-    }
-    return;
-  }
-  if (event.type === "content_block_delta") {
-    const block = partialBlocks.get(index);
-    if (!block) return;
-    if (block.kind === "text" && event.delta?.type === "text_delta" && typeof event.delta.text === "string") {
-      send({ type: "text-delta", id: block.id, delta: event.delta.text });
-    } else if (block.kind === "thinking" && event.delta?.type === "thinking_delta" && typeof event.delta.thinking === "string") {
-      send({
-        type: "reasoning-delta",
-        id: block.id,
-        delta: event.delta.thinking
-      });
-    } else if (block.kind === "tool-input" && event.delta?.type === "input_json_delta" && typeof event.delta.partial_json === "string") {
-      send({
-        type: "tool-input-delta",
-        id: block.id,
-        delta: event.delta.partial_json
-      });
-    }
-    return;
-  }
-  if (event.type === "content_block_stop") {
-    const block = partialBlocks.get(index);
-    if (!block) return;
-    partialBlocks.delete(index);
-    if (block.kind === "text") {
-      send({ type: "text-end", id: block.id });
-    } else if (block.kind === "thinking") {
-      send({ type: "reasoning-end", id: block.id });
-    } else {
-      send({ type: "tool-input-end", id: block.id });
-    }
-  }
+function handleStreamEvent({ event, message, state, send, toCommonName }) {
+	if (!event) return;
+	if (event.type === "message_start") {
+		state.pendingResponseUsage = toUsageRecord(event.message?.usage);
+		return;
+	}
+	if (event.type === "message_delta") {
+		const usage = toUsageRecord(event.usage);
+		if (usage) {
+			state.pendingResponseUsage = mergeNonNullUsage(state.pendingResponseUsage, usage);
+			state.pendingStepDeltaUsage = mergeNonNullUsage(state.pendingStepDeltaUsage, usage);
+			updatePendingStepUsage(state);
+		}
+		return;
+	}
+	if (event.type === "message_stop") {
+		send({
+			type: "raw",
+			rawValue: {
+				...message,
+				usage: state.pendingResponseUsage ?? {}
+			}
+		});
+		state.pendingResponseUsage = void 0;
+		return;
+	}
+	if (typeof event.index !== "number") return;
+	const index = event.index;
+	const partialBlocks = state.partialBlocks;
+	if (event.type === "content_block_start") {
+		const blockType = event.content_block?.type;
+		if (blockType === "text") {
+			const id = randomUUID();
+			partialBlocks.set(index, {
+				id,
+				kind: "text"
+			});
+			send({
+				type: "text-start",
+				id
+			});
+		} else if (blockType === "thinking") {
+			const id = randomUUID();
+			partialBlocks.set(index, {
+				id,
+				kind: "thinking"
+			});
+			send({
+				type: "reasoning-start",
+				id
+			});
+		} else if (blockType === "tool_use" && typeof event.content_block?.id === "string" && typeof event.content_block.name === "string") {
+			const id = event.content_block.id;
+			const nativeName = event.content_block.name;
+			if (nativeName === "StructuredOutput") return;
+			if (nativeName === "AskUserQuestion") return;
+			const hostToolName = nativeName.startsWith(HOST_TOOL_PREFIX) ? nativeName.slice(20) : void 0;
+			const dynamic = isExternalMcpTool(nativeName);
+			partialBlocks.set(index, {
+				id,
+				kind: "tool-input"
+			});
+			send({
+				type: "tool-input-start",
+				id,
+				toolName: hostToolName ?? toCommonName(nativeName),
+				providerExecuted: hostToolName === void 0,
+				...dynamic ? { dynamic: true } : {}
+			});
+		}
+		return;
+	}
+	if (event.type === "content_block_delta") {
+		const block = partialBlocks.get(index);
+		if (!block) return;
+		if (block.kind === "text" && event.delta?.type === "text_delta" && typeof event.delta.text === "string") send({
+			type: "text-delta",
+			id: block.id,
+			delta: event.delta.text
+		});
+		else if (block.kind === "thinking" && event.delta?.type === "thinking_delta" && typeof event.delta.thinking === "string") send({
+			type: "reasoning-delta",
+			id: block.id,
+			delta: event.delta.thinking
+		});
+		else if (block.kind === "tool-input" && event.delta?.type === "input_json_delta" && typeof event.delta.partial_json === "string") send({
+			type: "tool-input-delta",
+			id: block.id,
+			delta: event.delta.partial_json
+		});
+		return;
+	}
+	if (event.type === "content_block_stop") {
+		const block = partialBlocks.get(index);
+		if (!block) return;
+		partialBlocks.delete(index);
+		if (block.kind === "text") send({
+			type: "text-end",
+			id: block.id
+		});
+		else if (block.kind === "thinking") send({
+			type: "reasoning-end",
+			id: block.id
+		});
+		else send({
+			type: "tool-input-end",
+			id: block.id
+		});
+	}
 }
 function toUsageRecord(usage) {
-  return usage != null && typeof usage === "object" ? usage : void 0;
+	return usage != null && typeof usage === "object" ? usage : void 0;
 }
 function mergeNonNullUsage(current, update) {
-  const merged = { ...current };
-  for (const [key, value] of Object.entries(update)) {
-    if (value != null) {
-      merged[key] = value;
-    }
-  }
-  return merged;
+	const merged = { ...current };
+	for (const [key, value] of Object.entries(update)) if (value != null) merged[key] = value;
+	return merged;
 }
 function updatePendingStepUsage(state) {
-  const assistantUsage = state.pendingStepAssistantUsage;
-  const deltaUsage = state.pendingStepDeltaUsage;
-  state.pendingStepUsage = mapUsage(
-    assistantUsage || deltaUsage ? { ...assistantUsage, ...deltaUsage } : void 0
-  );
+	const assistantUsage = state.pendingStepAssistantUsage;
+	const deltaUsage = state.pendingStepDeltaUsage;
+	state.pendingStepUsage = mapUsage(assistantUsage || deltaUsage ? {
+		...assistantUsage,
+		...deltaUsage
+	} : void 0);
 }
 function isTextEntry(entry) {
-  return entry != null && typeof entry === "object" && "text" in entry;
+	return entry != null && typeof entry === "object" && "text" in entry;
 }
 function stringifyContent(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content.map(
-      (entry) => isTextEntry(entry) ? String(entry.text ?? "") : JSON.stringify(entry)
-    ).join("");
-  }
-  return JSON.stringify(content);
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((entry) => isTextEntry(entry) ? String(entry.text ?? "") : JSON.stringify(entry)).join("");
+	return JSON.stringify(content);
 }
 function hasNonTextContent(content) {
-  return Array.isArray(content) && content.some((entry) => !isTextEntry(entry));
+	return Array.isArray(content) && content.some((entry) => !isTextEntry(entry));
 }
-function resolveToolResult({
-  toolName,
-  dynamic,
-  isError,
-  rawContent
-}) {
-  if (toolName === "bash") {
-    return { exitCode: isError ? 1 : 0, stdout: stringifyContent(rawContent) };
-  }
-  if (hasNonTextContent(rawContent)) return rawContent;
-  const content = stringifyContent(rawContent);
-  return dynamic ? parseMcpToolResult(content) : content;
+function resolveToolResult({ toolName, dynamic, isError, rawContent }) {
+	if (toolName === "bash") return {
+		exitCode: isError ? 1 : 0,
+		stdout: stringifyContent(rawContent)
+	};
+	if (hasNonTextContent(rawContent)) return rawContent;
+	const content = stringifyContent(rawContent);
+	return dynamic ? parseMcpToolResult(content) : content;
 }
 function parseMcpToolResult(content) {
-  try {
-    const parsed = JSON.parse(content);
-    return parsed !== null && typeof parsed === "object" ? parsed : content;
-  } catch {
-    return content;
-  }
+	try {
+		const parsed = JSON.parse(content);
+		return parsed !== null && typeof parsed === "object" ? parsed : content;
+	} catch {
+		return content;
+	}
 }
 function mapUsage(usage) {
-  if (!usage || typeof usage !== "object") return void 0;
-  const u = usage;
-  return {
-    inputTokens: {
-      total: (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0),
-      noCache: u.input_tokens ?? 0,
-      cacheRead: u.cache_read_input_tokens ?? 0,
-      cacheWrite: u.cache_creation_input_tokens ?? 0
-    },
-    outputTokens: {
-      total: u.output_tokens ?? 0,
-      text: u.output_tokens ?? 0
-    }
-  };
+	if (!usage || typeof usage !== "object") return void 0;
+	const u = usage;
+	return {
+		inputTokens: {
+			total: (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0),
+			noCache: u.input_tokens ?? 0,
+			cacheRead: u.cache_read_input_tokens ?? 0,
+			cacheWrite: u.cache_creation_input_tokens ?? 0
+		},
+		outputTokens: {
+			total: u.output_tokens ?? 0,
+			text: u.output_tokens ?? 0
+		}
+	};
 }
 function defaultUsage() {
-  return {
-    inputTokens: { total: 0, noCache: 0, cacheRead: 0, cacheWrite: 0 },
-    outputTokens: { total: 0, text: 0 }
-  };
+	return {
+		inputTokens: {
+			total: 0,
+			noCache: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		outputTokens: {
+			total: 0,
+			text: 0
+		}
+	};
 }
-
-// src/bridge/json-schema-to-zod.ts
-import { z } from "zod/v4";
+//#endregion
+//#region src/bridge/json-schema-to-zod.ts
 function jsonSchemaToZodObject(input) {
-  const schema = isJsonSchemaObject(input) ? input : {};
-  return toZodObject(schema);
+	return toZodObject(isJsonSchemaObject(input) ? input : {});
 }
 function toZodObject(schema) {
-  const object = z.object(toZodShape(schema));
-  if (schema.additionalProperties === false) return object.strict();
-  return object.catchall(
-    isJsonSchemaObject(schema.additionalProperties) ? toZodType(schema.additionalProperties) : z.unknown()
-  );
+	const object = z.object(toZodShape(schema));
+	if (schema.additionalProperties === false) return object.strict();
+	return object.catchall(isJsonSchemaObject(schema.additionalProperties) ? toZodType(schema.additionalProperties) : z.unknown());
 }
 function toZodShape(schema) {
-  if (!schema?.properties) return {};
-  const required = new Set(schema.required);
-  const shape = {};
-  for (const [key, propSchema] of Object.entries(schema.properties)) {
-    const propType = toZodType(propSchema);
-    let propertyType = required.has(key) ? propType : propType.optional();
-    if (propSchema.description) {
-      propertyType = propertyType.describe(propSchema.description);
-    }
-    shape[key] = propertyType;
-  }
-  return shape;
+	if (!schema?.properties) return {};
+	const required = new Set(schema.required);
+	const shape = {};
+	for (const [key, propSchema] of Object.entries(schema.properties)) {
+		const propType = toZodType(propSchema);
+		let propertyType = required.has(key) ? propType : propType.optional();
+		if (propSchema.description) propertyType = propertyType.describe(propSchema.description);
+		shape[key] = propertyType;
+	}
+	return shape;
 }
 function toZodType(schema) {
-  if (!schema) return z.any();
-  let zType = zodForConst(schema) ?? zodForEnum(schema) ?? zodForUnion(schema) ?? zodForType(schema);
-  if (isNullable(schema)) zType = zType.nullable();
-  if (schema.description) zType = zType.describe(schema.description);
-  return zType;
+	if (!schema) return z.any();
+	let zType = zodForConst(schema) ?? zodForEnum(schema) ?? zodForUnion(schema) ?? zodForType(schema);
+	if (isNullable(schema)) zType = zType.nullable();
+	if (schema.description) zType = zType.describe(schema.description);
+	return zType;
 }
 function zodForType(schema) {
-  const types = getNonNullTypes(schema);
-  if (types.length > 1) return z.any();
-  if (Array.isArray(schema.type) && types.length === 0) return z.null();
-  const type = types[0] ?? (schema.properties ? "object" : void 0);
-  switch (type) {
-    case "string":
-      return z.string();
-    case "number":
-      return z.number();
-    case "integer":
-      return z.number().int();
-    case "boolean":
-      return z.boolean();
-    case "array":
-      return z.array(
-        Array.isArray(schema.items) ? z.any() : toZodType(schema.items)
-      );
-    case "object":
-      return toZodObject(schema);
-    case "null":
-      return z.null();
-    default:
-      return z.any();
-  }
+	const types = getNonNullTypes(schema);
+	if (types.length > 1) return z.any();
+	if (Array.isArray(schema.type) && types.length === 0) return z.null();
+	switch (types[0] ?? (schema.properties ? "object" : void 0)) {
+		case "string": return z.string();
+		case "number": return z.number();
+		case "integer": return z.number().int();
+		case "boolean": return z.boolean();
+		case "array": return z.array(Array.isArray(schema.items) ? z.any() : toZodType(schema.items));
+		case "object": return toZodObject(schema);
+		case "null": return z.null();
+		default: return z.any();
+	}
 }
 function zodForConst(schema) {
-  if (!("const" in schema)) return void 0;
-  return isJsonLiteral(schema.const) ? z.literal(schema.const) : z.any();
+	if (!("const" in schema)) return void 0;
+	return isJsonLiteral(schema.const) ? z.literal(schema.const) : z.any();
 }
 function zodForEnum(schema) {
-  if (!Array.isArray(schema.enum)) return void 0;
-  if (!schema.enum.every(isJsonLiteral)) return z.any();
-  return zodForLiterals(schema.enum);
+	if (!Array.isArray(schema.enum)) return void 0;
+	if (!schema.enum.every(isJsonLiteral)) return z.any();
+	return zodForLiterals(schema.enum);
 }
 function zodForUnion(schema) {
-  const unionSchemas = schema.anyOf ?? schema.oneOf;
-  if (!unionSchemas || unionSchemas.length < 2) return void 0;
-  const options = unionSchemas.map((item) => toZodType(item));
-  return z.union(options);
+	const unionSchemas = schema.anyOf ?? schema.oneOf;
+	if (!unionSchemas || unionSchemas.length < 2) return void 0;
+	const options = unionSchemas.map((item) => toZodType(item));
+	return z.union(options);
 }
 function zodForLiterals(values) {
-  if (values.length === 0) return z.any();
-  if (values.length === 1) return z.literal(values[0]);
-  const literals = values.map((value) => z.literal(value));
-  return z.union(literals);
+	if (values.length === 0) return z.any();
+	if (values.length === 1) return z.literal(values[0]);
+	const literals = values.map((value) => z.literal(value));
+	return z.union(literals);
 }
 function getNonNullTypes(schema) {
-  return Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : [schema.type].filter(Boolean);
+	return Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : [schema.type].filter(Boolean);
 }
 function isNullable(schema) {
-  return schema.nullable === true || Array.isArray(schema.type) && schema.type.includes("null");
+	return schema.nullable === true || Array.isArray(schema.type) && schema.type.includes("null");
 }
 function isJsonSchemaObject(input) {
-  return input != null && typeof input === "object" && !Array.isArray(input);
+	return input != null && typeof input === "object" && !Array.isArray(input);
 }
 function isJsonLiteral(value) {
-  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+	return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
 }
-
-// src/bridge/tool-filtering.ts
-var PUBLIC_TO_NATIVE = {
-  read: "Read",
-  write: "Write",
-  edit: "Edit",
-  bash: "Bash",
-  glob: "Glob",
-  grep: "Grep",
-  webSearch: "WebSearch",
-  WebFetch: "WebFetch",
-  NotebookEdit: "NotebookEdit",
-  TodoWrite: "TodoWrite",
-  Agent: "Agent",
-  TaskCreate: "TaskCreate",
-  TaskGet: "TaskGet",
-  TaskUpdate: "TaskUpdate",
-  TaskList: "TaskList",
-  TaskStop: "TaskStop",
-  TaskOutput: "TaskOutput",
-  Monitor: "Monitor",
-  ListMcpResources: "ListMcpResources",
-  ReadMcpResource: "ReadMcpResource",
-  ExitPlanMode: "ExitPlanMode",
-  EnterWorktree: "EnterWorktree",
-  ExitWorktree: "ExitWorktree",
-  askUserQuestions: "AskUserQuestion",
-  Skill: "Skill",
-  ToolSearch: "ToolSearch"
+//#endregion
+//#region src/bridge/tool-filtering.ts
+const PUBLIC_TO_NATIVE = {
+	read: "Read",
+	write: "Write",
+	edit: "Edit",
+	bash: "Bash",
+	glob: "Glob",
+	grep: "Grep",
+	webSearch: "WebSearch",
+	WebFetch: "WebFetch",
+	NotebookEdit: "NotebookEdit",
+	TodoWrite: "TodoWrite",
+	Agent: "Agent",
+	TaskCreate: "TaskCreate",
+	TaskGet: "TaskGet",
+	TaskUpdate: "TaskUpdate",
+	TaskList: "TaskList",
+	TaskStop: "TaskStop",
+	TaskOutput: "TaskOutput",
+	Monitor: "Monitor",
+	ListMcpResources: "ListMcpResources",
+	ReadMcpResource: "ReadMcpResource",
+	ExitPlanMode: "ExitPlanMode",
+	EnterWorktree: "EnterWorktree",
+	ExitWorktree: "ExitWorktree",
+	askUserQuestions: "AskUserQuestion",
+	Skill: "Skill",
+	ToolSearch: "ToolSearch"
 };
-var PUBLIC_TOOL_NAMES = Object.keys(PUBLIC_TO_NATIVE);
+const PUBLIC_TOOL_NAMES = Object.keys(PUBLIC_TO_NATIVE);
 function toNativeName(toolName) {
-  return PUBLIC_TO_NATIVE[toolName] ?? toolName;
+	return PUBLIC_TO_NATIVE[toolName] ?? toolName;
 }
 function resolveNativeTools(toolFiltering) {
-  if (toolFiltering == null || toolFiltering.mode === "deny") return void 0;
-  return toolFiltering.toolNames.map((name) => toNativeName(name));
+	if (toolFiltering == null || toolFiltering.mode === "deny") return void 0;
+	return toolFiltering.toolNames.map((name) => toNativeName(name));
 }
 function resolveInactiveNativeTools(toolFiltering) {
-  if (toolFiltering == null) return [];
-  const inactiveToolNames = toolFiltering.mode === "allow" ? PUBLIC_TOOL_NAMES.filter(
-    (name) => !toolFiltering.toolNames.includes(name)
-  ) : toolFiltering.toolNames;
-  return inactiveToolNames.map((name) => toNativeName(name));
+	if (toolFiltering == null) return [];
+	return (toolFiltering.mode === "allow" ? PUBLIC_TOOL_NAMES.filter((name) => !toolFiltering.toolNames.includes(name)) : toolFiltering.toolNames).map((name) => toNativeName(name));
 }
-
-// src/bridge/question-tool.ts
+//#endregion
+//#region src/bridge/question-tool.ts
 function claudeCodeQuestionKey(nativeInput) {
-  return JSON.stringify(nativeInput.questions);
+	return JSON.stringify(nativeInput.questions);
 }
 function toHarnessQuestionsInput(nativeInput) {
-  return {
-    allowPartialAnswers: true,
-    questions: nativeInput.questions.map((question, questionIndex) => ({
-      id: `question-${questionIndex + 1}`,
-      question: question.question,
-      header: question.header,
-      options: question.options.map((option, optionIndex) => ({
-        id: `option-${optionIndex + 1}`,
-        label: option.label,
-        description: option.description,
-        ...option.preview !== void 0 ? { preview: option.preview } : {}
-      })),
-      allowMultiple: question.multiSelect,
-      allowFreeForm: true
-    }))
-  };
+	return {
+		allowPartialAnswers: true,
+		questions: nativeInput.questions.map((question, questionIndex) => ({
+			id: `question-${questionIndex + 1}`,
+			question: question.question,
+			header: question.header,
+			options: question.options.map((option, optionIndex) => ({
+				id: `option-${optionIndex + 1}`,
+				label: option.label,
+				description: option.description,
+				...option.preview !== void 0 ? { preview: option.preview } : {}
+			})),
+			allowMultiple: question.multiSelect,
+			allowFreeForm: true
+		}))
+	};
 }
 function toClaudeCodeQuestionResult(input) {
-  const output = input.output;
-  if (output.action === "declined" || output.action === "cancelled") {
-    return {
-      behavior: "deny",
-      message: `The user ${output.action} the questions.`
-    };
-  }
-  const canonicalInput = toHarnessQuestionsInput(input.nativeInput);
-  const answers = Object.fromEntries(
-    canonicalInput.questions.flatMap((question, questionIndex) => {
-      const answer = output.answers[question.id];
-      if (answer == null) return [];
-      const nativeQuestion = input.nativeInput.questions[questionIndex];
-      return [
-        [
-          nativeQuestion.question,
-          toClaudeCodeAnswer({
-            nativeQuestion,
-            optionIds: answer.optionIds,
-            freeform: answer.freeform
-          })
-        ]
-      ];
-    })
-  );
-  return {
-    behavior: "allow",
-    updatedInput: { ...input.nativeInput, answers }
-  };
+	const output = input.output;
+	if (output.action === "declined" || output.action === "cancelled") return {
+		behavior: "deny",
+		message: `The user ${output.action} the questions.`
+	};
+	const canonicalInput = toHarnessQuestionsInput(input.nativeInput);
+	const answers = Object.fromEntries(canonicalInput.questions.flatMap((question, questionIndex) => {
+		const answer = output.answers[question.id];
+		if (answer == null) return [];
+		const nativeQuestion = input.nativeInput.questions[questionIndex];
+		return [[nativeQuestion.question, toClaudeCodeAnswer({
+			nativeQuestion,
+			optionIds: answer.optionIds,
+			freeform: answer.freeform
+		})]];
+	}));
+	return {
+		behavior: "allow",
+		updatedInput: {
+			...input.nativeInput,
+			answers
+		}
+	};
 }
 function toClaudeCodeAnswer(input) {
-  if (input.freeform !== void 0) return input.freeform;
-  const labels = input.optionIds.flatMap((optionId) => {
-    const index = positionalIdIndex({ id: optionId, prefix: "option-" });
-    const option = index == null ? void 0 : input.nativeQuestion.options[index];
-    return option == null ? [] : [option.label];
-  });
-  return input.nativeQuestion.multiSelect ? labels.join(", ") : labels[0] ?? "";
+	if (input.freeform !== void 0) return input.freeform;
+	const labels = input.optionIds.flatMap((optionId) => {
+		const index = positionalIdIndex({
+			id: optionId,
+			prefix: "option-"
+		});
+		const option = index == null ? void 0 : input.nativeQuestion.options[index];
+		return option == null ? [] : [option.label];
+	});
+	return input.nativeQuestion.multiSelect ? labels.join(", ") : labels[0] ?? "";
 }
 function positionalIdIndex(input) {
-  if (!input.id.startsWith(input.prefix)) return void 0;
-  const oneBasedIndex = Number(input.id.slice(input.prefix.length));
-  return Number.isInteger(oneBasedIndex) && oneBasedIndex > 0 ? oneBasedIndex - 1 : void 0;
+	if (!input.id.startsWith(input.prefix)) return void 0;
+	const oneBasedIndex = Number(input.id.slice(input.prefix.length));
+	return Number.isInteger(oneBasedIndex) && oneBasedIndex > 0 ? oneBasedIndex - 1 : void 0;
 }
-
-// src/bridge/index.ts
-var NATIVE_TO_COMMON = {
-  Read: "read",
-  Write: "write",
-  Edit: "edit",
-  Bash: "bash",
-  Glob: "glob",
-  Grep: "grep",
-  WebSearch: "webSearch",
-  AskUserQuestion: "askUserQuestions"
+//#endregion
+//#region src/bridge/index.ts
+const NATIVE_TO_COMMON = {
+	Read: "read",
+	Write: "write",
+	Edit: "edit",
+	Bash: "bash",
+	Glob: "glob",
+	Grep: "grep",
+	WebSearch: "webSearch",
+	AskUserQuestion: "askUserQuestions"
 };
-var NATIVE_TOOL_KINDS = {
-  Read: "readonly",
-  Glob: "readonly",
-  Grep: "readonly",
-  WebSearch: "readonly",
-  WebFetch: "readonly",
-  TaskGet: "readonly",
-  TaskList: "readonly",
-  TaskOutput: "readonly",
-  ListMcpResources: "readonly",
-  ReadMcpResource: "readonly",
-  Write: "edit",
-  Edit: "edit",
-  NotebookEdit: "edit",
-  TodoWrite: "edit",
-  TaskCreate: "edit",
-  TaskUpdate: "edit",
-  TaskStop: "edit",
-  EnterWorktree: "edit",
-  ExitWorktree: "edit",
-  ExitPlanMode: "edit",
-  Skill: "readonly",
-  AskUserQuestion: "readonly",
-  ToolSearch: "readonly",
-  Bash: "bash",
-  Monitor: "bash"
+const NATIVE_TOOL_KINDS = {
+	Read: "readonly",
+	Glob: "readonly",
+	Grep: "readonly",
+	WebSearch: "readonly",
+	WebFetch: "readonly",
+	TaskGet: "readonly",
+	TaskList: "readonly",
+	TaskOutput: "readonly",
+	ListMcpResources: "readonly",
+	ReadMcpResource: "readonly",
+	Write: "edit",
+	Edit: "edit",
+	NotebookEdit: "edit",
+	TodoWrite: "edit",
+	TaskCreate: "edit",
+	TaskUpdate: "edit",
+	TaskStop: "edit",
+	EnterWorktree: "edit",
+	ExitWorktree: "edit",
+	ExitPlanMode: "edit",
+	Skill: "readonly",
+	AskUserQuestion: "readonly",
+	ToolSearch: "readonly",
+	Bash: "bash",
+	Monitor: "bash"
 };
 function toCommonName(nativeName) {
-  return NATIVE_TO_COMMON[nativeName] ?? nativeName;
-}
-var args = parseArgs(argv.slice(2));
-var workdir = args.workdir;
-var bridgeStateDir = args.bridgeStateDir;
-if (!workdir) {
-  emitFatal("Missing --workdir argument.");
+	return NATIVE_TO_COMMON[nativeName] ?? nativeName;
 }
-if (!bridgeStateDir) {
-  emitFatal("Missing --bridge-state-dir argument.");
-}
-var claudeSdk = claudeAgentSdk;
-var mcpModule = mcpServerModule;
-var lastClaudeSessionId;
+const args = parseArgs(argv.slice(2));
+const workdir = args.workdir;
+const bridgeStateDir = args.bridgeStateDir;
+if (!workdir) emitFatal("Missing --workdir argument.");
+if (!bridgeStateDir) emitFatal("Missing --bridge-state-dir argument.");
+const claudeSdk = claudeAgentSdk;
+const mcpModule = mcpServerModule;
+/**
+* The Claude session id most recently reported by the SDK, captured from the
+* message stream. Every turn in this bridge process may fork a new id (the
+* SDK's `continue`/`resume` create a new session linked to the previous one),
+* so the latest observation is the one a later resume must name.
+*/
+let lastClaudeSessionId;
 await runBridge({
-  bridgeType: "claude-code",
-  bridgeStateDir,
-  onStart: runTurn,
-  // Claude Code's conversation state lives in the runtime's own store, keyed
-  // by working directory. The resume payload names the exact conversation so a
-  // later resume does not have to fall back to "most recent in this workdir".
-  onStop: () => lastClaudeSessionId == null ? {} : { claudeSessionId: lastClaudeSessionId }
+	bridgeType: "claude-code",
+	bridgeStateDir,
+	onStart: runTurn,
+	onStop: () => lastClaudeSessionId == null ? {} : { claudeSessionId: lastClaudeSessionId }
 });
 function createPermissionOptions(input) {
-  const permissionMode = input.start.permissionMode ?? "allow-all";
-  const inactiveNativeTools = new Set(input.inactiveNativeTools);
-  const permissionSettings = createPermissionSettings({
-    permissionMode,
-    inactiveNativeTools
-  });
-  const baseOptions = {
-    permissionMode: permissionMode === "allow-all" ? "bypassPermissions" : permissionMode === "allow-edits" ? "acceptEdits" : "default",
-    allowDangerouslySkipPermissions: permissionMode === "allow-all",
-    ...permissionSettings ? { settings: permissionSettings } : {}
-  };
-  if (permissionMode === "allow-all") {
-    return {
-      ...baseOptions,
-      /*
-       * Claude Code exposes AskUserQuestion in headless SDK sessions only
-       * when a permission prompt tool is configured. The stdio prompt tool
-       * preserves that tool surface without supplying the canUseTool callback
-       * that bypassPermissions guarantees it will never invoke.
-       */
-      permissionPromptToolName: "stdio"
-    };
-  }
-  return {
-    ...baseOptions,
-    canUseTool: async (toolName, toolInput, options) => {
-      if (toolName.startsWith("mcp__harness-tools__")) {
-        return { behavior: "allow", updatedInput: toolInput };
-      }
-      if (!inactiveNativeTools.has(toolName) && !nativeToolRequiresApproval({
-        nativeName: toolName,
-        permissionMode
-      })) {
-        return { behavior: "allow", updatedInput: toolInput };
-      }
-      const approvalId = options.toolUseID;
-      input.approvalRequestedToolUseIds.add(approvalId);
-      input.nativeToolCallNames.set(approvalId, toolName);
-      input.emit({
-        type: "tool-call",
-        toolCallId: approvalId,
-        toolName: toCommonName(toolName),
-        nativeName: toolName,
-        input: JSON.stringify(toolInput ?? {}),
-        providerExecuted: true,
-        ...isExternalMcpTool(toolName) ? { dynamic: true } : {}
-      });
-      input.emit({
-        type: "tool-approval-request",
-        approvalId,
-        toolCallId: approvalId
-      });
-      input.finishApprovalStep(approvalId);
-      const decision = await input.turn.requestToolApproval(approvalId);
-      return decision.approved ? { behavior: "allow", updatedInput: toolInput, toolUseID: approvalId } : {
-        behavior: "deny",
-        message: decision.reason ?? "Denied",
-        toolUseID: approvalId
-      };
-    }
-  };
+	const permissionMode = input.start.permissionMode ?? "allow-all";
+	const inactiveNativeTools = new Set(input.inactiveNativeTools);
+	const permissionSettings = createPermissionSettings({
+		permissionMode,
+		inactiveNativeTools
+	});
+	const baseOptions = {
+		permissionMode: permissionMode === "allow-all" ? "bypassPermissions" : permissionMode === "allow-edits" ? "acceptEdits" : "default",
+		allowDangerouslySkipPermissions: permissionMode === "allow-all",
+		...permissionSettings ? { settings: permissionSettings } : {}
+	};
+	if (permissionMode === "allow-all") return {
+		...baseOptions,
+		permissionPromptToolName: "stdio"
+	};
+	return {
+		...baseOptions,
+		canUseTool: async (toolName, toolInput, options) => {
+			if (toolName.startsWith("mcp__harness-tools__")) return {
+				behavior: "allow",
+				updatedInput: toolInput
+			};
+			if (!inactiveNativeTools.has(toolName) && !nativeToolRequiresApproval({
+				nativeName: toolName,
+				permissionMode
+			})) return {
+				behavior: "allow",
+				updatedInput: toolInput
+			};
+			const approvalId = options.toolUseID;
+			input.approvalRequestedToolUseIds.add(approvalId);
+			input.nativeToolCallNames.set(approvalId, toolName);
+			input.emit({
+				type: "tool-call",
+				toolCallId: approvalId,
+				toolName: toCommonName(toolName),
+				nativeName: toolName,
+				input: JSON.stringify(toolInput ?? {}),
+				providerExecuted: true,
+				...isExternalMcpTool(toolName) ? { dynamic: true } : {}
+			});
+			input.emit({
+				type: "tool-approval-request",
+				approvalId,
+				toolCallId: approvalId
+			});
+			input.finishApprovalStep(approvalId);
+			const decision = await input.turn.requestToolApproval(approvalId);
+			return decision.approved ? {
+				behavior: "allow",
+				updatedInput: toolInput,
+				toolUseID: approvalId
+			} : {
+				behavior: "deny",
+				message: decision.reason ?? "Denied",
+				toolUseID: approvalId
+			};
+		}
+	};
 }
 function createQuestionPreToolUseHook(input) {
-  return async (hookInput, toolUseID) => {
-    if (hookInput.hook_event_name !== "PreToolUse" || hookInput.tool_name !== "AskUserQuestion") {
-      return {};
-    }
-    const nativeInput = hookInput.tool_input;
-    const canonicalInput = toHarnessQuestionsInput(nativeInput);
-    const toolCallId = toolUseID ?? hookInput.tool_use_id;
-    input.nativeToolCallNames.set(toolCallId, hookInput.tool_name);
-    input.emit({
-      type: "tool-call",
-      toolCallId,
-      toolName: "askUserQuestions",
-      nativeName: hookInput.tool_name,
-      input: JSON.stringify(canonicalInput),
-      providerExecuted: false,
-      providerMetadata: {
-        "claude-code": {
-          nativeRequest: nativeInput
-        }
-      }
-    });
-    const questionKey = claudeCodeQuestionKey(nativeInput);
-    const result = await input.turn.requestToolResult({
-      toolCallId,
-      matches: (candidate) => {
-        const nativeRequest = candidate.toolResult?.providerOptions?.["claude-code"]?.nativeRequest;
-        return nativeRequest != null && claudeCodeQuestionKey(nativeRequest) === questionKey;
-      }
-    });
-    const nativeResult = toClaudeCodeQuestionResult({
-      nativeInput,
-      output: result.output
-    });
-    return {
-      hookSpecificOutput: {
-        hookEventName: "PreToolUse",
-        ...nativeResult.behavior === "allow" ? {
-          permissionDecision: "allow",
-          updatedInput: {
-            ...nativeResult.updatedInput
-          }
-        } : {
-          permissionDecision: "deny",
-          permissionDecisionReason: nativeResult.message
-        }
-      }
-    };
-  };
+	return async (hookInput, toolUseID) => {
+		if (hookInput.hook_event_name !== "PreToolUse" || hookInput.tool_name !== "AskUserQuestion") return {};
+		const nativeInput = hookInput.tool_input;
+		const canonicalInput = toHarnessQuestionsInput(nativeInput);
+		const toolCallId = toolUseID ?? hookInput.tool_use_id;
+		input.nativeToolCallNames.set(toolCallId, hookInput.tool_name);
+		input.emit({
+			type: "tool-call",
+			toolCallId,
+			toolName: "askUserQuestions",
+			nativeName: hookInput.tool_name,
+			input: JSON.stringify(canonicalInput),
+			providerExecuted: false,
+			providerMetadata: { "claude-code": { nativeRequest: nativeInput } }
+		});
+		const questionKey = claudeCodeQuestionKey(nativeInput);
+		const nativeResult = toClaudeCodeQuestionResult({
+			nativeInput,
+			output: (await input.turn.requestToolResult({
+				toolCallId,
+				matches: (candidate) => {
+					const nativeRequest = candidate.toolResult?.providerOptions?.["claude-code"]?.nativeRequest;
+					return nativeRequest != null && claudeCodeQuestionKey(nativeRequest) === questionKey;
+				}
+			})).output
+		});
+		return { hookSpecificOutput: {
+			hookEventName: "PreToolUse",
+			...nativeResult.behavior === "allow" ? {
+				permissionDecision: "allow",
+				updatedInput: { ...nativeResult.updatedInput }
+			} : {
+				permissionDecision: "deny",
+				permissionDecisionReason: nativeResult.message
+			}
+		} };
+	};
 }
 function createPermissionSettings(input) {
-  const askRules = /* @__PURE__ */ new Set();
-  for (const [nativeName, kind] of Object.entries(NATIVE_TOOL_KINDS)) {
-    if (input.inactiveNativeTools.has(nativeName) || (input.permissionMode === "allow-reads" ? kind === "edit" || kind === "bash" : input.permissionMode === "allow-edits" ? kind === "bash" : false)) {
-      askRules.add(`${nativeName}(*)`);
-    }
-  }
-  if (askRules.size === 0) return void 0;
-  return {
-    permissions: { ask: [...askRules] },
-    sandbox: { autoAllowBashIfSandboxed: false }
-  };
+	const askRules = /* @__PURE__ */ new Set();
+	for (const [nativeName, kind] of Object.entries(NATIVE_TOOL_KINDS)) if (input.inactiveNativeTools.has(nativeName) || (input.permissionMode === "allow-reads" ? kind === "edit" || kind === "bash" : input.permissionMode === "allow-edits" ? kind === "bash" : false)) askRules.add(`${nativeName}(*)`);
+	if (askRules.size === 0) return void 0;
+	return {
+		permissions: { ask: [...askRules] },
+		sandbox: { autoAllowBashIfSandboxed: false }
+	};
 }
 function nativeToolRequiresApproval(input) {
-  if (input.permissionMode === "allow-all") return false;
-  const kind = NATIVE_TOOL_KINDS[input.nativeName] ?? "edit";
-  if (input.permissionMode === "allow-edits") return kind === "bash";
-  return kind === "edit" || kind === "bash";
+	if (input.permissionMode === "allow-all") return false;
+	const kind = NATIVE_TOOL_KINDS[input.nativeName] ?? "edit";
+	if (input.permissionMode === "allow-edits") return kind === "bash";
+	return kind === "edit" || kind === "bash";
 }
 async function runTurn(start, turn) {
-  const emit = (msg) => turn.emit(msg);
-  const abortCtl = new AbortController();
-  let gracefulAbort;
-  let hardAbortTimer;
-  const onHostAbort = () => {
-    if (gracefulAbort) {
-      gracefulAbort();
-    } else {
-      abortCtl.abort();
-    }
-  };
-  if (turn.abortSignal.aborted) {
-    abortCtl.abort();
-  } else {
-    turn.abortSignal.addEventListener("abort", onHostAbort, { once: true });
-  }
-  const streamEventState = createClaudeStreamEventState();
-  const mcpServers = { ...start.mcpServers };
-  if (start.tools && start.tools.length > 0) {
-    const server = new mcpModule.McpServer({
-      name: "harness-tools",
-      version: "1.0.0"
-    });
-    for (const tool of start.tools) {
-      server.registerTool(
-        tool.name,
-        {
-          description: tool.description ?? "",
-          inputSchema: jsonSchemaToZodObject(tool.inputSchema)
-        },
-        async (...handlerArgs) => {
-          const [input, extra] = handlerArgs;
-          const metadataToolCallId = extra._meta?.["claudecode/toolUseId"];
-          const toolCallId = typeof metadataToolCallId === "string" ? metadataToolCallId : randomUUID3();
-          emit({
-            type: "tool-call",
-            toolCallId,
-            toolName: tool.name,
-            input: JSON.stringify(input),
-            providerExecuted: false
-          });
-          const { output, isError } = await turn.requestToolResult(toolCallId);
-          emit({
-            type: "tool-result",
-            toolCallId,
-            toolName: tool.name,
-            result: output ?? null,
-            isError: !!isError
-          });
-          return {
-            content: [{ type: "text", text: JSON.stringify(output ?? null) }],
-            isError
-          };
-        }
-      );
-    }
-    mcpServers["harness-tools"] = {
-      type: "sdk",
-      name: "harness-tools",
-      instance: server
-    };
-  }
-  const compaction = createCompactionLatch((event) => emit(event));
-  const queryInput = createQueryInput({
-    initialUserMessage: start.prompt,
-    userMessages: turn.experimental_userMessages,
-    abortSignal: abortCtl.signal
-  });
-  const skillsOption = toClaudeSkillsOption(start.skills);
-  const nativeTools = resolveNativeTools(start.builtinToolFiltering);
-  const inactiveNativeTools = resolveInactiveNativeTools(
-    start.builtinToolFiltering
-  );
-  const permissionOptions = createPermissionOptions({
-    start,
-    inactiveNativeTools,
-    turn,
-    emit,
-    finishApprovalStep: (approvalId) => {
-      finishApprovalStep({ state: streamEventState, emit, approvalId });
-    },
-    nativeToolCallNames: streamEventState.nativeToolCallNames,
-    approvalRequestedToolUseIds: streamEventState.approvalRequestedToolUseIds
-  });
-  const questionPreToolUseHook = createQuestionPreToolUseHook({
-    turn,
-    emit,
-    nativeToolCallNames: streamEventState.nativeToolCallNames
-  });
-  const q = claudeSdk.query({
-    prompt: queryInput.input,
-    options: {
-      ...start.model ? { model: start.model } : {},
-      ...start.maxTurns !== void 0 ? { maxTurns: start.maxTurns } : {},
-      ...start.env !== void 0 ? { env: { ...procEnv2, ...start.env } } : {},
-      ...skillsOption ? { skills: skillsOption } : {},
-      ...nativeTools !== void 0 ? { tools: nativeTools } : {},
-      ...inactiveNativeTools.length > 0 ? { disallowedTools: inactiveNativeTools } : {},
-      systemPrompt: createClaudeCodeSystemPrompt(start.instructions),
-      thinking: start.thinking,
-      ...start.effort !== void 0 ? { effort: start.effort } : {},
-      ...start.responseFormat?.type === "json" && start.responseFormat.schema != null ? {
-        outputFormat: {
-          type: "json_schema",
-          schema: start.responseFormat.schema
-        }
-      } : {},
-      includePartialMessages: true,
-      // The `PostCompact` hook carries the compaction summary, which the
-      // `compact_boundary` system message does not. Latch it for the unified
-      // `compaction` event; return an empty output so compaction proceeds.
-      hooks: {
-        PreToolUse: [
-          {
-            matcher: "AskUserQuestion",
-            hooks: [questionPreToolUseHook]
-          }
-        ],
-        PostCompact: [
-          {
-            hooks: [
-              async (input) => {
-                if (typeof input?.compact_summary === "string") {
-                  compaction.onSummary(input.compact_summary);
-                }
-                return {};
-              }
-            ]
-          }
-        ]
-      },
-      // Continuation rule, most specific first.
-      //
-      // `resumeSessionId` names the exact conversation and is what a
-      // cross-process resume should use: `continue` means "most recent thread
-      // in this workdir", which silently picks the wrong one once anything
-      // else has run there. The bridge also retains the id observed during its
-      // previous query, so every later query stays pinned to that conversation
-      // even when the host detached and reattached between turns. `resume` and
-      // `continue` are mutually exclusive in the SDK.
-      //
-      // Otherwise the host can force-continue by setting `start.continue`,
-      // and turns after the first fall back to the legacy cwd-based behavior
-      // when no exact id was observed.
-      ...start.resumeSessionId ?? lastClaudeSessionId ? { resume: start.resumeSessionId ?? lastClaudeSessionId } : start.continue === true || !turn.firstTurn ? { continue: true } : {},
-      ...permissionOptions,
-      mcpServers,
-      cwd: workdir,
-      abortSignal: abortCtl.signal
-    }
-  });
-  gracefulAbort = () => {
-    hardAbortTimer = setTimeout(() => abortCtl.abort(), 5e3);
-    hardAbortTimer.unref?.();
-    void Promise.resolve().then(() => q.interrupt()).catch(() => abortCtl.abort());
-  };
-  let turnUsage;
-  let totalCostUsd;
-  let emittedTerminalError = false;
-  let emittedTerminalFinish = false;
-  const emitTerminalError = (message) => {
-    const normalized = message?.trim();
-    if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
-    streamEventState.observedTerminalError = normalized;
-    emittedTerminalError = true;
-    if (!turn.abortSignal.aborted) {
-      turn.emitError({
-        error: normalized,
-        message: "claude-code terminal error"
-      });
-    }
-    queryInput.close();
-    abortCtl.abort();
-  };
-  const emitStreamEvent = createEmitStreamEvent({
-    state: streamEventState,
-    emit,
-    emitWarning: turn.emitWarning,
-    emitTerminalError,
-    onCompactionBoundary: (boundary) => compaction.onBoundary(boundary),
-    toCommonName
-  });
-  try {
-    for await (const msg of q) {
-      if (abortCtl.signal.aborted) break;
-      const type = msg.type;
-      if (type === "command_lifecycle") {
-        queryInput.handleLifecycle(msg);
-      }
-      const sessionId = msg.session_id;
-      if (typeof sessionId === "string" && sessionId.length > 0) {
-        lastClaudeSessionId = sessionId;
-      }
-      emitStreamEvent(msg);
-      if (type === "result") {
-        if (msg.subtype === "success") {
-          if (msg.is_error) {
-            emitTerminalError(
-              msg.result?.trim() || streamEventState.observedTerminalError || (typeof msg.api_error_status === "number" ? `Claude Code reported an API error (HTTP ${msg.api_error_status})` : "Claude Code reported a failed result")
-            );
-            continue;
-          }
-          const emptyResult = !msg.result?.trim?.();
-          if (emptyResult && streamEventState.observedTerminalError) {
-            emitTerminalError(streamEventState.observedTerminalError);
-            continue;
-          }
-          const usage = msg.usage ?? msg.message?.usage;
-          const harnessUsage = mapUsage(usage);
-          if (harnessUsage) turnUsage = addUsage(turnUsage, harnessUsage);
-          if (typeof msg.total_cost_usd === "number") {
-            totalCostUsd = (totalCostUsd ?? 0) + msg.total_cost_usd;
-          }
-          if (start.responseFormat?.type === "json" && msg.structured_output !== void 0) {
-            const id = randomUUID3();
-            emit({ type: "text-start", id });
-            emit({
-              type: "text-delta",
-              id,
-              delta: JSON.stringify(msg.structured_output)
-            });
-            emit({ type: "text-end", id });
-            streamEventState.stepOpen = true;
-          }
-          if (streamEventState.stepOpen) {
-            emitFinishStep({
-              state: streamEventState,
-              emit,
-              usage: streamEventState.pendingStepUsage ?? harnessUsage
-            });
-          }
-          queryInput.observeResult();
-          if (!queryInput.hasActiveUserMessages()) {
-            queryInput.close();
-            break;
-          }
-        } else {
-          emitTerminalError(
-            (Array.isArray(msg.errors) ? msg.errors.join("\n") : void 0) || streamEventState.observedTerminalError || msg.result || "Unknown error"
-          );
-        }
-        continue;
-      }
-      if (queryInput.hasObservedResult && !queryInput.hasActiveUserMessages()) {
-        queryInput.close();
-        break;
-      }
-    }
-  } catch (err) {
-    if (!turn.abortSignal.aborted && !(abortCtl.signal.aborted && emittedTerminalError)) {
-      turn.emitError({ error: err, message: "claude-code turn failed" });
-    }
-    return;
-  } finally {
-    gracefulAbort = void 0;
-    if (hardAbortTimer != null) clearTimeout(hardAbortTimer);
-    turn.abortSignal.removeEventListener("abort", onHostAbort);
-    queryInput.close();
-    try {
-      await q.return?.(
-        void 0
-      );
-    } catch {
-    }
-  }
-  if (emittedTerminalError) return;
-  emittedTerminalFinish = true;
-  void emittedTerminalFinish;
-  emit({
-    type: "finish",
-    finishReason: { unified: "stop", raw: "stop" },
-    totalUsage: turnUsage ?? streamEventState.stepUsage ?? defaultUsage(),
-    ...totalCostUsd !== void 0 || lastClaudeSessionId !== void 0 ? {
-      harnessMetadata: {
-        "claude-code": {
-          ...totalCostUsd !== void 0 ? { costUsd: totalCostUsd } : {},
-          // The conversation this turn belongs to, resumable outside the
-          // SDK with `claude --resume <sessionId>` and captured by the
-          // adapter for exact cross-process resume.
-          ...lastClaudeSessionId !== void 0 ? { sessionId: lastClaudeSessionId } : {}
-        }
-      }
-    } : {}
-  });
+	const emit = (msg) => turn.emit(msg);
+	const abortCtl = new AbortController();
+	let gracefulAbort;
+	let hardAbortTimer;
+	const onHostAbort = () => {
+		if (gracefulAbort) gracefulAbort();
+		else abortCtl.abort();
+	};
+	if (turn.abortSignal.aborted) abortCtl.abort();
+	else turn.abortSignal.addEventListener("abort", onHostAbort, { once: true });
+	const streamEventState = createClaudeStreamEventState();
+	const mcpServers = { ...start.mcpServers };
+	if (start.tools && start.tools.length > 0) {
+		const server = new mcpModule.McpServer({
+			name: "harness-tools",
+			version: "1.0.0"
+		});
+		for (const tool of start.tools) server.registerTool(tool.name, {
+			description: tool.description ?? "",
+			inputSchema: jsonSchemaToZodObject(tool.inputSchema)
+		}, async (...handlerArgs) => {
+			const [input, extra] = handlerArgs;
+			const metadataToolCallId = extra._meta?.["claudecode/toolUseId"];
+			const toolCallId = typeof metadataToolCallId === "string" ? metadataToolCallId : randomUUID();
+			emit({
+				type: "tool-call",
+				toolCallId,
+				toolName: tool.name,
+				input: JSON.stringify(input),
+				providerExecuted: false
+			});
+			const { output, isError } = await turn.requestToolResult(toolCallId);
+			emit({
+				type: "tool-result",
+				toolCallId,
+				toolName: tool.name,
+				result: output ?? null,
+				isError: !!isError
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(output ?? null)
+				}],
+				isError
+			};
+		});
+		mcpServers["harness-tools"] = {
+			type: "sdk",
+			name: "harness-tools",
+			instance: server
+		};
+	}
+	const compaction = createCompactionLatch((event) => emit(event));
+	const queryInput = createQueryInput({
+		initialUserMessage: start.prompt,
+		userMessages: turn.experimental_userMessages,
+		abortSignal: abortCtl.signal
+	});
+	const skillsOption = toClaudeSkillsOption(start.skills);
+	const nativeTools = resolveNativeTools(start.builtinToolFiltering);
+	const inactiveNativeTools = resolveInactiveNativeTools(start.builtinToolFiltering);
+	const permissionOptions = createPermissionOptions({
+		start,
+		inactiveNativeTools,
+		turn,
+		emit,
+		finishApprovalStep: (approvalId) => {
+			finishApprovalStep({
+				state: streamEventState,
+				emit,
+				approvalId
+			});
+		},
+		nativeToolCallNames: streamEventState.nativeToolCallNames,
+		approvalRequestedToolUseIds: streamEventState.approvalRequestedToolUseIds
+	});
+	const questionPreToolUseHook = createQuestionPreToolUseHook({
+		turn,
+		emit,
+		nativeToolCallNames: streamEventState.nativeToolCallNames
+	});
+	const q = claudeSdk.query({
+		prompt: queryInput.input,
+		options: {
+			...start.model ? { model: start.model } : {},
+			...start.maxTurns !== void 0 ? { maxTurns: start.maxTurns } : {},
+			...start.agentProgressSummaries !== void 0 ? { agentProgressSummaries: start.agentProgressSummaries } : {},
+			...start.forwardSubagentText !== void 0 ? { forwardSubagentText: start.forwardSubagentText } : {},
+			...start.env !== void 0 ? { env: {
+				...env,
+				...start.env
+			} } : {},
+			...skillsOption ? { skills: skillsOption } : {},
+			...nativeTools !== void 0 ? { tools: nativeTools } : {},
+			...inactiveNativeTools.length > 0 ? { disallowedTools: inactiveNativeTools } : {},
+			systemPrompt: createClaudeCodeSystemPrompt(start.instructions),
+			thinking: start.thinking,
+			...start.effort !== void 0 ? { effort: start.effort } : {},
+			...start.responseFormat?.type === "json" && start.responseFormat.schema != null ? { outputFormat: {
+				type: "json_schema",
+				schema: start.responseFormat.schema
+			} } : {},
+			includePartialMessages: true,
+			hooks: {
+				PreToolUse: [{
+					matcher: "AskUserQuestion",
+					hooks: [questionPreToolUseHook]
+				}],
+				PostCompact: [{ hooks: [async (input) => {
+					if (typeof input?.compact_summary === "string") compaction.onSummary(input.compact_summary);
+					return {};
+				}] }]
+			},
+			...start.resumeSessionId ?? lastClaudeSessionId ? { resume: start.resumeSessionId ?? lastClaudeSessionId } : start.continue === true || !turn.firstTurn ? { continue: true } : {},
+			...permissionOptions,
+			mcpServers,
+			cwd: workdir,
+			abortSignal: abortCtl.signal
+		}
+	});
+	gracefulAbort = () => {
+		hardAbortTimer = setTimeout(() => abortCtl.abort(), 5e3);
+		hardAbortTimer.unref?.();
+		Promise.resolve().then(() => q.interrupt()).catch(() => abortCtl.abort());
+	};
+	let turnUsage;
+	let totalCostUsd;
+	let emittedTerminalError = false;
+	let emittedTerminalFinish = false;
+	const emitTerminalError = (message) => {
+		const normalized = message?.trim();
+		if (!normalized || emittedTerminalError || emittedTerminalFinish) return;
+		streamEventState.observedTerminalError = normalized;
+		emittedTerminalError = true;
+		if (!turn.abortSignal.aborted) turn.emitError({
+			error: normalized,
+			message: "claude-code terminal error"
+		});
+		queryInput.close();
+		abortCtl.abort();
+	};
+	const emitStreamEvent = createEmitStreamEvent({
+		state: streamEventState,
+		emit,
+		emitWarning: turn.emitWarning,
+		emitTerminalError,
+		onCompactionBoundary: (boundary) => compaction.onBoundary(boundary),
+		toCommonName
+	});
+	try {
+		for await (const msg of q) {
+			if (abortCtl.signal.aborted) break;
+			const type = msg.type;
+			if (type === "command_lifecycle") queryInput.handleLifecycle(msg);
+			const sessionId = msg.session_id;
+			if (typeof sessionId === "string" && sessionId.length > 0) lastClaudeSessionId = sessionId;
+			emitStreamEvent(msg);
+			if (type === "result") {
+				if (msg.subtype === "success") {
+					if (msg.is_error) {
+						emitTerminalError(msg.result?.trim() || streamEventState.observedTerminalError || (typeof msg.api_error_status === "number" ? `Claude Code reported an API error (HTTP ${msg.api_error_status})` : "Claude Code reported a failed result"));
+						continue;
+					}
+					if (!msg.result?.trim?.() && streamEventState.observedTerminalError) {
+						emitTerminalError(streamEventState.observedTerminalError);
+						continue;
+					}
+					const harnessUsage = mapUsage(msg.usage ?? msg.message?.usage);
+					if (harnessUsage) turnUsage = addUsage(turnUsage, harnessUsage);
+					if (typeof msg.total_cost_usd === "number") totalCostUsd = (totalCostUsd ?? 0) + msg.total_cost_usd;
+					if (start.responseFormat?.type === "json" && msg.structured_output !== void 0) {
+						const id = randomUUID();
+						emit({
+							type: "text-start",
+							id
+						});
+						emit({
+							type: "text-delta",
+							id,
+							delta: JSON.stringify(msg.structured_output)
+						});
+						emit({
+							type: "text-end",
+							id
+						});
+						streamEventState.stepOpen = true;
+					}
+					if (streamEventState.stepOpen) emitFinishStep({
+						state: streamEventState,
+						emit,
+						usage: streamEventState.pendingStepUsage ?? harnessUsage
+					});
+					queryInput.observeResult();
+					if (!queryInput.hasActiveUserMessages()) {
+						queryInput.close();
+						break;
+					}
+				} else emitTerminalError((Array.isArray(msg.errors) ? msg.errors.join("\n") : void 0) || streamEventState.observedTerminalError || msg.result || "Unknown error");
+				continue;
+			}
+			if (queryInput.hasObservedResult && !queryInput.hasActiveUserMessages()) {
+				queryInput.close();
+				break;
+			}
+		}
+	} catch (err) {
+		if (!turn.abortSignal.aborted && !(abortCtl.signal.aborted && emittedTerminalError)) turn.emitError({
+			error: err,
+			message: "claude-code turn failed"
+		});
+		return;
+	} finally {
+		gracefulAbort = void 0;
+		if (hardAbortTimer != null) clearTimeout(hardAbortTimer);
+		turn.abortSignal.removeEventListener("abort", onHostAbort);
+		queryInput.close();
+		try {
+			await q.return?.(void 0);
+		} catch {}
+	}
+	if (emittedTerminalError) return;
+	emittedTerminalFinish = true;
+	emit({
+		type: "finish",
+		finishReason: {
+			unified: "stop",
+			raw: "stop"
+		},
+		totalUsage: turnUsage ?? streamEventState.stepUsage ?? defaultUsage(),
+		...totalCostUsd !== void 0 || lastClaudeSessionId !== void 0 ? { harnessMetadata: { "claude-code": {
+			...totalCostUsd !== void 0 ? { costUsd: totalCostUsd } : {},
+			...lastClaudeSessionId !== void 0 ? { sessionId: lastClaudeSessionId } : {}
+		} } } : {}
+	});
 }
-function createQueryInput({
-  initialUserMessage,
-  userMessages,
-  abortSignal
-}) {
-  let closed = false;
-  let observedResult = false;
-  const submittedMessages = /* @__PURE__ */ new Map();
-  const close = (error) => {
-    if (closed) return;
-    closed = true;
-    userMessages.close(error);
-  };
-  if (abortSignal.aborted) {
-    close(abortSignal.reason);
-  } else {
-    abortSignal.addEventListener("abort", () => close(abortSignal.reason), {
-      once: true
-    });
-  }
-  const toUserMessage = (options) => ({
-    type: "user",
-    message: {
-      role: "user",
-      content: [{ type: "text", text: options.text }]
-    },
-    parent_tool_use_id: null,
-    uuid: options.messageId,
-    ...options.priority == null ? {} : { priority: options.priority }
-  });
-  const messageIterator = userMessages[Symbol.asyncIterator]();
-  return {
-    close,
-    handleLifecycle: (message) => {
-      const lifecycle = message;
-      if (lifecycle.command_uuid == null || lifecycle.state == null) return;
-      const submitted = submittedMessages.get(lifecycle.command_uuid);
-      if (submitted == null) return;
-      if (lifecycle.state === "queued" || lifecycle.state === "started") {
-        submitted.accept();
-        return;
-      }
-      if (lifecycle.state === "cancelled" || lifecycle.state === "discarded") {
-        submitted.reject(
-          new Error(`Claude Code ${lifecycle.state} the user message.`)
-        );
-      }
-      submittedMessages.delete(lifecycle.command_uuid);
-    },
-    hasActiveUserMessages: () => submittedMessages.size > 0 || userMessages.pendingCount > 0,
-    observeResult: () => {
-      observedResult = true;
-    },
-    get hasObservedResult() {
-      return observedResult;
-    },
-    input: {
-      [Symbol.asyncIterator]() {
-        let sentInitial = false;
-        return {
-          async next() {
-            if (closed || abortSignal.aborted) {
-              return {
-                value: void 0,
-                done: true
-              };
-            }
-            if (!sentInitial) {
-              sentInitial = true;
-              return {
-                value: toUserMessage({
-                  text: initialUserMessage,
-                  messageId: randomUUID3()
-                }),
-                done: false
-              };
-            }
-            const nextMessage = await messageIterator.next();
-            if (nextMessage.done) {
-              return {
-                value: void 0,
-                done: true
-              };
-            }
-            submittedMessages.set(
-              nextMessage.value.messageId,
-              nextMessage.value
-            );
-            return {
-              value: toUserMessage({
-                text: nextMessage.value.text,
-                messageId: nextMessage.value.messageId,
-                priority: "next"
-              }),
-              done: false
-            };
-          }
-        };
-      }
-    }
-  };
+function createQueryInput({ initialUserMessage, userMessages, abortSignal }) {
+	let closed = false;
+	let observedResult = false;
+	const submittedMessages = /* @__PURE__ */ new Map();
+	const close = (error) => {
+		if (closed) return;
+		closed = true;
+		userMessages.close(error);
+	};
+	if (abortSignal.aborted) close(abortSignal.reason);
+	else abortSignal.addEventListener("abort", () => close(abortSignal.reason), { once: true });
+	const toUserMessage = (options) => ({
+		type: "user",
+		message: {
+			role: "user",
+			content: [{
+				type: "text",
+				text: options.text
+			}]
+		},
+		parent_tool_use_id: null,
+		uuid: options.messageId,
+		...options.priority == null ? {} : { priority: options.priority }
+	});
+	const messageIterator = userMessages[Symbol.asyncIterator]();
+	return {
+		close,
+		handleLifecycle: (message) => {
+			const lifecycle = message;
+			if (lifecycle.command_uuid == null || lifecycle.state == null) return;
+			const submitted = submittedMessages.get(lifecycle.command_uuid);
+			if (submitted == null) return;
+			if (lifecycle.state === "queued" || lifecycle.state === "started") {
+				submitted.accept();
+				return;
+			}
+			if (lifecycle.state === "cancelled" || lifecycle.state === "discarded") submitted.reject(/* @__PURE__ */ new Error(`Claude Code ${lifecycle.state} the user message.`));
+			submittedMessages.delete(lifecycle.command_uuid);
+		},
+		hasActiveUserMessages: () => submittedMessages.size > 0 || userMessages.pendingCount > 0,
+		observeResult: () => {
+			observedResult = true;
+		},
+		get hasObservedResult() {
+			return observedResult;
+		},
+		input: { [Symbol.asyncIterator]() {
+			let sentInitial = false;
+			return { async next() {
+				if (closed || abortSignal.aborted) return {
+					value: void 0,
+					done: true
+				};
+				if (!sentInitial) {
+					sentInitial = true;
+					return {
+						value: toUserMessage({
+							text: initialUserMessage,
+							messageId: randomUUID()
+						}),
+						done: false
+					};
+				}
+				const nextMessage = await messageIterator.next();
+				if (nextMessage.done) return {
+					value: void 0,
+					done: true
+				};
+				submittedMessages.set(nextMessage.value.messageId, nextMessage.value);
+				return {
+					value: toUserMessage({
+						text: nextMessage.value.text,
+						messageId: nextMessage.value.messageId,
+						priority: "next"
+					}),
+					done: false
+				};
+			} };
+		} }
+	};
 }
 function addUsage(total, usage) {
-  if (total == null) return usage;
-  const result = { ...total };
-  for (const [key, value] of Object.entries(usage)) {
-    const previous = result[key];
-    if (typeof value === "number" && typeof previous === "number") {
-      result[key] = previous + value;
-    } else if (value != null && previous != null && typeof value === "object" && typeof previous === "object" && !Array.isArray(value) && !Array.isArray(previous)) {
-      result[key] = addUsage(
-        previous,
-        value
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
+	if (total == null) return usage;
+	const result = { ...total };
+	for (const [key, value] of Object.entries(usage)) {
+		const previous = result[key];
+		if (typeof value === "number" && typeof previous === "number") result[key] = previous + value;
+		else if (value != null && previous != null && typeof value === "object" && typeof previous === "object" && !Array.isArray(value) && !Array.isArray(previous)) result[key] = addUsage(previous, value);
+		else result[key] = value;
+	}
+	return result;
 }
-function parseArgs(args2) {
-  const out = {};
-  for (let i = 0; i < args2.length; i++) {
-    if (args2[i] === "--workdir" && i + 1 < args2.length) {
-      out.workdir = args2[++i];
-    } else if (args2[i] === "--bridge-state-dir" && i + 1 < args2.length) {
-      out.bridgeStateDir = args2[++i];
-    }
-  }
-  return out;
+function parseArgs(args) {
+	const out = {};
+	for (let i = 0; i < args.length; i++) if (args[i] === "--workdir" && i + 1 < args.length) out.workdir = args[++i];
+	else if (args[i] === "--bridge-state-dir" && i + 1 < args.length) out.bridgeStateDir = args[++i];
+	return out;
 }
 function emitFatal(message) {
-  stdout2.write(JSON.stringify({ type: "bridge-fatal", message }) + "\n");
-  process.exit(1);
+	stdout.write(JSON.stringify({
+		type: "bridge-fatal",
+		message
+	}) + "\n");
+	process.exit(1);
 }
+//#endregion
+export {};
+
 //# sourceMappingURL=index.mjs.map