weacpx 0.6.1 → 0.8.0

package/dist/bridge/bridge-main.js

@@ -1,2120 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __promiseAll = (args) => Promise.all(args);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/transport/acpx-bridge/acpx-bridge-protocol.ts
-function encodeBridgeRequest(request) {
-  return `${JSON.stringify(request)}
-`;
-}
-function encodeBridgePromptSegmentEvent(event) {
-  return `${JSON.stringify(event)}
-`;
-}
-function encodeBridgePromptToolEvent(event) {
-  return `${JSON.stringify(event)}
-`;
-}
-function encodeBridgePromptThoughtEvent(event) {
-  return `${JSON.stringify(event)}
-`;
-}
-function encodeBridgeSessionProgressEvent(event) {
-  return `${JSON.stringify(event)}
-`;
-}
-function encodeBridgeSessionNoteEvent(event) {
-  return `${JSON.stringify(event)}
-`;
-}
-
-// src/transport/prompt-output.ts
-function getPromptText(result) {
-  const stdoutOutput = extractPromptOutput(result.stdout);
-  if (result.code === 0) {
-    return sanitizePromptText(stdoutOutput.text);
-  }
-  const preferredError = extractPromptFailureMessage(result);
-  if (preferredError) {
-    throw new PromptCommandError(preferredError, result);
-  }
-  const stderrOutput = extractPromptOutput(result.stderr);
-  const partialReply = [stdoutOutput, stderrOutput].filter((output) => output.hasAgentMessage && output.text.length > 0).map((output) => sanitizePromptText(output.text)).find((text) => text.length > 0);
-  if (partialReply) {
-    return partialReply;
-  }
-  throw new PromptCommandError(`command failed with exit code ${result.code}`, result);
-}
-function normalizeCommandError(result) {
-  const preferredError = extractPromptFailureMessage(result);
-  if (preferredError) {
-    return preferredError;
-  }
-  return result.stdout.trim() || null;
-}
-function extractPromptFailureMessage(result) {
-  const rpcMessages = extractJsonRpcErrorMessages(result.stderr).concat(extractJsonRpcErrorMessages(result.stdout)).filter((message) => message.length > 0);
-  const preferredMessage = [...rpcMessages].reverse().find((message) => message !== "Resource not found");
-  if (preferredMessage) {
-    return preferredMessage;
-  }
-  if (rpcMessages.length > 0) {
-    return rpcMessages[rpcMessages.length - 1] ?? null;
-  }
-  const stderrText = result.stderr.trim();
-  if (stderrText.length > 0) {
-    return stderrText;
-  }
-  return null;
-}
-function extractPromptOutput(output) {
-  const lines = output.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0);
-  let text = "";
-  let hasAgentMessage = false;
-  for (const line of lines) {
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    const isMessageChunk = event.method === "session/update" && event.params?.update?.sessionUpdate === "agent_message_chunk" && event.params.update.content?.type === "text" && typeof event.params.update.content.text === "string";
-    if (isMessageChunk) {
-      hasAgentMessage = true;
-      text += event.params.update.content.text ?? "";
-    }
-  }
-  if (hasAgentMessage && text.trim().length > 0) {
-    return {
-      text: text.trim(),
-      hasAgentMessage
-    };
-  }
-  return {
-    text: output.trim(),
-    hasAgentMessage
-  };
-}
-function sanitizePromptText(text) {
-  const trimmed = text.trim();
-  const paragraphs = trimmed.split(/\n\s*\n/);
-  if (paragraphs.length < 2) {
-    return trimmed;
-  }
-  const firstParagraph = paragraphs[0].trim().replace(/\s+/g, " ").toLowerCase();
-  if (!looksLikeWorkflowPreamble(firstParagraph)) {
-    return trimmed;
-  }
-  return paragraphs.slice(1).join(`
-
-`).trim();
-}
-function looksLikeWorkflowPreamble(paragraph) {
-  if (!paragraph.startsWith("using ")) {
-    return false;
-  }
-  return paragraph.includes("using-superpowers") || paragraph.includes("repo workflow requirement") || paragraph.includes("workflow requirement") || paragraph.includes("before responding") || paragraph.includes("skill check");
-}
-function extractJsonRpcErrorMessages(output) {
-  return output.split(`
-`).map((line) => line.trim()).filter((line) => line.length > 0).flatMap((line) => {
-    try {
-      const payload = JSON.parse(line);
-      const err = payload.error;
-      const dataMsg = typeof err?.data?.message === "string" && err.data.message.length > 0 ? err.data.message : undefined;
-      const baseMsg = typeof err?.message === "string" && err.message.length > 0 ? err.message : undefined;
-      const chosen = dataMsg && dataMsg !== baseMsg ? dataMsg : baseMsg;
-      if (chosen) {
-        return [chosen];
-      }
-    } catch {
-      return [];
-    }
-    return [];
-  });
-}
-var PromptCommandError;
-var init_prompt_output = __esm(() => {
-  PromptCommandError = class PromptCommandError extends Error {
-    exitCode;
-    stdout;
-    stderr;
-    constructor(message, result) {
-      super(message);
-      this.name = "PromptCommandError";
-      this.exitCode = result.code;
-      this.stdout = result.stdout;
-      this.stderr = result.stderr;
-    }
-  };
-});
-
-// src/process/spawn-command.ts
-function resolveSpawnCommand(command, args) {
-  if (SCRIPT_FILE_PATTERN.test(command)) {
-    return {
-      command: process.execPath,
-      args: [command, ...args]
-    };
-  }
-  return { command, args };
-}
-var SCRIPT_FILE_PATTERN;
-var init_spawn_command = __esm(() => {
-  SCRIPT_FILE_PATTERN = /\.(c|m)?js$/i;
-});
-
-// src/transport/prompt-media.ts
-import { mkdtemp, open, rm, writeFile } from "node:fs/promises";
-import { tmpdir as defaultTmpdir } from "node:os";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-async function createStructuredPromptFile(text, media, deps = defaultStructuredPromptFileDeps) {
-  const mediaList = normalizePromptMedia(media);
-  if (mediaList.length === 0) {
-    return null;
-  }
-  const blocks = [];
-  if (text.trim().length > 0) {
-    blocks.push({ type: "text", text });
-  }
-  const nonImages = mediaList.filter((item) => item.type !== "image");
-  if (nonImages.length > 0) {
-    blocks.push({ type: "text", text: buildAttachmentSummary(nonImages) });
-  }
-  for (const item of mediaList) {
-    if (item.type === "image") {
-      const imageData = await deps.readImageFile(item.filePath, MAX_STRUCTURED_IMAGE_BYTES);
-      if (imageData.byteLength === 0)
-        throw new Error("image prompt must not be empty");
-      if (imageData.byteLength > MAX_STRUCTURED_IMAGE_BYTES) {
-        throw new Error(`image prompt exceeds ${MAX_STRUCTURED_IMAGE_BYTES} bytes`);
-      }
-      blocks.push({
-        type: "image",
-        mimeType: resolveImageMimeType(imageData, item.mimeType),
-        data: imageData.toString("base64")
-      });
-      continue;
-    }
-    blocks.push({
-      type: "resource",
-      resource: {
-        uri: pathToFileURL(item.filePath).toString(),
-        text: `${item.fileName ?? path.basename(item.filePath)} ${item.mimeType} ${item.type}`
-      }
-    });
-  }
-  return await writeStructuredPromptBlocks(blocks, deps);
-}
-function normalizePromptMedia(media) {
-  if (!media)
-    return [];
-  return Array.isArray(media) ? media : [media];
-}
-function buildAttachmentSummary(items) {
-  const lines = ["Attachments available as local files:"];
-  for (const [index, item] of items.entries()) {
-    lines.push(`${index + 1}. ${item.type} ${item.fileName ?? path.basename(item.filePath)} ${item.mimeType} ${item.filePath}`);
-  }
-  return lines.join(`
-`);
-}
-async function writeStructuredPromptBlocks(blocks, deps) {
-  let dir = "";
-  try {
-    dir = await deps.mkdtemp(path.join(deps.tmpdir(), "weacpx-acp-prompt-"));
-    const filePath = path.join(dir, "prompt.json");
-    await deps.writeFile(filePath, JSON.stringify(blocks), "utf8");
-    return { filePath, cleanup: async () => deps.rm(dir, { recursive: true, force: true }) };
-  } catch (error) {
-    if (dir)
-      await deps.rm(dir, { recursive: true, force: true }).catch(() => {});
-    throw error;
-  }
-}
-async function readImageFileBounded(filePath, maxBytes) {
-  const handle = await open(filePath, "r");
-  try {
-    const imageStats = await handle.stat();
-    if (!imageStats.isFile()) {
-      throw new Error("image prompt path must be a regular file");
-    }
-    if (imageStats.size > maxBytes) {
-      throw new Error(`image prompt exceeds ${maxBytes} bytes`);
-    }
-    const chunks = [];
-    let total = 0;
-    let position = 0;
-    const chunkSize = 1024 * 1024;
-    while (total <= maxBytes) {
-      const buffer = Buffer.allocUnsafe(Math.min(chunkSize, maxBytes + 1 - total));
-      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
-      if (bytesRead === 0)
-        break;
-      chunks.push(buffer.subarray(0, bytesRead));
-      total += bytesRead;
-      position += bytesRead;
-    }
-    return Buffer.concat(chunks, total);
-  } finally {
-    await handle.close();
-  }
-}
-function resolveImageMimeType(buffer, declaredMimeType) {
-  if (/^image\/[A-Za-z0-9.+-]+$/.test(declaredMimeType) && declaredMimeType !== "image/*") {
-    return declaredMimeType;
-  }
-  if (buffer.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex"))) {
-    return "image/png";
-  }
-  if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
-    return "image/jpeg";
-  }
-  const header6 = buffer.subarray(0, 6).toString("ascii");
-  if (header6 === "GIF87a" || header6 === "GIF89a") {
-    return "image/gif";
-  }
-  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
-    return "image/webp";
-  }
-  if (buffer.length >= 2 && buffer.subarray(0, 2).toString("ascii") === "BM") {
-    return "image/bmp";
-  }
-  return "image/png";
-}
-var MAX_STRUCTURED_IMAGE_BYTES, defaultStructuredPromptFileDeps;
-var init_prompt_media = __esm(() => {
-  MAX_STRUCTURED_IMAGE_BYTES = 100 * 1024 * 1024;
-  defaultStructuredPromptFileDeps = {
-    readImageFile: readImageFileBounded,
-    mkdtemp,
-    writeFile,
-    rm,
-    tmpdir: defaultTmpdir
-  };
-});
-
-// src/transport/tool-event-mode.ts
-function resolveToolEventMode(input) {
-  if (input?.toolEventMode !== undefined) {
-    return input.toolEventMode;
-  }
-  if (input?.onToolEvent !== undefined) {
-    return "structured";
-  }
-  return "text";
-}
-
-// src/transport/tool-kind-emoji.ts
-var TOOL_KIND_EMOJI, DEFAULT_TOOL_EMOJI;
-var init_tool_kind_emoji = __esm(() => {
-  TOOL_KIND_EMOJI = {
-    read: "\uD83D\uDCD6",
-    search: "\uD83D\uDD0D",
-    execute: "\uD83D\uDCBB",
-    edit: "✏️",
-    think: "\uD83E\uDDE0",
-    other: "\uD83D\uDD27"
-  };
-  DEFAULT_TOOL_EMOJI = TOOL_KIND_EMOJI.other;
-});
-
-// src/transport/streaming-prompt.ts
-function createStreamingPromptState(formatToolCalls = false, options) {
-  let toolEventMode;
-  let onToolEvent;
-  let onThought;
-  if (options === undefined) {
-    toolEventMode = "text";
-    onToolEvent = undefined;
-  } else if (typeof options === "function") {
-    onToolEvent = options;
-    toolEventMode = "structured";
-  } else {
-    onToolEvent = options.onToolEvent;
-    onThought = options.onThought;
-    toolEventMode = resolveToolEventMode({
-      toolEventMode: options.mode,
-      onToolEvent
-    });
-  }
-  return {
-    buffer: "",
-    segments: [],
-    hasAgentMessage: false,
-    pendingLine: "",
-    formatToolCalls,
-    emittedToolCallIds: new Set,
-    toolEventMode,
-    onToolEvent,
-    onThought,
-    finalize() {
-      if (this.pendingLine.trim().length > 0) {
-        parseStreamingChunks(this, this.pendingLine);
-      }
-      const remaining = this.buffer.trim();
-      this.buffer = "";
-      this.pendingLine = "";
-      return remaining;
-    }
-  };
-}
-function parseStreamingDataChunk(state, chunk) {
-  state.pendingLine += chunk;
-  let boundary;
-  while ((boundary = state.pendingLine.indexOf(`
-`)) !== -1) {
-    const line = state.pendingLine.slice(0, boundary);
-    state.pendingLine = state.pendingLine.slice(boundary + 1);
-    parseStreamingChunks(state, line);
-  }
-}
-function parseStreamingChunks(state, line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0)
-    return;
-  let event;
-  try {
-    event = JSON.parse(trimmed);
-  } catch {
-    return;
-  }
-  if (event.method !== "session/update")
-    return;
-  const update = event.params?.update;
-  if (!update)
-    return;
-  if (state.formatToolCalls && (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update")) {
-    const wantsStructured = state.toolEventMode === "structured" || state.toolEventMode === "both";
-    const wantsText = state.toolEventMode === "text" || state.toolEventMode === "both";
-    if (wantsStructured && state.onToolEvent) {
-      const toolEvent = buildToolUseEvent(update);
-      if (toolEvent)
-        state.onToolEvent(toolEvent);
-    }
-    if (wantsText) {
-      const formatted = formatToolCallEvent(update, update.sessionUpdate);
-      if (formatted) {
-        const toolCallId = update.toolCallId;
-        if (toolCallId) {
-          if (state.emittedToolCallIds.has(toolCallId))
-            return;
-          state.emittedToolCallIds.add(toolCallId);
-        }
-        state.segments.push(formatted);
-      }
-    }
-    return;
-  }
-  const isThoughtChunk = update.sessionUpdate === "agent_thought_chunk" && update.content?.type === "text" && typeof update.content.text === "string";
-  if (isThoughtChunk) {
-    const chunk2 = update.content.text;
-    if (chunk2.length > 0) {
-      state.onThought?.(chunk2);
-    }
-    return;
-  }
-  const isMessageChunk = update.sessionUpdate === "agent_message_chunk" && update.content?.type === "text" && typeof update.content.text === "string";
-  if (!isMessageChunk)
-    return;
-  state.hasAgentMessage = true;
-  const chunk = update.content.text ?? "";
-  if (chunk.length === 0)
-    return;
-  state.buffer += chunk;
-  let boundary;
-  while ((boundary = state.buffer.indexOf(`
-
-`)) !== -1) {
-    const segment = state.buffer.slice(0, boundary).trim();
-    state.buffer = state.buffer.slice(boundary + 2);
-    if (segment.length > 0) {
-      state.segments.push(segment);
-    }
-  }
-}
-function formatToolCallEvent(update, sessionUpdate) {
-  if (!update)
-    return null;
-  const kind = update.kind ?? "";
-  const title = update.title ?? "";
-  if (title.length === 0)
-    return null;
-  const emoji = TOOL_KIND_EMOJI[kind] ?? DEFAULT_TOOL_EMOJI;
-  const inputSummary = summarizeToolInput(update.rawInput, title) || summarizeToolInput(update.rawOutput, title);
-  const status = readString(update, "status");
-  if (!inputSummary && status === "pending")
-    return null;
-  if (!inputSummary && isGenericToolTitle(kind, title))
-    return null;
-  const summaryText = inputSummary && inputSummary !== title ? `: ${truncateToolDisplay(inputSummary)}` : "";
-  const statusText = status ? ` (${status})` : "";
-  return `${emoji} ${title}${statusText}${summaryText}`;
-}
-function buildToolUseEvent(update) {
-  if (!update)
-    return null;
-  const toolCallId = update.toolCallId;
-  if (!toolCallId)
-    return null;
-  const kindRaw = update.kind ?? "";
-  const kind = (() => {
-    switch (kindRaw) {
-      case "read":
-      case "search":
-      case "execute":
-      case "edit":
-      case "think":
-        return kindRaw;
-      default:
-        return "other";
-    }
-  })();
-  const title = (update.title ?? "").trim();
-  const toolName = title || "Tool";
-  const summaryRaw = summarizeToolInput(update.rawInput, title) || summarizeToolInput(update.rawOutput, title);
-  const summary = summaryRaw && summaryRaw !== title ? summaryRaw : undefined;
-  const statusRaw = readString(update, "status");
-  const status = statusRaw === "completed" || statusRaw === "success" ? "success" : statusRaw === "failed" || statusRaw === "error" ? "error" : "running";
-  const rawInput = update.rawInput;
-  const content = update.content;
-  const rawOutput = update.rawOutput;
-  const locations = update.locations;
-  return {
-    toolCallId,
-    toolName,
-    kind,
-    ...summary ? { summary } : {},
-    ...rawInput !== undefined ? { rawInput } : {},
-    ...content !== undefined ? { content } : {},
-    ...rawOutput !== undefined ? { rawOutput } : {},
-    ...locations !== undefined ? { locations } : {},
-    status
-  };
-}
-function summarizeToolInput(rawInput, title = "") {
-  if (rawInput == null)
-    return;
-  if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") {
-    return String(rawInput);
-  }
-  if (!isRecord(rawInput))
-    return;
-  const taskSummary = summarizeTaskInput(rawInput, title);
-  if (taskSummary)
-    return taskSummary;
-  const command = readFirstString(rawInput, ["command", "cmd", "program"]);
-  const args = readFirstStringArray(rawInput, ["args", "arguments"]);
-  if (command) {
-    return [command, ...args ?? []].join(" ");
-  }
-  const parsedCmd = rawInput.parsed_cmd;
-  if (Array.isArray(parsedCmd) && parsedCmd.length > 0) {
-    const parts = [];
-    for (const entry of parsedCmd) {
-      if (isRecord(entry) && typeof entry.cmd === "string" && entry.cmd.length > 0) {
-        parts.push(entry.cmd);
-      }
-    }
-    if (parts.length > 0) {
-      return parts.join(" ");
-    }
-  }
-  return readFirstString(rawInput, [
-    "path",
-    "file",
-    "filePath",
-    "filepath",
-    "file_path",
-    "target",
-    "uri",
-    "url",
-    "query",
-    "pattern",
-    "text",
-    "search",
-    "name",
-    "description"
-  ]);
-}
-function summarizeTaskInput(rawInput, title) {
-  const subagentType = readFirstString(rawInput, ["subagent_type", "subagentType", "agent", "agentType"]);
-  const description = readFirstString(rawInput, ["description", "task", "summary"]);
-  if (subagentType && description) {
-    return description === title ? subagentType : `${subagentType}: ${description}`;
-  }
-  if (subagentType)
-    return subagentType;
-  return;
-}
-function readFirstString(record, keys) {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return value.trim();
-    }
-  }
-  return;
-}
-function readFirstStringArray(record, keys) {
-  for (const key of keys) {
-    const value = record[key];
-    if (!Array.isArray(value))
-      continue;
-    const entries = value.map((entry) => typeof entry === "string" && entry.trim().length > 0 ? entry.trim() : undefined).filter((entry) => entry !== undefined);
-    if (entries.length > 0) {
-      return entries;
-    }
-  }
-  return;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readString(rawInput, key) {
-  if (!isRecord(rawInput))
-    return;
-  const value = rawInput[key];
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function truncateToolDisplay(text) {
-  return text.length > 60 ? `${text.slice(0, 57)}...` : text;
-}
-function isGenericToolTitle(kind, title) {
-  const normalizedTitle = title.trim().toLowerCase();
-  if (kind === "execute" && ["bash", "shell", "sh", "powershell", "cmd"].includes(normalizedTitle)) {
-    return true;
-  }
-  if (kind === "search" && ["grep", "rg", "search"].includes(normalizedTitle)) {
-    return true;
-  }
-  if (kind === "read" && ["read", "cat"].includes(normalizedTitle)) {
-    return true;
-  }
-  return false;
-}
-var init_streaming_prompt = __esm(() => {
-  init_tool_kind_emoji();
-});
-
-// src/recovery/discover-parent-package-paths.ts
-import { spawn } from "node:child_process";
-import { createRequire as createRequire2 } from "node:module";
-import { access } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-function deriveParentPackageName(platformPackage) {
-  return platformPackage.replace(/-(?:linux|darwin|win32|windows|freebsd|openbsd|sunos|aix)(?:-(?:x64|arm64|ia32|arm|ppc64|s390x))?(?:-(?:baseline|musl|gnu|gnueabihf|musleabihf|msvc))?$/, "");
-}
-async function discoverParentPackagePaths(platformPackage, seedPath, deps = {}) {
-  const env = deps.env ?? process.env;
-  const home = deps.home ?? homedir();
-  const cwd = deps.cwd ?? process.cwd();
-  const fsExists = deps.fsExists ?? defaultFsExists;
-  const resolveFromCwd = deps.resolveFromCwd ?? defaultResolveFromCwd;
-  const queryRoot = deps.queryPackageManagerRoot ?? defaultQueryPackageManagerRoot;
-  const parentName = deriveParentPackageName(platformPackage);
-  const rawCandidates = [];
-  const bunGlobalRoot = env.BUN_INSTALL ? join(env.BUN_INSTALL, "install", "global", "node_modules") : join(home, ".bun", "install", "global", "node_modules");
-  const [npmRoot, pnpmRoot, yarnRoot] = await Promise.all([
-    queryRoot("npm"),
-    queryRoot("pnpm"),
-    queryRoot("yarn")
-  ]);
-  const classify = (p) => {
-    if (isUnder(p, bunGlobalRoot))
-      return "bun";
-    if (pnpmRoot && isUnder(p, pnpmRoot))
-      return "pnpm";
-    if (yarnRoot && isUnder(p, yarnRoot))
-      return "yarn";
-    return "npm";
-  };
-  if (seedPath) {
-    rawCandidates.push({ path: seedPath, manager: classify(seedPath) });
-  }
-  for (const name of [parentName, platformPackage]) {
-    const resolved = resolveFromCwd(name, cwd);
-    if (resolved)
-      rawCandidates.push({ path: resolved, manager: classify(resolved) });
-  }
-  rawCandidates.push({ path: join(bunGlobalRoot, parentName), manager: "bun" });
-  if (npmRoot)
-    rawCandidates.push({ path: join(npmRoot, parentName), manager: "npm" });
-  if (pnpmRoot)
-    rawCandidates.push({ path: join(pnpmRoot, parentName), manager: "pnpm" });
-  if (yarnRoot)
-    rawCandidates.push({ path: join(yarnRoot, parentName), manager: "yarn" });
-  const seen = new Set;
-  const verified = [];
-  for (const candidate of rawCandidates) {
-    if (seen.has(candidate.path))
-      continue;
-    seen.add(candidate.path);
-    if (await fsExists(join(candidate.path, "package.json"))) {
-      verified.push(candidate);
-    }
-  }
-  return verified;
-}
-function isUnder(child, parent) {
-  const c = child.replace(/[\\/]+$/, "");
-  const p = parent.replace(/[\\/]+$/, "");
-  return c === p || c.startsWith(p + "/") || c.startsWith(p + "\\");
-}
-async function defaultFsExists(path2) {
-  try {
-    await access(path2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function defaultResolveFromCwd(name, cwd) {
-  try {
-    const pkgJson = require2.resolve(`${name}/package.json`, {
-      paths: [cwd, ...require2.resolve.paths(name) ?? []]
-    });
-    return dirname(pkgJson);
-  } catch {
-    return null;
-  }
-}
-async function defaultQueryPackageManagerRoot(tool) {
-  const spec = tool === "yarn" ? { cmd: "yarn", args: ["global", "dir"], postfix: "node_modules" } : { cmd: tool, args: ["root", "-g"], postfix: null };
-  return await new Promise((resolve) => {
-    let settled = false;
-    const done = (value) => {
-      if (settled)
-        return;
-      settled = true;
-      resolve(value);
-    };
-    let child;
-    try {
-      child = spawn(spec.cmd, spec.args, {
-        stdio: ["ignore", "pipe", "pipe"],
-        shell: process.platform === "win32"
-      });
-    } catch {
-      done(null);
-      return;
-    }
-    let stdout = "";
-    const timer = setTimeout(() => {
-      try {
-        child.kill();
-      } catch {}
-      done(null);
-    }, 2000);
-    timer.unref?.();
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.on("error", () => {
-      clearTimeout(timer);
-      done(null);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      if (code !== 0)
-        return done(null);
-      const trimmed = stdout.trim().split(/\r?\n/).pop()?.trim() ?? "";
-      if (!trimmed)
-        return done(null);
-      done(spec.postfix ? join(trimmed, spec.postfix) : trimmed);
-    });
-  });
-}
-var require2;
-var init_discover_parent_package_paths = __esm(() => {
-  require2 = createRequire2(import.meta.url);
-});
-
-// src/process/terminate-process-tree.ts
-import { spawn as spawn2 } from "node:child_process";
-async function terminateProcessTree(pid, options = {}, platform = process.platform, runCommand = defaultRunProcessCommand, killProcess = (targetPid, signal) => {
-  process.kill(targetPid, signal);
-}, isProcessRunning = defaultIsProcessRunning) {
-  if (pid <= 0) {
-    return;
-  }
-  if (platform === "win32") {
-    try {
-      await runCommand("taskkill", ["/PID", String(pid), "/T", "/F"]);
-    } catch {}
-    return;
-  }
-  const targetPid = options.detachedProcessGroup ? -pid : pid;
-  try {
-    killProcess(targetPid, "SIGTERM");
-  } catch {
-    return;
-  }
-  const deadline = Date.now() + 5000;
-  while (Date.now() < deadline) {
-    if (!isProcessRunning(targetPid)) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  try {
-    killProcess(targetPid, "SIGKILL");
-  } catch {}
-}
-function defaultIsProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function defaultRunProcessCommand(command, args) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn2(command, args, { stdio: "ignore" });
-    child.on("error", reject);
-    child.on("close", (code) => resolve(code ?? 1));
-  });
-}
-var init_terminate_process_tree = () => {};
-
-// src/util/text.ts
-function truncateText(text, maxLength, ellipsis = "…") {
-  if (text.length <= maxLength)
-    return text;
-  return text.slice(0, maxLength - ellipsis.length) + ellipsis;
-}
-function escapeForDoubleQuotes(input) {
-  return input.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-}
-function quoteIfNeeded(input) {
-  return `"${escapeForDoubleQuotes(input)}"`;
-}
-
-// src/transport/acpx-queue-owner-launcher.ts
-import { createHash } from "node:crypto";
-import { spawn as spawn3 } from "node:child_process";
-import { readFile, unlink } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join2 } from "node:path";
-function buildWeacpxMcpServerSpec(input) {
-  const { command, args } = splitCommandLine(input.weacpxCommand);
-  return {
-    name: "weacpx",
-    type: "stdio",
-    command,
-    args: [
-      ...args,
-      "mcp-stdio",
-      "--coordinator-session",
-      input.coordinatorSession,
-      ...input.sourceHandle ? ["--source-handle", input.sourceHandle] : ["--internal-session-tools"]
-    ]
-  };
-}
-function buildQueueOwnerPayload(input) {
-  return {
-    sessionId: input.sessionId,
-    permissionMode: input.permissionMode,
-    nonInteractivePermissions: input.nonInteractivePermissions,
-    ttlMs: input.ttlMs ?? 300000,
-    maxQueueDepth: input.maxQueueDepth ?? 16,
-    ...Number.isFinite(input.promptRetries) ? { promptRetries: input.promptRetries } : {},
-    ...input.sessionOptions ? { sessionOptions: input.sessionOptions } : {},
-    mcpServers: input.mcpServers
-  };
-}
-
-class AcpxQueueOwnerLauncher {
-  acpxCommand;
-  weacpxCommand;
-  spawnOwner;
-  terminateOwner;
-  baseEnv;
-  ttlMs;
-  maxQueueDepth;
-  launchLocks = new Map;
-  constructor(options) {
-    this.acpxCommand = options.acpxCommand;
-    this.weacpxCommand = options.weacpxCommand ?? resolveDefaultWeacpxCommand(options.baseEnv ?? process.env);
-    this.spawnOwner = options.spawnOwner ?? defaultQueueOwnerSpawner;
-    this.terminateOwner = options.terminateOwner ?? createDefaultQueueOwnerTerminator(options.acpxCommand);
-    this.baseEnv = options.baseEnv ?? process.env;
-    this.ttlMs = options.ttlMs;
-    this.maxQueueDepth = options.maxQueueDepth;
-  }
-  async launch(input) {
-    const key = input.acpxRecordId;
-    const previous = this.launchLocks.get(key) ?? Promise.resolve();
-    const next = previous.then(() => this.doLaunch(input), () => this.doLaunch(input));
-    this.launchLocks.set(key, next.catch(() => {}));
-    return next;
-  }
-  async doLaunch(input) {
-    await this.terminateOwner(input.acpxRecordId);
-    const payload = buildQueueOwnerPayload({
-      sessionId: input.acpxRecordId,
-      permissionMode: input.permissionMode,
-      nonInteractivePermissions: input.nonInteractivePermissions,
-      ttlMs: this.ttlMs,
-      maxQueueDepth: this.maxQueueDepth,
-      mcpServers: [buildWeacpxMcpServerSpec({
-        weacpxCommand: this.weacpxCommand,
-        coordinatorSession: input.coordinatorSession,
-        ...input.sourceHandle ? { sourceHandle: input.sourceHandle } : {}
-      })]
-    });
-    const spawnSpec = resolveSpawnCommand(this.acpxCommand, ["__queue-owner"]);
-    await this.spawnOwner(spawnSpec.command, spawnSpec.args, {
-      env: {
-        ...stringEnv(this.baseEnv),
-        ACPX_QUEUE_OWNER_PAYLOAD: JSON.stringify(payload)
-      }
-    });
-  }
-}
-function splitCommandLine(value) {
-  const parts = [];
-  let current = "";
-  let quote = null;
-  let escaping = false;
-  for (const char of value) {
-    if (escaping) {
-      current += char;
-      escaping = false;
-      continue;
-    }
-    if (char === "\\" && quote !== "'") {
-      escaping = true;
-      continue;
-    }
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-      } else {
-        current += char;
-      }
-      continue;
-    }
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      if (current.length > 0) {
-        parts.push(current);
-        current = "";
-      }
-      continue;
-    }
-    current += char;
-  }
-  if (escaping) {
-    current += "\\";
-  }
-  if (quote) {
-    throw new Error("weacpx MCP command has an unterminated quote");
-  }
-  if (current.length > 0) {
-    parts.push(current);
-  }
-  if (parts.length === 0) {
-    throw new Error("weacpx MCP command must not be empty");
-  }
-  return { command: parts[0], args: parts.slice(1) };
-}
-function stringEnv(env) {
-  return Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === "string"));
-}
-async function defaultQueueOwnerSpawner(command, args, options) {
-  await new Promise((resolve, reject) => {
-    const child = spawn3(command, args, {
-      detached: true,
-      stdio: "ignore",
-      env: options.env,
-      windowsHide: true
-    });
-    child.once("error", reject);
-    child.once("spawn", () => {
-      child.unref();
-      resolve();
-    });
-  });
-}
-function createDefaultQueueOwnerTerminator(_acpxCommand) {
-  return async (sessionId) => {
-    await terminateAcpxQueueOwner(sessionId);
-  };
-}
-async function terminateAcpxQueueOwner(sessionId) {
-  const lockPath = queueLockFilePath(sessionId);
-  let owner;
-  try {
-    owner = JSON.parse(await readFile(lockPath, "utf8"));
-  } catch {
-    return;
-  }
-  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
-    await terminateProcessTree(owner.pid, { detachedProcessGroup: true });
-  }
-  await unlink(lockPath).catch(() => {});
-}
-function queueLockFilePath(sessionId) {
-  return join2(homedir2(), ".acpx", "queues", `${shortHash(sessionId, 24)}.lock`);
-}
-function shortHash(value, length) {
-  return createHash("sha256").update(value).digest("hex").slice(0, length);
-}
-function resolveDefaultWeacpxCommand(env) {
-  if (env.WEACPX_CLI_COMMAND?.trim()) {
-    return env.WEACPX_CLI_COMMAND.trim();
-  }
-  if (env.WEACPX_DAEMON_ARG0?.trim()) {
-    return `${quoteCommandPart(process.execPath)} ${quoteCommandPart(env.WEACPX_DAEMON_ARG0.trim())}`;
-  }
-  if (process.argv[1]) {
-    return `${quoteCommandPart(process.execPath)} ${quoteCommandPart(process.argv[1])}`;
-  }
-  return "weacpx";
-}
-function quoteCommandPart(value) {
-  return quoteIfNeeded(value);
-}
-var init_acpx_queue_owner_launcher = __esm(() => {
-  init_spawn_command();
-  init_terminate_process_tree();
-});
-
-// src/transport/permission-mode-flag.ts
-function permissionModeToFlag(permissionMode) {
-  switch (permissionMode) {
-    case "approve-reads":
-      return "--approve-reads";
-    case "deny-all":
-      return "--deny-all";
-    case "approve-all":
-      return "--approve-all";
-  }
-}
-
-// src/util/path.ts
-import path2 from "node:path";
-import { homedir as homedir3 } from "node:os";
-function normalizePath(input) {
-  const expanded = expandHome(input);
-  if (isWindowsLikePath(expanded)) {
-    return path2.win32.normalize(expanded).replace(/\\/g, "/");
-  }
-  return path2.posix.normalize(expanded.replace(/\\/g, "/"));
-}
-function basenameForPath(input) {
-  const normalized = normalizePath(input);
-  if (ROOT_PATH_RE.test(normalized)) {
-    return normalized;
-  }
-  const base = path2.posix.basename(normalized);
-  return base || normalized;
-}
-function isSamePath(left, right) {
-  const normalizedLeft = normalizePath(left);
-  const normalizedRight = normalizePath(right);
-  if (isWindowsLikePath(normalizedLeft) || isWindowsLikePath(normalizedRight)) {
-    return normalizedLeft.toLowerCase() === normalizedRight.toLowerCase();
-  }
-  return normalizedLeft === normalizedRight;
-}
-function isWindowsLikePath(input) {
-  return WINDOWS_DRIVE_PATH_RE.test(input) || WINDOWS_UNC_PATH_RE.test(input);
-}
-function expandHome(input) {
-  return input.startsWith("~") ? homedir3() + input.slice(1) : input;
-}
-var WINDOWS_DRIVE_PATH_RE, WINDOWS_UNC_PATH_RE, ROOT_PATH_RE;
-var init_path = __esm(() => {
-  WINDOWS_DRIVE_PATH_RE = /^[a-zA-Z]:[\\/]/;
-  WINDOWS_UNC_PATH_RE = /^\\\\/;
-  ROOT_PATH_RE = /^(\/|[a-zA-Z]:\/?)$/;
-});
-
-// src/transport/agent-session-list.ts
-function isUnknownFilterCwdOption(output) {
-  return /(?:unknown|unrecognized) option/i.test(output) && output.includes("--filter-cwd");
-}
-async function runAgentSessionList(options) {
-  let result = await options.runList(true);
-  let filterLocally = false;
-  if (result.code !== 0 && options.filterCwd && isUnknownFilterCwdOption(result.stdout + result.stderr)) {
-    result = await options.runList(false);
-    filterLocally = true;
-  }
-  if (result.code !== 0) {
-    if ((result.stdout + result.stderr).includes("sessionCapabilities.list")) {
-      return;
-    }
-    throw new Error(options.formatError(result));
-  }
-  return parseAgentSessionListOutput(result.stdout, filterLocally ? options.filterCwd : undefined);
-}
-function parseAgentSessionListOutput(stdout, filterCwd) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch {
-    throw new Error("failed to parse acpx sessions list output");
-  }
-  if (!isAgentSessionListResult(parsed)) {
-    return;
-  }
-  return filterCwd ? filterAgentSessionListByCwd(parsed, filterCwd) : parsed;
-}
-function isAgentSessionListResult(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return false;
-  const record = value;
-  if (record.source !== "agent" || !Array.isArray(record.sessions))
-    return false;
-  return record.sessions.every((session) => {
-    if (!session || typeof session !== "object" || Array.isArray(session))
-      return false;
-    const item = session;
-    return typeof item.sessionId === "string";
-  });
-}
-function filterAgentSessionListByCwd(result, cwd) {
-  return {
-    ...result,
-    sessions: result.sessions.filter((session) => session.cwd && isSamePath(session.cwd, cwd))
-  };
-}
-var init_agent_session_list = __esm(() => {
-  init_path();
-});
-
-// src/bridge/bridge-main.ts
-import { createInterface } from "node:readline";
-
-// src/bridge/bridge-env.ts
-function normalizeBridgePermissionMode(value) {
-  return value === "approve-reads" || value === "deny-all" || value === "approve-all" ? value : "approve-all";
-}
-function normalizeBridgeNonInteractivePermissions(value) {
-  return value === "deny" || value === "fail" ? value : "deny";
-}
-function normalizeBridgeQueueOwnerTtlSeconds(value) {
-  if (value === undefined) {
-    return;
-  }
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
-}
-
-// src/bridge/bridge-server.ts
-init_prompt_output();
-
-// src/bridge/bridge-request-scheduler.ts
-class BridgeRequestScheduler {
-  sessions = new Map;
-  run(sessionName, lane, task) {
-    if (lane === "control") {
-      return Promise.resolve().then(task);
-    }
-    const state = this.sessions.get(sessionName) ?? this.createSessionState(sessionName);
-    state.pendingNormals += 1;
-    const result = state.tail.then(() => task());
-    state.tail = result.then(() => {
-      return;
-    }, () => {
-      return;
-    });
-    return result.finally(() => {
-      state.pendingNormals -= 1;
-      if (state.pendingNormals === 0 && this.sessions.get(sessionName) === state) {
-        this.sessions.delete(sessionName);
-      }
-    });
-  }
-  createSessionState(sessionName) {
-    const state = {
-      pendingNormals: 0,
-      tail: Promise.resolve()
-    };
-    this.sessions.set(sessionName, state);
-    return state;
-  }
-}
-
-// src/bridge/bridge-runtime.ts
-init_spawn_command();
-init_prompt_output();
-init_prompt_media();
-init_streaming_prompt();
-import { copyFile, readdir } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname2, join as join3, win32 } from "node:path";
-import { spawn as spawn4 } from "node:child_process";
-
-// src/bridge/parse-missing-optional-dep.ts
-var PATTERN = /You can try manually installing ["']([^"']+)["']/;
-var VALID_NAME = /^(@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
-function parseMissingOptionalDep(text) {
-  const match = PATTERN.exec(text);
-  if (!match || !match[1])
-    return null;
-  const pkg = match[1];
-  if (!VALID_NAME.test(pkg))
-    return null;
-  return { package: pkg };
-}
-
-// src/bridge/bridge-runtime.ts
-init_discover_parent_package_paths();
-init_acpx_queue_owner_launcher();
-init_agent_session_list();
-class EnsureSessionFailedError extends Error {
-  kind;
-  data;
-  constructor(message, kind, data) {
-    super(message);
-    this.name = "EnsureSessionFailedError";
-    this.kind = kind;
-    this.data = data;
-  }
-}
-
-class BridgeRuntime {
-  command;
-  run;
-  runSessionCreate;
-  options;
-  runPromptCommand;
-  repairSessionIndex;
-  queueOwnerLauncher;
-  acpxVerboseSupported = undefined;
-  constructor(command = "acpx", run = defaultRunner, runSessionCreate = shellSessionCreateRunner, options = {}, runPromptCommand = defaultPromptRunner, repairSessionIndex = tryRepairAcpxSessionIndex, queueOwnerLauncher = new AcpxQueueOwnerLauncher({
-    acpxCommand: command,
-    ...typeof options.queueOwnerTtlSeconds === "number" && Number.isFinite(options.queueOwnerTtlSeconds) ? { ttlMs: options.queueOwnerTtlSeconds * 1000 } : {}
-  })) {
-    this.command = command;
-    this.run = run;
-    this.runSessionCreate = runSessionCreate;
-    this.options = options;
-    this.runPromptCommand = runPromptCommand;
-    this.repairSessionIndex = repairSessionIndex;
-    this.queueOwnerLauncher = queueOwnerLauncher;
-  }
-  async updatePermissionPolicy(policy) {
-    this.options.permissionMode = policy.permissionMode;
-    this.options.nonInteractivePermissions = policy.nonInteractivePermissions;
-    this.options.permissionPolicy = policy.permissionPolicy;
-    return {};
-  }
-  async listAgentSessions(input) {
-    return await runAgentSessionList({
-      filterCwd: input.filterCwd,
-      runList: async (includeFilterCwd) => {
-        const spec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-          "sessions",
-          "list",
-          ...includeFilterCwd && input.filterCwd ? ["--filter-cwd", input.filterCwd] : [],
-          ...input.cursor ? ["--cursor", input.cursor] : []
-        ], { format: "json" }));
-        return await this.run(spec.command, spec.args);
-      },
-      formatError: (result) => result.stderr || result.stdout || `sessions list failed with exit code ${result.code}`
-    });
-  }
-  async resumeAgentSession(input) {
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "sessions",
-      "new",
-      "--name",
-      input.name,
-      "--resume-session",
-      input.agentSessionId
-    ], { format: "quiet" }));
-    const result = await this.runSessionCreate(spawnSpec.command, spawnSpec.args, input.cwd);
-    if (result.code !== 0) {
-      throw new Error(result.stderr || result.stdout || "sessions resume failed");
-    }
-    return {};
-  }
-  async hasSession(input) {
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "sessions",
-      "show",
-      input.name
-    ]));
-    const result = await this.run(spawnSpec.command, spawnSpec.args);
-    return { exists: result.code === 0 };
-  }
-  async tailSessionHistory(input) {
-    const candidates = [
-      ["sessions", "history", "quiet", "-s", input.name, String(input.lines)],
-      ["sessions", "history", "quiet", input.name, String(input.lines)],
-      ["sessions", "history", "-s", input.name, "--tail", String(input.lines)],
-      ["sessions", "history", input.name, "--tail", String(input.lines)],
-      ["sessions", "history", "--name", input.name, "--tail", String(input.lines)]
-    ];
-    let lastResult;
-    for (const tailArgs of candidates) {
-      const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, tailArgs));
-      const result = await this.run(spawnSpec.command, spawnSpec.args);
-      if (result.code === 0) {
-        return { text: result.stdout.trimEnd() };
-      }
-      lastResult = result;
-    }
-    const message = lastResult?.stderr || lastResult?.stdout || "sessions history failed";
-    throw new Error(message);
-  }
-  async ensureSession(input, onProgress) {
-    onProgress?.("spawn");
-    const onStderrLine = onProgress ? (line) => {
-      const trimmed = line.replace(/\r$/, "").trimEnd();
-      if (trimmed.length === 0)
-        return;
-      onProgress({ kind: "note", text: trimmed });
-    } : undefined;
-    const runWithVerboseFallback = async (tailArgs, runner) => {
-      const useVerbose = this.acpxVerboseSupported !== false;
-      const spec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, tailArgs, { verbose: useVerbose }));
-      const result = await runner(spec.command, spec.args);
-      if (result.code === 0) {
-        if (useVerbose)
-          this.acpxVerboseSupported = true;
-        return result;
-      }
-      if (useVerbose && isUnknownVerboseOption(result.stderr, result.stdout)) {
-        this.acpxVerboseSupported = false;
-        const retrySpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, tailArgs, { verbose: false }));
-        return await runner(retrySpec.command, retrySpec.args);
-      }
-      return result;
-    };
-    const ensured = await runWithVerboseFallback(["sessions", "ensure", "--name", input.name], (command, args) => this.run(command, args, { onStderrLine }));
-    if (ensured.code === 0) {
-      onProgress?.("ready");
-      return {};
-    }
-    const existingSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, ["sessions", "show", input.name]));
-    const existing = await this.run(existingSpec.command, existingSpec.args);
-    if (existing.code === 0) {
-      onProgress?.("ready");
-      return {};
-    }
-    onProgress?.("initializing");
-    const created = await runWithVerboseFallback(["sessions", "new", "--name", input.name], (command, args) => this.runSessionCreate(command, args, input.cwd, { onStderrLine }));
-    if (created.code === 0) {
-      onProgress?.("ready");
-      return {};
-    }
-    const output = created.stderr || created.stdout || "";
-    if (output.includes("EPERM") && await this.repairSessionIndex()) {
-      const repaired = await this.run(existingSpec.command, existingSpec.args);
-      if (repaired.code === 0) {
-        onProgress?.("ready");
-        return {};
-      }
-    }
-    const rawMessage = output || ensured.stderr || ensured.stdout || "failed to create session";
-    const parseInput = rawMessage.split(/\r\n|\r|\n/).filter((line) => !/^\s*\[acpx\]/.test(line)).join(`
-`);
-    const parsed = parseMissingOptionalDep(parseInput);
-    if (parsed) {
-      const parentPackagePath = this.resolveParentPackagePath(input, parsed.package);
-      throw new EnsureSessionFailedError(rawMessage, "missing_optional_dep", {
-        package: parsed.package,
-        parentPackagePath
-      });
-    }
-    throw new EnsureSessionFailedError(rawMessage, "generic");
-  }
-  resolveParentPackagePath(input, platformPackage) {
-    const guess = deriveParentPackageName(platformPackage);
-    const candidates = [input.agentCommand, input.agent, guess].filter((c) => Boolean(c));
-    for (const candidate of candidates) {
-      try {
-        const resolved = __require.resolve(`${candidate}/package.json`, {
-          paths: [process.cwd(), ...__require.resolve.paths(candidate) ?? []]
-        });
-        return dirname2(resolved);
-      } catch {
-        continue;
-      }
-    }
-    return null;
-  }
-  async prompt(input, onEvent) {
-    await this.launchMcpQueueOwnerIfNeeded(input);
-    const structuredPrompt = await createStructuredPromptFile(input.text, input.media);
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildPromptArgs(input, [
-      "prompt",
-      "-s",
-      input.name,
-      ...structuredPrompt ? ["--file", structuredPrompt.filePath] : [input.text]
-    ]));
-    const formatToolCalls = (input.replyMode ?? "verbose") === "verbose";
-    const toolEventMode = input.toolEventMode ?? (input.toolEvents === true ? "structured" : "text");
-    try {
-      const result = onEvent ? await this.runPromptCommand(spawnSpec.command, spawnSpec.args, onEvent, {
-        formatToolCalls,
-        toolEventMode
-      }) : await this.run(spawnSpec.command, spawnSpec.args);
-      return { text: getPromptText(result) };
-    } finally {
-      try {
-        await structuredPrompt?.cleanup();
-      } catch {}
-    }
-  }
-  async launchMcpQueueOwnerIfNeeded(input) {
-    if (!input.mcpCoordinatorSession) {
-      return;
-    }
-    const record = await this.readSessionRecord(input);
-    await this.queueOwnerLauncher.launch({
-      acpxRecordId: record.acpxRecordId,
-      coordinatorSession: input.mcpCoordinatorSession,
-      ...input.mcpSourceHandle ? { sourceHandle: input.mcpSourceHandle } : {},
-      permissionMode: this.options.permissionMode ?? "approve-all",
-      nonInteractivePermissions: this.options.nonInteractivePermissions ?? "deny"
-    });
-  }
-  async readSessionRecord(input) {
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "sessions",
-      "show",
-      input.name
-    ]));
-    const result = await this.run(spawnSpec.command, spawnSpec.args);
-    if (result.code !== 0) {
-      throw new Error(result.stderr || result.stdout || "sessions show failed");
-    }
-    try {
-      const parsed = JSON.parse(result.stdout);
-      let acpxRecordId;
-      if (typeof parsed.acpxRecordId === "string") {
-        acpxRecordId = parsed.acpxRecordId;
-      } else if (typeof parsed.id === "string") {
-        acpxRecordId = parsed.id;
-      }
-      if (acpxRecordId) {
-        return { acpxRecordId };
-      }
-    } catch {
-      const firstLine = result.stdout.trim().split(/\r?\n/, 1)[0];
-      if (firstLine && /^[\w.:-]+$/.test(firstLine) && firstLine.length >= 8) {
-        return { acpxRecordId: firstLine };
-      }
-    }
-    throw new Error("failed to resolve acpx session record id");
-  }
-  async setMode(input) {
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "set-mode",
-      "-s",
-      input.name,
-      input.modeId
-    ]));
-    const result = await this.run(spawnSpec.command, spawnSpec.args);
-    if (result.code !== 0) {
-      throw new Error(result.stderr || result.stdout || "set-mode failed");
-    }
-    return {};
-  }
-  async cancel(input) {
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "cancel",
-      "-s",
-      input.name
-    ]));
-    const result = await this.run(spawnSpec.command, spawnSpec.args);
-    if (result.code !== 0) {
-      throw new Error(result.stderr || result.stdout || "cancel failed");
-    }
-    return {
-      cancelled: true,
-      message: result.stdout.trim()
-    };
-  }
-  async removeSession(input) {
-    const spawnSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "sessions",
-      "close",
-      input.name
-    ]));
-    const result = await this.run(spawnSpec.command, spawnSpec.args);
-    if (result.code === 0) {
-      return {};
-    }
-    if (isMissingBridgeSessionError(result.stderr, result.stdout)) {
-      return {};
-    }
-    throw new Error(result.stderr || result.stdout || "sessions close failed");
-  }
-  async shutdown() {
-    return {};
-  }
-  buildSessionArgs(input, tail, options = {}) {
-    const prefix = [
-      "--format",
-      options.format ?? "quiet",
-      "--cwd",
-      input.cwd,
-      ...this.buildPermissionArgs()
-    ];
-    if (options.verbose) {
-      prefix.push("--verbose");
-    }
-    if (input.agentCommand) {
-      return [...prefix, "--agent", input.agentCommand, ...tail];
-    }
-    return [...prefix, input.agent, ...tail];
-  }
-  buildPromptArgs(input, tail) {
-    const prefix = [
-      "--format",
-      "json",
-      "--json-strict",
-      "--cwd",
-      input.cwd,
-      ...this.buildPermissionArgs(),
-      ...this.buildQueueOwnerTtlArgs()
-    ];
-    if (input.agentCommand) {
-      return [...prefix, "--agent", input.agentCommand, ...tail];
-    }
-    return [...prefix, input.agent, ...tail];
-  }
-  buildQueueOwnerTtlArgs() {
-    const ttl = this.options.queueOwnerTtlSeconds;
-    if (typeof ttl !== "number" || !Number.isFinite(ttl)) {
-      return [];
-    }
-    return ["--ttl", String(ttl)];
-  }
-  buildPermissionArgs() {
-    const permissionMode = this.options.permissionMode ?? "approve-all";
-    const nonInteractivePermissions = this.options.nonInteractivePermissions ?? "deny";
-    const modeFlag = permissionModeToFlag(permissionMode);
-    const args = [modeFlag, "--non-interactive-permissions", nonInteractivePermissions];
-    if (typeof this.options.permissionPolicy === "string" && this.options.permissionPolicy.trim().length > 0) {
-      args.push("--permission-policy", this.options.permissionPolicy);
-    }
-    return args;
-  }
-}
-function spawnCapture(command, args, options) {
-  return new Promise((resolve, reject) => {
-    const child = spawn4(command, args, { cwd: options?.cwd, stdio: ["ignore", "pipe", "pipe"] });
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    let stdout = "";
-    let stderr = "";
-    let stderrTail = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      const text = String(chunk);
-      stderr += text;
-      if (!options?.onStderrLine)
-        return;
-      stderrTail += text;
-      const matches = stderrTail.split(/\r\n|\r|\n/);
-      stderrTail = matches.pop() ?? "";
-      for (const line of matches) {
-        options.onStderrLine(line);
-      }
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (options?.onStderrLine && stderrTail.length > 0) {
-        options.onStderrLine(stderrTail);
-      }
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-  });
-}
-async function defaultRunner(command, args, options) {
-  return await spawnCapture(command, args, options);
-}
-async function runStreamingPrompt(command, args, onEvent, options = {}) {
-  const spawnPrompt = options.spawnPrompt ?? ((spawnCommand, spawnArgs) => spawn4(spawnCommand, spawnArgs, { stdio: ["ignore", "pipe", "pipe"] }));
-  const setIntervalFn = options.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
-  const clearIntervalFn = options.clearIntervalFn ?? ((timer) => clearInterval(timer));
-  const maxSegmentWaitMs = options.maxSegmentWaitMs ?? 30000;
-  const flushCheckIntervalMs = options.flushCheckIntervalMs ?? 5000;
-  const now = options.now ?? (() => Date.now());
-  return await new Promise((resolve, reject) => {
-    const child = spawnPrompt(command, args);
-    let stdout = "";
-    let stderr = "";
-    const toolEventMode = options.toolEventMode ?? "text";
-    const state = createStreamingPromptState(options.formatToolCalls ?? false, {
-      mode: toolEventMode,
-      ...onEvent && (toolEventMode === "structured" || toolEventMode === "both") ? { onToolEvent: (toolEvent) => onEvent({ type: "prompt.tool_event", event: toolEvent }) } : {},
-      ...onEvent ? { onThought: (chunk) => onEvent({ type: "prompt.thought", text: chunk }) } : {}
-    });
-    let lastReplyAt = now();
-    const flushBuffer = () => {
-      const remaining = state.buffer.trim();
-      if (remaining.length > 0) {
-        state.buffer = "";
-        onEvent?.({ type: "prompt.segment", text: remaining });
-        lastReplyAt = now();
-      }
-    };
-    const timer = setIntervalFn(() => {
-      if (state.buffer.trim().length > 0 && now() - lastReplyAt >= maxSegmentWaitMs) {
-        flushBuffer();
-      }
-    }, flushCheckIntervalMs);
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      const text = String(chunk);
-      stdout += text;
-      parseStreamingDataChunk(state, text);
-      for (const segment of state.segments.splice(0)) {
-        onEvent?.({ type: "prompt.segment", text: segment });
-        lastReplyAt = now();
-      }
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      clearIntervalFn(timer);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      clearIntervalFn(timer);
-      const remaining = state.finalize();
-      if (remaining.length > 0) {
-        onEvent?.({ type: "prompt.segment", text: remaining });
-      }
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-  });
-}
-async function defaultPromptRunner(command, args, onEvent, options) {
-  return await runStreamingPrompt(command, args, onEvent, options);
-}
-async function shellSessionCreateRunner(command, args, cwd, options) {
-  return await spawnCapture(command, args, { cwd, onStderrLine: options?.onStderrLine });
-}
-function selectLatestAcpxSessionIndexTmp(files) {
-  let latestTmp = null;
-  let latestTime = 0;
-  for (const file of files) {
-    const match = file.match(/^index\.json\.\d+\.(\d+)\.tmp$/);
-    if (!match) {
-      continue;
-    }
-    const timestamp = Number(match[1]);
-    if (timestamp > latestTime) {
-      latestTime = timestamp;
-      latestTmp = file;
-    }
-  }
-  return latestTmp;
-}
-async function tryRepairAcpxSessionIndex(deps = {}) {
-  const platform = deps.platform ?? process.platform;
-  if (platform !== "win32") {
-    return false;
-  }
-  const home = deps.home ?? process.env.HOME ?? process.env.USERPROFILE ?? homedir4();
-  if (!home) {
-    return false;
-  }
-  const pathJoin = platform === "win32" ? win32.join : join3;
-  const sessionsDir = pathJoin(home, ".acpx", "sessions");
-  const indexPath = pathJoin(sessionsDir, "index.json");
-  const readdirFn = deps.readdirFn ?? readdir;
-  const copyFileFn = deps.copyFileFn ?? copyFile;
-  let files;
-  try {
-    files = await readdirFn(sessionsDir);
-  } catch {
-    return false;
-  }
-  const latestTmp = selectLatestAcpxSessionIndexTmp(files);
-  if (!latestTmp) {
-    return false;
-  }
-  try {
-    await copyFileFn(pathJoin(sessionsDir, latestTmp), indexPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isUnknownVerboseOption(stderr, stdout) {
-  const combined = `${stderr}
-${stdout}`;
-  return /(unknown|unrecognized)\b[^\n]*--verbose/i.test(combined);
-}
-function isMissingBridgeSessionError(stderr, stdout) {
-  const combined = `${stderr}
-${stdout}`.toLowerCase();
-  return combined.includes("no named session") || combined.includes("no cwd session") || combined.includes("session not found") || combined.includes("unknown session") || combined.includes("no acpx session found");
-}
-
-// src/bridge/bridge-server.ts
-class BridgeInvalidRequestError extends Error {
-}
-var BRIDGE_METHODS = new Set([
-  "ping",
-  "shutdown",
-  "updatePermissionPolicy",
-  "hasSession",
-  "ensureSession",
-  "tailSessionHistory",
-  "listAgentSessions",
-  "resumeAgentSession",
-  "prompt",
-  "setMode",
-  "cancel",
-  "removeSession"
-]);
-var SESSION_SCOPED_METHODS = new Set([
-  "hasSession",
-  "ensureSession",
-  "tailSessionHistory",
-  "resumeAgentSession",
-  "prompt",
-  "setMode",
-  "cancel",
-  "removeSession"
-]);
-
-class BridgeServer {
-  runtime;
-  scheduler = new BridgeRequestScheduler;
-  constructor(runtime) {
-    this.runtime = runtime;
-  }
-  async handleLine(line, writeLine) {
-    let requestId = extractRequestId(line);
-    try {
-      const request = parseBridgeRequest(line);
-      requestId = request.id;
-      const result = await this.dispatchRequest(request.id, request.method, request.params, writeLine);
-      return `${JSON.stringify({
-        id: request.id,
-        ok: true,
-        result
-      })}
-`;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const ensureSessionFields = error instanceof EnsureSessionFailedError ? { kind: error.kind, ...error.data ? { data: error.data } : {} } : {};
-      const promptDetails = error instanceof PromptCommandError ? { details: { exitCode: error.exitCode, stdout: error.stdout, stderr: error.stderr } } : {};
-      return `${JSON.stringify({
-        id: requestId,
-        ok: false,
-        error: {
-          code: error instanceof BridgeInvalidRequestError ? "BRIDGE_INVALID_REQUEST" : "BRIDGE_INTERNAL_ERROR",
-          message,
-          ...ensureSessionFields,
-          ...promptDetails
-        }
-      })}
-`;
-    }
-  }
-  async dispatchRequest(requestId, method, params, writeLine) {
-    if (!SESSION_SCOPED_METHODS.has(method)) {
-      return await this.dispatch(requestId, method, params, writeLine);
-    }
-    const sessionName = getSessionName(params);
-    if (!sessionName) {
-      return await this.dispatch(requestId, method, params, writeLine);
-    }
-    const sessionKey = getSessionScheduleKey(params);
-    if (!sessionKey) {
-      return await this.dispatch(requestId, method, params, writeLine);
-    }
-    const lane = method === "cancel" ? "control" : "normal";
-    return await this.scheduler.run(sessionKey, lane, () => this.dispatch(requestId, method, params, writeLine));
-  }
-  async dispatch(requestId, method, params, writeLine) {
-    switch (method) {
-      case "ping":
-        return {};
-      case "shutdown":
-        return await this.runtime.shutdown();
-      case "updatePermissionPolicy":
-        return await this.runtime.updatePermissionPolicy({
-          permissionMode: requirePermissionMode(params, "permissionMode"),
-          nonInteractivePermissions: requireNonInteractivePermissions(params, "nonInteractivePermissions")
-        });
-      case "hasSession":
-        return await this.runtime.hasSession({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name")
-        });
-      case "tailSessionHistory":
-        return await this.runtime.tailSessionHistory({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name"),
-          lines: requirePositiveInt(params, "lines")
-        });
-      case "listAgentSessions":
-        return await this.runtime.listAgentSessions({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          cursor: asOptionalString(params.cursor),
-          filterCwd: asOptionalString(params.filterCwd)
-        });
-      case "ensureSession":
-        return await this.runtime.ensureSession({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name"),
-          mcpCoordinatorSession: asOptionalString(params.mcpCoordinatorSession),
-          mcpSourceHandle: asOptionalString(params.mcpSourceHandle)
-        }, (progress) => {
-          if (typeof progress === "string") {
-            writeLine?.(encodeBridgeSessionProgressEvent({
-              id: requestId,
-              event: "session.progress",
-              stage: progress
-            }));
-          } else if (progress.kind === "note") {
-            writeLine?.(encodeBridgeSessionNoteEvent({
-              id: requestId,
-              event: "session.note",
-              text: progress.text
-            }));
-          }
-        });
-      case "prompt":
-        const media = asOptionalPromptMediaInput(params.media);
-        const resolvedToolEventMode = asOptionalToolEventMode(params.toolEventMode);
-        return await this.runtime.prompt({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name"),
-          mcpCoordinatorSession: asOptionalString(params.mcpCoordinatorSession),
-          mcpSourceHandle: asOptionalString(params.mcpSourceHandle),
-          text: requirePromptText(params, media),
-          replyMode: asOptionalReplyMode(params.replyMode),
-          toolEvents: params.toolEvents === true,
-          ...resolvedToolEventMode ? { toolEventMode: resolvedToolEventMode } : {},
-          media
-        }, (event) => {
-          if (event.type === "prompt.segment") {
-            writeLine?.(encodeBridgePromptSegmentEvent({
-              id: requestId,
-              event: "prompt.segment",
-              text: event.text
-            }));
-          } else if (event.type === "prompt.tool_event") {
-            writeLine?.(encodeBridgePromptToolEvent({
-              id: requestId,
-              event: "prompt.tool_event",
-              toolEvent: event.event
-            }));
-          } else if (event.type === "prompt.thought") {
-            writeLine?.(encodeBridgePromptThoughtEvent({
-              id: requestId,
-              event: "prompt.thought",
-              text: event.text
-            }));
-          }
-        });
-      case "resumeAgentSession":
-        return await this.runtime.resumeAgentSession({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name"),
-          agentSessionId: requireString(params, "agentSessionId")
-        });
-      case "setMode":
-        return await this.runtime.setMode({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name"),
-          modeId: requireString(params, "modeId")
-        });
-      case "cancel":
-        return await this.runtime.cancel({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name")
-        });
-      case "removeSession":
-        return await this.runtime.removeSession({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name")
-        });
-      default:
-        throw new Error(`unsupported bridge method: ${method}`);
-    }
-  }
-}
-function extractRequestId(line) {
-  try {
-    const raw = JSON.parse(line);
-    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-      return "unknown";
-    }
-    const id = raw.id;
-    return typeof id === "string" && id.length > 0 ? id : "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function parseBridgeRequest(line) {
-  let raw;
-  try {
-    raw = JSON.parse(line);
-  } catch {
-    throw new BridgeInvalidRequestError("request must be valid JSON");
-  }
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new BridgeInvalidRequestError("request must be a JSON object");
-  }
-  const request = raw;
-  const id = request.id;
-  const method = request.method;
-  const params = request.params;
-  if (typeof id !== "string" || id.length === 0) {
-    throw new BridgeInvalidRequestError("id must be a non-empty string");
-  }
-  if (typeof method !== "string" || method.length === 0) {
-    throw new BridgeInvalidRequestError("method must be a non-empty string");
-  }
-  if (!BRIDGE_METHODS.has(method)) {
-    throw new BridgeInvalidRequestError(`unsupported bridge method: ${method}`);
-  }
-  if (!params || typeof params !== "object" || Array.isArray(params)) {
-    throw new BridgeInvalidRequestError("params must be an object");
-  }
-  return {
-    id,
-    method,
-    params
-  };
-}
-function getSessionName(params) {
-  return asNonEmptyString(params.name);
-}
-function getSessionScheduleKey(params) {
-  const name = asNonEmptyString(params.name);
-  const cwd = asNonEmptyString(params.cwd);
-  const agentIdentity = asNonEmptyString(params.agentCommand) ?? asNonEmptyString(params.agent);
-  if (!name || !cwd || !agentIdentity) {
-    return;
-  }
-  return JSON.stringify([agentIdentity, cwd, name]);
-}
-function asNonEmptyString(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return;
-  }
-  return value;
-}
-function requireString(params, key) {
-  const value = params[key];
-  if (typeof value !== "string" || value.length === 0) {
-    throw new BridgeInvalidRequestError(`${key} must be a non-empty string`);
-  }
-  return value;
-}
-function requirePositiveInt(params, key) {
-  const value = params[key];
-  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value <= 0) {
-    throw new BridgeInvalidRequestError(`${key} must be a positive integer`);
-  }
-  return value;
-}
-function requirePromptText(params, media) {
-  const value = params.text;
-  if (typeof value !== "string") {
-    throw new BridgeInvalidRequestError("text must be a non-empty string");
-  }
-  const hasMedia = Array.isArray(media) ? media.length > 0 : Boolean(media);
-  if (value.length === 0 && !hasMedia) {
-    throw new BridgeInvalidRequestError("text must be a non-empty string unless media is provided");
-  }
-  return value;
-}
-function requirePermissionMode(params, key) {
-  const value = params[key];
-  if (value === "approve-all" || value === "approve-reads" || value === "deny-all") {
-    return value;
-  }
-  throw new BridgeInvalidRequestError(`${key} must be approve-all, approve-reads, or deny-all`);
-}
-function requireNonInteractivePermissions(params, key) {
-  const value = params[key];
-  if (value === "deny" || value === "fail") {
-    return value;
-  }
-  throw new BridgeInvalidRequestError(`${key} must be deny or fail`);
-}
-function asOptionalString(value) {
-  if (typeof value !== "string" || value.length === 0) {
-    return;
-  }
-  return value;
-}
-function asOptionalPromptMediaInput(value) {
-  if (value === undefined)
-    return;
-  if (Array.isArray(value))
-    return value.map(asPromptMedia);
-  return asPromptMedia(value);
-}
-function asPromptMedia(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new BridgeInvalidRequestError("media must be an object or array of objects when provided");
-  }
-  const record = value;
-  const type = record.type;
-  if (type !== "image" && type !== "audio" && type !== "video" && type !== "file") {
-    throw new BridgeInvalidRequestError("media.type must be image, audio, video, or file");
-  }
-  if (typeof record.filePath !== "string" || record.filePath.trim().length === 0) {
-    throw new BridgeInvalidRequestError("media.filePath must be a non-empty string");
-  }
-  if (typeof record.mimeType !== "string" || record.mimeType.trim().length === 0) {
-    throw new BridgeInvalidRequestError("media.mimeType must be a non-empty string");
-  }
-  return {
-    type,
-    filePath: record.filePath,
-    mimeType: record.mimeType,
-    ...typeof record.fileName === "string" && record.fileName ? { fileName: record.fileName } : {}
-  };
-}
-var VALID_REPLY_MODES = new Set(["stream", "final", "verbose"]);
-function asOptionalReplyMode(value) {
-  if (typeof value !== "string" || !VALID_REPLY_MODES.has(value)) {
-    return;
-  }
-  return value;
-}
-var VALID_TOOL_EVENT_MODES = new Set(["text", "structured", "both"]);
-function asOptionalToolEventMode(value) {
-  if (typeof value !== "string" || !VALID_TOOL_EVENT_MODES.has(value)) {
-    return;
-  }
-  return value;
-}
-
-// src/bridge/bridge-main.ts
-async function processBridgeInput(options) {
-  const pendingWrites = new Set;
-  let firstError;
-  for await (const line of options.input) {
-    const pendingWrite = (async () => {
-      const response = await options.server.handleLine(line, (chunk) => {
-        options.write(chunk);
-      });
-      options.write(response);
-    })();
-    const observedPendingWrite = pendingWrite.catch((error) => {
-      if (firstError === undefined) {
-        firstError = error;
-        options.input.close();
-      }
-    });
-    pendingWrites.add(pendingWrite);
-    observedPendingWrite.finally(() => {
-      pendingWrites.delete(pendingWrite);
-    });
-  }
-  await Promise.allSettled(pendingWrites);
-  if (firstError !== undefined) {
-    throw firstError;
-  }
-}
-async function runBridgeMain() {
-  const server = new BridgeServer(new BridgeRuntime(process.env.WEACPX_BRIDGE_ACPX_COMMAND ?? "acpx", undefined, undefined, {
-    permissionMode: normalizeBridgePermissionMode(process.env.WEACPX_BRIDGE_PERMISSION_MODE),
-    nonInteractivePermissions: normalizeBridgeNonInteractivePermissions(process.env.WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS),
-    queueOwnerTtlSeconds: normalizeBridgeQueueOwnerTtlSeconds(process.env.WEACPX_BRIDGE_QUEUE_OWNER_TTL_SECONDS)
-  }));
-  const input = createInterface({
-    input: process.stdin,
-    crlfDelay: Infinity
-  });
-  await processBridgeInput({
-    input,
-    server,
-    write: (chunk) => {
-      process.stdout.write(chunk);
-    }
-  });
-}
-if (__require.main == __require.module) {
-  await runBridgeMain();
-}
-export {
-  runBridgeMain,
-  processBridgeInput
-};