weacpx 0.2.1 → 0.3.0

package/dist/bridge/bridge-main.js

@@ -56,6 +56,14 @@ function encodeBridgePromptSegmentEvent(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) {
@@ -205,12 +213,14 @@ var init_spawn_command = __esm(() => {
 });
 
 // src/transport/streaming-prompt.ts
-function createStreamingPromptState() {
+function createStreamingPromptState(formatToolCalls = false) {
   return {
     buffer: "",
     segments: [],
     hasAgentMessage: false,
     pendingLine: "",
+    formatToolCalls,
+    emittedToolCallIds: new Set,
     finalize() {
       if (this.pendingLine.trim().length > 0) {
         parseStreamingChunks(this, this.pendingLine);
@@ -242,11 +252,29 @@ function parseStreamingChunks(state, line) {
   } catch {
     return;
   }
-  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 (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 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 isMessageChunk = update.sessionUpdate === "agent_message_chunk" && update.content?.type === "text" && typeof update.content.text === "string";
   if (!isMessageChunk)
     return;
   state.hasAgentMessage = true;
-  const chunk = event.params.update.content.text ?? "";
+  const chunk = update.content.text ?? "";
   if (chunk.length === 0)
     return;
   state.buffer += chunk;
@@ -261,211 +289,532 @@ function parseStreamingChunks(state, line) {
     }
   }
 }
-
-// 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 formatToolCallEvent(update, sessionUpdate) {
+  if (!update)
+    return null;
+  const kind = update.kind ?? "";
+  const title = update.title ?? "";
+  if (title.length === 0)
+    return null;
+  const emoji = KIND_EMOJI[kind] ?? "\uD83D\uDD27";
+  const command = getToolDisplayCommand(update);
+  if (command) {
+    return `${emoji} ${truncateToolDisplay(command)}`;
+  }
+  if (sessionUpdate === "tool_call_update" || isGenericToolTitle(kind, title))
+    return null;
+  return `${emoji} ${title}`;
 }
-function normalizeBridgeNonInteractivePermissions(value) {
-  return value === "deny" || value === "fail" ? value : "deny";
+function getToolDisplayCommand(update) {
+  if (!update)
+    return null;
+  const command = update.rawInput?.command;
+  if (typeof command === "string" && command.length > 0) {
+    return command;
+  }
+  const parsedCmd = update.rawInput?.parsed_cmd;
+  if (parsedCmd && parsedCmd.length > 0) {
+    const parts = [];
+    for (const entry of parsedCmd) {
+      if (entry && typeof entry.cmd === "string" && entry.cmd.length > 0) {
+        parts.push(entry.cmd);
+      }
+    }
+    if (parts.length > 0) {
+      return parts.join(" ");
+    }
+  }
+  return null;
 }
-
-// src/bridge/bridge-server.ts
-init_prompt_output();
-
-class BridgeInvalidRequestError extends Error {
+function truncateToolDisplay(text) {
+  return text.length > 60 ? `${text.slice(0, 57)}...` : text;
 }
-var BRIDGE_METHODS = new Set([
-  "ping",
-  "shutdown",
-  "updatePermissionPolicy",
-  "hasSession",
-  "ensureSession",
-  "prompt",
-  "setMode",
-  "cancel"
-]);
+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 KIND_EMOJI;
+var init_streaming_prompt = __esm(() => {
+  KIND_EMOJI = {
+    read: "\uD83D\uDCD6",
+    search: "\uD83D\uDD0D",
+    execute: "\uD83D\uDCBB",
+    edit: "✏️"
+  };
+});
 
-class BridgeServer {
-  runtime;
-  constructor(runtime) {
-    this.runtime = runtime;
+// src/recovery/discover-parent-package-paths.ts
+import { spawn } from "node:child_process";
+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) });
   }
-  async handleLine(line, writeLine) {
-    let requestId = extractRequestId(line);
-    try {
-      const request = parseBridgeRequest(line);
-      requestId = request.id;
-      const result = await this.dispatch(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);
-      return `${JSON.stringify({
-        id: requestId,
-        ok: false,
-        error: {
-          code: error instanceof BridgeInvalidRequestError ? "BRIDGE_INVALID_REQUEST" : "BRIDGE_INTERNAL_ERROR",
-          message,
-          ...error instanceof PromptCommandError ? {
-            details: {
-              exitCode: error.exitCode,
-              stdout: error.stdout,
-              stderr: error.stderr
-            }
-          } : {}
-        }
-      })}
-`;
-    }
+  for (const name of [parentName, platformPackage]) {
+    const resolved = resolveFromCwd(name, cwd);
+    if (resolved)
+      rawCandidates.push({ path: resolved, manager: classify(resolved) });
   }
-  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 "ensureSession":
-        return await this.runtime.ensureSession({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name")
-        });
-      case "prompt":
-        return await this.runtime.prompt({
-          agent: requireString(params, "agent"),
-          agentCommand: asOptionalString(params.agentCommand),
-          cwd: requireString(params, "cwd"),
-          name: requireString(params, "name"),
-          text: requireString(params, "text")
-        }, (event) => {
-          if (event.type === "prompt.segment") {
-            writeLine?.(encodeBridgePromptSegmentEvent({
-              id: requestId,
-              event: "prompt.segment",
-              text: event.text
-            }));
-          }
-        });
-      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")
-        });
-      default:
-        throw new Error(`unsupported bridge method: ${method}`);
+  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 extractRequestId(line) {
+function isUnder(child, parent) {
+  const c = child.replace(/[\\/]+$/, "");
+  const p = parent.replace(/[\\/]+$/, "");
+  return c === p || c.startsWith(p + "/") || c.startsWith(p + "\\");
+}
+async function defaultFsExists(path) {
   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";
+    await access(path);
+    return true;
   } catch {
-    return "unknown";
+    return false;
   }
 }
-function parseBridgeRequest(line) {
-  let raw;
+function defaultResolveFromCwd(name, cwd) {
   try {
-    raw = JSON.parse(line);
+    const pkgJson = __require.resolve(`${name}/package.json`, {
+      paths: [cwd, ...__require.resolve.paths(name) ?? []]
+    });
+    return dirname(pkgJson);
   } catch {
-    throw new BridgeInvalidRequestError("request must be valid JSON");
+    return null;
   }
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new BridgeInvalidRequestError("request must be a JSON object");
+}
+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 init_discover_parent_package_paths = () => {};
+
+// src/process/terminate-process-tree.ts
+import { spawn as spawn2 } from "node:child_process";
+async function terminateProcessTree(pid, platform = process.platform, runCommand = defaultRunProcessCommand, killProcess = (targetPid, signal) => {
+  process.kill(targetPid, signal);
+}, isProcessRunning = defaultIsProcessRunning) {
+  if (pid <= 0) {
+    return;
   }
-  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 (platform === "win32") {
+    try {
+      await runCommand("taskkill", ["/PID", String(pid), "/T", "/F"]);
+    } catch {}
+    return;
   }
-  if (typeof method !== "string" || method.length === 0) {
-    throw new BridgeInvalidRequestError("method must be a non-empty string");
+  const targetPid = pid > 0 ? -pid : pid;
+  try {
+    killProcess(targetPid, "SIGTERM");
+  } catch {
+    return;
   }
-  if (!BRIDGE_METHODS.has(method)) {
-    throw new BridgeInvalidRequestError(`unsupported bridge method: ${method}`);
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(targetPid)) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
   }
-  if (!params || typeof params !== "object" || Array.isArray(params)) {
-    throw new BridgeInvalidRequestError("params must be an object");
+  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/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 {
-    id,
-    method,
-    params
+    name: "weacpx-orchestration",
+    type: "stdio",
+    command,
+    args: [
+      ...args,
+      "mcp-stdio",
+      "--coordinator-session",
+      input.coordinatorSession,
+      ...input.sourceHandle ? ["--source-handle", input.sourceHandle] : []
+    ]
   };
 }
-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 buildQueueOwnerPayload(input) {
+  return {
+    sessionId: input.sessionId,
+    permissionMode: input.permissionMode,
+    nonInteractivePermissions: input.nonInteractivePermissions,
+    ttlMs: input.ttlMs ?? 300000,
+    maxQueueDepth: input.maxQueueDepth ?? 16,
+    mcpServers: input.mcpServers
+  };
 }
-function requirePermissionMode(params, key) {
-  const value = params[key];
-  if (value === "approve-all" || value === "approve-reads" || value === "deny-all") {
-    return value;
+
+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)
+      }
+    });
   }
-  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;
+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;
   }
-  throw new BridgeInvalidRequestError(`${key} must be deny or fail`);
+  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 asOptionalString(value) {
-  if (typeof value !== "string" || value.length === 0) {
+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;
   }
-  return value;
+  if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+    await terminateProcessTree(owner.pid);
+  }
+  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 `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+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/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";
+}
+
+// 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_streaming_prompt();
 import { copyFile, readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { spawn } from "node:child_process";
+import { homedir as homedir3 } 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();
+class EnsureSessionFailedError extends Error {
+  kind;
+  data;
+  constructor(message, kind, data) {
+    super(message);
+    this.name = "EnsureSessionFailedError";
+    this.kind = kind;
+    this.data = data;
+  }
+}
 
 class BridgeRuntime {
   command;
@@ -473,12 +822,19 @@ class BridgeRuntime {
   runSessionCreate;
   options;
   runPromptCommand;
-  constructor(command = "acpx", run = defaultRunner, runSessionCreate = shellSessionCreateRunner, options = {}, runPromptCommand = defaultPromptRunner) {
+  repairSessionIndex;
+  queueOwnerLauncher;
+  acpxVerboseSupported = undefined;
+  constructor(command = "acpx", run = defaultRunner, runSessionCreate = shellSessionCreateRunner, options = {}, runPromptCommand = defaultPromptRunner, repairSessionIndex = tryRepairAcpxSessionIndex, queueOwnerLauncher = new AcpxQueueOwnerLauncher({
+    acpxCommand: command
+  })) {
     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;
@@ -494,46 +850,137 @@ class BridgeRuntime {
     const result = await this.run(spawnSpec.command, spawnSpec.args);
     return { exists: result.code === 0 };
   }
-  async ensureSession(input) {
-    const ensuredSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, [
-      "sessions",
-      "ensure",
-      "--name",
-      input.name
-    ]));
-    const ensured = await this.run(ensuredSpec.command, ensuredSpec.args);
+  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 {};
     }
-    const createSpec = resolveSpawnCommand(this.command, this.buildSessionArgs(input, ["sessions", "new", "--name", input.name]));
-    const created = await this.runSessionCreate(createSpec.command, createSpec.args, input.cwd);
+    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 tryRepairAcpxSessionIndex()) {
+    if (output.includes("EPERM") && await this.repairSessionIndex()) {
       const repaired = await this.run(existingSpec.command, existingSpec.args);
       if (repaired.code === 0) {
+        onProgress?.("ready");
         return {};
       }
     }
-    throw new Error(output || ensured.stderr || ensured.stdout || "failed to create session");
+    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 spawnSpec = resolveSpawnCommand(this.command, this.buildPromptArgs(input, [
       "prompt",
       "-s",
       input.name,
       input.text
     ]));
-    const result = onEvent ? await this.runPromptCommand(spawnSpec.command, spawnSpec.args, onEvent) : await this.run(spawnSpec.command, spawnSpec.args);
+    const formatToolCalls = input.replyMode === "verbose";
+    const result = onEvent ? await this.runPromptCommand(spawnSpec.command, spawnSpec.args, onEvent, { formatToolCalls }) : await this.run(spawnSpec.command, spawnSpec.args);
     return { text: getPromptText(result) };
   }
+  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",
@@ -562,10 +1009,25 @@ class BridgeRuntime {
       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) {
+  buildSessionArgs(input, tail, options = {}) {
     const prefix = [
       "--format",
       "quiet",
@@ -573,6 +1035,9 @@ class BridgeRuntime {
       input.cwd,
       ...this.buildPermissionArgs()
     ];
+    if (options.verbose) {
+      prefix.push("--verbose");
+    }
     if (input.agentCommand) {
       return [...prefix, "--agent", input.agentCommand, ...tail];
     }
@@ -595,29 +1060,47 @@ class BridgeRuntime {
   buildPermissionArgs() {
     const permissionMode = this.options.permissionMode ?? "approve-all";
     const nonInteractivePermissions = this.options.nonInteractivePermissions ?? "deny";
-    const modeFlag = permissionMode === "approve-reads" ? "--approve-reads" : permissionMode === "deny-all" ? "--deny-all" : "--approve-all";
+    const modeFlag = permissionModeToFlag(permissionMode);
     return [modeFlag, "--non-interactive-permissions", nonInteractivePermissions];
   }
 }
-async function defaultRunner(command, args) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+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) => {
-      stderr += String(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) => spawn(spawnCommand, spawnArgs, { stdio: ["ignore", "pipe", "pipe"] }));
+  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;
@@ -627,7 +1110,7 @@ async function runStreamingPrompt(command, args, onEvent, options = {}) {
     const child = spawnPrompt(command, args);
     let stdout = "";
     let stderr = "";
-    const state = createStreamingPromptState();
+    const state = createStreamingPromptState(options.formatToolCalls ?? false);
     let lastReplyAt = now();
     const flushBuffer = () => {
       const remaining = state.buffer.trim();
@@ -669,81 +1152,375 @@ async function runStreamingPrompt(command, args, onEvent, options = {}) {
     });
   });
 }
-async function defaultPromptRunner(command, args, onEvent) {
-  return await runStreamingPrompt(command, args, onEvent);
+async function defaultPromptRunner(command, args, onEvent, options) {
+  return await runStreamingPrompt(command, args, onEvent, options);
 }
-async function shellSessionCreateRunner(command, args, cwd) {
-  return await new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      resolve({ code: code ?? 1, stdout, stderr });
-    });
-  });
+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() {
-  if (process.platform !== "win32") {
+async function tryRepairAcpxSessionIndex(deps = {}) {
+  const platform = deps.platform ?? process.platform;
+  if (platform !== "win32") {
     return false;
   }
-  const home = process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+  const home = deps.home ?? process.env.HOME ?? process.env.USERPROFILE ?? homedir3();
   if (!home) {
     return false;
   }
-  const sessionsDir = join(home, ".acpx", "sessions");
-  const indexPath = join(sessionsDir, "index.json");
+  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 readdir(sessionsDir);
+    files = await readdirFn(sessionsDir);
   } catch {
     return false;
   }
-  const tmpFiles = files.filter((f) => f.startsWith("index.json.") && f.endsWith(".tmp"));
-  if (tmpFiles.length === 0) {
-    return false;
-  }
-  let latestTmp = "";
-  let latestTime = 0;
-  for (const f of tmpFiles) {
-    const match = f.match(/^index\.json\.\d+\.(\d+)\.tmp$/);
-    if (match && Number(match[1]) > latestTime) {
-      latestTime = Number(match[1]);
-      latestTmp = f;
-    }
-  }
+  const latestTmp = selectLatestAcpxSessionIndexTmp(files);
   if (!latestTmp) {
     return false;
   }
   try {
-    await copyFile(join(sessionsDir, latestTmp), indexPath);
+    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",
+  "prompt",
+  "setMode",
+  "cancel",
+  "removeSession"
+]);
+var SESSION_SCOPED_METHODS = new Set([
+  "hasSession",
+  "ensureSession",
+  "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 "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":
+        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: requireString(params, "text"),
+          replyMode: asOptionalReplyMode(params.replyMode)
+        }, (event) => {
+          if (event.type === "prompt.segment") {
+            writeLine?.(encodeBridgePromptSegmentEvent({
+              id: requestId,
+              event: "prompt.segment",
+              text: event.text
+            }));
+          }
+        });
+      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 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;
+}
+var VALID_REPLY_MODES = new Set(["stream", "final", "verbose"]);
+function asOptionalReplyMode(value) {
+  if (typeof value !== "string" || !VALID_REPLY_MODES.has(value)) {
+    return;
+  }
+  return value;
+}
 
 // src/bridge/bridge-main.ts
-var 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)
-}));
-var input = createInterface({
-  input: process.stdin,
-  crlfDelay: Infinity
-});
-for await (const line of input) {
-  const response = await server.handleLine(line, (chunk) => {
-    process.stdout.write(chunk);
+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)
+  }));
+  const input = createInterface({
+    input: process.stdin,
+    crlfDelay: Infinity
+  });
+  await processBridgeInput({
+    input,
+    server,
+    write: (chunk) => {
+      process.stdout.write(chunk);
+    }
   });
-  process.stdout.write(response);
 }
+if (__require.main == __require.module) {
+  await runBridgeMain();
+}
+export {
+  runBridgeMain,
+  processBridgeInput
+};