@minhspark/codex-mcp-bridge 1.13.9 → 1.15.1

package/src/index.mjs

@@ -4,6 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import path from "node:path";
 import { realpathSync } from "node:fs";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 import { CodexAppServerClient, writerLockWarning } from "./app-server-client.mjs";
 import {
@@ -26,10 +27,13 @@ import { DesktopTaskDelivery, DESKTOP_TOOL_BUDGET_MS } from "./thread-delivery.m
 import { desktopTasksConfigured } from "./native-relay.mjs";
 import { exitForVersionRequest } from "./cli-version.mjs";
 import { createRuntimeState } from "./runtime-state.mjs";
+import { assertRoutingReload, clientReloadReason, createReloadControl } from "./reload-control.mjs";
+import { accountIdentity, assertAccountIdentity, publicAccountState, readBridgeAccounts, requireBridgeAccounts } from "./bridge-account-context.mjs";
+import { assertClaudeSenderContext, readClaudeSenderContext, requireClaudeSenderContext } from "./claude-sender-context.mjs";
 
 exitForVersionRequest(import.meta.url);
 
-const VERSION = "1.13.9";
+const VERSION = "1.15.1";
 const log = (msg) => process.stderr.write(`[codex-mcp-bridge] ${msg}\n`);
 
 /**
@@ -50,13 +54,61 @@ const RELEASE_TURN_STATUSES = TERMINAL_TURN_STATUSES;
 const security = new BridgeSecurityPolicy();
 const desktopTasksEnabled = desktopTasksConfigured();
 const runtime = createRuntimeState({ configuration: desktopTasksConfigured });
-const desktopTasks = new DesktopTaskDelivery({ security });
+const desktopOperation = new AsyncLocalStorage();
+const desktopTasks = new DesktopTaskDelivery({ security, beforeRequest: beforeDesktopRequest, accountContext: () => desktopOperation.getStore()?.accounts });
+
+async function assertDesktopOperation(context, { verifyProcess = false } = {}) {
+  if (!context || context.diagnostic) return;
+  runtime.assertCurrent();
+  const accounts = readBridgeAccounts();
+  assertAccountIdentity(context.accounts, accounts);
+  await assertClaudeSenderContext(context.caller, {
+    account: accounts.claude,
+    ...(!verifyProcess ? { readAncestry: async () => context.caller.lineage } : {}),
+  });
+  assertAccountIdentity(context.accounts);
+}
+
+async function beforeDesktopRequest({ operation, args, phase }) {
+  const context = desktopOperation.getStore();
+  if (context?.diagnostic) return;
+  if (!context) throw new Error("Desktop operations require a verified calling Code session.");
+  const mutating = ["create_thread", "send_message_to_thread", "set_thread_title", "navigate_to_codex_page"].includes(operation);
+  await assertDesktopOperation(context, { verifyProcess: mutating && phase === "write" });
+  if (mutating) {
+    context.dispatched = true;
+    if (args.threadId) context.threadId = args.threadId;
+  }
+}
+
+function withheldDesktopResult(error, context) {
+  if (context.dispatched) reload.defer("A Desktop operation was dispatched without a fully verified outcome");
+  const reason = (error?.message ?? "The calling session or accounts could not be reverified.").replace(/\s*No message was sent\./g, "");
+  return {
+    ...textResult(`${reason} ${context.dispatched ? "A Desktop operation may already have been dispatched. Its original destination and any creation receipt were preserved." : "No Desktop mutation was dispatched."} Reply content was withheld. Inspect the original task and do not resend automatically.`, true),
+    structuredContent: { accountContext: context.accounts, operation: { state: context.dispatched ? "dispatched_outcome_unverified" : "blocked", threadId: context.threadId ?? null } },
+  };
+}
 
 const client = desktopTasksEnabled ? null : new CodexAppServerClient({
   clientInfo: { name: "codex-mcp-bridge", title: "Codex MCP Bridge", version: VERSION },
   log,
 });
 
+const reload = createReloadControl({
+  entry: "index.mjs",
+  inspect: () => desktopTasks.threadOperations.size ? "Desktop task operations are still active" : clientReloadReason(client),
+  quiesce: () => { client?.close(); },
+  exportState: () => ({ desktopTasksEnabled, ownedThreadIds: [...security.ownedThreadIds] }),
+  restore: (state) => {
+    assertRoutingReload(state.desktopTasksEnabled, desktopTasksEnabled);
+    if (!Array.isArray(state.ownedThreadIds)
+      || state.ownedThreadIds.some((id) => typeof id !== "string" || !id.trim())
+      || new Set(state.ownedThreadIds).size !== state.ownedThreadIds.length) throw new Error("Invalid or incompatible Codex worker reload state");
+    security.ownedThreadIds = new Set(state.ownedThreadIds);
+  },
+});
+
 const textResult = (text, isError = false) => ({
   content: [{ type: "text", text }],
   ...(isError ? { isError: true } : {}),
@@ -116,7 +168,7 @@ function threadNameFor({ cwd, prompt, name }) {
 }
 
 async function delegateDesktopTask({ cwd, prompt, name, model, effort, timeoutSec, openInApp, waitForReply = true }) {
-  const deadline = Date.now() + Math.min((timeoutSec ?? 40) * 1000, DESKTOP_TOOL_BUDGET_MS);
+  const deadline = desktopOperation.getStore()?.deadline ?? Date.now() + Math.min((timeoutSec ?? 40) * 1000, DESKTOP_TOOL_BUDGET_MS);
   const workspace = resolveWorkspacePath(cwd);
   const created = await desktopTasks.create({
     cwd: workspace.path, prompt, name: threadNameFor({ cwd: workspace.path, prompt, name }),
@@ -293,16 +345,39 @@ const server = new McpServer(
 function registerTool(name, definition, handler) {
   server.registerTool(name, definition, async (...args) => {
     try {
+      return await reload.run(async () => {
       if (!definition.annotations?.readOnlyHint) runtime.assertCurrent();
       if (name === "codex_bridge_status") {
         const state = runtime.status();
         if (!state.current) return { ...failure(new Error(`${state.reason}; reconnect this MCP server in the existing task.`)), structuredContent: { runtime: state } };
-        const result = await handler(...args);
+        const accounts = desktopTasksEnabled ? readBridgeAccounts() : null;
+        const result = await desktopOperation.run({ diagnostic: true, accounts: accountIdentity(accounts) }, () => handler(...args));
         result.content.push({ type: "text", text: `runtime pid: ${state.pid}\nloaded source: ${state.revision}\nruntime state: current` });
         result.structuredContent = { ...result.structuredContent, runtime: state };
+        if (desktopTasksEnabled) {
+          result.structuredContent.accounts = { claude: publicAccountState(accounts.claude), codex: publicAccountState(accounts.codex) };
+        }
         return result;
       }
+      if (desktopTasksEnabled) {
+        const deadline = Date.now() + Math.min((args[0]?.timeoutSec ?? 40) * 1000, DESKTOP_TOOL_BUDGET_MS);
+        const accounts = readBridgeAccounts();
+        const identity = requireBridgeAccounts(accounts);
+        const caller = requireClaudeSenderContext(await readClaudeSenderContext({ account: accounts.claude }));
+        const context = { accounts: identity, caller, dispatched: false, deadline };
+        return await desktopOperation.run(context, async () => {
+          try {
+            await assertDesktopOperation(context);
+            const result = await handler(...args);
+            await assertDesktopOperation(context);
+            return result;
+          } catch (error) {
+            return withheldDesktopResult(error, context);
+          }
+        });
+      }
       return await handler(...args);
+      });
     } catch (err) {
       return failure(err);
     }
@@ -406,7 +481,10 @@ registerTool(
     title: "Send a prompt to a Codex thread",
     description:
       "Send a prompt as a new user turn inside an existing Codex thread and wait for Codex to answer. " +
-      "The thread keeps its full history, cwd and model. Use list_codex_threads first if you do not know the threadId.",
+      "The thread keeps its full history, cwd and model. Use list_codex_threads first if you do not know the threadId. " +
+      "Desktop-owned tasks must use Desktop native delivery; an open task is a valid destination. " +
+      "If legacy delivery reports an active writer, inspect codex_bridge_status and repair the native relay/configuration. " +
+      "Do not close the task, create a replacement, or ask the user to copy the message manually.",
     inputSchema: {
       threadId: z.string().describe("Codex thread id (UUID) - get it from list_codex_threads"),
       prompt: z.string().describe("The message to send to Codex, exactly as a user would type it"),
@@ -441,7 +519,7 @@ registerTool(
     },
   },
   async ({ threadId, prompt, timeoutSec, cwd, model, effort, name, openInApp, releaseAfterTurn }) => {
-    const deadline = desktopTasksEnabled ? Date.now() + Math.min((timeoutSec ?? 40) * 1000, DESKTOP_TOOL_BUDGET_MS) : undefined;
+    const deadline = desktopTasksEnabled ? desktopOperation.getStore()?.deadline ?? Date.now() + Math.min((timeoutSec ?? 40) * 1000, DESKTOP_TOOL_BUDGET_MS) : undefined;
     return (desktopTasksEnabled ? desktopTasks : client).withThread(threadId, async () => {
       const notes = [];
       const shouldOpen = openInApp ?? DEFAULT_OPEN_IN_APP;
@@ -670,7 +748,7 @@ registerTool(
   async ({ threadId, limit }) => {
     try {
       if (desktopTasksEnabled) {
-        const deadline = Date.now() + DESKTOP_TOOL_BUDGET_MS;
+        const deadline = desktopOperation.getStore()?.deadline ?? Date.now() + DESKTOP_TOOL_BUDGET_MS;
         await desktopTasks.inspect(threadId, undefined, { deadline });
         const response = await desktopTasks.request("read_thread", { threadId, hostId: "local", turnLimit: Math.min(limit ?? 10, 10) }, { deadline });
         return textResult(JSON.stringify(response, null, 2));
@@ -758,9 +836,12 @@ registerTool(
   async ({ threadId, background }) => {
     try {
       if (desktopTasksEnabled) {
-        const deadline = Date.now() + DESKTOP_TOOL_BUDGET_MS;
+        const deadline = desktopOperation.getStore()?.deadline ?? Date.now() + DESKTOP_TOOL_BUDGET_MS;
         await desktopTasks.inspect(threadId, undefined, { deadline });
-        if (background) await openThreadInCodexApp(threadId, { activate: false });
+        if (background) {
+          await beforeDesktopRequest({ operation: "navigate_to_codex_page", args: { threadId }, phase: "write" });
+          await openThreadInCodexApp(threadId, { activate: false });
+        }
         else await desktopTasks.open(threadId, { deadline });
         return textResult(`Opened ${codexThreadUrl(threadId)} in Codex Desktop.`);
       }
@@ -894,4 +975,5 @@ registerTool(
 
 const transport = new StdioServerTransport();
 await server.connect(transport);
+reload.listen();
 log(desktopTasksEnabled ? `ready on ${PLATFORM_LABEL} (Codex Desktop only; external app-server disabled)` : `ready on ${PLATFORM_LABEL} (app-server endpoint: ${client.url}, codex: ${client.codexBin})`);

package/src/mcp-supervisor.mjs

@@ -0,0 +1,326 @@
+#!/usr/bin/env node
+import { fork } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createReleaseSnapshot, sourceRevision } from "./release-snapshot.mjs";
+import { desktopTasksConfigured } from "./native-relay.mjs";
+
+const ENTRIES = new Set(["index.mjs", "claude-bridge.mjs", "native-relay-companion.mjs"]);
+const MAX_FRAME_BYTES = 16 * 1024 * 1024;
+const MAX_QUEUE = 256;
+const hasId = (message) => Object.hasOwn(message, "id");
+const idKey = (id) => JSON.stringify(id);
+const errorMessage = (id, message) => ({ jsonrpc: "2.0", id, error: { code: -32603, message } });
+
+function lines(stream, receive, failed) {
+  let buffer = Buffer.alloc(0);
+  stream.on("data", (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    if (buffer.length > MAX_FRAME_BYTES) { failed(new Error("MCP frame exceeds the buffer limit")); return; }
+    let index;
+    while ((index = buffer.indexOf(10)) !== -1) {
+      const frame = buffer.subarray(0, index).toString("utf8").trim();
+      buffer = buffer.subarray(index + 1);
+      if (!frame) continue;
+      try { receive(JSON.parse(frame)); }
+      catch (error) { failed(error); }
+    }
+  });
+}
+
+class Worker {
+  constructor(release, entry, env, handlers) {
+    this.release = release;
+    this.handlers = handlers;
+    this.rpcPending = new Map();
+    this.controlPending = new Map();
+    this.clientPending = new Map();
+    this.sequence = 0;
+    this.retiring = false;
+    this.closed = false;
+    this.process = fork(path.join(release.directory, "src", entry), [], {
+      execPath: process.execPath, execArgv: [], cwd: process.cwd(), windowsHide: true,
+      env: { ...env, CODEX_BRIDGE_WORKER: "1", CODEX_BRIDGE_STAGED: "1" },
+      stdio: ["pipe", "pipe", "pipe", "ipc"], serialization: "json",
+    });
+    this.process.stderr.on("data", (data) => process.stderr.write(data));
+    this.process.stdin.on("error", (error) => this.fail(error));
+    this.process.on("error", (error) => this.fail(error));
+    this.process.on("exit", (code, signal) => this.fail(new Error(`Bridge worker exited (${signal ?? code})`)));
+    this.process.on("message", (message) => {
+      if (message?.type !== "bridge:control-result") return;
+      const pending = this.controlPending.get(message.id);
+      if (!pending) return;
+      this.controlPending.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error) pending.reject(new Error(message.error));
+      else pending.resolve(message.result);
+    });
+    lines(this.process.stdout, (message) => {
+      if (!message || message.jsonrpc !== "2.0") throw new Error("Invalid worker JSON-RPC message");
+      if (!message.method && hasId(message) && this.rpcPending.has(message.id)) {
+        const pending = this.rpcPending.get(message.id);
+        this.rpcPending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (message.error) pending.reject(new Error(message.error.message));
+        else pending.resolve(message.result);
+      } else handlers.message(this, message);
+    }, (error) => this.fail(error));
+  }
+
+  write(message) {
+    if (this.closed) throw new Error("The bridge worker is unavailable");
+    this.process.stdin.write(`${JSON.stringify(message)}\n`);
+  }
+
+  rpc(method, params, timeout = 15000) {
+    const id = `supervisor:${++this.sequence}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { this.rpcPending.delete(id); reject(new Error(`Candidate ${method} timed out`)); }, timeout);
+      this.rpcPending.set(id, { resolve, reject, timer });
+      this.write({ jsonrpc: "2.0", id, method, ...(params === undefined ? {} : { params }) });
+    });
+  }
+
+  control(action, data, timeout = 15000) {
+    const id = ++this.sequence;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => { this.controlPending.delete(id); reject(new Error(`Worker ${action} timed out`)); }, timeout);
+      this.controlPending.set(id, { resolve, reject, timer });
+      this.process.send({ type: "bridge:control", id, action, data }, (error) => {
+        if (!error) return;
+        const pending = this.controlPending.get(id);
+        if (pending) { clearTimeout(timer); this.controlPending.delete(id); reject(error); }
+      });
+    });
+  }
+
+  fail(error) {
+    if (this.closed) return;
+    this.closed = true;
+    for (const pending of [...this.rpcPending.values(), ...this.controlPending.values()]) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.rpcPending.clear();
+    this.controlPending.clear();
+    this.handlers.exit(this, error);
+  }
+
+  async stop() {
+    this.retiring = true;
+    if (this.process.exitCode !== null || this.process.signalCode) return;
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => { this.process.kill(); resolve(); }, 1000);
+      this.process.once("exit", () => { clearTimeout(timer); resolve(); });
+      this.process.stdin.end();
+      if (this.process.connected) this.process.disconnect();
+    });
+  }
+}
+
+export async function runSupervisor(entry, options = {}) {
+  if (!ENTRIES.has(entry)) throw new Error("Expected index.mjs, claude-bridge.mjs, or native-relay-companion.mjs");
+  const root = fs.realpathSync.native(options.root ?? path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."));
+  if (process.argv.includes("--version") || process.argv.includes("-v")) {
+    process.stdout.write(`${JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).version}\n`);
+    return;
+  }
+  const log = (message) => process.stderr.write(`[bridge-supervisor] ${message}\n`);
+  const output = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+  const env = { ...process.env, CODEX_BRIDGE_SOURCE_ROOT: root };
+  const routingConfiguration = () => entry === "native-relay-companion.mjs" ? null : desktopTasksConfigured(env);
+  if (entry === "native-relay-companion.mjs" && !env.CODEX_APP_TOOLS_PIPE_PATH) {
+    const { resolveNativeToolsPipePath } = await import("./native-relay.mjs");
+    const pipe = await resolveNativeToolsPipePath();
+    if (pipe) env.CODEX_APP_TOOLS_PIPE_PATH = pipe;
+  }
+  const pollMs = Math.max(100, Number(env.CODEX_BRIDGE_RELOAD_POLL_MS) || 1000);
+  const settleMs = Math.max(100, Number(env.CODEX_BRIDGE_RELOAD_SETTLE_MS) || 1500);
+  let active;
+  let initializeParams;
+  let initializeResult;
+  let ready = false;
+  let switching = false;
+  let stopping = false;
+  let failure = null;
+  let sequence = 0;
+  let observed = null;
+  let observedRouting = null;
+  let observedAt = 0;
+  let retryAt = 0;
+  let reason = null;
+  let reloads = 0;
+  const queue = [];
+  const requests = new Map();
+  const reverse = new Map();
+  const workers = new Set();
+  const diagnostics = () => ({ enabled: true, supervisorPid: process.pid, workerPid: active?.process.pid ?? null,
+    revision: active?.release.revision ?? null, availableRevision: observed,
+    routingConfiguration: active?.routingConfiguration ?? null, availableRoutingConfiguration: observedRouting,
+    pending: Boolean(observed && (observed !== active?.release.revision || observedRouting !== active?.routingConfiguration)),
+    state: failure ? "failed" : switching ? "reloading" : reason ? "deferred" : "current", reason: failure ?? reason, reloads });
+
+  const handlers = {
+    message(worker, message) {
+      if (message.method && hasId(message)) {
+        const id = `bridge-server:${++sequence}`;
+        reverse.set(idKey(id), { worker, id: message.id });
+        output({ ...message, id });
+        return;
+      }
+      if (message.method) {
+        if (worker === active) output(message);
+        return;
+      }
+      const pending = worker.clientPending.get(message.id);
+      if (!pending) return;
+      worker.clientPending.delete(message.id);
+      requests.delete(idKey(pending.id));
+      const respond = async () => {
+        if (pending.method === "initialize" && !message.error) {
+          initializeResult = message.result;
+          await worker.control("activate");
+          ready = true;
+        }
+        if (message.result && ["codex_bridge_status", "claude_bridge_status", "native_relay_status"].includes(pending.tool)) {
+          message.result.structuredContent = { ...message.result.structuredContent, autoReload: diagnostics() };
+          message.result.content = [...(message.result.content ?? []), { type: "text", text: `automatic reload: ${diagnostics().state}\nsupervisor pid: ${process.pid}\nworker pid: ${worker.process.pid}\nreload count: ${reloads}${reason ? `\nreload detail: ${reason}` : ""}` }];
+        }
+        output({ ...message, id: pending.id });
+      };
+      void respond().catch((error) => { failure = error.message; output(errorMessage(pending.id, error.message)); });
+    },
+    exit(worker, error) {
+      for (const [id, pending] of worker.clientPending) {
+        requests.delete(idKey(pending.id));
+        output(errorMessage(pending.id, `${error.message}. The operation may already have been dispatched; it was not retried. Retain the original task and receipts.`));
+        worker.clientPending.delete(id);
+      }
+      for (const [id, pending] of reverse) if (pending.worker === worker) reverse.delete(id);
+      if (worker === active && !worker.retiring && !stopping) { failure = `${error.message}; automatic replay is disabled because delivery state may be unknown`; log(failure); }
+    },
+  };
+  const spawn = (release, routing) => {
+    if (stopping) throw new Error("The MCP client disconnected before activation");
+    const worker = new Worker(release, entry, env, handlers);
+    worker.routingConfiguration = routing;
+    workers.add(worker);
+    return worker;
+  };
+  const check = async () => {
+    if (switching || !ready || stopping || failure) return;
+    let revision;
+    let routing;
+    try { revision = sourceRevision(root); routing = routingConfiguration(); }
+    catch (error) { reason = `Installation is not ready: ${error.message}`; return; }
+    if (observed !== revision || observedRouting !== routing) { observed = revision; observedRouting = routing; observedAt = Date.now(); retryAt = 0; }
+    if (revision === active.release.revision && routing === active.routingConfiguration) { reason = null; return; }
+    if (Date.now() - observedAt < settleMs || Date.now() < retryAt) { reason ??= "Waiting for a complete, stable installation"; return; }
+    if (active.clientPending.size || reverse.size) { reason = "A request is still running; its worker is retained"; return; }
+    switching = true;
+    let candidate;
+    let quiesced = false;
+    const previous = active;
+    try {
+      const state = await previous.control("inspect");
+      if (!state.reloadable) { reason = state.reason ?? "Pending deliveries prevent a safe reload"; return; }
+      const release = createReleaseSnapshot(root, { expectedRevision: revision });
+      candidate = spawn(release, routing);
+      const initialized = await candidate.rpc("initialize", initializeParams);
+      if (initialized.protocolVersion !== initializeResult.protocolVersion || JSON.stringify(initialized.capabilities) !== JSON.stringify(initializeResult.capabilities)) {
+        throw new Error("The new MCP protocol or capabilities require an explicit client reconnect");
+      }
+      candidate.write({ jsonrpc: "2.0", method: "notifications/initialized" });
+      const catalog = await candidate.rpc("tools/list", {});
+      if (!Array.isArray(catalog.tools) || !catalog.tools.length || catalog.nextCursor) throw new Error("The candidate tool catalog is incomplete");
+      const oldCatalog = await previous.rpc("tools/list", {});
+      if (sourceRevision(root) !== revision) throw new Error("The installation changed before activation");
+      if (routingConfiguration() !== routing) throw new Error("The routing configuration changed before activation");
+      quiesced = true;
+      const exported = await previous.control("quiesce");
+      await candidate.control("restore", exported.state);
+      await candidate.control("activate");
+      if (stopping) throw new Error("The MCP client disconnected during activation");
+      active = candidate;
+      candidate = null;
+      reloads++;
+      reason = null;
+      if (JSON.stringify(catalog) !== JSON.stringify(oldCatalog)) output({ jsonrpc: "2.0", method: "notifications/tools/list_changed" });
+      await previous.stop();
+      workers.delete(previous);
+      log(`activated ${entry} revision ${revision.slice(0, 12)}; client connection retained`);
+    } catch (error) {
+      reason = `Update deferred: ${error.message}`;
+      retryAt = Date.now() + Math.max(pollMs, 5000);
+      if (candidate) { await candidate.stop(); workers.delete(candidate); }
+      if (quiesced && active === previous && !previous.closed) {
+        try { await previous.control("resume"); }
+        catch (resumeError) { failure = `Previous runtime could not resume: ${resumeError.message}`; }
+      }
+      log(reason);
+    } finally {
+      switching = false;
+      for (const message of queue.splice(0)) dispatch(message);
+    }
+  };
+  const dispatch = (message) => {
+    if (stopping) return;
+    if (!message.method && hasId(message)) {
+      const pending = reverse.get(idKey(message.id));
+      if (pending) { reverse.delete(idKey(message.id)); pending.worker.write({ ...message, id: pending.id }); }
+      return;
+    }
+    if (message.method === "notifications/cancelled") {
+      const pending = requests.get(idKey(message.params?.requestId));
+      if (pending) pending.worker.write({ ...message, params: { ...message.params, requestId: pending.workerId } });
+      else {
+        const index = queue.findIndex((queued) => hasId(queued) && idKey(queued.id) === idKey(message.params?.requestId));
+        if (index !== -1) { const [cancelled] = queue.splice(index, 1); output({ jsonrpc: "2.0", id: cancelled.id, error: { code: -32800, message: "Request cancelled before dispatch" } }); }
+      }
+      return;
+    }
+    if (failure) { if (hasId(message)) output(errorMessage(message.id, failure)); return; }
+    if (switching || !active) {
+      const bytes = queue.reduce((size, queued) => size + Buffer.byteLength(JSON.stringify(queued)), 0);
+      if (queue.length >= MAX_QUEUE || bytes + Buffer.byteLength(JSON.stringify(message)) > MAX_FRAME_BYTES) { if (hasId(message)) output(errorMessage(message.id, "Reload request queue is full; no operation was dispatched")); return; }
+      queue.push(message);
+      return;
+    }
+    if (message.method === "initialize") initializeParams = message.params;
+    if (hasId(message)) {
+      if (requests.has(idKey(message.id))) { output(errorMessage(message.id, "Duplicate active JSON-RPC request ID")); return; }
+      const id = `client:${++sequence}`;
+      active.clientPending.set(id, { id: message.id, method: message.method, tool: message.params?.name });
+      requests.set(idKey(message.id), { worker: active, workerId: id });
+      active.write({ ...message, id });
+    } else active.write(message);
+  };
+  const shutdown = async () => {
+    if (stopping) return;
+    stopping = true;
+    clearInterval(timer);
+    await Promise.allSettled([...workers].map((worker) => worker.stop()));
+    process.stdin.pause();
+  };
+  const preparationStarted = performance.now();
+  log(`preparing ${entry} runtime`);
+  const initial = createReleaseSnapshot(root);
+  log(`prepared ${entry} runtime in ${Math.round(performance.now() - preparationStarted)} ms`);
+  observed = initial.revision;
+  observedRouting = routingConfiguration();
+  active = spawn(initial, observedRouting);
+  const timer = setInterval(() => { void check(); }, pollMs);
+  lines(process.stdin, (message) => {
+    if (!message || message.jsonrpc !== "2.0" || (!message.method && !hasId(message))) throw new Error("Invalid client JSON-RPC message");
+    dispatch(message);
+  }, (error) => { log(error.message); void shutdown(); });
+  process.stdin.on("end", () => { void shutdown(); });
+  for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => { void shutdown(); });
+  log(`supervising ${entry}; installed updates activate after pending work completes`);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await runSupervisor(process.argv[2]);
+}